Partage de technologie

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

Les ressources personnalisées sont un type de ressource utilisé dans les programmes Windows pour stocker des données, des images, de l'audio, des fichiers binaires, etc. spécifiques à une application. Grâce à des ressources personnalisées, les développeurs peuvent gérer et stocker de manière centralisée divers fichiers de ressources requis par l'application pour un accès et une utilisation faciles dans le programme.

■Voici quelques points clés concernant les ressources personnalisées :

●Types de ressources personnalisées :

1. Les ressources personnalisées peuvent être des données ou des fichiers spécifiques à une application, tels que des images, de l'audio, des fichiers de configuration XML, des fichiers texte, etc.

2. Les ressources personnalisées peuvent être identifiées à l'aide d'un identifiant de type de ressource personnalisé, tel que « MY_CUSTOM_RESOURCE ».

●Créez et modifiez des ressources personnalisées :

1. Les ressources personnalisées sont généralement incluses dans le fichier de ressources d'une application (.rc).

2. Les ressources personnalisées peuvent être créées et modifiées à l'aide d'un éditeur de ressources, tel que la vue des ressources de Visual Studio.

3. Dans le fichier de ressources, vous pouvez spécifier un identifiant de ressource unique et le chemin d'accès au fichier de ressources correspondant pour chaque ressource.

●Référez-vous et utilisez des ressources personnalisées :

1. Lorsque vous référencez et utilisez des ressources personnalisées dans le code, vous pouvez utiliser des identifiants de ressources pour charger ou accéder aux ressources correspondantes.

2. Utilisez les fonctions API correspondantes (telles que LoadResource, FindResource, LockResource, etc.) pour charger et exploiter des ressources personnalisées.

