Move basic cursor (#3460)

* Move basic cursor

blockly_uncompressed.js

@@ -47,7 +47,7 @@ goog.addDependency("../../core/dropdowndiv.js", ['Blockly.DropDownDiv'], ['Block
 goog.addDependency("../../core/events.js", ['Blockly.Events'], ['Blockly.utils']);
 goog.addDependency("../../core/events_abstract.js", ['Blockly.Events.Abstract'], ['Blockly.Events']);
 goog.addDependency("../../core/extensions.js", ['Blockly.Extensions'], ['Blockly.utils']);
-goog.addDependency("../../core/field.js", ['Blockly.Field'], ['Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Gesture', 'Blockly.utils', 'Blockly.utils.dom', 'Blockly.utils.Size', 'Blockly.utils.userAgent', 'Blockly.utils.style']);
+goog.addDependency("../../core/field.js", ['Blockly.Field'], ['Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Gesture', 'Blockly.utils', 'Blockly.utils.dom', 'Blockly.utils.Size', 'Blockly.utils.style', 'Blockly.utils.userAgent']);
 goog.addDependency("../../core/field_angle.js", ['Blockly.FieldAngle'], ['Blockly.Css', 'Blockly.DropDownDiv', 'Blockly.fieldRegistry', 'Blockly.FieldTextInput', 'Blockly.utils.dom', 'Blockly.utils.math', 'Blockly.utils.object', 'Blockly.utils.userAgent']);
 goog.addDependency("../../core/field_checkbox.js", ['Blockly.FieldCheckbox'], ['Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.fieldRegistry', 'Blockly.utils.dom', 'Blockly.utils.object', 'Blockly.utils.Size']);
 goog.addDependency("../../core/field_colour.js", ['Blockly.FieldColour'], ['Blockly.Css', 'Blockly.DropDownDiv', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.fieldRegistry', 'Blockly.navigation', 'Blockly.utils.aria', 'Blockly.utils.colour', 'Blockly.utils.dom', 'Blockly.utils.IdGenerator', 'Blockly.utils.KeyCodes', 'Blockly.utils.object', 'Blockly.utils.Size']);
@@ -75,12 +75,13 @@ goog.addDependency("../../core/input.js", ['Blockly.Input'], ['Blockly.Connectio
 goog.addDependency("../../core/insertion_marker_manager.js", ['Blockly.InsertionMarkerManager'], ['Blockly.blockAnimations', 'Blockly.Events']);
 goog.addDependency("../../core/keyboard_nav/action.js", ['Blockly.Action'], []);
 goog.addDependency("../../core/keyboard_nav/ast_node.js", ['Blockly.ASTNode'], ['Blockly.utils.Coordinate']);
+goog.addDependency("../../core/keyboard_nav/basic_cursor.js", ['Blockly.BasicCursor'], ['Blockly.ASTNode']);
 goog.addDependency("../../core/keyboard_nav/cursor.js", ['Blockly.Cursor'], ['Blockly.ASTNode', 'Blockly.navigation']);
 goog.addDependency("../../core/keyboard_nav/flyout_cursor.js", ['Blockly.FlyoutCursor'], ['Blockly.Cursor', 'Blockly.navigation', 'Blockly.utils.object']);
 goog.addDependency("../../core/keyboard_nav/key_map.js", ['Blockly.user.keyMap'], ['Blockly.utils.KeyCodes', 'Blockly.utils.object']);
 goog.addDependency("../../core/keyboard_nav/marker_cursor.js", ['Blockly.MarkerCursor'], ['Blockly.Cursor', 'Blockly.utils.object']);
 goog.addDependency("../../core/keyboard_nav/navigation.js", ['Blockly.navigation'], ['Blockly.Action', 'Blockly.ASTNode', 'Blockly.utils.Coordinate', 'Blockly.user.keyMap']);
-goog.addDependency("../../core/keyboard_nav/tab_navigate_cursor.js", ['Blockly.TabNavigateCursor'], ['Blockly.ASTNode', 'Blockly.Cursor', 'Blockly.utils.object']);
+goog.addDependency("../../core/keyboard_nav/tab_navigate_cursor.js", ['Blockly.TabNavigateCursor'], ['Blockly.ASTNode', 'Blockly.BasicCursor', 'Blockly.utils.object']);
 goog.addDependency("../../core/msg.js", ['Blockly.Msg'], ['Blockly.utils.global']);
 goog.addDependency("../../core/mutator.js", ['Blockly.Mutator'], ['Blockly.Bubble', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Events.Ui', 'Blockly.Icon', 'Blockly.navigation', 'Blockly.utils', 'Blockly.utils.dom', 'Blockly.utils.global', 'Blockly.utils.object', 'Blockly.utils.xml', 'Blockly.WorkspaceSvg', 'Blockly.Xml']);
 goog.addDependency("../../core/names.js", ['Blockly.Names'], ['Blockly.Msg']);
@@ -88,14 +89,14 @@ goog.addDependency("../../core/options.js", ['Blockly.Options'], ['Blockly.Theme
 goog.addDependency("../../core/procedures.js", ['Blockly.Procedures'], ['Blockly.Blocks', 'Blockly.constants', 'Blockly.Events', 'Blockly.Events.BlockChange', 'Blockly.Field', 'Blockly.Msg', 'Blockly.Names', 'Blockly.utils.xml', 'Blockly.Workspace', 'Blockly.Xml']);
 goog.addDependency("../../core/rendered_connection.js", ['Blockly.RenderedConnection'], ['Blockly.Connection', 'Blockly.Events', 'Blockly.utils', 'Blockly.utils.Coordinate', 'Blockly.utils.dom', 'Blockly.utils.object']);
 goog.addDependency("../../core/renderers/common/block_rendering.js", ['Blockly.blockRendering'], ['Blockly.utils.object']);
-goog.addDependency("../../core/renderers/common/constants.js", ['Blockly.blockRendering.ConstantProvider'], ['Blockly.utils.dom', 'Blockly.utils.svgPaths']);
+goog.addDependency("../../core/renderers/common/constants.js", ['Blockly.blockRendering.ConstantProvider'], ['Blockly.utils.dom', 'Blockly.utils.svgPaths', 'Blockly.utils.userAgent']);
 goog.addDependency("../../core/renderers/common/cursor_svg.js", ['Blockly.blockRendering.CursorSvg'], ['Blockly.ASTNode']);
 goog.addDependency("../../core/renderers/common/debugger.js", ['Blockly.blockRendering.Debug'], ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.SpacerRow', 'Blockly.blockRendering.TopRow', 'Blockly.blockRendering.Types']);
 goog.addDependency("../../core/renderers/common/drawer.js", ['Blockly.blockRendering.Drawer'], ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.SpacerRow', 'Blockly.blockRendering.TopRow', 'Blockly.blockRendering.Types', 'Blockly.utils.svgPaths']);
 goog.addDependency("../../core/renderers/common/i_path_object.js", ['Blockly.blockRendering.IPathObject'], []);
 goog.addDependency("../../core/renderers/common/info.js", ['Blockly.blockRendering.RenderInfo'], ['Blockly.blockRendering.BottomRow', 'Blockly.blockRendering.ExternalValueInput', 'Blockly.blockRendering.Hat', 'Blockly.blockRendering.InlineInput', 'Blockly.blockRendering.InRowSpacer', 'Blockly.blockRendering.InputRow', 'Blockly.blockRendering.Measurable', 'Blockly.blockRendering.NextConnection', 'Blockly.blockRendering.OutputConnection', 'Blockly.blockRendering.PreviousConnection', 'Blockly.blockRendering.RoundCorner', 'Blockly.blockRendering.Row', 'Blockly.blockRendering.SpacerRow', 'Blockly.blockRendering.StatementInput', 'Blockly.blockRendering.SquareCorner', 'Blockly.blockRendering.TopRow', 'Blockly.blockRendering.Types']);
 goog.addDependency("../../core/renderers/common/path_object.js", ['Blockly.blockRendering.PathObject'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.IPathObject', 'Blockly.Theme', 'Blockly.utils.dom']);
-goog.addDependency("../../core/renderers/common/renderer.js", ['Blockly.blockRendering.Renderer'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.Drawer', 'Blockly.blockRendering.IPathObject', 'Blockly.blockRendering.PathObject', 'Blockly.blockRendering.RenderInfo', 'Blockly.blockRendering.CursorSvg']);
+goog.addDependency("../../core/renderers/common/renderer.js", ['Blockly.blockRendering.Renderer'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.CursorSvg', 'Blockly.blockRendering.Drawer', 'Blockly.blockRendering.IPathObject', 'Blockly.blockRendering.PathObject', 'Blockly.blockRendering.RenderInfo']);
 goog.addDependency("../../core/renderers/geras/constants.js", ['Blockly.geras.ConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.utils.object']);
 goog.addDependency("../../core/renderers/geras/drawer.js", ['Blockly.geras.Drawer'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.blockRendering.Drawer', 'Blockly.geras.Highlighter', 'Blockly.geras.RenderInfo', 'Blockly.utils.object', 'Blockly.utils.svgPaths']);
 goog.addDependency("../../core/renderers/geras/highlight_constants.js", ['Blockly.geras.HighlightConstantProvider'], ['Blockly.blockRendering.ConstantProvider', 'Blockly.utils.svgPaths']);

core/keyboard_nav/basic_cursor.js

@@ -22,6 +22,10 @@
  */
 'use strict';
 
+goog.provide('Blockly.BasicCursor');
+
+goog.require('Blockly.ASTNode');
+
 
 /**
  * Class for a basic cursor.
@@ -35,12 +39,131 @@ Blockly.BasicCursor = function() {
 };
 Blockly.utils.object.inherits(Blockly.BasicCursor, Blockly.Cursor);
 
+/**
+ * Find the next node in the pre order traversal.
+ * @return {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.next = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getNextNode_(curNode, this.validNode_);
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * For a basic cursor we only have the ability to go next and previous, so
+ * in will also allow the user to get to the next node in the pre order traversal.
+ * @return {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.in = function() {
+  return this.next();
+};
+
+/**
+ * Find the previous node in the pre order traversal.
+ * @return {Blockly.ASTNode} The previous node, or null if the current node
+ *     is not set or there is no previous value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.prev = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getPreviousNode_(curNode, this.validNode_);
+  
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * For a basic cursor we only have the ability to go next and previou, so
+ * out will allow the user to get to the previous node in the pre order traversal.
+ * @return {Blockly.ASTNode} The previous node, or null if the current node is
+ *     not set or there is no previous value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.out = function() {
+  return this.prev();
+};
+
+/**
+ * Uses pre order traversal to navigate the Blockly AST. This will allow
+ * a user to easily navigate the entire Blockly AST without having to go in
+ * and out levels on the tree.
+ * @param {Blockly.ASTNode} node The current position in the AST.
+ * @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
+ *     depending on whether the given node should be traversed.
+ * @return {Blockly.ASTNode} The next node in the traversal.
+ * @protected
+ */
+Blockly.BasicCursor.prototype.getNextNode_ = function(node, isValid) {
+  if (!node) {
+    return null;
+  }
+  var newNode = node.in() || node.next();
+  if (isValid(newNode)) {
+    return newNode;
+  } else if (newNode) {
+    return this.getNextNode_(newNode, isValid);
+  }
+  var siblingOrParent = this.findSiblingOrParent_(node.out());
+  if (isValid(siblingOrParent)) {
+    return siblingOrParent;
+  } else if (siblingOrParent) {
+    return this.getNextNode_(siblingOrParent, isValid);
+  }
+  return null;
+};
+
+/**
+ * Reverses the pre order traversal in order to find the previous node. This will
+ * allow a user to easily navigate the entire Blockly AST without having to go in
+ * and out levels on the tree.
+ * @param {Blockly.ASTNode} node The current position in the AST.
+ * @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
+ *     depending on whether the given node should be traversed.
+ * @return {Blockly.ASTNode} The previous node in the traversal or null if no
+ *     previous node exists.
+ * @protected
+ */
+Blockly.BasicCursor.prototype.getPreviousNode_ = function(node, isValid) {
+  if (!node) {
+    return null;
+  }
+  var newNode = node.prev();
+
+  if (newNode) {
+    newNode = this.getRightMostChild_(newNode);
+  } else {
+    newNode = node.out();
+  }
+  if (isValid(newNode)) {
+    return newNode;
+  } else if (newNode) {
+    return this.getPreviousNode_(newNode, isValid);
+  }
+  return null;
+};
+
 /**
  * Decides what nodes to traverse and which ones to skip. Currently, it
  * skips output, stack and workspace nodes.
  * @param {Blockly.ASTNode} node The AST node to check whether it is valid.
  * @return {boolean} True if the node should be visited, false otherwise.
- * @private
+ * @protected
  */
 Blockly.BasicCursor.prototype.validNode_ = function(node) {
   var isValid = false;
@@ -74,32 +197,6 @@ Blockly.BasicCursor.prototype.findSiblingOrParent_ = function(node) {
   return this.findSiblingOrParent_(node.out());
 };
 
-/**
- * Uses pre order traversal to navigate the Blockly AST. This will allow
- * a user to easily navigate the entire Blockly AST without having to go in
- * and out levels on the tree.
- * @param {Blockly.ASTNode} node The current position in the AST.
- * @return {Blockly.ASTNode} The next node in the traversal.
- * @private
- */
-Blockly.BasicCursor.prototype.getNextNode_ = function(node) {
-  if (!node) {
-    return null;
-  }
-  var newNode = node.in() || node.next();
-  if (this.validNode_(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getNextNode_(newNode);
-  }
-  var siblingOrParent = this.findSiblingOrParent_(node.out());
-  if (this.validNode_(siblingOrParent)) {
-    return siblingOrParent;
-  } else if (siblingOrParent) {
-    return this.getNextNode_(siblingOrParent);
-  }
-  return null;
-};
 
 /**
  * Get the right most child of a node.
@@ -119,91 +216,3 @@ Blockly.BasicCursor.prototype.getRightMostChild_ = function(node) {
   return this.getRightMostChild_(newNode);
 
 };
-
-/**
- * Reverses the pre order traversal in order to find the previous node. This will
- * allow a user to easily navigate the entire Blockly AST without having to go in
- * and out levels on the tree.
- * @param {Blockly.ASTNode} node The current position in the AST.
- * @return {Blockly.ASTNode} The previous node in the traversal or null if no
- *     previous node exists.
- * @private
- */
-Blockly.BasicCursor.prototype.getPreviousNode_ = function(node) {
-  if (!node) {
-    return null;
-  }
-  var newNode = node.prev();
-
-  if (newNode) {
-    newNode = this.getRightMostChild_(newNode);
-  } else {
-    newNode = node.out();
-  }
-  if (this.validNode_(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getPreviousNode_(newNode);
-  }
-  return null;
-};
-
-/**
- * Find the next node in the pre order traversal.
- * @return {Blockly.ASTNode} The next node, or null if the current node is
- *     not set or there is no next value.
- * @override
- */
-Blockly.BasicCursor.prototype.next = function() {
-  var curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  var newNode = this.getNextNode_(curNode);
-
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
-
-/**
- * For a basic cursor we only have the ability to go next and previous, so
- * in will also allow the user to get to the next node in the pre order traversal.
- * @return {Blockly.ASTNode} The next node, or null if the current node is
- *     not set or there is no next value.
- * @override
- */
-Blockly.BasicCursor.prototype.in = function() {
-  return this.next();
-};
-
-/**
- * Find the previous node in the pre order traversal.
- * @return {Blockly.ASTNode} The previous node, or null if the current node
- *     is not set or there is no previous value.
- * @override
- */
-Blockly.BasicCursor.prototype.prev = function() {
-  var curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  var newNode = this.getPreviousNode_(curNode);
-  
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
-
-/**
- * For a basic cursor we only have the ability to go next and previou, so
- * out will allow the user to get to the previous node in the pre order traversal.
- * @return {Blockly.ASTNode} The previous node, or null if the current node is
- *     not set or there is no previous value.
- * @override
- */
-Blockly.BasicCursor.prototype.out = function() {
-  return this.prev();
-};

core/keyboard_nav/tab_navigate_cursor.js

@@ -25,59 +25,25 @@
 goog.provide('Blockly.TabNavigateCursor');
 
 goog.require('Blockly.ASTNode');
-goog.require('Blockly.Cursor');
+goog.require('Blockly.BasicCursor');
 goog.require('Blockly.utils.object');
 
 
 /**
  * A cursor for navigating between tab navigable fields.
  * @constructor
- * @extends {Blockly.Cursor}
+ * @extends {Blockly.BasicCursor}
  */
 Blockly.TabNavigateCursor = function() {
   Blockly.TabNavigateCursor.superClass_.constructor.call(this);
 };
-Blockly.utils.object.inherits(Blockly.TabNavigateCursor, Blockly.Cursor);
-
-/**
- * Find the next node in the pre order traversal.
- * @override
- */
-Blockly.TabNavigateCursor.prototype.next = function() {
-  var curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  var newNode = this.getNextNode_(curNode);
-
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
-
-/**
- * Find the previous node in the pre order traversal.
- * @override
- */
-Blockly.TabNavigateCursor.prototype.prev = function() {
-  var curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  var newNode = this.getPreviousNode_(curNode);
-
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
+Blockly.utils.object.inherits(Blockly.TabNavigateCursor, Blockly.BasicCursor);
 
 /**
  * Skip all nodes except for tab navigable fields.
  * @param {Blockly.ASTNode} node The AST node to check whether it is valid.
  * @return {boolean} True if the node should be visited, false otherwise.
- * @private
+ * @override
  */
 Blockly.TabNavigateCursor.prototype.validNode_ = function(node) {
   var isValid = false;
@@ -92,90 +58,3 @@ Blockly.TabNavigateCursor.prototype.validNode_ = function(node) {
   }
   return isValid;
 };
-
-/**
- * From a given node find either the next valid sibling or parent.
- * @param {Blockly.ASTNode} node The current position in the AST.
- * @return {Blockly.ASTNode} The parent AST node or null if there are no
- *     valid parents.
- * @private
- */
-Blockly.TabNavigateCursor.prototype.findSiblingOrParent_ = function(node) {
-  if (!node) {
-    return null;
-  }
-  var nextNode = node.next();
-  if (nextNode) {
-    return nextNode;
-  }
-  return this.findSiblingOrParent_(node.out());
-};
-
-/**
- * Navigate the Blockly AST using pre-order traversal.
- * @param {Blockly.ASTNode} node The current position in the AST.
- * @return {Blockly.ASTNode} The next node in the traversal.
- * @private
- */
-Blockly.TabNavigateCursor.prototype.getNextNode_ = function(node) {
-  if (!node) {
-    return null;
-  }
-  var newNode = node.in() || node.next();
-  if (this.validNode_(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getNextNode_(newNode);
-  }
-  var siblingOrParent = this.findSiblingOrParent_(node.out());
-  if (this.validNode_(siblingOrParent)) {
-    return siblingOrParent;
-  } else if (siblingOrParent) {
-    return this.getNextNode_(siblingOrParent);
-  }
-  return null;
-};
-
-/**
- * Get the right most child of a node.
- * @param {Blockly.ASTNode} node The node to find the right most child of.
- * @return {Blockly.ASTNode} The right most child of the given node, or the node
- *     if no child exists.
- * @private
- */
-Blockly.TabNavigateCursor.prototype.getRightMostChild_ = function(node) {
-  if (!node.in()) {
-    return node;
-  }
-  var newNode = node.in();
-  while (newNode.next()) {
-    newNode = newNode.next();
-  }
-  return this.getRightMostChild_(newNode);
-};
-
-/**
- * Use reverse pre-order traversal in order to find the previous node.
- * @param {Blockly.ASTNode} node The current position in the AST.
- * @return {Blockly.ASTNode} The previous node in the traversal or null if no
- *     previous node exists.
- * @private
- */
-Blockly.TabNavigateCursor.prototype.getPreviousNode_ = function(node) {
-  if (!node) {
-    return null;
-  }
-  var newNode = node.prev();
-
-  if (newNode) {
-    newNode = this.getRightMostChild_(newNode);
-  } else {
-    newNode = node.out();
-  }
-  if (this.validNode_(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getPreviousNode_(newNode);
-  }
-  return null;
-};

demos/keyboard_nav/index.html

@@ -7,7 +7,7 @@
   <script src="../../blocks_compressed.js"></script>
   <script src="../../javascript_compressed.js"></script>
   <script src="../../msg/js/en.js"></script>
-  <script src="basic_cursor.js"></script>
+  <script src="line_cursor.js"></script>
   <style>
     body {
       background-color: #fff;
@@ -88,6 +88,7 @@
     <select id="cursorChanger" name="cursor" onchange="changeCursor(this.value)">
       <option value="default">Default Cursor</option>
       <option value="basic">Basic Cursor</option>
+      <option value="line">Line Cursor</option>
     </select>
 
     <button onclick="preOrderDemo()">Start Pre-order Demo</button>
@@ -290,8 +291,13 @@
       var oldCurNode = Blockly.getMainWorkspace().getCursor().getCurNode();
 
       if (cursorType === "basic") {
+        Blockly.ASTNode.NAVIGATE_ALL_FIELDS = false;
         Blockly.getMainWorkspace().setCursor(new Blockly.BasicCursor());
+      } else if (cursorType === "line") {
+        Blockly.ASTNode.NAVIGATE_ALL_FIELDS = true;
+        Blockly.getMainWorkspace().setCursor(new Blockly.LineCursor());
       } else {
+        Blockly.ASTNode.NAVIGATE_ALL_FIELDS = false;
         Blockly.getMainWorkspace().setCursor(new Blockly.Cursor());
       }
       if (oldCurNode) {

demos/keyboard_nav/line_cursor.js

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview The class representing a line cursor.
+ * A line cursor traverses the blocks as if they were
+ * lines of code in a text editor. 
+ * Previous and next go up and down lines. In and out go
+ * through the elements in a line.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+'use strict';
+
+
+/**
+ * Class for a line cursor.
+ * This will allow the user to get to all nodes in the AST by hitting next or
+ * previous.
+ * @constructor
+ * @extends {Blockly.BasicCursor}
+ */
+Blockly.LineCursor = function() {
+  Blockly.LineCursor.superClass_.constructor.call(this);
+};
+Blockly.utils.object.inherits(Blockly.LineCursor, Blockly.BasicCursor);
+
+
+/**
+ * Find the next node in the pre order traversal.
+ * @return {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.LineCursor.prototype.next = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getNextNode_(curNode, this.validLineNode_);
+
+  // Skip the input or next value if there is a connected block.
+  if (newNode && (newNode.getType() == Blockly.ASTNode.types.INPUT ||
+      newNode.getType() == Blockly.ASTNode.types.NEXT) &&
+      newNode.getLocation().targetBlock()) {
+    newNode = this.getNextNode_(newNode, this.validLineNode_);
+  }
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * For a basic cursor we only have the ability to go next and previous, so
+ * in will also allow the user to get to the next node in the pre order traversal.
+ * @return {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.LineCursor.prototype.in = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getNextNode_(curNode, this.validInLineNode_);
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * Find the previous node in the pre order traversal.
+ * @return {Blockly.ASTNode} The previous node, or null if the current node
+ *     is not set or there is no previous value.
+ * @override
+ */
+Blockly.LineCursor.prototype.prev = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getPreviousNode_(curNode, this.validLineNode_);
+  
+  if (newNode && (newNode.getType() == Blockly.ASTNode.types.INPUT ||
+    newNode.getType() == Blockly.ASTNode.types.NEXT) &&
+    newNode.getLocation().targetBlock()) {
+    newNode = this.getPreviousNode_(newNode, this.validLineNode_);
+  }
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * For a basic cursor we only have the ability to go next and previou, so
+ * out will allow the user to get to the previous node in the pre order traversal.
+ * @return {Blockly.ASTNode} The previous node, or null if the current node is
+ *     not set or there is no previous value.
+ * @override
+ */
+Blockly.LineCursor.prototype.out = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getPreviousNode_(curNode, this.validInLineNode_);
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+
+};
+
+/**
+ * Meant to traverse by lines of code. This is blocks, statement inputs and
+ * next connections.
+ * @param {Blockly.ASTNode} node The AST node to check whether it is valid.
+ * @return {boolean} True if the node should be visited, false otherwise.
+ * @private
+ */
+Blockly.LineCursor.prototype.validLineNode_ = function(node) {
+  if (!node) {
+    return false;
+  }
+  var isValid = false;
+  var location = node.getLocation();
+  var type = node && node.getType();
+  if (type == Blockly.ASTNode.types.BLOCK) {
+    if (location.outputConnection === null) {
+      isValid = true;
+    }
+  } else if (type == Blockly.ASTNode.types.INPUT && 
+      location.type == Blockly.NEXT_STATEMENT) {
+    isValid = true;
+  } else if (type == Blockly.ASTNode.types.NEXT) {
+    isValid = true;
+  }
+  return isValid;
+};
+
+/**
+ * Meant to traverse within a block. These are fields and input values.
+ * @param {Blockly.ASTNode} node The AST node to check whether it is valid.
+ * @return {boolean} True if the node should be visited, false otherwise.
+ * @private
+ */
+Blockly.LineCursor.prototype.validInLineNode_ = function(node) {
+  if (!node) {
+    return false;
+  }
+  var isValid = false;
+  var location = node.getLocation();
+  var type = node && node.getType();
+  if (type == Blockly.ASTNode.types.FIELD) {
+      isValid = true;
+  } else if (type == Blockly.ASTNode.types.INPUT &&
+      location.type == Blockly.INPUT_VALUE) {
+      isValid = true;
+  }
+  return isValid;
+};

tests/mocha/run_mocha_tests_in_browser.js

@@ -51,7 +51,7 @@ async function runMochaTestsInBrowser() {
     var elem = await browser.$('#failureCount');
     var text = await elem.getAttribute('tests_failed');
     return text != 'unset';
-  }, 6000);
+  }, 7000);
 
   const elem = await browser.$('#failureCount');
   const numOfFailure = await elem.getAttribute('tests_failed');