nodeskini 1.0.1 → 1.0.3

package/blocklySkini/blockly/core/variables_dynamic.js

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Utility functions for handling typed variables.
+ *
+ * @author duzc2dtw@gmail.com (Du Tian Wei)
+ */
+'use strict';
+
+goog.provide('Blockly.VariablesDynamic');
+
+goog.require('Blockly.Variables');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Msg');
+goog.require('Blockly.utils.xml');
+goog.require('Blockly.VariableModel');
+
+
+Blockly.VariablesDynamic.onCreateVariableButtonClick_String = function(button) {
+  Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace(),
+      undefined, 'String');
+};
+Blockly.VariablesDynamic.onCreateVariableButtonClick_Number = function(button) {
+  Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace(),
+      undefined, 'Number');
+};
+Blockly.VariablesDynamic.onCreateVariableButtonClick_Colour = function(button) {
+  Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace(),
+      undefined, 'Colour');
+};
+/**
+ * Construct the elements (blocks and button) required by the flyout for the
+ * variable category.
+ * @param {!Blockly.Workspace} workspace The workspace containing variables.
+ * @return {!Array.<!Element>} Array of XML elements.
+ */
+Blockly.VariablesDynamic.flyoutCategory = function(workspace) {
+  var xmlList = [];
+  var button = document.createElement('button');
+  button.setAttribute('text', Blockly.Msg['NEW_STRING_VARIABLE']);
+  button.setAttribute('callbackKey', 'CREATE_VARIABLE_STRING');
+  xmlList.push(button);
+  button = document.createElement('button');
+  button.setAttribute('text', Blockly.Msg['NEW_NUMBER_VARIABLE']);
+  button.setAttribute('callbackKey', 'CREATE_VARIABLE_NUMBER');
+  xmlList.push(button);
+  button = document.createElement('button');
+  button.setAttribute('text', Blockly.Msg['NEW_COLOUR_VARIABLE']);
+  button.setAttribute('callbackKey', 'CREATE_VARIABLE_COLOUR');
+  xmlList.push(button);
+
+  workspace.registerButtonCallback('CREATE_VARIABLE_STRING',
+      Blockly.VariablesDynamic.onCreateVariableButtonClick_String);
+  workspace.registerButtonCallback('CREATE_VARIABLE_NUMBER',
+      Blockly.VariablesDynamic.onCreateVariableButtonClick_Number);
+  workspace.registerButtonCallback('CREATE_VARIABLE_COLOUR',
+      Blockly.VariablesDynamic.onCreateVariableButtonClick_Colour);
+
+
+  var blockList = Blockly.VariablesDynamic.flyoutCategoryBlocks(workspace);
+  xmlList = xmlList.concat(blockList);
+  return xmlList;
+};
+
+/**
+ * Construct the blocks required by the flyout for the variable category.
+ * @param {!Blockly.Workspace} workspace The workspace containing variables.
+ * @return {!Array.<!Element>} Array of XML block elements.
+ */
+Blockly.VariablesDynamic.flyoutCategoryBlocks = function(workspace) {
+  var variableModelList = workspace.getAllVariables();
+
+  var xmlList = [];
+  if (variableModelList.length > 0) {
+    if (Blockly.Blocks['variables_set_dynamic']) {
+      var firstVariable = variableModelList[variableModelList.length - 1];
+      var block = Blockly.utils.xml.createElement('block');
+      block.setAttribute('type', 'variables_set_dynamic');
+      block.setAttribute('gap', 24);
+      block.appendChild(
+          Blockly.Variables.generateVariableFieldDom(firstVariable));
+      xmlList.push(block);
+    }
+    if (Blockly.Blocks['variables_get_dynamic']) {
+      variableModelList.sort(Blockly.VariableModel.compareByName);
+      for (var i = 0, variable; (variable = variableModelList[i]); i++) {
+        var block = Blockly.utils.xml.createElement('block');
+        block.setAttribute('type', 'variables_get_dynamic');
+        block.setAttribute('gap', 8);
+        block.appendChild(Blockly.Variables.generateVariableFieldDom(variable));
+        xmlList.push(block);
+      }
+    }
+  }
+  return xmlList;
+};

