Lazarus Resources/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Los archivos de recursos contienen información que debe ser compilada en el archivo exe. Esos datos pueden ser imágenes, tablas de cadenas, la información de versión, ... incluso un manifiesto Windows XP y formularios. Con ello se incluyen datos que el programador puede recuperar en su código (acceso a los mismos como si fuesen archivos). El uso de recursos puede ser útil si quiere distribuir ejecutables autónomos .
2	2
3	3		En las versiones previas a la 2.4 de FPC no era posible utilizar los recursos "normales", archivos de recursos (. res), en Lazarus, ya que son específicos de win32. Si queremos utilizar los recursos de todos modos, tendremos que volver a crearlos con lazres*. Lazres se encuentra en el directorio de herramientas de la carpeta de instalación de Lazarus (tal vez antes haya que compilarlo).
4	4
5	5		Ahora ya podemos compilar archivos de recursos de Lazarus (*.lrs) desde la línea de ordenes. La sintaxis para lazres es:
6	6
7		-	~~`lazres <nombre del archivo de recursos> <archivo1 (archivo2 archivo3 ...)>`~~
	7	+	```text
	8	+	lazres <nombre del archivo de recursos> <archivo1 (archivo2 archivo3 ...)>
	9	+	```
8	10
9	11		Por Ejemplo:
10	12
11		-	~~`lazres mirecursolazarus.lrs un_icono.ico`~~
	13	+	```text
	14	+	lazres mirecursolazarus.lrs un_icono.ico
	15	+	```
