Desenvolvimento Código Aberto

Nós já desenvolvemos muitos aplicativos C++ Standard com saída para o console e no post anterior desenvolvemos um aplicativo C++ Visual usando diretamente a API do Windows para criar a GUI, agora vamos utilizar o método predefinido pela Microsoft para programação C++ em Windows, visto que também é possível utilizar o Framework e desenvolver aplicativos C++ usando o CLR. A seguir vamos saber mais sobre estes assuntos e sobre programação C++ para Windows.

.NET Framework

Microsoft .NET  é uma iniciativa da empresa Microsoft, que visa uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado para .NET pode ser executado em qualquer dispositivo que possua um framework de tal plataforma. Com ideia semelhante à plataforma Java, o programador deixa de escrever código para um sistema ou dispositivo específico, e passa a escrever para a plataforma .NET.

O .NET Framework é um conceito central no Visual Studio, bem como em todos os outros  produtos de desenvolvimento da Microsoft .NET.  O .NET Framework é composto de dois elementos: o Common Language Runtime (CLR ), em que o aplicativo é executado em um conjunto de bibliotecas chamado bibliotecas de classes do .NET Framework . As bibliotecas de classe Framework .NET fornecem o apoio funcional para o seu código e será necessário durante a execução do CLR , independente da linguagem de programação assim utilizada nos programas escritos em C++ , C#, ou qualquer das outras línguas que suportam o . NET Framework todos usam a mesma biblioteca .NET.

Existem dois tipos fundamentalmente diferentes de aplicativos C ++  que você pode desenvolver com o Microsoft Visual C++. Você pode escrever aplicações que executam nativamente em seu computador. Estas aplicações serão referidas a programas como C++ nativo , você escrever programas C++ nativo na versão do C++ definida pela ISO/IEC (International Standards Organization  e International Electrotechnical Commision ), este é o padrão da linguagem.

Você também pode escrever aplicativos para serem executados sob o controle do CLR em um versão estendida do C++ chamado C++/CLI. Estes programas irão ser encaminhados para programas como CLR , ou programas C++/CLI.

O NET Framework  não é estritamente parte do Visual C++, mas sim um componente do Sistema operacional Windows que torna mais fácil construir aplicações de software e serviços web.

O .NET Framework oferece vantagens substanciais em termos de viabilidade e segurança do código , bem como a capacidade de integrar o seu código C++ com código escrito em mais de 20 outras linguagens de programação que são alvo do .NET Framework. Uma ligeira desvantagem de segmentação do .NET Framework . É que não há uma penalidade de desempenho pequeno em comparação com código nativo, mas você não consegue perceber isso na maioria das circunstâncias ou seja quando você precisa de um desempenho maior é preciso usar código C++ nativo.

CLR

O Common Language Runtime (CLR) é um ambiente padronizado para a execução de programas escritos em uma ampla gama de linguagens de alto nível.

Em C++ o caderno de especificações da CLR está agora incorporada nos Fabricantes European Computer Manufacturers (ECMA) para o Common Language Infrastructure (CLI), o ECMA – 335, e também na norma ISO equivalente, ISO/IEC 23271, de modo que o CLR é uma aplicação do presente padrão.

O CLI é, essencialmente, um caderno de especificações para um ambiente de uma máquina virtual que permite que os aplicativos escrito em diversas linguagens de programação de alto nível sejam executados em sistema de diferente ambientes sem que o código fonte original seja alterado ou replicado. As especificações CLI referem se a uma linguagem intermediária padrão para a máquina virtual com uma linguagem de alto nível onde o código-fonte é compilado. Com o .NET Framework, esta linguagem intermediária é conhecida como Microsoft Intermediate Language (MSIL). Código na linguagem intermediária é finalmente mapeado para código de máquina pelo Just-in-time (JIT) quando você executa um programa. Claro que, o código na linguagem intermediária CLI pode ser executado em qualquer outro ambiente que tenha uma implementação CLI.

C++ no Windows

Você tem duas opções básicas para aplicações do Windows: Você pode escrever código que executa com o CLR, e você também pode escrever código que compila diretamente para código de máquina e, portanto, executa nativamente. Para as janelas com base aplicações que visam a CLR, você usa o Windows Forms como a base para a interface gráfica fornecida pelas bibliotecas do .NET Framework. Usando o Windows Forms permite o desenvolvimento GUI rápido, porque você monta a GUI graficamente a partir de componentes padronizados e têm o código gerado automaticamente.

Para executar nativamente o código, você tem várias maneiras de fazer este trabalho. Uma possibilidade é usar o Microsoft  Fundation Classes (MFC) para a programação da interface gráfica de usuário para a sua aplicação Windows. O MFC encapsula o Application Programming Interface (API) do sistema operacional Windows para a criação e controle da GUI e facilita muito o processo de desenvolvimento do programa.

A API do Windows se originou muito antes da linguagem C++ chegar ao sistema, por isso não tem nenhuma das características orientada a objetos que seria de esperar se fosse escrito hoje, no entanto, você está não é obrigado a usar o MFC. Se você quer um melhor em desempenho, você pode escrever seu código C++ para acessar a API do Windows diretamente.

Conceitos Windows

Um programa do Windows, se é um programa nativo  C++ ou um programa escrito para o CLR, tem uma estrutura diferente daquela do programa típico de console que executa a partir da linha de comando, e é mais complicado. Em um programa de console você pode obter a entrada do teclado e escrever saída de volta para a linha de comando diretamente, ao passo que um programa do Windows pode acessar a entrada e instalações de saída do computador, apenas a título de funções fornecidas pelo ambiente do hospedeiro, não é permitido ter acesso direto aos recursos de hardware. Porque vários programas podem estar ativos de uma só vez no Windows, o Windows determina a aplicação de uma determinada entrada cru, como um clique do mouse ou o acionamento de uma tecla no teclado, é destinado a, e sinalizar o programa em causa. Assim, o sistema operacional Windows tem controle primário de toda comunicação com o usuário.

Windows Messages

Eventos em um aplicativo do Windows são ocorrências como ao usuário clicar com o mouse ou pressionando uma tecla ou se um temporizador atingir zero. O sistema operacional Windows registra cada evento em uma mensagem e coloca a mensagem em uma fila de mensagens para o programa para o qual a mensagem se destina. Assim uma mensagem do Windows é simplesmente um registro dos dados relativos a um evento, e a fila de mensagens para uma aplicação é apenas uma sequência de tais mensagens aguardando para serem processados pela aplicação, por envio de uma mensagem, o Windows pode dizer ao seu programa de que algo precisa ser feito, ou que algum informação tornou-se disponível, ou que um evento como um clique do mouse ocorreu. Se o seu programa está devidamente organizado, ele vai responder de forma adequada à mensagem. Tem muitos tipos diferentes de mensagens e eles podem ocorrer com muita frequência, muitas vezes até por segundo quando o mouse está sendo arrastado, por exemplo.

Um programa do Windows deve conter uma função especificamente para lidar com essas mensagens. a função é muitas vezes chamada WndProc () ou WindowProc (), embora ele não  tenha um nome específico porque o Windows acessa a função através de um ponteiro para uma função que você forneceu.

Você passa uma mensagem de volta para o Windows chamando uma função padrão fornecido pelo Windows chamada DefWindowProc (), o que proporciona o processamento de mensagem padrão.

Windows API

Todas as comunicações entre qualquer aplicativo do Windows e o próprio Windows usam o Windows Application Programming Interface, também conhecido como a API do Windows. Isto consiste em, literalmente, centenas de funções que são fornecidos como padrão com o sistema operacional Windows que fornece os meios pelos quais um aplicativo se comunica com o Windows, e vice-versa. A API do Windows foi desenvolvida nos dias em que C foi a principal língua em uso, muito antes do advento do C++, e, por esta razão, as estruturas, em vez de classes são frequentemente utilizadas para a passagem de alguns tipos de dados entre o Windows e o seu programa aplicativo.

A API do Windows abrange todos os aspectos das comunicações entre o Windows e a sua aplicação. Porque há um número tão grande de funções na API, utilizando-as na mão pode ser uma tarefa muito difícil.

Tipos de Dados Windows

O Windows define um número significativo de tipos de dados que são usados para especificar parâmetro de função, tipos e tipos de retorno na API do Windows. Estes tipos específicos do Windows também se propagam através de funções que são definida em MFC.

MICROSOFT FOUNDATION CLASSES

O Microsoft Foundation Classes (MFC) é um conjunto de classes predefinidas sobre a qual a programação Windows com Visual C++ é construída. Estas classes representam uma abordagem orientada a objeto para programação Windows que encapsula a API do Windows. O MFC não cumpri rigorosamente os princípios de orientação a objeto e de encapsulamento e ocultamento de dados, principalmente porque grande parte do código MFC foi escrito antes de tais princípios serem bem estabelecidos.

