652 lines
19 KiB
JavaScript
652 lines
19 KiB
JavaScript
import Blockly from "blockly/core";
|
|
import { getColour } from "../helpers/colour";
|
|
import * as Types from "../helpers/types";
|
|
import { getCompatibleTypes } from "../helpers/types";
|
|
|
|
Blockly.Blocks["controls_if"] = {
|
|
/**
|
|
* Block for if/elseif/else condition.
|
|
* @this Blockly.Block
|
|
*/
|
|
init: function () {
|
|
this.setHelpUrl(Blockly.Msg.CONTROLS_IF_HELPURL);
|
|
this.setColour(getColour().logic);
|
|
this.appendValueInput("IF0")
|
|
.setCheck(Types.getCompatibleTypes("boolean"))
|
|
.appendField(Blockly.Msg.CONTROLS_IF_MSG_IF);
|
|
this.appendStatementInput("DO0").appendField(
|
|
Blockly.Msg.CONTROLS_IF_MSG_THEN
|
|
);
|
|
this.setPreviousStatement(true);
|
|
this.setNextStatement(true);
|
|
this.setMutator(
|
|
new Blockly.Mutator(["controls_if_elseif", "controls_if_else"])
|
|
);
|
|
this.setTooltip(Blockly.Msg.CONTROLS_IF_TOOLTIP_1);
|
|
this.elseifCount_ = 0;
|
|
this.elseCount_ = 0;
|
|
},
|
|
/**
|
|
* Create XML to represent the number of else-if and else inputs.
|
|
* @return {Element} XML storage element.
|
|
* @this Blockly.Block
|
|
*/
|
|
mutationToDom: function () {
|
|
if (!this.elseifCount_ && !this.elseCount_) {
|
|
return null;
|
|
}
|
|
var container = document.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.
|
|
* @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.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) {
|
|
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 new Error("Unknown block type.");
|
|
}
|
|
clauseBlock =
|
|
clauseBlock.nextConnection && clauseBlock.nextConnection.targetBlock();
|
|
}
|
|
this.updateShape_();
|
|
// Reconnect any child blocks.
|
|
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");
|
|
},
|
|
/**
|
|
* 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;
|
|
var inputDo;
|
|
while (clauseBlock) {
|
|
switch (clauseBlock.type) {
|
|
case "controls_if_elseif":
|
|
var inputIf = this.getInput("IF" + i);
|
|
inputDo = this.getInput("DO" + i);
|
|
clauseBlock.valueConnection_ =
|
|
inputIf && inputIf.connection.targetConnection;
|
|
clauseBlock.statementConnection_ =
|
|
inputDo && inputDo.connection.targetConnection;
|
|
i++;
|
|
break;
|
|
case "controls_if_else":
|
|
inputDo = this.getInput("ELSE");
|
|
clauseBlock.statementConnection_ =
|
|
inputDo && inputDo.connection.targetConnection;
|
|
break;
|
|
default:
|
|
throw new Error("Unknown block type.");
|
|
}
|
|
clauseBlock =
|
|
clauseBlock.nextConnection && clauseBlock.nextConnection.targetBlock();
|
|
}
|
|
},
|
|
/**
|
|
* Modify this block to have the correct number of inputs.
|
|
* @private
|
|
* @this Blockly.Block
|
|
*/
|
|
updateShape_: function () {
|
|
// Delete everything.
|
|
if (this.getInput("ELSE")) {
|
|
this.removeInput("ELSE");
|
|
}
|
|
var j = 1;
|
|
while (this.getInput("IF" + j)) {
|
|
this.removeInput("IF" + j);
|
|
this.removeInput("DO" + j);
|
|
j++;
|
|
}
|
|
// Rebuild block.
|
|
for (var i = 1; i <= this.elseifCount_; i++) {
|
|
this.appendValueInput("IF" + i)
|
|
.setCheck(Types.getCompatibleTypes("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
|
|
);
|
|
}
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["controls_if_if"] = {
|
|
/**
|
|
* Mutator block for if container.
|
|
* @this Blockly.Block
|
|
*/
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendDummyInput().appendField(Blockly.Msg.CONTROLS_IF_IF_TITLE_IF);
|
|
this.setNextStatement(true);
|
|
this.setTooltip(Blockly.Msg.CONTROLS_IF_IF_TOOLTIP);
|
|
this.contextMenu = false;
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["controls_if_elseif"] = {
|
|
/**
|
|
* Mutator bolck for else-if condition.
|
|
* @this Blockly.Block
|
|
*/
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendDummyInput().appendField(
|
|
Blockly.Msg.CONTROLS_IF_ELSEIF_TITLE_ELSEIF
|
|
);
|
|
this.setPreviousStatement(true);
|
|
this.setNextStatement(true);
|
|
this.setTooltip(Blockly.Msg.CONTROLS_IF_ELSEIF_TOOLTIP);
|
|
this.contextMenu = false;
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["controls_if_else"] = {
|
|
/**
|
|
* Mutator block for else condition.
|
|
* @this Blockly.Block
|
|
*/
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendDummyInput().appendField(
|
|
Blockly.Msg.CONTROLS_IF_ELSE_TITLE_ELSE
|
|
);
|
|
this.setPreviousStatement(true);
|
|
this.setTooltip(Blockly.Msg.CONTROLS_IF_ELSE_TOOLTIP);
|
|
this.contextMenu = false;
|
|
},
|
|
};
|
|
|
|
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: Types.BOOLEAN.typeName,
|
|
style: "logic_blocks",
|
|
tooltip: "%{BKY_LOGIC_BOOLEAN_TOOLTIP}",
|
|
helpUrl: "%{BKY_LOGIC_BOOLEAN_HELPURL}",
|
|
},
|
|
{
|
|
type: "controls_ifelse",
|
|
message0: "%{BKY_CONTROLS_IF_MSG_IF} %1",
|
|
args0: [
|
|
{
|
|
type: "input_value",
|
|
name: "IF0",
|
|
check: Types.getCompatibleTypes("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}",
|
|
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: Types.BOOLEAN.typeName,
|
|
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: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
{
|
|
type: "field_dropdown",
|
|
name: "OP",
|
|
options: [
|
|
["%{BKY_LOGIC_OPERATION_AND}", "AND"],
|
|
["%{BKY_LOGIC_OPERATION_OR}", "OR"],
|
|
],
|
|
},
|
|
{
|
|
type: "input_value",
|
|
name: "B",
|
|
check: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
],
|
|
inputsInline: true,
|
|
output: Types.BOOLEAN.typeName,
|
|
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: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
],
|
|
output: Types.BOOLEAN.typeName,
|
|
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: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
],
|
|
message1: "%{BKY_LOGIC_TERNARY_IF_TRUE} %1",
|
|
args1: [
|
|
{
|
|
type: "input_value",
|
|
name: "THEN",
|
|
check: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
],
|
|
message2: "%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
|
|
args2: [
|
|
{
|
|
type: "input_value",
|
|
name: "ELSE",
|
|
check: Types.getCompatibleTypes("boolean"),
|
|
},
|
|
],
|
|
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.Blocks["logic_compare"] = {
|
|
/**
|
|
* Block for comparison operator.
|
|
* @this Blockly.Block
|
|
*/
|
|
init: function () {
|
|
var OPERATORS = this.RTL
|
|
? [
|
|
["=", "EQ"],
|
|
["\u2260", "NEQ"],
|
|
[">", "LT"],
|
|
["\u2265", "LTE"],
|
|
["<", "GT"],
|
|
["\u2264", "GTE"],
|
|
]
|
|
: [
|
|
["=", "EQ"],
|
|
["\u2260", "NEQ"],
|
|
["<", "LT"],
|
|
["\u2264", "LTE"],
|
|
[">", "GT"],
|
|
["\u2265", "GTE"],
|
|
];
|
|
this.setHelpUrl(Blockly.Msg.LOGIC_COMPARE_HELPURL);
|
|
this.setColour(getColour().logic);
|
|
this.setOutput(true, Types.BOOLEAN.typeName);
|
|
this.appendValueInput("A");
|
|
this.appendValueInput("B").appendField(
|
|
new Blockly.FieldDropdown(OPERATORS),
|
|
"OP"
|
|
);
|
|
this.setInputsInline(true);
|
|
// Assign 'this' to a variable for use in the tooltip closure below.
|
|
var thisBlock = this;
|
|
this.setTooltip(function () {
|
|
var op = thisBlock.getFieldValue("OP");
|
|
var TOOLTIPS = {
|
|
EQ: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_EQ,
|
|
NEQ: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_NEQ,
|
|
LT: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LT,
|
|
LTE: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LTE,
|
|
GT: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GT,
|
|
GTE: Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GTE,
|
|
};
|
|
return TOOLTIPS[op];
|
|
});
|
|
},
|
|
/**
|
|
* 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) {
|
|
var blockA = this.getInputTargetBlock("A");
|
|
var blockB = this.getInputTargetBlock("B");
|
|
if (blockA === null && blockB === null) {
|
|
this.getInput("A").setCheck(null);
|
|
this.getInput("B").setCheck(null);
|
|
}
|
|
if (blockA !== null && blockB === null) {
|
|
this.getInput("A").setCheck(
|
|
getCompatibleTypes(blockA.outputConnection.check_[0])
|
|
);
|
|
this.getInput("B").setCheck(
|
|
getCompatibleTypes(blockA.outputConnection.check_[0])
|
|
);
|
|
}
|
|
if (blockB !== null && blockA === null) {
|
|
this.getInput("B").setCheck(
|
|
getCompatibleTypes(blockB.outputConnection.check_[0])
|
|
);
|
|
this.getInput("A").setCheck(
|
|
getCompatibleTypes(blockB.outputConnection.check_[0])
|
|
);
|
|
}
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["switch_case"] = {
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.setPreviousStatement(true);
|
|
this.setTooltip(Blockly.Msg.cases_tooltip);
|
|
this.setNextStatement(true);
|
|
this.appendValueInput("CONDITION").appendField(Blockly.Msg.cases_switch);
|
|
this.appendValueInput("CASECONDITION0").appendField(
|
|
Blockly.Msg.cases_condition
|
|
);
|
|
this.appendStatementInput("CASE0").appendField(Blockly.Msg.cases_do);
|
|
this.setMutator(new Blockly.Mutator(["case_incaseof", "case_default"]));
|
|
this.caseCount_ = 0;
|
|
this.defaultCount_ = 0;
|
|
},
|
|
|
|
mutationToDom: function () {
|
|
if (!this.caseCount_ && !this.defaultCount_) {
|
|
return null;
|
|
}
|
|
var container = document.createElement("mutation");
|
|
if (this.caseCount_) {
|
|
container.setAttribute("case", this.caseCount_);
|
|
}
|
|
if (this.defaultCount_) {
|
|
container.setAttribute("default", 1);
|
|
}
|
|
return container;
|
|
},
|
|
|
|
domToMutation: function (xmlElement) {
|
|
this.caseCount_ = parseInt(xmlElement.getAttribute("case"), 10);
|
|
this.defaultCount_ = parseInt(xmlElement.getAttribute("default"), 10);
|
|
for (var x = 0; x <= this.caseCount_; x++) {
|
|
this.appendValueInput("CASECONDITION" + x).appendField(
|
|
Blockly.Msg.cases_condition
|
|
);
|
|
this.appendStatementInput("CASE" + x).appendField(Blockly.Msg.cases_do);
|
|
}
|
|
if (this.defaultCount_) {
|
|
this.appendStatementInput("ONDEFAULT").appendField("default");
|
|
}
|
|
},
|
|
|
|
decompose: function (workspace) {
|
|
var containerBlock = workspace.newBlock("control_case");
|
|
containerBlock.initSvg();
|
|
var connection = containerBlock.getInput("STACK").connection;
|
|
for (var x = 1; x <= this.caseCount_; x++) {
|
|
var caseBlock = workspace.newBlock("case_incaseof");
|
|
caseBlock.initSvg();
|
|
connection.connect(caseBlock.previousConnection);
|
|
connection = caseBlock.nextConnection;
|
|
}
|
|
if (this.defaultCount_) {
|
|
var defaultBlock = Blockly.Block.obtain(workspace, "case_default");
|
|
defaultBlock.initSvg();
|
|
connection.connect(defaultBlock.previousConnection);
|
|
}
|
|
return containerBlock;
|
|
},
|
|
|
|
compose: function (containerBlock) {
|
|
//Disconnect all input blocks and remove all inputs.
|
|
if (this.defaultCount_) {
|
|
this.removeInput("ONDEFAULT");
|
|
}
|
|
this.defaultCount_ = 0;
|
|
for (var x = this.caseCount_; x > 0; x--) {
|
|
this.removeInput("CASECONDITION" + x);
|
|
this.removeInput("CASE" + x);
|
|
}
|
|
this.caseCount_ = 0;
|
|
var caseBlock = containerBlock.getInputTargetBlock("STACK");
|
|
while (caseBlock) {
|
|
switch (caseBlock.type) {
|
|
case "case_incaseof":
|
|
this.caseCount_++;
|
|
var caseconditionInput = this.appendValueInput(
|
|
"CASECONDITION" + this.caseCount_
|
|
).appendField(Blockly.Msg.cases_condition);
|
|
var caseInput = this.appendStatementInput(
|
|
"CASE" + this.caseCount_
|
|
).appendField(Blockly.Msg.cases_do);
|
|
if (caseBlock.valueConnection_) {
|
|
caseconditionInput.connection.connect(caseBlock.valueConnection_);
|
|
}
|
|
if (caseBlock.statementConnection_) {
|
|
caseInput.connection.connect(caseBlock.statementConnection_);
|
|
}
|
|
break;
|
|
case "case_default":
|
|
this.defaultCount_++;
|
|
var defaultInput =
|
|
this.appendStatementInput("ONDEFAULT").appendField("default");
|
|
if (caseBlock.statementConnection_) {
|
|
defaultInput.connection.connect(caseBlock.statementConnection_);
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error("Unknown block type.");
|
|
}
|
|
caseBlock =
|
|
caseBlock.nextConnection && caseBlock.nextConnection.targetBlock();
|
|
}
|
|
},
|
|
|
|
saveConnections: function (containerBlock) {
|
|
var caseBlock = containerBlock.getInputTargetBlock("STACK");
|
|
var x = 1;
|
|
while (caseBlock) {
|
|
switch (caseBlock.type) {
|
|
case "case_incaseof":
|
|
var caseconditionInput = this.getInput("CASECONDITION" + x);
|
|
var caseInput = this.getInput("CASE" + x);
|
|
caseBlock.valueConnection_ =
|
|
caseconditionInput &&
|
|
caseconditionInput.connection.targetConnection;
|
|
caseBlock.statementConnection_ =
|
|
caseInput && caseInput.connection.targetConnection;
|
|
x++;
|
|
break;
|
|
case "case_default":
|
|
var defaultInput = this.getInput("ONDEFAULT");
|
|
caseBlock.satementConnection_ =
|
|
defaultInput && defaultInput.connection.targetConnection;
|
|
break;
|
|
default:
|
|
throw new Error("Unknown block type");
|
|
}
|
|
caseBlock =
|
|
caseBlock.nextConnection && caseBlock.nextConnection.targetBlock();
|
|
}
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["control_case"] = {
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendDummyInput().appendField(Blockly.Msg.cases_switch);
|
|
this.appendStatementInput("STACK");
|
|
this.setTooltip("--Placeholder--");
|
|
this.contextMenu = false;
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["case_incaseof"] = {
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendDummyInput().appendField(Blockly.Msg.cases_add);
|
|
this.setPreviousStatement(true);
|
|
this.setNextStatement(true);
|
|
this.setTooltip("--Placeholder--");
|
|
this.contextMenu = false;
|
|
},
|
|
};
|
|
|
|
Blockly.Blocks["case_default"] = {
|
|
init: function () {
|
|
this.setColour(getColour().logic);
|
|
this.appendValueInput("default").appendField("default");
|
|
this.setPreviousStatement(true);
|
|
this.setNextStatement(false);
|
|
this.setTooltip(
|
|
"This function will run if there aren't any matching cases."
|
|
);
|
|
this.contextMenu = false;
|
|
},
|
|
};
|