Data por extenso

Por vezes surge a necessidade de escrever uma data por extenso,  por exemplo na emissão de documentos como cheques, relatórios, etc.

A procedure abaixo, realiza esta tarefa de forma simples e rápida, permitindo inclusive retornar o dia da semana.


procedure TForm1.Button1Click(Sender: TObject);

var nrdia: Integer;
    diasemana: array[1..7] of String;
    meses: array[1..12] of String;
    dia, mes, ano: Word;
begin


   {Preenchendo o array diasemana com os dias da semana ...}
   diasemana[1]:= 'Domingo';
   diasemana[2]:= 'Segunda-feira';
   diasemana[3]:= 'Terça-feira';
   diasemana[4]:= 'Quarta-feira';
   diasemana[5]:= 'Quinta-feira';
   diasemana[6]:= 'Sexta-feira';
   diasemana[7]:= 'Sábado';


   {Preenchendo o array meses com dos meses do ano ... }
   meses[1]:= 'Janeiro';
   meses[2]:= 'Fevereiro';
   meses[3]:= 'Março';
   meses[4]:= 'Abril';
   meses[5]:= 'Maio';
   meses[6]:= 'Junho';
   meses[7]:= 'Julho';
   meses[8]:= 'Agosto';
   meses[9]:= 'Setembro';
   meses[10]:= 'Outubro';
   meses[11]:= 'Novembro';
   meses[12]:= 'Dezembro';


   {Decodificando a data }
   DecodeDate(DateTimePicker1.Date ,ano,mes,dia);
   nrdia:= DayOfWeek(DATE);


   {Exibindo a data por extenso em uma Edit }
   Edit1.Text:= diasemana[nrdia]+', '+INTTOSTR(dia)+' de '+meses[mes]+' de '+INTTOSTR(ano);
end;

Esta é um a dica super simples, mas bastante funcional:

Abraço e até o próximo post.

Importando arquivo CSV (Texto Delimitado)

A procedure abaixo listada permite ler qualquer arquivo de texto delimitado, quer seja por virgula, ponto e vírgula ou qualquer outro delimitador. Para tanto basta informar corretamente o delimitador na função aninhada MontaValor.
No exemplo abaixo as informações contidas no arquivo texto serão gravadas em dois ClientDataSet.

procedure TForm1.ImportarCSV;
var ArquivoCSV : TextFile;
    Contador, I : Integer;
    Linha : String;


  // Lê Linha e Monta os valores
  function MontaValor : String;
  var ValorMontado : String;
  begin
     ValorMontado := '';
     inc(I);
     While Linha[I] >= ' ' do
     begin
        If Linha[I]= ';' then  // vc pode usar qualquer delimitador ... eu estou usando o ";"
        break;
        ValorMontado := ValorMontado + Linha[I];
        inc(I);
     end;
     result := ValorMontado;
  end;


begin
   // Carregando o arquivo ...
   AssignFile(ArquivoCSV, 'c:\Nome_do_Arquivo');


   try
      Reset(ArquivoCSV);
      Readln(ArquivoCSV, Linha);
      Contador := 1;


      while not Eoln(ArquivoCSV) do
      begin
         if Contador = 1 then  // Primeira Linha do arquivo (Pedido);
         begin
            I := 0;
            cdsPedido.Append;
            cdsPedidoCodigoCliente.AsString  := MontaValor;
            cdsPedidoNomeDoCliente.AsString := MontaValor;
            cdsPedido.Post;
         end
         else
         begin
            // Demais Linhas (Itens do Pedido )
            I := 0;


            cdsItensDoPedido.Append;
            cdsItensDoPedidoCodigoProduto.AsString := MontaValor;
            cdsItensDoPedidoNomeDoProduto.AsString := AnsiUpperCase(MontaValor);
            cdsItensDoPedidoQuantidade.AsFloat     := StrToFloat(MontaValor);
            cdsItensDoPedidoPreco.AsCurrency       := StrToCurr(MontaValor);
            cdsItensDoPedido.Post;
         end;


         Readln(ArquivoCSV, Linha);
         Contador := Contador + 1;
      end;


   finally
      CloseFile(ArquivoCSV);
   end;