O processo de escrever um programa do Windows envolve a criação e uso de objetos MFC ou objetos de classes derivadas do MFC. No principal, você vai derivar suas próprias classes de MFC, com assistência considerável a partir das ferramentas especializadas em Visual C++ que tornam este trabalho muito mais fácil.

Como Criar uma Aplicação MFC

O MFC Application utiliza o método da Microsoft de Design Time, o “Design First, Code Later”, o que significa que você desenvolve o design da tela usando a IDE do Visual Studio, colocando os componentes diretamente da ToolBox no Form e pode manipular as propriedades e eventos dos componentes utilizando a janela Properties. Para nossa aplicação MFC utilize a imagem abaixo como referencia de design.

Visual Studio

1. No menu Files escolha New Project.
2. Na Lista de projetos C++ escolha MFC Application.
3. Nomeie o projeto para: Concatenador e clique em OK.
4. No Wizard clique em Next.
5. Na pagina Application Type escolha: Dialog Based e clique em Finish.
6. A IDE abre no modo Design Time, que possibilita você arrastar componentes da ToolBox para o Form aberto.
7. Apague os componentes default do form, que são um Static Text e dois Buttons.
8. Selecione na ToolBox e coloque no Form os seguintes componentes:
9. Um componente Static Text.
10. Três componentes Edit Control.
11. Um componente Button e mude o seu texto para: Somar.
12. Monte a disposição na tela de acordo com a figura acima.
13. Clique com o botao direito do mouse em cima do primeiro componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: texto1 e clique em Finish.
14. Clique com o botao direito do mouse em cima do segundo componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: texto2 e clique em Finish.
15. Clique com o botao direito do mouse em cima do componente Button e escolha ADD Variable, no Wizard em variable name coloque o nome: botao e clique em Finish.
16. Clique com o botao direito do mouse em cima do terceiro componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: resultado e clique em Finish.
17. Ainda no terceito Edit Control na janela de propriedades, mude Read Only para True.
18. Clique com o botão direito em cima do componente Button e escolha: Add Event Handler, no Wizard em Message Type selecione BN_CLICKED clique em Add and EDIT.
19. Neste momento uma nova unidade de codigo fonte é aberta com o evento escolhido, preencha a void do evento igual ao codigo abaixo.

Exemplo:

Neste exemplo criamos um programa visual em C++ utilizando MFC que concatena duas String, como usamos o conceito de “Design First e Code Later” da Microsoft você precisa apenas copiar o conteúdo da ultima void do código, todo o resto é gerado automaticamente.

C++

// Código Gerado automaticamente - MFC - Visual Studio 2013 - Ultimate
// Vá para o final do código
// Nossa implementação se trata apenas da ultima void

// ConcatenadorDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Concatenador.h"
#include "ConcatenadorDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CAboutDlg dialog used for App About

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// Dialog Data
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}

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

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

// CConcatenadorDlg dialog

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

void CConcatenadorDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT1, texto1);
	DDX_Control(pDX, IDC_EDIT2, texto2);
	DDX_Control(pDX, IDC_BUTTON1, botao);
	DDX_Control(pDX, IDC_EDIT3, resultado);
}

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

// CConcatenadorDlg message handlers

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

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// TODO: Add extra initialization here

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CConcatenadorDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CConcatenadorDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

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

		// Center icon in client rectangle
		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;

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

// The system calls this function to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CConcatenadorDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

/*
*********************
** Evento do Botão **
*********************
*/

// Evento do Botão
void CConcatenadorDlg::OnBnClickedButton1()
{
	// TODO: Add your control notification handler code here

	// Copie este codigo

	CString _texto1;
	CString _texto2;
	CString concatena;

	texto1.GetWindowTextW(_texto1);
	texto2.GetWindowTextW(_texto2);

	concatena = _texto1 + _texto2;

	resultado.SetWindowText(concatena);
}

Você pode criar um aplicativo Win32 quando você quer fazer um aplicativo de desktop nativo que tem uma interface de usuário baseada em janelas e pode ser executado em versões do Windows a partir do Windows 95 para o Windows 8.1. Você pode usar qualquer uma das edições do Visual Studio, exceto a versão Express.

Um aplicativo Win32 é o termo convencional para um aplicativo que usa a mensagem de loops para lidar com  as mensagens do Windows diretamente em vez de usar um quadro como o Microsoft Foundation Classes (MFC), o Active Template Library (ATL), ou o .NET Framework..

