Beiträge von KloMeister

Zu Punkt 1.
Du musst natürlich auch angeben welche Position aus der Liste ausgelesen werden soll. "$iCode", ist glaube ich in dem Code für etwas anderes verantwortlich nicht für die Position.

Ich habe dir mal eine Funktion zur Erkennung des angewählten Beitrags eingebaut.

Punkt 2.

Ja du kannst eine .txt Datei erstellen und die mit einem Array über FileReadLine einlesen und dabei deiner Listbox übergeben.

Also ich habe mal 10.000 Einträge über "GUICtrlSetData" eingefügt, geht ohne Probleme, dauert nur dementsprechend:

#include <GUIConstantsEx.au3>

Example()

Func Example()
GUICreate("My GUI") ; will create a dialog box that when displayed is centered
local $i
local $Items

for $i = 0 To 10000
$items = $items & $i & "|"
next

GUICtrlCreateCombo("", 10, 10)
GUICtrlSetData(-1, $items)
GUISetState(@SW_SHOW)

While 1
Switch GUIGetMsg()
Case $GUI_EVENT_CLOSE
ExitLoop
EndSwitch
WEnd

Damit die Zeile der Einträge nicht unendlich lang wird, kannst du wie ich in meinem Beispiel auch gemacht habe, mit Hilfe einer Schleife, hinter jeden Eintrag ein "|" einfügen und das Ergebnis in einer Variable speichern.

Dann brauchst du nurnoch diese Variable der GUICtrlSetData Funktion übermitteln.
Das macht die Sache zumindest übersichtlicher, als unendlich lange Zeilen zu erzeugen.

#include <GUIConstantsEx.au3>
#include <WinAPI.au3>

Global $aInput[5]

$hGUI = GUICreate("Test", 500, 500)

$aInput[0] = GUICtrlCreateInput("Some text 1", 10, 10, 200, 20)
$aInput[1] = GUICtrlCreateInput("Some text 2", 10, 40, 200, 20)
$aInput[2] = GUICtrlCreateInput("Some text 3", 10, 70, 200, 20)
$aInput[3] = GUICtrlCreateInput("Some text 4", 10, 100, 200, 20)
$aInput[4] = GUICtrlCreateInput("Some text 5", 10, 130, 200, 20)

local $StatusInput[5]

GUISetState()
While 1
Switch GUIGetMsg()
Case $GUI_EVENT_CLOSE
Exit
Case $GUI_EVENT_PRIMARYUP
For $i = 0 To UBound($aInput) - 1
If _WinAPI_GetFocus() = GUICtrlGetHandle($aInput[$i]) Then
select
case $StatusInput[$i] = 0
$StatusInput[$i] = 1
GUICtrlSetData($aInput[$i], "")
endselect
ExitLoop
EndIf
Next
EndSwitch
WEnd

Ich weiß nicht genau was du vor hast. Aber reicht es nicht mit "ProcessExists" zu prüfen, ob der Prozess existiert, falls nein dann starten, ansonsten eben nichts tun... oder besser: das Programm in den Vordergrund holen.

Ich glaube mit dem standard Control geht das nicht. Vielleicht gibt es aber bereits fertige Alternativen, die schon jemand anders programmiert hat..?. Dann musst du zumindest selber kein neues Control schreiben.

@Alina
Es gibt noch eine etwas leichtere bzw. übersichtlichere Variante um das zu erreichen, was du mit StringSplit erreicht hast:

$an_zeit = stringReplace($an_zeit, ":", "")
$end_zeit = stringReplace($end_zeit,":", "")

Macht die Sache zumindest bei der Abfrage übersichtlicher und spart Programmcode.

Achja und wenn es nicht Tagmodus ist, dann muss es doch Nachtmodus sein? - also wieso ein ElseIf mit einer weiteren Prüfung?

Tut da nicht auch ein einfaches:

Else
tagmodus()

?

https://www.autoitscript.com/autoit3/docs/l…dit_SetText.htm

#include <GuiEdit.au3> ; Benötigter Include - muss nach ganz oben im Code

_GUICtrlEdit_SetText ($hWnd, $sText) ; Befehl im Rohformat

$X1= MouseGetPos()
_GUICtrlEdit_SetText ($X_, $X1[0]) ; Befehl auf deine Funktion zugeschnitten

Da ist einiges "komisch".