12	16
13	17		Para utilizar un archivo de recursos de Lazarus en tus proyectos incluye el archivo correspondiente con la directiva del compilador \$I en la sección de inicio (initialization) de la unidad.
14	18
15	19		Puedes acceder a los datos de los recursos con el método LoadFromLazarusResource de los objetos que contendrán los contenidos de los archivos. LoadFromLazarusResource necesita un parámetro de cadena que indica qué objeto debe ser cargado desde el archivo de recursos.
16	20
17	21		Ejemplo:
18	22
19	23		``` pascal
20	24		...
21	25		procedure ejemploproc;
22	26		var
23	27		icono: TIcon;
24	28		begin
25	29		icono := TIcon.Create;
26	30		icono.LoadFromLazarusResource('un_icono');
27	31		end;
28	32
29	33		initialization
30	34		{$I mirecursolazarus.lrs}
31	35		...
32	36		```
33	37
34	38		Mediante {\$I mirecursolazarus.lrs} incluimos el archivo mirecursolazarus.lrs en la unidad compilada. En el procedimiento ejemploproc creamos la variable icono de tipo TIcon y cargamos en ella el objeto de nombre "un_icono" del archivo de recursos. El archivo que compiló en el archivo de recursos fue probablemente el de nombre un_icono.ico.
35	39
36	40		Todas las clases que se derivan de TGraphic contienen el procedimiento LoadFromLazarusResource.
37	41
38	42		## El archivo de recursos Lazarus del formulario
39	43
40	44		Lazarus genera un archivo .lrs del archivo de formulario .lfm. Pero no lo hace de forma automática si no existe el archivo .lrs; en esta situación FPC dará al compilar un mensaje como este: ''ERROR: unidad001.pas(24,4) Fatal: Can't open include file "unidad001.lrs".
41	45
42	46		Para solucionarlo podemos utilizar lazres: (LazarusDir)\tools\lazres unidad001.lrs unidad001.lfm. En linux: ~\$ lazres unidad001.lrs unidad001.lfm.
43	47
44	48		La forma más sencilla de rehacer un archivo .lrs es realizar un cambio trivial en el diseño del formulario, deshacerlo y guardar el formulario; así no necesitaremos recurrir a lazres. Vincent 09:47, 6 enero 2009 (CET)
45	49
46	50		## Obtener los datos en bruto de un recurso lrs
47	51
48	52		Puedes recuperar los datos de un recurso tal como se muestra en este código:
49	53
50	54		``` pascal
51	55		uses ...LResources...;
52	56
53	57		...
54	58		procedure TForm1.FormCreate(Sender: TObject);
55	59		var
56	60		r: TLResource;
57	61		Datos: String;
58	62		begin
59	63		r:=LazarusResources.Find('archivoDatos1');
60	64		if r=nil then raise Exception.Create('No existe el recurso archivoDatos1');
61	65		Datos:=r.Value;
62	66		...procesar los datos...
63	67		end;
64	68		```
65	69
66	70		# Recursos FPC
67	71
68	72		A partir de FPC 2.4 se puede utilizar archivos estándar .rc (script de recursos) y .res (compilado de recursos)en tu proyecto para incluir los recursos. Para convertir la secuencia de comandos del archivo .rc usado en el código fuente en un recurso binario (archivo .res), FPC ejecuta el compilador externos adecuado para los recursos (windres o GoRC). Por lo tanto el compilador de recursos tiene que estar instalado y presente en la variable de entorno PATH.
69	73
70	74		Para simplificar el proceso de compilación, es posible utilizar únicamente los recursos compilados en los archivos .res. Puedes precompilar los recursos con cualquier compilador de recursos disponible -windres (disponible en sistemas Unix y Windows), GoRC (sólo Windows), compilador de recursos de Microsoft (rc.exe, incluido en Visual Studio), compilador de recursos Borland (Brcc32.exe, incluido en Delphi, C++ Builder o productos RAD Studio) o cualquier otro.
71	75
72	76		Utiliza las directivas {\$R nombreArchivo.rc} o {\$R nombreArchivo.res} para incluir un archivo de recursos en el ejecutable. FPC RTL ofrece dos funciones de bajo nivel, así como clases de alto nivel para acceder a los recursos.
73	77
74	78		Las funciones de bajo nivel son:
75	79
76	80		- EnumResourceTypes
77	81		- EnumResourceNames
78	82		- EnumResourceLanguages
79	83		- FindResource
80	84		- FindResourceEx
81	85		- LoadResource
82	86		- SizeofResource
83	87		- LockResource
84	88		- UnlockResource
85	89		- FreeResource
86	90
87	91		Son compatibles con las funciones API de Windows: \[<http://msdn.microsoft.com/en-us/library/ff468902(VS.85>).aspx\]
88	92
89	93		La clase principal que se utiliza para trabajar con los recursos es TResourceStream. La LCL la utiliza para cargar bitmaps incrustados, iconos y los formularios. Mira TGraphic.LoadFromResourceID o TIcon.LoadFromResourceHandle para ver cómo se utilizan dentro de la LCL.
90	94
91	95		## Añadir recursos a tu programa
92	96
93	97		Vamos a revisar la situación cuando necesitas almacenar ciertos datos dentro de tu ejecutable y durante la ejecución del programa se desea extraer estos datos del mismo.
94	98
95	99		En primer lugar tenemos que indicar al compilador qué archivos queremos incluir en el recurso. Esto lo hacemos en un archivo .rc (secuencia de comandos de recursos): Archivo MisDatos.rc:
96	100
97	101
98	102		<nowiki> MISDATOS RCDATA "misdatos.dat"</nowiki>
99	103
100	104		Donde MISDATOS es el nombre del recurso, RCDATA es el tipo del recurso ( ver <http://msdn.microsoft.com/en-us/library/ms648009(VS.85>).aspx para la explicación de los posibles tipos) y "misdatos.dat" es tu archivo de datos.
101	105
102	106		Vamos a indicar al compilador que incluya el recurso en el proyecto:
103	107
104	108		``` pascal
105	109		program misdatos;
106	110
107	111		{$R MisDatos.rc}
108	112		begin
109	113		end.
110	114		```
111	115
112	116		Silenciosamente, el compilador FPC indica ahora al compilador de recursos distribuidos con FPC a leer el guión .rc para compilar tus archivos de datos en un archivo binario .res de recursos. El enlazador entonces incluirá este en el ejecutable. Aunque esto es transparente para el programador, puedes, si lo deseas, crear su propio archivo .res con, por ejemplo el compilador de recursos de Borland. Ene ste caso, en lugar de utilizar
113	117
114	118		``` pascal
115	119		{$R MisDatos.rc}
116	120		```
117	121
118	122		habrá que utilizar
119	123
120	124		``` pascal
121	125		{$R MisDatos.res}
122	126		```
123	127
124	128		.
125	129
126	130		## Usar los recursos en tu programa
127	131
128	132		Ahora vamos a extraer los recursos alamecandos en un archivo, v.g. misdatos.dat:
129	133
130	134		``` pascal
131	135		program mydata;
132	136		uses
133	137		SysUtils;
134	138		{$R misdatos.res}
135	139		var
136	140		S: TResourceStream;
137	141		F: TFileStream;
138	142		begin
139	143		// crear un flujo derecursos que apunta al recurso
140	144		S := TResourceStream.Create(HInstance, 'MISDATOS', 'RT_RCDATA');
141	145		try
142	146		// crear el archivo misdatos.dat en el directorio de la aplicación
143	147		F := TFileStream.Create(ExtractFilePath(ParamStr(0)) + 'misdatos.dat', fmCreate);
144	148		try
145	149		F.CopyFrom(S, S.Size); // copiar los datos desde el flujo de recurso al flujo de archivo
146	150		finally
147	151		F.Free; // liberar el flujo de archivo
148	152		end;
149	153		finally
150	154		S.Free; // liberar el flujo del recurso
151	155		end;
152	156		end.
153	157		```
154	158
155	159		---
156	160		From the Free Pascal wiki, page "Lazarus Resources/es", as it stood on 2020-02-18 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
157	161		Category: Castellano
158	162		Category: Español

Back to history