 |
|
||||
Você está aqui: Delphi ::: Dicas & Truques ::: Formatação de datas, strings e números |
Formatando datas e horas em Delphi usando a função FormatDateTime()Quantidade de visualizações: 47523 vezes |
Em algumas situações precisamos formatar um TDateTime e exibir seus valores de data e hora em formatos mais amigáveis ao usuário. Para isso o Delphi nos fornece a função FormatDateTime(), presente na unit SysUtils. Esta função recebe uma string de formatação e um TDateTime e retorna uma string contendo a data e hora formatadas. Veja um exemplo:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
data: TDateTime;
formatada: string;
begin
// vamos obter a data de hoje
data := Now;
// vamos formatar
formatada := FormatDateTime('dddd, dd "de" mmmm "de" yyyy',
data);
// vamos exibir o resultado
ShowMessage(formatada);
end;
Aqui a data será exibida em um formato semelhante à "sexta-feira, 22 de outubro de 2008", ou seja, o formato de data longa do Windows. Para tirar o máximo proveito da função FormatDateTime(), é importante conhecer os caracteres de formatação permitidos na função. Veja: c - Exibe a data usando o formato dado pela variável global ShortDateFormat, seguida pelas horas usando o formato dado pelo variável global LongTimeFormat. As horas não serão exibidas se o valor das horas indicarem meia-noite. d - Exibe o dia como um número não precedido de zero (1-31). dd - Exibe o dia como um número precedido de zero (01-31). ddd - Exibe o dia como uma abreviação (Dom-Sáb) usando as strings fornecidas pela variável global ShortDayNames. dddd - Exibe o dia com o nome completo (Domingo-Sábado) usando as strings dadas pela variável global LongDayNames. ddddd - Exibe a data usando o formato dado pela variável global ShortDateFormat. dddddd - Exibe a data usando o formato dado pela variável global LongDateFormat. e - (Windows somente) - Exibe o ano na era/período atual como um número não precedido por zero (somente os locales Japanese, Korean e Taiwanese). ee - (Windows somente) - Exibe o ano na era/período atual como um número precedido por zero (somente os locales Japanese, Korean e Taiwanese). g - (Windows somente) - Exibe a era/período atual como uma abreviação (somente os locales Japanese e Taiwanese). gg - (Windows somente) - Exibe a era/período atual com um nome completo (somente os locales Japanese e Taiwanese). m - Exibe o mês como um número não precedido por zero (1-12). Se o especificador m seguir imediatamente um especificador h ou hh, os minutos, e não é mês, são exibidos. mm - Exibe o mês como um número precedido por zero (01-12). Se o especificador m seguir imediatamente um especificador h ou hh, os minutos, e não é mês, são exibidos. mmm - Exibe o mês como uma abreviação (Jan-Dez) usando as string dadas pela variável global ShortMonthNames. mmmm - Exibe o mês com um nome completo (Janeiro-Dezembro) usando as strings dadas pela variável global LongMonthNames. yy - Exibe o ano com dois dígitos (00-99). yyyy - Exibe o ano com quatro dígitos (0000-9999). h - Exibe a hora não precedida por zero (0-23). hh - Exibe a hora precedida por zero (00-23). n - Exibe os minutos não precedidos por zero (0-59). nn - Exibe os minutos precedidos por zero (00-59). s - Exibe os segundos não precedidos por zero (0-59). ss - Exibe os segundos precedidos por zero (00-59). z - Exibe os milisegundos não precedidos por zero (0-999). zzz - Exibe os milisegundos precedidos por zero (000-999). t - Exibe as horas usando o formato dado pela variável global ShortTimeFormat. tt - Exibe as horas usando o formato dado pela variável global LongTimeFormat. am/pm - Usa o relógio de 12 horas para os especificadores h ou h precedentes e exibe "am" para as horas antes do meio-dia e "pm" para as horas depois do meio-dia. O especificador am/pm pode ser em letras minúsculas, maiúsculas ou uma combinação destas. a/p - Usa o relógio de 12 horas para os especificadores h ou h precedentes e exibe "a" para as horas antes do meio-dia e "p" para as horas depois do meio-dia. O especificador a/p pode ser em letras minúsculas, maiúsculas ou uma combinação destas. ampm - Usa o relógio de 12 horas para os especificadores h ou hh e exibe o conteúdo da variável global TimeAMString para qualquer hora antes do meio-dia e o conteúdo de TimePMString para as horas depois do meio-dia. / - Exibe o caractere de separador de datas dado pela variável global DateSeparator. : - Exibe o caractere de separador de horas dado pela variável global TimeSeparator. 'xx'/"xx" - Caracteres em aspas simples ou duplas não são formatados. Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
 Link para compartilhar na Internet ou com seus amigos: |
