Support for resizing windows on all sides

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])