Erstmal verwirren mich die ganzen doppelten Schleifen und Abfragen.
"While WEnd" und "Do...Until" und dann auch noch eine IF Abfrage? Das lässt sich vermutlich auch mit einer einzigen Schleife mit integrierter Abfrage lösen

Dann versuchst du Variablen zu vergleichen die einen Zahlenwert mit Doppelpunkt enthalten. Ich glaube, dass AutoIt in dem Fall nicht richtig mit der Formatierung klar kommt, da es sich ja nicht direkt um eine mathematische Zahl handelt.

Du musst entweder Stunde und Minute nacheinander vergleichen, oder du musst die Zeit komplett in Minuten oder Stunden umrechnen.

Ich vermute, dass liegt daran, dass die Konsole nicht ansprechbar ist, solange diese etwas ausführt.

Du hast dann wohl erst wieder Zugriff, wenn die Schleife im Updateprozess unterbrochen wird.

Eine Lösung direkt habe ich aber auch nicht. Wird wohl nicht ganz einfach werden. Ich vermute, man muss dafür mit Speicher-Hooks arbeiten, um einen Break im CMD auszulösen und damit die Konsole auslesefähig zu machen.

ich habe das ganze mal gebaut mit dem automatischen Child Enum. Lustigerweise reagiert die Listview, die mit "_GUICtrlListView_Create" wurde, wiedermal nicht .

Interessant ist auch, dass die Buttons sich zwar in ihrer Position ändern, aber nicht in ihrer Größe... Andere Steuerelemente funktionieren einwandfrei.

Hier trotzdem der Code, da er ja mit normalen Steuerelementen teils funktioniert (Hilft dir zwar nicht, aber Anderen eventuell):

Es reicht nun, wenn die beiden unteren Funktionen im Code vorhanden sind.

Mit der Funktion "Resize_All($FensterGui)" lassen sich nun automatisch alle Steuerelemente die sich auf der Form befinden ansprechen und der Fenstergröße entsprechend resizen. Diese Funktion sollte idealerweise dann mit dem Resize Event ausgelöst werden.

Aber im Grunde haben wir wieder das selbe, wie AutoIt schon standardmäßig kann. Kleiner Vorteil daran ist vielleicht, das man diese Funktion auch an fremden Fenstern nutzen könnte.

Das Problem ist, die Funktion wird von AutoIt bereit gestellt, so das du im Prinzip keinen Einfluss darauf hast. Die Frage ist, warum Controls die mit einer UDF erstellt wurden, ignoriert werden...

Mit mäßigem Aufwand, kann man eine eigene Auto-Resize Funktion erstellen.

Mit der Funktion "_WinAPI_EnumChildWindows", bekommt man alle Handle's der Steuerelemente, die auf der Form sind.
Dann ließt du einfach die Array-Größe aus und machst ne For Next Schleife, in welcher die Größe und Position der Steuerelemente mit Hilfe der Handle's ausgelesen werden und auf die aktuelle Formgröße umberechnet werden. Die Funktion führst du immer dann aus, wenn du ein "$GUI_EVENT_RESIZED" bekommst.

Das gute daran ist, diese Funktion ist universell für jede Form nutzbar, wenn man sie einmal hat, dann hat man sie.

Vielleicht gibt es ja auch bereits jemanden, der diese Funktion geschrieben hat?
Vermutlich eher weniger, da man im Normalfall ja die integrierte Resize Funktion nutzen kann...

Edit:
Ja es gibt jemanden, der zumindest schon 80% erledigt hat:
Siehe hier:
https://autoit.de/index.php/Thre…istView-Create/

Wenn du das mit dem ChildEnum kombinierst, hast du eine Funktion in der Tasche, die du auch in Zukunft ohne zusätzlichen Code, auf jeder Form nutzen kannst.

Hab mein Post nochmal angepasst, weil ich der Meinung bin, dass ich doch nicht ganz verstanden habe, was du genau vor hast.

Du willst vermutlich in deine Funktion zurückspringen, wenn das Fenster für eine bestimmte Zeit inaktiv war?

Dann versuch es mal so wie hier, dass du den "Zustand" in einer Variable speicherst und abfragst.

Hier mal 2 mögliche Varianten um den Fenster-Zustand abzufragen.

local $Status = WinWaitActive("[CLASS:Notepad]", "", 5)
Select
Case $Status = 0
msgbox(0,"","Editor war 5 Sek inaktiv")
Case else
msgbox(0,"", "Editor ist aktiv")
Endselect