Delphi ::: VCL - Visual Component Library ::: TListBox |
Como obter e exibir todos os itens selecionados em uma TListBox do Delphi de seleção múltiplaQuantidade de visualizações: 14337 vezes |
Este trecho de código mostra como podemos obter e exibir todos os itens selecionados em uma TListBox de seleção múltipla. Para executá-lo, coloque uma ListBox, um Memo e um Button em um formulário. Altere a propriedade MultiSelect da ListBox para True, adicione alguns itens e execute. Selecione um ou mais itens e clique no botão para visualizar o resultado. Note que usei um TStringList (classe concreta derivada de TStrings) para armazenar os itens selecionados. Veja o código:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
i: Integer;
selecionados: TStringList;
begin
// para que este exemplo funcione corretamente, a ListBox
// deverá permitir seleção múltipla
// ListBox1.MultiSelect := True;
selecionados := TStringList.Create;
// vamos obter os itens selecionados na ListBox
if ListBox1.SelCount > 0 then
begin
for i := 0 to ListBox1.Count - 1 do
begin
if ListBox1.Selected[i] then
selecionados.Add(ListBox1.Items[i]);
end;
// vamos exibir os itens selecionados em um TMemo
Memo1.Lines.Clear;
Memo1.Lines.Add('Os itens selecionados são:');
for i := 0 to selecionados.Count - 1 do
Memo1.Lines.Add(selecionados[i]);
end
else
ShowMessage('Nenhum item selecionado.');
// vamos liberar o TStringList
selecionados.Free;
end;
Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Delphi ::: Win32 API (Windows API) ::: Formulários e Janelas |
Como usar a função GetWindow() da API do Windows para pesquisar e retornar um handle para uma janela baseado em seu título completo ou parcial usando DelphiQuantidade de visualizações: 14950 vezes |
|
Em algumas situações nós precisamos pesquisar e retornar um handle para uma janela baseado em seu título completo ou parcial, ou seja, gostaríamos de encontrar uma janela que contenha a palavra "sexo". Isso pode ser feito com o auxílio da função GetWindow() da API do Windows. Veja: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// função personalizada que permite encontrar uma janela
// baseado em seu título
function FindWindowByTitle(WindowTitle: string): Hwnd;
var
NextHandle: Hwnd;
NextTitle: array[0..255] of char;
begin
// vamos obter a primeira janela
NextHandle := GetWindow(Application.Handle, GW_HWNDFIRST);
while NextHandle > 0 do
begin
// vamos obter o título da janela
GetWindowText(NextHandle, NextTitle, 256);
// a janela contém o título que procuramos?
if Pos(Uppercase(WindowTitle), UpperCase(String(NextTitle))) <> 0 then
begin
Result := NextHandle;
Exit;
end
else
// vamos tentar a próxima janela
NextHandle := GetWindow(NextHandle, GW_HWNDNEXT);
end;
// não encontramos nada? vamos retornar um handle nulo
Result := 0;
end;
procedure TForm1.Button1Click(Sender: TObject);
var
handle: hwnd;
begin
// vamos localizar e fechar a Calculadora do Windows
// ou qualquer janela que contenha o texto "Calculadora"
handle := FindWindowByTitle('Calculadora');
if handle <> 0 then // encontramos a janela? vamos fechá-la
SendMessage(handle, WM_SYSCOMMAND, SC_CLOSE, 0)
else
ShowMessage('A janela pesquisada não foi encontrada');
end;
Neste exemplo nós pesquisamos uma janela que contenha a palavra "Calculadora" em seu título. Se encontrada, nós a fechamos com o auxílio da função SendMessage() e a mensagem WM_SYSCOMMAND com o valor SC_CLOSE para o parâmetro wParam. Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Delphi ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI |
Como retornar uma lista dos dispositivos de entrada MIDI no sistema usando DelphiQuantidade de visualizações: 11186 vezes |
|
Em algumas ocasiões nós precisamos obter uma lista dos dispositivos de entrada MIDI no sistema, talvez com o propósito de selecionar um determinado dispositivo em uma ListBox ou ComboBox. O trecho de código abaixo mostra como isso pode ser feito. O primeiro passo é declarar uma variável do tipo TMidiInCaps. Este registro está declarado na unit MMSystem.pas e é uma tradução da estrutura MIDIINCAPS da API do Windows. Entre outros tipos de dados, esta estrutura possui um membro szPname que retorna o nome do dispositivo. Na unit MMSystem.pas este membro está declarado como array[0..MAXPNAMELEN-1] of AnsiChar, ou seja, uma matriz de AnsiChar que será preenchida pela API do Windows e terá seu final marcado com o caractere null (NULL terminated string). Note a conversão deste valor para o tipo String no momento de inserí-lo no ComboBox. Em versões anteriores do Delphi (estou escrevendo este código no Delphi 2009) podíamos usar a função StrPas() para esta finalidade. O passo seguinte é obter a quantidade de dispositivos de entrada MIDI. Isso é feito com uma chamada à função midiInGetNumDevs da API do Windows. Uma vez obtida a quantidade de dispositivos nós usamos um laço for e, no corpo deste laço, usamos o valor da variável de controle i para efetuar uma chamada à função midiInGetDevCaps(), também da API do Windows: midiInGetDevCaps(i, @MidiInCaps, sizeof(TMidiInCaps)); Esta função recebe o identificador do dispositivo (um valor inteiro começando em 0 e indo até a quantidade de dispositivos - 1), um ponteiro para um registro MidiInCaps e o tamanho em bytes do registro. Se a função for executada com sucesso, o registro MidiInCaps será preenchido com várias informações úteis, tais como o nome do dispositivo, o ID do fabricante, o ID do produto, versão do driver, etc. Para finalizar, nós acessamos o campo szPname do registro MidiInCaps e o adicionamos no ComboBox. Veja o código completo a seguir: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
i: Integer;
MidiInCaps: TMidiInCaps; // este record está definido em MMSystem.pas
erro: Word;
begin
// uses MMSystem
ComboBox1.Clear;
// midiInGetNumDevs retorna a quantidade de dispositivos de entrada
// MIDI no sistema
for i := 0 to midiInGetNumDevs - 1 do
begin
// vamos obter o dispositivo identificado pela variável i (uDeviceID)
erro := midiInGetDevCaps(i, @MidiInCaps, sizeof(TMidiInCaps));
if erro <> MMSYSERR_NOERROR then
raise Exception.Create('Não foi possível obter a lista de dispositivos ' +
'de entrada MIDI');
// vamos adicionar o nome do dispositivo no ComboBox
ComboBox1.Items.Add(String(MidiInCaps.szPname));
end;
end;
Ao executar este código o ComboBox será preenchido no mínimo com o valor: MPU-401 Este é o MPU 401-compatible MIDI input port, um dos dispositivos de entrada MIDI mais comuns nos PCs, embora já não esteja tão presente nos computadores mais atuais. Para fins de compatibilidade esta dica ou anotação foi escrita usando Delphi 2009. |
Delphi ::: Dicas & Truques ::: Matemática e Estatística |
Como calcular desvio padrão em Delphi - Delphi para Matemática e EstatísticaQuantidade de visualizações: 2096 vezes |
|
Em Matemática e Estatística, o Desvio padrão (em inglês: Standard Deviation) é uma medida de dispersão, ou seja, é uma medida que indica o quanto um conjunto de dados é uniforme. Quando o desvio padrão é baixo, isso quer dizer que os dados do conjunto estão mais próximos da média. Como calcular o desvio padrão de um conjunto de dados? Vamos começar analisando a fórmula mais difundida na matemática e na estatística: \[\sigma = \sqrt{ \frac{\sum_{i=1}^N (x_i -\mu)^2}{N}}\] Onde: a) __$\sigma__$ é o desvio; b) __$x_i__$ é um valor qualquer no conjunto de dados na posição i; c) __$\mu__$ é a média aritmética dos valores do conjunto de dados; d) N é a quantidade de valores no conjunto. O somatório dentro da raiz quadrada nos diz que devemos somar todos os elementos do conjunto, desde a posição 1 até a posição n, subtrair cada valor pela média do conjunto e elevar ao quadrado. Obtida a soma, nós a dividimos pelo tamanho do conjunto. Veja o código Delphi completo que obtém o desvio padrão a partir de um conjunto de dados contendo quatro valores: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// Algoritmo Delphi para calcular desvio padrão
program estudos_delphi;
{$APPTYPE CONSOLE}
uses
SysUtils, Math;
var
// conjunto de dados
conjunto: array[1..4] of double = (10, 30, 90, 30);
soma: double; // Soma dos elementos
desvio_padrao: double; // Desvio padrão
tam: integer; // Tamanho dos dados
media: double; // média
i: integer;
begin
soma := 0.0;
desvio_padrao := 0.0;
tam := 4;
// vamos somar todos os elementos
for i := 1 to tam do
begin
soma := soma + conjunto[i];
end;
// agora obtemos a média do conjunto de dados
media := soma / tam;
// e finalmente obtemos o desvio padrão
for i := 1 to tam do
begin
// não esqueça de adicionar a unit Math
desvio_padrao := desvio_padrao + Power(conjunto[i] - media, 2);
end;
// mostramos o resultado
WriteLn('Desvio Padrão Populacional: ' + FloatToStr(Sqrt(desvio_padrao / tam)));
WriteLn('Desvio Padrão Amostral: ' + FloatToStr(Sqrt(desvio_padrao / (tam - 1))));
WriteLn;
Write('Pressione Enter para sair...');
ReadLn;
end.
Ao executar este código Delphi nós teremos o seguinte resultado: Desvio Padrão Populacional: 30.0 Desvio Padrão Amostral: 34.64101615137755 Veja que, para calcular o Desvio Padrão Populacional, nós dividimos o somatório pela quantidade de elementos no conjunto, enquanto, para calcular o Desvio Padrão Amostral, nós dividimos o somatório pela quantidade de elementos - 1 (cuidado com a divisão por zero no caso de um conjunto com apenas um elemento). |
Delphi ::: Dicas & Truques ::: Ponteiros, Referências e Memória |
Como usar ponteiros na linguagem Delphi - Aprenda a usar ponteiros em DelphiQuantidade de visualizações: 23855 vezes |
|
O Delphi, assim como C e C++ permite o uso de ponteiros, uma das ferramentas mais poderosas de programação e presente em códigos mais elaborados, tais como estruturas de dados. Para entender ponteiros, é preciso lembrarmos do conceito de variáveis. Uma variável, em determinados momentos, possui várias propriedades ou atributos, a saber, um nome, um valor e o tipo de dados que poderá ser armazenado na mesma. Uma variável possui também um endereço na memória do computador e o seu nome não é nada mais que um apelido para tal endereço. Ponteiros também possuem um nome, um valor e um tipo de dados. A diferença é que ponteiros, em vez de guardar valores tais como inteiros, strings, caracteres, etc, guardam o endereço de outras variáveis (ou o endereço de outros ponteiros, o que resulta em um ponteiro para um ponteiro). Assim, um ponteiro é uma forma indireta de se acessar o conteúdo de uma outra variável. Veja, por exemplo, as seguintes declarações de variáveis: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- var valor: integer; pvalor: ^integer; Aqui nós temos uma variável valor do tipo Integer e uma variável pvalor que é um ponteiro para um Integer. Veja agora como atribuir valores a estas variáveis: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
valor: integer;
pvalor: ^integer;
begin
// atribui um valor à variável valor
valor := 20;
// vamos atribuir à pvalor o endereço de valor
pvalor := @valor;
// vamos usar o ponteiro pvalor para alterar o
// valor de valor
pvalor^ := 30;
// vamos obter o novo valor da variável valor
ShowMessage('Valor de valor: ' + IntToStr(valor));
end;
Veja que usamos o operador @ para obtermos o endereço da variável valor e guardá-lo no ponteiro pvalor. Em seguida usamos o símbolo ^ para acessar o valor da variável para a qual o ponteiro está apontando. Este processo é chamado de desreferenciamento (dereferencing). Em resumo, o símbolo ^ pode ser usado de duas formas: na frente de um tipo de dados, para indicar que a variável está sendo declarada como ponteiro e após o nome de uma variável do tipo ponteiro para indicar que queremos acessar o valor da variável para a qual o ponteiro está apontando atualmente e não o valor do ponteiro, que seria simplesmente um valor inteiro representando um endereço de memória. Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Delphi ::: Dicas & Truques ::: Strings e Caracteres |
Como obter a quantidade de caracteres em uma palavra ou texto usando a função Length() do DelphiQuantidade de visualizações: 20938 vezes |
Em algumas situações precisamos saber o tamanho de uma string, ou seja, quantos caracteres ela contém. Isso pode ser feito por meio da função Length(). Veja:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
nome: string; // declara uma variável do tipo string
tamanho: integer; // declara uma variável do tipo inteiro
begin
nome := 'Osmar';
// vamos obter a quantidade de caracteres na string
tamanho := Length(nome);
// mostra o resultado
ShowMessage('A string contém : ' + IntToStr(tamanho) +
' caracteres');
end;
Para questões de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Delphi ::: VCL - Visual Component Library ::: TEdit |
Como habilitar ou desabilitar um TEdit do Delphi usando a função EnableWindow() da API do WindowsQuantidade de visualizações: 11661 vezes |
|
Embora o Delphi já nos forneça as ferramentas necessárias para habilitar ou desabilitar um TEdit em tempo de execução, é importante saber como realizar esta tarefa usando a API do Windows. Para isso, podemos usar a função EnableWindow() com os valores true ou false. A função EnableWindow() possui a seguinte assinatura em C/C++: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- BOOL EnableWindow( HWND hWnd, BOOL bEnable ); No arquivo Windows.pas podemos encontrar o protótipo e corpo desta função convertidos para Object Pascal: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// Protótipo
{$EXTERNALSYM EnableWindow}
function EnableWindow(hWnd: HWND; bEnable: BOOL): BOOL; stdcall;
// Implementação
function EnableWindow; external user32 name 'EnableWindow';
Note que precisamos informar o HWND (parâmetro hWnd) para a caixa de texto e um valor BOOL. Se fornecermos false, a caixa de texto será desabilitada. Veja: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
begin
// vamos desabilitar o TEdit usando a função EnableWindow()
// com o valor false
if EnableWindow(Edit1.Handle, False) = True then
begin
ShowMessage('A caixa de texto foi desabilitada com sucesso.');
end;
end;
Para habilitar a caixa de texto novamente, só precisamos fornecer o valor true para o parâmetro bEnable: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
begin
// vamos habilitar o TEdit usando a função EnableWindow()
// com o valor true
if EnableWindow(Edit1.Handle, True) = True then
begin
ShowMessage('A caixa de texto foi habilitada com sucesso.');
end;
end;
É importante observar que o retorno da função EnableWindow será False se tentarmos habilitar uma caixa de texto que já está habilitada ou tentarmos desabilitar uma caixa de texto que já está desabilitada. |
Delphi ::: Dicas & Truques ::: Strings e Caracteres |
Como extrair uma substring de uma string usando a função AnsiMidStr() do DelphiQuantidade de visualizações: 30871 vezes |
Em algumas situações precisamos obter uma substring de uma string. Em Delphi isso pode ser feito por meio da função AnsiMidStr(). Esta função requer a string a partir da qual a substring será obtida, a posição inicial da substring (começando em 1) e a quantidade de caracteres que comporâo a substring. O retorno será uma nova string contendo a substring obtida. Veja o exemplo:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
frase, substring: string;
begin
frase := 'Programar em Delphi é muito bom';
// vamos obter a substring "Delphi"
substring := AnsiMidStr(frase, 14, 6);
// vamos exibir o resultado
ShowMessage('Resultado: ' + substring);
end;
Não se esqueça de adicionar a unit StrUtils no uses do seu formulário. Para questões de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Desafios, Exercícios e Algoritmos Resolvidos de Delphi |
Veja mais Dicas e truques de Delphi |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
