Lazarus - Criando um Splash e um Hint com várias linhas

Splash

Splash é uma janela de abertura de um programa. Vamos aprender como criar uma dessas em Lazarus. Para isso crie uma nova aplicação. Podemos dar o nome de frmPrincipal a esse form e salvar tudo. Para a unit dê o nome u_principal e ao projeto dê o nome Splash. Agora inclua mais um form na aplicação. Esse será o splash. Na propriedade Name digite frmSplash. Salve e digite u_splash no nome da unit. Na propriedade FormStyle desse form selecione fsSplash. Selecione a opção de menu Project -> Project Options. Localize a aba Forms, selecione frmSplash e, usando a seta, passe-o para a caixa da direita. Isso define que o form não será criado automaticamente.
Coloque um TImage em frmSplash e selecione uma imagem adequada ao seu projeto. É bom mudar Align para alClient e Stretch para True.
Agora clique no botão View Units na barra de ferramentas. Isso abrirá uma janela com todas as units da aplicação. Selecione o arquivo do projeto: splash.lpr.

program splash;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, crt, u_principal, LResources, u_splash
  { you can add units after this };

{$IFDEF WINDOWS}{$R splash.rc}{$ENDIF}

begin
  {$I splash.lrs}
  Application.Initialize;
  frmSplash := TfrmSplash.Create(nil);
  frmSplash.Show;
  frmSplash.Update;
  Delay(1000);
  Application.CreateForm(TfrmPrincipal, frmPrincipal);
  frmSplash.Hide;
  frmSplash.Free;
  Application.Run;
end.

Na seção uses acrescente Crt. Isso é necessário para invocar o procedimento Delay() na linha 21, que provoca um retardo para que o splash seja mostrado por um certo tempo. Explicando o código apenas para as linhas que serão acrescentadas:

Linha 18 - cria o form frmSplash.
Linha 19 - mostra o splash.
Linha 20 - funciona como Repaint, atualizando a janela, senão não será mostrada.
Linha 21 - causa um retardo na execução do programa.
Linha 23 - oculta o splash.
Linha 24 - libera a memória ocupada pelo splash.

Hint com várias linhas

Hints são aquelas dicas que aparecem quando paramos o mouse sobre um componente. Normalmente essas dicas são informadas na propriedade Hint e habilitadas na propriedade ShowHint. No entanto através do Object Inspector só conseguimos colocar uma linha. Para mostrar como podemos ter um Hint com múltiplas linhas coloque um botão do tipo TBitBtn - pode ser qualquer outro tipo de botão - em frmPrincipal. Em Name informe btnSair. Na propriedade Kind selecione bkClose. Dê um duplo clique no form para criar um método para o evento OnCreate. Digite no Editor de código:

btnSair.Hint := 'Para sair desse form' + #13 + 

                'clique neste botão';
btnSair.ShowHint:= True;

O #13 insere um Enter na string e causa um salto de linha. Pode inserir quantos #13 você precise. Execute a aplicação e pare o mouse sobre o botão.

Atualizado em 15/04/2010.

Lazarus - Conectando Firebird com SQLdb ou ZeosLib

Vamos mostrar duas maneiras de acessar Firebird no Lazarus. Uma usando os componentes nativos SQLdb e outra usando ZeosLib. Já fizemos aqui alguns exemplos e a construção da interface não será mais tratada. Apresentaremos apenas os passos necessários no Data Module. Usaremos a versão 0.9.29 do Lazarus.
Antes de iniciar é importante ter conhecimento da versão do Firebird, principalmente para o caso de usar ZeosLib. Crie o banco dados. Vamos usar o mesmo banco usado em artigos anteriores.

create table cidade (id_cidade integer not null primary key, nome varchar(30));

create table cliente (id_cliente integer not null primary key, nome varchar(40), endereco varchar(40), id_cidade integer references cidade(id_cidade), telefone varchar(14), tipo char(1));

Diferente do PG, no Firebird você pode ter um arquivo de banco em qualquer diretório que você queira, desde que seja na máquina local onde está instalado o servidor FB.

Usando SQLdb

Selecione a aba SQLdb e coloque no Data Module um TIBConnection. Ele que fará a conexão com o banco. Defina então as seguintes propriedades:

