Minicurso de TotalCross e Litebase

Mini-curso
TotalCross

Desenvolvimento de Aplicativos
para Dispositivos Móveis

Prof. Nécio de Lima Veras

Agenda
 Parte 1 (Introdução)
– A computação móvel;
– Tecnologias;
– O TotalCross (A plataforma);
– Visão Geral (GUI);
 Parte 2 (Desenvolvendo)
– Interface Gráfica com o Usuário;
– Classes Utilitárias;
 Parte 3 (Persistência de Dados)
– Litebase;

Parte I: Introdução

A Computação Móvel
Tecnologias
TotalCross
Noções de GUI

Computação
Móvel
• Tema bastante abrangente;
• Pode representar um novo paradigma:
– Mais acesso a serviços sem fronteiras físicas (localização);
– “Acesso à Informação em qualquer lugar e a qualquer
momento”;
• Dispositivos:
– Laptop e Palmtop;
– PDA's;
– Celulares;
• Infra-estrutura:
– Redes Internas;
– Redes Externas;
– Redes Ad-hoc;

Computação
Móvel
• Principais problemas:
– Erros em Transmissões Sem Fio;
– Energia;
– Interface com os dispositivos;
– Capacidade dos dispositivos;
– Segurança;
– Necessidades de adaptações p/ o
desenvolvedor;

Computação
Móvel
• Aplicações e Serviços:
– Pessoais;
– Corporativas;
– Financeiras;
– Ciências Médicas;
– Policiamento e Segurança;
– Militares;
– Informações em Geral;
– Entretenimento;
– Comércio Eletrônico Móvel (M-Commerce);
– Serviços baseados em localização;
Fonte: T&C Amazônia, ano 1, núm 2 (2003).

Exemplos de Personal Digital
Assistant

Sobre os PDA’s
 Família:  Empresas que adotam:
 Palm OS;  CELEPAR
 Pocket PC;  Distribuidores:
 SmartPhone; • SKOL, BRAHMA,
SCHIN e COCA-
 Pocket Linux;
COLA;
 Restaurantes
diversos (HABIBS);
 Clubes de Futebol;
 IBOPE;
 IBGE;

Tecnologias
 JME;
 Embedded Visual C++; (IDE p/ PocketPC);
 .NET;
 CodeWarrior;
 NSBasic;
 PocketStudio;
 HB++;
 Android;
 SuperWaba => TotalCross;

O TotalCross
(A plataforma)

1. Visão Geral (características, vantagens competitivas e
características técnicas);
2. O SDK;
3. Compilando, distribuindo e instalando suas aplicações;
4. Instalando e configurando a ferramenta Eclipse;

Visão Geral
 O que é TotalCross? (Um pouco de história)

É uma plataforma para desenvolvimento de
aplicações para PDAs e smartphones.
 Usa o conceito “write once run anywhere”;
 Substitui o SuperWaba;
• MV totalmente NOVA;
• P/ migração: SW2TC;

Visão Geral
 Códigos Java (com SDK próprio);
 Plataformas suportadas:
 iPhone (1.1.4);
 BlackBerry (4.3.0);
 Palm OS (5, 3 e 4 – sem suporte a multithread);
 Windows CE (3.0, .NET, Windows Mobile 5 e 6):
• Pocket PC (ARM, SH3 e MIPS);
• PPC ARM;
• HPC 2000 ARM;
 Windows 2000;
 Linux;
 Navegadores (Java applets – JDK 1.1 ou superior);

Visão Geral
 Características da Máquina Virtual:
 Possui seus próprios bytecodes (proprietário);
 Suas classes são otimizadas para economizar espaços (ex: os pool’s são
compartilhados entre todas as classes distribuídas);
• As classes são comprimidas usando o zlib;
 Possui suporte a aplicações headless (basta estender a interface
totalcross.MainClass);
 Possui manipulação especial de arrays (verificações de looping);
 Novos recursos para o GC (dontFinalize);
 Inconvenientes:
 Não suporta float, apenas double (limitação de não possuir um co-processador
matemático);
 Quer dizer que não posso usar variáveis do tipo float?
• Sim, pode, pois o compilador irá traduzir;

Visão Geral
 Suporte a Threads:
 Possui suporte nativo à preempção;
 Não suporta, por enquanto, concorrência e nem sincronização;
• Porém, é possível “escutar” um socket, ou um arquivo, ou ainda,
percorrer uma tabela em background;
 Usar threads para interface gráfica, por enquanto, é inseguro e
não recomendado;
 É utilizado principalmente para I/O;

 Gráficos, Paleta e Cores:
 As imagens são armazenadas em 24 bits (RGB);
 Possui suporte à rotação de telas;
 As cores são representadas pelo formato: 0xRRGGBB (null =
-1);

Visão Geral
 Mais Recursos:

– Gráficos de Linha e Barra;
– Gerenciamento de conexões;
– Manipulação de Câmera (windows mobile);
– Fontes de tamanho ilimitado (com anti-aliasing);
– Suporte à rotação de telas;
 Segurança:
 Decompilação impossível;
 Faça Backups, pois também não é possível decompilar uma
