C++ – Criando janelas usando apenas código

Em outro tutorial mostrei como criar janelas usando Visual C++, da Microsoft, uma forma muito fácil, mas se o leitor não gosta do estilo do Visual C++ e nem das extensões que foram incorporadas ao C++ nesse compilador, é possível criar janelas em C++ puro. Vou usar o Dev C++, um compilador bem simples para exemplificar a criação de uma janela feita “a mão” em C++, pode baixá-lo aqui. Precisará de um pouco de conhecimento em C++ e Windows, e vamos criar uma aplicação que calcula a hipotenusa a partir dos catetos! Inicie um novo projeto clicando no botão azul onde está escrito DEV, localizado no canto superior esquerdo da janela. No diálogo que será iniciado, digite um nome para o projeto e clique em Windows Application. Um código deve ter sido criado. Delete esse código, vamos começar a criação da janela passo-a-passo. Agora cole esse:

// Cabeçalhos necessários
#include <windows.h>
#include <stdlib.h>

LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

// WinMain, a função main em janelas
int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)
{

HWND hwnd;      // O objeto para indicar a janela
MSG messages;   // Objeto mensagem do Windows para controlar o acionamento de botões
WNDCLASSEX wincl;   // O objeto para criar a janela

wincl.hInstance = hThisInstance;
wincl.lpszClassName = “WindowsAppl”; // Nome da classe da janela
wincl.lpfnWndProc = WindowProcedure;
wincl.style = CS_DBLCLKS;
wincl.cbSize = sizeof (WNDCLASSEX);
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);      // Janela com icone default do Windows
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);          //Cursor default
wincl.lpszMenuName = NULL;
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;       // Cor cinza de background

if (!RegisterClassEx (&wincl))  // Se o registro da classe foi mal-sucedido return 0
return 0;

hwnd = CreateWindowEx (               // Criação da janela
0,
“WindowsAppl”,                 // Indicação da classe da janela
“Hello World”,                 // Nome da janela
WS_OVERLAPPEDWINDOW,           // Estilo da janela
350,                               // x em relação ao desktop
250,                                 // y em relação ao desktop
300,                                  // largura da janela
300,                               // altura da janela
HWND_DESKTOP,
NULL,
hThisInstance,
NULL
);

ShowWindow (hwnd, nFunsterStil);                // Mostrar a janela

while (GetMessage (&messages, NULL, 0, 0)) // Recuperar mensagens
{
TranslateMessage(&messages);
DispatchMessage(&messages);
}

return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE: // Criação da janela
break;
case WM_COMMAND:   // Interpretação da janela
break;
case WM_DESTROY:   // Destruição da janela
PostQuitMessage (0);
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}

O cabeçalho #include<windows.h> é obrigatório em qualquer aplicação que use janelas no Windows. O outro cabeçalho(stdlib.h) contém a biblioteca de funções do Windows e C++. Depois iniciamos uma Procedure do Windows e a função WinMain, que configura, cria e deixa visível a janela. Dentro dessa função precisamos definir uma variável HWND para a janela, uma variável MSG para armazenar as ações do usuário e da janela e uma variável WNDCLASSEX para configurar e criar a janela. A seguir podemos ver a variável wincl que definimos anteriormente chmando variáveis de configuração. Entre elas, podemos ver algumas importantes como lpszClassName, que define o nome da classe da janela, as outras importantes se tiver interesse pode ver nos comentários do código. Depois verificamos se a classe foi registrada com sucesso e criamos a janela com a função CreateWindowEx, pode ver os parâmetros importantes dessa função nos comentários. Depois mostramos a janela, recuperamos a variável messages determinada anteriormente, e agora uma parte importantíssima, que é a definição do WindowProcedure, a função chamada quando o usuário interage com a janela. Dentro da WindowProcedure temos um switch, e quando a condição é WM_CREATE a janela é criada, quando a condição é WM_COMMAND é porque o usuário interagiu com um componente da janela, e quando é WM_DESTROY é porque a janela foi destruída! A única dessas condições com algo além de break por enquanto é a WM_DESTROY, em que chamamos a função PostQuitMessage para destruir a janela. Aperte f9 para compilar. Isso é o que deve aparecer:

COLOCANDO OS COMPONENTES

Criamos uma janela vazia. Agora é hora de colocar os componentes!  Precisaremos de dois Textbox para a entrada dos valores dos catetos, um botão para acionar, duas labels para indicar os campos do cateto a e cateto b, e após o cálculo ser completado, disparar uma MessageBox com o resultado. Cole esse código acima da função WindowProcedure:

#define BUTTONOK 10

HINSTANCE g_inst;
HWND Cateto1, Cateto2, ButtonOk;

