Beiträge von BugFix

**BugFix**

Tipp: Arbeite im OnEvent-Mode. Das vereinfacht die Sache wesentlich.

**BugFix**

Yep, die kosten nicht so viel Stangen.

Zitat

Problem: Die NUM-Minustaste brauch man um bei SciTe schnell Zeilen auszukommentieren.

Ersatzlösung: STRG+Q tut's auch
Geht auch ganz fix (li. Daumen + li. Zeigefinger). Und du mußt die Hand nicht großartig bewegen. NUM- ist ja die am weitesten entfernte Taste auf der Tastatur. Bin icih viel zu faul zu

**BugFix**

Ich hab jetzt mal noch eine Erläuterung hinzugefügt, die hoffentlich alle Klarheiten restlos beseitigt
Objekt: Scripting.Dictionary

**BugFix**

Oder du nimmst ein Flex-Board, wie es auf Intensivstationen verwendet wird.
Das kannst du hemmungslos in ein Waschbecken schmeißen und mal gründlich abbürsten.

**BugFix**

Zitat

Also BugFix sicherlich mit einer Arraylösung

Nöö, hierfür bietet sich doch supi das Dictionary-Objekt an.
Legt mal schön los, mal sehen was so wird.

**BugFix**

Dann setz doch nen Zeilenumbruch:

GUICtrlSetData($Edit1, StringFormat($box3 & $box1 & " Ping:" & $edittext & @LF))

**BugFix**

Wenn du mehrere Checkboxen abfragen willst, ist folgendes Beispiel vllt. hilfreich.
Hier setzt du für 'Checked' deinen eigenen Statuswert (Bitwert), der für jede Box unterschiedlich ist. Startwert für alle Checkboxen ist dabei 'UnChecked'.
Egal, welche Boxen markiert sind - die Summe des Statuswertes ist eineindeutig. D.h. wenn z.B. der Wert 3 ist, sind die Boxen 1 und 2 markiert.
Das läßt sich dann prima mit Switch verarbeiten.

Spoiler anzeigen

[autoit]

