]> git.saurik.com Git - wxWidgets.git/blame - src/osx/window_osx.cpp
Remove unused global bitmap, which caused crash on startup with wxUSE_XPM==0.
[wxWidgets.git] / src / osx / window_osx.cpp
CommitLineData
524c47aa
SC
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
f55d9f74
SC
64#include "wx/graphics.h"
65
524c47aa
SC
66#if wxOSX_USE_CARBON
67#include "wx/osx/uma.h"
68#else
69#include "wx/osx/private.h"
11fed901 70#endif
524c47aa
SC
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
83BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
524c47aa
SC
84 EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
85END_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
100wxWindowMac::wxWindowMac()
101{
102 Init();
103}
104
105wxWindowMac::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
116void 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;
2ae3afa0 129 m_growBox = NULL ;
524c47aa
SC
130
131 m_macIsUserPane = true;
132 m_clipChildren = false ;
133 m_cachedClippedRectValid = false ;
134}
135
136wxWindowMac::~wxWindowMac()
137{
138 SendDestroyEvent();
139
524c47aa
SC
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 )
d3b9f782 150 frame->SetLastFocus(NULL);
524c47aa
SC
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
193WXWidget wxWindowMac::GetHandle() const
194{
d4e4ba48
SC
195 if ( m_peer )
196 return (WXWidget) m_peer->GetWXWidget() ;
197 return NULL;
524c47aa
SC
198}
199
524c47aa
SC
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
222bool 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
03647350 244 if ( (! IsKindOf(CLASSINFO(wxControl))
11fed901
SC
245#if wxUSE_STATUSBAR
246 && ! IsKindOf(CLASSINFO(wxStatusBar))
247#endif
248 )
524c47aa
SC
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
261void wxWindowMac::MacChildAdded()
262{
11fed901 263#if wxUSE_SCROLLBAR
524c47aa
SC
264 if ( m_vScrollBar )
265 m_vScrollBar->Raise() ;
266 if ( m_hScrollBar )
267 m_hScrollBar->Raise() ;
2ae3afa0
JS
268 if ( m_growBox )
269 m_growBox->Raise() ;
11fed901 270#endif
524c47aa
SC
271}
272
273void 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
524c47aa
SC
277 GetParent()->AddChild( this );
278
524c47aa 279 m_peer->InstallEventHandler();
c4825ef7 280 m_peer->Embed(GetParent()->GetPeer());
524c47aa 281
524c47aa
SC
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
f55d9f74
SC
289 // for controls we want to use best size for wxDefaultSize params )
290 if ( !m_macIsUserPane )
524c47aa
SC
291 SetInitialSize(size);
292
293 SetCursor( *wxSTANDARD_CURSOR ) ;
294}
295
296void 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 );
7ac5e1c9
SC
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:
9a83f860 335 wxFAIL_MSG(wxT("unexpected window variant"));
7ac5e1c9
SC
336 break ;
337 }
338 m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
339#endif
340
524c47aa
SC
341 wxFont font ;
342
b2088388 343 wxOSXSystemFont systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
524c47aa
SC
344
345 switch ( variant )
346 {
347 case wxWINDOW_VARIANT_NORMAL :
b2088388 348 systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
524c47aa
SC
349 break ;
350
351 case wxWINDOW_VARIANT_SMALL :
b2088388 352 systemFont = wxOSX_SYSTEM_FONT_SMALL ;
524c47aa
SC
353 break ;
354
355 case wxWINDOW_VARIANT_MINI :
b2088388 356 systemFont = wxOSX_SYSTEM_FONT_MINI ;
524c47aa
SC
357 break ;
358
359 case wxWINDOW_VARIANT_LARGE :
b2088388 360 systemFont = wxOSX_SYSTEM_FONT_NORMAL ;
524c47aa
SC
361 break ;
362
363 default:
9a83f860 364 wxFAIL_MSG(wxT("unexpected window variant"));
524c47aa
SC
365 break ;
366 }
367
b2088388 368 font.CreateSystemFont( systemFont ) ;
524c47aa
SC
369
370 SetFont( font ) ;
524c47aa
SC
371}
372
373void wxWindowMac::MacUpdateControlFont()
374{
f55d9f74
SC
375 if ( m_peer )
376 m_peer->SetFont( GetFont() , GetForegroundColour() , GetWindowStyle() ) ;
1e181c7a 377
524c47aa
SC
378 // do not trigger refreshes upon invisible and possible partly created objects
379 if ( IsShownOnScreen() )
380 Refresh() ;
381}
382
383bool wxWindowMac::SetFont(const wxFont& font)
384{
385 bool retval = wxWindowBase::SetFont( font );
386
387 MacUpdateControlFont() ;
388
389 return retval;
390}
391
392bool wxWindowMac::SetForegroundColour(const wxColour& col )
393{
394 bool retval = wxWindowBase::SetForegroundColour( col );
395
396 if (retval)
397 MacUpdateControlFont();
398
399 return retval;
400}
401
402bool 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
77a246e1
JS
413static 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
524c47aa
SC
424void wxWindowMac::SetFocus()
425{
426 if ( !AcceptsFocus() )
427 return ;
428
77a246e1
JS
429 if (wxIsWindowOrParentDisabled((wxWindow*) this))
430 return;
431
524c47aa
SC
432 wxWindow* former = FindFocus() ;
433 if ( former == this )
434 return ;
435
436 m_peer->SetFocus() ;
437}
438
439void wxWindowMac::DoCaptureMouse()
440{
441 wxApp::s_captureWindow = (wxWindow*) this ;
54f11060 442 m_peer->CaptureMouse() ;
524c47aa
SC
443}
444
445wxWindow * wxWindowBase::GetCapture()
446{
447 return wxApp::s_captureWindow ;
448}
449
450void wxWindowMac::DoReleaseMouse()
451{
452 wxApp::s_captureWindow = NULL ;
54f11060
SC
453
454 m_peer->ReleaseMouse() ;
524c47aa
SC
455}
456
457#if wxUSE_DRAG_AND_DROP
458
459void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
460{
0b1ca117 461 delete m_dropTarget;
524c47aa
SC
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
473void 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
480bool 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
69ce9cea
VZ
490 w = WidthDefault( size.x );
491 h = HeightDefault( size.y );
524c47aa
SC
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
1a4e2d5b 502 if ( GetParent() && !GetParent()->IsTopLevel() )
524c47aa
SC
503 {
504 x -= GetParent()->MacGetLeftBorderSize() ;
505 y -= GetParent()->MacGetTopBorderSize() ;
506 }
507
508 return true ;
509}
510
511// Get window size (not client size)
512void 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
524void wxWindowMac::DoGetPosition(int *x, int *y) const
525{
526 int x1, y1;
69ce9cea 527
524c47aa
SC
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
557void 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
571void 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
586void 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
597void 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
623void 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
649wxSize wxWindowMac::DoGetSizeFromClientSize( const wxSize & size ) const
650{
651 wxSize sizeTotal = size;
652
653 int innerwidth, innerheight;
654 int left, top;
655 int outerwidth, outerheight;
69ce9cea 656
524c47aa
SC
657 m_peer->GetContentArea( left, top, innerwidth, innerheight );
658 m_peer->GetSize( outerwidth, outerheight );
69ce9cea 659
0c530e5a
SC
660 sizeTotal.x += outerwidth-innerwidth;
661 sizeTotal.y += outerheight-innerheight;
69ce9cea 662
524c47aa
SC
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.
670void wxWindowMac::DoGetClientSize( int *x, int *y ) const
671{
672 int ww, hh;
673
674 int left, top;
69ce9cea 675
524c47aa 676 m_peer->GetContentArea( left, top, ww, hh );
11fed901 677#if wxUSE_SCROLLBAR
524c47aa
SC
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
11fed901 684#endif
524c47aa
SC
685 if (x)
686 *x = ww;
687 if (y)
688 *y = hh;
689}
690
691bool 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
54f11060
SC
710 if ( GetPeer() != NULL )
711 GetPeer()->SetCursor( m_cursor );
524c47aa
SC
712
713 return true ;
714}
715
716#if wxUSE_MENUS
717bool 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 }
2cb5d2d2 733 menu->GetPeer()->PopUp(this, x, y);
524c47aa 734 menu->SetInvokingWindow( NULL );
524c47aa
SC
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
749void wxWindowMac::DoSetToolTip(wxToolTip *tooltip)
750{
751 wxWindowBase::DoSetToolTip(tooltip);
752
753 if ( m_tooltip )
754 m_tooltip->SetWindow(this);
755}
756
757#endif
758
759void 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() ;
b2088388
SC
769
770 if ( m_peer->NeedsFocusRect() )
524c47aa 771 outerBorder += 4 ;
524c47aa
SC
772
773 if ( outerBorder == 0 )
774 return ;
775
776 // now we know that we have something to do at all
524c47aa
SC
777
778 int tx,ty,tw,th;
69ce9cea 779
524c47aa
SC
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 );
69ce9cea 787
1a4e2d5b
KO
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 }
524c47aa
SC
794}
795
796void 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
f1b1c779
SC
818#if 0
819 // min and max sizes are only for sizers, not for explicit size setting
524c47aa
SC
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;
f1b1c779 828#endif
524c47aa
SC
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
1a4e2d5b 846 if ( parent && !parent->IsTopLevel() )
524c47aa 847 {
1a4e2d5b 848 bounds.Offset( -parent->MacGetLeftBorderSize(), -parent->MacGetTopBorderSize() );
524c47aa
SC
849 }
850
851 MacInvalidateBorders() ;
852
853 m_cachedClippedRectValid = false ;
69ce9cea 854
524c47aa
SC
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
881wxSize wxWindowMac::DoGetBestSize() const
882{
883 if ( m_macIsUserPane || IsTopLevel() )
884 {
885 return wxWindowBase::DoGetBestSize() ;
886 }
887 else
888 {
889 wxRect r ;
69ce9cea 890
524c47aa
SC
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
03647350 900 if ( 0 )
11fed901
SC
901 {
902 }
903#if wxUSE_SCROLLBAR
904 else if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
524c47aa
SC
905 {
906 r.height = 16 ;
907 }
11fed901
SC
908#endif
909#if wxUSE_SPINBTN
524c47aa
SC
910 else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
911 {
912 r.height = 24 ;
913 }
11fed901 914#endif
524c47aa
SC
915 else
916 {
917 // return wxWindowBase::DoGetBestSize() ;
918 }
919 }
920
69ce9cea 921 int bestWidth = r.width + MacGetLeftBorderSize() +
524c47aa 922 MacGetRightBorderSize();
69ce9cea 923 int bestHeight = r.height + MacGetTopBorderSize() +
524c47aa
SC
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
940void 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
e47e063a
RR
956 if (sizeFlags & wxSIZE_FORCE_EVENT)
957 {
958 wxSizeEvent event( wxSize(width,height), GetId() );
959 event.SetEventObject( this );
960 HandleWindowEvent( event );
961 }
962
524c47aa
SC
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
1011wxPoint 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
1018void 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
1033void wxWindowMac::SetLabel(const wxString& title)
1034{
8c6c5778
VZ
1035 if ( title == m_label )
1036 return;
1037
524c47aa
SC
1038 m_label = title ;
1039
8c6c5778
VZ
1040 InvalidateBestSize();
1041
bad6c5e2 1042 if ( m_peer && m_peer->IsOk() )
524c47aa
SC
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
1050wxString wxWindowMac::GetLabel() const
1051{
1052 return m_label ;
1053}
1054
1055bool 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 return true;
1064}
1065
1066void wxWindowMac::DoEnable(bool enable)
1067{
1068 m_peer->Enable( enable ) ;
1069}
1070
1071//
1072// status change notifications
1073//
1074
1075void wxWindowMac::MacVisibilityChanged()
1076{
1077}
1078
1079void wxWindowMac::MacHiliteChanged()
1080{
1081}
1082
1083void wxWindowMac::MacEnabledStateChanged()
1084{
1085 OnEnabled( m_peer->IsEnabled() );
1086}
1087
1088//
1089// status queries on the inherited window's state
1090//
1091
1092bool wxWindowMac::MacIsReallyEnabled()
1093{
1094 return m_peer->IsEnabled() ;
1095}
1096
1097bool wxWindowMac::MacIsReallyHilited()
1098{
1099#if wxOSX_USE_CARBON
1100 return m_peer->IsActive();
1101#else
1102 return true; // TODO
1103#endif
1104}
1105
1106int wxWindowMac::GetCharHeight() const
1107{
f55d9f74
SC
1108 wxCoord height;
1109 GetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL );
524c47aa 1110
f55d9f74 1111 return height;
524c47aa
SC
1112}
1113
1114int wxWindowMac::GetCharWidth() const
1115{
f55d9f74
SC
1116 wxCoord width;
1117 GetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL );
524c47aa 1118
f55d9f74 1119 return width;
524c47aa
SC
1120}
1121
6de70470
VZ
1122void wxWindowMac::DoGetTextExtent(const wxString& str,
1123 int *x, int *y,
1124 int *descent,
1125 int *externalLeading,
1126 const wxFont *theFont) const
524c47aa
SC
1127{
1128 const wxFont *fontToUse = theFont;
1129 wxFont tempFont;
1130 if ( !fontToUse )
1131 {
1132 tempFont = GetFont();
1133 fontToUse = &tempFont;
1134 }
1135
f55d9f74
SC
1136 wxGraphicsContext* ctx = wxGraphicsContext::Create();
1137 ctx->SetFont( *fontToUse, *wxBLACK );
1138
1139 wxDouble h , d , e , w;
1140 ctx->GetTextExtent( str, &w, &h, &d, &e );
69ce9cea 1141
f55d9f74 1142 delete ctx;
69ce9cea 1143
524c47aa 1144 if ( externalLeading )
f55d9f74 1145 *externalLeading = (wxCoord)(e+0.5);
524c47aa 1146 if ( descent )
f55d9f74 1147 *descent = (wxCoord)(d+0.5);
524c47aa 1148 if ( x )
f55d9f74 1149 *x = (wxCoord)(w+0.5);
524c47aa 1150 if ( y )
f55d9f74 1151 *y = (wxCoord)(h+0.5);
524c47aa
SC
1152}
1153
1154/*
1155 * Rect is given in client coordinates, for further reading, read wxTopLevelWindowMac::InvalidateRect
1156 * we always intersect with the entire window, not only with the client area
1157 */
1158
1159void wxWindowMac::Refresh(bool WXUNUSED(eraseBack), const wxRect *rect)
1160{
1161 if ( m_peer == NULL )
1162 return ;
1163
1164 if ( !IsShownOnScreen() )
1165 return ;
69ce9cea 1166
524c47aa
SC
1167 m_peer->SetNeedsDisplay( rect ) ;
1168}
1169
1170void wxWindowMac::DoFreeze()
1171{
1172#if wxOSX_USE_CARBON
1173 if ( m_peer && m_peer->IsOk() )
1174 m_peer->SetDrawingEnabled( false ) ;
1175#endif
1176}
1177
1178void wxWindowMac::DoThaw()
1179{
1180#if wxOSX_USE_CARBON
1181 if ( m_peer && m_peer->IsOk() )
1182 {
1183 m_peer->SetDrawingEnabled( true ) ;
1184 m_peer->InvalidateWithChildren() ;
1185 }
1186#endif
1187}
1188
1189wxWindow *wxGetActiveWindow()
1190{
1191 // actually this is a windows-only concept
1192 return NULL;
1193}
1194
1195// Coordinates relative to the window
1508fcac 1196void wxWindowMac::WarpPointer(int x_pos, int y_pos)
524c47aa 1197{
1508fcac
JS
1198 int x = x_pos;
1199 int y = y_pos;
1200 DoClientToScreen(&x, &y);
1201 CGPoint cgpoint = CGPointMake( x, y );
1202 CGWarpMouseCursorPosition( cgpoint );
1203
1204 // At least GTK sends a mouse moved event after WarpMouse
1205 wxMouseEvent event(wxEVT_MOTION);
1206 event.m_x = x_pos;
1207 event.m_y = y_pos;
1208 wxMouseState mState = ::wxGetMouseState();
1209
1210 event.m_altDown = mState.AltDown();
1211 event.m_controlDown = mState.ControlDown();
1212 event.m_leftDown = mState.LeftDown();
1213 event.m_middleDown = mState.MiddleDown();
1214 event.m_rightDown = mState.RightDown();
1215 event.m_metaDown = mState.MetaDown();
1216 event.m_shiftDown = mState.ShiftDown();
1217 event.SetId(GetId());
1218 event.SetEventObject(this);
1219 GetEventHandler()->ProcessEvent(event);
524c47aa
SC
1220}
1221
524c47aa
SC
1222int wxWindowMac::GetScrollPos(int orient) const
1223{
11fed901 1224#if wxUSE_SCROLLBAR
524c47aa
SC
1225 if ( orient == wxHORIZONTAL )
1226 {
1227 if ( m_hScrollBar )
1228 return m_hScrollBar->GetThumbPosition() ;
1229 }
1230 else
1231 {
1232 if ( m_vScrollBar )
1233 return m_vScrollBar->GetThumbPosition() ;
1234 }
11fed901 1235#endif
524c47aa
SC
1236 return 0;
1237}
1238
1239// This now returns the whole range, not just the number
1240// of positions that we can scroll.
1241int wxWindowMac::GetScrollRange(int orient) const
1242{
11fed901 1243#if wxUSE_SCROLLBAR
524c47aa
SC
1244 if ( orient == wxHORIZONTAL )
1245 {
1246 if ( m_hScrollBar )
1247 return m_hScrollBar->GetRange() ;
1248 }
1249 else
1250 {
1251 if ( m_vScrollBar )
1252 return m_vScrollBar->GetRange() ;
1253 }
11fed901 1254#endif
524c47aa
SC
1255 return 0;
1256}
1257
1258int wxWindowMac::GetScrollThumb(int orient) const
1259{
11fed901 1260#if wxUSE_SCROLLBAR
524c47aa
SC
1261 if ( orient == wxHORIZONTAL )
1262 {
1263 if ( m_hScrollBar )
1264 return m_hScrollBar->GetThumbSize() ;
1265 }
1266 else
1267 {
1268 if ( m_vScrollBar )
1269 return m_vScrollBar->GetThumbSize() ;
1270 }
11fed901 1271#endif
524c47aa
SC
1272 return 0;
1273}
1274
1275void wxWindowMac::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
1276{
11fed901 1277#if wxUSE_SCROLLBAR
524c47aa
SC
1278 if ( orient == wxHORIZONTAL )
1279 {
1280 if ( m_hScrollBar )
1281 m_hScrollBar->SetThumbPosition( pos ) ;
1282 }
1283 else
1284 {
1285 if ( m_vScrollBar )
1286 m_vScrollBar->SetThumbPosition( pos ) ;
1287 }
11fed901 1288#endif
524c47aa
SC
1289}
1290
1291void
1292wxWindowMac::AlwaysShowScrollbars(bool hflag, bool vflag)
1293{
1294 bool needVisibilityUpdate = false;
1295
1296 if ( m_hScrollBarAlwaysShown != hflag )
1297 {
1298 m_hScrollBarAlwaysShown = hflag;
1299 needVisibilityUpdate = true;
1300 }
1301
1302 if ( m_vScrollBarAlwaysShown != vflag )
1303 {
1304 m_vScrollBarAlwaysShown = vflag;
1305 needVisibilityUpdate = true;
1306 }
1307
1308 if ( needVisibilityUpdate )
1309 DoUpdateScrollbarVisibility();
1310}
1311
1312//
1313// we draw borders and grow boxes, are already set up and clipped in the current port / cgContextRef
1314// our own window origin is at leftOrigin/rightOrigin
1315//
1316
1317void wxWindowMac::MacPaintGrowBox()
1318{
1319 if ( IsTopLevel() )
1320 return ;
1321
11fed901 1322#if wxUSE_SCROLLBAR
524c47aa
SC
1323 if ( MacHasScrollBarCorner() )
1324 {
2ae3afa0 1325#if 0
524c47aa
SC
1326 CGContextRef cgContext = (CGContextRef) MacGetCGContextRef() ;
1327 wxASSERT( cgContext ) ;
1328
1329 int tx,ty,tw,th;
69ce9cea 1330
524c47aa
SC
1331 m_peer->GetSize( tw, th );
1332 m_peer->GetPosition( tx, ty );
1333
1334 Rect rect = { ty,tx, ty+th, tx+tw };
1335
1336
1337 int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
1338 CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
524c47aa
SC
1339 CGContextSaveGState( cgContext );
1340
1341 if ( m_backgroundColour.Ok() )
1342 {
1343 CGContextSetFillColorWithColor( cgContext, m_backgroundColour.GetCGColor() );
1344 }
1345 else
1346 {
1347 CGContextSetRGBFillColor( cgContext, (CGFloat) 1.0, (CGFloat)1.0 ,(CGFloat) 1.0 , (CGFloat)1.0 );
1348 }
1349 CGContextFillRect( cgContext, cgrect );
1350 CGContextRestoreGState( cgContext );
2ae3afa0
JS
1351#else
1352 if (m_growBox)
1353 {
1354 if ( m_backgroundColour.Ok() )
1355 m_growBox->SetBackgroundColour(m_backgroundColour);
1356 else
1357 m_growBox->SetBackgroundColour(*wxWHITE);
1358 }
1359#endif
524c47aa 1360 }
2ae3afa0 1361
11fed901 1362#endif
524c47aa
SC
1363}
1364
1365void wxWindowMac::MacPaintBorders( int WXUNUSED(leftOrigin) , int WXUNUSED(rightOrigin) )
1366{
1367 if ( IsTopLevel() )
1368 return ;
1369
1370 bool hasFocus = m_peer->NeedsFocusRect() && m_peer->HasFocus() ;
1371
1372 // back to the surrounding frame rectangle
1373 int tx,ty,tw,th;
69ce9cea 1374
524c47aa
SC
1375 m_peer->GetSize( tw, th );
1376 m_peer->GetPosition( tx, ty );
1377
1378 Rect rect = { ty,tx, ty+th, tx+tw };
1379
1380#if wxOSX_USE_COCOA_OR_CARBON
1381
1382 InsetRect( &rect, -1 , -1 ) ;
1383
1384 {
1385 CGRect cgrect = CGRectMake( rect.left , rect.top , rect.right - rect.left ,
1386 rect.bottom - rect.top ) ;
1387
524c47aa
SC
1388 CGContextRef cgContext = (CGContextRef) GetParent()->MacGetCGContextRef() ;
1389 wxASSERT( cgContext ) ;
1390
f2f6030e 1391 if ( m_peer->NeedsFrame() )
524c47aa 1392 {
f2f6030e
SC
1393 HIThemeFrameDrawInfo info ;
1394 memset( &info, 0 , sizeof(info) ) ;
1395
1396 info.version = 0 ;
1397 info.kind = 0 ;
1398 info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
1399 info.isFocused = hasFocus ;
1400
1401 if ( HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER) )
1402 {
1403 info.kind = kHIThemeFrameTextFieldSquare ;
1404 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
1405 }
1406 else if ( HasFlag(wxSIMPLE_BORDER) )
1407 {
1408 info.kind = kHIThemeFrameListBox ;
1409 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
1410 }
524c47aa 1411 }
69ce9cea 1412
f2f6030e 1413 if ( hasFocus )
524c47aa
SC
1414 {
1415 HIThemeDrawFocusRect( &cgrect , true , cgContext , kHIThemeOrientationNormal ) ;
1416 }
524c47aa
SC
1417 }
1418#endif // wxOSX_USE_COCOA_OR_CARBON
1419}
1420
1421void wxWindowMac::RemoveChild( wxWindowBase *child )
1422{
11fed901 1423#if wxUSE_SCROLLBAR
524c47aa
SC
1424 if ( child == m_hScrollBar )
1425 m_hScrollBar = NULL ;
1426 if ( child == m_vScrollBar )
1427 m_vScrollBar = NULL ;
2ae3afa0
JS
1428 if ( child == m_growBox )
1429 m_growBox = NULL ;
11fed901 1430#endif
524c47aa
SC
1431 wxWindowBase::RemoveChild( child ) ;
1432}
1433
1434void wxWindowMac::DoUpdateScrollbarVisibility()
1435{
11fed901 1436#if wxUSE_SCROLLBAR
524c47aa
SC
1437 bool triggerSizeEvent = false;
1438
1439 if ( m_hScrollBar )
1440 {
1441 bool showHScrollBar = m_hScrollBarAlwaysShown || m_hScrollBar->IsNeeded();
1442
1443 if ( m_hScrollBar->IsShown() != showHScrollBar )
1444 {
1445 m_hScrollBar->Show( showHScrollBar );
1446 triggerSizeEvent = true;
1447 }
1448 }
1449
1450 if ( m_vScrollBar)
1451 {
1452 bool showVScrollBar = m_vScrollBarAlwaysShown || m_vScrollBar->IsNeeded();
1453
1454 if ( m_vScrollBar->IsShown() != showVScrollBar )
1455 {
1456 m_vScrollBar->Show( showVScrollBar ) ;
1457 triggerSizeEvent = true;
1458 }
1459 }
1460
1461 MacRepositionScrollBars() ;
1462 if ( triggerSizeEvent )
1463 {
1464 wxSizeEvent event(GetSize(), m_windowId);
1465 event.SetEventObject(this);
1466 HandleWindowEvent(event);
1467 }
11fed901 1468#endif
524c47aa
SC
1469}
1470
1471// New function that will replace some of the above.
1472void wxWindowMac::SetScrollbar(int orient, int pos, int thumb,
1473 int range, bool refresh)
1474{
11fed901 1475#if wxUSE_SCROLLBAR
524c47aa
SC
1476 if ( orient == wxHORIZONTAL && m_hScrollBar )
1477 m_hScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
1478 else if ( orient == wxVERTICAL && m_vScrollBar )
1479 m_vScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
1480
1481 DoUpdateScrollbarVisibility();
11fed901 1482#endif
524c47aa
SC
1483}
1484
1485// Does a physical scroll
1486void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
1487{
1488 if ( dx == 0 && dy == 0 )
1489 return ;
1490
1491 int width , height ;
1492 GetClientSize( &width , &height ) ;
1493
1494 {
1495 wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
1496 if ( rect )
1497 scrollrect.Intersect( *rect ) ;
1498 // as the native control might be not a 0/0 wx window coordinates, we have to offset
1499 scrollrect.Offset( -MacGetLeftBorderSize() , -MacGetTopBorderSize() ) ;
1500
1501 m_peer->ScrollRect( &scrollrect, dx, dy );
1502 }
1503
1504 wxWindowMac *child;
1505 int x, y, w, h;
1506 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
1507 {
1508 child = node->GetData();
1509 if (child == NULL)
1510 continue;
11fed901 1511#if wxUSE_SCROLLBAR
524c47aa
SC
1512 if (child == m_vScrollBar)
1513 continue;
1514 if (child == m_hScrollBar)
1515 continue;
2ae3afa0
JS
1516 if (child == m_growBox)
1517 continue;
11fed901 1518#endif
524c47aa
SC
1519 if (child->IsTopLevel())
1520 continue;
1521
1522 child->GetPosition( &x, &y );
1523 child->GetSize( &w, &h );
1524 if (rect)
1525 {
1526 wxRect rc( x, y, w, h );
1527 if (rect->Intersects( rc ))
1528 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
1529 }
1530 else
1531 {
1532 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
1533 }
1534 }
1535}
1536
1537void wxWindowMac::MacOnScroll( wxScrollEvent &event )
1538{
11fed901 1539#if wxUSE_SCROLLBAR
524c47aa
SC
1540 if ( event.GetEventObject() == m_vScrollBar || event.GetEventObject() == m_hScrollBar )
1541 {
1542 wxScrollWinEvent wevent;
1543 wevent.SetPosition(event.GetPosition());
1544 wevent.SetOrientation(event.GetOrientation());
1545 wevent.SetEventObject(this);
1546
1547 if (event.GetEventType() == wxEVT_SCROLL_TOP)
1548 wevent.SetEventType( wxEVT_SCROLLWIN_TOP );
1549 else if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
1550 wevent.SetEventType( wxEVT_SCROLLWIN_BOTTOM );
1551 else if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
1552 wevent.SetEventType( wxEVT_SCROLLWIN_LINEUP );
1553 else if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
1554 wevent.SetEventType( wxEVT_SCROLLWIN_LINEDOWN );
1555 else if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
1556 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEUP );
1557 else if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
1558 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEDOWN );
1559 else if (event.GetEventType() == wxEVT_SCROLL_THUMBTRACK)
1560 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBTRACK );
1561 else if (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE)
1562 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBRELEASE );
1563
1564 HandleWindowEvent(wevent);
1565 }
11fed901 1566#endif
524c47aa
SC
1567}
1568
524c47aa
SC
1569wxWindow *wxWindowBase::DoFindFocus()
1570{
f06e0fea 1571 return wxFindWindowFromWXWidget(wxWidgetImpl::FindFocus());
524c47aa
SC
1572}
1573
1574void wxWindowMac::OnInternalIdle()
1575{
1576 // This calls the UI-update mechanism (querying windows for
1577 // menu/toolbar/control state information)
1578 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1579 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1580}
1581
1582// Raise the window to the top of the Z order
1583void wxWindowMac::Raise()
1584{
1585 m_peer->Raise();
1586}
1587
1588// Lower the window to the bottom of the Z order
1589void wxWindowMac::Lower()
1590{
1591 m_peer->Lower();
1592}
1593
1594// static wxWindow *gs_lastWhich = NULL;
1595
1596bool wxWindowMac::MacSetupCursor( const wxPoint& pt )
1597{
1598 // first trigger a set cursor event
1599
1600 wxPoint clientorigin = GetClientAreaOrigin() ;
1601 wxSize clientsize = GetClientSize() ;
1602 wxCursor cursor ;
1603 if ( wxRect2DInt( clientorigin.x , clientorigin.y , clientsize.x , clientsize.y ).Contains( wxPoint2DInt( pt ) ) )
1604 {
1605 wxSetCursorEvent event( pt.x , pt.y );
1606
1607 bool processedEvtSetCursor = HandleWindowEvent(event);
1608 if ( processedEvtSetCursor && event.HasCursor() )
1609 {
1610 cursor = event.GetCursor() ;
1611 }
1612 else
1613 {
1614 // the test for processedEvtSetCursor is here to prevent using m_cursor
1615 // if the user code caught EVT_SET_CURSOR() and returned nothing from
1616 // it - this is a way to say that our cursor shouldn't be used for this
1617 // point
1618 if ( !processedEvtSetCursor && m_cursor.Ok() )
1619 cursor = m_cursor ;
1620
1621 if ( !wxIsBusy() && !GetParent() )
1622 cursor = *wxSTANDARD_CURSOR ;
1623 }
1624
1625 if ( cursor.Ok() )
1626 cursor.MacInstall() ;
1627 }
1628
1629 return cursor.Ok() ;
1630}
1631
1632wxString wxWindowMac::MacGetToolTipString( wxPoint &WXUNUSED(pt) )
1633{
1634#if wxUSE_TOOLTIPS
1635 if ( m_tooltip )
1636 return m_tooltip->GetTip() ;
1637#endif
1638
1639 return wxEmptyString ;
1640}
1641
1642void wxWindowMac::ClearBackground()
1643{
1644 Refresh() ;
1645 Update() ;
1646}
1647
1648void wxWindowMac::Update()
1649{
1650 wxNonOwnedWindow* top = MacGetTopLevelWindow();
1651 if (top)
1652 top->Update() ;
1653}
1654
1655wxNonOwnedWindow* wxWindowMac::MacGetTopLevelWindow() const
1656{
1657 wxWindowMac *iter = (wxWindowMac*)this ;
1658
1659 while ( iter )
1660 {
1661 if ( iter->IsTopLevel() )
1662 {
1663 wxTopLevelWindow* toplevel = wxDynamicCast(iter,wxTopLevelWindow);
1664 if ( toplevel )
1665 return toplevel;
1666#if wxUSE_POPUPWIN
1667 wxPopupWindow* popupwin = wxDynamicCast(iter,wxPopupWindow);
1668 if ( popupwin )
1669 return popupwin;
1670#endif
1671 }
1672 iter = iter->GetParent() ;
1673 }
1674
1675 return NULL ;
1676}
1677
1678const wxRect& wxWindowMac::MacGetClippedClientRect() const
1679{
1680 MacUpdateClippedRects() ;
1681
1682 return m_cachedClippedClientRect ;
1683}
1684
1685const wxRect& wxWindowMac::MacGetClippedRect() const
1686{
1687 MacUpdateClippedRects() ;
1688
1689 return m_cachedClippedRect ;
1690}
1691
1692const wxRect&wxWindowMac:: MacGetClippedRectWithOuterStructure() const
1693{
1694 MacUpdateClippedRects() ;
1695
1696 return m_cachedClippedRectWithOuterStructure ;
1697}
1698
1699const wxRegion& wxWindowMac::MacGetVisibleRegion( bool includeOuterStructures )
1700{
1701 static wxRegion emptyrgn ;
1702
1703 if ( !m_isBeingDeleted && IsShownOnScreen() )
1704 {
1705 MacUpdateClippedRects() ;
1706 if ( includeOuterStructures )
1707 return m_cachedClippedRegionWithOuterStructure ;
1708 else
1709 return m_cachedClippedRegion ;
1710 }
1711 else
1712 {
1713 return emptyrgn ;
1714 }
1715}
1716
1717void wxWindowMac::MacUpdateClippedRects() const
1718{
1719#if wxOSX_USE_CARBON
1720 if ( m_cachedClippedRectValid )
1721 return ;
1722
1723 // includeOuterStructures is true if we try to draw somthing like a focus ring etc.
1724 // also a window dc uses this, in this case we only clip in the hierarchy for hard
1725 // borders like a scrollwindow, splitter etc otherwise we end up in a paranoia having
1726 // to add focus borders everywhere
1727
1728 Rect rIncludingOuterStructures ;
1729
1730 int tx,ty,tw,th;
69ce9cea 1731
524c47aa
SC
1732 m_peer->GetSize( tw, th );
1733 m_peer->GetPosition( tx, ty );
1734
1735 Rect r = { ty,tx, ty+th, tx+tw };
1736
1737 r.left -= MacGetLeftBorderSize() ;
1738 r.top -= MacGetTopBorderSize() ;
1739 r.bottom += MacGetBottomBorderSize() ;
1740 r.right += MacGetRightBorderSize() ;
1741
1742 r.right -= r.left ;
1743 r.bottom -= r.top ;
1744 r.left = 0 ;
1745 r.top = 0 ;
1746
1747 rIncludingOuterStructures = r ;
1748 InsetRect( &rIncludingOuterStructures , -4 , -4 ) ;
1749
1750 wxRect cl = GetClientRect() ;
1751 Rect rClient = { cl.y , cl.x , cl.y + cl.height , cl.x + cl.width } ;
1752
1753 int x , y ;
1754 wxSize size ;
1755 const wxWindow* child = (wxWindow*) this ;
1756 const wxWindow* parent = NULL ;
1757
1758 while ( !child->IsTopLevel() && ( parent = child->GetParent() ) != NULL )
1759 {
1760 if ( parent->MacIsChildOfClientArea(child) )
1761 {
1762 size = parent->GetClientSize() ;
1763 wxPoint origin = parent->GetClientAreaOrigin() ;
1764 x = origin.x ;
1765 y = origin.y ;
1766 }
1767 else
1768 {
1769 // this will be true for scrollbars, toolbars etc.
1770 size = parent->GetSize() ;
1771 y = parent->MacGetTopBorderSize() ;
1772 x = parent->MacGetLeftBorderSize() ;
1773 size.x -= parent->MacGetLeftBorderSize() + parent->MacGetRightBorderSize() ;
1774 size.y -= parent->MacGetTopBorderSize() + parent->MacGetBottomBorderSize() ;
1775 }
1776
1777 parent->MacWindowToRootWindow( &x, &y ) ;
1778 MacRootWindowToWindow( &x , &y ) ;
1779
1780 Rect rparent = { y , x , y + size.y , x + size.x } ;
1781
1782 // the wxwindow and client rects will always be clipped
1783 SectRect( &r , &rparent , &r ) ;
1784 SectRect( &rClient , &rparent , &rClient ) ;
1785
1786 // the structure only at 'hard' borders
1787 if ( parent->MacClipChildren() ||
1788 ( parent->GetParent() && parent->GetParent()->MacClipGrandChildren() ) )
1789 {
1790 SectRect( &rIncludingOuterStructures , &rparent , &rIncludingOuterStructures ) ;
1791 }
1792
1793 child = parent ;
1794 }
1795
1796 m_cachedClippedRect = wxRect( r.left , r.top , r.right - r.left , r.bottom - r.top ) ;
1797 m_cachedClippedClientRect = wxRect( rClient.left , rClient.top ,
1798 rClient.right - rClient.left , rClient.bottom - rClient.top ) ;
1799 m_cachedClippedRectWithOuterStructure = wxRect(
1800 rIncludingOuterStructures.left , rIncludingOuterStructures.top ,
1801 rIncludingOuterStructures.right - rIncludingOuterStructures.left ,
1802 rIncludingOuterStructures.bottom - rIncludingOuterStructures.top ) ;
1803
1804 m_cachedClippedRegionWithOuterStructure = wxRegion( m_cachedClippedRectWithOuterStructure ) ;
1805 m_cachedClippedRegion = wxRegion( m_cachedClippedRect ) ;
1806 m_cachedClippedClientRegion = wxRegion( m_cachedClippedClientRect ) ;
1807
1808 m_cachedClippedRectValid = true ;
1809#endif
1810}
1811
1812/*
1813 This function must not change the updatergn !
1814 */
5398a2e0 1815bool wxWindowMac::MacDoRedraw( long time )
524c47aa
SC
1816{
1817 bool handled = false ;
69ce9cea 1818
5398a2e0
SC
1819 wxRegion formerUpdateRgn = m_updateRegion;
1820 wxRegion clientUpdateRgn = formerUpdateRgn;
524c47aa 1821
69ce9cea
VZ
1822 const wxRect clientRect = GetClientRect();
1823
1824 clientUpdateRgn.Intersect(clientRect);
1825
5398a2e0 1826 // first send an erase event to the entire update area
69ce9cea 1827 const wxBackgroundStyle bgStyle = GetBackgroundStyle();
6a5594e0 1828 switch ( bgStyle )
524c47aa 1829 {
6a5594e0
VZ
1830 case wxBG_STYLE_ERASE:
1831 case wxBG_STYLE_SYSTEM:
69ce9cea 1832 {
6a5594e0
VZ
1833 // for the toplevel window this really is the entire area for
1834 // all the others only their client area, otherwise they might
1835 // be drawing with full alpha and eg put blue into the grow-box
1836 // area of a scrolled window (scroll sample)
1837 wxWindowDC dc(this);
1838 if ( IsTopLevel() )
1839 dc.SetDeviceClippingRegion(formerUpdateRgn);
1840 else
1841 dc.SetDeviceClippingRegion(clientUpdateRgn);
1842
1843 if ( bgStyle == wxBG_STYLE_ERASE )
1844 {
1845 wxEraseEvent eevent( GetId(), &dc );
1846 eevent.SetEventObject( this );
1847 if ( ProcessWindowEvent( eevent ) )
1848 break;
1849 }
1850
773809f5 1851 if ( UseBgCol() )
6a5594e0
VZ
1852 {
1853 dc.SetBackground(GetBackgroundColour());
1854 dc.Clear();
1855 }
69ce9cea 1856 }
6a5594e0
VZ
1857 break;
1858
1859 case wxBG_STYLE_PAINT:
1860 // nothing to do, user-defined EVT_PAINT handler will overwrite the
1861 // entire window client area
1862 break;
1863
1864 default:
1865 wxFAIL_MSG( "unsupported background style" );
5398a2e0 1866 }
524c47aa 1867
5398a2e0 1868 MacPaintGrowBox();
524c47aa 1869
69ce9cea
VZ
1870 // calculate a client-origin version of the update rgn and set
1871 // m_updateRegion to that
1872 clientUpdateRgn.Offset(-clientRect.GetPosition());
5398a2e0 1873 m_updateRegion = clientUpdateRgn ;
524c47aa 1874
5398a2e0
SC
1875 if ( !m_updateRegion.Empty() )
1876 {
1877 // paint the window itself
524c47aa 1878
45f5bb03 1879 wxPaintEvent event(GetId());
5398a2e0
SC
1880 event.SetTimestamp(time);
1881 event.SetEventObject(this);
1882 handled = HandleWindowEvent(event);
1883 }
524c47aa 1884
5398a2e0
SC
1885 m_updateRegion = formerUpdateRgn;
1886 return handled;
1887}
524c47aa 1888
5398a2e0
SC
1889void wxWindowMac::MacPaintChildrenBorders()
1890{
1891 // now we cannot rely on having its borders drawn by a window itself, as it does not
1892 // get the updateRgn wide enough to always do so, so we do it from the parent
1893 // this would also be the place to draw any custom backgrounds for native controls
1894 // in Composited windowing
1895 wxPoint clientOrigin = GetClientAreaOrigin() ;
524c47aa 1896
5398a2e0
SC
1897 wxWindowMac *child;
1898 int x, y, w, h;
1899 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
1900 {
1901 child = node->GetData();
1902 if (child == NULL)
1903 continue;
11fed901 1904#if wxUSE_SCROLLBAR
5398a2e0
SC
1905 if (child == m_vScrollBar)
1906 continue;
1907 if (child == m_hScrollBar)
1908 continue;
2ae3afa0
JS
1909 if (child == m_growBox)
1910 continue;
11fed901 1911#endif
5398a2e0
SC
1912 if (child->IsTopLevel())
1913 continue;
1914 if (!child->IsShown())
1915 continue;
1916
1917 // only draw those in the update region (add a safety margin of 10 pixels for shadow effects
1918
1919 child->GetPosition( &x, &y );
1920 child->GetSize( &w, &h );
69ce9cea 1921
5398a2e0 1922 if ( m_updateRegion.Contains(clientOrigin.x+x-10, clientOrigin.y+y-10, w+20, h+20) )
524c47aa 1923 {
5398a2e0
SC
1924 // paint custom borders
1925 wxNcPaintEvent eventNc( child->GetId() );
1926 eventNc.SetEventObject( child );
1927 if ( !child->HandleWindowEvent( eventNc ) )
524c47aa 1928 {
5398a2e0 1929 child->MacPaintBorders(0, 0) ;
524c47aa
SC
1930 }
1931 }
1932 }
524c47aa
SC
1933}
1934
1935
1936WXWindow wxWindowMac::MacGetTopLevelWindowRef() const
1937{
69ce9cea 1938 wxNonOwnedWindow* tlw = MacGetTopLevelWindow();
524c47aa
SC
1939 return tlw ? tlw->GetWXWindow() : NULL ;
1940}
1941
1942bool wxWindowMac::MacHasScrollBarCorner() const
1943{
11fed901 1944#if wxUSE_SCROLLBAR
524c47aa
SC
1945 /* Returns whether the scroll bars in a wxScrolledWindow should be
1946 * shortened. Scroll bars should be shortened if either:
1947 *
1948 * - both scroll bars are visible, or
1949 *
1950 * - there is a resize box in the parent frame's corner and this
1951 * window shares the bottom and right edge with the parent
1952 * frame.
1953 */
1954
1955 if ( m_hScrollBar == NULL && m_vScrollBar == NULL )
1956 return false;
1957
1958 if ( ( m_hScrollBar && m_hScrollBar->IsShown() )
1959 && ( m_vScrollBar && m_vScrollBar->IsShown() ) )
1960 {
1961 // Both scroll bars visible
1962 return true;
1963 }
1964 else
1965 {
1966 wxPoint thisWindowBottomRight = GetScreenRect().GetBottomRight();
1967
1968 for ( const wxWindow *win = (wxWindow*)this; win; win = win->GetParent() )
1969 {
1970 const wxFrame *frame = wxDynamicCast( win, wxFrame ) ;
1971 if ( frame )
1972 {
1973 if ( frame->GetWindowStyleFlag() & wxRESIZE_BORDER )
1974 {
1975 // Parent frame has resize handle
1976 wxPoint frameBottomRight = frame->GetScreenRect().GetBottomRight();
1977
1978 // Note: allow for some wiggle room here as wxMac's
1979 // window rect calculations seem to be imprecise
1980 if ( abs( thisWindowBottomRight.x - frameBottomRight.x ) <= 2
1981 && abs( thisWindowBottomRight.y - frameBottomRight.y ) <= 2 )
1982 {
1983 // Parent frame has resize handle and shares
1984 // right bottom corner
1985 return true ;
1986 }
1987 else
1988 {
1989 // Parent frame has resize handle but doesn't
1990 // share right bottom corner
1991 return false ;
1992 }
1993 }
1994 else
1995 {
1996 // Parent frame doesn't have resize handle
1997 return false ;
1998 }
1999 }
2000 }
2001
2002 // No parent frame found
2003 return false ;
2004 }
11fed901
SC
2005#else
2006 return false;
2007#endif
524c47aa
SC
2008}
2009
2010void wxWindowMac::MacCreateScrollBars( long style )
2011{
11fed901 2012#if wxUSE_SCROLLBAR
524c47aa
SC
2013 wxASSERT_MSG( m_vScrollBar == NULL && m_hScrollBar == NULL , wxT("attempt to create window twice") ) ;
2014
2015 if ( style & ( wxVSCROLL | wxHSCROLL ) )
2016 {
2017 int scrlsize = MAC_SCROLLBAR_SIZE ;
2018 if ( GetWindowVariant() == wxWINDOW_VARIANT_SMALL || GetWindowVariant() == wxWINDOW_VARIANT_MINI )
2019 {
2020 scrlsize = MAC_SMALL_SCROLLBAR_SIZE ;
2021 }
2022
2023 int adjust = MacHasScrollBarCorner() ? scrlsize - 1: 0 ;
2024 int width, height ;
2025 GetClientSize( &width , &height ) ;
2026
2027 wxPoint vPoint(width - scrlsize, 0) ;
2028 wxSize vSize(scrlsize, height - adjust) ;
2029 wxPoint hPoint(0, height - scrlsize) ;
2030 wxSize hSize(width - adjust, scrlsize) ;
2031
2032 // we have to set the min size to a smaller value, otherwise they cannot get smaller (InitialSize sets MinSize)
2033 if ( style & wxVSCROLL )
2034 {
2035 m_vScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, vPoint, vSize , wxVERTICAL);
2036 m_vScrollBar->SetMinSize( wxDefaultSize );
2037 }
2038
2039 if ( style & wxHSCROLL )
2040 {
2041 m_hScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, hPoint, hSize , wxHORIZONTAL);
2042 m_hScrollBar->SetMinSize( wxDefaultSize );
2043 }
2ae3afa0
JS
2044
2045 wxPoint gPoint(width - scrlsize, height - scrlsize);
2046 wxSize gSize(scrlsize, scrlsize);
2047 m_growBox = new wxPanel((wxWindow *)this, wxID_ANY, gPoint, gSize, 0);
524c47aa
SC
2048 }
2049
2050 // because the create does not take into account the client area origin
2051 // we might have a real position shift
2052 MacRepositionScrollBars() ;
11fed901 2053#endif
524c47aa
SC
2054}
2055
2056bool wxWindowMac::MacIsChildOfClientArea( const wxWindow* child ) const
2057{
11fed901
SC
2058 bool result = ((child == NULL)
2059#if wxUSE_SCROLLBAR
2ae3afa0 2060 || ((child != m_hScrollBar) && (child != m_vScrollBar) && (child != m_growBox))
11fed901
SC
2061#endif
2062 );
524c47aa
SC
2063
2064 return result ;
2065}
2066
2067void wxWindowMac::MacRepositionScrollBars()
2068{
11fed901 2069#if wxUSE_SCROLLBAR
524c47aa
SC
2070 if ( !m_hScrollBar && !m_vScrollBar )
2071 return ;
2072
2073 int scrlsize = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2074 int adjust = MacHasScrollBarCorner() ? scrlsize - 1 : 0 ;
2075
2076 // get real client area
2077 int width, height ;
2078 GetSize( &width , &height );
2079
2080 width -= MacGetLeftBorderSize() + MacGetRightBorderSize();
2081 height -= MacGetTopBorderSize() + MacGetBottomBorderSize();
2082
2083 wxPoint vPoint( width - scrlsize, 0 ) ;
2084 wxSize vSize( scrlsize, height - adjust ) ;
2085 wxPoint hPoint( 0 , height - scrlsize ) ;
2086 wxSize hSize( width - adjust, scrlsize ) ;
2087
2088 if ( m_vScrollBar )
2089 m_vScrollBar->SetSize( vPoint.x , vPoint.y, vSize.x, vSize.y , wxSIZE_ALLOW_MINUS_ONE );
2090 if ( m_hScrollBar )
2091 m_hScrollBar->SetSize( hPoint.x , hPoint.y, hSize.x, hSize.y, wxSIZE_ALLOW_MINUS_ONE );
2ae3afa0
JS
2092 if ( m_growBox )
2093 {
2094 if ( MacHasScrollBarCorner() )
2095 {
2096 m_growBox->SetSize( width - scrlsize, height - scrlsize, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING );
2097 if ( !m_growBox->IsShown() )
2098 m_growBox->Show();
2099 }
2100 else
2101 {
2102 if ( m_growBox->IsShown() )
2103 m_growBox->Hide();
2104 }
2105 }
11fed901 2106#endif
524c47aa
SC
2107}
2108
2109bool wxWindowMac::AcceptsFocus() const
2110{
f06e0fea
SC
2111 if ( MacIsUserPane() )
2112 return wxWindowBase::AcceptsFocus();
2113 else
2114 return m_peer->CanFocus();
524c47aa
SC
2115}
2116
2117void wxWindowMac::MacSuperChangedPosition()
2118{
2119 // only window-absolute structures have to be moved i.e. controls
2120
2121 m_cachedClippedRectValid = false ;
2122
2123 wxWindowMac *child;
2124 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2125 while ( node )
2126 {
2127 child = node->GetData();
2128 child->MacSuperChangedPosition() ;
2129
2130 node = node->GetNext();
2131 }
2132}
2133
2134void wxWindowMac::MacTopLevelWindowChangedPosition()
2135{
2136 // only screen-absolute structures have to be moved i.e. glcanvas
2137
2138 wxWindowMac *child;
2139 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2140 while ( node )
2141 {
2142 child = node->GetData();
2143 child->MacTopLevelWindowChangedPosition() ;
2144
2145 node = node->GetNext();
2146 }
2147}
2148
2149long wxWindowMac::MacGetLeftBorderSize() const
2150{
2151 if ( IsTopLevel() )
2152 return 0 ;
2153
2154 SInt32 border = 0 ;
2155
7185918d 2156 if ( m_peer && m_peer->NeedsFrame() )
524c47aa 2157 {
f2f6030e
SC
2158 if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER))
2159 {
524c47aa 2160#if wxOSX_USE_COCOA_OR_CARBON
f2f6030e
SC
2161 // this metric is only the 'outset' outside the simple frame rect
2162 GetThemeMetric( kThemeMetricEditTextFrameOutset , &border ) ;
2163 border += 1;
524c47aa 2164#else
f2f6030e 2165 border += 2;
524c47aa 2166#endif
f2f6030e
SC
2167 }
2168 else if (HasFlag(wxSIMPLE_BORDER))
2169 {
524c47aa 2170#if wxOSX_USE_COCOA_OR_CARBON
f2f6030e
SC
2171 // this metric is only the 'outset' outside the simple frame rect
2172 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
2173 border += 1;
524c47aa 2174#else
f2f6030e 2175 border += 1;
524c47aa 2176#endif
f2f6030e 2177 }
524c47aa
SC
2178 }
2179
2180 return border ;
2181}
2182
2183long wxWindowMac::MacGetRightBorderSize() const
2184{
2185 // they are all symmetric in mac themes
2186 return MacGetLeftBorderSize() ;
2187}
2188
2189long wxWindowMac::MacGetTopBorderSize() const
2190{
2191 // they are all symmetric in mac themes
2192 return MacGetLeftBorderSize() ;
2193}
2194
2195long wxWindowMac::MacGetBottomBorderSize() const
2196{
2197 // they are all symmetric in mac themes
2198 return MacGetLeftBorderSize() ;
2199}
2200
2201long wxWindowMac::MacRemoveBordersFromStyle( long style )
2202{
2203 return style & ~wxBORDER_MASK ;
2204}
2205
2206// Find the wxWindowMac at the current mouse position, returning the mouse
2207// position.
2208wxWindow * wxFindWindowAtPointer( wxPoint& pt )
2209{
2210 pt = wxGetMousePosition();
2211 wxWindowMac* found = wxFindWindowAtPoint(pt);
2212
2213 return (wxWindow*) found;
2214}
2215
2216// Get the current mouse position.
2217wxPoint wxGetMousePosition()
2218{
2219 int x, y;
2220
2221 wxGetMousePosition( &x, &y );
2222
2223 return wxPoint(x, y);
2224}
2225
2226void wxWindowMac::OnMouseEvent( wxMouseEvent &event )
2227{
2228 if ( event.GetEventType() == wxEVT_RIGHT_DOWN )
2229 {
2230 // copied from wxGTK : CS
2231 // VZ: shouldn't we move this to base class then?
2232
2233 // generate a "context menu" event: this is similar to wxEVT_RIGHT_DOWN
2234 // except that:
2235 //
2236 // (a) it's a command event and so is propagated to the parent
2237 // (b) under MSW it can be generated from kbd too
2238 // (c) it uses screen coords (because of (a))
2239 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
2240 this->GetId(),
2241 this->ClientToScreen(event.GetPosition()));
2242 evtCtx.SetEventObject(this);
2243 if ( ! HandleWindowEvent(evtCtx) )
2244 event.Skip() ;
2245 }
2246 else
2247 {
2248 event.Skip() ;
2249 }
2250}
2251
19c7ac3d 2252void wxWindowMac::TriggerScrollEvent( wxEventType WXUNUSED(scrollEvent) )
524c47aa
SC
2253{
2254}
2255
2256Rect wxMacGetBoundsForControl( wxWindowMac* window , const wxPoint& pos , const wxSize &size , bool adjustForOrigin )
2257{
2258 int x, y, w, h ;
2259
2260 window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin ) ;
2261 Rect bounds = { y, x, y + h, x + w };
2262
2263 return bounds ;
2264}
2265
0faf03bf 2266bool wxWindowMac::OSXHandleClicked( double WXUNUSED(timestampsec) )
524c47aa
SC
2267{
2268 return false;
2269}
2270
2271wxInt32 wxWindowMac::MacControlHit(WXEVENTHANDLERREF WXUNUSED(handler) , WXEVENTREF event )
2272{
2273#if wxOSX_USE_COCOA_OR_CARBON
4eb5a0ec 2274 if ( OSXHandleClicked( GetEventTime((EventRef)event) ) )
524c47aa 2275 return noErr;
69ce9cea 2276
524c47aa
SC
2277 return eventNotHandledErr ;
2278#else
2279 return 0;
2280#endif
2281}
2282
2283bool wxWindowMac::Reparent(wxWindowBase *newParentBase)
2284{
2285 wxWindowMac *newParent = (wxWindowMac *)newParentBase;
2286 if ( !wxWindowBase::Reparent(newParent) )
2287 return false;
2288
2289 m_peer->RemoveFromParent();
2290 m_peer->Embed( GetParent()->GetPeer() );
b80fdc02
JS
2291
2292 MacChildAdded();
524c47aa
SC
2293 return true;
2294}
2295
2296bool wxWindowMac::SetTransparent(wxByte alpha)
2297{
2298 SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
2299
2300 if ( alpha != m_macAlpha )
2301 {
2302 m_macAlpha = alpha ;
2303 Refresh() ;
2304 }
2305 return true ;
2306}
2307
2308
2309bool wxWindowMac::CanSetTransparent()
2310{
2311 return true ;
2312}
2313
2314wxByte wxWindowMac::GetTransparent() const
2315{
2316 return m_macAlpha ;
2317}
2318
2319bool wxWindowMac::IsShownOnScreen() const
2320{
2321 if ( m_peer && m_peer->IsOk() )
2322 {
2323 bool peerVis = m_peer->IsVisible();
2324 bool wxVis = wxWindowBase::IsShownOnScreen();
2325 if( peerVis != wxVis )
2326 {
2327 // CS : put a breakpoint here to investigate differences
2328 // between native an wx visibilities
2329 // the only place where I've encountered them until now
2330 // are the hiding/showing sequences where the vis-changed event is
2331 // first sent to the innermost control, while wx does things
2332 // from the outmost control
2333 wxVis = wxWindowBase::IsShownOnScreen();
2334 return wxVis;
2335 }
2336
2337 return m_peer->IsVisible();
2338 }
2339 return wxWindowBase::IsShownOnScreen();
2340}
2341
4eb5a0ec 2342bool wxWindowMac::OSXHandleKeyEvent( wxKeyEvent& event )
19c7ac3d
SC
2343{
2344 bool handled = HandleWindowEvent( event ) ;
2345 if ( handled && event.GetSkipped() )
2346 handled = false ;
2347
2348#if wxUSE_ACCEL
2349 if ( !handled && event.GetEventType() == wxEVT_KEY_DOWN)
2350 {
2351 wxWindow *ancestor = this;
2352 while (ancestor)
2353 {
2354 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
2355 if (command != -1)
2356 {
2357 wxEvtHandler * const handler = ancestor->GetEventHandler();
2358
2359 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
2360 handled = handler->ProcessEvent( command_event );
2361
2362 if ( !handled )
2363 {
2364 // accelerators can also be used with buttons, try them too
2365 command_event.SetEventType(wxEVT_COMMAND_BUTTON_CLICKED);
2366 handled = handler->ProcessEvent( command_event );
2367 }
2368
2369 break;
2370 }
2371
2372 if (ancestor->IsTopLevel())
2373 break;
2374
2375 ancestor = ancestor->GetParent();
2376 }
2377 }
2378#endif // wxUSE_ACCEL
2379
2380 return handled ;
2381}
2382
524c47aa 2383//
69ce9cea 2384// wxWidgetImpl
524c47aa
SC
2385//
2386
f55d9f74
SC
2387WX_DECLARE_HASH_MAP(WXWidget, wxWidgetImpl*, wxPointerHash, wxPointerEqual, MacControlMap);
2388
2389static MacControlMap wxWinMacControlList;
2390
2391wxWindowMac *wxFindWindowFromWXWidget(WXWidget inControl )
2392{
2393 wxWidgetImpl* impl = wxWidgetImpl::FindFromWXWidget( inControl );
2394 if ( impl )
2395 return impl->GetWXPeer();
69ce9cea 2396
f55d9f74
SC
2397 return NULL;
2398}
2399
2400wxWidgetImpl *wxWidgetImpl::FindFromWXWidget(WXWidget inControl )
2401{
2402 MacControlMap::iterator node = wxWinMacControlList.find(inControl);
2403
2404 return (node == wxWinMacControlList.end()) ? NULL : node->second;
2405}
2406
2407void wxWidgetImpl::Associate(WXWidget inControl, wxWidgetImpl *impl)
2408{
2409 // adding NULL ControlRef is (first) surely a result of an error and
2410 // (secondly) breaks native event processing
2411 wxCHECK_RET( inControl != (WXWidget) NULL, wxT("attempt to add a NULL WXWidget to control map") );
2412
2413 wxWinMacControlList[inControl] = impl;
2414}
2415
2416void wxWidgetImpl::RemoveAssociations(wxWidgetImpl* impl)
2417{
2418 // iterate over all the elements in the class
2419 // is the iterator stable ? as we might have two associations pointing to the same wxWindow
2420 // we should go on...
2421
2422 bool found = true ;
2423 while ( found )
2424 {
2425 found = false ;
2426 MacControlMap::iterator it;
2427 for ( it = wxWinMacControlList.begin(); it != wxWinMacControlList.end(); ++it )
2428 {
2429 if ( it->second == impl )
2430 {
2431 wxWinMacControlList.erase(it);
2432 found = true ;
2433 break;
2434 }
2435 }
2436 }
2437}
2438
524c47aa
SC
2439IMPLEMENT_ABSTRACT_CLASS( wxWidgetImpl , wxObject )
2440
2441wxWidgetImpl::wxWidgetImpl( wxWindowMac* peer , bool isRootControl )
2442{
2443 Init();
2444 m_isRootControl = isRootControl;
2445 m_wxPeer = peer;
2446}
2447
2448wxWidgetImpl::wxWidgetImpl()
2449{
2450 Init();
2451}
2452
2453wxWidgetImpl::~wxWidgetImpl()
2454{
2455}
2456
2457void wxWidgetImpl::Init()
2458{
2459 m_isRootControl = false;
2460 m_wxPeer = NULL;
2461 m_needsFocusRect = false;
f2f6030e 2462 m_needsFrame = true;
524c47aa
SC
2463}
2464
2465void wxWidgetImpl::SetNeedsFocusRect( bool needs )
2466{
2467 m_needsFocusRect = needs;
2468}
2469
2470bool wxWidgetImpl::NeedsFocusRect() const
2471{
2472 return m_needsFocusRect;
2473}
2474
f2f6030e
SC
2475void wxWidgetImpl::SetNeedsFrame( bool needs )
2476{
2477 m_needsFrame = needs;
2478}
2479
2480bool wxWidgetImpl::NeedsFrame() const
2481{
2482 return m_needsFrame;
2483}