Beiträge von Yjuq

Mir war gerade noch langweilig, also habe ich mir die Demo des Programmes heruntergeladen. Hier mal ein Beispielcode angepasst auf das Programm. Konnte es aber nur mit der Version 7.1 testen, musst du ggf. etwas anpassen.

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
; * Getestet mit: PC-Notizz! 7.1

#include <GuiListBox.au3>
#include <GuiTreeView.au3>

; Wartet auf Programmstart um Handles auszulesen:
Global $hWnd = WinWait('[CLASS:Tfrm_Main]')
Global $hKategorie = ControlGetHandle($hWnd, '', '[CLASS:TEdit; INSTANCE:2]')
Global $hStichwoerter = ControlGetHandle($hWnd, '', '[CLASS:TEdit; INSTANCE:1]')
Global $hTreeView = ControlGetHandle($hWnd, '', '[CLASS:TTreeView; INSTANCE:1]')
Global $hTreeViewItem = _GUICtrlTreeView_FindItem($hTreeView, 'Beispiel-Kategorie')
Global $hListBox = ControlGetHandle($hWnd, '', '[CLASS:TStringGrid; INSTANCE:1]')
Global $iListBoxItem = _GUICtrlListBox_FindString($hListBox, 'Beispiel-Stichwort')

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

ControlSetText($hWnd, '', $hKategorie, 'Beispiel-Kategorie')
ControlSetText($hWnd, '', $hStichwoerter, 'Beispiel-Stichwort')

_GUICtrlTreeView_SelectItem($hTreeView, $hTreeViewItem)
ConsoleWrite(_GUICtrlTreeView_GetText($hTreeView, $hTreeViewItem) & @CRLF)

_GUICtrlListBox_ClickItem($hListBox, $iListBoxItem, 'right')

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Servus, die beiden Input Controls kannst du mit ControlSend() oder auch ControlSetText() befüllen. Da du sowohl die Klasse als auch die Instanz der Controls hast, kannst du diese damit eindeutig bestimmen, diese musst du lediglich nur in den entsprechenden Parametern einfügen:

ControlSend(*Handle des Fensters*, '', '[CLASS:TEdit; INSTANCE:3] (oder) [CLASS:TEdit; INSTANCE:1]', 'Text der gesendet werden soll')

Zu dem TreeView: Sobald du das Handle des TreeView hast, kannst du dieses komplett mit der GUITreeView UDF ansteuern, so als ob's dein eigenes wäre.
z.B. kannst du mit _GUICtrlTreeView_SetFocused() den Fokus auf ein bestimmtes Item legen. Um das Handle zu bestimmen kannst du mit ControlGetHandle() arbeiten. Über die Klasse und Instance (oder auch einfach der ID) hast du die Möglichkeit das sich wechselnde Handle immer wieder neu zu bestimmen.

Zu deinem List Control, schau mal ob du mit _GUICtrlListBox_SelectString() weiterkommst, gleiches Prinzip wie beim TreeView.

€dit:
Hier mal ein einfaches Beispiel mit Notepad, du kannst die UDF Funktionen so für jedes Control nutzen, das sollte die Ansteuerung erheblich erleichtern:

#include <GuiEdit.au3>

$hWnd = WinWait('[CLASS:Notepad]') ; Handle des Fensters
$hEdit = ControlGetHandle($hWnd, '', '[CLASS:Edit; INSTANCE:1]') ; Handle des Controls

_GUICtrlEdit_AppendText($hEdit, @CRLF & 'Make-Grafik') ; Funktion benutzen

Zitat

[...] Daher ... darf man hier auch alte Threads vor x Jahren ausgraben (oft als Leichenschänder scherzhaft verschrien) und drauf antworte [...]

Prinzipiell darfst du hier jeden Thread ausgraben, auch welche aus 2008 wenn es dir Spaß macht. Jedoch solltest du darauf achten dass dein Beitrag eben zu dem Thema passt. Ich persönlich halte mich ja an folgende Regel: Je älter der letzte Beitrag eines Threads ist, umso qualitativer muss meine Antwort sein damit es nicht als Spam gilt.

Ich habe in vielen Foren schon gesehen wo welche (die auf alte Fragestellungen antworten) als „Leichenschänder“ dargestellt werden. Aber eben diese „Leichenschänder“ gaben mir dann die Antwort, die ich sonst nirgends gefunden habe. Trau dich also ruhig auch etwas ältere Threads auszugraben und auch mal (sofern Google keine leicht auffindbaren Ergebnisse liefern) darauf zu antworten bzw. etwas nachzufragen. Zumindest ich werde dich dafür nicht verurteilen.

Zitat

[...] Und sollte man sehr themenspezifisch Threads eröffnen oder kann man auch diverse kleine Fragen in einem Thread unterbringen?

Schwierig, da musst du ein gutes Mittelmaß finden. Wenn die Fragen von der Thematik her nicht zu sehr auseinander driften (also keine sichtbare Beziehung zueinander haben) kannst du diese ruhig in einem Thread verpacken. Sieht hier aber glaube ich keiner so eng...

Hey ihr Lieben!
Ich habe mir ein kleines Spiel ausgedacht welches eure Gehirnzellen ein wenig anstrengen soll. Ziel ist es, etwas zu sortieren. Ihr bekommt nach der Reihe (verdeckt) entweder die Zahl 1 oder 0. Ihr müsst versuchen nacheinander die Zahlen in einem langen String irgendwo einzufügen, sodass möglichst viele Nullen auf der einen Seite und Einsen auf der anderen Seite zu finden sind. Wo ihr die Zahl einfügt dürft ihr euch aussuchen. Die Schwierigkeit ist halt, dass ihr nicht wisst um was für eine Zahl es sich dabei handelt, diese wird euch erst hinterher bekannt gegeben. Es geht also darum möglichst intelligent die Zahlen zu verteilen ohne zu wissen welche Zahl ihr an eurer gewünschten Stelle einfügt.

Hier einmal ein kleines Skript zur Veranschaulichung:

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

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

Global Const $g_eNumb = 100
Global Const $g_eRound = 100

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Global $iFor, $iNum, $sStr, $iPt

For $iFor = 1 To $g_eRound
$sStr = _GameRound(0, $iNum, True)

While $iNum
$sStr = _GameRound(Random(0, StringLen($sStr), 1), $iNum)
WEnd

$iPt += _GetPoints($sStr)
Next

ConsoleWrite('Punkte im Durchschnitt: ' & Round($iPt / $g_eRound) & @CRLF)

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func _GameRound($iPos, ByRef $iNumb, $bReset = False)
Local Static $sStr = Null

If $bReset Or IsKeyword($sStr) Then
$sStr = __GetNextNumb(True)
$iNum = 1
EndIf

If Not IsInt($iPos) Or $iPos < 0 Or $iPos > StringLen($sStr) Or Not $iNumb Then Return SetError(1)

$sStr = _StringInsert($sStr, __GetNextNumb(), $iPos)
$iNumb = $g_eNumb - StringLen($sStr)

Return $sStr
EndFunc

Func _GetPoints($sStr)
Local $iP, $i, $iT, $sT

For $i = 1 To StringLen($sStr) -1
$iT = __GetPoints($sStr, $i)
If $iT > $iP Then $iP = $iT
Next

Return $iP
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func __GetNextNumb($bReset = False)
Local Static $aiNumb[$g_eNumb]
Local $i

If $bReset Then
ReDim $aiNumb[$g_eNumb]
For $i = 0 To $g_eNumb -1
$aiNumb[$i] = String(($i < $g_eNumb / 2) ? 1 : 0)
Next
_ArrayShuffle($aiNumb)
EndIf

Return _ArrayPop($aiNumb)
EndFunc

Func __GetPoints($sStr, $iPos)
Local $asSplit = StringSplit(_StringInsert($sStr, '|', $iPos), '|', $STR_NOCOUNT)
Local $iPoints

$sStr = StringReplace($asSplit[0], '0', '') & StringReplace($asSplit[1], '1', '')
$iPoints = StringLen($sStr)
$sStr = StringReplace($asSplit[0], '1', '') & StringReplace($asSplit[1], '0', '')

Return (($iPoints > StringLen($sStr)) ? $iPoints : StringLen($sStr))
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

