Jaison Valmor Bruch

Highlighter de código-fonte

2017-08-10T15:31:00.000-07:00

Para escrever a respeito de algoritmos é necessário, melhor dizendo, é desejável que o código-fonte esteja legível, que seja possível distinguir visualmente as palavras reservadas, os comentários, etc. Os ambientes de desenvolvimento, tais como NetBeans, VisualStudio, PyCharm, entre outros, oferecem ótimos recursos relacionados à legibilidade do código-fonte. Porém, para publicar trechos de algoritmos em páginas html essa busca pela clareza é mais difícil. O trecho de código descrito abaixo não está ruim, do ponto de vista da formatação, mas quem conhece programação sabe que poderia ser melhor.

class Area{
public static void main(String args[]){
double pi, r, a;
r = 10.8;
pi = 3.1416;
a = pi * r * r;
System.out.println("Area do círculo é " + a);
}
}

Esse mesmo algoritmo pode ser exibido de uma maneira muito mais legível, observe-se o trecho de código abaixo, as palavras reservadas estão em destaque, o espaçamento entre as letras é maior, há a diferenciação dos valores literais e ainda o indicador de número da linha.

class Area{
  public static void main(String args[]){
    double pi, r, a;
    r = 10.8;
    pi = 3.1416;
    a = pi * r * r;
    System.out.println("Area do círculo é " + a);
  }
}

Para realizar essa excelente formatação foi empregada a biblioteca SyntaxHighlighter desenvolvida por Alex Gorbatchev. Trata-se de uma biblioteca JavaScript para formatar e realçar código-fonte, ela reconhece códigos das linguagens C++, C#, CSS, Java, JavaScript, PHP, Python, Ruby, SQL, VisualBasic, XML, HTML e Perl. Para utilizar essa biblioteca é necessário incluir os códigos abaixo entre as tags head da página html.

<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/> 
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCpp.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCSharp.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPhp.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPython.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushRuby.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushSql.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushVb.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPerl.js' type='text/javascript'></script> 
<script language='javascript'> 
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.config.clipboardSwf = 'http://alexgorbatchev.com/pub/sh/current/scripts/clipboard.swf';
SyntaxHighlighter.all();
</script>

Na sequência, os trechos de texto que contém código-fonte devem ser circundados pelas tags pre (conforme ilustrado no trecho a seguir), informando alguma das opções de linguagem disponíveis. No exemplo ilustrado estamos formatando código html. Mais informações e detalhes de utilização podem ser encontrados no site do desenvolvedor.

  código fonte

Hospedagem gratuita para sites desenvolvidos com a linguagem Python

2017-08-10T09:44:00.000-07:00

A linguagem Python também pode ser utilizada no desenvolvimento de sistemas web e quem deseja criar e testar esse tipo de aplicação em um ambiente de hospedagem real (além do servidor local) pode contar com um serviço gratuito (embora limitado) diponibilizado pelo site pythonanywhere. O ambiente oferecido em sua configuração gratuita é completamente funcional, dentre as principais características pode-se destacar as seguintes:

Hospedagem de uma única aplicação
Servidor Linux
SGBD MySQL
Python e IPython nas versões 2.7 até 3.6
Frameworks flask e django
Acesso aos consoles Bash e MySQL
Painel de controle simples e intuitivo

As principais restrições são relacionadas à disponibilidade de recursos de processamento, espaço em memória e largura de banda. Além disso, a conta gratuita impõem um padrão para a definição do endereço da aplicação e ainda a necessidade de revalidação a cada três meses.
Para ter acesso ao serviço é necessário realizar o cadastro e informar um email válido para a confirmação da solicitação, logo em seguida o acesso é liberado e o desenvolvedor torna-se apto a carregar arquivos e rodar sua aplicação.

Yii - Argumentos Controle/View

2012-09-16T19:57:00.001-07:00

Para passar um ou mais argumentos de um método de uma classe de controle para um arquivo de visão no framework Yii é bastante simples. No exemplo a seguir a variável $hello armazena uma string que é enviada ao arquivo de visão index utilizando um array. Neste array a variável $hello é atribuída ao indice 'message' que é acessado no arquivo index como uma variável $message.

// Método da classe de controle
public function actionIndex() {
$hello = "Ola mundo";
$this->render('index',array('menssage'=>$hello,));
}

// arquivo index.php
echo($message);

Yii - consultas SQL

2012-09-06T11:25:00.001-07:00

O framework Yii não realiza a geração automática do código CRUD para tabelas com chave primária composta (Yii 1.1.12). Esse tipo de tabela é utilizada para modelar o relacionamento N para N entre duas tabelas. Portanto, o desenvolvedor precisa codificar as operações necessárias usando SQL e isso pode ser feito empregando a estrutura disponibilizada pelo framework. O exemplo a seguir demonstra como isso é simples, após a execução deste comando a variável $user vai conter os valores presentes na tabela tbl_user.

$user = Yii::app()->db->createCommand()
  ->where('user_id=:id',array(':id'=>1))
  ->select('*')
->from('tbl_user')
->queryRow();

Yii - campos obrigatórios

2012-09-05T07:11:00.002-07:00

Para definir que os campos de um determinado formulário devem obrigatoriamente ser preenchidos, basta adicionar esta restrição no método rules() da classe de modelo. A classe de modelo foi gerada automaticamente pelo framework e está por default no seguinte diretório:

minhaAppUsandoYii/protected/models/minhaClasse.php

Como as classes de modelo são geradas a partir do esquema do banco de dados, as restrições definidas nas tabelas são propagadas para as classes de modelo, por exemplo: tamanho máximo de strings, as restrições de tipo (numérico, booleano), entre outras.

