source: trunk/gsinstaller/gs16bit.cpp@ 1538

#include <windows.h>

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

#include "splash.h"
#include "bmputil.h"

// define the magic value used in GetWinFlags to show that this application
// is running on a Windows NT box in 16-bit emulation mode.
#define WF_WINNT 0x4000

#ifdef _WIN32
int GetWinFlags()
{
  return 0;
}
#endif

HWND app_window;
HINSTANCE app_instance;
char *app_cmdLine;

typedef void (* splashfn) (HINSTANCE a, unsigned int time);
typedef HBITMAP (* bmploadfn) (HDC device, LPSTR name);

typedef struct
{   
  BYTE majorVersion;
  BYTE minorVersion;
  WORD buildNumber;
  BOOL debug;
} win32sInfo, FAR * lpWin32sInfo;

typedef enum
{ 
  Windows2x, Windows3_0x, Windows3_1x, Windows9x, WindowsNT
} gs16PlatformId;

typedef struct
{   
  gs16PlatformId platform;
  bool win32s;
} gs16PlatformInfo;

//typedef int FAR PASCAL (* win32sInfoFn)(lpWin32sInfo);
typedef int (FAR PASCAL * win32sInfoFn)(lpWin32sInfo);

bool GS16bit_checkForWin32s()
{
  //  HANDLE w32sHandle;
  HINSTANCE w32sHandle;
  win32sInfoFn infoFnPtr;
  win32sInfo w32sInfo;
  bool reply = false;

  // try to get a handle onto the win32s library
  w32sHandle = LoadLibrary("W32SYS.DLL");

  //  if (w32sHandle > HINSTANCE_ERROR)
  if (w32sHandle != NULL)
  { 
    // now get the address of the GetWin32sInfo function
    infoFnPtr = (win32sInfoFn) GetProcAddress(w32sHandle, "GETWIN32SINFO");

    // if the function exists, we've got win32s1.1 or later
    if (infoFnPtr != NULL)
    {
      if ((*infoFnPtr)((lpWin32sInfo) &w32sInfo) == 0) // no error state
        {
      reply = true;
    }
      else  
    // error - call didn't work; assume that we have a non-functional
    // win32s
    {   
      reply = false;
    }
    }
    // else we've got win32s 1.0.  TODO: We need to check if it's actually up and
    // running;
    else
      { 
    reply = true;
      }

    // we need to free the library before finishing this function
    FreeLibrary(w32sHandle);
  }
  // no win32s at all
  else
  {
    reply = false;
  }

  return reply;
}

void GS16bit_getPlatformInfo(gs16PlatformInfo &info)
{
  DWORD version = GetVersion();

  /**
   * NB: Ignore ALL standard information on using GetVersion in the
   *     standard Windows 3.1 SDK and Windows 32-bit SDK documentation;
   *     the latter does not apply, and the former is (slightly but signif-
   *     cantly) misdocumented.
   *
   *     On 16-bit windows (i.e. this program) take the following comments
   *     as gospel.  Also refer to
   *
   *        http://support.microsoft.com/support/kb/articles/Q131/3/71.asp
   */
  BYTE majorVersion = LOBYTE(LOWORD(version));
  BYTE minorVersion = HIBYTE(LOWORD(version));
  BYTE dosVersion = HIBYTE(HIWORD(version));

  if (majorVersion < 3)
  { 
    info.platform = Windows2x;
  }
  else if (majorVersion == 3 && minorVersion >= 95) 
    // it's Windows 95 from the
    // minor version; I guess that
    // 98 may have minor version == 98,
    // but I don't know!  Hence the
    // cautious check
  { 
    info.platform = Windows9x;
  }
  else // we're running in "some sort" of Windows 3.x environment
  { 
    if (minorVersion == 10 && dosVersion == 5)
      // it could be running under WOW
      // (16-bit Windows emulation in
      //  Windows NT)
      {
    if ((GetWinFlags() & WF_WINNT) == WF_WINNT) // check for NT in emulation mode
      { 
        info.platform = WindowsNT;
      }
    else
      {
        info.platform = Windows3_1x;
      }
      }
    else if (minorVersion >= 10) // perhaps Windows 3.11
      {
    info.platform = Windows3_1x;
      }
    else
      {
    info.platform = Windows3_0x;
      }
  }

  if (info.platform == Windows3_1x)
    {
      info.win32s = GS16bit_checkForWin32s();
    }
  else
    {   
      info.win32s = false;
    }
}

void GS16bit_checkWindowsVersion()
{   
  gs16PlatformInfo platformInfo;

  GS16bit_getPlatformInfo(platformInfo);
  if (platformInfo.platform == Windows3_0x ||
      platformInfo.platform == Windows2x)
    {   
      MessageBox(app_window,
         "Greenstone cannot be installed on this computer.  It requires "
         "Windows 3.10 or later",
         "Greenstone Installer",
         MB_OK);
    }
  else if (platformInfo.platform == Windows3_1x &&
       platformInfo.win32s == false)
    {
      MessageBox(app_window,
         "Greenstone requires 32 bit Windows.  Win32s will now be installed "
         "on your computer to provide this, before continuing with the main "
         "installation.",
         "Greenstone Installer",
         MB_OK);
    }
  else
    {
      char buffer[20];
      int result;
      /*    MessageBox(app_window,
        "Greenstone will now install", "Greenstone Installer", MB_OK);*/
      result = WinExec("gssetup.exe", SW_SHOWNORMAL);
    }
}

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

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

    case WM_COMMAND:
      break;

    case WM_CLOSE:
      DestroyWindow(Window);
      return 0L;

    case WM_DESTROY:
      {
    PostQuitMessage(0);
      }
      break;

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

void GS16bit_init(HINSTANCE instance, int Show)
{
  FARPROC showsplash;
  FARPROC loadbmp;
  HDC dc;
  char buffer[20];

  /*
    dc = GetDC(GetDesktopWindow());
    bmpUtil loadBitmap(dc, "C:\\gs.bmp");
    ReleaseDC(GetDesktopWindow(), dc);
  */
  //    showsplash = MakeProcInstance((FARPROC) splash_show, instance);
  //    (*(splashfn) showsplash)(instance, 3000);

  GS16bit_checkWindowsVersion();

  app_window = CreateWindow("GS16bit:Main", "GreenStone Installer",
                WS_OVERLAPPEDWINDOW | WS_MINIMIZE | CS_DBLCLKS,
                CW_USEDEFAULT,
                0,
                CW_USEDEFAULT,
                0,
                NULL,
                NULL,
                app_instance,
                NULL);

  ShowWindow(app_window, Show);
  
  PostQuitMessage(0);
}

void WinClassInit(void)
{ 
  WNDCLASS Class;

  Class.lpszClassName = "GS16bit:Main";
  Class.hInstance = app_instance;
  Class.lpfnWndProc = (WNDPROC) GS16bitWindProc;
  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);
}

int PASCAL WinMain(HINSTANCE Current,
           HINSTANCE Previous,
           LPSTR CmdLine,
           int CmdShow)
{ 
  MSG msg;

  app_cmdLine = (char *) LocalAlloc(LMEM_FIXED, lstrlen(CmdLine) + 1);
  lstrcpy(app_cmdLine, CmdLine);
  
  app_instance = Current;
  /* -- init application */
  if (!Previous)
    {
      WinClassInit();
    }

  /* -- init instance */
  GS16bit_init(Current, CmdShow);

  while (GetMessage(&msg, NULL, 0, 0))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  return (int) msg.wParam;
}