Beiträge von BugFix

**BugFix**

Zitat von Professor Bernd

Ehrlich water, ich weiß jetzt nicht, was du von mir willst. Ich habe doch alles gemacht, was du schreibst. Was fehlt denn noch?

Nun, vermutlich ist es etwas verwirrend, dass du zum Einen schreibst:

Zitat von Professor Bernd

"CallTip" war nur zur Erklärung, wofür die Lösung benutzt werden kann,

(Betonung auf kann)

andererseits sagst du, dass dies genau der gewünschte Einsatzzweck ist.

Zitat von Professor Bernd

Das soll erweitert werden, sodass ein CallTip auch automatisch angezeigt wird, wenn in PSPad ein "(" eingegeben wird. Da PSPad jedoch genau 0 Events zur Verfügung stellt, bleibt nur die Möglichkeit, in meinem CallTipViewer-Script eine systemweite Erkennung zu implementieren.

Insofern ist es wirklich besser aus dem gezielten Problem keine allgemeine Problematik ableiten zu wollen. Sonst ist man ruck-zuck beim XY-Problem.

Dein Ansatz ist: Key

Vielleicht ist der günstigere Weg tatsächlich: Char

Es fehlt momentan nur noch das Wie.

Deshalb würde ich mal die Fragestellung weiter fassen und dennoch spezifizieren:

'Wie kann ich ein Ereignis auslösen, wenn das OS nach Auswertung einer Tastatureingabe das Zeichen "(" im Puffer hat?'

Findet man den Einstiegspunkt um Char abzufragen, ist es völlig egal was im Vorfeld geschieht.

**BugFix**

Es gibt von Haus aus keine Möglichkeit dafür.

Du musst also zusammentragen, wie das gewünschte Zeichen in jedem existierenden KB-Layout dieser Welt gebildet wird. Dafür erstellst du ein Mapping.

- Dein Programm liest beim Start das verwendete Layout aus.

- Nun weißt Du durch Abgleichen mit deiner Map, welcher Code/Codesequenz in diesem Layout genutzt wird.

- Im Hintergrund deines Skriptes muss ein Keyboard-Hook laufen. Dort wird dann entsprechend des Codes reagiert.

Nicht umsonst liegen die Hotkeys in internationaler Software im Normalfall ausschließlich auf Tasten, die in allen Layouts gleich belegt sind. (a bis z, 0 bis 9, Strg, Umsch, Alt, AltGr, Win).

Wer z. B. den Editor Sublime Text kennt, hat das Problem schon erlebt (Dort wurde das Thema nicht sauber angegangen). Dort wurden standardmäßig Hotkeys für die Mac-Tastatur verwendet. Man musste also erst mal einiges ummappen.

**BugFix**

Ich weiß immer noch nicht, was du nun willst.

Im von mir gezeigten Bsp. ist das Layout egal. Wobei ich vermutet hatte, dass du eine Eingabe in ein Textfeld erwartest.

Dein letzter Post legt nun nahe, dass du einen Hotkey auswerten willst. Falls ja:

Ein Hotkey verwertet immer den Virtual Key Code - und dieser ist abhängig vom Layout. Um das "universal" zu gestalten muss eine Art Übersetzungstabelle bereitgestellt werden, die das ausgelesene Layout den gewünschten Codes zuordnet.

**BugFix**

Zitat von Professor Bernd

aber es geht um eine reine AutoIt Lösung. Ein Script soll unabhängig vom Tastaturlayout ermitteln, ob ein "(" per Tastatur eingegeben wurde.

Nur zur Klarheit: Die Eingabe erfolgt also in einem Input/Editfeld deines Skriptes und das möchtest du auswerten?

Dann geht das so:

AutoIt

#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

Global $charToCheck = "("

Global $hGui = GUICreate('Test')
Global $input = GUICtrlCreateInput('', 10, 20, 200, 20)
Global $hInput = GUICtrlGetHandle($input)

GuiRegisterMsg($WM_COMMAND, "WM_COMMAND")

GUISetState()

Do
Until GUIGetMsg() = -3

Func WM_COMMAND($hWnd, $iMsg, $iwParam, $ilParam)
    Local $hWndFrom = $ilParam
    Local $iIDFrom = BitAND($iwParam, 0xFFFF) ; Low Word
    Local $iCode = BitShift($iwParam, 16) ; Hi Word
    Local $charLast
    Switch $hWndFrom
        Case $hInput
            Switch $iCode
                Case $EN_CHANGE  ; Sent when the user has taken an action that may have altered text in an edit control
                    If StringRight(ControlGetText($hWnd, '', $iIDFrom), 1) = $charToCheck Then ; last Input = '('
                        ConsoleWrite('Last Char was: ' & $charToCheck & @CRLF)
                    EndIf
            EndSwitch
    EndSwitch
    Return $GUI_RUNDEFMSG
EndFunc   ;==>WM_COMMAND

Alles anzeigen

**BugFix**

Kommt drauf an, wo du abfragst. SciTE verwendet das Event "OnChar(char)" unabhängig vom Layout.

**BugFix**

Zitat von blackcho

je nachdem würde ich mir ein Raspberry Pi zulegen/bestellen.

Du solltest vielleicht andersrum anfangen.

• Was will ich machen?

• Welche Hardware ist dafür geeignet? (neben RasPi vermutlich auch Arduino)

• Welche Sprache benötige ich zur Programmierung?

Damit fällt AutoIt schonmal raus (Gründe wie im vorigen Post benannt).

Den RasPi kannst du mit einer Vielzahl von Sprachen programmieren: Von der visuellen Programmierung speziell für Anfänger (Scratch) bis zur CPU-nahen Programmierung mit Assembler.

**BugFix**

Zitat von Masel_tov

Hallo,
das weiß ich wohl. Aber es handelt sich ja hier um das deutsche Forum.

Ja, aber es ist kein Spaßforum. Insofern ist diese Verballhornung nicht angebracht.

Falls du die deutsche Entsprechung verwenden möchtest sind es Symbole.

**BugFix**

Nur der Vollständigkeit halber:

Du meinst das Icon/die Icons.

Ikonen sind Kult- und Heiligenbilder meist auf Holz gemalt.

**BugFix**

Hier mein neuestes Werk:

Eine UDF, die euch das Management für Minimum/Maximum Size von resizeable Windows (Style: SIZEBOX/THICKFRAME) abnimmt.

Die UDF funktioniert auch nur mit GUI, die den korrekten Style haben. Andere werden ignoriert.

Die Anzahl der gleichzeitig zu handelnden GUI ist nicht limitiert.

Es können einzelne oder alle Parameter (min width/height, max width/height) berücksichtigt werden.

Wird ein Parameter auf 0 gesetzt, wird er beim Handling ignoriert. Mit -1 werden die aktuellen Größenwerte übernommen.

Zur Auswahl steht auch die Größe des Fensters oder des Clientbereiches zu verwenden.

Per Option ist wählbar, ob der Minimize-Button das Fenster verkleinert auf die registrierten Minimumwerte (Standard) oder das normale Systemverhalten genutzt wird (minimieren in die Taskbar).

Es gibt eine Funktion mit der alle Parameter auf einmal gesetzt werden können. Alternativ lassen sich einzelne Parameter setzen.

Beim Minimieren und Maximieren wird der bisherige Fenstermittelpunkt beibehalten. Würde dabei die Taskbar oder der Desktoprand überlappt werden, wird die Position automatisch angepasst.

Hier die Liste aller Funktionen, das gibt schon etwas Aufschluss.

_GuiMM_SetMinMax

Setzt die MinMax Parameter für ein Fenster und registriert es für das MinMax Handling, falls noch nicht mit anderer Funktion erfolgt.

_GuiMM_GetMinMax

Gibt ein Array zurück mit den Min/Max Einstellungen. [wMin, hMin, wMax, hMax, bMinimizeToMinSize, bModeWindow]

_GuiMM_Unregister

Entfernt ein Fenster vom MinMax Handling

----------------------------------------------------------------------------------------------------

"_GuiMM_SetMinMax" erlaubt das Setzen aller möglichen Parameter auf einmal.

Die folgenden Funktionen können genutzt werden um einzelne Parameter zu ändern.

_GuiMM_SetMin

Setzt die Minimum-Größe Parameter für ein Fenster und registriert es, falls noch nicht erfolgt

_GuiMM_SetMax

Setzt die Maximum-Größe Parameter für ein Fenster und registriert es, falls noch nicht erfolgt

_GuiMM_SetMinimizeToMin

Setzt das Verhalten des Minimize-Button. Minimieren zu: Minimum-Größe oder Taskbar

_GuiMM_SetWindowMode

Setzt das Min/Max Handling für Fenster- oder Clientgröße

----------------------------------------------------------------------------------------------------

Zum Debuggen:

_GuiMM_DebugRegister

Registriert Input-ID's zum Empfangen der aktuellen Fenster und/oder Client-Rectangle

Im angehängten Beispiel könnt ihr damit experimentieren.

AutoIt: GuiMinMax.au3

;-- TIME_STAMP   2021-01-24 00:07:11   v 0.2

#cs

• MinMax handling for resizeable windows
• Choose to set MinMax values for client- or window- size

----------------------------------------------------------------------------------------------------
Function List

_GuiMM_SetMinMax
    Sets the MinMax parameters for a window and register this for MinMax handling, if not done with other function.

_GuiMM_GetMinMax
    Returns an array with the min/max settings. [wMin, hMin, wMax, hMax, bMinimizeToMinSize, bModeWindow]

_GuiMM_Unregister
    Unregisters a window from MinMax handling

----------------------------------------------------------------------------------------------------

"_GuiMM_SetMinMax" allows the complete setting of all possible parameters at once.
The following functions can be used to set or change single parameters.

_GuiMM_SetMin
    Sets the minimum size parameters for a window and register this, if not done before

_GuiMM_SetMax
    Sets the maximum size parameters for a window and register this, if not done before

_GuiMM_SetMinimizeToMin
    Sets the behaviour of the Minimize-Button. Minimize to: Minimium Size (True)/ Taskbar(False-Default)

_GuiMM_SetWindowMode
    Sets the min/max handling by size of client or window. Client (False - Default) or Window (True)

----------------------------------------------------------------------------------------------------

For Debugging:

_GuiMM_DebugRegister
    Registers input IDs to receive the current window and/or client size

----------------------------------------------------------------------------------------------------
#ce



#include-once
#include <WinAPISysWin.au3>
#include <WindowsConstants.au3>


Opt('MustDeclareVars', 1)
OnAutoItExitRegister("__GuiMM_CleanUp")


Global $g_hMinMaxHook, $g_hMinMaxProc = Null
Global $g_aGuiMinMax[100][9] = [[0]] ; [[counter],[hWnd,widthMin,heightMin,widthMax,heightMax,bMinimizeToMinSize,bMinimized,tCurrPos,bModeWindow], ..]

Global $g_debugID_sizeW = Null  ; for debug: ID that receives the current window size
Global $g_debugID_sizeC = Null  ; for debug: ID that receives the current client size

