Arquivo da categoria ‘C/C++’

Visual – MFC – CFileDialog – C++

Publicado: 24 de abril de 2014 em C/C++

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente

CFileDialog

Encapsula a caixa de diálogo comum que é usado para abrir um arquivo ou salvar um arquivo. CFileDialog depende do arquivo COMMDLG.DLL que está incluído no Windows.

cfiledialog

Visual Studio

  1. Crie um projeto MFC Dialog Based.
  2. Coloque no dialogo os seguintes componentes: um Static Text, um Edit Control e dois Buttons.
  3. Cria uma variável chamada m_texto para o Edit Control.
  4. Crie um evento BN_CLICKED para cada botão.
  5. Use a imagem acima para dispor os componentes no dialogo.
  6. Preencha o seu código gerado automaticamente com os trechos marcados do código abaixo:

Exemplo:

Neste exemplo usamos a classe CFileDialog para usar os diálogos comuns e retornar o caminho do arquivo selecionado.

C++

// Código gerado automaticamente
// DialogoscppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Dialogoscpp.h"
#include "DialogoscppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CDialogoscppDlg::CDialogoscppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CDialogoscppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CDialogoscppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT1, m_texto);
}

BEGIN_MESSAGE_MAP(CDialogoscppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CDialogoscppDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON2, &CDialogoscppDlg::OnBnClickedButton2)
END_MESSAGE_MAP()

BOOL CDialogoscppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);			
	SetIcon(m_hIcon, FALSE);		

	return TRUE;  
}

void CDialogoscppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;
				
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}


HCURSOR CDialogoscppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Nosso código começa aqui.

void CDialogoscppDlg::OnBnClickedButton1()
{
	CString filtro = L"Texto (*.txt)|*.txt"  ;
		
	CFileDialog dialogo(TRUE, L".txt", NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | 
	                            OFN_PATHMUSTEXIST, filtro);
		
	if (dialogo.DoModal() == IDOK)
	{			
		// TODO: coloque suas funcionalidades aqui
		CString caminho = dialogo.GetPathName();	
		m_texto.SetWindowTextW(caminho);
	}
}


void CDialogoscppDlg::OnBnClickedButton2()
{		
	CString filtro = L"Texto (*.txt)|*.txt";

	CFileDialog dialogo(TRUE, L".txt", NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST |
		OFN_PATHMUSTEXIST, filtro);

	if (dialogo.DoModal() == IDOK)
	{
		// TODO: coloque suas funcionalidades aqui.
		CString caminho = dialogo.GetPathName();
		m_texto.SetWindowTextW(caminho);
	}
}

Visual – MFC – CToolBar – C++

Publicado: 18 de abril de 2014 em C/C++

Para usar o componente Toolbar em C++ MFC, você precisa primeiro conhecer alguns conceitos. O componente Toolbar é um componente criado através de um arquivo de Resource,  neste arquivo se localizada os ícones da barra de ferramentas. O Toolbar também é composto da classe CToolbar no qual precisa ser criada dinamicamente no evento OnCreate  do Frame principal declarada através de uma variável no seu respectivo arquivo  de cabeçalho .h,

Outro importante ponto do qual você precisa saber é que o componente ToolBar não pode ser criado em uma aplicação Dialog Based como vimos até agora, caso tente, não encontrará erros, sua aplicação apenas não poderá desenhar a barra de ferramentas.

Para cria um componente toolbar você precisa utilizar um tipo de aplicação MFC chamada Multiple Top-Level documents. Se você criar uma interface de documentos múltiplos (MDI), que significa aplicativo baseado em formulários, o aplicativo será capaz de suportar múltiplas instâncias do mesmo formulário.

Toolbar - Programa

Toolbar – Programa – DA

Visual Studio

Para criar um componente Toolbar MFC, siga os seguintes passos.

  1. Crie uma aplicação Multiple Top-Level documents.
  2. Abra a tela de Resources ou aperte CTRL + SHIFT + E.
  3. Com o botão direito do mouse, adicione um novo Resource  e na janela escolha ToolBar, use a figura abaixo:

    Toolbar - Resource

    Toolbar – Resource

  4. Use a barra de ferramentas para desenhar os três botões ou o menu IMAGE/Tools, veja a figura abaixo:

    Design - Ícones

    Design – Ícones

  5. Troque ID de cada botão por um já existente exemplo: ID_NEW_FILE, ID_FILE_OPEN e ID_FILE_CLOSE, note que cada ID de botão é ligado a um botão do menu que também já foi criado automaticamente e possui seu próprio evento.
  6. Declare a variável m_ferramenta na interface da classe do arquivo MainFrm.h, como no primeiro código abaixo.
  7. Complete o evento OnCreate do arquivo MainFrm.cpp com os trechos marcados do segundo código abaixo.

 

Exemplo:

Neste exemplo criamos um componente Toolbar MFC para C++ em uma aplicação Multiple Top-Level documents, visto que temos algumas restrições e conceitos para respeitar, ao criar nosso aplicativo,  automaticamente já é criado uma toolbar padrão e vamos criar uma nova toolbar com ícones no qual vamos desenhar manualmente.

C++

Arquivo 1 – MainFrm.h

// Código gerado automaticamente
// MainFrm.h : interface of the CMainFrame class
//

#pragma once

class CMainFrame : public CFrameWnd
{

protected:
	CMainFrame();
	DECLARE_DYNCREATE(CMainFrame)

public:

public:

public:
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
	virtual BOOL LoadFrame(UINT nIDResource, DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW |
		                   FWS_ADDTOTITLE, CWnd* pParentWnd = NULL, CCreateContext* pContext = NULL);

public:
	virtual ~CMainFrame();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif

protected:  

	CToolBar          m_wndToolBar;

	// Desenvolvimento Aberto
	// Declara nova toolbar

	CToolBar          m_ferramenta; 

protected:
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnFileClose();
	DECLARE_MESSAGE_MAP()

};

Arquivo 2 – MainFrm.cpp


// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "MFCApplication2.h"

#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
	ON_WM_CREATE()
	ON_COMMAND(ID_FILE_CLOSE, &CMainFrame::OnFileClose)
END_MESSAGE_MAP()

CMainFrame::CMainFrame()
{
	// TODO: add member initialization code here
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	// Desenvolvimento Aberto
	// Toolbar MFC Default 

	if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE |
		                             CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS
								   | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_wndToolBar);

	// Desenvolvimento Aberto
	// Minha segunda Ctoolbar

	if (!m_ferramenta.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE |
		                             CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS |
									 CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_ferramenta.LoadToolBar(IDR_TOOLBAR1))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;
	}

	// TODO: Apague estas 3 linhas se não quiser que a barra de ferramentas seja arrastada
	m_ferramenta.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_ferramenta);

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;

	cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE
		 | WS_THICKFRAME | WS_SYSMENU;

	return TRUE;
}

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}
#endif 

BOOL CMainFrame::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)
{

	if (!CFrameWnd::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext))
	{
		return FALSE;
	}

	CWinApp* pApp = AfxGetApp();
	if (pApp->m_pMainWnd == NULL)
		pApp->m_pMainWnd = this;

	if (AfxGetApp()->m_pMainWnd != this)
	{
		CMenu *pMenu = GetMenu();
		ASSERT(pMenu);
		BOOL bNameValid;
		CString strTemp;
		bNameValid = strTemp.LoadString(IDS_CLOSE);
		ASSERT(bNameValid);
		pMenu->ModifyMenu(ID_APP_EXIT, MF_BYCOMMAND | MF_STRING, ID_FILE_CLOSE, strTemp);
	}

	return TRUE;
}

void CMainFrame::OnFileClose()
{
	DestroyWindow();
}

 

Em computação, um tree view (literalmente do inglês vista de árvore) é um elemento de interface gráfica (isto é um componente widget) que permite ao usuário mostrar dados hierárquicos em forma de árvore, expandir ou recolher os ramos e nós. Dependendo do wiget toolkit ou aplicação em uso, existem muitos estilos de apresentação gráfica de tree views.

CTreeCtrl

Um controle de árvore, representada pela classe CTreeCtrl, é uma janela que exibe uma lista hierárquica de itens, tais como os títulos de um documento, as entradas em um índice, ou os arquivos e diretórios em um disco. Cada item consiste em um rótulo e uma imagem bitmap opcional e cada item pode ter uma lista de subitens associados. Ao clicar em um item, o usuário pode expandir e recolher a lista associada de subitens. A árvore de diretórios no painel do lado esquerdo do File Explorer é um exemplo de um controle de árvore.

HTREEITEM

Representa um nó na arvore de controle.

GetSelectedItem

Retorna o item selecionado da arvore de controle.

GetItemText

Retorna o texto de um item.

Visual Studio

Para usar um Tree Control siga os seguintes passos:

  1. Crie um novo projeto MFC Dialog Based.
  2. Arraste para o dialogo dois componentes Static Text e um Componente Tree Control.
  3. Mude a propriedade Has_Button do componente Tree Control para True.
  4. Crie uma variável chamada m_disco para o Tree Control.
  5. Mude a propriedade ID de um dos Static Text para IDC_Rodape.
  6. Disponha os componentes como na figura abaixo:

    treecontrol-design

    Tree Control – Design

  7. Crie um evento NM_DBCLK para o Tree Control.
  8. Preencha seu código gerado automaticamente com os trechos marcados do código abaixo.
treecontrol-programa

Tree Control – programa

 

Exemplo:

Neste exemplo usamos uma visão de arvore para exibir uma discografia musical, você pode abrir e fechar os nós do modelo de dados em visão de  árvore, um duplo clique do mouse em cada nó dispara um evento para que exibido a descrição do nó corrente em um rodapé.