Do
local $Status = WinWaitActive("[CLASS:Notepad]", "", 5)
until $Status = not 0 ; Entfernst du das not, dann geht es nur weiter wenn das Fenster 5 Sek inaktiv ist

msgbox(0,"","Hier gehts nur weiter wenn das Fenster aktiv ist")

Was ich noch einbauen würde, um das ganze professioneller, dynamischer und universeller zu gestalten:

Eine Datei (.txt) die eingelesen wird und deinem Programm mitteilt, welche Buttons existieren und welches Icon mit auszuführendem Programm dazu gehört.

Beispiel:
Eine Datei wird einglesen mit z.B. folgendem Aufbau:

---Bereich Blau---
C:\Windows\System32\mspaint.exe | Icon1.jpg
C:\Windows\System32\calc.exe | Icon2.jpg
---Bereich Gruen---
C:\Windows\System32\cmd.exe | Icon1.jpg
C:\Windows\System32\msinfo32.exe | Icon4.jpg
C:\Windows\System32\regedt32.exe | Icon3.jpg
C:\Windows\System32\mspaint.exe | Icon5.jpg
---Bereich Gelb---
....

Je nach entsprechender Berechnung, könnte man z.B. sagen bis zu 9 Schaltflächen passen auf einen Farbbereich.
Die Datei wird dann reihenweise eineglesen, mithilfe der Bildschirmauflösung wird die entsprechende Größe und der Abstand der Schaltflächen berechnet. Die Schaltflächen bekommen dann die in der Datei festgelegten Icon-Bilder mit dem dazugehörigen auszuführendem Program-Pfad.

Das gute an der Sache, man kann auch ohne AutoIt, die Schaltflächen jederzeit anpassen.

Grobe Vorangehensweise für den Code:

Datei Zeilenweise einlesen...
Mit Case abfragen welcher Bereich (Rot, Blau Grün..).
Mit Split "|" den String teilen und die Pfade zuweisen.
Den Schaltflächen Index mithilfe eines Arrays zuweisen für GUI Msg
Und die entsprechenden Positionen für die Schaltflächen-Position durch Bildschirmauflösung und entsprechender Additionswerte berechnen und festlegen (Mit ein paar Resets und Abfragen).

Theoretisch, wenn das Projekt universell bleiben soll und beliebige Daten importieren können soll, müsste man noch zwei weitere Schritte einbauen.

1. prüfen wie Groß die maximalen Parameter von X und Y der Grafik sind und daran die Form anpassen (gegebenenfalls sogar die Grafik kleiner zeichnen - die Koordinaten durch Faktor "X" teilen)

2. Mithilfe des größten Parameter von Y der geladenen Koordinaten, den Punkt der Spiegelachse festlegen.

Versuchs mal so:

#include <GDIPlus.au3>
#include <GUIConstantsEx.au3>
#include <Array.au3>
#include <File.au3>
#include <GDIPlus.au3>
#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>
#include <WindowsConstants.au3>
Global $g_hGUI, $g_hGraphics, $g_hBmp_Buffer, $g_hGfx_Buffer, $g_hImage
Global $g_iMouseX, $g_iMouseY
Local $hGUI, $hGraphic, $hPen,$aArray,$g_hBmp_Buffer,$g_hGraphics
Local $g_iMouseX,$g_iMouseY,$lParam

$hGUI = GUICreate("GDI+", 1000, 300)
GUISetState(@SW_SHOW)

_GDIPlus_Startup()
$hGraphic = _GDIPlus_GraphicsCreateFromHWND($hGUI)
If Not _FileReadToArray("a2.din", $aArray, 0) Then
MsgBox($MB_SYSTEMMODAL, "", "There was an error reading the file. @error: " & @error) ; An error occurred reading the current script file.
EndIf