end;


Um grande abraço e até o próximo post.

Interface Gráfica do GIT

Olá amigos ... 

Aqueles que me acompanham sabem que sou fã incodicional do GIT e o considero como um dos melhores softwares de SCM (source code management) da atualidade. Entretanto alguns amigos sempre reclamavam de usa-lo via linha de comando ( particularmente eu gosto. Linha de comando te dá segurança e controle total da situação). 

Para esses meu amigos, vai a dica deste post: usar o comando git gui : O gui vem de graphics user interface ou seja interface gráfica com o usuário. Nesta interface você pode realizar o add + commits + push + um montão de comandos do git, tudo de forma gráfica. Eu mesmo uso bastante esse recurso. 

Quando se abre a tela no canto superior direito aparece o quadro chamado de Unstaged changes onde são mostrados os itens do repositorio que foram alterados/criados e que ainda não foram adicionados ao indice do git. Para adiciona-los ao indice basta clicar no ícone do item, o que equivale a linha de comando "git add nome_do_arquivo".  

Logo abaixo temos o quadro de Staged changes (will commit) . nesse quadro aparecem os itens que foram adicionados ao indice, porém ainda não foram commitados. Para retornar um item desse quadro para o quadro Unstaged Changes, apenas clique no seu ícone. 

Digite o texto do seu commit no quadro Commit Message e clique no botão Commit. Pronto isso equivale à linha de comando "git commit -m "mensagem do commit" " . 

Em seguida se quiser "empurrar" suas alterações para o servidor, basta clicar no botão push .

Além disso você poderá selecionar um arquivo e reverter as mudanças, deletar aquivos, gerenciar branches e muito mais através dessa ferramenta nativa do git. 

Se você ficou curioso, dê uma olhada nos menus desta ferramenta e veja as inúmeras possibilidades que ela oferece. 

No meu proximo post vou falar de outra ferramenta gráfica para trabalhar com o git ... a versão do Tortoise para o GIT ... 

Um grande abraço e até o próximo post. 

Número por Extenso

Diante da necessidade de gerar valores por extenso, pesquisando na web, deparei-me com a excelente procedure abaixo, para Firebird. 

Ela não usa UDF´s e consegue gerar extenso para valores de até 8 (oito) quatrilhões.

Ela pode ignorar a geração do extenso dos centavos, para o caso de um extenso para cheques (basta atribuir 'N' ao segundo parâmetro).
 
Parabéns ao Emersom, o autor dessa "belezura" !!!

CREATE PROCEDURE EXTENSO (
    valor numeric(18,2),
    cents char(1))
returns (
    valorextenso varchar(250))
