@Make Implementation und trigonometrische Funktionen. ![]()
Also, ich...
- Mehrere Projekte beenden
- Mehr Zeit für Freundin und Freunde nehmen
- Führerschein machen (mit 16 1/2)
Das war's im Wesentlichen. ![]()
Gruß
@Make Implementation und trigonometrische Funktionen. ![]()
Also, ich...
Das war's im Wesentlichen. ![]()
Gruß
Ich bin zwar noch nicht so lange dabei, aber lang genug, um die letzten... *zähl*... 5 Versionen (Stable) benutzt zu haben (3.3.6.1, 3.3.8.0, 3.3.8.1, 3.3.10.0 und natürlich 3.3.10.1 [wenn ich mich nicht irre?]).
Allerdings ist mir aufgefallen, in welche Richtung AutoIt geht. Und damit meine ich nicht die neuen Features, die finde ich an sich klasse, denn: Stillstand ist Rückstand.
Allerdings, seit ich AutoIt kenne, wird die Community immer weniger beachtet. Mit trancexx ist auch die letzte Möglichkeit, durch die Community Dinge einfließen zu lassen, gestorben... Denn Jonathan Bennett selber geht auf uns oder auf unsere englischsprachigen Kollegen ja nicht ein. Und da nur noch er übrig ist, ist der Weg von AutoIt wahrscheinlich klar.
Es sei denn, es tritt ein neuer Dev im Coding-Bereich zum Team dazu...
Ansonsten wird dieser Bug-Wahnsinn wahrscheinlich so weiter gehen.
Sonst gäbe es halt noch die Möglichkeit, mit Alternativ-Projekten (was ja auch mal eine Grundidee von minx' Perseus war) einen AutoIt-Compiler zu basteln... Oder auf Grundlage der alten Opensource-Versionen selber weiter zu machen.
... Aber leider wissen wir (aus Erfahrung), dass solche Projekte fast von Grund auf zum Scheitern verurteilt sind. Es gab ja schon einige Ansätze von solchen Commpilern...
Schade drum, um die Sprache.
gruß
Wie du richtig erkannt hast, geht das mit _GUICtrlComboBox(Ex)_DeleteString.
Wo hängt's?
Schau dir doch einfach das Beispiel in der Hilfe an (in SciTE mit dem Cursor im Befehl F1 drücken, oder auf den Befehl in einem Codetag im Forum klicken).
_GUICtrlComboBox_DeleteString
[/autoit]IniReadSectionNames, dann in einer Schleife schauen, ob der gesuchte Sektionsname im Array steht.
lg
PS: Für neue Fragen eröffnet man für gewöhnlich ein neues Thema. ![]()
Die Antwort lautet _Bass_GetDeviceInfo. ![]()
#include <Bass.au3>
_Bass_Startup()
[/autoit][autoit][/autoit][autoit]Local $iIndex = 0
[/autoit][autoit][/autoit][autoit]While True
$vTemp = _Bass_GetDeviceInfo($iIndex)
If $vTemp = 0 Then ExitLoop
ConsoleWrite("Device " & $iIndex & ": " & $vTemp[0] & @CRLF)
$iIndex += 1
WEnd
_Bass_Free()
[/autoit]Natürlich dann noch dementsprechend aufbereiten.
lg
Mit der Bass-UDF kann man so viel ich weiß das Ausgabegerät festlegen.
lg
Mit AutoIt ginge es wohl über die _FTP-Funktionen (FTP.au3).
Mit PHP wäre aber ein schöner "Bibliothek neu einlesen"-Button möglich... ![]()
lg
Bei uns werden die Threads nicht geschlossen - der Threadersteller setzt sie durch Bearbeiten des ersten Posts auf "gelöst".
Wenn du also so freundlich wärst... ![]()
lg
So, dann wollen wir mal antworten. ![]()
@Cheater
Klar, man muss das dann auch konsequent durchziehen. Sonst bringt das nichts. ![]()
command.name.37.$(au3)=Datatypes
command.37.*.au3="$(autoit3dir)\autoit3.exe" "$(SciteDefaultHome)\Datatypes\Datatypes.au3" "$(FilePath)"
command.mode.37.*=savebefore:yes
command.shortcut.37.*.au3=Ctrl+Alt+T
Zitat aus meiner SciTEUser.properties... Das ist dann auch alles, wofür Lua genutzt wird. Sonst ist das ein AutoIt-Skript.^^
Gut, das ist ja das schöne: Es ist nicht zwingend, sondern optional nutzbar. Daher müssen Anfänger sich mit sowas nicht belasten.
Und zum Beispiel für Sachen wie der Hex-Bug würde das schon helfen... Wenn man das ganze dementsprechend erweitert.
@Make
Du musstest dir keine Gedanken machen, richtig... Hat auch bestimmt einige Fehler produziert. ![]()
Aber von dir z.B. weiß ich ja, dass du auch gerne mit C und C++ programmierst. Gerade deswegen, um bei dieser "Formsache" näher an C dran zu sein, finde ich das sinnvoll. Mir zumindest fällt es zunehmend schwerer, von den primitiven Datentypen in C, den Klassen in C#/D/Java (
) und Variant in AutoIt hin und her zu wechseln. Das führt bei mir hin und wieder zu ein paar abenteuerlichen Code-Konstruktionen, vorallem in C, weil dann wildes hin und her Casten kommt. ![]()
Oscar
Die automatische Umwandlung bleibt ja. Es geht, wie schon gesagt, eher um die Ordentlichkeit des Programmierers, und nur sekundär um Debugging. ![]()
Generell finde ich diesen Weg gut... Solange dabei die eigentlichen Möglichkeiten von AutoIt erhalten bleiben. Beim Erzwingen von Datentypen z.B... wäre ich auch nicht dabei gewesen.
Diese C-Style Neuerungen gehören alle in den Bereich der Funktion Opt.
Aber grundsätzlich finde ich es nicht schlecht, dass sie vorhanden sind, solange eben die Nutzung nicht erzwungen wird.
BugFix
Das wäre ja so leicht erkennbar!
Die direkte Überprüfung des Ausdrucks (Also nach If <Ausdruck> Then) steht natürlich auch noch an... Aber erst später.
Und um die Skript-Breaking-Changes zu verhindern, benutze ich ja die Präfixe. Dadurch laufen die Skripte auch ohne das PlugIn. Das PlugIn greift ja sowieso nicht in das Skript ein. Es funktioniert unabhängig vom Ausführen unmittelbar davor. ![]()
Und was den Weg von AutoIt angeht... Solange keiner von uns in's Dev Team kommt, haben wir wohl leider keine Chance, da etwas zu ändern...
Gruß
chess
Hallo,
ich möchte mal kurz etwas vorstellen, und nebenher fragen, was die Allgemeinheit davon hält:
Nämlich das Prinzip der Datentypen in AutoIt, nach dieser Liste (mit kleinen Modifikationen).
Klingt zunächst einmal sehr... Utopisch. Etwas, was die Dev's aus dem EN-Forum wohl niemals freiwillig implementieren würden.
Da wir den AutoIt-Source nicht haben, können wir das auch nicht selber in die Hand nehmen. Wir müssen also an einer anderen Stelle ansetzen, wo wir AutoIt indirekt beeinflussen können: SciTE. ![]()
Damit haben wir natürlich von AutoIt aus keine Datentypen - allerdings für die Seite des Programmierers, was trotzdem ungemein bei der Fehlersuche und auch bei der Ordentlichkeit helfen kann. Daher auch die Bezeichnung Pseudo-Datentypen.
Realisiert würde das - wie bereits gesagt - über ein SciTE-Plugin, welches per Tastenkombination überprüft, ob im gerade geöffneten Skript auf Typenkonventionen geachtet wurde, und dann ggf. die Verletzungen der Regeln in der Konsole anprangert.
Ein wichtiger Punkt bei einem solchen Unternehmen ist natürlich die Einbindung in das restliche AutoIt-Schema. Es müssen z.B. auch alle Rückgabewerte der internen Funktionen dokumentiert werden, und generell muss auf viel Syntaktisches geachtet werden. Im derzeitigen Stadium wird nur die Überprüfung einer Zuweisung unterstützt, also z.B. $var = 42.
Doch wie bestimmt man den Datentyp? Aus C kennt man solche Initialisierungen:
Doch wenn wir dieses Schema in AutoIt nutzen würden, könnte ein Benutzer ohne dieses PlugIn das Skript nicht mehr ausführen.
int $i
Möglich wäre natürlich ein Kommentar hinter der Variable:
[autoit]
$i = 42 ;int
Aber das ist nicht sehr intuitiv nutzbar.
Darum habe ich mich für die Möglichkeit entschieden, die wir sowieso schon nutzen, und die ich für sehr intuitiv halte: Die Bestimmung des Datentypes über den ersten Buchstaben des Variablennamens.
Präfixgesteuerte Datentypen!
$i = 42
Hier ein Beispielskript:
$hWnd = GUICreate("Test", 100, 100)
$cCheck1 = GUICtrlCreateCheckbox("Check 1", 10, 10)
$sCheck2 = GUICtrlCreateCheckbox("Check 2", 10, 30)
$cCheck3 = GUICtrlCreateCheckbox("Check 3", 10, 50)
$cResult = GUICtrlCreateButton("Auswerten", 10, 70, 80)
[/autoit] [autoit][/autoit] [autoit]GUISetState()
[/autoit] [autoit][/autoit] [autoit]While 1
Switch GUIGetMsg()
Case -3
Exit
EndSwitch
WEnd
Wenn ich nun per Strg+Alt+T die Überprüfung starte, bekomme ich folgenden Output in der Konsole:
Handle in Zeile 1 ($hWnd), Zuweisung ist vom Typ Handle
Control in Zeile 3 ($cCheck1), Zuweisung ist vom Typ Control
!> Typenfehler: String in Zeile 4 ($sCheck2), Zuweisung ist vom Typ Control
Control in Zeile 5 ($cCheck3), Zuweisung ist vom Typ Control
Control in Zeile 7 ($cResult), Zuweisung ist vom Typ Control
(Mit gewissen Einstellungen kann man z.B. nur die Fehler anzeigen lassen)
Und siehe da, in Zeile 4 ist ein Fehler. ![]()
Mir persönlich gefällt dieses Prinzip sehr gut. Jetzt würde mich interessieren, was das Forum davon hält.
Veröffentlichen möchte ich es im Moment noch nicht. Dazu bin ich noch nicht weit genug, obwohl es grundlegend ja eigentlich einfach ist. ![]()
Fragen, Anregungen und Kritik sind - wie immer - willkommen. ![]()
Gruß
chesstiger
Du könntest auch den Haupt-Audiostream (Eventuell sogar auf einzelne Anwendungen beschränkt?) per Bass-UDF auslesen, soviel ich weiß. ![]()
lg
Ich hab's auch zeitlich einfach nicht geschafft... Also nicht zwangsläufig Kritik. ![]()
lg
+++++ +++[- >++++ ++++< ]>+++ ++.<+ +++++ [->++ ++++< ]>+++ +++++ ++++.
<++++ [->-- --<]> --.++ +++.< +++++ +++[- >---- ----< ]>--- ----- .<+++
+++++ [->++ +++++ +<]>+ .<+++ [->++ +<]>+ +..-- ----- .++++ +++++ .<+++
+++++ [->-- ----- -<]>- ----- ----- ---.< +++++ +++[- >++++ ++++< ]>+++
++.++ ++.++ +++.< +++++ +++[- >---- ----< ]>--- ----- ----- -.<++ +++++
+[->+ +++++ ++<]> +++++ +.<++ +[->+ ++<]> +++.- --.-- ----- .---. <+++[
->+++ <]>++ +++.< +++++ ++++[ ->--- ----- -<]>- -.<++ +++++ [->++ +++++
<]>++ ++++. <+++[ ->+++ <]>++ +++.+ +++.- .++++ ++.<+ ++[-> ---<] >----
.++.+ ++++. <+++[ ->+++ <]>++ +.-.< +++[- >---< ]>--- -.-.< +++[- >+++<
]>+++ ++.+. <++++ +++++ [->-- ----- --<]> --.<
Auf verschiedenen Sprachen, das kann ich auch! ![]()
Das müsstest du eher in einem 2-Dimensionalen Array lösen:
[autoit]
#include <Array.au3>
$sFile = "test.txt"
[/autoit][autoit][/autoit][autoit]$hFile = FileOpen($sFile) ;$[h]File! FileOpen gibt ein Handle zurück, keinen String!
$asLinesRaw = StringSplit(FileRead($hFile), @CRLF, 3)
Local $asLines[UBound($asLinesRaw)][2]
[/autoit][autoit][/autoit][autoit][/autoit][autoit]For $i = 0 To UBound($asLinesRaw) - 1
$asTemp = StringSplit($asLinesRaw[$i], ":", 3)
If UBound($asTemp) < 2 Then
ConsoleWrite("Line " & ($i + 1) & " bad format." & @CRLF)
ContinueLoop
EndIf
$asLines[$i][0] = $asTemp[0]
$asLines[$i][1] = $asTemp[1]
Next
_ArrayDisplay($asLines)
[/autoit]
Auf FileReadLine würde ich eher verzichten. ![]()
lg
Das Problem sollte doch eigentlich mit einem simplen StringFormat lösbar sein, oder?^^
lg
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
$iDefWinW = 500
$iDefWinH = 332
Opt("GUIResizeMode", $GUI_DOCKALL)
[/autoit] [autoit][/autoit] [autoit]GUICreate("Gui", 500, 332, -1, -1, BitOR($GUI_SS_DEFAULT_GUI,$WS_MAXIMIZEBOX,$WS_SIZEBOX,$WS_THICKFRAME,$WS_TABSTOP))
GUIRegisterMsg($WM_SIZE, "_ResizeHandler")
Global $GroupTop = GUICtrlCreateGroup("Dock: Left, Right, Top", 8, 8, 484, 100)
;~ GUICtrlSetResizing(-1, $GUI_DOCKLEFT+$GUI_DOCKRIGHT+$GUI_DOCKTOP)
GUICtrlCreateGroup("", -99, -99, 1, 1)
Global $GroupMiddle = GUICtrlCreateGroup("Dock: Left, Right, Height, VCenter", 8, 116, 484, 100)
;~ GUICtrlSetResizing(-1, $GUI_DOCKLEFT+$GUI_DOCKRIGHT+$GUI_DOCKVCENTER)
GUICtrlCreateGroup("", -99, -99, 1, 1)
Global $GroupBottom = GUICtrlCreateGroup("Dock: Left, Right, Bottom", 8, 224, 484, 100)
;~ GUICtrlSetResizing(-1, $GUI_DOCKLEFT+$GUI_DOCKRIGHT+$GUI_DOCKBOTTOM+$GUI_DOCKHEIGHT)
GUICtrlCreateGroup("", -99, -99, 1, 1)
GUISetState(@SW_SHOW)
While 1
Switch GUIGetMsg()
Case $GUI_EVENT_CLOSE
ExitLoop
EndSwitch
WEnd
Func _ResizeHandler($hWnd, $iCtrl, $iWParam, $iLParam)
$iW = _WinAPI_LoWord($iLParam)
$iH = _WinAPI_HiWord($iLParam)
ConsoleWrite("New Size: " & $iW & ":" & $iH & @CRLF)
;GBottom soll die Position nicht verändern. Breite muss trotzdem angepasst werden.
GUICtrlSetPos($GroupBottom, 8, $iH - $iDefWinH + 224, $iW - $iDefWinW + 484, 100)
;GMiddle soll die Hälfte des Abstandes vom oberen Rand und GBottom einnehmen. Die Position und die Höhe muss sich daher anpassen.
$iGMiddleHFactor = (($iH - 108) / ($iDefWinH - 108))
GUICtrlSetPos($GroupMiddle, 8, 116 * $iGMiddleHFactor, $iW - $iDefWinW + 484, $iH - $iDefWinH + 224 - $iGMiddleHFactor * 116)
;GTop soll die Position nicht verändern, nur die andere Hälfte des Abstandes zwischen dem oberen Rand und GBottom einnehmen.
GUICtrlSetPos($GroupTop, 8, 8, $iW - $iDefWinW + 484, 116 * $iGMiddleHFactor - ![]()
EndFunc
WM_SIZE ist der richtige Ansatz. ![]()
lg
Edit:
Raupis Idee wäre evtl. auch nicht schlecht, wenn man sich die Berechnungen anschaut... ![]()
Dann muss immer nur die Child-GUI verändert werden.
Vielleicht kannst du ganz auf Adobe Acrobat verzichten... Ob auf MatLab, das weiß ich nicht genau.
Was genau hast du denn damit vor? Bis zu einem bestimmten Punkt geht Grafikbearbeitung in AutoIt auch relativ komfortabel. ![]()
Ansonsten: Ja, kann man. Zumindest bei normalen Win32-Anwendungen, wozu Adobe glaub ich zählt. Siehe dazu die Control-Funktionen...
Wie misterspeed schon gesagt hat, geht das alles bei einer richtigen Schnittstelle seitens Adobe oder MathLab noch vieeel einfacher.
Gruß
chess
PS: Es heißt nicht Auto IT, sondern AutoIt, von dt. Automatisiere Es (Auto It). ![]()
Wie wär's mit $GUI_DEFBUTTON als Status für den Button? ![]()
#include <GUIConstants.au3>
$hWnd = GUICreate("$GUI_DEFBUTTON Example", 300, 100)
[/autoit][autoit][/autoit][autoit]$cInput = GUICtrlCreateInput("Text", 10, 10, 130, 20)
$cButton = GUICtrlCreateButton("Übernehmen", 10, 70, 130, 20)
$cLabel = GUICtrlCreateLabel("Text", 160, 40, 110, 20)
GUICtrlSetState($cButton, $GUI_DEFBUTTON) ;$cButton als Standard-Button der GUI definieren
[/autoit][autoit][/autoit][autoit]GUISetState()
[/autoit][autoit][/autoit][autoit]While True
Switch GUIGetMsg()
Case -3 ;$GUI_EVENT_CLOSE
Exit
Case $cButton
GUICtrlSetData($cLabel, GUICtrlRead($cInput))
EndSwitch
WEnd
lg
Ich würde eher zu einer Möglichkeit mit nur einem Key (und ohne Arrays) tendieren...
Es gibt doch bestimmt ein Zeichen, welches in den Benutzernamen nie vorkommt?
Ich nehme als Beispiel mal das Pipe-Zeichen | ( AltGr + < ).
Dann baust du deine config.ini wie folgt auf:
Im Code dann wiederum:
[autoit]
$sINI = "config.ini"
$sUsersAllowed = "|" & IniRead($sINI, "users", "userlist", "") & "|"
$sUserLogin = InputBox("", "Benutzername?")
[/autoit][autoit][/autoit][autoit]If Not StringInStr($sUsersAllowed, "|" & $sUserLogin & "|") Then
MsgBox(0, "", "Benutzer nicht bekannt!")
Exit
EndIf
MsgBox(0, "", "Login erfolgreich!")
[/autoit]Die Spielerei mit den Pipe-Zeichen in Zeile 2 und 6 muss sein, da sonst bei der gegebenen Userliste ein Login mit "chess" möglich wäre, obwohl dort nur "chesstiger" steht (StringInStr gibt natürlich dann einen positiven Wert zurück). Daher überprüfen wir, ob vor und nach dem Benutzernamen ein | steht. ![]()
Die Lösung mit Arrays wäre evtl. eleganter, aber auch aufwändiger, und performance-lastiger.
lg