Plugins


= Plugins =

Este capítulo é um tutorial prático para construção de plugins. Ele começa explorando
os //headers// e estruturas internas ao **GRAFO** que precisão ser conhecidas antes
da construção. Depois através de um exemplo simples, //Hello World//, é explorado
a estrutura de um plugin: //headers// necessários, protótipo das funções e corpo das funções.
Utilizando-se do //Hello World// também é abordo compilação, instalação e execução de um plugin.
O capitulo termina detalhando através do exemplo //Get some parameter// 
como se faz para receber parâmetros. Pelo exemplo //Generate Star Graph// como se cria vértices e arestas. 
E finalmente utilizando-se dos plugins //Highest Degree// e //Some Edge// como se faz
respectivamente para destacar os vértices e arestas na interface do grafo.  
 
Os plugins são bibliotecas carregadas dinamicamente pelo **GRAFO** no momento da
inicialização. Cada plugin pode ter um ou mais algoritmos. A cada algoritmo criado
recebe uma nova entrada no menu //Algorithms// de acordo com a sua categoria. São elas:

+ Test
+ Result
+ Step by step
+ Tranformations
+ Search


Sem dúvida a construção de plugins é que torna o **GRAFO** realmente poderoso. 
Com eles pode-se facilmente implementar um novo algoritmo e acompanhar visualmente
o seu resultado.


== Headers ==

Para a construção de plugins é preciso conhecer algumas estruturas internas do 
**GRAFO** e os //headers// onde estão declaradas. São Elas:

**//graph.h//**

No //header// //graph.h// estão declaradas as estruturas que representam um 
vértice, uma aresta e um //grafo// dentro do ambiente. Bem como as funções utilizadas
para manipula-los.

**Vertex struct** - Estrutura de um vértice

A estrutura //Vertex// (tabela 4.1) contém as informações necessárias para a representação de
um vértice são elas: Identificador, nome dado ao vértice, o seu peso, a sua posição
(x,y) no plano cartesiano, sua cor, informações se o vértice está conectado, se está
marcado, grau do vértice, grau de entrada e grau de saída.

Obs.: A propriedade //degree// só é utilizada em //grafos// enquanto que propriedades //indegree// e
//outdegree// em //Digrafos//.

|| Nome         | Tipo       | Descrição                              |  
| ``id``        | ``int``    | Identificador auto incremental e único |
| ``label``     | ``char *`` | Texto (nome) associado ao vértice      |
| ``weight``    | ``Weight`` | Peso da aresta - ``typedef float``     |
| ``x``         | ``float``  | Posição X em 2D                        |
| ``y``         | ``float``  | Posição Y em 2D                        |
| ``color``     | ``Color``  | Cor do vértice - ``typedef int``       |
| ``concomp``   | ``int``    | Se 1 o vértice está conectado          |
| ``mark``      | ``char``   | Se 1 o vértice está marcado            |
| ``degree``    | ``int``    | Grau do vértice                        | 
| ``indegree``  | ``int``    | Grau de entrada                        | 
| ``outdegree`` | ``int``    | Grau de saída                          |
(tabela 4.1)

**Edge** - Matriz de adjacência

Um aresta é representada pela matriz de adjacência e sua unidade básica é ``typedef char Edge``.
Neste caso assume //0// (zero) ou //1// (um). Na tabela 4.3 onde descrito as propriedades 
de um grafo pode ser visto que o //Edge// é declarado como ``Edge **``, ou seja uma matriz
bidimensional.

**Edge_prop struct** - Estrutura das propriedades de uma aresta

A estrutura //Edge_prop// (tabela 4.2) vem complementar a matriz de adjacência //Edge//.
As informações complementares são: Nome associado a aresta, o seu peso, a sua cor, informações
se a aresta está marcada e os pontos de controle utilizados para gerar arestas curvas.

|| Nome          | Tipo             | Descrição                          |  
| ``label``      | ``char *``       | Texto (nome) associado a aresta    |
| ``weight``     | ``Weight``       | Peso da aresta - ``typedef float`` |
| ``color``      | ``Color``        | Cor da aresta - ``typedef int``    |
| ``mark``       | ``char``         | Se 1 a aresta está marcada         |
| ``ctrlpoints`` | ``float [4][3]`` | Pontos de controle                 |
(tabela 4.2)

**Graph struct** - Estrutura de um grafo

A estrutura //Graph// (tabela 4.3) contém as informações necessárias para a representação
de um //grafo//. São elas: O seu tipo, a quantidade de vértices, o identificador do próximo vértice,
a quantidade de vértices para o tipo //grafo//, a quantidade de arestas para o tipo //digrafo//, 
o espaço em memória alocado, a lista de vértices, a matriz de adjacência, a matriz de propriedade
dos vértices, o número de componentes conexos e o número de cores utilizadas.

Obs.: As propriedades ncomp, ncolor e encolor não são inicializadas ou atualizadas automaticamente.
Caso deseje utiliza-las é necessário que as faça manualmente.

|| Nome              | Tipo             | Descrição                                                      |  
| ``type``           | ``GraphType``    | Informa o tipo do //grafo// - ``typedef enum (GRAPH,DIGRAPH)`` |
| ``size``           | ``int``          | Quantidade de vértices do //grafo//                            |
| ``nextid``         | ``int``          | Identificador a ser recebido pelo próximo vértice              |
| ``nedges``         | ``int``          | Quantidade de vértices (//Grafos//)                            |
| ``narcs``          | ``int``          | Quantidade de arcos (//Digrafos//)                             |
| ``allocated_size`` | ``int``          | Espaço alocado                                                 |
| ``vertex``         | ``Vertex *``     | Lista de vértices                                              |
| ``edge``           | ``Edge **``      | Matriz de adjacência - ``typedef char``                        |
| ``prop``           | ``Edge_prop **`` | Propriedades da matriz de adjacência                           |
| ``ncomp``          | ``int``          | Número de componentes conexos                                  |
| ``ncolor``         | ``int``          | Número de cores utilizadas (Não é número cromático)            |
| ``encolor``        | ``int``          | Número de cores utilizadas pelas arestas                       |
(tabela 4.3)
    
**SEdge struct** - Estrutura de uma aresta simples

A estrutura //SEdge// (tabela 4.4) contem a informação do par ordenado que forma uma
aresta. Esta estrutura será e incluída será utilizada na lista de destaque de aresta.
Vide tabela 4.18 para maiores detalhes.

Obs.: As estruturas SEdge e SVertex são auxiliares e são necessárias para destaque
de vértices e arestas na interface do **GRAFO**.

|| Nome | Tipo        | Descrição                   |  
| ``u`` | ``SVertex`` | Vértice U - ``typedef int`` |
| ``v`` | ``SVertex`` | Vértice V - ``typedef int`` |
(tabela 4.4)

**Functions** - Funções para manipulação de um //grafo//

A tabela 4.5 traz a lista de funções para manipulação do grafo. Com elas pode-se
alocar e liberar memória para um //grafo//, inicializar as estruturas internas,
copiar um grafo em outro, adicionar e remover vértices, arestas e arcos. E também
limpar o status de marcado (//mark//) de vértices e arestas.

Obs.: Funções internas de controle não estão documentadas. A princípio elas não
são necessárias para a construção de plugins.

|| Declaração                                   | Descrição                                                                                                   |  
| ``void AllocGraph(Graph *G)``                 | Aloca espaço para um //grafo// e as estruturas que o compõem (vértices, arestas, matriz de adjacência, etc) |
| ``void FreeGraph(Graph *G)``                  | Libera espaço alocado para //grafo// e suas estruturas                                                      |
| ``void InitGraph(Graph *G, GraphType type)``  | Inicializa um //grafo// e suas estruturas                                                                   |
| ``void InitEdges(Graph *G)``                  | Inicializa somente a matriz de adjacência e suas propriedades                                               |
| ``void CopyGraph(Graph *H, Graph *G)``        | Aloca o //grafo// H e copia o G nele                                                                        |
| ``void AddPoint(Graph *G, float x, float y)`` | Adiciona a vértice na posição (x,y)                                                                         |
| ``void RemovePoint(Graph *G, int p)``         | Remove o vértice o P vértice do //grafo//                                                                   |
| ``void AddEdge(Graph *G, int x, int y)``      | Adiciona um aresta entre os vértices X e Y                                                                  |
| ``void RemoveEdge(Graph *G, int x, int y)``   | Remove a aresta entre os vértices X e Y                                                                     |
| ``void AddArc(Graph *G, int x, int y)``       | Adciona o arco entre os vértice X para Y                                                                    |
| ``void RemoveArc(Graph *G, int x, int y)``    | Remove a aresta direcionada do vértice X para Y                                                             |
| ``void ClearMarkedVerts(Graph *G)``           | Limpa a propriedade //mark// dos vértices                                                                   |
| ``void ClearMarkedEdges(Graph *G)``           | Limpa a propriedade //mark// das arestas                                                                    |
(tabela 4.5)

**//pgin.h//**

No //header// //pgin.h// estão declarados a estrutura para a lista de algoritmos bem
como funções para entrada de parâmetros.

**Pgin struct** - Estrutura da lista de funções

A estrutura //Pgin// é uma lista de funções (algoritmos) disponíveis em um plugin.
Cada plugin deve possuir no mínimo uma função sempre terminada pelo tipo ``PGIN_LIST_END``
ao final do capítulo 4 a criação de plugins de exemplo irão abordar a correta construção
da lista de algoritmos disponíveis em um plugin. A tabela 4.6 detalha os campos
da estrutura. São eles: Tipo do algoritmo, nome para o menu, nome da função
principal do algoritmo e flags de controle para o **GRAFO**.

|| Nome     | Tipo       | Descrição                                                                                     |  
| ``type``  | ``int``    | Determina o tipo do plugin na lista de algoritmos                                             |
| ``label`` | ``char *`` | Determina o nome do algoritmo. Este é nome que irá aparecer na entrada do menu //Algorithms// |
| ``name``  | ``char *`` | Determina o nome da função do algoritmo dentro do plugin                                      |
| ``flags`` | ``int``    | Passa informações ao **GRAFO** de como tratar esse algoritmo após a sua execução              |
(tabela 4.6)

A tabela 4.7 detalha o valor para o campo ``type`` na lista de algoritimos. 

|| Nome               | Descrição                                  |  
| ``PGIN_TEST_ALG``   | Informa que o algoritmo é de testes        |
| ``PGIN_RESULT_ALG`` | Informa que o algoritmo é de resultado     |
| ``PGIN_STEP_ALG``   | Informa que o algoritmo é de passo a passo |
| ``PGIN_TRANSF_ALG`` | Informa que o algoritmo é de transformação |
| ``PGIN_SEARCH_ALG`` | Informa que o algoritmo é de busca         |
| ``PGIN_LIST_END``   | Final da lista de algoritmos               |
(tabela 4.7)

O campo ``flag`` detalhado na tabela 4.8 informa ao **GRAFO** como ele deve redesenhar o //grafo// resultante ao
termino da execução de um algoritmo de transformação. Os demais tipos de //plugins//
não são sensíveis a estes //flags// e os grafos não serão redesenhados ao término da execução
destes //plugin//.

|| Nome                  		         | Descrição                                                                                             |  
| ``PGIN_FLAG_NOREDRAW``                 | Não redesenha o //grafo//. O construtor do plugin é responsável por determinar a posição dos vértices |
| ``PGIN_FLAG_REDRAWASCIRCLE``           | Redesenha o //grafo// automaticamente em  circulo                                                     |
| ``PGIN_FLAG_REDRAWWITHCENTEREDVERTEX`` | Redesenha o //grafo// com o primeiro vértice no centro                                                |
(tabela 4.8)

**Functions** - Funções de entrada de dados a um //plugin//

A tabela 4.9 traz a lista de funções para manipulação de entrada de dados para
os plugins. Com elas é possível fazer a leitura dos tipos de dados: Inteiro, Double e String.

|| Declaração                                                                                                        | Descrição                                           |  
| ``int pgin_read_int(char *name, char *label,@@ int def, int min, int max, int inc)``                               | Cria janela para leitura de um tipo de dado inteiro |
| ``double pgin_read_double(char *name, char *label,@@ double def, double min, double max, double inc, int digits)`` | Cria janela para leitura de um tipo de dado double  |
| ``char *pgin_read_string(char *name, char *label,@@ char *def, int max_len)``                                      | Cria janela para leitura de uma tipo de dado string |
(tabela 4.9)

A tabela 4.10 detalha os parâmetros das funções de entrada de dados descritas na tabela 4.9.

|| Parâmetros | Descrição                            |  
| ``name``    | Nome da janela                       |
| ``label``   | Texto informativo                    |
| ``def``     | Valor padrão                         |
| ``min``     | Mínimo valor permitido               |
| ``max``     | Máximo valor permitido               |
| ``inc``     | Incremento para ``int`` e ``double`` |
| ``digits``  | Número de casas decimais             |
| ``max_len`` | Tamanho máximo da string             |
(tabela 4.10)

**//alghandler.h//**

No //header// //alghandler.h// estão declarados as estruturas das listas de algoritmos bem como as funções utilizadas
para manipula-las.

A tabela 4.11 detalha a função //RunAlgorithm// que pode ser utilizada para chamar
qualquer algoritmo existente no grafo sendo ele nativo ou não. As listas especiais
de destaque //arc_edges// e //verts// serão abordadas neste capítulo no tópico //Estrutura de um plugin//.

|| Declaração                                                                                | Descrição                                                           |  
| ``int RunAlgorithm(char *name, Graph *G, char *s,@@ int x, List *arc_edges, List *verts)`` | Chama qualquer algoritmo disponível sendo ele nativo ou por plugins |
(tabela 4.11)

**//list.h//**

No //header// //list.h// estão declarados as estruturas de pilha e lista. Bem como as funções utilizadas
para manipula-las. Elas são necessárias no destaque de vértices e arestas. Vide o tópico //Destacando vértices e arestas//
neste capítulo.

**Node struct** - Estrutura de um nodo

A estrutura //Node// na tabela 4.12 contém um nodo genérico onde o campo ``data`` pode apontar
para qualquer tipo de dado. O nodo pode ser utilizado tanto em uma lista ou em uma pilha.

|| Nome    | Tipo       | Descrição                            |  
| ``data`` | ``void *`` | Aponta para o dado do Node           |
| ``size`` | ``int``    | Tamanho alocado para o dado apontado |
| ``next`` | ``Node *`` | Aponta para o próximo nodo           |
| ``prev`` | ``Node *`` | Aponta para o nodo anterior          |
(tabela 4.12)

**Functions** - Funções para manipulação de um nodo

A tabela 4.13 traz a lista de funções para criação e destruição de um nodo.

|| Declaração                             | Descrição                                                               |  
| ``Node MakeNode(void *data, int size)`` | Cria um nodo apontando para um dado informado com o tamanho de ``size`` |
| ``void DestroyNode(Node n)``            | Destrói o nodo informado                                                |
(tabela 4.13)

**List struct** - Estrutura de uma lista

A estrutura //List// (tabela 4.14) contém os dados necessários para se trabalhar 
com o tipo de dado lista.

|| Nome    | Tipo     | Descrição       |  
| ``size`` | ``int``  | Número de nodes |
| ``head`` | ``Node`` | Primeiro node   |
| ``tail`` | ``Node`` | Último node     |
(tabela 4.14)

**Functions** - Funções para manipulação de uma lista

A tabela 4.15 contém a lista de funções para manipulação da estrutura //list// 
podendo-se com elas: Criar e inicializar uma lista, inserir e remover um nodo,
mover, copiar e limpar uma lista.

|| Declaração                                | Descrição                                                  |  
| ``List *CreateList(void)``                 | Cria uma lista                                             |
| ``void InitList(List *list)``              | Inicializa a lista informada                               |
| ``void InsertNode(List *list, Node node)`` | Insere um nodo na lista informada                          |
| ``Node RemoveNode(List *list, Node node)`` | Remove o nodo na lista informada                           |
| ``void MoveList(List *l1, List *l2)``      | Copia a L2 em L1 destruindo L2; L1 deve estar inicializada |
| ``void CleanList(List *list)``             | Remove todos os nodos de uma lista                         |
| ``void CopyList(List *l1, List *l2)``      | Copia a L2 em L1; L1 deve estar inicializada               |
(tabela 4.15)

**Stack struct** - Estrutura de uma pilha

A estrutura //Stack// (tabela 4.16) contém os dados necessários para se trabalhar 
com o tipo de dado pilha no **GRAFO**.

|| Nome    | Tipo     | Descrição       |  
| ``size`` | ``int``  | Número de nodes |
| ``top``  | ``Node`` | Topo da pilha   |
(tabela 4.16)

**Functions** - Funções para manipulação de uma pilha

A tabela 4.17 contém a lista de funções para manipulação da estrutura //Stack// 
podendo-se com elas: Criar e inicializar uma pilha, inserir e remover um nodo
e limpar a pilha.

|| Declaração                              | Descrição                      |  
| ``Stack *CreateStack(void)``             | Cria uma pilha                 |
| ``void InitStack(Stack *stk)``           | Inicializa a pilha informada   |
| ``void PushNode(Stack *stk, Node node)`` | Insere o nodo na pilha         |
| ``Node PopNode(Stack *stk)``             | Remove o nodo da pilha         |
| ``void CleanStack(Stack *stk)``          | Remove todos os nodos da pilha |
(tabela 4.17)

== Estrutura de um plugin ==

Neste tópico será abortado a criação do plugin //Hello World// e também o detalhamento
da estrutura e divisões de um plugin. O código fonte completo do plugin
//Hello Word// encontra-se no Apêndice B.

O plugin é dividido em 3 partes básicas. São elas:

+ Inclusão de //headers//
+ Protótipo das funções
+ Corpo das funções


=== headers ===

Na primeira parde deve-se incluir os //headers// da linguagem C e os //headers// obrigatórios
para os plugins:

%!include(html): ''include/04-Plugins-01-headers-hw.c.html'' 

Obs.: Os //headers// do grafo foram incluídos pressupondo que a diretório //plugins// está 
um nível abaixo do diretório do **GRAFO**.

=== Protótipo das funções ===

Na segunda parte deve-se declarar o protótipo para a função obrigatória //pgin_info//
o protótipo para as funções de algoritmos e outras funções internas ao plugin.
Como função de algoritmo foi declarado o tradicional //HelloWorld//.

%!include(html): ''include/04-Plugins-02-prototype-hw.c.html'' 

As funções de algoritmos possuem uma assinatura diferente para a lista de parâmetros de acordo
com o seu tipo. Essa diferença deve ser observada ao incluir o algoritmo na lista de funções
do //plugin//.

+ Test
```
int TestAlgorithm(Graph *G, char *mess)
```
+ Result
```
int ResultAlgorithm(Graph *G, char *mess, List *arc_edges, List *verts)
```
+ Step by step
```
int StepAlgorithm(Graph *G, char *mess, int indx, List *arc_edges, List *verts)
```
+ Tranformations
```
int Transformation(Graph *G, char *mess)
```
+ Search
```
int SearchAlgorithm(Graph *G, char *mess, int indx, List *arc_edges, List *verts)
```

A tabela 4.18 traz o detalhamento dos parâmetros passados as funções de algoritmos.

|| Parâmetros         | Descrição                                                         |  
| ``Graph *G``        | Aponta para //grafo// na área de trabalho                         |
| ``char *mess``      | Aponta para a mensagem na barra de status                         |
| ``int indx``        | Número do vértice inicial de buscas                               |
| ``List *arc_edges`` | Lista com as arestas destacadas do //grafo// na área de trabalho  |
| ``List *verts``     | Lista com os vértices destacados do //grafo// na área de trabalho |
(tabela 4.18)

É importante destacar que o //grafo// //G// passado como parâmetro aponta para a
estrutura do grafo que será desenhada na área de trabalho. E as listas //arc_edges//
e //verts// apontam para as estruturas de destaque de vértices e arestas.
Ao iniciar o **GRAFO** estas estruturas são alocadas e disponibilizadas para utilização.
Um plugin pode reinicializa-las com //InitGraph//, //InitEdges// e //CleanList//. Porem
**NÃO** deve liberar a memória alocadas a elas.

=== Corpo das funções ===

Na terceira parte deve-se criar o corpo para a função obrigatória //pgin_info// e implementar
as funções do algoritmo.

**//pgin_info//** - Função obrigatória

A //pgin_info// é responsável por inicializar a lista de funções existentes no //plugin//.
No exemplo abaixo incluímos a função //HelloWorld// do tipo //PGIN_TEST_ALG//.

%!include(html): ''include/04-Plugins-03-mandatory-hw.c.html'' 

Como já foi dito um plugin pode conter vários algoritmos, para isso basta incluí-los
na lista. Por exemplo se o algoritmo //HelloUniverse// estivesse no mesmo plugin que
o //HelloWorld// a função //pgin_info// deveria ser:

%!include(html): ''include/04-Plugins-04-mandatory2-hw.c.html'' 

**//HelloWorld//** - Funções de algoritmos

E finalmente a implementação da função de algoritmo. Quando o nosso exemplo
for executado será escrito na barra de status //Hello World!//.

%!include(html): ''include/04-Plugins-05-main-hw.c.html'' 

== Compilação e Instalação ==

Para que o plugin seja reconhecido pelo **GRAFO** devemos criar uma biblioteca 
dinâmica e inclui-lo no diretório destinado aos plugins.

+ Compilação

Para compilar o plugin de exemplo //HelloWorld// que está no arquivo //hw.c// utilizamos
a linha de comando abaixo:

```
gcc -Wall -fPIC -shared hw.c -o hw.so
```
+ Instalação

Para instalar o plugin basta copiar a biblioteca construída (//hw.so//) para o diretório 
de plugins. O diretório configurado pode ser consultado/alterado em 
//Options > Preferences... > Default paths > Plugins path//. Vide o capítulo 3 para
maiores detalhes.


== Execução ==

Ao abrir o **GRAFO** os plugins serão carregados e um item de menu criado 
para cada função neles contidas. No nosso exemplo o plugin //HelloWorld// criou
a entrada de menu abaixo. Figura 4.1:

[images/04-Plugins-HelloWorld-Menu.png]

(figura 4.1)

Ao clicar no menu //Hello World!// o **GRAFO** chama a função de algoritmo associado a ele.
E ao termino atualiza a //área de trabalho// e a //barra de status// com os resultados.
No nosso exemplo simplesmente escreve na //barra de status//. Figura 4.2.

[images/04-Plugins-HelloWorld-BarraStatus.png]

(figura 4.2)

== Recebendo parâmetros ==

Neste tópico será abordado a criação do plugin //Get some parameters// que ilustra a
utilização das funções de entrada de dados para o **GRAFO**. O código fonte completo do plugin
//Get some parameters// encontra-se no Apêndice B.

Os plugins podem receber 3 tipos de dados.

+ Inteiro
+ Double
+ String

Abaixo segue a função principal no arquivo //getsp.c//. O detalhamento das funções
//pgin_read_int//, //pgin_read_double// e //pgin_read_string// pode ser visto na tabela 4.9.

%!include(html): ''include/04-Plugins-06-main-getsp.c.html'' 

Como resultado obtemos os seguintes diálogos de entrada de dados.
Para um inteiro figura 4.3. Para um double figura 4.4. Para uma string figura 4.5.

| [images/04-Plugins-gepsp-int.png] | [images/04-Plugins-gepsp-double.png] | [images/04-Plugins-gepsp-string.png]
| (figura 4.3)                      | (figura 4.4)                         | (figura 4.5)

E os valores recebidos pelos diálogos são escritos na //barra de status//. Vide figura 4.6

[images/04-Plugins-gepsp-BarraStatus.png]

(figura 4.6)


== Criando vértices e arestas ==

Neste tópico será abordado a criação do plugin //Generate Star Graph// que ilustra a utilização das funções //AddPoint// e
//AddEdge// detalhadas na tabela 4.5. Abaixo segue a função principal no arquivo //stargraphexample.c//. O código fonte completo do plugin
//Generate Star Graph// encontra-se no Apêndice B.

%!include(html): ''include/04-Plugins-07-main-stargraphexample.c.html'' 

Como pode ser observado o algoritmo não se preocupa em posicionar de maneira elegante os
vértices na tela. Adicionando todos os vértices sempre na posição //(0,0)//.

%!include(html): ''include/04-Plugins-08-main-pice-stargraphexample.c.html'' 

Isto é possível porque o plugin de transformação criado está utilizando o //flag//
//PGIN_FLAG_REDRAWWITHCENTEREDVERTEX//. E com isso o //grafo// gerado será redesenhado
automaticamente com o primeiro vértice no centro. Se estivéssemos utilizando o //flag// //PGIN_FLAG_NOREDRAW//
o plugin deve responsável por posicionar os vértices corretamente na //área de trabalho//. 

Como resultado a geração de um grafo estrela com 20 vértices. Figura 4.7:

[images/04-Plugins-stargraph-grafo.png]

(figura 4.7)


== Destacando vértices e arestas ==

Neste tópico será abordado a construção do plugin //Highest Degree// que ilustra a utilização da lista especial //verts// e
a construção do plugin //Some Edge// que ilustra a utilização da lista especial //arc_edges//.
O destaque de vértices e arestas utilizam as listas especiais passadas como parâmetros aos plugins.
A lista //verts// contém os vértices destacados em um grafo.
A lista //arc_edges// contém as arestas e arcos destacados em um //{di,}grafo//.
Para o destaque deve-se simplesmente inserir um nodo nas listas a ao encerrar a execução do
algoritmo o **GRAFO** se encarrega de destacar na interface os nodos inseridos.
O detalhamento sobre as funções para manipulação de nodos e listas estão respectivamente
nas tabelas 4.13 e 4.15.

=== Destacando um vértice ===

Abaixo segue a função principal no arquivo //vertexexample.c// responsável pelo
plugin //Highest Degree// que ilustra a utilização da lista especial //verts//.
O código fonte completo do plugin //Highest Degree// encontra-se no Apêndice B.

%!include(html): ''include/04-Plugins-09-main-vertexexample.c.html'' 

Utiliza-se da função //MakeNode// para criar um novo nodo e depois da função //InsertNode//
para inserir um nodo com o vértice de maior grau na lista //verts//.

Como resultado o destaque do vértice 1 de grau 5 no grafo abaixo. Figura 4.8:

[images/04-Plugins-vertexexample-grafo.png]

(figura 4.8)

=== Destacando uma aresta ===

Abaixo segue a função principal no arquivo //edgeexample.c// responsável pelo
plugin //Some Edge// que ilustra a utilização da lista especial //arc_edges//.
O código fonte completo do plugin //Some Edge// encontra-se no Apêndice B.

%!include(html): ''include/04-Plugins-10-main-edgeexample.c.html'' 

Como no exemplo do vértice também se utiliza a função //MakeNode// para criar um novo nodo. Porem 
o nodo criado contém como dado uma aresta simples (//SEdge//). E depois utiliza-se da função //InsertNode//
para inserir o nodo com a aresta encontrada na lista //arc_edges//.

Como resultado o destaque da aresta entre o vértice 1 de grau 5 e o vértice 3 de grau 2. Figura 4.9:

[images/04-Plugins-edgeexample-grafo.png]

(figura 4.9)



