[Ajuda] Como eu Crio chaves e valores com o delphi 7

[DJrafinha 2]

Então Galera eu queria saber como eu crio "Chaves" e "Valores da cadeia de Caracteres"

que são aquelas pastas e arquivos que fica no "Regedit"

 

 

isso é para um "programinha" que eu quero criar..

só que eu sou bem iniciante não sei muito..

se alguem for me explicar poder colocar print ou algo do tipo

que me ajude, agradeceria muito :)

Obrigado !

 

 

 

 

------------------------------------------------------------------------------@EDIT---------------------------------------------------------------------

 

ja consegui fazer com o seguinte comando:

 

procedure TForm1.Button1Click(Sender: TObject);

var fts: TRegistry;

begin

fts:=TRegistry.Create;

fts.RootKey:= HKEY_LOCAL_MACHlNE

fts.CreateKey('\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons');

fts.OpenKey('\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons',false);

fts.WriteString('3','(vou por uma variavel aqui');

fts.CloseKey;

fts.Free;

 

só que não esta indo para o caminho que eu indiquei.. esta indo para:

 

"HKEY_LOCAL_MACHlNE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons"

 

Deveria ir para

 

"HKEY_LOCAL_MACHlNE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons"

 

 

Alguem me ajuda ! desculpe a confusão

 

 

---

 

 

 

[☢|EXPL01T3R|☣ 50]

Resposta muito grande :3

 

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs,Registry;

 

Agora sim podemos continuar ;)

 

Iremos começar criando uma chave no registro. Existem duas maneiras.

 

1) Utilizando o método Create

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.CreateKey('Minha Chave');

reg.Free;

end;

 

 

Nota-se que, previamente, inserimos um botão no formulírio: Button1.

 

Vamos analisar cada trecho:

 

 

 

var

reg: TRegistry;

 

 

Declaramos uma variível do tipo TRegistry; serve de referência ao registro.

 

 

 

reg := TRegistry.Create;

 

Nós criamos uma nova instância para podermos realizar operações com o registro.

 

 

reg.RootKey := HKEY_CURRENT_USER;

 

Definimos a chave primíria (ou raiz) na qual iremos trabalhar.

 

 

reg.CreateKey('Minha Chave');

 

Acima, temos a linha responsível por efetivamente criar a chave no registro: Minha Chave.

 

Se você abrir novamente o editor de registro, verí que, na chave principal HKEY_CURRENT_USER, existirí uma subchave chamada 'Minha Chave' - óbvio não ;)?

 

Após criar a subchave, liberamos a instância criada:

 

 

reg.Free;

 

 

2)

 

Utilizando o método OpenKey:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True);

reg.CloseKey();

reg.Free;

end;

 

Veja o método utilizado:

 

 

 

reg.OpenKey('Minha Chave',True);

 

 

Acima, o programa tenta abrir a chave "Minha Chave" dentro de "HKEY_CURRENT_USER".Hí um pequeno detalhe: se a chave não existir ele é criada. Vamos entender isso melhor analisando a sintaxe da função:

 

 

reg.OpenKey(NOME_CHAVE,CRIAR);

 

NOME_CHAVE:

nome da chave que se deseja abrir;

 

CRIAR:

é um valor BOOL, isto é, FALSE ou TRUE. Se FALSE, caso a chave não exista, ela não serí criada, se TRUE, a chave serí criada caso não exista.

Observando a sintaxe vemos que, como o segundo parâmetro foi passado como 'True', a chave seria criada =)

 

 

Uma observação a ser feita é que, para podermos trabalhar com valores dentro de uma chave, deve-se abri-la previamente através de OpenKey. Portanto, é mais simples utilizar este método mesmo quando formos criar uma chave, uma vez em que esta é criada e aberta de uma só vez =)

 

Após realizar as devidas tarefas com uma chave do registro, devemos fechí-la:

 

 

reg.CloseKey();

 

O método fecha a chave atual aberta, no caso, Minha Chave.

 

 

Ainda trabalhando com a chave 'Minha Chave', veremos como criar um simples valor:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True); // Abrimos (e criamos se necessírio) a chave

 

// Escrevemos o valor 'Valor1' dentro da chave tendo 'LOL' como conteúdo;

reg.WriteString('Valor1','LOL');