3. Selon le type de ressource personnalisée, vous pouvez utiliser différentes fonctions API (par exemple, les ressources d'image peuvent utiliser les fonctions GDI et les ressources audio peuvent utiliser les fonctions DirectSound) pour traiter les ressources personnalisées.

■Ce qui suit est un exemple d'extrait de code montrant comment charger et utiliser une ressource personnalisée :

#inclure<Windows.h>

int main()

{

HINSTANCE hInstance = GetModuleHandle(NULL); // Récupère le handle de l'instance actuelle

HRSRC hResource = FindResource(hInstance, MAKEINTRESOURCE(IDR_MY_RESOURCE), "MY_CUSTOM_RESOURCE"); // Rechercher des ressources personnalisées

HGLOBAL hResData = LoadResource(hInstance, hResource); // Charger des ressources personnalisées

LPVOID pData = LockResource(hResData); // Verrouiller les ressources personnalisées

// Utiliser des ressources personnalisées...

retourner 0;

}

Dans l'exemple ci-dessus, IDR_MY_RESOURCE est l'identifiant de la ressource personnalisée et le chemin du fichier de ressources correspondant est défini dans le fichier de ressources. Utilisez la fonction FindResource pour rechercher la ressource personnalisée, puis utilisez la fonction LoadResource pour charger la ressource personnalisée et enfin utilisez la fonction LockResource pour verrouiller la ressource personnalisée afin d'obtenir un pointeur vers les données de ressource. Par la suite, le pointeur pData peut être utilisé pour des traitements et opérations ultérieurs en fonction du type et des exigences de la ressource.

Il est important de noter que la manière dont une ressource personnalisée est utilisée dépend du type de ressource et des besoins de l'application. Les développeurs peuvent choisir les types de ressources appropriés et les fonctions API correspondantes pour traiter les ressources personnalisées en fonction des besoins réels.

Les ressources personnalisées fournissent une méthode flexible de gestion des ressources pour les applications. Diverses données et fichiers requis par l'application peuvent être gérés de manière uniforme et facilement accessibles et utilisés dans le programme. En utilisant des ressources personnalisées, vous pouvez rendre votre application plus modulaire, maintenable et extensible.

       ■en VSAjouter des ressources personnalisées dans

1. Ajouter des ressources

2. Cliquez sur "Personnaliser" et remplissez le type de ressource "TEXTE"

3. Importez des ressources et générez automatiquement le fichier text1.bin, ID de ressource : IDR_TEXT1

4. Dans VS, saisissez directement le nom du fichier de ressources dans le compilateur personnalisé et modifiez l'ID. Un message d'erreur apparaît : Impossible de charger les ressources externes - la raison possible est que les ressources ne sont pas importées.

5. Ajoutez des ressources dans la zone d'affichage des ressources.

6. Importez des fichiers de ressources externes.

7. Remplissez le nom et l'ID du fichier de ressources. Notez que le nom de l'ID doit être rempli avec la chaîne entre guillemets "ANNABELLEE".

8. Enregistrez simplement les paramètres.

 

Il existe une méthode plus simple, modifier directement le fichier de ressources POEPOEM.rc. Ajoutez simplement des ressources sous la ligne sous TEXTE.

      

9.1.6 Exercice 57 : Table de ressources de chaîne et ressources personnalisées

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

057 API WIN32 Pratiquer tous les jours

     Exemple 57 POEPOEM.C : table de ressources de chaîne et ressources personnalisées

Charger la chaîne fonction

Charger la ressource fonction

Trouver une ressource fonction

Ressource de verrouillage fonction

AnsiSuivant Définition des macros

(c) www.bcdaren.com Programmeur

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

#inclure <windows.h>

#inclure "ressource.h"

LRÉSULTAT RAPPELER WndProc (HWND, UINT, WPARAM, LPARAM) ;

Instance hInst ;

int API WIN WinMain (Instance hInstance, Instance hPrevInstance,

 PSTR szCmdLine, int iCmdShow)

{   //Nom du fichier de ressources, titre et message d'erreur

     TCHAR szAppName[16], Légende[64], szErrMsg[64];

     HWND hwnd;

     MSG message;

     CLASSE DES VENTS classe de vent;

     //Charger les ressources de chaîne

     Charger la chaîne(hInstance, ID_APPNAME, szAppName,

          taille de(szAppName) / taille de(TCHAR));

     Charger la chaîne(hInstance, IDS_CAPTION, Légende,

          taille de(Légende) / taille de(TCHAR));

     classe de vent.style = CS_HREDRAW | CS_VREDRAW;

     classe de vent.lpfnWndProc = WndProc;

     classe de vent.cbClsExtra = 0;

     classe de vent.cbWndExtra = 0;

     classe de vent.hInstance = hInstance;

//ajouter une icône

     classe de vent.hIcon = ChargerIcon(hInstance, FAITES-VOUS RESSOURCER(IDI_ICON1));

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

//Pointeur de souris personnalisé

     classe de vent.hCurseur = Charger le curseur(hInstance,FAITES-VOUS RESSOURCER(IDC_CURSOR1));

     classe de vent.hbrContexte = (Brosse à dents)Obtenir l'objet stock(PINCEAU_BLANC);

     classe de vent.lpszMenuName = NUL;

     classe de vent.Nom de la classe lpsz = szAppName;

     //hInst = hInstance;//Ce n'est pas dans le code original et aucune erreur ne sera signalée.

     si (!InscriptionClasse(&classe de vent))

     {

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

          // taille de(szAppName));

          ChargerChaîneA(hInstance, IDS_ERRMSG, (carboniser *)szErrMsg,

               taille de(szErrMsg));

          MessageBoxA(NUL, (carboniser *)szErrMsg,

               (carboniser *)szAppName,

               MB_ICONERROR);

          retour 0;

     }

     hwnd = Créer une fenêtre(szAppName, Légende,

          WS_OVERLAPPEDWINDOW | WS_CLIPENFANTS,

          CW_USEDEFAULT, CW_USEDEFAULT,

          CW_USEDEFAULT, CW_USEDEFAULT,

          NUL, NUL, hInstance, NUL);

     Fenêtre d'affichage(hwnd, iCmdShow);

     Fenêtre de mise à jour(hwnd);

     alors que (Obtenir un message(&message, NUL, 0, 0))

     {

          TraduireMessage(&message);

          Message d'envoi(&message);

     }

     retour message.wParam;

}

LRÉSULTAT RAPPELER WndProc ( HWND hwnd, UINT message, WPARAM wParam, LPARAM

lParam)

{

     //char statique * pText;

     statique LPCSTR pText;

     statique HGLOBAL hRessource;//Handle de ressource - un handle pointant vers un bloc de mémoire

     statique HWND hDéfiler;

     statique int iPosition, cxChar, cyChar, cyClient,

          iNumLines, xDéfilement;

     HDC HDC;

     PEINTURESTRUCTURE ps;

     RECT rect;

     TEXMETRIQUE m;

     changer (message)

     {

     cas WM_CRÉER:

          HDC = ObtenirDC(hwnd);

          Obtenir des mesures de texte(HDC, &m);

          cxChar = m.tmAveCharWidth;

          cyChar = m.tmHauteur + m.tmExternalLeading;

          LibérationDC(hwnd, HDC);

//La largeur de la barre de défilement verticale en pixels

          xDéfilement = Obtenir les mesures du système(SM_CXVSCROLL);

          //Générer une barre de défilement

          hDéfiler = Créer une fenêtre(TEXTEEE("barre de défilement"), NUL,

               WS_ENFANT | WS_VISIBLE | SBS_VERT,

               0, 0, 0, 0,

               hwnd, (MENU H)1, hInst, NUL);

          //Obtenir le descripteur de texte

          hRessource = Charger la ressource(hInst,

               Trouver une ressource(hInst, TEXTEEE("Annabel Lee"),//Assurez-vous qu'il a le type et le nom spécifiés

L'emplacement de la ressource dans le module spécifié

                    TEXTEEE("TEXTE")));

          //Récupérer un pointeur vers une ressource spécifiée en mémoire

          pText = (LPCSTR)Ressource de verrouillage(hRessource);

          iNumLines = 0;//Lire le nombre de lignes de texte

          //Obtenez le nombre de lignes de texte

          alors que (*pText != '\' && *pText != '0')//Terminer par ou 0

          {

               si (*pText == 'n')

                    iNumLines++;

                //Renvoie la position suivante (pointeur) dans la chaîne ansi, AnsiNext sous Windows 16 bits

//Une définition de macro, Win32 utilise CharNext à la place (AnsiNext ne peut gérer que les caractères ansi

//String ; CharNext peut être une chaîne ansi ou unicode)

                //pTexte = AnsiNext(pTexte);

               pText = (LPCSTR)CharSuivant((LPCWSTR)pText);

          }

     //*pTexte = '0';//Le code original indique ici qu'il se termine par un caractère nul --- le texte réel ne se termine pas par un caractère nul.

          //Définir la barre de défilement

          Définir la plage de défilement(hDéfiler, SB_CTL, 0, iNumLines, FAUX);

          DéfinirScrollPos(hDéfiler, SB_CTL, 0, FAUX);

          retour 0;

     cas TAILLE_WM:

          Déplacer la fenêtre(hDéfiler, LOWORD(lParam) - xDéfilement, 0,

               xDéfilement, cyClient = Mot-clé(lParam), VRAI);

          DéfinirFocus(hwnd);//Définir le focus

          retour 0;

     cas WM_SETFOCUS:

          DéfinirFocus(hDéfiler);//Capturer le focus du curseur de la barre de défilement

          retour 0;

     cas WM_VSCROLL:

          changer (LOWORD(wParam))  //LOWORD doit être ajouté car le code de notification est dans le mot faible

          {

          cas SB_HAUT:

               iPosition = 0;

               casser;

          cas SB_BAS:

               iPosition = iNumLines;

               casser;

          cas SB_ALIGNE:

               iPosition -= 1;

               casser;

          cas SB_LIGNE_BAS:

               iPosition += 1;

               casser;

          cas SB_PAGEUP:

               iPosition -= cyClient / cyChar;

               casser;

          cas SB_PAGEDOWN:

               iPosition += cyClient / cyChar;

               casser;

          cas SB_PISTE_POUCE:

               iPosition = Mot-clé(wParam);

               casser;

          }

          iPosition = max(0, min(iPosition, iNumLines));

          si (iPosition != ObtenirScrollPos(hDéfiler, SB_CTL))

          {

               DéfinirScrollPos(hDéfiler, SB_CTL, iPosition, VRAI);

               InvaliderRect(hwnd, NUL, VRAI);

          }

          retour 0;

     cas WM_PEINTURE:

          HDC = Commencer la peinture(hwnd, &ps);

          pText = (carboniser *)Ressource de verrouillage(hRessource);

          ObtenirClientRect(hwnd, &rect);

          rect.gauche += cxChar;//Affichage à partir de la colonne 2

          rect.haut += cyChar * (1 - iPosition);

          // Comprend la hauteur de la ligne extérieure de la police. Normalement, les en-têtes de lignes extérieures ne sont pas inclus dans la hauteur d'une ligne de texte.

          Dessiner un texteA(HDC, pText, -1, &rect, DT_EXTERNALLEADING);

          Fin de la peinture(hwnd, &ps);

          retour 0;

     cas WM_DÉTRUIRE:

          Ressource gratuite(hRessource);

          Message de post-quit(0);

          retour 0;

     }

     retour DefWindowProc(hwnd, message, wParam, lParam);

}

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

Charger la chaîne Fonction : charge une ressource de chaîne, puis copie la chaîne dans un tampon avec un caractère nul de fin,

Ou renvoyez un pointeur en lecture seule vers la ressource chaîne elle-même.

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

Charger la ressource Fonction : récupère un handle qui peut être utilisé pour obtenir un pointeur vers le premier octet de la ressource spécifiée en mémoire

HGLOBAL Charger la ressource(

HMODULE hModule,// Un handle vers le module dont l’exécutable contient la ressource.Si hModule est NULL, le système chargera la ressource du module utilisé pour créer le processus en cours

HRSRC hResInfo//Le handle de la ressource à charger

);

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

Trouver une ressource Fonction : Détermine l'emplacement d'une ressource du type et du nom spécifiés dans le module spécifié

HRSRC TrouverResourceA(

HMODULE hModule,//Handle du module contenant la ressource

LPCSTR lpName,//nom de la ressource

LPCSTR lpType//Type de ressource

);

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

Ressource de verrouillage Fonction : Récupérer un pointeur vers une ressource spécifiée en mémoire

Ressource de verrouillage LPVOID(

Données hRes HGLOBAL//Le handle de la ressource à laquelle accéder

);

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

AnsiSuivant Définition des macros :

16Une fonction api sous Windows (une définition de macro pour être précis) qui ne peut traiter que les chaînes ANSI ;

Plus tard, lorsque Win32 est apparu, Microsoft a implémenté l'encapsulation via CharNext pour des raisons de compatibilité.

CharSuivantIl peut s'agir d'une chaîne ANSI ou Unicode.

Cette fonction renvoie la position suivante (pointeur) dans la chaîne ansi.

*/

Ressource.hfichier principal

//{{AUCUNE_DÉPENDANCE}}

// Microsoft Visual C++ Fichiers d'inclusion générés.

// À l'usage de 057_POEPOEM.rc

//

#define IDS_APPNAME 1

#define IDS_Caption 2

#define IDS_CAPTION 3

#define IDS_ERRMSG 4

#définir IDI_ICON1 1

#define IDC_CURSOR1 2

#define IDR_TEXT1 107

#define IDR_TEXT2 108

// Valeurs par défaut suivantes pour les nouveaux objets

//

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NEXT_RESOURCE_VALUE 126

#define _APS_NEXT_COMMAND_VALUE 40002

#define _APS_NEXT_CONTROL_VALUE 1001

#define _APS_NEXT_SYMED_VALUE 101

#fin si

#fin si

057_POEPOEM.rcLes fichiers de script de ressources contiennent 4 types de ressources :

1 ． Ressources d'icônes :

// Icône

//

IDI_ICON1 ICÔNE "D:\code\windows5.0\A tous les jours

pratique\057_POEPOEM\057_POEPOEM\icon1.ico"

2 ． Ressource bitmap du pointeur de la souris :

// Le curseur

//

IDC_CURSOR1 CURSEUR "curseur1.cur"

3 ． Table de ressources de chaîne :

// Tableau de chaînes

//

TABLEAU DE CHAÎNES

COMMENCER

IDS_APPNAME "PoePoème"

IDS_CAPTION ""Annabel Lee"" d'Edgar Allan Poe"

IDS_ERRMSG « Ce programme nécessite Windows NT ! »

FIN

4 ． Ressources personnalisées :

// TEXTE

//

TEXTE D'ANNABELLEE "POEPOEM.TXT"

résultat de l'opération :

Figure 9-9 Table de ressources de chaîne et ressources personnalisées

 

Résumer

Dans le script de ressource POEPOEM.RC, la ressource définie par l'utilisateur est spécifiée comme type TEXT et le nom du texte est "ANNABELLEE" : ANNABELLEE TEXT POEPOEM.TXT

Lors du traitement du message WM_CREATE dans WndProc, le handle de la ressource est obtenu via FindResource et LoadResource. LockResource verrouille la ressource et une petite routine remplace la barre oblique inverse ( ) dans le fichier par 0. Ceci vise à faciliter l’utilisation de la fonction DrawText dans le message WM_PAINT suivant.

[Note] Nous utilisons le contrôle de la barre de défilement de la sous-fenêtre au lieu de la barre de défilement de la fenêtre. Le contrôle de barre de défilement de sous-fenêtre dispose d'une interface clavier automatique, il n'est donc pas nécessaire de traiter le message WM_KEYDOWN dans POEPOEM.

POEPOEM utilise également trois chaînes, dont les ID sont définis dans le fichier d'en-tête RESOURCE.H. Au début du programme, les chaînes IDS_APPNAME et IDS_CAPTION sont chargées en mémoire par LoadString :

LoadString (instance, IDS_APPNAME, szAppName,

taille de (szAppName) / taille de (TCHAR));

LoadString (instance, IDS_CAPTION, szCaption,

taille de (szCaption) / taille de (TCHAR)) ;

[Note] Ces deux appels précèdent RegisterClass. Le programme utilise LoadStringA pour charger les chaînes IDS_APPNAME et IDS_ERRMSG, et utilise MessageBoxA pour afficher une boîte de message personnalisée :

si (!RegisterClass (&wndclass))

{

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

taille de (szAppName)) ;

LoadStringA (hInstance, IDS_ERRMSG, (char *) szErrMsg,

taille de (szErrMsg)) ;

MessageBoxA (NULL, (char *) szErrMsg,

(char *) szAppName, MB_ICONERROR) ;

retourner 0 ;

}

[Note] Forcer la conversion de la variable de chaîne TCHAR en pointeur de caractère.

AnsiNext est une définition de macro sur Windows 16 bits. Win32 utilise CharNext à la place (AnsiNext ne peut gérer que les chaînes ansi ; CharNext peut gérer à la fois les chaînes ansi et les chaînes Unicode).

pTexte = AnsiNext(pTexte);

Remplacer par:

pTexte = (LPCSTR)CharNext((LPCWSTR)pTexte);

Toutes les chaînes utilisées par POEPOEM sont définies comme des ressources, de sorte que le programme peut facilement être converti par les traducteurs en versions non anglaises.