Incrustar archivos como recursos en un ejecutable Delphi

¿Cómo integrar a los iconos, cursores, cursores animados, mapas de bits, imágenes JPEG, archivos de la onda, archivos de texto y cualquier otro dentro de un archivo ejecutable Delphi.

Incrustar archivos como recursos en un ejecutable Delphi

Es posible incrustar cualquier tipo de archivo en un ejecutable usando archivos de recursos (*. RES). Ciertos tipos de recursos son reconocidos por la API y se puede utilizar directamente. Otros son simplemente como datos binarios y su hasta el uso de ellos. En este artículo veremos ejemplos de ambos tipos.

Para crear el archivo de recursos de empezar con el archivo fuente (*. RC), por ejemplo, el nombre RESOURCES.RC, que es un simple archivo de texto que contiene las entradas de recursos (nombre, clase y archivo):

   sample_bmp   BITMAP     sample.bmp 
   sample_ico   ICON       sample.ico 
   sample_cur   CURSOR     sample.cur 
   sample_ani   ANICURSOR  sample.ani 
   sample_jpg   JPEG       sample.jpg 
sample_wav ONDA sample.wav 
 TEXTO sample_txt ejemplo.txt 

Los nombres de los recursos (sample_bmp, sample_ico, etc) son arbitrarias. El tipo de recurso puede ser reconocida por la API (BITMAP, ICON, la posición del cursor) o arbitrarias (JPEG, WAVE, texto). Los nombres de archivo especificar los archivos que se incluirán en el. RES archivo (y más tarde en el. EXE).

Ahora tenemos que compilar el. RC para producir el archivo. RES archivo. Para que podamos utilizar los recursos del compilador Borland (brcc32.exe) que usted puede encontrar probablemente en Delphi de la carpeta Bin. Se trata de una simple utilidad de línea de comandos que espera que el nombre del archivo fuente como parámetro:

   C:\DELPHI\P0025>brcc32 resources 
   Borland Resource Compiler  Version 5.40 
   Copyright (c) 1990, 1999 Inprise Corporation.  All rights reserved. 
 
C: \ Delphi \ P0025> _ 

Para encargar el enlazador para incrustar el archivo de recursos en el ejecutable, usamos la directiva de archivo de recursos (R $ o $ recurso) en nuestro código Pascal Fuente:

   {$R resources.res} 

La carga de los recursos en su aplicación es fácil para el "recongnized" recursos como mapa de bits, iconos y cursores desde la API de Windows ofrece funciones (LoadBitmap, LoadIcon y LoadCursor respectivamente) para obtener maneja para estos elementos, que por ejemplo podemos asignar a la manija propiedad de los correspondientes objeto:

     Image1.Picture.Bitmap.Handle := 
       LoadBitmap(hInstance, 'sample_bmp'); 
Icon.Handle: = LoadIcon (hInstance, 'sample_ico'); 
 Screen.Cursors [1]: = LoadCursor (hInstance, 'sample_cur'); 

Para más alternativas cuando la carga de recursos de imágenes, ver el API LoadImage.

Otros recursos son poco más difícil de gestionar. Empecemos con las imágenes JPEG. La siguiente función TResourceStream utiliza para cargar el recurso como una corriente que podrá ser cargada en un objeto TJpegImage:

función GetResourceAsJpeg (const resname: string): TJpegImage; 
 var 
 Ciclo: TResourceStream; 
 empezar 
 Stream: = TResourceStream.Create (hInstance, ResName, 'JPEG'); 
 intentar 
 Result: = TJPEGImage.Create; 
 Result.LoadFromStream (Stream); 
 finalmente 
Stream.Free; 
 final; 
 final; 

Ejemplo:

   var 
     Jpg: TJPEGImage; 
   begin 
     // ... 
     Jpg := GetResourceAsJpeg('sample_jpg'); 
     Image2.Picture.Bitmap.Assign(Jpg); 
     Jpg.Free; 
     // ... 
   end; 

Para archivos WAV necesitamos un puntero al recurso cargado en la memoria, y para un archivo de texto que tenemos que cargar un recurso en una cadena. Podemos hacerlo utilizando TResourceStream, pero veamos un ejemplo usando la API:

   function GetResourceAsPointer(ResName: pchar; ResType: pchar; 
a cabo Tamaño: longword): pointer; 
 var 
 InfoBlock: HRSRC; 
 GlobalMemoryBlock: HGLOBAL; 
 empezar 
 InfoBlock: = FindResource (hInstance, resname, ResType); 