DatabaseName - informe o arquivo do banco de dados com o caminho completo.
HostName - informe o nome ou o IP do servidor de banco de dados.
Name - informe um nome para a conexão. Por exemplo: dbCliente.
Password - informe a senha do usuário. Normalmente é masterkey.
UserName - informe o nome do usuário. Normalmente é sysdba.

Coloque agora um TSQLTransaction e selecione dbCliente na propriedade Database, e na propriedade Name digite trGeral, por exemplo.
Volte ao TIBConnection e informe trGeral na propriedade Transaction. Coloque a propriedade Connected em True para verificar se a conexão é feita. Depois volte para False.
Coloque um TSQLQuery no Data Module e defina suas propriedades:

Database - selecione dbCliente.
Name - defina queCidade.
SQL - informe SELECT * FROM CIDADE.
Transaction - selecione trGeral.

Coloque agora um TDataSource da aba Data Access e mude Name para dsCidade e em DataSet selecione queCidade.
No evento AfterPost de queCidade digite o código:

queCidade.ApplyUpdates;
trGeral.CommitRetaining;

No evento AfterDelete selecione o mesmo método para não repetir código.
Pronto. Está feita a configuração de acesso, tanto para leitura quanto para escrita, em uma tabela FB. Assim como nos exemplos anteriores lembre-se de conectar e desconectar o banco de dados através de código.

Usando ZeosLib

Usaremos a versão 7.0 do ZeosLib disponível no grupo Lazarus-BR. Coloque um TZConnection no Data Module. Defina as propriedades:

Database - informe o arquivo do banco com o caminho completo.
HostName - informe o nome ou IP do servidor do banco. Para máquina local informe localhost.
Name - digite dbCliente.
Password - informe a senha do usuário. Geralmente masterkey.
Protocol - informe firebird-xx. Observe a versão do FB que você está usando.
User - informe sysdba.

Mude Connected para True. No Windows se ocorrer um erro de dll, localize a mesma na pasta do FB e copie-a para system32 do Windows. Depois de conectar com sucesso volte Connected para False.

Coloque um TZQuery e um TZUpdateSQL e configure-os como foi feito no artigo Lazarus - Conectando PostegreSQL com ZeosLib.
Coloque um TDataSource da aba Data Access e defina Name como dsCidade e em DataSet selecione a TZQuery anterior. Ai está. Agora crie a interface com nos posts anteriores.

Lazarus - Conectando MSAccess com ODBC

Atualizei o Lazarus para a versão Lazarus-0.9.29-24055-fpc-2.4.1-20100317-win32. E foi usando esse snapshot que criei o exemplo usado neste post. Pode-se baixar o mais recente snapshot em http://www.hu.freepascal.org/lazarus/
Nem todas as fontes de dados estão contempladas pelo SQLdb ou pelo ZeosLib. Algumas vezes é necessário migrar ou mesmo atualizar fontes de dados como Paradox, Access e outros. Para essa nobre tarefa o Lazarus disponibiliza o componente TODBCConnection, encontrado na aba SQLdb. Ou seja, podemos acessar qualquer banco de dados (mesmo aqueles que não merecem essa denominação) através de ODBC, desde que tenhamos o driver específico. Devo observar que fiz esse exemplo no Windows.
Então o primeiro passo é criar uma fonte de dados ODBC e isso é feito no sistema operacional. Usei uma fonte MSAccess - o dbdemos.mdb que vem com o Delphi. Após isso vamos ao Lazarus.
No Data Module coloque um TODBCConnection. Mude a propriedade Name para dbAccess, por exemplo. Em DatabaseName digite o nome da fonte de dados criada no sistema anteriormente. Mude Connected para True para testar a conexão. Depois volte para False.
Coloque um TSQLTransaction, mude Name para trAccess e em Database selecione dbAccess. Feito isso coloque um TSQLQuery e mude Name para queEmployee, em Database selecione dbAccess. Na propriedade SQL informe SELECT * FROM EMPLOYEE e em Transaction selecione trAccess. Se você mudar a propriedade Active de queEmployee para True, ela deveria abrir sem erro. No meu caso não funcionou e, depois de muito apanhar, mudei a propriedade UsePrimaryKeyAsKey de queEmployee para False e deu certo. Não sei explicar porque. Na propriedade InsertSQL digite:

