Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Los recursos personalizados son un tipo de recurso utilizado en los programas de Windows para almacenar datos, imágenes, audio, archivos binarios, etc. específicos de la aplicación. A través de recursos personalizados, los desarrolladores pueden administrar y almacenar de forma centralizada varios archivos de recursos requeridos por la aplicación para facilitar el acceso y uso en el programa.

■A continuación se detallan algunos puntos clave sobre los recursos personalizados:

●Tipos de recursos personalizados:

1. Los recursos personalizados pueden ser datos o archivos específicos de la aplicación, como imágenes, audio, archivos de configuración XML, archivos de texto, etc.

2. Los recursos personalizados se pueden identificar mediante un identificador de tipo de recurso personalizado, como "MY_CUSTOM_RESOURCE".

●Crear y editar recursos personalizados:

1. Los recursos personalizados normalmente se incluyen en el archivo de recursos de una aplicación (.rc).

2. Los recursos personalizados se pueden crear y editar utilizando un editor de recursos, como la Vista de recursos de Visual Studio.

3． En el archivo de recursos, puede especificar un identificador de recurso único y la ruta del archivo de recursos correspondiente para cada recurso.

●Consultar y utilizar recursos personalizados:

1. Al hacer referencia y utilizar recursos personalizados en el código, puede utilizar identificadores de recursos para cargar o acceder a los recursos correspondientes.

2. Utilice las funciones API correspondientes (como LoadResource, FindResource, LockResource, etc.) para cargar y operar recursos personalizados.

3． Dependiendo del tipo de recurso personalizado, puede usar diferentes funciones API (por ejemplo, los recursos de imagen pueden usar funciones GDI y los recursos de audio pueden usar funciones DirectSound) para procesar recursos personalizados.

■El siguiente es un fragmento de código de muestra que muestra cómo cargar y utilizar un recurso personalizado:

#incluir<Windows.h>

int principal()

{

HINSTANCE hInstance = GetModuleHandle(NULL); // Obtener el identificador de instancia actual

HRSRC hResource = FindResource(hInstance, MAKEINTRESOURCE(IDR_MY_RESOURCE), "MY_CUSTOM_RESOURCE");

HGLOBAL hResData = LoadResource(hInstance, hResource); // Cargar recursos personalizados

LPVOID pData = LockResource(hResData); // Bloquear recursos personalizados

// Utiliza recursos personalizados...

devuelve 0;

}

En el ejemplo anterior, IDR_MY_RESOURCE es el identificador del recurso personalizado y la ruta del archivo de recursos correspondiente se define en el archivo de recursos. Utilice la función FindResource para buscar el recurso personalizado, luego utilice la función LoadResource para cargar el recurso personalizado y, finalmente, utilice la función LockResource para bloquear el recurso personalizado y obtener un puntero a los datos del recurso. Posteriormente, el puntero pData se puede utilizar para procesamientos y operaciones posteriores según el tipo y requisitos del recurso.

Es importante tener en cuenta que la forma en que se utiliza un recurso personalizado depende del tipo de recurso y de las necesidades de la aplicación. Los desarrolladores pueden elegir los tipos de recursos apropiados y las funciones API correspondientes para procesar recursos personalizados según las necesidades reales.

Los recursos personalizados proporcionan un método flexible de administración de recursos para las aplicaciones. Se puede administrar y utilizar de manera uniforme y fácil en el programa varios datos y archivos requeridos por la aplicación. Al utilizar recursos personalizados, puede hacer que su aplicación sea más modular, mantenible y extensible.

       ■en VSAgregar recursos personalizados en

1. Agregar recursos

2. Haga clic en "Personalizar" y complete el tipo de recurso "TEXTO"

3. Importe recursos y genere automáticamente el archivo text1.bin, ID de recurso: IDR_TEXT1

4. En VS, ingrese directamente el nombre del archivo de recursos en el compilador personalizado y modifique la ID. Aparece un mensaje de error: No se pueden cargar recursos externos; la posible razón es que los recursos no se importan.

5. Agregue recursos en el cuadro de vista de recursos.

