Capítulo 13 Scripting Quicktest Professional Page 1

API WINDOWS 32................................................................................................................... 1

O QUE É API?........................................................................................................................ 2
MODELOSDEDESIGN............................................................................................................... 2
POLÍTICAS DE LIBERAÇÃO............................................................................................................ 3
EXEMPLOS DE API................................................................................................................. 3
A API DO WINDOWS ............................................................................................................... 4
ARQUIVOS DLL (DYNAMICLINKLIBRARY)................................................................................. 4
FUNDAMENTOS DO ADLL
FUNDO
HISTÓRIA
MENSAGENSWINDOWS
MANIPULADORES_DE_JANELA.............................................................................................................. 7
VISÃO GERAL DOS COMPONENTES DA API WINDOWS................................................................ 7
SERVIÇOS BASE................................................................................................................ 7
INTERFACEDEDISPOSITIVOGRÁFICO.......................................................................................... 7
INTERFACE DO USUÁRIO
BIBLIOTECADADIALOGOCOMUM...................................................................................... 8
BIBLIOTECA DE CONTROLE COMUM........................................................................................... 8
SHELLWINDOWS.............................................................................................................. 8
SERVIÇOS DE REDE......................................................................................................... 9
WEBAPIS......................................................................................................................... 9
APIs RELACIONADAS A MULTIMÍDIA............................................................................................ 9
APIs PARA INTERAÇÃO ENTRE PROGRAMAS................................................................. 10
FERRAMENTAS WINDOWSAPI......................................................................................................... 11
VISUALIZADOR DE API................................................................................................................... 11
OOBJETOEEXTERNO.......................................................................................................... 12
LIMITAÇÕES USANDO O OBJETO EXTERNO....................................................................... 12
CONVERTENDO [Link]................................................................................ 13
Exemplo 1: Função GetPrivateProfileString............................................................... 13
Exemplo 2: Função GetServiceKeyName................................................................... 15
DESTAQUES PARA A API WIN32 NO QUICKTEST................................................................... 17
Passando Parâmetros para funções da API Win32................................................................. 18
Funções de Retorno de Chamada....................................................................................................... 19
Interagindo com um arquivo dll personalizado .................................................................................. 19
OOBJETOEXTERNO........................................................ERRO! MARCADOR NÃO DEFINIDO.
APÊNDICE 13.A .................................................................................................................... 19
Declara tipos de dados...................................................................................................... 22

API do Windows 32

Este tutorial é sobre como adicionar funcionalidades adicionais às suas aplicações por meio de
usando a Interface de Programação Avançada do Windows.
A API do Windows (Interfaces de Programação de Aplicativos) é um conjunto de pré-definidos

Funções do Windows usadas para controlar a aparência e o comportamento de cada Windows

elemento (da perspectiva da janela do desktop à alocação de memória para um
novo processo). Cada ação do usuário causa a execução de vários ou mais APIs

Dani Vainstein Win32API Página 1 de 22

 Capítulo 13 Scripting Quicktest Professional Page 2

função informando ao Windows o que aconteceu.

É algo como o código nativo do Windows. Outras linguagens apenas agem como um
shell para fornecer uma maneira automatizada e mais fácil de acessar APIs.

QuickTest suporta uma linguagem de desenvolvimento VBScript e sua funcionalidade pode

ser estendido de duas maneiras. A primeira maneira é usando controles personalizados. Estes são
componentes de software que são facilmente incorporados em scripts QTP/VBS. Existem
controles personalizados para quase qualquer tarefa imaginável, incluindo análise numérica,
reconhecimento de fala, suporte a imagem e documentos. Controles personalizados são chamados
Ocx’s.
A segunda maneira, o QuickTest pode ser estendido é através do WindowsApplication
Interface de Programação de Aplicações (API), usando o objeto Extern. As funções da API não são
suportado em VBScript.

O que é API?

Uma interface de programação de aplicativos (API) é uma interface de código fonte que um
sistema de computador ou biblioteca de programa fornece para suportar solicitações por
serviços a serem feitos por um programa de computador.
Uma API difere de uma Interface Binária de Aplicação na medida em que é especificada em termos de
uma linguagem de programação que pode ser compilada quando um aplicativo é construído, em vez de
do que uma descrição explícita de baixo nível de como os dados estão dispostos na memória.

O software que fornece a funcionalidade descrita por uma API é dito ser um
implementação da API. A própria API é abstrata, pois especifica um
interface e não se envolve com os detalhes de implementação.
Uma API é frequentemente parte de um kit de desenvolvimento de software (SDK).
O termo API é usado em dois sentidos relacionados:
Uma interface coerente composta por várias classes ou vários conjuntos relacionados
funções ou procedimentos.
Um único ponto de entrada, como um método, função ou procedimento.
Em termos gerais, uma API é um software de sistema para um sistema operacional ou
ambiente, que consiste em um conjunto padronizado de funções e procedimentos.
Os programadores podem chamar essas funções e procedimentos de seus programas para obter
funcionalidade extra. Porque os programadores não precisam escrever esse código
eles mesmos, economizam tempo. O sistema também fornece um padrão e bem
forma documental de trabalho

Modelos de Design

Existem vários modelos de design para APIs. Interfaces destinadas ao mais rápido
a execução muitas vezes consiste em conjuntos de funções, procedimentos, variáveis e dados
estruturas. No entanto, outros modelos também existem - como o intérprete usado para
avalie expressões no ECMAScript/JavaScript ou na camada de abstração - qual
aliviar o programador da necessidade de saber como as funções da API se relacionam
para os níveis mais baixos de abstração. Isso torna possível redesenhar ou melhorar
as funções dentro da API sem quebrar o código que depende dela.
Algumas APIs, como as que são padrão de um sistema operacional, são implementadas

Dani Vainstein Win32API Página 2 de 22

 Capítulo 13 Scripting Quicktest Professional Page 3

como bibliotecas de código separadas que são distribuídas com o sistema operacional. Outros
exigir que os editores de software integrem a funcionalidade da API diretamente no
aplicação. Isso forma outra distinção nos exemplos acima. Microsoft
As APIs do Windows vêm com o sistema operacional para que qualquer pessoa possa usar. Software para
sistemas embarcados, como consoles de videogame, geralmente se enquadram em
categoria integrada ao aplicativo. Embora um documento oficial da API do PlayStation possa ser
interessante de ler, é de pouca utilidade sem sua correspondente implementação, em
a forma de uma biblioteca separada ou kit de desenvolvimento de software.

