Das mit dem zusätzlichen Thread sieht bisher sehr gut aus. Ich denke, dass ich erstmal damit weiter mache.
Ich habe noch einen "Trick" gefunden, wie man den "--Threads:on" Parameter auch beim Start von VSCodium ausführen lassen kann:
Man muss im gleichen Verzeichnis wo die "nim"-Datei liegt, eine Datei mit dem gleichen Namen aber der Endung ".nims" (s am Ende) erstellen und dort folgendes eintragen: --threads:on.
Das war's schon. Beim Start von VSCodium werden dann auch Threads benutzt.
Wenn die Semikola wirklich nur als Spaltentrenner dienen:
Global $sCSVfile = @ScriptDir & '\test.csv'
Global $aDataCSV = StringSplit(FileRead($sCSVfile), @CRLF, 3), $sTmp
For $i = 0 To UBound($aDataCSV) - 1
$sTmp = StringReplace($aDataCSV[$i], ';', '*', 25) ; die ersten 25 Semikola in * umwandeln
$sTmp = StringReplace($sTmp, ';', '*', -6) ; ebenso die letzten 6
$sTmp = StringReplace($sTmp, ';', '') ; die uebrigen Semikola loeschen
$sTmp = StringReplace($sTmp, '*', ';') ; jetzt die * wieder in Semikola wandeln
$aDataCSV[$i] = $sTmp
Next
Global $hFile = FileOpen(@ScriptDir & '\test_new.csv', 2)
If $hFile <> -1 Then
For $sData In $aDataCSV
FileWriteLine($hFile, $sData)
Next
FileClose($hFile)
EndIfOk, ich habe doch noch eine Möglichkeit gefunden: MultiThreading
Ich erstelle meine eigene Mainloop und lasse diese in einem zusätzlichen Thread laufen:
# Be sure to compile with --threads:on
import wNim, os
var
bStart: bool = false
iCount: int = 0
let app = App()
let frame = Frame(title="Test", size=(400, 300))
let panel = Panel(frame)
let idLabel = StaticText(panel, label= $iCount, pos=(10, 10), size=(380, 20))
let idButton = Button(panel, label="Start/Stop", pos=(10, 50), size=(100, 25))
idButton.wEvent_Button do (): bStart = not bStart
proc MyMainLoop() =
while true:
sleep(1000) # <- simuliert hier die Zeit zum auswerten der Daten
{.gcsafe.}:
if bStart == true:
iCount += 1
idLabel.label = $iCount
var thMainLoop: Thread[void]
createThread(thMainLoop, MyMainLoop) # starte einen extra Thread mit MyMainLoop
frame.center()
frame.show()
app.mainLoop()Achtung! Beim compilieren muss --threads:on angegeben werden!
muss ich wohl eine Timer-Prozedur verwenden:
Mist! Das klappt auch nicht. Wenn ich mal ein Sleep(1000) als Test verwende, dann hakelt das Ganze (Versuch, das Fenster zu bewegen, zeigt das).
Auch ein "frame.stopTimer" hilft dabei nicht: 
import wNim, os
var
bStart: bool = false
iCount: int = 0
let app = App()
let frame = Frame(title="Test", size=(400, 300))
let panel = Panel(frame)
let idLabel = StaticText(panel, label= $iCount, pos=(10, 10), size=(380, 20))
let idButton = Button(panel, label="Start/Stop", pos=(10, 50), size=(100, 25))
idButton.wEvent_Button do (): bStart = not bStart
frame.startTimer(0.1)
frame.wEvent_Timer do (event: wEvent):
frame.stopTimer
sleep(1000) # <- simuliert hier die Zeit zum auswerten der Daten
if bStart == true:
iCount += 1
idLabel.label = $iCount
frame.startTimer(0.1)
frame.center()
frame.show()
app.mainLoop()Ich vermute, dass man alles über eigene Events regeln muss, die dann mit frame.wEvent_Irgendwas ausgeführt werden.
Das geht aber nicht immer.
Eine Event-Prozedur sollte so schnell wie möglich wieder verlassen werden (genau wie in AutoIt), weil sonst die GUI nicht aktualisiert wird bzw. andere Events warten müssen.
Ich möchte bei einem bestimmten Event (Buttonclick) eine Auswertung machen. Dort werden auch Sounds ausgegeben. Außerdem will ich einige Buttons sperren (disable). Das passiert aber erst, wenn die Event-Prozedur wieder verlassen wurde.
Um das zu umgehen, wollte ich nur einen Marker setzen (bStart im obigen Beispiel) und die eigentliche Auswertung dann in der Mainloop erledigen. Damit würden die Buttons schonmal gesperrt und die Sound würden erst in der Mainloop abgespielt werden.
Aber wenn das nicht klappt, muss ich wohl eine Timer-Prozedur verwenden:
import wNim
var
bStart: bool = false
iCount: int = 0
let app = App()
let frame = Frame(title="Test", size=(400, 300))
let panel = Panel(frame)
let idLabel = StaticText(panel, label= $iCount, pos=(10, 10), size=(380, 20))
let idButton = Button(panel, label="Start/Stop", pos=(10, 50), size=(100, 25))
idButton.wEvent_Button do (): bStart = not bStart
frame.startTimer(0.1)
frame.wEvent_Timer do (event: wEvent):
if bStart == true:
iCount += 1
idLabel.label = $iCount
frame.center()
frame.show()
app.mainLoop()Wenn ich in AutoIt den OnEventMode verwende, dann gibt es ja auch eine "MainLoop":
#include <GUIConstantsEx.au3>
Opt("GUIOnEventMode", 1)
Global $bStart = False, $iCount = 0
Global $hGui = GUICreate("Test", 400, 300)
GUISetOnEvent($GUI_EVENT_CLOSE, "_CloseGui")
Global $idLabel = GUICtrlCreateLabel($iCount, 10, 10, 380, 20)
Global $idButton = GUICtrlCreateButton('Start/Stop', 10, 50, 100, 25)
GUICtrlSetOnEvent(-1, '_Start')
GUISetState(@SW_SHOW)
; MainLoop
While Sleep(100)
If $bStart Then
$iCount += 1
GUICtrlSetData($idLabel, $iCount)
EndIf
WEnd
Func _CloseGui()
Exit
EndFunc ;==>_CloseGui
Func _Start()
$bStart = Not $bStart
EndFunc ;==>_StartWenn ich das Gleiche aber in Nim machen will, dann klappt das nicht (Absturz):
import wNim
import os
var
bStart: bool = false
iCount: int = 0
let app = App()
let frame = Frame(title="Test", size=(400, 300))
let panel = Panel(frame)
let idLabel = StaticText(panel, label= $iCount, pos=(10, 10), size=(380, 20))
let idButton = Button(panel, label="Start/Stop", pos=(10, 50), size=(100, 25))
idButton.wEvent_Button do (): bStart = not bStart
frame.center()
frame.show()
app.mainLoop() # wenn ich das auskommentiere, dann stuerzt das Programm ab
# das reicht wohl nicht als "MainLoop"!?
while true:
sleep(100)
if bStart == true:
iCount += 1
idLabel.label = $iCountWas passiert denn da noch in "app.mainLoop"?
Neue Version (siehe Post#1).
Vielleicht habt ihr einen zündenden Gedanken .
Das auslesen des Dateinamens habe ich hinbekommen (so nebenbei noch Dein "MyFindWindow" etwas verkürzt):
include winim/[inc\winuser]
import strutils
import wNim/[wApp, wFrame, wPanel, wTextCtrl]
let
nsiApp = App()
nsiFrame = Frame(title="Nim-SciTE interface", size=(320,220))
nsiPanel = Panel(nsiFrame)
# kuerzere Variante von MyFindWindow
proc MyFindWindow(class = "", title = ""): HWND =
let
className = newWideCString(class, class.len)
titleName = newWideCString(title, title.len)
result = FindWindowW(if class.len > 0: cast[LPWSTR](className) else: nil,
if title.len > 0: cast[LPWSTR](titleName) else: nil)
let hRecv = nsiFrame.handle
echo "NSI-handle: " & hRecv.toHex
nsiFrame.connect(WM_COPYDATA) do (event: wEvent):
var
cds: PCOPYDATASTRUCT = cast[PCOPYDATASTRUCT](event.lParam)
len: int = cds.cbData
ret: cstring = cast[cstring](cds.lpData)
sFilename: string = $ret
sFilename.setLen(len)
echo "Stringlen: " & $len
echo sFilename
proc SendCommand(hwnd: HWND, cmd: string, recv: bool = false): bool {.discardable.} =
if hwnd == 0: return false
let hScite = MyFindWindow(class = "DirectorExtension")
echo "SciTE-handle: " & hScite.toHex
var
cmdScite = ":" & $hwnd & ":" & cmd
cds: COPYDATASTRUCT
cds.dwData = 1
cds.cbData = DWORD(cmdScite.len + 1)
cds.lpData = cmdScite[0].addr
SendMessage(hScite, WM_COPYDATA, cast[WPARAM](hwnd), cast[LPARAM](cds.addr))
return true
SendCommand(hRecv, "askfilename:")
nsiFrame.center()
nsiFrame.show()
nsiApp.mainLoop()className = newWideCString("", 4096)
Du reservierst für den Classname 4096 Bytes. Das brauchst Du nicht! Der Classname darf max. 256 Bytes lang sein:
The maximum length for lpszClassName is 256. If lpszClassName is greater than the maximum length, the RegisterClass function will fail.
Siehe: https://docs.microsoft.com/en-us/windows/…nuser-wndclassw
Zum kopieren von (Unicode-)Text in die Windows-Zwischenablage kann man diese Prozedur verwenden:
Edit: Das freigeben des Speichers erfolgt jetzt nur, falls SetClipboardData fehlschlägt, ansonsten übernimmt das das System:
If SetClipboardData succeeds, the system owns the object identified by the hMem parameter. The application may not write to or free the data once ownership has been transferred to the system
Edit 18.07.2020:
- Ich habe das Ganze mal als Modul ausgebaut. Es gibt jetzt zwei Prozeduren:
"ClipPut" zum kopieren von Text in die Zwischenablage und
"ClipGet" zum holen von Text aus der Zwischenablage
include winim/[inc\winuser, inc\winnls]
import strutils
proc ClipPut*(sText = ""): bool {.discardable.} =
if sText == "": return false
let data = newWideCString(sText)
let pData = cast[LPWSTR](data[0].addr)
let iLen = data.len * 2 + 2
# Allocate memory for the data (GHND = Combines GMEM_MOVEABLE and GMEM_ZEROINIT)
let hMem = GlobalAlloc(GHND, cast[SIZE_T](iLen))
if hMem == 0: return false
let pMem = GlobalLock(hMem) # Get pointer
if pMem == NULL: return false
copyMem(pMem, pData, iLen) # Copy data to allocated memory
GlobalUnlock(hMem) # Unlock memory
if OpenClipboard(0) == 0:
GlobalFree(hMem)
return false
if SetClipboardData(CF_UNICODETEXT, hMem) == 0: # Copy data to clipboard
GlobalFree(hMem)
CloseClipboard()
return false
return CloseClipboard() != 0
proc ClipGet*(): string =
if OpenClipboard(0) == 0: return
let hData = GetClipboardData(CF_UNICODETEXT) # Get clipboard data (utf-16)
if hData == 0: return
let pData = GlobalLock(hData) # Get pointer
if pData == NULL: return
let iLen = WideCharToMultiByte(CP_UTF8, 0, cast[LPCWCH](pData), -1, NULL, 0, NULL, NULL) # Get size
result = spaces(iLen) # Create utf-8 buffer
let ret = WideCharToMultiByte(CP_UTF8, 0, cast[LPCWCH](pData), -1, cast[LPSTR](result[0].addr), iLen, NULL, NULL) # Convert to utf-8
GlobalUnlock(hData)
CloseClipboard()
if ret == 0: return ""Und das Beispiel:
import Clipboard
# Die letzten beiden Zeichen sind Unicode-Zeichen:
# "Ohm U+2126" und "doppelte Achtelnote U+266B"
# zum testen der Unicode-Faehigkeit.
let sText = "ÄÖÜäöüß^° - who`´s loving you Ω♫"
echo "ClipPut: ", ClipPut(sText)
echo "ClipGet: ", ClipGet()Oder du verwendest SetClipboardData / GetClipboardData aus der winuser.nim
Ah! Das klappt ja! Danke! 
Hier mal ein Beispiel: RE: Sammlung: Nim Snippets / Procedures
Ich wollte mal ein kleines Programm mit Nim schreiben und so ist "Nim-WindowInfo" rausgekommen. 
Das Programm öffnet ein Fenster im Vordergrund (bleibt OnTop) und zeigt verschiedene Informationen zu dem Fenster an, dass gerade aktiv ist (Nein, nicht so ausführlich wie Au3Info).
Edit: Neue Version! CopyToClipboard funktioniert nun. Danke, BugFix!
Edit 23.06.20: Neue Version!
- Hotkey geändert! <CTRL> & <C> war suboptimal, weil das ja ein globaler Hotkey ist und man somit die Zwischenablage nicht mehr normal benutzen konnte. Der Hotkey ist jetzt <ALT> & <C>.
- Es werden jetzt auch Informationen zu den Control-Elementen angezeigt. Das funktioniert noch nicht perfekt. Bei manchen Programmen werden da "falsche" Daten angezeigt.
import wNim
import os
import strutils
import times
include winim/[inc\winuser]
const sTitle = "Nim-WindowInfo"
const sVersion = "0.3.0.0"
const sDate = "23.06.2020"
const sAuthor = "Oscar (www.autoit.de)"
proc copyTextToClip(sText: string): bool {.discardable.} =
let data = newWideCString(sText)
let pData = cast[LPWSTR](data[0].addr)
let iLen = data.len * 2 + 2
let hMem = GlobalAlloc(GMEM_MOVEABLE, cast[SIZE_T](iLen))
if hMem == 0: return false
let pMem = GlobalLock(hMem)
if pMem == NULL: return false
copyMem(pMem, pData, iLen)
GlobalUnlock(hMem)
OpenClipboard(0)
if SetClipboardData(CF_UNICODETEXT, hMem) == 0:
GlobalFree(hMem)
CloseClipboard()
return false
return CloseClipboard() != 0
let appSize: wSize = (600, 720)
let app = App()
let frame = Frame(title=sTitle & " v" & sVersion[0..2], size=appSize, style=(wDefaultFrameStyle or wStayOnTop))
frame.registerHotKey(1, wModAlt, wKey_C) # <ALT> & <C> registrieren, zum speichern der Infos (siehe unten)
let panel = Panel(frame)
panel.setBackgroundColor(0x00F0F0F0)
const aCtrlTitle = [
"Window-Title", "Window-Handle", "Window-Classname", "Window-Position", "Window-Size",
"Control-Handle", "Control-Classname", "Control-Position", "Control-Size"
]
var aidCtrl: array[9, wStaticText]
for i in 0..8:
StaticBox(panel, label=aCtrlTitle[i], pos=(10, 10 + i * 70), size=(560, 60))
aidCtrl[i] = StaticText(panel, pos=(20, 35 + i * 70), size=(520, 30), style=wAlignLeftNoWordWrap)
aidCtrl[i].font = Font(14, faceName="Arial", weight=wFontWeightNormal)
let idStatus = StatusBar(frame)
idStatus.setFieldsCount(3)
frame.dpiAutoScale:
frame.minSize = appSize
frame.maxSize = appSize
var
sWinInfo: string # String zum speichern der Infos (fuer die Zwischenablage)
iTime: int = 0 # zum zaehlen der Zehntelsekunden (Anzeige "gespeichert" in der Statuszeile)
wi: WINDOWINFO # WINDOWINFO-Struktur erstellen
pWi: PWINDOWINFO = wi.addr # Pointer auf die Struktur
wi.cbSize = cast[DWORD](sizeof(wi)) # die Groesse der WINDOWINFO-Struktur eintragen
var
classBuf = newWideCString("", 256) # Buffer fuer die Class erstellen
pClass = cast[LPWSTR](classBuf[0].addr) # Pointer auf den Buffer
frame.startTimer(0.1) # starte den Timer (Zeit in Sekunden als Float)
frame.wEvent_Timer do (event: wEvent): # hier wird das Timer-Event ausgewertet
var
pt: POINT # POINT-Struktur erstellen
pPt: LPPOINT = pt.addr # Pointer auf die Struktur
GetCursorPos(pPt) # Mauskoordinaten holen (POINT)
sWinInfo = "Window\r\n" # Infostring leeren
let sPos = "X: " & $pt.x & "\tY: " & $pt.y # Mauskoordinaten holen
idStatus.setStatusText(sPos) # und in die Statuszeile schreiben
var hRoot = WindowFromPoint(pt)
hRoot = GetAncestor(hRoot, GA_ROOTOWNER)
let iTitleLen = GetWindowTextLengthW(hRoot) + 1 # Titellaenger ermitteln
var
titleBuf = newWideCString("", iTitleLen) # Buffer fuer den Titel erstellen
pTitle: LPWSTR = cast[LPWSTR](titleBuf[0].addr) # Pointer auf den Buffer
GetWindowTextW(hRoot, pTitle, iTitleLen) # den Window-Titel holen
let sWinTitle = $(cast[WideCString](pTitle)) # in einen String umwandeln
sWinInfo &= "Title: \"" & sWinTitle & "\"\r\n"
aidCtrl[0].label = sWinTitle # ins Label schreiben
let sHandle = "0x" & $(hRoot.toHex) # das Handle als Hex in einen String umwandeln
aidCtrl[1].label = sHandle
sWinInfo &= "Handle: " & sHandle & "\r\n"
var sClassname = "no class name"
if GetClassNameW(hRoot, pClass, 255) > 0: # Classnamen holen
sClassname = $(cast[WideCString](pClass))
aidCtrl[2].label = sClassname
sWinInfo &= "Classname: \"" & sClassname & "\"\r\n"
GetWindowInfo(hRoot, pWi) # WINDOWINFO vom aktiven Fenster holen
let sWinPos = "X: " & $wi.rcWindow.left & "\t Y: " & $wi.rcWindow.top
sWinInfo &= "Position: " & sWinPos & "\r\n"
aidCtrl[3].label = sWinPos
let sWinSize = "W: " & $(wi.rcWindow.right - wi.rcWindow.left) & "\t H: " & $(wi.rcWindow.bottom - wi.rcWindow.top)
sWinInfo &= "Size: " & sWinSize & "\r\n"
aidCtrl[4].label = sWinSize
let hDc = GetWindowDC(0) # Desktop-DC holen
let iColor = GetPixel(hDc, pt.x, pt.y) # Farbe unter dem Mauszeiger
let sColor = "Color: 0x" & iColor.toHex
idStatus.setStatusText(sColor, 1) # in die Statuszeile schreiben
ReleaseDC(GetDesktopWindow(), hDc) # DC freigeben
var hParent = WindowFromPoint(pt) # ab hier werden die Daten des Control-Elements ermittelt
ScreenToClient(hParent, pPt)
var hChild = ChildWindowFromPointEx(hParent, pt, 0)
if hChild == hParent: hParent = GetParent(hParent)
let sCtrlHandle = "0x" & $(hChild.toHex)
sWinInfo &= "\r\nControl\r\nHandle: " & sCtrlHandle & "\r\n"
aidCtrl[5].label = sCtrlHandle
sClassname = "no class name"
if GetClassNameW(hChild, pClass, 255) > 0: # Classnamen holen
sClassname = $(cast[WideCString](pClass))
var
iInstance: int = 0
hCheck: HWND = FindWindowExW(hParent, 0, pClass, NULL)
while hCheck != 0:
inc(iInstance)
if hCheck == hChild: break
hCheck = FindWindowExW(hParent, hCheck, pClass, NULL)
sClassname &= $iInstance
sWinInfo &= "Classname: " & sClassname & "\r\n"
aidCtrl[6].label = sClassname
var
rCh: RECT # RECT-Struktur erstellen (Control)
sCtrlPos = "X: , Y: "
sClSize = "W: , H: "
if GetWindowRect(hChild, rCh.addr) == TRUE:
pt.x = rCh.left
pt.y = rCh.top
ScreenToClient(hRoot, pPt)
sCtrlPos = "X: " & $pt.x & ", Y: " & $pt.y
sClSize = "W: " & $(rCh.right - rCh.left) & ", H: " & $(rCh.bottom - rCh.top)
sWinInfo &= "Position: " & sCtrlPos & "\r\n"
aidCtrl[7].label = sCtrlPos
sWinInfo &= "Size: " & sClSize & "\r\n"
aidCtrl[8].label = sClSize
sWinInfo &= "\r\nMouse\r\nPosition: " & sPos & "\r\n"
sWinInfo &= sColor & "\r\n"
if iTime > -1: dec(iTime)
if iTime == 0: # ist die Zeit fuer die "gespeichert"-Anzeige abgelaufen?
idStatus.setStatusText("", 2)
frame.wEvent_HotKey do (event: wEvent): # Hotkey-Event-Funktion
if copyTextToClip(sWinInfo):
idStatus.setStatusText("Copy to clipboard.", 2)
iTime = 30 # Zeit (in Zehntelsekunden), fuer die "gespeichert"-Anzeige
frame.center()
frame.show()
app.mainLoop()Im ZIP-Archiv (Anhang) befindet sich der obige Programmcode zum herunterladen.
Der FileSaveDialog dient nur dazu, einen Dateinamen (zum speichern) vom Benutzer anzufordern.
Das Speichern selbst geschieht dann mit "FileOpen" und "FileWrite":
Local $hFile = FileOpen($sFileSaveDialog, $FO_OVERWRITE)
If $hFile <> -1 Then
FileWrite($hFile, GUICtrlRead($g_idMemo))
FileClose($hFile)
EndIfBitte das ganze Script posten!
Ich habe noch eine Möglichkeit gefunden, das aktive Fenster zu ermitteln:
include winim/[inc\winuser]
import strutils
var
gti: GUITHREADINFO
pGti: PGUITHREADINFO = gti.addr
gti.cbSize = cast[DWORD](sizeof(gti))
GetGUIThreadInfo(0, pGti)
echo "Active: \thwnd: 0x", toHex(gti.hwndActive)
echo "Focus: \thwnd: 0x", toHex(gti.hwndFocus)Ich muss int32 zu DWORD casten, sonst meckert der Compiler.
Genau das stört mich an Nim auch.
Im Prinzip hast Du ein uint32, aber tausend verschiedene Bezeichnungen.
Und obwohl es quasi der gleiche Datentyp ist, musst Du immer hin- und her casten.
Passiert das bei euch ebenso?
Ja, aber der Grund ist, dass Du zwar einen Pointer hast, aber der zeigt auf keinen Speicher für das RECT.
So geht's:
include winim/[inc\winuser]
var
h = GetForegroundWindow()
r: RECT
lpr: LPRECT = r.addr
echo "Is Window? ", bool(IsWindow(h))
echo "Success? ", bool(GetWindowRect(h, lpr))
if GetLastError() == 1400: echo "ERROR_INVALID_WINDOW_HANDLE"Alle 3 Versuche führen angeblich zum Erfolg: das aktive Fenster ist hinterher dasjenige, welches ich nach vorn bringen wollte.
Also, wenn ich Dein ursprüngliches Programm (aus Post#1) nehme und statt "Mozilla" "SciTE" benutze, dann funktioniert es genau so, wie es soll:
include winim/[inc\winuser]
import strutils
var hFore = GetForegroundWindow()
echo "Foreground Wnd: 0x", toHex(hFore)
let
class = "SciTEWindow"
h = FindWindowW(cast[LPWSTR](newWideCString(class, class.len)), nil)
echo "SciTE: 0x", toHex(h)
if bool(IsWindow(h)):
echo bool(SetForegroundWindow(h))
hFore = GetForegroundWindow()
echo "active Wnd: 0x", toHex(hFore)
if hFore != h: echo "SciTE isn't active"
else:
echo "none window handle"Foreground Wnd: 0x0000000000030AF8
SciTE: 0x0000000000120718
true
active Wnd: 0x0000000000120718
Ah, mir ist gerade noch eine Funktion in den WinApis aufgefallen: _WinAPI_MonitorFromWindow
Returns the handle to the monitor that has the largest area of intersection with the window
Damit bekommst Du die Displaynummer, die den größten Teil des Fensters enthält:
#include <WinAPIGdi.au3>
#include <WinAPISysInternals.au3>
Run("notepad.exe")
WinWait("[CLASS:Notepad]", "", 10)
$hWnd = WinGetHandle("[CLASS:Notepad]")
ConsoleWrite(_GetDisplayNumber($hWnd) & @CR)
Func _GetDisplayNumber(ByRef $hWnd)
Local $hMonitor = _WinAPI_MonitorFromWindow($hWnd)
Local $aDiplays = _WinAPI_EnumDisplayMonitors()
For $i = 1 To $aDiplays[0][0]
If $aDiplays[$i][0] = $hMonitor Then Return $i
Next
Return 0
EndFuncNur zum Verständnis: wieso wird GUISetState nur im Errorfall aufgerufen? Muss das nicht immer passieren?
Nein, das muss nur im Fehlerfall passieren, weil das sonst "_LoadWindowPlacement" übernimmt.