reg.CloseKey();

reg.Free;

end;

 

 

 

A sintaxe bísica seria:

 

 

reg.WriteString(NOME_VALOR,CONTEUDO);

 

NOME_VALOR:

nome do valor a ser inserido;

 

CONTEUDO:

dados do valor.

 

 

Se você reparar bem, o método utilizado foi WriteString, ou seja, iremos escrever um valor do tipo string na chave =)

 

Além de strings, podemos escrever inteiros, floats, valores booleanos, dentre outros.

 

Exemplo:

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True); // Abrimos (e criamos se necessírio) a chave

 

reg.WriteString('Valor String','LOL');

reg.WriteInteger('Valor Inteiro',100);

reg.WriteFloat('Valor Float',10.5);

reg.WriteBool('Valor Bool',FALSE);

 

reg.CloseKey();

reg.Free;

end;

 

Bem simples não?

 

Porém, as notações são diferentes no editor do registro. O que eu quero dizer é que se escrevemos um valor Inteiro na chave, este não irí aparecer como o tipo Integer, necessariamente. Você se lembra que, no inàcio do artigo, me referir ao nome, tipo e dados de um valor?

 

Pois bem, analise:

 

 

reg.WriteString('Valor String','LOL');

 

 

 

 

Valor String - nome do valor;

LOL - conteúdo do valor (dados)

???? - tipo

 

 

Pois bem, no registro, temos a seguinte associação:

 

 

 

String = REG_SZ

Integer = REG_DWORD

Float = REG_BINARY

Bool = REG_DWORD

 

 

Existe ainda outro tipo: REG_EXPAND_SZ, que é criado quando escrevemos um valor utilizando o método reg.WriteExpandString() - seria uma expansão para o tipo REG_SZ.

 

Podemos ler valores escritos em chaves do registro através do método reg.Read...(), onde ... seria o tipo de dado a ser lido.

 

Veja o exemplo:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

str:string;

inteiro:integer;

float:single;

bool:boolean;

 

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True);

 

str := reg.ReadString('Valor String');

inteiro := reg.ReadInteger('Valor Inteiro');

float := reg.ReadFloat('Valor Float');

bool := reg.ReadBool('Valor Bool');

 

ShowMessage(str);

ShowMessage(IntToStr(inteiro));

ShowMessage(FloatToStr(float));

ShowMessage(BoolToStr(bool));

 

reg.CloseKey();

reg.Free;

end;

 

 

Vejamos:

 

 

 

str:string; // string

inteiro:integer; // integer

float:single; // float

bool:boolean; // boolean

 

 

Declaramos as variíveis para cada tipo de dado.

 

Para ler cada valor fazemos:

 

 

 

str := reg.ReadString('Valor String'); // Lê um valor do tipo string (REG_SZ)

inteiro := reg.ReadInteger('Valor Inteiro'); // Lê um valor do tipo inteiro (REG_DWORD)

float := reg.ReadFloat('Valor Float'); // Lê um valor do tipo float (REG_BINARY)

bool := reg.ReadBool('Valor Bool'); // Lê um valor do tipo boolean (REG_DWORD)

 

 

Em seguida, mostramos os valores:

 

 

 

ShowMessage(str); // Mostra a string

ShowMessage(IntToStr(inteiro)); // Converte o valor inteiro para string e mostra-o

ShowMessage(FloatToStr(float)); // Converte o float para string e mostra-o

ShowMessage(BoolToStr(bool)); // Converte o boolean inteiro para string e mostra-o

 

 

Até agora, trabalhamos apenas com valores dentro da chave "Minha Chave" contida em HKEY_CURRENT_USER.

Veremos a seguir como proceder para criar uma subchave dentro de "Minha Chave":

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave\LOL',True);

reg.CloseKey();

reg.Free;

end;

 

 

O trecho acima cria a subchave 'LOL' dentro da chave 'Minha Chave'.

 

Veja agora o exemplo:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave\LOL',True);

reg.WriteString('Teste','XXX');

reg.CloseKey();

reg.Free;

end;

 

 

Se você observar bem, verí que o valor 'Teste' seria escrito dentro da subchave 'LOL' e não dentro de 'Minha Chave'.

 

Portanto, para criar subchaves, fazemos:

 

 

