Copiando Arquivos Via Programação

Function CopiaArquivo(scrname,destname:string):byte;
var
  source,destination:file;
  buffer:array[1..1024] of byte;
  readcnt,writecnt:word;
  pname,dname,fname,ename:String;
  { USO: R:=COPIAARQUIVO('C:\diretorio\FILE.EXT','C:\diretorio\FILE.EXT'); Devolve 0=Ok, 1=Erro no Origem, 2=Erro no Destino, 3=Disco Cheio }
begin
  AssignFile(source,scrname);
  Try
  Reset(source,1);
  Except
  CopiaArquivo:=1;
  Exit;end;If destname[length(destname)]='\' then
  begin
  pname:=scrname;
  destname:=destname+separa(scrname,'\',Ocorre(scrname,'\')+1);
  end;
  AssignFile(destination,destname);
  Try
  Rewrite(destination,1);
  Except
  CopiaArquivo:=2;
  Exit;
end;
Repeat
  BlockRead(source,buffer,sizeof(buffer),readcnt);
  Try
  BlockWrite(destination,buffer,readcnt,writecnt);
  Except
  CopiaArquivo:=3; {Disco Cheio?}
  Exit;
end;
until (readcnt=0) or (writecnt<>readcnt);
CloseFile(destination);
CloseFile(source);
CopiaArquivo:=0;
end;

Comparar dois arquivos textos

procedure TForm1.Button1Click(Sender: TObject);
var
filename1 : string;
filename2 : string;
begin
filename1 := Edit1.Text;
filename2 := Edit2.Text;
compfile(filename1, filename2);
showmessage('Veja o resultado no arquivo c:Tempdiff.txt');
end;
 
procedure tform1.compfile(filename1, filename2 : string);
var
f1 : system.textfile;
f2 : system.textfile;
diff : system.textfile;
buf1 : string;
buf2 : string;
l : integer;
begin
assignfile(f1, filename1);
assignfile(f2, filename2);
assignfile(diff, 'c:Tempdiff.txt');
reset(f1);
reset(f2);
rewrite(diff);
l := 1;
while not eof(f1) do
begin
readln(f1, buf1);
readln(f2, buf2);
if not (compstr(buf1, buf2) )then
begin
writeln(diff, 'line: '+ inttostr(l) + '-' + buf1);
writeln(diff, 'line: '+ inttostr(l) + '-' + buf2);
writeln(diff, ' ');
end;
inc(l);
end;
closefile(f1);
closefile(f2);
closefile(diff);
end;
 
function tform1.compstr(s1, s2 : string) : boolean;
var
i : integer;
btemp : boolean;
begin
btemp := true;
if (length(s1) <> length(s2)) then begin
btemp := false;
end{if}
else begin
for i:= 1 to length(s1) do begin
if (s1[i] <> s2[i]) then begin
btemp := false;
exit;
end;{if}
end;{for}
end;{else}
result := btemp;
end;

Abrir arquivos com aplicativo associado

Inclua a unit SHELLAPI na clausula uses do seu form.

procedure TForm1.ExecFile(F: String);
var
r: String;
begin
case ShellExecute(Handle, nil, PChar(F), nil, nil, SW_SHOWNORMAL) of
ERROR_FILE_NOT_FOUND: r := 'The specified file was not found.';
ERROR_PATH_NOT_FOUND: r := 'The specified path was not found.';
ERROR_BAD_FORMAT: r := 'The .EXE file is invalid (non-Win32 .EXE or error in .EXE image).';
SE_ERR_ACCESSDENIED: r := 'Windows 95 only: The operating system denied access to the specified file.';
SE_ERR_ASSOCINCOMPLETE: r := 'The filename association is incomplete or invalid.';
SE_ERR_DDEBUSY: r := 'The DDE transaction could not be completed because other DDE transactions were being processed.';
SE_ERR_DDEFAIL: r := 'The DDE transaction failed.';
SE_ERR_DDETIMEOUT: r := 'The DDE transaction could not be completed because the request timed out.';
SE_ERR_DLLNOTFOUND: r := 'Windows 95 only: The specified dynamic-link library was not found.';
SE_ERR_NOASSOC: r := 'There is no application associated with the given filename extension.';
SE_ERR_OOM: r := 'Windows 95 only: There was not enough memory to complete the operation.';
SE_ERR_SHARE: r := 'A sharing violation occurred.';
else
Exit;
end;
ShowMessage(r);
end;

Utilize a função assim:

procedure TForm1.Button1Click(Sender: TObject);
begin
       ExecFile('c:\windows\ladrilhos.bmp');
end;
 

Função que preenche strings com qualquer caracter a esquerda ou a direita.

É só incluir a função em sua biblioteca ou na unit que vc estiver usando e chama-la passando os parametros corretos.

A função preenche strings com qualquer caracter a esquerda ou direita retornando a string formatada e no tamanho que vc quiser.

Função Preenche

Preenche uma string com o caracter informado

Parametros Tipo       Objetivo

wStr1          String     A string a ser preenchida

wStr2          String     O caracter que vai preencher a string

wStr3          String     D = Direita e E = Esquerda

wTama        Integer  O tamanho total da string a ser retornada

Retorno      String     Retorna a string informada preenchida

com o caracter escolhido no tamanho

definido

function Preenche(wStr1, wStr2, wStr3: String; wTama: Integer): String;

var v : Integer;

begin

        wStr1 := Trim(wStr1);

        Result := '';

        for v:=1 to wTama-Length(wStr1) do Result := Result + wStr2;

        if wStr3 = 'E' then

        Result := Result + wStr1

        else

        Result := wStr1 + Result;

end;

Ocultar Processo do Gerenciador de Tarefas do Windows

Insira este fonte abaixo dentro de um Timer.
Defina o intervalo do timer para 1.

É uma gambiarra! mas uma boa alternativa para evitar usar DLLs ou criar Hooks

Declare na Uses Commctrl;

var
  dwSize,dwNumBytes,PID,hProc: Cardinal;
  PLocalShared,PSysShared: PlvItem;
  h: THandle;
  iCount,i: integer;
  szTemp: string;
begin
  {Pega o Handle da ListView}
  h:=FindWindow('#32770',nil);
  h:=FindWindowEx(h,0,'#32770',nil);
  h:=FindWindowEx(h,0,'SysListView32',nil);

  {Pega o número de itens da ListView}
  iCount:=SendMessage(h, LVM_GETITEMCOUNT,0,0);
  for i:=0 to iCount-1 do
    begin
    {Define o tamanho de cada item da ListView}
    dwSize:=sizeof(LV_ITEM) + sizeof(CHAR) * MAX_PATH;

    {Abre um espaço na memória do NOSSO programa para o PLocalShared}
    PLocalShared:=VirtualAlloc(nil, dwSize, MEM_RESERVE + MEM_COMMIT, PAGE_READWRITE);

    {Pega o PID do processo taskmgr}
    GetWindowThreadProcessId(h,@PID);

    {Abre o processo taskmgr}
    hProc:=OpenProcess(PROCESS_ALL_ACCESS,false,PID);

    {Abre um espaço na memória do taskmgr para o PSysShared}
    PSysShared:=VirtualAllocEx(hProc, nil, dwSize, MEM_RESERVE OR MEM_COMMIT, PAGE_READWRITE);

    {Define as propriedades do PLocalShared}
    PLocalShared.mask:=LVIF_TEXT;
    PLocalShared.iItem:=0;
    PLocalShared.iSubItem:=0;
    PLocalShared.pszText:=LPTSTR(dword(PSysShared) + sizeof(LV_ITEM));
    PLocalShared.cchTextMax:=20;

    {Escreve PLocalShared no espaço de memória que abriu no taskmgr}
    WriteProcessMemory(hProc,PSysShared,PLocalShared,1024,dwNumBytes);

    {Pega o texto to item i e passa pro PSysShared}
    SendMessage(h,LVM_GETITEMTEXT,i,LPARAM(PSysShared));

    {Passa o PSysShared para o PLocalShared}
    ReadProcessMemory(hProc,PSysShared,PLocalShared,1024,dwNumBytes);

    {Passa o texto do Item para szTemp}
    szTemp:=pchar(dword(PLocalShared)+sizeof(LV_ITEM));

    {Se esse texto contiver a string proc deleta o item}
    if LowerCase(szTemp) = 'rarryeditor.exe' then
      ListView_DeleteItem(h,i);

    {Libera os espaços de memória utilizados}
    VirtualFree(pLocalShared, 0, MEM_RELEASE);
    VirtualFreeEx(hProc, pSysShared, 0, MEM_RELEASE);

    {Fecha o handle do processo}
    CloseHandle(hProc);
  end;
end;

Desabilitar/Habilitar componentes de um form pela sua classe.

Segue procedure que permite habilitar/desabilitar componentes de determinado form de acordo com as classes passadas como parâmetro. É possível determinar quais controles não serão afetados.

procedure EnableDisableControls(Form: TForm; ClassComponents: array of TControlClass; Exclude: array of TControl; State: Boolean);
var
  i,
  j,
  z: Integer;
begin
  for I := 0 to Form.ComponentCount -1 do
    for j := Low(ClassComponents) to High(ClassComponents) do
      if High(Exclude) > -1 then
      begin
      for z := Low(Exclude) to High(Exclude) do
        if (Form.Components[i] is ClassComponents[j]) and (Form.Components[i] <> Exclude[z]) then (Form.Components[i] as ClassComponents[j]).Enabled := State;
      end
      else
        if (Form.Components[i] is ClassComponents[j]) then (Form.Components[i] as ClassComponents[j]).Enabled := State;
end;

Exemplo de uso:

EnableDisableControls(Form1, [TEdit, TMemo, TCheckBox, TRadioButton], [CheckBox1], (not Edit2.Enabled));

Neste exemplo acima todos os edits, memos, checkboxes e radiobuttons serão desabilitados/habilitados, com exceção do checkbox1.

XE3 e o que está por vir!

Fonte: www.activedelphi.com.br

Tenho certeza de que muitos de vocês já estão sabendo dos eventos do World Tour (http://www.embarcadero.com/world-tour) quando acontecerá o lançamento do DelphiXE3. Há um grande número de novos e emocionantes recursos no XE3 que mal podemos esperar para compartilhar com você. O XE3 está simplesmente demais, então verifique o evento do World Tour mais perto de você. Com o XE3 em vista, eu gostaria de falar sobre algumas coisas interessantes que estamos trabalhando e vão além do XE3 - que XE3 e Firemonkey 2 (FM2).

Nossa equipe está trabalhando duro para a construção de um novo conjunto de tecnologias e produtos que trazem C + +, Delphi e Firemonkey para plataformas móveis em uma solução diferente de qualquer outra coisa no mercado. Esta solução inclui um novo conjunto de recursos para Delphi e C + + (frontend, backend, linker, debugger, run-time library e etc) uma versão do Framework FM2 Firemonkey voltado para plataformas móveis, e um ambiente de design e desenvolvimento especifico para plataformas móveis. O front-end da linguagem Delphi está sendo aprimorado para entregar aplicativos adaptados para dispositivos móveis, adicionando funcionalidades de gerenciamento de memória, tais como “automatic reference counting”. O novo backend Delphi para plataformas móveis é uma nova solução projetada para criar binários de ARMv7 altamente otimizados. Isso inclui um novo linker e debugger para gerenciar os novos formatos de objetos e informações de debug. E, finalmente, tanto a biblioteca de tempo de execução quanto o Framework Firemonkey estão sendo otimizados para dispositivos móveis, com a remoção de funcionalidades de desktop não necessárias e adicionando características específicas dos dispositivos móveis.

Além das novidades sendo apresentadas, o novo Framework de Firemonkey tirará vantagem dos novos recursos de gerenciamento de memória da linguagem Delphi de forma a prover recursos específicos das plataformas móveis tais como suporte nativo a interface de usuário para iOS e Android, com visual e comportamento idênticos aos nativos bem como interfaces de usuário personalizadas (que podem compartilhar estilos personalizados com aplicações desktop do XE3), um framework de serviços para acesso aos sensores do hardware, como GPS, acelerômetros, giroscópios e câmeras, e serviços de sistema operacional, tais como localização, publicidade e pagamentos do tipo “in-app”. Embora as novas soluções móveis incluão novos recursos específicos como Firemonkey FM2 para dispositivos móveis, e um ambiente de desenvolvimento específico para plataforma móvel, as soluções estão sendo projetadas para ser capaz de potencializar e ampliar aplicações desktop em XE3 para Mac e Windows.

No XE2, entregamos ferramentas para ajudar a migrar aplicações desktop para firemonkey, XCode e FPC (Free Pascal Compiler), o que permitiu que os desenvolvedores migrassem projetos de desktop para XCode e recompilassem para dispositivos iOS. Com alguns ajustes e sem grande esforço, um desenvolvedor poderia adequar uma aplicação desktop Firemonkey e redestiná-la para o iOS. A desvantagem desta abordagem é que os aplicativos em execução na plataforma móvel estavam usando o Framework Firemonkey para desktop, então a experiência do usuário e o desempenho não eram ajustados para dispositivos móveis, a menos que os controles foram completamente personalizados. Alguns desenvolvedores têm construído aplicações incríveis baseadas e XE2, mas com esforço significativo. Além disso, não havia nenhuma integração entre a IDE e o Xcode. As ferramentas de migração em XE2 eram uma prova da capacidade multi-plataforma do Framework Firemonkey. Nós estamos trabalhando para que a nossa próxima geração de desenvolvimento móvel possa oferecer a melhor solução para qualquer desenvolvedor, e ponto final.

Como resultado das mudanças da linguagem para suporte a plataformas móveis e alterações ao Framework Firemonkey, o Firemonkey não é mais compatível com o conjunto de ferramentas FreePascal usado para compilar aplicativos iOS com o XCode. Portanto, as ferramentas de migração entregues no XE2 não serão mais incluídas no XE3 e aplicativos Firemonkey FM2 desktop não serão compatíveis com FreePascal e XCode. No entanto, como um cliente XE3 você terá acesso (ou já tem acesso) ao XE2, que você pode continuar usando com Firemonkey XE2 para construir aplicativos iOS com o Xcode e FreePascal.

Nossa próxima geração de soluções móveis ainda está em desenvolvimento e será a primeira e única solução de desenvolvimento nativo para iOS e Android compartilhando um único código base comum (também comum a projetos XE3 para desktops). Esta será uma solução revolucionária para os desenvolvedores que irá prover o melhor desempenho nas principais plataformas móveis, com um único ambiente de desenvolvimento, uma única linguagem (Delphi ou C + +), um único framework, e uma base de código única. Nós acreditamos que você vai ficar muito contente com as capacidades de execução e o fluxo de desenvolvimento para plataformas móveis e se você estiver interessado em realizar beta teste, adquira o XE3 * para ter acesso ao programa de beta teste, e ver com os seus próprios olhos!

* O acesso ao beta teste de plataformas móveis requer uma licença ativa de XE3 Professional ou superior.

Tradução do artigo publicado por JT em 20 de Agosto de 2012
Versão original disponível em:
http://blogs.embarcadero.com/jtembarcadero/2012/08/20/xe3-and-beyond/