/**
 * @license
 * Visual Blocks Editor
 *
 * Copyright 2012 Google Inc.
 * https://developers.google.com/blockly/
 *
 * 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.
 */
using System;
using System.Collections.Generic;
using Bridge;
using Bridge.Html5;

namespace WebMrbc
{
	/**
	 * @fileoverview Core JavaScript library for Blockly.
	 * @author fraser@google.com (Neil Fraser)
	 */
	[External, Name("Blockly")]
	public partial class Blockly
	{
		[Name(false)]
		public static Xml Xml;
		[Name(false)]
		public static Events Events;
		[Name(false)]
		public static Procedures Procedures;
		[Name(false)]
		public static Variables Variables;
		[Name(false)]
		public static Names Names;

		/// <summary>
		/// Number of pixels the mouse must move before a drag starts.
		/// </summary>
		[Name(false)]
		public static int DRAG_RADIUS = 5;

		/// <summary>
		/// Maximum misalignment between connections for them to snap together.
		/// </summary>
		[Name(false)]
		public static int SNAP_RADIUS = 20;

		/// <summary>
		/// Delay in ms between trigger and bumping unconnected block out of alignment.
		/// </summary>
		[Name(false)]
		public static int BUMP_DELAY = 250;

		/// <summary>
		/// Number of characters to truncate a collapsed block to.
		/// </summary>
		[Name(false)]
		public static int COLLAPSE_CHARS = 30;

		/// <summary>
		/// Length in ms for a touch to become a long press.
		/// </summary>
		[Name(false)]
		public static int LONGPRESS = 750;

		/// <summary>
		/// Prevent a sound from playing if another sound preceded it within this many
		/// miliseconds.
		/// </summary>
		[Name(false)]
		public static int SOUND_LIMIT = 100;

		/// <summary>
		/// The richness of block colours, regardless of the hue.
		/// Must be in the range of 0 (inclusive) to 1 (exclusive).
		/// </summary>
		[Name(false)]
		public static double HSV_SATURATION = 0.45;

		/// <summary>
		/// The intensity of block colours, regardless of the hue.
		/// Must be in the range of 0 (inclusive) to 1 (exclusive).
		/// </summary>
		[Name(false)]
		public static double HSV_VALUE = 0.65;

		/// <summary>
		/// Sprited icons and images.
		/// </summary>
		[Name(false)]
		public static object SPRITE = new {
			width = 96,
			height = 124,
			url = "sprites.png"
		};

		/// <summary>
		/// Required name space for SVG elements.
		/// </summary>
		[Name(false)]
		public static readonly string SVG_NS = "http://www.w3.org/2000/svg";

		/// <summary>
		/// Required name space for HTML elements.
		/// </summary>
		[Name(false)]
		public static readonly string HTML_NS = "http://www.w3.org/1999/xhtml";

		/// <summary>
		/// ENUM for a right-facing value input.  E.g. 'set item to' or 'return'.
		/// </summary>
		[Name(false)]
		public static int INPUT_VALUE = 1;

		/// <summary>
		/// ENUM for a left-facing value output.  E.g. 'random fraction'.
		/// </summary>
		[Name(false)]
		public static int OUTPUT_VALUE = 2;

		/// <summary>
		/// ENUM for a down-facing block stack.  E.g. 'if-do' or 'else'.
		/// </summary>
		[Name(false)]
		public static int NEXT_STATEMENT = 3;

		/// <summary>
		/// ENUM for an up-facing block stack.  E.g. 'break out of loop'.
		/// </summary>
		[Name(false)]
		public static int PREVIOUS_STATEMENT = 4;

		/// <summary>
		/// ENUM for an dummy input.  Used to add field(s) with no input.
		/// </summary>
		[Name(false)]
		public static int DUMMY_INPUT = 5;

		/// <summary>
		/// ENUM for left alignment.
		/// </summary>
		[Name(false)]
		public static int ALIGN_LEFT = -1;

		/// <summary>
		/// ENUM for centre alignment.
		/// </summary>
		[Name(false)]
		public static int ALIGN_CENTRE = 0;

		/// <summary>
		/// ENUM for right alignment.
		/// </summary>
		[Name(false)]
		public static int ALIGN_RIGHT = 1;

		/// <summary>
		/// ENUM for no drag operation.
		/// </summary>
		[Name(false)]
		public static int DRAG_NONE = 0;

		/// <summary>
		/// ENUM for inside the sticky DRAG_RADIUS.
		/// </summary>
		[Name(false)]
		public static int DRAG_STICKY = 1;

		/// <summary>
		/// ENUM for inside the non-sticky DRAG_RADIUS, for differentiating between
		/// clicks and drags.
		/// </summary>
		[Name(false)]
		public static int DRAG_BEGIN = 1;

		/// <summary>
		/// ENUM for freely draggable (outside the DRAG_RADIUS, if one applies).
		/// </summary>
		[Name(false)]
		public static int DRAG_FREE = 2;

		/// <summary>
		/// Lookup table for determining the opposite type of a connection.
		/// </summary>
		[Name(false)]
		public static int[] OPPOSITE_TYPE = {
			0,
			OUTPUT_VALUE,
			INPUT_VALUE,
			PREVIOUS_STATEMENT,
			NEXT_STATEMENT
		};

		/// <summary>
		/// ENUM for toolbox and flyout at top of screen.
		/// </summary>
		[Name(false)]
		public static int TOOLBOX_AT_TOP = 0;

		/// <summary>
		/// ENUM for toolbox and flyout at bottom of screen.
		/// </summary>
		[Name(false)]
		public static int TOOLBOX_AT_BOTTOM = 1;

		/// <summary>
		/// ENUM for toolbox and flyout at left of screen.
		/// </summary>
		[Name(false)]
		public static int TOOLBOX_AT_LEFT = 2;

		/// <summary>
		/// ENUM for toolbox and flyout at right of screen.
		/// </summary>
		[Name(false)]
		public static int TOOLBOX_AT_RIGHT = 3;

		/// <summary>
		/// The main workspace most recently used.
		/// Set by Blockly.WorkspaceSvg.prototype.markFocused
		/// </summary>
		public static WorkspaceSvg mainWorkspace;

		/// <summary>
		/// Currently selected block.
		/// </summary>
		public static Block selected;

		[Name(false)]
		public static Blocks Blocks;