package/blocklySkini/blockly/core/warning.js

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Object representing a warning.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Warning');
+
+goog.require('Blockly.Bubble');
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Ui');
+goog.require('Blockly.Icon');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Svg');
+
+
+/**
+ * Class for a warning.
+ * @param {!Blockly.Block} block The block associated with this warning.
+ * @extends {Blockly.Icon}
+ * @constructor
+ */
+Blockly.Warning = function(block) {
+  Blockly.Warning.superClass_.constructor.call(this, block);
+  this.createIcon();
+  // The text_ object can contain multiple warnings.
+  this.text_ = {};
+};
+Blockly.utils.object.inherits(Blockly.Warning, Blockly.Icon);
+
+/**
+ * Does this icon get hidden when the block is collapsed.
+ */
+Blockly.Warning.prototype.collapseHidden = false;
+
+/**
+ * Draw the warning icon.
+ * @param {!Element} group The icon group.
+ * @protected
+ */
+Blockly.Warning.prototype.drawIcon_ = function(group) {
+  // Triangle with rounded corners.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.PATH,
+      {
+        'class': 'blocklyIconShape',
+        'd': 'M2,15Q-1,15 0.5,12L6.5,1.7Q8,-1 9.5,1.7L15.5,12Q17,15 14,15z'
+      },
+      group);
+  // Can't use a real '!' text character since different browsers and operating
+  // systems render it differently.
+  // Body of exclamation point.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.PATH,
+      {
+        'class': 'blocklyIconSymbol',
+        'd': 'm7,4.8v3.16l0.27,2.27h1.46l0.27,-2.27v-3.16z'
+      },
+      group);
+  // Dot of exclamation point.
+  Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.RECT,
+      {
+        'class': 'blocklyIconSymbol',
+        'x': '7', 'y': '11', 'height': '2', 'width': '2'
+      },
+      group);
+};
+
+/**
+ * Create the text for the warning's bubble.
+ * @param {string} text The text to display.
+ * @return {!SVGTextElement} The top-level node of the text.
+ * @private
+ */
+Blockly.Warning.textToDom_ = function(text) {
+  var paragraph = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.TEXT,
+      {
+        'class': 'blocklyText blocklyBubbleText blocklyNoPointerEvents',
+        'y': Blockly.Bubble.BORDER_WIDTH
+      },
+      null);
+  var lines = text.split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var tspanElement = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.TSPAN,
+        {'dy': '1em', 'x': Blockly.Bubble.BORDER_WIDTH}, paragraph);
+    var textNode = document.createTextNode(lines[i]);
+    tspanElement.appendChild(textNode);
+  }
+  return paragraph;
+};
+
+/**
+ * Show or hide the warning bubble.
+ * @param {boolean} visible True if the bubble should be visible.
+ */
+Blockly.Warning.prototype.setVisible = function(visible) {
+  if (visible == this.isVisible()) {
+    return;
+  }
+  Blockly.Events.fire(
+      new Blockly.Events.Ui(this.block_, 'warningOpen', !visible, visible));
+  if (visible) {
+    this.createBubble();
+  } else {
+    this.disposeBubble();
+  }
+};
+
+/**
+ * Show the bubble.
+ * @package
+ */
+Blockly.Warning.prototype.createBubble = function() {
+  // TODO (#2943): This is package because comments steal this UI for
+  //  non-editable comments, but really this should be private.
+  this.paragraphElement_ = Blockly.Warning.textToDom_(this.getText());
+  this.bubble_ = new Blockly.Bubble(
+      /** @type {!Blockly.WorkspaceSvg} */ (this.block_.workspace),
+      this.paragraphElement_, this.block_.pathObject.svgPath,
+      /** @type {!Blockly.utils.Coordinate} */ (this.iconXY_), null, null);
+  // Expose this warning's block's ID on its top-level SVG group.
+  this.bubble_.setSvgId(this.block_.id);
+  if (this.block_.RTL) {
+    // Right-align the paragraph.
+    // This cannot be done until the bubble is rendered on screen.
+    var maxWidth = this.paragraphElement_.getBBox().width;
+    for (var i = 0, textElement;
+      (textElement = this.paragraphElement_.childNodes[i]); i++) {
+
+      textElement.setAttribute('text-anchor', 'end');
+      textElement.setAttribute('x', maxWidth + Blockly.Bubble.BORDER_WIDTH);
+    }
+  }
+  this.applyColour();
+};
+
+/**
+ * Dispose of the bubble and references to it.
+ * @package
+ */
+Blockly.Warning.prototype.disposeBubble = function() {
+  // TODO (#2943): This is package because comments steal this UI for
+  //  non-editable comments, but really this should be private.
+  this.bubble_.dispose();
+  this.bubble_ = null;
+  this.body_ = null;
+  this.paragraphElement_ = null;
+};
+
+/**
+ * Set this warning's text.
+ * @param {string} text Warning text (or '' to delete). This supports
+ *    linebreaks.
+ * @param {string} id An ID for this text entry to be able to maintain
+ *     multiple warnings.
+ */
+Blockly.Warning.prototype.setText = function(text, id) {
+  if (this.text_[id] == text) {
+    return;
+  }
+  if (text) {
+    this.text_[id] = text;
+  } else {
+    delete this.text_[id];
+  }
+  if (this.isVisible()) {
+    this.setVisible(false);
+    this.setVisible(true);
+  }
+};
+
+/**
+ * Get this warning's texts.
+ * @return {string} All texts concatenated into one string.
+ */
+Blockly.Warning.prototype.getText = function() {
+  var allWarnings = [];
+  for (var id in this.text_) {
+    allWarnings.push(this.text_[id]);
+  }
+  return allWarnings.join('\n');
+};
+
+/**
+ * Dispose of this warning.
+ */
+Blockly.Warning.prototype.dispose = function() {
+  this.block_.warning = null;
+  Blockly.Icon.prototype.dispose.call(this);
+};