;===================================================================================================
; Possible values for all min/max in _GuiMM_Set.. functions:
;
;  -1     Uses the current width/height.
;   0     The MinMax handling will ignored from this parameter.
;  Null   The already stored value will used. If not has done from User, the default value (0) will used.
;===================================================================================================
;
;===================================================================================================
; Function Name....: _GuiMM_SetMinMax
; Description......: Sets the MinMax parameters for a window and register this for MinMax handling, if not done before.
; Parameter(s).....: $_hWnd                The handle of the window
;                    $_wMin                The minimum width of the window.
;                    $_hMin                The minimum height of the window.
;                    $_wMax                The maximum width of the window.
;                    $_hMax                The maximum height of the window.
;                    $_bMinimizeToMinSize  The behaviour of the Minimize-Button. Minimize to: Minimium Size (True)/ Taskbar(False-Default)
;                    $_bModeWindow         Handles min/max values by size of client (False - Default) or window (True)
; Return Value(s)..: Success   1
;                    Failure   0 @error=1, hWnd is'nt a window handle
;                                @error=2, window is not resizeable
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_SetMinMax($_hWnd, $_wMin=0, $_hMin=0, $_wMax=0, $_hMax=0, $_bMinimizeToMinSize=False, $_bModeWindow=False)
    If Not IsHWnd($_hWnd) Then Return SetError(1,0,0)
    Local $aParam[] = [$_wMin, $_hMin, $_wMax, $_hMax, $_bMinimizeToMinSize, False, _WinAPI_GetWindowRect($_hWnd), $_bModeWindow]
    Return __GuiMM_ManageWnd($_hWnd, 'setMinMax', $aParam)
EndFunc  ;==>_GuiMM_SetMinMax


;===================================================================================================
; Function Name....: _GuiMM_GetMinMax
; Description......: Returns an array with the min/max settings.
; Parameter(s).....: $_hWnd    The handle of the window
; Return Value(s)..: Success   Array [wMin, hMin, wMax, hMax, bMinimizeToMinSize, bModeWindow]
;                    Failure   set @error = 1 hWnd is'nt a window handle
;                                  @error = 2 (none registered window), empty array
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_GetMinMax($_hWnd)
    If Not IsHWnd($_hWnd) Then Return SetError(1,0,0)
    Return __GuiMM_ManageWnd($_hWnd, 'getMinMax')
EndFunc  ;==>_GuiMM_GetMinMax


;===================================================================================================
; Function Name....: _GuiMM_SetMin
; Description......: Sets the minimum parameters for a window and register this, if not done before
; Parameter(s).....: $_hWnd    The handle of the window
;                    $_wMin    The minimum width of the window. -1 (Default) uses the current width.
;                    $_hMin    The minimum height of the window. -1 (Default) uses the current height.
; Return Value(s)..: Success   1
;                    Failure   0 @error = 1 hWnd is'nt a window handle
;                                @error = 2 window is not resizeable
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_SetMin($_hWnd, $_wMin=-1, $_hMin=-1)
    Return _GuiMM_SetMinMax($_hWnd, $_wMin, $_hMin, Null, Null, Null)
EndFunc  ;==>_GuiMM_SetMin


;===================================================================================================
; Function Name....: _GuiMM_SetMax
; Description......: Sets the maximum parameters for a window and register this, if not done before
; Parameter(s).....: $_hWnd    The handle of the window
;                    $_wMax    The maximum width of the window. -1 (Default) uses the current width.
;                    $_hMax    The maximum height of the window. -1 (Default) uses the current height.
; Return Value(s)..: Success   1
;                    Failure   0 @error = 1 hWnd is'nt a window handle
;                                @error = 2 window is not resizeable
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_SetMax($_hWnd, $_wMax=-1, $_hMax=-1)
    Return _GuiMM_SetMinMax($_hWnd, Null, Null, $_wMax, $_hMax, Null)
EndFunc  ;==>_GuiMM_SetMax


;===================================================================================================
; Function Name....: _GuiMM_SetMinimizeToMin
; Description......: Sets the behaviour of the Minimize-Button.
; Parameter(s).....: $_hWnd                The handle of the window
;                    $_bMinimizeToMinSize  Minimize to: minimium size (True-Default)/ Taskbar(False)
; Return Value(s)..: Success   1
;                    Failure   0 @error = 1 hWnd is'nt a window handle
;                                @error = 2 window is not resizeable
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_SetMinimizeToMin($_hWnd, $_bMinimizeToMinSize=True)
    Return _GuiMM_SetMinMax($_hWnd, Null, Null, Null, Null, $_bMinimizeToMinSize)
EndFunc  ;==>_GuiMM_SetMinimizeToMin


;===================================================================================================
; Function Name....: _GuiMM_SetWindowMode
; Description......: Sets the min/max handling by size of client or window
; Parameter(s).....: $_hWnd           The handle of the window
;                    $_bModeWindow    Use size of: client (False - Default) or window (True)
; Return Value(s)..: Success   1
;                    Failure   0 @error = 1 hWnd is'nt a window handle
;                                @error = 2 window is not resizeable
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_SetWindowMode($_hWnd, $_bModeWindow=False)
    Return _GuiMM_SetMinMax($_hWnd, Null, Null, Null, Null, Null, $_bModeWindow)
EndFunc  ;==>_GuiMM_SetWindowMode


;===================================================================================================
; Function Name....: _GuiMM_Unregister
; Description......: Unregisters a window from MinMax handling
; Parameter(s).....: $_hWnd    The handle of the window
; Return Value(s)..: Success   1
;                    Failure   0 @error = 1 hWnd is'nt a window handle
;                                @error = 2 hWnd is'nt registered
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_Unregister($_hWnd)
    If Not IsHWnd($_hWnd) Then Return SetError(1,0,0)
    Return __GuiMM_ManageWnd($_hWnd, 'unRegister')
EndFunc  ;==>_GuiMM_Unregister


;===================================================================================================
; Function Name....: _GuiMM_DebugRegister
; Description......: For debugging: Registers input IDs to receive the current window and/or client size
; Parameter(s).....: $_ID_sizeW   ID to receive the window size, "-1" don't set this param
;                    $_ID_sizeC   ID to receive the client size, "-1" don't set this param
; Return Value(s)..: None
; Author...........: BugFix
;===================================================================================================
Func _GuiMM_DebugRegister($_ID_sizeW=-1, $_ID_sizeC=-1)
    If $_ID_sizeW <> -1 Then $g_debugID_sizeW = $_ID_sizeW
    If $_ID_sizeC <> -1 Then $g_debugID_sizeC = $_ID_sizeC
EndFunc  ;==>_GuiMM_DebugRegister


#Region - internal


; [[counter],[hWnd,widthMin,heightMin,widthMax,heightMax,bMinimizeToMinSize,bMinimized,tCurrPos,bModeWindow], ..]
Func __GuiMM_ManageWnd($_hWnd, $_action='getIndex', $_aParam=Null)
    Local $index = -1, $n
    Switch $_action
        Case 'getIndex'
            If $g_aGuiMinMax[0][0] = 0 Then
                Return -1
            Else
                For $i = 1 To $g_aGuiMinMax[0][0]
                    If $g_aGuiMinMax[$i][0] = $_hWnd Then
                        $index = $i
                        ExitLoop
                    EndIf
                Next
                Return $index
            EndIf
        Case 'setMinMax'
            ; only resizeable windows will registered
            If Not __IsResizeable($_hWnd) Then Return SetError(2,0,0)
            $n = __GuiMM_ManageWnd($_hWnd)      ; get Index, if "-1": it's a new registered window
            __GuiMM_Set($n, $_hWnd, $_aParam)
            If $n = -1 Then
                ; if it's the 1.st registered window, our own window procedure will now registered
                If $g_hMinMaxProc = Null Then $g_hMinMaxProc = DllCallbackRegister('__GuiMM_WinProc', 'ptr', 'hwnd;uint;wparam;lparam')
                ; change the default window procedure to our own procedure
                $g_hMinMaxHook = _WinAPI_SetWindowLong($_hWnd, $GWL_WNDPROC, DllCallbackGetPtr($g_hMinMaxProc))
            EndIf
            Return 1
        Case 'getMinMax'
            Local $aRet[6] = [0,0,0,0,True,False]
            $index = __GuiMM_ManageWnd($_hWnd)
            If $index = -1 Then Return SetError(2,0,$aRet)
            $aRet[0] = $g_aGuiMinMax[$index][1] ; wMin
            $aRet[1] = $g_aGuiMinMax[$index][2] ; hMin
            $aRet[2] = $g_aGuiMinMax[$index][3] ; wMax
            $aRet[3] = $g_aGuiMinMax[$index][4] ; hMax
            $aRet[4] = $g_aGuiMinMax[$index][5] ; bMinimizeToMinSize
            $aRet[5] = $g_aGuiMinMax[$index][8] ; bModeWindow
            Return $aRet
        Case 'unRegister'
            $n = __GuiMM_ManageWnd($_hWnd)      ; get Index
            Return ($n = -1 ? SetError(2,0,0) : __GuiMM_UnRegister($n)) ; @error: a unregistered window cannot be removed
    EndSwitch
EndFunc  ;==>__GuiMM_ManageWnd


Func __GuiMM_Set($_index, $_hWnd, $_aParam)
    If $_index = -1 Then
        $g_aGuiMinMax[0][0] += 1
        $_index = $g_aGuiMinMax[0][0]
        If $g_aGuiMinMax[0][0] = UBound($g_aGuiMinMax) Then ReDim $g_aGuiMinMax[$g_aGuiMinMax[0][0]+100][9]
    EndIf
    Local $w = _WinAPI_GetWindowWidth($_hWnd)
    Local $h = _WinAPI_GetWindowHeight($_hWnd)
    $g_aGuiMinMax[$_index][0] = $_hWnd

    ; param (min/max W/H): -1 = current W/H
    ;                       0 = 0 (none min/max handling)
    ;                    Null = use the already stored value
    $g_aGuiMinMax[$_index][1] = _ ; wMin
        $_aParam[0] = -1 ? $w : ($_aParam[0] <> Null ? $_aParam[0] : $g_aGuiMinMax[$_index][1])
    $g_aGuiMinMax[$_index][2] = _ ; hMin
        $_aParam[1] = -1 ? $w : ($_aParam[1] <> Null ? $_aParam[1] : $g_aGuiMinMax[$_index][2])
    $g_aGuiMinMax[$_index][3] = _ ; wMax
        $_aParam[2] = -1 ? $w : ($_aParam[2] <> Null ? $_aParam[2] : $g_aGuiMinMax[$_index][3])
    $g_aGuiMinMax[$_index][4] = _ ; hMax
        $_aParam[3] = -1 ? $w : ($_aParam[3] <> Null ? $_aParam[3] : $g_aGuiMinMax[$_index][4])
    $g_aGuiMinMax[$_index][5] = $_aParam[4] = Null ? $g_aGuiMinMax[$_index][5] : $_aParam[4]    ; bMinimizeToMinSize
    $g_aGuiMinMax[$_index][6] = $_aParam[5] = Null ? $g_aGuiMinMax[$_index][6] : $_aParam[5]    ; bMinimized
    $g_aGuiMinMax[$_index][7] = $_aParam[6] ; curr Rect
    $g_aGuiMinMax[$_index][8] = $_aParam[7] ; bModeWindow
