merge upstreamdevelopment

1 files changed, 124 insertions, 248 deletions

diff --git a/morphic.js b/morphic.js
index 8b22f1b..f359bb3 100644
--- a/morphic.js
+++ b/morphic.js
@@ -528,7 +528,7 @@
     whose "isTemplate" flag is false, in other words: a non-template.
 
     When creating a copy from a template, the copy's
-    
+
         reactToTemplateCopy
 
     is invoked, if it is present.
@@ -828,13 +828,13 @@
             // use context to paint stuff here
         };
 
-    If your new morph stores or references other morphs outside of the
-    submorph tree in other properties, be sure to also override the
+    If your new morph stores or references to other morphs outside of
+    the submorph tree in other properties, be sure to also override the
     default
 
-        copyRecordingReferences()
+        updateReferences()
 
-    method accordingly if you want it to support duplication.
+    method if you want it to support duplication.
 
 
     (6) development and user modes
@@ -1036,7 +1036,7 @@
     ----------------------
     Joe Otto found and fixed many early bugs and taught me some tricks.
     Nathan Dinsmore contributed mouse wheel scrolling, cached
-    background texture handling and countless bug fixes.
+    background texture handling, countless bug fixes and optimizations.
     Ian Reynolds contributed backspace key handling for Chrome.
     Davide Della Casa contributed performance optimizations for Firefox.
 
@@ -1048,7 +1048,7 @@
 /*global window, HTMLCanvasElement, getMinimumFontHeight, FileReader, Audio,
 FileList, getBlurredShadowSupport*/
 
-var morphicVersion = '2015-May-01';
+var morphicVersion = '2015-June-26';
 var modules = {}; // keep track of additional loaded modules
 var useBlurredShadows = getBlurredShadowSupport(); // check for Chrome-bug
 
@@ -1243,19 +1243,9 @@ function getDocumentPositionOf(aDOMelement) {
     return pos;
 }
 
