MFC最详细入门教程[转载]

本人在学习MFC的过程中，发现下面这个比较好的教程，这边转载记录一下
原文地址：MFC 最详细入门教程

 

From：https://blog.csdn.net/wang18323834864/article/details/78621633/

Visual Studio 2019：https://visualstudio.microsoft.com/zh-hans/

 

鸡啄米 ----- VS2010/MFC编程入门教程之目录和总结：http://www.jizhuomi.com/software/257.html

      一、VS2010/MFC编程入门教程之目录

       第一部分：VS2010/MFC开发环境

       VS2010/MFC编程入门之前言
       VS2010/MFC编程入门之一（VS2010与MSDN安装过程图解）

       第二部分：VS2010/MFC应用程序框架

       VS2010/MFC编程入门之二（利用MFC向导生成单文档应用程序框架）
       VS2010/MFC编程入门之三（VS2010应用程序工程中文件的组成结构）
       VS2010/MFC编程入门之四（MFC应用程序框架分析）
       VS2010/MFC编程入门之五（MFC消息映射机制概述）

       第三部分：对话框

       VS2010/MFC编程入门之六（对话框：创建对话框模板和修改对话框属性）
       VS2010/MFC编程入门之七（对话框：为对话框添加控件）
       VS2010/MFC编程入门之八（对话框：创建对话框类和添加控件变量）
       VS2010/MFC编程入门之九（对话框：为控件添加消息处理函数）
       VS2010/MFC编程入门之十（对话框：设置对话框控件的Tab顺序）
       VS2010/MFC编程入门之十一（对话框：模态对话框及其弹出过程）
       VS2010/MFC编程入门之十二（对话框：非模态对话框的创建及显示）
       VS2010/MFC编程入门之十三（对话框：属性页对话框及相关类的介绍）
       VS2010/MFC编程入门之十四（对话框：向导对话框的创建及显示）
       VS2010/MFC编程入门之十五（对话框：一般属性页对话框的创建及显示）
       VS2010/MFC编程入门之十六（对话框：消息对话框）
       VS2010/MFC编程入门之十七（对话框：文件对话框）
       VS2010/MFC编程入门之十八（对话框：字体对话框）
       VS2010/MFC编程入门之十九（对话框：颜色对话框）

       第四部分：常用控件

       VS2010/MFC编程入门之二十（常用控件：静态文本框）
       VS2010/MFC编程入门之二十一（常用控件：编辑框Edit Control）
       VS2010/MFC编程入门之二十二（常用控件：按钮控件Button、Radio Button和Check Box）
       VS2010/MFC编程入门之二十三（常用控件：按钮控件的编程实例）
       VS2010/MFC编程入门之二十四（常用控件：列表框控件ListBox）
       VS2010/MFC编程入门之二十五（常用控件：组合框控件Combo Box）
       VS2010/MFC编程入门之二十六（常用控件：滚动条控件Scroll Bar）
       VS2010/MFC编程入门之二十七（常用控件：图片控件Picture Control）
       VS2010/MFC编程入门之二十八（常用控件：列表视图控件List Control 上）
       VS2010/MFC编程入门之二十九（常用控件：列表视图控件List Control 下）
       VS2010/MFC编程入门之三十（常用控件：树形控件Tree Control 上）
       VS2010/MFC编程入门之三十一（常用控件：树形控件Tree Control 下）
       VS2010/MFC编程入门之三十二（常用控件：标签控件Tab Control 上）
       VS2010/MFC编程入门之三十三（常用控件：标签控件Tab Control 下）

       第五部分：菜单、工具栏与状态栏

       Introdução à programação VS2010/MFC Thirty-Four (Menu: Explicação detalhada dos recursos do menu VS2010)
       Introdução à programação VS2010/MFC Thirty-five (Menu: Menu e uso da classe CMenu)
       Introdução à programação VS2010/MFC Trinta e seis (Barra de ferramentas: Recursos da barra de ferramentas e Classe CToolBar)
       Introdução à programação VS2010/MFC trinta e sete (barra de ferramentas: criação, encaixe e uso da barra de ferramentas)
       Introdução à programação VS2010/MFC trinta e oito (uso detalhado da barra de status)

       Parte VI: Documentação, Views e Frames

       Introdução à programação VS2010/MFC 39 (Documentos, exibições e estruturas: visão geral)
       Introdução à programação VS2010/MFC 40 (Documentos, exibições e quadros: relacionamentos entre objetos)
       Introdução à programação VS2010/MFC 41 (Documentos, exibições e quadros: divisão Janelas)

       Parte VII: classes comuns do MFC

       Introdução à Programação VS2010/MFC 42 (Classes MFC Comuns: Classe CString)
       Introdução à Programação VS2010/MFC 43 (Classes MFC Comuns: Classes CTime e CTimeSpan)
       Introdução à Programação VS2010/MFC 44 (Classes MFC Comuns: Timer Timer)
       VS2010/MFC Introdução à programação 45 (classe comum MFC: classe de operação de arquivo CFile)
       Introdução à programação VS2010/MFC 46 (classe comum MFC: tratamento de exceção MFC)

       Parte 8: Fontes e saída de texto

       Introdução à programação do VS2010/MFC 47 (Fonte e saída de texto: CFont Font Class)
       Introdução à programação do VS2010/MFC 48 (Fonte e saída de texto: saída de texto)

       Parte IX: Imagens Gráficas

       Introdução à programação VS2010/MFC quarenta e nove (imagem gráfica: classe CDC e sua função de desenho de tela)
       Introdução à programação VS2010/MFC cinquenta (imagem gráfica: pincel de objeto GDI CPen)
       Introdução à programação VS2010/MFC cinquenta e um (imagem gráfica: pincel de objeto GDI CBrush)

       Parte 10: Desenvolvimento da interface da faixa de opções

       Introdução à programação VS2010/MFC cinquenta e dois (Desenvolvimento da interface Ribbon: criando uma estrutura de aplicativo no estilo Ribbon) Introdução à
       programação VS2010/MFC cinquenta e três (Desenvolvimento da interface Ribbon: adicionando controles para a Barra Ribbon)
       Introdução à programação VS2010/MFC cinquenta Quatro (desenvolvimento de interface de faixa de opções: use mais controles e adicione funções de processamento de mensagens para controles)

 

 

As capturas de tela neste artigo são baseadas no VS2019 

 

 

1. Crie  um novo  projeto MFC

 

• 1. Selecione o item de menu  Arquivo->Novo->Projeto e a caixa de diálogo " Novo Projeto " aparecerá.
• 2. Selecione MFC , clique em Avançar e, em seguida, insira o nome do projeto , neste exemplo, nomeie-o como "Adição" e defina o caminho para salvar o projeto . Clique em " Criar ".
•  3. Selecione baseado em diálogo na lista suspensa do tipo de aplicativo e use as configurações padrão para outros e clique em " Concluir ".

Veja na exibição da solução , o arquivo deste projeto é muito menor do que o aplicativo de documento único, existem três classes principais na exibição de classe : CAboutDlg , CAdditionApp e CAdditionDlg  .

1. CAboutDlg é a classe de diálogo "Sobre" do aplicativo,
2. CAdditionApp é uma classe derivada de CWinApp,
3. CAdditionDlg  é a classe de diálogo principal, e o diálogo principal é a interface principal exibida após a execução do aplicativo.

 

abrir visualização de recursos

Na exibição Resource View, você pode ver a árvore de recursos do projeto Addition, expandir Addition.rc, há quatro subitens abaixo: Dialog (caixa de diálogo), Icon (ícone), String Table (tabela de strings) e Versão ( versão). Em seguida, expanda o item Diálogo, há dois modelos de diálogo abaixo e seus IDs são: IDD_ABOUTBOX e IDD_ADDITION_DIALOG, o primeiro é o modelo da caixa de diálogo "Sobre" e o último é o modelo da caixa de diálogo principal. ID é o identificador exclusivo de um recurso e é essencialmente um inteiro sem sinal. Geralmente, o valor inteiro representado por um ID é definido pelo sistema e não precisamos intervir.

Pode-se observar que, para a caixa de diálogo principal, a criação de um novo modelo de diálogo na primeira etapa da criação de uma caixa de diálogo foi concluída automaticamente pelo sistema. Se você precisar adicionar e criar um novo modelo de caixa de diálogo, clique com o botão direito do mouse no nó "Diálogo" da Visualização de recursos, selecione "Inserir caixa de diálogo" no menu do botão direito, um novo modelo de caixa de diálogo será gerado e o ID será atribuído automaticamente. Como mostrado na imagem:

Clique com o botão direito do mouse no modelo de diálogo Adição e selecione Propriedades no menu do botão direito, e a lista de propriedades da caixa de diálogo será exibida no painel direito. Como mostrado abaixo:

ilustrar:

• 1. ID: ID do diálogo, que identifica exclusivamente o recurso de diálogo e pode ser modificado. Aqui está IDD_ADDITION_DIALOG, não o modificamos.
• 2. Legenda: título da caixa de diálogo . Aqui o padrão está vazio, vamos modificá-lo para "Calculadora de Adições".
• 3. Borda: tipo de borda. Existem quatro tipos: Nenhum, Fino, Redimensionamento e Quadro de Diálogo. Usamos o quadro de diálogo padrão.
• 4. Maximizar: se o botão maximizar deve ser usado. Usamos o padrão de Falso.
• 5. Minimizar: se o botão minimizar deve ser usado. Também usamos o padrão False.
• 6. Estilo: tipo de caixa de diálogo. Existem três tipos: Overlapped (janela sobreposta), Popup (janela pop-up) e Child (janela filho). Janelas pop-up são relativamente comuns. Usamos o tipo de Popup padrão.
• 7. Menu do sistema: se há um menu do sistema no canto superior esquerdo da barra de título, incluindo itens de menu como mover e fechar. Usamos o padrão True.
• 8.Barra de título: Se deve ter uma barra de título. Usamos o padrão True.
• 9.Font(Size): Tipo e tamanho da fonte. Se for modificado para uma fonte que não seja do sistema, Use System é automaticamente alterado para False. E se Use System for originalmente False, altere-o para True, então Font(Size) será automaticamente definido como a fonte do sistema. Aqui usamos a fonte padrão do sistema.

Propriedade de título modificada. Neste momento, a interface após executarmos este programa é a seguinte:

 

1. Adicione uma caixa de texto estático (Static Text) à caixa de diálogo para exibir a string -- "summand".

Para uma caixa de texto estática intitulada "TODO:Coloque controles de diálogo aqui." que é adicionada automaticamente, exclua-a aqui e continue a adicionar novas caixas de texto estáticas.
Ao excluir um controle, você pode usar o botão esquerdo do mouse para clicar para selecioná-lo e um quadro pontilhado aparecerá ao redor do controle após a seleção e, em seguida, pressione a tecla Delete para excluí-lo. Abra o modelo de diálogo IDD_ADDITION_DIALOG criado na aula anterior na Visualização de recursos do projeto "Adição" e a caixa de texto estática adicionada automaticamente pode ser excluída dessa maneira.
Antes de adicionar uma nova caixa de texto estática, verifique se a visualização Toolbox é exibida, caso contrário, clique em View->Toolbox na barra de menu. A exibição da caixa de ferramentas é mostrada abaixo:

        Alguns controles comumente usados ​​estão listados na caixa de ferramentas , um dos quais é Static Text , que é o controle que queremos adicionar. Clique e segure o botão esquerdo do mouse no texto estático na caixa de ferramentas e arraste-o para o modelo de diálogo IDD_ADDITION_DIALOG, um quadro pontilhado aparecerá no modelo, encontramos uma posição adequada e solte o botão esquerdo do mouse para soltá-lo.

       Depois de selecionar o controle com o botão esquerdo do mouse, um quadro pontilhado aparecerá ao redor dele e, em seguida, mova o mouse para alguns pontos pretos no quadro pontilhado e ele se tornará uma forma de seta bidirecional. Nesse momento, você pode pressionar o botão esquerdo do mouse e arraste para alterar o tamanho do controle. Podemos alterar o tamanho do controle de caixa de texto estático recém-adicionado dessa maneira para exibir melhor o título. Obviamente, todo o modelo de diálogo também pode ser redimensionado dessa maneira.

       Em seguida, é hora de modificar o texto da caixa de texto estático. Clique com o botão direito do mouse na caixa de texto estático, selecione "Propriedades" no menu do botão direito e o painel Propriedades será exibido. No painel, modifique a propriedade Caption para "summand" e modifique o ID para IDC_SUMMAND_STATIC. Neste momento, o modelo é o seguinte:

 

