Custom block templates also visited, both options available from context menu

blocks.js

@@ -2394,10 +2394,9 @@ BlockMorph.prototype.userMenu = function () {
                 'refactorThisVar'
             );
         }
-        return menu;
+    } else { 
-    }  
-
         menu.addLine();
+    }
 
     if (this.selector === 'reportGetVar') {
         blck = this.fullCopy();
@@ -2405,6 +2404,9 @@ BlockMorph.prototype.userMenu = function () {
         menu.addItem(
             'rename just here...',
             function () {
+                if (this.isTemplate) {
+                    myself.refactorThisVar(true); // just the template
+                } else {
                     new DialogBoxMorph(
                         myself,
                         myself.userSetSpec,
@@ -2417,7 +2419,11 @@ BlockMorph.prototype.userMenu = function () {
                         InputSlotMorph.prototype.getVarNamesDict.call(myself)
                     );
                 }
+            }
         );
+        if (this.isTemplate) {
+            return menu;
+        }
     } else if (SpriteMorph.prototype.blockAlternatives[this.selector]) {
         menu.addItem(
             'relabel...',
@@ -3064,14 +3070,15 @@ BlockMorph.prototype.codeMappingHeader = function () {
 
 // Variable refactoring
 
-BlockMorph.prototype.refactorThisVar = function () {
+BlockMorph.prototype.refactorThisVar = function (justTheTemplate) {
-    // Rename all occurrences of the variable this block is holding, taking care of its
+    // Rename all occurrences of the variable this block is holding,
-    // lexical scope
+    // taking care of its lexical scope
 
-    var oldName = this.blockSpec,
+    var myself = this,
+        oldName = this.blockSpec,
         receiver = this.receiver(),
         ide = this.parentThatIsA(IDE_Morph),
-        stage = receiver.parentThatIsA(StageMorph),
+        stage = ide.stage,
         oldWatcher = receiver.findVariableWatcher(oldName),
         oldValue, newWatcher;
 
@@ -3082,6 +3089,10 @@ BlockMorph.prototype.refactorThisVar = function () {
                 
                 if (this.parent instanceof SyntaxElementMorph) {
                     // script var
+                    if (justTheTemplate) {
+                        myself.userSetSpec(newName);
+                        return;
+                    }
                     definer = this.parentThatIsA(CommandBlockMorph);
                     if (definer.definesScriptVariable(newName)) {
                         varExistsError();
@@ -3098,11 +3109,23 @@ BlockMorph.prototype.refactorThisVar = function () {
                         varExistsError('as a global variable');
                         return;
                     } else {
+                        oldValue = receiver.variables.getVar(oldName);
+                        receiver.deleteVariable(oldName);
+                        receiver.addVariable(newName, false);
+                        receiver.variables.setVar(newName, oldValue);
+
+                        if (oldWatcher && oldWatcher.isVisible) {
+                            newWatcher = receiver.toggleVariableWatcher(newName, false);
+                            newWatcher.setPosition(oldWatcher.position());
+                        }
+
+                        if (!justTheTemplate) {
                             receiver.refactorVariableInstances(oldName, newName, false);
                             receiver.customBlocks.forEach(function (eachBlock) {
-                            eachBlock.definition.body.expression.refactorVarInStack(oldName, newName);
+                                eachBlock.body.expression.refactorVarInStack(oldName, newName);
                             });
                         }
+                    }
                 } else {
                     // global var
                     if (!isNil(ide.globalVariables.vars[newName])) {
@@ -3112,29 +3135,39 @@ BlockMorph.prototype.refactorThisVar = function () {
                             detect(
                                 stage.children,
                                 function (any) {
-                                    return any.hasSpriteVariable(newName);
+                                    return any instanceof SpriteMorph && 
+                                        any.hasSpriteVariable(newName);
                                 })
                             ) {
                         varExistsError('as a sprite local variable');
                         return;
                     } else {
-                        oldValue = ide.globalVariables.vars[oldName];
+                        oldValue = ide.globalVariables.getVar(oldName);
                         stage.deleteVariable(oldName);
                         stage.addVariable(newName, true);
-                        ide.globalVariables.vars[newName] = oldValue;
+                        ide.globalVariables.setVar(newName, oldValue);
 
+                        if (oldWatcher && oldWatcher.isVisible) {
+                            newWatcher = receiver.toggleVariableWatcher(newName, true);
+                            newWatcher.setPosition(oldWatcher.position());
+                        }
+
+                        if (!justTheTemplate) {
                             stage.refactorVariableInstances(oldName, newName, true);
+                            stage.globalBlocks.forEach(function (eachBlock) {
+                                eachBlock.body.expression.refactorVarInStack(oldName, newName);
+                            });
+
                             stage.forAllChildren(function (child) {
                                 if (child instanceof SpriteMorph) {
                                     child.refactorVariableInstances(oldName, newName, true);
+                                    child.customBlocks.forEach(function (eachBlock) {
+                                        eachBlock.body.expression.refactorVarInStack(oldName, newName);
+                                    });
                                 }
                             });
                         }
                     }
-
-                if (oldWatcher && oldWatcher.isVisible) {
-                    newWatcher = stage.toggleVariableWatcher(newName, true);
-                    newWatcher.setPosition(oldWatcher.position());
                 }
 
                 ide.flushBlocksCache('variables');

objects.js

@@ -4821,22 +4821,10 @@ SpriteMorph.prototype.hasSpriteVariable = function (varName) {
 // Variable refactoring
 
 SpriteMorph.prototype.refactorVariableInstances = function (oldName, newName, isGlobal) {
-    var oldValue;
-
     if (isGlobal && this.hasSpriteVariable(oldName)) {
         return;
     }
 
-    if (!isGlobal) {
-        oldValue = this.variables.vars[oldName];
-        this.deleteVariable(oldName);
-        this.addVariable(newName, false);
-        this.variables.vars[newName] = oldValue;
-        this.blocksCache['variables'] = null;
-        this.paletteCache['variables'] = null;
-        this.parentThatIsA(IDE_Morph).refreshPalette();
-    }
-
     this.scripts.children.forEach(function (child) {
         if (child instanceof BlockMorph) {
             child.refactorVarInStack(oldName, newName);