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


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