Compartilhamento de tecnologia

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

Recursos personalizados são um tipo de recurso usado em programas do Windows para armazenar dados, imagens, áudio, arquivos binários específicos de aplicativos, etc. Por meio de recursos personalizados, os desenvolvedores podem gerenciar e armazenar centralmente vários arquivos de recursos exigidos pelo aplicativo para fácil acesso e uso no programa.

■Aqui estão alguns pontos-chave sobre recursos personalizados:

●Tipos de recursos personalizados:

1. Os recursos personalizados podem ser quaisquer dados ou arquivos específicos do aplicativo, como imagens, áudio, arquivos de configuração XML, arquivos de texto, etc.

2. Os recursos personalizados podem ser identificados usando um identificador de tipo de recurso personalizado, como "MY_CUSTOM_RESOURCE".

●Criar e editar recursos personalizados:

1. Os recursos personalizados normalmente são incluídos no arquivo de recursos de um aplicativo (.rc).

2. Os recursos personalizados podem ser criados e editados usando um editor de recursos, como o Resource View do Visual Studio.

3. No arquivo de recurso, você pode especificar um identificador de recurso exclusivo e o caminho do arquivo de recurso correspondente para cada recurso.

●Consulte e use recursos personalizados:

1. Ao fazer referência e usar recursos personalizados no código, você pode usar identificadores de recursos para carregar ou acessar os recursos correspondentes.

2. Use as funções de API correspondentes (como LoadResource, FindResource, LockResource, etc.) para carregar e operar recursos personalizados.

3. Dependendo do tipo de recurso personalizado, você pode usar diferentes funções de API (por exemplo, recursos de imagem podem usar funções GDI e recursos de áudio podem usar funções DirectSound) para processar recursos personalizados.

■A seguir está um trecho de código de exemplo que mostra como carregar e usar um recurso personalizado:

#incluir<Windows.h>

int principal()

{

HINSTANCE hInstance = GetModuleHandle(NULL); // Obtém o identificador da instância atual

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

HGLOBAL hResData = LoadResource(hInstance, hResource);

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

//Usar recursos personalizados...

retornar 0;

}

No exemplo acima, IDR_MY_RESOURCE é o identificador do recurso personalizado e o caminho do arquivo de recursos correspondente é definido no arquivo de recursos. Use a função FindResource para localizar o recurso personalizado, em seguida, use a função LoadResource para carregar o recurso personalizado e, finalmente, use a função LockResource para bloquear o recurso personalizado para obter um ponteiro para os dados do recurso. Posteriormente, o ponteiro pData pode ser utilizado para processamento e operações subsequentes de acordo com o tipo e requisitos do recurso.

É importante observar que a forma como um recurso personalizado é usado depende do tipo de recurso e das necessidades do aplicativo. Os desenvolvedores podem escolher tipos de recursos apropriados e funções de API correspondentes para processar recursos personalizados com base nas necessidades reais.

Os recursos personalizados fornecem um método flexível de gerenciamento de recursos para aplicativos. Vários dados e arquivos exigidos pelo aplicativo podem ser gerenciados de maneira uniforme e fácil, acessados ​​e usados ​​no programa. Ao usar recursos personalizados, você pode tornar seu aplicativo mais modular, sustentável e extensível.

       ■em VSAdicione recursos personalizados em

1. Adicione recursos

2. Clique em “Personalizar” e preencha o tipo de recurso “TEXTO”

3. Importe recursos e gere automaticamente o arquivo text1.bin, ID do recurso: IDR_TEXT1

4. No VS, insira diretamente o nome do arquivo de recurso no compilador personalizado e modifique o ID. Uma mensagem de erro aparece: Não é possível carregar recursos externos - o possível motivo é que os recursos não foram importados.

5. Adicione recursos na caixa de visualização de recursos.

6. Importe arquivos de recursos externos.

7. Preencha novamente o nome e o ID do arquivo de recursos. Observe que o nome do ID precisa ser preenchido com a string entre aspas "ANNABELLEE".

8. Basta salvar as configurações.

 

Existe um método mais simples, modificar diretamente o arquivo de recursos POEPOEM.rc. Basta adicionar recursos abaixo da linha em TEXTO.

      

9.1.6 Exercício 57: Tabela de recursos de string e recursos personalizados

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

057 API WIN32 Pratique diariamente

     Exemplo 57 POEPOEM.C: tabela de recursos de string e recursos customizados

Cadeia de Carga função

CarregarRecurso função

EncontrarRecurso função

Recurso de bloqueio função

AnsiPróximo Definição macro

(c) www.bcdaren.com Programador

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

