Support for resizing windows on all sides

AppKit/CPWindow/CPWindow.j

@@ -186,6 +186,11 @@ CPWindowShadowStyleStandard = 0;
 CPWindowShadowStyleMenu     = 1;
 CPWindowShadowStylePanel    = 2;
 
+CPWindowResizeStyleModern = 0;
+CPWindowResizeStyleLegacy = 1;
+CPWindowResizeStyle = CPWindowResizeStyleModern;
+CPWindowResizeSlop = 5;
+
 var SHADOW_MARGIN_LEFT      = 20.0,
     SHADOW_MARGIN_RIGHT     = 19.0,
     SHADOW_MARGIN_TOP       = 10.0,
@@ -197,7 +202,8 @@ var SHADOW_MARGIN_LEFT      = 20.0,
 var CPWindowSaveImage       = nil,
     CPWindowSavingImage     = nil,
 
-    CPWindowResizeTime      = 0.2;
+    CPWindowResizeTime      = 0.2,
+    CPWindowResizeStyleGlobalChangeNotification = @"CPWindowResizeStyleGlobalChangeNotification";
 
 /*
     Keys for which action messages will be sent by default when unhandled, e.g. complete:.
@@ -477,6 +483,11 @@ CPTexturedBackgroundWindowMask
         _keyViewLoopIsDirty = YES;
 
         [self setShowsResizeIndicator:_styleMask & CPResizableWindowMask];
+
+        [[CPNotificationCenter defaultCenter] addObserver:self
+                                 selector:@selector(_didReceiveResizeStyleChange:)
+                                     name:CPWindowResizeStyleGlobalChangeNotification
+                                   object:nil];
     }
 
     return self;
@@ -996,6 +1007,33 @@ CPTexturedBackgroundWindowMask
     return _isVisible;
 }
 
+/*!
+    Globally sets whether windows resize following the legacy style (using a resize thumb
+    in the bottom right corner), or the modern style (no resize thumb, resizing
+    can be done on all edges).
+*/
++ (void)setGlobalResizeStyle:(int)aStyle
+{
+    if (CPWindowResizeStyle === aStyle)
+        return;
+
+    CPWindowResizeStyle = aStyle;
+    [[CPNotificationCenter defaultCenter] postNotificationName:CPWindowResizeStyleGlobalChangeNotification object:nil];
+}
+
+- (void)_didReceiveResizeStyleChange:(CPNotification)aNotification
+{
+    [_windowView setShowsResizeIndicator:_styleMask & CPResizableWindowMask];
+}
+
+/*!
+    Returns the global window resizing style.
+*/
++ (int)globalResizeStyle
+{
+    return CPWindowResizeStyle;
+}
+
 /*!
     Returns \c YES if the window's resize indicator is showing. \c NO otherwise.
 */
@@ -1642,6 +1680,7 @@ CPTexturedBackgroundWindowMask
     // CPLeftMouseDown is needed for window moving and resizing to work.
     // CPMouseMoved is needed for rollover effects on title bar buttons.
     var sheet = [self attachedSheet];