2. Adicione uma caixa de edição (Controle de edição) à caixa de diálogo para inserir o summand.

O processo de adicionar uma caixa de edição é semelhante ao de uma caixa de texto estática. Selecione o controle Edit Control na caixa de ferramentas e arraste-o para o modelo de diálogo, alinhe-o horizontalmente com a caixa de texto estática anterior (para estética) e, em seguida, ajuste seu tamanho para caber na caixa de texto adicionada Entrada de número.
Clique com o botão direito do mouse na caixa de edição, selecione "Propriedades" no menu do botão direito para exibir o painel Propriedades (Propriedades) e modifique seu ID para IDC_SUMMAND_EDIT. Neste momento, o modelo é o seguinte:

3. Adicione uma caixa de texto estática intitulada "Addend" de acordo com o método em 1, que é usado para exibir a string -- "Addend". E altere seu ID para IDC_ADDEND_STATIC.
4. Siga o método em 2 para adicionar uma caixa de edição com ID IDC_ADDEND_EDIT para inserir o adendo.
5. Siga o método em 1 para adicionar uma caixa de texto estática intitulada "e" para exibir o texto -- "e". E modifique seu ID para IDC_SUM_STATIC.
6. Adicione uma caixa de edição com o ID IDC_SUM_EDIT de acordo com o método em 2 para exibir a soma final.
7. Um controle de botão semelhante (Botão) é adicionado ao modelo de diálogo, que é usado para acionar o cálculo de adição após ser clicado. Altere seu título para "Cálculo" e seu ID para IDC_ADD_BUTTON.

Até agora, o modelo da caixa de diálogo é mostrado na figura:

8. Exclua o botão  OK  . Abra  o painel Propriedades do botão Cancelar  , altere a Legenda para "Sair" e alinhe-a horizontalmente com o botão Calcular.
9. De acordo com o layout do controle, ajuste corretamente o tamanho de todo o modelo de diálogo para torná-lo um tamanho adequado em relação ao layout do controle e ter uma interface bonita.
Dessa forma, os controles que precisamos usar neste exemplo são adicionados ao modelo de diálogo. O efeito final é o seguinte:

Execute a captura de tela:

 

 

Criar classe de diálogo

Como o programa Addition é um programa baseado em diálogo, o programa cria automaticamente um modelo de diálogo IDD_ADDITION_DIALOG e gera automaticamente uma classe de diálogo CAdditionDlg, derivada da classe CDialogEx. Todos que usaram o VC++ 6.0 devem se lembrar que as classes de diálogo que definimos são todas derivadas da classe CDialog, mas no VS2010, as classes gerais de diálogo são herdadas da classe CDialogEx.

Se for um modelo de diálogo adicionado recentemente, como criar uma classe de diálogo para ele?

• 1. Clique com o botão direito do mouse no nó "Diálogo" da Exibição de recursos e selecione "Inserir diálogo" no menu do botão direito para criar um novo modelo de diálogo e o ID usará o padrão IDD_DIALOG1.
• 2. O modelo de diálogo recém-criado será exibido na área do meio, então selecione este modelo de diálogo, clique com o botão direito do mouse e selecione Adicionar classe no menu do botão direito.

3. Depois de selecionar "Adicionar classe", uma caixa de diálogo aparecerá. Basta escrever um nome de classe personalizado na caixa de edição em "Nome da classe" na caixa de diálogo, como CMyDialog.
4. Por fim, clique em "Concluir" para concluir.

Por fim, você pode ver a classe de diálogo recém-gerada CMyDialog no modo de exibição de classe, e o arquivo de cabeçalho MyDialog.h correspondente e o arquivo de origem MyDialog.cpp são gerados no Gerenciador de Soluções. A classe CMyDialog também é derivada da classe CDialogEx.
Observe que os nomes de classes gerais começam com C, por exemplo, CTestDlg.

 

 

Adicionar variáveis ​​aos controles na caixa de diálogo

        Nas etapas acima  , vários controles são adicionados à caixa de diálogo , incluindo três caixas de texto estáticas, três caixas de edição e um controle de botão. O botão Cancelar gerado pelo programa permanece como um botão de saída, enquanto o botão OK é removido.

       A caixa de texto estático é apenas para explicar o significado dos dados na caixa de edição a seguir, seja o summand, addend ou sum, para que eles não mudem e não adicionemos variáveis ​​para eles. Os controles de botão são usados ​​para operações e as variáveis ​​não são adicionadas a eles aqui. Os dados na caixa de edição podem mudar com frequência, sendo necessário associar uma variável para cada um deles.

 

Primeiro adicione uma variável para a caixa de edição IDC_SUMMAND_EDIT para o summand.

• 1. Clique com o botão direito do mouse na caixa de edição e selecione "Adicionar variável" no menu de contexto. Uma caixa de diálogo do assistente para adicionar variáveis ​​de membro será exibida.
• 2. Queremos adicionar uma variável de valor a ela em vez de uma variável de controle, então selecione Valor na caixa de combinação em "Categoria" na caixa de diálogo.
• 3. A caixa de combinação em "Tipo de variável" seleciona "CString" por padrão neste momento.CString é uma classe de string e, obviamente, não pode executar operações de adição. Podemos escolher double, float, int, etc. Aqui escolhemos double, ou seja, a caixa de edição está associada a uma variável do tipo double.
• 4. Escreva o nome da variável personalizada em "Nome da variável". Arroz de bicada de frango chamado m_editSummand.

5. Clique em "Concluir" para concluir.

Observe que o nome da variável membro de uma classe geralmente começa com m_ para identificá-la como uma variável membro.

Referindo-se a este método, adicione uma variável dupla m_editAddend à caixa de edição IDD_ADDEND_EDIT e adicione uma variável dupla m_editSum à caixa de edição IDD_SUM_EDIT.

 

Troca de dados e validação de classes de diálogo

       Na interface de execução do programa, o usuário geralmente altera as propriedades do controle, por exemplo, insere uma cadeia de caracteres na caixa de edição ou altera o item selecionado da caixa de combinação ou altera o estado selecionado da caixa de seleção. Depois que a propriedade do controle for alterada, o MFC modificará o valor da variável associada do controle de acordo. Essa alteração síncrona é realizada por meio da função de membro DoDataExchange() gerada automaticamente pelo MFC para a classe de diálogo, que também é chamada de mecanismo de troca e inspeção de dados da caixa de diálogo.

       Depois de adicionar variáveis ​​para as três caixas de edição, há mais três instruções de chamada DDX_Text no corpo da função DoDataExchange() de CAdditionDlg em AdditionDlg.cpp. A seguir está o código do corpo da função e os comentários adicionados pelo frango bicando arroz.

       Tome o programa Addion como exemplo para falar brevemente sobre o mecanismo de troca de dados. Se inserirmos o summand na interface de execução do programa, o valor de entrada pode ser salvo na variável m_editSummand através da função DoDataExchange() do CAddition, caso contrário, se o valor da variável m_editSummand for modificado durante a execução do programa, pode ser salvo através de DoDataExchange() do CAddition A função também pode exibir o novo valor da variável na caixa de edição do adendo.

       Mas neste mecanismo de troca de dados, DoDataExchange() não é chamado automaticamente, mas precisamos chamar a função CDialogEx::UpdateData() no programa e, em seguida, a função UpdateData() chamará automaticamente DoDataExchange().

       O protótipo da função CDialogEx::UpdateData() é: BOOL UpdateData(BOOL bSaveAndValidate = TRUE);

       Parâmetros: bSaveAndValidate é usado para indicar a direção da transmissão de dados, TRUE significa do controle para a variável , FALSE significa da variável para o controle . O valor padrão é TRUE, que é passado do controle para a variável.

       Valor de retorno: O valor de retorno da função CDialogEx::UpdateData() indica se a operação foi bem-sucedida, se for bem-sucedida, retorna TRUE, caso contrário, retorna FALSE.

       Na próxima aula, demonstraremos como utilizar a função CDialogEx::UpdateData().

       Chicken Pecking Rice Esta seção fala principalmente sobre a criação de novas classes de diálogo e adição de variáveis ​​de controle.As funções de processamento de mensagens dos controles serão apresentadas em detalhes na próxima aula.

 

 

Adicione uma função de processamento de mensagem para o controle.

 A criação de classes de diálogo e a adição de variáveis ​​de controle já foram mencionadas acima. O conteúdo principal desta aula é como adicionar funções de processamento de mensagens para controles.

 

       O MFC define muitas mensagens para caixas de diálogo e controles , etc. Quando operamos neles, as mensagens são acionadas e essas mensagens são finalmente processadas pelas funções de processamento de mensagens. Por exemplo, quando clicamos em um botão, uma mensagem BN_CLICKED será gerada, e quando o conteúdo da caixa de edição for modificado, uma mensagem EN_CHANGE será gerada. Geralmente, para obter o efeito de uma determinada operação, precisamos apenas implementar a função de processamento de mensagem de uma determinada mensagem.

 

1. Adicione a função de processamento de mensagens

       Arroz de bicada de frango Pegue o programa anterior da calculadora de adição como um exemplo para ilustrar como adicionar uma função de processamento de mensagem para o controle do botão "Cálculo". Existem 4 maneiras de adicionar:

       

• 1. Use o Assistente de classe para adicionar a função de processamento de mensagens

       Amigos que usaram VC++  6.0 devem estar familiarizados com o Class Wizard, que é frequentemente usado para adicionar classes , funções de processamento de mensagens, etc. Mas desde o VS2002, você não pode mais ver o Class Wizard.A maioria das funções são integradas nas propriedades das caixas de diálogo e controles, etc., o que é muito conveniente de usar. Em VS2010 , o Assistente de Classe há muito perdido está de volta. No entanto, o Chicken Pecking Rice está acostumado a usar as funções nas propriedades.Para aqueles que transferem diretamente do VC++ 6.0 para o VS2010, podem sentir que estão mais acostumados a usar o Class Wizard.

       Você deve se lembrar que o ID do botão "Calcular" é IDC_ADD_BUTTON. Na figura acima  , sob o rótulo de comando , existe este ID na lista de IDs do objeto . Como queremos implementar a função de processamento de mensagens após clicar no botão,  selecione a mensagem BN_CLICKED na lista de mensagens Adicionar manipulador no canto superior direito para adicionar a função de processamento de mensagem BN_CLICKED OnClickedAddButton. Claro, você também pode alterar o nome, mas geralmente pode usar o padrão.

 

• 2. Adicione uma função de processamento de mensagens por meio de "Adicionar manipulador de eventos..."

       Clique com o botão direito do mouse no botão "Cálculo" e selecione o item de menu "Adicionar manipulador de eventos..." no menu do botão direito, e a caixa de diálogo "Assistente de manipulador de eventos" será exibida, conforme mostrado na figura abaixo :

Pode-se observar que a mensagem BN_CLICKED é selecionada por padrão em "Tipo de mensagem", e o nome da função e a classe são fornecidos automaticamente, basta clicar em "OK".

 

•   3. Adicione uma função de processamento de mensagens na visualização de propriedades do botão

       Conforme mencionado acima, desde o VS2002 , a função de processamento de mensagens foi adicionada principalmente a partir da exibição de propriedade. Clicamos com o botão direito do mouse no botão "calcular", selecionamos "Propriedades" no menu do botão direito e a exibição de propriedade do botão será exibida no painel direito.

Podemos clicar no botão " Evento de controle " ( semelhante a um raio )        na exibição de atributos conforme mostrado na figura acima , e todas as mensagens do botão "Cálculo" estão listadas abaixo. O que queremos processar é a mensagem BN_CLICKED. Clique no item da lista em branco à direita e um botão com uma seta para baixo aparecerá. Clique neste botão novamente e a opção "<Adicionar> OnBnClickedAddButton" aparecerá. Finalmente, selecione esta opção e a função de processamento BN_CLICKED será adicionada automaticamente.

 

