Clique em |Design|Open/New|, abra "espiaores.h", expanda "menu" e dê um duplo clique em IDMAINMENU para abrir o editor de menus. Expanda "&File" e clique em "&New": este item está identificado por IDM_NEW e possui o valor 200. Troque &New por &Farejar e clique em [Apply] (eu aproveitei e mudei &File para &Espião, &E&xit para &Sair e eliminei o item de menu &Open). Feche o editor de menu e o editor de recursos.

O item de menu &Farejar continuou com a IDentificação IDM_NEW. É esta ID que precisamos interceptar para que a caçada seja iniciada. Acontece que o menu possui uma central de mensagens própria, a função MainWndProc_OnCommand. Como, para popular a árvore, já é possível prever que será necessário um trecho de código mais elaborado, vamos novamente usar a técnica do "top-down" e inserir uma chamada a uma função. Chamei esta função de criaTree (linhas 5 a 7):

Criando itens da árvore

O código da função, chamada através do item de menu "Farejar", que é interceptada em MainWndProc_OnCommand, inicialmente "fareja" a janela do desktop (ou área de trabalho do Windows). Depois disto, o procedimento relaciona todas as janelas-filhas da janela encontrada. Duas direções precisam ser exploradas: as janelas-filhas de uma dada janela e as janelas-irmãs de uma dada janela.

A função criaTree é chamada com o parâmetro manipulador da janela-mãe. Ela começa requisitando ao Windows o manipulador da janela do desktop e armazenando este valor na variável do tipo HWND Inicio. Como também vamos precisar do manipulador da janela da árvore, armazenamos seu valor na variável do tipo HWND hTree que nos é retornada pela função GetDlgItem. A seguir, manifestamos a estrutura itemTree. Este tipo de estrutura está assim definido no Windows:

Como cada nó da estrutura hierárquica da árvore também possui um manipulador próprio (o que é que não tem manipulador no Windows?), manifestamos a variável do tipo HTREEITEM hNovoNo.

É comum jogar estruturas para uma área da memória e referenciá-las através de ponteiros. Com a estrutura itemTree não vai ser diferente, mas para garantir que a área de memória esteja "limpinha", zeramos todos os bits com a chamada da função da linguagem C memset. Os parâmetros são o ponteiro para a área de memória onde está a estrutura (&itemTree), o valor de preenchimento (0) e o tamanho da estrutura ( sizeof(itemTree) ).

Tudo sob controle, começamos a atribuir valores para os campos da estrutura que nos interessam:

• itemTree.hParent = TVI_ROOT indica que se trata de um item raiz (o valor de TVI_ROOT é definido no Windows como -65536). Obtemos o mesmo resultado se atribuirmos NULL a este campo.
• itemTree.hInsertAfter = TVI_LAST indica que o item deve ser adicionado no final da lista (LAST = último). Outros valores possíveis são TVI_FIRST (inserir no começo da lista, pois a tradução de FIRST é primeiro) e TVI_SORT (inserir o item em ordem alfabética. SORT = ordenar).
• TV_ITEM é uma estrutura aninhada e contém muitos campos. Destes, foram escolhidos apenas dois:
• itemTree.item.mask = TVIF_TEXT | TVIF_PARAM. O valor TVIF_TEXT indica que o campo pszText desta estrutura aninhada é válido e o valor TVIF_PARAM indica que o campo lParam da estrutura aninhada é válido.
• itemTree.item.pszText = "Desktop" atribui a string "Desktop" ao campo lpzText.

Depois de atribuir os valores aos campos, chamamos a macro do Windows TreeView_InsertItem, que pede como parâmetros o manipulador da árvore e um ponteiro para a estrutura que especifica os atributos do item, e que retorna (dou-lhe uma, dou-lhe duas, dou-lhe três...) o manipulador do novo item se tudo correr bem; caso contrário, retorna NULL.

Tudo prontinho, chamamos a função Scan (discutida abaixo) para caçar as janelas existentes. De posse de todos os nós da árvore (a função criaTree prepara o raiz e a função Scan os nós restantes), chamamos a macro TreeView_Expand para mostrar a árvore completa.

