PC/CD Gamer UK 43/PCGAMER43.bin/utils/wing/timewing.cp_/timewing.cp

Text File | 1995-06-20 | 26.8 KB | 948 lines

/**************************************************************************

    TIMEWING.CPP - A timing demo for WinG

 **************************************************************************/
/**************************************************************************

    (C) Copyright 1994 Microsoft Corp.  All rights reserved.

    You have a royalty-free right to use, modify, reproduce and
    distribute the Sample Files (and/or any modified version) in
    any way you find useful, provided that you agree that
    Microsoft has no warranty obligations or liability for any
    Sample Application Files which are modified.

 **************************************************************************/

#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>
#include "timewing.h"

#include <string.h>
#include <mmsystem.h>
#include <fstream.h>
#include <strstrea.h>

#include <wing.h>
#include "..\utils\utils.h"

/*----------------------------------------------------------------------------*\
|                                        |
| g l o b a l   v a r i a b l e s                        |
|                                        |
\*----------------------------------------------------------------------------*/
static  char       szAppName[]="WinG Timer Sample";
static  char       szAppFilter[]="Bitmaps\0*.bmp\0";

static  HINSTANCE  hInstApp;
HWND               hwndApp;
static  HPALETTE   hpalApp;
static  BOOL       fAppActive;

static int         dx, dy;

PDIB               pCurrentDIB;
char               aDescription[200];
char               aBuffer[5000];
UINT               CurrentDIBUsage;

struct
{
  BITMAPINFOHEADER Header;
  RGBQUAD aColors[256];
} Info;

int Iterations = 100;
int StretchMenu = 0;
float StretchFactor = 1;

/*----------------------------------------------------------------------------

Timers

*/

struct timing_result;
typedef void timer( timing_result *pResults, HWND Window );

timer TimeStretchBlt;
timer TimeStretchDIBits;
timer TimeWinGBU;
timer TimeWinGTD;


/*----------------------------------------------------------------------------

Timer structure.

*/

void PrintTimingResults( ostream &Out );

struct timing_result
{
  DWORD Time;
  timer *pTimer;
  char const *pDescription;
} aTimings[] =
{
  0, TimeStretchBlt, "StretchBlt",
  0, TimeStretchDIBits, "StretchDIBits",
  0, TimeWinGTD, "WinGStretchBlt top-down",
  0, TimeWinGBU, "WinGStretchBlt bottom-up",
};

int const NumberOfTimings = sizeof(aTimings) / sizeof(aTimings[0]);




#if defined(WIN32) || defined(_WIN32)
  #define _export
#endif

/*----------------------------------------------------------------------------*\
|                                        |
| f u n c t i o n   d e f i n i t i o n s                    |
|                                        |
\*----------------------------------------------------------------------------*/

LONG FAR PASCAL _export  AppWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
int   ErrMsg (LPSTR sz,...);
LONG  AppCommand (HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);

void  AppExit(void);
BOOL  AppIdle(void);
void  AppOpenFile(HWND hwnd, LPSTR szFileName);

/*----------------------------------------------------------------------------*\
| AppAbout( hDlg, uiMessage, wParam, lParam )                  |
|                                        |
| Description:                                 |
|   This function handles messages belonging to the "About" dialog box.    |
|   The only message that it looks for is WM_COMMAND, indicating the use   |
|   has pressed the "OK" button.  When this happens, it takes down       |
|   the dialog box.                              |
|                                        |
| Arguments:                                   |
|   hDlg      window handle of about dialog window           |
|   uiMessage   message number                       |
|   wParam      message-dependent                    |
|   lParam      message-dependent                    |
|                                        |
| Returns:                                   |
|   TRUE if message has been processed, else FALSE               |
|                                        |
\*----------------------------------------------------------------------------*/
BOOL FAR PASCAL _export AppAbout(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
  switch (msg)
  {
    case WM_COMMAND:
      if (LOWORD(wParam) == IDOK)
      {
        EndDialog(hwnd,TRUE);
      }
      break;

    case WM_INITDIALOG:
      return TRUE;
  }
  return FALSE;
}