In erster Linie ist für euch nur die Funktion _GameRound() und _GetPoints() interessant. Mit _GameRound() führt ihr eine Spielrunde aus. Beim ersten Aufruf (oder wenn ihr das Spiel mit dem dritten Parameter resettet) werden euch lediglich 2 Anfangszahlen vorgegeben. Diese können 00, 01, 10 oder auch 11 sein (wird von der Funktion returnt). Danach könnt ihr im ersten Parameter angeben wo ihr eure nächste Zahl hinsetzen möchtet. Die Zahl 0 steht dabei für den Anfang des Strings. Im 2ten Parameter wird euch eine Zahl zurückgegeben, welche die noch verbleibende Anzahl an Runden enthält. Ist diese auf 0 gesunken, so ist das Spiel vorbei und ihr könnt eure Punktzahl mithilfe von _GetPoints() ermitteln. Diese teilt den String auf und schaut, wie viele Einsen auf der einen und wie viele Nullen auf der anderen Seite ist. Dabei wird nicht exakt in der Mitte geteilt, sondern dort wo ihr die meisten Punkte mit bekommen könnt. Es spielt auch keine Rolle ob ihr die Einsen eher nach links als nach rechts sortiert, das Beste Ergebnis wird euch errechnet.

Noch ein kleiner Tipp: Es sind so viele Einsen wie auch Nullen im Spiel vorhanden. Ich wünsche euch viel Erfolg! Mal schau'n wer die beste Punktzahl heraus bekommt, es bieten sich da einige Möglichkeiten an.

Falls Fragen auftauchen, immer her damit. Ach ja, wenn ich am WE Zeit finde dann versuche ich mal das Skript zu optimieren sodass es schneller läuft. Hab dazu gerade keine Zeit mehr. Und wer die Master Lösung herausfindet (*g* ^^) behält sie bitte erstmal für sich, ja?

Hey, ist im Grunde ganz einfach. Musst nur in der libdiscid-0.6.1-win32\libdiscid-0.6.1\include\discid\discid.h ein wenig herum wühlen und dir die Dokumentation dadrin durchlesen. Ist eigentlich alles sehr gut beschrieben. Ein Beispielcode dazu findest du auch hier: http://jonnyjd.github.io/libdiscid/

Dazu mal ein passender AutoIt Code:

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

OnAutoItExitRegister(__DiscID_Close__)

Global $g_hDiscID = DllOpen('discid.dll')

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Global $pDisc = _DiscID_New()

If Not _DiscID_ReadSparse($pDisc, Null, 0) Then
ConsoleWrite('! ERROR: ' & _DiscID_GetErrorMsg($pDisc) & @CRLF)
Else
ConsoleWrite(_DiscID_GetID($pDisc) & @CRLF)
EndIf

_DiscID_Free($pDisc)

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func _DiscID_New()
Return DllCall($g_hDiscID, 'ptr:cdecl', 'discid_new')[0]
EndFunc

Func _DiscID_ReadSparse($pD, $sDevice, $iFeatures)
Return DllCall($g_hDiscID, 'int:cdecl', 'discid_read_sparse', 'ptr', $pD, 'str', $sDevice, 'uint', $iFeatures)[0]
EndFunc

Func _DiscID_GetErrorMsg($pD)
Return DllCall($g_hDiscID, 'str:cdecl', 'discid_get_error_msg', 'ptr', $pD)[0]
EndFunc

Func _DiscID_GetID($pD)
Return DllCall($g_hDiscID, 'str:cdecl', 'discid_get_id', 'ptr', $pD)[0]
EndFunc

Func _DiscID_Free($pD)
DllCall($g_hDiscID, 'none:cdecl', 'discid_free', 'ptr', $pD)
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func __DiscID_Close__()
DllClose($g_hDiscID)
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Also, der Fehler versteckt sich in Zeile 9. Du deklarierst dort eine LOKALE Variable. Der Speicherplatz wird ja normalerweise beim Beenden der Funktion wieder freigegeben. Da du aber mit einen Pointer arbeitest und auf den freigegebenen Speicherplatz verweist, kann es sein dass der Speicher bereits schon mit neuen Werten überschrieben wurde. Das ist auch der Grund warum der Code bei AspirinJunkie scheinbar funktioniert, er hatte nur Glück bei der Ausführung, dass die Werte in dem Speicherbereich noch nicht überschrieben wurde. Abhilfe schafft hier eine statische lokale oder globale Variable.

$tRet = _SomeFunc()
$tRetTime = DllStructCreate($tRet.tagTime, $tRet.Time)
For $i = 1 To 6
ConsoleWrite('Return ' & $i & ': ' & DllStructGetData($tRetTime, $i) & @CRLF)
Next

Func _SomeFunc()
Local $tagTime = 'char Year[4];char Month[2];char Day[2];char Hour[2];char Min[2];char Sec[2]'
Local Static $tTime = DllStructCreate($tagTime)
DllStructSetData($tTime, 'Year', @YEAR)
DllStructSetData($tTime, 'Month', @MON)
DllStructSetData($tTime, 'Day', @MDAY)
DllStructSetData($tTime, 'Hour', @HOUR)
DllStructSetData($tTime, 'Min', @MIN)
DllStructSetData($tTime, 'Sec', @SEC)
Local $t = DllStructCreate('struct;ptr Time;char tagTime[75];endstruct')
DllStructSetData($t, 'Time', DllStructGetPtr($tTime))
DllStructSetData($t, 'tagTime', $tagTime)

; prüfen ob Struktur gefüllt und auslesbar
Local $tCheck = DllStructCreate($t.tagTime, $t.Time)
For $i = 1 To 6
ConsoleWrite('Check Feld ' & $i & ': ' & DllStructGetData($tCheck, $i) & @CRLF)
Next

Return $t
EndFunc

Ups
Na ja, gut das du nochmal drüber schaust.
Passiert mir aber garantiert nicht nochmal.

Servus, habe 4 weitere Päckchen für dich.
In 2 der Dateien war tatsächlich was neues zum übersetzen, alles andere habe ich auf Formatierungen und Übersetzung hin nochmal geprüft.
Nur hier und da eine Kleinigkeit die ich mal geändert habe, größten Teil eben nur die Formatierung.

In dem Archiv _GUICtrlToolbar_GetButtonInfo - bis - _GUIToolTip_BitsToTTF.zip solltest du dir mal die Datei _GUIToolTip_AddTool deutsch.txt und _GUIToolTip_BitsToTTF deutsch.txt genauer ansehen. Habe das nicht "wortwörtlich" übersetzt sondern eher sinngemäß. Schau mal ob das so passt und ob ich das für zukünftige Dateien dann so fortführen kann.

Tach, wäre es nicht sinnvoll direkt auf die 3.3.12.0 zuzusteuern oder zu warten bis die nächste Stable heraus kommt? Der AutoIt-Version-Boom ist ja soweit vorbei und ich denke die nächste Stable wird wieder länger halten. Da macht es doch direkt Sinn darauf hinzuarbeiten. Will mal versuchen mich auch wieder einzubringen.

Zitat

Ich muss mir noch überlegen, wie ich die Sekunden "weicher" bewegen kann.

Ist doch im Grunde einfach. Derzeitig bewegst du die Leuchtpunkte in den Augen im Sekundentakt um 6°. Du kannst aber auch die Leuchtpunkte im 1/6 Sekundentakt um 1° bewegen. Dadurch hast du automatisch eine feinere Bewegung. Noch besser ist natürlich ein noch kleinerer Intervall.

#pragma compile(FileVersion, 0.9.5.0)
#pragma compile(ProductVersion, 3.3.12.0)
#pragma compile(inputboxres, false)
#pragma compile(Icon, Eye_Clock.ico)
#AutoIt3Wrapper_Run_Au3Stripper=y
#Au3Stripper_Parameters=/SO
#AutoIt3Wrapper_Run_After=del /f /q "%scriptdir%\%scriptfile%_stripped.au3"

AutoItSetOption("TrayMenuMode", 11)

#include <Date.au3>
#include <GDIPlus.au3>
#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>
#include <WindowsConstants.au3>

Global Const $sTitle = "Eye Clock by UEZ ", $sVersion = "v0.95 build 2015-05-23"
#OnAutoItStartRegister "OnAutoItStart"
Global $__Restart = False

Global $iX, $iY, $fScale, $bSpeak_Init, $sPath_BgTexture, $iTexture_Fillmode

$iX = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "WinPosX")
If @error Then $iX = -1
$iY = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "WinPosY")
If @error Then $iY = -1
$fScale = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Scale")
If @error Then $fScale = 0.5
$fScale = $fScale < 0.1 ? 0.1 : $fScale > 4.0 ? 4.0 : $fScale
$bSpeak_Init = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Speak")
If @error Then $bSpeak_Init = 1
$iTexture_Fillmode = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "FillMode")
If @error Then $iTexture_Fillmode = 0
$iTexture_Fillmode = $iTexture_Fillmode < 0 ? 0 : $iTexture_Fillmode > 4 ? 4 : $iTexture_Fillmode
$sPath_BgTexture = RegRead("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Path_BgTexture")
Global $sBmpFormats = ".JPG|.BMP|.GIF|.PNG|.TIF"
If Not StringInStr($sBmpFormats, StringRight($sPath_BgTexture, 4)) Or Not FileExists($sPath_BgTexture) Then
$sPath_BgTexture = 0
$iTexture_Fillmode = 3
EndIf

_GDIPlus_Startup()
;if you want to resize the GUI please use $fScale only -> 1.0 = 100%, 0.5 = 50%, 1.5 = 150%
Global Const $iW = 768 * $fScale, $iH = 384 * $fScale, $iR2 = 170 * $fScale, $fD2R = ACos(-1) / 180, $fR2D = 180 / ACos(-1), _
$STM_SETIMAGE = 0x0172, $iW2 = $iW / 2, $iBorder = 5 * $fScale

Global $iR = 62 * $fScale, $fX1 = $fScale * 128, $fX2 = $fScale * 512, $fY1 = $fScale * 128, $fY2 = $fScale * 128, $f = 1, $x = 0, $y = 0, _
$aWinPos, $fVx, $fVy, $fAngle, $z = -0x7FFFFFFF, $zz, $hBmp_Texture

Global Const $hGUI = GUICreate($sTitle, $iW, $iH, $iX, $iY, $WS_POPUP, $WS_EX_TOPMOST)
GUICtrlCreateLabel("", 0, 0, $iW, $iH, -1, $GUI_WS_EX_PARENTDRAG)
Global Const $iPic = GUICtrlCreatePic("", 0, 0, $iW, $iH)
If Not $sPath_BgTexture Then
$hBmp_Texture = _GDIPlus_BitmapCreateFromMemory(_Background())
Else
$hBmp_Texture = _GDIPlus_BitmapCreateFromFile($sPath_BgTexture)
EndIf
Global Const $hBmp_Bg = _GDIPlus_BitmapCreateFromScan0($iW, $iH)
Global Const $hTexture = _GDIPlus_TextureCreate($hBmp_Texture, $iTexture_Fillmode)
Global Const $hCtxt = _GDIPlus_ImageGetGraphicsContext($hBmp_Bg)
_GDIPlus_GraphicsSetSmoothingMode($hCtxt, 4)
Global Const $hPen = _GDIPlus_PenCreate(0xE0A0A0A0, $iBorder)
_GDIPlus_GraphicsFillRect($hCtxt, 0, 0, $iW, $iH, $hTexture)
_GDIPlus_GraphicsDrawRect($hCtxt, 0, 0, $iW - 1, $iH - 1, $hPen)
Global Const $hBrush_Eye = _GDIPlus_BrushCreateSolid(0xF8FFFFFF)
_GDIPlus_GraphicsFillEllipse($hCtxt, $fScale * 64, $fScale * 64, $fScale * 256, $fScale * 256, $hBrush_Eye)
_GDIPlus_GraphicsFillEllipse($hCtxt, $fScale * 448, $fScale * 64, $fScale * 256, $fScale * 256, $hBrush_Eye)
Global Const $hPen_EyeBorder = _GDIPlus_PenCreate(0x50000000, 3)
_GDIPlus_GraphicsDrawEllipse($hCtxt, $fScale * 64, $fScale * 64, $fScale * 256, $fScale * 256, $hPen_EyeBorder)
_GDIPlus_GraphicsDrawEllipse($hCtxt, $fScale * 448, $fScale * 64, $fScale * 256, $fScale * 256, $hPen_EyeBorder)
Global Const $hBmp_Eye = _GDIPlus_BitmapCreateFromMemory(_Eye())
Global Const $hBmp_Pupil = _GDIPlus_BitmapCreateFromMemory(_Pupil())
Global Const $hBmp_Gradient = _GDIPlus_BitmapCreateFromMemory(_Pupillight())
Global $sTm, $bShowAMPM = False, $hr, $min, $sec, $sec_prev, $ms, $fms, $bMode = 0, $fTimer, $iDirL, $iDirR, $iSleep = 200

Global $oVoice = ObjCreate("SAPI.SpVoice"), $hUser32Dll = DllOpen("user32.dll")
If @error Then
$bSpeak_Init = 0
Else
$oVoice.Rate = -3
EndIf

Eye_Clock()

GUIRegisterMsg($WM_TIMER, "Eye_Clock") ;$WM_TIMER = 0x0113
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
$fms = TimerInit()

AdlibRegister("ChangeMode", 180 * 1000)

GUISetState()

Global Const $iTray_About = TrayCreateItem("About")
TrayCreateItem("")
Global Const $iTray_Reset = TrayCreateItem("Reset Settings")
TrayCreateItem("")
Global Const $iTray_Exit = TrayCreateItem("Exit")

Do
Switch GUIGetMsg()
Case $GUI_EVENT_CLOSE
$aWinPos = WinGetPos($hGUI)
_Exit($aWinPos[0], $aWinPos[1], $fScale, $bSpeak_Init, $sPath_BgTexture, $iTexture_Fillmode)
Exit
EndSwitch
Switch TrayGetMsg()
Case $iTray_Exit
$aWinPos = WinGetPos($hGUI)
_Exit($aWinPos[0], $aWinPos[1], $fScale, $bSpeak_Init, $sPath_BgTexture, $iTexture_Fillmode)
Exit
Case $iTray_Reset
$fScale = 0.5
$bSpeak_Init = 1
$sPath_BgTexture = 0
$iTexture_Fillmode = 3
_Exit(Int((@DesktopWidth - 768 * $fScale) / 2), Int((@DesktopHeight - 384 * $fScale) / 2), $fScale, $bSpeak_Init, $sPath_BgTexture, $iTexture_Fillmode)
_RestartScript()
Case $iTray_About
MsgBox(BitOR($MB_ICONINFORMATION, $MB_APPLMODAL, $MB_TOPMOST), "About", _
$sTitle & $sVersion & @CRLF & @CRLF & _
"Coded by UEZ", 30, $hGUI)

EndSwitch
If $bSpeak_Init And @MIN = 0 And @SEC = 0 Then
Sleep(1100)
$oVoice.Speak("It is now " & Mod(@HOUR, 12) & " " & $sTm, 1)
EndIf

Until False

Func _Exit($iX, $iY, $fScale, $bSpeak_Init, $sPath_BgTexture, $iTexture_Fillmode)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "WinPosX", "REG_SZ", $iX)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "WinPosY", "REG_SZ", $iY)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Scale", "REG_SZ", $fScale)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Speak", "REG_SZ", $bSpeak_Init)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "Path_BgTexture", "REG_SZ", $sPath_BgTexture)
RegWrite("HKEY_CURRENT_USER\Software\UEZ Software Development\Eye Clock", "FillMode", "REG_SZ", $iTexture_Fillmode)
$oVoice = Null
GUIRegisterMsg($WM_TIMER, "")
AdlibUnRegister("ChangeMode")
_GDIPlus_PenDispose($hPen)
_GDIPlus_BrushDispose($hTexture)
_GDIPlus_BrushDispose($hBrush_Eye)
_GDIPlus_PenDispose($hPen_EyeBorder)
_GDIPlus_GraphicsDispose($hCtxt)
_GDIPlus_BitmapDispose($hBmp_Texture)
_GDIPlus_BitmapDispose($hBmp_Bg)
_GDIPlus_BitmapDispose($hBmp_Eye)
_GDIPlus_BitmapDispose($hBmp_Pupil)
_GDIPlus_BitmapDispose($hBmp_Gradient)
_GDIPlus_Shutdown()
GUIDelete()
DllClose($hUser32Dll)
EndFunc ;==>_Exit

Func ChangeMode()
$bMode = Random(0, 3, 1)
Switch $bMode
Case 0
$x = 0
$y = 0
$f = 1
$iR = 62 * $fScale
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
Case 1
$x = 0
$y = 0
$f = 1
$iR = 62 * $fScale
$fTimer = TimerInit()
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", 60, "int", 0)
Case 2
$x = 0
$y = 0
$f = 1
$iR = 62 * $fScale
$iDirL = Random(-1, 1, 1)
$iDirL = ($iDirL = 0) ? $iDirL - 1 : $iDirL
$iDirR = Random(-1, 1, 1)
$iDirR = ($iDirR = 0) ? $iDirR + 1 : $iDirR
$fTimer = TimerInit()
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", 60, "int", 0)
Case 3
$x = -64 * $fScale
$y = -64 * $fScale
$f = 2
$iR = 0
$fTimer = TimerInit()
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
EndSwitch
EndFunc ;==>ChangeMode

Func Eye_Clock()
Local Const $hBitmap = _GDIPlus_BitmapCreateFromScan0($iW, $iH)
Local Const $hCtxt = _GDIPlus_ImageGetGraphicsContext($hBitmap)
_GDIPlus_GraphicsSetSmoothingMode($hCtxt, 4)
_GDIPlus_GraphicsSetTextRenderingHint($hCtxt, 5)
_GDIPlus_GraphicsSetPixelOffsetMode($hCtxt, 2)
_GDIPlus_GraphicsSetInterpolationMode($hCtxt, 7)
_GDIPlus_GraphicsSetCompositingQuality($hCtxt, 2)

_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Bg, 0, 0, $iW, $iH)

Switch $bMode
Case 0 ;default
$hr = @HOUR + @MIN / 60
$min = @MIN + @SEC / 60
Case 1 ;curious
If TimerDiff($fTimer) > 15 * 1000 Then
$bMode = 0
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
EndIf
$aWinPos = WinGetPos($hGUI)
$fVx = MouseGetPos(0) - ($aWinPos[0] + $fX1 + $iR)
$fVy = ($aWinPos[1] + $fY1 + $iR) - MouseGetPos(1)
$fAngle = 90 - ATan($fVy / $fVx) * $fR2D
If $fVx < 0 Then $fAngle += 180
$hr = $fAngle / 30
$fVx = MouseGetPos(0) - ($aWinPos[0] + $fX2 + $iR)
$fVy = ($aWinPos[1] + $fY2 + $iR) - MouseGetPos(1)
$fAngle = 90 - ATan($fVy / $fVx) * $fR2D
If $fVx < 0 Then $fAngle += 180
$min = $fAngle / 6
Case 2 ;spinning
If TimerDiff($fTimer) > 7.5 * 1000 Then
$bMode = 0
$hr = @HOUR + @MIN / 60
$min = @MIN + @SEC / 60
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
Else
$hr = Mod($hr + 1.5 * $iDirL, 12)
$min = Mod($min + 6 * $iDirR, 60)
EndIf
Case 3 ;big pupils
If TimerDiff($fTimer) > 10 * 1000 Then
$bMode = 0
$x = 0
$y = 0
$f = 1
$iR = 62 * $fScale
$hr = @HOUR + @MIN / 60
$min = @MIN + @SEC / 60
DllCall($hUser32Dll, "int", "SetTimer", "hwnd", $hGUI, "int", 0, "int", $iSleep, "int", 0)
EndIf
EndSwitch
$sec = @SEC + @MSEC / 1000

Local $fXPos_hr = $x + $fX1 + Cos((-90 + 30 * Mod($hr, 12) + $min / 2) * $fD2R) * $iR, _
$fYPos_hr = $y + $fY1 + Sin((-90 + 30 * Mod($hr, 12) + $min / 2) * $fD2R) * $iR, _
$fXPos_min = $x + $fX2 + Cos((-90 + 6 * $min) * $fD2R) * $iR, _
$fYPos_min = $y + $fY2 + Sin((-90 + 6 * $min) * $fD2R) * $iR, _
$fSize = $f * $fScale * 128, $fRadius_Lensflare = $fSize / 2 - 20 * $fScale, $fLensflare_size = 40 * $fScale
;hr
_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Pupil, $fXPos_hr, $fYPos_hr, $fSize, $fSize)
;min
_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Pupil, $fXPos_min, $fYPos_min, $fSize, $fSize)

;pupils
_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Eye, $fScale * 64, $fScale * 64, $fScale * 256, $fScale * 256)
_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Eye, $fScale * 448, $fScale * 64, $fScale * 256, $fScale * 256)

;sec
$ms = $sec
_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Gradient, _
($fXPos_hr + ($fSize - $fLensflare_size) / 2) + Cos((-90 + 6 * $ms) * $fD2R) * $fRadius_Lensflare, _
($fYPos_hr + ($fSize - $fLensflare_size) / 2)+ Sin((-90 + 6 * $ms) * $fD2R) * $fRadius_Lensflare, _
$fLensflare_size, $fLensflare_size)

_GDIPlus_GraphicsDrawImageRect($hCtxt, $hBmp_Gradient, _
($fXPos_min + ($fSize - $fLensflare_size) / 2) + Cos((-90 + 6 * $ms) * $fD2R) * $fRadius_Lensflare, _
($fYPos_min + ($fSize - $fLensflare_size) / 2)+ Sin((-90 + 6 * $ms) * $fD2R) * $fRadius_Lensflare, _
$fLensflare_size, $fLensflare_size)

If $sec <> $sec_prev Then
$sec_prev = $sec
$fms = TimerInit()
EndIf

Local Const $hBrush = _GDIPlus_BrushCreateSolid(0xF8000000)
;~ _GDIPlus_GraphicsFillPie($hCtxt, $iW2 - $iR2 / 2, $iH - ($iR2 + $iBorder) / 2 + 1, $iR2, $iR2, -180, (1 + $sec) * 3, $hBrush)

If $bShowAMPM Then
$sTm = "AM"
If Int(StringLeft(_NowTime(4), 2) / 12) Then $sTm = "PM"
_GDIPlus_BrushSetSolidColor($hBrush, 0xA0FF0000)
Local Const $hFormat = _GDIPlus_StringFormatCreate()
Local Const $hFamily = _GDIPlus_FontFamilyCreate("Impact")
Local Const $hFont = _GDIPlus_FontCreate($hFamily, $fScale * 40)
Local Const $tLayout = _GDIPlus_RectFCreate(0, $iH - $fScale * 58, $iW, $fScale * 55)
_GDIPlus_StringFormatSetAlign($hFormat, 1)
_GDIPlus_GraphicsDrawStringEx($hCtxt, $sTm, $hFont, $tLayout, $hFormat, $hBrush)
_GDIPlus_FontDispose($hFont)
_GDIPlus_FontFamilyDispose($hFamily)
_GDIPlus_StringFormatDispose($hFormat)
EndIf

Local Const $hBmp_GDI = _GDIPlus_BitmapCreateHBITMAPFromBitmap($hBitmap)
_WinAPI_DeleteObject(GUICtrlSendMsg($iPic, $STM_SETIMAGE, $IMAGE_BITMAP, $hBmp_GDI))

_GDIPlus_BrushDispose($hBrush)
_WinAPI_DeleteObject($hBmp_GDI)
_GDIPlus_GraphicsDispose($hCtxt)
_GDIPlus_BitmapDispose($hBitmap)
EndFunc ;==>Eye_Clock

Func _RestartScript($fExit = 1) ;thanks to Yashied
Local $iPID
If Not $__Restart Then
If @Compiled Then
$iPID = Run(@ScriptFullPath & ' ' & $CmdLineRaw, @ScriptDir, Default, 1)
Else
$iPID = Run(@AutoItExe & ' "' & @ScriptFullPath & '" ' & $CmdLineRaw, @ScriptDir, Default, 1)
EndIf
If @error Then
Return SetError(@error, 0, 0)
EndIf
StdinWrite($iPID, @AutoItPID)
EndIf
$__Restart = True
If $fExit Then
Sleep(50)
Exit
EndIf
Return 1
EndFunc ;==>_RestartScript

#Region images
;Code below was generated by: 'File to Base64 String' Code Generator v1.20 Build 2015-03-02