C++

// Código gerado automaticamente
// treeviewcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "treeviewcpp.h"
#include "treeviewcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// Desenvolvimento Aberto
// Inicializa constantes, variaveis e arrays

const int itemb = 14;
const int itemr = 12;

CString albumB = L"Please, Please Me";

CString MusicaB[itemb] = { L"I Saw Her Standing There", L"Misery", L"Anna (Go to Him)",
                      L"Chains", L"Boys", L"Ask Me Why", L"Please Please Me", L"Love Me Do",
                      L"P.S. I Love You", L"Baby It's You", L"Do You Want To Know A Secret?",
                      L"A Taste of Honey", L"There's A Place", L"Twist and Shout" };

CString albumR = L"The Rolling Stones";

CString MusicaR[itemr] = { L"Route 66", L"I Just Want to Make Love to You", L"Honest I Do",
                      L"Mona (I Need You Baby)", L"You Can Make It If You Try", L"Little by Little",
                      L"I\'m a King Bee", L"Carol", L"Tell Me (You \'re Coming Back)", L"Can I Get a Witness",
                      L"Tell Me (You\'re Coming Back)", L"Walking the Dog" };

CtreeviewcppDlg::CtreeviewcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CtreeviewcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CtreeviewcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TREE1, m_disco);
}

BEGIN_MESSAGE_MAP(CtreeviewcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_NOTIFY(NM_DBLCLK, IDC_TREE1, &CtreeviewcppDlg::OnNMDblclkTree1)
END_MESSAGE_MAP()

BOOL CtreeviewcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// Desenvolvimento Aberto
	// Inicializa Tree Control

	// Cria nós da arvore
	HTREEITEM arvore, bandasB, bandasR, albunsB, albunsR, listaB, listaR ;

	// Insere nós
	arvore = m_disco.InsertItem(L"Discografia", TVI_ROOT);

	bandasB = m_disco.InsertItem(L"Beatles", arvore);
	bandasR = m_disco.InsertItem(L"Rolling Stones", arvore);

	albunsB = m_disco.InsertItem(albumB, bandasB);
	albunsR = m_disco.InsertItem(albumR, bandasR);

	for (int i = 0; i < itemb; i++)
	{
		listaB = m_disco.InsertItem(MusicaB[i], albunsB);
	}

	for (int i = 0; i < itemr; i++)
	{
		listaR = m_disco.InsertItem(MusicaR[i], albunsR);
	}

	return TRUE;
}

void CtreeviewcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this);

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CtreeviewcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Evento duplo clique do tree control

void CtreeviewcppDlg::OnNMDblclkTree1(NMHDR *pNMHDR, LRESULT *pResult)
{	

	// Captura item selecionado
	HTREEITEM hItem = m_disco.GetSelectedItem();

	// retorna texto do item
	CString item;
	item = m_disco.GetItemText(hItem);

	// Adiona texto em controle statico
	GetDlgItem(IDC_Rodape)->SetWindowTextW(item);

	*pResult = 0;
}

Visual – MFC – LIst Control – Grid – C++

Publicado: 12 de abril de 2014 em C/C++

O Controle de lista para MFC, o List Control da classe, CListrCtrl é amplamente utilizado na aplicação GUI, pois suporta relatório de lista de exibição. Isso permite que os usuários tenham de linhas e colunas que simulam como funcionalidade uma grade de dados.

CListCtrl

Use um controle de lista para exibir qualquer arranjo de ícones com rótulos, como no File Explorer, ou listas de colunas de texto, com ou sem ícones. Para uma descrição das quatro possíveis “vistas” (não confundir com vistas MFC), você pode ter em um controle de lista exibição de ícones, exibição em tamanho pequeno ícone, exibição de lista, e exibição de relatório.

listcontrol-programa

List Control

Visual Studio

Para usar o list Control siga os seguintes passos:

  1. Crie um novo projeto MFC Dialog Based.
  2. Arraste para o dialogo um componente List Control, use a figura abaixo para o design:

    listcontrol-design

    List Control – Design

  3. Crie uma variável para este componente chamada: m_tabela.
  4. No evento de inicialização OnInital, complete seu código gerado automaticamente com os trechos marcados do código abaixo:

Exemplo:

Neste exemplo usamos um List Control para simular uma grade de dados.

C++

// Código gerado automaticamente
// gridcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "gridcpp.h"
#include "gridcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CgridcppDlg::CgridcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CgridcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CgridcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, m_tabela);
}

BEGIN_MESSAGE_MAP(CgridcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
END_MESSAGE_MAP()

BOOL CgridcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);		

	// Desenvolvimento Aberto
	// nosso código começa aqui.

	// Define tipo de visualização para detalhes
	m_tabela.SetView(LV_VIEW_DETAILS);

	// Insere colunas
	m_tabela.InsertColumn(0, L"Album", LVCFMT_LEFT, 90, -1);
	m_tabela.InsertColumn(1, L"Artista", LVCFMT_LEFT, 110, -1);
	m_tabela.InsertColumn(2, L"Musica", LVCFMT_LEFT, 120, -1);
	m_tabela.InsertColumn(3, L"Ano", LVCFMT_LEFT, 50, -1);
	m_tabela.InsertColumn(4, L"VideoClip", LVCFMT_LEFT, 80, -1);

	// Define visual para grid
	m_tabela.SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);

	// Cria item
	LVITEM lvItem;

	// cria estrutura para inserir o item
	typedef struct _LVITEM {
		UINT mask;
		int iItem;
		int iSubItem;
		UINT state;
		UINT stateMask;
		LPTSTR pszText;
		int cchTextMax;
		int iImage;
		LPARAM lParam;
    #if (_WIN32_IE >= 0x0300)
		int iIndent;
    #endif
	} LVITEM, FAR *LPLVITEM;

	// Define variaveis de itens
	int InsertItem(const LVITEM* pItem);
	int nItem;

	// Insere linha
	lvItem.mask = LVIF_TEXT;
	lvItem.iItem = 0;
	lvItem.iSubItem = 0;
	lvItem.pszText = L"Nevermind";
	nItem = m_tabela.InsertItem(&lvItem);

	// Insere colunas
	m_tabela.SetItemText(nItem, 1, L"Nirvana");
	m_tabela.SetItemText(nItem, 2, L"Smell Like Teen Spirit");
	m_tabela.SetItemText(nItem, 3, L"1991");
	m_tabela.SetItemText(nItem, 4, L"Sim");

	// Insere linha 2
	lvItem.mask = LVIF_TEXT;
	lvItem.iItem = 0;
	lvItem.iSubItem = 0;
	lvItem.pszText = L"Ten";
	nItem = m_tabela.InsertItem(&lvItem);

	// Insere colunas
	m_tabela.SetItemText(nItem, 1, L"Pearl Jam");
	m_tabela.SetItemText(nItem, 2, L"Jeremy");
	m_tabela.SetItemText(nItem, 3, L"1991");
	m_tabela.SetItemText(nItem, 4, L"Sim");

	// Insere linha 3
	lvItem.mask = LVIF_TEXT;
	lvItem.iItem = 0;
	lvItem.iSubItem = 0;
	lvItem.pszText = L"Badmotorfinger";
	nItem = m_tabela.InsertItem(&lvItem);

	// Insere colunas
	m_tabela.SetItemText(nItem, 1, L"SoundGarden");
	m_tabela.SetItemText(nItem, 2, L"Outshined");
	m_tabela.SetItemText(nItem, 3, L"1991");
	m_tabela.SetItemText(nItem, 4, L"Sim");

	// Insere linha 4
	lvItem.mask = LVIF_TEXT;
	lvItem.iItem = 0;
	lvItem.iSubItem = 0;
	lvItem.pszText = L"Sweet Oblivion";
	nItem = m_tabela.InsertItem(&lvItem);

	// Insere colunas
	m_tabela.SetItemText(nItem, 1, L"Screaming Trees");
	m_tabela.SetItemText(nItem, 2, L"Nearly I Lost You");
	m_tabela.SetItemText(nItem, 3, L"1993");
	m_tabela.SetItemText(nItem, 4, L"Sim");

	// Insere linha 5
	lvItem.mask = LVIF_TEXT;
	lvItem.iItem = 0;
	lvItem.iSubItem = 0;
	lvItem.pszText = L"Core";
	nItem = m_tabela.InsertItem(&lvItem);

    // Insere colunas
	m_tabela.SetItemText(nItem, 1, L"Stone Temple Pilots");
	m_tabela.SetItemText(nItem, 2, L"Plush");
	m_tabela.SetItemText(nItem, 3, L"1992");
	m_tabela.SetItemText(nItem, 4, L"Sim");

	return TRUE;
}

void CgridcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CgridcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

Uma imagem digital é a representação de uma imagem bidimensional usando números binários codificados de modo a permitir seu armazenamento, transferência, impressão ou reprodução, e seu processamento por meios eletrônicos. Há dois tipos fundamentais de imagem digital. Uma é do tipo rastreio (raster) e outra do tipo vetorial. Uma imagem digital do tipo raster, ou bitmap, ou ainda matricial, é aquela que em algum momento apresenta uma correspondência bit-a-bit entre os pontos da imagem raster e os pontos da imagem reproduzida na tela de um monitor.

A imagem vetorial não é reproduzida necessariamente por aproximação de pontos, antes era destinada a ser reproduzida por plotters de traços que reproduziam a imagem por deslocamento de canetas-tinteiro.