reg.OpenKey('CHAVE\SUBCHAVE1\SUBCHAVE2,...',True);

 

Note que o parâmetro 'True' deve ser obrigatório neste caso, jí que iremos criar as subchaves.

 

 

Agora que jí brincamos com o registro, iremos desfazer as alterações. Para isso, utilizamos os métodos reg.DeleteKey() e reg.DeleteValue(), respectivamente, para deletar chaves e valores.

 

Veja:

 

Exemplo 1:

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True); // Abrimos a chave 'Minha Chave'

 

// Deletamos todos os valores que criamos ao decorrer do artigo

reg.DeleteValue('Valor1');

reg.DeleteValue('Valor String');

reg.DeleteValue('Valor Inteiro');

reg.DeleteValue('Valor Float');

reg.DeleteValue('Valor Bool');

 

reg.CloseKey();

reg.Free;

end;

 

 

A sintaxe é muito simples:

 

 

reg.DeleteValue(NOME_DO_VALOR);

 

Após a execução do programa acima, irí constar no registro a chave 'Minha Chave' vazia, com a subchave 'LOL' contendo o valor 'Teste'. Iremos deletar ambas as chaves.

 

Veja:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

Reg.DeleteKey('Minha Chave');

reg.Free;

end;

 

 

Com isso, deletamos a subchave 'LOL' e a chave 'Minha Chave'.

Note que não foi preciso abrir nenhuma chave, por quê? Simplesmente pois a chave 'Minha Chave' estava dentro de HKEY_CURRENT_USER, e quando utilizamos o método reg.DeleteKey, deletamos a subchave especificada dentro da chave atual. Veja:

 

 

 

HKEY_CURRENT_USER; // Chave principal

[...]

[...]

[Minha Chave] // subchave

[...]

[...]

 

 

Quando fazemos reg.DeleteKey('Minha Chave'); deletamos a subchave especificada dentro da chave atual, que no caso seria 'HKEY_CURRENT_USER'.

 

Quando deletemos uma chave, todos seus valores, subchaves, valores destas subchaves (lolz) são deletados também. É o mesmo que ocorre com uma pasta normal:

 

Se você criar a chave "Teste", e inserir as subchaves "SUB1", "SUB2" e "SUB3", por lógica, caso a chave "Teste" seja deletada, todas estas últimas serão também =)

 

Com base nisso, veremos uma situação onde deletamos somente a subchave 'LOL' dentro de 'Minha Chave':

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',True);

reg.DeleteKey('LOL');

reg.CloseKey();

reg.Free;

end;

 

 

É importante observar que devemos abrir a chave 'Minha Chave' previamente pois a subchave 'LOL' estí dentro dela.

A chave 'Minha Chave' continuaria existindo após a execução do programa acima =)

 

 

Temos dois métodos muito interessantes: reg.GetKeyNames e reg.GetValueNames.

O primeiro nos permite obter o nome de todas as subchaves dentro de uma chave;

o último nos permite obter o nome de todos os valores dentro da chave atual.

 

Exemplo 1:

 

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

chaves: TStringList;

i:integer;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('SoftWare',false); // Abre a chave

chaves := TStringList.Create;

reg.GetKeyNames(chaves);

for i :=0 to chaves.Count -1 do ShowMessage(chaves.strings);

reg.CloseKey();

chaves.free; // Libera instância

reg.free;

 

end;

 

 

 

O código acima mostraria todas as subchaves contidas em 'HKEY_CURRENT_USER\Software'.

 

Vamos destacar alguns pontos importantes:

 

 

 

chaves: TStringList;

i:integer;

 

 

Chaves - variível do tipo TStringList; servirí para armazenar os nomes de cada chave;

i - varàavel que irí nos auxiliar no loop - mostrar os nomes.

 

 

chaves := TStringList.Create;

 

Criamos uma nova instância para a variível.

 

 

reg.GetKeyNames(chaves);

 

Obtemos o nome de cada chave e fazemos com que estes sejam armazenados em "chaves".

 

Por fim, fazemos um loop que nos motra cada valor:

 

 

for i :=0 to chaves.Count -1 do ShowMessage(chaves.strings);

 

Cada chave estí armazenada da seguinte forma:

 

 

 

chaves.strings[0] = nome da primeira chave;