Uma API que não requer royalties para acesso e uso é chamada de "aberta".
Embora geralmente existam 'implementações de referência' autoritativas para uma API (que
como o Microsoft Windows para a API Win32), não há nada que impeça o
criação de implementações adicionais. Por exemplo, a maioria da API Win32 pode
ser fornecido sob um sistema UNIX usando um software chamado Wine.

Políticas de Lançamento

Duas diretrizes gerais de políticas de publicação de API:

Algumas empresas guardam zelosamente as informações sobre suas APIs do público geral.
consumo. Por exemplo, a Sony costumava fazer sua API oficial do PlayStation 2
disponível apenas para desenvolvedores licenciados da PlayStation. Isso permitiu que a Sony controlasse quem
escreveu jogos para PlayStation 2. Esse controle pode ter benefícios de controle de qualidade e
potencial receita de licenciamento.

Algumas empresas disponibilizam suas APIs gratuitamente. Por exemplo, a Microsoft disponibiliza
a maior parte das informações da sua API são públicas, para que software seja escrito para o Windows
plataforma.
As empresas baseiam sua escolha de política de publicação na maximização do benefício para elas.

Exemplos de API

A interface de chamada BIOS do PC

Especificação UNIX Única (SUS)
API Win32 da Microsoft
APIs da Plataforma Java, Edição Empresarial
ASPI para interface de dispositivo SCSI
Carbon e Cocoa para o Macintosh OS
API multiplataforma OpenGL
DirectX para Microsoft Windows
Camada de Mídia Direta Simples (SDL)
API Universal Home
Interface de Programa de Aplicação LDAP
svgalib para Linux e FreeBSD
API do Google Maps
API da Wikipédia
[Link] O Diretório Aberto para Mashups e APIs Web 2.0

Dani Vainstein Win32API Página 3 de 22

 Capítulo 13 Scripting Quicktest Professional Page 4

A API do Windows

As funções da API residem em DLLs (como [Link], [Link], [Link], ...) no

Diretório do sistema Windows.
A API do Windows é o nome dado pela Microsoft ao conjunto principal de aplicativos
interfaces de programação disponíveis nos sistemas operacionais Microsoft Windows.
é projetado para uso por programas C/C++ e é a maneira mais direta de interagir
com um sistema Windows para aplicações de software. Acesso em nível inferior a um
sistema Windows

A O Software Development Kit (SDK) está disponível para Windows, que fornece
documentação e ferramentas para permitir que os desenvolvedores criem software usando o
API do Windows e tecnologias de janelas associadas.

A API do Windows é o conjunto de funções e procedimentos disponíveis no Windows.

Eles podem ser usados por todos os tipos de programadores. Mercury adicionou o acesso à API
interface incluindo aqueles que trabalham no QuickTest.

A funcionalidade mais frequentemente requisitada da API do Windows já existe no

Ambiente de desenvolvimento básico do VBScript. A maioria das funções da API e
procedimentos que não foram incluídos no VBScript podem ainda ser chamados de
oAplicativoQuickTest. A pequena porcentagem que não pode, raramente é necessária.

Arquivos DLL (Biblioteca de Vínculo Dinâmico)

Biblioteca de vínculo dinâmico (DLL), também conhecida como biblioteca de vínculo dinâmico (sem o
hífen), é a implementação da Microsoft do conceito de biblioteca compartilhada na
Sistemas operacionais Microsoft Windows. Essas bibliotecas geralmente têm o arquivo
extensionDLL, OCX (para bibliotecas que contêm controles ActiveX) ou DRV (para legado)
drivers do sistema).

DynamicLinkLibrary, uma biblioteca de funções executáveis ou dados que podem ser usados
por um aplicativo do Windows. Normalmente, um DLL fornece um ou mais específicos
funções e um programa acessa as funções criando uma estática ou
link dinâmico para o DLL. Um link estático permanece constante durante a execução do programa
enquanto um link dinâmico é criado pelo programa conforme necessário. DLLscan também pode conter
apenas dados. Arquivos DLL geralmente terminam com a extensão .dll, .exe, drv ou .fon. ADLL
pode ser utilizado por várias aplicações ao mesmo tempo. Alguns DLLs são fornecidos
com o sistema operacional Windows e disponível para qualquer aplicativo do Windows.
OutrasDLLs são escritas para uma aplicação específica e são carregadas com o
aplicação.

Fundamentos de uma DLL

Mencionamos que um aDLL é criado como um projeto que contém pelo menos um
arquivo de origem e este arquivo de origem deve apresentar um ponto de entrada. Após a criação do
DLL, você irá construir e distribuir para que outros programas possam usá-la. Ao construí-la,
você deve criar um arquivo de biblioteca que acompanhará o DLL. Este arquivo de biblioteca será
usado por outros programas para importar o que está disponível na DLL:

Dani Vainstein Win32API Página 4 de 22

 Capítulo 13 Scripting Quicktest Professional Page 5

Quando a biblioteca de importação é criada, ela contém informações sobre onde cada um
a função disponível está incluída no DLL e pode localizá-la. Quando um aplicativo
precisa usar uma função contida na DLL, apresenta seu pedido à importação
biblioteca. A biblioteca de importação verifica o DLL para essa função. Se a função existir,
o programa cliente pode usá-lo. Se não o fizer, a biblioteca comunica isso ao
o aplicativo e o aplicativo apresenta um erro.

Fundo

O propósito original dos DLLs era economizar tanto espaço em disco quanto a memória necessária.
para aplicações armazenando-o localmente no disco rígido. Em um não convencional
biblioteca compartilhada, seções de código são simplesmente adicionadas ao programa chamador. Se dois
os programas chamam a mesma rotina, esse código seria duplicado. Em vez disso, qualquer código
que muitas aplicações compartilham poderia ser separado em uma DLL que só existe como
um arquivo de disco único e uma única instância na memória. O uso extensivo de DLLs permitiu
versões iniciais do Windows para funcionar sob condições de memória restrita.

As DLLs oferecem os benefícios padrão das bibliotecas compartilhadas, como modularidade.

A modularidade permite que mudanças sejam feitas no código e nos dados em um único recipiente autônomo.
DLL compartilhada por várias aplicações sem qualquer mudança nas aplicações
eles mesmos. Esta forma básica de modularidade permite patches relativamente compactos
e pacotes de serviço para grandes aplicações, como o Microsoft Office, Microsoft
Visual Studio, e até mesmo o próprio Microsoft Windows.

Outro benefício da modularidade é o uso de interfaces genéricas para plug-ins. Um

uma única interface pode ser desenvolvida que permite que módulos antigos e novos sejam
integrado perfeitamente em tempo de execução em aplicações pré-existentes, sem nenhum
modificação para a própria aplicação. Este conceito de extensibilidade dinâmica é adotado
ao extremo com ActiveX.
Com tantos benefícios, o uso de DLLs também tem uma desvantagem: o hell de DLL, quando
vários aplicativos entram em conflito sobre qual versão de uma biblioteca sharedDLL deve ser usada.
Esses conflitos podem geralmente ser resolvidos colocando as diferentes versões do
problemaDLL nas pastas dos aplicativos, em vez de uma pasta de todo o sistema;
no entanto, isso também anula as economias proporcionadas pelo uso de sharedDLLs. Atualmente,
O Microsoft .NET é direcionado como uma solução para o problema do DLL hell, permitindo
coexistência lado a lado de diferentes versões de uma mesma biblioteca compartilhada. Com
computadores modernos que têm muito espaço em disco e memória, isso pode ser um
abordagem razoável.

História

A API do Windows sempre expôs uma grande parte da estrutura subjacente de

os vários sistemas Windows para os quais foi criado para o programador. Este
teve a vantagem de dar aos programadores do Windows uma grande flexibilidade
e controle sobre suas aplicações. No entanto, também deu aplicações do Windows
uma grande responsabilidade em lidar com várias tarefas de nível baixo, algumas vezes tediosas,

Dani Vainstein Win32API Página 5 de 22

 Capítulo 13 Scripting Quicktest Professional Page 6

operações que estão associadas a uma interface gráfica do usuário.

Um programa olá mundo é um exemplo de programação frequentemente utilizado, geralmente
desenhado para mostrar a aplicação mais fácil possível em um sistema que realmente pode fazer
algo (ou seja, imprimir uma linha que diz "Olá Mundo").
Ao longo dos anos, várias mudanças e adições foram feitas ao Windows
O sistema operacional e a API do Windows mudaram e cresceram para refletir isso.
A API do Windows para Windows 1.0 suportava menos de 450 chamadas de função, onde em
versões modernas da API do Windows há milhares. No entanto, em geral,
a interface permaneceu bastante consistente, e uma aplicação antiga do Windows 1.0 fará
ainda parece familiar para um programador que está acostumado com a API moderna do Windows.

Uma grande ênfase tem sido colocada pela Microsoft em manter a compatibilidade de software.
compatibilidade. Para alcançar isso, a Microsoft às vezes chegou até a apoiar
software que estava usando a API de uma maneira não documentada ou até mesmo (programaticamente)
maneira ilegal.

Uma das maiores mudanças que a API do Windows sofreu foi a transição de
Win16 (fornecido no Windows 3.1 e versões anteriores) para Win32 (Windows NT e Windows)
95 e acima). Enquanto o Win32 foi originalmente introduzido com o Windows NT 3.1 e
O Win32s permitiu o uso de um subconjunto Win32 antes do Windows 95, mas isso só aconteceu até
O Windows 95 fez com que muitos aplicativos começassem a ser portados para Win32. Para facilitar a
transição, no Windows 95, tanto para desenvolvedores externos quanto para a própria Microsoft, um
um esquema complexo de API foi utilizado que poderia permitir que código de 32 bits chamasse para 16
código de 32 bits e (em casos limitados) vice-versa. Os chamados thunks planos permitiram código de 32 bits
para chamar bibliotecas de 16 bits, e o esquema foi utilizado extensivamente dentro do Windows
95 para evitar portar todo o sistema operacional para Win32 em um único bloco. No Windows NT,
o SO era puro 32 bits (exceto pelas partes para compatibilidade com aplicações de 16 bits)
e a única thunk disponível era thunks genéricos que apenas thunks de Win16 para
Win32 e funcionou no Windows 95 também. O SDK da Plataforma foi enviado com um
compilador que poderia gerar o código necessário para esses thunks.

Mensagens do Windows

As mensagens são a forma básica que o Windows informa ao seu programa que algum tipo de entrada
ocorreu e você deve processá-lo. Uma mensagem para seu formulário é enviada quando o
o usuário clica em um botão, move o mouse sobre ele ou digita texto em uma caixa de texto. Todos
as mensagens são enviadas juntamente com quatro parâmetros

Uma alça de janela, um identificador de mensagem e dois valores de 32 bits (Long). O

o identificador da janela contém o identificador da janela para a qual a mensagem está indo.
O identificador é na verdade o tipo de entrada que ocorreu (clique, movimento do mouse).
Dois valores especificam uma informação adicional para a mensagem (como onde está o)
cursor do mouse quando o mouse está sendo movido).

Mas, quando mensagens são enviadas para você, por que você não as vê, parece que alguém
está roubando sua correspondência. E antes que você fique com raiva o suficiente, deixe-me te contar.

O roubo é na verdade o Seu Aplicativo. Mas ele não rouba seu e-mail, mas sim
Leia para você e te dê apenas o mais importante com uma melhor aparência (com alguns
informação escondida de tempos em tempos). Esta melhor aparência são os eventos que você escreve
código para.
Então, quando o usuário move o mouse sobre seu formulário, o Windows envia

Dani Vainstein Win32API Página 6 de 22

 Capítulo 13 Scripting Quicktest Professional Page 7

WM_MOUSEMOVE para sua janela, seu aplicativo recebe a mensagem e é

parâmetros e executa o código que você inseriu para o evento Button_MouseMove.
Outra coisa que precisa ser dita: Você pode enviar mensagens para sua própria janela
ou para outro você mesmo. Você apenas chama SendMessage ou PostMessage
(SendMessage fará com que a janela processe a mensagem imediatamente e
O PostMessage colocará isso em uma fila, chamada fila de mensagens, após qualquer outro.
mensagens aguardando para serem processadas (ele retornará após a mensagem ser processada,
ou seja, com algum atraso)). Você deve especificar o identificador da janela para enviar a mensagem
para, a mensagem e os dois valores de 32 bits.

Manipuladores do Windows