+
     if (sheet)
     {
         switch (type)
@@ -1663,162 +1702,173 @@ CPTexturedBackgroundWindowMask
 
     switch (type)
     {
-        case CPFlagsChanged:        return [[self firstResponder] flagsChanged:anEvent];
+        case CPFlagsChanged:
+            return [[self firstResponder] flagsChanged:anEvent];
 
-        case CPKeyUp:               return [[self firstResponder] keyUp:anEvent];
+        case CPKeyUp:
+            return [[self firstResponder] keyUp:anEvent];
 
-        case CPKeyDown:             if ([anEvent charactersIgnoringModifiers] === CPTabCharacter)
-                                    {
-                                        if ([anEvent modifierFlags] & CPShiftKeyMask)
-                                            [self selectPreviousKeyView:self];
-                                        else
-                                            [self selectNextKeyView:self];
+        case CPKeyDown:
+            if ([anEvent charactersIgnoringModifiers] === CPTabCharacter)
+            {
+                if ([anEvent modifierFlags] & CPShiftKeyMask)
+                    [self selectPreviousKeyView:self];
+                else
+                    [self selectNextKeyView:self];
 #if PLATFORM(DOM)
-                                        // Make sure the browser doesn't try to do its own tab handling.
-                                        // This is important or the browser might blur the shared text field or token field input field,
-                                        // even that we just moved it to a new first responder.
-                                        [[[anEvent window] platformWindow] _propagateCurrentDOMEvent:NO]
+                // Make sure the browser doesn't try to do its own tab handling.
+                // This is important or the browser might blur the shared text field or token field input field,
+                // even that we just moved it to a new first responder.
+                [[[anEvent window] platformWindow] _propagateCurrentDOMEvent:NO]
 #endif
-                                        return;
-                                    }
-                                    else if ([anEvent charactersIgnoringModifiers] === CPBackTabCharacter)
-                                    {
-                                        var didTabBack = [self selectPreviousKeyView:self];
-                                        if (didTabBack)
-                                        {
+                return;
+            }
+            else if ([anEvent charactersIgnoringModifiers] === CPBackTabCharacter)
+            {
+                var didTabBack = [self selectPreviousKeyView:self];
+
+                if (didTabBack)
+                {
 #if PLATFORM(DOM)
-                                            // Make sure the browser doesn't try to do its own tab handling.
-                                            // This is important or the browser might blur the shared text field or token field input field,
-                                            // even that we just moved it to a new first responder.
-                                            [[[anEvent window] platformWindow] _propagateCurrentDOMEvent:NO]
+                    // Make sure the browser doesn't try to do its own tab handling.
+                    // This is important or the browser might blur the shared text field or token field input field,
+                    // even that we just moved it to a new first responder.
+                    [[[anEvent window] platformWindow] _propagateCurrentDOMEvent:NO]
 #endif
-                                        }
+                }
 
-                                        return didTabBack;
-                                    }
+                return didTabBack;
+            }
 
-                                    [[self firstResponder] keyDown:anEvent];
+            [[self firstResponder] keyDown:anEvent];
 
-                                    // Trigger the default button if needed
-                                    // FIXME: Is this only applicable in a sheet? See isse: #722.
-                                    if (![self disableKeyEquivalentForDefaultButton])
-                                    {
-                                        var defaultButton = [self defaultButton],
-                                            keyEquivalent = [defaultButton keyEquivalent],
-                                            modifierMask = [defaultButton keyEquivalentModifierMask];
+            // Trigger the default button if needed
+            // FIXME: Is this only applicable in a sheet? See isse: #722.
+            if (![self disableKeyEquivalentForDefaultButton])
+            {
+                var defaultButton = [self defaultButton],
+                    keyEquivalent = [defaultButton keyEquivalent],
+                    modifierMask = [defaultButton keyEquivalentModifierMask];
 
-                                        if ([anEvent _triggersKeyEquivalent:keyEquivalent withModifierMask:modifierMask])
-                                            [[self defaultButton] performClick:self];
-                                    }
+                if ([anEvent _triggersKeyEquivalent:keyEquivalent withModifierMask:modifierMask])
+                    [[self defaultButton] performClick:self];
+            }
 
-                                    return;
+            return;
 
-        case CPScrollWheel:         return [[_windowView hitTest:point] scrollWheel:anEvent];
+        case CPScrollWheel:
+            return [[_windowView hitTest:point] scrollWheel:anEvent];
 
         case CPLeftMouseUp:
-        case CPRightMouseUp:        var hitTestedView = _leftMouseDownView,
-                                        selector = type == CPRightMouseUp ? @selector(rightMouseUp:) : @selector(mouseUp:);
+        case CPRightMouseUp:
+            var hitTestedView = _leftMouseDownView,
+                selector = type == CPRightMouseUp ? @selector(rightMouseUp:) : @selector(mouseUp:);
 
-                                    if (!hitTestedView)
-                                        hitTestedView = [_windowView hitTest:point];
+            if (!hitTestedView)
+                hitTestedView = [_windowView hitTest:point];
 
-                                    [hitTestedView performSelector:selector withObject:anEvent];
+            [hitTestedView performSelector:selector withObject:anEvent];
 
-                                    _leftMouseDownView = nil;
+            _leftMouseDownView = nil;
+
+            return;
 
-                                    return;
         case CPLeftMouseDown:
-        case CPRightMouseDown:      _leftMouseDownView = [_windowView hitTest:point];
+        case CPRightMouseDown:
+            _leftMouseDownView = [_windowView hitTest:point] || _windowView;
 
-                                    if (_leftMouseDownView != _firstResponder && [_leftMouseDownView acceptsFirstResponder])
-                                        [self makeFirstResponder:_leftMouseDownView];
+            if (_leftMouseDownView != _firstResponder && [_leftMouseDownView acceptsFirstResponder])
+                [self makeFirstResponder:_leftMouseDownView];
 
-                                    [CPApp activateIgnoringOtherApps:YES];
+            [CPApp activateIgnoringOtherApps:YES];
 
-                                    var theWindow = [anEvent window],
-                                        selector = type == CPRightMouseDown ? @selector(rightMouseDown:) : @selector(mouseDown:);
+            var theWindow = [anEvent window],
+                selector = type == CPRightMouseDown ? @selector(rightMouseDown:) : @selector(mouseDown:);
 
-                                    if ([theWindow isKeyWindow] || [theWindow becomesKeyOnlyIfNeeded] && ![_leftMouseDownView needsPanelToBecomeKey])
-                                        return [_leftMouseDownView performSelector:selector withObject:anEvent];
-                                    else
-                                    {
-                                        // FIXME: delayed ordering?
-                                        [self makeKeyAndOrderFront:self];
+            if ([theWindow isKeyWindow] || [theWindow becomesKeyOnlyIfNeeded] && ![_leftMouseDownView needsPanelToBecomeKey])
+                return [_leftMouseDownView performSelector:selector withObject:anEvent];
+            else
+            {
+                // FIXME: delayed ordering?
+                [self makeKeyAndOrderFront:self];
 
-                                        if ([_leftMouseDownView acceptsFirstMouse:anEvent])
-                                            return [_leftMouseDownView performSelector:selector withObject:anEvent];
-                                    }
-                                    break;
+                if ([_leftMouseDownView acceptsFirstMouse:anEvent])
+                    return [_leftMouseDownView performSelector:selector withObject:anEvent];
+            }
+            break;
 
         case CPLeftMouseDragged:
-        case CPRightMouseDragged:   if (!_leftMouseDownView)
-                                        return [[_windowView hitTest:point] mouseDragged:anEvent];
+        case CPRightMouseDragged:
+            if (!_leftMouseDownView)
+                return [[_windowView hitTest:point] mouseDragged:anEvent];
 
-                                    var selector;
-                                    if (type == CPRightMouseDragged)
-                                    {
-                                        selector = @selector(rightMouseDragged:)
-                                        if (![_leftMouseDownView respondsToSelector:selector])
-                                            selector = nil;
-                                    }
+            var selector;
 
-                                    if (!selector)
-                                        selector = @selector(mouseDragged:)
+            if (type == CPRightMouseDragged)
+            {
+                selector = @selector(rightMouseDragged:)
+                if (![_leftMouseDownView respondsToSelector:selector])
+                    selector = nil;
+            }
 
-                                    return [_leftMouseDownView performSelector:selector withObject:anEvent];
+            if (!selector)
+                selector = @selector(mouseDragged:)
 
-        case CPMouseMoved:          if (!_acceptsMouseMovedEvents)
-                                        return;
+            return [_leftMouseDownView performSelector:selector withObject:anEvent];
 
-                                    if (!_mouseEnteredStack)
-                                        _mouseEnteredStack = [];
+        case CPMouseMoved:
+            if (!_acceptsMouseMovedEvents)
+                return;
 
-                                    var hitTestView = [_windowView hitTest:point];
+            if (!_mouseEnteredStack)
+                _mouseEnteredStack = [];
 
-                                    if ([_mouseEnteredStack count] && [_mouseEnteredStack lastObject] === hitTestView)
-                                        return [hitTestView mouseMoved:anEvent];
+            var hitTestView = [_windowView hitTest:point];
 
-                                    var view = hitTestView,
-                                        mouseEnteredStack = [];
+            if ([_mouseEnteredStack count] && [_mouseEnteredStack lastObject] === hitTestView)
+                return [hitTestView mouseMoved:anEvent];
 
-                                    while (view)
-                                    {
-                                        mouseEnteredStack.unshift(view);
+            var view = hitTestView,
+                mouseEnteredStack = [];
 
-                                        view = [view superview];
-                                    }
+            while (view)
+            {
+                mouseEnteredStack.unshift(view);
 
-                                    var deviation = MIN(_mouseEnteredStack.length, mouseEnteredStack.length);
+                view = [view superview];
+            }
 
-                                    while (deviation--)
-                                        if (_mouseEnteredStack[deviation] === mouseEnteredStack[deviation])
-                                            break;
+            var deviation = MIN(_mouseEnteredStack.length, mouseEnteredStack.length);
 
-                                    var index = deviation + 1,
-                                        count = _mouseEnteredStack.length;
+            while (deviation--)
+                if (_mouseEnteredStack[deviation] === mouseEnteredStack[deviation])
+                    break;
 
-                                    if (index < count)
-                                    {
-                                        var event = [CPEvent mouseEventWithType:CPMouseExited location:point modifierFlags:[anEvent modifierFlags] timestamp:[anEvent timestamp] windowNumber:_windowNumber context:nil eventNumber:-1 clickCount:1 pressure:0];
+            var index = deviation + 1,
+                count = _mouseEnteredStack.length;
 
-                                        for (; index < count; ++index)
-                                            [_mouseEnteredStack[index] mouseExited:event];
-                                    }
+            if (index < count)
+            {
+                var event = [CPEvent mouseEventWithType:CPMouseExited location:point modifierFlags:[anEvent modifierFlags] timestamp:[anEvent timestamp] windowNumber:_windowNumber context:nil eventNumber:-1 clickCount:1 pressure:0];
 
-                                    index = deviation + 1;
-                                    count = mouseEnteredStack.length;
+                for (; index < count; ++index)
+                    [_mouseEnteredStack[index] mouseExited:event];
+            }
 
-                                    if (index < count)
-                                    {
-                                        var event = [CPEvent mouseEventWithType:CPMouseEntered location:point modifierFlags:[anEvent modifierFlags] timestamp:[anEvent timestamp] windowNumber:_windowNumber context:nil eventNumber:-1 clickCount:1 pressure:0];
+            index = deviation + 1;
+            count = mouseEnteredStack.length;
 
-                                        for (; index < count; ++index)
-                                            [mouseEnteredStack[index] mouseEntered:event];
-                                    }
+            if (index < count)
+            {
+                var event = [CPEvent mouseEventWithType:CPMouseEntered location:point modifierFlags:[anEvent modifierFlags] timestamp:[anEvent timestamp] windowNumber:_windowNumber context:nil eventNumber:-1 clickCount:1 pressure:0];
 
-                                    _mouseEnteredStack = mouseEnteredStack;
+                for (; index < count; ++index)
+                    [mouseEnteredStack[index] mouseEntered:event];
+            }
 
-                                    [hitTestView mouseMoved:anEvent];
+            _mouseEnteredStack = mouseEnteredStack;
+
+            [hitTestView mouseMoved:anEvent];
     }
 }
 
