src/palmos/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/palmos/windows.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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "window.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/window.h"
  33     #include "wx/accel.h"
  34     #include "wx/setup.h"
  35     #include "wx/menu.h"
  36     #include "wx/dc.h"
  37     #include "wx/dcclient.h"
  38     #include "wx/dcmemory.h"
  39     #include "wx/utils.h"
  40     #include "wx/app.h"
  41     #include "wx/layout.h"
  42     #include "wx/dialog.h"
  43     #include "wx/frame.h"
  44     #include "wx/listbox.h"
  45     #include "wx/button.h"
  46     #include "wx/msgdlg.h"
  47     #include "wx/settings.h"
  48     #include "wx/statbox.h"
  49 #endif
  50
  51 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
  52     #include "wx/ownerdrw.h"
  53 #endif
  54
  55 #include "wx/module.h"
  56
  57 #if wxUSE_DRAG_AND_DROP
  58     #include "wx/dnd.h"
  59 #endif
  60
  61 #if wxUSE_ACCESSIBILITY
  62     #include "wx/access.h"
  63 #endif
  64
  65 #include "wx/menuitem.h"
  66 #include "wx/log.h"
  67
  68 #if wxUSE_TOOLTIPS
  69     #include "wx/tooltip.h"
  70 #endif
  71
  72 #if wxUSE_CARET
  73     #include "wx/caret.h"
  74 #endif // wxUSE_CARET
  75
  76 #if wxUSE_SPINCTRL
  77     #include "wx/spinctrl.h"
  78 #endif // wxUSE_SPINCTRL
  79
  80 #include "wx/intl.h"
  81 #include "wx/log.h"
  82
  83 #include "wx/textctrl.h"
  84 #include "wx/notebook.h"
  85 #include "wx/listctrl.h"
  86 #include "wx/window.h"
  87
  88 // ---------------------------------------------------------------------------
  89 // global variables
  90 // ---------------------------------------------------------------------------
  91
  92 #if wxUSE_MENUS_NATIVE
  93 wxMenu *wxCurrentPopupMenu = NULL;
  94 #endif // wxUSE_MENUS_NATIVE
  95
  96 // true if we had already created the std colour map, used by
  97 // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
  98 static bool gs_hasStdCmap = false;
  99
 100 // ---------------------------------------------------------------------------
 101 // private functions
 102 // ---------------------------------------------------------------------------
 103
 104 // ---------------------------------------------------------------------------
 105 // event tables
 106 // ---------------------------------------------------------------------------
 107
 108 // in wxUniv/Palm this class is abstract because it doesn't have DoPopupMenu()
 109 // method
 110 #ifdef __WXUNIVERSAL__
 111     IMPLEMENT_ABSTRACT_CLASS(wxWindowPalm, wxWindowBase)
 112 #else // __WXPalm__
 113 #if wxUSE_EXTENDED_RTTI
 114
 115 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
 116 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
 117 // windows with negative ids never can be recreated anyway
 118
 119 bool wxWindowStreamingCallback( const wxObject *object, wxWriter * , wxPersister * , wxxVariantArray & )
 120 {
 121     return false;
 122 }
 123
 124 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow, wxWindowBase,"wx/window.h", wxWindowStreamingCallback)
 125
 126 // make wxWindowList known before the property is used
 127
 128 wxCOLLECTION_TYPE_INFO( wxWindow* , wxWindowList ) ;
 129
 130 template<> void wxCollectionToVariantArray( wxWindowList const &theList, wxxVariantArray &value)
 131 {
 132     wxListCollectionToVariantArray<wxWindowList::compatibility_iterator>( theList , value ) ;
 133 }
 134
 135 WX_DEFINE_FLAGS( wxWindowStyle )
 136
 137 wxBEGIN_FLAGS( wxWindowStyle )
 138     // new style border flags, we put them first to
 139     // use them for streaming out
 140
 141     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 142     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 143     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 144     wxFLAGS_MEMBER(wxBORDER_RAISED)
 145     wxFLAGS_MEMBER(wxBORDER_STATIC)
 146     wxFLAGS_MEMBER(wxBORDER_NONE)
 147
 148     // old style border flags
 149     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 150     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 151     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 152     wxFLAGS_MEMBER(wxRAISED_BORDER)
 153     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 154     wxFLAGS_MEMBER(wxBORDER)
 155
 156     // standard window styles
 157     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 158     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 159     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 160     wxFLAGS_MEMBER(wxWANTS_CHARS)
 161     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 162     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 163     wxFLAGS_MEMBER(wxVSCROLL)
 164     wxFLAGS_MEMBER(wxHSCROLL)
 165
 166 wxEND_FLAGS( wxWindowStyle )
 167
 168 wxBEGIN_PROPERTIES_TABLE(wxWindow)
 169     wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
 170     wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
 171     wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
 172     // Always constructor Properties first
 173
 174     wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 175     wxPROPERTY( Id,wxWindowID, SetId, GetId, wxID_ANY, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 176     wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxDefaultPosition , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
 177     wxPROPERTY( Size,wxSize, SetSize, GetSize, wxDefaultSize , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
 178     wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 179
 180     // Then all relations of the object graph
 181
 182     wxREADONLY_PROPERTY_COLLECTION( Children , wxWindowList , wxWindowBase* , GetWindowChildren , wxPROP_OBJECT_GRAPH /*flags*/ , wxT("Helpstring") , wxT("group"))
 183
 184    // and finally all other properties
 185
 186     wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
 187     wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
 188     wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
 189     wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 190     wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 191 #if 0
 192     // possible property candidates (not in xrc) or not valid in all subclasses
 193     wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
 194     wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
 195     wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
 196     // MaxHeight, Width , MinHeight , Width
 197     // TODO switch label to control and title to toplevels
 198
 199     wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
 200     //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
 201     // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
 202     wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
 203
 204
 205
 206 #endif
 207 wxEND_PROPERTIES_TABLE()
 208
 209 wxBEGIN_HANDLERS_TABLE(wxWindow)
 210 wxEND_HANDLERS_TABLE()
 211
 212 wxCONSTRUCTOR_DUMMY(wxWindow)
 213
 214 #else
 215     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 216 #endif
 217 #endif // __WXUNIVERSAL__/__WXPalm__
 218
 219 BEGIN_EVENT_TABLE(wxWindowPalm, wxWindowBase)
 220     EVT_ERASE_BACKGROUND(wxWindowPalm::OnEraseBackground)
 221     EVT_SYS_COLOUR_CHANGED(wxWindowPalm::OnSysColourChanged)
 222     EVT_INIT_DIALOG(wxWindowPalm::OnInitDialog)
 223 END_EVENT_TABLE()
 224
 225 // ===========================================================================
 226 // implementation
 227 // ===========================================================================
 228
 229 // ---------------------------------------------------------------------------
 230 // wxWindow utility functions
 231 // ---------------------------------------------------------------------------
 232
 233 // Find an item given the MS Windows id
 234 wxWindow *wxWindowPalm::FindItem(long id) const
 235 {
 236     return NULL;
 237 }
 238
 239 // Find an item given the MS Windows handle
 240 wxWindow *wxWindowPalm::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
 241 {
 242     return NULL;
 243 }
 244
 245 // Default command handler
 246 bool wxWindowPalm::PalmCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 247 {
 248     return false;
 249 }
 250
 251 // ----------------------------------------------------------------------------
 252 // constructors and such
 253 // ----------------------------------------------------------------------------
 254
 255 void wxWindowPalm::Init()
 256 {
 257 }
 258
 259 // Destructor
 260 wxWindowPalm::~wxWindowPalm()
 261 {
 262 }
 263
 264 // real construction (Init() must have been called before!)
 265 bool wxWindowPalm::Create(wxWindow *parent,
 266                          wxWindowID id,
 267                          const wxPoint& pos,
 268                          const wxSize& size,
 269                          long style,
 270                          const wxString& name)
 271 {
 272     wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 273
 274     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 275         return false;
 276
 277     parent->AddChild(this);
 278
 279     InheritAttributes();
 280
 281     return true;
 282 }
 283
 284 FormType *wxWindowPalm::GetFormPtr()
 285 {
 286     return FrameForm;
 287 }
 288 void wxWindowPalm::SetFormPtr(FormType *FormPtr)
 289 {
 290     FrameForm=FormPtr;
 291 }
 292
 293 // ---------------------------------------------------------------------------
 294 // basic operations
 295 // ---------------------------------------------------------------------------
 296
 297 void wxWindowPalm::SetFocus()
 298 {
 299 }
 300
 301 void wxWindowPalm::SetFocusFromKbd()
 302 {
 303 }
 304
 305 // Get the window with the focus
 306 wxWindow *wxWindowBase::DoFindFocus()
 307 {
 308     return NULL;
 309 }
 310
 311 bool wxWindowPalm::Enable(bool enable)
 312 {
 313     return false;
 314 }
 315
 316 bool wxWindowPalm::Show(bool show)
 317 {
 318     return false;
 319 }
 320
 321 // Raise the window to the top of the Z order
 322 void wxWindowPalm::Raise()
 323 {
 324 }
 325
 326 // Lower the window to the bottom of the Z order
 327 void wxWindowPalm::Lower()
 328 {
 329 }
 330
 331 void wxWindowPalm::SetTitle( const wxString& title)
 332 {
 333 }
 334
 335 wxString wxWindowPalm::GetTitle() const
 336 {
 337     return wxEmptyString;
 338 }
 339
 340 void wxWindowPalm::DoCaptureMouse()
 341 {
 342 }
 343
 344 void wxWindowPalm::DoReleaseMouse()
 345 {
 346 }
 347
 348 /* static */ wxWindow *wxWindowBase::GetCapture()
 349 {
 350     return NULL;
 351 }
 352
 353 bool wxWindowPalm::SetFont(const wxFont& font)
 354 {
 355     return false;
 356 }
 357 bool wxWindowPalm::SetCursor(const wxCursor& cursor)
 358 {
 359     return false;
 360 }
 361
 362 void wxWindowPalm::WarpPointer (int x, int y)
 363 {
 364 }
 365
 366 // ---------------------------------------------------------------------------
 367 // scrolling stuff
 368 // ---------------------------------------------------------------------------
 369
 370 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
 371 static inline int wxDirToWinStyle(int orient)
 372 {
 373     return 0;
 374 }
 375
 376 int wxWindowPalm::GetScrollPos(int orient) const
 377 {
 378     return 0;
 379 }
 380
 381 // This now returns the whole range, not just the number
 382 // of positions that we can scroll.
 383 int wxWindowPalm::GetScrollRange(int orient) const
 384 {
 385     return 0;
 386 }
 387
 388 int wxWindowPalm::GetScrollThumb(int orient) const
 389 {
 390     return 0;
 391 }
 392
 393 void wxWindowPalm::SetScrollPos(int orient, int pos, bool refresh)
 394 {
 395 }
 396
 397 // New function that will replace some of the above.
 398 void wxWindowPalm::SetScrollbar(int orient,
 399                                int pos,
 400                                int pageSize,
 401                                int range,
 402                                bool refresh)
 403 {
 404 }
 405
 406 void wxWindowPalm::ScrollWindow(int dx, int dy, const wxRect *prect)
 407 {
 408 }
 409
 410 bool wxWindowPalm::ScrollLines(int lines)
 411 {
 412     return false;
 413 }
 414
 415 bool wxWindowPalm::ScrollPages(int pages)
 416 {
 417     return false;
 418 }
 419
 420 // ---------------------------------------------------------------------------
 421 // subclassing
 422 // ---------------------------------------------------------------------------
 423
 424 void wxWindowPalm::SubclassWin(WXHWND hWnd)
 425 {
 426 }
 427
 428 void wxWindowPalm::UnsubclassWin()
 429 {
 430 }
 431
 432 bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
 433 {
 434     return false;
 435 }
 436
 437 // ----------------------------------------------------------------------------
 438 // Style handling
 439 // ----------------------------------------------------------------------------
 440
 441 void wxWindowPalm::SetWindowStyleFlag(long flags)
 442 {
 443 }
 444
 445 WXDWORD wxWindowPalm::PalmGetStyle(long flags, WXDWORD *exstyle) const
 446 {
 447     return 0;
 448 }
 449
 450 // Setup background and foreground colours correctly
 451 void wxWindowPalm::SetupColours()
 452 {
 453 }
 454
 455 bool wxWindowPalm::IsMouseInWindow() const
 456 {
 457     return false;
 458 }
 459
 460 void wxWindowPalm::OnInternalIdle()
 461 {
 462 }
 463
 464 // Set this window to be the child of 'parent'.
 465 bool wxWindowPalm::Reparent(wxWindowBase *parent)
 466 {
 467     return false;
 468 }
 469
 470 void wxWindowPalm::Freeze()
 471 {
 472 }
 473
 474 void wxWindowPalm::Thaw()
 475 {
 476 }
 477
 478 void wxWindowPalm::Refresh(bool eraseBack, const wxRect *rect)
 479 {
 480 }
 481
 482 void wxWindowPalm::Update()
 483 {
 484 }
 485
 486 // ---------------------------------------------------------------------------
 487 // drag and drop
 488 // ---------------------------------------------------------------------------
 489
 490
 491 #if wxUSE_DRAG_AND_DROP
 492 void wxWindowPalm::SetDropTarget(wxDropTarget *pDropTarget)
 493 {
 494 }
 495 #endif // wxUSE_DRAG_AND_DROP
 496
 497 // old style file-manager drag&drop support: we retain the old-style
 498 // DragAcceptFiles in parallel with SetDropTarget.
 499 void wxWindowPalm::DragAcceptFiles(bool accept)
 500 {
 501 }
 502
 503 // ----------------------------------------------------------------------------
 504 // tooltips
 505 // ----------------------------------------------------------------------------
 506
 507 #if wxUSE_TOOLTIPS
 508
 509 void wxWindowPalm::DoSetToolTip(wxToolTip *tooltip)
 510 {
 511 }
 512
 513 #endif // wxUSE_TOOLTIPS
 514
 515 // ---------------------------------------------------------------------------
 516 // moving and resizing
 517 // ---------------------------------------------------------------------------
 518
 519 // Get total size
 520 void wxWindowPalm::DoGetSize(int *x, int *y) const
 521 {
 522 }
 523
 524 // Get size *available for subwindows* i.e. excluding menu bar etc.
 525 void wxWindowPalm::DoGetClientSize(int *x, int *y) const
 526 {
 527 }
 528
 529 void wxWindowPalm::DoGetPosition(int *x, int *y) const
 530 {
 531 }
 532
 533 void wxWindowPalm::DoScreenToClient(int *x, int *y) const
 534 {
 535 }
 536
 537 void wxWindowPalm::DoClientToScreen(int *x, int *y) const
 538 {
 539 }
 540
 541 void wxWindowPalm::DoMoveWindow(int x, int y, int width, int height)
 542 {
 543 }
 544
 545 // set the size of the window: if the dimensions are positive, just use them,
 546 // but if any of them is equal to -1, it means that we must find the value for
 547 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
 548 // which case -1 is a valid value for x and y)
 549 //
 550 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 551 // the width/height to best suit our contents, otherwise we reuse the current
 552 // width/height
 553 void wxWindowPalm::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 554 {
 555 }
 556
 557 void wxWindowPalm::DoSetClientSize(int width, int height)
 558 {
 559 }
 560
 561 // ---------------------------------------------------------------------------
 562 // text metrics
 563 // ---------------------------------------------------------------------------
 564
 565 int wxWindowPalm::GetCharHeight() const
 566 {
 567     return 0;
 568 }
 569
 570 int wxWindowPalm::GetCharWidth() const
 571 {
 572     return 0;
 573 }
 574
 575 void wxWindowPalm::GetTextExtent(const wxString& string,
 576                              int *x, int *y,
 577                              int *descent, int *externalLeading,
 578                              const wxFont *theFont) const
 579 {
 580 }
 581
 582 // ---------------------------------------------------------------------------
 583 // popup menu
 584 // ---------------------------------------------------------------------------
 585
 586 #if wxUSE_MENUS_NATIVE
 587
 588 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
 589 // immediately, without waiting for the next event loop iteration
 590 //
 591 // NB: this function should probably be made public later as it can almost
 592 //     surely replace wxYield() elsewhere as well
 593 static void wxYieldForCommandsOnly()
 594 {
 595 }
 596
 597 bool wxWindowPalm::DoPopupMenu(wxMenu *menu, int x, int y)
 598 {
 599     return false;
 600 }
 601
 602 #endif // wxUSE_MENUS_NATIVE
 603
 604 // ===========================================================================
 605 // pre/post message processing
 606 // ===========================================================================
 607
 608 WXLRESULT wxWindowPalm::PalmDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 609 {
 610     return false;
 611 }
 612
 613 bool wxWindowPalm::PalmProcessMessage(WXMSG* pMsg)
 614 {
 615     return false;
 616 }
 617
 618 bool wxWindowPalm::PalmTranslateMessage(WXMSG* pMsg)
 619 {
 620     return false;
 621 }
 622
 623 bool wxWindowPalm::PalmShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
 624 {
 625     return false;
 626 }
 627
 628 // ---------------------------------------------------------------------------
 629 // Main wxWidgets window proc and the window proc for wxWindow
 630 // ---------------------------------------------------------------------------
 631
 632 // Hook for new window just as it's being created, when the window isn't yet
 633 // associated with the handle
 634
 635 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
 636 // window being created and insures that it's always unset back later
 637 wxWindowCreationHook::wxWindowCreationHook(wxWindowPalm *winBeingCreated)
 638 {
 639 }
 640
 641 wxWindowCreationHook::~wxWindowCreationHook()
 642 {
 643 }
 644
 645 WXLRESULT wxWindowPalm::PalmWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 646 {
 647     return false;
 648 }
 649
 650 // ----------------------------------------------------------------------------
 651 // wxWindow <-> HWND map
 652 // ----------------------------------------------------------------------------
 653
 654 wxWinHashTable *wxWinHandleHash = NULL;
 655
 656 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 657 {
 658     return NULL;
 659 }
 660
 661 void wxRemoveHandleAssociation(wxWindowPalm *win)
 662 {
 663 }
 664
 665 // ----------------------------------------------------------------------------
 666 // various Palm speciic class dependent functions
 667 // ----------------------------------------------------------------------------
 668
 669 // Default destroyer - override if you destroy it in some other way
 670 // (e.g. with MDI child windows)
 671 void wxWindowPalm::PalmDestroyWindow()
 672 {
 673 }
 674
 675 bool wxWindowPalm::PalmGetCreateWindowCoords(const wxPoint& pos,
 676                                            const wxSize& size,
 677                                            int& x, int& y,
 678                                            int& w, int& h) const
 679 {
 680     return false;
 681 }
 682
 683 WXHWND wxWindowPalm::PalmGetParent() const
 684 {
 685     return NULL;
 686 }
 687
 688 bool wxWindowPalm::PalmCreate(const wxChar *wclass,
 689                             const wxChar *title,
 690                             const wxPoint& pos,
 691                             const wxSize& size,
 692                             WXDWORD style,
 693                             WXDWORD extendedStyle)
 694 {
 695     return false;
 696 }
 697
 698 // ===========================================================================
 699 // Palm message handlers
 700 // ===========================================================================
 701
 702 // ---------------------------------------------------------------------------
 703 // end session messages
 704 // ---------------------------------------------------------------------------
 705
 706 bool wxWindowPalm::HandleQueryEndSession(long logOff, bool *mayEnd)
 707 {
 708     return false;
 709 }
 710
 711 bool wxWindowPalm::HandleEndSession(bool endSession, long logOff)
 712 {
 713     return false;
 714 }
 715
 716 // ---------------------------------------------------------------------------
 717 // window creation/destruction
 718 // ---------------------------------------------------------------------------
 719
 720 bool wxWindowPalm::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
 721 {
 722     return false;
 723 }
 724
 725 bool wxWindowPalm::HandleDestroy()
 726 {
 727     return false;
 728 }
 729
 730 // ---------------------------------------------------------------------------
 731 // activation/focus
 732 // ---------------------------------------------------------------------------
 733
 734 bool wxWindowPalm::HandleActivate(int state,
 735                               bool WXUNUSED(minimized),
 736                               WXHWND WXUNUSED(activate))
 737 {
 738     return false;
 739 }
 740
 741 bool wxWindowPalm::HandleSetFocus(WXHWND hwnd)
 742 {
 743     return false;
 744 }
 745
 746 bool wxWindowPalm::HandleKillFocus(WXHWND hwnd)
 747 {
 748     return false;
 749 }
 750
 751 // ---------------------------------------------------------------------------
 752 // miscellaneous
 753 // ---------------------------------------------------------------------------
 754
 755 bool wxWindowPalm::HandleShow(bool show, int WXUNUSED(status))
 756 {
 757     return false;
 758 }
 759
 760 bool wxWindowPalm::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
 761 {
 762     return false;
 763 }
 764
 765 bool wxWindowPalm::HandleDropFiles(WXWPARAM wParam)
 766 {
 767     return false;
 768 }
 769
 770
 771 bool wxWindowPalm::HandleSetCursor(WXHWND WXUNUSED(hWnd),
 772                                   short nHitTest,
 773                                   int WXUNUSED(mouseMsg))
 774 {
 775     return false;
 776 }
 777
 778 // ---------------------------------------------------------------------------
 779 // owner drawn stuff
 780 // ---------------------------------------------------------------------------
 781
 782 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
 783         (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
 784     #define WXUNUSED_UNLESS_ODRAWN(param) param
 785 #else
 786     #define WXUNUSED_UNLESS_ODRAWN(param)
 787 #endif
 788
 789 bool
 790 wxWindowPalm::PalmOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
 791                            WXDRAWITEMSTRUCT * WXUNUSED_UNLESS_ODRAWN(itemStruct))
 792 {
 793     return false;
 794 }
 795
 796 bool
 797 wxWindowPalm::PalmOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
 798                               WXMEASUREITEMSTRUCT *
 799                                   WXUNUSED_UNLESS_ODRAWN(itemStruct))
 800 {
 801     return false;
 802 }
 803
 804 // ---------------------------------------------------------------------------
 805 // colours and palettes
 806 // ---------------------------------------------------------------------------
 807
 808 bool wxWindowPalm::HandleSysColorChange()
 809 {
 810     return false;
 811 }
 812
 813 bool wxWindowPalm::HandleDisplayChange()
 814 {
 815     return false;
 816 }
 817
 818 bool wxWindowPalm::HandleCtlColor(WXHBRUSH *brush,
 819                               WXHDC pDC,
 820                               WXHWND pWnd,
 821                               WXUINT nCtlColor,
 822                               WXUINT message,
 823                               WXWPARAM wParam,
 824                               WXLPARAM lParam)
 825 {
 826     return false;
 827 }
 828
 829 // Define for each class of dialog and control
 830 WXHBRUSH wxWindowPalm::OnCtlColor(WXHDC WXUNUSED(hDC),
 831                                  WXHWND WXUNUSED(hWnd),
 832                                  WXUINT WXUNUSED(nCtlColor),
 833                                  WXUINT WXUNUSED(message),
 834                                  WXWPARAM WXUNUSED(wParam),
 835                                  WXLPARAM WXUNUSED(lParam))
 836 {
 837     return (WXHBRUSH)0;
 838 }
 839
 840 bool wxWindowPalm::HandlePaletteChanged(WXHWND hWndPalChange)
 841 {
 842     return false;
 843 }
 844
 845 bool wxWindowPalm::HandleCaptureChanged(WXHWND hWndGainedCapture)
 846 {
 847     return false;
 848 }
 849
 850 bool wxWindowPalm::HandleQueryNewPalette()
 851 {
 852     return false;
 853 }
 854
 855 // Responds to colour changes: passes event on to children.
 856 void wxWindowPalm::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
 857 {
 858 }
 859
 860 // ---------------------------------------------------------------------------
 861 // painting
 862 // ---------------------------------------------------------------------------
 863
 864 bool wxWindowPalm::HandlePaint()
 865 {
 866     return false;
 867 }
 868
 869 // Can be called from an application's OnPaint handler
 870 void wxWindowPalm::OnPaint(wxPaintEvent& event)
 871 {
 872 }
 873
 874 bool wxWindowPalm::HandleEraseBkgnd(WXHDC hdc)
 875 {
 876     return false;
 877 }
 878
 879 void wxWindowPalm::OnEraseBackground(wxEraseEvent& event)
 880 {
 881 }
 882
 883 // ---------------------------------------------------------------------------
 884 // moving and resizing
 885 // ---------------------------------------------------------------------------
 886
 887 bool wxWindowPalm::HandleMinimize()
 888 {
 889     return false;
 890 }
 891
 892 bool wxWindowPalm::HandleMaximize()
 893 {
 894     return false;
 895 }
 896
 897 bool wxWindowPalm::HandleMove(int x, int y)
 898 {
 899     return false;
 900 }
 901
 902 bool wxWindowPalm::HandleMoving(wxRect& rect)
 903 {
 904     return false;
 905 }
 906
 907 bool wxWindowPalm::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
 908                              WXUINT WXUNUSED(flag))
 909 {
 910     return false;
 911 }
 912
 913 bool wxWindowPalm::HandleSizing(wxRect& rect)
 914 {
 915     return false;
 916 }
 917
 918 bool wxWindowPalm::HandleGetMinMaxInfo(void *mmInfo)
 919 {
 920     return false;
 921 }
 922
 923 // ---------------------------------------------------------------------------
 924 // command messages
 925 // ---------------------------------------------------------------------------
 926
 927 bool wxWindowPalm::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 928 {
 929     return false;
 930 }
 931
 932 // ---------------------------------------------------------------------------
 933 // mouse events
 934 // ---------------------------------------------------------------------------
 935
 936 void wxWindowPalm::InitMouseEvent(wxMouseEvent& event,
 937                                  int x, int y,
 938                                  WXUINT flags)
 939 {
 940 }
 941
 942 // Windows doesn't send the mouse events to the static controls (which are
 943 // transparent in the sense that their WM_NCHITTEST handler returns
 944 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
 945 // and so we manually check if we don't have a child window under mouse and if
 946 // we do, send the event to it instead of the window Windows had sent WM_XXX
 947 // to.
 948 //
 949 // Notice that this is not done for the mouse move events because this could
 950 // (would?) be too slow, but only for clicks which means that the static texts
 951 // still don't get move, enter nor leave events.
 952 static wxWindowPalm *FindWindowForMouseEvent(wxWindowPalm *win, int *x, int *y) //TW:REQ:Univ
 953 {
 954     return NULL;
 955 }
 956
 957 bool wxWindowPalm::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
 958 {
 959     return false;
 960 }
 961
 962 bool wxWindowPalm::HandleMouseMove(int x, int y, WXUINT flags)
 963 {
 964     return false;
 965 }
 966
 967
 968 bool wxWindowPalm::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
 969 {
 970     return false;
 971 }
 972
 973
 974 // ---------------------------------------------------------------------------
 975 // keyboard handling
 976 // ---------------------------------------------------------------------------
 977
 978 // create the key event of the given type for the given key - used by
 979 // HandleChar and HandleKeyDown/Up
 980 wxKeyEvent wxWindowPalm::CreateKeyEvent(wxEventType evType,
 981                                        int id,
 982                                        WXLPARAM lParam,
 983                                        WXWPARAM wParam) const
 984 {
 985     wxKeyEvent event(evType);
 986
 987     return event;
 988 }
 989
 990 // isASCII is true only when we're called from WM_CHAR handler and not from
 991 // WM_KEYDOWN one
 992 bool wxWindowPalm::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
 993 {
 994     return false;
 995 }
 996
 997 bool wxWindowPalm::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
 998 {
 999     return false;
1000 }
1001
1002 bool wxWindowPalm::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
1003 {
1004     return false;
1005 }
1006
1007 // ---------------------------------------------------------------------------
1008 // joystick
1009 // ---------------------------------------------------------------------------
1010
1011 bool wxWindowPalm::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
1012 {
1013     return false;
1014 }
1015
1016 // ---------------------------------------------------------------------------
1017 // scrolling
1018 // ---------------------------------------------------------------------------
1019
1020 bool wxWindowPalm::PalmOnScroll(int orientation, WXWORD wParam,
1021                               WXWORD pos, WXHWND control)
1022 {
1023     return false;
1024 }
1025
1026 // ===========================================================================
1027 // global functions
1028 // ===========================================================================
1029
1030 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
1031 {
1032 }
1033
1034 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
1035 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
1036 int wxCharCodePalmToWX(int keySym, WXLPARAM lParam)
1037 {
1038     return 0;
1039 }
1040
1041 int wxCharCodeWXToPalm(int id, bool *isVirtual)
1042 {
1043     return 0;
1044 }
1045
1046 bool wxGetKeyState(wxKeyCode key)
1047 {
1048     return false;
1049 }
1050
1051 wxWindow *wxGetActiveWindow()
1052 {
1053     return NULL;
1054 }
1055
1056 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
1057 {
1058     return NULL;
1059 }
1060
1061 // Find the wxWindow at the current mouse position, returning the mouse
1062 // position.
1063 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1064 {
1065     return NULL;
1066 }
1067
1068 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
1069 {
1070     return NULL;
1071 }
1072
1073 // Get the current mouse position.
1074 wxPoint wxGetMousePosition()
1075 {
1076     return wxPoint(0, 0);
1077 }
1078
1079 #if wxUSE_HOTKEY
1080
1081 bool wxWindowPalm::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
1082 {
1083     return false;
1084 }
1085
1086 bool wxWindowPalm::UnregisterHotKey(int hotkeyId)
1087 {
1088     return false;
1089 }
1090
1091 #if wxUSE_ACCEL
1092
1093 bool wxWindowPalm::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
1094 {
1095     return false;
1096 }
1097
1098 #endif // wxUSE_ACCEL
1099
1100 #endif // wxUSE_HOTKEY
1101
1102