aplicação distribuída;
 Suporte a SSL;
 Algoritmos nativos de criptografia;

Especificações Técnicas
 Recursos básicos:

– Qualquer IDE Java;
– Depuração com Applet;
– Rica em GUI;

● Recursos avançados:
● Suporte à UNICODE;
● GPS;
● XML;
● Captura de Vídeo, Fotos e Voz;
● Desenvolvimento de Jogos;
● Suporte à leitor de código de barras;
● Biblioteca Zlib;
● Suporte à múltiplos formatos de imagens: BMP, JPEG, PNG e GIF;
● Suporte a HTML;

 Manipulação de dados:
 Classe File para manipulação de arquivos (cartões SD e MMC);
 Classe PDBFile para manipulação de arquivos PDB (Palm
Database) em todas as plataformas alvo;
 SGDB c/ Litebase;

 Conectividade:
 Suporte a Socket para TCP/IP, IR, Porta Serial, USB e
Bluetooth;
 Possui ServerSocket;
 Suporte aos protocolos: SMS, HTTPS, FTP e SMTP;
 Discagem de números;
 WebServices;

 Requisitos Mínimos:
 O Kit de Desenvolvimento TotalCross (SDK) pode ser instalado em Windows 98/
ME/NT/2000/XP, Linux e Mac OS-X.
 Pentium II ou equivalente com 128Mb de memória disponível.
 Mínimo de 200 Mb livres em disco .
 JDK 1.6 ou superior (utilizado durante o empacotamento da aplicação).
 Imagens:

O SDK
 Licença do SDK: LGPL V 3.0;
 Licença da VM: Versão DEMO;
 80 horas ininterruptas;
 Esse tempo é atualizado a cada 5s;
 É possível reiniciar esse tempo com um Hard
Reset;
 E no Windows?

O SDK
 Estrutura de diretórios:
 Dist (classes base e ferramentas de deploy)
+ samples (exemplos)
+ vm (máquinas virtuais)
+ docs (documentação)
+ etc (imagens, launchers, arquivos de
assinaturas, tools)
+ src (fontes dos exemplos)

Processos de compilação, distribuição
e instalação (introdução)
 O desenvolvimento é idêntico ao de Java;

 Porém existem diferenças e cuidados:
 Superclasse (MainWindow) ou a interface MainClass;
 Execução: a Classe Launcher;
 Por conveniência, existe o pacote totalcross.lang (ex.:
String e Object). Cuidado com as classes Wrapper;
 O TC é apenas compatível com o formato de
arquivos de classe Java 1.1, por tanto, o JDK 1.1 ou
1.2;
• Linha de comando: “-target 1.1 –source 1.2”;
• Para as IDE’s Java deve-se usar o level de 1.3;

e instalação
 Criando uma primeira aplicação, o “Hello World”:
 1º. Passo: Instalar o SDK do Java;
 2º. Passo: Instalar o SDK do TC;
 3º. Passo: Configurar o classpath [opcional] p/ o Java e TC;
 4º. Passo: Implementar!

package br.sinfo.necio.demos;

import totalcross.ui.*;

public class FirstHello extends MainWindow {

public void initUI(){
add (new Label("Hello World!"),0,0);
}
}

e instalação
 Compilação em linha de comando:
javac -target 1.1 -source 1.2 FirstHello.java

 Lembre-se, caso você NÃO configure o
CLASSPATH, ficaria assim:

javac -classpath
/opt/totalcrossSDK/dist/tc.jar -target 1.1
-source 1.2 FirstHello.java

e instalação
 Para executar uma aplicação em TC, use
como ponto de partida a classe Launcher;
java -classpath .;%CLASSPATH%
totalcross.Launcher FirstHello
 Resultado:

A Classe Launcher
 É uma aplicação JAVA;
 Formato básico:
totalcross.Launcher [optional arguments] <main class>
 Argumentos:
 Resolução de Tela (/scr);
 Definição de cores (/bpp);
 Estilo de interface com o usuário (/uiStyle);
 Características de dispositivos:
• /penlessDevice;
• /keypadOnly;

e instalação
 O TC facilita o processo de distribuição, através da
classe tc.Deploy:

java tc.Deploy FirstHello –all

 Lembre-se do CLASSPATH !

 O argumento “-all” define os tipos de distribuição, que
podem ser:
 palm ou –palmos;
 ce ou –wince;
 win32;
 bb ou blackberry;
 applet ou html;

e instalação
 O tc.Deploy criará para tipo de distribuição
uma pasta chamada install contendo:
 Os instaladores;
 Os executáveis (se for o caso);
 As bibliotecas necessárias;
 Exemplo do Windows:
 Tamanho padrão de tela: 240x320;
 Personalização: /scr x,y,width, heidht;

Opções da classe Deploy passadas
através do construtor de MainWindow

Opção Valor padrão Código Resultado

Opções da classe Deploy
passadas através do construtor
Opção Valor padrão Código Resultado

