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


0917200b8acfc9d65bebed6001d4b819b1fec0c2
[wxWidgets.git] / src / mac / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: windows.cpp
3 // Purpose: wxWindowMac
4 // Author: AUTHOR
5 // Modified by:
6 // Created: ??/??/98
7 // RCS-ID: $Id$
8 // Copyright: (c) AUTHOR
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "window.h"
14 #endif
15
16 #include "wx/setup.h"
17 #include "wx/menu.h"
18 #include "wx/window.h"
19 #include "wx/dc.h"
20 #include "wx/dcclient.h"
21 #include "wx/utils.h"
22 #include "wx/app.h"
23 #include "wx/panel.h"
24 #include "wx/layout.h"
25 #include "wx/dialog.h"
26 #include "wx/listbox.h"
27 #include "wx/scrolbar.h"
28 #include "wx/statbox.h"
29 #include "wx/button.h"
30 #include "wx/settings.h"
31 #include "wx/msgdlg.h"
32 #include "wx/frame.h"
33 #include "wx/notebook.h"
34 #include "wx/tabctrl.h"
35 #include "wx/tooltip.h"
36 #include "wx/statusbr.h"
37 #include "wx/menuitem.h"
38 #include "wx/log.h"
39
40 #if wxUSE_CARET
41 #include "wx/caret.h"
42 #endif // wxUSE_CARET
43
44 #define wxWINDOW_HSCROLL 5998
45 #define wxWINDOW_VSCROLL 5997
46 #define MAC_SCROLLBAR_SIZE 16
47
48 #include "wx/mac/uma.h"
49
50 #if wxUSE_DRAG_AND_DROP
51 #include "wx/dnd.h"
52 #endif
53
54 #include <string.h>
55
56 extern wxList wxPendingDelete;
57 wxWindowMac* gFocusWindow = NULL ;
58
59 #ifdef __WXUNIVERSAL__
60 IMPLEMENT_ABSTRACT_CLASS(wxWindowMac, wxWindowBase)
61 #else // __WXMAC__
62 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
63 #endif // __WXUNIVERSAL__/__WXMAC__
64
65 #if !USE_SHARED_LIBRARY
66
67 BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
68 EVT_NC_PAINT(wxWindowMac::OnNcPaint)
69 EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
70 EVT_SYS_COLOUR_CHANGED(wxWindowMac::OnSysColourChanged)
71 EVT_INIT_DIALOG(wxWindowMac::OnInitDialog)
72 EVT_IDLE(wxWindowMac::OnIdle)
73 EVT_SET_FOCUS(wxWindowMac::OnSetFocus)
74 END_EVENT_TABLE()
75
76 #endif
77
78 #define wxMAC_DEBUG_REDRAW 0
79 #ifndef wxMAC_DEBUG_REDRAW
80 #define wxMAC_DEBUG_REDRAW 0
81 #endif
82
83 #define wxMAC_USE_THEME_BORDER 0
84
85
86 // ===========================================================================
87 // implementation
88 // ===========================================================================
89
90
91 // ----------------------------------------------------------------------------
92 // constructors and such
93 // ----------------------------------------------------------------------------
94
95 void wxWindowMac::Init()
96 {
97 // generic
98 InitBase();
99
100 // MSW specific
101 m_doubleClickAllowed = 0;
102 m_winCaptured = FALSE;
103
104 m_isBeingDeleted = FALSE;
105
106 m_useCtl3D = FALSE;
107 m_mouseInWindow = FALSE;
108
109 m_xThumbSize = 0;
110 m_yThumbSize = 0;
111 m_backgroundTransparent = FALSE;
112
113 // as all windows are created with WS_VISIBLE style...
114 m_isShown = TRUE;
115
116 m_x = 0;
117 m_y = 0 ;
118 m_width = 0 ;
119 m_height = 0 ;
120
121 m_hScrollBar = NULL ;
122 m_vScrollBar = NULL ;
123
124 #if wxUSE_DRAG_AND_DROP
125 m_pDropTarget = NULL;
126 #endif
127 }
128
129 // Destructor
130 wxWindowMac::~wxWindowMac()
131 {
132 // deleting a window while it is shown invalidates the region
133 if ( IsShown() ) {
134 wxWindowMac* iter = this ;
135 while( iter ) {
136 if ( iter->IsTopLevel() )
137 {
138 Refresh() ;
139 break ;
140 }
141 iter = iter->GetParent() ;
142
143 }
144 }
145
146 m_isBeingDeleted = TRUE;
147
148 if ( s_lastMouseWindow == this )
149 {
150 s_lastMouseWindow = NULL ;
151 }
152
153 if ( gFocusWindow == this )
154 {
155 gFocusWindow = NULL ;
156 }
157
158 if ( m_parent )
159 m_parent->RemoveChild(this);
160
161 DestroyChildren();
162 }
163
164 // Constructor
165 bool wxWindowMac::Create(wxWindowMac *parent, wxWindowID id,
166 const wxPoint& pos,
167 const wxSize& size,
168 long style,
169 const wxString& name)
170 {
171 wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindowMac without parent") );
172
173 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
174 return FALSE;
175
176 parent->AddChild(this);
177
178 m_x = (int)pos.x;
179 m_y = (int)pos.y;
180 AdjustForParentClientOrigin(m_x, m_y, wxSIZE_USE_EXISTING);
181 m_width = WidthDefault( size.x );
182 m_height = HeightDefault( size.y ) ;
183 #ifndef __WXUNIVERSAL__
184 if ( ! IsKindOf( CLASSINFO ( wxControl ) ) && ! IsKindOf( CLASSINFO( wxStatusBar ) ) )
185 {
186 MacCreateScrollBars( style ) ;
187 }
188 #endif
189 return TRUE;
190 }
191
192 void wxWindowMac::SetFocus()
193 {
194 if ( gFocusWindow == this )
195 return ;
196
197 if ( AcceptsFocus() )
198 {
199 if (gFocusWindow )
200 {
201 #if wxUSE_CARET
202 // Deal with caret
203 if ( gFocusWindow->m_caret )
204 {
205 gFocusWindow->m_caret->OnKillFocus();
206 }
207 #endif // wxUSE_CARET
208 #ifndef __WXUNIVERSAL__
209 wxControl* control = wxDynamicCast( gFocusWindow , wxControl ) ;
210 if ( control && control->GetMacControl() )
211 {
212 UMASetKeyboardFocus( gFocusWindow->MacGetRootWindow() , control->GetMacControl() , kControlFocusNoPart ) ;
213 control->MacRedrawControl() ;
214 }
215 #endif
216 wxFocusEvent event(wxEVT_KILL_FOCUS, gFocusWindow->m_windowId);
217 event.SetEventObject(gFocusWindow);
218 gFocusWindow->GetEventHandler()->ProcessEvent(event) ;
219 }
220 gFocusWindow = this ;
221 {
222 #if wxUSE_CARET
223 // Deal with caret
224 if ( m_caret )
225 {
226 m_caret->OnSetFocus();
227 }
228 #endif // wxUSE_CARET
229 // panel wants to track the window which was the last to have focus in it
230 wxChildFocusEvent eventFocus(this);
231 GetEventHandler()->ProcessEvent(eventFocus);
232
233 #ifndef __WXUNIVERSAL__
234 wxControl* control = wxDynamicCast( gFocusWindow , wxControl ) ;
235 if ( control && control->GetMacControl() )
236 {
237 UMASetKeyboardFocus( gFocusWindow->MacGetRootWindow() , control->GetMacControl() , kControlEditTextPart ) ;
238 }
239 #endif
240 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
241 event.SetEventObject(this);
242 GetEventHandler()->ProcessEvent(event) ;
243 }
244 }
245 }
246
247 bool wxWindowMac::Enable(bool enable)
248 {
249 if ( !wxWindowBase::Enable(enable) )
250 return FALSE;
251
252 MacSuperEnabled( enable ) ;
253
254 return TRUE;
255 }
256
257 void wxWindowMac::CaptureMouse()
258 {
259 wxTheApp->s_captureWindow = this ;
260 }
261
262 wxWindow* wxWindowBase::GetCapture()
263 {
264 return wxTheApp->s_captureWindow ;
265 }
266
267 void wxWindowMac::ReleaseMouse()
268 {
269 wxTheApp->s_captureWindow = NULL ;
270 }
271
272 #if wxUSE_DRAG_AND_DROP
273
274 void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
275 {
276 if ( m_pDropTarget != 0 ) {
277 delete m_pDropTarget;
278 }
279
280 m_pDropTarget = pDropTarget;
281 if ( m_pDropTarget != 0 )
282 {
283 // TODO
284 }
285 }
286
287 #endif
288
289 // Old style file-manager drag&drop
290 void wxWindowMac::DragAcceptFiles(bool accept)
291 {
292 // TODO
293 }
294
295 // Get total size
296 void wxWindowMac::DoGetSize(int *x, int *y) const
297 {
298 if(x) *x = m_width ;
299 if(y) *y = m_height ;
300 }
301
302 void wxWindowMac::DoGetPosition(int *x, int *y) const
303 {
304 int xx,yy;
305
306 xx = m_x ;
307 yy = m_y ;
308 if ( !IsTopLevel() && GetParent())
309 {
310 wxPoint pt(GetParent()->GetClientAreaOrigin());
311 xx -= pt.x;
312 yy -= pt.y;
313 }
314 if(x) *x = xx;
315 if(y) *y = yy;
316 }
317
318 #if wxUSE_MENUS
319 bool wxWindowMac::DoPopupMenu(wxMenu *menu, int x, int y)
320 {
321 menu->SetInvokingWindow(this);
322 menu->UpdateUI();
323 ClientToScreen( &x , &y ) ;
324
325 ::InsertMenu( menu->GetHMenu() , -1 ) ;
326 long menuResult = ::PopUpMenuSelect(menu->GetHMenu() ,y,x, 0) ;
327 menu->MacMenuSelect( this , TickCount() , HiWord(menuResult) , LoWord(menuResult) ) ;
328 ::DeleteMenu( menu->MacGetMenuId() ) ;
329 menu->SetInvokingWindow(NULL);
330
331 return TRUE;
332 }
333 #endif
334
335 void wxWindowMac::DoScreenToClient(int *x, int *y) const
336 {
337 WindowRef window = MacGetRootWindow() ;
338
339 Point localwhere = {0,0} ;
340
341 if(x) localwhere.h = * x ;
342 if(y) localwhere.v = * y ;
343
344 GrafPtr port ;
345 ::GetPort( &port ) ;
346 ::SetPort( UMAGetWindowPort( window ) ) ;
347 ::GlobalToLocal( &localwhere ) ;
348 ::SetPort( port ) ;
349
350 if(x) *x = localwhere.h ;
351 if(y) *y = localwhere.v ;
352
353 MacRootWindowToClient( x , y ) ;
354 }
355
356 void wxWindowMac::DoClientToScreen(int *x, int *y) const
357 {
358 WindowRef window = MacGetRootWindow() ;
359
360 MacClientToRootWindow( x , y ) ;
361
362 Point localwhere = { 0,0 };
363 if(x) localwhere.h = * x ;
364 if(y) localwhere.v = * y ;
365
366 GrafPtr port ;
367 ::GetPort( &port ) ;
368 ::SetPort( UMAGetWindowPort( window ) ) ;
369
370 ::LocalToGlobal( &localwhere ) ;
371 ::SetPort( port ) ;
372 if(x) *x = localwhere.h ;
373 if(y) *y = localwhere.v ;
374 }
375
376 void wxWindowMac::MacClientToRootWindow( int *x , int *y ) const
377 {
378 wxPoint origin = GetClientAreaOrigin() ;
379 if(x) *x += origin.x ;
380 if(y) *y += origin.y ;
381
382 MacWindowToRootWindow( x , y ) ;
383 }
384
385 void wxWindowMac::MacRootWindowToClient( int *x , int *y ) const
386 {
387 wxPoint origin = GetClientAreaOrigin() ;
388 MacRootWindowToWindow( x , y ) ;
389 if(x) *x -= origin.x ;
390 if(y) *y -= origin.y ;
391 }
392
393 void wxWindowMac::MacWindowToRootWindow( int *x , int *y ) const
394 {
395 if ( !IsTopLevel() )
396 {
397 if(x) *x += m_x ;
398 if(y) *y += m_y ;
399 GetParent()->MacWindowToRootWindow( x , y ) ;
400 }
401 }
402
403 void wxWindowMac::MacRootWindowToWindow( int *x , int *y ) const
404 {
405 if ( !IsTopLevel() )
406 {
407 if(x) *x -= m_x ;
408 if(y) *y -= m_y ;
409 GetParent()->MacRootWindowToWindow( x , y ) ;
410 }
411 }
412
413 bool wxWindowMac::SetCursor(const wxCursor& cursor)
414 {
415 if (m_cursor == cursor)
416 return FALSE;
417
418 if (wxNullCursor == cursor)
419 {
420 if ( ! wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ) )
421 return FALSE ;
422 }
423 else
424 {
425 if ( ! wxWindowBase::SetCursor( cursor ) )
426 return FALSE ;
427 }
428
429 wxASSERT_MSG( m_cursor.Ok(),
430 wxT("cursor must be valid after call to the base version"));
431
432 Point pt ;
433 wxWindowMac *mouseWin ;
434 GetMouse( &pt ) ;
435
436 // Change the cursor NOW if we're within the correct window
437
438 if ( MacGetWindowFromPoint( wxPoint( pt.h , pt.v ) , &mouseWin ) )
439 {
440 if ( mouseWin == this && !wxIsBusy() )
441 {
442 m_cursor.MacInstall() ;
443 }
444 }
445
446 return TRUE ;
447 }
448
449
450 // Get size *available for subwindows* i.e. excluding menu bar etc.
451 void wxWindowMac::DoGetClientSize(int *x, int *y) const
452 {
453 int ww, hh;
454 ww = m_width ;
455 hh = m_height ;
456
457 ww -= MacGetLeftBorderSize( ) + MacGetRightBorderSize( ) ;
458 hh -= MacGetTopBorderSize( ) + MacGetBottomBorderSize( );
459
460 if ( (m_vScrollBar && m_vScrollBar->IsShown()) || (m_hScrollBar && m_hScrollBar->IsShown()) )
461 {
462 int x1 = 0 ;
463 int y1 = 0 ;
464 int w = m_width ;
465 int h = m_height ;
466
467 MacClientToRootWindow( &x1 , &y1 ) ;
468 MacClientToRootWindow( &w , &h ) ;
469
470 wxWindowMac *iter = (wxWindowMac*)this ;
471
472 int totW = 10000 , totH = 10000;
473 while( iter )
474 {
475 if ( iter->IsTopLevel() )
476 {
477 totW = iter->m_width ;
478 totH = iter->m_height ;
479 break ;
480 }
481
482 iter = iter->GetParent() ;
483 }
484
485 if (m_hScrollBar && m_hScrollBar->IsShown() )
486 {
487 hh -= MAC_SCROLLBAR_SIZE;
488 if ( h-y1 >= totH )
489 {
490 hh += 1 ;
491 }
492 }
493 if (m_vScrollBar && m_vScrollBar->IsShown() )
494 {
495 ww -= MAC_SCROLLBAR_SIZE;
496 if ( w-x1 >= totW )
497 {
498 ww += 1 ;
499 }
500 }
501 }
502 if(x) *x = ww;
503 if(y) *y = hh;
504 }
505
506
507 // ----------------------------------------------------------------------------
508 // tooltips
509 // ----------------------------------------------------------------------------
510
511 #if wxUSE_TOOLTIPS
512
513 void wxWindowMac::DoSetToolTip(wxToolTip *tooltip)
514 {
515 wxWindowBase::DoSetToolTip(tooltip);
516
517 if ( m_tooltip )
518 m_tooltip->SetWindow(this);
519 }
520
521 #endif // wxUSE_TOOLTIPS
522
523 void wxWindowMac::DoMoveWindow(int x, int y, int width, int height)
524 {
525 int former_x = m_x ;
526 int former_y = m_y ;
527 int former_w = m_width ;
528 int former_h = m_height ;
529
530 int actualWidth = width;
531 int actualHeight = height;
532 int actualX = x;
533 int actualY = y;
534
535 if ((m_minWidth != -1) && (actualWidth < m_minWidth))
536 actualWidth = m_minWidth;
537 if ((m_minHeight != -1) && (actualHeight < m_minHeight))
538 actualHeight = m_minHeight;
539 if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
540 actualWidth = m_maxWidth;
541 if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
542 actualHeight = m_maxHeight;
543
544 bool doMove = false ;
545 bool doResize = false ;
546
547 if ( actualX != former_x || actualY != former_y )
548 {
549 doMove = true ;
550 }
551 if ( actualWidth != former_w || actualHeight != former_h )
552 {
553 doResize = true ;
554 }
555
556 if ( doMove || doResize )
557 {
558 // erase former position
559
560 Refresh() ;
561
562 m_x = actualX ;
563 m_y = actualY ;
564 m_width = actualWidth ;
565 m_height = actualHeight ;
566
567 // erase new position
568
569 Refresh() ;
570 if ( doMove )
571 wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
572
573 MacRepositionScrollBars() ;
574 if ( doMove )
575 {
576 wxPoint point(m_x, m_y);
577 wxMoveEvent event(point, m_windowId);
578 event.SetEventObject(this);
579 GetEventHandler()->ProcessEvent(event) ;
580 }
581 if ( doResize )
582 {
583 MacRepositionScrollBars() ;
584 wxSize size(m_width, m_height);
585 wxSizeEvent event(size, m_windowId);
586 event.SetEventObject(this);
587 GetEventHandler()->ProcessEvent(event);
588 }
589 }
590
591 }
592
593 // set the size of the window: if the dimensions are positive, just use them,
594 // but if any of them is equal to -1, it means that we must find the value for
595 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
596 // which case -1 is a valid value for x and y)
597 //
598 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
599 // the width/height to best suit our contents, otherwise we reuse the current
600 // width/height
601 void wxWindowMac::DoSetSize(int x, int y, int width, int height, int sizeFlags)
602 {
603 // get the current size and position...
604 int currentX, currentY;
605 GetPosition(&currentX, &currentY);
606
607 int currentW,currentH;
608 GetSize(&currentW, &currentH);
609
610 // ... and don't do anything (avoiding flicker) if it's already ok
611 if ( x == currentX && y == currentY &&
612 width == currentW && height == currentH )
613 {
614 MacRepositionScrollBars() ; // we might have a real position shift
615 return;
616 }
617
618 if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
619 x = currentX;
620 if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
621 y = currentY;
622
623 AdjustForParentClientOrigin(x, y, sizeFlags);
624
625 wxSize size(-1, -1);
626 if ( width == -1 )
627 {
628 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
629 {
630 size = DoGetBestSize();
631 width = size.x;
632 }
633 else
634 {
635 // just take the current one
636 width = currentW;
637 }
638 }
639
640 if ( height == -1 )
641 {
642 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
643 {
644 if ( size.x == -1 )
645 {
646 size = DoGetBestSize();
647 }
648 //else: already called DoGetBestSize() above
649
650 height = size.y;
651 }
652 else
653 {
654 // just take the current one
655 height = currentH;
656 }
657 }
658
659 DoMoveWindow(x, y, width, height);
660
661 }
662 // For implementation purposes - sometimes decorations make the client area
663 // smaller
664
665 wxPoint wxWindowMac::GetClientAreaOrigin() const
666 {
667 return wxPoint(MacGetLeftBorderSize( ) , MacGetTopBorderSize( ) );
668 }
669
670 void wxWindow::SetTitle(const wxString& title)
671 {
672 m_label = title ;
673 }
674
675 wxString wxWindow::GetTitle() const
676 {
677 return m_label ;
678 }
679
680 bool wxWindowMac::Show(bool show)
681 {
682 if ( !wxWindowBase::Show(show) )
683 return FALSE;
684
685 MacSuperShown( show ) ;
686 if ( !show )
687 {
688 WindowRef window = MacGetRootWindow() ;
689 wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
690 if ( win && !win->m_isBeingDeleted )
691 Refresh() ;
692 }
693 else
694 {
695 Refresh() ;
696 }
697
698 return TRUE;
699 }
700
701 void wxWindowMac::MacSuperShown( bool show )
702 {
703 wxNode *node = GetChildren().First();
704 while ( node )
705 {
706 wxWindowMac *child = (wxWindowMac *)node->Data();
707 if ( child->m_isShown )
708 child->MacSuperShown( show ) ;
709 node = node->Next();
710 }
711 }
712
713 void wxWindowMac::MacSuperEnabled( bool enabled )
714 {
715 if ( !IsTopLevel() )
716 {
717 // to be absolutely correct we'd have to invalidate (with eraseBkground
718 // because unter MacOSX the frames are drawn with an addXXX mode)
719 // the borders area
720 }
721 wxNode *node = GetChildren().First();
722 while ( node )
723 {
724 wxWindowMac *child = (wxWindowMac *)node->Data();
725 if ( child->m_isShown )
726 child->MacSuperEnabled( enabled ) ;
727 node = node->Next();
728 }
729 }
730
731 bool wxWindowMac::MacIsReallyShown() const
732 {
733 if ( m_isShown && (m_parent != NULL) ) {
734 return m_parent->MacIsReallyShown();
735 }
736 return m_isShown;
737 /*
738 bool status = m_isShown ;
739 wxWindowMac * win = this ;
740 while ( status && win->m_parent != NULL )
741 {
742 win = win->m_parent ;
743 status = win->m_isShown ;
744 }
745 return status ;
746 */
747 }
748
749 int wxWindowMac::GetCharHeight() const
750 {
751 wxClientDC dc ( (wxWindowMac*)this ) ;
752 return dc.GetCharHeight() ;
753 }
754
755 int wxWindowMac::GetCharWidth() const
756 {
757 wxClientDC dc ( (wxWindowMac*)this ) ;
758 return dc.GetCharWidth() ;
759 }
760
761 void wxWindowMac::GetTextExtent(const wxString& string, int *x, int *y,
762 int *descent, int *externalLeading, const wxFont *theFont ) const
763 {
764 const wxFont *fontToUse = theFont;
765 if ( !fontToUse )
766 fontToUse = &m_font;
767
768 wxClientDC dc( (wxWindowMac*) this ) ;
769 long lx,ly,ld,le ;
770 dc.GetTextExtent( string , &lx , &ly , &ld, &le, (wxFont *)fontToUse ) ;
771 if ( externalLeading )
772 *externalLeading = le ;
773 if ( descent )
774 *descent = ld ;
775 if ( x )
776 *x = lx ;
777 if ( y )
778 *y = ly ;
779 }
780
781 /*
782 * Rect is given in client coordinates, for further reading, read wxTopLevelWindowMac::InvalidateRect
783 * we always intersect with the entire window, not only with the client area
784 */
785
786 void wxWindowMac::Refresh(bool eraseBack, const wxRect *rect)
787 {
788 if ( MacGetTopLevelWindow() == NULL )
789 return ;
790
791 wxPoint client ;
792 client = GetClientAreaOrigin( ) ;
793 Rect clientrect = { -client.y , -client.x , m_height - client.y , m_width - client.x} ;
794 if ( rect )
795 {
796 Rect r = { rect->y , rect->x , rect->y + rect->height , rect->x + rect->width } ;
797 SectRect( &clientrect , &r , &clientrect ) ;
798 }
799 if ( !EmptyRect( &clientrect ) )
800 {
801 int top = 0 , left = 0 ;
802
803 MacClientToRootWindow( &left , &top ) ;
804 OffsetRect( &clientrect , left , top ) ;
805
806 MacGetTopLevelWindow()->MacInvalidate( &clientrect , eraseBack ) ;
807 }
808 }
809
810 #if wxUSE_CARET && WXWIN_COMPATIBILITY
811 // ---------------------------------------------------------------------------
812 // Caret manipulation
813 // ---------------------------------------------------------------------------
814
815 void wxWindowMac::CreateCaret(int w, int h)
816 {
817 SetCaret(new wxCaret(this, w, h));
818 }
819
820 void wxWindowMac::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
821 {
822 wxFAIL_MSG("not implemented");
823 }
824
825 void wxWindowMac::ShowCaret(bool show)
826 {
827 wxCHECK_RET( m_caret, "no caret to show" );
828
829 m_caret->Show(show);
830 }
831
832 void wxWindowMac::DestroyCaret()
833 {
834 SetCaret(NULL);
835 }
836
837 void wxWindowMac::SetCaretPos(int x, int y)
838 {
839 wxCHECK_RET( m_caret, "no caret to move" );
840
841 m_caret->Move(x, y);
842 }
843
844 void wxWindowMac::GetCaretPos(int *x, int *y) const
845 {
846 wxCHECK_RET( m_caret, "no caret to get position of" );
847
848 m_caret->GetPosition(x, y);
849 }
850 #endif // wxUSE_CARET
851
852 wxWindowMac *wxGetActiveWindow()
853 {
854 // actually this is a windows-only concept
855 return NULL;
856 }
857
858 // Coordinates relative to the window
859 void wxWindowMac::WarpPointer (int x_pos, int y_pos)
860 {
861 // We really dont move the mouse programmatically under mac
862 }
863
864 const wxBrush& wxWindowMac::MacGetBackgroundBrush()
865 {
866 if ( m_backgroundColour == wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE) )
867 {
868 m_macBackgroundBrush.SetMacTheme( kThemeBrushDocumentWindowBackground ) ;
869 }
870 else if ( m_backgroundColour == wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE ) )
871 {
872 // on mac we have the difficult situation, that 3dface gray can be different colours, depending whether
873 // it is on a notebook panel or not, in order to take care of that we walk up the hierarchy until we have
874 // either a non gray background color or a non control window
875
876 WindowRef window = MacGetRootWindow() ;
877
878 wxWindowMac* parent = GetParent() ;
879 while( parent )
880 {
881 if ( parent->MacGetRootWindow() != window )
882 {
883 // we are in a different window on the mac system
884 parent = NULL ;
885 break ;
886 }
887
888 {
889 if ( parent->m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE )
890 && parent->m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE) )
891 {
892 // if we have any other colours in the hierarchy
893 m_macBackgroundBrush.SetColour( parent->m_backgroundColour ) ;
894 break ;
895 }
896 // if we have the normal colours in the hierarchy but another control etc. -> use it's background
897 if ( parent->IsKindOf( CLASSINFO( wxNotebook ) ) || parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
898 {
899 Rect extent = { 0 , 0 , 0 , 0 } ;
900 int x , y ;
901 x = y = 0 ;
902 wxSize size = GetSize() ;
903 parent->MacClientToRootWindow( &x , &y ) ;
904 extent.left = x ;
905 extent.top = y ;
906 extent.top-- ;
907 extent.right = x + size.x ;
908 extent.bottom = y + size.y ;
909 m_macBackgroundBrush.SetMacThemeBackground( kThemeBackgroundTabPane , extent ) ; // todo eventually change for inactive
910 break ;
911 }
912 }
913 parent = parent->GetParent() ;
914 }
915 if ( !parent )
916 {
917 m_macBackgroundBrush.SetMacTheme( kThemeBrushDialogBackgroundActive ) ; // todo eventually change for inactive
918 }
919 }
920 else
921 {
922 m_macBackgroundBrush.SetColour( m_backgroundColour ) ;
923 }
924
925 return m_macBackgroundBrush ;
926
927 }
928
929 void wxWindowMac::OnEraseBackground(wxEraseEvent& event)
930 {
931 event.GetDC()->Clear() ;
932 }
933
934 void wxWindowMac::OnNcPaint( wxNcPaintEvent& event )
935 {
936 wxWindowDC dc(this) ;
937 wxMacPortSetter helper(&dc) ;
938
939 MacPaintBorders( dc.m_macLocalOrigin.h , dc.m_macLocalOrigin.v) ;
940 }
941
942 int wxWindowMac::GetScrollPos(int orient) const
943 {
944 if ( orient == wxHORIZONTAL )
945 {
946 if ( m_hScrollBar )
947 return m_hScrollBar->GetThumbPosition() ;
948 }
949 else
950 {
951 if ( m_vScrollBar )
952 return m_vScrollBar->GetThumbPosition() ;
953 }
954 return 0;
955 }
956
957 // This now returns the whole range, not just the number
958 // of positions that we can scroll.
959 int wxWindowMac::GetScrollRange(int orient) const
960 {
961 if ( orient == wxHORIZONTAL )
962 {
963 if ( m_hScrollBar )
964 return m_hScrollBar->GetRange() ;
965 }
966 else
967 {
968 if ( m_vScrollBar )
969 return m_vScrollBar->GetRange() ;
970 }
971 return 0;
972 }
973
974 int wxWindowMac::GetScrollThumb(int orient) const
975 {
976 if ( orient == wxHORIZONTAL )
977 {
978 if ( m_hScrollBar )
979 return m_hScrollBar->GetThumbSize() ;
980 }
981 else
982 {
983 if ( m_vScrollBar )
984 return m_vScrollBar->GetThumbSize() ;
985 }
986 return 0;
987 }
988
989 void wxWindowMac::SetScrollPos(int orient, int pos, bool refresh)
990 {
991 if ( orient == wxHORIZONTAL )
992 {
993 if ( m_hScrollBar )
994 m_hScrollBar->SetThumbPosition( pos ) ;
995 }
996 else
997 {
998 if ( m_vScrollBar )
999 m_vScrollBar->SetThumbPosition( pos ) ;
1000 }
1001 }
1002
1003 void wxWindowMac::MacPaintBorders( int left , int top )
1004 {
1005 if( IsTopLevel() )
1006 return ;
1007
1008 RGBColor white = { 0xFFFF, 0xFFFF , 0xFFFF } ;
1009 RGBColor black = { 0x0000, 0x0000 , 0x0000 } ;
1010 RGBColor face = { 0xDDDD, 0xDDDD , 0xDDDD } ;
1011 RGBColor shadow = { 0x4444, 0x4444 , 0x4444 } ;
1012 PenNormal() ;
1013
1014 if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER) )
1015 {
1016 #if wxMAC_USE_THEME_BORDER
1017 Rect rect = { top , left , m_height + top , m_width + left } ;
1018 SInt32 border = 0 ;
1019 /*
1020 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
1021 InsetRect( &rect , border , border );
1022 DrawThemeListBoxFrame(&rect,IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
1023 */
1024
1025 DrawThemePrimaryGroup(&rect ,IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
1026 #else
1027 bool sunken = HasFlag( wxSUNKEN_BORDER ) ;
1028 RGBForeColor( &face );
1029 MoveTo( left + 0 , top + m_height - 2 );
1030 LineTo( left + 0 , top + 0 );
1031 LineTo( left + m_width - 2 , top + 0 );
1032
1033 MoveTo( left + 2 , top + m_height - 3 );
1034 LineTo( left + m_width - 3 , top + m_height - 3 );
1035 LineTo( left + m_width - 3 , top + 2 );
1036
1037 RGBForeColor( sunken ? &face : &black );
1038 MoveTo( left + 0 , top + m_height - 1 );
1039 LineTo( left + m_width - 1 , top + m_height - 1 );
1040 LineTo( left + m_width - 1 , top + 0 );
1041
1042 RGBForeColor( sunken ? &shadow : &white );
1043 MoveTo( left + 1 , top + m_height - 3 );
1044 LineTo( left + 1, top + 1 );
1045 LineTo( left + m_width - 3 , top + 1 );
1046
1047 RGBForeColor( sunken ? &white : &shadow );
1048 MoveTo( left + 1 , top + m_height - 2 );
1049 LineTo( left + m_width - 2 , top + m_height - 2 );
1050 LineTo( left + m_width - 2 , top + 1 );
1051
1052 RGBForeColor( sunken ? &black : &face );
1053 MoveTo( left + 2 , top + m_height - 4 );
1054 LineTo( left + 2 , top + 2 );
1055 LineTo( left + m_width - 4 , top + 2 );
1056 #endif
1057 }
1058 else if (HasFlag(wxSIMPLE_BORDER))
1059 {
1060 Rect rect = { top , left , m_height + top , m_width + left } ;
1061 RGBForeColor( &black ) ;
1062 FrameRect( &rect ) ;
1063 }
1064 }
1065
1066 // New function that will replace some of the above.
1067 void wxWindowMac::SetScrollbar(int orient, int pos, int thumbVisible,
1068 int range, bool refresh)
1069 {
1070 if ( orient == wxHORIZONTAL )
1071 {
1072 if ( m_hScrollBar )
1073 {
1074 if ( range == 0 || thumbVisible >= range )
1075 {
1076 if ( m_hScrollBar->IsShown() )
1077 m_hScrollBar->Show(false) ;
1078 }
1079 else
1080 {
1081 if ( !m_hScrollBar->IsShown() )
1082 m_hScrollBar->Show(true) ;
1083 m_hScrollBar->SetScrollbar( pos , thumbVisible , range , thumbVisible , refresh ) ;
1084 }
1085 }
1086 }
1087 else
1088 {
1089 if ( m_vScrollBar )
1090 {
1091 if ( range == 0 || thumbVisible >= range )
1092 {
1093 if ( m_vScrollBar->IsShown() )
1094 m_vScrollBar->Show(false) ;
1095 }
1096 else
1097 {
1098 if ( !m_vScrollBar->IsShown() )
1099 m_vScrollBar->Show(true) ;
1100 m_vScrollBar->SetScrollbar( pos , thumbVisible , range , thumbVisible , refresh ) ;
1101 }
1102 }
1103 }
1104 MacRepositionScrollBars() ;
1105 }
1106
1107 // Does a physical scroll
1108 void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
1109 {
1110 wxClientDC dc(this) ;
1111 wxMacPortSetter helper(&dc) ;
1112
1113 {
1114 int width , height ;
1115 GetClientSize( &width , &height ) ;
1116
1117 Rect scrollrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) , dc.YLOG2DEVMAC(height) , dc.XLOG2DEVMAC(width) } ;
1118 RgnHandle updateRgn = NewRgn() ;
1119 ClipRect( &scrollrect ) ;
1120 if ( rect )
1121 {
1122 Rect r = { dc.YLOG2DEVMAC(rect->y) , dc.XLOG2DEVMAC(rect->x) , dc.YLOG2DEVMAC(rect->y + rect->height) ,
1123 dc.XLOG2DEVMAC(rect->x + rect->width) } ;
1124 SectRect( &scrollrect , &r , &scrollrect ) ;
1125 }
1126 ScrollRect( &scrollrect , dx , dy , updateRgn ) ;
1127 InvalWindowRgn( MacGetRootWindow() , updateRgn ) ;
1128 DisposeRgn( updateRgn ) ;
1129 }
1130
1131 for (wxNode *node = GetChildren().First(); node; node = node->Next())
1132 {
1133 wxWindowMac *child = (wxWindowMac*)node->Data();
1134 if (child == m_vScrollBar) continue;
1135 if (child == m_hScrollBar) continue;
1136 if (child->IsTopLevel()) continue;
1137 int x,y;
1138 child->GetPosition( &x, &y );
1139 int w,h;
1140 child->GetSize( &w, &h );
1141 child->SetSize( x+dx, y+dy, w, h );
1142 }
1143
1144 }
1145
1146 void wxWindowMac::MacOnScroll(wxScrollEvent &event )
1147 {
1148 if ( event.m_eventObject == m_vScrollBar || event.m_eventObject == m_hScrollBar )
1149 {
1150 wxScrollWinEvent wevent;
1151 wevent.SetPosition(event.GetPosition());
1152 wevent.SetOrientation(event.GetOrientation());
1153 wevent.m_eventObject = this;
1154
1155 if (event.m_eventType == wxEVT_SCROLL_TOP) {
1156 wevent.m_eventType = wxEVT_SCROLLWIN_TOP;
1157 } else
1158 if (event.m_eventType == wxEVT_SCROLL_BOTTOM) {
1159 wevent.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
1160 } else
1161 if (event.m_eventType == wxEVT_SCROLL_LINEUP) {
1162 wevent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
1163 } else
1164 if (event.m_eventType == wxEVT_SCROLL_LINEDOWN) {
1165 wevent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
1166 } else
1167 if (event.m_eventType == wxEVT_SCROLL_PAGEUP) {
1168 wevent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
1169 } else
1170 if (event.m_eventType == wxEVT_SCROLL_PAGEDOWN) {
1171 wevent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
1172 } else
1173 if (event.m_eventType == wxEVT_SCROLL_THUMBTRACK) {
1174 wevent.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK;
1175 }
1176
1177 GetEventHandler()->ProcessEvent(wevent);
1178 }
1179 }
1180
1181 // Get the window with the focus
1182 wxWindowMac *wxWindowBase::FindFocus()
1183 {
1184 return gFocusWindow ;
1185 }
1186
1187 #if WXWIN_COMPATIBILITY
1188 // If nothing defined for this, try the parent.
1189 // E.g. we may be a button loaded from a resource, with no callback function
1190 // defined.
1191 void wxWindowMac::OnCommand(wxWindowMac& win, wxCommandEvent& event)
1192 {
1193 if ( GetEventHandler()->ProcessEvent(event) )
1194 return;
1195 if ( m_parent )
1196 m_parent->GetEventHandler()->OnCommand(win, event);
1197 }
1198 #endif // WXWIN_COMPATIBILITY_2
1199
1200 #if WXWIN_COMPATIBILITY
1201 wxObject* wxWindowMac::GetChild(int number) const
1202 {
1203 // Return a pointer to the Nth object in the Panel
1204 wxNode *node = GetChildren().First();
1205 int n = number;
1206 while (node && n--)
1207 node = node->Next();
1208 if ( node )
1209 {
1210 wxObject *obj = (wxObject *)node->Data();
1211 return(obj);
1212 }
1213 else
1214 return NULL;
1215 }
1216 #endif // WXWIN_COMPATIBILITY
1217
1218 void wxWindowMac::OnSetFocus(wxFocusEvent& event)
1219 {
1220 // panel wants to track the window which was the last to have focus in it,
1221 // so we want to set ourselves as the window which last had focus
1222 //
1223 // notice that it's also important to do it upwards the tree becaus
1224 // otherwise when the top level panel gets focus, it won't set it back to
1225 // us, but to some other sibling
1226
1227 // CS:don't know if this is still needed:
1228 //wxChildFocusEvent eventFocus(this);
1229 //(void)GetEventHandler()->ProcessEvent(eventFocus);
1230
1231 event.Skip();
1232 }
1233
1234 void wxWindowMac::Clear()
1235 {
1236 wxClientDC dc(this);
1237 wxBrush brush(GetBackgroundColour(), wxSOLID);
1238 dc.SetBackground(brush);
1239 dc.Clear();
1240 }
1241
1242 // Setup background and foreground colours correctly
1243 void wxWindowMac::SetupColours()
1244 {
1245 if ( GetParent() )
1246 SetBackgroundColour(GetParent()->GetBackgroundColour());
1247 }
1248
1249 void wxWindowMac::OnIdle(wxIdleEvent& event)
1250 {
1251 /*
1252 // Check if we need to send a LEAVE event
1253 if (m_mouseInWindow)
1254 {
1255 POINT pt;
1256 ::GetCursorPos(&pt);
1257 if (::WindowFromPoint(pt) != (HWND) GetHWND())
1258 {
1259 // Generate a LEAVE event
1260 m_mouseInWindow = FALSE;
1261 MSWOnMouseLeave(pt.x, pt.y, 0);
1262 }
1263 }
1264 */
1265
1266 // This calls the UI-update mechanism (querying windows for
1267 // menu/toolbar/control state information)
1268 UpdateWindowUI();
1269 }
1270
1271 // Raise the window to the top of the Z order
1272 void wxWindowMac::Raise()
1273 {
1274 }
1275
1276 // Lower the window to the bottom of the Z order
1277 void wxWindowMac::Lower()
1278 {
1279 }
1280
1281 void wxWindowMac::DoSetClientSize(int width, int height)
1282 {
1283 if ( width != -1 || height != -1 )
1284 {
1285
1286 if ( width != -1 && m_vScrollBar )
1287 width += MAC_SCROLLBAR_SIZE ;
1288 if ( height != -1 && m_vScrollBar )
1289 height += MAC_SCROLLBAR_SIZE ;
1290
1291 width += MacGetLeftBorderSize( ) + MacGetRightBorderSize( ) ;
1292 height += MacGetTopBorderSize( ) + MacGetBottomBorderSize( ) ;
1293
1294 DoSetSize( -1 , -1 , width , height ) ;
1295 }
1296 }
1297
1298
1299 wxWindowMac* wxWindowMac::s_lastMouseWindow = NULL ;
1300
1301 bool wxWindowMac::MacGetWindowFromPointSub( const wxPoint &point , wxWindowMac** outWin )
1302 {
1303 if ((point.x < m_x) || (point.y < m_y) ||
1304 (point.x > (m_x + m_width)) || (point.y > (m_y + m_height)))
1305 return FALSE;
1306
1307 WindowRef window = MacGetRootWindow() ;
1308
1309 wxPoint newPoint( point ) ;
1310
1311 newPoint.x -= m_x;
1312 newPoint.y -= m_y;
1313
1314 for (wxNode *node = GetChildren().First(); node; node = node->Next())
1315 {
1316 wxWindowMac *child = (wxWindowMac*)node->Data();
1317 // added the m_isShown test --dmazzoni
1318 if ( child->MacGetRootWindow() == window && child->m_isShown )
1319 {
1320 if (child->MacGetWindowFromPointSub(newPoint , outWin ))
1321 return TRUE;
1322 }
1323 }
1324
1325 *outWin = this ;
1326 return TRUE;
1327 }
1328
1329 bool wxWindowMac::MacGetWindowFromPoint( const wxPoint &screenpoint , wxWindowMac** outWin )
1330 {
1331 WindowRef window ;
1332 Point pt = { screenpoint.y , screenpoint.x } ;
1333 if ( ::FindWindow( pt , &window ) == 3 )
1334 {
1335 wxPoint point( screenpoint ) ;
1336 wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
1337 if ( win )
1338 {
1339 win->ScreenToClient( point ) ;
1340 return win->MacGetWindowFromPointSub( point , outWin ) ;
1341 }
1342 }
1343 return FALSE ;
1344 }
1345
1346 extern int wxBusyCursorCount ;
1347
1348 bool wxWindowMac::MacDispatchMouseEvent(wxMouseEvent& event)
1349 {
1350 if ((event.m_x < m_x) || (event.m_y < m_y) ||
1351 (event.m_x > (m_x + m_width)) || (event.m_y > (m_y + m_height)))
1352 return FALSE;
1353
1354
1355 if ( IsKindOf( CLASSINFO ( wxStaticBox ) ) )
1356 return FALSE ;
1357
1358 WindowRef window = MacGetRootWindow() ;
1359
1360 event.m_x -= m_x;
1361 event.m_y -= m_y;
1362
1363 int x = event.m_x ;
1364 int y = event.m_y ;
1365
1366 for (wxNode *node = GetChildren().First(); node; node = node->Next())
1367 {
1368 wxWindowMac *child = (wxWindowMac*)node->Data();
1369 if ( child->MacGetRootWindow() == window && child->IsShown() && child->IsEnabled() )
1370 {
1371 if (child->MacDispatchMouseEvent(event))
1372 return TRUE;
1373 }
1374 }
1375
1376 event.m_x = x ;
1377 event.m_y = y ;
1378
1379 if ( wxBusyCursorCount == 0 )
1380 {
1381 m_cursor.MacInstall() ;
1382 }
1383
1384 if ( event.GetEventType() == wxEVT_LEFT_DOWN )
1385 {
1386 // set focus to this window
1387 if (AcceptsFocus() && FindFocus()!=this)
1388 SetFocus();
1389 }
1390
1391 #if wxUSE_TOOLTIPS
1392 if ( event.GetEventType() == wxEVT_MOTION
1393 || event.GetEventType() == wxEVT_ENTER_WINDOW
1394 || event.GetEventType() == wxEVT_LEAVE_WINDOW )
1395 wxToolTip::RelayEvent( this , event);
1396 #endif // wxUSE_TOOLTIPS
1397 GetEventHandler()->ProcessEvent( event ) ;
1398 return TRUE;
1399 }
1400
1401 wxString wxWindowMac::MacGetToolTipString( wxPoint &pt )
1402 {
1403 if ( m_tooltip )
1404 {
1405 return m_tooltip->GetTip() ;
1406 }
1407 return "" ;
1408 }
1409
1410 void wxWindowMac::Update()
1411 {
1412 wxTopLevelWindowMac* win = MacGetTopLevelWindow( ) ;
1413 if ( win )
1414 win->MacUpdate( 0 ) ;
1415 }
1416
1417 wxTopLevelWindowMac* wxWindowMac::MacGetTopLevelWindow() const
1418 {
1419 wxTopLevelWindowMac* win = NULL ;
1420 WindowRef window = MacGetRootWindow() ;
1421 if ( window )
1422 {
1423 win = wxFindWinFromMacWindow( window ) ;
1424 }
1425 return win ;
1426 }
1427
1428 const wxRegion& wxWindowMac::MacGetVisibleRegion()
1429 {
1430 RgnHandle visRgn = NewRgn() ;
1431 RgnHandle tempRgn = NewRgn() ;
1432
1433 SetRectRgn( visRgn , 0 , 0 , m_width , m_height ) ;
1434
1435 //TODO : as soon as the new scheme has proven to work correctly, move this to wxStaticBox
1436 if ( IsKindOf( CLASSINFO( wxStaticBox ) ) )
1437 {
1438 int borderTop = 14 ;
1439 int borderOther = 4 ;
1440
1441 SetRectRgn( tempRgn , borderOther , borderTop , m_width - borderOther , m_height - borderOther ) ;
1442 DiffRgn( visRgn , tempRgn , visRgn ) ;
1443 }
1444
1445 wxWindow* parent = GetParent() ;
1446 while( parent )
1447 {
1448 wxSize size = parent->GetSize() ;
1449 int x , y ;
1450 x = y = 0 ;
1451 parent->MacWindowToRootWindow( &x, &y ) ;
1452 MacRootWindowToWindow( &x , &y ) ;
1453 SetRectRgn( tempRgn , x , y , x + size.x , y + size.y ) ;
1454 SectRgn( visRgn , tempRgn , visRgn ) ;
1455 if ( parent->IsTopLevel() )
1456 break ;
1457 parent = parent->GetParent() ;
1458 }
1459 if ( GetWindowStyle() & wxCLIP_CHILDREN )
1460 {
1461 for (wxNode *node = GetChildren().First(); node; node = node->Next())
1462 {
1463 wxWindowMac *child = (wxWindowMac*)node->Data();
1464
1465 if ( !child->IsTopLevel() && child->IsShown() )
1466 {
1467 SetRectRgn( tempRgn , child->m_x , child->m_y , child->m_x + child->m_width , child->m_y + child->m_height ) ;
1468 DiffRgn( visRgn , tempRgn , visRgn ) ;
1469 }
1470 }
1471 }
1472
1473 if ( (GetWindowStyle() & wxCLIP_SIBLINGS) && GetParent() )
1474 {
1475 bool thisWindowThrough = false ;
1476 for (wxNode *node = GetParent()->GetChildren().First(); node; node = node->Next())
1477 {
1478 wxWindowMac *sibling = (wxWindowMac*)node->Data();
1479 if ( sibling == this )
1480 {
1481 thisWindowThrough = true ;
1482 continue ;
1483 }
1484 if( !thisWindowThrough )
1485 {
1486 continue ;
1487 }
1488
1489 if ( !sibling->IsTopLevel() && sibling->IsShown() )
1490 {
1491 SetRectRgn( tempRgn , sibling->m_x - m_x , sibling->m_y - m_y , sibling->m_x + sibling->m_width - m_x , sibling->m_y + sibling->m_height - m_y ) ;
1492 DiffRgn( visRgn , tempRgn , visRgn ) ;
1493 }
1494 }
1495 }
1496 m_macVisibleRegion = visRgn ;
1497 DisposeRgn( visRgn ) ;
1498 DisposeRgn( tempRgn ) ;
1499 return m_macVisibleRegion ;
1500 }
1501
1502 void wxWindowMac::MacRedraw( RgnHandle updatergn , long time, bool erase)
1503 {
1504 // updatergn is always already clipped to our boundaries
1505 // it is in window coordinates, not in client coordinates
1506
1507 WindowRef window = MacGetRootWindow() ;
1508
1509 {
1510 // ownUpdateRgn is the area that this window has to repaint, it is in window coordinates
1511 RgnHandle ownUpdateRgn = NewRgn() ;
1512 CopyRgn( updatergn , ownUpdateRgn ) ;
1513
1514 SectRgn( ownUpdateRgn , MacGetVisibleRegion().GetWXHRGN() , ownUpdateRgn ) ;
1515
1516 // newupdate is the update region in client coordinates
1517 RgnHandle newupdate = NewRgn() ;
1518 wxSize point = GetClientSize() ;
1519 wxPoint origin = GetClientAreaOrigin() ;
1520 SetRectRgn( newupdate , origin.x , origin.y , origin.x + point.x , origin.y+point.y ) ;
1521 SectRgn( newupdate , ownUpdateRgn , newupdate ) ;
1522 OffsetRgn( newupdate , -origin.x , -origin.y ) ;
1523 m_updateRegion = newupdate ;
1524 DisposeRgn( newupdate ) ; // it's been cloned to m_updateRegion
1525
1526 if ( erase && !EmptyRgn(ownUpdateRgn) )
1527 {
1528 wxWindowDC dc(this);
1529 dc.SetClippingRegion(wxRegion(ownUpdateRgn));
1530 wxEraseEvent eevent( GetId(), &dc );
1531 eevent.SetEventObject( this );
1532 GetEventHandler()->ProcessEvent( eevent );
1533
1534 wxNcPaintEvent eventNc( GetId() );
1535 eventNc.SetEventObject( this );
1536 GetEventHandler()->ProcessEvent( eventNc );
1537 }
1538 DisposeRgn( ownUpdateRgn ) ;
1539 if ( !m_updateRegion.Empty() )
1540 {
1541 wxPaintEvent event;
1542 event.m_timeStamp = time ;
1543 event.SetEventObject(this);
1544 GetEventHandler()->ProcessEvent(event);
1545 }
1546 }
1547
1548 // now intersect for each of the children their rect with the updateRgn and call MacRedraw recursively
1549
1550 RgnHandle childupdate = NewRgn() ;
1551 for (wxNode *node = GetChildren().First(); node; node = node->Next())
1552 {
1553 // calculate the update region for the child windows by intersecting the window rectangle with our own
1554 // passed in update region and then offset it to be client-wise window coordinates again
1555 wxWindowMac *child = (wxWindowMac*)node->Data();
1556 SetRectRgn( childupdate , child->m_x , child->m_y , child->m_x + child->m_width , child->m_y + child->m_height ) ;
1557 SectRgn( childupdate , updatergn , childupdate ) ;
1558 OffsetRgn( childupdate , -child->m_x , -child->m_y ) ;
1559 if ( child->MacGetRootWindow() == window && child->IsShown() && !EmptyRgn( childupdate ) )
1560 {
1561 // because dialogs may also be children
1562 child->MacRedraw( childupdate , time , erase ) ;
1563 }
1564 }
1565 DisposeRgn( childupdate ) ;
1566 // eventually a draw grow box here
1567
1568 }
1569
1570 WindowRef wxWindowMac::MacGetRootWindow() const
1571 {
1572 wxWindowMac *iter = (wxWindowMac*)this ;
1573
1574 while( iter )
1575 {
1576 if ( iter->IsTopLevel() )
1577 return ((wxTopLevelWindow*)iter)->MacGetWindowRef() ;
1578
1579 iter = iter->GetParent() ;
1580 }
1581 wxASSERT_MSG( 1 , "No valid mac root window" ) ;
1582 return NULL ;
1583 }
1584
1585 void wxWindowMac::MacCreateScrollBars( long style )
1586 {
1587 wxASSERT_MSG( m_vScrollBar == NULL && m_hScrollBar == NULL , "attempt to create window twice" ) ;
1588
1589 bool hasBoth = ( style & wxVSCROLL ) && ( style & wxHSCROLL ) ;
1590 int adjust = hasBoth ? MAC_SCROLLBAR_SIZE - 1: 0 ;
1591 int width, height ;
1592 GetClientSize( &width , &height ) ;
1593
1594 wxPoint vPoint(width-MAC_SCROLLBAR_SIZE, 0) ;
1595 wxSize vSize(MAC_SCROLLBAR_SIZE, height - adjust) ;
1596 wxPoint hPoint(0 , height-MAC_SCROLLBAR_SIZE ) ;
1597 wxSize hSize( width - adjust, MAC_SCROLLBAR_SIZE) ;
1598
1599 m_vScrollBar = new wxScrollBar(this, wxWINDOW_VSCROLL, vPoint,
1600 vSize , wxVERTICAL);
1601
1602 if ( style & wxVSCROLL )
1603 {
1604
1605 }
1606 else
1607 {
1608 m_vScrollBar->Show(false) ;
1609 }
1610 m_hScrollBar = new wxScrollBar(this, wxWINDOW_HSCROLL, hPoint,
1611 hSize , wxHORIZONTAL);
1612 if ( style & wxHSCROLL )
1613 {
1614 }
1615 else
1616 {
1617 m_hScrollBar->Show(false) ;
1618 }
1619
1620 // because the create does not take into account the client area origin
1621 MacRepositionScrollBars() ; // we might have a real position shift
1622 }
1623
1624 void wxWindowMac::MacRepositionScrollBars()
1625 {
1626 bool hasBoth = ( m_hScrollBar && m_hScrollBar->IsShown()) && ( m_vScrollBar && m_vScrollBar->IsShown()) ;
1627 int adjust = hasBoth ? MAC_SCROLLBAR_SIZE - 1 : 0 ;
1628
1629 // get real client area
1630
1631 int width = m_width ;
1632 int height = m_height ;
1633
1634 width -= MacGetLeftBorderSize() + MacGetRightBorderSize();
1635 height -= MacGetTopBorderSize() + MacGetBottomBorderSize();
1636
1637 wxPoint vPoint(width-MAC_SCROLLBAR_SIZE, 0) ;
1638 wxSize vSize(MAC_SCROLLBAR_SIZE, height - adjust) ;
1639 wxPoint hPoint(0 , height-MAC_SCROLLBAR_SIZE ) ;
1640 wxSize hSize( width - adjust, MAC_SCROLLBAR_SIZE) ;
1641
1642 int x = 0 ;
1643 int y = 0 ;
1644 int w = m_width ;
1645 int h = m_height ;
1646
1647 MacClientToRootWindow( &x , &y ) ;
1648 MacClientToRootWindow( &w , &h ) ;
1649
1650 wxWindowMac *iter = (wxWindowMac*)this ;
1651
1652 int totW = 10000 , totH = 10000;
1653 while( iter )
1654 {
1655 if ( iter->IsTopLevel() )
1656 {
1657 totW = iter->m_width ;
1658 totH = iter->m_height ;
1659 break ;
1660 }
1661
1662 iter = iter->GetParent() ;
1663 }
1664
1665 if ( x == 0 )
1666 {
1667 hPoint.x = -1 ;
1668 hSize.x += 1 ;
1669 }
1670 if ( y == 0 )
1671 {
1672 vPoint.y = -1 ;
1673 vSize.y += 1 ;
1674 }
1675
1676 if ( w-x >= totW )
1677 {
1678 hSize.x += 1 ;
1679 vPoint.x += 1 ;
1680 }
1681
1682 if ( h-y >= totH )
1683 {
1684 vSize.y += 1 ;
1685 hPoint.y += 1 ;
1686 }
1687
1688 if ( m_vScrollBar )
1689 {
1690 m_vScrollBar->SetSize( vPoint.x , vPoint.y, vSize.x, vSize.y , wxSIZE_ALLOW_MINUS_ONE);
1691 }
1692 if ( m_hScrollBar )
1693 {
1694 m_hScrollBar->SetSize( hPoint.x , hPoint.y, hSize.x, hSize.y, wxSIZE_ALLOW_MINUS_ONE);
1695 }
1696 }
1697
1698 bool wxWindowMac::AcceptsFocus() const
1699 {
1700 return MacCanFocus() && wxWindowBase::AcceptsFocus();
1701 }
1702
1703 ControlHandle wxWindowMac::MacGetContainerForEmbedding()
1704 {
1705 return GetParent()->MacGetContainerForEmbedding() ;
1706 }
1707
1708 void wxWindowMac::MacSuperChangedPosition()
1709 {
1710 // only window-absolute structures have to be moved i.e. controls
1711
1712 wxNode *node = GetChildren().First();
1713 while ( node )
1714 {
1715 wxWindowMac *child = (wxWindowMac *)node->Data();
1716 child->MacSuperChangedPosition() ;
1717 node = node->Next();
1718 }
1719 }
1720
1721 void wxWindowMac::MacTopLevelWindowChangedPosition()
1722 {
1723 // only screen-absolute structures have to be moved i.e. glcanvas
1724
1725 wxNode *node = GetChildren().First();
1726 while ( node )
1727 {
1728 wxWindowMac *child = (wxWindowMac *)node->Data();
1729 child->MacTopLevelWindowChangedPosition() ;
1730 node = node->Next();
1731 }
1732 }
1733 long wxWindowMac::MacGetLeftBorderSize( ) const
1734 {
1735 if( IsTopLevel() )
1736 return 0 ;
1737
1738 if (m_windowStyle & wxRAISED_BORDER || m_windowStyle & wxSUNKEN_BORDER )
1739 {
1740 SInt32 border = 3 ;
1741 #if wxMAC_USE_THEME_BORDER
1742 #if TARGET_CARBON
1743 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
1744 #endif
1745 #endif
1746 return border ;
1747 }
1748 else if ( m_windowStyle &wxDOUBLE_BORDER)
1749 {
1750 SInt32 border = 3 ;
1751 #if wxMAC_USE_THEME_BORDER
1752 #if TARGET_CARBON
1753 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
1754 #endif
1755 #endif
1756 return border ;
1757 }
1758 else if (m_windowStyle &wxSIMPLE_BORDER)
1759 {
1760 return 1 ;
1761 }
1762 return 0 ;
1763 }
1764
1765 long wxWindowMac::MacGetRightBorderSize( ) const
1766 {
1767 // they are all symmetric in mac themes
1768 return MacGetLeftBorderSize() ;
1769 }
1770
1771 long wxWindowMac::MacGetTopBorderSize( ) const
1772 {
1773 // they are all symmetric in mac themes
1774 return MacGetLeftBorderSize() ;
1775 }
1776
1777 long wxWindowMac::MacGetBottomBorderSize( ) const
1778 {
1779 // they are all symmetric in mac themes
1780 return MacGetLeftBorderSize() ;
1781 }
1782
1783 long wxWindowMac::MacRemoveBordersFromStyle( long style )
1784 {
1785 return style & ~( wxDOUBLE_BORDER | wxSUNKEN_BORDER | wxRAISED_BORDER | wxBORDER | wxSTATIC_BORDER ) ;
1786 }
1787
1788 // Find the wxWindowMac at the current mouse position, returning the mouse
1789 // position.
1790 wxWindowMac* wxFindWindowAtPointer(wxPoint& pt)
1791 {
1792 pt = wxGetMousePosition();
1793 wxWindowMac* found = wxFindWindowAtPoint(pt);
1794 return found;
1795 }
1796
1797 // Get the current mouse position.
1798 wxPoint wxGetMousePosition()
1799 {
1800 int x, y;
1801 wxGetMousePosition(& x, & y);
1802 return wxPoint(x, y);
1803 }
1804
wxWidgets (Impactor)