Um identificador de janela (geralmente abreviado para hWnd) é um identificador único que o Windows
atribui a cada janela criada. Por janela, neste caso, estamos nos referindo a
tudo, desde botões de comando e caixas de texto, até caixas de diálogo e completas
janelas.
O identificador da janela é usado nas APIs como o único método de identificação de uma janela. Ele
é um valor aLong (4 bytes) e você pode obter o identificador para formulários e quase todos
controles.
O Windows identifica cada formulário, controle, menu, botão e item de menu ou
o que quer que você possa pensar pelo seu identificador. Quando seu aplicativo é executado, cada
o controle nele é atribuído a um manipulador que é usado mais tarde para separar o botão de
o resto dos controles. Se você quiser realizar qualquer operação no botão
através de uma API você deve usar este identificador. Onde obtê-lo? Bem, a API tem
fornecido anhWndproperty para todos os controles que têm manipuladores em Windows.

Visão geral dos componentes da API do Windows

Serviços Básicos

Fornecer acesso aos recursos fundamentais disponíveis em um sistema Windows.

Incluindo coisas como sistemas de arquivos, dispositivos, processos e threads, acesso ao
Registro do Windows e manuseio de erros. Essas funções residem no [Link],
arquivos [Link] ou [Link] no Windows de 16 bits, e [Link] e
[Link] no Windows de 32 bits.
Para mais informações:
[Link]
us/winprog/winprog/base_services.asp

Interface de Dispositivo Gráfico

Fornecer a funcionalidade para a saída de conteúdo gráfico para monitores, impressoras e

outros dispositivos de saída. Ele reside em [Link] no Windows de 16 bits e [Link] no de 32 bits.
bit Windows.
Para mais informações:
[Link]

Dani Vainstein Win32API Página 7 de 22

 Capítulo 13 Scriptando o Quicktest Professional Page 8

us/winprog/winprog/graphics_device_interface.asp

Interface do Usuário

Fornece a funcionalidade para criar e gerenciar janelas de tela e o mais básico

controles, como botões e barras de rolagem, recebem entrada do mouse e do teclado, e
outra funcionalidade associada à parte GUI do Windows. Esta unidade funcional
reside em [Link] no Windows de 16 bits e [Link] no Windows de 32 bits. Desde
As versões do Windows XP, os controles básicos residem em [Link], junto com o
controles comuns (Biblioteca de Controle Comum).

Para mais informações:

[Link]
us/winprog/winprog/interface_do_usuario.asp

Biblioteca de Caixa de Diálogo Comum

Fornece aos aplicativos as caixas de diálogo padrão para abrir e salvar arquivos,
escolhendo cor e fonte, etc. A biblioteca reside em um arquivo chamado [Link] em 16-
bit Windows, e [Link] em Windows de 32 bits. Ele está agrupado sob o Usuário
Categoria de interface da API.
Para mais informações:
[Link]
us/winui/winui/windowsuserinterface/userinput/[Link]

Biblioteca de Controle Comum

Dá acesso a aplicações a alguns controles avançados fornecidos pelo sistema operacional

sistema. Isso inclui coisas como barras de status, barras de progresso, barras de ferramentas e guias.
A biblioteca reside em um arquivo DLL chamado [Link] no Windows de 16 bits, e
[Link] no Windows de 32 bits. Ele está agrupado na categoria Interface do Usuário de
theAPI.
Para mais informações:
[Link]
us/winprog/winprog/biblioteca_de_controles_comuns.asp

Shell do Windows

O componente da WindowsAPI permite que os aplicativos acessem a funcionalidade

fornecido pelo shell do sistema operacional, assim como mudar e aprimorar isso. O
o componente reside em [Link] no Windows de 16 bits, e [Link] e depois em
Windows 95 [Link] em Windows de 32 bits. Está agrupado sob a Interface do Usuário
categoria da API.
Para mais informações:
[Link]
us/winprog/winprog/windows_shell.aspand
[Link]

Dani Vainstein Win32API Página 8 de 22

 Capítulo 13 Scripting Quicktest Professional Page 9

us/shellcc/platform/shell/programmersguide/shell_intro.asp

Serviços de Rede

Dê acesso às diversas capacidades de rede do sistema operacional. Seu

os subcomponentes incluem NetBIOS, Winsock, NetDDE, RPC e muitos outros.
Para mais informações:
[Link]
us/winprog/winprog/serviços_de_rede.asp

APIs da Web

O navegador web Internet Explorer também expõe muitas APIs que são frequentemente usadas por
aplicações, e como tal poderiam ser consideradas parte da API do Windows. Internet
O Explorer tem sido um componente integrado do sistema operacional desde
Windows 98, e fornece serviços relacionados à web para aplicações. A integração irá
pare com o Windows Vista. Especificamente, ele fornece:
Um controle de navegador da web incorporável, contido em [Link] e [Link].
O serviço de monikers de URL, contido em [Link], que fornece objetos COM para
aplicativos para resolver URLs. Os aplicativos também podem fornecer sua própria URL
manipuladores para outros usarem.
Uma biblioteca para ajudar com suporte a texto multilíngue e internacional
([Link]).
Transformações DirectX, um conjunto de componentes de filtro de imagem.

Suporte XML (os componentes MSXML).

Acesso ao Catálogo de Endereços do Windows.

APIs relacionadas a multimídia

A Microsoft forneceu o conjunto de APIs (DirectX) como parte de cada Windows

instalação desde o Windows 95 OSR2. O DirectX fornece um conjunto de ferramentas relacionadas de forma vaga

serviços multimídia e de jogos, incluindo:

Direct3D é uma alternativa ao OpenGL para acesso ao hardware de aceleração 3D.
DirectDraw para acesso acelerado por hardware ao framebuffer 2D. A partir de
DirectX 9, este componente foi descontinuado em favor do Direct3D, que
fornece funcionalidades gráficas de alto desempenho mais gerais (renderização 2D,
afinal, é realmente apenas um subconjunto de renderização em 3D).
DirectSound para acesso a cartões de som acelerados por hardware de baixo nível.

DirectInput para comunicação com dispositivos de entrada, como joysticks e

controladores.
DirectPlay é uma infraestrutura de jogos multiplayer. Este componente tem sido
obsoleto a partir do DirectX 9 e a Microsoft não recomenda mais seu uso para
desenvolvimento de jogos.

DirectShow que constrói e executa pipelines multimídia genéricos. É

Dani Vainstein Win32API Página 9 de 22

 Capítulo 13 Scripting Quicktest Professional Page 10

comparável ao framework GStreamer e é frequentemente usado para renderizar dentro do jogo

