]> git.saurik.com Git - wxWidgets.git/blob - src/cocoa/window.mm
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / cocoa / window.mm
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/cocoa/window.mm
3 // Purpose: wxWindowCocoa
4 // Author: David Elliott
5 // Modified by:
6 // Created: 2002/12/26
7 // RCS-ID: $Id$
8 // Copyright: (c) 2002 David Elliott
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #ifndef WX_PRECOMP
15 #include "wx/log.h"
16 #include "wx/window.h"
17 #include "wx/dc.h"
18 #include "wx/dcclient.h"
19 #include "wx/utils.h"
20 #endif //WX_PRECOMP
21
22 #include "wx/tooltip.h"
23
24 #include "wx/cocoa/dc.h"
25 #include "wx/cocoa/autorelease.h"
26 #include "wx/cocoa/string.h"
27 #include "wx/cocoa/trackingrectmanager.h"
28 #include "wx/cocoa/private/scrollview.h"
29 #include "wx/osx/core/cfref.h"
30 #include "wx/cocoa/ObjcRef.h"
31
32 #import <Foundation/NSArray.h>
33 #import <Foundation/NSRunLoop.h>
34 #include "wx/cocoa/objc/NSView.h"
35 #import <AppKit/NSEvent.h>
36 #import <AppKit/NSScrollView.h>
37 #import <AppKit/NSScroller.h>
38 #import <AppKit/NSColor.h>
39 #import <AppKit/NSClipView.h>
40 #import <Foundation/NSException.h>
41 #import <AppKit/NSApplication.h>
42 #import <AppKit/NSWindow.h>
43 #import <AppKit/NSScreen.h>
44
45 // Turn this on to paint green over the dummy views for debugging
46 #undef WXCOCOA_FILL_DUMMY_VIEW
47
48 #ifdef WXCOCOA_FILL_DUMMY_VIEW
49 #import <AppKit/NSBezierPath.h>
50 #endif //def WXCOCOA_FILL_DUMMY_VIEW
51
52 // STL list used by wxCocoaMouseMovedEventSynthesizer
53 #include <list>
54
55 /* NSComparisonResult is typedef'd as an enum pre-Leopard but typedef'd as
56 * NSInteger post-Leopard. Pre-Leopard the Cocoa toolkit expects a function
57 * returning int and not NSComparisonResult. Post-Leopard the Cocoa toolkit
58 * expects a function returning the new non-enum NSComparsionResult.
59 * Hence we create a typedef named CocoaWindowCompareFunctionResult.
60 */
61 #if defined(NSINTEGER_DEFINED)
62 typedef NSComparisonResult CocoaWindowCompareFunctionResult;
63 #else
64 typedef int CocoaWindowCompareFunctionResult;
65 #endif
66
67 // A category for methods that are only present in Panther's SDK
68 @interface NSView(wxNSViewPrePantherCompatibility)
69 - (void)getRectsBeingDrawn:(const NSRect **)rects count:(int *)count;
70 @end
71
72 // ========================================================================
73 // Helper functions for converting to/from wxWidgets coordinates and a
74 // specified NSView's coordinate system.
75 // ========================================================================
76 NSPoint CocoaTransformNSViewBoundsToWx(NSView *nsview, NSPoint pointBounds)
77 {
78 wxCHECK_MSG(nsview, pointBounds, wxT("Need to have a Cocoa view to do translation"));
79 if([nsview isFlipped])
80 return pointBounds;
81 NSRect ourBounds = [nsview bounds];
82 return NSMakePoint
83 ( pointBounds.x
84 , ourBounds.size.height - pointBounds.y
85 );
86 }
87
88 NSRect CocoaTransformNSViewBoundsToWx(NSView *nsview, NSRect rectBounds)
89 {
90 wxCHECK_MSG(nsview, rectBounds, wxT("Need to have a Cocoa view to do translation"));
91 if([nsview isFlipped])
92 return rectBounds;
93 NSRect ourBounds = [nsview bounds];
94 return NSMakeRect
95 ( rectBounds.origin.x
96 , ourBounds.size.height - (rectBounds.origin.y + rectBounds.size.height)
97 , rectBounds.size.width
98 , rectBounds.size.height
99 );
100 }
101
102 NSPoint CocoaTransformNSViewWxToBounds(NSView *nsview, NSPoint pointWx)
103 {
104 wxCHECK_MSG(nsview, pointWx, wxT("Need to have a Cocoa view to do translation"));
105 if([nsview isFlipped])
106 return pointWx;
107 NSRect ourBounds = [nsview bounds];
108 return NSMakePoint
109 ( pointWx.x
110 , ourBounds.size.height - pointWx.y
111 );
112 }
113
114 NSRect CocoaTransformNSViewWxToBounds(NSView *nsview, NSRect rectWx)
115 {
116 wxCHECK_MSG(nsview, rectWx, wxT("Need to have a Cocoa view to do translation"));
117 if([nsview isFlipped])
118 return rectWx;
119 NSRect ourBounds = [nsview bounds];
120 return NSMakeRect
121 ( rectWx.origin.x
122 , ourBounds.size.height - (rectWx.origin.y + rectWx.size.height)
123 , rectWx.size.width
124 , rectWx.size.height
125 );
126 }
127
128 // ============================================================================
129 // Screen coordinate helpers
130 // ============================================================================
131
132 /*
133 General observation about Cocoa screen coordinates:
134 It is documented that the first object of the [NSScreen screens] array is the screen with the menubar.
135
136 It is not documented (but true as far as I can tell) that (0,0) in Cocoa screen coordinates is always
137 the BOTTOM-right corner of this screen. Recall that Cocoa uses cartesian coordinates so y-increase is up.
138
139 It isn't clearly documented but visibleFrame returns a rectangle in screen coordinates, not a rectangle
140 relative to that screen's frame. The only real way to test this is to configure two screens one atop
141 the other such that the menubar screen is on top. The Dock at the bottom of the screen will then
142 eat into the visibleFrame of screen 1 by incrementing it's y-origin. Thus if you arrange two
143 1920x1200 screens top/bottom then screen 1 (the bottom screen) will have frame origin (0,-1200) and
144 visibleFrame origin (0,-1149) which is exactly 51 pixels higher than the full frame origin.
145
146 In wxCocoa, we somewhat arbitrarily declare that wx (0,0) is the TOP-left of screen 0's frame (the entire screen).
147 However, this isn't entirely arbitrary because the Quartz Display Services (CGDisplay) uses this same scheme.
148 This works out nicely because wxCocoa's wxDisplay is implemented using Quartz Display Services instead of NSScreen.
149 */
150
151 namespace { // file namespace
152
153 class wxCocoaPrivateScreenCoordinateTransformer
154 {
155 wxDECLARE_NO_COPY_CLASS(wxCocoaPrivateScreenCoordinateTransformer);
156 public:
157 wxCocoaPrivateScreenCoordinateTransformer();
158 ~wxCocoaPrivateScreenCoordinateTransformer();
159 wxPoint OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates(NSRect windowFrame);
160 NSPoint OriginInCocoaScreenCoordinatesForRectInWxDisplayCoordinates(wxCoord x, wxCoord y, wxCoord width, wxCoord height, bool keepOriginVisible);
161
162 protected:
163 NSScreen *m_screenZero;
164 NSRect m_screenZeroFrame;
165 };
166
167 // NOTE: This is intended to be a short-lived object. A future enhancment might
168 // make it a global and reconfigure it upon some notification that the screen layout
169 // has changed.
170 inline wxCocoaPrivateScreenCoordinateTransformer::wxCocoaPrivateScreenCoordinateTransformer()
171 {
172 NSArray *screens = [NSScreen screens];
173
174 [screens retain];
175
176 m_screenZero = nil;
177 if(screens != nil && [screens count] > 0)
178 m_screenZero = [[screens objectAtIndex:0] retain];
179
180 [screens release];
181
182 if(m_screenZero != nil)
183 m_screenZeroFrame = [m_screenZero frame];
184 else
185 {
186 wxLogWarning(wxT("Can't translate to/from wx screen coordinates and Cocoa screen coordinates"));
187 // Just blindly assume 1024x768 so that at least we can sort of flip things around into
188 // Cocoa coordinates.
189 // NOTE: Theoretically this case should never happen anyway.
190 m_screenZeroFrame = NSMakeRect(0,0,1024,768);
191 }
192 }
193
194 inline wxCocoaPrivateScreenCoordinateTransformer::~wxCocoaPrivateScreenCoordinateTransformer()
195 {
196 [m_screenZero release];
197 m_screenZero = nil;
198 }
199
200 inline wxPoint wxCocoaPrivateScreenCoordinateTransformer::OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates(NSRect windowFrame)
201 {
202 // x and y are in wx screen coordinates which we're going to arbitrarily define such that
203 // (0,0) is the TOP-left of screen 0 (the one with the menubar)
204 // NOTE WELL: This means that (0,0) is _NOT_ an appropriate position for a window.
205
206 wxPoint theWxOrigin;
207
208 // Working in Cocoa's screen coordinates we must realize that the x coordinate we want is
209 // the distance between the left side (origin.x) of the window's frame and the left side of
210 // screen zero's frame.
211 theWxOrigin.x = windowFrame.origin.x - m_screenZeroFrame.origin.x;
212
213 // Working in Cocoa's screen coordinates we must realize that the y coordinate we want is
214 // actually the distance between the top-left of the screen zero frame and the top-left
215 // of the window's frame.
216
217 theWxOrigin.y = (m_screenZeroFrame.origin.y + m_screenZeroFrame.size.height) - (windowFrame.origin.y + windowFrame.size.height);
218
219 return theWxOrigin;
220 }
221
222 inline NSPoint wxCocoaPrivateScreenCoordinateTransformer::OriginInCocoaScreenCoordinatesForRectInWxDisplayCoordinates(wxCoord x, wxCoord y, wxCoord width, wxCoord height, bool keepOriginVisible)
223 {
224 NSPoint theCocoaOrigin;
225
226 // The position is in wx screen coordinates which we're going to arbitrarily define such that
227 // (0,0) is the TOP-left of screen 0 (the one with the menubar)
228
229 // NOTE: The usable rectangle is smaller and hence we have the keepOriginVisible flag
230 // which will move the origin downward and/or left as necessary if the origin is
231 // inside the screen0 rectangle (i.e. x/y >= 0 in wx coordinates) and outside the
232 // visible frame (i.e. x/y < the top/left of the screen0 visible frame in wx coordinates)
233 // We don't munge origin coordinates < 0 because it actually is possible that the menubar is on
234 // the top of the bottom screen and thus that origin is completely valid!
235 if(keepOriginVisible && (m_screenZero != nil))
236 {
237 // Do al of this in wx coordinates because it's far simpler since we're dealing with top/left points
238 wxPoint visibleOrigin = OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates([m_screenZero visibleFrame]);
239 if(x >= 0 && x < visibleOrigin.x)
240 x = visibleOrigin.x;
241 if(y >= 0 && y < visibleOrigin.y)
242 y = visibleOrigin.y;
243 }
244
245 // The x coordinate is simple as it's just relative to screen zero's frame
246 theCocoaOrigin.x = m_screenZeroFrame.origin.x + x;
247 // Working in Cocoa's coordinates think to start at the bottom of screen zero's frame and add
248 // the height of that rect which gives us the coordinate for the top of the visible rect. Now realize that
249 // the wx coordinates are flipped so if y is say 10 then we want to be 10 pixels down from that and thus
250 // we subtract y. But then we still need to take into account the size of the window which is h and subtract
251 // that to get the bottom-left origin of the rectangle.
252 theCocoaOrigin.y = m_screenZeroFrame.origin.y + m_screenZeroFrame.size.height - y - height;
253
254 return theCocoaOrigin;
255 }
256
257 } // namespace
258
259 wxPoint wxWindowCocoa::OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates(NSRect windowFrame)
260 {
261 wxCocoaPrivateScreenCoordinateTransformer transformer;
262 return transformer.OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates(windowFrame);
263 }
264
265 NSPoint wxWindowCocoa::OriginInCocoaScreenCoordinatesForRectInWxDisplayCoordinates(wxCoord x, wxCoord y, wxCoord width, wxCoord height, bool keepOriginVisible)
266 {
267 wxCocoaPrivateScreenCoordinateTransformer transformer;
268 return transformer.OriginInCocoaScreenCoordinatesForRectInWxDisplayCoordinates(x,y,width,height,keepOriginVisible);
269 }
270
271 // ========================================================================
272 // wxWindowCocoaHider
273 // ========================================================================
274 class wxWindowCocoaHider: protected wxCocoaNSView
275 {
276 wxDECLARE_NO_COPY_CLASS(wxWindowCocoaHider);
277 public:
278 wxWindowCocoaHider(wxWindow *owner);
279 virtual ~wxWindowCocoaHider();
280 inline WX_NSView GetNSView() { return m_dummyNSView; }
281 protected:
282 wxWindowCocoa *m_owner;
283 WX_NSView m_dummyNSView;
284 virtual void Cocoa_FrameChanged(void);
285 virtual void Cocoa_synthesizeMouseMoved(void) {}
286 #ifdef WXCOCOA_FILL_DUMMY_VIEW
287 virtual bool Cocoa_drawRect(const NSRect& rect);
288 #endif //def WXCOCOA_FILL_DUMMY_VIEW
289 private:
290 wxWindowCocoaHider();
291 };
292
293 // ========================================================================
294 // wxDummyNSView
295 // ========================================================================
296 @interface wxDummyNSView : NSView
297 - (NSView *)hitTest:(NSPoint)aPoint;
298 @end
299 WX_DECLARE_GET_OBJC_CLASS(wxDummyNSView,NSView)
300
301 @implementation wxDummyNSView : NSView
302 - (NSView *)hitTest:(NSPoint)aPoint
303 {
304 return nil;
305 }
306
307 @end
308 WX_IMPLEMENT_GET_OBJC_CLASS(wxDummyNSView,NSView)
309
310 // ========================================================================
311 // wxWindowCocoaHider
312 // NOTE: This class and method of hiding predates setHidden: support in
313 // the toolkit. The hack used here is to replace the view with a stand-in
314 // that will be subject to the usual Cocoa resizing rules.
315 // When possible (i.e. when running on 10.3 or higher) we make it hidden
316 // mostly as an optimization so Cocoa doesn't have to consider it when
317 // drawing or finding key views.
318 // ========================================================================
319 wxWindowCocoaHider::wxWindowCocoaHider(wxWindow *owner)
320 : m_owner(owner)
321 {
322 wxASSERT(owner);
323 wxASSERT(owner->GetNSViewForHiding());
324 m_dummyNSView = [[WX_GET_OBJC_CLASS(wxDummyNSView) alloc]
325 initWithFrame:[owner->GetNSViewForHiding() frame]];
326 [m_dummyNSView setAutoresizingMask: [owner->GetNSViewForHiding() autoresizingMask]];
327 AssociateNSView(m_dummyNSView);
328
329 if([m_dummyNSView respondsToSelector:@selector(setHidden:)])
330 [m_dummyNSView setHidden:YES];
331 }
332
333 wxWindowCocoaHider::~wxWindowCocoaHider()
334 {
335 DisassociateNSView(m_dummyNSView);
336 [m_dummyNSView release];
337 }
338
339 void wxWindowCocoaHider::Cocoa_FrameChanged(void)
340 {
341 // Keep the real window in synch with the dummy
342 wxASSERT(m_dummyNSView);
343 [m_owner->GetNSViewForHiding() setFrame:[m_dummyNSView frame]];
344 }
345
346
347 #ifdef WXCOCOA_FILL_DUMMY_VIEW
348 bool wxWindowCocoaHider::Cocoa_drawRect(const NSRect& rect)
349 {
350 NSBezierPath *bezpath = [NSBezierPath bezierPathWithRect:rect];
351 [[NSColor greenColor] set];
352 [bezpath stroke];
353 [bezpath fill];
354 return true;
355 }
356 #endif //def WXCOCOA_FILL_DUMMY_VIEW
357
358
359 /*! @class WXManualScrollView
360 @abstract An NSScrollView subclass which implements wx scroll behavior
361 @discussion
362 Overrides default behavior of NSScrollView such that this class receives
363 the scroller action messages and allows the wxCocoaScrollView to act
364 on them accordingly. In particular, because the NSScrollView will not
365 receive action messages from the scroller, it will not adjust the
366 document view. This must be done manually using the ScrollWindow
367 method of wxWindow.
368 */
369 @interface WXManualScrollView : NSScrollView
370 {
371 /*! @field m_wxCocoaScrollView
372 */
373 wxWindowCocoaScrollView *m_wxCocoaScrollView;
374 }
375
376 // Override these to set up the target/action correctly
377 - (void)setHorizontalScroller:(NSScroller *)aScroller;
378 - (void)setVerticalScroller:(NSScroller *)aScroller;
379 - (void)setHasHorizontalScroller:(BOOL)flag;
380 - (void)setHasVerticalScroller:(BOOL)flag;
381
382 // NOTE: _wx_ prefix means "private" method like _ that Apple (and only Apple) uses.
383 - (wxWindowCocoaScrollView*)_wx_wxCocoaScrollView;
384 - (void)_wx_setWxCocoaScrollView:(wxWindowCocoaScrollView*)theWxScrollView;
385
386 /*! @method _wx_doScroller
387 @abstract Handles action messages from the scrollers
388 @discussion
389 Similar to Apple's _doScroller: method which is private and not documented.
390 We do not, however, call that method. Instead, we effectively override
391 it entirely. We don't override it by naming ourself the same thing because
392 the base class code may or may not call that method for other reasons we
393 simply cannot know about.
394 */
395 - (void)_wx_doScroller:(id)sender;
396
397 @end
398
399
400 @implementation WXManualScrollView : NSScrollView
401
402 static inline void WXManualScrollView_DoSetScrollerTargetAction(WXManualScrollView *self, NSScroller *aScroller)
403 {
404 if(aScroller != NULL && [self _wx_wxCocoaScrollView] != NULL)
405 {
406 [aScroller setTarget:self];
407 [aScroller setAction:@selector(_wx_doScroller:)];
408 }
409 }
410
411 - (void)setHorizontalScroller:(NSScroller *)aScroller
412 {
413 [super setHorizontalScroller:aScroller];
414 WXManualScrollView_DoSetScrollerTargetAction(self, aScroller);
415 }
416
417 - (void)setVerticalScroller:(NSScroller *)aScroller
418 {
419 [super setVerticalScroller:aScroller];
420 WXManualScrollView_DoSetScrollerTargetAction(self, aScroller);
421 }
422
423 - (void)setHasHorizontalScroller:(BOOL)flag
424 {
425 [super setHasHorizontalScroller:flag];
426 WXManualScrollView_DoSetScrollerTargetAction(self, [self horizontalScroller]);
427 }
428
429 - (void)setHasVerticalScroller:(BOOL)flag
430 {
431 [super setHasVerticalScroller:flag];
432 WXManualScrollView_DoSetScrollerTargetAction(self, [self verticalScroller]);
433 }
434
435 - (wxWindowCocoaScrollView*)_wx_wxCocoaScrollView
436 { return m_wxCocoaScrollView; }
437
438 - (void)_wx_setWxCocoaScrollView:(wxWindowCocoaScrollView*)theWxScrollView
439 {
440 m_wxCocoaScrollView = theWxScrollView;
441 [self setHorizontalScroller:[self horizontalScroller]];
442 [self setVerticalScroller:[self verticalScroller]];
443 }
444
445 - (void)_wx_doScroller:(id)sender
446 {
447 if(m_wxCocoaScrollView != NULL)
448 m_wxCocoaScrollView->_wx_doScroller(sender);
449 else
450 wxLogError(wxT("Unexpected action message received from NSScroller"));
451 }
452
453 - (void)reflectScrolledClipView:(NSClipView *)aClipView
454 {
455 struct _ScrollerBackup
456 {
457 _ScrollerBackup(NSScroller *aScroller)
458 : m_scroller(aScroller)
459 , m_floatValue(aScroller!=nil?[aScroller floatValue]:0.0)
460 , m_knobProportion(aScroller!=nil?[aScroller knobProportion]:1.0)
461 , m_isEnabled(aScroller!=nil?[aScroller isEnabled]:false)
462 {
463 }
464 NSScroller *m_scroller;
465 CGFloat m_floatValue;
466 CGFloat m_knobProportion;
467 BOOL m_isEnabled;
468 ~_ScrollerBackup()
469 {
470 if(m_scroller != nil)
471 {
472 [m_scroller setFloatValue:m_floatValue knobProportion:m_knobProportion];
473 [m_scroller setEnabled:m_isEnabled];
474 }
475 }
476 private:
477 _ScrollerBackup();
478 _ScrollerBackup(_ScrollerBackup const&);
479 _ScrollerBackup& operator=(_ScrollerBackup const&);
480 };
481 _ScrollerBackup _horizontalBackup([self horizontalScroller]);
482 _ScrollerBackup _verticalBackup([self verticalScroller]);
483 // We MUST call super's implementation or else nothing seems to work right at all.
484 // However, we need our scrollers not to change values due to the document window
485 // moving so we cheat and save/restore their values across this call.
486 [super reflectScrolledClipView: aClipView];
487 }
488
489 @end
490 WX_IMPLEMENT_GET_OBJC_CLASS(WXManualScrollView,NSScrollView)
491
492 // ========================================================================
493 // wxFlippedNSClipView
494 // ========================================================================
495 @interface wxFlippedNSClipView : NSClipView
496 - (BOOL)isFlipped;
497 @end
498 WX_DECLARE_GET_OBJC_CLASS(wxFlippedNSClipView,NSClipView)
499
500 @implementation wxFlippedNSClipView : NSClipView
501 - (BOOL)isFlipped
502 {
503 return YES;
504 }
505
506 @end
507 WX_IMPLEMENT_GET_OBJC_CLASS(wxFlippedNSClipView,NSClipView)
508
509 // ========================================================================
510 // wxWindowCocoaScrollView
511 // ========================================================================
512 wxWindowCocoaScrollView::wxWindowCocoaScrollView(wxWindow *owner)
513 : m_owner(owner)
514 , m_cocoaNSScrollView() // nil
515 , m_scrollRange() // {0,0}
516 , m_scrollThumb() // {0,0}
517 , m_virtualOrigin(0,0)
518 {
519 wxAutoNSAutoreleasePool pool;
520 wxASSERT(owner);
521 wxASSERT(owner->GetNSView());
522 m_isNativeView = ![owner->GetNSView() isKindOfClass:[WX_GET_OBJC_CLASS(WXNSView) class]];
523 m_cocoaNSScrollView = [(m_isNativeView?[NSScrollView alloc]:[WXManualScrollView alloc])
524 initWithFrame:[owner->GetNSView() frame]];
525 AssociateNSView(m_cocoaNSScrollView);
526 if(m_isNativeView)
527 {
528 /* Set a bezel border around the entire thing because it looks funny without it.
529 TODO: Be sure to undo any borders on the real view (if any) and apply them
530 to this view if necessary. Right now, there is no border support in wxCocoa
531 so this isn't an issue.
532 */
533 [m_cocoaNSScrollView setBorderType:NSBezelBorder];
534 }
535 else
536 {
537 [(WXManualScrollView*)m_cocoaNSScrollView _wx_setWxCocoaScrollView: this];
538 // Don't set a bezel because we might be creating a scroll view due to being
539 // the "target window" of a wxScrolledWindow. That is to say that the user
540 // has absolutely no intention of scrolling the clip view used by this
541 // NSScrollView.
542 }
543
544 /* Replace the default NSClipView with a flipped one. This ensures
545 scrolling is "pinned" to the top-left instead of bottom-right. */
546 NSClipView *flippedClip = [[WX_GET_OBJC_CLASS(wxFlippedNSClipView) alloc]
547 initWithFrame: [[m_cocoaNSScrollView contentView] frame]];
548 [m_cocoaNSScrollView setContentView:flippedClip];
549 [flippedClip release];
550
551 // In all cases we must encapsulate the real NSView properly
552 Encapsulate();
553 }
554
555 void wxWindowCocoaScrollView::Encapsulate()
556 {
557 // Set the scroll view autoresizingMask to match the current NSView
558 [m_cocoaNSScrollView setAutoresizingMask: [m_owner->GetNSView() autoresizingMask]];
559 [m_owner->GetNSView() setAutoresizingMask: NSViewNotSizable];
560 // NOTE: replaceSubView will cause m_cocaNSView to be released
561 // except when it hasn't been added into an NSView hierarchy in which
562 // case it doesn't need to be and this should work out to a no-op
563 m_owner->CocoaReplaceView(m_owner->GetNSView(), m_cocoaNSScrollView);
564 // The NSView is still retained by owner
565 [m_cocoaNSScrollView setDocumentView: m_owner->GetNSView()];
566 // Now it's also retained by the NSScrollView
567 }
568
569 void wxWindowCocoaScrollView::Unencapsulate()
570 {
571 [m_cocoaNSScrollView setDocumentView: nil];
572 m_owner->CocoaReplaceView(m_cocoaNSScrollView, m_owner->GetNSView());
573 if(![[m_owner->GetNSView() superview] isFlipped])
574 [m_owner->GetNSView() setAutoresizingMask: NSViewMinYMargin];
575 }
576
577 wxWindowCocoaScrollView::~wxWindowCocoaScrollView()
578 {
579 DisassociateNSView(m_cocoaNSScrollView);
580 if(!m_isNativeView)
581 {
582 [(WXManualScrollView*)m_cocoaNSScrollView _wx_setWxCocoaScrollView:NULL];
583 }
584 [m_cocoaNSScrollView release];
585 }
586
587 void wxWindowCocoaScrollView::ClientSizeToSize(int &width, int &height)
588 {
589 NSSize frameSize = [NSScrollView
590 frameSizeForContentSize: NSMakeSize(width,height)
591 hasHorizontalScroller: [m_cocoaNSScrollView hasHorizontalScroller]
592 hasVerticalScroller: [m_cocoaNSScrollView hasVerticalScroller]
593 borderType: [m_cocoaNSScrollView borderType]];
594 width = (int)frameSize.width;
595 height = (int)frameSize.height;
596 }
597
598 void wxWindowCocoaScrollView::DoGetClientSize(int *x, int *y) const
599 {
600 NSSize nssize = [m_cocoaNSScrollView contentSize];
601 if(x)
602 *x = (int)nssize.width;
603 if(y)
604 *y = (int)nssize.height;
605 }
606
607 static inline void SetCocoaScroller(NSScroller *aScroller, int WXUNUSED(orientation), int position, int thumbSize, int range)
608 {
609 wxCHECK_RET(aScroller != nil, wxT("Expected the NSScrollView to have a scroller"));
610
611 // NOTE: thumbSize is already ensured to be >= 1 and <= range by our caller
612 // unless range = 0 in which case we shouldn't have been be called.
613 wxCHECK_RET(range > 0, wxT("Internal wxCocoa bug: shouldn't have been called with 0 range"));
614
615 // Range of valid position values is from 0 to effectiveRange
616 // NOTE: if thumbSize == range then effectiveRange is 0.
617 // thumbSize is at least 1 which gives range from 0 to range - 1 inclusive
618 // which is exactly what we want.
619 int effectiveRange = range - thumbSize;
620
621 // knobProportion is hopefully easy to understand
622 // Note that thumbSize is already guaranteed >= 1 by our caller.
623 CGFloat const knobProportion = CGFloat(thumbSize)/CGFloat(range);
624
625 // NOTE: When effectiveRange is zero there really is no valid position
626 // We arbitrarily pick 0.0 which is the same as a scroller in the home position.
627 CGFloat const floatValue = (effectiveRange != 0)?CGFloat(position)/CGFloat(effectiveRange):0.0;
628
629 [aScroller setFloatValue:floatValue knobProportion: knobProportion];
630 // Make sure it's visibly working
631 [aScroller setEnabled:YES];
632 }
633
634 void wxWindowCocoaScrollView::SetScrollPos(wxOrientation orientation, int position)
635 {
636 // NOTE: Rather than using only setFloatValue: (which we could do) we instead
637 // simply share the SetCocoaScroller call because all but the knobProportion
638 // calculations have to be done anyway.
639 if(orientation & wxHORIZONTAL)
640 {
641 NSScroller *aScroller = [m_cocoaNSScrollView horizontalScroller];
642 if(aScroller != nil)
643 SetCocoaScroller(aScroller, orientation, position, m_scrollThumb[0], m_scrollRange[0]);
644 }
645 if(orientation & wxVERTICAL)
646 {
647 NSScroller *aScroller = [m_cocoaNSScrollView verticalScroller];
648 if(aScroller != nil)
649 SetCocoaScroller(aScroller, orientation, position, m_scrollThumb[1], m_scrollRange[1]);
650 }
651 }
652
653 void wxWindowCocoaScrollView::SetScrollbar(int orientation, int position, int thumbSize, int range)
654 {
655 // FIXME: API assumptions:
656 // 1. If the user wants to remove a scroller he gives range 0.
657 // 2. If the user wants to disable a scroller he sets thumbSize == range
658 // in which case it is logically impossible to scroll.
659 // The scroller shall still be displayed.
660
661 // Ensure that range is >= 0.
662 wxASSERT(range >= 0);
663 if(range < 0)
664 range = 0;
665
666 // Ensure that thumbSize <= range
667 wxASSERT(thumbSize <= range);
668 // Also ensure thumbSize >= 1 but don't complain if it isn't
669 if(thumbSize < 1)
670 thumbSize = 1;
671 // Now make sure it's really less than range, even if we just set it to 1
672 if(thumbSize > range)
673 thumbSize = range;
674
675 bool needScroller = (range != 0);
676
677 // Can potentially set both horizontal and vertical at the same time although this is
678 // probably not very useful.
679 if(orientation & wxHORIZONTAL)
680 {
681 m_scrollRange[0] = range;
682 m_scrollThumb[0] = thumbSize;
683 if(!m_isNativeView)
684 {
685 [m_cocoaNSScrollView setHasHorizontalScroller:needScroller];
686 if(needScroller)
687 SetCocoaScroller([m_cocoaNSScrollView horizontalScroller], orientation, position, thumbSize, range);
688 }
689 }
690
691 if(orientation & wxVERTICAL)
692 {
693 m_scrollRange[1] = range;
694 m_scrollThumb[1] = thumbSize;
695 if(!m_isNativeView)
696 {
697 [m_cocoaNSScrollView setHasVerticalScroller:needScroller];
698 if(needScroller)
699 SetCocoaScroller([m_cocoaNSScrollView verticalScroller], orientation, position, thumbSize, range);
700 }
701 }
702 }
703
704 int wxWindowCocoaScrollView::GetScrollPos(wxOrientation orient)
705 {
706 if((orient & wxBOTH) == wxBOTH)
707 {
708 wxLogError(wxT("GetScrollPos called for wxHORIZONTAL and wxVERTICAL together which makes no sense"));
709 return 0;
710 }
711 int effectiveScrollRange;
712 NSScroller *cocoaScroller;
713 if(orient & wxHORIZONTAL)
714 {
715 effectiveScrollRange = m_scrollRange[0] - m_scrollThumb[0];
716 cocoaScroller = [m_cocoaNSScrollView horizontalScroller];
717 }
718 else if(orient & wxVERTICAL)
719 {
720 effectiveScrollRange = m_scrollRange[1] - m_scrollThumb[1];
721 cocoaScroller = [m_cocoaNSScrollView verticalScroller];
722 }
723 else
724 {
725 wxLogError(wxT("GetScrollPos called without an orientation which makes no sense"));
726 return 0;
727 }
728 if(cocoaScroller == nil)
729 { // Document is not scrolled
730 return 0;
731 }
732 /*
733 The effective range of a scroll bar as defined by wxWidgets is from 0 to (range - thumbSize).
734 That is a scroller at the left/top position is at 0 and a scroller at the bottom/right
735 position is at range-thumbsize.
736
737 The range of an NSScroller is 0.0 to 1.0. Much easier! NOTE: Apple doesn't really specify
738 but GNUStep docs do say that 0.0 is top/left and 1.0 is bottom/right. This is actualy
739 in contrast to NSSlider which generally has 1.0 at the TOP when it's done vertically.
740 */
741 CGFloat cocoaScrollPos = [cocoaScroller floatValue];
742 return effectiveScrollRange * cocoaScrollPos;
743 }
744
745 int wxWindowCocoaScrollView::GetScrollRange(wxOrientation orient)
746 {
747 if((orient & wxBOTH) == wxBOTH)
748 {
749 wxLogError(wxT("GetScrollRange called for wxHORIZONTAL and wxVERTICAL together which makes no sense"));
750 return 0;
751 }
752 if(orient & wxHORIZONTAL)
753 {
754 return m_scrollRange[0];
755 }
756 else if(orient & wxVERTICAL)
757 {
758 return m_scrollRange[1];
759 }
760 else
761 {
762 wxLogError(wxT("GetScrollPos called without an orientation which makes no sense"));
763 return 0;
764 }
765 }
766
767 int wxWindowCocoaScrollView::GetScrollThumb(wxOrientation orient)
768 {
769 if((orient & wxBOTH) == wxBOTH)
770 {
771 wxLogError(wxT("GetScrollThumb called for wxHORIZONTAL and wxVERTICAL together which makes no sense"));
772 return 0;
773 }
774 if(orient & wxHORIZONTAL)
775 {
776 return m_scrollThumb[0];
777 }
778 else if(orient & wxVERTICAL)
779 {
780 return m_scrollThumb[1];
781 }
782 else
783 {
784 wxLogError(wxT("GetScrollThumb called without an orientation which makes no sense"));
785 return 0;
786 }
787 }
788
789 /*!
790 Moves the contents (all existing drawing as well as all all child wxWindow) by the specified
791 amount expressed in the wxWindow's own coordinate system. This is used to implement scrolling
792 but the usage is rather interesting. When scrolling right (e.g. increasing the value of
793 the scroller) you must give a negative delta x (e.g. moving the contents LEFT). Likewise,
794 when scrolling the window down, increasing the value of the scroller, you give a negative
795 delta y which moves the contents up.
796
797 wxCocoa notes: To accomplish this trick in Cocoa we basically do what NSScrollView would
798 have done and that is adjust the content view's bounds origin. The content view is somewhat
799 confusingly the NSClipView which is more or less sort of the pImpl for NSScrollView
800 The real NSView with the user's content (e.g. the "virtual area" in wxWidgets parlance)
801 is called the document view in NSScrollView parlance.
802
803 The bounds origin is basically the exact opposite concept. Whereas in Windows the client
804 coordinate system remains constant and the content must shift left/up for increases
805 of scrolling, in Cocoa the coordinate system is actually the virtual one. So we must
806 instead shift the bounds rectangle right/down to get the effect of the content moving
807 left/up. Basically, it's a higher level interface than that provided by wxWidgets
808 so essentially we're implementing the low-level move content interface in terms of
809 the high-level move the viewport (the bounds) over top that content (the document
810 view which is the virtual area to wx).
811
812 For all intents and purposes that basically just means that we subtract the deltas
813 from the bounds origin and thus a negative delta actually increases the bounds origin
814 and a positive delta actually decreases it. This is absolutely true for the horizontal
815 axis but there's a catch in the vertical axis. If the content view (the clip view) is
816 flipped (and we do this by default) then it works exactly like the horizontal axis.
817 If it is not flipped (i.e. it is in postscript coordinates which are opposite to
818 wxWidgets) then the sense needs to be reversed.
819
820 However, this plays hell with window positions. The frame rects of any child views
821 do not change origin and this is actually important because if they did, the views
822 would send frame changed notifications, not to mention that Cocoa just doesn't really
823 do scrolling that way, it does it the way we do it here.
824
825 To fix this we implement GetPosition for child windows to not merely consult its
826 superview at the Cocoa level in order to do proper Cocoa->wx coordinate transform
827 but to actually consult is parent wxWindow because it makes a big difference if
828 the parent is scrolled. Argh. (FIXME: This isn't actually implemented yet)
829 */
830 void wxWindowCocoaScrollView::ScrollWindow(int dx, int dy, const wxRect*)
831 {
832 // Update our internal origin so we know how much the application code
833 // expects us to have been scrolled.
834 m_virtualOrigin.x += dx;
835 m_virtualOrigin.y += dy;
836
837 // Scroll the window using the standard Cocoa method of adjusting the
838 // clip view's bounds in the opposite fashion.
839 NSClipView *contentView = [m_cocoaNSScrollView contentView];
840 NSRect clipViewBoundsRect = [contentView bounds];
841 clipViewBoundsRect.origin.x -= dx;
842 if([contentView isFlipped])
843 clipViewBoundsRect.origin.y -= dy;
844 else
845 clipViewBoundsRect.origin.y += dy;
846 [contentView scrollToPoint:clipViewBoundsRect.origin];
847 }
848
849 void wxWindowCocoaScrollView::_wx_doScroller(NSScroller *sender)
850 {
851 wxOrientation orientation;
852 if(sender == [m_cocoaNSScrollView horizontalScroller])
853 orientation = wxHORIZONTAL;
854 else if(sender == [m_cocoaNSScrollView verticalScroller])
855 orientation = wxVERTICAL;
856 else
857 {
858 wxLogDebug(wxT("Received action message from unexpected NSScroller"));
859 return;
860 }
861 // NOTE: Cocoa does not move the scroller for page up/down or line
862 // up/down events. That means the value will be the old value.
863 // For thumbtrack events, the value is the new value.
864 int scrollpos = GetScrollPos(orientation);
865 int commandType;
866 switch([sender hitPart])
867 {
868 default:
869 case NSScrollerNoPart:
870 case NSScrollerKnob: // Drag of knob
871 case NSScrollerKnobSlot: // Jump directly to position
872 commandType = wxEVT_SCROLLWIN_THUMBTRACK;
873 break;
874 case NSScrollerDecrementPage:
875 commandType = wxEVT_SCROLLWIN_PAGEUP;
876 break;
877 case NSScrollerIncrementPage:
878 commandType = wxEVT_SCROLLWIN_PAGEDOWN;
879 break;
880 case NSScrollerDecrementLine:
881 commandType = wxEVT_SCROLLWIN_LINEUP;
882 break;
883 case NSScrollerIncrementLine:
884 commandType = wxEVT_SCROLLWIN_LINEDOWN;
885 break;
886 }
887 wxScrollWinEvent event(commandType, scrollpos, orientation);
888 event.SetEventObject(m_owner);
889 m_owner->HandleWindowEvent(event);
890 }
891
892 void wxWindowCocoaScrollView::UpdateSizes()
893 {
894 // Using the virtual size, figure out what the document frame size should be
895 // NOTE: Assume that the passed in virtualSize is already >= the client size
896 wxSize virtualSize = m_owner->GetVirtualSize();
897
898 // Get the document's current frame
899 NSRect documentViewFrame = [m_owner->GetNSView() frame];
900 NSRect newFrame = documentViewFrame;
901 newFrame.size = NSMakeSize(virtualSize.x, virtualSize.y);
902
903 if(!NSEqualRects(newFrame, documentViewFrame))
904 {
905 [m_owner->GetNSView() setFrame:newFrame];
906 }
907 }
908
909 void wxWindowCocoaScrollView::Cocoa_FrameChanged(void)
910 {
911 wxLogTrace(wxTRACE_COCOA,wxT("wxWindowCocoaScrollView=%p::Cocoa_FrameChanged for wxWindow %p"), this, m_owner);
912 wxSizeEvent event(m_owner->GetSize(), m_owner->GetId());
913 event.SetEventObject(m_owner);
914 m_owner->HandleWindowEvent(event);
915
916 /* If the view is not a native one then it's being managed by wx. In this case the control
917 may decide to change its virtual size and we must update the document view's size to
918 match. For native views the virtual size will never have been set so we do not want
919 to use it at all.
920 */
921 if(!m_isNativeView)
922 UpdateSizes();
923 }
924
925 // ========================================================================
926 // wxWindowCocoa
927 // ========================================================================
928 // normally the base classes aren't included, but wxWindow is special
929 #ifdef __WXUNIVERSAL__
930 IMPLEMENT_ABSTRACT_CLASS(wxWindowCocoa, wxWindowBase)
931 #endif
932
933 BEGIN_EVENT_TABLE(wxWindowCocoa, wxWindowBase)
934 END_EVENT_TABLE()
935
936 wxWindow *wxWindowCocoa::sm_capturedWindow = NULL;
937
938 // Constructor
939 void wxWindowCocoa::Init()
940 {
941 m_cocoaNSView = NULL;
942 m_cocoaHider = NULL;
943 m_wxCocoaScrollView = NULL;
944 m_isInPaint = false;
945 m_visibleTrackingRectManager = NULL;
946 }
947
948 // Constructor
949 bool wxWindow::Create(wxWindow *parent, wxWindowID winid,
950 const wxPoint& pos,
951 const wxSize& size,
952 long style,
953 const wxString& name)
954 {
955 if(!CreateBase(parent,winid,pos,size,style,wxDefaultValidator,name))
956 return false;
957
958 // TODO: create the window
959 m_cocoaNSView = NULL;
960 SetNSView([[WX_GET_OBJC_CLASS(WXNSView) alloc] initWithFrame: MakeDefaultNSRect(size)]);
961 [m_cocoaNSView release];
962
963 if (m_parent)
964 {
965 m_parent->AddChild(this);
966 m_parent->CocoaAddChild(this);
967 SetInitialFrameRect(pos,size);
968 }
969
970 return true;
971 }
972
973 // Destructor
974 wxWindow::~wxWindow()
975 {
976 wxAutoNSAutoreleasePool pool;
977 DestroyChildren();
978
979 // Make sure our parent (in the wxWidgets sense) is our superview
980 // before we go removing from it.
981 if(m_parent && m_parent->GetNSView()==[GetNSViewForSuperview() superview])
982 CocoaRemoveFromParent();
983 delete m_cocoaHider;
984 delete m_wxCocoaScrollView;
985 if(m_cocoaNSView)
986 SendDestroyEvent();
987 SetNSView(NULL);
988 }
989
990 void wxWindowCocoa::CocoaAddChild(wxWindowCocoa *child)
991 {
992 // Pool here due to lack of one during wx init phase
993 wxAutoNSAutoreleasePool pool;
994
995 NSView *childView = child->GetNSViewForSuperview();
996
997 wxASSERT(childView);
998 [m_cocoaNSView addSubview: childView];
999 }
1000
1001 void wxWindowCocoa::CocoaRemoveFromParent(void)
1002 {
1003 [GetNSViewForSuperview() removeFromSuperview];
1004 }
1005
1006 void wxWindowCocoa::SetNSView(WX_NSView cocoaNSView)
1007 {
1008 // Clear the visible area tracking rect if we have one.
1009 delete m_visibleTrackingRectManager;
1010 m_visibleTrackingRectManager = NULL;
1011
1012 bool need_debug = cocoaNSView || m_cocoaNSView;
1013 if(need_debug) wxLogTrace(wxTRACE_COCOA_RetainRelease,wxT("wxWindowCocoa=%p::SetNSView [m_cocoaNSView=%p retainCount]=%d"),this,m_cocoaNSView,[m_cocoaNSView retainCount]);
1014 DisassociateNSView(m_cocoaNSView);
1015 wxGCSafeRetain(cocoaNSView);
1016 wxGCSafeRelease(m_cocoaNSView);
1017 m_cocoaNSView = cocoaNSView;
1018 AssociateNSView(m_cocoaNSView);
1019 if(need_debug) wxLogTrace(wxTRACE_COCOA_RetainRelease,wxT("wxWindowCocoa=%p::SetNSView [cocoaNSView=%p retainCount]=%d"),this,cocoaNSView,[cocoaNSView retainCount]);
1020 }
1021
1022 WX_NSView wxWindowCocoa::GetNSViewForSuperview() const
1023 {
1024 return m_cocoaHider
1025 ? m_cocoaHider->GetNSView()
1026 : m_wxCocoaScrollView
1027 ? m_wxCocoaScrollView->GetNSScrollView()
1028 : m_cocoaNSView;
1029 }
1030
1031 WX_NSView wxWindowCocoa::GetNSViewForHiding() const
1032 {
1033 return m_wxCocoaScrollView
1034 ? m_wxCocoaScrollView->GetNSScrollView()
1035 : m_cocoaNSView;
1036 }
1037
1038 NSPoint wxWindowCocoa::CocoaTransformBoundsToWx(NSPoint pointBounds)
1039 {
1040 // TODO: Handle scrolling offset
1041 return CocoaTransformNSViewBoundsToWx(GetNSView(), pointBounds);
1042 }
1043
1044 NSRect wxWindowCocoa::CocoaTransformBoundsToWx(NSRect rectBounds)
1045 {
1046 // TODO: Handle scrolling offset
1047 return CocoaTransformNSViewBoundsToWx(GetNSView(), rectBounds);
1048 }
1049
1050 NSPoint wxWindowCocoa::CocoaTransformWxToBounds(NSPoint pointWx)
1051 {
1052 // TODO: Handle scrolling offset
1053 return CocoaTransformNSViewWxToBounds(GetNSView(), pointWx);
1054 }
1055
1056 NSRect wxWindowCocoa::CocoaTransformWxToBounds(NSRect rectWx)
1057 {
1058 // TODO: Handle scrolling offset
1059 return CocoaTransformNSViewWxToBounds(GetNSView(), rectWx);
1060 }
1061
1062 WX_NSAffineTransform wxWindowCocoa::CocoaGetWxToBoundsTransform()
1063 {
1064 // TODO: Handle scrolling offset
1065 NSAffineTransform *transform = wxCocoaDCImpl::CocoaGetWxToBoundsTransform([GetNSView() isFlipped], [GetNSView() bounds].size.height);
1066 return transform;
1067 }
1068
1069 bool wxWindowCocoa::Cocoa_drawRect(const NSRect &rect)
1070 {
1071 wxLogTrace(wxTRACE_COCOA,wxT("Cocoa_drawRect"));
1072 // Recursion can happen if the event loop runs from within the paint
1073 // handler. For instance, if an assertion dialog is shown.
1074 // FIXME: This seems less than ideal.
1075 if(m_isInPaint)
1076 {
1077 wxLogDebug(wxT("Paint event recursion!"));
1078 return false;
1079 }
1080 m_isInPaint = true;
1081
1082 // Set m_updateRegion
1083 const NSRect *rects = &rect; // The bounding box of the region
1084 NSInteger countRects = 1;
1085 // Try replacing the larger rectangle with a list of smaller ones:
1086 if ([GetNSView() respondsToSelector:@selector(getRectsBeingDrawn:count:)])
1087 [GetNSView() getRectsBeingDrawn:&rects count:&countRects];
1088
1089 NSRect *transformedRects = (NSRect*)malloc(sizeof(NSRect)*countRects);
1090 for(int i=0; i<countRects; i++)
1091 {
1092 transformedRects[i] = CocoaTransformBoundsToWx(rects[i]);
1093 }
1094 m_updateRegion = wxRegion(transformedRects,countRects);
1095 free(transformedRects);
1096
1097 wxPaintEvent event(m_windowId);
1098 event.SetEventObject(this);
1099 bool ret = HandleWindowEvent(event);
1100 m_isInPaint = false;
1101 return ret;
1102 }
1103
1104 void wxWindowCocoa::InitMouseEvent(wxMouseEvent& event, WX_NSEvent cocoaEvent)
1105 {
1106 wxASSERT_MSG([m_cocoaNSView window]==[cocoaEvent window],wxT("Mouse event for different NSWindow"));
1107 // Mouse events happen at the NSWindow level so we need to convert
1108 // into our bounds coordinates then convert to wx coordinates.
1109 NSPoint cocoaPoint = [m_cocoaNSView convertPoint:[(NSEvent*)cocoaEvent locationInWindow] fromView:nil];
1110 if( m_wxCocoaScrollView != NULL)
1111 {
1112 // This gets the wx client area (i.e. the visible portion of the content) in
1113 // the coordinate system of our (the doucment) view.
1114 NSRect documentVisibleRect = [[m_wxCocoaScrollView->GetNSScrollView() contentView] documentVisibleRect];
1115 // For horizontal, simply subtract the origin.
1116 // e.g. if the origin is at 123 and the user clicks as far left as possible then
1117 // the coordinate that wx wants is 0.
1118 cocoaPoint.x -= documentVisibleRect.origin.x;
1119 if([m_cocoaNSView isFlipped])
1120 {
1121 // In the flipped view case this works exactly like horizontal.
1122 cocoaPoint.y -= documentVisibleRect.origin.y;
1123 }
1124 // For vertical we have to mind non-flipped (e.g. y=0 at bottom) views.
1125 // We also need to mind the fact that we're still in Cocoa coordinates
1126 // and not wx coordinates. The wx coordinate translation will still occur
1127 // and that is going to be wxY = boundsH - cocoaY for non-flipped views.
1128
1129 // When we consider scrolling we are truly interested in how far the top
1130 // edge of the bounds rectangle is scrolled off the screen.
1131 // Assuming the bounds origin is 0 (which is an assumption we make in
1132 // wxCocoa since wxWidgets has no analog to it) then the top edge of
1133 // the bounds rectangle is simply its height. The top edge of the
1134 // documentVisibleRect (e.g. the client area) is its height plus
1135 // its origin.
1136 // Thus, we simply need add the distance between the bounds top
1137 // and the client (docuemntVisibleRect) top.
1138 // Or putting it another way, we subtract the distance between the
1139 // client top and the bounds top.
1140 else
1141 {
1142 NSRect bounds = [m_cocoaNSView bounds];
1143 CGFloat scrollYOrigin = (bounds.size.height - (documentVisibleRect.origin.y + documentVisibleRect.size.height));
1144 cocoaPoint.y += scrollYOrigin;
1145 }
1146 }
1147
1148 NSPoint pointWx = CocoaTransformBoundsToWx(cocoaPoint);
1149 // FIXME: Should we be adjusting for client area origin?
1150 const wxPoint &clientorigin = GetClientAreaOrigin();
1151 event.m_x = (wxCoord)pointWx.x - clientorigin.x;
1152 event.m_y = (wxCoord)pointWx.y - clientorigin.y;
1153
1154 event.m_shiftDown = [cocoaEvent modifierFlags] & NSShiftKeyMask;
1155 event.m_controlDown = [cocoaEvent modifierFlags] & NSControlKeyMask;
1156 event.m_altDown = [cocoaEvent modifierFlags] & NSAlternateKeyMask;
1157 event.m_metaDown = [cocoaEvent modifierFlags] & NSCommandKeyMask;
1158
1159 // TODO: set timestamp?
1160 event.SetEventObject(this);
1161 event.SetId(GetId());
1162 }
1163
1164 bool wxWindowCocoa::Cocoa_mouseMoved(WX_NSEvent theEvent)
1165 {
1166 wxMouseEvent event(wxEVT_MOTION);
1167 InitMouseEvent(event,theEvent);
1168 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_mouseMoved @%d,%d"),this,event.m_x,event.m_y);
1169 return HandleWindowEvent(event);
1170 }
1171
1172 void wxWindowCocoa::Cocoa_synthesizeMouseMoved()
1173 {
1174 wxMouseEvent event(wxEVT_MOTION);
1175 NSWindow *window = [GetNSView() window];
1176 NSPoint locationInWindow = [window mouseLocationOutsideOfEventStream];
1177 NSPoint cocoaPoint = [m_cocoaNSView convertPoint:locationInWindow fromView:nil];
1178
1179 NSPoint pointWx = CocoaTransformBoundsToWx(cocoaPoint);
1180 // FIXME: Should we be adjusting for client area origin?
1181 const wxPoint &clientorigin = GetClientAreaOrigin();
1182 event.m_x = (wxCoord)pointWx.x - clientorigin.x;
1183 event.m_y = (wxCoord)pointWx.y - clientorigin.y;
1184
1185 // TODO: Handle shift, control, alt, meta flags
1186 event.SetEventObject(this);
1187 event.SetId(GetId());
1188
1189 wxLogTrace(wxTRACE_COCOA,wxT("wxwin=%p Synthesized Mouse Moved @%d,%d"),this,event.m_x,event.m_y);
1190 HandleWindowEvent(event);
1191 }
1192
1193 bool wxWindowCocoa::Cocoa_mouseEntered(WX_NSEvent theEvent)
1194 {
1195 if(m_visibleTrackingRectManager != NULL && m_visibleTrackingRectManager->IsOwnerOfEvent(theEvent))
1196 {
1197 m_visibleTrackingRectManager->BeginSynthesizingEvents();
1198
1199 // Although we synthesize the mouse moved events we don't poll for them but rather send them only when
1200 // some other event comes in. That other event is (guess what) mouse moved events that will be sent
1201 // to the NSWindow which will forward them on to the first responder. We are not likely to be the
1202 // first responder, so the mouseMoved: events are effectively discarded.
1203 [[GetNSView() window] setAcceptsMouseMovedEvents:YES];
1204
1205 wxMouseEvent event(wxEVT_ENTER_WINDOW);
1206 InitMouseEvent(event,theEvent);
1207 wxLogTrace(wxTRACE_COCOA_TrackingRect,wxT("wxwin=%p Mouse Entered TR#%d @%d,%d"),this,[theEvent trackingNumber], event.m_x,event.m_y);
1208 return HandleWindowEvent(event);
1209 }
1210 else
1211 return false;
1212 }
1213
1214 bool wxWindowCocoa::Cocoa_mouseExited(WX_NSEvent theEvent)
1215 {
1216 if(m_visibleTrackingRectManager != NULL && m_visibleTrackingRectManager->IsOwnerOfEvent(theEvent))
1217 {
1218 m_visibleTrackingRectManager->StopSynthesizingEvents();
1219
1220 wxMouseEvent event(wxEVT_LEAVE_WINDOW);
1221 InitMouseEvent(event,theEvent);
1222 wxLogTrace(wxTRACE_COCOA_TrackingRect,wxT("wxwin=%p Mouse Exited TR#%d @%d,%d"),this,[theEvent trackingNumber],event.m_x,event.m_y);
1223 return HandleWindowEvent(event);
1224 }
1225 else
1226 return false;
1227 }
1228
1229 bool wxWindowCocoa::Cocoa_mouseDown(WX_NSEvent theEvent)
1230 {
1231 wxMouseEvent event([theEvent clickCount]<2?wxEVT_LEFT_DOWN:wxEVT_LEFT_DCLICK);
1232 InitMouseEvent(event,theEvent);
1233 wxLogTrace(wxTRACE_COCOA,wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
1234 return HandleWindowEvent(event);
1235 }
1236
1237 bool wxWindowCocoa::Cocoa_mouseDragged(WX_NSEvent theEvent)
1238 {
1239 wxMouseEvent event(wxEVT_MOTION);
1240 InitMouseEvent(event,theEvent);
1241 event.m_leftDown = true;
1242 wxLogTrace(wxTRACE_COCOA,wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
1243 return HandleWindowEvent(event);
1244 }
1245
1246 bool wxWindowCocoa::Cocoa_mouseUp(WX_NSEvent theEvent)
1247 {
1248 wxMouseEvent event(wxEVT_LEFT_UP);
1249 InitMouseEvent(event,theEvent);
1250 wxLogTrace(wxTRACE_COCOA,wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
1251 return HandleWindowEvent(event);
1252 }
1253
1254 bool wxWindowCocoa::Cocoa_rightMouseDown(WX_NSEvent theEvent)
1255 {
1256 wxMouseEvent event([theEvent clickCount]<2?wxEVT_RIGHT_DOWN:wxEVT_RIGHT_DCLICK);
1257 InitMouseEvent(event,theEvent);
1258 wxLogDebug(wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
1259 return HandleWindowEvent(event);
1260 }
1261
1262 bool wxWindowCocoa::Cocoa_rightMouseDragged(WX_NSEvent theEvent)
1263 {
1264 wxMouseEvent event(wxEVT_MOTION);
1265 InitMouseEvent(event,theEvent);
1266 event.m_rightDown = true;
1267 wxLogDebug(wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
1268 return HandleWindowEvent(event);
1269 }
1270
1271 bool wxWindowCocoa::Cocoa_rightMouseUp(WX_NSEvent theEvent)
1272 {
1273 wxMouseEvent event(wxEVT_RIGHT_UP);
1274 InitMouseEvent(event,theEvent);
1275 wxLogDebug(wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
1276 return HandleWindowEvent(event);
1277 }
1278
1279 bool wxWindowCocoa::Cocoa_otherMouseDown(WX_NSEvent theEvent)
1280 {
1281 return false;
1282 }
1283
1284 bool wxWindowCocoa::Cocoa_otherMouseDragged(WX_NSEvent theEvent)
1285 {
1286 return false;
1287 }
1288
1289 bool wxWindowCocoa::Cocoa_otherMouseUp(WX_NSEvent theEvent)
1290 {
1291 return false;
1292 }
1293
1294 void wxWindowCocoa::Cocoa_FrameChanged(void)
1295 {
1296 // We always get this message for the real NSView which may have been
1297 // enclosed in an NSScrollView. If that's the case then what we're
1298 // effectively getting here is a notifcation that the
1299 // virtual sized changed.. which we don't need to send on since
1300 // wx has no concept of this whatsoever.
1301 bool isViewForSuperview = (m_wxCocoaScrollView == NULL);
1302 if(isViewForSuperview)
1303 {
1304 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_FrameChanged"),this);
1305 if(m_visibleTrackingRectManager != NULL)
1306 m_visibleTrackingRectManager->RebuildTrackingRect();
1307 wxSizeEvent event(GetSize(), m_windowId);
1308 event.SetEventObject(this);
1309 HandleWindowEvent(event);
1310 }
1311 else
1312 {
1313 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_FrameChanged ignored"),this);
1314 }
1315 }
1316
1317 bool wxWindowCocoa::Cocoa_resetCursorRects()
1318 {
1319 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_resetCursorRects"),this);
1320
1321 // When we are called there may be a queued tracking rect event (mouse entered or exited) and
1322 // we won't know it. A specific example is wxGenericHyperlinkCtrl changing the cursor from its
1323 // mouse exited event. If the control happens to share the edge with its parent window which is
1324 // also tracking mouse events then Cocoa receives two mouse exited events from the window server.
1325 // The first one will cause wxGenericHyperlinkCtrl to call wxWindow::SetCursor which will
1326 // invaildate the cursor rect causing Cocoa to schedule cursor rect reset with the run loop
1327 // which willl in turn call us before exiting for the next user event.
1328
1329 // If we are the parent window then rebuilding our tracking rectangle will cause us to miss
1330 // our mouse exited event because the already queued event will have the old tracking rect
1331 // tag. The simple solution is to only rebuild our tracking rect if we need to.
1332
1333 if(m_visibleTrackingRectManager != NULL)
1334 m_visibleTrackingRectManager->RebuildTrackingRectIfNeeded();
1335
1336 if(!m_cursor.GetNSCursor())
1337 return false;
1338
1339 [GetNSView() addCursorRect: [GetNSView() visibleRect] cursor: m_cursor.GetNSCursor()];
1340
1341 return true;
1342 }
1343
1344 bool wxWindowCocoa::SetCursor(const wxCursor &cursor)
1345 {
1346 if(!wxWindowBase::SetCursor(cursor))
1347 return false;
1348
1349 // Set up the cursor rect so that invalidateCursorRectsForView: will destroy it.
1350 // If we don't do this then Cocoa thinks (rightly) that we don't have any cursor
1351 // rects and thus won't ever call resetCursorRects.
1352 [GetNSView() addCursorRect: [GetNSView() visibleRect] cursor: m_cursor.GetNSCursor()];
1353
1354 // Invalidate the cursor rects so the cursor will change
1355 // Note that it is not enough to remove the old one (if any) and add the new one.
1356 // For the rects to work properly, Cocoa itself must call resetCursorRects.
1357 [[GetNSView() window] invalidateCursorRectsForView:GetNSView()];
1358 return true;
1359 }
1360
1361 bool wxWindowCocoa::Cocoa_viewDidMoveToWindow()
1362 {
1363 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::viewDidMoveToWindow"),this);
1364 // Set up new tracking rects. I am reasonably sure the new window must be set before doing this.
1365 if(m_visibleTrackingRectManager != NULL)
1366 m_visibleTrackingRectManager->BuildTrackingRect();
1367 return false;
1368 }
1369
1370 bool wxWindowCocoa::Cocoa_viewWillMoveToWindow(WX_NSWindow newWindow)
1371 {
1372 wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::viewWillMoveToWindow:%p"),this, newWindow);
1373 // Clear tracking rects. It is imperative this be done before the new window is set.
1374 if(m_visibleTrackingRectManager != NULL)
1375 m_visibleTrackingRectManager->ClearTrackingRect();
1376 return false;
1377 }
1378
1379 bool wxWindow::Close(bool force)
1380 {
1381 // The only reason this function exists is that it is virtual and
1382 // wxTopLevelWindowCocoa will override it.
1383 return wxWindowBase::Close(force);
1384 }
1385
1386 void wxWindow::CocoaReplaceView(WX_NSView oldView, WX_NSView newView)
1387 {
1388 [[oldView superview] replaceSubview:oldView with:newView];
1389 }
1390
1391 void wxWindow::DoEnable(bool enable)
1392 {
1393 CocoaSetEnabled(enable);
1394 }
1395
1396 bool wxWindow::Show(bool show)
1397 {
1398 wxAutoNSAutoreleasePool pool;
1399 // If the window is marked as visible, then it shouldn't have a dummy view
1400 // If the window is marked hidden, then it should have a dummy view
1401 // wxSpinCtrl (generic) abuses m_isShown, don't use it for any logic
1402 // wxASSERT_MSG( (m_isShown && !m_dummyNSView) || (!m_isShown && m_dummyNSView),wxT("wxWindow: m_isShown does not agree with m_dummyNSView"));
1403 // Return false if there isn't a window to show or hide
1404 NSView *cocoaView = GetNSViewForHiding();
1405 if(!cocoaView)
1406 return false;
1407 if(show)
1408 {
1409 // If state isn't changing, return false
1410 if(!m_cocoaHider)
1411 return false;
1412
1413 // Replace the stand-in view with the real one and destroy the dummy view
1414 CocoaReplaceView(m_cocoaHider->GetNSView(), cocoaView);
1415 wxASSERT(![m_cocoaHider->GetNSView() superview]);
1416 delete m_cocoaHider;
1417 m_cocoaHider = NULL;
1418 wxASSERT([cocoaView superview]);
1419
1420 // Schedule an update of the key view loop (NOTE: 10.4+ only.. argh)
1421 NSWindow *window = [cocoaView window];
1422 if(window != nil)
1423 {
1424 // Delay this until returning to the event loop for a couple of reasons:
1425 // 1. If a lot of stuff is shown/hidden we avoid recalculating needlessly
1426 // 2. NSWindow does not seem to see the newly shown views if we do it right now.
1427 if([window respondsToSelector:@selector(recalculateKeyViewLoop)])
1428 [window performSelector:@selector(recalculateKeyViewLoop) withObject:nil afterDelay:0.0];
1429 }
1430 }
1431 else
1432 {
1433 // If state isn't changing, return false
1434 if(m_cocoaHider)
1435 return false;
1436
1437 // Handle the first responder
1438 NSWindow *window = [cocoaView window];
1439 if(window != nil)
1440 {
1441 NSResponder *firstResponder = [window firstResponder];
1442 if([firstResponder isKindOfClass:[NSView class]] && [(NSView*)firstResponder isDescendantOf:cocoaView])
1443 {
1444 BOOL didResign = [window makeFirstResponder:nil];
1445 // If the current first responder (one of our subviews) refuses to give
1446 // up its status, then fail now and don't hide this view
1447 if(didResign == NO)
1448 return false;
1449 }
1450 }
1451
1452 // Create a new view to stand in for the real one (via wxWindowCocoaHider) and replace
1453 // the real one with the stand in.
1454 m_cocoaHider = new wxWindowCocoaHider(this);
1455 // NOTE: replaceSubview:with will cause m_cocaNSView to be
1456 // (auto)released which balances out addSubview
1457 CocoaReplaceView(cocoaView, m_cocoaHider->GetNSView());
1458 // m_coocaNSView is now only retained by us
1459 wxASSERT([m_cocoaHider->GetNSView() superview]);
1460 wxASSERT(![cocoaView superview]);
1461 }
1462 m_isShown = show;
1463 return true;
1464 }
1465
1466 void wxWindowCocoa::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1467 {
1468 wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoSetSizeWindow(%d,%d,%d,%d,Auto: %s%s)"),this,x,y,width,height,(sizeFlags&wxSIZE_AUTO_WIDTH)?"W":".",sizeFlags&wxSIZE_AUTO_HEIGHT?"H":".");
1469 int currentX, currentY;
1470 int currentW, currentH;
1471 DoGetPosition(&currentX, &currentY);
1472 DoGetSize(&currentW, &currentH);
1473 if((x==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
1474 x=currentX;
1475 if((y==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
1476 y=currentY;
1477
1478 AdjustForParentClientOrigin(x,y,sizeFlags);
1479
1480 wxSize size(wxDefaultSize);
1481
1482 if((width==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
1483 {
1484 if(sizeFlags&wxSIZE_AUTO_WIDTH)
1485 {
1486 size=DoGetBestSize();
1487 width=size.x;
1488 }
1489 else
1490 width=currentW;
1491 }
1492 if((height==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
1493 {
1494 if(sizeFlags&wxSIZE_AUTO_HEIGHT)
1495 {
1496 if(size.x==-1)
1497 size=DoGetBestSize();
1498 height=size.y;
1499 }
1500 else
1501 height=currentH;
1502 }
1503 DoMoveWindow(x,y,width,height);
1504 }
1505
1506 #if wxUSE_TOOLTIPS
1507
1508 void wxWindowCocoa::DoSetToolTip( wxToolTip *tip )
1509 {
1510 wxWindowBase::DoSetToolTip(tip);
1511
1512 if ( m_tooltip )
1513 {
1514 m_tooltip->SetWindow((wxWindow *)this);
1515 }
1516 }
1517
1518 #endif
1519
1520 void wxWindowCocoa::DoMoveWindow(int x, int y, int width, int height)
1521 {
1522 wxAutoNSAutoreleasePool pool;
1523 wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoMoveWindow(%d,%d,%d,%d)"),this,x,y,width,height);
1524
1525 NSView *nsview = GetNSViewForSuperview();
1526 NSView *superview = [nsview superview];
1527
1528 wxCHECK_RET(GetParent(), wxT("Window can only be placed correctly when it has a parent"));
1529
1530 NSRect oldFrameRect = [nsview frame];
1531 NSRect newFrameRect = GetParent()->CocoaTransformWxToBounds(NSMakeRect(x,y,width,height));
1532 [nsview setFrame:newFrameRect];
1533 // Be sure to redraw the parent to reflect the changed position
1534 [superview setNeedsDisplayInRect:oldFrameRect];
1535 [superview setNeedsDisplayInRect:newFrameRect];
1536 }
1537
1538 void wxWindowCocoa::SetInitialFrameRect(const wxPoint& pos, const wxSize& size)
1539 {
1540 NSView *nsview = GetNSViewForSuperview();
1541 NSView *superview = [nsview superview];
1542 wxCHECK_RET(superview,wxT("NSView does not have a superview"));
1543 wxCHECK_RET(GetParent(), wxT("Window can only be placed correctly when it has a parent"));
1544 NSRect frameRect = [nsview frame];
1545 if(size.x!=-1)
1546 frameRect.size.width = size.x;
1547 if(size.y!=-1)
1548 frameRect.size.height = size.y;
1549 frameRect.origin.x = pos.x;
1550 frameRect.origin.y = pos.y;
1551 // Tell Cocoa to change the margin between the bottom of the superview
1552 // and the bottom of the control. Keeps the control pinned to the top
1553 // of its superview so that its position in the wxWidgets coordinate
1554 // system doesn't change.
1555 if(![superview isFlipped])
1556 [nsview setAutoresizingMask: NSViewMinYMargin];
1557 // MUST set the mask before setFrame: which can generate a size event
1558 // and cause a scroller to be added!
1559 frameRect = GetParent()->CocoaTransformWxToBounds(frameRect);
1560 [nsview setFrame: frameRect];
1561 }
1562
1563 // Get total size
1564 void wxWindow::DoGetSize(int *w, int *h) const
1565 {
1566 NSRect cocoaRect = [GetNSViewForSuperview() frame];
1567 if(w)
1568 *w=(int)cocoaRect.size.width;
1569 if(h)
1570 *h=(int)cocoaRect.size.height;
1571 wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoGetSize = (%d,%d)"),this,(int)cocoaRect.size.width,(int)cocoaRect.size.height);
1572 }
1573
1574 void wxWindow::DoGetPosition(int *x, int *y) const
1575 {
1576 NSView *nsview = GetNSViewForSuperview();
1577
1578 NSRect cocoaRect = [nsview frame];
1579 NSRect rectWx = GetParent()->CocoaTransformBoundsToWx(cocoaRect);
1580 if(x)
1581 *x=(int)rectWx.origin.x;
1582 if(y)
1583 *y=(int)rectWx.origin.y;
1584 wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoGetPosition = (%d,%d)"),this,(int)cocoaRect.origin.x,(int)cocoaRect.origin.y);
1585 }
1586
1587 WXWidget wxWindow::GetHandle() const
1588 {
1589 return m_cocoaNSView;
1590 }
1591
1592 wxWindow* wxWindow::GetWxWindow() const
1593 {
1594 return (wxWindow*) this;
1595 }
1596
1597 void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
1598 {
1599 [m_cocoaNSView setNeedsDisplay:YES];
1600 }
1601
1602 void wxWindow::SetFocus()
1603 {
1604 if([GetNSView() acceptsFirstResponder])
1605 [[GetNSView() window] makeFirstResponder: GetNSView()];
1606 }
1607
1608 void wxWindow::DoCaptureMouse()
1609 {
1610 // TODO
1611 sm_capturedWindow = this;
1612 }
1613
1614 void wxWindow::DoReleaseMouse()
1615 {
1616 // TODO
1617 sm_capturedWindow = NULL;
1618 }
1619
1620 void wxWindow::DoScreenToClient(int *x, int *y) const
1621 {
1622 // Point in cocoa screen coordinates:
1623 NSPoint cocoaScreenPoint = OriginInCocoaScreenCoordinatesForRectInWxDisplayCoordinates(x!=NULL?*x:0, y!=NULL?*y:0, 0, 0, false);
1624 NSView *clientView = const_cast<wxWindow*>(this)->GetNSView();
1625 NSWindow *theWindow = [clientView window];
1626
1627 // Point in window's base coordinate system:
1628 NSPoint windowPoint = [theWindow convertScreenToBase:cocoaScreenPoint];
1629 // Point in view's bounds coordinate system
1630 NSPoint boundsPoint = [clientView convertPoint:windowPoint fromView:nil];
1631 // Point in wx client coordinates:
1632 NSPoint theWxClientPoint = CocoaTransformNSViewBoundsToWx(clientView, boundsPoint);
1633 if(x!=NULL)
1634 *x = theWxClientPoint.x;
1635 if(y!=NULL)
1636 *y = theWxClientPoint.y;
1637 }
1638
1639 void wxWindow::DoClientToScreen(int *x, int *y) const
1640 {
1641 // Point in wx client coordinates
1642 NSPoint theWxClientPoint = NSMakePoint(x!=NULL?*x:0, y!=NULL?*y:0);
1643
1644 NSView *clientView = const_cast<wxWindow*>(this)->GetNSView();
1645
1646 // Point in the view's bounds coordinate system
1647 NSPoint boundsPoint = CocoaTransformNSViewWxToBounds(clientView, theWxClientPoint);
1648
1649 // Point in the window's base coordinate system
1650 NSPoint windowPoint = [clientView convertPoint:boundsPoint toView:nil];
1651
1652 NSWindow *theWindow = [clientView window];
1653 // Point in Cocoa's screen coordinates
1654 NSPoint screenPoint = [theWindow convertBaseToScreen:windowPoint];
1655
1656 // Act as though this was the origin of a 0x0 rectangle
1657 NSRect screenPointRect = NSMakeRect(screenPoint.x, screenPoint.y, 0, 0);
1658
1659 // Convert that rectangle to wx coordinates
1660 wxPoint theWxScreenPoint = OriginInWxDisplayCoordinatesForRectInCocoaScreenCoordinates(screenPointRect);
1661 if(*x)
1662 *x = theWxScreenPoint.x;
1663 if(*y)
1664 *y = theWxScreenPoint.y;
1665 }
1666
1667 // Get size *available for subwindows* i.e. excluding menu bar etc.
1668 void wxWindow::DoGetClientSize(int *x, int *y) const
1669 {
1670 wxLogTrace(wxTRACE_COCOA,wxT("DoGetClientSize:"));
1671 if(m_wxCocoaScrollView)
1672 m_wxCocoaScrollView->DoGetClientSize(x,y);
1673 else
1674 wxWindowCocoa::DoGetSize(x,y);
1675 }
1676
1677 void wxWindow::DoSetClientSize(int width, int height)
1678 {
1679 wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("DoSetClientSize=(%d,%d)"),width,height);
1680 if(m_wxCocoaScrollView)
1681 m_wxCocoaScrollView->ClientSizeToSize(width,height);
1682 CocoaSetWxWindowSize(width,height);
1683 }
1684
1685 void wxWindow::CocoaSetWxWindowSize(int width, int height)
1686 {
1687 wxWindowCocoa::DoSetSize(wxDefaultCoord,wxDefaultCoord,width,height,wxSIZE_USE_EXISTING);
1688 }
1689
1690 void wxWindow::SetLabel(const wxString& WXUNUSED(label))
1691 {
1692 // Intentional no-op.
1693 }
1694
1695 wxString wxWindow::GetLabel() const
1696 {
1697 // General Get/Set of labels is implemented in wxControlBase
1698 wxLogDebug(wxT("wxWindow::GetLabel: Should be overridden if needed."));
1699 return wxEmptyString;
1700 }
1701
1702 int wxWindow::GetCharHeight() const
1703 {
1704 // TODO
1705 return 10;
1706 }
1707
1708 int wxWindow::GetCharWidth() const
1709 {
1710 // TODO
1711 return 5;
1712 }
1713
1714 void wxWindow::DoGetTextExtent(const wxString& string, int *outX, int *outY,
1715 int *outDescent, int *outExternalLeading, const wxFont *inFont) const
1716 {
1717 // FIXME: This obviously ignores the window's font (if any) along with any size
1718 // transformations. However, it's better than nothing.
1719 // We don't create a wxClientDC because we don't want to accidently be able to use
1720 // it for drawing.
1721 wxClientDC tmpdc(const_cast<wxWindow*>(this));
1722 return tmpdc.GetTextExtent(string, outX, outY, outDescent, outExternalLeading, inFont);
1723 }
1724
1725 // Coordinates relative to the window
1726 void wxWindow::WarpPointer (int x_pos, int y_pos)
1727 {
1728 // TODO
1729 }
1730
1731 int wxWindow::GetScrollPos(int orient) const
1732 {
1733 if(m_wxCocoaScrollView != NULL)
1734 return m_wxCocoaScrollView->GetScrollPos(static_cast<wxOrientation>(orient & wxBOTH));
1735 else
1736 return 0;
1737 }
1738
1739 // This now returns the whole range, not just the number
1740 // of positions that we can scroll.
1741 int wxWindow::GetScrollRange(int orient) const
1742 {
1743 if(m_wxCocoaScrollView != NULL)
1744 return m_wxCocoaScrollView->GetScrollRange(static_cast<wxOrientation>(orient & wxBOTH));
1745 else
1746 return 0;
1747 }
1748
1749 int wxWindow::GetScrollThumb(int orient) const
1750 {
1751 if(m_wxCocoaScrollView != NULL)
1752 return m_wxCocoaScrollView->GetScrollThumb(static_cast<wxOrientation>(orient & wxBOTH));
1753 else
1754 return 0;
1755 }
1756
1757 void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
1758 {
1759 if(m_wxCocoaScrollView != NULL)
1760 return m_wxCocoaScrollView->SetScrollPos(static_cast<wxOrientation>(orient & wxBOTH), pos);
1761 }
1762
1763 void wxWindow::CocoaCreateNSScrollView()
1764 {
1765 if(!m_wxCocoaScrollView)
1766 {
1767 m_wxCocoaScrollView = new wxWindowCocoaScrollView(this);
1768 }
1769 }
1770
1771 // New function that will replace some of the above.
1772 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
1773 int range, bool refresh)
1774 {
1775 CocoaCreateNSScrollView();
1776 m_wxCocoaScrollView->SetScrollbar(orient, pos, thumbVisible, range);
1777 // TODO: Handle refresh (if we even need to)
1778 }
1779
1780 // Does a physical scroll
1781 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
1782 {
1783 if(m_wxCocoaScrollView != NULL)
1784 m_wxCocoaScrollView->ScrollWindow(dx, dy, rect);
1785 }
1786
1787 void wxWindow::DoSetVirtualSize( int x, int y )
1788 {
1789 // Call wxWindowBase method which will set m_virtualSize to the appropriate value,
1790 // possibly not what the caller passed in. For example, the current implementation
1791 // clamps the width and height to within the min/max virtual ranges.
1792 // wxDefaultCoord is passed through unchanged but then GetVirtualSize() will correct
1793 // that by returning effectively max(virtual, client)
1794 wxWindowBase::DoSetVirtualSize(x,y);
1795 // Create the scroll view if it hasn't been already.
1796 CocoaCreateNSScrollView();
1797
1798 // The GetVirtualSize automatically increases the size to max(client,virtual)
1799 m_wxCocoaScrollView->UpdateSizes();
1800 }
1801
1802 bool wxWindow::SetFont(const wxFont& font)
1803 {
1804 // FIXME: We may need to handle wx font inheritance.
1805 return wxWindowBase::SetFont(font);
1806 }
1807
1808 #if 0 // these are used when debugging the algorithm.
1809 static char const * const comparisonresultStrings[] =
1810 { "<"
1811 , "=="
1812 , ">"
1813 };
1814 #endif
1815
1816 class CocoaWindowCompareContext
1817 {
1818 wxDECLARE_NO_COPY_CLASS(CocoaWindowCompareContext);
1819 public:
1820 CocoaWindowCompareContext(); // Not implemented
1821 CocoaWindowCompareContext(NSView *target, NSArray *subviews)
1822 {
1823 m_target = target;
1824 // Cocoa sorts subviews in-place.. make a copy
1825 m_subviews = [subviews copy];
1826 }
1827 ~CocoaWindowCompareContext()
1828 { // release the copy
1829 [m_subviews release];
1830 }
1831 NSView* target()
1832 { return m_target; }
1833 NSArray* subviews()
1834 { return m_subviews; }
1835 /* Helper function that returns the comparison based off of the original ordering */
1836 CocoaWindowCompareFunctionResult CompareUsingOriginalOrdering(id first, id second)
1837 {
1838 NSUInteger firstI = [m_subviews indexOfObjectIdenticalTo:first];
1839 NSUInteger secondI = [m_subviews indexOfObjectIdenticalTo:second];
1840 // NOTE: If either firstI or secondI is NSNotFound then it will be NSIntegerMax and thus will
1841 // likely compare higher than the other view which is reasonable considering the only way that
1842 // can happen is if the subview was added after our call to subviews but before the call to
1843 // sortSubviewsUsingFunction:context:. Thus we don't bother checking. Particularly because
1844 // that case should never occur anyway because that would imply a multi-threaded GUI call
1845 // which is a big no-no with Cocoa.
1846
1847 // Subviews are ordered from back to front meaning one that is already lower will have an lower index.
1848 NSComparisonResult result = (firstI < secondI)
1849 ? NSOrderedAscending /* -1 */
1850 : (firstI > secondI)
1851 ? NSOrderedDescending /* 1 */
1852 : NSOrderedSame /* 0 */;
1853
1854 #if 0 // Enable this if you need to debug the algorithm.
1855 NSLog(@"%@ [%d] %s %@ [%d]\n", first, firstI, comparisonresultStrings[result+1], second, secondI);
1856 #endif
1857 return result;
1858 }
1859 private:
1860 /* The subview we are trying to Raise or Lower */
1861 NSView *m_target;
1862 /* A copy of the original array of subviews */
1863 NSArray *m_subviews;
1864 };
1865
1866 /* Causes Cocoa to raise the target view to the top of the Z-Order by telling the sort function that
1867 * the target view is always higher than every other view. When comparing two views neither of
1868 * which is the target, it returns the correct response based on the original ordering
1869 */
1870 static CocoaWindowCompareFunctionResult CocoaRaiseWindowCompareFunction(id first, id second, void *ctx)
1871 {
1872 CocoaWindowCompareContext *compareContext = (CocoaWindowCompareContext*)ctx;
1873 // first should be ordered higher
1874 if(first==compareContext->target())
1875 return NSOrderedDescending;
1876 // second should be ordered higher
1877 if(second==compareContext->target())
1878 return NSOrderedAscending;
1879 return compareContext->CompareUsingOriginalOrdering(first,second);
1880 }
1881
1882 // Raise the window to the top of the Z order
1883 void wxWindow::Raise()
1884 {
1885 // wxAutoNSAutoreleasePool pool;
1886 NSView *nsview = GetNSViewForSuperview();
1887 NSView *superview = [nsview superview];
1888 CocoaWindowCompareContext compareContext(nsview, [superview subviews]);
1889
1890 [superview sortSubviewsUsingFunction:
1891 CocoaRaiseWindowCompareFunction
1892 context: &compareContext];
1893 }
1894
1895 /* Causes Cocoa to lower the target view to the bottom of the Z-Order by telling the sort function that
1896 * the target view is always lower than every other view. When comparing two views neither of
1897 * which is the target, it returns the correct response based on the original ordering
1898 */
1899 static CocoaWindowCompareFunctionResult CocoaLowerWindowCompareFunction(id first, id second, void *ctx)
1900 {
1901 CocoaWindowCompareContext *compareContext = (CocoaWindowCompareContext*)ctx;
1902 // first should be ordered lower
1903 if(first==compareContext->target())
1904 return NSOrderedAscending;
1905 // second should be ordered lower
1906 if(second==compareContext->target())
1907 return NSOrderedDescending;
1908 return compareContext->CompareUsingOriginalOrdering(first,second);
1909 }
1910
1911 // Lower the window to the bottom of the Z order
1912 void wxWindow::Lower()
1913 {
1914 NSView *nsview = GetNSViewForSuperview();
1915 NSView *superview = [nsview superview];
1916 CocoaWindowCompareContext compareContext(nsview, [superview subviews]);
1917
1918 #if 0
1919 NSLog(@"Target:\n%@\n", nsview);
1920 NSLog(@"Before:\n%@\n", compareContext.subviews());
1921 #endif
1922 [superview sortSubviewsUsingFunction:
1923 CocoaLowerWindowCompareFunction
1924 context: &compareContext];
1925 #if 0
1926 NSLog(@"After:\n%@\n", [superview subviews]);
1927 #endif
1928 }
1929
1930 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
1931 {
1932 return false;
1933 }
1934
1935 // Get the window with the focus
1936 wxWindow *wxWindowBase::DoFindFocus()
1937 {
1938 // Basically we are somewhat emulating the responder chain here except
1939 // we are only loking for the first responder in the key window or
1940 // upon failing to find one if the main window is different we look
1941 // for the first responder in the main window.
1942
1943 // Note that the firstResponder doesn't necessarily have to be an
1944 // NSView but wxCocoaNSView::GetFromCocoa() will simply return
1945 // NULL unless it finds its argument in its hash map.
1946
1947 wxCocoaNSView *win;
1948
1949 NSWindow *keyWindow = [[NSApplication sharedApplication] keyWindow];
1950 win = wxCocoaNSView::GetFromCocoa(static_cast<NSView*>([keyWindow firstResponder]));
1951 if(win)
1952 return win->GetWxWindow();
1953
1954 NSWindow *mainWindow = [[NSApplication sharedApplication] keyWindow];
1955 if(mainWindow == keyWindow)
1956 return NULL;
1957 win = wxCocoaNSView::GetFromCocoa(static_cast<NSView*>([mainWindow firstResponder]));
1958 if(win)
1959 return win->GetWxWindow();
1960
1961 return NULL;
1962 }
1963
1964 /* static */ wxWindow *wxWindowBase::GetCapture()
1965 {
1966 // TODO
1967 return wxWindowCocoa::sm_capturedWindow;
1968 }
1969
1970 wxWindow *wxGetActiveWindow()
1971 {
1972 // TODO
1973 return NULL;
1974 }
1975
1976 wxPoint wxGetMousePosition()
1977 {
1978 // TODO
1979 return wxDefaultPosition;
1980 }
1981
1982 wxMouseState wxGetMouseState()
1983 {
1984 wxMouseState ms;
1985 // TODO
1986 return ms;
1987 }
1988
1989 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1990 {
1991 pt = wxGetMousePosition();
1992 return NULL;
1993 }
1994
1995 // ========================================================================
1996 // wxCocoaMouseMovedEventSynthesizer
1997 // ========================================================================
1998
1999 #define wxTRACE_COCOA_MouseMovedSynthesizer wxT("COCOA_MouseMovedSynthesizer")
2000
2001 /* This class registers one run loop observer to cover all windows registered with it.
2002 * It will register the observer when the first view is registerd and unregister the
2003 * observer when the last view is unregistered.
2004 * It is instantiated as a static s_mouseMovedSynthesizer in this file although there
2005 * is no reason it couldn't be instantiated multiple times.
2006 */
2007 class wxCocoaMouseMovedEventSynthesizer
2008 {
2009 wxDECLARE_NO_COPY_CLASS(wxCocoaMouseMovedEventSynthesizer);
2010 public:
2011 wxCocoaMouseMovedEventSynthesizer()
2012 { m_lastScreenMouseLocation = NSZeroPoint;
2013 }
2014 ~wxCocoaMouseMovedEventSynthesizer();
2015 void RegisterWxCocoaView(wxCocoaNSView *aView);
2016 void UnregisterWxCocoaView(wxCocoaNSView *aView);
2017 void SynthesizeMouseMovedEvent();
2018
2019 protected:
2020 void AddRunLoopObserver();
2021 void RemoveRunLoopObserver();
2022 wxCFRef<CFRunLoopObserverRef> m_runLoopObserver;
2023 std::list<wxCocoaNSView*> m_registeredViews;
2024 NSPoint m_lastScreenMouseLocation;
2025 static void SynthesizeMouseMovedEvent(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info);
2026 };
2027
2028 void wxCocoaMouseMovedEventSynthesizer::RegisterWxCocoaView(wxCocoaNSView *aView)
2029 {
2030 m_registeredViews.push_back(aView);
2031 wxLogTrace(wxTRACE_COCOA_MouseMovedSynthesizer, wxT("Registered wxCocoaNSView=%p"), aView);
2032
2033 if(!m_registeredViews.empty() && m_runLoopObserver == NULL)
2034 {
2035 AddRunLoopObserver();
2036 }
2037 }
2038
2039 void wxCocoaMouseMovedEventSynthesizer::UnregisterWxCocoaView(wxCocoaNSView *aView)
2040 {
2041 m_registeredViews.remove(aView);
2042 wxLogTrace(wxTRACE_COCOA_MouseMovedSynthesizer, wxT("Unregistered wxCocoaNSView=%p"), aView);
2043 if(m_registeredViews.empty() && m_runLoopObserver != NULL)
2044 {
2045 RemoveRunLoopObserver();
2046 }
2047 }
2048
2049 wxCocoaMouseMovedEventSynthesizer::~wxCocoaMouseMovedEventSynthesizer()
2050 {
2051 if(!m_registeredViews.empty())
2052 {
2053 // This means failure to clean up so we report on it as a debug message.
2054 wxLogDebug(wxT("There are still %d wxCocoaNSView registered to receive mouse moved events at static destruction time"), m_registeredViews.size());
2055 m_registeredViews.clear();
2056 }
2057 if(m_runLoopObserver != NULL)
2058 {
2059 // This should not occur unless m_registeredViews was not empty since the last object unregistered should have done this.
2060 wxLogDebug(wxT("Removing run loop observer during static destruction time."));
2061 RemoveRunLoopObserver();
2062 }
2063 }
2064
2065 void wxCocoaMouseMovedEventSynthesizer::SynthesizeMouseMovedEvent(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info)
2066 {
2067 reinterpret_cast<wxCocoaMouseMovedEventSynthesizer*>(info)->SynthesizeMouseMovedEvent();
2068 }
2069
2070 void wxCocoaMouseMovedEventSynthesizer::AddRunLoopObserver()
2071 {
2072 CFRunLoopObserverContext observerContext =
2073 { 0
2074 , this
2075 , NULL
2076 , NULL
2077 , NULL
2078 };
2079
2080 // The kCFRunLoopExit observation point is used such that we hook the run loop after it has already decided that
2081 // it is going to exit which is generally for the purpose of letting the event loop process the next Cocoa event.
2082
2083 // Executing our procedure within the run loop (e.g. kCFRunLoopBeforeWaiting which was used before) results
2084 // in our observer procedure being called before the run loop has decided that it is going to return control to
2085 // the Cocoa event loop. One major problem is uncovered by the wxGenericHyperlinkCtrl (consider this to be "user
2086 // code") which changes the window's cursor and thus causes the cursor rectangle's to be invalidated.
2087
2088 // Cocoa implements this invalidation using a delayed notification scheme whereby the resetCursorRects method
2089 // won't be called until the CFRunLoop gets around to it. If the CFRunLoop has not yet exited then it will get
2090 // around to it before letting the event loop do its work. This has some very odd effects on the way the
2091 // newly created tracking rects function. In particular, we will often miss the mouseExited: message if the
2092 // user flicks the mouse quickly enough such that the mouse is already outside of the tracking rect by the
2093 // time the new one is built.
2094
2095 // Observing from the kCFRunLoopExit point gives Cocoa's event loop an opportunity to chew some events before it cedes
2096 // control back to the CFRunLoop, thus causing the delayed notifications to fire at an appropriate time and
2097 // the mouseExited: message to be sent properly.
2098
2099 m_runLoopObserver.reset(CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopExit, TRUE, 0, SynthesizeMouseMovedEvent, &observerContext));
2100 CFRunLoopAddObserver([[NSRunLoop currentRunLoop] getCFRunLoop], m_runLoopObserver, kCFRunLoopCommonModes);
2101 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("Added tracking rect run loop observer"));
2102 }
2103
2104 void wxCocoaMouseMovedEventSynthesizer::RemoveRunLoopObserver()
2105 {
2106 CFRunLoopRemoveObserver([[NSRunLoop currentRunLoop] getCFRunLoop], m_runLoopObserver, kCFRunLoopCommonModes);
2107 m_runLoopObserver.reset();
2108 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("Removed tracking rect run loop observer"));
2109 }
2110
2111 void wxCocoaMouseMovedEventSynthesizer::SynthesizeMouseMovedEvent()
2112 {
2113 NSPoint screenMouseLocation = [NSEvent mouseLocation];
2114 // Checking the last mouse location is done for a few reasons:
2115 // 1. We are observing every iteration of the event loop so we'd be sending out a lot of extraneous events
2116 // telling the app the mouse moved when the user hit a key for instance.
2117 // 2. When handling the mouse moved event, user code can do something to the view which will cause Cocoa to
2118 // call resetCursorRects. Cocoa does this by using a delayed notification which means the event loop gets
2119 // pumped once which would mean that if we didn't check the mouse location we'd get into a never-ending
2120 // loop causing the tracking rectangles to constantly be reset.
2121 if(screenMouseLocation.x != m_lastScreenMouseLocation.x || screenMouseLocation.y != m_lastScreenMouseLocation.y)
2122 {
2123 m_lastScreenMouseLocation = screenMouseLocation;
2124 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("Synthesizing mouse moved at screen (%f,%f)"), screenMouseLocation.x, screenMouseLocation.y);
2125 for(std::list<wxCocoaNSView*>::iterator i = m_registeredViews.begin(); i != m_registeredViews.end(); ++i)
2126 {
2127 (*i)->Cocoa_synthesizeMouseMoved();
2128 }
2129 }
2130 }
2131
2132 // Singleton used for all views:
2133 static wxCocoaMouseMovedEventSynthesizer s_mouseMovedSynthesizer;
2134
2135 // ========================================================================
2136 // wxCocoaTrackingRectManager
2137 // ========================================================================
2138
2139 wxCocoaTrackingRectManager::wxCocoaTrackingRectManager(wxWindow *window)
2140 : m_window(window)
2141 {
2142 m_isTrackingRectActive = false;
2143 BuildTrackingRect();
2144 }
2145
2146 void wxCocoaTrackingRectManager::ClearTrackingRect()
2147 {
2148 if(m_isTrackingRectActive)
2149 {
2150 [m_window->GetNSView() removeTrackingRect:m_trackingRectTag];
2151 m_isTrackingRectActive = false;
2152 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("%s@%p: Removed tracking rect #%d"), m_window->GetClassInfo()->GetClassName(), m_window, m_trackingRectTag);
2153 }
2154 // If we were doing periodic events we need to clear those too
2155 StopSynthesizingEvents();
2156 }
2157
2158 void wxCocoaTrackingRectManager::StopSynthesizingEvents()
2159 {
2160 s_mouseMovedSynthesizer.UnregisterWxCocoaView(m_window);
2161 }
2162
2163 void wxCocoaTrackingRectManager::BuildTrackingRect()
2164 {
2165 // Pool here due to lack of one during wx init phase
2166 wxAutoNSAutoreleasePool pool;
2167
2168 wxASSERT_MSG(!m_isTrackingRectActive, wxT("Tracking rect was not cleared"));
2169
2170 NSView *theView = m_window->GetNSView();
2171
2172 if([theView window] != nil)
2173 {
2174 NSRect visibleRect = [theView visibleRect];
2175
2176 m_trackingRectTag = [theView addTrackingRect:visibleRect owner:theView userData:NULL assumeInside:NO];
2177 m_trackingRectInWindowCoordinates = [theView convertRect:visibleRect toView:nil];
2178 m_isTrackingRectActive = true;
2179
2180 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("%s@%p: Added tracking rect #%d"), m_window->GetClassInfo()->GetClassName(), m_window, m_trackingRectTag);
2181 }
2182 }
2183
2184 void wxCocoaTrackingRectManager::BeginSynthesizingEvents()
2185 {
2186 s_mouseMovedSynthesizer.RegisterWxCocoaView(m_window);
2187 }
2188
2189 void wxCocoaTrackingRectManager::RebuildTrackingRectIfNeeded()
2190 {
2191 if(m_isTrackingRectActive)
2192 {
2193 NSView *theView = m_window->GetNSView();
2194 NSRect currentRect = [theView convertRect:[theView visibleRect] toView:nil];
2195 if(NSEqualRects(m_trackingRectInWindowCoordinates,currentRect))
2196 {
2197 wxLogTrace(wxTRACE_COCOA_TrackingRect, wxT("Ignored request to rebuild TR#%d"), m_trackingRectTag);
2198 return;
2199 }
2200 }
2201 RebuildTrackingRect();
2202 }
2203
2204 void wxCocoaTrackingRectManager::RebuildTrackingRect()
2205 {
2206 ClearTrackingRect();
2207 BuildTrackingRect();
2208 }
2209
2210 wxCocoaTrackingRectManager::~wxCocoaTrackingRectManager()
2211 {
2212 ClearTrackingRect();
2213 }
2214
2215 bool wxCocoaTrackingRectManager::IsOwnerOfEvent(NSEvent *anEvent)
2216 {
2217 return m_isTrackingRectActive && (m_trackingRectTag == [anEvent trackingNumber]);
2218 }
2219