INSERT INTO EMPLOYEE VALUES (:EMPNO, :LASTNAME, :FIRSTNAME, :PHONEEXT, :HIREDATE, :SALARY);

Em UpdateSQL:

UPDATE EMPLOYEE SET LASTNAME = :LASTNAME, FIRSTNAME = :FIRSTNAME, PHONEEXT = :PHONEEXT, HIREDATE = :HIREDATE, SALARY = :SALARY WHERE EMPNO = :EMPNO;

E em DeleteSQL:

DELETE FROM EMPLOYEE WHERE EMPNO = :EMPNO;

Agora coloque um TDataSource da aba Data Access. Defina Name como dsEmployee e DataSet como tbEmployee.

Crie uma interface. Se tiver dúvida de como fazer isso, dê uma olhada nos posts Lazarus - Acessando banco de dados com SQLdb - Parte I e Parte II.
Lembre de abrir e fechar a conexão do TODBCConnection. Pode fazer isso nos eventos OnShow e OnClose de form, usando os métodos Open e Close. Abra e feche tbEmployee nos mesmos eventos. Para finalizar, no evento AfterPost de tbEmployee escreva o seguinte código:

tbEmployee.ApplyUpdates;

E ligue o evento AfterDelete a esse mesmo método. Clique aqui para fazer o download do exemplo. Qualquer dúvida ou sugestão comente.

Lazarus - Tratamento de Arquivos Texto

Em determinadas situações tratar arquivos textos é necessário. Arquivos nesse formato são usados com frequência para troca de dados entre sistemas. Mesmo com a força de XML, esse formato ainda tem seu espaço.
Em Lazarus existem componentes que possibilitam o tratamento desse tipo de fontes de dados. Na aba de componentes Data Access encontramos o TSdfDataSet e o TFixedFormatDataSet. A seguir vamos abordar cada um deles e mostrar exemplos.

TSdfDataSet

Este componente permite tratar um arquivo texto que usa um delimitador entre os campos, como um arquivo csv. O arquivo já deve existir para ser utilizado. Pode ser criado facilmente usando um editor comum. Crie um arquivo e digite uma linha com três campos separados por vírgula, por exemplo:

1,JOÃO DA SILVA,joao@meuemail.com.br

Chame o arquivo de cliente.txt. Ele terá três campos: ID, NOME e EMAIL.
Crie uma nova aplicação no Lazarus. Vamos fazer tudo no próprio form, mas mantenha o hábito de colocar seus componentes de banco de dados em um Data Module, como costumamos fazer nos artigos anteriores.
Localize a aba Data Access e coloque um TSdfDataSet. Altere a propriedade Name para tbContato e, em FileName informe o nome do arquivo criado acima com o caminho completo. Na propriedade Delimiter é possível especificar um delimitador, que por padrão é (,).
Da mesma aba selecione um TDataSource e coloque no form. Altere Name para dsContato e selecione tbContato na propriedade DataSet.
Coloque três TDBEdits no form e identifique-os apropriadamente com TLabels. Defina a propriedade DataSource de cada um deles com dsContato. Defina DataField como Field1, Field2 e Field3, respectivamente. Deve ocorrer um erro em cada atribuição mas não se preocupe com isso. Se preferir, pode mudar a propriedade Active de tbContato para True e os nomes dos campos - Field1, Field2 e Field3 - devem aparecer automaticamente. Se ocorrer um erro ou os nomes dos campos não aparecerem verifique se o nome do arquivo está corretamente definido. Agora coloque um TDBNavigator da aba Data Controls e defina a propriedade DataSource como dsContato.

Agora vamos escrever o código para abrir e fechar a tabela. Faça como antes já fizemos. No evento OnShow do form escreva:

tbContato.Open;

E no evento OnClose, escreva:

tbContato.Close;

Execute o programa. Ele deve funcionar normalmente. Permite inserir, excluir, alterar e navegar nos registros.

TFixedFormatDataSet