Conceito Win32

Embora o termo é “Win32“, pode se referir a qualquer aplicativo de 32 bits ou um aplicativo de 64 bits. Um aplicativo Win32 em C ++ pode usar C Runtime (CRT) e Standard Template Library (STL), classes, funções, objetos COM, e qualquer uma das funções públicas do Windows, que coletivamente são conhecidas como a API do Windows.

Usando a API do Windows

Em nosso artigo de introdução ao visual C++ explicamos os conceitos básico da programação para Windows, neste post mostramos como isto é feito na pratica.

Basicamente uma aplicação para Windows onde não se utiliza nenhum método da Microsoft (Framework ou biblioteca de classes), além de suas APIs, podemos afirmar que um programa mínimo para o Windows que pode rodar em qualquer versão do sistema operacional é composto basicamente de duas funções, a primeira WinMain é responsável por criar uma aplicação de janelas e a segunda função chamada WndProc é responsável pelas mensagens do Windows. Existem muitas outras funções mas trabalhar com elas exigem um nível avançado de conhecimento em programação e da arquitetura do sistema operacional, veremos aos poucos os conceitos de arquitetura, tipos de variáveis e  regras básicas para utilizar as APIs do Windows.

Visual Studio

Para criar um programa Visual em C++ siga os passos abaixo:

1. No menu File, clique em New, Project.
2. Na caixa de dialogo para projetos C++, escolha Win32 Project.
3. Nomeie o projeto de Hellocpp.
4. No wizard de boas vindas, clique em Next.
5. Na janela de parâmetros clique em Empty Project e clique no botão Finish.
6. No Solution Explorer, clique com o botão direito em cima do nome do seu projeto e escolha: Add, New Item.
7. Escolha um arquivo .cpp e o nomeie para hello.cpp.

Exemplo:

Neste exemplo criamos uma janela visual em mensagem de loops. Você pode usar o este código como um padrão para criar outros aplicativos baseados em Win32.

C++

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>

// Variaveis globais

// Classe da janela principal.
static TCHAR szWindowClass[] = _T("win32app");

// String que aparece na barra de titulos
static TCHAR szTitle[] = _T("Win32 Guided Tour Application");

HINSTANCE hInst;

// Declarações de funções incluidas neste modulo:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nCmdShow)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);
	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
	wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = NULL;
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_APPLICATION));

	if (!RegisterClassEx(&wcex))
	{
		MessageBox(NULL,
			_T("Call to RegisterClassEx failed!"),
			_T("Win32 Guided Tour"),
			NULL);

		return 1;
	}

	hInst = hInstance; // Guarda a instancia e manipula a variavel local.

	// Parametros para criar a janela
	// szWindowClass: nome da aplicação
	// szTitle: texto da barra de titulos
	// WS_OVERLAPPEDWINDOW: tipo da janela
	// CW_USEDEFAULT, CW_USEDEFAULT: posição inicial (x, y)
	// 500, 300: tamanho inicial (width, length)
	// NULL: parent desta janela
	// NULL: esta aplicação não tem uma barra de menu
	// hInstance: o primeiro parametro da WinMain
	// NULL: não é usado nesta aplicação

	HWND hWnd = CreateWindow(
		szWindowClass,
		szTitle,
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT,
		500, 300,
		NULL,
		NULL,
		hInstance,
		NULL
		);

	if (!hWnd)
	{
		MessageBox(NULL,
			_T("Call to CreateWindow failed!"),
			_T("Win32 Guided Tour"),
			NULL);

		return 1;
	}

	// Parametros do ShowWindow :
	// hWnd: valor retornado do CreateWindow
	// nCmdShow: o quarto parametro do WinMain

	ShowWindow(hWnd,
		nCmdShow);
	UpdateWindow(hWnd);

	// Menssagem principal do loop:
	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return (int)msg.wParam;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processa menssagem para a janela principal
//
//  WM_PAINT    - pinta a janela principal
//  WM_DESTROY  - posta e cancela menssagem e retorna
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	PAINTSTRUCT ps;
	HDC hdc;
	TCHAR greeting[] = _T("Hello, World!");

	switch (message)
	{
	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);

		//Aqui sua aplicação é criada.
		// Para esta introdução nos só imprimiremos, "Hello, World!"
		// no canto esquerdo superior da janela.
		TextOut(hdc,
			5, 5,
			greeting, _tcslen(greeting));
		// fim da aplicação de layout.

		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
		break;
	}

	return 0;
}