Informática Numaboa - Tutoriais e Programação
Janelas (masm)
|
Dom 7 Jan 2007 10:34 |
- Detalhes
- Categoria: Assembly Numaboa (antigo oiciliS)
- Atualização: Terça, 16 Fevereiro 2010 22:54
- Autor: vovó Vicki
- Acessos: 18534
No tutorial anterior aprendemos como pôr uma janelinha na tela. Só que era uma janela do tipo message box, que não permite adicionar certas funcionalidades como um menu por exemplo. Neste tutorial vamos aprender a criar uma janela "de verdade". Além disso, vamos explorar a "mecânica" da coisa.
Projeto
Como sempre, nosso primeiro passo é planejar o programa. O projeto até que é pequeno, mas, em compensação... o tutorial é um mastodonte!
- O sistema operacional é o Windows de 32 bits.
- Não precisamos mais do que o conjunto de instruções do processador 386.
- Vamos criar apenas uma janela "nua", com um mínimo de funcionalidade (apenas pode ser fechada).
Vamos por partes que a coisa há de ficar clara. Um dos aspectos mais importantes é entender o sistema de comunicação do Windows. Antes de começar pra valer este tutorial que deve ficar um pouco longo, abra o QEditor do MASM32 e digite (ou copie e cole) o esqueleto de um programa que possa ser finalizado com ExitProcess:
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
.CODE
inicio:
invoke ExitProcess,0
end inicio
A teoria das janelas
A Interface Gráfica dos programas Windows, conhecida como GUI (Graphical User Interface), depende essencialmente de funções da API. O uso desta interface padrão beneficia usuários e programadores. Para os usuários, as GUIs dos programas Windows são todas parecidas facilitando a navegação. Para os programadores, os códigos da GUI estão testados e prontos para uso. A desvantagem para os programadores é a complexidade crescente envolvida. Para criar ou manipular qualquer objeto GUI, como janelas, menus ou ícones, os programadores precisam seguir regras rígidas definidas pelo sistema Windows.
Logo abaixo estão os passos necessários para se criar uma janela no desktop:
- Obter um manipulador de instância - HANDLE (obrigatório).
- Pegar as instruções da linha de comando (dispensável, a não ser que o programa necessite de parâmetros iniciais fornecidos pelo usuário).
- Criar e Registrar a classe da janela (requerido, a não ser que se use tipos de janelas predefinidos, por exemplo MessageBox ou uma Dialog Box).
- Criar a janela (Obrigatório).
- Mostrar a janela no desktop.
- Atualizar a área cliente da janela.
- Entrar num loop infinito checando as mensagens do Windows.
- Processar as mensagens da janela - o gerente de mensagens.
- Encerrar o programa se o usuário fechar a janela.
Handle
Como usuário do Windows você sabe que pode rodar várias instâncias de um mesmo programa. Se você abrir a calculadora do Windows duas vezes, obterá duas janelas distintas, cada uma delas rodando uma instância do programa. Se você fizer cálculos na primeira janela, a segunda não é afetada. Portanto, cada uma das instâncias, aos olhos do sistema, é um aplicativo independente. Como é que o Windows consegue individualizar cada uma das instâncias? Através de um identificador ou manipulador de instância. Este manipulador é apenas um número que identifica a instância para o sistema. Por exemplo, "a janela da instância 1 precisa ser atualizada", "a janela da instância 2 foi ativada", "a janela da instância 2 foi minimizada", etc, permite que o sistema efetue as tarefas nas janelas corretas. Se não existisse o número de identificação, bem... a bagunça seria inevitável. E se duas instâncias possuírem o mesmo número... o Windows vai dar pau.
Existe uma função da API que nos permite obter um manipulador de instância que não conflite com outros já existentes (as duas janelas que abrimos para a calculadora não são as únicas que estão abertas). Esta função é a GetModuleHandle, que faz parte da kernel32.lib.
Aproveite e familiarize-se um pouco mais com o MASM32: clique no item de menu [Tools / API Library List] para ativar uma ferramenta muito útil que nosso amigo hutch colocou à nossa disposição - a "API to Library list". Esta janelinha é o mapa da mina que relaciona uma grande quantidade de funções e as bibliotecas correspondentes. Digite "getmoduleh" e você já estará na linha que corresponde à função procurada: GetModuleHandle lib ==> kernel32.lib
Nós (e o sistema) vamos precisar do manipulador de instância quando quisermos atualizar ou alterar alguma coisa na(s) janela(s) do programa. É um número que será usado numa porção de funções diferentes, portanto, precisamos preparar um lugar onde vamos guardar este identificador e que possa ser acessado de qualquer ponto do programa . Um endereço de memória que guarda um valor e que pode ser acessado de qualquer ponto do programa é chamado de VARIÁVEL GLOBAL. Ao invés de lembrar do endereço, podemos dar um nome a ele. Por exemplo, você pode ir para a casa do "Zé" ou para a "rua dos bits, número 135" que dá na mesma, pois o Zé mora neste endereço.
Já que precisamos deixar a critério do sistema o número que será designado como manipulador de instância para o programa, o valor da variável que conterá o manipulador da instância só pode ser obtido em tempo de execução, portanto, não podemos (e não devemos!) inicializar esta variável. A seção para variáveis não inicializadas, conforme já foi visto no tutorial "Por onde começar", é a seção .DATA?. Nesta seção damos nomes às variáveis, indicamos seu tipo e informamos que não são inicializadas através de um ponto de interrogação (?).
A função GetModuleHandle
Qual é o tipo da variável que precisamos declarar? A referência da API nos diz que a função GetModuleHandle retorna um manipulador de módulo (módulo é igual a instância no win32) para o módulo especificado se o arquivo tiver sido mapeado no espaço de endereços do processo chamador e que o tipo do valor de retorno é HMODULE - apenas um dos muitos nomes que o Windows dá a DWORD.HMODULE GetModuleHandle(
LPCTSTR lpModuleName // endereço do nome do módulo para o qual se solicita um manipulador
);
- Parâmetro lpModuleName: Aponta para uma string terminada em zero com o nome de um módulo Win32 (uma .DLL ou arquivo .EXE). Se a extensão do nome do arquivo for omitida, a extensão default é .DLL. A string do nome do arquivo por ter um caracter finalizador ponto (.) para indicar que o nome do módulo não possui extensão. A string não precisa especificar um caminho (path). O nome é comparado (sem considerar maiúsculas e minúsculas) aos nomes dos módulos que já estejam mapeados no espaço de endereços do processo chamador.
Se o parâmetro for NULL, GetModuleHandle retorna um manipulador do arquivo usado para criar o processo da chamada.
Então vamos digitar um pouco. Certifique-se de que os arquivos kernel32.inc e kernel32.lib constam na lista de include e includelib. Uma vez familiarizados com a função, podemos chamá-la com o parâmetro NULL. É tudo o que queremos: um manipulador de instância para o nosso programa.
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
.DATA?
mInstancia DWORD ?
.CODE
inicio:
invoke GetModuleHandle, NULL
mov mInstancia, eax
invoke ExitProcess,0
end inicio
A diretiva invoke você já conhece do tutorial "O Folgado" e a função GetModuleHandle já foi mais do que explicada. A linha seguinte é que são elas: usa o mnemônico MOV com os operandos mInstancia e eax. Vamos por partes.
Um mnemônico é um nome reservado de uma família de códigos operacionais que realizam tarefas semelhantes no processador. MOV pede ao processador para MOVer ou copiar um valor de um local para outro. Dê uma olhada no texto acessório "Códigos Operacionais" para entender melhor.
EAX é um registrador de uso geral, ou seja, é um tipo especial de memória DENTRO do processador e que serve para o armazenamento temporário de dados (a informação pode ser colocada num determinado instante e de lá ser retirada quando isso se fizer necessário). Existem vários registradores dentro do processador - para maiores detalhes leia o texto acessório "Registradores".
Em todo caso, esta nova linha pode ser traduzida da seguinte maneira: MOVa o valor que se encontra no registrador EAX para a posição de memória referente à nossa variável mInstancia. Quando esta linha for executada, a variável global mInstancia é inicializada.
O motivo pelo qual transferimos o valor de EAX para mInstancia é que o valor de retorno das funções da API são armazenados no registrador EAX. Neste caso, assim que se volta da função GetModuleHandle, o registrador EAX contém o valor do manipulador de instância solicitado.
Instruções da linha de comando
A linha de comando geralmente se resume no nome do programa que queremos executar, ou seja, não contém parâmetros adicionais. Existem alguns raros casos em que é necessário enviar um ou alguns parâmetros para que o programa funcione corretamente ou de forma personalizada. Somente nestes raros casos é que precisamos usar a função da API GetCommandLine, também da kernel32.lib. Apenas a título de ilustração vamos inserir esta chamada.
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
.DATA?
mInstancia DWORD ?
linhaComando DWORD ?
.CODE
inicio:
invoke GetModuleHandle, NULL
mov mInstancia, eax
invoke GetCommandLine
mov linhaComando, eax
invoke ExitProcess,0
end inicio
A classe da janela
O Windows só consegue criar objetos a partir de um modelo - é como se o sistema precisasse da "planta da casa" para que poder construir a "casa". Primeiro é preciso criar a "planta" e depois entregá-la (fazer o registro) para que o Windows possa usá-la como modelo.
Normalmente a função padrão utilizada para esta dupla tarefa (criar e registrar) é a WinMain, que é chamada pelo sistema como ponto de entrada para um aplicativo win32. A referência da API nos mostra o seguinte:
int WINAPI WinMain(
HINSTANCE hInstance, // manipulador da instância
HINSTANCE hPrevInstance, // manipulador da instância anterior
LPSTR lpCmdLine, // ponteiro para a linha de comando
int nCmdShow // modo de apresentação da janela
);
Para poder utilizar esta função precisamos criar o protótipo da mesma. Se você esqueceu o que é um protótipo de função, refresque a memória relendo "O Folgado". Para criar o protótipo é necessário conhecer os tipos dos parâmetros que a função espera receber: HINSTANCE, LPSTR e int. Na verdade, todos eles são nomes diferentes que o Windows dá ao DWORD. Esta função recebe quatro parâmetros: o manipulador da instância do nosso programa, o manipulador de instância da instância anterior do nosso programa, a linha de comando e o estado da janela da primeira vez em que aparecer. No win32, NÃO existe uma instância anterior. Cada programa está sozinho no seu espaço de endereços, de modo que o valor de hPrevInstance será sempre 0 (NULL). Isto é uma sobra da época do win16 quando todas as instâncias de diversos programas rodavam no mesmo espaço de endereços e uma instância queria saber se era a primeira. No win16, se hPrevInstance for NULL, então esta instância é a primeira. O nome da função também pode ser um da nossa escolha, portanto, nosso protótipo pode ser
gerenteJanela proto :DWORD, :DWORD, :DWORD, :DWORD
O manipulador da instância do nosso programa já está armazenado em mInstancia, o manipulador da instância anterior é NULL, o ponteiro para a linha de comando já está em linhaComando e o modo de exibição pode ser o padrão (SW_SHOWDEFAULT). Nosso código fonte passa a ser o seguinte:
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
gerenteJanela proto :DWORD, :DWORD, :DWORD, :DWORD
.DATA?
mInstancia DWORD ?
linhaComando DWORD ?
.CODE
inicio:
invoke GetModuleHandle, NULL
mov mInstancia, eax
invoke GetCommandLine
mov linhaComando, eax
invoke gerenteJanela, mInstancia, NULL, linhaComando, SW_SHOWDEFAULT
invoke ExitProcess,0
end inicio
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
...
gerenteJanela endp
A função gerenteJanela é um procedimento que separamos do corpo principal do código (que fica entre o par de rótulos "inicio:" e "end inicio"). Fiz isto apenas para destacar e individualizar este procedimento do resto do código. Se você quiser, não precisa criar o protótipo da função, não precisa fazer o invoke e nem criar o procedimento gerenteJanela. Pode simplesmente colocar todo o código que vem a seguir no corpo principal.
Além disso, se você suprimiu o código correspondente à linha de comando, basta enviar um parâmetro NULL no lugar de linhaComando.
A estrutura WNDCLASSEX
A "planta" da classe da nossa janela é "desenhada" numa estrutura. Uma estrutura agrupa dados de tal forma que possam ser endereçados num bloco único (Leia mais sobre estruturas em "Trabalhando com Estruturas"). Usaremos uma estrutura predefinida no Windows, chamada WNDCLASSEX.
A estrutura WNDCLASSEX foi planejada para conter todas as informações de uma classe janela e a referência da API nos mostra o seguinte:
typedef struct _WNDCLASSEX {
UINT cbSize;
UINT style;
WNDPROC lpfnWndProc;
int cbClsExtra;
int cbWndExtra;
HANDLE hInstance;
HICON hIcon;
HCURSOR hCursor;
HBRUSH hbrBackground;
LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
HICON hIconSm;
} WNDCLASSEX;
A seguir, a explicação para cada um dos membros desta estrutura:
- cbSize: O tamanho da estrutura WNDCLASSEX em bytes. Podemos usar o operador SIZEOF para obter este valor.
- style: O estilo da janela criada a partir desta classe. Você pode combinar diversos estilos usando o operador "or".
- lpfnWndProc: O endereço do procedimento da janela (window procedure) responsável pelas janelas criadas a partir desta classe.
- cbClsExtra: Especifica o número de bytes extras que podem ser alocados logo após a estrutura. O sistema operacional inicializa os bytes com zero. Aqui você pode armazenar dados específicos da classe.
- cbWndExtra: Especifica o número de bytes extras que podem ser alocados logo após a instância da janela. O sistema operacional inicializa estes bytes com zero. Se o aplicativo usar a estrutura WNDCLASS para registrar uma caixa de diálogo usando a diretiva CLASS do arquivo de recursos, ele precisa indicar este membro como DLGWINDOWEXTRA.
- hInstance: O manipulador da instância do módulo (programa).
- hIcon: O manipulador do ícone. Obtenha-o através da chamada de LoadIcon.
- hCursor: O manipulador do cursor. Obtenha-o através da chamada de LoadCursor.
- hbrBackground: A cor de fundo das janelas criadas a partir desta classe.
- lpszMenuName: O manipulador de menu default para janelas criadas a partir desta classe.
- lpszClassName: O nome desta classe.
- hIconSm: O manipulador do ícone pequeno associado a esta classe. Se este membro for NULL, o sistema procura nos recursos de ícones especificado pelo membro hIcon por um ícone de tamanho apropriado que possa ser usado.
Declaração
Como só vamos precisar desta estrutura no procedimento da função gerenteJanela, vamos declará-la como variável LOCAL com o nome de ej (de estrutura janela - ou qualquer outro da sua escolha). A diretiva LOCAL aloca memória da pilha para esta variável e precisa estar situada imediatamente após a diretiva PROC. A sintaxe é LOCAL :. Vamos usar LOCAL ej:WNDCLASSEX, que pede ao MASM para alocar uma quantidade de memória de pilha correspondente ao tamanho da estrutura WNDCLASSEX para a variável de nome ej. A vantagem é que podemos referenciar ej no nosso código sem nos preocuparmos com o realinhamento da pilha, o que é mordomia pura. Uma desvantagem é que variáveis locais não podem ser usadas fora das funções onde foram criadas e que serão imediatamente destruídas quando se retorna ao chamador. Outra desvantagem é que variáveis locais não podem ser inicializadas automaticamente porque elas são apenas memória de pilha alocada dinamicamente na entrada da função. Precisamos atribuir seus valores manualmente após a diretiva LOCAL.
Entre os membros da estrutura encontramos o que deve conter o ponteiro para o nome da classe que desejamos criar. Para preencher este requisito, precisamos inicializar uma variável na seção .DATA que contenha o nome da classe.
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
gerenteJanela proto :DWORD, :DWORD, :DWORD, :DWORD
.DATA
NomeClasse db "JanelaNua",0
.DATA?
mInstancia DWORD ?
linhaComando DWORD ?
.CODE
inicio:
invoke GetModuleHandle, NULL
mov mInstancia, eax
invoke GetCommandLine
mov linhaComando, eax
invoke gerenteJanela, mInstancia, NULL, linhaComando, SW_SHOWDEFAULT
invoke ExitProcess,0
end inicio
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
gerenteJanela endp
A função
A partir deste ponto listarei apenas a porção da função gerenteJanela. O primeiro membro da estrutura é o cbSize, que deve conter o tamanho da estrutura. Podemos obter este valor usando o operador SIZEOF. Como estilo da janela usaremos CS_HREDRAW OR CS_VREDRAW. O terceiro membro, lpfnWndProc, é o mais importante de todos. O significado de lpfn é "long pointer to function", ou seja, ponteiro longo para função. No win32 não existem ponteiros "near" (perto) ou "far" (distante); devido ao modelo de memória FLAT, existem apenas ponteiros. Mas isto, novamente, é sucata da época do win16. Cada classe janela precisa estar associada a uma função que gerencie o comportamento das janelas criadas a partir desta classe. Esta função, que chamaremos de gerenteMensagem, é tão importante que será discutida em separado. Por enquanto vamos atribuir valores aos primeiros membros da estrutura usando o mnemônico MOV:
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
gerenteJanela endp
O ej.hInstance, o próximo membro da estrutura, deve conter o manipulador da instância do programa. Podemos usar a variável global mInstancia ou o parâmetro mInst recebido pela função gerenteJanela pois ambos apontam para o mesmo endereço, ou seja, contém o mesmo valor. Como não é possível transferir diretamente o valor de uma posição de memória para outra posição de memória e tanto ej.hInstance quanto mInst são posições de memória, será preciso usar o auxílio de um registrador. O mais fácil é utilizar o registrador da pilha: usar o mnemônico push para colocar o valor na pilha e o mnemônico pop para transferí-lo da pilha para ej.hInstance.
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
gerenteJanela endp
Ícone e Cursor
Para obter o manipulador do ícone e do cursor basta fazer uma chamada para LoadIcon e LoadCursor. A função LoadIcon carrega o recurso do ícone especificado a partir do executável associado a uma instância do aplicativo.
HICON LoadIcon(
HINSTANCE hInstance,
LPCTSTR lpIconName // string com o nome do ícone ou identificador do recurso do ícone
);
A função LoadCursor funciona como a anterior, apenas direcionada para o cursor.
HCURSOR LoadCursor(
HINSTANCE hInstance,
LPCTSTR lpCursorName // string com o nome do cursor ou identificador do recurso do cursor
);
Nas duas funções, HINSTANCE identifica uma instância do módulo cujo arquivo executável contém o ícone ou cursor que deve ser carregado. Como ainda não programamos os recursos do nosso aplicativo (vamos ver isto em tutoriais posteriores), nosso executável está "vazio" de recursos e HINSTANCE pode ser NULL. Neste caso serão usados os recursos do Windows e podemos usar os parâmetros default (veja mais detalhes na referência da API). Lembre-se de que o valor de retorno destas funções vai sempre para o registrador EAX.
Inicialização
A ordem de inicialização dos membros da estrutura WNDCLASSEX não é importante. Como estamos trabalhando o ícone do programa, aproveitaremos a chamada a LoadIcon e inicializaremos hIcon e hIconSm numa tacada.
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
invoke LoadIcon, NULL, IDI_WINLOGO
mov ej.hIcon, eax
mov ej.hIconSm, eax
invoke LoadCursor, NULL, IDC_ARROW
mov ej.hCursor, eax
gerenteJanela endp
A referência da API para WNDCLASSEX nos diz que, se usarmos uma cor para o membro hbrBackground, o valor da cor precisa ser um dos valores das cores padrão do sistema, acrescido de 1. Escolhemos a cor padrão COLOR_WINDOW, portanto usaremos COLOR_WINDOW+1.
Como não projetamos os recursos, também não temos um menu para o nosso aplicativo - a string com o nome do menu, por enquanto, será NULL.
E, finalmente, o nome da nossa classe de janela já foi definida na seção .DATA e o ponteiro para a string que contém o nome é OFFSET NomeClasse.
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
invoke LoadIcon, NULL, IDI_WINLOGO
mov ej.hIcon, eax
mov ej.hIconSm, eax
invoke LoadCursor, NULL, IDC_ARROW
mov ej.hCursor, eax
mov ej.hbrBackground, COLOR_WINDOW+1
mov ej.lpszMenuName, NULL
mov ej.lpszClassName, OFFSET NomeClasse
gerenteJanela endp
Foi extenso, porém não foi complicado. Nossa estrutura WNDCLASSEX está com todos os valores inicializados, ou seja, nossa classe de janela está definida. Mantendo a comparação inicial, a "planta da casa" está pronta. Agora podemos registrá-la.
Esta função é responsável pelo gerenciamento das mensagens provenientes de todas as janelas criadas a partir da classe associada. O Windows enviará mensagens à função para notificá-la de eventos importantes (entradas de teclado, cliques do mouse, etc) relativos às janelas pelas quais é responsável e a função deve responder adequadamente cada mensagem recebida.
Registro da classe
Após criar uma classe (a "planta de uma casa"), é obrigatório registrá-la para que o sistema permita usá-la como modelo para criar uma ou mais instâncias de objetos ("uma ou mais casas") baseados nesta classe. Como utilizamos a estrutura WNDCLASSEX para definir as caracteríticas da nossa classe de janela, para registrá-la precisamos usar a função que "faz par" com ela: a RegisterClassEx. Caso tivéssemos utilizado WNDCLASS, a função para registro seria RegisterClass.
ATOM RegisterClassEx(
CONST WNDCLASSEX *lpwcx // ponteiro para a estrutura com os dados da classe
);
Tranquilo. Temos a estrutura pronta e a função pede um ponteiro. Usando invoke podemos usar o operador ADDR para fornecê-lo. Acontece que esta função faz parte da user32.lib e esta biblioteca, assim como o arquivo include correspondente, precisa ser incluída:
...
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib
...
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
invoke LoadIcon, NULL, IDI_WINLOGO
mov ej.hIcon, eax
mov ej.hIconSm, eax
invoke LoadCursor, NULL, IDC_ARROW
mov ej.hCursor, eax
mov ej.hbrBackground, COLOR_WINDOW+1
mov ej.lpszMenuName, NULL
mov ej.lpszClassName, OFFSET NomeClasse
invoke RegisterClassEx, ADDR ej
gerenteJanela endp
Criando a janela
Se a nossa classe foi aceita pelo sistema para registro, isto significa que possuímos um "alvará de construção". Podemos criar quantos objetos quisermos usando a classe registrada como modelo. Registra-se apenas uma vez, usa-se quantas vezes forem necessárias.
A função CreateWindowEx
A função para criar uma janela de acordo com a classe que registramos é do grupo Ex, ou seja, CreateWindowEx (WNDCLASSEX -> RegisterClassEx -> CreateWindowEx). Seria CreateWindow caso tivéssemos usado uma estrutura WNDCLASS.
HWND CreateWindowEx(
DWORD dwExStyle,
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam
);
Esta função pede um caminhão de parâmetros (12 ao todo, se você tiver o trabalho de contar). Então, vamos lá:
- dwExStyle: Estilo extra da janela. Este é um parâmetro novo, adicionado ao CreateWindow antigo. Aqui podemos colocar os novos estilos das janelas do Windows 9x, NT e XP. Você pode especificar o estilo de janela comum em dwStyle porém, se você desejar estilos especiais, como janelas sempre no topo, você precisa especificá-los aqui. Usa-se NULL caso estilos extras não sejam requeridos.
- lpClassName: (Requerido) Endereço da string ASCIIZ (string terminada em zero) que contém o nome da classe que serve de modelo para esta janela. A classe pode ser uma que você tenha criado e registrado ou uma classe predefinida do Windows.
- lpWindowName: Endereço da string ASCIIZ que contém o nome da janela. O nome mostrado na barra de título da janela. Se este parâmetro for NULL, a barra de título ficará em branco.
- dwStyle: Estilos da janela. Aqui você pode especificar a aparência da janela. Passar NULL também é aceito mas, neste caso, a janela não terá uma caixa de menu do sistema, botões minimizar-maximizar e botão fechar (a janela não teria muito uso e você teria que usar Alt+F4 para fechá-la). O estilo mais comum é o WS_OVERLAPPEDWINDOW. Um estilo de janela é apenas um bit de flag, portanto, você pode combinar diversos estilos com o operador "or" para obter a aparência desejada. O estilo WS_OVERLAPPEDWINDOW nada mais é do que a combinação dos estilos mais comuns obtido através deste método.
- X, Y: As coordenadas do canto superior esquerdo da janela. Normalmente, estes valores deveriam ser CW_USERDEFAULT, ou seja, você deixa o Windows decidir onde colocar a janela no desktop.
- nWidth, nHeight: A largura e a altura da janela em pixels. Aqui você também pode usar CW_USERDEFAULT e deixar o Windows escolher a largura e a altura apropriadas.
- hWndParent: O manipulador da janela-mãe (se existir). Este parâmetro indica ao Windows se esta janela é uma janela-filha (subordinada) ou algum outro tipo de janela e, se for, qual é a janela-mãe. Este relacionamento é apenas para uso interno do Windows. Se a janela-mãe é destruída, todas as janelas-filhas serão automaticamente destruídas. É realmente simples. Como no nosso exemplo há apenas uma janela, nós especificamos este parâmetro como NULL.
- hMenu: Um manipulador para o menu da janela. NULL se for para usar a classe menu já definida na classe da janela. Dê novamente uma olhada no membro lpszMenuName da estrutura WNDCLASSEX. Este membro especifica o menu *default* para a classe. Toda janela criada a partir desta classe terá o mesmo menu por default, a não ser que você especifique aqui em hMenu um menu que se sobreponha ao menu default - isto se chamda overriding. hMenu é na verdade um parâmetro com dois objetivos. Se a janela que está sendo criada é do tipo predefinido, como button (botão) ou edit box (caixa de edição), esta janela/controle não pode possuir um menu. Neste caso, o hMenu é usado como identificador (ID) do controle. O Windows distingue se hMenu é realmente um manipulador de menu ou um ID de controle olhando no parâmetro lpClassName. Se for o nome de uma classe predefinida, o hMenu é um ID de controle. Se não for, então é um manipulador do menu da janela.
- hInstance: O manipulador da instância para o módulo do programa que cria a janela.
- lpParam: Um ponteiro opcional para uma estrutura de dados passada para a janela. É usado por janelas MDI para passar os dados de CLIENTCREATESTRUCT. Normalmente este valor é NULL, significando que não há dados sendo passados via CreateWindow(). A janela pode obter o valor deste parâmetro através da chamada da função GetWindowLong.
Chamando a função
É explicação que não acaba mais e tudo isso só para chamar uma funçãozinha! Para todos os parâmetros já temos os valores, exceto para o título da janela. Este vocês já tiram de letra: basta inicializar uma variável na seção .DATA. Também vamos precisar do valor de retorno da função CreateWindowEx, que é o manipulador da instância da janela que acabamos de criar. Sem este manipulador, ou seja, sem o número identificador desta janela recém criada, não teremos como acessá-la. Como vamos precisar deste manipulador apenas no âmbito da função gerenteJanela, podemos declarar uma variável LOCAL para armazená-lo.
...
.DATA
NomeClasse db "JanelaNua",0
TituloJanela db "Janelinha NumaBoa",0
...
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
mov ej.cbSize, SIZEOF WNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWndProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
invoke LoadIcon, NULL, IDI_WINLOGO
mov ej.hIcon, eax
mov ej.hIconSm, eax
invoke LoadCursor, NULL, IDC_ARROW
mov ej.hCursor, eax
mov ej.hbrBackground, COLOR_WINDOW+1
mov ej.lpszMenuName, NULL
mov ej.lpszClassName, OFFSET NomeClasse
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
gerenteJanela endp
Você deve estar pensando "até que enfim a janela está na tela"... ledo engano. A janela foi criada (a "casa foi construída"), está prontinha para uso, só que ninguém contou ao sistema que é para abrí-la ao público.
Pilotando a janela
Planta da casa elaborada, planta registrada, casa construída... é hora de inaugurá-la.
Vamos mostrar nossa janela no desktop com a função ShowWindow
BOOL ShowWindow(
HWND hWnd, // manipulador da janela
int nCmdShow // modo de apresentação
);
adicionando-a ao nosso código:
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
...
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
invoke ShowWindow, mJanela, SW_SHOWNORMAL
gerenteJanela endp
Atualizando a janela
Pode-se chamar UpdateWindow para refazer a pintura da área cliente da nossa janela. Esta função é útil quando se quer atualizar o conteúdo da área cliente. Esta chamada pode ser omitida, sem problemas... mas sempre é bom garantir. E, já que estamos garantindo algumas coisas, também vamos providenciar o retorno da função gerenteJanela para a área do procedimento chamador. O mnemônico ret garante esta volta.
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
...
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
invoke ShowWindow, mJanela, SW_SHOWNORMAL
invoke UpdateWindow, mJanela
ret
gerenteJanela endp
Estrutura das mensagens
Se interrompermos nosso código neste ponto, teremos uma surpresa: executando o programa, nossa linda janelinha é mostrada no desktop uma fração de segundo e desaparece. Faça o teste: Clique no item de menu do QEditor [Project / Assemble & Link] para criar o executável e depois em [Project / Run Program].
O que falta é um trechinho de código cuja função é a de manter a janela no desktop e, o que é mais importante, fazer com que ela saiba o que acontece com ela.
Imagine o seguinte: quem controla todos os eventos que ocorrem com esta janela é o Windows. Aliás, o Windows tem uma espécie de central que controla todos os eventos referentes a todas as janelas. É como se fosse uma agência de correio onde cada instância de janela possui sua caixa postal. Quando o gerente da janela solicita sua correspondência, a agência lhe envia um malote com a mensagem recebida - uma atrás da outra e sempre a primeira da fila - inclusive com o número da mensagem e a hora! O gerente da janela confere o recebimento e envia a mensagem para o gerente de mensagens. O gerente de mensagens da janela pode responder a mensagem a seu modo (ao nosso modo 
) ou pode devolvê-la para o remetente (o Windows) e deixar que ele processe a mensagem de acordo com as regras do sistema (procedimento padrão). Observação: no sistema Windows, o gerente de mensagens é conhecido como window procedure.
Ainda bem que a "agência de correio" cuida da correspondência da nossa janela. Só precisamos contratar os gerentes e fornecer o malote. O malote traz diversas informações que podem ser agrupadas, portanto o ideal é usar uma estrutura. A estrutura utilizada como "malote" é a MSG:
typedef struct tagMSG { // msg
HWND hwnd;
UINT message;
WPARAM wParam;
LPARAM lParam;
DWORD time;
POINT pt;
} MSG;
Os membros que constituem a estrutura MSG são:
- hwnd: Identifica a janela cujo procedimento de janela (nosso gerenteMensagem) recebe a mensagem.
- message: Especifica o número da mensagem.
- wParam: Informação adicional sobre a mensagem. O sentido exato depende do valor do membro mensagem.
- lParam: Informação adicional sobre a mensagem. O sentido exato depende do valor do membro mensagem.
- time: A hora que a mensagem foi enviada.
- pt: A posição do cursor, em coordenadas de janela, quando a mensagem foi enviada.
Pois bem, então vamos criar o "malote" da nossa janela:
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
LOCAL malote:MSG
...
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
invoke ShowWindow, mJanela, SW_SHOWNORMAL
invoke UpdateWindow, mJanela
ret
gerenteJanela endp
Solicitando e enviando mensagens
O gerente da janela solicita o envio de um "malote" com uma mensagem através da função GetMessage:
BOOL GetMessage(
LPMSG lpMsg, // endereço da estrutura com a mensagem
HWND hWnd, // manipulador da janela
UINT wMsgFilterMin, // primeira messagem
UINT wMsgFilterMax // última messagem
);
Existem algumas mensagens que chegam à "agência de correio" com características especiais. São como cartas registradas ou SEDEX: não podem ser entregues via caixa postal ou malote. Se usarmos o manipulador da janela (no exemplo, mJanela) como parâmetro hWnd da função GetMessage, apenas as "cartas normais" serão entregues. Se quisermos obter todas as mensagens, as "normais" E as "especiais", passamos este parâmetro como NULL.
Se não quisermos selecionar nossa correspondência (não queremos filtrar mensagens), passamos os parâmetros wMsgFilterMin e wMsgFilterMax como zero e a "agência" entregará TODAS as mensagens.
Se a função mandar um "malote" ao gerente de mensagens contendo a mensagem WM_QUIT, o valor de retorno será zero; caso contrário, o valor de retorno será diferente de zero. Se ocorrer um erro, o valor de retorno será -1 (por exemplo, quando o manipulador da janela não for válido).
Como já foi dito anteriormente, o Windows controla todos os eventos referentes a todas as janelas, inclusive os relativos à janela que acabamos de criar: a janela foi ativada, o cursor do mouse passou sobre ela, clique do mouse, tecla pressionada, janela minimizada, maximizada... tudo e mais alguma coisa gera uma mensagem. Dê uma olhada na referência da API do Windows e procure por WM_ (vem de Windows Message). Existe uma quantidade enorme de tipos de mensagens.
Caso a mensagem seja referente a uma tecla que foi pressionada, ela vem com um código de varredura do teclado. É muito chato trabalhar com estes códigos - mais fácil é trabalhar com o ASCII da tecla. Existe uma função que transforma uma mensagem WM_KEYDOWN (código de varredura) em uma mensagem WM_CHAR (código ASCII). É a função TranslateMessage:
BOOL TranslateMessage(
CONST MSG *lpMsg // endereço da estrutura com a mensagem (o "malote")
);
Para o gerente da janela mandar a mensagem ao gerente de mensagens, usamos a função DispatchMessage:
LONG DispatchMessage(
CONST MSG *lpmsg // endereço da estrutura com a mensagem (o "malote")
);
Loop infinito
Bem, então vamos ao trabalho. Queremos que nosso gerente de janela, depois de tudo que já fez, fique o tempo todo solicitando, conferindo e mandando suas mensagens para o gerente de mensagens. Para isto faremos uso de macros de pseudo alto nível do MASM: .WHILE, .BREAK e .IF
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
LOCAL malote:MSG
...
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
invoke ShowWindow, mJanela, SW_SHOWNORMAL
invoke UpdateWindow, mJanela
.WHILE TRUE
invoke GetMessage, ADDR malote, NULL, 0, 0
.BREAK .IF (eax < 1)
invoke TranslateMessage, ADDR malote
invoke DispatchMessage, ADDR malote
.ENDW
ret
gerenteJanela endp
Trocando em miúdos, este trecho de código diz o seguinte:
enquanto (.WHILE) verdadeiro (TRUE)
chame MandeMessagem, pelo malote, mensagens normais e especiais, sem filtro, sem filtro
páre (.BREAK) se (.IF) o valor de retorno for menor que 1
chame TraduzaMensagem, do malote
chame DespacheMensagem, do malote
fim do enquanto (.ENDW)
Este loop infinito só é interrompido quando o valor de retorno de GetMessage for 0 ou -1 (ou seja, menor que 1). Quando é 0, a mensagem recebida foi WM_QUIT e o programa deve ser encerrado. O valor -1 indica erro e o melhor é... também terminar ao invés de dar pau.
Saindo do loop, o gerente da janela ainda deve realizar uma tarefa antes de devolver o controle ao corpo principal do código: deve armazenar o código de saída em eax para devolvê-lo ao Windows. Até o presente momento, o Windows não faz uso deste valor de retorno, mas é melhor agir com segurança e jogar conforme a regra:
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
...
.WHILE TRUE
invoke GetMessage, ADDR malote, NULL, 0, 0
.BREAK .IF (eax < 1)
invoke TranslateMessage, ADDR malote
invoke DispatchMessage, ADDR malote
.ENDW
mov eax, malote.wParam
ret
gerenteJanela endp
Agora o gerente da janela está com todo o seu esquema de trabalho definido. Uma de suas funções é enviar as mensagens recebidas para o gerente de mensagens para que sejam processadas. Então, vamos para a última função...
Processando mensagens recebidas
Agora é a vez do nosso window procedure - o gerente de mensagens. Você pode dar a ele o nome que quiser - não precisa chamá-lo de WindowProc:
LRESULT CALLBACK WindowProc(
HWND hwnd, // manipulador da janela
UINT uMsg, // identificador da mensagem
WPARAM wParam,
LPARAM lParam
);
O primeiro parâmetro, hWnd, é o manipulador da janela para a qual a mensagem é destinada. uMsg é a mensagem. Observe que uMsg NÃO é uma estrutura MSG, é apenas um número identificador. O Windows define centenas de mensagens, a maioria sem maior interesse para o nosso programa, e irá enviar uma mensagem apropriada apenas quando ocorrer um fato relevante para a nossa janela. wParam e lParam são apenas parâmetros extras usados por algumas mensagens que enviam dados acessórios.
No nosso exemplo, vamos chamar o WindowProc de gerenteMensagem:
gerenteMensagem proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
...
gerenteMensagem endp
O gerente de mensagens precisa checar cada mensagem recebida do Windows para verificar se é de interesse. Se for de interesse, deve dar a resposta adequada; se não for, PRECISA chamar DefWindowProc, passando todos os parâmetros que recebeu, para que o processamento default seja efetuado. Esta DefWindowProc é uma função da API que processa as todas as mensagens que não são do interesse do seu programa.
gerenteMensagem proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
invoke DefWindowProc, hWnd, uMsg, wParam, lParam
ret
gerenteMensagem endp
Encerrando o programa
A única mensagem que SEMPRE PRECISA ser respondida é a WM_DESTROY. Esta mensagem é enviada toda vez a janela for fechada - é o sinal de final de expediente. No momento em que esta mensagem é recebida, a janela já foi removida da tela. Esta é apenas uma notificação de que a janela foi destruída e que os "gerentes" devem encerrar o expediente e se liberar do controle do Windows. Ainda há tempo de fazer alguma "ordem no escritório" mas, quando se chegou neste ponto, não há outra opção a não ser terminar. Se você quiser ter uma chance de impedir que o usuário feche a janela, você deve processar a mensagem WM_CLOSE.
gerenteMensagem proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage, NULL
xor eax,eax
ret
.ENDIF
invoke DefWindowProc, hWnd, uMsg, wParam, lParam
ret
gerenteMensagem endp
Bem, voltando à WM_DESTROY... após a eventual "ordem no escritório", o gerente de mensagens precisa chamar PostQuitMessage (a qual remeterá uma mensagem WM_QUIT), zerar o valor do registrador EAX com xor eax,eax ou mov eax,0 e retornar (ret) para o gerente da janela. O gerente da janela vai chamar GetMessage pela última vez, obtendo a mensagem WM_QUIT que acabou de ser enviada pelo gerente de mensagens. GetMessage retorna o valor zero em eax quando recebe WM_QUIT o que, por seu lado, encerra o loop infinito. O gerente da janela se despede enviando o malote.wParam para o Windows e o fluxo do programa volta para o corpo principal para executar a saída do processo chamando ExitProcess.
Código fonte completo
.386
.MODEL FLAT,STDCALL
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib
gerenteJanela proto :DWORD, :DWORD, :DWORD, :DWORD
.DATA?
mInstancia DWORD ?
linhaComando DWORD ?
.DATA
NomeClasse db "JanelaNua",0
TituloJanela db "Janelinha NumaBoa",0
.CODE
inicio:
invoke GetModuleHandle, NULL
mov mInstancia, eax
invoke GetCommandLine
mov linhaComando, eax
invoke gerenteJanela, mInstancia, NULL, linhaComando, SW_SHOWDEFAULT
invoke ExitProcess,0
gerenteJanela proc mInst:DWORD, mInstAnt:DWORD, linhaCmd:DWORD, Mostra:DWORD
LOCAL ej:WNDCLASSEX
LOCAL mJanela:HWND
LOCAL malote:MSG
mov ej.cbSize, SIZEOF WUNDCLASSEX
mov ej.style, CS_HREDRAW or CS_VREDRAW
mov ej.lpfnWdnProc, OFFSET gerenteMensagem
mov ej.cbClsExtra, NULL
mov ej.cbWndExtra, NULL
push mInst
pop ej.hInstance
invoke LoadIcon, NULL, IDI_WINLOGO
mov ej.hIcon, eax
mov ej.hIconSm, eax
invoke LoadCursor, NULL, IDC_ARROW
mov ej.hCursor, eax
mov ej.hbrBackground, COLOR_WINDOW+1
mov ej.lpszMenuName, NULL
mov ej.lpszClassName, OFFSET NomeClasse
invoke RegisterClassEx, ADDR ej
invoke CreateWindowEx, NULL, ADDR NomeClasse, ADDR TituloJanela,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, mInst, NULL
mov mJanela,eax
invoke ShowWindow, mJanela, SW_SHOWNORMAL
invoke UpdateWindow, mJanela
.WHILE TRUE
invoke GetMessage, ADDR malote, NULL, 0, 0
.BREAK .IF (eax < 1)
invoke TranslateMessage, ADDR malote
invoke DispatchMessage, ADDR malote
.ENDW
mov eax, malote.wParam
ret
gerenteJanela endp
gerenteMensagem proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage, NULL
xor eax,eax
ret
.ENDIF
invoke DefWindowProc, hWnd, uMsg, wParam, lParam
ret
gerenteMensagem endp
end inicio
Conferindo o trabalho do MASM
O QEditor não só é capaz de assemblar um código fonte, como também de dessassemblar um executável. Esta opção se encontra no menu [Tools / Dis-assemble EXE file]. Experimente usá-la com o texto deste programa ainda no editor. O QEditor abre uma nova instância dele mesmo e apresentará o seguinte:
:\masm32\ICZTUTES\TUTE03\WIN1.exe (hex) (dec)
.EXE size (bytes) 490 1168
Minimum load size (bytes) 450 1104
Overlay number 0 0
Initial CS:IP 0000:0000
Initial SS:SP 0000:00B8 184
Minimum allocation (para) 0 0
Maximum allocation (para) FFFF 65535
Header size (para) 4 4
Relocation table offset 40 64
Relocation entries 0 0
Portable Executable starts at b0
Signature 00004550 (PE)
Machine 014C (Intel 386)
Sections 0003
Time Date Stamp 3C4CEBF4 Tue Jan 22 01:35:00 2002
Symbol Table 00000000
Number of Symbols 00000000
Optional header size 00E0
Characteristics 010F
Relocation information stripped
Executable Image
Line numbers stripped
Local symbols stripped
32 bit word machine
Magic 010B
Linker Version 5.12
Size of Code 00000200
Size of Initialized Data 00000400
Size of Uninitialized Data 00000000
Address of Entry Point 00001000
Base of Code 00001000
Base of Data 00002000
Image Base 00400000
Section Alignment 00001000
File Alignment 00000200
Operating System Version 4.00
Image Version 0.00
Subsystem Version 4.00
reserved 00000000
Image Size 00004000
Header Size 00000400
Checksum 00000000
Subsystem 0002 (Windows)
DLL Characteristics 0000
Size Of Stack Reserve 00100000
Size Of Stack Commit 00001000
Size Of Heap Reserve 00100000
Size Of Heap Commit 00001000
Loader Flags 00000000
Number of Directories 00000010
Directory Name VirtAddr VirtSize
Export 00000000 00000000
Import 00002040 0000003C
Resource 00000000 00000000
Exception 00000000 00000000
Security 00000000 00000000
Base Relocation 00000000 00000000
Debug 00000000 00000000
Decription/Architecture 00000000 00000000
Machine Value (MIPS GP) 00000000 00000000
Thread Storage 00000000 00000000
Load Configuration 00000000 00000000
Bound Import 00000000 00000000
Import Address Table 00002000 00000040
Delay Import 00000000 00000000
COM Runtime Descriptor 00000000 00000000
(reserved) 00000000 00000000
Section Table
01 .text Virtual Address 00001000
Virtual Size 00000196
Raw Data Offset 00000400
Raw Data Size 00000200
Relocation Offset 00000000
Relocation Count 0000
Line Number Offset 00000000
Line Number Count 0000
Characteristics 60000020
Code
Executable
Readable
02 .rdata Virtual Address 00002000
Virtual Size 000001C2
Raw Data Offset 00000600
Raw Data Size 00000200
Relocation Offset 00000000
Relocation Count 0000
Line Number Offset 00000000
Line Number Count 0000
Characteristics 40000040
Initialized Data
Readable
03 .data Virtual Address 00003000
Virtual Size 00000024
Raw Data Offset 00000800
Raw Data Size 00000200
Relocation Offset 00000000
Relocation Count 0000
Line Number Offset 00000000
Line Number Count 0000
Characteristics C0000040
Initialized Data
Readable
Writeable
Imp Addr Hint Import Name from USER32.dll - Not Bound
00002010 19B LoadIconA
00002014 1DD PostQuitMessage
00002018 128 GetMessageA
0000201C 94 DispatchMessageA
00002020 27D TranslateMessage
00002024 28B UpdateWindow
00002028 197 LoadCursorA
0000202C 83 DefWindowProcA
00002030 58 CreateWindowExA
00002034 1EF RegisterClassExA
00002038 265 ShowWindow
Imp Addr Hint Import Name from KERNEL32.dll - Not Bound
00002000 111 GetModuleHandleA
00002004 B6 GetCommandLineA
00002008 75 ExitProcess
IAT Entry
00000000: 000021A0 0000218E - 00002180 00000000 - 00002110 0000211C
00000018: 000020F4 000020E0 - 00002150 00002164 - 00002102 000020CE
00000030: 000020BC 0000212E - 00002142 00000000
Disassembly
00401000 start:
00401000 6A00 push 0
00401002 E889010000 call fn_00401190
00401007 A31C304000 mov [40301Ch],eax
0040100C E879010000 call fn_0040118A
00401011 A320304000 mov [403020h],eax
00401016 6A0A push 0Ah
00401018 FF3520304000 push dword ptr [403020h]
0040101E 6A00 push 0
00401020 FF351C304000 push dword ptr [40301Ch]
00401026 E806000000 call fn_00401031
0040102B 50 push eax
0040102C E853010000 call fn_00401184
00401031 fn_00401031: ; o nosso gerenteJanela
00401031 55 push ebp
00401032 8BEC mov ebp,esp
00401034 83C4B0 add esp,0FFFFFFB0h
00401037 C745D030000000 mov dword ptr [ebp-30h],30h
0040103E C745D403000000 mov dword ptr [ebp-2Ch],3
00401045 C745D816114000 mov dword ptr [ebp-28h],401116h
0040104C C745DC00000000 mov dword ptr [ebp-24h],0
00401053 C745E000000000 mov dword ptr [ebp-20h],0
0040105A FF7508 push dword ptr [ebp+8]
0040105D 8F45E4 pop [ebp-1Ch]
00401060 68057F0000 push 7F05h
00401065 6A00 push 0
00401067 E8F4000000 call fn_00401160
0040106C 8945E8 mov [ebp-18h],eax
0040106F 8945FC mov [ebp-4],eax
00401072 68007F0000 push 7F00h
00401077 6A00 push 0
00401079 E8DC000000 call fn_0040115A
0040107E 8945EC mov [ebp-14h],eax
00401081 C745F006000000 mov dword ptr [ebp-10h],6
00401088 C745F400000000 mov dword ptr [ebp-0Ch],0
0040108F C745F800304000 mov dword ptr [ebp-8],403000h
00401096 8D45D0 lea eax,[ebp-30h]
00401099 50 push eax
0040109A E8CD000000 call fn_0040116C ; registra a classe
0040109F 6A00 push 0
004010A1 FF7508 push dword ptr [ebp+8]
004010A4 6A00 push 0
004010A6 6A00 push 0
004010A8 6800000080 push 80000000h
004010AD 6800000080 push 80000000h
004010B2 6800000080 push 80000000h
004010B7 6800000080 push 80000000h
004010BC 680000CF00 push 0CF0000h
004010C1 680A304000 push 40300Ah
004010C6 6800304000 push 403000h
004010CB 6A00 push 0
004010CD E870000000 call fn_00401142 ; cria a janela
004010D2 8945B0 mov [ebp-50h],eax
004010D5 6A01 push 1
004010D7 FF75B0 push dword ptr [ebp-50h]
004010DA E893000000 call fn_00401172 ; mostra a janela
004010DF FF75B0 push dword ptr [ebp-50h]
004010E2 E897000000 call fn_0040117E
004010E7 loc_004010E7: ; o loop infinito do gerenteJanela
004010E7 6A00 push 0
004010E9 6A00 push 0
004010EB 6A00 push 0
004010ED 8D45B4 lea eax,[ebp-4Ch]
004010F0 50 push eax
004010F1 E85E000000 call fn_00401154
004010F6 83F801 cmp eax,1
004010F9 7214 jb loc_0040110F
004010FB 8D45B4 lea eax,[ebp-4Ch]
004010FE 50 push eax
004010FF E874000000 call fn_00401178
00401104 8D45B4 lea eax,[ebp-4Ch]
00401107 50 push eax
00401108 E841000000 call fn_0040114E ; chama o gerenteMensagem
0040110D EBD8 jmp loc_004010E7
0040110F loc_0040110F: ; o nosso gerenteMensagem
0040110F 8B45BC mov eax,[ebp-44h]
00401112 C9 leave
00401113 C21000 ret 10h
00401116 55 push ebp
00401117 8BEC mov ebp,esp
00401119 837D0C02 cmp dword ptr [ebp+0Ch],2
0040111D 750D jnz loc_0040112C
0040111F 6A00 push 0
00401121 E840000000 call fn_00401166
00401126 33C0 xor eax,eax
00401128 C9 leave
00401129 C21000 ret 10h
0040112C loc_0040112C:
0040112C FF7514 push dword ptr [ebp+14h]
0040112F FF7510 push dword ptr [ebp+10h]
00401132 FF750C push dword ptr [ebp+0Ch]
00401135 FF7508 push dword ptr [ebp+8]
00401138 E80B000000 call fn_00401148
0040113D C9 leave
0040113E C21000 ret 10h
00401141 CC int 3
00401142 fn_00401142:
00401142 FF2530204000 jmp dword ptr [CreateWindowExA]
00401148 fn_00401148:
00401148 FF252C204000 jmp dword ptr [DefWindowProcA]
0040114E fn_0040114E:
0040114E FF251C204000 jmp dword ptr [DispatchMessageA]
00401154 fn_00401154:
00401154 FF2518204000 jmp dword ptr [GetMessageA]
0040115A fn_0040115A:
0040115A FF2528204000 jmp dword ptr [LoadCursorA]
00401160 fn_00401160:
00401160 FF2510204000 jmp dword ptr [LoadIconA]
00401166 fn_00401166:
00401166 FF2514204000 jmp dword ptr [PostQuitMessage]
0040116C fn_0040116C:
0040116C FF2534204000 jmp dword ptr [RegisterClassExA]
00401172 fn_00401172:
00401172 FF2538204000 jmp dword ptr [ShowWindow]
00401178 fn_00401178:
00401178 FF2520204000 jmp dword ptr [TranslateMessage]
0040117E fn_0040117E:
0040117E FF2524204000 jmp dword ptr [UpdateWindow]
00401184 fn_00401184:
00401184 FF2508204000 jmp dword ptr [ExitProcess]
0040118A fn_0040118A:
0040118A FF2504204000 jmp dword ptr [GetCommandLineA]
00401190 fn_00401190:
00401190 FF2500204000 jmp dword ptr [GetModuleHandleA]
Download
Você pode fazer o download de tutNB03.zip que contém o texto deste tutorial, além do código fonte e do executável ou ir para a seção Downloads/Tutoriais/Assembly Numaboa onde você encontra este e outros zips de tutoriais.