Este componente é usado para manipular arquivos de texto onde cada campo tem um tamanho fixo. Quando o valor do campo não preenche totalmente o tamanho dele, o restante é completado com espaços. Assim como no componente anteior, neste também é necessário criar o arquivo antes. Simplesmente vamos criar um novo arquivo texto vazio. Fica definido que o campo Id terá 5 caracteres, Nome e Email terão 30 caracteres, cada um. Diferente de TSdfDataSet, a programação de exige um pouco de código, como veremos mais a frente.
Crie uma nova aplicação no Lazarus. Coloque um TFixedFormatDataSet no form e defina a propriedade Name como tbContato e na propriedade FileName informe o nome do arquivo texto criado com o caminho completo.
Coloque também um TDataSource. Mude Name para dsContato e selecione tbContato em DataSet.
Bem, este componente precisa de algum código para funcionar. Ele só reconhece um campo - Line. Line representa uma linha do arquivo. Então coloque três TEdits e mude as propriedades Names para edId, edNome e edEmail, respectivamente. Coloque três TLabels para identificar esses campos. Coloque um TDBNavigator e defina a propriedade DataSource como dsContato.
Localize o evento AfterScroll de tbContato e escreva o seguinte código para ele:

edId.Text := copy(tbContato.FieldByName('Line').Value, 1, 5);
edNome.Text := copy(tbContato.FieldByName('Line').Value, 6, 30);
edEmail.Text := copy(tbContato.FieldByName('Line').Value, 36, 30);

Com isso, a cada vez que navegamos em um registro, este código extrai cada parte e a atribui ao TEdit correspondente. No evento BeforePost de tbContato escreva:

tbContato.FieldByName('Line').Value := Espacos(edId.Text,5) + Espacos(edNome.Text,30) + Espacos(edEmail.Text,30);

A função Espacos() preenche cada campo com espaços até completar o tamanho do campo:

function TfrmTexto.Espacos(s: string; t: integer): string;
var
  i: integer;
begin
  result := s;
  for i := length(s) + 1 to t do
     result := result + ' ';
end;

O cabeçalho dessa função deve ser declarado na seção type junto aos outros métodos da unit. Agora escreva o código para abrir a tabela em OnShow e para fechar em OnClose.
Pronto. Compile e execute o programa. Neste exemplo, a tabela não entra em modo de edição automaticamente quando alteramos algum campo nos TEdits. É necessário ativar o modo de edição pressionando o botão correspondente no TDBNavigator.

Pausa para uma xícara de café

Em Java usamos a classe Scanner para separar uma fonte de dados em partes delimitadas por um delimitador específico. Quem é responsável pela entrada de dados é System.in e não Scanner. Por exemplo, vamos observar esse trecho de código:

Scanner sc = new Scanner(System.in); // declara um objeto
                                     // Scanner
String nome;
String endereco;

System.out.println("Digite o nome:");
nome = sc.next();                   // lê nome do teclado
System.out.println("Digite o endereço:");
endereco = sc.next();               // lê endereço do teclado
System.out.println(nome + ", " + endereco);

Se você, quando for pedido o nome, entrar por exemplo: "Joao da Silva", vai observar que nome irá receber "Joao" e endereco, "da". O programa nem irá solicitar a digitação do endereço. Isso acontece porque o delimitador padrão da classe Scanner é o espaço. Scanner é um tokenizador, ou seja, divide uma string em pedaços, e quem delimita esses pedaços, por padrão, é o espaço. Dessa forma quando digitamos "Joao da Silva", Scanner o divide em três pedaços. O primeiro ("João") é atribuido a nome, o segundo ("da") é atribuido a endereço e o terceiro fica perdido. Então, como solucionar isso? A boa notícia é que Scanner tem um método que permite alterar o delimitador. Inclua a seguinte linha após a declaração do objeto Scanner:

sc.useDelimiter(System.getProperty("line.separator"));

System.getProperty("line.separator") retorna o separador de linhas definido no sistema e passa para o método useDelimiter(), que o define como um novo delimitador para Scanner. Normalmente o separador de linhas é o "\n". No Windows é "\r\n". Dessa forma quando for solicitado o nome, tudo que for digitado até o "\n", será considerado parte da variável nome. Podemos definir qualquer string como delimitador ou mesmo uma expressão regular (regex). Scanner pode tokenizar quaisquer strings, não apenas o que é lido do teclado.

Lazarus - Conectando PostgreSQL com ZeosLib