#incluir <windows.h>

#incluir "recurso.h"

LRESULT LIGAR DE VOLTA Processo Wnd (HWND, Unidade, WPARAM, LPARAM) ;

HISTÓRIA hInst ;

Inteiro WINAPI WinPrincipal (HISTÓRIA hInstância, HISTÓRIA hPrevInstance,

 PSTR Linha de comando szCmd, Inteiro iCmdMostrar)

{   //Nome do arquivo de recurso, título e mensagem de erro

     TCHAR szNomeApp[16], szLegenda[64], mensagem de erro szErr[64];

     HWND tchau;

     MSG mensagem;

     CLASSE WND classe wnd;

     //Carregar recursos de string

     Cadeia de Carga(hInstância, IDS_NOME_DO_APLICATIVO, szNomeApp,

          tamanho de(szNomeApp) / tamanho de(TCHAR));

     Cadeia de Carga(hInstância, IDS_LEGENDA, szLegenda,

          tamanho de(szLegenda) / tamanho de(TCHAR));

     classe wnd.estilo = CS_HREDRAW | CS_VREDRAW;

     classe wnd.lpfnWndProc = Processo Wnd;

     classe wnd.cbClsExtra = 0;

     classe wnd.cbWndExtra = 0;

     classe wnd.hInstância = hInstância;

//adicionar ícone

     classe wnd.hÍcone = Ícone de carga(hInstância, FAÇA RECURSOS(IDI_ICON1));

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

//Ponteiro do mouse personalizado

     classe wnd.Cursor h = Cursor de Carga(hInstância,FAÇA RECURSOS(IDC_CURSOR1));

     classe wnd.hbrAntecedentes = (ESCOVA H)ObterStockObject(PINCEL_BRANCO);

     classe wnd.lpszNomeDoMenu = NULO;

     classe wnd.lpszNomeDaClasse = szNomeApp;

     //hInst = hInstance;//Não está no código original e nenhum erro será relatado.

     se (!RegistrarClasse(&classe wnd))

     {

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

          // tamanho de(szAppName));

          CarregarStringA(hInstância, IDS_ERRMSG, (Caracteres *)mensagem de erro szErr,

               tamanho de(mensagem de erro szErr));

          CaixaDeMensagemA(NULO, (Caracteres *)mensagem de erro szErr,

               (Caracteres *)szNomeApp,

               MB_ICONERROR);

          retornar 0;

     }

     tchau = CriarJanela(szNomeApp, szLegenda,

          WS_JANELA SOBREPOSTA | WS_CLIPCHILDREN,

          CW_USEDEFAULT, CW_USEDEFAULT,

          CW_USEDEFAULT, CW_USEDEFAULT,

          NULO, NULO, hInstância, NULO);

     Mostrar janela(tchau, iCmdMostrar);

     Janela de atualização(tchau);

     enquanto (Obter mensagem(&mensagem, NULO, 0, 0))

     {

          TraduzirMensagem(&mensagem);

          Mensagem de Despacho(&mensagem);

     }

     retornar mensagem.wParam;

}

LRESULT LIGAR DE VOLTA Processo Wnd ( HWND tchau, Unidade mensagem, WPARAM wParam, LPARAM

lParam)