vídeos e construir reprodutores de mídia (o Windows Media Player é baseado nisso).
DirectShow não é mais recomendado para o desenvolvimento de jogos.
DirectMusic

APIs para interação entre programas

A API do Windows preocupa-se principalmente com a interação entre o Sistema Operacional

Sistema e um aplicativo. Para comunicação entre as diferentes janelas
aplicações entre si, a Microsoft desenvolveu uma série de tecnologias
junto à API principal do Windows. Isso começou com a Troca Dinâmica de Dados
(DDE), que foi substituído por Ligação e Incorporação de Objetos (OLE) e mais tarde
pelo Modelo de Objeto Componente (COM).

Dani Vainstein Win32API Página 10 de 22

 Capítulo 13 Scripting Quicktest Professional Page 11

Ferramentas da API do Windows

Visualizador de API

Figura 1 – Visual Studio API Viewer

Se você instalou o Microsoft Visual Studio, há uma pasta chamada

"Common\Tools\Winapi" Esta pasta contém o arquivo de texto [Link], junto
com outros arquivos. O arquivo [Link] contém as "Constantes," "Declarações" e
"Tipos" para as versões de 32 bits das funções da API do Windows. O arquivo
[Link] na mesma pasta contém mais informações.
Um clique duplo em [Link] carrega-o usando o WordPad - é muito grande para abrir
usando o Notepad. Mas há uma maneira melhor e mais eficiente de obterAPI
informação em seu aplicativo do que usando as funções "Copiar" e "Colar" em
o arquivo [Link].
Clicando duas vezes em "[Link]" carrega o Visualizador de API ou em Início -> Programas ->
Microsoft Visual Studio -> Ferramentas -> Visualizador de texto da API. Com ele, você pode olhar para o
Constantes, Declarações e Tipos da API. Funciona da seguinte forma:
Clique no menu "Arquivo", depois na opção do menu "Carregar Arquivo de Texto ... "
Selecione o item [Link] na lista e clique no comando "Abrir"
botão. Você será perguntado se deseja converter o arquivo da API em um banco de dados. Se
você responde sim, as informações serão carregadas mais rapidamente, então clique em "Sim"
botão de comando. Em seguida, você será solicitado a salvá-lo, com a recomendação de
salve como [Link]. Aceite esta recomendação clicando em "Salvar"
botão de comando. Você só precisará fazer isso na primeira vez.
Da próxima vez que você usar o Visualizador de API, poderá selecionar a opção do menu "Arquivo". Então
a opção "Carregar Arquivo de Banco de Dados ...". Da lista que aparece, você seleciona o item
[Link]

Dani Vainstein Win32API Página 11 de 22

 Capítulo 13 Scripting Quicktest Professional Page 12

Uma vez que as informações do arquivo do banco de dados tenham sido carregadas, use o Visualizador da API para selecionar

uma das categorias de Constantes, Declarações ou Tipos - e os itens disponíveis em

cada categoria será exibida agora.
O problema, para os usuários do QuickTest, é que a seção de declaração não tem o mesmo
sintaxe do [Link], mas, você pode usar o API Text Viewer para
ajudar você a como definir as declarações externas.

O Objeto Externo

Descrição
Permite que você declare chamadas a procedimentos externos de um link dinâmico externo
biblioteca (DLL).

Sintaxe

[Link]

Argumentos
Parâmetro Descrição
Tipo de dados do valor retornado pelo método. Para tipos de dados disponíveis,
Retorno veja Declare Tipos de Dados na Tabela 1 na página 22

NomeDoMétodo Uma string que pode ser qualquer nome de procedimento válido.

Uma String que representa o nome do DLL ou recurso de código que

Nome da Biblioteca
contém o procedimento declarado.
Uma string que representa o nome do procedimento no DLL ou código
recurso.
Alias
Observação: os pontos de entrada da DLL são sensíveis a maiúsculas e minúsculas.
Nota: Se o Alias for uma string vazia, MethodName é usado como o Alias.
Uma lista de tipos de dados representando os tipos de dados dos argumentos que são
passado para o procedimento quando é chamado. Para tipos de dados disponíveis, veja
Tipo(s) de Arg Declare Tipos de Dados na Tabela 1 na página 22
Nota: Para argumentos de saída, use a flag themicByRefflag.

Limitações ao usar o Objeto Externo

O objeto QuickTestExtern não suporta funções de API com CallBack

mecanismo, e também não suporta nenhuma função com um parâmetro de estrutura,
e um ponteiro para parâmetro de função.
BOOL ObterInformacaoCursor( PCURSORINFO pci);

A função usa aPCURSORINFO1parâmetro que não é suportado pelo

função externa
BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam);

A função EnumChildProc é uma função de callback definida pelo aplicativo usada com
aFunçãoEnumChildWindows.
Dani Vainstein
1
Será expandido no Capítulo COM.

Dani Vainstein Win32API Página 12 de 22

 Capítulo 13 Scripting Quicktest Professional Page 13

BOOL EnumChildWindows(HWND hWndParent, WNDENUMPROC lpEnumFunc, LPARAM lParam);

O ParameterlpEnumFunc é um ponteiro para uma função de callback definida pelo aplicativo.

Convertendo para [Link]

O objeto Extern do TheQuickTest não suporta funções de API com CallBack

mecanismo, e também não suporta nenhuma função com um parâmetro de estrutura,
e um ponteiro para parâmetro de função.
Como mencionado antes, existem centenas de funções da API do Windows. Na maioria dos
casos, você não precisará da API, porque há muitos objetos de automação
(ActiveX, ocx) que nos fazem viver mais facilmente para manipular, muita API do Windows
funcionalidade, sem usar a API do Windows diretamente (ADODB, EXCEL, MAPI, SHELL,
WSH e mais)
Bem, encontramos a função da API do Windows que precisamos, qual é o próximo passo?
a sintaxe e a documentação das funções podem ser encontradas no MSDN e em toda a parte
internet. Você deve procurar por funções no estilo Visual Basic, ou pode usar o
Visualizador de Texto da API.

Exemplo 1: Função GetPrivateProfileString

A função recupera uma string da seção especificada em uma inicialização

arquivo (arquivo ini)

Figura 2 - Documentação MSDN do GetPrivateProfileString

Primeiro, precisamos da sintaxe da função:

Dani Vainstein Win32API Página 13 de 22

 Capítulo 13 Scriptando Quicktest Professional Page 14

