File "factory_utils.js"
Full path: /usr/home/mndrn/domains/mndrn.ru/public_html/block-hill/blockly/demos/blockfactory/factory_utils.js
File size: 36.01 KiB (36870 bytes)
MIME-type: text/plain
Charset: utf-8
/**
* @license
* Copyright 2016 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview FactoryUtils is a namespace that holds block starter code
* generation functions shared by the Block Factory, Workspace Factory, and
* Exporter applications within Blockly Factory. Holds functions to generate
* block definitions and generator stubs and to create and download files.
*
* @author [email protected] (Neil Fraser), quachtina96 (Tina Quach), JC-Orozco
* (Juan Carlos Orozco)
*/
'use strict';
/**
* Namespace for FactoryUtils.
*/
var FactoryUtils = FactoryUtils || Object.create(null);
/**
* Get block definition code for the current block.
* @param {string} blockType Type of block.
* @param {!Blockly.Block} rootBlock RootBlock from main workspace in which
* user uses Block Factory Blocks to create a custom block.
* @param {string} format 'JSON' or 'JavaScript'.
* @param {!Blockly.Workspace} workspace Where the root block lives.
* @return {string} Block definition.
*/
FactoryUtils.getBlockDefinition = function(blockType, rootBlock, format, workspace) {
blockType = FactoryUtils.cleanBlockType(blockType);
switch (format) {
case 'JSON':
var code = FactoryUtils.formatJson_(blockType, rootBlock);
break;
case 'JavaScript':
var code = FactoryUtils.formatJavaScript_(blockType, rootBlock, workspace);
break;
}
return code;
};
/**
* Convert invalid block name to a valid one. Replaces whitespace
* and prepend names that start with a digit with an '_'.
* @param {string} blockType Type of block.
* @return {string} Cleaned up block type.
*/
FactoryUtils.cleanBlockType = function(blockType) {
if (!blockType) {
return '';
}
return blockType.replace(/\W/g, '_').replace(/^(\d)/, '_$1');
};
/**
* Get the generator code for a given block.
* @param {!Blockly.Block} block Rendered block in preview workspace.
* @param {string} generatorLanguage 'JavaScript', 'Python', 'PHP', 'Lua',
* or 'Dart'.
* @return {string} Generator code for multiple blocks.
*/
FactoryUtils.getGeneratorStub = function(block, generatorLanguage) {
// Build factory blocks from block
if (BlockFactory.updateBlocksFlag) { // TODO: Move this to updatePreview()
BlockFactory.mainWorkspace.clear();
var xml = BlockDefinitionExtractor.buildBlockFactoryWorkspace(block);
Blockly.Xml.domToWorkspace(xml, BlockFactory.mainWorkspace);
// Calculate timer to avoid infinite update loops
// TODO(#1267): Remove the global variables and any infinite loops.
BlockFactory.updateBlocksFlag = false;
setTimeout(
function() {BlockFactory.updateBlocksFlagDelayed = false;}, 3000);
}
BlockFactory.lastUpdatedBlock = block; // Variable to share the block value.
function makeVar(root, name) {
name = name.toLowerCase().replace(/\W/g, '_');
return ' var ' + root + '_' + name;
}
// The makevar function lives in the original update generator.
var language = generatorLanguage;
var code = [];
code.push("Blockly." + language + "['" + block.type +
"'] = function(block) {");
// Generate getters for any fields or inputs.
for (var i = 0, input; input = block.inputList[i]; i++) {
for (var j = 0, field; field = input.fieldRow[j]; j++) {
var name = field.name;
if (!name) {
continue;
}
if (field instanceof Blockly.FieldVariable) {
// Subclass of Blockly.FieldDropdown, must test first.
code.push(makeVar('variable', name) +
" = Blockly." + language +
".variableDB_.getName(block.getFieldValue('" + name +
"'), Blockly.Variables.NAME_TYPE);");
} else if (field instanceof Blockly.FieldAngle) {
// Subclass of Blockly.FieldTextInput, must test first.
code.push(makeVar('angle', name) +
" = block.getFieldValue('" + name + "');");
} else if (field instanceof Blockly.FieldColour) {
code.push(makeVar('colour', name) +
" = block.getFieldValue('" + name + "');");
} else if (field instanceof Blockly.FieldCheckbox) {
code.push(makeVar('checkbox', name) +
" = block.getFieldValue('" + name + "') == 'TRUE';");
} else if (field instanceof Blockly.FieldDropdown) {
code.push(makeVar('dropdown', name) +
" = block.getFieldValue('" + name + "');");
} else if (field instanceof Blockly.FieldNumber) {
code.push(makeVar('number', name) +
" = block.getFieldValue('" + name + "');");
} else if (field instanceof Blockly.FieldTextInput) {
code.push(makeVar('text', name) +
" = block.getFieldValue('" + name + "');");
}
}
var name = input.name;
if (name) {
if (input.type == Blockly.INPUT_VALUE) {
code.push(makeVar('value', name) +
" = Blockly." + language + ".valueToCode(block, '" + name +
"', Blockly." + language + ".ORDER_ATOMIC);");
} else if (input.type == Blockly.NEXT_STATEMENT) {
code.push(makeVar('statements', name) +
" = Blockly." + language + ".statementToCode(block, '" +
name + "');");
}
}
}
// Most languages end lines with a semicolon. Python & Lua do not.
var lineEnd = {
'JavaScript': ';',
'Python': '',
'PHP': ';',
'Lua': '',
'Dart': ';'
};
code.push(" // TODO: Assemble " + language + " into code variable.");
if (block.outputConnection) {
code.push(" var code = '...';");
code.push(" // TODO: Change ORDER_NONE to the correct strength.");
code.push(" return [code, Blockly." + language + ".ORDER_NONE];");
} else {
code.push(" var code = '..." + (lineEnd[language] || '') + "\\n';");
code.push(" return code;");
}
code.push("};");
return code.join('\n');
};
/**
* Update the language code as JSON.
* @param {string} blockType Name of block.
* @param {!Blockly.Block} rootBlock Factory_base block.
* @return {string} Generated language code.
* @private
*/
FactoryUtils.formatJson_ = function(blockType, rootBlock) {
var JS = {};
// Type is not used by Blockly, but may be used by a loader.
JS.type = blockType;
// Generate inputs.
var message = [];
var args = [];
var contentsBlock = rootBlock.getInputTargetBlock('INPUTS');
var lastInput = null;
while (contentsBlock) {
if (!contentsBlock.disabled && !contentsBlock.getInheritedDisabled()) {
var fields = FactoryUtils.getFieldsJson_(
contentsBlock.getInputTargetBlock('FIELDS'));
for (var i = 0; i < fields.length; i++) {
if (typeof fields[i] == 'string') {
message.push(fields[i].replace(/%/g, '%%'));
} else {
args.push(fields[i]);
message.push('%' + args.length);
}
}
var input = {type: contentsBlock.type};
// Dummy inputs don't have names. Other inputs do.
if (contentsBlock.type != 'input_dummy') {
input.name = contentsBlock.getFieldValue('INPUTNAME');
}
var check = JSON.parse(
FactoryUtils.getOptTypesFrom(contentsBlock, 'TYPE') || 'null');
if (check) {
input.check = check;
}
var align = contentsBlock.getFieldValue('ALIGN');
if (align != 'LEFT') {
input.align = align;
}
args.push(input);
message.push('%' + args.length);
lastInput = contentsBlock;
}
contentsBlock = contentsBlock.nextConnection &&
contentsBlock.nextConnection.targetBlock();
}
// Remove last input if dummy and not empty.
if (lastInput && lastInput.type == 'input_dummy') {
var fields = lastInput.getInputTargetBlock('FIELDS');
if (fields && FactoryUtils.getFieldsJson_(fields).join('').trim() != '') {
var align = lastInput.getFieldValue('ALIGN');
if (align != 'LEFT') {
JS.lastDummyAlign0 = align;
}
args.pop();
message.pop();
}
}
JS.message0 = message.join(' ');
if (args.length) {
JS.args0 = args;
}
// Generate inline/external switch.
if (rootBlock.getFieldValue('INLINE') == 'EXT') {
JS.inputsInline = false;
} else if (rootBlock.getFieldValue('INLINE') == 'INT') {
JS.inputsInline = true;
}
// Generate output, or next/previous connections.
switch (rootBlock.getFieldValue('CONNECTIONS')) {
case 'LEFT':
JS.output =
JSON.parse(
FactoryUtils.getOptTypesFrom(rootBlock, 'OUTPUTTYPE') || 'null');
break;
case 'BOTH':
JS.previousStatement =
JSON.parse(
FactoryUtils.getOptTypesFrom(rootBlock, 'TOPTYPE') || 'null');
JS.nextStatement =
JSON.parse(
FactoryUtils.getOptTypesFrom(rootBlock, 'BOTTOMTYPE') || 'null');
break;
case 'TOP':
JS.previousStatement =
JSON.parse(
FactoryUtils.getOptTypesFrom(rootBlock, 'TOPTYPE') || 'null');
break;
case 'BOTTOM':
JS.nextStatement =
JSON.parse(
FactoryUtils.getOptTypesFrom(rootBlock, 'BOTTOMTYPE') || 'null');
break;
}
// Generate colour.
var colourBlock = rootBlock.getInputTargetBlock('COLOUR');
if (colourBlock && !colourBlock.disabled) {
var hue = parseInt(colourBlock.getFieldValue('HUE'), 10);
JS.colour = hue;
}
JS.tooltip = FactoryUtils.getTooltipFromRootBlock_(rootBlock);
JS.helpUrl = FactoryUtils.getHelpUrlFromRootBlock_(rootBlock);
return JSON.stringify(JS, null, ' ');
};
/**
* Update the language code as JavaScript.
* @param {string} blockType Name of block.
* @param {!Blockly.Block} rootBlock Factory_base block.
* @param {!Blockly.Workspace} workspace Where the root block lives.
* @return {string} Generated language code.
* @private
*/
FactoryUtils.formatJavaScript_ = function(blockType, rootBlock, workspace) {
var code = [];
code.push("Blockly.Blocks['" + blockType + "'] = {");
code.push(" init: function() {");
// Generate inputs.
var TYPES = {'input_value': 'appendValueInput',
'input_statement': 'appendStatementInput',
'input_dummy': 'appendDummyInput'};
var contentsBlock = rootBlock.getInputTargetBlock('INPUTS');
while (contentsBlock) {
if (!contentsBlock.disabled && !contentsBlock.getInheritedDisabled()) {
var name = '';
// Dummy inputs don't have names. Other inputs do.
if (contentsBlock.type != 'input_dummy') {
name =
JSON.stringify(contentsBlock.getFieldValue('INPUTNAME'));
}
code.push(' this.' + TYPES[contentsBlock.type] + '(' + name + ')');
var check = FactoryUtils.getOptTypesFrom(contentsBlock, 'TYPE');
if (check) {
code.push(' .setCheck(' + check + ')');
}
var align = contentsBlock.getFieldValue('ALIGN');
if (align != 'LEFT') {
code.push(' .setAlign(Blockly.ALIGN_' + align + ')');
}
var fields = FactoryUtils.getFieldsJs_(
contentsBlock.getInputTargetBlock('FIELDS'));
for (var i = 0; i < fields.length; i++) {
code.push(' .appendField(' + fields[i] + ')');
}
// Add semicolon to last line to finish the statement.
code[code.length - 1] += ';';
}
contentsBlock = contentsBlock.nextConnection &&
contentsBlock.nextConnection.targetBlock();
}
// Generate inline/external switch.
if (rootBlock.getFieldValue('INLINE') == 'EXT') {
code.push(' this.setInputsInline(false);');
} else if (rootBlock.getFieldValue('INLINE') == 'INT') {
code.push(' this.setInputsInline(true);');
}
// Generate output, or next/previous connections.
switch (rootBlock.getFieldValue('CONNECTIONS')) {
case 'LEFT':
code.push(FactoryUtils.connectionLineJs_('setOutput', 'OUTPUTTYPE', workspace));
break;
case 'BOTH':
code.push(
FactoryUtils.connectionLineJs_('setPreviousStatement', 'TOPTYPE', workspace));
code.push(
FactoryUtils.connectionLineJs_('setNextStatement', 'BOTTOMTYPE', workspace));
break;
case 'TOP':
code.push(
FactoryUtils.connectionLineJs_('setPreviousStatement', 'TOPTYPE', workspace));
break;
case 'BOTTOM':
code.push(
FactoryUtils.connectionLineJs_('setNextStatement', 'BOTTOMTYPE', workspace));
break;
}
// Generate colour.
var colourBlock = rootBlock.getInputTargetBlock('COLOUR');
if (colourBlock && !colourBlock.disabled) {
var hue = parseInt(colourBlock.getFieldValue('HUE'), 10);
if (!isNaN(hue)) {
code.push(' this.setColour(' + hue + ');');
}
}
var tooltip = FactoryUtils.getTooltipFromRootBlock_(rootBlock);
var helpUrl = FactoryUtils.getHelpUrlFromRootBlock_(rootBlock);
code.push(' this.setTooltip(' + JSON.stringify(tooltip) + ');');
code.push(' this.setHelpUrl(' + JSON.stringify(helpUrl) + ');');
code.push(' }');
code.push('};');
return code.join('\n');
};
/**
* Create JS code required to create a top, bottom, or value connection.
* @param {string} functionName JavaScript function name.
* @param {string} typeName Name of type input.
* @param {!Blockly.Workspace} workspace Where the root block lives.
* @return {string} Line of JavaScript code to create connection.
* @private
*/
FactoryUtils.connectionLineJs_ = function(functionName, typeName, workspace) {
var type = FactoryUtils.getOptTypesFrom(
FactoryUtils.getRootBlock(workspace), typeName);
if (type) {
type = ', ' + type;
} else {
type = '';
}
return ' this.' + functionName + '(true' + type + ');';
};
/**
* Returns field strings and any config.
* @param {!Blockly.Block} block Input block.
* @return {!Array.<string>} Field strings.
* @private
*/
FactoryUtils.getFieldsJs_ = function(block) {
var fields = [];
while (block) {
if (!block.disabled && !block.getInheritedDisabled()) {
switch (block.type) {
case 'field_static':
// Result: 'hello'
fields.push(JSON.stringify(block.getFieldValue('TEXT')));
break;
case 'field_label_serializable':
// Result: new Blockly.FieldLabelSerializable('Hello'), 'GREET'
fields.push('new Blockly.FieldLabelSerializable(' +
JSON.stringify(block.getFieldValue('TEXT')) + '), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_input':
// Result: new Blockly.FieldTextInput('Hello'), 'GREET'
fields.push('new Blockly.FieldTextInput(' +
JSON.stringify(block.getFieldValue('TEXT')) + '), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_number':
// Result: new Blockly.FieldNumber(10, 0, 100, 1), 'NUMBER'
var args = [
Number(block.getFieldValue('VALUE')),
Number(block.getFieldValue('MIN')),
Number(block.getFieldValue('MAX')),
Number(block.getFieldValue('PRECISION'))
];
// Remove any trailing arguments that aren't needed.
if (args[3] == 0) {
args.pop();
if (args[2] == Infinity) {
args.pop();
if (args[1] == -Infinity) {
args.pop();
}
}
}
fields.push('new Blockly.FieldNumber(' + args.join(', ') + '), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_angle':
// Result: new Blockly.FieldAngle(90), 'ANGLE'
fields.push('new Blockly.FieldAngle(' +
Number(block.getFieldValue('ANGLE')) + '), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_checkbox':
// Result: new Blockly.FieldCheckbox('TRUE'), 'CHECK'
fields.push('new Blockly.FieldCheckbox(' +
JSON.stringify(block.getFieldValue('CHECKED')) +
'), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_colour':
// Result: new Blockly.FieldColour('#ff0000'), 'COLOUR'
fields.push('new Blockly.FieldColour(' +
JSON.stringify(block.getFieldValue('COLOUR')) +
'), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_variable':
// Result: new Blockly.FieldVariable('item'), 'VAR'
var varname
= JSON.stringify(block.getFieldValue('TEXT') || null);
fields.push('new Blockly.FieldVariable(' + varname + '), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
break;
case 'field_dropdown':
// Result:
// new Blockly.FieldDropdown([['yes', '1'], ['no', '0']]), 'TOGGLE'
var options = [];
for (var i = 0; i < block.optionList_.length; i++) {
options[i] = JSON.stringify([block.getUserData(i),
block.getFieldValue('CPU' + i)]);
}
if (options.length) {
fields.push('new Blockly.FieldDropdown([' +
options.join(', ') + ']), ' +
JSON.stringify(block.getFieldValue('FIELDNAME')));
}
break;
case 'field_image':
// Result: new Blockly.FieldImage('http://...', 80, 60, '*')
var src = JSON.stringify(block.getFieldValue('SRC'));
var width = Number(block.getFieldValue('WIDTH'));
var height = Number(block.getFieldValue('HEIGHT'));
var alt = JSON.stringify(block.getFieldValue('ALT'));
var flipRtl = JSON.stringify(block.getFieldValue('FLIP_RTL'));
fields.push('new Blockly.FieldImage(' +
src + ', ' + width + ', ' + height +
', { alt: ' + alt + ', flipRtl: ' + flipRtl + ' })');
break;
}
}
block = block.nextConnection && block.nextConnection.targetBlock();
}
return fields;
};
/**
* Returns field strings and any config.
* @param {!Blockly.Block} block Input block.
* @return {!Array.<string|!Object>} Array of static text and field configs.
* @private
*/
FactoryUtils.getFieldsJson_ = function(block) {
var fields = [];
while (block) {
if (!block.disabled && !block.getInheritedDisabled()) {
switch (block.type) {
case 'field_static':
// Result: 'hello'
fields.push(block.getFieldValue('TEXT'));
break;
case 'field_label_serializable':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
text: block.getFieldValue('TEXT')
});
break;
case 'field_input':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
text: block.getFieldValue('TEXT')
});
break;
case 'field_number':
var obj = {
type: block.type,
name: block.getFieldValue('FIELDNAME'),
value: Number(block.getFieldValue('VALUE'))
};
var min = Number(block.getFieldValue('MIN'));
if (min > -Infinity) {
obj.min = min;
}
var max = Number(block.getFieldValue('MAX'));
if (max < Infinity) {
obj.max = max;
}
var precision = Number(block.getFieldValue('PRECISION'));
if (precision) {
obj.precision = precision;
}
fields.push(obj);
break;
case 'field_angle':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
angle: Number(block.getFieldValue('ANGLE'))
});
break;
case 'field_checkbox':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
checked: block.getFieldValue('CHECKED') == 'TRUE'
});
break;
case 'field_colour':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
colour: block.getFieldValue('COLOUR')
});
break;
case 'field_variable':
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
variable: block.getFieldValue('TEXT') || null
});
break;
case 'field_dropdown':
var options = [];
for (var i = 0; i < block.optionList_.length; i++) {
options[i] = [block.getUserData(i),
block.getFieldValue('CPU' + i)];
}
if (options.length) {
fields.push({
type: block.type,
name: block.getFieldValue('FIELDNAME'),
options: options
});
}
break;
case 'field_image':
fields.push({
type: block.type,
src: block.getFieldValue('SRC'),
width: Number(block.getFieldValue('WIDTH')),
height: Number(block.getFieldValue('HEIGHT')),
alt: block.getFieldValue('ALT'),
flipRtl: block.getFieldValue('FLIP_RTL') == 'TRUE'
});
break;
}
}
block = block.nextConnection && block.nextConnection.targetBlock();
}
return fields;
};
/**
* Fetch the type(s) defined in the given input.
* Format as a string for appending to the generated code.
* @param {!Blockly.Block} block Block with input.
* @param {string} name Name of the input.
* @return {?string} String defining the types.
*/
FactoryUtils.getOptTypesFrom = function(block, name) {
var types = FactoryUtils.getTypesFrom_(block, name);
if (types.length == 0) {
return undefined;
} else if (types.indexOf('null') != -1) {
return 'null';
} else if (types.length == 1) {
return types[0];
} else {
return '[' + types.join(', ') + ']';
}
};
/**
* Fetch the type(s) defined in the given input.
* @param {!Blockly.Block} block Block with input.
* @param {string} name Name of the input.
* @return {!Array.<string>} List of types.
* @private
*/
FactoryUtils.getTypesFrom_ = function(block, name) {
var typeBlock = block.getInputTargetBlock(name);
var types;
if (!typeBlock || typeBlock.disabled) {
types = [];
} else if (typeBlock.type == 'type_other') {
types = [JSON.stringify(typeBlock.getFieldValue('TYPE'))];
} else if (typeBlock.type == 'type_group') {
types = [];
for (var n = 0; n < typeBlock.typeCount_; n++) {
types = types.concat(FactoryUtils.getTypesFrom_(typeBlock, 'TYPE' + n));
}
// Remove duplicates.
var hash = Object.create(null);
for (var n = types.length - 1; n >= 0; n--) {
if (hash[types[n]]) {
types.splice(n, 1);
}
hash[types[n]] = true;
}
} else {
types = [JSON.stringify(typeBlock.valueType)];
}
return types;
};
/**
* Return the uneditable container block that everything else attaches to in
* given workspace.
* @param {!Blockly.Workspace} workspace Where the root block lives.
* @return {Blockly.Block} Root block.
*/
FactoryUtils.getRootBlock = function(workspace) {
var blocks = workspace.getTopBlocks(false);
for (var i = 0, block; block = blocks[i]; i++) {
if (block.type == 'factory_base') {
return block;
}
}
return null;
};
// TODO(quachtina96): Move hide, show, makeInvisible, and makeVisible to a new
// AppView namespace.
/**
* Hides element so that it's invisible and doesn't take up space.
* @param {string} elementID ID of element to hide.
*/
FactoryUtils.hide = function(elementID) {
document.getElementById(elementID).style.display = 'none';
};
/**
* Un-hides an element.
* @param {string} elementID ID of element to hide.
*/
FactoryUtils.show = function(elementID) {
document.getElementById(elementID).style.display = 'block';
};
/**
* Hides element so that it's invisible but still takes up space.
* @param {string} elementID ID of element to hide.
*/
FactoryUtils.makeInvisible = function(elementID) {
document.getElementById(elementID).visibility = 'hidden';
};
/**
* Makes element visible.
* @param {string} elementID ID of element to hide.
*/
FactoryUtils.makeVisible = function(elementID) {
document.getElementById(elementID).visibility = 'visible';
};
/**
* Create a file with the given attributes and download it.
* @param {string} contents The contents of the file.
* @param {string} filename The name of the file to save to.
* @param {string} fileType The type of the file to save.
*/
FactoryUtils.createAndDownloadFile = function(contents, filename, fileType) {
var data = new Blob([contents], {type: 'text/' + fileType});
var clickEvent = new MouseEvent("click", {
"view": window,
"bubbles": true,
"cancelable": false
});
var a = document.createElement('a');
a.href = window.URL.createObjectURL(data);
a.download = filename;
a.textContent = 'Download file!';
a.dispatchEvent(clickEvent);
};
/**
* Get Blockly Block by rendering pre-defined block in workspace.
* @param {!Element} blockType Type of block that has already been defined.
* @param {!Blockly.Workspace} workspace Workspace on which to render
* the block.
* @return {!Blockly.Block} The Blockly.Block of desired type.
*/
FactoryUtils.getDefinedBlock = function(blockType, workspace) {
workspace.clear();
return workspace.newBlock(blockType);
};
/**
* Parses a block definition get the type of the block it defines.
* @param {string} blockDef A single block definition.
* @return {string} Type of block defined by the given definition.
*/
FactoryUtils.getBlockTypeFromJsDefinition = function(blockDef) {
var indexOfStartBracket = blockDef.indexOf('[\'');
var indexOfEndBracket = blockDef.indexOf('\']');
if (indexOfStartBracket != -1 && indexOfEndBracket != -1) {
return blockDef.substring(indexOfStartBracket + 2, indexOfEndBracket);
} else {
throw Error('Could not parse block type out of JavaScript block ' +
'definition. Brackets normally enclosing block type not found.');
}
};
/**
* Generates a category containing blocks of the specified block types.
* @param {!Array.<!Blockly.Block>} blocks Blocks to include in the category.
* @param {string} categoryName Name to use for the generated category.
* @return {!Element} Category XML containing the given block types.
*/
FactoryUtils.generateCategoryXml = function(blocks, categoryName) {
// Create category DOM element.
var categoryElement = Blockly.utils.xml.createElement('category');
categoryElement.setAttribute('name', categoryName);
// For each block, add block element to category.
for (var i = 0, block; block = blocks[i]; i++) {
// Get preview block XML.
var blockXml = Blockly.Xml.blockToDom(block);
blockXml.removeAttribute('id');
// Add block to category and category to XML.
categoryElement.appendChild(blockXml);
}
return categoryElement;
};
/**
* Parses a string containing JavaScript block definition(s) to create an array
* in which each element is a single block definition.
* @param {string} blockDefsString JavaScript block definition(s).
* @return {!Array.<string>} Array of block definitions.
*/
FactoryUtils.parseJsBlockDefinitions = function(blockDefsString) {
var blockDefArray = [];
var defStart = blockDefsString.indexOf('Blockly.Blocks');
while (blockDefsString.indexOf('Blockly.Blocks', defStart) != -1) {
var nextStart = blockDefsString.indexOf('Blockly.Blocks', defStart + 1);
if (nextStart == -1) {
// This is the last block definition.
nextStart = blockDefsString.length;
}
var blockDef = blockDefsString.substring(defStart, nextStart);
blockDefArray.push(blockDef);
defStart = nextStart;
}
return blockDefArray;
};
/**
* Parses a string containing JSON block definition(s) to create an array
* in which each element is a single block definition. Expected input is
* one or more block definitions in the form of concatenated, stringified
* JSON objects.
* @param {string} blockDefsString String containing JSON block
* definition(s).
* @return {!Array.<string>} Array of block definitions.
*/
FactoryUtils.parseJsonBlockDefinitions = function(blockDefsString) {
var blockDefArray = [];
var unbalancedBracketCount = 0;
var defStart = 0;
// Iterate through the blockDefs string. Keep track of whether brackets
// are balanced.
for (var i = 0; i < blockDefsString.length; i++) {
var currentChar = blockDefsString[i];
if (currentChar == '{') {
unbalancedBracketCount++;
}
else if (currentChar == '}') {
unbalancedBracketCount--;
if (unbalancedBracketCount == 0 && i > 0) {
// The brackets are balanced. We've got a complete block definition.
var blockDef = blockDefsString.substring(defStart, i + 1);
blockDefArray.push(blockDef);
defStart = i + 1;
}
}
}
return blockDefArray;
};
/**
* Define blocks from imported block definitions.
* @param {string} blockDefsString Block definition(s).
* @param {string} format Block definition format ('JSON' or 'JavaScript').
* @return {!Array.<!Element>} Array of block types defined.
*/
FactoryUtils.defineAndGetBlockTypes = function(blockDefsString, format) {
var blockTypes = [];
// Define blocks and get block types.
if (format == 'JSON') {
var blockDefArray = FactoryUtils.parseJsonBlockDefinitions(blockDefsString);
// Populate array of blocktypes and define each block.
for (var i = 0, blockDef; blockDef = blockDefArray[i]; i++) {
var json = JSON.parse(blockDef);
blockTypes.push(json.type);
// Define the block.
Blockly.Blocks[json.type] = {
init: function() {
this.jsonInit(json);
}
};
}
} else if (format == 'JavaScript') {
var blockDefArray = FactoryUtils.parseJsBlockDefinitions(blockDefsString);
// Populate array of block types.
for (var i = 0, blockDef; blockDef = blockDefArray[i]; i++) {
var blockType = FactoryUtils.getBlockTypeFromJsDefinition(blockDef);
blockTypes.push(blockType);
}
// Define all blocks.
eval(blockDefsString);
}
return blockTypes;
};
/**
* Inject code into a pre tag, with syntax highlighting.
* Safe from HTML/script injection.
* @param {string} code Lines of code.
* @param {string} id ID of <pre> element to inject into.
*/
FactoryUtils.injectCode = function(code, id) {
var pre = document.getElementById(id);
pre.textContent = code;
// Remove the 'prettyprinted' class, so that Prettify will recalculate.
pre.className = pre.className.replace('prettyprinted', '');
PR.prettyPrint();
};
/**
* Returns whether or not two blocks are the same based on their XML. Expects
* XML with a single child node that is a factory_base block, the XML found on
* Block Factory's main workspace.
* @param {!Element} blockXml1 An XML element with a single child node that
* is a factory_base block.
* @param {!Element} blockXml2 An XML element with a single child node that
* is a factory_base block.
* @return {boolean} Whether or not two blocks are the same based on their XML.
*/
FactoryUtils.sameBlockXml = function(blockXml1, blockXml2) {
// Each XML element should contain a single child element with a 'block' tag
if (blockXml1.tagName.toLowerCase() != 'xml' ||
blockXml2.tagName.toLowerCase() != 'xml') {
throw Error('Expected two XML elements, received elements with tag ' +
'names: ' + blockXml1.tagName + ' and ' + blockXml2.tagName + '.');
}
// Compare the block elements directly. The XML tags may include other meta
// information we want to ignore.
var blockElement1 = blockXml1.getElementsByTagName('block')[0];
var blockElement2 = blockXml2.getElementsByTagName('block')[0];
if (!(blockElement1 && blockElement2)) {
throw Error('Could not get find block element in XML.');
}
var cleanBlockXml1 = FactoryUtils.cleanXml(blockElement1);
var cleanBlockXml2 = FactoryUtils.cleanXml(blockElement2);
var blockXmlText1 = Blockly.Xml.domToText(cleanBlockXml1);
var blockXmlText2 = Blockly.Xml.domToText(cleanBlockXml2);
// Strip white space.
blockXmlText1 = blockXmlText1.replace(/\s+/g, '');
blockXmlText2 = blockXmlText2.replace(/\s+/g, '');
// Return whether or not changes have been saved.
return blockXmlText1 == blockXmlText2;
};
/**
* Strips the provided xml of any attributes that don't describe the
* 'structure' of the blocks (i.e. block order, field values, etc).
* @param {Node} xml The xml to clean.
* @return {Node}
*/
FactoryUtils.cleanXml = function(xml) {
var newXml = xml.cloneNode(true);
var node = newXml;
while (node) {
// Things like text inside tags are still treated as nodes, but they
// don't have attributes (or the removeAttribute function) so we can
// skip removing attributes from them.
if (node.removeAttribute) {
node.removeAttribute('xmlns');
node.removeAttribute('x');
node.removeAttribute('y');
node.removeAttribute('id');
}
// Try to go down the tree
var nextNode = node.firstChild || node.nextSibling;
// If we can't go down, try to go back up the tree.
if (!nextNode) {
nextNode = node.parentNode;
while (nextNode) {
// We are valid again!
if (nextNode.nextSibling) {
nextNode = nextNode.nextSibling;
break;
}
// Try going up again. If parentNode is null that means we have
// reached the top, and we will break out of both loops.
nextNode = nextNode.parentNode;
}
}
node = nextNode;
}
return newXml;
};
/**
* Checks if a block has a variable field. Blocks with variable fields cannot
* be shadow blocks.
* @param {Blockly.Block} block The block to check if a variable field exists.
* @return {boolean} True if the block has a variable field, false otherwise.
*/
FactoryUtils.hasVariableField = function(block) {
if (!block) {
return false;
}
return block.getVars().length > 0;
};
/**
* Checks if a block is a procedures block. If procedures block names are
* ever updated or expanded, this function should be updated as well (no
* other known markers for procedure blocks beyond name).
* @param {Blockly.Block} block The block to check.
* @return {boolean} True if the block is a procedure block, false otherwise.
*/
FactoryUtils.isProcedureBlock = function(block) {
return block &&
(block.type == 'procedures_defnoreturn' ||
block.type == 'procedures_defreturn' ||
block.type == 'procedures_callnoreturn' ||
block.type == 'procedures_callreturn' ||
block.type == 'procedures_ifreturn');
};
/**
* Returns whether or not a modified block's changes has been saved to the
* Block Library.
* TODO(quachtina96): move into the Block Factory Controller once made.
* @param {!BlockLibraryController} blockLibraryController Block Library
* Controller storing custom blocks.
* @return {boolean} True if all changes made to the block have been saved to
* the given Block Library.
*/
FactoryUtils.savedBlockChanges = function(blockLibraryController) {
if (BlockFactory.isStarterBlock()) {
return true;
}
var blockType = blockLibraryController.getCurrentBlockType();
var currentXml = Blockly.Xml.workspaceToDom(BlockFactory.mainWorkspace);
if (blockLibraryController.has(blockType)) {
// Block is saved in block library.
var savedXml = blockLibraryController.getBlockXml(blockType);
return FactoryUtils.sameBlockXml(savedXml, currentXml);
}
return false;
};
/**
* Given the root block of the factory, return the tooltip specified by the user
* or the empty string if no tooltip is found.
* @param {!Blockly.Block} rootBlock Factory_base block.
* @return {string} The tooltip for the generated block, or the empty string.
*/
FactoryUtils.getTooltipFromRootBlock_ = function(rootBlock) {
var tooltipBlock = rootBlock.getInputTargetBlock('TOOLTIP');
if (tooltipBlock && !tooltipBlock.disabled) {
return tooltipBlock.getFieldValue('TEXT');
}
return '';
};
/**
* Given the root block of the factory, return the help url specified by the
* user or the empty string if no tooltip is found.
* @param {!Blockly.Block} rootBlock Factory_base block.
* @return {string} The help url for the generated block, or the empty string.
*/
FactoryUtils.getHelpUrlFromRootBlock_ = function(rootBlock) {
var helpUrlBlock = rootBlock.getInputTargetBlock('HELPURL');
if (helpUrlBlock && !helpUrlBlock.disabled) {
return helpUrlBlock.getFieldValue('TEXT');
}
return '';
};