A classe ibm_ilog.graphlayout.GraphLayout define vários
recursos e parâmetros genéricos.
Estes recursos e parâmetros
podem ser usados para customizar os algoritmos de layout.
Embora a classe
GraphLayout
defina os parâmetros
genéricos, ela não controla como eles são usados por suas subclasses. Cada algoritmo de layout (ou seja, cada subclasse de GraphLayout
) suporta um subconjunto dos recursos
genéricos e determina a maneira que ele usa os parâmetros genéricos. Ao criar seu próprio algoritmo de layout definindo GraphLayout
como subclasse, você decide se deseja usar
os recursos e a maneira de usá-los. A classe
GraphLayout
define os seguintes recursos genéricos: Suporte por Algoritmos de Recursos e Parâmetros Genéricos
fornece um resumo dos parâmetros genéricos suportados por cada algoritmo
de layout.
Se estiver usando uma das subclasses fornecidas com a API do layout de
gráfico, verifique a documentação para essa subclasse para saber se ela
suporta um parâmetro específico e como ela interpreta o parâmetro.
Tempo Permitido
Vários algoritmos de layout podem ser projetados para parar o
cálculo quando uma especificação de tempo definido pelo usuário for
excedida. It can be done
for different reasons: for security to avoid a long computation time
on large graphs, or as an upper limit for algorithms that iteratively
improve a current solution and have no other criteria to stop the
computation.
Exemplo de Especificação do Tempo Permitido
Para especificar que o layout pode ser executado durante 60
segundos:
Chame:
layout.setAllowedTime(60000);
O tempo está em milissegundos. O valor padrão é 32000 (32
segundos).
Se você definir ibm_ilog.graphlayout.GraphLayout como subclasse, use o seguinte método para saber se o tempo
especificado foi excedido:
layout.isLayoutTimeElapsed();
Para indicar se uma subclasse de
GraphLayout
suporta este mecanismo, use o método: layout.supportsAllowedTime();
A implementação padrão retorna
false
.
Uma subclasse pode substituir este método para retornar true
para indicar que este mecanismo é suportado. Layout de Componentes Conectados
A classe base ibm_ilog.graphlayout.GraphLayout fornece suporte genérico para o layout de um gráfico desconectado
(composto de componentes conectados).
Para obter detalhes, consulte
Organizando Componentes Conectados de um Gráfico Desconectado.
Exemplo de Layout
Para ativar o posicionamento de gráficos desconectados:
Chame:
layout.setLayoutOfConnectedComponentsEnabled(true);
Nota
Algumas das classes de layout (
HierarchicalLayout
, CircularLayout
) possuem um algoritmo integrado
para posicionamento de componentes conectados. Este algoritmo é ativado por padrão
e se ajusta às situações mais comuns. Para esta classe de layout, o mecanismo genérico
fornecido pela classe base GraphLayout é desativado por padrão.Quando ativada, uma instância padrão da classe ibm_ilog.graphlayout.grid.GridLayout é usada internamente
para posicionar os gráficos desconectados.
Se
necessário, é possível customizar este layout.
Exemplo de Customização de Layout
Para customizar este layout:
Chamada:
var gridLayout = new ibm_ilog.graphlayout.grid.GridLayout(); gridLayout.setLayoutMode(ibm_ilog.graphlayout.grid.GridLayout.TILE_TO_ROWS); gridLayout.setTopMargin(20); layout.setLayoutOfConnectedComponents(gridLayout);
Exemplo para Especialistas
Os vários recursos da classe ibm_ilog.graphlayout.grid.GridLayout cobrem a maioria das prováveis
necessidades de posicionamento de gráficos desconectados. Se necessário, é possível gravar
sua própria subclasse de ibm_ilog.graphlayout.GraphLayout para posicionar gráficos
desconectados e especificá-la em vez de GridLayout:
Chame:
var myGridLayout = new MyGridLayout(); // settings for myGridLayout, if necessary layout.setLayoutOfConnectedComponents(myGridLayout);
Para indicar se uma subclasse de
GraphLayout
suporta este mecanismo, use o método: layout.supportsLayoutOfConnectedComponents();
A implementação padrão retorna
false
.
É possível gravar uma
subclasse ou substituir este comportamento. Região de Layout
Some layout algorithms can control the size of the graph
drawing and can take into account a user-defined layout region.
Exemplo de Especificação da Região de Layout
Para especificar uma região de 100 por 100:
layout.setLayoutRegion({x:0, y:0, width:100, height:100});
Para acessar a região de layout, use o método:
var rect = layout.getSpecLayoutRegion();
Este método retorna uma cópia do retângulo que define a
região de layout especificada.
Os algoritmos de layout chamam um método diferente:
var rect = layout.getCalcLayoutRegion();
Este método primeiro tenta usar a especificação da região de layout
chamando o método ibm_ilog.graphlayout.GraphLayout.getSpecLayoutRegion. Se este método retornar um retângulo não nulo, este
retângulo será retornado. Caso contrário, o método tentará estimar uma região de layout apropriada
de acordo com o número e tamanho dos nós no gráfico anexado. Se nenhum gráfico estiver anexado ou o gráfico anexado estiver vazio,
ele retornará um retângulo padrão
{x:0,
y:0, width:1000, height:1000}
. Para indicar se uma subclasse de
GraphLayout
suporta o mecanismo da região de layout, use o método: layout.supportsLayoutRegion();
A implementação padrão retorna
false
.
Uma subclasse pode substituir este método para retornar true
para indicar que este mecanismo é suportado. Nota
A implementação do método ibm_ilog.graphlayout.GraphLayout.layout() será responsável apenas se a região de layout for considerada
ao calcular o layout e em qual maneira. Para obter detalhes, consulte a documentação dos algoritmos de layout.
Link connection box
If a layout algorithm calculates specific connection
points, it places the connection points of links by default at the
border of the bounding box of the nodes symmetrically with respect
to the middle of each side. Sometimes it can be necessary to place
the connection points on a rectangle smaller or larger than the bounding
box, possibly asymmetrically. For example, connection points can be
placed asymmetrically when labels are displayed above or below nodes.
Consulte o Efeito da interface
link connection box. It can be achieved by specifying
a link connection box interface. The link connection box interface allows you to specify for each node
a node box different from the bounding box that is used to connect
the links to the node.
Exemplo de Interface
link connection box
Para configurar uma interface da caixa de conexão de link,
chame:
layout.setLinkConnectionBoxInterface(provider);
Você implementa a interface da caixa de conexão de link definindo
uma classe que implementa o ibm_ilog.graphlayout.ILinkConnectionBoxProvider. Esta interface define o seguinte método:
getBox(graphModel, node)
Este método permite retornar o retângulo efetivo no qual os
pontos de conexão dos links são posicionados.
Um segundo método definido na interface permite que os
pontos de conexão sejam “deslocados” tangencialmente, de uma maneira
diferente para cada lado de cada nó:
getTangentialOffset(graphModel, node, nodeSide)
Como as interfaces são usadas e quais pontos de conexão serão
o resultado final são específicos de cada algoritmo de layout.
O Layout Hierárquico, o Layout de Árvore e os Layouts de
Links Curto e Longo usam o link connection box
para definir a caixa do nó em que os links devem ser anexados.
A figura a seguir mostra os efeitos da customização da caixa
de conexão. À esquerda está o resultado sem nenhuma interface
link connection box. À direita está o resultado que
mostra o efeito quando a interface link connection box retorna o retângulo tracejado para o nó azul.

