Changeset 1475 for trunk

Timestamp:

2000-08-31T00:42:59+12:00 (24 years ago)

Author:

cs025

Message:

Updated sources with most of uninstall added

Location:

trunk/gsinstaller

Files:

• FilePath.cpp (modified) (1 diff)
• configFile.cpp (modified) (6 diffs)
• configFile.h (modified) (3 diffs)
• copyProgress.cpp (modified) (2 diffs)
• fileCopier.cpp (modified) (9 diffs)
• fileCopier.h (modified) (3 diffs)
• gsManifest.cpp (modified) (8 diffs)
• gsManifest.h (modified) (2 diffs)
• gsProfile.cpp (modified) (4 diffs)
• gsProfile.h (modified) (1 diff)
• gsProgman.cpp (modified) (14 diffs)
• gsProgman.h (modified) (3 diffs)
• gsRegistry.cpp (modified) (2 diffs)
• gsRegistry.h (modified) (1 diff)
• gsinstall.cpp (modified) (27 diffs)
• install.cfg (modified) (1 diff)
• manifest.cfg (modified) (1 diff)
• registry.cpp (modified) (3 diffs)
• registry.h (modified) (1 diff)
• stringArray.cpp (modified) (1 diff)
• stringArray.h (modified) (1 diff)
• unInstall.cpp (modified) (1 diff)
• unInstall.h (modified) (2 diffs)

trunk/gsinstaller/FilePath.cpp

@@ -103 +103 @@
   this->path = filePath;
 
-  // if it didn't have a concluding divider, then add one
-  if (this->path[filePath.length()-1] != divider)
+  // if it didn't have a concluding divider, then add one; note that if
+  // filePath is empty, we're not actually going to add any divider at
+  // all
+  if (filePath.length() > 0 &&
+      this->path[filePath.length()-1] != divider)
   { this->path.append(dividerStr);
   }

trunk/gsinstaller/configFile.cpp

@@ -43 +43 @@
   space -= strlen(configstr->item[loop].data);
   return true;
+}
+
+string configureFile::getString(string label)
+{   for (int loop = 0; loop < configstr->count; loop ++)
+    {   if (strcmp(configstr->item[loop].label, label.c_str()) == 0)
+    { return configstr->item[loop].data;
+    }
+  }
+  return "";
 }
 
@@ -88 +97 @@
 }
 