-function clone(target) {
-    // answer a new instance of target's type
-    if (typeof target === 'object') {
-        var Clone = function () {nop(); };
-        Clone.prototype = target;
-        return new Clone();
-    }
-    return target;
-}
-
 function copy(target) {
     // answer a shallow copy of target
-    var value, c, property;
+    var value, c, property, keys, l, i;
 
     if (typeof target !== 'object') {
         return target;
@@ -1266,18 +1256,16 @@ function copy(target) {
     }
     if (target instanceof target.constructor &&
             target.constructor !== Object) {
-        c = clone(target.constructor.prototype);
-        for (property in target) {
-            if (Object.prototype.hasOwnProperty.call(target, property)) {
-                c[property] = target[property];
-            }
+        c = Object.create(target.constructor.prototype);
+        keys = Object.keys(target);
+        for (l = keys.length, i = 0; i < l; i += 1) {
+            property = keys[i];
+            c[property] = target[property];
         }
     } else {
         c = {};
         for (property in target) {
-            if (!c[property]) {
-                c[property] = target[property];
-            }
+            c[property] = target[property];
         }
     }
     return c;
@@ -2212,7 +2200,7 @@ function Morph() {
 
 // Morph initialization:
 
-Morph.prototype.init = function () {
+Morph.prototype.init = function (noDraw) {
     Morph.uber.init.call(this);
     this.isMorph = true;
     this.bounds = new Rectangle(0, 0, 50, 40);
@@ -2225,7 +2213,7 @@ Morph.prototype.init = function () {
     this.isTemplate = false;
     this.acceptsDrops = false;
     this.noticesTransparentClick = false;
-    this.drawNew();
+    if (!noDraw) {this.drawNew(); }
     this.fps = 0;
     this.customContextMenu = null;
     this.lastTime = Date.now();
@@ -2411,19 +2399,19 @@ Morph.prototype.visibleBounds = function () {
 // Morph accessing - simple changes:
 
 Morph.prototype.moveBy = function (delta) {
-    this.changed();
-    this.bounds = this.bounds.translateBy(delta);
-    this.children.forEach(function (child) {
-        child.moveBy(delta);
-    });
-    this.changed();
+    this.fullChanged();
+    this.silentMoveBy(delta);
+    this.fullChanged();
 };
 
 Morph.prototype.silentMoveBy = function (delta) {
+    var children = this.children,
+        i = children.length;
     this.bounds = this.bounds.translateBy(delta);
-    this.children.forEach(function (child) {
-        child.silentMoveBy(delta);
-    });
+    // ugly optimization avoiding forEach()
+    for (i; i > 0; i -= 1) {
+        children[i - 1].silentMoveBy(delta);
+    }
 };
 
 Morph.prototype.setPosition = function (aPoint) {
@@ -2899,7 +2887,7 @@ Morph.prototype.fullChanged = function () {
 };
 
 Morph.prototype.childChanged = function () {
-    // react to a  change in one of my children,
+    // react to a change in one of my children,
     // default is to just pass this message on upwards
     // override this method for Morphs that need to adjust accordingly
     if (this.parent) {
@@ -2936,6 +2924,18 @@ Morph.prototype.addBack = function (aMorph) {
     this.addChildFirst(aMorph);
 };
 
+Morph.prototype.topMorphAt = function (point) {
+    var i, result;
+    if (!this.isVisible) {return null; }
+    for (i = this.children.length - 1; i >= 0; i -= 1) {
+        result = this.children[i].topMorphAt(point);
+        if (result) {return result; }
+    }
+    return this.bounds.containsPoint(point) &&
+        (this.noticesTransparentClick || !this.isTransparentAt(point)) ? this
+              : null;
+};
+
 Morph.prototype.topMorphSuchThat = function (predicate) {
     var next;
     if (predicate.call(null, this)) {
@@ -2951,30 +2951,6 @@ Morph.prototype.topMorphSuchThat = function (predicate) {
     return null;
 };
 
-Morph.prototype.morphAt = function (aPoint) {
-    var morphs = this.allChildren().slice(0).reverse(),
-        result = null;
-    morphs.forEach(function (m) {
-        if (m.fullBounds().containsPoint(aPoint) &&
-                (result === null)) {
-            result = m;
-        }
-    });
-    return result;
-};
-
-/*
-    alternative -  more elegant and possibly more
-    performant - solution for morphAt.
-    Has some issues, commented out for now
-
-Morph.prototype.morphAt = function (aPoint) {
-    return this.topMorphSuchThat(function (m) {
-        return m.fullBounds().containsPoint(aPoint);
-    });
-};
-*/
-
 Morph.prototype.overlappedMorphs = function () {
     //exclude the World
     var world = this.world(),
@@ -3046,45 +3022,54 @@ Morph.prototype.fullCopy = function () {
     Other properties are also *shallow* copied, so you must override
     to deep copy Arrays and (complex) Objects
     */
-    var dict = {}, c;
-    c = this.copyRecordingReferences(dict);
+    var map = new Map(), c;
+    c = this.copyRecordingReferences(map);
     c.forAllChildren(function (m) {
-        m.updateReferences(dict);
+        m.updateReferences(map);
     });
     return c;
 };
 
-Morph.prototype.copyRecordingReferences = function (dict) {
+Morph.prototype.copyRecordingReferences = function (map) {
     /*
     Recursively copy this entire composite morph, recording the
     correspondence between old and new morphs in the given dictionary.
     This dictionary will be used to update intra-composite references
     in the copy. See updateReferences().
-    Note: This default implementation copies ONLY morphs in the
-    submorph hierarchy. If a morph stores morphs in other properties
-    that it wants to copy, then it should override this method to do so.
-    The same goes for morphs that contain other complex data that
-    should be copied when the morph is duplicated.
+
+    Note: This default implementation copies ONLY morphs. If a morph
+    stores morphs in other properties that it wants to copy, then it
+    should override this method to do so. The same goes for morphs that
+    contain other complex data that should be copied when the morph is
+    duplicated.
     */
     var c = this.copy();
-    dict[this] = c;
+    map.set(this, c);
     this.children.forEach(function (m) {
-        c.add(m.copyRecordingReferences(dict));
+        c.add(m.copyRecordingReferences(map));
     });
     return c;
 };
 
-Morph.prototype.updateReferences = function (dict) {
+Morph.prototype.updateReferences = function (map) {
     /*
     Update intra-morph references within a composite morph that has
     been copied. For example, if a button refers to morph X in the
     orginal composite then the copy of that button in the new composite
     should refer to the copy of X in new composite, not the original X.
     */
-    var property;
-    for (property in this) {
-        if (this[property] && this[property].isMorph && dict[property]) {
-            this[property] = dict[property];
+    var properties = Object.keys(this),
+        l = properties.length,
+        property,
+        value,
+        reference,
+        i;
+    for (i = 0; i < l; i += 1) {
+        property = properties[i];
+        value = this[property];
+        if (value && value.isMorph) {
+            reference = map.get(value);
+            if (reference) { this[property] = reference; }
         }
     }
 };
@@ -3155,9 +3140,7 @@ Morph.prototype.slideBackTo = function (situation, inSteps) {
 
     this.fps = 0;
     this.step = function () {
-        myself.fullChanged();
-        myself.silentMoveBy(new Point(xStep, yStep));
-        myself.fullChanged();
+        myself.moveBy(new Point(xStep, yStep));
         stepCount += 1;
         if (stepCount === steps) {
             situation.origin.add(myself);
@@ -3706,6 +3689,10 @@ function ShadowMorph() {
     this.init();
 }
 
+ShadowMorph.prototype.topMorphAt = function () {
+    return null;
+};
+
 // HandleMorph ////////////////////////////////////////////////////////
 
 // I am a resize / move handle that can be attached to any Morph
@@ -3923,20 +3910,6 @@ HandleMorph.prototype.mouseLeave = function () {
     this.changed();
 };
 
-// HandleMorph duplicating:
-
-HandleMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = HandleMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.target && dict[this.target]) {
-        c.target = (dict[this.target]);
-    }
-    return c;
-};
-
 // HandleMorph menu:
 
 HandleMorph.prototype.attach = function () {
@@ -4260,20 +4233,6 @@ ColorPaletteMorph.prototype.updateTarget = function () {
     }
 };
 
-// ColorPaletteMorph duplicating:
-
-ColorPaletteMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = ColorPaletteMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.target && dict[this.target]) {
-        c.target = (dict[this.target]);
-    }
-    return c;
-};
-
 // ColorPaletteMorph menu:
 
 ColorPaletteMorph.prototype.developersMenu = function () {
@@ -5840,23 +5799,6 @@ SliderMorph.prototype.updateTarget = function () {
     }
 };
 
-// SliderMorph duplicating:
-
-SliderMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = SliderMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.target && dict[this.target]) {
-        c.target = (dict[this.target]);
-    }
-    if (c.button && dict[this.button]) {
-        c.button = (dict[this.button]);
-    }
-    return c;
-};
-
 // SliderMorph menu:
 
 SliderMorph.prototype.developersMenu = function () {
@@ -6563,7 +6505,7 @@ InspectorMorph.prototype.setExtent = function (aPoint) {
     this.fixLayout();
 };
 
-//InspectorMorph editing ops:
+// InspectorMorph editing ops:
 
 InspectorMorph.prototype.save = function () {
     var txt = this.detail.contents.children[0].text.toString(),
@@ -6653,6 +6595,15 @@ InspectorMorph.prototype.step = function () {
     this.fixLayout();
 };
 
+// InspectorMorph duplicating:
+
+InspectorMorph.prototype.updateReferences = function (map) {
+    var active = this.list.activeIndex();
+    InspectorMorph.uber.updateReferences.call(this, map);
+    this.buildPanes();
+    this.list.activateIndex(active);
+};
+
 // MenuMorph ///////////////////////////////////////////////////////////
 
 // MenuMorph: referenced constructors
@@ -7024,7 +6975,7 @@ StringMorph.prototype.init = function (
     this.markedBackgoundColor = new Color(60, 60, 120);
 
     // initialize inherited properties:
-    StringMorph.uber.init.call(this);
+    StringMorph.uber.init.call(this, true);
 
     // override inherited properites:
     this.color = color || new Color(0, 0, 0);
@@ -7402,6 +7353,11 @@ StringMorph.prototype.selectionStartSlot = function () {
 };
 
 StringMorph.prototype.clearSelection = function () {
+    if (!this.currentlySelecting &&
+            this.startMark === 0 &&
+            this.endMark === 0) {
+        return;
+    }
     this.currentlySelecting = false;
     this.startMark = 0;
     this.endMark = 0;
@@ -8141,20 +8097,6 @@ TriggerMorph.prototype.createLabel = function () {
     this.add(this.label);
 };
 
-// TriggerMorph duplicating:
-
-TriggerMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = TriggerMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.label && dict[this.label]) {
-        c.label = (dict[this.label]);
-    }
-    return c;
-};
-
 // TriggerMorph action:
 
 TriggerMorph.prototype.trigger = function () {
@@ -8500,15 +8442,19 @@ FrameMorph.prototype.fullDrawOn = function (aCanvas, aRect) {
     });
 };
 
-// FrameMorph scrolling optimization:
+// FrameMorph navigation:
 
-FrameMorph.prototype.moveBy = function (delta) {
-    this.changed();
-    this.bounds = this.bounds.translateBy(delta);
-    this.children.forEach(function (child) {
-        child.silentMoveBy(delta);
-    });
-    this.changed();
+FrameMorph.prototype.topMorphAt = function (point) {
+    var i, result;
+    if (!(this.isVisible && this.bounds.containsPoint(point))) {
+        return null;
+    }
+    for (i = this.children.length - 1; i >= 0; i -= 1) {
+        result = this.children[i].topMorphAt(point);
+        if (result) {return result; }
+    }
+    return this.noticesTransparentClick ||
+        !this.isTransparentAt(point) ? this : null;
 };
 
 // FrameMorph scrolling support:
@@ -8600,20 +8546,6 @@ FrameMorph.prototype.reactToGrabOf = function () {
     this.adjustBounds();
 };
 
-// FrameMorph duplicating:
-
-FrameMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = FrameMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.frame && dict[this.scrollFrame]) {
-        c.frame = (dict[this.scrollFrame]);
-    }
-    return c;
-};
-
 // FrameMorph menus:
 
 FrameMorph.prototype.developersMenu = function () {
@@ -8958,32 +8890,23 @@ ScrollFrameMorph.prototype.mouseScroll = function (y, x) {
 
 // ScrollFrameMorph duplicating:
 
-ScrollFrameMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = ScrollFrameMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.contents && dict[this.contents]) {
-        c.contents = (dict[this.contents]);
-    }
-    if (c.hBar && dict[this.hBar]) {
-        c.hBar = (dict[this.hBar]);
-        c.hBar.action = function (num) {
-            c.contents.setPosition(
-                new Point(c.left() - num, c.contents.position().y)
+ScrollFrameMorph.prototype.updateReferences = function (map) {
+    var myself = this;
+    ScrollFrameMorph.uber.updateReferences.call(this, map);
+    if (this.hBar) {
+        this.hBar.action = function (num) {
+            myself.contents.setPosition(
+                new Point(myself.left() - num, myself.contents.position().y)
             );
         };
     }
-    if (c.vBar && dict[this.vBar]) {
-        c.vBar = (dict[this.vBar]);
-        c.vBar.action = function (num) {
-            c.contents.setPosition(
-                new Point(c.contents.position().x, c.top() - num)
+    if (this.vBar) {
+        this.vBar.action = function (num) {
+            myself.contents.setPosition(
+                new Point(myself.contents.position().x, myself.top() - num)
             );
         };
     }
-    return c;
 };
 
 // ScrollFrameMorph menu:
@@ -9147,6 +9070,18 @@ ListMorph.prototype.setExtent = function (aPoint) {
     ListMorph.uber.setExtent.call(this, aPoint);
 };
 
+ListMorph.prototype.activeIndex = function () {
+    return this.listContents.children.indexOf(this.active);
+};
+
+ListMorph.prototype.activateIndex = function (idx) {
+    var item = this.listContents.children[idx];
+    if (!item) {return; }
+    item.image = item.pressImage;
+    item.changed();
+    item.trigger();
+};
+
 // StringFieldMorph ////////////////////////////////////////////////////
 
 // StringFieldMorph inherit from FrameMorph:
@@ -9243,20 +9178,6 @@ StringFieldMorph.prototype.mouseClickLeft = function (pos) {
     }
 };
 
-// StringFieldMorph duplicating:
-
-StringFieldMorph.prototype.copyRecordingReferences = function (dict) {
-    // inherited, see comment in Morph
-    var c = StringFieldMorph.uber.copyRecordingReferences.call(
-        this,
-        dict
-    );
-    if (c.text && dict[this.text]) {
-        c.text = (dict[this.text]);
-    }
-    return c;
-};
-
 // BouncerMorph ////////////////////////////////////////////////////////
 
 // I am a Demo of a stepping custom Morph
@@ -9384,54 +9305,18 @@ HandMorph.prototype.changed = function () {
     if (this.world !== null) {
         b = this.fullBounds();
         if (!b.extent().eq(new Point())) {
-            this.world.broken.push(this.fullBounds().spread());
+            this.world.broken.push(b.spread());
         }
     }
-
 };
 
-// HandMorph navigation:
-
-HandMorph.prototype.morphAtPointer = function () {
-    var morphs = this.world.allChildren().slice(0).reverse(),
-        myself = this,
-        result = null;
-
-    morphs.forEach(function (m) {
-        if (m.visibleBounds().containsPoint(myself.bounds.origin) &&
-                result === null &&
-                m.isVisible &&
-                (m.noticesTransparentClick ||
-                    (!m.isTransparentAt(myself.bounds.origin))) &&
-                (!(m instanceof ShadowMorph)) &&
-                m.allParents().every(function (each) {
-                    return each.isVisible;
-                })) {
-            result = m;
-        }
-    });
-    if (result !== null) {
-        return result;
-    }
-    return this.world;
-};
+HandMorph.prototype.fullChanged = HandMorph.prototype.changed;
 
-/*
-    alternative -  more elegant and possibly more
-    performant - solution for morphAtPointer.
-    Has some issues, commented out for now
+// HandMorph navigation:
 
 HandMorph.prototype.morphAtPointer = function () {
-    var myself = this;
-    return this.world.topMorphSuchThat(function (m) {
-        return m.visibleBounds().containsPoint(myself.bounds.origin) &&
-            m.isVisible &&
-            (m.noticesTransparentClick ||
-                (! m.isTransparentAt(myself.bounds.origin))) &&
-            (! (m instanceof ShadowMorph));
-    });
+    return this.world.topMorphAt(this.bounds.origin) || this.world;
 };
-*/
 
 HandMorph.prototype.allMorphsAtPointer = function () {
     var morphs = this.world.allChildren(),
@@ -9971,16 +9856,6 @@ HandMorph.prototype.destroyTemporaries = function () {
     });
 };
 
-// HandMorph dragging optimization
-
-HandMorph.prototype.moveBy = function (delta) {
-    Morph.prototype.trackChanges = false;
-    HandMorph.uber.moveBy.call(this, delta);
-    Morph.prototype.trackChanges = true;
-    this.fullChanged();
-};
-
-
 // WorldMorph //////////////////////////////////////////////////////////
 
 // I represent the <canvas> element
@@ -10009,6 +9884,7 @@ WorldMorph.prototype.init = function (aCanvas, fillPage) {
     this.isDraggable = false;
     this.currentKey = null; // currently pressed key code
     this.worldCanvas = aCanvas;
+    this.noticesTransparentClick = true;
 
     // additional properties:
     this.stamp = Date.now(); // reference in multi-world setups