si InfoBlock = 0 then 
 aumentar Exception.Create (SysErrorMessage (GetLastError)); 
 Tamaño: = SizeofResource (hInstance, InfoBlock); 
 si size = 0 then 
 aumentar Exception.Create (SysErrorMessage (GetLastError)); 
 GlobalMemoryBlock: = LoadResource (hInstance, InfoBlock); 
 si GlobalMemoryBlock = 0 then
 aumentar Exception.Create (SysErrorMessage (GetLastError)); 
 Result: = LockResource (GlobalMemoryBlock); 
 si Resultado = nil entonces 
 aumentar Exception.Create (SysErrorMessage (GetLastError)); 
 final; 

 función GetResourceAsString (ResName: pchar; ResType: pchar): string; 
 var 
 ResData: PChar; 
ResSize: longword; 
 empezar 
 ResData: = GetResourceAsPointer (resname, ResType, ResSize); 
 SetString (Result, ResData, ResSize); 
 final; 

Ejemplo de llamadas:

   var 
     sample_wav: pointer; 
 
   procedure TForm1.FormCreate(Sender: TObject); 
   var 
     size: longword; 
   begin
 ... 
 sample_wav: = GetResourceAsPointer ( 'sample_wav', 'ola', size); 
 Memo1.Lines.Text: = GetResourceAsString ( 'sample_txt', 'texto'); 
 final; 

Una vez que tengamos la ola de recursos cargados en la memoria podemos reproducirlo tantas veces como lo desee mediante el uso de la API sndPlaySound declarada en la unidad de MMSystem:

   procedure TForm1.Button1Click(Sender: TObject); 
   begin
 sndPlaySound (sample_wav, SND_MEMORY o SND_NODEFAULT o SND_ASYNC); 
 final; 

Existen algunos recursos (como fuentes y cursores animados) que no puede ser utilizado de la memoria. Estamos necesariamente tienen que guardar estos recursos a un archivo temporal en disco y cargarlos desde allí. La siguiente función guarda un recurso a un archivo:

   procedure SaveResourceAsFile(const ResName: string; ResType: pchar; 
const FileName: string); 
 empezar 
 con TResourceStream.Create (hInstance, ResName, ResType) hacer 
 intentar 
 SaveToFile (filename); 
 finalmente 
 Free; 
 final; 
 final; 

La siguiente función hace uso de la anterior para guardar un recurso en un archivo temporal:

   function SaveResourceAsTempFile(const ResName: string; 
     ResType: pchar): string; 
   begin 
     Result := CreateTempFile; 
     SaveResourceAsFile(ResName, ResType, Result); 
   end; 

El debate de la función CreateTempFile cae fuera del alcance de este artículo y su aplicación puede verse en el ejemplo adjunto a este boletín.

La siguiente función hace uso de SaveResourceAsTempFile para guardar un cursor animado-los recursos a un archivo temporal, entonces carga el cursor del archivo con LoadImage y, por último, elimina el archivo temporal. La función devuelve el manejador devuelto por LoadImage:

función GetResourceAsAniCursor (const ResName: string): hCursor; 
 var 
 CursorFile: string; 
 empezar 
 CursorFile: = SaveResourceAsTempFile (ResName, 'ANICURSOR'); 
 Resultado: LoadImage = (0, PChar (CursorFile), IMAGE_CURSOR, 0, 
0, LR_DEFAULTSIZE o LR_LOADFROMFILE); 
 DeleteFile (CursorFile); 
 si Resultado = 0 then 
 aumentar Exception.Create (SysErrorMessage (GetLastError)); 
 final; 

Llamada de ejemplo:

Screen.Cursors [1]: = GetResourceAsAniCursor ( 'sample_ani'); 
 Form1.Cursor: = 1; 

Bueno, eso es todo. Espero que les sea útil. Usted puede encontrar más información acerca de archivos de recursos en la MSDN Library:

http://msdn.microsoft.com/library/en-us/winui/hh/winui/rc_6cs3.asp

Usted puede encontrar el código fuente completo de este artículo en elarchivo que acompaña al Boletín Pascal # 25.