VCL Style e Build Configurations no Delphi

Através deste artigo quero apresentar um novo recurso presente a partir da versão XE2 do Delphi, o VCL Style e sobre o recurso Build Configurations existente a partir da versão 2009 do Delphi.

Estrutura de organização dos diretórios no Linux

O Linux é projetado para rodar tanto em máquinas com bastante poder de processamento como em máquinas com configurações mínimas e baixo poder de processamento.

Como fazer um Extract MetaData com o IbExpert?

Vamos aprender a usar um recurso muito interessante da ferramenta IBExpert, o: extract metadata. Qual a utilidade dessa ferramenta?

Como desativar mensagem de expiração do Winrar

Se você usa o Winrar, um dos softwares mais utilizado para compactação de arquivos, então você já se deparou com aquela mensagem "chatíssima" de expiração.

Removendo senha de usuário no Windows

Acredito que alguém já deve ter passado pela desagradável situação de esquecer a senha do seu usuário do Windows, e pesou "Agora ferrou!". Pois é, aconteceu isso com um de nossos clientes, como resolver?


ClipaTec Informática

Receba novidades por e-mail. Digite seu e-mail abaixo e clique no botão "Cadastrar"

Delivered by FeedBurner

8 de agosto de 2018

Algoritmo e lógica de programação - Estruturas de repetição (loop)

estrutura de repeticao loop

Olá clipatequeiros. Este artigo é voltado para os iniciantes em programação, que estão dando seus primeiros passos. Geralmente postamos coisas de nível médio e avançado, mas nosso objetivo é ajudar a todos, inclusive quem está começando agora, quanto mais programador melhor.
Vou abordar neste artigo a respeito das estruturas de decisão, também conhecidas por "loop" ou simplesmente laço de repetição. No desenvolvimento de software, estas estruturas são muito utilizadas. Em determinados momentos, precisamos repetir um determinado trecho de código (implementação) "n" vezes, é neste caso que entram as estruturas de repetição. Elas são muito úteis, até mesmo para reduzir códigos.
Podemos dividir as estruturas de decisão em dois grupos: iterativa e interativa. Uma letrinha a mais no nome, mas na prática, uma diferença considerável. Vamos ver um pouco sobre estes dois grupos de maneira bem resumida e direta (odeio enrolação, não leva a lugar nenhum e fica cansativo rsrsrs).
Praticamente, todas as linguagens de programação, disponibiliza três estruturas de repetição, são elas:

  • para ate faca
  • enquanto faca
  • repita ate


Digo "praticamente todas", porque desconheço alguma linguagem que não dê suporte a estas três estruturas, mas, vai que exista alguma por ai não é mesmo?

Estrutura de repetição iterativa (loop iterativo)

Dentro deste grupo, temos a estrutura de repetição, ou laço de repetição para ate faca.
Esta estrutura é utilizada quando já se tem o número de vezes definido que um determinado trecho de código será repetido. É dito iterativo porque dispensa a ação, interferência, interação do usuário para que o mesmo pare de se repetir, ou seja, ele vai se repetir até que o número de vezes definido seja satisfeito, dispensando a ação do usuário para pará-lo.
Vou apresentar uma situação simples, porém, vai te ajudar entender melhor. Imagine que um algoritmo precisa mostrar os números pares dentro de um intervalo de 1 até 10. Certo?
Note que já temos definido a quantidade de vezes em que este laço vai se repetir, isto é, dez vezes. Então este laço só vai parar após a décima repetição, não foi necessário o usuário intervir para parar a repetição, esta quantidade de vezes já foi predefino antes. Este laço é iterativo porque a cada repetição, a variável de controle do laço incrementa, adiciona, soma mais um.
Vejamos a sintaxe do laço para ate faca:

para "variavel_controle" de "valor_inicial" ate "valor_final" [passo "incremento"] faca
"sequencia_de_comandos"
fimpara

Onde:

"variavel_controle": é uma variável do tipo inteiro que vai controlar as repetições do laço;
"valor_inicial": definição do valor inicial para a variável_controle;
"valor_final": definição do valor limite para a variavel_controle;
"incremento": o valor a ser incrementado na variavel_controle;
"sequencia_comandos": parte do código (implementação) que será executada durante a repetição do laço;

Então, a variável de controle recebe um valor inicial para a contagem das repetições, e vai se repetir até que o valor final seja satisfeito, e, a cada repetição a variável de controle soma o valor do incremento. Este último, quando não passado, por padrão é sempre "um".
Em próximos artigos vamos trabalhar alguns algoritmos como exercícios práticos para entendermos melhor.

Estrutura de repetição interativa (loop interativo)

Dentro deste grupo, temos as estruturas "enquanto faca" e "repita ate".
Estas estruturas são utilizadas quando não temos previamente a quantidade de vezes que um determinado trecho de código irá se repetir. É dito interativo porque necessitada da ação do usuário para que o mesmo pare de se repetir. Essa interação do usuário vai ou não satisfazer uma condição de parada, desta maneira, quando tal condição for satisfeita o laço para de se repetir.
Imagine um algoritmo que cadastre nomes de pessoas, onde um menu será exibido ao usuário com duas opções: "Cadastrar" e "Sair". Sempre que o usuário escolher a opção "Cadastrar", o algoritmo pede para que o usuário digite o nome da pessoa, em seguida, o menu é exibido novamente. Percebe que, enquanto o usuário escolher a opção "Cadastrar", será necessário entrar com um nome a ser cadastrado, e quando, finalmente, o usuário escolher a opção "Sair", então, o laço para de se repetir, ou seja, a condição de parada do laço, é quando a opção escolhida for "Sair".
Essa é a diferença entre o laço iterativo e o laço interativo, este último, só para de se repetir, quando a condição de parada for satisfeita, neste caso, necessita-se da intervenção do usuário para isso. Então por que temos duas estruturas neste grupo?
Simples, o enquanto faca, o teste da condição de parada é feita no início, antes mesmo de entrar no laço, se o teste, ou expressão lógica, for satisfeita logo no início, então, o trecho de código dentro do laço nem chega a ser executado, já a estrutura repita ate, o teste da expressão lógica só é feito no final do laço, então, independente de tudo, o trecho de código dentro deste laço, sempre será executado pelo menos uma vez, ao chegar no fim, se a condição for satisfeita, o mesmo para, caso contrário, continua executando. Agora, cabe a você programador, analisar no seu dia a dia a necessidade do momento e escolher qual das duas estruturas interativas utilizar.
Vejamos a sintaxe do laço enquanto faca:

enquanto "condicao_de_parada" faca
"sequencia_de_comandos"
fimenquanto

Onde:

"condicao_de_parada": ou expressão lógica, representa o teste a ser realizado, se verdadeiro, o laço para, se falso, o laço continua executado. Esta expressão lógica é realizada a cada repetição, e deve ser do tipo booleana.

Agora, vejamos a sintaxe do laço repita ate:

repita
"sequencia_de_comandos"
ate "condicao_de_parada"

Neste caso, dispensa explicação, visto que é exatamente igual ao anterior, o que muda, é que o teste é feito no final do laço, e os comandos (repita..ate).
Também, faremos alguns algoritmos para praticar estas estruturas em próximos artigos, um grande abraço.

(Por Welinton J. Dias)

12 de maio de 2018

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 6

delphi mvc poo camada view

Aooooo meu povo, finalmente chegamos ao penúltimo artigo da nossa série de cadastro Delphi POO + MVC + DAO. Estamos felizes por ter acendido uma pequena luz nessa escuridão, algumas pessoas tem interagido outras entraram em contato, e isso é muito gratificante. Neste artigo vamos finalizar as implementações da camada VIEW.
Sem perca de tempo, com o projeto aberto no Delphi, acesse a tela de cadastro de cliente, selecione a "StringGrid" e implemente o evento "OnDrawCell" assim:

delphi mvc poo camada view

Esta implementação apenas pinta os títulos das colunas da Grid, para ter um destaque visual, caso as descrições dos títulos das colunas não aparecer, acrescente esta linha após a linha 340:

Canvas.TextOut(Rect.Left, Rect.Top, Cells[ACol,ARow]);

Agora vamos implementar o evento "OnDblClick" da "StringGrid", este evento é acionado quando o usuário der um duplo-clique sobre algum registro, ele apenas chama o método "Detalhar":

delphi mvc poo camada view

OK, agora, implemente o evento "OnShow" do formulário de cadastro assim:

delphi mvc poo camada view