package/blocklySkini/blockly/core/widgetdiv.js

@@ -0,0 +1,241 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A div that floats on top of Blockly.  This singleton contains
+ *     temporary HTML UI widgets that the user is currently interacting with.
+ *     E.g. text input areas, colour pickers, context menus.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * @name Blockly.WidgetDiv
+ * @namespace
+ */
+goog.provide('Blockly.WidgetDiv');
+
+goog.require('Blockly.utils.style');
+
+goog.requireType('Blockly.utils.Rect');
+goog.requireType('Blockly.utils.Size');
+
+
+/**
+ * The object currently using this container.
+ * @type {Object}
+ * @private
+ */
+Blockly.WidgetDiv.owner_ = null;
+
+/**
+ * Optional cleanup function set by whichever object uses the widget.
+ * @type {Function}
+ * @private
+ */
+Blockly.WidgetDiv.dispose_ = null;
+
+/**
+ * A class name representing the current owner's workspace renderer.
+ * @type {string}
+ * @private
+ */
+Blockly.WidgetDiv.rendererClassName_ = '';
+
+/**
+ * A class name representing the current owner's workspace theme.
+ * @type {string}
+ * @private
+ */
+Blockly.WidgetDiv.themeClassName_ = '';
+
+/**
+ * Create the widget div and inject it onto the page.
+ */
+Blockly.WidgetDiv.createDom = function() {
+  if (Blockly.WidgetDiv.DIV) {
+    return;  // Already created.
+  }
+  /**
+   * The HTML container for popup overlays (e.g. editor widgets).
+   * @type {!Element}
+   */
+  Blockly.WidgetDiv.DIV = document.createElement('div');
+  Blockly.WidgetDiv.DIV.className = 'blocklyWidgetDiv';
+  var container = Blockly.parentContainer || document.body;
+  container.appendChild(Blockly.WidgetDiv.DIV);
+};
+
+/**
+ * Initialize and display the widget div.  Close the old one if needed.
+ * @param {!Object} newOwner The object that will be using this container.
+ * @param {boolean} rtl Right-to-left (true) or left-to-right (false).
+ * @param {Function} dispose Optional cleanup function to be run when the
+ *     widget is closed.
+ */
+Blockly.WidgetDiv.show = function(newOwner, rtl, dispose) {
+  Blockly.WidgetDiv.hide();
+  Blockly.WidgetDiv.owner_ = newOwner;
+  Blockly.WidgetDiv.dispose_ = dispose;
+  var div = Blockly.WidgetDiv.DIV;
+  div.style.direction = rtl ? 'rtl' : 'ltr';
+  div.style.display = 'block';
+  var mainWorkspace =
+    /** @type {!Blockly.WorkspaceSvg} */ (Blockly.getMainWorkspace());
+  Blockly.WidgetDiv.rendererClassName_ =
+      mainWorkspace.getRenderer().getClassName();
+  Blockly.WidgetDiv.themeClassName_ = mainWorkspace.getTheme().getClassName();
+  Blockly.utils.dom.addClass(div, Blockly.WidgetDiv.rendererClassName_);
+  Blockly.utils.dom.addClass(div, Blockly.WidgetDiv.themeClassName_);
+};
+
+/**
+ * Destroy the widget and hide the div.
+ */
+Blockly.WidgetDiv.hide = function() {
+  if (!Blockly.WidgetDiv.isVisible()) {
+    return;
+  }
+  Blockly.WidgetDiv.owner_ = null;
+
+  var div = Blockly.WidgetDiv.DIV;
+  div.style.display = 'none';
+  div.style.left = '';
+  div.style.top = '';
+  Blockly.WidgetDiv.dispose_ && Blockly.WidgetDiv.dispose_();
+  Blockly.WidgetDiv.dispose_ = null;
+  div.textContent = '';
+
+  if (Blockly.WidgetDiv.rendererClassName_) {
+    Blockly.utils.dom.removeClass(div, Blockly.WidgetDiv.rendererClassName_);
+    Blockly.WidgetDiv.rendererClassName_ = '';
+  }
+  if (Blockly.WidgetDiv.themeClassName_) {
+    Blockly.utils.dom.removeClass(div, Blockly.WidgetDiv.themeClassName_);
+    Blockly.WidgetDiv.themeClassName_ = '';
+  }
+  (/** @type {!Blockly.WorkspaceSvg} */ (
+    Blockly.getMainWorkspace())).markFocused();
+};
+
+/**
+ * Is the container visible?
+ * @return {boolean} True if visible.
+ */
+Blockly.WidgetDiv.isVisible = function() {
+  return !!Blockly.WidgetDiv.owner_;
+};
+
+/**
+ * Destroy the widget and hide the div if it is being used by the specified
+ * object.
+ * @param {!Object} oldOwner The object that was using this container.
+ */
+Blockly.WidgetDiv.hideIfOwner = function(oldOwner) {
+  if (Blockly.WidgetDiv.owner_ == oldOwner) {
+    Blockly.WidgetDiv.hide();
+  }
+};
+
+/**
+ * Set the widget div's position and height.  This function does nothing clever:
+ * it will not ensure that your widget div ends up in the visible window.
+ * @param {number} x Horizontal location (window coordinates, not body).
+ * @param {number} y Vertical location (window coordinates, not body).
+ * @param {number} height The height of the widget div (pixels).
+ * @private
+ */
+Blockly.WidgetDiv.positionInternal_ = function(x, y, height) {
+  Blockly.WidgetDiv.DIV.style.left = x + 'px';
+  Blockly.WidgetDiv.DIV.style.top = y + 'px';
+  Blockly.WidgetDiv.DIV.style.height = height + 'px';
+};
+
+/**
+ * Position the widget div based on an anchor rectangle.
+ * The widget should be placed adjacent to but not overlapping the anchor
+ * rectangle.  The preferred position is directly below and aligned to the left
+ * (LTR) or right (RTL) side of the anchor.
+ * @param {!Blockly.utils.Rect} viewportBBox The bounding rectangle of the
+ *     current viewport, in window coordinates.
+ * @param {!Blockly.utils.Rect} anchorBBox The bounding rectangle of the anchor,
+ *     in window coordinates.
+ * @param {!Blockly.utils.Size} widgetSize The size of the widget that is inside
+ *     the widget div, in window coordinates.
+ * @param {boolean} rtl Whether the workspace is in RTL mode.  This determines
+ *     horizontal alignment.
+ * @package
+ */
+Blockly.WidgetDiv.positionWithAnchor = function(viewportBBox, anchorBBox,
+    widgetSize, rtl) {
+  var y = Blockly.WidgetDiv.calculateY_(viewportBBox, anchorBBox, widgetSize);
+  var x = Blockly.WidgetDiv.calculateX_(viewportBBox, anchorBBox, widgetSize,
+      rtl);
+
+  if (y < 0) {
+    Blockly.WidgetDiv.positionInternal_(x, 0, widgetSize.height + y);
+  } else {
+    Blockly.WidgetDiv.positionInternal_(x, y, widgetSize.height);
+  }
+};
+
+/**
+ * Calculate an x position (in window coordinates) such that the widget will not
+ * be offscreen on the right or left.
+ * @param {!Blockly.utils.Rect} viewportBBox The bounding rectangle of the
+ *     current viewport, in window coordinates.
+ * @param {!Blockly.utils.Rect} anchorBBox The bounding rectangle of the anchor,
+ *     in window coordinates.
+ * @param {Blockly.utils.Size} widgetSize The dimensions of the widget inside the
+ *     widget div.
+ * @param {boolean} rtl Whether the Blockly workspace is in RTL mode.
+ * @return {number} A valid x-coordinate for the top left corner of the widget
+ *     div, in window coordinates.
+ * @private
+ */
+Blockly.WidgetDiv.calculateX_ = function(viewportBBox, anchorBBox, widgetSize,
+    rtl) {
+  if (rtl) {
+    // Try to align the right side of the field and the right side of widget.
+    var widgetLeft = anchorBBox.right - widgetSize.width;
+    // Don't go offscreen left.
+    var x = Math.max(widgetLeft, viewportBBox.left);
+    // But really don't go offscreen right:
+    return Math.min(x, viewportBBox.right - widgetSize.width);
+  } else {
+    // Try to align the left side of the field and the left side of widget.
+    // Don't go offscreen right.
+    var x = Math.min(anchorBBox.left, viewportBBox.right - widgetSize.width);
+    // But left is more important, because that's where the text is.
+    return Math.max(x, viewportBBox.left);
+  }
+};
+
+/**
+ * Calculate a y position (in window coordinates) such that the widget will not
+ * be offscreen on the top or bottom.
+ * @param {!Blockly.utils.Rect} viewportBBox The bounding rectangle of the
+ *     current viewport, in window coordinates.
+ * @param {!Blockly.utils.Rect} anchorBBox The bounding rectangle of the anchor,
+ *     in window coordinates.
+ * @param {Blockly.utils.Size} widgetSize The dimensions of the widget inside the
+ *     widget div.
+ * @return {number} A valid y-coordinate for the top left corner of the widget
+ *     div, in window coordinates.
+ * @private
+ */
+Blockly.WidgetDiv.calculateY_ = function(viewportBBox, anchorBBox, widgetSize) {
+  // Flip the widget vertically if off the bottom.
+  if (anchorBBox.bottom + widgetSize.height >= viewportBBox.bottom) {
+    // The bottom of the widget is at the top of the field.
+    return anchorBBox.top - widgetSize.height;
+    // The widget could go off the top of the window, but it would also go off
+    // the bottom.  The window is just too small.
+  } else {
+    // The top of the widget is at the bottom of the field.
+    return anchorBBox.bottom;
+  }
+};