Desenvolvimento Código Aberto

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 – 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

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

   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();
}