Pontos e Vírgulas

Trocar ponto por vírgula, ou vírgula por ponto, muitas vezes precisamos desse código para o preenchimento de um cadastro.
É necessário atenção. O código é bem simples e fácil.

Trocar o PONTO pela VÍRGULA

No Evento OnKeyPress da Caixa de Texto (TEdit):

procedure TForm1.TEdit1KeyPress(Sender: TObject; var Key: Char);
begin
if Key in [',','.'] then
Key := DecimalSeparator;
end;


Trocar a VÍRGULA pelo PONTO

No Evento OnKeyPress da Caixa de Texto (TEdit):

procedure TForm1.TEdit2KeyPress(Sender: TObject; var Key: Char);
begin
if Key in ['.',','] then
Key := '.';
end;

********************************************************************
Faça o download do arquivo: Ponto e Virgula.rar
********************************************************************

"A vida é para quem topa qualquer parada.
Não para quem pára em qualquer topada." Bob Marley.

[...] Continue Lendo...

Calculando Percentual

Entre uma rotina e outra, as vezes é necessário efetuarmos cálculo de percentual.
Para calcular o percentual (%) de um determinado valor, insira essa função

no projeto:

function GeraPercentual(Valor:real;Percent:Real):real;
{Retorna a porcentagem de um valor}
begin
percent := percent / 100;
try
valor := valor * Percent;
finally
result := valor;
end;
end;

Para fazer a chamada dessa função, em um botão coloque o código:
-> GeraPercentual(Valor:real;Percent:real);

-> Em Valor, indique o valor correspondente;
-> Em Percent, indique a % correspondente.

Exemplo do valor 300 com % 2 -> GeraPercentual(300;2);
O Resultado será = 6.



Observe no código fonte, como a função é aplicada ao projeto.
Faça o download do arquivo.

Código Fonte
Neste exemplo, utilizei 3 caixas de textos, uma para Valor, outra para %, e a terceira para Resultado. E também utilizei um Botão (TBitbtn) para fazer a chamada da função.
Nome do Botão -> btCalcular;
Nome da Caixa de Texto 1 -> mValor;
Nome da Caixa de Tetxo 2 -> mPercent;
Nome da Caixa de Texto 3 -> mResult.

Declare a Função:
function GeraPercentual(Valor:real;Percent:real):real;
...
implementation
{$R *.dfm}
...

{Código da Função}
function TForm1.GeraPercentual(valor:real;Percent:Real):real; {Retorna a porcentagem de um valor}
begin
percent := percent / 100;
try
valor := valor * Percent;
finally
result := valor;
end;
end;

{Código do Botão Calcular}
procedure TForm1.btCalcularClick(Sender: TObject);
var Valor, Percent : real;
begin
{ShowMessage(FloatToStr(GeraPercentual(300,2)));}

{Limpando variáveis}
Valor := 0;
Percent:= 0;

{Previnindo possíveis erros}
if mValor.Text = '' then mValor.Text := '0';
if mPercent.Text = '' then mPercent.Text := '0';

{Convertendo dados das Edits Valor e Percent para Real}
Valor := StrToFloat(mValor.Text);
Percent := StrToFloat(mPercent.Text);

{Chama Função GeraPercentual}
mResult.Text := FloatToStr(GeraPercentual(Valor,Percent));
end;

Observação: Para não dá erro de Ponto Decimal, troque o "ponto" pela "vírgula" nas caixas de texto.
No Evento KeyPress de cada Edit, coloque o código:
if Key in [',','.'] then Key := DecimalSeparator;

********************************************************************
Faça o download do arquivo: Calculando Percentual.rar
********************************************************************

"Comece fazendo o que é necessário,
depois o que é possível,
e derrepente você estará fazendo o impossível." S. Francisco de Assis.

[...] Continue Lendo...

Montando Arquivo XML x NF-e

Para quem deseja começar a preparar o sistema da NF-e (Nota Fiscal Eletrônica), aqui vai uma dica muito interessante: como montar parte da estrutura XML

.

É importante lembrar que, a NF-e utiliza muito mais que isso. Não é só a estruturação do arquivo XML que é necessário, mas sim todo processo de validação dos dados, assinatura do arquivo, certificado etc.

