src/univ/winuniv.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        univ/window.cpp
   3 // Purpose:     implementation of extra wxWindow methods for wxUniv port
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     06.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   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 "univwindow.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/app.h"
  33     #include "wx/window.h"
  34     #include "wx/dcclient.h"
  35     #include "wx/dcmemory.h"
  36     #include "wx/event.h"
  37     #include "wx/scrolbar.h"
  38     #include "wx/menu.h"
  39     #include "wx/frame.h"
  40 #endif // WX_PRECOMP
  41
  42 #include "wx/log.h"
  43 #include "wx/univ/colschem.h"
  44 #include "wx/univ/renderer.h"
  45 #include "wx/univ/theme.h"
  46
  47 #if wxUSE_CARET
  48     #include "wx/caret.h"
  49 #endif // wxUSE_CARET
  50
  51 // turn Refresh() debugging on/off
  52 #define WXDEBUG_REFRESH
  53
  54 #ifndef __WXDEBUG__
  55     #undef WXDEBUG_REFRESH
  56 #endif
  57
  58 #if defined(WXDEBUG_REFRESH) && defined(__WXMSW__) && !defined(__WXMICROWIN__)
  59 #include "wx/msw/private.h"
  60 #endif
  61
  62 // ============================================================================
  63 // implementation
  64 // ============================================================================
  65
  66 // ----------------------------------------------------------------------------
  67 // event tables
  68 // ----------------------------------------------------------------------------
  69
  70 // we can't use wxWindowNative here as it won't be expanded inside the macro
  71 #if defined(__WXMSW__)
  72     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowMSW)
  73 #elif defined(__WXGTK__)
  74     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowGTK)
  75 #elif defined(__WXMGL__)
  76     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowMGL)
  77 #elif defined(__WXX11__)
  78     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowX11)
  79 #elif defined(__WXPM__)
  80     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowOS2)
  81 #endif
  82
  83 BEGIN_EVENT_TABLE(wxWindow, wxWindowNative)
  84     EVT_SIZE(wxWindow::OnSize)
  85
  86 #if wxUSE_ACCEL || wxUSE_MENUS
  87     EVT_KEY_DOWN(wxWindow::OnKeyDown)
  88 #endif // wxUSE_ACCEL
  89
  90 #if wxUSE_MENUS
  91     EVT_CHAR(wxWindow::OnChar)
  92     EVT_KEY_UP(wxWindow::OnKeyUp)
  93 #endif // wxUSE_MENUS
  94
  95     EVT_PAINT(wxWindow::OnPaint)
  96     EVT_NC_PAINT(wxWindow::OnNcPaint)
  97     EVT_ERASE_BACKGROUND(wxWindow::OnErase)
  98 END_EVENT_TABLE()
  99
 100 // ----------------------------------------------------------------------------
 101 // creation
 102 // ----------------------------------------------------------------------------
 103
 104 void wxWindow::Init()
 105 {
 106     m_scrollbarVert =
 107     m_scrollbarHorz = (wxScrollBar *)NULL;
 108
 109     m_isCurrent = false;
 110
 111     m_renderer = wxTheme::Get()->GetRenderer();
 112
 113     m_oldSize.x = wxDefaultCoord;
 114     m_oldSize.y = wxDefaultCoord;
 115 }
 116
 117 bool wxWindow::Create(wxWindow *parent,
 118                       wxWindowID id,
 119                       const wxPoint& pos,
 120                       const wxSize& size,
 121                       long style,
 122                       const wxString& name)
 123 {
 124     long actualStyle = style;
 125
 126     // FIXME: may need this on other platforms
 127 #ifdef __WXMSW__
 128     actualStyle &= ~wxVSCROLL;
 129     actualStyle &= ~wxHSCROLL;
 130 #endif
 131
 132     // we add wxCLIP_CHILDREN to get the same ("natural") behaviour under MSW
 133     // as under the other platforms
 134     if ( !wxWindowNative::Create(parent, id, pos, size,
 135                                  actualStyle | wxCLIP_CHILDREN,
 136                                  name) )
 137     {
 138         return false;
 139     }
 140
 141     // Set full style again, including those we didn't want present
 142     // when calling the base window Create().
 143     wxWindowBase::SetWindowStyleFlag(style);
 144
 145     // if we should always have a vertical scrollbar, do show it
 146     if ( style & wxALWAYS_SHOW_SB )
 147     {
 148 #if wxUSE_TWO_WINDOWS
 149         SetInsertIntoMain( true );
 150 #endif
 151         m_scrollbarVert = new wxScrollBar(this, wxID_ANY,
 152                                           wxDefaultPosition, wxDefaultSize,
 153                                           wxSB_VERTICAL);
 154 #if wxUSE_TWO_WINDOWS
 155         SetInsertIntoMain( false );
 156 #endif
 157     }
 158
 159     // if we should always have a horizontal scrollbar, do show it
 160     if ( style & wxHSCROLL )
 161     {
 162 #if wxUSE_TWO_WINDOWS
 163         SetInsertIntoMain( true );
 164 #endif
 165         m_scrollbarHorz = new wxScrollBar(this, wxID_ANY,
 166                                           wxDefaultPosition, wxDefaultSize,
 167                                           wxSB_HORIZONTAL);
 168 #if wxUSE_TWO_WINDOWS
 169         SetInsertIntoMain( false );
 170 #endif
 171     }
 172
 173     if (m_scrollbarHorz || m_scrollbarVert)
 174     {
 175         // position it/them
 176         PositionScrollbars();
 177     }
 178
 179     return true;
 180 }
 181
 182 // ----------------------------------------------------------------------------
 183 // background pixmap
 184 // ----------------------------------------------------------------------------
 185
 186 void wxWindow::SetBackground(const wxBitmap& bitmap,
 187                               int alignment,
 188                               wxStretch stretch)
 189 {
 190     m_bitmapBg = bitmap;
 191     m_alignBgBitmap = alignment;
 192     m_stretchBgBitmap = stretch;
 193 }
 194
 195 const wxBitmap& wxWindow::GetBackgroundBitmap(int *alignment,
 196                                                wxStretch *stretch) const
 197 {
 198     if ( m_bitmapBg.Ok() )
 199     {
 200         if ( alignment )
 201             *alignment = m_alignBgBitmap;
 202         if ( stretch )
 203             *stretch = m_stretchBgBitmap;
 204     }
 205
 206     return m_bitmapBg;
 207 }
 208
 209 // ----------------------------------------------------------------------------
 210 // painting
 211 // ----------------------------------------------------------------------------
 212
 213 // the event handlers executed when the window must be repainted
 214 void wxWindow::OnNcPaint(wxNcPaintEvent& WXUNUSED(event))
 215 {
 216     if ( m_renderer )
 217     {
 218         // get the window rect
 219         wxRect rect;
 220         wxSize size = GetSize();
 221         rect.x =
 222         rect.y = 0;
 223         rect.width = size.x;
 224         rect.height = size.y;
 225
 226         // if the scrollbars are outside the border, we must adjust the rect to
 227         // exclude them
 228         if ( !m_renderer->AreScrollbarsInsideBorder() )
 229         {
 230             wxScrollBar *scrollbar = GetScrollbar(wxVERTICAL);
 231             if ( scrollbar )
 232                 rect.width -= scrollbar->GetSize().x;
 233
 234             scrollbar = GetScrollbar(wxHORIZONTAL);
 235             if ( scrollbar )
 236                 rect.height -= scrollbar->GetSize().y;
 237         }
 238
 239         // get the DC and draw the border on it
 240         wxWindowDC dc(this);
 241         DoDrawBorder(dc, rect);
 242     }
 243 }
 244
 245 void wxWindow::OnPaint(wxPaintEvent& event)
 246 {
 247     if ( !m_renderer )
 248     {
 249         // it is a native control which paints itself
 250         event.Skip();
 251     }
 252     else
 253     {
 254         // get the DC to use and create renderer on it
 255         wxPaintDC dc(this);
 256         wxControlRenderer renderer(this, dc, m_renderer);
 257
 258         // draw the control
 259         DoDraw(&renderer);
 260     }
 261 }
 262
 263 // the event handler executed when the window background must be painted
 264 void wxWindow::OnErase(wxEraseEvent& event)
 265 {
 266     if ( !m_renderer )
 267     {
 268         event.Skip();
 269
 270         return;
 271     }
 272
 273     DoDrawBackground(*event.GetDC());
 274
 275     // if we have both scrollbars, we also have a square in the corner between
 276     // them which we must paint
 277     if ( m_scrollbarVert && m_scrollbarHorz )
 278     {
 279         wxSize size = GetSize();
 280         wxRect rectClient = GetClientRect(),
 281                rectBorder = m_renderer->GetBorderDimensions(GetBorder());
 282
 283         wxRect rectCorner;
 284         rectCorner.x = rectClient.GetRight() + 1;
 285         rectCorner.y = rectClient.GetBottom() + 1;
 286         rectCorner.SetRight(size.x - rectBorder.width);
 287         rectCorner.SetBottom(size.y - rectBorder.height);
 288
 289         if ( GetUpdateRegion().Contains(rectCorner) )
 290         {
 291             m_renderer->DrawScrollCorner(*event.GetDC(), rectCorner);
 292         }
 293     }
 294 }
 295
 296 bool wxWindow::DoDrawBackground(wxDC& dc)
 297 {
 298     wxRect rect;
 299
 300     wxSize size = GetSize();  // Why not GetClientSize() ?
 301     rect.x = 0;
 302     rect.y = 0;
 303     rect.width = size.x;
 304     rect.height = size.y;
 305
 306     wxWindow * const parent = GetParent();
 307     if ( HasTransparentBackground() && parent && parent->ProvidesBackground() )
 308     {
 309         wxASSERT( !IsTopLevel() );
 310
 311         wxPoint pos = GetPosition();
 312
 313         AdjustForParentClientOrigin( pos.x, pos.y, 0 );
 314
 315         // Adjust DC logical origin
 316         wxCoord org_x, org_y, x, y;
 317         dc.GetLogicalOrigin( &org_x, &org_y );
 318         x = org_x + pos.x;
 319         y = org_y + pos.y;
 320         dc.SetLogicalOrigin( x, y );
 321
 322         // Adjust draw rect
 323         rect.x = pos.x;
 324         rect.y = pos.y;
 325
 326         // Let parent draw the background
 327         parent->EraseBackground( dc, rect );
 328
 329         // Restore DC logical origin
 330         dc.SetLogicalOrigin( org_x, org_y );
 331     }
 332     else
 333     {
 334         // Draw background ouselves
 335         EraseBackground( dc, rect );
 336     }
 337
 338     return true;
 339 }
 340
 341 void wxWindow::EraseBackground(wxDC& dc, const wxRect& rect)
 342 {
 343     if ( GetBackgroundBitmap().Ok() )
 344     {
 345         // Get the bitmap and the flags
 346         int alignment;
 347         wxStretch stretch;
 348         wxBitmap bmp = GetBackgroundBitmap(&alignment, &stretch);
 349         wxControlRenderer::DrawBitmap(dc, bmp, rect, alignment, stretch);
 350     }
 351     else
 352     {
 353         // Just fill it with bg colour if no bitmap
 354
 355         m_renderer->DrawBackground(dc, wxTHEME_BG_COLOUR(this),
 356                                    rect, GetStateFlags());
 357     }
 358 }
 359
 360 void wxWindow::DoDrawBorder(wxDC& dc, const wxRect& rect)
 361 {
 362     // draw outline unless the update region is enitrely inside it in which
 363     // case we don't need to do it
 364 #if 0 // doesn't seem to work, why?
 365     if ( wxRegion(rect).Contains(GetUpdateRegion().GetBox()) != wxInRegion )
 366 #endif
 367     {
 368         m_renderer->DrawBorder(dc, GetBorder(), rect, GetStateFlags());
 369     }
 370 }
 371
 372 void wxWindow::DoDraw(wxControlRenderer * WXUNUSED(renderer))
 373 {
 374 }
 375
 376 void wxWindow::Refresh(bool eraseBackground, const wxRect *rectClient)
 377 {
 378     wxRect rectWin;
 379     wxPoint pt = GetClientAreaOrigin();
 380
 381     wxSize size = GetClientSize();
 382
 383     if ( rectClient )
 384     {
 385         rectWin = *rectClient;
 386
 387         // don't refresh anything beyond the client area (scrollbars for
 388         // example)
 389         if ( rectWin.GetRight() > size.x )
 390             rectWin.SetRight(size.x);
 391         if ( rectWin.GetBottom() > size.y )
 392             rectWin.SetBottom(size.y);
 393
 394         rectWin.Offset(pt);
 395     }
 396     else // refresh the entire client area
 397     {
 398         rectWin.x = pt.x;
 399         rectWin.y = pt.y;
 400         rectWin.width = size.x;
 401         rectWin.height = size.y;
 402     }
 403
 404     // debugging helper
 405 #ifdef WXDEBUG_REFRESH
 406     static bool s_refreshDebug = false;
 407     if ( s_refreshDebug )
 408     {
 409         wxWindowDC dc(this);
 410         dc.SetBrush(*wxCYAN_BRUSH);
 411         dc.SetPen(*wxTRANSPARENT_PEN);
 412         dc.DrawRectangle(rectWin);
 413
 414         // under Unix we use "--sync" X option for this
 415         #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 416             ::GdiFlush();
 417             ::Sleep(200);
 418         #endif // __WXMSW__
 419     }
 420 #endif // WXDEBUG_REFRESH
 421
 422     wxWindowNative::Refresh(eraseBackground, &rectWin);
 423
 424     // Refresh all sub controls if any.
 425     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 426     while ( node )
 427     {
 428         wxWindow *win = node->GetData();
 429         // Only refresh sub controls when it is visible
 430         // and when it is in the update region.
 431         if(!win->IsKindOf(CLASSINFO(wxTopLevelWindow)) && win->IsShown() && wxRegion(rectWin).Contains(win->GetRect()) != wxOutRegion)
 432             win->Refresh(eraseBackground, &rectWin);
 433
 434         node = node->GetNext();
 435     }
 436 }
 437
 438 // ----------------------------------------------------------------------------
 439 // state flags
 440 // ----------------------------------------------------------------------------
 441
 442 bool wxWindow::Enable(bool enable)
 443 {
 444     if ( !wxWindowNative::Enable(enable) )
 445         return false;
 446
 447     // disabled window can't keep focus
 448     if ( FindFocus() == this && GetParent() != NULL )
 449     {
 450         GetParent()->SetFocus();
 451     }
 452
 453     if ( m_renderer )
 454     {
 455         // a window with renderer is drawn by ourselves and it has to be
 456         // refreshed to reflect its new status
 457         Refresh();
 458     }
 459
 460     return true;
 461 }
 462
 463 bool wxWindow::IsFocused() const
 464 {
 465     wxWindow *self = wxConstCast(this, wxWindow);
 466     return self->FindFocus() == self;
 467 }
 468
 469 bool wxWindow::IsPressed() const
 470 {
 471     return false;
 472 }
 473
 474 bool wxWindow::IsDefault() const
 475 {
 476     return false;
 477 }
 478
 479 bool wxWindow::IsCurrent() const
 480 {
 481     return m_isCurrent;
 482 }
 483
 484 bool wxWindow::SetCurrent(bool doit)
 485 {
 486     if ( doit == m_isCurrent )
 487         return false;
 488
 489     m_isCurrent = doit;
 490
 491     if ( CanBeHighlighted() )
 492         Refresh();
 493
 494     return true;
 495 }
 496
 497 int wxWindow::GetStateFlags() const
 498 {
 499     int flags = 0;
 500     if ( !IsEnabled() )
 501         flags |= wxCONTROL_DISABLED;
 502
 503     // the following states are only possible if our application is active - if
 504     // it is not, even our default/focused controls shouldn't appear as such
 505     if ( wxTheApp->IsActive() )
 506     {
 507         if ( IsCurrent() )
 508             flags |= wxCONTROL_CURRENT;
 509         if ( IsFocused() )
 510             flags |= wxCONTROL_FOCUSED;
 511         if ( IsPressed() )
 512             flags |= wxCONTROL_PRESSED;
 513         if ( IsDefault() )
 514             flags |= wxCONTROL_ISDEFAULT;
 515     }
 516
 517     return flags;
 518 }
 519
 520 // ----------------------------------------------------------------------------
 521 // size
 522 // ----------------------------------------------------------------------------
 523
 524 void wxWindow::OnSize(wxSizeEvent& event)
 525 {
 526     event.Skip();
 527
 528     if ( m_scrollbarVert || m_scrollbarHorz )
 529     {
 530         PositionScrollbars();
 531     }
 532
 533 #if 0   // ndef __WXMSW__
 534     // Refresh the area (strip) previously occupied by the border
 535
 536     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) && IsShown() )
 537     {
 538         // This code assumes that wxSizeEvent.GetSize() returns
 539         // the area of the entire window, not just the client
 540         // area.
 541         wxSize newSize = event.GetSize();
 542
 543         if (m_oldSize.x == wxDefaultCoord && m_oldSize.y == wxDefaultCoord)
 544         {
 545             m_oldSize = newSize;
 546             return;
 547         }
 548
 549         if (HasFlag( wxSIMPLE_BORDER ))
 550         {
 551             if (newSize.y > m_oldSize.y)
 552             {
 553                 wxRect rect;
 554                 rect.x = 0;
 555                 rect.width = m_oldSize.x;
 556                 rect.y = m_oldSize.y-2;
 557                 rect.height = 1;
 558                 Refresh( true, &rect );
 559             }
 560             else if (newSize.y < m_oldSize.y)
 561             {
 562                 wxRect rect;
 563                 rect.y = newSize.y;
 564                 rect.x = 0;
 565                 rect.height = 1;
 566                 rect.width = newSize.x;
 567                 wxWindowNative::Refresh( true, &rect );
 568             }
 569
 570             if (newSize.x > m_oldSize.x)
 571             {
 572                 wxRect rect;
 573                 rect.y = 0;
 574                 rect.height = m_oldSize.y;
 575                 rect.x = m_oldSize.x-2;
 576                 rect.width = 1;
 577                 Refresh( true, &rect );
 578             }
 579             else if (newSize.x < m_oldSize.x)
 580             {
 581                 wxRect rect;
 582                 rect.x = newSize.x;
 583                 rect.y = 0;
 584                 rect.width = 1;
 585                 rect.height = newSize.y;
 586                 wxWindowNative::Refresh( true, &rect );
 587             }
 588         }
 589         else
 590         if (HasFlag( wxSUNKEN_BORDER ) || HasFlag( wxRAISED_BORDER ))
 591         {
 592             if (newSize.y > m_oldSize.y)
 593             {
 594                 wxRect rect;
 595                 rect.x = 0;
 596                 rect.width = m_oldSize.x;
 597                 rect.y = m_oldSize.y-4;
 598                 rect.height = 2;
 599                 Refresh( true, &rect );
 600             }
 601             else if (newSize.y < m_oldSize.y)
 602             {
 603                 wxRect rect;
 604                 rect.y = newSize.y;
 605                 rect.x = 0;
 606                 rect.height = 2;
 607                 rect.width = newSize.x;
 608                 wxWindowNative::Refresh( true, &rect );
 609             }
 610
 611             if (newSize.x > m_oldSize.x)
 612             {
 613                 wxRect rect;
 614                 rect.y = 0;
 615                 rect.height = m_oldSize.y;
 616                 rect.x = m_oldSize.x-4;
 617                 rect.width = 2;
 618                 Refresh( true, &rect );
 619             }
 620             else if (newSize.x < m_oldSize.x)
 621             {
 622                 wxRect rect;
 623                 rect.x = newSize.x;
 624                 rect.y = 0;
 625                 rect.width = 2;
 626                 rect.height = newSize.y;
 627                 wxWindowNative::Refresh( true, &rect );
 628             }
 629         }
 630
 631         m_oldSize = newSize;
 632     }
 633 #endif
 634 }
 635
 636 wxSize wxWindow::DoGetBestSize() const
 637 {
 638     return AdjustSize(DoGetBestClientSize());
 639 }
 640
 641 wxSize wxWindow::DoGetBestClientSize() const
 642 {
 643     return wxWindowNative::DoGetBestSize();
 644 }
 645
 646 wxSize wxWindow::AdjustSize(const wxSize& size) const
 647 {
 648     wxSize sz = size;
 649     if ( m_renderer )
 650         m_renderer->AdjustSize(&sz, this);
 651     return sz;
 652 }
 653
 654 wxPoint wxWindow::GetClientAreaOrigin() const
 655 {
 656     wxPoint pt = wxWindowBase::GetClientAreaOrigin();
 657
 658 #if wxUSE_TWO_WINDOWS
 659 #else
 660     if ( m_renderer )
 661         pt += m_renderer->GetBorderDimensions(GetBorder()).GetPosition();
 662 #endif
 663
 664     return pt;
 665 }
 666
 667 void wxWindow::DoGetClientSize(int *width, int *height) const
 668 {
 669     // if it is a native window, we assume it handles the scrollbars itself
 670     // too - and if it doesn't, there is not much we can do
 671     if ( !m_renderer )
 672     {
 673         wxWindowNative::DoGetClientSize(width, height);
 674
 675         return;
 676     }
 677
 678     int w, h;
 679     wxWindowNative::DoGetClientSize(&w, &h);
 680
 681     // we assume that the scrollbars are positioned correctly (by a previous
 682     // call to PositionScrollbars()) here
 683
 684     wxRect rectBorder;
 685     if ( m_renderer )
 686         rectBorder = m_renderer->GetBorderDimensions(GetBorder());
 687
 688     bool inside = m_renderer->AreScrollbarsInsideBorder();
 689
 690     if ( width )
 691     {
 692         // in any case, take account of the scrollbar
 693         if ( m_scrollbarVert )
 694             w -= m_scrollbarVert->GetSize().x;
 695
 696         // if we don't have scrollbar or if it is outside the border (and not
 697         // blended into it), take account of the right border as well
 698         if ( !m_scrollbarVert || inside )
 699             w -= rectBorder.width;
 700
 701         // and always account for the left border
 702         *width = w - rectBorder.x;
 703
 704         // we shouldn't return invalid width
 705         if ( *width < 0 )
 706             *width = 0;
 707     }
 708
 709     if ( height )
 710     {
 711         if ( m_scrollbarHorz )
 712             h -= m_scrollbarHorz->GetSize().y;
 713
 714         if ( !m_scrollbarHorz || inside )
 715             h -= rectBorder.height;
 716
 717         *height = h - rectBorder.y;
 718
 719         // we shouldn't return invalid height
 720         if ( *height < 0 )
 721             *height = 0;
 722     }
 723 }
 724
 725 void wxWindow::DoSetClientSize(int width, int height)
 726 {
 727     // take into account the borders
 728     wxRect rectBorder = m_renderer->GetBorderDimensions(GetBorder());
 729     width += rectBorder.x;
 730     height += rectBorder.y;
 731
 732     // and the scrollbars (as they may be offset into the border, use the
 733     // scrollbar position, not size - this supposes that PositionScrollbars()
 734     // had been called before)
 735     bool inside = m_renderer->AreScrollbarsInsideBorder();
 736     wxSize size = GetSize();
 737     if ( m_scrollbarVert )
 738         width += size.x - m_scrollbarVert->GetPosition().x;
 739     if ( !m_scrollbarVert || inside )
 740         width += rectBorder.width;
 741
 742     if ( m_scrollbarHorz )
 743         height += size.y - m_scrollbarHorz->GetPosition().y;
 744     if ( !m_scrollbarHorz || inside )
 745         height += rectBorder.height;
 746
 747     wxWindowNative::DoSetClientSize(width, height);
 748 }
 749
 750 wxHitTest wxWindow::DoHitTest(wxCoord x, wxCoord y) const
 751 {
 752     wxHitTest ht = wxWindowNative::DoHitTest(x, y);
 753     if ( ht == wxHT_WINDOW_INSIDE )
 754     {
 755         if ( m_scrollbarVert && x >= m_scrollbarVert->GetPosition().x )
 756         {
 757             // it can still be changed below because it may also be the corner
 758             ht = wxHT_WINDOW_VERT_SCROLLBAR;
 759         }
 760
 761         if ( m_scrollbarHorz && y >= m_scrollbarHorz->GetPosition().y )
 762         {
 763             ht = ht == wxHT_WINDOW_VERT_SCROLLBAR ? wxHT_WINDOW_CORNER
 764                                                   : wxHT_WINDOW_HORZ_SCROLLBAR;
 765         }
 766     }
 767
 768     return ht;
 769 }
 770
 771 // ----------------------------------------------------------------------------
 772 // scrolling: we implement it entirely ourselves except for ScrollWindow()
 773 // function which is supposed to be (efficiently) implemented by the native
 774 // window class
 775 // ----------------------------------------------------------------------------
 776
 777 void wxWindow::RefreshScrollbars()
 778 {
 779     if ( m_scrollbarHorz )
 780         m_scrollbarHorz->Refresh();
 781
 782     if ( m_scrollbarVert )
 783         m_scrollbarVert->Refresh();
 784 }
 785
 786 void wxWindow::PositionScrollbars()
 787 {
 788     // do not use GetClientSize/Rect as it relies on the scrollbars being
 789     // correctly positioned
 790
 791     wxSize size = GetSize();
 792     wxBorder border = GetBorder();
 793     wxRect rectBorder = m_renderer->GetBorderDimensions(border);
 794     bool inside = m_renderer->AreScrollbarsInsideBorder();
 795
 796     int height = m_scrollbarHorz ? m_scrollbarHorz->GetSize().y : 0;
 797     int width = m_scrollbarVert ? m_scrollbarVert->GetSize().x : 0;
 798
 799     wxRect rectBar;
 800     if ( m_scrollbarVert )
 801     {
 802         rectBar.x = size.x - width;
 803         if ( inside )
 804            rectBar.x -= rectBorder.width;
 805         rectBar.width = width;
 806         rectBar.y = 0;
 807         if ( inside )
 808             rectBar.y += rectBorder.y;
 809         rectBar.height = size.y - height;
 810         if ( inside )
 811             rectBar.height -= rectBorder.y + rectBorder.height;
 812
 813         m_scrollbarVert->SetSize(rectBar, wxSIZE_NO_ADJUSTMENTS);
 814     }
 815
 816     if ( m_scrollbarHorz )
 817     {
 818         rectBar.y = size.y - height;
 819         if ( inside )
 820             rectBar.y -= rectBorder.height;
 821         rectBar.height = height;
 822         rectBar.x = 0;
 823         if ( inside )
 824             rectBar.x += rectBorder.x;
 825         rectBar.width = size.x - width;
 826         if ( inside )
 827             rectBar.width -= rectBorder.x + rectBorder.width;
 828
 829         m_scrollbarHorz->SetSize(rectBar, wxSIZE_NO_ADJUSTMENTS);
 830     }
 831
 832     RefreshScrollbars();
 833 }
 834
 835 void wxWindow::SetScrollbar(int orient,
 836                             int pos,
 837                             int pageSize,
 838                             int range,
 839                             bool refresh)
 840 {
 841     wxASSERT_MSG( pageSize <= range,
 842                     _T("page size can't be greater than range") );
 843
 844     bool hasClientSizeChanged = false;
 845     wxScrollBar *scrollbar = GetScrollbar(orient);
 846     if ( range && (pageSize < range) )
 847     {
 848         if ( !scrollbar )
 849         {
 850             // create it
 851 #if wxUSE_TWO_WINDOWS
 852             SetInsertIntoMain( true );
 853 #endif
 854             scrollbar = new wxScrollBar(this, wxID_ANY,
 855                                         wxDefaultPosition, wxDefaultSize,
 856                                         orient & wxVERTICAL ? wxSB_VERTICAL
 857                                                             : wxSB_HORIZONTAL);
 858 #if wxUSE_TWO_WINDOWS
 859             SetInsertIntoMain( false );
 860 #endif
 861             if ( orient & wxVERTICAL )
 862                 m_scrollbarVert = scrollbar;
 863             else
 864                 m_scrollbarHorz = scrollbar;
 865
 866             // the client area diminished as we created a scrollbar
 867             hasClientSizeChanged = true;
 868
 869             PositionScrollbars();
 870         }
 871         else if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
 872         {
 873             // we might have disabled it before
 874             scrollbar->Enable();
 875         }
 876
 877         scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
 878     }
 879     else // no range means no scrollbar
 880     {
 881         if ( scrollbar )
 882         {
 883             // wxALWAYS_SHOW_SB only applies to the vertical scrollbar
 884             if ( (orient & wxVERTICAL) && (GetWindowStyle() & wxALWAYS_SHOW_SB) )
 885             {
 886                 // just disable the scrollbar
 887                 scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
 888                 scrollbar->Disable();
 889             }
 890             else // really remove the scrollbar
 891             {
 892                 delete scrollbar;
 893
 894                 if ( orient & wxVERTICAL )
 895                     m_scrollbarVert = NULL;
 896                 else
 897                     m_scrollbarHorz = NULL;
 898
 899                 // the client area increased as we removed a scrollbar
 900                 hasClientSizeChanged = true;
 901
 902                 // the size of the remaining scrollbar must be adjusted
 903                 if ( m_scrollbarHorz || m_scrollbarVert )
 904                 {
 905                     PositionScrollbars();
 906                 }
 907             }
 908         }
 909     }
 910
 911     // give the window a chance to relayout
 912     if ( hasClientSizeChanged )
 913     {
 914 #if wxUSE_TWO_WINDOWS
 915         wxWindowNative::SetSize( GetSize() );
 916 #else
 917         wxSizeEvent event(GetSize());
 918         (void)GetEventHandler()->ProcessEvent(event);
 919 #endif
 920     }
 921 }
 922
 923 void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
 924 {
 925     wxScrollBar *scrollbar = GetScrollbar(orient);
 926     wxCHECK_RET( scrollbar, _T("no scrollbar to set position for") );
 927
 928     scrollbar->SetThumbPosition(pos);
 929
 930     // VZ: I think we can safely ignore this as we always refresh it
 931     //     automatically whenever the value chanegs
 932 #if 0
 933     if ( refresh )
 934         Refresh();
 935 #endif
 936 }
 937
 938 int wxWindow::GetScrollPos(int orient) const
 939 {
 940     wxScrollBar *scrollbar = GetScrollbar(orient);
 941     return scrollbar ? scrollbar->GetThumbPosition() : 0;
 942 }
 943
 944 int wxWindow::GetScrollThumb(int orient) const
 945 {
 946     wxScrollBar *scrollbar = GetScrollbar(orient);
 947     return scrollbar ? scrollbar->GetThumbSize() : 0;
 948 }
 949
 950 int wxWindow::GetScrollRange(int orient) const
 951 {
 952     wxScrollBar *scrollbar = GetScrollbar(orient);
 953     return scrollbar ? scrollbar->GetRange() : 0;
 954 }
 955
 956 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 957 {
 958     // use native scrolling when available and do it in generic way
 959     // otherwise:
 960 #ifdef __WXX11__
 961
 962     wxWindowNative::ScrollWindow(dx, dy, rect);
 963
 964 #else // !wxX11
 965
 966     // before scrolling it, ensure that we don't have any unpainted areas
 967     Update();
 968
 969     wxRect r;
 970
 971     if ( dx )
 972     {
 973         r = ScrollNoRefresh(dx, 0, rect);
 974         Refresh(true /* erase bkgnd */, &r);
 975     }
 976
 977     if ( dy )
 978     {
 979         r = ScrollNoRefresh(0, dy, rect);
 980         Refresh(true /* erase bkgnd */, &r);
 981     }
 982
 983     // scroll children accordingly:
 984     wxPoint offset(dx, dy);
 985
 986     for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 987          node; node = node->GetNext())
 988     {
 989         wxWindow *child = node->GetData();
 990         if ( child == m_scrollbarVert || child == m_scrollbarHorz )
 991             continue;
 992
 993         // VS: Scrolling children has non-trivial semantics. If rect=NULL then
 994         //     it is easy: we scroll all children. Otherwise it gets
 995         //     complicated:
 996         //       1. if scrolling in one direction only, scroll only
 997         //          those children that intersect shaft defined by the rectangle
 998         //          and scrolling direction
 999         //       2. if scrolling in both axes, scroll all children
1000
1001         if ( rect && (dx * dy == 0 /* moving in only one of x, y axis */) )
1002         {
1003             wxRect childRect = child->GetRect();
1004             if ( dx == 0 && (childRect.GetLeft() <= rect->GetRight() ||
1005                              childRect.GetRight() >= rect->GetLeft()) )
1006             {
1007                 child->Move(child->GetPosition() + offset);
1008             }
1009             else if ( dy == 0 && (childRect.GetTop() <= rect->GetBottom() ||
1010                                   childRect.GetBottom() >= rect->GetTop()) )
1011             {
1012                 child->Move(child->GetPosition() + offset);
1013             }
1014         }
1015         else
1016         {
1017             child->Move(child->GetPosition() + offset);
1018         }
1019     }
1020 #endif // wxX11/!wxX11
1021 }
1022
1023 wxRect wxWindow::ScrollNoRefresh(int dx, int dy, const wxRect *rectTotal)
1024 {
1025     wxASSERT_MSG( !dx || !dy, _T("can't be used for diag scrolling") );
1026
1027     // the rect to refresh (which we will calculate)
1028     wxRect rect;
1029
1030     if ( !dx && !dy )
1031     {
1032         // nothing to do
1033         return rect;
1034     }
1035
1036     // calculate the part of the window which we can just redraw in the new
1037     // location
1038     wxSize sizeTotal = rectTotal ? rectTotal->GetSize() : GetClientSize();
1039
1040     wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
1041                sizeTotal.x, sizeTotal.y, dx, dy);
1042
1043     // the initial and end point of the region we move in client coords
1044     wxPoint ptSource, ptDest;
1045     if ( rectTotal )
1046     {
1047         ptSource = rectTotal->GetPosition();
1048         ptDest = rectTotal->GetPosition();
1049     }
1050
1051     // the size of this region
1052     wxSize size;
1053     size.x = sizeTotal.x - abs(dx);
1054     size.y = sizeTotal.y - abs(dy);
1055     if ( size.x <= 0 || size.y <= 0 )
1056     {
1057         // just redraw everything as nothing of the displayed image will stay
1058         wxLogTrace(_T("scroll"), _T("refreshing everything"));
1059
1060         rect = rectTotal ? *rectTotal : wxRect(0, 0, sizeTotal.x, sizeTotal.y);
1061     }
1062     else // move the part which doesn't change to the new location
1063     {
1064         // note that when we scroll the canvas in some direction we move the
1065         // block which doesn't need to be refreshed in the opposite direction
1066
1067         if ( dx < 0 )
1068         {
1069             // scroll to the right, move to the left
1070             ptSource.x -= dx;
1071         }
1072         else
1073         {
1074             // scroll to the left, move to the right
1075             ptDest.x += dx;
1076         }
1077
1078         if ( dy < 0 )
1079         {
1080             // scroll down, move up
1081             ptSource.y -= dy;
1082         }
1083         else
1084         {
1085             // scroll up, move down
1086             ptDest.y += dy;
1087         }
1088
1089 #if wxUSE_CARET
1090         // we need to hide the caret before moving or it will erase itself at
1091         // the wrong (old) location
1092         wxCaret *caret = GetCaret();
1093         if ( caret )
1094             caret->Hide();
1095 #endif // wxUSE_CARET
1096
1097         // do move
1098         wxClientDC dc(this);
1099         wxBitmap bmp(size.x, size.y);
1100         wxMemoryDC dcMem;
1101         dcMem.SelectObject(bmp);
1102
1103         dcMem.Blit(wxPoint(0, 0), size, &dc, ptSource
1104 #if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
1105                 + GetClientAreaOrigin()
1106 #endif // broken wxGTK wxDC::Blit
1107                   );
1108         dc.Blit(ptDest, size, &dcMem, wxPoint(0, 0));
1109
1110         wxLogTrace(_T("scroll"),
1111                    _T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
1112                    ptSource.x, ptSource.y,
1113                    size.x, size.y,
1114                    ptDest.x, ptDest.y);
1115
1116         // and now repaint the uncovered area
1117
1118         // FIXME: We repaint the intersection of these rectangles twice - is
1119         //        it bad? I don't think so as it is rare to scroll the window
1120         //        diagonally anyhow and so adding extra logic to compute
1121         //        rectangle intersection is probably not worth the effort
1122
1123         rect.x = ptSource.x;
1124         rect.y = ptSource.y;
1125
1126         if ( dx )
1127         {
1128             if ( dx < 0 )
1129             {
1130                 // refresh the area along the right border
1131                 rect.x += size.x + dx;
1132                 rect.width = -dx;
1133             }
1134             else
1135             {
1136                 // refresh the area along the left border
1137                 rect.width = dx;
1138             }
1139
1140             rect.height = sizeTotal.y;
1141
1142             wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
1143                        rect.x, rect.y,
1144                        rect.GetRight() + 1, rect.GetBottom() + 1);
1145         }
1146
1147         if ( dy )
1148         {
1149             if ( dy < 0 )
1150             {
1151                 // refresh the area along the bottom border
1152                 rect.y += size.y + dy;
1153                 rect.height = -dy;
1154             }
1155             else
1156             {
1157                 // refresh the area along the top border
1158                 rect.height = dy;
1159             }
1160
1161             rect.width = sizeTotal.x;
1162
1163             wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
1164                        rect.x, rect.y,
1165                        rect.GetRight() + 1, rect.GetBottom() + 1);
1166         }
1167
1168 #if wxUSE_CARET
1169         if ( caret )
1170             caret->Show();
1171 #endif // wxUSE_CARET
1172     }
1173
1174     return rect;
1175 }
1176
1177 // ----------------------------------------------------------------------------
1178 // accelerators and menu hot keys
1179 // ----------------------------------------------------------------------------
1180
1181 #if wxUSE_MENUS
1182     // the last window over which Alt was pressed (used by OnKeyUp)
1183     wxWindow *wxWindow::ms_winLastAltPress = NULL;
1184 #endif // wxUSE_MENUS
1185
1186 #if wxUSE_ACCEL || wxUSE_MENUS
1187
1188 void wxWindow::OnKeyDown(wxKeyEvent& event)
1189 {
1190 #if wxUSE_MENUS
1191     int key = event.GetKeyCode();
1192     if ( !event.ControlDown() && (key == WXK_MENU || key == WXK_F10) )
1193     {
1194         ms_winLastAltPress = this;
1195
1196         // it can't be an accel anyhow
1197         return;
1198     }
1199
1200     ms_winLastAltPress = NULL;
1201 #endif // wxUSE_MENUS
1202
1203 #if wxUSE_ACCEL
1204     for ( wxWindow *win = this; win; win = win->GetParent() )
1205     {
1206         int command = win->GetAcceleratorTable()->GetCommand(event);
1207         if ( command != -1 )
1208         {
1209             wxCommandEvent eventCmd(wxEVT_COMMAND_MENU_SELECTED, command);
1210             if ( win->GetEventHandler()->ProcessEvent(eventCmd) )
1211             {
1212                 // skip "event.Skip()" below
1213                 return;
1214             }
1215         }
1216
1217         if ( win->IsTopLevel() )
1218         {
1219             // try the frame menu bar
1220 #if wxUSE_MENUS
1221             wxFrame *frame = wxDynamicCast(win, wxFrame);
1222             if ( frame )
1223             {
1224                 wxMenuBar *menubar = frame->GetMenuBar();
1225                 if ( menubar && menubar->ProcessAccelEvent(event) )
1226                 {
1227                     // skip "event.Skip()" below
1228                     return;
1229                 }
1230             }
1231 #endif // wxUSE_MENUS
1232
1233             // if it wasn't in a menu, try to find a button
1234             if ( command != -1 )
1235             {
1236                 wxWindow* child = win->FindWindow(command);
1237                 if ( child && wxDynamicCast(child, wxButton) )
1238                 {
1239                     wxCommandEvent eventCmd(wxEVT_COMMAND_BUTTON_CLICKED, command);
1240                     eventCmd.SetEventObject(child);
1241                     if ( child->GetEventHandler()->ProcessEvent(eventCmd) )
1242                     {
1243                         // skip "event.Skip()" below
1244                         return;
1245                     }
1246                 }
1247             }
1248
1249             // don't propagate accels from the child frame to the parent one
1250             break;
1251         }
1252     }
1253 #endif // wxUSE_ACCEL
1254
1255     event.Skip();
1256 }
1257
1258 #endif // wxUSE_ACCEL
1259
1260 #if wxUSE_MENUS
1261
1262 wxMenuBar *wxWindow::GetParentFrameMenuBar() const
1263 {
1264     for ( const wxWindow *win = this; win; win = win->GetParent() )
1265     {
1266         if ( win->IsTopLevel() )
1267         {
1268             wxFrame *frame = wxDynamicCast(win, wxFrame);
1269             if ( frame )
1270             {
1271                 return frame->GetMenuBar();
1272             }
1273
1274             // don't look further - we don't want to return the menubar of the
1275             // parent frame
1276             break;
1277         }
1278     }
1279
1280     return NULL;
1281 }
1282
1283 void wxWindow::OnChar(wxKeyEvent& event)
1284 {
1285     if ( event.AltDown() && !event.ControlDown() )
1286     {
1287         int key = event.GetKeyCode();
1288
1289         wxMenuBar *menubar = GetParentFrameMenuBar();
1290         if ( menubar )
1291         {
1292             int item = menubar->FindNextItemForAccel(-1, key);
1293             if ( item != -1 )
1294             {
1295                 menubar->PopupMenu((size_t)item);
1296
1297                 // skip "event.Skip()" below
1298                 return;
1299             }
1300         }
1301     }
1302
1303     event.Skip();
1304 }
1305
1306 void wxWindow::OnKeyUp(wxKeyEvent& event)
1307 {
1308     int key = event.GetKeyCode();
1309     if ( !event.HasModifiers() && (key == WXK_MENU || key == WXK_F10) )
1310     {
1311         // only process Alt release specially if there were no other key
1312         // presses since Alt had been pressed and if both events happened in
1313         // the same window
1314         if ( ms_winLastAltPress == this )
1315         {
1316             wxMenuBar *menubar = GetParentFrameMenuBar();
1317             if ( menubar && this != menubar )
1318             {
1319                 menubar->SelectMenu(0);
1320             }
1321         }
1322     }
1323     else
1324     {
1325         event.Skip();
1326     }
1327
1328     // in any case reset it
1329     ms_winLastAltPress = NULL;
1330 }
1331
1332 #endif // wxUSE_MENUS
1333
1334 // ----------------------------------------------------------------------------
1335 // MSW-specific section
1336 // ----------------------------------------------------------------------------
1337
1338 #ifdef __WXMSW__
1339
1340 #include "wx/msw/private.h"
1341
1342 WXLRESULT wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1343 {
1344     if ( message == WM_NCHITTEST )
1345     {
1346         // the windows which contain the other windows should let the mouse
1347         // events through, otherwise a window inside a static box would
1348         // never get any events at all
1349         if ( IsStaticBox() )
1350         {
1351             return HTTRANSPARENT;
1352         }
1353     }
1354
1355     return wxWindowNative::MSWWindowProc(message, wParam, lParam);
1356 }
1357
1358 #endif // __WXMSW__
1359