WorkbenchViewController needs to have its functionality split into smaller pieces. Some areas that could use refactoring are:

• BlockView gesture recognizers
• TrashCanViewController and ToolboxCategoryListViewController

This will make object pruning much easier.

The CodeGenerator is currently running on the main thread as it seems to crash when on a background thread, but we need to check if this is performant for large workspaces.

Investigate using a JS Web Worker as an alternate solution.

Right now, custom versions of LayoutBuilder and LayoutFactory objects can't be used as there are many places in the code that just rely on the default one.

For use with the generator we should include an up to date copy of the compressed js files. Developers can replace them if they want to, but it would be good to have a known working version ready to go.

When dragging, filter out potential connections that are not visible in the current WorkspaceView (e.g., outside the current view bounds).

Android: https://github.com/RoboErikG/blockly-android/issues/55

BlockLayout:

1. Make height a property of BlockLayout.Background
2. Handle stroke widths for the background
3. Potentially move logic from BlockLayout.performLayout(...) into BlockLayout.Background to make things easier to follow.

InputLayout:

1. Handle stroke widths for the inline connector cut-out
2. If more blocks can be added to the last block in the group, add a bit of space to the bottom of the middle part to show this is possible

BlockView:

1. BlockView's highlight view frame needs to be larger than its parent frame since it highlights outside of the view's bounds

We should avoid using the default name because it can confuse XCode if there are two files with the same name.

Any potential changes to a Blocks/Fields/etc. need to respect the "editable" property.

These two methods make subclassing more complicated than they need to be. They should be refactored so subclasses simply implement refreshView(...) and prepareForReuse(...).

