![]() |
Crear resource icon por código
Trato de crear por código un resource que contenga un icono, o modificar el de un ejecutable o dll para añadir un icono.
Las API: FindResource LoadResource LockResource BeginUpdateResource UpdateResource EndUpdateResource Me permiten leer un resource de un archivo (.exe o dll) y modificarlo para luego escribir en disco el archivo modificado. He conseguido esto, es decir, leer un resource de un archivo (.exe o dll), y añadírle el icodo del mismo a otro archivo. Lo que no consigo es añadir un icono extraido de un icono.ico, el HRSRC no se corresponde con el Handle de un icono. He escrito el mismo en un archivo y me he dado cuenta de que es "casi el icono", me falta conocer algo que podría ser la cabecera del .ico. Lo que quiero, si no me explico bien es convertir un archivo.ico a una imagen en memoria del tipo HRSRC para incluirlo como un recurso en un ejecutable o dll. Intuyo que debe existir una API, pero no la encuentro. Un poco de código: Código:
HICON hIcon; //con mi icono leido del archivo.icon o de lo que sea. Saludos. |
Pues lo he conseguido, pero como veo que el tema no tiene mucho interés, lo publicaré sólo si realmente le interesa a alguno.:D
Saludos. |
Cita:
Saludos |
Cita:
En cualquier caso, pensando en que tienes razón, y sin ánimo de no compartir, siempre lejos de mi intención, publico mi humilde código, siempre mejorable:rolleyes:. Pero el post va a ser un poco largo..... Me di cuenta que un archivo.ico tiene una cabecera de al menos 22 bytes, al compararlo con lo obtenido al leer un icono del recurso de un .exe o .dll. Despreciándolos se llega a un código funcional pero no universal, pues un .ico puede albergar mas de un icono, y en ese caso la cabecera es mas grande. La información necesaria está aquí. Y ahora un poco de código: Por si el tema de las definiciones de las cabeceras no queda claro, publico cómo lo he usado. Archivo Iconos.h Código:
#ifndef iconosH Código:
bool CambiaIcono(char *FuenteICO, char *DestinoExe, char* ResName, bool BorraIconResPrevio=false) Otra forma de hacerlo puede ser mapeando en memoria un HICON utilizando las mismas estructuras y las API GetIconInfo y GetDIBits. Claro que si es engorroso utilizar GetDIBits, siempre se puede hechar mano de las VCL: Código:
TIcon Icon = new TIcon; Bueno no me extiendo mas, y espero, como señala cHackAll, que sirva de ayuda o ejemplo de partida.:D Saludos. |
Bueno, en el post anterior comentaba la forma de conseguir incluir en un ejecutable o dll un nuevo icono como un recurso. Comentaba también ciertas limitaciones del Builder y el delphi, en ediciones algo antiguas, para el manejo de los colores de un icono pasado por su Handle HICON. Hice refencia a la posibilidad de mapear el HICON en memoria.
Aquí dejo un ejemplo de como pasar un HICON a memoria, en este caso un bloque con el formato del archivo del icono.ico que puede ser volcado al disco como un .ico. Nos sirve también para crear un recurso en un ejecutable o dll. Para esto temdremos que pasar, como en el post anterior, un puntero al ICONIMAGE para así poder crear el recurso. El archivo de definiciones es el mismo que en el post anterior. El código: Código:
# include "Iconos.h" Código:
TIcon *Icon = new TIcon; Saludos. |
Dado el interés que se mostró por este tema y que he ido publicando de forma desordenada código para el manejo de iconos en la sección de recursos de un ejecutable o dll, voy a tratar de ordenar ese código siguiendo este hilo. Como esto será un poco largo, lo voy a dividir en varios post.
En primer lugar, he de aclarar que los Iconos de le sección de recursos están agrupados en grupos con una cabecera de tipo GRPICONDIR. En esa cabecera tenemos, entre otras cosas, el número de imágenes que contiene y un array de entradas a cada imagen cada entrada es del tipo MEMICONDIRENTRY o GRPICONDIRENTRY (son lo mismo). Los archivos de iconos se comportan igual pero únicamente contienen un sólo Grupo con una o varias imágenes. Su cabecera es del tipo ICONDIR y este contiene, entre otras cosas, el número de iconos y las entradas correspondientes a cada uno del tipo ICONDIRENTRY. Las definiciones están publicadas aquí y su fuente está aquí. Dicho esto, lo primero que tenemos que conseguir es enumerar los recursos por su tipo, lo que nos interesa es el tipo RT_GROUP_ICON que son los grupos de iconos, es decir enumeraremos esos grupos sabiendo que cada uno puede tener varias imágenes de iconos de distinto tamaño, resolución y número de colores. Código:
//------------------------------------------------------------------------------ Por el momento doy por terminada esta primera parte. Saludos. |
Aprovecho un ratito para publicar otra parte:
Explicado los conceptos preliminares y la enumeración de recursos, pasamos a la extracción se los recursos. He escrito dos funciones bastante similares. La primera, ExtractResIconFromModule, extrae un grupo de imágenes de la sección de recursos de un ejecutable o dll. La extracción es un buffer que contiene el binario del resource. La segunda, GetFileMemIconFromModule, hace lo propio pero en un buffer imagen de un archivo.ico. De cada uno se estos buffer se podrá extraer, entonces, una imagen de un icono individual, pero esto lo realizarán otras funciones. ExtractResIconFromModule, extrae un grupo de imágenes en un buffer de memoria con cabecera GRPICONDIR (o MEMICONDIR) con las entradas a cada imagen y estas. Este buffer puede usarse para pasar el recurso entero tipo RT_GROUP_ICON a una dll o ejecutable. Esto lo realizará otra función, AddIconToExe. Código:
//--------------------------------------------------------------------------- Código:
//--------------------------------------------------------------------------- Código:
//------------------------------------------------------------------------------ Saludos.;) PD: Edito para añadir otro ejemplo: AddIconToExe |
Continúo con la extracción de iconos de la sección de recursos de un ejecutable.
GetFileMemIconFromModule está diseñada para extraer un grupo de imágenes del recurso en un buffer que pueda ser escrito directamente a un archivo.ico. El formato es un buffer con una cabecera ICONDIR, sus entradas a las imágenes y éstas mismas. Un archivo de este tipo, a diferencia con la sección de recursos de un ejecutable, sólo tiene un grupo de iconos definido en su cabecera, aunque lo habitual es que, ese grupo sólo tenga una imagen, nada impide que tenga muchas más de diferente resolución y número de colores. Código:
//------------------------------------------------------------------------------ Para ilustrar el uso de esta función propongo un código que guarda el grupo de iconos en un archivo de iconos.ico, SaveResIconToFile: Código:
//------------------------------------------------------------------------------ Saludos.;) |
En el truco 575 publico la función hIconToMem de este post y un ejemplo de como usarla para guardar en un archivo un HICON y para pasar el HICON a un componente TIcon.
Saludos.;) |
Vista la demanda para guardar correctamente un Icono dado por su Handle (HICON) desde delphi, publico una implementación en delphi:
Estructuras necesarias:
La primera función auxiliar, NColors, consigue el número de colores según el valor de BitCountPerPixel. Observar que para valores de 24 y 32 el resultado es cero: Ahora la función hIconToMem que se encargará de conseguir una imagen en memoria de un fichero.ico a partir de un Handle HICON. El código está lo suficientemente comentado:
Un ejemplo para guardar en un archivo nuestro icono dado por su Handle:
Más información aquí. Saludos. |
La franja horaria es GMT +2. Ahora son las 03:24:59. |
Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi