stash _mainAxis and _anchorAxis in fullLayout axis objects

alexcjohnson · alexcjohnson · commit 274526afca78 · 2017-07-13T16:27:55.000-04:00
We could probably use these in other places too, to reduce getFromId calls
diff --git a/src/plot_api/subroutines.js b/src/plot_api/subroutines.js
@@ -172,12 +172,12 @@ exports.lsInner = function(gd) {
             .call(Drawing.setTranslate, xa._offset, ya._offset)
             .call(Drawing.setClipUrl, plotinfo.clipId);
 
-        var xIsFree = xa.anchor === 'free';
+        var xIsFree = !xa._anchorAxis;
         var showFreeX = xIsFree && !freeFinished[xa._id];
         var showBottom = shouldShowLine(xa, ya, 'bottom');
         var showTop = shouldShowLine(xa, ya, 'top');
 
-        var yIsFree = ya.anchor === 'free';
+        var yIsFree = !ya._anchorAxis;
         var showFreeY = yIsFree && !freeFinished[ya._id];
         var showLeft = shouldShowLine(ya, xa, 'left');
         var showRight = shouldShowLine(ya, xa, 'right');
@@ -249,7 +249,7 @@ exports.lsInner = function(gd) {
             showTop ? xLinesYTop : undefined,
             showFreeX ? xLinesYFree : undefined
         ];
-        if(xa.anchor === ya._id) {
+        if(xa._anchorAxis === ya) {
             xa._linepositions[subplot][3] = xa.side === 'top' ?
                 xLinesYTop : xLinesYBottom;
         }
@@ -262,7 +262,7 @@ exports.lsInner = function(gd) {
             showRight ? yLinesXRight : undefined,
             showFreeY ? yLinesXFree : undefined
         ];
-        if(ya.anchor === xa._id) {
+        if(ya._anchorAxis === xa) {
             ya._linepositions[subplot][3] = ya.side === 'right' ?
                 yLinesXRight : yLinesXLeft;
         }
@@ -329,28 +329,24 @@ exports.lsInner = function(gd) {
 };
 
 function shouldShowLine(ax, counterAx, side) {
-    return (ax.anchor === counterAx._id && (ax.mirror || ax.side === side)) ||
+    return (ax._anchorAxis === counterAx && (ax.mirror || ax.side === side)) ||
         ax.mirror === 'all' || ax.mirror === 'allticks' ||
         (ax.mirrors && ax.mirrors[counterAx._id + side]);
 }
 
-function findMainAxis(gd, ax) {
-    return ax.overlaying ? Plotly.Axes.getFromId(gd, ax.overlaying) : ax;
-}
-
 function findCounterAxes(gd, ax, axList) {
     var counterAxes = [];
-    var anchorAx = Plotly.Axes.getFromId(gd, ax.anchor);
+    var anchorAx = ax._anchorAxis;
     if(anchorAx) {
-        var counterMain = findMainAxis(gd, anchorAx);
+        var counterMain = anchorAx._mainAxis;
         if(counterAxes.indexOf(counterMain) === -1) {
             counterAxes.push(counterMain);
-        }
-        for(var i = 0; i < axList.length; i++) {
-            if(axList[i].overlaying === counterMain._id &&
-                counterAxes.indexOf(axList[i]) === -1
-            ) {
-                counterAxes.push(axList[i]);
+            for(var i = 0; i < axList.length; i++) {
+                if(axList[i].overlaying === counterMain._id &&
+                    counterAxes.indexOf(axList[i]) === -1
+                ) {
+                    counterAxes.push(axList[i]);
+                }
             }
         }
     }
@@ -360,7 +356,8 @@ function findCounterAxes(gd, ax, axList) {
 function findLineWidth(gd, axes, side) {
     for(var i = 0; i < axes.length; i++) {
         var ax = axes[i];
-        if(ax.anchor !== 'free' && shouldShowLine(ax, {_id: ax.anchor}, side)) {
+        var anchorAx = ax._anchorAxis;
+        if(anchorAx && shouldShowLine(ax, anchorAx, side)) {
             return Drawing.crispRound(gd, ax.linewidth);
         }
     }
@@ -374,7 +371,7 @@ function findCounterAxisLineWidth(gd, ax, subplotCounterLineWidth,
 
     // find all counteraxes for this one, then of these, find the
     // first one that has a visible line on this side
-    var mainAxis = findMainAxis(gd, ax);
+    var mainAxis = ax._mainAxis;
     var counterAxes = findCounterAxes(gd, mainAxis, axList);
 
     var lineWidth = findLineWidth(gd, counterAxes, side);
diff --git a/src/plots/cartesian/index.js b/src/plots/cartesian/index.js
@@ -242,40 +242,16 @@ function makeSubplotData(gd) {
         var subplot = subplots[i],
             plotinfo = fullLayout._plots[subplot];
 
-        var xa = plotinfo.xaxis,
-            ya = plotinfo.yaxis;
-
-        // is this subplot overlaid on another?
-        // ax.overlaying is the id of another axis of the same
-        // dimension that this one overlays to be an overlaid subplot,
-        // the main plot must exist make sure we're not trying to
-        // overlay on an axis that's already overlaying another
-        var xa2 = axisIds.getFromId(gd, xa.overlaying) || xa;
-        if(xa2 !== xa && xa2.overlaying) {
-            xa2 = xa;
-            xa.overlaying = false;
-        }
-
-        var ya2 = axisIds.getFromId(gd, ya.overlaying) || ya;
-        if(ya2 !== ya && ya2.overlaying) {
-            ya2 = ya;
-            ya.overlaying = false;
-        }
+        var xa = plotinfo.xaxis;
+        var ya = plotinfo.yaxis;
+        var xa2 = xa._mainAxis;
+        var ya2 = ya._mainAxis;
 
         var mainplot = xa2._id + ya2._id;
         if(mainplot !== subplot && subplots.indexOf(mainplot) !== -1) {
             plotinfo.mainplot = mainplot;
             plotinfo.mainplotinfo = fullLayout._plots[mainplot];
             overlays.push(subplot);
-
-            // for now force overlays to overlay completely... so they
-            // can drag together correctly and share backgrounds.
-            // Later perhaps we make separate axis domain and
-            // tick/line domain or something, so they can still share
-            // the (possibly larger) dragger and background but don't
-            // have to both be drawn over that whole domain
-            xa.domain = xa2.domain.slice();
-            ya.domain = ya2.domain.slice();
         }
         else {
             subplotData.push(subplot);
diff --git a/src/plots/plots.js b/src/plots/plots.js
@@ -641,7 +641,9 @@ plots.linkSubplots = function(newFullData, newFullLayout, oldFullData, oldFullLa
 
     var ids = Plotly.Axes.getSubplots(mockGd);
 
-    for(var i = 0; i < ids.length; i++) {
+    var i;
+
+    for(i = 0; i < ids.length; i++) {
         var id = ids[i],
             oldSubplot = oldSubplots[id],
             plotinfo;
@@ -661,6 +663,39 @@ plots.linkSubplots = function(newFullData, newFullLayout, oldFullData, oldFullLa
         plotinfo.xaxis = Plotly.Axes.getFromId(mockGd, id, 'x');
         plotinfo.yaxis = Plotly.Axes.getFromId(mockGd, id, 'y');
     }
+
+    // while we're at it, link overlaying axes to their main axes and
+    // anchored axes to the axes they're anchored to
+    var axList = Plotly.Axes.list(mockGd, null, true);
+    for(i = 0; i < axList.length; i++) {
+        var ax = axList[i];
+        var mainAx = null;
+
+        if(ax.overlaying) {
+            mainAx = Plotly.Axes.getFromId(mockGd, ax.overlaying);
+
+            // you cannot overlay an axis that's already overlaying another
+            if(mainAx && mainAx.overlaying) {
+                ax.overlaying = false;
+                mainAx = null;
+            }
+        }
+        ax._mainAxis = mainAx || ax;
+
+        /*
+         * For now force overlays to overlay completely... so they
+         * can drag together correctly and share backgrounds.
+         * Later perhaps we make separate axis domain and
+         * tick/line domain or something, so they can still share
+         * the (possibly larger) dragger and background but don't
+         * have to both be drawn over that whole domain
+         */
+        if(mainAx) ax.domain = mainAx.domain.slice();
+
+        ax._anchorAxis = ax.anchor === 'free' ?
+            null :
+            Plotly.Axes.getFromId(mockGd, ax.anchor);
+    }
 };
 
 // This function clears any trace attributes with valType: color and