#include <GUIConstants.au3>
Opt("GUIOnEventMode", 1)
Dim $CB_Bit = 0
#Region ### START Koda GUI section ### Form=
$Form1 = GUICreate("Form1", 460, 318, 286, 144)
GUISetOnEvent($GUI_EVENT_CLOSE, "Form1Close")
$Checkbox1 = GUICtrlCreateCheckbox("Checkbox1", 54, 42, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox1Click")
$Checkbox2 = GUICtrlCreateCheckbox("Checkbox2", 54, 81, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox2Click")
$Checkbox3 = GUICtrlCreateCheckbox("Checkbox3", 54, 120, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox3Click")
$Checkbox4 = GUICtrlCreateCheckbox("Checkbox4", 54, 160, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox4Click")
$Checkbox5 = GUICtrlCreateCheckbox("Checkbox5", 54, 199, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox5Click")
$Checkbox6 = GUICtrlCreateCheckbox("Checkbox6", 54, 238, 97, 17)
GUICtrlSetOnEvent(-1, "Checkbox6Click")
$Input1 = GUICtrlCreateInput("", 282, 38, 121, 21)
$Label1 = GUICtrlCreateLabel("Markiert sind:", 206, 42, 67, 17)
GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###

[/autoit] [autoit][/autoit] [autoit]

While 1
Sleep(100)
WEnd

[/autoit] [autoit][/autoit] [autoit]

Func Form1Close()
Exit
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Checkbox1Click()
$CB_Bit = BitXOR($CB_Bit, 1)
_CBRead()
EndFunc
Func Checkbox2Click()
$CB_Bit = BitXOR($CB_Bit, 2)
_CBRead()
EndFunc
Func Checkbox3Click()
$CB_Bit = BitXOR($CB_Bit, 4)
_CBRead()
EndFunc
Func Checkbox4Click()
$CB_Bit = BitXOR($CB_Bit,
_CBRead()
EndFunc
Func Checkbox5Click()
$CB_Bit = BitXOR($CB_Bit, 16)
_CBRead()
EndFunc
Func Checkbox6Click()
$CB_Bit = BitXOR($CB_Bit, 32)
_CBRead()
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _CBRead()
Local $str = ''
If BitAND($CB_Bit, 1) Then $str &= 1 & ', '
If BitAND($CB_Bit, 2) Then $str &= 2 & ', '
If BitAND($CB_Bit, 4) Then $str &= 3 & ', '
If BitAND($CB_Bit, Then $str &= 4 & ', '
If BitAND($CB_Bit, 16) Then $str &= 5 & ', '
If BitAND($CB_Bit, 32) Then $str &= 6
GUICtrlSetData($Input1, $str)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

; mögliche Abarbeitung:
Switch $CB_Bit
Case 1
; Code für CB 1 markiert
Case 2
; Code für CB 2 markiert
Case 3
; Code für CB 1+2 markiert
Case 4
; Code für CB 3 markiert
Case 5
; Code für CB 1+3 markiert
; usw.....
EndSwitch

[/autoit]

**BugFix**

Wenn du z.B. ein Inputfeld zur Eingabe markierst, dann blinkt dort drinnen das 'Caret'. Tippst du ein Zeichen wandert das Caret ein Zeichen weiter.
Das Zeichen sieht aus wie auf der Tastatur die Pipe.

**BugFix**

Er möchte die Caret-Position wissen.
Allerdings sehe ich darin keinen Sinn. Wenn das entsprechende Control den Focus hat, werden alle Eingaben automatisch beginnend an der Caret-Position getätigt.

**BugFix**

Zitat

weiß ich aber nicht wie man etwas rückgängig machen kann

Kommt immer drauf an, was du rückgängig machen willst. Aber kaum ein Control unterstützt von Haus aus die Undo-Funktion.
Bleibt also nur alle Daten zwischenspeichern und bei Undo den letzten Zustand wiederherstellen.

**BugFix**

Ich habe keine probable Lösung zur Hand - ich lasse das immer in einer Testschleife mit Zähleranzeige laufen, bis das gewünschte Zeichen erscheint.
Ich kann nur bestätigen, dass die im Reshacker angezeigten ID's gar nix mit den Windowsinternen ID's der shell32.dll zu tun haben.
Es ist nicht mal ein konstanter Versatz oder sonstiges System erkennbar.

**BugFix**

So schwer....
left: A-D (x links)
right: B-C (x rechts)
top: A-B (y oben)
bottom: C-D (y unten)

**BugFix**

Freut mich, wenn es euch gefällt. :]

Greenhorn:
Wenn du zum FSO noch Fragen hast, melde dich doch einfach.
Adhoc wüßte ich jetzt nicht, an welchen Punkten ich die Erläuterung vertiefen sollte.

**BugFix**

Dann verabschiede dich von Sprüngen
Fang an strukturiert zu denken

So gehts z.B.

[autoit]

If FileExists($file) Then
If FileGetVersion($file) = 'Versionsnr.-NEU' Then Exit
EndIf
FileInstall('.....')

[/autoit]

**BugFix**

Ich habe zu dem Objekt Dictionary (s. hier) eine UDF-Sammlung erstellt.

*** Funktionssammlung ***

_ObjDictCreate(Modus)
Erzeugt ein Dictionary Objekt im Binär- (default) oder Textmodus
Gibt das Handle des Objektes zurück

_ObjDictAdd(Objekt, Schlüssel, Wert)
Fügt einem Dictionary Objekt ein Schlüssel-Wert Paar hinzu

_ObjDictGetValue(Objekt, Schlüssel)
Liest den Wert für einen Schlüssel aus

_ObjDictSetValue(Objekt, Schlüssel, Wert)
Setzt einen neuen Wert für einen Schlüssel

_ObjDictCount(Objekt)
Gibt die Anzahl der Schlüssel-Wert Paare zurück

_ObjDictSearch(Objekt, Schlüssel)
Prüft ob der Schlüssel existiert, liefert 'TRUE' wenn gefunden

_ObjDictDeleteKey(Objekt, Schlüssel)
Löscht den angegebenen Schlüssel (und dessen Wert)
Wird statt eines Schlüsselnamens '' übergeben,
werden alle Schlüssel gelöscht (Standard)

_ObjDictList(Objekt)
Eine GUI mit einem ListView zeigt alle Schlüssel-Wert Paare

_IniReadSectionToObjDict(Objekt, INI-Pfad, Sektion)
Liest die angegebene INI-Sektion in das Objekt
Gibt Anzahl gelesener Paare zurück

_IniWriteSectionFromObjDict(Objekt, INI-Pfad, Sektion)
Schreibt die Schlüssel-Wert Paare des Objekts in die angegebene Sektion
der INI-Datei
Gibt Anzahl geschriebener Paare zurück

_FileReadToObjDict(Objekt, TextDatei-Pfad, Seperator)
Liest aus einer Textdatei alle Schlüssel-Wert Paare zeilenweise ein (1 Paar/Zeile)
Standard-Seperator ist '|', kann hier angepaßt werden
Gibt Anzahl gelesener Paare zurück

_FileWriteFromObjDict(Objekt, TextDatei-Pfad, Seperator, Overwrite)
Schreibt die Schlüssel-Wert Paare des Objekts in die angegebene Datei (1 Paar/Zeile)
Standard-Seperator ist '|', kann hier angepaßt werden
Gibt Anzahl geschriebener Paare zurück

Edit 24.10.07: _FileReadToObjDict() und _FileWriteFromObjDict() fertiggestellt

Edit 25.10.07:
Ergänzungen für SciTE
- Einträge für Autovervollständigung erstellt
- Abkürzungen erstellt
- Programm zur Aktualisierung der Autovervollständigungs- und Abkürzungsdatei erstellt (verwendet angehängte INI)

Spoiler anzeigen

[autoit]

#include <GuiConstants.au3>
#include <GuiListView.au3>

[/autoit] [autoit][/autoit] [autoit]

; Dictionary Objekt erstellen
$oTest = _ObjDictCreate(1)

[/autoit] [autoit][/autoit] [autoit]

; Schlüsselpaare hinzufügen
_ObjDictAdd($oTest, 'Schlüssel1', 'Wert1')
_ObjDictAdd($oTest, 'Schlüssel2', 'Wert2')
_ObjDictAdd($oTest, 'Schlüssel3', 'Wert3')

[/autoit] [autoit][/autoit] [autoit]

; Anzeige aller Schlüssel-Wert Paare
_ObjDictList($oTest, 'Einträge hinzugefügt')

[/autoit] [autoit][/autoit] [autoit]

; Wert von 'Schlüssel1' auslesen
MsgBox(0, 'Wert von Schlüssel1', _ObjDictGetValue($oTest, 'Schlüssel1'))

[/autoit] [autoit][/autoit] [autoit]

; Wert von 'Schlüssel1' neu setzen
_ObjDictSetValue($oTest, 'Schlüssel1', 'neuer Wert')
MsgBox(0, ' geänderter Wert Schlüssel1', _ObjDictGetValue($oTest, 'Schlüssel1'))

[/autoit] [autoit][/autoit] [autoit]

; Anzahl Schlüssel-Wert Paare ermitteln
MsgBox(0, 'Anzahl Schlüssel-Wert Paare', _ObjDictCount($oTest))

[/autoit] [autoit][/autoit] [autoit]

; Suchen ob 'Schlüssel3' vorhanden
If _ObjDictSearch($oTest, 'Schlüssel3') Then
MsgBox(0, 'Ergebnis Suche', 'Schlüssel3 - vorhanden')
EndIf
_ObjDictList($oTest, 'vor dem Löschen')

[/autoit] [autoit][/autoit] [autoit]

; 'Schlüssel2' löschen
_ObjDictDeleteKey($oTest, 'Schlüssel2')
_ObjDictList($oTest, 'Schlüssel2 gelöscht')

[/autoit] [autoit][/autoit] [autoit]

; alle Schlüssel löschen
_ObjDictDeleteKey($oTest, '')
_ObjDictList($oTest)

[/autoit] [autoit][/autoit] [autoit]

#cs
============================= OBJEKT 'Scripting.Dictionary' =======================================
*** Funktionssammlung ***

[/autoit] [autoit][/autoit] [autoit]

_ObjDictCreate(Modus)
Erzeugt ein Dictionary Objekt im Binär- (default) oder Textmodus
Gibt das Handle des Objektes zurück

_ObjDictAdd(Objekt, Schlüssel, Wert)
Fügt einem Dictionary Objekt ein Schlüssel-Wert Paar hinzu

_ObjDictGetValue(Objekt, Schlüssel)
Liest den Wert für einen Schlüssel aus

_ObjDictSetValue(Objekt, Schlüssel)
Setzt einen neuen Wert für einen Schlüssel

_ObjDictCount(Objekt)
Gibt die Anzahl der Schlüssel-Wert Paare zurück

_ObjDictSearch(Objekt, Schlüssel)
Prüft ob der Schlüssel existiert, liefert 'TRUE' wenn gefunden

_ObjDictDeleteKey(Objekt, Schlüssel)
Löscht den angegebenen Schlüssel (und dessen Wert)
Wird statt eines Schlüsselnamens '' übergeben,
werden alle Schlüssel gelöscht (Standard)

_ObjDictList(Objekt)
Eine GUI mit einem ListView zeigt alle Schlüssel-Wert Paare

_IniReadSectionToObjDict(Objekt, INI-Pfad, Sektion)
Liest die angegebene INI-Sektion in das Objekt
Gibt die Anzahl der gelesenen Schlüssel-Wert Paare zurück

_IniWriteSectionFromObjDict(Objekt, INI-Pfad, Sektion)
Schreibt die Schlüssel-Wert Paare des Objekts in die angegebene Sektion
der INI-Datei
Gibt die Anzahl der geschriebenen Schlüssel-Wert Paare zurück

_FileReadToObjDict(Objekt, TextDatei-Pfad, Seperator)
Liest aus einer Textdatei alle Schlüssel-Wert Paare zeilenweise ein (1 Paar/Zeile)
Standard-Seperator ist '|', kann hier angepaßt werden
Gibt die Anzahl der gelesenen Schlüssel-Wert Paare zurück

_FileWriteFromObjDict(Objekt, TextDatei-Pfad, Seperator, Overwrite)
Schreibt die Schlüssel-Wert Paare des Objekts in die angegebene Datei (1 Paar/Zeile).
Mit Overwrite='TRUE' (Standard) wird die angegebene Datei, falls sie bereits existiert,
überschrieben. Mit 'FALSE' wird an eine bestehende Datei angehängt.
Standard-Seperator ist '|', kann hier angepaßt werden.
Gibt die Anzahl der geschriebenen Schlüssel-Wert Paare zurück

Autor: BugFix ( [email='bugfix@autoit.de'][/email] )

[/autoit] [autoit][/autoit] [autoit]

===================================================================================================
#ce
#include <GuiConstants.au3>
#include <GuiListView.au3>
;==================================================================================================
; Parameter: $MODE
; 0 Binär (default)
; 1 Text
; Return: Objekt Handle
;==================================================================================================
Func _ObjDictCreate($MODE=0)
$oDICT = ObjCreate('Scripting.Dictionary')
If $MODE <> 0 Then $oDICT.CompareMode = 1
Return $oDICT
EndFunc ;==>_ObjDictCreate

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $KEY - Schlüssel
; $VALUE - Wert
; Return: Erfolg: 0
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 2 Schlüssel ohne Inhalt übergeben
; 3 Wert hat keinen Inhalt
; 4 Schlüssel bereits vorhanden
;==================================================================================================
Func _ObjDictAdd(ByRef $oDICT, $KEY, $VALUE)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $KEY = '' Then
SetError(2)
Return -1
ElseIf $VALUE = '' Then
SetError(3)
Return -1
ElseIf $oDICT.Exists($KEY) Then
SetError(4)
Return -1
EndIf
$oDICT.Add($KEY, $VALUE)
Return 0
EndFunc ;==>_ObjDictAdd

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $KEY - Schlüssel
; Return: Erfolg: Wert des Schlüssels
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 2 Schlüssel ohne Inhalt übergeben
; 5 Schlüssel nicht vorhanden
;==================================================================================================
Func _ObjDictGetValue(ByRef $oDICT, $KEY)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $KEY = '' Then
SetError(2)
Return -1
ElseIf Not $oDICT.Exists($KEY) Then
SetError(5)
Return -1
EndIf
Return $oDICT.Item($KEY)
EndFunc ;==>_ObjDictGetValue

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $KEY - Schlüssel
; $VALUE - Wert
; Return: Erfolg: 0
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 2 Schlüssel ohne Inhalt übergeben
; 3 Wert hat keinen Inhalt
; 5 Schlüssel nicht vorhanden
;==================================================================================================
Func _ObjDictSetValue(ByRef $oDICT, $KEY, $VALUE)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $KEY = '' Then
SetError(2)
Return -1
ElseIf $VALUE = '' Then
SetError(3)
Return -1
ElseIf Not $oDICT.Exists($KEY) Then
SetError(5)
Return -1
EndIf
$oDICT.Item($KEY) = $VALUE
Return 0
EndFunc ;==>_ObjDictSetValue

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; Return: Erfolg: Anzahl der Schlüssel-Wert Paare
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
;==================================================================================================
Func _ObjDictCount(ByRef $oDICT)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
EndIf
Return $oDICT.Count
EndFunc ;==>_ObjDictCount

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $KEY - Schlüssel
; Return: Erfolg: TRUE Schlüssel vorhanden
; FALSE Schlüssel nicht vorhanden
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 2 Schlüssel ohne Inhalt übergeben
;==================================================================================================
Func _ObjDictSearch(ByRef $oDICT, $KEY)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $KEY = '' Then
SetError(2)
Return -1
ElseIf Not $oDICT.Exists($KEY) Then
Return False
Else
Return True
EndIf
EndFunc ;==>_ObjDictSearch

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $KEY - Schlüssel (default='')
; mit $KEY = '' werden alle Schlüssel gelöscht
; Return: Erfolg: 0
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
;==================================================================================================
Func _ObjDictDeleteKey(ByRef $oDICT, $KEY='')
If Not IsObj($oDICT) Then
SetError(1)
Return -1
EndIf
If $KEY = '' Then
$oDICT.RemoveAll
Return 0
ElseIf Not $oDICT.Exists($KEY) Then
SetError(5)
Return -1
EndIf
$oDICT.Remove($KEY)
Return 0
EndFunc ;==>_ObjDictDeleteKey

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $TITLE - Fenstertitel (optional)
; Return: Erfolg: GUI mit ListView
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; Requirements: #include <GuiConstants.au3>
; #include <GuiListView.au3>
;==================================================================================================
Func _ObjDictList(ByRef $oDICT, $TITLE='Elemente: Objekt Dictionary')
If Not IsObj($oDICT) Then
SetError(1)
Return -1
EndIf
Local $count = $oDICT.Count
Local $SaveMode = Opt("GUIOnEventMode",0), $ListGUI, $oDictLV, $btnClose, $msg
$ListGUI = GUICreate($TITLE, 600, 400, (@DesktopWidth - 600)/2, (@DesktopHeight - 400)/2)
$btnClose = GUICtrlCreateButton('&Ende', 40, 360, 70, 22)
GUICtrlSetResizing($btnClose, BitOR($GUI_DockRight, $GUI_DockBottom, $GUI_DockSize))
GUICtrlDelete($oDictLV)
$oDictLV = GUICtrlCreateListView('Schlüssel|Wert', 10, 10, 580, 340, BitOR($LVS_SHOWSELALWAYS, _
$LVS_EDITLABELS), BitOR($LVS_EX_GRIDLINES, $LVS_EX_HEADERDRAGDROP, $LVS_EX_FULLROWSELECT, $LVS_EX_REGIONAL))
If $count > 0 Then
Local $strKey, $colKeys = $oDICT.Keys
For $strKey In $colKeys
GUICtrlCreateListViewItem($strKey & '|' & $oDICT.Item($strKey), $oDictLV)
Next
Else
WinSetTitle($ListGUI, '', 'Das Objekt Dictionary enthält keine Elemente!')
EndIf
GUISetState(@SW_SHOW, $ListGUI)
While 1
$msg = GUIGetMsg(1)
If $msg[1] = $ListGUI And _
($msg[0] = $GUI_EVENT_CLOSE Or $msg[0] = $btnClose) Then ExitLoop
WEnd
GUIDelete($ListGUI)
Opt("GUIOnEventMode",$SaveMode)
EndFunc ;==>ObjDictList

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $PathINI - Pfad der INI-Datei
; $SECTION - Sektion die gelesen werden soll
; Return: Erfolg: Anzahl der eingelesenen Schlüssel-Wert Paare
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 6 INI-Pfad nicht vorhanden
; 7 kein Sektionsname
; 8 INI-Sektion konnte nicht gelesen werden oder leer
;==================================================================================================
Func _IniReadSectionToObjDict(ByRef $oDICT, $PathINI, $SECTION)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf Not FileExists($PathINI) Then
SetError(6)
Return -1
ElseIf $SECTION = '' Then
SetError(7)
Return -1
EndIf
Local $arSECTION = IniReadSection($PathINI, $SECTION)
If Not IsArray($arSECTION) Then
SetError(8)
Return -1
EndIf
For $i = 1 To $arSECTION[0][0]
$oDICT.Add($arSECTION[$i][0], $arSECTION[$i][1])
Next
Return $arSECTION[0][0]
EndFunc ;==>_IniReadSectionToObjDict

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $PathINI - Pfad der INI-Datei
; $SECTION - Sektion die gelesen werden soll
; Return: Erfolg: Anzahl der geschriebenen Schlüssel-Wert Paare
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 7 kein Sektionsname
; 9 INI-Sektion konnte nicht geschrieben werden
;==================================================================================================
Func _IniWriteSectionFromObjDict(ByRef $oDICT, $PathINI, $SECTION)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $SECTION = '' Then
SetError(7)
Return -1
EndIf
Local $arSECTION[$oDICT.Count][2], $i = 0
Local $strKey, $colKeys = $oDICT.Keys
For $strKey In $colKeys
$arSECTION[$i][0] = $strKey
$arSECTION[$i][1] = $oDICT.Item($strKey)
$i += 1
Next
If IniWriteSection($PathINI, $SECTION, $arSECTION, 0) = 1 Then
Return $oDICT.Count
Else
SetError(9)
Return -1
EndIf
EndFunc ;==>_IniWriteSectionFromObjDict

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $PathFile - Pfad der Datei
; $SEPERATOR - Trennzeichen zwischen Wert u. Schlüssel, Standard: '|'
; Return: Erfolg: Anzahl der eingelesenen Schlüssel-Wert Paare
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 6 Datei-Pfad nicht vorhanden
; 7 Leerstring als Seperator übergeben
; 8 Datei konnte nicht gelesen werden
;==================================================================================================
Func _FileReadToObjDict(ByRef $oDICT, $PathFile, $SEPERATOR='|')
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf Not FileExists($PathFile) Then
SetError(6)
Return -1
ElseIf $SEPERATOR = '' Then
SetError(7)
Return -1
EndIf
Local $fh = FileOpen($PathFile, 0), $line
Local $val
If $fh = -1 Then
SetError(8)
Return -1
EndIf
While 1
$line = FileReadLine($fh)
If @error = -1 Then ExitLoop
$val = StringSplit($line, $SEPERATOR)
If $val[0] > 1 Then
$oDICT.Add($val[1], $val[2])
EndIf
Wend
FileClose($fh)
Return $oDICT.Count
EndFunc ;==>_FileReadToObjDict

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Parameter: $oDICT - Handle des Dictionary-Objektes
; $PathFile - Pfad der Datei
; $SEPERATOR - Trennzeichen zwischen Wert u. Schlüssel, Standard: '|'
; $OVERWRITE - Falls Datei existiert, wird sie überschrieben (Standard).
; Mit 'FALSE' wird an bestehende Datei angehängt.
; Return: Erfolg: Anzahl der geschriebenen Schlüssel-Wert Paare
; Fehler: -1
; Fehlerwert: 1 Objekt existiert nicht
; 7 Leerstring als Seperator übergeben
; 8 Datei konnte nicht geschrieben werden
;==================================================================================================
Func _FileWriteFromObjDict(ByRef $oDICT, $PathFile, $SEPERATOR='|', $OVERWRITE=True)
If Not IsObj($oDICT) Then
SetError(1)
Return -1
ElseIf $SEPERATOR = '' Then
SetError(7)
Return -1
EndIf
If $OVERWRITE Then
Local $fh = FileOpen($PathFile, 34)
Else
Local $fh = FileOpen($PathFile, 33)
EndIf
Local $strKey, $colKeys = $oDICT.Keys
For $strKey In $colKeys
FileWriteLine($fh, $strKey & $SEPERATOR & $oDICT.Item($strKey))
If @error Then
SetError(8)
Return -1
EndIf
Next
FileClose($fh)
Return $oDICT.Count
EndFunc ;==>_FileWriteFromObjDict

[/autoit]

**BugFix**

Zitat

Original von Masterraven9
...
Jetzt steh ich gerade vor mehreren Problemen z.B.
mit welchem Befehl kann ich das regeln das ich das Program auch während es runterzählt mit einem Klick auf "x" beenden kann oder
wie kann ich ein neues GUI Fenster erstellen in dem ich auch Anweisungen ausführen kann.
thx

Das geht nicht.
Während die Zeitsetzung läuft bist du in der Schleife 'gefangen'.
Andere Ereignisse lassen sich erst abfragen, wenn die Schleife beendet ist.
Ein zeitgleiches Ausführen eines anderen Fensters geht ebenfalls nicht - AutoIt ist nicht multithreadfähig.

**BugFix**

Das WshShell-Objektmodell
Ich habe hier anhand einiger Beispiele die Möglichkeiten des WshShell-Objektmodells dargestellt.
Wie auch schon beim FSO gilt, dass für fast alle Aktionen adäquate Befehle bereits direkt in AutoIt vorhanden sind.
Aber auch hier kann es von Fall zu Fall interessanter sein auf die Objektversion zuzugreifen.

[autoit]

$objShell = ObjCreate("WScript.Shell")

[/autoit]

Code

Programme ausführen                     Run, Exec
Arbeiten mit Spezialordnern             SpecialFolders
Arbeiten mit Verknüpfungen              CreateShortcut
Arbeiten mit Umgebungsvariablen         Environment, ExpandEnvironmentStrings
Arbeiten mit dem Ereignisprotokoll      LogEvent
Arbeiten mit der Registrierung          RegRead, RegWrite, RegDelete
Tastendrücke an Anwendungen senden      AppActivate, SendKeys
Abfragen des aktuellen
Verzeichnisses des Scripts              CurrentDirectory
Zeitgesteuerte Dialogfenster erstellen  Popup

Programme ausführen

Spoiler anzeigen

Methoden: Run und Exec

Syntax für Run

[autoit]

Run('File' [, 'Fensterstil=Integer' [, 'Wait=False']])

[/autoit]

Werte für den Parameter Window-Stil der Methode Run

Code

0 Verstecktes Fenster
 1 Aktiviert das Fenster und zeigt es an. Wenn das Fenster
   minimiert oder maximiert ist, werden Originalgröße und
   -position des Fensters wiederhergestellt.
 2 Aktiviert das Fenster und zeigt es minimiert an.
 3 Aktiviert das Fenster und zeigt es maximiert an.
 4 Zeigt das Fenster mit seiner letzten Größe und Position an.
   Das aktive Fenster bleibt aktiv.
 5 Aktiviert das Fenster und zeigt es mit seiner aktuellen
   Größe und Position an.
 6 Minimiert das Fenster und aktiviert das nächste Fenster in Z-Reihenfolge.
   Bei der Z-Reihenfolge handelt es sich um eine Liste, in der die
   Fenster aktiviert werden. Sie können die Liste sehen, wenn Sie ALT+TAB drücken.
 7 Zeigt das Fenster minimiert an. Das aktive Fenster bleibt aktiv.
 8 Zeigt das Fenster in seinem Zustand an. Das aktive Fenster bleibt aktiv.
 9 Aktiviert das Fenster und zeigt es an. Wen das Fenster minimiert
   oder maximiert ist, dann werden seine Originalgröße und
   -position wiederhergestellt.
10 Setzt den Anzeigezustand des Fensters auf Basis des
   Anzeigezustands des Programms, das die Anwendung gestartet hat.

Alles anzeigen

Die Konstanten-Deklaration der Parameter ist nicht zwingend erforderlich.
Das Einsetzen des numerischen Wertes erfüllt denselben Zweck.
Das Setzen der Konstanten verbessert aber die Lesbarkeit des Codes.

[autoit]

Const $HIDDEN_WINDOW = 0
Const $RESIZEPOS_WINDOW = 1
Const $MINIMIZE_WINDOW = 2
Const $MAXIMIZE_WINDOW = 3
Const $LAST_SIZE_POS_WINDOW_ACTIVE_NO_CHG = 4
Const $CURRENT_SIZE_POS_WINDOW = 5
Const $MINIMIZE_WINDOW_ACTIVATE_NEXT_Z = 6
Const $MINIMIZE_WINDOW_ACTIVE_NO_CHG = 7
Const $SHOW_AS_IS_WINDOW_ACTIVE_NO_CHG = 8
Const $ACTIVATE_WINDOW_RESIZEPOS_AFTER_MIN_MAX = 9
Const $WINDOW_STATE_LIKE_APPL_STATE = 10

[/autoit]

Notepad maximiert starten

[autoit]

$objShell = ObjCreate("WScript.Shell")
$objShell.Run("notepad.exe", $MAXIMIZE_WINDOW)

[/autoit]

Anmerkung:
Der Parameter Windows-Stil wird nicht von allen Anwendungen verarbeitet.
Die Systemsteuerung (control.exe) wird zum Beispiel immer in der gleichen Form geöffnet -
egal welcher Fensterstil im Script definiert wurde.

Befehlsausführung abwarten
Run akzeptiert als dritten Parameter 'TRUE' oder 'FALSE', voreingestellt ist 'FALSE'.
Wird 'TRUE' gesetzt wird mit der Skriptabarbeitung gewartet, bis das gestartete Programm
beendet wurde.
Rechner aufrufen und erst nach Beendigen Skript fortsetzen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$objShell.Run("calc.exe", 1, True)
MsgBox(0, '', "Script completed.")

[/autoit]

Ausführen von Kommandozeilentools
möglich mit Run und Exec
%comspec% /k Kommandozeilenfenster bleibt offen
%comspec% /c Kommandozeilenfenster wird geschlossen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$objShell.Run("%comspec% /K dir", 1, True)

[/autoit]

Programm ausführen und auf dessen Ausgaben zugreifen
Methode Exec

Ping absetzen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$IP = '192.168.178.1'
$objExecObject = $objShell.Exec("cmd /c ping -n 3 -w 1000 " & $IP)
Do
$strText = $objExecObject.StdOut.ReadLine()
If StringInStr($strText, 'Antwort', 1) = 1 Then
MsgBox(0, '', "Antwort erhalten.")
ExitLoop
EndIf
Until $objExecObject.StdOut.AtEndOfStream

[/autoit]

Konfiguration Netzwerkadapter abfragen

[autoit]

$objExecObject = $objShell.Exec("%comspec% /c ipconfig.exe")
$str = ''
Do
$strLine = $objExecObject.StdOut.ReadLine()
If StringInStr($strLine, "Adresse", 1) Then
$str &= $strLine & @LF
ElseIf StringInStr($strLine, "maske", 1) Then
$str &= $strLine & @LF
ElseIf StringInStr($strLine, "gateway", 1) Then
$str &= $strLine & @LF
EndIf
Until $objExecObject.StdOut.AtEndOfStream
MsgBox(0, 'Konfiguration', $str)

[/autoit]

Verknüpfungen

Spoiler anzeigen

Objekt WshShortcut

Code

Arguments         Zusätzliche Kommandozeilenargumente, die Sie beim
                  Start der Anwendung verwenden können.
Description       Beschreibung der Verknüpfung.
FullName          Nur-Lese-Eigenschaft, die den vollständigen Pfad
                  zur Zielanwendung angibt.
HotKey            Tastenkombination: Eine Tastenkombination, über die
                  die Anwendung gestartet werden kann. Tastenkombinationen
                  setzen sich normalerweise aus einer der folgenden Tasten
                  plus einem Buchstaben (a-z), einer Zahl (0-9) oder einer
                  Funktionstaste (F1-F12) zusammensetzen:
                    ALT
                    STRG
                    HOCHSTELLTASTE
                  Wenn Sie die Eigenschaft angeben, müssen Sie für
                  die Taste STRG den Wert CTRL und für die Hochstelltaste
                  den Wert SHIFT angeben. Für die Tastenkombination STRG
                  und 9 verwenden Sie beispielsweise den folgenden Wert:
                    Ctrl + 9
                  Wenn die Tastenkombination bereits verwendet wird, dann
                  wird sie überschrieben und der neuen Verknüpfung zugewiesen.
IconLocation      Ermöglicht Ihnen die Angabe einen Symbols und eines
                  Symbolindexes für die Verknüpfung. Wenn nichts angegeben
                  wird, dann wird das Standardsymbol der Anwendung verwendet.
TargetPath        Vollständiger Pfad zur Zielanwendung. Sie müssen einen
                  vollständigen Pfad (inklusive des Laufwerkbuchstabens)
                  oder einen UNC-Pfad angeben.
                  Der angegeben Wert wird nicht überprüft.
WindowStyle       Fenstertyp der gestarteten Anwendung. Die möglichen
                  Werte entsprechen den Werten der Methode Run.
WorkingDirectory  Arbeitsverzeichnis der Anwendung.

Alles anzeigen

Verknüpfung zum Windows-Taschenrechner auf dem Desktop
Zusätzlich Tastenkombination STRG-HOCHSTELLTASTE+T

[autoit]

$objShell = ObjCreate("WScript.Shell")
$strDesktopFolder = $objShell.SpecialFolders("AllUsersDesktop")
$objShortCut = $objShell.CreateShortcut($strDesktopFolder & "\Calculator.lnk")
With $objShortCut
.TargetPath = "%SystemRoot%\System32\calc.exe"
.Description = "Taschenrechner starten."
.HotKey = "Ctrl+Shift+T"
.Save
EndWith

[/autoit]

Verknüpfung zur AutoIt-URL auf dem Desktop

[autoit]

$objShell = ObjCreate("WScript.Shell")
$strDesktopFld = $objShell.SpecialFolders("Desktop")
$objURLShortcut = $objShell.CreateShortcut($strDesktopFld & "\AutoIt.url")
With $objURLShortcut
.TargetPath = "http://www.autoit.de/jgs_portal.php?sid="
.Save
EndWith

[/autoit]

Element zur Schnellstartleiste hinzufügen

[autoit]

$objShell = Objc("WScript.Shell")
$colEnvironmentVariables = $objShell.Environment("Volatile")
$strQLFolder = $colEnvironmentVariables.Item("APPDATA") & _
"\Microsoft\Internet Explorer\Quick Launch"
$objURLShortcut = $objShell.CreateShortcut($strQLFolder & "\AutoIt.url")
With $objURLShortcut
.TargetPath = "http://www.autoit.de/jgs_portal.php?sid="
.Save
EndWith

[/autoit]

Löschen von Verknüpfungen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colEnvironmentVariables = $objShell.Environment("Volatile")
$objFSO = ObjCreate("Scripting.FileSystemObject")
$strQLFolder = $colEnvironmentVariables.Item("APPDATA") & _
"\Microsoft\Internet Explorer\Quick Launch\AutoIt.url"
$objFSO.DeleteFile($strQLFolder)

[/autoit]

Spezialordner (Collection SpecialFolders)

Spoiler anzeigen

Hiermit kann AUSSCHLIESSLICH der Pfad des Ordners abgefragt werden.

Code

AllUsersDesktop     Desktopinhalte, die allen Benutzern angezeigt werden.
AllUsersStartMenu   Startmenüeinträge, die allen Benutzern angezeigt werden.
AllUsersPrograms    Einträge im Menü Programme, die allen Benutzern angezeigt werden.
AllUsersStartup     Programme, die für alle Benutzer beim Systemstart ausgeführt werden.
Desktop             Desktopinhalte, die nur dem aktuellen Benutzer angezeigt werden.
Favorites           Einträge in den Favoriten des aktuellen Benutzers.
Fonts               Installierte Schriften
MyDocuments         Ordner Meine Dokumente des aktuellen Benutzers.
NetHood             Objekte, die im Ordner Netzwerkumgebung angezeigt werden.
PrintHood           Drucker
Recent              Objekte, die unter dem Menüpunkt Dokumente im Startmenü
                    angezeigt werden (für den aktuellen Benutzer).
SendTo              Optionen im Menü Senden an im Kontextmenü nach einem
                    Rechtsklick im Windows Explorer.
StartMenu           Startmenü des aktuellen Benutzers.
Startup             Programme, die für den aktuellen Benutzer beim Systemstart
					ausgeführt werden.
Templates           Anwendungsvorlagen des aktuellen Benutzers.

Alles anzeigen

Speicherort des Spezialordners 'Fonts'

[autoit]

$objShell = ObjCreate("WScript.Shell")
$strFontDirectoryPath = $objShell.SpecialFolders.Item("Fonts")
MsgBox(0, "Pfad zum Ordner Font", $strFontDirectoryPath)

[/autoit]

Verknüpfung mit SciTE im Spezialordner 'Senden an' erstellen
um z.B. htm-Dateien per Kontextmenü in SciTE zu öffnen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$Path = RegRead('HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\SciTE.exe', '')
$strSendToFolder = $objShell.SpecialFolders("SendTo")
$strPathToScite = $objShell.ExpandEnvironmentStrings($Path)
$objShortcut = $objShell.CreateShortcut($strSendToFolder & "\SciTE.lnk")
$objShortcut.TargetPath = $strPathToScite
$objShortcut.Save

[/autoit]

Umgebungsvariablen und deren Speicherorte

Spoiler anzeigen

Die Eigenschaft Environment des Objekts WshShell gibt die Collection WshEnvironment zurück,
über die das Script Umgebungsvariablen abfragen, einrichten und verändern kann.

Code

User      Spezifisch für den angemeldeten Benutzer.  HKCU\Environment
          Werden zwischen Ab- und Anmeldung des 
          Benutzers gespeichert.
System    Gelten für alle Benutzer des Computers     HKLM\System\CurrentControlSet\
          und werden zwischen An- und                Control\Session Manager\Environment
          Abmeldung gespeichert.
Volatile  Gelten nur für die aktuelle Sitzung.       HKCU\VolatileEnvironment
          Werden nicht gespeichert.
Process   Gelten nur für den aktuellen Prozess.      Werden nicht in der Registrierung gespeichert.

Abfragen von Umgebungsvariablen
Um eine Collection mit den Umgebungsvariablen eines bestimmten Typs zu erhalten,
verwenden Sie die Eigenschaft WshShell.Environment. Ihr übergeben Sie eine String,
der den gewünschten Variablentyp enthält: system, user, process oder volatile.
Danach kann das Script über die Collection WshEnvironment über den Namen der
Umgebungsvariablen auf diese zugreifen.

Code

Name                   System  User  Process  Process (nur Windows 98/Me)


NUMBER_OF_PROCESSORS     x             x
PROCESSOR_ARCHITECTURE   x             x	
PROCESSOR_IDENTIFIER     x             x
PROCESSOR_LEVEL          x             x
PROCESSOR_REVISION       x             x
OS                       x             x
COMSPEC                  x             x         x
HOMEDRIVE                              x
HOMEPATH                               x
PATH                     x       x     x         x
PATHEXT                  x             x
PROMPT                                 x         x
SYSTEMDRIVE                            x
SYSTEMROOT                             x
WINDIR                   x             x         x
TEMP                             x     x         x
TMP                              x     x         x

Alles anzeigen

Benutzerspezifische und die Computerspezifische Umgebungsvariable PATH auslesen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colSystemEnvVars = $objShell.Environment("System")
$colUserEnvVars = $objShell.Environment("User")
$str = _
"Computer-specific PATH Environment Variable:" & @LF & _
$colSystemEnvVars("PATH") & @LF & _
"User-specific PATH Environment Variable:" & @LF & _
$colUserEnvVars("PATH")
MsgBox(0, 'Path - Variablen', $str)

[/autoit]

Umgebungsvariablen erstellen
Eine Umgebungsvariable mit dem Namen 'MeineVariable' mit den Anfangswert 0

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colUserEnvVars = $objShell.Environment("User")
$colUsrEnvVars("MeineVariable") = 0

[/autoit]

Variablen vom Typ 'user' und 'system' werden bei der Abmeldung des Benutzers gespeichert.
Es wird eine Umgebungsvariable vom Typ user mit dem Namen APP_VARIABLE erstellt und
deren Wert auf Installiert gesetzt. Danach fragt das Script den Wert der neu erstellen
Variable ab, um sicherzustellen, dass diese auch erstellt wurde.

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colUsrEnvVars = $objShell.Environment("USER")
$colUsrEnvVars("APP_VARIABLE") = "Installiert"
MsgBox(0, 'Wert von APP_VARIABLE', $colUsrEnvVars("APP_VARIABLE"))

[/autoit]

Änderung einer Umgebungsvariable von Typ user

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colUsrEnvVars = $objShell.Environment("USER")
$strCurrentValue = $colUsrEnvVars("APP_VARIABLE")
$colUsrEnvVars("APP_VARIABLE") = "Aktualisiert"
MsgBox(0, 'Geänderter Wert von APP_VARIABLE', $colUsrEnvVars("APP_VARIABLE"))

[/autoit]

Auswerten von Umgebungsvariablen
Über Umgebungsvariablen können Sie Systeminformationen abrufen. Wenn Sie zum Beispiel auf
den temporären Ordner des Benutzers zugreifen möchten, dann brauchen Sie die Pfadangabe für
diesen Ordner (beispielsweise C:\Temp).
Um den Wert einer Umgebungsvariable abzufragen, verwenden Sie die
Methode: WshShell.ExpandEnvironmentStrings.
Diese Methode erwartet als Parameter den in Prozentzeichen (%) eingeschlossenen Namen
der Umgebungsvariable als String und gibt deren Wert zurück.

Den Wert einer Umgebungsvariable und dann die ausgewertete Umgebungsvariable auslesen.

[autoit]

$objShell = ObjCreate("WScript.Shell")
$colEnvVars = $objShell.Environment("User")
$str = _
"Temporärer Ordner:" & @LF & _
$colEnvVars("TEMP") & @LF & _
"Temporärer Ordner (ausgewertet) " & @LF & _
$objShell.ExpandEnvironmentStrings("%TEMP%")
MsgBox(0, 'TEMP', $str)

[/autoit]

Einträge im Ereignisprotokoll erzeugen

Spoiler anzeigen

Das WshShell-Objekt stellt hierzu die Methode LogEvent zur Verfügung.
Sie erzeugt einen Eintrag im Anwendungsprotokoll.
Bearbeitung und Auswertung des Protokolls sind hiermit nicht möglich.
LogEvent erwartet zwei Parameter.
Der erste Parameter ist ein Integerwert, der das Ereignis definiert,
der zweite Parameter gibt den Text für den Protokolleintrag an.
Optional als dritten Parameter: der Computername (wird unter Win95/98 ignoriert)

Code

Wert   Ereignistyp
 0     Erfolgreich
 1     Fehler
 2     Warnung
 4     Information
 8     Erfolgsüberwachung
16     Fehlerüberwachung

Test Ereignisprotokoll

[autoit]

$objShell = ObjCreate("WScript.Shell")
With $objShell
.LogEvent(0,"Test Erfolgreich")
.LogEvent(1,"Test Fehler")
.LogEvent(2,"Test Warnung ")
.LogEvent(4, "Test Information ")
.LogEvent(8, "Test Erfolgsüberwachung ")
.LogEvent(16, "Test Fehlerüberwachung ")
EndWith

[/autoit]

Schreiben und Lesen in der lokalen Registry

Spoiler anzeigen

Registrierungseinträge lesen
Methode RegRead

Die Betriebssystemversion auslesen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$sngVersion = $objShell.RegRead _
("HKLM\Software\Microsoft\Windows NT\CurrentVersion\CurrentVersion")
MsgBox(0, 'Betriebssystemversion', $sngVersion)

[/autoit]

Registry-Datentypen

Code

REG_SZ         String
REG_DWORD      Number
REG_BINARY     Binary Value
REG_EXPAND_SZ  Expandable String
REG_MULTI_SZ   Array of Strings

Wenn versucht wird mit RegRead nicht unterstützte Datentypen auszulesen,
führt dies zu einem Fehler.

Registrierungswert vom Datentyp Multistring (REG_MULTI_SZ) auslesen.
Die Informationen werden als String-Array zurückgegeben,
der in einer For-Each-Schleife ausgegeben wird.

[autoit]

$objShell = ObjCreate("WScript.Shell")
$arrValues = $objShell.RegRead _
("HKLM\SYSTEM\CurrentControlSet\Services\EventLog\Security\Sources")
$str = ''
For $strValue In $arrValues
$str &= $strValue & @LF
Next
MsgBox(0, 'Multistring', $str)

[/autoit]

Registrierungseinträge erstellen oder ändern
Methode: RegWrite
Anmerkung: Der Datentyp REG_MULTI_SZ wird von der Methode RegWrite nicht unterstützt.

Einen DWORD-Eintrag erstellen

[autoit]

$objShell = ObjCreate("WScript.Shell")
$objShell.RegWrite("HKCU\TestKey\Version", 56, "REG_DWORD")

[/autoit]

Registrierungseinträge löschen
Methode RegDelete
Löschen eines DWORD-Eintrags aus der Registrierung

[autoit]

$objShell = ObjCreate("WScript.Shell")
$objShell.RegDelete("HKCU\TestKey\Version")

[/autoit]

Tastatureingaben an ein Programm schicken

Spoiler anzeigen

Methode: SendKeys (Zeichen als Parameter)

Zeichenkombinationen für Sondertasten mit SendKeys

Code

Taste                 Wert für SendKeys
Rückschritt           {BACKSPACE}, {BS}, oder {BKSP}
Pause                 {BREAK}
Feststelltaste        {CAPSLOCK}
Entf. oder Entfernen  {DELETE} oder {DEL}
Pfeil runter          {DOWN}
Ende                  {END}
Eingabe               {ENTER} oder ~
ESC                   {ESC}
Hilfe                 {HELP}
Pos1                  {HOME}
Einf. oder Einfügen   {INSERT} oder {INS}
Pfeil Links           {LEFT}
NUM                   {NUMLOCK}
Bild runter           {PGDN}
Bild hoch             {PGUP}
Druck                 {PRTSC}
Pfeil links           {RIGHT}
Rollen                {SCROLLLOCK}
Tabulator             {TAB}
Pfeil hoch            {UP}
Hochstelltaste        +
Steuerung (Strg)      ^
Alt                   %

Alles anzeigen

Alle Funktionstasten werden über den Tastennamen in geschweiften Klammern
angegeben - zum Beispiel {F1} für die Taste F1 usw.

Editor öffnen, warten bis aktiv, dann Text senden

[autoit]

$objShell = ObjCreate("WScript.Shell")
With $objShell
.Run("Notepad.exe")
Do
$Success = $objShell.AppActivate("Editor")
Sleep(500)
Until $Success
.SendKeys("Dies ist ein Test.")
EndWith

[/autoit]

Mit AppActivate wird der übergebene String mit allen Fenstertiteln verglichen.
Wenn keine Übereinstimmung gefunden wird, setzt AppActivate den Focus auf das Fenster,
dessen Titel mit dem übergebenen String beginnt. Wenn auch hier keine Übereinstimmung
gefunden werden kann, wird der Focus auf das Fenster gesetzt, dessen Titel mit dem String endet.
So wird sichergestellt, dass AppActivate auch mit Anwendungen funktioniert, in denen Dokumente
geöffnet werden können (wenn Sie zum Beispiel Notepad starten und ein neue Dokument öffnen, dann
lautet der Fenstertitel von Notepad 'Unbenannt -Editor' und nicht 'Editor'.

Nachrichtenfenster anzeigen

Spoiler anzeigen

Methode: Popup
.Popup(Text [,Timeout [,Titel [,Schalter]]])

[autoit]

$objShell = ObjCreate("WScript.Shell")
With $objShell
.Popup("Festplattenprüfung durchgeführt")
.Popup("Speicherprüfung durchgeführt")
.Popup("CPU-Prüfung durchgeführt")
EndWith

[/autoit]

Symbole und Schalter in Nachrichtenfenstern
Sie haben die Möglichkeit, unterschiedliche Schalter und Symbole im Nachrichtenfenster anzeigen
zu lassen (zum Beispiel die Schalter Ja und Nein oder die Schalter Abbrechen, Wiederholen, Ignorieren).
Die Angezeigten Schalter und Symbole definieren Sie mit dem vierten Parameter der Methode Popup.
Er setzt sich auch einer Kombination von vordefinierten Konstanten zusammen - die beiden Werte werden einfach addiert.

Code

Symbol                     Wert
Stop                        16
Fragezeichen                32
Ausrufungszeichen           48
Information                 64


Schalter                   Wert
OK                           0
OK und Abbrechen             1
Abbrechen, 
Wiederholen und Ignorieren   2
Ja, Nein und Abbrechen       3
Ja und Nein                  4
Wiederholen und Abbrechen    5


Konstanten für den Standardschalter
Standardschalter           Wert
Linker Schalter              0
Mittlerer Schalter         256
Rechter Schalter           512


Rückgabewerte der Tasten
Wert                    Schalter
 1               OK
 2               Abbrechen (bei OK, Abbrechen)
 3               Abbrechen (bei Wiederholen, Abbrechen, Ignorieren)
 4               Wiederholen
 5               Ignorieren
 6               Ja
 7               Nein

Alles anzeigen

Kombinationen von Symbolen und Schaltern anzeigen

[autoit]

Const $TIMEOUT = 5
Const $POPUP_TITLE = "Symbole und Schalter "
$objShell = ObjCreate("WScript.Shell")
With $objShell
.Popup("Stop / Abbrechen(Focus), Wiederholen und Ignorieren ", _
$TIMEOUT,$POPUP_TITLE,16+2)
.Popup("Fragezeichen/ Ja, Nein und Abbrechen(Focus)", _
$TIMEOUT,$POPUP_TITLE,32+3+512)
.Popup("Ausrufungszeichen / Ja und Nein(Focus) ", _
$TIMEOUT,$POPUP_TITLE,48+4+256)
.Popup("Information / Wiederholen und Abbrechen(Focus) ", _
$TIMEOUT,$POPUP_TITLE,64+5+256)
EndWith

[/autoit]

**BugFix**

Hier ein interessantes Objekt. AutoIt bietet dazu kein direktes Pendant.
Und vielleicht interessant für all jene, die sich mit Arrays nicht so anfreunden können aber Schlüssel-Wert-Paare verwalten müssen.

Hier mal eine kleine Erläuterung zur Funktionsweise (Edit):

Spoiler anzeigen

Wozu kann man es verwenden?

Mit dem Objekt lassen sich Zugriffe auf Schlüssel-Wert Paare wesentlich einfacher verwalten als mit einem Array.
Wer z.B. bei Arrays seine liebe Not mit dem verwendeten Index hat (Basis 0 oder 1, UBound falsch angesprochen etc.) wird diese Form der Datenspeicherung schätzen .
Überall dort, wo Daten paarweise (also in der Form Schlüssel=Wert) gespeichert werden, läßt sich das Objekt verwenden.

Bsp.: In einer INI-Datei werden Startwerte für ein Programm gespeichert

Code

[start]
breite=600
hoehe=400
x_pos=40
y_pos=60

Der übliche Weg in AutoIt wäre:

[autoit]

$var = INIReadSection($PathINI, 'start')
$GUI = GUICreate('Titel', $var[1][1], $var[2][1], $var[3][1], $var[4][1])

[/autoit]

Das setzt voraus, dass die Einträge in exakt dieser Reihenfolge in der INI-Datei stehen.
Für diese Parameter ist es noch übersichtlich, da aus dem Funktionsaufruf ersichtlich ist, welcher Parameter erwartet wird.
Habe ich aber eine Vielzahl von Einträgen, ist $var[n][1] nicht sehr aussagekräftig. Der Code läßt sich schwerer lesen.

Nun als Vergleich derselbe Vorgang mit meinen Funktionen für das Dictionary-Object:

[autoit]

$oINI = _objDictCreate(1)
_IniReadSectionToObjDict($oINI, $PathINI, 'start')
$GUI = GUICreate('Titel', _ObjDictGetValue($oINI, 'breite'), _ObjDictGetValue($oINI, 'hoehe'), _
_ObjDictGetValue($oINI, 'x_pos'), _ObjDictGetValue($oINI, 'y_pos'))

[/autoit]

Es ist ersichtlich, dass zum Zugriff direkt der Schlüsselname verwendet wird. Dadurch steigt die Lesbarkeit des Codes.

Ein weiterer Vorteil ist die Suchfunktion.
Hierbei wird nicht wie in einem Array jedes Element per Index angesprochen und dann überprüft.
Es wird direkt die Existenz des Schlüsselnamens geprüft. Dadurch ist der Vorgang schneller als eine Array-Suche.

Objekt: Dictionary

Code

Ein Dictionary-Objekt funktioniert wie ein assoziativer Array. Das heißt, 
es speichert Wert und Schlüssel in Paaren.
Vorteile gegenüber einem Array:
    - Es muß nicht festgelegt werden, wie viele Objekte gespeichert werden sollen. 
      Bei einem Array muß das Array im Voraus erstellt werden (oder später vergrößert werden).
    - Es ist keine Indexnummer zum Zugriff auf ein Element notwendig. Stattdessen kann über einen 
      Schlüssel(begriff) auf das Element zugegriffen werden.
Das Dictionary-Objekt hat nur eine konfigurierbare Eigenschaft: 
CompareMode
    Diese Eigenschaft beeinflusst, wie die Einträge im Dictionary-Objekt gefunden werden. 
    Standardmäßig arbeitet das Dictionary-Objekt im Binärmodus. 
      Das bedeutet, dass die einzelnen Schlüssel als ASCII-Werte gespeichert werden. 
      Bei ASCII-Werten wird zwischen Großbuchstaben und Kleinbuchstaben unterschieden.
      Bei der Abfrage ist es also notwendig, die exakte Schreibweise des Schlüssels zu verwenden.
    Im Textmodus, werden Groß- und Kleinbuchstaben gleich behandelt. In diesem Modus kann kein 
      Schlüssel mit dem Namen 'KEY' angelegt werden, wenn bereits ein Schlüssel mit dem Namen 'Key'
      vorhanden ist. Auch das Suchen ist viel einfacher.
      Die Suche nach 'key' würde die Einträge für 'KEY' und 'Key' zurückgeben.

Alles anzeigen

Spoiler anzeigen

Ein Dictionary-Objekt erstellen

[autoit]

Const $BinaerMode = 0
Const $TextMode = 1
$oDictionary = ObjCreate('Scripting.Dictionary') ; jetzt standardmäßig im Binärmode
$oDictionary.CompareMode = $TextMode ; den Textmode setzen

[/autoit]

Einträge zu einem Dictionary-Objekt hinzufügen
Methode: Add
Parameter: Schlüssel, Wert

[autoit]

$oDictionary = ObjCreate('Scripting.Dictionary')
$oDictionary.Add("Drucker 1", "Druckt")
$oDictionary.Add("Drucker 2", "Offline")
$oDictionary.Add("Drucker 3", "Druckt")

[/autoit]

Die Schlüsselnamen müssen eindeutig sein und dürfen nicht mehrfach auftreten.

Zugriff auf nicht existenten Schlüssel
Wird versucht, den Wert eines Schlüssels auszugeben, der nicht existiert, so wird dieser mit dem Wert Null angelegt.
Hierbei wird jedoch kein Fehler erzeugt!

Zahl der Einträge in einem Dictionary-Objekt abfragen

[autoit]

$oDictionary = ObjCreate('Scripting.Dictionary')
$oDictionary.Add("Drucker 1", "Druckt")
$oDictionary.Add("Drucker 2", "Offline")
$oDictionary.Add("Drucker 3", "Druckt")
MsgBox(0, 'Anzahl Schlüssel-Wert Paare', $oDictionary.Count)

[/autoit]

Elemente eines Dictionary-Objekts aufzählen
Methoden: Keys und Items

[autoit]

$oDictionary = ObjCreate('Scripting.Dictionary')
$oDictionary.Add("Drucker 1", "Druckt")
$oDictionary.Add("Drucker 2", "Offline")
$oDictionary.Add("Drucker 3", "Druckt")

[/autoit] [autoit][/autoit] [autoit]

$colKeys = $oDictionary.Keys
$str = ''
For $strKey in $colKeys
$str &= $strKey & @LF
Next
MsgBox(0, 'Schlüssel', $str)

[/autoit] [autoit][/autoit] [autoit]

$colItems = $oDictionary.Items
$str = ''
For $strItem in $colItems
$str &= $strItem & @LF
Next
MsgBox(0, 'Werte', $str)

[/autoit]

Wert eines bestimmten Eintrags anzeigen
Methode: Item
Die folgende Zeile zeigt zum Beispiel den Wert des Eintrags mit dem Schlüssel 'Drucker 3' an:

[autoit]

MsgBox(0, 'Wert von Schlüssel: Drucker 3', $oDictionary.Item("Drucker 3"))

[/autoit]

Existenz eines Schlüssels prüfen
Methode: Exists
Großer Vorteil gegenüber Array: Es müssen nicht alle Daten durchsucht werden.
Mit Exists wird die Existenz des Schlüssels abgefragt und 'True' oder 'False' zurückgegeben.

[autoit]

$oDictionary = ObjCreate('Scripting.Dictionary')
$oDictionary.Add("Drucker 1", "Druckt")
$oDictionary.Add("Drucker 2", "Offline")
$oDictionary.Add("Drucker 3", "Druckt")
If $oDictionary.Exists("Drucker 4") Then
MsgBox(0, '', "Drucker 4 ist vorhanden.")
Else
MsgBox(0, '', "Drucker 4 ist nicht vorhanden.")
EndIf

[/autoit]

Element in einem Dictionary-Objekt ändern

[autoit]

$oDictionary = ObjCreate('Scripting.Dictionary')
$oDictionary.Add("atl-dc-01", "Kein Status")
$oDictionary.Add("atl-dc-02", "Kein Status")
$oDictionary.Add("atl-dc-03", "Kein Status")

[/autoit] [autoit][/autoit] [autoit]

$colKeys = $oDictionary.Keys
$str = ''
For $strKey in $colKeys
$str &= $strKey & ' ' & $oDictionary.Item($strKey) & @LF
Next
MsgBox(0, 'Vor Änderung', $str)

[/autoit] [autoit][/autoit] [autoit]

$oDictionary.Item("atl-dc-01") = "Verfügbar"
$oDictionary.Item("atl-dc-02") = "Verfügbar"
$oDictionary.Item("atl-dc-03") = "Nicht verfügbar"

[/autoit] [autoit][/autoit] [autoit]

$str = ''
For $strKey in $colKeys
$str &= $strKey & ' ' & $oDictionary.Item($strKey) & @LF
Next
MsgBox(0, 'Nach Änderung', $str)

[/autoit]

Elemente aus einem Dictionary-Objekt entfernen
Methoden: Remove, RemoveAll

alle Schlüssel löschen

[autoit]

$oDictionary.RemoveAll

[/autoit]

einen bestimmten Schlüssel löschen

[autoit]

$oDictionary.Remove("Key")

[/autoit]

Edit:
Eine Funktionssammlung zu diesem Objekt habe ich hier erstellt:
UDF-Sammlung: Objekt Dictionary

**BugFix**

Hi,
hier habe ich mal alle Möglichkeiten des 'Scripting.FileSystemObject' in AutoIt umgesetzt.
Die meisten dieser Methoden stehen ja als Funktionen direkt in AutoIt zur Verfügung.
Insofern wäre es vielleicht interessant, mal einen repräsentativen Vergleichstest durchzuführen.

FileSystemObject

Code

enthält als eigene Objekte:
  Drive       Stellt den Zugriff auf ein Laufwerk oder eine Collection von Laufwerken zur Verfügung.
  File        Stellt den Zugriff auf eine Datei oder eine Collection von Dateien zur Verfügung.
  Folder      Stellt den Zugriff auf einen Ordner Laufwerk oder eine Collection von Ordnern zur Verfügung.
  TextStream  Stellt eine Quelle zur Verfügung, aus der Text gelesen werden kann, in die Text geschrieben 
              werden kann, oder an die Text angehängt werden kann.
Quelle: MS
http://www.microsoft.com/germany/technet/datenbank/articles/600360.mspx#EVD

Object Drive

Spoiler anzeigen

verfügbare Eigenschaften

Code

AvailableSpace  Der freie Speicherplatz auf dem Laufwerk in Byte. Um den freien Speicherplatz in KB
                zu erhalten, teilen Sie diesen Wert durch 1.024 (es handelt sich um den Speicherplatz,
                der dem aktuellen Benutzer zur Verfügung steht - wenn Kontingente verwendet werden, 
                kann der Wert kleiner sein als der gesamte zur Verfügung stehende freie Speicherplatz).
DriveLetter     Der dem Laufwerk zugewiesene Laufwerksbuchstabe ohne den angehängten Doppelpunkt. 
                Für das Diskettenlaufwerk wird also zum Beispiel der Buchstabe A verwendet.
DriveType       Ein Integer-Wert, der den Laufwerkstyp angibt:
                1 - Wechsellaufwerk
                2 - Festplatte
                3 - Netzlaufwerk
                4 - CD-ROM
                5 - RAM-Laufwerk
FreeSpace       Im Gegensatz zu AvailableSpace gibt diese Eigenschaft den gesamten zur Verfügung 
                stehenden freien Festplattenplatz in Byte zurück.
FileSystem      Der Typ des verwendeten Dateisystems (FAT, FAT 32, NTFS).
IsReady         Gibt an, ob auf das Laufwerk zugegriffen werden kann. Wenn sich zum Beispiel keine CD 
                im CD-Laufwerk oder keine Diskette im Diskettenlaufwerk befindet, hat diese Eigenschaft 
                den Wert False.
Path            Pfad zum Laufwerk. Bei lokalen Laufwerken finden Sie unter dieser Eigenschaft den 
                Laufwerksbuchstaben (zum Beispiel A). Bei Netzlaufwerken gibt die Eigenschaft den 
                UNC-Pfad des Laufwerkes zurück (zum Beispiel \\Server1\SharedFolder).
RootFolder      Der Pfad zum Stammordner des Laufwerks.
SerialNumber    Die Seriennummer des Laufwerks. Bei Diskettenlaufwerken oder Netzlaufwerken hat diese 
                Eigenschaft normalerweise den Wert 0.
ShareName       Freigabename eines Netzwerklaufwerks.
TotalSize       Gibt die Gesamtgröße des Laufwerks in Byte zurück (um die Gesamtgröße in KB zu erhalten, 
                teilen Sie den Wert durch 1.024. Für die Gesamtgröße in MB teilen Sie den Wert durch 
                1.048.576 (1.024 x 1.024).
VolumeName      Der Volumenname des Laufwerks.

Alles anzeigen

Auflistung aller Laufwerke

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $colDrives = $oFSO.Drives
$str = ''
For $objDrive in $colDrives
$str &= $objDrive.DriveLetter & @LF
Next
MsgBox(0, 'Laufwerksbuchstaben', $str)

[/autoit]

Referenz auf ein einzelnes Laufwerk

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $objDrive = $oFSO.GetDrive("C:")
MsgBox(0, 'Verfügbarer Speicherplatz', $objDrive.AvailableSpace)

[/autoit]

alle Laufwerkseigenschaften

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $colDrives = $oFSO.Drives
For $oDrive in $colDrives
$str = ''
If $oDrive.IsReady Then ; viele Eigenschaften sind nur verfügbar, wenn Lw bereit ==> Medium vorhanden
$str &= _
"Verfügbarer Speicherplatz: " & $oDrive.AvailableSpace & @LF & _
"Laufwerksbuchstabe: " & $oDrive.DriveLetter & @LF & _
"Laufwerkstyp: " & $oDrive.DriveType & @LF & _
"Dateisystem: " & $oDrive.FileSystem & @LF & _
"Bereit: " & $oDrive.IsReady & @LF & _
"Pfad: " & $oDrive.Path & @LF & _
"Stammordner: " & $oDrive.RootFolder & @LF & _
"Seriennummer: " & $oDrive.SerialNumber & @LF & _
"Freigabename: " & $oDrive.ShareName & @LF & _
"Gesamtgröße: " & $oDrive.TotalSize & @LF & _
"Volumenname: " & $oDrive.VolumeName
MsgBox(0, 'Laufwerkseigenschaften', $str)
Else
$str &= _
"Laufwerksbuchstabe: " & $oDrive.DriveLetter & @LF & _
"Laufwerkstyp: " & $oDrive.DriveType & @LF & _
"Bereit: " & $oDrive.IsReady & @LF & _
"Freigabename: " & $oDrive.ShareName
MsgBox(0, 'Laufwerkseigenschaften', $str)
EndIf
Next

[/autoit]

Object Folder

Spoiler anzeigen

verfügbare Eigenschaften

Code

Attributes         Ein Bitfeld mit den Attributen des Ordners. Weitere Informationen finden Sie im 
                   Abschnitt Verwalten von Ordnerattributen in diesem Kapitel.
DateCreated        Erstellungsdatum des Ordners.
DateLastAccessed   Letztes Zugriffsdatum.
DateLastModified   Letztes Bearbeitungsdatum.
Drive              Laufwerksbuchstabe mit Doppelpunkt (zum Beispiel C:) des Laufwerks, in dem der Ordner 
                   gespeichert ist.
Files              Eine Collection mit Objekten vom Typ File zum Zugriff auf die im Ordner gespeicherten 
                   Dateien.
IsRootFolder       Ein Boolean-Wert, der anzeigt, ob es sich um einen Stammordner (wie zum Beispiel C:\) 
				   handelt.
Name               Name des Ordners ohne Pfadangaben (zum Beispiel System32).
ParentFolder       Name des Ordners, in dem der Ordner gespeichert ist. Für den Ordner C:\Scripts wäre 
				   dies zum Beispiel C:\.
Path               Vollständiger Pfad des Ordners (zum Beispiel C:\Windows\System32).
ShortName          Ordnername in der MS-DOS-Syntax mit der 8.3-Namenskonvention. Der Ordner 
                   C:\Windows\Programme wird zum Beispiel als Progra~1 angezeigt
ShortPath          Pfadname des Ordners in der MS-DOS-Syntax. Der Ordner C:\Windows\Programme wird zum 
                   Beispiel als C:\Windows\Progra~1 angezeigt.
Size               Gesamtgröße in Byte aller Inhalte des Ordners. Dies schließt die in dem Ordner 
                   gespeicherten Dateien und alle Dateien in Unterordnern ein.
SubFolders         Eine Collection mit den Unterordnern des Ordners. Die Unterordner in den Unterordnern 
                   sind nicht in dieser Collection enthalten.
Type               Ein String mit einer Beschreibung des Ordnertyps - meist File Folder.

Alles anzeigen

Referenz auf einen Ordner
- erforderlich Pfadangabe als lokaler Pfad (z.B. D:\Daten) oder als UNC-Pfad (z.B. \\accounting\receivables)
- Wildcards sind nicht zulässig

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFolder = $oFSO.GetFolder($Path)
; Bsp.:
$oFolder = $oFSO.GetFolder("C:\Daten") ; erzeugt eine Referenz auf "C:\Daten"
$oFolder = $oFSO.GetFolder(".") ; erzeugt eine Referenz auf den AKTUELLEN Ordner
$oFolder = $oFSO.GetFolder("..") ; erzeugt eine Referenz auf den ÜBERGEORDNETEN Ordner

[/autoit]

Fehlervermeidung (Ordner nicht vorhanden/vorhanden), Objekt nur erstellen, wenn Ordner existiert oder
Ordner erstellen und dann referenzieren

[autoit]

If $oFSO.FolderExists($Path) Then
$oFolder = $oFSO.GetFolder($Path)
Else
MsgBox(0, 'ACHTUNG!', 'Ordner: "' & $Path & '", existiert nicht. Referenz wurde nicht erstellt.') ; Oder:
;~ $oFSO.CreateFolder($Path) ; Ordner erstellen
;~ $oFolder = $oFSO.GetFolder($Path) ; referenzieren
EndIf

[/autoit]

FileSystemObject kann nur Ordner auf dem lokalen Computer erstellen.
Um Ordner auf einem Remotecomputer zu erstellen kann das Objekt WshController verwendet werden
(oder lokal erstellen und mit WMI verschieben)

Ordner löschen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.DeleteFolder($Path)

[/autoit]

Die Methode DeleteFolder löscht den Ordner und alle Inhalte sofort.
Es wird keine Bestätigung angefordert, und die Elemente werden auch nicht im Papierkorb abgelegt!

Ordner über Wildcards löschen
z.B. besteht folgende Struktur:

Code

MyData
	Data_1
	Data_2
	Unterordner_pic
	Unterordner_audio

gelöscht werden sollen alle Unterordner, die mit 'U' beginnen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.DeleteFolder("C:\MyData\U*")

[/autoit]

Wichtig! Wildcards können nur im letzten Teil des Pfades verwendet werden.

Ordner und Inhalte kopieren
Methode: CopyFolder
Werden keine Wildcards verwendet, funktioniert die Methode wie der Befehl Xcopy /E: sie kopiert alle Dateien und alle Unterordner, inklusive aller leeren Unterordner.
Die Methode benötigt zwei Parameter: Quellordner und Zielordner
Optionaler dritter Parameter: Überschreiben (Standardwert 'TRUE')
Wird Überschreiben auf 'FALSE' gesetzt und im Zielordner ist bereits ein gleichnamiger Ordner vorhanden, bricht der Vorgang mit einem Laufzeitfehler ab.

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.CopyFolder($Path_Quelle, $Path_Ziel [, $OverWriteFiles=True])

[/autoit]

Ordner mit Hilfe von Wildcards kopieren
Bsp.: alle Ordner (+ Unterordner mit Dateien), die mit 'Log' beginnen in den Ordner Archiv kopieren

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.CopyFolder("C:\Scripts\Log*" , "C:\Archive", True)

[/autoit]

Verschieben von Ordnern und Inhalten
Methode: MoveFolder
Die Methode benötigt zwei Parameter: Quellordner und Zielordner ; Angabe als Lokaler oder UNC-Pfad
Überschreiben bestehender Ordner ist nicht möglich
Bsp.: verschiebt den lokalen Ordner C:\Scripts in die Freigabe \\helpdesk\management.

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.MoveFolder($Path_Quelle, $Path_Ziel)
$oFSO.MoveFolder("C:\Scripts", "\\helpdesk\management")

[/autoit]

Ordner umbenennen
Hierfür gibt es keine eigene Methode. Es wird MoveFolder genutzt
Bsp.: Ordner C:\FSO\Samples in C:\FSO\Scripts umbenennen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.MoveFolder("C:\FSO\Samples", "C:\FSO\Scripts")

[/autoit]

Ordner Eigenschaften abfragen
Beachten: Die Eigenschaften 'Files' und 'Subfolders' geben eine Collection zurück.
'Subfolders' arbeitet nicht rekursiv

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'ORDNERPFAD'
$oFolder = $oFSO.GetFolder($Path)
$str = _
"DateCreated: " & $oFolder.DateCreated & @LF & _
"DateLastAccessed: " & $oFolder.DateLastAccessed & @LF & _
"DateLastModified: " & $oFolder.DateLastModified & @LF & _
"Drive: " & $oFolder.Drive & @LF & _
"IsRootFolder: " & $oFolder.IsRootFolder & @LF & _
"Name: " & $oFolder.Name & @LF & _
"ParentFolder: " & $oFolder.ParentFolder & @LF & _
"Path: " & $oFolder.Path & @LF & _
"ShortName: " & $oFolder.ShortName & @LF & _
"ShortPath: " & $oFolder.ShortPath & @LF & _
"Size: " & $oFolder.Size & @LF & _
"Type: " & $oFolder.Type
MsgBox(0, 'Eigenschaften Ordner', $str)
$str = ''
For $File In $oFolder.Files
$str &= $File.Name & @LF
Next
MsgBox(0, 'Dateien im Ordner', $str)
$str = ''
For $SubFolder In $oFolder.Subfolders
$str &= $SubFolder.Name & @LF
Next
MsgBox(0, 'Unterordner im Ordner', $str)

[/autoit]

Ordnerattribute

Code

Hidden         2  Versteckt - Zeigt an, dass der Ordner versteckt ist.
System         4  System - Zeigt an, dass es sich um einen Systemordner handelt.
Directory     16  Ordner - Der Standardwert für alle Ordner.
Archive       32  Archiv - Das Archiv-Attribut wird zum Beispiel von Sicherungsprogrammen 
                  verwendet. Diese stellt über das Attribut fest, welche Dateien und Ordner 
                  gesichert werden müssen.
Compressed  2048  Komprimiert - Zeigt an, ob der Ordner komprimiert ist.

Anzeigen von Ordnerattributen
Ordnerattribute (und auch Dateiattribute) sind Bitfelder.
Das Abfragen erfolgt mit BitAnd(), d.h. wenn der übergebene Wert im Ausdruck enthalten ist, ist die Abfrage wahr.
Das Setzen erfolgt mit BitXOR(), d.h. hier wird 'geswitcht'.
Ist der übergebene Wert enthalten, wird er aus dem Ausdruck entfernt (binär subtrahiert).
Ist der übergebene Wert nicht enthalten, wird er in den Ausdruck eingefügt (binär addiert).

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'ORDNERPFAD'
$oFolder = $oFSO.GetFolder($Path)
If BitAND($oFolder.Attributes, 2) Then
MsgBox(0, 'Attribut', "Versteckt")
EndIf
If BitAND($oFolder.Attributes, 4) Then
MsgBox(0, 'Attribut', "System")
EndIf
If BitAND($oFolder.Attributes, 16) Then
MsgBox(0, 'Attribut', "Ordner")
EndIf
If BitAND($oFolder.Attributes, 32) Then
MsgBox(0, 'Attribut', "Archiv")
EndIf
If BitAND($oFolder.Attributes, 2048) Then
MsgBox(0, 'Attribut', "Komprimiert")
EndIf

[/autoit]

Ändern von Ordnerattributen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'ORDNERPFAD'
$oFolder = $oFSO.GetFolder($Path)
If Not BitAND($oFolder.Attributes, 2) Then ; wenn nicht 'versteckt'
$oFolder.Attributes = BitXOR($oFolder.Attributes, 2) ; 'Versteckt' setzen
EndIf

[/autoit]

Rekursive Auflistung von Unterordnern

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'ORDNERPFAD'
Dim $str = ''
_ShowSubFolders($oFSO.GetFolder($Path))

[/autoit] [autoit][/autoit] [autoit]

Func _ShowSubFolders($Folder)
For $Subfolder in $Folder.SubFolders
$str &= $Subfolder.Path & @LF
_ShowSubFolders($Subfolder)
Next
EndFunc
MsgBox(0, 'Rekursive Auflistung Unterordner', $str)

[/autoit]

Object File

Spoiler anzeigen

verfügbare Eigenschaften

Code

Attributes         Ein Bitfeld mit den Attributen der Datei.
DateCreated        Das Erstellungsdatum der Datei.
DateLastAccessed   Das Datum des letzten Dateizugriffs.
DateLastModified   Das Datum der letzten Änderung an der Datei.
Drive              Laufwerksbuchstabe mit Doppelpunkt des Laufwerks, auf dem die Datei gespeichert ist.
Name               Dateiname ohne Pfadinformationen. Für die Datei C:\Windows\System32\Scrrun.dll 
                   wäre das zum Beispiel Scrrun.dll.
ParentFolder       Name des Ordners, in dem die Datei gespeichert ist. Für C:\Windows\System32\Scrrun.dll 
                   wäre das zum Beispiel System32.
Path               Der vollständige Pfad der Datei (zum Beispiel C:\Windows\System32\Scrrun.dll).
ShortName          Der MS-DOS-Name der Datei (in 8.3-Schreibweise). Für die Datei C:\MySpreadsheet.xls 
                   ist das zum Beispiel MySpre~1.xls.
ShortPath          Der Pfad in MS-DOS-Schreibweise (in 8.3-Schreibweise). Für die Datei 
                   C:\Windows\Program Files\MyScript.vbs wäre das zum Beispiel C:\Windows\Progra~1\MyScript.vbs.
Size               Gesamtgröße der Datei in Byte.
Type               Ein String mit der Dateiart (zum Beispiel Microsoft Word Document).

Alles anzeigen

Methode: GetFile
Parameter: Dateiname (entweder ein lokaler Pfad oder ein UNC-Pfad)
Referenz auf eine Datei erstellen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
; z.B.
$oFile = $oFSO.GetFile('D:\Data\Test.txt') ; kpl. Pfadname
$oFile = $oFSO.GetFile('Test.txt') ; Datei ist im Skript-Ordner
$oFile = $oFSO.GetFile('.\Test.txt') ; Datei ist im übergeordneter Ordner

[/autoit]

Zugriffsfehler vermeiden, vor Zugriff auf Existenz abfragen

[autoit]

If $oFSO.FileExists($Path) Then
$oFile = $oFSO.GetFile($Path)
Else
MsgBox(0, 'FEHLER', "Datei ist nicht vorhanden.")
EndIf

[/autoit]

Das Prüfen mit Wildcards (z.B. *.txt) auf eine Gruppe von Dateien ist nicht möglich.

Löschen einer Datei

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFSO.DeleteFile($Path [, $Force=False])

[/autoit]

Löscht standardmäßig keine schreibgeschützten Dateien, Abbruch mit Laufzeitfehler
Um schreibgeschützte Dateien zu löschen den Parameter $Force auf 'TRUE' setzen.

Löschen von Dateien mit Wildcard

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD\*log.*' ; alle Dateien im Pfad mit 'log' irgendwo im Dateinamen
$oFSO.DeleteFile($Path)

[/autoit]

Kopieren von Dateien

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.CopyFile($Path_Quelle, $Path_Ziel [, $OverWriteExisting=False])

[/autoit]

Standardmäßig werden beim Kopieren keine existierenden Dateien überschrieben.
Dies kann erzwungen werden, indem der Parameter $OverWriteExisting auf 'TRUE' gesetzt wird.

Kopieren von mehreren Dateien mit Wildcard

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.CopyFile('D:\Data\*.doc', $Path_Ziel [, $OverWriteExisting=False])
; Alle 'doc'-Dateien des Ordners 'D:\Data' werden in den Zielordner kopiert.
$oFSO.CopyFile('D:\Data\*.*', $Path_Ziel [, $OverWriteExisting=False])
; Alle 'Dateien des Ordners 'D:\Data' werden in den Zielordner kopiert.

[/autoit]

Verschieben einer Datei

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$oFSO.MoveFile('D:\Data\Test.doc', $Path_Ziel) ; $Path_Ziel muß MIT abschließendem Backslash deklariert werden!

[/autoit]

Mehrere Dateien verschieben

[autoit]

$oFSO.MoveFile('D:\Data\*.doc', $Path_Ziel)
; Alle 'doc'-Dateien des Ordners 'D:\Data' werden in den Zielordner verschoben.

[/autoit]

Eine Datei umbenennen
Hierfür gibt es keine eigene Methode. Es wird MoveFile genutzt
Bsp.: Umbenennen 'Test.doc' in 'Test.bak'

[autoit]

$oFSO.MoveFile('D:\Data\Test.doc', 'D:\Data\Test.bak')

[/autoit]

Alle Dateieigenschaften auflisten

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
$str = _
"DateCreated: " & $oFile.DateCreated & @LF & _
"DateLastAccessed: " & $oFile.DateLastAccessed & @LF & _
"DateLastModified: " & $oFile.DateLastModified & @LF & _
"Drive: " & $oFile.Drive & @LF & _
"Name: " & $oFile.Name & @LF & _
"ParentFolder: " & $oFile.ParentFolder & @LF & _
"Path: " & $oFile.Path & @LF & _
"ShortName: " & $oFile.ShortName & @LF & _
"ShortPath: " & $oFile.ShortPath & @LF & _
"Size: " & $oFile.Size & @LF & _
"Type: " & $oFile.Type
MsgBox(0, 'Datei Eigenschaften', $str)

[/autoit]

Dateiattribute

Code

Normal         0  Datei ohne Attribute.
Read-only      1  Datei kann nur gelesen werden.
Hidden         2  Versteckte Datei.
System         4  Datei ist Teil des Betriebssystems.
Archive       32  Datei ist zur Sicherung markiert.
Alias         64  Datei ist eine Verknüpfung, die auf eine andere Datei verweist.
Compressed  2048  Datei ist komprimiert.

Anzeigen von Dateiattributen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
If BitAND($oFile.Attributes, 0) Then
MsgBox(0, 'Attribut', "Keine Attribute vorhanden")
EndIf
If BitAND($oFile.Attributes, 1) Then
MsgBox(0, 'Attribut', "Read-only")
EndIf
If BitAND($oFile.Attributes, 2) Then
MsgBox(0, 'Attribut', "Versteckt")
EndIf
If BitAND($oFile.Attributes, 4) Then
MsgBox(0, 'Attribut', "System")
EndIf
If BitAND($oFile.Attributes, 32) Then
MsgBox(0, 'Attribut', "Archiv")
EndIf
If BitAND($oFile.Attributes, 64) Then
MsgBox(0, 'Attribut', "Alias")
EndIf
If BitAND($oFile.Attributes, 2048) Then
MsgBox(0, 'Attribut', "Komprimiert")
EndIf

[/autoit]

Dateiattribute ändern
Folgende Attribute können geändert werden:
ReadOnly, Hidden, System, Archive

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
If Not BitAND($oFile.Attributes, 1) Then ; wenn nicht 'Read-only'
$oFile.Attributes = BitXOR($oFile.Attributes, 1) ; 'Read-only' setzen
EndIf

[/autoit]

Alle Attribute gleichzeitig ausschalten

[autoit]

$oFile.Attributes = BitAND($oFile.Attributes, 0)

[/autoit]

Pfadinformationen

Code

GetAbsolutePathName   Gibt den vollständigen Pfad einer Datei zurück (zum Beispiel C:\FSO\Scripts\Scriptlog.txt).
GetParentFolderName   Gibt den Pfad des Ordners zurück, in dem die Datei gespeichert ist (zum Beispiel C:\FSO\Scripts).
GetFileName           Gibt den Dateinamen ohne Pfadinformationen zurück (zum Beispiel ScriptLog.txt).
GetBaseName           Gibt den Basisnamen der Datei zurück (der Dateiname ohne Erweiterung - zum Beispiel ScriptLog).
GetExtensionName      Gibt die Erweiterung der Datei zurück (zum Beispiel txt).

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
$str = _
"Absoluter Pfad: " & $oFSO.GetAbsolutePathName($oFile) & @LF & _
"Überg. Ordner: " & $oFSO.GetParentFolderName($oFile) & @LF & _
"Dateiname: " & $oFSO.GetFileName($oFile) & @LF & _
"Basisname: " & $oFSO.GetBaseName($oFile) & @LF & _
"Erweiterung: " & $oFSO.GetExtensionName($oFile)
MsgBox(0, 'Pfadinformationen', $str)

[/autoit]

Abfragen der Dateiversion

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
MsgBox(0, 'Dateiversion', $oFSO.GetFileVersion($Path))

[/autoit]

Textdateien erstellen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
Dim $Path = 'DATEIPFAD'
$oFile = $oFSO.CreateTextFile($Path [,$Overwrite=True])
; Mit $Overwrite=True (Standard) wird eine evtl. bereits bestehende Datei überschrieben.

[/autoit]

Generieren von Dateinamen
Es können automatisch Dateinamen generiert werden. Diese beginnen alle mit 'rad', gefolgt von 5 beliebigen Buchstaben/Ziffern
und der Dateiendung 'tmp'. Maximal sind somit 9.894 eindeutige Dateinamen möglich

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$str = ''
For $i = 1 to 10
$strTempFile = $oFSO.GetTempName
$str &= $strTempFile & @LF
Next
MsgBox(0, 'automatisch generierte Dateinamen', $str)

[/autoit]

Object TextStream

Spoiler anzeigen

Erstellen und Bennennen einer Textdatei

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$strPath = 'DATEIPFAD'
$strFileName = $oFSO.GetTempName
$strFullName = $oFSO.BuildPath($strPath, $strFileName)
$oFile = $oFSO.CreateTextFile($strFullName)
$oFile.Close

[/autoit]

Öffnen von Textdateien
Objekt vom Typ TextStream
Methode: OpenTextFile

Code

Modi:
ForReading    (1) Die Datei wird im Lesemodus geöffnet. Schreiben in die Datei 
                  ist nicht möglich (hierzu müssten Sie die Datei schließen und 
                  dann im Modus ForWriting oder ForAppending neu öffnen).
ForWriting    (2) In diesem Modus werden die vorhanden Dateien der Textdatei mit
                  den neuen Daten überschrieben.
ForAppending  (8) In diesem Modus werden die neuen Dateien an die bestehenden 
                  Daten der Datei angehängt.

[autoit]

Const $ForReading = 1
Const $ForWriting = 2
Const $ForAppending = 8
Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.OpenTextFile($Path, 'Modus')
; z.B. 'Test.txt' zum Lesen öffnen
$oFile = $oFSO.OpenTextFile('D:\Data\Test.txt', 1)

[/autoit]

Methoden zum Lesen

Code

Read       Liest die angegeben Anzahl an Zeichen. Der folgende Befehl liest zum 
           Beispiel die ersten 12 Zeichen der ersten Zeile und speichert diese 
           in der Variable $strText:
           $strText = $oTextFile.Read(12)
ReadLine   Liest eine Zeile auf der Textdatei. Der folgende Befehl liest zum 
           Beispiel die erste Zeile und speichert sie in der Variable $strText:
           $strText = $oTextFile.ReadLine
ReadAll    Liest die gesamte Textdatei.
Skip       Überspringt die angegebene Anzahl an Zeichen. Der folgende Befehl 
           überspringt zum Beispiel die ersten 12 Zeichen. Alle weiteren 
           Leseoperationen beginnen also bei Zeichen 13:
           $oTextFile.Skip(12)
SkipLine   Überspringt eine Zeile. Der folgende Code liest zum Beispiel die erste 
           und die dritte Zeile:
           $strText = $oTextFile.Readline
           $oTextFile.SkipLine
           $strText = $oTextFile.Readline

Alles anzeigen

Achtung: Der Versuch eine leere Datei zu Lesen führt zu einem Laufzeitfehler.
Dies läßt sich umgehen, indem nur Dateien >0 geöffnet werden.

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.GetFile($Path)
If $oFile.Size > 0 Then
$oReadFile = $oFSO.OpenTextFile($Path, 1)
$strContents = $oReadFile.ReadAll
MsgBox(0, 'Datei Inhalt', $strContents)
$oReadFile.Close
Else
MsgBox(0, 'Datei Inhalt', "Die Datei ist leer.")
EndIf

[/autoit]

Zeilenweises Lesen einer Textdatei

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.OpenTextFile($Path, 1)
$n = 1
Do
$strLine = $oFile.ReadLine
MsgBox(0, 'Text Zeile: ' & $n, $strLine)
$n += 1
Until $oFile.AtEndOfStream
$oFile.Close

[/autoit]

Eine Textdatei Zeichen für Zeichen einlesen
Methode: Read
Bsp.: aus jeder Zeile nur das sechste Zeichen Auslesen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.OpenTextFile($Path, 1)
$str = ''
Do
$oFile.Skip(5)
$strCharacters = $oFile.Read(1)
$str &= $strCharacters & @LF
$oFile.SkipLine
Until $oFile.AtEndOfStream
$oFile.Close

[/autoit]

In Textdateien schreiben
Methoden: Write, WriteLine oder WriteBlankLines

Code

Write             Schreibt Daten in eine Textdatei, OHNE einen Zeilenumbruch anzuhängen. 
                  Der folgende Code schreibt zum Beispiel zwei Strings in eine Textdatei:
                  $oFile.Write ("Die ist Zeile 1.")
                  $oFile.Write ("Die ist Zeile 2.")
                  Die Textdatei sieht dann so aus:
                  	Die ist Zeile 1.Die ist Zeile 2.
WriteLine         Schreibt Daten in eine Textdatei und hängt einen Zeilenumbruch an. 
                  Der folgende Code schreibt zum Beispiel zwei Strings in eine Textdatei:
                  $oFile.WriteLine ("Die ist Zeile 1.")
                  $oFile.WriteLine ("Die ist Zeile 2.")
                  Das Ergebnis sieht so aus:
                  	Die ist Zeile 1.
                  	Die ist Zeile 2.
WriteBlankLines   Schreibt eine leere Zeile in die Textdatei. Der folgende Code schreibt zwei Strings 
                  in die Textdatei und trennt diese durch einen Leerzeile:
                  $oFile.Writeline ("Dies ist Zeile 1.")
                  $oFile.WriteBlankLines(1)
                  $oFile.Writeline ("Dies ist Zeile 2.")
                  Das Ergebnis sieht so aus:
                  	Dies ist Zeile 1.


                  	Dies ist Zeile 2.

Alles anzeigen

Überschreiben von Dateien
Wird eine Datei im Modus ForWriting geöffnet, dann werden die in der Datei vorhanden Daten mit den neu geschriebenen Daten überschrieben.

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.OpenTextFile($Path, 2)
$oFile.Write('Text neu')
$oFile.Close

[/autoit]

Neue Daten an bestehende Daten anhängen

[autoit]

Dim $oFSO = ObjCreate('Scripting.FileSystemObject')
$Path = 'DATEIPFAD'
$oFile = $oFSO.OpenTextFile($Path,
$oFile.WriteLine('TextZeile angehängt')
$oFile.Close

[/autoit]

**BugFix**

Mignon, was is nu ?
Bekommst du Control-Infos vom Window-Info-Tool?

Beiträge von BugFix

Weihnachtskalender

Schmutziges Keyboard

Weihnachtskalender

Schmutziges Keyboard

Weihnachtskalender

combo eingaben speichern

mehrere Checkboxen überprüfen

Pointer Position

Pointer Position

Tray Menü bearbeiten

Icon richtig darstellen - ID falsch

grundlegendes zum thema pixelsearch

Objekt: WScript.Shell

Else - if --> ich werde wahnsinnig!

UDF-Sammlung: Objekt Dictionary

Counter

Objekt: WScript.Shell

Objekt: Scripting.Dictionary

Objekt: Scripting.FileSystemObject

Popup speichern