		/// <summary>
		/// Register a callback function associated with a given key, for clicks on
		/// buttons and labels in the flyout.
		/// For instance, a button specified by the XML
		/// <button text="create variable" callbackKey="CREATE_VARIABLE"></button>
		/// should be matched by a call to
		/// registerButtonCallback("CREATE_VARIABLE", yourCallbackFunction).
		/// </summary>
		/// <param name="key">The name to use to look up this function.</param>
		/// <param name="func">The function to call when the
		/// given button is clicked.</param>
		internal static void registerButtonCallback(string key, Action<FlyoutButton> func)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Convert a hue (HSV model) into an RGB hex triplet.
		/// </summary>
		/// <param name="hue">Hue on a colour wheel (0-360).</param>
		/// <returns>RGB code, e.g. '#5ba65b'.</returns>
		public static string hueToRgb(int hue)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Returns the dimensions of the specified SVG image.
		/// </summary>
		/// <param name="svg">SVG image.</param>
		/// <returns>Contains width and height properties.</returns>
		public static goog.math.Size svgSize(Element svg)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Size the workspace when the contents change.  This also updates
		/// scrollbars accordingly.
		/// </summary>
		/// <param name="workspace"></param>
		public static void resizeSvgContents(WorkspaceSvg workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Size the SVG image to completely fill its container. Call this when the view
		/// actually changes sizes (e.g. on a window resize/device orientation change).
		/// See Blockly.resizeSvgContents to resize the workspace when the contents
		/// change (e.g. when a block is added or removed).
		/// Record the height/width of the SVG image.
		/// </summary>
		/// <param name="workspace">Any workspace in the SVG.</param>
		public static void svgResize(WorkspaceSvg workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Close tooltips, context menus, dropdown selections, etc.
		/// </summary>
		/// <param name="opt_allowToolbox">If true, don't close the toolbox.</param>
		public static void hideChaff(bool opt_allowToolbox = false)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// When something in Blockly's workspace changes, call a function.
		/// </summary>
		/// <param name="func">Function to call.</param>
		/// <returns>Opaque data that can be passed to removeChangeListener.</returns>
		public static Action<Abstract> addChangeListener(Action<Abstract> func)
		{
			// Backwards compatability from before there could be multiple workspaces.
			App.WriteLine("Deprecated call to Blockly.addChangeListener, " +
						 "use workspace.addChangeListener instead.");
			return getMainWorkspace().addChangeListener(func);
		}

		/// <summary>
		/// Returns the main workspace.  Returns the last used main workspace (based on
		/// focus).  Try not to use this function, particularly if there are multiple
		/// Blockly instances on a page.
		/// </summary>
		/// <returns>The main workspace.</returns>
		public static WorkspaceSvg getMainWorkspace()
		{
			return mainWorkspace;
		}

		/// <summary>
		/// Wrapper to window.alert() that app developers may override to
		/// provide alternatives to the modal browser window.
		/// </summary>
		/// <param name="message">The message to display to the user.</param>
		/// <param name="opt_callback">The callback when the alert is dismissed.</param>
		internal static void alert(string message, Action opt_callback = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Wrapper to window.prompt() that app developers may override to provide
		/// alternatives to the modal browser window. Built-in browser prompts are
		/// often used for better text input experience on mobile device. We strongly
		/// recommend testing mobile when overriding this.
		/// </summary>
		/// <param name="message">The message to display to the user.</param>
		/// <param name="defaultValue">The value to initialize the prompt with.</param>
		/// <param name="callback">The callback for handling user reponse.</param>
		internal static void prompt(string message, string defaultValue, Action<string> callback)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Inject a Blockly editor into the specified container element (usually a div).
		/// </summary>
		/// <param name="container">Containing element, or its ID, or a CSS selector.</param>
		/// <param name="opt_options">opt_options Optional dictionary of options.</param>
		/// <returns>Newly created main workspace.</returns>
		public static WorkspaceSvg inject(Union<string, Element> container, object opt_options = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Modify the block tree on the existing toolbox.
		/// </summary>
		/// <param name="tree">DOM tree of blocks, or text representation of same.</param>
		public static void updateToolbox(Union<Node, string> tree)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Don't do anything for this event, just halt propagation.
		/// </summary>
		/// <param name="e">An event.</param>
		public static void noEvent(Event e)
		{
			// This event has been handled.  No need to bubble up to the document.
			e.PreventDefault();
			e.StopPropagation();
		}

		/// <summary>
		/// Helper method for creating SVG elements.
		/// </summary>
		/// <param name="name">Element's tag name.</param>
		/// <param name="attrs">Dictionary of attribute names and values.</param>
		/// <param name="parent">Optional parent on which to append the element.</param>
		/// <param name="opt_workspace">Optional workspace for access to context (scale...).</param>
		/// <returns>Newly created SVG element.</returns>
		public static Element createSvgElement(string name, object attrs, Element parent, Workspace opt_workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Is this event a right-click?
		/// </summary>
		/// <param name="e">Mouse event.</param>
		/// <returns>True if right-click.</returns>
		public static bool isRightButton(Event e)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Return the converted coordinates of the given mouse event.
		/// The origin (0,0) is the top-left corner of the Blockly svg.
		/// </summary>
		/// <param name="e">Mouse event.</param>
		/// <param name="svg">SVG element.</param>
		/// <param name="matrix">Inverted screen CTM to use.</param>
		/// <returns>Object with .x and .y properties.</returns>
		public static goog.math.Coordinate mouseToSvg(Event e, Element svg, SVGMatrix matrix)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Given an array of strings, return the length of the shortest one.
		/// </summary>
		/// <param name="array">Array of strings.</param>
		/// <returns>Length of shortest string.</returns>
		public static int shortestStringLength(string[] array)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Given an array of strings, return the length of the common prefix.
		/// Words may not be split.  Any space after a word is included in the length.
		/// </summary>
		/// <param name="array">Array of strings.</param>
		/// <param name="opt_shortest">Length of shortest string.</param>
		/// <returns>Length of common prefix.</returns>
		public static int commonWordPrefix(string[] array, int opt_shortest = 0)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Given an array of strings, return the length of the common suffix.
		/// Words may not be split.  Any space after a word is included in the length.
		/// </summary>
		/// <param name="array">Array of strings.</param>
		/// <param name="opt_shortest">Length of shortest string.</param>
		/// <returns>Length of common suffix.</returns>
		public static int commonWordSuffix(string[] array, int opt_shortest = 0)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Is the given string a number (includes negative and decimals).
		/// </summary>
		/// <param name="str">Input string.</param>
		/// <returns>True if number, false otherwise.</returns>
		public static bool isNumber(string str)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Parse a string with any number of interpolation tokens (%1, %2, ...).
		/// '%' characters may be self-escaped (%%).
		/// </summary>
		/// <param name="message">Text containing interpolation tokens.</param>
		/// <returns>Array of strings and numbers.</returns>
		public static Union<string, int> tokenizeInterpolation(string message)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Generate a unique ID.  This should be globally unique.
		/// 87 characters ^ 20 length > 128 bits (better than a UUID).
		/// </summary>
		/// <returns>A globally unique ID string.</returns>
		public static string genUid()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Wrap text to the specified width.
		/// </summary>
		/// <param name="text">Text to wrap.</param>
		/// <param name="wrap">Width to wrap each line.</param>
		/// <returns></returns>
		public static string wrap(string text, int wrap)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Xml")]
	public class Xml
	{
		/// <summary>
		/// Encode a block tree as XML.
		/// </summary>
		/// <param name="workspace">workspace The workspace containing blocks.</param>
		/// <returns>XML document.</returns>
		public Element workspaceToDom(Workspace workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Encode a block subtree as XML with XY coordinates.
		/// </summary>
		/// <param name="block">The root block to encode.</param>
		/// <returns>Tree of XML elements.</returns>
		public Element blockToDomWithXY(Block block)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Encode a block subtree as XML.
		/// </summary>
		/// <param name="block">The root block to encode.</param>
		/// <returns>Tree of XML elements.</returns>
		public Element blockToDom(Block block)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Converts a DOM structure into plain text.
		/// Currently the text format is fairly ugly: all one line with no whitespace.
		/// </summary>
		/// <param name="dom">A tree of XML elements.</param>
		/// <returns>Text representation.</returns>
		public string domToText(Element dom)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Converts a DOM structure into properly indented text.
		/// </summary>
		/// <param name="dom">A tree of XML elements.</param>
		/// <returns>Text representation.</returns>
		public string domToPrettyText(Element dom)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Converts plain text into a DOM structure.
		/// Throws an error if XML doesn't parse.
		/// </summary>
		/// <param name="text">Text representation.</param>
		/// <returns>A tree of XML elements.</returns>
		public Element textToDom(string text)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Decode an XML DOM and create blocks on the workspace.
		/// </summary>
		/// <param name="xml">XML DOM.</param>
		/// <param name="workspace">The workspace.</param>
		public void domToWorkspace(Element xml, Workspace workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Decode an XML block tag and create a block (and possibly sub blocks) on the
		/// workspace.
		/// </summary>
		/// <param name="xmlBlock">XML block element.</param>
		/// <param name="workspace">The workspace.</param>
		/// <returns>The root block created.</returns>
		public Block domToBlock(Element xmlBlock, Workspace workspace)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Remove any 'next' block (statements in a stack).
		/// </summary>
		/// <param name="xmlBlock">XML block element.</param>
		public void deleteNext(Element xmlBlock)
		{
			throw new NotImplementedException();
		}
	}

	/**
	 * @fileoverview Object representing a workspace.
	 * @author fraser@google.com (Neil Fraser)
	 */
	[External, Name("Blockly.Workspace")]
	public class Workspace
	{
		public string id;
		public Options options;
		public bool RTL;
		public bool horizontalLayout;
		public int toolboxPosition;
		public bool isFlyout;

		/// <summary>
		/// A list of all of the named variables in the workspace, including variables
		/// that are not currently in use.
		/// </summary>
		public string[] variableList;

		/// <summary>
		/// Workspaces may be headless.
		/// True if visible.  False if headless.
		/// </summary>
		public bool rendered;

		/// <summary>
		/// Maximum number of undo events in stack.
		/// 0 to turn off undo, Infinity for unlimited.
		/// </summary>
		public int MAX_UNDO = 1024;

		/// <summary>
		/// Class for a workspace.  This is a data structure that contains blocks.
		/// There is no UI, and can be created headlessly.
		/// </summary>
		/// <param name="opt_options">Dictionary of options.</param>
		public Workspace(Options opt_options = null)
		{
			options = opt_options;
		}

		/// <summary>
		/// Dispose of this workspace.
		/// Unlink from all DOM elements to prevent memory leaks.
		/// </summary>
		public void dispose()
		{

		}

		/// <summary>
		/// Angle away from the horizontal to sweep for blocks.  Order of execution is
		/// generally top to bottom, but a small angle changes the scan to give a bit of
		/// a left to right bias (reversed in RTL).  Units are in degrees.
		/// See: http://tvtropes.org/pmwiki/pmwiki.php/Main/DiagonalBilling.
		/// </summary>
		public int SCAN_ANGLE = 3;

		/// <summary>
		/// Add a block to the list of top blocks.
		/// </summary>
		/// <param name="block">Block to remove.</param>
		public void addTopBlock(Block block)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Remove a block from the list of top blocks.
		/// </summary>
		/// <param name="block">Block to remove.</param>
		public void removeTopBlock(Block block)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Finds the top-level blocks and returns them.  Blocks are optionally sorted
		/// by position; top to bottom (with slight LTR or RTL bias).
		/// </summary>
		/// <param name="ordered">Sort the list if true.</param>
		/// <returns>The top-level block objects.</returns>
		public Block[] getTopBlocks(bool ordered)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Find all blocks in workspace.  No particular order.
		/// </summary>
		/// <returns></returns>
		public Block[] getAllBlocks()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Dispose of all blocks in workspace.
		/// </summary>
		public void clear()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Returns the horizontal offset of the workspace.
		/// Intended for LTR/RTL compatibility in XML.
		/// Not relevant for a headless workspace.
		/// </summary>
		/// <returns>Width.</returns>
		public int getWidth()
		{
			throw new NotImplementedException();
		}


		/// <summary>
		/// Obtain a newly created block.
		/// </summary>
		/// <param name="prototypeName">Name of the language object containing
		/// type-specific functions for this block.</param>
		/// <param name="opt_id">Optional ID.  Use this ID if provided, otherwise
		/// create a new id.</param>
		/// <returns>The created block.</returns>
		public Block newBlock(string prototypeName, string opt_id = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// The number of blocks that may be added to the workspace before reaching
		/// the maxBlocks.
		/// </summary>
		/// <returns></returns>
		public int remainingCapacity()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Undo or redo the previous action.
		/// </summary>
		/// <param name="redo">False if undo, true if redo.</param>
		public void undo(bool redo)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Clear the undo/redo stacks.
		/// </summary>
		public void clearUndo()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// When something in this workspace changes, call a function.
		/// </summary>
		/// <param name="func">Function to call.</param>
		/// <returns>Function that can be passed to
		/// removeChangeListener.</returns>
		public Action<Abstract> addChangeListener(Action<Abstract> func)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Stop listening for this workspace's changes.
		/// </summary>
		/// <param name="func">Function to stop calling.</param>
		public void removeChangeListener(Action<Abstract> func)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Fire a change event.
		/// </summary>
		/// <param name="event">Event to fire.</param>
		public void fireChangeListener(Abstract @event)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Find the block on this workspace with the specified ID.
		/// </summary>
		/// <param name="id">ID of block to find.</param>
		/// <returns>The sought after block or null if not found.</returns>
		public Block getBlockById(string id)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Find the workspace with the specified ID.
		/// </summary>
		/// <param name="id">ID of workspace to find.</param>
		/// <returns>The sought after workspace or null if not found.</returns>
		public Workspace getById(string id)
		{
			throw new NotImplementedException();
		}

		/**
		 * Create a variable with the given name.
		 * TODO: #468
		 * @param {string} name The new variable's name.
		 */
		public void createVariable(string newText)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Check whether a variable exists with the given name.  The check is
		/// case-insensitive.
		/// </summary>
		/// <param name="name">The name to check for.</param>
		/// <returns>The index of the name in the variable list, or -1 if it is
		/// not present.</returns>
		internal int variableIndexOf(string name)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.WorkspaceSvg")]
	public class WorkspaceSvg : Workspace
	{
		public WorkspaceSvg(Options options)
			: base(options)
		{
		}

		public Metrics getMetrics()
		{
			throw new NotImplementedException();
		}

		public void setMetrics(Metrics metrics)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Getter for the inverted screen CTM.
		/// </summary>
		/// <returns>The matrix to use in mouseToSvg</returns>
		public SVGMatrix getInverseScreenCTM()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Update the inverted screen CTM.
		/// </summary>
		public void updateInverseScreenCTM()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Save resize handler data so we can delete it later in dispose.
		/// </summary>
		/// <param name="handler">Data that can be passed to unbindEvent_.</param>
		public void setResizeHandlerWrapper(Action handler)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Create the workspace DOM elements.
		/// </summary>
		/// <param name="opt_backgroundClass">opt_backgroundClass Either 'blocklyMainBackground' or
		/// 'blocklyMutatorBackground'.</param>
		/// <returns>The workspace's SVG group.</returns>
		public Element createDom(string opt_backgroundClass = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Dispose of this workspace.
		/// Unlink from all DOM elements to prevent memory leaks.
		/// </summary>
		public new void dispose()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Obtain a newly created block.
		/// </summary>
		/// <param name="prototypeName">Name of the language object containing
		/// type-specific functions for this block.</param>
		/// <param name="opt_id">Optional ID.  Use this ID if provided, otherwise
		/// create a new id.</param>
		/// <returns>The created block.</returns>
		public new BlockSvg newBlock(string prototypeName, string opt_id = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Resize the parts of the workspace that change when the workspace
		/// contents (e.g. block positions) change.  This will also scroll the
		/// workspace contents if needed.
		/// </summary>
		public void resizeContents()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Resize and reposition all of the workspace chrome (toolbox,
		/// trash, scrollbars etc.)
		/// This should be called when something changes that
		/// requires recalculating dimensions and positions of the
		/// trash, zoom, toolbox, etc. (e.g.window resize).
		/// </summary>
		public void resize()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Get the SVG element that forms the drawing surface.
		/// </summary>
		/// <returns>SVG element.</returns>
		public Element getCanvas()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Get the SVG element that forms the bubble surface.
		/// </summary>
		/// <returns>SVG element.</returns>
		public Element getBubbleCanvas()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Get the SVG element that contains this workspace.
		/// </summary>
		/// <returns>SVG element.</returns>
		public Element getParentSvg()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Translate this workspace to new coordinates.
		/// </summary>
		/// <param name="x">Horizontal translation.</param>
		/// <param name="y">Vertical translation.</param>
		public void translate(int x, int y)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Returns the horizontal offset of the workspace.
		/// Intended for LTR/RTL compatibility in XML.
		/// </summary>
		/// <returns>Width.</returns>
		public new int getWidth()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Toggles the visibility of the workspace.
		/// Currently only intended for main workspace.
		/// </summary>
		/// <param name="isVisible">True if workspace should be visible.</param>
		public void setVisible(bool isVisible)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Render all blocks in workspace.
		/// </summary>
		public void render()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Turn the visual trace functionality on or off.
		/// </summary>
		/// <param name="armed">True if the trace should be on.</param>
		public void traceOn(bool armed)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Highlight a block in the workspace.
		/// </summary>
		/// <param name="id">ID of block to find.</param>
		public void highlightBlock(string id)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Paste the provided block onto the workspace.
		/// </summary>
		/// <param name="xmlBlock">XML block element.</param>
		public void paste(Element xmlBlock)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Make a list of all the delete areas for this workspace.
		/// </summary>
		public void recordDeleteAreas()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Is the mouse event over a delete area (toolbox or non-closing flyout)?
		/// Opens or closes the trashcan and sets the cursor as a side effect.
		/// </summary>
		/// <param name="e">Mouse move event.</param>
		/// <returns></returns>
		public bool isDeleteArea(Event e)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Start tracking a drag of an object on this workspace.
		/// </summary>
		/// <param name="e">Mouse down event.</param>
		/// <param name="xy">Starting location of object.</param>
		public void startDrag(Event e, goog.math.Coordinate xy)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Track a drag of an object on this workspace.
		/// </summary>
		/// <param name="e">Mouse move event.</param>
		/// <returns>New location of object.</returns>
		public goog.math.Coordinate moveDrag(Event e)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Is the user currently dragging a block or scrolling the flyout/workspace?
		/// </summary>
		/// <returns>True if currently dragging or scrolling.</returns>
		public bool isDragging()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Calculate the bounding box for the blocks on the workspace.
		/// </summary>
		/// <returns>Contains the position and size of the bounding box
		/// containing the blocks on the workspace.
		/// {x: 0, y: 0, width: 0, height: 0}</returns>
		public object getBlocksBoundingBox()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Play a named sound at specified volume.  If volume is not specified,
		/// use full volume (1).
		/// </summary>
		/// <param name="name">Name of sound.</param>
		/// <param name="opt_volume">Volume of sound (0-1).</param>
		public void playAudio(string name, double opt_volume = 1)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Modify the block tree on the existing toolbox.
		/// </summary>
		/// <param name="tree">DOM tree of blocks, or text representation of same.</param>
		public void updateToolbox(Union<Node, string> tree)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Mark this workspace as the currently focused main workspace.
		/// </summary>
		public void markFocused()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Zooming the blocks centered in (x, y) coordinate with zooming in or out.
		/// </summary>
		/// <param name="x">X coordinate of center.</param>
		/// <param name="y">Y coordinate of center.</param>
		/// <param name="type">Type of zooming (-1 zooming out and 1 zooming in).</param>
		public void zoom(double x, double y, double type)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Zooming the blocks centered in the center of view with zooming in or out.
		/// </summary>
		/// <param name="type"></param>
		public void zoomCenter(double type)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Zoom the blocks to fit in the workspace if possible.
		/// </summary>
		public void zoomToFit()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Center the workspace.
		/// </summary>
		public void scrollCenter()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Set the workspace's zoom factor.
		/// </summary>
		/// <param name="newScale">Zoom factor.</param>
		public void setScale(double newScale)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Metrics")]
	public class Metrics
	{
		///<summary>Height of the visible rectangle</summary>
		public double viewHeight;
		///<summary>Width of the visible rectangle</summary>
		public double viewWidth;
		///<summary>Height of the contents</summary>
		public double contentHeight;
		///<summary>Width of the contents</summary>
		public double contentWidth;
		///<summary>Offset of top edge of visible rectangle from parent</summary>
		public double viewTop;
		///<summary>Offset of the top-most content from the y=0 coordinate</summary>
		public double contentTop;
		///<summary>Top-edge of view</summary>
		public double absoluteTop;
		///<summary>Offset of the left edge of visible rectangle from parent</summary>
		public double viewLeft;
		///<summary>Offset of the left-most content from the x=0 coordinate</summary>
		public double contentLeft;
		///<summary>Left-edge of view</summary>
		public double absoluteLeft;
	}

	[External, Name("Blockly.Events")]
	public class Events
	{
		public const string CREATE = "create";
		public const string DELETE = "delete";
		public const string CHANGE = "change";
		public const string MOVE = "move";
		public const string UI = "ui";

		internal string group_ = "";
		public bool recordUndo = false;

		internal string[] getDescendantIds_(Block block)
		{
			throw new NotImplementedException();
		}

		internal void enable()
		{
			throw new NotImplementedException();
		}

		internal void disable()
		{
			throw new NotImplementedException();
		}

		internal void setGroup(string group)
		{
			throw new NotImplementedException();
		}

		internal void fire(Abstract ev)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Events.Abstract")]
	public class Abstract
	{
		/// <summary>
		/// One of Blockly.Events.CREATE, Blockly.Events.DELETE, Blockly.Events.CHANGE, Blockly.Events.MOVE, Blockly.Events.UI.
		/// </summary>
		internal string type;

		/// <summary>
		/// UUID of workspace. The workspace can be found with Workspace.getById(event.workspaceId)
		/// </summary>
		internal string workspaceId;

		/// <summary>
		/// UUID of block. The block can be found with workspace.getBlockById(event.blockId)
		/// </summary>
		internal string blockId;

		/// <summary>
		/// UUID of group. Some events are part of an indivisible group, such as inserting a statement in a stack.
		/// </summary>
		internal string group;

		internal bool recordUndo;

		public Abstract(Block block, string type)
		{
			this.type = type;
			if (block != null) {
				blockId = block.id;
				workspaceId = block.workspace.id;
			}
			group = Blockly.Events.group_;
			recordUndo = Blockly.Events.recordUndo;
		}
	}

	[External, Name("Blockly.Events.Create")]
	public class Create : Abstract
	{
		/// <summary>
		/// An XML tree defining the new block and any connected child blocks.
		/// </summary>
		internal Element xml;

		/// <summary>
		/// An array containing the UUIDs of the new block and any connected child blocks.
		/// </summary>
		internal string[] ids;

		/// <summary>
		/// Class for a block creation event.
		/// </summary>
		/// <param name="block">The created block.  Null for a blank event.</param>
		public Create(Block block)
			 : base(block, Events.CHANGE)
		{
			if (block == null) {
				return;  // Blank event to be populated by fromJson.
			}
			xml = Blockly.Xml.blockToDomWithXY(block);
			ids = Blockly.Events.getDescendantIds_(block);
		}
	}

	[External, Name("Blockly.Events.Delete")]
	public class Delete : Abstract
	{
		/// <summary>
		/// An XML tree defining the deleted block and any connected child blocks.
		/// </summary>
		internal object oldXml;

		/// <summary>
		/// An array containing the UUIDs of the deleted block and any connected child blocks.
		/// </summary>
		internal string[] ids;

		/// <summary>
		/// Class for a block deletion event.
		/// </summary>
		/// <param name="block">The deleted block.  Null for a blank event.</param>
		public Delete(Block block)
			: base(block, Events.DELETE)
		{
			if (block == null) {
				return;  // Blank event to be populated by fromJson.
			}
			if (block.getParent() != null) {
				throw new Exception("Connected blocks cannot be deleted.");
			}
			oldXml = Blockly.Xml.blockToDomWithXY(block);
			ids = Blockly.Events.getDescendantIds_(block);
		}
	}

	[External, Name("Blockly.Events.Change")]
	public class Change : Abstract
	{
		/// <summary>
		/// One of 'field', 'comment', 'collapsed', 'disabled', 'inline', 'mutate'
		/// </summary>
		internal string element;

		/// <summary>
		/// Name of the field if this is a change to a field.
		/// </summary>
		internal string name;

		/// <summary>
		/// Original value.
		/// </summary>
		internal object oldValue;

		/// <summary>
		/// Changed value.
		/// </summary>
		internal object newValue;

		/// <summary>
		/// Class for a block change event.
		/// </summary>
		/// <param name="block">The changed block.  Null for a blank event.</param>
		/// <param name="element">One of 'field', 'comment', 'disabled', etc.</param>
		/// <param name="name">Name of input or field affected, or null.</param>
		/// <param name="oldValue">Previous value of element.</param>
		/// <param name="newValue">New value of element.</param>
		public Change(Block block, string element, string name, string oldValue, string newValue)
			: base(block, Events.CHANGE)
		{
			if (block == null) {
				return;  // Blank event to be populated by fromJson.
			}
			this.element = element;
			this.name = name;
			this.oldValue = oldValue;
			this.newValue = newValue;
		}
	}

	[External, Name("Blockly.Events.Move")]
	public class Move : Abstract
	{
		/// <summary>
		/// UUID of old parent block. Undefined if it was a top level block.
		/// </summary>
		internal string oldParentId;

		/// <summary>
		/// Name of input on old parent. Undefined if it was a top level block or parent's next block.
		/// </summary>
		internal string oldInputName;

		/// <summary>
		/// X and Y coordinates if it was a top level block. Undefined if it had a parent.
		/// </summary>
		internal object oldCoordinate;

		/// <summary>
		/// UUID of new parent block. Undefined if it is a top level block.
		/// </summary>
		internal string newParentId;

		/// <summary>
		/// Name of input on new parent. Undefined if it is a top level block or parent's next block.
		/// </summary>
		internal string newInputName;

		/// <summary>
		/// X and Y coordinates if it is a top level block. Undefined if it has a parent.
		/// </summary>
		internal object newCoordinate;

		/// <summary>
		/// Class for a block move event.  Created before the move.
		/// </summary>
		/// <param name="block">The moved block.  Null for a blank event.</param>
		public Move(Block block)
			: base(block, Events.MOVE)
		{
			if (block == null) {
				return;  // Blank event to be populated by fromJson.
			}
			var location = this.currentLocation_();
			this.oldParentId = location.parentId;
			this.oldInputName = location.inputName;
			this.oldCoordinate = location.coordinate;
		}

		/**
		 * Record the block's new location.  Called after the move.
		 */
		public void recordNew()
		{
			var location = this.currentLocation_();
			this.newParentId = location.parentId;
			this.newInputName = location.inputName;
			this.newCoordinate = location.coordinate;
		}

		class Location
		{
			public string parentId;
			public string inputName;
			public object coordinate;

			public Location(string parentId, string inputName, object coordinate)
			{
				this.parentId = parentId;
				this.inputName = inputName;
				this.coordinate = coordinate;
			}
		}

		/**
		 * Returns the parentId and input if the block is connected,
		 *   or the XY location if disconnected.
		 * @return {!Object} Collection of location info.
		 * @private
		 */
		private Location currentLocation_()
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Events.Ui")]
	public class Ui : Abstract
	{
		/// <summary>
		/// One of 'selected', 'category', 'click', 'commentOpen', 'mutatorOpen', 'warningOpen'
		/// </summary>
		internal string element;

		/// <summary>
		/// Original value.
		/// </summary>
		internal object oldValue;

		/// <summary>
		/// Changed value.
		/// </summary>
		internal object newValue;

		/// <summary>
		/// Class for a UI event.
		/// </summary>
		/// <param name="block">The affected block.</param>
		/// <param name="element">One of 'selected', 'comment', 'mutator', etc.</param>
		/// <param name="oldValue">Previous value of element.</param>
		/// <param name="newValue">New value of element.</param>
		public Ui(Block block, string element, string oldValue, string newValue)
			: base(block, Events.UI)
		{
			this.element = element;
			this.oldValue = oldValue;
			this.newValue = newValue;
		}
	}

	[External, Name("Blockly.Options")]
	public class Options
	{
		public Node languageTree;
		public bool oneBasedIndex;
		public Workspace parentWorkspace;
		public bool comments;
	}

	[External, Name("Blockly.BlockSvg")]
	public class BlockSvg : Block
	{
		[Name(false)]
		public int TAB_HEIGHT = 20;

		public BlockSvg(string type) : base(type)
		{
		}
	}

	[External, Name("Blockly.Comment")]
	public class Comment : Block
	{
		public Comment(string type) : base(type)
		{
		}
	}

	[External, Name("Blockly.Input")]
	public class Input
	{
		public int type;
		public string name;
		public Block block;
		public Connection connection;
		public Field[] fieldRow;

		/// <summary>
		/// Class for an input with an optional field.
		/// </summary>
		/// <param name="type">The type of the input.</param>
		/// <param name="name">Language-neutral identifier which may used to find this
		/// input again.</param>
		/// <param name="block">The block containing this input.</param>
		/// <param name="connection">Optional connection for this input.</param>
		public Input(int type, string name, Block block, Connection connection)
		{
			this.type = type;
			this.name = name;
			this.block = block;
			this.connection = connection;
		}

		/// <summary>
		/// Add an item to the end of the input's field row.
		/// </summary>
		/// <param name="field">Something to add as a field.</param>
		/// <param name="opt_name">Language-neutral identifier which may used to find
		/// this field again.Should be unique to the host block.</param>
		/// <returns>The input being append to (to allow chaining).</returns>
		public Input appendField(Union<string, Field> field, string opt_name = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Add an item to the end of the input's field row.
		/// </summary>
		/// <param name="field">Something to add as a field.</param>
		/// <param name="opt_name">Language-neutral identifier which may used to find
		/// this field again.Should be unique to the host block.</param>
		/// <returns>The input being append to (to allow chaining).</returns>
		public Input appendTitle(Union<string, Field> field, string opt_name = null)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Remove a field from this input.
		/// </summary>
		/// <param name="name">The name of the field.</param>
		public void removeField(string name)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Gets whether this input is visible or not.
		/// </summary>
		/// <returns>True if visible.</returns>
		public bool isVisible()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Sets whether this input is visible or not.
		/// Used to collapse/uncollapse a block.
		/// </summary>
		/// <param name="visible">True if visible.</param>
		/// <returns>List of blocks to render.</returns>
		public Block[] setVisible(bool visible)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Change a connection's compatibility.
		/// </summary>
		/// <param name="check">Compatible value type or
		/// list of value types.Null if all types are compatible.</param>
		/// <returns>The input being modified (to allow chaining).</returns>
		public Input setCheck(Union<string, string[]> check)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Change the alignment of the connection's field(s).
		/// </summary>
		/// <param name="align">align One of Blockly.ALIGN_LEFT, ALIGN_CENTRE, ALIGN_RIGHT.
		/// In RTL mode directions are reversed, and ALIGN_RIGHT aligns to the left.</param>
		/// <returns>The input being modified (to allow chaining).</returns>
		public Input setAlign(double align)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Initialize the fields on this input.
		/// </summary>
		public void init()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Sever all links to this input.
		/// </summary>
		public void dispose()
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Icon")]
	public class Icon
	{
		public Icon(Block block)
		{
		}
	}

	[External, Name("Blockly.Mutator")]
	public class Mutator : Icon
	{
		public Workspace workspace_;

		public Mutator(string[] quarkNames)
			: base(null)
		{
		}

		/// <summary>
		/// Reconnect an block to a mutated input.
		/// </summary>
		/// <param name="connectionChild">Connection on child block.</param>
		/// <param name="block">Parent block.</param>
		/// <param name="inputName">Name of input on parent block.</param>
		/// <returns>True iff a reconnection was made, false otherwise.</returns>
		internal static bool reconnect(Connection connectionChild, Block block, string inputName)
		{
			throw new NotImplementedException();
		}

		internal bool isVisible()
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Connection")]
	public class Connection
	{
		public Connection targetConnection;

		public Connection(Block source, int type)
		{
		}

		public void connect(Connection previousConnection)
		{
			throw new NotImplementedException();
		}

		public void disconnect()
		{
			throw new NotImplementedException();
		}

		public Block targetBlock()
		{
			throw new NotImplementedException();
		}

		public bool checkType_(Connection connection)
		{
			throw new NotImplementedException();
		}

		public Connection setCheck(object check)
		{
			throw new NotImplementedException();
		}

		internal Block getSourceBlock()
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.RenderedConnection")]
	public class RenderedConnection : Connection
	{
		public RenderedConnection(Block source, int type)
			: base(source, type)
		{
		}
	}

	[External, Name("Blockly.Field")]
	public class Field
	{
		public goog.math.Size size_;
		public string text_;
		public Block sourceBlock_;

		/// <summary>
		/// Abstract class for an editable field.
		/// </summary>
		/// <param name="text">The initial content of the field.</param>
		/// <param name="opt_validator">An optional function that is called
		/// to validate any constraints on what the user entered.  Takes the new
		/// text as an argument and returns either the accepted text, a replacement
		/// text, or null to abort the change.</param>
		public Field(string text, Func<string, object> opt_validator = null)
		{
			size_ = new goog.math.Size(0, 25);
			setValue(text);
			setValidator(opt_validator);
		}

		/// <summary>
		/// Name of field.  Unique within each block.
		/// Static labels are usually unnamed.
		/// </summary>
		public string name;

		/// <summary>
		/// Maximum characters of text to display before adding an ellipsis.
		/// </summary>
		public int maxDisplayLength;

		/// <summary>
		/// Non-breaking space.
		/// </summary>
		[Name(false)]
		public const string NBSP = "\u00A0";

		/// <summary>
		/// Editable fields are saved by the XML renderer, non-editable fields are not.
		/// </summary>
		[Name(false)]
		public bool EDITABLE = true;

		/// <summary>
		/// Attach this field to a block.
		/// </summary>
		/// <param name="block">The block containing this field.</param>
		public void setSourceBlock(Block block)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Install this field on a block.
		/// </summary>
		public virtual void init()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Dispose of all DOM objects belonging to this editable field.
		/// </summary>
		public virtual void dispose()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Add or remove the UI indicating if this field is editable or not.
		/// </summary>
		public void updateEditable()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Gets whether this editable field is visible or not.
		/// </summary>
		/// <returns>True if visible.</returns>
		public bool isVisible()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Sets whether this editable field is visible or not.
		/// </summary>
		/// <param name="visible">True if visible.</param>
		public void setVisible(bool visible)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Sets a new validation function for editable fields.
		/// </summary>
		/// <param name="handler">New validation function, or null.</param>
		public virtual void setValidator(Func<string, object> handler)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Gets the validation function for editable fields.
		/// </summary>
		/// <returns>Validation function, or null.</returns>
		public Func<string, string> getValidator()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Gets the group element for this editable field.
		/// Used for measuring the size and for positioning.
		/// </summary>
		/// <returns>The group element.</returns>
		public virtual Element getSvgRoot()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Start caching field widths.  Every call to this function MUST also call
		/// stopCache.  Caches must not survive between execution threads.
		/// </summary>
		public void startCache()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Stop caching field widths.  Unless caching was already on when the
		/// corresponding call to startCache was made.
		/// </summary>
		public void stopCache()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Returns the height and width of the field.
		/// </summary>
		/// <returns>Height and width.</returns>
		public goog.math.Size getSize()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Get the text from this field.
		/// </summary>
		/// <returns>Current text.</returns>
		public virtual string getText()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Set the text in this field.  Trigger a rerender of the source block.
		/// </summary>
		/// <param name="text">New text.</param>
		public virtual void setText(string text)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// By default there is no difference between the human-readable text and
		/// the language-neutral values.  Subclasses (such as dropdown) may define this.
		/// </summary>
		/// <returns>Current text.</returns>
		public virtual string getValue()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// By default there is no difference between the human-readable text and
		/// the language-neutral values.  Subclasses (such as dropdown) may define this.
		/// </summary>
		/// <param name="newText">New text.</param>
		public virtual void setValue(string newText)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Change the tooltip text for this field.
		/// </summary>
		/// <param name="newTip">newTip Text for tooltip or a parent element to
		/// link to for its tooltip.</param>
		public virtual void setTooltip(Union<string, Element> newTip)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.FieldLabel")]
	public class FieldLabel : Field
	{
		/// <summary>
		/// Class for a non-editable field.
		/// </summary>
		/// <param name="text">The initial content of the field.</param>
		/// <param name="opt_class">Optional CSS class for the field's text.</param>
		public FieldLabel(string text, string opt_class = null)
			: base(text)
		{
		}

		/// <summary>
		/// Install this text on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Dispose of all DOM objects belonging to this text.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}

		/// <summary>
		/// Gets the group element for this field.
		/// Used for measuring the size and for positioning.
		/// </summary>
		/// <returns></returns>
		public override Element getSvgRoot()
		{
			return base.getSvgRoot();
		}

		/// <summary>
		/// Change the tooltip text for this field.
		/// </summary>
		/// <param name="newTip">Text for tooltip or a parent element to
		/// link to for its tooltip.</param>
		public override void setTooltip(Union<string, Element> newTip)
		{
			base.setTooltip(newTip);
		}
	}

	[External, Name("Blockly.FieldCheckbox")]
	public class FieldCheckbox : Field
	{
		/// <summary>
		/// Class for a checkbox field.
		/// </summary>
		/// <param name="state">The initial state of the field ('TRUE' or 'FALSE').</param>
		/// <param name="opt_validator">A function that is executed when a new
		/// option is selected.  Its sole argument is the new checkbox state.  If
		/// it returns a value, this becomes the new checkbox state, unless the
		/// value is null, in which case the change is aborted.</param>
		public FieldCheckbox(string state, Func<string, object> opt_validator = null)
			: base("", opt_validator)
		{
		}

		/// <summary>
		/// Character for the checkmark.
		/// </summary>
		public string CHECK_CHAR = "\u2713";

		/// <summary>
		/// Mouse cursor style when over the hotspot that initiates editability.
		/// </summary>
		public string CURSOR = "default";

		/// <summary>
		/// Install this checkbox on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Return 'TRUE' if the checkbox is checked, 'FALSE' otherwise.
		/// </summary>
		/// <returns>Current state.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the checkbox to be checked if strBool is 'TRUE', unchecks otherwise.
		/// </summary>
		/// <param name="strBool">New state.</param>
		public override void setValue(string strBool)
		{
			base.setValue(strBool);
		}
	}

	[External, Name("Blockly.FieldDropdown")]
	public class FieldDropdown : Field
	{
		/// <summary>
		/// Class for an editable dropdown field.
		/// </summary>
		/// <param name="menuGenerator">An array of
		/// options for a dropdown list, or a function which generates these options.</param>
		/// <param name="opt_validator">A function that is executed when a new
		/// option is selected, with the newly selected value as its sole argument.
		/// If it returns a value, that value (which must be one of the options) will
		/// become selected in place of the newly selected option, unless the return
		/// value is null, in which case the change is aborted.
		/// </param>
		public FieldDropdown(Union<string[][], Func<string[][]>> menuGenerator, Func<string, object> opt_validator = null)
			: base(menuGenerator.As<string[][]>()[0][1], opt_validator)
		{
		}

		/// <summary>
		/// Horizontal distance that a checkmark ovehangs the dropdown.
		/// </summary>
		public int CHECKMARK_OVERHANG = 25;

		/// <summary>
		/// Android can't (in 2014) display "▾", so use "▼" instead.
		/// </summary>
		public string ARROW_CHAR = "\u25BE";

		/// <summary>
		/// Mouse cursor style when over the hotspot that initiates the editor.
		/// </summary>
		public string CURSOR = "default";

		/// <summary>
		/// Install this dropdown on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Get the language-neutral value from this dropdown menu.
		/// </summary>
		/// <returns>Current text.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the language-neutral value for this dropdown menu.
		/// </summary>
		/// <param name="newText">New value to set.</param>
		public override void setValue(string newText)
		{
			base.setValue(newText);
		}

		/// <summary>
		/// Set the text in this field.  Trigger a rerender of the source block.
		/// </summary>
		/// <param name="text">New text.</param>
		public override void setText(string text)
		{
			base.setText(text);
		}

		/// <summary>
		/// Close the dropdown menu if this input is being deleted.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}
	}

	[External, Name("Blockly.FieldTextInput")]
	public class FieldTextInput : Field
	{
		public Action<string> onFinishEditing_;

		/// <summary>
		/// Class for an editable text field.
		/// </summary>
		/// <param name="text">The initial content of the field.</param>
		/// <param name="opt_validator">An optional function that is called
		/// to validate any constraints on what the user entered.  Takes the new
		/// text as an argument and returns either the accepted text, a replacement
		/// text, or null to abort the change.</param>
		public FieldTextInput(string text, Func<string, object> opt_validator = null)
			: base(text, opt_validator)
		{
		}

		/// <summary>
		/// Point size of text.  Should match blocklyText's font-size in CSS.
		/// </summary>
		public int FONTSIZE = 11;

		/// <summary>
		/// Mouse cursor style when over the hotspot that initiates the editor.
		/// </summary>
		public string CURSOR = "text";

		/// <summary>
		/// Close the input widget if this input is being deleted.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}

		/// <summary>
		/// Set the text in this field.
		/// </summary>
		/// <param name="text">New text.</param>
		public override void setValue(string text)
		{
			base.setValue(text);
		}

		/// <summary>
		/// Set whether this field is spellchecked by the browser.
		/// </summary>
		/// <param name="check">True if checked.</param>
		public void setSpellcheck(bool check)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Ensure that only a number may be entered.
		/// </summary>
		/// <param name="text">The user's text.</param>
		/// <returns>A string representing a valid number, or null if invalid.</returns>
		public virtual string numberValidator(string text)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Ensure that only a nonnegative integer may be entered.
		/// </summary>
		/// <param name="test">The user's text.</param>
		/// <returns>A string representing a valid int, or null if invalid.</returns>
		public string nonnegativeIntegerValidator(string test)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.FieldDate")]
	public class FieldDate : Field
	{
		/// <summary>
		/// Class for a date input field.
		/// </summary>
		/// <param name="date">The initial date.</param>
		/// <param name="opt_validator">A function that is executed when a new
		/// date is selected.  Its sole argument is the new date value.  Its
		/// return value becomes the selected date, unless it is undefined, in
		/// which case the new date stands, or it is null, in which case the change
		/// is aborted.</param>
		public FieldDate(string date, Func<string, object> opt_validator = null)
			: base(date, opt_validator)
		{
		}

		/// <summary>
		/// Mouse cursor style when over the hotspot that initiates the editor.
		/// </summary>
		public string CURSOR = "text";

		/// <summary>
		/// Close the colour picker if this input is being deleted.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}

		/// <summary>
		/// Return the current date.
		/// </summary>
		/// <returns>Current date.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the date.
		/// </summary>
		/// <param name="newText">The new date.</param>
		public override void setValue(string newText)
		{
			base.setValue(newText);
		}

		/// <summary>
		/// CSS for date picker.  See css.js for use.
		/// </summary>
		public string[] CSS = new string[0];
	}

	[External, Name("Blockly.FieldColour")]
	public class FieldColour : Field
	{
		/// <summary>
		/// Class for a colour input field.
		/// </summary>
		/// <param name="colour">The initial colour in '#rrggbb' format.</param>
		/// <param name="opt_validator">A function that is executed when a new
		/// colour is selected.  Its sole argument is the new colour value.  Its
		/// return value becomes the selected colour, unless it is undefined, in
		/// which case the new colour stands, or it is null, in which case the change
		/// is aborted.</param>
		public FieldColour(string colour, Func<string, object> opt_validator = null)
			: base(colour, opt_validator)
		{
		}

		/// <summary>
		/// Install this field on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Mouse cursor style when over the hotspot that initiates the editor.
		/// </summary>
		public string CURSOR = "default";

		/// <summary>
		/// Close the colour picker if this input is being deleted.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}

		/// <summary>
		/// Return the current colour.
		/// </summary>
		/// <returns>Current colour in '#rrggbb' format.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the colour.
		/// </summary>
		/// <param name="colour">The new colour in '#rrggbb' format.</param>
		public override void setValue(string colour)
		{
			base.setValue(colour);
		}

		/// <summary>
		/// Get the text from this field.  Used when the block is collapsed.
		/// </summary>
		/// <returns>Current text.</returns>
		public override string getText()
		{
			return base.getText();
		}

		/// <summary>
		/// An array of colour strings for the palette.
		/// See bottom of this page for the default:
		/// http://docs.closure-library.googlecode.com/git/closure_goog_ui_colorpicker.js.source.html
		/// </summary>
		public string[] COLOURS = new string[0];

		/// <summary>
		/// Set a custom colour grid for this field.
		/// </summary>
		/// <param name="colours">Array of colours for this block,
		/// or null to use default (FieldColour.COLOURS).</param>
		/// <returns>Returns itself (for method chaining).</returns>
		public FieldColour setColours(string[] colours)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Set a custom grid size for this field.
		/// </summary>
		/// <param name="columns">Number of columns for this block,
		/// or 0 to use default (FieldColour.COLUMNS).</param>
		/// <returns>Returns itself (for method chaining).</returns>
		public FieldColour setColumns(int columns)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.FieldNumber")]
	public class FieldNumber : FieldTextInput
	{
		/// <summary>
		/// Class for an editable number field.
		/// </summary>
		/// <param name="value">The initial content of the field.</param>
		/// <param name="opt_min">Minimum value.</param>
		/// <param name="opt_max">Maximum value.</param>
		/// <param name="opt_precision">Precision for value.</param>
		/// <param name="opt_validator">An optional function that is called
		/// to validate any constraints on what the user entered.  Takes the new
		/// text as an argument and returns either the accepted text, a replacement
		/// text, or null to abort the change.</param>
		public FieldNumber(string value, Union<string, int> opt_min,
			Union<string, int> opt_max, Union<string, int> opt_precision,
			Func<string, object> opt_validator = null)
			: base(value, opt_validator)
		{
		}

		/// <summary>
		/// Set the maximum, minimum and precision constraints on this field.
		/// Any of these properties may be undefiend or NaN to be disabled.
		/// Setting precision (usually a power of 10) enforces a minimum step between
		/// values. That is, the user's value will rounded to the closest multiple of
		/// precision. The least significant digit place is inferred from the precision.
		/// Integers values can be enforces by choosing an integer precision.
		/// </summary>
		/// <param name="min">Minimum value.</param>
		/// <param name="max">Maximum value.</param>
		/// <param name="precision">Precision for value.</param>
		public void setConstraints(Union<string, int> min, Union<string, int> max,
			Union<string, int> precision)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Sets a new change handler for number field.
		/// </summary>
		/// <param name="handler">New change handler, or null.</param>
		public override void setValidator(Func<string, object> handler)
		{
			base.setValidator(handler);
		}

		/// <summary>
		/// Ensure that only a number in the correct range may be entered.
		/// </summary>
		/// <param name="text">The user's text.</param>
		/// <returns>A string representing a valid number, or null if invalid.</returns>
		public override string numberValidator(string text)
		{
			return base.numberValidator(text);
		}
	}

	[External, Name("Blockly.FieldAngle")]
	public class FieldAngle : FieldTextInput
	{
		/// <summary>
		/// Class for an editable angle field.
		/// </summary>
		/// <param name="text">The initial content of the field.</param>
		/// <param name="opt_validator">An optional function that is called
		/// to validate any constraints on what the user entered.  Takes the new
		/// text as an argument and returns the accepted text or null to abort
		/// the change.</param>
		public FieldAngle(string text, Func<string, object> opt_validator = null)
			: base(text, opt_validator)
		{
		}

		/// <summary>
		/// Sets a new change handler for angle field.
		/// </summary>
		/// <param name="handler">New change handler, or null.</param>
		public override void setValidator(Func<string, object> handler)
		{
			base.setValidator(handler);
		}

		/// <summary>
		/// Round angles to the nearest 15 degrees when using mouse.
		/// Set to 0 to disable rounding.
		/// </summary>
		public int ROUND = 15;

		/// <summary>
		/// Half the width of protractor image.
		/// </summary>
		public static int HALF = 100 / 2;

		/// <summary>
		/// Angle increases clockwise (true) or counterclockwise (false).
		/// </summary>
		public bool CLOCKWISE = false;

		/// <summary>
		/// Offset the location of 0 degrees (and all angles) by a constant.
		/// Usually either 0 (0 = right) or 90 (0 = up).
		/// </summary>
		public int OFFSET = 0;

		/// <summary>
		/// Maximum allowed angle before wrapping.
		/// Usually either 360 (for 0 to 359.9) or 180 (for -179.9 to 180).
		/// </summary>
		public int WRAP = 360;

		/// <summary>
		/// Radius of protractor circle.  Slightly smaller than protractor size since
		/// otherwise SVG crops off half the border at the edges.
		/// </summary>
		public int RADIUS = HALF - 1;

		/// <summary>
		/// Set the angle to match the mouse's position.
		/// </summary>
		/// <param name="e">Mouse move event.</param>
		public void onMouseMove(Event e)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Insert a degree symbol.
		/// </summary>
		/// <param name="text">New text.</param>
		public override void setText(string text)
		{
			base.setText(text);
		}

		/// <summary>
		/// Ensure that only an angle may be entered.
		/// </summary>
		/// <param name="text">The user's text.</param>
		/// <returns>A string representing a valid angle, or null if invalid.</returns>
		public string angleValidator(string text)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.FieldImage")]
	public class FieldImage : Field
	{
		/// <summary>
		/// Class for an image.
		/// </summary>
		/// <param name="src">The URL of the image.</param>
		/// <param name="width">Width of the image.</param>
		/// <param name="height">Height of the image.</param>
		/// <param name="opt_alt">Optional alt text for when block is collapsed.</param>
		public FieldImage(string src, int width, int height, string opt_alt = "")
			: base(src)
		{
		}

		/// <summary>
		/// Install this image on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Dispose of all DOM objects belonging to this text.
		/// </summary>
		public override void dispose()
		{
			base.dispose();
		}

		/// <summary>
		/// Change the tooltip text for this field.
		/// </summary>
		/// <param name="newTip">Text for tooltip or a parent element to
		/// link to for its tooltip.</param>
		public override void setTooltip(Union<string, Element> newTip)
		{
			base.setTooltip(newTip);
		}

		/// <summary>
		/// Get the source URL of this image.
		/// </summary>
		/// <returns>Current text.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the source URL of this image.
		/// </summary>
		/// <param name="newText">New source.</param>
		public override void setValue(string newText)
		{
			base.setValue(newText);
		}

		/// <summary>
		/// Set the alt text of this image.
		/// </summary>
		/// <param name="alt">New alt text.</param>
		public override void setText(string alt)
		{
			base.setText(alt);
		}
	}

	[External, Name("Blockly.FieldVariable")]
	public class FieldVariable : Field
	{
		/// <summary>
		/// Class for a variable's dropdown field.
		/// </summary>
		/// <param name="varname">The default name for the variable.  If null,
		/// a unique variable name will be generated.</param>
		/// <param name="opt_validator">A function that is executed when a new
		/// option is selected.  Its sole argument is the new option value.</param>
		public FieldVariable(string varname, Func<string, object> opt_validator = null)
			: base(varname, opt_validator)
		{
		}

		/// <summary>
		/// Sets a new change handler for angle field.
		/// </summary>
		/// <param name="handler">New change handler, or null.</param>
		public override void setValidator(Func<string, object> handler)
		{
			base.setValidator(handler);
		}

		/// <summary>
		/// Install this dropdown on a block.
		/// </summary>
		public override void init()
		{
			base.init();
		}

		/// <summary>
		/// Get the variable's name (use a variableDB to convert into a real name).
		/// Unline a regular dropdown, variables are literal and have no neutral value.
		/// </summary>
		/// <returns>Current text.</returns>
		public override string getValue()
		{
			return base.getValue();
		}

		/// <summary>
		/// Set the variable name.
		/// </summary>
		/// <param name="newValue">New text.</param>
		public override void setValue(string newValue)
		{
			base.setValue(newValue);
		}

		/// <summary>
		/// Return a sorted list of variable names for variable dropdown menus.
		/// Include a special option at the end for creating a new variable name.
		/// </summary>
		/// <returns>Array of variable names.</returns>
		public string[] dropdownCreate()
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Event handler for a change in variable name.
		/// Special case the 'New variable...' and 'Rename variable...' options.
		/// In both of these special cases, prompt the user for a new name.
		/// </summary>
		/// <param name="text">The selected dropdown menu option.</param>
		/// <returns>An acceptable new variable name, or null if
		/// change is to be either aborted (cancel button) or has been already
		/// handled (rename), or undefined if an existing variable was chosen.</returns>
		public string dropdownChange(string text)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.Rectangle")]
	public class Rectangle
	{
		public goog.math.Coordinate topLeft;
		public goog.math.Coordinate bottomRight;
	}

	[External, Name("Blockly.ContextMenu")]
	public class ContextMenu
	{
		public static Action callbackFactory(Block block, Element xml)
		{
			throw new NotImplementedException();
		}
	}

	[External, Name("Blockly.FlyoutButton")]
	public class FlyoutButton
	{
		internal Workspace getTargetWorkspace()
		{
			throw new NotImplementedException();
		}
	}

	/// <summary>
	/// Allow for switching between one and zero based indexing for lists and text,
	/// one based by default.
	/// </summary>
	[External, Name("Blockly.Blocks")]
	public class Blocks
	{
		public bool ONE_BASED_INDEXING = true;
	}
}

/// <summary>
/// Google's common JavaScript library
/// https://developers.google.com/closure/library/
/// </summary>
[External]
public static class goog
{
	public static string getMsg(string str, object opt_values)
	{
		throw new NotImplementedException();
	}

	public static class dom
	{
		public static Element createDom(string v, object o = null, Union<string, Element> t = null)
		{
			throw new NotImplementedException();
		}
	}

	public static class math
	{
		public class Size
		{
			public double width;
			public double height;

			public Size(double width, double hieght)
			{
				this.width = width;
				this.height = hieght;
			}
		}

		public class Coordinate
		{
			public double x;
			public double y;
		}
	}

	public static class @string
	{
		public class CaseInsensitiveCompare : IComparer<string>
		{
			public int Compare(string x, string y)
			{
				return x.ToLower().CompareTo(y.ToLower());
			}
		}

		public static CaseInsensitiveCompare caseInsensitiveCompare = new CaseInsensitiveCompare();
	}

	public static class array
	{
		internal static bool equals(Array a, Array b)
		{
			throw new NotImplementedException();
		}
	}

	public static class asserts
	{
		internal static void assert(bool cond, string format, params string[] args)
		{
			if (!cond) throw new NotImplementedException();
		}

		internal static void assertArray(object array, string format, params string[] args)
		{
			assert(array is Array, format, args);
		}

		internal static void assertFunction(object func, string format, params string[] args)
		{
			assert(func is System.Reflection.MethodInfo, format, args);
		}

		internal static void assertString(object str, string format, params string[] args)
		{
			assert(str is String, format, args);
		}

		internal static void fail(string format, params string[] args)
		{
			throw new NotImplementedException();
		}
	}
}