•  4. Clique duas vezes no botão para adicionar uma função de processamento de mensagens

       O método mais direto e fácil é clicar duas vezes no botão "Calcular" e o MFC adicionará automaticamente a função de processamento OnBnClickedAddButton() para a mensagem BN_CLICKED na classe CAdditionDlg.

 

 

Adicionar funcionalidade personalizada na função de manipulador de mensagens

       Depois de usar qualquer método para adicionar a função de processamento de mensagens, podemos obter apenas um corpo de função vazio da função OnBnClickedAddButton(). Para realizar a função que queremos, precisamos adicionar código de função personalizada no corpo da função.

       No programa de calculadora de adição, a função que queremos que o botão "Cálculo" realize é obter os valores do summand e do addend e, em seguida, calcular sua soma e exibi-la na caixa de edição da soma. Então, o corpo da função de OnBnClickedAddButton() deve ser modificado como:

  
  
   
   
void CAdditionDlg::OnClickedAddButton ()
{
// TODO: adicione o código do manipulador de notificação de controle aqui

// Salva os dados de cada controle na variável correspondente
UpdateData (VERDADEIRO);

// Atribui a soma do summand e do addend a m_editSum
m_editSum = m_editSummand + m_editAddend;

// Atualize o controle correspondente de acordo com o valor de cada variável. e a caixa de edição exibirá o valor de m_editSum
UpdateData (FALSO);
}
  
  
   
   

        Comentários foram adicionados ao código acima, o que deve ser fácil para todos entenderem. A descrição da função UpdateData() foi apresentada na aula anterior. Se você esquecer, pode voltar à aula anterior para saber mais. Em seguida, executamos o aplicativo. Na interface de resultado em execução, insira o summand 1.1 e o addend 2.2 e clique em "Calcular":

Análise simples do processo em execução: insira o summand e o addend, clique no botão "Calcular" para gerar uma mensagem de clique e, em seguida, chame a função OnBnClickedAddButton(). Depois de inserir esta função, o valor do summand 5.1 e o valor do addend 2.3 são salvos nas variáveis ​​m_editSummand e m_editAddend respectivamente pela função UpdateData(TRUE) e, em seguida, o summand e o addend são calculados pela instrução m_editSum = m_editSummand + m_editAddend; A soma é 7,4 e atribui 7,4 a m_editSum. Por fim, chame UpdateData(FALSE) para atualizar os valores de exibição das três caixas de edição de acordo com os valores do summand, addend e sum, e o resultado na figura acima é obtido.

       Neste ponto, um aplicativo de calculadora de adição com funções de adição simples é basicamente concluído.

 

 

Como ajustar a ordem de tabulação dos controles na caixa de diálogo.

Depois de adicionar uma função de processamento de mensagens para o botão "Calcular" na aula anterior , a calculadora de adição já pode realizar operações de adição de ponto flutuante. Mas ainda há um pequeno problema restante, ou seja, a ordem de tabulação do controle da caixa de diálogo.

       Execute o programa da calculadora de adição, não execute nenhuma operação após a exibição da caixa de diálogo, apenas pressione Enter e você verá que a caixa de diálogo foi encerrada. Isso ocorre porque o botão "Sair" é um controle com uma ordem de tabulação de 1, que é o primeiro controle a aceitar a entrada do usuário. Mas, de acordo com nossos hábitos de entrada, deve ser a caixa de edição de adendos que aceita a entrada do usuário primeiro, depois a caixa de edição de adendos, depois o botão "Calcular" e, finalmente, o botão "Sair".

       Primeiro, observe intuitivamente a ordem de tabulação de cada controle : abra a " exibição do recurso " e, em seguida, localize a caixa de diálogo IDD_ADDITION_DIALOG no recurso, clique duas vezes no ID e sua exibição de modelo aparecerá na área central do cliente. Selecione "Formatar" -> "Ordem de tabulação" no menu principal ou pressione a tecla de atalho Ctrl+D e o número da ordem de tabulação de cada controle será exibido no modelo da caixa de diálogo. Como mostrado abaixo:

       Na figura acima, há um número no canto superior esquerdo de cada controle, que é a ordem de resposta do Tab. Quando a caixa de diálogo acaba de ser aberta, o foco de entrada está no botão "Sair" com a ordem de tabulação de 1. Se você pressionar a tecla Tab sem nenhuma operação, o foco de entrada será transferido para a caixa de texto estática "summand" com a ordem de tabulação de 2. Mas como a caixa de texto estática não aceita nenhuma entrada, o foco de entrada continua a mudar automaticamente para a caixa de edição summand com a ordem de tabulação de 3 e, em seguida, pressione a tecla Tab e o foco de entrada mudará para o texto estático "adicionar" com a ordem de tabulação de 4 Na caixa, também porque é uma caixa de texto estática, o foco de entrada continuará a ser transferido para a caixa de edição de adendos e os seguintes controles são os mesmos.

       Achamos que essa ordem não é razoável, então como modificá-la? É muito simples, comece pelo controle que você acha que a ordem do Tab deve ser 1, e clique por vez.Com a conclusão do clique, a ordem de resposta do Tab de cada controle também é definida de acordo com nossas ideias.

       Por exemplo, neste exemplo, podemos clicar na caixa de edição summand, na caixa de texto estático "summand", na caixa de edição addend, na caixa de texto estático "addend" e na caixa de edição, "and" caixa de texto estático, botão " Calculate" e " botão Sair". Após a configuração, como mostrado abaixo:

Por fim, pressione a tecla ESC para confirmar a configuração e sair do estado de configuração da ordem de tabulação do modelo de diálogo.

       Agora rodamos o programa novamente, podemos ver que depois que a caixa de diálogo é aberta, o foco de entrada inicial está na caixa de edição summand e, em seguida, pressionamos a tecla Tab e o foco de entrada se move para a caixa de edição addend. serão transferidos circularmente na ordem de "e caixa de edição--botão 'calcular'--botão 'sair'--soma e caixa de edição-adicionar caixa de edição--e caixa de edição...". Isso alcança nosso propósito.

 

 

Caixas de diálogo modais e não modais e como as caixas de diálogo modais aparecem.

 

1.   Caixa de diálogo modal e caixa de diálogo não modal

       As caixas de diálogo do Windows são divididas em duas categorias: caixas de diálogo modais e caixas de diálogo sem janela restrita .

1.  Uma caixa de diálogo modal é uma caixa de diálogo: quando ela aparece, outras janelas do aplicativo não aceitam mais a entrada do usuário e apenas a caixa de diálogo responde à entrada do usuário, e outras janelas podem continuar a se comunicar com o usuário após o correspondente operação é realizada nele e sai. interagir.
2.  Caixa de diálogo não modal: depois que a caixa de diálogo não modal aparecer, outras janelas do programa ainda poderão responder à entrada do usuário. As caixas de diálogo não modais geralmente são usadas para exibir informações de prompt e assim por diante.

       Todos conhecem muito bem o sistema Windows e acredito que essas duas caixas de diálogo deveriam ter sido encontradas. A caixa de diálogo anterior da calculadora de adição é, na verdade, uma caixa de diálogo modal.

 

2. Como a caixa de diálogo modal aparece

       Afinal, a maioria dos programas de cálculo de adição são gerados automaticamente pelo MFC, e você pode não estar muito claro sobre como a caixa de diálogo aparece. Frango bicando arroz Deixe-me falar brevemente sobre onde ele aparece e, em seguida, reconstrua uma nova caixa de diálogo e a abra, para que todos possam usar a caixa de diálogo modal com mais flexibilidade após a prática.

       Se você abrir o arquivo Addition.cpp, poderá ver que a classe CAdditionApp tem uma função InitInstance().   Essa função foi mencionada na análise da estrutura do aplicativo MFC , mas está na classe App do aplicativo de documento único e no corpo da função não é o mesmo, mas todos inicializam a instância da classe App.

       Na segunda metade da função InitInstance(),  há um trecho de código que define o objeto de diálogo e abre a caixa de diálogo . O código a seguir é fornecido e comentado:

  
  
   
   