Simplesmente, ao abrir a tela de cadastro de cliente, o método "SetUp" será chamado, e as configurações básicas para o bom funcionamento da tela serão realizadas. 
Implemente o evento "OnKeyPress" da tela de cadastro desta maneira:

delphi mvc poo camada view

Este método verifica se a tecla "Enter" foi pressionada, caso sim, nós anulamos sua funcionalidade em seguida e chamamos a função "Tab", para que quando o usuário pressionar a tecla "Enter", ele consiga navegar entre os campos da tela.
Agora, vamos implementar os eventos "OnClick" dos seguintes botões:

Pesquisar

delphi mvc poo camada view

Novo

delphi mvc poo camada view

Detalhar

delphi mvc poo camada view

Excluir

delphi mvc poo camada view

Listar

delphi mvc poo camada view

Alterar

delphi mvc poo camada view

Gravar

delphi mvc poo camada view

Cancelar

delphi mvc poo camada view

Esta foi a parte mais simples, pois, apenas chamamos os métodos que já foram implementados nos botões. Desta maneira, finalizamos as implementações da camada VIEW, agora, no próximo artigo, vamos finalizar o projeto. Qualquer dúvida, só comentar, até o próximo, abraço.

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

11 de maio de 2018

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 5

delphi mvc poo camada view

Olá clipatequeiros de plantão. Estamos em reta final desta série de artigos, e no artigo de hoje, vamos continuar implementando os métodos da camada VIEW. Com o projeto aberto no Delphi, implemente o método "Gravar":

delphi mvc poo camada view

Conforme vimos no início da parte 3 vamos usar o Field "FOperacao", o qual, uma de suas finalidades é nortear o método gravar, rapidamente explicando, quando o usuário clicar no botão "Novo", este campo recebe um valor de tipo enumerado "opNovo", e quando o usuário clicar no botão "Alterar", este campo recebe um valor "opAlterar", desta maneira, agora aqui dentro do método "Gravar", fazemos uma verificação, se o valor deste campo é "opNovo", então o método "Gravar" vai chamar o método de inserção, caso for "opAlterar", o método  de alteração será chamado.
Após o método Inserir ou Alterar for chamado, ao final da operação, se deu tudo certo, novamente chamamos o método de pesquisa para atualizar as informações.

Muito bem, agora implemente o método "Inserir":

delphi mvc poo camada view

Como você já deve estar habituado, não tem muito segredo, algumas linhas dispensa comentários e explicações. Basicamente um objeto do tipo "TCliente" é criado, e alimentado com as informações dos componentes que o usuário digitou, logo após, este objeto é enviado para a DAO por meio da Controller, onde as informações do mesmo será extraída e inserida na base de dados, se ocorrer algum erro, este erro é retornado dentro da variável "sErro" e exibida para o usuário como uma exceção.
Agora, vamos implementar o método que faz aquela mágica nos componentes para habilitar e desabilitar conforme a operação que está sendo realizada, então, mão na massa, implemente o método "HabilitarControles":

delphi mvc poo camada view
C
Como você percebeu, este método vai habilitar ou desabilitar os controles (TEdit, TButton, etc) conforme a operação (Inserção, Alteração ou Navegação). Sem segredos nénom? Qualquer dúvida, deixe seu comentário.
Ufa, calma que já estamos quase concluindo nosso projeto por completo, daqui sete artigos chegaremos ao fim (kkkkkkkkkk) brincadeira, faltam poucos artigos. Brincadeiras a parte, agora vamos implementar o evento "OnClick" do botão "btnCliente". Este botão, está no formulário do menu principal, então, acesse ele, dê um duplo-clique sobre o botão "Cliente" e implemente desta forma:

delphi mvc poo camada view

Este botão simplesmente cria o formulário de cadastro de cliente na memória e exibe para o usuário, e quando for fechado, o mesmo é liberado da memória. É importante ressaltar que, você precisa fazer o formulário principal enxergar o formulário de cadastro, para isso, pressione "Alt + F11" e selecione o formulário de cadastro de cliente na lista, deixe a opção "Implementation" marcada e clique no botão "OK". É o famoso "Use Unit". Para finalizarmos este artigo, volte para o formulário de cadastro de cliente, selecione a "StringGrid" e implemente o evento "OnSelectCell" da seguinte maneira:

delphi mvc poo camada view






