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