@@ -2158,6 +2208,7 @@ CPTexturedBackgroundWindowMask
         return;
 
     var documents = [_windowController documents];
+
     if ([documents count])
     {
         var index = [documents indexOfObject:[_windowController document]];
@@ -3229,6 +3280,15 @@ var keyViewComparator = function(lhs, rhs, context)
     return CGRectContainsPoint(_frame, aPoint);
 }
 
+- (BOOL)_isValidMousePoint:(CGPoint)aPoint
+{
+    // If we are using the new resizing mode, mouse events are valid
+    // outside the window's frame.
+    var mouseFrame = ((_styleMask & CPResizableWindowMask) && (CPWindowResizeStyle === CPWindowResizeStyleModern)) ? _CGRectInset(_frame, -CPWindowResizeSlop, -CPWindowResizeSlop) : _frame;
+
+    return CGRectContainsPoint(mouseFrame, aPoint);
+}
+
 @end
 
 @implementation CPWindow (Deprecated)

AppKit/CPWindow/_CPStandardWindowView.j

@@ -334,13 +334,13 @@ var STANDARD_GRADIENT_HEIGHT                    = 41.0;
     [self _updateCloseButton];
 }
 
-- (void)mouseDown:(CPEvent)anEvent
+- (BOOL)couldBeMoveEvent:(CPEvent)anEvent
 {
     if (![_headView isHidden])
         if (CGRectContainsPoint([_headView frame], [self convertPoint:[anEvent locationInWindow] fromView:nil]))
-            return [self trackMoveWithEvent:anEvent];
+            return YES;
 
-    [super mouseDown:anEvent];
+    return [super couldBeMoveEvent:anEvent];
 }
 
 - (void)_enableSheet:(BOOL)enable