/*----------------------------------------------------------------------------*\
| AppInit( hInst, hPrev)                                                       |
|                                                                              |
| Description:                                                                 |
|   This is called when the application is first loaded into                   |
|   memory.  It performs all initialization that doesn't need to be done       |
|   once per instance.                                                         |
|                                                                              |
| Arguments:                                                                   |
|   hInstance   instance handle of current instance                            |
|   hPrev       instance handle of previous instance                           |
|                                                                              |
| Returns:                                                                     |
|   TRUE if successful, FALSE if not                                           |
|                                                                              |
\*----------------------------------------------------------------------------*/
BOOL AppInit(HINSTANCE hInst,HINSTANCE hPrev,int sw,LPSTR szCmdLine)
{
  WNDCLASS cls;

  /* Save instance handle for DialogBoxes */
  hInstApp = hInst;

// Clear the System Palette so that WinGStretchBlt runs at full speed.
  ClearSystemPalette();

  if (!hPrev)
  {
    /*
     *  Register a class for the main application window
     */
    cls.hCursor      = LoadCursor(NULL,IDC_ARROW);
    cls.hIcon      = LoadIcon(hInst,"AppIcon");
    cls.lpszMenuName   = "AppMenu";
    cls.lpszClassName  = szAppName;
    cls.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
    cls.hInstance    = hInst;
    cls.style      = CS_BYTEALIGNCLIENT | CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;
    cls.lpfnWndProc    = (WNDPROC)AppWndProc;
    cls.cbWndExtra     = 0;
    cls.cbClsExtra     = 0;

    if (!RegisterClass(&cls))
      return FALSE;
  }

  dx = 400;
  dy = 400;

  hwndApp = CreateWindow (szAppName,    // Class name
              szAppName,                // Caption
              WS_OVERLAPPEDWINDOW,      // Style bits
              50, 50,                   // Position
              dx+20,dy+75,              // Size
              (HWND)NULL,               // Parent window (no parent)
              (HMENU)NULL,              // use class menu
              hInst,                    // handle to window instance
              (LPSTR)NULL               // no params to pass on
               );
  ShowWindow(hwndApp,sw);


    HMENU Menu = GetMenu(hwndApp);
    CheckMenuItem(Menu,MENU_1TO1,MF_CHECKED);

    //
    // build the timing menu.
    //

    HMENU hmenu = GetSubMenu(Menu, 3);
    DeleteMenu(hmenu, MENU_TIME, MF_BYCOMMAND);

    for (int i=0; i<NumberOfTimings; i++)
    {
        AppendMenu(hmenu, 0, MENU_TIME+i, aTimings[i].pDescription);
    }

    hpalApp = WinGCreateHalftonePalette();
    AppOpenFile(hwndApp,"frog.bmp");

    if(!pCurrentDIB)
    {
      // we couldn't load froggie

      PostMessage(hwndApp,WM_COMMAND,MENU_OPEN,0);
    }

  return TRUE;
}


/*----------------------------------------------------------------------------*\
| AppExit()                                                                    |
|                                                                              |
| Description:                                                                 |
|   App is just about to exit, cleanup.                                        |
|                                                                              |
\*----------------------------------------------------------------------------*/
void AppExit()
{
  DeleteObject(hpalApp);
}

/*----------------------------------------------------------------------------*\
| WinMain( hInst, hPrev, lpszCmdLine, cmdShow )                                |
|                                                                              |
| Description:                                                                 |
|   The main procedure for the App.  After initializing, it just goes          |
|   into a message-processing loop until it gets a WM_QUIT message             |
|   (meaning the app was closed).                                              |
|                                                                              |
| Arguments:                                                                   |
|   hInst     instance handle of this instance of the app                      |
|   hPrev     instance handle of previous instance, NULL if first              |
|   szCmdLine ->null-terminated command line                                   |
|   cmdShow   specifies how the window is initially displayed                  |
|                                                                              |
| Returns:                                                                     |
|   The exit code as specified in the WM_QUIT message.                         |
|                                                                              |
\*----------------------------------------------------------------------------*/
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
{
  MSG   msg;

  /* Call initialization procedure */
  if (!AppInit(hInst,hPrev,sw,szCmdLine))
  return FALSE;

  /*
   * Polling messages from event queue
   */
  for (;;)
  {
    if (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))
    {
      if (msg.message == WM_QUIT)
        break;

      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
    else
  {
    if (AppIdle())
        WaitMessage();
    }
  }

  AppExit();
  return msg.wParam;
}

/*----------------------------------------------------------------------------*\
| AppIdle()
|
| Description:
|   Place to do idle time stuff.
|
\*----------------------------------------------------------------------------*/
BOOL AppIdle()
{
  if (fAppActive)
  {
  //
  // we are the foreground app.
  //
  return TRUE;    // nothing to do.
  }
  else
  {
  //
  // we are a background app.
  //
  return TRUE;    // nothing to do.
  }
}