Instalando e configurando
a ferramenta Eclipse
 Podemos fazer isso
em qualquer
versão do eclipse;
 Vamos lá:
 Inicie um projeto
Java normal;
 Feito isso, vá nas
propriedades do
projeto, na aba
Libraries e
adicione uma
“Library”:

 Adicione uma “User
Library” (nome
sugerido: TCLibrary);
 Depois, adicione um
Jar (“Add JARs”);
 Você deve adicionar o
arquivo tc.jar (pasta
dist do
TOTALCROSS_HOM
E;
 Depois, configure o
Source e o JavaDoc;
 Feito isso, deve ficar
assim:

 A aplicação deve
ficar com DUAS
bibliotecas:
 JRE do Java;
 TCLibrary;
 Não esqueça de
também configurar
o compilador com o
nível 1.3;

 Agora, vamos testar:
 Crieuma classe Hello.java (conforme
vimos antes);
• Não esqueça de que a sua superclasse é a
MainWindow;
 Personalizaremos uma configuração no
“Run Dialog”, com:
• A classe mãe;
• Argumentos;

 Se o resultado
deve ser este =>
 Parabéns!
 Agora, estamos
com tudo pronto
para iniciar o
desenvolvimento
de aplicações!

Visão Geral
Interface Gráfica
(GUI)

Controles
(Estrutura da classe MainWindow)

 Método initUI();
 Método onExit();
 Informações Importantes:
O método initUI é abstrato de um Container;
• Deve-se inicializar TODAS as UI’s nele;
O método onExit apenas é chamado em
circunstâncias normais de saída;
• Qualquer saída anormal, o método NÃO é chamado;
 Para alterar títulos e estilos é aconselhável chamá-lo
no construtor da classe MainWindow (super);

Adicionando Controles
 Os controles apenas podem ser
adicionados em Containers e suas
subclasses (como a MainWindow);
 Para criar o espaço de visualização do
controle existe o método:
setRect (x, y, width, height)
 Exemplo: setRect(10,10,40,20);

Métodos relacionados ao
posicionamento e adição de controles
 setRect:
 (x, y, width, height);
 (Rect r);
 (x, y, width, height, Control relative);
 add:
 (Control, x, y);
 (Control, x, y, Control relative);
 (Control, x, y, width, height);
 (Control, x, y, width, height, Control relative);

Um pouco de Prática
 Adicione Label’s para mostrar as
coordenadas de direções:
 Norte, Sul, Leste, Oeste, Nordeste, Noroeste,
Sudeste, Sudoeste e CENTRO;
 O comando para adicionar um label, pode
ser:
 add(new Label(“N”),60,0, 12, 12);
 Ao final deve ficar assim:

Reflexão sobre o exercício

 Agora, com o exercício pronto, faça:
 Tente aumentar o tamanho da tela;
 Algo deu errado?

 JAMAIS devermos definir posição com
valores exatos!
E agora?

Solução:
Coordenadas relativas
 Para a coordenada X:
 LEFT: O controle é posicionado na posição 0
horizontal;
 RIGHT: Alinha o controle à direita;
 CENTER: Alinha no centro horizontal do
Container;
 BEFORE: Coloca o controle ANTES do último
controle adicionado;
 AFTER: Coloca o controle DEPOIS do último
 SAME: Coloca o controle na MESMA
coordenada X do último controle adicionado;

 Para a coordenada Y:
 TOP: Coloca o controle na posição 0 vertical;
 BOTTOM: Coloca o controle na base do
Container;
 CENTER: centraliza verticalmente o controle no
Container;
 BEFORE: Coloca o controle ANTES do último
 AFTER: Coloca o controle DEPOIS do último
 SAME: Coloca o controle na MESMA coordenada
Y do último controle adicionado;

 Largura:
 PREFERRED: o controle é ajustado conforme sua
MELHOR largura;
• É usado, normalmente, para controles de textos;
 FILL:o controle usará TODO o espaço disponível
da esquerda até o final do Container;
• NÃO pode ser usado em conjunto com RIGHT/
CENTER;
 SAME: o controle será adicionado com a mesma
largura do último adicionado;
 FIT: o controle será posicionado entre uma posição
específica em X e último controle adicionado;

 Altura:
 PREFERRED: o controle será desenhado
com a melhor altura possível;
 FILL: o controle será posicionado da
esquerda até o final do Container;
• Não pode ser usando em conjunto com BOTTOM/
CENTER;
 SAME: o controle usará a mesma altura do
último controle adicionado;
 FIT: o controle será posicionado entre uma
posição específica em Y e último controle
adicionado;

 Observações:
 Antesde chamar o setRect de um controle,
você deve, preferencialmente, adicioná-lo ao
Container;
O controle de coordenadas sempre é
relativo à coordenada do controle PAI;
Não se usa FIT com largura e altura ao
mesmo tempo;
Podemos usar refinamentos nas
coordenadas relativas, mas sem
EXAGERO;
• Use no máximo variações entre -5 e +5;
• Não é sugerido usar valores acima de 5;

Praticando...

 Que tal refazer o exercício anterior,
agora da maneira correta?

Eventos

 Representam todas as atividades
entre o usuário e a aplicação;

 Quando um usuário interage com o
programa, a VM cria um evento
representando a ação e
comunicação;

A Classe Event
 O TC possui 4 classes para manipulação
de eventos:
 ControlEvent;
 PenEvent;
 KeyEvent;
 Event (classe Pai);
 Membros da classe Event:
 type (código do evento passado);
 target (originador do evento);

Exemplo
package br.sinfo.necio.demos;
import totalcross.ui.Label;
import totalcross.ui.MainWindow;
import totalcross.ui.event.Event;
import totalcross.ui.event.KeyEvent;
public class PenEvent extends MainWindow {
Label l;
public void initUI(){
add (l = new Label("Pressione uma tecla!"), CENTER, CENTER,
PREFERRED, PREFERRED);
}
public void onEvent(Event e){
if (e.type == KeyEvent.KEY_PRESS){
l.setText("Obrigado pela tecla pressionada!");
l.setRect(CENTER, CENTER, PREFERRED, PREFERRED);
}
}
}

Tipos mais comuns de eventos
manipulados pelo ControlEvent

 PRESSED: é chamado quando acontece
um PEN_DOWN, PEN_UP ou um
WINDOW_CLOSED;
 FOCUS_IN e FOCUS_OUT;
 TIMER: evento especial;
 WINDOW_CLOSED: para alguns
elementos, o evento PRESSED é
chamado;

Parte II: Desenvolvimento
de Aplicações Gráficas

G.U.I.
Classes Utilitárias

Interface Gráfica com o Usuário:
Controles Básico
● Estão embutidos no pacote: totalcross.ui;
● São eles:
● Button; Edit;Label; Check; Radio;
RadioGroupControler; ComboBox; ListBox; MultiEdit;
Grid e ToolTip;
● Podemos manipular:
● Cores (foregound/backgroup);
● Estados (enabled/disabled);
● Lembre-se de que as características dos controles
devem ser setadas ANTES do de seu desenho
(setRect);

Controle básico: Button
● Suporta textos multi-linhas e imagens
misturados;
● Possui 4 estilos de borda:
● BORDER_NONE;
● NORDER_SIMPLE;
● BORDER_3D;
● BORDER_3D_GRADIENT;
● O método setImage NÃO redimensiona o
botão;

Controle básico: Button
● Possui um campo estático
commonGap;

● Possui o método
setPressedColor;

● A cor de fundo de um
botão com bordas 3D
gradiente, sempre será
AZUL;

● Exercício: crie um exemplo
conforme a imagem:

Controle básico: Edit
● Trabalha com textos oriundos do teclado ou da área de escrita
manual (grafitti);
● Permite selecionar o texto e: copiar, cortar e colar;
● Possui dois construtores: com (máscara) e sem argumentos;
● Possui os métodos:
● setMaxLength;
● setValidChars;
● setMode (NORMAL, DATE, CURRENCY, PASSWORD,
PASSWORD_ALL);
● setEditable;
● setDecimalPlace;

Controle básico: Edit
● Possui os membros:
● overwrite (escrita
com INSERT ligado);
● autoSelect (ao
receber o foco);
● Exercício: Implemente
o exemplo da figura:

Controle básico: Label
● Texto estático;
● Pode possuir múltiplas linhas, separadas
pelo caractere ‘n’;
● Possui três construtores:
● Sem parâmetro;
● Com String texto;
● Com String texto e int align;
● O texto é automaticamente ajustado;

● Possui os métodos:
● set3d;
● setInvert;
● setText;
● Como ele é multi-linha, as barras de
rolagem podem ser ativadas:
● scroll(boolean);

 Prática:
 Crie um exemplo que mostre labels (em
linhas separadas) com as seguintes
características:
1. Simples alinhado à esquerda;
2. Simples centralizado;
3. 3d;
4. Invertido;
5. Com várias linhas.

Controle básico: Check
 Serve como uma caixa de checagem;
 O texto é alinhado à direita, caso não
queira isso atribua true ao campo
leftJustify;
 Possui os métodos:
 isChecked;
 setChecked;
 setText;

Controle básico: Radio e
RadioGroupControler
● O Radio permite escolher alternativas pré-
definidas;
● As opções podem ser agrupadas usando o
RadioGroupControler;
● O Radio possui 2 construtores:
● Recebendo uma String;
● Recebendo uma String e um Controlador;
● O RadioGroupControler NÃO é um controle então
NÃO pode ser adicionar a um Container;

Controle básico: Radio e
RadioGroupControler
● No RGC podemos:
● Verificar o índice do Radio selecionado
(getSelectedIndex);
● Selecionar um Radio pelo índice (setSelectedIndex);
● Os índices são baseados na ordem como são
inseridos;

Prática
● Exemplifique o uso destes componentes criando um
tipo de grupo com pelo menos 2 radios, conforme a
figura;

Controle básico: ComboBox
● Controle útil quando se precisar
selecionar um item em um conjunto de
itens;
● Possui 4 construtores, mas apenas 3 são
relevantes:
● Um vazio;
● Recebendo um ListBox;
● Outro recebendo um array de Objects;

● Atributos:
● fullHeight - boolean;
● fullWidth - boolean;
● Métodos:
● setBackgroudColor();
● add possui três variantes:
– add(Object item);
– add(Object[] items); - prefira este ao invés de muitas
chamadas ao anterior
– add(Object[] items, int startAt, int size);
● insert (Object, int index);
● setItemAt (int i, Object o);
● getItemAt (int i) ou indexOf(Object name);
● size();

● Métodos: ● Exemplo:
● getSelectedItem();
● getSelectedIndex();
● setSelectIndex(int i);
● setSelectedItem (Object
name);
● selectLast();
● Para remover um item,
temos 3 opções:
– remove(int itemIndex);
– remove(Object item);
– removeAll();
● qsort();
● enableHorizontalScroll();

Controle Básico: ListBox
● Permite selecionar um item de uma lista de
múltiplas linhas;
● Não é possível selecionar múltiplos itens;
● Possui 2 construtores:
● Um vazio;
● O outro recebendo Object[];
● Podemos adicionar itens pelo método add:
● add(Object item);
● add(Object[] moreItems); - prefira este ao invés de
muitas chamadas ao anterior;
● add(Object[] moreItems, int startAt, int size);

● Métodos:
● insert (Object item, int index);
● setItemAt (int i, Object o);
● size();
● getItemAt(int i); ou indexOf(Object name);
● getSelectedIndex() ou getSelectedItem();
● setSelectedIndex(int i) ou setSelectedItem(Object
name);
● selectLast();

● Métodos de remoção: ● Exemplo:
● remove(int
itemIndex);
● remove(Object item);
● removeAll();
● Ordenação: qsort();
● Mais métodos:
● enableHorizontalScro
ll();
● setSimpleBorder(bool
ean);

Controle Básico: MultiEdit
● É basicamente, um Edit que suporta múltiplas
linhas;
● Construtores:
● MultiEdit(int rowCount, int spaceBetweenLines);
● MultiEdit(String mask, int rowCount, int
spaceBetweenLines);
● Possui uma vertical scrollbar, mas isso é preciso
ser habilitado;
● setScrollbarsAlwaysVisible(boolean asNeeded);

Controle Básico: MultiEdit
● Métodos:
● getNumberOfTextLine
s();
● Manipulação de
scrollbars:
– scrollToBottom();
– scrollToLine(int line);
– scrollToTop();
● Exemplo:

Controle básico: Grid
● Controle usado para mostrar tabulação de dados
com uma matriz de String;
● Opcionalmente é possível adicionar colunas extras
com com um checkBox ao lado esquerdo do Grid;
● Funcionalidades:
● Barras de rolagem horizontal e vertical com ajuste
automático ao tamanho da tela;
● Fácil interface para o usuário adicionar ou remover
informações no próprio Grid;
● Coluna opcional de checagem (para selecionar mais
de um linha);

● As colunas podem ser redimensionadas pelo
usuário;
● Estilos de cores personalizáveis;
● Gera eventos (contido na classe GridEvent);
● A coluna pode ser editável ou não;
● Ordenação da coluna com um click no título;
● Se o texto for maior que o tamanho da célula,
poderá ser clicado e aparecerá um tooltip com o
texto completo;
● É possível customizar uma célula com a classe
CellControler manipulando:
– Cores (back e fore);
– Estado (enable/disable);

● Construtores:
● Grid(String[] captions, boolean checkEnabled);
● Grid(String[] captions, int[] widths, int[] aligns, boolean
checkEnabled);
● Métodos:
● add(String[] item) – apenas UMA tupla;
● add(String[] item, int row);
● clear();
● del(int row);
● getCellText(int row, int col);
● setCellText(int row, int col, Strint text);
● getItem(int index); - retorna a linha toda;
● getItemsVector();
● getCheckedRows(); - retorna um IntVector;
● int getSelectedIndex();

● Métodos:
● String[] getSelectedItem();
● isChecked:(int lineIndex);
● setChecked(int row, boolean check);
● replace(String[] item, int row);
● setSelectedRow(int line);
● size(); - retorna o número de linhas;
● setColumnEditable(int col, boolean editable);
● setColumnChoices(int col, String[] choices); - Habilita
um CheclBox com possíveis valores;
● setCellController(Grid.CellController cc);

● Métodos da classe CellControler:
● Color getBackColor(int row, int col);
● Color getForeColor(int row, int col);
● boolean isEnabled(int row, int col);
● String[] getChoices(int row, int col);
● Obs: Usando o CellControler o desenho do Grid
ficará mais lento;
● Atributos:
● boldCheck (apenas para alta resoluções);
● canClickSelectAll;
● disableSort;
● enabledColumnResize;
● oldCellText;

● captionsBackColor;
● firstStripeColor;
● secondStripeColor;
● drawStripe;
● String[] captions;
● verticalLineStyle:
– Valores possíveis:
VERT_LINE,
VERTO_DOT(default)
, VERT_NONE;
● Exemplo:

A classe Window
● Já sabemos a utilidade da MainWindow;
● Esta, pode chamar uma janela (Window), que pode chamar
outra e assim sucessivamente;
● Todas serão modal, porém, apenas a última (topMost) poderá
receber eventos e não se pode alternar para a janela anterior
sem antes fechar a atual;
● Como Window estende Control, então você não pode adicionar
a um Container uma janela;
● Para exibir uma janela, você pode chamar os métodos:
● popup;
● popupNonBlocking;

A classe Window
● Recursos:
● setTitle;
● setBorderStyle, valores válidos:
– NO_BORDER; RECT_BORDER; ROUND_BORDER;
TAB_BORDER; TAB_ONLY_BORDER;
● Janelas podem ser movidas pela tela;
● E se eu não quiser isso? (makeUnmovable);
● Os métodos getPreferredWidth (e height) são
mecanismos especiais da classe Window;
● Eles retornam o valor mínimo necessário para uma
correta exibição da janela;

A classe Window
● Métodos:
● onClickOutside(int x, int y);
– Temos duas opções de manuplação:
● Retornar true e tratar o erro;
● Retornar false e setar true em beepIfOut;
● onPopup();
● postPopup();
● onUnpop();
● postUnpop();

A Classe Window
● Prática: Observe as figuras e tente fazer
igual;

Interfaces de Diálogos
● São chamadas quando há uma
mensagem informativa ou uma requisição
específica de entrada;
● São sub-classes de Window;
● Não são mostradas automaticamente;
● Seguem as mesmas regras anteriores;
● Existem classes prontas para
determinadas tarefas, tais como:
● Mensagens, datas, números, ...

Interface de Diálogos:
MessageBox
● Diálogo simples para mostrar um texto
com alguns botões personalizáveis (Yes/
No, Ok/Cancel, Save/Discard/Cancel);
● String title, String msg;
● String title, String text, String[]
buttonCaptions;
● String title, String text, String[]
buttonCaptions, int gap, int insideGap;

MessageBox
● Possui apenas 3
métodos:
● getPressedButtonIndex
()
– Inicia com ZERO;
– Se retornar -1 a janela
foi fechada;
● setTextAlignment(int
align)
– LEFT, CENTER
(default), RIGHT;
● setUnpopDelay(int
unpopDelay);
– Em milisegundos;

InputBox
● Diálogo simples usado para capturar uma entrada
(texto) de um usuário;
● É contido, basicamente, pelo um Label e um Edit;
● Se comporta como um Edit;
● É posicionado no centro da tela e o Edit recebe o
foco automático;
● (String title, String text, String defaultValue);
– Cria com 2 botões padrões: Ok e Cancel;
● (String title, String text, String defaultValue, String[]
buttonCaptions);

InputBox
● Métodos:
● getPressedButtonIndex();
● getEdit();
● getValue();
● setValue(String txt);

KeyboardBox
● Teclado virtual para dispositivos
touchscreen;
● Seu construtor não recebe
argumento;
● Não possui nenhum método;
● Ora bolas então como usá-lo?
● Quando ele é exibido, ele pega
uma referência à Window
topMost, fixa o foco para um Edit
e por fim, devolve para o “target”;

CalculatorBox
● Uma caixa prontinha com uma
calculadora básica com dois
operandos, o resultado e algumas
opções de operadores;
● Possui apenas o construtor padrão
que:
● Limpa os dados da calculadora;
● Pega o valor do controle que iniciou
(edit) a chamada e adiciona ao
operador 1;
● Pode ser usado o método popup();

CalendarBox
● Mostra um pequeno calendário;
● É mostrado com o dia atual por
default;
● Quando o dia é selecionado o
controle é fechado;
● Possui apenas o construtor padrão,
mas existem os seguintes métodos:
● getSelectedDate();
● setSelectedDate(Date d);
● Pode ser usado o método popup();

Imagens
● Constituem imagens retangulares;
● O TC suporta imagens de 24bpp;
● Apenas o formato PNG e JPEG;
● Porém, podemos usar o GIF e BMP que a TCMV
converte automaticamente;
● Imagens NÃO podem ser adicionadas diretamente
em um Container, pois NÃO são controles;
● Então como exibir?
● Existem duas formas:
– ImageControl;
– Button;

Imagens
● Construtores:
● Image(int width, int
height);
● Image(byte[]
fullDescription);
● Image(String path);
● Image(Stream s);
● Métodos:
● Image.isSupported(String
filename);
● getHeight() e getWidth();
● getGraphics();
● changeColors(int from, int
to);
● Exemplo:

Assim...
● Estamos praticamente aptos a criar nossa primeira aplicação
de verdade;
● Eis algumas opções:
● Mini-agenda (pessoal);
● Gerenciamento de plantil de rosas (agrícola);
● Gerenciamento de vendas (comercial);
● Controle de custos para viagens (pessoal e comercial);
● Comanda eletrônica p/ restaurantes(comercial);
● Controle de irrigação de lotes(agrícola);
● Carrinho eletrônico p/ supermercados (empresarial);

● Que tal?

Classes utilitárias
● Podemos encontrar nestes pacotes (util e
sys) os seguintes recursos:
● Manipulação de Datas e Horas;
● Geração de números aleatórios;
● Estrutura de dados;
● Loggin;
● Conversões;

O pacote util: manipulação de data
● Manipula o calendário Gregoriano com o intervalo
de 1/1/1000 até 31/12/2999.
● Constantes:
● Date.JANUARY ... Date.DECEMBER;
● Date.SUNDAY ... Date.SATURDAY;
● Date();
● Date(int sentDay, int sentMonth, int sentYear);
● Date(String strDate);

O pacote util: manipulação de data
● Métodos:
● advance(int numberDays);
– Caso o parâmetro seja negativo ele faz o retrocesso;
● advanceMonth();
● advanceWeek();
● setToday();
● Comparação entre objetos Date:
● isAfter(Date sentDate);
● isBefore(Date sentDate);
● equals(Object sentDate);
● E muito mais ...

O pacote util: a classe Vector
● Implementa um array dinâmico de objetos;
● Não se pode acessar os elementos
diretamente, usa-se os métodos
encapsulados;
● Por questões de performance, o TC
implementa os atributos como public;
● Todavia, JAMAIS manipule inserção, remoção
e redimensionamento do array (garantia de
integridade);
● Porém, pode se usar getter e setter;

● Construtores:
● Vector() : tamanho default de 8;
● Vector(int size) : size >= 0;
● Vector(Object[] startingWith);
● Métodos
● De adição:
– addElement(Object obj);
– insertElementAt(Object obj, int index);
● De Remoção:
– removeElement(Object obj);
– removeElementAt(int index);
– removeAllElements();

● De Indexação:
– indexOf(Object obj, int startIndex);
– indexOf(Object obj);
– Retornam -1 se o objeto não for encontrado;
● Outros métodos:
● isEmpty();
● size();
● setSize(int newSize);
● qsort();
● toObjectArray();
● Um Vector pode ser usado como um Pilha:
● push(Object obj);
● pop();
● peek(); - retorna o objeto sem removê-lo;

O pacote util: a classe IntVector
● Idem ao anterior, com a diferença que agora
teremos um vetor de números inteiros;
● Construtores:
● IntVector();
● IntVector(int size);
● IntVector(int[] items);
● Os métodos são exatamente os mesmos,
apenas alterando o parâmetro que agora
sempre será int;
● O métodos toObjectArray agora é
toIntArray();

O pacote util: a classe Hashtable
● Implementa uma tabela hash com chaves
e valores;
● Hashtable(int initialCapacity);
● Hashtable(String res);
– Constrói uma tabela hash com os elementos da String;
● Métodos de inserção:
● put(Object key, Object value);
● put(int hash, Object value);
● Para saber se um chave já existe, use:
exists(Object key);

O pacote util: a classe Hashtable
● Métodos para retirar um elemento:
● get(Object key);
● get(int hash);
● Métodos para retornar todos os valores:
● Vector getKeys();
● Vector getValues();
● Vector getKeyValuePairs(String separator);
– Retorna o conjunto: key + separador + valores;
● Mais métodos:
● size(): retorna o número de chaves;
● remove(Object key);
● clear(): limpa todas as entradas da tabela;

O pacote util: a classe IntHashtable
● Idem ao anterior, com a diferença que
agora teremos uma tabela hash de
números inteiros;

● Os métodos são exatamente os
mesmos, apenas alterando o
parâmetro que agora sempre será int;

O pacote util: a classe Random
● É uma operação linear para gerar
números aleatórios no intervalo de
[0,231];
● O intervalo não é grande, porém sua
utilização é rápida e usa pouca
memória;
● Construtores:
● Random();
● Random(int seed);
– Seed possui valor absoluto;

O pacote util: a classe Random
● A classe possui apenas 4 métodos:
● nextInt(int n);
● nextDouble();
● between(int s, int e);
● between(char s, char e);

O pacote sys: a classe Time
● Especifica uma data e hora;
● O ano possui 4 dígitos e a hora usa
notação de 24 horas com a notação
padrão internacional;
● Também pode ser referido ao tempo militar e
astronômico;
● Por questões de performance, seus
atributos são públicos;

● Campos e faixas:
● Ano: 4 dígitos;
● Mês: de 1 a 12;
● Dia: de 1 a último dia do mês especificado;
● Hora: de 0 a 23;
● Minutos: de 0 a 59;
● Segundos: de 0 a 59;
● Milisegundos: de 0 a 999;

● Construtores:
● Time(); - data e hora atual;
● Time(int year, int month, int day, int hour, int
minute, int second, int millis);
● Time(long t);
– Formato: YYYYMMDDHHMMSS
● Time(String iso8601);
– Formato: YYYYMMDDTHH:MM:SS;

● Métodos:
● De comparação: equals(Object o);
● getTimeLong();
● toIso8601();
● toString();

O pacote sys: a classe
Convert
● Contém métodos para conversão de objetos e tipos
básicos;
● É uma classe Final e seus métodos e atributos são
estáticos;
● Conversões entre Strings e Tipos Básicos:
● toDouble(String s);
● toInt(String s);
● toLong(String s);
● toLong(String s, int radix);
● toString(boolean b);
● toString(char c);
● toString(double d);

Convert
● toString(double val, int decimalCount);
● toString(int i);
● toString(long l);
● toString(long i, int radix);
● toString(String doubleValue, int n);
● unsigned2hex(int b, int places);
● Caracteres, Strings e StringBuffers;
● appendPath(String path1, String path2);
● insertAt(StringBuffer sb, int pos, char c);
● numberOf(String s, char c);
● replace(String source, String from, String to);
● toLowerCase(char c);
● toUpperCase(char c);

Convert
● Arrays:
● cloneStringArray(String[] strs);
● toStringArray(Object[] objs);
● detectSortType(Object item);
– Constantes provenientes da ordenação de Arrays usando o
Quick Sort:
● SORT_AUTODETECT;
● SORT_OBJECT;
● SORT_STRING;
● SORT_INT;
● SORT_DOUBLE;
● SORT_DATE;
● SORT_COMPARABLE;
● SORT_STRING_NOCASE;

Convert
● Ordenação:
– qsort(Object[] items, int first, int last);
– qsort(Object[] items, int first, int last, int sortType);
– qsort(Object[] items, int first, int last, int sortType,
boolean ascending);
● Outras conversões:
● chars2int(String fourChars);
● int2chars(int i);

Parte III:
O SGDB LiteBase
Noções Básicas e Visão Geral

O Litebase
● É um “SGDB” para TotalCross;
● Usa a linguagem SQL para manipulação e criação
de dados (DDL e DML);
● Está contido no pacote: litebase.*;
● É suportado em TODAS as plataformas do TC;
● Suporte a múltiplas linguagens:
● LitebaseConnection.setLanguage
(LitebaseConnection.LANGUAGE_PT);
● Não esqueça de adicionado à sua biblioteca
personalizada no Eclipse!

Limitações e uso
● O nome da tabela é limitado em 23
caracteres;
● Pode-se criar acima 99 índices;
● Índices usados durante uma avaliação da
cláusula where:
● and; or; like ‘a%’;
● Não suportados:
– like '%a' (ends with); like '%a%' (index of);
– ( ), and; not.

Limitações e uso
● Funções de agregação:
● max, min, avg, sum, count e order by;
● O Join é suportado;
● Exceto: Inner, Left e Right;
● Valores nulos e default são suportados;
● BLOBs são suportados;
● Varchar também;
● Tente não usar o * nos selects;

Limitações e uso
● É possível armazenar usando o memory
card;
● É possível usar multi-threads para várias
conexões com o banco;
● No entanto, isso NÃO é recomendado;
● Existem várias palavras reservadas e
funções!
● Consulte o manual e “Mãos a Obra”;

Tipos de dados
● Short: Java short [-32768 +32767];
● INT: Java int [-2.147.483.648 +2.147.483.647]
● LONG: Java long [-9.223.372.036.854.775.808 … ]
● FLOAT: Java float;
● DOUBLE: Java double;
● CHAR: Java char;
● CHAR NOCASE;
● VARCHAR;
● DATE;
● DATETIME;
● BLOB;

Entendendo seu funcionamento...
● 1º. Criar o driver de conexão:
LitebaseConnection driver = LitebaseConnection.getInstance("Test");

● 2º. Criar uma tabela com seus índices:
try
{
driver.execute("CREATE TABLE TBTeste (id int, valorD double, valorI
int, name varchar)");

driver.execute("CREATE INDEX idx_name ON TBTeste(id)");
} catch (AlreadyCreatedException e){ }

Entendendo seu funcionamento...
● 3º. Inserir valores:
driver.executeUpdate("INSERT INTO TBTeste VALUES (1, 30.0, 31)");
driver.executeUpdate("INSERT INTO TBTeste VALUES (2, 99.8, 22)");

● 4º. Recuperando valores:
...
ResultSet rs = driver.executeQuery("SELECT id, valorD, name FROM
TBTeste WHERE valorI >= 20");
if (rs.next()){
String name = rs.getString("name");
double salary = rs.getDouble(2);
...
} // if
rs.close();

Concluindo ...

Muito Obrigado e
agora é com vocês!!!!!!!

Minicurso de TotalCross e Litebase

Recommandé

Recommandé

Contenu connexe

Similaire à Minicurso de TotalCross e Litebase

Similaire à Minicurso de TotalCross e Litebase (20)

Plus de Nécio de Lima Veras

Plus de Nécio de Lima Veras (20)

Minicurso de TotalCross e Litebase