No exemplo abaixo, o tamanho máximo da string name é de 128 caracteres e isso foi definido a partir do tamanho especificado no banco de dados. Para determinar que o campo name deve ser preenchido basta adicionar o valor required, conforme destacado no exemplo. Se mais campos são obrigatório basta acrescentar no array da seguinte forma:

array('name, outrocampo', 'required').

/**
* @return array validation rules for model attributes.
*/
public function rules()
{
return array(

array('name', 'length', 'max'=>128),

array('name', 'required'),
);

}

Exemplo de uso do HSQLDB com a ide Netbeans gerando o arquivo para distribuição

2010-03-24T16:54:00.000-07:00

Para quem não conhece, HSQLDB é um banco de dados desenvolvido utilizando a linguagem de programação java. Este software pode ser utilizado no modo cliente-servidor ou standalone, no modo cliente-servido ele se comporta como os demais bancos de dados, fica aguardando conexões através de uma rede de comunicação. No modo standalone (abordado neste tutorial) o banco de dados permite acesso de apenas um cliente de cada vez, esta característica é interessante no desenvolvimento de aplicações pequenas que requerem persistência de pouca quantidade de dados. Outro diferencial do HSQLDB é que por conta do seu tamanho (aproximadamente 6 MB) pode ser distribuído juntamente com a aplicação.

Neste tutorial iremos criar uma aplicação simples que acessa o banco, salva e recupera registros, também será demonstrado como utilizar o Netbeans para gerar o arquivo de distribuição de aplicações:

(i) Primeiramente é necessário configurar o ambiente de desenvolvimento, para este tutorial foi utilizado o Netbeans 6.5 e o hsqldb-2.0.0-rc7.

(ii) Inicie o Netbeans e crie um novo projeto java

(iii)Crie um novo formulário Jframe e nas configurações do projeto:

botão direito no projeto>definir configuração>personalizar

Selecione a classe criada como sendo a classe principal em seguida monte uma tela semelhante a da próxima figura.

Nesta tela temos três botões auto explicativos, cabe aqui apenas um alerta: a ação de criar o banco só pode ser executada uma vez, pois caso ocorra uma tentativa de criar um banco que já existe, ocorrerá uma exceção.

(iv)Para cada botão adicione um actionListener, isso pode ser feito através da aba de propriedades de cada botão ou simplesmente com um duplo clique no botão que automaticamente gera o actionListener e posiciona o cursor dentro do método.

   (v)Agora é necessário adicionar o HSQLDB ao projeto, isso pode ser feito com um clique do botão direito do mouse no ícone bibliotecas>adicionar jar/pasta e selecionar o local onde o hsqldb.jar está armazenado.
   (vi)Então deve ser codificadas as três ações que o programa poderá executar: criar o banco, inserir e listar:
