#include #include #include /*----------------------------------------------------------------------*\ Einige Hinweise: Alle Funktionen der HotHelp-Library greifen intensiv auf DOS-Funktionen zurück, weshalb sie nur von Prozessen, nicht jedoch von Tasks aus benutzt werden dürfen. Dies gilt für ALLE Funktionen der Library; sollte eine Funktion im Augenblick keine DOS-Funktionen ausführen, so kann sich das in einer späteren Version der Library durchaus ändern! Weiterhin muß darauf geachtet werden, daß jeder Prozeß, der die Library verwenden will, diese selbst öffnen und auch selbst wieder schließen muß - der Austausch der Library-Base zwischen verschiedenen Prozessen ist nicht erlaubt! Wird diese Regel nicht beachtet, kann es zu Speicherplatzverlusten kommen. Bei der üblichen Art der Programmierung (Öffnen der Library im Hauptprogramm, Aufruf ihrer Funktionen während des Programms und Schließen der Library am Programmende) sind diese beiden Auflagen automatisch erfüllt. Sie sollten lediglich beachtet werden, wenn ein komplexeres Programm über 'AddTask ()', 'CreateProc ()' oder verwandte Funktionen eigene Sub-Tasks oder -Prozesse erzeugt. Der Autor liebt sprechende Namen (wie z.B. 'HH_FLAG_SHOW_ABSOLUT_LAST'). Ist Ihnen das zu untypisch für die Sprache C, können Sie die Flags auch gerne umbenennen (z.B. in 'HHFSAL')... Es existieren bisher zwei Versionen der Library: 2 und 3. Eine der beiden Zahlen muß beim Öffnen der Library über 'OpenLibrary ()' angegeben werden; die aktuelle Versionsnummer liegt als HH_VERSION vor. Alle neuen Features sind durch die Kennung V3 gekennzeichnet; sollen sie verwendet werden, muß die Library auch mit dieser Versions-Nummer angefordert werden. Dadurch wird sichergestellt, daß keine alte Library-Version angesprochen werden kann. Die Funktions-Prototypen und #pragmas sind für die Kompilierung unter Manx-Aztec-C 5.0 erstellt worden. Manx-Compiler mit niedrigerer Versions-Nummer unterstützen weder die angegebenen Prototypen noch die #pragmas, die zum direkten Aufruf einer Library-Funktion ohne Umweg über eine Stub-Routine dienen. Bei Verwendung eines solchen Compilers müssen bei den Funktions-Deklarationen alle Angaben innerhalb der Klammern entfernt werden und die #pragmas müssen entfernt oder auf Kommentar gesetzt werden. Statt dessen muß die Datei 'HotHelpGlue.asm' übersetzt und zu dem entsprechenden Programm hinzugebunden werden (sie enthält Assembler-Funktionen, die die Verbindung zwischen dem C-Programm und der Library herstellen und kann zusammen mit den Beispielprogrammen installiert werden). Benutzer anderer Sprachen müssen auf die FD-Datei zurückgreifen, die die Library-Schnittstellen in standardisierter Form beschreibt. Bei Ihrem Compiler sollten Sie auch ein Tool finden, mit dessen Hilfe eine solche FD-Datei in für den entsprechenden Compiler verständlichen Code übersetzt werden kann (beim Aztec-C-Compiler übernimmt dies ein Programm mit dem Namen 'MapFD'). Wenden Sie sich dafür ggf. an den Hersteller Ihres Compilers. Falls Sie nicht über die OS 2.0-Includes (speziell die Datei 'Utility/TagItem.h') verfügen, sollten Sie die folgenden Zeilen aus dem Kommentar herausnehmen. Sie definieren die verwendete TagItem-Struktur und die von HotHelp unterstützten Standard-Tags. struct TagItem { ULONG ti_Tag; ULONG ti_Data; }; #define TAG_DONE (0L) #define TAG_END TAG_DONE #define TAG_IGNORE (1L) #define TAG_MORE (2L) #define TAG_SKIP (3L) #define TAG_USER (1L<<31) Als Alternative zu 'HH_ShowHelpTagList ()' kann noch die folgende Funktion verwendet werden, bei der die Tags und die zugehörigen Werte direkt über den Stapel übergeben werden können. Übernehmen Sie diese Funktion in Ihre Programme, wenn Sie sich das umständliche Füllen einer Liste von TagItems sparen wollen. LONG HH_ShowHelpTags ( struct HH_NewWindow * hh_new, Tag tag1, ... ) { return (HH_ShowHelpTagList (hh_new, (struct TagItem *) &tag1)); } // HH_ShowHelpTags () \*----------------------------------------------------------------------*/ LONG HH_AddProject (BYTE *, BYTE *, LONG); LONG HH_EasyHelp (BYTE *, BYTE *, struct Screen *, struct Window *, BOOL, BOOL); LONG HH_FontVersion (VOID); LONG HH_OpenAll (LONG); LONG HH_ShowHelp (struct HH_NewWindow *); /* Die folgenden Funktionen sind neu in V3! */ VOID HH_AddHandler (struct Interrupt *); LONG HH_ASyncActivate (LONG); LONG HH_ASyncCheckWindow (LONG); LONG HH_ASyncCloseWindow (LONG); LONG HH_ASyncCustomText (LONG, struct HH_CustomText *, BYTE *, BYTE *); LONG HH_ASyncGadget (LONG, LONG); LONG HH_ASyncMenu (LONG, WORD, WORD); LONG HH_ASyncPage (LONG, LONG); LONG HH_ASyncScroll (LONG, LONG, LONG); LONG HH_ASyncSearch (LONG, BYTE *, UWORD); LONG HH_ASyncStatus (LONG, struct HH_Status *); LONG HH_ASyncStrGadget (LONG, BYTE *, BYTE *, BYTE *, BYTE *, BOOL, WORD); LONG HH_ASyncWindowAddr (LONG, struct Window **); VOID HH_Beep (struct Screen *); BOOL HH_CheckPattern (BYTE *, BYTE *); BOOL HH_CheckProject (BYTE *); BOOL HH_CreatePath (BYTE *, struct DiskObject *); LONG HH_EasyASyncHelp (BYTE *, BYTE *, struct Screen *, struct Window *, BOOL, BOOL); BOOL HH_FileRequest (struct Window *, BYTE *, BYTE *, BYTE *, BYTE *, UWORD); LONG HH_KeyList (BYTE *, struct List *); LONG HH_ProjectList (struct List *); VOID HH_RemHandler (struct Interrupt *); LONG HH_Request (struct Window *, WORD, BYTE *, BYTE *, BYTE *, BOOL, BOOL); BOOL HH_ScanPalette (struct Screen *, struct Rectangle *); LONG HH_Semprini (VOID); VOID HH_SetPointer (struct Window *, LONG); LONG HH_ShowHelpTagList (struct HH_NewWindow *, struct TagItem *); BOOL HH_StrCmp (BYTE *, BYTE *); BOOL HH_StrNCmp (BYTE *, BYTE *); UBYTE HH_ToUpper (UBYTE); LONG HH_Translate (struct HH_TranslateData *, struct HH_CustomText *); VOID HH_TranslateFree (struct HH_TranslateData *); struct Menu * HH_BuildMenus (struct NewMenu *, struct Remember **, struct Screen *, struct TextFont *, BOOL *, BOOL); #pragma amicall(HotHelpBase, 0x3c, HH_AddProject(a0,a1,d0)) #pragma amicall(HotHelpBase, 0x42, HH_EasyHelp(a0,a1,a2,a3,d0,d1)) #pragma amicall(HotHelpBase, 0x48, HH_FontVersion()) #pragma amicall(HotHelpBase, 0x4e, HH_OpenAll(d0)) #pragma amicall(HotHelpBase, 0x54, HH_ShowHelp(a0)) /* Die folgenden Funktionen sind neu in V3! */ #pragma amicall(HotHelpBase, 0x5a, HH_AddHandler(a0)) #pragma amicall(HotHelpBase, 0x60, HH_ASyncActivate(d0)) #pragma amicall(HotHelpBase, 0x66, HH_ASyncCheckWindow(d0)) #pragma amicall(HotHelpBase, 0x6c, HH_ASyncCloseWindow(d0)) #pragma amicall(HotHelpBase, 0x72, HH_ASyncCustomText(d0,a0,a1,a2)) #pragma amicall(HotHelpBase, 0x78, HH_ASyncGadget(d0,d1)) #pragma amicall(HotHelpBase, 0x7e, HH_ASyncMenu(d0,d1,d2)) #pragma amicall(HotHelpBase, 0x84, HH_ASyncPage(d0,d1)) #pragma amicall(HotHelpBase, 0x8a, HH_ASyncScroll(d0,d1,d2)) #pragma amicall(HotHelpBase, 0x90, HH_ASyncSearch(d0,a0,d1)) #pragma amicall(HotHelpBase, 0x96, HH_ASyncStatus(d0,a0)) #pragma amicall(HotHelpBase, 0x9c, HH_ASyncStrGadget(d0,a0,a1,a2,a3,d1,d2)) #pragma amicall(HotHelpBase, 0xa2, HH_ASyncWindowAddr(d0,a0)) #pragma amicall(HotHelpBase, 0xa8, HH_Beep(a0)) #pragma amicall(HotHelpBase, 0xae, HH_BuildMenus(a0,a1,a2,a3,d0,d1)) #pragma amicall(HotHelpBase, 0xb4, HH_CheckPattern(a0,a1)) #pragma amicall(HotHelpBase, 0xba, HH_CheckProject(a0)) #pragma amicall(HotHelpBase, 0xc0, HH_CreatePath(a0,a1)) #pragma amicall(HotHelpBase, 0xc6, HH_EasyASyncHelp(a0,a1,a2,a3,d0,d1)) #pragma amicall(HotHelpBase, 0xcc, HH_FileRequest(a0,a1,a2,a3,d0,d1)) #pragma amicall(HotHelpBase, 0xd2, HH_KeyList(a0,a1)) #pragma amicall(HotHelpBase, 0xd8, HH_ProjectList(a0)) #pragma amicall(HotHelpBase, 0xde, HH_RemHandler(a0)) #pragma amicall(HotHelpBase, 0xe4, HH_Request(a0,d0,a1,a2,a3,d1,d2)) #pragma amicall(HotHelpBase, 0xea, HH_ScanPalette(a0,a1)) #pragma amicall(HotHelpBase, 0xf0, HH_Semprini()) #pragma amicall(HotHelpBase, 0xf6, HH_SetPointer(a0,d0)) #pragma amicall(HotHelpBase, 0xfc, HH_ShowHelpTagList(a0,a1)) #pragma amicall(HotHelpBase, 0x102, HH_StrCmp(a0,a1)) #pragma amicall(HotHelpBase, 0x108, HH_StrNCmp(a0,a1)) #pragma amicall(HotHelpBase, 0x10e, HH_ToUpper(d0)) #pragma amicall(HotHelpBase, 0x114, HH_Translate(a0,a1)) #pragma amicall(HotHelpBase, 0x11a, HH_TranslateFree(a0)) struct HotHelpBase { struct Library hh_Lib; BPTR hh_SegList; }; /*----------------------------------------------------------------------*\ Der Name und die Nummer der aktuellen Library-Version. Bisher existieren die folgenden Versionen (in Klammern die Versionsnummer für 'OpenLibrary ()'): 2.00 (2) - die erste veröffentlichte Version 3.00 (3) - die aktuelle Version Werden Features (Funktionen, Flags) verwendet, die erst in neueren Library-Versionen unterstützt werden, muß beim Öffnen der Library auch die korrekte Versionsnummer angegeben werden. HH_VERSION gibt immer die Nummer der aktuellsten Version an - und sollte daher auch nur verwendet werden, wenn spezielle Möglichkeiten dieser neuesten Version angesprochen werden! \*----------------------------------------------------------------------*/ #define HH_NAME "hothelp.library" #define HH_VERSION 3 /*----------------------------------------------------------------------*\ Diese Konstanten geben die maximale Länge für Schlüssel-, Projekt-, Projektpfad-, Such-, Titel- und ARexxkommando-Strings sowie Icon-Namen an. Hinter dem String muß noch ein Platz für ein abschließendes '\0'-Byte bleiben, so daß Schlüssel z.B. maximal 49 Zeichen lang sein dürfen. Werden Schlüssel- oder Projekt-Namen bzw. Such-Texte oder Titel von außen an die Library übergeben, müssen diese Begrenzungen beachtet werden, da die Library keine Überprüfung vornimmt! Zu lange Strings können daher dazu führen, daß Speicher unkontrolliert überschrieben wird! Die Maximal-Länge für Schlüssel ist auch für Querverweise verbindlich (ein Querverweis, der länger ist als jeder mögliche Schlüssel, wäre nicht besonders sinnvoll...). \*----------------------------------------------------------------------*/ #define HH_KEY_LEN 50 #define HH_PROJECT_LEN 30 #define HH_SEARCH_LEN 30 #define HH_TITLE_LEN 120 #define HH_AREXX_LEN 100 #define HH_ICON_LEN 100 /*----------------------------------------------------------------------*\ Die verschiedenen Fehlercodes, die von HotHelp-Funktionen zurückgeliefert werden können. HH_ERROR_NONE: Alles klar! HH_ERROR_ALREADY_OPEN: Kann nur von 'HH_OpenAll ()' zurückgegeben werden, falls die Ressourcen bereits geöffnet wurden. Kein Grund zur Sorge; irgend- jemand anderes war lediglich etwas schneller als wir... HH_ERROR_ALREADY_LOADED: Ein Projekt, das gelesen werden sollte, war bereits geladen. Kann nur bei einem expliziten Aufruf von 'HH_AddProject ()' zurückgegeben werden. HH_ERROR_DISABLED: Ein Projekt, das gelesen werden sollte, ist ausgeschaltet und der 'force'-Parameter wurde nicht angegeben. Kann nur bei einem expliziten Aufruf von 'HH_AddProject ()' auftreten. HH_ERROR_WINDOW_CLOSED: Ein asynchrones Fenster, das von außen manipuliert werden sollte, existierte zu diesem Zeitpunkt bereits nicht mehr. Kann nur von den entsprechenden Funktionen, die Anweisungen an asynchrone Fenster senden, erzeugt werden. HH_ERROR_INACTIVE: Ein Gadget oder Menüpunkt eines asynchronen HotHelp-Fensters, der von außen manipuliert werden sollte, ist deaktviert (ghosted) und kann nicht ausgewählt werden. HH_ERROR_FONT: Ein gewünschter Font ließ sich nicht öffnen. HH_ERROR_HEADERFILE: Eine Header-Datei konnte nicht geöffnet oder gelesen werden. HH_ERROR_SCAN_PROJECTS: Beim Durchsuchen des Verzeichnisses 'HOTHELP:Projekte' kam es zu einem Fehler; evtl. existiert das Verzeichnis auch gar nicht. HH_ERROR_VERSION: Eine Datei liegt in der falschen Version vor. HH_ERROR_INTUITION_LIB: Die Intuition-Library konnte nicht geöffnet werden (wer läßt da dieses Programm unter Kick 1.1 laufen?). HH_ERROR_GFX_LIB: Dasselbe für die Graphics-Library. HH_ERROR_DISKFONT_LIB: Noch Fragen? HH_ERROR_WINDOW: Das Window ging nicht auf. Das klingt doch stark nach Speicherplatzmangel... HH_ERROR_MEM: Und hier ist er, der Speicherplatzmangel! HH_ERROR_NAME_TOO_LONG: Ein Projekt-Name + zugehörigem Pfad war zu lang. Sollte eigentlich nur bei 'HH_AddProject ()' auftreten können... HH_ERROR_SCREEN: Der gewünschte Screen wurde nicht gefunden oder ist kleiner als die kleinstmögliche Größe des HotHelp-Fensters. Diese Fehlermeldung tritt auch auf, wenn der angeforderte Public Screen (V3) nicht existiert. HH_ERROR_CONSOLE: Das Console.Device konnte nicht geöffnet werden. HH_ERROR_HANDLER: Die Datei 'L:HotHelpHandler' konnte nicht geladen werden. HH_ERROR_CREATEPROC: Der zur Verwaltung eines asynchronen Fensters notwendige Prozess konnte nicht gestartet werden. HH_ERROR_PORT: Beim Anlegen eines MessagePorts trat ein Fehler auf. HH_ERROR_STRUCT: Dieser Fehler tritt auf, wenn eine verwendete HH_Data- bzw. HH_Export-Struktur nicht in der korrekten Versionsnummer vorliegt. HH_ERROR_ICON_LIB: Die Icon-Library konnte nicht geöffnet werden. HH_ERROR_PARENT_CLOSED: Ein HotHelp-Fenster wurde mit Angabe einer ungültigen Window- bzw. Screen-Adresse geöffnet (Optionen 'Parent_Window' bzw. 'Parent_Screen'). Tritt ein Fehler auf, so informiert HotHelp den User davon selbständig. Dies ist insbesondere bei irgendwelchen Datei-Fehlern sinnvoll, da HotHelp den Datei-Namen kennt und auch mit ausgibt. Von außen ließe sich nur eine 'Irgendeine Datei fehlerhaft'-Fehlermeldung erstellen, die dem User wohl kaum weiterhelfen dürfte. Fehler mit einem Wert kleiner als 10 sind eigentlich gar keine, werden auch nicht als solche ausgegeben und können ignoriert werden, da sie lediglich eine Art Rückmeldung für den Aufrufer darstellen. Die Fehler von 10 bis 19 sind Datei-Fehler (bei der Angabe der Fehlerart wird noch der Name der betroffenen Datei ausgegeben). Alle Fehler darüber sind allgemeine Fehler. In späteren Versionen werden evtl. noch weitere Fehlercodes hinzugefügt; also Vorsicht! \*----------------------------------------------------------------------*/ #define HH_ERROR_NONE 0 #define HH_ERROR_ALREADY_OPEN 1 #define HH_ERROR_ALREADY_LOADED 2 #define HH_ERROR_DISABLED 3 #define HH_ERROR_WINDOW_CLOSED 4 /* Neu in V3 */ #define HH_ERROR_INACTIVE 5 /* Neu in V3 */ #define HH_ERROR_FONT 10 #define HH_ERROR_HEADERFILE 11 #define HH_ERROR_SCAN_PROJECTS 12 #define HH_ERROR_VERSION 13 #define HH_ERROR_INTUITION_LIB 20 #define HH_ERROR_GFX_LIB 21 #define HH_ERROR_DISKFONT_LIB 22 #define HH_ERROR_WINDOW 23 #define HH_ERROR_MEM 24 #define HH_ERROR_NAME_TOO_LONG 25 #define HH_ERROR_SCREEN 26 #define HH_ERROR_CONSOLE 27 #define HH_ERROR_HANDLER 28 /* Neu in V3 */ #define HH_ERROR_CREATEPROC 29 /* Neu in V3 */ #define HH_ERROR_PORT 30 /* Neu in V3 */ #define HH_ERROR_STRUCT 31 /* Neu in V3 */ #define HH_ERROR_ICON_LIB 32 /* Neu in V3 */ #define HH_ERROR_PARENT_CLOSED 33 /* Neu in V3 */ /* Diese (falsch geschriebenen) Konstanten wurden in Version 2.0 definiert und sollten nun nicht mehr verwendet werden... */ #define HH_ERROR_ALLREADY_OPEN HH_ERROR_ALREADY_OPEN #define HH_ERROR_ALLREADY_LOADED HH_ERROR_ALREADY_LOADED /*----------------------------------------------------------------------*\ Optionen Normalerweise werden für HotHelp-Fenster die internen bzw. die über HotHelpPref editierbaren Voreinstellungen benutzt. Sollen eigene Einstellungen verwendet werden, so können diese den entsprechenden Library-Funktionen übermittelt werden. Eine Ausnahme hiervon stellen nur die EasyHelp-Funktionen dar, bei denen ausdrücklich die globalen Voreinstellungen Verwendung finden. Unter V2 der Library mußten die von den Default-Werten abweichenden Voreinstellungen in Form einer HH_NewWindow-Struktur übergeben werden, in die die Werte für die einzelnen Einstellungen eingetragen wurden. Ein Wert von -1 (bzw. NULL bei Zeigern) signalisierte dabei, daß die Default-Einstellung verwendet werden sollte. Auch wenn nur eine einzige Einstellung geändert werden sollte, mußte dennoch eine komplette Struktur ausgefüllt werden, die dann überwiegend aus den Werten -1 und NULL bestand. Ab V3 der Library ist es auch möglich, mit TagListen zu arbeiten. Dort werden lediglich die Optionen angegeben, die auch mit speziellen Werten versehen werden sollen. Nicht angegebene Optionen werden dann von HotHelp durch ihre in HotHelpPref eingestellten Default-Werte ersetzt. Eine TagList kann auch zusätzlich zu einer HH_NewWindow-Struktur angegeben werden; auf diese Weise können alte Programme leicht an die neue Library angepaßt werden: der alte Code, der die Struktur ausfüllt, kann erhalten bleiben und lediglich die neuen Features werden über Tags angesprochen. Wird eine TagList zusammen mit einer HH_NewWindow-Struktur angegeben, wird zuerst die Struktur ausgewertet, bevor die TagList untersucht wird - durch die TagList können also die Optionen in der Struktur überschrieben werden. Einige Variablen aus der HH_NewWindow-Struktur werden ab V3 in einer eigenen Struktur mit dem Namen HH_Data zusammengefaßt, die über das Tag 'DataStruct' angegeben werden kann. Diese Struktur beinhaltet alle Daten, die beim Öffnen von mehreren HotHelp-Fenstern nacheinander erhalten bleiben sollen - so z.B. die Position und Größe des Fensters. Alle anderen Variablen der HH_NewWindow-Struktur, die lediglich das aktuelle Fenster beeinflußen sollen, wurden zu TagItems. Ebenso ausgelagert wurden die Variablen, die einen ausgeschnittenen Textblock beschreiben - sie befinden sich jetzt in der HH_Export-Struktur, die über die 'ExportStruct'-Option angegeben werden kann. Wird eine HH_NewWindow-Struktur zusammem mit einer HH_Data- und/oder HH_Export-Struktur verwendet, so werden die entsprechenden Daten (Position, Größe etc. bzw. exportierte Daten) jeweils in beiden Strukturen festgehalten. Die neue Library unterstützt zwar noch die alte Methode des Aufrufs über die HH_NewWindow-Struktur; diese Struktur wird aber nicht mehr erweitert, so daß neue Features (Asynchrone Fenster, Suchflags, Public Screens etc.) nur über die neuen Funktionen mit TagListen angesprochen werden können. Eine komplette Beschreibung aller unterstützten Optionen finden Sie in der gleichnamigen Datei. \*----------------------------------------------------------------------*/ #define HHT_ASyncWindow (TAG_USER+ 1) #define HHT_CheckAll (TAG_USER+ 2) #define HHT_CloseCut (TAG_USER+ 3) #define HHT_ColorActiView (TAG_USER+ 4) #define HHT_ColorDark (TAG_USER+ 5) #define HHT_ColorLight (TAG_USER+ 6) #define HHT_ColorReference (TAG_USER+ 7) #define HHT_ColorText (TAG_USER+ 8) #define HHT_DataStruct (TAG_USER+ 9) #define HHT_DefaultFont (TAG_USER+10) #define HHT_ExportStruct (TAG_USER+11) #define HHT_FastFont (TAG_USER+12) #define HHT_FontName (TAG_USER+13) #define HHT_FontSize (TAG_USER+14) #define HHT_Forget (TAG_USER+15) #define HHT_GadgetMask (TAG_USER+16) #define HHT_ID (TAG_USER+17) #define HHT_Key (TAG_USER+18) #define HHT_KeyGroup (TAG_USER+19) #define HHT_KeyLayout (TAG_USER+20) #define HHT_KeyTab (TAG_USER+21) #define HHT_MaxHeight (TAG_USER+22) #define HHT_MaxWidth (TAG_USER+23) #define HHT_MenuPort (TAG_USER+24) #define HHT_MenuText (TAG_USER+25) #define HHT_NoActivation (TAG_USER+26) #define HHT_Notification (TAG_USER+27) #define HHT_ParentScreen (TAG_USER+28) #define HHT_ParentWindow (TAG_USER+29) #define HHT_PosAbsolutLast (TAG_USER+30) #define HHT_PrintTitle (TAG_USER+31) #define HHT_Priority (TAG_USER+32) #define HHT_Project (TAG_USER+33) #define HHT_PubScreen (TAG_USER+34) #define HHT_Quiet (TAG_USER+35) #define HHT_RamIcon (TAG_USER+36) #define HHT_ScreenToFront (TAG_USER+37) #define HHT_ScrollDelay (TAG_USER+38) #define HHT_ScrollSpeed (TAG_USER+39) #define HHT_SearchAll (TAG_USER+40) #define HHT_SearchBack (TAG_USER+41) #define HHT_SearchIgnore (TAG_USER+42) #define HHT_SearchReference (TAG_USER+43) #define HHT_SearchArea (TAG_USER+44) #define HHT_ShowAbsolutLast (TAG_USER+45) #define HHT_ShowLast (TAG_USER+46) #define HHT_ShowStart (TAG_USER+47) #define HHT_SmartColors (TAG_USER+48) #define HHT_SmartFont (TAG_USER+49) #define HHT_SpecialText (TAG_USER+50) #define HHT_StackSize (TAG_USER+51) #define HHT_StdNumPad (TAG_USER+52) #define HHT_UseRamIcon (TAG_USER+53) /*----------------------------------------------------------------------*\ struct HH_NewWindow Ähnlich wie Intuitions NewWindow-Struktur enthält auch die HH_NewWindow-Struktur alle Informationen, die zum Öffnen eines HotHelp-Fensters benötigt werden. Die meisten Variablen dienen lediglich dazu, die in HotHelpPref vorgenommenen Voreinstellungen zu variieren. Werden diese Variablen mit einem Default-Wert (meist -1) geladen, wird der entsprechende Voreinstellungs-Wert übernommen. In der Regel genügt es daher, die HH_NewWindow-Struktur wie folgt zu vereinbaren: HH_FLAG_POS_ABSOLUT_LAST, // flags -1, -1, // x, y -1, -1, // width, height -1, -1, // max_width, max_height "", // project "", // key NULL, // stack NULL, // open_screen NULL, // open_window -1, // dummy -1, // stack_size -1, // gadget_mask -1, -1, -1, -1, // colors NULL, 0, // font_name, font_size -1, -1, // scroll_delay, scroll_speed -1, -1, // key_tab, key_layout -1, // print_title -1, // close_cut -1, // search_area Lediglich für 'project' und 'key' sollten noch die gewünschten Start- Strings eingetragen werden. Ab V3 der Library können diese Einstellungen auch über eine TagListe verändert werden, so daß auf das Ausfüllen einer kompletten HH_NewWindow-Struktur verzichtet werden kann. Die neuen Optionen (wie asynchrone Fenster, Public Screens, Einstellung der Suchflags etc.) können nur über die entsprechenden TagItems geändert werden, da die starre HH_NewWindow-Struktur Erweiterungen dieser Art nicht unterstützt. Eine Erläuterung der einzelnen Optionen finden Sie in der gleichnamigen Datei. flags: Es existieren lediglich 8 Flags für diese Variable. Aus Kompatibilitäts-Gründen sollten die restlichen Bits alle auf 0 gesetzt werden. Die Font-Flags dürfen nicht gemeinsam gesetzt sein; die Ergebnisse wären im besten Falle undefiniert... Dasselbe gilt auch für die Show-Flags. HH_FLAG_FASTFONT: Siehe Option 'FastFont'. HH_FLAG_DEFAULTFONT: Siehe Option 'DefaultFont'. HH_FLAG_QUIET: Siehe Option 'Quiet'. HH_FLAG_SHOW_START: Siehe Option 'ShowStart'. HH_FLAG_SHOW_LAST: Siehe Option 'ShowLast'. HH_FLAG_SHOW_ABSOLUT_LAST: Siehe Option 'ShowAbsolutLast'. HH_FLAG_POS_ABSOLUT_LAST: Siehe Option 'PosAbsolutLast'. HH_FLAG_FORGET: Siehe Option 'Forget'. Das Flag wirkt wie die Kombination von 'HH_FORGET_POS' und 'HH_FORGET_TEXT'. x, y, width, height: Siehe Beschreibung der 'HH_Data'-Struktur. max_width, max_height: Siehe Optionen 'MaxWidth' und 'MaxHeight'. project, key: Siehe 'Project'- und 'Key'-Optionen. stack: Siehe Beschreibung der 'HH_Data'-Struktur. open_screen, open_window: Siehe 'ParentScreen'- und 'ParentWindow'-Optionen. Wird für 'open_window' ein Wert angegeben, wird 'open_screen' ignoriert. Nur wenn 'open_window' NULL ist, verwendet HotHelp die 'open_screen'-Variable. dummy: Über diese Variable konnte unter HotHelp-Version 2.00 von einem parallel zum Hauptprogramm ablaufenden Task auf ein geöffnetes HotHelp-Fenster zugegriffen werden. Unter Version 3.00 ist dies nicht mehr nötig, da jetzt auch asynchrone Fenster angeboten werden, die über Standard-Funktionen angesprochen werden können. Die Möglichkeit, auch synchrone Fenster auf diese Weise anzusprechen, wird zwar aus Kompatibilitäts-Gründen weiterhin unterstützt; da sie aber inzwischen überflüssig sein sollte, wird hier nicht mehr weiter darauf eingegangen. stack_size: Siehe Option 'StackSize'. Ein Wert von -1 übernimmt die Voreinstellung. gadget_mask: Siehe Option 'GadgetMask'. colors [4]: Siehe Optionen 'ColorText', 'ColorLight', 'ColorDark' und 'ColorReference', die in dieser Reihenfolge den vier Feldelementen entsprechen. Werte von -1 übernehmen die Voreinstellungen. font_name, font_size: Siehe Optionen 'FontName' und 'FontSize'. Ist 'font_name' NULL oder verweist auf einen Leerstring und ist keines der beiden Font-Flags gesetzt, wird der in HotHelpPref voreingestellte Zeichensatz benutzt. scroll_delay, scroll_speed: Siehe 'ScrollDelay'- und 'ScrollSpeed'-Optionen. Werte von -1 übernehmen die Voreinstellung. key_tab: Siehe Option 'KeyTab'. Ein Wert von -1 übernimmt die Voreinstellung. key_layout: Siehe Option 'KeyLayOut'. Ein Wert von -1 übernimmt die Voreinstellung. print_title: Siehe Option 'PrintTitle'. Ein Wert von -1 übernimmt die Voreinstellung. close_cut: Siehe Option 'CloseCut'. Ein Wert von -1 übernimmt die Voreinstellung. search_area: Siehe Option 'SearchArea'. Ein Wert von -1 übernimmt die Voreinstellung. cut_filled, cut_type: Siehe Beschreibung der 'HH_Export'-Struktur. Die folgenden Variablen dürfen nur ausgelesen werden, wenn die verwendete Funktion keinen Fehlercode zurückgeliefert hat. reserved: Reservierter Bereich, der ignoriert werden kann (bzw. muß). \*----------------------------------------------------------------------*/ struct HH_NewWindow { UWORD flags; WORD x; WORD y; WORD width; WORD height; WORD max_width; WORD max_height; BYTE project [HH_PROJECT_LEN]; BYTE key [HH_KEY_LEN]; struct Stack * stack; struct Screen * open_screen; struct Window * open_window; LONG dummy; LONG stack_size; ULONG gadget_mask; BYTE colors [4]; BYTE * font_name; UBYTE font_size; BYTE scroll_delay; BYTE scroll_speed; WORD key_tab; BYTE key_layout; BYTE print_title; BYTE close_cut; BYTE search_area; BYTE cut_filled; BYTE cut_type; union { BYTE ram_file [40]; struct { struct Remember * remember; BYTE * text_buffer; LONG numb_chars; } special; } cut_data; LONG reserved [25]; }; /*----------------------------------------------------------------------*\ Die Flags für die 'flags'-Variable der 'HH_NewWindow'-Struktur. \*----------------------------------------------------------------------*/ #define HH_FLAG_FASTFONT 0x0001 #define HH_FLAG_DEFAULTFONT 0x0002 #define HH_FLAG_QUIET 0x0004 #define HH_FLAG_SHOW_START 0x0008 #define HH_FLAG_SHOW_LAST 0x0010 #define HH_FLAG_SHOW_ABSOLUT_LAST 0x0020 #define HH_FLAG_POS_ABSOLUT_LAST 0x0040 #define HH_FLAG_FORGET 0x0080 /*----------------------------------------------------------------------*\ struct HH_Data Diese Struktur wird ab Library-Version V3 aus der HH_NewWindow-Struktur herausgelöst. Sie beinhaltet Angaben, die beim Öffnen mehrerer Fenster nacheinander erhalten bleiben sollen, wie Größe und Position, Suchtexte und Sucheinstellungen, Textmarken, zuletzt gesehene Einträge etc. Unter Library-Version V2 wurden diese Daten mit den Optionen und den Export-Variablen zusammen in der HH_NewWindow-Struktur zusammengefaßt. Da diese Struktur in V3 aber durch die Verwendung von TagItems überflüssig geworden ist, wurden die Variablen in einer eigenen Struktur zusammengefaßt. Sollen die oben genannten Angaben beim Schließen und Neu-Öffnen eines HotHelp-Fensters über die neuen Funktionen (V3) nicht verloren gehen, dann muß vor dem ersten Öffnen eine HH_Data-Struktur angelegt und korrekt initalisiert werden und dann bei jedem Öffnen über das 'DataStruct'-Tag an HotHelp übergeben werden. Die Library hält dann beim Schließen des ersten Fensters die entsprechenden Daten in dieser Struktur fest und kann beim nächsten Öffnen eines Fensters über dieselbe Struktur die Daten wieder auslesen. version: Bevor die Struktur an eine HotHelp-Funktion übergeben wird, muß hier die aktuelle Library-Version (HH_VERSION) eingetragen werden. Auf diese Weise kann die Struktur in späteren Versionen der Library einfach erweitert werden, ohne zu alten Programmen inkompatibel zu werden. Da die Struktur erst ab V3 der Library zur Verfügung steht, darf hier als niedrigster Wert '3' eingetragen werden. Ein falscher Wert führt zum Fehler HH_ERROR_STRUCT! x, y, width, height: Die X- und Y-Koordinaten, Breite und Höhe des gewünschten Fensters. Hat eine der Variablen den Wert -1, wird der entsprechende Wert aus den Voreinstellungen übernommen. Dies gilt auch, wenn ALLE vier Variablen auf 0 gesetzt werden - dadurch muß eine global angelegte Struktur lediglich noch mit der Versions-Nummer gefüllt werden; die Zuweisung von -1 an die vier Variablen kann entfallen. Bevor die Variablen verwendet werden, werden sie zuerst überprüft; ggf. wird das Fenster dann mit den korrigierten Variablen geöffnet, falls die Anforderungen nicht mit den Ausmaßen des gewünschten Screens in Einklang zu bringen sind. HotHelp versucht dabei, die geforderten Fensterkoordinaten beizubehalten und lediglich die Fenstergröße einzuschränken. Nur wenn das Fenster auch bei Minimal-Größe noch nicht auf den Bildschirm paßt, werden die Koordinaten entsprechend verändert. Die Variablen werden ignoriert, wenn auch die Option 'PosAbsolutLast' angegeben wird. Beim Schließen eines Fensters werden die aktuellen Werte aus der Window-Struktur übernommen und in diesen Variablen abgespeichert. Wird das nächste HotHelp-Fenster dann unter Verwendung derselben HH_Data-Struktur geöffnet, erscheint das Fenster an derselben Position wie das vorhergehende. stack: Dieser Zeiger dient zur Verwaltung interner Informationen und enthält Angaben über die zuletzt gelesenen Einträge, auf die über das Vortext-Gadget wieder zurückgegriffen werden kann. Der Zeiger muß vor dem ersten Aufruf einer HotHelp-Funktion auf NULL gesetzt werden; anschließend darf er nicht mehr geändert werden! Einzige Ausnahme dieser Regel: Falls ein Prozeß nacheinander mehrere synchrone (oder asynchrone mit Notification) HotHelp-Fenster öffnet (also: 1. Fenster öffnen; warten, bis es wieder geschlossen wird; 2. Fenster öffnen; warten, bis es geschlossen wird; 3. Fenster öffnen...) und dabei jedesmal eine eigene HH_Data-Struktur benutzen will (aus welchen Gründen auch immer), sollte dieser Wert aus der zuletzt verwendeten Struktur festgehalten und dann in die folgende Struktur übertragen werden; andernfalls würde für jedes Fenster ein neuer Stack angelegt. Der Wert darf erst ausgelesen werden, wenn das entsprechende Fenster geschlossen wurde - dies gilt speziell für asynchrone Fenster mit Notification. \*----------------------------------------------------------------------*/ struct HH_Data { WORD version; WORD x; WORD y; WORD width; WORD height; struct Stack * stack; }; /*----------------------------------------------------------------------*\ struct HH_Export Diese Struktur wird ab Library-Version V3 aus der HH_NewWindow-Struktur herausgelöst. Über die Struktur ist es möglich, Rückmeldungen von HotHelp über exportierte Daten zu erhalten. Dies ist zumindest im Fall eines Exportes über das 'Spezial'-Gadget notwendig, da dabei lediglich der markierte Text an das aufrufende Programm zur weiteren Bearbeitung zurückgegeben wird. Um Informationen über den Export zu erhalten, muß die Adresse dieser Struktur über das 'ExportStruct'-Tag übergeben werden. Bei Verwendung der V2-Funktion 'HH_ShowHelp ()' befinden sich die Variablen innerhalb der HH_NewWindow-Struktur selber und können dort ausgelesen werden. version: Bevor die Struktur an eine HotHelp-Funktion übergeben wird, muß hier die aktuelle Library-Version (HH_VERSION) eingetragen werden. Auf diese Weise kann die Struktur in späteren Versionen der Library einfach erweitert werden, ohne zu alten Programmen inkompatibel zu werden. Da die Struktur erst ab V3 der Library zur Verfügung steht, darf hier als niedrigster Wert '3' eingetragen werden. Ein falscher Wert führt zum Fehler HH_ERROR_STRUCT! cut_filled: Alle Variablen dieser Struktur werden von HotHelp selbst beschrieben. Sie geben Auskunft darüber, ob - und in welcher Form - der User Textteile ausgeschnitten hat. Die folgenden Variablen sind daher nur gültig, wenn 'cut_filled' TRUE ist; ansonsten sind ihre Inhalte undefiniert und können sich während des Aufrufs geändert haben! Sie erhalten außerdem nur Auskunft über das Ausschneiden eines Blockes, wenn das HotHelp-Fenster durch den Ausschneide-Vorgang geschlossen wurde ('CloseCut'-Option). Im Normalfall geschieht dies nur beim Export über das 'Spezial'-Gadget. cut_type: Kann drei verschiedene Werte annehmen: HH_CUT_CLIPBOARD Die ausgeschnittenen Daten wurden vom User im ClipBoard abgelegt. Weitere Informationen sind nicht notwendig. HH_CUT_RAMFILE Der ausgeschnittene Text wurde in einer Datei abgelegt, deren Name aus 'cut_file' hervorgeht. Da nun Export in beliebige Dateien möglich ist (nicht nur in solche im Root der RAM-Disk), wurde der String-Bereich gegenüber dem String in der HH_NewWindow-Struktur erheblich vergrößert. Wenn eine solche Struktur verwendet wird, der Dateiname aber zu lang ist, wird dort ein Leerstring festgehalten. Sicherheitshalber sollten neue Programme daher immer die HH_Export-Struktur benutzen. HH_CUT_SPECIAL Der Text wurde im RAM abgelegt. Ein Zeiger auf den Speicherbereich befindet sich in 'cut_text_buffer', die Anzahl von Zeichen in diesem Speicherbereich geht aus 'cut_numb_chars' hervor. Wird der Speicher nicht mehr benötigt, sollte er über 'FreeRemember (&export.cut_remember, TRUE);' wieder freigegeben werden, da HotHelp sich nicht weiter um diesen Speicherbereich kümmert. \*----------------------------------------------------------------------*/ struct HH_Export { WORD version; BYTE cut_filled; BYTE cut_type; union { BYTE file [300]; struct { struct Remember * remember; BYTE * text_buffer; LONG numb_chars; } special; } cut_data; }; /*----------------------------------------------------------------------*\ Ein paar Abkürzungen, um schneller auf die Einzelteile der Union innerhalb der HH_Export-Struktur zugreifen zu können. \*----------------------------------------------------------------------*/ #define cut_file cut_data.file #define cut_remember cut_data.special.remember #define cut_text_buffer cut_data.special.text_buffer #define cut_numb_chars cut_data.special.numb_chars /*----------------------------------------------------------------------*\ Die drei Cut-Typen für die 'type'-Variable der 'HH_Export'-Struktur. \*----------------------------------------------------------------------*/ #define HH_CUT_SPECIAL 0 #define HH_CUT_CLIPBOARD 1 #define HH_CUT_RAMFILE 2 /*----------------------------------------------------------------------*\ struct HH_MenuMsg Ab V3 besteht die Möglichkeit, ein HotHelp-Fenster um ein zusätzliches Menü zu erweitern (siehe 'MenuText'-Option). Wird ein Punkt eines solchen Menüs vom User ausgewählt, so sendet HotHelp eine Nachricht des Typs 'HH_MenuMsg' an den dafür vorgegebenen Port. WICHTIG: Nachdem die Nachricht vom Port abgeholt und abgearbeitet worden ist, darf sie nicht wie sonst üblich über 'ReplyMsg ()' zurückgeschickt werden! Statt dessen muß sie über 'FreeMem ()' wieder freigegeben werden. Die Größe des freizugebenden Datenblocks (und somit der zweite Parameter für 'FreeMem ()') geht aus 'msg.mn_Length' hervor. Es darf NICHT einfach 'sizeof (struct HH_MenuMsg)' verwendet werden! msg: Die grundlegende Exec-Message, über die die Nachricht später an den Port des Aufrufers geschickt wird. version: Enthält die Versionsnummer der Library, die diese Nachricht verschickt. Die Variable ist für zukünftige Erweiterungen gedacht und kann momentan noch ignoriert werdem. type: Eine Message darf nur dann weiter verwendet werden, wenn diese Variable den Wert HH_TYPE_MENU hat - andernfalls muß sie ignoriert werden. Momentan (V3) haben ALLE Messages diesen Typ; um spätere Erweiterungen zu erleichtern, muß der Typ aber dennoch auch jetzt schon sicherheitshalber überprüft werden. Die folgenden Variablen dürfen dann nur ausgewertet werden, wenn die Überprüfung erfolgreich war. item: Diese Variable gibt an, der wievielte Menüpunkt vom User ausgewählt wurde. Die Zählung beginnt immer bei 1. Ein positiver Wert besagt, daß der User den Menüpunkt angewählt hat. Ab OS 2.0 können auch negative Werte übergeben werden; diese besagen, daß der User über die Help-Taste Hilfe zu dem entsprechenden Punkt angefordert hat. Der Absolutwert der Variablen gibt dann wiederum die Nummer des Menüpunktes selber an. Wird ein Wert von 0 übergeben, so hat der User lediglich das Menü geöffnet, ohne einen Menüpunkt auszuwählen, und dann die Help-Taste gedrückt. Wird ein Wert < 1 übergeben, liegt es beim aufrufenden Programm, einen Hilfstext zu dem entsprechenden Menü bzw. Menüpunkt darzustellen - dies ist über 'HH_ASyncStrGadget ()' ohne weiteres möglich, sofern der Hilfstext in einem Projekt vorliegt - andernfalls kann auch 'HH_ASyncCustomText ()' verwendet werden. \*----------------------------------------------------------------------*/ struct HH_MenuMsg { struct Message msg; WORD version; WORD type; WORD item; }; /*----------------------------------------------------------------------*\ Die möglichen Typen von Menü-Messages. \*----------------------------------------------------------------------*/ #define HH_TYPE_MENU 0 /*----------------------------------------------------------------------*\ struct HH_TranslateData Mit Hilfe dieser Struktur ist es möglich, einen normalen ASCII-Text in das für Handler und die Funktion 'HH_ASyncCustomText ()' benötigte interne HotHelp-Text-Format zu übersetzen. Sie nimmt alle Ein- und Ausgabe-Daten der Funktion 'HH_Translate ()' auf. War die Funktion erfolgreich, so wird der übersetzte Text üblicherweise in eine HH_CustomText-Struktur übertragen und dann an HotHelp übergeben. Dazu müssen 'hh_text', 'hh_text_len' und 'hh_real_len' in die entsprechenden Variablen der anderen Struktur übertragen werden. Bei den Variablen bis einschließlich 'compress' handelt es sich um Eingabe-Variable, die beim Aufruf der Funktion mit sinvollen Werten gefüllt sein müssen. Die danach folgenden Variablen enthalten nach der erfolgreichen (!) Durchführung der Funktion die Ergebnisse der Übersetzung. Nachdem das Ergebnis der Übersetzung komplett ausgewertet wurde, muß die Struktur an 'HH_TranslateFree ()' übergeben werden, wo alle von 'HH_Translate ()' angelegten Speicherbereiche wieder freigegeben werden. Die entsprechenden Pointer der Struktur werden dabei auf NULL zurückgesetzt, so daß sie anschließend nicht mehr verwendet werden dürfen. Die Freigabe muß spätestens am Programmende oder vor der nächsten Benutzung der Struktur erfolgen. version: Bevor die Struktur an eine HotHelp-Funktion übergeben wird, muß hier die aktuelle Library-Version (HH_VERSION) eingetragen werden. Auf diese Weise kann die Struktur in späteren Versionen der Library einfach erweitert werden, ohne zu alten Programmen inkompatibel zu werden. Da die Struktur erst ab V3 der Library zur Verfügung steht, darf hier als niedrigster Wert '3' eingetragen werden. Ein falscher Wert führt zum Fehler HHT_ERROR_STRUCT! ascii_text: Ein Zeiger auf den Speicherbereich mit dem normalen ASCII-Text, der übersetzt werden soll. ascii_text_len: Die Anzahl von Zeichen im Buffer 'ascii_text'. mark_key, mark_ref, mark_style, mark_para: Sollen innerhalb des Textes noch bestimmte Elemente definiert werden (Schlüssel, Querverweise, Schriftarten und Absatzenden), müssen diese durch Marken gekennzeichnet werden (analog zur Vorgehensweise bei der Übersetzung mit HotHelpComp). Über diese Variablen können nun Strings angegeben werden, die als Marken verwendet werden sollen. Wird z.B. 'mark_key' mit dem String "|Key|" initialisiert, so erkennt HotHelp alle Begriffe im ASCII-Text, die mit '|Key|' eingerahmt sind, als Schlüsselnamen an und hält sie im 'keys'-Feld fest. Bei diesem Vergleich werden Groß- und Kleinschreibung unterschieden! Leerstrings werden wie NULL-Pointer interpretiert (s.u.). Außerdem dürfen die Marken nicht mit Blanks oder Tabulatoren beginnen oder enden und auch keinen Zeilenvorschub ('\n') beinhalten. Die Strings gelten (in der Reihenfolge der Variablen) für Schlüssel, normale Querverweise, Schriftarten und Absatzenden. Sollen verschiedene dieser Marken nicht verwendet werden, so kann der entsprechende Zeiger auch mit NULL initialisiert werden. Andere als die genannten Marken können nicht bearbeitet werden. Dies betrifft Projekt- und ARexx-Querverweise, Titel (soll der Text mit einem Titel versehen werden, kann dieser direkt in die HH_CustomText-Struktur eingetragen werden), Gruppen-Titel und -Listen (Gruppen sind Projekt-spezifisch; sie können daher nicht verwendet werden, da so definierte Texte keinem Projekt angehören), Einrückungs-Marken, Eintragsenden (es kann immer nur ein Eintrag übersetzt werden) und Kommentare. Gefundene Marken (die ja nur der Markierung eines anderen Text-Teiles dienen) werden bei der Übersetzung nicht mit übernommen und tauchen im späteren HotHelp-Text nicht mehr auf. Um einen Schlüssel oder einen Querverweis zu definieren, muß der entsprechende Text durch die dafür angegebene Marke umrahmt werden. Eine Schriftart wird angefordert, indem hinter der Schriftart-Marke eine Zahl zwischen 0 und 7 angegeben wird (entspricht der Reihenfolge in HotHelpComp: Normal, Unterstrichen, Fett, Fett + Unterstrichen, Kursiv, Kursiv + Unterstrichen, Fett + Kursiv + Unterstrichen). Eine Absatzende-Marke kennzeichnet das Ende des aktuellen Absatzes. Die Definition von Schlüsseln im Text hat auf diesen keine besonderen Auswirkungen; es werden lediglich die Namen aller gefundenen Schlüssel gesammelt und dann im Feld 'keys' abgelegt. Dies ist im wesentlichen sinnvoll, wenn vom Benutzer ein Text eingegeben wurde, der bereits den Schlüsselbegriff beinhaltet, unter dem er von einem Handler verwaltet werden soll. In diesem Fall können der oder die Schlüssel nach der Übersetzung direkt aus dem Feld entnommen werden; eine weitere Untersuchung des Quelltextes durch den Handler selber entfällt damit. Die Absatzende-Marke hat großen Einfluß auf die Art der Übersetzung: Wird hierfür ein String angegeben, geht HotHelp bei der Übersetzung davon aus, daß der Quelltext in einem bestimmten Format vorliegt. Wie auch bei der Übersetzung mit HotHelpComp werden alle aufeinanderfolgenden Zeilen zu einem Absatz zusammengefaßt, bis entweder ein oder mehrere Leerzeilen oder aber die definierte Absatzende-Marke gefunden werden. Als Leerzeilen gelten sowohl normale Leerzeilen als auch Zeilen, die lediglich Blanks und Tabulatoren enthalten. Die Absatzende-Marke muß sich immer am Ende der Zeile befinden. Diese Art der Übersetzung ist zwar aufwendig, aber auch sinnvoll, da der Text wie üblich in Abhängigkeit von der aktuellen Fensterbreite neu formatiert und optimal ausgegeben werden kann. Problematisch ist dieses Vorgehen lediglich, wenn nicht sichergestellt ist, daß der Quelltext in diesem Format vorliegt. Dies kann z.B. der Fall sein, wenn der Text direkt vom Benutzer angegeben wurde. Wird dabei nicht zwingend vorausgesetzt, daß Absätze durch Leerzeilen getrennt bzw. durch eine Textmarke gekennzeichnet werden, kann es durch das unerwartete Zusammenfassen der Zeilen zu einem einzigen Absatz zu einigen Überraschungen kommen. Um dem vorzubeugen, kann auch NULL übergeben werden. In diesem Fall faßt der Übersetzer keine Zeilen zusammen, sondern übernimmt jede einzelne Zeile als eigenen Absatz - die Zeilenaufteilung entspricht dann bei der späteren Ausgabe in einem HotHelp-Fenster genau der Aufteilung im Quelltext. Der große Nachteil dieser Methode ist jedoch, daß der Text nicht sinnvoll neu formatiert werden kann, wenn das Fenster zu schmal werden sollte. tab_size: Zur korrekten Ermittlung der Einrückungstiefe muß HotHelp die Größe eines Tabulator-Schrittes bekannt sein. Dazu kann in dieser Variablen ein Wert zwischen 1 und 50 angegeben werden. Enthält der Text keine Tabulatoren, wird die Variable ignoriert. compress: Ist diese Variable TRUE, wird der übersetzte Text automatisch komprimiert - Andernfalls wird ein lesbarer Text erzeugt. Kompression ist lediglich sinnvoll, wenn der übersetzte Text längere Zeit beibehalten werden soll (z.B. im Speicher, wenn er öfters dargestellt werden soll, oder auf Disk, wenn er später auch noch benötigt wird). Wird der Text lediglich übersetzt, um ihn direkt anschließend an HotHelp zu übergeben, sollte auf die Kompression verzichtet werden - sie verschlingt dann lediglich kostbare Zeit! hh_text: Diese Variable enthält nach der (erfolgreichen) Übersetzung einen Zeiger auf einen neu allozierten Bereich mit dem übersetzten Text. Im Falle eines Fehlers wird kein Speicher angelegt. hh_text_len, hh_real_len: Falls kein Fehler auftritt, wird in der ersten Variablen die Größe des 'hh_text'-Bereiches festgehalten. Die zweite Variable gibt dann an, wie groß der Text tatsächlich ist. Die beiden Variablen können sich unterscheiden, wenn der Text komprimiert wurde ('hh_real_len' ist dann größer als 'hh_text_len'). keys: Wurden im übersetzten Text Schlüssel gefunden, legt HotHelp in dieser Variablen die Adresse eines Feldes von Zeigern auf Strings ab. Die einzelnen Elemente des Feldes zeigen auf jeweils einen Schlüssel-Namen (in der Reihenfolge des Auftauchens im ASCII-Text). Wurden keine Schlüssel gefunden oder trat ein Fehler auf, enthält die Variable den Wert NULL. numb_keys: Hierin hält HotHelp die Anzahl von gefundenen Schlüssel-Begriffen fest. Dieser Wert gibt somit an, wieviele gültige Elemente das Feld 'keys' hat. error: Im Fall eines Fehlers wird hier die genaue Fehler-Ursache festgehalten. Im Moment können die folgenden Werte auftreten - in späteren Library-Versionen kommen evtl. noch weitere hinzu: HHT_ERROR_NONE: Alles klar, kein Fehler ist aufgetreten. In allen anderen Fällen gibt die 'HH_Translate ()'-Funktion FALSE zurück. HHT_ERROR_STRUCT: Die HHT_Translate-Struktur liegt in der falschen Versions-Nummer vor. HHT_ERROR_EMPTY: Der übergebene Text ist leer. HHT_ERROR_MEM: Es steht nicht mehr genügend freier Speicherplatz zur Verfügung. HHT_ERROR_ODDKEYS: Es wurde eine ungerade Anzahl von Schlüssel-Marken angegeben. HHT_ERROR_STYLE: Hinter einer Style-Marke sind nur die ASCII-Zahlen '0' bis '7' erlaubt. HHT_ERROR_OPENREF: Der aktuelle Querverweis wurde bis zum Ende des Absatzes nicht beendet. HHT_ERROR_OPENKEY: Der aktuelle Schlüssel wurde bis zum Absatzende nicht abgeschlossen. HHT_ERROR_REFLEN: Ein Querverweis ist zu lang. HHT_ERROR_KEYLEN: Ein Schlüssel-Begriff ist zu lang. HHT_ERROR_PARA: Die Absatzende-Marke muß sich grundsätzlich am Zeilenende befinden. HHT_ERROR_LHLIB: Die Lh-Library ist nicht installiert. error_line: Hierin wird die Nummer der Zeile innerhalb des Quelltextes abgelegt, in der der Fehler auftrat. Die Zählung beginnt immer bei 0. Die Variable darf nur verwendet werden, wenn 'error' das Auftreten eines Fehlers anzeigt. Sie hat den Wert -1, wenn der Fehler keiner speziellen Zeile zugeordnet wird. \*----------------------------------------------------------------------*/ struct HH_TranslateData { WORD version; BYTE * ascii_text; LONG ascii_text_len; BYTE * mark_key; BYTE * mark_ref; BYTE * mark_style; BYTE * mark_para; WORD tab_size; BOOL compress; BYTE * hh_text; LONG hh_text_len; LONG hh_real_len; BYTE ** keys; WORD numb_keys; WORD error; WORD error_line; }; /*----------------------------------------------------------------------*\ Die möglichen Fehlerwerte, die bei einer Übersetzung auftreten können. In späteren Versionen können noch weitere Codes hinzukommen. \*----------------------------------------------------------------------*/ #define HHT_ERROR_NONE 0 #define HHT_ERROR_STRUCT 1 #define HHT_ERROR_EMPTY 2 #define HHT_ERROR_MEM 3 #define HHT_ERROR_ODDKEYS 4 #define HHT_ERROR_STYLE 5 #define HHT_ERROR_OPENREF 6 #define HHT_ERROR_OPENKEY 7 #define HHT_ERROR_REFLEN 8 #define HHT_ERROR_KEYLEN 9 #define HHT_ERROR_PARA 10 #define HHT_ERROR_LHLIB 11 /*----------------------------------------------------------------------*\ struct HH_CustomText Soll von einem Handler oder über die Funktion 'HH_ASyncCustomText ()' ein eigener Text in einem HotHelp-Fenster dargestellt werden, so muß er durch eine solche Struktur beschrieben werden. Alle Daten aus der Struktur werden kopiert, so daß sie anschließend wiederverwendet oder freigegeben werden können. Der einfachste Weg, eine solche Struktur zu initialisieren, besteht in einem Aufruf der 'HH_Translate ()'-Funktion, die einen normalen ASCII-Text in eine für HotHelp verständliche Form übersetzt und eine HH_CustomText-Struktur ausfüllen kann. version: Bevor die Struktur an eine HotHelp-Funktion übergeben wird, muß hier die aktuelle Library-Version (HH_VERSION) eingetragen werden. Auf diese Weise kann die Struktur in späteren Versionen der Library einfach erweitert werden, ohne zu alten Programmen inkompatibel zu werden. Da die Struktur erst ab V3 der Library zur Verfügung steht, darf hier als niedrigster Wert '3' eingetragen werden. Ein falscher Wert führt zum Fehler HH_ERROR_STRUCT! project, key: In diesen beiden String-Feldern können der tatsächliche Projekt- und Schlüssel-Name angegeben werden, die für den übergebenen Text gelten sollen. Sie werden benutzt, um die Titelzeile des Fensters aufzubauen. HotHelp gibt dazu zuerst den 'project'-String aus, gefolgt von " / ", gefolgt vom 'key'-String und schließlich ": " und dem 'title'-String. An Stelle eines Leerstrings setzt HotHelp an der entsprechenden Position den Inhalt des Eingabegadgets für den Projekt- bzw. Schlüssel-Namen ein. Deren Inhalt wird durch diese beiden Strings nicht beeinflußt - es dreht sich lediglich um den Inhalt der Titelzeile. Diese Möglichkeit ist insbesondere für einen Handler interessant, der ein Muster übergeben bekommt. Wenn der Handler daraufhin einen konkreten Text zurückliefert, sollte er in diesen beiden Variablen den ausgeschriebenen Projekt- und Schlüssel-Namen ablegen. Der Anwender sieht dann (wie bei einem normalen Text auch), in den beiden String-Gadgets noch das geforderte Muster, während in der Titelzeile Projekt und Schlüssel des aktuellen Textes gezeigt werden. Verfügt der Handler über mehrere passende Texte, so sollte er eine Übersicht aus Querverweisen zurückgeben. In diesem Fall sollte 'project' einen Leerstring beinhalten und in 'key' sollte sich der String 'Schlüssel-Übersicht' befinden. 'title' sollte ebenfalls leer sein. title: Falls der Text über einen speziellen Titel verfügen soll, kann dieser hier angegeben werden - ansonsten muß hier ein Leerstring übergeben werden (title [0] = '\0'). hh_text: Dies ist ein Zeiger auf den Text selber. Dieser muß im für HotHelp-Texte üblichen Format vorliegen (damit ist nicht das von HotHelpComp verwendete Format für Quelltexte gemeint, sondern das interne Format, in das der Compiler die Quelltexte umsetzt!). Ein solcher Text kann entweder über die Funktion 'HH_Translate ()' automatisch aus einem normalen ASCII-Text erzeugt werden; es besteht jedoch auch die Möglichkeit, ihn selber vorzubereiten. Sie finden dazu in der Datei 'TextAufbau' eine ausführliche Beschreibung von HotHelps internem Text-Format. Im Normalfall sollte die 'HH_Translate ()'-Funktion jedoch für alle Anwendungen ausreichend sein. hh_text_len, hh_real_len: Die erste Variable gibt die Größe des Feldes 'hh_text' an, während die zweite Variable die tatsächliche Länge des Textes beschreibt. Im Normalfall müssen beide Variablen mit demselben Wert geladen werden; nur wenn der Text im 'hh_text'-Feld komprimiert ist, hat 'hh_text_len' einen kleineren Wert als 'hh_real_len'. Ist das der Fall, dekomprimiert HotHelp den Text automatisch, bevor er verwendet wird. Im Normalfall (wenn der Text durch 'HH_Translate ()' erzeugt wurde), sollten hier die entsprechenden Werte aus der HH_TranslateData-Struktur eingetragen werden. tab_size: Gibt die Größe jedes Tabulator-Schrittes für diesen Text an. Es dürfen nur Werte zwischen 1 und 50 angegeben werden. \*----------------------------------------------------------------------*/ struct HH_CustomText { WORD version; BYTE project [HH_PROJECT_LEN]; BYTE key [HH_KEY_LEN]; BYTE title [HH_TITLE_LEN]; BYTE * hh_text; LONG hh_text_len; LONG hh_real_len; WORD tab_size; }; /*----------------------------------------------------------------------*\ struct HH_HandlerData Diese Struktur wird nur bei der Programmierung eines eigenen HotHelp-Handlers benötigt. Eine ausführliche Erklärung dieser Handler finden Sie in der gleichnamigen Datei, in der auch die Bedeutung der einzelnen Variablen erklärt wird. Über das Makro 'PAT_MEM (m)' kann die Mindestgröße eines Buffers ermittelt werden, der ein über einen String der Länge 'm' gebildetes Pattern aufnehmen soll. \*----------------------------------------------------------------------*/ #define PAT_MEM(m) ((m) * 4 + 4) struct HH_HandlerData { WORD action; struct List pro_names; BYTE project [PAT_MEM (HH_PROJECT_LEN)]; BYTE key [PAT_MEM (HH_KEY_LEN)]; BOOL pro_pattern; BOOL key_pattern; struct HH_CustomText * custom_text; }; /*----------------------------------------------------------------------*\ Die möglichen Aktionen, die von einem HotHelp-Handler erwartet werden. In Zukunft können noch weitere Aktionen hinzukommen, so daß auf unbekannte Aktionen immer mit einem definierten Rückgabewert (FALSE) reagiert werden sollte. \*----------------------------------------------------------------------*/ #define HHA_PROJECTS 1 #define HHA_KEY 2 #define HHA_PROJECT_START 3 #define HHA_FREE 4 /*----------------------------------------------------------------------*\ struct HH_Project Diese Struktur wird von der Funktion 'HH_ProjectList ()' verwendet, um Informationen über alle aktiven Projekte zurückzugeben. node: Über diese Variable wird die Struktur in eine Liste eingehängt. 'ln_name' enthält einen Zeiger auf 'name'. struct_version: Die Version dieser Struktur. Im Augenblick kann dieser Wert noch ignoriert werden; er ist lediglich für eine eventuelle spätere Erweiterung der Struktur interessant. struct_size: Die Größe dieser Struktur. Wird eine Projekt-Liste über 'HH_ProjectList ()' angefordert, müssen die Listenelemente später vom Aufrufer selber wieder freigegeben werden - HotHelp kümmert sich nicht weiter um den Speicherplatz. Diese Variable gibt nun die Größe des freizugebenden Bereiches jeder einzelnen Struktur an; es darf auf keinen Fall 'sizeof (struct HH_Project)' verwendet werden! name: Der Name des Projektes selber. text_file: Der vollständige Pfadname der Text-Datei des Projektes, die ja über HotHelpPro umbenannt werden kann. version: Dies gibt die Versions-Nummer des Projektes als Dezimalzahl an. Die beiden hinteren Stellen beschreiben die Revision, alle übrigen die Version des Projektes. Im Moment können nur die Zahlen 200 (V 2.00) oder 300 (V 3.00) auftreten. flags: Eine Variable mit Flags. Im Moment sind nur zwei Flags definiert: HHPF_AMIGAGUIDE: Bei diesem Projekt handelt es sich um kein richtiges HotHelp-Projekt, sondern um eine Datei im AmigaGuide-Format, die über das entsprechende Modul von HotHelpPro als HotHelp-Projekt angemeldet wurde. 'version' enthält dann keinen brauchbaren Wert, während die anderen Variablen wie üblich verwendet werden können ('text_file' enthält den Namen der AmigaGuide-Datei, die diesem Projekt zugrunde liegt). HHPF_KEYS_LOADED: Die Schlüssel dieses Projektes liegen bereits im Speicher, von wo sie ggf. über 'HH_RemoveKeys ()' wieder entfernt werden können. userdata: Diese Variable wird von HotHelp nicht verwendet und steht dem Aufrufer für eigene Verwaltungs-Aufgaben zur Verfügung, wenn er die Liste noch weiter bearbeiten möchte. Die Variable wird mit 0 initialisiert. Sie kann z.B. verwendet werden, um eigene Listenelemente von den durch HotHelp angelegten Strukturen abzugrenzen. \*----------------------------------------------------------------------*/ struct HH_Project { struct Node node; WORD struct_version; LONG struct_size; BYTE name [HH_PROJECT_LEN]; BYTE text_file [200 + HH_PROJECT_LEN + 10]; WORD version; UWORD flags; LONG userdata; }; #define HHPF_AMIGAGUIDE 0x0001 #define HHPF_KEYS_LOADED 0x0002 /*----------------------------------------------------------------------*\ struct HH_Key Diese Struktur wird von der Funktion 'HH_KeyList ()' verwendet, um Informationen über alle Schlüssel eines Projektes zurückzugeben. node: Über diese Variable wird die Struktur in eine Liste eingehängt. 'ln_name' enthält einen Zeiger auf 'name'. struct_version: Die Version dieser Struktur. Im Augenblick kann dieser Wert noch ignoriert werden; er ist lediglich für eine eventuelle spätere Erweiterung der Struktur interessant. struct_size: Die Größe dieser Struktur. Wird eine Schlüssel-Liste über 'HH_KeyList ()' angefordert, müssen die Listenelemente später vom Aufrufer selber wieder freigegeben werden - HotHelp kümmert sich nicht weiter um den Speicherplatz. Diese Variable gibt nun die Größe des freizugebenden Bereiches jeder einzelnen Struktur an; es darf auf keinen Fall 'sizeof (struct HH_Key)' verwendet werden! name: Der Name des Schlüssels selber. n_group, groups: Diese beiden Variablen geben an, ob der Schlüssel in ein oder mehreren Gruppen-Listen enthalten ist. 'n_group' gibt die Anzahl von Gruppen an, die den Schlüssel beinhalten; 'groups' zeigt auf ein Feld von entsprechend vielen UBYTEs mit den Nummern der beteiligten Gruppen (die Gruppen werden mit 0 beginnend durchnummeriert). Ist der Schlüssel in keiner Gruppe enthalten, hat 'groups' den Wert NULL. userdata: Diese Variablen wird von HotHelp nicht verwendet und steht dem Aufrufer für eigene Verwaltungs-Aufgaben zur Verfügung, wenn er die Liste noch weiter bearbeiten möchte. Die Variable wird mit 0 initialisiert. Sie kann z.B. verwendet werden, um eigene Listenelemente von den durch HotHelp angelegten Strukturen abzugrenzen. \*----------------------------------------------------------------------*/ struct HH_Key { struct Node node; WORD struct_version; LONG struct_size; BYTE name [HH_KEY_LEN]; UBYTE n_group; UBYTE * groups; LONG userdata; }; /*----------------------------------------------------------------------*\ struct HH_Status Diese Struktur wird von der 'HH_ASyncStatus ()'-Funktion verwendet, um wichtige Daten des angesprochenen HotHelp-Fensters zu ermitteln. pro_gadget, key_gadget: Aus diesen beiden Feldern geht der aktuelle Inhalt des Projekt- und Schlüssel-Gadgets hervor. pro_name, key_name: Diese beiden Strings beinhalten den Projekt- und Schlüssel-Begriff des aktuell dargestellten Textes. Sie unterscheiden sich von den beiden vorherigen Variablen, wenn Patterns verwendet wurden. Befinden sich hier Leerstrings, so gibt es keinen aktuellen Schlüssel. Dies kann z.B. passieren, wenn ein Fehler auftrat (zu dem eingegebenen Schlüssel existiert kein passender Eintrag) oder wenn ein Custom-Text angezeigt wird (z.B. durch einen Handler). win_lines, win_columns: Hier wird die Anzahl von bedruckbaren Zeilen und Spalten im Fenster übergeben. txt_lines, txt_columns: Diese Variablen enthalten die Anzahl von Zeilen und Spalten, die der aktuelle Text umfaßt. Als Spaltenanzahl wird immer die Länge der längsten Zeile im gesamten Text angegeben. first_line, first_column: Die Nummer der ersten im Fenster sichtbaren Zeile und Spalte. Beide Werte werden von 0 an gezählt. \*----------------------------------------------------------------------*/ struct HH_Status { BYTE pro_gadget [HH_PROJECT_LEN]; BYTE key_gadget [HH_KEY_LEN]; BYTE pro_name [HH_PROJECT_LEN]; BYTE key_name [HH_KEY_LEN]; LONG win_lines; LONG win_columns; LONG txt_lines; LONG txt_columns; LONG first_line; LONG first_column; }; /*----------------------------------------------------------------------*\ Die Defines für die 'GadgetMask'-Option. HH_GADGET_KEY - Schlüssel-Gadget HH_GADGET_PROJECTS - Projekt-Gadget HH_GADGET_LEVEL_UP - Kapitel HH_GADGET_PREVIOUS_ITEM - Pfeil links HH_GADGET_CUT_PRINTER - Export: Drucker-Gadget HH_GADGET_CUT_FILE - Export: Datei-Gadget HH_GADGET_CUT_CLIP - Export: ClipBoard-Gadget HH_GADGET_CUT_SPECIAL - Export: Spezial-Gadget HH_GADGET_LAST_ENTRY - Voriger Eintrag HH_GADGET_NEXT_ITEM - Pfeil rechts HH_GADGET_CUT_INIT - Export-Gadget HH_GADGET_CUT_END - Export beenden HH_GADGET_HELP - Hilfs-Gadget, Hilfe zu Gadgets und Menüs über die Help-Taste HH_GADGET_PROJECT_STR - Eingabefeld für das Projekt HH_GADGET_KEY_STR - Eingabefeld für den Schlüssel HH_GADGET_REFERENCE - Ermöglicht die Auswahl von Querverweisen \*----------------------------------------------------------------------*/ #define HH_GADGET_KEY 0x00000001L #define HH_GADGET_PROJECTS 0x00000002L #define HH_GADGET_LEVEL_UP 0x00000004L #define HH_GADGET_PREVIOUS_ITEM 0x00000008L #define HH_GADGET_CUT_PRINTER 0x00000010L #define HH_GADGET_CUT_FILE 0x00000020L #define HH_GADGET_CUT_CLIP 0x00000040L #define HH_GADGET_CUT_SPECIAL 0x00000080L #define HH_GADGET_LAST_ENTRY 0x00000100L #define HH_GADGET_NEXT_ITEM 0x00000200L #define HH_GADGET_CUT_INIT 0x00000400L #define HH_GADGET_CUT_END 0x00000800L #define HH_GADGET_HELP 0x00001000L #define HH_GADGET_PROJECT_STR 0x00002000L #define HH_GADGET_KEY_STR 0x00004000L #define HH_GADGET_REFERENCE 0x00008000L /*----------------------------------------------------------------------*\ Die Defines für die 'Forget'-Option. Die Flags dürfen auch kombiniert werden. HH_FORGET_NONE - Position und Text werden festgehalten. HH_FORGET_POS - Die Position dieses Fensters wird nicht festgehalten. HH_FORGET_TEXT - Der letzte angezeigte Text dieses Fenster wird nicht festgehalten. \*----------------------------------------------------------------------*/ #define HH_FORGET_NONE 0x0000 #define HH_FORGET_POS 0x0001 #define HH_FORGET_TEXT 0x0002 /*----------------------------------------------------------------------*\ Die Rückgabe-Werte von 'HH_FontVersion ()'. HH_FONT_NORMAL: Die installierte HotHelp-Library verfügt nicht über einen eingebauten FastFont. HH_FONT_FAST_8: Es ist eine Library mit eingebautem FastFont (Topaz 8) installiert. \*----------------------------------------------------------------------*/ #define HH_FONT_NORMAL 0 #define HH_FONT_FAST_8 1 /*----------------------------------------------------------------------*\ Mit Hilfe dieser Werte können die Such-Parameter der Funktion 'HH_ASyncSearch ()' festgelegt werden. \*----------------------------------------------------------------------*/ #define HH_SEARCH_IGNORE 0x0001 #define HH_SEARCH_BACKWARD 0x0002 #define HH_SEARCH_ALL 0x0004 /*----------------------------------------------------------------------*\ Die Parameter für 'HH_SetPointer ()'. HHP_SLEEP: Ändert den Pointer in eine Stoppuhr um, die durch Programme wie PointerX und ähnliche auch animiert werden kann. Ab OS 3.0 wird der System-Busy-Pointer verwendet. HHP_HELP: Setzt einen Help-Pointer, der signalisiert, daß beim Anklicken eines Bildschirmbereiches Hilfe dazu dargestellt wird. \*----------------------------------------------------------------------*/ #define HHP_SLEEP 0 #define HHP_HELP 1 /*----------------------------------------------------------------------*\ Die Flag-Bits für 'HH_FileRequest ()': HHFR_SAVEMODE: Durch dieses Flag kann unterschieden werden, ob der Requester zum Laden oder zum Speichern verwendet werden soll. Dies hat z.B. Einfluß auf die Hintergrund- und Textfarbe. HHFR_DRAWERSONLY: Wird dieses Flag gesetzt, so ermöglicht der File-Requester lediglich die Auswahl eines Verzeichnisses, jedoch nicht den Namen einer Datei. Ist es gelöscht, wird wie üblich ein Verzeichnis- und Dateiname erfragt. HHFR_BLOCKWINDOW: Wenn dieses Flag gesetzt ist und wenn bei 'window' ein Fenster angegeben wurde, dann blockiert die Funktion dieses Fenster automatisch, bis der Requester wieder geschlossen wird. Der User kann dann in dem angegebenen Fenster weder Gadgets noch Menüs betätigen. \*----------------------------------------------------------------------*/ #define HHFR_SAVEMODE 0x0001 #define HHFR_DRAWERSONLY 0x0002 #define HHFR_BLOCKWINDOW 0x0004 /*----------------------------------------------------------------------*\ Die Nachrichten-IDs für 'HH_Request ()'. \*----------------------------------------------------------------------*/ #define HH_MSG_DEFAULT -1 #define HH_MSG_INFO 0 #define HH_MSG_DISK 1 #define HH_MSG_DELETE 2 #define HH_MSG_GURU 3 #define HH_MSG_RWERROR 4 #define HH_MSG_WPROTECT 5 #define HH_MSG_PRINTER 6 #define HH_MSG_QUESTION 7 #define HH_MSG_EXCLAM 8 /*----------------------------------------------------------------------*\ Die folgenden Daten sind privat und nur der Vollständigkeit halber hier aufgelistet. Sie dürfen NICHT verwendet werden! "I tell you this is private. The data beyond this point has changed, is changing, and will continue to change." \*----------------------------------------------------------------------*/ #ifdef HH_PRIVATE BOOL HH_AskStdShortcuts (BYTE *, WORD); VOID HH_ASyncMain (struct HandlerStartMsg *); VOID HH_Catalog (VOID); struct Pref * HH_ExportPrefs (VOID); BYTE * HH_GetString (WORD); VOID HH_LoadPref (VOID); LONG HH_Lock (VOID); LONG HH_RemoveProject (BYTE *); LONG HH_UnLock (VOID); VOID HH_ExportPrefsNew (struct Pref *, LONG); LONG HH_GetVersion (BPTR); BYTE HH_CountIndent (BYTE **, WORD); BOOL HH_SavePref (struct Pref *, LONG); BOOL HH_StartTool (LONG, BYTE *, BOOL, WORD, WORD, BYTE *); VOID HH_LockHotHelp (VOID); BOOL HH_RemoveKeys (BYTE *); BOOL HH_CheckProjectNew (struct HH_Project *); VOID HH_FreeCompErrors (struct List *); VOID HH_AddCompError (BYTE *, LONG, LONG, BYTE *); struct List * HH_GetCompErrors (VOID); #pragma amicall(HotHelpBase, 0x1e, HH_ExportPrefs()) #pragma amicall(HotHelpBase, 0x24, HH_LoadPref()) #pragma amicall(HotHelpBase, 0x2a, HH_Lock()) #pragma amicall(HotHelpBase, 0x30, HH_RemoveProject(a0)) #pragma amicall(HotHelpBase, 0x36, HH_UnLock()) #pragma amicall(HotHelpBase, 0x120, HH_AddCompError(a0,d0,d1,a1)) #pragma amicall(HotHelpBase, 0x126, HH_AskStdShortcuts(a0,d0)) #pragma amicall(HotHelpBase, 0x12c, HH_ASyncMain(a0)) #pragma amicall(HotHelpBase, 0x132, HH_Catalog()) #pragma amicall(HotHelpBase, 0x138, HH_CheckProjectNew(a0)) #pragma amicall(HotHelpBase, 0x13e, HH_CountIndent(a0,d0)) #pragma amicall(HotHelpBase, 0x144, HH_ExportPrefsNew(a0,d0)) #pragma amicall(HotHelpBase, 0x14a, HH_FreeCompErrors(a0)) #pragma amicall(HotHelpBase, 0x150, HH_GetCompErrors()) #pragma amicall(HotHelpBase, 0x156, HH_GetString(d0)) #pragma amicall(HotHelpBase, 0x15c, HH_GetVersion(d0)) #pragma amicall(HotHelpBase, 0x162, HH_LockHotHelp()) #pragma amicall(HotHelpBase, 0x168, HH_RemoveKeys(a0)) #pragma amicall(HotHelpBase, 0x16e, HH_SavePref(a0,d0)) #pragma amicall(HotHelpBase, 0x174, HH_StartTool(d0,a0,d1,d2,d3,a1)) #define HH_ERROR_LOCK 200 #define HH_ERROR_UNLOCK 201 #define HH_ERROR_REMOVE 202 #define HH_CUT_PRINTER 3 #endif