Tipicamente, as imagens raster são imagens fotográficas, e as imagens vetoriais são desenhos técnicos de engenharia. Os quadrinhos ilustrados se assemelham em qualidade a imagens raster, mas são impressos em plotters que passaram a imprimir à maneira das impressoras comuns por jato de tinta.

picturecontrol-programa

CPicture Control – BMP – programa

 

CStatic

Fornece a funcionalidade de um controle estático do Windows.

HBITMAP

Um identificador para um bitmap. Para exibir imagens do tipo GIF e JPG use a classe CImage.

Visual Studio

Para usar o Picture Control siga os seguintes passos:

  1. Crie uma novo projeto MFC – Dialog Based.
  2. Arraste para o dialogo um componente Static Text e um Picture Control.
  3. Mude o ID do componente Picture Control para IDC_IMAGEM.
  4. Mude a propriedade Type do componente Picture Control para Bitmap.
  5. Use a figura abaixo para montar seu design:

    picturecontrol-design

    Picture Control – Design

  6. Efetue o download da imagem em: dowload da imagem.
  7. Abra a imagem no Paint Brush do Windows e a salve como tipo BMP em um diretório da sua escolha.
  8. Preencha seu código gerado automaticamente com os trechos do código abaixo.
  9. Lembre-se de trocar o diretório da imagem no código pelo seu diretório escolhido, em C++ as barras de diretório precisam ser invertidas.

Exemplo:

Neste exemplo usamos a mensagem de inicialização do Windows e um componente Picture Control para exibir uma imagem de Bitmap.

C++

// Código gerado autimaticamente
// ImagemcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Imagemcpp.h"
#include "ImagemcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CImagemcppDlg::CImagemcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CImagemcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CImagemcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CImagemcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()

END_MESSAGE_MAP()

BOOL CImagemcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);		

	// Desenvolvimento Aberto
	// Este bloco exibe uma imagem no formato BMP

	CStatic * foto;
	CString imagem;

	foto = (CStatic *) GetDlgItem(IDC_IMAGEM);

	imagem = L"C:/Desenvolvimento Aberto/images.bmp";

	HBITMAP pic = (HBITMAP)LoadImage(NULL, imagem, IMAGE_BITMAP, 275, 183, LR_LOADFROMFILE);
	foto->SetBitmap(pic);

	return TRUE;  

}

void CImagemcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);

	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CImagemcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

Progress Control

Fornece a funcionalidade do controle de barra de progresso comum do Windows. O Progress Control é um componente da classe CProgressCtrl e quando instanciado utiliza sua própria thread para redesenhar o controle de posição da barra de progresso, o tornando assim, um componente muito fácil de ser utilizado, dispensando o uso de um temporizador e uma nova thread para o efeito de progressão da tarefa.

Visual Studio

Para utilizar o componente Progress Control siga os seguintes passos:

  1. Crie um programa C++ MFC Dialog Based.
  2. Coloque no dialogo um Static Text, um Progress Control e um Button.
  3. Crie uma variável para o componente Progress Control chamada m_progresso.
  4. Modele seu design como na figura abaixo:

    progresscontrol

    Progress Control – Design

  5. Crie um evento de clique para o botão.
  6. Complete seu código gerado automaticamente com o trecho marcado do código abaixo:

Exemplo:

Neste exemplo criamos uma barra de progresso e incrementamos seu valor para efeito de uma progressão de uma tarefa.

// Código gerado automaticamente
// progressbarcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "progressbarcpp.h"
#include "progressbarcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CprogressbarcppDlg::CprogressbarcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CprogressbarcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CprogressbarcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_PROGRESS1, m_progresso);
}

BEGIN_MESSAGE_MAP(CprogressbarcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CprogressbarcppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

BOOL CprogressbarcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();
		
	SetIcon(m_hIcon, TRUE);			
	SetIcon(m_hIcon, FALSE);		
	
	return TRUE; 
}


void CprogressbarcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;
				
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CprogressbarcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// nosso código começa aqui

void CprogressbarcppDlg::OnBnClickedButton1()
{
	// Zera a barra de progresso
	m_progresso.SetPos(0);
	
	// Adiciona limites de valores
	m_progresso.SetRange(0, 100);
	
	// Adiciona valor de incremento
	m_progresso.SetStep(1);
	
	// Incrementa barra de progresso
	for (int andamento = 0; andamento <= 100; andamento++)
	{
		m_progresso.SetPos(andamento);
	}
}

Em interfaces gráficas de usuário (GUI), uma interface tabulada  ou um Tab Control  é um widget que permite a interação de vários documentos ou painéis para ser contido dentro de uma única janela, usando guias como um widget de navegação para alternar entre conjuntos de painéis.

TabControl