Podemos ver que a função retorna um valor DWORD, de acordo com a Declaração
Tipos de Dados DWORD = micDWord, O segundo argumento é o nome do
função a ser usada no QuickTest
[Link] micDword, "GetIniString"

O argumento TheLibName pode ser encontrado na parte inferior da função MSDN

documentação

Não a seção DLL, [Link].

[Link] micDword,"GetIniString","[Link]"

Agora, o argumento Alias. Para recuperar exatamente o argumento alias, você precisará de
pesquise mais na internet, especialmente sobre declarações de API do Visual Basic.
pode notar na documentação que a função se chama WritePrivateProfileA
e também GetPrivateProfileW, onde A significa ASCII e W significa wide-char
(Unicode). Quando uma função de API tem uma string em um dos argumentos, você precisa
usar a carta do Apost.
[Link] micDword,"GetIniString","[Link]","GetPrivateProfileStringA"
Por último, a lista de argumentos. Você deve prestar atenção em 2 coisas
1. O tipo de dado do argumento
2. A direção do argumento (entrada, saída ou entrada-saída)

LPCTSTR significa: Ponteiro Longo para uma String Constante Terminado em Nulo
LPTSTR significa: Ponteiro Longo para uma string terminada em nulo

significa que ambos são strings, mas a diferença entre eles é a direção

Dani Vainstein Win32API Página 14 de 22

 Capítulo 13 Scripting Quicktest Professional Page 15

NotelpReturnesStringis [out] parâmetro (LPTSTR)

[Link] micDword,"GetIniString","[Link]","GetPrivateProfileStringA", _
micString, micString, micString, micString + micByRef, micDWord, micString

No seu código, você usará a função usando a seguinte sintaxe

Dim nBytes, sRetValue
nBytes = [Link] ("Seção","Chave","", sRetValue,256,"C:\[Link]")
Caixa de Mensagem Bytes Retornados =
MsgBox sRetValue

Exemplo 2: Função GetServiceKeyName

Esta função recupera um nome de chave a partir de um nome de serviço do Windows.

Declarar Public Function GetServiceKeyName Lib "[Link]" Alias

"GetServiceKeyNameA" (PorValor hSCManager Como Long, PorValor lpDisplayName Como
String, lpServiceName Como String, lpcchBuffer Como Long) Como Long
O método TheQuickTestDeclare para o objeto Extern deve começar com a declaração.
[Link]

a declaração VB que vemos a última declaração Como Long. Isso significa que o
a função retorna um tipo de dado Long, na tabela de tipos de dados Long=micLong

[Link] micLong

O nome do método pode ser qualquer string única. Recomenda-se usar o

o nome da função em si, para seguir os padrões de codificação.

[Link] micLong, "GetServiceKeyName"

O argumento LibName na declaração VB é a palavra-chave após Lib. Isso

Dani Vainstein Win32API Página 15 de 22

 Capítulo 13 Scriptando o Quicktest Professional Page 16

o argumento pode ser escrito de 3 maneiras diferentes:

"[Link]" – Este é um arquivo dll do sistema, será reconhecido de qualquer lugar em
sua aplicação.
"advapi32" – você também pode remover a extensão, pois é um sistema conhecido
arquivo dll.
"C:\Windows\System32\[Link]" – se a dll utilizada não for uma dll do sistema, e
não armazenado sob System32, você deve escrever o caminho completo.

[Link] micLong, "GetServiceKeyName", "[Link]"

O argumento alias pode ser encontrado na declaração VB após a palavra-chave Alias. O

o nome do alias é muito importante. É o nome físico da função no arquivo dll.
Às vezes, esse nome muda para o sufixo ‘A’ (ANSI) ‘W’ (Unicode/WideChar).
Preste atenção a este nome, é sensível a maiúsculas e minúsculas. Qualquer erro de sintaxe levantará um
mensagem de erro geral em tempo de execução. Normalmente funções que um dos argumentos é
uma string, o nome do Alias muda.
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA"

Os argumento(s) na declaração VB, os argumentos são todos os parâmetros

dentro do parêntese.
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA",
micLong

Observe a lista de argumentos. Quase todos os parâmetros na declaração VB têm um

Pela palavra-chave ByVal, excluindo os parâmetros lpcchBuffer e lpServiceName, eles
estão vazios; isso significa que os parâmetros são valores de retorno (ByRef). Então, aqui está
a declaração final:
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA",
micLong, micString, micString + micByRef, micLong + micByRef

Usando a Função.
A ativação da função deve ser após a declaração da função!
Você pode colocar sua declaração uma linha antes do uso, ou no topo do
ação
Você pode colocar a declaração em uma ação reutilizável Init.
Você pode colocar sua declaração em um arquivo de recurso VBS.

No exemplo a seguir, vamos recuperar o nome da chave do Terminal.

ServiçosServiço. Certifique-se de que você possui o Serviço; caso contrário, escolha outro
serviço do Painel de Controle->Ferramentas Administrativas->Serviços.

Para ativar esta função específica, precisamos da alça do gerente de serviços, e

então precisamos fechar o manipulador do gerenciador de serviços (liberar a memória)

Opção Explícito
[Link] micLong,"OpenSCManager","advapi32","OpenSCManagerA", _
micString, micString, micLong
[Link] micLong,"CloseServiceHandle","[Link]","", micLong
[Link] micLong,"GetServiceKeyName","advapi32","GetServiceKeyNameA", _
micLong, micString, micString + micByRef, micLong + micByRef
Privado Const GENERIC_READ = &H80000000
Dim hSCManager
Dim sKeyName
Dim nRet, nBuffer

Dani Vainstein Win32API Página 16 de 22

 Capítulo 13 Scripting Quicktest Professional Page 17

hSCManager = [Link](vbNullString,vbNullString, GENERIC_READ)

Se hSCManager > 0 Então
nBuffer =0
[Link] hSCManager,"Serviços de Terminal", sKeyName, nBuffer
Caixa de Mensagem Tamanho do buffer necessário:
nRet=[Link]( hSCManager,"Serviços de Terminal", sKeyName, nBuffer)
Se nRetEntão
Caixa de mensagem O nome da chave de serviço é:
nRet = [Link](hSCManager)
Fim Se
Fim Se

A declaração constante foi escrita em valor hexadecimal. Se você se mover para o

a visualização de palavra-chave no QTP ou faça uma verificação de sintaxe, você receberá o seguinte erro
message

Este é um bug do QTP. É uma declaração legal em VBS, executar o script não gerará um
erro de tempo de execução