{

     //char estático * pText;

     estático LPCSTR pText;

     estático HGLOBAL hRecurso;//Identificador de recurso - um identificador apontando para um bloco de memória

     estático HWND hRolagem;

     estático Inteiro iPosição, cxCaráter, cyChar, cyClienteeee,

          iNumLines, xRolagem;

     HDC hdc;

     ESTRUTURA DE PINTURA ps;

     RECT reto;

     TEXTEMÉTRICO tm;

     trocar (mensagem)

     {

     caso WM_CRIAR:

          hdc = ObterDC(tchau);

          Obter Métricas de Texto(hdc, &tm);

          cxCaráter = tm.tmAveCharLargura;

          cyChar = tm.tmAltura + tm.tmExternalLiderança;

          LançamentoDC(tchau, hdc);

//A largura da barra de rolagem vertical em pixels

          xRolagem = Obter Métricas do Sistema(SM_CXVSCROLL);

          //Gerar barra de rolagem

          hRolagem = CriarJanela(TEXTOOO("Barra de rolagem"), NULO,

               WS_CRIANÇA | WS_VISÍVEL | SBS_VERT,

               0, 0, 0, 0,

               tchau, (Menu H)1, hInst, NULO);

          //Obter identificador de texto

          hRecurso = CarregarRecurso(hInst,

               EncontrarRecurso(hInst, TEXTOOO("Annabel Lee"),//Certifique-se de que tenha o tipo e o nome especificados

A localização do recurso no módulo especificado

                    TEXTOOO("TEXTO")));

          //Recuperar um ponteiro para um recurso especificado na memória

          pText = (LPCSTR)Recurso de bloqueio(hRecurso);

          iNumLines = 0;//Leia o número de linhas de texto

          //Obtenha o número de linhas de texto

          enquanto (*pText != '\' && *pText != '0')//Termina com ou 0

          {

               se (*pText == 'e')

                    iNumLines++;

                //Retorna a próxima posição (ponteiro) na string ansi, AnsiNext no Windows de 16 bits

//Uma definição de macro, Win32 usa CharNext (AnsiNext só pode lidar com caracteres ansi

//String; CharNext pode ser uma string ansi ou unicode)

                //pTexto = AnsiNext(pTexto);

               pText = (LPCSTR)CharPróximo((LPCWSTR)pText);

          }

     //*pTexto = '0';//O código original aqui afirma que termina com um caractere nulo — o texto real não termina com um caractere nulo.

          //Definir barra de rolagem

          DefinirIntervaloDeRolagem(hRolagem, SB_CTL, 0, iNumLines, FALSO);

          Definir posição de rolagem(hRolagem, SB_CTL, 0, FALSO);

          retornar 0;

     caso TAMANHO_WM:

          MoverJanela(hRolagem, BAIXO ORDEN(lParam) - xRolagem, 0,

               xRolagem, cyClienteeee = PALAVRA-CHAVE(lParam), verdadeiro);

          Definir foco(tchau);//Definir foco

          retornar 0;

     caso WM_SETFOCUS:

          Definir foco(hRolagem);//Capturar o foco do controle deslizante da barra de rolagem

          retornar 0;

     caso WM_VSCROLL:

          trocar (BAIXO ORDEN(wParam))  //LOWORD deve ser adicionado porque o código de notificação está na palavra baixa

          {

          caso SB_TOP:

               iPosição = 0;

               quebrar;

          caso SB_INFERIOR:

               iPosição = iNumLines;

               quebrar;

          caso SB_ALINHAMENTO:

               iPosição -= 1;

               quebrar;

          caso SB_LINHADOWN:

               iPosição += 1;

               quebrar;

          caso SB_PÁGINAUP:

               iPosição -= cyClienteeee / cyChar;

               quebrar;

          caso SB_PAGEDOWN:

               iPosição += cyClienteeee / cyChar;

               quebrar;

          caso SB_THUMBTRACK:

               iPosição = PALAVRA-CHAVE(wParam);

               quebrar;

          }

          iPosição = máx.(0, mínimo(iPosição, iNumLines));

          se (iPosição != ObterScrollPos(hRolagem, SB_CTL))

          {

               Definir posição de rolagem(hRolagem, SB_CTL, iPosição, verdadeiro);

               InvalidarRect(tchau, NULO, verdadeiro);

          }

          retornar 0;

     caso WM_PINTURA:

          hdc = Começar a pintar(tchau, &ps);

          pText = (Caracteres *)Recurso de bloqueio(hRecurso);

          ObterClienteRect(tchau, &reto);

          reto.esquerda += cxCaráter;//Exibir a partir da coluna 2

          reto.principal += cyChar * (1 - iPosição);

          // Inclui a altura principal da linha externa da fonte. Normalmente, os cabeçalhos das linhas externas não são incluídos na altura de uma linha de texto.

          DesenharTextoA(hdc, pText, -1, &reto, DT_EXTERNOALÍNDICE);

          Pintura final(tchau, &ps);

          retornar 0;

     caso WM_DESTRUIR:

          Recurso Livre(hRecurso);

          PostQuitMessage(0);

          retornar 0;

     }

     retornar DefWindowProc(tchau, mensagem, wParam, lParam);

}

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

Cadeia de Carga Função: Carrega um recurso de string e depois copia a string em um buffer com um caractere nulo de terminação,

Ou retorne um ponteiro somente leitura para o próprio recurso de string.

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

CarregarRecurso Função: recupera um identificador que pode ser usado para obter um ponteiro para o primeiro byte do recurso especificado na memória

CarregarRecurso HGLOBAL(

HMODULE hModule,// Um identificador para o módulo cujo executável contém o recurso.Se hModule for NULL, o sistema carregará o recurso do módulo usado para criar o processo atual

HRSRC hResInfo//O identificador do recurso a ser carregado

);

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

EncontrarRecurso Função: Determina a localização de um recurso do tipo e nome especificados no módulo especificado

HRSRC EncontrarRecursoA(

HMODULE hModule,//Identificador do módulo que contém o recurso

LPCSTR lpNome,//nome do recurso

LPCSTR lpType//Tipo de recurso

);

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

Recurso de bloqueio Função: Recuperar um ponteiro para um recurso especificado na memória

Recurso de bloqueio LPVOID(

HGLOBAL hResData//O identificador do recurso a ser acessado

);

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

AnsiPróximo Definição macro:

16Uma função de API no Windows (uma definição de macro para ser mais preciso) que só pode processar strings ANSI;

Mais tarde, quando o Win32 apareceu, a Microsoft implementou o encapsulamento através do CharNext para compatibilidade.

CharPróximoPode ser uma string ansi ou unicode.

Esta função retorna a próxima posição (ponteiro) na string ansi.

*/

Recurso.harquivo principal

//{{SEM_DEPENDÊNCIAS}}

// Microsoft Visual C++ Arquivos include gerados.

// Para uso por 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 padrão para novos objetos

//

#ifdef APSTUDIO_INVOCADO

#ifndef APSTUDIO_SÍMBOLOS_SOMENTE_LEITURA

#define _APS_NEXT_RESOURCE_VALUE 126

#define _APS_NEXT_COMMAND_VALUE 40002

#define _APS_NEXT_CONTROL_VALUE 1001

#define _APS_NEXT_SYMED_VALUE 101

#fim se

#fim se

057_POEPOEM.rcOs arquivos de script de recursos contêm 4 tipos de recursos:

1 ． Recursos de ícones:

// Ícone

//

IDI_ICON1 ÍCONE "D:\code\windows5.0\A diário

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

2 ． Recurso de bitmap do ponteiro do mouse:

// Cursor

//

IDC_CURSOR1 CURSOR "cursor1.cur"

3 ． Tabela de recursos de string:

// Tabela de Strings

//

TABELA DE CORDAS

COMEÇAR

IDS_APPNAME "PoePoem"

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

IDS_ERRMSG "Este programa requer o Windows NT!"

FIM

4 ． Recursos personalizados:

// TEXTO

//

TEXTO DE ANNABELLEE "POEPOEM.TXT"

resultado da operação:

Figura 9-9 Tabela de recursos de string e recursos personalizados

 

Resumir

No script de recurso POEPOEM.RC, o recurso definido pelo usuário é especificado como tipo TEXT e o nome do texto é "ANNABELLEE": ANNABELLEE TEXT POEPOEM.TXT

Ao processar a mensagem WM_CREATE em WndProc, o identificador do recurso é obtido por meio de FindResource e LoadResource. LockResource bloqueia o recurso e uma pequena rotina substitui a barra invertida ( ) no arquivo por 0. Isso facilita o uso da função DrawText na mensagem WM_PAINT subsequente.

[Nota] Usamos o controle da barra de rolagem da subjanela em vez da barra de rolagem da janela. O controle da barra de rolagem da subjanela possui uma interface de teclado automática, portanto não há necessidade de processar a mensagem WM_KEYDOWN no ​​POEPOEM.

POEPOEM também utiliza três strings, cujos IDs são definidos no arquivo de cabeçalho RESOURCE.H. No início do programa, as strings IDS_APPNAME e IDS_CAPTION são carregadas na memória pelo LoadString:

LoadString (hlnstance, IDS_APPNAME, szAppName,

tamanho de (szAppName) /tamanho de (TCHAR));

LoadString (hlnstance, IDS_CAPTION, szCaption,

tamanho de (szCaption) /tamanho de (TCHAR));

[Nota] Essas duas chamadas precedem RegisterClass. O programa usa LoadStringA para carregar as strings IDS_APPNAME e IDS_ERRMSG e usa MessageBoxA para exibir uma caixa de mensagem personalizada:

se (!RegistrarClasse (&wndclass))

{

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

tamanho de (szAppName));

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

tamanho de (szErrMsg)) ;

MessageBoxA (NULL, (char *) szErrMsg,

(char *) szAppName, MB_ICONERROR) ;

retornar 0 ;

}

[Nota] Força a conversão da variável de string TCHAR para o ponteiro char.

AnsiNext é uma definição de macro no Windows de 16 bits. O Win32 usa CharNext (AnsiNext só pode lidar com strings ansi; CharNext pode lidar com strings ansi e strings unicode).

pTexto = AnsiNext(pTexto);

Substituir com:

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

Todas as strings usadas pelo POEPOEM são definidas como recursos, para que o programa possa ser facilmente convertido pelos tradutores para versões que não sejam o inglês.