/*----------------------------------------------------------------------------*\
| AppOpenFile()
|
| Description:
|   Open a file.
|
\*----------------------------------------------------------------------------*/
void AppOpenFile(HWND hwnd, LPSTR szFileName)
{
  PDIB pDIB = DibOpenFile(szFileName);

  if(pDIB)
  {
    if(pCurrentDIB)
    {
      DibFree(pCurrentDIB);
    }

    pCurrentDIB = pDIB;

     // Map the dib to the palette if it's not 4-bit

    if (DibBitCount(pDIB) != 4)
    {
      DibMapToPalette(pCurrentDIB,hpalApp);
        CurrentDIBUsage = DIB_PAL_COLORS;

      hmemcpy(&Info,pDIB,sizeof(Info));

      DibSetUsage(pCurrentDIB,hpalApp,CurrentDIBUsage);
    }
     else
     {
       CurrentDIBUsage = DIB_RGB_COLORS;
     }

    ostrstream Out(aDescription,sizeof(aDescription));

    while(*szFileName)
    {
      Out<<*szFileName++;   // can't use far * and near stream.
    }

    Out<<" - "<<DibWidth(pDIB)<<" x "<<DibHeight(pDIB)<<ends;

    SetWindowText(hwnd,aDescription);
  }
}

/*----------------------------------------------------------------------------*\
| AppPaint(hwnd, hdc)
|
| Description:
|   The paint function.
|
| Arguments:
|   hwnd       window painting into
|   hdc        display context to paint to
|
\*----------------------------------------------------------------------------*/
AppPaint (HWND hwnd, HDC hdc)
{
  RECT  rc;

  GetClientRect(hwnd,&rc);

  SetTextColor(hdc,GetSysColor(COLOR_WINDOWTEXT));
  SetBkColor(hdc,GetSysColor(COLOR_WINDOW));

  return TRUE;
}

/*----------------------------------------------------------------------------*\
| AppWndProc( hwnd, uiMessage, wParam, lParam )                                |
|                                                                              |
| Description:                                                                 |
|   The window proc for the app's main (tiled) window.  This processes all     |
|   of the parent window's messages.                                           |
|                                                                              |
\*----------------------------------------------------------------------------*/
LONG FAR PASCAL _export AppWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
  PAINTSTRUCT ps;
  HDC hdc;
  BOOL f;

  switch (msg)
  {
    case WM_CREATE:
    break;

    case WM_ACTIVATEAPP:
    fAppActive = (BOOL)wParam;
    break;

    case WM_TIMER:
      break;

    case WM_ERASEBKGND:
      break;

    case WM_INITMENU:
      break;

    case WM_COMMAND:
      return AppCommand(hwnd,msg,wParam,lParam);

  case WM_DESTROY:
      PostQuitMessage(0);
      break;

    case WM_CLOSE:
    break;

    case WM_SIZE:
    {
      static FirstTime = 1;

      if(FirstTime)
      {
        FirstTime = 0;
        break;
      }
      else
      {
        return 0;
        break;
      }
    }

    case WM_PALETTECHANGED:
    if ((HWND)wParam == hwnd)
    break;

    // fall through to WM_QUERYNEWPALETTE

  case WM_QUERYNEWPALETTE:
    hdc = GetDC(hwnd);

    if (hpalApp)
      SelectPalette(hdc, hpalApp, FALSE);

    f = RealizePalette(hdc);
    ReleaseDC(hwnd,hdc);

    if (f)
      InvalidateRect(hwnd,NULL,TRUE);

    return f;

    case WM_PAINT:
    hdc = BeginPaint(hwnd,&ps);
    AppPaint (hwnd,hdc);
      EndPaint(hwnd,&ps);
      return 0L;
  }
  return DefWindowProc(hwnd,msg,wParam,lParam);
}