as
declare variable cmoeda varchar(10);
declare variable cmoedas varchar(10);
declare variable ccentavo varchar(10);
declare variable ccentavos varchar(10);
declare variable cmil varchar(12);
declare variable cmils varchar(12);
declare variable cmilhao varchar(12);
declare variable cmilhoes varchar(12);
declare variable cbilhao varchar(12);
declare variable cbilhoes varchar(12);
declare variable ctrilhao varchar(12);
declare variable ctrilhoes varchar(12);
declare variable cquatrilhao varchar(12);
declare variable cquatrilhoes varchar(12);
declare variable cvalor varchar(100);
declare variable nvalor smallint;
declare variable cvalorint varchar(100);
declare variable nvalorint integer;
declare variable nvalordec  numeric(6,3);
declare variable i smallint;
declare variable nconj integer;
declare variable cletra varchar(1);
declare variable caux varchar(200);
declare variable extensocentavos varchar(100);
declare variable separador varchar(3);
declare variable extensoconj varchar(150);
declare variable cdig1 varchar(10);
declare variable cdig2 varchar(10);
declare variable cdig3 varchar(10);
declare variable centenas char(108) = 'CENTO       DUZENTOS    TREZENTOS   QUATROCENTOSQUINHENTOS  SEISCENTOS  SETECENTOS  OITOCENTOS  NOVECENTOS  ';
declare variable dezenas char(79) = 'DEZ      VINTE    TRINTA   QUARENTA CINQUENTASESSENTA SETENTA  OITENTA  NOVENTA  ';
declare variable unidades char(54) = 'UM    DOIS  TRES  QUATROCINCO SEIS  SETE  OITO  NOVE  ';
declare variable unid10 char(81) = 'ONZE     DOZE     TREZE    QUATORZE QUINZE   DEZESSEISDEZESSETEDEZOITO  DEZENOVE ';
declare variable extensounidade varchar(12);
declare variable extensodezena varchar(12);
declare variable extensocentena varchar(12);
declare variable vlrextenso varchar(250);
begin
  if (cents is null) then cents = 'S';
  cents = UPPER(cents);
 
  -- poderia ter deixado esses valores fixos,
  -- mas preferi em variáveis
  cMil = 'MIL'; cMils = 'MIL';
  cMilhao = 'MILHÃO'; cMilhoes = 'MILHÕES';
  cBilhao = 'BILHÃO'; cBilhoes = 'BILHÕES';
  cTrilhao = 'TRILHÃO'; cTrilhoes = 'TRILHÕES';
  cQuatrilhao = 'QUATRILHÃO'; cQuatrilhoes = 'QUATRILHÕES';
  cMoeda = 'REAL'; cMoedas = 'REAIS';
  cCentavo = 'CENTAVO'; cCentavos = 'CENTAVOS';
  Separador = ' ';
 
  -- valores a serem utilizados para geração do extenso
  nValorInt = cast(valor/100*100 as integer);
  nValorDec = (Valor - Cast(nValorInt as numeric(18,3))) / 10;
  cAux = Cast(nValorDec as varchar(100));

  cValorInt = Cast(nValorInt as varchar(100)) || Substring(cAux from 3 for 3);
 
  -- inverto o número. assim fica mais fácil trabalhar
  -- pois não haverá necessidade de UDF's
  cLetra = Substring(cValorInt from 1 for 1);
  cAux = cValorInt;
  cValorInt = '';
  while (cAux <> '') do
  begin
    cValorInt = (cLetra || cValorInt);
    cAux = Substring(cAux from 2 for 100);
    cLetra = Substring(cAux from 1 for 1);
    if (cLetra = '') then cLetra = ' ';
  end
 
  -- obtenho os subconjuntos de números, de 3 em 3,
  -- para formar o extenso, que poderá chegar aos quatrilhões
  nConj = 1;
  extensocentavos = '';
  vlrextenso = '';
 
  if (Valor <> 0) then
  begin
    while (cValorInt <> '') do
    begin
      cValor = '';
      i = 1;
      while (i <= 3) do
      begin
        cLetra = Substring(cValorInt from 1 for 1);
        if (cLetra = '') then cLetra = ' ';
        cValor = (cLetra || cValor);
        cValorInt = Substring(cValorInt from 2 for 100);
        i = (i + 1);
      end
 
      nValor = Cast(cValor as smallint);
 
      cDig1 = Substring(cValor from 1 for 1);
      cDig2 = Substring(cValor from 2 for 1);
      cDig3 = Substring(cValor from 3 for 1);
 
      extensounidade = '';
      extensodezena = '';
      extensocentena = '';
 
      -- obtenho o extenso da unidade
      if (cDig3 > '0') then
      begin
        cAux = cast((cast(cDig3 as integer) * 6 - 5) as varchar(3));
        cAux = 'select cast(Substring(''' || unidades || ''' from ' || cAux || ' for 6) as varchar(12)) from rdb$database';
        execute statement cAux into :extensounidade;
      end
 
      -- obtenho o extenso da dezena
      if (cDig2 > '0') then
      begin
        if ((cDig3 > '0') and (cDig2 = '1')) then
        begin
          extensounidade = '';
          cAux = unid10 || ''' from ' || cast((cast(cDig3 as integer) * 9 - 8) as varchar(3));
        end
        else
          cAux = dezenas || ''' from ' || cast((cast(cDig2 as integer) * 9 - 8) as varchar(3));
        cAux = 'select cast(Substring(''' || cAux || ' for 9) as varchar(12)) from rdb$database';
        execute statement cAux into :extensodezena;
      end
 
      -- obtenho o extenso da centena
      if (cDig1 > '0') then
      begin
        if (nValor = 100) then
          extensocentena = 'CEM';
        else
        begin
          cAux = cast((cast(cDig1 as integer) * 12 - 11) as varchar(3));
          cAux = 'select cast(Substring(''' || centenas || ''' from ' || cAux || ' for 12) as varchar(12)) from rdb$database';
          execute statement cAux into :extensocentena;
        end
      end
 
      -- faço a montagem do extenso do conjunto
      if (extensounidade <> '') then
        extensoconj = extensounidade;
      else
        extensoconj = '';
 
      if (extensodezena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensodezena || ' E ' || extensoconj;
        else
          extensoconj = extensodezena;
      end
 
      if (extensocentena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensocentena || ' E ' || extensoconj;
        else
          extensoconj = extensocentena;
      end
 
      -- adiciono os devidos sufixos de cada conjunto
      if (nValor > 0) then
      begin
        if (nConj = 1) then -- centavos
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' ||ccentavos;
          else
            extensoconj = extensoconj || ' ' || ccentavo;
        end
 
        -- obs.: o conjunto 2 não precisa ser avaliado, pois
        --       nele NÃO há necessidade de acrescentar sufixo
 
        if (nConj = 3) then -- milhares
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMils;
          else
            extensoconj = extensoconj || ' ' || cMil;
        end
        else
        if (nConj = 4) then -- milhoes
        begin
        if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMilhoes;
          else
            extensoconj = extensoconj || ' ' || cMilhao;
        end
        else
        if (nConj = 5) then -- bilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cBilhoes;
          else
            extensoconj = extensoconj || ' ' || cBilhao;
        end
        else
        if (nConj = 6) then -- trilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cTrilhoes;
          else
            extensoconj = extensoconj || ' ' || cTrilhao;
        end
        else
        if (nConj = 7) then -- quatrilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cQuatrilhoes;
          else
            extensoconj = extensoconj || ' ' || cQuatrilhao;
        end
 
        if ((vlrextenso = '') and (nConj > 3)) then
          extensoconj = extensoconj || ' DE ';
      end
 
      -- avalio qual será o separador de conjuntos
      if (nConj < 4) then
        Separador = ' E ';
      else
        Separador = ', ';
 
      -- gero o extenso dos 'inteiros' e dos centavos
      if (nConj = 1) then -- centavos
        extensocentavos = extensoconj;
      else
      if (extensoconj <> '') then
      begin
        if (vlrextenso <> '') then
          vlrextenso = extensoconj || Separador || vlrextenso;
        else
          vlrextenso = extensoconj;
      end
 
      nConj = nConj + 1;
    end
 
    -- depois de tudo avaliado...
    -- acrescento a moeda
    if (nvalorint > 0) then
    begin
      if (nvalorint > 1) then
        vlrextenso = vlrextenso || ' ' || cmoedas;
      else
        vlrextenso = vlrextenso || ' ' || cmoeda;
    end
 
    -- monto o extenso completo: inteiros mais os centavos.
    -- obs.: a inclusão dos centavos é controlada pela variável
    -- 'cents'. fiz assim pois pode ser uma geração de extenso
    -- para cheques, que não destacam os centavos no extenso
    if ((extensocentavos <> '') and (cents = 'S')) then
    begin
      if (vlrextenso <> '') then
        vlrextenso = vlrextenso || ' E ' || extensocentavos;
      else
        vlrextenso = extensocentavos;
    end
  
    -- limpo a variavel de retorno, pois ainda preciso trabalhar os 'espaços'
    valorextenso = '';
 
    -- retiro os espacos desnecessários e populo a variável de retorno.
    -- obs.: fiz com while pra não precisar de UDF's
    cLetra = Substring(vlrextenso from 1 for 1);
    cAux = '';
    while (vlrextenso <> '') do
    begin
      cLetra = Substring(vlrextenso from 1 for 1);
      vlrextenso = Substring(vlrextenso from 2 for 250);
      if ((cLetra <> ' ') or ((cLetra = ' ') and (cAux <> ' ')))  then
        valorextenso = valorextenso || cLetra;
      cAux = cLetra;
    end
  end
  else
    valorextenso = 'ZERO';
 
  -- exibe o resultado
  suspend;
end

-----

Veja o Post Original em http://www.firebase.com.br/fb/artigo.php?id=2078

Dicas da IDE do Delphi - Parte 05

Olá amigos ... finalizando a série de dicas sobre a IDE do Delphi, seguem as duas últimas dicas:


Dica 09 - Re-factoring

O re-factoring agrupa algumas funções que podem ser facilmente chamada pelas suas teclas de atalho e  que  facilitam o trabalho do desenvolvedor de diversas maneiras. Algumas delas: 

- Rename (CTRL + SHIFT + E) - Rename :  Faz uma busca no código da palavra selecionada e lista as mesmas para que se decida se quer ou não aplicar as alterações.

- Declare variable (CTRL + SHIFT + V) - Declare variable : Cria uma variável durante a escrita do código sem ter que voltar no início do método e declarar. 

- Declare field (CTRL + SHIFT + D) - Declare field : Cria um field durante a escrita do código sem ter que declará-lo incialmente. 

- Extract Method (CTRL + SHIFT + M) - Extract Method : Extrai um determinado bloco de código e o transforma em um método. No lugar onde haviam as linhas retiradas é colocada a chamada para o método. 

- Find Unit - Find Unit : Encontra a unit e a declara. Ele permite escolher a seção que ela deve ser declarada. 

Dica 10  - Options Delphi 2006

Nessa versão as opções “Environment Options”, “Editor Options”, “Debugger Options” foram reorganizadas para ficarem em apenas um lugar, ou seja, em Tools > Options.

Figura 8. Janela options do delphi 2006 

      Vejamos alguns exemplos de configurações que podem ser feitas através do Options:

Options > Environment Options > VCL Designer > Module Creation Options > New forms as a text: Essa opção deve estar marcada para que o arquivo do formulário (dfm) seja gravado como texto e não como binário.

Options > Environment Options > VCL Designer > Module Creation Options > Auto create forms e data modules: Essa opção deve estar marcada para que os formulários e data modules sejam criados automaticamente.

Options > Environment Options > VCL Designer > Options > Embedded designer : Se essa opção estiver marcada os formulários ficarão suspensos.

Options > Editor Options > Source Options > Options > Block indent : Seta a indentação para as teclas de atalho Ctrl + Shift + I/U.

Options > Debugger Options > General > Integrated debugging : Se essa opção estiver desmarcada não será feito mais debug para nenhum projeto.

Options > Debugger Options > General > Mark buffers read-only on run : Se essa opção estiver marcada não será permitido editar o código da unit em tempo de execução.

Estes foram apenas algumas funcionalidades da IDE. Existem muitas outras que podem até se encaixar melhor com a sua realidade de trabalho e suas necessidades pessoais e com o gosto pessoal de cada desenvolvedor. 

Experimente navegar pelo Help do Delphi, você descobrirá muita coisa “bacana”. Além disso existe também muito material sobre o assunto disponível na DevMedia e na Internet.  Pesquise, busque e compartilhe suas formas pessoais de interagir com o ambiente Delphi.

Um grande abraço e até o próximo artigo.

Dicas da IDE do Delphi - Parte 04

Olá amigos ... mais um artigo da série Dicas da IDE do Delphi

Dica 06 - Collapsible Regions (Delphi 2006 e posteriores) 

Este recurso está presente no Delphi 2006 e versões posteriores e é bastante útil para gerenciamento do código, permitindo que sejam criados blocos de códigos (as Regions) que podem ser expandidos ou recolhidos de acordo com a necessidade do desenvolvedor, assim conseguimos visualizar nosso código de maneira muito mais eficaz, tornando extensos trechos de código em apenas uma linha, facilitando o entendimento do código.

Para criar um region basta digitar {$ REGION } antes do bloco de código desejado e no final do bloco de código digite {$ENDREGION}.

Ao lado de cada REGION surgirá  um botão de “+” ou “-” para que o código possa ser expandido ou escondido.  

 

Figura 5. visualizando as Regions

Dica 07 - SyncEdit (Delphi 2006 e posteriores)  

Já imaginou a situação de ter uma variável citada em diversas partes da Unit e precisar alterar o seu nome. Ou ainda realizar a correção do nome de um método chamado em vários pontos do código.  Isso é facilitado pelo recurso de SyncEdit (edição sinconizada), que faz uma varredura no bloco de código selecionado encontrando as palavras iguais ou similares.  

Para chamar o SyncEdit basta selecionar um bloco de código e teclar Shift+Ctrl+J. Irá aparecer um símbolo e para alterar o nome desejado basta andar com o tab e posicionar em cima da palavra, alterá-la e essa alteração será feita para todas as palavras iguais dentro do bloco selecionado. 

Figura 6. visualisando recurso SyncEdit

Dica 08 - Surround (Delphi 2006 e posteriores) 

Este também é um recurso muito interessante, pois transforma  o bloco de código selecionado em  uma nova estrutura,  que poderá ser um bloco begin/end, uma procedure,  uma function, uma region, etc.  

Como exemplo prático imagine que você tenha um código extenso e deseje transformar partes desse código em novos métodos ... para isso basta selecionar o código e no  menu POP-UP escolher a opção Surround / procedure. A IDE realiza todos os procedimentos de criação do método. O desenvolvedor deverá apenas informar o nome da nova procedure.

Figura 7. Opções de Sorround  

Um grande abraço e até o próximo post. 

Instalar ZeosLib no Delphi 2009 e Delphi 2010

Na minha opinião um dos melhores componentes para acesso a banco de dados é o Zeoslib. Além de fornecer acesso à diversos SGDB, esse componente é open source o que eu considero uma grande vantagem frente à outros componentes.

Já utilizava este componente para acessar o Firebird com o Delphi 7. 

Decidido a atualizar meu código para uma versão mais recente do Delphi, optei pelo 2009 e fui em busca de uma versão do Zeoslib compatível com essa versão do Delphi. tentei usar as versões estáveis disponíveis no site da Souce Forge, (6.6.4, 6.6.6, etc) mas sempre ocorria um erros de type cast no momento de compilar as packages, então acabei optando pela versão 7.0.0 Alpha, que tem funcionado perfeitamente. 

Para facilitar a vida de quem pretenda usar essa versão, abaixo segue o caminho das pedras. 

1 - Faça o download do arquivo (link para download)

2 - Crie uma pasta chamada Zeos7 dentro da pasta Lib do RAD Studio. Por exemplo, meu RAD Studio esta em C:\Program Files\CodeGear\RAD Studio\6.0\lib, então meu diretório base será: C:\Program Files\CodeGear\RAD Studio\6.0\lib\zeos7 

3 - Descompacte os arquivos dentro do diretório recem criado no ítem 2. 

4 - Com o Delphi 2009/2010 aberto, vá em File -Open Project (Ctrl+F11) e abra o arquivo ZeosDbo.GroupProj, dentro de C:\Program Files\CodeGear\RAD Studio\6.0\lib\zeos7\packages\delphi12 

5 - Vá ao menu Project - Build All Projects 

6 - Antes de continuar, se você estiver usando o Windows Vista ou Windows 7 com o UAC habilitado, você terá que dar permissão TOTAL para a pasta Zeos7 criada, caso contrário não irá funcionar. 

7 - Agora, antes da instalação vá ao menu Tools - Options - Evironment Options - Delphi Options - Library - Win 32 e adicione o caminho a seguir no Library Path: $(BDS)\lib\Zeos7\packages\delphi12\build 

8 - Feito isto, minimize o Delphi, abra o diretório C:\Program Files\CodeGear\RAD Studio\6.0\lib\zeos7\packages\delphi12\build, selecione todos os arquivos ".bpl" copie-os e cole-o dentro da pasta Bpl do RAD Studio: C:\Users\Public\Documents\RAD Studio\6.0\Bpl 

9 - Volte ao Delphi vá ao menu View - Project Manager (Ctrl + Atl + F11). Selecione e compile as bpls abaixo, uma a uma. Para compilar, clique com o botão direto sobre o bpl. É a primeira opção.

- ZCore120.Bpl

- ZPlain120.Bpl

- ZParseSql120.Bpl

- ZDbc120.Blq

- ZComponent120.Bpl

- ZComponentDesign120.Bpl

10 - Depois de compiladas, clique com o botão direito sobre o pacote ZComponentDesign120.Bpl (o único em negrito) e clique em Install. 

11 - Pronto, feche tudo (File - Close All). Crie um novo projeto e veja que os componentes já podem ser utilizados.

Dicas da IDE do Delphi - Parte 03

Dando seguimento à série de artigos com dicas sobre a IDE do Delphi, aqui vai a terceira parte

Dica 04 - Desktops

Normalmente o desenvolvedor gosta de personalizar sua área de trabalho colocando os itens que mais costuma utilizar, ocultando ou exibindo barras de ferramentas, janelas, etc.  O leiaute da tela depois de  ajustado pelo desenvolvedor  será   salvo clicando-se  em View > Desktops > save desktop. 

O desenvolvedor pode criar Leiautes para diversos momentos do desenvolvimento, como por exemplo um leiaute de debug, um leiaute de edição, e seleciona-los de acordo com sua necessidade ou conveniência.

Figura 3. Visualisando os Desktops existentes na IDE

Dica 05 - Structure view (Shit + alt + F11)

Na versão 7 do Delphi esse recurso é chamado de  Objetct Tree View.

A structure view mostra a hierarquia do código fonte e os componentes mostrados no designer, permitindo acesso rápido aos componentes do form.  Isso é bastante útil quando temos forms com muitos componentes  e por vezes acabamos nos perdendo ao tentar localizar um deles “no olho”.

Através da structure view podemos realizar uma busca digitando no nome do componente e ele será selecionado no form.

Outra facilidade é que quando realizamos um duplo clique no componente na Structure View a IDE nos leva para o código fonte.

Se um componentes está em determinado container e desejarmos colocá-lo em basta arrastá-lo dentro da structure view para o novo dono a quem ele deve pertencer. 

Figura 4. Painel da Structure view 

Dicas da IDE do Delphi - Parte 02

Dando seguimento à série de artigos com dicas sobre a IDE do Delphi, aqui vai a segunda parte

Dica 02 - To-Do list 

Quem nunca disse pra si mesmo ... "depois eu tenho que voltar nesse método para corrigi-lo" ... e depois se esqueceu completamente disto ... O Delphi disponibiliza um recurso muito interessante para resolver este problema o To-Do list. Quando chamado o To-Do (botão direito “Add To-Do ou Ctrl+Shift+T) ele abre-se  uma tela onde deve ser informado: o que precisa ser feito, a prioridade, o dono da tarefa e a categoria. Depois ele insere “To-Do” na frente do texto para o ele foi chamado. para ver a lista de tarefas a realizar (To-Do) , selecione Menu View > To-Do List. 

Figura 1. Janela de adição do To-Do Item

Dica 03 - Bookmarks

Debugando funcionalidades, ou mesmo apenas navegando pelo código, por vezes temos que cumprir um ritual de ir e vir pelas linhas de uma determinada Unit.  Ficar teclando seta para cima ou para baixo, Page down  ou Page up, pode tornar-se chato e cansativo. Para solucionar este problema use um Bookmark. Os bookmarks facilitam a navegação no código através de marcações que são numeradas de 0 a 9. 

Para marcar basta clicar na linha desejada, clicar com o botão direito e selecionar “Toggle Bookmarks”.

Quando quiser voltar nessa linha basta clicar com o botão direito e selecionar “Goto Bookmarks” que ele irá posicionar na linha desejada.  

Figura 2. Visualizando a opção Bookmark s

Dicas da IDE do Delphi - Parte 01

Uma IDE, do inglês Integrated Development Environment ou Ambiente Integrado de Desenvolvimento, é um programa de computador que reúne características e ferramentas de apoio ao desenvolvimento de software com o objetivo de agilizar este processo.

Geralmente as IDEs facilitam a técnica de RAD (de Rapid Application Development, ou "Desenvolvimento Rápido de Aplicativos"), que visa a maior produtividade dos desenvolvedores.

Entre as características e ferramentas mais comuns encontradas nos IDEs temos o  Editor de código onde o desenvolvedor escreve o código-fonte do programa  na(s) linguagem(ns) suportada(s) pela IDE e que muitas vezes é confundido como sendo a totalidade da IDE, mas ainda existem outras ferramentas como o compilador, o linker, o depurador, entre outras;

Durante o processo de evolução da IDE  do Delphi, muito recursos foram adicionados visando aumentar a produtividade do desenvolvedor. Porém, em minha experiência como desenvolver e Instrutor de Delphi, pude notar que a grande maioria dos programadores iniciantes e até mesmo boa parte de programados “antigos” conhece apenas os recursos básicos da IDE, deixando assim de aproveitar as  inúmeras facilidades disponibilizadas pela ferramenta e acabam perdendo tempo em atividades que poderiam ter sua implementação bastante facilitada utilizando mais os recursos  da IDE. 

Neste artigo vou explorar alguns desses recursos que apesar de simples podem poupar tempo durante o processo de desenvolvimento.  

Não tenho a pretensão de esgotar o assunto uma vez que em apenas 10 dicas não seria possível trazer a enorme quantidade de ferramentas, opções e recursos disponíveis na IDE.

Compartilho aquelas que mais utilizo e que me são mais úteis no meu trabalho diário.

Dica 01 - Code Templates

Os Codes Templates fornecem meios de automatizar tarefa de digitação e rotinas de códigos, que se repetem freqüentemente em um desenvolvimento de uma aplicação.  Já existe no Delphi uma lista de Templates que pode ser vista através da combinação das teclas < Ctrl + J >.

A IDE do nos permite criar novos Code Template, que conterá um bloco de códigos digitado por nós, para que possamos usá-lo em qualquer parte de nosso projeto.

Se você utiliza sempre da mesma estrutura em diversas partes do código e ela ainda não faz parte das várias code templates do Delphi, crie a sua e facilite sua vida. 

Performance em ClientDataSet com campo BLOB

dica enviada por meus colegas de trabalho Suzana e Weverton

Estavamos com um problema de desempenho ao dar um open em um ClientDataSet. demorava algo em torno de 20 segundos para trazer 19 mil registros.

O curioso é que via ibExpert demorava apenas 16 milisegundos.

Fazendo testes descobrimos que a demora era causada por um campo BLOB.

A solução foi setar a propriedade "poFetchBlobOnDemand" do DataSetProvider para TRUE.

O resultado? agora demora apenas 1 (um) segundo para trazer os 19 mil registros!

Fica aí a dica ...