applicat.cpp Il demo usa il prawin.ini e non prassis.ini

archives.*     Supporto pkzip
array.cpp      Sostituito items()-1 con last() in un ciclo
array.h        Aggiunte macro di iterazione


git-svn-id: svn://10.65.10.50/trunk@6575 c028cbd2-c16b-5b4b-a496-9718f37d4682

include/applicat.cpp

@@ -350,7 +350,7 @@ void TApplication::stop_run()
 #ifdef _DEMO_             
   {  
     const TString16 hname(encode("ORA"));
-    TConfig c(CONFIG_STUDIO, "Main");
+    TConfig c(CONFIG_INSTALL, "Main");
     real remaining_time(decode(c.get(hname)));
     if (name() != "ba0100")
     {

include/archives.cpp

@@ -1,18 +1,26 @@
 #include <direct.h>
-#include <al.h>         
 
+#if XVT_OS == XVT_OS_WIN
 #define XVT_INCL_NATIVE
 #define STRICT
+#endif
 
 #include <archives.h>
 #include <config.h>
+#include <defmask.h>
+#include <execp.h>
 #include <isam.h>
 #include <mask.h>
+#include <os_dep.h>
 #include <prefix.h> 
 #include <progind.h>
 #include <urldefid.h>
 #include <utility.h>
 
+#if XVT_OS == XVT_OS_WIN
+
+#include <al.h>         
+
 ///////////////////////////////////////////////////////////
 // TProgress_win declaration
 ///////////////////////////////////////////////////////////
@@ -32,6 +40,7 @@ public:
   ~TProgress_win();
 };
 
+#endif
 
 ///////////////////////////////////////////////////////////
 // TArchive
@@ -53,13 +62,15 @@ FILE* TArchive::ask_disk(
                             // @flag FALSE | Apre il file in scrittura
 {     
   TFilename prev(name);
-  prev.ext(format("%03d", disk-1));       // File precedente
+  TString16 ext; ext.format("%03d", disk-1);
+  prev.ext(ext);       // File precedente
   bool first = TRUE;
   do
   {                 
     if (first)
     {
-      message_box("Inserire il disco %d nel drive %c:", disk, floppy);
+      message_box("Inserire il disco %d nel drive %c:\n"
+                  "File %s", disk, floppy, (const char*)name);
       first = FALSE;
     }  
     else
@@ -71,7 +82,8 @@ FILE* TArchive::ask_disk(
     }
   } while (prev.exist());                 // Non facciamo i furbetti!
                                             
-  name.ext(format("%03d", disk));         // File attuale
+  ext.format("%03d", disk);
+  name.ext(ext);         // File attuale
   
   FILE* f = NULL;                                                           
   bool retry = TRUE;
@@ -108,14 +120,17 @@ int TArchive::build_backup_list(long firm, TString_array& fl) const
     TLocalisamfile ditte(LF_NDITTE);
     for (int err = ditte.first(); err == NOERR; err = ditte.next())
     {
-      const char* dir = firm2dir(ditte.get_long("CODDITTA"));
+      const long cod = ditte.get_long("CODDITTA");
-      if (fexist(dir))
+      if (prefix().exist(cod))
+      {
+        TFilename dir = firm2dir(cod);
         fl.add(dir);
+      }
     }  
     
     TFilename name(firm2dir(-1));     // __ptprf
     name.add("config");               // Aggiungi configurazioni
-    if (fexist(name))
+    if (name.exist())
       fl.add(name);                                                
   }
   else
@@ -169,7 +184,7 @@ int TArchive::build_restore_list(
 //
 // @rdesc Ritorna se e' riuscito a spezzare il file
 bool TArchive::fsplit(
-     const char* filename,    // @parm Nome del file da spezare
+     const char* filename,    // @parm Nome del file da spezzare
      char floppy,             // @parm Floppy su cui scaricare il file
      const char* desc) const  // @parm Descrizione dell'archivio
 {               
@@ -237,13 +252,14 @@ bool TArchive::fsplit(
         
         TConfig c(ini, parag);
         const char* oggi = TDate(TODAY).string();
-        c.set("Size", tot , NULL, TRUE); 
+        c.set("Size", tot); 
-        c.set("Disk", disk, NULL, TRUE);
+        c.set("Disk", disk);
-        c.set("Description", desc, NULL, TRUE);
+        c.set("Description", desc);
-        c.set("Date", oggi, NULL, TRUE);
+        c.set("Date", oggi);
         
         ok = (letti > 0) ? (fwrite((char*)(const char*)buffer, letti, 1, o) == 1) : TRUE;
-        if (!ok) error_box("Impossibile scrivere i dati sul dischetto");
+        if (!ok) 
+          error_box("Impossibile scrivere i dati sul dischetto");
         else 
           scritti +=letti;
       }  
@@ -312,7 +328,7 @@ bool TArchive::fbuild(
         if (disk == 1)
         {                                            
           TFilename ini("a:/backup.ini"); ini[0] = floppy;
-          if (fexist(ini)) 
+          if (ini.exist()) 
           {
             TFilename parag(name.name()); parag.ext("");
             TConfig c(ini, parag);
@@ -361,9 +377,7 @@ bool TArchive::fbuild(
 bool TArchive::backup(
      const char* dir,  // @parm Directory di cui effettuare il backup
      char floppy,      // @parm Floppy su cui effettuare il backup
-     const char* desc, // @parm Descrizione da assegnare al backup
+     const char* desc) // @parm Descrizione da assegnare al backup
-     bool pr_set)      // @parm Se TRUE setta il prefix come vuoto (default TRUE)
-                       // @parm long | firm | Ditta di cui effettuare il backup
                        
 // @syntax bool backup(const char* dir, char floppy, const char* desc, bool pr_set);
 // @syntax bool backup(long firm, char floppy, const char* desc, bool pr_set);
@@ -372,8 +386,7 @@ bool TArchive::backup(
 
 {                                      
   const TString16 old(prefix().name());
-  if (pr_set)
+  prefix().set(NULL);
-    prefix().set(NULL);
   
   xvt_fsys_save_dir();
   chdir(dir);
@@ -404,13 +417,12 @@ bool TArchive::backup(
   
   remove(work);
   xvt_fsys_restore_dir();
-  if (pr_set)
+  prefix().set(old);
-    prefix().set(old);
   
   return ok;
 }
 
-bool TArchive::backup(long firm, char floppy, const char* desc, bool pr_set)
+bool TArchive::backup(long firm, char floppy, const char* desc)
 {                     
   TString_array fl;
   const int num_ditte = build_backup_list(firm, fl);
@@ -418,7 +430,7 @@ bool TArchive::backup(long firm, char floppy, const char* desc, bool pr_set)
   bool ok = TRUE;
   for (int f = 0; f < num_ditte; f++)
   {                                  
-    ok = backup(fl.row(f), floppy, desc, pr_set);
+    ok = backup(fl.row(f), floppy, desc);
     if (!ok) break;
   }
   
@@ -433,14 +445,11 @@ bool TArchive::backup(long firm, char floppy, const char* desc, bool pr_set)
 bool TArchive::restore(
      const char* dir,   // @parm Directory di cui effettuare il restore
      char floppy,       // @parm Floppy da cui leggere i dati
-     bool tmp,          // @parm Directory temporanea da utilizzare
+     bool tmp)          // @parm Directory temporanea da utilizzare
-     bool pr_set)       // @parm Se TRUE setta il prefix come vuoto (default TRUE)
      
 // @syntax bool restore(const char* dir, char floppy, bool temp, bool pr_set);
 // @syntax bool restore(long firm, char floppy, bool temp, bool pr_set);
 
-// @comm Il parametro <p pr_set> e' utilizzato per evitare errori di riaperture di files.
-
 {                 
   TFilename work;
   if (tmp) 
@@ -470,8 +479,7 @@ bool TArchive::restore(
   }  
 
   const TString16 old(prefix().name());
-  if(pr_set)
+  prefix().set(NULL);
-    prefix().set(NULL);
   
   ok = fbuild(output, floppy);
 
@@ -518,13 +526,12 @@ bool TArchive::restore(
   }
   
   xvt_fsys_restore_dir();
-  if(pr_set)
+  prefix().set(old);
-    prefix().set(old);
 
   return ok;
 }
 
-bool TArchive::restore(long firm, char floppy, bool temp, bool pr_set)
+bool TArchive::restore(long firm, char floppy, bool temp)
 {
   TString_array fl;
   const int num_ditte = build_restore_list(firm, floppy, fl);
@@ -532,12 +539,14 @@ bool TArchive::restore(long firm, char floppy, bool temp, bool pr_set)
   bool ok = TRUE;
   for (int f = 0; f < num_ditte; f++)
   {                                  
-    ok = restore(fl.row(f), floppy, temp, pr_set);
+    ok = restore(fl.row(f), floppy, temp);
     if (!ok) break;
   }
   return ok;  
 }
 
+#if XVT_OS == XVT_OS_WIN
+
 void TArchive::stop_job()
 {
   if (_arc != NULL)
@@ -560,11 +569,9 @@ TProgress_win::TProgress_win(const char* title, TArchive* arc)
   add_button(DLG_USER, 0, "Cancel", -11, -1, 10, 2, "", BMP_CANCEL); 
   set_handler(DLG_USER, cancel_handler);
 
-#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_WIN32
   HWND txt = (HWND)xvt_vobj_get_attr(wtxt, ATTR_NATIVE_WINDOW);
   HWND num = (HWND)xvt_vobj_get_attr(wnum, ATTR_NATIVE_WINDOW);
   _monitor = new ALWindowsMessage(AL_MONITOR_OBJECTS, txt, AL_SEND_RATIO, num);
-#endif                      
 }                   
 
 TProgress_win::~TProgress_win()
@@ -583,4 +590,353 @@ bool TProgress_win::cancel_handler(TMask_field& f, KEY k)
   return TRUE;
 }
 
+#endif                      
 
+bool TArchive::move_file(const TFilename& file, const char* dir) const
+{
+  TFilename dest(dir);
+  dest.add(file.name());
+  
+  long filesize = ::fsize(file);
+  filesize -= ::fsize(dest);
+  
+  bool space_ok = filesize <= 0;
+  while (!space_ok)
+  {
+    space_ok = ::os_test_disk_free_space(dest, filesize);
+    if (!space_ok)
+    {
+      TString msg(128);
+      msg << "Lo spazio sull'unita' e' insufficiente:\n";
+      if (::os_is_removable_drive(dest))
+        msg << "Inserire un nuovo disco e ritentare?";
+      else                                               
+        msg << "Liberare dello spazio e ritentare?";
+      if (!yesno_box(msg))
+        return FALSE;
+    }  
+  }  
+
+  bool write_ok = TRUE;
+  bool user_abort = FALSE;
+  do
+  {
+    write_ok = ::fcopy(file, dest);
+    if (write_ok) 
+      ::remove(file);  
+    else
+    {
+      if (!yesno_box("Errore di copia del file %s.\nSi desidera riprovare?",
+                     (const char*)file))
+        user_abort = TRUE;
+    }    
+  } while (!write_ok && !user_abort);
+    
+  return write_ok;
+}
+
+bool TArchive::fsplit_zip(
+     const char* filename,    // @parm Nome del file da spezzare
+     char floppy,             // @parm Floppy su cui scaricare il file
+     const char* desc) const  // @parm Descrizione dell'archivio
+{                  
+  const TFilename archive(filename);
+                    
+  unsigned long size = 0;                  
+  TFilename path; path << floppy << ':';
+  
+  while (size <= 0)
+  {
+    message_box("Inserire il disco 1 nel drive %c:", floppy);
+    size = os_get_disk_size(path) - (64L*1024L);
+    if (size <= 0)
+    {
+      if (!yesno_box("Errore di accesso al drive %c\nSi desidera ritentare?", floppy))
+        return FALSE;
+    }
+    do_events();
+  } 
+
+  const long minsize = 360*1024L;
+  if (size < minsize)
+    size = minsize;
+  
+  // Costruisce percorso dello splitter
+  TFilename cmd("zipsplit.pif");     
+  cmd << " -n " << (long)size << " -b " << archive.path() << ' ' << archive;
+    
+  // Esegue lo splitter nella directory temporanea
+  TExternal_app app(cmd);
+  int err = app.run(FALSE, FALSE, FALSE, FALSE);
+
+  if (err != NOERR)
+    return error_box("Errore %d durante lo splitting del file %s",
+                     err, (const char*)archive);
+  
+  size = ::fsize(archive);
+  ::remove(archive);
+
+  for (int d = 1; ; d++)
+  {            
+    TFilename src(archive);
+    src.ext("");
+    src << d;
+    src.ext("zip");
+    if (src.exist())
+    {            
+      if (d > 1)
+      {
+        message_box("Inserire il disco %d nel drive %c:", d, floppy);
+        do_events();
+      }
+    
+      if (move_file(src, path))
+      {
+        TFilename ini(path);
+        ini.add("backup.ini");
+        TConfig c(ini, archive.name());
+        c.set("Size", size); 
+        c.set("Disk", d);
+        c.set("Description", desc);
+        c.set("Date", TDate(TODAY).string());
+      }
+      else
+        break;
+    } 
+    else
+      break;
+  }  
+                                                            
+  return TRUE;                                                          
+}
+
+const char* const file[] = { "zip.pif", "zip386.bat", "zip386.exe", "ziplist.txt", NULL };
+
+bool TArchive::copy_zipper(const char* dir) const
+{           
+  bool ok = TRUE;
+  TFilename dest;
+  for (int f = 0; ok && file[f]; f++)
+  {                           
+    dest = dir;
+    dest.add(file[f]);
+    ok &= ::fcopy(file[f], dest);
+  } 
+  return ok;
+}
+
+bool TArchive::remove_zipper(const char* dir) const
+{           
+  TFilename dest;
+  for (int f = 0; file[f]; f++)
+  {                           
+    dest = dir;
+    dest.add(file[f]);
+    ::remove(dest);
+  } 
+  return TRUE;
+}
+
+void TArchive::add_zipper_list(TString& str) const
+{
+  for (int f = 0; file[f]; f++)
+    str << ' ' << file[f];
+}
+
+
+// @doc EXTERNAL
+
+// @mfunc Effettua il backup della directory
+//
+// @rdesc Ritorna il risultato dell'operazione
+bool TArchive::zip(
+     const char* dir,  // @parm Directory di cui effettuare il backup
+     char floppy,      // @parm Floppy su cui effettuare il backup
+     const char* desc) // @parm Descrizione da assegnare al backup
+                       // @parm long | firm | Ditta di cui effettuare il backup
+                       
+// @syntax bool backup(const char* dir, char floppy, const char* desc, bool pr_set);
+// @syntax bool backup(long firm, char floppy, const char* desc, bool pr_set);
+
+// @comm Il parametro <p pr_set> e' utilizzato per evitare errori di riaperture di files.
+
+{                                      
+  const TString16 old(prefix().name());
+  prefix().set(NULL);
+                  
+  const TFilename workdir(dir);
+    
+  TString16 name(workdir.name());
+  // Trasforma com in datcom altrimenti lo splitter lo trasforma in com1 e com2!
+  if (name.compare("com", -1, TRUE) == 0)
+    name = "datcom";
+  
+  // Nome del file compresso
+  TFilename work; work.tempdir(); work.add(name); work.ext("zip");
+
+  TString title("Archiviazione di "); title << workdir;
+  TIndwin waitw(100,title,FALSE,FALSE); 
+  TWait_cursor hourglass;
+  
+  // Crea il file con la lista dei file da comprimere
+  const char* const ZIPLIST = "ziplist.txt";
+  FILE* flist = fopen(ZIPLIST, "w");
+  fprintf(flist, "*.*");
+  fclose(flist);
+  
+  copy_zipper(workdir);
+  
+  // Esegui lo zippatore
+  TFilename cmd = workdir; 
+  cmd.add("zip.pif");
+  cmd << ' ' << work << ' ' << ZIPLIST << " -D -r";
+  
+  TExternal_app zipapp(cmd);
+  int err = zipapp.run(FALSE, FALSE, FALSE, FALSE);
+
+  // Elimina files temporanei dallo zip
+/*  
+  cmd = workdir; 
+  cmd.add("zip386.exe");
+  cmd << ' ' << work << " -d";
+  add_zipper_list(cmd);
+  TExternal_app zipdel(cmd);
+  zipdel.run(FALSE, FALSE, FALSE, FALSE);
+*/  
+  
+  // Elimina i file temporanei dalla directory
+  remove_zipper(workdir);
+  
+  // Splitta su floppy
+  bool ok = err == 0;
+  if (ok)
+    ok = fsplit_zip(work, floppy, desc);
+  else  
+    error_box("Compressione degli archivi errata o incompleta");
+
+  prefix().set(old);
+  
+  return ok;
+}
+
+bool TArchive::zip(long firm, char floppy, const char* desc)
+{                     
+  TString_array fl;
+  const int num_ditte = build_backup_list(firm, fl);
+  
+  bool ok = TRUE;
+  for (int f = 0; f < num_ditte; f++)
+  {                                  
+    ok = zip(fl.row(f), floppy, desc);
+    if (!ok) break;
+  }
+  
+  return ok;  
+}
+
+// @doc EXTERNAL
+
+// @mfunc Effettua il restore della directory
+//
+// @rdesc Ritorna il risultato dell'operazione
+bool TArchive::unzip(
+     const char* dir,   // @parm Directory di cui effettuare il restore
+     char floppy,       // @parm Floppy da cui leggere i dati
+     bool tmp)          // @parm Directory temporanea da utilizzare
+// @syntax bool restore(const char* dir, char floppy, bool temp, bool pr_set);
+// @syntax bool restore(long firm, char floppy, bool temp, bool pr_set);
+// @comm Il parametro <p pr_set> e' utilizzato per evitare errori di riaperture di files.
+{                 
+  TFilename work;
+  if (tmp) 
+    work.tempdir();
+  else 
+    work = dir;
+  
+  TFilename output(dir); 
+  output = output.name(); 
+  if (output.compare("com", -1, TRUE) == 0)
+    output = "datcom";
+  output.ext("zip");
+
+  if (!yesno_box("Attenzione l'archivio %c:%s verra' ripristinato\n"
+                 "nel direttorio %s. Continuare?", 
+                 floppy, (const char*)output, (const char*)work))
+    return FALSE;             
+  
+  bool ok = work.exist();
+  if (!ok) 
+  {
+    ok = yesno_box("Non esiste il direttorio %s: si desidera crearlo?", (const char*)work);
+    if (ok) 
+    {
+      make_dir(work);
+      ok = work.exist();
+    }  
+    if (!ok)
+      return error_box("Impossibile accedere a %s", (const char*)work);
+  }  
+  
+  TString title("Ripristino di "); title << output;
+  TIndwin waitw(100,title,FALSE,FALSE); 
+
+  const TString16 old(prefix().name());
+  prefix().set(NULL);
+  
+  TFilename cfg;
+  cfg << floppy << ':';
+  cfg.add("backup.ini");
+  TConfig c(cfg, output.name());
+  long total_size = c.get_long("Size");
+  long read_size = 0;
+  for (int d = 1; read_size < total_size; d++)
+  {
+    TFilename src;
+    src << floppy << ':' << SLASH << output.name();
+    src.ext("");
+    src << d << ".zip";
+    
+    message_box("Inserire il disco %d contenente il file %s", d, (const char*)src);
+    while (!src.exist())
+    {
+      if (!yesno_box("Impossibile aprire il file %s:\nSi desidera ritentare?", 
+                     (const char *)src))
+        break;
+    }
+    
+    if (src.exist())
+    {
+      TFilename cmd;
+      cmd << "unzip.pif -o " << src << " -d " << work;
+      TExternal_app app(cmd);
+      int err = app.run(FALSE, FALSE, FALSE, FALSE);
+      if (err == 0)
+        read_size += ::fsize(src);
+      else    
+      {
+        error_box("Errore %d durante il ripristino del file %s", err, (const char*)src);
+        break;  
+      }
+    }
+    else
+      break;
+  }
+  
+  prefix().set(old);
+
+  return ok;
+}
+
+bool TArchive::unzip(long firm, char floppy, bool temp)
+{
+  TString_array fl;
+  const int num_ditte = build_restore_list(firm, floppy, fl);
+  
+  bool ok = TRUE;
+  for (int f = 0; f < num_ditte; f++)
+  {                                  
+    ok = unzip(fl.row(f), floppy, temp);
+    if (!ok) break;
+  }
+  return ok;  
+}

include/archives.h

@@ -33,16 +33,21 @@ class TArchive : public TObject
 
 // @access Protected Member
 protected:
-  // @cmember NON IMPLEMENTATA
-  KEY query() const;
   // @cmember Funzione per richiedere all'utente il dischetto e per controllare la
-  //					corretta sequenza dei dischetti da inserire
+  //          corretta sequenza dei dischetti da inserire
   FILE* ask_disk(TFilename& name, int disk, char floppy, bool lettura) const;
   
   // @cmember Ritorna la dimensione del file <p f>
   long fsize(FILE* f) const;         
+             
+  // @cmember Sposta il file nella directory dir
+  bool move_file(const TFilename& file, const char* dir) const;
+                   
   // @cmember Spezza il file in modo da farlo stare sul dischetto
   bool fsplit(const char* filename, char floppy, const char* desc = "") const;
+  // @cmember Spezza il file.zip in modo da farlo stare sul dischetto
+  bool fsplit_zip(const char* filename, char floppy, const char* desc = "") const;
+
   // @cmember Ricostruisce il file spezzato
   bool fbuild(const char* filename, char floppy) const;
   
@@ -51,20 +56,37 @@ protected:
   // @cmember Costruisce la lista delle directory da scompattare
   int build_restore_list(long firm, char floppy, TString_array& fl) const;
   
+  bool copy_zipper(const char* dir) const;
+  bool remove_zipper(const char* dir) const;
+  void add_zipper_list(TString& str) const;
+
 // @access Public Member
 public:   
   // @cmember Effettua il backup della directory
-  bool backup(const char* dir, char floppy, const char* desc, bool pr_set=TRUE);
+  bool backup(const char* dir, char floppy, const char* desc);
   // @cmember Effettua il backup della ditta
-  bool backup(long firm, char floppy, const char* desc, bool pr_set=TRUE);
+  bool backup(long firm, char floppy, const char* desc);
 
   // @cmember Effettua il restore della directory
-  bool restore(const char* dir, char floppy, bool temp, bool pr_set=TRUE);
+  bool restore(const char* dir, char floppy, bool temp);
   // @cmember Effettua il restore della ditta
-  bool restore(long firm, char floppy, bool temp, bool pr_set=TRUE);
+  bool restore(long firm, char floppy, bool temp);
 
   // @cmember Interrompe le operazioni
   void stop_job();
+  
+  // @cmember Effettua il backup della directory
+  bool zip(const char* dir, char floppy, const char* desc);
+  // @cmember Effettua il backup della ditta
+  bool zip(long firm, char floppy, const char* desc);
+
+  // @cmember Effettua il restore della directory
+  bool unzip(const char* dir, char floppy, bool temp);
+  // @cmember Effettua il restore della ditta
+  bool unzip(long firm, char floppy, bool temp);
+
+  TArchive() { }
+  virtual ~TArchive() { }
 };           
 
 #endif            

include/array.cpp

@@ -163,7 +163,7 @@ bool TArray::destroy(
 
   if (index < 0)
   {
-    for (int i = size()-1; i >= 0; i--) if (_data[i] != NULL)
+    for (int i = last(); i >= 0; i--) if (_data[i] != NULL)
     {
       delete _data[i];
       _data[i] = NULL;

include/array.h

@@ -203,6 +203,19 @@ inline TObject& TArray::operator[] (int index) const
 }
 #endif
 
+#define FOR_EACH_ARRAY_ITEM(__arr, __r, __obj)      \
+  TObject* __obj;                                   \
+  for (int __r = __arr.first();                     \
+       __obj = __arr.objptr(__r);                   \
+       __r = __arr.succ(__r))
+
+#define FOR_EACH_ARRAY_ITEM_BACK(__arr, __r, __obj) \
+  TObject* __obj;                                   \
+  for (int __r = __arr.last();                      \
+       __obj = __arr.objptr(__r);                   \
+       __r = __arr.pred(__r))
+
+
 class TPointer_array : public TArray
 {
 public:
@@ -213,6 +226,7 @@ public:
   virtual TPointer_array& operator= (const TArray& a);
   
   long get_long(int index) const { return (long)objptr(index); }
+  int get_int(int index) const { return (int)get_long(index); }
   int add_long(long value, int index = -1) { return add((TObject*)value, index); }
   int insert_long(long value, int index = -1) { return TArray::insert((TObject*)value, index, TRUE); }