Neste artigo mostraremos como criar uma aplicação simples usando o conjunto de componentes ZeosLib e o banco de dados PostgreSQL (PG). ZeosLib precisar ser baixado e instalado. Depois de extrair os arquivos, inicie o Lazarus. Selecione no menu Package -> Open package file (.lpk). Localize o diretório onde você extraiu o componente e selecione o pacote zcomponent.lpk em \packages\lazarus. Na janela que abrir clique em Compile. Aguarde finalizar e então clique em Install. Esse procedimento irá recompilar o Lazarus e depois ele será reinicializado. Confira que uma nova aba foi adicionada na paleta de componentes - Zeos Access.
Com relação ao banco de dados, você pode baixá-lo no site oficial. A instalação é muito simples, inclusive no Ubuntu. No Windows localize libpq.dll no diretório de instalação do PG e copie-a para o diretório System32 - procedimento necessário para o funcionamento do Zeos com PG.
Agora que está tudo instalado, no PG, crie um novo banco de dados - chame-o de clientes - e as tabelas necessárias para o nosso exemplo:

create table cidade (id_cidade integer primary key, nome varchar(30));

create table cliente (id_cliente integer primary key, nome varchar(40), endereco varchar(40), id_cidade integer references cidade(id_cidade), telefone varchar(14), tipo char(1), status boolean);

Vamos criar uma aplicação semelhante àquela que criamos nos posts em Lazarus - Acessando banco de dados com SQLdb - Parte I e Parte II. Como a interface é a mesma, vamos descrever apenas a criação do Data Module.
Inicie o Lazaus, crie uma nova aplicação e adicione um Data Module ao programa. Defina Name como dmDados. É no Data Module que tudo irá acontecer daqui em diante.

TZConnection

Esse componente é reponsável por criar uma conexão com o banco de dados e controlar as transações. Veremos que ele possui propriedades que permitem que seja configurado para se conectar a vários bancos de dados: PostgreSQL, Firebird, Oracle, SQLite e outros. Coloque um desses no Data Module. As seguintes propriedades merecem um melhor entendimento:

AutoCommit - determina de que forma as alterações são confirmadas no banco de dados. Se deixar em True as alterações são confirmadas implicitamente. Caso se deseje confirmar explicitamente devemos mudar para False. No nosso caso deixemos em True.
Connected - estabelece uma conexão com o banco. Durante o desenvolvimento, se for necessário, coloque em True. Mas lembre de voltar para False antes de finalizar o projeto.
Database - define o nome do banco de dados. Digite clientes. Se estiver usando o Firebird ou SQLite você deve informar o caminho completo do arquivo do banco de dados.
HostName - informa o nome ou IP do servidor de banco de dados. Se for a máquina local atribua o nome localhost.
Name - informe dbCliente.
Password - informar a senha do servidor de banco de dados. Informe a senha do usuário definida durante a instalação do PG.
Protocol - define qual o banco de dados que será conectado. Informe postgresql-8 ou o que for adequado ao banco usado.
TransactionIsolation - define o nível de isolamento da transação. No nosso caso vamos usar tiReadCommitted.
User - define o nome do usuário do banco de dados. Informe o usuário criado durante a instalação do PG.

Para fazer um teste da conexão, mude a propriedade Connected para True. Se estiver tudo certo não deve acontecer erro.

TZUpdateSQL

Especifica os comandos SQL de atualização - INSERT, UPDATE e DELETE. Atua em conjunto com um TZQuery. Inclua um componente desse no Data Module e defina suas propriedades assim:

DeleteSQL - DELETE FROM CIDADE WHERE ID_CIDADE = :OLD_ID_CIDADE;
InsertSQL - INSERT INTO CIDADE VALUES (:ID_CIDADE, :NOME);
ModifySQL - UPDATE CIDADE SET NOME = :NOME WHERE ID_CIDADE = :OLD_ID_CIDADE;
Para informar os comandos clique na propriedade correspondente do Inspetor de Objetos. Digite o comando no editor e tecle OK.

Name - defina como upCidade.
Qualquer identificador precedido por dois pontos (:) é um parâmetro que será definido quando o comando for executado. O prefixo OLD possibilita o acesso ao valor do campo antes dele ser modificado.

TZQuery

