#include "Directry.ch"
#include "Xbp.ch"
#include "DelDbe.ch"
#include "Common.ch"
#include "Fileio.ch"


PROCEDURE INEUx( cFunk )      /* cFunk ist f�r spezielle Funktionen, wie z.B. L”schen von Dateien */
* index neu vergeben
LOCAL aDry, nHandle, oDlg
LOCAL aPosT := {}, aSizeT := {}, aPosF := {}, aSizeF := {}, nZeiF := 1, nZeiT := 1
LOCAL lVisible, aCfA, nCfA, cText, CRLF := Chr(13)+Chr(10)
DEFAULT cFunk TO ""

//+25.08.2009 19:35 testet, ob irgendwo im Netz das Programm l„uft:
nHandle := FOpen( cDatver + "HilfeTip.dbf", FO_EXCLUSIVE )
IF nHandle = -1 .AND. AppKeyState(65552)!=1  //+02.04.2013 11:33 Shift nicht gedr�ckt
   //+ eine ScrapX-Version l„uft irgendwo im Netz: Pr�flauf abbrechen
   FClose(nHandle)
   RETURN
ELSE
   FClose(nHandle)
ENDIF

IIf( IsMemVar("oBest") .AND. ValType(oBest)=="O",,oBest := oApp )
IIf( !IsMemVar("cDatver"), cDatver := CurDrive()+":\"+CurDir()+"\", )

//+09.03.2010 11:12 Test:  ++++++++++++++++++++++++++++++++++++++++++++++
IF IsMemVar("oBest") .AND. ValType(oBest)=="O"
ELSE
   cFunk := ""
   DbUseArea(,"DBFNTX",cDatver + "PARAM",,.F.)
   oDlg := AKDialog():new( AppDesktop(), SetAppWindow(), {100,100}, {AppDesktop():currentSize()[1]-200,AppDesktop():currentSize()[2]-200}, , .F.)
   oDlg:title := "Programm-Start mit Pr�flauf -> NICHT unterbrechen !"
   oDlg:CREATE()
   oDlg:show()
   oBest := DialogFF():new( oDlg:drawingArea, oDlg, , ,,, , "s_best", -99, -99, 1 )
   AAdd( oBest:BEArea, oDlg:drawingArea )
   oBest:BENr := Len( oBest:BEArea )
   oBest:CREATE( oDlg:drawingArea, oDlg, , ,,, , "s_best", -99, -99, 1 )
ENDIF
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//      aCfA := { ;
//                {'','T',20,-751,1,0,0,0,20,.F.,'','<Alle',5,1,175,20}, ;
//                {'','T',20,-751,2,0,0,0,20,.F.,'','^meine',5,2,175,20}, ;
//                {'','T',20,-751,3,0,0,0,20,.F.,'','Entchen',5,3,175,20}, ;
//                {'','T',20,-751,4,0,0,0,20,.F.,'','<schwimmen auf dem See',5,4,175,20} ;
//              }
//      cText := aCfA   /* passend gemacht... */

/* aCfA wird bei einfacher Textausgabe nicht gebraucht.
   cText und die Parameter f�r Pos und Size reichen aus (Reihenfolge wie in aCfA) */
      cText := "^P R š F L A U F"      /* ^ist zentriert - <ist linksb�ndig - rechtsb�ndig=Standard!*/
      IIf(cFunk="T",,oBest:TextFenster( , , , , , .T., nBz/2, , , , , cText, 10, 1, 400, 20 ))

/* cText darf auch mehrzeilig sein, dann wird es in ::TextFenster rekursiv aufgesplittet  */
      cText := "" + CRLF + ;  /* f�hrende Leerzeile f�r gr”áeren Anfangsabstand */
               "^Achtung, alle Index-Bereiche werden neu gesetzt !!!" + CRLF +;
               "^W„hrend dieser Zeit darf auf keinem Arbeitsplatz" + CRLF +;
               "^im Programm gearbeitet werden!"                      
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , cText, 10, -1, 400, 20 ))

SELECT 1

      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Bitte warten ..... ich arbeite ......", 10, -2, 400, 20 ))

/* Dateien f�r das ScrapX-Programm:
      PARAM.DBF      -  Parameter des Programms
                        (DBFNTX) - ohne Index, da nur 1 Datensatz
      DRUPAR.DBF     -  Drucker-Parameter des Programms
                        (DBFNTX) - ohne Index, da nur 1 Datensatz
      AK_F_LOG.DBF   -  Fehler-Logbuch
         AK_F_LOG.DBT
                        (DBFNTX) - ohne Index, da chronologisch
      TRANSLOG.DBF   -  Transaktions-Logbuch
                        (DBFNTX) - ohne Index, da chronologisch
      STAMM.DBF      -  Stammdaten der Droste AG
                        (DBFNTX) - ohne Index, da nur 1 Datensatz
      PLZ.DBF        -  Postleitzahlen mit Straáennamen (von Deutschland?)
         PLZ.CDX
                        (FOXCDX) hat das Vorteile???
      PLZDE.DBF      -  Postleitzahlen von Deutschland
         PLZDE.CDX
                        (FOXCDX) hat das Vorteile???
      S_.TAK         -  Bildschirmmasken-Beschreibung
         S_.SDF
         xFldPos.NTX
                        (SDFCDX), da Textdatei
      BL_.TAK        -  Druckausgaben-Beschreibung
         BL_.SDF
         xBlFName.NTX
                        (SDFCDX), da Textdatei
      HILFETIP.DBF   -  Hilfe-Zeilen
         xHTIP.NTX
      ANLIEF.DBF     -  Stammdaten der Anlieferer von Schrott (im Pflichtenheft 'Kunden' genannt)
         ANLIEF.FPT
         ANLIEF.CDX
                        (FOXCDX)
      HISTORIE.DBF   -  Aufzeichnung der Ver„nderungen der ANLIEF.DBF
         HISTORIE.FPT
         HISTORIE.CDX
                        (FOXCDX)
                        In HISTORIE.DBF sind alle ANLIEF.DBF-Datens„tze, die jemals erzeugt wurden.
                        Die Datei darf nie ver„ndert, immer nur um ganze Datens„tze erg„nzt werden.
      ABRECH.DBF     -  Abrechnungen f�r (An-)lieferungen von Material
         ABRECH.FPT  
         ABRECH.CDX  
                        (FOXCDX)
                        In ABRECH.DBF sind alle Abrechnungsk”pfe erfasst.
                        Sie befindet sich nur im Verzeichnis \SCRAPXR auf dem Stick.
      ABRECHT.DBF    -  Abrechnungen f�r (An-)lieferungen von Material
         ABRECHT.CDX  
                        (FOXCDX)
                        In ABRECHT.DBF sind alle Abrechnungstabellen (=Materialzeilen) erfasst.
                        Sie befindet sich nur im Verzeichnis \SCRAPXR auf dem Stick.
      ROHMAT.DBF     -  Alle Materialien (Artikel)
         ROHMAT.FPT  
         ROHMAT.CDX  
                        (FOXCDX)
                        In ROHMAT.DBF sind alle Materialien mit den aktuellen Preisen erfasst.
                        Sie befindet sich nur im Verzeichnis \SCRAPXR auf dem Stick.
      RMPREISE.DBF   -  Alle historischen Preise der Materialien (Artikel)
         RMPREISE.CDX  
                        (FOXCDX)
                        In RMPREISE.DBF sind alle fr�heren Preise der Materialien erfasst.
                        Sie befindet sich nur im Verzeichnis \SCRAPXR auf dem Stick.
      RMERZIEL.DBF   -  Alle historischen Erziel-(VK-)Preise der Materialien (Artikel)
         RMERZIEL.CDX  
                        (FOXCDX)
                        In RMERZIEL.DBF sind alle fr�heren Erziel-(VK-)-Preise der Materialien erfasst.
                        Sie befindet sich nur im Verzeichnis \SCRAPXR auf dem Stick.
      
      ABR_M.DBF      -  Stickless-Muster-Material-Kopf
      ABR_MT.DBF     -  Stickless-Muster-Material-Tabelle
      ABR_TB.DBF     -  StickLess-Tagesbericht
                        (FOCCDX)
                        Liegen alle drei im Verzeichnis cDatver.

   Dateien mit eingescannten Daten werden nach dem Namen und der AnLieferer-Nr. benannt
    und bekommen als weitere Unterscheidung den Typ (Art des Nachweises) und das DtoS()-Datum:
      %NUMMER+NAME+TYP+DtoS%
   */

SET EXCLUSIVE ON