Mas aqui falaremos apenas sobre a estrutura inicial do XML.
Neste exemplo a seguir será mostrado como: adicionar um nó; e como adicionar um nó como filho de outro nó.

Breve explicação do que será feito:
>> Vamos declarar uma variável do tipo IXmlNode, ela será chamada de "Root", e será usada por vários procedimentos.

>> Criaremos três procedimentos: CabecalhoXML; Informacao1 e Informacao2.
No CabecalhoXML é onde será criado todo o cabeçalho do arquivo XML.
Em Informacao1 e Informacao2, é onde irá conter os dados que irá compor o arquivo.

>> Criaremos uma função: CriaDirCaminho(const NomeSubDir: string): boolean;
Essa função é para criar uma pasta (no nosso exemplo, será a pasta "TESTE") em um diretório qualquer informado (no nosso exemplo, será no diretório "H", mude para um de sua preferência).

>>E adicionaremos um botão no formulário: nele será colocado informações de entrada e saída do arquivo XML.

Eis o significado de alguns termos que será utilizado na codificação:
XMLDocument1 -> é o componente do XML.
IXmlNode -> é como se fosse o raiz, nele contém os nós filhos do XML.
AddChild -> Adiciona um elemento filho à um nó XML
NodeValue -> Retorna o valor do nó do objeto XML.
Resumindo: na verdade são árvores de nó em qual cada nó é um elemento.

Iniciando o projeto:
Abra o Delphi.
Na aba INTERNET, adicione ao formulário um TXMLDocument.


Adicione um botão, onde será armazenado o código.

Vamos a codificação:
Crie os três procedimentos: procedure CabecalhoXML; procedure Informacao1; procedure Informacao2;
E uma função: CriaDirCaminho(const NomeSubDir: string): boolean;
Declare a variável como global ---> Root : IXmlNode;

Atenção aos códigos:

Esse é o código da função para criar uma Pasta no diretório:
function TForm1.CriaDirCaminho(const NomeSubDir: string): boolean;
var Dir : string;
begin
Dir := 'H:'+'\'+NomeSubDir;

if not DirectoryExists(Dir) then
ForceDirectories(Dir);
end;

Código do procedimento de CabecalhoXML:
procedure TForm1.CabecalhoXML;
var versao : real;
id : integer;
begin
//Transformando "," em "." (vírgula em ponto)
DecimalSeparator := '.';

//Preenchendo variáveis:
id := 12345;
versao:= 1.00;

XMLDocument1.Options := [doNodeAutoIndent];

//Ativa XML
XMLDocument1.Active := True;

//Cabeçalho
XMLDocument1.Encoding := 'utf-8';
XMLDocument1.Version := '1.0';

//Declara o Namespace (se houver)
Root := XMLDocument1.addChild('Delphizinho','http://www.delphizinho.blogspot.com');

//Identificação (se houver)
Root := Root.AddChild('atributos');
Root.Attributes['Id'] := id;
Root.Attributes['versao'] := FormatFloat('0.00', versao);

//Retornando "." para "," (ponto para vírgula)
DecimalSeparator := ',';
end;


Código do procedimento de Informacao1:
procedure TForm1.Informacao1;
begin
//ROOT raiz de informacao1
//AddChild -> Início do nó em informacao1
with Root.AddChild('informacao1') do begin
AddChild('nome').NodeValue := 'Carlos Felizberto Assis';
AddChild('idade').NodeValue := '30';
AddChild('sexo').NodeValue := 'Masculino'
end; //fim de informacao1
end;

Código do procedimento de Informacao2:
procedure TForm1.Informacao2;
begin
//ROOT raiz de informacao2
//AddChild -> Início do nó em informacao2
with Root.AddChild('informacao2') do begin
AddChild('telefone').NodeValue := '(021)5555-5555';
AddChild('celular').NodeValue := '(021)8888-8888';

//AddChild -> Adiciona um nó como filho de outro nó
with AddChild('endereco') do begin
AddChild('rua').NodeValue := 'Rua da Felicidade';
AddChild('numero').NodeValue := 's/n';
AddChild('complemento').NodeValue := 'quadra 5000'
end; //fim de endereco

AddChild('observacao').NodeValue := 'sem observacao';
end; //fim de informacao2
end;