Func _Background($bSaveBinary = False, $sSavePath = @ScriptDir)
Local $Background
$Background &= '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'
$Background &= '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'
$Background &= 'ENTUELtCZIVOQWuPOXTPu32MHxRLzXfLxpvWA5ATBgJBRggtRPoXL3DOIyPgzUKQlqR3ZwWkKfBK9y9lo0dIeIFIC0GBIRibke6/7PdSnMiIjDAIXF1AQw58H6hIwF/KxqFXJKCllM236gGLDERyUi9fs1anCqyLxpHU9EP+NjwLD3LD3bJR8r/HwuKNxWsTN68uLh5+66zqP9wTHfv2+tWFbas+u35p5OLodTd144r3T7uWv9YvHrtwt2x809r6/9IOPmi/0mOSAAAAAElFTkSuQmCC'
Local $bString = _WinAPI_Base64Decode($Background)
If @error Then Return SetError(1, 0, 0)
$bString = Binary($bString)
If $bSaveBinary Then
Local Const $hFile = FileOpen($sSavePath & "\brickwall.png", 18)
If @error Then Return SetError(2, 0, $bString)
FileWrite($hFile, $bString)
FileClose($hFile)
EndIf
Return $bString
EndFunc ;==>_Background

Func _Eye($bSaveBinary = False, $sSavePath = @ScriptDir)
Local $Eye
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= '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'
$Eye &= 'fUsp0c/NWYJP3hxqEFjwebQ36LQX4T5OiANIFsVmLSg8QcEFoeXW4rlRChUFQwaUNd6EDmWNQOug3tdO2J0EXucRuc2iWH0AdCrUErr1lpGerIHgIz6HXX0enR3IFwcQGkSJQRZZA+IJJoWw5Hzm4hU15vViEe2UgiwwqnKwUxRuYbpezSDo8ru4eR+7MEglSAsKD1IWHM0OCP4iCrwqKN1lco/H2g/kj/0jIyNRhAf5bDZLR5Xvxv+e13gFpqKWYYdY2El4dIqhYaMkOgXdvbw+Z90FEWpKkRbFtRYw57tQ2j2L+D5XrVYjyWSSXX0e6z/oC8D04RJswgbCgx3YmDsEaVhTiKkBhSgrS5zBcAc8hG5BwyDsNQeis+TTF0oNiN9tYm53omR3vlKp1CH4SYRmfAQ3j67yCiIoKR0AeTiGEGFZKIMZsfEHFM/ASikWpRh8yMZDqLXgZq+nwNuFJLKFH/Idn+rUpTkL4lozNIc0l1C0Y5jfAVTtca0+j+4eIAvpg5dhIA8rRZ+HJtKQ0olNISwlabNb3oFaCltWFIKTUlhL5dBwwUGowj6skJB2xU458d50L8q07MScLaEuYwJdnHmUbIcRarGLz2PzDbDRfmQQeuCyZpFOnKBz5EVKcVEQiBUhFDkNd1DQKAVTbt1CzQN0VtsOKqE47NNXNaqlzmosb8XzdD3qylykmB4h1BzmawKKMwuitYcP4uCxFTmDHpCHCYQJtXK5PIGYdqcIFSyFUBMClFcsZF7xFGTFMKjxGoYcFIUTVCsupxMHNYIuW3bdsw8KZUMCv0TVefTuNAeYkxoUZAI5e3bveWyfAY+APj8ewcbP0JeO0PM/E4/HV6wh/nlZuMOTQnDKvuMr/9TwQS29NSkJLyhprldQ7qkKekE8a108O70DkaO76N3oHeld0YjTT+/O+XoePN7kDgLIZwfhHWSR084h7p2gNCMVuOCf3yJ4hCUhVFMiZq5qCDXZ1ZZLd71CvY6sZMri3qPiWebEs5Hyegvl5ilNR+9AqTpY+jSKdIL4Ows8Dx5eBjyEKBRDEqFDHwRoFOTYONzmlfABfMJuuNO7Rc/CTuE5LAqBnBXCOQGM+8xVdzKBOCp+lqz3tLjGnLgmCTjdc5e45256BnoWeiYI/AgUVx+Y+iT+zl/N4cFjLQeEjBRDDHUIMbjVWXgQDToAFa51A39vwN0mwT2hHdAZeXQtuiYEvQFirgH3PQtlFINFjyGM4Z76TTz+P6XQCEY4pXqLAAAAAElFTkSuQmCC'
Local $bString = _WinAPI_Base64Decode($Eye)
If @error Then Return SetError(1, 0, 0)
$bString = Binary($bString)
If $bSaveBinary Then
Local Const $hFile = FileOpen($sSavePath & "\highlight_256x256.png", 18)
If @error Then Return SetError(2, 0, $bString)
FileWrite($hFile, $bString)
FileClose($hFile)
EndIf
Return $bString
EndFunc ;==>_Eye

Func _Pupil($bSaveBinary = False, $sSavePath = @ScriptDir)
Local $Pupil
$Pupil &= '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'
$Pupil &= '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'
$Pupil &= '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'
$Pupil &= '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'
$Pupil &= 'bTg3OCOsnte2dRUuv1XD16uEKtHc4D7C6TYE/rzwgBziGCgaaKlEG3xkbjAIsg7yAuT3IhNurad1fgrZKZplbOzkJ+KnISxw3pDXmP4T5HetSBHOC/D3iv0SHtUubCvuPkxYoDV0SNTPGKwRewq/SbTMAdQ6Edb+GXKnyHli8JYPFYHXmfSHzBfJ4o9EW/lixKHT2n8BOSSqneGirIvBp5kjcF+BJ1zHQFZB/gLyE8jHiWhsO9cKxfyFyOh5E+cUUe6WtdZ6vrnCAxe0B2Q05JpE/VAqF50j6h+KJKup84ZqUb79PFE/+7BXWDq3wfuIXCa29iZWhjzhGZhF9xbeYb6ItX+eqN9Bo1K8LRSDXTbOJ9QIi60VoUQV+fs1AvJnwsuwT/GGSEzp1nnfztJE/dFrDsVWijIuv62WclFRiCJhfd0EmBGJ+rtxFggLXS+6bfdB9kMOQB4WchDydcj9ifqzdRsgq4WXmSY8Dnc2ewqlK4mBR1shUkIpCoRi0ELLRYVRKbpu3UU4kdJNZOkdRQJaJrxMgQK71bn1/wdIEmtZJi7AZQAAAABJRU5ErkJggg=='
Local $bString = _WinAPI_Base64Decode($Pupil)
If @error Then Return SetError(1, 0, 0)
$bString = Binary($bString)
If $bSaveBinary Then
Local Const $hFile = FileOpen($sSavePath & "\018712-glossy-black-icon-symbols-shapes-shapes-circle_128x128.png", 18)
If @error Then Return SetError(2, 0, $bString)
FileWrite($hFile, $bString)
FileClose($hFile)
EndIf
Return $bString
EndFunc ;==>_Pupil

Func _Pupillight($bSaveBinary = False, $sSavePath = @ScriptDir)
Local $Pupillight
$Pupillight &= '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'
$Pupillight &= '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'
$Pupillight &= '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'
$Pupillight &= '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'
$Pupillight &= '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'
$Pupillight &= 'Q7EKPKpXA77bcDUg91kAezlcDXjSEF8NeJzlasB5lqsBdw64GvBvI10NWC8G6tD9AFwA8EYNAGz3A+A+C3BuhPsBnGm4H8AtlvsBjCe4H8ASy/0ArmvhfgDbkfsBvNPjfgD1cuAhAoD0jkCutwSX3BG4zTsCfZ+5I9B4xDsCjTN3BLrP845AR2S6I5DrDUHa/GyAekegFm8J1uY9AQ/S3BPwJME9AW8R3BNwPMI9AccF9wS8nqT/9Z6AQ3xLsBLvChzzY8FsAMBHgdK7Au+uyQFsdwU+w+GuwA9o7go8HnBX4CWauwLf63FXYNMC0H7M/L+r4F4A0hMAKQA2LfimoPW24Jk+F0CyC+ATBKb4XICbhZ8LMO7xuQB/En4uAL4X4GWWzwX4RMDnArgGgLnWgCsAMn8wSI5dANcgkPtkoLkeY8DhZC34k8QF2D4Z6NuGTwZ6ET75x/bJQC/Cpp/uk4G+7vHJQMdm+GQgUwDocgIwTGvAUQDQlW3A0PsCbsGcBNAg0PTZgDtaPhuQjgH7oDEg5LMBryefDXgv3CtA99mAzw12+XsX9EzVH0D0vzV8NuC95GPBrkcfELoALf7oPhvwCMMnBEvs//sdPhswwQlAMTsAI/fZgKEnARtHOglwzQFMY4DUBZwAJwKnWz4dWEEAfzrwfTAShH468H1wtR/+dODr0dz/WfJhIPTTgaXdX2L/Y8z/b4T/3rFPAIYCAMP68eCxcgDBQpDoA0K5MJBmAfg24XgUOA/lAVcgJ/CvkAncBqcDd8OewH0wFnwPdvcfhM7+E1QPwdd/CI97AIT/Lej6X4HXvRlsv/pU4CvQ3H8eY/1V8q/7ZGDJ9h+1/znm/5H9ePCuHQWaTgJy5QDccSA+DXB1AYeiC4TUXgAeBRQE5gMElBO4CoLBG+Bo7nZYFrp74Aj6o8F3YDy4H0T+Xfj9fvj6fWD17wHhfxVe5xZI+78E74M7/3wkfmT9Z5z7q+TftftL0n/b+X+K+T/GCUCrOwBtASDWSYBvECjNAULGAG4r0OQC8GagcgF4FBhcJTh9KqA2BM9D48ACCOIWwhHhdXD/QAWCO2E0uGtwKXHvfgJ9kX8Tfv8GfP0usPp3IuHfhCz/QnifBcj2n4c2/k4dpP5TV/1h64+Tf7X5Z+r+uu0/l/3/0Pk/VgCY43MBswIgx1FgQBBoXAnW5QC+Y4BpK5BzAbtDt8MuYF/0YaEHM6OAygNOZpzARRAMXg5HccoNKBDcCBcQ3Qo2/nYI8u4Aoat/vh2+fys8/kaw+9eirv85eJ9LiO0/c/rIb8bcj62/OvfHF/7Q7r8r0/3N239y+x+yABQjAHQFQNITgBwAKCkI9P2MAN0YwJ0G6FzAHKELUHsBB5HlIBsEPg3p+8XQlRcgECyEpP5LAIMboKPfzNRN8P3rwOqrjq+EvwDm/Yvh/T5NbD8nfrz0cxA59/ft/i7pv8n+x5z/SwwAowIg1UmAaxCYOgfwGQNoGLi9wAXsZgkEuTyAg8AZkLqfC+fvyg1gEFwJl+guhE5+NYj7WlJXw/cXwuOvJML/DLz++fB+Z8P7c+Ln5v6PGII/3exPu79L+Odq/1PM/7EDwGgnACkB0FYQaMoBdPsArmOALQw0ZQHcXgA3CuBTAXU0SCFwPASD6lOEsBtQILgYrPrlIOIrQNCfB3F/AdWV8PXPweMWIKt/MRI+7vqnQ9p/Eoj/GCJ+deTHpf6c9WeSf1H355Z/Itr/JPN/jAAwGQBKCgJDcoDQMcC0FOTjAvBeADcK0FMBDgJqHFDB4ImwJ6DcwFkEBBdCSq9gcCkIW1eXIdHPh+dj4Z+Fuv4p8P7HI/F/QiN+mvpz1p+e+6fs/rntf3EBYAkAyJEDpBwDhC6A3QswjQL7IAj8I4IAzQSOgj2BE5AbOI2A4BwEgwtA0BdBzUelvnYhPE6J/hwi/NNI1z8Ofg4683Pi38di/U3n/lz3dwn/Utn/Uub/VgBQag4QMga4hIE2F2Da'
$Pupillight &= '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'
$Pupillight &= '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'
$Pupillight &= '1n8ZABTgAkqBgDQXsLkB21hgAoELDGwOIWHRn8FJ9Cbhh3Z933l/dMXf8VEgBwQkbsBlLAiBAQeE12oEuYHAMZg6uk7or2Pef/1Ios/R9VOJv1vWPwEAugCBWZEh4DMWSF2BBAYmKJjgICnd661vKZ3opd3eVfixxD+rcPGnBUDBeUAuCOhygRA34AMCCQzWEwhRCghXgZsELxF9qPBdur5p3i9J/Cu0Lv7C84CUEAh1A64gcBkPXIDgA4YQobsI3mTzQ4Sf0/J3Wvw5AVAyBEJzAZ+xwAUEEhjogGADQ2jp3u/VEUQvFb5r16/idxF/hYBxJNC5gRggkMBgXYvYXpOhXu0g+HU1f6bYwpd2/S6Kf/ns4o8IgC5BIIYbcAGBqyvwAUKOkgjeJHoX4afo+kMvfi8AZHYBuSAQkgv4jgUSEPg4AxMUYsNB9/rrOAheIvoUwnfp+lX8hY4CqSEQ4gZMY4HJEUhcwas0QlrHodYNLOn7rB1J9Dbh6+x+aNePLf7uzf1DBIFXJIZAKAikrkAKBFcohNbaQsG/yvJncxG9i/BDLX/Iht9wib8jeYAUAqG5QGoQ2GDgAoS1HWGxtme5CN6n24cIP5XlTyn+8gBQGARWiAyBGG7ABoJUMNBBIQQOEpFLxS4Rvc3mS4Wfy/L7zvzdFf8IQ6AtEHAwcAGCBA7S8nnPtTxF35bwq/gLBEAbEIg1FviCQAcDHRB8oRCz1hIK3iT6GMKv4k8NgCGAQEo34AuCNSzCcAVCKjDY3s9V8Gsyfw+lCr+Kv6MQSOEGYoLAFQYmILjAwbds77tmBNHHFn6qrj+a4h9yCIS4ASkIXGCwhlBUUjDEqjUdao1A0UuEH9r1q/hHFAIp3IALCEwwCAWCKyzWjFRSwdtEHyL8lJa/ij8BAEqEQAoQxIZBTCjEEnts0acS/lCIv1UAtAiBtkGwiiMIXF2BDQYSKIRCwuW1bT/napG6fdeFP1ziH3EIxALBqkKBrO5Ya0Qul/dezVP0sYRfxV8hIIJADhC4wmBVBwGtXkCtFih4H9HnEn4V/5BAwNcNuILA1xWYYLCqo8hiA2K1gFrVQ/S5hB/a9av4M0BguYwQ8HEDviCwwSAVEFKXr+BnCf6+XIWfsutX8RcKgS6CQAIDGxBywkH6c8xKKPouCH80xT8CEPAFgRQGUiC4QCF1zYokeJvofYVfxV8hkB0EsWDgAoSUcPD5GVz+jL6izyH8Kv6OQiCWG0gJAlcYhEAhZa0SUfA5hF981++8+BMBoE03YANBWzDICYaQny216GMKv3XxDwUACoJATDcQAwQrCQWxSodr5UiijyX8FF2/ir9lECzfohuQgCAmDEqGwsqOFUP0sYVfu351A62DwAcIOQCxcmC5/NlLF34V/4hBwAUEKWAQAwo5y+fPFlP0Kzr+t63iH2EItA2CECC0DYaQn9nl72aohT9y4s8AgdJA4AqDUCCEwCLV+74ioehTC7+Kf4Qg4AqCHDBICYRSBJ9a9MUJf+TFnwkCJYPAFwYlgSH051+xUOFX8Q8ZBEoHQSwgxAJFqp8j5O9mKIRfxd9NN+ADglAYpARCrloxs+ir8CsEigRBDBiUDIaYf7YVMgu/in9EIdAWCFIAITUgUv6soX+PRQu/ir98CISCoHQYlFhtin75nP9vVSWPhhuIBYJhhELMv5Mq/AqBToAgNgy6AoUUf+bluyT8Kv7hAUHpMGgLDjn+LMtX4ddfpUAgJghywaCLtXxXhV/FPxoQiA2CUQdCir/L5ar4Kwi6DIPlq+C7Ifoq/AqB1CDoMhRy/J0sV8Vff5UEglwwKAUObfxZl6vCr7+6AIK2YDCMtVwVfv3VZRBUGHRU9MMs/P8Hs251Dr37jDgAAAAASUVORK5CYII='
Local $bString = _WinAPI_Base64Decode($Pupillight)
If @error Then Return SetError(1, 0, 0)
$bString = Binary($bString)
If $bSaveBinary Then
Local Const $hFile = FileOpen($sSavePath & "\OARIy_v5.png", 18)
If @error Then Return SetError(2, 0, $bString)
FileWrite($hFile, $bString)
FileClose($hFile)
EndIf
Return $bString
EndFunc ;==>_Pupillight

Func _WinAPI_Base64Decode($sB64String)
Local $aCrypt = DllCall("Crypt32.dll", "bool", "CryptStringToBinaryA", "str", $sB64String, "dword", 0, "dword", 1, "ptr", 0, "dword*", 0, "ptr", 0, "ptr", 0)
If @error Or Not $aCrypt[0] Then Return SetError(1, 0, "")
Local $bBuffer = DllStructCreate("byte[" & $aCrypt[5] & "]")
$aCrypt = DllCall("Crypt32.dll", "bool", "CryptStringToBinaryA", "str", $sB64String, "dword", 0, "dword", 1, "struct*", $bBuffer, "dword*", $aCrypt[5], "ptr", 0, "ptr", 0)
If @error Or Not $aCrypt[0] Then Return SetError(2, 0, "")
Return DllStructGetData($bBuffer, 1)
EndFunc ;==>_WinAPI_Base64Decode
#EndRegion images

Zeile 247

Hö, wie meinst du das mit einer Zeile? Ich habe bisher immer alles in Einer Zeile verfrachtet und bisher kein Problem damit gehabt:

[*spoiler][*autoit]; Codezeile 1
; Codezeile 2
; Codezeile 3[*/autoit][*/spoiler]

You write AutoIt wrong on your website.
It's very funny. AutoIt means automate it, not AutoIT.

Zitat

Learn how to automate boring tasks and develop added value applications in record time using the popular scripting standard, AutoIT.

What I should think about this offer?

@zocker-udo
Echt Klasse, da hab ich ihn/sie gerade soweit von der ImageSearch UDF weg, da kommst du und sagst dass du eine lauffähige hast. Zudem bringt es absolut nichts nach dem Skript zu fragen, da er/sie uns bereits mitgeteilt hat dass es sich lediglich um das Video in Post #4 handelt. Sorry wenn das hier so blöd jetzt herüber kommt, aber mittlerweile zweifel ich ernsthaft an den Verstand der User hier. Nicht nur das Niveau des Designs scheint hier in dem Forum zu sinken, sondern auch die qualitativen Beiträge.

Ich selber programmiere schon seit 5 Jahren. Habe gesehen wie User ein Problem nach dem anderen mit dieser UDF hatten. Selber habe ich sie nie gebraucht. Ich verrate dir mal ein kleines Geheimnis: Die UDF hat weder irgend einen Wert noch ist sie in irgend einer Weise wirklich brauchbar. Selbst Programmierer die wirklich auf gute Bots aus sind haben andere Mittel ihr Ziel zu erreichen, ich spreche da aus Erfahrung. Keiner hier im Forum hat in irgend einer Weise Bock darauf eine so gut wie unnötige UDF zum Laufen zu bringen, nur weil du meinst mit dieser herumspielen zu müssen. Es hat weder einen Lerneffekt für dich noch einen effizienten Nutzen. Am besten schmeißt du die Datei einfach in den virtuellen Papiermüll auf deinen Desktop, damit ist nicht nur dir sondern auch allen anderen geholfen. Ist jetzt nicht böse gemeint, aber lerne lieber mit pragmatischeren UDFs umzugehen als mit der ImageSearch.au3.

Mal ganz ehrlich, die youtube tutorials kannst du gleich in die tonne werfen. Am besten liest du dir erst mal das buch von peethebee durch, alles andere wäre nur verschwendete zeit.

Es gibt kaum einen sinnvollen Einsatz der Imagesearch.au3 außer halt Bots.
Da kannst du noch so beteuern dass du keine schreiben möchtest.

Vielleicht wäre dir besser geholfen wenn du uns einfach mal erklärst was du vor hast.
Es gibt bestimmt einen besseren Weg (und einfacheren) als mit der Imagesearch.au3 zu hantieren.

Und dein Thread wird nicht wieder gelöscht wenn wir wissen was du erreichen möchtest.

Ich glaube du hast nicht verstanden was ich dir damit sagen wollte...

Probier einfach mal folgendes aus, dann siehst du es selber:

Global Const $g_sFunc = '_IrgendEinLangerUnoetigerFunktionName'
Global $g_iCall

$g_iCall = Call($g_sFunc)
;~ $g_iCall = _IrgendEinLangerUnoetigerFunktionName()

ConsoleWrite($g_iCall & @CRLF)

Func _IrgendEinLangerUnoetigerFunktionsName()
Return 7
EndFunc

Zitat

Sollte ich davon abweichen, weil es fehleranfälliger ist?

Genau das solltest du.
Sobald du eine Funktion via Call() aufrufst schlägt der Au3Check kein Alarm falls du dich vertippen solltest. Die einzige Möglichkeit um Fehler abzufangen wäre hinter jedem Call() Aufruf eine Error-Abfrage (If @error Then ; …) einzubauen. Wenn du jedoch die Funktion direkt aufrufst (so wie man das eigentlich machen sollte) kann bei einem Tippfehler der Au3Check dies erkennen. Die SciTE warnt dich und du kannst den Fehler sofort berichtigen.

Es gibt nur ganz wenige Ausnahmefälle wo Call() tatsächlich Sinn macht. Ich habe es bisher tatsächlich nur 2~3 mal gebraucht wo ich einfach nicht drum herum kam. Sollte man also nach Möglichkeit immer vermeiden!

Die Idee hatte ich auch, aber da in einer Kette die 1. Millionen überschritten werden kann, weißt du nicht ob vielleicht noch eine Zahl folgt die unter einer Millionen liegt. Demnach kann die Berechnung sogar unter Umständen zu lange dauern. Außerdem weißt du ja nicht wie lang die längste Kette ist sodass du diese Information als Abbruchbedingung nutzen könntest. Und es gibt zu viele Möglichkeiten wie die Kette aufgebaut sein könnte. Bei 556 Terme sind das 2^556 Möglichkeiten wie die Kette zusammengesetzt sein könnte. Aber nur eine Zahl liegt dabei als Anfangswert unter 1. Millionen. Bringt also nichts das Ganze Rückwärts zu versuchen.

Servus, wie einige vielleicht mitbekommen haben bin ich fleißig Aufgaben an lösen in der Proejct Euler. Normalerweise ist es so, dass es zu jeder Aufgabe (nach erfolgreichen Lösen) eine PDF gibt, wo ein optimierter Pseudocode + Erklärung niedergeschrieben sind. Bei Aufgabe 14 war dies aber nicht der Fall. Hier eine deutsche Übersetzung der Aufgabe: Aufgabe #14

Ich würde gerne einmal wissen wie ihr an die Aufgabe heran gehen würdet. Ich selber habe schon ein relativ geeignetes Lösungsverfahren gefunden, jedoch dauert die Berechnung bei mir etwa 100 Sekunden. Da geht bestimmt noch mehr.

Hier mal mein Skript zum Vergleich:

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

#include <MsgBoxConstants.au3>

Global Const $eTo = 999999

Global $oStack = ObjCreate('System.Collections.Stack')
Global $avNumbs[$eTo +1][2] = [[1, 1], [True, 1]]
Global Enum $eNum, $eState = 0, $eLen

Global $iFor, $iNext, $iLast, $iCount

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

For $iFor = 2 To $eTo
If Not $avNumbs[$iFor][$eState] Then
$iNext = (Mod($iFor, 2) ? 3 * $iFor +1 : $iFor / 2)

While $iNext > $eTo Or Not $avNumbs[$iNext][$eState]
$oStack.Push($iNext)
$iNext = (Mod($iNext, 2) ? 3 * $iNext +1 : $iNext / 2)
WEnd

$iCount = 1

While $oStack.Count
$iLast = $oStack.Pop()
If $iLast <= $eTo Then
$avNumbs[$iLast][$eLen] += $avNumbs[$iNext][$eLen] + $iCount
$avNumbs[$iLast][$eState] = True
$iNext = $iLast
$iCount = 1
Else
$iCount += 1
EndIf
WEnd

$avNumbs[$iFor][$eLen] = $avNumbs[$iNext][$eLen] + $iCount
$avNumbs[$iFor][$eState] = True

If $avNumbs[$iFor][$eLen] > $avNumbs[0][$eLen] Then
$avNumbs[0][$eNum] = $iFor
$avNumbs[0][$eLen] = $avNumbs[$iFor][$eLen]
EndIf
EndIf
Next

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

MsgBox($MB_TOPMOST, 'Problem 14 - Longest Collatz sequence', 'Num = ' & $avNumbs[0][$eNum] & @CRLF & 'Len = ' & $avNumbs[0][$eLen])

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

837799 -> 2513398 -> 1256699 -> 3770098 -> 1885049 -> 5655148 -> 2827574 -> 1413787 -> 4241362 -> 2120681 -> 6362044 -> 3181022 -> 1590511 -> 4771534 -> 2385767 -> 7157302 -> 3578651 -> 10735954 -> 5367977 -> 16103932 -> 8051966 -> 4025983 -> 12077950 -> 6038975 -> 18116926 -> 9058463 -> 27175390 -> 13587695 -> 40763086 -> 20381543 -> 61144630 -> 30572315 -> 91716946 -> 45858473 -> 137575420 -> 68787710 -> 34393855 -> 103181566 -> 51590783 -> 154772350 -> 77386175 -> 232158526 -> 116079263 -> 348237790 -> 174118895 -> 522356686 -> 261178343 -> 783535030 -> 391767515 -> 1175302546 -> 587651273 -> 1762953820 -> 881476910 -> 440738455 -> 1322215366 -> 661107683 -> 1983323050 -> 991661525 -> 2974984576 -> 1487492288 -> 743746144 -> 371873072 -> 185936536 -> 92968268 -> 46484134 -> 23242067 -> 69726202 -> 34863101 -> 104589304 -> 52294652 -> 26147326 -> 13073663 -> 39220990 -> 19610495 -> 58831486 -> 29415743 -> 88247230 -> 44123615 -> 132370846 -> 66185423 -> 198556270 -> 99278135 -> 297834406 -> 148917203 -> 446751610 -> 223375805 -> 670127416 -> 335063708 -> 167531854 -> 83765927 -> 251297782 -> 125648891 -> 376946674 -> 188473337 -> 565420012 -> 282710006 -> 141355003 -> 424065010 -> 212032505 -> 636097516 -> 318048758 -> 159024379 -> 477073138 -> 238536569 -> 715609708 -> 357804854 -> 178902427 -> 536707282 -> 268353641 -> 805060924 -> 402530462 -> 201265231 -> 603795694 -> 301897847 -> 905693542 -> 452846771 -> 1358540314 -> 679270157 -> 2037810472 -> 1018905236 -> 509452618 -> 254726309 -> 764178928 -> 382089464 -> 191044732 -> 95522366 -> 47761183 -> 143283550 -> 71641775 -> 214925326 -> 107462663 -> 322387990 -> 161193995 -> 483581986 -> 241790993 -> 725372980 -> 362686490 -> 181343245 -> 544029736 -> 272014868 -> 136007434 -> 68003717 -> 204011152 -> 102005576 -> 51002788 -> 25501394 -> 12750697 -> 38252092 -> 19126046 -> 9563023 -> 28689070 -> 14344535 -> 43033606 -> 21516803 -> 64550410 -> 32275205 -> 96825616 -> 48412808 -> 24206404 -> 12103202 -> 6051601 -> 18154804 -> 9077402 -> 4538701 -> 13616104 -> 6808052 -> 3404026 -> 1702013 -> 5106040 -> 2553020 -> 1276510 -> 638255 -> 1914766 -> 957383 -> 2872150 -> 1436075 -> 4308226 -> 2154113 -> 6462340 -> 3231170 -> 1615585 -> 4846756 -> 2423378 -> 1211689 -> 3635068 -> 1817534 -> 908767 -> 2726302 -> 1363151 -> 4089454 -> 2044727 -> 6134182 -> 3067091 -> 9201274 -> 4600637 -> 13801912 -> 6900956 -> 3450478 -> 1725239 -> 5175718 -> 2587859 -> 7763578 -> 3881789 -> 11645368 -> 5822684 -> 2911342 -> 1455671 -> 4367014 -> 2183507 -> 6550522 -> 3275261 -> 9825784 -> 4912892 -> 2456446 -> 1228223 -> 3684670 -> 1842335 -> 5527006 -> 2763503 -> 8290510 -> 4145255 -> 12435766 -> 6217883 -> 18653650 -> 9326825 -> 27980476 -> 13990238 -> 6995119 -> 20985358 -> 10492679 -> 31478038 -> 15739019 -> 47217058 -> 23608529 -> 70825588 -> 35412794 -> 17706397 -> 53119192 -> 26559596 -> 13279798 -> 6639899 -> 19919698 -> 9959849 -> 29879548 -> 14939774 -> 7469887 -> 22409662 -> 11204831 -> 33614494 -> 16807247 -> 50421742 -> 25210871 -> 75632614 -> 37816307 -> 113448922 -> 56724461 -> 170173384 -> 85086692 -> 42543346 -> 21271673 -> 63815020 -> 31907510 -> 15953755 -> 47861266 -> 23930633 -> 71791900 -> 35895950 -> 17947975 -> 53843926 -> 26921963 -> 80765890 -> 40382945 -> 121148836 -> 60574418 -> 30287209 -> 90861628 -> 45430814 -> 22715407 -> 68146222 -> 34073111 -> 102219334 -> 51109667 -> 153329002 -> 76664501 -> 229993504 -> 114996752 -> 57498376 -> 28749188 -> 14374594 -> 7187297 -> 21561892 -> 10780946 -> 5390473 -> 16171420 -> 8085710 -> 4042855 -> 12128566 -> 6064283 -> 18192850 -> 9096425 -> 27289276 -> 13644638 -> 6822319 -> 20466958 -> 10233479 -> 30700438 -> 15350219 -> 46050658 -> 23025329 -> 69075988 -> 34537994 -> 17268997 -> 51806992 -> 25903496 -> 12951748 -> 6475874 -> 3237937 -> 9713812 -> 4856906 -> 2428453 -> 7285360 -> 3642680 -> 1821340 -> 910670 -> 455335 -> 1366006 -> 683003 -> 2049010 -> 1024505 -> 3073516 -> 1536758 -> 768379 -> 2305138 -> 1152569 -> 3457708 -> 1728854 -> 864427 -> 2593282 -> 1296641 -> 3889924 -> 1944962 -> 972481 -> 2917444 -> 1458722 -> 729361 -> 2188084 -> 1094042 -> 547021 -> 1641064 -> 820532 -> 410266 -> 205133 -> 615400 -> 307700 -> 153850 -> 76925 -> 230776 -> 115388 -> 57694 -> 28847 -> 86542 -> 43271 -> 129814 -> 64907 -> 194722 -> 97361 -> 292084 -> 146042 -> 73021 -> 219064 -> 109532 -> 54766 -> 27383 -> 82150 -> 41075 -> 123226 -> 61613 -> 184840 -> 92420 -> 46210 -> 23105 -> 69316 -> 34658 -> 17329 -> 51988 -> 25994 -> 12997 -> 38992 -> 19496 -> 9748 -> 4874 -> 2437 -> 7312 -> 3656 -> 1828 -> 914 -> 457 -> 1372 -> 686 -> 343 -> 1030 -> 515 -> 1546 -> 773 -> 2320 -> 1160 -> 580 -> 290 -> 145 -> 436 -> 218 -> 109 -> 328 -> 164 -> 82 -> 41 -> 124 -> 62 -> 31 -> 94 -> 47 -> 142 -> 71 -> 214 -> 107 -> 322 -> 161 -> 484 -> 242 -> 121 -> 364 -> 182 -> 91 -> 274 -> 137 -> 412 -> 206 -> 103 -> 310 -> 155 -> 466 -> 233 -> 700 -> 350 -> 175 -> 526 -> 263 -> 790 -> 395 -> 1186 -> 593 -> 1780 -> 890 -> 445 -> 1336 -> 668 -> 334 -> 167 -> 502 -> 251 -> 754 -> 377 -> 1132 -> 566 -> 283 -> 850 -> 425 -> 1276 -> 638 -> 319 -> 958 -> 479 -> 1438 -> 719 -> 2158 -> 1079 -> 3238 -> 1619 -> 4858 -> 2429 -> 7288 -> 3644 -> 1822 -> 911 -> 2734 -> 1367 -> 4102 -> 2051 -> 6154 -> 3077 -> 9232 -> 4616 -> 2308 -> 1154 -> 577 -> 1732 -> 866 -> 433 -> 1300 -> 650 -> 325 -> 976 -> 488 -> 244 -> 122 -> 61 -> 184 -> 92 -> 46 -> 23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

Ich selber lege eine Tabelle an wo ich einfach schon bereits berechnete Längen abspeichere. Ich gehe jede Zahl einzeln durch und speichere die Länge der Kette ab. Sollte ein Glied einer Kette noch keine Länge zugewiesen bekommen haben, wird dies direkt erledigt. Der Vorteil ist dann, dass ich nur noch die Länge der Kette bis zu einem bereits berechneten Glied bestimmen muss und eben nicht bis zur 1. Ich hoffe es ist verständlich wie ich das meine.

Soa, wie würdet ihr das Problem angehen und lösen?