/* Erzeugen der Parameter-Datei, wenn sie noch nicht existiert:   */
   IF !FILE( cDatver+"PARAM.DBF" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Parameter-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
               { "VOLL"      , "N",  5, 2 }, ;
               { "HALB"      , "N",  5, 2 }, ;
               { "SONDER"    , "N",  5, 2 }, ;
               { "RECHNR"    , "C",  6, 0 }, ;
               { "F00"       , "C",  5, 0 }, ;
               { "F01"       , "C",  5, 0 }, ;
               { "F02"       , "C",  5, 0 }, ;
               { "F03"       , "C",  5, 0 }, ;
               { "F04"       , "C",  5, 0 }, ;
               { "F05"       , "C",  5, 0 }, ;
               { "F06"       , "C",  5, 0 }, ;
               { "F07"       , "C",  5, 0 }, ;
               { "F08"       , "C",  5, 0 }, ;
               { "F09"       , "C",  5, 0 }, ;
               { "F10"       , "C",  5, 0 }, ;
               { "F11"       , "C",  5, 0 }, ;
               { "F12"       , "C",  5, 0 }, ;
               { "F13"       , "C",  5, 0 }, ;
               { "F14"       , "C",  5, 0 }, ;
               { "F15"       , "C",  5, 0 }, ;
               { "SYSTEM"    , "C",  1, 0 }, ;
               { "DATVER"    , "C", 60, 0 }, ;
               { "NETVER"    , "C", 60, 0 }, ;
               { "TEXTPROG"  , "C", 60, 0 }, ;
               { "COMCOM"    , "C", 30, 0 }, ;
               { "DRUCKER"   , "C", 60, 0 }, ;
               { "PUBAUF"    , "C",  6, 0 }, ;
               { "FIRMA"     , "C", 60, 0 }, ;
               { "ADRESSE1"  , "C", 50, 0 }, ;
               { "ADRESSE2"  , "C", 50, 0 }, ;
               { "ADRESSE3"  , "C", 50, 0 }, ;
               { "ADRESSE_F" , "C", 70, 0 }, ;
               { "PW0"       , "C", 15, 0 }, ;
               { "RS0"       , "C",  1, 0 }, ;
               { "BK0"       , "C",  3, 0 }, ;
               { "FONT0"     , "C", 30, 0 }, ;
               { "BESTP1_0"  , "N",  4, 0 }, ;
               { "BESTP2_0"  , "N",  4, 0 }, ;
               { "BESTS1_0"  , "N",  4, 0 }, ;
               { "BESTS2_0"  , "N",  4, 0 }, ;
               { "PW1"       , "C", 15, 0 }, ;
               { "RS1"       , "C",  1, 0 }, ;
               { "BK1"       , "C",  3, 0 }, ;
               { "FONT1"     , "C", 30, 0 }, ;
               { "BESTP1_1"  , "N",  4, 0 }, ;
               { "BESTP2_1"  , "N",  4, 0 }, ;
               { "BESTS1_1"  , "N",  4, 0 }, ;
               { "BESTS2_1"  , "N",  4, 0 }, ;
               { "PW2"       , "C", 15, 0 }, ;
               { "RS2"       , "C",  1, 0 }, ;
               { "BK2"       , "C",  3, 0 }, ;
               { "FONT2"     , "C", 30, 0 }, ;
               { "BESTP1_2"  , "N",  4, 0 }, ;
               { "BESTP2_2"  , "N",  4, 0 }, ;
               { "BESTS1_2"  , "N",  4, 0 }, ;
               { "BESTS2_2"  , "N",  4, 0 }, ;
               { "PW3"       , "C", 15, 0 }, ;
               { "RS3"       , "C",  1, 0 }, ;
               { "BK3"       , "C",  3, 0 }, ;
               { "FONT3"     , "C", 30, 0 }, ;
               { "BESTP1_3"  , "N",  4, 0 }, ;
               { "BESTP2_3"  , "N",  4, 0 }, ;
               { "BESTS1_3"  , "N",  4, 0 }, ;
               { "BESTS2_3"  , "N",  4, 0 }, ;
               { "PW4"       , "C", 15, 0 }, ;
               { "RS4"       , "C",  1, 0 }, ;
               { "BK4"       , "C",  3, 0 }, ;
               { "FONT4"     , "C", 30, 0 }, ;
               { "BESTP1_4"  , "N",  4, 0 }, ;
               { "BESTP2_4"  , "N",  4, 0 }, ;
               { "BESTS1_4"  , "N",  4, 0 }, ;
               { "BESTS2_4"  , "N",  4, 0 }, ;
               { "PW5"       , "C", 15, 0 }, ;
               { "RS5"       , "C",  1, 0 }, ;
               { "BK5"       , "C",  3, 0 }, ;
               { "FONT5"     , "C", 30, 0 }, ;
               { "BESTP1_5"  , "N",  4, 0 }, ;
               { "BESTP2_5"  , "N",  4, 0 }, ;
               { "BESTS1_5"  , "N",  4, 0 }, ;
               { "BESTS2_5"  , "N",  4, 0 }, ;
               { "PW6"       , "C", 15, 0 }, ;
               { "RS6"       , "C",  1, 0 }, ;
               { "BK6"       , "C",  3, 0 }, ;
               { "FONT6"     , "C", 30, 0 }, ;
               { "BESTP1_6"  , "N",  4, 0 }, ;
               { "BESTP2_6"  , "N",  4, 0 }, ;
               { "BESTS1_6"  , "N",  4, 0 }, ;
               { "BESTS2_6"  , "N",  4, 0 }, ;
               { "PW7"       , "C", 15, 0 }, ;
               { "RS7"       , "C",  1, 0 }, ;
               { "BK7"       , "C",  3, 0 }, ;
               { "FONT7"     , "C", 30, 0 }, ;
               { "BESTP1_7"  , "N",  4, 0 }, ;
               { "BESTP2_7"  , "N",  4, 0 }, ;
               { "BESTS1_7"  , "N",  4, 0 }, ;
               { "BESTS2_7"  , "N",  4, 0 }, ;
               { "PW8"       , "C", 15, 0 }, ;
               { "RS8"       , "C",  1, 0 }, ;
               { "BK8"       , "C",  3, 0 }, ;
               { "FONT8"     , "C", 30, 0 }, ;
               { "BESTP1_8"  , "N",  4, 0 }, ;
               { "BESTP2_8"  , "N",  4, 0 }, ;
               { "BESTS1_8"  , "N",  4, 0 }, ;
               { "BESTS2_8"  , "N",  4, 0 }, ;
               { "PW9"       , "C", 15, 0 }, ;
               { "RS9"       , "C",  1, 0 }, ;
               { "BK9"       , "C",  3, 0 }, ;
               { "FONT9"     , "C", 30, 0 }, ;
               { "BESTP1_9"  , "N",  4, 0 }, ;
               { "BESTP2_9"  , "N",  4, 0 }, ;
               { "BESTS1_9"  , "N",  4, 0 }, ;
               { "BESTS2_9"  , "N",  4, 0 } ;
               }
      DbCreate( "PARAM", aStruktur, "DBFNTX" )
      DbUseArea(,"DBFNTX",cDatver + "PARAM",,.F.)
      DbAppend()        /* leeren Datensatz erzeugen */
      DbCloseArea()
   ENDIF
/* die Parameter-Datei muss nicht geindext werden, weil sie ohnehin nur aus einem Satz besteht  */

/* Erzeugen der Drucker-Parameter-Datei, wenn sie noch nicht existiert:   */
   IF !FILE( cDatver+"DRUPAR.DBF" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Drucker-Parameter-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
               { "DRUCKER"   , "C", 60, 0 }, ;
               { "POSX"      , "N",  6, 1 }, ;
               { "POSY"      , "N",  6, 1 }, ;
               { "ZEILEPIX"  , "N",  3, 0 }, ;
               { "SPALTEPIX" , "N",  3, 0 }, ;
               { "DFONT1"    , "C", 30, 0 }, ;
               { "DFONT2"    , "C", 30, 0 }, ;
               { "DFONT3"    , "C", 30, 0 }, ;
               { "DFONT4"    , "C", 30, 0 }, ;
               { "DFONT5"    , "C", 30, 0 }, ;
               { "DFONT6"    , "C", 30, 0 }, ;
               { "DFONT7"    , "C", 30, 0 }, ;
               { "D01"       , "C",  5, 0 }, ;
               { "D02"       , "C",  5, 0 }, ;
               { "D03"       , "C",  5, 0 }, ;
               { "D04"       , "C",  5, 0 }, ;
               { "D05"       , "C",  5, 0 }, ;
               { "D06"       , "C",  5, 0 }, ;
               { "D07"       , "C",  5, 0 }, ;
               { "D08"       , "C",  5, 0 }, ;
               { "D09"       , "C",  5, 0 }, ;
               { "D10"       , "C",  5, 0 }, ;
               { "D11"       , "C",  5, 0 }, ;
               { "D12"       , "C",  5, 0 }, ;
               { "D13"       , "C",  5, 0 }, ;
               { "D14"       , "C",  5, 0 }, ;
               { "D15"       , "C",  5, 0 } ;
               }
      DbCreate( "DRUPAR", aStruktur, "DBFNTX" )
      DbUseArea(,"DBFNTX",cDatver + "DRUPAR",,.F.)
      DbAppend()        /* leeren Datensatz erzeugen */
      DbCloseArea()
   ENDIF
/* die Drucker-Parameter-Datei muss nicht geindext werden, weil sie ohnehin nur aus einem Satz besteht  */

/* Fehler-Log-Datei erzeugen  */
   IF !FExists( cDatver + "AK_F_LOG.DBT" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Fehler-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
            { "DATUM"  , "D",  8, 0 } , ;
            { "ZEIT"   , "C",  8, 0 } , ;
            { "LOGTEXT", "M", 10, 0 } ;
             }
      DbCreate( "AK_F_LOG", aStruktur )
   ELSEIF cFunk = "F"     // zum L”schen der Fehlereintr„ge
      DbUseArea(,"DBFNTX",cDatver + "AK_F_LOG",,.F.)
      ZAP
      DbCloseArea()
   ENDIF