Efeito da interface
link connection box
Circular Layout, Random Layout, and Force-directed Layout do not spread out links at the node border,
but can route links to point to the node center.
Consulte o método ibm_ilog.graphlayout.basic.BasicLinkStyleLayout.setConnectLinksToNodeCenters.
Se um nó tiver uma forma irregular, os links às vezes não
deverão apontar para o centro da caixa delimitadora do nó, mas para um
centro virtual dentro do nó. A interface link connection box pode ser usada para definir o centro do nó virtual. A figura
a seguir mostra um exemplo do efeito.

Efeito combinado da efetuar o link de recorte de link e da link connection box
Se os links forem recortados no nó em estrela verde irregular
à esquerda da figura, eles não apontarão para o centro da estrela, mas
para o centro da caixa delimitadora do nó.
É possível corrigir este efeito especificando uma interface
link connection box que retorna uma caixa do nó
menor que a caixa delimitadora, conforme mostrado à direta da figura. Como
alternativa, o problema pode ser corrigido especificando uma interface
link connection box que retorna a caixa
delimitadora como a caixa do nó, mas com deslocamentos tangenciais
adicionais que deslocam o centro virtual do nó.
Por exemplo, para configurar uma interface da caixa de
conexão de link que retorna um retângulo de conexão de link menor que a
caixa delimitadora para todos os nós do tipo
MyNode e desloca os pontos de
conexão à esquerda e à direita de todos os nós, chame:
dojo.declare('MyLinkConnectionBoxProvider', ibm_ilog.graphlayout.ILinkConnectionBoxProvider, { getBox: function(graphModel, node) { var rect:Rectangle = graphModel.getBounds(node); if (node is MyNode) { // for example, the size of the bounding box is reduced: rect.x += 4; rect.y += 4; rect.width -= 8; rect.height -= 8; } return rect; } getTangentialOffset: function(graphModel, node, side) { switch (side) { case ibm_ilog.graphlayout.Direction.LEFT: case ibm_ilog.graphlayout.Direction.RIGHT: return -10; // shift up with 10 for both left and right side case ibm_ilog.graphlayout.Direction.TOP: case ibm_ilog.graphlayout.Direction.BOTTOM: default: return 0; // no shift for top and bottom side } } }); layout.setLinkConnectionBoxProvider(new MyLinkConnectionBoxProvider());
Para indicar se uma subclasse de ibm_ilog.graphlayout.GraphLayout suporta a interface do provedor da caixa de conexão de link, use o método ibm_ilog.graphlayout.GraphLayout.supportsLinkConnectionBox().
A implementação padrão retorna false. É possível gravar uma
subclasse para substituir este método para retornar true para indicar que
este mecanismo é suportado.
Cálculo de Porcentagem de Conclusão
Alguns algoritmos de layout podem fornecer uma estimativa da
quantidade do layout que foi concluída. Esta estimativa é disponibilizada
como um valor de porcentagem que é armazenado no relatório de layout de
gráfico. Quando o algoritmo é iniciado, o valor de porcentagem é
configurado como 0. Ocasionalmente, o algoritmo de layout chama o seguinte
método para aumentar o valor de porcentagem por etapas até atingir 100:
layout.increasePercentageComplete(newPercentage);
O valor de porcentagem pode ser acessado a partir do
relatório de layout usando o seguinte método:
var percentage = layoutReport.getPercentageComplete();
Para indicar se uma subclasse de ibm_ilog.graphlayout.GraphLayout suporta este mecanismo, use o método:
layout.supportsPercentageComplete();
A implementação padrão retorna
false
.
Uma subclasse pode substituir este método para retornar true
para indicar que este mecanismo é suportado. Preservar Links Fixos
Às vezes, você deseja que alguns links do gráfico fiquem “retidos”
(ou seja, permaneçam em sua forma atual quando o layout for executado).
Você deseja uma maneira de indicar aos links que o algoritmo de layout não
pode ser redimensionado. It makes sense especially when using a semiautomatic layout
(the method where the user fine-tunes the layout by hand after the
layout is completed) or when using an incremental layout (the method
where the graph, the shape of the links, or both are modified after
the layout has been performed, and then the layout is performed again).
Exemplo de Links Fixos
Para especificar se um link é fixo:
Use o método:
layout.setFixed(link, fixed);
Se o parâmetro
fixed
estiver configurado como true
, isto
significa que o link é fixo. Para obter a configuração atual para um link: layout.isFixed(link);
O valor padrão é
false
. Para remover o atributo fixo de todos os links no gráfico,
use o método:
layout.unfixAllLinks();
The fixed attributes on links are considered only if
you additionally call the following statement:
layout.setPreserveFixedLinks(true);
Para indicar se uma subclasse de
GraphLayout
suporta este mecanismo, use o método: layout.supportsPreserveFixedLinks();
A implementação padrão retorna
false
.
Uma subclasse pode substituir este método para retornar true
para indicar que este mecanismo é suportado. Preservar Nós Fixos
At times, you might want some nodes of the graph to be
“pinned” (that is, to stay in their current position
when the layout is performed). Você precisa de uma maneira de indicar aos nós que o algoritmo
de layout não pode ser movido. It makes sense especially when
using a semiautomatic layout (the method where the user fine-tunes
the layout by hand after the layout is completed) or when using an
incremental layout (the method where the graph, the position of the
nodes, or both are modified after the layout has been performed, and
then the layout is performed again).
Exemplo de Nós Fixos
Para especificar que um nó é fixo:
Use o método:
layout.setFixed(node, fixed);
Se o parâmetro
fixed
estiver configurado como true
, isto
significa que o nó é fixo. Para obter a configuração atual para um nó: layout.isFixed(node);
O valor padrão é
false
. Para remover o atributo fixo de todos os nós no gráfico, use
o método:
layout.unfixAllNodes();
The fixed attributes on nodes are considered only if
you also call:
layout.setPreserveFixedNodes(true);
Para indicar se uma subclasse de
GraphLayout
suporta este mecanismo, use o método: layout.supportsPreserveFixedNodes();
A implementação padrão retorna
false
.
Uma subclasse pode substituir este método para retornar true
para indicar que este mecanismo é suportado. Parar Imediatamente
Vários algoritmos de layout podem parar o cálculo quando ocorre
um evento externo, por exemplo, quando o usuário pressiona um botão “Parar”.
Para parar o layout, é possível chamar:
layout.stopImmediately();
O método retornará
true
se a parada foi iniciada e false
se o algoritmo não puder parar. O método retorna imediatamente, mas
o encadeamento de layout geralmente precisa de algum tempo adicional depois
de iniciar a parada para limpar as estruturas de dados. As consequências de parar um processo de layout dependem do
algoritmo de layout específico. Alguns algoritmos de layout possuem uma
natureza iterativa. Parar o processo de iteração resulta em uma pequena perda de qualidade no
desenho, mas o layout ainda pode ser considerado válido.
Outros algoritmos de layout possuem uma natureza sequencial. Interrupting the
sequence of the layout steps might not result in a valid layout. Geralmente, estes algoritmos retornam à situação antes do início do
processo de layout.
Para indicar se uma subclasse de
GraphLayout
suporta este mecanismo, use o método: layout.supportsStopImmediately();
A implementação padrão retorna
false
.
É possível gravar uma subclasse para substituir este método para retornar true
para indicar que este mecanismo é suportado.