EndFunc  ;==>__GuiMM_Set


Func __GuiMM_UnRegister($_index)
    ; reset to default window procedure
    _WinAPI_SetWindowLong($g_aGuiMinMax[$_index][0], $GWL_WNDPROC, $g_hMinMaxHook)

    ; move from last entry to index that should be removed
    For $i = 0 To 8
        $g_aGuiMinMax[$_index][$i] = $g_aGuiMinMax[$g_aGuiMinMax[0][0]][$i]
    Next

    ; reset all entries from last used index
    For $i = 0 To 8
        If $i = 5 Or $i = 6 Or $i = 8 Then
            $g_aGuiMinMax[$g_aGuiMinMax[0][0]][$i] = False
        Else
            $g_aGuiMinMax[$g_aGuiMinMax[0][0]][$i] = 0
        EndIf
    Next

    ; decrease the counter
    $g_aGuiMinMax[0][0] -= 1
    Return 1
EndFunc  ;==>__GuiMM_UnRegister


Func __GuiMM_WinProc($_hWnd, $_iMsg, $_iwParam, $_ilParam)
    If ($_iMsg <> $WM_WINDOWPOSCHANGING And $_iMsg <> $WM_WINDOWPOSCHANGED And $_iMsg <> $WM_SYSCOMMAND) Then _
        Return _WinAPI_CallWindowProc($g_hMinMaxHook, $_hWnd, $_iMsg, $_iwParam, $_ilParam)
    Local $index = __GuiMM_ManageWnd($_hWnd)
    If $index = -1 Then Return _WinAPI_CallWindowProc($g_hMinMaxHook, $_hWnd, $_iMsg, $_iwParam, $_ilParam) ; default Window processing

    Local $wMin               = $g_aGuiMinMax[$index][1]
    Local $hMin               = $g_aGuiMinMax[$index][2]
    Local $wMax               = $g_aGuiMinMax[$index][3]
    Local $hMax               = $g_aGuiMinMax[$index][4]
    Local $bMinimizeToMinSize = $g_aGuiMinMax[$index][5]
    Local $bMinimized         = $g_aGuiMinMax[$index][6]
    Local $tCurrRect          = $g_aGuiMinMax[$index][7]
    Local $bModeWindow        = $g_aGuiMinMax[$index][8]

    ; if size is in client mode (NOT $bModeWindow) calculate the resulting min/max for the window
    ; all calculations uses the bounding rect of the window
    If Not $bModeWindow Then
        Local $iW_Diff = _WinAPI_GetWindowWidth($_hWnd) - _WinAPI_GetClientWidth($_hWnd)
        Local $iH_Diff = _WinAPI_GetWindowHeight($_hWnd) - _WinAPI_GetClientHeight($_hWnd)
        $wMin = $wMin = 0 ? 0 : $wMin + $iW_Diff
        $wMax = $wMax = 0 ? 0 : $wMax + $iW_Diff
        $hMin = $hMin = 0 ? 0 : $hMin + $iH_Diff
        $hMax = $hMax = 0 ? 0 : $hMax + $iH_Diff
    EndIf

    If (Not $bMinimizeToMinSize) And $bMinimized Then ; now RESTORE, use size & pos from before minimized ($tCurrRect)
        $g_aGuiMinMax[$index][6] = False ; $bMinimized
        _WinAPI_SetWindowPos($_hWnd, $HWND_TOP, _
                             $tCurrRect.Left, $tCurrRect.Top, $tCurrRect.Right - $tCurrRect.Left, $tCurrRect.Bottom - $tCurrRect.Top, _
                             BitOR($SWP_FRAMECHANGED,$SWP_NOSENDCHANGING,$SWP_SHOWWINDOW)) ; prevents 1-time from WM_WINDOWPOSCHANGING
        Return 0                         ; avoid default window processing
    EndIf
    Local $tRectWnd = _WinAPI_GetWindowRect($_hWnd)
    $g_aGuiMinMax[$index][7] = $tRectWnd ; $tCurrRect, store current rect to use for RESTORE
    Local $iW_Wnd = $tRectWnd.Right - $tRectWnd.Left
    Local $iH_Wnd = $tRectWnd.Bottom - $tRectWnd.Top
    Local $iX_Wnd = $tRectWnd.Left
    Local $iY_Wnd = $tRectWnd.Top

    If $_iMsg = $WM_SYSCOMMAND Then
        If $_iwParam = 0xF020 Then ; $SC_MINIMIZE
            If $bMinimizeToMinSize Then ; none MINIMIZE, instead move window to minimal size with current center point
                ; center point of the current window position
                Local $xCenter = $iX_Wnd + Int($iW_Wnd/2)
                Local $yCenter = $iY_Wnd + Int($iH_Wnd/2)
                ; if min/max = 0 ? ==> this value will not changed
                WinMove($_hWnd, '', ($wMin > 0 ? ($xCenter - Int($wMin/2)) : $iX_Wnd), _
                                    ($hMin > 0 ? ($yCenter - Int($hMin/2)) : $iY_Wnd), _
                                    ($wMin > 0 ? $wMin : $iW_Wnd), _
                                    ($hMin > 0 ? $hMin : $iH_Wnd))
                __GuiMM_DebugSize($_hWnd)
                Return 0                        ; avoid default window processing
            Else                                ; the default behaviour of $SC_MINIMIZE (minimize to taskbar)
                $g_aGuiMinMax[$index][6] = True ; $bMinimized, trigger to detect the RESTORE (next window msg is the restore msg)
                Return _WinAPI_CallWindowProc($g_hMinMaxHook, $_hWnd, $_iMsg, $_iwParam, $_ilParam) ; default Window processing
            EndIf
        EndIf
    EndIf

    If $_iMsg = $WM_WINDOWPOSCHANGING Then
        Local $tWINDOWPOS = DllStructCreate("struct; HWND hwndInsertAfter;HWND hwnd;INT x;INT y;INT cx;INT cy;UINT flags; endstruct", $_ilParam)
        ; undocumented flags: 0x8000, 0x1000 and 0x0800
        Local Const $SWP_FROZENWINDOW = 0x8000

        Local $tBorders = __GuiMM_GetBorders()
        Local $xBorderL = $tBorders.left
        Local $yBorderT = $tBorders.top
        Local $xBorderR = $tBorders.right
        Local $yBorderB = $tBorders.bottom
        ; min/max = 0 ? ==> none min/max handling for this value, set to 0/real borders
        $wMin = $wMin = 0 ? 0 : $wMin
        $hMin = $hMin = 0 ? 0 : $hMin
        $wMax = $wMax = 0 ? ($xBorderR - $xBorderL) : $wMax
        $hMax = $hMax = 0 ? ($yBorderB - $yBorderT) : $hMax

        Local $aMaxPos = __GuiMM_MaxPosCalc($wMax, $hMax, $iX_Wnd + Int($iW_Wnd/2), $iY_Wnd + Int($iH_Wnd/2))
        If $tWINDOWPOS.cx < $wMin Then  ; target width too small
            $tWINDOWPOS.cx = $wMin      ; set to min
            $tWINDOWPOS.x = $iX_Wnd     ; keep the current x value
        EndIf
        If $tWINDOWPOS.cy < $hMin Then  ; target height too small
            $tWINDOWPOS.cy = $hMin      ; set to min
            $tWINDOWPOS.y = $iY_Wnd     ; keep the current y value
        EndIf
        If $tWINDOWPOS.cx > $wMax Then  ; target width too large
            $tWINDOWPOS.cx = $wMax      ; set to max
            $tWINDOWPOS.x = $aMaxPos[0] ; calculated by current center position
        EndIf
        If $tWINDOWPOS.cy > $hMax Then  ; target height too large
            $tWINDOWPOS.cy = $hMax      ; set to max
            $tWINDOWPOS.y = $aMaxPos[1] ; calculated by current center position
        EndIf
        If (BitAND($tWINDOWPOS.flags, $SWP_FROZENWINDOW)) Then _WinAPI_ShowWindow($_hWnd, @SW_RESTORE)

        Return 0 ; avoid default window processing
    EndIf

    If $_iMsg = $WM_WINDOWPOSCHANGED Then
        __GuiMM_DebugSize($_hWnd)
    EndIf
    Return _WinAPI_CallWindowProc($g_hMinMaxHook, $_hWnd, $_iMsg, $_iwParam, $_ilParam) ; default Window processing
EndFunc  ;==>__GuiMM_WinProc


Func __GuiMM_MaxPosCalc($_wMax, $_hMax, $_xCenter, $_yCenter)
    Local $tBorders = __GuiMM_GetBorders()
    Local $xBorderL = $tBorders.left
    Local $yBorderT = $tBorders.top
    Local $xBorderR = $tBorders.right
    Local $yBorderB = $tBorders.bottom

    ; Try to use the same center point. If there is an overlap with the taskbar or desktop border, the position will be corrected
    Local $xMax = $_xCenter - (Int($_wMax/2))
    If $xMax < 0 Then
        $xMax = $xBorderL
    Else
        If $xMax + $_wMax > $xBorderR Then $xMax = $xBorderR - $_wMax
    EndIf
    Local $yMax = $_yCenter - (Int($_hMax/2))
    If $yMax < 0 Then
        $yMax = $yBorderT
    Else
        If $yMax + $_hMax > $yBorderB Then $yMax = $yBorderB - $_hMax
    EndIf
    Local $aRet[] = [$xMax,$yMax]
    Return $aRet
EndFunc  ;==>__GuiMM_MaxPosCalc


Func __GuiMM_GetBorders()
    Local Static $tBorders = DllStructCreate('struct;int left;int top;int right;int bottom;endstruct')
    Local Static $xBorderL = 0
    Local Static $yBorderT = 0
    Local Static $xBorderR = @DesktopWidth
    Local Static $yBorderB = @DesktopHeight

    ; get Taskbar properties
    Local $tTB = _GetTaskBarProps(True)
    ; if always on top: calculate borders
    If Not $tTB.autohide Then  ; .uEdge  0, 1, 2, 3 = 'LEFT', 'TOP', 'RIGHT', 'BOTTOM'
        If $tTB.uEdge = 0 Then $xBorderL  = ($tTB.right  - $tTB.left) ; left   (width of TB)
        If $tTB.uEdge = 1 Then $yBorderT  = ($tTB.bottom - $tTB.top)  ; top    (height of TB)
        If $tTB.uEdge = 2 Then $xBorderR -= ($tTB.right  - $tTB.left) ; right  (desk width - width of TB)
        If $tTB.uEdge = 3 Then $yBorderB -= ($tTB.bottom - $tTB.top)  ; bottom (desk height - height of TB)
    EndIf
    $tBorders.left   = $xBorderL
    $tBorders.top    = $yBorderT
    $tBorders.right  = $xBorderR
    $tBorders.bottom = $yBorderB

    Return $tBorders
EndFunc  ;==>__GuiMM_GetBorders


