|
|||
| class WIN32OLE |
|
require 'win32ole'
ie = WIN32OLE.new('InternetExplorer.Application')
ie.visible = true
ie.gohome
|
WIN32OLE liefert ein Client-Interface für
Windows-32-OLE-Automation-Server. In der Anleitung auf Seite 166 gibt es dazu
mehr Informationen.
| Konstanten |
WIN32OLE::VERSION |
Aktuelle Versions-Nummer |
| class methods | |
| connect | WIN32OLE.connect( aString ) -> wapi | Liefert einen neuen OLE-Automation-Client, der mit einer existierenden Instanz des genannten Automation-Server verbunden ist. |
| const_load |
WIN32OLE.const_load( wapi,
[aClass=WIN32OLE] )
-> nil |
Definiert die Konstanten des angegebenen Automation-Server als Klassen-Konstanten in aClass. |
| new | WIN32OLE.new( aString ) -> wapi | Liefert einen neuen OLE-Automation-Client, der verbunden ist mit einer neuen Instanz des Automation-Server namens aString. |
| instance methods | |
| [ ] | wapi[ aString ] -> anObject | Liefert die angegebene Eigenschaft des OLE-Automation-Objekts. |
| [ ]= | wapi[ aString ] = aValue-> nil |
Setzt die angegebene Eigenschaft des OLE-Automation-Objekts. |
| each | wapi.each {| anObj | block }-> nil |
Iteriert über jedes Element dieses OLE-Servers, das das
IEnumVARIANT-Interface unterstützt.
|
| invoke | wapi.invoke ( aCmdString, [args]* ) -> anObject |
Ruft das in aCmdString angegebene Kommando mit den angegebenen
args auf. args kann ein Hash sein
mit benamten Parametern und Werten. Man muss invoke nicht explizit aufrufen;
Diese Klasse benutzt method_missing, um Aufrufe über
invoke weiter zu reichen. Man kann also die OLE-Methoden als einfache
Methoden dieser Klasse benutzen.
|
| class WIN32OLE_EVENT |
|
require 'win32ole'
$urls = []
def navigate(url)
$urls << url
end
def stop_msg_loop
puts "IE has exited..."
throw :done
end
def default_handler(event, *args)
case event
when "BeforeNavigate"
puts "Now Navigating to #{args[0]}..."
end
end
ie = WIN32OLE.new('InternetExplorer.Application')
ie.visible = TRUE
ie.gohome
ev = WIN32OLE_EVENT.new(ie, 'DWebBrowserEvents')
ev.on_event {|*args| default_handler(*args)}
ev.on_event("NavigateComplete") {|url| navigate(url)}
ev.on_event("Quit") {|*args| stop_msg_loop}
catch(:done) {
loop {
WIN32OLE_EVENT.message_loop
}
}
puts "You Navigated to the following URLs: "
$urls.each_with_index do |url, i|
puts "(#{i+1}) #{url}"
end
|
WIN32OLE_EVENT wird in Verbundung mit WIN32OLE
benutzt, um Callbacks für Windows-32-Ereignisse zu erhalten.
| class methods | |
| message_loop |
WIN32OLE_EVENT.message_loop
-> nil |
Führt die Windows-Ereignis-Schleife aus, die Ereignisse interpretiert und verteilt. |
| new | WIN32OLE_EVENT.new ( anOle, aName ) -> wapi |
Liefert ein neues WIN32OLE_EVENT (einen Ereignis-Fänger) für das angegebene
WIN32OLE-Objekt und die genannte Ereignis-Quelle. Falls aName nil ist, wird versucht, die Default-Quelle zu benutzen und es wird ein
RuntimeError ausgelöst, wenn eine solche nicht gefunden werden kann.
|
| instance methods | |
| on_event | wapi.on_event ( [anEvent] )
{| args | block }-> nil |
Defiiert einen Callback für das genannte anEvent. Falls anEvent nil ist, wird dieser Callback mit allen Events verbunden.
Der Block bekommt alle für dieses Ereignis zuständige Argumente.
|
| class Win32API |
|
ext/Win32API:
require 'Win32API'
getCursorPos = Win32API.new("user32", "GetCursorPos", ['P'], 'V')
lpPoint = " " * 8 # store two LONGs
getCursorPos.Call(lpPoint)
x, y = lpPoint.unpack("LL") # get the actual values
print "x: ", x, "\n"
print "y: ", y, "\n"
ods = Win32API.new("kernel32", "OutputDebugString", ['P'], 'V')
ods.Call("Hello, World\n")
GetDesktopWindow = Win32API.new("user32", "GetDesktopWindow", [], 'L')
GetActiveWindow = Win32API.new("user32", "GetActiveWindow", [], 'L')
SendMessage = Win32API.new("user32", "SendMessage", ['L'] * 4, 'L')
SendMessage.Call(GetDesktopWindow.Call, 274, 0xf140, 0)
|
Win32API-Modul erlaubt den Zugriff auf alle Windows-32-Funktionen. Viele
dieser Funktionen nehmen einen Pointer-Datentyp entgegen oder liefern ihn
zurück --- ein Speicherbereich, der zu einem C-String oder -Structure gehört.
In Ruby werden diese Pointer mit der Klasse String repräsentiert,
die eine Folge von 8-bittigen Bytes enthält. Wenn man will kann man die Bits in dem
String packen oder entpacken. Siehe die Referenz für unpack auf
Seite 383 und für pack auf Seite 290.
| class methods | |
| new | Win32API.new( dllname, procname, importArray, export ) -> wapi | Liefert ein neues Objekt, das eine Windows-32-API-Funktion repräsentiert. dllname ist der Name der DLL, die diese Funktion enthält, etwa ``user32'' oder ``kernel32.'' procname ist der Name der gewünschten Funktion. importArray ist ein Array mit Strings, die die Typen der Argumente der Funktion repräsentieren. export ist ein String, der den Rückgabe-Typ der Funktion repräsentiert. Die Strings ``n'' und ``l'' repräsentieren Zahlen, ``i'' repräsentiert Integer, ``p'' repräsentiert Pointer für Daten, die in einem String gespeichert werden und ``v'' repräsentiert einen Void-Typ (wird nur für die Rückgabe von Daten benutzt). Diese Strings unterscheiden Groß- und klein-Buchstaben. |
| instance methods | |
| call | wapi.call( [args]* ) -> anObject |
Ruft diese API-Funktion mit den angegebenen Argumenten auf, die auf die bei
new angegebene Signatur passen müssen.
|
| Call | wapi.Call( [args]* ) -> anObject |
Synonym für Win32API#call.
|