Código do procedimento do Botão:
procedure TForm1.BitBtn1Click(Sender: TObject);
var Nome_Arquivo, Caminho : string;
begin
XMLDocument1.Active := False;
XMLDocument1.XML.Clear;

//Cria pasta Teste1 no diretório H (caso não exista)
CriaDirCaminho('Teste'); //função para criar a pasta Teste

//Preenchendo variáveis:
Nome_Arquivo := ''; //limpa
Nome_Arquivo := 'Teste1'; //Indica nome do arquivo XML
Caminho := ''; //limpa
Caminho := 'H:\Teste'; //Indica caminho a ser gravado o XML

//Chamada do Cabeçalho:
CabecalhoXML;

//Chamada de dados de Informacao1:
Informacao1;

//Chamada de dados de Informacao2:
Informacao2;

//Salva o arquivo XML
XMLDocument1.SaveToFile(Caminho+'\'+Nome_Arquivo+'.xml');

ShowMessage('XML '+Nome_Arquivo+' gerada com sucesso na pasta '+Caminho);
btSair.SetFocus;
end;


Depois de executado o código, o arquivo teste1.xml foi criado (conforme nosso exemplo) no caminho: "H:\Teste".
Dê um duplo clique no arquivo, para visualizá-lo no navegador.

Se for pelo navegador Firefox, basta clicar direto.
Pronto, já está sendo exibido corretamente. Clique nas abas "-" para ocultar e na aba "+" para exibir as informações contidas em cada nó:



Se for visualizar pelo navegador IE, faça:
Serão necessários alguns ajustes, para ele exibir corretamente o XML. Clique na barra amarela:


2- Controle ActiveX, é necessário executar, clique em "Permitir Conteúdo Bloqueado...":


3- Nessa pergunta, responda "SIM":


4- Pronto, já está sendo exibido corretamente. Clique nas abas "-" para ocultar e na aba "+" para exibir as informações contidas em cada nó:


5- Exemplo de algumas informações ocultadas pelas abas:


Fiz testes em alguns navegadores (Safari, Firefox, Chrome, IE), e constatei que o IE e o Firefox são os que o exibem corretamente (em forma identada (com as abas "-" e "+" de controle) e exibe conteúdo do código chamado em xml). Pois os outros mostram a informação direta (somente o resultado final).
----------------------------------------------------------------------------------

Na NF-e este exemplo (da parte do Cabeçalho) ficaria do seguinte modo:
o Root:
Root:= XMLDocument1.addChild('NFe','http://www.portalfiscal.inf.br/nfe');

Definição de Relações. Identificação da NF-e e Versão do Leiaute:
Id:= 'NFe'+chaveNFe; //variável recebe palavra "NFe" + a chave.

Root := Root.AddChild('infNFe');
Root.Attributes['Id'] := id;
Root.Attributes['versao'] := FormatFloat('0.00', versao);

id -> é a chave da NF-e;
versao-> é a versão do aplicativo (conforme o layout estabelece).

Observe, que nesse exemplo, o nó "Delphizinho" é o geral, nele contém: nó "atributos";
O nó "atributos" contém: nó "informacao1" e nó "informacao2";
O nó "informacao2", contém: nó "endereco".

Nos exemplos dos procedimentos Informacao1 e Informacao2, para aplicar à NF-e, é só substituir conforme o layout pede.

Onde obter mais informação sobre XML:
-> Site da W3C http://www.w3c.org/XML/

************************************************
Faça o download do arquivo: XML.rar
************************************************

"Uma viagem de mil léguas começou
com o primeiro passo." Lao Tsé.

[...] Continue Lendo...

Movimentando Objetos Livremente

Hoje, vamos aprender como movimentar (arrastar) qualquer objeto na tela do formulário, utilizando apenas o mouse. Para o objeto ser arrastado em qualquer direção, são necessários alguns ajustes.

Neste exemplo, vamos utilizar uma Label

(TLabel da Paleta Standart) e um Botão (TBitBtn da Paleta Additional).
Nome do formulário será: FMovObj.

>> Vamos precisar de três procedimentos: ControlMouseDown, ControlMouseUp, ControlMouseMove;
>> De uma classe TMoveControle do tipo TControl;
Observação: A classe TMoveControle será declarado em Type.
>> E de três variáveis: moveX, moveY do tipo Inteiro (integer) e mover do tipo (boolean). Essas variáveis são globais.

Definições:
>> Type -> com esta clausula podemos declarar Novos Tipos e/ou Classes.
>> Variáveis Globais -> declaradas da Interface da Unit. Podem ser acessadas por qualquer Unit usuária.

Como o entendimento desse código é um pouco mais complicado, colocarei aqui toda a Unit.

unit uMovObj;

interfaceuses
Classes, Controls, StdCtrls, Forms, Buttons;

type
TFMovObj = class(TForm)
Label1: TLabel;
BitBtn1: TBitBtn;
Label2: TLabel;

{Procedimentos para o objeto se mover}
procedure ControlMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
procedure ControlMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
procedure ControlMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

private
{ Private declarations }
public
{ Public declarations }
end;

var
FMovObj: TFMovObj;

{variáveis necessárias}
moveX, moveY: Integer;
mover: boolean;

implementation
{$R *.dfm}

{-----------------------------------------------------
{ Iniciando codificação de Movimentação de Objetos.
{----------------------------- ------------------------}
{Mover Componentes RunTime}
type
TMoveControle = class(TControl);

procedure TFMovObj.ControlMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
moveX := X;
moveY := Y;
mover := True;
TMoveControle(Sender).MouseCapture := True;
end;

procedure TFMovObj.ControlMouseMove(Sender: TObject;
Shift: TShiftState; X, Y: Integer);
begin

if mover then begin

with Sender As TControl Do
Begin
Left := X-moveX+Left;

Top := Y-moveY+Top;

End;
end;
end;

procedure TFMovObj.ControlMouseUp(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
if mover then begin
mover := False;
TMoveControle(Sender).MouseCapture := False;
end;
end;
{-----------------------------------------------------
{ Finalizando codificação de Movimentação de Objetos.
{-----------------------------------------------------}

Para que cada objeto que colocamos na tela (Label, Botão) funcione, é preciso linka-los com os procedimentos codificados.

-----------------------
Linkando a Label -> Selecione a Label, e em Eventos faça:

-> No Evento OnMouseDown, selecione a procedure ControlMouseDown.

-> No Evento OnMouseMove, selecione a procedure ControlMouveMove.

-> No Evento OnMouseUp, selecione a procedure ControlMouseUp.

-----------------------
Linkando o Botão -> Selecione o Botão, e em Eventos faça:

-> No Evento OnMouseDown, selecione a procedure ControlMouseDown.

-> No Evento OnMouseMove, selecione a procedure ControlMouveMove.

-> No Evento OnMouseUp, selecione a procedure ControlMouseUp.

Dica Importante: Ao selecionar a procedure no Evento do objeto, dê um duplo-clique na procedure selecionada até que seja exibido o código da procedure na janela da Unit, para que o Delphi reconheça o código a ser linkado.

Exemplo, ao selecionar no Evento OnMouseDown -> a procedure ControlMouseDown, dando um duplo-clique, aparece o código, na janela da Unit:

(selecionando na Janela de Eventos):

(visualizando código):

*********************************************************************

Faça o download do arquivo: Movimentando Objetos.rar
*********************************************************************

"Só fazemos melhor aquilo que repetidamente insistimos em melhorar.
A busca da excelência não deve ser um objetivo e sim um hábito." Aristóteles.

[...] Continue Lendo...

Criar Form dinamicamente

Criar formulário (ou form) dinamicamente em tempo de execução, é uma tarefa simples e eficiente.

Vantagens:
Ao criar formulários no Delphi, automaticamente eles são criados na lista

de formulários.
A memória tem diversos trabalhos, como, carregar conexões de banco de dados, abertura de tabelas, configurações, arquivos, etc... isso faz com que este carregamento seja um processo demorado.

Para alívio dos programadores, existe a criação dinâmica dos formulários, que fará com que o aplicativo carregue mais rapidamente, deixando de ser pesado, pois manterá toda essa memória alocada por toda a execução do mesmo.

Inicialmente, o formulário principal deveria ser o único criado automaticamente.
Mas existem algumas exceções:
-> Data Modules pois são utilizados em todo o sistema ou em vários formulários. Mas lembre-se: deixe todas as tabelas fechadas em tempo de projeto, e abra somente quando necessário.
-> Formulários não modais que são mostrados o tempo todo.

Seguindo todas essas instruções, a memória não terá mais tanto trabalho, e o tempo de carregamento do "que é necessário" na memória, será bem reduzido. Vejamos:

Vamos começar:
1º- Crie um Formulário Novo, ele receberá o nome de Form2.

2º- Vá no menu Project/Options,


























vai ter 2 list boxes, conforme mostrada figura abaixo, o da esquerda "Auto-create forms" contém os forms que serão criados automaticamente quando a aplicação for iniciada. Mova o Form2 para o ListBox da direita "Available forms" (este deverá conter os forms que serão criados dinamicamente).


3º- Pronto, o Delphi não mais criará o Form2 automaticamente. Para não dar erro ao compilar o projeto, então o Form1 antes, irá fazer uma referência, utilizando no código uses a chamada da Unit2.

4º- No Form1 crie um botão e digite o código da chamada do segundo formulário em seu evento Click.

O código ficará assim no Form1:
...
implementation
uses Unit2;
{$R *.DFM}

{Segue aqui o Código do Botão fazendo a chamda do segundo formulário}
procedure TForm1.Button1Click(Sender: TObject);
begin
Form2 := TForm2.Create(Self); // cria
Form2.ShowModal; //exibe
Form2.Free; //libera da memória
end;
end.

************************************************************************

Faça download do arquivo: Criar Form Dinamicamente.rar
************************************************************************

"A mente do homem, uma vez ampliada por uma nova idéia,
jamais retorna à sua dimensão anterior." Oliver Wendell Holmes.

[...] Continue Lendo...

CheckBox no DBGrid do Delphi

Simular CheckBox no DBGrid, sempre foi algo muito trabalhoso,

mas existe uma jeito simples e rápido de fazer essa simulação.

Adicione no formulário um: TDBGrid,TDataSource e

TClientDataSet.
-> O TDataSource e o TClientDataSet ambos estão na paleta Data Access.
-> O TDBGrid está na paleta Data Controls.

No DBGrid1, para fazer a ligação dele com o DataSource, em Propriedade faça:
-> DataSource = DataSource1
Para desativar o modo Edição no DBGrid, na Propriedade Options faça:
-> dgEdition = False

No DataSource1, para fazer ligação dele com o ClientDataSet, em Propriedade faça:
-> DataSet = ClientDataSet1

No ClientDataSet1, faça:
-> dê um duplo clique no ClientDataSet1, ou clique com o botão direito do mouse, e escolha a opção Fields Editor ...

Uma janela será aberta.
Na parte vazia (em branco) clique com o botão direito do mouse, e escolha a opção NewField.


Crie um campo com as seguintes características:

Tipo (type): StringTamanho (size): 1
Nome (name): ATIVO


Após o preenchimento, clique em OK, e em seguida feche a janela, onde o campo ATIVO está
aparecendo.











Para Ativar o ClientDataSet:
-> clique com o botão direito do mouse em ClientDataSet, e clique em Create DataSet.





























-> na Propriedade Active coloque como True.




















Se todos os procedimentos acima tiverem sido seguidos, nesse momento o campo ATIVO, já aparecerá no DBGrid.

Em Eventos do DBGrid siga as instruções abaixo.

Para Desenhar o CheckBox no DBGrid (use o procedimento DrawColumnCell do DBGrid):

procedure TForm1.DBGrid1DrawColumnCell(Sender: TObject; const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
var
Check: Integer;
R: TRect;
begin
//Desenha um checkbox no dbgrid
if Column.FieldName = 'ATIVO' then begin
DBGrid1.Canvas.FillRect(Rect);
Check := 0;
if ClientDataSet1Ativo.AsString = 'X' then
Check := DFCS_CHECKED
else Check := 0;
R:=Rect;
InflateRect(R,-2,-2); {Diminue o tamanho do CheckBox}
DrawFrameControl(DBGrid1.Canvas.Handle,R,DFC_BUTTON, DFCS_BUTTONCHECK or Check);
end;
end;

Para executar ação TRUE ou FALSE no CheckBox (use o procedimento CellClick do DBGrid):
procedure TForm1.DBGrid1CellClick(Column: TColumn);
begin
ClientDataSet1.Edit;
if ClientDataSet1Ativo.AsString = 'X' then
ClientDataSet1Ativo.AsString := ''
else ClientDataSet1Ativo.AsString := 'X';
ClientDataSet1.Post;

end;

Programa executando:

*********************************************************************************

Faça o download do arquivo: CheckBox no DBGrid.rar
(acompanha arquivo: midas.dll -> necessária para o funcionamento)
*********************************************************************************


"Bem feito é melhor do que bem explicado." Benjamim Franklin.

[...] Continue Lendo...

Criar Edits dinâmicos em tempo de execução

Nesse código podemos criar vários Edits (caixas de texto) dinamicamente no formulário.
Vejamos:

private
{ Private declarations }
ArrayEdit : Array[0..9] of TEdit; //define quantidade de Edits a serem criadas

Dentro de um Button ou em qualquer outro lugar de sua preferência, coloque:

var
x : integer;
begin
for x := 0 to 9 do begin
ArrayEdit[x] := TEdit.Create(Self);
ArrayEdit[x].Parent := Self;
ArrayEdit[x].Text := 'Edit' + IntToStr(x);
ArrayEdit[x].Left := 10;
ArrayEdit[x].Top := 30 + x * 20;
end;

//Edit n° 5, mudando a cor da fonte
ArrayEdit[5].Font.Color := clBlue;

end;

************************************************************
Faça o download do arquivo: Edits Dinamico.rar
************************************************************

"Programar não significa nada;
o importante é encontrar." Pablo Picasso.

[...] Continue Lendo...

Quebrando Linhas no MessageBox

Quebrar linhas no MessageBox, é simples, basta utilizar o comando #13.

Exemplo exibido em um botão (TBitbtn):

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
Application.MessageBox(PChar('Gerando Sistemas...' + #13 + 'Delphi'), 'Teste Quebrar Linha', MB_ICONEXCLAMATION);
end;

**********************************************************************************

Faça o download do arquivo: Quebrando Linhas no MessageBox.rar
**********************************************************************************

"Treino, é treino,
jogo é jogo." Neném Prancha.

[...] Continue Lendo...

Usando MessageBox

Apresentarei aqui duas formas de exibição de mensagem usando o MessageBox.

No primeiro caso, o texto a ser mostrado, é armazenado em duas variáveis do tipo String. Exemplo no botão 1:

procedure TForm1.BitBtn1Click(Sender: TObject);
var Txt1, Txt2: String;
begin
Txt1 := ''; //limpa a variável
Txt2 := ''; //limpa a variável

Txt1 := 'Testando MessageBox';
Txt2 := 'Rio de Janeiro';

MessageBox(Application.Handle, PChar(Txt1), 'Teste 1', MB_ICONINFORMATION + MB_OK);

MessageBox(Application.Handle, PChar('Moro no '+Txt2), 'Teste 2', MB_ICONINFORMATION + MB_OK);
end;
* * * * * * * * * * * * ** ** * *** * * * * * **

Já no segundo caso, a mensagem é armazenada em uma variável do tipo PChar. Exemplo no botão 2:

procedure TForm1.BitBtn2Click(Sender: TObject);
var Msg : PChar;
begin
Msg := ''; //limpa a variável
Msg := 'Testando MessageBox';

Application.MessageBox(Msg,'Teste 1',MB_ICONINFORMATION);
//ou também pode ser:
MessageBox(Application.Handle, Msg, 'Teste 2', MB_ICONINFORMATION + MB_OK);
end;

******************************************************************

Faça o download do arquivo: Usando MessageBox.rar
******************************************************************

"Pense grande.
Quem já ouviu falar de Alexandre, o Médio?" Giles Montgomery.

[...] Continue Lendo...

Entendendo MessageBox

Esta função pertence a API do Windows. Com isso as janelas de mensagens ficam no padrão do Windows. Não é tão complexo de usar.

Parâmetros:
- Handle da janela pai. Este é o handle da aplicação ao qual a janela de mensagens está associada.
- Texto a ser mostrado
- Título da janela
- Flags

- Ícones
MB_ICONINFORMATION,
MB_ICONASTERISK - Letra "i" dentro de um "balãozinho" branco
MB_ICONEXCLAMATION,
MB_ICONWARNING - Ponto de exclamação (!) dentro de um triângulo amarelo
MB_ICONERROR,
MB_ICONSTOP,
MB_ICONHAND - Letra "X" dentro de um círculo vermelho
MB_ICONQUESTION - Ponto de interrogação dentro de um "balãozinhO" brnaco

- Botões
MB_OK - Apenas o botão OK
MB_OKCANCEL - Botões OK e Cancelar
MB_YESNO - Botôes SIM e NÂO
MB_YESNOCANCEL - Botões SIM, NÃO e Cancelar
MB_ABORTRETRYIGNORE - Botões Anular, Repetir e Ignorar
MB_RETRYCANCEL - Botões Repetir e Cancelar

- Default
MB_DEFBUTTON1 - Primeiro botão é o default
MB_DEFBUTTON2 - Segundo botão é o default
MB_DEFBUTTON3 - Terceiro botão é o default

- Modalidade
MB_APPLMODAL - O usuário deve clicar num dos botões da caixa de mensagem antes de continuar trabalhando na janela identificada como pai. O usuário consegue trabalhar em outras janelas de outras aplicações.
MB_SYSTEMMODAL - Igual a MB_APPLMODAL porém impede que o usuário trabalhe em outras janelas

- Outras configurações
MB_HELP - Adiciona "Ajuda" na caixa de mensagens. Clicar no botão Ajuda ou pressionar F1 gera um evento Help
MB_RIGHT - Justifica o texto à direita

- Retorno
IDABORT - Botão "Anular" foi pressionado
IDCANCEL - Botão "Cancelar" foi pressionado ou a tecla "ESC" foi pressionada
IDIGNORE - Botão "Ignorar" foi pressionado
IDNO - Botão "Não" foi pressionado
IDYES - Botão "Sim" foi pressionado
IDOK - Botão "OK" foi pressionado
IDRETRY - Botão "Repetir" foi pressionado

"Se você quer que as pessoas pensem que você é muito inteligente,
simplesmente concorde com elas." Provérbio Judaico.

[...] Continue Lendo...

Criando Slides no Delphi

Muitas vezes nos perguntamos se é possível criar efeitos sem usar o Timer.

Pois é possível sim. Existem efeitos tipo os que são aplicados nos Slides do PowerPoint, que funcionam aqui também.

Essa dica exibe um Panel que mostrará uma mensagem e aparecerá na horizontal, da esquerda para a direita.
E um formulario (form2) sendo exibido do meio para

fora.
Tudo que precisa é adicionar um botão no formulário principal e inserir a codificação.

Utilizados:
TButton = Button1 (Paleta de Componentes Standart)
TPanel = Panel1 (Paleta de Componentes Standart)
Um novo formulario = form2.

uses
Windows, Messages, SysUtils, Variantes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls;
...
implementation
uses Unit2;
...

procedure TForm1.FormShow(Sender: TObject);
begin
Panel1.Visible : = False;
end;

procedure TButton1Click(Sender: TObject);
begin
//---------------------------------------------------------
//Exibindo Efeito em Panel.
//---------------------------------------------------------
Panel1.Caption := 'Exibindo Efeito';
AnimateWindow(Panel1.Handle,3000,AW_HOR_POSITIVE );
Panel1.Visible := True;

//---------------------------------------------------------
//Exibindo Efeito em Formulário 2.
//---------------------------------------------------------
form2.BringToFront;
form1.Hide;
AnimateWindow(form2.Handle,2000,AW_CENTER);
form2.show;
end;

{Segue abaixo outras formas de Animações:
AW_BLEND //Somente no Windows 2000
AW_CENTER //Abre o objeto do meio pra fora
AW_HOR_POSITIVE //Abre o objeto na horizontal, da direita para a esquerda
AW_HOR_NEGATIVE //Abre o objeto na horizontal, da esquerda para a direita
AW_VER_POSITIVE //Abre o objeto na vertical, de cima para baixo
AW_VER_NEGATIVE //Abre o objeto na vertical, de baixo para cima
}
end.

**********************************************************************
Faça o download do arquivo: Criando Slides no Delphi.rar
**********************************************************************

"Escolha um trabalho que você goste de fazer
e não terá que trabalhar um único dia da sua vida." Confúcio.

[...] Continue Lendo...