Right now positions are set on the Connection object, but it may make more sense to have them on a ConnectionLayout object instead (since connections don't have a position in a headless version). This would clean up the code and define a clearer separation between model and layout.

Optimizations that should be done for Layout/View rendering:

WorkspaceView:

1. When block layouts are removed from the workspace, all views in the workspace view are checked to see which layouts were removed.
2. All block layouts are currently rendered into views regardless if they are visible on-screen.

Layout:

1. Optimize refreshViewPositionsForTree(...) so it only recalculates view positions for layouts that are "dirty"

BlockLayout/BlockView:

1. Reduce overdraw by limiting BlockView's frame to the block's background only (not all of its connected input children). However, the frame of the BlockView's tree should be kept as a property for BlockHighlighting purposes.

WorkspaceLayout:

1. Optimize updateLayoutHierarchyForConnection(...) so it goes through the minimal number of layout passes

InputLayout:

1. Updating self.absolutePosition eats into execution time. "swift_unknownRetainUnowned", "objc_loadWeakRetained", and "objc_...release" are called often and take about 15% of CPU time.

Examples of things that can be animated:

1. Block's being automatically moved from one position to another (e.g. when it snaps into place or it is bumped away)
2. Block inline/statement fields growing/shrinking based on new blocks being added to it

Events in LayoutEventManager are sent at the beginning of the next run loop, but they could be sent at the end of the current run loop.

Blockly allows blocks to be dragged around on a (practically) infinite plane. This means blocks can be at negative workspace coordinates and the view needs to resize to fit them.

The standard implementation is to provide half a screen width of space between any edge and its nearest block so the user has room to add more content above, left, right, or below their current blocks.

Right now, FieldDate is a text field that is edited with a date picker "keyboard". Instead, it should be a button that opens a date picker within a popover.

1. Handle screen rotations when blocks are being dragged (either lock the screen during drags or stop any on-going drags when the screen is rotated).

Trying to define a custom Obj-C name for the protocol FieldLayoutMeasurer results in an error. For some reason, the custom protocol name is not forward declared before the class that uses it. This seems to be an XCode bug, most recently seen in version 7.2.

It might be nicer to make them follow some sort of convention.

WKWebView new API for iOS 8+, which offers performance improvements over UIWebView. Currently the code generator and turtle demo app use UIWebView, where they should be able to be replaced with WKWebView.

For now match web Blockly's drag visualization so it's clear a stack is being dragged.

Colour picker, Angle picker, etc. don't currently scale with the workspace when zooming. We should review the UX for these and decide if they zoom and how much.

Android: https://github.com/RoboErikG/blockly-android/issues/66

Initial use-case is to enable both vertical and horizontal layouts.

Taking a set of blocks out of the trash is causing a performance hit (~300ms for 20 blocks on iPad mini). This is because this operation is performed as a copy and delete, instead of a true cut.

Currently, the block config object is a globally shared object. At the very minimum, it should be defined at the WorkspaceLayout level.

Initial findings indicate the crash code is from the web demo code, but it could also be from the CodeGenerator service.

EXC_BAD_ACCESS is thrown from a WebThread:

WebCore`void std::__1::__sift_up<WebCore::TimerHeapLessThanFunction&, WebCore::TimerHeapIterator>:
    0x11470d430 <+0>:   pushq  %rbp
    0x11470d431 <+1>:   movq   %rsp, %rbp
    0x11470d434 <+4>:   pushq  %rbx
    0x11470d435 <+5>:   cmpq   $0x2, %rcx
    0x11470d439 <+9>:   jl     0x11470d538               ; <+264>
    0x11470d43f <+15>:  leaq   -0x2(%rcx), %rax
    0x11470d443 <+19>:  shrq   $0x3f, %rax
    0x11470d447 <+23>:  leaq   -0x2(%rcx,%rax), %rcx
    0x11470d44c <+28>:  sarq   %rcx
->  0x11470d44f <+31>:  movq   (%rdi,%rcx,8), %r11
    0x11470d453 <+35>:  movq   -0x8(%rsi), %r8
    0x11470d457 <+39>:  movsd  0x8(%r11), %xmm1
    0x11470d45d <+45>:  movsd  0x8(%r8), %xmm0
    0x11470d463 <+51>:  ucomisd %xmm1, %xmm0
    0x11470d467 <+55>:  jne    0x11470d46b               ; <+59>
    0x11470d469 <+57>:  jnp    0x11470d476               ; <+70>
    0x11470d46b <+59>:  ucomisd %xmm0, %xmm1
    0x11470d46f <+63>:  ja     0x11470d489               ; <+89>
    0x11470d471 <+65>:  jmp    0x11470d538               ; <+264>
    0x11470d476 <+70>:  movl   0x24(%r11), %eax
    0x11470d47a <+74>:  subl   0x24(%r8), %eax
    0x11470d47e <+78>:  cmpl   $0x7ffffffe, %eax
    0x11470d483 <+83>:  ja     0x11470d538               ; <+264>
    0x11470d489 <+89>:  leaq   0x24(%r8), %r9
    0x11470d48d <+93>:  leaq   (%rdi,%rcx,8), %rax
    0x11470d491 <+97>:  addq   $-0x8, %rsi
    0x11470d495 <+101>: nopw   %cs:(%rax,%rax)
    0x11470d4a0 <+112>: movq   %rax, %r10
    0x11470d4a3 <+115>: movq   %r11, (%rsi)
    0x11470d4a6 <+118>: movq   0x28(%r11), %rbx
    0x11470d4aa <+122>: movq   (%rbx), %rdx
    0x11470d4ad <+125>: movq   %rsi, %rax
    0x11470d4b0 <+128>: subq   %rdx, %rax
    0x11470d4b3 <+131>: jb     0x11470d4c9               ; <+153>
    0x11470d4b5 <+133>: movl   0xc(%rbx), %ebx
    0x11470d4b8 <+136>: leaq   (%rdx,%rbx,8), %rdx
    0x11470d4bc <+140>: cmpq   %rdx, %rsi
    0x11470d4bf <+143>: jae    0x11470d4c9               ; <+153>
    0x11470d4c1 <+145>: shrq   $0x3, %rax
    0x11470d4c5 <+149>: movl   %eax, 0x20(%r11)
    0x11470d4c9 <+153>: testq  %rcx, %rcx
    0x11470d4cc <+156>: je     0x11470d512               ; <+226>
    0x11470d4ce <+158>: leaq   -0x1(%rcx), %rax
    0x11470d4d2 <+162>: shrq   $0x3f, %rax
    0x11470d4d6 <+166>: leaq   -0x1(%rcx,%rax), %rcx
    0x11470d4db <+171>: sarq   %rcx
    0x11470d4de <+174>: leaq   (%rdi,%rcx,8), %rax
    0x11470d4e2 <+178>: movq   (%rdi,%rcx,8), %r11
    0x11470d4e6 <+182>: movsd  0x8(%r11), %xmm1
    0x11470d4ec <+188>: ucomisd %xmm1, %xmm0
    0x11470d4f0 <+192>: jne    0x11470d4f4               ; <+196>
    0x11470d4f2 <+194>: jnp    0x11470d500               ; <+208>
    0x11470d4f4 <+196>: ucomisd %xmm0, %xmm1
    0x11470d4f8 <+200>: movq   %r10, %rsi
    0x11470d4fb <+203>: ja     0x11470d4a0               ; <+112>
    0x11470d4fd <+205>: jmp    0x11470d512               ; <+226>
    0x11470d4ff <+207>: nop    
    0x11470d500 <+208>: movl   0x24(%r11), %edx
    0x11470d504 <+212>: subl   (%r9), %edx
    0x11470d507 <+215>: cmpl   $0x7fffffff, %edx
    0x11470d50d <+221>: movq   %r10, %rsi
    0x11470d510 <+224>: jb     0x11470d4a0               ; <+112>
    0x11470d512 <+226>: movq   %r8, (%r10)
    0x11470d515 <+229>: movq   0x28(%r8), %rcx
    0x11470d519 <+233>: movq   (%rcx), %rax
    0x11470d51c <+236>: cmpq   %rax, %r10
    0x11470d51f <+239>: jb     0x11470d538               ; <+264>
    0x11470d521 <+241>: movl   0xc(%rcx), %ecx
    0x11470d524 <+244>: leaq   (%rax,%rcx,8), %rcx
    0x11470d528 <+248>: cmpq   %rcx, %r10
    0x11470d52b <+251>: jae    0x11470d538               ; <+264>
    0x11470d52d <+253>: subq   %rax, %r10
    0x11470d530 <+256>: shrq   $0x3, %r10
    0x11470d534 <+260>: movl   %r10d, 0x20(%r8)
    0x11470d538 <+264>: popq   %rbx
    0x11470d539 <+265>: popq   %rbp
    0x11470d53a <+266>: retq   
    0x11470d53b <+267>: nopl   (%rax,%rax)

Create a way configure a default font for the entire app. It should support scaling based on the current workspace layout's scale.

Create a protocol called LayoutFactory and change the existing LayoutFactory class into DefaultLayoutFactory, which implements the new protocol.

Android issue: https://github.com/RoboErikG/blockly-android/issues/63

Currently, users can't create custom field views for existing or new FieldLayout types.

In order to limit errant connections from occurring, especially in crowded workspaces, limit the connections available connections to the block's output, previous, first statement input, and any external inputs before the first statement. (This is a rough heuristic worthy of discussion.)

Android: https://github.com/RoboErikG/blockly-android/issues/54