source: trunk/gsinstaller/gsinstall.cpp@ 1397

#include <vector>
#include <string>
using namespace std;

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <commctrl.h>

#include "dirSelector.h"
#include "common.h"
#include "configFile.h"
#include "File.h"
#include "FilePath.h"
#include "FileCopier.h"
#include "launchApp.h"
#include "unInstall.h"

#include "gsRegistry.h"
#include "gsPlatform.h"
#include "gsProgman.h"
#include "gsProfile.h"
#include "gsManifest.h"

char *      app_cmdLine;
static char app_name[] = "Greenstone Installer";
HINSTANCE   app_instance;
HWND          app_window;

bool            config_complete = false;
// static char app_tmptext[100] = "George";

typedef vector<dirSelector *> dirSelVector;

class GSInstall
{ private:
        configureFile   *   configFile;
        FilePath *          collectPath;
    FilePath *          installToPath;
    FilePath *          sourcePath;
    FilePath *          gsdlSourcePath;
    FilePath *          destinationPath;
    FilePath *          dataDestPath;
    bool            installExe;
    bool                        installVolume;
    bool                        installFullVolume;
    gsPlatform          platform;
    unInstaller *       unInstall;

    dirSelVector        selectedDirs;

    gsRegistry *        gsRegister;
    gsManifest *        manifest;

    void                getSourcePath();
    public:
        GSInstall();
    FilePath *  collectionPath();
    FilePath *  installPath();
    bool                copyFiles();
    bool        updateRegistry();
    bool                updateProfiles();
    bool                updateProgman();
    bool                installNetscape();
    void                setDestination();
    void                setManifest();
    void                addSelectedDir(dirSelector *selector);
};

static string gsdl_DBHOME = "gdbmhome";
static string gsdl_VLHOME = "gsdlhome";
static string gsdl_STATIC = "staticpath";
static string gsdl_COLLIST= "collections";

void gsInstall_getDesktopExt(int *sx, int *sy)
{
    HDC dc = GetDC(GetDesktopWindow());
  *sx = GetDeviceCaps(dc, HORZRES);
  *sy = GetDeviceCaps(dc, VERTRES);
  ReleaseDC(GetDesktopWindow(), dc);
}

/**
 * Get various and nefarious details before we start trying an installation.
 * The installation configuration file is read, we seek for an existing
 * installation and reconfigure the default install settings appropriately.
 * THe source path is also discovered.
 */
GSInstall::GSInstall()
{ gsPlatform    platform;

    // get the installation configuration file
    this->configFile    = new configureFile("install.cfg");

  // initialise the pointers that we test later this fn.
  this->unInstall       = NULL;

    // don't attempt this with windows 3.1
  if (!platform.isWindows32s() || TRUE)
  { // 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
      //       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("");
  }

  // assume for now we will install the full volume and the database
  this->installVolume           = true;
  this->installFullVolume   = true;

  // get where we are installing from
  this->getSourcePath();

  // get the manifest
  this->manifest = new gsManifest(*this->sourcePath);

  // tell manifest the number of bits in the raw windows environment; this may
  // 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");
  }
*/
  // inform manifests of collection directory name
  char *buffer;
  this->configFile->get("CollectionDirName", &buffer);
  this->manifest->expandMacro("COLDIRNAME", buffer);
  delete buffer;
}

/**
 * get the source path for this install; we derive this from the path of this
 * executable (the installer)
 */
void GSInstall::getSourcePath()
{ static char filename[512];
    FilePath     *exePath;

  // get the filepath of this executable
  GetModuleFileName(0, filename, 512);
  exePath   = new FilePath(filename);

  // get the parent (i.e. the folder containing this executable) for the source
  // folder
  this->sourcePath  = exePath->parent();

  // get the gsdl source path
  this->gsdlSourcePath  = new FilePath(this->sourcePath->cString(), "gsdl");
  delete exePath;
}

/**
 * Controls the actual copying of the files; manifests of what to install
 * are read in from a configuration on the hard drive - this should be basically
 * greenstone dependent, and void of any collection-specific rubbish!
 */
bool GSInstall::copyFiles()
{   FileVector *fileList;

  // ensure that we have got the required destination and that we can write there
  if (this->installExe)
  { this->destinationPath->ensureWriteablePath();
  }

  // ensure that the destination path for the collection itself is available
  if (this->installVolume)
  { this->dataDestPath->ensureWriteablePath();
  }

  // do the copy
    this->manifest->copy(this->gsdlSourcePath);

  return true;
}

/**
 * Fulfill registry update requirements; first the keys are set up, then they
 * are filled with key item/value pairs.
 */
