Upload 310 files

.editorconfig

@@ -0,0 +1,10 @@
+# editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.eslintignore

@@ -0,0 +1,16 @@
+*_compressed*.js
+*_uncompressed*.js
+/msg/*
+/core/css.js
+/i18n/*
+/tests/jsunit/*
+/tests/workspace_svg/*
+/tests/blocks/*
+/demos/*
+/accessible/*
+/appengine/*
+/shim/*
+/dist/*
+/gh-pages/*
+/webpack.config.js
+/build/*

.eslintrc

@@ -0,0 +1,58 @@
+{
+    "extends": "eslint:recommended",
+    "rules": {
+        "curly": ["error", "multi-line"],
+        "eol-last": ["error"],
+        "indent": [
+            "error", 2,  # Blockly/Google use 2-space indents
+            # Blockly/Google uses +4 space indents for line continuations.
+            {
+                "SwitchCase": 1,
+                "MemberExpression": 2,
+                "ObjectExpression": 1,
+                "FunctionDeclaration": {
+                    "body": 1,
+                    "parameters": 2
+                },
+                "FunctionExpression": {
+                    "body": 1,
+                    "parameters": 2
+                },
+                "CallExpression": {
+                    "arguments": 2
+                },
+                # Ignore default rules for ternary expressions.
+                "ignoredNodes": ["ConditionalExpression"]
+            }
+        ],
+        "linebreak-style": ["off"],
+        "max-len": ["error", 120, 4],
+        "no-trailing-spaces": ["error", { "skipBlankLines": true }],
+        "no-unused-vars": [
+            "error",
+            {
+                "args": "after-used",
+                # Ignore vars starting with an underscore.
+                "varsIgnorePattern": "^_",
+                # Ignore arguments starting with an underscore.
+                "argsIgnorePattern": "^_"
+            }
+        ],
+        "no-use-before-define": ["error"],
+        "quotes": ["off"], # Blockly mixes single and double quotes
+        "semi": ["error", "always"],
+        "space-before-function-paren": ["error", "never"], # Blockly doesn't have space before function paren
+        "space-infix-ops": ["error"],
+        "strict": ["off"], # Blockly uses 'use strict' in files
+        "no-cond-assign": ["off"], # Blockly often uses cond-assignment in loops
+        "no-redeclare": ["off"], # Closure style allows redeclarations
+        "valid-jsdoc": ["error", {"requireReturn": false}],
+        "no-console": ["off"],
+        "no-constant-condition": ["off"]
+    },
+    "enviroment": "web",
+    "globals": {
+        "Blockly": true, # Blockly global
+        "goog": true, # goog closure libraries/includes
+    }
+}

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,15 @@
+### Expected Behavior
+
+_Please describe what should happen_
+
+### Actual Behavior
+
+_Describe what actually happens_
+
+### Steps to Reproduce
+
+_Explain what someone needs to do in order to see what's described in *Actual behavior* above_
+
+### Operating System and Browser
+
+_e.g. Mac OS 10.11.6 Safari 10.0_

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+### Resolves
+
+_What Github issue does this resolve (please include link)?_
+
+### Proposed Changes
+
+_Describe what this Pull Request does_
+
+### Reason for Changes
+
+_Explain why these changes should be made_
+
+### Test Coverage
+
+_Please show how you have added tests to cover your changes_

.github/workflows/build.yml

@@ -0,0 +1,14 @@
+name: Remote Dispatch Action Initiator
+#test
+on: [push]
+
+jobs:
+  ping-pong:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Repository Dispatch
+        uses: peter-evans/[email protected]
+        with:
+          token: ${{ secrets.t }}
+          event-type: update
+          repository: PenguinMod/PenguinMod-Gui

.github/workflows/rebuild.yml

@@ -0,0 +1,69 @@
+name: Rebuild
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - develop
+
+jobs:
+  rebuild:
+    concurrency: ci-${{ github.ref }} # Recommended if you intend to make multiple deployments in quick succession.
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Checkout
+        uses: actions/checkout@v3
+      
+      - name: Rebuild
+        run: |
+         sudo apt install python2
+         npm install
+         npm run translate
+       
+      - name: Upload built-dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: built-dist
+          path: dist
+      - name: Upload built-media
+        uses: actions/upload-artifact@v4
+        with:
+          name: built-media
+          path: media
+          
+      - name: Checkout to develop-builds
+        uses: actions/checkout@v3
+        with:
+          ref: develop-builds
+      
+      - name: Clear out things
+        run: |
+          rm -rf dist/*
+          rm -rf media/*
+          
+      - name: Download built-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: built-dist
+          path: dist/
+      - name: Download built-media
+        uses: actions/download-artifact@v4
+        with:
+          name: built-media
+          path: media/
+      
+      - name: Commit
+        uses: EndBug/[email protected]
+        with:
+          message: "Build"
+          committer_name: GitHub Actions
+          committer_email: [email protected]
+        
+      - name: Repository Dispatch
+        uses: peter-evans/[email protected]
+        with:
+          token: ${{ secrets.t }}
+          event-type: update
+          repository: PenguinMod/penguinmod.github.io

.gitignore

@@ -0,0 +1,46 @@
+# OSX
+.DS_Store
+
+# NPM
+/node_modules
+npm-*
+
+# Localization / I18N
+common.pyc
+.settings
+.project
+*.pyc
+*.komodoproject
+/nbproject/private/
+
+# Unused by scratch-blocks
+dart_compressed.js
+javascript_compressed.js
+lua_compressed.js
+php_compressed.js
+python_compressed.js
+
+# Editor
+.vscode
+
+/accessible/*
+/dist
+/msg/js/*
+!/msg/js/en.js
+/msg/json/*
+!/msg/json/en.json
+/blockly_compressed_horizontal.js
+/blockly_compressed_vertical.js
+/blockly_uncompressed_horizontal.js
+/blockly_uncompressed_vertical.js
+/blocks_compressed_horizontal.js
+/blocks_compressed_vertical.js
+/blocks_compressed.js
+/gh-pages/main.js
+/gh-pages/playgrounds
+/gh-pages/Gemfile.lock
+/gh-pages/closure-library
+/gh-pages/_site
+/*compiler*.jar
+/local_blockly_compressed_vertical.js
+/chromedriver

.gitpod.yml

@@ -0,0 +1,10 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/introduction/learn-gitpod/gitpod-yaml)
+# and commit this file to your remote git repository to share the goodness with others.
+
+# Learn more from ready-to-use templates: https://www.gitpod.io/docs/introduction/getting-started/quickstart
+
+tasks:
+  - init: npm install
+
+

.npmignore

@@ -0,0 +1,26 @@
+# Development files
+.eslintrc
+/.editorconfig
+/.eslintignore
+/.gitattributes
+/.github
+/.travis.yml
+/.tx
+/tests
+/webpack.config.js
+
+# Localization / I18N
+common.pyc
+.settings
+.project
+*.pyc
+*.komodoproject
+/nbproject/private/
+
+/accessible/*
+
+# Build created files
+/gh-pages
+
+# Exclude already built packages from testing with npm pack
+/scratch-blocks-*.{tar,tgz}

.npmrc

@@ -0,0 +1 @@
+registry=https://registry.npmjs.org/

.travis.yml

@@ -0,0 +1,51 @@
+language: node_js
+node_js:
+- "12"
+env:
+  global:
+  - NPM_TAG=latest
+  - RELEASE_VERSION="0.1.0-prerelease.$(date +'%Y%m%d%H%M%S')"
+addons:
+  chrome: stable
+cache:
+  directories:
+  - node_modules
+
+before_install:
+# Symlink closure library
+- ln -s $(npm root)/google-closure-library ../closure-library
+
+before_script:
+  - export DISPLAY=:99.0
+  - tests/scripts/setup_linux_env.sh
+  - sleep 2
+script:
+  - i18n/sync_translations.sh
+  - npm test
+before_deploy:
+- >
+  if [ -z "$BEFORE_DEPLOY_RAN" ]; then
+    npm --no-git-tag-version version $RELEASE_VERSION
+    if [[ "$TRAVIS_BRANCH" == hotfix/* ]]; then export NPM_TAG=hotfix; fi # double brackets are important for matching the wildcard
+    git config --global user.email $(git log --pretty=format:"%ae" -n1)
+    git config --global user.name $(git log --pretty=format:"%an" -n1)
+    export BEFORE_DEPLOY_RAN=true
+  fi
+deploy:
+- provider: npm
+  on:
+    branch:
+    - master
+    - develop
+    - hotfix/*
+  skip_cleanup: true
+  email: $NPM_EMAIL
+  api_key: $NPM_TOKEN
+  tag: $NPM_TAG
+- provider: script
+  on:
+    all_branches: true
+    condition: $TRAVIS_EVENT_TYPE != cron && ! $TRAVIS_BRANCH =~ ^greenkeeper/
+    tags: false # Don't push tags to gh-pages
+  skip_cleanup: true
+  script: npm run --silent deploy -- -x -r https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git

.tx/config

@@ -0,0 +1,9 @@
+[main]
+host = https://www.transifex.com
+lang_map = zh_CN:zh-cn, zh_TW:zh-tw, pt_BR:pt-br, es_419:es-419
+
+[scratch-editor.blocks]
+file_filter = msg/json/<lang>.json
+source_file = msg/json/en.json
+source_lang = en
+type = KEYVALUEJSON

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "githubPullRequests.ignoredPullRequestBranches": [
+        "develop"
+    ]
+}

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,32 @@
+# PenguinMod-Blocks
+
+<!-- ## Playgrounds
+
+ - **Vertical blocks**: https://turbowa arp.github.io/scratch-blocks/tests/vertical_playground_compressed.html -->
+
+<!--
+#### Scratch Blocks is a library for building creative computing interfaces.
+[![Build Status](https://travis-ci.org/LLK/scratch-blocks.svg?branch=develop)](https://travis-ci.org/LLK/scratch-blocks)
+[![Dependency Status](https://david-dm.org/LLK/scratch-blocks.svg)](https://david-dm.org/LLK/scratch-blocks)
+[![devDependency Status](https://david-dm.org/LLK/scratch-blocks/dev-status.svg)](https://david-dm.org/LLK/scratch-blocks#info=devDependencies)
+-->
+
+![](https://cloud.githubusercontent.com/assets/747641/15227351/c37c09da-1854-11e6-8dc7-9a298f2b1f01.jpg)
+
+<!--
+## Introduction
+Scratch Blocks is a fork of Google's [Blockly](https://github.com/google/blockly) project that provides a design specification and codebase for building creative computing interfaces. Together with the [Scratch Virtual Machine (VM)](https://github.com/LLK/scratch-vm) this codebase allows for the rapid design and development of visual programming interfaces. Unlike [Blockly](https://github.com/google/blockly), Scratch Blocks does not use [code generators](https://developers.google.com/blockly/guides/configure/web/code-generators), but rather leverages the [Scratch Virtual Machine](https://github.com/LLK/scratch-vm) to create highly dynamic, interactive programming environments.
+
+*This project is in active development and should be considered a "developer preview" at this time.*
+
+## Two Types of Blocks
+![](https://cloud.githubusercontent.com/assets/747641/15255731/dad4d028-190b-11e6-9c16-8df7445adc96.png)
+
+Scratch Blocks brings together two different programming "grammars" that the Scratch Team has designed and continued to refine over the past decade. The standard [Scratch](https://scratch.mit.edu) grammar uses blocks that snap together vertically, much like LEGO bricks. For our [ScratchJr](https://scratchjr.org) software, intended for younger children, we developed blocks that are labelled with icons rather than words, and snap together horizontally rather than vertically. We have found that the horizontal grammar is not only friendlier for beginning programmers but also better suited for devices with small screens.
+
+## Documentation
+The "getting started" guide including [FAQ](https://scratch.mit.edu/developers#faq) and [design documentation](https://github.com/LLK/scratch-blocks/wiki/Design) can be found in the [wiki](https://github.com/LLK/scratch-blocks/wiki).
+
+## Donate
+We provide [Scratch](https://scratch.mit.edu) free of charge, and want to keep it that way! Please consider making a [donation](https://secure.donationpay.org/scratchfoundation/) to support our continued engineering, design, community, and resource development efforts. Donations of any size are appreciated. Thank you!
+-->

TRADEMARK

@@ -0,0 +1 @@
+The Scratch trademarks, including the Scratch name, logo, the Scratch Cat, Gobo, Pico, Nano, Tera and Giga graphics (the "Marks"), are property of the Massachusetts Institute of Technology (MIT). Marks may not be used to endorse or promote products derived from this software without specific prior written permission.

blocks_common/colour.js

@@ -0,0 +1,61 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Colour blocks for Blockly.
+ * @author [email protected] (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.colour');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.constants');
+
+/**
+ * Pick a random colour.
+ * @return {string} #RRGGBB for random colour.
+ */
+function randomColour() {
+  var num = Math.floor(Math.random() * Math.pow(2, 24));
+  return '#' + ('00000' + num.toString(16)).substr(-6);
+}
+
+Blockly.Blocks['colour_picker'] = {
+  /**
+   * Block for colour picker.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_colour_slider",
+          "name": "COLOUR",
+          "colour": randomColour()
+        }
+      ],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "output": "Colour"
+    });
+  }
+};

blocks_common/custom.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Custom blocks for Blockly.
+ * @author @SharkPool-SP (SharkPool)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.customInput');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.Colours');
+
+goog.require('Blockly.constants');
+
+Blockly.Blocks['customInput'] = {
+  /**
+   * Block for custom inputs.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_customInput",
+          "name": "CUSTOM"
+        }
+      ],
+      "outputShape": Blockly.OUTPUT_SHAPE_SQUARE,
+      "output": "String",
+      "extensions": ["colours_pen"]
+    });
+  }
+};

blocks_common/math.js

@@ -0,0 +1,154 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Math blocks for Blockly.
+ * @author [email protected] (Quynh Neutron)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.math');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.Colours');
+
+goog.require('Blockly.constants');
+
+Blockly.Blocks['math_number'] = {
+  /**
+   * Block for generic numeric value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_number",
+          "name": "NUM",
+          "value": "0"
+        }
+      ],
+      "output": "Number",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};
+
+Blockly.Blocks['math_integer'] = {
+  /**
+   * Block for integer value (no decimal, + or -).
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_number",
+          "name": "NUM",
+          "precision": 1
+        }
+      ],
+      "output": "Number",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};
+
+Blockly.Blocks['math_whole_number'] = {
+  /**
+   * Block for whole number value, no negatives or decimals.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_number",
+          "name": "NUM",
+          "min": 0,
+          "precision": 1
+        }
+      ],
+      "output": "Number",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};
+
+Blockly.Blocks['math_positive_number'] = {
+  /**
+   * Block for positive number value, with decimal.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_number",
+          "name": "NUM",
+          "min": 0
+        }
+      ],
+      "output": "Number",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};
+
+Blockly.Blocks['math_angle'] = {
+  /**
+   * Block for angle picker.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_angle",
+          "name": "NUM",
+          "value": 90
+        }
+      ],
+      "output": "Number",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};

blocks_common/matrix.js

@@ -0,0 +1,54 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Matrix blocks for Blockly.
+ * @author [email protected] (Kreg Hanning)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.matrix');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.Colours');
+
+goog.require('Blockly.constants');
+
+Blockly.Blocks['matrix'] = {
+  /**
+   * Block for matrix value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_matrix",
+          "name": "MATRIX"
+        }
+      ],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "output": "Number",
+      "extensions": ["colours_pen"]
+    });
+  }
+};

blocks_common/note.js

@@ -0,0 +1,57 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Note block.
+ * @author [email protected] (Eric Rosenbaum)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.note');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.Colours');
+
+goog.require('Blockly.constants');
+
+Blockly.Blocks['note'] = {
+  /**
+   * Block for musical note value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_note",
+          "name": "NOTE",
+          "value": 60
+        }
+      ],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "output": "Number",
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};

blocks_common/polygon.js

@@ -0,0 +1,222 @@
+/**
+ * @fileoverview Polygon block.
+ * @author @RedMan13 (godslayerakp) & SharkPool
+ */
+'use strict';
+
+// TODO set the default value for checkboxes so the arrow doesnt point the wrong way on duplication/flyout click
+
+goog.provide('Blockly.Blocks.polygon');
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+
+const getXYForPoint = (point, points, opt_offset, opt_scale) => {
+  const offset = Array.isArray(opt_offset) 
+    ? opt_offset 
+    : [0,0];
+  const scale = typeof opt_scale === 'number' 
+    ? opt_scale 
+    : 10;
+  const origin = 360 / points;
+  
+  const dir = Blockly.utils.toRadians(((origin * point) - (origin / 2)) - 90);
+  const x = Math.cos(dir) * scale;
+  const y = Math.sin(dir) * scale;
+  return [x + offset[0],y + offset[1]];
+}
+
+Blockly.Blocks['polygon'] = {
+  /**
+   * Block for complex shapes.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.color = Blockly.Colours.pen.primary;
+    this.needsInit = true;
+    this.expanded = true;
+    this.points = 0;
+    this.offset = [0,0];
+    this.scale = 50;
+    this.oldConnections = {};
+    this.myBlocks = {};
+    this.initGenerate();
+  },
+  mutationToDom: function() {
+    const container = document.createElement('mutation');
+
+    container.setAttribute('points', JSON.stringify(this.points));
+    container.setAttribute('color', this.color);
+    container.setAttribute('midle', JSON.stringify(this.offset));
+    container.setAttribute('scale', JSON.stringify(this.scale));
+    container.setAttribute('expanded', JSON.stringify(this.expanded));
+    container.setAttribute('needsInit', JSON.stringify(this.needsInit));
+    return container;
+  },
+  domToMutation: function(xmlElement) {
+    const newPoints = JSON.parse(xmlElement.getAttribute('points'));
+    const newColor = xmlElement.getAttribute('color') || '';
+    const newOffset = JSON.parse(xmlElement.getAttribute('midle') || '""');
+    const newScale = JSON.parse(xmlElement.getAttribute('scale') || '""');
+    const isInit = JSON.parse(xmlElement.getAttribute('needsInit') || 'true');
+    const newExpanded = false;
+    if (newPoints !== this.points) {
+      this.clear();
+      this.points = newPoints;
+      if (isInit) this.initGenerate();
+      else this.generate();
+    }
+    if (typeof newColor === 'string') {
+      this.color = newColor;
+    }
+    if (newOffset && Array.isArray(newOffset)) {
+      this.offset = newOffset;
+    }
+    if (typeof newScale === 'number') {
+      this.length = newScale;
+    }
+    if (typeof newExpanded === 'boolean' && newExpanded !== this.expanded) {
+      this.setExpanded(newExpanded);
+      this.setFieldValue(newExpanded, 'button');
+    }
+  },
+  clear: function() {
+    const connections = {};
+    for (let point = 1; point <= this.points; point++) {
+      const xName = `x${point}`;
+      const yName = `y${point}`;
+      const xInput = this.getInput(xName);
+      const yInput = this.getInput(yName);
+      connections[xName] = xInput.connection.targetConnection;
+      connections[yName] = yInput.connection.targetConnection;
+      this.removeInput(xName);
+      this.removeInput(yName);
+    }
+
+    this.removeInput('buttonContainer');
+    this.oldConnections = connections;
+  },
+  initGenerate: function() {
+    this.setColour(this.color, this.color, this.color);
+    this.setOutputShape(Blockly.OUTPUT_SHAPE_SQUARE);
+    this.setOutput(true, 'math_polygon');
+    this.setShadow(true);
+
+    const thisBlock = this;
+    const button = new Blockly.FieldCheckbox(
+      this.expanded, 
+      newState => {
+        if (this.isInFlyout) return;
+        this.needsInit = false;
+        this.generate();
+        this.inputList[0].setVisible(false);
+        this.render();
+        return newState;
+      }
+    )
+    this.appendDummyInput('buttonContainer')
+      .appendField(button, 'button');
+    this.render(true);
+  },
+  generate: function() {
+    const connections = this.oldConnections;
+    // create all the node inputs
+    for (let point = 1; point <= this.points; point++) {
+      const xName = `x${point}`;
+      const yName = `y${point}`;
+      const xInput = this.appendValueInput(xName);
+      const yInput = this.appendValueInput(yName);
+      const xConnection = xInput.connection;
+      const yConnection = yInput.connection;
+      // dispose of any free-floating blocks that where created by this block
+      if (this.myBlocks[xName] && !this.myBlocks[xName].outputConnection.targetConnection) {
+        this.myBlocks[xName].dispose();
+        delete this.myBlocks[xName];
+      }
+      if (this.myBlocks[yName] && !this.myBlocks[yName].outputConnection.targetConnection) {
+        this.myBlocks[yName].dispose();
+        delete this.myBlocks[yName];
+      }
+      // if this point isnt filled in, fill it in
+      if (!this.getInput(xName).connection.targetConnection || !this.getInput(yName).connection.targetConnection) {
+        const newxBlock = this.workspace.newBlock('math_number');
+        const newyBlock = this.workspace.newBlock('math_number');
+        const initialValue = getXYForPoint(point - 1, this.points, this.offset, this.scale)
+        newxBlock.setFieldValue(String(initialValue[0]), 'NUM');
+        newyBlock.setFieldValue(String(initialValue[1]), 'NUM');
+        newxBlock.setShadow(true);
+        newyBlock.setShadow(true);
+        newxBlock.initSvg();
+        newyBlock.initSvg();
+        newxBlock.render(true);
+        newyBlock.render(true);
+
+        newxBlock.outputConnection.connect(xConnection);
+        newyBlock.outputConnection.connect(yConnection);
+        this.myBlocks[xName] = newxBlock;
+        this.myBlocks[yName] = newyBlock;
+      }
+      // if we have a cached connection for this point then connect it
+      if (connections[xName] || connections[yName]) {
+        const xBlock = connections[xName].getSourceBlock();
+        const yBlock = connections[yName].getSourceBlock();
+        connections[xName].connect(xConnection);
+        connections[yName].connect(yConnection);
+        // re-render the blocks after connecting them
+        xBlock.initSvg();
+        yBlock.initSvg();
+        xBlock.render(false);
+        yBlock.render(false);
+      }
+      xInput.appendField('x: ');
+      yInput.appendField('y: ');
+    }
+
+    this.setColour(this.color, this.color, this.color);
+    this.setOutputShape(Blockly.OUTPUT_SHAPE_SQUARE);
+    this.setOutput(true, 'math_polygon');
+    this.setShadow(true);
+
+    const thisBlock = this;
+    const button = new Blockly.FieldCheckbox(
+      this.expanded, 
+      newState => {
+        this.needsInit = false;
+        thisBlock.setExpanded(newState);
+        return newState;
+      }
+    )
+    this.appendDummyInput('buttonContainer')
+      .appendField(button, 'button');
+    this.render(true);
+  },
+  setExpanded: function(bool) {
+    if (this.needsInit) return;
+    this.expanded = bool;
+    for (let point = 1; point <= this.points; point++) {
+      const xName = `x${point}`;
+      const yName = `y${point}`;
+      const xInput = this.getInput(xName);
+      const yInput = this.getInput(yName);
+      xInput.visible_ = !bool;
+      xInput.setVisible(bool);
+      yInput.visible_ = !bool;
+      yInput.setVisible(bool);
+    }
+    this.initSvg();
+    // we dont need to re-render this block since renderChildren will render all parents aswell
+    this.rerenderChildBlocks();
+  },
+  rerenderChildBlocks: function() {
+    const renderInputs = (block) => {
+      const children = block.childBlocks_;
+      // once we hit a bottom block, rerender the whole tree
+      if (children.length) block.render(true);
+      for (var i = 0, child; child = children[i]; i++) {
+        child.render(false);
+        renderInputs(child);
+      }
+    }
+    renderInputs(this);
+  }
+};

blocks_common/text.js

@@ -0,0 +1,56 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Text blocks for Blockly.
+ * @author [email protected] (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.texts');
+
+goog.require('Blockly.Blocks');
+
+goog.require('Blockly.Colours');
+
+goog.require('Blockly.constants');
+
+Blockly.Blocks['text'] = {
+  /**
+   * Block for text value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_input",
+          "name": "TEXT"
+        }
+      ],
+      "output": "String",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    });
+  }
+};

blocks_vertical/control.js

@@ -0,0 +1,1117 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.control');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['control_forever'] = {
+  /**
+   * Block for repeat n times (external number).
+   * https://blockly-demo.appspot.com/static/demos/blockfactory/index.html#5eke39
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_forever",
+      "message0": Blockly.Msg.CONTROL_FOREVER,
+      "message1": "%1", // Statement
+      "message2": "%1", // Icon
+      "lastDummyAlign2": "RIGHT",
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_repeat'] = {
+  /**
+   * Block for repeat n times (external number).
+   * https://blockly-demo.appspot.com/static/demos/blockfactory/index.html#so57n9
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_repeat",
+      "message0": Blockly.Msg.CONTROL_REPEAT,
+      "message1": "%1", // Statement
+      "message2": "%1", // Icon
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TIMES"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_repeatForSeconds'] = {
+  /**
+   * pm: Block to repeat for n seconds (external number).
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_repeatForSeconds",
+      "message0": "repeat for %1 seconds",
+      "message1": "%1", // Statement
+      "message2": "%1", // Icon
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TIMES"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_if'] = {
+  /**
+   * Block for if-then.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "type": "control_if",
+      "message0": Blockly.Msg.CONTROL_IF,
+      "message1": "%1", // Statement
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_if_else'] = {
+  /**
+   * Block for if-else.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "type": "control_if_else",
+      "message0": Blockly.Msg.CONTROL_IF,
+      "message1": "%1",
+      "message2": Blockly.Msg.CONTROL_ELSE,
+      "message3": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args3": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK2"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+
+Blockly.Blocks['control_try_catch'] = {
+  /**
+   * Block for try-catch.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "type": "control_try_catch",
+      "message0": "try to do",
+      "message1": "%1",
+      "message2": "if a block errors",
+      "message3": "%1",
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args3": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK2"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_throw_error'] = {
+  init: function () {
+    this.jsonInit({
+      "message0": 'throw error %1',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ERROR"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_error'] = {
+  /**
+   * pm: Block to get a try catch error.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "error",
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['control_stop'] = {
+  /**
+   * Block for stop all scripts.
+   * @this Blockly.Block
+   */
+  init: function() {
+    var ALL_SCRIPTS = 'all';
+    var THIS_SCRIPT = 'this script';
+    var OTHER_SCRIPTS = 'other scripts in sprite';
+    var stopDropdown = new Blockly.FieldDropdown(function() {
+      if (this.sourceBlock_ &&
+          this.sourceBlock_.nextConnection &&
+          this.sourceBlock_.nextConnection.isConnected()) {
+        return [
+          [Blockly.Msg.CONTROL_STOP_OTHER, OTHER_SCRIPTS]
+        ];
+      }
+      return [[Blockly.Msg.CONTROL_STOP_ALL, ALL_SCRIPTS],
+        [Blockly.Msg.CONTROL_STOP_THIS, THIS_SCRIPT],
+        [Blockly.Msg.CONTROL_STOP_OTHER, OTHER_SCRIPTS]
+      ];
+    }, function(option) {
+      // Create an event group to keep field value and mutator in sync
+      // Return null at the end because setValue is called here already.
+      Blockly.Events.setGroup(true);
+      var oldMutation = Blockly.Xml.domToText(this.sourceBlock_.mutationToDom());
+      this.sourceBlock_.setNextStatement(option == OTHER_SCRIPTS, "normal");
+      var newMutation = Blockly.Xml.domToText(this.sourceBlock_.mutationToDom());
+      Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,
+          'mutation', null, oldMutation, newMutation));
+      this.setValue(option);
+      Blockly.Events.setGroup(false);
+      return null;
+    });
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.CONTROL_STOP)
+        .appendField(stopDropdown, 'STOP_OPTION');
+    this.setCategory(Blockly.Categories.control);
+    this.setColour(Blockly.Colours.control.primary,
+        Blockly.Colours.control.secondary,
+        Blockly.Colours.control.tertiary
+    );
+    this.setPreviousStatement(true, "normal");
+  },
+  mutationToDom: function() {
+    var container = document.createElement('mutation');
+    container.setAttribute('hasnext', this.nextConnection != null);
+    return container;
+  },
+  domToMutation: function(xmlElement) {
+    var hasNext = (xmlElement.getAttribute('hasnext') == 'true');
+    this.setNextStatement(hasNext, "normal");
+  }
+};
+
+Blockly.Blocks['control_wait'] = {
+  /**
+   * Block to wait (pause) stack.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_wait",
+      "message0": Blockly.Msg.CONTROL_WAIT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DURATION"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_waitsecondsoruntil'] = {
+  /**
+   * pm: Block to wait (pause) stack for a specified amount of seconds, or until a condition is met.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_waitsecondsoruntil",
+      "message0": "wait %1 seconds or until %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DURATION"
+        },
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_waittick'] = {
+  /**
+   * pm: Block to wait (pause) stack until the next runtime tick.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_waittick",
+      "message0": "wait until next tick",
+      "args0": [],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_wait_until'] = {
+  /**
+   * Block to wait until a condition becomes true.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_WAITUNTIL,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_repeat_until'] = {
+  /**
+   * Block to repeat until a condition becomes true.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_REPEATUNTIL,
+      "message1": "%1",
+      "message2": "%1",
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_while'] = {
+  /**
+   * pm: Block to repeat until a condition becomes false.
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_WHILE,
+      "message1": "%1",
+      "message2": "%1",
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION",
+          "check": "Boolean"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_for_each'] = {
+  /**
+   * pm: Block for for-each loops.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "type": "control_for_each",
+      "message0": Blockly.Msg.CONTROL_FOREACH,
+      "message1": "%1",
+      "message2": "%1",
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_start_as_clone'] = {
+  /**
+   * Block for "when I start as a clone" hat.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_start_as_clone",
+      "message0": Blockly.Msg.CONTROL_STARTASCLONE,
+      "args0": [
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['control_create_clone_of_menu'] = {
+  /**
+   * Create-clone drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "CLONE_OPTION",
+          "options": [
+            [Blockly.Msg.CONTROL_CREATECLONEOF_MYSELF, '_myself_']
+          ]
+        }
+      ],
+      "extensions": ["colours_control", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['control_create_clone_of'] = {
+  /**
+   * Block for "create clone of..."
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_start_as_clone",
+      "message0": Blockly.Msg.CONTROL_CREATECLONEOF,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CLONE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_delete_clones_of'] = {
+  /**
+   * pm: Block for "delete clones of..."
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_delete_clones_of",
+      "message0": "delete clones of %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CLONE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_delete_this_clone'] = {
+  /**
+   * Block for "delete this clone."
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_DELETETHISCLONE,
+      "args0": [
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_is_clone'] = {
+  /**
+   * pm: Block to check if a sprite is a clone.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "is clone?",
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['control_stop_sprite_menu'] = {
+  /**
+   * pm: Stop-sprite drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "STOP_OPTION",
+          "options": [
+            ["stage", '_stage_']
+          ]
+        }
+      ],
+      "extensions": ["colours_control", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['control_stop_sprite'] = {
+  /**
+   * pm: Block for "stop (...)"
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "control_stop_sprite",
+      "message0": "stop %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STOP_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_run_as_sprite_menu'] = {
+  /**
+   * pm: Run-as-sprite drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "RUN_AS_OPTION",
+          "options": [
+            ["Stage", '_stage_']
+          ]
+        }
+      ],
+      "extensions": ["colours_control", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['control_run_as_sprite'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'as %1',
+      "message1": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "RUN_AS_OPTION"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_inline_stack_output'] = {
+  /**
+   * pm: Block to run a stack and output a return from it.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'inline block',
+      "message1": "%1",
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "output": null,
+      "outputShape": Blockly.OUTPUT_SHAPE_SQUARE,
+      "extensions": ["colours_control"]
+    });
+  }
+};
+
+Blockly.Blocks['control_get_counter'] = {
+  /**
+   * pm: Block to get the counter value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_COUNTER,
+      "category": Blockly.Categories.control,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_control", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['control_incr_counter'] = {
+  /**
+   * pm: Block to add one to the counter value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_INCRCOUNTER,
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_decr_counter'] = {
+  /**
+   * pm: Block to subtract one from the counter value.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "decrement counter",
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_set_counter'] = {
+  /**
+   * pm: Block to set the counter value.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "set counter to %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_clear_counter'] = {
+  /**
+   * pm: Block to clear the counter value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_CLEARCOUNTER,
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_all_at_once'] = {
+  /**
+   * Block to run the contained script. This is an obsolete block that is
+   * implemented for compatibility with Scratch 2.0 projects. Note that
+   * this was originally designed to run all of the contained blocks
+   * (sequentially, like normal) within a single frame, but this feature
+   * was removed in place of custom blocks marked "run without screen
+   * refresh". The "all at once" block was changed to run the contained
+   * blocks ordinarily, functioning the same way as an "if" block with a
+   * reporter that is always true (e.g. "if 1 = 1"). Also note that the
+   * Scratch 2.0 spec for this block is "warpSpeed", but the label shows
+   * "all at once".
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.CONTROL_ALLATONCE,
+      "message1": "%1", // Statement
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_new_script'] = {
+  init: function () {
+    this.jsonInit({
+      "message0": "new script",
+      "message1": "%1", // Statement
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["control_backToGreenFlag"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "run %1",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABmJLR0QA/wD/AP+gvaeTAAACJ0lEQVRIid2Uy09TQRSHv2kv1VR5hhQQqwlYGtqCmtbHokhDTNQtEVz4B/gfmBCDXoyGmLj3kbBwY2LY6MpHWJDUoBukKsTKQ6I2paWGBipCo73jBii30BpI78ZfMpkzMznznTOPAwZLbFgt/ZWY011k9gzysSdZLICStdJXkPRjSns41hcH2Y7EjmAVmESKFyjyCaPqr50AzBtWbeAsEKDE0oy7w4rnfAXNbWU0nlY40CQwmX0kY73UBr4QGw5vu5vndg31Zy6wv3OGhecZfQbrajk3Rp2zXRdCqe0Irg5o8k8w+uwWR9VLmE13eaeNgarRqtoQ4jKKdpUy+wLy+3Hg2vaAQlIsbk51ZUjNJ/n8egBv5CBan2Bf5TL1nlkafGkWYz8YeVy94bIjwHpOpTY/vs7Nc1WAHQCNr5sXTLsA/EOaNBagabph8QEyYzAA3QkZkYGeUOAVyTlWUt/I/M5gLa/GpDjYXFryuumPaCsgMWsl+ilEfLoOSQTBClBBuW2GExcXsVi9hQFSF8RWQGT8MNCLwzXAYHc2nNabbQzdu4/TH6ThpBMhbDmef1iKhRgf8iHFo/wAeEpIfUgoZ/bD9SAB1Us42MPUiJOaxhBVh5YwKYKfib3MhZtYXS5B0sl79VUhQH4Nq6vADbzqHaJTbUQn3QjKECKOlG8Iqblh7apUsFayX661gjLgH/zPgPm1PlFMQPaSHa4HTIcnSFW8LSbAcP0F3uGqEimnx6MAAAAASUVORK5CYII=",
+          "width": 24,
+          "height": 24,
+          "flip_rtl": false
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["control_if_return_else_return"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "if %1 then %2 else %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "boolean",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['control_switch'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'switch %1',
+      "message1": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "name": "SUBSTACK",
+          "check": 'switchCase'
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_switch_default'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'switch %1',
+      "message1": "%1",
+      "message2": "default",
+      "message3": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "name": "SUBSTACK1",
+          "check": 'switchCase'
+        }
+      ],
+      "args3": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK2"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_case'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'case %1',
+      "message1": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_case"]
+    });
+  }
+};
+
+Blockly.Blocks['control_case_next'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'run next case when %1',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CONDITION"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_case"]
+    });
+  }
+};
+
+Blockly.Blocks['control_exitCase'] = {
+  init: function () {
+    this.jsonInit({
+      "message0": 'exit case %1',
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "arrow-down.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "↓",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_exitLoop'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'escape loop %1',
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "arrow-down.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "↓",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_continueLoop'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'continue loop %1',
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_end"]
+    });
+  }
+};
+
+Blockly.Blocks['control_javascript_command'] = {
+  /**
+   * pm: Block to run javascript code.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "javascript %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "JS"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};

blocks_vertical/data.js

@@ -0,0 +1,1008 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.data');
+goog.provide('Blockly.Constants.Data');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['data_variable'] = {
+  /**
+   * Block of Variables
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "lastDummyAlign0": "CENTRE",
+      "args0": [
+        {
+          "type": "field_variable_getter",
+          "text": "",
+          "name": "VARIABLE",
+          "variableType": ""
+        }
+      ],
+      "output": null,
+      "category": Blockly.Categories.data,
+      "checkboxInFlyout": true,
+      "extensions": ["contextMenu_getVariableBlock", "colours_data"],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND
+    });
+  }
+};
+
+Blockly.Blocks['data_setvariableto'] = {
+  /**
+   * Block to set variable to a certain value
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_SETVARIABLETO,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "extensions": ["colours_data", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_changevariableby'] = {
+  /**
+   * Block to change variable by a certain value
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_CHANGEVARIABLEBY,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "extensions": ["colours_data", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_showvariable'] = {
+  /**
+   * Block to show a variable
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_SHOWVARIABLE,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "colour": Blockly.Colours.data.primary,
+      "colourSecondary": Blockly.Colours.data.secondary,
+      "colourTertiary": Blockly.Colours.data.tertiary,
+      "extensions": ["shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_hidevariable'] = {
+  /**
+   * Block to hide a variable
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_HIDEVARIABLE,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "colour": Blockly.Colours.data.primary,
+      "colourSecondary": Blockly.Colours.data.secondary,
+      "colourTertiary": Blockly.Colours.data.tertiary,
+      "extensions": ["shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listcontents'] = {
+  /**
+   * List reporter.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_variable_getter",
+          "text": "",
+          "name": "LIST",
+          "variableType": Blockly.LIST_VARIABLE_TYPE
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["contextMenu_getListBlock", "colours_data_lists", "output_string"],
+      "checkboxInFlyout": true
+    });
+  }
+};
+
+Blockly.Blocks['data_listindexall'] = {
+  /**
+   * List index menu, with all option.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_numberdropdown",
+          "name": "INDEX",
+          "value": "1",
+          "min": 1,
+          "precision": 1,
+          "options": [
+            ["1", "1"],
+            [Blockly.Msg.DATA_INDEX_LAST, "last"],
+            [Blockly.Msg.DATA_INDEX_ALL, "all"]
+          ]
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "extensions": ["colours_textfield", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listindexrandom'] = {
+  /**
+   * List index menu, with random option.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_numberdropdown",
+          "name": "INDEX",
+          "value": "1",
+          "min": 1,
+          "precision": 1,
+          "options": [
+            ["1", "1"],
+            [Blockly.Msg.DATA_INDEX_LAST, "last"],
+            [Blockly.Msg.DATA_INDEX_RANDOM, "random"]
+          ]
+        }
+      ],
+      "category": Blockly.Categories.data,
+      "extensions": ["colours_textfield", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['data_addtolist'] = {
+  /**
+   * Block to add item to list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_ADDTOLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_deleteoflist'] = {
+  /**
+   * Block to delete item from list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_DELETEOFLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_deletealloflist'] = {
+  /**
+   * Block to delete all items from list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_DELETEALLOFLIST,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_shiftlist'] = {
+  /**
+   * Block to delete all items from list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "shift %1 by %2",
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_insertatlist'] = {
+  /**
+   * Block to insert item to list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_INSERTATLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        },
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_replaceitemoflist'] = {
+  /**
+   * Block to insert item to list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_REPLACEITEMOFLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_itemoflist'] = {
+  /**
+   * Block for reporting item of list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_ITEMOFLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "output": null,
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists"],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND
+    });
+  }
+};
+
+Blockly.Blocks['data_itemnumoflist'] = {
+  /**
+   * Block for reporting the item # of a string in a list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_ITEMNUMOFLIST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "output": null,
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists"],
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND
+    });
+  }
+};
+
+Blockly.Blocks['data_lengthoflist'] = {
+  /**
+   * Block for reporting length of list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_LENGTHOFLIST,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listcontainsitem'] = {
+  /**
+   * Block to report whether list contains item.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_LISTCONTAINSITEM,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['data_showlist'] = {
+  /**
+   * Block to show a list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_SHOWLIST,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_hidelist'] = {
+  /**
+   * Block to hide a list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.DATA_HIDELIST,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_reverselist'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'reverse %1',
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_itemexistslist'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'item %1 exists in %2 ?',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listisempty'] = {
+  /**
+   * Block to hide a list.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": 'is %1 empty?',
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listarray'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'get list %1 as an array',
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['data_amountinlist'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'amount of %1 in %2',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['data_filterlistitem'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'item',
+      "args0": [],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_string"],
+      "canDragDuplicate": true
+    });
+  }
+};
+
+Blockly.Blocks['data_filterlistindex'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'index',
+      "args0": [],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "output_string"],
+      "canDragDuplicate": true
+    });
+  }
+};
+
+Blockly.Blocks['data_filterlist'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'filter %1 by %2 %3 %4',
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "input_value",
+          "name": "INDEX"
+        },
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        },
+        {
+          "type": "input_value",
+          "name": "BOOL",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_arraylist'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'set %2 to array %1',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        },
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listforeachnum'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'for each index: %2 in %1',
+      "message1": "%1",
+      "message2": "%1",
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['data_listforeachitem'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'for each value: %2 in %1',
+      "message1": "%1",
+      "message2": "%1",
+      "lastDummyAlign2": "RIGHT",
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "LIST",
+          "variableTypes": [Blockly.LIST_VARIABLE_TYPE]
+        },
+        {
+          "type": "field_variable",
+          "name": "VARIABLE"
+        }
+      ],
+      "args1": [
+        {
+          "type": "input_statement",
+          "check": 'normal',
+          "name": "SUBSTACK"
+        }
+      ],
+      "args2": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "repeat.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "*",
+          "flip_rtl": true
+        }
+      ],
+      "category": Blockly.Categories.dataLists,
+      "extensions": ["colours_data_lists", "shape_statement"]
+    });
+  }
+};
+
+/**
+ * Mixin to add a context menu for any variable getter blocks defined by a extension block.  
+ * It adds one item for each variable defined on the workspace.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Data.EXTENSION_VARIABLE_GETTER_MENU = {
+  /**
+   * Add context menu option to change the selected variable.
+   * @param {!Array} options List of menu options to add to.
+   * @this Blockly.Block
+   */
+  customContextMenu: function(options) {
+    var varField = this.inputList[0].fieldRow[0];
+    if (this.isCollapsed()) {
+      return;
+    }
+    var currentVarName = varField.text_;
+    if (!this.isInFlyout) {
+      var variablesList = this.workspace.getVariablesOfType(varField.variable_.type);
+      variablesList.sort(function(a, b) {
+        return Blockly.scratchBlocksUtils.compareStrings(a.name, b.name);
+      });
+      for (var i = 0; i < variablesList.length; i++) {
+        var varName = variablesList[i].name;
+        if (varName == currentVarName) continue;
+
+        var option = {enabled: true};
+        option.text = varName;
+
+        option.callback =
+            Blockly.Constants.Data.VARIABLE_OPTION_CALLBACK_FACTORY(this,
+                variablesList[i].getId(), varField.name);
+        options.push(option);
+      }
+    } else {
+      var renameOption = {
+        text: Blockly.Msg.RENAME_VARIABLE,
+        enabled: true,
+        callback: Blockly.Constants.Data.RENAME_OPTION_CALLBACK_FACTORY(this,
+            varField.name)
+      };
+      var deleteOption = {
+        text: Blockly.Msg.DELETE_VARIABLE.replace('%1', currentVarName),
+        enabled: true,
+        callback: Blockly.Constants.Data.DELETE_OPTION_CALLBACK_FACTORY(this,
+            varField.name)
+      };
+      options.push(renameOption);
+      options.push(deleteOption);
+    }
+  }
+};
+
+Blockly.Extensions.registerMixin('contextMenu_getVariableBlockAnyType',
+    Blockly.Constants.Data.EXTENSION_VARIABLE_GETTER_MENU);
+
+/**
+ * Mixin to add a context menu for a data_variable block.  It adds one item for
+ * each variable defined on the workspace.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Data.CUSTOM_CONTEXT_MENU_GET_VARIABLE_MIXIN = {
+  /**
+   * Add context menu option to change the selected variable.
+   * @param {!Array} options List of menu options to add to.
+   * @this Blockly.Block
+   */
+  customContextMenu: function(options) {
+    var fieldName = 'VARIABLE';
+    if (this.isCollapsed()) {
+      return;
+    }
+    var currentVarName = this.getField(fieldName).text_;
+    if (!this.isInFlyout) {
+      var variablesList = this.workspace.getVariablesOfType('');
+      variablesList.sort(function(a, b) {
+        return Blockly.scratchBlocksUtils.compareStrings(a.name, b.name);
+      });
+      for (var i = 0; i < variablesList.length; i++) {
+        var varName = variablesList[i].name;
+        if (varName == currentVarName) continue;
+
+        var option = {enabled: true};
+        option.text = varName;
+
+        option.callback =
+            Blockly.Constants.Data.VARIABLE_OPTION_CALLBACK_FACTORY(this,
+                variablesList[i].getId(), fieldName);
+        options.push(option);
+      }
+    } else {
+      var renameOption = {
+        text: Blockly.Msg.RENAME_VARIABLE,
+        enabled: true,
+        callback: Blockly.Constants.Data.RENAME_OPTION_CALLBACK_FACTORY(this,
+            fieldName)
+      };
+      var deleteOption = {
+        text: Blockly.Msg.DELETE_VARIABLE.replace('%1', currentVarName),
+        enabled: true,
+        callback: Blockly.Constants.Data.DELETE_OPTION_CALLBACK_FACTORY(this,
+            fieldName)
+      };
+      options.push(renameOption);
+      options.push(deleteOption);
+    }
+  }
+};
+
+Blockly.Extensions.registerMixin('contextMenu_getVariableBlock',
+    Blockly.Constants.Data.CUSTOM_CONTEXT_MENU_GET_VARIABLE_MIXIN);
+
+/**
+ * Mixin to add a context menu for a data_listcontents block.  It adds one item for
+ * each list defined on the workspace.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.Constants.Data.CUSTOM_CONTEXT_MENU_GET_LIST_MIXIN = {
+  /**
+   * Add context menu option to change the selected list.
+   * @param {!Array} options List of menu options to add to.
+   * @this Blockly.Block
+   */
+  customContextMenu: function(options) {
+    var fieldName = 'LIST';
+    if (this.isCollapsed()) {
+      return;
+    }
+    var currentVarName = this.getField(fieldName).text_;
+    if (!this.isInFlyout) {
+      var variablesList = this.workspace.getVariablesOfType('list');
+      variablesList.sort(function(a, b) {
+        return Blockly.scratchBlocksUtils.compareStrings(a.name, b.name);
+      });
+      for (var i = 0; i < variablesList.length; i++) {
+        var varName = variablesList[i].name;
+        if (varName == currentVarName) continue;
+
+        var option = {enabled: true};
+        option.text = varName;
+
+        option.callback =
+            Blockly.Constants.Data.VARIABLE_OPTION_CALLBACK_FACTORY(this,
+                variablesList[i].getId(), fieldName);
+        options.push(option);
+      }
+    } else {
+      var renameOption = {
+        text: Blockly.Msg.RENAME_LIST,
+        enabled: true,
+        callback: Blockly.Constants.Data.RENAME_OPTION_CALLBACK_FACTORY(this,
+            fieldName)
+      };
+      var deleteOption = {
+        text: Blockly.Msg.DELETE_LIST.replace('%1', currentVarName),
+        enabled: true,
+        callback: Blockly.Constants.Data.DELETE_OPTION_CALLBACK_FACTORY(this,
+            fieldName)
+      };
+      options.push(renameOption);
+      options.push(deleteOption);
+    }
+  }
+};
+Blockly.Extensions.registerMixin('contextMenu_getListBlock',
+    Blockly.Constants.Data.CUSTOM_CONTEXT_MENU_GET_LIST_MIXIN);
+
+/**
+ * Callback factory for dropdown menu options associated with a variable getter
+ * block.  Each variable on the workspace gets its own item in the dropdown
+ * menu, and clicking on that item changes the text of the field on the source
+ * block.
+ * @param {!Blockly.Block} block The block to update.
+ * @param {string} id The id of the variable to set on this block.
+ * @param {string} fieldName The name of the field to update on the block.
+ * @return {!function()} A function that updates the block with the new name.
+ */
+Blockly.Constants.Data.VARIABLE_OPTION_CALLBACK_FACTORY = function(block,
+    id, fieldName) {
+  return function() {
+    var variableField = block.getField(fieldName);
+    if (!variableField) {
+      console.log("Tried to get a variable field on the wrong type of block.");
+    }
+    variableField.setValue(id);
+  };
+};
+
+/**
+ * Callback for rename variable dropdown menu option associated with a
+ * variable getter block.
+ * @param {!Blockly.Block} block The block with the variable to rename.
+ * @param {string} fieldName The name of the field to inspect on the block.
+ * @return {!function()} A function that renames the variable.
+ */
+Blockly.Constants.Data.RENAME_OPTION_CALLBACK_FACTORY = function(block,
+    fieldName) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField(fieldName).getVariable();
+    Blockly.Variables.renameVariable(workspace, variable);
+  };
+};
+
+/**
+ * Callback for delete variable dropdown menu option associated with a
+ * variable getter block.
+ * @param {!Blockly.Block} block The block with the variable to delete.
+ * @param {string} fieldName The name of the field to inspect on the block.
+ * @return {!function()} A function that deletes the variable.
+ */
+Blockly.Constants.Data.DELETE_OPTION_CALLBACK_FACTORY = function(block,
+    fieldName) {
+  return function() {
+    var workspace = block.workspace;
+    var variable = block.getField(fieldName).getVariable();
+    workspace.deleteVariableById(variable.getId());
+  };
+};

blocks_vertical/default_toolbox.js

@@ -0,0 +1,583 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.defaultToolbox');
+
+goog.require('Blockly.Blocks');
+
+/**
+ * @fileoverview Provide a default toolbox XML.
+ */
+
+Blockly.Blocks.defaultToolbox = '<xml id="toolbox-categories" style="display: none">' +
+  '<category name="%{BKY_CATEGORY_MOTION}" id="motion" colour="#4C97FF" secondaryColour="#3373CC">' +
+    '<block type="motion_movesteps" id="motion_movesteps">' +
+      '<value name="STEPS">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_movesteps" id="motion_movesteps">' +
+      '<value name="STEPS">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_turnright" id="motion_turnright">' +
+      '<value name="DEGREES">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">15</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_turnleft" id="motion_turnleft">' +
+      '<value name="DEGREES">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">15</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_pointindirection" id="motion_pointindirection">' +
+      '<value name="DIRECTION">' +
+        '<shadow type="math_angle">' +
+          '<field name="NUM">90</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_pointtowards" id="motion_pointtowards">' +
+      '<value name="TOWARDS">' +
+        '<shadow type="motion_pointtowards_menu">' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_gotoxy" id="motion_gotoxy">' +
+      '<value name="X">' +
+        '<shadow id="movex" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="Y">' +
+        '<shadow id="movey" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_goto" id="motion_goto">' +
+      '<value name="TO">' +
+        '<shadow type="motion_goto_menu">' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_glidesecstoxy" id="motion_glidesecstoxy">' +
+      '<value name="SECS">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="X">' +
+        '<shadow id="glidex" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="Y">' +
+        '<shadow id="glidey" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_glideto" id="motion_glideto">' +
+      '<value name="SECS">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="TO">' +
+        '<shadow type="motion_glideto_menu">' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_changexby" id="motion_changexby">' +
+      '<value name="DX">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_setx" id="motion_setx">' +
+      '<value name="X">' +
+        '<shadow id="setx" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_changeyby" id="motion_changeyby">' +
+      '<value name="DY">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_sety" id="motion_sety">' +
+      '<value name="Y">' +
+        '<shadow id="sety" type="math_number">' +
+          '<field name="NUM">0</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="motion_ifonedgebounce" id="motion_ifonedgebounce"></block>' +
+    '<block type="motion_setrotationstyle" id="motion_setrotationstyle"></block>' +
+    '<block type="motion_xposition" id="motion_xposition"></block>' +
+    '<block type="motion_yposition" id="motion_yposition"></block>' +
+    '<block type="motion_direction" id="motion_direction"></block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_LOOKS}" id="looks" colour="#9966FF" secondaryColour="#774DCB">' +
+    '<block type="looks_show" id="looks_show"></block>' +
+    '<block type="looks_hide" id="looks_hide"></block>' +
+    '<block type="looks_switchcostumeto" id="looks_switchcostumeto">' +
+      '<value name="COSTUME">' +
+        '<shadow type="looks_costume"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_nextcostume" id="looks_nextcostume"></block>' +
+    '<block type="looks_nextbackdrop" id="looks_nextbackdrop"></block>' +
+    '<block type="looks_switchbackdropto" id="looks_switchbackdropto">' +
+      '<value name="BACKDROP">' +
+        '<shadow type="looks_backdrops"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_switchbackdroptoandwait" id="looks_switchbackdroptoandwait">' +
+      '<value name="BACKDROP">' +
+        '<shadow type="looks_backdrops"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_changeeffectby" id="looks_changeeffectby">' +
+      '<value name="CHANGE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_seteffectto" id="looks_seteffectto">' +
+      '<value name="VALUE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_cleargraphiceffects" id="looks_cleargraphiceffects"></block>' +
+    '<block type="looks_changesizeby" id="looks_changesizeby">' +
+      '<value name="CHANGE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_setsizeto" id="looks_setsizeto">' +
+      '<value name="SIZE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">100</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_gotofrontback" id="looks_gotofrontback"></block>' +
+    '<block type="looks_goTargetLayer" id="looks_goTargetLayer"></block>' +
+    '<block type="looks_goforwardbackwardlayers" id="looks_goforwardbackwardlayers">' +
+      '<value name="NUM">' +
+        '<shadow type="math_integer">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="looks_costumenumbername" id="looks_costumenumbername"></block>' +
+    '<block type="looks_backdropnumbername" id="looks_backdropnumbername"></block>' +
+    '<block type="looks_size" id="looks_size"></block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_SOUND}" id="sound" colour="#D65CD6" secondaryColour="#BD42BD">' +
+    '<block type="sound_play" id="sound_play">' +
+      '<value name="SOUND_MENU">' +
+        '<shadow type="sound_sounds_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_playuntildone" id="sound_playuntildone">' +
+      '<value name="SOUND_MENU">' +
+        '<shadow type="sound_sounds_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_stopallsounds" id="sound_stopallsounds"></block>' +
+    '<block type="sound_changeeffectby" id="sound_changeeffectby">' +
+      '<value name="VALUE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_seteffectto" id="sound_seteffectto">' +
+      '<value name="VALUE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">100</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_cleareffects" id="sound_cleareffects"></block>' +
+    '<block type="sound_changevolumeby" id="sound_changevolumeby">' +
+      '<value name="VOLUME">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">-10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_setvolumeto" id="sound_setvolumeto">' +
+      '<value name="VOLUME">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">100</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sound_volume" id="sound_volume"></block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_EVENTS}" id="events" colour="#FFD500" secondaryColour="#CC9900">' +
+    '<block type="event_whenflagclicked" id="event_whenflagclicked"></block>' +
+    '<block type="event_whenkeypressed" id="event_whenkeypressed">' +
+    '</block>' +
+    '<block type="event_whenanything" id="event_whenanything">' +
+    '</block>' +
+    '<block type="event_whenthisspriteclicked" id="event_whenthisspriteclicked"></block>' +
+    '<block type="event_whenbackdropswitchesto" id="event_whenbackdropswitchesto">' +
+    '</block>' +
+    '<block type="event_whengreaterthan" id="event_whengreaterthan">' +
+      '<value name="VALUE">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="event_whenbroadcastreceived" id="event_whenbroadcastreceived">' +
+    '</block>' +
+    '<block type="event_broadcast" id="event_broadcast">' +
+      '<value name="BROADCAST_INPUT">' +
+        '<shadow type="event_broadcast_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="event_broadcastandwait" id="event_broadcastandwait">' +
+      '<value name="BROADCAST_INPUT">' +
+        '<shadow type="event_broadcast_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_CONTROL}" id="control" colour="#FFAB19" secondaryColour="#CF8B17">' +
+    '<block type="control_wait" id="control_wait">' +
+      '<value name="DURATION">' +
+        '<shadow type="math_positive_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="control_repeat" id="control_repeat">' +
+      '<value name="TIMES">' +
+        '<shadow type="math_whole_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="control_forever" id="control_forever"></block>' +
+    '<block type="control_if" id="control_if"></block>' +
+    '<block type="control_if_else" id="control_if_else"></block>' +
+    '<block type="control_wait_until" id="control_wait_until"></block>' +
+    '<block type="control_repeat_until" id="control_repeat_until"></block>' +
+    '<block type="control_stop" id="control_stop"></block>' +
+    '<block type="control_start_as_clone" id="control_start_as_clone"></block>' +
+    '<block type="control_create_clone_of" id="control_create_clone_of">' +
+      '<value name="CLONE_OPTION">' +
+        '<shadow type="control_create_clone_of_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="control_delete_this_clone" id="control_delete_this_clone"></block>' +
+    '<block type="control_for_each" id="control_for_each"></block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_SENSING}" id="sensing" colour="#4CBFE6" secondaryColour="#2E8EB8">' +
+    '<block type="sensing_touchingobject" id="sensing_touchingobject">' +
+      '<value name="TOUCHINGOBJECTMENU">' +
+        '<shadow type="sensing_touchingobjectmenu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sensing_touchingcolor" id="sensing_touchingcolor">' +
+      '<value name="COLOR">' +
+        '<shadow type="colour_picker"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sensing_coloristouchingcolor" id="sensing_coloristouchingcolor">' +
+      '<value name="COLOR">' +
+        '<shadow type="colour_picker"></shadow>' +
+      '</value>' +
+      '<value name="COLOR2">' +
+        '<shadow type="colour_picker"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sensing_distanceto" id="sensing_distanceto">' +
+      '<value name="DISTANCETOMENU">' +
+        '<shadow type="sensing_distancetomenu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sensing_keypressed" id="sensing_keypressed">' +
+        '<value name="KEY_OPTION">' +
+          '<shadow type="sensing_keyoptions"></shadow>' +
+        '</value>' +
+    '</block>' +
+    '<block type="sensing_mousedown" id="sensing_mousedown"></block>' +
+    '<block type="sensing_mousex" id="sensing_mousex"></block>' +
+    '<block type="sensing_mousey" id="sensing_mousey"></block>' +
+    '<block type="sensing_setdragmode" id="sensing_setdragmode"></block>' +
+    '<block type="sensing_loudness" id="sensing_loudness"></block>' +
+    '<block type="sensing_timer" id="sensing_timer"></block>' +
+    '<block type="sensing_resettimer" id="sensing_resettimer"></block>' +
+    '<block type="sensing_of" id="sensing_of">' +
+      '<value name="OBJECT">' +
+        '<shadow type="sensing_of_object_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="sensing_current" id="sensing_current"></block>' +
+    '<block type="sensing_dayssince2000" id="sensing_dayssince2000"></block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_OPERATORS}" id="operators" colour="#40BF4A" secondaryColour="#389438">' +
+    '<block type="operator_add" id="operator_add">' +
+      '<value name="NUM1">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="NUM2">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_subtract" id="operator_subtract">' +
+      '<value name="NUM1">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="NUM2">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_multiply" id="operator_multiply">' +
+      '<value name="NUM1">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="NUM2">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_divide" id="operator_divide">' +
+      '<value name="NUM1">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="NUM2">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_random" id="operator_random">' +
+      '<value name="FROM">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="TO">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">10</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_lt" id="operator_lt">' +
+      '<value name="OPERAND1">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="OPERAND2">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_equals" id="operator_equals">' +
+      '<value name="OPERAND1">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="OPERAND2">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_gt" id="operator_gt">' +
+      '<value name="OPERAND1">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="OPERAND2">' +
+        '<shadow type="text">' +
+          '<field name="TEXT"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_and" id="operator_and"></block>' +
+    '<block type="operator_or" id="operator_or"></block>' +
+    '<block type="operator_not" id="operator_not"></block>' +
+    '<block type="operator_join" id="operator_join">' +
+      '<value name="STRING1">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">hello</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="STRING2">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">world</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_letter_of" id="operator_letter_of">' +
+      '<value name="LETTER">' +
+        '<shadow type="math_whole_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="STRING">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">world</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_length" id="operator_length">' +
+      '<value name="STRING">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">world</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_contains" id="operator_contains">' +
+      '<value name="STRING1">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">hello</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="STRING2">' +
+        '<shadow type="text">' +
+          '<field name="TEXT">world</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_mod" id="operator_mod">' +
+      '<value name="NUM1">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="NUM2">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_round" id="operator_round">' +
+      '<value name="NUM">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="operator_mathop" id="operator_mathop">' +
+      '<value name="NUM">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM"></field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_VARIABLES}" id="variable" colour="#FF8C1A" secondaryColour="#DB6E00" custom="VARIABLE">' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_LISTS}" id="list" colour="#FF661A" secondaryColour="#FF5500" custom="LIST">' +
+  '</category>' +
+  '<category name="%{BKY_CATEGORY_MYBLOCKS}" id="more" colour="#FF6680" secondaryColour="#FF4D6A" custom="PROCEDURE">' +
+  '</category>' +
+  '<category name="Extensions" id="extensions" colour="#FF6680" secondaryColour="#FF4D6A" ' +
+    'iconURI="../media/extensions/wedo2-block-icon.svg" showStatusButton="true" ' +
+    'options="extensionControls">' +
+    '<block type="extension_pen_down" id="extension_pen_down"></block>' +
+    '<block type="extension_music_drum" id="extension_music_drum">' +
+      '<value name="NUMBER">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">1</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="extension_wedo_motor" id="extension_wedo_motor"></block>' +
+    '<block type="extension_wedo_hat" id="extension_wedo_hat"></block>' +
+    '<block type="extension_wedo_boolean" id="extension_wedo_boolean"></block>' +
+  '<block type="control_fieldbutton" id="control_fieldbutton"></block>' +
+  '<block type="control_fieldcheckboxoriginal" id="control_fieldcheckboxoriginal"></block>' +
+  '<block type="motion_mutatorCheckboxTest" id="motion_mutatorCheckboxTest"></block>' +
+    '<block type="operators_expandablejoininputs" id="extension_wedo_boolean"></block>' +
+    '<block type="extension_wedo_tilt_reporter" id="extension_wedo_reporter">' +
+      '<value name="TILT">' +
+        '<shadow type="extension_wedo_tilt_menu"></shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="extension_music_reporter" id="extension_music_reporter"></block>' +
+    '<block type="extension_microbit_display" id="extension_microbit_display">' +
+      '<value name="MATRIX">' +
+        '<shadow type="matrix">' +
+          '<field name="MATRIX">0101010101100010101000100</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="extension_music_play_note" id="extension_music_play_note">' +
+      '<value name="NOTE">' +
+        '<shadow type="note">' +
+          '<field name="NOTE">60</field>' +
+        '</shadow>' +
+      '</value>' +
+      '<value name="BEATS">' +
+        '<shadow type="math_number">' +
+          '<field name="NUM">0.25</field>' +
+        '</shadow>' +
+      '</value>' +
+    '</block>' +
+    '<block type="field_textdropdown_test" id="extension_wedo_boolean"></block>' +
+  '</category>' +
+  '</xml>';

blocks_vertical/event.js

@@ -0,0 +1,489 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.event');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+Blockly.Blocks['event_whentouchingobject'] = {
+  /**
+   * Block for when a sprite is touching an object.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_WHENTOUCHINGOBJECT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TOUCHINGOBJECTMENU"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_touchingobjectmenu'] = {
+  /**
+   * "Touching [Object]" Block Menu.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TOUCHINGOBJECTMENU",
+          "options": [
+            [Blockly.Msg.SENSING_TOUCHINGOBJECT_POINTER, '_mouse_'],
+            [Blockly.Msg.SENSING_TOUCHINGOBJECT_EDGE, '_edge_']
+          ]
+        }
+      ],
+      "extensions": ["colours_event", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenflagclicked'] = {
+  /**
+   * Block for when flag clicked.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenflagclicked",
+      "message0": Blockly.Msg.EVENT_WHENFLAGCLICKED,
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "blue-flag.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "flag"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenstopclicked'] = {
+  /**
+   * pm: Block for when stop button clicked.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenstopclicked",
+      "message0": "when %1 clicked",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "/icons/control_stop.svg",
+          "width": 24,
+          "height": 24,
+          "alt": "stop"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenthisspriteclicked'] = {
+  /**
+   * Block for when this sprite clicked.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_WHENTHISSPRITECLICKED,
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+
+};
+
+Blockly.Blocks['event_whenstageclicked'] = {
+  /**
+   * Block for when the stage is clicked.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_WHENSTAGECLICKED,
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenbroadcastreceived'] = {
+  /**
+   * Block for when broadcast received.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenbroadcastreceived",
+      "message0": Blockly.Msg.EVENT_WHENBROADCASTRECEIVED,
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "BROADCAST_OPTION",
+          "variableTypes": [Blockly.BROADCAST_MESSAGE_VARIABLE_TYPE],
+          "variable": Blockly.Msg.DEFAULT_BROADCAST_MESSAGE_NAME
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenbackdropswitchesto'] = {
+  /**
+   * Block for when the current backdrop switched to a selected backdrop.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_WHENBACKDROPSWITCHESTO,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "BACKDROP",
+          "options": [
+            ['backdrop1', 'BACKDROP1']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whengreaterthan'] = {
+  /**
+   * Block for when loudness/timer/video motion is greater than the value.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_WHENGREATERTHAN,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "WHENGREATERTHANMENU",
+          "options": [
+            [Blockly.Msg.EVENT_WHENGREATERTHAN_LOUDNESS, 'LOUDNESS'],
+            [Blockly.Msg.EVENT_WHENGREATERTHAN_TIMER, 'TIMER']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_broadcast_menu'] = {
+  /**
+   * Broadcast drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_variable",
+          "name": "BROADCAST_OPTION",
+          "variableTypes": [Blockly.BROADCAST_MESSAGE_VARIABLE_TYPE],
+          "variable": Blockly.Msg.DEFAULT_BROADCAST_MESSAGE_NAME
+        }
+      ],
+      "colour": Blockly.Colours.event.secondary,
+      "colourSecondary": Blockly.Colours.event.secondary,
+      "colourTertiary": Blockly.Colours.event.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['event_broadcast'] = {
+  /**
+   * Block to send a broadcast.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_broadcast",
+      "message0": Blockly.Msg.EVENT_BROADCAST,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "BROADCAST_INPUT"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['event_broadcastandwait'] = {
+  /**
+   * Block to send a broadcast.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.EVENT_BROADCASTANDWAIT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "BROADCAST_INPUT"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenkeypressed'] = {
+  /**
+   * Block to send a broadcast.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenkeypressed",
+      "message0": Blockly.Msg.EVENT_WHENKEYPRESSED,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "KEY_OPTION",
+          "options": [
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_SPACE, 'space'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_UP, 'up arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_DOWN, 'down arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_RIGHT, 'right arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_LEFT, 'left arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_ANY, 'any'],
+            ['a', 'a'],
+            ['b', 'b'],
+            ['c', 'c'],
+            ['d', 'd'],
+            ['e', 'e'],
+            ['f', 'f'],
+            ['g', 'g'],
+            ['h', 'h'],
+            ['i', 'i'],
+            ['j', 'j'],
+            ['k', 'k'],
+            ['l', 'l'],
+            ['m', 'm'],
+            ['n', 'n'],
+            ['o', 'o'],
+            ['p', 'p'],
+            ['q', 'q'],
+            ['r', 'r'],
+            ['s', 's'],
+            ['t', 't'],
+            ['u', 'u'],
+            ['v', 'v'],
+            ['w', 'w'],
+            ['x', 'x'],
+            ['y', 'y'],
+            ['z', 'z'],
+            ['0', '0'],
+            ['1', '1'],
+            ['2', '2'],
+            ['3', '3'],
+            ['4', '4'],
+            ['5', '5'],
+            ['6', '6'],
+            ['7', '7'],
+            ['8', '8'],
+            ['9', '9']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenkeyhit'] = {
+  /**
+   * Block to send a broadcast.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenkeyhit",
+      "message0": "when %1 key hit",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "KEY_OPTION",
+          "options": [
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_SPACE, 'space'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_UP, 'up arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_DOWN, 'down arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_RIGHT, 'right arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_LEFT, 'left arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_ANY, 'any'],
+            ['a', 'a'],
+            ['b', 'b'],
+            ['c', 'c'],
+            ['d', 'd'],
+            ['e', 'e'],
+            ['f', 'f'],
+            ['g', 'g'],
+            ['h', 'h'],
+            ['i', 'i'],
+            ['j', 'j'],
+            ['k', 'k'],
+            ['l', 'l'],
+            ['m', 'm'],
+            ['n', 'n'],
+            ['o', 'o'],
+            ['p', 'p'],
+            ['q', 'q'],
+            ['r', 'r'],
+            ['s', 's'],
+            ['t', 't'],
+            ['u', 'u'],
+            ['v', 'v'],
+            ['w', 'w'],
+            ['x', 'x'],
+            ['y', 'y'],
+            ['z', 'z'],
+            ['0', '0'],
+            ['1', '1'],
+            ['2', '2'],
+            ['3', '3'],
+            ['4', '4'],
+            ['5', '5'],
+            ['6', '6'],
+            ['7', '7'],
+            ['8', '8'],
+            ['9', '9']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks['event_whenmousescrolled'] = {
+  /**
+   * pm: Block to send a broadcast when the mouse is scrolled in a direction.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "id": "event_whenmousescrolled",
+      "message0": "when mouse is scrolled %1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "KEY_OPTION",
+          "options": [
+            ['up', 'up'],
+            ['down', 'down']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks["event_always"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "always",
+      "args0": [],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks["event_whenanything"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "when %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ANYTHING",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};
+
+Blockly.Blocks["event_whenjavascript"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "when javascript %1 === true",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "JS"
+        }
+      ],
+      "category": Blockly.Categories.event,
+      "extensions": ["colours_event", "shape_hat"]
+    });
+  }
+};

blocks_vertical/extensions.js

@@ -0,0 +1,294 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.extensions');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+Blockly.Blocks['extension_pen_down'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 pen down",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/pen-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "shape_statement", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_music_drum'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 play drum %3",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/music-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        },
+        {
+          "type": "input_value",
+          "name": "NUMBER"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "shape_statement", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_wedo_motor'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 turn a motor %3",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/wedo2-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        },
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "rotate-right.svg",
+          "width": 24,
+          "height": 24
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "shape_statement", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_wedo_hat'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 when I am wearing a hat",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/wedo2-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "shape_hat", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_wedo_boolean'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 O RLY?",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/wedo2-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "output_boolean", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_wedo_tilt_reporter'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 tilt angle %3",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/wedo2-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        },
+        {
+          "type": "input_value",
+          "name": "TILT"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "output_number", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_wedo_tilt_menu'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TILT",
+          "options": [
+            ['Any', 'Any'],
+            ['Whirl', 'Whirl'],
+            ['South', 'South'],
+            ['Back in time', 'Back in time']
+          ]
+        }
+      ],
+      "extensions": ["colours_more", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_music_reporter'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 hey now, you're an all-star",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/music-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        }
+      ],
+      "category": Blockly.Categories.more,
+      "extensions": ["colours_more", "output_number", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_microbit_display'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 display %3",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/microbit-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        },
+        {
+          "type": "input_value",
+          "name": "MATRIX"
+        },
+      ],
+      "category": Blockly.Categories.pen,
+      "extensions": ["colours_pen", "shape_statement", "scratch_extension"]
+    });
+  }
+};
+
+Blockly.Blocks['extension_music_play_note'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 %2 play note %3 for %4 beats",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "extensions/music-block-icon.svg",
+          "width": 40,
+          "height": 40
+        },
+        {
+          "type": "field_vertical_separator"
+        },
+        {
+          "type": "input_value",
+          "name": "NOTE"
+        },
+        {
+          "type": "input_value",
+          "name": "BEATS"
+        }
+      ],
+      "category": Blockly.Categories.pen,
+      "extensions": ["colours_pen", "shape_statement", "scratch_extension"]
+    });
+  }
+};

blocks_vertical/live_tests.js

@@ -0,0 +1,419 @@
+'use strict';
+
+goog.provide('Blockly.Blocks.liveTests');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+Blockly.Blocks['sensing_set_of'] = {
+  /**
+   * Block to report properties of sprites.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": 'set %1 of %2 to %3',
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "PROPERTY",
+          "options": [
+            [Blockly.Msg.SENSING_OF_XPOSITION, 'x position'],
+            [Blockly.Msg.SENSING_OF_YPOSITION, 'y position'],
+            [Blockly.Msg.SENSING_OF_DIRECTION, 'direction'],
+            [Blockly.Msg.SENSING_OF_COSTUMENUMBER, 'costume #'],
+            [Blockly.Msg.SENSING_OF_COSTUMENAME, 'costume name'],
+            [Blockly.Msg.SENSING_OF_SIZE, 'size'],
+            [Blockly.Msg.SENSING_OF_VOLUME, 'volume'],
+            [Blockly.Msg.SENSING_OF_BACKDROPNUMBER, 'backdrop #'],
+            [Blockly.Msg.SENSING_OF_BACKDROPNAME, 'backdrop name']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "OBJECT"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_setVertTransform'] = {
+  /**
+   * Block to report properties of sprites.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": 'skew sprite vertically %1 %',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "PERCENT"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_setHorizTransform'] = {
+  /**
+   * Block to report properties of sprites.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": 'skew sprite horizontally %1 %',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "PERCENT"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['field_textdropdown_test'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_textdropdown",
+          "name": "TEXT",
+          "options": [
+            ['item1', 'item1'],
+            ['item2', 'item2'],
+            ['item3', 'item3']
+          ]
+        }
+      ],
+      "output": "String",
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField
+    })
+  }
+}
+
+Blockly.Blocks['motion_mutatorCheckboxTest_checkboxMutatorMenu'] = {
+  init: function () {
+    this.setInputsInline(false);
+    this.setColour("#c1c1c1");
+  }
+};
+Blockly.Blocks['motion_mutatorCheckboxTest'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'checkbox mutator',
+      "args0": [],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+    this.setMutator(new Blockly.Mutator([]));
+
+    this.BORDER_FIELDS = ["ABC", "DEF"];
+    this.FIELD_NAMES = ["first", "second"];
+
+    this.inputs_ = [false, false];
+  },
+
+  mutationToDom: function () {
+    // console.log('mutationToDom', this.inputs_);
+    if (!this.inputs_) {
+      return null;
+    }
+    const container = document.createElement("mutation");
+    for (let i = 0; i < this.inputs_.length; i++) {
+      if (this.inputs_[i]) {
+        container.setAttribute(this.BORDER_FIELDS[i], this.inputs_[i]);
+      }
+    }
+    return container;
+  },
+
+  domToMutation: function (xmlElement) {
+    for (let i = 0; i < this.inputs_.length; i++) {
+      this.inputs_[i] = xmlElement.getAttribute(this.BORDER_FIELDS[i].toLowerCase()) == "true";
+    }
+    // console.log('domToMutation', this.inputs_);
+    this.updateShape_();
+  },
+
+  decompose: function (workspace) {
+    // console.log('decompose');
+    const containerBlock = workspace.newBlock('motion_mutatorCheckboxTest_checkboxMutatorMenu');
+    for (let i = 0; i < this.inputs_.length; i++) {
+      // BaseBlockly.Msg[this.BORDER_FIELDS[i]] = this.FIELD_NAMES[i];
+      containerBlock.appendDummyInput()
+        // .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(this.FIELD_NAMES[i])
+        .appendField(new Blockly.FieldCheckboxOriginal(this.inputs_[i] ? "TRUE" : "FALSE"), this.BORDER_FIELDS[i].toUpperCase());
+    }
+    containerBlock.initSvg();
+    containerBlock.moveBy(4, 22);
+    return containerBlock;
+  },
+
+  compose: function (containerBlock) {
+    // console.log('compose');
+    // Set states
+    for (let i = 0; i < this.inputs_.length; i++) {
+      const field = this.BORDER_FIELDS[i].toUpperCase();
+      const value = containerBlock.getFieldValue(field);
+      // console.log(value);
+      this.inputs_[i] = value == "TRUE";
+    }
+    this.updateShape_();
+  },
+
+  updateShape_: function () {
+    // console.log('updateShape_');
+    for (let i = 0; i < this.inputs_.length; i++) {
+      if ((!this.inputs_[i]) && (this.getInput(this.BORDER_FIELDS[i].toUpperCase()))) {
+        this.removeInput(this.BORDER_FIELDS[i].toUpperCase());
+      }
+    }
+    for (let i = 0; i < this.inputs_.length; i++) {
+      if ((this.inputs_[i]) && (!(this.getInput(this.BORDER_FIELDS[i].toUpperCase())))) {
+        // BaseBlockly.Msg[this.BORDER_FIELDS[i]] = this.FIELD_NAMES[i];
+        this.appendValueInput(this.BORDER_FIELDS[i].toUpperCase())
+          // .setAlign(Blockly.ALIGN_RIGHT)
+          // todo: insert string/number input?
+          .appendField(this.FIELD_NAMES[i]);
+      }
+    }
+  }
+};
+
+Blockly.Blocks['control_fieldbutton'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'button %1',
+      "args0": [
+        {
+          "type": "field_button",
+          "name": "BUTTON",
+          "label": "alert",
+          "opcode": "alert"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  },
+
+  onFieldButtonClicked_: function (opcode) {
+    if (opcode === "alert") {
+      alert('wow');
+    } else if (opcode === "flaberghasted") {
+      alert(':rivflabbergasted:')
+    }
+  }
+};
+
+Blockly.Blocks['control_fieldcheckboxoriginal'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'mm checkbox %1 gagag %2',
+      "args0": [
+        {
+          "type": "field_checkbox_original",
+          "name": "BUTTON"
+        },
+        {
+          "type": "field_checkbox_original",
+          "name": "BUTT2ON"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_testcolorfieldoriginal'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'color %1',
+      "args0": [
+        {
+          "type": "field_colour",
+          "colour": "#ff0000",
+          "name": "COLOR"
+        }
+      ],
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_blockduplicatesondrag'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'duplicate',
+      "category": Blockly.Categories.control,
+      "canDragDuplicate": true,
+      "extensions": ["colours_control", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['control_dualblock'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'dual block',
+      "category": Blockly.Categories.control,
+      "extensions": ["colours_control", "shape_statement", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['operators_expandablejoininputs'] = {
+  /**
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'join %1 %2',
+      "args0": [
+        {
+          "type": "field_expandable_remove",
+          "name": "REMOVE"
+        },
+        {
+          "type": "field_expandable_add",
+          "name": "ADD"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+
+    this.inputs_ = 0;
+    // this.lastMutation_ = null;
+  },
+
+  mutationToDom: function () {
+    // on save
+    // console.log('mutationToDom');
+    const container = document.createElement("mutation");
+    let number = Number(this.inputs_);
+    if (isNaN(number)) number = 0;
+    container.setAttribute("INPUTCOUNT", String(number));
+    // console.log(this.inputs_);
+    return container;
+  },
+
+  domToMutation: function (xmlElement) {
+    // on load
+    // console.log('domToMutation');
+    // console.log(xmlElement.getAttribute("INPUTCOUNT"));
+    const inputCount = Number(xmlElement.getAttribute("INPUTCOUNT"));
+    // console.log(inputCount);
+    this.inputs_ = isNaN(inputCount) ? 0 : inputCount;
+    // console.log(this.inputs_);
+    for (let i = 0; i < this.inputs_; i++) {
+      this.appendValueInput(`INPUT${i + 1}`);
+    }
+  },
+
+  saveExtraState: function() {
+    let number = Number(this.inputs_);
+    if (isNaN(number)) number = 0;
+    return {inputs: number}
+  },
+
+  loadExtraState: function(state) {
+    this.inputs_ = isNaN(state.inputs) ? 0 : state.inputs;
+    for (let i = 0; i < this.inputs_; i++) {
+      this.appendValueInput(`INPUT${i + 1}`);
+    }
+  },
+
+  // updateShape_: function () {
+  //   this.lastMutation_ = this.mutationToDom();
+  //   console.log('updateShape_');
+  //   console.log(this.inputs_);
+  //   for (let i = 0; i < this.inputs_; i++) {
+  //     this.appendValueInput(`INPUT${i + 1}`);
+  //   }
+  //   this.updateIfNeeded_();
+  // },
+  // updateIfNeeded_: function () {
+  //   this.initSvg();
+  //   if (this.rendered) {
+  //     this.render();
+  //   }
+  //   // manually update because idk why
+  //   Blockly.Events.setGroup(true);
+  //   var oldMutation = Blockly.Xml.domToText(this.lastMutation_);
+  //   var newMutation = Blockly.Xml.domToText(this.mutationToDom());
+  //   Blockly.Events.fire(new Blockly.Events.BlockChange(this,
+  //     'mutation', null, oldMutation, newMutation));
+  //   Blockly.Events.setGroup(false);
+  // },
+
+  onExpandableButtonClicked_: function (isAdding) {
+    // Create an event group to keep field value and mutator in sync
+    // Return null at the end because setValue is called here already.
+    Blockly.Events.setGroup(true);
+    var oldMutation = Blockly.Xml.domToText(this.mutationToDom());
+    if (!isAdding) {
+      const number = this.inputs_;
+      this.removeInput(`INPUT${number}`);
+      this.inputs_--;
+      if (this.inputs_ < 0) {
+        this.inputs_ = 0;
+      }
+      // console.log(this.inputs_);
+      // this.updateIfNeeded_();
+    } else {
+      this.inputs_++;
+      const number = this.inputs_;
+      this.appendValueInput(`INPUT${number}`);
+      // console.log(this.inputs_);
+      // this.updateIfNeeded_();
+    }
+    this.initSvg();
+    if (this.rendered) {
+      this.render();
+    }
+    var newMutation = Blockly.Xml.domToText(this.mutationToDom());
+    Blockly.Events.fire(new Blockly.Events.BlockChange(this,
+      'mutation', null, oldMutation, newMutation));
+    Blockly.Events.setGroup(false);
+  }
+};

blocks_vertical/looks.js

@@ -0,0 +1,1158 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.looks');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['looks_sayforsecs'] = {
+  /**
+   * Block to say for some time.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SAYFORSECS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "MESSAGE"
+        },
+        {
+          "type": "input_value",
+          "name": "SECS"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_say'] = {
+  /**
+   * Block to say.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SAY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "MESSAGE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_thinkforsecs'] = {
+  /**
+   * Block to think for some time.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_THINKFORSECS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "MESSAGE"
+        },
+        {
+          "type": "input_value",
+          "name": "SECS"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_think'] = {
+  /**
+   * Block to think.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_THINK,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "MESSAGE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_setFont"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline":true,
+      "args0":[
+        {
+          "type":"input_value",
+          "name":"font"
+        },
+        {
+          "type":"input_value",
+          "name":"size"
+        }
+      ],
+      "message0":"set font to %1 with font size %2",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_setColor"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline":true,
+      "args0":[
+        {
+          "type":"field_dropdown",
+          "name":"prop",
+          "options":[
+            ["border","BUBBLE_STROKE"],
+            ["fill","BUBBLE_FILL"],
+            ["text","TEXT_FILL"]
+          ]
+        },
+        {
+          "type":"input_value",
+          "name":"color"
+        }
+      ],
+      "message0":"set %1 color to %2",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_setShape"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline":true,
+      "args0":[
+        {
+          "type":"field_dropdown",
+          "name":"prop",
+          "options":[
+            ["minimum width","MIN_WIDTH"],
+            ["maximum width","MAX_LINE_WIDTH"],
+            ["border line width","STROKE_WIDTH"],
+            ["padding size","PADDING"],
+            ["corner radius","CORNER_RADIUS"],
+            ["tail height","TAIL_HEIGHT"],
+            ["font pading percent","FONT_HEIGHT_RATIO"],
+            ["text length limit","texlim"]
+          ]
+        },
+        {
+          "type":"input_value",
+          "name":"color"
+        }
+      ],
+      "message0":"set text bubble %1 to %2",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_show'] = {
+  /**
+   * Show block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SHOW,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_hide'] = {
+  /**
+   * Hide block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_HIDE,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+
+Blockly.Blocks['looks_changeVisibilityOfSprite_menu'] = {
+  /**
+   * pm: changeVisibilityOfSprite drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "VISIBLE_OPTION",
+          "options": [
+            ["myself", '_myself_']
+          ]
+        }
+      ],
+      "extensions": ["colours_looks", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changeVisibilityOfSprite'] = {
+  /**
+   * pm: changeVisibilityOfSprite block.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 %2",
+      "inputsInline": true,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "VISIBLE_TYPE",
+          "options": [
+            ["show", "show"],
+            ["hide", "hide"]
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VISIBLE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changeVisibilityOfSpriteShow'] = {
+  /**
+   * pm: changeVisibilityOfSprite block.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "show %1",
+      "inputsInline": true,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VISIBLE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changeVisibilityOfSpriteHide'] = {
+  /**
+   * pm: changeVisibilityOfSprite block.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "hide %1",
+      "inputsInline": true,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VISIBLE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_hideallsprites'] = {
+  /**
+   * Hide-all-sprites block. Does not actually do anything. This is an
+   * obsolete block that is implemented for compatibility with Scratch 2.0
+   * projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_HIDEALLSPRITES,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_setTintColor"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "args0":[
+        {
+          "type":"input_value",
+          "name":"color"
+        }
+      ],
+      "message0":"set tint color to %1",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+Blockly.Blocks['looks_tintColor'] = {
+  /**
+   * pm: Block to report the tint color effect in hex code
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "tint color",
+      "category": Blockly.Categories.looks,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_looks", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changeeffectby'] = {
+  /**
+   * Block to change graphic effect.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_CHANGEEFFECTBY,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.LOOKS_EFFECT_COLOR, 'COLOR'],
+            [Blockly.Msg.LOOKS_EFFECT_FISHEYE, 'FISHEYE'],
+            [Blockly.Msg.LOOKS_EFFECT_WHIRL, 'WHIRL'],
+            [Blockly.Msg.LOOKS_EFFECT_PIXELATE, 'PIXELATE'],
+            [Blockly.Msg.LOOKS_EFFECT_MOSAIC, 'MOSAIC'],
+            [Blockly.Msg.LOOKS_EFFECT_BRIGHTNESS, 'BRIGHTNESS'],
+            [Blockly.Msg.LOOKS_EFFECT_GHOST, 'GHOST'],
+            ["saturation", 'SATURATION'],
+            ["red", 'RED'],
+            ["green", 'GREEN'],
+            ["blue", 'BLUE'],
+            ["opaque", 'OPAQUE']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "CHANGE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_seteffectto'] = {
+  /**
+   * Block to set graphic effect.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SETEFFECTTO,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.LOOKS_EFFECT_COLOR, 'COLOR'],
+            [Blockly.Msg.LOOKS_EFFECT_FISHEYE, 'FISHEYE'],
+            [Blockly.Msg.LOOKS_EFFECT_WHIRL, 'WHIRL'],
+            [Blockly.Msg.LOOKS_EFFECT_PIXELATE, 'PIXELATE'],
+            [Blockly.Msg.LOOKS_EFFECT_MOSAIC, 'MOSAIC'],
+            [Blockly.Msg.LOOKS_EFFECT_BRIGHTNESS, 'BRIGHTNESS'],
+            [Blockly.Msg.LOOKS_EFFECT_GHOST, 'GHOST'],
+            ["saturation", 'SATURATION'],
+            ["red", 'RED'],
+            ["green", 'GREEN'],
+            ["blue", 'BLUE'],
+            ["opaque", 'OPAQUE']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_cleargraphiceffects'] = {
+  /**
+   * Block to clear graphic effects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_CLEARGRAPHICEFFECTS,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changesizeby'] = {
+  /**
+   * Block to change size
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_CHANGESIZEBY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CHANGE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_setsizeto'] = {
+  /**
+   * Block to set size
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SETSIZETO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SIZE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_size'] = {
+  /**
+   * Block to report size
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SIZE,
+      "category": Blockly.Categories.looks,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_looks", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_changestretchby'] = {
+  /**
+   * Block to change stretch. Does not actually do anything. This is an
+   * obsolete block that is implemented for compatibility with Scratch 1.4
+   * projects as well as 2.0 projects that still have the block.
+   * The "stretch" blocks were introduced in very early versions of Scratch,
+   * but their functionality was removed shortly later. They still appeared
+   * correctly up until (and including) Scratch 1.4 - as "change stretch by"
+   * and "set stretch to" - but were removed altogether in Scratch 2.0, and
+   * displayed as red "undefined" blocks. Some Scratch projects still contain
+   * these blocks, however, and they don't open in 3.0 unless the blocks
+   * actually exist (though they still don't funcitonally do anything).
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_CHANGESTRETCHBY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "CHANGE"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_setstretchto'] = {
+  /**
+   * Block to set stretch. Does not actually do anything. This is an obsolete
+   * block that is implemented for compatibility with Scratch 1.4 projects
+   * (see looks_changestretchby).
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SETSTRETCHTO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STRETCH"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_costume'] = {
+  /**
+   * Costumes drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "COSTUME",
+          "options": [
+            ['costume1', 'COSTUME1'],
+            ['costume2', 'COSTUME2']
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.looks.secondary,
+      "colourSecondary": Blockly.Colours.looks.secondary,
+      "colourTertiary": Blockly.Colours.looks.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_switchcostumeto'] = {
+  /**
+   * Block to switch the sprite's costume to the selected one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SWITCHCOSTUMETO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "COSTUME"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_nextcostume'] = {
+  /**
+   * Block to switch the sprite's costume to the next one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_NEXTCOSTUME,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_previouscostume'] = {
+  /**
+   * pm: Block to switch the sprite's costume to the previous one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "previous costume",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_switchbackdropto'] = {
+  /**
+   * Block to switch the backdrop to the selected one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SWITCHBACKDROPTO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "BACKDROP"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_backdrops'] = {
+  /**
+   * Backdrop list
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "id": "looks_backdrops",
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "BACKDROP",
+          "options": [
+            ['backdrop1', 'BACKDROP1']
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.looks.secondary,
+      "colourSecondary": Blockly.Colours.looks.secondary,
+      "colourTertiary": Blockly.Colours.looks.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_gotofrontback'] = {
+  /**
+   * "Go to front/back" Block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_GOTOFRONTBACK,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "FRONT_BACK",
+          "options": [
+            [Blockly.Msg.LOOKS_GOTOFRONTBACK_FRONT, 'front'],
+            [Blockly.Msg.LOOKS_GOTOFRONTBACK_BACK, 'back']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_goforwardbackwardlayers'] = {
+  /**
+   * "Go forward/backward [Number] Layers" Block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_GOFORWARDBACKWARDLAYERS,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "FORWARD_BACKWARD",
+          "options": [
+            [Blockly.Msg.LOOKS_GOFORWARDBACKWARDLAYERS_FORWARD, 'forward'],
+            [Blockly.Msg.LOOKS_GOFORWARDBACKWARDLAYERS_BACKWARD, 'backward']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "NUM"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_goTargetLayer'] = {
+  /**
+   * "Go infront/behind [sprite]" Block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "go %1 %2",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "FORWARD_BACKWARD",
+          "options": [
+            ['infront', 'infront'],
+            ['behind', 'behind']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VISIBLE_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_layersSetLayer"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "go to layer %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM"
+        }
+      ],
+      "extensions": [
+        "shape_statement",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_layersGetLayer"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "layer",
+      "checkboxInFlyout": true,
+      "extensions": [
+        "output_number",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks['looks_backdropnumbername'] = {
+  /**
+   * Block to report backdrop's number or name
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_BACKDROPNUMBERNAME,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "NUMBER_NAME",
+          "options": [
+            [Blockly.Msg.LOOKS_NUMBERNAME_NUMBER, 'number'],
+            [Blockly.Msg.LOOKS_NUMBERNAME_NAME, 'name']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_looks", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_costumenumbername'] = {
+  /**
+   * Block to report costume's number or name
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_COSTUMENUMBERNAME,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "NUMBER_NAME",
+          "options": [
+            [Blockly.Msg.LOOKS_NUMBERNAME_NUMBER, 'number'],
+            [Blockly.Msg.LOOKS_NUMBERNAME_NAME, 'name']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_looks", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_switchbackdroptoandwait'] = {
+  /**
+   * Block to switch the backdrop to the selected one and wait.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_SWITCHBACKDROPTOANDWAIT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "BACKDROP"
+        }
+      ],
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_nextbackdrop'] = {
+  /**
+   * Block to switch the backdrop to the next one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.LOOKS_NEXTBACKDROP_BLOCK,
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_previousbackdrop'] = {
+  /**
+   * pm: Block to switch the backdrop to the previous one.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "previous backdrop",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_setStretch"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "message0": "set stretch to x: %1 y: %2",
+      "extensions": [
+        "shape_statement",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_changeStretch"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "message0": "change stretch by x: %1 y: %2",
+      "extensions": [
+        "shape_statement",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_stretchGetX"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "checkboxInFlyout": true,
+      "category": "looks",
+      "message0": "x stretch",
+      "extensions": [
+        "output_string",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_stretchGetY"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "checkboxInFlyout": true,
+      "category": "looks",
+      "message0": "y stretch",
+      "extensions": [
+        "output_string",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_getSpriteVisible"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "visible?",
+      "checkboxInFlyout": true,
+      "extensions": [
+        "output_boolean",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks['looks_getOtherSpriteVisible_menu'] = {
+  /**
+   * pm: Sprite-visible drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "VISIBLE_OPTION",
+          "options": [
+            ["myself", '_myself_']
+          ]
+        }
+      ],
+      "extensions": ["colours_looks", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["looks_getOtherSpriteVisible"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "is %1 visible?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VISIBLE_OPTION"
+        }
+      ],
+      "extensions": [
+        "output_boolean",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_getEffectValue"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "%1 effect",
+      "checkboxInFlyout": true,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.LOOKS_EFFECT_COLOR, 'COLOR'],
+            [Blockly.Msg.LOOKS_EFFECT_FISHEYE, 'FISHEYE'],
+            [Blockly.Msg.LOOKS_EFFECT_WHIRL, 'WHIRL'],
+            [Blockly.Msg.LOOKS_EFFECT_PIXELATE, 'PIXELATE'],
+            [Blockly.Msg.LOOKS_EFFECT_MOSAIC, 'MOSAIC'],
+            [Blockly.Msg.LOOKS_EFFECT_BRIGHTNESS, 'BRIGHTNESS'],
+            [Blockly.Msg.LOOKS_EFFECT_GHOST, 'GHOST'],
+            ["saturation", 'SATURATION'],
+            ["red", 'RED'],
+            ["green", 'GREEN'],
+            ["blue", 'BLUE'],
+            ["opaque", 'OPAQUE']
+          ]
+        }
+      ],
+      "extensions": [
+        "output_number",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_sayHeight"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "bubble height",
+      "checkboxInFlyout": true,
+      "extensions": [
+        "output_string",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks["looks_sayWidth"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": "looks",
+      "message0": "bubble width",
+      "checkboxInFlyout": true,
+      "extensions": [
+        "output_string",
+        "colours_looks"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks['looks_stoptalking'] = {
+  /**
+   * pm: Block to stop talking/thinking.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "stop speaking",
+      "category": Blockly.Categories.looks,
+      "extensions": ["colours_looks", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_getinputofcostume'] = {
+  /**
+   * pm: Block to report an attribute on a costume
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 of %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INPUT"
+        },
+        {
+          "type": "input_value",
+          "name": "COSTUME"
+        },
+      ],
+      "category": Blockly.Categories.looks,
+      "inputsInline": true,
+      "extensions": ["colours_looks", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['looks_getinput_menu'] = {
+  /**
+   * pm: List of options for the first input of looks_getinputofcostume.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "INPUT",
+          "options": [
+            ['width', 'width'],
+            ['height', 'height'],
+            ['rotation center x', 'rotation center x'],
+            ['rotation center y', 'rotation center y'],
+            ['drawing mode', 'drawing mode']
+          ]
+        }
+      ],
+      "extensions": ["colours_looks", "output_string"]
+    });
+  }
+};

blocks_vertical/motion.js

@@ -0,0 +1,887 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.motion');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['motion_movesteps'] = {
+  /**
+   * Block to move steps.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_MOVESTEPS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STEPS"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_movebacksteps'] = {
+  /**
+   * pm: Block to move back steps.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "move back %1 steps",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STEPS"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_moveupdownsteps'] = {
+  /**
+   * pm: Block to move up or down steps.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "move %1 %2 steps",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "DIRECTION",
+          "options": [
+            ['up', 'up'],
+            ['down', 'down']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "STEPS"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_turnright'] = {
+  /**
+   * Block to turn right.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_TURNRIGHT,
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "rotate-right.svg",
+          "width": 24,
+          "height": 24
+        },
+        {
+          "type": "input_value",
+          "name": "DEGREES"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_turnleft'] = {
+  /**
+   * Block to turn left.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_TURNLEFT,
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "rotate-left.svg",
+          "width": 24,
+          "height": 24
+        },
+        {
+          "type": "input_value",
+          "name": "DEGREES"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_turnrightaroundxy'] = {
+  /**
+   * pm: Block to turn right around a certain point.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "turn %1 %2 degrees around x: %3 y: %4",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "rotate-right.svg",
+          "width": 24,
+          "height": 24
+        },
+        {
+          "type": "input_value",
+          "name": "DEGREES"
+        },
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_turnleftaroundxy'] = {
+  /**
+   * pm: Block to turn left around a certain point.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "turn %1 %2 degrees around x: %3 y: %4",
+      "args0": [
+        {
+          "type": "field_image",
+          "src": Blockly.mainWorkspace.options.pathToMedia + "rotate-left.svg",
+          "width": 24,
+          "height": 24
+        },
+        {
+          "type": "input_value",
+          "name": "DEGREES"
+        },
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_pointindirection'] = {
+  /**
+   * Block to point in direction.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_POINTINDIRECTION,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DIRECTION"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_pointtowards_menu'] = {
+  /**
+   * Point towards drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TOWARDS",
+          "options": [
+            [Blockly.Msg.MOTION_POINTTOWARDS_POINTER, '_mouse_'],
+            [Blockly.Msg.MOTION_POINTTOWARDS_RANDOM, '_random_']
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.motion.secondary,
+      "colourSecondary": Blockly.Colours.motion.secondary,
+      "colourTertiary": Blockly.Colours.motion.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_turnaround'] = {
+  /**
+   * pm: Block to point in the opposite direction.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "turn around",
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_pointinrandomdirection'] = {
+  /**
+   * pm: Block to point in a random direction.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "point in random direction",
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_pointtowardsxy'] = {
+  /**
+   * pm: Block to point towards an x and y position.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "point towards x: %1 y: %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_pointtowards'] = {
+  /**
+   * Block to point in direction.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_POINTTOWARDS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TOWARDS"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_goto_menu'] = {
+  /**
+   * Go to drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TO",
+          "options": [
+            [Blockly.Msg.MOTION_GOTO_POINTER, '_mouse_'],
+            [Blockly.Msg.MOTION_GOTO_RANDOM, '_random_']
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.motion.secondary,
+      "colourSecondary": Blockly.Colours.motion.secondary,
+      "colourTertiary": Blockly.Colours.motion.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_gotoxy'] = {
+  /**
+   * Block to go to X, Y.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_GOTOXY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_goto'] = {
+  /**
+   * Block to go to a menu item.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_GOTO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TO"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_glidesecstoxy'] = {
+  /**
+   * Block to glide for a specified time.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_GLIDESECSTOXY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SECS"
+        },
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_glidedirectionstepsinseconds'] = {
+  /**
+   * pm: Block to glide for a specified time in a specified direction.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "glide %1 steps %2 in %3 secs",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STEPS"
+        },
+        {
+          "type": "field_dropdown",
+          "name": "DIRECTION",
+          "options": [
+            ['forwards', 'forwards'],
+            ['backwards', 'backwards'],
+            ['up', 'up'],
+            ['down', 'down']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "SECS"
+        },
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_glideto_menu'] = {
+  /**
+   * Glide to drop-down menu
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TO",
+          "options": [
+            [Blockly.Msg.MOTION_GLIDETO_POINTER, '_mouse_'],
+            [Blockly.Msg.MOTION_GLIDETO_RANDOM, '_random_']
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.motion.secondary,
+      "colourSecondary": Blockly.Colours.motion.secondary,
+      "colourTertiary": Blockly.Colours.motion.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_glideto'] = {
+  /**
+   * Block to glide to a menu item
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_GLIDETO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SECS"
+        },
+        {
+          "type": "input_value",
+          "name": "TO"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_changebyxy'] = {
+  /**
+   * pm: Block to change X and Y at the same time.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "change by x: %1 y: %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DX"
+        },
+        {
+          "type": "input_value",
+          "name": "DY"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_changexby'] = {
+  /**
+   * Block to change X.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_CHANGEXBY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DX"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_setx'] = {
+  /**
+   * Block to set X.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_SETX,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_changeyby'] = {
+  /**
+   * Block to change Y.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_CHANGEYBY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DY"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_sety'] = {
+  /**
+   * Block to set Y.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_SETY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_ifonedgebounce'] = {
+  /**
+   * Block to bounce on edge.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_IFONEDGEBOUNCE,
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_ifonspritebounce'] = {
+  /**
+   * pm: Block to bounce on a sprite.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "if touching %1, bounce",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SPRITE"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_ifonxybounce'] = {
+  /**
+   * pm: Block to bounce on x and y.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "if touching x: %1 y: %2, bounce",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "X"
+        },
+        {
+          "type": "input_value",
+          "name": "Y"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_setrotationstyle'] = {
+  /**
+   * Block to set rotation style.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_SETROTATIONSTYLE,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "STYLE",
+          "options": [
+            [Blockly.Msg.MOTION_SETROTATIONSTYLE_LEFTRIGHT, 'left-right'],
+            ['up-down', 'up-down'],
+            ['look at', 'look at'],
+            [Blockly.Msg.MOTION_SETROTATIONSTYLE_DONTROTATE, 'don\'t rotate'],
+            [Blockly.Msg.MOTION_SETROTATIONSTYLE_ALLAROUND, 'all around']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_xposition'] = {
+  /**
+   * Block to report X.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_XPOSITION,
+      "category": Blockly.Categories.motion,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_motion", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_yposition'] = {
+  /**
+   * Block to report Y.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_YPOSITION,
+      "category": Blockly.Categories.motion,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_motion", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_direction'] = {
+  /**
+   * Block to report direction.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_DIRECTION,
+      "category": Blockly.Categories.motion,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_motion", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_scroll_right'] = {
+  /**
+   * Block to scroll the stage right. Does not actually do anything. This is
+   * an obsolete block that is implemented for compatibility with Scratch 2.0
+   * projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_SCROLLRIGHT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DISTANCE"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_scroll_up'] = {
+  /**
+   * Block to scroll the stage up. Does not actually do anything. This is an
+   * obsolete block that is implemented for compatibility with Scratch 2.0
+   * projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_SCROLLUP,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DISTANCE"
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_move_sprite_to_scene_side'] = {
+  /**
+   * pm: Block to move the sprite to the stage's side.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "move to stage %1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "ALIGNMENT",
+          "options": [
+            [Blockly.Msg.MOTION_ALIGNSCENE_BOTTOMLEFT, 'bottom-left'],
+            ['bottom', 'bottom'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_BOTTOMRIGHT, 'bottom-right'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_MIDDLE, 'middle'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_TOPLEFT, 'top-left'],
+            ['top', 'top'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_TOPRIGHT, 'top-right'],
+            ['left', 'left'],
+            ['right', 'right'],
+          ]
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_align_scene'] = {
+  /**
+   * Block to change the stage's scrolling alignment. Does not actually do
+   * anything. This is an obsolete block that is implemented for compatibility
+   * with Scratch 2.0 projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_ALIGNSCENE,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "ALIGNMENT",
+          "options": [
+            [Blockly.Msg.MOTION_ALIGNSCENE_BOTTOMLEFT, 'bottom-left'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_BOTTOMRIGHT, 'bottom-right'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_MIDDLE, 'middle'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_TOPLEFT, 'top-left'],
+            [Blockly.Msg.MOTION_ALIGNSCENE_TOPRIGHT, 'top-right']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_xscroll'] = {
+  /**
+   * Block to report the stage's scroll position's X value. Does not actually
+   * do anything. This is an obsolete block that is implemented for
+   * compatibility with Scratch 2.0 projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_XSCROLL,
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['motion_yscroll'] = {
+  /**
+   * Block to report the stage's scroll position's Y value. Does not actually
+   * do anything. This is an obsolete block that is implemented for
+   * compatibility with Scratch 2.0 projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.MOTION_YSCROLL,
+      "category": Blockly.Categories.motion,
+      "extensions": ["colours_motion", "output_number"]
+    });
+  }
+};

blocks_vertical/operators.js

@@ -0,0 +1,1288 @@
+/**
+ * @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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.operators');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['operator_add'] = {
+  /**
+   * Block for adding two numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_ADD,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_subtract'] = {
+  /**
+   * Block for subtracting two numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_SUBTRACT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_multiply'] = {
+  /**
+   * Block for multiplying two numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_MULTIPLY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_divide'] = {
+  /**
+   * Block for dividing two numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_DIVIDE,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_random'] = {
+  /**
+   * Block for picking a random number.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_RANDOM,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FROM"
+        },
+        {
+          "type": "input_value",
+          "name": "TO"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_lt'] = {
+  /**
+   * Block for less than comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_LT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_equals'] = {
+  /**
+   * Block for equals comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_EQUALS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_gt'] = {
+  /**
+   * Block for greater than comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_GT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_gtorequal'] = {
+  /**
+   * pm: Block for greater than or equal comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 ≥ %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_ltorequal'] = {
+  /**
+   * pm: Block for less than or equal comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 ≤ %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_notequal'] = {
+  /**
+   * pm: Block for not equal comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 ≠ %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_and'] = {
+  /**
+   * Block for "and" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_AND,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_nand'] = {
+  /**
+   * pm: Block for "nand" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 nand %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+Blockly.Blocks['operator_nor'] = {
+  /**
+   * pm: Block for "nor" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 nor %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+Blockly.Blocks['operator_xor'] = {
+  /**
+   * pm: Block for "xor" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 xor %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+Blockly.Blocks['operator_xnor'] = {
+  /**
+   * pm: Block for "nor" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 xnor %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_or'] = {
+  /**
+   * Block for "or" boolean comparator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_OR,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND1",
+          "check": "Boolean"
+        },
+        {
+          "type": "input_value",
+          "name": "OPERAND2",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_not'] = {
+  /**
+   * Block for "not" unary boolean operator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_NOT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "OPERAND",
+          "check": "Boolean"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_join'] = {
+  /**
+   * Block for string join operator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_JOIN,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STRING1"
+        },
+        {
+          "type": "input_value",
+          "name": "STRING2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_join3'] = {
+  /**
+   * pm: Block for joining 3 strings together.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_JOIN3,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STRING1"
+        },
+        {
+          "type": "input_value",
+          "name": "STRING2"
+        },
+        {
+          "type": "input_value",
+          "name": "STRING3"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_letter_of'] = {
+  /**
+   * Block for "letter _ of _" operator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_LETTEROF,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "LETTER"
+        },
+        {
+          "type": "input_value",
+          "name": "STRING"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_length'] = {
+  /**
+   * Block for string length operator.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_LENGTH,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STRING"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_contains'] = {
+  /**
+   * Block for _ contains _ operator
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_CONTAINS,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "STRING1"
+        },
+        {
+          "type": "input_value",
+          "name": "STRING2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_mod'] = {
+  /**
+   * Block for mod two numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_MOD,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_round'] = {
+  /**
+   * Block for rounding a numbers.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_ROUND,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['operator_mathop'] = {
+  /**
+   * Block for "advanced" math ops on a number.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_MATHOP,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "OPERATOR",
+          "options": [
+            [Blockly.Msg.OPERATORS_MATHOP_ABS, 'abs'],
+            [Blockly.Msg.OPERATORS_MATHOP_FLOOR, 'floor'],
+            [Blockly.Msg.OPERATORS_MATHOP_CEILING, 'ceiling'],
+            ['sign', 'sign'],
+            [Blockly.Msg.OPERATORS_MATHOP_SQRT, 'sqrt'],
+            [Blockly.Msg.OPERATORS_MATHOP_SIN, 'sin'],
+            [Blockly.Msg.OPERATORS_MATHOP_COS, 'cos'],
+            [Blockly.Msg.OPERATORS_MATHOP_TAN, 'tan'],
+            [Blockly.Msg.OPERATORS_MATHOP_ASIN, 'asin'],
+            [Blockly.Msg.OPERATORS_MATHOP_ACOS, 'acos'],
+            [Blockly.Msg.OPERATORS_MATHOP_ATAN, 'atan'],
+            [Blockly.Msg.OPERATORS_MATHOP_LN, 'ln'],
+            [Blockly.Msg.OPERATORS_MATHOP_LOG, 'log'],
+            ['log2', 'log2'],
+            [Blockly.Msg.OPERATORS_MATHOP_EEXP, 'e ^'],
+            [Blockly.Msg.OPERATORS_MATHOP_10EXP, '10 ^']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "NUM"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+Blockly.Blocks['operator_advlog'] = {
+  /**
+   * Block for better use of logarithm
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.OPERATORS_ADVLOG,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1",
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_regexmatch"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "match %1 with regex %2 %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "text"
+        },
+        {
+          "type": "input_value",
+          "name": "reg"
+        },
+        {
+          "type": "input_value",
+          "name": "regrule"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_replaceAll"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "in %1 replace all %2 with %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "text"
+        },
+        {
+          "type": "input_value",
+          "name": "term"
+        },
+        {
+          "type": "input_value",
+          "name": "res"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_replaceFirst"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "in %1 replace first %2 with %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "text"
+        },
+        {
+          "type": "input_value",
+          "name": "term"
+        },
+        {
+          "type": "input_value",
+          "name": "res"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_getLettersFromIndexToIndexInText"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "letters from %1 up to before %2 in %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX1"
+        },
+        {
+          "type": "input_value",
+          "name": "INDEX2"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+
+Blockly.Blocks["operator_getLettersFromIndexToIndexInTextFixed"] = {
+  /**
+   * pm: Duplicate of operator_getLettersFromIndexToIndexInText to prevent breaking old projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": Blockly.Msg.OPERATORS_LETTERSFROMTOIN,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "INDEX1"
+        },
+        {
+          "type": "input_value",
+          "name": "INDEX2"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_readLineInMultilineText"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "read line %1 in %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "LINE"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_newLine"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "new line",
+      "args0": [],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_tabCharacter"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "tab character",
+      "args0": [],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_stringify"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_boolify"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_character_to_code"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "character %1 to id",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_code_to_character"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "id %1 to character",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_lerpFunc"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "interpolate %1 to %2 by %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        },
+        {
+          "type": "input_value",
+          "name": "TWO"
+        },
+        {
+          "type": "input_value",
+          "name": "AMOUNT"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_advMath"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 %2 %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        },
+        {
+          "type": "field_dropdown",
+          "name": "OPTION",
+          "options": [
+            ["^", "^"],
+            ["root", "root"],
+            ["log", "log"]
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "TWO"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_advMathExpanded"] = {
+  /**
+   * pm: Duplicate of operator_advMath to prevent breaking old projects.
+   * Updated to split power and root + log, while also allowing extra params for them
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 * %2 %3 %4",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ONE"
+        },
+        {
+          "type": "input_value",
+          "name": "TWO"
+        },
+        {
+          "type": "field_dropdown",
+          "name": "OPTION",
+          "options": [
+            ["root", "root"],
+            ["log", "log"]
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "THREE"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+Blockly.Blocks['operator_power'] = {
+  /**
+   * pm: Block for getting a ^ b.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 ^ %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "NUM1"
+        },
+        {
+          "type": "input_value",
+          "name": "NUM2"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_constrainnumber"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "constrain %1 min %2 max %3",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "inp"
+        },
+        {
+          "type": "input_value",
+          "name": "min"
+        },
+        {
+          "type": "input_value",
+          "name": "max"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_trueBoolean"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "true",
+      "args0": [],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_falseBoolean"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "false",
+      "args0": [],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_randomBoolean"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "random",
+      "args0": [],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_indexOfTextInText"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "index of %1 in %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.operator,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_lastIndexOfTextInText"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "last index of %1 in %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.operator,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_countAppearTimes"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "amount of times %1 appears in %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.operator,
+      "extensions": ["colours_operators", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_textIncludesLetterFrom"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 includes a letter from %2?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.operator,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_textStartsOrEndsWith"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 %2 with %3?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        },
+        {
+          "type": "field_dropdown",
+          "name": "OPTION",
+          "options": [
+            ["starts", "starts"],
+            ["ends", "ends"]
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "TEXT2"
+        }
+      ],
+      "category": Blockly.Categories.operator,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_toUpperLowerCase"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 to %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT"
+        },
+        {
+          "type": "field_dropdown",
+          "name": "OPTION",
+          "options": [
+            ["uppercase", "upper"],
+            ["lowercase", "lower"]
+          ]
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_javascript_output"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "javascript %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "JS"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks["operator_javascript_boolean"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "javascript %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "JS"
+        }
+      ],
+      "category": Blockly.Categories.operators,
+      "extensions": ["colours_operators", "output_boolean"]
+    });
+  }
+};

blocks_vertical/procedures.js

@@ -0,0 +1,1305 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Procedure blocks for Scratch.
+ */
+'use strict';
+
+goog.provide('Blockly.ScratchBlocks.ProcedureUtils');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+// Serialization and deserialization.
+
+/**
+ * Create XML to represent the (non-editable) name and arguments of a procedure
+ * call block.
+ * @return {!Element} XML storage element.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.callerMutationToDom = function() {
+  var container = document.createElement('mutation');
+  container.setAttribute('proccode', this.procCode_.replaceAll('<', '&lt;'));
+  container.setAttribute('argumentids', JSON.stringify(this.argumentIds_));
+  container.setAttribute('warp', JSON.stringify(this.warp_));
+  container.setAttribute('returns', JSON.stringify(this.output_));
+  container.setAttribute('edited', JSON.stringify(this.edited));
+  container.setAttribute('optype', JSON.stringify(this.outputType));
+  container.setAttribute('color', JSON.stringify(this.color));
+  container.innerText = this.image;
+  return container;
+};
+
+/**
+ * Parse XML to restore the (non-editable) name and arguments of a procedure
+ * call block.
+ * @param {!Element} xmlElement XML storage element.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.callerDomToMutation = function(xmlElement) {
+  this.procCode_ = xmlElement.getAttribute('proccode').replaceAll('&lt;', '<');
+  this.generateShadows_ =
+      JSON.parse(xmlElement.getAttribute('generateshadows'));
+  this.argumentIds_ = JSON.parse(xmlElement.getAttribute('argumentids'));
+  this.warp_ = JSON.parse(xmlElement.getAttribute('warp'));
+  this.output_ = JSON.parse(xmlElement.getAttribute('returns'));
+  this.edited = JSON.parse(xmlElement.getAttribute('edited'));
+  this.outputType = JSON.parse(xmlElement.getAttribute('optype'));
+  this.color = JSON.parse(xmlElement.getAttribute('color'));
+  // compat bc dum poopoo code
+  if (!this.color) this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  if (this.color && this.color.primary) {
+    this.color = [this.color.primary, this.color.secondary, this.color.tertiary]
+  }
+  // @todo figure out why the fuck we are even getting 8 digit hex colors in the first place
+  this.color = this.color.map(c => c.slice(0, 7))
+  this.image = xmlElement.innerText;
+  this.updateDisplay_();
+};
+
+/**
+ * Create XML to represent the (non-editable) name and arguments of a
+ * procedures_prototype block or a procedures_declaration block.
+ * @param {boolean=} opt_generateShadows Whether to include the generateshadows
+ *     flag in the generated XML.  False if not provided.
+ * @return {!Element} XML storage element.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.definitionMutationToDom = function(
+    opt_generateShadows) {
+  var container = document.createElement('mutation');
+
+  if (opt_generateShadows) {
+    container.setAttribute('generateshadows', true);
+  }
+  container.setAttribute('proccode', this.procCode_.replaceAll('<', '&lt;'));
+  container.setAttribute('argumentids', JSON.stringify(this.argumentIds_));
+  container.setAttribute('argumentnames', JSON.stringify(this.displayNames_));
+  container.setAttribute('argumentdefaults', JSON.stringify(this.argumentDefaults_));
+  container.setAttribute('warp', JSON.stringify(this.warp_));
+  container.setAttribute('returns', JSON.stringify(this.output_));
+  container.setAttribute('edited', JSON.stringify(this.edited));
+  container.setAttribute('optype', JSON.stringify(this.outputType));
+  container.setAttribute('color', JSON.stringify(this.color));
+  container.innerText = this.image;
+  return container;
+};
+
+/**
+ * Parse XML to restore the (non-editable) name and arguments of a
+ * procedures_prototype block or a procedures_declaration block.
+ * @param {!Element} xmlElement XML storage element.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.definitionDomToMutation = function(xmlElement) {
+  this.procCode_ = xmlElement.getAttribute('proccode').replaceAll('&lt;', '<');
+  this.warp_ = JSON.parse(xmlElement.getAttribute('warp'));
+
+  var prevArgIds = this.argumentIds_;
+  var prevDisplayNames = this.displayNames_;
+
+  this.argumentIds_ = JSON.parse(xmlElement.getAttribute('argumentids'));
+  this.displayNames_ = JSON.parse(xmlElement.getAttribute('argumentnames'));
+  this.argumentDefaults_ = JSON.parse(xmlElement.getAttribute('argumentdefaults'));
+  this.output_ = JSON.parse(xmlElement.getAttribute('returns'));
+  this.outputType = JSON.parse(xmlElement.getAttribute('optype'));
+  this.edited = JSON.parse(xmlElement.getAttribute('edited'));
+  this.image = xmlElement.innerText;
+  this.color = JSON.parse(xmlElement.getAttribute('color'));
+  // compat bc dum poopoo code
+  if (!this.color) this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  if (this.color && this.color.primary) {
+    this.color = [this.color.primary, this.color.secondary, this.color.tertiary]
+  }
+  // @todo figure out why the fuck we are even getting 8 digit hex colors in the first place
+  this.color = this.color.map(c => c.slice(0, 7))
+  this.image = xmlElement.innerText;
+  this.updateDisplay_();
+  if (this.updateArgumentReporterNames_) {
+    this.updateArgumentReporterNames_(prevArgIds, prevDisplayNames);
+  }
+};
+
+// End of serialization and deserialization.
+
+// Shared by all three procedure blocks (procedures_declaration,
+// procedures_call, and procedures_prototype).
+/**
+ * Returns the name of the procedure this block calls, or the empty string if
+ * it has not yet been set.
+ * @return {string} Procedure name.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.getProcCode = function() {
+  return this.procCode_;
+};
+
+/**
+ * Update the block's structure and appearance to match the internally stored
+ * mutation.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_ = function() {
+  var wasRendered = this.rendered;
+  // @todo add statement check?
+  var ConectionType = (this.outputType || (this.output_ ? 'string' : 'statement')).toLowerCase()
+  this.rendered = false;
+
+  var connectionMap = this.disconnectOldBlocks_();
+  this.removeAllInputs_();
+
+  this.createAllInputs_(connectionMap);
+  this.deleteShadows_(connectionMap);
+  this.setOutputShape(Blockly.OUTPUT_SHAPE_SQUARE);
+  // only change the color if we have a color to change to
+  this.setColour(...this.color)
+  if (
+      this.outputConnection && 
+      this.outputConnection.targetConnection && 
+      this.outputConnection.targetConnection.sourceBlock_.type === 'procedures_definition_return') {
+    this.outputConnection.targetConnection.sourceBlock_.setColour(...this.color)
+  }
+  if (
+      this.previousConnection && 
+      this.previousConnection.targetConnection && 
+      this.previousConnection.targetConnection.sourceBlock_.type === 'procedures_definition') {
+    this.previousConnection.targetConnection.sourceBlock_.setColour(...this.color)
+  }
+  if (this.output_) {
+    this.setPreviousStatement(false)
+    this.setNextStatement(false)
+    switch (ConectionType) {
+      case 'string':
+      case 'number':
+      default:
+        this.setOutputShape(Blockly.OUTPUT_SHAPE_ROUND); break;
+      case 'boolean':
+        this.setOutputShape(Blockly.OUTPUT_SHAPE_HEXAGONAL); break;
+    }
+    this.setOutput(this.output_, this.isDisplayOnly ? 'procedure' : null);
+  } else {
+    this.setOutput(false)
+    switch (ConectionType) {
+      case 'statement':
+        this.setPreviousStatement(!this.output_, this.isDisplayOnly ? 'procedure' : 'normal')
+        this.setNextStatement(!this.output_, this.isDisplayOnly ? 'procedure' : 'normal')
+        break
+      case 'end':
+        this.setPreviousStatement(!this.output_, this.isDisplayOnly ? 'procedure' : 'normal')
+        this.setNextStatement(false, 'procedure')
+        break
+    }
+  }
+
+  this.rendered = wasRendered;
+  if (wasRendered && !this.isInsertionMarker()) {
+    this.initSvg();
+    this.render();
+  }
+};
+
+/**
+ * Disconnect old blocks from all value inputs on this block, but hold onto them
+ * in case they can be reattached later.  Also save the shadow DOM if it exists.
+ * The result is a map from argument ID to information that was associated with
+ * that argument at the beginning of the mutation.
+ * @return {!Object.<string, {shadow: Element, block: Blockly.Block}>} An object
+ *     mapping argument IDs to blocks and shadow DOMs.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.disconnectOldBlocks_ = function() {
+  // Remove old stuff
+  var connectionMap = {};
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection) {
+      var target = input.connection.targetBlock();
+      var saveInfo = {
+        shadow: input.connection.getShadowDom(),
+        block: target
+      };
+      connectionMap[input.name] = saveInfo;
+
+      // Remove the shadow DOM, then disconnect the block.  Otherwise a shadow
+      // block will respawn instantly, and we'd have to remove it when we remove
+      // the input.
+      input.connection.setShadowDom(null);
+      if (target) {
+        input.connection.disconnect();
+      }
+    }
+  }
+  return connectionMap;
+};
+
+/**
+ * Remove all inputs on the block, including dummy inputs.
+ * Assumes no input has shadow DOM set.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.removeAllInputs_ = function() {
+  // Delete inputs directly instead of with block.removeInput to avoid splicing
+  // out of the input list at every index.
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    input.dispose();
+  }
+  this.inputList = [];
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.createIcon_ = function() {
+  if (!this.image) return
+  if (this.image.startsWith('data:') || this.image.startsWith('http')) {
+    const iconField = new Blockly.FieldImage(this.image, 40, 40);
+    const separatorField = new Blockly.FieldVerticalSeparator();
+    this.appendDummyInput()
+      .appendField(iconField)
+      .appendField(separatorField);
+  }
+};
+
+/**
+ * Create all inputs specified by the new procCode, and populate them with
+ * shadow blocks or reconnected old blocks as appropriate.
+ * @param {!Object.<string, {shadow: Element, block: Blockly.Block}>}
+ *     connectionMap An object mapping argument IDs to blocks and shadow DOMs.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_ = function(connectionMap) {
+  this.createIcon_()
+  // Split the proc into components, by %n, %b, and %s (ignoring escaped).
+  var procComponents = this.procCode_.split(/(?=[^\\]%[nsbc])/);
+  procComponents = procComponents.map(function(c) {
+    return c.trim(); // Strip whitespace.
+  });
+  // Create arguments and labels as appropriate.
+  var argumentCount = 0;
+  for (var i = 0, component; component = procComponents[i]; i++) {
+    var labelText;
+    var argumentType = component.substring(1, 2);
+    var id = this.argumentIds_[argumentCount];
+    // user error shouldnt literally nuke the app, ignore invalid markers instead of erroring on them
+    if (component.substring(0, 1) == '%' && (['n', 's', 'b', 'c'].includes(argumentType)) && id) {
+      /*
+      if (!(argumentType == 'n' || argumentType == 'b' || argumentType == 's')) {
+        throw new Error(
+            'Found an custom procedure with an invalid type: ' + argumentType);
+      }
+      */
+      labelText = component.substring(2).trim();
+
+      if (argumentType == "c") {
+        var input = this.appendStatementInput(id)
+      } else {
+        var input = this.appendValueInput(id);
+      }
+      if (argumentType == 'b') {
+        input.setCheck('Boolean');
+      }
+      this.populateArgument_(argumentType, argumentCount, connectionMap, id,
+          input);
+      argumentCount++;
+    } else {
+      labelText = component.trim();
+    }
+    this.addProcedureLabel_(labelText.replace(/\\%/, '%'));
+  }
+};
+
+/**
+ * Delete all shadow blocks in the given map.
+ * @param {!Object.<string, Blockly.Block>} connectionMap An object mapping
+ *     argument IDs to the blocks that were connected to those IDs at the
+ *     beginning of the mutation.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.deleteShadows_ = function(connectionMap) {
+  // Get rid of all of the old shadow blocks if they aren't connected.
+  if (connectionMap) {
+    for (var id in connectionMap) {
+      var saveInfo = connectionMap[id];
+      if (saveInfo) {
+        var block = saveInfo['block'];
+        if (block && block.isShadow()) {
+          block.dispose();
+          connectionMap[id] = null;
+          // At this point we know which shadow DOMs are about to be orphaned in
+          // the VM.  What do we do with that information?
+        }
+      }
+    }
+  }
+};
+// End of shared code.
+
+/**
+ * Add a label field with the given text to a procedures_call or
+ * procedures_prototype block.
+ * @param {string} text The label text.
+ * @private
+ */
+Blockly.ScratchBlocks.ProcedureUtils.addLabelField_ = function(text) {
+  this.appendDummyInput().appendField(text);
+};
+
+/**
+ * Add a label editor with the given text to a procedures_declaration
+ * block.  Editing the text in the label editor updates the text of the
+ * corresponding label fields on function calls.
+ * @param {string} text The label text.
+ * @private
+ */
+Blockly.ScratchBlocks.ProcedureUtils.addLabelEditor_ = function(text) {
+  if (text) {
+    this.appendDummyInput(Blockly.utils.genUid()).
+        appendField(new Blockly.FieldTextInputRemovable(text));
+  }
+};
+
+/**
+ * Build a DOM node representing a shadow block of the given type.
+ * @param {string} type One of 's' (string) or 'n' (number).
+ * @return {!Element} The DOM node representing the new shadow block.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.buildShadowDom_ = function(type) {
+  var shadowDom = goog.dom.createDom('shadow');
+  if (type == 'n') {
+    var shadowType = 'math_number';
+    var fieldName = 'NUM';
+    var fieldValue = '1';
+  } else {
+    var shadowType = 'text';
+    var fieldName = 'TEXT';
+    var fieldValue = '';
+  }
+  shadowDom.setAttribute('type', shadowType);
+  var fieldDom = goog.dom.createDom('field', null, fieldValue);
+  fieldDom.setAttribute('name', fieldName);
+  shadowDom.appendChild(fieldDom);
+  return shadowDom;
+};
+
+/**
+ * Create a new shadow block and attach it to the given input.
+ * @param {!Blockly.Input} input The value input to attach a block to.
+ * @param {string} argumentType One of 'b' (boolean), 's' (string) or
+ *     'n' (number).
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.attachShadow_ = function(input,
+    argumentType) {
+  if (argumentType == 'n' || argumentType == 's') {
+    var blockType = argumentType == 'n' ? 'math_number' : 'text';
+    Blockly.Events.disable();
+    try {
+      var newBlock = this.workspace.newBlock(blockType);
+      if (argumentType == 'n') {
+        newBlock.setFieldValue('1', 'NUM');
+      } else {
+        newBlock.setFieldValue('', 'TEXT');
+      }
+      newBlock.setShadow(true);
+      if (!this.isInsertionMarker()) {
+        newBlock.initSvg();
+        newBlock.render(false);
+      }
+    } finally {
+      Blockly.Events.enable();
+    }
+    if (Blockly.Events.isEnabled()) {
+      Blockly.Events.fire(new Blockly.Events.BlockCreate(newBlock));
+    }
+    newBlock.outputConnection.connect(input.connection);
+  }
+};
+
+/**
+ * Create a new argument reporter block.
+ * @param {string} argumentType One of 'b' (boolean), 's' (string) or
+ *     'n' (number).
+ * @param {string} displayName The name of the argument as provided by the
+ *     user, which becomes the text of the label on the argument reporter block.
+ * @return {!Blockly.BlockSvg} The newly created argument reporter block.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.createArgumentReporter_ = function(
+    argumentType, displayName) {
+  switch (argumentType) {
+    case 'n':
+    case 's':
+      var blockType = 'argument_reporter_string_number';
+      break;
+    case 'b':
+      var blockType = 'argument_reporter_boolean';
+      break;
+    case 'c':
+      var blockType = 'argument_reporter_command';
+      break;
+  }
+  Blockly.Events.disable();
+  try {
+    var newBlock = this.workspace.newBlock(blockType);
+    newBlock.setShadow(true);
+    newBlock.setFieldValue(displayName, 'VALUE');
+    newBlock.color = this.color
+    newBlock.setColour(...this.color)
+    if (!this.isInsertionMarker()) {
+      newBlock.initSvg();
+      newBlock.render(false);
+    }
+  } finally {
+    Blockly.Events.enable();
+  }
+  if (Blockly.Events.isEnabled()) {
+    Blockly.Events.fire(new Blockly.Events.BlockCreate(newBlock));
+  }
+  return newBlock;
+};
+
+/**
+ * Populate the argument by attaching the correct child block or shadow to the
+ * given input.
+ * @param {string} type One of 'b' (boolean), 's' (string) or 'n' (number).
+ * @param {number} index The index of this argument into the argument id array.
+ * @param {!Object.<string, {shadow: Element, block: Blockly.Block}>}
+ *     connectionMap An object mapping argument IDs to blocks and shadow DOMs.
+ * @param {string} id The ID of the input to populate.
+ * @param {!Blockly.Input} input The newly created input to populate.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnCaller_ = function(type,
+    index, connectionMap, id, input) {
+  var oldBlock = null;
+  var oldShadow = null;
+  if (connectionMap && (id in connectionMap)) {
+    var saveInfo = connectionMap[id];
+    oldBlock = saveInfo['block'];
+    oldShadow = saveInfo['shadow'];
+  }
+
+  if (connectionMap && oldBlock) {
+    // Reattach the old block and shadow DOM.
+    connectionMap[input.name] = null;
+    if (type == "c") {
+      oldBlock.previousConnection.connect(input.connection);
+    } else {
+      oldBlock.outputConnection.connect(input.connection);
+    }
+    if (type != 'b' && type != 'c' && this.generateShadows_) {
+      var shadowDom = oldShadow || this.buildShadowDom_(type);
+      console.log("setting shadow dom: " + shadowDom);
+      input.connection.setShadowDom(shadowDom);
+    }
+  } else if (this.generateShadows_) {
+    this.attachShadow_(input, type);
+  }
+};
+
+/**
+ * Populate the argument by attaching the correct argument reporter to the given
+ * input.
+ * @param {string} type One of 'b' (boolean), 's' (string) or 'n' (number).
+ * @param {number} index The index of this argument into the argument ID and
+ *     argument display name arrays.
+ * @param {!Object.<string, {shadow: Element, block: Blockly.Block}>}
+ *     connectionMap An object mapping argument IDs to blocks and shadow DOMs.
+ * @param {string} id The ID of the input to populate.
+ * @param {!Blockly.Input} input The newly created input to populate.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnPrototype_ = function(
+    type, index, connectionMap, id, input) {
+  var oldBlock = null;
+  if (connectionMap && (id in connectionMap)) {
+    var saveInfo = connectionMap[id];
+    oldBlock = saveInfo['block'];
+  }
+
+  var oldTypeMatches =
+    Blockly.ScratchBlocks.ProcedureUtils.checkOldTypeMatches_(oldBlock, type);
+  var displayName = this.displayNames_[index];
+
+  // Decide which block to attach.
+  if (connectionMap && oldBlock && oldTypeMatches) {
+    // Update the text if needed. The old argument reporter is the same type,
+    // and on the same input, but the argument's display name may have changed.
+    var argumentReporter = oldBlock;
+    argumentReporter.setFieldValue(displayName, 'VALUE');
+    connectionMap[input.name] = null;
+  } else {
+    var argumentReporter = this.createArgumentReporter_(type, displayName);
+  }
+
+  // Attach the block.
+  if (type == "c") {
+    input.connection.connect(argumentReporter.previousConnection);
+  } else {
+    input.connection.connect(argumentReporter.outputConnection);
+  }
+};
+
+/**
+ * Populate the argument by attaching the correct argument editor to the given
+ * input.
+ * @param {string} type One of 'b' (boolean), 's' (string) or 'n' (number).
+ * @param {number} index The index of this argument into the argument id and
+ *     argument display name arrays.
+ * @param {!Object.<string, {shadow: Element, block: Blockly.Block}>}
+ *     connectionMap An object mapping argument IDs to blocks and shadow DOMs.
+ * @param {string} id The ID of the input to populate.
+ * @param {!Blockly.Input} input The newly created input to populate.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnDeclaration_ = function(
+    type, index, connectionMap, id, input) {
+
+  var oldBlock = null;
+  if (connectionMap && (id in connectionMap)) {
+    var saveInfo = connectionMap[id];
+    oldBlock = saveInfo['block'];
+  }
+
+  // TODO: This always returns false, because it checks for argument reporter
+  // blocks instead of argument editor blocks.  Create a new version for argument
+  // editors.
+  var oldTypeMatches =
+    Blockly.ScratchBlocks.ProcedureUtils.checkOldTypeMatches_(oldBlock, type);
+  var displayName = this.displayNames_[index];
+
+  // Decide which block to attach.
+  if (oldBlock && oldTypeMatches) {
+    var argumentEditor = oldBlock;
+    oldBlock.setFieldValue(displayName, 'TEXT');
+    connectionMap[input.name] = null;
+  } else {
+    var argumentEditor = this.createArgumentEditor_(type, displayName);
+  }
+
+  // Attach the block.
+  if (type == "c") {
+    input.connection.connect(argumentEditor.previousConnection);
+  } else {
+    input.connection.connect(argumentEditor.outputConnection);
+  }
+};
+
+/**
+ * Check whether the type of the old block corresponds to the given argument
+ * type.
+ * @param {Blockly.BlockSvg} oldBlock The old block to check.
+ * @param {string} type The argument type.  One of 'n', 'n', or 's'.
+ * @return {boolean} True if the type matches, false otherwise.
+ */
+Blockly.ScratchBlocks.ProcedureUtils.checkOldTypeMatches_ = function(oldBlock,
+    type) {
+  if (!oldBlock) {
+    return false;
+  }
+  if ((type == 'n' || type == 's') &&
+      oldBlock.type == 'argument_reporter_string_number') {
+    return true;
+  }
+  if (type == 'b' && oldBlock.type == 'argument_reporter_boolean') {
+    return true;
+  }
+  //dunno if this is needed but oh well
+  if (type == 'c' && oldBlock.type == 'argument_reporter_command') {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Create an argument editor.
+ * An argument editor is a shadow block with a single text field, which is used
+ * to set the display name of the argument.
+ * @param {string} argumentType One of 'b' (boolean), 's' (string) or
+ *     'n' (number).
+ * @param {string} displayName The display name  of this argument, which is the
+ *     text of the field on the shadow block.
+ * @return {!Blockly.BlockSvg} The newly created argument editor block.
+ * @private
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.createArgumentEditor_ = function(
+    argumentType, displayName) {
+  Blockly.Events.disable();
+  try {
+    switch (argumentType) {
+      case 'n':
+      case 's':
+        var newBlock = this.workspace.newBlock('argument_editor_string_number');
+        break;
+      case 'b':
+        var newBlock = this.workspace.newBlock('argument_editor_boolean');
+        break;
+      case 'c':
+        var newBlock = this.workspace.newBlock('argument_editor_command')
+    }
+    newBlock.setFieldValue(displayName, 'TEXT');
+    newBlock.setShadow(true);
+    if (!this.isInsertionMarker()) {
+      newBlock.initSvg();
+      newBlock.render(false);
+    }
+  } finally {
+    Blockly.Events.enable();
+  }
+  if (Blockly.Events.isEnabled()) {
+    Blockly.Events.fire(new Blockly.Events.BlockCreate(newBlock));
+  }
+  return newBlock;
+};
+
+/**
+ * Update the serializable information on the block based on the existing inputs
+ * and their text.
+ */
+Blockly.ScratchBlocks.ProcedureUtils.updateDeclarationProcCode_ = function() {
+  this.procCode_ = '';
+  this.displayNames_ = [];
+  this.argumentIds_ = [];
+  for (var i = 0; i < this.inputList.length; i++) {
+    if (i != 0) {
+      this.procCode_ += ' ';
+    }
+    var input = this.inputList[i];
+    if (input.type == Blockly.DUMMY_INPUT) {
+      this.procCode_ += input.fieldRow[0].getValue();
+    } else if (input.type == Blockly.INPUT_VALUE || input.type == Blockly.NEXT_STATEMENT) {
+      // Inspect the argument editor.
+      var target = input.connection.targetBlock();
+      this.displayNames_.push(target.getFieldValue('TEXT'));
+      this.argumentIds_.push(input.name);
+      switch (target.type) {
+        case 'argument_editor_string_number':
+          this.procCode_ += '%s';
+          break;
+        case 'argument_editor_boolean':
+          this.procCode_ += '%b';
+          break;
+        case 'argument_editor_command':
+          this.procCode_ += "%c";
+          break;
+      }
+    } else {
+      throw new Error(
+          'Unexpected input type on a procedure mutator root: ' + input.type);
+    }
+  }
+};
+
+/**
+ * Focus on the last argument editor or label editor on the block.
+ * @private
+ */
+Blockly.ScratchBlocks.ProcedureUtils.focusLastEditor_ = function() {
+  if (this.inputList.length > 0) {
+    var newInput = this.inputList[this.inputList.length - 1];
+    if (newInput.type == Blockly.DUMMY_INPUT) {
+      newInput.fieldRow[0].showEditor_();
+    } else if (newInput.type == Blockly.INPUT_VALUE) {
+      // Inspect the argument editor.
+      var target = newInput.connection.targetBlock();
+      target.getField('TEXT').showEditor_();
+    }
+  }
+};
+
+/**
+ * Externally-visible function to add a label to the procedure declaration.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.addLabelExternal = function() {
+  Blockly.WidgetDiv.hide(true);
+  this.procCode_ = this.procCode_ + ' label text';
+  this.updateDisplay_();
+  this.focusLastEditor_();
+};
+
+/**
+ * Externally-visible function to add a boolean argument to the procedure
+ * declaration.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.addBooleanExternal = function() {
+  Blockly.WidgetDiv.hide(true);
+  this.procCode_ = this.procCode_ + ' %b';
+  this.displayNames_.push('boolean');
+  this.argumentIds_.push(Blockly.utils.genUid());
+  this.argumentDefaults_.push('false');
+  this.updateDisplay_();
+  this.focusLastEditor_();
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.addCommandExternal = function () {
+  Blockly.WidgetDiv.hide(true);
+  this.procCode_ = this.procCode_ + " %c";
+  this.displayNames_.push("branch");
+  this.argumentIds_.push("SUBSTACK" + Blockly.utils.genUid());
+  this.argumentDefaults_.push("");
+  this.updateDisplay_();
+  this.focusLastEditor_();
+};
+
+/**
+ * Externally-visible function to add a string/number argument to the procedure
+ * declaration.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.addStringNumberExternal = function() {
+  Blockly.WidgetDiv.hide(true);
+  this.procCode_ = this.procCode_ + ' %s';
+  this.displayNames_.push('number or text');
+  this.argumentIds_.push(Blockly.utils.genUid());
+  this.argumentDefaults_.push('');
+  this.updateDisplay_();
+  this.focusLastEditor_();
+};
+
+/**
+ * Externally-visible function to get the warp on procedure declaration.
+ * @return {boolean} The value of the warp_ property.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.getWarp = function() {
+  return this.warp_;
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.getReturns = function() {
+  return this.output_;
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.getEdited = function() {
+  return this.edited;
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.setEdited = function(edited) {
+  this.edited = edited;
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.setReturns = function(returns) {
+  this.output_ = returns;
+  this.updateDisplay_();
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.setType = function(type) {
+  this.outputType = type.toLowerCase()
+  this.updateDisplay_();
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.setImage = function(image) {
+  this.image = image
+  this.updateDisplay_();
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.unsetImage = function() {
+  this.image = ''
+  this.updateDisplay_();
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.setColor = function(primary, secondary, tertiary) {
+  this.color = [primary, secondary, tertiary]
+  this.updateDisplay_();
+}
+
+Blockly.ScratchBlocks.ProcedureUtils.removeColor = function() {
+  this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  this.updateDisplay_();
+}
+
+/**
+ * Externally-visible function to set the warp on procedure declaration.
+ * @param {boolean} warp The value of the warp_ property.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.setWarp = function(warp) {
+  this.warp_ = warp;
+};
+
+/**
+ * Callback to remove a field, only for the declaration block.
+ * @param {Blockly.Field} field The field being removed.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.removeFieldCallback = function(field) {
+  // Do not delete if there is only one input
+  if (this.inputList.length === 1) {
+    return;
+  }
+  var inputNameToRemove = null;
+  for (var n = 0; n < this.inputList.length; n++) {
+    var input = this.inputList[n];
+    if (input.connection) {
+      var target = input.connection.targetBlock();
+      if (target.getField(field.name) == field) {
+        inputNameToRemove = input.name;
+      }
+    } else {
+      for (var j = 0; j < input.fieldRow.length; j++) {
+        if (input.fieldRow[j] == field) {
+          inputNameToRemove = input.name;
+        }
+      }
+    }
+  }
+  if (inputNameToRemove) {
+    Blockly.WidgetDiv.hide(true);
+    this.removeInput(inputNameToRemove);
+    this.onChangeFn();
+    this.updateDisplay_();
+  }
+};
+
+/**
+ * Callback to pass removeField up to the declaration block from arguments.
+ * @param {Blockly.Field} field The field being removed.
+ * @public
+ */
+Blockly.ScratchBlocks.ProcedureUtils.removeArgumentCallback_ = function(field) {
+  if (this.parentBlock_ && this.parentBlock_.removeFieldCallback) {
+    this.parentBlock_.removeFieldCallback(field);
+  }
+};
+
+/**
+ * Update argument reporter field values after an edit to the prototype mutation
+ * using previous argument ids and names.
+ * Because the argument reporters only store names and not which argument ids they
+ * are linked to, it would not be safe to update all argument reporters on the workspace
+ * since they may be argument reporters with the same name from a different procedure.
+ * Until there is a more explicit way of identifying argument reporter blocks using ids,
+ * be conservative and only update argument reporters that are used in the
+ * stack below the prototype, ie the definition.
+ * @param {!Array<string>} prevArgIds The previous ordering of argument ids.
+ * @param {!Array<string>} prevDisplayNames The previous argument names.
+ * @this Blockly.Block
+ */
+Blockly.ScratchBlocks.ProcedureUtils.updateArgumentReporterNames_ = function(prevArgIds, prevDisplayNames) {
+  var nameChanges = [];
+  var argReporters = [];
+  var definitionBlock = this.getParent();
+  if (!definitionBlock) return;
+
+  // Create a list of argument reporters that are descendants of the definition stack (see above comment)
+  var allBlocks = definitionBlock.getDescendants(false);
+  for (var i = 0; i < allBlocks.length; i++) {
+    var block = allBlocks[i];
+    if ((block.type === 'argument_reporter_string_number' ||
+        block.type === 'argument_reporter_boolean' ||
+        block.type === 'argument_reporter_command') &&
+        !block.isShadow()) { // Exclude arg reporters in the prototype block, which are shadows.
+      argReporters.push(block);
+    }
+  }
+
+  // Create a list of "name changes", including the new name and blocks matching the old name
+  // Only search over the current set of argument ids, ignore args that have been removed
+  for (var i = 0, id; id = this.argumentIds_[i]; i++) {
+    // Find the previous index of this argument id. Could be -1 if it is newly added.
+    var prevIndex = prevArgIds.indexOf(id);
+    if (prevIndex == -1) continue; // Newly added argument, no corresponding previous argument to update.
+    var prevName = prevDisplayNames[prevIndex];
+    if (prevName != this.displayNames_[i]) {
+      nameChanges.push({
+        newName: this.displayNames_[i],
+        blocks: argReporters.filter(function(block) {
+          return block.getFieldValue('VALUE') == prevName;
+        })
+      });
+    }
+  }
+
+  // Finally update the blocks for each name change.
+  // Do this after creating the lists to avoid cycles of renaming.
+  for (var j = 0, nameChange; nameChange = nameChanges[j]; j++) {
+    for (var k = 0, block; block = nameChange.blocks[k]; k++) {
+      block.setFieldValue(nameChange.newName, 'VALUE');
+    }
+  }
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.argumentReporterMutationToDom = function() {
+  var dom = document.createElement('mutation');
+  dom.setAttribute('color', JSON.stringify(this.color))
+  return dom
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.argumentReporterDomToMutation = function(dom) {
+  try {
+    this.color = JSON.parse(dom.getAttribute('color'))
+    this.updateDisplay_()
+  } catch (err) {
+    console.warn('unknown old argument reporter')
+  }
+};
+
+Blockly.ScratchBlocks.ProcedureUtils.argumentReporterUpdateDisplay = function(dom) {
+  this.setColour(...this.color)
+};
+
+Blockly.Blocks['procedures_definition'] = {
+  /**
+   * Block for defining a procedure with no return value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.PROCEDURES_DEFINITION,
+      "args0": [
+        {
+          "type": "input_statement",
+          "name": "custom_block",
+          "check": 'procedure'
+        }
+      ],
+      "extensions": ["colours_more", "shape_hat", "procedure_def_contextmenu"]
+    });
+  }
+};
+
+Blockly.Blocks['procedures_definition_return'] = {
+  /**
+   * Block for defining a procedure with no return value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.PROCEDURES_DEFINITION,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "custom_block",
+          "check": 'procedure'
+        }
+      ],
+      "extensions": ["colours_more", "shape_hat", "procedure_def_contextmenu"]
+    });
+  }
+};
+
+Blockly.Blocks['procedures_call'] = {
+  /**
+   * Block for calling a procedure with no return value.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "extensions": ["colours_more", "shape_statement", "procedure_call_contextmenu"]
+    });
+    this.procCode_ = '';
+    this.argumentIds_ = [];
+    this.warp_ = false;
+    this.output_ = false;
+    this.isDisplayOnly = false
+    this.edited = false
+    this.outputType = 'statement'
+    this.image = ''
+    this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  },
+  // Shared.
+  getProcCode: Blockly.ScratchBlocks.ProcedureUtils.getProcCode,
+  removeAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.removeAllInputs_,
+  disconnectOldBlocks_: Blockly.ScratchBlocks.ProcedureUtils.disconnectOldBlocks_,
+  deleteShadows_: Blockly.ScratchBlocks.ProcedureUtils.deleteShadows_,
+  createIcon_: Blockly.ScratchBlocks.ProcedureUtils.createIcon_,
+  createAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_,
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_,
+
+  // Exist on all three blocks, but have different implementations.
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.callerMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.callerDomToMutation,
+  populateArgument_: Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnCaller_,
+  addProcedureLabel_: Blockly.ScratchBlocks.ProcedureUtils.addLabelField_,
+
+  // Only exists on the external caller.
+  attachShadow_: Blockly.ScratchBlocks.ProcedureUtils.attachShadow_,
+  buildShadowDom_: Blockly.ScratchBlocks.ProcedureUtils.buildShadowDom_
+};
+
+Blockly.Blocks['procedures_prototype'] = {
+  /**
+   * Block for calling a procedure with no return value, for rendering inside
+   * define block.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "extensions": ["colours_more", 'shape_procedure']
+    });
+
+    /* Data known about the procedure. */
+    this.procCode_ = '';
+    this.displayNames_ = [];
+    this.argumentIds_ = [];
+    this.argumentDefaults_ = [];
+    this.warp_ = false;
+    this.output_ = false;
+    this.isDisplayOnly = true
+    this.edited = false
+    this.outputType = 'statement'
+    this.image = ''
+    this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  },
+  // Shared.
+  getProcCode: Blockly.ScratchBlocks.ProcedureUtils.getProcCode,
+  removeAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.removeAllInputs_,
+  disconnectOldBlocks_: Blockly.ScratchBlocks.ProcedureUtils.disconnectOldBlocks_,
+  deleteShadows_: Blockly.ScratchBlocks.ProcedureUtils.deleteShadows_,
+  createIcon_: Blockly.ScratchBlocks.ProcedureUtils.createIcon_,
+  createAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_,
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_,
+
+  // Exist on all three blocks, but have different implementations.
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.definitionMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.definitionDomToMutation,
+  populateArgument_: Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnPrototype_,
+  addProcedureLabel_: Blockly.ScratchBlocks.ProcedureUtils.addLabelField_,
+
+  // Only exists on procedures_prototype.
+  createArgumentReporter_: Blockly.ScratchBlocks.ProcedureUtils.createArgumentReporter_,
+  updateArgumentReporterNames_: Blockly.ScratchBlocks.ProcedureUtils.updateArgumentReporterNames_
+};
+
+Blockly.Blocks['procedures_declaration'] = {
+  /**
+   * The root block in the procedure declaration editor.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "extensions": ["colours_more", 'shape_procedure']
+    });
+    /* Data known about the procedure. */
+    this.procCode_ = '';
+    this.displayNames_ = [];
+    this.argumentIds_ = [];
+    this.argumentDefaults_ = [];
+    this.warp_ = false;
+    this.output_ = false;
+    this.isDisplayOnly = true
+    this.edited = false
+    this.outputType = 'statement'
+    this.image = ''
+    this.color = [Blockly.Colours.more.primary, Blockly.Colours.more.secondary, Blockly.Colours.more.tertiary]
+  },
+  // Shared.
+  getProcCode: Blockly.ScratchBlocks.ProcedureUtils.getProcCode,
+  removeAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.removeAllInputs_,
+  disconnectOldBlocks_: Blockly.ScratchBlocks.ProcedureUtils.disconnectOldBlocks_,
+  deleteShadows_: Blockly.ScratchBlocks.ProcedureUtils.deleteShadows_,
+  createIcon_: Blockly.ScratchBlocks.ProcedureUtils.createIcon_,
+  createAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_,
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_,
+
+  // Exist on all three blocks, but have different implementations.
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.definitionMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.definitionDomToMutation,
+  populateArgument_: Blockly.ScratchBlocks.ProcedureUtils.populateArgumentOnDeclaration_,
+  addProcedureLabel_: Blockly.ScratchBlocks.ProcedureUtils.addLabelEditor_,
+
+  // Exist on declaration and arguments editors, with different implementations.
+  removeFieldCallback: Blockly.ScratchBlocks.ProcedureUtils.removeFieldCallback,
+
+  // Only exist on procedures_declaration.
+  createArgumentEditor_: Blockly.ScratchBlocks.ProcedureUtils.createArgumentEditor_,
+  focusLastEditor_: Blockly.ScratchBlocks.ProcedureUtils.focusLastEditor_,
+  getWarp: Blockly.ScratchBlocks.ProcedureUtils.getWarp,
+  setWarp: Blockly.ScratchBlocks.ProcedureUtils.setWarp,
+  getReturns: Blockly.ScratchBlocks.ProcedureUtils.getReturns,
+  setReturns: Blockly.ScratchBlocks.ProcedureUtils.setReturns,
+  getEdited: Blockly.ScratchBlocks.ProcedureUtils.getEdited,
+  setEdited: Blockly.ScratchBlocks.ProcedureUtils.setEdited,
+  setType: Blockly.ScratchBlocks.ProcedureUtils.setType,
+  setImage: Blockly.ScratchBlocks.ProcedureUtils.setImage,
+  unsetImage: Blockly.ScratchBlocks.ProcedureUtils.unsetImage,
+  setColor: Blockly.ScratchBlocks.ProcedureUtils.setColor,
+  removeColor: Blockly.ScratchBlocks.ProcedureUtils.removeColor,
+  addLabelExternal: Blockly.ScratchBlocks.ProcedureUtils.addLabelExternal,
+  addBooleanExternal: Blockly.ScratchBlocks.ProcedureUtils.addBooleanExternal,
+  addCommandExternal: Blockly.ScratchBlocks.ProcedureUtils.addCommandExternal,
+  addStringNumberExternal: Blockly.ScratchBlocks.ProcedureUtils.addStringNumberExternal,
+  onChangeFn: Blockly.ScratchBlocks.ProcedureUtils.updateDeclarationProcCode_
+};
+
+Blockly.Blocks['argument_reporter_boolean'] = {
+  init: function() {
+    this.jsonInit({ 
+      "message0": " %1",
+      "args0": [
+        {
+          "type": "field_label_serializable",
+          "name": "VALUE",
+          "text": ""
+        }
+      ],
+      "extensions": ["colours_more", "output_boolean"]
+    });
+  },
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterUpdateDisplay,
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterDomToMutation
+};
+
+Blockly.Blocks['argument_reporter_string_number'] = {
+  init: function() {
+    this.jsonInit({ 
+      "message0": " %1",
+      "args0": [
+        {
+          "type": "field_label_serializable",
+          "name": "VALUE",
+          "text": ""
+        }
+      ],
+      "extensions": ["colours_more", "output_number", "output_string"]
+    });
+  },
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterUpdateDisplay,
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterDomToMutation
+};
+
+Blockly.Blocks['argument_reporter_command'] = {
+  init: function () {
+    this.jsonInit({ "message0": " %1",
+      "args0": [
+        {
+          "type": "field_label_serializable",
+          "name": "VALUE",
+          "text": ""
+        }
+      ],
+      "canDragDuplicate": true,
+      "extensions": ["colours_more", "shape_statement"],
+    });
+  },
+  updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterUpdateDisplay,
+  mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterMutationToDom,
+  domToMutation: Blockly.ScratchBlocks.ProcedureUtils.argumentReporterDomToMutation
+};
+
+Blockly.Blocks['argument_editor_boolean'] = {
+  init: function() {
+    this.jsonInit({ "message0": " %1",
+      "args0": [
+        {
+          "type": "field_input_removable",
+          "name": "TEXT",
+          "text": "foo"
+        }
+      ],
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField,
+      "extensions": ["output_boolean"]
+    });
+  },
+  // Exist on declaration and arguments editors, with different implementations.
+  removeFieldCallback: Blockly.ScratchBlocks.ProcedureUtils.removeArgumentCallback_
+};
+
+Blockly.Blocks['argument_editor_string_number'] = {
+  init: function() {
+    this.jsonInit({ "message0": " %1",
+      "args0": [
+        {
+          "type": "field_input_removable",
+          "name": "TEXT",
+          "text": "foo"
+        }
+      ],
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField,
+      "extensions": ["output_number", "output_string"]
+    });
+  },
+  // Exist on declaration and arguments editors, with different implementations.
+  removeFieldCallback: Blockly.ScratchBlocks.ProcedureUtils.removeArgumentCallback_
+};
+
+Blockly.Blocks['argument_editor_command'] = {
+  init: function () {
+    this.jsonInit({ "message0": " %1",
+      "args0": [
+        {
+          "type": "field_input_removable",
+          "name": "TEXT",
+          "text": "foo"
+        }
+      ],
+      "colour": Blockly.Colours.textField,
+      "colourSecondary": Blockly.Colours.textField,
+      "colourTertiary": Blockly.Colours.textField,
+      "extensions": ["colours_more", "shape_statement"],
+    });
+  },
+  // Exist on declaration and arguments editors, with different implementations.
+  removeFieldCallback: Blockly.ScratchBlocks.ProcedureUtils.removeArgumentCallback_,
+};
+
+Blockly.Blocks['procedures_set'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'set %1 to %2',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "PARAM"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "extensions": ["colours_more", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['procedures_return'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'return %1',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "return"
+        }
+      ],
+      "extensions": ["colours_more", "shape_end"]
+    });
+  }
+};

blocks_vertical/sensing.js

@@ -0,0 +1,1158 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.sensing');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+
+Blockly.Blocks['sensing_touchingobject'] = {
+  /**
+   * Block to Report if its touching a Object.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_TOUCHINGOBJECT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TOUCHINGOBJECTMENU"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_objecttouchingclonesprite'] = {
+  /**
+   * pm: Block to Report if an Object is touching a clone of another sprite.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 touching clone of %2?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FULLTOUCHINGOBJECTMENU"
+        },
+        {
+          "type": "input_value",
+          "name": "SPRITETOUCHINGOBJECTMENU"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_objecttouchingobject'] = {
+  /**
+   * pm" Block to Report if an Object is touching another Object.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1 touching %2?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FULLTOUCHINGOBJECTMENU"
+        },
+        {
+          "type": "input_value",
+          "name": "SPRITETOUCHINGOBJECTMENU"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_touchingobjectmenu'] = {
+  /**
+   * "Touching [Object]" Block Menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "TOUCHINGOBJECTMENU",
+          "options": [
+            [Blockly.Msg.SENSING_TOUCHINGOBJECT_POINTER, '_mouse_'],
+            [Blockly.Msg.SENSING_TOUCHINGOBJECT_EDGE, '_edge_']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fulltouchingobjectmenu'] = {
+  /**
+   * pm: "Touching [Object]" Block Menu with more options.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "FULLTOUCHINGOBJECTMENU",
+          "options": [
+            ["mouse-pointer", '_mouse_'],
+            ["edge", '_edge_'],
+            ["this sprite", '_myself_']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_touchingobjectmenusprites'] = {
+  /**
+   * pm: "Touching [Object]" Block Menu with sprite options.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "SPRITETOUCHINGOBJECTMENU",
+          "options": [
+            ["this sprite", '_myself_']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_touchingcolor'] = {
+  /**
+   * Block to Report if its touching a certain Color.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_TOUCHINGCOLOR,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "COLOR"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_coloristouchingcolor'] = {
+  /**
+   * Block to Report if a color is touching a certain Color.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_COLORISTOUCHINGCOLOR,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "COLOR"
+        },
+        {
+          "type": "input_value",
+          "name": "COLOR2"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_distanceto'] = {
+  /**
+   * Block to Report distance to another Object.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_DISTANCETO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "DISTANCETOMENU"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_distancetomenu'] = {
+  /**
+   * "Distance to [Object]" Block Menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "DISTANCETOMENU",
+          "options": [
+            [Blockly.Msg.SENSING_DISTANCETO_POINTER, '_mouse_']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_askandwait'] = {
+  /**
+   * Block to ask a question and wait
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_ASKANDWAIT,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "QUESTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_answer'] = {
+  /**
+   * Block to report answer
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_ANSWER,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_keypressed'] = {
+  /**
+   * Block to Report if a key is pressed.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_KEYPRESSED,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "KEY_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_keyhit'] = {
+  /**
+   * pm: Block to Report if a key is hit on the same tick.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "key %1 hit?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "KEY_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_mousescrolling'] = {
+  /**
+   * pm: Block to report if the mouse is scrolling in a direction.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "is mouse scrolling %1?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SCROLL_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_scrolldirections'] = {
+  /**
+   * pm: Options for scroll direction
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "SCROLL_OPTION",
+          "options": [
+            ['up', 'up'],
+            ['down', 'down']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_keyoptions'] = {
+  /**
+   * Options for Keys
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "KEY_OPTION",
+          "options": [
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_SPACE, 'space'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_UP, 'up arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_DOWN, 'down arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_RIGHT, 'right arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_LEFT, 'left arrow'],
+            [Blockly.Msg.EVENT_WHENKEYPRESSED_ANY, 'any'],
+            ['a', 'a'],
+            ['b', 'b'],
+            ['c', 'c'],
+            ['d', 'd'],
+            ['e', 'e'],
+            ['f', 'f'],
+            ['g', 'g'],
+            ['h', 'h'],
+            ['i', 'i'],
+            ['j', 'j'],
+            ['k', 'k'],
+            ['l', 'l'],
+            ['m', 'm'],
+            ['n', 'n'],
+            ['o', 'o'],
+            ['p', 'p'],
+            ['q', 'q'],
+            ['r', 'r'],
+            ['s', 's'],
+            ['t', 't'],
+            ['u', 'u'],
+            ['v', 'v'],
+            ['w', 'w'],
+            ['x', 'x'],
+            ['y', 'y'],
+            ['z', 'z'],
+            ['0', '0'],
+            ['1', '1'],
+            ['2', '2'],
+            ['3', '3'],
+            ['4', '4'],
+            ['5', '5'],
+            ['6', '6'],
+            ['7', '7'],
+            ['8', '8'],
+            ['9', '9']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fingeroptions'] = {
+  /**
+   * pm: Options for Fingers
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "FINGER_OPTION",
+          "options": [
+            ['1', '1'],
+            ['2', '2'],
+            ['3', '3'],
+            ['4', '4'],
+            ['5', '5']
+          ]
+        }
+      ],
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_mousedown'] = {
+  /**
+   * Block to Report if the mouse is down.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_MOUSEDOWN,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_mouseclicked'] = {
+  /**
+   * pm: Block to Report if the mouse is clicked on the same tick.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "mouse clicked?",
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fingerdown'] = {
+  /**
+   * pm: Block to Report if the specified finger is down.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "finger %1 down?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FINGER_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fingertapped'] = {
+  /**
+   * pm: Block to Report if the specified finger has tapped on this frame.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "finger %1 tapped?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FINGER_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_mousex'] = {
+  /**
+   * Block to report mouse's x position
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_MOUSEX,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_mousey'] = {
+  /**
+   * Block to report mouse's y position
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_MOUSEY,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fingerx'] = {
+  /**
+   * pm: Block to report finger #<options>'s x position
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "finger %1 x",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FINGER_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_fingery'] = {
+  /**
+   * pm: Block to report finger #<options>'s y position
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "finger %1 y",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "FINGER_OPTION"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_setclipboard'] = {
+  /**
+   * pm: Block to add an item to the Clipboard
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_ADDTOCLIPBOARD,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "ITEM"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_getclipboard'] = {
+  /**
+   * pm: Block to report the current item in the Clipboard
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_CLIPBOARDITEM,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_setdragmode'] = {
+  /**
+   * Block to set drag mode.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_SETDRAGMODE,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "DRAG_MODE",
+          "options": [
+            [Blockly.Msg.SENSING_SETDRAGMODE_DRAGGABLE, 'draggable'],
+            [Blockly.Msg.SENSING_SETDRAGMODE_NOTDRAGGABLE, 'not draggable']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_getdragmode'] = {
+  /**
+   * pm: Block to report drag mode.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "draggable?",
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_loudness'] = {
+  /**
+   * Block to report loudness
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_LOUDNESS,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_loud'] = {
+  /**
+   * Block to report if the loudness is "loud" (greater than 10). This is an
+   * obsolete block that is implemented for compatibility with Scratch 2.0 and
+   * 1.4 projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_LOUD,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_timer'] = {
+  /**
+   * Block to report timer
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_TIMER,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_resettimer'] = {
+  /**
+   * Block to reset timer
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_RESETTIMER,
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_of_object_menu'] = {
+  /**
+   * "* of _" object menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "OBJECT",
+          "options": [
+            ['Sprite1', 'Sprite1'],
+            ['Stage', '_stage_']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+
+Blockly.Blocks['sensing_of'] = {
+  /**
+   * Block to report properties of sprites.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_OF,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "PROPERTY",
+          "options": [
+            [Blockly.Msg.SENSING_OF_XPOSITION, 'x position'],
+            [Blockly.Msg.SENSING_OF_YPOSITION, 'y position'],
+            [Blockly.Msg.SENSING_OF_DIRECTION, 'direction'],
+            [Blockly.Msg.SENSING_OF_COSTUMENUMBER, 'costume #'],
+            [Blockly.Msg.SENSING_OF_COSTUMENAME, 'costume name'],
+            [Blockly.Msg.SENSING_OF_SIZE, 'size'],
+            [Blockly.Msg.SENSING_OF_VOLUME, 'volume'],
+            [Blockly.Msg.SENSING_OF_BACKDROPNUMBER, 'backdrop #'],
+            [Blockly.Msg.SENSING_OF_BACKDROPNAME, 'backdrop name']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "OBJECT"
+        }
+      ],
+      "output": true,
+      "category": Blockly.Categories.sensing,
+      "outputShape": Blockly.OUTPUT_SHAPE_ROUND,
+      "extensions": ["colours_sensing"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_current'] = {
+  /**
+   * Block to Report the current option.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_CURRENT,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "CURRENTMENU",
+          "options": [
+            [Blockly.Msg.SENSING_CURRENT_YEAR, 'YEAR'],
+            [Blockly.Msg.SENSING_CURRENT_MONTH, 'MONTH'],
+            [Blockly.Msg.SENSING_CURRENT_DATE, 'DATE'],
+            [Blockly.Msg.SENSING_CURRENT_DAYOFWEEK, 'DAYOFWEEK'],
+            [Blockly.Msg.SENSING_CURRENT_HOUR, 'HOUR'],
+            [Blockly.Msg.SENSING_CURRENT_MINUTE, 'MINUTE'],
+            [Blockly.Msg.SENSING_CURRENT_SECOND, 'SECOND'],
+            ['js timestamp', 'TIMESTAMP']
+          ]
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_dayssince2000'] = {
+  /**
+   * Block to report days since 2000
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_DAYSSINCE2000,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_username'] = {
+  /**
+   * Block to report user's username
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_USERNAME,
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_loggedin'] = {
+  /**
+   * pm: Block to report if a user is logged in.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": 'logged in?',
+      "category": Blockly.Categories.sensing,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_userid'] = {
+  /**
+   * Block to report user's ID. Does not actually do anything. This is an
+   * obsolete block that is implemented for compatibility with Scratch 2.0
+   * projects.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SENSING_USERID,
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_regextest"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "test regex %2 %3 with text %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "text"
+        },
+        {
+          "type": "input_value",
+          "name": "reg"
+        },
+        {
+          "type": "input_value",
+          "name": "regrule"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_thing_is_number"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 is number?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_thing_has_text"] = {
+  init: function () {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 has text?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_thing_has_number"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 has number?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_mobile"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "mobile?",
+      "args0": [],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks["sensing_thing_is_text"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 is text?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "TEXT1"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+
+
+Blockly.Blocks["sensing_getspritewithattrib"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "get sprite with %1 set to %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "var"
+        },
+        {
+          "type": "input_value",
+          "name": "val"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_distanceTo'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'distance from %1 %2 to %3 %4',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "x1"
+        },
+        {
+          "type": "input_value",
+          "name": "y1"
+        },
+        {
+          "type": "input_value",
+          "name": "x2"
+        },
+        {
+          "type": "input_value",
+          "name": "y2"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_directionTo'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'direction to %1 %2 from %3 %4',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "x2"
+        },
+        {
+          "type": "input_value",
+          "name": "y2"
+        },
+        {
+          "type": "input_value",
+          "name": "x1"
+        },
+        {
+          "type": "input_value",
+          "name": "y1"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_isUpperCase'] = {
+  init: function() {
+    this.jsonInit({
+      "message0": 'is character %1 uppercase?',
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "text"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_boolean"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_getoperatingsystem'] = {
+  /**
+   * pm: Block to report the users Operating System
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "operating system",
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_getbrowser'] = {
+  /**
+   * pm: Block to report the users Operating System
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "browser",
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_geturl'] = {
+  /**
+   * pm: Block to report the users Operating System
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "url",
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sensing_getxyoftouchingsprite'] = {
+  /**
+   * Block to set drag mode.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1 of touching %2 point",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "XY",
+          "options": [
+            ['x', 'x'],
+            ['y', 'y']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "SPRITE"
+        }
+      ],
+      "category": Blockly.Categories.sensing,
+      "extensions": ["colours_sensing", "output_number"]
+    });
+  }
+};

blocks_vertical/sound.js

@@ -0,0 +1,494 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 Massachusetts Institute of Technology
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+'use strict';
+
+goog.provide('Blockly.Blocks.sound');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+goog.require('Blockly.ScratchBlocks.VerticalExtensions');
+
+Blockly.Blocks['sound_sounds_menu'] = {
+  /**
+   * Sound effects drop-down menu.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "%1",
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "SOUND_MENU",
+          "options": [
+            ['1', '0'],
+            ['2', '1'],
+            ['3', '2'],
+            ['4', '3'],
+            ['5', '4'],
+            ['6', '5'],
+            ['7', '6'],
+            ['8', '7'],
+            ['9', '8'],
+            ['10', '9'],
+            ['call a function', function() {
+              window.alert('function called!');}
+            ]
+          ]
+        }
+      ],
+      "colour": Blockly.Colours.sounds.secondary,
+      "colourSecondary": Blockly.Colours.sounds.secondary,
+      "colourTertiary": Blockly.Colours.sounds.tertiary,
+      "extensions": ["output_string"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_play'] = {
+  /**
+   * Block to play sound.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_PLAY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_playuntildone'] = {
+  /**
+   * Block to play sound until done.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_PLAYUNTILDONE,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_stop'] = {
+  /**
+   * pm: Block to stop a sound.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "stop sound %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_pause'] = {
+  /**
+   * pm: Block to pause a sound.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "pause sound %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_set_stop_fadeout_to'] = {
+  /**
+   * pm: Block to set the fadeout time on a sound.
+   * The fadeout time is used when the sound is stopped in any way.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "set fade out to %1 seconds on %2",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        },
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_play_at_seconds'] = {
+  /**
+   * pm: Block to start a sound at a specific time position.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "start sound %1 at %2 seconds",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_play_at_seconds_until_done'] = {
+  /**
+   * pm: Block to start a sound at a specific time position.
+   * This block will wait until the sound is actually finished
+   * before continuing the stack.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "play sound %1 starting at %2 seconds until done",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_stopallsounds'] = {
+  /**
+   * Block to stop all sounds
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_STOPALLSOUNDS,
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_pauseallsounds'] = {
+  /**
+   * pm: Block to pause all sounds
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "pause all sounds",
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_playallsounds'] = {
+  /**
+   * pm: Block to play all sounds
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "play all sounds",
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_seteffectto'] = {
+  /**
+   * Block to set the audio effect
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_SETEFFECTO,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.SOUND_EFFECTS_PITCH, 'PITCH'],
+            [Blockly.Msg.SOUND_EFFECTS_PAN, 'PAN']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+
+Blockly.Blocks['sound_changeeffectby'] = {
+  /**
+   * Block to change the audio effect
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_CHANGEEFFECTBY,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.SOUND_EFFECTS_PITCH, 'PITCH'],
+            [Blockly.Msg.SOUND_EFFECTS_PAN, 'PAN']
+          ]
+        },
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_cleareffects'] = {
+  /**
+   * Block to clear audio effects
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_CLEAREFFECTS,
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_getEffectValue'] = {
+  /**
+   * pm: Block to report sound effect values
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "message0": "%1 effect",
+      "checkboxInFlyout": true,
+      "category": Blockly.Categories.sound,
+      "args0": [
+        {
+          "type": "field_dropdown",
+          "name": "EFFECT",
+          "options": [
+            [Blockly.Msg.SOUND_EFFECTS_PITCH, 'PITCH'],
+            [Blockly.Msg.SOUND_EFFECTS_PAN, 'PAN']
+          ]
+        }
+      ],
+      "extensions": ["colours_sounds", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_changevolumeby'] = {
+  /**
+   * Block to change the sprite's volume by a certain value
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_CHANGEVOLUMEBY,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VOLUME"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_setvolumeto'] = {
+  /**
+   * Block to set the sprite's volume to a certain percent
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_SETVOLUMETO,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VOLUME"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "shape_statement"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_volume'] = {
+  /**
+   * Block to report volume
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.SOUND_VOLUME,
+      "category": Blockly.Categories.sound,
+      "checkboxInFlyout": true,
+      "extensions": ["colours_sounds", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks["sound_isSoundPlaying"] = {
+  init: function() {
+    this.jsonInit({
+      "inputsInline": true,
+      "category": Blockly.Categories.sound,
+      "message0": "is %1 playing?",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "extensions": [
+        "output_boolean",
+        "colours_sounds"
+      ]
+    });
+  }
+};
+
+Blockly.Blocks['sound_getLength'] = {
+  /**
+   * pm: Block to report the length of a sound.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.jsonInit({
+      "message0": "length of %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_getTimePosition'] = {
+  /**
+   * pm: Block to report the current time position of a sound.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "current time position of %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "output_number"]
+    });
+  }
+};
+
+Blockly.Blocks['sound_getSoundVolume'] = {
+  /**
+   * pm: Block to report the volume of a sound at the current position.
+   * @this Blockly.Block
+   */
+  init: function () {
+    this.jsonInit({
+      "message0": "current volume of %1",
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "SOUND_MENU"
+        }
+      ],
+      "category": Blockly.Categories.sound,
+      "extensions": ["colours_sounds", "output_number"]
+    });
+  }
+};

blocks_vertical/vertical_extensions.js

@@ -0,0 +1,295 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2017 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.
+ */
+
+/**
+ * @fileoverview Extensions for vertical blocks in scratch-blocks.
+ * The following extensions can be used to describe a block in Scratch terms.
+ * For instance, a block in the operators colour scheme with a number output
+ * would have the "colours_operators" and "output_number" extensions.
+ * @author [email protected] (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.ScratchBlocks.VerticalExtensions');
+
+goog.require('Blockly.Colours');
+goog.require('Blockly.constants');
+
+
+/**
+ * Helper function that generates an extension based on a category name.
+ * The generated function will set primary, secondary, and tertiary colours
+ * based on the category name.
+ * @param {String} category The name of the category to set colours for.
+ * @return {function} An extension function that sets colours based on the given
+ *     category.
+ */
+Blockly.ScratchBlocks.VerticalExtensions.colourHelper = function(category) {
+  var colours = Blockly.Colours[category];
+  if (!(colours && colours.primary && colours.secondary && colours.tertiary)) {
+    throw new Error('Could not find colours for category "' + category + '"');
+  }
+  /**
+   * Set the primary, secondary, and tertiary colours on this block for the
+   * given category.
+   * @this {Blockly.Block}
+   */
+  return function() {
+    this.setColourFromRawValues_(colours.primary, colours.secondary,
+        colours.tertiary);
+  };
+};
+
+/**
+ * Extension to set the colours of a text field, which are all the same.
+ */
+Blockly.ScratchBlocks.VerticalExtensions.COLOUR_TEXTFIELD = function() {
+  this.setColourFromRawValues_(Blockly.Colours.textField,
+      Blockly.Colours.textField, Blockly.Colours.textField);
+};
+
+/**
+ * Extension to make a block fit into a stack of statements, regardless of its
+ * inputs.  That means the block should have a previous connection and a next
+ * connection and have inline inputs.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.SHAPE_PROCEDURE = function() {
+  this.setInputsInline(true);
+  this.setPreviousStatement(true, 'procedure');
+  this.setNextStatement(true, 'procedure');
+};
+
+/**
+ * Extension to make a block fit into a stack of statements, regardless of its
+ * inputs.  That means the block should have a previous connection and a next
+ * connection and have inline inputs.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.SHAPE_CASE = function() {
+  this.setInputsInline(true);
+  this.setPreviousStatement(true, 'switchCase');
+  this.setNextStatement(true, 'switchCase');
+};
+
+/**
+ * Extension to make a block fit into a stack of statements, regardless of its
+ * inputs.  That means the block should have a previous connection and a next
+ * connection and have inline inputs.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.SHAPE_STATEMENT = function() {
+  this.setInputsInline(true);
+  this.setPreviousStatement(true, 'normal');
+  this.setNextStatement(true, 'normal');
+};
+
+/**
+ * Extension to make a block be shaped as a hat block, regardless of its
+ * inputs.  That means the block should have a next connection and have inline
+ * inputs, but have no previous connection.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.SHAPE_HAT = function() {
+  this.setInputsInline(true);
+  this.setNextStatement(true, 'normal');
+};
+
+/**
+ * Extension to make a block be shaped as an end block, regardless of its
+ * inputs.  That means the block should have a previous connection and have
+ * inline inputs, but have no next connection.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.SHAPE_END = function() {
+  this.setInputsInline(true);
+  this.setPreviousStatement(true, 'normal');
+};
+
+/**
+ * Extension to make represent a number reporter in Scratch-Blocks.
+ * That means the block has inline inputs, a round output shape, and a 'Number'
+ * output type.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_NUMBER = function() {
+  this.setInputsInline(true);
+  this.setOutputShape(Blockly.OUTPUT_SHAPE_ROUND);
+  this.setOutput(true, 'Number');
+};
+
+/**
+ * Extension to make represent a string reporter in Scratch-Blocks.
+ * That means the block has inline inputs, a round output shape, and a 'String'
+ * output type.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_STRING = function() {
+  this.setInputsInline(true);
+  this.setOutputShape(Blockly.OUTPUT_SHAPE_ROUND);
+  this.setOutput(true, 'String');
+};
+
+/**
+ * Extension to make represent a boolean reporter in Scratch-Blocks.
+ * That means the block has inline inputs, a round output shape, and a 'Boolean'
+ * output type.
+ * @this {Blockly.Block}
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_BOOLEAN = function() {
+  this.setInputsInline(true);
+  this.setOutputShape(Blockly.OUTPUT_SHAPE_HEXAGONAL);
+  this.setOutput(true, 'Boolean');
+};
+
+/**
+ * Mixin to add a context menu for a procedure definition block.
+ * It adds the "edit" option and removes the "duplicate" option.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.PROCEDURE_DEF_CONTEXTMENU = {
+  /**
+   * Add the "edit" option and removes the "duplicate" option from the context
+   * menu.
+   * @param {!Array.<!Object>} menuOptions List of menu options to edit.
+   * @this Blockly.Block
+   */
+  customContextMenu: function(menuOptions) {
+    // Add the edit option at the end.
+    menuOptions.push(Blockly.Procedures.makeEditOption(this));
+
+    // Find the delete option and update its callback to be specific to
+    // functions.
+    for (var i = 0, option; option = menuOptions[i]; i++) {
+      if (option.text == Blockly.Msg.DELETE_BLOCK) {
+        var input = this.getInput('custom_block');
+        // this is the root block, not the shadow block.
+        if (input && input.connection && input.connection.targetBlock()) {
+          var procCode = input.connection.targetBlock().getProcCode();
+        } else {
+          return;
+        }
+        var rootBlock = this;
+        option.callback = function() {
+          var didDelete = Blockly.Procedures.deleteProcedureDefCallback(
+              procCode, rootBlock);
+          if (!didDelete) {
+            alert(Blockly.Msg.PROCEDURE_USED);
+          }
+        };
+      }
+    }
+    // Find and remove the duplicate option
+    for (var i = 0, option; option = menuOptions[i]; i++) {
+      if (option.text == Blockly.Msg.DUPLICATE) {
+        menuOptions.splice(i, 1);
+        break;
+      }
+    }
+  }
+};
+
+/**
+ * Mixin to add a context menu for a procedure call block.
+ * It adds the "edit" option and the "define" option.
+ * @mixin
+ * @augments Blockly.Block
+ * @package
+ * @readonly
+ */
+Blockly.ScratchBlocks.VerticalExtensions.PROCEDURE_CALL_CONTEXTMENU = {
+  /**
+   * Add the "edit" option to the context menu.
+   * @todo Add "go to definition" option once implemented.
+   * @param {!Array.<!Object>} menuOptions List of menu options to edit.
+   * @this Blockly.Block
+   */
+  customContextMenu: function(menuOptions) {
+    menuOptions.push(Blockly.Procedures.makeEditOption(this));
+  }
+};
+
+
+Blockly.ScratchBlocks.VerticalExtensions.SCRATCH_EXTENSION = function() {
+  this.isScratchExtension = true;
+};
+
+/**
+ * Register all extensions for scratch-blocks.
+ * @package
+ */
+Blockly.ScratchBlocks.VerticalExtensions.registerAll = function() {
+  var categoryNames =
+      ['control', 'data', 'data_lists', 'sounds', 'motion', 'looks', 'event',
+        'sensing', 'pen', 'operators', 'more'];
+  // Register functions for all category colours.
+  for (var i = 0; i < categoryNames.length; i++) {
+    var name = categoryNames[i];
+    Blockly.Extensions.register('colours_' + name,
+        Blockly.ScratchBlocks.VerticalExtensions.colourHelper(name));
+  }
+
+  // Text fields transcend categories.
+  Blockly.Extensions.register('colours_textfield',
+      Blockly.ScratchBlocks.VerticalExtensions.COLOUR_TEXTFIELD);
+
+  // Register extensions for common block shapes.
+  Blockly.Extensions.register('shape_procedure',
+      Blockly.ScratchBlocks.VerticalExtensions.SHAPE_PROCEDURE);
+  Blockly.Extensions.register('shape_case',
+      Blockly.ScratchBlocks.VerticalExtensions.SHAPE_CASE);
+  Blockly.Extensions.register('shape_statement',
+      Blockly.ScratchBlocks.VerticalExtensions.SHAPE_STATEMENT);
+  Blockly.Extensions.register('shape_hat',
+      Blockly.ScratchBlocks.VerticalExtensions.SHAPE_HAT);
+  Blockly.Extensions.register('shape_end',
+      Blockly.ScratchBlocks.VerticalExtensions.SHAPE_END);
+
+  // Output shapes and types are related.
+  Blockly.Extensions.register('output_number',
+      Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_NUMBER);
+  Blockly.Extensions.register('output_string',
+      Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_STRING);
+  Blockly.Extensions.register('output_boolean',
+      Blockly.ScratchBlocks.VerticalExtensions.OUTPUT_BOOLEAN);
+
+  // Custom procedures have interesting context menus.
+  Blockly.Extensions.registerMixin('procedure_def_contextmenu',
+      Blockly.ScratchBlocks.VerticalExtensions.PROCEDURE_DEF_CONTEXTMENU);
+  Blockly.Extensions.registerMixin('procedure_call_contextmenu',
+      Blockly.ScratchBlocks.VerticalExtensions.PROCEDURE_CALL_CONTEXTMENU);
+
+  // Extension blocks have slightly different block rendering.
+  Blockly.Extensions.register('scratch_extension',
+      Blockly.ScratchBlocks.VerticalExtensions.SCRATCH_EXTENSION);
+};
+
+Blockly.ScratchBlocks.VerticalExtensions.registerAll();

build.py

@@ -0,0 +1,608 @@
+#!/usr/bin/python2.7
+# Compresses the core Blockly files into a single JavaScript file.
+#
+# 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.
+
+# This script generates two versions of Blockly's core files:
+#   blockly_compressed.js
+#   blockly_uncompressed.js
+# The compressed file is a concatenation of all of Blockly's core files which
+# have been run through Google's Closure Compiler.  This is done using the
+# online API (which takes a few seconds and requires an Internet connection).
+# The uncompressed file is a script that loads in each of Blockly's core files
+# one by one.  This takes much longer for a browser to load, but is useful
+# when debugging code since line numbers are meaningful and variables haven't
+# been renamed.  The uncompressed file also allows for a faster developement
+# cycle since there is no need to rebuild or recompile, just reload.
+#
+# This script also generates:
+#   blocks_compressed.js: The compressed common blocks.
+#   blocks_vertical_compressed.js: The compressed Scratch vertical blocks.
+#   msg/js/<LANG>.js for every language <LANG> defined in msg/js/<LANG>.json.
+
+import sys
+if sys.version_info[0] != 2:
+  raise Exception("Blockly build only compatible with Python 2.x.\n"
+                  "You are using: " + sys.version)
+
+import errno, glob, httplib, json, os, re, subprocess, threading, urllib
+
+REMOTE_COMPILER = "remote"
+
+CLOSURE_DIR = os.path.pardir
+CLOSURE_ROOT = os.path.pardir
+CLOSURE_LIBRARY = "closure-library"
+CLOSURE_COMPILER = REMOTE_COMPILER
+
+CLOSURE_DIR_NPM = "node_modules"
+CLOSURE_ROOT_NPM = os.path.join("node_modules")
+CLOSURE_LIBRARY_NPM = "google-closure-library"
+CLOSURE_COMPILER_NPM = ("google-closure-compiler.cmd" if os.name == "nt" else "google-closure-compiler")
+
+def import_path(fullpath):
+  """Import a file with full path specification.
+  Allows one to import from any directory, something __import__ does not do.
+
+  Args:
+      fullpath:  Path and filename of import.
+
+  Returns:
+      An imported module.
+  """
+  path, filename = os.path.split(fullpath)
+  filename, ext = os.path.splitext(filename)
+  sys.path.append(path)
+  module = __import__(filename)
+  reload(module)  # Might be out of date.
+  del sys.path[-1]
+  return module
+
+def read(filename):
+    f = open(filename)
+    content = "".join(f.readlines())
+    f.close()
+    return content
+
+HEADER = ("// Do not edit this file; automatically generated by build.py.\n"
+          "'use strict';\n")
+
+
+class Gen_uncompressed(threading.Thread):
+  """Generate a JavaScript file that loads Blockly's raw files.
+  Runs in a separate thread.
+  """
+  def __init__(self, search_paths, vertical, closure_env):
+    threading.Thread.__init__(self)
+    self.search_paths = search_paths
+    self.vertical = vertical
+    self.closure_env = closure_env
+
+  def run(self):
+    target_filename = 'blockly_uncompressed_vertical.js'
+    f = open(target_filename, 'w')
+    f.write(HEADER)
+    f.write(self.format_js("""
+var isNodeJS = !!(typeof module !== 'undefined' && module.exports &&
+                  typeof window === 'undefined');
+
+if (isNodeJS) {
+  var window = {};
+  require('{closure_library}');
+}
+
+window.BLOCKLY_DIR = (function() {
+  if (!isNodeJS) {
+    // Find name of current directory.
+    var scripts = document.getElementsByTagName('script');
+    var re = new RegExp('(.+)[\/]blockly_uncompressed_vertical\.js$');
+    for (var i = 0, script; script = scripts[i]; i++) {
+      var match = re.exec(script.src);
+      if (match) {
+        return match[1];
+      }
+    }
+    alert('Could not detect Blockly\\'s directory name.');
+  }
+  return '';
+})();
+
+window.BLOCKLY_BOOT = function() {
+  var dir = '';
+  if (isNodeJS) {
+    require('{closure_library}');
+    dir = 'blockly';
+  } else {
+    // Execute after Closure has loaded.
+    if (!window.goog) {
+      alert('Error: Closure not found.  Read this:\\n' +
+            'developers.google.com/blockly/guides/modify/web/closure');
+    }
+    if (window.BLOCKLY_DIR.search(/node_modules/)) {
+      dir = '..';
+    } else {
+      dir = window.BLOCKLY_DIR.match(/[^\\/]+$/)[0];
+    }
+  }
+"""))
+    add_dependency = []
+    base_path = calcdeps.FindClosureBasePath(self.search_paths)
+    for dep in calcdeps.BuildDependenciesFromFiles(self.search_paths):
+      add_dependency.append(calcdeps.GetDepsLine(dep, base_path))
+    add_dependency.sort()  # Deterministic build.
+    add_dependency = '\n'.join(add_dependency)
+    # Find the Blockly directory name and replace it with a JS variable.
+    # This allows blockly_uncompressed.js to be compiled on one computer and be
+    # used on another, even if the directory name differs.
+    m = re.search('[\\/]([^\\/]+)[\\/]core[\\/]blockly.js', add_dependency)
+    add_dependency = re.sub('([\\/])' + re.escape(m.group(1)) +
+        '([\\/]core[\\/])', '\\1" + dir + "\\2', add_dependency)
+    f.write(add_dependency + '\n')
+
+    provides = []
+    for dep in calcdeps.BuildDependenciesFromFiles(self.search_paths):
+      # starts with '../' or 'node_modules/'
+      if not dep.filename.startswith(self.closure_env["closure_root"] + os.sep):
+        provides.extend(dep.provides)
+    provides.sort()  # Deterministic build.
+    f.write('\n')
+    f.write('// Load Blockly.\n')
+    for provide in provides:
+      f.write("goog.require('%s');\n" % provide)
+
+    f.write(self.format_js("""
+delete this.BLOCKLY_DIR;
+delete this.BLOCKLY_BOOT;
+};
+
+if (isNodeJS) {
+  window.BLOCKLY_BOOT();
+  module.exports = Blockly;
+} else {
+  // Delete any existing Closure (e.g. Soy's nogoog_shim).
+  document.write('<script>var goog = undefined;</script>');
+  // Load fresh Closure Library.
+  document.write('<script src="' + window.BLOCKLY_DIR +
+      '/{closure_dir}/{closure_library}/closure/goog/base.js"></script>');
+  document.write('<script>window.BLOCKLY_BOOT();</script>');
+}
+"""))
+    f.close()
+    print("SUCCESS: " + target_filename)
+
+  def format_js(self, code):
+    """Format JS in a way that python's format method can work with to not
+    consider brace-wrapped sections to be format replacements while still
+    replacing known keys.
+    """
+
+    key_whitelist = self.closure_env.keys()
+
+    keys_pipe_separated = reduce(lambda accum, key: accum + "|" + key, key_whitelist)
+    begin_brace = re.compile(r"\{(?!%s)" % (keys_pipe_separated,))
+
+    end_brace = re.compile(r"\}")
+    def end_replacement(match):
+      try:
+        maybe_key = match.string[match.string[:match.start()].rindex("{") + 1:match.start()]
+      except ValueError:
+        return "}}"
+
+      if maybe_key and maybe_key in key_whitelist:
+        return "}"
+      else:
+        return "}}"
+
+    return begin_brace.sub("{{", end_brace.sub(end_replacement, code)).format(**self.closure_env)
+
+class Gen_compressed(threading.Thread):
+  """Generate a JavaScript file that contains all of Blockly's core and all
+  required parts of Closure, compiled together.
+  Uses the Closure Compiler's online API.
+  Runs in a separate thread.
+  """
+  def __init__(self, search_paths_vertical, closure_env):
+    threading.Thread.__init__(self)
+    self.search_paths_vertical = search_paths_vertical
+    self.closure_env = closure_env
+
+  def run(self):
+    self.gen_core(True)
+    self.gen_core(False)
+    self.gen_blocks("vertical")
+    self.gen_blocks("common")
+
+  def gen_core(self, vertical):
+    target_filename = 'blockly_compressed_vertical.js'
+    search_paths = self.search_paths_vertical
+    # Define the parameters for the POST request.
+    params = [
+      ("compilation_level", "SIMPLE"),
+
+      # remote will filter this out
+      ("language_in", "ECMASCRIPT_2017"),
+      ("language_out", "ECMASCRIPT5"),
+      ("rewrite_polyfills", "false"),
+      ("define", "goog.DEBUG=false"),
+
+      # local will filter this out
+      ("use_closure_library", "true"),
+    ]
+
+    # Read in all the source files.
+    filenames = calcdeps.CalculateDependencies(search_paths,
+      [os.path.join("core", "blockly.js")])
+    filenames.sort()  # Deterministic build.
+    for filename in filenames:
+      # Append filenames as false arguments the step before compiling will
+      # either transform them into arguments for local or remote compilation
+      params.append(("js_file", filename))
+
+    self.do_compile(params, target_filename, filenames, "")
+
+  def gen_blocks(self, block_type):
+    if block_type == "vertical":
+      target_filename = "blocks_compressed_vertical.js"
+      filenames = glob.glob(os.path.join("blocks_vertical", "*.js"))
+    elif block_type == "common":
+      target_filename = "blocks_compressed.js"
+      filenames = glob.glob(os.path.join("blocks_common", "*.js"))
+
+    # glob.glob ordering is platform-dependent and not necessary deterministic
+    filenames.sort()  # Deterministic build.
+
+    # Define the parameters for the POST request.
+    params = [
+      ("compilation_level", "SIMPLE"),
+    ]
+
+    # Read in all the source files.
+    # Add Blockly.Blocks to be compatible with the compiler.
+    params.append(("js_file", os.path.join("build", "gen_blocks.js")))
+    # Add Blockly.Colours for use of centralized colour bank
+    filenames.append(os.path.join("core", "colours.js"))
+    filenames.append(os.path.join("core", "constants.js"))
+
+    for filename in filenames:
+      # Append filenames as false arguments the step before compiling will
+      # either transform them into arguments for local or remote compilation
+      params.append(("js_file", filename))
+
+    # Remove Blockly.Blocks to be compatible with Blockly.
+    remove = "var Blockly={Blocks:{}};"
+    self.do_compile(params, target_filename, filenames, remove)
+
+  def do_compile(self, params, target_filename, filenames, remove):
+    if self.closure_env["closure_compiler"] == REMOTE_COMPILER:
+      do_compile = self.do_compile_remote
+    else:
+      do_compile = self.do_compile_local
+    json_data = do_compile(params, target_filename)
+
+    if self.report_errors(target_filename, filenames, json_data):
+      self.write_output(target_filename, remove, json_data)
+      self.report_stats(target_filename, json_data)
+
+  def do_compile_local(self, params, target_filename):
+      filter_keys = ["use_closure_library"]
+
+      # Drop arg if arg is js_file else add dashes
+      dash_params = []
+      for (arg, value) in params:
+        dash_params.append((value,) if arg == "js_file" else ("--" + arg, value))
+
+      # Flatten dash_params into dash_args if their keys are not in filter_keys
+      dash_args = []
+      for pair in dash_params:
+        if pair[0][2:] not in filter_keys:
+          dash_args.extend(pair)
+
+      # Build the final args array by prepending CLOSURE_COMPILER_NPM to
+      # dash_args and dropping any falsy members
+      args = []
+      for group in [[CLOSURE_COMPILER_NPM], dash_args]:
+        args.extend(filter(lambda item: item, group))
+
+      proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+      (stdout, stderr) = proc.communicate()
+
+      # Build the JSON response.
+      filesizes = [os.path.getsize(value) for (arg, value) in params if arg == "js_file"]
+      return dict(
+        compiledCode=stdout,
+        statistics=dict(
+          originalSize=reduce(lambda v, size: v + size, filesizes, 0),
+          compressedSize=len(stdout),
+        )
+      )
+
+  def do_compile_remote(self, params, target_filename):
+      filter_keys = [
+        "language_in",
+        "language_out",
+        "rewrite_polyfills",
+        "define",
+      ]
+
+      params.extend([
+        ("output_format", "json"),
+        ("output_info", "compiled_code"),
+        ("output_info", "warnings"),
+        ("output_info", "errors"),
+        ("output_info", "statistics"),
+      ])
+
+      # Send the request to Google.
+      remoteParams = []
+      for (arg, value) in params:
+        if not arg in filter_keys:
+          if arg == "js_file":
+            if not value.startswith(self.closure_env["closure_root"] + os.sep):
+              remoteParams.append(("js_code", read(value)))
+          # Change the normal compilation_level value SIMPLE to the remove
+          # service's SIMPLE_OPTIMIZATIONS
+          elif arg == "compilation_level" and value == "SIMPLE":
+            remoteParams.append((arg, "SIMPLE_OPTIMIZATIONS"))
+          else:
+            remoteParams.append((arg, value))
+
+      headers = {"Content-type": "application/x-www-form-urlencoded"}
+      conn = httplib.HTTPSConnection("closure-compiler.appspot.com")
+      conn.request("POST", "/compile", urllib.urlencode(remoteParams), headers)
+      response = conn.getresponse()
+      json_str = response.read()
+      conn.close()
+
+      # Parse the JSON response.
+      return json.loads(json_str)
+
+  def report_errors(self, target_filename, filenames, json_data):
+    def file_lookup(name):
+      if not name.startswith("Input_"):
+        return "???"
+      n = int(name[6:]) - 1
+      return filenames[n]
+
+    if json_data.has_key("serverErrors"):
+      errors = json_data["serverErrors"]
+      for error in errors:
+        print("SERVER ERROR: %s" % target_filename)
+        print(error["error"])
+    elif json_data.has_key("errors"):
+      errors = json_data["errors"]
+      for error in errors:
+        print("FATAL ERROR")
+        print(error["error"])
+        if error["file"]:
+          print("%s at line %d:" % (
+              file_lookup(error["file"]), error["lineno"]))
+          print(error["line"])
+          print((" " * error["charno"]) + "^")
+        sys.exit(1)
+    else:
+      if json_data.has_key("warnings"):
+        warnings = json_data["warnings"]
+        for warning in warnings:
+          print("WARNING")
+          print(warning["warning"])
+          if warning["file"]:
+            print("%s at line %d:" % (
+                file_lookup(warning["file"]), warning["lineno"]))
+            print(warning["line"])
+            print((" " * warning["charno"]) + "^")
+        print()
+
+      return True
+
+    return False
+
+  def write_output(self, target_filename, remove, json_data):
+      if not json_data.has_key("compiledCode"):
+        print("FATAL ERROR: Compiler did not return compiledCode.")
+        sys.exit(1)
+
+      code = HEADER + "\n" + json_data["compiledCode"]
+      code = code.replace(remove, "")
+
+      # Trim down Google's (and only Google's) Apache licences.
+      # The Closure Compiler preserves these.
+      LICENSE = re.compile("""/\\*
+
+ [\w ]+
+
+ Copyright \\d+ 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.
+\\*/""")
+      code = re.sub(LICENSE, "", code)
+
+      stats = json_data["statistics"]
+      original_b = stats["originalSize"]
+      compressed_b = stats["compressedSize"]
+      if original_b > 0 and compressed_b > 0:
+        f = open(target_filename, "w")
+        f.write(code)
+        f.close()
+
+  def report_stats(self, target_filename, json_data):
+      stats = json_data["statistics"]
+      original_b = stats["originalSize"]
+      compressed_b = stats["compressedSize"]
+      if original_b > 0 and compressed_b > 0:
+        original_kb = int(original_b / 1024 + 0.5)
+        compressed_kb = int(compressed_b / 1024 + 0.5)
+        ratio = int(float(compressed_b) / float(original_b) * 100 + 0.5)
+        print("SUCCESS: " + target_filename)
+        print("Size changed from %d KB to %d KB (%d%%)." % (
+            original_kb, compressed_kb, ratio))
+      else:
+        print("UNKNOWN ERROR")
+
+
+class Gen_langfiles(threading.Thread):
+  """Generate JavaScript file for each natural language supported.
+
+  Runs in a separate thread.
+  """
+
+  def __init__(self):
+    threading.Thread.__init__(self)
+
+  def _rebuild(self, srcs, dests):
+    # Determine whether any of the files in srcs is newer than any in dests.
+    try:
+      return (max(os.path.getmtime(src) for src in srcs) >
+              min(os.path.getmtime(dest) for dest in dests))
+    except OSError as e:
+      # Was a file not found?
+      if e.errno == errno.ENOENT:
+        # If it was a source file, we can't proceed.
+        if e.filename in srcs:
+          print("Source file missing: " + e.filename)
+          sys.exit(1)
+        else:
+          # If a destination file was missing, rebuild.
+          return True
+      else:
+        print("Error checking file creation times: " + e)
+
+  def run(self):
+    # The files msg/json/{en,qqq,synonyms}.json depend on msg/messages.js.
+    if self._rebuild([os.path.join("msg", "messages.js")],
+                     [os.path.join("msg", "json", f) for f in
+                      ["en.json", "qqq.json", "synonyms.json"]]):
+      try:
+        subprocess.check_call([
+            "python",
+            os.path.join("i18n", "js_to_json.py"),
+            "--input_file", "msg/messages.js",
+            "--output_dir", "msg/json/",
+            "--quiet"])
+      except (subprocess.CalledProcessError, OSError) as e:
+        # Documentation for subprocess.check_call says that CalledProcessError
+        # will be raised on failure, but I found that OSError is also possible.
+        print("Error running i18n/js_to_json.py: ", e)
+        sys.exit(1)
+
+    # Checking whether it is necessary to rebuild the js files would be a lot of
+    # work since we would have to compare each <lang>.json file with each
+    # <lang>.js file.  Rebuilding is easy and cheap, so just go ahead and do it.
+    try:
+      # Use create_messages.py to create .js files from .json files.
+      cmd = [
+          "python",
+          os.path.join("i18n", "create_messages.py"),
+          "--source_lang_file", os.path.join("msg", "json", "en.json"),
+          "--source_synonym_file", os.path.join("msg", "json", "synonyms.json"),
+          "--source_constants_file", os.path.join("msg", "json", "constants.json"),
+          "--key_file", os.path.join("msg", "json", "keys.json"),
+          "--output_dir", os.path.join("msg", "js"),
+          "--quiet"]
+      json_files = glob.glob(os.path.join("msg", "json", "*.json"))
+      json_files = [file for file in json_files if not
+                    (file.endswith(("keys.json", "synonyms.json", "qqq.json", "constants.json")))]
+      cmd.extend(json_files)
+      subprocess.check_call(cmd)
+    except (subprocess.CalledProcessError, OSError) as e:
+      print("Error running i18n/create_messages.py: ", e)
+      sys.exit(1)
+
+    # Output list of .js files created.
+    for f in json_files:
+      # This assumes the path to the current directory does not contain "json".
+      f = f.replace("json", "js")
+      if os.path.isfile(f):
+        print("SUCCESS: " + f)
+      else:
+        print("FAILED to create " + f)
+
+if __name__ == "__main__":
+  try:
+    closure_dir = CLOSURE_DIR_NPM
+    closure_root = CLOSURE_ROOT_NPM
+    closure_library = CLOSURE_LIBRARY_NPM
+    closure_compiler = CLOSURE_COMPILER_NPM
+
+    # Load calcdeps from the local library
+    calcdeps = import_path(os.path.join(
+        closure_root, closure_library, "closure", "bin", "calcdeps.py"))
+
+    # Sanity check the local compiler
+    test_args = [closure_compiler, os.path.join("build", "test_input.js")]
+    test_proc = subprocess.Popen(test_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    (stdout, _) = test_proc.communicate()
+    assert stdout == read(os.path.join("build", "test_expect.js"))
+
+    print("Using local compiler: %s ...\n" % CLOSURE_COMPILER_NPM)
+  except (ImportError, AssertionError):
+    print("Using remote compiler: closure-compiler.appspot.com ...\n")
+
+    try:
+      closure_dir = CLOSURE_DIR
+      closure_root = CLOSURE_ROOT
+      closure_library = CLOSURE_LIBRARY
+      closure_compiler = CLOSURE_COMPILER
+
+      calcdeps = import_path(os.path.join(
+          closure_root, closure_library, "closure", "bin", "calcdeps.py"))
+    except ImportError:
+      if os.path.isdir(os.path.join(os.path.pardir, "closure-library-read-only")):
+        # Dir got renamed when Closure moved from Google Code to GitHub in 2014.
+        print("Error: Closure directory needs to be renamed from"
+              "'closure-library-read-only' to 'closure-library'.\n"
+              "Please rename this directory.")
+      elif os.path.isdir(os.path.join(os.path.pardir, "google-closure-library")):
+        print("Error: Closure directory needs to be renamed from"
+             "'google-closure-library' to 'closure-library'.\n"
+             "Please rename this directory.")
+      else:
+        print("""Error: Closure not found.  Read this:
+  developers.google.com/blockly/guides/modify/web/closure""")
+      sys.exit(1)
+
+  search_paths = calcdeps.ExpandDirectories(
+      ["core", os.path.join(closure_root, closure_library)])
+
+  search_paths_vertical = search_paths
+
+  closure_env = {
+    "closure_dir": closure_dir,
+    "closure_root": closure_root,
+    "closure_library": closure_library,
+    "closure_compiler": closure_compiler,
+  }
+
+  # Run all tasks in parallel threads.
+  # Uncompressed is limited by processor speed.
+  # Compressed is limited by network and server speed.
+  # Vertical:
+  Gen_uncompressed(search_paths_vertical, True, closure_env).start()
+
+  # Compressed forms of vertical
+  Gen_compressed(search_paths_vertical, closure_env).start()
+
+  # This is run locally in a separate thread.
+  # Gen_langfiles().start()

build/gen_blocks.js

@@ -0,0 +1 @@
+goog.provide('Blockly.Blocks');

build/test_expect.js

@@ -0,0 +1 @@
+var Blockly={Blocks:{}};

build/test_input.js

@@ -0,0 +1 @@
+goog.provide('Blockly.Blocks');

cleanup.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+
+# Script for cleaning up blockly-specific files when merging blockly into scratch-blocks
+# Removes files and directories that scratch-blocks doesn't want.
+# Rachel Fenichel ([email protected])
+
+# Note: 'ours' is scratch-blocks, 'theirs' is blockly.
+
+# Formatting helpers.
+indent() { sed 's/^/  /'; }
+indent_more() { sed 's/^/\t/'; }
+empty_lines() { printf '\n\n'; }
+
+
+empty_lines
+echo Cleaning up a merge from Blockly to Scratch-Blocks...
+
+# Get rid of Blockly's internationalization/messages.  This is not usually worth
+# scrolling up to look at.
+empty_lines
+echo Cleaning up Blockly message files...
+# Turn on more powerful globbing
+shopt -s extglob
+
+# Having trouble with directories.  Let's just go there.
+cd msg/json
+git rm -f !(en.json|synonyms.json) | indent_more
+cd ../..
+
+# Having trouble with directories.  Let's just go there.
+cd msg/js
+git rm -f !(en.js) | indent_more
+cd ../..
+
+# Turn powerful globbing off again
+shopt -u extglob
+
+# Whole directories that we want to get rid of.
+empty_lines
+echo Removing blockly-specific directories...
+dirslist="accessible demos tests/generators appengine blocks local_build"
+for directory in $dirslist
+do
+  echo 'Cleaning up' $directory | indent
+  git rm -rf $directory | indent_more
+done
+
+# Scratch-blocks does not use generators
+empty_lines
+echo Removing generators...
+generated_langs="dart javascript lua php python"
+for lang in $generated_langs
+do
+  echo 'Cleaning up' $lang | indent
+  # Directories containing block generators.
+  git rm -rf generators/${lang} | indent_more
+done
+
+# Built stuff that we should get rid of.
+empty_lines
+echo Removing built files...
+built_files="blockly_compressed.js \
+blockly_uncompressed.js \
+blockly_accessible_compressed.js \
+blockly_accessible_uncompressed.js \
+blocks_compressed.js \
+dart_compressed.js \
+php_compressed.js \
+python_compressed.js \
+javascript_compressed.js \
+lua_compressed.js"
+
+for filename in $built_files
+do
+  git rm $filename | indent_more
+done
+
+empty_lines
+echo Miscellaneous cleanup...
+# Use ours.
+keep_ours=".github/ISSUE_TEMPLATE.md \
+.github/PULL_REQUEST_TEMPLATE.md \
+.gitignore \
+.travis.yml \
+core/block_animations.js \
+msg/messages.js \
+msg/js/en.js \
+msg/json/en.json"
+
+
+for filename in $keep_ours
+do
+  git checkout --ours $filename && git add $filename | indent_more
+done
+
+# Scratch-blocks has separate vertical and horizontal playgrounds and block
+# rendering.
+git rm -f tests/playground.html core/block_render_svg.js | indent_more
+
+empty_lines
+echo Done with cleanup.

core/block.js

@@ -0,0 +1,1841 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2011 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.
+ */
+
+/**
+ * @fileoverview The class representing one block.
+ * @author [email protected] (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Block');
+
+goog.require('Blockly.Blocks');
+goog.require('Blockly.Colours');
+goog.require('Blockly.Comment');
+goog.require('Blockly.ScratchBlockComment');
+goog.require('Blockly.Connection');
+goog.require('Blockly.Events.BlockChange');
+goog.require('Blockly.Events.BlockCreate');
+goog.require('Blockly.Events.BlockDelete');
+goog.require('Blockly.Events.BlockMove');
+goog.require('Blockly.Extensions');
+goog.require('Blockly.FieldLabelSerializable');
+goog.require('Blockly.FieldVariableGetter');
+goog.require('Blockly.Input');
+goog.require('Blockly.Mutator');
+goog.require('Blockly.Warning');
+goog.require('Blockly.Workspace');
+goog.require('Blockly.Xml');
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.math.Coordinate');
+goog.require('goog.string');
+
+
+/**
+ * Class for one block.
+ * Not normally called directly, workspace.newBlock() is preferred.
+ * @param {!Blockly.Workspace} workspace The block's workspace.
+ * @param {?string} prototypeName Name of the language object containing
+ *     type-specific functions for this block.
+ * @param {string=} opt_id Optional ID.  Use this ID if provided, otherwise
+ *     create a new ID.  If the ID conflicts with an in-use ID, a new one will
+ *     be generated.
+ * @constructor
+ */
+Blockly.Block = function(workspace, prototypeName, opt_id) {
+  var flyoutWorkspace = workspace && workspace.getFlyout && workspace.getFlyout() ?
+     workspace.getFlyout().getWorkspace() : null;
+  /** @type {string} */
+  this.id = (opt_id && !workspace.getBlockById(opt_id) &&
+      (!flyoutWorkspace || !flyoutWorkspace.getBlockById(opt_id))) ?
+      opt_id : Blockly.utils.genUid();
+  workspace.blockDB_[this.id] = this;
+  /** @type {Blockly.Connection} */
+  this.outputConnection = null;
+  /** @type {Blockly.Connection} */
+  this.nextConnection = null;
+  /** @type {Blockly.Connection} */
+  this.previousConnection = null;
+  /** @type {!Array.<!Blockly.Input>} */
+  this.inputList = [];
+  /** @type {boolean|undefined} */
+  this.inputsInline = true;
+  /** @type {boolean} */
+  this.disabled = false;
+  /** @type {string|!Function} */
+  this.tooltip = '';
+  /** @type {boolean} */
+  this.contextMenu = true;
+
+  /**
+   * @type {Blockly.Block}
+   * @protected
+   */
+  this.parentBlock_ = null;
+
+  /**
+   * @type {!Array.<!Blockly.Block>}
+   * @protected
+   */
+  this.childBlocks_ = [];
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.deletable_ = true;
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.movable_ = true;
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.editable_ = true;
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.isShadow_ = false;
+
+  /**
+   * @type {boolean}
+   * @protected
+   */
+  this.collapsed_ = false;
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this.checkboxInFlyout_ = false;
+
+  /**
+   * @type {boolean} pm: Determines whether or not this block will duplicate on drag.
+   * @private
+   */
+  this.canDragDuplicate_ = false;
+
+  /** @type {string|Blockly.Comment} */
+  this.comment = null;
+
+  /**
+   * @type {?number}
+   * @private
+   */
+  this.outputShape_ = null;
+
+  /**
+   * @type {?string}
+   * @private
+   */
+  this.category_ = null;
+
+  /**
+   * The block's position in workspace units.  (0, 0) is at the workspace's
+   * origin; scale does not change this value.
+   * @type {!goog.math.Coordinate}
+   * @private
+   */
+  this.xy_ = new goog.math.Coordinate(0, 0);
+
+  /** @type {!Blockly.Workspace} */
+  this.workspace = workspace;
+  /** @type {boolean} */
+  this.isInFlyout = workspace.isFlyout;
+  /** @type {boolean} */
+  this.isInMutator = workspace.isMutator;
+
+  /** @type {boolean} */
+  this.RTL = workspace.RTL;
+
+  /** @type {boolean} */
+  this.isInsertionMarker_ = false;
+
+  // Copy the type-specific functions and data from the prototype.
+  if (prototypeName) {
+    /** @type {string} */
+    this.type = prototypeName;
+    var prototype = Blockly.Blocks[prototypeName];
+    goog.asserts.assertObject(prototype,
+        'Error: Unknown block type "%s".', prototypeName);
+    goog.mixin(this, prototype);
+  }
+
+  workspace.addTopBlock(this);
+
+  // Call an initialization function, if it exists.
+  if (goog.isFunction(this.init)) {
+    this.init();
+  }
+  // Record initial inline state.
+  /** @type {boolean|undefined} */
+  this.inputsInlineDefault = this.inputsInline;
+
+  // Fire a create event.
+  if (Blockly.Events.isEnabled()) {
+    var existingGroup = Blockly.Events.getGroup();
+    if (!existingGroup) {
+      Blockly.Events.setGroup(true);
+    }
+    try {
+      Blockly.Events.fire(new Blockly.Events.BlockCreate(this));
+    } finally {
+      if (!existingGroup) {
+        Blockly.Events.setGroup(false);
+      }
+    }
+
+  }
+  // Bind an onchange function, if it exists.
+  if (goog.isFunction(this.onchange)) {
+    this.setOnChange(this.onchange);
+  }
+};
+
+/**
+ * Optional text data that round-trips beween blocks and XML.
+ * Has no effect. May be used by 3rd parties for meta information.
+ * @type {?string}
+ */
+Blockly.Block.prototype.data = null;
+
+/**
+ * Colour of the block in '#RRGGBB' format.
+ * @type {string}
+ * @private
+ */
+Blockly.Block.prototype.colour_ = '#FF0000';
+
+/**
+ * Secondary colour of the block in '#RRGGBB' format.
+ * @type {string}
+ * @private
+ */
+Blockly.Block.prototype.colourSecondary_ = '#FF0000';
+
+/**
+ * Tertiary colour of the block in '#RRGGBB' format.
+ * @type {string}
+ * @private
+ */
+Blockly.Block.prototype.colourTertiary_ = '#FF0000';
+
+/**
+ * Fill colour used to override default shadow colour behaviour.
+ * @type {string}
+ * @private
+ */
+Blockly.Block.prototype.shadowColour_ = null;
+
+/**
+ * Dispose of this block.
+ * @param {boolean} healStack If true, then try to heal any gap by connecting
+ *     the next statement with the previous statement.  Otherwise, dispose of
+ *     all children of this block.
+ */
+Blockly.Block.prototype.dispose = function(healStack) {
+  if (!this.workspace) {
+    // Already deleted.
+    return;
+  }
+  // Terminate onchange event calls.
+  if (this.onchangeWrapper_) {
+    this.workspace.removeChangeListener(this.onchangeWrapper_);
+  }
+  this.unplug(healStack);
+  if (Blockly.Events.isEnabled()) {
+    Blockly.Events.fire(new Blockly.Events.BlockDelete(this));
+  }
+  Blockly.Events.disable();
+
+  try {
+    // This block is now at the top of the workspace.
+    // Remove this block from the workspace's list of top-most blocks.
+    if (this.workspace) {
+      this.workspace.removeTopBlock(this);
+      // Remove from block database.
+      delete this.workspace.blockDB_[this.id];
+      this.workspace = null;
+    }
+
+    // Just deleting this block from the DOM would result in a memory leak as
+    // well as corruption of the connection database.  Therefore we must
+    // methodically step through the blocks and carefully disassemble them.
+
+    if (Blockly.selected == this) {
+      Blockly.selected = null;
+    }
+
+    // First, dispose of all my children.
+    for (var i = this.childBlocks_.length - 1; i >= 0; i--) {
+      this.childBlocks_[i].dispose(false);
+    }
+    // Then dispose of myself.
+    // Dispose of all inputs and their fields.
+    for (var i = 0, input; input = this.inputList[i]; i++) {
+      input.dispose();
+    }
+    this.inputList.length = 0;
+    // Dispose of any remaining connections (next/previous/output).
+    var connections = this.getConnections_(true);
+    for (var i = 0; i < connections.length; i++) {
+      var connection = connections[i];
+      if (connection.isConnected()) {
+        connection.disconnect();
+      }
+      connections[i].dispose();
+    }
+  } finally {
+    Blockly.Events.enable();
+  }
+};
+
+/**
+ * Call initModel on all fields on the block.
+ * May be called more than once.
+ * Either initModel or initSvg must be called after creating a block and before
+ * the first interaction with it.  Interactions include UI actions
+ * (e.g. clicking and dragging) and firing events (e.g. create, delete, and
+ * change).
+ * @public
+ */
+Blockly.Block.prototype.initModel = function() {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.initModel) {
+        field.initModel();
+      }
+    }
+  }
+};
+
+/**
+ * Unplug this block from its superior block.  If this block is a statement,
+ * optionally reconnect the block underneath with the block on top.
+ * @param {boolean=} opt_healStack Disconnect child statement and reconnect
+ *   stack.  Defaults to false.
+ */
+Blockly.Block.prototype.unplug = function(opt_healStack) {
+  if (this.outputConnection) {
+    if (this.outputConnection.isConnected()) {
+      // Disconnect from any superior block.
+      this.outputConnection.disconnect();
+    }
+  } else {
+    if (this.previousConnection) {
+      var previousTarget = null;
+      if (this.previousConnection.isConnected()) {
+        // Remember the connection that any next statements need to connect to.
+        previousTarget = this.previousConnection.targetConnection;
+        // Detach this block from the parent's tree.
+        this.previousConnection.disconnect();
+      }
+    }
+    var nextBlock = this.getNextBlock();
+    if (opt_healStack && nextBlock) {
+      // Disconnect the next statement.
+      var nextTarget = this.nextConnection.targetConnection;
+      nextTarget.disconnect();
+      if (previousTarget && previousTarget.checkType_(nextTarget)) {
+        // Attach the next statement to the previous statement.
+        previousTarget.connect(nextTarget);
+      }
+    }
+  }
+};
+
+/**
+ * Returns all connections originating from this block.
+ * @return {!Array.<!Blockly.Connection>} Array of connections.
+ * @private
+ */
+Blockly.Block.prototype.getConnections_ = function() {
+  var myConnections = [];
+  if (this.outputConnection) {
+    myConnections.push(this.outputConnection);
+  }
+  if (this.previousConnection) {
+    myConnections.push(this.previousConnection);
+  }
+  if (this.nextConnection) {
+    myConnections.push(this.nextConnection);
+  }
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection) {
+      myConnections.push(input.connection);
+    }
+  }
+  return myConnections;
+};
+
+/**
+ * Walks down a stack of blocks and finds the last next connection on the stack.
+ * @return {Blockly.Connection} The last next connection on the stack, or null.
+ * @package
+ */
+Blockly.Block.prototype.lastConnectionInStack = function() {
+  var nextConnection = this.nextConnection;
+  while (nextConnection) {
+    var nextBlock = nextConnection.targetBlock();
+    if (!nextBlock) {
+      // Found a next connection with nothing on the other side.
+      return nextConnection;
+    }
+    nextConnection = nextBlock.nextConnection;
+  }
+  // Ran out of next connections.
+  return null;
+};
+
+/**
+ * Bump unconnected blocks out of alignment.  Two blocks which aren't actually
+ * connected should not coincidentally line up on screen.
+ * @protected
+ */
+Blockly.Block.prototype.bumpNeighbours_ = function() {
+  console.warn('Not expected to reach this bumpNeighbours_ function. The ' +
+    'BlockSvg function for bumpNeighbours_ was expected to be called instead.');
+};
+
+/**
+ * Return the parent block or null if this block is at the top level.
+ * @return {Blockly.Block} The block that holds the current block.
+ */
+Blockly.Block.prototype.getParent = function() {
+  // Look at the DOM to see if we are nested in another block.
+  return this.parentBlock_;
+};
+
+/**
+ * Return the input that connects to the specified block.
+ * @param {!Blockly.Block} block A block connected to an input on this block.
+ * @return {Blockly.Input} The input that connects to the specified block.
+ */
+Blockly.Block.prototype.getInputWithBlock = function(block) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection && input.connection.targetBlock() == block) {
+      return input;
+    }
+  }
+  return null;
+};
+
+/**
+ * Return the input that contains the specified connection
+ * @param {!Blockly.Connection} conn A connection on this block.
+ * @return {Blockly.Input} The input that contains the specified connection.
+ */
+Blockly.Block.prototype.getInputWithConnection = function(conn) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection == conn) {
+      return input;
+    }
+  }
+  return null;
+};
+
+/**
+ * Return the parent block that surrounds the current block, or null if this
+ * block has no surrounding block.  A parent block might just be the previous
+ * statement, whereas the surrounding block is an if statement, while loop, etc.
+ * @return {Blockly.Block} The block that surrounds the current block.
+ */
+Blockly.Block.prototype.getSurroundParent = function() {
+  var block = this;
+  do {
+    var prevBlock = block;
+    block = block.getParent();
+    if (!block) {
+      // Ran off the top.
+      return null;
+    }
+  } while (block.getNextBlock() == prevBlock);
+  // This block is an enclosing parent, not just a statement in a stack.
+  return block;
+};
+
+/**
+ * Return the next statement block directly connected to this block.
+ * @return {Blockly.Block} The next statement block or null.
+ */
+Blockly.Block.prototype.getNextBlock = function() {
+  return this.nextConnection && this.nextConnection.targetBlock();
+};
+
+/**
+ * Return the previous statement block directly connected to this block.
+ * @return {Blockly.Block} The previous statement block or null.
+ */
+Blockly.Block.prototype.getPreviousBlock = function() {
+  return this.previousConnection && this.previousConnection.targetBlock();
+};
+
+/**
+ * Return the connection on the first statement input on this block, or null if
+ * there are none.
+ * @return {Blockly.Connection} The first statement connection or null.
+ */
+Blockly.Block.prototype.getFirstStatementConnection = function() {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection && input.connection.type == Blockly.NEXT_STATEMENT) {
+      return input.connection;
+    }
+  }
+  return null;
+};
+
+/**
+ * Return the top-most block in this block's tree.
+ * This will return itself if this block is at the top level.
+ * @return {!Blockly.Block} The root block.
+ */
+Blockly.Block.prototype.getRootBlock = function() {
+  var rootBlock;
+  var block = this;
+  do {
+    rootBlock = block;
+    block = rootBlock.parentBlock_;
+  } while (block);
+  return rootBlock;
+};
+
+/**
+ * Find all the blocks that are directly nested inside this one.
+ * Includes value and statement inputs, as well as any following statement.
+ * Excludes any connection on an output tab or any preceding statement.
+ * Blocks are optionally sorted by position; top to bottom.
+ * @param {boolean} ordered Sort the list if true.
+ * @return {!Array.<!Blockly.Block>} Array of blocks.
+ */
+Blockly.Block.prototype.getChildren = function(ordered) {
+  if (!ordered) {
+    return this.childBlocks_;
+  }
+  var blocks = [];
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.connection) {
+      var child = input.connection.targetBlock();
+      if (child) {
+        blocks.push(child);
+      }
+    }
+  }
+  var next = this.getNextBlock();
+  if (next) {
+    blocks.push(next);
+  }
+  return blocks;
+};
+
+/**
+ * Set parent of this block to be a new block or null.
+ * @param {Blockly.Block} newParent New parent block.
+ */
+Blockly.Block.prototype.setParent = function(newParent) {
+  if (newParent == this.parentBlock_) {
+    return;
+  }
+  if (this.parentBlock_) {
+    // Remove this block from the old parent's child list.
+    goog.array.remove(this.parentBlock_.childBlocks_, this);
+
+    // Disconnect from superior blocks.
+    if (this.previousConnection && this.previousConnection.isConnected()) {
+      throw 'Still connected to previous block.';
+    }
+    if (this.outputConnection && this.outputConnection.isConnected()) {
+      throw 'Still connected to parent block.';
+    }
+    this.parentBlock_ = null;
+    // This block hasn't actually moved on-screen, so there's no need to update
+    // its connection locations.
+  } else {
+    // Remove this block from the workspace's list of top-most blocks.
+    this.workspace.removeTopBlock(this);
+  }
+
+  this.parentBlock_ = newParent;
+  if (newParent) {
+    // Add this block to the new parent's child list.
+    newParent.childBlocks_.push(this);
+  } else {
+    this.workspace.addTopBlock(this);
+  }
+};
+
+/**
+ * Find all the blocks that are directly or indirectly nested inside this one.
+ * Includes this block in the list.
+ * Includes value and statement inputs, as well as any following statements.
+ * Excludes any connection on an output tab or any preceding statements.
+ * Blocks are optionally sorted by position, top to bottom.
+ * @param {boolean} ordered Sort the list if true.
+ * @param {boolean=} opt_ignoreShadows If set, don't include shadow blocks.
+ * @return {!Array.<!Blockly.Block>} Flattened array of blocks.
+ */
+Blockly.Block.prototype.getDescendants = function(ordered, opt_ignoreShadows) {
+  var blocks = [this];
+  var childBlocks = this.getChildren(ordered);
+  for (var child, i = 0; child = childBlocks[i]; i++) {
+    if (!opt_ignoreShadows || !child.isShadow_) {
+      blocks.push.apply(
+          blocks, child.getDescendants(ordered, opt_ignoreShadows));
+    }
+  }
+  return blocks;
+};
+
+/**
+ * Get whether this block is deletable or not.
+ * @return {boolean} True if deletable.
+ */
+Blockly.Block.prototype.isDeletable = function() {
+  return this.deletable_ && !this.isShadow_ &&
+      !(this.workspace && this.workspace.options.readOnly);
+};
+
+/**
+ * Set whether this block is deletable or not.
+ * @param {boolean} deletable True if deletable.
+ */
+Blockly.Block.prototype.setDeletable = function(deletable) {
+  this.deletable_ = deletable;
+};
+
+/**
+ * Get whether this block is movable or not.
+ * @return {boolean} True if movable.
+ */
+Blockly.Block.prototype.isMovable = function() {
+  return this.movable_ && !this.isShadow_ &&
+      !(this.workspace && this.workspace.options.readOnly);
+};
+
+/**
+ * Set whether this block is movable or not.
+ * @param {boolean} movable True if movable.
+ */
+Blockly.Block.prototype.setMovable = function(movable) {
+  this.movable_ = movable;
+};
+
+/**
+ * Get whether this block is a shadow block or not.
+ * @return {boolean} True if a shadow.
+ */
+Blockly.Block.prototype.isShadow = function() {
+  return this.isShadow_;
+};
+
+/**
+ * Set whether this block is a shadow block or not.
+ * @param {boolean} shadow True if a shadow.
+ */
+Blockly.Block.prototype.setShadow = function(shadow) {
+  this.isShadow_ = shadow;
+};
+
+/**
+ * Get whether this block is an insertion marker block or not.
+ * @return {boolean} True if an insertion marker.
+ */
+Blockly.Block.prototype.isInsertionMarker = function() {
+  return this.isInsertionMarker_;
+};
+
+/**
+ * Set whether this block is an insertion marker block or not.
+ * @param {boolean} insertionMarker True if an insertion marker.
+ */
+Blockly.Block.prototype.setInsertionMarker = function(insertionMarker) {
+  if (this.isInsertionMarker_ == insertionMarker) {
+    return;  // No change.
+  }
+  this.isInsertionMarker_ = insertionMarker;
+  // TODO: handle removing insertion marker status.
+  if (this.isInsertionMarker_) {
+    this.setColour(Blockly.Colours.insertionMarker);
+    this.setOpacity(Blockly.Colours.insertionMarkerOpacity);
+    Blockly.utils.addClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyInsertionMarker');
+  }
+};
+
+/**
+ * Get whether this block is editable or not.
+ * @return {boolean} True if editable.
+ */
+Blockly.Block.prototype.isEditable = function() {
+  return this.editable_ && !(this.workspace && this.workspace.options.readOnly);
+};
+
+/**
+ * Set whether this block is editable or not.
+ * @param {boolean} editable True if editable.
+ */
+Blockly.Block.prototype.setEditable = function(editable) {
+  this.editable_ = editable;
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      field.updateEditable();
+    }
+  }
+};
+
+/**
+ * Set whether the connections are hidden (not tracked in a database) or not.
+ * Recursively walk down all child blocks (except collapsed blocks).
+ * @param {boolean} hidden True if connections are hidden.
+ */
+Blockly.Block.prototype.setConnectionsHidden = function(hidden) {
+  if (!hidden && this.isCollapsed()) {
+    if (this.outputConnection) {
+      this.outputConnection.setHidden(hidden);
+    }
+    if (this.previousConnection) {
+      this.previousConnection.setHidden(hidden);
+    }
+    if (this.nextConnection) {
+      this.nextConnection.setHidden(hidden);
+      var child = this.nextConnection.targetBlock();
+      if (child) {
+        child.setConnectionsHidden(hidden);
+      }
+    }
+  } else {
+    var myConnections = this.getConnections_(true);
+    for (var i = 0, connection; connection = myConnections[i]; i++) {
+      connection.setHidden(hidden);
+      if (connection.isSuperior()) {
+        var child = connection.targetBlock();
+        if (child) {
+          child.setConnectionsHidden(hidden);
+        }
+      }
+    }
+  }
+};
+
+/**
+ * Find the connection on this block that corresponds to the given connection
+ * on the other block.
+ * Used to match connections between a block and its insertion marker.
+ * @param {!Blockly.Block} otherBlock The other block to match against.
+ * @param {!Blockly.Connection} conn The other connection to match.
+ * @return {Blockly.Connection} the matching connection on this block, or null.
+ */
+Blockly.Block.prototype.getMatchingConnection = function(otherBlock, conn) {
+  var connections = this.getConnections_(true);
+  var otherConnections = otherBlock.getConnections_(true);
+  if (connections.length != otherConnections.length) {
+    throw "Connection lists did not match in length.";
+  }
+  for (var i = 0; i < otherConnections.length; i++) {
+    if (otherConnections[i] == conn) {
+      return connections[i];
+    }
+  }
+  return null;
+};
+
+/**
+ * Set the URL of this block's help page.
+ * @param {string|Function} url URL string for block help, or function that
+ *     returns a URL.  Null for no help.
+ */
+Blockly.Block.prototype.setHelpUrl = function(url) {
+  this.helpUrl = url;
+};
+
+/**
+ * Change the tooltip text for a block.
+ * @param {string|!Function} newTip Text for tooltip or a parent element to
+ *     link to for its tooltip.  May be a function that returns a string.
+ */
+Blockly.Block.prototype.setTooltip = function(newTip) {
+  this.tooltip = newTip;
+};
+
+/**
+ * Get the colour of a block.
+ * @return {string} #RRGGBB string.
+ */
+Blockly.Block.prototype.getColour = function() {
+  return this.colour_;
+};
+
+/**
+ * Get the secondary colour of a block.
+ * @return {string} #RRGGBB string.
+ */
+Blockly.Block.prototype.getColourSecondary = function() {
+  return this.colourSecondary_;
+};
+
+/**
+ * Get the tertiary colour of a block.
+ * @return {string} #RRGGBB string.
+ */
+Blockly.Block.prototype.getColourTertiary = function() {
+  return this.colourTertiary_;
+};
+
+/**
+ * Get the shadow colour of a block.
+ * @return {string} #RRGGBB string.
+ */
+Blockly.Block.prototype.getShadowColour = function() {
+  return this.shadowColour_;
+};
+
+/**
+ * Set the shadow colour of a block.
+ * @param {number|string} colour HSV hue value, or #RRGGBB string.
+ */
+Blockly.Block.prototype.setShadowColour = function(colour) {
+  this.shadowColour_ = this.makeColour_(colour);
+  if (this.rendered) {
+    this.updateColour();
+  }
+};
+
+/**
+ * Clear the shadow colour of a block.
+ */
+Blockly.Block.prototype.clearShadowColour = function() {
+  this.shadowColour_ = null;
+  if (this.rendered) {
+    this.updateColour();
+  }
+};
+
+/**
+* Create an #RRGGBB string colour from a colour HSV hue value or #RRGGBB string.
+* @param {number|string} colour HSV hue value, or #RRGGBB string.
+* @return {string} #RRGGBB string.
+* @private
+*/
+Blockly.Block.prototype.makeColour_ = function(colour) {
+  var hue = Number(colour);
+  if (!isNaN(hue)) {
+    return Blockly.hueToRgb(hue);
+  } else if (goog.isString(colour) && colour.match(/^#[0-9a-fA-F]{6,8}$/)) {
+    return colour;
+  } else {
+    throw 'Invalid colour: ' + colour;
+  }
+};
+
+/**
+ * Change the colour of a block, and optional secondary/teriarty colours.
+ * @param {number|string} colour HSV hue value, or #RRGGBB string.
+ * @param {number|string} colourSecondary HSV hue value, or #RRGGBB string.
+ * @param {number|string} colourTertiary HSV hue value, or #RRGGBB string.
+ */
+Blockly.Block.prototype.setColour = function(colour, colourSecondary, colourTertiary) {
+  this.colour_ = this.makeColour_(colour);
+  if (colourSecondary !== undefined) {
+    this.colourSecondary_ = this.makeColour_(colourSecondary);
+  } else {
+    this.colourSecondary_ = goog.color.rgbArrayToHex(
+        goog.color.darken(goog.color.hexToRgb(this.colour_), 0.1));
+  }
+  if (colourTertiary !== undefined) {
+    this.colourTertiary_ = this.makeColour_(colourTertiary);
+  } else {
+    this.colourTertiary_ = goog.color.rgbArrayToHex(
+        goog.color.darken(goog.color.hexToRgb(this.colour_), 0.2));
+  }
+  if (this.rendered) {
+    this.updateColour();
+  }
+};
+
+/**
+ * Sets a callback function to use whenever the block's parent workspace
+ * changes, replacing any prior onchange handler. This is usually only called
+ * from the constructor, the block type initializer function, or an extension
+ * initializer function.
+ * @param {function(Blockly.Events.Abstract)} onchangeFn The callback to call
+ *     when the block's workspace changes.
+ * @throws {Error} if onchangeFn is not falsey or a function.
+ */
+Blockly.Block.prototype.setOnChange = function(onchangeFn) {
+  if (onchangeFn && !goog.isFunction(onchangeFn)) {
+    throw new Error("onchange must be a function.");
+  }
+  if (this.onchangeWrapper_) {
+    this.workspace.removeChangeListener(this.onchangeWrapper_);
+  }
+  this.onchange = onchangeFn;
+  if (this.onchange) {
+    this.onchangeWrapper_ = onchangeFn.bind(this);
+    this.workspace.addChangeListener(this.onchangeWrapper_);
+  }
+};
+
+/**
+ * Returns the named field from a block.
+ * @param {string} name The name of the field.
+ * @return {Blockly.Field} Named field, or null if field does not exist.
+ */
+Blockly.Block.prototype.getField = function(name) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.name === name) {
+        return field;
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * Return all variables referenced by this block.
+ * @return {!Array.<string>} List of variable names.
+ * @package
+ */
+Blockly.Block.prototype.getVars = function() {
+  var vars = [];
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.referencesVariables()) {
+        vars.push(field.getValue());
+      }
+    }
+  }
+  return vars;
+};
+
+/**
+ * Return all variables referenced by this block.
+ * @return {!Array.<!Blockly.VariableModel>} List of variable models.
+ * @package
+ */
+Blockly.Block.prototype.getVarModels = function() {
+  var vars = [];
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.referencesVariables()) {
+        var model = this.workspace.getVariableById(field.getValue());
+        // Check if the variable actually exists (and isn't just a potential
+        // variable).
+        if (model) {
+          vars.push(model);
+        }
+      }
+    }
+  }
+  return vars;
+};
+
+/**
+ * Notification that a variable is renaming but keeping the same ID.  If the
+ * variable is in use on this block, rerender to show the new name.
+ * @param {!Blockly.VariableModel} variable The variable being renamed.
+ * @package
+ */
+Blockly.Block.prototype.updateVarName = function(variable) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.referencesVariables() &&
+          variable.getId() == field.getValue()) {
+        field.setText(variable.name);
+      }
+    }
+  }
+};
+
+/**
+ * Notification that a variable is renaming.
+ * If the ID matches one of this block's variables, rename it.
+ * @param {string} oldId ID of variable to rename.
+ * @param {string} newId ID of new variable.  May be the same as oldId, but with
+ *     an updated name.
+ */
+Blockly.Block.prototype.renameVarById = function(oldId, newId) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field.referencesVariables() &&
+          oldId == field.getValue()) {
+        field.setValue(newId);
+      }
+    }
+  }
+};
+
+/**
+ * Returns the language-neutral value from the field of a block.
+ * @param {string} name The name of the field.
+ * @return {?string} Value from the field or null if field does not exist.
+ */
+Blockly.Block.prototype.getFieldValue = function(name) {
+  var field = this.getField(name);
+  if (field) {
+    return field.getValue();
+  }
+  return null;
+};
+
+/**
+ * Change the field value for a block (e.g. 'CHOOSE' or 'REMOVE').
+ * @param {string} newValue Value to be the new field.
+ * @param {string} name The name of the field.
+ */
+Blockly.Block.prototype.setFieldValue = function(newValue, name) {
+  var field = this.getField(name);
+  goog.asserts.assertObject(field, 'Field "%s" not found.', name);
+  field.setValue(newValue);
+};
+
+/**
+ * Set whether this block can chain onto the bottom of another block.
+ * @param {boolean} newBoolean True if there can be a previous statement.
+ * @param {(string|Array.<string>|null)=} opt_check Statement type or
+ *     list of statement types.  Null/undefined if any type could be connected.
+ */
+Blockly.Block.prototype.setPreviousStatement = function(newBoolean, opt_check) {
+  if (newBoolean) {
+    if (opt_check === undefined) {
+      opt_check = null;
+    }
+    if (!this.previousConnection) {
+      goog.asserts.assert(!this.outputConnection,
+          'Remove output connection prior to adding previous connection.');
+      this.previousConnection =
+          this.makeConnection_(Blockly.PREVIOUS_STATEMENT);
+    }
+    this.previousConnection.setCheck(opt_check);
+  } else {
+    if (this.previousConnection) {
+      goog.asserts.assert(!this.previousConnection.isConnected(),
+          'Must disconnect previous statement before removing connection.');
+      this.previousConnection.dispose();
+      this.previousConnection = null;
+    }
+  }
+};
+
+/**
+ * Set whether another block can chain onto the bottom of this block.
+ * @param {boolean} newBoolean True if there can be a next statement.
+ * @param {(string|Array.<string>|null)=} opt_check Statement type or
+ *     list of statement types.  Null/undefined if any type could be connected.
+ */
+Blockly.Block.prototype.setNextStatement = function(newBoolean, opt_check) {
+  if (newBoolean) {
+    if (opt_check === undefined) {
+      opt_check = null;
+    }
+    if (!this.nextConnection) {
+      this.nextConnection = this.makeConnection_(Blockly.NEXT_STATEMENT);
+    }
+    this.nextConnection.setCheck(opt_check);
+  } else {
+    if (this.nextConnection) {
+      goog.asserts.assert(!this.nextConnection.isConnected(),
+          'Must disconnect next statement before removing connection.');
+      this.nextConnection.dispose();
+      this.nextConnection = null;
+    }
+  }
+};
+
+/**
+ * Set whether this block returns a value.
+ * @param {boolean} newBoolean True if there is an output.
+ * @param {(string|Array.<string>|null)=} opt_check Returned type or list
+ *     of returned types.  Null or undefined if any type could be returned
+ *     (e.g. variable get).
+ */
+Blockly.Block.prototype.setOutput = function(newBoolean, opt_check) {
+  if (newBoolean) {
+    if (opt_check === undefined) {
+      opt_check = null;
+    }
+    if (!this.outputConnection) {
+      goog.asserts.assert(!this.previousConnection,
+          'Remove previous connection prior to adding output connection.');
+      this.outputConnection = this.makeConnection_(Blockly.OUTPUT_VALUE);
+    }
+    this.outputConnection.setCheck(opt_check);
+  } else {
+    if (this.outputConnection) {
+      goog.asserts.assert(!this.outputConnection.isConnected(),
+          'Must disconnect output value before removing connection.');
+      this.outputConnection.dispose();
+      this.outputConnection = null;
+    }
+  }
+};
+
+/**
+ * Set whether value inputs are arranged horizontally or vertically.
+ * @param {boolean} newBoolean True if inputs are horizontal.
+ */
+Blockly.Block.prototype.setInputsInline = function(newBoolean) {
+  if (this.inputsInline != newBoolean) {
+    Blockly.Events.fire(new Blockly.Events.BlockChange(
+        this, 'inline', null, this.inputsInline, newBoolean));
+    this.inputsInline = newBoolean;
+  }
+};
+
+/**
+ * Get whether value inputs are arranged horizontally or vertically.
+ * @return {boolean} True if inputs are horizontal.
+ */
+Blockly.Block.prototype.getInputsInline = function() {
+  if (this.inputsInline != undefined) {
+    // Set explicitly.
+    return this.inputsInline;
+  }
+  // Not defined explicitly.  Figure out what would look best.
+  for (var i = 1; i < this.inputList.length; i++) {
+    if (this.inputList[i - 1].type == Blockly.DUMMY_INPUT &&
+        this.inputList[i].type == Blockly.DUMMY_INPUT) {
+      // Two dummy inputs in a row.  Don't inline them.
+      return false;
+    }
+  }
+  for (var i = 1; i < this.inputList.length; i++) {
+    if (this.inputList[i - 1].type == Blockly.INPUT_VALUE &&
+        this.inputList[i].type == Blockly.DUMMY_INPUT) {
+      // Dummy input after a value input.  Inline them.
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Set whether the block is disabled or not.
+ * @param {boolean} disabled True if disabled.
+ */
+Blockly.Block.prototype.setDisabled = function(disabled) {
+  if (this.disabled != disabled) {
+    Blockly.Events.fire(new Blockly.Events.BlockChange(
+        this, 'disabled', null, this.disabled, disabled));
+    this.disabled = disabled;
+  }
+};
+
+/**
+ * Get whether the block is disabled or not due to parents.
+ * The block's own disabled property is not considered.
+ * @return {boolean} True if disabled.
+ */
+Blockly.Block.prototype.getInheritedDisabled = function() {
+  var ancestor = this.getSurroundParent();
+  while (ancestor) {
+    if (ancestor.disabled) {
+      return true;
+    }
+    ancestor = ancestor.getSurroundParent();
+  }
+  // Ran off the top.
+  return false;
+};
+
+/**
+ * Get whether the block is collapsed or not.
+ * @return {boolean} True if collapsed.
+ */
+Blockly.Block.prototype.isCollapsed = function() {
+  return this.collapsed_;
+};
+
+/**
+ * Set whether the block is collapsed or not.
+ * @param {boolean} collapsed True if collapsed.
+ */
+Blockly.Block.prototype.setCollapsed = function(collapsed) {
+  if (this.collapsed_ != collapsed) {
+    Blockly.Events.fire(new Blockly.Events.BlockChange(
+        this, 'collapsed', null, this.collapsed_, collapsed));
+    this.collapsed_ = collapsed;
+  }
+};
+
+/**
+ * Create a human-readable text representation of this block and any children.
+ * @param {number=} opt_maxLength Truncate the string to this length.
+ * @param {string=} opt_emptyToken The placeholder string used to denote an
+ *     empty field. If not specified, '?' is used.
+ * @return {string} Text of block.
+ */
+Blockly.Block.prototype.toString = function(opt_maxLength, opt_emptyToken) {
+  var text = [];
+  var emptyFieldPlaceholder = opt_emptyToken || '?';
+  if (this.collapsed_) {
+    text.push(this.getInput('_TEMP_COLLAPSED_INPUT').fieldRow[0].text_);
+  } else {
+    for (var i = 0, input; input = this.inputList[i]; i++) {
+      for (var j = 0, field; field = input.fieldRow[j]; j++) {
+        if (field instanceof Blockly.FieldDropdown && !field.getValue()) {
+          text.push(emptyFieldPlaceholder);
+        } else {
+          text.push(field.getText());
+        }
+      }
+      if (input.connection) {
+        var child = input.connection.targetBlock();
+        if (child) {
+          text.push(child.toString(undefined, opt_emptyToken));
+        } else {
+          text.push(emptyFieldPlaceholder);
+        }
+      }
+    }
+  }
+  text = goog.string.trim(text.join(' ')) || '???';
+  if (opt_maxLength) {
+    // TODO: Improve truncation so that text from this block is given priority.
+    // E.g. "1+2+3+4+5+6+7+8+9=0" should be "...6+7+8+9=0", not "1+2+3+4+5...".
+    // E.g. "1+2+3+4+5=6+7+8+9+0" should be "...4+5=6+7...".
+    text = goog.string.truncate(text, opt_maxLength);
+  }
+  return text;
+};
+
+/**
+ * Shortcut for appending a value input row.
+ * @param {string} name Language-neutral identifier which may used to find this
+ *     input again.  Should be unique to this block.
+ * @return {!Blockly.Input} The input object created.
+ */
+Blockly.Block.prototype.appendValueInput = function(name) {
+  return this.appendInput_(Blockly.INPUT_VALUE, name);
+};
+
+/**
+ * Shortcut for appending a statement input row.
+ * @param {string} name Language-neutral identifier which may used to find this
+ *     input again.  Should be unique to this block.
+ * @return {!Blockly.Input} The input object created.
+ */
+Blockly.Block.prototype.appendStatementInput = function(name) {
+  return this.appendInput_(Blockly.NEXT_STATEMENT, name);
+};
+
+/**
+ * Shortcut for appending a dummy input row.
+ * @param {string=} opt_name Language-neutral identifier which may used to find
+ *     this input again.  Should be unique to this block.
+ * @return {!Blockly.Input} The input object created.
+ */
+Blockly.Block.prototype.appendDummyInput = function(opt_name) {
+  return this.appendInput_(Blockly.DUMMY_INPUT, opt_name || '');
+};
+
+/**
+ * Initialize this block using a cross-platform, internationalization-friendly
+ * JSON description.
+ * @param {!Object} json Structured data describing the block.
+ */
+Blockly.Block.prototype.jsonInit = function(json) {
+  var warningPrefix = json['type'] ? 'Block "' + json['type'] + '": ' : '';
+
+  // Validate inputs.
+  goog.asserts.assert(
+      json['output'] == undefined || json['previousStatement'] == undefined,
+      warningPrefix + 'Must not have both an output and a previousStatement.');
+
+  // Set basic properties of block.
+  if (json['colour'] !== undefined) {
+    this.setColourFromJson_(json);
+  }
+
+  // Interpolate the message blocks.
+  var i = 0;
+  while (json['message' + i] !== undefined) {
+    this.interpolate_(json['message' + i], json['args' + i] || [],
+        json['lastDummyAlign' + i]);
+    i++;
+  }
+
+  if (json['inputsInline'] !== undefined) {
+    this.setInputsInline(json['inputsInline']);
+  }
+  // Set output and previous/next connections.
+  if (json['output'] !== undefined) {
+    this.setOutput(true, json['output']);
+  }
+  if (json['previousStatement'] !== undefined) {
+    this.setPreviousStatement(true, json['previousStatement']);
+  }
+  if (json['nextStatement'] !== undefined) {
+    this.setNextStatement(true, json['nextStatement']);
+  }
+  if (json['tooltip'] !== undefined) {
+    var rawValue = json['tooltip'];
+    var localizedText = Blockly.utils.replaceMessageReferences(rawValue);
+    this.setTooltip(localizedText);
+  }
+  if (json['enableContextMenu'] !== undefined) {
+    var rawValue = json['enableContextMenu'];
+    this.contextMenu = !!rawValue;
+  }
+  if (json['helpUrl'] !== undefined) {
+    var rawValue = json['helpUrl'];
+    var localizedValue = Blockly.utils.replaceMessageReferences(rawValue);
+    this.setHelpUrl(localizedValue);
+  }
+  if (goog.isString(json['extensions'])) {
+    console.warn('JSON attribute \'extensions\' should be an array of ' +
+      'strings. Found raw string in JSON for \'' + json['type'] + '\' block.');
+    json['extensions'] = [json['extensions']];  // Correct and continue.
+  }
+
+  // Add the mutator to the block
+  if (json['mutator'] !== undefined) {
+    Blockly.Extensions.apply(json['mutator'], this, true);
+  }
+
+  if (Array.isArray(json['extensions'])) {
+    var extensionNames = json['extensions'];
+    for (var i = 0; i < extensionNames.length; ++i) {
+      var extensionName = extensionNames[i];
+      Blockly.Extensions.apply(extensionName, this, false);
+    }
+  }
+  if (json['outputShape'] !== undefined) {
+    this.setOutputShape(json['outputShape']);
+  }
+  if (json['canDragDuplicate'] !== undefined) {
+    this.setDragDuplication(json['canDragDuplicate']);
+  }
+  if (json['checkboxInFlyout'] !== undefined) {
+    this.setCheckboxInFlyout(json['checkboxInFlyout']);
+  }
+  if (json['category'] !== undefined) {
+    this.setCategory(json['category']);
+  }
+};
+
+/**
+ * Add key/values from mixinObj to this block object. By default, this method
+ * will check that the keys in mixinObj will not overwrite existing values in
+ * the block, including prototype values. This provides some insurance against
+ * mixin / extension incompatibilities with future block features. This check
+ * can be disabled by passing true as the second argument.
+ * @param {!Object} mixinObj The key/values pairs to add to this block object.
+ * @param {boolean=} opt_disableCheck Option flag to disable overwrite checks.
+ */
+Blockly.Block.prototype.mixin = function(mixinObj, opt_disableCheck) {
+  if (goog.isDef(opt_disableCheck) && !goog.isBoolean(opt_disableCheck)) {
+    throw new Error("opt_disableCheck must be a boolean if provided");
+  }
+  if (!opt_disableCheck) {
+    var overwrites = [];
+    for (var key in mixinObj) {
+      if (this[key] !== undefined) {
+        overwrites.push(key);
+      }
+    }
+    if (overwrites.length) {
+      throw new Error('Mixin will overwrite block members: ' +
+        JSON.stringify(overwrites));
+    }
+  }
+  goog.mixin(this, mixinObj);
+};
+
+/**
+ * Set the colour of the block from strings or string table references.
+ * @param {string|?} primary Primary colour, which may be a string that contains
+ *     string table references.
+ * @param {string|?} secondary Secondary colour, which may be a string that
+ *     contains string table references.
+ * @param {string|?} tertiary Tertiary colour, which may be a string that
+ *     contains string table references.
+ * @private
+ */
+Blockly.Block.prototype.setColourFromRawValues_ = function(primary, secondary,
+    tertiary) {
+  primary = goog.isString(primary) ?
+      Blockly.utils.replaceMessageReferences(primary) : primary;
+  secondary = goog.isString(secondary) ?
+      Blockly.utils.replaceMessageReferences(secondary) : secondary;
+  tertiary = goog.isString(tertiary) ?
+      Blockly.utils.replaceMessageReferences(tertiary) : tertiary;
+
+  this.setColour(primary, secondary, tertiary);
+};
+
+/**
+ * Set the colour of the block from JSON, replacing message references as
+ * needed.
+ * @param {!Object} json Structured data describing the block.
+ * @private
+ */
+Blockly.Block.prototype.setColourFromJson_ = function(json) {
+  this.setColourFromRawValues_(json['colour'], json['colourSecondary'],
+      json['colourTertiary']);
+};
+
+/**
+ * Interpolate a message description onto the block.
+ * @param {string} message Text contains interpolation tokens (%1, %2, ...)
+ *     that match with fields or inputs defined in the args array.
+ * @param {!Array} args Array of arguments to be interpolated.
+ * @param {string=} lastDummyAlign If a dummy input is added at the end,
+ *     how should it be aligned?
+ * @private
+ */
+Blockly.Block.prototype.interpolate_ = function(message, args, lastDummyAlign) {
+  var tokens = Blockly.utils.tokenizeInterpolation(message);
+  // Interpolate the arguments.  Build a list of elements.
+  var indexDup = [];
+  var indexCount = 0;
+  var elements = [];
+  for (var i = 0; i < tokens.length; i++) {
+    var token = tokens[i];
+    if (typeof token == 'number') {
+      if (token <= 0 || token > args.length) {
+        throw new Error('Block "' + this.type + '": ' +
+            'Message index %' + token + ' out of range.');
+      }
+      if (indexDup[token]) {
+        throw new Error('Block "' + this.type + '": ' +
+            'Message index %' + token + ' duplicated.');
+      }
+      indexDup[token] = true;
+      indexCount++;
+      elements.push(args[token - 1]);
+    } else {
+      token = token.trim();
+      if (token) {
+        elements.push(token);
+      }
+    }
+  }
+  if (indexCount != args.length) {
+    throw new Error('Block "' + this.type + '": ' +
+        'Message does not reference all ' + args.length + ' arg(s).');
+  }
+  // Add last dummy input if needed.
+  if (elements.length && (typeof elements[elements.length - 1] == 'string' ||
+      goog.string.startsWith(
+          elements[elements.length - 1]['type'], 'field_'))) {
+    var dummyInput = {type: 'input_dummy'};
+    if (lastDummyAlign) {
+      dummyInput['align'] = lastDummyAlign;
+    }
+    elements.push(dummyInput);
+  }
+  // Lookup of alignment constants.
+  var alignmentLookup = {
+    'LEFT': Blockly.ALIGN_LEFT,
+    'RIGHT': Blockly.ALIGN_RIGHT,
+    'CENTRE': Blockly.ALIGN_CENTRE
+  };
+  // Populate block with inputs and fields.
+  var fieldStack = [];
+  for (var i = 0; i < elements.length; i++) {
+    var element = elements[i];
+    if (typeof element == 'string') {
+      fieldStack.push([element, undefined]);
+    } else {
+      var field = null;
+      var input = null;
+      do {
+        var altRepeat = false;
+        if (typeof element == 'string') {
+          field = new Blockly.FieldLabel(element);
+        } else {
+          switch (element['type']) {
+            case 'input_value':
+              input = this.appendValueInput(element['name']);
+              break;
+            case 'input_statement':
+              input = this.appendStatementInput(element['name']);
+              break;
+            case 'input_dummy':
+              input = this.appendDummyInput(element['name']);
+              break;
+            default:
+              field = Blockly.Field.fromJson(element);
+
+              // Unknown field.
+              if (!field) {
+                if (element['alt']) {
+                  element = element['alt'];
+                  altRepeat = true;
+                } else {
+                  console.warn('Blockly could not create a field of type ' +
+                      element['type'] +
+                      '. You may need to register your custom field.  See ' +
+                      'github.com/google/blockly/issues/1584');
+                }
+              }
+          }
+        }
+      } while (altRepeat);
+      if (field) {
+        fieldStack.push([field, element['name']]);
+      } else if (input) {
+        if (element['shape']) {
+          input.setShape(element['shape']);
+        }
+        if (element['check']) {
+          input.setCheck(element['check']);
+        }
+        if (element['align']) {
+          input.setAlign(alignmentLookup[element['align']]);
+        }
+        for (var j = 0; j < fieldStack.length; j++) {
+          input.appendField(fieldStack[j][0], fieldStack[j][1]);
+        }
+        fieldStack.length = 0;
+      }
+    }
+  }
+};
+
+/**
+ * Add a value input, statement input or local variable to this block.
+ * @param {number} type Either Blockly.INPUT_VALUE or Blockly.NEXT_STATEMENT or
+ *     Blockly.DUMMY_INPUT.
+ * @param {string} name Language-neutral identifier which may used to find this
+ *     input again.  Should be unique to this block.
+ * @return {!Blockly.Input} The input object created.
+ * @protected
+ */
+Blockly.Block.prototype.appendInput_ = function(type, name) {
+  var connection = null;
+  if (type == Blockly.INPUT_VALUE || type == Blockly.NEXT_STATEMENT) {
+    connection = this.makeConnection_(type);
+  }
+  var input = new Blockly.Input(type, name, this, connection);
+  // Append input to list.
+  this.inputList.push(input);
+  return input;
+};
+
+/**
+ * Move a named input to a different location on this block.
+ * @param {string} name The name of the input to move.
+ * @param {?string} refName Name of input that should be after the moved input,
+ *   or null to be the input at the end.
+ */
+Blockly.Block.prototype.moveInputBefore = function(name, refName) {
+  if (name == refName) {
+    return;
+  }
+  // Find both inputs.
+  var inputIndex = -1;
+  var refIndex = refName ? -1 : this.inputList.length;
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.name == name) {
+      inputIndex = i;
+      if (refIndex != -1) {
+        break;
+      }
+    } else if (refName && input.name == refName) {
+      refIndex = i;
+      if (inputIndex != -1) {
+        break;
+      }
+    }
+  }
+  goog.asserts.assert(inputIndex != -1, 'Named input "%s" not found.', name);
+  goog.asserts.assert(
+      refIndex != -1, 'Reference input "%s" not found.', refName);
+  this.moveNumberedInputBefore(inputIndex, refIndex);
+};
+
+/**
+ * Move a numbered input to a different location on this block.
+ * @param {number} inputIndex Index of the input to move.
+ * @param {number} refIndex Index of input that should be after the moved input.
+ */
+Blockly.Block.prototype.moveNumberedInputBefore = function(
+    inputIndex, refIndex) {
+  // Validate arguments.
+  goog.asserts.assert(inputIndex != refIndex, 'Can\'t move input to itself.');
+  goog.asserts.assert(inputIndex < this.inputList.length,
+      'Input index ' + inputIndex + ' out of bounds.');
+  goog.asserts.assert(refIndex <= this.inputList.length,
+      'Reference input ' + refIndex + ' out of bounds.');
+  // Remove input.
+  var input = this.inputList[inputIndex];
+  this.inputList.splice(inputIndex, 1);
+  if (inputIndex < refIndex) {
+    refIndex--;
+  }
+  // Reinsert input.
+  this.inputList.splice(refIndex, 0, input);
+};
+
+/**
+ * Remove an input from this block.
+ * @param {string} name The name of the input.
+ * @param {boolean=} opt_quiet True to prevent error if input is not present.
+ * @throws {goog.asserts.AssertionError} if the input is not present and
+ *     opt_quiet is not true.
+ */
+Blockly.Block.prototype.removeInput = function(name, opt_quiet) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.name == name) {
+      if (input.connection && input.connection.isConnected()) {
+        input.connection.setShadowDom(null);
+        var block = input.connection.targetBlock();
+        if (block.isShadow()) {
+          // Destroy any attached shadow block.
+          block.dispose();
+        } else {
+          // Disconnect any attached normal block.
+          block.unplug();
+        }
+      }
+      input.dispose();
+      this.inputList.splice(i, 1);
+      return;
+    }
+  }
+  if (!opt_quiet) {
+    goog.asserts.fail('Input "%s" not found.', name);
+  }
+};
+
+/**
+ * Fetches the named input object.
+ * @param {string} name The name of the input.
+ * @return {Blockly.Input} The input object, or null if input does not exist.
+ */
+Blockly.Block.prototype.getInput = function(name) {
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (input.name == name) {
+      return input;
+    }
+  }
+  // This input does not exist.
+  return null;
+};
+
+/**
+ * Fetches the block attached to the named input.
+ * @param {string} name The name of the input.
+ * @return {Blockly.Block} The attached value block, or null if the input is
+ *     either disconnected or if the input does not exist.
+ */
+Blockly.Block.prototype.getInputTargetBlock = function(name) {
+  var input = this.getInput(name);
+  return input && input.connection && input.connection.targetBlock();
+};
+
+/**
+ * Returns the comment on this block (or '' if none).
+ * @return {string} Block's comment.
+ */
+Blockly.Block.prototype.getCommentText = function() {
+  return this.comment || '';
+};
+
+/**
+ * Set this block's comment text.
+ * @param {?string} text The text, or null to delete.
+ */
+Blockly.Block.prototype.setCommentText = function(text) {
+  if (this.comment != text) {
+    Blockly.Events.fire(new Blockly.Events.BlockChange(
+        this, 'comment', null, this.comment, text || ''));
+    this.comment = text;
+  }
+};
+
+/**
+ * Set this block's output shape.
+ * e.g., null, OUTPUT_SHAPE_HEXAGONAL, OUTPUT_SHAPE_ROUND, OUTPUT_SHAPE_SQUARE, etc.
+ * @param {?number} outputShape Value representing output shape
+ *     (see constants.js).
+ */
+Blockly.Block.prototype.setOutputShape = function(outputShape) {
+  this.outputShape_ = outputShape;
+};
+
+/**
+ * Get this block's output shape.
+ * @return {?number} Value representing output shape (see constants.js).
+ */
+Blockly.Block.prototype.getOutputShape = function() {
+  return this.outputShape_;
+};
+
+/**
+ * Set this block's category (for styling purposes)
+ * @param {?string} category The block's category (see constants.js).
+ */
+Blockly.Block.prototype.setCategory = function(category) {
+  this.category_ = category;
+};
+
+/**
+ * Get this block's category (for styling purposes)
+ * @return {?string} category The block's category (see constants.js).
+ */
+Blockly.Block.prototype.getCategory = function() {
+  return this.category_;
+};
+
+/**
+ * Set whether this block has a checkbox next to it in the flyout.
+ * @param {boolean} hasCheckbox True if this block should have a checkbox.
+ */
+Blockly.Block.prototype.setCheckboxInFlyout = function(hasCheckbox) {
+  this.checkboxInFlyout_ = hasCheckbox;
+};
+
+/**
+ * Get whether this block has a checkbox next to it in the flyout.
+ * @return {boolean} True if this block should have a checkbox.
+ */
+Blockly.Block.prototype.hasCheckboxInFlyout = function() {
+  return this.checkboxInFlyout_;
+};
+
+/**
+ * pm: Set whether this block can duplicate on drag.
+ * Note that a block must be a shadow block to duplicate on drag.
+ * @param {boolean} canDragDuplicate True if this block should duplicate on drag.
+ */
+Blockly.Block.prototype.setDragDuplication = function(canDragDuplicate) {
+  this.canDragDuplicate_ = canDragDuplicate;
+};
+
+/**
+ * pm: Get whether this block can duplicate on drag.
+ * This will only return true if the block is also a shadow block.
+ * @return {boolean} True if this block can duplicate on drag.
+ */
+Blockly.Block.prototype.canDragDuplicate = function() {
+  return this.canDragDuplicate_ && this.isShadow();
+};
+
+/**
+ * Set this block's warning text.
+ * @param {?string} text The text, or null to delete.
+ * @abstract
+ */
+Blockly.Block.prototype.setWarningText = function(/* text */) {
+  // NOP.
+};
+
+/**
+ * Give this block a mutator dialog.
+ * @param {Blockly.Mutator} mutator A mutator dialog instance or null to remove.
+ * @abstract
+ */
+Blockly.Block.prototype.setMutator = function(/* mutator */) {
+  // NOP.
+};
+
+/**
+ * Return the coordinates of the top-left corner of this block relative to the
+ * drawing surface's origin (0,0), in workspace units.
+ * @return {!goog.math.Coordinate} Object with .x and .y properties.
+ */
+Blockly.Block.prototype.getRelativeToSurfaceXY = function() {
+  return this.xy_;
+};
+
+/**
+ * Move a block by a relative offset.
+ * @param {number} dx Horizontal offset, in workspace units.
+ * @param {number} dy Vertical offset, in workspace units.
+ */
+Blockly.Block.prototype.moveBy = function(dx, dy) {
+  goog.asserts.assert(!this.parentBlock_, 'Block has parent.');
+  var event = new Blockly.Events.BlockMove(this);
+  this.xy_.translate(dx, dy);
+  event.recordNew();
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Create a connection of the specified type.
+ * @param {number} type The type of the connection to create.
+ * @return {!Blockly.Connection} A new connection of the specified type.
+ * @private
+ */
+Blockly.Block.prototype.makeConnection_ = function(type) {
+  return new Blockly.Connection(this, type);
+};
+
+/**
+ * Recursively checks whether all statement and value inputs are filled with
+ * blocks. Also checks all following statement blocks in this stack.
+ * @param {boolean=} opt_shadowBlocksAreFilled An optional argument controlling
+ *     whether shadow blocks are counted as filled. Defaults to true.
+ * @return {boolean} True if all inputs are filled, false otherwise.
+ */
+Blockly.Block.prototype.allInputsFilled = function(opt_shadowBlocksAreFilled) {
+  // Account for the shadow block filledness toggle.
+  if (opt_shadowBlocksAreFilled === undefined) {
+    opt_shadowBlocksAreFilled = true;
+  }
+  if (!opt_shadowBlocksAreFilled && this.isShadow()) {
+    return false;
+  }
+
+  // Recursively check each input block of the current block.
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    if (!input.connection) {
+      continue;
+    }
+    var target = input.connection.targetBlock();
+    if (!target || !target.allInputsFilled(opt_shadowBlocksAreFilled)) {
+      return false;
+    }
+  }
+
+  // Recursively check the next block after the current block.
+  var next = this.getNextBlock();
+  if (next) {
+    return next.allInputsFilled(opt_shadowBlocksAreFilled);
+  }
+
+  return true;
+};
+
+/**
+ * This method returns a string describing this Block in developer terms (type
+ * name and ID; English only).
+ *
+ * Intended to on be used in console logs and errors. If you need a string that
+ * uses the user's native language (including block text, field values, and
+ * child blocks), use [toString()]{@link Blockly.Block#toString}.
+ * @return {string} The description.
+ */
+Blockly.Block.prototype.toDevString = function() {
+  var msg = this.type ? '"' + this.type + '" block' : 'Block';
+  if (this.id) {
+    msg += ' (id="' + this.id + '")';
+  }
+  return msg;
+};

core/block_animations.js

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2018 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.
+ */
+
+/**
+ * @fileoverview Methods animating a block on connection and disconnection.
+ * @author [email protected] (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.BlockAnimations');
+
+
+/**
+ * Play some UI effects (sound, animation) when disposing of a block.
+ * @param {!Blockly.BlockSvg} block The block being disposed of.
+ * @package
+ */
+Blockly.BlockAnimations.disposeUiEffect = function(block) {
+  var workspace = block.workspace;
+  var svgGroup = block.getSvgRoot();
+  workspace.getAudioManager().play('delete');
+
+  var xy = workspace.getSvgXY(svgGroup);
+  // Deeply clone the current block.
+  var clone = svgGroup.cloneNode(true);
+  clone.translateX_ = xy.x;
+  clone.translateY_ = xy.y;
+  clone.setAttribute('transform', 'translate(' + xy.x + ',' + xy.y + ')');
+  workspace.getParentSvg().appendChild(clone);
+  clone.bBox_ = clone.getBBox();
+  // Start the animation.
+  Blockly.BlockAnimations.disposeUiStep_(clone, workspace.RTL, new Date,
+      workspace.scale);
+};
+
+/**
+ * Animate a cloned block and eventually dispose of it.
+ * This is a class method, not an instance method since the original block has
+ * been destroyed and is no longer accessible.
+ * @param {!Element} clone SVG element to animate and dispose of.
+ * @param {boolean} rtl True if RTL, false if LTR.
+ * @param {!Date} start Date of animation's start.
+ * @param {number} workspaceScale Scale of workspace.
+ * @private
+ */
+Blockly.BlockAnimations.disposeUiStep_ = function(clone, rtl, start,
+    workspaceScale) {
+  var ms = new Date - start;
+  var percent = ms / 150;
+  if (percent > 1) {
+    goog.dom.removeNode(clone);
+  } else {
+    var x = clone.translateX_ +
+        (rtl ? -1 : 1) * clone.bBox_.width * workspaceScale / 2 * percent;
+    var y = clone.translateY_ + clone.bBox_.height * workspaceScale * percent;
+    var scale = (1 - percent) * workspaceScale;
+    clone.setAttribute('transform', 'translate(' + x + ',' + y + ')' +
+        ' scale(' + scale + ')');
+    setTimeout(Blockly.BlockAnimations.disposeUiStep_, 10, clone, rtl, start,
+        workspaceScale);
+  }
+};
+
+/**
+ * Play some UI effects (sound, ripple) after a connection has been established.
+ * @param {!Blockly.BlockSvg} block The block being connected.
+ * @package
+ */
+Blockly.BlockAnimations.connectionUiEffect = function(block) {
+  block.workspace.getAudioManager().play('click');
+};
+
+/**
+ * Play some UI effects (sound, animation) when disconnecting a block.
+ * No-op in scratch-blocks, which has no disconnect animation.
+ * @param {!Blockly.BlockSvg} _block The block being disconnected.
+ * @package
+ */
+Blockly.BlockAnimations.disconnectUiEffect = function(
+    /* eslint-disable no-unused-vars */ _block
+    /* eslint-enable no-unused-vars */) {
+};
+
+/**
+ * Stop the disconnect UI animation immediately.
+ * No-op in scratch-blocks, which has no disconnect animation.
+ * @package
+ */
+Blockly.BlockAnimations.disconnectUiStop = function() {
+};

core/block_drag_surface.js

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2016 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.
+ */
+
+/**
+ * @fileoverview A class that manages a surface for dragging blocks.  When a
+ * block drag is started, we move the block (and children) to a separate DOM
+ * element that we move around using translate3d. At the end of the drag, the
+ * blocks are put back in into the SVG they came from. This helps performance by
+ * avoiding repainting the entire SVG on every mouse move while dragging blocks.
+ * @author picklesrus
+ */
+
+'use strict';
+
+goog.provide('Blockly.BlockDragSurfaceSvg');
+goog.require('Blockly.utils');
+goog.require('goog.asserts');
+goog.require('goog.math.Coordinate');
+
+
+/**
+ * Class for a drag surface for the currently dragged block. This is a separate
+ * SVG that contains only the currently moving block, or nothing.
+ * @param {!Element} container Containing element.
+ * @constructor
+ */
+Blockly.BlockDragSurfaceSvg = function(container) {
+  /**
+   * @type {!Element}
+   * @private
+   */
+  this.container_ = container;
+  this.createDom();
+};
+
+/**
+ * The SVG drag surface. Set once by Blockly.BlockDragSurfaceSvg.createDom.
+ * @type {Element}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.SVG_ = null;
+
+/**
+ * This is where blocks live while they are being dragged if the drag surface
+ * is enabled.
+ * @type {Element}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.dragGroup_ = null;
+
+/**
+ * Containing HTML element; parent of the workspace and the drag surface.
+ * @type {Element}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.container_ = null;
+
+/**
+ * Cached value for the scale of the drag surface.
+ * Used to set/get the correct translation during and after a drag.
+ * @type {number}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.scale_ = 1;
+
+/**
+ * Cached value for the translation of the drag surface.
+ * This translation is in pixel units, because the scale is applied to the
+ * drag group rather than the top-level SVG.
+ * @type {goog.math.Coordinate}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.surfaceXY_ = null;
+
+/**
+ * ID for the drag shadow filter, set in createDom.
+ * Belongs in Scratch Blocks but not Blockly.
+ * @type {string}
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.dragShadowFilterId_ = '';
+
+/**
+ * Standard deviation for gaussian blur on drag shadow, in px.
+ * Belongs in Scratch Blocks but not Blockly.
+ * @type {number}
+ * @const
+ */
+Blockly.BlockDragSurfaceSvg.SHADOW_STD_DEVIATION = 6;
+
+/**
+ * Create the drag surface and inject it into the container.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.createDom = function() {
+  if (this.SVG_) {
+    return;  // Already created.
+  }
+  this.SVG_ = Blockly.utils.createSvgElement('svg',
+      {
+        'xmlns': Blockly.SVG_NS,
+        'xmlns:html': Blockly.HTML_NS,
+        'xmlns:xlink': 'http://www.w3.org/1999/xlink',
+        'version': '1.1',
+        'class': 'blocklyBlockDragSurface'
+      }, this.container_);
+  this.dragGroup_ = Blockly.utils.createSvgElement('g', {}, this.SVG_);
+  // Belongs in Scratch Blocks, but not Blockly.
+  var defs = Blockly.utils.createSvgElement('defs', {}, this.SVG_);
+  this.dragShadowFilterId_ = this.createDropShadowDom_(defs);
+  this.dragGroup_.setAttribute(
+      'filter', 'url(#' + this.dragShadowFilterId_ + ')');
+};
+
+/**
+ * Scratch-specific: Create the SVG def for the drop shadow.
+ * @param {Element} defs Defs element to insert the shadow filter definition
+ * @return {string} ID for the filter element
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.createDropShadowDom_ = function(defs) {
+  var rnd = String(Math.random()).substring(2);
+  // Adjust these width/height, x/y properties to stop the shadow from clipping
+  var dragShadowFilter = Blockly.utils.createSvgElement('filter',
+      {
+        'id': 'blocklyDragShadowFilter' + rnd,
+        'height': '140%',
+        'width': '140%',
+        'y': '-20%',
+        'x': '-20%'
+      },
+      defs);
+  Blockly.utils.createSvgElement('feGaussianBlur',
+      {
+        'in': 'SourceAlpha',
+        'stdDeviation': Blockly.BlockDragSurfaceSvg.SHADOW_STD_DEVIATION
+      },
+      dragShadowFilter);
+  var componentTransfer = Blockly.utils.createSvgElement(
+      'feComponentTransfer', {'result': 'offsetBlur'}, dragShadowFilter);
+  // Shadow opacity is specified in the adjustable colour library,
+  // since the darkness of the shadow largely depends on the workspace colour.
+  Blockly.utils.createSvgElement('feFuncA',
+      {
+        'type': 'linear',
+        'slope': Blockly.Colours.dragShadowOpacity
+      },
+      componentTransfer);
+  Blockly.utils.createSvgElement('feComposite',
+      {
+        'in': 'SourceGraphic',
+        'in2': 'offsetBlur',
+        'operator': 'over'
+      },
+      dragShadowFilter);
+  return dragShadowFilter.id;
+};
+
+/**
+ * Set the SVG blocks on the drag surface's group and show the surface.
+ * Only one block group should be on the drag surface at a time.
+ * @param {!Element} blocks Block or group of blocks to place on the drag
+ * surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.setBlocksAndShow = function(blocks) {
+  goog.asserts.assert(
+      this.dragGroup_.childNodes.length == 0, 'Already dragging a block.');
+  // appendChild removes the blocks from the previous parent
+  this.dragGroup_.appendChild(blocks);
+  this.SVG_.style.display = 'block';
+  this.surfaceXY_ = new goog.math.Coordinate(0, 0);
+  // This allows blocks to be dragged outside of the blockly svg space.
+  // This should be reset to hidden at the end of the block drag.
+  // Note that this behavior is different from blockly where block disappear
+  // "under" the blockly area.
+  var injectionDiv = document.getElementsByClassName('injectionDiv')[0];
+  injectionDiv.style.overflow = 'visible';
+};
+
+/**
+ * Translate and scale the entire drag surface group to the given position, to
+ * keep in sync with the workspace.
+ * @param {number} x X translation in workspace coordinates.
+ * @param {number} y Y translation in workspace coordinates.
+ * @param {number} scale Scale of the group.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateAndScaleGroup = function(x, y, scale) {
+  this.scale_ = scale;
+  // This is a work-around to prevent a the blocks from rendering
+  // fuzzy while they are being dragged on the drag surface.
+  var fixedX = x.toFixed(0);
+  var fixedY = y.toFixed(0);
+  this.dragGroup_.setAttribute('transform',
+      'translate(' + fixedX + ',' + fixedY + ') scale(' + scale + ')');
+};
+
+/**
+ * Translate the drag surface's SVG based on its internal state.
+ * @private
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateSurfaceInternal_ = function() {
+  var x = this.surfaceXY_.x;
+  var y = this.surfaceXY_.y;
+  // This is a work-around to prevent a the blocks from rendering
+  // fuzzy while they are being dragged on the drag surface.
+  x = x.toFixed(0);
+  y = y.toFixed(0);
+  this.SVG_.style.display = 'block';
+
+  Blockly.utils.setCssTransform(this.SVG_,
+      'translate(' + x + 'px, ' + y + 'px)');
+};
+
+/**
+ * Translate the entire drag surface during a drag.
+ * We translate the drag surface instead of the blocks inside the surface
+ * so that the browser avoids repainting the SVG.
+ * Because of this, the drag coordinates must be adjusted by scale.
+ * @param {number} x X translation for the entire surface.
+ * @param {number} y Y translation for the entire surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.translateSurface = function(x, y) {
+  this.surfaceXY_ = new goog.math.Coordinate(x * this.scale_, y * this.scale_);
+  this.translateSurfaceInternal_();
+};
+
+/**
+ * Reports the surface translation in scaled workspace coordinates.
+ * Use this when finishing a drag to return blocks to the correct position.
+ * @return {!goog.math.Coordinate} Current translation of the surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getSurfaceTranslation = function() {
+  var xy = Blockly.utils.getRelativeXY(this.SVG_);
+  return new goog.math.Coordinate(xy.x / this.scale_, xy.y / this.scale_);
+};
+
+/**
+ * Provide a reference to the drag group (primarily for
+ * BlockSvg.getRelativeToSurfaceXY).
+ * @return {Element} Drag surface group element.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getGroup = function() {
+  return this.dragGroup_;
+};
+
+/**
+ * Get the current blocks on the drag surface, if any (primarily
+ * for BlockSvg.getRelativeToSurfaceXY).
+ * @return {!Element|undefined} Drag surface block DOM element, or undefined
+ * if no blocks exist.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.getCurrentBlock = function() {
+  return this.dragGroup_.firstChild;
+};
+
+/**
+ * Clear the group and hide the surface; move the blocks off onto the provided
+ * element.
+ * If the block is being deleted it doesn't need to go back to the original
+ * surface, since it would be removed immediately during dispose.
+ * @param {Element=} opt_newSurface Surface the dragging blocks should be moved
+ *     to, or null if the blocks should be removed from this surface without
+ *     being moved to a different surface.
+ */
+Blockly.BlockDragSurfaceSvg.prototype.clearAndHide = function(opt_newSurface) {
+  if (opt_newSurface) {
+    // appendChild removes the node from this.dragGroup_
+    opt_newSurface.appendChild(this.getCurrentBlock());
+  } else {
+    this.dragGroup_.removeChild(this.getCurrentBlock());
+  }
+  this.SVG_.style.display = 'none';
+  goog.asserts.assert(
+      this.dragGroup_.childNodes.length == 0, 'Drag group was not cleared.');
+  this.surfaceXY_ = null;
+
+  // Reset the overflow property back to hidden so that nothing appears outside
+  // of the blockly area.
+  // Note that this behavior is different from blockly. See note in
+  // setBlocksAndShow.
+  var injectionDiv = document.getElementsByClassName('injectionDiv')[0];
+  injectionDiv.style.overflow = 'hidden';
+};

core/block_dragger.js

@@ -0,0 +1,425 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2017 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.
+ */
+
+/**
+ * @fileoverview Methods for dragging a block visually.
+ * @author [email protected] (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.BlockDragger');
+
+goog.require('Blockly.BlockAnimations');
+goog.require('Blockly.Events.BlockMove');
+goog.require('Blockly.Events.DragBlockOutside');
+goog.require('Blockly.Events.EndBlockDrag');
+goog.require('Blockly.InsertionMarkerManager');
+
+goog.require('goog.math.Coordinate');
+goog.require('goog.asserts');
+
+
+/**
+ * Class for a block dragger.  It moves blocks around the workspace when they
+ * are being dragged by a mouse or touch.
+ * @param {!Blockly.BlockSvg} block The block to drag.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace to drag on.
+ * @constructor
+ */
+Blockly.BlockDragger = function(block, workspace) {
+  /**
+   * The top block in the stack that is being dragged.
+   * @type {!Blockly.BlockSvg}
+   * @private
+   */
+  this.draggingBlock_ = block;
+
+  /**
+   * The workspace on which the block is being dragged.
+   * @type {!Blockly.WorkspaceSvg}
+   * @private
+   */
+  this.workspace_ = workspace;
+
+  /**
+   * Object that keeps track of connections on dragged blocks.
+   * @type {!Blockly.InsertionMarkerManager}
+   * @private
+   */
+  this.draggedConnectionManager_ = new Blockly.InsertionMarkerManager(
+      this.draggingBlock_);
+
+  /**
+   * Which delete area the mouse pointer is over, if any.
+   * One of {@link Blockly.DELETE_AREA_TRASH},
+   * {@link Blockly.DELETE_AREA_TOOLBOX}, or {@link Blockly.DELETE_AREA_NONE}.
+   * @type {?number}
+   * @private
+   */
+  this.deleteArea_ = null;
+
+  /**
+   * Whether the block would be deleted if dropped immediately.
+   * @type {boolean}
+   * @private
+   */
+  this.wouldDeleteBlock_ = false;
+
+  /**
+   * Whether the currently dragged block is outside of the workspace. Keep
+   * track so that we can fire events only when this changes.
+   * @type {boolean}
+   * @private
+   */
+  this.wasOutside_ = false;
+
+  /**
+   * The location of the top left corner of the dragging block at the beginning
+   * of the drag in workspace coordinates.
+   * @type {!goog.math.Coordinate}
+   * @private
+   */
+  this.startXY_ = this.draggingBlock_.getRelativeToSurfaceXY();
+
+  /**
+   * A list of all of the icons (comment, warning, and mutator) that are
+   * on this block and its descendants.  Moving an icon moves the bubble that
+   * extends from it if that bubble is open.
+   * @type {Array.<!Object>}
+   * @private
+   */
+  this.dragIconData_ = Blockly.BlockDragger.initIconData_(block);
+};
+
+/**
+ * Sever all links from this object.
+ * @package
+ */
+Blockly.BlockDragger.prototype.dispose = function() {
+  this.draggingBlock_ = null;
+  this.workspace_ = null;
+  this.startWorkspace_ = null;
+  this.dragIconData_.length = 0;
+
+  if (this.draggedConnectionManager_) {
+    this.draggedConnectionManager_.dispose();
+    this.draggedConnectionManager_ = null;
+  }
+};
+
+/**
+ * Make a list of all of the icons (comment, warning, and mutator) that are
+ * on this block and its descendants.  Moving an icon moves the bubble that
+ * extends from it if that bubble is open.
+ * @param {!Blockly.BlockSvg} block The root block that is being dragged.
+ * @return {!Array.<!Object>} The list of all icons and their locations.
+ * @private
+ */
+Blockly.BlockDragger.initIconData_ = function(block) {
+  // Build a list of icons that need to be moved and where they started.
+  var dragIconData = [];
+  var descendants = block.getDescendants(false);
+  for (var i = 0, descendant; descendant = descendants[i]; i++) {
+    var icons = descendant.getIcons();
+    for (var j = 0; j < icons.length; j++) {
+      var data = {
+        // goog.math.Coordinate with x and y properties (workspace coordinates).
+        location: icons[j].getIconLocation(),
+        // Blockly.Icon
+        icon: icons[j]
+      };
+      dragIconData.push(data);
+    }
+  }
+  return dragIconData;
+};
+
+/**
+ * Start dragging a block.  This includes moving it to the drag surface.
+ * @param {!goog.math.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at mouse down, in pixel units.
+ * @package
+ */
+Blockly.BlockDragger.prototype.startBlockDrag = function(currentDragDeltaXY) {
+  if (!Blockly.Events.getGroup()) {
+    Blockly.Events.setGroup(true);
+  }
+
+  this.workspace_.setResizesEnabled(false);
+  Blockly.BlockAnimations.disconnectUiStop();
+
+  if (this.draggingBlock_.getParent()) {
+    this.draggingBlock_.unplug();
+    var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+    var newLoc = goog.math.Coordinate.sum(this.startXY_, delta);
+
+    this.draggingBlock_.translate(newLoc.x, newLoc.y);
+    Blockly.BlockAnimations.disconnectUiEffect(this.draggingBlock_);
+  }
+  this.draggingBlock_.setDragging(true);
+  // For future consideration: we may be able to put moveToDragSurface inside
+  // the block dragger, which would also let the block not track the block drag
+  // surface.
+  this.draggingBlock_.moveToDragSurface_();
+
+  var toolbox = this.workspace_.getToolbox();
+  if (toolbox) {
+    var style = this.draggingBlock_.isDeletable() ? 'blocklyToolboxDelete' :
+        'blocklyToolboxGrab';
+    toolbox.addStyle(style);
+  }
+};
+
+/**
+ * Execute a step of block dragging, based on the given event.  Update the
+ * display accordingly.
+ * @param {!Event} e The most recent move event.
+ * @param {!goog.math.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @package
+ * @return {boolean} True if the event should be propagated, false if not.
+ */
+Blockly.BlockDragger.prototype.dragBlock = function(e, currentDragDeltaXY) {
+  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  var newLoc = goog.math.Coordinate.sum(this.startXY_, delta);
+
+  this.draggingBlock_.moveDuringDrag(newLoc);
+  this.dragIcons_(delta);
+
+  this.deleteArea_ = this.workspace_.isDeleteArea(e);
+  var isOutside = !this.workspace_.isInsideBlocksArea(e);
+  this.draggedConnectionManager_.update(delta, this.deleteArea_, isOutside);
+  if (isOutside !== this.wasOutside_) {
+    this.fireDragOutsideEvent_(isOutside);
+    this.wasOutside_ = isOutside;
+  }
+
+  this.updateCursorDuringBlockDrag_(isOutside);
+  return isOutside;
+};
+
+/**
+ * Finish a block drag and put the block back on the workspace.
+ * @param {!Event} e The mouseup/touchend event.
+ * @param {!goog.math.Coordinate} currentDragDeltaXY How far the pointer has
+ *     moved from the position at the start of the drag, in pixel units.
+ * @package
+ */
+Blockly.BlockDragger.prototype.endBlockDrag = function(e, currentDragDeltaXY) {
+  // Make sure internal state is fresh.
+  this.dragBlock(e, currentDragDeltaXY);
+  this.dragIconData_ = [];
+  var isOutside = this.wasOutside_;
+  this.fireEndDragEvent_(isOutside);
+  this.draggingBlock_.setMouseThroughStyle(false);
+
+  Blockly.BlockAnimations.disconnectUiStop();
+
+  var delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+  var newLoc = goog.math.Coordinate.sum(this.startXY_, delta);
+  this.draggingBlock_.moveOffDragSurface_(newLoc);
+
+  // Scratch-specific: note possible illegal definition deletion for rollback below.
+  var isDeletingProcDef = this.wouldDeleteBlock_ &&
+      (this.draggingBlock_.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE ||
+      this.draggingBlock_.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE + '_return');
+  if (isDeletingProcDef) {
+    var procCodeBeingDeleted = this.draggingBlock_.getInput('custom_block').connection.targetBlock().getProcCode();
+  }
+
+  var deleted = this.maybeDeleteBlock_();
+  if (!deleted) {
+    // These are expensive and don't need to be done if we're deleting.
+    this.draggingBlock_.moveConnections_(delta.x, delta.y);
+    this.draggingBlock_.setDragging(false);
+    this.fireMoveEvent_();
+    if (this.draggedConnectionManager_.wouldConnectBlock()) {
+      // Applying connections also rerenders the relevant blocks.
+      this.draggedConnectionManager_.applyConnections();
+    } else {
+      this.draggingBlock_.render();
+    }
+    this.draggingBlock_.scheduleSnapAndBump();
+  }
+  this.workspace_.setResizesEnabled(true);
+
+  var toolbox = this.workspace_.getToolbox();
+  if (toolbox) {
+    var style = this.draggingBlock_.isDeletable() ? 'blocklyToolboxDelete' :
+        'blocklyToolboxGrab';
+    toolbox.removeStyle(style);
+  }
+  Blockly.Events.setGroup(false);
+
+  if (isOutside) {
+    var ws = this.workspace_;
+    // Reset a drag to outside of scratch-blocks
+    setTimeout(function() {
+      ws.undo();
+    });
+  }
+
+  // Scratch-specific: roll back deletes that create call blocks with defines.
+  // Have to wait for connections to be re-established, so put in setTimeout.
+  // Only do this if we deleted a proc def.
+  if (isDeletingProcDef) {
+    var ws = this.workspace_;
+    setTimeout(function() {
+      var allBlocks = ws.getAllBlocks();
+      for (var i = 0; i < allBlocks.length; i++) {
+        var block = allBlocks[i];
+        if (block.type == Blockly.PROCEDURES_CALL_BLOCK_TYPE) {
+          var procCode = block.getProcCode();
+          // Check for call blocks with no associated define block.
+          if (procCode === procCodeBeingDeleted) {
+            alert(Blockly.Msg.PROCEDURE_USED);
+            ws.undo();
+            return; // There can only be one define deletion at a time.
+          }
+        }
+      }
+      // The proc deletion was valid, update the toolbox.
+      ws.refreshToolboxSelection_();
+    });
+  }
+};
+
+/**
+ * Fire an event when the dragged blocks move outside or back into the blocks workspace
+ * @param {?boolean} isOutside True if the drag is going outside the visible area.
+ * @private
+ */
+Blockly.BlockDragger.prototype.fireDragOutsideEvent_ = function(isOutside) {
+  var event = new Blockly.Events.DragBlockOutside(this.draggingBlock_);
+  event.isOutside = isOutside;
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Fire an end drag event at the end of a block drag.
+ * @param {?boolean} isOutside True if the drag is going outside the visible area.
+ * @private
+ */
+Blockly.BlockDragger.prototype.fireEndDragEvent_ = function(isOutside) {
+  var event = new Blockly.Events.EndBlockDrag(this.draggingBlock_, isOutside);
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Fire a move event at the end of a block drag.
+ * @private
+ */
+Blockly.BlockDragger.prototype.fireMoveEvent_ = function() {
+  var event = new Blockly.Events.BlockMove(this.draggingBlock_);
+  event.oldCoordinate = this.startXY_;
+  event.recordNew();
+  Blockly.Events.fire(event);
+};
+
+/**
+ * Shut the trash can and, if necessary, delete the dragging block.
+ * Should be called at the end of a block drag.
+ * @return {boolean} whether the block was deleted.
+ * @private
+ */
+Blockly.BlockDragger.prototype.maybeDeleteBlock_ = function() {
+  var trashcan = this.workspace_.trashcan;
+
+  if (this.wouldDeleteBlock_) {
+    if (trashcan) {
+      goog.Timer.callOnce(trashcan.close, 100, trashcan);
+    }
+    // Fire a move event, so we know where to go back to for an undo.
+    this.fireMoveEvent_();
+    this.draggingBlock_.dispose(false, true);
+  } else if (trashcan) {
+    // Make sure the trash can is closed.
+    trashcan.close();
+  }
+  return this.wouldDeleteBlock_;
+};
+
+/**
+ * Update the cursor (and possibly the trash can lid) to reflect whether the
+ * dragging block would be deleted if released immediately.
+ * @param {boolean} isOutside True if the cursor is outside of the blocks workspace
+ * @private
+ */
+Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_ = function(isOutside) {
+  this.wouldDeleteBlock_ = this.draggedConnectionManager_.wouldDeleteBlock();
+  var trashcan = this.workspace_.trashcan;
+  if (this.wouldDeleteBlock_) {
+    this.draggingBlock_.setDeleteStyle(true);
+    if (this.deleteArea_ == Blockly.DELETE_AREA_TRASH && trashcan) {
+      trashcan.setOpen_(true);
+    }
+  } else {
+    this.draggingBlock_.setDeleteStyle(false);
+    if (trashcan) {
+      trashcan.setOpen_(false);
+    }
+  }
+
+  if (isOutside) {
+    // Let mouse events through to GUI
+    this.draggingBlock_.setMouseThroughStyle(true);
+  } else {
+    this.draggingBlock_.setMouseThroughStyle(false);
+  }
+};
+
+/**
+ * Convert a coordinate object from pixels to workspace units, including a
+ * correction for mutator workspaces.
+ * This function does not consider differing origins.  It simply scales the
+ * input's x and y values.
+ * @param {!goog.math.Coordinate} pixelCoord A coordinate with x and y values
+ *     in css pixel units.
+ * @return {!goog.math.Coordinate} The input coordinate divided by the workspace
+ *     scale.
+ * @private
+ */
+Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_ = function(pixelCoord) {
+  var result = new goog.math.Coordinate(pixelCoord.x / this.workspace_.scale,
+      pixelCoord.y / this.workspace_.scale);
+  if (this.workspace_.isMutator) {
+    // If we're in a mutator, its scale is always 1, purely because of some
+    // oddities in our rendering optimizations.  The actual scale is the same as
+    // the scale on the parent workspace.
+    // Fix that for dragging.
+    var mainScale = this.workspace_.options.parentWorkspace.scale;
+    result = result.scale(1 / mainScale);
+  }
+  return result;
+};
+
+/**
+ * Move all of the icons connected to this drag.
+ * @param {!goog.math.Coordinate} dxy How far to move the icons from their
+ *     original positions, in workspace units.
+ * @private
+ */
+Blockly.BlockDragger.prototype.dragIcons_ = function(dxy) {
+  // Moving icons moves their associated bubbles.
+  for (var i = 0; i < this.dragIconData_.length; i++) {
+    var data = this.dragIconData_[i];
+    data.icon.setIconLocation(goog.math.Coordinate.sum(data.location, dxy));
+  }
+};

core/block_events.js

@@ -0,0 +1,531 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2018 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.
+ */
+
+/**
+ * @fileoverview Classes for all types of block events.
+ * @author [email protected] (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.Events.BlockBase');
+goog.provide('Blockly.Events.BlockChange');
+goog.provide('Blockly.Events.BlockCreate');
+goog.provide('Blockly.Events.BlockDelete');
+goog.provide('Blockly.Events.BlockMove');
+goog.provide('Blockly.Events.Change');  // Deprecated.
+goog.provide('Blockly.Events.Create');  // Deprecated.
+goog.provide('Blockly.Events.Delete');  // Deprecated.
+goog.provide('Blockly.Events.Move');  // Deprecated.
+
+goog.require('Blockly.Events');
+goog.require('Blockly.Events.Abstract');
+
+goog.require('goog.array');
+goog.require('goog.math.Coordinate');
+
+
+/**
+ * Abstract class for a block event.
+ * @param {Blockly.Block} block The block this event corresponds to.
+ * @extends {Blockly.Events.Abstract}
+ * @constructor
+ */
+Blockly.Events.BlockBase = function(block) {
+  Blockly.Events.BlockBase.superClass_.constructor.call(this);
+
+  /**
+   * The block id for the block this event pertains to
+   * @type {string}
+   */
+  this.blockId = block.id;
+  this.workspaceId = block.workspace.id;
+};
+goog.inherits(Blockly.Events.BlockBase, Blockly.Events.Abstract);
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.BlockBase.prototype.toJson = function() {
+  var json = Blockly.Events.BlockBase.superClass_.toJson.call(this);
+  json['blockId'] = this.blockId;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.BlockBase.prototype.fromJson = function(json) {
+  Blockly.Events.BlockBase.superClass_.toJson.call(this);
+  this.blockId = json['blockId'];
+};
+
+/**
+ * Class for a block change event.
+ * @param {Blockly.Block} block The changed block.  Null for a blank event.
+ * @param {string} element One of 'field', 'comment', 'disabled', etc.
+ * @param {?string} name Name of input or field affected, or null.
+ * @param {*} oldValue Previous value of element.
+ * @param {*} newValue New value of element.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Change = function(block, element, name, oldValue, newValue) {
+  if (!block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  Blockly.Events.Change.superClass_.constructor.call(this, block);
+  this.element = element;
+  this.name = name;
+  this.oldValue = oldValue;
+  this.newValue = newValue;
+};
+goog.inherits(Blockly.Events.Change, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block change event.
+ * @param {Blockly.Block} block The changed block.  Null for a blank event.
+ * @param {string} element One of 'field', 'comment', 'disabled', etc.
+ * @param {?string} name Name of input or field affected, or null.
+ * @param {*} oldValue Previous value of element.
+ * @param {*} newValue New value of element.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockChange = Blockly.Events.Change;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Change.prototype.type = Blockly.Events.CHANGE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Change.prototype.toJson = function() {
+  var json = Blockly.Events.Change.superClass_.toJson.call(this);
+  json['element'] = this.element;
+  if (this.name) {
+    json['name'] = this.name;
+  }
+  json['newValue'] = this.newValue;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Change.prototype.fromJson = function(json) {
+  Blockly.Events.Change.superClass_.fromJson.call(this, json);
+  this.element = json['element'];
+  this.name = json['name'];
+  this.newValue = json['newValue'];
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.Change.prototype.isNull = function() {
+  return this.oldValue == this.newValue;
+};
+
+/**
+ * Run a change event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Change.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var block = workspace.getBlockById(this.blockId);
+  if (!block) {
+    console.warn("Can't change non-existent block: " + this.blockId);
+    return;
+  }
+  if (block.mutator) {
+    // Close the mutator (if open) since we don't want to update it.
+    block.mutator.setVisible(false);
+  }
+  var value = forward ? this.newValue : this.oldValue;
+  switch (this.element) {
+    case 'field':
+      var field = block.getField(this.name);
+      if (field) {
+        // Run the validator for any side-effects it may have.
+        // The validator's opinion on validity is ignored.
+        field.callValidator(value);
+        field.setValue(value);
+      } else {
+        console.warn("Can't set non-existent field: " + this.name);
+      }
+      break;
+    case 'comment':
+      block.setCommentText(value || null);
+      break;
+    case 'collapsed':
+      block.setCollapsed(value);
+      break;
+    case 'disabled':
+      block.setDisabled(value);
+      break;
+    case 'inline':
+      block.setInputsInline(value);
+      break;
+    case 'mutation':
+      var oldMutation = '';
+      if (block.mutationToDom) {
+        var oldMutationDom = block.mutationToDom();
+        oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom);
+      }
+      if (block.domToMutation) {
+        value = value || '<mutation></mutation>';
+        var dom = Blockly.Xml.textToDom('<xml>' + value + '</xml>');
+        block.domToMutation(dom.firstChild);
+      }
+      Blockly.Events.fire(new Blockly.Events.Change(
+          block, 'mutation', null, oldMutation, value));
+      break;
+    default:
+      console.warn('Unknown change type: ' + this.element);
+  }
+};
+
+/**
+ * Class for a block creation event.
+ * @param {Blockly.Block} block The created block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Create = function(block) {
+  if (!block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  Blockly.Events.Create.superClass_.constructor.call(this, block);
+
+  if (block.workspace.rendered) {
+    this.xml = Blockly.Xml.blockToDomWithXY(block);
+  } else {
+    this.xml = Blockly.Xml.blockToDom(block);
+  }
+  this.ids = Blockly.Events.getDescendantIds_(block);
+};
+goog.inherits(Blockly.Events.Create, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block creation event.
+ * @param {Blockly.Block} block The created block. Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockCreate = Blockly.Events.Create;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Create.prototype.type = Blockly.Events.CREATE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Create.prototype.toJson = function() {
+  var json = Blockly.Events.Create.superClass_.toJson.call(this);
+  json['xml'] = Blockly.Xml.domToText(this.xml);
+  json['ids'] = this.ids;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Create.prototype.fromJson = function(json) {
+  Blockly.Events.Create.superClass_.fromJson.call(this, json);
+  this.xml = Blockly.Xml.textToDom('<xml>' + json['xml'] + '</xml>').firstChild;
+  this.ids = json['ids'];
+};
+
+/**
+ * Run a creation event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Create.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    var xml = goog.dom.createDom('xml');
+    xml.appendChild(this.xml);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  } else {
+    for (var i = 0, id; id = this.ids[i]; i++) {
+      var block = workspace.getBlockById(id);
+      if (block) {
+        block.dispose(false, false);
+      } else if (id == this.blockId) {
+        // Only complain about root-level block.
+        console.warn("Can't uncreate non-existent block: " + id);
+      }
+    }
+  }
+};
+
+/**
+ * Class for a block deletion event.
+ * @param {Blockly.Block} block The deleted block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Delete = function(block) {
+  if (!block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  if (block.getParent()) {
+    throw 'Connected blocks cannot be deleted.';
+  }
+  Blockly.Events.Delete.superClass_.constructor.call(this, block);
+
+  if (block.workspace.rendered) {
+    this.oldXml = Blockly.Xml.blockToDomWithXY(block);
+  } else {
+    this.oldXml = Blockly.Xml.blockToDom(block);
+  }
+  this.ids = Blockly.Events.getDescendantIds_(block);
+};
+goog.inherits(Blockly.Events.Delete, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block deletion event.
+ * @param {Blockly.Block} block The deleted block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockDelete = Blockly.Events.Delete;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Delete.prototype.type = Blockly.Events.DELETE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Delete.prototype.toJson = function() {
+  var json = Blockly.Events.Delete.superClass_.toJson.call(this);
+  json['ids'] = this.ids;
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Delete.prototype.fromJson = function(json) {
+  Blockly.Events.Delete.superClass_.fromJson.call(this, json);
+  this.ids = json['ids'];
+};
+
+/**
+ * Run a deletion event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Delete.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  if (forward) {
+    for (var i = 0, id; id = this.ids[i]; i++) {
+      var block = workspace.getBlockById(id);
+      if (block) {
+        block.dispose(false, false);
+      } else if (id == this.blockId) {
+        // Only complain about root-level block.
+        console.warn("Can't delete non-existent block: " + id);
+      }
+    }
+  } else {
+    var xml = goog.dom.createDom('xml');
+    xml.appendChild(this.oldXml);
+    Blockly.Xml.domToWorkspace(xml, workspace);
+  }
+};
+
+/**
+ * Class for a block move event.  Created before the move.
+ * @param {Blockly.Block} block The moved block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.Move = function(block) {
+  if (!block) {
+    return;  // Blank event to be populated by fromJson.
+  }
+  Blockly.Events.Move.superClass_.constructor.call(this, block);
+  var location = this.currentLocation_();
+  this.oldParentId = location.parentId;
+  this.oldInputName = location.inputName;
+  this.oldCoordinate = location.coordinate;
+};
+goog.inherits(Blockly.Events.Move, Blockly.Events.BlockBase);
+
+/**
+ * Class for a block move event.  Created before the move.
+ * @param {Blockly.Block} block The moved block.  Null for a blank event.
+ * @extends {Blockly.Events.BlockBase}
+ * @constructor
+ */
+Blockly.Events.BlockMove = Blockly.Events.Move;
+
+/**
+ * Type of this event.
+ * @type {string}
+ */
+Blockly.Events.Move.prototype.type = Blockly.Events.MOVE;
+
+/**
+ * Encode the event as JSON.
+ * @return {!Object} JSON representation.
+ */
+Blockly.Events.Move.prototype.toJson = function() {
+  var json = Blockly.Events.Move.superClass_.toJson.call(this);
+  if (this.newParentId) {
+    json['newParentId'] = this.newParentId;
+  }
+  if (this.newInputName) {
+    json['newInputName'] = this.newInputName;
+  }
+  if (this.newCoordinate) {
+    json['newCoordinate'] = Math.round(this.newCoordinate.x) + ',' +
+        Math.round(this.newCoordinate.y);
+  }
+  return json;
+};
+
+/**
+ * Decode the JSON event.
+ * @param {!Object} json JSON representation.
+ */
+Blockly.Events.Move.prototype.fromJson = function(json) {
+  Blockly.Events.Move.superClass_.fromJson.call(this, json);
+  this.newParentId = json['newParentId'];
+  this.newInputName = json['newInputName'];
+  if (json['newCoordinate']) {
+    var xy = json['newCoordinate'].split(',');
+    this.newCoordinate =
+        new goog.math.Coordinate(parseFloat(xy[0]), parseFloat(xy[1]));
+  }
+};
+
+/**
+ * Record the block's new location.  Called after the move.
+ */
+Blockly.Events.Move.prototype.recordNew = function() {
+  var location = this.currentLocation_();
+  this.newParentId = location.parentId;
+  this.newInputName = location.inputName;
+  this.newCoordinate = location.coordinate;
+};
+
+/**
+ * Returns the parentId and input if the block is connected,
+ *   or the XY location if disconnected.
+ * @return {!Object} Collection of location info.
+ * @private
+ */
+Blockly.Events.Move.prototype.currentLocation_ = function() {
+  var workspace = Blockly.Workspace.getById(this.workspaceId);
+  var block = workspace.getBlockById(this.blockId);
+  var location = {};
+  var parent = block.getParent();
+  if (parent) {
+    location.parentId = parent.id;
+    var input = parent.getInputWithBlock(block);
+    if (input) {
+      location.inputName = input.name;
+    }
+  } else {
+    var blockXY = block.getRelativeToSurfaceXY();
+    // The X position in the block move event should be the language agnostic
+    // position of the block. I.e. it should not be different in LTR vs. RTL.
+    var rtlAwareX = workspace.RTL ? workspace.getWidth() - blockXY.x : blockXY.x;
+    location.coordinate = new goog.math.Coordinate(rtlAwareX, blockXY.y);
+  }
+  return location;
+};
+
+/**
+ * Does this event record any change of state?
+ * @return {boolean} False if something changed.
+ */
+Blockly.Events.Move.prototype.isNull = function() {
+  return this.oldParentId == this.newParentId &&
+      this.oldInputName == this.newInputName &&
+      goog.math.Coordinate.equals(this.oldCoordinate, this.newCoordinate);
+};
+
+/**
+ * Run a move event.
+ * @param {boolean} forward True if run forward, false if run backward (undo).
+ */
+Blockly.Events.Move.prototype.run = function(forward) {
+  var workspace = this.getEventWorkspace_();
+  var block = workspace.getBlockById(this.blockId);
+  if (!block) {
+    console.warn("Can't move non-existent block: " + this.blockId);
+    return;
+  }
+  var parentId = forward ? this.newParentId : this.oldParentId;
+  var inputName = forward ? this.newInputName : this.oldInputName;
+  var coordinate = forward ? this.newCoordinate : this.oldCoordinate;
+  var parentBlock = null;
+  if (parentId) {
+    parentBlock = workspace.getBlockById(parentId);
+    if (!parentBlock) {
+      console.warn("Can't connect to non-existent block: " + parentId);
+      return;
+    }
+  }
+  if (block.getParent()) {
+    block.unplug();
+  }
+  if (coordinate) {
+    var xy = block.getRelativeToSurfaceXY();
+    var rtlAwareX = workspace.RTL ? workspace.getWidth() - coordinate.x : coordinate.x;
+    block.moveBy(rtlAwareX - xy.x, coordinate.y - xy.y);
+  } else {
+    var blockConnection = block.outputConnection || block.previousConnection;
+    var parentConnection;
+    if (inputName) {
+      var input = parentBlock.getInput(inputName);
+      if (input) {
+        parentConnection = input.connection;
+      }
+    } else if (blockConnection.type == Blockly.PREVIOUS_STATEMENT) {
+      parentConnection = parentBlock.nextConnection;
+    }
+    if (parentConnection) {
+      blockConnection.connect(parentConnection);
+    } else {
+      console.warn("Can't connect to non-existent input: " + inputName);
+    }
+  }
+};

core/block_svg.js

@@ -0,0 +1,1369 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Methods for graphically rendering a block as SVG.
+ * @author [email protected] (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.BlockSvg');
+
+goog.require('Blockly.Block');
+goog.require('Blockly.BlockAnimations');
+goog.require('Blockly.ContextMenu');
+goog.require('Blockly.Events.Ui');
+goog.require('Blockly.Events.BlockMove');
+goog.require('Blockly.Grid');
+goog.require('Blockly.RenderedConnection');
+goog.require('Blockly.scratchBlocksUtils');
+goog.require('Blockly.Tooltip');
+goog.require('Blockly.Touch');
+goog.require('Blockly.utils');
+
+goog.require('goog.Timer');
+goog.require('goog.asserts');
+goog.require('goog.dom');
+goog.require('goog.math.Coordinate');
+
+
+/**
+ * Class for a block's SVG representation.
+ * Not normally called directly, workspace.newBlock() is preferred.
+ * @param {!Blockly.Workspace} workspace The block's workspace.
+ * @param {?string} prototypeName Name of the language object containing
+ *     type-specific functions for this block.
+ * @param {string=} opt_id Optional ID.  Use this ID if provided, otherwise
+ *     create a new ID.  If the ID conflicts with an in-use ID, a new one will
+ *     be generated.
+ * @extends {Blockly.Block}
+ * @constructor
+ */
+Blockly.BlockSvg = function(workspace, prototypeName, opt_id) {
+  // Create core elements for the block.
+  /**
+   * @type {SVGElement}
+   * @private
+   */
+  this.svgGroup_ = Blockly.utils.createSvgElement('g', {}, null);
+  /** @type {SVGElement} */
+  this.svgPath_ = Blockly.utils.createSvgElement('path',
+      {'class': 'blocklyPath blocklyBlockBackground'},
+      this.svgGroup_);
+  this.svgPath_.tooltip = this;
+
+  /** @type {boolean} */
+  this.rendered = false;
+
+  /**
+   * Whether to move the block to the drag surface when it is dragged.
+   * True if it should move, false if it should be translated directly.
+   * @type {boolean}
+   * @private
+   */
+  this.useDragSurface_ = Blockly.utils.is3dSupported() && !!workspace.blockDragSurface_;
+
+  Blockly.Tooltip.bindMouseEvents(this.svgPath_);
+  Blockly.BlockSvg.superClass_.constructor.call(this,
+      workspace, prototypeName, opt_id);
+
+  // Expose this block's ID on its top-level SVG group.
+  if (this.svgGroup_.dataset) {
+    this.svgGroup_.dataset.id = this.id;
+  }
+};
+goog.inherits(Blockly.BlockSvg, Blockly.Block);
+
+/**
+ * Height of this block, not including any statement blocks above or below.
+ * Height is in workspace units.
+ */
+Blockly.BlockSvg.prototype.height = 0;
+
+/**
+ * Width of this block, including any connected value blocks.
+ * Width is in workspace units.
+ */
+Blockly.BlockSvg.prototype.width = 0;
+
+/**
+ * Minimum width of block if insertion marker; comes from inserting block.
+ * @type {number}
+ */
+Blockly.BlockSvg.prototype.insertionMarkerMinWidth_ = 0;
+
+/**
+ * Opacity of this block between 0 and 1.
+ * @type {number}
+ * @private
+ */
+Blockly.BlockSvg.prototype.opacity_ = 1;
+
+/**
+ * Original location of block being dragged.
+ * @type {goog.math.Coordinate}
+ * @private
+ */
+Blockly.BlockSvg.prototype.dragStartXY_ = null;
+
+/**
+ * Whether the block glows as if running.
+ * @type {boolean}
+ * @private
+ */
+Blockly.BlockSvg.prototype.isGlowingBlock_ = false;
+
+/**
+ * Whether the block's whole stack glows as if running.
+ * @type {boolean}
+ * @private
+ */
+Blockly.BlockSvg.prototype.isGlowingStack_ = false;
+
+/**
+ * Constant for identifying rows that are to be rendered inline.
+ * Don't collide with Blockly.INPUT_VALUE and friends.
+ * @const
+ */
+Blockly.BlockSvg.INLINE = -1;
+
+/**
+ * Create and initialize the SVG representation of the block.
+ * May be called more than once.
+ */
+Blockly.BlockSvg.prototype.initSvg = function() {
+  goog.asserts.assert(this.workspace.rendered, 'Workspace is headless.');
+  if (!this.isInsertionMarker()) { // Insertion markers not allowed to have inputs or icons
+    // Input shapes are empty holes drawn when a value input is not connected.
+    for (var i = 0, input; input = this.inputList[i]; i++) {
+      input.init();
+      input.initOutlinePath(this.svgGroup_);
+    }
+    var icons = this.getIcons();
+    for (i = 0; i < icons.length; i++) {
+      icons[i].createIcon();
+    }
+  }
+  this.updateColour();
+  this.updateMovable();
+  if (!this.workspace.options.readOnly && !this.eventsInit_) {
+    Blockly.bindEventWithChecks_(
+        this.getSvgRoot(), 'mousedown', this, this.onMouseDown_);
+  }
+  this.eventsInit_ = true;
+
+  if (!this.getSvgRoot().parentNode) {
+    this.workspace.getCanvas().appendChild(this.getSvgRoot());
+  }
+};
+
+/**
+ * Select this block.  Highlight it visually.
+ */
+Blockly.BlockSvg.prototype.select = function() {
+  if (this.isShadow() && this.getParent()) {
+    // Shadow blocks should not be selected.
+    this.getParent().select();
+    return;
+  }
+  if (Blockly.selected == this) {
+    return;
+  }
+  var oldId = null;
+  if (Blockly.selected) {
+    oldId = Blockly.selected.id;
+    // Unselect any previously selected block.
+    Blockly.Events.disable();
+    try {
+      Blockly.selected.unselect();
+    } finally {
+      Blockly.Events.enable();
+    }
+  }
+  var event = new Blockly.Events.Ui(null, 'selected', oldId, this.id);
+  event.workspaceId = this.workspace.id;
+  Blockly.Events.fire(event);
+  Blockly.selected = this;
+  this.addSelect();
+};
+
+/**
+ * Unselect this block.  Remove its highlighting.
+ */
+Blockly.BlockSvg.prototype.unselect = function() {
+  if (Blockly.selected != this) {
+    return;
+  }
+  var event = new Blockly.Events.Ui(null, 'selected', this.id, null);
+  event.workspaceId = this.workspace.id;
+  Blockly.Events.fire(event);
+  Blockly.selected = null;
+  this.removeSelect();
+};
+
+/**
+ * Glow only this particular block, to highlight it visually as if it's running.
+ * @param {boolean} isGlowingBlock Whether the block should glow.
+ */
+Blockly.BlockSvg.prototype.setGlowBlock = function(isGlowingBlock) {
+  this.isGlowingBlock_ = isGlowingBlock;
+  this.updateColour();
+};
+
+/**
+ * Glow the stack starting with this block, to highlight it visually as if it's running.
+ * @param {boolean} isGlowingStack Whether the stack starting with this block should glow.
+ */
+Blockly.BlockSvg.prototype.setGlowStack = function(isGlowingStack) {
+  this.isGlowingStack_ = isGlowingStack;
+  // Update the applied SVG filter if the property has changed
+  var svg = this.getSvgRoot();
+  if (this.isGlowingStack_ && !svg.hasAttribute('filter')) {
+    var stackGlowFilterId = this.workspace.options.stackGlowFilterId || 'blocklyStackGlowFilter';
+    svg.setAttribute('filter', 'url(#' + stackGlowFilterId + ')');
+  } else if (!this.isGlowingStack_ && svg.hasAttribute('filter')) {
+    svg.removeAttribute('filter');
+  }
+};
+
+/**
+ * Glow the stack starting with this block, to highlight it visually as if it's errored.
+ * @param {boolean} isGlowingStack Whether the stack starting with this block should glow.
+ */
+Blockly.BlockSvg.prototype.setErrorStack = function(isGlowingStack) {
+  this.isGlowingStack_ = isGlowingStack;
+  // Update the applied SVG filter if the property has changed
+  var svg = this.getSvgRoot();
+  if (this.isGlowingStack_ && !svg.hasAttribute('filter')) {
+    var stackGlowFilterId = this.workspace.options.stackGlowFilterErrorId || 'blocklyStackGlowFilterError';
+    svg.setAttribute('filter', 'url(#' + stackGlowFilterId + ')');
+  } else if (!this.isGlowingStack_ && svg.hasAttribute('filter')) {
+    svg.removeAttribute('filter');
+  }
+};
+
+/**
+ * Block's mutator icon (if any).
+ * @type {Blockly.Mutator}
+ */
+Blockly.BlockSvg.prototype.mutator = null;
+
+/**
+ * Block's comment icon (if any).
+ * @type {Blockly.Comment}
+ */
+Blockly.BlockSvg.prototype.comment = null;
+
+/**
+ * Block's warning icon (if any).
+ * @type {Blockly.Warning}
+ */
+Blockly.BlockSvg.prototype.warning = null;
+
+/**
+ * Returns a list of mutator, comment, and warning icons.
+ * @return {!Array} List of icons.
+ */
+Blockly.BlockSvg.prototype.getIcons = function() {
+  var icons = [];
+  if (this.mutator) {
+    icons.push(this.mutator);
+  }
+  if (this.comment) {
+    icons.push(this.comment);
+  }
+  if (this.warning) {
+    icons.push(this.warning);
+  }
+  return icons;
+};
+
+Blockly.BlockSvg.prototype.intersects_ = true;
+
+Blockly.BlockSvg.prototype.setIntersects = function(intersects) {
+  if (intersects === this.intersects_) {
+    return;
+  }
+  this.intersects_ = intersects;
+  var root = this.getSvgRoot();
+  if (!root) {
+    return;
+  }
+  if (intersects) {
+    root.style.display = '';
+  } else {
+    root.style.display = 'none';
+  }
+};
+
+Blockly.BlockSvg.prototype.updateIntersectionObserver = function() {
+  if (this.workspace.intersectionObserver) {
+    if (this.getParent()) {
+      this.workspace.intersectionObserver.unobserve(this);
+      if (!this.intersects_) {
+        this.setIntersects(true);
+      }
+    } else {
+      this.workspace.intersectionObserver.observe(this);
+    }
+  }
+};
+
+/**
+ * Set parent of this block to be a new block or null.
+ * @param {Blockly.BlockSvg} newParent New parent block.
+ */
+Blockly.BlockSvg.prototype.setParent = function(newParent) {
+  var oldParent = this.parentBlock_;
+  if (newParent == oldParent) {
+    return;
+  }
+  Blockly.Field.startCache();
+  Blockly.BlockSvg.superClass_.setParent.call(this, newParent);
+  Blockly.Field.stopCache();
+
+  var svgRoot = this.getSvgRoot();
+
+  // Bail early if workspace is clearing, or we aren't rendered.
+  // We won't need to reattach ourselves anywhere.
+  if (this.workspace.isClearing || !svgRoot) {
+    return;
+  }
+
+  this.updateIntersectionObserver();
+
+  var oldXY = this.getRelativeToSurfaceXY();
+  if (newParent) {
+    newParent.getSvgRoot().appendChild(svgRoot);
+    var newXY = this.getRelativeToSurfaceXY();
+    // Move the connections to match the child's new position.
+    this.moveConnections_(newXY.x - oldXY.x, newXY.y - oldXY.y);
+    // If we are a shadow block, inherit tertiary colour.
+    if (this.isShadow()) {
+      this.setColour(this.getColour(), this.getColourSecondary(),
+          newParent.getColourTertiary());
+    }
+  }
+  // If we are losing a parent, we want to move our DOM element to the
+  // root of the workspace.
+  else if (oldParent) {
+    this.workspace.getCanvas().appendChild(svgRoot);
+    this.translate(oldXY.x, oldXY.y);
+  }
+
+};
+
+/**
+ * Return the coordinates of the top-left corner of this block relative to the
+ * drawing surface's origin (0,0), in workspace units.
+ * If the block is on the workspace, (0, 0) is the origin of the workspace
+ * coordinate system.
+ * This does not change with workspace scale.
+ * @return {!goog.math.Coordinate} Object with .x and .y properties in
+ *     workspace coordinates.
+ */
+Blockly.BlockSvg.prototype.getRelativeToSurfaceXY = function() {
+  // The drawing surface is relative to either the workspace canvas
+  // or to the drag surface group.
+  var x = 0;
+  var y = 0;
+
+  var dragSurfaceGroup = this.useDragSurface_ ?
+      this.workspace.blockDragSurface_.getGroup() : null;
+
+  var element = this.getSvgRoot();
+  if (element) {
+    do {
+      // Loop through this block and every parent.
+      var xy = Blockly.utils.getRelativeXY(element);
+      x += xy.x;
+      y += xy.y;
+      // If this element is the current element on the drag surface, include
+      // the translation of the drag surface itself.
+      if (this.useDragSurface_ &&
+          this.workspace.blockDragSurface_.getCurrentBlock() == element) {
+        var surfaceTranslation = this.workspace.blockDragSurface_.getSurfaceTranslation();
+        x += surfaceTranslation.x;
+        y += surfaceTranslation.y;
+      }
+      element = element.parentNode;
+    } while (element && element != this.workspace.getCanvas() &&
+        element != dragSurfaceGroup);
+  }
+  return new goog.math.Coordinate(x, y);
+};
+
+/**
+ * Move a block by a relative offset.
+ * @param {number} dx Horizontal offset in workspace units.
+ * @param {number} dy Vertical offset in workspace units.
+ */
+Blockly.BlockSvg.prototype.moveBy = function(dx, dy) {
+  goog.asserts.assert(!this.parentBlock_, 'Block has parent.');
+  var eventsEnabled = Blockly.Events.isEnabled();
+  if (eventsEnabled) {
+    var event = new Blockly.Events.BlockMove(this);
+  }
+  var xy = this.getRelativeToSurfaceXY();
+  this.translate(xy.x + dx, xy.y + dy);
+  this.moveConnections_(dx, dy);
+  if (eventsEnabled) {
+    event.recordNew();
+    Blockly.Events.fire(event);
+  }
+  this.workspace.resizeContents();
+};
+
+/**
+ * Transforms a block by setting the translation on the transform attribute
+ * of the block's SVG.
+ * @param {number} x The x coordinate of the translation in workspace units.
+ * @param {number} y The y coordinate of the translation in workspace units.
+ */
+Blockly.BlockSvg.prototype.translate = function(x, y) {
+  this.getSvgRoot().setAttribute('transform',
+      'translate(' + x + ',' + y + ')');
+};
+
+/**
+ * Move this block to its workspace's drag surface, accounting for positioning.
+ * Generally should be called at the same time as setDragging_(true).
+ * Does nothing if useDragSurface_ is false.
+ * @private
+ */
+Blockly.BlockSvg.prototype.moveToDragSurface_ = function() {
+  if (!this.useDragSurface_) {
+    return;
+  }
+  // The translation for drag surface blocks,
+  // is equal to the current relative-to-surface position,
+  // to keep the position in sync as it move on/off the surface.
+  // This is in workspace coordinates.
+  var xy = this.getRelativeToSurfaceXY();
+  this.clearTransformAttributes_();
+  this.workspace.blockDragSurface_.translateSurface(xy.x, xy.y);
+  // Execute the move on the top-level SVG component
+  this.workspace.blockDragSurface_.setBlocksAndShow(this.getSvgRoot());
+};
+
+/**
+ * Move this block back to the workspace block canvas.
+ * Generally should be called at the same time as setDragging_(false).
+ * Does nothing if useDragSurface_ is false.
+ * @param {!goog.math.Coordinate} newXY The position the block should take on
+ *     on the workspace canvas, in workspace coordinates.
+ * @private
+ */
+Blockly.BlockSvg.prototype.moveOffDragSurface_ = function(newXY) {
+  if (!this.useDragSurface_) {
+    return;
+  }
+  // Translate to current position, turning off 3d.
+  this.translate(newXY.x, newXY.y);
+  this.workspace.blockDragSurface_.clearAndHide(this.workspace.getCanvas());
+};
+
+/**
+ * Move this block during a drag, taking into account whether we are using a
+ * drag surface to translate blocks.
+ * This block must be a top-level block.
+ * @param {!goog.math.Coordinate} newLoc The location to translate to, in
+ *     workspace coordinates.
+ * @package
+ */
+Blockly.BlockSvg.prototype.moveDuringDrag = function(newLoc) {
+  if (this.useDragSurface_) {
+    this.workspace.blockDragSurface_.translateSurface(newLoc.x, newLoc.y);
+  } else {
+    this.svgGroup_.translate_ = 'translate(' + newLoc.x + ',' + newLoc.y + ')';
+    this.svgGroup_.setAttribute('transform',
+        this.svgGroup_.translate_ + this.svgGroup_.skew_);
+  }
+};
+
+/**
+ * Clear the block of transform="..." attributes.
+ * Used when the block is switching from 3d to 2d transform or vice versa.
+ * @private
+ */
+Blockly.BlockSvg.prototype.clearTransformAttributes_ = function() {
+  Blockly.utils.removeAttribute(this.getSvgRoot(), 'transform');
+};
+
+/**
+ * Snap this block to the nearest grid point.
+ */
+Blockly.BlockSvg.prototype.snapToGrid = function() {
+  if (!this.workspace) {
+    return;  // Deleted block.
+  }
+  if (this.workspace.isDragging()) {
+    return;  // Don't bump blocks during a drag.
+  }
+  if (this.getParent()) {
+    return;  // Only snap top-level blocks.
+  }
+  if (this.isInFlyout) {
+    return;  // Don't move blocks around in a flyout.
+  }
+  var grid = this.workspace.getGrid();
+  if (!grid || !grid.shouldSnap()) {
+    return;  // Config says no snapping.
+  }
+  var spacing = grid.getSpacing();
+  var half = spacing / 2;
+  var xy = this.getRelativeToSurfaceXY();
+  var dx = Math.round((xy.x - half) / spacing) * spacing + half - xy.x;
+  var dy = Math.round((xy.y - half) / spacing) * spacing + half - xy.y;
+  dx = Math.round(dx);
+  dy = Math.round(dy);
+  if (dx != 0 || dy != 0) {
+    this.moveBy(dx, dy);
+  }
+};
+
+/**
+ * Returns the coordinates of a bounding box describing the dimensions of this
+ * block and any blocks stacked below it.
+ * Coordinate system: workspace coordinates.
+ * @return {!{topLeft: goog.math.Coordinate, bottomRight: goog.math.Coordinate}}
+ *    Object with top left and bottom right coordinates of the bounding box.
+ */
+Blockly.BlockSvg.prototype.getBoundingRectangle = function() {
+  var blockXY = this.getRelativeToSurfaceXY(this);
+  var blockBounds = this.getHeightWidth();
+  var topLeft;
+  var bottomRight;
+  if (this.RTL) {
+    topLeft = new goog.math.Coordinate(blockXY.x - blockBounds.width,
+        blockXY.y);
+    bottomRight = new goog.math.Coordinate(blockXY.x,
+        blockXY.y + blockBounds.height);
+  } else {
+    topLeft = new goog.math.Coordinate(blockXY.x, blockXY.y);
+    bottomRight = new goog.math.Coordinate(blockXY.x + blockBounds.width,
+        blockXY.y + blockBounds.height);
+  }
+
+  return {topLeft: topLeft, bottomRight: bottomRight};
+};
+
+/**
+ * Set block opacity for SVG rendering.
+ * @param {number} opacity Intended opacity, betweeen 0 and 1
+ */
+Blockly.BlockSvg.prototype.setOpacity = function(opacity) {
+  this.opacity_ = opacity;
+  if (this.rendered) {
+    this.updateColour();
+  }
+};
+
+/**
+ * Get block opacity for SVG rendering.
+ * @return {number} Intended opacity, betweeen 0 and 1
+ */
+Blockly.BlockSvg.prototype.getOpacity = function() {
+  return this.opacity_;
+};
+
+/**
+ * Set whether the block is collapsed or not.
+ * @param {boolean} collapsed True if collapsed.
+ */
+Blockly.BlockSvg.prototype.setCollapsed = function(collapsed) {
+  if (this.collapsed_ == collapsed) {
+    return;
+  }
+  var renderList = [];
+  // Show/hide the inputs.
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    renderList.push.apply(renderList, input.setVisible(!collapsed));
+  }
+
+  var COLLAPSED_INPUT_NAME = '_TEMP_COLLAPSED_INPUT';
+  if (collapsed) {
+    var icons = this.getIcons();
+    for (var i = 0; i < icons.length; i++) {
+      icons[i].setVisible(false);
+    }
+    var text = this.toString(Blockly.COLLAPSE_CHARS);
+    this.appendDummyInput(COLLAPSED_INPUT_NAME).appendField(text).init();
+  } else {
+    this.removeInput(COLLAPSED_INPUT_NAME);
+    // Clear any warnings inherited from enclosed blocks.
+    this.setWarningText(null);
+  }
+  Blockly.BlockSvg.superClass_.setCollapsed.call(this, collapsed);
+
+  if (!renderList.length) {
+    // No child blocks, just render this block.
+    renderList[0] = this;
+  }
+  if (this.rendered) {
+    for (var i = 0, block; block = renderList[i]; i++) {
+      block.render();
+    }
+    // Don't bump neighbours.
+    // Although bumping neighbours would make sense, users often collapse
+    // all their functions and store them next to each other.  Expanding and
+    // bumping causes all their definitions to go out of alignment.
+  }
+};
+
+/**
+ * Open the next (or previous) FieldTextInput.
+ * @param {Blockly.Field|Blockly.Block} start Current location.
+ * @param {boolean} forward If true go forward, otherwise backward.
+ */
+Blockly.BlockSvg.prototype.tab = function(start, forward) {
+  var list = this.createTabList_();
+  var i = list.indexOf(start);
+  if (i == -1) {
+    // No start location, start at the beginning or end.
+    i = forward ? -1 : list.length;
+  }
+  var target = list[forward ? i + 1 : i - 1];
+  if (!target) {
+    // Ran off of list.
+    // If there is an output, tab up to that block.
+    var outputBlock = this.outputConnection && this.outputConnection.targetBlock();
+    if (outputBlock) {
+      outputBlock.tab(this, forward);
+    } else { // Otherwise, go to next / previous block, depending on value of `forward`
+      var block = forward ? this.getNextBlock() : this.getPreviousBlock();
+      if (block) {
+        block.tab(this, forward);
+      }
+    }
+  } else if (target instanceof Blockly.Field) {
+    target.showEditor_();
+  } else {
+    target.tab(null, forward);
+  }
+};
+
+/**
+ * Create an ordered list of all text fields and connected inputs.
+ * @return {!Array.<!Blockly.FieldTextInput|!Blockly.Input>} The ordered list.
+ * @private
+ */
+Blockly.BlockSvg.prototype.createTabList_ = function() {
+  // This function need not be efficient since it runs once on a keypress.
+  var list = [];
+  for (var i = 0, input; input = this.inputList[i]; i++) {
+    for (var j = 0, field; field = input.fieldRow[j]; j++) {
+      if (field instanceof Blockly.FieldTextInput) {
+        // TODO(# 1276): Also support dropdown fields.
+        list.push(field);
+      }
+    }
+    if (input.connection) {
+      var block = input.connection.targetBlock();
+      if (block) {
+        list.push(block);
+      }
+    }
+  }
+  return list;
+};
+
+/**
+ * Handle a mouse-down on an SVG block.
+ * @param {!Event} e Mouse down event or touch start event.
+ * @private
+ */
+Blockly.BlockSvg.prototype.onMouseDown_ = function(e) {
+  if (this.workspace && this.workspace.isDragging()) {
+    return;
+  }
+  var gesture = this.workspace && this.workspace.getGesture(e);
+  if (gesture) {
+    gesture.handleBlockStart(e, this);
+  }
+};
+
+/**
+ * Load the block's help page in a new window.
+ * @private
+ */
+Blockly.BlockSvg.prototype.showHelp_ = function() {
+  var url = goog.isFunction(this.helpUrl) ? this.helpUrl() : this.helpUrl;
+  if (url) {
+    // @todo rewrite
+    alert(url);
+  }
+};
+
+
+/**
+ * Show the context menu for this block.
+ * @param {!Event} e Mouse event.
+ * @private
+ */
+Blockly.BlockSvg.prototype.showContextMenu_ = function(e) {
+  if (this.workspace.options.readOnly || !this.contextMenu) {
+    return;
+  }
+  // Save the current block in a variable for use in closures.
+  var block = this;
+  var menuOptions = [];
+  if (this.isDeletable() && this.isMovable() && !block.isInFlyout) {
+    menuOptions.push(Blockly.ContextMenu.blockDuplicateOption(block, e));
+    if (this.isEditable() && this.workspace.options.comments) {
+      menuOptions.push(Blockly.ContextMenu.blockCommentOption(block));
+    }
+    //menuOptions.push(Blockly.ContextMenu.blockCollapseOption(block));
+    menuOptions.push(Blockly.ContextMenu.blockDeleteOption(block));
+  } else if (this.parentBlock_ && this.isShadow_ && this.type !== 'polygon') {
+    this.parentBlock_.showContextMenu_(e);
+    return;
+  }
+
+  // Allow the block to add or modify menuOptions.
+  if (this.customContextMenu) {
+    this.customContextMenu(menuOptions);
+  }
+  Blockly.ContextMenu.show(e, menuOptions, this.RTL);
+  Blockly.ContextMenu.currentBlock = this;
+};
+
+/**
+ * Move the connections for this block and all blocks attached under it.
+ * Also update any attached bubbles.
+ * @param {number} dx Horizontal offset from current location, in workspace
+ *     units.
+ * @param {number} dy Vertical offset from current location, in workspace
+ *     units.
+ * @private
+ */
+Blockly.BlockSvg.prototype.moveConnections_ = function(dx, dy) {
+  if (!this.rendered) {
+    // Rendering is required to lay out the blocks.
+    // This is probably an invisible block attached to a collapsed block.
+    return;
+  }
+  var myConnections = this.getConnections_(false);
+  for (var i = 0; i < myConnections.length; i++) {
+    myConnections[i].moveBy(dx, dy);
+  }
+  var icons = this.getIcons();
+  for (i = 0; i < icons.length; i++) {
+    icons[i].computeIconLocation();
+  }
+
+  // Recurse through all blocks attached under this one.
+  for (i = 0; i < this.childBlocks_.length; i++) {
+    this.childBlocks_[i].moveConnections_(dx, dy);
+  }
+};
+
+/**
+ * Recursively adds or removes the dragging class to this node and its children.
+ * @param {boolean} adding True if adding, false if removing.
+ * @package
+ */
+Blockly.BlockSvg.prototype.setDragging = function(adding) {
+  if (adding) {
+    var group = this.getSvgRoot();
+    group.translate_ = '';
+    group.skew_ = '';
+    Blockly.draggingConnections_ =
+        Blockly.draggingConnections_.concat(this.getConnections_(true));
+    Blockly.utils.addClass(
+        /** @type {!Element} */ (this.svgGroup_), 'blocklyDragging');
+  } else {
+    Blockly.draggingConnections_ = [];
+    Blockly.utils.removeClass(
+        /** @type {!Element} */ (this.svgGroup_), 'blocklyDragging');
+  }
+  // Recurse through all blocks attached under this one.
+  for (var i = 0; i < this.childBlocks_.length; i++) {
+    this.childBlocks_[i].setDragging(adding);
+  }
+};
+
+/**
+ * Add or remove the UI indicating if this block is movable or not.
+ */
+Blockly.BlockSvg.prototype.updateMovable = function() {
+  if (this.isMovable()) {
+    Blockly.utils.addClass(
+        /** @type {!Element} */ (this.svgGroup_), 'blocklyDraggable');
+  } else {
+    Blockly.utils.removeClass(
+        /** @type {!Element} */ (this.svgGroup_), 'blocklyDraggable');
+  }
+};
+
+/**
+ * Set whether this block is movable or not.
+ * @param {boolean} movable True if movable.
+ */
+Blockly.BlockSvg.prototype.setMovable = function(movable) {
+  Blockly.BlockSvg.superClass_.setMovable.call(this, movable);
+  this.updateMovable();
+};
+
+/**
+ * Set whether this block is editable or not.
+ * @param {boolean} editable True if editable.
+ */
+Blockly.BlockSvg.prototype.setEditable = function(editable) {
+  Blockly.BlockSvg.superClass_.setEditable.call(this, editable);
+  var icons = this.getIcons();
+  for (var i = 0; i < icons.length; i++) {
+    icons[i].updateEditable();
+  }
+};
+
+/**
+ * Set whether this block is a shadow block or not.
+ * @param {boolean} shadow True if a shadow.
+ */
+Blockly.BlockSvg.prototype.setShadow = function(shadow) {
+  Blockly.BlockSvg.superClass_.setShadow.call(this, shadow);
+  this.updateColour();
+};
+
+/**
+ * Set whether this block is an insertion marker block or not.
+ * @param {boolean} insertionMarker True if an insertion marker.
+ * @param {Number=} opt_minWidth Optional minimum width of the marker.
+ */
+Blockly.BlockSvg.prototype.setInsertionMarker = function(insertionMarker, opt_minWidth) {
+  Blockly.BlockSvg.superClass_.setInsertionMarker.call(this, insertionMarker);
+  this.insertionMarkerMinWidth_ = opt_minWidth;
+  this.updateColour();
+};
+
+/**
+ * Return the root node of the SVG or null if none exists.
+ * @return {Element} The root SVG node (probably a group).
+ */
+Blockly.BlockSvg.prototype.getSvgRoot = function() {
+  return this.svgGroup_;
+};
+
+/**
+ * Dispose of this block.
+ * @param {boolean} healStack If true, then try to heal any gap by connecting
+ *     the next statement with the previous statement.  Otherwise, dispose of
+ *     all children of this block.
+ * @param {boolean} animate If true, show a disposal animation and sound.
+ */
+Blockly.BlockSvg.prototype.dispose = function(healStack, animate) {
+  if (!this.workspace) {
+    // The block has already been deleted.
+    return;
+  }
+  Blockly.Tooltip.hide();
+  Blockly.Field.startCache();
+  // Save the block's workspace temporarily so we can resize the
+  // contents once the block is disposed.
+  var blockWorkspace = this.workspace;
+  // If this block is being dragged, unlink the mouse events.
+  if (Blockly.selected == this) {
+    this.unselect();
+    this.workspace.cancelCurrentGesture();
+  }
+  // If this block has a context menu open, close it.
+  if (Blockly.ContextMenu.currentBlock == this) {
+    Blockly.ContextMenu.hide();
+  }
+
+  if (animate && this.rendered) {
+    this.unplug(healStack);
+    Blockly.BlockAnimations.disposeUiEffect(this);
+  }
+  // Stop rerendering.
+  this.rendered = false;
+
+  Blockly.Events.disable();
+  try {
+    var icons = this.getIcons();
+    for (var i = 0; i < icons.length; i++) {
+      icons[i].dispose();
+    }
+  } finally {
+    Blockly.Events.enable();
+  }
+  Blockly.BlockSvg.superClass_.dispose.call(this, healStack);
+
+  if (blockWorkspace.intersectionObserver) {
+    blockWorkspace.intersectionObserver.unobserve(this);
+  }
+  goog.dom.removeNode(this.svgGroup_);
+  blockWorkspace.resizeContents();
+  // Sever JavaScript to DOM connections.
+  this.svgGroup_ = null;
+  this.svgPath_ = null;
+  Blockly.Field.stopCache();
+};
+
+/**
+ * Enable or disable a block.
+ */
+Blockly.BlockSvg.prototype.updateDisabled = function() {
+  // not supported
+};
+
+/**
+ * Returns the comment on this block (or '' if none).
+ * @return {string} Block's comment.
+ */
+Blockly.BlockSvg.prototype.getCommentText = function() {
+  if (this.comment) {
+    var comment = this.comment.getText();
+    // Trim off trailing whitespace.
+    return comment.replace(/\s+$/, '').replace(/ +\n/g, '\n');
+  }
+  return '';
+};
+
+/**
+ * Set this block's comment text.
+ * @param {?string} text The text, or null to delete.
+ * @param {string=} commentId Id of the comment, or a new one will be generated if not provided.
+ * @param {number=} commentX Optional x position for scratch comment in workspace coordinates
+ * @param {number=} commentY Optional y position for scratch comment in workspace coordinates
+ * @param {boolean=} minimized Optional minimized state for scratch comment, defaults to false
+ */
+Blockly.BlockSvg.prototype.setCommentText = function(text, commentId,
+    commentX, commentY, minimized) {
+  var changedState = false;
+  if (goog.isString(text)) {
+    if (!this.comment) {
+      this.comment = new Blockly.ScratchBlockComment(this, text, commentId,
+          commentX, commentY, minimized);
+      changedState = true;
+    } else {
+      this.comment.setText(/** @type {string} */ (text));
+    }
+  } else {
+    if (this.comment) {
+      this.comment.dispose();
+      changedState = true;
+    }
+  }
+  if (changedState && this.rendered) {
+    this.render();
+    if (goog.isString(text)) {
+      this.comment.setVisible(true);
+    }
+    // Adding or removing a comment icon will cause the block to change shape.
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Set this block's warning text.
+ * @param {?string} text The text, or null to delete.
+ * @param {string=} opt_id An optional ID for the warning text to be able to
+ *     maintain multiple warnings.
+ */
+Blockly.BlockSvg.prototype.setWarningText = function(text, opt_id) {
+  if (!this.setWarningText.pid_) {
+    // Create a database of warning PIDs.
+    // Only runs once per block (and only those with warnings).
+    this.setWarningText.pid_ = Object.create(null);
+  }
+  var id = opt_id || '';
+  if (!id) {
+    // Kill all previous pending processes, this edit supersedes them all.
+    for (var n in this.setWarningText.pid_) {
+      clearTimeout(this.setWarningText.pid_[n]);
+      delete this.setWarningText.pid_[n];
+    }
+  } else if (this.setWarningText.pid_[id]) {
+    // Only queue up the latest change.  Kill any earlier pending process.
+    clearTimeout(this.setWarningText.pid_[id]);
+    delete this.setWarningText.pid_[id];
+  }
+  if (this.workspace.isDragging()) {
+    // Don't change the warning text during a drag.
+    // Wait until the drag finishes.
+    var thisBlock = this;
+    this.setWarningText.pid_[id] = setTimeout(function() {
+      if (thisBlock.workspace) {  // Check block wasn't deleted.
+        delete thisBlock.setWarningText.pid_[id];
+        thisBlock.setWarningText(text, id);
+      }
+    }, 100);
+    return;
+  }
+  if (this.isInFlyout) {
+    text = null;
+  }
+
+  var changedState = false;
+  if (goog.isString(text)) {
+    if (!this.warning) {
+      this.warning = new Blockly.Warning(this);
+      changedState = true;
+    }
+    this.warning.setText(/** @type {string} */ (text), id);
+  } else {
+    // Dispose all warnings if no ID is given.
+    if (this.warning && !id) {
+      this.warning.dispose();
+      changedState = true;
+    } else if (this.warning) {
+      var oldText = this.warning.getText();
+      this.warning.setText('', id);
+      var newText = this.warning.getText();
+      if (!newText) {
+        this.warning.dispose();
+      }
+      changedState = oldText != newText;
+    }
+  }
+  if (changedState && this.rendered) {
+    this.render();
+    // Adding or removing a warning icon will cause the block to change shape.
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Give this block a mutator dialog.
+ * @param {Blockly.Mutator} mutator A mutator dialog instance or null to remove.
+ */
+Blockly.BlockSvg.prototype.setMutator = function(mutator) {
+  if (this.mutator && this.mutator !== mutator) {
+    this.mutator.dispose();
+  }
+  if (mutator) {
+    mutator.block_ = this;
+    this.mutator = mutator;
+    mutator.createIcon();
+  }
+};
+
+/**
+ * Select this block.  Highlight it visually.
+ */
+Blockly.BlockSvg.prototype.addSelect = function() {
+  Blockly.utils.addClass(
+      /** @type {!Element} */ (this.svgGroup_), 'blocklySelected');
+};
+
+/**
+ * Unselect this block.  Remove its highlighting.
+ */
+Blockly.BlockSvg.prototype.removeSelect = function() {
+  Blockly.utils.removeClass(
+      /** @type {!Element} */ (this.svgGroup_),  'blocklySelected');
+};
+
+/**
+ * Update the cursor over this block by adding or removing a class.
+ * @param {boolean} letMouseThrough True if the blocks should ignore pointer
+ *     events, false otherwise.
+ * @package
+ */
+Blockly.BlockSvg.prototype.setMouseThroughStyle = function(letMouseThrough) {
+  if (letMouseThrough) {
+    Blockly.utils.addClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyDraggingMouseThrough');
+  } else {
+    Blockly.utils.removeClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyDraggingMouseThrough');
+  }
+};
+
+/**
+ * Update the cursor over this block by adding or removing a class.
+ * @param {boolean} enable True if the delete cursor should be shown, false
+ *     otherwise.
+ * @package
+ */
+Blockly.BlockSvg.prototype.setDeleteStyle = function(enable) {
+  if (enable) {
+    Blockly.utils.addClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyDraggingDelete');
+  } else {
+    Blockly.utils.removeClass(/** @type {!Element} */ (this.svgGroup_),
+        'blocklyDraggingDelete');
+  }
+};
+
+// Overrides of functions on Blockly.Block that take into account whether the
+// block has been rendered.
+
+/**
+ * Change the colour of a block.
+ * @param {number|string} colour HSV hue value, or #RRGGBB string.
+ * @param {number|string} colourSecondary Secondary HSV hue value, or #RRGGBB
+ *    string.
+ * @param {number|string} colourTertiary Tertiary HSV hue value, or #RRGGBB
+ *    string.
+ */
+Blockly.BlockSvg.prototype.setColour = function(colour, colourSecondary,
+    colourTertiary) {
+  Blockly.BlockSvg.superClass_.setColour.call(this, colour, colourSecondary,
+      colourTertiary);
+
+  if (this.rendered) {
+    this.updateColour();
+  }
+};
+
+/**
+ * Move this block to the front of the visible workspace.
+ * <g> tags do not respect z-index so SVG renders them in the
+ * order that they are in the DOM.  By placing this block first within the
+ * block group's <g>, it will render on top of any other blocks.
+ * @package
+ */
+Blockly.BlockSvg.prototype.bringToFront = function() {
+  var block = this;
+  do {
+    var root = block.getSvgRoot();
+    root.parentNode.appendChild(root);
+    block = block.getParent();
+  } while (block);
+};
+
+/**
+ * Set whether this block can chain onto the bottom of another block.
+ * @param {boolean} newBoolean True if there can be a previous statement.
+ * @param {(string|Array.<string>|null)=} opt_check Statement type or
+ *     list of statement types.  Null/undefined if any type could be connected.
+ */
+Blockly.BlockSvg.prototype.setPreviousStatement = function(newBoolean,
+    opt_check) {
+  Blockly.BlockSvg.superClass_.setPreviousStatement.call(this, newBoolean,
+      opt_check);
+
+  if (this.rendered) {
+    this.render();
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Set whether another block can chain onto the bottom of this block.
+ * @param {boolean} newBoolean True if there can be a next statement.
+ * @param {(string|Array.<string>|null)=} opt_check Statement type or
+ *     list of statement types.  Null/undefined if any type could be connected.
+ */
+Blockly.BlockSvg.prototype.setNextStatement = function(newBoolean, opt_check) {
+  Blockly.BlockSvg.superClass_.setNextStatement.call(this, newBoolean,
+      opt_check);
+
+  if (this.rendered) {
+    this.render();
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Set whether this block returns a value.
+ * @param {boolean} newBoolean True if there is an output.
+ * @param {(string|Array.<string>|null)=} opt_check Returned type or list
+ *     of returned types.  Null or undefined if any type could be returned
+ *     (e.g. variable get).
+ */
+Blockly.BlockSvg.prototype.setOutput = function(newBoolean, opt_check) {
+  Blockly.BlockSvg.superClass_.setOutput.call(this, newBoolean, opt_check);
+
+  if (this.rendered) {
+    this.render();
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Set whether value inputs are arranged horizontally or vertically.
+ * @param {boolean} newBoolean True if inputs are horizontal.
+ */
+Blockly.BlockSvg.prototype.setInputsInline = function(newBoolean) {
+  Blockly.BlockSvg.superClass_.setInputsInline.call(this, newBoolean);
+
+  if (this.rendered) {
+    this.render();
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Remove an input from this block.
+ * @param {string} name The name of the input.
+ * @param {boolean=} opt_quiet True to prevent error if input is not present.
+ * @throws {goog.asserts.AssertionError} if the input is not present and
+ *     opt_quiet is not true.
+ */
+Blockly.BlockSvg.prototype.removeInput = function(name, opt_quiet) {
+  Blockly.BlockSvg.superClass_.removeInput.call(this, name, opt_quiet);
+
+  if (this.rendered) {
+    this.render();
+    // Removing an input will cause the block to change shape.
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Move a numbered input to a different location on this block.
+ * @param {number} inputIndex Index of the input to move.
+ * @param {number} refIndex Index of input that should be after the moved input.
+ */
+Blockly.BlockSvg.prototype.moveNumberedInputBefore = function(
+    inputIndex, refIndex) {
+  Blockly.BlockSvg.superClass_.moveNumberedInputBefore.call(this, inputIndex,
+      refIndex);
+
+  if (this.rendered) {
+    this.render();
+    // Moving an input will cause the block to change shape.
+    this.bumpNeighbours_();
+  }
+};
+
+/**
+ * Add a value input, statement input or local variable to this block.
+ * @param {number} type Either Blockly.INPUT_VALUE or Blockly.NEXT_STATEMENT or
+ *     Blockly.DUMMY_INPUT.
+ * @param {string} name Language-neutral identifier which may used to find this
+ *     input again.  Should be unique to this block.
+ * @return {!Blockly.Input} The input object created.
+ * @private
+ */
+Blockly.BlockSvg.prototype.appendInput_ = function(type, name) {
+  var input = Blockly.BlockSvg.superClass_.appendInput_.call(this, type, name);
+
+  if (this.rendered) {
+    this.render();
+    // Adding an input will cause the block to change shape.
+    this.bumpNeighbours_();
+  }
+  return input;
+};
+
+/**
+ * Returns connections originating from this block.
+ * @param {boolean} all If true, return all connections even hidden ones.
+ *     Otherwise, for a non-rendered block return an empty list, and for a
+ *     collapsed block don't return inputs connections.
+ * @return {!Array.<!Blockly.Connection>} Array of connections.
+ * @package
+ */
+Blockly.BlockSvg.prototype.getConnections_ = function(all) {
+  var myConnections = [];
+  if (all || this.rendered) {
+    if (this.outputConnection) {
+      myConnections.push(this.outputConnection);
+    }
+    if (this.previousConnection) {
+      myConnections.push(this.previousConnection);
+    }
+    if (this.nextConnection) {
+      myConnections.push(this.nextConnection);
+    }
+    if (all || !this.collapsed_) {
+      for (var i = 0, input; input = this.inputList[i]; i++) {
+        if (input.connection) {
+          myConnections.push(input.connection);
+        }
+      }
+    }
+  }
+  return myConnections;
+};
+
+/**
+ * Create a connection of the specified type.
+ * @param {number} type The type of the connection to create.
+ * @return {!Blockly.RenderedConnection} A new connection of the specified type.
+ * @private
+ */
+Blockly.BlockSvg.prototype.makeConnection_ = function(type) {
+  return new Blockly.RenderedConnection(this, type);
+};
+
+/**
+ * Bump unconnected blocks out of alignment.  Two blocks which aren't actually
+ * connected should not coincidentally line up on screen.
+ * @private
+ */
+Blockly.BlockSvg.prototype.bumpNeighbours_ = function() {
+  if (!this.workspace) {
+    return;  // Deleted block.
+  }
+  if (this.workspace.isDragging()) {
+    return;  // Don't bump blocks during a drag.
+  }
+  var rootBlock = this.getRootBlock();
+  if (rootBlock.isInFlyout) {
+    return;  // Don't move blocks around in a flyout.
+  }
+  // Loop through every connection on this block.
+  var myConnections = this.getConnections_(false);
+  for (var i = 0, connection; connection = myConnections[i]; i++) {
+
+    // Spider down from this block bumping all sub-blocks.
+    if (connection.isConnected() && connection.isSuperior()) {
+      connection.targetBlock().bumpNeighbours_();
+    }
+
+    var neighbours = connection.neighbours_(Blockly.SNAP_RADIUS);
+    for (var j = 0, otherConnection; otherConnection = neighbours[j]; j++) {
+
+      // If both connections are connected, that's probably fine.  But if
+      // either one of them is unconnected, then there could be confusion.
+      if (!connection.isConnected() || !otherConnection.isConnected()) {
+        // Only bump blocks if they are from different tree structures.
+        if (otherConnection.getSourceBlock().getRootBlock() != rootBlock) {
+
+          // Always bump the inferior block.
+          if (connection.isSuperior()) {
+            otherConnection.bumpAwayFrom_(connection);
+          } else {
+            connection.bumpAwayFrom_(otherConnection);
+          }
+        }
+      }
+    }
+  }
+};
+
+/**
+ * Schedule snapping to grid and bumping neighbours to occur after a brief
+ * delay.
+ * @package
+ */
+Blockly.BlockSvg.prototype.scheduleSnapAndBump = function() {
+  var block = this;
+  // Ensure that any snap and bump are part of this move's event group.
+  var group = Blockly.Events.getGroup();
+
+  setTimeout(function() {
+    Blockly.Events.setGroup(group);
+    block.snapToGrid();
+    Blockly.Events.setGroup(false);
+  }, Blockly.BUMP_DELAY / 2);
+
+  setTimeout(function() {
+    Blockly.Events.setGroup(group);
+    block.bumpNeighbours_();
+    Blockly.Events.setGroup(false);
+  }, Blockly.BUMP_DELAY);
+};

core/blockly.js

@@ -0,0 +1,675 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2011 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.
+ */
+
+/**
+ * @fileoverview Core JavaScript library for Blockly.
+ * @author [email protected] (Neil Fraser)
+ */
+'use strict';
+
+/**
+ * The top level namespace used to access the Blockly library.
+ * @namespace Blockly
+ **/
+goog.provide('Blockly');
+
+goog.require('Blockly.BlockSvg.render');
+goog.require('Blockly.DropDownDiv');
+goog.require('Blockly.Events');
+goog.require('Blockly.FieldAngle');
+goog.require('Blockly.FieldButton');
+goog.require('Blockly.FieldCheckbox');
+goog.require('Blockly.FieldCheckboxOriginal');
+goog.require('Blockly.FieldColour');
+goog.require('Blockly.FieldColourSlider');
+// Date picker commented out since it increases footprint by 60%.
+// Add it only if you need it.
+//goog.require('Blockly.FieldDate');
+goog.require('Blockly.FieldDropdown');
+goog.require('Blockly.FieldExpandableAdd');
+goog.require('Blockly.FieldExpandableRemove');
+goog.require('Blockly.FieldIconMenu');
+goog.require('Blockly.FieldImage');
+goog.require('Blockly.FieldNote');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.FieldTextInputRemovable');
+goog.require('Blockly.FieldTextDropdown');
+goog.require('Blockly.FieldNumber');
+goog.require('Blockly.FieldNumberDropdown');
+goog.require('Blockly.FieldMatrix');
+goog.require('Blockly.FieldVariable');
+goog.require('Blockly.FieldVerticalSeparator');
+goog.require('Blockly.FieldCustom');
+goog.require('Blockly.Generator');
+goog.require('Blockly.Msg');
+goog.require('Blockly.Procedures');
+goog.require('Blockly.ScratchMsgs');
+goog.require('Blockly.Toolbox');
+goog.require('Blockly.Touch');
+goog.require('Blockly.WidgetDiv');
+goog.require('Blockly.WorkspaceSvg');
+goog.require('Blockly.constants');
+goog.require('Blockly.inject');
+goog.require('Blockly.utils');
+goog.require('goog.color');
+
+
+// Turn off debugging when compiled.
+/* eslint-disable no-unused-vars */
+var CLOSURE_DEFINES = {'goog.DEBUG': false};
+/* eslint-enable no-unused-vars */
+
+/**
+ * The main workspace most recently used.
+ * Set by Blockly.WorkspaceSvg.prototype.markFocused
+ * @type {Blockly.Workspace}
+ */
+Blockly.mainWorkspace = null;
+
+/**
+ * Currently selected block.
+ * @type {Blockly.Block}
+ */
+Blockly.selected = null;
+
+/**
+ * All of the connections on blocks that are currently being dragged.
+ * @type {!Array.<!Blockly.Connection>}
+ * @private
+ */
+Blockly.draggingConnections_ = [];
+
+/**
+ * Contents of the local clipboard.
+ * @type {Element}
+ * @private
+ */
+Blockly.clipboardXml_ = null;
+
+/**
+ * Source of the local clipboard.
+ * @type {Blockly.WorkspaceSvg}
+ * @private
+ */
+Blockly.clipboardSource_ = null;
+
+/**
+ * Cached value for whether 3D is supported.
+ * @type {!boolean}
+ * @private
+ */
+Blockly.cache3dSupported_ = null;
+
+/**
+ * Convert a hue (HSV model) into an RGB hex triplet.
+ * @param {number} hue Hue on a colour wheel (0-360).
+ * @return {string} RGB code, e.g. '#5ba65b'.
+ */
+Blockly.hueToRgb = function(hue) {
+  return goog.color.hsvToHex(hue, Blockly.HSV_SATURATION,
+      Blockly.HSV_VALUE * 255);
+};
+
+/**
+ * constrains a number to a specified range
+ * @param {Number} number the number to constrain
+ * @param {Number} min the lower wall
+ * @param {Number} max the uper wall
+ * @returns {Number} the constrained number
+ */
+goog.constrain = function(number, min, max) {
+  var num = Math.min(Math.max(number, min), max)
+  if (!num && num !== 0) num = 0
+  return num
+}
+
+/**
+ * converts hsva to rgba
+ * @param {Number} hue the color
+ * @param {Number} saturation the saturation
+ * @param {Number} value the brightness
+ * @param {Number} alpha the transparency
+ * @returns {Number} the hex color
+ */
+goog.color.hsvaToHex = function(hue, saturation, value, alpha) {
+  var hex = goog.color.hsvToHex(hue, saturation, value)
+  var alpha = goog.constrain(Math.floor(alpha * 255), 0, 255).toString(16)
+  if (alpha.length === 1) alpha = '0' + alpha
+  return hex + alpha
+}
+
+/**
+ * convert hex to hsva
+ * @param {String|Number} hex the hex 
+ * @returns {Array} the hsva
+ */
+goog.color.hexToHsva = function(decimal) {
+  var alpha = (() => {
+    if (typeof decimal === 'string') return parseInt(decimal.slice(7, 9), 16)
+    return decimal & 0xFF
+  })() / 255
+  
+  var [hue, saturation, value] = goog.color.hexToHsv(decimal.slice(0, 7))
+  return [hue,saturation,value,alpha];
+}
+
+/**
+ * Returns the dimensions of the specified SVG image.
+ * @param {!Element} svg SVG image.
+ * @return {!Object} Contains width and height properties.
+ */
+Blockly.svgSize = function(svg) {
+  return {
+    width: svg.cachedWidth_,
+    height: svg.cachedHeight_
+  };
+};
+
+/**
+ * Size the workspace when the contents change.  This also updates
+ * scrollbars accordingly.
+ * @param {!Blockly.WorkspaceSvg} workspace The workspace to resize.
+ */
+Blockly.resizeSvgContents = function(workspace) {
+  workspace.resizeContents();
+};
+
+/**
+ * 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.
+ * @param {!Blockly.WorkspaceSvg} workspace Any workspace in the SVG.
+ */
+Blockly.svgResize = function(workspace) {
+  var mainWorkspace = workspace;
+  while (mainWorkspace.options.parentWorkspace) {
+    mainWorkspace = mainWorkspace.options.parentWorkspace;
+  }
+  var svg = mainWorkspace.getParentSvg();
+  var div = svg.parentNode;
+  if (!div) {
+    // Workspace deleted, or something.
+    return;
+  }
+  var width = div.offsetWidth;
+  var height = div.offsetHeight;
+  if (svg.cachedWidth_ != width) {
+    svg.setAttribute('width', width + 'px');
+    svg.cachedWidth_ = width;
+  }
+  if (svg.cachedHeight_ != height) {
+    svg.setAttribute('height', height + 'px');
+    svg.cachedHeight_ = height;
+  }
+  mainWorkspace.resize();
+};
+
+/**
+ * Handle a key-down on SVG drawing surface. Does nothing if the main workspace is not visible.
+ * @param {!Event} e Key down event.
+ * @private
+ */
+// TODO (https://github.com/google/blockly/issues/1998) handle cases where there are multiple workspaces
+// and non-main workspaces are able to accept input.
+Blockly.onKeyDown_ = function(e) {
+  if (Blockly.mainWorkspace.options.readOnly || Blockly.utils.isTargetInput(e)
+      || (Blockly.mainWorkspace.rendered && !Blockly.mainWorkspace.isVisible())) {
+    // No key actions on readonly workspaces.
+    // When focused on an HTML text input widget, don't trap any keys.
+    // Ignore keypresses on rendered workspaces that have been explicitly
+    // hidden.
+    return;
+  }
+  var deleteBlock = false;
+  if (e.keyCode == 27) {
+    // Pressing esc closes the context menu and any drop-down
+    Blockly.hideChaff();
+    Blockly.DropDownDiv.hide();
+  } else if (e.keyCode == 8 || e.keyCode == 46) {
+    // Delete or backspace.
+    // Stop the browser from going back to the previous page.
+    // Do this first to prevent an error in the delete code from resulting in
+    // data loss.
+    e.preventDefault();
+    // Don't delete while dragging.  Jeez.
+    if (Blockly.mainWorkspace.isDragging()) {
+      return;
+    }
+    if (Blockly.selected && Blockly.selected.isDeletable()) {
+      deleteBlock = true;
+    }
+  } else if (e.altKey || e.ctrlKey || e.metaKey) {
+    // Don't use meta keys during drags.
+    if (Blockly.mainWorkspace.isDragging()) {
+      return;
+    }
+    if (Blockly.selected &&
+        Blockly.selected.isDeletable() && Blockly.selected.isMovable()) {
+      // Don't allow copying immovable or undeletable blocks. The next step
+      // would be to paste, which would create additional undeletable/immovable
+      // blocks on the workspace.
+      if (e.keyCode == 67) {
+        // 'c' for copy.
+        Blockly.hideChaff();
+        Blockly.copy_(Blockly.selected);
+      } else if (e.keyCode == 88 && !Blockly.selected.workspace.isFlyout) {
+        // 'x' for cut, but not in a flyout.
+        // Don't even copy the selected item in the flyout.
+        Blockly.copy_(Blockly.selected);
+        deleteBlock = true;
+      }
+    }
+    if (e.keyCode == 86) {
+      // 'v' for paste.
+      if (Blockly.clipboardXml_) {
+        Blockly.Events.setGroup(true);
+        // Pasting always pastes to the main workspace, even if the copy started
+        // in a flyout workspace.
+        var workspace = Blockly.clipboardSource_;
+        if (workspace.isFlyout) {
+          workspace = workspace.targetWorkspace;
+        }
+        workspace.paste(Blockly.clipboardXml_);
+        Blockly.Events.setGroup(false);
+      }
+    } else if (e.keyCode == 90 || e.keyCode === 89) {
+      // 'z' for undo 'Z' is for redo. 'y' is always redo.
+      e.preventDefault();
+      Blockly.hideChaff();
+      Blockly.mainWorkspace.undo(e.shiftKey || e.keyCode === 89);
+    }
+  }
+  // Common code for delete and cut.
+  // Don't delete in the flyout.
+  if (deleteBlock && !Blockly.selected.workspace.isFlyout) {
+    Blockly.Events.setGroup(true);
+    Blockly.hideChaff();
+    Blockly.selected.dispose(/* heal */ true, true);
+    Blockly.Events.setGroup(false);
+  }
+};
+
+/**
+ * Copy a block or workspace comment onto the local clipboard.
+ * @param {!Blockly.Block | !Blockly.WorkspaceComment} toCopy Block or Workspace Comment
+ *    to be copied.
+ * @private
+ */
+Blockly.copy_ = function(toCopy) {
+  if (toCopy.isComment) {
+    var xml = toCopy.toXmlWithXY();
+  } else {
+    var xml = Blockly.Xml.blockToDom(toCopy);
+    // Encode start position in XML.
+    var xy = toCopy.getRelativeToSurfaceXY();
+    xml.setAttribute('x', toCopy.RTL ? -xy.x : xy.x);
+    xml.setAttribute('y', xy.y);
+  }
+  Blockly.clipboardXml_ = xml;
+  Blockly.clipboardSource_ = toCopy.workspace;
+};
+
+/**
+ * Duplicate this block and its children, or a workspace comment.
+ * @param {!Blockly.Block | !Blockly.WorkspaceComment} toDuplicate Block or
+ *     Workspace Comment to be copied.
+ * @private
+ */
+Blockly.duplicate_ = function(toDuplicate) {
+  // Save the clipboard.
+  var clipboardXml = Blockly.clipboardXml_;
+  var clipboardSource = Blockly.clipboardSource_;
+
+  // Create a duplicate via a copy/paste operation.
+  Blockly.copy_(toDuplicate);
+  toDuplicate.workspace.paste(Blockly.clipboardXml_);
+
+  // Restore the clipboard.
+  Blockly.clipboardXml_ = clipboardXml;
+  Blockly.clipboardSource_ = clipboardSource;
+};
+
+/**
+ * Cancel the native context menu, unless the focus is on an HTML input widget.
+ * @param {!Event} e Mouse down event.
+ * @private
+ */
+Blockly.onContextMenu_ = function(e) {
+  if (!Blockly.utils.isTargetInput(e)) {
+    // When focused on an HTML text input widget, don't cancel the context menu.
+    e.preventDefault();
+  }
+};
+
+/**
+ * Close tooltips, context menus, dropdown selections, etc.
+ * @param {boolean=} opt_allowToolbox If true, don't close the toolbox.
+ */
+Blockly.hideChaff = function(opt_allowToolbox) {
+  Blockly.hideChaffInternal_(opt_allowToolbox);
+  Blockly.WidgetDiv.hide(true);
+};
+
+/**
+ * Close tooltips, context menus, dropdown selections, etc.
+ * For some elements (e.g. field text inputs), rather than hiding, it will
+ * move them.
+ * @param {boolean=} opt_allowToolbox If true, don't close the toolbox.
+ */
+Blockly.hideChaffOnResize = function(opt_allowToolbox) {
+  Blockly.hideChaffInternal_(opt_allowToolbox);
+  Blockly.WidgetDiv.repositionForWindowResize();
+};
+
+/**
+ * Does a majority of the work for hideChaff including tooltips, dropdowns,
+ * toolbox, etc. It does not deal with the WidgetDiv.
+ * @param {boolean=} opt_allowToolbox If true, don't close the toolbox.
+ * @private
+ */
+Blockly.hideChaffInternal_ = function(opt_allowToolbox) {
+  Blockly.Tooltip.hide();
+  Blockly.DropDownDiv.hideWithoutAnimation();
+  if (!opt_allowToolbox) {
+    var workspace = Blockly.getMainWorkspace();
+    if (workspace.toolbox_ &&
+        workspace.toolbox_.flyout_ &&
+        workspace.toolbox_.flyout_.autoClose) {
+      workspace.toolbox_.clearSelection();
+    }
+  }
+};
+
+/**
+ * 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.
+ * @return {!Blockly.Workspace} The main workspace.
+ */
+Blockly.getMainWorkspace = function() {
+  return Blockly.mainWorkspace;
+};
+
+/**
+ * Wrapper to window.alert() that app developers may override to
+ * provide alternatives to the modal browser window.
+ * @param {string} message The message to display to the user.
+ * @param {function()=} opt_callback The callback when the alert is dismissed.
+ */
+Blockly.alert = function(message, opt_callback) {
+  window.alert(message);
+  if (opt_callback) {
+    opt_callback();
+  }
+};
+
+/**
+ * Wrapper to window.confirm() that app developers may override to
+ * provide alternatives to the modal browser window.
+ * @param {string} message The message to display to the user.
+ * @param {!function(boolean)} callback The callback for handling user response.
+ */
+Blockly.confirm = function(message, callback) {
+  callback(window.confirm(message));
+};
+
+/**
+ * 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.
+ * @param {string} message The message to display to the user.
+ * @param {string} defaultValue The value to initialize the prompt with.
+ * @param {!function(string)} callback The callback for handling user response.
+ * @param {?string} _opt_title An optional title for the prompt.
+ * @param {?string} _opt_varType An optional variable type for variable specific
+ *     prompt behavior.
+ */
+Blockly.prompt = function(message, defaultValue, callback, _opt_title,
+    _opt_varType) {
+  // opt_title and opt_varType are unused because we only need them to pass
+  // information to the scratch-gui, which overwrites this function
+  callback(window.prompt(message, defaultValue));
+};
+
+/**
+ * A callback for status buttons. The window.alert is here for testing and
+ * should be overridden.
+ * @param {string} id An identifier.
+ */
+Blockly.statusButtonCallback = function(id) {
+  window.alert('status button was pressed for ' + id);
+};
+
+/**
+ * Refresh the visual state of a status button in all extension category headers.
+ * @param {Blockly.Workspace} workspace A workspace.
+ */
+Blockly.refreshStatusButtons = function(workspace) {
+  var buttons = workspace.getFlyout().buttons_;
+  for (var i = 0; i < buttons.length; i++) {
+    if (buttons[i] instanceof Blockly.FlyoutExtensionCategoryHeader) {
+      buttons[i].refreshStatus();
+    }
+  }
+};
+
+/**
+ * Helper function for defining a block from JSON.  The resulting function has
+ * the correct value of jsonDef at the point in code where jsonInit is called.
+ * @param {!Object} jsonDef The JSON definition of a block.
+ * @return {function()} A function that calls jsonInit with the correct value
+ *     of jsonDef.
+ * @private
+ */
+Blockly.jsonInitFactory_ = function(jsonDef) {
+  return function() {
+    this.jsonInit(jsonDef);
+  };
+};
+
+/**
+ * Define blocks from an array of JSON block definitions, as might be generated
+ * by the Blockly Developer Tools.
+ * @param {!Array.<!Object>} jsonArray An array of JSON block definitions.
+ */
+Blockly.defineBlocksWithJsonArray = function(jsonArray, ignoreOverites) {
+  for (var i = 0; i < jsonArray.length; i++) {
+    var elem = jsonArray[i];
+    if (!elem) {
+      console.warn(
+          'Block definition #' + i + ' in JSON array is ' + elem + '. ' +
+          'Skipping.');
+    } else {
+      var typename = elem.type;
+      if (typename == null || typename === '') {
+        console.warn(
+            'Block definition #' + i +
+            ' in JSON array is missing a type attribute. Skipping.');
+      } else {
+        if (Blockly.Blocks[typename]) {
+          if (!ignoreOverites) {
+            console.warn(
+                'Block definition #' + i + ' in JSON array' +
+                ' overwrites prior definition of "' + typename + '".');
+          }
+        }
+        Blockly.Blocks[typename] = {
+          init: Blockly.jsonInitFactory_(elem)
+        };
+      }
+    }
+  }
+};
+
+/**
+ * Bind an event to a function call.  When calling the function, verifies that
+ * it belongs to the touch stream that is currently being processed, and splits
+ * multitouch events into multiple events as needed.
+ * @param {!EventTarget} node Node upon which to listen.
+ * @param {string} name Event name to listen to (e.g. 'mousedown').
+ * @param {Object} thisObject The value of 'this' in the function.
+ * @param {!Function} func Function to call when event is triggered.
+ * @param {boolean=} opt_noCaptureIdentifier True if triggering on this event
+ *     should not block execution of other event handlers on this touch or other
+ *     simultaneous touches.
+ * @param {boolean=} opt_noPreventDefault True if triggering on this event
+ *     should prevent the default handler.  False by default.  If
+ *     opt_noPreventDefault is provided, opt_noCaptureIdentifier must also be
+ *     provided.
+ * @return {!Array.<!Array>} Opaque data that can be passed to unbindEvent_.
+ */
+Blockly.bindEventWithChecks_ = function(node, name, thisObject, func,
+    opt_noCaptureIdentifier, opt_noPreventDefault) {
+  var handled = false;
+  var wrapFunc = function(e) {
+    var captureIdentifier = !opt_noCaptureIdentifier;
+    // Handle each touch point separately.  If the event was a mouse event, this
+    // will hand back an array with one element, which we're fine handling.
+    var events = Blockly.Touch.splitEventByTouches(e);
+    for (var i = 0, event; event = events[i]; i++) {
+      if (captureIdentifier && !Blockly.Touch.shouldHandleEvent(event)) {
+        continue;
+      }
+      Blockly.Touch.setClientFromTouch(event);
+      if (thisObject) {
+        func.call(thisObject, event);
+      } else {
+        func(event);
+      }
+      handled = true;
+    }
+  };
+
+  node.addEventListener(name, wrapFunc, false);
+  var bindData = [[node, name, wrapFunc]];
+
+  // Add equivalent touch event.
+  if (name in Blockly.Touch.TOUCH_MAP) {
+    var touchWrapFunc = function(e) {
+      wrapFunc(e);
+      // Calling preventDefault stops the browser from scrolling/zooming the
+      // page.
+      var preventDef = !opt_noPreventDefault;
+      if (handled && preventDef) {
+        e.preventDefault();
+      }
+    };
+    for (var i = 0, type; type = Blockly.Touch.TOUCH_MAP[name][i]; i++) {
+      node.addEventListener(type, touchWrapFunc, false);
+      bindData.push([node, type, touchWrapFunc]);
+    }
+  }
+  return bindData;
+};
+
+
+/**
+ * Bind an event to a function call.  Handles multitouch events by using the
+ * coordinates of the first changed touch, and doesn't do any safety checks for
+ * simultaneous event processing.
+ * @deprecated in favor of bindEventWithChecks_, but preserved for external
+ * users.
+ * @param {!EventTarget} node Node upon which to listen.
+ * @param {string} name Event name to listen to (e.g. 'mousedown').
+ * @param {Object} thisObject The value of 'this' in the function.
+ * @param {!Function} func Function to call when event is triggered.
+ * @return {!Array.<!Array>} Opaque data that can be passed to unbindEvent_.
+ * @private
+ */
+Blockly.bindEvent_ = function(node, name, thisObject, func) {
+  var wrapFunc = function(e) {
+    if (thisObject) {
+      func.call(thisObject, e);
+    } else {
+      func(e);
+    }
+  };
+
+  node.addEventListener(name, wrapFunc, false);
+  var bindData = [[node, name, wrapFunc]];
+
+  // Add equivalent touch event.
+  if (name in Blockly.Touch.TOUCH_MAP) {
+    var touchWrapFunc = function(e) {
+      // Punt on multitouch events.
+      if (e.changedTouches.length == 1) {
+        // Map the touch event's properties to the event.
+        var touchPoint = e.changedTouches[0];
+        e.clientX = touchPoint.clientX;
+        e.clientY = touchPoint.clientY;
+      }
+      wrapFunc(e);
+
+      // Stop the browser from scrolling/zooming the page.
+      e.preventDefault();
+    };
+    for (var i = 0, type; type = Blockly.Touch.TOUCH_MAP[name][i]; i++) {
+      node.addEventListener(type, touchWrapFunc, false);
+      bindData.push([node, type, touchWrapFunc]);
+    }
+  }
+  return bindData;
+};
+
+/**
+ * Unbind one or more events event from a function call.
+ * @param {!Array.<!Array>} bindData Opaque data from bindEvent_.
+ *     This list is emptied during the course of calling this function.
+ * @return {!Function} The function call.
+ * @private
+ */
+Blockly.unbindEvent_ = function(bindData) {
+  while (bindData.length) {
+    var bindDatum = bindData.pop();
+    var node = bindDatum[0];
+    var name = bindDatum[1];
+    var func = bindDatum[2];
+    node.removeEventListener(name, func, false);
+  }
+  return func;
+};
+
+/**
+ * Is the given string a number (includes negative and decimals).
+ * @param {string} str Input string.
+ * @return {boolean} True if number, false otherwise.
+ */
+Blockly.isNumber = function(str) {
+  return !!str.match(/^\s*-?\d+(\.\d+)?\s*$/);
+};
+
+// IE9 does not have a console.  Create a stub to stop errors.
+if (!goog.global['console']) {
+  goog.global['console'] = {
+    'log': function() {},
+    'warn': function() {}
+  };
+}
+
+// Export symbols that would otherwise be renamed by Closure compiler.
+if (!goog.global['Blockly']) {
+  goog.global['Blockly'] = {};
+}
+goog.global['Blockly']['getMainWorkspace'] = Blockly.getMainWorkspace;
+goog.global['Blockly']['goog'] = goog;
+Blockly.goog = goog;