Bem, depois de todas estas explicações, acho que já é possível inserir o código acima no seu programa... o susto não vai mais ser tão grande. Não se esqueça, programador profissional faz protótipo de função, então:

Farejando as janelas

Agora é a hora de rastrear as janelas-filhas e janelas-irmãs. Como o desktop é a janela raiz de todas as janelas e não possui janelas-irmãs, toca achar as janelas-filhas. A função GetWindow é perfeita, retornando (dou-lhe uma, dou-lhe duas...) o manipulador da primeira janela-filha. Depois a coisa fica um pouco mais elaborada e merece novamente uma função própria. Chamei-a de Scan porque ela vai "escanear" e povoar nossa árvore com dados:

Analisando o loop criado com while (hwnd != NULL), que diz "enquanto(hwnd não for NULL)", verificamos que a função Scan é chamada recursivamente enquanto existirem janelas-irmãs. Os passos são:

1. Enviamos a mensagem WM_GETTEXT (pegue o texto) através da chamada à função SendMessage para obter o texto da janela em questão. O texto é armazenado no array de caracteres bufTxt manifestado acima.
2. Obtemos o nome da classe da janela com GetClassName. O nome da classe é armazenado no array de caracteres NomeClasseBuf manifestado acima.
3. Formatamos o texto da janela e o nome da classe com a função da linguagem C wsprintf e colocamos o resultado na variável Saida, também um array de caracteres manifestado acima.
4. Limpamos a área de memória reservada para a estrutura novoItemTree, do tipo TV_INSERTSTRUCT.
5. Atribuímos valores a determinados campos da estrutura TV_INSERTSTRUCT, da mesma forma como foi descrito para a janela do desktop.
6. Criamos um novo nó na árvore contendo as informações da estrutura.
7. Neste ponto, verificamos se a janela em questão possui janelas-filhas com GetWindow e GW_CHILD. Se possuir, chamamos recursivamente a função Scan para popular a árvore com esta(s) janela(s).
8. Obtemos o manipulador da próxima janela-irmã com GetWindow e GW_HWNDNEXT. Se houver uma nova janela, o loop é repetido, caso contrário, é encerrado.

Mostrando os troféus

Salve o código fonte. Compile e execute o projeto espião. Clique em |Farejar| para mostrar o resultado da caça. Espantoso! Só que, se clicarmos algumas vezes em |Farejar|, uma porção de nós repetidos vão aparecer. É melhor dar uma conferida

Analisando melhor a função criaTree percebemos que sempre adicionamos nós no fim da lista mas... nunca limpamos a árvore. Taí. É preciso começar a popular uma árvore "zerada". Além disto, a árvore é redesenhada a cada novo nó adicionado. Soma-se ao trabalho desnecessário uma imagem que fica tremendo. Mas é tudo coisa pouca, fácil de corrigir (linhas 7, 8 e 17):

A função SendMessage com os parâmetros WM_SETREDRAW e 0 (zero) desliga a atualização de tela, ou seja, a imagem fica "congelada". A seguir, a macro TreeView_DeleteAllItems apaga todos os nós da árvore - o usuário não percebe nada porque ele continua vendo a imagem anterior (que foi congelada). Se é assim, podemos continuar populando a árvore tranquilamente sem que a imagem seja redesenhada toda santa vez que um novo nó for adicionado . Nos finalmentes, ativamos novamente a atualização de tela com a mesma função SendMessage, só que com os parâmetros WM_SETREDRAW e 1.

Yeeees. Você já sabe, é salvar, compilar e executar. O resultado deve ser algo parecido com

Observações da vó

O programa espião não é uma obra perfeitamente acabada, mas até que está legal. Mais legal ainda é ter servido de exemplo para dar uma idéia do potencial da programação com a linguagem C para o sistema operacional Windows. C é uma linguagem especialmente robusta e flexível, ideal para se programar qualquer tipo de sistema operacional. E o Linux está precisando de bons programadores...

Bão, filosofias à parte, esta seqüência de tutoriais ainda tem um para reforçar os conceitos de eventos e mensagens. Vamos colocar informações referentes às janelas "caçadas" na barra de status. Quer saber como? Vá para Linguagem C - Projeto Espião III.