AppKit/CPWindow/_CPWindowView.j

@@ -24,7 +24,18 @@
 @import "CPView.j"
 
 
-var _CPWindowViewResizeIndicatorImage = nil;
+var _CPWindowViewResizeIndicatorImage = nil,
+    _CPWindowViewCornerResizeRectWidth = 10,
+
+    _CPWindowViewResizeRegionNone = -1,
+    _CPWindowViewResizeRegionTopLeft = 0,
+    _CPWindowViewResizeRegionTop = 1,
+    _CPWindowViewResizeRegionTopRight = 2,
+    _CPWindowViewResizeRegionRight = 3,
+    _CPWindowViewResizeRegionBottomRight = 4,
+    _CPWindowViewResizeRegionBottom = 5,
+    _CPWindowViewResizeRegionBottomLeft = 6,
+    _CPWindowViewResizeRegionLeft = 7;
 
 @implementation _CPWindowView : CPView
 {
@@ -38,6 +49,7 @@ var _CPWindowViewResizeIndicatorImage = nil;
 //    BOOL        _isAnimatingToolbar;
 
     CGRect      _resizeFrame;
+    int         _resizeRegion;
     CGPoint     _mouseDraggedPoint;
 
     CGRect      _cachedScreenFrame;
@@ -50,17 +62,17 @@ var _CPWindowViewResizeIndicatorImage = nil;
     if (self !== [_CPWindowView class])
         return;
 
-    _CPWindowViewResizeIndicatorImage = [[CPImage alloc] initWithContentsOfFile:[[CPBundle bundleForClass:[CPWindow class]] pathForResource:@"_CPWindowView/_CPWindowViewResizeIndicator.png"] size:CGSizeMake(12.0, 12.0)];
+    _CPWindowViewResizeIndicatorImage = [[CPImage alloc] initWithContentsOfFile:[[CPBundle bundleForClass:[CPWindow class]] pathForResource:@"_CPWindowView/_CPWindowViewResizeIndicator.png"] size:_CGSizeMake(12.0, 12.0)];
 }
 
 + (CGRect)contentRectForFrameRect:(CGRect)aFrameRect
 {
-    return CGRectMakeCopy(aFrameRect);
+    return _CGRectMakeCopy(aFrameRect);
 }
 
 + (CGRect)frameRectForContentRect:(CGRect)aContentRect
 {
-    return CGRectMakeCopy(aContentRect);
+    return _CGRectMakeCopy(aContentRect);
 }
 
 + (CPString)defaultThemeClass