/*----------------------------------------------------------------------------*\
| AppCommand(hwnd, msg, wParam, lParam )                                       |
|                                                                              |
| Description:                                                                 |
|   Handles WM_COMMAND messages for the main window (hwndApp)                  |
| of the parent window's messages.                                             |
|                                                                              |
\*----------------------------------------------------------------------------*/
LONG AppCommand (HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
  static char achFileName[128];
  OPENFILENAME ofn;
  ostrstream Out(aBuffer,sizeof(aBuffer));
  int PrevStretchMenu;
  int i;

  switch(wParam)
  {
    case MENU_ABOUT:
    DialogBox(hInstApp,"AppAbout",hwnd,(DLGPROC)AppAbout);
      break;

    case MENU_TIMEALL:
    {
      HCURSOR Arror = SetCursor(0);

      for(int Counter = 0;Counter < NumberOfTimings;Counter++)
      {
        SetWindowText(hwndApp,aTimings[Counter].pDescription);

        (*aTimings[Counter].pTimer)(aTimings+Counter,hwnd);
      }

      SetCursor(Arror);
      SetWindowText(hwndApp,aDescription);

      PrintTimingResults(Out);
      MessageBox(0,aBuffer,"Timing Results",MB_OK);

      break;
    }

    case MENU_1TO1:
    case MENU_1TO2:
    case MENU_1TOALMOST2:
    {
      float aStretchFactors[3] = { 1, 2, 1.9 };
      HMENU Menu = GetMenu(hwnd);

      // uncheck current selection
      CheckMenuItem(Menu,MENU_1TO1 + StretchMenu,MF_UNCHECKED);

      PrevStretchMenu = StretchMenu;

      StretchMenu = wParam - MENU_1TO1;

      // get the stretch factor
      StretchFactor = aStretchFactors[StretchMenu];

      Iterations = (StretchFactor == 1) ? 100 : 20;

      CheckMenuItem(Menu,wParam,MF_CHECKED);

      if (StretchMenu != PrevStretchMenu)
      {
        for (i = 0; i < NumberOfTimings; i++)
          aTimings[i].Time = 0;
      }

      break;
    }

    default:
    {
      int Index = (int)LOWORD(wParam) - MENU_TIME;

      if(Index >= 0 && Index < NumberOfTimings)
      {
        HCURSOR Arror = SetCursor(0);

        SetWindowText(hwndApp,aTimings[Index].pDescription);

        (*aTimings[Index].pTimer)(aTimings+Index,hwnd);

        SetCursor(Arror);
        SetWindowText(hwndApp,aDescription);
      }

      PrintTimingResults(Out);
      MessageBox(0,aBuffer,"Timing Results",MB_OK);
      InvalidateRect(hwnd,0,TRUE);
      UpdateWindow(hwnd);

      break;
    }

  case MENU_OPEN:
  {
      /* prompt user for file to open */
      ofn.lStructSize = sizeof(OPENFILENAME);
      ofn.hwndOwner = hwnd;
      ofn.hInstance = NULL;
      ofn.lpstrFilter = szAppFilter;
      ofn.lpstrCustomFilter = NULL;
      ofn.nMaxCustFilter = 0;
      ofn.nFilterIndex = 0;
      ofn.lpstrFile = achFileName;
      ofn.nMaxFile = sizeof(achFileName);
      ofn.lpstrFileTitle = NULL;
      ofn.nMaxFileTitle = 0;
      ofn.lpstrInitialDir = NULL;
      ofn.lpstrTitle = NULL;
      ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
      ofn.nFileOffset = 0;
      ofn.nFileExtension = 0;
      ofn.lpstrDefExt = NULL;
      ofn.lCustData = 0;
      ofn.lpfnHook = NULL;
      ofn.lpTemplateName = NULL;

      if(GetOpenFileName(&ofn))
      {
        AppOpenFile(hwnd,achFileName);
        break;
      }
  }

      break;

    case MENU_EXIT:
      PostMessage(hwnd,WM_CLOSE,0,0L);
      break;
  }
  return 0L;
}




/*----------------------------------------------------------------------------*\
| ErrMsg - Opens a Message box with a error message in it.  The user can       |
|      select the OK button to continue                                        |
\*----------------------------------------------------------------------------*/
int ErrMsg (LPSTR sz,...)
{
  char ach[128];

  wvsprintf (ach,sz,(LPSTR)(&sz+1));   /* Format the string */
  MessageBox(hwndApp,ach,szAppName,MB_OK|MB_ICONEXCLAMATION|MB_TASKMODAL);
  return FALSE;
}


void PrintTimingResults( ostream &Out )
{
  int CurrentOffset = 0;

  for(int Counter = 0;Counter < NumberOfTimings;Counter++)
  {
    Out<<aTimings[Counter].pDescription
      <<":\t";

    if(aTimings[Counter].Time)
    {
      Out.setf(ios::fixed | ios::showpoint);
      Out.width(6);
      Out.precision(2);
      Out<<(Iterations / (aTimings[Counter].Time / 1000.0))<<" per Second"<<endl;
    }
    else
    {
      Out<<"Not timed yet"<<endl;
    }

  }

  Out<<ends;

}