Destaques para a API Win32 no QuickTest

Você deve notar que o tipo BOOL (Boolean) é avaliado como Inteiro e não
Booleano. Assim, 0 (zero) refere-se a Falso e qualquer outro valor a Verdadeiro.

HWND, HDC, HMENU, etc. - e outros tipos como estes. Todos eles começam com
Mão significa MANIVELA, para manivelas de diferentes tipos de objetos.
Por exemplo, HBITMAP é um manipulador de bitmap; HBRUSH é um manipulador de pincel e assim por diante.

Eles todos avaliam a Long e devem ser passados por valor.

Observe também que LPVOID é declarado como variável AsAny. Algumas mensagens
contém parâmetros declarados como Qualquer. Isso significa que este parâmetro pode ser uma variedade
de tipos (você pode passar um inteiro, uma string, ou um tipo definido pelo usuário, ou outro.

Alguns tipos começam com LP. É uma abreviação de LongPointer para.

LPWORD é na verdade um local de memória onde os dados são armazenados. Não, você

Dani Vainstein Win32API Página 17 de 22

 Capítulo 13 Scriptando Quicktest Professional Page 18

não precisará chamar uma função para obter este endereço. Quando você passar seu argumento
Por referência (o padrão), você na verdade passa seu endereço. A coisa a lembrar aqui
se o tipo de parâmetro começar com LP-, você deve passá-lo por referência. Pelo
dessa forma, LPARAM não é um ponteiro. Você deve passar o valor real aqui, então é
passado ByVal.
Há também um tipo estranho NULL. Basta escolher uma maneira de passá-lo quando
necessário. Na maioria dos casos, use ByVal0& para números, Null ou vbNull.
e para strings use vbNullString, para um único caractere use vbNullChar.
VOID é usado para o valor de retorno de funções para especificar que não existe tal valor.
A API não tem Subs, então esta é a maneira como as implementa. Apenas lembre-se
- se o valor de retorno for VOID, use micVoid.
Estruturas ou tipos de dados complexos. Não há como usar esses tipos de dados em
QuickTest via objeto Extern.
Bem, se o valor de retorno for uma estrutura, você pode usar micUnknown, e
manipule isso de alguma forma no seu código, mas, usando API, funções não retornam
estruturas, você deve passar a estrutura ByRef. E aqui está o problema, o
O objeto Extern não pode fazer isso, o VBScript é limitado (sem suporte a API de forma alguma), então, não é
maneira de construir uma Estrutura dentro do QuickTest ou VBS.

Por exemplo, há uma função de API muito útil chamada GetCursorPos, a função
retorna a posição do cursor via a estrutura POINT.
A solução para este problema em Usar classes COM personalizadas pelo usuário.

Passando Parâmetros para funções da API Win32

Claro que você sabe como passar parâmetros, basta colocá-lo na chamada da função e é
feito! Bem, há alguns detalhes que você deve estar ciente ao passar
parâmetros para funções de API.
PorValorPorReferencia. Normalmente, você não precisa se preocupar com essas palavras-chave, já que a API VB
O Visualizador de Texto declara os parâmetros da função conforme a API os deseja e quando você
basta inserir seu valor, ele é passado conforme declarado.

Geralmente, quando um valor é passado por valor, o valor real é passado diretamente para o
função, e quando passadoPorRef, o endereço (ponteiro) do valor é passado.
Passar strings para a função API também não é difícil. A API espera o endereço de
o primeiro caractere da string e lê à frente deste endereço até que chegue a um
Nullcharacter. Parece ruim, mas esta é a forma como o sistema operacional realmente lida com cadeias de caracteres. O

a única coisa a lembrar é sempre passar o StringByRef.

A situação é um pouco diferente quando você espera que algumas informações sejam retornadas.
pela função. Aqui está a declaração das funções GetComputerNameAPI:
[Link] micLong, "GetComputerName", _
"[Link]", "GetComputerNameA", micString + micByRef, micLong + micByRef

O primeiro parâmetro é um ponteiro longo para uma string, e o segundo é o comprimento do

string. Se você apenas declarar uma variável de Tamanho do Buffer e passá-la para esta função, um
um erro ocorre. Portanto, você precisa inicializar o tamanho do buffer primeiro. Aqui está como obter o
nome do computador:

Opção Explícito
[Link] micLong,"GetComputerName","[Link]","GetComputerNameA", _
micString + micByRef, micLong + micByref

Dani Vainstein Win32API Página 18 de 22

 Capítulo 13 Scripting Quicktest Professional Page 19

Dim sBuffer
Dim nRet, nBuffSize
nBuffSize =255
nRet = [Link](sBuffer, nBuffSize)

Algumas funções também esperam arrays. Aqui está um exemplo. Os últimos dois parâmetros
são arrays de Long. Para passar um array para uma função, você passa apenas o primeiro elemento.
Aqui está um código de exemplo:

Opção Explícita
[Link] micLong,"SetSysColors", user32","SetSysColors", _
micLong, micLong+micByref, micLong+micByref
Privado Const COR_ACTIVECAPTION = 2
Privado Const COLOR_INACTIVECAPTION =3
Privado Const COLOR_CAPTIONTEXT =9
Privado Const COLOR_INACTIVECAPTIONTEXT =19
Dim SysColor(3), ColorValues(3)
Dim nRet
SysColor(0) = COR_CAPAATIVA
SysColor(1) = COR_CAPTURA_INATIVA
SysColor(2) = COR_TEXTO_CAPTION
SysColor(3) = COR_TEXTO_CAPTION_INATIVO
ColorValues(0) = RGB(58,158,58)'dark green
ColorValues(1) = RGB(93,193,93)'verde claro
0'preto
RGB(126,126,126)'cinza
nRet = [Link](4, SysColor(0), ColorValues(0))

Funções de Retorno

Um callback é uma função que você escreve e diz ao Windows para chamar por algum motivo.
crie sua própria função com um número e tipo de parâmetros especificados, então diga
Janelas para as quais esta função deve ser chamada por algum motivo e seus parâmetros
preenchido com algumas informações de que você precisa. Então o Windows chama sua função, você lida com a
parâmetros e sai da função retornando algum tipo de valor. Um uso típico
de callbacks é para receber um fluxo contínuo de dados do Windows. Este tópico
também não é suportado pelo QuickTest.

Interagindo com um arquivo dll personalizado

Você também pode interagir com seus DLLs personalizados, seus DLLs de aplicativos testados.
Sempre que eles escreviam em VB, C ou C++.
A Biblioteca de Tempo de Execução C da Microsoft tem o nome de arquivo [Link].

[Link] micLong, "abs", "C:\RTO\[Link]", "abs", micLong

Msgbox [Link](-55)

Interagindo entre a API Win32 e o QuickTest

Um recurso muito legal e útil (para mim) é destacar automaticamente um objeto

antes de acessá-lo.

Dani Vainstein Win32API Página 19 de 22

 Capítulo 13 Scripting Quicktest Professional Page 20

Por exemplo, eu quero clicar em um botão na minha aplicação, usando QTP.

Para mim, implementar o código é muito simples
Janela( "W" ).BotãoWin( "B" ).Clique
Para mim é 1 linha de código, mas, para te falar a verdade, esta função faz muito mais.
Verifica se o objeto existe.
Verifique se o objeto está habilitado.
Destacar o objeto
Clique
Primeiro, eu uso o recurso RegisterUserFunc para substituir o método de objeto comum.
Dentro da função sobrescrita, eu realizo uma consulta [Link] e [Link].
Eu chamo algumas APIs win32 para o recurso de destaque e, por último, clico no botão.
Mais para TextEdit, Lista, WebEdit, WebList também adiciono um ponto de sincronização para o esperado
resultado.
Ao destacar cada objeto antes do QTP acessá-lo, a performance será reduzida.
Seu script ficará mais lento, mas acho que vale a pena. Você pode acompanhar visualmente cada operação que
O QTP faz sobre sua aplicação. E, claro, você pode adicionar um Ambiente ou Global
Parâmetro que ignora a marcação ao executar o script à noite.

Sobrescrita

RegisterUserFunc "Image", "Click", "ControlsImageClick",True

RegistrarFuncUsuário
RegisterUserFunc "WebTable", "Blink", "fBlink",False
RegistrarUsuarioFunc
RegistrarFunçãoUsuário

Função Pública WebEditSet(ByRef sender, ByVal value)

** Validação já realizada pelo ControlsBlink, não é necessário revalidar

Chame fBlink( remetente, 2 )
Se [Link] = micFailEntão Sair Função
[Link] valor

Fim Função

Ao chamar para Browser( "B" ).Page( "P" ).WebEdit( "WE" ).Set "exemplo"
A função RegisterUserFunc do QTP substitui o método Set do QTP, em vez disso, WebEditSet é chamado.
Chamar fBlink do WebEditSet verificará se o objeto existe, caso contrário, eu receberei um
mensagem de erro no Reporter.
Se o objeto existir, então um processo de piscar ocorrerá durante a execução e imediatamente
a função QTP original é chamada de dentro de WebEditSet

Declarações de API

[Link] micHwnd, "GetDesktopWindow", "user32", "GetDesktopWindow"

[Link] micULong, "GetWindowDC", "user32", "GetWindowDC", micHwnd
[Link] micInteger, "ReleaseDC", "user32", "ReleaseDC", micHwnd, micULong
[Link] micULong, "CreatePen", "gdi32", "CreatePen", _
micInteiro, micInteiro, micDword

Dani Vainstein Win32API Página 20 de 22

 Capítulo 13 Scripting Quicktest Professional Page 21

[Link] micInteger, "SetROP2", "gdi32", "SetROP2", micULong, micInteger

[Link] micULong, "SelectObject", "gdi32", "SelectObject", micULong, micULong
[Link] micULong, "DeleteObject", "gdi32", "DeleteObject", micULong
[Link] micULong, "GetStockObject", "gdi32", "GetStockObject", micInteger
[Link] micULong, "Retângulo", "gdi32", _
"Retângulo", micULong, micInteger, micInteger, micInteger, micInteger

A Função fBlink

' *****************************************************************************
** fBlink
Destaca um controle número específico de vezes "Vezes
** Todas as funções são API do Windows - Externo deve ser declarado.
' *****************************************************************************
Público Função fBlink(ByRef remetente, ByVal vezes)
Const PS_SOLID = 0 :Const PS_INSIDEFRAME = 6 :Const R2_NOT = 6
Const NULL_BRUSH = 5 :Const PEN_WIDTH = 2 :
Dim hDC, hPen
Dim nX, nY, nH, nW, i

Se Não [Link]( 1 )Então

micFail
Sair da Função
Fim Se
** Recuperar as informações do remetente...
Com remetente
nX = .GetROProperty("abs_x")
nY = .GetROProperty("abs_y")
nW = .GetROProperty("largura")
nH = .ObterPropriedadeRO("altura")
Fim Com
** Obter o DC da área de trabalho
hDC = [Link]([Link]() )
** Crie uma caneta com três pixels de largura
hPen = [Link]( PS_INSIDEFRAME, PEN_WIDTH, RGB( 255, 0, 0 ) )
Extern.SetROP2 hDC, R2_NOT
[Link] hDC, hPen
** Use um preenchimento vazio
[Link] hDC, [Link]( NULL_BRUSH )
** Faça o destaque
Para i = 0 até vezes * 2 + 1
[Link] hDC, nX, nY, nX + nW, nY + nH
Espere 0, 50
Próximo
** Liberar Recursos
[Link] [Link], hDC
[Link] hPen
Fim Função

Dani Vainstein Win32API Página 21 de 22

 Capítulo 13 Scripting Quicktest Professional Page 22

Apêndice 13.A

Declarar Tipos de Dados

Constante Valor Descrição

micVoid 0 vazio (apenas tipo de retorno)

micInteger 2 int
micLong 3 longo
micFloat 4 flutuar
micDouble 5 duplo

micString 8 CHAR*
micDispatch nove IDispatch*
micWideString 18 WChar*
micChar 19 caractere
micDesconhecido 20 IUnknown
micHwnd 21 HWND
micVPtr 22 void*
micCurto 23 curto
micPalavra 24 PALAVRA
micDWord 25 DWORD
micByte 26 BYTE
micWParam 27 WPARAM
micLParam 28 LPARAM
micLResultado 29 LRESULT
micByRef h&4000 fora
micUnsigned h&8000 sem sinal
micUChar micChar + micUnsigned unsigned char
micULong micLong + micUnsigned long unsigned
micUShort microfone curto não assinado curto

micUInteger micInteiro + micSemSinal unsigned int ( UINT )

Tabela 1 – Declarar Constantes de Tipo de Dados

Dani Vainstein Win32API Página 22 de 22