Func __GuiMM_CleanUp()
    If $g_hMinMaxProc = Null Then Return
    For $i = 1 To $g_aGuiMinMax[0][0]  ; reset to default window procedure
        If WinExists($g_aGuiMinMax[$i][0]) Then _WinAPI_SetWindowLong($g_aGuiMinMax[$i][0], $GWL_WNDPROC, $g_hMinMaxHook)
    Next
    DllCallbackFree($g_hMinMaxProc)
EndFunc  ;==>__GuiMM_CleanUp


Func __IsResizeable($_hWnd)
    Return (BitAND(_WinAPI_GetWindowLong($_hWnd, -16), 0x00040000) = 0x00040000)
EndFunc  ;==>__IsResizeable


Func __GuiMM_DebugSize($_hWnd)
    If $g_debugID_sizeW <> Null Then
        Local $tW = _WinAPI_GetWindowRect($_hWnd)
        GUICtrlSetData($g_debugID_sizeW, __RectToStr($tW))
    EndIf
    If $g_debugID_sizeC <> Null Then
        Local $tC = _WinAPI_GetClientRect($_hWnd)
        GUICtrlSetData($g_debugID_sizeC, __RectToStr($tC))
    EndIf
EndFunc  ;==>__GuiMM_DebugSize


Func __RectToStr($_tRect)
    Return StringFormat('%d, %d, %d, %d', $_tRect.left, $_tRect.top, $_tRect.right, $_tRect.bottom)
EndFunc  ;==>__RectToStr



#EndRegion - internal


;===================================================================================================
; Function Name....: _GetTaskBarProps
; Description......: gibt Eigenschaften und Position der Taskbar zurück
; Parameter(s).....: [optional] $_bReturnStruct - Rückgabe als (True) Struktur, (False - Standard) Array
; Return Value(s)..: Array / Struktur mit den Taskbarwerten
; Author...........: BugFix
;===================================================================================================
Func _GetTaskBarProps($_bReturnStruct=False)
    Local Const $ABM_GETSTATE = 0x4         ; specify the cbSize.
    Local Const $ABM_GETTASKBARPOS = 0x5    ; specify the cbSize.
    Local Const $ABM_GETAUTOHIDEBAR = 0x7   ; specify the cbSize and uEdge. Returns the handle to the autohide appbar

    ; ABM_GETSTATE
    Local Const $ABS_AUTOHIDE = 0x1
    Local Const $ABS_ALWAYSONTOP = 0x2  ; ab Win7 nicht mehr!! --> wenn NICHT $ABS_AUTOHIDE ist es $ABS_ALWAYSONTOP

    ; uEdge - ABM_GETAUTOHIDEBAR
    Local Const $ABE_LEFT = 0
    Local Const $ABE_TOP = 1
    Local Const $ABE_RIGHT = 2
    Local Const $ABE_BOTTOM = 3

    Local $hWndAppBar = DllCall("user32.dll", 'long', "FindWindowA", 'str', "Shell_traywnd", 'str', "")[0]
    Local $iState, $iEdge, $hWnd, $shell32 = DllOpen("shell32")
    Local $tRC = DllStructCreate("struct;int left;int top;int right;int bottom;endstruct")
    Local $tAPPBARDATA = DllStructCreate("dword cbSize;int hWnd;uint;uint uEdge;int left;int top;int right;int bottom;int")
    $tAPPBARDATA.cbSize = DllStructGetSize($tAPPBARDATA)
    $tAPPBARDATA.hWnd = $hWndAppBar

    ; get pos
    Local $ret = DllCall($shell32, 'int', 'SHAppBarMessage', 'int', $ABM_GETTASKBARPOS, 'ptr', DllStructGetPtr($tAPPBARDATA))
    For $i = 1 To 4
        DllStructSetData($tRC, $i, DllStructGetData($tAPPBARDATA, $i+4))
    Next

    ; get state
    $ret = DllCall($shell32, 'int', 'SHAppBarMessage', 'int', $ABM_GETSTATE, 'ptr', DllStructGetPtr($tAPPBARDATA))
    $iState = $ret[0]

    ; get Edge
    If $iState = $ABS_AUTOHIDE Then
        For $i = $ABE_LEFT To $ABE_BOTTOM
            $tAPPBARDATA.uEdge = $i
            $ret = DllCall($shell32, 'int', 'SHAppBarMessage', 'int', $ABM_GETAUTOHIDEBAR, 'ptr', DllStructGetPtr($tAPPBARDATA))
            $hWnd = $ret[0]
            If $hWnd Then
                $iEdge = $i
                ExitLoop
            EndIf
        Next
    Else
        If $tRC.top < 1 And $tRC.left < 1 Then
                If $tRC.bottom > $tRC.right Then $iEdge = 0
                If $tRC.right > $tRC.bottom Then $iEdge = 1
        ElseIf $tRC.top < 1 And $tRC.left > 0 Then
            $iEdge = 2
        Else
            $iEdge = 3
        EndIf
    EndIf
    DllClose($shell32)

    ; return array or structure: [.hWnd, .autohide(True/False), .uEdge(0..3), .sEdge(left..bottom), .left, .top, .right, .bottom]
    Local $aEdge[] = ['LEFT','TOP','RIGHT','BOTTOM']
    Local $aRet[] = [$hWndAppBar, ($iState = $ABS_AUTOHIDE), $iEdge, $aEdge[$iEdge], $tRC.left, $tRC.top, $tRC.right, $tRC.bottom]
    Local $tRet = DllStructCreate('int hWnd;bool autohide;uint uEdge;char sEdge[' & StringLen($aEdge[$iEdge]) & '];int left;int top;int right;int bottom;')
    For $i = 0 To UBound($aRet) -1
        DllStructSetData($tRet, $i+1, $aRet[$i])
    Next

    Return ($_bReturnStruct ? $tRet : $aRet)
EndFunc  ;==>_GetTaskBarProps

Alles anzeigen

AutoIt: GuiMinMax_Example.au3

;-- TIME_STAMP   2021-01-24 00:06:54

Opt('MustDeclareVars', 1)

#include 'GuiMinMax.au3'
#include <GUIConstantsEx.au3>

_Example()

Func _Example()
    Local $hMain = GUICreate('Set Min/Max', 300, 400, 70, 70)
    GUISetFont(8.5, 0, 0, 'Consolas')
    GUIStartGroup()
    GUICtrlCreateLabel('Setting Gui', 10, 13, 80)
    Local $r1 = GUICtrlCreateRadio(' GUI 1', 140, 10, 60)
    GUICtrlSetState(-1, $GUI_CHECKED)
    Local $r2 = GUICtrlCreateRadio(' GUI 2', 220, 10, 60)
    GUICtrlCreateLabel('Minimum  width | height', 10, 43, 150)
    Local $inMinW = GUICtrlCreateInput('', 160, 40, 60, 20)
    Local $inMinH = GUICtrlCreateInput('', 230, 40, 60, 20)
    GUICtrlCreateLabel('Maximum  width | height', 10, 73, 150)
    Local $inMaxW = GUICtrlCreateInput('', 160, 70, 60, 20)
    Local $inMaxH = GUICtrlCreateInput('', 230, 70, 60, 20)
    GUICtrlCreateLabel('Minimize Button minimizes to', 10, 103, 100, 30)
    GUIStartGroup()
    Local $r3 = GUICtrlCreateRadio(' MinSize', 140, 104, 70)
    GUICtrlSetState(-1, $GUI_CHECKED)
    Local $r4 = GUICtrlCreateRadio(' Taskbar', 220, 104, 70)
    Local $cb = GUICtrlCreateCheckbox(' Using window size instead of client size', 10, 140)
    Local $btGui1 = GUICtrlCreateButton('Show Gui1', 10, 170, 80, 20)
    Local $btGui2 = GUICtrlCreateButton('Show Gui2', 100, 170, 80, 20)
    Local $btSet = GUICtrlCreateButton('Apply', 210, 170, 80, 20)
    GUICtrlCreateLabel('Possible values for min/max settings', 10, 230)
    GUICtrlCreateLabel('  -1', 10, 247)
    GUICtrlCreateLabel('Uses the current width/height', 50, 247)
    GUICtrlCreateLabel('   0', 10, 264)
    GUICtrlCreateLabel('The MinMax handling will ignored from this parameter', 50, 264, 200, 30)
    GUICtrlCreateLabel('Current Rectangle', 10, 320)
    GUICtrlCreateLabel('Window', 50, 343)
    Local $inRectW = GUICtrlCreateInput('', 120, 340, 170, 20, 0x0800) ; $ES_READONLY
    GUICtrlSetBkColor(-1, 0xFFFFFF)
    GUICtrlCreateLabel('Client', 50, 373)
    Local $inRectC = GUICtrlCreateInput('', 120, 370, 170, 20, 0x0800)
    GUICtrlSetBkColor(-1, 0xFFFFFF)

    _GuiMM_DebugRegister($inRectW, $inRectC) ; registers ID to receive current rect

    Local $hGui1 = GUICreate('Test Min/Max [1]', 400, 300, -1, 60, BitOR($WS_SYSMENU, $WS_MINIMIZEBOX, $WS_MAXIMIZEBOX, $WS_SIZEBOX))
    Local $hGui2 = GUICreate('Test Min/Max [2]', 400, 300, -1, 400, BitOR($WS_SYSMENU, $WS_MINIMIZEBOX, $WS_MAXIMIZEBOX, $WS_SIZEBOX))


    GUISetState(@SW_SHOW, $hMain)


    Local $hWnd = $hGui1, $wMin = 0, $hMin = 0, $wMax = 0, $hMax = 0, $aSet
    Local $bMinimizeToMinSize = True, $bModeWindow = False
    Local $aMsg
    While True
        $aMsg = GUIGetMsg(1)
        Switch $aMsg[0]
            Case -3
                If $aMsg[1] = $hMain Then
                    Exit
                Else
                    GUISetState(@SW_HIDE, $aMsg[1])
                    GUICtrlSetState(($aMsg[1] = $hGui1 ? $btGui1 : $btGui2), $GUI_ENABLE)
                EndIf
            Case $r1, $r2
                $hWnd = BitAND(GUICtrlRead($r1), $GUI_CHECKED) ? $hGui1 : $hGui2
                ; [wMin, hMin, wMax, hMax, bMinimizeToMinSize, bModeWindow]
                $aSet = _GuiMM_GetMinMax($hWnd)
                If Not @error Then
                    GUICtrlSetData($inMinW, $aSet[0])
                    GUICtrlSetData($inMinH, $aSet[1])
                    GUICtrlSetData($inMaxW, $aSet[2])
                    GUICtrlSetData($inMaxH, $aSet[3])
                    GUICtrlSetState(($aSet[4] ? $r3 : $r4), $GUI_CHECKED)
                    GUICtrlSetState($cb, ($aSet[5] ? $GUI_CHECKED : $GUI_UNCHECKED))
                EndIf
            Case $r3, $r4
                $bMinimizeToMinSize = BitAND(GUICtrlRead($r3), $GUI_CHECKED) ? True : False
            Case $cb
                $bModeWindow = BitAND(GUICtrlRead($cb), $GUI_CHECKED) ? True : False
            Case $btGui1
                GUISetState(@SW_SHOW, $hGui1)
                GUICtrlSetState($btGui1, $GUI_DISABLE)
            Case $btGui2
                GUISetState(@SW_SHOW, $hGui2)
                GUICtrlSetState($btGui2, $GUI_DISABLE)
            Case $btSet
                $wMin = Int(GUICtrlRead($inMinW))
                $hMin = Int(GUICtrlRead($inMinH))
                $wMax = Int(GUICtrlRead($inMaxW))
                $hMax = Int(GUICtrlRead($inMaxH))
                _GuiMM_SetMinMax($hWnd, $wMin, $hMin, $wMax, $hMax, $bMinimizeToMinSize, $bModeWindow)
        EndSwitch
    WEnd
    Exit