Query que deve ser usada para atualizar dados em tabelas. É usada em conjunto TZUpdateSQL para que execute as operações de INSERT, UPDATE ou DELETE. Para cada tabela do banco deveremos ter um desses componentes no Data Module. Inclua uma TZQuery no Data Module e vamos alterar suas propriedades:


Connection - especifica o objeto TZConnection. Selecione dbCliente.
Name - queCidade.
SQL - especifica um comando SELECT para mostrar os dados da tabela. Informe: SELECT * FROM CIDADE.
UpdateObject - define o objeto TZUpdateSQL que será usado em conjunto com TZQuery. Selecione upCidade.

Para finalizar o desenho do acesso à tabela Cidade, coloque um TDataSource da aba Data Access. Defina Name como dsCidade e DataSet como queCidade.
Com exceção de TZConnection - que deve ser apenas um - repita o processo para definir o acesso à tabela Cliente. O Data Module deverá ter esse aspecto:

Não é necessário incluir todo aquele código no evento AfterPost das TZQueries. Isso é feito automaticamente pois a propriedade AutoCommit de TZConnection está definida como True. A partir de agora o programa é exatamente igual ao que foi criado em Lazarus - Acessando banco de dados com SQLdb - Parte I e Parte II. Siga os mesmos passos desses posts. Bem, uma pequena modificação se faz necessária. Nos eventos OnShow e OnClose de frmPrincipal na aplicação anterior nós incluimos códigos para abrir e fechar a conexão. Diferente do SQLdb, no Zeos, o comando para abrir a conexão será:

dmDados.dbCliente.Connect;

e para encerrar:

dmDados.dbCliente.Disconnect;

Qualquer dúvida na criação dessa aplicação, podem me escrever ou deixar um comentário. Terei o maior prazer em ajudar.

Lazarus - Criando uma aplicação para WinCE

Preparando o ambiente

Para criar aplicações que executem em dispositivos móveis com SO Windows Mobile ou WinCE é necessário instalar o cross-arm-wince, que tem apenas versão para Win32. Se já existir o Lazarus instalado, baixe e instale o Lazarus-0.9.28.2-fpc-2.2.4-cross-arm-wince-win32.exe no mesmo diretório do Lazarus.
A partir de agora sua instalação continuará compilando para o ambiente Windows, mas terá a opção de compilar para o WinCE. Sempre que você iniciar um projeto WinCE é necessário fazer algumas configurações em Project -> Compiler options. Na aba Paths selecione wince em LCL Widget Type (various). Na aba Code escolha WinCE em Target OS (-T) e arm em Target CPU family (-P). Pronto. O compilador irá gerar um executável que executa apenas no PDA. Dessa forma para compilar use sempre CTRL + F9.

Banco de dados

A opção pelo SQLite é quase forçada. Só precisamos de uma dll e tudo funciona. Bem de acordo com as limitações impostas pelos PDAs. Prefiro sempre baixar alguma coisa já pronta, compilar os fontes gera um certo incômodo. Se você prefere compilar pode baixar os fontes aqui. Mas pode obter algo pronto aqui, inclusive com um visualizador de tabelas para WinCE. A dll deverá ser instalada na mesma pasta do PDA onde estará o banco de dados SQLite e o executável.

Escolha dos componentes

Essa foi a parte mais difícil. Muitas opções mas não tive muito sucesso. Para banco de dados tive problemas com SQLdb e Zeos. Com SQLdb não reconhecia o banco no PDA. Com Zeos deram alguns erros durante a compilação. Então optei por usar o TSQLite3Dataset da unit sqlite3ds. Mesmo existindo um pacote com o componente eu usei código FreePascal direto.
Para a interface existe o pacote KOL-CE. No entanto nos meus testes eu não consegui integrar esses componentes com banco de dados. Vou continuar tentando e apresento o resultado mais tarde.
Assim, usei os próprios componentes nativos do Lazarus. A grande dificuldade é adequar a interface ao modelo de PDA onde a aplicação irá executar. Fiz testes em um HP iPAQ com Windows Mobile 5.0.

Criação da interface

