Guía de API de Windows 32 en QuickTest
Traducido por
ScribdTranslationsGuía de API de Windows 32 en QuickTest
Traducido por
ScribdTranslationsCapítulo 13 Scripting Quicktest Professional Page 1
API WINDOWS 32................................................................................................................... 1
¿QUÉ ES API?
DESIGNMODELS............................................................................................................... 2
RELEASEPOLICIES............................................................................................................ 3
EJEMPLOS DE API..................................................................................................................... 3
LAAPICIÓNDEWINDOWS ....................................................................................................................... 4
ARCHIVOS DLL (BIBLIOTECA DINÁMICA)................................................................................ 4
FUNDAMENTOS DE ADLL.................................................................................................... 4
ANTECEDENTES......................................................................................................................... 5
HISTORY................................................................................................................................ 5
MENSAJESWINDOWS............................................................................................................ 6
WINDOWSHANDLES.............................................................................................................. 7
VISIÓN GENERAL DE LOS COMPONENTES DE LA API DE WINDOWS................................................................ 7
SERVICIOSBÁSICOS................................................................................................................ 7
INTERFAZDEDISPOSITIVOSGRÁFICOS...................................................................................... 7
USERINTERFACE.............................................................................................................. 8
BIBLIOTECA DE CUADRO DE DIÁLOGO COMÚN...................................................................................... 8
BIBLIOTECA DE CONTROLES COMUNES.................................................................................. 8
SHELLDEWINDOWS.............................................................................................................. 8
SERVICIOSRED......................................................................................................... 9
APISWEB.......................................................................................................................... 9
APIS RELACIONADOS CON MULTIMEDIA............................................................................................ 9
APIS PARA INTERACCIÓN ENTRE PROGRAMAS......................................................... 10
HERRAMIENTAS DE WINDOWSAPI......................................................................................................... 11
VISOR DE API................................................................................................................... 11
ELOBJETOEXTERNO.......................................................................................................... 12
LIMITACIONES AL USAR THEEXTERNOBJECT....................................................................... 12
CONVERSIÓN A [Link]................................................................................ 13
Ejemplo 1: Función GetPrivateProfileString............................................................... 13
Ejemplo 2: Función GetServiceKeyName................................................................... 15
HIGHLIGHTS FORWIN32 APIINQUICKTEST................................................................... 17
Pasando parámetros a las funciones de la API de Win32................................................................. 18
Funciones de devolución de llamada....................................................................................................... 19
Interacción con un archivo dll personalizado .................................................................................. 19
ELOBJETOEXTERNO........................................................¡ERROR! MARCADOR NO DEFINIDO.
APÉNDICE 13.A .................................................................................................................... 19
Declarar Tipos de Datos...................................................................................................... 22
API de Windows 32
Este tutorial trata sobre cómo agregar funcionalidad adicional a tus aplicaciones mediante
usando la Interfaz de Programación Avanzada de Windows.
La API de Windows (Interfaces de Programación de Aplicaciones) es un conjunto de definiciones predefinidas
Las funciones de Windows se utilizan para controlar la apariencia y el comportamiento de cada Windows
elemento (desde la perspectiva de la ventana de escritorio hasta la asignación de memoria para un)
nuevo proceso). Cada acción del usuario provoca la ejecución de varios o más API
Dani Vainstein Win32API Página 1 de 22
Capítulo 13 Scripting Quicktest Professional Page 2
función que le dice a Windows lo que ha sucedido.
Es algo así como el código nativo de Windows. Otros lenguajes solo actúan como un
shell para proporcionar una forma automatizada y más fácil de acceder a las APIs.
QuickTest soporta un lenguaje de desarrollo VBScript y su funcionalidad puede
ser extendido de dos maneras. La primera manera es usando controles personalizados. Estos son
software components that are easily incorporated intoQTP/VBSscripts. There are
controles personalizados para casi cualquier tarea imaginable, incluyendo análisis numérico,
reconocimiento de voz, soporte de imágenes y documentos. Los controles personalizados se llaman
Ocx's.
La segunda forma en que QuickTest se puede extender es a través de la Aplicación de Windows.
Interfaz de Programación de Aplicaciones (API), utilizando el objeto Extern. Las funciones de la API no son
compatible con VBSript.
¿Qué es una API?
Una interfaz de programación de aplicaciones (API) es una interfaz de código fuente que un
computer system or program library provides in order to support requests for
servicios que se harán de él por un programa de computadora.
Una API se diferencia de una Interfaz Binaria de Aplicación en que se especifica en términos de
un lenguaje de programación que se puede compilar cuando se construye una aplicación, en lugar de
que una descripción explícita de bajo nivel de cómo se organiza los datos en memoria.
El software que proporciona la funcionalidad descrita por una API se dice que es un
implementación de la API. La API en sí es abstracta, en el sentido de que especifica un
interfaz y no se involucra en los detalles de implementación.
Una API a menudo es parte de un kit de desarrollo de software (SDK).
El término API se utiliza en dos sentidos relacionados:
Una interfaz coherente que consiste en varias clases o varios conjuntos de relacionados
funciones o procedimientos.
Un único punto de entrada como un método, función o procedimiento.
En términos generales, una API es un software del sistema para un sistema operativo o
entorno, que consiste en un conjunto estandarizado de funciones y procedimientos.
Los programadores pueden llamar a estas funciones y procedimientos desde sus programas para obtener
funcionalidad adicional. Porque los programadores no tienen que escribir este código
se ahorran tiempo. El sistema también proporciona un estándar y bien
manera de trabajar documentada
Modelos de Diseño
Existen varios modelos de diseño para APIs. Interfaces destinadas a la más rápida
la ejecución a menudo consiste en conjuntos de funciones, procedimientos, variables y datos
estructuras. Sin embargo, existen otros modelos también - como el intérprete utilizado para
evalúa expresiones en ECMAScript/JavaScript o en la capa de abstracción - cuál
aliviar al programador de la necesidad de saber cómo las funciones de la API se relacionan
a los niveles más bajos de abstracción. Esto hace posible rediseñar o mejorar
las funciones dentro de laAPI sin romper el código que depende de ella.
Algunas API, como las que son estándar en un sistema operativo, se implementan
Dani Vainstein Win32API Página 2 de 22
Capítulo 13 Scripting Quicktest Professional Page 3
como bibliotecas de código separadas que se distribuyen con el sistema operativo. Otros
exigir a los editores de software que integren la funcionalidad de la API directamente en el
aplicación. Esto forma otra distinción en los ejemplos anteriores. Microsoft
Las API de Windows vienen con el sistema operativo para que cualquiera las use. Software para
los sistemas embebidos como las consolas de videojuegos generalmente caen en el
categoria integrada en la aplicación. Mientras que un documento oficial de la API de PlayStation puede ser
interesante de leer, es de poca utilidad sin su correspondiente implementación, en
la forma de una biblioteca separada o un kit de desarrollo de software.
Una API que no requiere regalías para acceder y usar se llama "abierta".
Aunque generalmente existen "implementaciones de referencia" autorizadas para una API
como Microsoft Windows para la API Win32), no hay nada que impida el
creación de implementaciones adicionales. Por ejemplo, la mayoría de la API de Win32 puede
se proporcionará bajo un sistema UNIX utilizando un software llamado Wine.
Políticas de Lanzamiento
Dos líneas generales de políticas de publicación de API:
Algunas empresas protegen celosamente la información sobre sus API del público en general.
consumo. Por ejemplo, Sony solía hacer su API oficial de PlayStation 2
disponible solo para desarrolladores de PlayStation con licencia. Esto permitió a Sony controlar quién
escribió juegos de PlayStation 2. Tal control puede tener beneficios de control de calidad y
ingresos potenciales por licencias.
Algunas empresas hacen sus APIs disponibles de forma gratuita. Por ejemplo, Microsoft hace
la mayor parte de su información de API es pública, para que se escriba software para Windows
plataforma.
Las empresas basan su elección de política de publicación en maximizar el beneficio para ellas.
Ejemplos de API
La interfaz de llamada del BIOS de PC
Especificación Única de UNIX (SUS)
API de Microsoft Win32
Java Platform, Enterprise Edition APIs
ASPI para la interfaz de dispositivos SCSI
Carbon y Cocoa para el sistema operativo Macintosh
API de OpenGL multiplataforma
DirectX para Microsoft Windows
Capa de Medios Directos Simple (SDL)
API de Hogar Universal
Interfaz de Programa de Aplicación LDAP
svgalib para Linux y FreeBSD
API de Google Maps
API de Wikipedia
[Link] El Directorio Abierto para Mashups & APIs de Web 2.0
Dani Vainstein Win32API Página 3 de 22
Capítulo 13 Scripting Quicktest Professional Page 4
La API de Windows
Las funciones de la API residen en DLLs (como [Link], [Link], [Link], ...) en el
Directorio del sistema de Windows.
La API de Windows es el nombre que Microsoft le da al conjunto central de aplicaciones
interfaces de programación disponibles en los sistemas operativos Microsoft Windows.
está diseñado para ser utilizado por programas en C/C++ y es la forma más directa de interactuar
con un sistema operativo Windows para aplicaciones de software. Acceso de bajo nivel a un
Sistema Windows
A El Kit de Desarrollo de Software (SDK) está disponible para Windows, que proporciona
documentación y herramientas para permitir a los desarrolladores crear software utilizando el
API de Windows y tecnologías de ventanas asociadas.
La API de Windows es el conjunto de funciones y procedimientos disponibles en Windows.
Pueden ser utilizados por todo tipo de programadores. Mercury agregó el acceso a la API.
interfaz incluyendo a aquellos que trabajan en QuickTest.
La funcionalidad más solicitada de la API de Windows ya existe en el
VBScript entorno de desarrollo básico. La mayoría de las funciones de la API y
los procedimientos que no han sido incluidos en VBScript aún pueden ser llamados desde
laAplicaciónPruebaRápida. El pequeño porcentaje que no puede, rara vez es necesario.
Archivos DLL (Biblioteca de Enlace Dinámico)
Biblioteca de enlaces dinámicos (DLL), también conocida como biblioteca de enlaces dinámicos (sin el
guion), es la implementación de Microsoft del concepto de biblioteca compartida en el
Sistemas operativos Microsoft Windows. Estas bibliotecas suelen tener el archivo
extensionDLL, OCX (para bibliotecas que contienen controles ActiveX), o DRV (para legado)
controladores del sistema).
DynamicLinkLibrary, una biblioteca de funciones o datos ejecutables que se pueden utilizar
por una aplicación de Windows. Típicamente, una DLL proporciona uno o más particulares
las funciones y un programa accede a las funciones creando ya sea estático o
enlace dinámico a la DLL. Un enlace estático permanece constante durante la ejecución del programa
mientras que un enlace dinámico es creado por el programa según sea necesario. DLL también puede contener
los archivos .DLL de datos generalmente terminan con la extensión .dll, .exe., drv, o .fon. ADLL
puede ser utilizado por varias aplicaciones al mismo tiempo. Algunos DLLs son proporcionados
con el sistema operativo Windows y disponible para cualquier aplicación de Windows.
Otras DLL se escriben para una aplicación particular y se cargan con el
aplicación.
Fundamentos de una DLL
Hemos mencionado que un aDLL se crea como un proyecto que contiene al menos uno
archivo fuente y este archivo fuente debe presentar un punto de entrada. Después de crear el
DLL, la construirás y la distribuirás para que otros programas puedan usarla. Al construirla,
debes crear un archivo de biblioteca que acompañe a la DLL. Este archivo de biblioteca será
utilizado por otros programas para importar lo que está disponible en la DLL:
Dani Vainstein API de Win32 Página 4 de 22
Capítulo 13 Scripting Quicktest Professional Page 5
Cuando se crea la biblioteca de importación, contiene información sobre dónde se encuentra cada
la función disponible está incluida en el DLL y puede localizarla. Cuando una aplicación
necesita usar una función contenida en el DLL, presenta su solicitud a la importación
la biblioteca. La biblioteca de importación verifica el DLL para esa función. Si la función existe,
el programa cliente puede usarlo. Si no, la biblioteca comunica esto al
la aplicación y la aplicación presenta un error.
Antecedentes
El propósito original de los DLLs era ahorrar tanto espacio en disco como memoria requerida.
para aplicaciones al almacenarlo localmente en el disco duro. En un no convencional
la biblioteca compartida, se añaden secciones de código simplemente al programa que llama. Si dos
los programas llaman a la misma rutina, ese código se duplicaría. En cambio, cualquier código
las cuales muchas aplicaciones comparten podrían separarse en un DLL que solo existe como
un archivo de disco único y una única instancia en memoria. El uso extensivo de DLLs permitió
versiones tempranas de Windows para funcionar bajo condiciones de memoria ajustadas.
Las DLL proporcionan los beneficios estándar de las bibliotecas compartidas, como la modularidad.
La modularidad permite realizar cambios en el código y los datos en un solo conjunto autónomo.
DLL compartida por varias aplicaciones sin ningún cambio en las aplicaciones
a sí mismos. Esta forma básica de modularidad permite parches relativamente compactos
y paquetes de servicio para aplicaciones grandes, como Microsoft Office, Microsoft
Visual Studio, e incluso Microsoft Windows en sí mismo.
Otro beneficio de la modularidad es el uso de interfaces genéricas para los complementos. A
se puede desarrollar una interfaz única que permita a los módulos antiguos así como a los nuevos
integrado sin problemas en tiempo de ejecución en aplicaciones preexistentes, sin ningún
modificación a la aplicación misma. Este concepto de extensibilidad dinámica se toma
hasta el extremo con ActiveX.
Con tantos beneficios, el uso de DLL también tiene una desventaja: el DLL hell, cuando
varias aplicaciones entran en conflicto sobre qué versión de una biblioteca compartida DLL debe usarse.
Tales conflictos suelen resolverse colocando las diferentes versiones del
problemaDLL en las carpetas de las aplicaciones, en lugar de una carpeta de sistema global;
sin embargo, esto también anula los ahorros proporcionados por el uso de sharedDLLs. Actualmente,
Microsoft .NET está diseñado como una solución al problema de DLL hell al permitir
coexistencia lado a lado de diferentes versiones de una misma biblioteca compartida. Con
las computadoras modernas que tienen mucho espacio en disco y memoria, pueden ser un
enfoque razonable.
Historia
La API de Windows siempre ha expuesto una gran parte de la estructura subyacente de
los diversos sistemas Windows para los cuales ha sido construido para el programador. Esto
ha tenido la ventaja de ofrecer a los programadores de Windows una gran cantidad de flexibilidad
y control sobre sus aplicaciones. Sin embargo, también ha dado lugar a aplicaciones de Windows
una gran cantidad de responsabilidad en manejar varias tareas de bajo nivel, a veces tediosas,
Dani Vainstein Win32API Página 5 de 22
Capítulo 13 Scripting Quicktest Professional Page 6
operaciones que están asociadas con una interfaz gráfica de usuario.
Un programa Hello World es un ejemplo de programación que se utiliza con frecuencia, generalmente
diseñado para mostrar la aplicación más fácil posible en un sistema que realmente puede hacer
algo (es decir, imprimir una línea que diga "Hola Mundo").
A lo largo de los años, se realizaron varios cambios y adiciones en Windows
El sistema operativo y la API de Windows cambiaron y crecieron para reflejar esto.
La API de Windows para Windows 1.0 admitía menos de 450 llamadas a funciones, donde en
hay miles de versiones modernas de la API de Windows. Sin embargo, en general,
la interfaz se mantuvo bastante consistente, y una antigua aplicación de Windows 1.0 será
todavía se ve familiar para un programador que está acostumbrado a la API moderna de Windows.
Se ha puesto un gran énfasis por parte de Microsoft en mantener la compatibilidad con versiones anteriores del software.
compatibilidad. Para lograr esto, Microsoft a veces incluso llegó a apoyar
software que estaba utilizando laAPI de una manera no documentada o incluso (programáticamente)
forma ilegal.
Uno de los cambios más grandes que experimentó la API de Windows fue la transición de
Win16 (enviado en Windows 3.1 y versiones anteriores) a Win32 (Windows NT y Windows
95 y superior). Mientras que Win32 se introdujo originalmente con Windows NT 3.1 y
Win32s permitió el uso de un subconjunto de Win32 antes de Windows 95, no fue hasta
Windows 95 que muchas aplicaciones comenzaron a ser trasladadas a Win32. Para facilitar la
transición, en Windows 95, tanto para desarrolladores externos como para Microsoft mismo, un
se utilizó un esquema complejo de API que podría permitir que el código de 32 bits llamara a 16
código de 32 bits y (en casos limitados) viceversa. Los llamados thunks planos permitieron código de 32 bits
para llamar a bibliotecas de 16 bits, y el esquema se utilizó ampliamente dentro de Windows
95 para evitar portear todo el sistema operativo a Win32 en un solo bloque. En Windows NT,
el sistema operativo era puro de 32 bits (excepto las partes para compatibilidad con aplicaciones de 16 bits)
y el único thunk disponible era thunks genéricos que solo thunks de Win16 a
Win32 y también funcionó en Windows 95. El SDK de ThePlatform se envió con un
compilador que podría producir el código necesario para estos thunks.
Mensajes de Windows
Los mensajes son la forma básica en que Windows le dice a su programa que hay algún tipo de entrada.
ha ocurrido y debes procesarlo. Se envía un mensaje a tu formulario cuando el
el usuario hace clic en un botón, mueve el ratón sobre él o escribe texto en un cuadro de texto. Todo
los mensajes se envían junto con cuatro parámetros
Un manejador de ventana, un identificador de mensaje y dos valores de 32 bits (Long). El
el identificador de la ventana contiene el identificador de la ventana a la que se dirige el mensaje.
El identificador es en realidad el tipo de entrada que ocurrió (clic, movimiento del mouse).
Dos valores especifican información adicional para el mensaje (como dónde está el)
cursor del ratón cuando se mueve el ratón).
Pero, cuando te envían mensajes, ¿por qué no los ves? Parece que alguien
está robando tu correo. Y antes de que te enojes lo suficiente, déjame decirte.
El robo es en realidad Tu Aplicación. Pero no roba tu correo, sino que en su lugar
léelo para ti y darte solo lo más importante en una mejor vista (con algunos
información oculta de vez en cuando). Esta mejor apariencia son los eventos que escribes
código para.
Entonces, cuando el usuario mueve el mouse sobre tu formulario, Windows envía
Dani Vainstein Win32API Página 6 de 22
Chapter 13 Scripting Quicktest Professional Page 7
WM_MOUSEMOVE a tu ventana, tu aplicación recibe el mensaje y su
parámetros y ejecuta el código que has ingresado para el evento Button_MouseMove.
Algo más que debe decirse: puedes enviar mensajes a tu propia ventana
o a otro tú mismo. Solo llama a SendMessage o PostMessage
(SendMessagewill cause the window to process the message immediately and
PostMessage lo publicará en una cola, llamada cola de mensajes, después de cualquier otro
mensajes esperando ser procesados (regresará después de que el mensaje sea procesado,
es decir, con algún retraso)). Debes especificar el identificador de la ventana para enviar el mensaje
a, el mensaje y los dos valores de 32 bits.
Manejadores de Windows
Un identificador de ventana (generalmente abreviado como hWnd) es un identificador único que Windows
asigna a cada ventana creada. Por ventana en este caso nos referimos a
todo, desde botones de comando y cuadros de texto, hasta cuadros de diálogo y completos
ventanas.
El identificador de ventana se utiliza en las API como el único método para identificar una ventana. Él
es un valor Long (4 bytes) y puedes obtener el identificador para formularios y casi todos
controles.
Windows identifica cada formulario, control, menú, botón y elemento de menú o
cualquier cosa que puedas pensar por su mango. Cuando se ejecuta tu aplicación, cada
el control se le asigna un mango que se utiliza más tarde para separar el botón de
el resto de los controles. Si deseas realizar alguna operación en el botón
a través de unAPIdebes usar este identificador. ¿De dónde obtenerlo? BuenoAPI tiene
se proporcionó la propiedad anhWnd para todos los controles que tienen manejadores en Windows.
Descripción general de los componentes de la API de Windows
Servicios Básicos
Proporcione acceso a los recursos fundamentales disponibles en un sistema Windows.
Se incluyen cosas como sistemas de archivos, dispositivos, procesos e hilos, acceso al
Registro de Windows y manejo de errores. Estas funciones residen en [Link],
archivos [Link] o [Link] en Windows de 16 bits, y [Link] y
[Link] en Windows de 32 bits.
Para más información:
[Link]
us/winprog/winprog/base_services.asp
Interfaz de Dispositivo Gráfico
Proporcionar la funcionalidad para la salida de contenido gráfico a monitores, impresoras y
otros dispositivos de salida. Reside en [Link] en Windows de 16 bits y [Link] en 32-
bit Windows.
Para más información:
[Link]
Dani Vainstein Win32API Página 7 de 22
Capítulo 13 Scripting Quicktest Professional Page 8
us/winprog/winprog/interfaz_de_dispositivo_grá[Link]
Interfaz de Usuario
Proporciona la funcionalidad para crear y gestionar ventanas de pantalla y la mayoría de las básicas
los controles, como botones y barras de desplazamiento, reciben entrada del mouse y del teclado, y
otra funcionalidad asociada con la parte GUI de Windows. Esta unidad funcional
reside en [Link] en Windows de 16 bits y en [Link] en Windows de 32 bits. Desde
Las versiones de Windows XP, los controles básicos residen en [Link], junto con el
controles comunes (Biblioteca de Controles Comunes).
Para más información:
[Link]
us/winprog/winprog/interfaz_usuario.asp
Biblioteca de Cuadro de Diálogo Común
Proporciona a las aplicaciones los cuadros de diálogo estándar para abrir y guardar archivos,
elegir color y fuente, etc. La biblioteca reside en un archivo llamado [Link] en 16-
bit Windows, y [Link] en Windows de 32 bits. Está agrupado bajo el Usuario
Categoría de interfaz de la API.
Para más información:
[Link]
us/winui/winui/windowsuserinterface/userinput/[Link]
Biblioteca de Controles Comunes
Otorga a las aplicaciones acceso a algunos controles avanzados proporcionados por el sistema operativo
sistema. Esto incluye cosas como barras de estado, barras de progreso, barras de herramientas y pestañas.
La biblioteca reside en un archivo DLL llamado [Link] en Windows de 16 bits, y
[Link] en Windows de 32 bits. Se agrupa bajo la categoría de Interfaz de Usuario de
laAPI.
Para más información:
[Link]
us/winprog/winprog/common_control_library.asp
Shell de Windows
El componente de la API de Windows permite a las aplicaciones acceder a la funcionalidad
proporcionado por el shell del sistema operativo, así como cambiarlo y mejorarlo. El
el componente reside en [Link] en Windows de 16 bits, y [Link] y más adelante en
Windows 95 [Link] en Windows de 32 bits. Se agrupa bajo la Interfaz de Usuario
categoría de la API.
Para más información:
[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
Servicios de Red
Brindar acceso a las diversas capacidades de red del sistema operativo. Su
los subcomponentes incluyen NetBIOS, Winsock, NetDDE, RPC y muchos otros.
Para más información:
[Link]
us/winprog/winprog/servicios_de_red.asp
APIs web
El navegador web Internet Explorer también expone muchas API que a menudo son utilizadas por
aplicaciones, y como tal se podría considerar una parte de la API de Windows. Internet
Explorer ha sido un componente integrado del sistema operativo desde
Windows 98 y proporciona servicios relacionados con la web a las aplicaciones. La integración será
deja de usar Windows Vista. Específicamente, proporciona:
Un control de navegador web embebido, contenido en [Link] y [Link].
El servicio de monikers de URL, contenido en [Link], que proporciona objetos COM a
aplicaciones para resolver URLs. Las aplicaciones también pueden proporcionar su propia URL
controladores para que otros los usen.
Una biblioteca para ayudar con el soporte de texto en múltiples idiomas e internacional
([Link]).
Transformaciones de DirectX, un conjunto de componentes de filtros de imagen.
Soporte XML (los componentes MSXML).
Acceso a la libreta de direcciones de Windows.
APIs relacionadas con multimedia
Microsoft ha proporcionado el conjunto de APIs (DirectX) como parte de cada Windows
instalación desde Windows 95 OSR2. DirectX proporciona un conjunto de características relacionadas de manera laxa
servicios multimedia y de videojuegos, incluyendo:
Direct3D es una alternativa a OpenGL para el acceso al hardware de aceleración 3D.
DirectDraw para acceso acelerado por hardware al framebuffer 2D. A partir de
DirectX 9, este componente ha sido desaprobado a favor de Direct3D, que
proporciona funcionalidad gráfica de alto rendimiento más general (renderizado 2D,
después de todo, en realidad es solo un subconjunto de la representación 3D).
DirectSound para acceso a tarjetas de sonido aceleradas por hardware a bajo nivel.
DirectInput para la comunicación con dispositivos de entrada como joysticks y
controladores
DirectPlay es una infraestructura de juegos multijugador. Este componente ha sido
deprecated desde DirectX 9 y Microsoft ya no recomienda su uso para
desarrollo de juegos.
DirectShow que construye y ejecuta tuberías multimedia genéricas. Es
Dani Vainstein Win32API Página 9 de 22
Capítulo 13 Scripting Quicktest Professional Page 10
comparable al marco de GStreamer y a menudo se utiliza para renderizar en el juego
videos y construir reproductores de medios (Windows Media Player se basa en ello).
DirectShow ya no se recomienda para el desarrollo de juegos.
DirectMusic
APIs para la interacción entre programas
La API de Windows se ocupa principalmente de la interacción entre el sistema operativo
Sistema y una aplicación. Para la comunicación entre las diferentes ventanas.
las aplicaciones entre sí, Microsoft ha desarrollado una serie de tecnologías
junto a la API principal de Windows. Esto comenzó con el Intercambio de Datos Dinámico
(DDE), que fue reemplazado por la vinculación y la incorporación de objetos (OLE) y más tarde
por el Modelo de Objetos Componente (COM).
Dani Vainstein Win32API Página 10 de 22
Capítulo 13 Scripting Quicktest Professional Page 11
Herramientas de API de Windows
Visor de API
Figura 1 – Visor de API de Visual Studio
Si has instalado Microsoft Visual Studio, hay una carpeta llamada
"Común\Herramientas\Winapi" Esta carpeta contiene el archivo de texto [Link], junto con
con otros archivos. El archivo [Link] contiene las "Constantes", "Declaraciones" y
"Tipos" para las versiones de 32 bits de las funciones de la API de Windows. El archivo
[Link] en la misma carpeta contiene más información.
Hacer doble clic en [Link] lo carga usando WordPad - es demasiado grande para abrirlo
usando Notepad. Pero hay una manera mejor y más eficiente de obtener API
información en tu aplicación que usando las funciones "Copiar" y "Pegar" en
el archivo [Link].
Haciendo doble clic en "[Link]" se carga el Visor de API o en Inicio -> Programas ->
Microsoft Visual Studio -> Herramientas -> Visor de texto de API. Con él puedes ver el
Constantes, Declaraciones y Tipos de la API. Funciona de la siguiente manera:
Haga clic en el menú "Archivo", luego en la opción del menú "Cargar archivo de texto ... "
Selecciona el elemento [Link] en el cuadro de lista y haz clic en el comando 'Abrir'
botón. Se le preguntará si desea convertir el archivo de API a una base de datos. Si
tú respondes que sí, la información se cargará más rápido, así que haz clic en "Sí"
botón de comando. A continuación se le pedirá que lo guarde, con la recomendación de
guárdalo como [Link]. Acepta esta recomendación haciendo clic en "Guardar"
botón de comando. Solo tendrás que hacer esto la primera vez.
La próxima vez que uses el Visor de API, puedes seleccionar la opción del menú "Archivo". Luego
the "Load Database File ..." option. From the list that appears you select the item
"[Link]".
Dani Vainstein Win32API Página 11 de 22
Capítulo 13 Scripting Quicktest Professional Page 12
Una vez que se ha cargado la información del archivo de la base de datos, utiliza el Visor de API para seleccionar
una de las categorías de Constantes, Declaraciones o Tipos - y los elementos disponibles en
cada categoría se mostrará ahora.
El problema, para los usuarios de QuickTest, es que la sección de declaración no tiene la misma
sintaxis de [Link], pero, puedes usar elAPI Text Viewer para
te ayudo a cómo definir las declaraciones extern.
El Objeto Externo
Descripción
Te permite declarar llamadas a procedimientos externos desde un enlace dinámico externo
biblioteca (DLL).
Sintaxis
[Link],MethodName,LibName,Alias,ArgType(s)
Argumentos
Parámetro Description
Tipo de dato del valor devuelto por el método. Para los tipos de datos disponibles,
RetType ver Declarar Tipos de Datos en la Tabla 1 en la página 22
MethodName Una cadena que puede ser cualquier nombre de procedimiento válido.
Una cadena que representa el nombre de la DLL o recurso de código que
NombreDeLaBiblioteca
contiene el procedimiento declarado.
Una cadena que representa el nombre del procedimiento en la DLL o código
recurso.
Alias
Nota: Los puntos de entrada de la DLL son sensibles a mayúsculas y minúsculas.
Nota: Si Alias es una cadena vacía, se utiliza MethodName como el Alias.
Una lista de tipos de datos que representan los tipos de datos de los argumentos que son
se pasa al procedimiento cuando se llama. Para los tipos de datos disponibles, consulte
Tipo(s) de argumento
Declarar tipos de datos en la tabla 1 en la página 22
Nota: Para los argumentos de salida, utilice el flag themicByRefflag.
Limitaciones al usar el Objeto Externo
El objeto QuickTestExtern no soporta funciones API con CallBack
mecanismo, y tampoco soporta ninguna función con un parámetro de estructura,
y un puntero a parámetro de función.
BOOL ObtenerInformacionDelCursor( PCURSORINFO pci);
La función utiliza aPCURSORINFO1parámetro que no es compatible con el
función externa
BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam);
La función TheEnumChildProc es una función de callback definida por la aplicación que se utiliza con
la función enumeraVentanasHijas.
Dani Vainstein
1
Se ampliará en el 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);
El ParameterlpEnumFunc es un puntero a una función de callback definida por la aplicación.
Converting to [Link]
El objeto Extern de TheQuickTest no soporta funciones API con CallBack
mecanismo, y además no soporta ninguna función con un parámetro de estructura,
y un puntero a parámetro de función.
Como se dijo antes, hay cientos de funciones de la API de Windows. En la mayoría de los
en muchos casos, no necesitarás la API, porque hay muchos objetos de automatización
(ActiveX, ocx) que nos hacen la vida más fácil para manipular, muchos de los API de Windows
funcionalidad, sin usar directamente la API de Windows (ADODB, EXCEL, MAPI, SHELL,
WSH y más)
Bueno, encontramos la función de la API de Windows que necesitamos, ¿qué sigue?
la sintaxis y la documentación de las funciones se pueden encontrar en MSDN y en todo el
internet. Debes buscar funciones en estilo Visual Basic, o puedes usar el
Visor de texto de API.
Ejemplo 1: Función GetPrivateProfileString
La función recupera una cadena de la sección especificada en una inicialización
archivo (archivo ini)
Figura 2 - Documentación de GetPrivateProfileString de MSDN
Primero, necesitamos la sintaxis de la función:
Dani Vainstein Win32API Página 13 de 22
Capítulo 13 Scripting Quicktest Professional Page 14
Podemos ver que la función devuelve un valor DWORD, de acuerdo con la Declaración
Tipos de datos DWORD = micDWord, El segundo argumento es el nombre del
función que se usará en QuickTest
[Link] micDword, "GetIniString"
El argumento TheLibName se puede encontrar al final de la función MSDN
documentación
No la sección DLL, [Link].
[Link] micDword,"GetIniString","[Link]"
Ahora, el argumento de alias. Para recuperar exactamente el argumento de alias, necesitarás
busca más en Internet, especialmente en las declaraciones de la API de Visual Basic.
puede notar en la documentación que la función se llama WritePrivateProfileA
y también GetPrivateProfileW, donde A significa ASCII y W significa carácter ancho
(Unicode). Cuando una función de API tiene una cadena en uno de los argumentos, necesitas
usar la carta Apost-letra.
[Link] micDword,"GetIniString","[Link]","GetPrivateProfileStringA"
Por último, la lista de argumentos. Debes prestar atención a 2 cosas
1. El tipo de dato de argumento
2. La dirección del argumento (dentro, fuera o dentro-fuera)
LPCTSTR significa: Puntero largo a una cadena de caracteres constante terminada en nulo
LPTSTR significa: Puntero largo a una cadena terminada en nulo
significa que ambos son cadenas, pero la diferencia entre ellos es la dirección
Dani Vainstein Win32API Página 14 de 22
Chapter 13 Scripting Quicktest Professional Page 15
NotelpReturnesStringis [out] parámetro (LPTSTR)
[Link] micDword,"GetIniString","[Link]","GetPrivateProfileStringA", _
micString, micString, micString, micString + micByRef, micDWord, micString
En tu código, usarás la función con la siguiente sintaxis
Dim nBytes, sRetValue
nBytes = [Link] ("Sección","Clave","", sRetValue,256,"C:\[Link]")
MsgBox Bytes devueltos =
MsgBox sRetValue
Ejemplo 2: Función GetServiceKeyName
Esta función recupera un nombre de clave a partir de un nombre de servicio de Windows.
Declarar Función Pública GetServiceKeyName Lib "[Link]" Alias
"GetServiceKeyNameA" (Por Valor hSCManager Como Largo, Por Valor lpDisplayName Como
Cadena, lpServiceName Como Cadena, lpcchBuffer Como Largo) Como Largo
El método TheQuickTestDeclare para el objeto Extern debe comenzar con la declaración.
[Link]
la declaración VB vemos que la última instrucción es As Long. Eso significa que el
la función devuelve un tipo de dato Long, en la tabla de tipos de datos Long=micLong
[Link] micLong
El valor del nombre del método puede ser cualquier cadena única. Se recomienda usar el
el nombre de la función en sí, para seguir los estándares de codificación.
[Link] micLong, "GetServiceKeyName"
El argumento LibName en la declaración de VB es la palabra clave después de Lib. Este
Dani Vainstein Win32API Página 15 de 22
Capítulo 13 Scripting Quicktest Professional Page 16
el argumento se puede escribir de 3 maneras diferentes:
"[Link]" - Este es un archivo dll del sistema, será reconocido desde cualquier lugar en
tu aplicación.
"advapi32" - también puedes quitar la extensión, porque es un sistema conocido
archivo dll.
"C:\Windows\System32\[Link]" - si la dll utilizada no es una dll del sistema, y
no almacenado en System32, deberías escribir la ruta completa.
[Link] micLong, "GetServiceKeyName", "[Link]"
El argumento alias se puede encontrar en la declaración de VB después de la palabra clave Alias.
el alias es muy importante. Es el nombre físico de la función en el archivo dll.
A veces, este nombre cambia a sufijo 'A' (ANSI) 'W' (Unicode/WideChar).
Presta atención a este nombre, es sensible a mayúsculas y minúsculas. Cualquier error de sintaxis generará un
mensaje de error general en tiempo de ejecución. Normalmente funciones que uno de los argumentos es
una cadena, el nombre de alias cambia.
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA"
Los argumentos en la declaración de VB son todos los parámetros
dentro del paréntesis.
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA"
["micLargo","micCadena","micCadena","micLargo"]
Observe la lista de argumentos. Cerca de cada parámetro en la declaración de VB hay un
Por el valor de la palabra clave, excluyendo los parámetros lpcchBuffer y lpServiceName, ellos
están vacíos; significa que los parámetros son valores de retorno (ByRef). Así que, aquí está
la declaración final
[Link] micLong, "GetServiceKeyName", "[Link]", "GetServiceKeyNameA"
micLong, micString, micString + micByRef, micLong + micByRef
Usando la función.
¡La activación de la función debe ser después de la declaración de la función!
Puedes colocar tu declaración un línea antes de su uso, o en la parte superior de la
acción
Puedes colocar la declaración en una acción reutilizable Init.
Puedes poner tu declaración en un archivo de recursos VBS.
En el siguiente ejemplo vamos a recuperar el nombre de la clave del terminal.
ServiciosServicio. Asegúrate de que tienes el Servicio; de lo contrario, elige otro
servicio desde el Panel de Control->Herramientas Administrativas->Servicios.
Para activar esta función en particular, necesitamos el identificador del gestor de servicios, y
entonces necesitamos cerrar el manejador del servicio (liberar la memoria)
Option 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)
Si hSCManager >0 Entonces
nBuffer =0
[Link] hSCManager,"Servicios de Terminal", sKeyName, nBuffer
Msgbox Tamaño de buffer requerido:
nRet=[Link]( hSCManager,"Servicios de Terminal", sKeyName, nBuffer)
Si nRetEntonces
Caja de mensaje El nombre de la clave de servicio es:
nRet = [Link](hSCManager)
Fin Si
Fin Si
La declaración constante se escribió en su valor hexadecimal. Si te mueves a la
vista de palabras clave en QTP o hacer una verificación de sintaxis obtendrás el siguiente error
message:
Este es un error de QTP. Es una declaración legal en VBS, ejecutar el script no generará un
error en tiempo de ejecución
Aspectos destacados de la API Win32 en QuickTest
Deberías notar que el tipo BOOL (Booleano) se evalúa como Entero y no
Booleano. Entonces, 0 (cero) se refiere a Falso y cualquier otro valor a Verdadero.
HWND, HDC, HMENU, etc. - y otros tipos como estos. Todos ellos comienzan con
La mano significa MANIJA, para manijas de diferentes tipos de objetos.
Por ejemplo, HBITMAP es un identificador de mapa de bits; HBRUSH es un identificador de brocha y así sucesivamente.
on. Todos ellos se evalúan a Long y deben ser pasados por valor.
Nota también que LPVOID se declara como variable AsAny. Algunos mensajes
contienen parámetros declarados como Any. Esto significa que este parámetro puede ser una variedad
de tipos (puedes pasar un entero, una cadena, o un tipo definido por el usuario, o lo que sea.
Algunos tipos comienzan con LP. Es una abreviatura de LongPointer a.
LPWORD es en realidad una ubicación de memoria donde se almacenan los datos. No, tú
Dani Vainstein Win32API Página 17 de 22
Capítulo 13 Scripting Quicktest Professional Page 18
no tendrás que llamar a una función para obtener esta dirección. Cuando pases tu argumento
Por defecto (ByRef) en realidad pasas su dirección. Lo que hay que recordar aquí
es que, si el tipo de parámetro comienza con LP-, deberías pasarlo ByRef. Por la
De esta manera, LPARAM no es un puntero. Debes pasar el valor real aquí, así que es
pasó ByVal.
También hay algún tipo extraño NULL. Simplemente elige un método para pasarlo cuando
necesitado. En la mayoría de los casos usa ByVal0& para números, Null o vbNull.
y para cadenas usa vbNullString, para un solo carácter usa vbNullChar.
VOID se utiliza para el valor de retorno de funciones para especificar que no hay tal valor.
La API no tiene Subs, así que esta es la forma en que las implementa. Solo recuerda
- si el valor de retorno es VOID usa micVoid.
Estructuras o tipos de datos complejos. No hay forma de utilizar esos tipos de datos en
QuickTest a través de objeto Extern.
Bueno, si el valor de retorno es una estructura, puedes usar micUnknown, y
manipúlelo de alguna manera en su código, pero, usando la API, las funciones no devuelven
estructuras, debes pasar la estructura ByRef. Y aquí está el problema, el
El objeto Extern no puede hacer esto, VBScript está limitado (sin soporte de API en absoluto) así que, no es posible.
manera de construir una estructura dentro de QuickTest o VBS.
Por ejemplo, hay una función de API muy útil llamada GetCursorPos, la función
devuelve la posición del cursor a través de la estructura POINT.
La solución para este problema en el uso de clases COM personalizadas por el usuario.
Pasando parámetros a las funciones de la API de Win32
Por supuesto que sabes cómo pasar parámetros, solo ponlo en la llamada a la función y es
¡Hecho! Bueno, hay algunos detalles de los que deberías estar al tanto al pasar.
parámetros para funciones de API.
ByValorByRef. Normalmente no tienes que preocuparte por estas palabras clave, ya que API de VB
El visor de texto declara los parámetros de la función como los solicita la API y cuando tú
simplemente ingresa tu valor, se pasa tal como se declara.
Generalmente, cuando un valor se pasa por valor (passByVal), el valor real se pasa directamente al
función, y cuando se pasa por referencia, se pasa la dirección (puntero) del valor.
Pasar cadenas a la función API tampoco es difícil. La API espera la dirección de
el primer carácter de la cadena y lee hacia adelante desde esta dirección hasta que alcanza un
Caracter nulo. Suena mal, pero así es como el sistema operativo maneja realmente las cadenas.
lo único que hay que recordar es siempre pasar el StringByRef.
La situación es ligeramente diferente cuando esperas que se devuelva cierta información.
por la función. Aquí está la declaración de las funciones de GetComputerNameAPI:
[Link] micLong, "GetComputerName", _
"[Link]", "GetComputerNameA", micString + micByRef, micLong + micByRef
El primer parámetro es un puntero largo a una cadena, y el segundo es la longitud de la
cadena. Si solo declaras una variable de Tamaño de Buffer y la pasas a esta función, un
ocurre un error. Entonces, debes inicializar el tamaño del búfer primero. Aquí está cómo obtener el
computer name:
Opción 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)
Algunas funciones también esperan arreglos. Aquí hay un ejemplo. Los últimos dos parámetros.
son arreglos de Long. Para pasar un arreglo a una función, solo pasas el primer elemento.
Aquí hay un código de ejemplo:
Opción Explícita
[Link] micLong,"SetSysColors", usuario32","EstablecerColoresDelSistema", _
micLong, micLong+micByref, micLong+micByref
Privado Const COLOR_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) = COLOR_CAPTURA_ACTIVA
SysColor(1) = COLOR_CAPTIONINACTIVO
SysColor(2) = COLOR_TEXTO_DEL_CAPTION
SysColor(3) = COLOR_TEXTOCAPTION_INACTIVO
ColorValues(0) = RGB(58,158,58)'verde oscuro
ColorValues(1) = RGB(93,193,93)'verde claro
ColorValues(2) = 0'negro
ColorValues(3) = RGB(126,126,126)'gray
nRet = [Link](4, SysColor(0), ColorValues(0))
Funciones de Retorno
Una devolución de llamada es una función que escribes y le dices a Windows que llame por alguna razón.
crea tu propia función con un número y tipo de parámetros especificado, luego di
Ventanas para las cuales esta función debería ser llamada por alguna razón y sus parámetros
llenado con alguna información que necesitas. Luego Windows llama a tu función, tú manejas el
parámetros y salir de la función devolviendo algún tipo de valor. Un uso típico
de las devoluciones de llamada es para recibir un flujo continuo de datos de Windows. Este tema
tampoco es compatible con QuickTest.
Interactuando con un archivo dll personalizado
También puedes interactuar con tus DLL de personalización, tus DLL de aplicaciones probadas.
Cada vez que escriben en VB, C o C++.
La biblioteca de tiempo de ejecución de Microsoft C tiene el nombre de archivo [Link].
[Link] micLong, "abs","C:\RTO\[Link]","abs", micLong
Msgbox [Link](-55)
Interacción entre la API de Win32 y QuickTest
Una característica muy agradable y útil (para mí) es resaltar automáticamente un objeto.
antes de acceder a él.
Dani Vainstein Win32API Página 19 de 22
Capítulo 13 Scripting Quicktest Professional Page 20
For example I want to Click a button in my application, usingQTP.
Para mí, implementar el código es muy simple.
Ventana( "W" ).BotónVentana( "B" ).Click
Para mí es una línea de código, pero, diciéndote la verdad, esta función hace mucho más.
Verifica si el objeto existe.
Verifique si el objeto está habilitado.
Destacar el objeto
Hacer clic
Primero uso la función RegisterUserFunc para anular el método del objeto común
Dentro de la función sobreescrita, realizo una consulta [Link] y [Link].
Llamo a alguna API de win32 para la función de resaltar, y luego hago clic en el botón.
Más para TextEdit, Lista, WebEdit, WebList, también añado un punto de sincronización para lo esperado
resultado.
Al resaltar cada objeto antes de que QTP acceda a él, se disminuirá el rendimiento.
Tu script será más lento, pero creo que vale la pena. Puedes seguir visualmente cada operación que
QTP hace sobre tu aplicación. Y por supuesto puedes añadir un Entorno o Global
Parámetro que omite el resaltado, al ejecutar el script por la noche.
Sobrescritura
RegisterUserFunc "Image", "Click", "ControlsImageClick",True
RegistrarUsuarioFunc "BotónWeb", "Clic", "ClicBotónWeb", Falso
RegisterUserFunc "WebTable", "Blink", "fBlink",False
RegisterUserFunc "WebElement", "Click", "WebElementClick",False
RegisterUserFunc "WebEdit", "Set", "WebEditSet",False
Función Pública WebEditSet(ByRef sender, ByVal value)
** Validación ya realizada por ControlsBlink, no es necesario volver a validar
Llamar a fBlink( remitente, 2 )
Si [Link] = micFailEntonces Salida Función
[Link] valor
Fin Función
Al llamar a Browser( "B" ).Page( "P" ).WebEdit( "WE" ).Set "muestra"
Qtp RegisterUserFunc anula el método Set de QTP, en su lugar se llama a WebEditSet.
Llamar a fBlink desde WebEditSet comprobará que el objeto existe, de lo contrario, recibiré un
mensaje de error en elReporter.
Si el objeto existe, entonces un proceso de parpadeo ocurrirá durante el tiempo de ejecución y de inmediato el
La función QTP original se llama desde dentro de WebEditSet
Declaraciones 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", _
micInteger, micInteger, micDword
Dani Vainstein Win32API Page 20 of 22
Chapter 13 Scripting Quicktest Professional Page 21
[Link] micInteger, "SetROP2", "gdi32", "SetROP2", micULong, micInteger
[Link] micULong, "SeleccionarObjeto", "gdi32", "SeleccionarObjeto", micULong, micULong
[Link] micULong, "DeleteObject", "gdi32", "DeleteObject", micULong
[Link] micULong, "GetStockObject", "gdi32", "GetStockObject", micInteger
[Link] micULong, "Rectángulo", "gdi32", _
Rectángulo, micULong, micInteger, micInteger, micInteger, micInteger
La función fBlink
' *****************************************************************************
** fBlink
** Descripción : Destaca un control un número específico de veces "Veces
** Todas las funciones son API de Windows - Extern debe ser declarado.
' *****************************************************************************
Público Función fBlink(ByRef remitente, ByVal veces)
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
Si No existe el remitente.( 1 )Entonces
[Link] micFail, "fBlink", "Objeto no encontrado."
Salir de la función
Fin Si
** Recuperar la información del remitente...
Con remitente
nX = .GetROProperty("abs_x")
nY = .GetROProperty("abs_y")
nW = .ObtenerPropiedadRO("ancho")
nH = .GetROProperty("altura")
Fin Con
** Obtén el DC de escritorio
hDC = [Link]([Link]())
** Crear un bolígrafo de tres píxeles de ancho
hPen =[Link]( PS_INSIDEFRAME, PEN_WIDTH, RGB( 255, 0, 0 ) )
Extern.SetROP2 hDC, R2_NO
[Link] hDC, hPen
** Use un relleno vacío
[Link] hDC, [Link]( NULL_BRUSH )
** Haz el resaltado
Para i = 0 hasta times * 2 + 1
[Link]ángulo hDC, nX, nY, nX + nW, nY + nH
Espera 0, 50
Siguiente
** Liberar Recursos
[Link] [Link], hDC
[Link] hPen
Fin Función
Dani Vainstein Win32API Página 21 de 22
Capítulo 13 Scripting Quicktest Professional Page 22
Appendix 13.A
Declarar Tipos de Datos
Constante Valor Description
micVoid 0 vacío (solo tipo de retorno)
micInteger 2 int
micLong 3 largo
micFloat 4 flotar
micDoble 5 doble
micString 8 CHAR*
micDispatch 9 IDispatch*
micWideString 18 WChar*
micChar 19 carácter
micDesconocido 20 IUnknown
micHwnd 21 HWND
micVPtr 22 void*
micShort 23 corto
micWord 24 PALABRA
micDWord 25 DWORD
micByte 26 BYTE
micWParam 27 WPARAM
micLParam 28 LPARAM
micLResultado 29 LRESULT
micByRef h&4000 fuera
micUnsigned h&8000 sin signo
micUChar micChar + micUnsigned unsigned char
micULong micLong + micSinSigno sin signo largo
micUShort micCorto entero corto sin signo