EndFunc

Alles anzeigen

**BugFix**

Aufgefrischte Version in #Post1

**BugFix**

Zitat von oh-ha

Würde das ganze etwas umändern in" ICH LASSE MICH IMPFEN"

Oder:

NICHT IMPFEN IST ASOZIAL

**BugFix**

Im den nächsten Monaten werden wir alle (hoffentlich) die Möglichkeit haben, uns gegen Corona impfen zu lassen. Auch wenn das politisch recht kontrovers diskutiert wird, bin ich der Meinung, dass es von Vorteil wäre, dass bereits geimpfte Personen auch als solche erkennbar sein können (sofern sie das möchten). Das gäbe den anderen dann ein etwas besseres Gefühl (Bsp. Nahverkehr, das Grauen fährt immer mit).

Da könnte doch die Ansteck-Button-Kultur der 80-er mal wieder zum Tragen kommen. Ich habe mal mit paint.net gebastelt, wie das aussehen könnte.

corona_geimpft.png

corona_geimpft_sphere.png

**BugFix**

Das Thema von rollod hatte mich an meine frühjugendlichen Erfahrungen mit dem Morsen erinnert (schon weit über 40 Jahre her). Also habe ich mich mal rangesetzt und eine UDF erstellt, die geeignet ist um sowohl das Geben als auch das Hören zu trainieren. Frei nach Hans Grade heißt es beim Morsen: "Lerne Hören, dann kannst du geben." - Ich weiß noch, wie wir die ersten Monate immer nur die Kopfhörer auf hatten und mit dem Bleistift dann die empfangenen Dit's und Dah's notiert haben. Dabei wollten wir doch endlich mal die Morsetaste bedienen.

Übrigens: Die Computermaus ist nicht optimal geeignet zum Morsen. Beim Geben soll der Geber sich vor (und nicht unter) der Hand befinden. Ist aber sicher nur für Hardcorefunker von entscheidender Bedeutung. In der UDF wird aber als Gebertaste "rechte CTRL-Taste" verwendet.

• Mit der UDF kann ich eine Gui zur Entgegennahme der Morsezeichen registrieren. Nur wenn diese aktiv ist, wird R-CTRL ausgewertet.

• Es lassen sich Ctrl (Input/Edit) zum Anzeigen der erkannten Zeichen und zum Anzeigen des aus den Zeichen dekodierten Textes registrieren.

• Weiterhin kann ein Ctrl (Edit empfohlen) als Log registriert werden. Hier werden die erkannten DOWN-Time und UP-Time der Gebertaste angezeigt. Überschreitet die UP-Time 7 Basiseinheiten (> Wortpause), wird [UP IDLE] angezeigt.

• Text kann in Morsezeichen konvertiert werden.

• Eine Zeichenfolge von Morsezeichen kann akustisch (Beep-Funktion) ausgegeben werden, wahlweise mit zusätzlicher Konsolenausgabe jedes dekodierten Zeichens. Die Basiseinheit bei Beep-Ausgabe ist auf 120 ms festgelegt. Das ist relativ lang, aber wenn man das verkürzt, kommt die Audioausgabe nicht mehr mit.

Natürlich wäre es schick, wenn man beim Geben auch einen Beep hören könnte. Aber das übersteigt die Fähigkeiten eines PC. Beep ist eine Funktion mit definierter Zeit, somit könnte ich erst mit abgeschlossenem Tastendruck die DOWN-Time für Beep verwenden, hätte also immer ein Delay in der Länge des zuletzt gegebenen Zeichens. Wie ein Film mit schlecht synchronisierter Tonspur.

Und nacheinander Beeps mit kurzem Intervall auszuführen solange die Taste gedrückt ist, ist nur solange eine gute Idee, bis man das Ergebnis zum ersten mal gehört hat.

In der UDF setze ich die Keyboardeinstellungen auf max. Delay und min. Wiederholfrequenz (wird beim Beenden zurückgesetzt). Das ist nicht zwingend erforderlich, reduziert u.U. aber die Aufrufhäufigkeit der Callback-Funktion.

Ich habe ausgiebig kommentiert, ein Blick in den Code sollte somit eventuelle Fragen schon weitestgehend klären.

Übrigens ist es gar nicht so einfach mehrere Dah hintereinander einzugeben. "3-Units-Down/1-Unit-Up/3-Units-Down/1-Unit-Up/3-Units-Down/Up" - da braucht man schon ein gutes Zeitgefühl. Anfangs wird man meist die 1-Unit Sequenzpause überschreiten und schon wird die Eingabe als Zeichenpause gewertet und statt dem gewollten O steht da TTT.

AutoIt: Morse.au3

;-- TIME_STAMP   2021-01-04 13:58:50   v 0.1


#include-once
#include <GuiEdit.au3>
#include <WinAPIConstants.au3>
#include <WinAPISys.au3>
#include <WindowsConstants.au3>

Opt('MustDeclareVars', 1)

#cs
- Es wird eine ganz bestimmte feste Zeiteinheit gewählt.
- Die Länge eines Punktes (Dit) dauert eine Zeiteinheit.
- Die Länge eines Striches (Dah) dauert drei Zeiteinheiten.
- Die Punkte bzw. Striche, die jeweils ein Zeichen darstellen, werden durch eine Pause von einer Zeiteinheit getrennt.
- Die Pause zwischen den Darstellungen zweier verschiedener Zeichen beträgt drei Zeiteinheiten.
- Die Pause zwischen Zeichensequenzen, die zwei verschiedene Wörter darstellen, beträgt 7 Zeiteinheiten.

A    B      C      D     E   F      G     H      I    J      K     L      M
.-   -...   -.-.   -..   .   ..-.   --.   ....   ..   .---   -.-   .-..   --


N     O     P      Q      R     S     T   U     V      W     X      Y      Z
-.    ---   .--.   --.-   .-.   ...   -   ..-   ...-   .--   -..-   -.--   --..


Ä      Ö      Ü      ß         ;           Umlaute, "ß" und ";" sind nicht ITU-konform
.-.-   ---.   ..--   ...--..   -.-.-.


1        2        3        4        5        6        7        8        9        0
.----    ..---    ...--    ....-    .....    -....    --...    ---..    ----.    -----


Full stop (period) ............................................................................. [.] .−.−.−
Comma .......................................................................................... [,] −−..−−
Colon or division sign ......................................................................... [:] −−−...
Question mark (note of interrogation or request for repetition of a transmission not understood) [?] ..−−..
Apostrophe ..................................................................................... [’] .−−−−.
Hyphen or dash or subtraction sign ............................................................. [–] −....−
Fraction bar or division sign .................................................................. [/] −..−.
Left-hand bracket (parenthesis) ................................................................ [(] −.−−.
Right-hand bracket (parenthesis) ............................................................... [)] −.−−.−
Inverted commas (quotation marks) (before and after the words) ................................. ["] .−..−.
Double hyphen .................................................................................. [=] −...−
Understood ..................................................................................... VE  ...−.
Error (eight dots) ............................................................................. HH  ........
Cross or addition sign ......................................................................... [+] .−.−.
Invitation to transmit ......................................................................... K   −.−      (als Wort)
Wait ........................................................................................... AS  .−...
End of work .................................................................................... SK  ...−.−
Starting signal (to precede every transmission)................................................. CT  −.−.−
Multiplication sign ............................................................................ X   −..−     (als Wort)
Commercial at .................................................................................. [@] .––.-.
#ce

OnAutoItExitRegister('OnMorseExit')

Global $g_MorseUnit = 80      ; Dauer einer Einheit in ms
Global $g_MorseBeepUnit = 120 ; Dauer einer Einheit in ms für die Audioausgabe - Langsamer ist nicht sinnvoll, da kommt die Ausgabe nicht hinterher
Global $g_MorseF = 2500       ; Frequenz in Hz (Audioausgabe)
Global $g_MorseCharCB = ' '   ; Symbol für Zeichenpause
Global $g_MorseCharWB = '   ' ; Symbol für Wortpause (darf nicht dasselbe Zeichen, wie Zeichenpause sein!)

Global $g_hKeyProc = Null, $g_hHook
Global $g_bMorseKeyIsDown = False  ; Zustand Morsetaste (Up/Down)
Global $g_MorseKeyUpTimer          ; Timer für Messung: Morsetaste nicht gedrückt
Global $g_MorseKeyDownTimer        ; Timer für Messung: Morsetaste gedrückt
Global $g_MorseKeyTimeUp           ; gemessene Zeit: Morsetaste nicht gedrückt
Global $g_MorseKeyTimeDown         ; gemessene Zeit: Morsetaste gedrückt
Global $g_bMorseIDLE = True        ; Wenn keine neue Eingabe erfolgt, würde jede Pause der Länge 7 als Sequenz "Wortpause" gewertet.
                                   ; Das kann hiermit abgefangen werden. (Es dürfen keine zwei Pausen aufeinander folgen)
                                   ; Da beim Start derselbe Zustand, wie bei Mehrfachpause besteht: Vorbelegung mit "True"
Global $g_MorseStr = ''            ; zum Verketten der Sequenzen
Global $g_MorseSeq = ''            ; Sequenz (Dit/Dah)

Global $aMorse[][] = [ _
['A','.-'],['B','-...'],['C','-.-.'],['D','-..'],['E','.'],['F','..-.'],['G','--.'],['H','....'],['I','..'],['J','.---'],['K','-.-'],['L','.-..'],['M','--'], _
['N','-.'],['O','---'],['P','.--.'],['Q','--.-'],['R','.-.'],['S','...'],['T','-'],['U','..-'],['V','...-'],['W','.--'],['X','-..-'],['Y','-.--'],['Z','--..'], _
['1','.----'],['2','..---'],['3','...--'],['4','....-'],['5','.....'],['6','-....'],['7','--...'],['8','---..'],['9','----.'],['0','-----'], _
['Ä','.-.-'],['Ö','---.'],['Ü','..--'],['ß','...--..'],[';','-.-.-.'], _
['.','.-.-.-'],[',','--.--'],[':','---...'],['?','..--..'],["'",'.----.'],['-','-....-'],['/','-..-.'],['(','−.−−.'],[')','−.−−.−'],['"','.-..-.'],['=','-...-'], _
['VE','...-.'],['HH','........'],['+','.-.-.'],['AS','.-...'],['SK','...-.-'],['CT','-.-.-'],['@','.--.-.']]

Global $oMorseSend = ObjCreate("Scripting.Dictionary")
Global $oMorseRecv = ObjCreate("Scripting.Dictionary")
For $i = 0 To UBound($aMorse) -1
    $oMorseSend.Add($aMorse[$i][0],$aMorse[$i][1])
    $oMorseRecv.Add($aMorse[$i][1],$aMorse[$i][0])
Next

Global $g_MorseGui           ; GUI, die die Morsesignale empfängt
Global $g_MorseRawIn = Null  ; [optional] Ctrl, in das die erkannten Morsesymbole eingetragen werden
Global $g_MorseDecIn = Null  ; [optional] Ctrl, in das die aus den erkannten Morsesymbolen dekodierten Textzeichen eingetragen werden
Global $g_MorseLog = Null    ; [optional] Ctrl, in das die Zeiten (DOWN-Time, UP-Time) protokolliert werden
Global $g_MorseRawBreakCount ; [optional] für mehrzeiliges Ctrl, Anzahl der Zeichen, nach denen ein Zeilenumbruch eingefügt wird
Global $g_MorseDecBreakCount ; [optional] für mehrzeiliges Ctrl, Anzahl der Zeichen, nach denen ein Zeilenumbruch eingefügt wird
Global $g_MorseLogCount      ; [optional] für mehrzeiliges Ctrl, Anzahl der Aufrufe, nach denen ein Zeilenumbruch eingefügt wird

Global $g_tKBSettings = _KeyboardSetting() ; aktuelle Keyboardeinstellungen beim Start speichern

Func OnMorseExit()
    If $g_hKeyProc <> Null Then
        _WinAPI_UnhookWindowsHookEx($g_hHook)
        DllCallbackFree($g_hKeyProc)
        _KeyboardSetting($g_tKBSettings.Delay, $g_tKBSettings.Speed) ; nicht zwingend erforderlich
    EndIf
EndFunc  ;==>OnMorseExit



; Gui für Morse-UDF registrieren, Keyboard-Hook aktivieren, Adlib-Funktion zur Morse-Sequenz-Verarbeitung starten
Func _Morse_RegisterGui($_hWnd)
    $g_MorseGui = $_hWnd
    If $g_hKeyProc = Null Then
        _KeyboardSetting(3, 0) ; Delay auf 1s und Wiederholrate auf 2 Zeichen/s (nicht zwingend erforderlich)
        $g_hKeyProc = DllCallbackRegister("_Morse_KeyProc", "long", "int;wparam;lparam")
        $g_hHook = _WinAPI_SetWindowsHookEx($WH_KEYBOARD_LL, DllCallbackGetPtr($g_hKeyProc), _WinAPI_GetModuleHandle(0))
        AdlibRegister('_Morse_BreakTime', 20)
    EndIf
EndFunc  ;==>_Morse_RegisterGui


; GuiCtrl-ID registrieren für Eintragen des Morsecodes
; $_iCharBreak: optional für mehrzeiliges Ctrl, Anzahl der Zeichen, nach denen ein Zeilenumbruch eingefügt wird
Func _Morse_RegisterRawIn($_ID, $_iCharBreak=0)
    $g_MorseRawIn = $_ID
    $g_MorseRawBreakCount = $_iCharBreak
EndFunc  ;==>_Morse_RegisterRawIn


; GuiCtrl-ID registrieren für Eintragen des dekodierten Morsecodes
; $_iCharBreak: optional für mehrzeiliges Ctrl, Anzahl der Zeichen, nach denen ein Zeilenumbruch eingefügt wird
Func _Morse_RegisterDecodeIn($_ID, $_iCharBreak=0)
    $g_MorseDecIn = $_ID
    $g_MorseDecBreakCount = $_iCharBreak
EndFunc  ;==>_Morse_RegisterDecodeIn


; GuiCtrl-ID registrieren für Loggen der UP/DOWN Zeiten, je UP und je DOWN ein Funktionsaufruf
; $_iCallBreak: optional für mehrzeiliges Ctrl, Anzahl der Aufrufe, nach denen ein Zeilenumbruch eingefügt wird
Func _Morse_RegisterLog($_ID, $_iCallBreak=0)
    $g_MorseLog = $_ID
    $g_MorseLogCount = $_iCallBreak
EndFunc  ;==>_Morse_RegisterLog


; Morsefrequenz definieren für Audioausgabe
Func _Morse_SetFrequency($_i=-1) ; Standard(-1): 2500 Hz
    $g_MorseUnit = ($_i < 0 ? 2500 : $_i)
    Return $g_MorseUnit
EndFunc  ;==>_Morse_SetFrequency


; Basislänge der Morseeinheit definieren
Func _Morse_SetUnit($_i=-1) ; Standard(-1): min = 30 ms
    $g_MorseUnit = ($_i < 0 ? 30 : ($_i < 30 ? 30 : $_i))
    Return $g_MorseUnit
EndFunc  ;==>_Morse_SetUnit


; Trennzeichen im Morsecode nach Zeichenende definieren
Func _Morse_SetCharacterCharBreak($_s='') ; Standard(''): ' '
    $g_MorseCharCB = ($_s = '' ? ' ' : $_s)
    Return $g_MorseCharCB
EndFunc  ;==>_Morse_SetCharacterCharBreak


; Trennzeichen im Morsecode nach Wortende definieren
Func _Morse_SetCharacterWordBreak($_s='') ; Standard(''): '  '
    $g_MorseCharWB = ($_s = '' ? '  ' : $_s)
    Return $g_MorseCharWB
EndFunc  ;==>_Morse_SetCharacterWordBreak



; konvertiert einen Text in geschriebene Morsezeichen
; Zeichenende wird mit $g_MorseCharCB und Wortende mit $g_MorseCharWB markiert
Func _Morse_EnCrypt($_s)
    Local $sMorse
    $_s = StringUpper($_s)
    Local $aSplit = StringSplit($_s, '')
    For $i = 1 To $aSplit[0]
        If $aSplit[$i] = ' ' Then ; Wortende
            $sMorse = StringTrimRight($sMorse,1) & $g_MorseCharWB
            ContinueLoop
        EndIf
        If $oMorseSend.Exists($aSplit[$i]) Then
            $sMorse &= $oMorseSend.Item($aSplit[$i]) & $g_MorseCharCB
        Else
            $sMorse &= $aSplit[$i] & $g_MorseCharCB
        EndIf
    Next
    Return StringTrimRight($sMorse, 1)
EndFunc  ;==>_Morse_EnCrypt

; konvertiert einen Satz geschriebener Morsezeichen in Text
Func _Morse_DeCrypt($_p)
    Local $sPhrase
    Local $aWords = StringSplit($_p, $g_MorseCharWB, 1)
    For $i = 1 To $aWords[0]
        $sPhrase &= __Morse_DeCryptWord($aWords[$i]) & ' '
    Next
    Return $sPhrase
EndFunc  ;==>_Morse_DeCrypt

; konvertiert eine Wortsequenz von Morsezeichen in Text
Func __Morse_DeCryptWord($_w)
    Local $sWord, $aChars = StringSplit($_w, $g_MorseCharCB, 1)
    For $i = 1 To $aChars[0]
        $sWord &= __Morse_DeCryptChar($aChars[$i])
    Next
    Return $sWord
EndFunc  ;==>__Morse_DeCryptWord

; konvertiert eine Zeichensequenz von Morsezeichen in Text
Func __Morse_DeCryptChar($_c)
    If $oMorseRecv.Exists($_c) Then
        Return $oMorseRecv.Item($_c)
    Else
        Return '[' & $_c & ']' ; unbekanntes Zeichen, wird wie erkannt zurückgegeben
    EndIf
EndFunc  ;==>__Morse_DeCryptChar

; fügt erkannte Morsesequenz in Ctrl ein (sofern registriert)
Func __Morse_AddRaw($_s)
    If $g_MorseRawIn = Null Then Return
    Local Static $h_RawIn = IsHWnd($g_MorseRawIn) ? $g_MorseRawIn : GUICtrlGetHandle($g_MorseRawIn)
    Local Static $iCount = 0
    If $g_MorseRawBreakCount > 0 Then
        $iCount += 1
        If $iCount = $g_MorseRawBreakCount Then
            $_s &= @CRLF
            $iCount = 0
        EndIf
    EndIf
    _GUICtrlEdit_AppendText($h_RawIn, $_s)
EndFunc  ;==>__Morse_AddRaw

; fügt aus Morsesequenz dekodiertes Zeichen in Ctrl ein (sofern registriert)
Func __Morse_AddDec($_s)
    If $g_MorseDecIn = Null Then Return
    Local Static $h_DecIn = IsHWnd($g_MorseDecIn) ? $g_MorseDecIn : GUICtrlGetHandle($g_MorseDecIn)
    Local Static $iCount = 0
    Local $sCRLF = ''
    If $g_MorseDecBreakCount > 0 Then
        $iCount += 1
        If $iCount = $g_MorseDecBreakCount Then
            $sCRLF = @CRLF
            $iCount = 0
        EndIf
    EndIf
    If ($_s = $g_MorseCharCB) Or ($_s = $g_MorseCharWB) Or ($_s = ' ') Then
        _GUICtrlEdit_AppendText($h_DecIn, $_s & $sCRLF)
    Else
        _GUICtrlEdit_AppendText($h_DecIn, __Morse_DeCryptChar($_s) & $sCRLF)
    EndIf
EndFunc  ;==>__Morse_AddDec

; fügt DOWN/UP-Time in Ctrl ein (sofern registriert)
Func __Morse_AddLog($_s)
    If $g_MorseLog = Null Then Return
    Local Static $iCount = 0
    Local Static $h_Log = IsHWnd($g_MorseLog) ? $g_MorseLog : GUICtrlGetHandle($g_MorseLog)
    If $g_MorseLogCount > 0 Then
        $iCount += 1
        If $iCount = $g_MorseLogCount Then ; $g_MorseLogCount/2 Tastendrücke (Down und Up) nebeneinander, dann neue Zeile
            $_s &= @CRLF
            $iCount = 0
        EndIf
    EndIf
    _GUICtrlEdit_AppendText($h_Log, $_s)
EndFunc  ;==>__Morse_AddLog


; Akustische Wiedergabe eines mit "_Morse_EnCrypt" codierten Textes
Func _Morse_Beep($_sMorse, $_bConsoleOut=False)
    Local Static $oLen = ObjCreate('Scripting.Dictionary')
    Local Static $bAdd = False
    If $bAdd = False Then
        $bAdd = True
        $oLen.Add('.', 1)
        $oLen.Add('-', 3)
        $oLen.Add('°', 3-1) ; Da nach jedem '.' oder '-' IMMER eine Pause von 1 folgt, ...
        $oLen.Add('^', 7-1) ; ... wird dieser Wert bei Zeichen- und Wortende abgezogen.
    EndIf
    $_sMorse = StringReplace($_sMorse, $g_MorseCharWB, '^') ; Zeichen- u. Wortende durch Platzhalter mit 1 Zeichen Länge ersetzen ...
    $_sMorse = StringReplace($_sMorse, $g_MorseCharCB, '°') ; ... um zeichenweises Verarbeiten zu gewährleisten
    Local $aSplit = StringSplit($_sMorse, ''), $sCh = ''
    For $i = 1 To $aSplit[0]
        Switch $aSplit[$i]
            Case '.', '-'
                Beep($g_MorseF, $oLen.Item($aSplit[$i]) * $g_MorseBeepUnit) ; Beep in definierter Frequenz und Länge des Dit/Dah
                Sleep($g_MorseBeepUnit)                                     ; Pause von 1 Einheit, die nach jedem Dit/Dah folgt
                If $_bConsoleOut Then
                    $sCh &= $aSplit[$i]
                    If $i = $aSplit[0] Then ConsoleWrite($oMorseRecv.Item($sCh) & @CRLF) ; letztes Zeichen erreicht -> Ausgabe erkanntes Zeichen
                EndIf
            Case '°', '^'
                Sleep($oLen.Item($aSplit[$i]) * $g_MorseBeepUnit)   ; Zeichen-/Wortpause in der entsprechenden Länge
                If $_bConsoleOut Then
                    ConsoleWrite($oMorseRecv.Item($sCh))        ; bei Zeichen-/Wortpause das zuletzt erkannte Zeichen ausgeben
                    $sCh = ''                                   ; Zeichen-Variable zurücksetzen
                    If $aSplit[$i] = '^' Then ConsoleWrite(' ') ; Wortpause: Leerzeichen als Worttrenner (Text) ausgeben
                EndIf
        EndSwitch
    Next
EndFunc  ;==>_Morse_Beep


;==============================================================================
; Callback-Function: wird erst gestartet, wenn dafür eine Gui registriert ist
;==============================================================================
Func _Morse_KeyProc($nCode, $wParam, $lParam)
    Local Static $iUnit1_Max = 1.4 * $g_MorseUnit   ; max. Dit-Länge und Pausenlänge zwischen zwei aufeinanderfolgenden Dit oder Dah
    Local Static $iUnit3_Min = 0.6 * 3*$g_MorseUnit ; min. und
    Local Static $iUnit3_Max = 1.4 * 3*$g_MorseUnit ; max Dah-Länge und Pausenlänge zwischen zwei aufeinanderfolgenden Zeichen
    Local Static $bOnce = False

    If ($nCode < 0) Or (Not BitAND(WinGetState($g_MorseGui), 8)) Then _ ; nicht verarbeiten, wenn registrierte Gui inaktiv
        Return _WinAPI_CallNextHookEx($g_hHook, $nCode, $wParam, $lParam)
    Local $tKEYHOOKS = DllStructCreate($tagKBDLLHOOKSTRUCT, $lParam)
    Local $vkCode = DllStructGetData($tKEYHOOKS, "vkCode")
    If $vkCode <> 163 Then Return _WinAPI_CallNextHookEx($g_hHook, $nCode, $wParam, $lParam) ; nur R-CTRL auswerten

    If $wParam = $WM_KEYDOWN Then
        If Not $bOnce Then ; bei erstmaligem Aufruf der Funktion Ausgabe der aktuellen Parameter in das Log
            $bOnce = True
            __Morse_AddLog(StringFormat('[DIT: <= %i ms, DAH: %i ms bis %i ms, SEQ: < %i ms, CHAR: %i ms bis %i ms]\n', _
                                        $iUnit1_Max, $iUnit3_Min, $iUnit3_Max, $iUnit1_Max, $iUnit3_Min, $iUnit3_Max))
        EndIf
        $g_bMorseKeyIsDown = True
        $g_MorseKeyDownTimer = TimerInit()       ; Timer für DOWN-Time starten
        $g_MorseKeyTimeUp = TimerDiff($g_MorseKeyUpTimer) ; UP-Time (Pausenzeit) messen und auswerten
        __Morse_AddLog($g_bMorseIDLE ? '[UP IDLE]' : (StringFormat('[UP %03i] ', $g_MorseKeyTimeUp)))
        If $g_bMorseIDLE Then  ; IDLE-Mode, beim Start oder wenn Eingabepause > 7 Units
            $g_bMorseIDLE = False                ; IDLE-Mode beendet
            ; falls letzte Eingabe noch nicht verarbeitet
            If $g_MorseStr <> '' Then
                __Morse_AddDec($g_MorseStr)      ; erkanntes Zeichen (dekodiert) in Dekodiert-Ctrl ausgeben
                __Morse_AddRaw($g_MorseCharCB)   ; Zeichen für Zeichentrennung in Raw-Ctrl ausgeben
                $g_MorseStr = ''                 ; Stringvariable zurücksetzen
            EndIf
        Else                   ; Eingabemodus, UP-Time < 7 Units
            Select
                Case $g_MorseKeyTimeUp > $iUnit3_Min And _ ; Zeichenpause, Sequenzen des Zeichens ...
                     $g_MorseKeyTimeUp < $iUnit3_Max       ; ... dekodieren und ausgeben
                    If $g_MorseStr <> '' Then
                        __Morse_AddDec($g_MorseStr)      ; erkanntes Zeichen (dekodiert) in Dekodiert-Ctrl ausgeben
                        __Morse_AddRaw($g_MorseCharCB)   ; Zeichen für Zeichentrennung in Raw-Ctrl ausgeben
                        $g_MorseStr = ''                 ; Stringvariable zurücksetzen
                    EndIf
                Case $g_MorseKeyTimeUp < $iUnit1_Max       ; Sequenzpause
                    ; keine gesonderte Auswertung erforderlich,
            EndSelect
        EndIf
    ElseIf $wParam = $WM_KEYUP Then
        $g_bMorseKeyIsDown = False
        $g_MorseKeyUpTimer = TimerInit()         ; Timer für UP-Time starten
        $g_MorseKeyTimeDown = TimerDiff($g_MorseKeyDownTimer) ; DOWN-Time (Taste gedrückt Zeit) messen und auswerten
        __Morse_AddLog(StringFormat('[DOWN %03i] ', $g_MorseKeyTimeDown))
        $g_MorseSeq = ''
        Select
            Case $g_MorseKeyTimeDown > $iUnit3_Max
                $g_MorseSeq = '>'      ; Tastendruck länger als max. Zeitraum für längstes Zeichen
            Case $g_MorseKeyTimeDown > $iUnit3_Min And $g_MorseKeyTimeDown < $iUnit3_Max
                $g_MorseSeq = '-'      ; Dah
            Case $g_MorseKeyTimeDown < $iUnit1_Max  ; alles kürzer max. wird immer als Dit gewertet
                $g_MorseSeq = '.'      ; Dit
        EndSelect
        $g_MorseStr &= $g_MorseSeq     ; Sequenz verketten
        __Morse_AddRaw($g_MorseSeq)    ; Sequenz in Raw-Ctrl ausgeben
    EndIf

    Return _WinAPI_CallNextHookEx($g_hHook, $nCode, $wParam, $lParam)
EndFunc  ;==>_Morse_KeyProc


; Auswertung der Pausen zwischen R-CTRL bei aktiver (registrierter) GUI
Func _Morse_BreakTime()
    Local Static $iUnit7_Min = 7*$g_MorseUnit
    If $g_bMorseKeyIsDown Then Return  ; nur UP-Zyklus (Pause) auswerten
    AdlibUnRegister('_Morse_BreakTime')
    If TimerDiff($g_MorseKeyUpTimer) > $iUnit7_Min Then
        If Not $g_bMorseIDLE Then ; Wortpause, kein IDLE
            If $g_MorseStr <> '' Then ; falls letzte Eingabe noch nicht verarbeitet
                __Morse_AddDec($g_MorseStr)      ; erkanntes Zeichen (dekodiert) in Dekodiert-Ctrl ausgeben
                $g_MorseStr = ''
            EndIf
            __Morse_AddRaw($g_MorseCharWB)  ; Zeichen für Worttrennung in Raw-Ctrl ausgeben
            __Morse_AddDec(' ')             ; Leerzeichen für Worttrennung in Dekodiert-Ctrl ausgeben
            $g_bMorseIDLE = True            ; Beginn IDLE
        EndIf
    EndIf
    AdlibRegister('_Morse_BreakTime', 20)
EndFunc  ;==>_Morse_BreakTime



; #FUNCTION# ====================================================================================================================
; Name ..........: _KeyboardSetting
; Description ...: Abfragen (Standard "-1") oder Setzen der Keyboardeinstellungen in der Registry
; Parameters ....: $_iDelay               (Default = -1) Verzögerung bis bei gedrückter Taste die Zeichenwiederholung aktiviert wird
;                                         gültige Werte: 0 = 250ms, 1 = 500ms, 2 = 750ms, 3 = 1s
; ...............: $_iSpeed               (Default = -1) Geschwindigkeit, mit der bei aktivierter Zeichenwiederholung das Zeichen wiederholt wird
;                                         gültige Werte: "0" (2 Zeichen je Sekunde) bis "31" (30 Zeichen je Sekunde)
; ...............: $_iNumlockOnAtStartup  (Default = -1) Numlock-Taste ist beim Start an oder aus
;                                         gültige Werte: "0" = Aus, "2" = An
;                                         Der Wert für Numlock wird beim Abmelden des Users mit dem dann aktuellen Zustand der Taste überschrieben.
; Return values .: Struktur mit den aktuellen Keyboardeinstellungen: ".Delay", ".Speed", ".NumlockOn"
; Author ........: BugFix
; ===============================================================================================================================
Func _KeyboardSetting($_iDelay=-1, $_iSpeed=-1, $_iNumlockOnAtStartup=-1)
    Local $iDelay = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardDelay")
    Local $iSpeed = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardSpeed")
    Local $iInitIndicator = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "InitialKeyboardIndicators")
    Local $tKeyboard = DllStructCreate("struct;int Delay;int Speed;int NumlockOn;endstruct")
    ; alle Parameter "-1" -> nur Auslesen
    If $_iDelay = -1 And $_iSpeed = -1 And $_iNumlockOnAtStartup = -1 Then
        $tKeyboard.Delay = $iDelay
        $tKeyboard.Speed = $iSpeed
        $tKeyboard.NumlockOn = $iInitIndicator
        Return $tKeyboard
    EndIf
    If $_iDelay <> -1 Then
        $_iDelay = ($_iDelay < 0 ? 0 : ($_iDelay > 3 ? 3 : $_iDelay))
        RegWrite("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardDelay", "REG_SZ", $_iDelay)
        $tKeyboard.Delay = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardDelay")
    Else
        $tKeyboard.Delay = $iDelay
    EndIf
    If $_iSpeed <> -1 Then
        $_iSpeed = ($_iSpeed < 0 ? 0 : ($_iSpeed > 31 ? 31 : $_iSpeed))
        RegWrite("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardSpeed", "REG_SZ", $_iSpeed)
        $tKeyboard.Speed = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "KeyboardSpeed")
    Else
        $tKeyboard.Speed = $iSpeed
    EndIf
    If $_iNumlockOnAtStartup <> -1 Then
        $_iNumlockOnAtStartup = ($_iNumlockOnAtStartup < 0 ? 0 : ($_iNumlockOnAtStartup = 2 ? 2 : 0))
        RegWrite("HKEY_CURRENT_USER\Control Panel\Keyboard", "InitialKeyboardIndicators", "REG_SZ", $_iNumlockOnAtStartup)
        $tKeyboard.NumlockOn = RegRead("HKEY_CURRENT_USER\Control Panel\Keyboard", "InitialKeyboardIndicators")
    Else
        $tKeyboard.NumlockOn = $iInitIndicator
    EndIf
    Return $tKeyboard
EndFunc  ;==>_KeyboardSetting

Alles anzeigen

AutoIt: Morse_Bsp.au3

;-- TIME_STAMP   2021-01-04 13:59:25   v 0.1


Opt('MustDeclareVars', 1)

#include "Morse.au3"

_Example_1()
_Example_2()

Func _Example_1()
    _Morse_SetUnit(100) ; Basis-Einheit der Morsesequenzen festlegen (ms)

    Global $g_hGui = GUICreate('Morsen', 700, 400)
    _Morse_RegisterGui($g_hGui) ; Gui registrieren, nur wenn diese Gui aktiv ist, wird R-CTRL als Morsetaste ausgewertet
    GUICtrlCreateLabel('Erkannte Morsezeichen', 10, 15)
    Global $inMorseReceived = GUICtrlCreateInput('', 10, 30, 680, 30, BitOR($ES_LEFT, $ES_AUTOHSCROLL, $ES_READONLY))
    GUICtrlSetBkColor(-1, 0x000090)
    GUICtrlSetColor(-1, 0xFFFF00)
    GUICtrlSetFont(-1, 14, 600, Default, 'Consolas')
    _Morse_RegisterRawIn($inMorseReceived) ; Input registrieren zur Ausgabe der erkannten Morsezeichen
    GUICtrlCreateLabel('Entspricht Klartext', 10, 80)
    Global $inTextReceived = GUICtrlCreateInput('', 10, 95, 680, 30, BitOR($ES_LEFT, $ES_AUTOHSCROLL, $ES_READONLY))
    GUICtrlSetBkColor(-1, 0x000090)
    GUICtrlSetColor(-1, 0xFFFF00)
    GUICtrlSetFont(-1, 12)
    _Morse_RegisterDecodeIn($inTextReceived) ; Input registrieren zur Ausgabe der aus den Morsezeichen dekodierten Textzeichen
    GUICtrlCreateLabel('Erfasste Tastendruck- und Pausenlängen. MORSETASTE ist <STRG-RECHTS>.', 10, 145)
    Global $edButtonReceived = GUICtrlCreateEdit('', 10, 160, 680, 200, BitOR($GUI_SS_DEFAULT_EDIT, $ES_READONLY))
    GUICtrlSetBkColor(-1, 0xFFFFFF)
    GUICtrlSetFont(-1, 9, Default, Default, 'Consolas')
    _Morse_RegisterLog($edButtonReceived, 8) ; Edit registrieren zum Loggen DOWN/UP-Zeiten, nach 8 Aufrufen (je 4 DOWN und UP) erfolgt Zeilenumbruch

    ; individuelle Darstellung der Zeichen- und Wortpausen im erkannten Morsecode ($inMorseReceived)
    _Morse_SetCharacterCharBreak('°') ; Standard: ' '
    _Morse_SetCharacterWordBreak('^') ; Standard: '  '

    GUISetState()

    While True
        Switch GUIGetMsg()
            Case -3
                Exit
        EndSwitch
    WEnd
