archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/com/oleutest/cachetst/main.cpp

1521 lines
34 KiB
Raw Blame History

// This is a multi-threaded app with two primary threads. One
// sits in the message loop, waiting specifically for WM_PAINT
// messages which are generated by the other thread, on which
// the actual unit test runs.
//
// When the window thread receives an update message, it takes
// a snapshot of the unit test state (protected by a mutex),
// and redraws the screen accordingly.
//
// When the unit test thread wants a resource to be drawn in
// the main window, it places the handle to that resource (for
// example, an HMETAFILEPICT) in the ctest object associated
// with the window thread, then fires a screen update. In
// doing so, ownership of the resource is transfered from the
// unit test thread to the window thread. By using this
// mechanism, the window thread can draw the resource at its
// leisure, while the unit test proceeds. The onus is on
// the window thread to clean up any resources which have
// been deposited in its care when it exists.
//
// If the window thread receives a WM_CLOSE message, it must
// first check to see that the unit test thread has completed.
// If not, it spins in a RETRY/CANCEL loop until the unit test
// thread has completed, or until the user selects CANCEL, at
// which point execution proceeds, ignoring the WM_CLOSE.
//
// "OVER-ENGINEERED, AND BUILT TO STAY THAT WAY" (tm)
//
#include "headers.hxx"
#pragma hdrstop
CCacheTestApp ctest; // Application instance
TestInstance inst; // Test instance
//
// Prototype for the entry-point of the unit test thread
//
unsigned long __stdcall testmain(void *);
//+---------------------------------------------------------------------------
//
// Function: WinMain
//
// Synopsis: windows entry point
//
// Arguments: [hInst] --
// [hPrevInst] --
// [lpszCmdLine] --
// [nCmdShow] --
//
// Returns: int
//
// History: 05-Sep-94 davepl Created
//
// Notes:
//
//----------------------------------------------------------------------------
int WINAPI WinMain (HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpszCmdLine, int nCmdShow)
{
MSG message;
//
// Initialize the application
//
if (SUCCEEDED(ctest.Initialize(hInst, hPrevInst, lpszCmdLine)))
{
//
// Show and update the window
//
ShowWindow(ctest.Window(), nCmdShow);
UpdateWindow(ctest.Window());
//
// The main message loop
//
while (GetMessage(&message, NULL, NULL, NULL))
{
TranslateMessage(&message);
DispatchMessage(&message);
}
}
else
{
return(0);
}
return(message.wParam);
}
//+---------------------------------------------------------------------------
//
// Member: CCacheTestApp::CCacheTestApp
//
// Synopsis: Constructor
//
// Arguments: (none)
//
// Returns: nothing
//
// History: 05-Sep-94 Davepl Created
//
// Notes:
//
//----------------------------------------------------------------------------
CCacheTestApp::CCacheTestApp ()
{
}
//+---------------------------------------------------------------------------
//
// Member: CCacheTestApp::Initialize
//
// Synopsis: initializes the application
//
// Arguments: [hInst] -- current instance
// [hPrevInst] -- previous instance
// [lpszCmdLine] -- command line parameters
//
// Returns: HRESULT
//
// History: 05-Sep-94 Davepl Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT CCacheTestApp::Initialize (HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpszCmdLine)
{
HRESULT hr = S_OK;
//
// Register the window class
//
if (hPrevInst == NULL)
{
WNDCLASS wndclass;
wndclass.style = 0;
wndclass.lpfnWndProc = CacheTestAppWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInst;
wndclass.hIcon = LoadIcon(hInst, IDI_EXCLAMATION);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = CTESTAPPCLASS;
if (RegisterClass(&wndclass) == 0)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
//
// Create the mutex
//
m_hMutex = CreateMutex(NULL, FALSE, NULL);
if (NULL == m_hMutex)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
//
// Create the window
//
if (SUCCEEDED(hr))
{
if ((m_hWnd = CreateWindowEx(0L,
CTESTAPPCLASS,
CTESTAPPTITLE,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
CW_USEDEFAULT,
0,
NULL,
NULL,
hInst,
NULL)) == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
return(hr);
}
//+---------------------------------------------------------------------------
//
// Member: CCacheTestApp::~CCacheTestApp
//
// Synopsis: Destructor
//
// Arguments: (none)
//
// Returns: nothing
//
// History: 05-Sep-94 Davepl Created
//
// Notes:
//
//----------------------------------------------------------------------------
CCacheTestApp::~CCacheTestApp ()
{
}
//+---------------------------------------------------------------------------
//
// Function: CacheTestAppWndProc
//
// Synopsis: window procedure
//
// Arguments: [hWnd] -- window
// [message] -- message id
// [wParam] -- parameter
// [lParam] -- parameter
//
// Returns: LRESULT
//
// History: 05-Sep-94 Davepl Created
//
// Notes:
//
//----------------------------------------------------------------------------
LRESULT FAR PASCAL CacheTestAppWndProc (HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
//
// Process the messages
//
switch (message)
{
case WM_CREATE:
//
// The unit test window is opening. Create another thread
// on which the unit test itself runs, while this thread
// continues to spin, waiting for redraws, close, and so
// on...
//
ctest.m_hTest = CreateThread(NULL,
0,
testmain,
NULL,
0,
&ctest.m_dwThreadID);
if (NULL == ctest.m_hTest)
{
mprintf("Unable to begin unit test\n");
PostQuitMessage(0);
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hDC;
//
// Get the DC for painting
//
hDC = BeginPaint(hWnd, &ps);
if (hDC)
{
//
// Draw the metafile
//
inst.Draw(hDC);
EndPaint(hWnd, &ps);
}
}
break;
case WM_SIZE:
//
// Invalidate the rectangle
//
InvalidateRect(hWnd, NULL, TRUE);
return DefWindowProc(hWnd, message, wParam, lParam);
break;
case WM_CLOSE:
{
//
// The user has tried to exit the main program. Before we
// can shut down, we must wait until the child thread has
// completed. We allow the user to keep retrying on the
// thread, or to "cancel" and wait until later. We do not
// provide the option of terminating the child thread while
// it is still busy.
//
DWORD dwStatus = 0;
if (FALSE == GetExitCodeThread(ctest.m_hTest, &dwStatus))
{
mprintf("Could not get thread information!");
break;
}
else
{
INT response = IDRETRY;
while (STILL_ACTIVE == dwStatus)
{
response = MessageBox(ctest.Window(),
"The child thread has not yet completed.",
"Cannot Shutdown",
MB_RETRYCANCEL);
if (IDCANCEL == response)
{
break;
}
}
}
//
// Destroy the window if the child has gone away
//
if (STILL_ACTIVE != dwStatus)
{
DestroyWindow(hWnd);
}
break;
}
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return NULL;
}
//+----------------------------------------------------------------------------
//
// Member:
//
// Synopsis:
//
// Arguments:
//
// Returns: HRESULT
//
// Notes:
//
// History: 23-Aug-94 Davepl Created
//
//-----------------------------------------------------------------------------
unsigned long __stdcall testmain(void *)
{
HRESULT hr;
hr = inst.CreateAndInit( OLESTR("mystg") );
if (S_OK != hr)
{
mprintf("Cache Unit Test Failed [CreateAndInit] hr = %x\n", hr);
goto exit;
}
hr = inst.EnumeratorTest();
if (S_OK != hr)
{
mprintf("Cache Unit Test Failed [EnumeratorTest] hr = %x\n", hr);
goto exit;
}
hr = inst.MultiCache(50);
if (S_OK != hr)
{
mprintf("Cache Unit Test Failed [MultiCache] hr = %x\n", hr);
goto exit;
}
hr = inst.CacheDataTest("TIGER.BMP", "TIGERNPH.WMF");
if (S_OK != hr)
{
mprintf("Cache Unit Test Failed [CacheDataTest] hr = %x\n", hr);
goto exit;
}
exit:
PostMessage(ctest.Window(), WM_CLOSE, (WPARAM) hr, 0);
return (ULONG) hr;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::TestInstance
//
// Synopsis: Constructor
//
// Arguments:
//
// Returns:
//
// Notes:
//
// History: 23-Aug-94 Davepl Created
//
//-----------------------------------------------------------------------------
TestInstance::TestInstance()
{
m_pStorage = NULL;
m_pPersistStorage = NULL;
m_pOleCache = NULL;
m_pOleCache2 = NULL;
m_pDataObject = NULL;
m_pViewObject = NULL;
m_State = TEST_STARTING;
}
TestInstance::~TestInstance()
{
//
// Release our interface pointers
//
if (m_pDataObject)
{
m_pDataObject->Release();
}
if (m_pViewObject)
{
m_pViewObject->Release();
}
if (m_pPersistStorage)
{
m_pPersistStorage->Release();
}
if (m_pOleCache2)
{
m_pOleCache2->Release();
}
if (m_pOleCache)
{
m_pOleCache->Release();
}
if (m_pStorage)
{
m_pStorage->Release();
}
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::CreateAndInit
//
// Synopsis: Creates a cache and sets up internal interface ptrs
//
// Arguments: (none)
//
// Returns: HRESULT
//
// Notes:
//
// History: 23-Aug-94 Davepl Created
//
//-----------------------------------------------------------------------------
HRESULT TestInstance::CreateAndInit(LPOLESTR lpwszStgName)
{
HRESULT hr;
TraceLog Log(this, "TestInstance::CreateAndInit", GS_CACHE, VB_MINIMAL);
Log.OnEntry (" ( %p ) \n", lpwszStgName);
Log.OnExit (" ( %X ) \n", &hr);
//
// Create the storage on which we will instantiate our cache
//
// BUGBUG use correct strcpy fn
wcscpy(m_wszStorage, lpwszStgName);
hr = StgCreateDocfile(lpwszStgName,
STGM_DIRECT |
STGM_READWRITE |
STGM_SHARE_EXCLUSIVE |
STGM_CREATE,
0,
&m_pStorage);
//
// Create a Data Cache on our IStorage
//
if (S_OK == hr)
{
hr = CreateDataCache(NULL,
CLSID_NULL,
IID_IPersistStorage,
(void **)&m_pPersistStorage);
}
if (S_OK == hr)
{
hr = m_pPersistStorage->InitNew(m_pStorage);
}
//
// Get an IOleCache interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IOleCache,
(void **) &m_pOleCache);
}
//
// Get an IOleCache2 interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IOleCache2,
(void **) &m_pOleCache2);
}
//
// Get an IViewObject interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IViewObject,
(void **) &m_pViewObject);
}
//
// Get an IDataObject interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IDataObject,
(void **) &m_pDataObject);
}
return hr;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::SaveAndReload
//
// Synopsis: Saves the cache to its storage and reloads it
// right back.
//
// Arguments: (none)
//
// Returns: HRESULT
//
// Notes: Once saved, the behavior of DiscardCache will
// change, since each node present at the time of
// save will have a stream from which it can demand
// load its data.
//
// Since each interface pointer is released and
// reaquired, the pointer values will (likely) change
// during this call; hence, so _not_ cache the pointers
// locally around this call.
//
// History: 23-Aug-94 Davepl Created
//
//-----------------------------------------------------------------------------
HRESULT TestInstance::SaveAndReload()
{
HRESULT hr;
TraceLog Log(NULL, "TestInstance::SaveAndReload", GS_CACHE, VB_MINIMAL);
Log.OnEntry ();
Log.OnExit (" ( %X )\n", &hr);
SetCurrentState(SAVE_AND_RELOAD);
hr = m_pPersistStorage->Save(m_pStorage, TRUE);
if (S_OK == hr)
{
hr = m_pPersistStorage->SaveCompleted(NULL);
}
// Release our hold on the storage and the cache
if (S_OK == hr)
{
m_pViewObject->Release();
m_pViewObject = NULL;
m_pDataObject->Release();
m_pDataObject = NULL;
m_pStorage->Release();
m_pStorage = NULL;
m_pPersistStorage->Release();
m_pPersistStorage = NULL;
m_pOleCache2->Release();
m_pOleCache2 = NULL;
m_pOleCache->Release();
m_pOleCache = NULL;
//
// Reload the cache and QI to get our interfaces back
//
hr = StgOpenStorage(m_wszStorage,
NULL,
STGM_DIRECT |
STGM_READWRITE |
STGM_SHARE_EXCLUSIVE,
NULL,
0,
&m_pStorage);
//
// Create a Data Cache on our IStorage
//
if (S_OK == hr)
{
hr = CreateDataCache(NULL,
CLSID_NULL,
IID_IPersistStorage,
(void **)&m_pPersistStorage);
}
if (S_OK == hr)
{
hr = m_pPersistStorage->Load(m_pStorage);
}
//
// Get an IOleCache interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IOleCache,
(void **) &m_pOleCache);
}
//
// Get an IOleCache2 interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IOleCache2,
(void **) &m_pOleCache2);
}
//
// Get an IViewObject interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IViewObject,
(void **) &m_pViewObject);
}
//
// Get an IDataObject interface pointer to the cache
//
if (S_OK == hr)
{
hr = m_pPersistStorage->QueryInterface(IID_IDataObject,
(void **) &m_pDataObject);
}
}
return hr;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::CacheDataTest
//
// Synopsis: Checks the cache for data integrity
//
// Arguments: lpszBMPFileName - Name of .BMP file to use for test
// lpszWMFFileName - Name of .WMF file to use for test
//
// Returns: HRESULT
//
// Notes:
//
// History: 04-Sep-94 Davepl Created
//
//-----------------------------------------------------------------------------
HRESULT TestInstance::CacheDataTest(char * lpszBMPFileName, char * lpszWMFFileName)
{
HRESULT hr = S_OK;
TraceLog Log(NULL, "TestInstance::CacheDataTest", GS_CACHE, VB_MINIMAL);
Log.OnEntry (" ( BMP=%s, WMF=%s )\n", lpszBMPFileName, lpszWMFFileName);
Log.OnExit (" ( %X )\n", &hr);
SetCurrentState(DATA_TEST);
CBitmapFile bmpFile;
HGLOBAL hDIB = NULL;
//
// Allocate an hglobal to hold our metafilepict structure
//
HGLOBAL hMFPICT = GlobalAlloc(GMEM_FIXED, sizeof(METAFILEPICT));
if (NULL == hMFPICT)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
METAFILEPICT * pMFPICT = (METAFILEPICT *) hMFPICT;
//
// Load the bitmap from disk
//
if (S_OK == hr)
{
hr = bmpFile.LoadBitmapFile(lpszBMPFileName);
}
//
// Create a DIB on an HGLOBAL from the bitmap
//
if (S_OK == hr)
{
hr = bmpFile.CreateDIBInHGlobal(&hDIB);
}
//
// Add DIB and MF nodes to the cache
//
DWORD dwDIBCon;
DWORD dwMFCon;
if (S_OK == hr)
{
hr = AddDIBCacheNode(&dwDIBCon);
}
if (S_OK == hr)
{
hr = AddMFCacheNode(&dwMFCon);
}
//
// Load the metafile from disk, then set up the
// METAFILEPICT structure
//
if (S_OK == hr)
{
pMFPICT->hMF = GetMetaFileA(lpszWMFFileName);
if (NULL == pMFPICT->hMF)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
//
// We deem the metafile to have the same extents
// as the the DIB. This is completely arbitrary,
// but might aid in tracking down extents problems.
// After all, we have to pick _some_ value, so it
// might as well be a useful one...
//
pMFPICT->xExt = ConvWidthInPelsToLHM(NULL, bmpFile.GetDIBHeight());
pMFPICT->yExt = ConvHeightInPelsToLHM(NULL, bmpFile.GetDIBWidth());
pMFPICT->mm = MM_ANISOTROPIC;
}
}
//
// Place the nodes in the cache. We keep ownership of the handles,
// which will force the cache to duplicate it. We can then compare
// our original with whatever we later get back from the cache.
//
FORMATETC fetcDIB =
{
CF_DIB,
NULL,
DVASPECT_CONTENT,
DEF_LINDEX,
TYMED_HGLOBAL
};
STGMEDIUM stgmDIB;
FORMATETC fetcMF =
{
CF_METAFILEPICT,
NULL,
DVASPECT_CONTENT,
DEF_LINDEX,
TYMED_MFPICT
};
STGMEDIUM stgmMF;
if (S_OK == hr)
{
stgmDIB.tymed = TYMED_HGLOBAL;
stgmDIB.hGlobal = hDIB;
hr = m_pOleCache->SetData(&fetcDIB, &stgmDIB, FALSE);
}
if (S_OK == hr)
{
stgmMF.tymed = TYMED_MFPICT,
stgmMF.hMetaFilePict = hMFPICT;
hr = m_pOleCache->SetData(&fetcMF, &stgmMF, FALSE);
}
//
// If we were able to place the data in the cache, check
// to make sure whatever is in the cache matches our
// original.
//
if (S_OK == hr)
{
hr = CompareDIB(hDIB);
if (S_OK == hr)
{
hr = CompareMF(hMFPICT);
}
}
//
// Save and Reload the cache to test persistance
//
if (S_OK == hr)
{
hr = SaveAndReload();
}
if (S_OK == hr)
{
SetCurrentState(DATA_TEST);
}
//
// Compare the data again
//
if (S_OK == hr)
{
hr = CompareDIB(hDIB);
if (S_OK == hr)
{
hr = CompareMF(hMFPICT);
}
}
//
// Discard the cache.
//
if (S_OK == hr)
{
hr = m_pOleCache2->DiscardCache(DISCARDCACHE_NOSAVE);
}
//
// Now compare again against the current presentations,
// which would have to be demand-loaded after the discard.
//
if (S_OK == hr)
{
hr = CompareDIB(hDIB);
if (S_OK == hr)
{
hr = CompareMF(hMFPICT);
}
}
//
// Try to draw the cache's best presentation (which should
// be metafile at this point) into a metafile DC which we
// will then hand off to the window thread for drawing.
//
if (S_OK == hr)
{
hr = DrawCacheToMetaFilePict(&ctest.m_hMFP, FALSE);
if (S_OK == hr)
{
SetCurrentState(DRAW_METAFILE_NOW);
}
}
//
// Now draw the metafile tiled 4 times into the display
// metafile, and hand it off...
//
if (S_OK == hr)
{
hr = DrawCacheToMetaFilePict(&ctest.m_hMFPTILED, TRUE);
if (S_OK == hr)
{
SetCurrentState(DRAW_METAFILETILED_NOW);
}
}
//
// Uncache the metafile node, which will leave the DIB node
// as the best (and only) node left for drawing
//
if (S_OK == hr)
{
hr = UncacheFormat(CF_METAFILEPICT);
}
//
// Now draw the DIB into a metafile and hand that off
// to the window thread for drawing
//
if (S_OK == hr)
{
hr = DrawCacheToMetaFilePict(&ctest.m_hMFPDIB, FALSE);
if (S_OK == hr)
{
SetCurrentState(DRAW_DIB_NOW);
}
}
//
// Now draw the DIB again, this time tiled into the mf
//
if (S_OK == hr)
{
hr = DrawCacheToMetaFilePict(&ctest.m_hMFPDIBTILED, TRUE);
if (S_OK == hr)
{
SetCurrentState(DRAW_DIBTILED_NOW);
}
}
//
// Cleanup our local DIB
//
if (hDIB)
{
GlobalFree(hDIB);
}
//
// Cleaup our local metafile
//
if (pMFPICT)
{
if (pMFPICT->hMF)
{
if (FALSE == DeleteMetaFile(pMFPICT->hMF))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
GlobalFree(hMFPICT);
}
return hr;
}
HRESULT TestInstance::CompareDIB(HGLOBAL hDIB)
{
return S_OK;
}
HRESULT TestInstance::CompareMF(HMETAFILEPICT hMFPICT)
{
return S_OK;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::DrawCacheToMetaFilePict
//
// Synopsis: Draws the cache's current best presentation to
// a metafile, contained in a metafilepict structure,
// which is allocated off of the hGlobal pointer passed
// in by the caller
//
// Arguments: [phGlobal] - The ptr to the hglobal to allocate on
// [fTile] - If true, the pres is tiled into the mf
//
// Returns: HRESULT
//
// Notes:
//
// History: 06-Sep-94 Davepl Created
//
//-----------------------------------------------------------------------------
HRESULT TestInstance::DrawCacheToMetaFilePict(HGLOBAL *phGlobal, BOOL fTile)
{
HRESULT hr = S_OK;
TraceLog Log(NULL, "TestInstance::DrawCacheToMetaFilePict", GS_CACHE, VB_MINIMAL);
Log.OnEntry (" ( %p, %d )\n", phGlobal, fTile);
Log.OnExit (" ( %X )\n", &hr);
//
// Create a metafile, and have the cache draw its metafile
// into _our_ metafile.
//
//
// First, set up the METAFILEPICT structure.
// Since ANISOTROPIC mode allows arbitrary scaling extents, we
// pick 1000 as a nice arbitrary size.
//
//
METAFILEPICT *pmfp = NULL;
if (S_OK == hr)
{
*phGlobal = GlobalAlloc(GMEM_FIXED, sizeof(METAFILEPICT));
if (NULL == *phGlobal)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
pmfp = (METAFILEPICT *) GlobalLock(*phGlobal);
if (NULL == pmfp)
{
GlobalFree(*phGlobal);
*phGlobal = NULL;
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
pmfp->xExt = 1000;
pmfp->yExt = 1000;
pmfp->mm = MM_ANISOTROPIC;
}
}
}
//
// Now create the metafile within the METAFILEPICT structure,
// and ask the cache to draw to it.
//
HDC mfdc;
if (S_OK == hr)
{
mfdc = CreateMetaFile(NULL);
if (NULL == mfdc)
{
hr = HRESULT_FROM_WIN32(GetLastError());
GlobalUnlock(*phGlobal);
GlobalFree(*phGlobal);
*phGlobal = NULL;
}
}
//
// If we are not tiling the metafile, we draw it exactly once,
// scaled to fit the entire output metafile
//
if (S_OK == hr && FALSE == fTile)
{
RECTL rcBounds = {0, 0, 1000, 1000};
RECTL rcWBounds = {0, 0, 1000, 1000};
SetMapMode(mfdc, MM_ANISOTROPIC);
SetWindowExtEx(mfdc, 1000, 1000, NULL);
SetWindowOrgEx(mfdc, 0, 0, NULL);
hr = m_pViewObject->Draw(DVASPECT_CONTENT, // Aspect
DEF_LINDEX, // LIndex
NULL, // pvAspect
NULL, // ptd
NULL, // hicTargetDev
mfdc, // hdc to draw to
&rcBounds, // rectange to draw to
&rcWBounds, // bounds of our mfdc
NULL, // callback fn
0); // continue param
}
//
// If we are tiling the metafile (which tests the ability of
// the cache to offset and scale the presentation to a rect within
// a larger metafile rect), we draw it once in each of the four
// corners
//
if (S_OK == hr && TRUE == fTile)
{
RECTL rcBounds;
RECTL rcWBounds = {0, 0, 1000, 1000};
SetMapMode(mfdc, MM_ANISOTROPIC);
SetWindowExtEx(mfdc, 1000, 1000, NULL);
SetWindowOrgEx(mfdc, 0, 0, NULL);
for (int a=0; a < 4 && S_OK == hr; a++)
{
switch(a)
{
case 0: // Upper left hand tile
rcBounds.left = 0;
rcBounds.top = 0;
rcBounds.right = 500;
rcBounds.bottom = 500;
break;
case 1: // Upper right hand tile
rcBounds.left = 500;
rcBounds.top = 0;
rcBounds.right = 1000;
rcBounds.bottom = 500;
break;
case 2: // Lower left hand tile
rcBounds.left = 0;
rcBounds.top = 500;
rcBounds.right = 500;
rcBounds.bottom = 1000;
break;
case 3: // Lower right hand tile
rcBounds.left = 500;
rcBounds.top = 500;
rcBounds.right = 1000;
rcBounds.bottom = 1000;
break;
}
hr = m_pViewObject->Draw(DVASPECT_CONTENT, // Aspect
DEF_LINDEX, // LIndex
NULL, // pvAspect
NULL, // ptd
NULL, // hicTargetDev
mfdc, // hdc to draw to
&rcBounds, // rectange to draw to
&rcWBounds, // bounds of our mfdc
NULL, // callback fn
0); // continue param
}
}
//
// If the draw failed, clean up the metafile DC now
//
if (S_OK != hr)
{
GlobalUnlock(*phGlobal);
GlobalFree(*phGlobal);
HMETAFILE temp = CloseMetaFile(mfdc);
if (temp)
{
DeleteMetaFile(temp);
}
}
//
// Finish up the metafile and prepare to return it to the caller
//
if (S_OK == hr)
{
pmfp->hMF = CloseMetaFile(mfdc);
if (pmfp->hMF)
{
GlobalUnlock(*phGlobal);
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
GlobalUnlock(*phGlobal);
GlobalFree(*phGlobal);
*phGlobal = NULL;
}
}
return hr;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::GetCurrentState
//
// Synopsis: Returns the state of the unit test (for drawing)
//
// Arguments: (none)
//
// Returns: HRESULT
//
// Notes:
//
// History: 04-Sep-94 Davepl Created
//
//-----------------------------------------------------------------------------
TEST_STATE TestInstance::GetCurrentState()
{
//
// In order to avoid race conditions, we have a mutex around the
// current state of the unit test (required because this member
// function will be running on the window's thread, not the current
// test instance thread.)
//
DWORD dwResult = WaitForSingleObject(ctest.Mutex(), INFINITE);
if (WAIT_FAILED == dwResult)
{
return INVALID_STATE;
}
TEST_STATE tsSnapshot = m_State;
ReleaseMutex(ctest.Mutex());
return tsSnapshot;
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::SetCurrentState
//
// Synopsis: Sets the current (drawing) state of the unit test
//
// Arguments: [state] - the state to set
//
// Returns: HRESULT
//
// Notes:
//
// History: 04-Sep-94 Davepl Created
//
//-----------------------------------------------------------------------------
void TestInstance::SetCurrentState(TEST_STATE state)
{
//
// In order to avoid race conditions, we have a mutex around the
// current state of the unit test (required because this member
// function will be running on the window's thread, not the current
// test instance thread.)
//
DWORD dwResult = WaitForSingleObject(ctest.Mutex(), INFINITE);
if (WAIT_FAILED == dwResult)
{
return;
}
m_State = state;
ReleaseMutex(ctest.Mutex());
//
// Invalid the main window so it will redraw itself with the new
// state of the test.
//
InvalidateRgn(ctest.Window(), NULL, FALSE);
UpdateWindow(ctest.Window());
}
//+----------------------------------------------------------------------------
//
// Member: TestInstance::Draw
//
// Synopsis: Draws the current state of the unit test
//
// Arguments: [hdc] - The DC to draw to
//
// Returns: HRESULT
//
// Notes: The DC is supplied, but the main window is assumed
//
// History: 04-Sep-94 Davepl Created
//
//-----------------------------------------------------------------------------
static char szStarting[] = "Test is starting...";
static char szInvalid[] = "The state of the test has become invalid...";
static char szEnumerator[] = "Testing the cache enumerator...";
static char szSaveReload[] = "Saving and reloading the cache and its data...";
static char szDataTest[] = "Testing data integrity within the cache...";
static char szMulti[] = "Testing a large number of simultaneous cache nodes...";
static char szMetafile[] = "MF -> MF";
static char szMetafileTiled[] = "MF -> MF (Tiled)";
static char szDib[] = ""; // Dib contains its own title
void TestInstance::Draw(HDC hdc)
{
//
// Retrieve the current state of the unit test
//
TEST_STATE tsState = GetCurrentState();
//
// Clear the window
//
RECT rect;
if (TRUE == GetClientRect(ctest.Window(), &rect))
{
FillRect(hdc, &rect, (HBRUSH) GetStockObject(LTGRAY_BRUSH));
}
//
// Draw the current state
//
int iBackMode = SetBkMode(hdc, TRANSPARENT);
switch(tsState)
{
case TEST_STARTING:
TextOut(hdc, 10, 10, szStarting, strlen(szStarting));
break;
case TESTING_ENUMERATOR:
TextOut(hdc, 10, 10, szEnumerator, strlen(szEnumerator));
break;
case SAVE_AND_RELOAD:
TextOut(hdc, 10, 10, szSaveReload, strlen(szSaveReload));
break;
case DATA_TEST:
TextOut(hdc, 10, 10, szDataTest, strlen(szDataTest));
break;
case MULTI_CACHE:
TextOut(hdc, 10, 10, szMulti, strlen(szMulti));
break;
case DRAW_METAFILE_NOW:
case DRAW_METAFILETILED_NOW:
case DRAW_DIB_NOW:
case DRAW_DIBTILED_NOW:
{
// We know now that we have to draw a metafile, so
// determine which of the metafiles we should be drawing,
// and set a handle (so we can reuse the draw code) and
// the description text appropriately.
HGLOBAL hMFP;
char * szDesc;
if (DRAW_METAFILE_NOW == tsState)
{
hMFP = ctest.m_hMFP;
szDesc = szMetafile;
}
else if (DRAW_METAFILETILED_NOW == tsState)
{
hMFP = ctest.m_hMFPTILED;
szDesc = szMetafileTiled;
}
else if (DRAW_DIB_NOW == tsState)
{
hMFP = ctest.m_hMFPDIB;
szDesc = szDib;
}
else if (DRAW_DIBTILED_NOW == tsState)
{
hMFP = ctest.m_hMFPDIBTILED;
szDesc = szDib;
}
TextOut(hdc, 10, 10, szDesc, strlen(szDesc));
//
// Now actually draw the metafile to our main window
//
if (hMFP)
{
METAFILEPICT *pMFP = (METAFILEPICT *) GlobalLock(hMFP);
if (NULL == pMFP)
{
mprintf("Unable to lock metafile handle");
break;
}
int save = SaveDC(hdc);
SetMapMode(hdc, pMFP->mm);
SetWindowExtEx(hdc, pMFP->xExt, pMFP->yExt, NULL);
RECT client;
GetClientRect(ctest.Window(), &client);
SetViewportExtEx(hdc, client.right, client.bottom, NULL);
SetWindowOrgEx(hdc, 0, 0, NULL);
SetViewportOrgEx(hdc, client.left, client.top, NULL);
PlayMetaFile(hdc, pMFP->hMF);
RestoreDC(hdc, save);
}
break;
}
case INVALID_STATE:
default:
TextOut(hdc, 10, 10, szInvalid, strlen(szInvalid));
break;
}
SetBkMode(hdc, iBackMode);
}