[270] | 1 | /**
|
---|
| 2 | * @license
|
---|
| 3 | * Visual Blocks Editor
|
---|
| 4 | *
|
---|
| 5 | * Copyright 2012 Google Inc.
|
---|
| 6 | * https://developers.google.com/blockly/
|
---|
| 7 | *
|
---|
| 8 | * Licensed under the Apache License, Version 2.0 (the "License");
|
---|
| 9 | * you may not use this file except in compliance with the License.
|
---|
| 10 | * You may obtain a copy of the License at
|
---|
| 11 | *
|
---|
| 12 | * http://www.apache.org/licenses/LICENSE-2.0
|
---|
| 13 | *
|
---|
| 14 | * Unless required by applicable law or agreed to in writing, software
|
---|
| 15 | * distributed under the License is distributed on an "AS IS" BASIS,
|
---|
| 16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
---|
| 17 | * See the License for the specific language governing permissions and
|
---|
| 18 | * limitations under the License.
|
---|
| 19 | */
|
---|
| 20 |
|
---|
| 21 | /**
|
---|
| 22 | * @fileoverview Utility functions for handling variables.
|
---|
| 23 | * @author fraser@google.com (Neil Fraser)
|
---|
| 24 | */
|
---|
| 25 | using System;
|
---|
| 26 | using System.Collections.Generic;
|
---|
| 27 | using System.Runtime.InteropServices;
|
---|
| 28 | using Bridge;
|
---|
| 29 | using Bridge.Html5;
|
---|
| 30 | using WebMrbc;
|
---|
| 31 |
|
---|
| 32 | namespace WebMrbc
|
---|
| 33 | {
|
---|
| 34 | public class Variables
|
---|
| 35 | {
|
---|
| 36 | /// <summary>
|
---|
| 37 | /// Category to separate variable names from procedures and generated functions.
|
---|
| 38 | /// </summary>
|
---|
| 39 | public string NAME_TYPE = "VARIABLE";
|
---|
| 40 |
|
---|
| 41 | /// <summary>
|
---|
| 42 | /// Common HSV hue for all blocks in this category.
|
---|
| 43 | /// </summary>
|
---|
| 44 | public int HUE = 330;
|
---|
| 45 |
|
---|
| 46 | /// <summary>
|
---|
| 47 | /// Find all user-created variables that are in use in the workspace.
|
---|
| 48 | /// For use by generators.
|
---|
| 49 | /// </summary>
|
---|
| 50 | /// <param name="root">Root block or workspace.</param>
|
---|
| 51 | /// <returns>Array of variable names.</returns>
|
---|
| 52 | public string[] allUsedVariables(Union<Block, Workspace> root)
|
---|
| 53 | {
|
---|
| 54 | Block[] blocks;
|
---|
| 55 | if (Script.Write<bool>("root instanceof Blockly.Block")) {
|
---|
| 56 | // Root is Block.
|
---|
| 57 | blocks = ((Block)root).getDescendants();
|
---|
| 58 | }
|
---|
| 59 | else if (Script.Write<bool>("root instanceof Blockly.Workspace")) {
|
---|
| 60 | // Root is Workspace.
|
---|
| 61 | blocks = ((Workspace)root).getAllBlocks();
|
---|
| 62 | }
|
---|
| 63 | else {
|
---|
| 64 | throw new Exception("Not Block or Workspace: " + root);
|
---|
| 65 | }
|
---|
| 66 | var variableHash = new Dictionary<string, string>();
|
---|
| 67 | // Iterate through every block and add each variable to the hash.
|
---|
| 68 | for (var x = 0; x < blocks.Length; x++) {
|
---|
| 69 | var blockVariables = blocks[x].getVars();
|
---|
| 70 | if (blockVariables != null) {
|
---|
| 71 | for (var y = 0; y < blockVariables.Length; y++) {
|
---|
| 72 | var varName = blockVariables[y];
|
---|
| 73 | // Variable name may be null if the block is only half-built.
|
---|
| 74 | if (varName != null) {
|
---|
| 75 | variableHash[varName.ToLower()] = varName;
|
---|
| 76 | }
|
---|
| 77 | }
|
---|
| 78 | }
|
---|
| 79 | }
|
---|
| 80 | // Flatten the hash into a list.
|
---|
| 81 | var variableList = new string[0];
|
---|
| 82 | foreach (var name in variableHash.Keys) {
|
---|
| 83 | variableList.Push(variableHash[name]);
|
---|
| 84 | }
|
---|
| 85 | return variableList;
|
---|
| 86 | }
|
---|
| 87 |
|
---|
| 88 | /// <summary>
|
---|
| 89 | /// Find all variables that the user has created through the workspace or
|
---|
| 90 | /// toolbox. For use by generators.
|
---|
| 91 | /// </summary>
|
---|
| 92 | /// <param name="root">The workspace to inspect.</param>
|
---|
| 93 | /// <returns>Array of variable names.</returns>
|
---|
| 94 | public string[] allVariables(Workspace root)
|
---|
| 95 | {
|
---|
| 96 | if (Script.Write<bool>("root instanceof Blockly.Block")) {
|
---|
| 97 | // Root is Block.
|
---|
| 98 | App.WriteLine("Deprecated call to Variables.allVariables " +
|
---|
| 99 | "with a block instead of a workspace. You may want " +
|
---|
| 100 | "Variables.allUsedVariables");
|
---|
| 101 | }
|
---|
| 102 | return root.variableList;
|
---|
| 103 | }
|
---|
| 104 |
|
---|
| 105 | /// <summary>
|
---|
| 106 | /// Construct the blocks required by the flyout for the variable category.
|
---|
| 107 | /// </summary>
|
---|
| 108 | /// <param name="workspace">The workspace contianing variables.</param>
|
---|
| 109 | /// <returns>Array of XML block elements.</returns>
|
---|
| 110 | public Element[] flyoutCategory(Workspace workspace)
|
---|
| 111 | {
|
---|
| 112 | var variableList = workspace.variableList;
|
---|
| 113 | Array.Sort(variableList, goog.@string.caseInsensitiveCompare);
|
---|
| 114 |
|
---|
| 115 | var xmlList = new Element[0];
|
---|
| 116 | var button = goog.dom.createDom("button");
|
---|
| 117 | button.SetAttribute("text", Msg.NEW_VARIABLE);
|
---|
| 118 | button.SetAttribute("callbackKey", "CREATE_VARIABLE");
|
---|
| 119 |
|
---|
| 120 | Blockly.registerButtonCallback("CREATE_VARIABLE", (btn) => {
|
---|
| 121 | createVariable(btn.getTargetWorkspace());
|
---|
| 122 | });
|
---|
| 123 |
|
---|
| 124 | xmlList.Push(button);
|
---|
| 125 |
|
---|
| 126 | if (variableList.Length > 0) {
|
---|
| 127 | if (Script.Get(Blockly.Blocks, "variables_set") != null) {
|
---|
| 128 | // <block type="variables_set" gap="20">
|
---|
| 129 | // <field name="VAR">item</field>
|
---|
| 130 | // </block>
|
---|
| 131 | var block = goog.dom.createDom("block");
|
---|
| 132 | block.SetAttribute("type", "variables_set");
|
---|
| 133 | if (Script.Get(Blockly.Blocks, "math_change") != null) {
|
---|
| 134 | block.SetAttribute("gap", "8");
|
---|
| 135 | }
|
---|
| 136 | else {
|
---|
| 137 | block.SetAttribute("gap", "24");
|
---|
| 138 | }
|
---|
| 139 | var field = goog.dom.createDom("field", null, variableList[0]);
|
---|
| 140 | field.SetAttribute("name", "VAR");
|
---|
| 141 | block.AppendChild(field);
|
---|
| 142 | xmlList.Push(block);
|
---|
| 143 | }
|
---|
| 144 | if (Script.Get(Blockly.Blocks, "math_change") != null) {
|
---|
| 145 | // <block type="math_change">
|
---|
| 146 | // <value name="DELTA">
|
---|
| 147 | // <shadow type="math_number">
|
---|
| 148 | // <field name="NUM">1</field>
|
---|
| 149 | // </shadow>
|
---|
| 150 | // </value>
|
---|
| 151 | // </block>
|
---|
| 152 | var block = goog.dom.createDom("block");
|
---|
| 153 | block.SetAttribute("type", "math_change");
|
---|
| 154 | if (Script.Get(Blockly.Blocks, "variables_get") != null) {
|
---|
| 155 | block.SetAttribute("gap", "20");
|
---|
| 156 | }
|
---|
| 157 | var value = goog.dom.createDom("value");
|
---|
| 158 | value.SetAttribute("name", "DELTA");
|
---|
| 159 | block.AppendChild(value);
|
---|
| 160 |
|
---|
| 161 | var field = goog.dom.createDom("field", null, variableList[0]);
|
---|
| 162 | field.SetAttribute("name", "VAR");
|
---|
| 163 | block.AppendChild(field);
|
---|
| 164 |
|
---|
| 165 | var shadowBlock = goog.dom.createDom("shadow");
|
---|
| 166 | shadowBlock.SetAttribute("type", "math_number");
|
---|
| 167 | value.AppendChild(shadowBlock);
|
---|
| 168 |
|
---|
| 169 | var numberField = goog.dom.createDom("field", null, "1");
|
---|
| 170 | numberField.SetAttribute("name", "NUM");
|
---|
| 171 | shadowBlock.AppendChild(numberField);
|
---|
| 172 |
|
---|
| 173 | xmlList.Push(block);
|
---|
| 174 | }
|
---|
| 175 |
|
---|
| 176 | for (var i = 0; i < variableList.Length; i++) {
|
---|
| 177 | if (Script.Get(Blockly.Blocks, "variables_get") != null) {
|
---|
| 178 | // <block type="variables_get" gap="8">
|
---|
| 179 | // <field name="VAR">item</field>
|
---|
| 180 | // </block>
|
---|
| 181 | var block = goog.dom.createDom("block");
|
---|
| 182 | block.SetAttribute("type", "variables_get");
|
---|
| 183 | if (Script.Get(Blockly.Blocks, "variables_set") != null) {
|
---|
| 184 | block.SetAttribute("gap", "8");
|
---|
| 185 | }
|
---|
| 186 | var field = goog.dom.createDom("field", null, variableList[i]);
|
---|
| 187 | field.SetAttribute("name", "VAR");
|
---|
| 188 | block.AppendChild(field);
|
---|
| 189 | xmlList.Push(block);
|
---|
| 190 | }
|
---|
| 191 | }
|
---|
| 192 | }
|
---|
| 193 | return xmlList;
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 | /// <summary>
|
---|
| 197 | /// Return a new variable name that is not yet being used. This will try to
|
---|
| 198 | /// generate single letter variable names in the range 'i' to 'z' to start with.
|
---|
| 199 | /// If no unique name is located it will try 'i' to 'z', 'a' to 'h',
|
---|
| 200 | /// then 'i2' to 'z2' etc. Skip 'l'.
|
---|
| 201 | /// </summary>
|
---|
| 202 | /// <param name="workspace">The workspace to be unique in.</param>
|
---|
| 203 | /// <returns>New variable name.</returns>
|
---|
| 204 | public string generateUniqueName(Workspace workspace)
|
---|
| 205 | {
|
---|
| 206 | var variableList = workspace.variableList;
|
---|
| 207 | var newName = "";
|
---|
| 208 | if (variableList.Length != 0) {
|
---|
| 209 | var nameSuffix = 1;
|
---|
| 210 | var letters = "ijkmnopqrstuvwxyzabcdefgh"; // No 'l'.
|
---|
| 211 | var letterIndex = 0;
|
---|
| 212 | var potName = letters.CharAt(letterIndex);
|
---|
| 213 | while (String.IsNullOrEmpty(newName)) {
|
---|
| 214 | var inUse = false;
|
---|
| 215 | for (var i = 0; i < variableList.Length; i++) {
|
---|
| 216 | if (variableList[i].ToLower() == potName) {
|
---|
| 217 | // This potential name is already used.
|
---|
| 218 | inUse = true;
|
---|
| 219 | break;
|
---|
| 220 | }
|
---|
| 221 | }
|
---|
| 222 | if (inUse) {
|
---|
| 223 | // Try the next potential name.
|
---|
| 224 | letterIndex++;
|
---|
| 225 | if (letterIndex == letters.Length) {
|
---|
| 226 | // Reached the end of the character sequence so back to 'i'.
|
---|
| 227 | // a new suffix.
|
---|
| 228 | letterIndex = 0;
|
---|
| 229 | nameSuffix++;
|
---|
| 230 | }
|
---|
| 231 | potName = letters.CharAt(letterIndex);
|
---|
| 232 | if (nameSuffix > 1) {
|
---|
| 233 | potName += nameSuffix;
|
---|
| 234 | }
|
---|
| 235 | }
|
---|
| 236 | else {
|
---|
| 237 | // We can use the current potential name.
|
---|
| 238 | newName = potName;
|
---|
| 239 | }
|
---|
| 240 | }
|
---|
| 241 | }
|
---|
| 242 | else {
|
---|
| 243 | newName = "i";
|
---|
| 244 | }
|
---|
| 245 | return newName;
|
---|
| 246 | }
|
---|
| 247 |
|
---|
| 248 | /// <summary>
|
---|
| 249 | /// Create a new variable on the given workspace.
|
---|
| 250 | /// </summary>
|
---|
| 251 | /// <param name="workspace">The workspace on which to create the variable.</param>
|
---|
| 252 | /// <param name="opt_callback">A callback. It will
|
---|
| 253 | /// return an acceptable new variable name, or null if change is to be
|
---|
| 254 | /// aborted (cancel button), or undefined if an existing variable was chosen.</param>
|
---|
| 255 | public void createVariable(Workspace workspace, Func<string, object> opt_callback = null)
|
---|
| 256 | {
|
---|
| 257 | Action<string> promptAndCheckWithAlert = null;
|
---|
| 258 | promptAndCheckWithAlert = new Action<string>((defaultName) => {
|
---|
| 259 | promptName(Msg.NEW_VARIABLE_TITLE, defaultName,
|
---|
| 260 | (text) => {
|
---|
| 261 | if (text != null) {
|
---|
| 262 | if (workspace.variableIndexOf(text) != -1) {
|
---|
| 263 | Blockly.alert(Msg.VARIABLE_ALREADY_EXISTS.Replace("%1",
|
---|
| 264 | text.ToLower()),
|
---|
| 265 | () => {
|
---|
| 266 | promptAndCheckWithAlert(text); // Recurse
|
---|
| 267 | });
|
---|
| 268 | }
|
---|
| 269 | else {
|
---|
| 270 | workspace.createVariable(text);
|
---|
| 271 | if (opt_callback != null) {
|
---|
| 272 | opt_callback(text);
|
---|
| 273 | }
|
---|
| 274 | }
|
---|
| 275 | }
|
---|
| 276 | else {
|
---|
| 277 | // User canceled prompt without a value.
|
---|
| 278 | if (opt_callback != null) {
|
---|
| 279 | opt_callback(null);
|
---|
| 280 | }
|
---|
| 281 | }
|
---|
| 282 | });
|
---|
| 283 | });
|
---|
| 284 | promptAndCheckWithAlert("");
|
---|
| 285 | }
|
---|
| 286 |
|
---|
| 287 | /// <summary>
|
---|
| 288 | /// Prompt the user for a new variable name.
|
---|
| 289 | /// </summary>
|
---|
| 290 | /// <param name="promptText">The string of the prompt.</param>
|
---|
| 291 | /// <param name="defaultText">The default value to show in the prompt's field.</param>
|
---|
| 292 | /// <param name="callback">A callback. It will return the new
|
---|
| 293 | /// variable name, or null if the user picked something illegal.</param>
|
---|
| 294 | public void promptName(string promptText, string defaultText, Action<string> callback)
|
---|
| 295 | {
|
---|
| 296 | Blockly.prompt(promptText, defaultText, new Action<string>((newVar) => {
|
---|
| 297 | // Merge runs of whitespace. Strip leading and trailing whitespace.
|
---|
| 298 | // Beyond this, all names are legal.
|
---|
| 299 | if (newVar != null) {
|
---|
[425] | 300 | newVar = newVar.Replace(new RegExp(@"[\s\xa0] +"), " ").Replace(new RegExp("^ | $"), "");
|
---|
[270] | 301 | if (newVar == Msg.RENAME_VARIABLE ||
|
---|
| 302 | newVar == Msg.NEW_VARIABLE) {
|
---|
| 303 | // Ok, not ALL names are legal...
|
---|
| 304 | newVar = null;
|
---|
| 305 | }
|
---|
| 306 | }
|
---|
| 307 | callback(newVar);
|
---|
| 308 | }));
|
---|
| 309 | }
|
---|
| 310 | }
|
---|
| 311 | }
|
---|