1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. chesstiger

Beiträge von chesstiger

  • Kindern etwas spielerisch beibringen - Schritt für Schritt Anleitungen

    • chesstiger
    • 3. Januar 2017 um 17:12

    Zu zwei: Man platziere die Slots ebenfalls auf Child-Windows und erstelle sie nach den verschiebbaren Feldern (im Skript Tiles). Dann passt das.

    PARENTDRAG können nur Label und Pic, soweit ich mich erinnere. Ich habe das ganze mal ein wenig ausgebaut, mit Positionsüberprüfung. Die richtige Reihenfolge ist 1, 2, 3. Dann wird der Hintergrund grün. :D

    [autoit]

    #include <StaticConstants.au3>
    #include <GUIConstants.au3>

    [/autoit][autoit][/autoit][autoit]

    ;Main Window
    $hMainWnd = GUICreate("Child Window Sort", 600, 400)
    GUISetBkColor(0xffffff)

    [/autoit][autoit][/autoit][autoit]

    ;Tile Windows
    Global $ahTileWnd[3]
    For $i = 0 To UBound($ahTileWnd) - 1
    $ahTileWnd[$i] = GUICreate("", 100, 100, 0, 0, $WS_CHILD, $WS_EX_TOPMOST, $hMainWnd)
    GUICtrlCreateLabel("Drag Me " & ($i + 1), 0, 0, 100, 100, $SS_CENTER + $SS_CENTERIMAGE, $GUI_WS_EX_PARENTDRAG)
    GUISetBkColor(0xff00ff)
    GUISetState()
    Next

    [/autoit][autoit][/autoit][autoit]

    ;Slot Windows
    Global $ahSlotWnd[3]
    For $i = 0 To UBound($ahSlotWnd) - 1
    $ahSlotWnd[$i] = GUICreate("", 100, 100, 100 * ((1.5 * $i) + 1), 150, $WS_CHILD, Default, $hMainWnd)
    GUICtrlCreateLabel("Slot " & ($i + 1), 0, 0, 100, 100, $SS_CENTER + $SS_CENTERIMAGE)
    GUICtrlSetBkColor(-1, 0x0000ff)
    GUISetState()
    Next

    [/autoit][autoit][/autoit][autoit]

    GUISetState(@SW_SHOW, $hMainWnd) ;parent window auf sichtbar stellen

    [/autoit][autoit][/autoit][autoit]

    While True
    Switch GUIGetMsg()
    Case $GUI_EVENT_CLOSE
    Exit
    Case $GUI_EVENT_PRIMARYUP
    ;Linke Maustaste losgelassen
    $aTilePos = AlignTiles($ahTileWnd, $ahSlotWnd)
    CheckPositions($aTilePos)
    EndSwitch
    WEnd

    [/autoit][autoit][/autoit][autoit]

    Func CheckPositions($aTilePos)
    ;Diese Funktion entscheidet,
    ;ob ein Tile auf dem richtigen Slot
    ;liegt (bzw. ob alle richtig liegen)

    [/autoit][autoit][/autoit][autoit]

    ;Das folgende kann man auch in eine
    ;Schleife packen, so ist der Sinn
    ;aber deutlicher
    If ($aTilePos[0] = 0) And ($aTilePos[1] = 1) And ($aTilePos[2] = 2) Then
    GUISetBkColor(0x00ff00, $hMainWnd)
    Else
    GUISetBkColor(0xff0000, $hMainWnd)
    EndIf
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func AlignTiles($ahTileWnd, $ahSlotWnd)
    ;Alle Child-Windows durchgehen und schauen,
    ;ob eines teilweise auf dem Slot liegt
    ;(Stichwort: Kollisionsabfrage
    Local $aReturn[UBound($ahSlotWnd)]
    For $i = 0 To UBound($aReturn) - 1
    $aReturn[$i] = -1
    Next
    ;Außerdem gibt diese Funktion ein
    ;Array zur Bestimmung der Positionen
    ;zurück. Aufbau: $aReturn[n] = m
    ; n: Tile-Nummer
    ; m: Slot-Nummer
    $aMainPos = WinGetPos($hMainWnd)
    $aMainClientSize = WinGetClientSize($hMainWnd)
    $aMainPos[0] += $aMainPos[2] - $aMainClientSize[0] - 3
    $aMainPos[1] += $aMainPos[3] - $aMainClientSize[1] - 3
    For $iSlot = 0 To UBound($ahSlotWnd) - 1
    $aSlotPos = WinGetPos($ahSlotWnd[$iSlot])
    For $iTile = 0 To UBound($ahTileWnd) - 1
    $aTilePos = WinGetPos($ahTileWnd[$iTile])
    If IsRectCollision($aTilePos, $aSlotPos) Then
    ConsoleWrite("+DEBUG> Kollision erkannt. Richte ChildWnd " & ($iTile + 1) & " neu aus..." & @CRLF)
    WinMove($ahTileWnd[$iTile], "", $aSlotPos[0] - $aMainPos[0], $aSlotPos[1] - $aMainPos[1])
    $aReturn[$iTile] = $iSlot
    EndIf
    Next
    Next
    Return $aReturn
    EndFunc ;==>AlignTiles

    [/autoit][autoit][/autoit][autoit]

    Func IsRectCollision($aPosA, $aPosB)
    Local Enum $X, $Y, $W, $H
    If $aPosA[$X] > ($aPosB[$X] + $aPosB[$W]) Then Return False
    If ($aPosA[$X] + $aPosA[$W]) < $aPosB[$X] Then Return False
    If $aPosA[$Y] > ($aPosB[$Y] + $aPosB[$H]) Then Return False
    If ($aPosA[$Y] + $aPosA[$H]) < $aPosB[$Y] Then Return False
    Return True
    EndFunc ;==>IsRectCollision

    [/autoit]

    P.S.: Das ist nicht violett, das ist pink!

    Edit: Hatte vergessen, das Return-Array von AlignTiles() vorher auf unplausible Werte zu setzen.

  • Kindern etwas spielerisch beibringen - Schritt für Schritt Anleitungen

    • chesstiger
    • 3. Januar 2017 um 14:38

    Hi,

    ich würde das ganze auf Basis von Child Windows realisieren. Dann nimmt dir Windows das Verschieben und Neuzeichnen direkt ab. Ich hab mal ein kleines (fehlerhaftes) Minimalbeispiel geschrieben. Bei mir gibt es da den ein oder anderen Darstellungsfehler, ich bin mir aber nicht sicher, was davon am Betriebssystem liegt (Debian 8 mit Wine). Daher, sieh es einfach mal als Proof-Of-Concept.

    [autoit]


    #include <StaticConstants.au3>
    #include <GUIConstants.au3>

    [/autoit][autoit][/autoit][autoit]

    $hMainWnd = GUICreate("Child Window Sort", 600, 400)
    $cSlotA = GUICtrlCreateLabel("Example Slot", 250, 150, 100, 100, $SS_CENTER + $SS_CENTERIMAGE)
    GUICtrlSetBkColor(-1, 0x00ff00)
    GUISetBkColor(0xffffff)

    [/autoit][autoit][/autoit][autoit]

    Global $ahChildWnd[3]
    For $i = 0 To UBound($ahChildWnd) - 1
    $ahChildWnd[$i] = GUICreate("", 100, 100, 0, 0, $WS_CHILD, Default, $hMainWnd)
    GUICtrlCreateLabel("Drag Me " & ($i + 1), 0, 0, 100, 100, $SS_CENTER + $SS_CENTERIMAGE, $GUI_WS_EX_PARENTDRAG)
    GUISetBkColor(0xff00ff)
    GUISetState()
    Next

    [/autoit][autoit][/autoit][autoit]

    GUISetState(@SW_SHOW, $hMainWnd) ;parent window auf sichtbar stellen

    [/autoit][autoit][/autoit][autoit]

    While True
    Switch GUIGetMsg()
    Case $GUI_EVENT_CLOSE
    Exit
    Case $GUI_EVENT_PRIMARYUP
    ;Linke Maustaste losgelassen
    CheckPositions()
    EndSwitch
    WEnd

    [/autoit][autoit][/autoit][autoit]

    Func CheckPositions()
    ;Alle Child-Windows durchgehen und schauen,
    ;ob eines teilweise auf dem Slot liegt
    ;(Stichwort: Kollisionsabfrage)
    $aSlotPos = WinGetPos(GUICtrlGetHandle($cSlotA))
    $aMainPos = WinGetPos($hMainWnd)
    For $i = 0 To UBound($ahChildWnd) - 1
    $aChildPos = WinGetPos($ahChildWnd[$i])
    If IsRectCollision($aChildPos, $aSlotPos) Then
    ConsoleWrite("Kollision erkannt. Richte ChildWnd " & ($i + 1) & " neu aus..." & @CRLF)
    WinMove($ahChildWnd[$i], "", $aSlotPos[0] - $aMainPos[0], $aSlotPos[1] - $aMainPos[1])
    EndIf
    Next
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func IsRectCollision($aPosA, $aPosB)
    Local Enum $X, $Y, $W, $H
    If $aPosA[$X] > ($aPosB[$X] + $aPosB[$W]) Then Return False
    If ($aPosA[$X] + $aPosA[$W]) < $aPosB[$X] Then Return False
    If $aPosA[$Y] > ($aPosB[$Y] + $aPosB[$H]) Then Return False
    If ($aPosA[$Y] + $aPosA[$H]) < $aPosB[$Y] Then Return False
    Return True
    EndFunc

    [/autoit]
  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 2. Januar 2017 um 12:44

    Update v1.1.0

    Da mir hier eben ein Thread mit dem Thema Dictionaries ins Auge gesprungen ist, habe ich da mal flugs was für gebastelt.
    Dictionaries können nach dem Schema Local/Global/Dim Dict $oDict erstellt werden. Auch eine Initialisierung wie aus PHP (Local Dict $oDict = ["foo" => "bar"]) ist möglich. Im ganzen weiteren Skript kann auf die Dictionary-Einträge mit eckigen Klammern zugegriffen werden. Außerdem wird UBound($oDict) durch $oDict.count ersetzt.

    Weiteres in der Readme-Datei, Quellcode ist im Repository.

  • GUICtrlCreateGraphic soll auf Rechtsklick die Farbe ändern (gelöst)

    • chesstiger
    • 31. Dezember 2016 um 14:01

    @alpines
    Kann man jetzt sehen, wie man will. Auf die aufsteigende Vergabe der Control-IDs kann man sich eigentlich verlassen, das ist immer so. Zumindest bei einfachen Controls wie Graphic oder Button. Und dann liest man einfach: "Wenn die Control-ID nicht zwischen $cTiles[0] und $cTiles[1] liegt, dann return"
    Persönlich finde ich das sogar besser lesbar als eine For-Schleife. ^^

    Aber, wie du schon sagtest, jedem das seine. Ob das für Anfänger angemessen ist, kann man wohl auch mit recht bezweifeln.

    Aber immerhin hast du nicht damit gerechnet... :whistling:

  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 31. Dezember 2016 um 13:47

    UPDATE

    Die bereits angesprochenen Erweiterungen für Debug2File wurden umgesetzt: Das entstandene Skript wird nun automatisch durch Tidy gejagt und dann mit dem voreingestellten Editor (meistens SciTE) geöffnet.

    Weiterhin ist noch die Referenz-Foreach-Schleife aus PHP dazugekommen. Das ist im Prinzip eine For-In-Next-Schleife, bei der man das aktuelle Element auch bearbeiten kann. Dafür sind zwei Schreibweisen erlaubt. Einmal Original-PHP:

    [autoit]


    For &$e In $a

    [/autoit]


    Und dann noch eine schöner zu lesende, an AutoIt angepasste Schreibweise:

    [autoit]


    For ByRef $e In $a

    [/autoit]

    So. Das letzte Update für dieses Jahr. :D

  • GUICtrlCreateGraphic soll auf Rechtsklick die Farbe ändern (gelöst)

    • chesstiger
    • 31. Dezember 2016 um 13:16

    Das stimmt. Ist mir auch eben aufgefallen. $GUI_DISABLE wird ja durch GUIGetCursorInfo erfolgreich umgangen.

    Aber wer braucht schon ein Switch oder For? Wir sind doch kreativ und wissen, wie AutoIt Control-IDs vergibt. :D

    [autoit]


    #include <GUIConstants.au3>

    [/autoit][autoit][/autoit][autoit]

    Opt("GUIOnEventMode", True)

    [/autoit][autoit][/autoit][autoit]

    Global $hWnd
    Global $cTiles[4] ;Anklickbare Felder (L->R, O->U)

    [/autoit][autoit][/autoit][autoit]

    $hWnd = GUICreate("GUI 4x4", 140, 140)
    GUISetOnEvent($GUI_EVENT_CLOSE, Close)
    GUISetOnEvent($GUI_EVENT_PRIMARYDOWN, LeftClick)
    GUISetOnEvent($GUI_EVENT_SECONDARYDOWN, RightClick)
    $cBackground = GUICtrlCreateGraphic(0, 0, 140, 140)
    GUICtrlSetBkColor($cBackground, 0xA0A0A0)
    GUICtrlSetState($cBackground, $GUI_DISABLE)
    $cTiles[0] = GUICtrlCreateGraphic(1, 1, 69, 69)
    $cTiles[1] = GUICtrlCreateGraphic(71, 1, 69, 69)
    $cTiles[2] = GUICtrlCreateGraphic(1, 71, 69, 69)
    $cTiles[3] = GUICtrlCreateGraphic(71, 71, 69, 69)
    For $cTile In $cTiles
    GUICtrlSetBkColor($cTile, 0xFFFFFF)
    Next
    GUISetState()

    [/autoit][autoit][/autoit][autoit]

    While True
    Sleep(42)
    WEnd

    [/autoit][autoit][/autoit][autoit]

    Func Close()
    Exit
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func LeftClick()
    $cClicked = GUIGetCursorInfo()[4]
    If ($cTiles[0] > $cClicked) Or ($cClicked > $cTiles[3]) Then Return
    GUICtrlSetBkColor($cClicked, 0xFF0000)
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func RightClick()
    $cClicked = GUIGetCursorInfo()[4]
    If ($cTiles[0] > $cClicked) Or ($cClicked > $cTiles[3]) Then Return
    GUICtrlSetBkColor($cClicked, 0x00FF00)
    EndFunc

    [/autoit]
  • GUICtrlCreateGraphic soll auf Rechtsklick die Farbe ändern (gelöst)

    • chesstiger
    • 31. Dezember 2016 um 13:00

    Eieiei...

    Zunächst mal was zu dem Skript an sich und zu deinem Stil. Es ist eigentlich Schwachsinn, vorher alle Variablen mit 0 zu initialisieren. Das erledigt man - wenn überhaupt - mit einer Deklaration a la Global $fenster. Du kannst es aber auch einfach weglassen, AutoIt stört das nicht. Und es empfiehlt sich, englische Bezeichner zu verwenden. Das liest sich wesentlich schöner, weil der Code rundrum ja auch englisch ist. Weiterhin... Bei vier Elementen der gleichen Art spielt das noch keine so große Rolle, aber zum Speichern der Control-IDs kannst du auch gut ein Array verwenden.

    Inhaltlich kannst du dir die ersten sechs Graphic-Controls auch sparen. Leg einfach ein großes dahinter und stell es auf $GUI_DISABLE. Das klappt genau so.

    So, nun zum eigentlichen Thema. Du kannst mittels GUISetOnEvent die Events $GUI_EVENT_PRIMARYDOWN und $GUI_EVENT_SECONDARYDOWN abfangen. Das erste ist ein Linksklick, das zweite ein Rechtsklick. Mittels GUIGetCursorInfo() holst du dir dann das Control-Handle. Ich habe alle hier angesprochenen Änderungen mal auf dein Skript übertragen.

    Hier gilt es aber zu beachten, dass alles dem Beispiel angepasst worden ist. Falls die GUI noch mehr Elemente enthält, muss in den Klick-Funktionen noch eine Abfrage nach der Control-ID erfolgen. Habe ich mir hier jetzt - weil es möglich ist und das Skript signifikant verkürzt - gespart.

    [autoit]


    #include <GUIConstants.au3>

    [/autoit][autoit][/autoit][autoit]

    Opt("GUIOnEventMode", True)

    [/autoit][autoit][/autoit][autoit]

    Global $hWnd
    Global $cTiles[4] ;Anklickbare Felder (L->R, O->U)

    [/autoit][autoit][/autoit][autoit]

    $hWnd = GUICreate("GUI 4x4", 140, 140)
    GUISetOnEvent($GUI_EVENT_CLOSE, Close)
    GUISetOnEvent($GUI_EVENT_PRIMARYDOWN, LeftClick)
    GUISetOnEvent($GUI_EVENT_SECONDARYDOWN, RightClick)
    $cBackground = GUICtrlCreateGraphic(0, 0, 140, 140)
    GUICtrlSetBkColor($cBackground, 0xA0A0A0)
    GUICtrlSetState($cBackground, $GUI_DISABLE)
    $cTiles[0] = GUICtrlCreateGraphic(1, 1, 69, 69)
    $cTiles[1] = GUICtrlCreateGraphic(71, 1, 69, 69)
    $cTiles[2] = GUICtrlCreateGraphic(1, 71, 69, 69)
    $cTiles[3] = GUICtrlCreateGraphic(71, 71, 69, 69)
    For $cTile In $cTiles
    GUICtrlSetBkColor($cTile, 0xFFFFFF)
    Next
    GUISetState()

    [/autoit][autoit][/autoit][autoit]

    While True
    Sleep(42)
    WEnd

    [/autoit][autoit][/autoit][autoit]

    Func Close()
    Exit
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func LeftClick()
    $cClicked = GUIGetCursorInfo()[4]
    GUICtrlSetBkColor($cClicked, 0xFF0000)
    EndFunc

    [/autoit][autoit][/autoit][autoit]

    Func RightClick()
    $cClicked = GUIGetCursorInfo()[4]
    GUICtrlSetBkColor($cClicked, 0x00FF00)
    EndFunc

    [/autoit]
  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 29. Dezember 2016 um 12:10

    @BugFix Genau das wollte ich mit dem Rest des Satzes andeuten, den du nicht mitzitiert hast. :D

  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 28. Dezember 2016 um 23:34

    @Xori
    Ist schon was dran, dafür ist dann eben die Debug2File-Option. Momentan muss man halt noch manuell Tidy drüberlaufen lassen, aber ich hab das mal auf die Todo-Liste geschrieben.

    @Andy
    Wenn C dich einmal hat, lässt es dich nie wieder los. Dazu macht die Sprache zu viel Spaß. Vor allem, wenn die Java-Leute bei Betrachtung deines Codes die Hände über dem Kopf zusammenschlagen. :D

  • Assemblercode - Noch optimierbar?

    • chesstiger
    • 28. Dezember 2016 um 23:30

    @Andy

    i7-2670QM
    SSE: 3949.001000
    AVX: 3981.006000

  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 28. Dezember 2016 um 22:12

    @Xori
    Dazu war eigentlich die Zeile #SynSug_Enable=yes gedacht. Wenn irgendjemand das Skript in den Weiten des Internets findet, kann er mit dem Stichwort "SynSug" entweder den Thread hier oder auch das Repository finden und dann entsprechend damit arbeiten.

    Davon ab ist es natürlich möglich, das bearbeitete Skript zu speichern. Dafür kann man die oben angesprochene "Debug to File"-Funktion verwenden. "test.au3" wird dann übersetzt und als "test_synsug.au3" im gleichen Verzeichnis gespeichert. Sieht nur leider momentan ziemlich bescheiden aus, danach müsste man nochmal mit Tidy drüber gehen.

  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 28. Dezember 2016 um 22:03

    Hi!

    Der ein oder andere hat ja vielleicht schon den Link zum git-Repo in der Shoutbox gesehen. Ihr wisst schon, worum es geht. Hier trotzdem - bevor es zum Wesentlichen geht - einmal die Vorgeschichte.

    In letzter Zeit arbeite ich regelmäßig mit den verschiedensten Programmiersprachen, von Assembler über C und Java bis hin zu PHP. Nun, manche dieser Sprachen können ein paar coole Sachen, die ich dann prompt beim Programmieren in AutoIt vermisst habe. Als einfaches Beispiel sei hier mal die Postfix-Inkrementierung ($i++) genannt.
    Aus dieser "Problematik" heraus ist dann ein kleiner Präprozessor entstanden, der gewisse Ausdrücke (meistens mit Hilfe von RegEx) in andere Ausdrücke umwandelt. Es wird also streng genommen nicht die Funktionalität von AutoIt erweitert, sondern nur eine alternative Schreibweise für bereits vorhandene Mechanismen angeboten. Das nennt man dann Syntactic Sugar. In der README-Datei ist (mehr oder weniger genau) beschrieben, welche Spielereien im Einzelnen verfügbar sind. Dabei wird es aber ziemlich sicher nicht bleiben.

    Noch dazu kommt, dass die Pattern noch nicht perfekt sind. Es kann durchaus zu Parsing-Fehlern kommen. Daher erscheint nach der Installation auch ein Punkt namens "Syntactic Sugar (Debug to File)" im Tools-Menü von SciTE. Dann kann man genau nachvollziehen, wie der eigene Quellcode verändert worden ist.

    Um gewisse Probleme bei der Arbeit mit SynSug zu vermeiden, muss jedes Skript die Zeile #SynSug_Enable=yes enthalten. Sieht im ersten Augenblick zwar aus, wie übertriebene Formalität, hat aber den netten Nebeneffekt, dass man veröffentlichte SynSug-Skripte als solche identifizieren kann.

    Naja, mehr muss ich, glaube ich, dazu nicht sagen, alles weitere steht in der README-Datei. :D

    Link zum Repo: bitbucket.org/chesstiger/synsug-autoit

    Grüße!

  • Von Prozess auf einen Anderen Prozess zugreifen

    • chesstiger
    • 28. Dezember 2016 um 03:59

    Um die von alpines beschriebene Funktion zu nutzen, musst du allerdings nicht die obenstehende Funktion in dein Skript integrieren. In der Include-Datei WinAPiFiles.au3 ist diese bereits als _WinAPI_FileInUse enthalten. Wichtig zu wissen ist bei dieser Funktion, dass eine Benutzung durch einen anderen Prozess signalisiert wird, sobald ein Handle für diese Datei im System bekannt ist. Das gilt auch für Handles deines eigenen Programmes. Klartext: Wenn du im selben Skript erst FileOpen und dann FileInUse aufrufst, bekommst du immer "Datei ist in Benutzung" zurück. Darum musst du das Skript so umstricken, dass deine Datei nach jedem Lese-/Schreibvorgang mittels FileClose geschlossen wird.

    Alternativ kann man auch direkt mit den sog. Mandatory Locks von Windows arbeiten. Grundsätzlich muss man dazu wissen, dass Windows eigentlich jede geöffnete Datei automatisch für andere Prozesse sperrt, damit es da keine Probleme oder Informationsverluste gibt. Auf WinAPI-Ebene werden Dateien mittels der API-Funktion CreateFile geöffnet; diese Funktion besitzt einen Parameter, der sich Sharing Mode nennt. Damit kann der Benutzer festlegen, ob diese Sperre erfolgen soll. Standardmäßig ist dies (sinnvollerweise) der Fall. MSDN sagt dazu:

    Zitat


    If this parameter is zero and CreateFile succeeds, the file or device cannot be shared and cannot be opened again until the handle to the file or device is closed.

    Nun, im Prinzip macht AutoIt ja auch nichts anderes, als diese API-Funktionen aufzurufen. Allerdings arbeitet AutoIts FileOpen intern mit dem großzügigsten Share Mode, den es gibt, sodass jeder Prozess alles mit der Datei machen kann. Keine Ahnung, wieso. Wenn wir jetzt unsere Datei mit _WinAPI_CreateFile in AutoIt öffnen, ohne einen solchen Share Mode anzugeben, wird jeder weitere Öffnungsversuch von anderen Prozessen scheitern. Man spricht dann von einem bereits erwähnten Mandatory Lock, unser Prozess hat garantierte, exklusive Zugriffsrechte. Das könnte man sich hier auch zu Nutze machen, Windows sieht das eigentlich auch so vor. Da man dann allerdings nur mit den WinAPI-Funktionen auf die Datei zugreifen könnte, welce nicht ganz so komfortabel wie AutoIts File-Befehle sind, würde man hier wohl mit Kanonen auf Spatzen schießen. Da ist die o.g. Funktion FileInUse die bessere Lösung. Aber in Sprachen, in denen man sich eh auf dieser Ebene bewegt (z.B. C), würde man das so realisieren. ^^

  • Assemblercode - Noch optimierbar?

    • chesstiger
    • 8. Dezember 2016 um 23:12

    Ich habe das ganze mal mittels PThreads und C realisiert. Kompiliert habe ich es unter Debian 8 mit gcc, da Windows aber ebenfalls POSIX-Threads unterstützt, sollte sich das auch mit VC++ oder so für Windows kompilieren lassen.

    Es ist zu beachten, dass durch meine Realisierung des Threadings nur gerade Threadanzahlen möglich sind. So spare ich mir das alternierende Vorzeichen in der Hauptschleife. Mein Lösungsweg kurz dargestellt am Beispiel von 4 Threads:
    Leibniz-Reihe: 1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 - 1/15...
    Thread 1: 1 + 1/9 +...
    Thread 2: 1/3 + 1/11 + ...
    Thread 3: 1/5 + 1/13 + ...
    Thread 4: 1/7 + 1/15 + ...
    Ergebnis: (Thread 1 + Thread 3) - (Thread 2 + Thread 4)
    In Worten: Ich erzeuge Teilsummen bei gleicher Schrittgröße durch unterschiedliche Startwerte. Um das wechselnde Vorzeichen zu beachten, wird am Ende die Summe aller geraden Threads von der Summe der ungeraden Threads subtrahiert. (Mein Programm arbeitet direkt mit Brüchen, die im Zähler 4 stehen haben, um die Multiplikation am Ende zu sparen.)

    Ansonsten... Der C-Code an sich ist total unoptimiert. Es ging hier wirklich nur ums Threading. Außerdem ist die ein oder andere Programmiersünde im Quellcode enthalten. :D

    C
    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    
    
    #define DEBUG 0
    
    
    #define THREADS 5
    #define LOOPSEACH 100000000 / THREADS
    
    
    //Threadfunktion
    static void *loop(void* result) {
        //void* result: Doppelt benutzte Variable
        // 1. Übergabe des Startwertes
        // 2. Rückgabe der Teilsumme
        int i = (int) (*((double*)result));
        const int add = 2*THREADS;
        *((double*)result) = 0.0;
        #if DEBUG
            printf("Enter Thread.\n");
        #endif
        int count = LOOPSEACH;
        while(count--) {
            *((double*)result) += (double)4.0/i;
            i += add;
        }
        #if DEBUG
            printf("Exit Thread.\n");
        #endif
        pthread_exit(0);
    }
    
    
    int main (void) {
        pthread_t threads[THREADS];
        double parts[THREADS];
        double pi = 0.0;
        int error;
        for(int i = 0; i < THREADS; i++) {
            parts[i] = (double)((i * 2) + 1);
            error = pthread_create(&threads[i], NULL, &loop, &parts[i]);
            if(error) {
                #if DEBUG
                    printf("Cannot start Thread %d.\n", i+1);
                #endif
                return EXIT_FAILURE;
            }
        }
    
    
        for(int i = 0; i < THREADS; i++) {
            pthread_join(threads[i], NULL);
            pi += parts[i] * (((i+1)%2) ? +1 : -1); //Vorzeichenwechsel
        }
        printf("Pi: %f\n", pi);
        return EXIT_SUCCESS;
    }
    Alles anzeigen
  • Assemblercode - Noch optimierbar?

    • chesstiger
    • 1. Dezember 2016 um 10:30

    So, ich habe auch nochmal ein wenig rumprobiert. Die Zeitmessung per Linux' time haben wir deswegen gewählt, damit nicht in jeder zu testenden Sprache noch die Zeitmessung selbst implementiert werden muss. Dass da auch einiges an Overhead gemessen wird, ist klar. Das war aber in diesem Moment die praktikabelste Lösung.

    So, jetzt zurück zum Thema. Ich habe meinen Code nach euren Vorschlägen ein wenig optimiert. Allerdings zeigen sich bei mir ein paar interessante Phänomene. Generell ist zum Beispiel fld1 langsamer als fldi dword [one]. Daher ist (bei mir) der Code Nr. 1 auch schneller als der Code Nr. 2 (Unterschiede => 1 arbeitet mit einer Speichervariable zum Zwischenspeichern von Pi, 2 arbeitet komplett auf dem FPU-Stack.).

    Codes


    Nr. 1

    Code
    Use32
    
    
    global main
    extern printf
    
    
    section .data
        pi: dq 0.0
        store: dd 1
        msg: db "Pi: %f",10,0
    
    
    section .text
        main:
        mov ecx, 100000000
        shr ecx, 1
        finit
        fldz ;0
        fld qword [four] ;4;0
    
    
        while:
            ;pos. Bruch 4/... berechnen
            fld st0 ;4;4;pi
            fild dword [store] ;s;4;4;pi
            fdiv ;4/s;4;pi
            faddp st2 ;4;pi+
            add dword [store], 2
    
    
            ;neg. Bruch 4/... berechnen
            fld st0 ;4;4;pi+
            fild dword [store] ;s;4;4;pi+
            fdiv ;4/s;4;pi+
            fsubp st2, st0 ;4;pi
            add dword [store], 2
        ;Schleifenkopf
        loop while
    
    
        fincstp 
        fstp qword [pi] ;[stack leer]
    
    
        ;Ausgabe (printf)
        push dword [pi+4]
        push dword [pi]
        push dword msg
        call printf
        add esp, 12
        mov eax, 0
        ret
    Alles anzeigen


    Nr. 2

    Code
    Use32
    
    
    global main
    extern printf
    
    
    section .data
        pi: dq 0.0
        msg: db "Pi: %f",10,0
    
    
    section .text
        main:
        mov ecx, 100000000
        shr ecx, 1
        finit
        ;Stack aufbauen
        fld1                ;1
        fld1                ;1;1
        fadd st1, st0       ;1;2
        fldz                ;0;1;2
        fld st2             ;2;0;1;2
        fmul st0, st0       ;4;0;1;2
                        ; => 4;pi;s;2
        while:
            ;pos. Bruch 4/s berechnen
            fld st0         ;4;4;pi;s;2
            fld st3         ;s;4;4;pi;s;2
            fdiv            ;4/s;4;pi;s;2
            faddp st2       ;4;pi+;s;2
            ;s um 2 erhöhen
            fld st2         ;s;4;pi+;s;2
            fadd st4        ;s';4;pi+;s;2
            fstp st3        ;4;pi+;s';2 
                            ;s=s'
    
    
            ;neg. Bruch 4/s berechnen
            fld st0         ;4;4;pi+;s;2
            fld st3         ;s;4;4;pi+;s;2
            fdiv            ;4/s;4;pi+;s;2
            fsubp st2, st0  ;4;pi;s;2
            ;s um 2 erhöhen
            fld st2         ;s;4;pi+;s;2
            fadd st4        ;s';4;pi+;s;2
            fstp st3        ;4;pi+;s';2
                            ;s=s'
        ;Schleifenkopf
        loop while
    
    
        fincstp
        fstp qword [pi] ;[stack leer]
    
    
        ;Ausgabe (printf)
        push dword [pi+4]
        push dword [pi]
        push dword msg
        call printf
        add esp, 12
        mov eax, 0
        ret
    Alles anzeigen
  • Assemblercode - Noch optimierbar?

    • chesstiger
    • 23. November 2016 um 22:52

    Ach du je, da habe ich ja was losgetreten. :D
    Ich kann auch mal eine kompilierte Variante anhängen - allerdings nur als ELF. Ich habe zur Zeit keine Windows-Installation mehr.

    Manche von den anfangs genannten Optimierungstipps hatte ich auch schon mal festgestellt - aber keinen Geschwindigkeitsvorteil erreicht. Daher habe ich sie zwecks Lesbarkeit wieder rückgängig gemacht. Als separat kompilierte Assembler-Datei ist der erste Vorschlag von Andy auf meinem System bspw. genau so schnell wie mein Assembler-Code aus dem ersten Post. Da kommt natürlich das Laden der Binärdatei noch hinzu (5.7 KB), Linux' time misst die Laufzeit einer Binärdatei inkl. Ladevorgang.

    Ich probiere morgen mal das ein oder andere hiervon aus und schaue mal, ob das noch was bringt.

  • Assemblercode - Noch optimierbar?

    • chesstiger
    • 21. November 2016 um 21:51

    Hi allerseits,

    bevor ich jetzt mit der Tür ins Haus falle, will ich eben mal die Rahmengeschichte zum Besten geben. Ich habe dieses Jahr mein Informatik-Studium begonnen. Im Modul OOP haben wir neulich im Praktikum einen einfachen Algorithmus zum Berechnen von Pi behandelt (die Leibniz-Reihe). Ein paar anderen erfahreneren Kommilitonen und mir war die reine Implementierung in Java ein bisschen zu fad, daher kamen noch ein paar andere Sprachen hinzu. Irgendwann wurde dann aus der reinen Implementierung ein kleiner Wettkampf um Performance/Geschwindigkeit. Gut, die Implementierungen in PHP oder JavaScript waren dann nicht mehr wirklich konkurrenzfähig. Auch Lua und Python waren nicht die besten Kandidaten. Tatsächlich war die Java-Variante zunächst die schnellste - bis mein C-Programm fertig war. Das war dann dezent schneller. Ein Kommilitone konnte das nicht auf sich sitzen lassen und hat eine eher unbekannte, ungewöhnliche Sprache verwendet: Pony. Auf meinem Netbook (Intel Celeron) braucht die Pony-Variante bei 10.000.000 Schleifendurchläufen mitsamt Ergebnisausgabe knapp 230 ms. Knapp doppelt so schnell wie mein C-Code...
    Also musste jetzt das letzte Register gezogen werden (haha, Register...): Assembler. :thumbup:

    Ich bin bei weitem kein Assembler-Profi. Ich kann zwar damit programmieren, aber die meisten Tricks kenne ich vermutlich nicht. Da das drumherum um den Algorithmus relativ kurz ist, habe ich direkt alles in Assembler geschrieben. Für knappe 20 ms schneller hat es auch gereicht, auf meinem Rechner also ~210 ms im Schnitt. Ich glaube nicht, dass das noch jemand schlägt. Aber ich bin mir fast sicher, dass es da noch Optimierungsmöglichkeiten gibt. Da sich hier auch einige Leute schon ausführlich mit Assembler auseinandergesetzt haben, dachte ich, ich frage mal, ob jemandem noch etwas einfällt. Kompiliert wurde das Ganze bei mir mit nasm, gelinkt mit gcc unter Debian 8. Die Zeiten wurden einfach im Terminal mit time gemessen.

    Code
    global main
    extern printf
    
    
    section .data
        stepc: dd 0
        pi: dq 0.0
        sign: dd 0
        store: dd 1
        four: dq 4.0
        msg: db "Pi: %f",10,0
    
    
    section .text
        main:
        xor edx, edx
    
    
        loop:
        fld qword [pi]
    
    
        ;Bruch 4/... berechnen
        fld qword [four]
        fild dword [store]
        fdiv
    
        ;Vorzeichenwechsel und Addition
        cmp dword [sign], 0
        jnz sub
        fadd
        jmp afteradd
        sub:
        fsub
    
    
        ;Speichern Variable
        afteradd:
        not dword [sign] ;Flag für VZW
        fstp qword [pi]
    
    
        ;Schleifenkopf
        add dword [store], 2
        inc edx
        cmp edx, 10000000
        jnz loop
    
    
        ;Ausgabe (printf)
        push dword [pi+4]
        push dword [pi]
        push dword msg
        call printf
        add esp, 12
        mov eax, 0
        ret
    Alles anzeigen

    Ich denke mal, so ein paar ASM-Kniffe zu kennen, schadet keinem. Hat auf jeden Fall das Potential, sich zu einer spannenden Diskussion zu entwickeln.

    Grüße!

  • Embedded Internet Explorer

    • chesstiger
    • 11. November 2016 um 22:26

    Dein Browser ist auch tatsächlich zu alt. Für eingebettete Internet-Explorer-Instanzen wird (leider) nicht der aktuelle IE verwendet, sondern IE 7. X/
    Frag mich nicht, warum das so ist... Ist aber so. Kannst du auch selber testen, einfach mal per _IENavigate eine Seite wie http://www.meine-browser-version.de/ aufrufen.

    Edit:
    https://www.autoitscript.com/forum/topic/16…html5-in-a-gui/
    So kannst du Einfluss auf den o.g. Sachverhalt nehmen.

  • WINAPI GetLogicalProcessorInformation

    • chesstiger
    • 11. November 2016 um 22:07

    So, fertig. Müsste so klappen. Zumindest produziert das Beispiel bei mir eine sinnvolle Ausgabe.
    Zu erwähnen ist, dass die Funktion a) Quick'n'Dirty umgesetzt ist und b) in der Struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION bei dem Union NumaNode das Byte Flags nur über Umwege lesbar ist (Adresse von NodeNumber holen und Struct mit Byte an selber Stelle erstellen ODER Bit-Operationen mit NodeNumber).

    Kannst ja mal rumprobieren, ob das so passt.

    [autoit]


    #include <Array.au3>
    #include <Memory.au3>

    [/autoit][autoit][/autoit][autoit]

    #cs
    BOOL WINAPI GetLogicalProcessorInformation(
    _Out_ PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
    _Inout_ PDWORD ReturnLength
    );

    [/autoit][autoit][/autoit][autoit]

    AUS: Kernel32.dll
    #ce
    Global Const $RELATIONPROCESSORCORE = 0

    [/autoit][autoit][/autoit][autoit]

    $atSLPI = GetLogicalProcessorInformation()
    $hMem = @extended
    $iCores = 0
    For $i = 0 To UBound($atSLPI) - 1
    If $atSLPI[$i].Relationship = $RELATIONPROCESSORCORE Then
    $iCores += 1
    EndIf
    Next
    ConsoleWrite("Detected " & $iCores & " processor cores on your system." & @CRLF)
    _MemGlobalFree($hMem) ;Immer dran denken, den Speicher wieder freizugeben!!!

    [/autoit][autoit][/autoit][autoit][/autoit][autoit]

    Func GetLogicalProcessorInformation()
    Local $hDll, $hMem, $tBufferSize, $tBuffer, $tSLPI, $atSLPI, $tagSLPI, $iOffset
    $hDll = DllOpen("Kernel32.dll")
    $tBufferSize = DllStructCreate("dword size;")
    DllCall($hDll, "bool", "GetLogicalProcessorInformation", "struct*", 0, "DWORD_PTR", DllStructGetPtr($tBufferSize, "size"))

    [/autoit][autoit][/autoit][autoit]

    $hMem = _MemGlobalAlloc($tBufferSize.size, $GPTR) ;Nötig, da sonst nach Verlassen der Funktion der Speicherbereich freigegeben wird...
    $tBuffer = DllStructCreate("byte[" & $tBufferSize.size & "]", $hMem)
    DllCall($hDll, "bool", "GetLogicalProcessorInformation", "struct*", DllStructGetPtr($tBuffer), "DWORD_PTR", DllStructGetPtr($tBufferSize, "size"))

    [/autoit][autoit][/autoit][autoit]

    $tagSLPI = "ULONG_PTR ProcessorMask; WORD Relationship; STRUCT; DWORD NodeNumber; ENDSTRUCT; STRUCT; BYTE Level; BYTE Associativity; WORD LineSize; DWORD Size; INT Type; ENDSTRUCT; UINT64 Reserved[2]"
    $iOffset = 0
    Local $atSLPI[0]
    While ($iOffset + 40) < $tBufferSize.size
    $tSLPI = DllStructCreate($tagSLPI, DllStructGetPtr($tBuffer) + $iOffset)
    _ArrayAdd($atSLPI, $tSLPI)
    $iOffset += DllStructGetSize($tSLPI)
    WEnd

    [/autoit][autoit][/autoit][autoit]

    DllClose($hDll)
    Return SetExtended($hMem, $atSLPI)
    EndFunc

    [/autoit]
  • SuchString zwischen den ersten und den letzten Buchstaben eines Satzes verwenden

    • chesstiger
    • 10. November 2016 um 21:49

    RegExp nur stumpf nach Tutorial zu lernen ist meist nicht mit allzu viel Erfolg verbunden. Das muss man einfach machen. Dann wird man mit der Zeit immer geschickter.
    Die AutoIt-Hilfe ist eigentlich schon ein guter Anlaufpunkt im Sinne eines Nachschlagwerkes, bei StringRegExp steht eigentlich alles übersichtlich erklärt. Man muss nur einmal das Grundprinzip der regulären Ausdrücke verstanden haben.
    Auf die Gefahr hin, dich noch mehr zu verwirren... Will ich das mal kurz umreißen:

    Erstmal gilt es zu klären, was ein regulärer Ausdruck ist. Im Prinzip beschreibt so ein Ausdruck nur ein gewisses Muster, dem ein Eingabetext folgen muss. In "Pseudocode" könnte ich zum Beispiel bei dem Eingabetext Meine Zahl ist 42, der Sinn des Lebens. sagen: Ich suche zwei Ziffern (von 0 bis 9) hintereinander. Dann wäre das Ergebnis 42. Ich beschreibe also die textliche Form und Umgebung, in der meine gesuchte Information vorliegt und wende dieses allgemeine Muster dann an, um an meine konkrete Information zu gelangen. Mal kurz drüber nachdenken, vielleicht nochmal lesen. Dann sollte es Sinn machen. Normalerweise sollte der Grundgedanke von RegExp dir helfen.

    Dann will ich dir auch noch kurz meinen komplizierten Ausdruck von oben grob erklären.

    Spoiler anzeigen


    (?m) - Das nennt man eine Option. Konkret sorgt m (für multiline) dafür, dass ^ und $ nicht nur Anfang und Ende des gesamten Textes darstellen, sondern auch Zeilenanfang und -ende.
    ^ - Text- oder Zeilenbeginn.
    \Qhttp://top-\E - \Q ... \E bewirken einfach nur, dass der Text dazwischen nicht als RegExp-Befehl interpretiert wird. \Q^\E würde beispielsweise keinen Zeilenanfang darstellen, sondern das Zeichen "^" an sich.
    .*? - Der Punkt bedeutet "Ein beliebiges Zeichen (bis auf Zeilenumbruch)". Das Sternchen bedeutet "beliebig oft". Das Fragezeichen bedeutet "nicht mehr als unbedingt nötig". .* alleine bedeutet also einfach "Beliebig oft ein beliebiges Zeichen" und dient als Universalplatzhalter. Das Fragezeichen ist schon ein wenig komplizierter. Beim regulären Ausdruck A.*C würde bei dem Eingabetext "ACDC" auch "ACDC" gematcht. Ohne Fragezeichen wird also .* als so lang wie möglich angenommen, das hintere C wird verwendet. Bei A.*?C wäre das Ergebnis so kurz wie möglich, also "AC", eben weil das erste C verwendet wird. Ein wenig holprig erklärt, gebe ich zu.
    (?: - Eine sogenannte "Non-Capturing Group". Liest sich wie eine normale Klammer in der Mathematik. Der aussenstehende Operator wird auf alles zwischen (?: und ) angewendet.
    \.exe|\.bat|\.php|\.html - Der Backslash dient zum Maskieren, im Prinzip die Kurzform von \Q...\E. Es wird also nicht ein beliebiges Zeichen gesucht, sondern der Punkt. Der Querstrich bedeutet einfach "Oder".
    ) - Ende der Gruppe (von "(?:").
    $ - Zeilen- oder Textende.
    (\r\n)? - \r\n ist ein Zeilenumbruch unter Windows. Wenn das Fragezeichen ohne einen Stern oder ein Plus da steht, dann liest es sich als "Einmal oder keinmal".

    RegExp zu lernen ist anstrengend. Aber es lohnt sich, glaub mir. Das ist extrem nützlich, nicht nur in AutoIt. ^^

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™