bool GSInstall::updateRegistry()
{ // don't do registry stuff under windows 32s
    if (this->platform.isWindows32s() && FALSE)
    {   return true;
  }

  // ensure all pertinent keys already exist for this volume/collection
    this->gsRegister->ensureKeysExist();

  // now move on to add key items
    if (this->installExe)
  { FilePath *serverPath    = new FilePath((char *) this->destinationPath->cString(), "server.exe");
    char *exeKeyPath;
    gsPlatform platform;

    // store the normal collection key information
    this->gsRegister->storeKeyString(   HKEY_LOCAL_MACHINE,
                                                                        this->gsRegister->collectKeyId(),
                                      "library",
                                      serverPath->cString());

    // This test is in fact for 9x or NT 4+; we're worried about the registry
    // format, not about the shell as such
    if (platform.isExplorerShell())
    { // get special app path key for windows 9x
        exeKeyPath  =   this->gsRegister->exeKeyId("library.exe");

      // ensure that the exe key exists
        this->gsRegister->ensureKeyExists(HKEY_LOCAL_MACHINE, exeKeyPath);

        // store default key for this application
        this->gsRegister->storeKeyString(   HKEY_LOCAL_MACHINE,
                                                                        exeKeyPath,
                                          NULL,
                                        serverPath->cString());

      // store path for this application
        this->gsRegister->storeKeyString(   HKEY_LOCAL_MACHINE,
                                                                        exeKeyPath,
                                          "path",
                                        this->destinationPath->cString());
      // delete the windows 9x speciall app path key
            delete exeKeyPath;

      // TODO: set up uninstall option
    }
    delete serverPath;
  }

  if (this->installVolume || this->installFullVolume)
  { // no actual key items are held in the volume key; for future use
  }
  return true;
}

/**
 * Set the destination directory details
 */
void GSInstall::setDestination()
{   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
  { this->dataDestPath  = new FilePath(this->selectedDirs[1]->selectedPath());
  }
  else
  { this->dataDestPath  = this->destinationPath;
  }
}

/**
 *  Collate the manifest for installation
 */
void GSInstall::setManifest()
{   if (this->installExe)
    {   this->manifest->selectGroup("library", this->destinationPath->pathString());
  }
  if (this->installFullVolume)
  { this->manifest->selectGroup("collection", this->dataDestPath->pathString());
  }
  else
  { this->manifest->selectGroup("database", this->dataDestPath->pathString());
  }
}

/**
 * Update the program manager/explorer shell with icons, groups etc for this
 * collection/application
 */
bool GSInstall::updateProgman()
{ gsProgramManager  progman;
    char *            groupName = NULL;

  // if we managed to get a connection to the program manager (or explorer
  // shell) then do the requisite updates
  if (progman.connect())
  { // get group name from folders
    this->configFile->get("ProgramGroupName", &groupName);
      if (groupName == NULL)
    {   // TODO: error handling
        progman.disconnect();
          delete groupName;
        return false;
      }

      // add the group
        if (!progman.addProgramGroup(groupName))
      { progman.disconnect();
          delete groupName;
        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;
      }

    // 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;
      }

    FilePath readMePath(this->destinationPath->cString(), "readme.txt");
      if (!progman.addIcon(groupName, "ReadMe", readMePath.cString(), ""))
    {   progman.disconnect();
          delete groupName;
        return false;
      }

    FilePath supportPath(this->destinationPath->cString(), "support.html");
      if (!progman.addIcon(groupName, "Technical Support", supportPath.cString(), ""))
    {   progman.disconnect();
          delete groupName;
        return false;
      }

    // TODO: add uninstall support

    // dispose of group name
      delete groupName;

    // disconnect from program manager
    progman.disconnect();
  }
  return true;
}

/**
 * Update the profile (ini) files associated with the program; these changes
 * must be made after copying to files in the destination/executable folders
 * as we can't write to CD-ROM (or at least we shouldn't - the install would
 * become tainted).
 */
bool GSInstall::updateProfiles()
{ FilePath *exePath;
    FilePath *dataPath;
  FilePath *iniPath;

  // if we're installing the exe, then the exe path leads to the destination
  // folder of this installation sequence;  if not, then we pick it up from
  // the existing location of that folder
    if (this->installExe)
    {   exePath = this->destinationPath;
  }
  else
    {   exePath = this->collectPath;
  }
  iniPath   = new FilePath((char *) exePath->cString(), "gsdl.ini");

  // TODO: check if this 'if' structure is correct; suspect that it isn't quite
  //       as we may not be installing the volume, but exe etc individually;
  //       may be okay now but not future proof; also the destination directory
  //       may or may not be tied to the exe directory if that existed already.
  //       This all needs investigating
  if (this->installVolume)
  { char volumeSectionName[100] = "\0";
    unsigned int space  = 99;

    // 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);

    // if we're installing the full data for the collection, then take the
    // data path to be at the selected destination directory for the collection
    // files; otherwise take the data path to be on the CD/distribution media
    if (this->installFullVolume)
    {   dataPath    =   this->dataDestPath;
    }
    else
    {   dataPath    = this->gsdlSourcePath;
    }

    // create a profile object to write to the gsdl.ini file
    gsProfile gsdlProfile(iniPath->cString());

    // if installing the executable, add the database and greenstone home
    // directories
    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());
    }

    // set the correct collection volume entries in gsdl.ini
    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);

      // 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());
    }
  }

  // clean up
  delete iniPath;

  return true;
}