O componente TabControl para C++ é um componente complexo, quando você o arrasta para o dialogo, logo você descobre que este componente não é nada intuitivo, um modo simples e eficaz de controlar o TabControl é usando um jogo de visualização entre suas guias e os componentes no dialogo manipulando seu evento de mudança de seleção de abas manualmente. Porem se torna um pouco complexo caso haja muitos componentes em um dialogo. Você também pode usar as classes CTabCtrl e CPropertySheet para criar um controle de tabulação e suas respectivas paginas.

Visual Studio

Para usar o componente Tab Control em uma aplicação C++ siga os seguintes passos:

  1. Crie um programa MFC Dialog Based para C++.
  2. Adicione no dialogo um componente Tab Control.
  3. Adicione 3 componentes Edit Control e 3 componentes Static Text.
  4. Mude os nomes dos componentes Static Text para: IDC_rotulo1, IDC_rotulo2, IDC_rotulo3.
  5. Crie uma variável para o componente Tab Control chamada: m_abas.
  6. Crie uma variável para cada Edit Control chamada: m_numero1, m_numero2 e m_total.
  7. Crie um evento TCN_SELCHANGE para o Tab Control.
  8. Seu dialogo deve conter os componentes nomeados como na figura abaixo:

    tabcontrol-comp

    Primeiro Passo – Design

  9. Sobreponha os componentes alinhados  um e cima do outro como mostra a imagem a seguir:

    tabcontrol

    Segundo Passo – Design

  10. Complete o seu código gerado automaticamente com os trechos marcados do código abaixo.
  11. Compile e rode o programa.

Efeito da Aplicação

A sobre posição dos componentes do dialogo combinado com evento de mudança do Tab Control nos dará uma aplicação com o seguinte efeito:

tabcontrol-programa1

Tab Control – Aba 1

tabcontrol-programa2

Tab Control – Aba – 2

tabcontrol-programa3

Tab Control – Aba 3

 

 

 

 

 

 

 

 

 

 

Exemplo:

Neste exemplo criamos um painel tabulado com 3 guias onde na primeira e na segunda guia o usuário entrará com um numero inteiro e na terceira guia sobre o evento TCN_SELCHANGE efetuaremos a soma dos números escolhidos.

C++

// Código gerado automaticamente
// tabcontrol-cppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "tabcontrol-cpp.h"
#include "tabcontrol-cppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CtabcontrolcppDlg::CtabcontrolcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CtabcontrolcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CtabcontrolcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TAB1, m_abas);
	DDX_Control(pDX, IDC_EDIT2, m_numero2);
	DDX_Control(pDX, IDC_EDIT1, m_numero1);
	DDX_Control(pDX, IDC_EDIT3, m_total);
}

BEGIN_MESSAGE_MAP(CtabcontrolcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB1, &CtabcontrolcppDlg::OnTcnSelchangeTab1)
	
END_MESSAGE_MAP()

BOOL CtabcontrolcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);		
	SetIcon(m_hIcon, FALSE);	

	// TODO: Add extra initialization here

   // Desenvolvimento Aberto --->>
   // Inicialização do programa

	m_abas.InsertItem(0, _T("Numero 1"));
	m_abas.InsertItem(1, _T("Numero 2"));
	m_abas.InsertItem(2, _T("Total"));

	// Inicializa visualização de componentes
	GetDlgItem(IDC_rotulo1)->ShowWindow(SW_SHOW);
	GetDlgItem(IDC_rotulo2)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_rotulo3)->ShowWindow(SW_HIDE);
	
	GetDlgItem(IDC_EDIT1)->ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT2)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT3)->ShowWindow(SW_HIDE);

	return TRUE;  
}

void CtabcontrolcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
			
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;
				
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CtabcontrolcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Evento de mudança de abas do Tab Control

void CtabcontrolcppDlg::OnTcnSelchangeTab1(NMHDR *pNMHDR, LRESULT *pResult)
{
	// Captura evento de mudança
	int mudar = m_abas.GetCurSel();

	// Seleciona aba corrente
	if (mudar == 0)
	{
		// Exibe os itens na tela de acordo com aba selecionada
		GetDlgItem(IDC_rotulo1)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_rotulo2)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_rotulo3)->ShowWindow(SW_HIDE);
		
		GetDlgItem(IDC_EDIT1)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_EDIT2)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_EDIT3)->ShowWindow(SW_HIDE);
		
	}
	
	if (mudar == 1)
	{
		// Exibe os itens na tela de acordo com aba selecionada
		GetDlgItem(IDC_rotulo1)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_rotulo2)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_rotulo3)->ShowWindow(SW_HIDE);
		
		GetDlgItem(IDC_EDIT1)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_EDIT2)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_EDIT3)->ShowWindow(SW_HIDE);
	}

	if (mudar == 2)
	{
		// Exibe os itens na tela de acordo com aba selecionada
		GetDlgItem(IDC_rotulo1)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_rotulo2)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_rotulo3)->ShowWindow(SW_SHOW);
		
		GetDlgItem(IDC_EDIT1)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_EDIT2)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_EDIT3)->ShowWindow(SW_SHOW);

		// Declara variaveis
		CString valor1;
		CString valor2;
		CString total;

		// Alimenta variaveis 
		m_numero1.GetWindowTextW(valor1);
		m_numero2.GetWindowTextW(valor2);

		// Efetua calculo
		int soma = _wtoi(valor1) + _wtoi(valor2);
		
		// Converte variavel inteira para Cstring
		total.Format(_T("%d"), soma);
		
		// Exibe valor da variavel na tela
		m_total.SetWindowTextW(total);

	}

	*pResult = 0; 
}

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