Conforme o usuário seleciona um registro na "StringGrid", o código do mesmo é armazenado no campo "IdSelecionado", conforme você observou durante as implementações, este campo é usado durante as chamadas de alguns métodos, como o método "CarregarCliente" por exemplo.
Gente boa, assim terminamos mais um artigo, esperamos vocês no próximo artigo, um dos últimos desta série espetacular. Até lá. Tchauuu brigadoooo.

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

10 de maio de 2018

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 4

delphi mvc poo camada view

Salve, salve galera. De volta a nossa série, no artigo anterior havíamos implementado alguns métodos, neste artigo, daremos continuidade nas implementações dos métodos. Para tal, abra o projeto no Delphi e implemente o método "CarregarCliente" da seguinte forma:

delphi mvc poo camada view

Nas linhas 157 e 158 declaramos nossos objetos da classe TCliente e TClienteController.
Nas linhas 160 e 161 criamos as instâncias desses objetos na memória e nas linhas 176 e 177 liberamos da memória após o uso.

Na linha 163, invocamos o método "CarregarCliente" da classe TClienteController, que por sua vez, vai chamar o método "CarregarCliente" da DAO. Note que este método pede um objeto do tipo TCliente que será preenchido lá na camada DAO, e o código do cliente, cujas informações serão buscadas na base de dados para preencher o objeto.
Da linha 164 a 174, apenas estamos lendo as informações que estão no objeto "oCliente" que foi preenchido anteriormente, e jogando nos componentes da tela, para que o usuário possa ver essas informações.

Agora, vamos implementar o método "Alterar:

delphi mvc poo camada view

Este método, conforme observado, vai ler as informações que estão nos componentes da tela que foram preenchidos pelo usuário e alimenta o objeto com estas informações. Feito isso, este objeto preenchido é passado para o método "Alterar" da "TClienteController", que vai direcionar para a DAO, onde as alterações serão persistida na base de dados, caso ocorra algum erro, o mesmo é retornado pelo método através do parâmetro do tipo variável "sErro", que é exibido pela exceção (raise Exception).
Agora, o método "Listar":

delphi mvc poo camada view

Este método simplesmente ativa a aba de pesquisa.
Implemente o método "Excluir":

delphi mvc poo camada view
Clique na imagem para ampliar e vê-la completo

O método excluir também é bem simples. Na linha 196, estamos verificando se nossa "StringGrid" possui algum registro, caso contrário, uma exceção é suscitada informando que a tabela está vazia, portanto, não há o que excluir.
Caso tenha algum registro selecionado, capturamos o código dele e repassamos para o método "Excluir" da "TClienteController" que fara o resto, como você já sabe.
Após a exclusão, apenas chamamos o método de pesquisa novamente, para atualizar a "StringGrid", se isso não for feito, embora o registro seja excluído ele continuará listado na tabela, e isso pode causar uma dúvida ao usuário, que vai pensar que o registro não foi excluído.
Muito bem, assim chegamos ao final de mais um artigo, aguardamos você no próximo para darmos continuidade, já estamos quase no final desta série, continue conosco, um grande abraço.

Este artigo faz parte da série: CRUD Delphi + POO + MVC + DAO;

(Por ClipaTec Informática)

14 de março de 2018

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 3

crud delphi mvc dao camada view

Olá meu povo, no artigo anterior nós implementamos a camada Controller, e neste artigo, vamos retornar a nossa camada VIEW, só que desta vez, vamos iniciar a implementação dos métodos.
Para, isso, com o projeto aberto no Delphi, acesse o "FrmCadastrarCliente", e no código, logo acima da classe do formulário, vamos criar um tipo enumerado chamada "TOperacao" que utilizaremos como flag para habilitar e desabilitar controles e para nortear o botão "Gravar", então, declare-o logo acima da classe do formulário:
crud delphi mvc dao camada view

Muito bem, feito isso, agora precisamos criar um atributo na classe do formulário que armazene o valor deste tipo enumerado que utilizaremos em determinados momentos durante a execução do aplicativo. No Delphi, os atributos de uma classe são chamados de "Fields", por isso, por convenção, o nome de um "Field" sempre inicia com a letra "F", então, vamos criar dois "Fields", um para armazenar o valor do tipo enumerado "FOperacao" e outro para guardar o código do cliente que for selecionado na Grid de pesquisa "FIdSelecionado", tudo isso na seção "Private". Também, aproveitando o momento, vamos declarar nossos métodos, a implementação completa ficará assim:
crud delphi mvc dao camada view

