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


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