Edit Control – Multiline

Este tipo de controle foi projetados para inserir, exibir e editar pequenas quantidades de texto. Eles não foram feitos para ser a base para editores de texto de grande escala e possuem limites.

Controles de edição de várias linhas são limitados a um máximo de 64K (65.535 bytes) de texto. Técnicas para controlar a forma como os controles de edição usam memória são necessárias. Controles de edição de várias linhas também estão limitadas ao seguinte: caracteres por linha de texto,  linhas de texto e pixels por linha de texto.

O Edit Control é um componente que armazena seu texto em um buffer e o seu conteúdo pode ser manipulado diretamente, por isto não possui as propriedades Append, WordWrap entre outras, para aprender como manipular o Edit Control diretamente use o link abaixo:

Edit Controls : http://msdn.microsoft.com/en-us/library/ms997530.aspx

Visual Studio.

Para usar o Edit Control para manipular textos siga os seguintes passos:

  1. Crie um novo projeto MFC – C++ – Dialog Based.
  2. Coloque no dialogo um Static Text, dois Edit Controls e um Button, use a imagem abaixo para o design da tela:

    multilines

    Multilines – Design

  3. Mude a propriedade do primeiro Edit_Control para Multilines = True e Vertical Scroll = True.
  4. Crie uma variável m_area para o primeiro Edit Control e uma variável m_texto para o segundo Edit Control.
  5. Crie um evento BN_CLICKED para o botão
  6. Preencha o seu código com os trechos marcados do código abaixo.

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

// Código gerado automaticamente
// TextBoxcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "TextBoxcpp.h"
#include "TextBoxcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CTextBoxcppDlg::CTextBoxcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CTextBoxcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CTextBoxcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT2, m_texto);
	DDX_Control(pDX, IDC_EDIT3, m_area);
}

BEGIN_MESSAGE_MAP(CTextBoxcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CTextBoxcppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

BOOL CTextBoxcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);		

	// Desenvolvimento Aberto
	// inicializa area de texto

	int tam1 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam1, tam1);
	m_area.ReplaceSel(L"Escreva um texto dentro da caixa de texto\n");

	int tam2 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam2, tam2);
	m_area.ReplaceSel(L"Você também pode adicionar novas linhas nesta caixa\n");

	int tam3 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam3, tam3);
	m_area.ReplaceSel(L"Escrevendo no editor e clicando no botão\n");

	return TRUE;
}

void CTextBoxcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CTextBoxcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Evento do botão
void CTextBoxcppDlg::OnBnClickedButton1()
{
	CString novotxt;

	m_texto.GetWindowTextW(novotxt);
	int tam = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam, tam);
	m_area.ReplaceSel(novotxt + L"\n");
}

Para validar senhas em C++ você deve usar o componente Edit Control com sua propriedade Password alterada para True, deste modo o controle altera a visualização dos caracteres comuns para caracteres “*”.

MessageBox

Envia mensagens para o usuário através da API do Windows.

Visual Studio

Para criar um programa que valida senhas siga os seguintes passos:

  1. Crie um novo projeto C++ MFC Application Dialog Based.
  2. Coloque os componentes: Static Text, Edit Control e um Button no dialogo, use a figura abaixo para o design:

    password_design

    Design

  3. Crie uma variável chamada m_senha para o Edit Control.
  4. Mude a propriedade Password do Edit Control para True.
  5. Crie um evento para o clique do botão.
  6. Use o código abaixo e complete seu código gerado automaticamente.
password_prog

Programa

 

Exemplo:

Neste exemplo criamos um campo de entrada de senha, o validamos e exibimos mensagens para o usuário.

C++

// Código gerado automaticamente
// senhacppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "senhacpp.h"
#include "senhacppDlg.h"
#include "afxdialogex.h"
#include <Windows.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CsenhacppDlg::CsenhacppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CsenhacppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CsenhacppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT1, m_senha);
}

BEGIN_MESSAGE_MAP(CsenhacppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CsenhacppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

BOOL CsenhacppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);			
	SetIcon(m_hIcon, FALSE);		

	return TRUE;  
}

void CsenhacppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;
				
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CsenhacppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// nosso código começa aqui