bool GSInstall::installNetscape()
{   FilePath    netscape32Path(this->sourcePath->cString(), "netscape\\n32e405.exe");
  FilePath  netscape16Path(this->sourcePath->cString(), "netscape\\n16e405.exe");

  launchApp launchNetscape(netscape32Path);
  launchNetscape.platformApp(gsPlatform_WINDOWS32S, netscape16Path);
  if (launchNetscape.run(true, 1,
                                                "This library is displayed using a web browser.  If you don't "
                              "currently have a web browser installed on your machine you may "
                              "install the Netscape 4.05 browser now.\n\n"
                              "Note that if your current browser was provided by your internet "
                              "service provider, you should install Netscape in a different "
                              "directory.\n\n"
                              "Would you like to install the Netscape 4.05 browser now?",
                              "Greenstone Installer", false) < 0)
  { MessageBox(0, "Error", app_name, MB_OK);
    return false;
  }
  return true;
}

FilePath *GSInstall::collectionPath()
{   return this->collectPath;
}

FilePath *GSInstall::installPath()
{   return this->installToPath;
}

void GSInstall::addSelectedDir(dirSelector *selector)
{   this->selectedDirs.push_back(selector);
}

typedef struct
{ dirSelector * dirSelect;
} GSInstall_dirPathData;

HGLOBAL loadDirBrowser()
{ HRSRC resHdl;

    resHdl = FindResource(app_instance, "MySaveAsDlg", RT_DIALOG);
  return LoadResource(app_instance, resHdl);
}

void gsInstall_wizard_centre(HWND dialog)
{
  RECT rect;
  int sx, sy;
  int dx, dy;

  gsInstall_getDesktopExt(&sx, &sy);
  GetWindowRect(dialog, &rect);

  dx = (sx - rect.right + rect.left) >> 1;
  dy = (sy - rect.bottom + rect.top) >> 1;
  SetWindowPos(dialog, 0, dx, dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
}

BOOL FAR PASCAL GSInstall_dlgproc(HWND Dialog, UINT Message, WPARAM wParam, LPARAM lParam)
{ static bool first = true;     // static variable to hack the position of the
                              // whole wizard; note doing this in the wizard
                              // property sheet initialisation DOES NOT WORK

    switch (Message)
    {   case WM_INITDIALOG:
    {   dirSelector *selector = (dirSelector *) ((PROPSHEETPAGE *) lParam)->lParam;

        SetDlgItemText(Dialog, dirpath_PROMPT, selector->prompt);
      if (selector->optPrompt != NULL)
      { SetDlgItemText(Dialog, dirpath_OPTION, selector->optPrompt);
          EnableWindow(GetDlgItem(Dialog, dirpath_BROWSE), true); // was false
        EnableWindow(GetDlgItem(Dialog, dirpath_PATH), true);       // was false
      }
      else
      { ShowWindow(GetDlgItem(Dialog, dirpath_OPTION), SW_HIDE);
      }
      SetWindowLong(Dialog, GWL_USERDATA, ((PROPSHEETPAGE *) lParam)->lParam);
      SetDlgItemText(Dialog, dirpath_PATH, selector->selectedPath());

      // if this is the first time this function is called, then centre the
      // wizard into the centre of our screen.
      if (first)
      { gsInstall_wizard_centre(GetParent(Dialog));
        first = false;
      }
    }
    return TRUE;

    case WM_COMMAND:
        switch (LOWORD(wParam))
      { case dirpath_BROWSE:
            ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA))->requestPath(Dialog, "Select Directory");
          SetDlgItemText(Dialog, dirpath_PATH, ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA))->selectedPath());
        break;

        case dirpath_OPTION:
            ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA))->setOption(IsDlgButtonChecked(Dialog, dirpath_OPTION));
            if (HIWORD(wParam) == BN_CLICKED && false) // don't do the enable/disable these days
          { EnableWindow(GetDlgItem(Dialog, dirpath_BROWSE), IsDlgButtonChecked(Dialog, dirpath_OPTION));
            EnableWindow(GetDlgItem(Dialog, dirpath_PATH), IsDlgButtonChecked(Dialog, dirpath_OPTION));
          }
        break;
      }
    break;

    case WM_NOTIFY:
        switch (((LPNMHDR) lParam)->code)
      { case PSN_SETACTIVE:
        {   dirSelector *selector = ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA));
            if (selector->isFinal())
            { PropSheet_SetWizButtons(GetParent(Dialog), PSWIZB_BACK | PSWIZB_FINISH);
            }
          else
            { PropSheet_SetWizButtons(GetParent(Dialog), PSWIZB_BACK | PSWIZB_NEXT);
          }
        }
        break;

        case PSN_KILLACTIVE:
        { // note the path from the dialog
            dirSelector *selector = ((dirSelector *) GetWindowLong(Dialog, GWL_USERDATA));
            selector->setPathFromEdit(GetDlgItem(Dialog, dirpath_PATH));

            // create a new FilePath object to check on the proposed destination
                    FilePath *path = new FilePath(selector->selectedPath());
          if (path->exists() == false)
          { char buffer[128];

            sprintf(buffer, "Directory %s does not exist - create it?", selector->selectedPath());

            // if the user cancelled that, then don't permit them to go to the next
            // page of the wizard
            if (MessageBox(0, buffer, app_name, MB_YESNO | MB_TOPMOST) == IDNO)
            {   delete path;
                SetWindowLong(Dialog, DWL_MSGRESULT, TRUE);
              return TRUE;
            }
          }
          delete path;
        }
        break;

                case PSN_WIZNEXT:
          { if (((LPNMHDR) lParam)->idFrom == 0)
            { // TODO: note a default here
            }
          }
        break;

        case PSN_WIZFINISH:
          { // Finish the activity now
            config_complete = true;
          }
        break;
      }
    break;
  }
    return FALSE;
}