6. Importe archivos de recursos externos.

7. Complete el nombre del archivo de recursos y el ID. Tenga en cuenta que el nombre del ID debe completarse con la cadena entre comillas "ANNABELLEE".

8. Simplemente guarde la configuración.

 

Existe un método más simple: modificar directamente el archivo de recursos POEPOEM.rc. Simplemente agregue recursos debajo de la línea debajo de TEXTO.

      

9.1.6 Ejercicio 57: tabla de recursos de cadenas y recursos personalizados

/*------------------------------------------------------------------------

057 API WIN32 Practica cada día

     Ejemplo 57 POEPOEM.C: tabla de recursos de cadenas y recursos personalizados

Cadena de carga función

Cargar recurso función

Encontrar recurso función

Recurso de bloqueo función

AnsiNext Definición de macros

(c) www.bcdaren.com Programador

-----------------------------------------------------------------------*/

#incluir <windows.h>

#incluir "recurso.h"

LRESULT LLAMAR DE VUELTA Proceso de viento (HWND, Unidad Interna, Parámetros Parámetros WPARAM, LPARAM) ;

ANTECEDENTES sugerencia ;

En t WINAPÍ WinMain (ANTECEDENTES hInstancia, ANTECEDENTES hPrevInstancia,

 PSTR Línea de comando szCmd, En t iCmdMostrar)

{   //Nombre del archivo de recursos, título y mensaje de error

     TCHAR nombre de la aplicación sz[16], szCaption[64], Mensaje de error[64];

     HWND carajo;

     glutamato monosódico mensaje;

     CLASE DE WND clase de viento;

     //Cargar recursos de cadena

     Cadena de carga(hInstancia, IDS_NOMBRE_APLICACIÓN, nombre de la aplicación sz,

          tamaño de(nombre de la aplicación sz) / tamaño de(TCHAR));

     Cadena de carga(hInstancia, Título de identificación, szCaption,

          tamaño de(szCaption) / tamaño de(TCHAR));

     clase de viento.estilo = CS_HREDRAW | CS_VREDRAW;

     clase de viento.procedimiento lpfnWnd = Proceso de viento;

     clase de viento.cbClsExtra = 0;

     clase de viento.cbWndExtra = 0;

     clase de viento.hInstancia = hInstancia;

//agregar icono

     clase de viento.icono h = Icono de carga(hInstancia, HACER RECURSO(IDI_ICONO1));

     //wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

//Puntero del mouse personalizado

     clase de viento.Cursor h = Cargar cursor(hInstancia,HACER RECURSO(Cursor IDC_1));

     clase de viento.Antecedentes de hbr = (HBRUSH)Obtener objeto de stock(PINCEL BLANCO);

     clase de viento.lpszNombreMenú = NULO;

     clase de viento.lpszNombreClase = nombre de la aplicación sz;

     //hInst = hInstancia;//No está en el código original y no se informará ningún error.

     si (!RegistrarClase(&clase de viento))

     {

          //LoadStringA(hInstance, IDS_APPNAME, (carácter *)szAppName,

          // tamaño de(szAppName));

          CargarCadenaA(hInstancia, Identificación de errores_ERRMSG, (carbonizarse *)Mensaje de error,

               tamaño de(Mensaje de error));

          Cuadro de mensaje A(NULO, (carbonizarse *)Mensaje de error,

               (carbonizarse *)nombre de la aplicación sz,

               Error de icono MB);

          devolver 0;

     }

     carajo = Crear ventana(nombre de la aplicación sz, szCaption,

          WS_VENTANA SUPERPUESTA | WS_CLIPCHILDREN,

          CW_USEDEFAULT, CW_USEDEFAULT,

          CW_USEDEFAULT, CW_USEDEFAULT,

          NULO, NULO, hInstancia, NULO);

     Mostrar ventana(carajo, iCmdMostrar);

     Ventana de actualización(carajo);

     mientras (Obtener mensaje(&mensaje, NULO, 0, 0))

     {

          Traducir mensaje(&mensaje);

          Mensaje de Despacho(&mensaje);

     }

     devolver mensaje.parámetro;

}