EndFunc

Func _Example_2()
    Local $sEncrypt = _Morse_EnCrypt('AutoIt ist eine leicht zu lernende Programmiersprache. Besonders leicht lassen sich damit wiederkehrende Aufgaben unter Windows automatisieren.')
    ConsoleWrite('als Morsecode:' & @CRLF & $sEncrypt & @CRLF)
    _Morse_Beep($sEncrypt, True)  ; Audioausgabe und zusätzlich Console
EndFunc

Alles anzeigen

**BugFix**

Ich denke nicht, dass es notwendig ist in der Hilfe auch noch zu erklären, welche Flags (logischerweise) kombiniert werden können. Es muss doch die Entscheidung des Users vorliegen ob er nur Lesen oder evtl. Daten anhängen möchte. Wenn er nicht weiß, was er will, kann er auch nicht die korrekten Flags wählen. Das ist dann aber nicht der Hilfe geschuldet, sondern dem mangelnden Programmiervermögen des Users.

**BugFix**

Zitat von bazii

Da hindert bei uns immer der zentrale Einkauf dran. Die wollen vor einem Softwarekauf immer ein ausführliches Lastenheft und eine Gefährdungsbeurteilung durch den Datenschutzbeauftragten und den ganzen Kram den keiner von und wirklich abarbeiten will.

Nur mal am Rande:

Sofern ihr irgendeine Form des Qualitätsmanagements verwendet, gilt das adäquat für jedes Softwareprodukt - dazu zählen auch selbst erstellte Skripte.

Aber der Aufwand ist überschaubar:

- Beschreibung des aktuellen Ablaufs

- Beschreibung der Parts, die von der Software übernommen werden sollen

- Parallellauf beider Verfahren zur Absicherung der Ergebnisgleichheit

- Freigabe für den produktiven Einsatz

Das passt auf ein DIN A4 Blatt. Alle 3 Jahre checkst du, ob alles noch wie gewollt läuft und vermerkst das auf dem Blatt: "weiterhin gültig, Datum/Unterschrift"

Falls du mal solch ein Musterformular benötigst, melde dich.

**BugFix**

Bin gerade nicht am PC, aber grundsätzlich erstelle ich auch den extended Style sofort mit GuiCtrlCreate... - ist zwar dann oft eine sehr lange Befehlszeile, aber bisher hat das immer funktioniert.

**BugFix**

zu 1.

Es funktioniert, sicher auch bei dir - du siehst es nur nicht, weil du einen Fehler eingebaut hast: Verwende NIE ArrayDisplay/MsgBox o.ä. in einer GuiRegisterMsg-Funktion! Das führt dann zu solch undefinierten Zuständen.

Ändere mal deine Callbackroutine so:

Code

Func On_WM_DROPFILES($hWnd, $msg, $wParam, $lParam)
    Local $aFileList, $nSize, $pFileName, $tPoint, $hCtrl

    $tPoint = _WinAPI_DragQueryPoint($wParam)
    If Not DllStructGetSize($tPoint) Then Return     ;window border
    $hCtrl = _WinAPI_ChildWindowFromPointEx($hWnd, $tPoint)

    If $hCtrl = ControlGetHandle($hGui, "", $idListview) Then     ;ListView
        $aFileList = _WinAPI_DragQueryFileEx($wParam)

;~         _ArrayDisplay($aFileList)
        If IsArray($aFileList) Then
            For $i = 1 To $aFileList[0]
                ConsoleWrite($aFileList[$i] & @CRLF)
            Next
        EndIf

        _WinAPI_DragFinish($wParam)
        _WinAPI_MessageBeep(0)     ;Ton erzeugen
    EndIf

    Return
EndFunc   ;==>On_WM_DROPFILES

Alles anzeigen

Dann siehst du, dass alles funktioniert.

2. resultiert aus 1.

**BugFix**

Zitat von Bitnugger

Evtl. lässt sich da ja was mit Nim via DllCall zaubern... eg. SpezRegEx.nim ==> SpezRegEx.dll - eine Funktion, um den String zu übergeben, und eine, um das Pattern auzuwerten.

Wäre es dann nicht besser, gleich eine der Nim-JSON Bibliotheken zu nutzen und die gesamte Verarbeitung in einer Dll ausführen zu lassen?

**BugFix**

Zitat von polarole

GUICtrlGetHandle("SysDateTimePick322")

DAS geht nur für eigene Ctrl.

Local $hCalendar = ControlGetHandle("FENSTERTITEL", "", "[CLASS:SysDateTimePick322; INSTANCE:1]") -- hier die Klassen- und Instancenamen für das Ctrl genau eintragen

Übrigens: "[CLASS:#32770]" als Identifizierung für das Fenster ist etwas ungünstig, das ist die Standard-Windows-Fensterklasse.

**BugFix**

Bitte poste immer deinen Code. Sonst kann ich nicht sehen, was du falsch machst.

Das Array muß 7 Elemente haben (daraus wird die Datumsstruktur befüllt) aber wenn du die Zeit auf '0' setzt, kannst du das beim Deklarieren auch weglassen. Beim Auslesen verwendet AutoIt dann für: kein Wert = 0.

Also: $a_Date[7] = [False, 2013, 10, 25] ist identisch mit $a_Date[7] = [False, 2013, 10, 25, 0, 0, 0]

EDIT:

Für ein besseres Verständnis ist es durchaus sinnvoll sich auch einmal die UDF anzuschauen. In SciTE: Cursor auf "#include UDF-Datei.au3" setzen und <Alt+I>. öffnet die Include Datei.

Die Funktion sieht dort so aus:

AutoIt

Func _GUICtrlDTP_SetSystemTime($hWnd, ByRef $aDate)
    Local $tDate = DllStructCreate($tagSYSTEMTIME)
    DllStructSetData($tDate, "Year", $aDate[1])
    DllStructSetData($tDate, "Month", $aDate[2])
    DllStructSetData($tDate, "Day", $aDate[3])
    DllStructSetData($tDate, "Hour", $aDate[4])
    DllStructSetData($tDate, "Minute", $aDate[5])
    DllStructSetData($tDate, "Second", $aDate[6])
    Return _GUICtrlDTP_SetSystemTimeEx($hWnd, $tDate, $aDate[0])
EndFunc   ;==>_GUICtrlDTP_SetSystemTime

Beiträge von BugFix

Systemweit ermitteln, ob ein "(" per Tastatur eingegeben wurde - UNABHÄNGIG vom Tastaturlayout

Systemweit ermitteln, ob ein "(" per Tastatur eingegeben wurde - UNABHÄNGIG vom Tastaturlayout

Systemweit ermitteln, ob ein "(" per Tastatur eingegeben wurde - UNABHÄNGIG vom Tastaturlayout

Systemweit ermitteln, ob ein "(" per Tastatur eingegeben wurde - UNABHÄNGIG vom Tastaturlayout

Systemweit ermitteln, ob ein "(" per Tastatur eingegeben wurde - UNABHÄNGIG vom Tastaturlayout

Raspberry Pi AutoIT

Liste sämtlicher Windows 10 Icons + Möglichkeit diese nach Belieben zu ersetzen

Liste sämtlicher Windows 10 Icons + Möglichkeit diese nach Belieben zu ersetzen

GuiMinMax.au3

Taskbar Eigenschaften

Corona - endlich impfen

Corona - endlich impfen

Morse-UDF

Script zu langsam

Dateiverzeichnisse: Bestimmte Berechtigungsgruppe auslesen und auflisten.

ListView - 3 Probleme: ArrayDisplay / Drag & Drop / erweiterte Stile

ListView - 3 Probleme: ArrayDisplay / Drag & Drop / erweiterte Stile

JSON-UDF

Datum in AutoIt speichern fuer SysDateTimePick32

Datum in AutoIt speichern fuer SysDateTimePick32