Musste ich erst mal ausprobieren, weil mir das noch gar nicht aufgefallen war. Ich habe bei mir die Ruler auf 80 gesetzt und AutoWrap auch auf diesen Wert. Dadurch überlappen meine beiden Fenster nie.
Du wolltest, dass der AutoWrap in der Hälfte, die du zusammen schiebst, ebenfalls AutoWrap mitwandert. Ich habe dafür auch keine Möglichkeit entdeckt.
Technisch sollte es so funktionieren. Den Callback musst du ja nicht initialisieren. Die Funktion erwartet nur eine Callbackfunktion vom Typ "MONITORENUMPROC" (winuser.nim, #4083)
include winim/[inc\winuser]
# Deine Prozedur muss exakt dem verlangten Typ "MONITORENUMPROC" entsprechen
# MONITORENUMPROC* = proc (P1: HMONITOR, P2: HDC, P3: LPRECT, P4: LPARAM): WINBOOL {.stdcall.}
proc MyInfoEnumProc(hMonitor: HMONITOR,hDC: HDC,rect: LPRECT,lparam: LPARAM): WINBOOL {.stdcall.} =
if hDC != 0: return TRUE # ist jetzt von mir vermutet, dass hDC leer ist, wenn kein weiterer Monitor vorhanden
else: return FALSE
let
hwndScreen = FindWindowA("Progman", nil) # hWnd Desktop
dcScreen = GetDC(hwndScreen) # DC Desktop
var
lprcClip: LPCRECT # Rect
lpfnenum = MyInfoEnumProc # callbackfunktion
data: LPARAM
EnumDisplayMonitors(dcScreen, lprcClip, lpfnenum, data)
ReleaseDC(hwndScreen, dcScreen)
# Deine Auswertung ...
# ...Probiers mal mit EnumMonitors
Diese Funktion existiert und ist zu finden in der Datei:
C:\Users\USER\.nimble\pkgs\winim-3.3.0\winim\inc\winspool.nim
Habs jetzt nicht probiert, ob sie mit import winim verfügbar ist. Ansonsten sollte es auch gehen mit import winim\inc\winspool.nim
Hm, recursiv... ist das denn nicht eher ein iteratives Durchsuchen?
- Öffne Datei-1
- Finde Include1 - Öffne dieses (Sub)Include und finde dort ein weiteres Include usw. usf.
- Finde Include2- Öffne dieses (Sub)Include ......
Das ist m.M. ein rekursives Vorgehen (auf das, was ich gefunden habe, erneut mit demselben Verfahren zugreifen)
In dem Bsp. im obigen Post habe ich die Funktion BalancedPairs, die ich schon mal als Einzelfunktion erstellt hatte, aufgesplittet in Einzelfunktionen. Die Einzelfunktion hatte sich nach jedem Fund selbst aufgerufen um weiterzusuchen (eindeutig rekursiv). In der neuen Version ist das Vorgehen aufgesplittet. Somit eher keine Rekursion.
Ich bin mir nicht ganz sicher was genau du versuchst
Im Moment sammele ich erstmal Lösungsansätze. Ich habe zwei Baustellen (GetUnsusedVars, ManageIncludes), die beide auf derselben Basis arbeiten (sollen) --> On-The-Fly müssen Dateien und Includes (und Includes in Includes..) durchsucht werden.
Ich werde sehr wahrscheinlich den zeitintensiven Part auslagern (Nim). Aber das steckt alles noch am Anfang, wobei das Vorgehen selbst von der Sprache unabhängig ist.
Einen eierlegenden RegEx zu finden halte ich für eine sehr schlechte Idee, das Ding zu parsen für sinnvoller.
Die eierlegende Wollmilchsau zu finden war auch eher scherzhaft gemeint. Aber RegEx wird für einzelne Prüfungen/Selektionen sicher dabei sein.
Wenn du es als Subpattern schreibst wird es auch deutlich übersichtlicher:
Ich habe jetzt mal einige Pattern aus meiner Patternsammlung umgeschrieben in Subpattern-Definition. Ich muss sagen: Wenn man das 2..3 mal gemacht hat, wird das Erstellen von RegEx-Pattern geradezu ein Kinderspiel.
Durch die Definition werden die Pattern viel besser lesbar und verständlich (vor allem wenn man später mal wieder in den Code schaut). Auch ein Plus, wenn mal jemand anders da reinguckt. Ist zwar etwas mehr Schreibaufwand, aber aufgrund des Benefits auf jeden Fall gerechtfertigt.
Auf jeden Fall schon mal vielen Dank für euer Interesse und eure Anregungen.
EDIT:
Was mir beim Schreiben der Definitionen mal wieder aufgefallen ist: In AutoIt fehlt ganz klar der MultiLine-String. In Lua: [[ multiline ]], in einigen anderen Sprachen: """ multiline """, und in AutoIt wurde der FeatureRequest dazu mit wenig Interesse behandelt und abgelehnt. 
Nach dieser Methode habe ich auch meine "Balanced Pairs" erstellt. Da ich damit jedoch den String rekursiv durchforstet habe, führte das mit Stringbegrenzern nicht zu sinnvollen Ergebnissen.
Func BalancedPairs($_s, $_a)
Local $aPos = __openPos($_s, $_a)
If @error Then Return SetError(1,0,0)
Local $b, $aPairs[] = ['(', '{', '[', '<', ')', '}', ']', '>']
For $i = 0 To 3
If $aPairs[$i] = $_a Then $b = $aPairs[$i + 4]
Next
Local $aRes[UBound($aPos)]
For $i = 0 To UBound($aPos) -1
$aRes[$i] = __boundSearch($_s, $_a, $b, $aPos[$i])
Next
Return $aRes
EndFunc
Func __openPos($_s, $_a)
Local $aRes[100], $n = 0
For $i = 1 To StringLen($_s) -1
If StringMid($_s, $i, 1) = $_a Then
If Mod($n, 100) = 0 Then ReDim $aRes[UBound($aRes)+100]
$aRes[$n] = $i
$n += 1
EndIf
Next
If $n = 0 Then Return SetError(1,0,0)
ReDim $aRes[$n]
Return $aRes
EndFunc
Func __boundSearch($_s, $_a, $_b, $_n)
Local $iOpen, $iLevel = 0, $c
For $i = $_n To StringLen($_s)
$c = StringMid($_s, $i, 1)
If $c = $_a Then
If $iLevel = 0 Then $iOpen = $i
$iLevel += 1
ElseIf $c = $_b Then
$iLevel -= 1
If $iLevel = 0 Then Return StringMid($_s, $iOpen, $i -$iOpen +1)
EndIf
Next
Return ""
EndFuncDie Subpattern Definition sieht schon mal super aus. 
Das Pattern zum Kommentare killen muss ich mal auf meine Skripte loslassen. Meines war etwa halb so lang und hatte ein paar mögliche Fehlerkennungen. 
Kommentare muss ich eh entfernen. Im zweiten Schritt werden alle Zeilenfortschreibungen aufgehoben und dann kann ich mit meinem eigentlichen Parsen beginnen.
Danke erst mal für eure Ideen.
Wenn ich es mit meinem Projekt verheiratet habe, gibt es das natürlich hier im Forum.
$curUrl= _StringBetween($temp[$i] ,'<lat>',"</lat") ; für jedes Array Feld des Bereiches der uns interessiert nehmen wir den Teil des Strings de wir suchen
$curUrl= _StringBetween($temp[$i] ,'<lon>',"</lon")
Du speicherst beide Ergebnisse in derselben Variable
Dein letzter Post war 4:20 Uhr ?! - Und was machst du tagsüber? 
Danke für deine Gedanken und das Hilfsangebot.
Momentan erledige ich erstmal einiges "drumherum". Da ich die ManageIncludes endlich fertigstellen will schreibe ich mir erst mal externe Parser, in der Hoffnung dann auf das Abspeichern von Funktionen/Konstanten etc. verzichten zu können und tatsächlich On-The-Fly zu arbeiten. Mal sehen ob das performancemäßig möglich ist. Wird evtl. davon abhängen, wie ich IPC hier umsetzen kann.
Ggf. werde ich dann auf dein Angebot zurückkommen.
Und jetzt geh erst mal schlafen. 
Ich möchte mal etwas Brainstorming mit euch betreiben.
Ziel: Ausbalanzierte Stringsequenzen in (auch geschachtelten) Strings erkennen.
Mir geht es darum, in Programmzeilen, die aus der au3 Datei gelesen werden, die Stringbereiche eindeutig zuordnen zu können.
Im Editor selbst ist die Zuordnung recht unproblematisch, da dort jeder Position auch der Style zugeordnet ist (editor.StyleAt[pos]).
Wenn ich z.B. folgende fiktive Programmzeile habe:
_SomeFunc($param1, '"', ';', "'", $param5, "text, text, text", '"') ; Kommentar, hat auch "string"
Hier zeigen sich auch schon Probleme:
- , kann nicht als Parametertrenner gelesen werden, da evtl. auch Bestandteil von Parametern oder Kommentar
- " kann selbst ein Parameter sein, aber auch Stringbegrenzer (oder auch zum Maskieren von sich selbst im String)
- Stringbegrenzer als ' oder " erleichtern es auch nicht unbedingt und das Bsp. kann man natürlich noch unberechenbarer gestalten.
Wahrscheinlich bleibt hier nur die Lösung, wie sie vermutlich auch vom Interpreter durchgeführt wird: Regex mit Subpattern-Definitionen, sieht z.B. so aus:
(?x) # ignore pattern whitespace
(?(DEFINE)
(?<string> ".*?" )
(?<number> \d+ )
(?<value>
\s* (?:
(?&string)
| (?&number)
| (?&list)
) \s*
)
(?<list> \[ (?&value) (?: , (?&value) )* \] )
)
^(?&value)$Wobei ich (obwohl ich Regex mag) hier mit der PCRE-Syntax etwas fremdele. Ich habe vor längerer Zeit mal mit Oniguruma gearbeitet, ist zwar ähnlich (alle Regex Dialekte ähneln sich irgendwo) - aber lag mir mehr. Naja, das ist aber nur Gewohnheitssache.
Im obigen Bsp. habe ich einen Funktionsaufruf, dadurch lässt sich der Kommentar sauber abtrennen. Habe ich aber Variablenzuweisungen mit Text (der ; enthält) wird es schon wieder unangenehmer und die ausbalanzierte Erkennung des Strings ist zwingend notwendig.
Also Lösungsvariante #1 ist, dass ich mir das Eierlegende-Wollmilchsau-Regex-Pattern bastele.
Wenn ihr ein paar Gedanken beibringen möchtet, bin ich sicher nicht böse.
Kann man immer brauchen, Paare (auch verschachtelt) mit den Begrenzern "< > [ ] { } ( )" lassen sich so sauber auslesen. Es wird nur das öffnende Zeichen übergeben:
proc balancedPairs(s: string, a: char): seq[string] =
proc openPos(s: string, a: char): seq[int] =
var seqOpenpos = newSeq[int]()
for i in 0..s.len - 1:
if s[i] == a: seqOpenpos.add(i)
result = seqOpenpos
proc boundSearch(s: string, a, b: char, n: int): string =
var
iopen: int
level = 0
for i in n..s.len - 1:
if s[i] == a:
if level == 0: iopen = i
level += 1
elif s[i] == b:
level -= 1
if level == 0:
return s[iopen..i]
result = ""
var
seqBalanced = newSeq[string]()
aPairs = ['(', '{', '[', '<', ')', '}', ']', '>']
b = ' '
sop: seq[int]
# get the counterpart char
for i in 0..3:
if aPairs[i] == a: b = aPairs[i + 4]
if b != ' ':
sop = s.openPos(a)
for i in sop: seqBalanced.add(s.boundSearch(a, b, i))
result = seqBalanced
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
let sNested = "(1st bound (nested #1 (nested #2)) 1st (neighbour nested #1) 1st)"
let bp = sNested.balancedPairs('(')
echo bp
# result: @["(1st bound (nested #1 (nested #2)) 1st (neighbour nested #1) 1st)", "(nested #1 (nested #2))", "(nested #2)", "(neighbour nested #1)"]
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Standardmäßig ist in Nim kein Ternärer Operator implementiert. Ich habe dazu etwas gefunden:
type
ConditionPair[T] = object
ifTrue, ifFalse: T
proc `!`*[T](a, b: T): ConditionPair[T] {.inline.} = ConditionPair[T](ifTrue: a, ifFalse: b)
template `?`*[T](cond: bool; p: ConditionPair[T]): T =
(if cond: p.ifTrue else: p.ifFalse)
# Example
let
a = 5
b = 7
echo (a < b ? a ! b)
# output: 5":" lässt sich nicht überladen, deshalb "!". "a" und "b" müssen selbstverständlich vom selben Typ sein.
Kommandozeilenaufrufe in Nim erlauben eine genaue Spezifikation der Parameter (Short, Long, Argument) .
Für die Auswertung gibt es fertige Funktionen.
import os, parseopt
let cmdLine = commandLineParams()
var p = initOptParser(cmdLine)
# Bei der Initialisierung des Parsers können übergeben werden:
# shortNoVal - set[char] = {}
# longNoVal - seq[string] = @[]
# allowWhitespaceAfterColon - Standard: true
for kind, key, val in p.getopt():
echo "kind: ", kind
echo "key: ", key
echo "val: ", val
#[
cmdLongOption:
Dem Key werden "--" vorangestellt, Trennung zum Val durch "=" oder ":"
C:\CODE\nim\_myExamples_>test_cmd --file="c:\test ordner\test.file" --cmd=read --pattern=(\D+)
kind: cmdLongOption
key: file
val: c:\test ordner\test.file
kind: cmdLongOption
key: cmd
val: read
kind: cmdLongOption
key: pattern
val: (\D+)
cmdShortOption:
Dem Key wird "-" vorangestellt, Trennung zum Val durch "=" oder ":".
Der Key darf dann nur 1 Zeichen lang sein!
C:\CODE\nim\_myExamples_>test_cmd -f="c:\test ordner\test.file" -c=read -p=(\D+)
kind: cmdShortOption
key: f
val: c:\test ordner\test.file
kind: cmdShortOption
key: c
val: read
kind: cmdShortOption
key: p
val: (\D+)
cmdArgument:
Alle Parameter die ohne vorangestellte Short-/Long Option übergeben werden, werden als Key ausgegeben. Evtl. enthaltene "=" oder ":" dienen nicht der Abtrennung zu Val, sondern sind Bestandteil des Key.
C:\CODE\nim\_myExamples_>test_cmd --file="c:\test ordner\test.file" --cmd=read pattern=(\D+)
kind: cmdLongOption
key: file
val: c:\test ordner\test.file
kind: cmdLongOption
key: cmd
val: read
kind: cmdArgument
key: pattern=(\D+)
val:
]#Doku: parseopt
Das da wäre die beste Lösung, da Windows deinem Skript bescheid gibt, wenn sich in einem bestimmten Pfad was tun sollte,
Registers a window to receive notifications from the file system or Shell
Kann man dann aber nur anwenden, wenn man eine Anwendung mit GUI laufen hat, was für Überwachungsskripte eher nicht der Fall ist. Ich habe bei mir ein Skript laufen, das alle 5 Sekunden in einem Ordner schaut, ob eine neue PDF abgelegt wurde. Diese wird dann nach bestimmten Kriterien umbenannt und an eine andere Anwendung weitergereicht. Dafür existiert selbstredend keine grafische Oberfläche.
Ich vermute mal, bei HansJ54 sieht das ähnlich aus.
Ach das ist so etwas wie ein If ... then ... elseif ... elseif?
Das ist ein Ternärer Operator, hier mehrfach verschachtelt. Wirkt wie If-Then-Else, wobei Else immer belegt sein muss. Wenn man es untereinander schreibt, wird es deutlich:
$sTCPErrorText = _ ; Zuweisung
(@error = -2) ? 'not connected' : _ ; wie: If-Then
(@error = 1) ? 'IPAddr is incorrect' : _ ; wie: ElseIf-Then
(@error = 2) ? 'Port is incorrect' : _ ; wie: ElseIf-Then
(@error = 10060) ? 'Connection timed out' : _ ; wie: ElseIf-Then
'Unknown error' ; wie: Else; doppelte "" ersetzen durch einen String, der sicher nicht vorkommt, hier !&=$/&%
Etwas sehr kompliziert, finde ich. Warum so ein String-Konstrukt? Wie wäre es stattdessen mit z.B. Chr(5), kommt im Text zu 100% nicht vor.
wie gut sieht es mit der geplanten Nutzung von Variablendeklarationen in Include Dateien aus?
Kennst du vielleicht: Bei der Entwicklung des Skriptes fällt dir auf, dass sich noch ein ständig wachsender Haufen an Folgemaßnahmen erforderlich macht und dann schiebst du das erst mal vor dir her. Ein wesentlicher Punkt (der mich auch bei meinem ManageIncludes gebremst hat) ist eine Routine zum rekursiven Auslesen/Vergleichen der Includes. Da habe ich schon etliche Ansätze probiert aber noch nichts (geschwindigkeitsmäßig) zufriedenstellendes gefunden. Dadurch dass viele Includes Querverweise auf andere Includes haben, landet man da schnell in einem InfinityLoop. 
Ich werde vermutlich das Parsen der Includes in ein externes (Nicht-AutoIt) Programm auslagern, das mit der notwendigen Geschwindigkeit arbeitet.
Bei dem Projekt sind die Variablen nicht in der Hauptroutine deklariert, sondern die Dekalaration erfolgt über eine include Datei die die Variablendeklaration enthält. Um es noch komplizierter zu machen, gibt es für die Internationalisierung der GUI auch Include-dateien in zweiter Schachtelungsebene
He, da ticken wir ähnlich. 
In meinen (größeren) Projekten baue ich das so auf:
- Mainskript (meist nur ein paar Zeilen: Includes, Initialisierungsaufrufe(Variablen, GUI), Mainloop)
- getrennte Includes: Variablendeklaration, Variableninitialisierung, GUI-Erstellung, GUI-Funktionen, Programmfunktionen
Aber ich halte das alles in einer Ebene.
Bei derartigen Konstrukten ist das Problem, dass ein Include auf Variablen zugreift, welche in einem anderen Include deklariert sind, aber dieses Include noch nicht geparst wurde.
Hier die richtigen Abhängigkeiten zu finden ist nicht ohne. Eigentlich müsste man dasselbe tun, wie der Interpreter: Alle Includes in einen gemeinsamen Kontext zusammenführen und dann parsen.
Aber, wie schon oben beschrieben, wird eine Lösung für ManageIncludes auch hier ein bessere Umsetzung ermöglichen.
erwartet die Daten per Maus / Drag &Drop
Sicher, dass das nur so möglich ist? Oft gibt es die Variante die Parameter per Kommandozeile zu übergeben.
Ansonsten schau dir mal die _FileDragDrop.au3 an.
Warum willst du das mit der Maus machen?
Ziehen ist doch nichts anderes als
Copy To
oder
Move To
wohin muss die GetUnusedVars.au3 kopiert werden
$(SciteDefaultHome) ist das Installationsverzeichnis von SciTE. Das würde ich nicht zum Speichern eigener Anwendungen empfehlen. Verwende besser einen Ordner im Bereich USER, indem du Skripte (au3 und lua) für SciTE ablegst. Z.B. C:\Users\USER\MySciTE.
Am Besten speicherst du diesen Pfad in der SciTEUser.properties (SciTE-Optionen-Benutzereinstellungen) als:
User.Scripts.Path=C:\Users\USER\MySciTE
Dann kannst du später in den SciTE.properties auf den Pfad immer zugreifen in der Form $(User.Scripts.Path).
In deinem Fall also entweder:
command.39.*.au3="$(autoit3dir)\autoit3.exe" "C:\Users\USER\MySciTE\GetUnusedVars.au3" "$(FilePath)" "1" "0"
oder:
command.39.*.au3="$(autoit3dir)\autoit3.exe" "$(User.Scripts.Path)\GetUnusedVars.au3" "$(FilePath)" "1" "0"
Ja, sind denn schon wieder Ferien, dass die Bot-Kiddies aus den Löchern kriechen?
Natürlich: CLOSED
[OT]
zieht nur über die alten Leute her
Na ob du da richtig liegst. Kann gut sein, dass die meisten Posts von "Älteren" kamen.
[/OT]