LRESULT LLAMAR DE VUELTA Proceso de viento ( HWND carajo, Unidad Interna mensaje, Parámetros Parámetros WPARAM parámetro, LPARAM

lParámetro)

{

     //carácter estático * pTexto;

     estático LPCSTR-LPC-LPC-LPC pText;

     estático HGLOBAL Recursos humanos;//Identificador de recursos: un identificador que apunta a un bloque de memoria

     estático HWND Desplazarse;

     estático En t iPosición, Carácter cx, Carácter ciclónico, Cliente Cy,

          iNumLineas, Desplazarse x;

     HDC HDC-1;

     ESTRUCTURA DE PINTURA PD;

     RECT rectooooo;

     TEXTEMÉTRICO también;

     cambiar (mensaje)

     {

     caso WM_CREAR:

          HDC-1 = Obtener DC(carajo);

          Obtener métricas de texto(HDC-1, &también);

          Carácter cx = también.Ancho del carácter tmAve;

          Carácter ciclónico = también.tmAltura + también.tmExternalLíder;

          LanzamientoDC(carajo, HDC-1);

//El ancho de la barra de desplazamiento vertical en píxeles.

          Desplazarse x = Obtener métricas del sistema(Desplazamiento SM_CXV);

          //Generar barra de desplazamiento

          Desplazarse = Crear ventana(TEXTOOO("barra de desplazamiento"), NULO,

               WS_NIÑO | WS_VISIBLE | SBS_VERT,

               0, 0, 0, 0,

               carajo, (HMENÚ)1, sugerencia, NULO);

          //Obtener identificador de texto

          Recursos humanos = Cargar recurso(sugerencia,

               Encontrar recurso(sugerencia, TEXTOOO("Annabel Lee"),//Asegúrese de que tenga el tipo y nombre especificados.

La ubicación del recurso en el módulo especificado.

                    TEXTOOO("TEXTO")));

          //Recuperar un puntero a un recurso específico en la memoria

          pText = (LPCSTR-LPC-LPC-LPC)Recurso de bloqueo(Recursos humanos);

          iNumLineas = 0;//Leer el número de líneas de texto.

          //Obtener el número de líneas de texto.

          mientras (*pText != '\' && *pText != '0')//Termina con o 0

          {

               si (*pText == 'norte')

                    iNumLineas++;

                //Devuelve la siguiente posición (puntero) en una cadena ansi, AnsiNext en Windows de 16 bits

//Una definición de macro, Win32 usa CharNext en su lugar (AnsiNext solo puede manejar caracteres ansi

//String; CharNext puede ser una cadena ansi o unicode)

                //pTexto = AnsiNext(pTexto);

               pText = (LPCSTR-LPC-LPC-LPC)CharSiguiente((LPCWSTR)pText);

          }

     //*pTexto = '0';//El código original aquí indica que termina con un carácter nulo; el texto real no termina con un carácter nulo.

          //Establecer barra de desplazamiento

          Establece el rango de desplazamiento(Desplazarse, Control SB, 0, iNumLineas, FALSO);

          Establece la posición de desplazamiento(Desplazarse, Control SB, 0, FALSO);

          devolver 0;

     caso TAMAÑO DE WM:

          Mover ventana(Desplazarse, PALABRA BAJA(lParámetro) - Desplazarse x, 0,

               Desplazarse x, Cliente Cy = HIWORD(lParámetro), VERDADERO);

          Enfocar(carajo);//Enfocar

          devolver 0;

     caso WM_SETFOCUS:

          Enfocar(Desplazarse);//Capturar el foco del control deslizante de la barra de desplazamiento

          devolver 0;

     caso WM_VSCROLL:

          cambiar (PALABRA BAJA(parámetro))  //Se debe agregar LOWORD porque el código de notificación está en la palabra baja.

          {

          caso SB_ARRIBA:

               iPosición = 0;

               romper;

          caso SB_INFERIOR:

               iPosición = iNumLineas;

               romper;

          caso SB_ALINEACIÓN:

               iPosición -= 1;

               romper;

          caso SB_LINEA ABAJO:

               iPosición += 1;

               romper;

          caso SB_REPÁGINA:

               iPosición -= Cliente Cy / Carácter ciclónico;

               romper;

          caso SB_PAGINA ABAJO:

               iPosición += Cliente Cy / Carácter ciclónico;

               romper;

          caso PISTA DE PULGAR SB:

               iPosición = HIWORD(parámetro);

               romper;

          }

          iPosición = máximo(0, mín.(iPosición, iNumLineas));

          si (iPosición != Obtener posición de desplazamiento(Desplazarse, Control SB))

          {

               Establece la posición de desplazamiento(Desplazarse, Control SB, iPosición, VERDADERO);

               InvalidarRect(carajo, NULO, VERDADERO);

          }

          devolver 0;

     caso WM_PINTURA:

          HDC-1 = Empezar a pintar(carajo, &PD);

          pText = (carbonizarse *)Recurso de bloqueo(Recursos humanos);

          ObtenerRectClient(carajo, &rectooooo);

          rectooooo.izquierda += Carácter cx;//Mostrar a partir de la columna 2

          rectooooo.arriba += Carácter ciclónico * (1 - iPosición);

          // Incluye la altura inicial de la línea exterior de la fuente. Normalmente, los encabezados de las líneas exteriores no se incluyen en la altura de una línea de texto.

          DibujarTextoA(HDC-1, pText, -1, &rectooooo, DT_LEADER EXTERNO);

          Pintura final(carajo, &PD);

          devolver 0;

     caso WM_DESTRUIR:

          Recurso gratuito(Recursos humanos);

          Mensaje posterior al abandono(0);

          devolver 0;

     }

     devolver DefWindowProc(carajo, mensaje, parámetro, lParámetro);

}

/******************************************************************************

Cadena de carga Función: carga un recurso de cadena y luego copia la cadena en un búfer con un carácter nulo de terminación.

O devolver un puntero de solo lectura al propio recurso de cadena.

*******************************************************************************

Cargar recurso Función: recupera un identificador que se puede utilizar para obtener un puntero al primer byte del recurso especificado en la memoria.

Recurso de carga HGLOBAL(

HMODULE hMódulo,// Un identificador del módulo cuyo ejecutable contiene el recurso.Si hModule es NULL, el sistema cargará el recurso del módulo utilizado para crear el proceso actual.

Información de investigación del HRSRC//El identificador del recurso a cargar.

);

*******************************************************************************

Encontrar recurso Función: Determina la ubicación de un recurso del tipo y nombre especificados en el módulo especificado

Buscador de recursos HRSRC A(

HMODULE hMódulo,//Identificador del módulo que contiene el recurso.

LPCSTR lpNombre,//nombre del recurso

LPCSTR lpTipo//Tipo de recurso

);

*******************************************************************************

Recurso de bloqueo Función: recuperar un puntero a un recurso específico en la memoria

Recurso de bloqueo LPVOID(

Datos de Reseña de HGLOBAL//El identificador del recurso al que se accederá.

);

*******************************************************************************

AnsiNext Definición de macros:

16Una función API en Windows (una definición de macro para ser precisos) que solo puede procesar cadenas ANSI;

Más tarde, cuando apareció Win32, Microsoft implementó la encapsulación a través de CharNext para mayor compatibilidad.

CharSiguientePuede ser una cadena ansi o unicode.

Esta función devuelve la siguiente posición (puntero) en la cadena ansi.

*/

Recurso.harchivo principal

//{{SIN DEPENDENCIAS}}

// Microsoft Visual C++ Archivos de inclusión generados.

// Para uso de 057_POEPOEM.rc

//

#define IDS_APPNAME 1

#define IDS_Caption 2

#define IDS_CAPTION 3

#define IDS_ERRMSG 4

#define IDI_ICON1 1

#define IDC_CURSOR1 2

#define IDR_TEXT1 107

#define IDR_TEXT2 108

// Próximos valores predeterminados para nuevos objetos

//

#ifdef APSTUDIO_INVOCADO

#ifndef SÍMBOLOS DE LECTURA DE APSTUDIO

#define _VALOR_DE_RECURSO_APS_SIGUIENTE 126

#define _VALOR_DE_COMANDO_APS_SIGUIENTE 40002

#define _VALOR_DE_CONTROL_APS_SIGUIENTE 1001

#define _APS_SIGUIENTE_VALOR_SYMED 101

#terminara si

#terminara si

057_POEPOEM.rcLos archivos de script de recursos contienen 4 tipos de recursos:

1 ． Recursos de iconos:

// Icono

//

IDI_ICON1 ICONO "D:\code\windows5.0\A diario

práctica\057_POEPOEM\057_POEPOEM\icon1.ico"

2 ． Recurso de mapa de bits del puntero del mouse:

// Cursor

//

IDC_CURSOR1 CURSOR "cursor1.cur"

3 ． Tabla de recursos de cadenas:

// Tabla de cadenas

//

TABLA DE CADENA

COMENZAR

IDS_APPNAME "PoemaPoema"

IDS_CAPTION """Annabel Lee"" de Edgar Allan Poe"

IDS_ERRMSG "¡Este programa requiere Windows NT!"

FIN

4 ． Recursos personalizados:

// TEXTO

//

TEXTO DE ANNABELLEE "POEPOEM.TXT"

resultado de la operación:

Figura 9-9 Tabla de recursos de cadenas y recursos personalizados

 

Resumir

En el script de recursos POEPOEM.RC, el recurso definido por el usuario se especifica como tipo TEXTO y el nombre del texto es "ANNABELLEE": ANNABELLEE TEXT POEPOEM.TXT

Al procesar el mensaje WM_CREATE en WndProc, el identificador del recurso se obtiene a través de FindResource y LoadResource. LockResource bloquea el recurso y una pequeña rutina reemplaza la barra invertida final ( ) en el archivo por 0. Esto es para facilitar el uso de la función DrawText en el mensaje WM_PAINT posterior.

[Nota] Usamos el control de la barra de desplazamiento de la subventana en lugar de la barra de desplazamiento de la ventana. El control de la barra de desplazamiento de la subventana tiene una interfaz de teclado automática, por lo que no es necesario procesar el mensaje WM_KEYDOWN en POEPOEM.

POEPOEM también utiliza tres cadenas, cuyos ID se definen en el archivo de encabezado RESOURCE.H. Al comienzo del programa, LoadString carga las cadenas IDS_APPNAME e IDS_CAPTION en la memoria:

Cadena de carga (hlnstance, IDS_APPNAME, szAppName,

tamaño de (szAppName) / tamaño de (TCHAR));

Cadena de carga (hlnstance, IDS_CAPTION, szCaption,

tamaño de (szCaption) / tamaño de (TCHAR));

[Nota] Estas dos llamadas preceden a RegisterClass. El programa usa LoadStringA para cargar las cadenas IDS_APPNAME e IDS_ERRMSG, y usa MessageBoxA para mostrar un cuadro de mensaje personalizado:

si (!RegisterClass (&wndclass))

{

LoadStringA (hInstance, IDS_APPNAME, (char *) szAppName,

tamaño de (szAppName));

LoadStringA (hInstance, IDS_ERRMSG, (carácter *) szErrMsg,

tamaño de (szErrMsg));

MessageBoxA (NULL, (carácter *) szErrMsg,

(char *) szAppName, MB_ICONERROR);

devuelve 0;

}

[Nota] Fuerce la conversión de la variable de cadena TCHAR al puntero char.

AnsiNext es una definición de macro en Windows de 16 bits que usa CharNext en su lugar (AnsiNext solo puede manejar cadenas ansi; CharNext puede manejar tanto cadenas ansi como cadenas Unicode).

pTexto = AnsiNext(pTexto);

Reemplazar con:

pTexto = (LPCSTR)CharNext((LPCWSTR)pTexto);

Todas las cadenas utilizadas por POEPOEM se definen como recursos, por lo que los traductores pueden convertir fácilmente el programa a versiones que no estén en inglés.