/*----------------------------------------------------------------------------

StretchBlt

*/

void TimeStretchBlt( timing_result *pResult, HWND Window )
{
  int Counter;
  HDC Screen = GetDC(Window);
  DWORD Time;

  // setup here

  HDC Buffer = CreateCompatibleDC(Screen);
  HBITMAP Bitmap = CreateCompatibleBitmap(Screen,DibWidth(pCurrentDIB),
            DibHeight(pCurrentDIB));
  Bitmap = SelectBitmap(Buffer,Bitmap);

  HPALETTE OldPalette = SelectPalette(Buffer,hpalApp,FALSE);
  SelectPalette(Screen,hpalApp,FALSE);
  RealizePalette(Screen);
  RealizePalette(Buffer);
  SetStretchBltMode(Buffer,COLORONCOLOR);

  StretchDIBits(Buffer,0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),
    0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),DibPtr(pCurrentDIB),
    DibInfo(pCurrentDIB),CurrentDIBUsage,SRCCOPY);

  SetStretchBltMode(Screen,COLORONCOLOR);

  int Width = StretchFactor * DibWidth(pCurrentDIB);
  int Height = StretchFactor * DibHeight(pCurrentDIB);

  Time = timeGetTime();

  for(Counter = 0;Counter < Iterations;Counter++)
  {
    StretchBlt(Screen,Counter,Counter,Width,Height,
      Buffer,0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),
      SRCCOPY);
  }

  Time = timeGetTime() - Time;

  pResult->Time = Time;

  // clean up

  SelectPalette(Buffer,OldPalette,FALSE);
  SelectPalette(Screen,OldPalette,FALSE);
  DeleteObject(SelectBitmap(Buffer,Bitmap));
  DeleteDC(Buffer);

  ReleaseDC(Window,Screen);
}



/*----------------------------------------------------------------------------

StretchDIBits

*/

void TimeStretchDIBits( timing_result *pResult, HWND Window )
{
  int Counter;
  HDC Screen = GetDC(Window);
  DWORD Time;

  // setup here

  HPALETTE OldPalette = SelectPalette(Screen,hpalApp,FALSE);
  RealizePalette(Screen);

  int Width = StretchFactor * DibWidth(pCurrentDIB);
  int Height = StretchFactor * DibHeight(pCurrentDIB);

  Time = timeGetTime();

  for(Counter = 0;Counter < Iterations;Counter++)
  {
    StretchDIBits(Screen,Counter,Counter,Width,Height,
      0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),
      DibPtr(pCurrentDIB),DibInfo(pCurrentDIB),CurrentDIBUsage,SRCCOPY);
  }

  Time = timeGetTime() - Time;

  pResult->Time = Time;

  // clean up

  SelectPalette(Screen,OldPalette,FALSE);

  ReleaseDC(Window,Screen);
}

/*----------------------------------------------------------------------------

WinGStretchBlt - bottom-up

*/

void TimeWinGBU( timing_result *pResult, HWND Window )
{
  int Counter;
  HDC Screen = GetDC(Window);
  DWORD Time;

  void far *pBits;

  // setup here

  HDC WinGDC = WinGCreateDC();

  Info.Header.biSize = sizeof(BITMAPINFOHEADER);
  Info.Header.biWidth = DibWidth(pCurrentDIB);

  // NOTE!  You should use the WinGRecommendedDIBFormat for your WinGBitmaps.
  // This is forced to bottom-up for this example.  See the WinG.HLP file.

  Info.Header.biHeight = DibHeight(pCurrentDIB);

  HBITMAP WinGBitmap = WinGCreateBitmap(WinGDC,(BITMAPINFO far *)&Info,
                &pBits);

  WinGBitmap = SelectBitmap(WinGDC,WinGBitmap);

  HPALETTE OldPalette = SelectPalette(Screen,hpalApp,FALSE);
  RealizePalette(Screen);

  // We're selecting a palette into the WinGDC so we can use the
  // DIB_PAL_COLORS pCurrentDIB.  This does NOT change the WinGBitmap's
  // color table, but GDI needs to look up the DIB_PAL_COLORS somewhere!
  // Different devices can't share a palette, so we need another copy.

  HPALETTE WinGPalette = WinGCreateHalftonePalette();

  HPALETTE OldWinGPalette = SelectPalette(WinGDC,WinGPalette,FALSE);
  RealizePalette(WinGDC);

  SetStretchBltMode(WinGDC,COLORONCOLOR);

  StretchDIBits(WinGDC,0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),
    0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),DibPtr(pCurrentDIB),
    DibInfo(pCurrentDIB),CurrentDIBUsage,SRCCOPY);

  // we just needed the palette for the StretchDIBits

  SelectPalette(WinGDC,OldWinGPalette,FALSE);
  DeleteObject(WinGPalette);

  int Width = StretchFactor * DibWidth(pCurrentDIB);
  int Height = StretchFactor * DibHeight(pCurrentDIB);

  // WinG does a lot of work on the first blt, so do it outside the loop

  WinGStretchBlt(Screen,0,0,Width,Height,
      WinGDC,0,0,DibWidth(pCurrentDIB),
      DibHeight(pCurrentDIB));

  Time = timeGetTime();

  for(Counter = 0;Counter < Iterations;Counter++)
  {
    WinGStretchBlt(Screen,Counter,Counter,Width,Height,
      WinGDC,0,0,DibWidth(pCurrentDIB),
      DibHeight(pCurrentDIB));
  }

  Time = timeGetTime() - Time;

  pResult->Time = Time;

  // clean up

  SelectPalette(Screen,OldPalette,FALSE);
  SelectPalette(WinGDC,OldPalette,FALSE);
  DeleteObject(SelectBitmap(WinGDC,WinGBitmap));
  DeleteDC(WinGDC);

  ReleaseDC(Window,Screen);
}