-bool configureFile::scan(char *block, unsigned int &pos)
+/**
+ * Scan one line of the configuration file
+ */
+bool configureFile::scan(char *block, unsigned int &pos, unsigned int length)
 { int off = 0;
     void *newstr;
 
+  if (pos == length)
+  { return true;
+  }
+
+    // if it's a comment line, skip it straightaway
+  if (block[pos] == '#')
+  { while (block[pos] >= ' ')
+    {   block ++;
+    }
+    while (block[pos] < ' ')
+    {   block ++;
+        if (block[pos-1] == '\0')
+      { break;
+      }
+    }
+    return true;
+  }
+
+  // otherwise create a new struct to cope with the list of configuration items
   newstr = realloc(configstr, sizeof(config_str) +
                               sizeof(config_item) * configstr->count);
@@ -101 +132 @@
   configstr = (config_str *) newstr;
 
-  while (block[pos] != ':')
+  // scan to the colon to get the label
+  while (pos < length && block[pos] != ':')
   { configstr->item[configstr->count].label[off] = block[pos];
     off ++;
@@ -108 +140 @@
   configstr->item[configstr->count].label[off] = '\0';
 
+  // read until we get past any leading whitespace or tabs
   off = 0;
-  do
-  { pos ++;
-  } while (block[pos] <= ' ' && block[pos] != '\x0a' && block[pos] != '\x0d');
-
-  while(block[pos] >= ' ')
+  if (pos < length)
+  { do
+    {   pos ++;
+    }
+    while (block[pos] <= ' ' && block[pos] != '\x0a' && block[pos] != '\x0d');
+  }
+
+  // read until we reach a "magic" character - this is where we read the value
+  while(pos < length && block[pos] >= ' ')
   { configstr->item[configstr->count].data[off] = block[pos];
     pos ++;
@@ -120 +157 @@
   configstr->item[configstr->count].data[off] = '\0';
 
-  do
-  { pos ++;
-  }
-    while (block[pos] <= ' ');
-
+  // skip any magic characters
+  if (pos < length)
+  { do
+    { pos ++;
+    }
+      while (block[pos] <= ' ' && pos < length);
+  }
+
+  // remember that we've added to the list
   configstr->count ++;
   return true;
@@ -190 +231 @@
     position    = 0;
     while (position < length)
-    { this->scan(block, position);
+    { this->scan(block, position, length);
     }
 
     fclose(fhandle);
+
+      free(block);
+
+      this->valid = true;
   }
   else
   { // No config file MessageBox(0, "oops", "oops", MB_OK);
-  }
-
-  free(block);
+    this->valid = false;
+  }
 //Acorn:  free(varval);
 
-  this->valid = true;
 }
 

trunk/gsinstaller/configFile.h

@@ -1 +1 @@
 #ifndef _CONFIG_H_
 #define _CONFIG_H_
+#include <string>
+using namespace std;
+
 #include <stdio.h>
 #include <string.h>
@@ -22 +25 @@
     bool valid;
 
-    bool scan(char *buffer, unsigned int &pos);
+    bool scan(char *buffer, unsigned int &pos, unsigned int length);
     public:
     configureFile(char *name);
@@ -28 +31 @@
     bool put(char *label, char *value);
     bool concat(char *label, char *buffer, unsigned int &space);
+    string getString(string label);
     void get(char *label, char **to);
     bool store(char *);

trunk/gsinstaller/copyProgress.cpp

@@ -7 +7 @@
 
 extern HINSTANCE app_instance;
+extern gsInstall_getDesktopExt(int *x, int *y);
 
 LRESULT CALLBACK copyProgressBar_windowProc(    HWND window, UINT message,
@@ -85 +86 @@
 void copyProgressBar::show()
 { long params[2];
+  int sx, sy, dx, dy;
 
     params[0] = (long) this;
   params[1] = (long) "Copying files....";
   this->registerClass();
-    this->progressParent    = CreateWindowEx(WS_EX_APPWINDOW, "CopyProgressBar", "GreenStone Installer", WS_VISIBLE,
-                                                                         CW_USEDEFAULT, CW_USEDEFAULT, 200, 80, 0, (HMENU) 0,
-                                         app_instance, (void *) params);
+
+  gsInstall_getDesktopExt(&sx, &sy);
+
+  dx = (sx - 200) >> 1;
+  dy = (sy - 80) >> 1;
+
+    this->progressParent    = CreateWindowEx(   WS_EX_APPWINDOW, "CopyProgressBar",
+                                                                                "GreenStone Installer", WS_VISIBLE,
+                                                                                    dx, dy, 200, 80,
+                                          0, (HMENU) 0,
+                                                    app_instance, (void *) params);
     this->progressBar   = CreateWindowEx(0, PROGRESS_CLASS, NULL, WS_CHILD | WS_VISIBLE,
-                                                                         10, 30, 180, GetSystemMetrics(SM_CYVSCROLL), this->progressParent, (HMENU) 0,
+                                                                         10, 30, 180, GetSystemMetrics(SM_CYVSCROLL),
+                                     this->progressParent, (HMENU) 0,
                                          app_instance, NULL);
 }

trunk/gsinstaller/fileCopier.cpp

@@ -14 +14 @@
     this->sourceDir = from;
   this->destDir     = to;
+  this->dataSize    = 0;
 
     FileVector::iterator here   = files.begin();
@@ -43 +44 @@
  * Copy a particular file to its destination
  */
-bool fileCopySet::copyFile(File *file, copyProgressBar &progressBar)
+bool fileCopySet::copyFile(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar)
 { unsigned long copied = 0;
     unsigned long bytes_read, bytes_written;
@@ -89 +90 @@
 
   // free destination filename text
+  if (monitor != NULL)
+  { monitor->copied(file->getFileName(), destination, false);
+  }
   delete destination;
   return true;
@@ -97 +101 @@
  *  destination
  */
-void fileCopySet::copy(File *file, copyProgressBar &progressBar)
+void fileCopySet::copy(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar)
 { // just skip this file if it doesn't exist
     if (file->exists() == false)
@@ -116 +120 @@
     vector<File>::iterator end  = file->childEnd();
     while (here != end)
-    {   this->copy(here, progressBar);
+    {   this->copy(here, monitor, progressBar);
         here ++;
     }
+
+      if (monitor != NULL)
+    {   monitor->copied(file->getFileName(), thisDestDir, true);
+    }
 
     // delete constructed destination name
@@ -126 +134 @@
   else
   { // copy file itself
-    this->copyFile(file, progressBar);
+    this->copyFile(file, monitor, progressBar);
   }
   progressBar.done(file->getRawFileSize());
 }
 
-void fileCopySet::copy(copyProgressBar &progressBar)
+void fileCopySet::copy(fileCopyMonitor *monitor, copyProgressBar &progressBar)
 {   FileVector::iterator here = fileList.begin();
     FileVector::iterator end    = fileList.end();
 
   while (here != end)
-  { this->copy(here, progressBar);
+  { this->copy(here, monitor, progressBar);
     here ++;
   }
@@ -173 +181 @@
 
     // get destination root and use it to obtain space check information
-    char buffer[120];
         FilePath *destRoot = localSet[0].destDir.root();
-    strcpy(buffer, destRoot->cString());
-    MessageBox(0, buffer, "A", MB_OK);
         DiskSpace space(destRoot->cString());
 
@@ -230 +235 @@
 }
 
-fileCopier::fileCopier(fileCopySetList &_list)
+fileCopier::fileCopier(fileCopyMonitor *monitor, fileCopySetList &_list)
 {   this->list  = _list;
   this->dataSize    = 0;
   this->copied      = 0;
-}
-
-fileCopier::fileCopier()
+  this->monitor     = monitor;
+}
+
+fileCopier::fileCopier(fileCopyMonitor *monitor)
 { this->dataSize    = 0;
   this->copied      = 0;
+  this->monitor     = monitor;
 }
 
@@ -247 +254 @@
   this->progressBar.show();
   while (here != end)
-  { here->copy(this->progressBar);
+  { here->copy(this->monitor, this->progressBar);
     here ++;
   }

trunk/gsinstaller/fileCopier.h

@@ -4 +4 @@
 #include "copyProgress.h"
 #include "diskSpace.h"
+
+class fileCopyMonitor
+{   public:
+        fileCopyMonitor() {};
+        virtual void copied(string from, string to, bool isDir) = 0;
+};
 
 class fileCopySet
@@ -17 +23 @@
     unsigned long getOriginalSize();
     unsigned long getCopiedSize(DiskSpace &space);
-    bool copyFile(File *file, copyProgressBar &progressBar);
-    void copy(File *file, copyProgressBar &progressBar);
-    void copy(copyProgressBar &progressBar);
+    bool copyFile(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+    void copy(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+    void copy(fileCopyMonitor *monitor, copyProgressBar &progressBar);
 };
 
@@ -30 +36 @@
     unsigned long   copied;
       copyProgressBar progressBar;
+    fileCopyMonitor *monitor;
     protected:
   public:
-    fileCopier::fileCopier(fileCopySetList &list);
-    fileCopier::fileCopier();
+    fileCopier::fileCopier(fileCopyMonitor *monitor, fileCopySetList &list);
+    fileCopier::fileCopier(fileCopyMonitor *monitor);
     void fileCopier::addSet(fileCopySet &set) { this->list.push_back(set); }
     bool checkSpace();

trunk/gsinstaller/gsManifest.cpp

@@ -1 +1 @@
 #include "gsManifest.h"
-#include "fileCopier.h"
 
 #include <string.h>
@@ -7 +6 @@
 #include <windows.h>
 
-gsManifest::gsManifest(FilePath &root)
+gsManifest::gsManifest(installManager &manager)
+  : installAgent(manager)
+{   // do nothing!
+}
+
+gsManifest::gsManifest(installManager &manager, FilePath &root)
+  : installAgent(manager), fileCopyMonitor()
 {   this->getManifest(root);
     this->expandGroups();
@@ -87 +92 @@
     group = newgroup;
   }
+  // if it starts with a hash it's just a comment line; skip it
+  else if (*line == '#')
+  { // do nothing!
+  }
+  // an actual line of member items; read them in
   else
   { stringArray array;
@@ -186 +196 @@
 }
 
-void gsManifest::selectGroup(string &groupName, FilePath &destination)
+void gsManifest::selectGroup(string groupName, FilePath &destination)
 { stringArray &groupArray = this->manifests[groupName];
 
@@ -193 +203 @@
 }
 
+/**
+ * Copy the manifest
+ */
 bool gsManifest::copy(FilePath *source)
-{ fileCopier    copy;
+{ fileCopier    copy(this);
 
     pathStringArrayMap::iterator here = this->selected.begin();
   pathStringArrayMap::iterator end  = this->selected.end();
 
+  // add all the sets to copy to the manifest
   while (here != end)
   { FileVector *fileList;
@@ -205 +219 @@
 
     // TODO: eliminate inefficiency; we're doing FilePath->string->FilePath in
-    // effect between constructing the copy lists, and then the sets as far
+    // effect between constructing the copy lists, and then the sets, as far
     // as the destinations go
-    fileList = this->selection(array);
+    fileList = this->selection(*source, array);
     fileCopySet copySet(*fileList, *source, path);
     copy.addSet(copySet);
@@ -214 +228 @@
   }
 
+  // check that we've got enough space @ the destination(s)
   if (!copy.checkSpace())
   { return false;
   }
+
+  // do the actual copying
   copy.copy();
   return true;
 }
 
-FileVector *gsManifest::selection(stringArray &array)
+void gsManifest::copied(string from, string to, bool isDir)
+{ if (isDir)
+    {   this->logAction("Manifest.CreateDir", to);
+    }
+  else
+  { this->logAction("Manifest.CopyFile", from, to);
+  }
+}
+
+void gsManifest::logAction(string actionName, string file)
+{   manager->writeString(actionName);
+    manager->writeSeparator();
+  manager->writeString(file);
+  manager->writeString("\n");
+}
+
+void gsManifest::logAction(string actionName, string source, string dest)
+{   manager->writeString(actionName);
+    manager->writeSeparator();
+  manager->writeString(source);
+    manager->writeSeparator();
+  manager->writeString(dest);
+  manager->writeString("\n");
+}
+
+bool gsManifest::undoAction(string actionName, stringArray &params)
+{   if (actionName == "Manifest.CreateDir" || actionName == "CreateDir")
+    {   RemoveDirectory(params[0].c_str());
+      return true;
+  }
+  else if (actionName == "Manifest.CopyFile" || actionName == "CopyFile")
+    {   DeleteFile(params[1].c_str());
+    return true;
+  }
+  return false;
+}
+
+FileVector *gsManifest::selection(FilePath &root, stringArray &array)
 {   FileVector *reply = new FileVector();
 
   for (unsigned int i = 0; i < array.size(); i++)
-  { File file(array[i]);
+  { FilePath    fileName(root.pathString(), array[i]);
+    File file(fileName.pathString());
     reply->push_back(file);
   }
@@ -231 +286 @@
 }
 
-FileVector *gsManifest::selection(FilePath &destination)
-{   return this->selection(this->selected[destination]);
-}
-
+FileVector *gsManifest::selection(FilePath &source, FilePath &destination)
+{   return this->selection(source, this->selected[destination]);
+}
+

trunk/gsinstaller/gsManifest.h

@@ -6 +6 @@
 #include "File.h"
 #include "FilePath.h"
+#include "FileCopier.h"
 #include "stringArray.h"
+#include "uninstall.h"
 
 typedef map<FilePath, stringArray, less<FilePath> > pathStringArrayMap;
 
-class gsManifest
+class gsManifest : public installAgent, fileCopyMonitor
 {   private:
     protected:
         strArrayMap                 manifests;
     pathStringArrayMap  selected;
+
+    bool getManifestLine(char *line, string &macro);
   public:
-    gsManifest(FilePath &path);
+    gsManifest(installManager &manager, FilePath &path); // used for install
+    gsManifest(installManager &manager); // used for uninstall
     bool getManifest(FilePath &path);
-    bool getManifestLine(char *line, string &macro);
+    void logAction(string actionName, string file);
+    void logAction(string actionName, string source, string dest);
+    bool undoAction(string actionName, stringArray &params);
     void expandGroupInstance(string parent, string child);
     void expandGroup(string &group);
@@ -26 +33 @@
     void clearSelection();
     bool copy(FilePath *source);
-    void selectGroup(string &groupName, FilePath &destination);
-    FileVector *selection(stringArray &array);
-    FileVector *selection(FilePath &destination);
+    void selectGroup(string groupName, FilePath &destination);
+    FileVector *selection(FilePath &source, stringArray &array);
+    FileVector *selection(FilePath &source, FilePath &destination);
     bool selectCheckSpace();
+
+    void copied(string from, string to, bool isDir); // from fileCopyMonitor
 };
 #endif;

trunk/gsinstaller/gsProfile.cpp

@@ -2 +2 @@
 
 #include <stdio.h>
-#include "stringArray.h"
 
-gsProfile::gsProfile(const char *fileName)
+gsProfile::gsProfile(installManager &manager, string fileName)
+  : installAgent(manager)
 {   this->fileName  = fileName;
 }
 
-bool gsProfile::ensureListMember(const char *sectionName, const char *listName,
-                                                                    const char *listMember)
+void gsProfile::logAction(string action, string sectionName, string item,
+                                                    string value)
+{ manager->writeString(action);
+    manager->writeSeparator();
+  manager->writeString(this->fileName);
+  manager->writeSeparator();
+  manager->writeString(sectionName);
+  manager->writeSeparator();
+  manager->writeString(item);
+  manager->writeSeparator();
+  manager->writeString(value);
+  manager->writeString("\n");
+}
+
+bool gsProfile::undoAction(string actionName, stringArray &params)
+{   if (actionName == "ProfileAddListMember")
+    {   this->removeListMember(params[0], params[1], params[2]);
+    return true;
+  }
+  return false;
+}
+
+bool gsProfile::ensureListMember(string sectionName, string listName,
+                                                                    string listMember)
 { char              buffer[256] = "\0";
     stringArray *members;
+  bool              reply = true;
 
-    if (GetPrivateProfileString(sectionName, listName, "",
-                                                        buffer, 256, this->fileName) <= 0)
+    if (GetPrivateProfileString(sectionName.c_str(), listName.c_str(), "",
+                                                        buffer, 256, this->fileName.c_str()) <= 0)
   { buffer[0] = '\0';
   }
@@ -22 +45 @@
   { members->add(listMember);
     members->writeToCString(buffer, ";", 256);
-    delete members;
-    return WritePrivateProfileString(sectionName, listName, buffer, this->fileName);
+
+    reply   = this->writeString(sectionName, listName, buffer);
+    if (reply)
+    {   this->logAction("ProfileAddListMember", sectionName, listName, listMember);
+    }
   }
   delete members;
-  return true;
+  return reply;
 }
 
-bool gsProfile::addListMember(const char *sectionName, const char *listName, const char *listMember)
+bool gsProfile::addListMember(string sectionName, string listName, string listMember)
 { char buffer[256];
   stringArray   *members;
 
-    GetPrivateProfileString(sectionName, listName, "",
-                                                    buffer, 256, this->fileName);
+    GetPrivateProfileString(sectionName.c_str(), listName.c_str(), "",
+                                                    buffer, 256, this->fileName.c_str());
     // straightforward, unthinking, add
   members   = new stringArray(buffer, ";");
@@ -40 +66 @@
   members->writeToCString(buffer, ";", 256);
   delete members;
-  return WritePrivateProfileString(sectionName, listName, buffer, this->fileName);
+  return this->writeString(sectionName, listName, buffer);
 }
 
-bool gsProfile::removeListMember(const char *sectionName, const char *listName, const char *listMember)
+bool gsProfile::removeListMember(string sectionName, string listName, string listMember)
 { char buffer[256];
   stringArray   *members;
 
-    GetPrivateProfileString(sectionName, listName, "",
-                                                    buffer, 256, this->fileName);
+    GetPrivateProfileString(sectionName.c_str(), listName.c_str(), "",
+                                                    buffer, 256, this->fileName.c_str());
     // straightforward, unthinking, removal - if it isn't there, we won't need to
   // worry!
@@ -56 +82 @@
   delete members;
 
-  return WritePrivateProfileString(sectionName, listName, buffer, this->fileName);
+  return this->writeString(sectionName, listName, buffer);
 }
 
-bool gsProfile::writeString(const char *sectionName, const char *itemName, const char *itemValue)
-{   if (!WritePrivateProfileString(sectionName, itemName, itemValue, this->fileName))
+bool gsProfile::writeString(string sectionName, string itemName, string itemValue)
+{   if (!WritePrivateProfileString( sectionName.c_str(), itemName.c_str(),
+                                                                    itemValue.c_str(), this->fileName.c_str()))
     { DWORD error = GetLastError();
     char buffer[20];

trunk/gsinstaller/gsProfile.h

@@ -1 +1 @@
 #ifndef _GSPROFILE_H_
 #define _GSPROFILE_H_
+#include <string>
+using namespace std;
 #include <windows.h>
-class gsProfile
+
+#include "uninstall.h"
+#include "stringarray.h"
+
+class gsProfile : public installAgent
 {
     private:
-    const char *fileName;
+    string fileName;
+
+    void logAction(string action, string sectionName, string item, string value);
   protected:
   public:
-    gsProfile(const char *fileName);
-    bool ensureListMember(const char *sectionName, const char *listName, const char *listMember);
-    bool removeListMember(const char *sectionName, const char *listName, const char *listMember);
-    bool addListMember(const char *sectionName, const char *listName, const char *listMember);
-    bool writeString(const char *sectionName, const char *itemName, const char *itemValue);
+    gsProfile(installManager &manager, string fileName);
+    bool ensureListMember(string sectionName, string listName, string listMember);
+    bool removeListMember(string sectionName, string listName, string listMember);
+    bool addListMember(string sectionName, string listName, string listMember);
+    bool writeString(string sectionName, string itemName, string itemValue);
+    bool undoAction(string actionName, stringArray &params);
 };
 #endif

trunk/gsinstaller/gsProgman.cpp

@@ -80 +80 @@
 }
 
-gsProgramManager::gsProgramManager()
+gsProgramManager::gsProgramManager(installManager &manager)
+    : installAgent(manager)
 {   this->platform  = new gsPlatform();
     this->connected = false;
+}
+
+void gsProgramManager::logAction(string actionName, string group)
+{   manager->writeString(actionName);
+    manager->writeSeparator();
+  manager->writeString(group);
+    manager->writeString("\n");
+}
+
+void gsProgramManager::logAction(string actionName, string group, string item, string parameter)
+{   manager->writeString(actionName);
+    manager->writeSeparator();
+  manager->writeString(group);
+    manager->writeSeparator();
+  manager->writeString(item);
+    manager->writeSeparator();
+  manager->writeString(parameter);
+    manager->writeString("\n");
+}
+
+bool gsProgramManager::undoAction(string actionName, stringArray &params)
+{ if (actionName == "ProgManCreateGroup")
+    {   this->removeProgramGroup(params[0]);
+    return true;
+  }
+  else if (actionName == "ProgManAddIcon")
+  { this->removeIcon(params[0], params[1]);
+    return true;
+  }
+  return false;
 }
 
@@ -123 +154 @@
 }
 
-bool gsProgramManager::addProgramGroup(const char *groupName)
+bool gsProgramManager::addProgramGroup(string groupName)
 {   //CreateGroup(groupName);
     char buffer[256];
@@ -147 +178 @@
   else
   { // add using program manager DDE
-    sprintf(buffer, "[CreateGroup (%s)]", groupName);
+    sprintf(buffer, "[CreateGroup (%s)]", groupName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     {   // flag error by returning false
@@ -153 +184 @@
     }
   }
+
+  this->logAction("ProgManCreateGroup", groupName);
     return true;
 }
 
-bool gsProgramManager::addIcon( const char *groupName,              // group of the icon
-                                                                const char *iconName,                   // name of the icon
-                                const char *iconDestination,    // destination file of the icon
-                                                            const char *description)            // the textual description
-                                                                                            // of the icon (not usually displayed)
+bool gsProgramManager::addIcon( string groupName,               // group of the icon
+                                                                string iconName,                // name of the icon
+                                string iconDestination, // destination file of the icon
+                                                            string description)         // the textual description
+                                                                                // of the icon (not usually displayed)
 {   bool                    reply = false;
     char                    buffer[MAX_PATH];
@@ -176 +209 @@
 
         SHGetPathFromIDList(pidl, buffer);
-        fullPath    = new FilePath(4, buffer, groupName, iconName, "!.lnk");
+        fullPath    = new FilePath(4, buffer, groupName.c_str(), iconName.c_str(), ".lnk");
 
         // Get a pointer to the IShellLink interface.
@@ -186 +219 @@
         // Set the path to the shortcut target, and add the
         // description.
-      psl->SetPath(iconDestination);
-
-        psl->SetDescription(description);
+      psl->SetPath(iconDestination.c_str());
+
+        psl->SetDescription(description.c_str());
 
         // Query IShellLink for the IPersistFile interface for saving the
@@ -214 +247 @@
     // ensure that the requisite group is active; the add icon command will
     // use the active group.
-    sprintf(buffer, "[ShowGroup(%s,5)]", groupName);
+    sprintf(buffer, "[ShowGroup(%s,5)]", groupName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     { // TODO: articulate/determine possible errors; expand error handling
@@ -221 +254 @@
 
     // and now add the item itself to the active (given) group
-    sprintf(buffer, "[AddItem(%s,%s)]", iconDestination, iconName);
+    sprintf(buffer, "[AddItem(%s,%s)]", iconDestination.c_str(), iconName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     {   // TODO: again work out what the problems could be
@@ -228 +261 @@
     reply = true;
   }
+
+  if (reply)
+  { this->logAction("ProgManAddItem", groupName, iconName, iconDestination);
+  }
   return reply;
 }
 
-bool gsProgramManager::removeProgramGroup(const char *groupName)
+bool gsProgramManager::removeProgramGroup(string groupName)
 {   //CreateGroup(groupName);
     char buffer[256];
@@ -255 +292 @@
   else
   { // add using program manager DDE
-    sprintf(buffer, "[DeleteGroup (%s)]", groupName);
+    sprintf(buffer, "[DeleteGroup (%s)]", groupName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     {   // flag error by returning false
@@ -264 +301 @@
 }
 
-bool gsProgramManager::removeIcon(const char *groupName,                // group of the icon
-                                                                    const char *iconName)                   // name of the icon
+bool gsProgramManager::removeIcon(string groupName,             // group of the icon
+                                                                    string iconName)                    // name of the icon
 {   bool                    reply = false;
     char                    buffer[MAX_PATH];
@@ -281 +318 @@
 
         SHGetPathFromIDList(pidl, buffer);
-        fullPath    = new FilePath(4, buffer, groupName, iconName, "!.lnk");
+        fullPath    = new FilePath(4, buffer, groupName.c_str(), iconName.c_str(), "!.lnk");
 
     // TODO: delete file
@@ -290 +327 @@
     // ensure that the requisite group is active; the add icon command will
     // use the active group.
-    sprintf(buffer, "[ShowGroup(%s,5)]", groupName);
+    sprintf(buffer, "[ShowGroup(%s,5)]", groupName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     { // TODO: articulate/determine possible errors; expand error handling
@@ -297 +334 @@
 
     // and now add the item itself to the active (given) group
-    sprintf(buffer, "[DeleteItem(%s)]", iconName);
+    sprintf(buffer, "[DeleteItem(%s)]", iconName.c_str());
     if (!DDEShellCommand(this->instance, buffer))
     {   // TODO: again work out what the problems could be

trunk/gsinstaller/gsProgman.h

@@ -4 +4 @@
 
 #include "gsPlatform.h"
+#include "uninstall.h"
+#include "stringArray.h"
 
-class gsProgramManager
+class gsProgramManager : public installAgent
 {
     private:
@@ -11 +13 @@
     DWORD               instance;
     bool                connected;
+
+    void logAction(string actionName, string group);
+    void logAction(string actionName, string group, string item, string parameter);
   protected:
   public:
     // constructor
-    gsProgramManager();
+    gsProgramManager(installManager &manager);
 
     // connect/disconnect activity
@@ -20 +25 @@
     bool disconnect();
 
-    bool addProgramGroup(const char *name);
-    bool removeProgramGroup(const char *name);
-    bool addIcon(   const char *groupName, const char *iconName, const char *iconDestination,
-                                const char *description);
-    bool removeIcon(    const char *groupName, const char *iconName);
+    bool addProgramGroup(string name);
+    bool removeProgramGroup(string name);
+    bool addIcon(   string groupName, string iconName, string iconDestination,
+                                string description);
+    bool removeIcon(    string groupName, string iconName);
+
+    bool undoAction(string actionName, stringArray &params);
 };
 #endif

trunk/gsinstaller/gsRegistry.cpp

@@ -1 +1 @@
 #include "gsRegistry.h"
 
-gsRegistry::gsRegistry(configureFile &configFile)
+gsRegistry::gsRegistry(installManager &manager, configureFile &configFile)
+  : installAgent(manager)
 { unsigned int space;
 
     // Create string for volume key
-    strcpy(volumeKey, "Software\\");
-    space   = 255 - strlen(volumeKey);
-
-    configFile.concat("CompanyName", volumeKey, space);
-  strcat(volumeKey, "\\");
-    configFile.concat("CollectionName", volumeKey, space);
-  strcat(volumeKey, "\\");
-    configFile.concat("CollectionVolume", volumeKey, space);
-  strcat(volumeKey, "\\");
-    configFile.concat("CollectionVersion", volumeKey, space);
+    volumeKey = "Software\\" + configFile.getString("CompanyName") + "\\" +
+                            configFile.getString("CollectionName") + "\\" +
+                            configFile.getString("CollectionVolume") + "\\" +
+                            configFile.getString("CollectionVersion");
 
     // Create string for collection key
-    strcpy(collectKey, "Software\\");
-    space   = 255 - strlen(collectKey);
-
-    configFile.concat("CompanyName", collectKey, space);
-  strcat(collectKey, "\\");
-    configFile.concat("CollectionName", collectKey, space);
-  strcat(collectKey, "\\");
-    configFile.concat("CollectionVersion", collectKey, space);
+    collectKey = "Software\\" + configFile.getString("CompanyName") + "\\" +
+                            configFile.getString("CollectionName") + "\\" +
+                configFile.getString("CollectionVersion");
 }
 
-bool gsRegistry::ensureKeysExist()
-{   if (registry_ensureKeyExists(HKEY_LOCAL_MACHINE, this->collectKey) == false)
-    {   return false;
+bool gsRegistry::logAction(string action, HKEY base, string path, string item, string value)
+{   manager->writeString(action);
+    manager->writeSeparator();
+  manager->writeString(path);
+    if (item != "" || value != "")
+  { manager->writeSeparator();
+    if (item == "")
+    {   manager->writeString("{Default}");
+    }
+    else
+    {   manager->writeString(item);
+    }
+        manager->writeSeparator();
+    manager->writeString(value);
   }
-  if (registry_ensureKeyExists(HKEY_LOCAL_MACHINE, this->volumeKey) == false)
-  { return false;
+  manager->writeString("\n");
+}
+
+bool gsRegistry::undoAction(string actionName, stringArray &params)
+{ if (actionName == "RegistryCreateKey")
+    {   this->destroyKey(HKEY_LOCAL_MACHINE, params[0]);
+  }
+  else if (actionName == "RegistrySetString")
+  { this->destroyItem(HKEY_LOCAL_MACHINE, params[0], params[1]);
+  }
+  else
+  { return false;
   }
   return true;
 }
 
-bool gsRegistry::ensureKeyExists(HKEY base, const char *key)
-{   return(registry_ensureKeyExists(base, key));
+bool gsRegistry::ensureKeysExist()
+{ if (!this->ensureKeyExists(HKEY_LOCAL_MACHINE, this->collectKey))
+    {   return false;
+  }
+  return this->ensureKeyExists(HKEY_LOCAL_MACHINE, this->volumeKey);
 }
 
-bool gsRegistry::storeKeyString(HKEY base, const char *path, const char *item, const char *string)
+bool gsRegistry::ensureKeyExists(HKEY base, string key)
+{ if (!registry_keyExists(base, key.c_str()))
+    {   if (!registry_ensureKeyExists(base, key.c_str()))
+    {   return false;
+    }
+    this->logAction("RegistryCreateKey", base, key, "", "");
+  }
+  return true;
+}
+
+bool gsRegistry::destroyKey(HKEY base, string key)
+{   registry_deletekey(base, key.c_str());
+}
+
+bool gsRegistry::storeKeyString(HKEY base, string path, string item, string value)
 {   HKEY local;
     bool    reply;
 
-  if (!registry_openkey(base, (char *) path, &local))
+  if (!registry_openkey(base, path.c_str(), &local))
     {   return false;
   }
-  reply = registry_setstring(local, item, string);
+  reply = registry_setstring(local, item.c_str(), value.c_str());
+  if (reply)
+  { this->logAction("RegistrySetString", base, path, item, value);
+  }
   registry_closekey(local);
   return reply;
 }
 
+bool gsRegistry::destroyItem(HKEY base, string path, string item)
+{ HKEY local;
+
+    if (!registry_openkey(base, path.c_str(), &local))
+  { return false;
+  }
+  registry_deleteitem(local, item.c_str());
+  registry_closekey(local);
+}
+
 bool gsRegistry::collectionInstalled()
-{   return registry_keyExists(HKEY_LOCAL_MACHINE, this->collectKey);
+{   return registry_keyExists(HKEY_LOCAL_MACHINE, this->collectKey.c_str());
 }
 
 bool gsRegistry::volumeInstalled()
-{   return registry_keyExists(HKEY_LOCAL_MACHINE, this->volumeKey);
+{   return registry_keyExists(HKEY_LOCAL_MACHINE, this->volumeKey.c_str());
 }
 
-char *gsRegistry::collectKeyId()
+string gsRegistry::collectKeyId()
 {   return this->collectKey;
 }
 
-char *gsRegistry::volumeKeyId()
+string gsRegistry::volumeKeyId()
 {   return this->volumeKey;
 }
 
-char *gsRegistry::exeKeyId(char *exename)
-{   char *reply = new char[256];
+string gsRegistry::exeKeyId(string exename)
+{   string reply = "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\";
+    reply += exename;
+  return reply;
+}
 
-    // Create string for exe path
-    strcpy(reply, "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\");
-  strcat(reply, exename);
-  return reply;
+string gsRegistry::uninstallKeyId(string collectName)
+{   return "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\" + collectName;
 }
 
@@ -83 +125 @@
     HKEY key;
 
-  if (registry_openkey(HKEY_LOCAL_MACHINE, this->collectKey, &key))
+  if (registry_openkey(HKEY_LOCAL_MACHINE, this->collectKey.c_str(), &key))
   { if (registry_getstring(key, "library", &path))
     { // get leaf (\library.exe) and remove it to give a path

trunk/gsinstaller/gsRegistry.h

@@ -1 +1 @@
 #ifndef _GSREGISTRY_H_
 #define _GSREGISTRY_H_
+#include <string>
+using namespace std;
+
 #include "registry.h"
 #include "configFile.h"
 #include "FilePath.h"
+#include "uninstall.h"
+#include "stringArray.h"
 
-class gsRegistry
+class gsRegistry : public installAgent
 {   private:
-        char volumeKey[256];
-    char collectKey[256];
+        string volumeKey;
+    string collectKey;
+
+    bool logAction(string action, HKEY base, string path, string item, string value);
     public:
-    gsRegistry(configureFile &configFileb);
-        bool            storeKeyString( HKEY base, const char *path,
-                                                        const char *item, const char *string);
+    gsRegistry(installManager &manager, configureFile &configFileb);
+        bool            storeKeyString( HKEY base, string path, string item, string value);
     bool            collectionInstalled();
     bool            volumeInstalled();
     bool            ensureKeysExist();
-    bool            ensureKeyExists( HKEY base, const char *key);
-    char *      collectKeyId();
-    char *      volumeKeyId();
-    char *      exeKeyId(char *exeName);
+    bool            ensureKeyExists( HKEY base, string key);
+    bool            destroyKey(HKEY base, string key);
+    bool            destroyItem(HKEY base, string key, string name);
+    string      collectKeyId();
+    string      volumeKeyId();
+    string      exeKeyId(string exeName);
+    string    uninstallKeyId(string collectName);
     FilePath *collectionPath();
-    Path();
+    bool undoAction(string ActionName, stringArray &params);
+//    Path();
 };
 #endif

trunk/gsinstaller/gsinstall.cpp

@@ -29 +29 @@
 
 bool            config_complete = false;
-// static char app_tmptext[100] = "George";
 
 typedef vector<dirSelector *> dirSelVector;
 
-class GSInstall
+class GSInstall : public installManager
 { private:
-        configureFile   *   configFile;
-        FilePath *          collectPath;
-    FilePath *          installToPath;
-    FilePath *          sourcePath;
-    FilePath *          gsdlSourcePath;
-    FilePath *          destinationPath;
-    FilePath *          dataDestPath;
+        configureFile   *   configFile;             // the installation configure file
+
+        FilePath *          collectPath;            // where the collection is currently installed
+    FilePath *          installToPath;      // the first cut at a destination folder
+    FilePath *          sourcePath;             // the root source folder
+    FilePath *          gsdlSourcePath;     // the gsdl folder in the source area
+    FilePath *          destinationPath;    // where the executables will be installed to
+    FilePath *          dataDestPath;           // where the collection data files will go
+
+    bool                        installVolume;      // whether to install collection data
+    bool                        installFullVolume;// whether to install all collection data
+
+    dirSelVector        selectedDirs;           // configuration objects
+
+    gsPlatform                  platform;           // platform information
+    gsRegistry *                gsRegister;     // registry
+    gsManifest *                manifest;           // manifest of files
+    gsProgramManager  * progman;            // program manager connection
+
+    void                getSourcePath();
+    void                getExistingInstall();
+    public:
     bool            installExe;
-    bool                        installVolume;
-    bool                        installFullVolume;
-    gsPlatform          platform;
-    unInstaller *       unInstall;
-
-    dirSelVector        selectedDirs;
-
-    gsRegistry *        gsRegister;
-    gsManifest *        manifest;
-
-    void                getSourcePath();
-    public:
-        GSInstall();
+
+        GSInstall(bool uninstall);
     FilePath *  collectionPath();
     FilePath *  installPath();
@@ -64 +67 @@
     bool                installNetscape();
     void                setDestination();
+    void                setUninstall();
+    void                uninstall();
     void                setManifest();
     void                addSelectedDir(dirSelector *selector);
@@ -87 +92 @@
  * THe source path is also discovered.
  */
-GSInstall::GSInstall()
-{ gsPlatform    platform;
-
-    // get the installation configuration file
+GSInstall::GSInstall(bool uninstall)
+    : installManager()
+{ // get the installation configuration file
     this->configFile    = new configureFile("install.cfg");
 
-  // initialise the pointers that we test later this fn.
-  this->unInstall       = NULL;
+    // set up "default" installation bits
+  this->installToPath   = new FilePath("C:\\GSDL");
+    this->collectPath   = NULL;
+  this->installExe  = true; // we must install the exe files
 
     // don't attempt this with windows 3.1
-  if (!platform.isWindows32s() || TRUE)
+  if (!this->platform.isWindows32s())
   { // get the registry
-      this->gsRegister  = new gsRegistry(*this->configFile);
-
-    // TODO: in windows 3.1 we can't use the register as it isn't fully/properly
+      this->gsRegister  = new gsRegistry(*this, *this->configFile);
+  }
+  else
+  { // TODO: in windows 3.1 we can't use the register as it isn't fully/properly
       //       implemented; we must get the existing path information from elsewhere
-    if (gsRegister->collectionInstalled())
-      { // TODO: check if receptionist etc should be replaced or not
-
-        // TODO: check build version of the volume
-
-        // Get location of the library executable from the registry; this
-        // is thence used to get the location of gsdl.ini etc.
-        this->collectPath   = this->gsRegister->collectionPath();
-        this->installToPath = this->collectPath;
-
-        // TODO: if collectPath == NULL generate error
-
-      // get uninstall information from destination location
-      FilePath *uninstallPath   = new FilePath(this->collectPath->cString(), "uninstl.cfg");
-      this->unInstall   = new unInstaller(uninstallPath->cString());
-      delete uninstallPath;
-
-      // we don't need to install the exe files
-        this->installExe = false||true;
-      }
-    else
-      { this->installToPath = new FilePath("C:\\GSDL");
-            this->collectPath   = NULL;
-        // we must install the exe files
-          this->installExe  = true;
-    }
-  }
-  else
-  { // TODO: do windows 3.1 stuff here
-    this->installToPath = new FilePath("C:\\GSDL");
-    this->installExe = true;
-    this->collectPath   = NULL;
-  }
-
-  if (this->unInstall   == NULL)
-  { this->unInstall = new unInstaller("");
+    this->gsRegister    = new gsRegistry(*this, *this->configFile);
   }
 
@@ -145 +117 @@
   this->installFullVolume   = true;
 
+    // detect any existing installation; unnecessary in uninstall (it's the
+  // "source" directory - see later
+  if (uninstall == false)
+  { this->getExistingInstall();
+  }
+
   // get where we are installing from
   this->getSourcePath();
 
-  // get the manifest
-  this->manifest = new gsManifest(*this->sourcePath);
+  // if doing an uninstall we now know where the "uninstall" is
+  if (uninstall == true)
+  { this->collectPath   = this->sourcePath;
+  }
+
+  // get the manifest and program manager objects
+  if (uninstall)
+  { this->manifest = new gsManifest(*this);
+  }
+  else
+  { this->manifest = new gsManifest(*this, *this->sourcePath);
+  }
+  this->progman  = new gsProgramManager(*this);
 
   // tell manifest the number of bits in the raw windows environment; this may
@@ -165 +154 @@
   }
 */
-  // inform manifests of collection directory name
-  char *buffer;
-  this->configFile->get("CollectionDirName", &buffer);
-  this->manifest->expandMacro("COLDIRNAME", buffer);
-  delete buffer;
+  // inform manifest of collection directory name
+  string colDir;
+  colDir = this->configFile->getString("CollectionDirName");
+  if (colDir != "")
+  { this->manifest->expandMacro("COLDIRNAME", colDir);
+  }
+}
+
+/**
+ * Detect the presence of an existing installation
+ */
+void GSInstall::getExistingInstall()
+{   if (!this->platform.isWindows32s())
+    {   if (gsRegister->collectionInstalled())
+      { // TODO: check if receptionist etc should be replaced or not
+
+        // TODO: check build version of the volume
+
+        // Get location of the library executable from the registry; this
+        // is thence used to get the location of gsdl.ini etc.
+        this->collectPath   = this->gsRegister->collectionPath();
+      if (this->collectPath != "")
+      { this->installToPath = this->collectPath;
+
+        // we don't need to install the exe files
+            this->installExe = false;
+      }
+      }
+  }
 }
 
@@ -189 +202 @@
 
   // get the gsdl source path
-  this->gsdlSourcePath  = new FilePath(this->sourcePath->cString(), "gsdl");
+  this->gsdlSourcePath  = new FilePath(this->sourcePath->pathString(), "gsdl");
   delete exePath;
 }
@@ -199 +212 @@
  */
 bool GSInstall::copyFiles()
-{   FileVector *fileList;
-
-  // ensure that we have got the required destination and that we can write there
+{   // ensure that we have got the required destination and that we can write there
   if (this->installExe)
   { this->destinationPath->ensureWriteablePath();
@@ -232 +243 @@
   // now move on to add key items
     if (this->installExe)
-  { FilePath *serverPath    = new FilePath((char *) this->destinationPath->cString(), "server.exe");
-    char *exeKeyPath;
+  { FilePath *serverPath    = new FilePath(this->destinationPath->pathString(), "server.exe");
+    FilePath *setupPath     = new FilePath(this->destinationPath->pathString(), "gssetup.exe");
+      FilePath *logPath = new FilePath(this->destinationPath->pathString(), "install.log");
+    string exeKeyPath, uninstallCmd, uninstallKeyPath;
     gsPlatform platform;
 
@@ -240 +253 @@
                                                                         this->gsRegister->collectKeyId(),
                                       "library",
-                                      serverPath->cString());
+                                      serverPath->pathString());
 
     // This test is in fact for 9x or NT 4+; we're worried about the registry
@@ -254 +267 @@
         this->gsRegister->storeKeyString(   HKEY_LOCAL_MACHINE,
                                                                         exeKeyPath,
-                                          NULL,
-                                        serverPath->cString());
+                                          "",
+                                        serverPath->pathString());
 
       // store path for this application
@@ -261 +274 @@
                                                                         exeKeyPath,
                                           "path",
-                                        this->destinationPath->cString());
-      // delete the windows 9x speciall app path key
-            delete exeKeyPath;
-
-      // TODO: set up uninstall option
+                                        this->destinationPath->pathString());
+
+      // create uninstall command line
+      uninstallCmd = setupPath->pathString() + " -u " + logPath->pathString();
+      uninstallKeyPath = this->gsRegister->uninstallKeyId(this->configFile->getString("CollectionName"));
+
+      // ensure uninstall key exists
+      this->gsRegister->ensureKeyExists(HKEY_LOCAL_MACHINE, uninstallKeyPath);
+
+      this->gsRegister->storeKeyString(HKEY_LOCAL_MACHINE, uninstallKeyPath,
+                                                                        "DisplayName",
+                                        this->configFile->getString("CollectionName"));
+      this->gsRegister->storeKeyString(HKEY_LOCAL_MACHINE, uninstallKeyPath,
+                                                                        "UninstallString", uninstallCmd);
     }
+    delete setupPath;
     delete serverPath;
+      delete logPath;
   }
 
@@ -280 +304 @@
  */
 void GSInstall::setDestination()
-{   this->destinationPath       = new FilePath(this->selectedDirs[0]->selectedPath());
+{ // get configuration from the install wizard pages
+    this->destinationPath       = new FilePath(this->selectedDirs[0]->selectedPath());
     this->installFullVolume = this->selectedDirs[1]->getOption();
   if (this->installFullVolume || true)  // NB: always take path from 2nd dialog
@@ -287 +312 @@
   else
   { this->dataDestPath  = this->destinationPath;
+  }
+
+  // open the log for writing
+  FilePath *logPath = new FilePath(this->destinationPath->pathString(), "install.log");
+  this->openLog(logPath->pathString(), true);
+  delete logPath;
+}
+
+void GSInstall::setUninstall()
+{
+  // open the log for reading
+  FilePath *logPath = new FilePath(this->collectPath->pathString(), "install.log");
+  this->openLog(logPath->pathString(), false);
+  delete logPath;
+}
+
+void GSInstall::uninstall()
+{ FilePath *iniPath;
+    string      command;
+  stringArray params;
+
+    this->manifest = new gsManifest(*this); // get a manifest manager
+
+  iniPath   = new FilePath(this->collectPath->pathString(), "gsdl.ini");
+    gsProfile gsdlProfile(*this, iniPath->pathString());
+
+    while ((command = this->readCommand(params)) != "")
+  { if (!this->manifest->undoAction(command, params))
+    { if (!gsdlProfile.undoAction(command, params))
+        { if (!this->gsRegister->undoAction(command, params))
+        { if (!this->progman->undoAction(command, params))
+            {
+          }
+        }
+      }
+    }
   }
 }
@@ -295 +356 @@
 void GSInstall::setManifest()
 {   if (this->installExe)
-    {   this->manifest->selectGroup("library", this->destinationPath->pathString());
+    {   this->manifest->selectGroup("library", *this->destinationPath);
   }
   if (this->installFullVolume)
-  { this->manifest->selectGroup("collection", this->dataDestPath->pathString());
+  { this->manifest->selectGroup("collection", *this->dataDestPath);
   }
   else
-  { this->manifest->selectGroup("database", this->dataDestPath->pathString());
+  { this->manifest->selectGroup("database", *this->dataDestPath);
   }
 }
@@ -310 +371 @@
  */
 bool GSInstall::updateProgman()
-{ gsProgramManager  progman;
-    char *            groupName = NULL;
+{ string groupName;
 
   // if we managed to get a connection to the program manager (or explorer
   // shell) then do the requisite updates
-  if (progman.connect())
+  if (this->progman->connect())
   { // get group name from folders
-    this->configFile->get("ProgramGroupName", &groupName);
-      if (groupName == NULL)
+    groupName = this->configFile->getString("ProgramGroupName");
+      if (groupName == "")
     {   // TODO: error handling
-        progman.disconnect();
-          delete groupName;
+        this->progman->disconnect();
         return false;
       }
 
       // add the group
-        if (!progman.addProgramGroup(groupName))
-      { progman.disconnect();
-          delete groupName;
+        if (!this->progman->addProgramGroup(groupName))
+      { this->progman->disconnect();
         return false;
     }
 
     // add a "server" icon
-    FilePath libraryPath(this->destinationPath->cString(), "library.exe");
-      if (!progman.addIcon(groupName, "Library (without nextwork support)", libraryPath.cString(), ""))
-    { progman.disconnect();
-          delete groupName;
-        return false;
+    FilePath libraryPath(this->destinationPath->pathString(), "library.exe");
+      if (!this->progman->addIcon(groupName, "Library (without nextwork support)", libraryPath.pathString(), ""))
+    { // assume that it may be there already
       }
 
-    // TODO: check for server existence
-    FilePath serverPath(this->destinationPath->cString(), "server.exe");
-      if (!progman.addIcon(groupName, "Server", serverPath.cString(), ""))
-    {   progman.disconnect();
-          delete groupName;
-        return false;
+    // check for server existence
+    FilePath serverPath(this->destinationPath->pathString(), "server.exe");
+    if (serverPath.exists())
+    { if (!this->progman->addIcon(groupName, "Server", serverPath.pathString(), ""))
+        {   // assume that it may be there already
+      }
       }
 
-    FilePath readMePath(this->destinationPath->cString(), "readme.txt");
-      if (!progman.addIcon(groupName, "ReadMe", readMePath.cString(), ""))
-    {   progman.disconnect();
-          delete groupName;
-        return false;
+    FilePath readMePath(this->destinationPath->pathString(), "readme.txt");
+      if (!this->progman->addIcon(groupName, "ReadMe", readMePath.pathString(), ""))
+    {
       }
 
-    FilePath supportPath(this->destinationPath->cString(), "support.html");
-      if (!progman.addIcon(groupName, "Technical Support", supportPath.cString(), ""))
-    {   progman.disconnect();
-          delete groupName;
-        return false;
+    FilePath supportPath(this->destinationPath->pathString(), "support.html");
+      if (!this->progman->addIcon(groupName, "Technical Support", supportPath.pathString(), ""))
+    {
       }
 
-    // TODO: add uninstall support
-
-    // dispose of group name
-      delete groupName;
+    // TODO: uninstall icon
+    // FilePath uninstallPath(this->destinationPath->pathString(), "gssetup.exe");
 
     // disconnect from program manager
-    progman.disconnect();
+    this->progman->disconnect();
   }
   return true;
@@ -393 +443 @@
     {   exePath = this->collectPath;
   }
-  iniPath   = new FilePath((char *) exePath->cString(), "gsdl.ini");
+  iniPath   = new FilePath(exePath->pathString(), "gsdl.ini");
 
   // TODO: check if this 'if' structure is correct; suspect that it isn't quite
@@ -401 +451 @@
   //       This all needs investigating
   if (this->installVolume)
-  { char volumeSectionName[100] = "\0";
-    unsigned int space  = 99;
-
-    // Manufacture the appropriate section name now; an equivalent string
+  { // Manufacture the appropriate section name now; an equivalent string
     // is also constructed
-    this->configFile->concat("CollectionName", volumeSectionName, space);
-    strcat(volumeSectionName, "#");
-    space --;
-    this->configFile->concat("CollectionVolume", volumeSectionName, space);
-    string volumeSectionString(volumeSectionName);
+    string volumeSectionString = this->configFile->getString("CollectionName") +
+                                                             "#" + this->configFile->getString("CollectionVolume");
 
     // if we're installing the full data for the collection, then take the
@@ -423 +467 @@
 
     // create a profile object to write to the gsdl.ini file
-    gsProfile gsdlProfile(iniPath->cString());
+    gsProfile gsdlProfile(*this, iniPath->pathString());
 
     // if installing the executable, add the database and greenstone home
@@ -429 +473 @@
     if (this->installExe)
     {   // set the correct exe entries in gsdl.ini (in the gsdl section)
-            gsdlProfile.writeString("gsdl", "gsdlhome", dataPath->cString());
-      gsdlProfile.writeString("gsdl", "gdbmhome", this->dataDestPath->cString());
-
-      this->unInstall->record("gsdl", "profilewrite", 2, &gsdl_VLHOME,
-                                                    &dataPath->pathString());
-      this->unInstall->record("gsdl", "profilewrite", 2, &gsdl_DBHOME,
-                                                    &this->dataDestPath->pathString());
+            gsdlProfile.writeString("gsdl", "gsdlhome", dataPath->pathString());
+      gsdlProfile.writeString("gsdl", "gdbmhome", this->dataDestPath->pathString());
     }
 
@@ -441 +480 @@
     if (this->installVolume)
     { // note the collection in the general gsdl section; and add the undo item too
-        gsdlProfile.ensureListMember("gsdl", gsdl_COLLIST.c_str(), volumeSectionName);
-      this->unInstall->record("gsdl", "proflistensure", 2, &gsdl_COLLIST, &volumeSectionString);
+        gsdlProfile.ensureListMember("gsdl", gsdl_COLLIST, volumeSectionString);
 
       // note the volume data in its own section
-        gsdlProfile.writeString(volumeSectionName, "gsdlhome", dataPath->cString());
-        gsdlProfile.writeString(volumeSectionName, "gdbmhome", this->dataDestPath->cString());
-        gsdlProfile.writeString(volumeSectionName, "staticpath", dataPath->cString());
-
-      this->unInstall->record(volumeSectionName, "profilewrite", 2, &gsdl_VLHOME, &dataPath->pathString());
-      this->unInstall->record(volumeSectionName, "profilewrite", 2, &gsdl_DBHOME, &this->dataDestPath->pathString());
-      this->unInstall->record(volumeSectionName, "profilewrite", 2, &gsdl_STATIC, &dataPath->pathString());
+        gsdlProfile.writeString(volumeSectionString, "gsdlhome", dataPath->pathString());
+        gsdlProfile.writeString(volumeSectionString, "gdbmhome", this->dataDestPath->pathString());
+        gsdlProfile.writeString(volumeSectionString, "staticpath", dataPath->pathString());
     }
   }
@@ -462 +496 @@
 
 bool GSInstall::installNetscape()
-{   FilePath    netscape32Path(this->sourcePath->cString(), "netscape\\n32e405.exe");
-  FilePath  netscape16Path(this->sourcePath->cString(), "netscape\\n16e405.exe");
+{   FilePath    netscape32Path(this->sourcePath->pathString(), "netscape\\n32e405.exe");
+  FilePath  netscape16Path(this->sourcePath->pathString(), "netscape\\n16e405.exe");
 
   launchApp launchNetscape(netscape32Path);
@@ -580 +614 @@
 
         case PSN_KILLACTIVE:
-        { // note the path from the dialog
+        break;
+
+                case PSN_WIZNEXT:
+          { // note the path from the dialog
             dirSelector *selector = ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA));
             selector->setPathFromEdit(GetDlgItem(Dialog, dirpath_PATH));
@@ -586 +623 @@
             // create a new FilePath object to check on the proposed destination
                     FilePath *path = new FilePath(selector->selectedPath());
+
+          // if the proposed destination doesn't exist, ask the user whether to
+          // create it now.  TODO: actually create it if asked!
           if (path->exists() == false)
           { char buffer[128];
@@ -600 +640 @@
           }
           delete path;
-        }
-        break;
-
-                case PSN_WIZNEXT:
-          { if (((LPNMHDR) lParam)->idFrom == 0)
-            { // TODO: note a default here
-            }
           }
         break;
@@ -673 +706 @@
     pshead.nPages      = 2;
     pshead.nStartPage  = 0;
-    pshead.ppsp        = ppage;
+  if (install.installExe == true)
+  { pshead.ppsp          = ppage;
+  }
+  else // cheat as the executable etc. is already installed
+  { pshead.ppsp          = &ppage[1];
+  }
     pshead.pfnCallback = GSInstall_wizardProc;
 
@@ -705 +743 @@
   switch(Message)
     { case WM_CREATE:
-    {
+    { ShowWindow(Window, SW_MAXIMIZE);
     }
     break;
@@ -713 +751 @@
 
     case WM_USER:
-    {   //dirSelector selector("Choose a Greenstone directory", "Select directory");
-
-      //selector.requestPath(Window, "Select directory");
-      GSInstall install;
-      GSInstall_init_wizard(install);
-      if (config_complete == false)
-      { MessageBox(0, "Install cancelled", app_name, MB_OK);
-            }
+    { // uninstall action
+        if (strstr(app_cmdLine, "-u") != NULL || true)
+        { char *at = strstr(app_cmdLine, "-u");
+        at += strlen("-u") + 1;
+
+                GSInstall install(true);
+        install.setUninstall();
+        install.uninstall();
+      }
+      // install wizard
       else
-      { install.setDestination();
-        install.setManifest();
-          install.copyFiles();
-        install.updateProgman();
-          install.updateRegistry();
-        install.updateProfiles();
-        install.installNetscape();
+      { GSInstall install(false);
+        GSInstall_init_wizard(install);
+          if (config_complete == false)
+        {   MessageBox(0, "Install cancelled", app_name, MB_OK);
+                }
+        else
+          { // configure the installation
+            install.setDestination();
+            install.setManifest();
+
+            // perform installation
+              install.copyFiles();
+            install.updateProgman();
+              install.updateRegistry();
+            install.updateProfiles();
+
+            // do further actions
+          install.installNetscape();
+          }
       }
       DestroyWindow(Window);

trunk/gsinstaller/install.cfg

@@ -1 @@
-CompanyName:FAO
-CollectionName:Humanity Development Library
-CollectionDirName:HDL
+CompanyName:Demo
+CollectionName:Demo Collection
+CollectionDirName:demo
 CollectionVersion:1.0
 CollectionVolume:1
-ProgramGroupName:FAO Library
+ProgramGroupName:Demo Collection

trunk/gsinstaller/manifest.cfg

@@ -3 +3 @@
 
 library:
-  gsdl.ini net32 net16 readme.html
+  gsdl.ini library.exe Net32 Net16 readme.txt
 
 database:

trunk/gsinstaller/registry.cpp

@@ -21 +21 @@
     reply = RegOpenKeyEx(key, name, NULL, KEY_QUERY_VALUE, keyout);
   if (reply != ERROR_SUCCESS)
-  { return FALSE;
-  }
-  return TRUE;
+  { return false;
+  }
+  return true;
+}
+
+bool registry_deletekey(HKEY key, const char *name)
+{   if (RegDeleteKey(key, name) != ERROR_SUCCESS)
+    {   return false;
+  }
+  return true;
 }
 
@@ -57 +64 @@
 }
 
+bool registry_deleteitem(HKEY key, const char *name)
+{   if (RegDeleteValue(key, name) != ERROR_SUCCESS)
+    {   return false;
+  }
+  return true;
+}
+
 bool registry_setstring(HKEY key, const char *name, const char *value)
 { LONG reply;
@@ -62 +76 @@
     reply = RegSetValueEx(key, (LPCTSTR) name, NULL, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
   if (reply != ERROR_SUCCESS)
-  { return FALSE;
-  }
-  return TRUE;
+  { return false;
+  }
+  return true;
 }
 

trunk/gsinstaller/registry.h

@@ -8 +8 @@
 bool registry_getstring(HKEY key, char *name, char **string);
 bool registry_setstring(HKEY key, const char *name, const char *string);
+bool registry_deleteitem(HKEY key, const char *name);
 bool registry_createkey(HKEY key, const char *name, PHKEY keyout);
+bool registry_deletekey(HKEY key, const char *name);
 bool registry_closekey(HKEY key);
 bool registry_keyExists(HKEY key, const char *name);

trunk/gsinstaller/stringArray.cpp

@@ -50 +50 @@
   for (int i = 0; i < other.size(); i ++)
   { this->add(other[i]);
+  }
+}
+
+/**
+ * Insert a string at a given location
+ */
+void stringArray::insertAt(string s, unsigned int at)
+{ if (at >= this->size())
+    { this->add(s);
+  }
+  else
+  { this->array.insert(this->array.begin() + at, s);
   }
 }

trunk/gsinstaller/stringArray.h

@@ -17 +17 @@
     void add(string member);
     void add(stringArray &array);
+    void insertAt(string member, unsigned int at);
     void remove(char *member);
     void remove(string member);

trunk/gsinstaller/unInstall.cpp

@@ -4 +4 @@
 #include <stdarg.h>
 #include "File.h"
+
+bool installManager::openLog(string filename, bool write)
+{   if (this->logfile.rdbuf()->is_open())
+    {   this->logfile.close();
+  }
+  this->logfile.open(filename.c_str(), (write ? ios::out : ios::in) | ios::app);
+}
+
+void installManager::setModule(string moduleName)
+{   this->currentModule = moduleName;
+}
+
+bool installManager::writeString(char *buffer)
+{ string s(buffer);
+    this->writeString(s);
+}
+
+bool installManager::writeString(string str)
+{ bool quote;
+
+    // TODO: check for space characters in str and quote if necessary
+  quote = str.find_first_of(' ') < str.length();
+
+    if (quote)
+  { this->logfile << "\"";
+  }
+    this->logfile << str;
+  if (quote)
+  { this->logfile << "\"";
+  }
+  return true;
+}
+
+bool installManager::writeSeparator()
+{   this->logfile << " ";
+    return true;
+}
+
+string installManager::readString()
+{   string reply;
+    char c;
+
+  this->logfile >> c;
+  while (c <= ' ')
+  { this->logfile.get();
+  }
+  if (c == '\"')
+  { do
+    {   c = this->logfile.get();
+        if (c != '\"')
+      { reply += c;
+      }
+    }
+    while (c != '\"');
+  }
+  else
+  { /*while (c > ' ')
+    { reply += c;
+        c = this->logfile.get();
+    }*/
+    this->logfile.putback(c);
+    this->logfile >> reply;
+  }
+  return reply;
+}
+
+string installManager::readCommand(stringArray &array)
+{   string reply;
+  char c;
+
+  array.clear();
+
+    reply = this->readString();
+  while((c = this->logfile.get()) != '\n')
+  { this->logfile.putback(c);
+    array.add(this->readString());
+  }
+  this->logfile.putback(c);
+
+  return reply;
+}
+
+installManager::~installManager()
+{   if (this->logfile.rdbuf()->is_open())
+    {   this->logfile.close();
+  }
+}
 
 unInstaller::unInstaller(string &fileName)

trunk/gsinstaller/unInstall.h

@@ -5 +5 @@
 #include <map>
 using namespace std;
+
+#include <stdio.h>
+#include <fstream.h>
 
 #include "stringArray.h"
@@ -18 +21 @@
 
 typedef map<string, unInstallCommandList, less<string> > unInstallCommandMap;
+
+class installManager
+{   private:
+        fstream logfile;
+    string  currentModule;
+    public:
+    installManager() { };
+    bool openLog(string filename, bool write);
+    void setModule(string moduleName);
+    bool writeString(string str);
+    bool writeString(char *string);
+    bool writeSeparator();
+    string readString();
+    string readCommand(stringArray &params);
+    ~installManager();
+};
+
+class installAgent
+{   protected:
+    installManager *manager;
+    public:
+    installAgent(installManager &useManager) { this->manager = &useManager; };
+    virtual bool undoAction(string actionName, stringArray &params) { return false; };
+//    bool undo(string actionName);
+};
 
 class unInstaller