chaves.strings[1] = nome da segunda chave;

chaves.strings[2] = nome da terceira chave;

[...]

 

 

E se por acaso, ao invés de mostrar as subchaves de 'SoftWare', quiséssemos mostrar as subchaves dentro de 'HKEY_CURRENT_USER'? Bem simples, basta utilizar o método reg.OpenKey passando o primeiro parâmetro vazio:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

chaves: TStringList;

i:integer;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('',false); // Abre a própria chave principal

chaves := TStringList.Create;

reg.GetKeyNames(chaves);

for i :=0 to chaves.Count -1 do ShowMessage(chaves.strings);

reg.CloseKey();

reg.free;

 

end;

 

 

 

Exemplo 2:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

valores: TStringList;

i:integer;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_LOCAL_*******; // Note que a chave agora não é mais HKEY_CURRENT_USER

 

// Abrimos a subchave que armazena informações sobre o windows

reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVer sion',false);

valores := TStringList.Create;

reg.GetValueNames(valores);

for i :=0 to valores.Count -1 do ShowMessage(valores.strings);

reg.CloseKey();

reg.free;

 

 

 

Temos basicamente a mesma situação, porém, desta vez, obtemos o nome dos valores da subchave.

É importante notar que obtemos o nome de cada valor e não os dados de cada um.

 

Exemplo:

 

 

 

CommonFilesDir = nome do valor

C:\Arquivos de programas\Arquivos comuns = dados

 

 

Mas se você observar bem, podemos obter os dados de um valor através do seu nome utilizando o método reg.ReadString() - quando o valor é uma string.

 

A partir dai, podemos combinar o método no loop, veja:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

valores: TStringList;

i:integer;

nome_valor: string; // Nome do valor

dados_valor:string; // Dados do valor

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_LOCAL_*******;

reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVer sion',false);

valores := TStringList.Create;

reg.GetValueNames(valores);

for i :=0 to valores.Count -1 do

begin

nome_valor := valores.Strings;

dados_valor := reg.ReadString(nome_valor);

ShowMessage(nome_valor + ' = ' + dados_valor);

 

end;

reg.CloseKey();

reg.free;

 

end;

 

 

A parte que devemos destacar é:

 

 

 

nome_valor := valores.Strings; // Obtém o nome do valor

dados_valor := reg.ReadString(nome_valor); // Obtém os dados deste mesmo valor

ShowMessage(nome_valor + ' = ' + dados_valor); // Mostra: [VALOR] = [DADOS]

 

 

Note que, como o valor é retirado da chave que foi aberta previamente, podemos utilizar o método reg.ReadString sem problemas ;)

 

Para finalizar o artigo, iremos tratar um pouco de validação.

 

 

1) Verificando se uma chave existe

 

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

if reg.KeyExists('Minha Chave') then // Verifica se a chave 'Minha Chave' existe

ShowMessage('A chave existe!')

else

ShowMessage('A chave não existe!');

 

reg.free;

end;

 

O método reg.KeyExists() retorna FALSE se uma chave ou subchave não existir, ou TRUE caso exista.

 

Outro exemplo:

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

if reg.KeyExists('Minha Chave\LOL') then

ShowMessage('A chave existe!')

else

ShowMessage('A chave não existe!');

 

reg.free;

end;

 

 

Desta vez, verificamos se a subchave 'LOL' existe dentro de 'Minha Chave'.

 

 

2) Verificando se um valor existe

 

 

 

procedure TForm1.Button1Click(Sender: TObject);

var

reg: TRegistry;

begin

reg := TRegistry.Create;

reg.RootKey := HKEY_CURRENT_USER;

reg.OpenKey('Minha Chave',FALSE);

 

if reg.ValueExists('Valor1') then

ShowMessage('O valor existe!')

else

ShowMessage('O valor não existe!');

 

reg.CloseKey();

 

reg.free;

end;

 

O método reg.ValueExists() retorna TRUE se um valor existir, ou FALSE do contrírio.

 

 

fonte:

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

[DJrafinha 2]

Nossa, eu li tudo e talz.. complico em algumas pastes mais é bem intereçante.. !

valeu cara.. só que eu ainda não entendi porque ta indo para a pasta errada no regedit

quando eu do o comando de criar a chave lá no botao :)