---

Power Basic Abschnitt Prinzipien für einen Einstieg in die Programmierung		Power Basic Section Principles for an entrance into programming
This is: Power BASIC
Gott (und die Firma Power Basic) mögen mir vergeben, dass ich immer dazu neige, PB zu vergleichen mit vbScript und Visual Basic, aber das wirft etwas mehr Licht darauf, wie man über Programm-Strukturen denken kann. Mir ist bewußt, dass meine persönliche Definition, was ist strukturierte Programmierung von den Kenntnissen anderen Leute abweicht, aber ich sehe, dass sich die Strukturen ändern mit der Größe des Programms in der Absicht den Überblick zu behalten über die wachsende Funktionalität, so dass jedesmal bei der Anpassung der Struktur an die gewachsenen Erfordernisse das Programm sogar teilweise umgeschrieben werden muss. Und das ist meine persönliche Definition eines einzelnen Programmierers. Jede Programmierung beginnt mit dem Schreiben einer Prozedur-Sammlung mit einzeln getesteten Prozeduren, die ich Module nenne und welche erfahrungsgemäß in vielen Programmen vorkommen, die aber nicht enthalten sind in der kommerziellen Programmier-Sprache. Diese kann gleichzeitig wachsen mit dem ersten Programm. Ein Programm kann entweder mit einer "Form" (Fenster mit Bedienungselementen) zur Bedienung gestartet werden, oder laufen ohne jede Anzeige auf dem Bildschirm. Wenn ein Programm startet mit einer "Form" mit nur einer Listbox zur Auswahl von Parametern zum Start des Programms, welche verschwindet nach dem Programmlauf, das ist der Primär-Code, in welchen die PB-Main eingebettet ist und nach der Initiierung der Form kommt schliesslich der Aufruf des Benutzer-Programms vom Ergebnis der Form. Und gleichzeitig sollte für beide Fälle (mit und ohne Bedienerfenster) eine gleiche vom Benutzer gemachte Modul-Sammlung existieren mit allen Prozeduren in einer Include-Datei, welche wiederholt vorkommt in anderen Programmen, so dass die grosse Code-Sammlung, die Forms, die Declarationen und alles, was immer vorkommt in allen Programmen, verschwindet von der Programm-Seite, um den Überblick zu behalten, die PB-Main verbleibt auf der Programmseite und wird vom Compiler richtig übernommen. Damit ist es möglich nun eine Seite zu haben nur für das Programm (in einer SUB, aufgerufen von der Form in der UDM (User defined Modules (deutsch: benützer-eigene Module)), die Seite beginnend mit #include des UDM ) und die programm-spezifischen Prozeduren, welche nicht in anderen Programmen vorkommen. Sogar die immer am Beginn stehen müssenden Declarationen von dem Ganzen, sind in der UDM platziert, insofern es immer derselbe Code ist. Damit hat man eine Vorlage, einfach zu benützen, für die Programmierung von mehreren Programmen mit leistungsfähigen Funktionen in kurzer Zeit. Das ist das Power-Basic-Konzept. In vbScript gibt es keine includes und man müßte die Prozeduren der UDM in einer Klasse zusammen zu einem Paket schnüren, damit man sie nicht durcheinander bringt, aber der Code muss immer auf der Programmseite bleiben, auch wenn er größer ist als das Programm. vbScript ist anstatt dessen gemacht, um den Code in eine hta-Seite zu integrieren, um die Funktionen einer HTML-ähnlichen Seite zu ergänzen. In Visual Basic kann man Seiten und Prozeduren wegklappen, aber das ist ein anderes Kapitel.		God (and the Power Basic Company) may forgive me, that I always tend to compare Power Basic with vbScript and Visual Basic, but this sheds some more light on how to think in program-structures. I am conscious, that my personal definition of what is structured programming could divert from the knowledges of other people, but I see, that the structures change with the size of my programs in the intention to keep the overview over a growing functionality, so that by every accomodation of the structure to the grown demands parts of the program have even to be rewritten. And that is my personal definition of a single programmer. All programming starts by writing a procedure-collection with single tested procedures, what I call modules, which occur due to experience in many programs, but which is not included in the commercial programming language. This can grow at the same time with the first-made program. A program can be started either with a form (window with control elements) for user-control or should run without any display on screen. If a program starts with a form with only a listbox to select a parameter for start the program, which disappears after program-finish, this is the primary code, in this the PB-MAIN is embedded and called after initiating the form and the call of the user-defined program comes from the result of the form. And at the same time there should exists for both cases (with and without a control-window) a same user-made module-collection with all procedures in an include-file, which repeatedly occur in other programs, so that the big code-collection, the forms, the declarations and everything, which is always occuring in all programs, disappears from the program-page to keep the overview, the PB-Main remains in the program-page and will be taken over from the compiler correctly. It is possible to have now a page only for the program (in a SUB called by the form in the UDM (User defined Modules)), the page beginning with the #include of the userdefined modules (UDM) and a couple of lines for initiating of the UDM by calling a SUB in the UDM, and the program-specific procedures, which won't occur in other programs. Even the declarations of the entire, which always must stand at the very beginning of any program, are placed in the UDM, insofar it is always the same code. With that, one has a template, easy to use, for programming of several programs with powerful functions in a short time. This is the Power Basic-concept. In vbScript there is no include and one would have to put the procedures of the UDM in a class to tie it to a package, that procedures won't get confused, but the code must be always resident and is mostly bigger than the program. vbScript is made instead to put the code into a hta-page to complete functions of a HTML-like page. And in Visual Basic there can be pages and procedures clapped away, but this is another chapter.
Das Programm ist getestet vor der Publikation, aber es kann keine Garantie gegeben werden, dass es fehlerfrei ist 2. Sept 2012		The program ist tested before publication, but there can be given no guarantee, that it is free of errors Sept 2nd 2012

	' ----------------- Template for use of UserOwnModules ----------------- ' -------------------------- Program-File ------------------------------ #COMPILE EXE #DIM ALL #INCLUDE "Listbox.inc" #INCLUDE "UserOwnModules.INC" ' WIN32API.INC in UserOwnModules included ' DECLARE FUNCTION for program only ' DECLARE FUNCTION for program only ' DECLARE FUNCTION for program only FUNCTION PBMAIN()     ' IF Listbox used then     ShowDIALOG1 %HWND_DESKTOP     ' END IF     CALL Program END FUNCTION SUB Program(AnyText$) ' AnyText$ = Listbox-Text     CALL DeclareModuleVariables ' UserOwnModules activated     ' Users Code END SUB ' Procedure ' Procedure ' Procedure ' Procedure ' ---------------------- UserOwnModules.INC --------------------------- #IF NOT %DEF(%WINAPI)     #INCLUDE "WIN32API.INC" #ENDIF DECLARE FUNCTION GetDriveLetterFromDriveName(STRING) AS STRING ' DECLARE FUNCTION ' DECLARE FUNCTION ' DECLARE FUNCTION ' DECLARE FUNCTION SUB DeclareModuleVariables     GLOBAL CurrentPath AS STRING, CurrentFileName AS STRING     GLOBAL DriveList() AS STRING     CurrentPath = EXE.PATH$     CurrentFileName = EXE.NAME$ END SUB ' Procedure ' Procedure ' Procedure ' Procedure