/* Transaktions-Logbuch-Datei erzeugen */
   IF !FExists( cDatver + "TRANSLOG.TXT" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<LogBuch-Datei anlegen", 10, -1, 400, 20 ))
      aStruct := {{"TEXT","C",255,0}}
      DbeSetDefault( "DELDBE" )
      DbeInfo( COMPONENT_DATA, DELDBE_FIELD_TYPES, "C" )
      DbeInfo( COMPONENT_DATA, DELDBE_MODE, DELDBE_SINGLEFIELD )
      DbCreate( "TRANSLOG", aStruct, "DELDBE" )
      DbUseArea(.T.,"DELDBE",cDatver + "TransLog","tl",.F.)
      tl->(DbAppend())
      tl->FIELD := "Start"
      DbCloseArea()
      DbeSetDefault( "DBFNTX" )
   ELSEIF cFunk = "L"     // zum L”schen der Transaktionseintr„ge
      DbUseArea(,"DELDBE",cDatver + "TransLog",,.F.)
      ZAP
      DbCloseArea()
   ENDIF

/* Erzeugen der Stammdaten-Datei, wenn sie noch nicht existiert:   */

/*
   muss noch definiert werden ! ersteinmal nur kopiert aus der Parameter-Datei !!!
                                    */
                                   
   IF !FILE( cDatver+"STAMM.DBF" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Stamm-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
               { "F00"       , "C",  5, 0 }, ;
               { "F01"       , "C",  5, 0 }, ;
               { "F02"       , "C",  5, 0 }, ;
               { "F03"       , "C",  5, 0 }, ;
               { "F04"       , "C",  5, 0 }, ;
               { "F05"       , "C",  5, 0 }, ;
               { "F06"       , "C",  5, 0 }, ;
               { "F07"       , "C",  5, 0 }, ;
               { "F08"       , "C",  5, 0 }, ;
               { "F09"       , "C",  5, 0 }, ;
               { "F10"       , "C",  5, 0 }, ;
               { "F11"       , "C",  5, 0 }, ;
               { "F12"       , "C",  5, 0 }, ;
               { "F13"       , "C",  5, 0 }, ;
               { "F14"       , "C",  5, 0 }, ;
               { "F15"       , "C",  5, 0 }, ;
               { "FIRMA"     , "C", 60, 0 }, ;
               { "ADRESSE1"  , "C", 50, 0 }, ;
               { "ADRESSE2"  , "C", 50, 0 }, ;
               { "ADRESSE3"  , "C", 50, 0 }, ;
               { "ADRESSE_F" , "C", 70, 0 } ;
               }
      DbCreate( "STAMM", aStruktur, "DBFNTX" )
      DbUseArea(,"DBFNTX",cDatver + "STAMM",,.F.)
      DbAppend()        /* leeren Datensatz erzeugen */
      DbCloseArea()
   ENDIF
/* die Stammdaten-Datei muss nicht geindext werden, weil sie ohnehin nur aus einem Satz besteht  */

/* PLZ mit Straáen, muss aber noch erg„nzt werden */
   IF !FILE( cDatver+"PlzStr.dbf" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<PLZ1-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
            { "PLZ"        , "C",  5, 0 } , ;
            { "STR_SUCH"   , "C", 46, 0 } , ;
            { "STR_46"     , "C", 46, 0 } , ;
            { "STR_22"     , "C", 46, 0 } , ;
            { "HNR_VON"    , "C",  5, 0 } , ;
            { "HNR_BIS"    , "C",  5, 0 } , ;
            { "HNR_TYP"    , "C",  1, 0 }  ;
             }
      DbCreate( "PlzStr", aStruktur, "FOXCDX" )
   ENDIF
   DbUseArea( , "FOXCDX", cDatver + "PlzStr", "plz" )
   nOldArea := SELECT()
   IF Eof()
      DbUseArea(.T. ,"SDFNTX", cDatver + "stra_da.tak", "sd" )
      DO WHILE !sd->(Eof())
         plz->(DbAppend())
         plz->plz := sd->plz_plz
         plz->str_such := sd->str_names
         plz->str_46 := sd->str_name46
         plz->str_22 := sd->str_name22
         plz->hnr_von := sd->str_hnrvon
         plz->hnr_bis := sd->str_hnrbis
         plz->hnr_typ := sd->plz_hnrtyp
         sd->(DbSkip())
      ENDDO
      sd->(DbCloseArea())
      SELECT &nOldArea
      FErase( cDatver+"PlzStr.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cDatver + "PlzStr", "ps", "PLZ+STR_SUCH" )  // PLZ +  Straáe in Suchform (Upper + ohne Sonder-Zeichen)
      OrdCreate( cDatver + "PlzStr", "ss", "STR_SUCH+PLZ" )      // Straáe in Suchform (Upper + ohne Sonder-Zeichen)
      DbCloseArea()
   ENDIF

/* die gesamtdeutsche PLZ-Datei (ohne Straáen)  */
   IF !FILE( cDatver+"PlzOrt.dbf" )
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<PLZ2-Datei anlegen", 10, -1, 400, 20 ))
      aStruktur := { ;
            { "PLZ"        , "C",  5, 0 } , ;
            { "ORT"        , "C", 40, 0 } , ;
            { "PLZ_ORT"    , "C", 46, 0 } , ;
            { "PLZ_STR"    , "C",  1, 0 }  ;
             }
      DbCreate( cDatver + "PlzOrt", aStruktur, "FOXCDX" )
   ENDIF
   DbUseArea( , "FOXCDX", cDatver + "PlzOrt", "po" )
   IF Eof()
      DbImport( "Plz_Orte.tak",,,,,,, "SDFNTX" )
      DbEval( {|| po->plz_ort := po->plz+" "+po->ort } )
      FErase( cDatver+"PlzOrt.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cDatver + "PlzOrt", "p", "PLZ" )         // PLZ
      OrdCreate( cDatver + "PlzOrt", "o", "Upper(ORT)" )          // Ort ohne PLZ
//      OrdListAdd( "PlzOrt" )
      OrdSetFocus( "p" )
      nOldArea := SELECT()
         DbUseArea( .T., "FOXCDX", cDatver + "PlzStr", "plz" )
         OrdListAdd( "PlzStr" )
         OrdSetFocus( "ps" )
      SELECT &nOldArea
      DbGotop()
      DO WHILE !Eof()
         IF plz->(DbSeek(po->plz,.F.))
            po->plz_str := "2"
         ELSE
            po->plz_str := "1"
         ENDIF
         DbSkip()
      ENDDO
      plz->(DbCloseArea())
      DbCloseArea()
   ENDIF

/* Datei zum Bildschirmaufbau:
   S_.SDF + S_.TAK m�ssen vorher erstellt worden sein
   S_.SDF enth„lt dabei die Struktur:
      [INFO]
      file=s_.tak
      fieldcount=17
      recsize=327
      reccount=2475
      
      [FIELDS]
      FNAME=C,8,0
      FIELD_NAME=C,10,0
      FIELD_TYPE=C,1,0
      FIELD_LEN=N,5,0
      FIELD_DEC=N,4,0
      FIELD_POS=N,3,0
      SPAF=N,4,0
      ZEIF=N,4,0
      BRF=N,3,0
      HOF=N,3,0
      TAB_STOP=L,1,0
      ZAHL_FORM=C,15,0
      TEXT=C,250,0
      SPAT=N,4,0
      ZEIT=N,4,0
      BRT=N,3,0
      HOT=N,3,0
      [END]
    S_.TAK muss gem„á dieser Struktur aufgebaut sein.
      */
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Bildschirm-Datei indizieren", 10, -1, 400, 20 ))
   DbUseArea( ,"SDFNTX", cDatver + "s_.tak", "sv" )
   OrdCreate( cDatver + "xFldPos",, "Upper(fname)+StrZero(field_pos+1000,4,0)" )
   DbCloseArea()
      //+02.02.2013 10:27 erzeugt die s_xxx.dbf-Dateien, wenn noch nicht vorhanden oder veraltet
            // gibt es eine neue s_.tak-Version? Dann alle s_xxx.dbf erzeugen
               cs_tak := cDatver+"s_.tak"       // .tak-Datei ist Teil des Programms
               cs_dbf := cDatver+"s_scrap.dbf"
               aTakFiles := Directory( cs_tak )
               aDbfFiles := Directory( cs_dbf )
               IF Len( aTakFiles ) > 0                // gibt es eine neue Programmversion auf dem Server? :
                  IF AppKeyState(65552)=1 .OR. Len(aDbfFiles)==0 .OR. aTakFiles[ 1, F_WRITE_DATE ] > aDbfFiles[ 1, F_WRITE_DATE ]
                     TXT_zu_DBF("s")   // in DbDruSysS, macht kleine DBFs aus der groáen TAK
                  ENDIF
               ENDIF
      //^^//////////////////////////////////////////////////////////////////////////////////////////////

/* Datei zum Aufbau der Drucke 
   BL_.SDF + BL_.TAK m�ssen vorher erstellt worden sein
   BL_.SDF enth„lt dabei die Struktur:
      [INFO]
      file=bl_.tak
      fieldcount=11
      recsize=248
      reccount=4115
      
      [FIELDS]
      FNAME=C,8,0
      SEITE=C,1,0
      NA=C,1,0
      PROMPT=C,20,0
      TEXT=C,100,0
      TFONT=N,1,0
      BEREICH=C,2,0
      FELD=C,100,0
      FFONT=N,1,0
      ZEILE=N,6,1
      SPALTE=N,6,1
      [END]
    BL_.TAK muss gem„á dieser Struktur aufgebaut sein.
      */
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Ausdruck-Datei indizieren", 10, -1, 400, 20 ))
   DbUseArea( ,"SDFNTX", cDatver + "bl_.tak", "bv" )
   OrdCreate( cDatver + "xBlFName",, "Upper(fname)" )
   DbCloseArea()
      //+02.09.2013 10:36 erzeugt die bl_xxx.dbf-Dateien, wenn noch nicht vorhanden oder veraltet
            // gibt es eine neue bl_.tak-Version? Dann alle bl_xxx.dbf erzeugen
               cbl_tak := cDatver+"bl_.tak"       // .tak-Datei ist Teil des Programms
               cbl_dbf := cDatver+"bl_anl.dbf"
               aTakFiles := Directory( cbl_tak )
               aDbfFiles := Directory( cbl_dbf )
               IF Len( aTakFiles ) > 0                // gibt es eine neue Programmversion auf dem Server? :
                  IF AppKeyState(65552)=1 .OR. Len(aDbfFiles)==0 .OR. aTakFiles[ 1, F_WRITE_DATE ] > aDbfFiles[ 1, F_WRITE_DATE ]
                     TXT_zu_DBF("b")   // in DbDruSysS, macht kleine DBFs aus der groáen TAK
                  ENDIF
               ENDIF
      //^^//////////////////////////////////////////////////////////////////////////////////////////////

/* Datei f�r die Hilfezeilen  */
   IF !FILE( cDatver+"HILFETIP.DBF" )
      aStruktur := { ;
               { "LANG_ID"   , "N",  4, 0 }, ;
               { "HELP_ID"   , "N",  4, 0 }, ;
               { "HINT"      , "C",250, 0 }, ;
               { "DESCRIPT"  , "C",250, 0 }  ;
               }
      DbCreate( cDatver + "HILFETIP", aStruktur, "DBFNTX" )

   ENDIF
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Hilfe-Datei indizieren", 10, -1, 400, 20 ))
   IF AppKeyState(65552)!=1  //+02.04.2013 11:33 Shift nicht gedr�ckt
      DbUseArea( , "DBFNTX", cDatver + "HilfeTip" )
      OrdCreate( cDatver + "xHTip", "id", "StrZero(lang_id,4,0)+StrZero(help_id,4,0)" )         // PLZ
      DbCloseArea()
   ENDIF

/* Erzeugen der AnLieferer-Datei, wenn sie noch nicht existiert:   */
   IF !FILE( cDatver+"ANLIEF.DBF" )
      aStruktur := { ;
               { "ANUMMER"   , "C",  6, 0 }, ;
               { "PERSKONTO" , "C",  6, 0 }, ;
               { "ADATUM"    , "D",  8, 0 }, ;
               { "BEARBEITER", "C",  3, 0 }, ;
               { "BENUTZER"  , "C",  3, 0 }, ;
               { "ANREDE"    , "C", 30, 0 }, ;
               { "GEBDATUM"  , "D",  8, 0 }, ;
               { "NAME"      , "C", 30, 0 }, ;
               { "VORNAME"   , "C", 30, 0 }, ;
               { "ZUSATZ"    , "C", 50, 0 }, ;
               { "STRASSE"   , "C", 50, 0 }, ;
               { "PLZ"       , "C", 10, 0 }, ;
               { "ORT"       , "C", 30, 0 }, ;
               { "LAND"      , "C", 30, 0 }, ;
               { "TELEFON"   , "C", 50, 0 }, ;
               { "FAX"       , "C", 50, 0 }, ;
               { "MOBIL"     , "C", 50, 0 }, ;
               { "EMAIL"     , "C", 50, 0 }, ;
               { "AUSW_ART"  , "C", 30, 0 }, ;
               { "AUSW_NR"   , "C", 15, 0 }, ;
               { "AUSW_DAT"  , "D",  8, 0 }, ;
               { "AUSW_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"A"+Ausw_Art[1](=Typ)+DtoS(Ausw_Scn_V)+'V'   */
               { "AUSW_SCN_R", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"A"+Ausw_Art[1](=Typ)+DtoS(Ausw_Scn_R)+'R'   */
               { "VOLL_ART"  , "C", 30, 0 }, ;
               { "VOLL_GEBER", "C", 50, 0 }, ;
               { "VOLL_DAT1" , "D",  8, 0 }, ;
               { "VOLL_DAT"  , "D",  8, 0 }, ;
               { "VOLL_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"V"+Voll_Art[1](=Typ)+DtoS(Vollm_Dat)   */
               { "UIDN_NR"   , "C", 14, 0 }, ;
               { "UIDN_DAT1" , "D",  8, 0 }, ;
               { "UIDN_DAT2" , "D",  8, 0 }, ;
               { "UIDN_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"UIDN"(=Typ)+DtoS(UIDN_dat1)   */
               { "NOTIZ"     , "M",  4, 0 }, ;
               { "BANK"      , "C", 50, 0 }, ;
               { "KONTONR"   , "C", 16, 0 }, ;
               { "BLZ"       , "C", 10, 0 }, ;
               { "IBAN"      , "C", 28, 0 }, ;
               { "BIC"       , "C", 14, 0 } ;
               }
      DbCreate( cDatver + "ANLIEF", aStruktur, "FOXCDX" )
      DbUseArea( , "FOXCDX", cDatver + "AnLief" )
      IF FExists(cDatver+"anl0.dbf")
         APPEND FROM (cDatver+"anl0") VIA "FOXCDX"
         IF FRename( cDatver+"anl0.dbf", cDatver+"anl1.dbf" ) = -1
            FErase( cDatver+"anl1.dbf" )
            FRename( cDatver+"anl0.dbf", cDatver+"anl1.dbf" )
         ENDIF
         IF FRename( cDatver+"anl0.fpt", cDatver+"anl1.fpt" ) = -1
            FErase( cDatver+"anl1.fpt" )
            FRename( cDatver+"anl0.fpt", cDatver+"anl1.fpt" )
         ENDIF
      ELSE
         DbAppend()        /* leeren Datensatz erzeugen */
         FIELD->anummer := "000000"    // damit NEU funktioniert
         DbAppend()        /* leeren Datensatz erzeugen */
         FIELD->anummer := "999999"    // damit bei Eof() nicht eine neue Hist angelegt wird
      ENDIF
      DbCloseArea()
   ENDIF
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Anlieferer-Datei indizieren", 10, -1, 400, 20 ))
   DbUseArea( , "FOXCDX", cDatver + "AnLief" )
   REPLACE ALL benutzer WITH ""     //+28.02.2010 17:52 damit Reste verschwinden
   PACK
//   Erweiterung(cDatver+"AnLief", {{"PERSKONTO","C",6,0}}, "FOXCDX" ) //+08.02.2011 19:10
   DbUseArea( , "FOXCDX", cDatver + "AnLief" )
   FErase( cDatver+"AnLief.cdx" )              // damit der Index nicht nur �berschrieben wird
   OrdCreate( cDatver + "AnLief", "an", "ANUMMER" )
   OrdCreate( cDatver + "AnLief", "na", "NAME+VORNAME" ) //+16.09.2012 17:25 +VORNAME, wegen SuchThread!
   DbCloseArea()

/* HISTORIE.DBF braucht dieselbe Struktur wie ANLIEF.DBF,
   weil dort lediglich alle erzeugten ANLIEF.DBF-Datens„tze reinkopiert werden,
   sobald die Ver„nderung komplettiert wurde
   (ggf. automatisch, wenn man den Anlief-Satz verl„sst bzw. das Programm beendet?) */
/* Erzeugen der Historie-Datei, wenn sie noch nicht existiert:   */
   IF !FILE( cDatver+"HISTORIE.DBF" )
      DbUseArea( , "FOXCDX", cDatver + "AnLief" )
      aStruktur := DbStruct()
      DbCloseArea()
               /* das steht jetzt in aStruktur: (die Struktur von Anlief.dbf)
               { ;
               { "ANUMMER"   , "C",  6, 0 }, ;
               { "PERSKONTO" , "C",  6, 0 }, ;
               { "ADATUM"    , "D",  8, 0 }, ;
               { "BEARBEITER", "C",  3, 0 }, ;
               { "BENUTZER"  , "C",  3, 0 }, ;
               { "ANREDE"    , "C", 30, 0 }, ;
               { "GEBDATUM"  , "D",  8, 0 }, ;
               { "NAME"      , "C", 30, 0 }, ;
               { "VORNAME"   , "C", 30, 0 }, ;
               { "ZUSATZ"    , "C", 50, 0 }, ;
               { "STRASSE"   , "C", 50, 0 }, ;
               { "PLZ"       , "C", 10, 0 }, ;
               { "ORT"       , "C", 30, 0 }, ;
               { "LAND"      , "C", 30, 0 }, ;
               { "TELEFON"   , "C", 50, 0 }, ;
               { "FAX"       , "C", 50, 0 }, ;
               { "MOBIL"     , "C", 50, 0 }, ;
               { "EMAIL"     , "C", 50, 0 }, ;
               { "AUSW_ART"  , "C", 30, 0 }, ;
               { "AUSW_NR"   , "C", 15, 0 }, ;
               { "AUSW_DAT"  , "D",  8, 0 }, ;
               { "AUSW_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"A"+Ausw_Art[1](=Typ)+DtoS(Ausw_Scn_V)+'V'   *//*
               { "AUSW_SCN_R", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"A"+Ausw_Art[1](=Typ)+DtoS(Ausw_Scn_R)+'R'   *//*
               { "VOLL_ART"  , "C", 30, 0 }, ;
               { "VOLL_GEBER", "C", 50, 0 }, ;
               { "VOLL_DAT1" , "D",  8, 0 }, ;  //+ 22.07.2008 10:20 'Vollmacht vom'
               { "VOLL_DAT"  , "D",  8, 0 }, ;
               { "VOLL_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"V"+Voll_Art[1](=Typ)+DtoS(Vollm_Dat)   *//*
               { "UIDN_NR"   , "C", 14, 0 }, ;
               { "UIDN_DAT1" , "D",  8, 0 }, ;
               { "UIDN_DAT2" , "D",  8, 0 }, ;
               { "UIDN_SCN_V", "D",  8, 0 }, ;  /* JPG-Datei: ANummer+"UIDN"(=Typ)+DtoS(Vollm_Dat)   *//*
               { "NOTIZ"     , "M",  4, 0 }, ;
               { "BANK"      , "C", 50, 0 }, ;
               { "KONTONR"   , "C", 16, 0 }, ;
               { "BLZ"       , "C", 10, 0 }, ;
               { "IBAN"      , "C", 28, 0 }, ;
               { "BIC"       , "C", 14, 0 } ;
               }
               */
      /* ...und das muss noch an aStruktur erg„nzt werden: */
      aStruktErg := { ;
               { "HDATUM"    , "D",  8, 0 }, ;  /* gef�llt mit Date() der Žnderung */
               { "HUHRZEIT"  , "C",  8, 0 }, ;  /* gef�llt mit Time() HH:MM:SS   */
               { "TYP"       , "C", 15, 0 }, ;  /* Neuanlage/Daten-Žnderung/Scan-Žnderung/.. */
               { "BETR_FLDR" , "M",  4, 0 }, ;  /* z.B.: EMAIL: altdings@altbums.de - neudings@neubums.de */
               { "HIST_NOTIZ", "M",  4, 0 }  ;  /* zus„tzliche Notiz speziell zum Historieneintrag   */
               }
      AEval( aStruktErg, {|a| AAdd(aStruktur,a) } )
      DbCreate( cDatver + "HISTORIE", aStruktur, "FOXCDX" )
      DbUseArea( , "FOXCDX", cDatver + "Historie" )
      IF FExists(cDatver+"hist0.dbf")
         APPEND FROM (cDatver+"hist0") VIA "FOXCDX"
         IF FRename( cDatver+"hist0.dbf", cDatver+"hist1.dbf" ) = -1
            FErase( cDatver+"hist1.dbf" )
            FRename( cDatver+"hist0.dbf", cDatver+"hist1.dbf" )
         ENDIF
         IF FRename( cDatver+"hist0.fpt", cDatver+"hist1.fpt" ) = -1
            FErase( cDatver+"hist1.fpt" )
            FRename( cDatver+"hist0.fpt", cDatver+"hist1.fpt" )
         ENDIF
      ELSE
         DbAppend()        /* leeren Datensatz erzeugen */
         FIELD->anummer := "000000"    // damit NEU funktioniert
         DbAppend()        /* leeren Datensatz erzeugen */
         FIELD->anummer := "999999"    // damit bei Eof() nicht eine neue Hist angelegt wird
      ENDIF
      DbCloseArea()
   ENDIF
      IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Historie-Datei indizieren", 10, -1, 400, 20 ))
   DbUseArea( , "FOXCDX", cDatver + "Historie" )
   PACK
//   Erweiterung(cDatver+"Historie", {{"PERSKONTO","C",6,0}}, "FOXCDX" ) //+08.02.2011 19:30
   DbUseArea( , "FOXCDX", cDatver + "Historie" )
   FErase( cDatver+"Historie.cdx" )              // damit der Index nicht nur �berschrieben wird
   OrdCreate( cDatver + "Historie", "an", "ANUMMER" )
   OrdCreate( cDatver + "Historie", "na", "NAME" )
   DbCloseArea()
/**/
//+30.07.2008 09:35 erzeugt ein SubDir unter Scans2, damit FileView funktioniert:
   IF !FExists(cDatver+"Scans2\wichtig","D")
      RunShell( "/C MD "+cDatver + "Scans2\wichtig",, .T. )
   ENDIF
   //+ wenn der Stick mit dem Verzeichnis der ausgelagerten Dateien verf�gbar,
   //+   dann die Dateien erzeugen bzw. indizieren:
   IF FExists( cStickDrive + ":\ScrapXR", "D" )
      /* Erzeugen der Abrechnungs-Datei, wenn sie noch nicht existiert:   */
      IF !FExists( cStickVer + "ABRECH.DBF" )
         aStruktur := { ;
                  { "ANUMMER"   , "C",  6, 0 }, ;
                  { "ABRECHNR"  , "C",  6, 0 }, ;
                  { "ABRDATUM"  , "D",  8, 0 }, ;
                  { "BEARBEITER", "C",  3, 0 }, ;
                  { "BENUTZER"  , "C",  3, 0 }, ;
                  { "LIEFDATUM" , "D",  8, 0 }, ;
                  { "ADRESSE"   , "M",  4, 0 }, ;
                  { "LEGITIM"   , "C", 50, 0 }, ;
                  { "BRUNET"    , "C",  1, 0 }, ;
                  { "UIDN_NR"   , "C", 14, 0 }, ;
                  { "ANLIEF_ABH", "C",  1, 0 }, ;
                  { "GEWICHT"   , "N",  6, 0 }, ;
                  { "NE_BETRAG" , "N",  9, 2 }, ;
                  { "MW_BETRAG" , "N",  9, 2 }, ;
                  { "BR_BETRAG" , "N",  9, 2 }, ;
                  { "ZAHLART"   , "C",  1, 0 }, ;
                  { "ZAHL_BETR" , "N",  9, 2 }, ;
                  { "KONTO"     , "C",  6, 0 }, ;
                  { "GEBUCHT"   , "C",  1, 0 }, ;
                  { "R_NOTIZ"   , "M",  4, 0 }, ;
                  { "R_BEMERK"  , "M",  4, 0 } ;
                  }
         DbCreate( cStickVer + "ABRECH", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cStickVer + "Abrech" )
         DbAppend()
         1->anummer := "000000"
         1->abrechnr:= "000100"
         1->adresse := "MUSTER"
         DbImport( cStickver + "Abrech_X",,,,,,,"FOXCDX" )    //+15.03.2010 20:43
         DbCloseArea()
      ENDIF
         IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Abrechnungs-Datei indizieren", 10, -1, 400, 20 ))


      DbUseArea( , "FOXCDX", cStickVer + "Abrech" )
      PACK
//         Erweiterung(cStickVer+"Abrech", {{"R_BEMERK","M",4,0}}, "FOXCDX" ) //+15.06.2009 18:21
      DbUseArea( , "FOXCDX", cStickVer + "Abrech" )
      FErase( cStickVer+"Abrech.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cStickVer + "Abrech", "an", "ANUMMER+ABRECHNR" )
      OrdCreate( cStickVer + "Abrech", "ab", "ABRECHNR" )
      DbCloseArea()
      /* Erzeugen der AbrechnungsTabellen-Datei, wenn sie noch nicht existiert:   */
      IF !FExists( cStickDrive+":\ScrapXR\ABRECHT.DBF" )
         aStruktur := { ;
                  { "ABRECHNR"  , "C",  6, 0 }, ;
                  { "ZEILE"     , "C",  2, 0 }, ;
                  { "MAT_KURZ"  , "C",  6, 0 }, ;
                  { "MATERIAL"  , "C", 40, 0 }, ;
                  { "MAT_ART"   , "C",  2, 0 }, ;
                  { "MENGE_KG"  , "N",  6, 0 }, ;
                  { "EK_PREIS"  , "N",  8, 2 }, ;     //+ Preis pro Kg
                  { "EK_NETTO"  , "N",  8, 2 }, ;     //+ Preis pro Tonne
                  { "GES_PREIS" , "N",  9, 2 }, ;
                  { "GES_PRNET" , "N",  9, 2 }, ;
                  { "MWST_SATZ" , "N",  4, 1 }, ;
                  { "EK_PR_ALT" , "N",  8, 2 }, ;
                  { "EK_DAT_ALT", "D",  8, 0 }, ;     //+08.03.2010 18:08
                  { "EK_MAT_ALT", "C", 40, 0 }, ;     //+09.09.2011 18:03
                  { "KONTO"     , "C",  6, 0 }, ;
                  { "GEBUCHT"   , "C",  1, 0 } ;
                  }
         DbCreate( cStickVer + "ABRECHT", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cStickVer + "AbrechT",,.F. )
         FOR i := 1 TO 20     //+15.06.2009 18:07 jetzt 20 Zeilen
            DbAppend()
            1->abrechnr := "000100"
            1->zeile    := StrX(i,2)
         NEXT
         DbCloseArea()
      ENDIF
         IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<AbrechnungsT-Datei indizieren", 10, -1, 400, 20 ))
      DbUseArea( , "FOXCDX", cStickVer + "AbrechT" )
      PACK
      //+08.03.2010 18:20+++++++++++++++++++++++++++++++++++++++++++++++++++++
      IF AppKeyState(65553)=1 .OR. DATE() < CtoD("31.03.2010")     //+08.03.2010 18:12 neues Feld ek_dat_alt
         aStruktur := { ;
                  { "ABRECHNR"  , "C",  6, 0 }, ;
                  { "ZEILE"     , "C",  2, 0 }, ;
                  { "MAT_KURZ"  , "C",  6, 0 }, ;
                  { "MATERIAL"  , "C", 40, 0 }, ;
                  { "MAT_ART"   , "C",  2, 0 }, ;
                  { "MENGE_KG"  , "N",  6, 0 }, ;
                  { "EK_PREIS"  , "N",  8, 2 }, ;     //+ Preis pro Kg
                  { "EK_NETTO"  , "N",  8, 2 }, ;     //+ Preis pro Tonne
                  { "GES_PREIS" , "N",  9, 2 }, ;
                  { "GES_PRNET" , "N",  9, 2 }, ;
                  { "MWST_SATZ" , "N",  4, 1 }, ;
                  { "EK_PR_ALT" , "N",  8, 2 }, ;
                  { "EK_DAT_ALT", "D",  8, 0 }, ;     //+08.03.2010 18:08
                  { "EK_MAT_ALT", "C", 40, 0 }, ;     //+08.03.2010 18:08
                  { "KONTO"     , "C",  6, 0 }, ;
                  { "GEBUCHT"   , "C",  1, 0 } ;
                  }
         Erweiterung(cStickVer + "AbrechT", aStruktur, "FOXCDX" )
//         REPLACE ALL ek_dat_alt WITH CtoD(" ")
      ENDIF
      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//      Erweiterung(cStickVer + "AbrechT", {{ "MENGE_KG"  , "N",  7, 0 }}, "FOXCDX" ) //*09.06.2009 09:50
      DbUseArea( , "FOXCDX", cStickVer + "AbrechT" )
      FErase( cStickVer + "AbrechT.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cStickVer + "AbrechT", "az", "ABRECHNR+ZEILE" )
      DbCloseArea()
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      /* Erzeugen der RohMaterial-Datei, wenn sie noch nicht existiert:   */
      IF !FExists( cStickDrive+":\ScrapXR\ROHMAT.DBF" )
         aStruktur := { ;
                  { "MAT_REIHE" , "C",  4, 0 }, ;
                  { "MAT_KURZ"  , "C",  8, 0 }, ;
                  { "MATERIAL"  , "C", 40, 0 }, ;
                  { "MAT_ART"   , "C",  2, 0 }, ;     //+ evtl. Zeilennr der Abrechnung - Position im Tagesbericht!
                  { "BESTAND_KG", "N",  9, 0 }, ;
                  { "JAHRMENGEK", "N",  9, 0 }, ;     //+ kg-Angabe
                  { "UMSATZ_EK" , "N",  9, 2 }, ;     //+ EUR
                  { "JAHRMENGVK", "N",  9, 0 }, ;     //+ kg-Angabe
                  { "UMSATZ_VK" , "N",  9, 2 }, ;     //+ EUR
                  { "EKPR_DATUM", "D",  8, 0 }, ;
                  { "VONPREIS"  , "N",  8, 2 }, ;     //+ kg ODER t-Basis
                  { "MITTPREIS" , "N",  8, 2 }, ;
                  { "BISPREIS"  , "N",  8, 2 }, ;
                  { "EKPR_EINH" , "C",  2, 0 }, ;     //+ Einheit/Basis des EK-Preises
                  { "VKPR_DATUM", "D",  8, 0 }, ;
                  { "VKPREIS"   , "N",  8, 2 }, ;     //+ kg ODER t-Basis
                  { "VKPR_EINH" , "C",  2, 0 }, ;     //+ Einheit/Basis des VK-Preises
                  { "KONTO"     , "C",  6, 0 }, ;     //+ Buchhaltungs-Konto?
                  { "NOTIZEN"   , "M",  4, 0 } ;      //+ ggf automatische Eintr„ge (z.B. Verkauf an wen?)
                  }
         DbCreate( cStickVer + "ROHMAT", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cStickVer + "ROHMAT",,.F. )
         DbCloseArea()
      ENDIF
         IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<Material-Datei indizieren", 10, -1, 400, 20 ))
      DbUseArea( , "FOXCDX", cStickVer + "ROHMAT" )
      PACK
      Erweiterung(cStickVer + "ROHMAT", {{ "MAT_REIHE" , "C",  4, 0 }}, "FOXCDX" ) //*09.06.2009 09:50
      DbUseArea( , "FOXCDX", cStickVer + "ROHMAT" )
      FErase( cStickVer + "ROHMAT.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cStickVer + "ROHMAT", "mr", "Upper(MAT_REIHE)+MAT_ART" )  //+23.09.2009 12:04
      OrdCreate( cStickVer + "ROHMAT", "mk", "Upper(MAT_KURZ)" )  //+darf es nur einmal geben!
      OrdCreate( cStickVer + "ROHMAT", "ma", "Upper(MATERIAL)" )
      DbCloseArea()

      //+ sammelt die zur�ckliegenden (historischen) Ankaufspreise:
      IF !FExists( cStickDrive+":\ScrapXR\RMPREISE.DBF" )
         aStruktur := { ;
                  { "MAT_REIHE" , "C",  4, 0 }, ;
                  { "MAT_KURZ"  , "C",  8, 0 }, ;
                  { "MAT_ART"   , "C",  2, 0 }, ;     //+ evtl. Zeilennr der Abrechnung - Position im Tagesbericht!
                  { "EKPR_DATUM", "D",  8, 0 }, ;
                  { "VONPREIS"  , "N",  8, 2 }, ;     //+ kg ODER t-Basis
                  { "MITTPREIS" , "N",  8, 2 }, ;     //+ demn„chst: automatischer Wochenpreis aus Abrechnungen
                  { "BISPREIS"  , "N",  8, 2 }, ;
                  { "EKPR_EINH" , "C",  2, 0 } ;     //+ Einheit/Basis des EK-Preises
                  }
         DbCreate( cStickVer + "RMPREISE", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cStickVer + "RMPREISE",,.F. )
         DbCloseArea()
      ENDIF
         IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<MaterialPreis-Datei indizieren", 10, -1, 400, 20 ))
      DbUseArea( , "FOXCDX", cStickVer + "RMPREISE" )
      PACK
      Erweiterung(cStickVer + "RMPREISE", {{ "MAT_REIHE" , "C",  4, 0 }}, "FOXCDX" ) //*09.06.2009 09:50
      DbUseArea( , "FOXCDX", cStickVer + "RMPREISE" )
      FErase( cStickVer + "RMPREISE.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cStickVer + "RMPREISE", "md", "Upper(MAT_KURZ)+DtoS(EKPR_DATUM)" )
      DbCloseArea()

      //+ sammelt die zur�ckliegenden (historischen) Verkaufspreise:
      IF !FExists( cStickDrive+":\ScrapXR\RMERZIEL.DBF" )
         aStruktur := { ;
                  { "MAT_REIHE" , "C",  4, 0 }, ;
                  { "MAT_KURZ"  , "C",  8, 0 }, ;
                  { "MAT_ART"   , "C",  2, 0 }, ;     //+ evtl. Zeilennr der Abrechnung - Position im Tagesbericht!
                  { "VKPR_DATUM", "D",  8, 0 }, ;
                  { "VKPREIS"   , "N",  8, 2 }, ;     //+ kg ODER t-Basis
                  { "VKPR_EINH" , "C",  2, 0 } ;     //+ Einheit/Basis des VK-Preises
                  }
         DbCreate( cStickVer + "RMERZIEL", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cStickVer + "RMERZIEL",,.F. )
         DbCloseArea()
      ENDIF
         IIf(cFunk="T",,oBest:TextFenster( , , , , , , nBz/2, , , , , "<MaterialVKPreis-Datei indizieren", 10, -1, 400, 20 ))
      DbUseArea( , "FOXCDX", cStickVer + "RMERZIEL" )
      PACK
      Erweiterung(cStickVer + "RMERZIEL", {{ "MAT_REIHE" , "C",  4, 0 }}, "FOXCDX" ) //*09.06.2009 09:50
      DbUseArea( , "FOXCDX", cStickVer + "RMERZIEL" )
      FErase( cStickVer + "RMERZIEL.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cStickVer + "RMERZIEL", "md", "Upper(MAT_KURZ)+DtoC(VKPR_DATUM)" )
      DbCloseArea()
   ENDIF
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+11.07.2009 22:27++++++++++++++++++++++++++++++++++++++++++++++++++
      DbUseArea( , "FOXCDX", cDatVer + "Abr_m" )
      PACK
//         Erweiterung(cDatVer+"Abr_m", {{"R_BEMERK","M",4,0}}, "FOXCDX" ) //+15.06.2009 18:21
      DbUseArea( , "FOXCDX", cDatVer + "Abr_m" )
      FErase( cDatVer+"Abr_m.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cDatVer + "Abr_m", "an", "ANUMMER+ABRECHNR" )
      OrdCreate( cDatVer + "Abr_m", "ab", "ABRECHNR" )
      DbCloseArea()
   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      DbUseArea( , "FOXCDX", cDatVer + "Abr_mT" )
      PACK
//      Erweiterung(cDatVer + "Abr_mT", {{ "MENGE_KG"  , "N",  7, 0 }}, "FOXCDX" ) //*09.06.2009 09:50
      DbUseArea( , "FOXCDX", cDatVer + "Abr_mT" )
      FErase( cDatVer + "Abr_mT.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cDatVer + "Abr_mT", "az", "ABRECHNR+ZEILE" )
      DbCloseArea()
   //+ 12.07.2009 12:02 +++++++++++++++++++++++++++++++++++++++++++++++++++
      //+01.11.2009 12:00 einmalig neu erzeugen:
         IF FRename( cDatver + "ABR_TB.DBF", cDatver + "ABR_TB_ur.DBF" ) == -1  // alte Datei kann nur einmal umbenannt werden
         ELSEIF FRename( cDatver + "ABR_TB.FPT", cDatver + "ABR_TB_ur.FPT" ) == -1
         ELSEIF FRename( cDatver + "ABR_TB.CDX", cDatver + "ABR_TB_ur.CDX" ) == -1
         ENDIF
         Sleep(10)
      //++//
      IF !FExists( cDatver + "ABR_TB.DBF" )
         aStruktur := { ;
                  { "ANUMMER"   , "C",  6, 0 }, ;
                  { "ABRECHNR"  , "C",  6, 0 }, ;
                  { "ABRDATUM"  , "D",  8, 0 }, ;
                  { "BEARBEITER", "C",  3, 0 }, ;
                  { "BENUTZER"  , "C",  3, 0 }, ;
                  { "LIEFDATUM" , "D",  8, 0 }, ;
                  { "ADRESSE"   , "M",  4, 0 }, ;     //++ Felder ab hier
                  { "LEGITIM"   , "C", 50, 0 }, ;     //++ werden eigentlich ...
                  { "BRUNET"    , "C",  1, 0 }, ;
                  { "UIDN_NR"   , "C", 14, 0 }, ;
                  { "ANLIEF_ABH", "C",  1, 0 }, ;
                  { "GEWICHT"   , "N",  6, 0 }, ;
                  { "NE_BETRAG" , "N",  9, 2 }, ;     //++ (ausgenommen von hier     
                  { "MW_BETRAG" , "N",  9, 2 }, ;
                  { "BR_BETRAG" , "N",  9, 2 }, ;     
                  { "ZAHLART"   , "C",  1, 0 }, ;
                  { "ZAHL_BETR" , "N",  9, 2 }, ;     //++ ...bis hier) - oder nur dieses?
                  { "KONTO"     , "C",  6, 0 }, ;
                  { "GEBUCHT"   , "C",  1, 0 }, ;
                  { "R_NOTIZ"   , "M",  4, 0 }, ;     //++ ...nicht gebraucht
                  { "R_BEMERK"  , "M",  4, 0 }, ;     //++ Felder bis hier
                  { "VA"        , "N",  6, 0 }, ;
                  { "KMK"       , "N",  6, 0 }, ;
                  { "KABEL"     , "N",  6, 0 }, ;
                  { "PB"        , "N",  6, 0 }, ;
                  { "ZN"        , "N",  6, 0 }, ;
                  { "MS"        , "N",  6, 0 }, ;
                  { "CU"        , "N",  6, 0 }, ;
                  { "ALU"       , "N",  6, 0 }, ;
                  { "RG"        , "N",  6, 0 }, ;
                  { "VERH"      , "N",  6, 0 }, ;
                  { "EMOT"      , "N",  6, 0 }, ;
                  { "AKKU"      , "N",  6, 0 }, ;
                  { "CRST"      , "N",  6, 0 }, ;
                  { "DIVM1"     , "N",  6, 0 }, ;
                  { "DIVM2"     , "N",  6, 0 }, ;
                  { "DIVM3"     , "N",  6, 0 }, ;
                  { "EURM"      , "N",  9, 2 }, ;
                  { "NENT"      , "N",  9, 2 }, ;
                  { "SCHR"      , "N",  6, 0 }, ;
                  { "SPAN"      , "N",  6, 0 }, ;
                  { "GUSS"      , "N",  6, 0 }, ;
                  { "EURS"      , "N",  9, 2 } ;
                  }
         DbCreate( cDatver + "ABR_TB", aStruktur, "FOXCDX" )
         DbUseArea( , "FOXCDX", cDatver + "Abr_TB", "abr_T" )
         IF FExists( cStickDrive + ":\ScrapXR", "D" )
//+04.01.2010 10:55 geREMt, weil es nicht funktionierte wegen Dateifehler auf externem LW
//+             DbImport(cStickVer+"Abrech.dbf",,,,,,,"FOXCDX")
//++//
            //+ 04.01.2010 10:55 DbImport ersetzt durch FieldPut(FieldGet):
               DbUseArea(.T. , "FOXCDX", cStickVer + "ABRECH", "abr" )
               OrdListAdd( cStickVer + "ABRECH" )
               OrdSetFocus( "ab" )           /* kontrollierender Index ABRECHNR+ZEILE*/
               DbUseArea(.T. , "FOXCDX", cStickVer + "ABRECHT", "abrT" )
               OrdListAdd( cStickVer + "ABRECHT" )
               OrdSetFocus( "az" )           /* kontrollierender Index ABRECHNR+ZEILE*/
            SELECT("abr")     //+ abrech.dbf
            DbGotop()
            DO WHILE !Eof()   //+ abrech.dbf durchgehen

            //+ das m�sste mal eine Funktion werden, damit es im Rechnungsmodul verwendet werden kann:
               IF Val(abr->abrechnr) >= 100000    //+ wenn kein Entwurf oder Muster
                  abrT->(DbSeek(abr->abrechnr,.F.))   //+abrechT synchronisieren mit abrech.dbf
                  IF !abrT->(Eof())    //+ wenn es wirklich eine Rechnungstabelle gibt
                     abr_T->(DbAppend())  //+ abr_T.dbf
                     FOR i := 1 TO abr->(FCount())
                        abr_T->(FieldPut(i,abr->(FieldGet(i))))
                     NEXT
                     //+04.01.2010 14:17
                     TBDatenSummen()   //+04.01.2010 14:21 steht in BRegieRmSt, ganz hinten
                     //++//
                  ENDIF
               ENDIF
               //++//+ Ende der zuk�nftigen Funktion
               
               abr->(DbSkip())      //+ abrech.dbf
            ENDDO
            abrT->(DbCloseArea())
            abr->(DbCloseArea())    //+04.01.2010 10:57
            SELECT("abr_T")         //+04.01.2010 10:57
         ENDIF
         DbCloseArea()
      ENDIF
      DbUseArea( , "FOXCDX", cDatver+ "Abr_TB" )
      PACK
//         Erweiterung(cDatver+"Abrech", {{"R_BEMERK","M",4,0}}, "FOXCDX" ) //+15.06.2009 18:21
      DbUseArea( , "FOXCDX", cDatver + "Abr_TB" )
      FErase( cDatver+"Abr_TB.cdx" )              // damit der Index nicht nur �berschrieben wird
      OrdCreate( cDatver + "Abr_TB", "an", "ANUMMER+ABRECHNR" )
      OrdCreate( cDatver + "Abr_TB", "ab", "ABRECHNR" )
      DbCloseArea()

      IF !FExists(cDatver+"Auskunft","D")
         RunShell( "/C MD "+cDatver + "Auskunft",, .T. )
      ENDIF
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      IIf(cFunk="T",,{oBest:Textfenster(), ;
               IIf( ValType(oDlg) =="O", {oDlg:hide(),oDlg:destroy()},)}) //+23.03.2010 09:11
SET EXCLUSIVE off
RETURN

//23.03.2008 12:44 aus PROC -> FUNCTION 
FUNCTION Erweiterung( cDatei, aErweiterung, cDBE )      // 15.08.2005
   LOCAL aStruktur := DbStruct(), i, nFeld := 0, lGleich := .T.
   IF Len(aStruktur) <= Len(aErweiterung) //+08.03.2010 18:05
      IF ACompare( aStruktur, aErweiterung )
         RETURN !lGleich   //+ wenn die Struktur schon stimmt
      ELSE
         aStruktur := AClone(aErweiterung)   //+ z.B. neue Ordnung in der Struktur
         lGleich := .F.
      ENDIF
   ELSE
      FOR i := 1 TO Len(aErweiterung)
         nFeld := aScan( aStruktur, {|a| a[1] == aErweiterung[i,1] } )
         IF nFeld > 0   // in aErweiterung ist ein ge„ndertes Feld
            IF !ACompare( aStruktur[nFeld], aErweiterung[i] )
               lGleich := .F.
               aStruktur[nFeld] := aErweiterung[i]
            ENDIF
         ELSE           // in aErweiterung ist ein neues Feld
            AAdd( aStruktur, aErweiterung[i] )
            lGleich := .F.
         ENDIF
      NEXT
   ENDIF
   IF lGleich     // .T. nur dann, wenn ACompare immer Gleichheit meldet
      RETURN !lGleich    //23.03.2008 12:38
   ENDIF
   DbCreate( cDatei+StrZero(nFeld,3,0), aStruktur, cDBE )
   DbUseArea( ,cDBE,cDatei+StrZero(nFeld,3,0),,.F.)
   DbImport( cDatei,,,,,,,cDBE )
   IF FRename( cDatei+".DBF", cDatei+"_.DBF" ) == -1  // alte Datei kann nur einmal umbenannt werden
   ELSEIF File( cDatei+".DBT" ) .AND. ;
                FRename( cDatei+".DBT", cDatei+"_.DBT" ) == -1
   ENDIF
   DbExport( cDatei,,,,,,,cDBE )
RETURN !lGleich    //23.03.2008 12:38

PROCEDURE MemoPack(cFile,cDBE)
   LOCAL lDeleted := Set( _SET_DELETED, .T. ) 

                                    // Deleted-Flag setzen/sichern 
   DbUseArea(.T.,cDBE, cFile)    // DBF- und DBT-Datei ”ffnen. 
   DbGoTop()                        // Ersten, nicht gel”schten 
                                    // Datensatz ausw„hlen. 
   DbExport( "Temp",,,,,,,cDBE )               // Datens„tze exportieren. 
   DbCloseArea()                    // Sicherungskopien erzeugen 
   COPY FILE (cFile+".DBF") to (cFile+"MP.DBF")
   IF File( cFile+".FPT" )
      COPY FILE (cFile+".FPT") to (cFile+"MP.FPT")
   ELSEIF File( cFile+".DBT" )
      COPY FILE (cFile+".DBT") to (cFile+"MP.DBT")
   ENDIF
                                    // tempor„re Dateien umbenennen 
   COPY FILE ("Temp.DBF") to (cFile+".DBF")
   IF File( "Temp.FPT" )
      COPY FILE ("Temp.FPT") TO (cFile+".FPT")
   ELSEIF File( "Temp.DBT" )
      COPY FILE ("Temp.DBT") TO (cFile+".DBT")
   ENDIF
   Set( _SET_DELETED, lDeleted ) 
RETURN

////////////////////////////////////////////////////////////////////////
//Hannes Ziegler:
//I would go with "brute force" to reduce the memo file size once in a while.
//1) Write "N" into the DBF file header for all Memo fields using FOpen/FWrite. 
//   This changes the FIELD type from Memo to Numeric.
//2) Open the DBF file regularly with DbUseArea()/USE
//3) Iterate the DBF file and read the numeric values of former Memo fields. 
//   They represent the file offset as number of memo blocks into the FPT file 
//   (default memo block size varies between 64 and 512). 
//   Then read the contents of the FPT file. 
//   Note: the first 4 bytes of an FPT memo indicate the length of the memo entry 
//   (convert with Bin2U())
//4) Write the FPT contents to a new FPT file and store its new pointer value in the DBF
//5) Write "M" back to the DBF file header when done.
//Sounds complicated, but isn't, when you know the Memo file format ...
//+16.03.2010 15:27
PROCEDURE MemoPack2(cFile)    //+ vorerst nur f�r FOX-Dateien! (4bit-Memos)
   LOCAL nHandle, nHandle2, cBuffer, nBuffer
   LOCAL aM := {}, nM := 12
   LOCAL aStruktur, aData, i
   DEFAULT cFile TO cStickver+"abrech"    //+22.03.2010 09:14
   
//+ aus jedem 'M' in der Struktur der .dbf wird ein "N"
   nHandle := FOpen( cFile+".dbf", FO_READWRITE )
   cBuffer := Space(32) ; nBuffer := 32
   FSeek( nHandle, nM )
   nBuffer := FRead( nHandle, @cBuffer, nBuffer )
   DO WHILE nBuffer == 32
      nM += nBuffer
      IF Right(cBuffer,1) == "M"
         AAdd(aM,nM-1)              //+ merkt sich die Position des "M"s
         FSeek( nHandle, -1, FS_RELATIVE )
         FWrite( nHandle, "C", 1 )
      ELSEIF !Right(cBuffer,1)$"NCDM"
         EXIT
      ENDIF
      nBuffer := FRead( nHandle, @cBuffer, nBuffer )
   ENDDO
   FClose( nHandle )

//+ *.dbf ”ffnen und mit der Struktur eine *Neu.dbf erzeugen:
   DbUseArea( , "FOXCDX", cFile, "dat" )
   aStruktur := DbStruct()
   DbCreate( cFile + "Neu", aStruktur, "FOXCDX" )
   DbUseArea( .T., "FOXCDX", cFile + "Neu", "neu" )
   SELECT("dat")

//+ *.fpt mit FOpen ”ffnen und eine *Neu.fpt mit FCreate erzeugen:
   nHandle := FOpen( cFile+".fpt", FO_READ )    //+ alte, originale Datei
   nHandle2 := FCreate( cFile+"Neu.fpt" )       //+ neue, korrigierte Datei
   cBuffer := Space(512) ; nBuffer := 512
   IF FRead(nHandle,@cBuffer,nBuffer) == nBuffer
      IF FWrite(nHandle2,cBuffer,nBuffer) != nBuffer
         msgbox("Schreiben von *Neu.fpt klappt nicht",cFile)
      ENDIF
   ELSE
      msgbox("Lesen von *.fpt klappt nicht",cFile)
   ENDIF
   
//+ "dat" in Schleife abarbeiten und damit *Neu.dbf/fpt f�llen:
   aData := Array( FCount() )
   DO WHILE !Eof()
      FOR i := 1 TO FCount()
         aData[i] := FieldGet(i)             //+ *.dbf lesen
      NEXT
      SELECT("neu")
      DbAppend()
      FOR i := 1 TO FCount()
         FieldPut( i, aData[i] )          //+ *Neu.dbf schreiben
      NEXT
      SELECT("dat")

      //+ Adressenfeld kopieren
      nBuffer := Bin2U(dat->adresse)   //+ Lage des Textes in .FPT (in 64bit Bl”cken)
      IF nBuffer > 0                   //+ wenn Text existiert
         FSeek( nHandle, nBuffer*64 )  //+ positionieren auf den Text in alter .FPT
         //+ Text aus alter .FPT in neue .FPT kopieren:
         //+ dazu muss zuerst die L„nge des Textes festgestellt werden:
         cBuffer := Space(8) ; nBuffer := 8  //+ in den ersten 8 Bytes steht die L„nge
         IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ erste 8 Byte lesen
            IF Left(cBuffer,4) == Chr(0)+Chr(0)+Chr(0)+Chr(1)
               nBuffer += Asc(cBuffer[8])+Asc(cBuffer[7])*256  //+ 8 plus L„nge des Textes
               IF nBuffer > 1024                               //+ Fehler entdeclen...
                  msgbox( "Bufferl„nge f�r Adresse: "+Str(nBuffer) ) //+ ...anzeigen...
                  nBuffer := 1000                              //+ ...und korrigieren
               ENDIF
               nBuffer := (Int(nBuffer/64)+1)*64   //+ ganze 64Byte-Bl”cke
               cBuffer := Space(nBuffer)           //+ Buffer einrichten
               FSeek( nHandle, -8, FS_RELATIVE )   //+ an den Anfang zur�ckgehen
               IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ Text lesen
                  IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                     msgbox("Schreiben von *Neu.fpt klappt nicht")
                  ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                     neu->adresse := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
                  ENDIF
               ENDIF
            ELSE
               msgbox("M�ll im Adressfeld - wird ersetzt",dat->anummer+"/"+dat->abrechnr)
               cBuffer := Chr(0)+Chr(0)+Chr(0)+Chr(1)+Chr(0)+Chr(0)+Chr(0)+Chr(56)+ ;
                           "Zerst”rter Text wurde am " + ;
                           DtoC(DATE()) + "-" + Time() + "ersetzt."+Chr(0)+Chr(0)+Chr(0)+Chr(0)
               nBuffer := 64
               IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                  msgbox("Schreiben von *Neu.fpt klappt nicht")
               ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                  neu->adresse := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
               ENDIF
            ENDIF
         ENDIF
      ENDIF
      //+ Notizfeld kopieren
      nBuffer := Bin2U(dat->r_notiz)
      IF nBuffer > 0
         FSeek( nHandle, nBuffer*64 )
         cBuffer := Space(8) ; nBuffer := 8
         IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ erste 8 Byte lesen
            IF Left(cBuffer,4) == Chr(0)+Chr(0)+Chr(0)+Chr(1)
               nBuffer += Asc(cBuffer[8])+Asc(cBuffer[7])*256  //+ 8 plus L„nge des Textes
               IF nBuffer > 1024                               //+ Fehler entdeclen...
                  msgbox( "Bufferl„nge f�r Notiz: "+Str(nBuffer) ) //+ ...anzeigen...
                  nBuffer := 1000                              //+ ...und korrigieren
               ENDIF
               nBuffer := (Int(nBuffer/64)+1)*64   //+ ganze 64Byte-Bl”cke
               cBuffer := Space(nBuffer)           //+ Buffer einrichten
               FSeek( nHandle, -8, FS_RELATIVE )   //+ an den Anfang zur�ckgehen
               IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ Text lesen
                  IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                     msgbox("Schreiben von *Neu.fpt klappt nicht")
                  ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                     neu->r_notiz := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
                  ENDIF
               ENDIF
            ELSE
               msgbox("M�ll im Notizfeld - wird ersetzt",dat->anummer+"/"+dat->abrechnr)
               cBuffer := Chr(0)+Chr(0)+Chr(0)+Chr(1)+Chr(0)+Chr(0)+Chr(0)+Chr(56)+ ;
                           "Zerst”rter Text wurde am " + ;
                           DtoC(DATE()) + "-" + Time() + "ersetzt."+Chr(0)+Chr(0)+Chr(0)+Chr(0)
               nBuffer := 64
               IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                  msgbox("Schreiben von *Neu.fpt klappt nicht")
               ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                  neu->r_notiz := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
               ENDIF
            ENDIF
         ENDIF
      ENDIF
      //+ Bemerkungsfeld kopieren
      nBuffer := Bin2U(dat->r_bemerk)
      IF nBuffer > 0
         FSeek( nHandle, nBuffer*64 )
         cBuffer := Space(8) ; nBuffer := 8
         IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ erste 8 Byte lesen
            IF Left(cBuffer,4) == Chr(0)+Chr(0)+Chr(0)+Chr(1)
               nBuffer += Asc(cBuffer[8])+Asc(cBuffer[7])*256  //+ 8 plus L„nge des Textes
               IF nBuffer > 1024                               //+ Fehler entdeclen...
                  msgbox( "Bufferl„nge f�r Bemerkung: "+Str(nBuffer) ) //+ ...anzeigen...
                  nBuffer := 1000                              //+ ...und korrigieren
               ENDIF
               nBuffer := (Int(nBuffer/64)+1)*64   //+ ganze 64Byte-Bl”cke
               cBuffer := Space(nBuffer)           //+ Buffer einrichten
               FSeek( nHandle, -8, FS_RELATIVE )   //+ an den Anfang zur�ckgehen
               IF FRead( nHandle, @cBuffer, nBuffer ) == nBuffer  //+ Text lesen
                  IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                     msgbox("Schreiben von *Neu.fpt klappt nicht")
                  ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                     neu->r_bemerk := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
                  ENDIF
               ENDIF
            ELSE
               msgbox("M�ll im Bemerkungsfeld - wird ersetzt",dat->anummer+"/"+dat->abrechnr)
               cBuffer := Chr(0)+Chr(0)+Chr(0)+Chr(1)+Chr(0)+Chr(0)+Chr(0)+Chr(56)+ ;
                           "Zerst”rter Text wurde am " + ;
                           DtoC(DATE()) + "-" + Time() + "ersetzt."+Chr(0)+Chr(0)+Chr(0)+Chr(0)
               nBuffer := 64
               IF FWrite( nHandle2, cBuffer, nBuffer ) != nBuffer //+ Text in neue Datei schreiben
                  msgbox("Schreiben von *Neu.fpt klappt nicht")
               ELSE  //+ Textposition in neuer .FPT feststellen + in neue .DBF schreiben:
                  neu->r_bemerk := U2Bin(Int(FSeek( nHandle2, 0, FS_RELATIVE )-nBuffer)/64)
               ENDIF
            ENDIF
         ENDIF
      ENDIF
//      SELECT("dat")
      DbSkip()
   ENDDO
   
   neu->(DbCloseArea())
   dat->(DbCloseArea())
   FClose( nHandle )
   FClose( nHandle2 )
   
   //+ M-Felder wieder dazu machen (sie waren zwischendurch N-Felder)      
   nHandle := FOpen( cFile+"Neu.dbf", FO_READWRITE )
   cBuffer := Space(32) ; nBuffer := 32
   FOR i := 1 TO Len(aM)
      FSeek( nHandle, aM[i] )
      FWrite( nHandle, "M", 1 )
   NEXT
   FClose( nHandle )
   //+ M-Felder wieder dazu machen (sie waren zwischendurch N-Felder)      
   nHandle := FOpen( cFile+".dbf", FO_READWRITE )
   cBuffer := Space(32) ; nBuffer := 32
   FOR i := 1 TO Len(aM)
      FSeek( nHandle, aM[i] )
      FWrite( nHandle, "M", 1 )
   NEXT
   FClose( nHandle )

RETURN