source: trunk/gsinstaller/gs16bit.cpp@ 1539

#include "Splash.h"



UINT        timer;

HWND    splash_window;

BOOL        splash_done;

HBITMAP splash_bmp;

int         splash_bmpheight;



void CALLBACK splash_timerproc(HWND Window, UINT Message, UINT id, DWORD time)

{   splash_done = TRUE;

  KillTimer(NULL, 0);

}



long FAR PASCAL _export splash_windproc(HWND Window, UINT Message, WPARAM wParameter, LPARAM lParameter)

{   switch (Message)

    { case WM_CREATE:

    { timer = SetTimer(NULL, 0, 3000, (TIMERPROC) splash_timerproc);

    }

    break;



    case WM_TIMER: // valid id; just kill window after timer elapses

      splash_done = TRUE;

        KillTimer(Window, 0);

    break;



    case WM_DESTROY:

      splash_window = 0;

    break;



        case WM_PAINT:

        { PAINTSTRUCT   PaintInfo;

        HDC                 dc, bmpDC;

      BITMAP            bmpData;

      POINT             origin, size;                                        



            dc = BeginPaint(Window, &PaintInfo);

      bmpDC = CreateCompatibleDC(dc);

      SelectObject(bmpDC, splash_bmp);



      GetObject(splash_bmp, sizeof(BITMAP), (LPVOID) &bmpData);



      size.x = bmpData.bmWidth;

      size.y = bmpData.bmHeight;

      DPtoLP(dc, &size, 1);



      origin.x = 0;

      origin.y = 0;

      DPtoLP(dc, &origin, 1);



      BitBlt(dc, 0, 0, size.x, size.y,

             bmpDC, origin.x, origin.y, SRCCOPY);



      DeleteDC(bmpDC);

            EndPaint(Window, &PaintInfo);

        }

        break;



    case WM_COMMAND:

    break;



    default:

            return(DefWindowProc(Window, Message, wParameter, lParameter));

  }

    return 0L;

}



void splash_register(HINSTANCE instance)

{ WNDCLASS Class;

    static bool registered = false;

  if (registered == false)

  { Class.lpszClassName = "Generic:Splash";

        Class.hInstance     = 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);

    registered  = TRUE;

    }

}



void _export splash_show(HINSTANCE instance, unsigned int time)

{ MSG       msg;

  RECT      r;

  BITMAP    bmpData;

  POINT     size;

  int     sx, sy;

  HDC     dc;



  splash_register(instance);



  splash_bmp    = LoadBitmap(instance, (LPCSTR) MAKEINTRESOURCE(9007));

    splash_done = FALSE;



  GetObject(splash_bmp, sizeof(BITMAP), (LPVOID) &bmpData);

  size.x = bmpData.bmWidth;

  size.y = bmpData.bmHeight;



  r.left        = 0;

  r.top         = 0;

  r.right       = size.x;

  r.bottom  = size.y;

  AdjustWindowRect(&r, 0, TRUE);



  splash_bmpheight  = size.y;

  dc = GetDC(GetDesktopWindow());

  sx = GetDeviceCaps(dc, HORZRES);

  sy = GetDeviceCaps(dc, VERTRES);

  ReleaseDC(GetDesktopWindow(), dc);



    splash_window = CreateWindow("Generic:Splash", "Greenstone Installer",

                                                                WS_DLGFRAME | WS_VISIBLE,

                                (sx - r.right + r.left) / 2,

                                (sy - r.bottom + r.top) / 2,

                                r.right-r.left, r.bottom-r.top,

                                0, 0, instance, NULL);

  while (GetMessage(&msg, NULL, NULL, NULL) &&

                splash_done == FALSE)

  { if (msg.message == WM_TIMER)

    { msg.hwnd = splash_window;

    }

    TranslateMessage(&msg);

    DispatchMessage(&msg);

  }

  DestroyWindow(splash_window);

}



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