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. BugFix

Beiträge von BugFix

  • strg-Taste bleibt gedrückt

    • BugFix
    • 1. August 2019 um 11:30
    Zitat von Tweaky

    Stimmt, aber so ganz verstehe ich die Funktion nicht.

    Es ist ja nichts drin, wo die strg-Taste wieder losgelassen wird.

    Nein, aber die Funktion feuert Send erst ab, wenn die Tasten freigegeben sind. Ist das nach 1s noch nicht passiert kommt die Fehlermeldung.

  • Checkbox schalten über das Internet - vergleichbar mit Schach online

    • BugFix
    • 31. Juli 2019 um 18:22

    Wenn du schon Erfahrungen hast, geht es also darum, den richtigen Weg zu finden.

    - auf beiden PC brauchst du Server und Client

    - jeweils an unterschiedlichem Port

    - definiere ein Protokoll

    z. B. könntest du nach folgendem Muster senden: '1#1056#NACHRICHT#0'

    # = Trennzeichen

    1 = beginne zu senden

    1056 = Anzahl Bytes der Sendung (gesamter String)

    NACHRICHT = die Nachricht selbst

    0 = fertig mit senden

    Der Empfänger bestätigt dann mit der empfangenen Bytezahl (worauf der Sender wartet). Wird diese Nachricht mit falschem Wert oder außerhalb eines Zeitfensters empfangen, wird erneut gesendet.

    Ich meine mich zu erinnern, dass hier im Forum ein Bsp. zur Interprozesskommunikation existiert, welches auf TCP Basis arbeitet. Such einfach mal.

  • Checkbox schalten über das Internet - vergleichbar mit Schach online

    • BugFix
    • 31. Juli 2019 um 16:50

    Schau mal in der Hilfe die Bsp. zu TCPRec() oder auch UDPRec() an. Du brauchst in beiden Fällen Server und Client um Daten in beiden Richtungen senden und empfangen zu können.

  • Konvertieren zwischen Zahlensystemen in Lua

    • BugFix
    • 31. Juli 2019 um 16:35

    Eigentlich wollte ich nur Dezimalzahlen als Hex ausgeben um Handle zu vergleichen. Aber, wie üblich, war mir die einseitige Nutzung der Funktion zu wenig und ich habe es auf alle Basen von 2 bis 16 angewendet zum Konvertieren von/zu allen Bereichen.

    Nur Dezimal wird als Zahl ein-/ausgegeben, für alle anderen Basen kommen Strings zur Anwendung. Auf Base2 und Base16 kann zusätzlich mit einem Parameter für Länge konvertiert werden. Bei Bedarf werden dann Vornullen eingefügt. Ist die Längenangabe kürzer als das Ergebnis, wird automatisch angepasst. Falsche Längenangaben [<1, >32(2bin), >16(2hex)] werden korrigiert.

    Es gibt eine Universalfunktion (base2base), die alle Typen untereinander konvertiert und vordefinierte Funktionen für die gängigeren Typen (2, 8, 10, 12, 16) untereinander (dec2bin, bin2hex, ...), es entfallen hier die Parameter für Quell- und Zieltyp.

    conversion.lua
    Lua
    -- TIME_STAMP   2021-10-22 10:47:23   v 0.2
    
    do
       conversion = {}
           --[[
           Note:
               With the exception of base10 values, all other values are used as strings.
               Conversion to base2 and to base16 can commit an optional length parameter to insert leading zeros.
               The length is limited for 32bit numbers (base2: 32, base16: 16).
               Base2 values also recognised, if they committed as number (without leading zeros) with max length of 19 characters.
           Syntax:
               load module:    module = require "ModuleName"            i.e. conv = require "conversion"
               function call:    module:FunctionName(param..)            i.e. result = conv:dec2bin(NUM)
                               or
                               module.FunctionName(module, param..)    i.e. result = conv.dec2bin(conv, NUM)
               or
                               require "conversion"                     (without variable assignment)
                               uses the name: "conversion" instead above the own variable "conv"
               universal function for all bases from 2 to 16:
                 conversion.base2base(ValueToConvert, BaseForThisValue, BaseForTheResult[default:10] [,opt. length])
                   default length: for base2 = the result length itself
                                   for base16 = 6
                                   increases automatically, if the result is longer as the given length
               predefined functions for usual base types (2, 8, 10, 12, 16):
                 conversion.FUNCNAME(ValueToConvert [,opt. length])
           --]]
           ------------------------------------------------------------------------------------------------
           -- universal base to base conversion (2...16)
           -- default target is base10
           ------------------------------------------------------------------------------------------------
           conversion.base2base = function(self, _v, _basesource, _basetarget, _len)
               _basetarget = _basetarget or 10
               if _basesource == _basetarget then return _v end
               if (_basesource < 2 or _basesource > 16) or
                  (_basetarget < 2 or _basetarget > 16) then return nil end
               local decsource = self:_base2dec(_v, _basesource)
               if _basetarget == 2 then
                   return self:dec2bin(decsource, _len)
               elseif _basetarget == 16 then
                   return self:dec2hex(decsource, _len)
               else
                   return self:_dec2base(decsource, _basetarget)
               end
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           -- predefined functions for usual base types (2, 8, 10, 12, 16)
           ------------------------------------------------------------------------------------------------
           -- binary
           ------------------------------------------------------------------------------------------------
           conversion.bin2oct = function(self, _b)
               return self:dec2oct(self:bin2dec(_b))
           end
           conversion.bin2dec = function(self, _b)
               return self:_base2dec(_b, 2)
           end
           conversion.bin2duodec = function(self, _b)
               return self:dec2duodec(self:bin2dec(_b))
           end
           conversion.bin2hex = function(self, _b, _len)
               return self:dec2hex(self:bin2dec(_b), _len)
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           -- octal
           ------------------------------------------------------------------------------------------------
           conversion.oct2bin = function(self, _o, _len)
               return self:dec2bin(self:oct2dec(_o), _len)
           end
           conversion.oct2dec = function(self, _o)
               return self:_base2dec(_o, 8)
           end
           conversion.oct2duodec = function(self, _o)
               return self:dec2duodec(self:oct2dec(_o))
           end
           conversion.oct2hex = function(self, _o, _len)
               return self:dec2hex(self:oct2dec(_o), _len)
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           --decimal
           ------------------------------------------------------------------------------------------------
           conversion.dec2bin = function(self, _d, _len)
               local _len = _len or 1
               if _len < 1 then _len = 1 end
               if _len > 32 then _len = 32 end
               local sRet = self:_dec2base(_d, 2)
               local retlen = #sRet
               if _len < retlen then _len = retlen end
               return ('0'):rep(_len-retlen)..sRet
           end
           conversion.dec2oct = function(self, _d)
               return self:_dec2base(_d, 8)
           end
           conversion.dec2duodec = function(self, _d)
               return self:_dec2base(_d, 12)
           end
           conversion.dec2hex = function(self, _d, _len)
               _len = _len or 6
               if _len < 1 then _len = 1 end
               if _len > 16 then _len = 16 end
               local sRet = self:_dec2base(_d, 16)
               local retlen = #sRet
               if retlen > _len then _len = retlen end
               return '0x'..('0'):rep(_len-retlen)..sRet
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           -- duodecimal
           ------------------------------------------------------------------------------------------------
           conversion.duodec2bin = function(self, _dd, _len)
               return self:dec2bin(self:duodec2dec(_dd), _len)
           end
           conversion.duodec2oct = function(self, _dd)
               return self:dec2oct(self:duodec2dec(_dd))
           end
           conversion.duodec2dec = function(self, _dd)
               return self:_base2dec(_dd, 12)
           end
           conversion.duodec2hex = function(self, _dd, _len)
               return self:dec2hex(self:duodec2dec(_dd), _len)
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           -- hexadecimal
           ------------------------------------------------------------------------------------------------
           conversion.hex2bin = function(self, _h, _len)
               return self:dec2bin(self:hex2dec(_h), _len)
           end
           conversion.hex2oct = function(self, _h)
               return self:dec2oct(self:hex2dec(_h))
           end
           conversion.hex2dec = function(self, _h)
               return self:_base2dec(_h, 16)
           end
           conversion.hex2duodec = function(self, _h)
               return self:dec2duodec(self:hex2dec(_h))
           end
           ------------------------------------------------------------------------------------------------
           ------------------------------------------------------------------------------------------------
           -- helper functions
           ------------------------------------------------------------------------------------------------
           conversion._dec2base = function(self, _d, _baseto)
               local tNumstr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}
               local sRet, rest = '', 0
               repeat
                   rest = (_d % _baseto) +1
                   sRet = tNumstr[rest]..sRet
                   _d = math.floor(_d/_baseto)
               until _d == 0
               return sRet
           end
           conversion._base2dec = function(self, _v, _basefrom)
               if _basefrom == 16 then return tonumber(_v) end
               local iRet = 0
               local tNum = {['0']=0,['1']=1,['2']=2,['3']=3,['4']=4,['5']=5,['6']=6,['7']=7,['8']=8,['9']=9,['A']=10,['B']=11,['C']=12,['D']=13,['E']=14}
               if type(_v) ~= 'string' then _v = tostring(_v) end
               for i = #_v, 1, -1 do
                   iRet = iRet + tNum[_v:sub(i,i)] * (_basefrom^(#_v -i))
               end
               return iRet
           end
           ------------------------------------------------------------------------------------------------
    
       return conversion
    end
    Alles anzeigen
    Bsp.
    Lua
    -- load library in local space
    local conv = require 'conversion'
    
    -- conversion with predefined functions
    b10 = 2147483647
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b10:", b10)
    b10_b2 = conv:dec2bin(b10)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b10_b2:", b10_b2)
    b2_b8 = conv:bin2oct(b10_b2)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b2_b8:", b2_b8)
    b8_b12 = conv:oct2duodec(b2_b8)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b8_b12:", b8_b12)
    b12_b16 = conv:duodec2hex(b8_b12)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b12_b16:", b12_b16)
    b16_b10 = conv:hex2dec(b12_b16)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b16_b10:", b16_b10)
    
    -- conversion with universal function
    b10 = 129
    print("\n@@_Debug_line        "..debug.getinfo(1).currentline.." b10:", b10)
    b10_b5 = conv:base2base(b10, 10, 5)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b10_b5:", b10_b5)
    b5_b13 = conv:base2base(b10_b5, 5, 13)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b5_b13:", b5_b13)
    b13_b16 = conv:base2base(b5_b13, 13, 16, 8) -- length 8
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b13_b16:", b13_b16)
    b16_b2 = conv:base2base(b13_b16, 16, 2, 16) -- length 16
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b16_b2:", b16_b2)
    b2_b10 = conv:base2base(b16_b2, 2)
    print("@@_Debug_line        "..debug.getinfo(1).currentline.." b2_b10:", b2_b10)
     
    @@_Debug_line        407 b10:       2147483647
    @@_Debug_line        410 b10_b2:    1111111111111111111111111111111
    @@_Debug_line        413 b2_b8:     17777777777
    @@_Debug_line        416 b8_b12:    4BB2308A7
    @@_Debug_line        419 b12_b16:   0x7FFFFFFF
    @@_Debug_line        422 b16_b10:   2147483647
    @@_Debug_line        427 b10:       129
    @@_Debug_line        430 b10_b5:    1004
    @@_Debug_line        433 b5_b13:    9C
    @@_Debug_line        436 b13_b16:   0x00000081
    @@_Debug_line        439 b16_b2:    0000000010000001
    @@_Debug_line        442 b2_b10:    129
    Alles anzeigen

    Dateien

    conversion.lua 7,28 kB – 374 Downloads
  • strg-Taste bleibt gedrückt

    • BugFix
    • 30. Juli 2019 um 15:22

    Ich sag mal ganz bösartig:

    Weil Hotkeyset und Send einfach Scheißfunktionen sind.

    Wenn ich Hotkey mit STRG verwenden muss, dann immer die kpl. Sequenz: {CTRLDOWN}q{CTRLUP}

    Das löst i.A. das Problem.

  • EditBox TAB-Einrückung

    • BugFix
    • 29. Juli 2019 um 11:13

    Hier wäre interessant zu wissen, wie der Aufbau deiner Word Datei ist, wie der Text formatiert ist (linksbündig, Blocksatz).

    Sofern mitten im Text <Ansprechpartner> ersetzt werden soll, ist es ja auch nicht sinnvoll, wenn dort mehrere untereinander erscheinen. Es müsste erst ein Zeilenumbruch und dann die Liste mit den Ansprechpartnern folgen, sonst hast du einen Stilbruch im Dokument.

    Um sicher zu gehen, trenne den eingelesenen Wert aus der Editbox (StringSplit) und erstelle den Einfügestring aus dem Array selbständig. Dann sieht der String auch so aus, wie du möchtest.

  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 29. Juli 2019 um 10:14
    Zitat von Professor Bernd

    probiere ich noch einen Workaround von BugFix:

    Das enthält aber einen Stolperstein, den du im selbsterstellten Skript beachten musst:

    Wenn du als Verhalten festgelegt hast: Doppelklick auf au3 im Explorer öffnet die Datei in SciTE, musst du das in deinem Skript abfragen (*.au3 wird als Parameter des Aufrufs übergeben) und durchreichen an die echte SciTE.exe.

  • Microsoft "Windows-Diagnose": Button auswählen, sobald dieser vorhanden ist

    • BugFix
    • 29. Juli 2019 um 09:56

    Wenn du das oben gezeigte Fenster auf dem Schirm hast, gehe so vor:

    - Bekommst du das Handle?

    $hWnd = WinGetHandle("Verzeichnisdienst-Diagnose")

    ConsoleWrite("@@_Debug_line" & @TAB & @TAB & @ScriptLineNumber & " var: $hWnd --> " & $hWnd & @LF)

    - wenn ja, hast du Zugriff auf das Control?

    $hButton = ControlGetHandle($hWnd, "Speichern", "[CLASS:Button; INSTANCE:1]")

    oder

    $hButton = ControlGetHandle($hWnd, "", "[CLASS:Button; INSTANCE:1]")

    ConsoleWrite("@@_Debug_line" & @TAB & @TAB & @ScriptLineNumber & " var: $hButton --> " & $hButton & @LF)

    - wenn alles klappt, solltest du auch den Button klicken können:

    ControlClick($hWnd, "", $hButton)


    Und das fertige Skript könnte dann so aussehen:

    Python
    $hWnd = WinWaitActive("Verzeichnisdienst-Diagnose")
    While True
        $hButton = ControlGetHandle($hWnd, "", "[CLASS:Button; INSTANCE:1]")
        If IsHWnd($hButton) Then
            ControlClick($hWnd, "", $hButton)
            ExitLoop
        EndIf
        Sleep(100)
    WEnd
  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 29. Juli 2019 um 09:20

    Professor Bernd

    Jeder hat halt seine eigenen Routinen, wie er arbeitet. Das führt dann auch zu unterschiedlichen Fragestellungen. Deine Vorgehensweise scheint etwas seltener zu sein, sonst hätte wohl schon früher jemand das als Problem bekundet.

    Ich habe mir angewöhnt:

    - au3 zum Bearbeiten öffnen: ausschließlich im geöffneten SciTE über Datei Öffnen

    Das mach ich schon aus dem Grund, weil ansonsten die letzte Session gelöscht wird und nur die geöffnete Datei in SciTE offen ist. Ich bearbeite i.A. aber >5 Dateien in SciTE zeitgleich (u.A. Testumgebungen für Scriptlets und Lua). - Kann natürlich sein, dass ich das Verhalten per Option ändern kann. Aber das ist mir so in Fleisch und Blut übergegangen, dass es kein Problem ist.

    - au3 zum "mal schnell reinschauen": Explorer-Öffnen mit: NPP

    Warum ist es übrigens so kompliziert aus SciTE heraus (also mit Lua Skript) einen Toolbarbutton zu manipulieren?

    Lua unterstützt das Betriebssystem, auf dem es läuft, nur begrenzt (ist ja auch Open Plattform Software). Ich kann vollwertigen Zugriff also nur über die WinApi erlangen. Dafür gibt es die Bibliothek Alien, mit der sich Dateistrukturen und Funktionsaufrufe der Windows *.dll abbilden lassen.

    Wenn man das in AutoIt geschriebene Skript mal auf die verwendeten WinApi Funktionen herunterbricht, ergibt sich folgendes Vorgehen.

    Der schwierige Teil ist, dass die TBBUTTON-Struktur, die die Schaltflächeninformationen empfängt, in demselben Prozess zugewiesen werden muss, in dem sich die Symbolleiste befindet. Dazu muss ich:

    • die Prozess-ID der Symbolleiste abrufen / GetWindowThreadProcessId()
    • ein Handle für diesen Prozess erhalten / OpenProcess()
    • die Struktur innerhalb dieses Prozesses zuweisen / VirtualAllocEx()
    • die TB_GETBUTTON-Nachricht(en) an die Symbolleiste senden und den von VirtualAllocEx() zurückgegebenen Pointer angeben
    • die Strukturdaten wieder in Ihren eigenen Prozess kopieren, damit sie nach Bedarf verarbeitet werden können / ReadProcessMemory()
    • den zugewiesenen Speicher freigeben / VirtualFreeEx()

    In AutoIt passiert das für uns unsichtbar in der GuiToolbar.au3, die wiederum SendMessage.au3, Memory.au3 und Security.au3 verwendet.

    Es ist also nicht unbedingt kompliziert - eher arbeitsintensiv :P


    P.S.

    Ich werde mal die ganze Diskussion nicht löschen (könnte sicher interessant zum Nachschlagen sein), sondern in einen Diskussions-Thread zur FAQ-SciTE verschieben.

  • SciTE in den Vordergrund bringen

    • BugFix
    • 28. Juli 2019 um 11:30
    Zitat von Professor Bernd

    Danach blitzen CMD-Fenster von LUA auf, die zudem auch noch SciTE in den Hintergrund setzen.

    Die CMD Fenster sind nicht von Lua, sondern die von os.execute distanzierten Systemfenster.

    Das SciTE Fenster in den Vordergrund zu holen aus einem im SciTE Prozess laufenden Lua Skript heraus ist nicht ohne Weiteres möglich. Dazu muss man WinApi Funktionen übersetzten und mit Alien für Lua ausführen. Da aber das Einbinden der shell.dll nicht geklappt hat, wird das Einbinden von Alien wohl auch nichts. Zumal hier noch eine Vielzahl von Funktionen übersetzt werden müssten.

  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 28. Juli 2019 um 09:23

    Dazu fällt mir eigentlich nur ein:

    Warum einfach, wenns auch kompliziert geht.

    Und einfach heißt:

    Zitat von BugFix

    Starte die Exe mit dem Autostart und lass sie werkeln. CPU-Bedarf: nicht messbar.

  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 26. Juli 2019 um 22:11

    Wie shell einbinden?

    Detailliert hier beschrieben: Link

  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 26. Juli 2019 um 21:25
    Zitat von Professor Bernd

    aber die CMD-Fenster blitzen bei jedem SciTE-Start auf. Warum benutzt du als Command "start"? Welche Commands gibts denn noch? "Open" habe ich probiert, da passiert gar nichts.

    Das ist der Nachteil bei Verwendung von os.execute - das CMD-Fenster popt kurz auf -- deshalb besser die shell verwenden. :P

    Das Kommando "start" ist nun mal in der Windowswelt der Befehl um einen Programmpfad in der CMD aufzurufen. Link

  • Array2D Problem

    • BugFix
    • 26. Juli 2019 um 14:21

    wuff100

    Du versuchst das Problem zu verallgemeinern, mit einem Lösungsgedanken, der dir vorschwebt.

    Einfacher und für uns verständlicher ist aber, wenn du einen Satz Daten einstellst und sagst: Das ist die Ausgangslage und dann stellst du einen zweiten Satz Daten ein, mit dem gewünschten Ergebnis.

    Momentan ist das Kaffesatzleserei.

  • Array2D Problem

    • BugFix
    • 26. Juli 2019 um 11:30

    Etwas unklar deine Fragestellung.

    Das Ausgangsarray hat 2 Spalten, das Ziel-Array auch. Welche Werte willst du wie bearbeiten?

    Und erstelle sinnvollerweise ein Testskript mit befüllten Arrays (optimal mit deinem Lösungsversuch), damit wir dein Problem etwas besser nachvollziehen können.

  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 26. Juli 2019 um 09:40
    Zitat von Professor Bernd

    (Es will mir nicht behagen, dass 4 Dateien dafür nötig sind!)

    Sind ja auch nicht nötig. Das ist nur für den Fall, wenn du die mit AutoIt erstellte Exe mit SciTE aufrufen willst. Warum? Starte die Exe mit dem Autostart und lass sie werkeln. CPU-Bedarf: nicht messbar.

    Oder wenn du wirklich möchtest, dass diese Datei ausschliesslich gestartet wird, wenn SciTE läuft, ersetze die SciTE.exe durch ein Startprogramm, dass SciTE.exe und das Skript aufruft.

  • Enum in Lua

    • BugFix
    • 25. Juli 2019 um 17:45

    Wenn man in anderen Programmiersprachen unterwegs ist, wird einem erst bewusst, wenn etwas aus AutoIt gewohntes fehlt. In diesem Fall geht es um Enumeration, ist in Lua nicht implementiert.

    Erschwerend zur Gestaltung einer eigenen Funktion kommt hinzu, dass Variablen in Lua immer ByVal sind. Also Variablen deklarieren und ByRef in der Funktion Werte zuweisen geht nicht.

    Ich muss eine variable Anzahl von Werten aus der Funktion zurückgeben. Zum Glück erlaubt Lua den Return mehrerer Werte auf einmal. Die folgende Funktion tut nun was sie soll. Kleiner Schönheitsfehler ist, dass ich als Parameter die Anzahl der zu enumerierenden Werte angeben muss.

    Python: Enum
    ------------------------------------------------------------------------- FUNCTIONS ----------------
    Enum = {}
    
    ----------------------------------------------------------------------------------------------------
    --[[ Enumerates values by step (positive/negative integer)
         _count   The amount of variables to generate values for.
         _step    The step width (+n/-n). Default is 1.
         _start   The start value for the first variable. Default is 0.
      ]]
    ----------------------------------------------------------------------------------------------------
    Enum.ByStep = function(self, _count, _step, _start)
        _step = _step or 1
        return self:Enum(_count, _step, _start)
    end
    ----------------------------------------------------------------------------------------------------
    
    ----------------------------------------------------------------------------------------------------
    --[[ Enumerates values by factor (positive integer)
         _count   The amount of variables to generate values for.
         _factor  The factor for increasing the values. (n^0, n^1, n^2, n^_count-1)
      ]]
    ----------------------------------------------------------------------------------------------------
    Enum.ByFactor = function(self, _count, _factor)
        _factor = _factor or 1
        return self:Enum(_count, _factor, '*')
    end
    ----------------------------------------------------------------------------------------------------
    
    ----------------------------------------------------------------------------------------------------
    --[[ The main enumerating function ]]
    ----------------------------------------------------------------------------------------------------
    Enum.Enum = function(self, _count, _step, _start)
        _start = _start or 0
        local tRet, factor = {}, 1
        if type(_start) == 'string' then
            factor = _step
            _step = 0
            _start = 1
        end
        for i = 1, _count, 1 do
            table.insert(tRet, _start)
            _start = (_start +_step) * factor
        end
        return unpack(tRet)
    end
    ----------------------------------------------------------------------------------------------------
    Alles anzeigen
    Python: Anwendung im Vergleich zu AutoIt
    -- AutoIt: Local Enum $a, $b, $c 
    local a, b, c = Enum:ByStep(3)
    print(a, b, c)
    
    -- AutoIt: Local Enum Step -2 $a = 5, $b, $c 
    local a, b, c = Enum:ByStep(3, -2, 5)
    print(a, b, c)
    
    -- AutoIt: Local Enum Step *4 $a, $b, $c 
    local a, b, c = Enum:ByFactor(3, 4)
    print(a, b, c)
    Alles anzeigen
  • Diskussion zu: FAQ SciTE Editor

    • BugFix
    • 25. Juli 2019 um 09:52
    Zitat von Professor Bernd

    Gibt es vielleicht auch eine Möglichkeit, das "von innen" zu bewerkstelligen, also ohne dass ein extra Programm gestartet werden muss?

    Nein. Lua Skripte sind an kein OS gebunden, was den Nachteil hat, das bestimmte OS-Methoden nicht zur Verfügung stehen. Alle Funktionen, die in dem au3 Skript ausgeführt werden, basieren auf der WinAPI. Es gibt zwar die Möglichkeit, mithilfe der Alien-Bibliothek WinAPI Funktionen in Lua Skripten zu verwenden, aber die Portierung ist recht aufwändig und umfasst in diesem Fall auch eine Vielzahl von Funktionen, sodass Aufwand und Nutzen in keinem Verhältnis stehen.

    Somit ist hier der Weg über ein externes Skript die bessere Lösung.

  • FAQ - SciTE Editor

    • BugFix
    • 23. Juli 2019 um 13:36

    Wie kann man den Toolbar-Speicher-Button ausgrauen, wenn keine Änderung im Script vorhanden, also nichts zu speichern ist?

    Dazu habe ich folgende AutoIt-Lösung erstellt.

    EDIT: Modifikationen von Bitnugger übernommen

    Python: SciTE_EnDisable_SaveBtn.au3
    ;-- TIME_STAMP   2019-07-26 09:32:14
    
    ; created  by @BugFix
    ; modified by @Bitnugger
    
    ; setzt Status des Toolbar-Button <SAVE> abhängig von Erfordernis zu speichern oder nicht auf ENABLE/DISABLE
    ; Skript kompilieren
    ; mit Autostart-Eintrag starten
    ; läuft ständig im Hintergrund, kann mit '"Skript\Pfad" /Exit' beendet werden
    
    
    #NoTrayIcon
    
    #include <Misc.au3>
    #include <WinAPISys.au3>
    #include <GuiToolbar.au3>
    
    Opt('MustDeclareVars', 1)
    
    If Not @Compiled Then Exit 1
    
    Global $g_hUSER32 = DllOpen('user32.dll')
    
    ; Index des gewünschten Button ermitteln
    ; Die Trennstriche zählen mit! Gezählt wird bei 0 beginnend.
    ; Bsp. Button "Save": Davor liegt "Trenner", "NEW", "OPEN" --> "SAVE" ist das 4.te Element - somit Index "3"
    Global Const $g_iIndexSave = 3
    
    If $CMDLINE[0] And $CMDLINE[1] = '/Exit' Then _SciTE_EnDisable_SaveBtn_Exit()
    
    _Singleton('SciTE_EnDisable_SaveBtn') ; Enforce a design paradigm where only one instance of the script may be running
    
    
    While Sleep(500)
        _CheckAndSetState()
    WEnd
    Exit
    
    
    
    Func _CheckAndSetState()
        Local $hScite, $sTitle, $iBtnState, $iNewState, $hWndToolbar, $idCmd, $aResult
    
        $hScite = WinGetHandle('[ACTIVE]')
        $aResult = DllCall($g_hUSER32, "int", "GetClassNameW", "hwnd", $hScite, "wstr", "", "int", 4096)
        If Not @error And $aResult[2] = 'SciTEWindow' Then
            $hWndToolbar = ControlGetHandle($hScite, '', '[CLASS:ToolbarWindow32; INSTANCE:1]')
            $aResult = DllCall($g_hUSER32, "bool", "IsWindowVisible", "hwnd", $hWndToolbar)
            If Not @error And $aResult[0] Then
                $idCmd = _GUICtrlToolbar_IndexToCommand($hWndToolbar, $g_iIndexSave)
                $sTitle = WinGetTitle($hScite)
                If StringRegExp($sTitle, 'SciTE( \[\d+ (of|von) \d+\])?$') Then
                    $iBtnState = _GUICtrlToolbar_GetButtonState($hWndToolbar, $idCmd)
                    If Not StringInStr($sTitle, '*') And BitAND($iBtnState, $TBSTATE_ENABLED) Then
                        $iNewState = BitXOR($iBtnState, $TBSTATE_ENABLED)
                    ElseIf StringInStr($sTitle, '*') And Not BitAND($iBtnState, $TBSTATE_ENABLED) Then
                        $iNewState = BitOR($iBtnState, $TBSTATE_ENABLED)
                    Else
                        Return
                    EndIf
                    _GUICtrlToolbar_SetButtonState($hWndToolbar, $idCmd, $iNewState)
                EndIf
            EndIf
        EndIf
    EndFunc
    
    Func _SciTE_EnDisable_SaveBtn_Exit()
        Local $aWinList = WinList('[CLASS:SciTEWindow]'), $hWndToolbar, $idCmd, $iBtnState, $iNewState, $aProcessList = ProcessList(@ScriptName)
        For $i = 1 To $aProcessList[0][0] Step 1
            If $aProcessList[$i][1] <> @AutoItPID Then ProcessClose($aProcessList[$i][1])
        Next
        For $i = 1 To $aWinList[0][0] Step 1
            $hWndToolbar = ControlGetHandle($aWinList[$i][1], '', '[CLASS:ToolbarWindow32; INSTANCE:1]')
            $idCmd = _GUICtrlToolbar_IndexToCommand($hWndToolbar, $g_iIndexSave)
            $iBtnState = _GUICtrlToolbar_GetButtonState($hWndToolbar, $idCmd)
            $iNewState = BitOR($iBtnState, $TBSTATE_ENABLED)
            If $iNewState <> $iBtnState Then _GUICtrlToolbar_SetButtonState($hWndToolbar, $idCmd, $iNewState)
        Next
        DllClose($g_hUSER32)
        Exit
    EndFunc
    Alles anzeigen

    Die kompilierte Exe über den Autostart laden ist der einfachste Weg. Dann dümpelt das Skript ständig im Hintergrund und tut seine Arbeit, kann aber bei Bedarf auch mit dem Parameter /Exit beendet werden.

    Dateien

    SciTE_EnDisable_SaveBtn.au3 3,14 kB – 780 Downloads
  • Kommandozeilen parsen ( _CmdLine_Parse )

    • BugFix
    • 19. Juli 2019 um 18:01

    zu 1.

    Die Variante hatte ich zuerst. Da ".scr" nicht angegeben wird (ein gern genutztes Einfallstor für Schadcode) habe ich mich auf eine Liste der selbst ausführbaren Dateien beschränkt und die, die einen Interpreter erfordern aussen vor gelassen. - Könnte man aber auch kombinieren.

    zu 2.

    Die Längenangabe war willkürlich, die genaue Angabe für MAXPATH wollte ich noch nachschauen - verpennt.

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™