/*----------------------------------------------------------------------------

WinGStretchBlt - top-down

*/

void TimeWinGTD( timing_result *pResult, HWND Window )
{
  int Counter;
  HDC Screen = GetDC(Window);
  DWORD Time;

  void far *pBits;

  // setup here

  HDC WinGDC = WinGCreateDC();

  Info.Header.biSize = sizeof(BITMAPINFOHEADER);
  Info.Header.biWidth = DibWidth(pCurrentDIB);

  // NOTE!  You should use the WinGRecommendedDIBFormat for your WinGBitmaps.
  // This is forced to top-down for this example.  See the WinG.HLP file.

  Info.Header.biHeight = -int(DibHeight(pCurrentDIB));

  HBITMAP WinGBitmap = WinGCreateBitmap(WinGDC,(BITMAPINFO far *)&Info,
                &pBits);

  WinGBitmap = SelectBitmap(WinGDC,WinGBitmap);

  HPALETTE OldPalette = SelectPalette(Screen,hpalApp,FALSE);
  RealizePalette(Screen);

  // We're selecting a palette into the WinGDC so we can use the
  // DIB_PAL_COLORS pCurrentDIB.  This does NOT change the WinGBitmap's
  // color table, but GDI needs to look up the DIB_PAL_COLORS somewhere!
  // Different devices can't share a palette, so we need another copy.

  HPALETTE WinGPalette = WinGCreateHalftonePalette();

  HPALETTE OldWinGPalette = SelectPalette(WinGDC,WinGPalette,FALSE);
  RealizePalette(WinGDC);

  SetStretchBltMode(WinGDC,COLORONCOLOR);

  StretchDIBits(WinGDC,0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),
    0,0,DibWidth(pCurrentDIB),DibHeight(pCurrentDIB),DibPtr(pCurrentDIB),
    DibInfo(pCurrentDIB),CurrentDIBUsage,SRCCOPY);

  // we just needed the palette for the StretchDIBits

  SelectPalette(WinGDC,OldWinGPalette,FALSE);
  DeleteObject(WinGPalette);

  int Width = StretchFactor * DibWidth(pCurrentDIB);
  int Height = StretchFactor * DibHeight(pCurrentDIB);

  // WinG does a lot of work on the first blt, so do it outside the loop

  WinGStretchBlt(Screen,0,0,Width,Height,
      WinGDC,0,0,DibWidth(pCurrentDIB),
      DibHeight(pCurrentDIB));

  Time = timeGetTime();

  for(Counter = 0;Counter < Iterations;Counter++)
  {
    WinGStretchBlt(Screen,Counter,Counter,Width,Height,
      WinGDC,0,0,DibWidth(pCurrentDIB),
      DibHeight(pCurrentDIB));
  }

  Time = timeGetTime() - Time;

  pResult->Time = Time;

  // clean up

  SelectPalette(Screen,OldPalette,FALSE);
  SelectPalette(WinGDC,OldPalette,FALSE);
  DeleteObject(SelectBitmap(WinGDC,WinGBitmap));
  DeleteDC(WinGDC);

  ReleaseDC(Window,Screen);
}