void GSInstall_init_propertySheet(PROPSHEETPAGE &ppage, char *prompt, char *optPrompt,
                                                                    char *title, GSInstall &installer, bool isFinal)
{ GSInstall_dirPathData *data = new GSInstall_dirPathData;

    data->dirSelect     = new dirSelector(prompt, optPrompt, title, installer.installPath());
  data->dirSelect->setFinal(isFinal);

  installer.addSelectedDir(data->dirSelect);

    ppage.dwSize        = sizeof(PROPSHEETPAGE);
    ppage.dwFlags       = PSP_USETITLE;
  ppage.hInstance   = app_instance;
  ppage.pszTemplate = "getDirPath";
  ppage.pszIcon         = 0;
  ppage.pszTitle        = app_name;
  ppage.pfnDlgProc  = (DLGPROC) GSInstall_dlgproc;
    ppage.lParam      = (LPARAM) data->dirSelect;
  ppage.pfnCallback = NULL;
}

int CALLBACK GSInstall_wizardProc(HWND dialog, UINT Message, LPARAM lParameter)
{ switch (Message)
    { case PSCB_INITIALIZED :
            // Process PSCB_INITIALIZED
      gsInstall_wizard_centre(dialog);
        break ;

        case PSCB_PRECREATE :
            // Process PSCB_PRECREATE
        break ;

        default :
            // Unknown message
        break ;
    }
  return 0;
}

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;
    pshead.ppsp        = ppage;
    pshead.pfnCallback = GSInstall_wizardProc;

  GSInstall_init_propertySheet( ppage[0],
                                                            "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);

  reply = (PropertySheet (&pshead) >= 0);
  return reply;
}

long FAR PASCAL GSInstallWindProc(HWND          Window,
                                                                    WORD            Message,
                                                                    WPARAM      wParameter,
                                                                    LPARAM      lParameter)
{ long reply = 0;

  switch(Message)
    { case WM_CREATE:
    {
    }
    break;

    case WM_COMMAND:
        break;

    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);
            }
      else
      { install.setDestination();
        install.setManifest();
          install.copyFiles();
        install.updateProgman();
          install.updateRegistry();
        install.updateProfiles();
        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);
        }
        break;

        default:
            return(DefWindowProc(Window, Message, wParameter, lParameter));
    }
  return reply;
}

void GSInstall_init(HINSTANCE instance, int Show)
{ int sx, sy;

    gsInstall_getDesktopExt(&sx, &sy);

    app_window = CreateWindow("GSInstall:Main", "GreenStone Installer",
                                                            WS_OVERLAPPEDWINDOW | WS_MAXIMIZE | CS_DBLCLKS,
                                                            0, 0,
                                                            sx, sy,
                                                            NULL,
                                                            NULL,
                                                            app_instance,
                                                            NULL);

    ShowWindow(app_window, Show);

  PostMessage(app_window, WM_USER, 0, 0L);
}

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);*/
}

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 */
  GSInstall_init(Current, CmdShow);

//  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;
}