Projekt NDW Near Delphi Work

[derschutzhund]

Wollte euch kurz mein aktuelles PureBasic-Projekt vorstellen.
Da mein Ideal PureBasic mit dem Komfort von Delphi oder Gambas wäre, habe ich mir mal Gedanken gemacht, wie man den FormDesigner mit dem Programmcode verbinden kann und zwar automatisch.

Wer weiterhin alles eintippen will kann/soll das tun. Mit NDW gibt es allerdings neben VisualGeneratDeluxe nun eine Möglichkeit wie Standardarbeiten automatisch erledigt werden können und die Navigation zur Procedure eines Buttons automatisch ablaufen kann.

Das Progrämmchen habe ich als PB-Anfänger geschrieben und daher ist es mit Sicherheit noch verbesserungsfähig!
Auch deshalb stelle ich es hier ein!

NDW einrichten:
Es wird zunächst einmal für das System (Linux oder Windows) kompiliert und dann als Werkzeug konfiguriert:
- Argumente: %FILE %WORD
- Warten bis zum Beenden des Werkzeugs
- Tastenkürzel Alt + G

- Tastenkürzel für "Form -> Ansicht umschalten" Alt + F
- Tastenkürzel für "Datei -> neu laden" Crtl + Alt + G

Arbeit mit NDW:
- neues Formular erzeugen und abspeichern (z.B. prog1.pbf)
- z.B. Button per drag and drop einfügen
- Beschriftung eintragen z.B. "testbutton"
- Ereignisprozedure eintragen z.B. "testbutton"
- mit Alt + F in die Codeansicht wechseln und "testbutton" markieren
- mit Alt + G wird nun prog1.pb erzeugt, der Standardcode sowie IncludeFile "prog1.pbf" und die "Procedure testbutton(EventType)" eingefügt und der Cursor befindet sich direkt in der noch leeren Procedure
- gewünschte Funktion eintippen z.B. "End"
- abspeichern. Damit ist ein Primitivprogramm erzeugt

Jetzt können neue Elemente auf die gleiche Weise eingefügt werden, wobei die Proceduren dann ans Ende des Progs angehängt werden und ebenfalls der Cursor an diese Stelle positioniert wird damit der Code eingegeben werden kann.

Wenn das .pb bereits geladen ist muss zum "neu laden" einmal Ctrl + Alt + G gedrückt werden!!!

Was mir noch nicht gefällt sind die Tastenkürzel!
Ich würde gerne nach dem Eingeben der Procedurebezeichnung im Ereignis-Procedure-Feld mit einem Doppelklick auf die Bezeichnung mein NDW starten! Dann würden die Kürzel Alt + F und Alt + G komplett weg fallen!
Oder wenn es wenigstens möglich wäre nicht mit einem Doppelklick sondern mit Alt + G zu starten.
Geht leider an der Stelle nicht, weil der Text aus dem Ereignisfeld wohl nicht nach %WORD übernommen wird!

Weiterhin bleibt das Problem des "neu ladens" wenn bereits das .pb geladen ist.
Man könnte in den Editor-Einstellungen "offene Dateien auf Änderungen auf Disk überwachen" aktivieren.
Dann muss man aber jedes Mal bestätigen und das nervt auch!
Vielleicht besteht ja hier auch noch die Möglichkeit bei den Editoreinstellungen noch einen Parameter einzubauen: "offene Dateien bei Änderungen automatisch laden" einzubauen? Sollte nicht so ein Problem sein da es ja in der aktuellen Funktion schon enthalten ist!

Bin schon auf eure Meinung gespannt!
Viel Spaß beim Testen!

Code: Alles auswählen

EnableExplicit
;##################################################################
;## Programm: NDW      (Near Delphi Work)                        ##
;## Erzeugung einer neuen Codedatei aus einer pbf - Datei        ##
;## automatische Navigation zur Procedure eines pbf-Elements     ##
;##                                                              ##
;## schnellere Programmentwicklung und einfachere Navigation !   ##
;## Version 1.0 von W.Schmidt                                    ##      
;## Start als externes Werkzeug mit Aufrufparameter: %FILE %WORD ##
;##     Die Parameter genau in dieser Reihenfolge angeben!!      ##
;## Den neuen Procedurnamen im pbf markieren und NDW starten     ##
;##################################################################

Define event, EventGadget, EventType, EventMenu, EventWindow, prglauf
Define progverz$, proz$, pb_path$, pb_name$

Global NewList Dateinhalt.s()

progverz$=ProgramParameter()                                 ;lese ersten übergebenen Parameter
proz$=ProgramParameter()                                     ;lese den zweiten Parameter

;progverz$ = "/mnt/sda1/PureBasic/turbo/testprog.pbf"       ;########## Linux-test
;progverz$ = "C:\PureBasic\turbo\testprog.pbf"              ;########## windows-test
;proz$="taste_1"                                            ;########## test

pb_path$=GetPathPart(progverz$)                              ;Path der *.pbf ermitteln
pb_name$=ReplaceString(GetFilePart(progverz$),".pbf","")     ;name ermitteln und Endung .pbf löschen

;prüft ob string_datei (.pb) vorhanden ist sonst erzeugen und Standardkopf einfügen sowie die leere Procedure
;------------------------------------------------------------------------------------------------------------
Procedure  lese_pbf(string_path$,string_datei$,string_proz$)   
  Define string_hilf$, zeilennr, gefundennr, i
  
  #DATEI_REPORT = 1
   
  If FileSize(string_path$ + string_datei$ + ".pb") = -1                                                               ;prüfen ob Datei.pb vorhanden ist -> nicht vorhanden
                                                    ;Datei.pb nicht vorhanden, wird neu erzeugt!
    If CreateFile(#DATEI_REPORT, string_path$ + string_datei$ + ".pb")    
      WriteStringN(#DATEI_REPORT, "EnableExplicit")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "IncludeFile " + Chr(34) + string_datei$ + ".pbf" + Chr(34))
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "Define event, EventGadget, EventType, EventMenu, EventWindow, prglauf")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "OpenWindow_0()")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "; ----- hier etwas das sofort beim Start erledigt werden soll eintragen")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "Repeat")
      WriteStringN(#DATEI_REPORT, "  Event = WaitWindowEvent()")
      WriteStringN(#DATEI_REPORT, "  EventGadget = EventGadget()")
      WriteStringN(#DATEI_REPORT, "  EventType = EventType()")
      WriteStringN(#DATEI_REPORT, "  EventMenu = EventMenu()")
      WriteStringN(#DATEI_REPORT, "  EventWindow = EventWindow()")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "  prglauf=Window_0_Events(Event)")
      WriteStringN(#DATEI_REPORT, "Until prglauf=#False")
      WriteStringN(#DATEI_REPORT, "End")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, ";-------- ab hier die Proceduren für Buttons, etc. -----------------")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "Procedure " + string_proz$ +"(EventType)")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "EndProcedure")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, " ")
      WriteStringN(#DATEI_REPORT, "; IDE Options = PureBasic 5.11 (Linux - x86)")
      WriteStringN(#DATEI_REPORT, "; CursorPosition = 24")
      WriteStringN(#DATEI_REPORT, "; FirstLine = 1")
      WriteStringN(#DATEI_REPORT, "; Folding = -")
      WriteStringN(#DATEI_REPORT, "; EnableThread")
      WriteStringN(#DATEI_REPORT, "; EnableXP")
      WriteStringN(#DATEI_REPORT, "; Executable = " + string_datei$)
      CloseFile(#DATEI_REPORT)
    EndIf 
 
  Else                                                                                                   
    zeilennr=0                                                                  ;Datei.pb ist vorhanden
    gefundennr=0
    If ReadFile(#DATEI_REPORT, string_path$ + string_datei$ + ".pb")                               
      While Eof(#DATEI_REPORT) = #False
        AddElement(Dateinhalt())
        zeilennr = zeilennr + 1
        string_hilf$ = ReadString(#DATEI_REPORT)
        If FindString(string_hilf$,"Procedure " + string_proz$) > 0             ;Procedure wurde bei Gefundennr gefunden
          gefundennr=zeilennr
        EndIf
        Dateinhalt() = string_hilf$
      Wend
      CloseFile(#DATEI_REPORT)
    EndIf
         
    If gefundennr = 0                        ;----------------------------Procedure ist noch nicht vorhanden
                                             ;---------------- neue Procedure am Ende des Prog einbauen
      LastElement(Dateinhalt())
      PreviousElement(Dateinhalt())
      Repeat      
        PreviousElement(Dateinhalt())
        string_hilf$ = Trim(Dateinhalt())
      Until string_hilf$= "" 
      
      InsertElement(Dateinhalt())
      Dateinhalt() = " "      
      InsertElement(Dateinhalt())
      Dateinhalt() = "EndProcedure"
      InsertElement(Dateinhalt())
      Dateinhalt() = " "
      InsertElement(Dateinhalt())
      Dateinhalt() = "Procedure " + string_proz$ +"(EventType)"
      
      zeilennr=0                                                                  ;Datei.pb ist vorhanden
      gefundennr=0

      ForEach Dateinhalt()
        zeilennr = zeilennr +1
        If FindString(Dateinhalt(),"Procedure " + string_proz$) > 0             ;Procedure wurde bei Gefundennr gefunden
          gefundennr=zeilennr
        EndIf
 
      Next
                                          
    EndIf
    If CreateFile(#DATEI_REPORT, string_path$ + string_datei$ + ".pb")        ;neue Cursorposition abspeichern
      ForEach  Dateinhalt()
        If FindString(Dateinhalt(),"; CursorPosition =") = 1
          Dateinhalt() = "; CursorPosition = " + Str(gefundennr )
        EndIf
        
        If FindString(Dateinhalt(),"; FirstLine =") = 1
          Dateinhalt() = "; FirstLine = 1"
        EndIf  
        
        WriteStringN(#DATEI_REPORT, dateinhalt())
      Next
      CloseFile(#DATEI_REPORT)
    EndIf
  
  EndIf
     
EndProcedure
      
;------------------------------------------------------------------
lese_pbf(pb_path$,pb_name$,proz$)

If FindString(pb_path$,"\") > 0      ;Test ob Windows oder Linux
  RunProgram(#PB_Compiler_Home + "PureBasic.exe",pb_path$ + pb_name$ + ".pb","")

Else
  RunProgram(#PB_Compiler_Home + "compilers/purebasic",pb_path$ + pb_name$ + ".pb","") 
EndIf  

End

[matbal]

Ich glaube, daß du mehr von Delphi übernehmen willst, als mit dem Designer bis jetzt möglich ist.

Das Generieren der fehlenden Ereignisprozedur ist praktisch. Allerdings sind es einige (zu viele) Umwege, die man gehen muß - weil man eben nur über den Quelltext der Form den Namen der Prozedur markieren kann.

Außerdem hat dein Konzept eine Schwäche; man kann nur eine Form im Projekt einbauen. In der PB-Hilfe ist ein Beispiel, wie es mit mehreren Form-Dateien gehen würde.

In Anlehnung an das Beispiel in der PB-Hilfe würde ich mich nur auf das wesentliche beschränken, das Anlegen fehlender Prozeduren. Das Tool müßte dann folgendes machen:
- In der Main-Datei die Include-Anweisungen für die Form-Dateien suchen.
- In den Form-Dateien die Declares für die Event-Prozeduren suchen.
- In der Main-Datei nach vorhandenen Prozeduren suchen und fehlende Prozeduren anhängen.

So könnte man im FormDesigner gleich mehrere Ereignisprozeduren eintragen, und am Ende mit einem Klick alle neuen Prozeduren in die Main-Datei anlegen lassen.

Das Suchen nach den Eventprozeduren geht über den Reiter "Prozeduren" einfacher als der Weg mit NDW, ist also eigentlich unnötig.

---------

Ich hoffe ja, daß sich im FormDesigner noch einiges tun wird.

Insbesondere der vorgeschlagene Name für ein eingefügtes Gadgets sollte auch den Namen des Window beinhalten - würde einiges Tippen ersparen, wenn man mehrere Fenster verwenden will.

p.s. Noch ein kleiner Fehler in deiner Vorlage ist mir aufgefallen. Die beiden Prozeduren OpenWindow_0 und Window_0_Events heißten nur so, wenn das Fenster Window_0 heißt.

[derschutzhund]

Hallo matbal,

schön eine Rückmeldung zu bekommen!

Ich glaube, daß du mehr von Delphi übernehmen willst, als mit dem Designer bis jetzt möglich ist.

Natürlich möchte ich mehr von Delphi übernehmen als der Designer bis jetzt möglich macht, sonst hätte ich NDW ja nicht programmieren müssen. Der Designer ist jetzt im Augenblick wie er ist und einige (viele) nutzen ihn vermutlich nicht, weil die Verbindung zwischen Code und Form nicht durchgängig funktioniert.
Das ist der Ausgangspunkt.

Das Generieren der fehlenden Ereignisprozedur ist praktisch. Allerdings sind es einige (zu viele) Umwege, die man gehen muß - weil man eben nur über den Quelltext der Form den Namen der Prozedur markieren kann.

Genau das ist der Punkt der es im Augenblick unmöglich macht eben so schnell mit PureBasic ein kleines Programm zu realisieren wie mit Delphi!
So bald der / die Entwickler von PB diese kleine Erweiterung programmieren, dass man mit WORD% auch einen Wert aus dem Eigenschaftsbereich übergeben kann ist es wirklich geschmeidig!
Absolut genial wäre es, wenn man NDW, oder wie es dann auch immer heißt, über einen Doppelklick starten könnte!

Ich denke das sind kleine Erweiterungen die viele neue Möglichkeiten eröffnen.
Es sollte doch für Programmentwickler nichts besseres geben als wenn Anwender Anregungen geben und einen Lösungsweg gleich dazu!!!

Außerdem hat dein Konzept eine Schwäche; man kann nur eine Form im Projekt einbauen. In der PB-Hilfe ist ein Beispiel, wie es mit mehreren Form-Dateien gehen würde.

Stimmt, das ist im Augenblick so. Ich wollte halt irgendwo mal anfangen, aber wenn es gewünscht wird könnte man das leicht über eine Art "Steuerdatei" erweitern. Darüber habe ich mir schon Gedanken gemacht.
Da aktuell meine eigenen kleinen Programme mit einer Form auskommen hab ich mir es erst mal so einfach wie möglich gemacht.

In Anlehnung an das Beispiel in der PB-Hilfe würde ich mich nur auf das wesentliche beschränken, das Anlegen fehlender Prozeduren. Das Tool müßte dann folgendes machen:
- In der Main-Datei die Include-Anweisungen für die Form-Dateien suchen.
- In den Form-Dateien die Declares für die Event-Prozeduren suchen.
- In der Main-Datei nach vorhandenen Prozeduren suchen und fehlende Prozeduren anhängen.

Das ist überhaupt kein Problem!

So könnte man im FormDesigner gleich mehrere Ereignisprozeduren eintragen, und am Ende mit einem Klick alle neuen Prozeduren in die Main-Datei anlegen lassen.

Darüber habe ich auch nachgedacht. So in der Art macht es ja VisualGenerateDeluxe.
Daran gefällt mir nicht, dass zu viele Dateien erzeugt werden und auch, dass es keine Navigation zur Procedure gibt.
Das ist bei NDW anders. Die Erzeugung und die Navigation sind in einer Funktion vereint!
Es spricht auch nichts dagegen in der Form beliebig viele Proceduren zu definieren und dann der Reihe nach einzufügen.
Oder wenn es absolut gewünscht wird macht man halt ein kleines, zweites Programm zum Erzeugen aller Proceduren in einer MainDatei.
Das ist die leichteste Übung!

Das Suchen nach den Eventprozeduren geht über den Reiter "Prozeduren" einfacher als der Weg mit NDW, ist also eigentlich unnötig.

So lange es die "Doppelklickfunktion" nicht gibt könnte man es natürlich auch über den Reiter "Proceduren" machen.

Insbesondere der vorgeschlagene Name für ein eingefügtes Gadgets sollte auch den Namen des Window beinhalten - würde einiges Tippen ersparen, wenn man mehrere Fenster verwenden will.

Das wäre sicher eine Verbesserung!

p.s. Noch ein kleiner Fehler in deiner Vorlage ist mir aufgefallen. Die beiden Prozeduren OpenWindow_0 und Window_0_Events heißten nur so, wenn das Fenster Window_0 heißt.

Stimmt! Das ist mir auch aufgefallen. Werde ich noch ändern!

Vielen Dank erst mal für deine Rückmeldung und die Anregungen!

Wolfgang

[matbal]

So könnte man im FormDesigner gleich mehrere Ereignisprozeduren eintragen, und am Ende mit einem Klick alle neuen Prozeduren in die Main-Datei anlegen lassen.

Darüber habe ich auch nachgedacht. So in der Art macht es ja VisualGenerateDeluxe.
Daran gefällt mir nicht, dass zu viele Dateien erzeugt werden und auch, dass es keine Navigation zur Procedure gibt.
Das ist bei NDW anders. Die Erzeugung und die Navigation sind in einer Funktion vereint!
Es spricht auch nichts dagegen in der Form beliebig viele Proceduren zu definieren und dann der Reihe nach einzufügen.
Oder wenn es absolut gewünscht wird macht man halt ein kleines, zweites Programm zum Erzeugen aller Proceduren in einer MainDatei.
Das ist die leichteste Übung!

Damit kein Mißverständnis entsteht...
Ich dachte im Beispiel an eine PB-Datei (Code), in der mehrere PBF-Dateien eingebunden sein können. Der Generator bekommt die PB-Datei, sieht darin welche PBF-Dateien verwendet werden und kann dann in den PBF-Dateien nachsehen, welche Ereignis-Prozeduren gebraucht werden.

Es wären nur eine Code-Datei und für jedes Fenster je eine PBF-Datei. In diese Code-Datei kommen auch die Ereignisprozeduren, die im FormDesigner eingetragen wurden.

Die einzige Bedingung, damit das funktionieren kann, ist, daß die Include-Anweisungen für die benötigten PBF-Dateien schon im Code eingetragen sein müssen.


Ich gehöre auch zu denen, die den integrierten FormDesigner noch nicht nutzen, einfach weil er noch unfertig ist.
Ich bevorzuge PureForm. Zusammenstellen einer Form geht damit einfach und man kann einstellen, wie die Namen der Konstanten aufgebaut sein sollen. Auch Ereignisprozeduren kann man schon anlegen lassen, wenn man will.

[Lothar Schirm]

Hallo matbal,

wie kommst du denn mit Pureform zurecht? Gibt es da keine Kollisionsprobleme mit dem Form Designer? Beide speichern ihre Daten mit der Erweiterung .pbf ab. Da muss man schon aufpassen, eine pbf-Datei mit dem richtigen Programm zu öffnen und im Fehlerfall diese ja nicht zu speichern, sonst ist sie hin. Oder kann man die IDE so einstellen, dass sie den Form Designer ignoriert? Und wie kann man Pureform so einstellen, dass es Ereignisprozeduren erzeugt?

[matbal]

Und wie kann man Pureform so einstellen, dass es Ereignisprozeduren erzeugt?

Rechtsklick auf ein Gadget und im Kontextmenü "Code infussion" auswählen. Dann öffnet sich ein Editorfenster für den Code. Wenn man da eine Code-Zeile reinschreibt, wird eine Prozedur für das Gadget angelegt. Ich schreibe dort nur eine kurze Debug-Anweisung rein. Den eigentlichen Code schreibe ich doch lieber im PB-Editor...

Wenn mein Fenster #FormMain heißt, und mein Gadget #FormMain_ListIcon_Show, entsteht eine Prozedure FormMain_ListIcon_Show_OnEvent(EventType).

Ich benutze den Designer wirklich nur für die ersten Schritte, das erste Gerüst. Bei geeigneten Einstellungen bekommen die Konstanten auch gleich praktische Bezeichnungen. Und das erspart einige Tipparbeit.

[Lothar Schirm]

Danke!

Ich bin soweit mit dem Form Designer zufrieden, er macht was ich brauche, man kann auch das Design nachträglich gut ändern / erweitern. Ein bisschen mehr Komfort könnte allerdings nicht schaden, z.B. eine automatische Erzeugung der Ereignisprozedur, wenn man einen Doppelklick auf ein Gadget macht. Aber vielleicht kommt das ja noch. Ich habe mal den FireFly Visual Designer für FreeBASIC ausprobiert, der macht das, erzeugt aber eine Riesenmenge an WinAPI Code im Hauptprogramm. Da bleibe ich lieber bei PureBasic, da ist die GUI-Programmierung schön schlank und übersichtlich.

[derschutzhund]

Danke!

Ich bin soweit mit dem Form Designer zufrieden, er macht was ich brauche, man kann auch das Design nachträglich gut ändern / erweitern. Ein bisschen mehr Komfort könnte allerdings nicht schaden, z.B. eine automatische Erzeugung der Ereignisprozedur, wenn man einen Doppelklick auf ein Gadget macht. Aber vielleicht kommt das ja noch. Ich habe mal den FireFly Visual Designer für FreeBASIC ausprobiert, der macht das, erzeugt aber eine Riesenmenge an WinAPI Code im Hauptprogramm. Da bleibe ich lieber bei PureBasic, da ist die GUI-Programmierung schön schlank und übersichtlich.

Das sehe ich ähnlich wie du! PureBasic ist so schön klein und übersichtlich und im Grunde fehlt garnicht mehr so viel damit man wirklich komfortabel damit arbeiten kann.
- geänderte Dateien automatisch in die IDE laden und zwar ohne Nachfrage (wäre einfach ein zusätzlicher Auswahlpunkt in Einstellungen -> Editor)
Ist eigentlich nur eine abgespeckte Version von "Offene Dateien ..."

- Werte aus dem Feld "Ereignis-Procedur" in %WORD übernehmen und nicht nur aus dem Codebereich

- Doppelklick als Startereignis im Form -> Eigenschaftsbereich z.B. auf dem Feld "Ereignis-Procedur"

- Vielleicht könnte man noch jeweils vor und nach dem Aufruf eines externen Programms Tastenfunktionen definieren

Allein wenn die ersten beiden Punkte möglich wären könnte man schon ein sehr komfortabel arbeiten.

Inzwischen habe ich noch testweise per Ctrl + C den Inhalt des Feldes "Ereignis-Procedur" ins Clipboard kopiert dann in meinem NDW per "proz$=GetClipboardText()" eingelesen und dann NDW ohne sonstige Änderung laufen lassen.
Es läuft gut wenn man das externe NDW über einen Startbutton oben im Menü startet. Wenn man es aber über eine Tastenfunktion, egal welche startet dann kommt die Info, dass das aktuelle *.pb geändert werden soll und ob diese Änderung durch das Einlesen überschrieben werden soll.
Bestätigt man das dann wird das neue *.pb richtig eingelesen aber man muss halt immer einmal ok mehr anklicken.

Hat dazu jemand eine Idee woran es liegen könnte????

LG

Wolfgang

[derschutzhund]

Aktueller Stand zum Projekt NDW:

Für mein Minitestprogramm welches mit einem Button den Inhalt eines Textfeldes in ein anderes Textfeld kopiert ist soweit optimiert dass es insgesamt mit einer Tastenfunktion auskommt.
Ich habe mir dafür Crtl + rechte Maustaste definiert.
Um das gesamte Testprogramm zu erstellen benötige ich 1 Minute 24 Sek.
Viel Zeit kostet allein diese Zeile: "SetGadgetText(string_0,GetGadgetText(string_1))"

Arbeit mit NDW am Beispiel eines Primitivprogramms mit einem Ende-Button:
- neues Formular erzeugen und abspeichern (z.B. prog1.pbf)
- z.B. Button per drag and drop einfügen
- Beschriftung eintragen z.B. "ende"
- Ereignisprozedure eintragen z.B. "ende"
- Crtl + rechte Maustaste
Jetzt wird automatisch das komplette prog1.pb erzeugt sowie eine leere Procedure "ende".
- gewünschte Funktion eintippen z.B. "End"
- abspeichern. Damit ist ein Primitivprogramm erzeugt

Dafür braucht man insgesamt 30 Sek.

Um diesen Automatismus zu erhalten verwende ich neben einem kleinen PureBasic-Programm das Freewareprog. "Autohotkey" mit einem kleinen Script (7 Zeilen)

Unter Linux läuft es mit xdotool !

LG Wolfgang

[Derren]

Viel Zeit kostet allein diese Zeile: "SetGadgetText(string_0,GetGadgetText(string_1))"
[...]
gewünschte Funktion eintippen z.B. "End"

D.h. beim schreiben von reinem PB Code schreibst du "SetGadgetText...." und brauchst da für 1,5 min.
Und mit deinem Tool, mit dem nur 30 Sek. brauchst schreibst du "End"?

Also entweder übersehe ich komplett den Schritt bei dem definiert wird, dass ein GadgetText geändert wird, oder du musst auch mit deinem Tool "SetGadgetText..." schreiben womit du aber deutlich länger als 30 Sek. brauchen würdest.