Pressione a tecla de atalho "Shift + Ctrl + C" e vamos iniciar implementando o método "SetUp":
crud delphi mvc dao camada view

Este método será chamado assim que a tela de cadastro for aberta, desta maneira, conforme a implementação acima, ele oculta a visibilidade das abas, ativa por padrão a aba de pesquisa, e define o código "1" por padrão ao nosso Field "IdSelecionado".
Agora vamos implementar o nosso método "Pesquisar":
crud delphi mvc dao camada view

Como já deve estar bem claro na sua mente, os métodos estão na camada DAO, portanto, para que a VIEW possa consumi-los, isto é, ter acesso a eles, isso é feito por intermédio da camada Controller, então, nós precisamos criar um objeto do tipo "TClienteController" para que por meio deste objeto, tenhamos acesso ao método da DAO, pois a Controller consegue enxergá-la.
Na linha 307 declaramos nosso objeto com seu tipo, na linha 309 instanciamos ele na memória. Na linha 311, chamamos o método "Pesquisar" que pede dois parâmetros, o primeiro, o filtro da pesquisa, que é por "Nome", desta maneira, passamos o conteúdo digitado pelo usuário no "edtPesquisar", o segundo parâmetro, é a nossa "TStringGrid" da aba de pesquisa, pois a mesma será configurada e preenchida lá na camada DAO. Por fim, na linha 313 apenas liberamos o objeto da memória após sua utilização.
Agora vamos implementar o método "Novo":
crud delphi mvc dao camada view

Este método é bem simples, ele apenas define o valor do nosso field "FOperacao" para "opNovo" e ativa a aba de dados. Este método será chamada quando o usuário clicar no botão "Novo". Você vai entender melhor porque estamos definindo o valor "opNovo" para o Field quando estivermos implementando o botão "Gravar".
Seguindo, agora implementaremos o método "Detalhar":
crud delphi mvc dao camada view

Este método verifica o cliente que está selecionado na pesquisa, captura o código dele, consulta ele no banco de dados, busca todas as informações por meio do método "CarregarCliente", e em seguida, ativa a aba de dados com estas informações preenchidas nos controles. Mas note que antes, na linha 183, fazemos uma pequena verificação, se na coluna 0 e linha 1 da Grid, se existe alguma informação, caso não exista informação, significa que a pesquisa não retornou nada, então, abortamos a operação de detalhamento e emitimos uma mensagem para o usuário.
Legal, no próximo artigo, seguiremos com a implementação dos métodos, vamos ficando por aqui, qualquer dúvida, deixe seu comentário, um forte Abraço. Tchau!

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

3 de março de 2018

Cadastro Delphi POO + MVC + DAO - Camada Controller

crud delphi poo mvc dao camada controller

Oi, tudo bem com vocês? Estamos quase acabando nossa série por completo. No artigo de hoje, iremos implementar a camada Controller que é bem simples.
Sem delongas, com o projeto aberto no Delphi, crie uma nova unit e salve com o nome "uClienteController" dentro da pasta "controller".
Vamos precisar criar uma classe "TClienteController" com seus métodos, segue a implementação (não esqueça das uses):

crud delphi poo mvc dao camada controller
Agora, pressione a tecla de atalho "Shift + Ctrl + C" e implemente os métodos da seguinte maneira:

crud delphi poo mvc dao camada controller
crud delphi poo mvc dao camada controller

Note que criamos os métodos exatamente iguais a camada DAO em sua assinatura, pois como você já sabe, a camada Controller, vai ser apenas uma intermediária entre a View e DAO, ela é responsável por definir o fluxo de dados, de onde vem e para onde vai, sendo assim, ela apenas chama os métodos da DAO, repassando os mesmos parâmetros, e após a execução dos métodos na DAO, ela captura o retorno e envia para quem está chamando o método, neste caso, será a View.
Pronto, acabou. Mas já? Só isso? Tem certeza? Simmmm. Acabou hehehe. Então isso é um tchau, até o próximo artigo, onde retornaremos a camada View, só que agora, para implementar os métodos, visto que nas parte 1 e parte 2 da View já publicados apenas criamos o layout da tela de CRUD Cliente. Até lá, abraço.

Este artigo faz parte da série CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)