CAdditionDlg dlg; // Define o objeto dlg da classe de diálogo CAdditionDlg
m_pMainWnd = &dlg; // Define dlg como a janela principal
INT_PTR nResponse = dlg.DoModal ( ); // Abra a caixa de diálogo dlg e atribua o valor de retorno da função DoModal (o ID do botão clicado ao sair) para nResponse
if (nResponse == IDOK) // Determina se o valor de retorno é o botão OK (seu ID é IDOK, que foi deletado pelo frango bicando arroz)
{
// TODO: Quando colocar o processamento aqui
// "OK" para fechar o código da caixa de diálogo
}
else if (nResponse == IDCANCEL) // Determina se o valor de retorno é um botão Cancelar (seu ID é IDCANCEL, e o arroz de frango mudou sua legenda para "sair")
{
// TODO: Quando colocar o processamento aqui
// código para "cancelar" para fechar a caixa de diálogo
}
senão se (nResposta == -1 )
{
TRACE (traceAppMsg, 0 , "Aviso: falha na criação da caixa de diálogo, o aplicativo será encerrado inesperadamente.\n" );
TRACE (traceAppMsg, 0 , "Aviso: Você não pode #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS se estiver usando controles MFC em caixas de diálogo.\n" );
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

Uma das principais funções da caixa de diálogo pop-up é a função DoModal() da classe da caixa de diálogo. O protótipo da função CDialog::DoModal() é:

       virtual INT_PTR DoModal(); 　　

       Valor de retorno: um valor inteiro especificando o valor do parâmetro nResult passado para CDialog::EndDialog (essa função é usada para fechar a caixa de diálogo). Retorna -1 se a função não puder criar o diálogo ou IDABORT se ocorrer outro erro.

       Depois de chamá-lo, uma caixa de diálogo aparecerá e o valor de retorno é o ID do botão clicado ao sair da caixa de diálogo. Por exemplo, se clicarmos no botão "Sair", o valor de retorno de DoModal será IDCANCEL.

 

 3. Adicione uma nova caixa de diálogo e abra-a

Adiciona uma caixa de diálogo ao programa de calculadora de adição que pergunta ao usuário se deseja realizar um cálculo antes de calculá-lo. Você pode dar uma olhada completa no processo de adição e pop-up da caixa de diálogo.

       1. Clique com o botão direito do mouse em "Diálogo" na Exibição de recursos e selecione "Inserir diálogo", crie um novo modelo de diálogo, modifique seu ID para IDD_TIP_DIALOG, altere a legenda para "Prompt" e, em seguida, consulte "Adicionando controles à caixa de diálogo" Conforme mencionado acima, adicione uma caixa de texto estático (texto estático) ao modelo de diálogo e altere a Legenda para "Tem certeza de que deseja executar o cálculo de adição?" e, em seguida, modifique a Legenda do botão OK para "OK" e a legenda do botão Cancelar para "Cancelar", e por fim ajuste a posição de cada controle e o tamanho da caixa de diálogo. O modelo de diálogo final é o seguinte:

2. De acordo com o método de criação de uma classe de diálogo em "Criando uma classe de diálogo e adicionando uma variável de controle", clique com o botão direito do mouse no modelo de diálogo e selecione "Adicionar classe..." para abrir uma caixa de diálogo para adicionar uma classe e defina "Nome da classe como       " No Solution Explorer, você pode ver que o arquivo de cabeçalho TipDlg.h e o arquivo de origem TipDlg.cpp da classe CTipDlg são gerados.

       3. Queremos abrir esta caixa de diálogo de prompt depois de clicar no botão "Calcular", então precisamos acessar a classe de diálogo de prompt na função de processamento de mensagem OnBnClickedAddButton() do botão "Calcular", portanto, para acessar o CTipDlg class, em AdditionDlg.cpp Inclua o arquivo de cabeçalho de CTipDlg: #include "CTipDlg.h".

       4. Modifique o corpo da função de OnBnClickedAddButton(). Antes de todos os códigos, construa o objeto tipDlg da classe CTipDlg e use a instrução tipDlg.DoModal(); para abrir uma caixa de diálogo e, finalmente, determinar se o valor de retorno de a função DoModal() é IDOK ou IDCANCEL Se o cálculo deve continuar. A função OnBnClickedAddButton() é modificada da seguinte forma:

  
  
   
   
void CAdditionDlg::OnClickedAddButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
INT_PTR nRes; // Usado para salvar o valor de retorno da função DoModal

CTipDlg tipDlg; // Constrói uma instância da classe de diálogo CTipDlg
nRes = tipDlg.DoModal (); // caixa de diálogo pop-up
if (IDCANCEL == nRes) // Determina se o valor de retorno é IDCANCEL após a saída da caixa de diálogo, se for, retorna, caso contrário, continua a executar
retorno ;

// Salva os dados de cada controle na variável correspondente
UpdateData (VERDADEIRO);

// Atribui a soma do summand e do addend a m_editSum
m_editSum = m_editSummand + m_editAddend;

// Atualize o controle correspondente de acordo com o valor de cada variável. e a caixa de edição exibirá o valor de m_editSum
UpdateData (FALSO);
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

       5. Teste. Depois de compilar e executar o programa, digite o summand e o addend na caixa de diálogo, clique em "Calcular", uma caixa de diálogo de prompt aparece perguntando se deseja realizar o cálculo, se você escolher "OK", a caixa de diálogo de prompt sai e é exibida na caixa de diálogo principal A soma da soma e da adenda, e se "Cancelar" for selecionado, a caixa de diálogo de prompt também será encerrada, mas a soma exibida na caixa de diálogo principal permanecerá inalterada, ou seja, nenhum cálculo de adição será realizada.

 

 

Crie e exiba caixas de diálogo não modais.

 

Resumo: As principais etapas são, após criar uma nova caixa de diálogo, associar uma classe e, em seguida, usar um ponteiro para apontar para a classe; em seguida, usar o ponteiro para criar e exibir a caixa de diálogo e, finalmente, destruir o ponteiro na função virtual liberar recursos.

       Após a exibição da caixa de diálogo não modal, outras janelas do programa ainda podem ser executadas normalmente, responder à entrada do usuário e alternar entre si . Altere a caixa de diálogo modal Dica criada na aula anterior para uma caixa de diálogo não modal, para que todos vejam o efeito.

       Na verdade, não há diferença entre o diálogo modal e o diálogo não modal na criação de recursos de diálogo e geração de classes de diálogo, portanto, nem o recurso de diálogo IDD_TIP_DIALOG nem a classe CTipDlg criada na aula anterior precisam ser modificados.

       O que precisa ser modificado é a criação e exibição da instância da classe de diálogo, ou seja, o código de exibição do diálogo adicionado no corpo da função CAdditionDlg::OnBnClickedAddButton(). Aqui estão as etapas específicas:

• 1. Inclua o arquivo de cabeçalho CTipDlg em AdditionDlg.he defina a variável de membro do ponteiro do tipo CTipDlg. O método de operação detalhado é excluir o #include "CTipDlg.h" adicionado anteriormente em AdditionDlg.cpp e adicionar #include "CTipDlg.h" em AdditionDlg.h, porque precisamos definir o tipo CTipDlg na variável de ponteiro AdditionDlg.h , portanto, seu arquivo de cabeçalho deve ser incluído primeiro; em seguida, adicione a variável de membro privado CTipDlg *m_pTipDlg; à classe CAdditionDlg em AdditionDlg.h.
• 2. Inicialize a variável de membro m_pTipDlg no construtor da classe CAdditionDlg . Se houver muitas funções no arquivo cpp, podemos encontrar a classe CAdditionDlg na metade superior da exibição de classe e, em seguida, encontrar seu construtor na metade inferior da exibição. Clique duas vezes e a área do cliente do meio pode imediatamente mude para a implementação do construtor. É um bom hábito adicionar m_pTipDlg = NULL; no corpo do construtor. Chicken bicando arroz mencionado na atribuição de ponteiro e aritmética de ponteiro da série de introdução à programação C++ que é inicializado antes de qualquer variável de ponteiro ser usada, o que pode evitar acesso acidental. endereço de memória importante e destruir os dados neste endereço.
• 3. Comente ou exclua o código de exibição de diálogo modal adicionado na aula anterior e adicione a criação de diálogo não modal e o código de exibição. Em VC++, "//" é usado para comentar uma única linha de código, e "/*" pode ser adicionado no início do código a ser comentado e "*/" no final do código comentado. A função CAdditionDlg::OnBnClickedAddButton() modificada é a seguinte:

  
  
   
   
void CAdditionDlg::OnClickedAddButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
/*INT_PTR nRes; // Usado para salvar o valor de retorno da função DoModal

CTipDlg tipDlg; // Constrói uma instância da classe de diálogo CTipDlg
nRes = tipDlg.DoModal(); // caixa de diálogo pop-up
if (IDCANCEL == nRes) // Determina se o valor de retorno é IDCANCEL após a saída da caixa de diálogo, se for, retorna, caso contrário, continua a executar
retornar;*/

// Se o valor da variável do ponteiro m_pTipDlg for NULL, a caixa de diálogo ainda não foi criada e precisa ser criada dinamicamente
if ( NULL == m_pTipDlg)
{
// 创建非模态对话框实例
m_pTipDlg = new CTipDlg();
m_pTipDlg-> Create(IDD_TIP_DIALOG, this);
}
// 显示非模态对话框
m_pTipDlg-> ShowWindow(SW_SHOW);

// 将各控件中的数据保存到相应的变量
UpdateData(TRUE);

// 将被加数和加数的加和赋值给m_editSum
m_editSum = m_editSummand + m_editAddend;

// 根据各变量的值更新相应的控件。和的编辑框会显示m_editSum的值
UpdateData(FALSE);
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

  这样，非模态对话框创建和显示的代码就添加修改完了。让我们运行下看看效果吧。

      在加法计算器对话框上输入被加数和加数，然后点“计算”按钮，依然像上节一样弹出了提示对话框，但是先不要关闭它，你可以拖动它后面的加法计算器对话框试试，我们发现加法计算器对话框竟然可以拖动了，而且“和”编辑框里已经显示了运算结果，这表明提示对话框显示以后还没有关闭，OnBnClickedAddButton() 就继续向下执行了，不仅如此，加法计算器的每个编辑框还都可以响应输入。

这只是一个简单的例子，非模态对话框的用处有很多，以后大家在软件开发中会用到。

 

 

属性页对话框

 

属性页对话框的分类

属性页对话框想必大家并不陌生，XP系统中桌面右键点属性，弹出的就是属性页对话框，它通过标签切换各个页面。另外，我们在创建MFC工程时使用的向导对话框也属于属性页对话框，它通过点击“Next”等按钮来切换页面。
属性页对话框就是包含一般属性页对话框和向导对话框两类。它将多个对话框集成于一身，通过标签或按钮来切换页面。
属性页对话框相关类

我们使用属性页对话框时，用到的类主要有两个：CPropertyPage类 和 CPropertySheet 类。

 

 1.CPropertyPage 类

       CPropertyPage类继承自CDialog类，它被用于处理某单个的属性页，所以要为每个属性页都创建一个继承自CPropertyPage的子类。大家可以在VS2010的MSDN中查找CPropertyPage类以及它的成员的详细说明。下面鸡啄米就为大家讲解MSDN中列出的CPropertyPage类的部分主要成员函数。

  
  
   
   
（ 1）构造函数
       这里讲三个CProperty类的构造函数，函数原型为：
       CPropertyPage( );

       explicit CPropertyPage(
               UINT nIDTemplate,
               UINT nIDCaption = 0,
               DWORD dwSize = sizeof (PROPSHEETPAGE)
        );

        explícito CPropertyPage(
               LPCTSTR lpszTemplateName,
               UINT nIDCaption = 0 ,
               DWORD dwSize = sizeof (PROPSHEETPAGE)
        );

       O primeiro é um construtor sem nenhum parâmetro.
       No segundo construtor, o parâmetro nIDTemplate é o ID do recurso de diálogo da página de propriedades,
O parâmetro nIDCaption é o ID do recurso de string usado para o título da guia da caixa de diálogo da página de propriedades,
Se definido como 0 , o título da guia usará o título do recurso de diálogo da página de propriedades.

       No terceiro construtor, o parâmetro lpszTemplateName é a string de nome do recurso de diálogo da página de propriedades,
Não pode ser NULO . O parâmetro nIDCaption é o mesmo acima.

( 2 ) Função CancelToClose ()
      Use a função CancelToClose() após uma operação irrecuperável ter sido executada na página de propriedades da caixa de diálogo da página de propriedades modal
Altere o botão "OK" para um botão "Fechar" e desative o botão "Cancelar". O protótipo da função é:
       void CancelToClose( );

( 3 ) Função SetModified()
       Chame esta função para ativar ou desativar o botão "Aplicar", o protótipo da função é:
       void SetModified( BOOL bChanged = TRUE );

( 4 ) Funções sobrecarregáveis
       A classe CPropertyPage fornece algumas funções de processamento de mensagens para responder a várias mensagens da caixa de diálogo da página de propriedades.
Podemos personalizar o processamento das operações da caixa de diálogo da página de propriedades sobrecarregando essas funções de processamento de mensagens.
Manipuladores de mensagens sobrecarregáveis ​​incluem:
      OnApply: Tratar a mensagem de que o botão "Aplicar" da página de propriedades foi clicado
      OnCancel: Tratar a mensagem de que o botão "Cancelar" da página de propriedades foi clicado
      OnKillActive: Lida com a mensagem de que o estado ativo atual da página de propriedades é alternado, geralmente usado para validação de dados
      OnOK: Tratar a mensagem de que o botão "OK", botão "Aplicar" ou botão "Fechar" da página de propriedades é clicado
      OnQueryCancel: Tratar a mensagem enviada antes que o botão "Cancelar" da página de propriedades seja clicado
      OnReset: trata a mensagem de que o botão "Redefinir" da página de propriedades foi clicado
      OnSetActive: trata a mensagem de que a página de propriedades é alterada para a página ativa atual
      OnWizardBack: Trata a mensagem de que o botão "Voltar" da página de propriedades é clicado, válido apenas na caixa de diálogo do assistente
      OnWizardFinish: Trata a mensagem de que o botão "Concluir" da página de propriedades é clicado, válido apenas na caixa de diálogo do assistente
      OnWizardNext: Trata a mensagem de que o botão "Avançar" da página de propriedades é clicado, válido apenas na caixa de diálogo do assistente
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

 

2. Classe CPropertySheet

       A classe CPropertySheet herda da classe CWnd, que é uma classe de folha de propriedade responsável por carregar, abrir ou excluir páginas de propriedade e alternar páginas de propriedade na caixa de diálogo da página de propriedade. É semelhante a uma caixa de diálogo e também possui dois tipos: modal e não modal. O arroz de frango a seguir explicará algumas funções de membro da classe CPropertySheet.

  
  
   
   
( 1 ) Construtor
       Os três construtores da classe CPropertySheet ainda estão listados aqui:
      CPropertySheet ( );

       explícito CPropertySheet (
               UINT nIDCaption,
              CWnd* pParentWnd = NULL ,
              UINT iSelectPage = 0
      ) ;

      explícito CPropertySheet (
              LPCTSTR pszLegenda,
              CWnd* pParentWnd = NULL ,
              UINT iSelectPage = 0
      ) ;

      Parâmetro nIDCaption: ID da cadeia de recursos para o título.
      Parâmetro pParentWnd: a janela pai da caixa de diálogo da página de propriedades, se definida como NULL , a janela pai é a janela principal do aplicativo.
      Parâmetro iSelectPage: No estado inicial, o índice da página de propriedades ativa, cujo padrão é a primeira página de propriedades adicionada à folha de propriedades.
      Parâmetro pszCaption: string do título.

( 2 ) Função GetActiveIndex ()
      Obtenha o índice da página de propriedades atualmente ativa. O protótipo da função é:
      int GetActiveIndex () const ;
       Valor de retorno: O índice da página de propriedades atualmente ativa.

( 3 ) Função GetActivePage ()
       Obtém o objeto de página de propriedade atualmente ativo. O protótipo da função é:
      CPropertyPage* GetActivePage ( ) const ;
      Valor de retorno: ponteiro para o objeto da página de propriedades atualmente ativo.

( 4 ) Função GetPage ()
      Obtenha um objeto de página de propriedade. O protótipo da função é:
      CPropertyPage* GetPage ( int nPage) const ;
      Parâmetros nPage: O índice da página de propriedades de destino.
      Valor de retorno: Um ponteiro para o objeto de página de propriedades de destino.

( 5 ) Função GetPageCount ()
      Obtenha o número de páginas de propriedades. O protótipo da função é:
       int GetPageCount () const ;
      Valor de retorno: o número de páginas de propriedade.

( 6 ) Função GetPageIndex ()
       Obtém o índice de uma página de propriedade na caixa de diálogo da página de propriedade. O protótipo da função é:
      int GetPageIndex (CPropertyPage* pPage) ;
      Parâmetro pPage: O ponteiro do objeto de página de propriedade para obter o índice.
      Valor de retorno: O índice do objeto da página de propriedades na caixa de diálogo da página de propriedades.

( 7 ) Função SetActivePage ()
       Define uma página de propriedade como a página de propriedade ativa. O protótipo da função é:
       BOOL SetActivePage (
                 int nPágina
       ) ;

       BOOL SetActivePage (
                CPropertyPage* pPage
       ) ;
       Parâmetros nPage: O índice a ser definido como a página de propriedade ativa.
       Parâmetros pPage: o ponteiro do objeto a ser definido como a página de propriedades ativa.

( 8 ) Função SetWizardButtons ()
       Para habilitar ou desabilitar os botões Voltar, Avançar ou Concluir em uma caixa de diálogo do assistente, essa função deve ser chamada antes de chamar DoModal.
O protótipo da função é:
       void SetWizardButtons (
               DWORD dwFlags
       ) ;

       Parâmetro dwFlags: Defina os atributos de aparência e função do botão do assistente. Pode ser uma combinação dos seguintes valores:
       PSWIZB_BACK Habilita o botão "Voltar" ou desabilita o botão "Voltar" se este valor não estiver incluído.
       PSWIZB_NEXT Habilita o botão "Avançar" ou desabilita o botão "Avançar" se este valor não estiver incluído.
       PSWIZB_FINISH Ativa o botão "Concluir".
       PSWIZB_DISABLEDFINISH Exibe um botão "Concluir" desativado.

( 9 ) Função SetWizardMode ()
       Define a caixa de diálogo da página de propriedades como uma caixa de diálogo do assistente e essa função deve ser chamada antes de chamar DoModal. O protótipo da função é:
       void SetWizardMode () ;

( 10 ) Função SetTitle ()
       Define o título da caixa de diálogo de propriedades. O protótipo da função é:
       void SetTitle (
              LPCTSTR lpszTexto,
              UINT nEstilo = 0
       ) ;
       Parâmetro lpszText: string do título.
      Parâmetro nStyle: Especifica o estilo do título da tabela de atributos. Deve ser 0 ou PSH_PROPTITLE.
Se definido como PSH_PROPTITLE, a palavra "Propriedades" aparecerá após o título especificado.
Por exemplo, uma chamada para SetTitle ( "Simple" ,PSH_PROPTITLE) faria com que o título da folha de propriedades fosse "Propriedades Simples".

( 11 ) Função AddPage ()
       Adicionada uma nova página de propriedades para a caixa de diálogo de propriedades. O protótipo da função é:
       void AdicionarPágina (
              CPropertyPage *pPage
       ) ;
       Parâmetro pPage: o ponteiro do objeto da nova página de propriedades a ser adicionada.

( 12 ) Função PressButton ()
       Simula o pressionamento de um botão especificado. O protótipo da função é:
       void PressButton (
              int nButton
       ) ;
       Parâmetro nButton: O botão para simular que está sendo pressionado, pode ser um dos seguintes valores:
       PSBTN_BACK Selecione o botão "Voltar".
      PSBTN_NEXT Selecione o botão "Avançar".
      PSBTN_FINISH Selecione o botão "Concluir".
      PSBTN_OK Selecione o botão "OK".
      PSBTN_APPLYNOW Selecione o botão Aplicar.
      PSBTN_CANCEL Selecione o botão "Cancelar".
      PSBTN_HELP Selecione o botão Ajuda.

( 13 ) Função RemovePage ()
       Excluir uma página de propriedade. O protótipo da função é:
      void RemoverPágina (
              CPropertyPage *pPage
       ) ;

       void RemoverPágina (
               int nPágina
      ) ;

      Parâmetro pPage: o ponteiro do objeto da página de propriedades a ser deletada.
      Parâmetros nPage: O índice da página de propriedades a ser excluída.
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

       A caixa de diálogo de propriedades e os dois tipos relacionados de arroz de frango são introduzidos aqui primeiro, principalmente para preparar o uso da caixa de diálogo da página de propriedades posteriormente.

 

 

Criar caixa de diálogo do assistente

 

       Ainda com base no exemplo anterior da "calculadora de adição", adicionando uma caixa de diálogo do assistente, podemos usá-la para explicar como usar a calculadora de adição e guiar o usuário passo a passo, que também é um uso relativamente comum.

       Ao usar a calculadora de adição, ela pode ser dividida em três etapas: insira a soma, insira a adição e clique no botão "calcular".

       Arroz de bicada de frango detalhará as etapas de criação da caixa de diálogo do assistente:

 

1. Crie um recurso de caixa de diálogo da página de propriedades

       De acordo com o método descrito em Criando um Modelo de Diálogo e Modificando as Propriedades do Diálogo, clique com o botão direito do mouse no nó Diálogo de "Exibição de Recursos" e selecione "Inserir Diálogo" no menu do botão direito para criar o primeiro modelo de diálogo, o ID da caixa de diálogo

       Exclua os botões "OK" e "Cancelar" e, em seguida, adicione uma caixa de texto estática de acordo com o método descrito em Adicionando controles à caixa de diálogo e modifique a propriedade Legenda da caixa de texto estática para "Insira primeiro a soma dupla" .

       Prossiga para adicionar o segundo e terceiro recursos de diálogo, seguindo as etapas acima. O ID do segundo modelo de diálogo é definido como IDD_ADDEND_PAGE, e a propriedade Caption é alterada para "Addend Page", e uma caixa de texto estática também é adicionada, e a legenda é definida como "Please continue to enter double type addend" e outras propriedades são as mesmas da primeira caixa de diálogo. O ID do terceiro modelo de diálogo é definido como IDD_ADD_PAGE, a propriedade Caption é alterada para "Calculation Page", a propriedade Caption da caixa de texto estática adicionada é alterada para "Finalmente, pressione o botão "Calcular"" e outras propriedades são iguais à primeira caixa de diálogo.

 

2. Crie uma classe de página de propriedade

       De acordo com o método em criar uma classe de diálogo e adicionar variáveis ​​de controle , clique com o botão direito do mouse no primeiro modelo de diálogo, selecione "Adicionar classe" no menu do botão direito e a caixa de diálogo do assistente de classe aparecerá, insira a classe no Caixa de edição "Nome da classe" O nome "CSummandPage" é diferente de antes, porque a classe da página de propriedade deve herdar da classe CPropertyPage, portanto, para modificar a opção "Classe base" abaixo, selecione "CPropertyPage" na lista suspensa.

       Como é a primeira página de propriedades, ela deve ter um botão "Avançar", onde adicioná-la? Conforme mencionado na aula anterior sobre a função sobrecarregável da classe CPropertyPage , a função OnSetActive é utilizada para processar a mensagem de que a página de propriedades é trocada para a página ativa atual, para que possamos fazer configurações relacionadas na função OnSetActive.

       Então, como sobrecarregar a função OnSetActive? Podemos encontrar o nó "CSummandPage" em "Class View", clicar com o botão direito do mouse para abrir o menu do botão direito, selecionar "Propriedades" e, em seguida, a lista de propriedades da caixa de diálogo será exibida no painel direito do VS2010. Há uma informação de dica na barra de ferramentas da lista de propriedades como botão "Substitui", pressione-o, as funções sobrecarregadas são listadas na lista inferior, localize "OnSetActive", clique no item da lista em branco à direita e uma seta para baixo aparecerá aparecer, então clique na seta e "<Adicionar>" aparecerá abaixo da opção OnSetActive", selecione-a adicionará automaticamente a função OnSetActive na classe CSummandPage.

   Precisamos apenas adicionar códigos relevantes no corpo da função OnSetActive para obter o efeito de adicionar o botão "Next". O novo corpo da função é o seguinte:

  
  
   
   
BOOL CSummandPage::OnSetActive ()
{
// TODO: Adicione seu código especializado aqui e/ou chame a classe base

// Obtém a janela pai, ou seja, a folha de propriedades classe CPropertySheet
CPropertySheet* psheet = (CPropertySheet*) GetParent ();
// Defina a folha de propriedades para ter apenas o botão "Avançar"
psheet-> SetWizardButtons (PSWIZB_NEXT);

return CPropertyPage:: OnSetActive ();
}
  
  
   
   

       Adicione também as classes de página de propriedade CAddendPage e CAddPage para a segunda e terceira caixas de diálogo, respectivamente. Mas a página de propriedades da segunda caixa de diálogo não precisa substituir a função OnSetActive. A terceira caixa de diálogo é a última caixa de diálogo, portanto, o botão "Avançar" não é necessário, mas deve ser substituído pelo botão "Concluir", portanto, também é necessário sobrecarregar a função OnSetActive para definir o botão "Concluir". O OnSetActive sobrecarregado é o seguinte:

  
  
   
   
BOOL CAddPage::OnSetActive ()
{
// TODO: Adicione seu código especializado aqui e/ou chame a classe base

// Obtém a janela pai, ou seja, a folha de propriedades classe CPropertySheet
CPropertySheet* psheet = (CPropertySheet*) GetParent ();
// Define a tabela de atributos para ter apenas o botão "Concluído"
psheet-> SetFinishText (_T( "完成" ));

return CPropertyPage:: OnSetActive ();
}
  
  
   
   

       No segmento de código acima, um _T é adicionado antes da string "Complete", isso ocorre porque o conjunto de caracteres Unicode padrão foi usado quando o projeto foi criado e, se _T não for adicionado antes de "Complete", é uma string ASCII. _T é na verdade uma macro. Quando o conjunto de caracteres do projeto é selecionado como Unicode, a string é convertida em uma string Unicode, e quando Muli-Byte é selecionado, ela é convertida em uma string ASCII. Podemos clicar com o botão direito do mouse no nó raiz Adição do Gerenciador de Soluções, selecionar "Propriedades" no menu do botão direito e a caixa de diálogo de propriedades do projeto aparecerá. O Conjunto de Caracteres na lista à direita de Propriedades de Configuração-> Geral exibirá o conjunto de caracteres selecionado.

       Em seguida, clique no botão "Concluir" na terceira página de propriedades.Se quisermos realizar algum processamento, iremos sobrecarregar a função OnWizardFinish, o método é o mesmo da função OnSetActive. A função OnWizardFinish sobrecarregada é a seguinte:

  
  
   
   
BOOL CAddPage::OnWizardFinish ()
{
// TODO: Adicione seu código especializado aqui e/ou chame a classe base

// Avisa que o assistente está completo
MessageBox (_T( "O guia de instruções foi lido!" ));

return CPropertyPage:: OnWizardFinish ();
}
  
  
   
   

 

3. Crie uma classe de folha de propriedades

       Depois que os recursos da página de propriedade e as classes da página de propriedade são criados, a caixa de diálogo do assistente não pode ser gerada.Também precisamos de uma classe de folha de propriedade para acomodar essas páginas de propriedade.

       Clique com o botão direito do mouse no nó raiz "Addition" na exibição Solution Explorer, selecione Add->Class no menu do botão direito e a caixa de diálogo "Add Class" será exibida e, em seguida, selecione "MFC Class" na área do meio, e clique no botão "Adicionar", outra caixa de diálogo do assistente de classe aparece, defina o nome da classe como CAddSheet, selecione "CPropertySheet" como a classe Base e clique no botão "Concluir", para que a classe da folha de propriedades seja criada.

       Em seguida, inclua os arquivos de cabeçalho para as três classes de folha de propriedades no recém-gerado AddSheet.h:

       #include "SummandPage.h"
       #include "AddendPage.h"
       #include "AddPage.h"

       Em seguida, adicione variáveis ​​privadas em AddSheet.h:

       CSummandPage m_summandPage;C
       CAddendPage m_addendPage;
       CAddPage m_addPage;

       Em seguida, modifique os dois construtores de CAddSheet no arquivo AddSheet.cpp como:

  
  
   
   
CAddSheet :: CAddSheet ( UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)
:CPropertySheet(nIDCaption, pParentWnd, iSelectPage)
{
// Adiciona três páginas de propriedades à folha de propriedades
AddPage(&m_summandPage);
AddPage(&m_addendPage);
AddPage(&m_addPage);
}

CAddSheet :: CAddSheet (LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage)
:CPropertySheet(pszCaption, pParentWnd, iSelectPage)
{
// Adiciona três páginas de propriedades à folha de propriedades
AddPage(&m_summandPage);
AddPage(&m_addendPage);
AddPage(&m_addPage);
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

 

4. Mostrar caixa de diálogo do assistente

        Adicionamos um botão à caixa de diálogo da calculadora de adição, clique nele para abrir a caixa de diálogo do assistente. A ID desse botão é definida como IDC_INSTRUCT_BUTTON e a propriedade Caption é definida como "Instruções".

        De acordo com o método descrito em Adicionando uma função de processamento de mensagem para um controle , adicione uma função de processamento de mensagem de clique OnBnClickedInstructButton na classe CAdditionDlg para o botão IDC_INSTRUCT_BUTTON. Em seguida, inclua o arquivo de cabeçalho de CAddSheet no arquivo AdditionDlg.cpp: #include "AddSheet.h". Por fim, modifique a função OnBnClickedInstructButton da seguinte maneira:

  
  
   
   
void CAdditionDlg::OnBnClickedInstructButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui

// cria o objeto da tabela de atributos
Folha CAddSheet (_T( "" )) ;
// Define a caixa de diálogo de propriedades como uma caixa de diálogo do assistente
folha. SetWizardMode ();
// Abre a caixa de diálogo do assistente modal
folha. DoModal ();
}
  
  
   
   

Neste ponto, a caixa de diálogo do assistente está completamente criada e pode ser exibida clicando no botão "Instruções" na caixa de diálogo da calculadora de adição. Vamos ver o efeito:

       A imagem acima é apenas o efeito da página adicionada, clique no botão "Avançar" nela para continuar exibindo as próximas duas páginas.

       As caixas de diálogo do assistente são menos complexas do que se pensava anteriormente? Você pode usar sua imaginação para fazer modificações mais complexas e obter funções mais perfeitas. Amigos ainda são bem-vindos ao blog de arroz de bicando frango para trocar e aprender.

 

 

Criação e exibição de caixas de diálogo da página de propriedades

 

As caixas de diálogo da página de propriedades incluem as caixas de diálogo do assistente e as caixas de diálogo da página de propriedades gerais. A seção anterior descreveu como criar e exibir as caixas de diálogo do assistente . Esta seção continuará apresentando a criação e a exibição das caixas de diálogo da página de propriedades gerais.

       Na verdade, o processo de criação e exibição das caixas de diálogo da página de propriedade geral é muito semelhante ao das caixas de diálogo do assistente. Chicken Peck Rice modifica ligeiramente a caixa de diálogo do assistente na seção anterior para torná-la uma caixa de diálogo de página de propriedade geral.

       As etapas de criação da caixa de diálogo da página de propriedades gerais:

       1. Crie um recurso de caixa de diálogo da página de propriedades

       O método de criação do recurso de diálogo da página de propriedades é o mesmo do diálogo do assistente, e o recurso de diálogo da aula anterior não precisa de nenhuma modificação.

       2. Crie uma classe de página de propriedade

       A criação da classe de página de propriedade é basicamente a mesma que a classe de página de propriedade da caixa de diálogo do assistente, exceto que botões como "Avançar" e "Concluir" não são necessários na caixa de diálogo da página de propriedade geral, portanto, OnSetActive e OnWizardFinish da classe página de propriedade na aula anterior As funções sobrecarregadas podem ser removidas. Ou seja, a função OnSetActive na classe CSummandPage, a função OnSetActive e a função OnWizardFinish na classe CAddPage podem ser excluídas ou comentadas. Outras partes não precisam de nenhuma modificação.

       3. Crie uma classe de folha de propriedades

       O processo de criação da classe de folha de propriedades é o mesmo da classe de folha de propriedades da caixa de diálogo do assistente, portanto, a classe CAddSheet da aula anterior não precisa ser modificada.

       4. Exiba a caixa de diálogo Páginas de propriedades gerais

       A exibição da caixa de diálogo do assistente na aula anterior é implementada na função OnBnClickedInstructButton. A instrução sheet.SetWizardMode(); visa definir a folha de propriedades como o modo de diálogo do assistente, portanto, não é necessário chamar a função membro SetWizardMode quando exibindo a caixa de diálogo da página de propriedades gerais. Além disso, podemos definir o título da caixa de diálogo da página de propriedades como "Instruções" e passar essa string como um parâmetro do construtor ao construir o objeto da folha de propriedades . A função OnBnClickedInstructButton é modificada da seguinte forma:

  
  
   
   
void CAdditionDlg::OnBnClickedInstructButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui

// cria o objeto da tabela de atributos
Folha CAddSheet (_T( "Instruções" )) ;

// Abre a caixa de diálogo da página de propriedade geral modal
folha. DoModal ();
}
  
  
   
   

