Cette note décrit comment l'éditeur de ressources Visual C++ prend en charge plusieurs fichiers de ressources et les fichiers d'en-tête partagées dans un seul projet ou partagent entre plusieurs projets et comment vous pouvez profiter de ce soutien. Ce billet répond à ces questions:
Vous devez être conscient que si vous ajoutez un fichier de ressources supplémentaires à votre projet, ClassWizard ne reconnaît pas les ressources dans le fichier ajouté.
Cette note est structurée pour répondre aux questions ci-dessus comme suit:
Aperçu de la façon dont Visual C++ gère les fichiers de ressources et fichiers d'en-têtes
Visual C++ gère une seule.Fichier de ressources RC et un correspondant.En-tête h comme une paire étroitement couplée de fichiers. Lorsque vous modifiez et économiser les ressources en un.Fichier RC, vous indirectement modifier et enregistrez des symboles correspondant.Dossier H. Bien que vous pouvez ouvrir et modifier des multiples.Fichiers RC à un moment (en utilisant l'interface utilisateur de Visual C++ MDI) pour toute donnée.Fichier RC vous modifier indirectement exactement un fichier d'en-tête correspondant.
Fichier d'en-tête de symbole
Par défaut, Visual C++ nomme toujours le fichier d'en-tête correspondant ressources.H, quel que soit le nom du fichier de ressources (par exemple, MYAPP.RC). À l'aide de la commande définir le fichier inclut dans Visual C++, vous pouvez modifier le nom de ce fichier d'en-tête en mettant à jour le fichier de fichier d'en-tête de symbole dans la boîte de dialogue définir comprend.
Directives de symbole lecture seule
Bien que Visual C++ n'édite un fichier d'en-tête pour tout donné.Fichier RC, Visual C++ prend en charge les références à des symboles définis dans les fichiers d'en-tête supplémentaire de lecture seule. À l'aide de la commande définir le fichier inclut dans Visual C++, vous pouvez spécifier n'importe quel nombre de fichiers d'en-tête de la lecture seule supplémentaires comme des Directives de symbole en lecture seule. La restriction « lecture seule » signifie que lorsque vous ajoutez une nouvelle ressource dans le.Fichier RC, vous pouvez utiliser un symbole défini dans le fichier d'en-tête lecture seule ; mais, si vous supprimez la ressource, le symbole reste défini dans le fichier d'en-tête de lecture seule. Vous ne pouvez pas modifier la valeur numérique attribuée à un symbole en lecture seule.
Directives de compilation
Visual C++ prend également en charge l'imbrication des fichiers de ressources, où l'on.Fichier RC est # include'd dans un autre. Lorsque vous modifiez une donnée.Fichier RC à l'aide de Visual C++, toutes les ressources dans les fichiers # include'd ne sont pas visibles. Mais lorsque vous compilez le.Fichier RC, les fichiers # include'd sont également compilés. À l'aide de la commande définir le fichier inclut dans Visual C++, vous pouvez spécifier n'importe quel nombre de # include'd.Fichiers RC : Directives de compilation.
Notez que se passe-t-il si vous lisez dans Visual C++ un.Fichier RC que # include est une autre.RC du fichier soit pas spécifié comme une Directive de compilation. Cette situation pourrait survenir lorsque vous apportez à Visual C++ un.Fichier RC qui vous avait été précédemment maintenant manuellement avec un éditeur de texte. Lorsque Visual C++ lit le # include'd.Fichier RC, elle fusionne les ressources # include'd dans le parent.Fichier RC. Lorsque vous enregistrez le parent.Fichier RC, le # include déclaration, en effet, sera remplacé par les ressources de # include'd. Si vous ne souhaitez pas cette fusion se produise, vous devez supprimer le # déclaration du parent.Fichier RC avant de lire dans Visual C++ ; puis à l'aide de Visual C++, ajouter la même instruction comme une Directive de compilation # include.
Visual C++ permet d'économiser en un.Les trois types de fichiers RC de ci-dessus défini comprend informations (fichier d'en-tête de symbole, Directives de symbole en lecture seule et les Directives de compilation) # comprennent les directives et ressources TEXTINCLUDE. Les ressources TEXTINCLUDE, un détail de mise en oeuvre que vous n'avez pas besoin normalement de traiter, sont expliqués dans Comment Visual C++ gère Set comprend les renseignements.
Analyse de AppWizard créée.RC et.Fichiers H
Examinant le code d'application produit par AppWizard donne un aperçu de la façon dont Visual C++ gère plusieurs fichiers de ressources et fichiers d'en-tête. Les extraits de code examinés ci-dessous proviennent d'une application MYAPP produite par AppWizard en utilisant les options par défaut.
Une application créée par AppWizard utilise plusieurs fichiers de ressources et de multiples fichiers d'en-tête, résumées dans le diagramme ci-dessous:
nbsp ; RESSOURCES.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2 AFXRES.RC AFXPRINT.RC & nbsp
Vous pouvez afficher ces multiples relations de fichier à l'aide de la commande Visual C++ fichier/Set comprend.
MONAPP.RC
Le fichier de ressources d'application que vous modifiez à l'aide de Visual C++.
RESSOURCES.H est le fichier d'en-tête spécifiques à l'application. Il est toujours nommé ressource.H par AppWizard, compatible avec la valeur par défaut du Visual C++ nom du fichier d'en-tête. Le # include pour ce fichier d'en-tête est la première instruction dans le fichier de ressources (MonApp.RC):
//Microsoft visual C++ généré le script de ressources
//
# include « resource.h »
RES\MYAPP.RC2
Contient des ressources qui ne seront pas éditables par Visual C++, mais seront inclus dans la finale de la compilation.Fichier EXE. AppWizard ne crée aucuns ressources par défaut, étant donné que Visual C++ peut modifier toutes les ressources standards, y compris les ressources de version (une nouveauté dans cette version). Un fichier vide est généré par AppWizard dans le cas où vous souhaitez ajouter vos propres ressources au format personnalisés à ce fichier.
Si vous utilisez des ressources mise en forme personnalisées, vous pouvez les ajouter à la RES\MYAPP.RC2 et les modifier à l'aide de l'éditeur de texte Visual C++.
AFXRES.RC et AFXPRINT.RC contiennent des ressources standards requis par certains éléments du cadre. Comme RES\MYAPP.RC2, ces deux fichiers de ressource fournie par le cadre sont # include'd à la fin du MonApp.RC et qu'ils sont spécifiés dans les Directives de compilation de la boîte de dialogue définir comprend. Ainsi, vous ne pas directement afficher ou modifier ces ressources cadre tandis que vous modifiez MonApp.RC dans Visual C++, mais ils sont compilés en binaire de l'application.Fichier RES et finale.Fichier EXE. Pour plus d'informations sur les ressources du cadre standard, y compris les procédures pour leur modification, consultez Technical Note 23.
AFXRES.H définit les symboles standards, tels ID_FILE_NEW, utilisée par le framework et spécifiquement AFXRES.RC. AFXRES.H # comprennent également de WINRES.H, qui contient un sous-ensemble de WINDOWS.H qui sont requis par Visual C++ généré.Fichiers RC ainsi que AFXRES.RC. Les symboles définis dans AFXRES.H sont disponibles lorsque vous modifiez le fichier de ressources d'application (MonApp.RC). Par exemple, ID_FILE_NEW est utilisé pour l'élément de menu nouveau dossier dans MYAPP.Ressources de menu du RC. Vous ne pouvez changer ou supprimer ces symboles cadre défini.
Y compris les fichiers d'en-tête supplémentaires
L'application créée par AppWizard comprend seulement deux fichiers d'en-tête : ressources.H et AFXRES.H. seule ressource.H est spécifique à l'application. Il se peut que vous deviez inclure les fichiers d'en-tête supplémentaire de lecture seule dans les cas suivants
Le fichier d'en-tête est fourni par une source externe, ou vous souhaitez partager le fichier d'en-tête parmi plusieurs projets ou de plusieurs parties du même projet.
Le fichier d'en-tête est mise en forme et les commentaires que vous ne voulez pas de Visual C++ pour modifier ou filtrer lorsqu'il enregistre le fichier. Par exemple, peut-être que vous souhaitez conserver # de définir qui utilisent arithmétique symbolique comme:
# define rouge 0
# define bleu 1
# define vert 2
# define ID_COLOR_BUTTON 1001
# define ID_RED_BUTTON (ID_COLOR_BUTTON + rouge)
# define ID_BLUE_BUTTON (ID_COLOR_BUTTON + bleu)
# define ID_GREEN_BUTTON (ID_COLOR_BUTTON + vert)
Vous pouvez inclure des fichiers d'en-tête supplémentaire de lecture seule à l'aide de la commande Set comprend les fichier pour spécifier les # include déclaration comme une deuxième Directive de symbole en lecture seule, comme dans:
# include « afxres.h »
# include « second.h »
Le nouveau diagramme de relation du fichier ressemble maintenant à ceci:
nbsp ; AFXRES.RESSOURCES H.SECONDE H.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2 AFXRES.RC AFXPRINT.RC & nbsp
Partage d'un fichier d'en-tête entre les deux.Fichiers RC
Vous pouvez partager un fichier d'en-tête entre les deux.Fichiers RC qui se trouvent dans différents projets, ou peut-être le même projet. Pour ce faire, appliquer simplement la technique accessible en lecture seule Directives décrite ci-dessus à la fois.Fichiers RC. Dans le cas où les deux.Fichiers RC sont pour différentes applications (différents projets), le résultat est illustré dans le diagramme suivant:
nbsp ; RESSOURCES.H AFXRES.RESSOURCES H.H (pour MYAPP1) deuxième.H (for MYAPP2)
\ / \ /
\ / \ /
MYAPP1.RC MYAPP2.RC
/ \ / \
/ \ / \
RES\MYAPP1.RC2 AFXRES.RC RES\MYAPP2.RC2 AFXPRINT.RC & nbsp
Le cas où le second fichier d'en-tête est partagé par deux.Fichiers RC dans la même application (projet) est abordée plus loin.
À l'aide de plusieurs fichiers de ressources dans le même projet
Visual C++ et le compilateur de ressources prend en charge plusieurs.Fichiers RC dans le même projet par # de comprennent un.Fichier RC dans une autre. Imbrication multiples est autorisée. Il y a diverses raisons de diviser les ressources de votre projet en multiples.Fichiers RC:
Vous pouvez # inclure une seconde.RC dans les Directives de compilation dans la boîte de dialogue définir comprend:
# include "res\myapp.rc2"nbsp ; / / non - Visual C++ sous la Direction des ressources
# include « second.rc » / / le SECO&ND.RC FICHIER
# include « afxres.rc » / / norme composants
# include « afxprint.rc » / / impression/imprimer aperçu des ressources
Le résultat est illustré dans le diagramme suivant:
nbsp ; RESSOURCES.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
SECONDE.RC AFXRES.RC AFXPRINT.RC & nbsp
À l'aide de Directives de compilation, vous pouvez organiser vos ressources visuelles de C++-modifiables et non modifiables en multiples.Fichiers RC, où le « maître » MonApp.RC ne fait rien mais # inclure l'autre.Fichiers RC. Si vous utilisez un projet Visual C++.MAK fichier, puis vous devez inclure le « maître ».RC du fichier dans le projet afin que toutes les ressources de la # include'd sont compilés avec votre demande.
Exécution des fichiers Visual C++ Non éditable
Les RES\MYAPP créés par AppWizard.Fichier RC2 est un exemple d'un fichier qui contient les ressources que vous ne voulez lire accidentellement dans Visual C++ et l'écrire puis régularisez avec perte d'informations de formatage. Afin de protéger contre cela, nous mettons les lignes suivantes au début de la RES\MYAPP.Fichier RC2:
# ifdef APSTUDIO_I&NVOKED
nbsp ; # Error ce fichier n'est pas modifiable par Visual C++
# endif //APSTUDIO_INVOKED
Lorsque Visual C++ compiler le.Fichier RC, il définit APSTUDIO_INVOKED comme RC_INVOKED. Si la structure de fichiers créés par AppWizard est corrompue et Visual C++ lit la ligne de type ci-dessus, il signale une erreur fatale et abandonner la lecture de la.Fichier RC.
Gestion des symboles partagés par plusieurs Visual C++-édité.Fichiers RC
Deux questions se posent lorsque vous fractionnez vos ressources dans plusieurs.Fichiers RC que vous souhaitez modifier séparément dans Visual C++:
Le diagramme suivant illustre une organisation.RC et.Fichiers h qui traite de la première question:
nbsp ; MO&NAPP.RC
/ \
/ \
MYSTRS.H / MYSHARED.H \ MYMENUS.H
\ / / \ \ \
\ / / \ \ \
MYSTRS.RC MYMENUS.RC
Dans cet exemple, les ressources de type chaîne sont conservés dans le fichier de ressources, MYSTRS.RC et les menus sont conservés dans un autre, MYMENUS.RC. Certains symboles, comme pour les commandes, devra peut-être être partagées entre les deux fichiers. Par exemple, un ID_TOOLS_SPELL peut être l'ID de commande de menu pour l'élément de charme dans un menu Outils ; et il peut être également l'ID de la chaîne de l'invite de commandes s'affichée dans le cadre de la barre d'État de l'application, la fenêtre principale.
Le symbole ID_TOOLS_SPELL est conservé dans le fichier d'en-tête commun, MYSHARED.H. vous conservez ce fichier d'en-tête partagé manuellement avec un éditeur de texte ; Visual C++ ne pas directement modifier. Dans les deux ressources de fichiers MYSTRS.RC et MYMENUS.RC, vous spécifiez # inclure MYSHARED.H dans les Directives en lecture seule pour MYAPP.RC, à l'aide de la commande Set comprend des fichiers, comme décrit précédemment.
Il est plus commode d'anticiper un symbole vous partagerez avant que vous essayez d'utiliser pour identifier toutes les ressources. Ajouter le symbole dans le fichier d'en-tête partagé et, si vous ne l'avez pas déjà # include'd le fichier d'en-tête partagé dans les Directives en lecture seule pour le.RC du fichier, de le faire avant d'utiliser le symbole. Si vous n'avait pas prévu de partager le symbole de cette manière, alors vous devrez manuellement (à l'aide d'un éditeur de texte) déplacer le # define déclaration pour le symbole de, disons, MYMENUS.H MYSHARED.H avant de l'utiliser en MYSTRS.RC.
Lorsque vous gérez des symboles multiples.Fichiers RC, vous aussi devez aider Visual C++ éviter d'attribuer le même ID de valeurs numériques aux ressources distinctes (symboles). Pour toute donnée.Fichier RC, Visual C++ affecte progressivement ID dans chacun des quatre domaines d'ID. Entre les sessions d'édition, Visual C++ assure le suivi de la dernière ID il attribué dans chacun des domaines dans le fichier d'en-tête de symbole pour le.Fichier RC. Voici ce que les valeurs APS_NEXT sont pour un vide (nouveau).Fichier RC:
# define _APS_&NEXT_RESOURCE_VALUEnbsp ; 101
# define _APS_NEXT_COMMAND_VALUE 40001
# define _APS_NEXT_CONTROL_VALUE 1000
# define _APS_NEXT_SYMED_VALUE 101
_APS_NEXT_RESOURCE_VALUE est la prochaine valeur de symbole qui sera utilisée pour une ressource de boîte de dialogue, ressource menu et ainsi de suite. La plage valide pour les valeurs de symbole de ressources est de 1 à 0x6FFF.
_APS_NEXT_COMMAND_VALUE est la prochaine valeur de symbole qui est utilisée pour une identification de la commande. La plage valide pour les valeurs de symbole de commandement est 0 x 8000 à 0xDFFF.
_APS_NEXT_CONTROL_VALUE est la prochaine valeur de symbole qui sera utilisée pour un contrôle de boîte de dialogue. La plage valide pour les valeurs de symbole pour le contrôle de dialogue est 8 à 0xDFFF.
_APS_NEXT_SYMED_VALUE est la prochaine valeur de symbole qui sera délivrée lorsque vous affecter manuellement une valeur de symbole à l'aide de la commande nouveau dans le navigateur de symbole.
Visual C++ commence avec des valeurs légèrement plus élevés que juridique plus basse valeur lorsque la création d'un nouveau.Fichier RC. AppWizard initialisera également ces valeurs à quelque chose de plus approprié pour les applications MFC. Pour plus d'informations sur les chaînes de valeur ID, consultez Technical Note 20.
Maintenant chaque fois que vous créez un nouveau fichier de ressources, même dans le même projet, Visual C++ définit les mêmes valeurs _APS_NEXT_ . Cela signifie que si vous ajoutez, dire, plusieurs boîtes de dialogue de deux différentes.Fichiers RC, il est fort probable que le même # définir valeur sera affectée à différentes boîtes de dialogue. Par exemple, IDD_MY_DLG1 dans la première.Fichier RC pourrait être attribué le même numéro, 101, comme IDD_MY_DLG2 en une seconde.Fichier RC.
Pour éviter cela, vous devez réserver une plage numérique distincte pour chacun des quatre domaines d'ID dans les respectifs.Fichiers RC. Pour ce faire mettre à jour manuellement les valeurs _APS_NEXT dans chacune de la.Fichiers RC avant de que commencer à ajouter des ressources. Par exemple, si le premier.Fichier RC utilise les valeurs par défaut _APS_NEXT , puis vous pouvez attribuer les valeurs suivantes de la _APS_NEXT à la seconde.Fichier RC:
# define _APS_&NEXT_RESOURCE_VALUEnbsp ; 2000
# define _APS_NEXT_COMMAND_VALUE 42000
# define _APS_NEXT_CONTROL_VALUE 2000
# define _APS_NEXT_SYMED_VALUE 2000
Bien sûr, il est toujours possible que Visual C++ assignera ID tant dans la première.Fichier RC que les valeurs numériques commencent à se chevauchent ceux réservés pour le second.Fichier RC. Vous devez réserver suffisamment grandes plages afin que cela ne se produit pas.
Gestion des dépendances entre.RC.RPC, et.Fichiers H
Lorsque Visual C++ enregistre un.Fichier RC, il enregistre également les changements de symbole à la ressource correspondante.Dossier H. Une des votre.Fichiers RPC qui font référence à des ressources dans le.Fichier RC doit # inclure la ressource.Dossier H, généralement de l'intérieur fichier d'en-tête principal de votre projet. Ceci conduit à un effet secondaire indésirable en raison de la gestion de projet interne de l'environnement de développement qui analyse les fichiers source des dépendances de l'en-tête. Chaque fois que vous ajoutez un nouveau symbole dans Visual C++, toutes les.Fichier de la RPC que # include des ressources.H aurait besoin d'être recompilées.
Visual C++, contourne la dépendance à l'égard des ressources.H y compris le commentaire qui suit la première ligne de la ressource.Fichier H:
//{{NO_DEPENDENCIES}}
L'environnement de développement interprète ce commentaire en ignorant les modifications apportées à la ressource.H si cette charge.Fichiers RPC n'auront pas besoin de l'être recompilée.
Visual C++ toujours ajoute la //{{NO_DEPENDENCIES}} à la ligne de commentaire un.Fichier RC lorsqu'il enregistre le fichier. Dans certains cas, contourner de la dépendance de compilation sur les ressources.H peut conduire à des erreurs d'exécution sans être détectés au moment de la liaison. Par exemple, si vous utilisez le navigateur de symbole pour modifier la valeur numérique attribuée à un symbole d'une ressource, la ressource ne sera pas correctement trouvée et chargée si run-time de demande le.Fichier RPC se référant à la ressource n'est pas recompilé. Dans de tels cas, vous devez explicitement recompiler tout.Fichiers RPC que vous connaissez sont touchés par les changements de symbole dans les ressources.H ou sélectionnez reconstruire tous. Si vous avez le besoin de changer fréquemment les valeurs de symbole pour un certain groupe de ressources, vous sans doute trouverez plus commode et plus sûr de sortir de ces symboles dans un fichier d'en-tête distinct de lecture seule, tel que décrit dans la section ci-dessus, Y compris des fichiers d'en-tête supplémentaires.
Comment Visual C++ gère ensemble comprend des informations
Tel que mentionné précédemment, le menu fichier, commande Set comprend vous permet de spécifier trois types d'informations:
Ce qui suit décrit comment Visual C++ maintient cette information dans un.Fichier RC. Vous n'avez pas cette information pour utiliser Visual C++, mais il peut améliorer votre compréhension afin que vous pouvez utiliser avec plus de confiance la fonctionnalité Set comprend.
Chacun des trois types de Set comprend les renseignements ci-dessus est stockée dans le.Fichier RC sous deux formes: (1): # inclure ou autres directives interprétables par le compilateur de ressources et (2) comme TEXTINCLUDE ressources spéciales interprétables uniquement par Visual C++.
Le but de la ressource TEXTINCLUDE est de stocker en toute sécurité définie comprennent des renseignements sous une forme qui est facilement présentable dans valeur boîte de dialogue de Visual C++. TEXTINCLUDE est un type de ressources définis par Visual C++. Visual C++ reconnaît trois ressources TEXTINCLUDE spécifiques qui ont de la ressource, les numéros d'identification 1, 2 et 3:
| TEXTINCLUDE ressource i.d. | Type de Set comprend les renseignements |
| 1 | Fichier d'en-tête de symbole |
| 2 | Directives de symbole lecture seule |
| 3 | Directives de compilation |
Chacun des trois types d'information Set comprend est illustrée par la valeur par défaut MonApp.RC et ressources.H fichiers créés par AppWizard, comme décrit ci-dessous. Le \0 supplémentaire et » « jetons entre les blocs BEGIN et END sont tenus par la syntaxe de la RC pour spécifier zéro chaînes fin et le caractère guillemet double respectivement.
Fichier d'en-tête de symbole
La forme de l'information de la fichier d'en-tête de symbole interprétée par le compilateur de ressources est tout simplement un # include déclaration:
# include « resource.h »
La ressource TEXTINCLUDE correspondante est:
1 TEXTINCLUDE JETABLES
BEGIN
# resource.h\0 »
FIN
Directives de symbole lecture seule
Directives de symbole de lecture seule sont inclus au sommet du MonApp.RC sous la forme suivante interprétable par le compilateur de ressources:
# include « afxres.h »
La ressource TEXTINCLUDE correspondante est:
2 TEXTINCLUDE JETABLES
BEGIN
"# include" « afxres.h""\r\n »
« \0 »
FIN
Directives de compilation
Directives de compilation sont inclus à la fin du MonApp.RC sous la forme suivante interprétable par le compilateur de ressources:
# ifndef APSTUDIO_I&NVOKED
///////////////////////
//
/ / De TEXTINCLUDE 3
//
# include "res\myapp.rc2"nbsp ; / / non - Visual C++ sous la Direction des ressources
# include « afxres.rc » / / norme composants
# include « afxprint.rc » / / impression/imprimer aperçu des ressources
# endif / / pas APSTUDIO_INVOKED
La directive APSTUDIO_INVOKED # ifndef indique à Visual C++ pour sauter des Directives de compilation.
La ressource TEXTINCLUDE correspondante est:
3 TEXTI&NCLUDE JETABLES
BEGIN
"# include" « res\myapp.rc2""nbsp ; / / non - Visual C++ édité resources\r\n »
« \r\n »
« # include "" afxres.rc"" / / Standard components\r\n »
« # include "" afxprint.rc"" / / impression/imprimer aperçu resources\r\n »
« \0 »
FIN
&Notes techniques par le numéro |nbsp ; Notes techniques par catégorie