// Verifica senha
static bool  verificaSenha(CString psenha)
{
	bool correto = true;
	
	// Retorna senha de alguma fonte
	CString rsenha = L"daaberto";

	// Verifica tamanho
	if (psenha.GetLength() != rsenha.GetLength())
	{
		correto = false;
	}
	else
	{
		// Verifica senha
		if (psenha != rsenha)
		{
			correto = false;
		}
	}

	return correto;
}

// Cria menssagens
int menssagem(bool correto)
{
	LPCWSTR msg;

	if (correto)
	{
		msg = L"A Senha está correta";
	}
	else
	{
		msg = L"A Senha está incorreta";
	}

	int msgboxID = MessageBox(
		NULL,
		msg,
		(LPCWSTR)L"Menssagem",
		MB_ICONWARNING | MB_OK | MB_DEFBUTTON2
		);

	switch (msgboxID)
	{
	case IDOK:

		break;	
	}

	return msgboxID;
}

// Evento do botão
void CsenhacppDlg::OnBnClickedButton1()
{
	// Exibe menssagem
	CString psenha;

	m_senha.GetWindowTextW(psenha);

	if (verificaSenha(psenha))
	{
		menssagem(true);
	}
	else
	{
		menssagem(false);
	}
	
}

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

OnContextMenu

Evento da mensagem WM_CONTEXTMENU, chamado ao usuário clicar no botão direito do mouse na janela de dialogo.

GetClientRect

Cópia as coordenadas da área de cliente CWnd na estrutura apontada pelo lpRect.

ClientToScreen

Converte as coordenadas do cliente de um determinado ponto ou retângulo na tela em coordenadas de tela.

TrackPopUpMenu

Exibe um menu pop-up flutuante no local especificado e controla a seleção de itens no menu pop-up.

Assert

Avalia um argumento. Se o resultado for 0, a macro imprime uma mensagem de diagnóstico e anula o programa. Se a condição for diferente de zero, o programa não faz nada.

Visual Studio

Neste ponto presumimos que você já sabe como criar componentes e menus no Visual Studio para um projeto MFC Application C++, caso ainda não saiba veja nossos posts anteriores.

  1. Coloque um componente Static Text e um componente Edit Control no dialogo, use a imagem abaixo para referencia:

    popupmenu3

    Design

  2. Mude as propriedades para o EditControl para Border = False e Read Only = True.
  3. Crie uma variável para o Edit Control chamada m_texto.
  4. Crie um menu usando Resources, veja a imagem abaixo como referencia:

    popupmenu2

    Menu

  5. No Class Wizard adicione a mensagem WM_CONTEXTMENU, use a figura abaixo como referencia:

    popupmenu

    Class Wizard

  6. Complete o código gerado automaticamente com os trechos marcados no código abaixo.

Exemplo:

Neste exemplo criamos um menu e usamos a mensagem do Windows que contém o clique do botão direito do mouse e a usamos para exibir o menu de contexto.

// Código gerado automaticamente
// PopUpCppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "PopUpCpp.h"
#include "PopUpCppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CPopUpCppDlg::CPopUpCppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CPopUpCppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CPopUpCppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT2, m_texto);
}

BEGIN_MESSAGE_MAP(CPopUpCppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_COMMAND(ID_POPUPMENU_ITEM1, &CPopUpCppDlg::OnPopupmenuItem1)
	ON_COMMAND(ID_POPUPMENU_ITEM2, &CPopUpCppDlg::OnPopupmenuItem2)
	ON_COMMAND(ID_POPUPMENU_ITEM3, &CPopUpCppDlg::OnPopupmenuItem3)
	ON_WM_CONTEXTMENU()
END_MESSAGE_MAP()

BOOL CPopUpCppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);		

	return TRUE;
}

void CPopUpCppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CPopUpCppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Nosso código começa aqui.

// Eventos dos itens do menu
void CPopUpCppDlg::OnPopupmenuItem1()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 1");
}

void CPopUpCppDlg::OnPopupmenuItem2()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 2");
}

void CPopUpCppDlg::OnPopupmenuItem3()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 3");
}

// Evento da menssagem WM_CONTEXTMENU

void CPopUpCppDlg::OnContextMenu(CWnd* pWnd, CPoint point)
{
	// Declara componentes
	CRect posicao;
	CMenu SubMenu;

	// Captura e transforma posição da tela
	GetClientRect(&posicao);
	ClientToScreen(&posicao);

	// Verifica se a posição esta no contexto escolhido
	if (posicao.PtInRect(point))
	{
		// Carrega o menu
		SubMenu.LoadMenuW(IDR_MENU1);

		// Retira o menu da barra de menus
		CMenu *pMenu = SubMenu.GetSubMenu(0);
		ASSERT(pMenu);

		// Mostra menu
		pMenu->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this);

	}
	else
	{
		CWnd::OnContextMenu(pWnd, point);
	} 

}