For $x = 1 To UBound($aArray)-1
If StringInStr($aArray[$x],"G00 X") Then
;~ _GDIPlus_GraphicsDrawLine($hGraphic, StringTrimLeft($spl[2],1), StringTrimLeft($spl[3],1), StringTrimLeft($spl2[2],1), StringTrimLeft($spl2[3],1), $hPen)
ElseIf StringInStr($aArray[$x],"G01 X") Then
$spl = StringSplit($aArray[$x]," ")
$spl2 = StringSplit($aArray[$x-1]," ")
If $spl[0] >= 3 and $spl2[0] >= 3 Then
IF StringTrimLeft($spl2[2],1) = "-0.1" Then
Else
_GDIPlus_GraphicsDrawLine($hGraphic, StringTrimLeft($spl[2],1), 300 -StringTrimLeft($spl[3],1), StringTrimLeft($spl2[2],1), 300 -StringTrimLeft($spl2[3],1), $hPen)
EndIf
EndIf
EndIf
Next

Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE

; Clean up resources
_GDIPlus_PenDispose($hPen)
_GDIPlus_GraphicsDispose($hGraphic)
_GDIPlus_Shutdown()

Was vermutlich einfacher und sinnvoller wäre, wäre folgender Variante:

Du entfernst das Intel Extreme Tuning Utility aus dem Autostart.

Dafür baust du ein AutoIt Program, welches im Autostart ist. Dieses AutoIt-Tool startet dann einfach das "Intel Extreme Tuning Utilty" im Tray-Modus und beendet sich danach selber.

Fertig.

Wäre meines Erachtens sinnvoller und einfacher umzusetzen.

Kann natürlich auch sein, das ich da irgendwelche Probleme nicht berücksichtigt habe.

Es geht ja auch darum, dass du etwas dabei lernst und selber etwas zu deinem Programm beiträgst.

Wichtig ist zu wissen, wo genau du nicht weiterkommst und wie erfahren du im allgemeinen mit AutoIt bist.

Darauf aufbauend kann man dann weiterarbeiten / helfen.

Hier mal ein grobes Beispiel zum splitten:

#include <StringConstants.au3>
#include <MsgBoxConstants.au3>
#include <Array.au3>

Example()

Func Example()
local $RegPfad
local $Datentyp

Local $sText = "Register64 'HKey_Local_Machine' 'SYSTEM\CurrentControlSet\Control\Class\{4D36E968-E325-11CE-BFC1-08002BE10318}\0002' 'InfPath' 'oem12.inf' 'REG_SZ'" ;Einzulesene Zeile - Hier einfach Schleife, die Zeilenweise bis zum Ende deiner Datei einließt.
Local $aArray = StringSplit($sText, "'")

$Regpfad = $aArray[2] & "\" & $aArray[4]

For $i = 5 To $aArray[0]

Select
Case $aArray[$i] = "REG_SZ"
$Datentyp = "REG_SZ"

Case $aArray[$i] = "REG_DWORD"
$Datentyp = "REG_DWORD"

Case $aArray[$i] = "REG_MULTI_SZ"
$Datentyp = "REG_MULTI_SZ"

Case $aArray[$i] = "REG_BINARY"
$Datentyp = "REG_BINARY"

Case $aArray[$i] = " "

Case $aArray[$i] = ""

Case Else
msgbox (0,"Variablen",$aArray[$i])

EndSelect
Next

msgbox(0,"Reg_Pfad", $Regpfad )
msgbox(0,"Daten_Typ", $Datentyp )
EndFunc

Zum Schlüssel gehörige Values, werden noch nicht getrennt erkannt.

Das kann man z.B. folgender maßen machen:

Du ließt deine Datei Zeilenweise ein. Darauffolgend suchst du mit StringInStr und / oder "StringSplit" die entsprechend für den Registry-Eintrag notwendigen Textanteile heraus. Dazu bedarf es etwas Logik (Also ein paar Abfragen). Die jeweiligen Text-Anteile weißt du einer Variable zu.

Danach fügst und formatierst du deinen String entsprechend wie es für die Reg-Datei notwendig ist zusammen

Der Aufbau ist so:

Windows Registry Editor Version 5.00
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\MAIN\FeatureControl\FEATURE_MAXCONNECTIONSPERSERVER 
"iexplore.exe "=dword:0000000a
"XXXX"=dword:0000000a
...

Das ganze speicherst du dann in einer .reg Datei ab.

Als weitere Option wäre da noch die Möglichkeit, die Win-API Funktion "CopyFileEx" zu nutzen. Diese bietet die Möglichkeit den Kopierfortschritt anzeigen zu lassen. Mit Google (Suche nach: "CopyfileEx AutoIt") findet man da auch ein paar Beispiel-Ansätze.

Unteranderem gibt es die UDF "_MultiFileCopy", die bietet bereits eine einfache Lösung.