--------------------------------------------------------------------------------------------------------------
     public void criaBancoDados(){
   try {
   Class.forName("org.hsqldb.jdbcDriver");
   } catch (ClassNotFoundException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   Statement stmt = null;
   ResultSet result;
   Connection c;

   try {
   c = DriverManager.getConnection("jdbc:hsqldb:file:testdb", "sa", "");
   stmt = c.createStatement();
   stmt.execute("CREATE TABLE Gravadora ( id BIGINT IDENTITY NOT NULL PRIMARY KEY ,nome VARCHAR(100) NOT NULL);");
   stmt.executeUpdate("shutdown");

   c.commit();
   stmt.close();
   c.close();
   } catch (SQLException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   }
------------------------------------------------------------------------------------------------------------

   public void insereDados(){
   try {
   Class.forName("org.hsqldb.jdbcDriver");
   } catch (ClassNotFoundException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   Statement stmt = null;
   ResultSet result;
   Connection c;

   try {
   c = DriverManager.getConnection("jdbc:hsqldb:file:testdb", "sa", "");
   stmt = c.createStatement();
   stmt.execute("insert into gravadora (nome) values ('EMI');");

   stmt.executeUpdate("shutdown");

   c.commit();
   stmt.close();
   c.close();
   } catch (SQLException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   }

------------------------------------------------------------------------------------------------------------

public void buscaDados(){
   try {
   Class.forName("org.hsqldb.jdbcDriver");
   } catch (ClassNotFoundException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   Statement stmt = null;
   ResultSet result;
   Connection c;

   try {
   c = DriverManager.getConnection("jdbc:hsqldb:file:testdb", "sa", "");
   stmt = c.createStatement();
   result = stmt.executeQuery("select * from gravadora;");

   while (result.next()) {
   String nome = result.getString("nome");
   System.out.println(nome);
   }

   stmt.executeUpdate("shutdown");

   c.commit();
   stmt.close();
   c.close();
   } catch (SQLException ex) {
   Logger.getLogger(Inicial.class.getName()).log(Level.SEVERE, null, ex);
   }
   }

------------------------------------------------------------------------------------------------------------

Observações:
   (i)Cada um destes métodos deve ser chamado a partir de seu botão específico.
   (ii)Para acessa o banco não é necessário inserir a uma url para localização uma vez que estamos trabalhando com o HSQLDB no modo standalone. O nome de usuário "SA" é o valor default do próprio sistema.
   (ii)O código acima foi gerado com o auxílio da IDE e está sujeito a incompatibilidade no tratamento de exceções.

   Vamos agora executar o projeto fora da IDE:
   O arquivo executável está localizado na pasta dist do projeto, para rodar basta digitar o código java -jar "url" a partir do seu terminal. Esta informação é fornecida no console da IDE após ser executada a ação de limpar e construir.
   Para distribuir sua aplicação basta selecionar a opção limpar e construir na IDE , acessar a pasta dist no seu projeto, criar um pacote com o seu conteúdo e está pronto.

O passeio do cavalo

2009-12-10T05:19:00.000-08:00

O passeio do cavalo é um problema baseado nos movimentos do cavalo no tabuleiro de xadrez, sempe em 'L'. Este problema é dito intratável por conta do número de movimentos possíveis, desta forma não é viável a utilização de algoritmos de força bruta para resolve-lo. A solução consiste em passear com o cavalo por todas as casas de um tabuleiro com 64 posições (8 x 8), para tanto utiliza-se a teoria dos grafos ou algum tipo de heurística para modelagem do problema. No exemplo que a ser demonstrado é utilizada a heurística do diamante e do quadrado.

A heurística do diamante e quadrado consiste em dividir o tabuleiro em quatro quadrantes e apartir de um ponto qualquer preencher as posições por onde o cavalo pode passar de acordo 4 tipos de figuras, como demonstrado na imagem acima. Deve-se preencher tipos intercalados de figura, por exemplo, se iniciar preenchendo um diamante na diagonal principal, esta figura é preenchida em todos os outros quadrante e a próxima figura a ser preenchida deverá ser um quadrado. O inverso também é válido, se iniciar com um quadrado, a próxima figura deverá ser um diamante. No desenvolvimento do algoritmo alguns cuidados devem ser tomados, como certificar-se de que o ponto final da figura que está sendo preenchida permita acesso a mesma figura no próximo quadrante ou no caso de ser o último quadrante, para a próxima figura a ser preenchida.

Na imagem acima, o programa desenvolvido em java, onde o usuário seleciona uma determinada posição do tabuleiro e visualiza os possíveis trajetos percorridos pelo cavalo. Se cruzarmos uma linha na sequencia em que os números aparecem na tela pode-se conferir o formato das figuras diamante e quadrado.
Segue abaixo o código fonte, com as seis classes implementadas.

// classe PasseioDoCavalo

package passeiodocavalo;
/**
*
* @author jaison
*/
public class PasseioDoCavalo {
    private Celula[][] tabuleiro = new Celula[8][8];

public   PasseioDoCavalo(){
    for(int x=0; x
        for(int y=0; y
            getTabuleiro()[x][y] = new Celula();
        }
    }
}

    public void impimeTabuleiro(){
        for(int x=0; x
            for(int y=0; y
                System.out.println(" [ "+x+ " "+y+" ] "+ getTabuleiro()[x][y].getPasso() + "\t"); //+ getTabuleiro()[x][y].getQuadrante());
            }
            System.out.println("\n");
        }
    }
    public boolean preencheFigura(int x_pos, int y_pos){
        boolean ret = false;

        switch(getTabuleiro()[x_pos][y_pos].getFigura()){
            case ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL:
                if(getTabuleiro()[x_pos][y_pos].getQuadrante() == ConstantDataManager.PRIMEIRO_QUADRANTE){

                }
                System.out.println("TRIANGULO_DIAGONAL_PRINCIPAL");
            break;
            case ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA:
                System.out.println("TRIANGULO_DIAGONAL_SECUNDARIA");
            break;
            case ConstantDataManager.QUADRADO_HORIZONTAL:
                System.out.println("QUADRADO_HORIZONTAL");
            break;
            case ConstantDataManager.QUADRADO_INCLINADO:
                System.out.println("QUADRADO_INCLINADO");
            break;
        }
        return false;
    }

    /**
     * @return the tabuleiro
     */
    public Celula[][] getTabuleiro() {
        return tabuleiro;
    }

    /**
     * @param tabuleiro the tabuleiro to set
     */
    public void setTabuleiro(Celula[][] tabuleiro) {
        this.tabuleiro = tabuleiro;
    }
}

// Classe TelaTabuleiro

package passeiodocavalo;

import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
*
* @author jaison
*/
public class TelaTabuleiro extends JFrame {
    static JPanel panel;
    JButton[][] casas = new JButton[8][8];

    public TelaTabuleiro(){
        init();
    }
    public void init(){

    panel=new JPanel(new GridLayout(8,8));

    for(int x=0; x
        for(int y=0; y
            casas[x][y] = new JButton(String.valueOf(x)+" "+String.valueOf(y));
            casas[x][y].setSize(80,80);
            casas[x][y].setActionCommand(String.valueOf(x)+String.valueOf(y));
            casas[x][y].addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent arg0) {
                        carregaTelaTabuleiro(arg0);
                    }
                });
                panel.add(casas[x][y]);
            }
        }
        super.setTitle("Selecione a posição inicial no tabuleiro");
        super.add(panel);
        super.pack();
    }

     public void carregaTelaTabuleiro(java.awt.event.ActionEvent e){
        for(int x=0; x
            for(int y=0; y
                casas[x][y].setText(" ");
            }
        }

        System.out.println(e.getActionCommand().charAt(0)+" "+e.getActionCommand().charAt(1));
        vai(Integer.parseInt(String.valueOf(e.getActionCommand().charAt(0))),
                    Integer.parseInt(String.valueOf(e.getActionCommand().charAt(1))));
     }

     public void vai(int x, int y){
        ControleMovimentacao c = new ControleMovimentacao();
        PasseioDoCavalo p = new PasseioDoCavalo();

        c.setTabuleiro(p.getTabuleiro()); // manda o tabuleiro para o controle de movimentação
        c.iniciar(x, y);   // inicia com a coordenada desejada

        if(c.temEstaFiguraNoQuadrante(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL,ConstantDataManager.SEGUNDO_QUADRANTE)){
        }

        //for(int i=0; i
        ArrayList aux = c.caminhosPossiveis(3, 3);
            for(int j=0; j
                System.out.println( "aqui-> " + aux.get(j));
            }
     for(int linha=0; linha
            for(int coluna=0; coluna
                casas[linha][coluna].setText(String.valueOf(p.getTabuleiro()[linha][coluna].getPasso()));
        }
     }
    }
}

// classe ControleMovimentacao

package passeiodocavalo;

import java.awt.Point;
import java.util.ArrayList;
import java.util.List;

/**
*
* @author jaison
*/
public class ControleMovimentacao {

    private Celula[][] tabuleiro;
    private Point pontoInicial;
    private Point pontoFinal;
    private boolean inicio = false;
    private List possibilidades = new ArrayList();
    private int contadorPassos = 0;

    /**
     * @return the tabuleiro
     */
    public Celula[][] getTabuleiro() {
        return tabuleiro;
    }

    /**
     * @param tabuleiro the tabuleiro to set
     */
    public void setTabuleiro(Celula[][] tabuleiro) {
        this.tabuleiro = tabuleiro;
    }

    public void iniciar(int x, int y) {
        resetTabuleiro(ConstantDataManager.PRIMEIRO_QUADRANTE);
        resetTabuleiro(ConstantDataManager.SEGUNDO_QUADRANTE);
        resetTabuleiro(ConstantDataManager.TERCEIRO_QUADRANTE);
        resetTabuleiro(ConstantDataManager.QUARTO_QUADRANTE);

        int figuraAtual;
        int quadranteAtual;
        int indexPontofinal = 0;
        int indexQuadrante = 0;
        int contadorCaminhoAlternativo = 0;
        int aux_x;
        int aux_y;
        setInicio(true);                   // inicia

        boolean fluxoNormal = false;
        boolean inverteu = false;

        setPontoInicial(new Point(x, y));
        //setPontoFinal(pontoFinal(getPontoInicial().x, getPontoInicial().y)[0]); // primeira opção de ponto final
        figuraAtual = getTabuleiro()[getPontoInicial().x][getPontoInicial().y].getFigura();       // encontra a figura do ponto inicial
        quadranteAtual = getTabuleiro()[getPontoInicial().x][getPontoInicial().y].getQuadrante(); // encoontra o quadrante

        for (int teste = 0; teste < 55; teste++) {
            if(indexPontofinal == 0){
                indexPontofinal = 1;
            }else{
                indexPontofinal = 0;
            }
            setPontoFinal(pontoFinal(getPontoInicial().x, getPontoInicial().y)[indexPontofinal]);
            for (int saltos = 0; saltos < caminhosPossiveis(getPontoFinal().x, getPontoFinal().y).size(); saltos++) {
                aux_x = caminhosPossiveis(getPontoFinal().x, getPontoFinal().y).get(saltos).x;
                aux_y = caminhosPossiveis(getPontoFinal().x, getPontoFinal().y).get(saltos).y;

                if ( getTabuleiro()[aux_x][aux_y].getFigura() == figuraAtual                            &&
                      getTabuleiro()[aux_x][aux_y].getQuadrante() == proximoQuadrante(quadranteAtual)[0] &&
                      getTabuleiro()[aux_x][aux_y].isOcupada() == false ) {
                    // se encontrar a mesma figura na primeira opção do proximo quadrante
                    preencheFigura(getPontoInicial(),getPontoFinal());
                    setPontoInicial(new Point(aux_x, aux_y));

                    quadranteAtual = getTabuleiro()[aux_x][aux_y].getQuadrante();
                    figuraAtual = getTabuleiro()[aux_x][aux_y].getFigura();
                    break;

                }else if ( getTabuleiro()[aux_x][aux_y].getFigura() == figuraAtual                            &&
                           getTabuleiro()[aux_x][aux_y].getQuadrante() == proximoQuadrante(quadranteAtual)[1] &&
                           getTabuleiro()[aux_x][aux_y].isOcupada() == false ) {
                    // se encontrar a mesma figura na segunda opção do proximo quadrante
                    preencheFigura(getPontoInicial(),getPontoFinal());
                    setPontoInicial(new Point(aux_x, aux_y));

                    quadranteAtual = getTabuleiro()[aux_x][aux_y].getQuadrante();
                    figuraAtual = getTabuleiro()[aux_x][aux_y].getFigura();
                    break;
                } else if (quantasVezesPreenchida(figuraAtual) == 3){
                    // se a figura atual ja foi preenchida 3 vezes
                    //preencheFigura(getPontoInicial(),getPontoFinal());
                    //figuraAtual = proximaFigura(figuraAtual);
                    if ( getTabuleiro()[aux_x][aux_y].getFigura() == proximaFigura(figuraAtual)             &&
                          getTabuleiro()[aux_x][aux_y].getQuadrante() == proximoQuadrante(quadranteAtual)[0] &&
                          getTabuleiro()[aux_x][aux_y].isOcupada() == false ) {

                        preencheFigura(getPontoInicial(),getPontoFinal());

                    }else if ( getTabuleiro()[aux_x][aux_y].getFigura() == proximaFigura(figuraAtual)             &&
                                getTabuleiro()[aux_x][aux_y].getQuadrante() == proximoQuadrante(quadranteAtual)[1] &&
                                getTabuleiro()[aux_x][aux_y].isOcupada() == false ){

                        preencheFigura(getPontoInicial(),getPontoFinal());
                    }else{
                        int fim = quantasFigurasPreenchidasNesteQuadrante(ConstantDataManager.PRIMEIRO_QUADRANTE) +
                                  quantasFigurasPreenchidasNesteQuadrante(ConstantDataManager.SEGUNDO_QUADRANTE ) +
                                  quantasFigurasPreenchidasNesteQuadrante(ConstantDataManager.TERCEIRO_QUADRANTE) +
                                  quantasFigurasPreenchidasNesteQuadrante(ConstantDataManager.QUARTO_QUADRANTE );
                        if(fim == 15){
                            preencheFigura(getPontoInicial(),getPontoFinal());
                        }
                   }
                }
            }
            if(quantasVezesPreenchida(figuraAtual) == 4){
                figuraAtual = proximaFigura(figuraAtual);
            }
        }
    }

    public boolean proximoPasso() {
        boolean ret = false;
        if (isInicio()) { // se já iniciou
        }
        return ret;
    }

    /*Recebe as coordenadas xy e retorna quais são as casas atingiveis apartir
     * deste ponto
     **/
    public ArrayList caminhosPossiveis(int x, int y) {
        getPossibilidades().clear();
        if (x + 2 <= 7 && y + 1 <= 7) { // 1
            getPossibilidades().add(new Point(x + 2, y + 1));
        }
        if (x + 2 <= 7 && y - 1 >= 0) { // 2
            getPossibilidades().add(new Point(x + 2, y - 1));
        }
        if (x - 2 >= 0 && y + 1 <= 7) { // 3
            getPossibilidades().add(new Point(x - 2, y + 1));
        }
        if (x - 2 >= 0 && y - 1 >= 0) { // 4
            getPossibilidades().add(new Point(x - 2, y - 1));
        }
        if (y + 2 <= 7 && x + 1 <= 7) { // 5
            getPossibilidades().add(new Point(x + 1, y + 2));
        }
        if (y + 2 <= 7 && x - 1 >= 0) { // 6
            getPossibilidades().add(new Point(x - 1, y + 2));
        }
        if (y - 2 >= 0 && x + 1 <= 7) { // 7
            getPossibilidades().add(new Point(x + 1, y - 2));
        }
        if (y - 2 >= 0 && x - 1 >= 0) { // 8
            getPossibilidades().add(new Point(x - 1, y - 2));
        }
        return (ArrayList) getPossibilidades();
    }

    /*Recebe uma coordenada e verifica quais as coordenadas finais de acordo com
     * o tipo de figura da coordenada
     **/
    public Point[] pontoFinal(int px, int py) {
        Point[] pontosFinais = new Point[2];

        pontosFinais[0] = new Point(-1, -1);
        pontosFinais[1] = new Point(-1, -1);

        getTabuleiro()[px][py].getFigura();
        int x = -1;
        int y = -1;

        switch (getTabuleiro()[px][py].getQuadrante()) {
            case ConstantDataManager.PRIMEIRO_QUADRANTE:
                x = 0;
                y = 0;
                break;
            case ConstantDataManager.SEGUNDO_QUADRANTE:
                x = 0;
                y = 4;
                break;
            case ConstantDataManager.TERCEIRO_QUADRANTE:
                x = 4;
                y = 0;
                break;
            case ConstantDataManager.QUARTO_QUADRANTE:
                x = 4;
                y = 4;
                break;
        }

        switch (getTabuleiro()[px][py].getFigura()) {
            case ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL:
                if ((px == 0 + x && py == 0 + y) || (px == 3 + x && py == 3 + y)) {
                    pontosFinais[0] = new Point(1 + x, 2 + y);
                    pontosFinais[1] = new Point(2 + x, 1 + y);
                } else {
                    pontosFinais[0] = new Point(0 + x, 0 + y);
                    pontosFinais[1] = new Point(3 + x, 3 + y);
                }
                break;
            case ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA:
                if ((px == 0 + x && py == 3 + y) || (px == 3 + x && py == 0 + y)) {
                    pontosFinais[0] = new Point(1 + x, 1 + y);
                    pontosFinais[1] = new Point(2 + x, 2 + y);
                } else {
                    pontosFinais[0] = new Point(0 + x, 3 + y);
                    pontosFinais[1] = new Point(3 + x, 0 + y);
                }
                break;
            case ConstantDataManager.QUADRADO_HORIZONTAL:
                if ((px == 0 + x && py == 1 + y) || (px == 3 + x && py == 2 + y)) {
                    pontosFinais[0] = new Point(2 + x, 0 + y);
                    pontosFinais[1] = new Point(1 + x, 3 + y);
                } else {
                    pontosFinais[0] = new Point(0 + x, 1 + y);
                    pontosFinais[1] = new Point(3 + x, 2 + y);
                }
                break;
            case ConstantDataManager.QUADRADO_INCLINADO:
                if ((px == 0 + x && py == 2 + y) || (px == 3 + x && py == 1 + y)) {
                    pontosFinais[0] = new Point(1 + x, 0 + y);
                    pontosFinais[1] = new Point(2 + x, 3 + y);
                } else {
                    pontosFinais[0] = new Point(0 + x, 2 + y);
                    pontosFinais[1] = new Point(3 + x, 1 + y);
                }
                break;
        }
        return pontosFinais;
    }

    /*Recebe um quadrante e retorna os próximos quadrantes possíveis
     **/
    public int[] proximoQuadrante(int quadranteAtual) {
        int[] ret = new int[2];

        switch (quadranteAtual) {
            case ConstantDataManager.PRIMEIRO_QUADRANTE:
                ret[0] = ConstantDataManager.SEGUNDO_QUADRANTE;
                ret[1] = ConstantDataManager.TERCEIRO_QUADRANTE;
                break;
            case ConstantDataManager.SEGUNDO_QUADRANTE:
                ret[0] = ConstantDataManager.PRIMEIRO_QUADRANTE;
                ret[1] = ConstantDataManager.QUARTO_QUADRANTE;
                break;
            case ConstantDataManager.TERCEIRO_QUADRANTE:
                ret[0] = ConstantDataManager.PRIMEIRO_QUADRANTE;
                ret[1] = ConstantDataManager.QUARTO_QUADRANTE;
                break;
            case ConstantDataManager.QUARTO_QUADRANTE:
                ret[0] = ConstantDataManager.SEGUNDO_QUADRANTE;
                ret[1] = ConstantDataManager.TERCEIRO_QUADRANTE;
                break;
            default:
                ret[0] = 0;
                ret[1] = 0;
                break;
        }
        return ret;
    }

    public int proximaFigura(int figura) {
        int ret = 0;
        switch (figura) {
            case ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL:
                ret = ConstantDataManager.QUADRADO_INCLINADO;
                break;
            case ConstantDataManager.QUADRADO_INCLINADO:
                ret = ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA;
                break;
            case ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA:
                ret = ConstantDataManager.QUADRADO_HORIZONTAL;
                break;
            case ConstantDataManager.QUADRADO_HORIZONTAL:
                ret = ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL;
                break;
        }
        return ret;
    }

    /*Recebe os pontos inicial e final e preenche a figura na tabuleiro
     **/
    public void preencheFigura(Point pontoInicial, Point pontoFinal) {
        if (!getTabuleiro()[pontoInicial.x][pontoInicial.y].isOcupada()) {
            incrementaPasso();
            getTabuleiro()[pontoInicial.x][pontoInicial.y].setPasso(getContadorPassos());
            getTabuleiro()[pontoInicial.x][pontoInicial.y].setOcupada(true);

            if (pontoFinal(pontoInicial.x, pontoInicial.y)[0].x != pontoFinal.x &&
                    pontoFinal(pontoInicial.x, pontoInicial.y)[0].y != pontoFinal.y) {
                incrementaPasso();

                getTabuleiro()[pontoFinal(pontoInicial.x, pontoInicial.y)[0].x][pontoFinal(pontoInicial.x, pontoInicial.y)[0].y].setPasso(getContadorPassos());
                getTabuleiro()[pontoFinal(pontoInicial.x, pontoInicial.y)[0].x][pontoFinal(pontoInicial.x, pontoInicial.y)[0].y].setOcupada(true);

            } else {
                incrementaPasso();
                getTabuleiro()[pontoFinal(pontoInicial.x, pontoInicial.y)[1].x][pontoFinal(pontoInicial.x, pontoInicial.y)[1].y].setPasso(getContadorPassos());
                getTabuleiro()[pontoFinal(pontoInicial.x, pontoInicial.y)[1].x][pontoFinal(pontoInicial.x, pontoInicial.y)[1].y].setOcupada(true);
            }

            if (pontoFinal(pontoFinal.x, pontoFinal.y)[0].x != pontoInicial.x &&
                    pontoFinal(pontoFinal.x, pontoFinal.y)[0].y != pontoInicial.y) {
                incrementaPasso();
                getTabuleiro()[pontoFinal(pontoFinal.x, pontoFinal.y)[0].x][pontoFinal(pontoFinal.x, pontoFinal.y)[0].y].setPasso(getContadorPassos());
                getTabuleiro()[pontoFinal(pontoFinal.x, pontoFinal.y)[0].x][pontoFinal(pontoFinal.x, pontoFinal.y)[0].y].setOcupada(true);
            } else {
                incrementaPasso();
                getTabuleiro()[pontoFinal(pontoFinal.x, pontoFinal.y)[1].x][pontoFinal(pontoFinal.x, pontoFinal.y)[1].y].setPasso(getContadorPassos());
                getTabuleiro()[pontoFinal(pontoFinal.x, pontoFinal.y)[1].x][pontoFinal(pontoFinal.x, pontoFinal.y)[1].y].setOcupada(true);
            }

            incrementaPasso();
            getTabuleiro()[pontoFinal.x][pontoFinal.y].setPasso(getContadorPassos());
            getTabuleiro()[pontoFinal.x][pontoFinal.y].setOcupada(true);
        }
    }

    /*Verifica se a referida figura está totalmente preenchida do quadrante indicado
     **/
    public boolean temEstaFiguraNoQuadrante(int fgr, int quadrante) {
        boolean ret = false;
        int x = -1;
        int y = -1;
        switch (quadrante) {
            case ConstantDataManager.PRIMEIRO_QUADRANTE:
                x = 0;
                y = 0;
                break;
            case ConstantDataManager.SEGUNDO_QUADRANTE:
                x = 0;
                y = 4;
                break;
            case ConstantDataManager.TERCEIRO_QUADRANTE:
                x = 4;
                y = 0;
                break;
            case ConstantDataManager.QUARTO_QUADRANTE:
                x = 4;
                y = 4;
                break;
        }
        switch (fgr) {
            case ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL:
                ret = getTabuleiro()[0 + x][0 + y].isOcupada() &&
                        getTabuleiro()[1 + x][2 + y].isOcupada() &&
                        getTabuleiro()[2 + x][1 + y].isOcupada() &&
                        getTabuleiro()[3 + x][3 + y].isOcupada();
                break;
            case ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA:
                ret = getTabuleiro()[0 + x][3 + y].isOcupada() &&
                        getTabuleiro()[1 + x][1 + y].isOcupada() &&
                        getTabuleiro()[2 + x][2 + y].isOcupada() &&
                        getTabuleiro()[3 + x][0 + y].isOcupada();
                break;
            case ConstantDataManager.QUADRADO_HORIZONTAL:
                ret = getTabuleiro()[0 + x][1 + y].isOcupada() &&
                        getTabuleiro()[2 + x][0 + y].isOcupada() &&
                        getTabuleiro()[3 + x][2 + y].isOcupada() &&
                        getTabuleiro()[1 + x][3 + y].isOcupada();
                break;
            case ConstantDataManager.QUADRADO_INCLINADO:
                ret = getTabuleiro()[0 + x][2 + y].isOcupada() &&
                        getTabuleiro()[1 + x][0 + y].isOcupada() &&
                        getTabuleiro()[3 + x][1 + y].isOcupada() &&
                        getTabuleiro()[2 + x][3 + y].isOcupada();
                break;
        }
        System.out.println(quadrante + " " + fgr);
        return ret;
    }

    /*Verifica quantas figuras estão preenchidas em um quadrante
     **/
    public int quantasFigurasPreenchidasNesteQuadrante(int q) {
        int ret = 0;
        if (temEstaFiguraNoQuadrante(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL, q)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA, q)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(ConstantDataManager.QUADRADO_HORIZONTAL, q)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(ConstantDataManager.QUADRADO_INCLINADO, q)) {
            ret++;
        }
        return ret;
    }

    public int quantasVezesPreenchida(int figura) {
        int ret = 0;
        if (temEstaFiguraNoQuadrante(figura, ConstantDataManager.PRIMEIRO_QUADRANTE)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(figura, ConstantDataManager.SEGUNDO_QUADRANTE)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(figura, ConstantDataManager.TERCEIRO_QUADRANTE)) {
            ret++;
        }
        if (temEstaFiguraNoQuadrante(figura, ConstantDataManager.QUARTO_QUADRANTE)) {
            ret++;
        }
        return ret;
    }

    public void resetTabuleiro(int quadrante) {
        int x = -1;
        int y = -1;
        switch (quadrante) {
            case ConstantDataManager.PRIMEIRO_QUADRANTE:
                x = 0;
                y = 0;
                break;
            case ConstantDataManager.SEGUNDO_QUADRANTE:
                x = 0;
                y = 4;
                break;
            case ConstantDataManager.TERCEIRO_QUADRANTE:
                x = 4;
                y = 0;
                break;
            case ConstantDataManager.QUARTO_QUADRANTE:
                x = 4;
                y = 4;
                break;
        }
        // ---------------------------------------------------------------------
        getTabuleiro()[0 + x][0 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL);
        getTabuleiro()[1 + x][2 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL);
        getTabuleiro()[2 + x][1 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL);
        getTabuleiro()[3 + x][3 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_PRINCIPAL);

        getTabuleiro()[0 + x][0 + y].setQuadrante(quadrante);
        getTabuleiro()[1 + x][2 + y].setQuadrante(quadrante);
        getTabuleiro()[2 + x][1 + y].setQuadrante(quadrante);
        getTabuleiro()[3 + x][3 + y].setQuadrante(quadrante);

        getTabuleiro()[0 + x][0 + y].setOcupada(false);
        getTabuleiro()[1 + x][2 + y].setOcupada(false);
        getTabuleiro()[2 + x][1 + y].setOcupada(false);
        getTabuleiro()[3 + x][3 + y].setOcupada(false);
        // ---------------------------------------------------------------------
        getTabuleiro()[0 + x][3 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA);
        getTabuleiro()[1 + x][1 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA);
        getTabuleiro()[2 + x][2 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA);
        getTabuleiro()[3 + x][0 + y].setFigura(ConstantDataManager.TRIANGULO_DIAGONAL_SECUNDARIA);

        getTabuleiro()[0 + x][3 + y].setQuadrante(quadrante);
        getTabuleiro()[1 + x][1 + y].setQuadrante(quadrante);
        getTabuleiro()[2 + x][2 + y].setQuadrante(quadrante);
        getTabuleiro()[3 + x][0 + y].setQuadrante(quadrante);

        getTabuleiro()[0 + x][3 + y].setOcupada(false);
        getTabuleiro()[1 + x][1 + y].setOcupada(false);
        getTabuleiro()[2 + x][2 + y].setOcupada(false);
        getTabuleiro()[3 + x][0 + y].setOcupada(false);
        // ---------------------------------------------------------------------
        getTabuleiro()[0 + x][1 + y].setFigura(ConstantDataManager.QUADRADO_HORIZONTAL);
        getTabuleiro()[2 + x][0 + y].setFigura(ConstantDataManager.QUADRADO_HORIZONTAL);
        getTabuleiro()[3 + x][2 + y].setFigura(ConstantDataManager.QUADRADO_HORIZONTAL);
        getTabuleiro()[1 + x][3 + y].setFigura(ConstantDataManager.QUADRADO_HORIZONTAL);

        getTabuleiro()[0 + x][1 + y].setQuadrante(quadrante);
        getTabuleiro()[2 + x][0 + y].setQuadrante(quadrante);
        getTabuleiro()[3 + x][2 + y].setQuadrante(quadrante);
        getTabuleiro()[1 + x][3 + y].setQuadrante(quadrante);

        getTabuleiro()[0 + x][1 + y].setOcupada(false);
        getTabuleiro()[2 + x][0 + y].setOcupada(false);
        getTabuleiro()[3 + x][2 + y].setOcupada(false);
        getTabuleiro()[1 + x][3 + y].setOcupada(false);
        // ---------------------------------------------------------------------
        getTabuleiro()[0 + x][2 + y].setFigura(ConstantDataManager.QUADRADO_INCLINADO);
        getTabuleiro()[1 + x][0 + y].setFigura(ConstantDataManager.QUADRADO_INCLINADO);
        getTabuleiro()[3 + x][1 + y].setFigura(ConstantDataManager.QUADRADO_INCLINADO);
        getTabuleiro()[2 + x][3 + y].setFigura(ConstantDataManager.QUADRADO_INCLINADO);

        getTabuleiro()[0 + x][2 + y].setQuadrante(quadrante);
        getTabuleiro()[1 + x][0 + y].setQuadrante(quadrante);
        getTabuleiro()[3 + x][1 + y].setQuadrante(quadrante);
        getTabuleiro()[2 + x][3 + y].setQuadrante(quadrante);

        getTabuleiro()[0 + x][2 + y].setOcupada(false);
        getTabuleiro()[1 + x][0 + y].setOcupada(false);
        getTabuleiro()[3 + x][1 + y].setOcupada(false);
        getTabuleiro()[2 + x][3 + y].setOcupada(false);
    }

    /*Se todas as posições do tabuleiro já foram preenchidas
     **/
    public boolean terminouPreencher() {
        boolean ret = true;
        for (int linha = 0; linha < getTabuleiro().length; linha++) {
            for (int coluna = 0; coluna < getTabuleiro().length; coluna++) {
                if (!getTabuleiro()[linha][coluna].isOcupada()) {
                    ret = false;
                }
            }
        }
        return ret;
    }

    public void incrementaPasso() {
        setContadorPassos(getContadorPassos() + 1);
    }

    /**
     * @return the pontoInicial
     */
    public Point getPontoInicial() {
        return pontoInicial;
    }

    /**
     * @param pontoInicial the pontoInicial to set
     */
    public void setPontoInicial(Point pontoInicial) {
        this.pontoInicial = pontoInicial;
    }

    /**
     * @return the inicio
     */
    public boolean isInicio() {
        return inicio;
    }

    /**
     * @param inicio the inicio to set
     */
    public void setInicio(boolean inicio) {
        this.inicio = inicio;
    }

    /**
     * @return the possibilidades
     */
    private List getPossibilidades() {
        return possibilidades;
    }

    /**
     * @param possibilidades the possibilidades to set
     */
    private void setPossibilidades(List possibilidades) {
        this.possibilidades = possibilidades;
    }

    /**
     * @return the contadorPassos
     */
    public int getContadorPassos() {
        return contadorPassos;
    }

    /**
     * @param contadorPassos the contadorPassos to set
     */
    public void setContadorPassos(int contadorPassos) {
        this.contadorPassos = contadorPassos;
    }

    /**
     * @return the pontoFinal
     */
    public Point getPontoFinal() {
        return pontoFinal;
    }

    /**
     * @param pontoFinal the pontoFinal to set
     */
    public void setPontoFinal(Point pontoFinal) {
        this.pontoFinal = pontoFinal;
    }
}

// Classe constantDataManager

package passeiodocavalo;

/**
*
* @author jaison
*/

public class ConstantDataManager {
    public static final int PRIMEIRO_QUADRANTE = 1;
    public static final int SEGUNDO_QUADRANTE = 2;
    public static final int TERCEIRO_QUADRANTE = 3;
    public static final int QUARTO_QUADRANTE   = 4;
    public static final int TRIANGULO_DIAGONAL_PRINCIPAL = 5;
    public static final int TRIANGULO_DIAGONAL_SECUNDARIA = 6;
    public static final int QUADRADO_HORIZONTAL = 7;
    public static final int QUADRADO_INCLINADO = 8;
}

// classe Celula

package passeiodocavalo;

/**
*
* @author jaison
*/
public class Celula {
    private int figura;
    private int quadrante;
    private int passo = 0;
    private boolean ocupada = false;

    /**
     * @return the figura
     */
    public int getFigura() {
        return figura;
    }

    /**
     * @param figura the figura to set
     */
    public void setFigura(int figura) {
        this.figura = figura;
    }

    /**
     * @return the quadrante
     */
    public int getQuadrante() {
        return quadrante;
    }

    /**
     * @param quadrante the quadrante to set
     */
    public void setQuadrante(int quadrante) {
        this.quadrante = quadrante;
    }

    /**
     * @return the ocupada
     */
    public boolean isOcupada() {
        return ocupada;
    }

    /**
     * @param ocupada the ocupada to set
     */
    public void setOcupada(boolean ocupada) {
        this.ocupada = ocupada;
    }

    /**
     * @return the passo
     */
    public int getPasso() {
        return passo;
    }

    /**
     * @param passo the passo to set
     */
    public void setPasso(int passo) {
        this.passo = passo;
    }
}

// Classe Main

package passeiodocavalo;

import javax.swing.JFrame;

/**
*
* @author jaison
*/
public class Main extends JFrame{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        TelaTabuleiro frame=new TelaTabuleiro();
        frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Ergonomia e Usabilidade

2009-09-22T06:12:00.000-07:00

Sistemas ergonômicos possuem interfaces adaptadas a seus usuário e a forma como eles realizam suas tarefas. Interfaces com tais características oferecem usabilidade às pessoas que as utilizam, proporcionando interação eficas, eficiente e agradável. O retorno do investimento em usabilidade e ergonomia vem em forma de aumento de produtividade, redução do tempo de treinamento e da estrutura de suporte(CYBIS; BETIOL; FAUST, 2007).

Referências bibliográficas

CYBIS, Walter Abreu; BETIOL, Adriana Holtz; FAUST, Richard. Ergonomia e Usabilidade: Conhecimentos, Métodos e Aplicações. São Paulo: Novatec, 2007. 344 p.