Esta anotação descreve como o editor de recursos do Visual C++ oferece suporte a Múltiplo arquivos de recurso e arquivos de cabeçalho compartilhados em um único projeto ou compartilhados entre Múltiplo projetos e como você pode tirar proveito desse apoio. Esta anotação responde a estas perguntas:
Você deve estar ciente que se você adicionar um arquivo de recursos adicionais ao seu projeto, ClassWizard não reconhecerá os recursos no arquivo adicionado.
Esta nota é estruturada para responder às perguntas acima da seguinte forma:
Visão geral de como o Visual C++ gerencia arquivos de recurso e arquivos de cabeçalho
Visual C++ gerencia um único.Arquivo de recurso RC e um correspondente.Arquivo de cabeçalho h como um par de arquivos totalmente fraco. Quando você editar e salvar os recursos em um.Arquivo RC, você indiretamente editar e salvar símbolos correspondentes.Arquivo de H. Embora você pode abrir e editar múltiplo.RC arquivos ao mesmo tempo (usando a interface de usuário MDI do Visual C++) para qualquer dado.Arquivo RC você indiretamente edita exatamente um arquivo de cabeçalho correspondente.
Arquivo de cabeçalho símbolo
Por padrão, o Visual C++ sempre nomeia o arquivo de cabeçalho correspondentes RESOURCE.H, independentemente do nome do arquivo de recurso (por exemplo, MYAPP.RC). Usando o comando Set inclui o arquivo no Visual C++, você pode alterar o nome desse arquivo de cabeçalho, atualizando o arquivo arquivo de cabeçalho símbolo na caixa de diálogo Definir inclui.
Diretivas de símbolo somente leitura
Embora Visual C++ somente edita um arquivo de cabeçalho para qualquer dado.Arquivo RC, Visual C++ oferece suporte a referências a símbolos definidos em arquivos de cabeçalho de somente leitura adicional. Usando o comando Set inclui o arquivo no Visual C++, você pode especificar qualquer número de arquivos de cabeçalho de somente leitura adicional como as diretivas de símbolo somente leitura. A restrição "somente leitura" significa que quando você adiciona um novo recurso na.Arquivo RC, você pode usar um símbolo definido no arquivo de cabeçalho de somente leitura; mas se você excluir o recurso, o símbolo ainda é definido no arquivo de cabeçalho de somente leitura. Você não pode alterar o valor numérico atribuído a um símbolo somente leitura.
Diretivas de tempo de compilar
Visual C++ também suporta o aninhamento de arquivos de recurso, onde uma.Arquivo RC é # include ' d dentro de outra. Quando você edita um determinado.Arquivo RC usando o Visual C++, quaisquer recursos nos arquivos # include ' d não são visíveis. Mas quando você compila o.Arquivo RC, os arquivos de # include ' d também são compilados. Usando o comando Set inclui o arquivo no Visual C++, você pode especificar qualquer número de # include ' d.Arquivos RC como as diretivas de tempo de compilar.
Observe o que acontece se você ler no Visual C++ um.Arquivo RC # include é outra.RC ou seja arquivo não especificado como uma diretiva de tempo de compilar. Nesta situação pode surgir quando você traz para o Visual C++ um.Arquivo RC que você tinha sido anteriormente mantendo manualmente com um editor de texto. Quando Visual C++ lê o # include ' d.Arquivo RC, ele mescla os recursos de # include ' d para o pai.Arquivo RC. Quando você salvar o pai.Arquivo RC, o # include instrução, com efeito, será substituído pelos recursos de # include ' d. Se você não quiser essa mesclagem para acontecer, você deve remover o # incluir instrução do pai.Arquivo RC prévia para lê-lo em Visual C++; em seguida, usando o Visual C++, adicionar novamente o mesmo # include instrução como uma diretiva de tempo de compilar.
Visual C++ salva em um.RC arquivo três tipos de acima definir inclui informações (arquivo de cabeçalho símbolo, as diretivas de símbolo somente leitura e diretivas de tempo de compilar) no # incluir directivas e em recursos TEXTINCLUDE. Os recursos TEXTINCLUDE, um detalhe de implementação que você normalmente não precisa de tratar, são explicados Como Visual C++ gerencia definir inclui informações.
Análise de criado AppWizard.RC e.H arquivos
Examinar o código de aplicativo produzido pelo AppWizard fornece a introspecção em como o Visual C++ gerencia Múltiplo recurso files and files header. Os trechos de código analisados abaixo são de um aplicativo MYAPP produzido pelo AppWizard usando as opções padrão.
Um aplicativo criado AppWizard usa múltiplo recurso files and Múltiplo arquivos de cabeçalho, como resumido no diagrama abaixo:
nbsp; RECURSO.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2 AFXRES.RC AFXPRINT.RC & nbsp
Você pode exibir essas Múltiplo relações de arquivo usando o comando Visual C++ arquivo/conjunto inclui.
MYAPP.RC
O arquivo de recurso do aplicativo que você editar usando o Visual C++.
RECURSO.H é o arquivo de cabeçalho específico do aplicativo. Ele sempre é denominado recurso.H por AppWizard, consistente com o padrão do Visual C++ de nomeação do arquivo de cabeçalho. O # incluir para esse arquivo de cabeçalho é a primeira instrução no arquivo de recurso (MYAPP.RC):
//Microsoft visual C++ gerados de script de recurso
//
# include "Resource. h"
RES\MYAPP.RC2
Contém recursos que não serão editados pelo Visual C++, mas serão incluídos na final compilado.Arquivo EXE. AppWizard cria sem tais recursos por padrão, uma vez que Visual C++ pode editar todos os recursos padrão, incluindo o recurso de versão (um novo recurso nesta versão). Um arquivo vazio é gerado pelo AppWizard caso você queira adicionar seus próprios recursos Personalizars formatados para este arquivo.
Se você usar recursos formatados Personalizars, você pode adicioná-los para RES\MYAPP.RC2 e editá-los usando o editor de texto do Visual C++.
AFXRES.RC e AFXPRINT.RC contêm recursos padrão exigidos por determinados recursos do framework. Como RES\MYAPP.RC2, esses dois arquivos de recurso fornecido pelo quadro são # include ' d no final do MYAPP.RC e elas são especificadas nas diretivas de tempo de compilar da caixa de diálogo Definir inclui. Assim, você não diretamente exibir ou editar esses recursos de quadro enquanto você edita MYAPP.RC no Visual C++, mas eles são compilados no binário do aplicativo.Arquivo RES e final.Arquivo EXE. Para obter mais informações sobre os recursos de estrutura padrão, incluindo procedimentos para modificá-los, consulte técnico Anotação 23.
AFXRES.H define símbolos padrão, como ID_FILE_NEW, usado pela estrutura e especificamente usado em AFXRES.RC. AFXRES.H também # include do WINRES.H, que contém um subconjunto de janelas.H que são necessárias pelo Visual C++ gerados.RC arquivos bem como AFXRES.RC. Os símbolos definidos no AFXRES.H estão disponíveis conforme você edita o arquivo de recurso do aplicativo (MYAPP.RC). Por exemplo, ID_FILE_NEW é usado para o item de menu arquivo novo em MYAPP.Recurso de menu do RC. Você não pode alterar ou excluir esses símbolos definidos pelo quadro.
Incluindo arquivos de cabeçalho adicionais
O aplicativo criado AppWizard inclui apenas dois arquivos de cabeçalho: recurso.H e AFXRES.H. somente recurso.H é específico do aplicativo. Talvez você precise incluir arquivos de cabeçalho de somente leitura adicional nos seguintes casos
O arquivo de cabeçalho é fornecido por uma fonte externa, ou você deseja compartilhar o arquivo de cabeçalho entre Múltiplo projetos ou várias partes do projeto.
O arquivo de cabeçalho tem formatação e comentários que você não deseja Visual C++ para alterar ou filtrar quando ele salva o arquivo. Por exemplo, talvez você queira preservar # do definir que usar aritmética simbólica, como:
# define vermelho 0
# define azul 1
# Definir verde 2
# define ID_COLOR_BUTTON 1001
# define ID_RED_BUTTON (ID_COLOR_BUTTON + vermelho)
# define ID_BLUE_BUTTON (ID_COLOR_BUTTON + azul)
# define ID_GREEN_BUTTON (ID_COLOR_BUTTON + verde)
Você pode incluir arquivos de cabeçalho de somente leitura adicional usando o comando Set inclui o arquivo para especificar o # include instrução como uma segunda directiva de símbolo somente leitura, como no:
# include "AFXRES. h"
# include "second.h"
O novo arquivo diagrama relacionamento agora se parece com isso:
nbsp; AFXRES.RECURSO DE H.SEGUNDO H.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2 AFXRES.RC AFXPRINT.RC & nbsp
Compartilhamento de um arquivo de cabeçalho entre os dois.Arquivos RC
Você pode querer compartilhar um arquivo de cabeçalho entre os dois.RC arquivos que estão em diferentes projetos, ou possivelmente o mesmo projeto. Para fazer isso, basta aplica a técnica de directivas de somente leitura descrita acima para ambos.Arquivos de RC. No caso onde os dois.RC arquivos são para diferentes aplicações (projetos diferentes), o resultado é ilustrado no diagrama a seguir:
nbsp; RECURSO.H AFXRES.RECURSO DE H.H (para MYAPP1) segundo.H (for MYAPP2)
\ / \ /
\ / \ /
MYAPP1.RC MYAPP2.RC
/ \ / \
/ \ / \
RES\MYAPP1.RC2 AFXRES.RC RES\MYAPP2.RC2 AFXPRINT.RC & nbsp
O caso onde o segundo arquivo de cabeçalho é compartilhado por dois.RC arquivos no mesmo aplicativo (projeto) é discutido abaixo.
Usando Múltiplo arquivos de recurso no mesmo projeto
O Visual C++ e o compilador de recursos oferecem suporte a vários.RC arquivos no mesmo projeto através de # do incluir um.Arquivo RC dentro de outra. O aninhamento múltiplo é permitido. Existem várias razões para dividir os recursos do projeto em Múltiplo.Arquivos RC:
Você pode # incluir um segundo.RC nas diretivas de tempo de compilar na caixa de diálogo Definir inclui:
# i&nclude "res\myapp.rc2"nbsp; / / não - Visual C++ editado recursos
# include "second.rc" / / O segundo.ARQUIVO RC
# include "AFXRES. RC" / / padrão componentes
# include "afxprint.rc" / / impressão/recursos de visualização de impressão
O resultado é ilustrado no diagrama a seguir:
nbsp; RECURSO.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
EM SEGUNDO LUGAR.RC AFXRES.RC AFXPRINT.RC & nbsp
Usando diretivas de tempo de compilação, você pode organizar seus recursos visuais C++ editáveis e não editáveis em Múltiplo.Arquivos RC, onde o "mestre" MYAPP.RC não faz nada mas # incluir o outro.Arquivos de RC. Se você estiver usando um projeto do Visual C++.Arquivo MAK e, em seguida, você deve incluir o "mestre".RC do arquivo do projeto para que todos os recursos de # include ' d são compilados com o seu aplicativo.
Aplicação de arquivos não-editáveis Visual C++
RES\MYAPP criado AppWizard.Arquivo RC2 é um exemplo de um arquivo que contém recursos que você não queira ler acidentalmente em Visual C++ e, em seguida, escrevê-lo de volta com perda de informações de formatação. Para proteger contra isso, colocamos as seguintes linhas no início do RES\MYAPP.Arquivo RC2:
# ifdef APSTUDIO_I&NVOKED
nbsp; # erro esse arquivo não é editável pelo Visual C++
# endif //APSTUDIO_INVOKED
Quando Visual C++ compila a.Arquivo RC, ele define APSTUDIO_INVOKED bem como RC_INVOKED. Se a estrutura do arquivo criado AppWizard está corrompida e Visual C++ lê linha # erro acima, ele relata um erro fatal e abortar a leitura do.Arquivo RC.
Gerenciar símbolos compartilhados por Múltiplo Visual C++-Edited.Arquivos RC
Dois problemas surgem quando você dividir os recursos em Múltiplo.RC arquivos que você deseja editar separadamente no Visual C++:
O diagrama a seguir ilustra uma organização de.RC e.Arquivos de h que lida com a primeira edição:
nbsp; MYAPP.RC
/ \
/ \
MYSTRS.H / MYSHARED.H \ MYME&NUS.H
\ / / \ \ \
\ / / \ \ \
MYSTRS.RC MYMENUS.RC
Neste exemplo, recursos de Cadeia de caracteres são mantidos no arquivo de um recurso, MYSTRS.RC e menus são mantidos em outro, MYMENUS.RC. Alguns símbolos, como para comandos, talvez precise ser compartilhados entre os dois arquivos. Por exemplo, um ID_TOOLS_SPELL pode ser a identificação de comando de menu para o item de mágica em um menu de ferramentas; e também pode ser a ID de Cadeia de caracteres do prompt de comando exibida pela estrutura na barra de status de janela principal do aplicativo.
O símbolo ID_TOOLS_SPELL é mantido no arquivo de cabeçalho compartilhada, MYSHARED.H. você manter esse arquivo de cabeçalho compartilhada manualmente com um editor de texto; Visual C++ diretamente não editá-lo. No recurso de dois arquivos MYSTRS.RC e MYMENUS.RC, você especifica # incluem MYSHARED.H nas directivas somente leitura para MYAPP.RC, usando o comando arquivo conjunto inclui, como descrito anteriormente.
É mais conveniente antecipar um símbolo você irá compartilhar antes de tentar usar ele para identificar qualquer recurso. Adicionar o símbolo para o arquivo de cabeçalho compartilhada e, se ainda não tiver o # include ' d o arquivo de cabeçalho compartilhada pelas directivas de somente leitura para o.RC arquivo, fazê-lo antes de usar o símbolo. Se você não antecipou a partilha o símbolo desta forma e, em seguida, você terá que manualmente (usando um editor de texto) move o # definir instrução para o símbolo de, digamos, MYMENUS.H a MYSHARED.H antes de usá-lo em MYSTRS.RC.
Quando você gerencia símbolos em Múltiplo.Arquivos RC, você também deve ajudar Visual C++ Evite atribuir a mesma ID de valores numéricos para recursos distintos (símbolos). Para uma dada.Arquivo RC, Visual C++ incrementalmente atribui IDs em cada um dos quatro domínios de ID. Entre sessões de edição, Visual C++ mantém registro do último ID atribuído em cada um dos domínios no arquivo de cabeçalho de símbolo para o.Arquivo RC. Aqui está o que os valores APS_NEXT são para um vazio (novo).Arquivo 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 é o próximo valor de símbolo que será usado para um recurso dialog, menu recursos e assim por diante. O intervalo válido para valores de símbolo de recurso é 1 a 0x6FFF.
_APS_NEXT_COMMAND_VALUE é o próximo valor de símbolo que será usado para uma identificação de comando. O intervalo válido para valores de símbolo de comando é 0 x 8000 para 0xDFFF.
_APS_NEXT_CONTROL_VALUE é o próximo valor de símbolo que será usado para um controle de caixa de diálogo. O intervalo válido para valores de símbolo de Controlarar de caixa de diálogo é 8 para 0xDFFF.
APS_NEXT_SYMED_VALUE é o próximo valor de símbolo que será emitido quando você atribuir manualmente um valor de símbolo usando o comando novo no navegador do símbolo.
Visual C++ começa com valores ligeiramente mais elevados que o judiciário mais baixo valor quando criar um novo.Arquivo RC. AppWizard também irá inicializar esses valores para algo mais apropriado para aplicativos do MFC. Para obter mais informações sobre intervalos de valores de ID, consulte técnico Anotação 20.
Agora cada vez que você cria um novo arquivo de recurso, até mesmo no mesmo projeto, Visual C++ define os mesmos valores _APS_NEXT_ . Isto significa que se você adicionar, digamos, de múltiplos diálogos em dois diferentes.Arquivos de RC, é altamente provável que o mesmo # definir valor será atribuído a diferentes caixas de diálogo. Por exemplo, IDD_MY_DLG1 no primeiro.Arquivo RC pode ser atribuído o mesmo número, 101, como IDD_MY_DLG2 em um segundo.Arquivo RC.
Para evitar isso, você deve reservar um intervalo numérico separado para cada um dos quatro domínios de identificações na respectiva.Arquivos de RC. Para fazer isso, atualizar manualmente os valores _APS_NEXT em cada um do.RC arquivos antes de que você começar a adicionar recursos. Por exemplo, se o primeiro.Arquivo RC usa os valores _APS_NEXT padrão e, em seguida, você pode querer atribuir os seguintes valores _APS_NEXT para o segundo.Arquivo 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
Naturalmente, ainda é possível que o Visual C++ irá atribuir tantas identificações no primeiro.Arquivo RC que os valores numéricos começam a sobrepor-se aqueles reservados para o segundo.Arquivo RC. Você deve reservar intervalos suficientemente grandes para que isso não aconteça.
Gerenciar dependências entre.RC.CPP, e.H arquivos
Quando Visual C++ salva um.Arquivo RC, ele também salva alterações de símbolo para o recurso correspondente.Arquivo de H. Qualquer um dos seus.Arquivos CPP que se referem a recursos na.Arquivo RC deve # incluir o recurso.Arquivo H, normalmente de dentro arquivo de cabeçalho principal do seu projeto. Isto leva a um efeito colateral indesejável devido ao gerenciamento de projetos internos do ambiente de desenvolvimento que examina os arquivos de origem para dependências de cabeçalho. Sempre que você adicionar um novo símbolo no Visual C++, todos os.Arquivo CPP que # incluir recurso.H seria precisam de ser recompilados.
Visual C++, evitará a dependência do recurso.H, incluindo o comentário a seguir como a primeira linha do recurso.Arquivo H:
//{{NO_DEPENDENCIES}}
O ambiente de desenvolvimento interpreta esse comentário ignorando as alterações ao recurso.H assim que dependente.Arquivos CPP não precisará ser recompilado.
Visual C++ sempre adiciona o //{{NO_DEPENDENCIES}} Comentário linha para um.Arquivo RC quando ele salva o arquivo. Em alguns casos, evasão da dependência compilação em recurso.H pode levar a erros de tempo de execução não detectados em tempo de link. Por exemplo, se você usar o Pesquisador de símbolo para alterar o valor numérico atribuído a um símbolo de um recurso, o recurso será não ser corretamente encontrado e carregado no caso de tempo de execução de aplicativo do.Arquivo CPP, referindo-se ao recurso não é recompilado. Em tais casos, você deve explicitamente recompilar qualquer um.Arquivos CPP que você sabe que são afectados pelas alterações símbolo em recurso.H ou selecionar Rebuild tudo. Se você tiver a necessidade de freqüentemente alterar valores de símbolo por um determinado grupo de recursos, você provavelmente vai encontrá-lo mais conveniente e mais seguro para quebrar esses símbolos em um arquivo de cabeçalho separado de somente leitura, conforme descrito na seção acima Incluindo arquivos de cabeçalho adicionais.
Como o Visual C++ gerencia conjunto inclui informações
Como discutido acima, o menu arquivo conjunto inclui comando permite que você especificar três tipos de informações:
O seguinte descreve como o Visual C++ mantém essas informações em um.Arquivo RC. Você não precisa desta informação para usar o Visual C++, mas ela pode melhorar sua compreensão de modo mais confiàvel você pode usar o recurso de conjunto inclui.
Cada um dos três tipos acima de Set inclui informações é armazenada na.Arquivo RC em duas formas: (1) como # incluir ou outras directivas interpretable pelo compilador de recurso e (2) como especiais recursos TEXTINCLUDE interpretable somente pelo Visual C++.
A finalidade do recurso TEXTINCLUDE é armazenar com segurança definir incluir informações em um formulário que é facilmente apresentável na caixa de diálogo Definir inclui do Visual C++. TEXTINCLUDE é um tipo de recurso definido pelo Visual C++. Visual C++ reconhece três recursos TEXTINCLUDE específicos que têm o recurso de números de identificação 1, 2 e 3:
| ID de recurso TEXTINCLUDE. | Tipo de conjunto inclui informações |
| 1 | Arquivo de cabeçalho símbolo |
| 2 | Diretivas de símbolo somente leitura |
| 3 | Diretivas de tempo de compilar |
Cada um dos três tipos de informações de conjunto inclui é ilustrada pelos padrão MYAPP.RC e recurso.H arquivos criados por AppWizard, conforme descrito abaixo. \0 Extra e "" tokens entre BEGIN e END blocos são necessárias pela sintaxe RC para especificar zero seqüências encerradas e o caractere de aspas duplas respectivamente.
Arquivo de cabeçalho símbolo
O formulário de informações de arquivo de cabeçalho símbolo interpretados pelo compilador de recurso é simplesmente uma instrução # include:
# include "Resource. h"
O recurso TEXTINCLUDE correspondente é:
1 TEXTINCLUDE DISCARDABLE
COMEÇAR
# resource.h\0 "
FIM
Diretivas de símbolo somente leitura
As diretivas de símbolo somente leitura são incluídas na parte superior da MYAPP.RC no seguinte Formulárioato interpretable pelo compilador de recurso:
# include "AFXRES. h"
O recurso TEXTINCLUDE correspondente é:
2 TEXTINCLUDE DISCARDABLE
COMEÇAR
"# include" "afxres.h""\r\n"
"\0"
FIM
Diretivas de tempo de compilar
Diretivas de tempo de compilação são incluídas no final do MYAPP.RC no seguinte Formulárioato interpretable pelo compilador de recurso:
# ifndef APSTUDIO_I&NVOKED
///////////////////////
//
/ / From TEXTINCLUDE 3
//
# include "res\myapp.rc2"nbsp; / / não - Visual C++ editado recursos
# include "AFXRES. RC" / / padrão componentes
# include "afxprint.rc" / / impressão/recursos de visualização de impressão
# endif / / não APSTUDIO_INVOKED
A diretiva APSTUDIO_INVOKED # ifndef instrui o Visual C++ para ignorar sobre as diretivas de compilação-tempo.
O recurso TEXTINCLUDE correspondente é:
3 TEXTI&NCLUDE DISCARDABLE
COMEÇAR
"# include" "res\myapp.rc2""nbsp; / / não - Visual C++ editado resources\r\n "
"\r\n"
"# include""AFXRES. RC" "/ / padrão components\r\n"
"# include""afxprint.rc" "/ / impressão/imprimir visualização resources\r\n"
"\0"
FIM
Técnico anotações por número |nbsp; &Notas técnicas por categoria