[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]
LLMEMO.INT

 { ---------------------------------------------------------------- }
 {                      LOW-LEVEL-MEMO-ROUTINEN                     }
 { ---------------------------------------------------------------- }
 { Erm.glicht die Bearbeitung von Memo-Dateien nach dBase- und      }
 { Clipper-Norm (*.DBT).                                            }
 { Es werden (prozedurale) Routinen zum .ffnen, Erzeugen und        }
 { Schlie.en von Memodateien, zum Lesen, .berschreiben und Anh.ngen }
 { von Memos und einige Verwaltungsprozeduren zur Verf.gung ge-     }
 { stellt.                                                          }
 { ---------------------------------------------------------------- }
 { Eine der gr..ten Schw.chen der Verwaltung von Memos nach dem     }
 { dBase-Standard ist, da. bei .nderungen einfach der neue Text an  }
 { das Ende der Datei angeh.ngt wird, die alten Versionen bleiben   }
 { aber weiter bestehen und bl.hen die DBT-Datei immer weiter auf.  }
 { Leider wurde von den dBase-Entwicklern dieses Problem vernach-   }
 { l.ssigt und es ist daher ein Packen nur unter Zugriff auf die    }
 { entsprechende DBF-Datei m.glich.                                 }
 { Enstprechend findet sich die "Pack"-Funktion f.r Memo-Dateien    }
 { erst im n.chsth.hereren Level (Unit "TDB").                      }
 { ---------------------------------------------------------------- }
 {       (c)  1992  by  Aurora  featuring  M.J. Schwaiger           }
 { ---------------------------------------------------------------- }

 UNIT LLMemo; { Low-Level-Memo }

 INTERFACE


   USES
     AStrTool,                 { Aurora's Stringbearbeitungsroutinen }

     DbTypes,                              { Globale Typdefinitionen }
     Idle,                                    { Anti-Absturz-Anzeige }
     Error,                              { Fehlerbehandlungsroutinen }
     AStrings,                                { STRINGS-Compatiblity }
 {$IFDEF Windows}
     Strings,                    { Null-terminated-Strings (PChar's) }
     WinAdd,                          { Windows-Kompatibilit.ts-Unit }
     WinDOS;                                 { Windows-DOS-Routinen }
 {$ELSE}
     DOS;                                        { DOS-DOS-Routinen }
 {$ENDIF}


   TYPE

 { ---------------------------------------------------------------- }
 { Definition eines Records f.r die Kenndaten einer Datenbank.      }
 { Beinhaltet neben dem Dateizeiger ein Flag, das anzeigt, ob die   }
 { (Memo-) Datei .berhaupt ge.ffnet ist.                            }
 { ---------------------------------------------------------------- }
 { Dieser (Pointer auf einen) Record charakterisiert eine Memo-     }
 { Datei und mu. bei jedem Zugriff angegeben werden.                }
 { ---------------------------------------------------------------- }

     PMemo          = ^TMemo;
     TMemo          = RECORD
       Opened       : BOOLEAN;               { .berhaupt ge.ffnet ? }
       Datei        : FILE;
       DateiName    : PATHSTR;
       FirstFree    : LONGINT;
     END; { RECORD TMemo }


 { ---------------------------------------------------------------- }
 {                     EIGENTLICHE MEMOFUNKTIONEN                   }
 { ---------------------------------------------------------------- }

 { ---------------------------------------------------------------- }
 { Bei allen Memooperationen wird zuerst gepr.ft, ob die Memo-Datei }
 { .berhaupt ge.ffnet ist (via MemoUse oder MemoCreate).            }
 { Sollte das nicht der Fall sein, so wird der Fehler Nummer 30     }
 { gesetzt.                                                         }
 { ---------------------------------------------------------------- }
 { Wird versucht, eine Funktion zu verwenden, die einen Datenbank-  }
 { Inhalt voraussetzt (MemoReplace, MemoRead usw.), die Anzahl      }
 { der S.tze jedoch 0 sein, so wird Fehler 16 gesetzt.              }
 { ---------------------------------------------------------------- }

 { ---------------------------------------------------------------- }
 { .ffnet die mit "Name" angegebene Memo-Datei zur genehmen Verwen- }
 { dung. Es werden die Kenndaten in den Record f^ geschrieben, wo   }
 { sie in der Zukunft als Identifikation f.r die Memo-Datei dienen. }
 { ---------------------------------------------------------------- }
 { Sollte die angegebene Datei nicht vorhanden sein, so wird Fehler }
 { 32 gesetzt, sollte der Header nicht stimmen, Fehler 33.          }
 { ---------------------------------------------------------------- }

   PROCEDURE MemoUse (F : PMemo; Name : PATHSTR);


 { ---------------------------------------------------------------- }
 { Erzeugt eine neue Memo-Datei mit dem angegebenen Namen. Sollte   }
 { dabei ein Pfad angegeben worden sein, so wird das angegebene     }
 { Verzeichnis verwendet, sonst das aktuelle.                       }
 { Sollte beim Namen keine Endung (vulgo Extension) angegeben sein, }
 { so wird defaultm..ig ".DBT" verwendet.                           }
 { ---------------------------------------------------------------- }
 { Sollte eine gleichnamige Datei bereits vorhanden sein, so wird   }
 { Fehler 6 gesetzt, wenn das Laufwerk nicht beschreibbar ist, 7    }
 { und wenn zu wenig Platz ist, 8.                                  }
 { ---------------------------------------------------------------- }

   PROCEDURE MemoCreate  (F : PMemo; Name : PATHSTR);


 { ---------------------------------------------------------------- }
 { Schlie.t die Memo-Datei wieder.                                  }
 { ---------------------------------------------------------------- }

   PROCEDURE MemoClose (F : PMemo);


 { ---------------------------------------------------------------- }
 { Liest aus dem angegebenen Memo-Satz den Text und gibt ihn als    }
 { PChar (!) zur.ck.                                                }
 { ---------------------------------------------------------------- }

   FUNCTION MemoRead (F : PMemo; Satz : TSatzNr) : PChar;


 { ---------------------------------------------------------------- }
 { H.ngt einen Satz (= Text) an die Memo-Datei an und schreibt den  }
 { Header neu. Zur.ckgeliefert wird die Nummer des ersten vom Text  }
 { belegten Blockes, die in das entsprechende Feld der DBF-Datei    }
 { eingetragen werden mu..                                          }
 { ---------------------------------------------------------------- }
 { Sollte auf dem Datentr.ger zu wenig Platz sein, so wird Fehler   }
 { 12 gesetzt.                                                      }
 { ---------------------------------------------------------------- }

   FUNCTION MemoAppend (F : PMemo; Txt : PChar) : TSatzNr;


 { ---------------------------------------------------------------- }
 { Ersetzt den Text des angegebenen Satzes durch den angegebenen    }
 { Text. Das ganze ist ein ziemlich problematisches Verfahren, das  }
 { nur bei kleineren Text.nderungen funktioniert, dort aber eine    }
 { sehr gro.e Speicherersparnis bringen kann.                       }
 { Zuerst wird .berpr.ft, ob die Gr..e des alten Blockes ausreicht, }
 { um den neuen Text aufzunehmen. Sollte sich die Sache ausgehen,   }
 { so wird .berschrieben und True zur.ckgegeben, sonst ist der      }
 { R.ckgabewert False.                                              }
 { ---------------------------------------------------------------- }

   FUNCTION MemoReplace (F : PMemo; Satz : TSatzNr; Txt : PChar) :
                                                             BOOLEAN;


 { ---------------------------------------------------------------- }
 { Gibt die Anzahl der Bl.cke (!) zur.ck. Diese hat nichts (oder    }
 { zumindest wenig) mit der Anzahl der gespeicherten Texte zu tun.  }
 { ---------------------------------------------------------------- }

   FUNCTION MemoCount (F : PMemo) : LONGINT;


 { ---------------------------------------------------------------- }
 {               D I V .   H I L F S R O U T I N E N                }
 { ---------------------------------------------------------------- }

 { ---------------------------------------------------------------- }
 { Initialisiert eine neue Memo-Variable: Reservieren des           }
 { ben.tigten Heaps, Inhalt l.schen, "Opened"-Flag auf False setzen.}
 { ---------------------------------------------------------------- }
 { Diese Funktion sollte sicherheitshalber immer vor Verwendung     }
 { einer Memovariable (sprich: vor dem .ffnen !) angewendet werden. }
 { ---------------------------------------------------------------- }

   FUNCTION NewMemo : PMemo

This page created by ng2html v1.05, the Norton guide to HTML conversion utility. Written by Dave Pearson