Bloqueios personalizados: parâmetros de bloqueio

Há vários paradigmas para escolher ao projetar um aplicativo. que usa o Blockly. É preciso considerar essas escolhas desde o início, já que eles afetam os bloqueios que o usuário vai precisar.

Configuração

Muitos aplicativos Blockly são usados para descrever configurações, do que programas executáveis. Os aplicativos de configuração geralmente começam inicializando um bloco no nível da raiz no espaço de trabalho. Um bom exemplo é a guia "Block Factory" das Ferramentas para desenvolvedores do Blockly:

Blockly.Blocks['factory_base'] = {
  init: function() {
    this.setDeletable(false);
    this.setMovable(false);
    this.setEditable(false);
    // etc...
  }
}

Blockly.serialization.blocks.append({'type': 'factory_base'}, workspace);

Isso cria um bloco imóvel que contém configuração do usuário. O espaço de trabalho pode ser serializado a qualquer momento para determinar a configuração atual.

Esses aplicativos podem querer desativar automaticamente qualquer bloqueio conectada ao bloco raiz. Isso pode ser feito em uma linha:

workspace.addChangeListener(Blockly.Events.disableOrphans);

Programa em série

A maioria dos aplicativos Blockly é projetada para criar programas. Os usuários empilham os blocos que são executados em ordem.

Cada bloco (não desativado) no espaço de trabalho fará parte do neste programa. Se houver várias pilhas de blocos, as mais altas serão executadas primeiro. (Se duas pilhas tiverem aproximadamente a mesma altura, pilhas à esquerda (à direita no modo RTL) recebem prioridade.

O espaço de trabalho pode ser exportado para um código executável a qualquer momento. Este código podem ser executados no lado do cliente em JavaScript (usando eval ou o JavaScript intérprete) ou do servidor em qualquer idioma.

import {javascriptGenerator} from 'blockly/javascript';

var code = javascriptGenerator.workspaceToCode(workspace);

Programa paralelo

Alguns aplicativos Blockly optam por executar todas as pilhas de blocos em em paralelo, e não em série. Um exemplo seria um aplicativo de música em que uma repetição de bateria é executada simultaneamente a uma melodia.

Uma forma de implementar a execução paralela é gerar o código para cada bloquear individualmente:

import {javascriptGenerator} from 'blockly/javascript';

var json = Blockly.serialization.workspaces.save(workspace);

// Store top blocks separately, and remove them from the JSON.
var blocks = json['blocks']['blocks'];
var topBlocks = blocks.slice();  // Create shallow copy.
blocks.length = 0;

// Load each block into the workspace individually and generate code.
var allCode = [];
var headless = new Blockly.Workspace();
for (var i = 0; block < topBlocks.length; i++) {
  var block = topBlocks[i];
  blocks.push(block);
  Blockly.serialization.workspaces.load(json, headless);
  allCode.push(javascriptGenerator.workspaceToCode(headless));
  blocks.length = 0;
}

Se o idioma de destino for JavaScript, a matriz allCode poderá ser usada para criar vários intérpretes de JS para execução simultânea. Se a linguagem de destino for algo como Python, então a matriz allCode podem ser agrupadas em um único programa que usa um módulo de threading.

Como em qualquer programa paralelo, é preciso tomar decisões cuidadosas sobre todos os recursos compartilhados, como variáveis e funções.

Programa voltado para eventos

Manipuladores de eventos são apenas funções que são chamadas pelo sistema, em vez do que pelo programa. Esses blocos podem incluir a pilha de blocos a serem executados ou podem ser cabeçalhos que ficam no topo de uma pilha de blocos.

Alguns desenvolvedores gostam de adicionar um "chapéu" ao topo dos blocos de eventos, de modo que eles parecem diferentes de outros blocos. Essa não é a aparência padrão para Blockly, mas pode ser adicionada substituindo a constante do renderizador ADD_START_HATS para true (Codelab de renderizadores personalizados: substituir constantes). ou adicionando um tema e definindo a opção de chapéu no estilo do bloco. Mais informações sobre a definição de chapéus em blocos como parte dos temas podem ser encontradas aqui.

Dentro de um modelo orientado a eventos, pode fazer sentido também fazer um manipulador para o início do programa. Nesse modelo, qualquer bloco no espaço de trabalho conectado a um manipulador de eventos seriam ignorados e não executados.

Ao projetar um sistema que usa eventos, considere se ele é possível ou desejável oferecer suporte a várias instâncias do mesmo evento .