react-native-smooth-clip-view 0.1.0 → 0.2.1

package/android/src/main/java/com/smoothclipview/ClipGeometryNormalizer.kt

@@ -3,6 +3,7 @@ package com.smoothclipview
 import android.view.View
 import kotlin.math.max
 import kotlin.math.min
+import kotlin.math.roundToInt
 
 /**
  * Normalizes clip geometry without allocating a result object. The callback is
@@ -53,6 +54,30 @@ internal inline fun normalizeClipGeometryPx(
 internal fun clipVisibility(isEmpty: Boolean): Int =
     if (isEmpty) View.INVISIBLE else View.VISIBLE
 
+/**
+ * Outline dedupe on the rounded integer physical-pixel edges actually emitted
+ * to the outline provider. Sub-pixel motion that rounds to the cached integers
+ * must not invalidate the outline; the radius stays a float comparison because
+ * it is emitted to the outline as a float.
+ */
+internal fun outlineChanged(
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    radius: Float,
+    cachedLeft: Int,
+    cachedTop: Int,
+    cachedRight: Int,
+    cachedBottom: Int,
+    cachedRadius: Float,
+): Boolean =
+    left.roundToInt() != cachedLeft ||
+        top.roundToInt() != cachedTop ||
+        right.roundToInt() != cachedRight ||
+        bottom.roundToInt() != cachedBottom ||
+        radius != cachedRadius
+
 internal fun clipAccessibility(
     isEmpty: Boolean,
     requestedAccessibility: Int,

package/android/src/main/java/com/smoothclipview/SmoothClipBindings.kt

@@ -0,0 +1,55 @@
+package com.smoothclipview
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+
+/**
+ * Bridge to the shared C++ SmoothClip registry. All driver state, animation and
+ * geometry live in native C++ (see android/src/main/cpp); this object only loads
+ * the library, exposes the worklet-callable JSI bindings installer, and forwards
+ * Fabric view lifecycle to the registry.
+ */
+@DoNotStrip
+internal object SmoothClipBindings {
+    init {
+        System.loadLibrary("smoothclipview")
+    }
+
+    /** Installs `global.__SmoothClipView` and wires completion delivery. */
+    external fun getBindingsInstaller(): BindingsInstallerHolder
+
+    external fun nativeRegisterView(
+        driverId: Double,
+        view: SmoothClipView,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        density: Double,
+        widthPx: Double,
+        heightPx: Double,
+    )
+
+    /**
+     * Pushes a registered view's density and pixel host size so driver
+     * deliveries are pre-normalized in C++; redelivers the visible value.
+     */
+    external fun nativeSetViewHostGeometry(
+        driverId: Double,
+        view: SmoothClipView,
+        density: Double,
+        widthPx: Double,
+        heightPx: Double,
+    )
+
+    external fun nativeUnregisterView(driverId: Double, view: SmoothClipView)
+
+    /**
+     * Releases runtime-bound listener state during host teardown; must run
+     * while the JS runtime is still alive (module invalidate).
+     */
+    external fun nativeInvalidate()
+}

package/android/src/main/java/com/smoothclipview/SmoothClipModule.kt

@@ -0,0 +1,128 @@
+package com.smoothclipview
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+
+/**
+ * The Android driver runs entirely through worklet-callable C++ JSI bindings
+ * (installed via [getBindingsInstaller]); JS resolves `global.__SmoothClipView`
+ * instead of these TurboModule methods. The spec methods below are required by
+ * codegen but are never invoked on Android.
+ */
+@ReactModule(name = NativeSmoothClipModuleSpec.NAME)
+class SmoothClipModule(context: ReactApplicationContext) :
+    NativeSmoothClipModuleSpec(context), TurboModuleWithJSIBindings {
+
+    override fun getBindingsInstaller(): BindingsInstallerHolder =
+        SmoothClipBindings.getBindingsInstaller()
+
+    override fun invalidate() {
+        super.invalidate()
+        // Completions must stop and runtime-bound listener functions must be
+        // released before the JS runtime is torn down; otherwise a later host
+        // would deliver completions into a destroyed runtime.
+        SmoothClipBindings.nativeInvalidate()
+    }
+
+    override fun setClipPresentation(
+        driverId: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        takeOwnership: Boolean,
+    ) = Unit
+
+    override fun beginInteraction(driverId: Double): WritableArray =
+        Arguments.createArray()
+
+    override fun animateTiming(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startRadius: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        durationMs: Double,
+        controlPoint1X: Double,
+        controlPoint1Y: Double,
+        controlPoint2X: Double,
+        controlPoint2Y: Double,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun animateSpring(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startRadius: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        mass: Double,
+        stiffness: Double,
+        damping: Double,
+        initialVelocity: Double,
+        inheritVelocity: Boolean,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun animateKeyframes(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startRadius: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        durationMs: Double,
+        frames: ReadableArray,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun rejectAnimation(driverId: Double): Double = 0.0
+
+    override fun cancelAnimation(
+        driverId: Double,
+        animationId: Double,
+        behavior: Double,
+    ): WritableArray = Arguments.createArray()
+
+    override fun destroyDriver(driverId: Double) = Unit
+}

package/android/src/main/java/com/smoothclipview/SmoothClipView.kt

@@ -1,29 +1,46 @@
 package com.smoothclipview
 
+import android.content.res.Configuration
 import android.graphics.Outline
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewOutlineProvider
+import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
 import kotlin.math.roundToInt
 
 class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
+    internal val contentContainer = ReactViewGroup(context)
     private var requestedX = 0f
     private var requestedY = 0f
     private var requestedWidth = 0f
     private var requestedHeight = 0f
     private var requestedRadius = 0f
+    private var requestedContentTranslateX = 0f
+    private var requestedContentTranslateY = 0f
     private var clipLeft = 0f
     private var clipTop = 0f
     private var clipRight = 0f
     private var clipBottom = 0f
     private var clipRadius = 0f
+    // Rounded edges actually emitted to the outline provider. Sub-pixel changes
+    // that round to the same integers must not invalidate the outline.
+    private var outlineLeft = 0
+    private var outlineTop = 0
+    private var outlineRight = 0
+    private var outlineBottom = 0
     private var clipIsEmpty = true
     private var requestedImportantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_AUTO
     private var acceptingTouchStream = false
 
+    /** Driver this view is registered with in the native registry (0 = none). */
+    internal var boundDriverId: Double = 0.0
+
+    /** Set once a legacy command arrives; later initialClip* props are ignored. */
+    internal var commandIsAuthoritative = false
+
     private val clipOutlineProvider = object : ViewOutlineProvider() {
         override fun getOutline(view: View, outline: Outline) {
             if (clipIsEmpty) {
@@ -32,16 +49,17 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
             }
 
             outline.setRoundRect(
-                clipLeft.roundToInt(),
-                clipTop.roundToInt(),
-                clipRight.roundToInt(),
-                clipBottom.roundToInt(),
+                outlineLeft,
+                outlineTop,
+                outlineRight,
+                outlineBottom,
                 clipRadius,
             )
         }
     }
 
     init {
+        super.addView(contentContainer)
         outlineProvider = clipOutlineProvider
         clipToOutline = true
         visibility = INVISIBLE
@@ -54,9 +72,21 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
         width: Double,
         height: Double,
         radius: Double,
+    ) = setClipPresentationDip(x, y, width, height, radius, 0.0, 0.0)
+
+    @DoNotStrip
+    fun setClipPresentationDip(
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
     ) {
         if (!x.isFinite() || !y.isFinite() || !width.isFinite() ||
-            !height.isFinite() || !radius.isFinite()
+            !height.isFinite() || !radius.isFinite() ||
+            !contentTranslateX.isFinite() || !contentTranslateY.isFinite()
         ) {
             return
         }
@@ -66,8 +96,11 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
         val nextWidth = PixelUtil.toPixelFromDIP(width).toFloat()
         val nextHeight = PixelUtil.toPixelFromDIP(height).toFloat()
         val nextRadius = PixelUtil.toPixelFromDIP(radius).toFloat()
+        val nextContentTranslateX = PixelUtil.toPixelFromDIP(contentTranslateX).toFloat()
+        val nextContentTranslateY = PixelUtil.toPixelFromDIP(contentTranslateY).toFloat()
         if (!nextX.isFinite() || !nextY.isFinite() || !nextWidth.isFinite() ||
-            !nextHeight.isFinite() || !nextRadius.isFinite()
+            !nextHeight.isFinite() || !nextRadius.isFinite() ||
+            !nextContentTranslateX.isFinite() || !nextContentTranslateY.isFinite()
         ) {
             return
         }
@@ -77,9 +110,43 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
         requestedWidth = nextWidth
         requestedHeight = nextHeight
         requestedRadius = nextRadius
+        if (requestedContentTranslateX != nextContentTranslateX) {
+            requestedContentTranslateX = nextContentTranslateX
+            contentContainer.translationX = nextContentTranslateX
+        }
+        if (requestedContentTranslateY != nextContentTranslateY) {
+            requestedContentTranslateY = nextContentTranslateY
+            contentContainer.translationY = nextContentTranslateY
+        }
         applyRequestedGeometry()
     }
 
+    /**
+     * Driver hot path: called from the C++ registry with final pixel-space,
+     * pre-normalized values (see deliverToView in SmoothClipRegistry.cpp).
+     * No validation, scaling or normalization happens here.
+     */
+    @DoNotStrip
+    fun setClipPresentationPx(
+        left: Float,
+        top: Float,
+        right: Float,
+        bottom: Float,
+        radius: Float,
+        contentTranslateX: Float,
+        contentTranslateY: Float,
+    ) {
+        if (requestedContentTranslateX != contentTranslateX) {
+            requestedContentTranslateX = contentTranslateX
+            contentContainer.translationX = contentTranslateX
+        }
+        if (requestedContentTranslateY != contentTranslateY) {
+            requestedContentTranslateY = contentTranslateY
+            contentContainer.translationY = contentTranslateY
+        }
+        applyNormalizedClipPx(left, top, right, bottom, radius)
+    }
+
     private fun applyRequestedGeometry() {
         normalizeClipGeometryPx(
             requestedX,
@@ -90,40 +157,98 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
             width.toFloat(),
             height.toFloat(),
         ) { left, top, right, bottom, radius ->
-            val isEmpty = right <= left || bottom <= top
-            val geometryChanged =
-                left != clipLeft || top != clipTop || right != clipRight ||
-                    bottom != clipBottom || radius != clipRadius
+            applyNormalizedClipPx(left, top, right, bottom, radius)
+        }
+    }
 
-            if (!geometryChanged && isEmpty == clipIsEmpty) {
-                return@normalizeClipGeometryPx
-            }
+    private fun applyNormalizedClipPx(
+        left: Float,
+        top: Float,
+        right: Float,
+        bottom: Float,
+        radius: Float,
+    ) {
+        val isEmpty = right <= left || bottom <= top
+        val outlineGeometryChanged = outlineChanged(
+            left,
+            top,
+            right,
+            bottom,
+            radius,
+            outlineLeft,
+            outlineTop,
+            outlineRight,
+            outlineBottom,
+            clipRadius,
+        )
 
-            clipLeft = left
-            clipTop = top
-            clipRight = right
-            clipBottom = bottom
-            clipRadius = radius
-
-            if (isEmpty != clipIsEmpty) {
-                clipIsEmpty = isEmpty
-                visibility = clipVisibility(isEmpty)
-                importantForAccessibility = clipAccessibility(
-                    isEmpty,
-                    requestedImportantForAccessibility,
-                )
-                if (isEmpty) acceptingTouchStream = false
-            }
+        if (!outlineGeometryChanged && isEmpty == clipIsEmpty) {
+            return
+        }
+
+        clipLeft = left
+        clipTop = top
+        clipRight = right
+        clipBottom = bottom
+        clipRadius = radius
+        outlineLeft = left.roundToInt()
+        outlineTop = top.roundToInt()
+        outlineRight = right.roundToInt()
+        outlineBottom = bottom.roundToInt()
 
-            invalidateOutline()
+        if (isEmpty != clipIsEmpty) {
+            clipIsEmpty = isEmpty
+            visibility = clipVisibility(isEmpty)
+            importantForAccessibility = clipAccessibility(
+                isEmpty,
+                requestedImportantForAccessibility,
+            )
+            if (isEmpty) acceptingTouchStream = false
         }
+
+        invalidateOutline()
     }
 
     override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
         super.onSizeChanged(w, h, oldw, oldh)
-        applyRequestedGeometry()
+        contentContainer.layout(0, 0, w, h)
+        if (boundDriverId != 0.0) {
+            // Driver deliveries are pre-normalized in C++ against the pushed
+            // host metrics; refresh them and let the registry redeliver the
+            // visible value synchronously.
+            SmoothClipBindings.nativeSetViewHostGeometry(
+                boundDriverId,
+                this,
+                densityScale(),
+                w.toDouble(),
+                h.toDouble(),
+            )
+        }
+        if (boundDriverId == 0.0 || commandIsAuthoritative) {
+            // Command geometry lives in the requested* DIP fields. Reapplying
+            // after the driver redelivery keeps the last-writer semantics: an
+            // authoritative command wins over the driver value on resize.
+            applyRequestedGeometry()
+        }
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        if (boundDriverId != 0.0) {
+            // Density can change without a size change (display switch); the
+            // registry scales DIP deliveries by the pushed density.
+            SmoothClipBindings.nativeSetViewHostGeometry(
+                boundDriverId,
+                this,
+                densityScale(),
+                width.toDouble(),
+                height.toDouble(),
+            )
+        }
+    }
+
+    internal fun densityScale(): Double = PixelUtil.toPixelFromDIP(1f).toDouble()
+
     private fun containsRoundedPoint(x: Float, y: Float): Boolean {
         return containsRoundedPointPx(
             x,
@@ -179,11 +304,20 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
 
     fun resetClipState() {
         acceptingTouchStream = false
+        commandIsAuthoritative = false
         requestedX = 0f
         requestedY = 0f
         requestedWidth = 0f
         requestedHeight = 0f
         requestedRadius = 0f
+        requestedContentTranslateX = 0f
+        requestedContentTranslateY = 0f
+        contentContainer.translationX = 0f
+        contentContainer.translationY = 0f
+        outlineLeft = 0
+        outlineTop = 0
+        outlineRight = 0
+        outlineBottom = 0
         requestedImportantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_AUTO
         applyRequestedGeometry()
     }

package/android/src/main/java/com/smoothclipview/SmoothClipViewManager.kt

@@ -1,5 +1,6 @@
 package com.smoothclipview
 
+import android.view.View
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
@@ -20,10 +21,21 @@ class SmoothClipViewManager : ViewGroupManager<SmoothClipView>(),
         var width: Double = 0.0,
         var height: Double = 0.0,
         var radius: Double = 0.0,
+        var contentTranslateX: Double = 0.0,
+        var contentTranslateY: Double = 0.0,
+        var driverId: Double = 0.0,
+        // Whether any prop setter ran in the current update transaction.
+        var dirty: Boolean = false,
     )
 
+    // Sticky per-view prop state: Fabric only delivers changed props, so a
+    // transaction touching one initialClip* prop must keep every other value
+    // — including driverId — from earlier transactions.
     private val pendingInitialClips = java.util.WeakHashMap<SmoothClipView, PendingInitialClip>()
 
+    private fun pending(view: SmoothClipView): PendingInitialClip =
+        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.also { it.dirty = true }
+
     override fun getName(): String = NAME
 
     override fun getDelegate(): ViewManagerDelegate<SmoothClipView> = delegate
@@ -31,6 +43,25 @@ class SmoothClipViewManager : ViewGroupManager<SmoothClipView>(),
     override fun createViewInstance(context: ThemedReactContext): SmoothClipView =
         SmoothClipView(context).also { pendingInitialClips[it] = PendingInitialClip() }
 
+    @ReactProp(name = "driverId")
+    override fun setDriverId(view: SmoothClipView, value: Double) {
+        pending(view).driverId = value
+    }
+
+    override fun addView(parent: SmoothClipView, child: View, index: Int) {
+        parent.contentContainer.addView(child, index)
+    }
+
+    override fun getChildCount(parent: SmoothClipView): Int =
+        parent.contentContainer.childCount
+
+    override fun getChildAt(parent: SmoothClipView, index: Int): View =
+        parent.contentContainer.getChildAt(index)
+
+    override fun removeViewAt(parent: SmoothClipView, index: Int) {
+        parent.contentContainer.removeViewAt(index)
+    }
+
     override fun setImportantForAccessibility(
         view: SmoothClipView,
         importantForAccessibility: String?,
@@ -41,27 +72,37 @@ class SmoothClipViewManager : ViewGroupManager<SmoothClipView>(),
 
     @ReactProp(name = "initialClipX")
     override fun setInitialClipX(view: SmoothClipView, value: Double) {
-        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.x = value
+        pending(view).x = value
     }
 
     @ReactProp(name = "initialClipY")
     override fun setInitialClipY(view: SmoothClipView, value: Double) {
-        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.y = value
+        pending(view).y = value
     }
 
     @ReactProp(name = "initialClipWidth")
     override fun setInitialClipWidth(view: SmoothClipView, value: Double) {
-        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.width = value
+        pending(view).width = value
     }
 
     @ReactProp(name = "initialClipHeight")
     override fun setInitialClipHeight(view: SmoothClipView, value: Double) {
-        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.height = value
+        pending(view).height = value
     }
 
     @ReactProp(name = "initialClipRadius")
     override fun setInitialClipRadius(view: SmoothClipView, value: Double) {
-        pendingInitialClips.getOrPut(view) { PendingInitialClip() }.radius = value
+        pending(view).radius = value
+    }
+
+    @ReactProp(name = "initialContentTranslateX")
+    override fun setInitialContentTranslateX(view: SmoothClipView, value: Double) {
+        pending(view).contentTranslateX = value
+    }
+
+    @ReactProp(name = "initialContentTranslateY")
+    override fun setInitialContentTranslateY(view: SmoothClipView, value: Double) {
+        pending(view).contentTranslateY = value
     }
 
     override fun setClipGeometry(
@@ -72,28 +113,84 @@ class SmoothClipViewManager : ViewGroupManager<SmoothClipView>(),
         height: Double,
         radius: Double,
     ) {
-        pendingInitialClips.remove(view)
+        view.commandIsAuthoritative = true
         view.setClipGeometryDip(x, y, width, height, radius)
     }
 
+    override fun setClipPresentation(
+        view: SmoothClipView,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        radius: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+    ) {
+        view.commandIsAuthoritative = true
+        view.setClipPresentationDip(
+            x,
+            y,
+            width,
+            height,
+            radius,
+            contentTranslateX,
+            contentTranslateY,
+        )
+    }
+
     override fun onAfterUpdateTransaction(view: SmoothClipView) {
         super.onAfterUpdateTransaction(view)
-        val initial = pendingInitialClips.remove(view)
-        if (initial == null) {
+        val initial = pendingInitialClips[view]
+        if (initial == null || !initial.dirty) {
             view.reapplyClipPresentation()
-        } else {
-            view.setClipGeometryDip(
+            return
+        }
+        initial.dirty = false
+        if (view.boundDriverId != 0.0 && view.boundDriverId != initial.driverId) {
+            // The view moved to a different driver: leave the old driver's
+            // fanout before joining the new one.
+            SmoothClipBindings.nativeUnregisterView(view.boundDriverId, view)
+        }
+        view.boundDriverId = initial.driverId
+        if (initial.driverId != 0.0) {
+            SmoothClipBindings.nativeRegisterView(
+                initial.driverId,
+                view,
                 initial.x,
                 initial.y,
                 initial.width,
                 initial.height,
                 initial.radius,
+                initial.contentTranslateX,
+                initial.contentTranslateY,
+                view.densityScale(),
+                view.width.toDouble(),
+                view.height.toDouble(),
             )
+        } else if (!view.commandIsAuthoritative) {
+            // Command-driven mode (driverId 0): the initial props are the only
+            // source of the first clip, so apply them directly.
+            view.setClipPresentationDip(
+                initial.x,
+                initial.y,
+                initial.width,
+                initial.height,
+                initial.radius,
+                initial.contentTranslateX,
+                initial.contentTranslateY,
+            )
+        } else {
+            view.reapplyClipPresentation()
         }
     }
 
     override fun onDropViewInstance(view: SmoothClipView) {
         pendingInitialClips.remove(view)
+        if (view.boundDriverId != 0.0) {
+            SmoothClipBindings.nativeUnregisterView(view.boundDriverId, view)
+            view.boundDriverId = 0.0
+        }
         view.resetClipState()
         super.onDropViewInstance(view)
     }