]> git.saurik.com Git - wxWidgets.git/blob - src/univ/winuniv.cpp
projects / wxWidgets.git / blob
? search:


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