SuperWaba

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Este artigo não cita fontes confiáveis e independentes (desde dezembro de 2013). Por favor, adicione referências e insira-as corretamente no texto ou no rodapé. Conteúdo sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)
SuperWaba
Paradigma Orientação a objeto, Imperativo, Genérico
Surgido em 2000
Criado por Guilherme Campos Hazan
Estilo de tipagem: Forte, Estática
Compiladores Warp e Exegen
Influenciada por Java, J2ME ,Waba
Influenciou TotalCross

SuperWaba é uma linguagem de programação utilizada para desenvolvimento de aplicações para aparelhos móveis como telefones celulares e aparelhos que comportam sistemas como PalmOS, Windows, Windows Mobile, WindowsCE e SymbianOS. O SuperWaba se baseia e estende o Waba. A linguagem do SuperWaba é um versão reduzida da definida em Java. Existe semelhança com o Java, também é usada uma máquina virtual cuja implementação é específica de cada aparelho onde é instalada. Diferentemente do Java, SuperWaba não suporta o modelo de sincronização e, como tal, não pode ser considerada verdadeiramente tecnologia Java. SuperWaba cumpre um papel semelhante à tecnologia J2ME. A diferença fundamental é sua maior integração nativa com os aparelhos moveis e um modelo de API mais pragmático que a API J2ME.

História[editar | editar código-fonte]

O SuperWaba começou no início de 2000, quando Guilherme Campos Hazan (Guich)percebeu que o Waba (linguagem, máquina virtual e SDK para PalmOS e Windows CE) era simples demais para criar uma aplicação financeira. Rapidamente ele começou a adicionar alguns métodos, classes, como também criou um teclado virtual para o Waba. Desejando compartilhar seu trabalho com o resto do mundo, ele criou o Waba 1.0G (G = Guich).

A intenção era que as mudanças feitas no 1.0G fossem repassadas para o Rick Wild (criador do Waba) incluir na distribuição padrão do Waba, mas isso nunca aconteceu.

Então, Guich continuou aperfeiçoando o Waba 1.0G, e na próxima versão o nome foi mudado para SuperWaba. Uma das mais importantes mudanças no SuperWaba 1.1 e 1.2 foi o suporte para janelas popup. Na versão 1.2 Dave Slaughter portou a versão PalmOS do SuperWaba para o WindowsCE. Até este ponto, o SuperWaba era apenas uma outra versão do Waba com exceção de algumas classes e métodos nativos aperfeiçoados.

O real desafio surgiu no início de 2001: adicionar suporte para tons de cinza (pois Waba só possuía supor te a dois tons de cores: preto e branco) em todos os dispositivos com PalmOS, iniciando com PalmProfessional e PalmOS 2.0. Mas para colocar suporte à tons de cinza, Guich teve que criar algumas funções do assembly 68k (a Palm não tinha lançado supor te a tons de cinza até a versão PalmOS 3.5). O suporte para cores também foi adicionado rapidamente no SuperWaba. Após centenas de otimizações de alto nível, o SuperWaba ficou agora 2x mais rápido do que o Waba. A partir de outubro de 2001 Guich deixou seu antigo emprego para dedicar seu tempo para construir um SuperWaba cada vez melhor. Renato Rocha Ribeiro também entrou no time para ajudar na estrutura de negócios do SuperWaba. No início de 2003, Marcos Guirland Nosowad entrou no time para produzir produtos de alta qualidade e aperfeiçoamentos voltados para a plataforma SuperWaba. Em setembro de 2003, Pierre G. Richard, também se juntou ao time. Marcos e Pierre irão brevemente oferecer serviços de consultoria, treinamento e suporte nos USA e na França, respectivamente. O próprio Guilherme oferece esses mesmos serviços aqui no Brasil.

Características[editar | editar código-fonte]

O SuperWaba é uma plataforma que possui uma implementação própria de linguagem (com sintaxe semelhante ao Java), máquina virtual, formato de arquivos de classes e um conjunto de classes. Além disso, ele permite o uso de ferramentas Java no desenvolvimento.

Dentre as diversas características, podemos notar o suporte para SQL, leitor de código de barras, protocolo GPS, protocolo HTTP, tratamento de imagens JPEG, PNG, GIF e PNG, e suporte para compressão de dados.

Podemos comparar o SuperWaba ao .NET Compact Framework em recursos (exceto linguagem), porém o SuperWaba é ainda mais portável, rodando em várias plataformas como comentado na seção anterior.

Somente podemos compará-lo com o J2ME em termos de sintaxe da linguagem utilizada, pois enquanto o J2ME usa a linguagem Java o SuperWaba possui uma linguagem de sintaxe similar ao Java, porém não podemos comparar os dois em termos de recursos e portabilidade, pois o SuperWaba roda em dispositivos em que o J2ME não possui máquina virtual, sem considerar que o SuperWaba possui muito mais recursos que o J2ME.

Programação[editar | editar código-fonte]