@@ -81,7 +93,7 @@ var _CPWindowViewResizeIndicatorImage = nil;
 
     if ([theToolbar isVisible])
     {
-        var toolbarHeight = CGRectGetHeight([[theToolbar _toolbarView] frame]);
+        var toolbarHeight = _CGRectGetHeight([[theToolbar _toolbarView] frame]);
 
         contentRect.origin.y += toolbarHeight;
         contentRect.size.height -= toolbarHeight;
@@ -97,7 +109,7 @@ var _CPWindowViewResizeIndicatorImage = nil;
 
     if ([theToolbar isVisible])
     {
-        var toolbarHeight = CGRectGetHeight([[theToolbar _toolbarView] frame]);
+        var toolbarHeight = _CGRectGetHeight([[theToolbar _toolbarView] frame]);
 
         frameRect.origin.y -= toolbarHeight;
         frameRect.size.height += toolbarHeight;
@@ -113,8 +125,8 @@ var _CPWindowViewResizeIndicatorImage = nil;
     if (self)
     {
         _styleMask = aStyleMask;
-        _resizeIndicatorOffset = CGSizeMakeZero();
-        _toolbarOffset = CGSizeMakeZero();
+        _resizeIndicatorOffset = _CGSizeMakeZero();
+        _toolbarOffset = _CGSizeMakeZero();
     }
 
     return self;
@@ -135,48 +147,186 @@ var _CPWindowViewResizeIndicatorImage = nil;
 
 - (void)mouseDown:(CPEvent)anEvent
 {
-    var theWindow = [self window];
+    var theWindow = [self window],
+        couldResize = _styleMask & CPResizableWindowMask;
 
-    if ((_styleMask & CPResizableWindowMask) && _resizeIndicator)
+    couldResize = couldResize && (
+        (CPWindowResizeStyle === CPWindowResizeStyleModern) ||
+        ((CPWindowResizeStyle === CPWindowResizeStyleLegacy) && _resizeIndicator));
+
+    if (couldResize)
     {
-        // FIXME: This should be better
-        var frame = [_resizeIndicator frame];
+        var theWindow = [self window],
+            windowFrame = [theWindow frame],
+            shouldResize = NO;
 
-        if (CGRectContainsPoint(frame, [self convertPoint:[anEvent locationInWindow] fromView:nil]))
+        if (CPWindowResizeStyle === CPWindowResizeStyleModern)
+        {
+            var globalPoint = [theWindow convertBaseToGlobal:[anEvent locationInWindow]];
+
+            _resizeRegion = [self resizeRegionForPoint:globalPoint inFrame:windowFrame];
+            shouldResize = _resizeRegion !== _CPWindowViewResizeRegionNone;
+        }
+        else
+        {
+            // Extend the resize frame to the edge of the window frame
+            var resizeFrame = [_resizeIndicator frame];
+            resizeFrame.size.width = _CGRectGetWidth(windowFrame) - _CGRectGetMinX(resizeFrame);
+            resizeFrame.size.height = _CGRectGetHeight(windowFrame) - _CGRectGetMinY(resizeFrame);
+
+            var localPoint = [self convertPoint:[anEvent locationInWindow] fromView:nil];
+            shouldResize = CGRectContainsPoint(resizeFrame, localPoint);
+
+            // When in legacy mode, the only possible resize region is lower right
+            _resizeRegion = shouldResize ? _CPWindowViewResizeRegionBottomRight : _CPWindowViewResizeRegionNone;
+        }
+
+        if (shouldResize)
             return [self trackResizeWithEvent:anEvent];
     }
 
-    if ([theWindow isMovable] && [theWindow isMovableByWindowBackground])
+    if ([self couldBeMoveEvent:anEvent])
         [self trackMoveWithEvent:anEvent];
     else
         [super mouseDown:anEvent];
 }
 
+- (BOOL)couldBeMoveEvent:(CPEvent)anEvent
+{
+    var theWindow = [self window];
+
+    return [theWindow isMovable] && [theWindow isMovableByWindowBackground];
+}
+
+/*
+    aPoint should be in global coordinates
+*/
+- (int)resizeRegionForPoint:(CGPoint)aPoint inFrame:(CGRect)aFrame
+{
+    /*
+        There are 8 possible resize rects, 1 for each side and 1 for each corner.
+        The four corner rects are the same size, and the top/bottom and left/right
+        rects are the same size. So to save calculations, we can just create
+        3 rects and move them around to do hit testing. Start with the corners
+        and then do left/right and top/bottom.
+    */
+    var rect = _CGRectMake(aFrame.origin.x - CPWindowResizeSlop,
+                           aFrame.origin.y - CPWindowResizeSlop,
+                           _CPWindowViewCornerResizeRectWidth + CPWindowResizeSlop,
+                           _CPWindowViewCornerResizeRectWidth + CPWindowResizeSlop);
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionTopLeft;
+
+    rect.origin.x = _CGRectGetMaxX(aFrame) - _CPWindowViewCornerResizeRectWidth;
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionTopRight;
+
+    rect.origin.y = _CGRectGetMaxY(aFrame) - _CPWindowViewCornerResizeRectWidth;
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionBottomRight;
+
+    rect.origin.x = aFrame.origin.x - CPWindowResizeSlop;
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionBottomLeft;
+
+    rect = _CGRectMake(rect.origin.x,
+                       aFrame.origin.y + _CPWindowViewCornerResizeRectWidth,
+                       CPWindowResizeSlop * 2,
+                       _CGRectGetHeight(aFrame) - (_CPWindowViewCornerResizeRectWidth * 2));
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionLeft;
+
+    rect.origin.x = _CGRectGetMaxX(aFrame) - CPWindowResizeSlop;
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionRight;
+
+    rect = _CGRectMake(aFrame.origin.x + _CPWindowViewCornerResizeRectWidth,
+                       aFrame.origin.y - CPWindowResizeSlop,
+                       _CGRectGetWidth(aFrame) - (_CPWindowViewCornerResizeRectWidth * 2),
+                       CPWindowResizeSlop * 2);
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionTop;
+
+    rect.origin.y = _CGRectGetMaxY(aFrame) - CPWindowResizeSlop;
+
+    if (_CGRectContainsPoint(rect, aPoint))
+        return _CPWindowViewResizeRegionBottom;
+
+    return _CPWindowViewResizeRegionNone;
+}
+
 - (void)trackResizeWithEvent:(CPEvent)anEvent
 {
-    var location = [anEvent locationInWindow],
-        type = [anEvent type];
+    var type = [anEvent type];
 
     if (type === CPLeftMouseUp)
         return;
 
-    var theWindow = [self window];
+    var location = [anEvent locationInWindow],
+        theWindow = [self window],
+        globalLocation = [theWindow convertBaseToGlobal:location],
+        frame = [theWindow frame];
 
     if (type === CPLeftMouseDown)
     {
-        var frame = [theWindow frame];
-
-        _resizeFrame = CGRectMake(location.x, location.y, CGRectGetWidth(frame), CGRectGetHeight(frame));
+        _mouseDraggedPoint = _CGPointMakeCopy(globalLocation);
+        _resizeFrame = _CGRectMakeCopy(frame);
     }
 
     else if (type === CPLeftMouseDragged)
     {
-        var newSize = CGSizeMake(CGRectGetWidth(_resizeFrame) + location.x - CGRectGetMinX(_resizeFrame), CGRectGetHeight(_resizeFrame) + location.y - CGRectGetMinY(_resizeFrame));
+        var diffX = globalLocation.x - _mouseDraggedPoint.x,
+            diffY = globalLocation.y - _mouseDraggedPoint.y,
+            newX = _CGRectGetMinX(_resizeFrame),
+            newY = _CGRectGetMinY(_resizeFrame),
+            newWidth = _CGRectGetWidth(_resizeFrame),
+            newHeight = _CGRectGetHeight(_resizeFrame);
 
-        if (theWindow._isSheet && theWindow._parentView && (theWindow._frame.size.width !== newSize.width))
+        // Calculate x and width first
+        switch (_resizeRegion)
+        {
+            case _CPWindowViewResizeRegionTopLeft:
+            case _CPWindowViewResizeRegionLeft:
+            case _CPWindowViewResizeRegionBottomLeft:
+                newX += diffX,
+                newWidth -= diffX;
+                break;
+
+            case _CPWindowViewResizeRegionTopRight:
+            case _CPWindowViewResizeRegionRight:
+            case _CPWindowViewResizeRegionBottomRight:
+                newWidth += diffX;
+                break;
+        }
+
+        // Now calculate y and height
+        switch (_resizeRegion)
+        {
+            case _CPWindowViewResizeRegionTopLeft:
+            case _CPWindowViewResizeRegionTop:
+            case _CPWindowViewResizeRegionTopRight:
+                newY += diffY,
+                newHeight -= diffY;
+                break;
+
+            case _CPWindowViewResizeRegionBottomLeft:
+            case _CPWindowViewResizeRegionBottom:
+            case _CPWindowViewResizeRegionBottomRight:
+                newHeight += diffY;
+                break;
+        }
+
+        if (theWindow._isSheet && theWindow._parentView && (frame.size.width !== newWidth))
             [theWindow._parentView _setAttachedSheetFrameOrigin];
 
-        [theWindow setFrameSize:newSize];
+        [theWindow setFrame:_CGRectMake(newX, newY, newWidth, newHeight)];
     }
 
     [CPApp setTarget:self selector:@selector(trackResizeWithEvent:) forNextEventMatchingMask:CPLeftMouseDraggedMask | CPLeftMouseUpMask untilDate:nil inMode:nil dequeue:YES];
@@ -200,8 +350,8 @@ var _CPWindowViewResizeIndicatorImage = nil;
 
     var restrictedPoint = CGPointMake(0, 0);
 
-    restrictedPoint.x = MIN(MAX(aPoint.x, -_frame.size.width + 4.0), CGRectGetMaxX(visibleFrame) - 4.0);
-    restrictedPoint.y = MIN(MAX(aPoint.y, minPointY), CGRectGetMaxY(visibleFrame) - 8.0);
+    restrictedPoint.x = MIN(MAX(aPoint.x, -_frame.size.width + 4.0), _CGRectGetMaxX(visibleFrame) - 4.0);
+    restrictedPoint.y = MIN(MAX(aPoint.y, minPointY), _CGRectGetMaxY(visibleFrame) - 8.0);
 
     return restrictedPoint;
 }
@@ -251,12 +401,12 @@ var _CPWindowViewResizeIndicatorImage = nil;
 
 - (void)setShowsResizeIndicator:(BOOL)shouldShowResizeIndicator
 {
-    if (shouldShowResizeIndicator)
+    if (shouldShowResizeIndicator && CPWindowResizeStyle === CPWindowResizeStyleLegacy)
     {
         var size = [_CPWindowViewResizeIndicatorImage size],
             boundsSize = [self frame].size;
 
-        _resizeIndicator = [[CPImageView alloc] initWithFrame:CGRectMake(boundsSize.width - size.width - _resizeIndicatorOffset.width, boundsSize.height - size.height - _resizeIndicatorOffset.height, size.width, size.height)];
+        _resizeIndicator = [[CPImageView alloc] initWithFrame:_CGRectMake(boundsSize.width - size.width - _resizeIndicatorOffset.width, boundsSize.height - size.height - _resizeIndicatorOffset.height, size.width, size.height)];
 
         [_resizeIndicator setImage:_CPWindowViewResizeIndicatorImage];
         [_resizeIndicator setAutoresizingMask:CPViewMinXMargin | CPViewMinYMargin];
@@ -325,7 +475,7 @@ var _CPWindowViewResizeIndicatorImage = nil;
     if (!_toolbarView || [_toolbarView isHidden])
         return [self toolbarOffset].height;
 
-    return CGRectGetMaxY([_toolbarView frame]);
+    return _CGRectGetMaxY([_toolbarView frame]);
 }
 
 - (_CPToolbarView)toolbarView
@@ -337,14 +487,14 @@ var _CPWindowViewResizeIndicatorImage = nil;
 {
     var theWindow = [self window],
         bounds = [self bounds],
-        width = CGRectGetWidth(bounds);
+        width = _CGRectGetWidth(bounds);
 
     if ([[theWindow toolbar] isVisible])
     {
         var toolbarView = [self toolbarView],
             toolbarOffset = [self toolbarOffset];
 
-        [toolbarView setFrame:CGRectMake(toolbarOffset.width, toolbarOffset.height, width, CGRectGetHeight([toolbarView frame]))];
+        [toolbarView setFrame:_CGRectMake(toolbarOffset.width, toolbarOffset.height, width, _CGRectGetHeight([toolbarView frame]))];
     }
 
     if ([self showsResizeIndicator])