Aula 05 Interface gráfica

Prévia do material em texto

Projeto de Interface Gráfica
Introdução
************************************************** *****
Ao aprender C/C++, geralmente, se aprende a deselvolver programas no console certo? Se por acaso, tivéssimos que desenvolver um programa onde existam caixas de textos, botões, listas de itens, etc? É nesta parte que entra a GUI - Graphical User Interface ou Interface Grífica do Usírio, ou simplesmente "interface grífica" - uma tecnologia utilizada em sistemas operacionais para aplicar ao software, àcones, gríficos, controle por mouse, dentre outros, com o objetivo de fazer com que o usuírio interaja com o tal software.
Neste tutorial, demonstrarei os principais fundamentos, exemplos da programação GUI em ambiente WIN32.
1) Crie um novo arquivo : "main.cpp"
2) Adicione o seguinte código ao arquivo criado (utilize o copiar e colar, salve e rode o programa com F9).
3) Durante a execução aparecerá a tela do MS-DOS(tela preta), mas também a janela de interface gráfica.
#include <windows.h>
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
 LPSTR lpCmdLine, int nCmdShow)
{
 MessageBox(NULL, "CHEGA DE HELL WORLD!", "MENSAGEM", MB_OK);
 return 0;
}
Vamos analisar:
#include <windows.h>
Todo programa WINDOWS deve incluir este header.
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
Esta função é a equivalente do Windows, para a função main() do console.
WINAPI -> Indica que que a chamada é definida como "_stdcall".
Seus argumentos:
HINSTANCE hInstance -> Handle (identificação) do programa no sistema. É por este valor que se controla quando um aplicativo estí executando ou é encerrado. É usado para carregar recursos como àcones, ou DLLS.
HINSTANCE hPrevInstance -> É um valor sempre nulo nos programa WIN32.Em win32, é ignorado.
LPSTR lpCmdLine -> Retorna a linha de comando, como uma string (LPSTR = char*), não incluindo o nome do executível
.
int nCmdShow -> Retorna o estado inicial da janela, para mudí-lo, utilizamos a função SHOW_WINDOW.
MessageBox(NULL, "CHEGA DE HELL WORLD!", "MENSAGEM", MB_OK); 
É uma função da API, responsível por exibir uma mensagem, para mais informações, consulte o tópico sobre API do Windows:
return 0; -> Fim do programa
1) Crie um novo arquivo : “primeiraJanela.cpp"
2) Adicione o seguinte código ao arquivo criado (utilize o copiar e colar, salve e rode o programa com F9).
3) Durante a execução aparecerá a tela do MS-DOS(tela preta), mas também a janela de interface gráfica.
#include <windows.h>
LRESULT CALLBACK WinProc(HWND window,UINT msg,WPARAM wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
 LPSTR lpCmdLine, int nCmdShow)
{
HWND hwnd;
WNDCLASSEX win;
MSG message;
win.cbClsExtra=0;
win.cbSize=sizeof(win);
win.cbWndExtra=0;
win.hbrBackground=GetSysColorBrush(COLOR_WINDOW);
win.hCursor=LoadCursor(NULL,IDC_ARROW);
win.hIcon=LoadIcon(NULL,IDI_APPLICATION);
win.hIconSm=LoadIcon(NULL,IDI_APPLICATION);
win.hInstance=hInstance;
win.lpfnWndProc=WinProc;
win.lpszClassName="Janela";
win.lpszMenuName=NULL;
win.style=0;
if(!RegisterClassEx(&win))
return 0;
hwnd = CreateWindowEx(0,"Janela","Minha janelinha",WS_OVERLAPPED|WS_SYSMENU,300,100,400,400,NULL,NULL,hInstance,NULL);
if(hwnd == NULL)
return 0;
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
while(GetMessage(&message,0,0,0)){
 TranslateMessage(&message);
DispatchMessage(&message);
}
return message.wParam;
}
LRESULT CALLBACK WinProc(HWND window,UINT msg,WPARAM wParam,LPARAM lParam){
switch(msg)
 {
 case WM_CLOSE:
 DestroyWindow(window);
 break;
 case WM_DESTROY:
 PostQuitMessage(0);
 break;
 default:
 return DefWindowProc(window, msg, wParam, lParam);
}
	return 0;
}
WNDCLASSEX win; -> Declara variível para a classe da janela
win.cbClsExtra=0; -> Quantidade extra de dados alocados na meória pela classe
win.cbSize=sizeof(win); -> Tamanho da estrutura
win.cbWndExtra=0; -> Quantidade extra de dados alocados na meória pela classe por cada janela do tipo especifidado.
win.hbrBackground=GetSysColorBrush(COLOR_WINDOW); -> Cor de fundo da janela
win.hCursor=LoadCursor(NULL,IDC_ARROW); -> Ponteiro do mouse
win.hIcon=LoadIcon(NULL,IDI_APPLICATION); -> O àcone da janela
win.hIconSm=LoadIcon(NULL,IDI_APPLICATION); -> Ícone da janela quando é pressionado ALT+TAB.
win.hInstance=hInstance; -> Instância da janela, o mesmo valor declarado em WinMain.
win.lpfnWndProc=WinProc; -> Função que irí receber as mensagens enviadas à nossa janela. Esta é a função que controla os eventos, como cliques, movimento de mouse, etc.
win.lpszClassName="Janela"; -> Nome da classe da janela
win.lpszMenuName=NULL; ->Especifica o nome de do menu a ser utilizado na janela.
win.style=0; -> Especifica o tipo inicial da janela.
if(!RegisterClassEx(&win)) -> Registra nossa classe, caso ocorra um erro, o programa encerra.
return 0;
2 Passo - Criando a janela;
*************************************************
hwnd = CreateWindowEx(0,"Janela","Minha janelinha",
WS_OVERLAPPED|WS_SYSMENU,300,100,400,400,
NULL,NULL,hInstance,NULL);
Analisando:
Janela = nome da classe
Minha Janelinha = tàtulo da janela
WS_OVERLAPPED = estilo da janela - Fixa
WS_SYSMENU = janela com os botões superiores
300 = posição horizontal (left)
100 = posição vertical (top)
400 = largura da janela
400 = altura da janela
NULL = HWND pai
NULL = O menu criado para janela
Hinstace = instância -> WinMain
NULL = Representa um valor lParam -> caiu em desuso.
if(hwnd == NULL) -> Verifica se a janela foi criada, senão, encerra.
return 0;
ShowWindow(hwnd,SW_SHOW); -> Mostra a janela.
UpdateWindow(hwnd); -> Atualiza-a.
3 Passo - LOOP de Mensagens;
*************************************************
Os programas WIN32, executam enquanto estiverem recebendo "mensagens", que por sua vez, são interpretadas e "filtradas", executando uma certa ação.
O processo é feito pela seguinte trecho:
while(GetMessage(&message,0,0,0)){ -> Enquanto estiver recebendo mensagens..
TranslateMessage(&message); -> "Traduz" a mensagem, para que possar ser lida.
DispatchMessage(&message); -> Envia a menssagem para a função que irí interpretí-la.
}
return message.wParam; -> Retorna um valo, quando o loop é interrompido.
4 Passo - WinProc
*************************************************
Esta função, como jí foi dito, recebe as mensagens enviadas pelo programa e executa uma determinada ação para cada tipo.
LRESULT CALLBACK WinProc(HWND window,UINT msg,WPARAM wParam,LPARAM lParam){
switch(msg)
{
case WM_CLOSE:
DestroyWindow(window);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(window, msg, wParam, lParam); -> Retorna mensagens não geradas para o WinProc.
}
return 0;
}
window - hwnd da nossa janela.
msg - mensagem recebida
WPARAM - parâmetro 1 da mensagem
LPARAM - parâmetro 2 da mensagem
Algumas Constantes, Estilos de Janelas, Cursores e Mensagem
************************************************** ******
Até agora demonstrei valores utilizados no exemplo inicial, listarei agora, outros valores que você podería utilizar.
Estilos de Janela:
Código:
WS_BORDER -> Borda fina
WS_CAPTION -> Barra de tàtulo e borda fina
WS_CHILD/WS_CHILDWINDOW -> Janela filha
WS_DISABLED -> Desabilitada
WS_DLGFRAME -> Borda usada em dialogs.
WS_HSCROLL/WS_VSCROLL -> Adiciona barra de rolagem horizontal(HSCROLL) e vertical(VSCROLL)
WS_MAXIMIZE -> Janela maximizada
WS_MAXIMIZEBOX /WS_MINIMIZEBOX -> Botões maximizar e minimizar
WS_MINIMIZE -> Janela minimizada
WS_OVERLAPPED -> Borda fixa e barra de tàtulo
WS_OVERLAPPEDWINDOW -> Padrão
WS_POPUP -> Janela POPUP
WS_SIZEBOX -> Janela que pode ser redimensionada
WS_SYSMENU -> Define a janela com o menu comum.
WS_TABSTOP -> Define o possàvel recebimento de focus,pela tecla TAB
WS_VISIBLE -> Janela iniciamente visàvel
Cursores:
Código:
IDC_ARROW -> Padrão
IDC_CROSS -> Cruz
IDC_IBEAM -> Cursor editando
IDC_ICON -> Ícone
IDC_NO -> Sem cursor
IDC_SIZE -> Redimesionar
IDC_SIZEALL -> Mover/Redimesionar
IDC_SIZENESW -> Redimensionar
IDC_SIZENS -> Redimensionar
IDC_SIZENWSE -> Redimensionar
IDC_SIZEWE -> Redimensionar
IDC_UPARROW -> Seta para cima
IDC_WAIT -> Ocupado
ÍCONES:
Código:
IDI_APPLICATION -> Padrão
IDI_ASTERISK -> Informação
IDI_EXCLAMATION -> Exclamação
IDI_HAND ->HiperLink
IDI_QUESTION -> Ajuda
IDI_WINLOGO -> Logon
CORES:
Código:
COLOR_ACTIVEBORDER
COLOR_ACTIVECAPTION
COLOR_APPWORKSPACE
COLOR_BACKGROUND
COLOR_BTNFACE
COLOR_BTNSHADOW
COLOR_BTNTEXT
COLOR_CAPTIONTEXT
COLOR_GRAYTEXT
COLOR_HIGHLIGHT
COLOR_HIGHLIGHTTEXT
COLOR_INACTIVEBORDER
COLOR_INACTIVECAPTION
COLOR_MENU
COLOR_MENUTEXT
COLOR_SCROLLBAR
COLOR_WINDOW
COLOR_WINDOWFRAME
COLOR_WINDOWTEXT
Mensagens:
Código:
WM_ACTIVATE -> Recebe focus
WM_CLOSE -> Fechar janela
WM_COPY -> Copiar
WM_CREATE -> Criação da janel
WM_CUT -> Recortar
WM_DESTROY -> Sair
WM_ENABLE -> Torna habilitade
WM_KEYDOWN -> Tecla pressionada
WM_LBUTTONDNLCLK -> Botão Esquerdo - 2 cliques
WM_LBUTTONDOWN -> Botão Esquerdo - 1 clique
WM_MBUTTONDBLCLK -> Botão Central - 2 clqiues
WM_MBUTTONDOWN -> Botão Central - 1 clique
WM_MOUSEMOVE -> Movimento do mouse
WM_MOUSEWHEEL -> Rodinha do mouse
WM_MOVE -> Movimento da janela
WM_PAINT -> Implementação dos objetos na janela 
WM_PASTE -> Colar
WM_QUIT -> Sair
WM_RBUTTONDNLCLK -> Botão Direito - 2 Cliques
WM_RBUTTONDOWN -> Botão Direito - 1 Clique
WM_SETFOCUS -> Recebe focus
WM_SIZE -> Janela Redimensionada
1) Crie um novo arquivo : “primeiroButton.cpp"
2) Adicione o seguinte código ao arquivo criado (utilize o copiar e colar, salve e rode o programa com F9).
3) Durante a execução aparecerá a tela do MS-DOS(tela preta), mas também a janela de interface gráfica.
#include <windows.h>
//Definimos um nome para os controles
#define t_1 1
#define r_1 2
#define r_2 3
//HWND dos controles
HWND txt;
HWND radio1,radio2;
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM 
wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
MSG message;
HWND hwnd;
WNDCLASSEX wc;
wc.cbClsExtra=0;
wc.cbSize=sizeof(wc);
wc.cbWndExtra=0;
wc.hbrBackground=GetSysColorBrush(COLOR_BTNFACE);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
wc.hIconSm=LoadIcon(NULL,IDI_APPLICATION);
wc.lpfnWndProc=WinProc;
wc.lpszClassName="Janela";
wc.lpszMenuName=NULL;
wc.style=0;
RegisterClassEx(&wc);
hwnd = CreateWindowEx(0,"Janela","EXEMPLO 1",WS_OVERLAPPED|WS_SYSMENU,200,200,400,120,NULL,NULL,NULL,NULL);
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
while(GetMessage(&message,0,0,0)){
	TranslateMessage(&message);
	DispatchMessage(&message);
}
return message.wParam ;
}
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam){
switch(msg)
{
case WM_CLOSE:
	PostQuitMessage(0);
	break;
case WM_CREATE: //No processo de criação da janela
txt = CreateWindowEx(0,"EDIT","" ,WS_CHILD|WS_VISIBLE|WS_BORDER,10,10,370,20,window,(HMENU)t_1,0,0); //Cria nosso textbox
radio1 = CreateWindowEx(0,"BUTTON","Obter nome do usuírio",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,10,50,240,15,window,(HMENU)r_1,0,0); //Cria o primeiro radiobutton
radio2 = CreateWindowEx(0,"BUTTON","Sair do programa" ,WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,240,50,240,15,window,(HMENU)r_2,0,0); //Cria o segundo
break;
case WM_COMMAND: //Mensagem enviada quando se clica em um controle
	switch(wParam) //Verifica o parâmetro
	{
	case r_1: //Caso seja o primeiro radiobutton
//Obtém o nome do usuírio 			
char buffer[256];
DWORD size;
size=256;
			GetUserName(buffer,&size);
			SetWindowText(txt,buffer); //Mostra no textbox
break;
	case r_2: //Caso seja o segundo
		ExitProcess(0); //Encerra
	} break;
default:
	return DefWindowProc(window,msg,wParam,lParam);
}
return 0;
}
Muito bem, na primeira parte, aprendemos como um programa Windows é iniciado, alguns argumentos de inicialização, registro de classes, criação da janela e sobre o LOOP de mensagens.Vimos também um exemplo de uma janela vazia.Aprenderemos a seguir, como "enfeitar" nossa janela com os famosos controles do windows: labels, caixas de texto, etc.
Criando e utilizando controles comuns do Windows
************************************************** *
Lembra-se de como criamos a nossa primeira janela?
Utilizamos a função CreateWindowEx. Usaremos essa mesma função para criar nossos controles.
Observe:
Código:
HWND hwnd;
hwnd = CreateWindow(0,CLASSE,TÍTULO/CAPTION,ESTILO,Horizontal,Vertical,Largura,Altura,HWND-PAI,ID,INSTÂNCIA,lParam);
Entendendo:
CLASSE -> Literalmente, é a classe a qual o objeto pertence.
TÍTULO/CAPTION -> Texto/tàtulo do referido objeto.
ESTILO -> Modo de exibição do objeto.
Horizontal -> posição horizontal.
Vertical -> posição vertical.
Altura -> altura do objeto.
HWND-Pai -> Identificação do objeto principal, onde o controle no nosso caso, serí criado.
ID -> Identifação do nosso objeto.
INSTÂNCIA -> Propriedade HINSTANCE do objeto principal. (Opicional)
lParam -> Não utilizado.
Exemplo simples - Criando um Label:
Código:
#define lb1 1
HWND label1;
label1 = CreateWindowEx(0,"STATIC","OLÁ!",WS_CHILD|WS_VISIBLE,0,0,100,20,HWND-MAIN,(HMENU)lb1,NULL,0);
STATIC -> Classe do LABEL
OLÁ -> Tàtulo
WS_CHILD -> Indica que o objeto fica "dentro" de outro.
WS_VISIBLE -> Mostra nosso objeto.
0 -> Posição horizontal
0 -> Posição vertial
100 -> Larguda
20 -> Altura
HWND-MAIN -> HWND do WinProc
(HMENU)lb1 -> Converte o valor de lb1 (nome do nosso objeto) para o dado correto (HMENU).
NULL -> Instância
0 -> lParam
Você deve estar se perguntando: Onde eu coloco isso?
Bem, existem diversas maneiras de você implementí-lo, vou mostrar duas:
1) Logo após a criação da janela principal. Exemplo:
Código:
#define lb1 1
[...]
hwnd = CreateWindowEx(0,"Janela","Minha janelinha",WS_OVERLAPPED|WS_SYSMENU,300,100,400,400,NULL,NULL,hInstance,NULL);
HWND label1;
label1 = CreateWindowEx(0,"STATIC","OLÁ!",WS_CHILD|WS_VISIBLE,0,0,100,20,HWND-MAIN,(HMENU)lb1,NULL,0);
[...]
2) Após o programa receber a mensagem que foi iniciado com sucesso: WM_CREATE. Exemplo:
Código:
#define lb1 1
[...]
switch(msg)
 {
case WM_CREATE:
HWND label1;
label1 = CreateWindow(0,"STATIC","OLÁ!",WS_CHILD|WS_VISIBLE,10,10,100,20,window,(HMENU)lb1,NULL,0);
break;
}
[...]
Muito bem, mostrarei agora, algumas classes e estilos dos controles mais comuns:
Label:
************************
Classe: STATIC
Estilos comuns: 
SS_SIMPLE -> Simples
WS_EX_TRANSPARENT -> Transparente
Caixa de Texto:
************************
Classe: EDIT
Estilos comuns:
ES_AUTOVSCROLL -> Rolagem vertical automítica.
ES_AUTOHSCROLL -> Rolagem horizontíl automatica.
ES_MULTILINE -> Múltiplas linhas
ES_NUMBER -> Apenas números
ES_OEMCONVERT -> Converte caracters DOS para fonte normal.
ES_PASSWORD -> Password (não se combina com ES_MULTILINE).
ES_READONLY -> Apenas leitura
ES_UPPERCASE -> Apenas caixa alta 
WS_HSCROLL -> Barra de rolagem horizontal (Necessita ES_MULTILINE)
WS_VSCROLL -> Barra de rolagem vertical (Necessita ES_MULTILINE)
Botão:
********************
Classe: BUTTON
Estilos comuns:
BS_DEFPUSHBUTTON -> Botão DEFAULT
CheckBox
********************
Classe: BUTTON
Estilos OBRIGATÓRIOS: BS_AUTOCHECKBOX
Estilos comuns:
BS_AUTO3STATE -> 3 Possibilidades: Marcado, Semi-Marcado e Não-Marcado.
RadioButton
********************
Classe: BUTTON
Estilos OBRIGATÓRIOS: BS_RADIOBUTTON
ListBox
********************
Classe: LISTBOX
Estilos comuns:
LBS_MULTICOLUMN -> Múltiplas colunas
LBS_MULTIPLESEL -> Seleção múltipla
LBS_SORT -> Classifica itens por ordem alfabéticaWS_HSCROLL -> Rolagem horizontal
WS_VSCROLL -> Rolagem verticalComboBox
********************
CLASSE: COMBOBOX
Estilos Comuns:
CBS_DROPDOWN -> Seleção/Escrita
CBS_DROPDOWNLIST ->Apenas seleção de itens 
CBS_SORT -> Classifica itens em ordem alfabética
WS_HSCOLL -> Rolagem horizontal
WS_VSCROLL -> Rolagem vertical
Estilos OBRIGATÓRIOS à todos os controles:
WS_VISIBLE -> Torna os controles visàveis, dispensando o uso de ShowWindow().
WS_CHILD -> Aclopam o controle dentro da janela.
Estilos comuns à todos os controles:
WS_BORDER -> Adiciona borda ao controle
WS_DISABLED -> Cria o controle iniciamente disabilitado.
WS_TABSTOP -> Permite que o controle receba FOCO pela tecla TAB.
Bem, temos outros controles, por enquanto aprensentarei apenas estes.
Funções comuns à maioria dos controles:
*******************************************
Habilitando/Desabilitando o controle:
EnableWindow(hwnd,valor);
hwnd -> HWND do controle.
valor -> 1 (true - habilitado) ou 0 (false - disabilitado)
Adicionando/Modificando um texto:
SetWindowText(hwnd,texto);
hwnd -> HWND do controle.
texto -> Texto a ser adicionado.
Obtendo um texto:
char buffer[256];
GetWindowText(hwnd,buffer,256);
hwnd -> HWND do controle.
buffer -> variível que receberí o texto
256 -> tamanho do buffer.
Trabalhando com CheckBox e RadioButtons:
*******************************************
Verificando estados:
int estado;
estado = SendMessage(hwnd,BM_GETCHECK,0,0);
if(x==BST_CHECKED){
//Marcado
}
else
{
//Desmarcado
}
hwnd -> HWND do controle.
BM_GETCHECK -> Mensagem:: Checar estado.
0 -> WPARAM
0 -> Lparam
BST_CHECKED -> Marcado
BST_UNCHECKED -> Desmarcado
Trabalhando com ListBox:
*******************************************
Adicionando um item:
SendMessage(hwnd,LB_ADDSTRING,0,(LPARAM)item);
hwnd -> HWND do controle.
LB_ADDSTRING -> mensagem enviada ao listbox para adicionar um item.
0 -> WPARAM não utilizado.
(LPARAM)item -> converte e adiciona o item desejado.
Obtendo posição de um item selecionado:
int pos;
pos = SendMessage(hwnd,LB_GETCURSEL,0,0);
pos -> Inteiro que receberí a posição do item.
hwnd -> HWND do controle.
LB_GETCURSEL -> Mensagem:: obtém o item selecionado.
0 -> WPARAM
0 -> LPARAM
Obtendo texto de um item:
char buffer[256];
SendMessage(hwnd,LB_GETTEXT,(WPARAM)index,(LPARAM) buffer);
hwnd -> HWND do controle.
LB_GETCURSEL -> Mensagem:: obtém o texto do item.
(WPARAM)index -> Posição do item a receber o texto.
(LPARAM)buffer -> Converte e armazena o texto do item INDEX no buffer.
Deletando um item:
SendMessage(hwnd,LB_DELETESTRING,(WPARAM)index,0);
hwnd -> HWND do controle.
LB_DELETESTRING -> Mensagem:: deleta um item.
(WPARAM)index -> Posição do item a deletar.
Modificando um item:
SendMessage(hwnd,LB_INSERTSTRING,(WPARAM)index,(LP ARAM)valor);
hwnd -> HWND do controle.
LB_DELETESTRING -> Mensagem:: modifica um item.
(WPARAM)index -> Posição do item a modificar.
(LPARAM)valor -> Novo texto do item.
Trabalhando com ComboBox:
*******************************************
Adicionando um item:
SendMessage(hwnd,CB_ADDSTRING,0,(LPARAM)item);
hwnd -> HWND do controle.
CB_ADDSTRING -> mensagem enviada ao listbox para adicionar um item.
0 -> WPARAM não utilizado.
(LPARAM)item -> converte e adiciona o item desejado.
Obtendo posição de um item selecionado:
int pos;
pos = SendMessage(hwnd,CB_GETCURSEL,0,0);
pos -> Inteiro que receberí a posição do item.
hwnd -> HWND do controle.
CB_GETCURSEL -> Mensagem:: obtém o item selecionado.
0 -> WPARAM
0 -> LPARAM
Obtendo texto de um item:
char buffer[256];
SendMessage(hwnd,CB_GETTEXT,(WPARAM)index,(LPARAM) buffer);
hwnd -> HWND do controle.
CB_GETCURSEL -> Mensagem:: obtém o texto do item.
(WPARAM)index -> Posição do item a receber o texto.
(LPARAM)buffer -> Converte e armazena o texto do item INDEX no buffer.
Deletando um item:
SendMessage(hwnd,CB_DELETESTRING,(WPARAM)index,0);
hwnd -> HWND do controle.
CB_DELETESTRING -> Mensagem:: deleta um item.
(WPARAM)index -> Posição do item a deletar.
Modificando um item:
SendMessage(hwnd,CB_INSERTSTRING,(WPARAM)index,(LP ARAM)valor);
hwnd -> HWND do controle.
CB_DELETESTRING -> Mensagem:: modifica um item.
(WPARAM)index -> Posição do item a modificar.
(LPARAM)valor -> Novo texto do item.
1) Crie um novo arquivo : “primeiroRadio.cpp"
2) Adicione o seguinte código ao arquivo criado (utilize o copiar e colar, salve e rode o programa com F9).
3) Durante a execução aparecerá a tela do MS-DOS(tela preta), mas também a janela de interface gráfica.
#include <windows.h>
//Nomes para os controles
#define lb1 1
#define txtbox 2
#define combo 3
#define btn 4
//HWND do controles
HWND label1;
HWND txt1;
HWND combo1;
HWND bot1;
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
MSG message;
HWND hwnd;
WNDCLASSEX wc;
wc.cbClsExtra=0;
wc.cbSize=sizeof(wc);
wc.cbWndExtra=0;
wc.hbrBackground=GetSysColorBrush(COLOR_BTNFACE);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
wc.hIconSm=LoadIcon(NULL,IDI_APPLICATION);
wc.lpfnWndProc=WinProc;
wc.lpszClassName="Janela";
wc.lpszMenuName=NULL;
wc.style=0;
RegisterClassEx(&wc);
hwnd = CreateWindowEx(0,"Janela","EXEMPLO 1",WS_OVERLAPPED|WS_SYSMENU,200,200,400,100,NULL,NULL,NULL,NULL);
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
while(GetMessage(&message,0,0,0)){
	TranslateMessage(&message);
	DispatchMessage(&message);
}
return message.wParam ;
}
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam){
switch(msg)
{
case WM_CLOSE:
	PostQuitMessage(0);
	break;
case WM_CREATE: //Processo de criação da janela
label1 = CreateWindowEx(0,"STATIC","Texto:" ,WS_CHILD|WS_VISIBLE,10,10,40,20,window,(HMENU)lb1,0,0);
txt1 = CreateWindowEx(0,"EDIT","" ,WS_CHILD|WS_VISIBLE|WS_BORDER,60,10,140,20,window,(HMENU)txtbox,0,0); //Cria label
combo1 = CreateWindowEx(0,"COMBOBOX","" ,WS_CHILD|WS_VISIBLE|CBS_DROPDOWNLIST,230,10,140,400,window,(HMENU)combo,0,0); //Cria ComboBox
bot1 = CreateWindowEx(0,"BUTTON","Adicionar texto..." ,WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON,140,40,120,20,window,(HMENU)btn,0,0); //Cria botão
break;
case WM_COMMAND: //Mensagem enviada quando um controle é clicado:
	switch(wParam) //Verifica parâmetro
	{
	case btn: //Se for o botão
//Obtém conteúdo do textbox.
		char buffer[256]; 
		GetWindowText(txt1,buffer,256);
	//Adiciona este no combobox.	SendMessage(combo1,CB_ADDSTRING,0,(LPARAM)buffer);
	} break;
default:
	return DefWindowProc(window,msg,wParam,lParam);
}
return 0;
}
1) Crie um novo arquivo : “primeiroRadio.cpp"
2) Adicione o seguinte código ao arquivo criado (utilize o copiar e colar, salve e rode o programa com F9).
3) Durante a execução aparecerá a tela do MS-DOS(tela preta), mas também a janela de interface gráfica.
#include <windows.h>
//Nomes dos controles
#define check 1
#define list 2
#define btn_add 3
#define btn_del 4
//HWND dos controles
HWND check1;
HWND list1;
HWND bot1,bot2;
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
MSG message;
HWND hwnd;
WNDCLASSEX wc;
wc.cbClsExtra=0;
wc.cbSize=sizeof(wc);
wc.cbWndExtra=0;
wc.hbrBackground=GetSysColorBrush(COLOR_BTNFACE);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
wc.hIconSm=LoadIcon(NULL,IDI_APPLICATION);
wc.lpfnWndProc=WinProc;
wc.lpszClassName="Janela";
wc.lpszMenuName=NULL;
wc.style=0;
RegisterClassEx(&wc);
hwnd = CreateWindowEx(0,"Janela","EXEMPLO 1",WS_OVERLAPPED|WS_SYSMENU,200,200,400,200,NULL,NULL,NULL,NULL);
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
while(GetMessage(&message,0,0,0)){
	TranslateMessage(&message);
	DispatchMessage(&message);
}
return message.wParam ;
}
LRESULT CALLBACKWinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam){
switch(msg)
{
case WM_CLOSE:
	PostQuitMessage(0);
	break;
case WM_CREATE: //Processo de criação da janela
check1 = CreateWindowEx(0,"BUTTON","Manipular ListBox" ,WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX,10,10,150,20,window,(HMENU)check,0,0); //Criamos o checkbox
list1 = CreateWindowEx(0,"LISTBOX","" ,WS_CHILD|WS_VISIBLE|WS_BORDER|WS_VSCROLL,240,10,145,150,window,(HMENU)list,0,0); //Criamos a Listbox
bot1 = CreateWindowEx(0,"BUTTON","Adicionar Item" ,WS_CHILD|WS_VISIBLE|WS_DISABLED,10,35,100,20,window,(HMENU)btn_add,0,0); //Criamos o botão para adicionar item
bot2 = CreateWindowEx(0,"BUTTON","Remover Item" ,WS_CHILD|WS_VISIBLE|WS_DISABLED,120,35,100,20,window,(HMENU)btn_del,0,0); //Criamos o botão para deletar item.
break;
case WM_COMMAND: //Mensagem enviada quando um controle é clicado:
	switch(wParam) //Verifa o parâmetro
	{
	case check: //Se for o checkbox
		int estado; //Variível Retorno
		estado = SendMessage(check1,BM_GETCHECK,0,0); //Verfica estado
		if(estado==BST_CHECKED){ //Se checado, habilita os botões
	EnableWindow(bot1,1);
 EnableWindow(bot2,1);
		}
		else //Se não, os desabilitada.
		{
	EnableWindow(bot1,0);
 EnableWindow(bot2,0);
		}break;
	case btn_add: //Se for o botão para adicionar itens
		SendMessage(list1,LB_ADDSTRING,0,(LPARAM)"ITEM"); //Adicione "ITEM" à Listbox
		break;
	case btn_del: //Se for o botão para deletar
		int pos;//Variível Retorno
		pos = SendMessage(list1,LB_GETCURSEL,0,0); //Verifica posição
		if(pos==-1) //Se for -1 (nenhum item)
			MessageBox(window,"Nenhum item selecionado!","ERRO",MB_OK|MB_ICONINFORMATION);
		else //Se não
			SendMessage(list1,LB_DELETESTRING,(WPARAM)pos,0); //Deleta o item selecionado.
		break;
	} break;
default:
	return DefWindowProc(window,msg,wParam,lParam);
}
return 0;
}
Exercício
O paciente do sexo masculino pode fazer raiox (custo de R$ 300,00), sangue (R$ 150,00) e espermograma (R$ 250,00) e o paciente do sexo feminino pode fazer raiox (custo de R$ 300,00), sangue (R$ 150,00) e gravidez (R$ 122,00).
Desenvolva um programa que calcule o valor a ser pago pelo cliente. 
Considere que a Clínica cobra uma taxa fixa de R$ 250,00 pelo atendimento. Dado o exemplo:
Paciente do sexo masculino: Exames feitos de sangue e espermograma, custo total de 650,00.
Paciente do sexo feminino: Exames feitos de raiox e gravidez, custo total de 672,00.
/* site da documentação interface gráfica.
http://www.forum-invaders.com.br/vb/showthread.php/8290-Tutorial-Interface-Gr%C3%A1fica-(GUI)-C-C
*/
#include <windows.h>
#include <stdio.h>
//Definimos um nome para os controles
#define label_1 1
#define label_2 2
#define radio_1 3
#define radio_2 4
#define texto_1 6
#define check_1 7
#define check_2 8
#define check_3 9
#define check_4 10
#define label_3 11
#define label_4 12
#define label_5 13
//HWND dos controles
HWND texto1;
HWND radio1,radio2;
HWND label1, label2, label3, label4,label5;
HWND check1, check2, check3,check4;
float total, diferenca;
char buffer[16];
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM 
wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
MSG message;
HWND hwnd;
WNDCLASSEX wc;
wc.cbClsExtra=0;
wc.cbSize=sizeof(wc);
wc.cbWndExtra=0;
wc.hbrBackground=GetSysColorBrush(COLOR_BTNFACE);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
wc.hIconSm=LoadIcon(NULL,IDI_APPLICATION);
wc.lpfnWndProc=WinProc;
wc.lpszClassName="Janela";
wc.lpszMenuName=NULL;
wc.style=0;
RegisterClassEx(&wc);
hwnd = CreateWindowEx(0,"Janela","Clinica Boa Vida",WS_OVERLAPPED|WS_SYSMENU,50,50,600,600,NULL,NULL,NULL,NULL);
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
while(GetMessage(&message,0,0,0)){
	TranslateMessage(&message);
	DispatchMessage(&message);
}
return message.wParam ;
}
LRESULT CALLBACK WinProc(HWND window,UINT msg, WPARAM wParam,LPARAM lParam){
switch(msg)
{
case WM_CLOSE:
	PostQuitMessage(0);
	break;
case WM_CREATE: //No processo de criação da janela
 label1 = CreateWindowEx(0,"STATIC","PACIENTE:" ,WS_CHILD|WS_VISIBLE,60,50,80,40,window,(HMENU)label_1,0,0);
 texto1 = CreateWindowEx(0,"EDIT","" ,WS_CHILD|WS_VISIBLE|WS_BORDER,140,50,370,20,window,(HMENU)texto_1,0,0); //Cria nosso textbox
 label2 = CreateWindowEx(0,"STATIC","SEXO:" ,WS_CHILD|WS_VISIBLE,60,80,60,40,window,(HMENU)label_2,0,0);
 radio1 = CreateWindowEx(0,"BUTTON","Masculino", WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,60,100,240,15,window,(HMENU)radio_1,0,0);
 radio2 = CreateWindowEx(0,"BUTTON","Feminino" , WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,60,120,240,15,window,(HMENU)radio_2,0,0); 
 label3 = CreateWindowEx(0,"STATIC","TIPO DE EXAME:" , WS_CHILD|WS_VISIBLE, 60,160,180,80,window,(HMENU)label_3,0,0);
 check1 = CreateWindowEx(0,"BUTTON","RaioX" , WS_CHILD|WS_VISIBLE|WS_DISABLED|BS_AUTOCHECKBOX,60,180,100,20,window,(HMENU)check_1,0,0); 
 check2 = CreateWindowEx(0,"BUTTON","Sangue" , WS_CHILD|WS_VISIBLE|WS_DISABLED|BS_AUTOCHECKBOX,60,220,100,20,window,(HMENU)check_2,0,0); 
 check3 = CreateWindowEx(0,"BUTTON","Espermograma" , WS_CHILD|WS_VISIBLE|WS_DISABLED|BS_AUTOCHECKBOX,200,180,120,20,window,(HMENU)check_3,0,0);
 check4 = CreateWindowEx(0,"BUTTON","Gravidez" , WS_CHILD|WS_VISIBLE|WS_DISABLED|BS_AUTOCHECKBOX,200,220,100,20,window,(HMENU)check_4,0,0); 
 label4 = CreateWindowEx(0,"STATIC","VALOR A PAGAR:" ,WS_CHILD|WS_VISIBLE,60,280,180,80,window,(HMENU)label_4,0,0);
 label5 = CreateWindowEx(0,"STATIC","" ,WS_CHILD|WS_VISIBLE|WS_BORDER, 180,280,80,30,window,(HMENU)label_5,0,0);
 
 break;
case WM_COMMAND: //Mensagem enviada quando se clica em um controle
	switch(wParam) //Verifica o parâmetro
	{
	case radio_1:
 diferenca=250;
 if(SendMessage(check1,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+300;
 } 
 if(SendMessage(check2,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+150;
 }
 if(SendMessage(check3,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+250;
 }
 total = diferenca;
 EnableWindow(check1,2);
 EnableWindow(check2,1);
 EnableWindow(check3,1);
 EnableWindow(check4,0);
 EnableWindow(radio1,1);
 EnableWindow(radio2,1);
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer); 
 	break; 
 case radio_2:
 diferenca=250;
 if(SendMessage(check1,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+300;
 } 
 if(SendMessage(check2,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+150;
 }
 if(SendMessage(check4,BM_GETCHECK,0,0) == BST_CHECKED){
 diferenca=diferenca+122;
 }
 total = diferenca; 
 EnableWindow(check1,1);
 EnableWindow(check2,1);
 EnableWindow(check3,0);
 EnableWindow(check4,1);
 EnableWindow(radio1,1);
 EnableWindow(radio2,1);
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer); 
 break; 
	
	case check_1: 
 if(SendMessage(check1,BM_GETCHECK,0,0) == BST_CHECKED){ 
 total = total + 300;
 	}
		else
		{
	 total = total - 300; 
		}
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer); 
 break;
 case check_2: 
		 if(SendMessage(check2,BM_GETCHECK,0,0) == BST_CHECKED){ 
 total = total + 150;
 	}
		else
		{
	 total = total - 150; 
		}
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer);break;
 case check_3:
		 if(SendMessage(check3,BM_GETCHECK,0,0) == BST_CHECKED){ 
 total = total + 250;
 }
		else
		{ 
	 total = total - 250; 
		}
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer); 
 break; 
 case check_4:
		 if(SendMessage(check4,BM_GETCHECK,0,0) == BST_CHECKED){ 
 total = total + 122;
 }
		else
		{ 
	 total = total - 122; 
		}
 sprintf (buffer,"%.2f",total);
 SetWindowText(label5,buffer); 
 break; 
 } 
 break;
 default: return DefWindowProc(window,msg,wParam,lParam);
}
return 0;
}