1 files changed, 72 insertions, 410 deletions

diff --git a/node_modules/montage/ui/flow.reel/flow.js b/node_modules/montage/ui/flow.reel/flow.js
index 2137f782..fa676a67 100644
--- a/node_modules/montage/ui/flow.reel/flow.js
+++ b/node_modules/montage/ui/flow.reel/flow.js
@@ -10,74 +10,6 @@ var Montage = require("montage").Montage,
 
 var Flow = exports.Flow = Montage.create(Component, {
 
-    _splinePaths: {
-        enumerable: false,
-        value: null
-    },
-
-    splinePaths: {
-        enumerable: false,
-        get: function () {
-            if (!this._splinePaths) {
-                this._splinePaths = [];
-            }
-            return this._splinePaths;
-        },
-        set: function (value) {
-            this._splinePaths = value;
-        }
-    },
-
-    appendPath: {
-        value: function (path) {
-            var splinePath = Object.create(FlowBezierSpline),
-                pathKnots = path.knots,
-                length = path.knots.length,
-                knots = [],
-                nextHandlers = [],
-                previousHandlers = [],
-                densities = [],
-                i;
-
-            for (i = 0; i < length; i++) {
-                knots[i] = pathKnots[i].knotPosition;
-                previousHandlers[i] = pathKnots[i].previousHandlerPosition;
-                nextHandlers[i] = pathKnots[i].nextHandlerPosition;
-                densities[i] = pathKnots[i].previousDensity; // TODO: implement previous/next density
-                // TODO: add rotations, arbitrary CSS and units
-            }
-            splinePath.knots = knots;
-            splinePath.previousHandlers = previousHandlers;
-            splinePath.nextHandlers = nextHandlers;
-            splinePath.densities = densities;
-            splinePath._computeDensitySummation();
-            this.splinePaths.push(splinePath);
-            this._paths.push(path);
-        }
-    },
-
-    _paths: {
-        enumerable: false,
-        value: null
-    },
-
-    paths: { // TODO: listen for changes?
-        get: function () {
-            return this._paths;
-        },
-        set: function (value) {
-            var length = value.length,
-                i;
-
-            if (length) {
-                this._paths = [];
-                for (i = 0; i < length; i++) {
-                    this.appendPath(value[i]);
-                }
-            }
-        }
-    },
-
     _cameraPosition: {
         enumerable: false,
         value: [0, 0, 800]
@@ -144,171 +76,17 @@ var Flow = exports.Flow = Montage.create(Component, {
         }
     },
 
-    _scrollingTransitionDurationMiliseconds: {
-        enumerable: false,
-        value: 500
-    },
-
-    _scrollingTransitionDuration: {
-        enumerable: false,
-        value: "500ms"
-    },
-
-    scrollingTransitionDuration: { // TODO: think about using the Date Converter
-        get: function () {
-            return this._scrollingTransitionDuration;
-        },
-        set: function (duration) {
-            var durationString = duration + "",
-                length = durationString.length,
-                value;
-
-            if ((length >= 2) && (durationString[length - 1] === "s")) {
-                if ((length >= 3) && (durationString[length - 2] === "m")) {
-                    value = durationString.substr(0, length - 2) - 0;
-                } else {
-                    value = durationString.substr(0, length - 1) * 1000;
-                }
-            } else {
-                value = durationString - 0;
-                durationString += "ms";
-            }
-            if (!isNaN(value) && (this._scrollingTransitionDurationMiliseconds !== value)) {
-                this._scrollingTransitionDurationMiliseconds = value;
-                this._scrollingTransitionDuration = durationString;
-            }
-        }
-    },
-
-    _scrollingTransitionTimingFunctionBezier: {
-        enumerable: false,
-        value: [.25, .1, .25, 1]
-    },
-
-    _scrollingTransitionTimingFunction: {
-        enumerable: false,
-        value: "ease"
-    },
-
-    hasSelectedIndexScrolling: {
+    _splinePath: {
         enumerable: false,
-        value: false
-    },
-
-    selectedIndexScrollingOffset: {
-        enumerable: false,
-        value: 0
-    },
-
-    _handleSelectedIndexesChange: {
-        enumerable: false,
-        value: function (event) {
-            if (this.hasSelectedIndexScrolling && event._plus) {
-                this.startScrollingIndexToOffset(event._plus[0], this.selectedIndexScrollingOffset);
-            }
-        }
-    },
-
-    _timingFunctions: {
-        enumerable: false,
-        value: {
-            "ease": [.25, .1, .25, 1],
-            "linear": [0, 0, 1, 1],
-            "ease-in": [.42, 0, 1, 1],
-            "ease-out": [0, 0, .58, 1],
-            "ease-in-out": [.42, 0, .58, 1]
-        }
+        value: null
     },
 
-    scrollingTransitionTimingFunction: {
+    splinePath: {
         get: function () {
-            return this._scrollingTransitionTimingFunction;
+            return this._splinePath;
         },
-        set: function (timingFunction) {
-            var string = timingFunction + "";
-
-            if (this._timingFunctions.hasOwnProperty(string)) {
-                this._scrollingTransitionTimingFunction = string;
-                this._scrollingTransitionTimingFunctionBezier = this._timingFunctions[string];
-            } else {
-                if ((string.substr(0, 13) === "cubic-bezier(") && (string.substr(string.length - 1, 1) === ")")) {
-                    var bezier = string.substr(13, string.length - 14).split(","),
-                        i;
-
-                    if (bezier.length === 4) {
-                        for (i = 0; i < 4; i++) {
-                            bezier[i] -= 0;
-                            if (isNaN(bezier[i])) {
-                                return;
-                            }
-                        }
-                        if (bezier[0] < 0) {
-                            bezier[0] = 0;
-                        } else {
-                            if (bezier[0] > 1) {
-                                bezier[0] = 1;
-                            }
-                        }
-                        if (bezier[2] < 0) {
-                            bezier[2] = 0;
-                        } else {
-                            if (bezier[2] > 1) {
-                                bezier[2] = 1;
-                            }
-                        }
-                        // TODO: check it is not the same bezier
-                        this._scrollingTransitionTimingFunction = "cubic-bezier(" + bezier + ")";
-                        this._scrollingTransitionTimingFunctionBezier = bezier;
-                    }
-                }
-            }
-        }
-    },
-
-    _computeCssCubicBezierValue: {
-        enumerable: false,
-        value: function (x, bezier) {
-            var t = .5,
-                step = .25,
-                t2,
-                k,
-                i;
-
-            for (i = 0; i < 20; i++) { // TODO: optimize with Newton's method or similar
-                t2 = t * t;
-                k = 1 - t;
-                if ((3 * (k * k * t * bezier[0] + k * t2 * bezier[2]) + t2 * t) > x) {
-                    t -= step;
-                } else {
-                    t += step;
+        set: function (value) {
+            this._splinePath = value;