Changeset 1536 for trunk/gsinstaller

trunk/gsinstaller/FilePath.cpp

-              r1498
+              r1536
 #include <stdarg.h>
 #include <stdio.h>
+#include <dir.h>
+//#include <dir.h>
+#include <direct.h>
 static char divider = '\\';
 …
 bool __pathIsAValidRoot(string path)
+{   DWORD driveMask;
+    int     driveNum;
+{
+  DWORD driveMask;
+  int driveNum;
   if (path.length() > 3)
+  { return false;
+  }
+    if (path[1] != ':' || !isalpha(path[0]))
+  { return false;
+  }
+  {
+    return false;
+  }
+  if (path[1] != ':' || !isalpha(path[0]))
+    {
+      return false;
+    }
   if (isupper(path[0]))
+  { driveNum = path[0] - 'A';
+  }
+  else
+  { driveNum = path[0] - 'a';
+  }
+  {
+    driveNum = path[0] - 'A';
+  }
+  else
+    {
+      driveNum = path[0] - 'a';
+    }
   if (driveNum > 25)
+  { return false;
+  }
+  {
+    return false;
+  }
   driveMask = GetLogicalDrives();
   if ((driveMask & (1 << driveNum)) != (1 << driveNum))
+  { return false;
+  }
+    {
+      return false;
+    }
   return true;
+}
+FilePath::FilePath()
+{
+}
+FilePath::FilePath() {}
 FilePath::FilePath(int npaths, ...)
+{   va_list list;
+    string* pathArray;
+  pathArray = new string[npaths];
+{
+  va_list list;
+  string* pathArray;
+  pathArray = new string[npaths];
   // initialise use of variable parameters
 …
   if (pathArray)
+  { for (int i = 0; i < npaths; i ++)
+    { // get next parameter (guaranteed to be a char * by caller!!!)
+        pathArray[i] = va_arg(list, char *);
+      // discount leading slashes
+      if (pathArray[i][0] == divider)
+      { pathArray[i] = pathArray[i].substr(1);
+      }
+      // get rid of terminating slashes if present
+      if (pathArray[i][pathArray[i].length() - 1] == divider)
+      { pathArray[i] = pathArray[i].substr(0, pathArray[i].length() - 1);
+      }
+    }
+  }
+    {
+      for (int i = 0; i < npaths; i ++)
+    {
+      // get next parameter (guaranteed to be a char * by caller!!!)
+      pathArray[i] = va_arg(list, char *);
+      // discount leading slashes
+      if (pathArray[i][0] == divider)
+        {
+          pathArray[i] = pathArray[i].substr(1);
+        }
+      // get rid of terminating slashes if present
+      if (pathArray[i][pathArray[i].length() - 1] == divider)
+        {
+          pathArray[i] = pathArray[i].substr(0, pathArray[i].length() - 1);
+        }
+    }
+    }
   // end of variable arguments
     va_end(list);
+  va_end(list);
   // construct path in the usual manner
   if (npaths > 0)
+  { this->path = pathArray[0];
+  }
+    {
+      this->path = pathArray[0];
+    }
   for (int i = 1; i < npaths; i ++)
+  { // don't add slashes if suppressed
+    if (pathArray[i][0] != '!')
+    {   this->path.append("\\");
+        this->path.append(pathArray[i]);
+    }
+    // if slashes suppressed, skip the magic character
+    else
+    { this->path.append(pathArray[i].substr(1));
+    }
+  }
+    {
+      // don't add slashes if suppressed
+      if (pathArray[i][0] != '!')
+    {
+      this->path.append("\\");
+      this->path.append(pathArray[i]);
+    }
+      // if slashes suppressed, skip the magic character
+      else
+    {
+      this->path.append(pathArray[i].substr(1));
+    }
+    }
   // destroy temporary array
   if (pathArray)
+  { delete[] pathArray;
+  }
+    {
+      delete[] pathArray;
+    }
   // set if this is a valid root (unlikely in this circumstance)
 …
 void FilePath::_init(string filePath, string subPath)
+{ // copy the directory path
+{
+  // copy the directory path
   this->path = filePath;
 …
   // 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);
+  {
+    this->path.append(dividerStr);
+  }
   // copy in the subdirectory path, eliminating any leading divider
   if (subPath[0] != divider)
+  { this->path.append(subPath);
+  }
+  else
+  { this->path.append(subPath.substr(1));
+  }
+    // set if this is a valid root (unlikely when joining two paths)
+  {
+    this->path.append(subPath);
+  }
+  else
+  {
+    this->path.append(subPath.substr(1));
+  }
+  // set if this is a valid root (unlikely when joining two paths)
   this->is_aRoot = __pathIsAValidRoot(this->path);
+}
 …
  * Construct a Filepath from a directory and a sub-directory path
  */
 FilePath::FilePath(string filePath, string subPath)
+{ this->_init(filePath, subPath);
+{
+  this->_init(filePath, subPath);
+}
 FilePath::FilePath(FilePath &path, string subPath)
+{ this->_init(path.pathString(), subPath);
+{
+  this->_init(path.pathString(), subPath);
+}
 FilePath::FilePath(string filePath)
+{ if (filePath.length() < 3)
+    { this->path    = filePath;
+    this->path.append("\\");
+  }
+  else
+  { this->path  = filePath;
+    // trim trailing directory separators
+    if (this->path[this->path.length() - 1] == '\\')
+    {   this->path = this->path.substr(0, this->path.length() - 1);
+    }
+  }
+{
+  if (filePath.length() < 3)
+    {
+      this->path = filePath;
+      this->path.append("\\");
+    }
+  else
+    {
+    this->path = filePath;
+    // trim trailing directory separators
+    if (this->path[this->path.length() - 1] == '\\')
+      {
+    this->path = this->path.substr(0, this->path.length() - 1);
+      }
+    }
   // check for a valid root
 …
 bool FilePath::isEmpty()
+{   return this->path.length() == 0;
+{
+  return this->path.length() == 0;
+}
 bool FilePath::isRoot()
+{   return this->is_aRoot;
+{
+  return this->is_aRoot;
+}
 bool FilePath::equals(FilePath &other)
+{   if (this->path.compare(other.path) == 0)
+    {   return true;
+  }
+{
+  if (this->path.compare(other.path) == 0)
+    {
+      return true;
+    }
   return false;
+}
 bool FilePath::equals(const char *other)
+{   if (strcmp(this->path.c_str(), other) == 0)
+    {   return true;
+  }
+{
+  if (strcmp(this->path.c_str(), other) == 0)
+    {
+      return true;
+    }
   return false;
+}
 …
  */
 FilePath *FilePath::rootDrive()
+{   FilePath *reply = this->root();
+    if (reply->path.length() >= 2 &&
+        reply->path[1] == ':' &&
+{
+  FilePath *reply = this->root();
+  if (reply->path.length() >= 2 &&
+      reply->path[1] == ':' &&
       isalpha(reply->path[0])) // if this is a drive letter destination
+  { reply->path = reply->path.substr(0, 2);
+  }
+  else
+  { reply->path = "";
+  {
+    reply->path = reply->path.substr(0, 2);
+  }
+  else
+  {
+    reply->path = "";
+  }
   return reply;
 …
  */
 FilePath *FilePath::root()
+{ // TODO: cope with network destinations
+    FilePath *reply = new FilePath(this->path);
+{
+  // TODO: cope with network destinations
+  FilePath *reply = new FilePath(this->path);
   unsigned int truncate = reply->path.find(divider);
   if (truncate != -1) // if it's got a divider then skip past it;
+                                        // we will assume that it's a drive letter first
+  { truncate ++;
+    reply->path = reply->path.substr(0, truncate);
+  }
+                      // we will assume that it's a drive letter first
+  {
+    truncate ++;
+    reply->path = reply->path.substr(0, truncate);
+  }
   // if we've got a drive, then we'll use it plus the divider
   else if (reply->path[1] == ':' && reply->path.length() == 2 &&
+                 isalpha(reply->path[0]))
+  { reply->path = reply->path + dividerStr;
+  }
+  else
+  { reply->path = "";
+  }
+       isalpha(reply->path[0]))
+    {
+      reply->path = reply->path + dividerStr;
+    }
+  else
+    {
+      reply->path = "";
+    }
   return reply;
+}
 …
  */
 bool FilePath::exists()
 { File f(this->path);
     return f.exists();
+{
+  File f(this->path);
+  return f.exists();
+}
 …
  */
 FilePath *FilePath::parent()
+{ // TODO: cope with network roots
+    FilePath *reply = new FilePath(this->path);
+    // get the last divider
+    unsigned int truncate   =   reply->path.find_last_of(divider);
+{
+  // TODO: cope with network roots
+  FilePath *reply = new FilePath(this->path);
+  // get the last divider
+  unsigned int truncate = reply->path.find_last_of(divider);
   // if it exists, then we can do a normal get parent
   if (truncate != -1)
+  { // if it's the leftmost one as well then we'll skip it to
+    // give a parent of <drive>:\ as this patches some problems
+    // with windows calls!  Note that a parent call to the returned
+    // object in this case will return itself
+    if (truncate == reply->path.find(divider))
+    {   truncate ++;
+    }
+    reply->path = reply->path.substr(0, truncate);
+  }
+    {
+      // if it's the leftmost one as well then we'll skip it to
+      // give a parent of <drive>:\ as this patches some problems
+      // with windows calls!  Note that a parent call to the returned
+      // object in this case will return itself
+      if (truncate == reply->path.find(divider))
+    {
+      truncate ++;
+    }
+      reply->path = reply->path.substr(0, truncate);
+    }
   // if we've got a drive letter only, then append the divider to
   // patch problematic windows calls;  again subsequent parent
   // calls to our returned object would in effect return itself
   else if (reply->path[1] == ':' && reply->path.length() == 2 &&
+                 isalpha(reply->path[0]))
+  { reply->path = reply->path + dividerStr;
+  }
+       isalpha(reply->path[0]))
+    {
+      reply->path = reply->path + dividerStr;
+    }
   // a non-rooted object; return blank
   else
+  { reply->path = "";
+  }
+    reply->is_aRoot = __pathIsAValidRoot(reply->path);
+    {
+      reply->path = "";
+    }
+  reply->is_aRoot = __pathIsAValidRoot(reply->path);
   return reply;
+}
 FilePath *FilePath::append(FilePath &subPath)
+{   return new FilePath(this->path, subPath.path);
+{
+  return new FilePath(this->path, subPath.path);
+}
 FilePath *FilePath::append(char *subPath)
+{   return new FilePath(this->path, subPath);
+{
+  return new FilePath(this->path, subPath);
+}
 const char *FilePath::cString()
+{   return this->path.c_str();
+{
+  return this->path.c_str();
+}
 string FilePath::pathString()
+{   return this->path;
+{
+  return this->path;
+}
 bool FilePath::ensureWriteablePath()
+{ //TODO: don't assume that all roots are writeable!
+    if (this->isRoot())
+  { return true;
+  }
+    // does this path exist?
+    File thisFile(this->path);
+{
+  //TODO: don't assume that all roots are writeable!
+  if (this->isRoot())
+    {
+      return true;
+    }
+  // does this path exist?
+  File thisFile(this->path);
   bool reply = false;
     // if not, ensure writeable parent
+  // if not, ensure writeable parent
   if (thisFile.exists() == false)
+  { FilePath    *parent;
+    // create parent reference
+    parent  = this->parent();
+    if (parent->equals(thisFile.getFileName()))
+    { delete parent;
+        return true;
+    }
+    // if parent is writeable then try to make the directory
+    if (parent->ensureWriteablePath())
+    { // make this directory; if it succeeded we reply positively
+        if (mkdir(this->path.c_str()) == 0)
+      { reply = true;
+      }
+    }
+    // destroy parent reference
+    delete parent;
+  }
+    {
+      FilePath *parent;
+      // create parent reference
+      parent = this->parent();
+      if (parent->equals(thisFile.getFileName()))
+    {
+      delete parent;
+      return true;
+    }
+      // if parent is writeable then try to make the directory
+      if (parent->ensureWriteablePath())
+    {
+      // make this directory; if it succeeded we reply positively
+      if (_mkdir(this->path.c_str()) == 0)
+        {
+          reply = true;
+        }
+    }
+      // destroy parent reference
+      delete parent;
+    }
   else if (thisFile.isDirectory() == true)
+  { // is this writeable by user?; if so we're okay
+    if (thisFile.isWriteable())
+    {   reply = true;
+    }
+  }
+    {
+      // is this writeable by user?; if so we're okay
+      if (thisFile.isWriteable())
+    {
+      reply = true;
+    }
+    }
   return reply;
+}

trunk/gsinstaller/FilePath.h

-              r1498
+              r1536
 class FilePath
+{   private:
+        string path;            // full path of this item
+    bool     is_aRoot;  // indicates whether this directory/file is a file root
+    void   _init(string path, string subPath);
+    public:
+    FilePath();
+    FilePath(string filePath);
+    FilePath(string filePath, string filePath2);
+    FilePath(int nPaths, ...);
+    FilePath(FilePath &path, string subPath);
+    bool      equals(FilePath &path);
+    bool      equals(const char *path);
+    bool            isRoot();
+    bool            isEmpty();
+    FilePath *append(FilePath &path);
+    FilePath *append(char *path);
+    FilePath *parent();
+    FilePath *root();
+    FilePath *rootDrive();
+    bool ensureWriteablePath();
+    bool exists();
+    const char *cString();
+    string      pathString();
+    bool operator==(const FilePath &b) { return this->path == b.path; }
+    bool operator!=(const FilePath &b) { return this->path != b.path; }
+    bool operator<(const FilePath &b) { return this->path < b.path; }
+{
+private:
+  string path;                  // full path of this item
+  bool is_aRoot;                // indicates whether this directory/file is a file root
+  void _init(string path, string subPath);
+public:
+  FilePath();
+  FilePath(string filePath);
+  FilePath(string filePath, string filePath2);
+  FilePath(int nPaths, ...);
+  FilePath(FilePath &path, string subPath);
+  bool equals(FilePath &path);
+  bool equals(const char *path);
+  bool isRoot();
+  bool isEmpty();
+  FilePath *append(FilePath &path);
+  FilePath *append(char *path);
+  FilePath *parent();
+  FilePath *root();
+  FilePath *rootDrive();
+  bool ensureWriteablePath();
+  bool exists();
+  const char *cString();
+  string pathString();
+  bool operator==(const FilePath &b) const { return this->path == b.path; }
+  bool operator!=(const FilePath &b) const { return this->path != b.path; }
+  bool operator<(const FilePath &b) const { return this->path < b.path; }
 };
 #endif

trunk/gsinstaller/copyProgress.cpp

-              r1475
+              r1536
 extern HINSTANCE app_instance;
 extern gsInstall_getDesktopExt(int *x, int *y);
+extern void gsInstall_getDesktopExt(int *x, int *y);
+LRESULT CALLBACK copyProgressBar_windowProc(    HWND window, UINT message,
+                                                                                            WPARAM wParam, LPARAM lParam)
+{   switch (message)
+    {   case WM_CREATE:
+    {   CREATESTRUCT *createStruct = (CREATESTRUCT *) lParam;
+LRESULT CALLBACK copyProgressBar_windowProc(HWND window, UINT message,
+                        WPARAM wParam, LPARAM lParam)
+{
+  switch (message)
+    {
+    case WM_CREATE:
+      {
+    CREATESTRUCT *createStruct = (CREATESTRUCT *) lParam;
         long *createParams;
         copyProgressBar *progressBar;
+      createParams = (long *) createStruct->lpCreateParams;
+    createParams = (long *) createStruct->lpCreateParams;
+    SetWindowLong(window, GWL_USERDATA, createParams[0]);
+    progressBar = (copyProgressBar *) GetWindowLong(window, GWL_USERDATA);
+    if (progressBar == NULL)
+      {
+        MessageBox(0, "A", "A", MB_OK);
+      }
+            SetWindowLong(window, GWL_USERDATA, createParams[0]);
+      progressBar = (copyProgressBar *) GetWindowLong(window, GWL_USERDATA);
+        if (progressBar == NULL)
+      { MessageBox(0, "A", "A", MB_OK);
+    CreateWindowEx( 0, "STATIC", (char *) createParams[1], WS_CHILD | WS_VISIBLE,
+, 5, 180, 20, window, (HMENU) 0,
+            app_instance, NULL);
+      }
+      break;
       CreateWindowEx( 0, "STATIC", (char *) createParams[1], WS_CHILD | WS_VISIBLE,
+, 5, 180, 20, window, (HMENU) 0,
                          app_instance, NULL);
+    default:
+      return(DefWindowProc(window, message, wParam, lParam));
+    }
+    }
+    break;
+        default:
+            return(DefWindowProc(window, message, wParam, lParam));
+  }
+    return 0;
+  return 0;
+}

trunk/gsinstaller/dirSelector.cpp

-              r1397
+              r1536
 void dirSelector::requestPath(HWND parent, LPSTR message)
+{ OPENFILENAME  openStr;
+    char                    fileName[256] = "dir.dir\0";
+  DWORD                 error;
+  BROWSEINFO    bInfo;
+  int                       image;
+{
+  OPENFILENAME openStr;
+  char fileName[256] = "dir.dir\0";
+  DWORD error;
+  BROWSEINFO bInfo;
+  int image;
   bInfo.hwndOwner = parent;
   bInfo.pidlRoot                = NULL;
   bInfo.pszDisplayName  = fileName;
   bInfo.lpszTitle               = message;
   bInfo.ulFlags                 = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
   bInfo.lpfn                        = initSelect;
   bInfo.lParam                  = (LONG) this;
   bInfo.iImage                  = image = 0;
+  bInfo.pidlRoot = NULL;
+  bInfo.pszDisplayName = fileName;
+  bInfo.lpszTitle = message;
+  bInfo.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
+  bInfo.lpfn = initSelect;
+  bInfo.lParam = (LONG) this;
+  bInfo.iImage = image = 0;
   LPITEMIDLIST itemList = SHBrowseForFolder(&bInfo);
   if (itemList != NULL)
+  { SHGetPathFromIDList(itemList, fileName);
+    this->setPath(fileName);
+  }
+    {
+      SHGetPathFromIDList(itemList, fileName);
+      this->setPath(fileName);
+    }
   return;
+    openStr.lStructSize = sizeof(OPENFILENAME);
+  openStr.hwndOwner     = parent;
+  openStr.hInstance     = 0;// app_instance; //this->dlgBlock;
+  openStr.lpstrFilter               = NULL;
+  openStr.lpstrCustomFilter = NULL;
+  openStr.nMaxCustFilter        = NULL;
+  openStr.nFilterIndex          = 0;
+  openStr.lpstrFile                 = fileName;
+  openStr.nMaxFile                  = 255;
+  openStr.lpstrFileTitle        = NULL;
+  openStr.lpstrInitialDir       = NULL;
+  openStr.lpstrTitle                = message;
+  openStr.Flags                         = OFN_ENABLEHOOK | OFN_NOTESTFILECREATE | OFN_NOVALIDATE | OFN_EXPLORER; //  || OFN_ENABLETEMPLATE | OFN_EXPLORER;
+  openStr.nFileOffset               = 0;
+  openStr.nFileExtension        = 4;
+  openStr.lpstrDefExt               = NULL;
+  openStr.lCustData                 = NULL;
+  openStr.lpfnHook                  = hookProc;
+  openStr.lpTemplateName        = 0; // "MySaveAsDlg";
+  openStr.lStructSize = sizeof(OPENFILENAME);
+  openStr.hwndOwner = parent;
+  openStr.hInstance = 0; // app_instance; //this->dlgBlock;
+  openStr.lpstrFilter = NULL;
+  openStr.lpstrCustomFilter = NULL;
+  //  openStr.nMaxCustFilter = NULL;
+  openStr.nMaxCustFilter = 0;
+  openStr.nFilterIndex = 0;
+  openStr.lpstrFile = fileName;
+  openStr.nMaxFile = 255;
+  openStr.lpstrFileTitle = NULL;
+  openStr.lpstrInitialDir = NULL;
+  openStr.lpstrTitle = message;
+  openStr.Flags = OFN_ENABLEHOOK | OFN_NOTESTFILECREATE | OFN_NOVALIDATE | OFN_EXPLORER; //  || OFN_ENABLETEMPLATE | OFN_EXPLORER;
+  openStr.nFileOffset = 0;
+  openStr.nFileExtension = 4;
+  openStr.lpstrDefExt = NULL;
+  //  openStr.lCustData = NULL;
+  openStr.lCustData = 0;
+  openStr.lpfnHook = hookProc;
+  openStr.lpTemplateName = 0; // "MySaveAsDlg";
   if (GetSaveFileName(&openStr) == 0)
+  { error = CommDlgExtendedError();
+  }
+    {
+      error = CommDlgExtendedError();
+    }
   else
+  { if (this->path != NULL)
+    { free(this->path);
+    {
+      if (this->path != NULL)
+    {
+      free(this->path);
+    }
+      this->path = (char *) malloc (strlen(openStr.lpstrFile) + 1);
+      strcpy(this->path, openStr.lpstrFile);
+    }
-    this->path = (char *) malloc (strlen(openStr.lpstrFile) + 1);
-    strcpy(this->path, openStr.lpstrFile);
+  }
+}
 char *dirSelector::selectedPath()
+{   return this->path;
+{
+  return this->path;
+}

trunk/gsinstaller/dirent.cpp

-              r1524
+              r1536
 #include <string.h>
 #include <windows.h>
+#include <malloc.h>
 #include "dirent.h"
 void _getFileName(DIRSTR *dirlist, WIN32_FIND_DATA *winFileData)
+{ // get leaf if directory name is given
+    char *leafname = strrchr(winFileData->cFileName, '\\');
+{
+  // get leaf if directory name is given
+  char *leafname = strrchr(winFileData->cFileName, '\\');
+    if (leafname)
+  { leafname ++;
+  if (leafname)
+  {
+    leafname ++;
+  }
   else
+  { leafname = winFileData->cFileName;
+  {
+    leafname = winFileData->cFileName;
+  }
     strcpy(dirlist->fileData.d_name, leafname);
+  strcpy(dirlist->fileData.d_name, leafname);
+}
 DIRSTR *opendir(const char *name)
+{ char buffer[MAX_PATH];
+{
+  char buffer[MAX_PATH];
   WIN32_FIND_DATA winFileData;
+    DIRSTR *newlist = (DIRSTR *) malloc(sizeof(DIRSTR));
+  DIRSTR *newlist = (DIRSTR *) malloc(sizeof(DIRSTR));
   strcpy(buffer, name);
   if (buffer[strlen(buffer)-1] != '\\')
+  { strcat(buffer, "\\*");
+  }
+    {
+      strcat(buffer, "\\*");
+    }
   else
+  { strcat(buffer, "*");
+  }
+    {
+      strcat(buffer, "*");
+    }
   newlist->searchHandle = FindFirstFile(buffer, &winFileData);
   if (newlist->searchHandle == INVALID_HANDLE_VALUE)
+  { DWORD error = GetLastError();
+    if (error == ERROR_NO_MORE_FILES)
+    { newlist->first = 2;
+    {
+      DWORD error = GetLastError();
+      if (error == ERROR_NO_MORE_FILES)
+    {
+      newlist->first = 2;
+    }
+      else
+    {
+      free(newlist);
+      newlist = NULL;
+    }
+    }
+    else
+    {   free(newlist);
+      newlist = NULL;
+  else
+    {
+      _getFileName(newlist, &winFileData);
+      newlist->first = 1;
+    }
+  }
-  else
-  { _getFileName(newlist, &winFileData);
-    newlist->first = 1;
+  }
   return newlist;
+}
 dirent *readdir(DIRSTR *dirlist)
+{ if (dirlist->first == 2)
+    { // empty directory
+    return NULL;
+  }
+    else if (dirlist->first != 1)
+    { WIN32_FIND_DATA winFileData;
+    if (FindNextFile(dirlist->searchHandle, &winFileData) == 0)
+    { DWORD error = GetLastError();
+        return NULL;
+{
+  if (dirlist->first == 2)
+    {
+      // empty directory
+      return NULL;
+    }
+    else
+    { _getFileName(dirlist, &winFileData);
+  else if (dirlist->first != 1)
+    {
+      WIN32_FIND_DATA winFileData;
+      if (FindNextFile(dirlist->searchHandle, &winFileData) == 0)
+    {
+      DWORD error = GetLastError();
+      return NULL;
+    }
+      else
+    {
+      _getFileName(dirlist, &winFileData);
+    }
+    }
+  }
   else
+  { dirlist->first = 0;
+  }
+    {
+      dirlist->first = 0;
+    }
   return &dirlist->fileData;
 …
 void closedir(DIRSTR *dirlist)
+{ free(dirlist);
+{
+  free(dirlist);
+}

trunk/gsinstaller/file.h

-              r1397
+              r1536
 class File
+{   private:
+    string              name;
+    unsigned long size;
+        vector<File>    children;
+    bool                    is_dir;
+    bool                    does_exist;
+    bool          is_writable;
+{
+private:
+  string name;
+  unsigned long size;
+  vector<File> children;
+  bool is_dir;
+  bool does_exist;
+  bool is_writable;
         void _getDetails();
     void getChildren();
     protected:
   public:
     File();
     File(string filename, unsigned long filesize);
     File(string filename);
     void copy(char *destination);
     bool isDirectory();
     bool isWriteable();
     bool exists();
     unsigned long getRawFileSize();
     unsigned long getFileSize();
     const char *getFileName();
     unsigned long getDiskSpace(DiskSpace &diskSpace);
     vector<File>::iterator childBegin();
     vector<File>::iterator childEnd();
+  void _getDetails();
+  void getChildren();
+protected:
+public:
+  File();
+  File(string filename, unsigned long filesize);
+  File(string filename);
+  void copy(char *destination);
+  bool isDirectory();
+  bool isWriteable();
+  bool exists();
+  unsigned long getRawFileSize();
+  unsigned long getFileSize();
+  const char *getFileName();
+  unsigned long getDiskSpace(DiskSpace &diskSpace);
+  vector<File>::iterator childBegin();
+  vector<File>::iterator childEnd();
 };

trunk/gsinstaller/fileCopier.cpp

-              r1498
+              r1536
 #include <stdlib.h>
 #include <stdio.h>
+#include <dir.h>
+//#include <dir.h>
+#include <direct.h>
 fileCopySet::fileCopySet()
+{   this->sourceDir = NULL;
+    this->destDir       = NULL;
+{
+  // do we need this - they're FilePath's, not pointers
+  //  this->sourceDir = NULL;
+  //  this->destDir = NULL;
+}
 fileCopySet::fileCopySet(FileVector files, FilePath &from, FilePath &to)
+{   this->fileList  = files;
+    this->sourceDir = from;
+  this->destDir     = to;
+  this->dataSize    = 0;
+    FileVector::iterator here   = files.begin();
+  FileVector::iterator end  = files.end();
+  while (here != end)
+  { this->dataSize  +=  here->getFileSize();
+    here ++;
+  }
+{
+  this->fileList = files;
+  this->sourceDir = from;
+  this->destDir = to;
+  this->dataSize = 0;
+  FileVector::iterator here = files.begin();
+  FileVector::iterator end = files.end();
+  while (here != end)
+    {
+      this->dataSize += here->getFileSize();
+      here ++;
+    }
+}
 …
  */
 char *fileCopySet::destination(File *file)
+{   const char *oldname = file->getFileName();
+    char *newname = (char *) malloc(strlen(oldname) - strlen(this->sourceDir.cString()) + strlen(this->destDir.cString()) + 1);
+{
+  const char *oldname = file->getFileName();
+  char *newname = (char *) malloc(strlen(oldname) - strlen(this->sourceDir.cString()) + strlen(this->destDir.cString()) + 1);
   if (newname != NULL)
+  { strcpy(newname, this->destDir.cString());
+    strcat(newname, &oldname[strlen(this->sourceDir.cString())]);
+  }
+    {
+      strcpy(newname, this->destDir.cString());
+      strcat(newname, &oldname[strlen(this->sourceDir.cString())]);
+    }
   return newname;
 …
  */
 bool fileCopySet::copyFile(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar)
+{ unsigned long copied = 0;
+    unsigned long bytes_read, bytes_written;
+    unsigned char buffer[65536];
+{
+  unsigned long copied = 0;
+  unsigned long bytes_read, bytes_written;
+  unsigned char buffer[65536];
   FILE *read_handle, *write_handle;
   char *destination;
   // get destination as a char[] block; will free it later
   destination   = this->destination(file);
+  destination = this->destination(file);
   // get read and write file handles
   read_handle   = fopen(file->getFileName(), "rb");
+  read_handle = fopen(file->getFileName(), "rb");
   if (read_handle == NULL)
+  { return false;
+  }
+    write_handle    = fopen(destination, "wb");
+    {
+      return false;
+    }
+  write_handle = fopen(destination, "wb");
   if (write_handle == NULL)
+  { fclose(read_handle);
+    return false;
+  }
+    {
+      fclose(read_handle);
+      return false;
+    }
   while (copied < file->getFileSize())
+  { // TODO: lock
+        // read so many bytes
+    if (file->getFileSize() - copied < 65536)
+    {   bytes_read = file->getFileSize() - copied;
+    }
+    else
+    {   bytes_read  = 65536;
+    }
+    bytes_read = fread((void *) buffer, 1, bytes_read, read_handle);
+    // write so many bytes
+    bytes_written   =   fwrite((void *) buffer, 1, bytes_read, write_handle);
+    // TODO: unlock
+    // note new bytes copied
+    copied                  +=  bytes_written;
+    this->dataSize  += bytes_written;
+  }
+    {
+      // TODO: lock
+      // read so many bytes
+      if (file->getFileSize() - copied < 65536)
+    {
+      bytes_read = file->getFileSize() - copied;
+    }
+      else
+    {
+      bytes_read = 65536;
+    }
+      bytes_read = fread((void *) buffer, 1, bytes_read, read_handle);
+      // write so many bytes
+      bytes_written = fwrite((void *) buffer, 1, bytes_read, write_handle);
+      // TODO: unlock
+      // note new bytes copied
+      copied += bytes_written;
+      this->dataSize += bytes_written;
+    }
   fclose(read_handle);
   fclose(write_handle);
 …
   // free destination filename text
   if (monitor != NULL)
+  { monitor->copied(file->getFileName(), destination, false);
+  }
+    {
+      monitor->copied(file->getFileName(), destination, false);
+    }
   delete destination;
   return true;
 …
  */
 void fileCopySet::copy(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar)
+{ // just skip this file if it doesn't exist
+    if (file->exists() == false)
+    {   return;
+  }
+{
+  // just skip this file if it doesn't exist
+  if (file->exists() == false)
+    {
+      return;
+    }
   // if a directory, scan it.
+    if (file->isDirectory())
+    { // create directory
+    char *thisDestDir   = this->destination(file);
+    mkdir(thisDestDir);
+    // note amount of data copied
+    // this->copied += file->getRawFileSize();
+    // note for uninstall the action done
+      if (monitor != NULL)
+    {   monitor->copied(file->getFileName(), thisDestDir, true);
+  if (file->isDirectory())
+    {
+      // create directory
+      char *thisDestDir = this->destination(file);
+      _mkdir(thisDestDir);
+      // note amount of data copied
+      // this->copied += file->getRawFileSize();
+      // note for uninstall the action done
+      if (monitor != NULL)
+    {
+      monitor->copied(file->getFileName(), thisDestDir, true);
+    }
+    // copy children
+    vector<File>::iterator here = file->childBegin();
+    vector<File>::iterator end  = file->childEnd();
+    while (here != end)
+    {   this->copy(here, monitor, progressBar);
+        here ++;
+    }
+    // delete constructed destination name
+    delete thisDestDir;
+  }
+      // copy children
+      vector<File>::iterator here = file->childBegin();
+      vector<File>::iterator end = file->childEnd();
+      while (here != end)
+    {
+      this->copy(here, monitor, progressBar);
+      here ++;
+    }
+      // delete constructed destination name
+      delete thisDestDir;
+    }
   // not a directory; just copy the file
   else
+  { // copy file itself
+    this->copyFile(file, monitor, progressBar);
+  }
+    {
+      // copy file itself
+      this->copyFile(file, monitor, progressBar);
+    }
   progressBar.done(file->getRawFileSize());
+}
 void fileCopySet::copy(fileCopyMonitor *monitor, copyProgressBar &progressBar)
+{   FileVector::iterator here = fileList.begin();
+    FileVector::iterator end    = fileList.end();
+  while (here != end)
+  { this->copy(here, monitor, progressBar);
+    here ++;
+  }
+{
+  FileVector::iterator here = fileList.begin();
+  FileVector::iterator end = fileList.end();
+  while (here != end)
+    {
+      this->copy(here, monitor, progressBar);
+      here ++;
+    }
+}
 unsigned long fileCopySet::getCopiedSize(DiskSpace &space)
+{ // initialise counters for size
+    unsigned long copiedSize        = 0;
+{
+  // initialise counters for size
+  unsigned long copiedSize = 0;
   // iterate through our list of files to obtain total space requirement
   FileVector::iterator here = fileList.begin();
+    FileVector::iterator end    = fileList.end();
+  while (here != end)
+  { copiedSize += here->getDiskSpace(space);
+    here ++;
+  }
+  FileVector::iterator end = fileList.end();
+  while (here != end)
+    {
+      copiedSize += here->getDiskSpace(space);
+      here ++;
+    }
   return copiedSize;
+}
 unsigned long fileCopySet::getOriginalSize()
+{ // initialise counters for size
+    return this->dataSize;
+{
+  // initialise counters for size
+  return this->dataSize;
+}
 …
  */
 bool fileCopier::checkSpace()
+{ fileCopySetList localSet = this->list;
+    do
+  { unsigned int i = 0;
+    // get destination root and use it to obtain space check information
+        FilePath *destRoot = localSet[0].destDir.root();
+        DiskSpace space(destRoot->cString());
+      // check that diskspace checking is functional
+      if (space.initialisedOk() == false)
+    { delete destRoot;
+        return false;
+{
+  fileCopySetList localSet = this->list;
+  do
+    {
+      unsigned int i = 0;
+      // get destination root and use it to obtain space check information
+      FilePath *destRoot = localSet[0].destDir.root();
+      DiskSpace space(destRoot->cString());
+      // check that diskspace checking is functional
+      if (space.initialisedOk() == false)
+    {
+      delete destRoot;
+      return false;
+    }
+    // get size of the first set
+    unsigned long copiedSize = localSet[0].getCopiedSize(space);
+    // dispose of the first set
+    localSet.erase(localSet.begin());
+    // get all remaining sets and in turn if they share the root with
+    // the first root, add their size to the count and remove them from
+    // the local list of sets; otherwise skip
+    while (i < localSet.size())
+    { // get a new root object for this set's destination
+        FilePath *p = localSet[i].destDir.root();
+        if (*destRoot == *p)
+      { copiedSize  +=  localSet[i].getCopiedSize(space);
+        localSet.erase(localSet.begin() + i);
+      }
+      else
+      { i ++;
+      }
+      // delete the constructed root
+      delete p;
+    }
+    // dispose of destination root
+    delete destRoot;
+      // return false if not enough space
+    if (space.totalFreeSpace() < copiedSize)
+    { return false;
+      // get size of the first set
+      unsigned long copiedSize = localSet[0].getCopiedSize(space);
+      // dispose of the first set
+      localSet.erase(localSet.begin());
+      // get all remaining sets and in turn if they share the root with
+      // the first root, add their size to the count and remove them from
+      // the local list of sets; otherwise skip
+      while (i < localSet.size())
+    {
+      // get a new root object for this set's destination
+      FilePath *p = localSet[i].destDir.root();
+      if (*destRoot == *p)
+        {
+          copiedSize += localSet[i].getCopiedSize(space);
+          localSet.erase(localSet.begin() + i);
+        }
+      else
+        {
+          i ++;
+        }
+      // delete the constructed root
+      delete p;
+    }
+      // dispose of destination root
+      delete destRoot;
+      // return false if not enough space
+      if (space.totalFreeSpace() < copiedSize)
+    {
+      return false;
+    }
+  } while (localSet.size() != 0);
+    } while (localSet.size() != 0);
   // record size and initialise the progressbar with the same
   this->dataSize    = 0;
+  this->dataSize = 0;
   for (unsigned int i = 0; i < this->list.size(); i ++)
+  { this->dataSize  += this->list[i].getOriginalSize();
+  }
+    {
+      this->dataSize += this->list[i].getOriginalSize();
+    }
   this->progressBar.init(this->dataSize);
 …
 fileCopier::fileCopier(fileCopyMonitor *monitor, fileCopySetList &_list)
+{   this->list  = _list;
+  this->dataSize    = 0;
+  this->copied      = 0;
+  this->monitor     = monitor;
+{
+  this->list = _list;
+  this->dataSize = 0;
+  this->copied = 0;
+  this->monitor = monitor;
+}
 fileCopier::fileCopier(fileCopyMonitor *monitor)
+{ this->dataSize    = 0;
+  this->copied      = 0;
+  this->monitor     = monitor;
+{
+  this->dataSize = 0;
+  this->copied = 0;
+  this->monitor = monitor;
+}
 void fileCopier::copy()
+{   fileCopySetList::iterator here = list.begin();
+    fileCopySetList::iterator end   = list.end();
+{
+  fileCopySetList::iterator here = list.begin();
+  fileCopySetList::iterator end = list.end();
   this->progressBar.show();
   while (here != end)
+  { here->copy(this->monitor, this->progressBar);
+    here ++;
+  }
+    {
+      here->copy(this->monitor, this->progressBar);
+      here ++;
+    }
   this->progressBar.close();
+}

trunk/gsinstaller/fileCopier.h

-              r1475
+              r1536
 class fileCopyMonitor
+{   public:
+        fileCopyMonitor() {};
+        virtual void copied(string from, string to, bool isDir) = 0;
+{
+public:
+  fileCopyMonitor() {};
+  virtual void copied(string from, string to, bool isDir) = 0;
 };
 class fileCopySet
+{ private:
+        FileVector    fileList;
+    FilePath      sourceDir;
+        unsigned long   dataSize;
+  public:
+    FilePath      destDir;
+    fileCopySet();
+    fileCopySet(FileVector files, FilePath &from, FilePath &to);
+      char *destination(File *file);
+    unsigned long getOriginalSize();
+    unsigned long getCopiedSize(DiskSpace &space);
+    bool copyFile(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+    void copy(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+    void copy(fileCopyMonitor *monitor, copyProgressBar &progressBar);
+{
+private:
+  FileVector fileList;
+  FilePath sourceDir;
+  unsigned long dataSize;
+public:
+  FilePath destDir;
+  fileCopySet();
+  fileCopySet(FileVector files, FilePath &from, FilePath &to);
+  char *destination(File *file);
+  unsigned long getOriginalSize();
+  unsigned long getCopiedSize(DiskSpace &space);
+  bool copyFile(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+  void copy(File *file, fileCopyMonitor *monitor, copyProgressBar &progressBar);
+  void copy(fileCopyMonitor *monitor, copyProgressBar &progressBar);
 };
 …
 class fileCopier
+{ private:
+        fileCopySetList list;
+        unsigned long       dataSize;
+    unsigned long   copied;
+      copyProgressBar progressBar;
+    fileCopyMonitor *monitor;
+    protected:
+  public:
+    fileCopier::fileCopier(fileCopyMonitor *monitor, fileCopySetList &list);
+    fileCopier::fileCopier(fileCopyMonitor *monitor);
+    void fileCopier::addSet(fileCopySet &set) { this->list.push_back(set); }
+    bool checkSpace();
+    void copy();
+{
+private:
+  fileCopySetList list;
+  unsigned long dataSize;
+  unsigned long copied;
+  copyProgressBar progressBar;
+  fileCopyMonitor *monitor;
+protected:
+public:
+  fileCopier::fileCopier(fileCopyMonitor *monitor, fileCopySetList &list);
+  fileCopier::fileCopier(fileCopyMonitor *monitor);
+  void fileCopier::addSet(fileCopySet &set) { this->list.push_back(set); }
+  bool checkSpace();
+  void copy();
 };
 #define _FILECOPIER_H_

trunk/gsinstaller/gsManifest.cpp

-              r1498
+              r1536
  */
 void gsManifest::expandGroups()
+{   strArrayMap::iterator here = this->manifests.begin();
+  strArrayMap::iterator end = this->manifests.end();
+{
+  strArrayMap::iterator here = this->manifests.begin();
+  strArrayMap::iterator end = this->manifests.end();
   while (here != end)
+  { this->expandGroup((*here).first);
+    here ++;
+  }
+    {
+      this->expandGroup((*here).first);
+      here ++;
+    }
+}
 …
  * expand a particular group
  */
+void gsManifest::expandGroup(string &group)
+{   stringArray &array = this->manifests[group];
+    unsigned int i = 0;
+void gsManifest::expandGroup(const string &group)
+{
+  stringArray &array = this->manifests[group];
+  unsigned int i = 0;
   while (i < array.size())
+  { if (this->isGroup(array[i]))
+    {   this->expandGroupInstance(group, array[i]);
+    }
+  {
+    if (this->isGroup(array[i]))
+      {
+    this->expandGroupInstance(group, array[i]);
+      }
     else
+    {   i ++;
+    {
+      i ++;
+    }
+  }
 …
  * expand a group instance inside a given group
  */
+void gsManifest::expandGroupInstance(string parentgroup, string groupName)
+{ // remove the group instance from the parent
+    this->manifests[parentgroup].remove(groupName);
+    // create a "clean" name without the { } brackets
+    string group(groupName, 1, groupName.length() - 2);
+void gsManifest::expandGroupInstance(const string &parentgroup, string groupName)
+{
+  // remove the group instance from the parent
+  this->manifests[parentgroup].remove(groupName);
+  // create a "clean" name without the { } brackets
+  string group(groupName, 1, groupName.length() - 2);
   // circular reference - we're kind and ignore it!!
   if (parentgroup.compare(group) == 0)
+  { return;
+  {
+    return;
+  }
   // lookup chidl group and add it to the parent
     this->manifests[parentgroup].add(this->manifests[group]);
+  this->manifests[parentgroup].add(this->manifests[group]);
+}
 …
  */
 bool gsManifest::isGroup(string &name)
+{ if (name[0] == '{' && name[name.length()-1] == '}')
+    {   return true;
+  }
+    return false;
+{
+  if (name[0] == '{' && name[name.length()-1] == '}')
+    {
+      return true;
+    }
+  return false;
+}
 void gsManifest::expandMacro(string macro, string value)
+{   string macroRef = "\$(" + macro + ")";
+{
+  // illegal escape sequence ??
+  // string macroRef = "\$(" + macro + ")";
+  string macroRef = "$(" + macro + ")";
   strArrayMap::iterator here = this->manifests.begin();
 …
   while (here != end)
+  { stringArray &array = this->manifests[(*here).first];
+    unsigned int i = 0;
+  {
+    stringArray &array = this->manifests[(*here).first];
+    unsigned int i = 0;
     while (i < array.size())
+    { unsigned int pos;
+      {
+    unsigned int pos;
         while ((pos = array[i].find(macroRef)) < array[i].length() && pos != -1)
+            {   array[i].replace(pos, macroRef.length(), value);
+      {
+        array[i].replace(pos, macroRef.length(), value);
+      }
+    i ++;
+      }
-      i ++;
+    }
     here ++;
+  }
 …
 void gsManifest::selectGroup(string groupName, FilePath &destination)
+{ stringArray &groupArray = this->manifests[groupName];
+    groupArray  = this->manifests[groupName];
+{
+  stringArray &groupArray = this->manifests[groupName];
+  // do we really need this twice ??
+  // groupArray = this->manifests[groupName];
   this->selected[destination].add(groupArray);
+}

trunk/gsinstaller/gsManifest.h

-              r1475
+              r1536
 class gsManifest : public installAgent, fileCopyMonitor
+{   private:
+    protected:
+        strArrayMap                 manifests;
+    pathStringArrayMap  selected;
+{
+private:
+protected:
+  strArrayMap manifests;
+  pathStringArrayMap selected;
     bool getManifestLine(char *line, string &macro);
   public:
     gsManifest(installManager &manager, FilePath &path); // used for install
     gsManifest(installManager &manager); // used for uninstall
     bool getManifest(FilePath &path);
     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);
     void expandGroups();
     bool isGroup(string &name);
     void expandMacro(string macroName, string value);
     void clearSelection();
     bool copy(FilePath *source);
     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
+  bool getManifestLine(char *line, string &macro);
+public:
+  gsManifest(installManager &manager, FilePath &path); // used for install
+  gsManifest(installManager &manager); // used for uninstall
+  bool getManifest(FilePath &path);
+  void logAction(string actionName, string file);
+  void logAction(string actionName, string source, string dest);
+  bool undoAction(string actionName, stringArray &params);
+  void expandGroupInstance(const string &parentgroup, string groupName);
+  void expandGroup(const string &group);
+  void expandGroups();
+  bool isGroup(string &name);
+  void expandMacro(string macroName, string value);
+  void clearSelection();
+  bool copy(FilePath *source);
+  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/gsPlatform.cpp

-              r1397
+              r1536
 bool gsPlatform::isUserAdministrator()
+{ if (this->isWindowsNT())
+    { HANDLE    token;
+    PSID    adminId;
+    PACL        aclData;
+    PSECURITY_DESCRIPTOR            psdAdmin;
+    SID_IDENTIFIER_AUTHORITY    systemSidAuthority;
+    GENERIC_MAPPING                     genericMapping;
+    PRIVILEGE_SET                           privilegeSet;
+    DWORD       aclSize, status, structureSize;
+    BOOL        result;
+{
+  if (this->isWindowsNT())
+    {
+      HANDLE token;
+      PSID adminId;
+      PACL aclData;
+      PSECURITY_DESCRIPTOR psdAdmin;
+      SID_IDENTIFIER_AUTHORITY systemSidAuthority;
+      GENERIC_MAPPING genericMapping;
+      PRIVILEGE_SET privilegeSet;
+      DWORD aclSize, status, structureSize;
+      BOOL result;
     // Get an impersonation token
     ImpersonateSelf(SecurityImpersonation);
+      // Get an impersonation token
+      ImpersonateSelf(SecurityImpersonation);
+    if (!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &token))
+    {   if (GetLastError() != ERROR_NO_TOKEN)
+        {   return false;
+      }
+      if (!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &token))
+    {
+      if (GetLastError() != ERROR_NO_TOKEN)
+        {
+          return false;
+        }
+      // if we didn't have an access token, take the process token instead
+      if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
+      { return false;
+      }
+      // if we didn't have an access token, take the process token instead
+      if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
+        {
+          return false;
+        }
+    }
+      // By now we have a valid process/thread token; now get information on the
+      // admin group in this domain
+      if (!AllocateAndInitializeSid(&systemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
+                    DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
+                    &adminId))
+    {
+      return false;
+    }
+      // allocate space for security descriptor
+      psdAdmin = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
+      if (psdAdmin == NULL)
+    {
+      return false;
+    }
+      // initialise descriptor
+      if (!InitializeSecurityDescriptor(psdAdmin, SECURITY_DESCRIPTOR_REVISION))
+    {
+      return false;
+    }
+      // get ACL size and allocate ACL block
+      aclSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(adminId) - sizeof(DWORD);
+      aclData = (PACL) LocalAlloc(LPTR, aclSize);
+      if (aclData == NULL)
+    {
+      return false;
+    }
+      // initalise the acl block
+      if (!InitializeAcl(aclData, aclSize, ACL_REVISION2))
+    {
+      return false;
+    }
+      // try to add the given item to the Access Control Entry (ACE) list (ACL)
+      if (!AddAccessAllowedAce(aclData, ACL_REVISION2, ACCESS_READ | ACCESS_WRITE, adminId))
+    {
+      return false;
+    }
+      // endeavour to add the acl to the discretionary acl (DACL)
+      if (!SetSecurityDescriptorDacl(psdAdmin, TRUE, aclData, FALSE))
+    {
+      return false;
+    }
+      // endeavour to set the owner/group identification
+      SetSecurityDescriptorGroup(psdAdmin, adminId, FALSE);
+      SetSecurityDescriptorOwner(psdAdmin, adminId, FALSE);
+      // right, we've now built up a discretionary acl on the current user,
+      // finally get the generic mapping ready
+      genericMapping.GenericRead = ACCESS_READ;
+      genericMapping.GenericWrite = ACCESS_WRITE;
+      genericMapping.GenericExecute = 0;
+      genericMapping.GenericAll = ACCESS_READ | ACCESS_WRITE;
+      // do the actual access check
+      if (!AccessCheck (psdAdmin, token, ACCESS_READ, &genericMapping,
+            &privilegeSet, &structureSize, &status, &result))
+    {
+      return false;
+    }
+      // end impersonisation
+      RevertToSelf();
+      return result;
+    }
+    // By now we have a valid process/thread token; now get information on the
+    // admin group in this domain
+    if (!AllocateAndInitializeSid(&systemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
+                                                                DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
+                                  &adminId))
+    {   return false;
+    }
+    // allocate space for security descriptor
+        psdAdmin    =   LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
+    if (psdAdmin == NULL)
+    {   return false;
+    }
+        // initialise descriptor
+    if (!InitializeSecurityDescriptor(psdAdmin, SECURITY_DESCRIPTOR_REVISION))
+    {   return false;
+    }
+    // get ACL size and allocate ACL block
+        aclSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(adminId) - sizeof(DWORD);
+    aclData =   (PACL) LocalAlloc(LPTR, aclSize);
+    if (aclData == NULL)
+    {   return false;
+    }
+    // initalise the acl block
+    if (!InitializeAcl(aclData, aclSize, ACL_REVISION2))
+    {   return false;
+    }
+    // try to add the given item to the Access Control Entry (ACE) list (ACL)
+    if (!AddAccessAllowedAce(aclData, ACL_REVISION2, ACCESS_READ | ACCESS_WRITE, adminId))
+    {   return false;
+    }
+    // endeavour to add the acl to the discretionary acl (DACL)
+    if (!SetSecurityDescriptorDacl(psdAdmin, TRUE, aclData, FALSE))
+    {   return false;
+    }
+    // endeavour to set the owner/group identification
+    SetSecurityDescriptorGroup(psdAdmin, adminId, FALSE);
+    SetSecurityDescriptorOwner(psdAdmin, adminId, FALSE);
+    // right, we've now built up a discretionary acl on the current user,
+    // finally get the generic mapping ready
+        genericMapping.GenericRead      = ACCESS_READ;
+    genericMapping.GenericWrite     = ACCESS_WRITE;
+    genericMapping.GenericExecute   = 0;
+    genericMapping.GenericAll           = ACCESS_READ | ACCESS_WRITE;
+    // do the actual access check
+    if (!AccessCheck(   psdAdmin, token, ACCESS_READ, &genericMapping,
+                                        &privilegeSet, &structureSize, &status, &result))
+    {   return false;
+    }
+    // end impersonisation
+    RevertToSelf();
+    return result;
+  }
+    return true;
+  return true;
+}
 bool gsPlatform::reboot()
+{
+    // Check for appropriate privileges if this is NT
+    if (this->isWindowsNT())
+  { HANDLE token;
+    TOKEN_PRIVILEGES tkp;
+  // Check for appropriate privileges if this is NT
+  if (this->isWindowsNT())
+    {
+      HANDLE token;
+      TOKEN_PRIVILEGES tkp;
+    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                                &token))
+        {   return false;
+    }
+      if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                &token))
+    {
+      return false;
+    }
+      LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
+    LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
+      tkp.PrivilegeCount = 1; // set one privilege
+      tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
     tkp.PrivilegeCount  = 1; // set one privilege
     tkp.Privileges[0].Attributes    = SE_PRIVILEGE_ENABLED;
+      // Get the actual shutdown privilege
+      AdjustTokenPrivileges(token, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);
+    // Get the actual shutdown privilege
+    AdjustTokenPrivileges(token, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);
+    // as we can't test a return value on the previous call, use GetLastError
+    if (GetLastError() != ERROR_SUCCESS)
+    {   return false;
+      // as we can't test a return value on the previous call, use GetLastError
+      if (GetLastError() != ERROR_SUCCESS)
+    {
+      return false;
+    }
+    }
+  }
   return ExitWindowsEx(EWX_REBOOT | EWX_FORCE, 0);
+}
 string gsPlatform::platformString()
+{   if (this->isWindowsNT())
+    {   return gsPlatform_WINDOWSNT;
+  }
+{
+  if (this->isWindowsNT())
+    {
+      return gsPlatform_WINDOWSNT;
+    }
   else if (this->isWindows9x())
+  { return gsPlatform_WINDOWS9X;
+  {
+    return gsPlatform_WINDOWS9X;
+  }
   else if (this->isWindows32s())
+  { return gsPlatform_WINDOWS32S;
+  {
+    return gsPlatform_WINDOWS32S;
+  }
   else
+  { return gsPlatform_WINDOWS;
+  {
+    return gsPlatform_WINDOWS;
+  }
+}

trunk/gsinstaller/gsPlatform.h

-              r1397
+              r1536
 class gsPlatform
+{   private:
+        OSVERSIONINFO   platformInfo;
+    protected:
+    public:
+        gsPlatform();
+    bool isWindows9x();
+    bool isWindowsNT();
+    bool isWindows32s();
+    bool isOldWindows32s();
+    bool isExplorerShell();
+    bool isUserAdministrator();
+    bool reboot();
+    string platformString();
+{
+private:
+  OSVERSIONINFO platformInfo;
+protected:
+public:
+  gsPlatform();
+  bool isWindows9x();
+  bool isWindowsNT();
+  bool isWindows32s();
+  bool isOldWindows32s();
+  bool isExplorerShell();
+  bool isUserAdministrator();
+  bool reboot();
+  string platformString();
 };
 #endif

trunk/gsinstaller/gsProgman.cpp

r1498	r1536
350	350	return reply;
351	351	}
352
353

trunk/gsinstaller/gsinstall.cpp

-              r1502
+              r1536
 #include "gsManifest.h"
 char *      app_cmdLine;
+char *app_cmdLine;
 static char app_name[] = "Greenstone Installer";
 HINSTANCE   app_instance;
 HWND          app_window;
 bool            config_complete = false;
+HINSTANCE app_instance;
+HWND app_window;
+bool config_complete = false;
 typedef vector<dirSelector *> dirSelVector;
 class GSInstall : public installManager
+{ private:
+        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;
+        GSInstall(bool uninstall);
+    FilePath *  collectionPath();
+    FilePath *  installPath();
+    bool                copyFiles();
+    bool        updateRegistry();
+    bool                updateProfiles();
+    bool                updateProgman();
+    bool                updateSetupExe();
+    bool                installNetscape();
+    void                setDestination();
+    bool                setUninstall();
+    void                uninstall();
+    void                setManifest();
+    void                addSelectedDir(dirSelector *selector);
+{
+private:
+  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;
+  GSInstall(bool uninstall);
+  FilePath *collectionPath();
+  FilePath *installPath();
+  bool copyFiles();
+  bool updateRegistry();
+  bool updateProfiles();
+  bool updateProgman();
+  bool updateSetupExe();
+  bool installNetscape();
+  void setDestination();
+  bool setUninstall();
+  void uninstall();
+  void setManifest();
+  void addSelectedDir(dirSelector *selector);
 };
 …
 void gsInstall_getDesktopExt(int *sx, int *sy)
+{
     HDC dc = GetDC(GetDesktopWindow());
+  HDC dc = GetDC(GetDesktopWindow());
   *sx = GetDeviceCaps(dc, HORZRES);
   *sy = GetDeviceCaps(dc, VERTRES);
 …
  */
 GSInstall::GSInstall(bool uninstall)
+    : installManager()
+{ // get the installation configuration file
+    this->configFile    = new configureFile("install.cfg");
+    // 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
+  : installManager()
+{
+  // get the installation configuration file
+  this->configFile = new configureFile("install.cfg");
+  // 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 (!this->platform.isWindows32s())
+  { // get the registry
+      this->gsRegister  = new gsRegistry(*this, *this->configFile);
+  }
+    {
+      // get the registry
+      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
+    this->gsRegister    = new gsRegistry(*this, *this->configFile);
+  }
+    {
+      // 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
+      this->gsRegister = new gsRegistry(*this, *this->configFile);
+    }
   // assume for now we will install the full volume and the database
   this->installVolume           = true;
   this->installFullVolume   = true;
     // detect any existing installation; unnecessary in uninstall (it's the
+  this->installVolume = true;
+  this->installFullVolume = true;
+  // detect any existing installation; unnecessary in uninstall (it's the
   // "source" directory - see later
   if (uninstall == false)
+  { this->getExistingInstall();
+  }
+    {
+      this->getExistingInstall();
+    }
   // get where we are installing from
 …
   // if doing an uninstall we now know where the "uninstall" is
   if (uninstall == true)
+  { this->collectPath   = this->sourcePath;
+  }
+    {
+      this->collectPath = this->sourcePath;
+    }
   // get the manifest and program manager objects
   if (uninstall)
+  { this->manifest = new gsManifest(*this);
+  }
+    {
+      this->manifest = new gsManifest(*this);
+    }
   else
+  { this->manifest = new gsManifest(*this, *this->sourcePath);
+  }
+    {
+      this->manifest = new gsManifest(*this, *this->sourcePath);
+    }
   this->progman  = new gsProgramManager(*this);
 …
   // be required for loading certain modules such as winsock; the number of
   // macros is over-the-top, but is more robust to unforeseen future requirements
 /*  if (platform.isWindows32s())
   { this->manifest->expandMacro("WINBITS", "16");
     this->manifest->expandMacro("WIN16", "16");
     this->manifest->expandMacro("WIN32", "32");
+  }
   else
   { this->manifest->expandMacro("WINBITS", "32");
     this->manifest->expandMacro("WIN16", "");
     this->manifest->expandMacro("WIN32", "32");
+  }
 */
+  /*  if (platform.isWindows32s())
+      { this->manifest->expandMacro("WINBITS", "16");
+      this->manifest->expandMacro("WIN16", "16");
+      this->manifest->expandMacro("WIN32", "32");
+      }
+      else
+      { this->manifest->expandMacro("WINBITS", "32");
+      this->manifest->expandMacro("WIN16", "");
+      this->manifest->expandMacro("WIN32", "32");
+      }
+  */
   // inform manifest of collection directory name
   string colDir;
   colDir = this->configFile->getString("CollectionDirName");
   if (colDir != "")
+  { this->manifest->expandMacro("COLDIRNAME", colDir);
+  }
+    {
+      this->manifest->expandMacro("COLDIRNAME", colDir);
+    }
+}
 …
  */
 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;
+      }
+      }
+  }
+{
+  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->pathString() != "")
+        {
+          this->installToPath = this->collectPath;
+          // we don't need to install the exe files
+          this->installExe = false;
+        }
+    }
+    }
+}
 …
 bool GSInstall_init_wizard(GSInstall &install)
+{ PROPSHEETHEADER pshead;
+    PROPSHEETPAGE   ppage[2];
+  bool                      reply;
+    ZeroMemory(&pshead, sizeof(PROPSHEETHEADER));
+    pshead.dwSize  = sizeof(PROPSHEETHEADER);
+    pshead.dwFlags = PSH_PROPSHEETPAGE | PSH_USECALLBACK | PSH_USEHICON | PSH_WIZARD;
+    pshead.hwndParent  = app_window;
+    pshead.hInstance   = app_instance;
+    pshead.hIcon       = NULL;
+    pshead.pszCaption  = "Greenstone Installer";
+    pshead.nPages      = 2;
+    pshead.nStartPage  = 0;
+{
+  PROPSHEETHEADER pshead;
+  PROPSHEETPAGE ppage[2];
+  bool reply;
+  ZeroMemory(&pshead, sizeof(PROPSHEETHEADER));
+  pshead.dwSize = sizeof(PROPSHEETHEADER);
+  pshead.dwFlags = PSH_PROPSHEETPAGE | PSH_USECALLBACK | PSH_USEHICON | PSH_WIZARD;
+  pshead.hwndParent = app_window;
+  pshead.hInstance = app_instance;
+  pshead.hIcon = NULL;
+  pshead.pszCaption = "Greenstone Installer";
+  pshead.nPages = 2;
+  pshead.nStartPage = 0;
   if (install.installExe == true)
+  { pshead.ppsp          = ppage;
+  }
+    {
+      pshead.ppsp = ppage;
+    }
   else // cheat as the executable etc. is already installed
+  { pshead.ppsp          = &ppage[1];
+  }
+    pshead.pfnCallback = GSInstall_wizardProc;
+    {
+      pshead.ppsp = &ppage[1];
+    }
+  pshead.pfnCallback = GSInstall_wizardProc;
   GSInstall_init_propertySheet( ppage[0],
                                                             "Choose a directory to install your "
+                "Choose a directory to install your "
                                 "GreenStone software to.", NULL,
                                 "Select", install, false);
   GSInstall_init_propertySheet(ppage[1],
                                                             "Choose a directory to install the collection "
                                 "files to.\n\n"
                                                             "You can also choose to install all the collection "
                                 "files onto your computer hard drive.\n\n"
                                 "If you do this, you will not have to load the "
                                 "CD-ROM each time you use your Greenstone software "
                                 "but more of your hard disk will be used.\n\n"
                                 "Some collection files must be installed on your "
                                 "computer.\n\n",
                                 "Install all collection files",
                                 "Select", install, true);
+                   "Choose a directory to install the collection "
+                   "files to.\n\n"
+                   "You can also choose to install all the collection "
+                   "files onto your computer hard drive.\n\n"
+                   "If you do this, you will not have to load the "
+                   "CD-ROM each time you use your Greenstone software "
+                   "but more of your hard disk will be used.\n\n"
+                   "Some collection files must be installed on your "
+                   "computer.\n\n",
+                   "Install all collection files",
+                   "Select", install, true);
   reply = (PropertySheet (&pshead) >= 0);
 …
+}
+long FAR PASCAL GSInstallWindProc(HWND          Window,
+                                                                    WORD            Message,
+                                                                    WPARAM      wParameter,
+                                                                    LPARAM      lParameter)
+{ long reply = 0;
+long FAR PASCAL GSInstallWindProc(HWND Window, WORD Message, WPARAM wParameter, LPARAM lParameter)
+{
+  long reply = 0;
   switch(Message)
+    { case WM_CREATE:
+    { ShowWindow(Window, SW_MAXIMIZE);
+    }
+    break;
+    case WM_COMMAND:
+        break;
+    {
+    case WM_CREATE:
+      {
+    ShowWindow(Window, SW_MAXIMIZE);
+      }
+      break;
+    case WM_COMMAND:
+      break;
     case WM_USER:
+    { // uninstall action
+        if (strstr(app_cmdLine, "-u") != NULL)
+        { // skip past the -u option itself
+        char *at = strstr(app_cmdLine, "-u");
+        at += strlen("-u");
+        // extract the log file path from the command line
+        while (*at == ' ')
+        { at ++;
+        }
+        string logPathString(at);
+        FilePath logPath(logPathString);
+                GSInstall install(true);
+        // if we're running in the temporary directory, do the uninstall
+        if (install.setUninstall())
+        {   install.uninstall();
+            // close the log to write back all changes to the log; if the file
+          // will be deleted, it must be closed; copying may also fail, so it's
+          // safer to close it before doing either.
+            install.closeLog();
+          // if the install is empty, terminate all final items (currently the
+          // log and setup executables,
+          if (install.isEmpty())
+          { // delete the log file
+            DeleteFile(logPath.cString());
+            // get it's parent to find where the gssetup executable will be
+            FilePath *logParent = logPath.parent();
+                        FilePath uninstallPath(*logParent, "gssetup.exe");
+            // delete the gssetup executable
+            DeleteFile(uninstallPath.cString());
+            // dispose of the parent directory information
+            delete logParent;
+          }
+          // if not, then overwrite the original log with the modified one
+          else
+          { // do nothing - should be changed already!
+          }
+        }
+      }
+    {
+      // uninstall action
+      if (strstr(app_cmdLine, "-u") != NULL)
+        {
+      // skip past the -u option itself
+      char *at = strstr(app_cmdLine, "-u");
+      at += strlen("-u");
+      // extract the log file path from the command line
+      while (*at == ' ')
+        {
+          at ++;
+        }
+      string logPathString(at);
+      FilePath logPath(logPathString);
+      GSInstall install(true);
+      // if we're running in the temporary directory, do the uninstall
+      if (install.setUninstall())
+        {
+          install.uninstall();
+          // close the log to write back all changes to the log; if the file
+          // will be deleted, it must be closed; copying may also fail, so it's
+          // safer to close it before doing either.
+          install.closeLog();
+          // if the install is empty, terminate all final items (currently the
+          // log and setup executables,
+          if (install.isEmpty())
+        {
+          // delete the log file
+          DeleteFile(logPath.cString());
+          // get it's parent to find where the gssetup executable will be
+          FilePath *logParent = logPath.parent();
+          FilePath uninstallPath(*logParent, "gssetup.exe");
+          // delete the gssetup executable
+          DeleteFile(uninstallPath.cString());
+          // dispose of the parent directory information
+          delete logParent;
+        }
+          // if not, then overwrite the original log with the modified one
+          else
+        {
+          // do nothing - should be changed already!
+        }
+        }
+    }
       // install wizard
       else
+      { GSInstall install(false);
+        GSInstall_init_wizard(install);
+    {
+      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();
+          install.updateSetupExe();
+          // the log will need reopening (probably failed initially)
+                  install.reopenLog();
+          // close log
+          install.closeLog();
+            // do further actions
+        {
+          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();
+          install.updateSetupExe();
+          // the log will need reopening (probably failed initially)
+          install.reopenLog();
+          // close log
+          install.closeLog();
+          // do further actions
           install.installNetscape();
+          }
+        }
+    }
+      DestroyWindow(Window);
+    }
+    break;
+    case WM_CLOSE:
+      /*if (!file_ischanged || IDCANCEL != file_query(Window, file_name))*/
+      DestroyWindow(Window);
+      return 0L;
+    case WM_DESTROY:
+      {
+    PostQuitMessage(0);
+      }
+      DestroyWindow(Window);
+        }
+    break;
+        case WM_CLOSE:
+/*          if (!file_ischanged || IDCANCEL != file_query(Window, file_name))*/
+            DestroyWindow(Window);
+        return 0L;
+        case WM_DESTROY:
+        { PostQuitMessage(0);
+        }
+        break;
+        default:
+            return(DefWindowProc(Window, Message, wParameter, lParameter));
+    }
+      break;
+    default:
+      return(DefWindowProc(Window, Message, wParameter, lParameter));
+    }
   return reply;
+}
 …
 void WinClassInit(void)
+{ WNDCLASS  Class;
+    Class.lpszClassName = "GSInstall:Main";
+    Class.hInstance     = app_instance;
+    Class.lpfnWndProc       = (WNDPROC) GSInstallWindProc;
+    Class.hCursor               = LoadCursor(NULL, IDC_ARROW);
+    Class.hIcon                 = NULL; //LoadIcon(app_instance, "GSInstall");
+    Class.lpszMenuName  = NULL;
+    Class.hbrBackground = (HBRUSH) (COLOR_APPWORKSPACE+1);
+    Class.style                 = NULL;
+    Class.cbClsExtra        = 0;
+    Class.cbWndExtra        = 0;
+    RegisterClass(&Class);
+/*
+    Class.lpszClassName = "GSInstall:Splash";
+    Class.hInstance     = app_instance;
+    Class.lpfnWndProc       = (WNDPROC) splash_windproc;
+    Class.hCursor               = LoadCursor(NULL, IDC_ARROW);
+    Class.hIcon                 = NULL;
+    Class.lpszMenuName  = NULL;
+    Class.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
+    Class.style                 = NULL;
+    Class.cbClsExtra        = 0;
+    Class.cbWndExtra        = 0;
+    RegisterClass(&Class);*/
+{
+  WNDCLASS Class;
+  Class.lpszClassName = "GSInstall:Main";
+  Class.hInstance = app_instance;
+  Class.lpfnWndProc = (WNDPROC) GSInstallWindProc;
+  Class.hCursor = LoadCursor(NULL, IDC_ARROW);
+  Class.hIcon = NULL; //LoadIcon(app_instance, "GSInstall");
+  Class.lpszMenuName = NULL;
+  Class.hbrBackground = (HBRUSH) (COLOR_APPWORKSPACE+1);
+  //Class.style = NULL;
+  Class.style = 0;
+  Class.cbClsExtra = 0;
+  Class.cbWndExtra = 0;
+  RegisterClass(&Class);
+  /*
+    Class.lpszClassName = "GSInstall:Splash";
+    Class.hInstance = app_instance;
+    Class.lpfnWndProc = (WNDPROC) splash_windproc;
+    Class.hCursor = LoadCursor(NULL, IDC_ARROW);
+    Class.hIcon = NULL;
+    Class.lpszMenuName = NULL;
+    Class.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
+    Class.style = NULL;
+    Class.cbClsExtra = 0;
+    Class.cbWndExtra = 0;
+    RegisterClass(&Class);*/
+}
 int PASCAL WinMain(HINSTANCE Current,
+                                        HINSTANCE Previous,
+                                        LPSTR CmdLine,
+                                        int CmdShow)
+{ MSG msg;
+//  HACCEL accel;
+    app_cmdLine = (char *) malloc(lstrlen(CmdLine) + 1);
+    lstrcpy(app_cmdLine, CmdLine);
+    app_instance = Current;
+    /* -- init application */
+    if (!Previous)
+    { WinClassInit();
+    InitCommonControls();
+//    grbStatic_registerClass(Current);
+    }
+    /* -- init instance */
+           HINSTANCE Previous,
+           LPSTR CmdLine,
+           int CmdShow)
+{
+  MSG msg;
+  // HACCEL accel;
+  app_cmdLine = (char *) malloc(lstrlen(CmdLine) + 1);
+  lstrcpy(app_cmdLine, CmdLine);
+  app_instance = Current;
+  /* -- init application */
+  if (!Previous)
+    {
+      WinClassInit();
+      InitCommonControls();
+      //    grbStatic_registerClass(Current);
+    }
+  /* -- init instance */
   GSInstall_init(Current, CmdShow);
+//  config_init("ReTreeval");
+//  accel   = LoadAccelerators(Current, "ReTreevalMenu");
+    while (GetMessage(&msg, NULL, 0, 0))
+    { /*if (!TranslateAccelerator(app_window, accel, &msg))
+  //  config_init("ReTreeval");
+  //  accel = LoadAccelerators(Current, "ReTreevalMenu");
+  while (GetMessage(&msg, NULL, 0, 0))
+    {
+      /*if (!TranslateAccelerator(app_window, accel, &msg))
     { */
         TranslateMessage(&msg);
             DispatchMessage(&msg);
     /*}*/
+    }
     return (int) msg.wParam;
+}
+      TranslateMessage(&msg);
+      DispatchMessage(&msg);
+      /*}*/
+    }
+  return (int) msg.wParam;
+}

trunk/gsinstaller/registry.cpp

-              r1475
+              r1536
 bool registry_createkey(HKEY key, const char *name, PHKEY keyout)
+{ LONG reply;
+    DWORD disposition;
+    reply = RegCreateKeyEx( key, name, NULL, NULL,
+                                                REG_OPTION_NON_VOLATILE,
+                          KEY_ALL_ACCESS, NULL,
+                          keyout, &disposition);
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+  }
+{
+  LONG reply;
+  DWORD disposition;
+  reply = RegCreateKeyEx(key, name, 0, NULL,
+             REG_OPTION_NON_VOLATILE,
+             KEY_ALL_ACCESS, NULL,
+             keyout, &disposition);
+  if (reply != ERROR_SUCCESS)
+    {
+      return FALSE;
+    }
   return TRUE;
+}
 bool registry_openkey(HKEY key, const char *name, PHKEY keyout)
+{ LONG reply;
+    reply = RegOpenKeyEx(key, name, NULL, KEY_QUERY_VALUE, keyout);
+  if (reply != ERROR_SUCCESS)
+  { return false;
+  }
+{
+  LONG reply;
+  reply = RegOpenKeyEx(key, name, 0, KEY_QUERY_VALUE, keyout);
+  if (reply != ERROR_SUCCESS)
+    {
+      return false;
+    }
   return true;
+}
 bool registry_deletekey(HKEY key, const char *name)
+{   if (RegDeleteKey(key, name) != ERROR_SUCCESS)
+    {   return false;
+  }
+{
+  if (RegDeleteKey(key, name) != ERROR_SUCCESS)
+    {
+      return false;
+    }
   return true;
+}
 bool registry_closekey(HKEY key)
+{ LONG reply;
+    reply = RegCloseKey(key);
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+{
+  LONG reply;
+  reply = RegCloseKey(key);
+  if (reply != ERROR_SUCCESS)
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_keyExists(HKEY key, const char *name)
+{ HKEY local;
+    if (!registry_openkey(key, name, &local))
+  { return false;
+{
+  HKEY local;
+  if (!registry_openkey(key, name, &local))
+  {
+    return false;
+  }
   registry_closekey(local);
 …
 bool registry_ensureKeyExists(HKEY key, const char *name)
+{ HKEY local;
+    if (!registry_openkey(key, name, &local))
+    {   if (!registry_createkey(key, name, &local))
+    {   return false;
+    }
+  }
+    registry_closekey(local);
+{
+  HKEY local;
+  if (!registry_openkey(key, name, &local))
+    {
+      if (!registry_createkey(key, name, &local))
+    {
+      return false;
+    }
+    }
+  registry_closekey(local);
   return true;
+}
 bool registry_deleteitem(HKEY key, const char *name)
+{   if (RegDeleteValue(key, name) != ERROR_SUCCESS)
+    {   return false;
+  }
+{
+  if (RegDeleteValue(key, name) != ERROR_SUCCESS)
+    {
+      return false;
+    }
   return true;
+}
 bool registry_setstring(HKEY key, const char *name, const char *value)
+{ LONG reply;
+    reply = RegSetValueEx(key, (LPCTSTR) name, NULL, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
+  if (reply != ERROR_SUCCESS)
+  { return false;
+{
+  LONG reply;
+  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
+  if (reply != ERROR_SUCCESS)
+  {
+    return false;
+  }
   return true;
 …
 bool registry_setlong(HKEY key, char *name, LONG value)
+{ LONG  reply;
+    DWORD word;
+{
+  LONG  reply;
+  DWORD word;
   word = (DWORD) value;
+    reply = RegSetValueEx(key, (LPCTSTR) name, NULL, REG_DWORD, (CONST BYTE *) &word, sizeof(DWORD));
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_DWORD, (CONST BYTE *) &word, sizeof(DWORD));
+  if (reply != ERROR_SUCCESS)
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_setblock(HKEY key, char *name, char *data, int size)
+{ LONG  reply;
+    reply = RegSetValueEx(key, name, NULL, REG_BINARY, (CONST BYTE *) data, size);
+  if (reply != ERROR_SUCCESS)
+  { // display_error();
+    return FALSE;
+{
+  LONG  reply;
+  reply = RegSetValueEx(key, name, 0, REG_BINARY, (CONST BYTE *) data, size);
+  if (reply != ERROR_SUCCESS)
+  {
+    // display_error();
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_setint(HKEY key, char *name, int value)
+{ return registry_setlong(key, name, (LONG) value);
+{
+  return registry_setlong(key, name, (LONG) value);
+}
 bool registry_getstring(HKEY key, char *name, char **string)
+{ LONG reply;
+    DWORD type;
+{
+  LONG reply;
+  DWORD type;
   DWORD size;
   BYTE  buffer[128];
 …
   do
+  {
+        reply = RegQueryValueEx(key, name, NULL, &type, buffer, &size);
+    if (reply != ERROR_SUCCESS)
+      { //display_error();
+        //sprintf(buffer, "%x {%s}", key, name);
+        //MessageBox(0, buffer, name, MB_OK);
+      }
+    tries ++;
+  } while (reply != ERROR_SUCCESS && tries < 3);
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+    {
+      reply = RegQueryValueEx(key, name, NULL, &type, buffer, &size);
+      if (reply != ERROR_SUCCESS)
+    {
+      //display_error();
+      //sprintf(buffer, "%x {%s}", key, name);
+      //MessageBox(0, buffer, name, MB_OK);
+    }
+      tries ++;
+    } while (reply != ERROR_SUCCESS && tries < 3);
+  if (reply != ERROR_SUCCESS)
+  {
+    return FALSE;
+  }
   *string = (char *) malloc(size);
   if (*string == NULL)
+  { return FALSE;
+  {
+    return FALSE;
+  }
   strcpy(*string, (char *) buffer);
 …
 bool registry_getint(HKEY key, char *name, int *out)
+{ DWORD type;
+    DWORD size;
+{
+  DWORD type;
+  DWORD size;
   LONG  reply;
+    reply = RegQueryValueEx(key, (LPTSTR) name, NULL, &type, (LPBYTE) out, &size);
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+  reply = RegQueryValueEx(key, (LPTSTR) name, NULL, &type, (LPBYTE) out, &size);
+  if (reply != ERROR_SUCCESS)
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_getlong(HKEY key, char *name, LONG *out)
+{ DWORD type;
+    DWORD size;
+{
+  DWORD type;
+  DWORD size;
   LONG  reply;
   DWORD got;
 …
   size = sizeof(DWORD);
+    reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) &got, &size);
+  if (reply != ERROR_SUCCESS)
+  { return FALSE;
+  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) &got, &size);
+  if (reply != ERROR_SUCCESS)
+  {
+    return FALSE;
+  }
   *out = (LONG) got;
 …
 int registry_getblock(HKEY key, char *name, char *data, int size)
+{ DWORD type;
+    DWORD lsize;
+{
+  DWORD type;
+  DWORD lsize;
   LONG  reply;
   lsize = size;
+    reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) data, &lsize);
+  if (reply != ERROR_SUCCESS)
+  { return -1;
+  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) data, &lsize);
+  if (reply != ERROR_SUCCESS)
+  {
+    return -1;
+  }
   return lsize;
 …
 bool registry_fetchlong(char *keystr, LONG *lptr)
+{ HKEY key;
+    if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+    { return FALSE;
+  }
+{
+  HKEY key;
+  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+    {
+      return FALSE;
+    }
   if (!registry_getlong(key, keystr, lptr))
+  { return FALSE;
+  }
+    {
+      return FALSE;
+    }
   if (registry_closekey(key) == FALSE)
+  { return FALSE;
+    }
+  {
+    return FALSE;
+  }
   return TRUE;
+}
 bool registry_fetchblock(char *keystr, char *data, int size)
+{ HKEY  key;
+    int     read;
+    if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+    { return FALSE;
+  }
+{
+  HKEY key;
+  int read;
+  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+    {
+      return FALSE;
+    }
   read = registry_getblock(key, keystr, data, size);
   if (read < 0)
+  { return FALSE;
+  }
+    {
+      return FALSE;
+    }
   if (registry_closekey(key) == FALSE)
+  { return FALSE;
+    }
+  {
+    return FALSE;
+  }
   return TRUE;
+}
 bool registry_storelong(char *keystr, LONG value)
+{ HKEY key;
+    if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  { return FALSE;
+{
+  HKEY key;
+  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  {
+    return FALSE;
+  }
   if (!registry_setlong(key, keystr, value))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   if (!registry_closekey(key))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_storeint(char *keystr, int value)
+{ HKEY key;
+    if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  { return FALSE;
+{
+  HKEY key;
+  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  {
+    return FALSE;
+  }
   if (!registry_setint(key, keystr, value))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   if (!registry_closekey(key))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_storeblock(char *keystr, char *data, int size)
+{ HKEY key;
+    if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  { return FALSE;
+{
+  HKEY key;
+  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  {
+    return FALSE;
+  }
   if (!registry_setblock(key, keystr, data, size))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   if (!registry_closekey(key))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   return TRUE;
 …
 bool registry_storestring(char *keystr, char *value)
+{ HKEY key;
+    if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  { return FALSE;
+{
+  HKEY key;
+  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
+  {
+    return FALSE;
+  }
   if (!registry_setstring(key, keystr, value))
+  { return FALSE;
+  {
+    return FALSE;
+  }
   if (!registry_closekey(key))
+  { return FALSE;
+  }
+  return TRUE;
+}
+  {
+    return FALSE;
+  }
+  return TRUE;
+}

trunk/gsinstaller/stringArray.h

-              r1498
+              r1536
 class stringArray
+{   private:
+    protected:
+  public:
+        vector<string> array;
+    stringArray();
+    stringArray(char *list, char *divider);
+    void add(char *member);
+    void add(string member);
+    void add(stringArray &array);
+    void insertAt(string member, unsigned int at);
+    void remove(char *member);
+    void remove(string member);
+    void clear();
+    bool includes(char *member);
+    bool includes(string member);
+    static stringArray words(char *line);
+    unsigned int size(){ return this->array.size(); };
+    int  indexOf(char *member);
+    int  indexOf(string member);
+    int  writeToCString(char *buffer, char *divider, int bufflen);
+    string toString(string separator);
+    string &operator[](const unsigned int);
+{
+private:
+protected:
+public:
+  vector<string> array;
+  stringArray();
+  stringArray(char *list, char *divider);
+  void add(char *member);
+  void add(string member);
+  void add(stringArray &array);
+  void insertAt(string member, unsigned int at);
+  void remove(char *member);
+  void remove(string member);
+  void clear();
+  bool includes(char *member);
+  bool includes(string member);
+  static stringArray words(char *line);
+  unsigned int size(){ return this->array.size(); };
+  int  indexOf(char *member);
+  int  indexOf(string member);
+  int  writeToCString(char *buffer, char *divider, int bufflen);
+  string toString(string separator);
+  string &operator[](const unsigned int);
 };

trunk/gsinstaller/unInstall.h

-              r1525
+              r1536
 #include <stdio.h>
+#if defined (GSDL_USE_IOS_H)
 #include <fstream.h>
+#else
+#include <fstream>
+#endif
 #include "stringArray.h"
 …
 typedef class unInstallCommand
+{ public:
+        string          command;
+        stringArray parameters;
+{
+public:
+  string command;
+  stringArray parameters;
+    unInstallCommand() { };
+    unInstallCommand(string commandname) { this->command = commandname; };
+    unInstallCommand(string commandname, stringArray params)
+    { this->command = commandname;
+        this->parameters = params;
+    };
+    void addParameter(string parameter) { this->parameters.add(parameter); };
+    string commandName() { return this->command; };
+    stringArray &parameterList() { return this->parameters; };
+  unInstallCommand() { };
+  unInstallCommand(string commandname) { this->command = commandname; };
+  unInstallCommand(string commandname, stringArray params)
+  {
+    this->command = commandname;
+    this->parameters = params;
+  };
+  void addParameter(string parameter) { this->parameters.add(parameter); };
+  string commandName() { return this->command; };
+  stringArray &parameterList() { return this->parameters; };
 } unInstallCommand;
 …
 class installManager
+{   private:
+        fstream                             logfile;
+    string                              logfileName;
+    string                              currentModule;
+    unInstallCommandMap     modules;
+{
+private:
+  fstream logfile;
+  string logfileName;
+  string currentModule;
+  unInstallCommandMap modules;
     bool writeString(string str);
     bool writeString(char *string);
     bool writeSeparator();
     string readString();
     bool writeCommand(unInstallCommand &command);
     string readCommand(stringArray &params);
     public:
     installManager() { };
     bool openLog(string filename, bool write);
     bool closeLog();
     bool reopenLog();
     void setModule(string moduleName);
     bool storeCommand(unInstallCommand &command);
     string popCommand(stringArray &params);
     bool isEmpty();
     ~installManager();
+  bool writeString(string str);
+  bool writeString(char *string);
+  bool writeSeparator();
+  string readString();
+  bool writeCommand(unInstallCommand &command);
+  string readCommand(stringArray &params);
+public:
+  installManager() { };
+  bool openLog(string filename, bool write);
+  bool closeLog();
+  bool reopenLog();
+  void setModule(string moduleName);
+  bool storeCommand(unInstallCommand &command);
+  string popCommand(stringArray &params);
+  bool isEmpty();
+  ~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);
+{
+protected:
+  installManager *manager;
+public:
+  installAgent(installManager &useManager) { this->manager = &useManager; };
+  virtual bool undoAction(string actionName, stringArray &params) { return false; };
+  //    bool undo(string actionName);
 };

Context Navigation

Legend:

trunk/gsinstaller/FilePath.cpp

trunk/gsinstaller/FilePath.h

trunk/gsinstaller/copyProgress.cpp

trunk/gsinstaller/dirSelector.cpp

trunk/gsinstaller/dirent.cpp

trunk/gsinstaller/file.h

trunk/gsinstaller/fileCopier.cpp

trunk/gsinstaller/fileCopier.h

trunk/gsinstaller/gsManifest.cpp

trunk/gsinstaller/gsManifest.h

trunk/gsinstaller/gsPlatform.cpp

trunk/gsinstaller/gsPlatform.h

trunk/gsinstaller/gsProgman.cpp

trunk/gsinstaller/gsinstall.cpp

trunk/gsinstaller/registry.cpp

trunk/gsinstaller/stringArray.h

trunk/gsinstaller/unInstall.h

Download in other formats: