= Camada de Controle (Control) =
[[WikiInclude(WF/tableofcontents)]]

Por definição, a camada de Controle faz o gerenciamento entre o usuário, as Views (interfaces) e o Model (funções do sistema). Ela 
deve saber apenas quais são as funções do sistema e não como implementá-las. Será responsável por receber as 
solicitações de serviços vindas do usuário, chamar a implementação da Model correspondente e com base na resposta, encaminhar uma interface (View) adequada de volta ao usuário.

Em hipótese alguma poderá existir formatação de dados nesta camada, bem como não poderão estar implementadas regras do negócio, como por exemplo acesso ao banco de dados.

Os arquivos das classes de Controle devem ter nome no formato class.!AtividadeController.inc.php, e ficam gravados no diretório 'code' da estrutura de diretórios apresentada anteriormente, ou então estão acessíveis na aba 'Includes' da interface de codificação.

Exemplo de código de uma camada Controller:

{{{
<?php
/**
 * Gerencia atividade Compor do processo Atos Administrativos.
 * @author carloseduardo
 * @author viani
 * @author aleheil
 * @version 1.4
 * @license http://www.gnu.org/copyleft/gpl.html GPL 
 * @package Atos_Administrativos.
 */
class ComporController extends Controller
{ 
	/**
	 * Acao padrao/inicial da atividade.
	 * @return void
	 * @access public
	 */
	function __default ()
	{		
		$this->model->defaultAction();
		$this->loadViewVars();
		$this->showForm($this->COMPOR);
	}
	
	/**
	 * Executa a ação salvar da atividade compor e encerra a execução da atividade.
	 * @return void
	 * @access public 
	 */
	function salvar()
	{               
	   	if ( ! $this->model->salvarAction())
	   	{
	   		$this->loadViewVars();
			$this->showForm($this->COMPOR);	
	   	}
	}    
	
	/**
	 * Execucao da atividade.
	 * @param $action Servico (acao) solicitado
	 * @return void
	 * @access private 
	 */ 
	function run($action)
	{    	
		$this->model->DAO->connect ( );
    	        $this->dispatch($action);
   		$this->model->DAO->disconnect ( );  		
    }
} 
?>
}}}

Neste exemplo, a função run() recebe como parâmetro a ação a ser executada, e o método dispatch() está encarregado de executar a função de controle correspondente. Assim, se for passada a ação 'salvar' será executado o método Salvar() desta mesma classe. Antes disto, porém foi realizada a conexão com o banco de dados, através do comando $this->model->DAO->connect(), mas isto é opcional.

Caso nenhuma ação seja recebida, será executado o método !__default(), também definido nesta classe.

Note que para cada ação que for necessária na atividade, deverá existir uma função correspondente na camada Controller.

Analisando a função Salvar(), vemos que a mesma faz uso da camada Model para executar a operação de salvamento (negócio) e caso obtenha sucesso irá carregar os dados na camada View e a seguir definir qual o template a ser usado para mostrar os dados.

Tudo que foi falado até aqui sobre a camada Controller diz respeito ao código da atividade, mas note que na definição da classe Controller, existe uma heranca de outra classe, representado pela cláusula 'extends Controller'. Isso significa que existe uma classe superior (pai) da qual a classe em questão é filha. Na classe pai existem métodos que são comuns a todos as classes Controller das atividades. Esta maneira de programar por objetos, com herança, é fundamental para evitar a repetição de código.

Continuando com o exemplo, teremos uma classe Controller, a nível de processo, cujo código está a seguir. Esta classe também fica armazena no diretório 'code', e nome do arquivo deve seguir o formato class.Controller.inc.php

{{{
<?php
/**
 * Gerencia o processo Atos Administrativos
 * @author carloseduardo
 * @author viani
 * @author aleheil
 * @version 1.4
 * @license http://www.gnu.org/copyleft/gpl.html GPL 
 * @package Atos_Administrativos
 */
class Controller extends BaseController
{	
    /**
     * @var string Tela inicial da atividade Compor
     * @access public
     */
	var $COMPOR = 'Compor.tpl';

	/**
     * @var string Tela da atividade Enviar
     * @access public
     */
	var $ENVIAR = 'Enviar.tpl';

	/**
     * @var string Tela da atividade Consultar
     * @access public
     */
	var $CONSULTAR = 'Consultar.tpl';

	/**
     * @var string Tela da atividade Alterar
     * @access public
     */
	var $ALTERAR = 'alterar.tpl';

	/**
     * @var string Tela da atividade Visualizar
     * @access public
     */
	var $VISUALIZAR = 'visualizar.tpl';     

	/**
     * @var string Tela da atividade Imprimir
     * @access public
     */
	var $IMPRIMIR = 'imprimir.tpl';
	
	/**
     * @var string Tela da atividade Manter Categorias
     * @access public
     */
	var $MANTER = 'Manter_Categorias.tpl';

	/**
     * Process startup settings
     * @param object $model Model layer instance for activities business logic
     * @param array $env MVC environment settings 
     * @return object
     * @access protected
     */ 
	function Controller(&$model , &$env)
    {
        $this->super(&$model , &$env);
        $this->assign('inbox', $this->model->getWfProperty('wf_workflow_path') . 
                       SEP . 'index.php?start_tab=0');
	$this->assign('processes', $this->model->getWfProperty('wf_workflow_path') . 
                       SEP . 'index.php?start_tab=1');
	$this->assign('activity_title', 'Atos Administrativos');
    }    	
}
?>
}}}

Na classe de Controle, a nível de processo, representado pelo exemplo anterior, iremos colocar tudo aquilo que for comum ao Controle das atividades. A classe começa definindo as constantes que representam os templates do processo. Depois implementa o método construtor 'Controller', que no exemplo, está definindo três variáveis da camada View, que ficarão disponíveis para as classes que a extenderem.

Mais uma vez observamos a existência de uma cláusula 'extends' que neste caso está extendendo a classe !BaseController. Essa classe está definida a nível de módulo e contém métodos de uso geral para atividades de Controle, que estão disponíveis para as classes filhas.

Segue uma explicação dos atributos da classe !BaseController:

 * view: objeto da classe Smarty que representa a camada View
 * templateFile: armazena o nome do template em uso pela camada View
 * model: objeto da classe Model da atividade

Métodos da classe !BaseController:

 * showForm: troca o template em uso;
 * syncVars: transfere todos os atributos da camada Model para a Camada View;
 * loadViewVars: recupera os dados produzidos pela camada Model e os transfere para a camada View;
 * assign: seta o valor de uma variável da camada View;
 * cancelar: aborta a execução da atividade corrente;
 * dispatch: executa a ação solicitada pelo usuário;