Desta forma, a criação e exibição da caixa de diálogo da página de propriedades gerais está concluída. Vamos executar o programa e clicar no botão "Instruções" na caixa de diálogo resultante para ver o efeito:

    Para resumir, a diferença entre a criação e exibição da caixa de diálogo da página de propriedades gerais e a caixa de diálogo do assistente inclui: se é necessário funções sobrecarregadas, como OnSetActive e OnWizardFinish, e se é necessário chamar a função SetWizardMode da classe de folha de propriedades para definir como o modo da caixa de diálogo do assistente.

 

 

diálogo de mensagem

 

Nas seções anteriores, o frango bicando arroz falou sobre a caixa de diálogo da página de propriedades e podemos criar facilmente nossa própria caixa de diálogo da página de propriedades de acordo com o conteúdo. Esta seção explica o tipo de caixa de diálogo mais comumente usado e mais simples no sistema Windows - a caixa de diálogo de mensagem.

       Muitas vezes vemos caixas de diálogo de mensagens no processo de uso do sistema Windows, informando que há uma exceção ou fazendo perguntas. Como as caixas de diálogo de mensagem são frequentemente usadas no desenvolvimento de software, o MFC fornece duas funções que podem gerar diretamente uma caixa de diálogo de mensagem de um estilo especificado, sem a necessidade de criarmos recursos de diálogo e gerar caixas de diálogo sempre que o usarmos. classe etc. Essas duas funções são a função de membro MessageBox() da classe CWnd e a função global AfxMessageBox().

 

