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:     wxWidgets 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/utils.h"
  19 #endif //WX_PRECOMP
  20
  21 #include "wx/tooltip.h"
  22
  23 #include "wx/cocoa/autorelease.h"
  24 #include "wx/cocoa/string.h"
  25 #include "wx/cocoa/trackingrectmanager.h"
  26
  27 #import <Foundation/NSRunLoop.h>
  28 #include "wx/cocoa/objc/NSView.h"
  29 #import <AppKit/NSEvent.h>
  30 #import <AppKit/NSScrollView.h>
  31 #import <AppKit/NSColor.h>
  32 #import <AppKit/NSClipView.h>
  33 #import <Foundation/NSException.h>
  34 #import <AppKit/NSApplication.h>
  35 #import <AppKit/NSWindow.h>
  36
  37 // Turn this on to paint green over the dummy views for debugging
  38 #undef WXCOCOA_FILL_DUMMY_VIEW
  39
  40 #ifdef WXCOCOA_FILL_DUMMY_VIEW
  41 #import <AppKit/NSBezierPath.h>
  42 #endif //def WXCOCOA_FILL_DUMMY_VIEW
  43
  44 /* NSComparisonResult is typedef'd as an enum pre-Leopard but typedef'd as
  45  * NSInteger post-Leopard.  Pre-Leopard the Cocoa toolkit expects a function
  46  * returning int and not NSComparisonResult.  Post-Leopard the Cocoa toolkit
  47  * expects a function returning the new non-enum NSComparsionResult.
  48  * Hence we create a typedef named CocoaWindowCompareFunctionResult.
  49  */
  50 #if defined(NSINTEGER_DEFINED)
  51 typedef NSComparisonResult CocoaWindowCompareFunctionResult;
  52 #else
  53 typedef int CocoaWindowCompareFunctionResult;
  54 #endif
  55
  56 // A category for methods that are only present in Panther's SDK
  57 @interface NSView(wxNSViewPrePantherCompatibility)
  58 - (void)getRectsBeingDrawn:(const NSRect **)rects count:(int *)count;
  59 @end
  60
  61 NSPoint CocoaTransformNSViewBoundsToWx(NSView *nsview, NSPoint pointBounds)
  62 {
  63     wxCHECK_MSG(nsview, pointBounds, wxT("Need to have a Cocoa view to do translation"));
  64     if([nsview isFlipped])
  65         return pointBounds;
  66     NSRect ourBounds = [nsview bounds];
  67     return NSMakePoint
  68     (   pointBounds.x
  69     ,   ourBounds.size.height - pointBounds.y
  70     );
  71 }
  72
  73 NSRect CocoaTransformNSViewBoundsToWx(NSView *nsview, NSRect rectBounds)
  74 {
  75     wxCHECK_MSG(nsview, rectBounds, wxT("Need to have a Cocoa view to do translation"));
  76     if([nsview isFlipped])
  77         return rectBounds;
  78     NSRect ourBounds = [nsview bounds];
  79     return NSMakeRect
  80     (   rectBounds.origin.x
  81     ,   ourBounds.size.height - (rectBounds.origin.y + rectBounds.size.height)
  82     ,   rectBounds.size.width
  83     ,   rectBounds.size.height
  84     );
  85 }
  86
  87 NSPoint CocoaTransformNSViewWxToBounds(NSView *nsview, NSPoint pointWx)
  88 {
  89     wxCHECK_MSG(nsview, pointWx, wxT("Need to have a Cocoa view to do translation"));
  90     if([nsview isFlipped])
  91         return pointWx;
  92     NSRect ourBounds = [nsview bounds];
  93     return NSMakePoint
  94     (   pointWx.x
  95     ,   ourBounds.size.height - pointWx.y
  96     );
  97 }
  98
  99 NSRect CocoaTransformNSViewWxToBounds(NSView *nsview, NSRect rectWx)
 100 {
 101     wxCHECK_MSG(nsview, rectWx, wxT("Need to have a Cocoa view to do translation"));
 102     if([nsview isFlipped])
 103         return rectWx;
 104     NSRect ourBounds = [nsview bounds];
 105     return NSMakeRect
 106     (   rectWx.origin.x
 107     ,   ourBounds.size.height - (rectWx.origin.y + rectWx.size.height)
 108     ,   rectWx.size.width
 109     ,   rectWx.size.height
 110     );
 111 }
 112
 113 // ========================================================================
 114 // wxWindowCocoaHider
 115 // ========================================================================
 116 class wxWindowCocoaHider: protected wxCocoaNSView
 117 {
 118     DECLARE_NO_COPY_CLASS(wxWindowCocoaHider)
 119 public:
 120     wxWindowCocoaHider(wxWindow *owner);
 121     virtual ~wxWindowCocoaHider();
 122     inline WX_NSView GetNSView() { return m_dummyNSView; }
 123 protected:
 124     wxWindowCocoa *m_owner;
 125     WX_NSView m_dummyNSView;
 126     virtual void Cocoa_FrameChanged(void);
 127     virtual void Cocoa_synthesizeMouseMoved(void) {}
 128 #ifdef WXCOCOA_FILL_DUMMY_VIEW
 129     virtual bool Cocoa_drawRect(const NSRect& rect);
 130 #endif //def WXCOCOA_FILL_DUMMY_VIEW
 131 private:
 132     wxWindowCocoaHider();
 133 };
 134
 135 // ========================================================================
 136 // wxWindowCocoaScrollView
 137 // ========================================================================
 138 class wxWindowCocoaScrollView: protected wxCocoaNSView
 139 {
 140     DECLARE_NO_COPY_CLASS(wxWindowCocoaScrollView)
 141 public:
 142     wxWindowCocoaScrollView(wxWindow *owner);
 143     virtual ~wxWindowCocoaScrollView();
 144     inline WX_NSScrollView GetNSScrollView() { return m_cocoaNSScrollView; }
 145     void ClientSizeToSize(int &width, int &height);
 146     void DoGetClientSize(int *x, int *y) const;
 147     void Encapsulate();
 148     void Unencapsulate();
 149 protected:
 150     wxWindowCocoa *m_owner;
 151     WX_NSScrollView m_cocoaNSScrollView;
 152     virtual void Cocoa_FrameChanged(void);
 153     virtual void Cocoa_synthesizeMouseMoved(void) {}
 154 private:
 155     wxWindowCocoaScrollView();
 156 };
 157
 158 // ========================================================================
 159 // wxDummyNSView
 160 // ========================================================================
 161 @interface wxDummyNSView : NSView
 162 - (NSView *)hitTest:(NSPoint)aPoint;
 163 @end
 164 WX_DECLARE_GET_OBJC_CLASS(wxDummyNSView,NSView)
 165
 166 @implementation wxDummyNSView : NSView
 167 - (NSView *)hitTest:(NSPoint)aPoint
 168 {
 169     return nil;
 170 }
 171
 172 @end
 173 WX_IMPLEMENT_GET_OBJC_CLASS(wxDummyNSView,NSView)
 174
 175 // ========================================================================
 176 // wxWindowCocoaHider
 177 // ========================================================================
 178 wxWindowCocoaHider::wxWindowCocoaHider(wxWindow *owner)
 179 :   m_owner(owner)
 180 {
 181     wxASSERT(owner);
 182     wxASSERT(owner->GetNSViewForHiding());
 183     m_dummyNSView = [[WX_GET_OBJC_CLASS(wxDummyNSView) alloc]
 184         initWithFrame:[owner->GetNSViewForHiding() frame]];
 185     [m_dummyNSView setAutoresizingMask: [owner->GetNSViewForHiding() autoresizingMask]];
 186     AssociateNSView(m_dummyNSView);
 187 }
 188
 189 wxWindowCocoaHider::~wxWindowCocoaHider()
 190 {
 191     DisassociateNSView(m_dummyNSView);
 192     [m_dummyNSView release];
 193 }
 194
 195 void wxWindowCocoaHider::Cocoa_FrameChanged(void)
 196 {
 197     // Keep the real window in synch with the dummy
 198     wxASSERT(m_dummyNSView);
 199     [m_owner->GetNSViewForHiding() setFrame:[m_dummyNSView frame]];
 200 }
 201
 202
 203 #ifdef WXCOCOA_FILL_DUMMY_VIEW
 204 bool wxWindowCocoaHider::Cocoa_drawRect(const NSRect& rect)
 205 {
 206     NSBezierPath *bezpath = [NSBezierPath bezierPathWithRect:rect];
 207     [[NSColor greenColor] set];
 208     [bezpath stroke];
 209     [bezpath fill];
 210     return true;
 211 }
 212 #endif //def WXCOCOA_FILL_DUMMY_VIEW
 213
 214 // ========================================================================
 215 // wxFlippedNSClipView
 216 // ========================================================================
 217 @interface wxFlippedNSClipView : NSClipView
 218 - (BOOL)isFlipped;
 219 @end
 220 WX_DECLARE_GET_OBJC_CLASS(wxFlippedNSClipView,NSClipView)
 221
 222 @implementation wxFlippedNSClipView : NSClipView
 223 - (BOOL)isFlipped
 224 {
 225     return YES;
 226 }
 227
 228 @end
 229 WX_IMPLEMENT_GET_OBJC_CLASS(wxFlippedNSClipView,NSClipView)
 230
 231 // ========================================================================
 232 // wxWindowCocoaScrollView
 233 // ========================================================================
 234 wxWindowCocoaScrollView::wxWindowCocoaScrollView(wxWindow *owner)
 235 :   m_owner(owner)
 236 {
 237     wxAutoNSAutoreleasePool pool;
 238     wxASSERT(owner);
 239     wxASSERT(owner->GetNSView());
 240     m_cocoaNSScrollView = [[NSScrollView alloc]
 241         initWithFrame:[owner->GetNSView() frame]];
 242     AssociateNSView(m_cocoaNSScrollView);
 243
 244     /* Replace the default NSClipView with a flipped one.  This ensures
 245        scrolling is "pinned" to the top-left instead of bottom-right. */
 246     NSClipView *flippedClip = [[WX_GET_OBJC_CLASS(wxFlippedNSClipView) alloc]
 247         initWithFrame: [[m_cocoaNSScrollView contentView] frame]];
 248     [m_cocoaNSScrollView setContentView:flippedClip];
 249     [flippedClip release];
 250
 251     [m_cocoaNSScrollView setBackgroundColor: [NSColor windowBackgroundColor]];
 252     [m_cocoaNSScrollView setHasHorizontalScroller: YES];
 253     [m_cocoaNSScrollView setHasVerticalScroller: YES];
 254     Encapsulate();
 255 }
 256
 257 void wxWindowCocoaScrollView::Encapsulate()
 258 {
 259     // Set the scroll view autoresizingMask to match the current NSView
 260     [m_cocoaNSScrollView setAutoresizingMask: [m_owner->GetNSView() autoresizingMask]];
 261     [m_owner->GetNSView() setAutoresizingMask: NSViewNotSizable];
 262     // NOTE: replaceSubView will cause m_cocaNSView to be released
 263     // except when it hasn't been added into an NSView hierarchy in which
 264     // case it doesn't need to be and this should work out to a no-op
 265     m_owner->CocoaReplaceView(m_owner->GetNSView(), m_cocoaNSScrollView);
 266     // The NSView is still retained by owner
 267     [m_cocoaNSScrollView setDocumentView: m_owner->GetNSView()];
 268     // Now it's also retained by the NSScrollView
 269 }
 270
 271 void wxWindowCocoaScrollView::Unencapsulate()
 272 {
 273     [m_cocoaNSScrollView setDocumentView: nil];
 274     m_owner->CocoaReplaceView(m_cocoaNSScrollView, m_owner->GetNSView());
 275     if(![[m_owner->GetNSView() superview] isFlipped])
 276         [m_owner->GetNSView() setAutoresizingMask: NSViewMinYMargin];
 277 }
 278
 279 wxWindowCocoaScrollView::~wxWindowCocoaScrollView()
 280 {
 281     DisassociateNSView(m_cocoaNSScrollView);
 282     [m_cocoaNSScrollView release];
 283 }
 284
 285 void wxWindowCocoaScrollView::ClientSizeToSize(int &width, int &height)
 286 {
 287     NSSize frameSize = [NSScrollView
 288         frameSizeForContentSize: NSMakeSize(width,height)
 289         hasHorizontalScroller: [m_cocoaNSScrollView hasHorizontalScroller]
 290         hasVerticalScroller: [m_cocoaNSScrollView hasVerticalScroller]
 291         borderType: [m_cocoaNSScrollView borderType]];
 292     width = (int)frameSize.width;
 293     height = (int)frameSize.height;
 294 }
 295
 296 void wxWindowCocoaScrollView::DoGetClientSize(int *x, int *y) const
 297 {
 298     NSSize nssize = [m_cocoaNSScrollView contentSize];
 299     if(x)
 300         *x = (int)nssize.width;
 301     if(y)
 302         *y = (int)nssize.height;
 303 }
 304
 305 void wxWindowCocoaScrollView::Cocoa_FrameChanged(void)
 306 {
 307     wxLogTrace(wxTRACE_COCOA,wxT("Cocoa_FrameChanged"));
 308     wxSizeEvent event(m_owner->GetSize(), m_owner->GetId());
 309     event.SetEventObject(m_owner);
 310     m_owner->GetEventHandler()->ProcessEvent(event);
 311 }
 312
 313 // ========================================================================
 314 // wxWindowCocoa
 315 // ========================================================================
 316 // normally the base classes aren't included, but wxWindow is special
 317 #ifdef __WXUNIVERSAL__
 318 IMPLEMENT_ABSTRACT_CLASS(wxWindowCocoa, wxWindowBase)
 319 #else
 320 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 321 #endif
 322
 323 BEGIN_EVENT_TABLE(wxWindowCocoa, wxWindowBase)
 324 END_EVENT_TABLE()
 325
 326 wxWindow *wxWindowCocoa::sm_capturedWindow = NULL;
 327
 328 // Constructor
 329 void wxWindowCocoa::Init()
 330 {
 331     m_cocoaNSView = NULL;
 332     m_cocoaHider = NULL;
 333     m_wxCocoaScrollView = NULL;
 334     m_isBeingDeleted = false;
 335     m_isInPaint = false;
 336     m_visibleTrackingRectManager = NULL;
 337 }
 338
 339 // Constructor
 340 bool wxWindow::Create(wxWindow *parent, wxWindowID winid,
 341            const wxPoint& pos,
 342            const wxSize& size,
 343            long style,
 344            const wxString& name)
 345 {
 346     if(!CreateBase(parent,winid,pos,size,style,wxDefaultValidator,name))
 347         return false;
 348
 349     // TODO: create the window
 350     m_cocoaNSView = NULL;
 351     SetNSView([[WX_GET_OBJC_CLASS(WXNSView) alloc] initWithFrame: MakeDefaultNSRect(size)]);
 352     [m_cocoaNSView release];
 353
 354     if (m_parent)
 355     {
 356         m_parent->AddChild(this);
 357         m_parent->CocoaAddChild(this);
 358         SetInitialFrameRect(pos,size);
 359     }
 360
 361     return true;
 362 }
 363
 364 // Destructor
 365 wxWindow::~wxWindow()
 366 {
 367     wxAutoNSAutoreleasePool pool;
 368     DestroyChildren();
 369
 370     // Make sure our parent (in the wxWidgets sense) is our superview
 371     // before we go removing from it.
 372     if(m_parent && m_parent->GetNSView()==[GetNSViewForSuperview() superview])
 373         CocoaRemoveFromParent();
 374     delete m_cocoaHider;
 375     delete m_wxCocoaScrollView;
 376     if(m_cocoaNSView)
 377         SendDestroyEvent();
 378     SetNSView(NULL);
 379 }
 380
 381 void wxWindowCocoa::CocoaAddChild(wxWindowCocoa *child)
 382 {
 383     // Pool here due to lack of one during wx init phase
 384     wxAutoNSAutoreleasePool pool;
 385
 386     NSView *childView = child->GetNSViewForSuperview();
 387
 388     wxASSERT(childView);
 389     [m_cocoaNSView addSubview: childView];
 390     child->m_isShown = !m_cocoaHider;
 391 }
 392
 393 void wxWindowCocoa::CocoaRemoveFromParent(void)
 394 {
 395     [GetNSViewForSuperview() removeFromSuperview];
 396 }
 397
 398 void wxWindowCocoa::SetNSView(WX_NSView cocoaNSView)
 399 {
 400     // Clear the visible area tracking rect if we have one.
 401     delete m_visibleTrackingRectManager;
 402     m_visibleTrackingRectManager = NULL;
 403
 404     bool need_debug = cocoaNSView || m_cocoaNSView;
 405     if(need_debug) wxLogTrace(wxTRACE_COCOA_RetainRelease,wxT("wxWindowCocoa=%p::SetNSView [m_cocoaNSView=%p retainCount]=%d"),this,m_cocoaNSView,[m_cocoaNSView retainCount]);
 406     DisassociateNSView(m_cocoaNSView);
 407     [cocoaNSView retain];
 408     [m_cocoaNSView release];
 409     m_cocoaNSView = cocoaNSView;
 410     AssociateNSView(m_cocoaNSView);
 411     if(need_debug) wxLogTrace(wxTRACE_COCOA_RetainRelease,wxT("wxWindowCocoa=%p::SetNSView [cocoaNSView=%p retainCount]=%d"),this,cocoaNSView,[cocoaNSView retainCount]);
 412 }
 413
 414 WX_NSView wxWindowCocoa::GetNSViewForSuperview() const
 415 {
 416     return m_cocoaHider
 417         ?   m_cocoaHider->GetNSView()
 418         :   m_wxCocoaScrollView
 419             ?   m_wxCocoaScrollView->GetNSScrollView()
 420             :   m_cocoaNSView;
 421 }
 422
 423 WX_NSView wxWindowCocoa::GetNSViewForHiding() const
 424 {
 425     return m_wxCocoaScrollView
 426         ?   m_wxCocoaScrollView->GetNSScrollView()
 427         :   m_cocoaNSView;
 428 }
 429
 430 NSPoint wxWindowCocoa::CocoaTransformBoundsToWx(NSPoint pointBounds)
 431 {
 432     // TODO: Handle scrolling offset
 433     return CocoaTransformNSViewBoundsToWx(GetNSView(), pointBounds);
 434 }
 435
 436 NSRect wxWindowCocoa::CocoaTransformBoundsToWx(NSRect rectBounds)
 437 {
 438     // TODO: Handle scrolling offset
 439     return CocoaTransformNSViewBoundsToWx(GetNSView(), rectBounds);
 440 }
 441
 442 NSPoint wxWindowCocoa::CocoaTransformWxToBounds(NSPoint pointWx)
 443 {
 444     // TODO: Handle scrolling offset
 445     return CocoaTransformNSViewWxToBounds(GetNSView(), pointWx);
 446 }
 447
 448 NSRect wxWindowCocoa::CocoaTransformWxToBounds(NSRect rectWx)
 449 {
 450     // TODO: Handle scrolling offset
 451     return CocoaTransformNSViewWxToBounds(GetNSView(), rectWx);
 452 }
 453
 454 WX_NSAffineTransform wxWindowCocoa::CocoaGetWxToBoundsTransform()
 455 {
 456     // TODO: Handle scrolling offset
 457     NSAffineTransform *transform = wxDC::CocoaGetWxToBoundsTransform([GetNSView() isFlipped], [GetNSView() bounds].size.height);
 458     return transform;
 459 }
 460
 461 bool wxWindowCocoa::Cocoa_drawRect(const NSRect &rect)
 462 {
 463     wxLogTrace(wxTRACE_COCOA,wxT("Cocoa_drawRect"));
 464     // Recursion can happen if the event loop runs from within the paint
 465     // handler.  For instance, if an assertion dialog is shown.
 466     // FIXME: This seems less than ideal.
 467     if(m_isInPaint)
 468     {
 469         wxLogDebug(wxT("Paint event recursion!"));
 470         return false;
 471     }
 472     m_isInPaint = true;
 473
 474     // Set m_updateRegion
 475     const NSRect *rects = &rect; // The bounding box of the region
 476     NSInteger countRects = 1;
 477     // Try replacing the larger rectangle with a list of smaller ones:
 478     if ([GetNSView() respondsToSelector:@selector(getRectsBeingDrawn:count:)])
 479         [GetNSView() getRectsBeingDrawn:&rects count:&countRects];
 480
 481     NSRect *transformedRects = (NSRect*)malloc(sizeof(NSRect)*countRects);
 482     for(int i=0; i<countRects; i++)
 483     {
 484         transformedRects[i] = CocoaTransformBoundsToWx(rects[i]);
 485     }
 486     m_updateRegion = wxRegion(transformedRects,countRects);
 487     free(transformedRects);
 488
 489     wxPaintEvent event(m_windowId);
 490     event.SetEventObject(this);
 491     bool ret = GetEventHandler()->ProcessEvent(event);
 492     m_isInPaint = false;
 493     return ret;
 494 }
 495
 496 void wxWindowCocoa::InitMouseEvent(wxMouseEvent& event, WX_NSEvent cocoaEvent)
 497 {
 498     wxASSERT_MSG([m_cocoaNSView window]==[cocoaEvent window],wxT("Mouse event for different NSWindow"));
 499     // Mouse events happen at the NSWindow level so we need to convert
 500     // into our bounds coordinates then convert to wx coordinates.
 501     NSPoint cocoaPoint = [m_cocoaNSView convertPoint:[(NSEvent*)cocoaEvent locationInWindow] fromView:nil];
 502     NSPoint pointWx = CocoaTransformBoundsToWx(cocoaPoint);
 503     // FIXME: Should we be adjusting for client area origin?
 504     const wxPoint &clientorigin = GetClientAreaOrigin();
 505     event.m_x = (wxCoord)pointWx.x - clientorigin.x;
 506     event.m_y = (wxCoord)pointWx.y - clientorigin.y;
 507
 508     event.m_shiftDown = [cocoaEvent modifierFlags] & NSShiftKeyMask;
 509     event.m_controlDown = [cocoaEvent modifierFlags] & NSControlKeyMask;
 510     event.m_altDown = [cocoaEvent modifierFlags] & NSAlternateKeyMask;
 511     event.m_metaDown = [cocoaEvent modifierFlags] & NSCommandKeyMask;
 512
 513     // TODO: set timestamp?
 514     event.SetEventObject(this);
 515     event.SetId(GetId());
 516 }
 517
 518 bool wxWindowCocoa::Cocoa_mouseMoved(WX_NSEvent theEvent)
 519 {
 520     wxMouseEvent event(wxEVT_MOTION);
 521     InitMouseEvent(event,theEvent);
 522     wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_mouseMoved @%d,%d"),this,event.m_x,event.m_y);
 523     return GetEventHandler()->ProcessEvent(event);
 524 }
 525
 526 void wxWindowCocoa::Cocoa_synthesizeMouseMoved()
 527 {
 528     wxMouseEvent event(wxEVT_MOTION);
 529     NSWindow *window = [GetNSView() window];
 530     NSPoint locationInWindow = [window mouseLocationOutsideOfEventStream];
 531     NSPoint cocoaPoint = [m_cocoaNSView convertPoint:locationInWindow fromView:nil];
 532
 533     NSPoint pointWx = CocoaTransformBoundsToWx(cocoaPoint);
 534     // FIXME: Should we be adjusting for client area origin?
 535     const wxPoint &clientorigin = GetClientAreaOrigin();
 536     event.m_x = (wxCoord)pointWx.x - clientorigin.x;
 537     event.m_y = (wxCoord)pointWx.y - clientorigin.y;
 538
 539     // TODO: Handle shift, control, alt, meta flags
 540     event.SetEventObject(this);
 541     event.SetId(GetId());
 542
 543     wxLogTrace(wxTRACE_COCOA,wxT("wxwin=%p Synthesized Mouse Moved @%d,%d"),this,event.m_x,event.m_y);
 544     GetEventHandler()->ProcessEvent(event);
 545 }
 546
 547 bool wxWindowCocoa::Cocoa_mouseEntered(WX_NSEvent theEvent)
 548 {
 549     if(m_visibleTrackingRectManager != NULL && m_visibleTrackingRectManager->IsOwnerOfEvent(theEvent))
 550     {
 551         m_visibleTrackingRectManager->BeginSynthesizingEvents();
 552
 553         // Although we synthesize the mouse moved events we don't poll for them but rather send them only when
 554         // some other event comes in.  That other event is (guess what) mouse moved events that will be sent
 555         // to the NSWindow which will forward them on to the first responder.  We are not likely to be the
 556         // first responder, so the mouseMoved: events are effectively discarded.
 557         [[GetNSView() window] setAcceptsMouseMovedEvents:YES];
 558
 559         wxMouseEvent event(wxEVT_ENTER_WINDOW);
 560         InitMouseEvent(event,theEvent);
 561         wxLogTrace(wxTRACE_COCOA,wxT("wxwin=%p Mouse Entered @%d,%d"),this,event.m_x,event.m_y);
 562         return GetEventHandler()->ProcessEvent(event);
 563     }
 564     else
 565         return false;
 566 }
 567
 568 bool wxWindowCocoa::Cocoa_mouseExited(WX_NSEvent theEvent)
 569 {
 570     if(m_visibleTrackingRectManager != NULL && m_visibleTrackingRectManager->IsOwnerOfEvent(theEvent))
 571     {
 572         m_visibleTrackingRectManager->StopSynthesizingEvents();
 573
 574         wxMouseEvent event(wxEVT_LEAVE_WINDOW);
 575         InitMouseEvent(event,theEvent);
 576         wxLogTrace(wxTRACE_COCOA,wxT("wxwin=%p Mouse Exited @%d,%d"),this,event.m_x,event.m_y);
 577         return GetEventHandler()->ProcessEvent(event);
 578     }
 579     else
 580         return false;
 581 }
 582
 583 bool wxWindowCocoa::Cocoa_mouseDown(WX_NSEvent theEvent)
 584 {
 585     wxMouseEvent event([theEvent clickCount]<2?wxEVT_LEFT_DOWN:wxEVT_LEFT_DCLICK);
 586     InitMouseEvent(event,theEvent);
 587     wxLogTrace(wxTRACE_COCOA,wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
 588     return GetEventHandler()->ProcessEvent(event);
 589 }
 590
 591 bool wxWindowCocoa::Cocoa_mouseDragged(WX_NSEvent theEvent)
 592 {
 593     wxMouseEvent event(wxEVT_MOTION);
 594     InitMouseEvent(event,theEvent);
 595     event.m_leftDown = true;
 596     wxLogTrace(wxTRACE_COCOA,wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
 597     return GetEventHandler()->ProcessEvent(event);
 598 }
 599
 600 bool wxWindowCocoa::Cocoa_mouseUp(WX_NSEvent theEvent)
 601 {
 602     wxMouseEvent event(wxEVT_LEFT_UP);
 603     InitMouseEvent(event,theEvent);
 604     wxLogTrace(wxTRACE_COCOA,wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
 605     return GetEventHandler()->ProcessEvent(event);
 606 }
 607
 608 bool wxWindowCocoa::Cocoa_rightMouseDown(WX_NSEvent theEvent)
 609 {
 610     wxMouseEvent event([theEvent clickCount]<2?wxEVT_RIGHT_DOWN:wxEVT_RIGHT_DCLICK);
 611     InitMouseEvent(event,theEvent);
 612     wxLogDebug(wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
 613     return GetEventHandler()->ProcessEvent(event);
 614 }
 615
 616 bool wxWindowCocoa::Cocoa_rightMouseDragged(WX_NSEvent theEvent)
 617 {
 618     wxMouseEvent event(wxEVT_MOTION);
 619     InitMouseEvent(event,theEvent);
 620     event.m_rightDown = true;
 621     wxLogDebug(wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
 622     return GetEventHandler()->ProcessEvent(event);
 623 }
 624
 625 bool wxWindowCocoa::Cocoa_rightMouseUp(WX_NSEvent theEvent)
 626 {
 627     wxMouseEvent event(wxEVT_RIGHT_UP);
 628     InitMouseEvent(event,theEvent);
 629     wxLogDebug(wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
 630     return GetEventHandler()->ProcessEvent(event);
 631 }
 632
 633 bool wxWindowCocoa::Cocoa_otherMouseDown(WX_NSEvent theEvent)
 634 {
 635     return false;
 636 }
 637
 638 bool wxWindowCocoa::Cocoa_otherMouseDragged(WX_NSEvent theEvent)
 639 {
 640     return false;
 641 }
 642
 643 bool wxWindowCocoa::Cocoa_otherMouseUp(WX_NSEvent theEvent)
 644 {
 645     return false;
 646 }
 647
 648 void wxWindowCocoa::Cocoa_FrameChanged(void)
 649 {
 650     wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_FrameChanged"),this);
 651     if(m_visibleTrackingRectManager != NULL)
 652         m_visibleTrackingRectManager->RebuildTrackingRect();
 653     wxSizeEvent event(GetSize(), m_windowId);
 654     event.SetEventObject(this);
 655     GetEventHandler()->ProcessEvent(event);
 656 }
 657
 658 bool wxWindowCocoa::Cocoa_resetCursorRects()
 659 {
 660     wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_resetCursorRects"),this);
 661     if(m_visibleTrackingRectManager != NULL)
 662         m_visibleTrackingRectManager->RebuildTrackingRect();
 663
 664     if(!m_cursor.GetNSCursor())
 665         return false;
 666
 667     [GetNSView() addCursorRect: [GetNSView() visibleRect]  cursor: m_cursor.GetNSCursor()];
 668
 669     return true;
 670 }
 671
 672 bool wxWindowCocoa::Cocoa_viewDidMoveToWindow()
 673 {
 674     wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::viewDidMoveToWindow"),this);
 675     // Set up new tracking rects.  I am reasonably sure the new window must be set before doing this.
 676     if(m_visibleTrackingRectManager != NULL)
 677         m_visibleTrackingRectManager->BuildTrackingRect();
 678     return false;
 679 }
 680
 681 bool wxWindowCocoa::Cocoa_viewWillMoveToWindow(WX_NSWindow newWindow)
 682 {
 683     wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::viewWillMoveToWindow:%p"),this, newWindow);
 684     // Clear tracking rects.  It is imperative this be done before the new window is set.
 685     if(m_visibleTrackingRectManager != NULL)
 686         m_visibleTrackingRectManager->ClearTrackingRect();
 687     return false;
 688 }
 689
 690 bool wxWindow::Close(bool force)
 691 {
 692     // The only reason this function exists is that it is virtual and
 693     // wxTopLevelWindowCocoa will override it.
 694     return wxWindowBase::Close(force);
 695 }
 696
 697 void wxWindow::CocoaReplaceView(WX_NSView oldView, WX_NSView newView)
 698 {
 699     [[oldView superview] replaceSubview:oldView with:newView];
 700 }
 701
 702 void wxWindow::DoEnable(bool enable)
 703 {
 704         CocoaSetEnabled(enable);
 705 }
 706
 707 bool wxWindow::Show(bool show)
 708 {
 709     wxAutoNSAutoreleasePool pool;
 710     // If the window is marked as visible, then it shouldn't have a dummy view
 711     // If the window is marked hidden, then it should have a dummy view
 712     // wxSpinCtrl (generic) abuses m_isShown, don't use it for any logic
 713 //    wxASSERT_MSG( (m_isShown && !m_dummyNSView) || (!m_isShown && m_dummyNSView),wxT("wxWindow: m_isShown does not agree with m_dummyNSView"));
 714     // Return false if there isn't a window to show or hide
 715     NSView *cocoaView = GetNSViewForHiding();
 716     if(!cocoaView)
 717         return false;
 718     if(show)
 719     {
 720         // If state isn't changing, return false
 721         if(!m_cocoaHider)
 722             return false;
 723         CocoaReplaceView(m_cocoaHider->GetNSView(), cocoaView);
 724         wxASSERT(![m_cocoaHider->GetNSView() superview]);
 725         delete m_cocoaHider;
 726         m_cocoaHider = NULL;
 727         wxASSERT([cocoaView superview]);
 728     }
 729     else
 730     {
 731         // If state isn't changing, return false
 732         if(m_cocoaHider)
 733             return false;
 734         m_cocoaHider = new wxWindowCocoaHider(this);
 735         // NOTE: replaceSubview:with will cause m_cocaNSView to be
 736         // (auto)released which balances out addSubview
 737         CocoaReplaceView(cocoaView, m_cocoaHider->GetNSView());
 738         // m_coocaNSView is now only retained by us
 739         wxASSERT([m_cocoaHider->GetNSView() superview]);
 740         wxASSERT(![cocoaView superview]);
 741     }
 742     m_isShown = show;
 743     return true;
 744 }
 745
 746 void wxWindowCocoa::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 747 {
 748     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":".");
 749     int currentX, currentY;
 750     int currentW, currentH;
 751     DoGetPosition(&currentX, &currentY);
 752     DoGetSize(&currentW, &currentH);
 753     if((x==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
 754         x=currentX;
 755     if((y==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
 756         y=currentY;
 757
 758     AdjustForParentClientOrigin(x,y,sizeFlags);
 759
 760     wxSize size(wxDefaultSize);
 761
 762     if((width==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
 763     {
 764         if(sizeFlags&wxSIZE_AUTO_WIDTH)
 765         {
 766             size=DoGetBestSize();
 767             width=size.x;
 768         }
 769         else
 770             width=currentW;
 771     }
 772     if((height==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
 773     {
 774         if(sizeFlags&wxSIZE_AUTO_HEIGHT)
 775         {
 776             if(size.x==-1)
 777                 size=DoGetBestSize();
 778             height=size.y;
 779         }
 780         else
 781             height=currentH;
 782     }
 783     DoMoveWindow(x,y,width,height);
 784 }
 785
 786 #if wxUSE_TOOLTIPS
 787
 788 void wxWindowCocoa::DoSetToolTip( wxToolTip *tip )
 789 {
 790     wxWindowBase::DoSetToolTip(tip);
 791
 792     if ( m_tooltip )
 793     {
 794         m_tooltip->SetWindow((wxWindow *)this);
 795     }
 796 }
 797
 798 #endif
 799
 800 void wxWindowCocoa::DoMoveWindow(int x, int y, int width, int height)
 801 {
 802     wxAutoNSAutoreleasePool pool;
 803     wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoMoveWindow(%d,%d,%d,%d)"),this,x,y,width,height);
 804
 805     NSView *nsview = GetNSViewForSuperview();
 806     NSView *superview = [nsview superview];
 807
 808     wxCHECK_RET(GetParent(), wxT("Window can only be placed correctly when it has a parent"));
 809
 810     NSRect oldFrameRect = [nsview frame];
 811     NSRect newFrameRect = GetParent()->CocoaTransformWxToBounds(NSMakeRect(x,y,width,height));
 812     [nsview setFrame:newFrameRect];
 813     // Be sure to redraw the parent to reflect the changed position
 814     [superview setNeedsDisplayInRect:oldFrameRect];
 815     [superview setNeedsDisplayInRect:newFrameRect];
 816 }
 817
 818 void wxWindowCocoa::SetInitialFrameRect(const wxPoint& pos, const wxSize& size)
 819 {
 820     NSView *nsview = GetNSViewForSuperview();
 821     NSView *superview = [nsview superview];
 822     wxCHECK_RET(superview,wxT("NSView does not have a superview"));
 823     wxCHECK_RET(GetParent(), wxT("Window can only be placed correctly when it has a parent"));
 824     NSRect frameRect = [nsview frame];
 825     if(size.x!=-1)
 826         frameRect.size.width = size.x;
 827     if(size.y!=-1)
 828         frameRect.size.height = size.y;
 829     frameRect.origin.x = pos.x;
 830     frameRect.origin.y = pos.y;
 831     // Tell Cocoa to change the margin between the bottom of the superview
 832     // and the bottom of the control.  Keeps the control pinned to the top
 833     // of its superview so that its position in the wxWidgets coordinate
 834     // system doesn't change.
 835     if(![superview isFlipped])
 836         [nsview setAutoresizingMask: NSViewMinYMargin];
 837     // MUST set the mask before setFrame: which can generate a size event
 838     // and cause a scroller to be added!
 839     frameRect = GetParent()->CocoaTransformWxToBounds(frameRect);
 840     [nsview setFrame: frameRect];
 841 }
 842
 843 // Get total size
 844 void wxWindow::DoGetSize(int *w, int *h) const
 845 {
 846     NSRect cocoaRect = [GetNSViewForSuperview() frame];
 847     if(w)
 848         *w=(int)cocoaRect.size.width;
 849     if(h)
 850         *h=(int)cocoaRect.size.height;
 851     wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoGetSize = (%d,%d)"),this,(int)cocoaRect.size.width,(int)cocoaRect.size.height);
 852 }
 853
 854 void wxWindow::DoGetPosition(int *x, int *y) const
 855 {
 856     NSView *nsview = GetNSViewForSuperview();
 857
 858     NSRect cocoaRect = [nsview frame];
 859     NSRect rectWx = GetParent()->CocoaTransformBoundsToWx(cocoaRect);
 860     if(x)
 861         *x=(int)rectWx.origin.x;
 862     if(y)
 863         *y=(int)rectWx.origin.y;
 864     wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("wxWindow=%p::DoGetPosition = (%d,%d)"),this,(int)cocoaRect.origin.x,(int)cocoaRect.origin.y);
 865 }
 866
 867 WXWidget wxWindow::GetHandle() const
 868 {
 869     return m_cocoaNSView;
 870 }
 871
 872 wxWindow* wxWindow::GetWxWindow() const
 873 {
 874     return (wxWindow*) this;
 875 }
 876
 877 void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
 878 {
 879     [m_cocoaNSView setNeedsDisplay:YES];
 880 }
 881
 882 void wxWindow::SetFocus()
 883 {
 884     if([GetNSView() acceptsFirstResponder])
 885         [[GetNSView() window] makeFirstResponder: GetNSView()];
 886 }
 887
 888 void wxWindow::DoCaptureMouse()
 889 {
 890     // TODO
 891     sm_capturedWindow = this;
 892 }
 893
 894 void wxWindow::DoReleaseMouse()
 895 {
 896     // TODO
 897     sm_capturedWindow = NULL;
 898 }
 899
 900 void wxWindow::DoScreenToClient(int *x, int *y) const
 901 {
 902     // TODO
 903 }
 904
 905 void wxWindow::DoClientToScreen(int *x, int *y) const
 906 {
 907     // TODO
 908 }
 909
 910 // Get size *available for subwindows* i.e. excluding menu bar etc.
 911 void wxWindow::DoGetClientSize(int *x, int *y) const
 912 {
 913     wxLogTrace(wxTRACE_COCOA,wxT("DoGetClientSize:"));
 914     if(m_wxCocoaScrollView)
 915         m_wxCocoaScrollView->DoGetClientSize(x,y);
 916     else
 917         wxWindowCocoa::DoGetSize(x,y);
 918 }
 919
 920 void wxWindow::DoSetClientSize(int width, int height)
 921 {
 922     wxLogTrace(wxTRACE_COCOA_Window_Size,wxT("DoSetClientSize=(%d,%d)"),width,height);
 923     if(m_wxCocoaScrollView)
 924         m_wxCocoaScrollView->ClientSizeToSize(width,height);
 925     CocoaSetWxWindowSize(width,height);
 926 }
 927
 928 void wxWindow::CocoaSetWxWindowSize(int width, int height)
 929 {
 930     wxWindowCocoa::DoSetSize(wxDefaultCoord,wxDefaultCoord,width,height,wxSIZE_USE_EXISTING);
 931 }
 932
 933 void wxWindow::SetLabel(const wxString& WXUNUSED(label))
 934 {
 935     // Intentional no-op.
 936 }
 937
 938 wxString wxWindow::GetLabel() const
 939 {
 940     // General Get/Set of labels is implemented in wxControlBase
 941     wxLogDebug(wxT("wxWindow::GetLabel: Should be overridden if needed."));
 942     return wxEmptyString;
 943 }
 944
 945 int wxWindow::GetCharHeight() const
 946 {
 947     // TODO
 948     return 0;
 949 }
 950
 951 int wxWindow::GetCharWidth() const
 952 {
 953     // TODO
 954     return 0;
 955 }
 956
 957 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 958         int *descent, int *externalLeading, const wxFont *theFont) const
 959 {
 960     // TODO
 961 }
 962
 963 // Coordinates relative to the window
 964 void wxWindow::WarpPointer (int x_pos, int y_pos)
 965 {
 966     // TODO
 967 }
 968
 969 int wxWindow::GetScrollPos(int orient) const
 970 {
 971     // TODO
 972     return 0;
 973 }
 974
 975 // This now returns the whole range, not just the number
 976 // of positions that we can scroll.
 977 int wxWindow::GetScrollRange(int orient) const
 978 {
 979     // TODO
 980     return 0;
 981 }
 982
 983 int wxWindow::GetScrollThumb(int orient) const
 984 {
 985     // TODO
 986     return 0;
 987 }
 988
 989 void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
 990 {
 991     // TODO
 992 }
 993
 994 void wxWindow::CocoaCreateNSScrollView()
 995 {
 996     if(!m_wxCocoaScrollView)
 997     {
 998         m_wxCocoaScrollView = new wxWindowCocoaScrollView(this);
 999     }
1000 }
1001
1002 // New function that will replace some of the above.
1003 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
1004     int range, bool refresh)
1005 {
1006     CocoaCreateNSScrollView();
1007     // TODO
1008 }
1009
1010 // Does a physical scroll
1011 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
1012 {
1013     // TODO
1014 }
1015
1016 void wxWindow::DoSetVirtualSize( int x, int y )
1017 {
1018     wxWindowBase::DoSetVirtualSize(x,y);
1019     CocoaCreateNSScrollView();
1020     [m_cocoaNSView setFrameSize:NSMakeSize(m_virtualSize.x,m_virtualSize.y)];
1021 }
1022
1023 bool wxWindow::SetFont(const wxFont& font)
1024 {
1025     // TODO
1026     return true;
1027 }
1028
1029 #if 0 // these are used when debugging the algorithm.
1030 static char const * const comparisonresultStrings[] =
1031 {   "<"
1032 ,   "=="
1033 ,   ">"
1034 };
1035 #endif
1036
1037 class CocoaWindowCompareContext
1038 {
1039     DECLARE_NO_COPY_CLASS(CocoaWindowCompareContext)
1040 public:
1041     CocoaWindowCompareContext(); // Not implemented
1042     CocoaWindowCompareContext(NSView *target, NSArray *subviews)
1043     {
1044         m_target = target;
1045         // Cocoa sorts subviews in-place.. make a copy
1046         m_subviews = [subviews copy];
1047     }
1048     ~CocoaWindowCompareContext()
1049     {   // release the copy
1050         [m_subviews release];
1051     }
1052     NSView* target()
1053     {   return m_target; }
1054     NSArray* subviews()
1055     {   return m_subviews; }
1056     /* Helper function that returns the comparison based off of the original ordering */
1057     CocoaWindowCompareFunctionResult CompareUsingOriginalOrdering(id first, id second)
1058     {
1059         NSUInteger firstI = [m_subviews indexOfObjectIdenticalTo:first];
1060         NSUInteger secondI = [m_subviews indexOfObjectIdenticalTo:second];
1061         // NOTE: If either firstI or secondI is NSNotFound then it will be NSIntegerMax and thus will
1062         // likely compare higher than the other view which is reasonable considering the only way that
1063         // can happen is if the subview was added after our call to subviews but before the call to
1064         // sortSubviewsUsingFunction:context:.  Thus we don't bother checking.  Particularly because
1065         // that case should never occur anyway because that would imply a multi-threaded GUI call
1066         // which is a big no-no with Cocoa.
1067
1068         // Subviews are ordered from back to front meaning one that is already lower will have an lower index.
1069         NSComparisonResult result = (firstI < secondI)
1070             ?   NSOrderedAscending /* -1 */
1071             :   (firstI > secondI)
1072                 ?   NSOrderedDescending /* 1 */
1073                 :   NSOrderedSame /* 0 */;
1074
1075 #if 0 // Enable this if you need to debug the algorithm.
1076         NSLog(@"%@ [%d] %s %@ [%d]\n", first, firstI, comparisonresultStrings[result+1], second, secondI);
1077 #endif
1078         return result;
1079     }
1080 private:
1081     /* The subview we are trying to Raise or Lower */
1082     NSView *m_target;
1083     /* A copy of the original array of subviews */
1084     NSArray *m_subviews;
1085 };
1086
1087 /* Causes Cocoa to raise the target view to the top of the Z-Order by telling the sort function that
1088  * the target view is always higher than every other view.  When comparing two views neither of
1089  * which is the target, it returns the correct response based on the original ordering
1090  */
1091 static CocoaWindowCompareFunctionResult CocoaRaiseWindowCompareFunction(id first, id second, void *ctx)
1092 {
1093     CocoaWindowCompareContext *compareContext = (CocoaWindowCompareContext*)ctx;
1094     // first should be ordered higher
1095     if(first==compareContext->target())
1096         return NSOrderedDescending;
1097     // second should be ordered higher
1098     if(second==compareContext->target())
1099         return NSOrderedAscending;
1100     return compareContext->CompareUsingOriginalOrdering(first,second);
1101 }
1102
1103 // Raise the window to the top of the Z order
1104 void wxWindow::Raise()
1105 {
1106 //    wxAutoNSAutoreleasePool pool;
1107     NSView *nsview = GetNSViewForSuperview();
1108     NSView *superview = [nsview superview];
1109     CocoaWindowCompareContext compareContext(nsview, [superview subviews]);
1110
1111     [superview sortSubviewsUsingFunction:
1112             CocoaRaiseWindowCompareFunction
1113         context: &compareContext];
1114 }
1115
1116 /* Causes Cocoa to lower the target view to the bottom of the Z-Order by telling the sort function that
1117  * the target view is always lower than every other view.  When comparing two views neither of
1118  * which is the target, it returns the correct response based on the original ordering
1119  */
1120 static CocoaWindowCompareFunctionResult CocoaLowerWindowCompareFunction(id first, id second, void *ctx)
1121 {
1122     CocoaWindowCompareContext *compareContext = (CocoaWindowCompareContext*)ctx;
1123     // first should be ordered lower
1124     if(first==compareContext->target())
1125         return NSOrderedAscending;
1126     // second should be ordered lower
1127     if(second==compareContext->target())
1128         return NSOrderedDescending;
1129     return compareContext->CompareUsingOriginalOrdering(first,second);
1130 }
1131
1132 // Lower the window to the bottom of the Z order
1133 void wxWindow::Lower()
1134 {
1135     NSView *nsview = GetNSViewForSuperview();
1136     NSView *superview = [nsview superview];
1137     CocoaWindowCompareContext compareContext(nsview, [superview subviews]);
1138
1139 #if 0
1140     NSLog(@"Target:\n%@\n", nsview);
1141     NSLog(@"Before:\n%@\n", compareContext.subviews());
1142 #endif
1143     [superview sortSubviewsUsingFunction:
1144             CocoaLowerWindowCompareFunction
1145         context: &compareContext];
1146 #if 0
1147     NSLog(@"After:\n%@\n", [superview subviews]);
1148 #endif
1149 }
1150
1151 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
1152 {
1153     return false;
1154 }
1155
1156 // Get the window with the focus
1157 wxWindow *wxWindowBase::DoFindFocus()
1158 {
1159     // Basically we are somewhat emulating the responder chain here except
1160     // we are only loking for the first responder in the key window or
1161     // upon failing to find one if the main window is different we look
1162     // for the first responder in the main window.
1163
1164     // Note that the firstResponder doesn't necessarily have to be an
1165     // NSView but wxCocoaNSView::GetFromCocoa() will simply return
1166     // NULL unless it finds its argument in its hash map.
1167
1168     wxCocoaNSView *win;
1169
1170     NSWindow *keyWindow = [[NSApplication sharedApplication] keyWindow];
1171     win = wxCocoaNSView::GetFromCocoa(static_cast<NSView*>([keyWindow firstResponder]));
1172     if(win)
1173         return win->GetWxWindow();
1174
1175     NSWindow *mainWindow = [[NSApplication sharedApplication] keyWindow];
1176     if(mainWindow == keyWindow)
1177         return NULL;
1178     win = wxCocoaNSView::GetFromCocoa(static_cast<NSView*>([mainWindow firstResponder]));
1179     if(win)
1180         return win->GetWxWindow();
1181
1182     return NULL;
1183 }
1184
1185 /* static */ wxWindow *wxWindowBase::GetCapture()
1186 {
1187     // TODO
1188     return wxWindowCocoa::sm_capturedWindow;
1189 }
1190
1191 wxWindow *wxGetActiveWindow()
1192 {
1193     // TODO
1194     return NULL;
1195 }
1196
1197 wxPoint wxGetMousePosition()
1198 {
1199     // TODO
1200     return wxDefaultPosition;
1201 }
1202
1203 wxMouseState wxGetMouseState()
1204 {
1205     wxMouseState ms;
1206     // TODO
1207     return ms;
1208 }
1209
1210 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1211 {
1212     pt = wxGetMousePosition();
1213     return NULL;
1214 }
1215
1216
1217 // ========================================================================
1218 // wxCocoaTrackingRectManager
1219 // ========================================================================
1220
1221 wxCocoaTrackingRectManager::wxCocoaTrackingRectManager(wxWindow *window)
1222 :   m_window(window)
1223 {
1224     m_isTrackingRectActive = false;
1225     m_runLoopObserver = NULL;
1226     BuildTrackingRect();
1227 }
1228
1229 void wxCocoaTrackingRectManager::ClearTrackingRect()
1230 {
1231     if(m_isTrackingRectActive)
1232     {
1233         [m_window->GetNSView() removeTrackingRect:m_trackingRectTag];
1234         m_isTrackingRectActive = false;
1235     }
1236     // If we were doing periodic events we need to clear those too
1237     StopSynthesizingEvents();
1238 }
1239
1240 void wxCocoaTrackingRectManager::StopSynthesizingEvents()
1241 {
1242     if(m_runLoopObserver != NULL)
1243     {
1244         CFRunLoopRemoveObserver([[NSRunLoop currentRunLoop] getCFRunLoop], m_runLoopObserver, kCFRunLoopCommonModes);
1245         CFRelease(m_runLoopObserver);
1246         m_runLoopObserver = NULL;
1247     }
1248 }
1249
1250 void wxCocoaTrackingRectManager::BuildTrackingRect()
1251 {
1252     // Pool here due to lack of one during wx init phase
1253     wxAutoNSAutoreleasePool pool;
1254
1255     wxASSERT_MSG(!m_isTrackingRectActive, wxT("Tracking rect was not cleared"));
1256     if([m_window->GetNSView() window] != nil)
1257     {
1258         m_trackingRectTag = [m_window->GetNSView() addTrackingRect:[m_window->GetNSView() visibleRect] owner:m_window->GetNSView() userData:NULL assumeInside:NO];
1259         m_isTrackingRectActive = true;
1260     }
1261 }
1262
1263 static NSPoint s_lastScreenMouseLocation = NSZeroPoint;
1264
1265 static void SynthesizeMouseMovedEvent(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info)
1266 {
1267     NSPoint screenMouseLocation = [NSEvent mouseLocation];
1268     if(screenMouseLocation.x != s_lastScreenMouseLocation.x || screenMouseLocation.y != s_lastScreenMouseLocation.y)
1269     {
1270         wxCocoaNSView *win = reinterpret_cast<wxCocoaNSView*>(info);
1271         win->Cocoa_synthesizeMouseMoved();
1272     }
1273 }
1274
1275 void wxCocoaTrackingRectManager::BeginSynthesizingEvents()
1276 {
1277     CFRunLoopObserverContext observerContext =
1278     {   0
1279     ,   static_cast<wxCocoaNSView*>(m_window)
1280     ,   NULL
1281     ,   NULL
1282     ,   NULL
1283     };
1284     m_runLoopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopBeforeWaiting, TRUE, 0, SynthesizeMouseMovedEvent, &observerContext);
1285     CFRunLoopAddObserver([[NSRunLoop currentRunLoop] getCFRunLoop], m_runLoopObserver, kCFRunLoopCommonModes);
1286 }
1287
1288 void wxCocoaTrackingRectManager::RebuildTrackingRect()
1289 {
1290     ClearTrackingRect();
1291     BuildTrackingRect();
1292 }
1293
1294 wxCocoaTrackingRectManager::~wxCocoaTrackingRectManager()
1295 {
1296     ClearTrackingRect();
1297 }
1298
1299 bool wxCocoaTrackingRectManager::IsOwnerOfEvent(NSEvent *anEvent)
1300 {
1301     return m_isTrackingRectActive && (m_trackingRectTag == [anEvent trackingNumber]);
1302 }
1303