O SuperWaba estende uma linguagem parecida com o Java, porém, com vários recursos reduzidos devido ao processamento limitado dos dispositivos moveis, existem alguns pontos a serem destacados:

  • As classes do SuperWaba estão contidas no pacote waba, embora a maioria possua o mesmo nome que as classes java, são implementadas de forma diferenciada.
  • Embora o SuperWaba seja semelhante ao Java, o compilador não aceita classes Java, ocorrendo um erro no processo de compilação.
  • Os tipos de variáveis do SuperWaba são iguais aos tipos do Java, todos ocupam mesmo espaço de memória e são caracterizados iguais.
  • Uma exceção muito crítica em comparação ao Java, é a variável String, que não são aceitos alguns métodos como o "split".
  • As maiores reduções encontradas em comparação ao java é em questão ao pacote "útil" do Java, onde no SuperWaba a única collections existente é o "Vector" não existindo List, Map, Set e outras.

Ferramentas[editar | editar código-fonte]

IDE - Eclipse (IDE)

Plugins de IDE - SuperWaba Kit

Compiladores - Warp e Exegen

Compiladores[editar | editar código-fonte]

O ponto crucial do SuperWaba é a compilação, feita pelo Warp que gera o arquivo .pdb responsável por conter o código do programa, e o Exegen que gera os arquivos de execução de acordo com a plataforma.

Existe uma maquina virtual para cada plataforma (PalmOS, WindowsCE, etc..), tendo que utilizar os arquivos compilados de acordo com tal maquina virtual.

O processo de compilação ocorre sob um arquivo JAR que é gerado pela interpretação de um arquivo XML que contem as informações necessárias para o procedimento:

<!--  ****** GENERATED BY SUPERWABA-IDE - DO NOT MODIFY!!! ******
  -->
- <project name="RegisterSum" basedir="." default="all">
- <!--  Application classpath
  -->
- <path id="classpath">
  <pathelement location="G:\Projetos\Java\SuperWabaSDKPro/lib/SuperWaba.jar" />
  <pathelement location="\RegisterSum\lib\comm.jar" />
</path>
- <!--  Warp/Exegen classpath
  -->
- <path id="utils">
  <pathelement path="G:\Projetos\Java\SuperWabaSDKPro/utils" />
  <pathelement location="G:\Projetos\Java\SuperWabaSDKPro/lib/SuperWaba.jar" />
</path>
- <!--  Clean directories and files
  -->
- <target name="clean">
  <delete dir="build" />
  <delete dir="dist" />
</target>
- <!--  Compile
  -->
- <target name="build" depends="clean">
  <mkdir dir="build" />
  <mkdir dir="dist" />
- <javac srcdir="G:\Projetos\Java\ProjetosCurrent\RegisterSum\src" destdir="build" target="1.1">
  <include name="**/*.java" />
  <classpath refid="classpath" />
</javac>
- <copy todir="build">
- <fileset dir="G:\Projetos\Java\ProjetosCurrent\RegisterSum\src">
  <exclude name="**/*.java" />
</fileset>
</copy>
</target>
- <!--  Package classes
  -->
- <target name="jar" depends="build">
- <jar jarfile="build/${ant.project.name}.jar">
  <fileset dir="build" includes="**/*.class" />
</jar>
</target>
- <!--  Execute WARP
  -->
- <target name="warp" depends="jar">
- <java dir="build" classname="Warp" fork="true" classpathref="utils">
  <arg value="c" />
  <arg value="/c" />
  <arg value="2345" />
  <arg value="${ant.project.name}" />
  <arg value="${ant.project.name}.jar" />
</java>
</target>
- <!--  Prepare EXEGEN execution
  -->
- <target name="prepare-exegen">
  <mkdir dir="icons" />
- <copy todir="build">
- <fileset dir="icons">
  <include name="*.bmp" />
</fileset>
</copy>
</target>
- <!--  Execute EXEGEN
  -->
- <target name="exegen" depends="warp, prepare-exegen">
- <java dir="build" classname="Exegen" fork="true" classpathref="utils">
  <arg value="/c" />
  <arg value="2345" />
  <arg value="/i" />
  <arg value="ooo" />
  <arg value="${ant.project.name}" />
  <arg value="br.com.cas.janela.RegisterSumMain" />
  <arg value="${ant.project.name}" />
</java>
</target>
- <!--  Execute EXEGEN with WinCE EXE
  -->
- <target name="exegen-exe" depends="warp, prepare-exegen">
- <java dir="build" classname="Exegen" fork="true" classpathref="utils">
  <arg value="/c" />
  <arg value="2345" />
  <arg value="/i" />
  <arg value="ooo" />
  <arg value="/e" />
  <arg value="${ant.project.name}" />
  <arg value="br.com.cas.janela.RegisterSumMain" />
  <arg value="${ant.project.name}" />
</java>
</target>
- <!--  Execute EXEGEN with WinCE CAB
  -->