1.   Uso das funções CWnd::MessageBox() e AfxMessageBox()

       O arroz de frango a seguir explicará o uso das duas funções, respectivamente.

       1. Função CWnd::MessageBox()

       O protótipo da função CWnd::MessageBox() é o seguinte:     

  
  
   
   
 int MessageBox(
          LPCTSTR lpszTexto,
          LPCTSTR lpszCaption = NULL ,
           UINT nTipo = MB_OK
      );

      Descrição do parâmetro:
      lpszText: A string da mensagem a ser exibida.
      lpszCaption: A cadeia de caracteres do título da caixa de diálogo da mensagem. O valor padrão é NULL . Use o título padrão quando o valor for NULL .
      nType: O estilo e as propriedades da caixa de diálogo da mensagem. O padrão é o estilo MB_OK, ou seja, apenas o botão "OK".
      O valor de nType pode ser um dos valores nas duas tabelas a seguir ou qualquer combinação de um valor para cada.
Ou seja, você pode especificar um tipo de caixa de diálogo, um ícone de diálogo ou ambos.
  
  
   
   

O valor de nType pode ser um dos valores nas duas tabelas a seguir ou qualquer combinação de um valor para cada. Ou seja, você pode especificar um tipo de caixa de diálogo, um ícone de diálogo ou ambos. A tabela a seguir é  a tabela do tipo caixa de diálogo

nTipo valor	Descrição do parâmetro
MB_ABORTRETRY	Possui botões "Abortar", "Repetir" e "Ignorar"
MB_OK	Tem um botão "OK"
MB_OKCANCEL	Possui botões "OK" e "Cancelar"
MB_RETRYCANCEL	Possui botões "Repetir" e "Cancelar"
MB_SIMNÃO	Possui botões "Sim" e "Não"
MB_SIMNOCANCELAR	Possui botões "Sim", "Não" e "Cancelar"

A tabela a seguir é   a tabela de ícones da caixa de diálogo

nTipo valor	mostrar Icone
MB_ICONEXCLAMTION MB_ICONWARNING
MB_ICONASTERISK MB_ICONINFORMATION
MB_ICONQUESTION
MB_ICONHAND MB_ICONSTOP MB_ICONERROR

       Se você deseja definir o valor de nType como uma combinação de tipo e ícone, pode obter o valor assim: MB_OKCANCEL | MB_ICONQUESTION. OU bit a bit está bem.

 

       2. Função AfxMessageBox()

       O protótipo da função de AfxMessageBox() é:

  
  
   
   
      int AfxMessageBox (
          LPCTSTR lpszTexto,
          UINT nTipo = MB_OK,
          UINT nIDHelp = 0
      ) ;

      Descrição do parâmetro:
      lpszText: O mesmo que CWnd:: função MessageBox ()
      nType: CWnd:: função MessageBox ()
      nIDHelp: O ID de contexto da ajuda para esta mensagem. O valor padrão é 0 , e quando for 0 , significa usar o contexto de ajuda padrão do aplicativo.
  
  
   
   

 

2.  O valor de retorno de CWnd::MessageBox() e AfxMessageBox()

      Depois de chamarmos as duas funções acima, podemos abrir uma caixa de diálogo de mensagem modal. Depois que a caixa de diálogo da mensagem é fechada, também podemos obter seus valores de retorno. O valor de retorno de ambos é o ID do botão clicado pelo usuário na caixa de diálogo da mensagem, que podem ser os seguintes valores:

      IDABORT: Clique no botão Encerrar.
      IDCANCEL: Clique no botão Cancelar.
      IDIGNORE: Clique no botão Ignorar.
      IDNO: Clique no botão "Não".
      IDOK: Clique no botão OK.
      IDRETRY: Clique no botão Repetir.
      IDYES: Clique no botão "Sim".

 

3.  Exemplos de aplicação

     Vamos ainda usar o programa de calculadora de adição anterior como exemplo.

       Você se lembra que modificamos a função CAdditionDlg::OnBnClickedAddButton() durante a caixa de diálogo modal e seu processo pop-up Após clicar no botão "Calcular", uma caixa de diálogo modal apareceu primeiro, perguntando ao usuário se ele tem certeza de execute o cálculo de adição e julgue se o usuário selecionou "OK" ou "Cancelar" por meio do valor de retorno da função DoModal da caixa de diálogo modal. Essas funções são obviamente totalmente realizadas pela caixa de diálogo de mensagem, e Chicken Peck Rice usa a caixa de diálogo de mensagem para substituir a caixa de diálogo modal original.

       Na criação e exibição da caixa de diálogo não modal , Jipemi comentou o código relevante da caixa de diálogo modal e adicionou o código de criação e exibição da caixa de diálogo não modal. Antes de adicionar a caixa de diálogo de mensagem, adicionamos o não Caixa de diálogo -modal O código da caixa também é comentado ou excluído para garantir que a caixa de diálogo modal original ou a caixa de diálogo não modal não seja mais gerada nesta função.

       A função CAdditionDlg::OnBnClickedAddButton() modificada é a seguinte:

  
  
   
   
void CAdditionDlg::OnBnClickedAddButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui

INT_PTR nRes;

// mostra a caixa de diálogo da mensagem
nRes = MessageBox (_T( "Tem certeza que deseja realizar cálculo de adição?" ), _T( "Calculadora de adição" ), MB_OKCANCEL | MB_ICONQUESTION);
// Determina o valor de retorno da caixa de diálogo da mensagem. Se for IDCANCEL, retorne, caso contrário, continue a executar para baixo
if (IDCANCEL == nRes)
retorno ;