void DrawComponents(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {

CreateWindowEx (
0,
“STATIC”,
“Cateto a”,
WS_VISIBLE|WS_CHILD,
30, 20, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);
Cateto1 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 50, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

CreateWindowEx (
0,
“STATIC”,
“Cateto b”,
WS_VISIBLE|WS_CHILD,
30, 80, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);

Cateto2 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 110, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

ButtonOk = CreateWindowEx (
0,
“BUTTON”,
“Ok”,
WS_VISIBLE|WS_CHILD,
40, 140, 20, 20,
hwnd,
(HMENU)BUTTONOK,
g_inst,
NULL
);

}

Dentro da função WindowProcedure e do switch, chame essa função que acabamos de criar desse modo dentro do WM_CREATE:

DrawComponents(hwnd,message,wParam,lParam);

Com esse código criamos uma função para desenhar os componentes na janela, e podemos ver a função CreateWindowEx ser chamada, mas dessa vez, com parâmetros diferentes. Os parâmetros mais importantes são: o segundo(tipo do componente), o terceiro(texto do componente), o quarto(Definição de que o componente será visível e filho da janela), o quinto(distância da esquerda), sexto(distância do topo), sétimo(largura do componente), e oitavo(altura do componente). Podemos também ver a declaração de algumas variáveis HWND, que guardarão os dados das Textbox e do botão, para sabermos seus valores e se foram acionados. O botão precisa excepcionalmente de um ID, criado com #define anteriormente. Finalmente chamamos a função que criamos e informamos os parâmetros definimos na função WinMain. Aperte f9 e deverá ver isso:

CRIANDO A LÓGICA DA APLICAÇÃO

Agora que já criamos todos os componentes, devemos calcular a hipotenusa. Inclua no seu programa o cabeçalho math.h para podermos calcular a raiz quadrada. Agora copie esse código para dentro do WM_COMMAND no switch do WindowProcedure.

if ((HIWORD(wParam) == BN_CLICKED))
{

SendMessage(
(HWND) Cateto1,
(UINT) EM_GETLINE,
(WPARAM) 1,
(LPARAM) &Cat1
);

SendMessage((HWND)Cateto2,(UINT)EM_GETLINE,(WPARAM)1,(LPARAM) &Cat2);

CatetoA = atoi(Cat1);
CatetoB = atoi(Cat2);
int Hipotenusa_quadrado = CatetoA*CatetoA + CatetoB*CatetoB;
hipotenusa = sqrt(Hipotenusa_quadrado);

itoa (hipotenusa,Hipot,10);

MessageBox (NULL, Hipot, “Resultado”, MB_OK);
}

Antes da função WindowProcedure também copie essas variáveis:

char Cat1[20] = “0”, Cat2[20] = “0”, Hipot[20] = “0”;
int CatetoA, CatetoB, hipotenusa;

Neste código colocamos uma condição if(HIWORD == BN_CLICKED) para determinar se o botão foi clicado. Se foi o código abaixo do if será executado. Com a função SendMessage nós recuperamos o texto digitado nas duas textBox e iniciamos duas variáveis String determinadas anteriormente com o seu valor. Depois fazemos uma conversão de String para int coma  função atoi e finalmente calculamos a hipotenusa! Mas ainda não acabou. Precisamos converter de int para String para podermos mostrar o resultado em uma MessageBox. Agora sim! Abaixo seguem a imagem do programa em ação e o link para download do código:

Download Source

CONCLUSÃO

O que levaria cinco linhas de código para fazer no Visual C++ levou mais de 100 no Dev C++. Programar janelas em C++ sem usar facilitadores como os do Visual C++ gasta muito mais tempo, mas em compensação é mais flexível e deixa o programa mais rápido. Recomendo programar assim apenas programas que realmente necessitem desse tipo de programação.

Programando para Android

O Android, sistema operacional open-source desenvolvido pelo Google para smartphones, vem dominando o mercado, e dentro de algum tempo talvez seja até expandido para rodar em netbooks. A linguagem usada para desenvolver aplicaçoes Android é java, e neste tutorial ensinarei como configurar as IDEs Eclipse e Netbeans usando Windows.

INSTALAÇÃO DA SDK

1. Primeiramente, baixe a SDK do Android aqui.

2. Extraia o arquivo para algum diretório no seu computador, geralmente esse diretório leva esse nome: android-sdk-<release>-<build>.

CRIAÇÃO DE UMA AVD

AVD significa Android Virtual Device, ou seja, o dispositivo móvel que será emulado no seu computador. Antes de começarmos, deve ser configurada uma variável no seu ambiente de trabalho para podermos usar recursos do Android na linha de comando. Pode parecer assustador para quem nunca fez isso, mas é muito fácil.

Clique com o botão direito em Computador -> Propriedades -> Avançado -> Variáveis do Ambiente

Nas variáveis do sistema, haverá uma chamada Path. Clique nessa variável e depois em Editar, e acrescente no final da variável esse caminho <SDK_ANDROID>\tools\.

Agora temos tudo pronto para escolher a AVD. Vá ao prompt de comando do Windows e digite: android list targets. Se tudo ocorreu bem, ele listará no prompt os diferentes tipos de sistema(Android 1.1, Android 1.5 e Google APIs). Estarei usando Android 1.1 neste tutorial. Depois que decidir qual avd usar, digite esse comando para cria-la: android create avd -n <Nome_da_avd> -t <Sistema_da_avd>. Exemplo:

android create avd -n T-Mobile -t 1

A AVD está criada!

O EMULADOR ANDROID

O Emulador Android é o arquivo: <ANDROID_SDK>\tools\emulator.exe. Se voce tentar executa-lo sem definir uma avd, ele apenas lançará uma mensagem de erro num prompt, este que desaparecera rapidamente. Para iniciar o emulador com sucesso, abra o prompt de comando, digite <ANDROID_SDK>\tools\emulator.exe -avd <Nome da sua avd>. Exemplo:

C:\android-sdk-windows-1.5_r3\tools\emulator.exe -avd T-Mobile

O emulador pode demorar um pouco para ser iniciado, por isso é bom deixá-lo sempre aberto. O que você verá quando o emulador terminar de carregar será isso:

CRIANDO APLICAÇÕES USANDO ECLIPSE

Criar aplicações Android usando Eclipse é muito fácil, graças a um plugin oferecido pelo Google, o ADT, ou Android Development Kit. Baixe o Eclipse desse site: http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/R/eclipse-java-galileo-win32.zip

Extraia o arquivo para qualquer pasta, e execute o arquivo eclipse.exe. Espere a IDE carregar e vá em Help -> Install New Software. Na janela que se segue, digite esse endereço em Work With: https://dl-ssl.google.com/android/eclipse/site.xml

Deverá aparecer logo abaixo o Developer Tools, marque a checkbox e clique em Next. Alguns cliques mais e tudo deverá estar instalado.

Agora falta especificar o caminho da SDK Android. Vá em Window -> Preferences -> Android e especifique o caminho da SDK em SDK Location. Agora já está tudo pronto para começarmos a programar. Vá em FIle -> New -> Project -> Android Project. Digite algum nome, selecione Android 1.1, e preencha os outros campos(O nome do pacote deverá ter pelo menos um pontos). O projeto será criado, e o que nos interessa é o arquivo Nome_da_sua_aplicação.java na pasta src. No final do método onCreate(bundle) acrescente a linha:

setContentView(R.layout.main);

Essa linha mostrará uma string do arquivo main.xml na tela do aplicativo. Para correr sua aplicação apenas clique em Run e selecione Android Application(o emulador deve estar aberto). Você deverá ver uma tela preta no emulador com a mensagem: Hello World, Nome_da_sua_aplicação. Agora você já pode criar aplicações simples para Android no Eclipse!

DESENVOLVENDO COM NETBEANS

Configurar e desenvolver com a IDE Netbeans é um pouco mais complicado, mas nada impossível. Também existe um plugin para Netbeans, o nbandroid. Eu estou usando o Netbeans 6.5.1, o processo pode ser levemente diferente em outras versões. Vá em Tools -> Plugins. Na janela Plugins, vá até a aba Settings e aperte o botão Add, e na janela que aparecerá preencha o campo URL com http://kenai.com/downloads/nbandroid/updates.xml e preencha o campo name com nbandroid. Vá para a aba Available Plugins e procure por Android, marque a caixa de texto do plugin achado e instale, não se assuste se receber um aviso durante a instalação sobre unsigned plugins.

Depois de instalado o plugin, você terá que adicionar a plataforma Android indo em Tools -> Java Platforms -> Add Platform. Selecione Google Android Open Handheld Platform e coloque o nome Android e a localização da sua SDK na próxima janela. Já está tudo pronto para começar a programar com Netbeans! Crie um projeto e selecione na categoria Android -> Android Application. Você já deve ver um arquivo java. Nesse arquivo, acrescente no final do método onCreate a linha:

setContentView(R.layout.main);

Isso fará o programa mostrar uma mensagem na tela do emulador. Para rodar a aplicação, aperte f6 e selecione a avd na qual quer testar a aplicação(já deve estar iniciada). O que verá será isso:

CONCLUSÕES

A plataforma Androide bastante flexível, e utiliza uma linguagem muito boa para programação móvel, na minha opinião é melhor do que todas as outras plataformas móveis pagas do mercado. Se for adotado como padrão para celulares, o preço dos aparelhos pode baixar e pode ser eliminada a incompatibilidade entre os aparelhos, mas sem um visual repetitivo em todos os aparelhos, já que seu código pode ser customizada e o tema mudado para melhor se parecer com o aparelho. Agora quero saber o que vocês acham! Se quiserem que eu acrescente algo mais no tutorial eu atenderei prontamente!