- <target name="exegen-cab" depends="warp, prepare-exegen">
- <java dir="build" classname="Exegen" fork="true" classpathref="utils">
  <arg value="/c" />
  <arg value="2345" />
  <arg value="/i" />
  <arg value="ooo" />
  <arg value="/z" />
  <arg value="${ant.project.name}" />
  <arg value="br.com.cas.janela.RegisterSumMain" />
  <arg value="${ant.project.name}" />
</java>
</target>
- <!--  Execute WARP and populate distribution directory
  -->
- <target name="all-warp" depends="warp">
  <move file="build/${ant.project.name}.pdb" todir="dist" />
</target>
- <!--  Execute EXEGEN and populate distribution directory
  -->
- <target name="all-exegen" depends="exegen, all-warp">
  <move todir="dist" file="build/${ant.project.name}.prc" />
</target>
- <!--  Execute EXEGEN with WinCE EXE and populate distribution directory
  -->
- <target name="all-exegen-exe" depends="exegen-exe, all-warp">
- <move todir="dist">
- <fileset dir="build">
  <include name="${ant.project.name}.prc" />
  <include name="**/*.exe" />
</fileset>
</move>
</target>
- <!--  Execute EXEGEN with WinCE CAB and populate distribution directory
  -->
- <target name="all-exegen-cab" depends="exegen-cab, all-warp">
- <move todir="dist">
- <fileset dir="build">
  <include name="${ant.project.name}.prc" />
  <include name="*.CAB" />
  <include name="*.ini" />
  <include name="*.bat" />
</fileset>
</move>
</target>
  <target name="all" depends="all-exegen-cab" />
</project>

Existem dois procedimentos a serem tomados para compilação:

//Dentro do shell digite:

//Primeiro procedimento:
Warp c NomeDoPDB  NomeDoJAR

//Segundo procedimento:
Exegen /e NomeDoExecutavel ClassePrincipal(main) NomeDoPdb

Desta forma ocorrerá a compilação para todos os tipos de maquinas virtuais possíveis.

Exemplo de Sintaxe[editar | editar código-fonte]

No SuperWaba não existe uma diferença muito grande em comparação ao java, a maior diferenção é a localização das classes para o pacote "waba", porém existem suas particularidades em questão da montagem de um sistema visual, abaixo está o modelo basico:


import waba.ui.Container;
import waba.ui.ControlEvent;
import waba.ui.Event;
import waba.ui.Window;

public class NomeDaClassePrincipal extends waba.ui.MainWindow{
        
        // DECLARAÇÃO DE VARIAVEIS      
        public final static String versao = "v1.0.0.0";
        private int numero;
        
        // CONSTRUTOR                   
        public RegisterSumMain(){
                super("NOMDE DO APLICATIVO NA JANELA", Window.TAB_ONLY_BORDER);
                waba.sys.Settings.setUIStyle(waba.sys.Settings.WinCE);

        }
        
        // METODO DE START, ONDE CRIA TODOS OS COMPONENTES E OS APRESENTA VISUALMENTE
        public void onStart(){
                super.onStart();
                
        }
        
        // METODO DE FLUXO DE EVENTOS
        public void onEvent(Event event){
                switch(event.type){
                        case ControlEvent.PRESSED:{
                        
                                if (event.target == NOME DO COMPONENTE DO EVENTO) {
                                }
                           }    
                  }
         }
    }
}

Exemplos de Codigos[editar | editar código-fonte]

Hello World[editar | editar código-fonte]


import waba.ui.Label;
import waba.ui.MainWindow;
import waba.ui.Window;

public class Teste extends MainWindow{
        private Label label;
        
        public Teste(){
                super("Hello World", Window.TAB_ONLY_BORDER);
                waba.sys.Settings.setUIStyle(waba.sys.Settings.WinCE);
        }
        
        public void onStart(){
                super.onStart();
                
                this.label = new Label("Hello World!!");
                add(this.label,CENTER,CENTER);
        }               
}

N PRIMEIROS NUMEROS PERFEITOS[editar | editar código-fonte]


import waba.ui.Label;
import waba.ui.MainWindow;
import waba.ui.Window;
import waba.util.Vector;

public class Teste extends MainWindow{
        private Label label;
        private String resultado;
        
        public Teste(){
                super("N Perfeitos", Window.TAB_ONLY_BORDER);
                waba.sys.Settings.setUIStyle(waba.sys.Settings.WinCE);
                
                this.resultado = this.nPerfeitos();
        }
        
        public void onStart(){
                super.onStart();
                
                this.label = new Label("Resultado: "+resultado);
                add(this.label,CENTER,CENTER);
        }       
        
        private String nPerfeitos(){
                int num=0, soma, cont=0, n=4;
                String result = "";
                
                do{
                        num++;
                        soma = 0;
                        for (int i = 1; i <= num-1; i++) {
                                if(num%i == 0)soma += i;
                        }
                        if(soma == num){
                                result += " "+soma;
                                cont++;
                        }
            }while(cont != n);
                return result;
        }
                
}

Referencias Externas[editar | editar código-fonte]