O TEMA DO FÓRUM ESTÁ EM MANUTENÇÃO. FEEDBACKS AQUI: ACESSAR

Win32API: Aula 1 - Introdução

Iniciado por Raizen, 28/03/2014 às 17:38

Imprimir
Ir para o fim Páginas1
Ações
28/03/2014 às 17:38
[box class=errorbox2]
Win32API
Aula 1 - Introdução
[/box]
Autor: Kyo Panda

[box class=catbg2][info float=right border=none].[/info].
Sumário de Aulas Win32API:[/box]

[box class=catbg2][info float=right border=none].[/info].
Sumário:[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Introdução:[/box]

Você já deve ter visto scripts que realizam funções, até então, inimagináveis para RPG Maker, que incluem desde sistemas de mouse, até scripts que mudam o tamanho da janela do programa. Estes e outros scripts apenas são acessados através da classe de Ruby Win32API.

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
No que consiste a Win32API?[/box]
A Win32API foi criada para acessar funções de DLL (bibliotecas de funções), seja do Windows ou de fontes externas. Logo, funções que não são aceitas pela Ruby, podem ser facilmente acessadas utilizando esta classe, aumentando suas dimensões como scripter.

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Como definir uma classe Win32API?[/box]
Segue-se o seguinte modelo para iniciar uma Win32API:

[box class=errorbox2]Win32API.new("DLL", "Função", "Argumentos", "Retorno")







Parâmetro
Descrição
"DLL"
O nome da DLL que executará a função API (ex.: "Kernel32", "User32", "GDI32").
"Função"
A função que será executada na DLL, definidas de acordo com a mesma.
"Argumentos"
Os argumentos pedidos pela função. Tais argumentos possuem valores específicos, que serão ditados a seguir.
"Retorno"
O valor que será retornado. Geralmente é retornado um valor boleano, mas isso não quer dizer que seja necessariamente isso que precise, como será explicado futuramente.
[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Como chamar uma classe Win32API?[/box]
A classe Win32API possui um método de chamada chamado call, esse é o único método da classe Win32API (ignorando o método new), mostrando sua simplicidade operacional. Segue-se o modelo de chamada:

[box class=errorbox2]Win32API.call("Argumentos")




Parâmetro
Descrição
"Argumentos"
Os argumentos pedidos pela função, como definidos em sua criação. Atenha-se ao próximo tópico para aprender a lidar com os argumentos.
[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Como definir os argumentos?[/box]
A Win32API utiliza um método muito interessante de definir seus argumentos. Desde que eles são variáveis (mudam de função para função) nota-se que um sistema eficiente deveria ser criado para lidar com isso. Agora vamos a definição dos argumentos:

[box class=errorbox2]argumentos = "LIPNV"

Confuso? Não. Vamos aprender como funciona a definição dos argumentos.

Em Win32API os argumentos são definidos por uma string em uma sucessão de letras que indicam o que cada valor significa para ser chamado pela função da DLL. Cada letra indica um valor específico, que varia de Long, Integer, String, Struct ou Void. Eis a definição de cada valor, indicado por suas devidas letras:








"L"
Long
Um número longo. Varia em seu valor e forma. É comumente utilizado para expressar números no Windows. Difere-se do Integer por ser mutável em sua forma, podendo ser formado por mais Bytes, e alcançar valores diferentes segundo sua aplicação.
"I"
Integer
Um número inteiro. Um número definido inteiro, Difere-se do Long pelo fato de o mesmo representar números inteiros, como 0 e 1.
"P"
String
Uma string, ou texto.
"P"
Struct
O valor "P" também é utilizado para armazenar estruturas em Win32API, ou seja, vários valores inclusos dentro da mesma. Estruturas são uma forma mais avançada de utilizar a Win32API, e serão abordadas mais tarde.
"N"
Long
Possuem o mesmo valor e sentido de "L".
"V"
Void
Valor nulo. Usado apenas para exportação da valores.

Estes são os valores primários dos parâmetros, sempre são definidos de acordo com o que pede a função, logo é estritamente importante descobrir os parâmetros da função que deseja executar para que a mesma não falhe. Será explicado como encontrar os seus valores à seguir.

Atente-se que o valor de Retorno segue o mesmo processo dos parâmetros, pela única diferença que o valor de retorno é único, não podendo ser combinados com outros.
[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Onde encontrar informações sobre como usar uma função?[/box]
Quando tratamos de DLLs paralelas, ou seja, DLLs que não são pertencentes ao Windows, seus valores são ocultos, o único modo de encontrá-las é contatando o criador das mesmas.

Mas, se for uma DLL do Windows, é fácil encontrar seus valores. Citemos alguns métodos à seguir.

[box class=errorbox2]MSDN (Microsoft Developer Network)

É um site criado pela Microsoft que visa disponibilizar recursos para programadores das mais diferentes plataformas de programação. Todas as funções das DLLs do Windows são citadas lá, assim como suas descrições e o modo que ela age no sistema. Claro que se deve haver o mínimo de conhecimento em inglês, pois todas as funções lá citadas estão em inglês. Mas caso não domine a língua, há diversos sites na internet que disponibilizam as descrições de seus valores em português, o que deve resolver o caso.[/font]

[box class=errorbox2]API Guide

É um programa que lista grande parte (não todas) as funções das DLLs do Windows. É uma grande ajuda aqueles que não possuem acesso direto à internet. Mas um aviso: Tal programa não descreve as constantes das funções, ou seja, os valores que quando utilizados em relação aos parâmetros determinados das funções, regem o que a função deve fazer.
[/box][/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Descobrindo os parâmetros de uma função.[/box]
[box class=errorbox2]API Guide

Pelo API Guide, penso que seria mais fácil de identificar os valores necessários das funções. Logo iniciaremos por ele:


Selecione a função desejada pela lista que se encontra à esquerda do programa e abra a aba Parameters. Aqui é definido todos os parâmetros da função. A função selecionada aqui foi a MessageBox. Veja em sua declaração (caixa Declaration),  a DLL é indicada: "User32", o nome da função é a própria função, no caso "MessageBox", e seguem-se os valores de cada parâmetro: hWnd As Long, lpText As String, lpCaption As String e wType As Long. Então temos: Long, String, String, Long, ou "LPPL". Bem simples, não?

Algumas funções pode possuir valores como Struct, que serão explicados depois.

O que cada parâmetro significa é mostrado na caixa Parameters dessa janela. Observando e realizando uma breve análise nos valores temos:






hWnd
Handle da janela que será pai da caixa de mensagens (explicarei o que são handles em Win32API, mas como esse valor é opcional, manteremos como 0).
lpText
Texto da janela de mensagem.
lpCaption
Título da janela de mensagem.
uType
Tipo da janela (como é só um exemplo, usaremos a janela básica, de valor 0).

O valor de retorno se encontra na caixa Return values logo abaixo, analisando, ela retornará zero se não funcionar e outro valor se funcionar, então, qual é o valor do Retorno? Seria "I", "L" ou "N", pois trata-se de um número.

Assim temos nossa função formada:

[box class=errorbox2]Win32API.new("User32", "MessageBox", "LPPL", "l")[/box]

[box class=errorbox2]MSDN (Microsoft Developer Network)[/box]


No MSDN segue o mesmo modelo, mas nem sempre serão mostrados valores como As Long ou As String, logo cabe à você ler as instruções de cada valor e descobrir do que ele se trata.
[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Como executar uma Win32API?[/box]
Esta é a hora de executar a nova Win32API formada. Tomando como exemplo a Win32API acima, sabemos que para executá-la necessitaremos de 4 valores (referentes ao "LPPL"). Então, como proceder com isso? Bem, analisando o que cada valor significa, é realmente fácil utilizar a Win32API, com o simples comando call. Vejamos um exemplo:

[box class=errorbox2]
# Cria uma nova Win32API com a função MessageBox
c = Win32API.new("User32", "MessageBox", "LPPL", "L")

# Executa a função MessageBox
c.call(0, "Hello world!", "Mensagem", 0)

Simples, não? Vejam que acabamos de criar um substituto notável para o comando print padrão do Ruby, que podemos deixar melhor até que o mesmo, se soubermos trabalhar com estes valores.
[/box]

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Finalização:[/box]
Estes são os comandos básicos do Win32API. Conhecendo os valores necessários para cada função, nada é impossível de fazer. Você pode programar facilmente com esta classe os mais diversos tipos e modelos de programas. Até a próxima.

[box class=catbg2][info float=right border=none][Voltar ao topo][/info].
Perguntas:[/box]

  • Onde encontro a classe Win32API?
    Desde que a classe Win32API é uma classe built-in do Ruby, ou seja, uma classe primária do Ruby, ela já está embutida no RPG Maker.
28/03/2014 às 18:11 #1
 Hahahha bem legal você ter trazido essa aula aqui.. eu aprendi a mexer com isso através delas.. vou ver se trago as minhas para cá de Win32API e DLL


Imprimir
Ir para o topo Páginas1
Ações