@breakside/jskit 2022.25.1 → 2022.28.0

package/Root/Frameworks/UIKit/UITextEditorDelegate.js

@@ -19,6 +19,8 @@
 JSProtocol("UITextEditorDelegate", JSProtocol, {
 
     textEditorDidReplaceCharactersInRange: function(textEditor, range, insertedText){},
-    textEditorDidPositionCursors: function(textEditor){}
+    textEditorDidPositionCursors: function(textEditor){},
+    textEditorPrepareInsertAttributes: function(textEditor, attributes){},
+    atomicRangeForTextEditorIndex: function(textEditor, index){}
 
 });

package/Root/Frameworks/UIKit/UITextLayer.js

@@ -59,8 +59,8 @@ JSClass("UITextLayer", UILayer, {
     },
 
     didChangeSize: function(){
-        UITextLayer.$super.didChangeSize.call(this);
         this._textContainer.size = this._availableTextSize();
+        UITextLayer.$super.didChangeSize.call(this);
     },
 
     // MARK: - Styling

package/Root/Frameworks/UIKit/UIView.js

@@ -22,6 +22,7 @@
 // #import "UITraitCollection.js"
 // #import "UICursor.js"
 // #import "UIAccessibility.js"
+// #import "UIMouseTrackingArea.js"
 'use strict';
 
 JSGlobalObject.UIViewLayerProperty = function(){
@@ -183,7 +184,7 @@ JSClass('UIView', UIResponder, {
     shadowColor: UIViewLayerProperty(),
     shadowOffset: UIViewLayerProperty(),
     shadowRadius: UIViewLayerProperty(),
-    cursor: JSDynamicProperty('_cursor', null),
+    cursor: JSDynamicProperty(),
     tooltip: null,
 
     // -------------------------------------------------------------------------
@@ -322,6 +323,17 @@ JSClass('UIView', UIResponder, {
         return null;
     },
 
+    isDescendantOfView: function(view){
+        if (view === null || view === undefined){
+            return false;
+        }
+        var superview = this.superview;
+        while (superview !== null && superview !== view){
+            superview = superview.superview;
+        }
+        return superview !== null && superview === view;
+    },
+
     // -------------------------------------------------------------------------
     // MARK: - Window
 
@@ -329,11 +341,21 @@ JSClass('UIView', UIResponder, {
 
     setWindow: function(window){
         if (window != this._window){
-            if (this._window && this._window.firstResponder === this){
-                this._window.firstResponder = null;
+            if (this._window){
+                if (this._window.firstResponder === this){
+                    this._window.firstResponder = null;
+                }
+                if (this._mouseTrackingAreas !== null && this._mouseTrackingAreas.length > 0){
+                    this._window.removeMouseTrackingView(this);
+                }
             }
             this._setWindowServer(window ? window.windowServer : null);
             this._window = window;
+            if (this._window){
+                if (this._mouseTrackingAreas !== null && this._mouseTrackingAreas.length > 0){
+                    this._window.addMouseTrackingView(this);
+                }
+            }
             for (var i = 0, l = this.subviews.length; i < l; ++i){
                 this.subviews[i].window = window;
             }
@@ -348,22 +370,6 @@ JSClass('UIView', UIResponder, {
 
     _setWindowServer: function(windowServer, includeSubviews){
         if (this._windowServer !== windowServer){
-            if (this.cursor !== null){
-                if (this._windowServer !== null){
-                    this._windowServer.viewDidChangeCursor(this, null);
-                }
-                if (windowServer !== null){
-                    windowServer.viewDidChangeCursor(this, this.cursor);
-                }
-            }
-            if (this.mouseTrackingType !== UIView.MouseTracking.none){
-                if (this._windowServer !== null){
-                    this._windowServer.viewDidChangeMouseTracking(this, UIView.MouseTracking.none);
-                }
-                if (windowServer !== null){
-                    windowServer.viewDidChangeMouseTracking(this, this.mouseTrackingType);
-                }
-            }
             if (this.isAccessibilityElement){
                 if (this._windowServer !== null){
                     this._windowServer.postNotificationsForAccessibilityElementDestroyed(this);
@@ -381,13 +387,6 @@ JSClass('UIView', UIResponder, {
         }
     },
 
-    setCursor: function(cursor){
-        this._cursor = cursor;
-        if (this._windowServer !== null){
-            this._windowServer.viewDidChangeCursor(this, this.cursor);
-        }
-    },
-
     windowDidChangeKeyStatus: function(){
         for (var i = 0, l = this.subviews.length; i < l; ++i){
             this.subviews[i].windowDidChangeKeyStatus();
@@ -547,6 +546,7 @@ JSClass('UIView', UIResponder, {
     layerDidChangeSize: function(layer){
         if (layer === this.layer){
             this.invalidateFocusRingPath();
+            this.updateMouseTrackingAreas();
         }
     },
 
@@ -680,9 +680,8 @@ JSClass('UIView', UIResponder, {
     },
 
     // -------------------------------------------------------------------------
-    // MARK: - Responder & Mouse Tracking
-
-    mouseTrackingType: 0,
+    // MARK: - Responder
+    
     isMultipleTouchEnabled: false,
 
     isFirstResponder: function(){
@@ -696,24 +695,113 @@ JSClass('UIView', UIResponder, {
         return this.superview;
     },
 
-    startMouseTracking: function(trackingType){
-        this.mouseTrackingType = trackingType;
-        if (this._windowServer !== null){
-            this._windowServer.viewDidChangeMouseTracking(this, this.mouseTrackingType);
+    keyActive: JSReadOnlyProperty(undefined, undefined, 'isKeyActive'),
+
+    isKeyActive: function(){
+        return this.window !== null && this.window.isKeyWindow && this.window.firstResponder === this;
+    },
+
+    // -------------------------------------------------------------------------
+    // MARK: - Mouse Tracking
+
+    _mouseTrackingAreas: null,
+
+    addMouseTrackingArea: function(trackingArea){
+        if (this._mouseTrackingAreas === null){
+            this._mouseTrackingAreas = [];
+        }
+        var index = this._mouseTrackingAreas.indexOf(trackingArea);
+        if (index < 0){
+            trackingArea.view = this;
+            this._mouseTrackingAreas.push(trackingArea);
+            if (this._mouseTrackingAreas.length === 1 && this._window !== null){
+                this._window.addMouseTrackingView(this);
+            }
         }
     },
 
-    stopMouseTracking: function(){
-        this.mouseTrackingType = UIView.MouseTracking.none;
-        if (this._windowServer !== null){
-            this._windowServer.viewDidChangeMouseTracking(this, this.mouseTrackingType);
+    removeMouseTrackingArea: function(trackingArea){
+        if (this._mouseTrackingAreas !== null){
+            var index = this._mouseTrackingAreas.indexOf(trackingArea);
+            if (index >= 0){
+                if (trackingArea._entered && trackingArea.cursor !== null){
+                    trackingArea.cursor.unset();
+                }
+                trackingArea._entered = false;
+                trackingArea.view = null;
+                this._mouseTrackingAreas.splice(index, 1);
+                if (this._window !== null && this._mouseTrackingAreas.length === 0){
+                    this._window.removeMouseTrackingView(this);
+                }
+            }
         }
     },
 
-    keyActive: JSReadOnlyProperty(undefined, undefined, 'isKeyActive'),
+    updateMouseTrackingAreas: function(){
+        if (this._startStopMouseTrackingArea !== null){
+            this._startStopMouseTrackingArea.rect = this.bounds;
+        }
+        if (this._cursorMouseTrackingArea !== null){
+            this._cursorMouseTrackingArea.rect = this.bounds;
+        }
+    },
 
-    isKeyActive: function(){
-        return this.window !== null && this.window.isKeyWindow && this.window.firstResponder === this;
+    _cursorMouseTrackingArea: null,
+
+    setCursor: function(cursor){
+        if (this._cursorMouseTrackingArea === null){
+            if (cursor !== null){
+                this._cursorMouseTrackingArea = UIMouseTrackingArea.initWithResponder(this, this.bounds, UIMouseTrackingArea.TrackingType.enterAndExit);
+                this._cursorMouseTrackingArea.cursor = cursor;
+                this.addMouseTrackingArea(this._cursorMouseTrackingArea);
+            }
+        }else{
+            if (cursor !== null){
+                this._cursorMouseTrackingArea.cursor = cursor;
+                if (this._cursorMouseTrackingArea._entered){
+                    cursor.set();
+                }
+            }else{
+                this.removeMouseTrackingArea(this._cursorMouseTrackingArea);
+                this._cursorMouseTrackingArea = null;
+            }
+        }
+    },
+
+    getCursor: function(){
+        if (this._cursorMouseTrackingArea !== null){
+            return this._cursorMouseTrackingArea.cursor;
+        }
+        return null;
+    },
+
+    // legacy/deprecated
+    
+    mouseTrackingType: JSReadOnlyProperty(),
+
+    getMouseTrackingType: function(){
+        if (this._startStopMouseTrackingArea !== null){
+            return this._startStopMouseTrackingArea.trackingType;
+        }
+        return UIView.MouseTracking.none;
+    },
+
+    _startStopMouseTrackingArea: null,
+
+    startMouseTracking: function(trackingType){
+        if (this._startStopMouseTrackingArea === null){
+            this._startStopMouseTrackingArea = UIMouseTrackingArea.initWithResponder(this, this.bounds, trackingType);
+            this.addMouseTrackingArea(this._startStopMouseTrackingArea);
+        }else{
+            this._startStopMouseTrackingArea.trackingType = trackingType;
+        }
+    },
+
+    stopMouseTracking: function(){
+        if (this._startStopMouseTrackingArea !== null){
+            this.removeMouseTrackingArea(this._startStopMouseTrackingArea);
+            this._startStopMouseTrackingArea = null;
+        }
     },
 
     // -------------------------------------------------------------------------
@@ -1047,12 +1135,7 @@ JSClass('UIView', UIResponder, {
 
 });
 
-UIView.MouseTracking = {
-    none: 0,
-    move: 1,
-    enterAndExit: 2,
-    all: 3
-};
+UIView.MouseTracking = UIMouseTrackingArea.TrackingType;
 
 UIView.layerClass = UILayer;
 

package/Root/Frameworks/UIKit/UIViewController.js

@@ -307,9 +307,15 @@ JSClass("UIViewController", UIResponder, {
             }
         }else{
             if (previousChildViewController !== null){
+                if (previousChildViewController._lifecycleState === UIViewController.LifecycleState.appearing){
+                    previousChildViewController.scheduleDisappearance();
+                }
                 previousChildViewController.removeFromParentViewController();
             }
             if (childViewController !== null){
+                if (this._lifecycleState === UIViewController.LifecycleState.appearing){
+                    childViewController.beginAppearance(this._appearanceTransitionAnimated);
+                }
                 this.addChildViewController(childViewController);
             }
         }

package/Root/Frameworks/UIKit/UIWindow.js

@@ -752,6 +752,95 @@ JSClass('UIWindow', UIView, {
         return JSRect(this.convertPointToScreen(rect.origin), rect.size);
     },
 
+    // -------------------------------------------------------------------------
+    // MARK: - Mouse Tracking
+
+    mouseTrackingViews: null,
+
+    addMouseTrackingView: function(view){
+        if (this.mouseTrackingViews === null){
+            this.mouseTrackingViews = [];
+        }
+        var index = this.mouseTrackingViews.indexOf(view);
+        if (index < 0){
+            this.mouseTrackingViews.push(view);
+        }
+    },
+
+    removeMouseTrackingView: function(view){
+        if (this.mouseTrackingViews === null){
+            return;
+        }
+        var index = this.mouseTrackingViews.indexOf(view);
+        if (index >= 0){
+            this.mouseTrackingViews.splice(index, 1);
+        }
+    },
+
+    sendMouseTrackingEvents: function(locationInWindow, timestamp, modifiers, isExiting){
+        if (this.mouseTrackingViews === null || this.mouseTrackingViews.length === 0){
+            return;
+        }
+        var view;
+        var area;
+        var viewIndex, viewCount;
+        var areaIndex, areaCount;
+        var location;
+        var enters = [];
+        var exits = [];
+        var moves = [];
+        for (viewIndex = 0, viewCount = this.mouseTrackingViews.length; viewIndex < viewCount; ++viewIndex){
+            view = this.mouseTrackingViews[viewIndex];
+            location = this.convertPointToView(locationInWindow, view);
+            for (areaIndex = 0, areaCount = view._mouseTrackingAreas.length; areaIndex < areaCount; ++areaIndex){
+                area = view._mouseTrackingAreas[areaIndex];
+                if (!isExiting && !view.hidden && view.userInteractionEnabled && area.containsPoint(location)){
+                    if (!area._entered){
+                        area._entered = true;
+                        if ((area.trackingType & UIMouseTrackingArea.TrackingType.enterAndExit) !== 0){
+                            enters.push(area);
+                        }
+                    }
+                    if ((area.trackingType & UIMouseTrackingArea.TrackingType.move) !== 0){
+                        moves.push(area);
+                    }
+                }else{
+                    if (area._entered){
+                        area._entered = false;
+                        if ((area.trackingType & UIMouseTrackingArea.TrackingType.enterAndExit) !== 0){
+                            exits.push(area);
+                        }
+                    }
+                }
+            }
+        }
+        // FIXME: the order could be important here for views that overlap and
+        // set cursors.  We'd want the topmost one to be called last for enters
+        // and first for exits
+        var event;
+        if (exits.length > 0){
+            event = UIEvent.initMouseEventWithType(UIEvent.Type.mouseExited, timestamp, this, locationInWindow, modifiers, 0);
+            for (areaIndex = 0, areaCount = exits.length; areaIndex < areaCount; ++areaIndex){
+                area = exits[areaIndex];
+                area.mouseExited(event);
+            }
+        }
+        if (enters.length > 0){
+            event = UIEvent.initMouseEventWithType(UIEvent.Type.mouseEntered, timestamp, this, locationInWindow, modifiers, 0);
+            for (areaIndex = 0, areaCount = enters.length; areaIndex < areaCount; ++areaIndex){
+                area = enters[areaIndex];
+                area.mouseEntered(event);
+            }
+        }
+        if (moves.length > 0){
+            event = UIEvent.initMouseEventWithType(UIEvent.Type.mouseMoved, timestamp, this, locationInWindow, modifiers, 0);
+            for (areaIndex = 0, areaCount = moves.length; areaIndex < areaCount; ++areaIndex){
+                area = moves[areaIndex];
+                area.mouseMoved(event);
+            }
+        }
+    },
+
     // -------------------------------------------------------------------------
     // MARK: - Event Dispatch
 

package/Root/Frameworks/UIKit/UIWindowServer.js

@@ -209,6 +209,9 @@ JSClass("UIWindowServer", JSObject, {
                 this.windowStack.splice(i, 1);
                 this.displayServer.windowRemoved(window);
                 window._screen = null;
+                if (window === this._mouseTrackingWindow){
+                    this._mouseTrackingWindow = null;
+                }
                 break;
             }
             this.windowStack[i].subviewIndex = this.windowStack[i].layer.sublayerIndex = i - 1;
@@ -252,23 +255,10 @@ JSClass("UIWindowServer", JSObject, {
         this._endWindowOrderChange();
     },
 
-    _previousEventWindow: null,
-
     _beginWindowOrderChange: function(){
-        if (this._previousEventWindow !== null){
-            return;
-        }
-        this._previousEventWindow = this.windowForEventAtLocation(this.mouseLocation);
     },
 
     _endWindowOrderChange: function(){
-        if (this._previousEventWindow === null){
-            return;
-        }
-        var previousEventWindow = this._previousEventWindow;
-        var currentEventWindow = this.windowForEventAtLocation(this.mouseLocation);
-        this._previousEventWindow = null;
-        this._createTrackingEventsForWindowLevelChangeAtLocation(this.mouseLocation, previousEventWindow, currentEventWindow);
     },
 
     // -----------------------------------------------------------------------
@@ -325,10 +315,6 @@ JSClass("UIWindowServer", JSObject, {
     // -----------------------------------------------------------------------
     // MARK: - Cursor Managment
 
-    viewDidChangeCursor: function(view, cursor){
-        // subclasses should override
-    },
-
     hideCursor: function(){
         // subclasses should override
     },
@@ -696,6 +682,7 @@ JSClass("UIWindowServer", JSObject, {
             this.draggingSessionDidChangeLocation();
         }else{
             if (this.mouseDownCount === 0){
+                this.sendMouseTrackingEvents(timestamp, modifiers);
                 if (this._tooltipWindow === null){
                     this._mouseIdleTimer.schedule();
                 }else{
@@ -728,74 +715,28 @@ JSClass("UIWindowServer", JSObject, {
     // -----------------------------------------------------------------------
     // MARK: - Mouse Tracking
 
-    viewDidChangeMouseTracking: function(view, trackingType){
-        // subclasses should override
-    },
-
-    createMouseTrackingEvent: function(type, timestamp, location, modifiers, view, force){
-        if (!force && !this._shouldCreateTrackingEventForView(view)){
-            return;
-        }
-        var event = UIEvent.initMouseEventWithType(type, timestamp, view.window, view.window.convertPointFromScreen(location), modifiers, 0);
-        event.trackingView = view;
-        this._sendEventToApplication(event, view.window.application);
-    },
-
-    _shouldCreateTrackingEventForView: function(view){
-        if (this.mouseEventWindow !== null){
-            // no tracking events if the mouse is down
-            return false;
-        }
-        var window = view.window;
-        if (window === null){
-            return false;
-        }
-        if (window.shouldReceiveTrackingInBack){
-            return true;
-        }
-        if (window.receivesAllEvents){
-            return true;
-        }
-        if (window === this.mainWindow){
-            return true;
-        }
-        if (window === this.keyWindow){
-            return true;
-        }
-        return true;
-    },
+    _mouseTrackingWindow: null,
 
-    _createTrackingEventsForWindowLevelChangeAtLocation: function(location, previousWindow, currentWindow){
-        if (currentWindow === previousWindow){
-            return;
-        }
-        var view;
-        if (previousWindow !== null && (previousWindow.objectID in this._windowsById)){
-            view = this._trackingViewInWindowAtLocation(previousWindow, location);
-            if (view !== null){
-                this.createMouseTrackingEvent(UIEvent.Type.mouseExited, -1, location, UIEvent.Modifier.none, view, true);
+    sendMouseTrackingEvents: function(timestamp, modifiers){
+        var window = null;
+        var windowIndex;
+        var location;
+        var event;
+        for (windowIndex = this.windowStack.length - 1; windowIndex >= 0 && window === null; --windowIndex){
+            location = this.windowStack[windowIndex].convertPointFromScreen(this.mouseLocation);
+            if (this.windowStack[windowIndex].userInteractionEnabled && this.windowStack[windowIndex].containsPoint(location)){
+                window = this.windowStack[windowIndex];
             }
         }
-        if (currentWindow !== null && (currentWindow.objectID in this._windowsById)){
-            view = this._trackingViewInWindowAtLocation(currentWindow, location);
-            if (view !== null){
-                this.createMouseTrackingEvent(UIEvent.Type.mouseEntered, -1, location, UIEvent.Modifier.none, view, true);
+        if (this._mouseTrackingWindow !== null){
+            if (window !== this._mouseTrackingWindow){
+                this._mouseTrackingWindow.sendMouseTrackingEvents(this._mouseTrackingWindow.convertPointFromScreen(this.mouseLocation), timestamp, modifiers, true);
             }
         }
-    },
-
-    _trackingViewInWindowAtLocation: function(window, location){
-        var view = window.hitTest(window.convertPointFromScreen(location));
-        if (view === null){
-            return null;
-        }
-        while (view.superview !== null && ((view.mouseTrackingType & UIView.MouseTracking.enterAndExit) === 0)){
-            view = view.superview;
+        this._mouseTrackingWindow = window;
+        if (this._mouseTrackingWindow !== null){
+            this._mouseTrackingWindow.sendMouseTrackingEvents(this._mouseTrackingWindow.convertPointFromScreen(this.mouseLocation), timestamp, modifiers, false);
         }
-        if ((view.mouseTrackingType & UIView.MouseTracking.enterAndExit) !== 0){
-            return view;
-        }
-        return null;
     },
 
     // -----------------------------------------------------------------------

package/Root/Frameworks/UIKitTesting/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.UIKitTesting
-JSBundleVersion: 2022.25.1
+JSBundleVersion: 2022.28.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSLicenseNotice: |

package/package.json

@@ -9,7 +9,7 @@
     "node": ">=10.10.0"
   },
   "name": "@breakside/jskit",
-  "version": "2022.25.1",
+  "version": "2022.28.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "files": [
     "*"