// Salva os dados de cada controle na variável correspondente
UpdateData (VERDADEIRO);

// Atribui a soma do summand e do addend a m_editSum
m_editSum = m_editSummand + m_editAddend;

// Atualize o controle correspondente de acordo com o valor de cada variável. e a caixa de edição exibirá o valor de m_editSum
UpdateData (FALSO);
// Define a caixa de diálogo de propriedades como uma caixa de diálogo do assistente
//planilha.SetWizardMode();
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

Compile e execute e clique no botão "Calcular" na caixa de diálogo do resultado em execução para exibir a seguinte caixa de diálogo de mensagem:

Você também pode substituir a função MessageBox pela função AfxMessageBox(), modificar os parâmetros de acordo e executá-la para ver o efeito.

 

 

diálogo de arquivo

 

      Classificação de caixas de diálogo de arquivo

      A caixa de diálogo de arquivo é dividida em caixa de diálogo de arquivo aberto e caixa de diálogo de salvamento de arquivo.Acredito que você costuma ver essas duas caixas de diálogo de arquivo no sistema Windows. Por exemplo, muitos softwares de edição, como o Bloco de Notas, têm a opção "Abrir". Após selecionar "Abrir", uma caixa de diálogo será exibida, permitindo escolher o caminho para abrir o arquivo. Essa caixa de diálogo é a caixa de diálogo de abertura de arquivo; exceto para a opção "Abrir" Geralmente, também haverá uma opção "Salvar como". Depois de selecionar "Salvar como", geralmente aparecerá uma caixa de diálogo, vamos escolher o caminho para salvar, esta é a caixa de diálogo para salvar o arquivo caixa.

       Conforme ilustrado acima, a caixa de diálogo abrir arquivo é usada para selecionar o caminho do arquivo a ser aberto e a caixa de diálogo salvar arquivo é usada para selecionar o caminho do arquivo a ser salvo.

 

       Classe de diálogo de arquivo CFileDialog

      O MFC usa a classe de caixa de diálogo de arquivo CFileDialog para encapsular a operação da caixa de diálogo de arquivo. O protótipo do construtor da classe CFileDialog é o seguinte:

  
  
   
   
CFileDialog explícito (
  BOOL bOpenFileDialog,
  LPCTSTR lpszDefExt = NULL ,
  LPCTSTR lpszFileName = NULL ,
  DWORD dwFlags = FEAR_HIDEREADONLY | FEAR_OVERWRITEPROMPT,
  LPCTSTR lpszFilter = NULL ,
  CWnd* pParentWnd = NULL ,
  DWORD dwSize = 0 ,
  BOOL bVistaStyle = TRUE
) ;
  
  
   
   

       Descrição do parâmetro:

       bOpenFileDialog: Especifica o tipo de diálogo de arquivo a ser criado. Defina como TRUE para criar um diálogo de arquivo aberto, caso contrário, um diálogo de salvamento de arquivo será criado.

       lpszDefExt: A extensão de arquivo padrão. Se o usuário não inserir uma extensão na caixa de edição do nome do arquivo, a extensão especificada por lpszDefExt será adicionada automaticamente ao nome do arquivo. O padrão é NULO.

       lpszFileName: O nome de arquivo inicial exibido na caixa de edição de nome de arquivo. Se NULL, nenhum nome de arquivo inicial é exibido.

       dwFlags: O atributo da caixa de diálogo do arquivo, que pode ser um valor ou uma combinação de vários valores. Em relação à definição de valores de atributos, você pode encontrar a estrutura OPENFILENAME no MSDN, e a descrição do elemento Flags contém todos os valores de atributos. O padrão é a combinação de OFN_HIDEREADONLY e OFN_OVERWRITEPROMPT. OFN_HIDEREADONLY significa ocultar a caixa de seleção "Somente leitura" na caixa de diálogo do arquivo. OFN_OVERWRITEPROMPT significa que, se o arquivo selecionado existir na caixa de diálogo salvar arquivo, uma caixa de diálogo aparecerá perguntando se deseja confirmar a substituição deste arquivo.

       lpszFilter: filtro de arquivo, que é uma sequência de strings composta por vários pares de strings. Se um filtro de arquivo for especificado, apenas os arquivos que atenderem aos critérios do filtro serão exibidos na lista de arquivos a serem selecionados na caixa de diálogo de arquivo. Deixe-me mostrar um exemplo fornecido no VS2010 MSDN:

       static TCHAR BASED_CODE szFilter[] = _T("Arquivos de gráfico (*.xlc)|*.xlc|Arquivos de planilha (*.xls)|*.xls|Arquivos de dados (*.xlc;*.xls)|*.xlc; *.xls|Todos os arquivos (*.*)|*.*||");

       Depois de definir o filtro desta forma, haverá quatro opções na caixa de combinação de extensão da caixa de diálogo do arquivo: Arquivos de gráfico (*.xlc), Arquivos de planilha (*.xls), Arquivos de dados (*.xlc;*.xls ) e Todos os arquivos (*.*), você pode ver que a extensão de cada arquivo é um par de strings. Por exemplo, a string de filtro de Chart Files é um par de Chart Files (*.xlc) e *.xlc.

       pParentWnd: O ponteiro para a janela pai da caixa de diálogo do arquivo.

       dwSize: O tamanho da estrutura OPENFILENAME. Diferentes sistemas operacionais correspondem a diferentes valores dwSize. O MFC usa esse parâmetro para determinar o tipo apropriado de caixa de diálogo de arquivo (por exemplo, se deve ser criada uma caixa de diálogo de arquivo do Windows 2000 ou uma caixa de diálogo de arquivo do XP). O padrão é 0, o que significa que o MFC decidirá qual caixa de diálogo de arquivo usar de acordo com a versão do sistema operacional em que o programa está sendo executado.

       bVistaStyle: Especifique o estilo da caixa de diálogo de arquivo, defina como TRUE para usar a caixa de diálogo de arquivo estilo Vista, caso contrário, use a versão antiga da caixa de diálogo de arquivo. Este parâmetro só se aplica ao compilar no Windows Vista.

       A caixa de diálogo de arquivo também é uma caixa de diálogo modal, portanto, a função de membro DoModal() da classe CFileDialog precisa ser chamada quando for aberta. Depois de clicar em "Abrir" na caixa de diálogo abrir arquivo ou clicar em "Salvar" na caixa de diálogo salvar arquivo, podemos usar a função membro GetPathName() da classe CFileDialog para obter o caminho do arquivo selecionado.

       Abaixo estão listadas várias funções de membro da classe CFileDialog, podemos usá-las para obter várias opções na caixa de diálogo do arquivo.

GetFileExt()：获得选定文件的后缀名。
GetFileName()：获得选定文件的名称，包括后缀名。
GetFileTitle()：获得选定文件的标题，即不包括后缀名。
GetFolderPath()：获得选定文件的目录。
GetNextPathName()：获得下一个选定的文件的路径全名。
GetPathName()：获得选定文件的路径全名。
GetReadOnlyPref()：获得是否“以只读方式打开”。
GetStartPosition()：获得文件名列表中的第一个元素的位置。

 

       文件对话框实例

      根据前面所讲内容，鸡啄米给大家做个文件对话框实例。

       1.创建一个基于对话框的MFC应用程序工程，名称设为“Example17”。

       2.修改主对话框IDD_EXAMPLE17_DIALOG的模板，删除自动生成的“TODO: Place dialog controls here.”静态文本框，添加两个编辑框，ID分别为IDC_OPEN_EDIT和IDC_SAVE_EDIT，再添加两个按钮，ID分别设为IDC_OPEN_BUTTON和IDC_SAVE_BUTTON，Caption分别设为“打开”和“保存”。按钮IDC_OPEN_BUTTON用于显示打开文件对话框，编辑框IDC_OPEN_EDIT显示在打开文件对话框中选择的文件路径。按钮IDC_SAVE_BUTTON用于显示保存文件对话框，编辑框IDC_SAVE_BUTTON显示在保存文件对话框中选择的文件路径。

3. Adicione as funções de processamento        de mensagem de clique CExample17Dlg::OnBnClickedOpenButton() e CExample17Dlg::OnBnClickedSaveButton() para os botões IDC_OPEN_BUTTON e IDC_SAVE_BUTTON, respectivamente.

       4. Modifique as duas funções de processamento de mensagens da seguinte forma:

  
  
   
   
void CExample17Dlg::OnBnClickedOpenButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
// definir filtro
TCHAR szFilter[] = _T( "Arquivos de texto (*.txt)|*.txt|todos os arquivos (*.*)|*.*||" );
// constrói diálogo de arquivo aberto
CFileDialog fileDlg (TRUE, _T( "txt" ), NULL , 0 , szFilter, this ) ;
CString strFilePath;

// mostra a caixa de diálogo de arquivo aberto
if (IDOK == arquivoDlg. DoModal ())
{
// Se o botão "Abrir" na caixa de diálogo do arquivo for clicado, o caminho do arquivo selecionado será exibido na caixa de edição
strFilePath = arquivoDlg. GetPathName ();
SetDlgItemText (IDC_OPEN_EDIT, strFilePath);
}
}


void CExample17Dlg::OnBnClickedSaveButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
// definir filtro
TCHAR szFilter[] = _T( "Arquivos de texto (*.txt)|*.txt|Arquivos do Word (*.doc)|*.doc|todos os arquivos (*.*)|*.*||" ) ;
// Constrói a caixa de diálogo para salvar o arquivo
CFileDialog fileDlg (FALSE, _T( "doc" ), _T( "meu" ), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, this ) ;
CString strFilePath;

// mostra a caixa de diálogo de salvar arquivo
if (IDOK == arquivoDlg. DoModal ())
{
// Se o botão "Salvar" na caixa de diálogo do arquivo for clicado, o caminho do arquivo selecionado será exibido na caixa de edição
strFilePath = arquivoDlg. GetPathName ();
SetDlgItemText (IDC_SAVE_EDIT, strFilePath);
}
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

Ao exibir o conteúdo da caixa de edição acima, o Jipeimi usa a função SetDlgItemText da API do Windows. Claro, você também pode associar variáveis ​​à caixa de edição        primeiro e depois usar a função CDialogEx
::UpdateData( ), mas o arroz de pica-frango é mais acostumado a usar a função SetDlgItemText, que parece mais flexível.

       5. Execute o programa, clique no botão "Abrir" na caixa de diálogo do resultado e a caixa de diálogo de abertura do arquivo será exibida da seguinte forma:

Depois de clicar no botão "Salvar", a caixa de diálogo Salvar arquivo é exibida:

Depois de selecionar o caminho do arquivo na caixa de diálogo abrir arquivo e na caixa de diálogo salvar arquivo, a caixa de diálogo principal é a seguinte:

    Neste ponto, a caixa de diálogo do arquivo está concluída, ainda é muito simples? Se você esquecer o significado dos parâmetros do construtor da classe de diálogo de arquivo, poderá voltar ao arroz de bicada de frango ou procurá-lo no MSDN.

 

 

caixa de diálogo de fonte

 

       A função da caixa de diálogo de fonte é selecionar uma fonte. Também vemos com frequência. O MFC usa a classe CFontDialog para encapsular todas as operações da caixa de diálogo de fonte. A caixa de diálogo de fonte também é uma caixa de diálogo modal .

       Construtor da classe CFontDialog

       Vamos primeiro entender a classe CFontDialog. Seu protótipo de construtor comum é o seguinte:

  
  
   
   
CFontDialog (
  LPLOGFONT lplfInitial = NULL ,
  DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
  CDC* pdcImpressora = NULL ,
  CWnd* pParentWnd = NULL
);

      Descrição do parâmetro:
      lplfInitial: Um ponteiro para os dados da estrutura LOGFONT, através do qual algumas características da fonte podem ser definidas.
      dwFlags: Especifica um ou mais atributos da fonte selecionada, detalhes podem ser encontrados no MSDN.
      pdcPrinter: Um ponteiro para um contexto de dispositivo de impressão.
      pParentWnd: Um ponteiro para a janela pai da caixa de diálogo de fonte.
  
  
   
   

       O primeiro parâmetro no construtor acima é o ponteiro LOGFONT e a estrutura LOGFONT contém a maioria das características da fonte, incluindo altura da fonte, largura, direção, nome e assim por diante. Aqui está a definição desta estrutura:

  
  
   
   
