|
Über dieses Programm:
Die Idee dieses Programms hatte ich bereits vor langer Zeit. Ich wollte ein Programm entwerfen, das etwas leistet und das man herzeigen kann. Normalerweise habe ich als Schüler nicht soviel Zeit, um ein wirklich anspruchsvolles Programm zu entwerfen. Diese Fachbereichsarbeit gab mir die Gelegenheit dazu, ein Programm aus zwei Gründen zu entwerfen. Der erste Grund ist, wie bereits erwähnt, daß ich schon immer einmal ein leistungsfähiges Programm entwerfen wollte. Der zweite Grund ist, daß ich dies dann machen kann, wenn es mir wirklich etwas nützt.
Aufgrund dieser Fachbereichsarbeit kann ich nun diese beiden Faktoren verknüpfen.
Natürlich kann sich dieses Programm nicht mit den Programmen von professionellen Programmierern messen. Es ist auch erst das zweite Projekt in dieser Größenordnung. Das Ziel dieses Programmes ist es, ein gutes Beispiel dafür zu sein, was mit einfachen Mitteln alles möglich ist. Zu Beginn sollte dieses Programm einfach die Möglichkeiten darstellen, was alles möglich ist. Ich dachte zuerst nicht daran, ein vollständiges Programm zu entwickeln. Im Laufe der Zeit allerdings, kam immer mehr der Wunsch nach einer "richtigen" Oberfläche. Da zuerst die Laufwerksinformationen entwickelt wurden, war zunächst dies mein Hauptfenster. Als ich dann allerdings nicht mehr wußte, wie ich die verschiedenen Schaltflächen anordnen sollte, wurde mir klar, daß eine größere Oberfläche her mußte. Ein einfaches Fenster, das sich zu Beginn öffnet und mir zehn verschiedene Schaltflächen zeigte, war mir zu primitiv und unschön. Also beschloß ich, einen Explorer bzw. Dateimanager - Ersatz zu machen. Obwohl auch meine Version viele Funktionen für verschiedene Dateitypen beinhaltet, ist es kein vollwertiger Ersatz. Die Programmierung schritt fort, und kurze Zeit später hatte ich die Systemspeicherinformationen, die Prozessorinformationen und Betriebssysteminformationen. Als Schlußpunkt suchte ich noch einige spielerische aber dennoch nützliche API - Funktionen, die mir ich unter die Rubrik "Verschiedene API - Funktionen" steckte. Vielleicht sind diese im Augenblick nicht nützlich, aber es ist einfacher an sie zu gelangen als sich in der Systemsteuerung von Windows95 herumzuquälen.
Information bezüglich Sourcecode:
Da ich nicht den ganzen Sourcecode abdrucken kann, der gute 34 Seiten umfaßt (+20 Seiten Programmformatierung), habe ich eine CD beigelegt, die sowohl diese Arbeit als auch den vollständigen Code des Programmes enthält. Ich habe mich dazu entschlossen, nur die wichtigsten Stellen abzudrucken. Damit sind die Stellen gemeint, die für die API - Routinen wirklich wichtig sind. Da ich nur wenige, dafür teilweise recht komplizierte API - Routinen verwende, habe ich mich ebenfalls entschlossen alle davon mit dem richtigen Aufruf darzustellen. Diese stellvertretend für die gewaltige Menge an API - Aufrufen. Alle Aufrufe der restlichen Routinen, funktionieren mehr oder weniger nach demselben Prinzip.
Vor dem Programmcode befindet sich eine kurze Beschreibung der Form, die klarmachen soll, was diese Form darstellen bzw. auswerten soll und um was es sich in dem jeweiligen Teilbereich des Programmes handelt.
Der eigentliche Programmcode wird in Blau dargestellt. Nach jedem Programmblock folgt eine kurze Erklärung, die die wichtigsten Schritte verdeutlicht.
Der Sourcecode:
Generelle Informationen:
In diesem Programm kommen sehr viele benutzerdefinierte Datentypen vor. Diese werden, zusammen mit den API - Aufrufen in dem Modul Modul1.bas definiert.
Die Hauptform:
Diese Form ist eigentlich nicht sehr wichtig, denn sie ist nur die Sprungform zu den wichtigen Teilen.
Allerdings enthält sie eine API - Routine. Bei Doppelklick auf eine Datei mit Endung "wav" innerhalb des Dateifensters, wird diese Sounddatei (wav = Sounddatei) automatisch abgespielt. Die der dazu gehörende Code:
Dim PathuDatei As String
If Len(Dir1.Path) > 3 Then \'markierte Datei an Variable PathuDatei übergeben
PathuDatei = Dir1.Path + \"\\\" + File1.filename
Else
PathuDatei = Dir1.Path + File1.filename
End If
endung = Trim$(Right$(PathuDatei, 3))
Select Case endung
...
Case \"wav\"
xxx& = sndPlaySound(PathuDatei, 1) \'API - Aufruf, um Sound Datei abzuspielen
...
Case Else
...
End Select
Hier wird zuerst der Variable "PathuDatei" der Datentyp String zugewiesen. Der Variable PathuDatei wird darauf der Name und der Ort der Datei, auf die doppelgeklickt wurde, übergeben (Bsp.: "C:\\WINDOWS\\MEDIA\\Der Microsoft Sound.wav". Hierauf werden die letzten drei Zeichen genommen (sie sind die endung), welche dann in der Variable "endung" gespeichert werden. Nun folgt eine Select Case - Anweisung, die je nach "endung" eine bestimmte Prozedur vollzieht. In diesem Fall geschieht dies, wenn die Endung auf "wav" lautet. Ist dies der Fall, so wird eine API - Routine aufgerufen, die den Namen sndPlaySound trägt. Ihr werden zwei Parameter übergeben. Einer übergibt die Datei und wo diese gespeichert ist, der andere bezeichnet die Art, wie die Datei abgespielt wird. Dies ist die einzige API - Routine, die in dieser Form vorkommt.
Die Form ProzInfo:
Auch hier kommt nur eine API - Routine zum Einsatz. Diese liefert allerdings mehr als eine Information. Sie würde noch mehrere Informationen liefern, allerdings sind diese in diesem Programm nicht wichtig. Benötigt werden nur zwei Informationen: Die Anzahl der Prozessoren und den Typ der/des Prozessoren/Prozessors. Diese Informationen werden in einer benutzerdefinierten Variable namens "SysInfo" gespeichert. Hier der Code:
\'DEKLARATION DER VARIABLEN
DIM SYSINFO AS SYSTEM_INFO \'BENUTZERDEFINIERTER DATENTYP
DIM M AS STRING
GETSYSTEMINFO SYSINFO \'API - AUFRUF
M$ = \"PROZESSORTYP: \"
\'PROZESSORTYP
SELECT CASE SYSINFO.DWPROCESSORTYPE
CASE PROCESSOR_INTEL_386
M$ = M$ + \"INTEL 386\"
CASE PROCESSOR_INTEL_486
M$ = M$ + \"INTEL 486\"
CASE PROCESSOR_INTEL_PENTIUM
M$ = M$ + \"INTEL PENTIUM\"
CASE PROCESSOR_MIPS_R4000
M$ = M$ + \"MIPS R4000\"
CASE PROCESSOR_ALPHA_21064
M$ = M$ + \"ALPHA WORKSTATION\"
...
M$ = M$ + VBCRLF
M$ = M$ + \"ANZAHL DER PROZESSOREN: \"
\'ANZAHL DER INSTALLIERTEN PROZESSOREN
ANZ& = SYSINFO.DWNUMBERORFPROCESSORS
M$ = M$ + STR$(ANZ&)
Zu Beginn werden die verschiedenen Variablen initialisiert. "SysInfo" wird als benutzerdefinierte Variable SYSTEM_INFO und "m" als Zeichenkette initialisiert. Die API - Routine wird mit der Anweisung GetSystemInfo aufgerufen. Die verschiedenen Werte werden an die Variable SysInfo übergeben. In der Variable m steht, was später im Bezeichnungsfeld in der Form ausgegeben werden soll. Zuerst das Wort Prozessortyp, dann der dazugehörige Wert, eine Zeilenschaltung und dann die Zeichenfolge "Anzahl der Prozessoren" und deren Wert.
Der Prozessortyp ist in einer Untervariable der Variable SysInfo gespeichert. Diese Untervariable lautet "dwProcessorType". Die gesamte Variable lautet demzufolge "SysInfo.dwProcessorType". Die zweite Untervariable betrifft die Anzahl der Prozessoren und lautet "dwNumberOrfProcessors". Die zusammengesetzte lautet demzufolge "SysInfo.dwNumberOrfProcessors".
In dem Modul Modul.bas befinden sich die Konstanten, die benötigt werden, um den Prozessortyp zu bestimmen, da die Variable dwProcessorType nur einen Hexadezimalwert liefert. Der richtige Prozessor wird durch eine Case - Anweisung ausgewählt.
Die Form OSInfo:
Diese Form stellt Informationen, die das Betriebssystem betreffen, dar. Auch hier wird wieder ein benutzerdefinierter Datentyp verwendet.
DIM VI AS OSVERSIONINFO \'BENUTZERDEFINIERTER DATENTYP
DIM MAJORVERSION AS STRING \'HAUPT VERSION
DIM MINORVERSION AS STRING \'UNTER VERSION
GETVERSIONEX VI \'API - AUFRUF: SPEICHERT INFORMATIONEN IN DER VARIABLE VI
SELECT CASE VI.DWMAJORVERSION
...
VERSIO$ = MA$ + \".\" + MI$ + \".\" + M$
...
INFO$ = VI.SZCSDVERSION
...
LABEL1.CAPTION = \"MAJOR VERSION: \" + MAJORVERSION + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"MINOR VERSION: \" + MINORVERSION + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"BUILD: \" + STR$(VI.DWBUILDNUMBER) + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"PLATFORM ID: \" + STR$(VI.DWPLATFORMID) + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"VERSION: \" + VERSIO$ + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"ZUSATZINFORMATIONEN \" + INFO$ + VBCRLF
...
Hier wird die Variable "Vi" als benutzerdefinierter Datentyp dimensioniert. Außerdem werden zwei weitere Variablen benötigt: Die Hauptversion und die Unterversion des Betriebssystem. Existiert kein zweites Betriebssystems, so soll eine Meldung im Bezeichnungsfeld auf der Form stehen. Die hier benötigte API - Routine lautet mit vollem Aufruf: "GetVersionEx Vi". Durch diesen werden sämtliche Werte in der Variable Vi gespeichert.
Die Versionsnummer setzt sich aus mehreren Komponenten zusammen. Der Nummer der Hauptbetriebsystems, der Nummer des Unterbetriebsystems und aus der Build Number, die ebenfalls ein Teilbereich der Variable Vi ist.
Eventuelle Zusatzinformationen werden noch in der Variable "szCSDVersion" gespeichert und schlußendlich wird die Information in das Bezeichnungsfeld der Form "OsInfo" eingetragen.
Die Form RamInfo:
Diese Form ist zwar etwas komplizierter aufgebaut, ist allerdings dasselbe wie die vorhergehenden Formen. Sie beinhaltet wiederum eine einzelne API - Routine, die sämtliche Werte in einer Variable abspeichert. Diese werden dann jeweils durch 1024 dividiert, um die nächst - größeren Einheiten zu erhalten (Kbyte, Mbyte, ...).
DIM MEMINFO AS MEMORYSTATUS
GLOBALMEMORYSTATUS MEMINFO
USED& = MEMINFO.DWMEMORYLOAD
\'PHYSIKALISCHER SPEICHER (WIRKLICH)
PHYSICAL& = MEMINFO.DWTOTALPHYS / 1024
AVAIL& = MEMINFO.DWAVAILPHYS / 1024
PIP& = 100 * AVAIL& / PHYSICAL&
\'PAGE FILE - SPEICHER
PAGEFILE& = MEMINFO.DWTOTALPAGEFILE / 1024
AVAILPAGE& = MEMINFO.DWAVAILPAGEFILE / 1024
PFIP& = 100 * AVAILPAGE& / PAGEFILE&
\'VIRTUELLER SPEICHER
VIRTUAL& = MEMINFO.DWTOTALVIRTUAL / 1024
AVAILVIRTUAL& = MEMINFO.DWAVAILVIRTUAL / 1024
VIP& = 100 * AVAILVIRTUAL& / VIRTUAL&
Die Variable memInfo wird hier, wie bei den anderen Formen, als ein benutzerdefinierter Datentyp dimensioniert. Nun wird der API Aufruf mit "GlobalMemoryStatus memInfo" vollzogen. Die Variable beinhaltet nun die verschiedenen Werte für den physikalischen Speicher, den Page File - Speicher und den Virtuellen Speicher in Byte. Sie beinhaltet sowohl den zur Zeit benutzten als auch den zur Zeit freien Systemspeicher. Nun werden die einzelnen Angaben der Reihe nach in Kbyte und in Prozent umgewandelt, um besser lesbare Werte zu erhalten. Zum Schluß werden diese wieder in drei verschiedene Bezeichnungsfelder eingetragen.
Die Form SysInfo:
Diese Form stellt verschiedene Möglichkeiten zur Auswahl, wie Windows beendet werden soll. Dies sind genau die Funktionen, die man beim Abschalten des Computers erhält. Diese Funktionen sind ebenfalls API - Routinen. Genauer gesagt sie sind eine einzelne API - Routine, der als Parameter übergeben werden muß, wie Windows beendet werden soll. Dieses Problem wurde mit vier Optionsknöpfen gelöst (Windows beenden, Windows neu starten, MS-DOS - Modus, Neu Anmelden). Außerdem enthält die Form zwei Schaltflächen, durch die die Auswahl bestätigt oder abgebrochen werden soll (OK, Abbrechen).
IF OPTION1.VALUE = TRUE THEN R& = EXITWINDOWSEX(1, 0)
IF OPTION2.VALUE = TRUE THEN R& = EXITWINDOWSEX(2, 0)
IF OPTION3.VALUE = TRUE THEN R& = EXITWINDOWSEX(8, 0)
IF OPTION4.VALUE = TRUE THEN R& = EXITWINDOWSEX(0, 0)
Dies ist der ganze Code, der für diese vier Möglichkeiten benötigt wird. Die API - Routine lautet "ExitWindowsEx". Ihr wird ein Parameter übergeben, der bestimmt, auf welche Art dies geschieht. Der zweite Parameter ist nicht wichtig. Er wird daher auf 0 (Null) gesetzt. Um unterscheiden zu können, welches Optionsfeld aktiviert wurde, wird die If - Bedingung verwendet.
Die Form SmallDriveDir
Diese Form beinhaltet eigentlich keinen richtigen API - Aufruf. Dennoch ist sie wichtig, um eine Datei auszuwählen, die dann einer anderen Form als globale Variable übergeben wird. Mit Hilfe einer API werden dann aus dieser Datei verschiedene Informationen genommen, die z.B.: bestimmen, ob es eine 32bit - EXE(cute) - Datei ist. Sie ist demzufolge nur ein kleiner Baustein, der in meinem Programm genutzt wird und beinhaltet keine API - Routinen.
Die Form GenInfo:
Diese Datei beinhaltet verschiedene API - Routinen, die den Benutzernamen bzw. den Namen des Computers ermitteln, die Multimedia - Ausrüstung (Soundkarte) ermitteln, den Batteriestatus ermitteln (nur bei einem Notebook interessant), die Systempfade für das Windows - Systemverzeichnis bzw. das temporäre Verzeichnis ermitteln und auch die Sprungplattform zur Form SmallDriveDir ist (32bit - Programme). Diese Form ist sehr komplex und unterschiedet sich von den bisherigen Formen dadurch, daß nicht nur eine einzelne API - Routine, sondern gleich mehrere Funktionen vorkommen.
Hier ein paar Bruchstücke aus dem Code dieser Form:
PRIVATE SUB FORM_LOAD()
X = VBCRLF
\' WERTE IN BEZEICHNNGSFELDER EINTRAGEN
LABEL1.CAPTION = \"COMPUTERNAME:\" + X
LABEL1.CAPTION = LABEL1.CAPTION + \"BENUTZERNAME:\" + X
LABEL5.CAPTION = \"\"
\'VERSCHIEDENE PROZEDUREN AUSFÜHREN
GENINFOSZEIGEN
GETAKKUINF
GETSYSTEMDIRS
GETMMINFO
END SUB
Wird diese Form geladen, so werden als erstes die Beschriftungen in die Bezeichnungsfelder eingetragen. Danach werden verschiedene Prozeduren ausgeführt, von denen jede für einen bestimmten Teil der API - Routinen zuständig ist (GenInfosZeigen: Computer- und Benutzername; GetAkkuInf: Ladezustand des Akkus anzeigen; GetSystemDirs: Systemverzeichnisse ermitteln; GetMMInfo: Multimedia - Informationen ermitteln).
Zuerst zur Prozedur GenInfosZeigen:
AUSGABE = SPACE$(255)
LENGTH = LEN(AUSGABE)
VERWERFEN% = GETCOMPUTERNAME(AUSGABE, LENGTH)
AUSGABE = LEFT$(AUSGABE, LENGTH)
LABEL2.CAPTION = AUSGABE + X
AUSGABE = SPACE$(255)
LENGTH = LEN(AUSGABE)
A% = GETUSERNAME(AUSGABE, LENGTH)
LABEL2.CAPTION = LABEL2.CAPTION + LEFT$(AUSGABE, LENGTH)
Hier wird zuerst die Variable Ausgabe auf 255 Zeichen dimensioniert, d.h. sie hat eine Länge von 255 Zeichen, egal ob nur 10 Zeichen in sie geschrieben werden. Die restlichen Zeichen werden der Einfachheit halber durch Nullen bzw. Leerzeichen ersetzt. Hierauf wird die Länge auf die Länge der Variable Ausgabe gesetzt (in diesem Fall 255). Nun wird die API - Routine GetComputerName aufgerufen. Diese erhält als Übergabewerte zwei Argumente, nämlich den Text (Variable: Ausgabe) und die Länge des Textes (Variable: Length). Damit nun die restlichen Leerzeichen abgeschnitten werden, wird der Befehl "Left" verwendet. Dieser erhält nun ebenfalls zwei Argumente, genau dieselben, die zuvor der API - Routine entnommen wurden. Mit dem Befehl Left werden von der Variable "Ausgabe" soviel Zeichen behalten, wie in der Längenangabe "Length" enthalten sind. Ist Length zum Beispiel 15, so werden 15 Zeichen genommen, der Rest wird abgeschnitten. Nun wird noch die Variable "Ausgabe", die nun genauso viel Zeichen enthält, wie die Information wirklich hat, in das Bezeichnungsfeld eingetragen. Dasselbe geschieht nun mit der API - Routine GetUserName, nur mit dem Unterschied, daß diese Routine den Benutzernamen anstatt des Computer - Namens ausgibt.
Die zweite Prozedur gilt den Akku - Ladestatus - Informationen:
DIM PSTATUS AS SYSTEM_POWER_STATUS
IF GETSYSTEMPOWERSTATUS(PSTATUS) THEN
ELSE
MSGBOX \"FEHLER BEIM ABFRAGEN DES BATTERIESTATUS\"
END IF
LABEL3.CAPTION = \"AC POWER STATUS:\" \'BATTERIESTATUS
SELECT CASE PSTATUS.ACLINESTATUS
CASE 0
.....
Hier wird zu Beginn die Variable pStatus (steht für Power Status) als benutzerdefinierter Datentyp deklariert. Nun folgt eine Überprüfung, ob der Computer Informationen über den Batteriestatus liefert. Tut er dies nicht, so wird eine Fehlermeldung ausgegeben. Hier wurde die API - Routine in eine If - Schleife mit eingebaut. Auch auf diese Art erhält Visual Basic den Wert der API - Routine (bzw. die Werte). Der API - Routine wird nur ein Argument übergeben, nämlich die Variable, in der die Informationen gespeichert werden sollen. Nun wird je nach Wert mit Hilfe einer Case - Auswahlschleife die Information ermittelt und der dazu passende Text ausgegeben. Nun folgen verschiedene Aufrufe, die verschiedene Werte (alle aus dem benutzerdefinierten Datentyp pStatus) ausgelesen. Diese werden dann in die verschiedenen Bezeichnungsfelder geschrieben.
Die Prozedur GetSystemDirs:
\'WINDOWS SYS - VERZEICHNIS ERMITTELN
TEMP$ = SPACE$(255)
LENGTH& = GETSYSTEMDIRECTORY(TEMP$, LEN(TEMP$))
LABEL6.CAPTION = \"WINDOWS SYSTEMVERZEICHNIS: \" + LEFT(TEMP$, LENGTH&)
\'TEMPORÄRES VERZEICHNIS ERMITTELN
TEMP$ = SPACE$(255)
LENGTH& = GETTEMPPATH(LEN(TEMP$), TEMP$)
LABEL6.CAPTION = LABEL6.CAPTION + VBCRLF + \"WINDOWS TEMP - VERZEICHNIS: \" + LEFT(TEMP$, LENGTH&)
Dies ist wiederum eine kurze Prozedur, die nur zwei Aufrufe erfordert. Genau wie bei dem Computernamen wird auch hier die Variable "Temp" (entspricht der Variable "Ausgabe" beim Computernamen) auf die Länge von 255 Zeichen gebracht. Der einzige Unterschied zum Computernamen besteht darin, daß die Länge nicht einzeln als Variable dimensioniert wird. Sie wurde bereits in die API - Funktion mit einbezogen. Ansonsten verläuft der gesamte Aufbau gleich wie bei der ersten Prozedur dieser Form.
Die letzte Prozedur liest aus verschiedenen API - Routinen Informationen zur Multimedia Ausstattung aus.
VERSIONOFMM% = MMSYSTEMGETVERSION
WINOD% = WAVEINGETNUMDEVS \'ANZAHL DER WAVE - IN GERÄTE
WONOD% = WAVEOUTGETNUMDEVS \'ANZAHL DER WAVE - OUT GERÄTE
\'EINTRAGEN
LABEL7.CAPTION = \"VERSION DES MM-SYSTEMS: \" + STR$(VERSIONOFMM%) + VBCRLF
LABEL7.CAPTION = LABEL7.CAPTION + \"ANZAHL DER WAVE-IN GERÄTE: \" + STR$(WINOD%) + VBCRLF
LABEL7.CAPTION = LABEL7.CAPTION + \"ANZAHL DER WAVE-OUT GERÄTE: \" + STR$(WONOD%)
Zuerst wird mit der Routine mmsystemGetVersion die Versionsnummer des Multimedia - Subsystems ausgelesen. Danach werden noch die Anzahl der Wave - In - (Geräte, die Musik aufzeichnen können) und die Anzahl der Wave - Out - (Geräte , die Musik abspielen können) Geräte ausgelesen. Zum Schluß werden diese Informationen noch in diese Form eingetragen. Damit ist auch die Form GenInfo fertig.
Die Form DiffAPI:
Diese Form stellt mehr oder weniger Funktionen zur Verfügung, die auch über die Systemsteuerung einzustellen sind. Unter anderem beinhaltet sie eine Möglichkeit zum Einstellen der Doppelklickgeschwindigkeit. Diese Form ist nicht dazu da, wirklich zum Nutzen meines Programmes beizutragen. Diese Form ist eher als Darstellung der verschiedenen Möglichkeiten, die mit API - Funktionen möglich sind, zu sehen. Sie beinhaltet im wesentlichen drei Teile: Der erste Teil dient dem Einstellen der Doppelklickgeschwindigkeit. Dazu gehört auch, daß der aktuelle Wert zunächst ausgelesen wird. Dies geschieht bereits beim ersten Öffnen der Form. Außerdem werden hier auch gleich die Werte des Tastaturzeichens ausgelesen (CaretBlinkTime)
\'DOPPELKLICKZEIT UND CARET - BLINKZEIT - INFORMATION HOLEN UND EINTRAGEN
LABEL2.CAPTION = STR$(GETDOUBLECLICKTIME) + \" MS\"
LABEL3.CAPTION = STR$(GETCARETBLINKTIME) + \" MS\"
In das erste Bezeichnungsfeld (Label2) wird über die API - Routine "GetDoubleClickTime" die Doppelklickzeit ausgelesen. Durch den Befehl Str$ wird diese in einen Zeichenfolgen - Datentyp umgewandelt und der Zusatz MS (Millisekunden) wird an den Wert angehängt. Das Selbe geschieht mit dem Tastaturzeichen.
Um die Doppelklickgeschwindigkeit einzustellen, benötigt man eine andere API - Routine: Die zur Get - dazugehörende Set - Anweisung
ANFANG:
NEWDCTIME = INPUTBOX(\"NEUE DOPPELKLICKZEIT EINGEBEN\")
IF ISNUMERIC(NEWDCTIME) = TRUE THEN
NEWDCTIME = CLNG(NEWDCTIME)
XXX& = SETDOUBLECLICKTIME(NEWDCTIME)
STARTPROZ
ELSE \'SONST: FEHLERMELDUNG
MSGBOX (\"BITTE GEBEN SIE EINE GÜLTIGE ZAHL IN MS EIN (STANDARD = 500)\")
GOTO ANFANG
END IF
Gleich zu Beginn wird eine Zeilenmarke eingeführt, an die das Programm im Falle eines Fehlers bei der Ausführung springt. Die neue Doppelklickzeit wird über eine InputBox eingegeben. Nun wird überprüft, ob dies überhaupt eine Zahl ist (IsNumeric). Ist dies der Fall, so wird die Zeit vom Zeichenfolgen - Datentyp in den Datentyp Long umgewandelt (Long = Lange Ganzzahl). Mit Hilfe der Funktion SetDoubleClickTime, der als Argument der Wert der neuen Doppelklickzeit übergeben wird, wird nun die neue Doppelklickzeit eingestellt. Zum Schluß wird noch einmal die Prozedur StartProz aufgerufen, die die Werte neu liest und in der Form neu darstellt. Ist nun aber der eingegebene Wert keine Zahl, so wird eine Fehlermeldung ausgegeben und das Programm springt zum Anfang der Prozedur, es fordert demnach den Benutzer zu einer neuerlichen Eingabe auf.
Um die Blinkgeschwindigkeit der Tastaturcursors einzustellen, wird genau dieselbe Funktion verwendet. Die API - Routine für diese Prozedur lautet SetCaretBlinkTime. Der folgende Code bedarf keiner Erklärung, da eigentlich alles schon in der Prozedur zur Einstellung der Doppelklickgeschwindigkeit beschrieben wurde.
ANFANG:
NEWCBTIME = INPUTBOX(\"NEUE CARET BLINKZEIT EINGEBEN\")
IF ISNUMERIC(NEWCBTIME) = TRUE THEN
NEWCBTIME = CLNG(NEWCBTIME)
XXX& = SETCARETBLINKTIME(NEWCBTIME)
STARTPROZ
ELSE
MSGBOX (\"BITTE GEBEN SIE EINE GÜLTIGE ZAHL IN MS EIN (STANDARD = 500)\")
GOTO ANFANG
END IF
Der nächste Teil, der dem Einstellen der Mauscursor - Koordinaten dient, ist nicht viel komplexer, allerdings wird hier ein benutzerdefinierter Datentyp verwendet, der den X - Wert (horizontal) und den Y - Wert beinhaltet. Im Gegenteil zu den beiden vorhergehenden Funktionen werden die angezeigten Werte nicht nur einmal aktualisiert, sondern bei jeder Bewegung der Maus über der Form.
DIM LPPOINT AS POINTAPI
D& = GETCURSORPOS(LPPOINT)
KOOX = STR$(LPPOINT.X)
KOOY = STR$(LPPOINT.Y)
LABEL1.CAPTION = \"AKTUELLE X - KOORDINATE DES MAUSZEIGERS \" + KOOX + \" PIXEL\" + VBCRLF
LABEL1.CAPTION = LABEL1.CAPTION + \"AKTUELLE Y - KOORDINATE DES MAUSZEIGERS \" + KOOY + \" PIXEL\"
Zuerst wird die Variable lpPoint als benutzerdefinierter Datentyp dimensioniert. Mit der Funktion GetCursorPos werden die aktuellen Werte in die Variable lpPoint eingetragen. Nun werden die einzelnen Werte aus der Variable ausgelesen, umgewandelt, formatiert und in die Form eingetragen.
Um die Werte zu setzen wird die API - Routine SetCursorPos verwendet.
ON ERROR GOTO ENDE
DIM XPOS AS LONG
DIM YPOS AS LONG
XPOS = CLNG(INPUTBOX(\"BITTE GEBEN SIE DIE X - KOORDIANTE EIN:\"))
YPOS = CLNG(INPUTBOX(\"BITTE GEBEN SIE DIE Y - KOORDIANTE EIN:\"))
IF ISNUMERIC(XPOS AND YPOS) = TRUE THEN
XXX& = SETCURSORPOS(XPOS, YPOS)
ELSE
MSGBOX (\"FEHLER!!!!!!!!!!!!!!!!\")
END IF
ENDE:
Hier wird eine Sprungmarke eingesetzt, um bei einem Fehler zu einem anderen Teil des Programms zu verzweigen. Hierauf werden die X - und Y - Koordinaten als Long - Datentyp dimensioniert. In zwei Eingabekästchen wird der Benutzer aufgefordert die gewünschten Variablen einzugeben. Es folgt eine Gültigkeitsüberprüfung mit dem Verknüpfungsoperator AND. Sind nun beide eine gültige Zahl, so wird das Programm normal fortgesetzt und die API - Routine SetCursorPos kann aufgerufen werden (als Argumente werden ihr der X - und der Y - Wert übergeben). Ist dies nicht der Fall, so wird dieser Teil einfach ausgelassen und es geschieht nichts, außer daß eine Fehlermeldung ausgegeben wird.
Die Form LWInfo:
Diese Form ist wohl die komplexeste Form innerhalb meiner Programmes. Obwohl nur drei API - Routinen vorkommen, ist sie sehr komplex, da verschiedene Werte miteinander verknüpft werden.
Der gesamte Code dieser Form befindet sich in einer einzelnen Prozedur, die aufgerufen wird, sobald die Form geladen wird.
DIM PFAD AS STRING
DIM DRIVETYP AS STRING
DIM DISKNAME AS STRING
DIM T AS STRING
LET X = VBCRLF
PFAD = LEFT$(UEBERGEBEL, 1) + \":\\\"
RESL& = GETDISKFREESPACE(PFAD$, LPSECTORPERCLUSTER&, LPBYTESPERSECTOR&, LPNUMBEROFFREECLUSTERS&, LPTOTALNUMBEROFCLUSTERS&)
IF RESL& = 0 THEN
L_INFO = \"FEHLER - - - - LAUFWERK NICHT BEREIT\"
EXIT SUB
END IF
BPC& = LPSECTORPERCLUSTER& * LPBYTESPERSECTOR&
PROZ! = LPNUMBEROFFREECLUSTERS& / LPTOTALNUMBEROFCLUSTERS&
,LAUFWERKSTYP ERMITTELN
SELECT CASE GETDRIVETYPE(PFAD)
CASE DRIVE_REMOVEABLE
DRIVETYP$ = \"AUSTAUSCHBARE WECHSELPLATTE\"
CASE DRIVE_FIXED
DRIVETYP$ = \"FESTPLATTENLAUFWERK\"
CASE DRIVE_REMOTE
DRIVETYP$ = \"NETZWERKLAUFWERK\"
CASE DRIVE_CDROM
DRIVETYP$ = \"CD - ROM (ISO 9660/JOLIET/DVD)\"
CASE DRIVE_RAMDISK
DRIVETYP = \"RAM - DISK - LAUFWERK\"
CASE ELSE
DRIVETYP$ = \"UNBEKANNT - ANDERER TYP\"
END SELECT
,LAUFWERKSNAMEN ERMITTELN
DISKNAME$ = STRING$(100, 32)
FILESYSTEMNAME$ = DISKNAME$
RESL& = GETVOLUMEINFORMATION(PFAD, DISKNAME$, LEN(DISKNAME$), SERIENNR&, MAXIMUMCOMPONENTLENGTH&, FILESYSTEMFLAGS&, FILESYSTEMNAME$, LEN(FILESYSTEMNAME$))
\'NAMEN KAPPEN
DISKNAME$ = LEFT$(DISKNAME$, INSTR(DISKNAME$, CHR$(0)) - 1)
FILESYSTEMNAME$ = LEFT$(FILESYSTEMNAME$, INSTR(FILESYSTEMNAME$, CHR$(0)) - 1)
\'DATEISYSTEM FLAGS AUSWERTEN
\'UNICODE?
IF FILESYSTEMFLAGS& AND FILE_UNICODE_ON_DISK THEN
FILESYSTEMNAME$ = FILESYSTEMNAME$ + \" (UNICODE)\"
END IF
\'KOMPRIMIERT?
IF FILESYSTEMFLAGS& AND FILE_VOLUME_IS_COMPRESSED THEN
FILESYSTEMNAME$ = FILESYSTEMNAME$ + \" (KOMPRIMIERT)\"
END IF
\'VERSION
VERSIONX$ = STR(GETVERSION&)
\'EINTRAGEN DER INFORMATIONEN IN DIE RECHTE SEITE
T = DISKNAME + X
T = T + STR$(SERIENNR&) + X
T = T + FORMAT$(FILESYSTEMNAME$, \"#,0\") + X
T = T + DRIVETYP$ + X + X
T = T + FORMAT$(LPTOTALNUMBEROFCLUSTERS& * BPC&, \"#,0\") + X
T = T + FORMAT$(LPTOTALNUMBEROFCLUSTERS& * BPC& / 1024, \"#,0\") + X
T = T + FORMAT$(LPTOTALNUMBEROFCLUSTERS& * BPC& / 1048576, \"#,0\") + X
T = T + FORMAT$((LPTOTALNUMBEROFCLUSTERS& - LPNUMBEROFFREECLUSTERS&) * BPC&, \"#,0\") + X
T = T + FORMAT$(LPNUMBEROFFREECLUSTERS& * BPC&, \"#,0\") + X + X
T = T + FORMAT$(LPTOTALNUMBEROFCLUSTERS&, \"#,0\") + X
T = T + FORMAT$(LPTOTALNUMBEROFCLUSTERS& - LPNUMBEROFFREECLUSTERS&, \"#,0\") + X
T = T + FORMAT$(LPNUMBEROFFREECLUSTERS&, \"#,0\") + X + X
T = T + FORMAT$(LPSECTORPERCLUSTER&) + X
T = T + FORMAT$(LPBYTESPERSECTOR&, \"#,0\") + X
T = T + FORMAT$(BPC&, \"#,0\") + X
L_INFO.CAPTION = T
Zu Beginn dieser Prozedur werden verschiedene Variablen dimensioniert, in welchen später die verschiedenen Werte abgelegt werden. Beim Aufruf der Form aus der Form DateiInfo wird der Form LWInfo auch ein Laufwerksbuchstabe mitgeteilt, der hier global übergeben wird (Variable "uebergebel"). Um diesen zu vervollständigen, werden noch ein Doppelpunkt und ein verkehrter Schrägstrich angehängt (\\). Somit "weiß" das Programm nun, welches Laufwerk untersucht werden soll. Nun wird die erste API - Routine aufgerufen, der als Argument der Laufwerksbuchstabe (Pfad$) übergeben wird. Die Variablen die sie von der Funktion übernimmt werden in den Variablen lpSectorPerCluster (Sektoren pro Cluster), lpBytesPerSector (Anzahl der Bytes pro Sektor), lpNumberOfFreeClusters (Anzahl der freien Cluster) und lpTotalNumberOfClusters (Gesamtanzahl der Cluster - Einheiten) gespeichert. Es folgt eine Überprüfung, ob der Aufruf gültig war - ansonsten wird eine Fehlermeldung ausgegeben.
Es werden nun die Anzahl der Sektoren / Cluster mit der Anzahl der Bytes /Sektoren multipliziert, um die Anzahl der Bytes / Sektor zu ermitteln. Um eine Prozentanzahl zu erhalten, wird nun die Anzahl der Freien Cluster durch die Anzahl der gesamten Cluster dividiert. Mit Hilfe der API - Routine GetDriveType, der das Laufwerk als Argument übergeben wird, wird der Laufwerkstyp ermittelt (Festplatte, Diskettenlaufwerk, CD-ROM).
Um den Laufwerksnamen und ähnliche Informationen zu ermitteln, wird die dritte Routine benötigt. Sie lautet GetVolumeInformation und gibt als Rückgabewerte den Namen des Laufwerks (und die Länge des Namens), die Seriennummer, Dateisystem - Flags (also Bytes, die verschiedene Eigenschaften der Dateisystems identifizieren), und den Dateisystem - Namen (ebenfalls die Länge) zurück.
Um einen String in passender Länge für das Dateisystem und den Namen zu erhalten, werden diese Variablen nun gekappt. Es werden genau soviel Zeichen verwendet, wie der Rückgabewert liefert (VB Funktion Left$()). Hierauf werden die Dateisystem - Flags "dekodiert". Je nachdem, was für ein Wert zurückgegeben wird, wird entweder der String UNICODE (egal, ob Gross- oder Kleinschreibung) oder komprimiert an den Dateisystem - String angehängt. Die Version wird schlußendlich mit einer kleinen API - Routine namens GetVersion() ermittelt. Schlußendlich werden noch die gesammelten Informationen formatiert (Format$) in das rechte Bezeichnungsfeld eingetragen. Das "X" ersetzt hierbei einen Zeilenschub (vbCrLf).
Das Modul Modul1.bas
Dieses Modul beinhaltet sämtliche API - Aufrufe, die für mein Programm von Bedeutung sind. Ich stelle an dieser Stelle nur zwei vor, die sich in ihrem Aufruf etwas voneinander unterscheiden. Auch beinhaltet dieses Modul die Typdefinitionen. All diese Informationen können direkt aus dem Microsoft API - Katalog kopiert werden. Dieser beinhaltet alle verfügbaren API - Routinen und Typdefinitionen.
\'LAUFWERKSBELEGUNG
DECLARE FUNCTION GETDISKFREESPACE LIB \"KERNEL32\" ALIAS \"GETDISKFREESPACEA\" (BYVAL LPROOTPATHNAME AS STRING, LPSECTORPERCLUSTER AS LONG, LPBYTESPERSECTOR AS LONG, LPNUMBEROFFREECLUSTERS AS LONG, LPTOTALNUMBEROFCLUSTERS AS LONG) AS LONG
Diese Funktion wird im Programm benötigt, um den Speicherplatz zu ermitteln. Mit der Variable lpRootPathName wird dem Programm mitgeteilt, welches Laufwerk untersucht wird. Diese Variable muss angegeben werden. Die restlichen Namen liefern Informationen wie z.B.: die Anzahl der Sektoren pro Cluster, die Anzahl der Bytes pro Sektor, die Anzahl der freien Cluster und die Anzahl der gesamten Cluster. Mit der Hilfe dieser Funktion kann die Größe der Festplatte oder anderer Laufwerken angegeben werden.
\'SYSTEM POWER STATUS - STROMRESSOURCEN
DECLARE FUNCTION GETSYSTEMPOWERSTATUS LIB \"KERNEL32\" (LPSYSTEMPOWERSTATUS AS SYSTEM_POWER_STATUS) AS LONG
Diese Funktion ermittelt die Akku - Informationen und speichert sie in der als SYSTEM_POWER_STATUS deklarierten Variable lpSystemPowerStatus.
|
