]> git.saurik.com Git - wxWidgets.git/blob - src/osx/window_osx.cpp
Fix width of the wxDataViewTreeCtrl column under OSX/Cocoa.
[wxWidgets.git] / src / osx / window_osx.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/window.cpp
3 // Purpose: wxWindowMac
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // RCS-ID: $Id: window.cpp 54981 2008-08-05 17:52:02Z SC $
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #include "wx/window.h"
15
16 #ifndef WX_PRECOMP
17 #include "wx/log.h"
18 #include "wx/app.h"
19 #include "wx/utils.h"
20 #include "wx/panel.h"
21 #include "wx/frame.h"
22 #include "wx/dc.h"
23 #include "wx/dcclient.h"
24 #include "wx/button.h"
25 #include "wx/menu.h"
26 #include "wx/dialog.h"
27 #include "wx/settings.h"
28 #include "wx/msgdlg.h"
29 #include "wx/scrolbar.h"
30 #include "wx/statbox.h"
31 #include "wx/textctrl.h"
32 #include "wx/toolbar.h"
33 #include "wx/layout.h"
34 #include "wx/statusbr.h"
35 #include "wx/menuitem.h"
36 #include "wx/treectrl.h"
37 #include "wx/listctrl.h"
38 #endif
39
40 #include "wx/tooltip.h"
41 #include "wx/spinctrl.h"
42 #include "wx/geometry.h"
43
44 #if wxUSE_LISTCTRL
45 #include "wx/listctrl.h"
46 #endif
47
48 #if wxUSE_TREECTRL
49 #include "wx/treectrl.h"
50 #endif
51
52 #if wxUSE_CARET
53 #include "wx/caret.h"
54 #endif
55
56 #if wxUSE_POPUPWIN
57 #include "wx/popupwin.h"
58 #endif
59
60 #if wxUSE_DRAG_AND_DROP
61 #include "wx/dnd.h"
62 #endif
63
64 #include "wx/graphics.h"
65
66 #if wxOSX_USE_CARBON
67 #include "wx/osx/uma.h"
68 #else
69 #include "wx/osx/private.h"
70 #endif
71
72 #define MAC_SCROLLBAR_SIZE 15
73 #define MAC_SMALL_SCROLLBAR_SIZE 11
74
75 #include <string.h>
76
77 #ifdef __WXUNIVERSAL__
78 IMPLEMENT_ABSTRACT_CLASS(wxWindowMac, wxWindowBase)
79 #else
80 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
81 #endif
82
83 BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
84 EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
85 END_EVENT_TABLE()
86
87 #define wxMAC_DEBUG_REDRAW 0
88 #ifndef wxMAC_DEBUG_REDRAW
89 #define wxMAC_DEBUG_REDRAW 0
90 #endif
91
92 // ===========================================================================
93 // implementation
94 // ===========================================================================
95
96 // ----------------------------------------------------------------------------
97 // constructors and such
98 // ----------------------------------------------------------------------------
99
100 wxWindowMac::wxWindowMac()
101 {
102 Init();
103 }
104
105 wxWindowMac::wxWindowMac(wxWindowMac *parent,
106 wxWindowID id,
107 const wxPoint& pos ,
108 const wxSize& size ,
109 long style ,
110 const wxString& name )
111 {
112 Init();
113 Create(parent, id, pos, size, style, name);
114 }
115
116 void wxWindowMac::Init()
117 {
118 m_peer = NULL ;
119 m_macAlpha = 255 ;
120 m_cgContextRef = NULL ;
121
122 // as all windows are created with WS_VISIBLE style...
123 m_isShown = true;
124
125 m_hScrollBar = NULL ;
126 m_vScrollBar = NULL ;
127 m_hScrollBarAlwaysShown = false;
128 m_vScrollBarAlwaysShown = false;
129 m_growBox = NULL ;
130
131 m_macIsUserPane = true;
132 m_clipChildren = false ;
133 m_cachedClippedRectValid = false ;
134 }
135
136 wxWindowMac::~wxWindowMac()
137 {
138 SendDestroyEvent();
139
140 MacInvalidateBorders() ;
141
142 #ifndef __WXUNIVERSAL__
143 // VS: make sure there's no wxFrame with last focus set to us:
144 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
145 {
146 wxFrame *frame = wxDynamicCast(win, wxFrame);
147 if ( frame )
148 {
149 if ( frame->GetLastFocus() == this )
150 frame->SetLastFocus(NULL);
151 break;
152 }
153 }
154 #endif
155
156 // destroy children before destroying this window itself
157 DestroyChildren();
158
159 // wxRemoveMacControlAssociation( this ) ;
160 // If we delete an item, we should initialize the parent panel,
161 // because it could now be invalid.
162 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent((wxWindow*)this), wxTopLevelWindow);
163 if ( tlw )
164 {
165 if ( tlw->GetDefaultItem() == (wxButton*) this)
166 tlw->SetDefaultItem(NULL);
167 }
168
169 if ( g_MacLastWindow == this )
170 g_MacLastWindow = NULL ;
171
172 #ifndef __WXUNIVERSAL__
173 wxFrame* frame = wxDynamicCast( wxGetTopLevelParent( (wxWindow*)this ) , wxFrame ) ;
174 if ( frame )
175 {
176 if ( frame->GetLastFocus() == this )
177 frame->SetLastFocus( NULL ) ;
178 }
179 #endif
180
181 // delete our drop target if we've got one
182 #if wxUSE_DRAG_AND_DROP
183 if ( m_dropTarget != NULL )
184 {
185 delete m_dropTarget;
186 m_dropTarget = NULL;
187 }
188 #endif
189
190 delete m_peer ;
191 }
192
193 WXWidget wxWindowMac::GetHandle() const
194 {
195 if ( m_peer )
196 return (WXWidget) m_peer->GetWXWidget() ;
197 return NULL;
198 }
199
200 // ---------------------------------------------------------------------------
201 // Utility Routines to move between different coordinate systems
202 // ---------------------------------------------------------------------------
203
204 /*
205 * Right now we have the following setup :
206 * a border that is not part of the native control is always outside the
207 * control's border (otherwise we loose all native intelligence, future ways
208 * may be to have a second embedding control responsible for drawing borders
209 * and backgrounds eventually)
210 * so all this border calculations have to be taken into account when calling
211 * native methods or getting native oriented data
212 * so we have three coordinate systems here
213 * wx client coordinates
214 * wx window coordinates (including window frames)
215 * native coordinates
216 */
217
218 //
219 //
220
221 // Constructor
222 bool wxWindowMac::Create(wxWindowMac *parent,
223 wxWindowID id,
224 const wxPoint& pos,
225 const wxSize& size,
226 long style,
227 const wxString& name)
228 {
229 wxCHECK_MSG( parent, false, wxT("can't create wxWindowMac without parent") );
230
231 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
232 return false;
233
234 m_windowVariant = parent->GetWindowVariant() ;
235
236 if ( m_macIsUserPane )
237 {
238 m_peer = wxWidgetImpl::CreateUserPane( this, parent, id, pos, size , style, GetExtraStyle() );
239 MacPostControlCreate(pos, size) ;
240 }
241
242 #ifndef __WXUNIVERSAL__
243 // Don't give scrollbars to wxControls unless they ask for them
244 if ( (! IsKindOf(CLASSINFO(wxControl))
245 #if wxUSE_STATUSBAR
246 && ! IsKindOf(CLASSINFO(wxStatusBar))
247 #endif
248 )
249 || (IsKindOf(CLASSINFO(wxControl)) && ((style & wxHSCROLL) || (style & wxVSCROLL))))
250 {
251 MacCreateScrollBars( style ) ;
252 }
253 #endif
254
255 wxWindowCreateEvent event((wxWindow*)this);
256 GetEventHandler()->AddPendingEvent(event);
257
258 return true;
259 }
260
261 void wxWindowMac::MacChildAdded()
262 {
263 #if wxUSE_SCROLLBAR
264 if ( m_vScrollBar )
265 m_vScrollBar->Raise() ;
266 if ( m_hScrollBar )
267 m_hScrollBar->Raise() ;
268 if ( m_growBox )
269 m_growBox->Raise() ;
270 #endif
271 }
272
273 void wxWindowMac::MacPostControlCreate(const wxPoint& WXUNUSED(pos), const wxSize& size)
274 {
275 wxASSERT_MSG( m_peer != NULL && m_peer->IsOk() , wxT("No valid mac control") ) ;
276
277 GetParent()->AddChild( this );
278
279 m_peer->InstallEventHandler();
280 m_peer->Embed(GetParent()->GetPeer());
281
282 GetParent()->MacChildAdded() ;
283
284 // adjust font, controlsize etc
285 DoSetWindowVariant( m_windowVariant ) ;
286
287 m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics), GetFont().GetEncoding() ) ;
288
289 // for controls we want to use best size for wxDefaultSize params )
290 if ( !m_macIsUserPane )
291 SetInitialSize(size);
292
293 SetCursor( *wxSTANDARD_CURSOR ) ;
294 }
295
296 void wxWindowMac::DoSetWindowVariant( wxWindowVariant variant )
297 {
298 // Don't assert, in case we set the window variant before
299 // the window is created
300 // wxASSERT( m_peer->Ok() ) ;
301
302 m_windowVariant = variant ;
303
304 if (m_peer == NULL || !m_peer->IsOk())
305 return;
306
307 m_peer->SetControlSize( variant );
308 #if wxOSX_USE_CARBON
309 ControlSize size ;
310
311 // we will get that from the settings later
312 // and make this NORMAL later, but first
313 // we have a few calculations that we must fix
314
315 switch ( variant )
316 {
317 case wxWINDOW_VARIANT_NORMAL :
318 size = kControlSizeNormal;
319 break ;
320
321 case wxWINDOW_VARIANT_SMALL :
322 size = kControlSizeSmall;
323 break ;
324
325 case wxWINDOW_VARIANT_MINI :
326 // not always defined in the headers
327 size = 3 ;
328 break ;
329
330 case wxWINDOW_VARIANT_LARGE :
331 size = kControlSizeLarge;
332 break ;
333
334 default:
335 wxFAIL_MSG(wxT("unexpected window variant"));
336 break ;
337 }
338 m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
339 #endif
340
341 wxFont font ;
342
343 wxOSXSystemFont systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
344
345 switch ( variant )
346 {
347 case wxWINDOW_VARIANT_NORMAL :
348 systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
349 break ;
350
351 case wxWINDOW_VARIANT_SMALL :
352 systemFont = wxOSX_SYSTEM_FONT_SMALL ;
353 break ;
354
355 case wxWINDOW_VARIANT_MINI :
356 systemFont = wxOSX_SYSTEM_FONT_MINI ;
357 break ;
358
359 case wxWINDOW_VARIANT_LARGE :
360 systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
361 break ;
362
363 default:
364 wxFAIL_MSG(wxT("unexpected window variant"));
365 break ;
366 }
367
368 font.CreateSystemFont( systemFont ) ;
369
370 SetFont( font ) ;
371 }
372
373 void wxWindowMac::MacUpdateControlFont()
374 {
375 if ( m_peer )
376 m_peer->SetFont( GetFont() , GetForegroundColour() , GetWindowStyle() ) ;
377
378 // do not trigger refreshes upon invisible and possible partly created objects
379 if ( IsShownOnScreen() )
380 Refresh() ;
381 }
382
383 bool wxWindowMac::SetFont(const wxFont& font)
384 {
385 bool retval = wxWindowBase::SetFont( font );
386
387 MacUpdateControlFont() ;
388
389 return retval;
390 }
391
392 bool wxWindowMac::SetForegroundColour(const wxColour& col )
393 {
394 bool retval = wxWindowBase::SetForegroundColour( col );
395
396 if (retval)
397 MacUpdateControlFont();
398
399 return retval;
400 }
401
402 bool wxWindowMac::SetBackgroundColour(const wxColour& col )
403 {
404 if ( !wxWindowBase::SetBackgroundColour(col) && m_hasBgCol )
405 return false ;
406
407 if ( m_peer )
408 m_peer->SetBackgroundColour( col ) ;
409
410 return true ;
411 }
412
413 static bool wxIsWindowOrParentDisabled(wxWindow* w)
414 {
415 while (w && !w->IsTopLevel())
416 {
417 if (!w->IsEnabled())
418 return true;
419 w = w->GetParent();
420 }
421 return false;
422 }
423
424 void wxWindowMac::SetFocus()
425 {
426 if ( !AcceptsFocus() )
427 return ;
428
429 if (wxIsWindowOrParentDisabled((wxWindow*) this))
430 return;
431
432 wxWindow* former = FindFocus() ;
433 if ( former == this )
434 return ;
435
436 m_peer->SetFocus() ;
437 }
438
439 void wxWindowMac::DoCaptureMouse()
440 {
441 wxApp::s_captureWindow = (wxWindow*) this ;
442 m_peer->CaptureMouse() ;
443 }
444
445 wxWindow * wxWindowBase::GetCapture()
446 {
447 return wxApp::s_captureWindow ;
448 }
449
450 void wxWindowMac::DoReleaseMouse()
451 {
452 wxApp::s_captureWindow = NULL ;
453
454 m_peer->ReleaseMouse() ;
455 }
456
457 #if wxUSE_DRAG_AND_DROP
458
459 void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
460 {
461 delete m_dropTarget;
462
463 m_dropTarget = pDropTarget;
464 if ( m_dropTarget != NULL )
465 {
466 // TODO:
467 }
468 }
469
470 #endif
471
472 // Old-style File Manager Drag & Drop
473 void wxWindowMac::DragAcceptFiles(bool WXUNUSED(accept))
474 {
475 // TODO:
476 }
477
478 // From a wx position / size calculate the appropriate size of the native control
479
480 bool wxWindowMac::MacGetBoundsForControl(
481 const wxPoint& pos,
482 const wxSize& size,
483 int& x, int& y,
484 int& w, int& h , bool adjustOrigin ) const
485 {
486 // the desired size, minus the border pixels gives the correct size of the control
487 x = (int)pos.x;
488 y = (int)pos.y;
489
490 w = WidthDefault( size.x );
491 h = HeightDefault( size.y );
492
493 x += MacGetLeftBorderSize() ;
494 y += MacGetTopBorderSize() ;
495 w -= MacGetLeftBorderSize() + MacGetRightBorderSize() ;
496 h -= MacGetTopBorderSize() + MacGetBottomBorderSize() ;
497
498 if ( adjustOrigin )
499 AdjustForParentClientOrigin( x , y ) ;
500
501 // this is in window relative coordinate, as this parent may have a border, its physical position is offset by this border
502 if ( GetParent() && !GetParent()->IsTopLevel() )
503 {
504 x -= GetParent()->MacGetLeftBorderSize() ;
505 y -= GetParent()->MacGetTopBorderSize() ;
506 }
507
508 return true ;
509 }
510
511 // Get window size (not client size)
512 void wxWindowMac::DoGetSize(int *x, int *y) const
513 {
514 int width, height;
515 m_peer->GetSize( width, height );
516
517 if (x)
518 *x = width + MacGetLeftBorderSize() + MacGetRightBorderSize() ;
519 if (y)
520 *y = height + MacGetTopBorderSize() + MacGetBottomBorderSize() ;
521 }
522
523 // get the position of the bounds of this window in client coordinates of its parent
524 void wxWindowMac::DoGetPosition(int *x, int *y) const
525 {
526 int x1, y1;
527
528 m_peer->GetPosition( x1, y1 ) ;
529
530 // get the wx window position from the native one
531 x1 -= MacGetLeftBorderSize() ;
532 y1 -= MacGetTopBorderSize() ;
533
534 if ( !IsTopLevel() )
535 {
536 wxWindow *parent = GetParent();
537 if ( parent )
538 {
539 // we must first adjust it to be in window coordinates of the parent,
540 // as otherwise it gets lost by the ClientAreaOrigin fix
541 x1 += parent->MacGetLeftBorderSize() ;
542 y1 += parent->MacGetTopBorderSize() ;
543
544 // and now to client coordinates
545 wxPoint pt(parent->GetClientAreaOrigin());
546 x1 -= pt.x ;
547 y1 -= pt.y ;
548 }
549 }
550
551 if (x)
552 *x = x1 ;
553 if (y)
554 *y = y1 ;
555 }
556
557 void wxWindowMac::DoScreenToClient(int *x, int *y) const
558 {
559 wxNonOwnedWindow* tlw = MacGetTopLevelWindow() ;
560 wxCHECK_RET( tlw , wxT("TopLevel Window missing") ) ;
561 tlw->GetNonOwnedPeer()->ScreenToWindow( x, y);
562 MacRootWindowToWindow( x , y ) ;
563
564 wxPoint origin = GetClientAreaOrigin() ;
565 if (x)
566 *x -= origin.x ;
567 if (y)
568 *y -= origin.y ;
569 }
570
571 void wxWindowMac::DoClientToScreen(int *x, int *y) const
572 {
573 wxNonOwnedWindow* tlw = MacGetTopLevelWindow() ;
574 wxCHECK_RET( tlw , wxT("TopLevel window missing") ) ;
575
576 wxPoint origin = GetClientAreaOrigin() ;
577 if (x)
578 *x += origin.x ;
579 if (y)
580 *y += origin.y ;
581
582 MacWindowToRootWindow( x , y ) ;
583 tlw->GetNonOwnedPeer()->WindowToScreen( x , y );
584 }
585
586 void wxWindowMac::MacClientToRootWindow( int *x , int *y ) const
587 {
588 wxPoint origin = GetClientAreaOrigin() ;
589 if (x)
590 *x += origin.x ;
591 if (y)
592 *y += origin.y ;
593
594 MacWindowToRootWindow( x , y ) ;
595 }
596
597 void wxWindowMac::MacWindowToRootWindow( int *x , int *y ) const
598 {
599 wxPoint pt ;
600
601 if (x)
602 pt.x = *x ;
603 if (y)
604 pt.y = *y ;
605
606 if ( !IsTopLevel() )
607 {
608 wxNonOwnedWindow* top = MacGetTopLevelWindow();
609 if (top)
610 {
611 pt.x -= MacGetLeftBorderSize() ;
612 pt.y -= MacGetTopBorderSize() ;
613 wxWidgetImpl::Convert( &pt , m_peer , top->m_peer ) ;
614 }
615 }
616
617 if (x)
618 *x = (int) pt.x ;
619 if (y)
620 *y = (int) pt.y ;
621 }
622
623 void wxWindowMac::MacRootWindowToWindow( int *x , int *y ) const
624 {
625 wxPoint pt ;
626
627 if (x)
628 pt.x = *x ;
629 if (y)
630 pt.y = *y ;
631
632 if ( !IsTopLevel() )
633 {
634 wxNonOwnedWindow* top = MacGetTopLevelWindow();
635 if (top)
636 {
637 wxWidgetImpl::Convert( &pt , top->m_peer , m_peer ) ;
638 pt.x += MacGetLeftBorderSize() ;
639 pt.y += MacGetTopBorderSize() ;
640 }
641 }
642
643 if (x)
644 *x = (int) pt.x ;
645 if (y)
646 *y = (int) pt.y ;
647 }
648
649 wxSize wxWindowMac::DoGetSizeFromClientSize( const wxSize & size ) const
650 {
651 wxSize sizeTotal = size;
652
653 int innerwidth, innerheight;
654 int left, top;
655 int outerwidth, outerheight;
656
657 m_peer->GetContentArea( left, top, innerwidth, innerheight );
658 m_peer->GetSize( outerwidth, outerheight );
659
660 sizeTotal.x += outerwidth-innerwidth;
661 sizeTotal.y += outerheight-innerheight;
662
663 sizeTotal.x += MacGetLeftBorderSize() + MacGetRightBorderSize() ;
664 sizeTotal.y += MacGetTopBorderSize() + MacGetBottomBorderSize() ;
665
666 return sizeTotal;
667 }
668
669 // Get size *available for subwindows* i.e. excluding menu bar etc.
670 void wxWindowMac::DoGetClientSize( int *x, int *y ) const
671 {
672 int ww, hh;
673
674 int left, top;
675
676 m_peer->GetContentArea( left, top, ww, hh );
677 #if wxUSE_SCROLLBAR
678 if (m_hScrollBar && m_hScrollBar->IsShown() )
679 hh -= m_hScrollBar->GetSize().y ;
680
681 if (m_vScrollBar && m_vScrollBar->IsShown() )
682 ww -= m_vScrollBar->GetSize().x ;
683
684 #endif
685 if (x)
686 *x = ww;
687 if (y)
688 *y = hh;
689 }
690
691 bool wxWindowMac::SetCursor(const wxCursor& cursor)
692 {
693 if (m_cursor.IsSameAs(cursor))
694 return false;
695
696 if (!cursor.IsOk())
697 {
698 if ( ! wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ) )
699 return false ;
700 }
701 else
702 {
703 if ( ! wxWindowBase::SetCursor( cursor ) )
704 return false ;
705 }
706
707 wxASSERT_MSG( m_cursor.Ok(),
708 wxT("cursor must be valid after call to the base version"));
709
710 if ( GetPeer() != NULL )
711 GetPeer()->SetCursor( m_cursor );
712
713 return true ;
714 }
715
716 #if wxUSE_MENUS
717 bool wxWindowMac::DoPopupMenu(wxMenu *menu, int x, int y)
718 {
719 #ifndef __WXUNIVERSAL__
720 menu->SetInvokingWindow((wxWindow*)this);
721 menu->UpdateUI();
722
723 if ( x == wxDefaultCoord && y == wxDefaultCoord )
724 {
725 wxPoint mouse = wxGetMousePosition();
726 x = mouse.x;
727 y = mouse.y;
728 }
729 else
730 {
731 ClientToScreen( &x , &y ) ;
732 }
733 menu->GetPeer()->PopUp(this, x, y);
734 menu->SetInvokingWindow( NULL );
735 return true;
736 #else
737 // actually this shouldn't be called, because universal is having its own implementation
738 return false;
739 #endif
740 }
741 #endif
742
743 // ----------------------------------------------------------------------------
744 // tooltips
745 // ----------------------------------------------------------------------------
746
747 #if wxUSE_TOOLTIPS
748
749 void wxWindowMac::DoSetToolTip(wxToolTip *tooltip)
750 {
751 wxWindowBase::DoSetToolTip(tooltip);
752
753 if ( m_tooltip )
754 m_tooltip->SetWindow(this);
755 }
756
757 #endif
758
759 void wxWindowMac::MacInvalidateBorders()
760 {
761 if ( m_peer == NULL )
762 return ;
763
764 bool vis = IsShownOnScreen() ;
765 if ( !vis )
766 return ;
767
768 int outerBorder = MacGetLeftBorderSize() ;
769
770 if ( m_peer->NeedsFocusRect() )
771 outerBorder += 4 ;
772
773 if ( outerBorder == 0 )
774 return ;
775
776 // now we know that we have something to do at all
777
778 int tx,ty,tw,th;
779
780 m_peer->GetSize( tw, th );
781 m_peer->GetPosition( tx, ty );
782
783 wxRect leftupdate( tx-outerBorder,ty,outerBorder,th );
784 wxRect rightupdate( tx+tw, ty, outerBorder, th );
785 wxRect topupdate( tx-outerBorder, ty-outerBorder, tw + 2 * outerBorder, outerBorder );
786 wxRect bottomupdate( tx-outerBorder, ty + th, tw + 2 * outerBorder, outerBorder );
787
788 if (GetParent()) {
789 GetParent()->m_peer->SetNeedsDisplay(&leftupdate);
790 GetParent()->m_peer->SetNeedsDisplay(&rightupdate);
791 GetParent()->m_peer->SetNeedsDisplay(&topupdate);
792 GetParent()->m_peer->SetNeedsDisplay(&bottomupdate);
793 }
794 }
795
796 void wxWindowMac::DoMoveWindow(int x, int y, int width, int height)
797 {
798 // this is never called for a toplevel window, so we know we have a parent
799 int former_x , former_y , former_w, former_h ;
800
801 // Get true coordinates of former position
802 DoGetPosition( &former_x , &former_y ) ;
803 DoGetSize( &former_w , &former_h ) ;
804
805 wxWindow *parent = GetParent();
806 if ( parent )
807 {
808 wxPoint pt(parent->GetClientAreaOrigin());
809 former_x += pt.x ;
810 former_y += pt.y ;
811 }
812
813 int actualWidth = width ;
814 int actualHeight = height ;
815 int actualX = x;
816 int actualY = y;
817
818 #if 0
819 // min and max sizes are only for sizers, not for explicit size setting
820 if ((m_minWidth != -1) && (actualWidth < m_minWidth))
821 actualWidth = m_minWidth;
822 if ((m_minHeight != -1) && (actualHeight < m_minHeight))
823 actualHeight = m_minHeight;
824 if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
825 actualWidth = m_maxWidth;
826 if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
827 actualHeight = m_maxHeight;
828 #endif
829
830 bool doMove = false, doResize = false ;
831
832 if ( actualX != former_x || actualY != former_y )
833 doMove = true ;
834
835 if ( actualWidth != former_w || actualHeight != former_h )
836 doResize = true ;
837
838 if ( doMove || doResize )
839 {
840 // as the borders are drawn outside the native control, we adjust now
841
842 wxRect bounds( wxPoint( actualX + MacGetLeftBorderSize() ,actualY + MacGetTopBorderSize() ),
843 wxSize( actualWidth - (MacGetLeftBorderSize() + MacGetRightBorderSize()) ,
844 actualHeight - (MacGetTopBorderSize() + MacGetBottomBorderSize()) ) ) ;
845
846 if ( parent && !parent->IsTopLevel() )
847 {
848 bounds.Offset( -parent->MacGetLeftBorderSize(), -parent->MacGetTopBorderSize() );
849 }
850
851 MacInvalidateBorders() ;
852
853 m_cachedClippedRectValid = false ;
854
855 m_peer->Move( bounds.x, bounds.y, bounds.width, bounds.height);
856
857 wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
858
859 MacInvalidateBorders() ;
860
861 MacRepositionScrollBars() ;
862 if ( doMove )
863 {
864 wxPoint point(actualX, actualY);
865 wxMoveEvent event(point, m_windowId);
866 event.SetEventObject(this);
867 HandleWindowEvent(event) ;
868 }
869
870 if ( doResize )
871 {
872 MacRepositionScrollBars() ;
873 wxSize size(actualWidth, actualHeight);
874 wxSizeEvent event(size, m_windowId);
875 event.SetEventObject(this);
876 HandleWindowEvent(event);
877 }
878 }
879 }
880
881 wxSize wxWindowMac::DoGetBestSize() const
882 {
883 if ( m_macIsUserPane || IsTopLevel() )
884 {
885 return wxWindowBase::DoGetBestSize() ;
886 }
887 else
888 {
889 wxRect r ;
890
891 m_peer->GetBestRect(&r);
892
893 if ( r.GetWidth() == 0 && r.GetHeight() == 0 )
894 {
895 r.x =
896 r.y = 0 ;
897 r.width =
898 r.height = 16 ;
899
900 if ( 0 )
901 {
902 }
903 #if wxUSE_SCROLLBAR
904 else if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
905 {
906 r.height = 16 ;
907 }
908 #endif
909 #if wxUSE_SPINBTN
910 else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
911 {
912 r.height = 24 ;
913 }
914 #endif
915 else
916 {
917 // return wxWindowBase::DoGetBestSize() ;
918 }
919 }
920
921 int bestWidth = r.width + MacGetLeftBorderSize() +
922 MacGetRightBorderSize();
923 int bestHeight = r.height + MacGetTopBorderSize() +
924 MacGetBottomBorderSize();
925 if ( bestHeight < 10 )
926 bestHeight = 13 ;
927
928 return wxSize(bestWidth, bestHeight);
929 }
930 }
931
932 // set the size of the window: if the dimensions are positive, just use them,
933 // but if any of them is equal to -1, it means that we must find the value for
934 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
935 // which case -1 is a valid value for x and y)
936 //
937 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
938 // the width/height to best suit our contents, otherwise we reuse the current
939 // width/height
940 void wxWindowMac::DoSetSize(int x, int y, int width, int height, int sizeFlags)
941 {
942 // get the current size and position...
943 int currentX, currentY;
944 int currentW, currentH;
945
946 GetPosition(&currentX, &currentY);
947 GetSize(&currentW, &currentH);
948
949 // ... and don't do anything (avoiding flicker) if it's already ok
950 if ( x == currentX && y == currentY &&
951 width == currentW && height == currentH && ( height != -1 && width != -1 ) )
952 {
953 // TODO: REMOVE
954 MacRepositionScrollBars() ; // we might have a real position shift
955
956 if (sizeFlags & wxSIZE_FORCE_EVENT)
957 {
958 wxSizeEvent event( wxSize(width,height), GetId() );
959 event.SetEventObject( this );
960 HandleWindowEvent( event );
961 }
962
963 return;
964 }
965
966 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
967 {
968 if ( x == wxDefaultCoord )
969 x = currentX;
970 if ( y == wxDefaultCoord )
971 y = currentY;
972 }
973
974 AdjustForParentClientOrigin( x, y, sizeFlags );
975
976 wxSize size = wxDefaultSize;
977 if ( width == wxDefaultCoord )
978 {
979 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
980 {
981 size = DoGetBestSize();
982 width = size.x;
983 }
984 else
985 {
986 // just take the current one
987 width = currentW;
988 }
989 }
990
991 if ( height == wxDefaultCoord )
992 {
993 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
994 {
995 if ( size.x == wxDefaultCoord )
996 size = DoGetBestSize();
997 // else: already called DoGetBestSize() above
998
999 height = size.y;
1000 }
1001 else
1002 {
1003 // just take the current one
1004 height = currentH;
1005 }
1006 }
1007
1008 DoMoveWindow( x, y, width, height );
1009 }
1010
1011 wxPoint wxWindowMac::GetClientAreaOrigin() const
1012 {
1013 int left,top,width,height;
1014 m_peer->GetContentArea( left , top , width , height);
1015 return wxPoint( left + MacGetLeftBorderSize() , top + MacGetTopBorderSize() );
1016 }
1017
1018 void wxWindowMac::DoSetClientSize(int clientwidth, int clientheight)
1019 {
1020 if ( clientwidth != wxDefaultCoord || clientheight != wxDefaultCoord )
1021 {
1022 int currentclientwidth , currentclientheight ;
1023 int currentwidth , currentheight ;
1024
1025 GetClientSize( &currentclientwidth , &currentclientheight ) ;
1026 GetSize( &currentwidth , &currentheight ) ;
1027
1028 DoSetSize( wxDefaultCoord , wxDefaultCoord , currentwidth + clientwidth - currentclientwidth ,
1029 currentheight + clientheight - currentclientheight , wxSIZE_USE_EXISTING ) ;
1030 }
1031 }
1032
1033 void wxWindowMac::SetLabel(const wxString& title)
1034 {
1035 if ( title == m_label )
1036 return;
1037
1038 m_label = title ;
1039
1040 InvalidateBestSize();
1041
1042 if ( m_peer && m_peer->IsOk() )
1043 m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics), GetFont().GetEncoding() ) ;
1044
1045 // do not trigger refreshes upon invisible and possible partly created objects
1046 if ( IsShownOnScreen() )
1047 Refresh() ;
1048 }
1049
1050 wxString wxWindowMac::GetLabel() const
1051 {
1052 return m_label ;
1053 }
1054
1055 bool wxWindowMac::Show(bool show)
1056 {
1057 if ( !wxWindowBase::Show(show) )
1058 return false;
1059
1060 if ( m_peer )
1061 m_peer->SetVisibility( show ) ;
1062
1063 wxShowEvent eventShow(GetId(), show);
1064 eventShow.SetEventObject(this);
1065
1066 HandleWindowEvent(eventShow);
1067
1068 return true;
1069 }
1070
1071 bool wxWindowMac::OSXShowWithEffect(bool show,
1072 wxShowEffect effect,
1073 unsigned timeout)
1074 {
1075 if ( effect == wxSHOW_EFFECT_NONE ||
1076 !m_peer || !m_peer->ShowWithEffect(show, effect, timeout) )
1077 return Show(show);
1078
1079 return true;
1080 }
1081
1082 void wxWindowMac::DoEnable(bool enable)
1083 {
1084 m_peer->Enable( enable ) ;
1085 }
1086
1087 //
1088 // status change notifications
1089 //
1090
1091 void wxWindowMac::MacVisibilityChanged()
1092 {
1093 }
1094
1095 void wxWindowMac::MacHiliteChanged()
1096 {
1097 }
1098
1099 void wxWindowMac::MacEnabledStateChanged()
1100 {
1101 OnEnabled( m_peer->IsEnabled() );
1102 }
1103
1104 //
1105 // status queries on the inherited window's state
1106 //
1107
1108 bool wxWindowMac::MacIsReallyEnabled()
1109 {
1110 return m_peer->IsEnabled() ;
1111 }
1112
1113 bool wxWindowMac::MacIsReallyHilited()
1114 {
1115 #if wxOSX_USE_CARBON
1116 return m_peer->IsActive();
1117 #else
1118 return true; // TODO
1119 #endif
1120 }
1121
1122 int wxWindowMac::GetCharHeight() const
1123 {
1124 wxCoord height;
1125 GetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL );
1126
1127 return height;
1128 }
1129
1130 int wxWindowMac::GetCharWidth() const
1131 {
1132 wxCoord width;
1133 GetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL );
1134
1135 return width;
1136 }
1137
1138 void wxWindowMac::DoGetTextExtent(const wxString& str,
1139 int *x, int *y,
1140 int *descent,
1141 int *externalLeading,
1142 const wxFont *theFont) const
1143 {
1144 const wxFont *fontToUse = theFont;
1145 wxFont tempFont;
1146 if ( !fontToUse )
1147 {
1148 tempFont = GetFont();
1149 fontToUse = &tempFont;
1150 }
1151
1152 wxGraphicsContext* ctx = wxGraphicsContext::Create();
1153 ctx->SetFont( *fontToUse, *wxBLACK );
1154
1155 wxDouble h , d , e , w;
1156 ctx->GetTextExtent( str, &w, &h, &d, &e );
1157
1158 delete ctx;
1159
1160 if ( externalLeading )
1161 *externalLeading = (wxCoord)(e+0.5);
1162 if ( descent )
1163 *descent = (wxCoord)(d+0.5);
1164 if ( x )
1165 *x = (wxCoord)(w+0.5);
1166 if ( y )
1167 *y = (wxCoord)(h+0.5);
1168 }
1169
1170 /*
1171 * Rect is given in client coordinates, for further reading, read wxTopLevelWindowMac::InvalidateRect
1172 * we always intersect with the entire window, not only with the client area
1173 */
1174
1175 void wxWindowMac::Refresh(bool WXUNUSED(eraseBack), const wxRect *rect)
1176 {
1177 if ( m_peer == NULL )
1178 return ;
1179
1180 if ( !IsShownOnScreen() )
1181 return ;
1182
1183 m_peer->SetNeedsDisplay( rect ) ;
1184 }
1185
1186 void wxWindowMac::DoFreeze()
1187 {
1188 #if wxOSX_USE_CARBON
1189 if ( m_peer && m_peer->IsOk() )
1190 m_peer->SetDrawingEnabled( false ) ;
1191 #endif
1192 }
1193
1194 void wxWindowMac::DoThaw()
1195 {
1196 #if wxOSX_USE_CARBON
1197 if ( m_peer && m_peer->IsOk() )
1198 {
1199 m_peer->SetDrawingEnabled( true ) ;
1200 m_peer->InvalidateWithChildren() ;
1201 }
1202 #endif
1203 }
1204
1205 wxWindow *wxGetActiveWindow()
1206 {
1207 // actually this is a windows-only concept
1208 return NULL;
1209 }
1210
1211 // Coordinates relative to the window
1212 void wxWindowMac::WarpPointer(int x_pos, int y_pos)
1213 {
1214 #if wxOSX_USE_COCOA_OR_CARBON
1215 int x = x_pos;
1216 int y = y_pos;
1217 DoClientToScreen(&x, &y);
1218 CGPoint cgpoint = CGPointMake( x, y );
1219 CGWarpMouseCursorPosition( cgpoint );
1220
1221 // At least GTK sends a mouse moved event after WarpMouse
1222 wxMouseEvent event(wxEVT_MOTION);
1223 event.m_x = x_pos;
1224 event.m_y = y_pos;
1225 wxMouseState mState = ::wxGetMouseState();
1226
1227 event.m_altDown = mState.AltDown();
1228 event.m_controlDown = mState.ControlDown();
1229 event.m_leftDown = mState.LeftIsDown();
1230 event.m_middleDown = mState.MiddleIsDown();
1231 event.m_rightDown = mState.RightIsDown();
1232 event.m_metaDown = mState.MetaDown();
1233 event.m_shiftDown = mState.ShiftDown();
1234 event.SetId(GetId());
1235 event.SetEventObject(this);
1236 GetEventHandler()->ProcessEvent(event);
1237 #endif
1238 }
1239
1240 int wxWindowMac::GetScrollPos(int orient) const
1241 {
1242 #if wxUSE_SCROLLBAR
1243 if ( orient == wxHORIZONTAL )
1244 {
1245 if ( m_hScrollBar )
1246 return m_hScrollBar->GetThumbPosition() ;
1247 }
1248 else
1249 {
1250 if ( m_vScrollBar )
1251 return m_vScrollBar->GetThumbPosition() ;
1252 }
1253 #endif
1254 return 0;
1255 }
1256
1257 // This now returns the whole range, not just the number
1258 // of positions that we can scroll.
1259 int wxWindowMac::GetScrollRange(int orient) const
1260 {
1261 #if wxUSE_SCROLLBAR
1262 if ( orient == wxHORIZONTAL )
1263 {
1264 if ( m_hScrollBar )
1265 return m_hScrollBar->GetRange() ;
1266 }
1267 else
1268 {
1269 if ( m_vScrollBar )
1270 return m_vScrollBar->GetRange() ;
1271 }
1272 #endif
1273 return 0;
1274 }
1275
1276 int wxWindowMac::GetScrollThumb(int orient) const
1277 {
1278 #if wxUSE_SCROLLBAR
1279 if ( orient == wxHORIZONTAL )
1280 {
1281 if ( m_hScrollBar )
1282 return m_hScrollBar->GetThumbSize() ;
1283 }
1284 else
1285 {
1286 if ( m_vScrollBar )
1287 return m_vScrollBar->GetThumbSize() ;
1288 }
1289 #endif
1290 return 0;
1291 }
1292
1293 void wxWindowMac::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
1294 {
1295 #if wxUSE_SCROLLBAR
1296 if ( orient == wxHORIZONTAL )
1297 {
1298 if ( m_hScrollBar )
1299 m_hScrollBar->SetThumbPosition( pos ) ;
1300 }
1301 else
1302 {
1303 if ( m_vScrollBar )
1304 m_vScrollBar->SetThumbPosition( pos ) ;
1305 }
1306 #endif
1307 }
1308
1309 void
1310 wxWindowMac::AlwaysShowScrollbars(bool hflag, bool vflag)
1311 {
1312 bool needVisibilityUpdate = false;
1313
1314 if ( m_hScrollBarAlwaysShown != hflag )
1315 {
1316 m_hScrollBarAlwaysShown = hflag;
1317 needVisibilityUpdate = true;
1318 }
1319
1320 if ( m_vScrollBarAlwaysShown != vflag )
1321 {
1322 m_vScrollBarAlwaysShown = vflag;
1323 needVisibilityUpdate = true;
1324 }
1325
1326 if ( needVisibilityUpdate )
1327 DoUpdateScrollbarVisibility();
1328 }
1329
1330 //
1331 // we draw borders and grow boxes, are already set up and clipped in the current port / cgContextRef
1332 // our own window origin is at leftOrigin/rightOrigin
1333 //
1334
1335 void wxWindowMac::MacPaintGrowBox()
1336 {
1337 if ( IsTopLevel() )
1338 return ;
1339
1340 #if wxUSE_SCROLLBAR
1341 if ( MacHasScrollBarCorner() )
1342 {
1343 #if 0
1344 CGContextRef cgContext = (CGContextRef) MacGetCGContextRef() ;
1345 wxASSERT( cgContext ) ;
1346
1347 int tx,ty,tw,th;
1348
1349 m_peer->GetSize( tw, th );
1350 m_peer->GetPosition( tx, ty );
1351
1352 Rect rect = { ty,tx, ty+th, tx+tw };
1353
1354
1355 int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
1356 CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
1357 CGContextSaveGState( cgContext );
1358
1359 if ( m_backgroundColour.Ok() )
1360 {
1361 CGContextSetFillColorWithColor( cgContext, m_backgroundColour.GetCGColor() );
1362 }
1363 else
1364 {
1365 CGContextSetRGBFillColor( cgContext, (CGFloat) 1.0, (CGFloat)1.0 ,(CGFloat) 1.0 , (CGFloat)1.0 );
1366 }
1367 CGContextFillRect( cgContext, cgrect );
1368 CGContextRestoreGState( cgContext );
1369 #else
1370 if (m_growBox)
1371 {
1372 if ( m_backgroundColour.Ok() )
1373 m_growBox->SetBackgroundColour(m_backgroundColour);
1374 else
1375 m_growBox->SetBackgroundColour(*wxWHITE);
1376 }
1377 #endif
1378 }
1379
1380 #endif
1381 }
1382
1383 void wxWindowMac::MacPaintBorders( int WXUNUSED(leftOrigin) , int WXUNUSED(rightOrigin) )
1384 {
1385 if ( IsTopLevel() )
1386 return ;
1387
1388 bool hasFocus = m_peer->NeedsFocusRect() && m_peer->HasFocus() ;
1389
1390 // back to the surrounding frame rectangle
1391 int tx,ty,tw,th;
1392
1393 m_peer->GetSize( tw, th );
1394 m_peer->GetPosition( tx, ty );
1395
1396 Rect rect = { ty,tx, ty+th, tx+tw };
1397
1398 #if wxOSX_USE_COCOA_OR_CARBON
1399
1400 InsetRect( &rect, -1 , -1 ) ;
1401
1402 {
1403 CGRect cgrect = CGRectMake( rect.left , rect.top , rect.right - rect.left ,
1404 rect.bottom - rect.top ) ;
1405
1406 CGContextRef cgContext = (CGContextRef) GetParent()->MacGetCGContextRef() ;
1407 wxASSERT( cgContext ) ;
1408
1409 if ( m_peer->NeedsFrame() )
1410 {
1411 HIThemeFrameDrawInfo info ;
1412 memset( &info, 0 , sizeof(info) ) ;
1413
1414 info.version = 0 ;
1415 info.kind = 0 ;
1416 info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
1417 info.isFocused = hasFocus ;
1418
1419 if ( HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER) )
1420 {
1421 info.kind = kHIThemeFrameTextFieldSquare ;
1422 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
1423 }
1424 else if ( HasFlag(wxSIMPLE_BORDER) )
1425 {
1426 info.kind = kHIThemeFrameListBox ;
1427 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
1428 }
1429 }
1430
1431 if ( hasFocus )
1432 {
1433 HIThemeDrawFocusRect( &cgrect , true , cgContext , kHIThemeOrientationNormal ) ;
1434 }
1435 }
1436 #endif // wxOSX_USE_COCOA_OR_CARBON
1437 }
1438
1439 void wxWindowMac::RemoveChild( wxWindowBase *child )
1440 {
1441 #if wxUSE_SCROLLBAR
1442 if ( child == m_hScrollBar )
1443 m_hScrollBar = NULL ;
1444 if ( child == m_vScrollBar )
1445 m_vScrollBar = NULL ;
1446 if ( child == m_growBox )
1447 m_growBox = NULL ;
1448 #endif
1449 wxWindowBase::RemoveChild( child ) ;
1450 }
1451
1452 void wxWindowMac::DoUpdateScrollbarVisibility()
1453 {
1454 #if wxUSE_SCROLLBAR
1455 bool triggerSizeEvent = false;
1456
1457 if ( m_hScrollBar )
1458 {
1459 bool showHScrollBar = m_hScrollBarAlwaysShown || m_hScrollBar->IsNeeded();
1460
1461 if ( m_hScrollBar->IsShown() != showHScrollBar )
1462 {
1463 m_hScrollBar->Show( showHScrollBar );
1464 triggerSizeEvent = true;
1465 }
1466 }
1467
1468 if ( m_vScrollBar)
1469 {
1470 bool showVScrollBar = m_vScrollBarAlwaysShown || m_vScrollBar->IsNeeded();
1471
1472 if ( m_vScrollBar->IsShown() != showVScrollBar )
1473 {
1474 m_vScrollBar->Show( showVScrollBar ) ;
1475 triggerSizeEvent = true;
1476 }
1477 }
1478
1479 MacRepositionScrollBars() ;
1480 if ( triggerSizeEvent )
1481 {
1482 wxSizeEvent event(GetSize(), m_windowId);
1483 event.SetEventObject(this);
1484 HandleWindowEvent(event);
1485 }
1486 #endif
1487 }
1488
1489 // New function that will replace some of the above.
1490 void wxWindowMac::SetScrollbar(int orient, int pos, int thumb,
1491 int range, bool refresh)
1492 {
1493 #if wxUSE_SCROLLBAR
1494 if ( orient == wxHORIZONTAL && m_hScrollBar )
1495 m_hScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
1496 else if ( orient == wxVERTICAL && m_vScrollBar )
1497 m_vScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
1498
1499 DoUpdateScrollbarVisibility();
1500 #endif
1501 }
1502
1503 // Does a physical scroll
1504 void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
1505 {
1506 if ( dx == 0 && dy == 0 )
1507 return ;
1508
1509 int width , height ;
1510 GetClientSize( &width , &height ) ;
1511
1512 {
1513 wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
1514 if ( rect )
1515 scrollrect.Intersect( *rect ) ;
1516 // as the native control might be not a 0/0 wx window coordinates, we have to offset
1517 scrollrect.Offset( -MacGetLeftBorderSize() , -MacGetTopBorderSize() ) ;
1518
1519 m_peer->ScrollRect( &scrollrect, dx, dy );
1520 }
1521
1522 wxWindowMac *child;
1523 int x, y, w, h;
1524 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
1525 {
1526 child = node->GetData();
1527 if (child == NULL)
1528 continue;
1529 #if wxUSE_SCROLLBAR
1530 if (child == m_vScrollBar)
1531 continue;
1532 if (child == m_hScrollBar)
1533 continue;
1534 if (child == m_growBox)
1535 continue;
1536 #endif
1537 if (child->IsTopLevel())
1538 continue;
1539
1540 child->GetPosition( &x, &y );
1541 child->GetSize( &w, &h );
1542 if (rect)
1543 {
1544 wxRect rc( x, y, w, h );
1545 if (rect->Intersects( rc ))
1546 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
1547 }
1548 else
1549 {
1550 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
1551 }
1552 }
1553 }
1554
1555 void wxWindowMac::MacOnScroll( wxScrollEvent &event )
1556 {
1557 #if wxUSE_SCROLLBAR
1558 if ( event.GetEventObject() == m_vScrollBar || event.GetEventObject() == m_hScrollBar )
1559 {
1560 wxScrollWinEvent wevent;
1561 wevent.SetPosition(event.GetPosition());
1562 wevent.SetOrientation(event.GetOrientation());
1563 wevent.SetEventObject(this);
1564
1565 if (event.GetEventType() == wxEVT_SCROLL_TOP)
1566 wevent.SetEventType( wxEVT_SCROLLWIN_TOP );
1567 else if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
1568 wevent.SetEventType( wxEVT_SCROLLWIN_BOTTOM );
1569 else if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
1570 wevent.SetEventType( wxEVT_SCROLLWIN_LINEUP );
1571 else if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
1572 wevent.SetEventType( wxEVT_SCROLLWIN_LINEDOWN );
1573 else if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
1574 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEUP );
1575 else if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
1576 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEDOWN );
1577 else if (event.GetEventType() == wxEVT_SCROLL_THUMBTRACK)
1578 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBTRACK );
1579 else if (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE)
1580 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBRELEASE );
1581
1582 HandleWindowEvent(wevent);
1583 }
1584 #endif
1585 }
1586
1587 wxWindow *wxWindowBase::DoFindFocus()
1588 {
1589 return wxFindWindowFromWXWidget(wxWidgetImpl::FindFocus());
1590 }
1591
1592 void wxWindowMac::OnInternalIdle()
1593 {
1594 // This calls the UI-update mechanism (querying windows for
1595 // menu/toolbar/control state information)
1596 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1597 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1598 }
1599
1600 // Raise the window to the top of the Z order
1601 void wxWindowMac::Raise()
1602 {
1603 m_peer->Raise();
1604 }
1605
1606 // Lower the window to the bottom of the Z order
1607 void wxWindowMac::Lower()
1608 {
1609 m_peer->Lower();
1610 }
1611
1612 // static wxWindow *gs_lastWhich = NULL;
1613
1614 bool wxWindowMac::MacSetupCursor( const wxPoint& pt )
1615 {
1616 // first trigger a set cursor event
1617
1618 wxPoint clientorigin = GetClientAreaOrigin() ;
1619 wxSize clientsize = GetClientSize() ;
1620 wxCursor cursor ;
1621 if ( wxRect2DInt( clientorigin.x , clientorigin.y , clientsize.x , clientsize.y ).Contains( wxPoint2DInt( pt ) ) )
1622 {
1623 wxSetCursorEvent event( pt.x , pt.y );
1624
1625 bool processedEvtSetCursor = HandleWindowEvent(event);
1626 if ( processedEvtSetCursor && event.HasCursor() )
1627 {
1628 cursor = event.GetCursor() ;
1629 }
1630 else
1631 {
1632 // the test for processedEvtSetCursor is here to prevent using m_cursor
1633 // if the user code caught EVT_SET_CURSOR() and returned nothing from
1634 // it - this is a way to say that our cursor shouldn't be used for this
1635 // point
1636 if ( !processedEvtSetCursor && m_cursor.Ok() )
1637 cursor = m_cursor ;
1638
1639 if ( !wxIsBusy() && !GetParent() )
1640 cursor = *wxSTANDARD_CURSOR ;
1641 }
1642
1643 if ( cursor.Ok() )
1644 cursor.MacInstall() ;
1645 }
1646
1647 return cursor.Ok() ;
1648 }
1649
1650 wxString wxWindowMac::MacGetToolTipString( wxPoint &WXUNUSED(pt) )
1651 {
1652 #if wxUSE_TOOLTIPS
1653 if ( m_tooltip )
1654 return m_tooltip->GetTip() ;
1655 #endif
1656
1657 return wxEmptyString ;
1658 }
1659
1660 void wxWindowMac::ClearBackground()
1661 {
1662 Refresh() ;
1663 Update() ;
1664 }
1665
1666 void wxWindowMac::Update()
1667 {
1668 wxNonOwnedWindow* top = MacGetTopLevelWindow();
1669 if (top)
1670 top->Update() ;
1671 }
1672
1673 wxNonOwnedWindow* wxWindowMac::MacGetTopLevelWindow() const
1674 {
1675 wxWindowMac *iter = (wxWindowMac*)this ;
1676
1677 while ( iter )
1678 {
1679 if ( iter->IsTopLevel() )
1680 {
1681 wxTopLevelWindow* toplevel = wxDynamicCast(iter,wxTopLevelWindow);
1682 if ( toplevel )
1683 return toplevel;
1684 #if wxUSE_POPUPWIN
1685 wxPopupWindow* popupwin = wxDynamicCast(iter,wxPopupWindow);
1686 if ( popupwin )
1687 return popupwin;
1688 #endif
1689 }
1690 iter = iter->GetParent() ;
1691 }
1692
1693 return NULL ;
1694 }
1695
1696 const wxRect& wxWindowMac::MacGetClippedClientRect() const
1697 {
1698 MacUpdateClippedRects() ;
1699
1700 return m_cachedClippedClientRect ;
1701 }
1702
1703 const wxRect& wxWindowMac::MacGetClippedRect() const
1704 {
1705 MacUpdateClippedRects() ;
1706
1707 return m_cachedClippedRect ;
1708 }
1709
1710 const wxRect&wxWindowMac:: MacGetClippedRectWithOuterStructure() const
1711 {
1712 MacUpdateClippedRects() ;
1713
1714 return m_cachedClippedRectWithOuterStructure ;
1715 }
1716
1717 const wxRegion& wxWindowMac::MacGetVisibleRegion( bool includeOuterStructures )
1718 {
1719 static wxRegion emptyrgn ;
1720
1721 if ( !m_isBeingDeleted && IsShownOnScreen() )
1722 {
1723 MacUpdateClippedRects() ;
1724 if ( includeOuterStructures )
1725 return m_cachedClippedRegionWithOuterStructure ;
1726 else
1727 return m_cachedClippedRegion ;
1728 }
1729 else
1730 {
1731 return emptyrgn ;
1732 }
1733 }
1734
1735 void wxWindowMac::MacUpdateClippedRects() const
1736 {
1737 #if wxOSX_USE_CARBON
1738 if ( m_cachedClippedRectValid )
1739 return ;
1740
1741 // includeOuterStructures is true if we try to draw somthing like a focus ring etc.
1742 // also a window dc uses this, in this case we only clip in the hierarchy for hard
1743 // borders like a scrollwindow, splitter etc otherwise we end up in a paranoia having
1744 // to add focus borders everywhere
1745
1746 Rect rIncludingOuterStructures ;
1747
1748 int tx,ty,tw,th;
1749
1750 m_peer->GetSize( tw, th );
1751 m_peer->GetPosition( tx, ty );
1752
1753 Rect r = { ty,tx, ty+th, tx+tw };
1754
1755 r.left -= MacGetLeftBorderSize() ;
1756 r.top -= MacGetTopBorderSize() ;
1757 r.bottom += MacGetBottomBorderSize() ;
1758 r.right += MacGetRightBorderSize() ;
1759
1760 r.right -= r.left ;
1761 r.bottom -= r.top ;
1762 r.left = 0 ;
1763 r.top = 0 ;
1764
1765 rIncludingOuterStructures = r ;
1766 InsetRect( &rIncludingOuterStructures , -4 , -4 ) ;
1767
1768 wxRect cl = GetClientRect() ;
1769 Rect rClient = { cl.y , cl.x , cl.y + cl.height , cl.x + cl.width } ;
1770
1771 int x , y ;
1772 wxSize size ;
1773 const wxWindow* child = (wxWindow*) this ;
1774 const wxWindow* parent = NULL ;
1775
1776 while ( !child->IsTopLevel() && ( parent = child->GetParent() ) != NULL )
1777 {
1778 if ( parent->MacIsChildOfClientArea(child) )
1779 {
1780 size = parent->GetClientSize() ;
1781 wxPoint origin = parent->GetClientAreaOrigin() ;
1782 x = origin.x ;
1783 y = origin.y ;
1784 }
1785 else
1786 {
1787 // this will be true for scrollbars, toolbars etc.
1788 size = parent->GetSize() ;
1789 y = parent->MacGetTopBorderSize() ;
1790 x = parent->MacGetLeftBorderSize() ;
1791 size.x -= parent->MacGetLeftBorderSize() + parent->MacGetRightBorderSize() ;
1792 size.y -= parent->MacGetTopBorderSize() + parent->MacGetBottomBorderSize() ;
1793 }
1794
1795 parent->MacWindowToRootWindow( &x, &y ) ;
1796 MacRootWindowToWindow( &x , &y ) ;
1797
1798 Rect rparent = { y , x , y + size.y , x + size.x } ;
1799
1800 // the wxwindow and client rects will always be clipped
1801 SectRect( &r , &rparent , &r ) ;
1802 SectRect( &rClient , &rparent , &rClient ) ;
1803
1804 // the structure only at 'hard' borders
1805 if ( parent->MacClipChildren() ||
1806 ( parent->GetParent() && parent->GetParent()->MacClipGrandChildren() ) )
1807 {
1808 SectRect( &rIncludingOuterStructures , &rparent , &rIncludingOuterStructures ) ;
1809 }
1810
1811 child = parent ;
1812 }
1813
1814 m_cachedClippedRect = wxRect( r.left , r.top , r.right - r.left , r.bottom - r.top ) ;
1815 m_cachedClippedClientRect = wxRect( rClient.left , rClient.top ,
1816 rClient.right - rClient.left , rClient.bottom - rClient.top ) ;
1817 m_cachedClippedRectWithOuterStructure = wxRect(
1818 rIncludingOuterStructures.left , rIncludingOuterStructures.top ,
1819 rIncludingOuterStructures.right - rIncludingOuterStructures.left ,
1820 rIncludingOuterStructures.bottom - rIncludingOuterStructures.top ) ;
1821
1822 m_cachedClippedRegionWithOuterStructure = wxRegion( m_cachedClippedRectWithOuterStructure ) ;
1823 m_cachedClippedRegion = wxRegion( m_cachedClippedRect ) ;
1824 m_cachedClippedClientRegion = wxRegion( m_cachedClippedClientRect ) ;
1825
1826 m_cachedClippedRectValid = true ;
1827 #endif
1828 }
1829
1830 /*
1831 This function must not change the updatergn !
1832 */
1833 bool wxWindowMac::MacDoRedraw( long time )
1834 {
1835 bool handled = false ;
1836
1837 wxRegion formerUpdateRgn = m_updateRegion;
1838 wxRegion clientUpdateRgn = formerUpdateRgn;
1839
1840 const wxRect clientRect = GetClientRect();
1841
1842 clientUpdateRgn.Intersect(clientRect);
1843
1844 // first send an erase event to the entire update area
1845 const wxBackgroundStyle bgStyle = GetBackgroundStyle();
1846 switch ( bgStyle )
1847 {
1848 case wxBG_STYLE_ERASE:
1849 case wxBG_STYLE_SYSTEM:
1850 {
1851 // for the toplevel window this really is the entire area for
1852 // all the others only their client area, otherwise they might
1853 // be drawing with full alpha and eg put blue into the grow-box
1854 // area of a scrolled window (scroll sample)
1855 wxWindowDC dc(this);
1856 if ( IsTopLevel() )
1857 dc.SetDeviceClippingRegion(formerUpdateRgn);
1858 else
1859 dc.SetDeviceClippingRegion(clientUpdateRgn);
1860
1861 if ( bgStyle == wxBG_STYLE_ERASE )
1862 {
1863 wxEraseEvent eevent( GetId(), &dc );
1864 eevent.SetEventObject( this );
1865 if ( ProcessWindowEvent( eevent ) )
1866 break;
1867 }
1868
1869 if ( UseBgCol() )
1870 {
1871 dc.SetBackground(GetBackgroundColour());
1872 dc.Clear();
1873 }
1874 }
1875 break;
1876
1877 case wxBG_STYLE_PAINT:
1878 // nothing to do, user-defined EVT_PAINT handler will overwrite the
1879 // entire window client area
1880 break;
1881
1882 default:
1883 wxFAIL_MSG( "unsupported background style" );
1884 }
1885
1886 MacPaintGrowBox();
1887
1888 // calculate a client-origin version of the update rgn and set
1889 // m_updateRegion to that
1890 clientUpdateRgn.Offset(-clientRect.GetPosition());
1891 m_updateRegion = clientUpdateRgn ;
1892
1893 if ( !m_updateRegion.Empty() )
1894 {
1895 // paint the window itself
1896
1897 wxPaintEvent event(GetId());
1898 event.SetTimestamp(time);
1899 event.SetEventObject(this);
1900 handled = HandleWindowEvent(event);
1901 }
1902
1903 m_updateRegion = formerUpdateRgn;
1904 return handled;
1905 }
1906
1907 void wxWindowMac::MacPaintChildrenBorders()
1908 {
1909 // now we cannot rely on having its borders drawn by a window itself, as it does not
1910 // get the updateRgn wide enough to always do so, so we do it from the parent
1911 // this would also be the place to draw any custom backgrounds for native controls
1912 // in Composited windowing
1913 wxPoint clientOrigin = GetClientAreaOrigin() ;
1914
1915 wxWindowMac *child;
1916 int x, y, w, h;
1917 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
1918 {
1919 child = node->GetData();
1920 if (child == NULL)
1921 continue;
1922 #if wxUSE_SCROLLBAR
1923 if (child == m_vScrollBar)
1924 continue;
1925 if (child == m_hScrollBar)
1926 continue;
1927 if (child == m_growBox)
1928 continue;
1929 #endif
1930 if (child->IsTopLevel())
1931 continue;
1932 if (!child->IsShown())
1933 continue;
1934
1935 // only draw those in the update region (add a safety margin of 10 pixels for shadow effects
1936
1937 child->GetPosition( &x, &y );
1938 child->GetSize( &w, &h );
1939
1940 if ( m_updateRegion.Contains(clientOrigin.x+x-10, clientOrigin.y+y-10, w+20, h+20) )
1941 {
1942 // paint custom borders
1943 wxNcPaintEvent eventNc( child->GetId() );
1944 eventNc.SetEventObject( child );
1945 if ( !child->HandleWindowEvent( eventNc ) )
1946 {
1947 child->MacPaintBorders(0, 0) ;
1948 }
1949 }
1950 }
1951 }
1952
1953
1954 WXWindow wxWindowMac::MacGetTopLevelWindowRef() const
1955 {
1956 wxNonOwnedWindow* tlw = MacGetTopLevelWindow();
1957 return tlw ? tlw->GetWXWindow() : NULL ;
1958 }
1959
1960 bool wxWindowMac::MacHasScrollBarCorner() const
1961 {
1962 #if wxUSE_SCROLLBAR
1963 /* Returns whether the scroll bars in a wxScrolledWindow should be
1964 * shortened. Scroll bars should be shortened if either:
1965 *
1966 * - both scroll bars are visible, or
1967 *
1968 * - there is a resize box in the parent frame's corner and this
1969 * window shares the bottom and right edge with the parent
1970 * frame.
1971 */
1972
1973 if ( m_hScrollBar == NULL && m_vScrollBar == NULL )
1974 return false;
1975
1976 if ( ( m_hScrollBar && m_hScrollBar->IsShown() )
1977 && ( m_vScrollBar && m_vScrollBar->IsShown() ) )
1978 {
1979 // Both scroll bars visible
1980 return true;
1981 }
1982 else
1983 {
1984 wxPoint thisWindowBottomRight = GetScreenRect().GetBottomRight();
1985
1986 for ( const wxWindow *win = (wxWindow*)this; win; win = win->GetParent() )
1987 {
1988 const wxFrame *frame = wxDynamicCast( win, wxFrame ) ;
1989 if ( frame )
1990 {
1991 if ( frame->GetWindowStyleFlag() & wxRESIZE_BORDER )
1992 {
1993 // Parent frame has resize handle
1994 wxPoint frameBottomRight = frame->GetScreenRect().GetBottomRight();
1995
1996 // Note: allow for some wiggle room here as wxMac's
1997 // window rect calculations seem to be imprecise
1998 if ( abs( thisWindowBottomRight.x - frameBottomRight.x ) <= 2
1999 && abs( thisWindowBottomRight.y - frameBottomRight.y ) <= 2 )
2000 {
2001 // Parent frame has resize handle and shares
2002 // right bottom corner
2003 return true ;
2004 }
2005 else
2006 {
2007 // Parent frame has resize handle but doesn't
2008 // share right bottom corner
2009 return false ;
2010 }
2011 }
2012 else
2013 {
2014 // Parent frame doesn't have resize handle
2015 return false ;
2016 }
2017 }
2018 }
2019
2020 // No parent frame found
2021 return false ;
2022 }
2023 #else
2024 return false;
2025 #endif
2026 }
2027
2028 void wxWindowMac::MacCreateScrollBars( long style )
2029 {
2030 #if wxUSE_SCROLLBAR
2031 wxASSERT_MSG( m_vScrollBar == NULL && m_hScrollBar == NULL , wxT("attempt to create window twice") ) ;
2032
2033 if ( style & ( wxVSCROLL | wxHSCROLL ) )
2034 {
2035 int scrlsize = MAC_SCROLLBAR_SIZE ;
2036 if ( GetWindowVariant() == wxWINDOW_VARIANT_SMALL || GetWindowVariant() == wxWINDOW_VARIANT_MINI )
2037 {
2038 scrlsize = MAC_SMALL_SCROLLBAR_SIZE ;
2039 }
2040
2041 int adjust = MacHasScrollBarCorner() ? scrlsize - 1: 0 ;
2042 int width, height ;
2043 GetClientSize( &width , &height ) ;
2044
2045 wxPoint vPoint(width - scrlsize, 0) ;
2046 wxSize vSize(scrlsize, height - adjust) ;
2047 wxPoint hPoint(0, height - scrlsize) ;
2048 wxSize hSize(width - adjust, scrlsize) ;
2049
2050 // we have to set the min size to a smaller value, otherwise they cannot get smaller (InitialSize sets MinSize)
2051 if ( style & wxVSCROLL )
2052 {
2053 m_vScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, vPoint, vSize , wxVERTICAL);
2054 m_vScrollBar->SetMinSize( wxDefaultSize );
2055 }
2056
2057 if ( style & wxHSCROLL )
2058 {
2059 m_hScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, hPoint, hSize , wxHORIZONTAL);
2060 m_hScrollBar->SetMinSize( wxDefaultSize );
2061 }
2062
2063 wxPoint gPoint(width - scrlsize, height - scrlsize);
2064 wxSize gSize(scrlsize, scrlsize);
2065 m_growBox = new wxPanel((wxWindow *)this, wxID_ANY, gPoint, gSize, 0);
2066 }
2067
2068 // because the create does not take into account the client area origin
2069 // we might have a real position shift
2070 MacRepositionScrollBars() ;
2071 #endif
2072 }
2073
2074 bool wxWindowMac::MacIsChildOfClientArea( const wxWindow* child ) const
2075 {
2076 bool result = ((child == NULL)
2077 #if wxUSE_SCROLLBAR
2078 || ((child != m_hScrollBar) && (child != m_vScrollBar) && (child != m_growBox))
2079 #endif
2080 );
2081
2082 return result ;
2083 }
2084
2085 void wxWindowMac::MacRepositionScrollBars()
2086 {
2087 #if wxUSE_SCROLLBAR
2088 if ( !m_hScrollBar && !m_vScrollBar )
2089 return ;
2090
2091 int scrlsize = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2092 int adjust = MacHasScrollBarCorner() ? scrlsize - 1 : 0 ;
2093
2094 // get real client area
2095 int width, height ;
2096 GetSize( &width , &height );
2097
2098 width -= MacGetLeftBorderSize() + MacGetRightBorderSize();
2099 height -= MacGetTopBorderSize() + MacGetBottomBorderSize();
2100
2101 wxPoint vPoint( width - scrlsize, 0 ) ;
2102 wxSize vSize( scrlsize, height - adjust ) ;
2103 wxPoint hPoint( 0 , height - scrlsize ) ;
2104 wxSize hSize( width - adjust, scrlsize ) ;
2105
2106 if ( m_vScrollBar )
2107 m_vScrollBar->SetSize( vPoint.x , vPoint.y, vSize.x, vSize.y , wxSIZE_ALLOW_MINUS_ONE );
2108 if ( m_hScrollBar )
2109 m_hScrollBar->SetSize( hPoint.x , hPoint.y, hSize.x, hSize.y, wxSIZE_ALLOW_MINUS_ONE );
2110 if ( m_growBox )
2111 {
2112 if ( MacHasScrollBarCorner() )
2113 {
2114 m_growBox->SetSize( width - scrlsize, height - scrlsize, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING );
2115 if ( !m_growBox->IsShown() )
2116 m_growBox->Show();
2117 }
2118 else
2119 {
2120 if ( m_growBox->IsShown() )
2121 m_growBox->Hide();
2122 }
2123 }
2124 #endif
2125 }
2126
2127 bool wxWindowMac::AcceptsFocus() const
2128 {
2129 if ( MacIsUserPane() )
2130 return wxWindowBase::AcceptsFocus();
2131 else
2132 return m_peer->CanFocus();
2133 }
2134
2135 void wxWindowMac::MacSuperChangedPosition()
2136 {
2137 // only window-absolute structures have to be moved i.e. controls
2138
2139 m_cachedClippedRectValid = false ;
2140
2141 wxWindowMac *child;
2142 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2143 while ( node )
2144 {
2145 child = node->GetData();
2146 child->MacSuperChangedPosition() ;
2147
2148 node = node->GetNext();
2149 }
2150 }
2151
2152 void wxWindowMac::MacTopLevelWindowChangedPosition()
2153 {
2154 // only screen-absolute structures have to be moved i.e. glcanvas
2155
2156 wxWindowMac *child;
2157 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2158 while ( node )
2159 {
2160 child = node->GetData();
2161 child->MacTopLevelWindowChangedPosition() ;
2162
2163 node = node->GetNext();
2164 }
2165 }
2166
2167 long wxWindowMac::MacGetLeftBorderSize() const
2168 {
2169 if ( IsTopLevel() )
2170 return 0 ;
2171
2172 SInt32 border = 0 ;
2173
2174 if ( m_peer && m_peer->NeedsFrame() )
2175 {
2176 if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER))
2177 {
2178 #if wxOSX_USE_COCOA_OR_CARBON
2179 // this metric is only the 'outset' outside the simple frame rect
2180 GetThemeMetric( kThemeMetricEditTextFrameOutset , &border ) ;
2181 border += 1;
2182 #else
2183 border += 2;
2184 #endif
2185 }
2186 else if (HasFlag(wxSIMPLE_BORDER))
2187 {
2188 #if wxOSX_USE_COCOA_OR_CARBON
2189 // this metric is only the 'outset' outside the simple frame rect
2190 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
2191 border += 1;
2192 #else
2193 border += 1;
2194 #endif
2195 }
2196 }
2197
2198 return border ;
2199 }
2200
2201 long wxWindowMac::MacGetRightBorderSize() const
2202 {
2203 // they are all symmetric in mac themes
2204 return MacGetLeftBorderSize() ;
2205 }
2206
2207 long wxWindowMac::MacGetTopBorderSize() const
2208 {
2209 // they are all symmetric in mac themes
2210 return MacGetLeftBorderSize() ;
2211 }
2212
2213 long wxWindowMac::MacGetBottomBorderSize() const
2214 {
2215 // they are all symmetric in mac themes
2216 return MacGetLeftBorderSize() ;
2217 }
2218
2219 long wxWindowMac::MacRemoveBordersFromStyle( long style )
2220 {
2221 return style & ~wxBORDER_MASK ;
2222 }
2223
2224 // Find the wxWindowMac at the current mouse position, returning the mouse
2225 // position.
2226 wxWindow * wxFindWindowAtPointer( wxPoint& pt )
2227 {
2228 pt = wxGetMousePosition();
2229 wxWindowMac* found = wxFindWindowAtPoint(pt);
2230
2231 return (wxWindow*) found;
2232 }
2233
2234 // Get the current mouse position.
2235 wxPoint wxGetMousePosition()
2236 {
2237 int x, y;
2238
2239 wxGetMousePosition( &x, &y );
2240
2241 return wxPoint(x, y);
2242 }
2243
2244 void wxWindowMac::OnMouseEvent( wxMouseEvent &event )
2245 {
2246 if ( event.GetEventType() == wxEVT_RIGHT_DOWN )
2247 {
2248 // copied from wxGTK : CS
2249 // VZ: shouldn't we move this to base class then?
2250
2251 // generate a "context menu" event: this is similar to wxEVT_RIGHT_DOWN
2252 // except that:
2253 //
2254 // (a) it's a command event and so is propagated to the parent
2255 // (b) under MSW it can be generated from kbd too
2256 // (c) it uses screen coords (because of (a))
2257 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
2258 this->GetId(),
2259 this->ClientToScreen(event.GetPosition()));
2260 evtCtx.SetEventObject(this);
2261 if ( ! HandleWindowEvent(evtCtx) )
2262 event.Skip() ;
2263 }
2264 else
2265 {
2266 event.Skip() ;
2267 }
2268 }
2269
2270 void wxWindowMac::TriggerScrollEvent( wxEventType WXUNUSED(scrollEvent) )
2271 {
2272 }
2273
2274 Rect wxMacGetBoundsForControl( wxWindowMac* window , const wxPoint& pos , const wxSize &size , bool adjustForOrigin )
2275 {
2276 int x, y, w, h ;
2277
2278 window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin ) ;
2279 Rect bounds = { y, x, y + h, x + w };
2280
2281 return bounds ;
2282 }
2283
2284 bool wxWindowMac::OSXHandleClicked( double WXUNUSED(timestampsec) )
2285 {
2286 return false;
2287 }
2288
2289 wxInt32 wxWindowMac::MacControlHit(WXEVENTHANDLERREF WXUNUSED(handler) , WXEVENTREF event )
2290 {
2291 #if wxOSX_USE_COCOA_OR_CARBON
2292 if ( OSXHandleClicked( GetEventTime((EventRef)event) ) )
2293 return noErr;
2294
2295 return eventNotHandledErr ;
2296 #else
2297 return 0;
2298 #endif
2299 }
2300
2301 bool wxWindowMac::Reparent(wxWindowBase *newParentBase)
2302 {
2303 wxWindowMac *newParent = (wxWindowMac *)newParentBase;
2304 if ( !wxWindowBase::Reparent(newParent) )
2305 return false;
2306
2307 m_peer->RemoveFromParent();
2308 m_peer->Embed( GetParent()->GetPeer() );
2309
2310 MacChildAdded();
2311 return true;
2312 }
2313
2314 bool wxWindowMac::SetTransparent(wxByte alpha)
2315 {
2316 SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
2317
2318 if ( alpha != m_macAlpha )
2319 {
2320 m_macAlpha = alpha ;
2321 Refresh() ;
2322 }
2323 return true ;
2324 }
2325
2326
2327 bool wxWindowMac::CanSetTransparent()
2328 {
2329 return true ;
2330 }
2331
2332 wxByte wxWindowMac::GetTransparent() const
2333 {
2334 return m_macAlpha ;
2335 }
2336
2337 bool wxWindowMac::IsShownOnScreen() const
2338 {
2339 if ( m_peer && m_peer->IsOk() )
2340 {
2341 bool peerVis = m_peer->IsVisible();
2342 bool wxVis = wxWindowBase::IsShownOnScreen();
2343 if( peerVis != wxVis )
2344 {
2345 // CS : put a breakpoint here to investigate differences
2346 // between native an wx visibilities
2347 // the only place where I've encountered them until now
2348 // are the hiding/showing sequences where the vis-changed event is
2349 // first sent to the innermost control, while wx does things
2350 // from the outmost control
2351 wxVis = wxWindowBase::IsShownOnScreen();
2352 return wxVis;
2353 }
2354
2355 return m_peer->IsVisible();
2356 }
2357 return wxWindowBase::IsShownOnScreen();
2358 }
2359
2360 bool wxWindowMac::OSXHandleKeyEvent( wxKeyEvent& event )
2361 {
2362 bool handled = HandleWindowEvent( event ) ;
2363 if ( handled && event.GetSkipped() )
2364 handled = false ;
2365
2366 #if wxUSE_ACCEL
2367 if ( !handled && event.GetEventType() == wxEVT_KEY_DOWN)
2368 {
2369 wxWindow *ancestor = this;
2370 while (ancestor)
2371 {
2372 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
2373 if (command != -1)
2374 {
2375 wxEvtHandler * const handler = ancestor->GetEventHandler();
2376
2377 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
2378 handled = handler->ProcessEvent( command_event );
2379
2380 if ( !handled )
2381 {
2382 // accelerators can also be used with buttons, try them too
2383 command_event.SetEventType(wxEVT_COMMAND_BUTTON_CLICKED);
2384 handled = handler->ProcessEvent( command_event );
2385 }
2386
2387 break;
2388 }
2389
2390 if (ancestor->IsTopLevel())
2391 break;
2392
2393 ancestor = ancestor->GetParent();
2394 }
2395 }
2396 #endif // wxUSE_ACCEL
2397
2398 return handled ;
2399 }
2400
2401 //
2402 // wxWidgetImpl
2403 //
2404
2405 WX_DECLARE_HASH_MAP(WXWidget, wxWidgetImpl*, wxPointerHash, wxPointerEqual, MacControlMap);
2406
2407 static MacControlMap wxWinMacControlList;
2408
2409 wxWindowMac *wxFindWindowFromWXWidget(WXWidget inControl )
2410 {
2411 wxWidgetImpl* impl = wxWidgetImpl::FindFromWXWidget( inControl );
2412 if ( impl )
2413 return impl->GetWXPeer();
2414
2415 return NULL;
2416 }
2417
2418 wxWidgetImpl *wxWidgetImpl::FindFromWXWidget(WXWidget inControl )
2419 {
2420 MacControlMap::iterator node = wxWinMacControlList.find(inControl);
2421
2422 return (node == wxWinMacControlList.end()) ? NULL : node->second;
2423 }
2424
2425 void wxWidgetImpl::Associate(WXWidget inControl, wxWidgetImpl *impl)
2426 {
2427 // adding NULL ControlRef is (first) surely a result of an error and
2428 // (secondly) breaks native event processing
2429 wxCHECK_RET( inControl != (WXWidget) NULL, wxT("attempt to add a NULL WXWidget to control map") );
2430
2431 wxWinMacControlList[inControl] = impl;
2432 }
2433
2434 void wxWidgetImpl::RemoveAssociations(wxWidgetImpl* impl)
2435 {
2436 // iterate over all the elements in the class
2437 // is the iterator stable ? as we might have two associations pointing to the same wxWindow
2438 // we should go on...
2439
2440 bool found = true ;
2441 while ( found )
2442 {
2443 found = false ;
2444 MacControlMap::iterator it;
2445 for ( it = wxWinMacControlList.begin(); it != wxWinMacControlList.end(); ++it )
2446 {
2447 if ( it->second == impl )
2448 {
2449 wxWinMacControlList.erase(it);
2450 found = true ;
2451 break;
2452 }
2453 }
2454 }
2455 }
2456
2457 IMPLEMENT_ABSTRACT_CLASS( wxWidgetImpl , wxObject )
2458
2459 wxWidgetImpl::wxWidgetImpl( wxWindowMac* peer , bool isRootControl )
2460 {
2461 Init();
2462 m_isRootControl = isRootControl;
2463 m_wxPeer = peer;
2464 }
2465
2466 wxWidgetImpl::wxWidgetImpl()
2467 {
2468 Init();
2469 }
2470
2471 wxWidgetImpl::~wxWidgetImpl()
2472 {
2473 }
2474
2475 void wxWidgetImpl::Init()
2476 {
2477 m_isRootControl = false;
2478 m_wxPeer = NULL;
2479 m_needsFocusRect = false;
2480 m_needsFrame = true;
2481 }
2482
2483 void wxWidgetImpl::SetNeedsFocusRect( bool needs )
2484 {
2485 m_needsFocusRect = needs;
2486 }
2487
2488 bool wxWidgetImpl::NeedsFocusRect() const
2489 {
2490 return m_needsFocusRect;
2491 }
2492
2493 void wxWidgetImpl::SetNeedsFrame( bool needs )
2494 {
2495 m_needsFrame = needs;
2496 }
2497
2498 bool wxWidgetImpl::NeedsFrame() const
2499 {
2500 return m_needsFrame;
2501 }