Und was machst du tagsüber?
Im Augenblick machen wir in unserem Betrieb Schichtdienst - wegen Coronna und Reduzierungs des Ansteckungsrisiko. Auch wenn ich viel von zuhause arbeiten kann, muß ich dann auch in dem entsprechenden Zeitschema arbeiten.
Durch die Schichtwechsel ist der Schlafrythmus immer etwas gestört, das wäre die Zeit wo ich für die Frühschicht aufstehen müßte - auch wenn ich diese Woche Spätschicht habe.
PapaPeter
Hallo Bugfix,
Wenn ich noch genauer nachdenke fallen 2 Dinge ein die ich noch variieren würde:
... Sobald Du auf ein Include triffst - trage es in eine Liste ein. Wenn das Include vorher schon in der Liste war überspringe es, Wenn das Include vorher nicht in der Liste war, arbeite das Include jetzt analog zeilenweise ab, bis Du auf das nächste Include triffst oder oder das Ende des Includes erreichst....
Da man in der Regel nicht an "unnötig" deklarierten Variablen/Konstanten in Standard-Includes interessiert ist und um diese nicht jedes Mal durchsuchen zu müssen, würde ich eine Option vorsehen diese zu ignorieren. In dem Fall würde das Include einfach so übernommen, wie es im Sourcecode steht.
Eine weitere Variation wurde ich ebenfalls [optional] noch in diesem Punktt vornehmen:
... Starte mit dem ursprünglichen Script arbeite dich Zeile für Zeile durch das Skript und kopiere den gescannten Teil eine Tempdatei....
Im Sinne einer schnelleren Abarbeitung und in Anbetracht heutiger Speichergrößen, sollte es in der Regel reichen das Ergebnis in ein Array zu schreiben.
Papa Peter
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.
Das ist bei mir ähnlich kurzes Hauptprogramm, das dann die Haupbestandteile also aufruft, also:
* Globale Variablen und Allgemeine Autoit Includes (hier oder nach der Initialisierung ggf. Einbindung von länderspezifischen Parameter für Internationalisierung als getrenntes Include)
* Programmspezifische Funktionsbibliotheken als includes definiert
* Includes für die Initialisierung (Parameter aus SQL Datenbanken oder ini-dateien einlesen), ggf. auch Auto-Update des kompilierten Programms
* Funktionen für die GUI (deren oberste Ebene) aus dem Hauptprogramm aufgerufen werden,
* Include für das Gui-Handling und die Auswertung der Gui und zwar die Teile die nicht direkt aus dem Hauptprogramm aufgerufen werden. Gegebenfalls - je nach Umfang - noch getrennt wie es thematisch passt.
Manchmal kann - zumindestens ich - es ablauftechnisch aufgrund der Deklarations-Abhängigkeiten nicht vermeiden die Includes zu schachteln, andererseits versuche ich halt thematische Blöcke pro include zu finden um sich nicht einen Wolf bein Debugging zu suchen.
In meinen größten Projekt stecken einige 10.000 Zeilen eigener Code. Deshalb dokumentiere und modularisiere ich lieber extrem, als Code auf Teufel komm raus zu optimieren, Schliesslich will ich einen Fehler auch noch 3 Jahre später finden können, nur weil ich gerade mal was angepasst habe und jetzt der Fehler nicht auf Anhieb zu finden ist sondern durch die andere Nutzung ganz wo anders vergraben ist.
PapaPeter
Da gebe ich Dir vollkommen recht, eine gute Idee zieht manchmal viel nach was dann ach noch alles berücksichtigt werden kann und das man im ersten Anlauf gar nicht gesehen hat.
Wenn Du dich durch alle Dateien hangeln willst, würde ich folgendermassen vorgehen - aber das wäre nur mein Ansatz:
Starte mit dem ursprünglichen Script arbeite dich Zeile für Zeile durch das Skript und kopiere den gescannten Teil eine Tempdatei.
Sobald Du auf ein Include triffst - trage es in eine Liste ein. Wenn das Include vorher schon in der Liste war überspringe es, Wenn das Include vorher nicht in der Liste war, arbeite das Include jetzt analog zeilenweise ab, bis Du auf das nächste include triffst oder oder das Ende des includes erreichst.
Hast Du das Ende des Includes erreicht mache mit dem Sourcecode in der übergeordneten Ende weiter bis du irgendwann das Ende der Haupdatei erreicht hast.
Am Ende hast Du eine temporäre Datei die allen Sourcecode einmal in chronlogischer Reihenfolge enthält und den du dann parsen kannst.
Include-Once würde ich ignorieren und Includes auch nicht mehr mehrfach einbinden (wegen der Gefahr von Schleifen).
Das einzige Problem was Du jetzt noch hast ist die Zuordnung der Zeilen in der Tempdatei zu den eigentlichen Sourcecodedateien.
Hier fallen mir zwei Ansätze ein, entweder Du führst eine Liste die Zuordnung jeder Zeile in der Tempdatei zu der Zeile und den Namen der Sourcecodedatei enthält (u.U. schneller aber Resoucen fressender) oder du erfasst nur eine Liste der Sprünge zwischen den Soucecodedateien mit jeweiligenj Zeilennummern (weniger Resourcen, aber schwieriger zu tracken). Diese Hilfslisten sollten sich auch parallel auch dazu nutzen zu lassen, wo man am Ende des Parsen einer Sourcecodedatei weiterfortsetzen muss.
Am Ende musst Du also sogar noch mehr tun als der Interpreter, da es ja nicht reicht einen Fehler festzustellen, sondern man muß ihn ja auch noch lokalisieren.
Die Umsetzung könnte ein interessante Herausforderung werden, aber fürchte Dir bleibt dazu vermutlich genauso wenig Zeit wie mir.
Wenn ich in näherer Zeit (Sommerferien vielleicht) etwas Luft haben sollte und Du auch noch Unterstüzung möchtest, könnte ich Dich gerne unterstützen. Aber ich verstehe auch wenn das Du gerne das Heft in der Hand halten möchtest und Programmierstile sind auch nicht immer kompatibel. Sehe es einfach als Angebot das Du auch unbegründet ablehnen kannst - ich bin Dir in keinem Fall böse.
PapaPeter
Hallo BugFix,
cooles Script - es war mir gar nicht bewußt das man SAPI von AutoIt nutzen kann.
Hallo BugFix,
wie gut sieht es mit der geplanten Nutzung von Variablendeklarationen in Include Dateien aus?
Bei mir habe ich dein Script mal auf ein (zugegebenermassen extrem umfangreiches) Projekt angesetzt und es gibt Variablen aus als 'Out_Of_Func' aus die in einer geschachtelten include Ebene enthalten sind. 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 (komme nicht dazu die Meldungen in eine ini-Datei zu verfrachten). Schachtelung ist also etwa in der Form Hauptcode => Include Globale Variablendeklaration => Include Internationale GUI-Meldung . Bin mir jetzt nicht sicher, ob eine solche Stuktur bei der Überprüfung überhaupt vorgesehen war.
Bei normalen Skripten ohne Variablendeklaration in Include-Dateien funktioniert es bei mir prima.
Danke PapaPeter
Natürlich, ändere das noch eben 
War irgendwie der Wurm drin - sorry
Hallo Bitnugger,
zu Deiner Anmerkung:
So kannst du dir das If $Debug=1 Then an zig Stellen sparen:
Ich bin durchaus auch ein Fan, mehrfach benutzte Teile in Funktionen auszulagern, aber für Debugcode mache ich das in der Regel nicht. Mal ehrlich der Kosten-/Nutzen-Aufwand ist in diesem Fall eher gering, vor allem wird es durch den Funktionsnamen '_ConsoleWrite' auch nicht lesbarer.
Zu Deiner Anmerkung:
UDF-Version
Anscheinend benutzte ich eine zu alte Version von Scite4AutoIt3 (bzw. von Jos SciTE Config), meine Version hatte die 'Generate UDF Header Option' noch nicht oder zumindestens waren sie mir nicht bewußt. Ich hatte noch eine sehr frühe Version (unter 1.6, aktuell ist 1.19) von Scite4AutoIt3 installiert und bisher nicht die Notwendigkeit gesehen dies zu ändern. Jetzt habe ich mal aktualisiert. In der reinen "Einbinde" Version meines Codes, die ich vielleicht unsauber "UDF-Version" genannt hatte, war weiterhin alles von Hand kommentiert. Ich werde das demnächst auf eine CallTip Manager kompatible Version umstellen - Danke für den Hinweis.
Zu Deiner Anmerkung
Anhand der Parameter lässt sich zwar ableiten, was die Funktion macht, schöner wäre aber, wenn sich dies bereits anhand des Funktionsnamen ableiten lassen würde.
Sprechende Funktionsnamen sind was Schönes und ich bin ein starker Verfechter der sprechenden Funktionsnamen. Ich finde 'MoveToActiveDisplay'. In der Tat wäre 'MoveWindowToActiveDisplay' wohl besser gewesen und es macht aus meiner Sicht Sinn die Funktion umzubennen.
Der Name 'MoveWindowToDisplayFromMousePos' macht aus technischer Sicht vielleicht mehr Sinn. Er ist aber erstens aus meiner sich für den Users/Anwenders zu lang (vor allem nicht alle User nutzen Scite und Autoextension) und zweitens wenn ich irgendwo mit der Maus irgendwohin klicke und sich dann ein Fenster öffnet, möchte ich gerne das es sich auf demselben Bildschirm öfnen wo sich gerade hinschaue, also aus meiner Sicht da wo sich gerade die Maus befindet.
Insofern macht es für mich Sinn den Bildschirm auf dem sich die Maus gerade befindet als aktiven Bildschirm zu bezeichnen. Aus technischer Sicht gibt es keinen Grund einen Bildschirm zu bevorzugen und man könnte es so lassen wie es ist und bräuchte die Funktion gar nicht. Aus Gründen der Usablity gibt aber für mich schon gewichtige Gründe von einem aktiven Bildschirm zu sprechen.
Zu Deiner Anmerkung:
...ein Window-Handle sollte man schon übergeben können...
Das wäre auch eine Option gewesen und sicher kann man da gerne nachbessern. So wie es in der Routine genutzt wird wäre hier vermutlich ein Windows Handle auch möglich, da es an die entspechen Window... Funktionen weitergeleitet wird - das muß ich aber erst einmal testen (offensichtlich programmiert jeder etwas anders- also gibt es unterschiedliche Needs). Es wird hier nicht der Parameter direkt überprüft, so wie Du es vorschlägst - dann würde tatsächlich nur das eine oder das andere gehen - sondern es wird überprüft ob mit dem Übergabeparametern das Fenster gefunden wird. Aus meiner Sicht ist das hier fehlertoleranter, da es keine unnötigen Beschränkungen einführt und umgekehrt nichts passieren kann wenn hier Müll landet - dann kommt es halt zu dem Fehler, daß das Fenster nicht gefunden werden kann. Ich schaue mal, ob ich eine Lösung finden kann die unser beiden Ansprüchen gerecht wird 
.
Zu Deiner Anmerkung:
... Gar nicht schön! ...
Hier geht es um die Kombination WinActivate/WinWaitActive. Hast Du mal den orginalen Beispiel-Code laufen lassen? Hier wird ein externes Programm gestartet - nämlich Notepad. Wenn man in AutoIt ein externes Programm startet und direkt danach ein WinExist macht, dann kann man das Problem haben das Notepad zwar gestartet wird, das Fenster aber noch nicht erschienen ist und damit das WinExists fehlschlägt.
Zugegeben das Problem sollte nicht bei im eigentlichen Sourcecode erzeugten Fenstern auftreten, davon kann ich aber nicht immer ausgehen.
Was wäre die Alternative gewesen? Man kann auch eine Schleife mit WinExists machen, die benötigt aber zwingend ein Timeout da es sonst unendlich auf ein Fenster wartet das nicht gefunden werden kann (z.B. aufgrund fehlerhafter Parameter) und die Ausführung in der Funktion hängen bleibt. Dies wäre mit einem zusätzlichen optionalen Parameter möglich, der einen Defaultwert enthält.
Um ehrlich zu sein der Code stand ursprünglich nur im Beispielcode und nicht in der Funktion. Dann hatte ich mir gedacht, das die User obiges verzögertes Verhalten bei Aufruf von externen Programmen nicht berücksichtigen und sich wundern werden, das die Funktion nicht "richtig" arbeitet und habe den Code kurzerhand in die Funktion verschoben.
Jetzt zu dem Punkt - sollte eine Funktion ein Fenster überhaupt aktivieren wenn es verschoben werden soll? Aus meiner Sicht macht das durchaus Sinn, sonst kann es passieren das das Fenster zwar verschioben wird, aber hinter einem anderen Fenster verschwindet (ist mir auch beim Testen pasiert). Lösung wäre auch hier ein optionaler Parameter, der ein gezieltes Aktivieren/Belassen des Fensters im bisherigen Status erlaubt.
Ich werde mal überlegen und testen ob ich die beiden obigen Punkte in einer zukünftigen Version berücksichtige.
Zu Deiner Anmerkung:
... Variablennamen... schöner wäre, wenn du sie entsprechend des Typs deklarierst.... Hier findest du das Wiki dazu: https://www.autoitscript.com/wiki/Best_coding_practices ...
Bitnugger über Best Practices kann man lange streiten und ich weiß das in den AutoIt-Foren, den AutoIt Helpdateien und dem AutIt Wiki wird tatsächlich die Typ-basierte Benennung bevorzugt wird (in der Regel ohne sprechende Namen - als kleine Randnotiz). Die Bevorzugung war aber nicht immer so eindeutig (ich programmiere schon seit über 30 Jahren und auch AutoIt schon ewig - z.B. die deutsche AutoIt2 Hilfe Übersetzung stammte von mir im Alleingang).
Ich persönlich bin eher ein Anhänger im Beginn des Namens klar zu machen in welchem Kontext die Variable steht (Lokal, Global, Parameter) und wozu sie verwendet wird. Der Typ ist für mich in der Regel aus dem Kontext klar. Bei größeren Projekten (und meine Projekte sind sehr umfangreich) ist mir persönlich das zumindestens wichtiger. Außerdem können Übergabevariablen in AutoIt auch von unterschiedlichen Typ sein wie z.B das Beispiel Winexists zeigt.
Im Sinne einer einheitlichen Ausrichtung wäre ich bereit den Sourcecode umzuschreiben, aber eigentlich möchte ich auch gerne meinem eigenen Stil treu bleiben.
Danke für dieAnregungen
Papa Peter
P.S.: Vielleicht bin ich unverbesserlich - aber ich hege keine Feindschaft gegen Dich nur weil Du Kritik äußerst - wenn alle gleich Denken wäre es langweilig.
Hier noch der Sourcecode in lesbarer Form
mit Berücksichtigung von Kommmentaren von Bitnugger und Übernahme der Änderungen von BugFix
Kommentatare in der UDF-Version sind jetzt in englisch
#include-once
#include <WinAPIGdi.au3> ; Used by _WinAPI_EnumDisplayMonitors, _WinAPI_GetMousePos, _WinAPI_MonitorFromPoint and _WinAPI_GetPosFromRect
#include <StructureConstants.au3> ; DLLStruct Windows API constants used by function CheckCoordinatesInRange
; ==> Example for invoking found in MoveToActiveDisplay.au3 on https://autoit.de/thread/86942-autoit-script-f%C3%BCr-multi-bildschirm-betrieb/
; #FUNCTION# ====================================================================================================================
; Name ..........: MoveWindowsToActiveDisplay
; Description ...: Move a window to the active display monitor in a 2 display configuration
; (active window is considered to be where the mouse is located)
; Syntax ........: MoveWindowsToActiveDisplay($ParmWindowTitle[, $ParmWindowText = ""[, $ParmTimeOut [, $ParmActivateWindow]])
; Parameters ....: $ParmWindowTitle - The title/hWnd/class of the window to move
; $ParmWindowText - Text in the window to move. Default is an empty string.
; $ParmTimeOut - Max timeout in seconds while searching for the window. Default value is 3.
; $ParmActivateWindow - If value is 1 the window will be activated to get it to the foregound. Default is 1
; Return values .: 1 - function completed successfully
; 0 - an error has occued
; Author ........: PapaPeter
; Modified ......: 4.5.2020, considering recommendations from Bitnugger
; Remarks .......: error codes: 1 - Given window doesn't exist
; 2 - No display regonized
; 3 - no active display monitor found
; Tested with AutoIt Version 3.3.14.2
; Related .......: Auxiliary function CheckCoordinatesInRange in same file is used
; Link ..........: https://autoit.de/thread/86942-autoit-script-f%C3%BCr-multi-bildschirm-betrieb/
; Example .......: MoveWindowsToActiveDisplay("Untitled - Notepad")
; ===============================================================================================================================
Func MoveWindowsToActiveDisplay($ParmWindowTitle, $ParmWindowText="", $ParmTimeOut=3, $ParmActivateWindow=1)
; Initialization
Local $ReturnValue = 1 ; If no error occurs ReturnValue is 1
; Activate window in max $ParmTimeOut seconds or wait $ParmTimeOut seconds for window to exist
If $ParmActivateWindow=1 then ; If window should be activated
WinActivate($ParmWindowTitle, $ParmWindowText) ; use commbination WinActivate/WinWaitActive to ensure that window is already existing and visible
WinWaitActive($ParmWindowTitle, $ParmWindowText, $ParmTimeOut) ; wait $ParmTimeOut seconds max for window to be activated
Else ; If window should not be activated
Local $Count=1 ; while loop for windows, loop will be skipped after $ParmTimeOut seconds or if window exists
While ($Count>$ParmTimeOut And WinExists($ParmWindowTitle, $ParmWindowText))
Sleep(1000)
$Count+=1
WEnd
EndIf
if WinExists($ParmWindowTitle) Then ; Check if given window exist (not ensured with code above)
Local $WindowCoordinates=WinGetPos($ParmWindowTitle,$ParmWindowText) ; Read coordinates of the given window
; Remark 1: WinGetPos will fail if windows does not exist and as result $WindowCoordinates is no array,
; Remark 2: As also above and below $ParmWindowTitle can be title, window handle or class of the window
; Get actual active displaymonitor handle out of mouse position
Local $MousePos = _WinAPI_GetMousePos() ; Reads out actual mouse position
Local $ActualMonitorHandle = _WinAPI_MonitorFromPoint($MousePos) ; get displaymonitor handle belonging to mouse position
; Gets array displaymonitor handles and number of connected displays
Local $DisplayList = _WinAPI_EnumDisplayMonitors() ; Result enumerates display monitors (including invisible pseudo-monitors associated with the mirroring drivers)
; element[0][0] contains the number of rows (displaymonitors) in array
; Search for active displaymonitor handle in array and if move window if neccesary
If IsArray($DisplayList) Then ; if we get a valid list of display monitors
Local $ActiveDisplay=0 ; set default value for active display monitor
; Lese Parameter des aktiven Fensters aus
For $DisplayCount = 1 To $DisplayList[0][0] ; Loop for all display monitors ($DisplayList[0][0] contains the number of displaymonitors)
if $DisplayList[$DisplayCount][0]= $ActualMonitorHandle Then ; Compare handle in list with previously determined handle of the active displaymonitor
Local $ActiveDisplayData = _WinAPI_GetPosFromRect($DisplayList[$DisplayCount][1]) ; If active display monitor is found get coordinate data to array $ActiveDisplayData
EndIf
Next
If IsArray($ActiveDisplayData) Then ; If we get a valid result for $ActiveDisplayData
; Check if we need to move window
if Not CheckCoordinatesInRange($WindowCoordinates, $ActiveDisplayData)=1 Then ; yes we have
; Move window with the offset of the coordinate of left top corner of the active display monitor
; Remark for further versions: Check if in display monitor configuration with 3 and more display monitors this will work too!
; We may have to consider offset on local displaymonitor, if the window was on one of other display monitors except primary display
WinMove($ParmWindowTitle, $ParmWindowText, $WindowCoordinates[0]+ $ActiveDisplayData[0], $WindowCoordinates[1]+$ActiveDisplayData[1])
If $ParmActivateWindow=1 then
WinActivate($ParmWindowTitle,$ParmWindowText) ; activate window to get it to foreground
EndIf
EndIf
Else ; If we dont get a valid result for $ActiveDisplayData (no active display monitor found)
SetError(3, 0, 0) ; set return value to 0 and error code to 3
$ReturnValue = 0
EndIf
Else ; if we dont get a valid list of display monitors (no display monitor regonized)
SetError(2, 0, 0) ; set return value to 0 and error code to 2
$ReturnValue = 0
EndIf
Else ; Given window doesn't exist
SetError(1, 0, 0) ; set return value to 0 and error code to 1
$ReturnValue = 0
EndIf
Return $ReturnValue
EndFunc ; ==> MoveWindowToActiveDisplay()
; #FUNCTION# ====================================================================================================================
; Name ..........: CheckCoordinatesInRange
; Description ...: Checks if the coordinates in $Parm_CheckCoordinatesArray are in range of the area defined in $Parm_DisplayArray
; Syntax ........: CheckCoordinatesInRange($Parm_CheckCoordinatesArray, $Parm_DisplayArray)
; Parameters ....: $Parm_CheckCoordinatesArray- Array with at least 2 entries for X and Y coordinate.
; $Parm_DisplayArray - Array reprenting an aera, at least entries for X and Y (top left corner), width and height.
; Return values .: 1 - coordinates in area
; 0 - coordinates not in area
; Author ........: BugFix, based on a script written by PapaPeter
; Modified ......: 3.5.2020 by BugFix
; Remarks .......: error codes: 1 - $Parm_CheckCoordinatesArray is no array
; 2 - $Parm_DisplayArray is no array
; Tested with AutoIt Version 3.3.14.2
; Related .......: Used by MoveWindowsToActiveDisplay as auxiliary function
; Link ..........: https://autoit.de/thread/86942-autoit-script-f%C3%BCr-multi-bildschirm-betrieb/
; Example .......: No
; ===============================================================================================================================
Func CheckCoordinatesInRange($Parm_CheckCoordinatesArray, $Parm_DisplayArray)
Local $iErr = IsArray($Parm_CheckCoordinatesArray) ? 0 : 1
$iErr += IsArray($Parm_DisplayArray) ? 0 : 2
If $iErr Then Return SetError($iErr,0,-1)
Local $tPt = DllStructCreate($tagPoint)
$tPt.X = $Parm_CheckCoordinatesArray[0]
$tPt.Y = $Parm_CheckCoordinatesArray[1]
Local $tRect = DllStructCreate($tagRECT)
$tRect.Left = $Parm_DisplayArray[0]
$tRect.Top = $Parm_DisplayArray[1]
$tRect.Right = $Parm_DisplayArray[2]
$tRect.Bottom = $Parm_DisplayArray[3]
Return _WinAPI_PtInRect($tRect, $tPt)
EndFunc ; ==> CheckCoordinatesInRange()Hallo BugFix,
können wir gerne machen, da es für reine Anwender den Code kürzer und schneller macht. Mein Gegenvorschlag eine kommentierte für Einsteiger nachvollziehbare Version und eine optimierte Version zum reinen Einbinden.
Neue Version angehängt (Berücksichtigt Kommentare von Bitnugger und Änderungen von BugFix):
Version 1.1.1 (in wesentlichen Änderungen in den UDF-Headern):
Hallo BugFix,
nette Idee - da keine zusätzlichen (Fremd-)Tools zur Erstellung von QR-Code benötigt werden und es die Nutzung im eigenen Programmen ermöglicht.
PapaPeter
Dies ist die aktuelle Version des Quellcodes in der deutsch dokumentierten Variante:
(enthält Änderungen aufgrund der Beiträge von Bitnugger und
Beispielcode für Benutzung eines Windows Handles erweitert um Fehlerhandling)
#include-once
#include <WinAPIGdi.au3> ; Benötigt für _WinAPI_EnumDisplayMonitors, _WinAPI_GetMousePos, _WinAPI_MonitorFromPoint und _WinAPI_GetPosFromRect
Opt("MustDeclareVars",1)
; Beispiel: Erzeuge ein beliebiges Fenster und verschiebe es ggf.
Run("notepad.exe") ; hier einfachheitshalber nur Notepad öffnen
; Option 1 - benutze Titel des Fensters für $WindowTitle
; Local $WindowTitle="Unbenannt - Editor" ; Titel des Fensters festlegen (dies ist der deutsche Titel des Windowsfensters von dem Editor Notepad.exe)
; Option 2 - Benutze Windows Handle für $WindowTitle
Sleep(1000) ; Hier ist es wichtig ggf. Zeit zu geben um Sicherstellen das Handle auch jetzt schon esistiert
Local $WindowTitle= WinGetHandle("Unbenannt - Editor")
If @error Then
MsgBox (48, "Fehler", "Es ist ein Fehler aufgetreten, beim Versuch das Windows Handle zu bestimmen.")
Exit
EndIf
; Option 3 - Benutze Klasse für $WindowTitle
; Local $WindowTitle="[CLASS:Notepad]" ; oder über Klasse
; Verschiebe Fenster wenn notwendig
If MoveWindowsToActiveDisplay($WindowTitle)=1 then ; Im Zweifelsfall verschiebt die Routine, das zuletzt geöffnente Fenster mit dem angegebenen Titel und Text
MsgBox (0,"Erfolg","Fenster auf aktivem Display", 5) ; Timeout für Erfolgsmeldung = 5 Sekunden
Else ; Ansonsten Fehlermeldung ohne Timeout
MsgBox (48,"Fehler", "Fenster nicht verschoben"&@CRLF&"Errorcode = "&@error&@CRLF&@CRLf& _
" 1 = Fenster existiert nicht" &@CRLF&" 2 = kein Display gefunden"&@CRLF& _
" 3 = kein aktives Display gefunden" )
EndIf
; #FUNCTION# ====================================================================================================================
; Name ..........: MoveWindowsToActiveDisplay
; Description ...: Bewegt in einer 2 Bildschirmkonfiguration ein Fenster dessen Titel übergeben wird auf das aktive Display,
; also dort sich gerade die Maus befindet.
; Syntax ........: MoveWindowsToActiveDisplay($ParmWindowTitle[, $ParmWindowText = ""[, $ParmTimeOut [, $ParmActivateWindow]])
; Parameters ....: $ParmWindowTitle - Der Titel, das Handle oder die Klasse des Fensters das verschoben werden soll
; $ParmWindowText - Test in dem Fenster verschoben werden soll. Default ist ein leerer String.
; $ParmTimeOut - Maimaler Timeout in Sekunden bei der Suche nach dem Fenster. Default ist 3 Sekunden
; $ParmActivateWindow - Wenn Wert 1 dann aktiviere Fenster um es in den Vordergrund zu bringen.
; Defaultwert ist 1
; Return values .: 1 - Funktion erfolgreich beendet
; 0 - Ein Fehler ist aufgetreten
; Author ........: PapaPeter
; Modified ......: 4.5.2020 (mit Berücksichtigung von Bemerkungen von Bitnugger)
; Remarks .......: Errorcodes: 1 - Fenster existiert nicht
; 2 - Kein Bildschirm erkannt
; 3 - Aktiver Bildschirm konnte nicht bestimmt werden
; Tested mit AutoIt Version 3.3.14.2
; --------------------------------------------------------------------------------------------------------------
; Es gibt zwei Versionen dieser Datei. Diese Version ist mit debug Optionen in beiden Funktionen ausgestattet
; und mit deutschen Kommentaren teilweise ausführlicher dokumentiert.Es gibt auch eine UDF-Version dieser Datei
; mit englischen Kommentaren und verkürzter Hilfsfunktion CheckCoordinatesInRange.
; --------------------------------------------------------------------------------------------------------------
; Diese Version ist zur Zeit nur mit 2 Bildschirmen getestet worden, Tests mit 3 oder Mehr Bildschirmen können
; weitere Änderungen am Code bedingen.
; Related .......: Die Hilfsfunktion CheckCoordinatesInRange im selben Sourcecode wird verwendet
; Link ..........: https://autoit.de/thread/86942-autoit-script-f%C3%BCr-multi-bildschirm-betrieb/
; Example .......: MoveWindowsToActiveDisplay("Unbenannt - Editor")
; ===============================================================================================================================
Func MoveWindowsToActiveDisplay($ParmWindowTitle, $ParmWindowText="", $ParmTimeOut=5, $ParmActivateWindow=1)
; Initialisierung
Local $ReturnValue = 1 ; Wenn kein Fehler auftritt ist $ReturnValue 1
Local $Debug=1 ; Debugvariable (0 = keine Debugging-Ausgaben auf Konsole, 1 = Debugging-Ausgaben auf Konsole)
ConsoleWrite(@min&":"&@SEC&":"&@MSEC&@CRLF)
If $ParmActivateWindow=1 then ; Wenn Fenster aktiviert werden soll
If $Debug=1 Then ConsoleWrite('... Warte auf Fenster $ParmActivateWindow' & @CRLF)
WinActivate($ParmWindowTitle, $ParmWindowText) ; Benutzt die Kombination WinActivate/WinWaitActive um sicher zu stellenn das das Fenster schon existiert und sichtbar ist
WinWaitActive($ParmWindowTitle, $ParmWindowText, $ParmTimeOut) ; Wartet maximal $ParmTimeOut Sekunden ob das Fenster aktiviert werden konnte
Else ; Wenn Fenster nicht aktiviert werden soll
Local $Count=1 ; Schleife die maximal $ParmTimeOut Sekunden darauf wartet, daß das Fenster existiert
While ($Count<$ParmTimeOut And Not WinExists($ParmWindowTitle, $ParmWindowText)) ; Prüfen ob maximale Zeit überschritten oder Fenster schon existiert
Sleep(1000)
$Count+=1
If $Debug=1 Then ConsoleWrite('... Warte auf Fenster' & @CRLF)
WEnd
EndIf
; Liest Koordinaten des übergebenen Fensters aus
Local $WindowCoordinates=WinGetPos($ParmWindowTitle,$ParmWindowText) ; Koordinaten des Fenster in Array $WindowCoordinates einlesen
; Bestimmt aktuell aktives Display(/Monitor) aus der aktueller Mausposition und Funktion _WinAPI_MonitorFromPoint
Local $MousePos = _WinAPI_GetMousePos() ; Liest aktuelle Mausposition aus
Local $ActualMonitorHandle = _WinAPI_MonitorFromPoint($MousePos) ; Bestimmt Displaymonitor Handle zur aktuellen Mausposition
; Lese Infos zu den angeschlossenen Monitoren aus
Local $DisplayData = _WinAPI_EnumDisplayMonitors() ; Gibt ein Array mit den Handles der vorhandenen Displaymonitore zurück
If WinExists($ParmWindowTitle) Then ; Prüfen ob Fenster existiert -> Fenster existiert
; Suche aktives Display und verschiebe Fenster wenn notwendig
If IsArray($DisplayData) Then ; Wenn Displays erkannt wurden
Local $NumDisplays=$DisplayData[0][0] ; Bestimme Anzahl der Displays aus ersten Wert des Rückgabearrays von _WinAPI_EnumDisplayMonitors
Local $ActiveDisplay=0 ; Defaultwert für aktives Display festlegen (0 ist primäres Display)
; Lese Parameter des aktiven Fensters aus
For $DisplayCount = 1 To $NumDisplays ; Schleife über Daten aller Displays
if $DisplayData[$DisplayCount][0]= $ActualMonitorHandle Then ; Vergleiche mit Handle des aktiven Displays
Local $ActiveDisplayData = _WinAPI_GetPosFromRect($DisplayData[$DisplayCount][1]) ; wenn gleich Daten dann in Array $ActiveDisplayData einlesen
EndIf
Next
If IsArray($ActiveDisplayData) Then ; Wenn aktives Display gefunden
; Prüfen ob ein Verschieben des Fensters notwendig
if Not CheckCoordinatesInRange($WindowCoordinates, $ActiveDisplayData)=1 Then ; Verschieben notwendig
; Verschiebe Fenster wobei $ActiveDisplayData[0] der horizontale und
; $ActiveDisplayData[1] vertikaler Offset ist (kann auch negativ sein)
WinMove($ParmWindowTitle, $ParmWindowText, $WindowCoordinates[0]+ $ActiveDisplayData[0], $WindowCoordinates[1]+$ActiveDisplayData[1])
If $ParmActivateWindow=1 then ; Muß Fenster aktiviert werden?
WinActivate($ParmWindowTitle,$ParmWindowText) ; Fenster aktivieren um es in den Vordergrund zu holen
EndIf
If $Debug=1 Then ConsoleWrite('Erfolg - Fenster verschoben' & @CRLF)
EndIf
Else ; kein aktives Display gefunden
SetError(3, 0, 0) ; Kein aktives Display erkannt
$ReturnValue = 0 ; also ReturnValue = 0 und Errorcode = 3
If $Debug=1 Then ConsoleWrite('Error 3 = Kein aktives Display erkannt' & @CRLF)
EndIf
Else ; Wenn kein Display erkannt wurde
SetError(2, 0, 0) ; Kein Display erkannt
$ReturnValue = 0 ; also ReturnValue = 0 und Errorcode = 2
If $Debug=1 Then ConsoleWrite('Error 2 = Kein Display erkannt' & @CRLF)
EndIf
Else ; Fenster existiert nicht
SetError(1, 0, 0) ; Fenster nicht gefunden
$ReturnValue = 0 ; also ReturnValue = 0 und Errorcode = 1
If $Debug=1 Then ConsoleWrite('Error 1 = Fenster nicht gefunden' & @CRLF)
EndIf
Return $ReturnValue
EndFunc ; ==> MoveToActiveDisplay()
; #FUNCTION# ====================================================================================================================
; Name ..........: CheckCoordinatesInRange
; Description ...: Überprüft ob Koordinaten in $Parm_CheckCoordinatesArray in der Fläche liegen die $Parm_DisplayArray definiert
; Syntax ........: CheckCoordinatesInRange($Parm_CheckCoordinatesArray, $Parm_DisplayArray)
; Parameters ....: $Parm_CheckCoordinatesArray - Array mit miondestens 2 Einträgen für die X & Y Koordinaten.
; $Parm_DisplayArray - Flächen-Array mit mindestens 4 Einträgen für X, Y, Breite & Höhe.
; $Parm_CheckCoordinatesArray[0] = Wert der X-Koordinate die überprüft wird
; $Parm_CheckCoordinatesArray[1] = Wert der Y-Koordinate die überprüft wird
; $Parm_DisplayArray[0] = Wert der X-Koordinate der linken oberen Ecke der Fläche
; $Parm_DisplayArray[1] = Wert der Y-Koordinate der linken oberen Ecke der Fläche
; $Parm_DisplayArray[2] = Wert der Breite der Fläche
; $Parm_DisplayArray[3] = Wert der Höhe der Fläche
; Return values .: 1 - Koordinaten liegen in Fläche
; 0 - Koordinaten liegen in Fläche
; Author ........: PapaPeter
; Modified ......: 4.5.2020 by PapaPeter
; Remarks .......: Errorcodes: 1 - $Parm_CheckCoordinatesArray ist kein Array
; 2 - $Parm_DisplayArray ist kein Array
; Getestet unter AutoIt Version 3.3.14.2
; ---------------------------------------------------------------------------------------------------------------
; Dies ist leichter lesbare Variante der Funktion, eine analoge kürze Form von BugFix findet sich in der UDF
; Version dieser Datei. Funktionell sind die beiden Varianten gleichwertig. Diese Version ist vermutlich etwas
; langsamer.
; Related .......: Wird von MoveWindowsToActiveDisplay benutzt
; Link ..........: https://autoit.de/thread/86942-autoit-script-f%C3%BCr-multi-bildschirm-betrieb/
; Example .......: kein Beispiel vorhanden
; ===============================================================================================================================
Func CheckCoordinatesInRange($Parm_CheckCoordinatesArray, $Parm_DisplayArray)
Local $ReturnValue=0 ; Initialisierung ReturnValue
Local $Debug=0 ; Debugvariable (0 = keine Debugging-Ausgaben auf Konsole, 1 = Debugging-Ausgaben auf Konsole)
If Not IsArray($Parm_CheckCoordinatesArray) Then ; Überprüfe ob erster Parameter ein Array ist
If $Debug=1 Then ConsoleWrite('Error 1' & @CRLF)
SetError(1, 0, -1)
$ReturnValue=-1
ElseIf Not IsArray($Parm_DisplayArray) Then ; Überprüfe ob zweiter Parameter ein Array ist
If $Debug=1 Then ConsoleWrite('Error 2' & @CRLF)
$ReturnValue=-1
Else ; Ansonsten weitermachen mit den Übergabeparametern
If $Debug=1 Then ConsoleWrite('No Error' & @CRLF)
; Überpüfe die X-Koordinate (0)
if ($Parm_DisplayArray[0]<= $Parm_CheckCoordinatesArray[0]) And (($Parm_CheckCoordinatesArray[0] < $Parm_DisplayArray[0]+$Parm_DisplayArray[2])) Then
If $Debug=1 Then ConsoleWrite (" X: "&$Parm_DisplayArray[0]&"<=" & $Parm_CheckCoordinatesArray[0] & "<" & $Parm_DisplayArray[0]+$Parm_DisplayArray[2] & " -> X in Range"& @CRLF)
; X-Koordinate liegt im Bereich der Fläche
; Überpüfe die Y-Koordinate (1)
If ($Parm_DisplayArray[1]<= $Parm_CheckCoordinatesArray[1]) And ($Parm_CheckCoordinatesArray[1] < ($Parm_DisplayArray[1]+$Parm_DisplayArray[3])) Then
; X-und Y-Koordinaten liegen im Bereich der Fläche
If $Debug=1 Then ConsoleWrite (" Y: "&$Parm_DisplayArray[1]&"<=" & $Parm_CheckCoordinatesArray[1] & "<" & $Parm_DisplayArray[1]+$Parm_DisplayArray[3] & " -> Y in Range"& @CRLF)
$ReturnValue=1
Else ; Y-Koordinate liegt nicht im Bereich der Fläche
If $Debug=1 Then ConsoleWrite("Y-Coordinate not in Range: "& $Parm_CheckCoordinatesArray[1]&@crlf)
$ReturnValue=0
EndIf
Else ; X-Koordinate liegt nicht im Bereich der Fläche
If $Debug=1 Then ConsoleWrite("X-Coordinate not in Range: "& $Parm_CheckCoordinatesArray[0]&@crlf)
$ReturnValue=0
EndIf
EndIf
Return $ReturnValue
EndFunc ; ==> CheckCoordinatesInRange()Hallo zusammen,
vielleicht habt Ihr auch schon mal festgestellt das AutoIt neue Fenster immer auf dem Hauptbildschirm des Rechners aufmacht. Also häufig auf dem Bildschirm des Notebooks - was leider nicht immer ideal ist. In AutoIt selber gibt es dazu keine Funktion, die das Verhalten ändert oder ein vorhandenes Fenster auf den aktiven Bildschirm verschiebt.
Ich habe jetzt eine Funktion geschrieben die bei Aufruf genau Letzteres macht. Ein geöffnetes Fenster wird also auf den Bildschirm verschoben, auf dem sich gerade die Maus befindet. Die relative Position des Fenster auf dem jeweiligen Bildschirm wird beibehalten.
Version 1.1.2 (deutsch):
Version 1.1.1 (englisch dokumentierte UDF Variante):
Hallo zusammen,
bisher habe ich eine Filecopy Funktion vermisst, die wie das Standard FileCopy funktioniert, aber nicht bei Konflikten mit einer vorhandenen Zieldatei scheitert. Insbesondere sollte beim Kopieren - analog zum Explorer - die Option bestehen einfach die neue Zieldatei um ein "... (n)" vor der Extension zu ergänzen.
Deshalb stelle ich hier meine private UDF zur Diskussion.
#include-once
#include <File.au3>
#include <Array.au3>
; =========================================================================================================
; _SaveFileCopy($Parm_Src, $Parm_Dest, $Parm_Flag=0)
;
; Funktion: Kopiert eine oder mehrere Datei(en).
;
; $Parm_Src: Die Quelldatei(en) - Wildcards werden unterstützt.
;
; $Parm_Dest: Das Zielverzeichnis der zu kopierenden Datei(en).
;
; $Parm_Flag [optional]: Dieses Flag bestimmt, ob Dateien überschrieben werden, falls sie schon bestehen.
; $Parm_Flag kann eine Kombination der folgenden sein:
; 0 = (Standard) bestehende Dateien nicht überschreiben
; 1 = Überschreiben bestehender Dateien
; 8 = Erstellt die Zielverzeichnisstruktur, falls diese nicht besteht.
;
; Bemerkung: Wenn Flag eine gerade Zahl ist und die Zieldatei schon existiert, wird der Zielname um ein
; ' (n)' vor der Dateierweiterung ergänzt (n = Zahl ab 2, wobei Zielname noch nicht existiert)
; analog zum Verhalten des Windows Explorers mit der Option beide Dateien behalten.
;
; Rückgabe: Erfolg - Gibt 1 zurück.
; Fehlerfall - Gibt 0 zurück.
;
; Beispiel: Der kombinierte Flagwert '9' (1 + 8) überschreibt das Zielverzeichnis und prüft vorher, ob
; die Zielverzeichnisstruktur besteht und erstellt sie gegebenenfalls automatisch.
; =========================================================================================================
Func _SaveFileCopy($Parm_Src, $Parm_Dest, $Parm_Flag=0)
Local $Loc_Searchhandle, $Loc_SrcFilename
Local $Loc_SrcDrive, $Loc_SrcDir, $Loc_SrcName, $Loc_SrcExt
Local $Loc_RV=1 ; Standardrückgabe = ok, ein einzelner Fehler setzt Rückgabe auf 0
If BitAND($Parm_Flag, 1) = 1 then ; Zieldateien überschrieben?
; Wenn ja, dann Standard FileCopy() Funktion verwenden
FileCopy($Parm_Src, $Parm_Dest, $Parm_Flag)
Else ; Zieldateien nicht überschrieben
If ((StringInStr($Parm_Src,"*")>0) Or (StringInStr($Parm_Src,"?")>0)) Then
; Wildcard benutzt
; Dann alle möglichen Quelldateien bestimmen
$Loc_Searchhandle = FileFindFirstFile($Parm_Src)
; Prüfen, ob die Suche erfolgreich war
If ($Loc_Searchhandle = -1) Then ; Keine Datei entspricht Suchmuster in $Parm_Src
Return 0
else ; Mindestens eine Quelldatei entspricht Suchmuster in $Parm_Src
While 1 ; Endlosschleife
; ; Suche Namen einer passenden Quelldatei
$Loc_SrcFilename = FileFindNextFile($Loc_Searchhandle)
If @error Then ; bis alle Quelldateien überprüft
ExitLoop
else ; ansonsten kopiere Quelldatei
; FileFindNextFile findet nur den Dateinamen ohne Pfad
; deshalb ergänzen um Quelllaufwerk und Quellpfad
_PathSplit(_CompletePath($Parm_Src), $Loc_SrcDrive, $Loc_SrcDir, $Loc_SrcName, $Loc_SrcExt)
If (_SaveCopySingleFile($Loc_SrcDrive&$Loc_SrcDir&$Loc_SrcFilename, $Parm_Dest, $Parm_Flag)=0) then
$Loc_RV=0 ; und setzte Rückgabewert auf 0 ( = Fehler)
; wenn mindestens ein Fehler aufgetreten
EndIf
EndIf
WEnd ; Ende Schleife
FileClose($Loc_Searchhandle) ; Am Ende Handle für Suche wieder schliessen
Return ($Loc_RV)
EndIf
Else ; Keine Wildcards
Return (_SaveCopySingleFile($Parm_Src, $Parm_Dest, $Parm_Flag))
EndIf
EndIf ; Ende Zieldateien nicht überschrieben
EndFunc
; =========================================================================================================
; _SaveCopySingleFile($Parm_Src, $Parm_Dest, $Parm_Flag=0)
;
; Funktion: Kopiert eine einzelne Datei.
;
; $Parm_Src: Die Quelldatei (relativ oder vollem Pfad) - Wildcards werden nicht unterstützt.
;
; $Parm_Dest: Das Zielverzeichnis (mit abschliessenden Backslash) oder die Zieldatei.
;
; $Parm_Flag [optional]: Dieses Flag bestimmt, ob die Zieldatei überschrieben wird, falls sie schon besteht.
; $Parm_Flag kann eine Kombination der folgenden sein:
; 0 = (Standard) bestehende Dateie nicht überschreiben
; 1 = Überschreiben der bestehenden Datei
; 8 = Erstellt die Zielverzeichnisstruktur, falls diese nicht besteht.
;
; Bemerkung: Wenn Flag eine gerade Zahl ist und die Zieldatei schon existiert, wird der Zielname um ein
; ' (n)' vor der Dateierweiterung ergänzt (n = Zahl ab 2, wobei Zielname noch nicht existiert)
; analog zum Verhalten des Windows Explorers mit der Option 'beide Dateien behalten'.
;
; Rückgabe: Erfolg - Gibt 1 zurück.
; Fehlerfall - Gibt 0 zurück.
;
; Beispiel: Der kombinierte Flagwert '9' (1 + 8) überschreibt das Zielverzeichnis und prüft vorher, ob
; die Zielverzeichnisstruktur besteht und erstellt sie gegebenenfalls automatisch.
; =========================================================================================================
Func _SaveCopySingleFile($Parm_Src, $Parm_Dest, $Parm_Flag=0)
Local $Loc_FullDestFileName, $Loc_Count, $Loc_NewDest, $Loc_DestArray, $Loc_SrcArray
Local $Loc_DestDrive, $Loc_DestDir, $Loc_DestName, $Loc_DestExt
Local $Loc_SrcDrive, $Loc_SrcDir, $Loc_SrcName, $Loc_SrcExt
If BitAND($Parm_Flag, 1) = 1 then ; Zieldateien überschrieben?
; Wenn ja, dann Standard FileCopy() Funktion verwenden
FileCopy($Parm_Src, $Parm_Dest, $Parm_Flag)
Else ; Zieldatei nicht überschreiben
If Not ((StringInStr($Parm_Src,"*")>0) Or (StringInStr($Parm_Src,"?")>0)) Then
; No Wildcards
If StringRight(StringStripWS($Parm_Dest,2),1)="\" Then ; Ziel ist ein Verzeichnis
; dann Dateiname und Dateiextension für Zieldatei aus Quelle bestimmen
_PathSplit(_CompletePath($Parm_Dest), $Loc_DestDrive, $Loc_DestDir, $Loc_DestName, $Loc_DestExt)
_PathSplit($Parm_Src, $Loc_SrcDrive, $Loc_SrcDir, $Loc_SrcName, $Loc_SrcExt)
; Absoluter Zieldateiname ohne Extenstion = Ziellaufwerk + Zielverzeichnis + Quelldateiname
$Loc_FullDestFileName = $Loc_DestDrive & $Loc_DestDir & $Loc_SrcName
; Zieldateiextension = Quellextension
$Loc_DestExt=$Loc_SrcExt
Else ; Ziel ist eine Datei
; dann Dateiname und Dateiextension für Zieldatei aus Ziel bestimmen
$Loc_DestArray = _PathSplit(_CompletePath($Parm_Dest), $Loc_DestDrive, $Loc_DestDir, $Loc_DestName, $Loc_DestExt)
; Absoluter Zieldateiname ohne Extenstion = Ziellaufwerk + Zielverzeichnis + Zieldateiname
$Loc_FullDestFileName=$Loc_DestDrive & $Loc_DestDir & $Loc_DestName
EndIf ; Ende Ziel ist eine Datei
$Loc_Count=1 ; Analog zu Windows beim 1. Versuch 'Dateiname',
$Loc_NewDest=$Loc_FullDestFileName ; dann 'Dateiname (2)', ... usw. in $Loc_NewDest
While FileExists($Loc_NewDest&$Loc_DestExt) ; Durchlaufe Schleife bis Dateiname nicht existiert
$Loc_Count+=1 ; Zähler um 1 erhöhen
$Loc_NewDest = $Loc_FullDestFileName & " ("&$Loc_Count&")"
WEnd ; Ende Schleife
Return (FileCopy ($Parm_Src, $Loc_NewDest&$Loc_DestExt, $Parm_Flag))
Else ; Wildcards sind nicht erlaubt - also Rückgabewert 0
Return 0
EndIf ; Ende Wildcards
EndIf ; Ende Zieldatei nicht überschreiben
EndFunc
; =========================================================================================================
; Func _CompletePath($Parm_Path)
;
; Funktion: Ergänzt - falls notwendig - den angegebenen relativen Pfad zu einem absoluten Pfad
;
; $Parm_Path: Übergebener absoluter oder relativer Pfad
;
; Rückgabe: Zugehöriger absoluter Pfad
;
; =========================================================================================================
Func _CompletePath($Parm_Path)
If (StringLeft($Parm_Path,1)=".") Then ; Bei relativen Pfaden mit die mit '.'
; oder '..' beginnen
$Parm_Path=_PathFull($Parm_Path) ; Absoluter Pfad relativ zu Arbeitsverzeichnis
; berechnen
ElseIf not (StringInStr($Parm_Path,":")>0) then ; Bei Pfaden etwas ohne Laufwerkbuchstaben
if Not (StringLeft($Parm_Path,1)="\") then ; Pfade ohne beginnendes Backslash
$Parm_Path=_PathFull($Parm_Path) ; Absoluter Pfad relativ zu Arbeitsverzeichnis
; berechnen
Elseif Not (StringLeft($Parm_Path,2)="\\") then ; oder Pfade die EINEM Backslash beginnen
; (also keine UNC-Pfade)
$Parm_Path=StringLeft(@WorkingDir,2)&$Parm_Path ; Pfad um Laufwerk des Arbeitsverzeichnisses
; ergänzen
EndIf
EndIf ; Ende Pfad ohne Laufwerkbuchstaben
; (Bei UNC- oder absoluten Pfaden mit Laufwerksbuchstaben - Eingabe unverändert zurückgeben)
Return $Parm_Path
EndFuncDer Aufruf erfolgt mit _SaveFileCopy() mit exakt den gleichen Parametern wie das Standard Filecopy.
Die Routine berücksichtigt auch Jokersysmbole beim Dateinamen und wirkt wenn Flag=1 oder 9 als Wrapper für die normale FileCopy() Funktion. Ansonsten scheitert die Funktion nicht, wenn die Zieldatei schon vorhanden ist, sondern kopiert statt dessen nach "Dateiname (n).Extension" (n=2 oder größer falls eine Datei mit diesem Namen schon existiert).
Die Hilfsfunktion _SaveCopySingleFile() kopiert eine eine einzelne Datei und unterstützt keine Wildcards. Die Funktion wird für den Kopiervorgang einer einzelnen Datei von _SaveFileCopy() aufgerufen.
Die Hilfsfunktion _CompletePath() ist ein Wrapper für _PathFull() aus der File.au3 UDF. Im Gegensatz zu _PathFull() muß hier der übergegeben Parameter kein relativer Pfad sein. Man muß keine Fallunterscheidungen beim Parameter mehr machen, sondern man erhält von der Funktion immer einen absolut adressierten Pfad.
Übergebene Pfade die von der Root adressieren - aber ohne Laufwerksbuchstaben - werden um den Laufwerkbuchstaben des WorkingDirectories ergänzt. Übergebene absolute Pfade mit Laufwerkbuchstaben oder in UNC-Notation werden nicht ergänzt.
Peter
Tweaky,
danke für die Info bezüglich zum Status des Übersetzungssystem.
Mir schon klar das Ihr die api aus den Übersetzungen des Forum generieren wollt. Ich habe die Übersetzung auch primär für den Eigenbedarf gemacht.
Noch eine Anregung zur neuen Version: Macht es Sinn auch Ergänzungen wie die "pcre pattern man page" mit zu übersetzen und direkt in der deutschen Hilfe zu verlinken (statt der englischen Seite auf autoitscript.com)? Regular Expressions sind wirklich mächtig, aber nicht so leicht zu verstehen - deshalb würde es für mich Sinn machen eine deutsche Version zu verlinken.
PapaPeter
Hallo zusammen,
ich habe die deutsche au3.api v.3.3.6.1 mal mithilfe der englischen au3.api v3.3.8.0 auf das akuelle Niveau gebracht. Sie könnte im Zusammenhang mit der Übersetzung der 3.3.8.1 Hilfe als Basis für ein offizielles Release dienen. By the way - wann ist die nächste Übersetzungsrunde geplant.
Peter
Hier als Starthilfe eine eingedeutschte au3.api für Scite auf Versionslevel 3.3.8.0 (ich weiß aktuell wäre 3.3.8.1 aber noch liegt auch keine englische Version vor)
PapaPeter
Hallo Gemeinde,
gibt es im Bereich Autoit-Sourcecode -> Flowchart noch neue Entwicklungen - mit Google habe ich nichts Sinnvolles gefunden?
Danke Peter