Crie uma nova aplicação no Lazarus. Altere a propriedade Name do form para frmCidade, Caption para Cidades. Salve tudo. Para a unit dê o nome u_cidade e para o projeto digite Cidade. Faça as alterações em Project -> Compiler options conforme falamos anteriormente.
Desenhe o form de acordo com a figura abaixo: coloque dois TEdits, dois TLabels, cinco TButtons da aba Standard, e um TStringGrid da aba Additional.

Note que não estamos usando controles da aba Data Controls. Defina as propriedades dos componentes - da esquerda para a direita e de cima para baixo - da seguinte forma:

TLabel - Caption defina como ID.
TLabel - Caption defina como Nome.
TEdit - Name defina com edId e apague o conteúdo de Text.
TEdit - Name defina com edNome e apague o conteúdo de Text.
TButton - Caption defina como Inserir e Name defina como btnInserir.
TButton - Caption defina como Excluir e Name defina como btnExcluir.
TButton - Caption defina como Alterar e Name defina como btnAlterar.
TButton - Caption defina como Consultar e Name defina como btnConsultar.
TButton - Caption defina como Sair e Name defina como btnSair.
TStringGrid - Name defina como grdDados e FixedCols como 0. Clique no botão à direita na propriedade Columns. Clique no botão Add para adicionar duas colunas. Selecione a primeira e expanda a propriedade Title. Digite ID na propriedade Caption. Faça o mesmo na segunda coluna e digite NOME na propriedade Caption. Feche a janela.
Você deve ajustar as dimensões do form de acordo com o PDA onde a aplicação será executada. O form do exemplo tem 243 x 300.

O código

Para nosso exemplo usarei o mesmo banco de dados criados nos post anteriores. Inicialmente as declarações de variáveis. Inclua sqlite3ds na cláusula uses:

var

  frmCidade: TfrmCidade;

  tbCidade: TSQLite3Dataset;   

  sSql: string;

              
No evento OnShow do form o objeto tbCidade é criado e inicializado com os dados do banco de dados e da tabela Cidade:

  tbCidade := TSqlite3Dataset.Create(nil);

  tbCidade.FileName := 'clientes.db';

  tbCidade.TableName := 'cidade';

  tbCidade.PrimaryKey := 'Id_Cidade';

No evento OnSelectCell da TStringGrid definimos que a os dados na linha selecionada na StringGrid são copiados para os TEdits:

  edId.Text := grdDados.Cells[0, aRow];

  edNome.Text := grdDados.Cells[1, aRow];

No evento OnClick de btnConsultar a tabela é consultada e seus dados mostrados na StringGrid:

  tbCidade.Close;

  tbCidade.SQL := 'select * from cidade';

  tbCidade.Open;

  grdDados.Clear;

  while not tbCidade.EOF do

  begin

     grdDados.Row := grdDados.RowCount - 1;

     grdDados.RowCount := grdDados.RowCount + 1;

     grdDados.Cells[0, grdDados.Row] := tbCidade.Fields[0].AsString;

     grdDados.Cells[1, grdDados.Row] := tbCidade.Fields[1].AsString;

     tbCidade.Next;

  end;

  tbCidade.Close;

No evento OnClick de btnAlterar o comando UPDATE é construído e executado:

   sSql := 'update cidade set nome = ''%s'' where id_cidade = %d';
   tbCidade.SQL := Format(sSql, [edNome.Text, StrToInt(edId.Text)]);
   tbCidade.ExecSQL;

No evento OnClick de btnInserir fazemos o mesmo com o comando INSERT:

  sSql := 'insert into cidade(id_cidade, nome) ' +

     'values(%d, ''%s'')';

  tbCidade.SQL := Format(sSql, [StrToInt(edId.Text), edNome.Text]);

  tbCidade.ExecSql;

O comando DELETE é construído e executado no evento OnClick de btnExcluir:

  if MessageDlg('Confirmação','Deseja excluir o registro?', mtConfirmation, [mbYes, mbNo],0) = mrYes then

  begin

     sSql := 'delete from cidade where id_cidade = %d';

     tbCidade.SQL := Format(sSql, [StrToInt(edId.Text)]);

     tbCidade.ExecSQL;

  end;

Este programa é apenas um exemplo e muita coisa precisa ser feita para que ele funcione bem. Por exemplo, os botões btnAlterar e btnExcluir só podem ser habilitados se houver um ID a ser pesquisado, entre outras melhorias que devem ser implementadas.