Dokument erzeugt am 25.07.2017, Quelle: http://xprofan.com/xpse/ Syntax ------ Auskommentieren/ Remarks APIs ---- Befehls/ Zeilentrennung C-Style ------- Create-Funktionen ----------------- Const/ vordefinierte Konstanten Export/ Noexport FOR-Schleifen ------------- Geschweifte Klammern Include/#Include ---------------- OOP --- Parametertrennzeichen --------------------- Prä- und Postfixe Variablendeklaration -------------------- Zuweisungs/ Vergleichsoperatoren Auskommentieren/Remarks ----------------------- Das Auskommentieren zeilenübergreifender Blöcke mittels /* text */ und zeilenabschliessendes Auskommentieren mit //. APIs ---- APIs können einfach getippt werden, müssen nicht deklariert werden, auch ändert sich nicht die Schreibweise beim Funktionsaufruf: print timeGetTime() Kollidiert einmal ein API-Schlüsselwort, dann einfach per Tilde-Zeichen auf die API zeigen: print ~MessageBox(0, "Test", "Hallo", 0) Egal welche Schreibweise, alle APIs werden in schnellere Calls konvertiert deren Funktionsadresse bereits zu Programmbeginn bezogen werden - was auch für Aufrufe von APIs gilt welche nachträglich/zusätzlich per Headerdatei (*.ph) deklariert wurden und ebenso gilt für native Funktionen. Daraus resultieren eine deutlich höhere Programmgeschwindigkeit und mehr Sicherheit. Befehls/Zeilentrennung ---------------------- XPSE ermöglicht das in anderen Sprachen typische Semikolon ";" und den Doppelpunkt ":", um Anweisungen voneinander zu trennen und Backslash "\" um Zeilen miteinander zu verknüpfen. Geschweifte Klammern "{" "}" können ebenfalls verwendet werden, um Anweisungen voneinander zu trennen. C-Style ------- Der C-Style ergibt sich aus: Auskommentieren per // und /* */ Wie in C und PHP üblich, können // und /* */ zum Auskommentieren genutzt werden. Befehls/Zeilentrennung per Semikolon Wie in C und PHP üblich, können Anweisungen per Semikolon ";" voneinander getrennt werden. Const/ vordefinierte Konstanten Ähnlich der C-Syntax Konstanten definieren. Geschweifte Klammern Wie in C und PHP üblich können Anweisungblöcke per geschweiften Klammern "{" "}" deklariert werden. Include/#Include Wie in C und PHP üblich einzubindende Dateien mit "#Include" einbinden. OOP "this->" für Methoden innerhalb von Klassen, "::" für Methoden ausserhalb von Klassen. keine Prä- und Postfixe Keine Prä- und Postfixe für Variablen Variablendeklaration Variablendeklaration im C-Style Zuweisungs/ Vergleichsoperatoren Vergleich mit Operator "==" möglich. Create-Funktionen ----------------- createBlackframe(... createBlackrect(... createButton(... createCentertext(... createChoicebox(... createDateedit(... createDefbutton(... createDialog(... createEdit(... createGroupbox(... createHtmlbox(... createIconbutton(... createLeftbutton(... createListbox(... createMultiedit(... createPicbutton(... createRighttext(... createSortedListbox(... createSpinedit(... createStatic(... createSunkencentertext(... createSunkenrighttext(... createSunkentext(... createTabcontrol(... createText(... createTimeedit(... createToolwindow(... createWindow(... Const ----- Mit Const werden Konstanten oder ganze Zeichenfolgen wie auch Syntaxblöcke definiert. Die Verwendung dieser Konstanten, z.B. statt der Def -Konstanten, ist deutlich schneller, da diese nicht zur Laufzeit, sondern beim Kompilieren umgesetzt werden.const irgendwas="hallo" const irgendwas1=55510+myProc("test") Vordefinierte Konstanten String XPSECOMPILETIMESTAMPSTRINGDatum und Uhrzeit der Programmkompilierung im Format yyyymmddHHMMSS String XPSESOURCECODEFILENAMESTRINGDateiname des kompilierten Programmes einschliesslich Pfad. String XPSEVERSIONSTRINGVersionsstring von XPSE - z.B. "0.1.7g". Long XPSENUMSOURCECODELINESLONGAnzahl der relevanten geladenen Quelltextzeilen Export/Noexport --------------- In Units verwendbares Schlüsselwort für kleine in die .def-Datei zu erportierende Hilfetexte:proc myProc export "myProc ist für ..."Eine mit noexport gekennzeichnete Funktion wird nicht in die def-Datei exportiert. FOR-Schleifen ------------- FOR-Schleifen nach Pascal-Syntax mit optionalem Step und DownTo. for l=1 to 10 do begin ... endDie in XProfan eingebauten WhileLoop-Schleifen sind schneller und vorzuziehen. Geschweifte Klammern Geschweifte Klammern wie auch aus C oder PHP bekannt können wie gewohnt verwendet werden um Blöcke für if, while, whileloop, repeate und proc zu definieren. if (10/*anmerkung*/==20) { print "Hallo" } else { ... Include/#Include ---------------- Inkludiert automatisch Quelltextdateien, Headerdateien und Units. Je nach Dateiendung wird entsprechend eingebunden. Wird "include" mit Raute angeführt: "#include", dann wird die angegebene Datei nicht eingebunden, wenn sie bereits zuvor schon einmal mit "#include" eingebunden wurde. (Wird nur ein Mal eingebunden, ähnlich wie PHP's "include_once".) OOP --- Innherhalb von Klassen kann auf Methoden der gleichen Klasse mit "this->" zugegriffen werden (erspart das wiederholte Tippen der Klassenbezeichnung) und ausserhalb von Klassen kann auf Methoden mittels Doppeldoppelpunkt "::" zugegriffen werden, erspart Raute-Punkt "#.". Einheitliches Parametertrennzeichen Wie folgt kann für diese Befehle, neben der regulären Schreibweise mit unterschiedlichen Parametertrennzeichen, als Parametertrennzeichen auch einzig das Komma verwendet werden: ARCX1, Y1, X2, Y2, X3, Y3, X4, Y4 CHORDX1, Y1, X2, Y2, X3, Y3, X4, Y4 CLIPLOADBMPX1, Y1, X2, Y2, X3, Y3, X4, Y4 COPYS1, S2 COPYBMPX1, Y1, X2, Y2, X3, Y3, N1[, N2] COPYPICH, X1, Y1, X2, Y2, X3, Y3, N1[, N2] COPYSIZEDBMPX1, Y1, X2, Y2, X3, Y3, X4, Y4, N COPYSIZEDPICH, X1, Y1, X2, Y2, X3, Y3, X4, Y4, N DRAWPICH, X, Y, N1[, N2] DRAWPICI, S, X, Y, N1, N2 DRAWPICS, X, Y, N1[, N2] DRAWSIZEDEXTBMPI, S, X1, Y1, X2, Y2[, N] DRAWSIZEDPICH, X, Y, DX, DY[, N] DRAWSIZEDPICI, S, X, Y, DX, DY, N ELLIPSEX1, Y1, X2, Y2 LINEX1, Y1, X2, Y2 LOADBMPS, X, Y[, N] LOADSIZEDBMPS, X1, Y1, X2, Y2[, N] MCOPYBMPX1, Y1, X2, Y2, X3, Y3, N1[, N2] MCOPYSIZEDBMPX1, Y1, X2, Y2, X3, Y3, X4, Y4, N MOUSE(X1, Y1, X2, Y2) PIEX1, Y1, X2, Y2, X3, Y3, X4, Y4 RECTANGLEX1, Y1, X2, Y2 ROUNDRECTX1, Y1, X2, Y2, X3, Y3 SETWINDOWPOSW, X, Y[, DX, DY[, N]] TBOXX1, Y1, X2, Y2, N WINDOWX1, Y1[, X2, Y2]Wird die Kommaschreibweise genutzt, müssen alle Parameter mit Komma getrennt sein - es kann nicht innerhalb einer Befehlsparameterkette zwischen Parametertrennzeichenschreibweisen gewechselt werden. Keine Prä- und Postfixe Keine Prä- und Postfixe für Variablen und Systemvariablen, wo sie dann nicht notwendig sind, wenn es keine gleichnamige Funktion gibt. Variablendeklaration -------------------- Variablen ohne Postfix können im C-Style deklariert werden: long a, b, c int a, b, c string a, b, c float a, b, c print a, b, c Arrays ebenso einfach: longs a, b, c ints a, b, c strings a, b, c floats a, b, c print a[0], b[0], c[0] Variablen mit Postfix wie gewohnt per Declare und Var deklarieren, siehe: Datentypen. Zuweisungs/ Vergleichsoperatoren OperationXProfanPHP/CPPDelphi PascalXPSE Wertzuweisung==:= Vergleiche==== Installation ------------ 1 XPSE ist im Lieferumfang des XProfan enthalten, ggf. aktuelle Version herunterladen. 2 XPSE.exe im XProfan-Verzeichnis ablegen, im Normalfall "C:\XProfan...". 3 XPSE in der IDE bei den Kompilereinstellungen als Kompiler, oder als Hilfsmittel festlegen. Optionale Komponenten 4 Für native Funktionen z.B. jwasm.exe und polink.exe im XProfan-Verzeichnis ablegen: herunterladen Download -------- XPSE V11.2.1.8 Alpha: http://dl.xprofan.net/?icum/xpse.exe http://dl.xprofan.net/?icum/xpse.exe http://xprofan.net/intl/de/xpse/ [Diskussion] Optional/ Tools/ Includes ASM und Linker für native Funktionen: JWasm: http://xprofan.com/xpse/bin/jwasm.exe http://xprofan.com/xpse/bin/jwasm.exe POLink: http://xprofan.com/xpse/bin/polink.exe http://xprofan.com/xpse/bin/polink.exe Native Funktionen Für native Funktionen werden im XProfan-Verzeichnis (dort wo sich auch xpse.exe befindet) ein ASM und ein Linker benötigt, z.B. jwasm.exe und polink.exe (siehe oben). Die Dateien stammen von http://www.japheth.de/JWasm http://www.japheth.de/JWasm.html und http://www.smorgasbordet.com/pellesc/download.htm http://www.smorgasbordet.com/pellesc/download.htm. Siehe auch: XPSE installieren XPSE ---- Vorwort ------- Hauptfunktionen --------------- Funktionsreferenz ----------------- Installation ------------ Support ------- Vorwort ------- XPSE ist seit Profan² 4.5 Profan²/ XProfan-http://de.wikipedia.org/wiki/Precompiler Präkompilierer. Hauptfunktionen --------------- Einfach Programmieren Vordeklarierte APIs, Strukturen, Konstanten, keine Prä- und Suffixe Fehler aufdecken Warnmeldungen vor dem Kompilieren, Syntaxprüfung, Debuggen Funktionsadresschutz Schnellere Funktionsaufrufe, sicherer gegen Angriffe Inline-Assembler Inline-Assembler mit Komfort, mit Profansyntax mischbar und Datentypunterstützung Kompilerschalter Kompilerschalter für definierbare Vorgänge und Plugins Multi-Threading, Threadsicheres Konzept/ Datentypen Asynchone Vorgänge nativ in Profansyntax programmieren Natives Profan Nahtloser Übergang nativ zu programmieren Projektmanagement Spezialkonstanten und Kompilerschalter für Methoden, Tools und externe Plugins Quelltextoptimierung Schnelleres Programm Syntaxoptimierung Variablennamen und Systemvariablen ohne Prä- und Suffixe, C-Style, ... Unterbrechungsfreies SubClassing Echtes unterbrechungsfreies SubClassing mit nativen Funktionen Installation ------------ 1 XPSE ist im Lieferumfang des XProfan enthalten, ggf. aktuelle Version herunterladen. 2 XPSE.exe im XProfan-Verzeichnis ablegen, im Normalfall "C:\XProfan...". 3 XPSE in der IDE bei den Kompilereinstellungen als Kompiler, oder als Hilfsmittel festlegen. Optionale Komponenten 4 Für native Funktionen z.B. jwasm.exe und polink.exe im XProfan-Verzeichnis ablegen: herunterladen Support ------- Siehe: Support und Kontakt Support und Kontakt, Impressum Support und Kontakt Verantwortlicher und Rechtliches Haftungsausschluss ------------------ Support und Kontakt Support für XPSE: http://xprofan.net/intl/de/xpse/ http://xprofan.net/intl/de/xpse/ Verantwortlicher und Rechtliches XProfan.Net/ XProfan.Com, XProfan.Net-Developers, David Strutz, 14195 Berlin, Spilstr. 10, Tel. +49 (030) 6443 6443, Gerichtsstand Deutschland, Berlin, Amtsgericht Berlin Charlottenburg, USt.-ID DE-256-357-206, Finanzamt Berlin Schöneberg, E-Mail: support@xprofan.net Haftungsausschluss ------------------ Diese(r) Haftungsbeschränkung/ Gewährleistungsausschluss ist als Teil des Angebotes zu betrachten. Kompilerschalter ---------------- Shorties -------- Include/ #Include {$BATCH} -------- {$CODESTORE} ------------ {$COMPILER} ----------- {$CPP} ------ {$DEBUG} -------- {$INCLUDEPATH} -------------- {$INTERPRETER} -------------- {$LOG} ------ {$MAPFILE} ---------- {$NOERR} -------- {$NODEF} -------- {$NOTMP} -------- {$NOSECTIONCHECK} ----------------- {$RUNTIME} ---------- {$PREBATCH} ----------- {$PUSHKEYWORD} -------------- {$UNIT} ------- Shorties -------- Shorties sind Kompilerschalter welche aus nur einem Buchstaben bestehen und die Besonderheit haben, auch miteinander innerhalb einer Kompilerschalteranweisungszeile kombiniert werden zu können. So entstehen die Klassiker {$CLEQ} für Kompilieren, Linken, Exe starten, Quiet (Ruhe) und {$iq} für Interpretieren, Quiet (Ruhe). SchalterFunktion {$C} Compile Der Quelltext ist zu kompilieren. {$L} Link Nach dem Kompilieren linken. {$E} Exe Nach dem Linken die erzeugte Exe starten. {$Q} Quietmode Schliessen wenn keine Warnungen/Errors. {$I} Interprete Quelltext im Interpretermodus starten. {$R} Run PRC mit Runtime starten. {$S} ShowSource Zeigt den übersetzen Quelltext. {$T} NoTempFiles Entfernt automatisch temporäre Dateien, Shorty für {$notemp}. Include/ #Include Inkludiert Quelltextdateien, Headerdateien und Units, je nach Dateiendung automatisch. Wird "include" mit Raute angeführt: "#include", dann wird die angegebene Datei nicht eingebunden, wenn sie bereits zuvor schon einmal mit #include eingebunden wurde. (Wird nur ein Mal eingebunden, ähnlich wie PHP's "include_once".) Weitere Kompilerschalter Diese Kompilerschalter müssen jeweils in einer eigenen Zeile stehen. Einige Kompilerschalter erwarten einen Parameter. Die Angabe eines nötigen Parameters ist mit param gekennzeichnet. {$BATCH param} Führt param nach dem Abarbeiten der Kompilerschalter aus, wird {$PREBATCH param} verwendet dann wird param vor dem Abarbeiten der Kompilerschalter ausgeführt. Param kann auf eine Batchdatei oder auf ein Programm zeigen, oder direkt ein Batchbefehl sein. Bei Angaben von Pfaden oder Dateinamen welche ein Freizeichen beinhalten, sollten Anführungszeichen verwendet werden. 'Beispiel: {$cleq} {$batch copy "C:\xprofan\1.exe" "C:\1.exe"} {$CODESTORE} ------------ Legt den Quellcode leicht komprimiert in den Quellcode ab, mit Aufruf der Funktion __codeStore.Export() kann der Quellcode wiederhergestellt werden. Es muss - wenn {$codestore} gesetzt - eine Funktion __codeStore.Question() angelegt werden, welche entweder 12345 oder 22345 zurückliefert, wenn der Quelltext in eine Datei geschrieben oder als String von __codeStore.Export() zurückgeliefert werden soll. In der __codeStore.Question() kann z.B. auch eine Passwortabfrage erfolgen. Setzt man beim zu verteilenden Release den Schalter {$CODESTORE}, dann kann man den Quellcode (zur Not) auch dann immer wieder herstellen, wenn man ihn verloren hat also obwohl man ("nur") noch die Exe hat. Je nach dem, was man in der __codeStore.Question() programmiert, legt man damit fest, ob der Quelltext jedem oder z.B. nur per Passwort zurückgegeben werden soll. Export des Quelltextes indem man __codeStore.Export() aufruft, die Funktion __codeStore.Question() stellt die Sicherheitsabfrage dar. {$COMPILER param} Legt param als Kompiler fest, praktisch wenn man mit verschiedenen Kompilern arbeitet oder ein Programm nur von einem bestimmten Kompiler kompiliert wird. {$CPP} ------ Übergibt den Quelltext statt an den XProfan-Kompiler, an Profan2Cpp. Sinnvoll nur in Kombination mit dem Schalter {$C} wobei hier auf {$L} verzichtet werden kann, da hier nicht per XProfan gelinkt wird sondern Profan2Cpp die Anweisung zum Linken gibt. {$DEBUG} -------- Bei gesetztem Schalter können perdebug "MeineAusgabe"Mitteilungen an den Debugviewer gesandt werden, native Funktionen senden nach jeder Programmzeile einen Register und Stack-Dump an den Debugviewer und die Nummer des Haltepunktes. {$INCLUDEPATH param} Fügt param auf den Stapel der zu durchsuchenden Pfade für Includedateien hinzu. Es können bis zu 5 zusätzliche Pfade angegeben werden. Die im ProfanEditor angegebenen Includepfade werden automatisch über {$INCLUDEPATH} eingebunden. {$INTERPRETER param} Legt param als Interpreter fest, praktisch wenn man mit verschiedenen Interpretern arbeitet oder ein Programm von einem bestimmten Interpreter ausgeführt werden soll. {$LOG} ------ Operationen wie Linken oder Kompilieren, die diesen Quelltext betreffen, werden in die xpse.log geschrieben. {$MAPFILE} ---------- Schalter übergibt den Kommandozeilenparameter "-M" an den XProfan-Kompiler weiter. (Mapdatei) Im MapFile steht welche Zeilennummer welcher Datei (auch Includes und Units) angehört. {$NOERR} -------- Fehler im Quelltext ignorieren. {$NODEF} -------- Units: Es wird keine .def-File und .hlp.html-Datei angelegt und wenn vorhanden gelöscht. {$NOTMP} -------- Entfernt automatisch temporäre Dateien - Shorty {$T}. {$NOSECTIONCHECK} ----------------- Dieser Schalter schaltet die Sektionskontrolle ab. Hiermit ist gemeint das Fehler wie: proc if endproc endif geduldet werden. Von der Nutzung des Schalters ist grundsätzlich abzuraten. {$RUNTIME param} Legt param als Runtime fest, praktisch wenn man mit verschiedenen Runtimes arbeitet oder ein Programm nur von einer bestimmten Runtime ausgeführt wird. {$PREBATCH param} Führt param vor dem Abarbeiten der Kompilerschalter aus. param kann auf eine Batchdatei oder auf ein Programm zeigen, oder direkt ein Batchbefehl sein. Es kann nur ein Batchbefehl angegeben werden, was z.B. bei $INCLUDEPATH anders ist. TIP: Beim Angeben von Pfaden oder Dateinamen welche ein Freizeichen beinhalten sollten Anführungszeichen verwendet werden um die Pfad+Dateiangaben einzuschließen. Das ist keine XPSE-Maßgabe sondern CMD erfordert dies. 'Beispiel: {$cleq} {$prebatch copy "C:\xprofan\1.exe" "C:\1.exe"} {$PREFEREDNAMESPACE param} (veraltet, siehe {$unit}) Legt den bevorzugten Namensraum dieser Unit auf param fest. param wird dann in der Automatisch erzeugten Hilfe (.hlp.htm-Datei) zum eigendlichen Identifier angezeigt. {$PUSHKEYWORD param} Param kann ein einzelnes Keyword, oder eine Aufzählung von Keywords sein welche mit Komma voneinander getrennt werden. Mit dem Schalter kann man Schlüsselworte als existent definieren. {$UNIT param} Legt den bevorzugten Namensraum dieser Unit auf param fest und teilt dem XProfan-Kompiler über $L automatisch mit, dass es sich um eine Unit handelt. $L entfällt also wenn {$unit param} angegeben ist. param wird auch in der Automatisch erzeugten Hilfe (.hlp.htm-Datei) zum eigendlichen Identifier angezeigt. Dieser Kompilerschalter hat jedoch noch einen anderen wichtigen Zweck bei der Herstellung von Units. XPSE wandelt API's aus Headern in direkte Call 's um. Damit die Funktionsadressen nicht mit denen aus anderen Units, oder mit denen aus dem Hauptprogramm kollidieren, wird den Variablen der Funktionsadressen das Präfix param vorangestellt. In Units ist dieser Schalter somit Pflicht. Siehe auch: export , noexport und Unitsupport Kompilerschalter als Kommandozeilenparameter Kompilerschalter als Kommandozeilenparameter werden ignoriert. Aus kompatiblitätsgründen zu verschiedenen IDE's ist die Angabe von Kompilerschaltern per Kommandozeilenparameter zwar möglich, so das XPSE diese erkennt und damit trotzdem den "richtigen" Dateinamen ermittelt, aber die übergebenen Schalter werden Aufgrund der möglichen Konflikte mit Kompilerschaltern im Quelltext verhindert. Folgende Kommandozeilenparameter, welche aus den verschiedenen IDE's bekannt sind, werden erkannt und verhindert: -E -B -L -S -R -M -V -LINK Funktionsreferenz ----------------- Vorwort ------- Befehlssatz ----------- Datentypen ---------- Debuggen -------- Kontrollstrukturen ------------------ Operatoren ---------- Pseudo-Klassen -------------- Variablen --------- Zeiger ------ Vorwort ------- Diese Funktionsreferenz gilt innerhalb NProc-Funktionen, gleichnamige Befehle der XProfan-Runtime haben möglicherweise eine andere Syntax und Funktion. NProc-Funktionen werden in Assembler umgewandelt, um Hooks, Subclassing, Threads, Callbacks und all die Dinge zu programmieren, bei denen es auf Threadsicherheit und hohe Geschwindigkeit ankommt. Der Sprachschatz innerhalb von NProc-Funktionen orientiert sich an dem von XProfan, weicht aber in einigen Punkten davon ab (siehe hierzu z.B. Syntax), auch um zuverlässigen Umgang mit Threads zu ermöglichen. Zusätzlich kann man innerhalb von NProc-Funktionen Assembler-Befehle verwenden. Befehlssatz ----------- Der Befehlssatz ergibt sich aus: hier genannten Befehlen, Funktionen, Systemvariablen 25.000 automatisch deklarierten APIs, Konstanten, Strukturen externen Funktionen/ APIs welche über Headerdateien (*.ph) inkludiert werden eigenen NProc-Funktionen welche auch inkludiert werden können Assembler Native Funktionen können in Profansyntax programmiert werden, oder auch in Assembler - es kann auch Assembler mit Profansyntax gemischt werden. Die Syntax in nativen Funktionen ist einfacher als die der Runtime. Beispielsweise müssen Funktionen immer wie Funktionen aufgerufen werden, nicht Sleep 50 sondern sleep(50) und einzig das Komma ist Parametertrennzeichen. Befehle und Systemvariablen können einzig vom Befehlssatz gestellt werden, NProc-Funktionen sind immer Funktionen. Float-Konstanten müssen immer mit Dezimalpunkt als Kommazahl ausgedrückt werden (z.B. 1.0 statt 1) und Stringkonstanten per Anführungszeichen (z.B. "Stringinhalt"). Siehe auch: C-Style-Syntax Datentypen ---------- Datentypen Long, Float und String: TypBytesPostfixSchreibweisen Long4&declare a& var a&=0 long a=0 Float8!declare a! var a!=0 float a=0 String8+Zeichen+1$declare a$ var a$="" string a="" Hinweis: Strings können bis zu 4GB groß sein, sind binärsicher (Binary-Safe, alle Zeichen von 0-255 können enthalten sein) und automatisch immer mit Zeichen #0 am Ende abgeschlossen. Strings können direkt an Apis übergeben werden. Debuggen -------- Vollautomatischer Zugriff auf die Windows-API ermöglichen beliebige Ausgaben, beispielsweise per http://msdn.microsoft.com/en-us/library/aa363362%28VS.85%29.aspx OutputDebugString, SetText(hWnd, MessageBox(0, ... Schreiben Sie z.B. OutputDebugString("Ausgabe"+str$(foregroundColor.a)) um den Alphawert der gewählten Vordergrundfarbe mit einem Debug-Viewer wie z.B. http://technet.microsoft.com/en-us/sysinternals/bb896647.aspx DebugView anzuzeigen. Siehe auch: {$Debug} Kontrollstrukturen ------------------ Folgende Kontrollstrukturen werden unterstützt: break, continue case, casenot do -- if, ifnot, elseif, else for --- goto ---- repeat ------ return ------ while, whilenot, whileloop Operatoren ---------- OperationOperator/ SchreibweisenBoolLongFloatStringAddierenAdd, +GrundrechnenSub, Mul, Div, -, *, /ModulaMod, %IstgleichEqu, =UngleichNeq, <>, !=KleinerBitweises Linksschieben<>Kleiner o. gleich<=Grösser o. gleich>=Logisches UndAnd, &&Logisches OderOr, ||Binäres Und&Binäres Oder| Siehe auch: Syntax: C-Style: Zuweisungs/ Vergleichsoperatoren Pseudo-Klassen -------------- Pseudo-Klassen sind das native Gegenstück zu interpretierten Container-Funktionen, wobei die Unterfunktionen nicht per Stringkonstante benannt werden, sondern einfach mit Punkt "." direkt hinter dem Klassennamen geschrieben werden: thread.is() statt thread("is"). CriticalSection GetText Thread Variablen --------- Variablen sind lokal, typisiert und besitzen einen eindeutigen Namen bestehend aus 1-96 Zeichen welcher keinem Namen anderer Variablen oder Schlüsselworte gleicht (eindeutige Bezeichnernamen). Werden Variablen mit Postfix per Declare oder Var deklariert, dann muss das Postfix für diese Variable durchgehend verwendet werden, andernfalls müssen Variablen kein Postfix besitzen, wenn sie per C-Style deklariert werden. Siehe auch: Datentypen, Declare, Var, Syntax: C-Style: Variablendeklaration Zeiger ------ Siehe: Addr, ProcAddr Abs(l) ------ Rückgabewert: Long, Absolutwert von l. Add --- Add als Befehl, Funktion und Operator. add a, b a=add(a, b) a=a add b Addr(v) ------- Rückgabewert: Long, Speicheradresse von Variable v. Siehe auch: ProcAddr AddString(l, s) Fügt String s als Eintrag der ListBox l hinzu. Rückgabewert: Long, undefiniert. Siehe auch: CreateList, ClearList, DeleteString, GetCount, GetString Beispiel: var list&=createList(0) //erzeuge unsortierte Liste addString(list&, "Hallo Welt") //füge "Hallo Welt" als Eintrag zur Liste hinzu. deleteString(list&, 0) //entferne ersten Eintrag aus der Liste destroyWindow(list&) //entferne Liste ArcCos(f) --------- Rückgabewert: Float, ArcCos von f. Siehe auch: Sin, Pi ArcCot(f) --------- Rückgabewert: Float, ArcCot von f. Siehe auch: Sin, Pi ArcSin(f) --------- Rückgabewert: Float, ArcSin von f. Siehe auch: Sin, Pi ArcTan(f) --------- Rückgabewert: Float, ArcTan von f. Siehe auch: Sin, Pi Between(l1, l2, l3) Rückgabewert: Bool, ob Wert l1 im Bereich von l2 bis l3. Siehe auch: Range BGR(bB, bG, bR[, bA]) Rückgabewert: Long, Farbnummer. Hinweis: Diese Funktion ist ein Alias für RGB, nur dort nützlich wo Angaben in BGR-Reihenfolge erwartet sind. (z.B. DIB) Siehe auch: GetAValue, GetBValue, GetGValue, GetRValue Beispiel: nProc filter parameters h&, _width&, _height& var a&=GetPixels(h&, _width&, _height&) whileLoop 0, _width&*_height&*4-1, 4 long a&, loop=bgr(255, 0, 0) wend SetPixels(h&, a&, _width&, _height&) endproc Break ----- Schleife verlassen. Siehe auch: Continue, While Beispiel: while 1 case rnd(100) : break wend Byte ---- Wird Byte als Funktion "byte(" verwendet, werden 1 Byte von der Adresse als Long-Wert zurückgeliefert. Byte als Befehl setzt das Byte an Adresse auf den Wert. Der Klarheit halber gibt es auch GetByte und SetByte. wert&=byte(adresse&, offset&) //8-Bit-Wert von Speicheradresse einlesen byte adresse&, offset&=wert& //8-Bit-Wert an Speicheradresse setzen Siehe auch: Long Call(l[, l1[, ...]]) Ruft Funktion an Adresse l auf und gibt den Wert zurück. Rückgabewert: Long Case Argument : Anweisung Anweisung wird ausgeführt, wenn Argument nicht Null ist. Siehe auch: CaseNot, If CaseNot Argument : Anweisung Anweisung wird ausgeführt, wenn Argument Null ist. Siehe auch: Case, IfNot Char ---- Wird Char als Funktion verwendet char(addr, offs, anz) dann werden Anzahl Byte von der Adresse als String zurückgeliefert. Wird Char als Befehl mit einer Variable mit Variablenpostfix angegeben char addr&, offs=s dann werden die Zeichen vom String s hintereinander an die Adresse geschrieben. Hinweis: Schreibweise Char$( ebenso erlaubt. Siehe auch: String Wichtig: In aktueller Version ist Char als Funktion fehlerhaft und daher bitte nicht zu nutzen. Ersatzfunktion: nProc _char(long hMem, from, length){ case length Rückgabewert: Long, Handle des erzeugten Controls Cos(f) ------ Rückgabewert: Float, Cosinus von Winkel f. Siehe auch: Sin, Pi CreateList(lTyp) ---------------- Rückgabewert: Long, Liste, lTyp 0 ist unsortiert, 1 Sortiert, 2 Mehrfachauswahl, 3 Sortiert und Mehrfachauswahl. Siehe auch: AddString, ClearList, DeleteString, GetCount, GetString, InsertString Beispiel: var list&=createList(0) //erzeuge unsortierte Liste addString(list&, "Hallo Welt") //füge "Hallo Welt" als Eintrag zur Liste hinzu. deleteString(list&, 0) //entferne ersten Eintrag aus der Liste destroyWindow(list&) //entferne Liste CriticalSection (Pseudo-Klasse) Die Klasse enthält Funktionen zur Threadsynchronisation. CriticalSection.Begin CriticalSection.End CriticalSection.Is Siehe auch: Thread CriticalSection.Begin(sSectionName) ----------------------------------- CriticalSection.Begin wartet, wenn die mit sSectionName benannte Sektion läuft und gibt andernfalls ein Sektionshandle zurück und deklariert die Sektion sSectionName als laufend, bis CriticalSection.End mit dem Sektionshandle aufgerufen wird. Rückgabewert: Long, Sektion. Beispiel: var section&=criticalSection.Begin("MeineSektion") ... criticalSection.End(section&) CriticalSection.End(lSection) ----------------------------- Rückgabewert: Long, undefiniert, die Sektion lSection wird beendet. CriticalSection.Is(sSectionName) -------------------------------- Rückgabewert: Bool, True wenn Sektion sSectionName läuft. Date(l) ------- Rückgabewert: String, Datum nach Format l. lRückgabewert 001.02.2013 101. Februar 2013 2Freitag, 01. Februar 2013 320130201 4dd.MM.yyyy 5Fri, 1 Feb 2013 06:00:00 +0100 Hinweis: Schreibweise Date$( ebenso erlaubt. Siehe auch: GetTickCount, Time, UnixTime Beispiel: {$cleq} cls clearclip putclip test() waitinput end nproc test var s$="" whileLoop 0, 5 s$=s$+date$(loop)+"\n" wend return s$ endproc Ausgabe: 08.03.2010 8. März 2010 Montag, der 8. März 2010 20100308 dd.MM.yyyy Mon, 8 Mar 2010 06:41:40 +0100 Date.isLeapYear(l) ------------------ Rückgabewert: Long, ob das per Parameter l übergebene Jahr ein Schaltjahr ist. Hinweis: Diese Funktion ist noch nicht implementiert. Beispiel: nProc Date.isLeapYear(long yr) return iff((((yr mod 4) = 0 & (yr mod 100) 0) | ((yr mod 400) = 0)), 1, 0) endProc ------- Declare V1, V2, ... Deklariert Variablen mit Postfix $, & oder !. Siehe auch: Var, Variablen, Datentypen Beispiel: declare a&, b!, c$ a&=100 b!=10.1 c$="Hallo Welt" Deg2Rad(f) ---------- Rückgabewert: Float, Bogenmaß aus Grad f. Siehe auch: Rad2Deg, Pi Del(s, l1, l2) Rückgabewert: String, es werden l2 Zeichen am Position l1 aus dem String s entfernt. Hinweis: Schreibweise del$( ebenso erlaubt. DeleteString(lList, lItem) Löscht aus ListBox lList Eintrag lItem. Siehe auch: AddString, GetString Beispiel: var list&=createList(0) //erzeuge unsortierte Liste addString(list&, "Hallo Welt") //füge "Hallo Welt" als Eintrag zur Liste hinzu. deleteString(list&, 0) //entferne ersten Eintrag aus der Liste destroyWindow(list&) //entferne Liste Desktop ------- Systemvariable -------------- Hinweis: Schreibweise %Desktop ebenso erlaubt. Rückgabewert: Long, Handle des Desktopfensters. DestroyWindow(l) ---------------- Entfernt Fenster oder Control mit Handle l samt Childs. Rückgabewert: 0 wenn fehlgeschlagen. Dim(l) ------ Dimensioniert l Byte Speicher. Rückgabewert: Long, Speicherhandle Siehe auch: Dispose, SetByte, SetLong Beispiel: long m=dim(16) dispose(m) Dispose(l) ---------- Gibt den mit Dim bezogenen Speicher wieder frei. Rückgabewert: Long, undefiniert Siehe auch: Dim Beispiel: long m=dim(16) dispose(m) Div --- Div als Befehl, Funktion und Operator: div a&, b& a&=div(a&, b&) a&=a& div b& DrawText(lDC, lX, lY, s) Gibt String s auf DC lDC an Position lX, lY aus. Beispiel: DrawText(hDC, 10, 10, "Hallo Welt") ExitProcess(lExitCode) ---------------------- Prozess-Not-Stop. ----------------- Hinweis: Diese Funktion sollte nur im Notfall verwendet werden, da keine Aufräumarbeiten durchgeführt werden. Der gesamte Prozess (alle Threads) wird beendet und der ExitCode auf lExitCode gesetzt. Beispiel: ExitProcess(22) Float ----- Float konvertiert Long zu Float (f!=float(20)) oder liesst 8 Byte von einer Adresse (f!=float(addr&, offs&)) und gibt den Wert als Float zurück oder schreibt 8 Byte an eine Adresse (float addr&, offs&=f!) oder Deklariert Variablen ohne PostFix (float a, b, c). Wird Float als Funktion "float(" verwendet, werden 8 Byte von der Adresse als Float-Wert zurückgeliefert oder wenn nur 1 Parameter angegeben, der übergebene Wert der Long-Variablen als Float zurückgeliefert/konvertiert. Float als Befehl kennt ebenso 2 Möglichkeiten: 1) Wird eine Variable mit Variablenpostfix angegeben, dann wird der Wert an die Adresse des Variablenwertes geschrieben. 2) Suffixlose Variablen werden im C-Style deklariert. Der Klarheit halber gibt es auch GetFloat und SetFloat. Siehe auch: Int, Long, Var, Variablen, Datentypen Beispiele: ---------- Variablen a, b und c vom Typ Float deklarieren: float a, b, c 64-Bit-Wert von Speicheradresse einlesen: wert!=float(adresse&, offset&) 64-Bit-Wert an Speicheradresse setzen: float adresse&, offset&=wert! Beliebiges Beispiel: nproc test float a, b, c a=5.5 return a endproc GetString(lList, lPos) Rückgabewert: String, Zeichen aus Zeile lPos aus ListBox lList. Hinweis: Schreibweise GetString$( ebenso erlaubt. Siehe auch: AddString Beispiel: var list&=createList(0) //erzeuge unsortierte Liste addString(list&, "Hallo Welt") //füge "Hallo Welt" als Eintrag zur Liste hinzu. var s$=getString$(list&, 0) //ersten Eintrag der Liste ("Hallo Welt") nach s$ speichern deleteString(list&, 0) //entferne ersten Eintrag aus der Liste destroyWindow(list&) //entferne Liste messageBox(0, s$, s$, 0) GetText (Pseudo-Klasse) Die Klasse enthält Funktionen für einfaches Textermitteln aus verschiedenen Controls bereit. GetText GetText.Listview GetText(lH) ----------- Rückgabewert: String, Zeichen aus Text von Control lH. Hinweis: Schreibweise GetText$( ebenso erlaubt. Siehe auch: SetText GetText.Listview(lListview, lColumn, lRow) Rückgabewert: String, Zeichen aus Text von Zeile lColumn in Spalte lRow aus Listview lListview. Hinweis: Schreibweise GetTextFromListview$( ebenso erlaubt. Siehe auch: GetString GetAValue(l) ------------ Rückgabewert: Long, Alpha in Farbnummer l. Siehe auch: Rgb GetBValue(l) ------------ Rückgabewert: Long, Blau in Farbnummer l. Siehe auch: Rgb GetByte(adresse, offset) Liesst von Adresse+Offset 1 Byte und liefert dieses als Long-Wert zurück. Alias für die Funktion Byte(adresse, offset). Siehe auch: SetByte GetCount(lList) --------------- Rückgabewert: Long, Anzahl Einträge in iList. Siehe auch: CreateList GetExitCode(lPID) ----------------- Rückgabewert: Long, ExitCode von Prozess lPID. GetFloat(adresse, offset) Liesst von Adresse+Offset 8 Byte und liefert und liefert den Float-Wert zurück. Alias für die Funktion float(adresse, offset). Siehe auch: SetFloat GetFocus() ---------- Liefert das Handle des fokusbesitzenden Controls. Siehe auch: SetFocus GetGValue(l) ------------ Rückgabewert: Long, Grün in Farbnummer l. Siehe auch: Rgb GetLong(adresse, offset) Liesst von Adresse+Offset 4 Byte und liefert diese als Long-Wert zurück. Alias für die Funktion Long(adresse, offset). Siehe auch: SetLong GetParent(lH) ------------- Rückgabewert: Long, Handle des Elterncontrols von lH. Siehe auch: SetParent GetPixel(lDC, lX, lY) Rückgabewert: Long, Farbe von Pixel lX, lY in DC lDC. Siehe auch: SetPixel, hDC GetRValue(l) ------------ Rückgabewert: Long, Rot in Farbnummer l. Siehe auch: Rgb GetTickCount ------------ Systemvariable -------------- Rückgabewert: Long, vergangene Millisekunden seit Windows-Start. Hinweis: Schreibweise &getTickCount ebenso erlaubt. Siehe auch: Sleep, Date, Time, UnixTime GetWord(adresse, offset) Liesst von Adresse+Offset 2 Byte und liefert diese als Word-Wert zurück. Alias für die Funktion Word(adresse, offset). Siehe auch: SetWord Global V1, V2, ... Deklariert in nativen Funktionen Long-Variablen mit Postfix & und initialisiert die Variablen mit den Werten gleichnamiger globaler per Declare deklarierter Variablen. Somit ist einfacher Zugriff auf globale Variablenwerte gewährleistet. Hinweis: Aus threadsicherheitsgründen nur Lesezugriff. Threadsichere Globale per Mutex oder Semaphor-APIs. Siehe auch: Declare //Hauptfenster Subclassing declare owp& cls owp&=setWindowLong(hWnd, gwl_wndProc, procaddr(hWnd.wndProc, 4)) waitinput end nProc hWnd.wndProc Parameters wnd&, msg&, wp&, lp& global owp& return callWindowProc(owp&, wnd&, msg&, wp&, lp&) endproc Goto "Ziel" Springt zum Label, Label werden mit einem Doppelpunkt am Zeilenende gekennzeichnet. Hinweis: Ausführungsblöcke dürfen nicht durchsprungen werden, ebenso muss das Spungziel innerhalb derselben nativen Funktion vorliegen und Sprungziel-Bezeichnungen dürfen funktionsübergreifend nur einmalig verwendet werden. Sprungmarke: goto "Sprungmarke" HDC --- Rückgabewert: Long, Hauptfenster-DC. Hinweis: Schreibweise %hDC ebenso erlaubt. Siehe auch: HDC2, HWnd HDC2 ---- Rückgabewert: Long, Hauptfensterkopie-DC. Hinweis: Schreibweise %hDC2 ebenso erlaubt. Siehe auch: HDC Height(lH) ---------- Rückgabewert: Long, Höhe von Control lH. Siehe auch: Width HiWord(l) --------- Rückgabewert: Long, HiWord von l. Siehe auch: LoWord, Word HWnd ---- Rückgabewert: Long, Hauptfenster-Handle. Hinweis: Schreibweise %hWnd ebenso erlaubt. Siehe auch: HDC If Bedingung ... ElseIf Bedingung ... Else ... EndIf Programmverzweigung. -------------------- Siehe auch: Case, IfNot, While Iff(bArg, lTrue, lFalse) Rückgabewert: Long, if als Funktion, lFalse wenn bArg gleich 0 ist, andernfalls lTrue. IfNot Bedingung ... ElseIf Bedingung ... Else ... EndIf Programmverzweigung. -------------------- Siehe auch: If Ins(sNeedle, sText, lPos) Rückgabewert: String, sNeedle wird in sText an Position lPos eingefügt. Hinweis: Schreibweise Ins$( ebenso erlaubt. Hinweis: Die Funktion ist nicht geeignet um an das Stringende anzuhängen, lPos darf nicht größer len(sText) sein! Siehe auch: Trim InsertString(lList, lPos, sText) Fügt in die Liste lList an Position lPos sText ein. Rückgabewert: Long, undefiniert. Siehe auch: CreateList Beispiel: var list&=createList(0) //erzeuge unsortierte Liste insertString(list&, 0, "Hallo Welt") //füge "Hallo Welt" als Eintrag an Position 0 zur Liste hinzu. deleteString(list&, 0) //entferne ersten Eintrag aus der Liste destroyWindow(list&) //entferne Liste InStr(sNeedle, sText, lFrom) Rückgabewert: Long, Position vom String sNeedle im String sText bei Suche ab Position lFrom bzw. 0, wenn kein Vorkommen enthalten ist. Wichtig: In aktueller Version ist diese Funktion fehlerhaft und daher bitte nicht zu nutzen. Int(f) ------ Rückgabewert: Long, konvertiert Float f. Siehe auch: Val IsKey(l) -------- Rückgabewert: Bool, True wenn Taste mit Scancode l gedrückt ist. Siehe auch: MousePressed Left(s, l) Rückgabewert: String, l Zeichen von Links von String s. Hinweis: Schreibweise Left$( ebenso erlaubt. Siehe auch: Right Len(s) ------ Rückgabewert: Long, Stringlänge von s. Long ---- Wird Long als Funktion "long(" verwendet und ein Floatparameter angegeben, dann wird der Float wie bei Int in Long konvertiert zurückgegeben. Wird Long als Funktion verwendet und werden eine Adresse und ein Offset angegeben, dann werden 4 Byte von der Adresse als Long-Wert zurückgeliefert. Long als Befehl kennt 2 Möglichkeiten: 1) Wird eine Variable mit Variablenpostfix angegeben, dann wird der Wert an die Adresse des Variablenwertes geschrieben. 2) Suffixlose Variablen werden im C-Style deklariert. Der Klarheit halber gibt es auch GetLong und SetLong. Variablen a, b und c vom Typ Long deklarieren: long a, b, c 32-Bit-Wert von Speicheradresse einlesen: wert&=long(adresse&, offset&) 32-Bit-Wert an Speicheradresse setzen: long adresse&, offset&=wert& Float in Long konvertieren: var a&=long(2.2) Wichtig: In aktueller Version verhindert ein Fehler im Parser das man mit einem Minuszeichen beginnende Konstanten an Stelle von z& per Long x&, y&=z& und setLong(x&, y&, z&) mit korrektem Vorzeichen in den Speicher schreiben kann. Workaround: long x&, y&=z&*-1 Siehe auch: Var, Variablen, Datentypen Loop ---- Systemvariable -------------- Hinweis: Schreibweise &Loop ebenso erlaubt. Rückgabewert: Long, WhileLoop-Zählerstand Lower(s) -------- Rückgabewert: String, Großbuchstaben in String s werden in Kleinbuchstaben umgewandelt. Hinweis: Schreibweise Lower$( ebenso erlaubt. Siehe auch: Upper LoWord(l) --------- Rückgabewert: Long, LoWord von l. Siehe auch: HiWord, Word LTrim(s) -------- Rückgabewert: String, alle voranstehenden Zeichen mit Wert Beispiele --------- Control(s)/ Dialog erzeugen: cls test() waitinput end nproc test long h=control("DIALOG", "Test", \ ws_thickFrame | ws_minimizeBox | ws_maximizeBox | ws_visible | \ ws_sysmenu | ws_Popup | ws_border | ws_child | ws_caption | \ ws_hScroll | ws_vScroll, \ 300, 300, 400, 400, hWnd, 0, hInstance, 0) long lb=control("LISTBOX", "", \ ws_visible | ws_child | ws_vScroll | ws_border, \ 10, 10, 100, 200, h, 0, hInstance, 0) //listbox demoweise füllen sendmessage(lb, wm_setredraw, false, ) //listbox zeichnen abschalten, schneller whileLoop 1000 addString(lb, str$(loop)) wend sendmessage(lb, wm_setredraw, true, ) //zeichen wieder einschalten return h endproc ------- Thread(s): ---------- Kurzbeispiel per Thread-Pseudoklasse: {$cleq} cls var thread&=thread.start(procaddr(meinThread), 0, "") waitinput thread.close(thread&) end nproc meinThread parameters thread&, dataLong&, dataString$ ... return 0 endproc Ordentliches Beispiel per Thread-Pseudoklasse [...] (empfohlen): {$cleq} cls var thread&=thread.start(procaddr(meinThread), 0, "") waitinput thread.stop(thread&) //Thread senden, dass er sich beenden soll while thread.is(thread&) //Warten, solange Thread aktiv wend thread.close(thread&) //lThread Speicher freigeben end nproc meinThread parameters thread&, dataLong&, dataString$ whilenot thread.message(thread&)==wm_close settext(%hWnd, "Mein FensterTitel - ["+time$(0)+"."+substr$(time$(1), 1, ".")+"]") sleep(1000) wend return 0 endproc Thread per CreateThread-API: cls createThread(0, 0, procAddr(myTest1, 1), %hWnd, 0, 0) while 1 locate 1, 1 print myTest2() waitinput wend end nproc myTest1 parameters data& while 1 setText(data&, str$(&getTickCount)) sleep(100) wend return data& endproc nproc myTest2 return 50 endproc Timer-Proc: ----------- Print "Hallo Welt" ~setTimer(%hWnd, 0, 50, procAddr(myTest1, 4)) waitinput end nproc myTest1 parameters data&, b&, c&, d& setText(data&, str$(&getTickCount)) return data& endproc HPic, weisses Rauschen: cls --- var hPic&=create("hNewPic", 640, 480, 0) var hPicPixels&=getPixels(hPic&, 640, 480) while 1 makeMyHPic(hPic&, hPicPixels&) drawSizedPic hPic&, 0, 0 - width(hWnd), height(hWnd);0 wend end --- nProc makeMyHPic parameters hPic&, pixels& whileLoop 0, 1228800, 4 //640x480*4 long pixels&, loop=rnd(2)*$FFFFFF wend setPixels(hPic&, pixels&, 640, 480) endProc FPU/Fliesskomma selberschreiben: nProc ArcSin2 Parameters a! //Formel welche unten umgesetzt wird: arctan(a!/Sqrt(-a!*a!+1.0)) mov eax, addr(a!) finit fld qword ptr [eax] fmul qword ptr [eax] fsubr qword ptr __xeTF_00//__xeTF_00 Konstante für 0.0 fadd qword ptr __xeTF_01//__xeTF_00 Konstante für 1.0 fsqrt fdivr qword ptr [eax] fld1 fpatan fwait fstp qword ptr [eax] return a! endproc ------- Hauptfenster SubClassing: declare owp& cls owp&=setWindowLong(hWnd, gwl_wndProc, procaddr(hWnd.wndProc, 4)) waitinput end nProc hWnd.wndProc Parameters wnd&, msg&, wp&, lp& global owp& return callWindowProc(owp&, wnd&, msg&, wp&, lp&) endproc Hauptfenster SubClassing ohne Globale: cls setWindowLong(hWnd, gwl_userData, setWindowLong(hWnd, gwl_wndProc, procaddr(hWnd.wndProc, 4))) while 1 waitinput wend end nProc hWnd.wndProc Parameters wnd&, msg&, wp&, lp& if msg&=wm_lButtonDown exitProcess(22) endif return callWindowProc(getWindowLong(wnd&, gwl_userData), wnd&, msg&, wp&, lp&) endproc Control/ Listbox- SubClassing: cls var lb&=create("listbox", hWnd, "Hallo Welt", 10, 10, 100, 100) setWindowLong(lb&, gwl_userData, setWindowLong(lb&, gwl_wndProc, procaddr(my.wndProc, 4))) while 1 waitinput wend nProc my.wndProc parameters wnd&, msg&, wp&, lp& var owp&=getWindowLong(wnd&, gwl_userData) if msg&=wm_lButtonDown exitProcess(22) endif return callWindowProc(owp&, wnd&, msg&, wp&, lp&) endproc Weitere Beispiele: MessageBoxen in jeweils eigenem Thread, Rückmeldungen asynchoner MessageBoxen-Beispiel: http://xprofan.com/thread.core?t=8087 [...] ScrolListare Fenster und Controls mit dem ScrollControl/ Scrollarea: http://xprofan.com/thread.core?t=6274 [...] Pixel-Echtzeit-Manipulationen: http://xprofan.com/thread.core?p=55347 1 [...], http://xprofan.com/thread.core?t=7893 2 [...], http://xprofan.com/thread.core?p=55158#55158 3 [...]