mirror of
https://github.com/google/blockly.git
synced 2026-01-06 08:30:13 +01:00
90b3f75d82
Our files are up to a decade old, and have churned so much, that the initial author of the file no longer has much meaning. Furthermore, this will encourage developers to post to the developer group, rather than emailing Googlers (usually me) directly.
660 lines
20 KiB
JavaScript
660 lines
20 KiB
JavaScript
/**
|
|
* @license
|
|
* Copyright 2012 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview Logic blocks for Blockly.
|
|
*
|
|
* This file is scraped to extract a .json file of block definitions. The array
|
|
* passed to defineBlocksWithJsonArray(..) must be strict JSON: double quotes
|
|
* only, no outside references, no functions, no trailing commas, etc. The one
|
|
* exception is end-of-line comments, which the scraper will remove.
|
|
*/
|
|
'use strict';
|
|
|
|
goog.provide('Blockly.Blocks.logic'); // Deprecated
|
|
goog.provide('Blockly.Constants.Logic');
|
|
|
|
goog.require('Blockly');
|
|
goog.require('Blockly.FieldDropdown');
|
|
goog.require('Blockly.FieldLabel');
|
|
goog.require('Blockly.Mutator');
|
|
|
|
|
|
/**
|
|
* Unused constant for the common HSV hue for all blocks in this category.
|
|
* @deprecated Use Blockly.Msg['LOGIC_HUE']. (2018 April 5)
|
|
*/
|
|
Blockly.Constants.Logic.HUE = 210;
|
|
|
|
Blockly.defineBlocksWithJsonArray([ // BEGIN JSON EXTRACT
|
|
// Block for boolean data type: true and false.
|
|
{
|
|
"type": "logic_boolean",
|
|
"message0": "%1",
|
|
"args0": [
|
|
{
|
|
"type": "field_dropdown",
|
|
"name": "BOOL",
|
|
"options": [
|
|
["%{BKY_LOGIC_BOOLEAN_TRUE}", "TRUE"],
|
|
["%{BKY_LOGIC_BOOLEAN_FALSE}", "FALSE"]
|
|
]
|
|
}
|
|
],
|
|
"output": "Boolean",
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_LOGIC_BOOLEAN_TOOLTIP}",
|
|
"helpUrl": "%{BKY_LOGIC_BOOLEAN_HELPURL}"
|
|
},
|
|
// Block for if/elseif/else condition.
|
|
{
|
|
"type": "controls_if",
|
|
"message0": "%{BKY_CONTROLS_IF_MSG_IF} %1",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "IF0",
|
|
"check": "Boolean"
|
|
}
|
|
],
|
|
"message1": "%{BKY_CONTROLS_IF_MSG_THEN} %1",
|
|
"args1": [
|
|
{
|
|
"type": "input_statement",
|
|
"name": "DO0"
|
|
}
|
|
],
|
|
"previousStatement": null,
|
|
"nextStatement": null,
|
|
"style": "logic_blocks",
|
|
"helpUrl": "%{BKY_CONTROLS_IF_HELPURL}",
|
|
"suppressPrefixSuffix": true,
|
|
"mutator": "controls_if_mutator",
|
|
"extensions": ["controls_if_tooltip"]
|
|
},
|
|
// If/else block that does not use a mutator.
|
|
{
|
|
"type": "controls_ifelse",
|
|
"message0": "%{BKY_CONTROLS_IF_MSG_IF} %1",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "IF0",
|
|
"check": "Boolean"
|
|
}
|
|
],
|
|
"message1": "%{BKY_CONTROLS_IF_MSG_THEN} %1",
|
|
"args1": [
|
|
{
|
|
"type": "input_statement",
|
|
"name": "DO0"
|
|
}
|
|
],
|
|
"message2": "%{BKY_CONTROLS_IF_MSG_ELSE} %1",
|
|
"args2": [
|
|
{
|
|
"type": "input_statement",
|
|
"name": "ELSE"
|
|
}
|
|
],
|
|
"previousStatement": null,
|
|
"nextStatement": null,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKYCONTROLS_IF_TOOLTIP_2}",
|
|
"helpUrl": "%{BKY_CONTROLS_IF_HELPURL}",
|
|
"suppressPrefixSuffix": true,
|
|
"extensions": ["controls_if_tooltip"]
|
|
},
|
|
// Block for comparison operator.
|
|
{
|
|
"type": "logic_compare",
|
|
"message0": "%1 %2 %3",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "A"
|
|
},
|
|
{
|
|
"type": "field_dropdown",
|
|
"name": "OP",
|
|
"options": [
|
|
["=", "EQ"],
|
|
["\u2260", "NEQ"],
|
|
["\u200F<", "LT"],
|
|
["\u200F\u2264", "LTE"],
|
|
["\u200F>", "GT"],
|
|
["\u200F\u2265", "GTE"]
|
|
]
|
|
},
|
|
{
|
|
"type": "input_value",
|
|
"name": "B"
|
|
}
|
|
],
|
|
"inputsInline": true,
|
|
"output": "Boolean",
|
|
"style": "logic_blocks",
|
|
"helpUrl": "%{BKY_LOGIC_COMPARE_HELPURL}",
|
|
"extensions": ["logic_compare", "logic_op_tooltip"]
|
|
},
|
|
// Block for logical operations: 'and', 'or'.
|
|
{
|
|
"type": "logic_operation",
|
|
"message0": "%1 %2 %3",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "A",
|
|
"check": "Boolean"
|
|
},
|
|
{
|
|
"type": "field_dropdown",
|
|
"name": "OP",
|
|
"options": [
|
|
["%{BKY_LOGIC_OPERATION_AND}", "AND"],
|
|
["%{BKY_LOGIC_OPERATION_OR}", "OR"]
|
|
]
|
|
},
|
|
{
|
|
"type": "input_value",
|
|
"name": "B",
|
|
"check": "Boolean"
|
|
}
|
|
],
|
|
"inputsInline": true,
|
|
"output": "Boolean",
|
|
"style": "logic_blocks",
|
|
"helpUrl": "%{BKY_LOGIC_OPERATION_HELPURL}",
|
|
"extensions": ["logic_op_tooltip"]
|
|
},
|
|
// Block for negation.
|
|
{
|
|
"type": "logic_negate",
|
|
"message0": "%{BKY_LOGIC_NEGATE_TITLE}",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "BOOL",
|
|
"check": "Boolean"
|
|
}
|
|
],
|
|
"output": "Boolean",
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_LOGIC_NEGATE_TOOLTIP}",
|
|
"helpUrl": "%{BKY_LOGIC_NEGATE_HELPURL}"
|
|
},
|
|
// Block for null data type.
|
|
{
|
|
"type": "logic_null",
|
|
"message0": "%{BKY_LOGIC_NULL}",
|
|
"output": null,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_LOGIC_NULL_TOOLTIP}",
|
|
"helpUrl": "%{BKY_LOGIC_NULL_HELPURL}"
|
|
},
|
|
// Block for ternary operator.
|
|
{
|
|
"type": "logic_ternary",
|
|
"message0": "%{BKY_LOGIC_TERNARY_CONDITION} %1",
|
|
"args0": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "IF",
|
|
"check": "Boolean"
|
|
}
|
|
],
|
|
"message1": "%{BKY_LOGIC_TERNARY_IF_TRUE} %1",
|
|
"args1": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "THEN"
|
|
}
|
|
],
|
|
"message2": "%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
|
|
"args2": [
|
|
{
|
|
"type": "input_value",
|
|
"name": "ELSE"
|
|
}
|
|
],
|
|
"output": null,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_LOGIC_TERNARY_TOOLTIP}",
|
|
"helpUrl": "%{BKY_LOGIC_TERNARY_HELPURL}",
|
|
"extensions": ["logic_ternary"]
|
|
}
|
|
]); // END JSON EXTRACT (Do not delete this comment.)
|
|
|
|
Blockly.defineBlocksWithJsonArray([ // Mutator blocks. Do not extract.
|
|
// Block representing the if statement in the controls_if mutator.
|
|
{
|
|
"type": "controls_if_if",
|
|
"message0": "%{BKY_CONTROLS_IF_IF_TITLE_IF}",
|
|
"nextStatement": null,
|
|
"enableContextMenu": false,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_CONTROLS_IF_IF_TOOLTIP}"
|
|
},
|
|
// Block representing the else-if statement in the controls_if mutator.
|
|
{
|
|
"type": "controls_if_elseif",
|
|
"message0": "%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",
|
|
"previousStatement": null,
|
|
"nextStatement": null,
|
|
"enableContextMenu": false,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"
|
|
},
|
|
// Block representing the else statement in the controls_if mutator.
|
|
{
|
|
"type": "controls_if_else",
|
|
"message0": "%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",
|
|
"previousStatement": null,
|
|
"enableContextMenu": false,
|
|
"style": "logic_blocks",
|
|
"tooltip": "%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"
|
|
}
|
|
]);
|
|
|
|
/**
|
|
* Tooltip text, keyed by block OP value. Used by logic_compare and
|
|
* logic_operation blocks.
|
|
* @see {Blockly.Extensions#buildTooltipForDropdown}
|
|
* @package
|
|
* @readonly
|
|
*/
|
|
Blockly.Constants.Logic.TOOLTIPS_BY_OP = {
|
|
// logic_compare
|
|
'EQ': '%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}',
|
|
'NEQ': '%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}',
|
|
'LT': '%{BKY_LOGIC_COMPARE_TOOLTIP_LT}',
|
|
'LTE': '%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}',
|
|
'GT': '%{BKY_LOGIC_COMPARE_TOOLTIP_GT}',
|
|
'GTE': '%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}',
|
|
|
|
// logic_operation
|
|
'AND': '%{BKY_LOGIC_OPERATION_TOOLTIP_AND}',
|
|
'OR': '%{BKY_LOGIC_OPERATION_TOOLTIP_OR}'
|
|
};
|
|
|
|
Blockly.Extensions.register('logic_op_tooltip',
|
|
Blockly.Extensions.buildTooltipForDropdown(
|
|
'OP', Blockly.Constants.Logic.TOOLTIPS_BY_OP));
|
|
|
|
/**
|
|
* Mutator methods added to controls_if blocks.
|
|
* @mixin
|
|
* @augments Blockly.Block
|
|
* @package
|
|
* @readonly
|
|
*/
|
|
Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN = {
|
|
elseifCount_: 0,
|
|
elseCount_: 0,
|
|
|
|
/**
|
|
* Create XML to represent the number of else-if and else inputs.
|
|
* Backwards compatible serialization implementation.
|
|
* @return {Element} XML storage element.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
mutationToDom: function() {
|
|
if (!this.elseifCount_ && !this.elseCount_) {
|
|
return null;
|
|
}
|
|
var container = Blockly.utils.xml.createElement('mutation');
|
|
if (this.elseifCount_) {
|
|
container.setAttribute('elseif', this.elseifCount_);
|
|
}
|
|
if (this.elseCount_) {
|
|
container.setAttribute('else', 1);
|
|
}
|
|
return container;
|
|
},
|
|
/**
|
|
* Parse XML to restore the else-if and else inputs.
|
|
* Backwards compatible serialization implementation.
|
|
* @param {!Element} xmlElement XML storage element.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
domToMutation: function(xmlElement) {
|
|
this.elseifCount_ = parseInt(xmlElement.getAttribute('elseif'), 10) || 0;
|
|
this.elseCount_ = parseInt(xmlElement.getAttribute('else'), 10) || 0;
|
|
this.rebuildShape_();
|
|
},
|
|
/**
|
|
* Returns the state of this block as a JSON serializable object.
|
|
* @return {?{elseIfCount: (number|undefined), haseElse: (boolean|undefined)}}
|
|
* The state of this block, ie the else if count and else state.
|
|
*/
|
|
saveExtraState: function() {
|
|
if (!this.elseifCount_ && !this.elseCount_) {
|
|
return null;
|
|
}
|
|
var state = Object.create(null);
|
|
if (this.elseifCount_) {
|
|
state['elseIfCount'] = this.elseifCount_;
|
|
}
|
|
if (this.elseCount_) {
|
|
state['hasElse'] = true;
|
|
}
|
|
return state;
|
|
},
|
|
/**
|
|
* Applies the given state to this block.
|
|
* @param {*} state The state to apply to this block, ie the else if count and
|
|
* else state.
|
|
*/
|
|
loadExtraState: function(state) {
|
|
this.elseifCount_ = state['elseIfCount'] || 0;
|
|
this.elseCount_ = state['hasElse'] ? 1 : 0;
|
|
this.updateShape_();
|
|
},
|
|
/**
|
|
* Populate the mutator's dialog with this block's components.
|
|
* @param {!Blockly.Workspace} workspace Mutator's workspace.
|
|
* @return {!Blockly.Block} Root block in mutator.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
decompose: function(workspace) {
|
|
var containerBlock = workspace.newBlock('controls_if_if');
|
|
containerBlock.initSvg();
|
|
var connection = containerBlock.nextConnection;
|
|
for (var i = 1; i <= this.elseifCount_; i++) {
|
|
var elseifBlock = workspace.newBlock('controls_if_elseif');
|
|
elseifBlock.initSvg();
|
|
connection.connect(elseifBlock.previousConnection);
|
|
connection = elseifBlock.nextConnection;
|
|
}
|
|
if (this.elseCount_) {
|
|
var elseBlock = workspace.newBlock('controls_if_else');
|
|
elseBlock.initSvg();
|
|
connection.connect(elseBlock.previousConnection);
|
|
}
|
|
return containerBlock;
|
|
},
|
|
/**
|
|
* Reconfigure this block based on the mutator dialog's components.
|
|
* @param {!Blockly.Block} containerBlock Root block in mutator.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
compose: function(containerBlock) {
|
|
var clauseBlock = containerBlock.nextConnection.targetBlock();
|
|
// Count number of inputs.
|
|
this.elseifCount_ = 0;
|
|
this.elseCount_ = 0;
|
|
var valueConnections = [null];
|
|
var statementConnections = [null];
|
|
var elseStatementConnection = null;
|
|
while (clauseBlock && !clauseBlock.isInsertionMarker()) {
|
|
switch (clauseBlock.type) {
|
|
case 'controls_if_elseif':
|
|
this.elseifCount_++;
|
|
valueConnections.push(clauseBlock.valueConnection_);
|
|
statementConnections.push(clauseBlock.statementConnection_);
|
|
break;
|
|
case 'controls_if_else':
|
|
this.elseCount_++;
|
|
elseStatementConnection = clauseBlock.statementConnection_;
|
|
break;
|
|
default:
|
|
throw TypeError('Unknown block type: ' + clauseBlock.type);
|
|
}
|
|
clauseBlock = clauseBlock.nextConnection &&
|
|
clauseBlock.nextConnection.targetBlock();
|
|
}
|
|
this.updateShape_();
|
|
// Reconnect any child blocks.
|
|
this.reconnectChildBlocks_(valueConnections, statementConnections,
|
|
elseStatementConnection);
|
|
},
|
|
/**
|
|
* Store pointers to any connected child blocks.
|
|
* @param {!Blockly.Block} containerBlock Root block in mutator.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
saveConnections: function(containerBlock) {
|
|
var clauseBlock = containerBlock.nextConnection.targetBlock();
|
|
var i = 1;
|
|
while (clauseBlock) {
|
|
switch (clauseBlock.type) {
|
|
case 'controls_if_elseif':
|
|
var inputIf = this.getInput('IF' + i);
|
|
var inputDo = this.getInput('DO' + i);
|
|
clauseBlock.valueConnection_ =
|
|
inputIf && inputIf.connection.targetConnection;
|
|
clauseBlock.statementConnection_ =
|
|
inputDo && inputDo.connection.targetConnection;
|
|
i++;
|
|
break;
|
|
case 'controls_if_else':
|
|
var inputDo = this.getInput('ELSE');
|
|
clauseBlock.statementConnection_ =
|
|
inputDo && inputDo.connection.targetConnection;
|
|
break;
|
|
default:
|
|
throw TypeError('Unknown block type: ' + clauseBlock.type);
|
|
}
|
|
clauseBlock = clauseBlock.nextConnection &&
|
|
clauseBlock.nextConnection.targetBlock();
|
|
}
|
|
},
|
|
/**
|
|
* Reconstructs the block with all child blocks attached.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
rebuildShape_: function() {
|
|
var valueConnections = [null];
|
|
var statementConnections = [null];
|
|
var elseStatementConnection = null;
|
|
|
|
if (this.getInput('ELSE')) {
|
|
elseStatementConnection = this.getInput('ELSE').connection.targetConnection;
|
|
}
|
|
var i = 1;
|
|
while (this.getInput('IF' + i)) {
|
|
var inputIf = this.getInput('IF' + i);
|
|
var inputDo = this.getInput('DO' + i);
|
|
valueConnections.push(inputIf.connection.targetConnection);
|
|
statementConnections.push(inputDo.connection.targetConnection);
|
|
i++;
|
|
}
|
|
this.updateShape_();
|
|
this.reconnectChildBlocks_(valueConnections, statementConnections,
|
|
elseStatementConnection);
|
|
},
|
|
/**
|
|
* Modify this block to have the correct number of inputs.
|
|
* @this {Blockly.Block}
|
|
* @private
|
|
*/
|
|
updateShape_: function() {
|
|
// Delete everything.
|
|
if (this.getInput('ELSE')) {
|
|
this.removeInput('ELSE');
|
|
}
|
|
var i = 1;
|
|
while (this.getInput('IF' + i)) {
|
|
this.removeInput('IF' + i);
|
|
this.removeInput('DO' + i);
|
|
i++;
|
|
}
|
|
// Rebuild block.
|
|
for (i = 1; i <= this.elseifCount_; i++) {
|
|
this.appendValueInput('IF' + i)
|
|
.setCheck('Boolean')
|
|
.appendField(Blockly.Msg['CONTROLS_IF_MSG_ELSEIF']);
|
|
this.appendStatementInput('DO' + i)
|
|
.appendField(Blockly.Msg['CONTROLS_IF_MSG_THEN']);
|
|
}
|
|
if (this.elseCount_) {
|
|
this.appendStatementInput('ELSE')
|
|
.appendField(Blockly.Msg['CONTROLS_IF_MSG_ELSE']);
|
|
}
|
|
},
|
|
/**
|
|
* Reconnects child blocks.
|
|
* @param {!Array<?Blockly.RenderedConnection>} valueConnections List of
|
|
* value connections for 'if' input.
|
|
* @param {!Array<?Blockly.RenderedConnection>} statementConnections List of
|
|
* statement connections for 'do' input.
|
|
* @param {?Blockly.RenderedConnection} elseStatementConnection Statement
|
|
* connection for else input.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
reconnectChildBlocks_: function(valueConnections, statementConnections,
|
|
elseStatementConnection) {
|
|
for (var i = 1; i <= this.elseifCount_; i++) {
|
|
Blockly.Mutator.reconnect(valueConnections[i], this, 'IF' + i);
|
|
Blockly.Mutator.reconnect(statementConnections[i], this, 'DO' + i);
|
|
}
|
|
Blockly.Mutator.reconnect(elseStatementConnection, this, 'ELSE');
|
|
}
|
|
};
|
|
|
|
Blockly.Extensions.registerMutator('controls_if_mutator',
|
|
Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN, null,
|
|
['controls_if_elseif', 'controls_if_else']);
|
|
/**
|
|
* "controls_if" extension function. Adds mutator, shape updating methods, and
|
|
* dynamic tooltip to "controls_if" blocks.
|
|
* @this {Blockly.Block}
|
|
* @package
|
|
*/
|
|
Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION = function() {
|
|
|
|
this.setTooltip(function() {
|
|
if (!this.elseifCount_ && !this.elseCount_) {
|
|
return Blockly.Msg['CONTROLS_IF_TOOLTIP_1'];
|
|
} else if (!this.elseifCount_ && this.elseCount_) {
|
|
return Blockly.Msg['CONTROLS_IF_TOOLTIP_2'];
|
|
} else if (this.elseifCount_ && !this.elseCount_) {
|
|
return Blockly.Msg['CONTROLS_IF_TOOLTIP_3'];
|
|
} else if (this.elseifCount_ && this.elseCount_) {
|
|
return Blockly.Msg['CONTROLS_IF_TOOLTIP_4'];
|
|
}
|
|
return '';
|
|
}.bind(this));
|
|
};
|
|
|
|
Blockly.Extensions.register('controls_if_tooltip',
|
|
Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);
|
|
|
|
/**
|
|
* Adds dynamic type validation for the left and right sides of a logic_compare
|
|
* block.
|
|
* @mixin
|
|
* @augments Blockly.Block
|
|
* @package
|
|
* @readonly
|
|
*/
|
|
Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN = {
|
|
/**
|
|
* Called whenever anything on the workspace changes.
|
|
* Prevent mismatched types from being compared.
|
|
* @param {!Blockly.Events.Abstract} e Change event.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
onchange: function(e) {
|
|
if (!this.prevBlocks_) {
|
|
this.prevBlocks_ = [null, null];
|
|
}
|
|
|
|
var blockA = this.getInputTargetBlock('A');
|
|
var blockB = this.getInputTargetBlock('B');
|
|
// Disconnect blocks that existed prior to this change if they don't match.
|
|
if (blockA && blockB &&
|
|
!this.workspace.connectionChecker.doTypeChecks(
|
|
blockA.outputConnection, blockB.outputConnection)) {
|
|
// Mismatch between two inputs. Revert the block connections,
|
|
// bumping away the newly connected block(s).
|
|
Blockly.Events.setGroup(e.group);
|
|
var prevA = this.prevBlocks_[0];
|
|
if (prevA !== blockA) {
|
|
blockA.unplug();
|
|
if (prevA && !prevA.isDisposed() && !prevA.isShadow()) {
|
|
// The shadow block is automatically replaced during unplug().
|
|
this.getInput('A').connection.connect(prevA.outputConnection);
|
|
}
|
|
}
|
|
var prevB = this.prevBlocks_[1];
|
|
if (prevB !== blockB) {
|
|
blockB.unplug();
|
|
if (prevB && !prevB.isDisposed() && !prevB.isShadow()) {
|
|
// The shadow block is automatically replaced during unplug().
|
|
this.getInput('B').connection.connect(prevB.outputConnection);
|
|
}
|
|
}
|
|
this.bumpNeighbours();
|
|
Blockly.Events.setGroup(false);
|
|
}
|
|
this.prevBlocks_[0] = this.getInputTargetBlock('A');
|
|
this.prevBlocks_[1] = this.getInputTargetBlock('B');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* "logic_compare" extension function. Adds type left and right side type
|
|
* checking to "logic_compare" blocks.
|
|
* @this {Blockly.Block}
|
|
* @package
|
|
* @readonly
|
|
*/
|
|
Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION = function() {
|
|
// Add onchange handler to ensure types are compatible.
|
|
this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN);
|
|
};
|
|
|
|
Blockly.Extensions.register('logic_compare',
|
|
Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);
|
|
|
|
/**
|
|
* Adds type coordination between inputs and output.
|
|
* @mixin
|
|
* @augments Blockly.Block
|
|
* @package
|
|
* @readonly
|
|
*/
|
|
Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN = {
|
|
prevParentConnection_: null,
|
|
|
|
/**
|
|
* Called whenever anything on the workspace changes.
|
|
* Prevent mismatched types.
|
|
* @param {!Blockly.Events.Abstract} e Change event.
|
|
* @this {Blockly.Block}
|
|
*/
|
|
onchange: function(e) {
|
|
var blockA = this.getInputTargetBlock('THEN');
|
|
var blockB = this.getInputTargetBlock('ELSE');
|
|
var parentConnection = this.outputConnection.targetConnection;
|
|
// Disconnect blocks that existed prior to this change if they don't match.
|
|
if ((blockA || blockB) && parentConnection) {
|
|
for (var i = 0; i < 2; i++) {
|
|
var block = (i === 1) ? blockA : blockB;
|
|
if (block &&
|
|
!block.workspace.connectionChecker.doTypeChecks(
|
|
block.outputConnection, parentConnection)) {
|
|
// Ensure that any disconnections are grouped with the causing event.
|
|
Blockly.Events.setGroup(e.group);
|
|
if (parentConnection === this.prevParentConnection_) {
|
|
this.unplug();
|
|
parentConnection.getSourceBlock().bumpNeighbours();
|
|
} else {
|
|
block.unplug();
|
|
block.bumpNeighbours();
|
|
}
|
|
Blockly.Events.setGroup(false);
|
|
}
|
|
}
|
|
}
|
|
this.prevParentConnection_ = parentConnection;
|
|
}
|
|
};
|
|
|
|
Blockly.Extensions.registerMixin('logic_ternary',
|
|
Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);
|