type def struct tagLOGFONT {
   LONG lfAltura;
   LONG lfWidth;
   LONG lfEscapement;
   LONG lfOrientation;
   Peso LONGO;
   BYTE lfItálico;
   BYTE lfSublinhado;
   BYTE lfStrikeOut;
   BYTE lfCharSet;
   BYTE lfOutPrecision;
   BYTE lfClipPrecision;
   BYTE lfQualidade;
   BYTE lfPitchAndFamily;
   TCHAR lfFaceName[LF_FACESIZE];
} LOGFONT;
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

 

       Obtenha a fonte selecionada na caixa de diálogo de fonte

       Depois de selecionar uma fonte na caixa de diálogo de fonte, como obter a fonte selecionada? Podemos obter indiretamente o objeto CFont da fonte selecionada por meio da variável membro m_cf da classe CFontDialog. m_cf é uma variável do tipo CHOOSEFONT, e a estrutura CHOOSEFONT é definida da seguinte forma:

  
  
   
   
typedef struct {
   DWORD lStructSize;
   HWND hwndOwner;
   HDC hDC;
   LPLOGFONT lpLogFont;
   INT iPointSize;
   Sinalizadores DWORD;
   COLORREF rgbColors;
   LPARAM lCustData;
   LPCFHOOKPROC lpfnHook;
   LPCTSTR lpTemplateName;
   HINSTÂNCIA hInstance;
   LPTSTR lpszEstilo;
   WORD nFontType;
   INT nTamanhoMin;
   INT nSizeMax;
} ESCOLHER FONTE, *LP ESCOLHER FONTE;
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

       Existe um membro lpLogFont na estrutura CHOOSEFON, que é um ponteiro para a variável da estrutura LOGFONT.Como mencionado acima, LOGFONT contém características de fonte.Por exemplo, podemos saber o nome da fonte através de LFFaceName de LOGFONT.

       O que finalmente queremos obter é o objeto CFont da fonte selecionada. Como obter o objeto CFont correspondente com o LOGFONT da fonte? Isso pode ser obtido usando a função de membro CreateFontIndirect da classe CFont. O protótipo da função é o seguinte:

       BOOL CreateFontIndirect(const LOGFONT* lpLogFont );

       O parâmetro é um tipo de ponteiro LOGFONT, podemos passar o membro lpLogFont da variável membro da classe CFontDialog m_cf e, em seguida, podemos obter o objeto CFont da fonte selecionada.

 

       Exemplo de aplicação de caixa de diálogo de fonte

       Frango bicando arroz fará um exemplo de caixa de diálogo de fonte para todos. Primeiro introduza as funções a serem realizadas neste exemplo, gere uma caixa de diálogo e coloque um botão de "seleção de fonte" e uma caixa de edição na caixa de diálogo. Clique no botão "Seleção de fonte" para abrir a caixa de diálogo da fonte. A caixa de edição é usada para exibir o nome da fonte selecionada e a string do nome da fonte é exibida na fonte selecionada, por exemplo, se Arial for selecionada, a string "宋体" será exibida em Arial na caixa de edição.

       Aqui estão as etapas para criar esta instância:

       1. Crie um projeto MFC baseado em diálogo chamado "Example18".

       2. No modelo da caixa de diálogo principal gerada automaticamente IDD_EXAMPLE18_DIALOG, exclua a caixa de texto estática "TODO: Place dialog controls here.", adicione um botão, defina o ID como IDC_FONT_BUTTON e defina a legenda como "seleção de fonte" para exibir a caixa de diálogo de fonte para selecionar a fonte e, em seguida, adicione uma caixa de edição com o ID definido como IDC_FONT_EDIT para exibir a string do nome da fonte na fonte selecionada.

       3. Adicione uma variável de membro particular à classe CExample18Dlg em Example18Dlg.h: CFont m_font;, que é usada para salvar a fonte selecionada na caixa de edição.

       4. Adicione a função de processamento de mensagem de clique CExample18Dlg::OnBnClickedFontButton() para o botão IDC_FONT_BUTTON.

       5. Modifique a função de processamento de mensagens CExample18Dlg::OnBnClickedFontButton() da seguinte forma:

  
  
   
   
void CExample18Dlg::OnBnClickedFontButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
CString strFontName; // nome da fonte
LOGFONT lf; // variável LOGFONT

// Limpa todos os bytes de lf para zero
memset (&lf, 0 , sizeof (LOGFONT));

// Define o nome da fonte do elemento em lf para "Arial"
_tcscpy_s(lf.lfFaceName, LF_FACESIZE, _T( "Arial" ));

// Construir a caixa de diálogo da fonte, o nome da fonte de seleção inicial é "Song Ti"
CFontDialog fontDlg (&lf) ;

if (IDOK == fontDlg.DoModal ( )) // mostra a caixa de diálogo da fonte
{
// Se m_font foi associado a um objeto de recurso de fonte, libere-o
if (m_font.m_hObject)
{
m_font. DeleteObject ();
}
// Cria uma nova fonte usando o LOGFONT da fonte selecionada
m_font. CreateFontIndirect (fontDlg.m_cf.lpLogFont);
// Obtém o ponteiro CWnd da caixa de edição IDC_FONT_EDIT e define sua fonte
GetDlgItem (IDC_FONT_EDIT)-> SetFont (&m_font);

// Se o usuário selecionar o botão OK da caixa de diálogo da fonte, obterá o nome da fonte selecionada e a exibirá na caixa de edição
strFontName = fontDlg.m_cf.lpLogFont->lfFaceName;
SetDlgItemText (IDC_FONT_EDIT, strFontName);
}
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

       6. Finalmente, compile e execute o programa. Exiba a caixa de diálogo do resultado, clique no botão "Seleção de fonte", uma caixa de diálogo de fonte aparecerá, a seleção padrão é "Song Ti", vamos escolher a fonte "Huawen Caiyun" e clique em "OK", a caixa de edição será exibido a seguir:

       Até agora, aprendemos como usar a caixa de diálogo de fonte, que é muito útil para controlar a fonte exibida no futuro desenvolvimento de interface. Se você tiver alguma dúvida, deixe uma mensagem no Chicken Peck Rice.

 

 

caixa de diálogo de cores

 

       Todos estão familiarizados com a caixa de diálogo de cores, podemos abri-la para selecionar a cor desejada, enfim, sua função é selecionar a cor. A classe CColorDialog fornecida no MFC encapsula todas as operações da caixa de diálogo de cores, por meio das quais podemos exibir a caixa de diálogo de cores e obter a cor selecionada na caixa de diálogo de cores. Como a caixa de diálogo de fonte, a caixa de diálogo de cores também é uma caixa de diálogo modal .

       Construtor da classe CColorDialog

CColorDialog(
   COLORREF clrInit = 0,
   DWORD dwFlags = 0,
   CWnd* pParentWnd = NULL
);

       Descrição do parâmetro:

       clrInit: O valor da cor selecionada por padrão, o tipo é COLORREF, que na verdade é um tipo longo sem sinal. Se seu valor não for definido, o padrão será RGB(0,0,0), que é preto.

       Observação: RGB(r,g,b) é uma macro que pode calcular valores de cores. Os três valores entre parênteses são os valores dos componentes vermelho, verde e azul, respectivamente.

       dwFlags: Valores de atributos para personalizar a funcionalidade e a aparência da caixa de diálogo de cores. Os detalhes podem ser encontrados no MSDN.

       pParentWnd: O ponteiro para a janela principal da caixa de diálogo de cores.

       Obtenha o valor da cor selecionado na caixa de diálogo de cores

       Nosso objetivo final ao usar a caixa de diálogo de cores é obter o valor de cor selecionado na caixa de diálogo de cores. Por esse motivo, a função de membro GetColor() da classe CColorDialog pode atender muito bem aos nossos requisitos. O protótipo da função GetColor() é:

       COLORREF GetColor( ) const;

       Retorna o valor COLORREF da cor selecionada.

       E se quisermos obter o valor de cada componente de R, G e B? De acordo com o valor de cor COLORREF obtido por GetColor, ele pode ser obtido usando as três macros GetRValue, GetGValue e GetBValue. A sintaxe de GetRValue é:

       BYTE GetRValue(DWORD rgb);

       O parâmetro rgb é o valor da cor COLORREF e o valor de retorno é o valor do componente R. As outras duas macros têm uma forma semelhante. Por exemplo, se o COLORREF retornado pela função GetColor() for 10000, o valor do componente R será GetRValue(10000).

       Exemplo de aplicação de caixa de diálogo de cores

       Aqui está um pequeno exemplo de uma caixa de diálogo de cores para você. As funções a serem realizadas neste exemplo são brevemente apresentadas: uma caixa de diálogo é gerada e um botão de "seleção de cores", quatro caixas de texto estáticas e quatro caixas de edição são colocadas na caixa de diálogo. As quatro caixas de texto estático exibem Color:, R:, G: e B: respectivamente, e cada caixa de texto estático é seguida por uma caixa de edição, que é usada para exibir o valor de cor selecionado na caixa de diálogo de cores e o componente vermelho do valor de cor selecionado, componente verde e componente azul.

       Aqui estão as etapas para criar uma instância:

       1. Crie um projeto MFC baseado em diálogo chamado "Example19".

       2. No modelo da caixa de diálogo principal gerada automaticamente IDD_EXAMPLE19_DIALOG, exclua a caixa de texto estática "TODO: Place dialog controls here.", adicione um botão, o ID é definido como IDC_COLOR_BUTTON, a legenda é definida como "seleção de cores", usada para exibir a caixa de diálogo de cores para selecionar uma cor. Adicione mais quatro caixas de texto estáticas, os IDs são IDC_COLOR_STATIC, IDC_R_STATIC, IDC_G_STATIC, IDC_B_STATIC, a legenda é definida como "Color:", "R:", "G:", "B:" e, depois de cada caixa de texto estática, adicione uma caixa de edição. Os IDs das quatro caixas de edição são IDC_COLOR_EDIT, IDC_R_EDIT, IDC_G_EDIT e IDC_B_EDIT, que são usados ​​para exibir o valor de cor selecionado na caixa de diálogo de cores e o componente vermelho, componente verde e componente azul do valor de cor selecionado .

       3. Adicione uma função de processamento de mensagem de clique CExample19Dlg::OnBnClickedColorButton() para o botão IDC_COLOR_BUTTON.

       4. Modifique a função de processamento de mensagens CExample19Dlg::OnBnClickedColorButton() da seguinte forma:

  
  
   
   
void CExample19Dlg::OnBnClickedColorButton ()
{
// TODO: Adicione o código do manipulador de notificação de controle aqui
COLORREF color = RGB ( 255 , 0 , 0 ); // A cor inicial do diálogo de cores é vermelho
CColorDialog colorDlg (color) ; // Constrói uma caixa de diálogo de cores e passa o valor inicial da cor

if (IDOK == colorDlg.DoModal ( )) // Exibe a caixa de diálogo de cores e determina se "OK" foi clicado
{
color = colorDlg.GetColor ( ); // Obtém o valor da cor selecionada na caixa de diálogo de cores
SetDlgItemInt (IDC_COLOR_EDIT, color); // Exibe o valor da cor selecionada na caixa de edição Color
SetDlgItemInt (IDC_R_EDIT, GetRValue (cor)); // Exibe o valor do componente R da cor selecionada na caixa de edição R
SetDlgItemInt (IDC_G_EDIT, GetGValue (cor)); // Exibe o valor do componente G da cor selecionada na caixa de edição G
SetDlgItemInt (IDC_B_EDIT, GetBValue (cor)); // Exibe o valor do componente B da cor selecionada na caixa de edição B
}
}
  
  
   
   

   
   
    
    
  
  
   
   
  
  
   
   

       5. Por fim, compile e execute o programa, clique no botão "seleção de cores" na caixa de diálogo de resultados e a caixa de diálogo de cores será exibida. No estado inicial, a caixa de seleção está em vermelho, e escolhemos outra cor. Neste momento, a caixa de diálogo de cores é a seguinte:

Clique em "OK" e as quatro caixas de edição na caixa de diálogo principal exibem, respectivamente, o valor da cor selecionada, componente R, componente G e componente B: