LINKSRC.CPP
/*
* LINKSRC.CPP
* Link Source Server Chapter 9
*
* Server of various objects that can be named with monikers.
*
* Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
*
* Kraig Brockschmidt, Microsoft
* Internet : kraigb@microsoft.com
* Compuserve: >INTERNET:kraigb@microsoft.com
*/
#define INITGUIDS
#include "linksrc.h"
//Count number of objects and number of locks.
ULONG g_cObj=0;
ULONG g_cLock=0;
BOOL g_fUser=FALSE;
//Make window handle global so other code can cause a shutdown
HWND g_hWnd=NULL;
/*
* WinMain
*
* Purpose:
* Main entry point of application.
*/
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hInstPrev
, LPSTR pszCmdLine, int nCmdShow)
{
MSG msg;
PAPP pApp;
SETMESSAGEQUEUE;
pApp=new CApp(hInst, hInstPrev, pszCmdLine, nCmdShow);
if (NULL==pApp)
return -1;
if (pApp->Init())
{
while (GetMessage(&msg, NULL, 0,0 ))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
delete pApp;
return msg.wParam;
}
/*
* KoalaWndProc
*
* Purpose:
* Standard window class procedure.
*/
LRESULT APIENTRY LinkSrcWndProc(HWND hWnd, UINT iMsg
, WPARAM wParam, LPARAM lParam)
{
PAPP pApp;
pApp=(PAPP)GetWindowLong(hWnd, LINKSRCWL_STRUCTURE);
switch (iMsg)
{
case WM_NCCREATE:
pApp=(PAPP)(((LPCREATESTRUCT)lParam)->lpCreateParams);
SetWindowLong(hWnd, LINKSRCWL_STRUCTURE, (LONG)pApp);
return (DefWindowProc(hWnd, iMsg, wParam, lParam));
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDM_FILECREATEGOOP:
pApp->CreateSampleFile(TEXT("goop.lks"));
break;
case IDM_FILEEXIT:
PostMessage(hWnd, WM_CLOSE, 0, 0L);
break;
default:
break;
}
break;
case WM_CLOSE:
//Don't close with object's active
if (0==g_cObj && 0==g_cLock)
return (DefWindowProc(hWnd, iMsg, wParam, lParam));
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return (DefWindowProc(hWnd, iMsg, wParam, lParam));
}
return 0L;
}
/*
* ObjectDestroyed
*
* Purpose:
* Function for the LinkSrc object to call when it gets destroyed.
* We destroy the main window if the proper conditions are met
* for shutdown.
*/
void ObjectDestroyed(void)
{
g_cObj--;
/*
* No more objects and no locks, and user is not in
* control (CApp::m_fEmbedding), then shut down.
*/
if (0L==g_cObj && 0L==g_cLock && IsWindow(g_hWnd)
&& !g_fUser)
PostMessage(g_hWnd, WM_CLOSE, 0, 0L);
return;
}
/*
* CApp::CApp
* CApp::~CApp
*
* Constructor Parameters:
* hInst HINSTANCE of the Application from WinMain
* hInstPrev HINSTANCE of a previous instance from WinMain
* pszCmdLine LPSTR of the command line.
* nCmdShow UINT specifying how to show the app window,
* from WinMain.
*/
CApp::CApp(HINSTANCE hInst, HINSTANCE hInstPrev
, LPSTR pszCmdLine, UINT nCmdShow)
{
//Initialize WinMain parameter holders.
m_hInst =hInst;
m_hInstPrev =hInstPrev;
m_pszCmdLine=pszCmdLine;
m_nCmdShow =nCmdShow;
m_hWnd=NULL;
m_dwRegCO=0;
m_pIClassFactory=NULL;
m_fInitialized=FALSE;
/*
* We can run stand-alone or at OLE's request, but we
* remain hidden if run from OLE.
*/
m_fEmbedding=TRUE;
return;
}
CApp::~CApp(void)
{
//Opposite of CoRegisterClassObject; class factory ref is now 1
if (0L!=m_dwRegCO)
CoRevokeClassObject(m_dwRegCO);
//The last Release, which frees the class factory.
if (NULL!=m_pIClassFactory)
m_pIClassFactory->Release();
if (m_fInitialized)
CoUninitialize();
return;
}
/*
* CApp::Init
*
* Purpose:
* Initializes an CApp object by registering window classes,
* creating the main window, and doing anything else prone to
* failure. If this function fails the caller should guarantee
* that the destructor is called.
*
* Parameters:
* None
*
* Return Value:
* BOOL TRUE if successful, FALSE otherwise.
*/
BOOL CApp::Init(void)
{
WNDCLASS wc;
HRESULT hr;
CHECKVER_COM;
//Check if we're run stand-alone
if (lstrcmpiA(m_pszCmdLine, "-Embedding")
&& lstrcmpiA(m_pszCmdLine, "/Embedding"))
{
m_fEmbedding=FALSE;
g_fUser=TRUE;
}
//Call CoInitialize so we can call other Co* functions
if (FAILED(CoInitialize(NULL)))
return FALSE;
m_fInitialized=TRUE;
if (!m_hInstPrev)
{
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = LinkSrcWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = CBWNDEXTRA;
wc.hInstance = m_hInst;
wc.hIcon = LoadIcon(m_hInst, TEXT("Icon"));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
wc.lpszClassName = TEXT("LinkSrc");
if (!RegisterClass(&wc))
return FALSE;
}
m_hWnd=CreateWindow(TEXT("LinkSrc"), TEXT("Link Source")
, WS_OVERLAPPEDWINDOW, 450, 35, 350, 250
, NULL, NULL, m_hInst, this);
if (NULL==m_hWnd)
return FALSE;
//Don't show the window outside of embedding
if (!m_fEmbedding)
{
ShowWindow(m_hWnd, SW_SHOW);
UpdateWindow(m_hWnd);
}
g_hWnd=m_hWnd;
/*
* We only server file objects through a CLSID. Other
* items are referenced through the File object.
*/
m_pIClassFactory=new CFileObjectFactory();
if (NULL==m_pIClassFactory)
return FALSE;
//Since we hold on to this, we should AddRef it.
m_pIClassFactory->AddRef();
hr=CoRegisterClassObject(CLSID_LinkedFile, m_pIClassFactory
, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &m_dwRegCO);
if (FAILED(hr))
return FALSE;
return TRUE;
}
/*
* CApp::CreateSampleFile
*
* Purpose:
* Creates a file with the structure we can use in binding
* monikers.
*
* Parameters:
* pszFile LPTSTR to the file name to create.
*
* Return Value:
* None
*/
void CApp::CreateSampleFile(LPTSTR pszFile)
{
HRESULT hr;
IStorage *pIStorage;
hr=StgCreateDocfile(pszFile, STGM_DIRECT | STGM_READWRITE
| STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &pIStorage);
if (SUCCEEDED(hr))
{
UINT i;
TCHAR szTemp[40];
TCHAR szDesc[256];
WriteDescription(pIStorage
, TEXT("This is a sample compound file from LinkSource that demonstrates binding to a file moniker."));
for (i=0; i < 4; i++)
{
wsprintf(szTemp, TEXT("Object %d"), i);
wsprintf(szDesc
, TEXT("This is the first-level item named %s in the file.")
, szTemp);
hr=CreateStore(pIStorage, szTemp, szDesc, 5);
if (FAILED(hr))
break;
}
}
pIStorage->SetClass(CLSID_LinkedFile);
pIStorage->Release();
if (FAILED(hr))
{
MessageBox(m_hWnd, TEXT("File creation failed.")
, TEXT("Link Source"), MB_OK);
}
else
{
MessageBox(m_hWnd, TEXT("File created successfully.")
, TEXT("Link Source"), MB_OK);
}
return;
}
/*
* CApp::CreateStore
*
* Purpose:
* Creates a sub-storage below pIStorage with the given name and
* writes a description stream using the stringtable string idsDesc.
*
* Parameters:
* pIStorage IStorage * in which to create the storage.
* pszName LPTSTR naming the storage to create.
* pszDesc LPTSTR holding the description.
* cSubs UINT number of sub-storages to create in this one
*
* Return Value:
* HRESULT Result of the operation.
*/
HRESULT CApp::CreateStore(IStorage *pIStorage, LPTSTR pszName
, LPTSTR pszDesc, UINT cSubs)
{
HRESULT hr;
IStorage *pSub;
TCHAR szTemp[40];
TCHAR szDesc[256];
UINT i;
#ifdef WIN32ANSI
OLECHAR szUNI[40];
MultiByteToWideChar(CP_ACP, 0, pszName, -1, szUNI, 40);
hr=pIStorage->CreateStorage(szUNI, STGM_DIRECT
| STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pSub);
#else
hr=pIStorage->CreateStorage(pszName, STGM_DIRECT
| STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pSub);
#endif
if (FAILED(hr))
return hr;
hr=WriteDescription(pSub, pszDesc);
if (cSubs > 255)
cSubs=255;
/*
* If cSubs is zero we'll pass to the return statement
* which allows recursion in the loop below for 2nd level storages.
*/
for (i=0; i < cSubs; i++)
{
wsprintf(szTemp, TEXT("Sub-Object %d"), i);
wsprintf(szDesc
, TEXT("This is the second-level item named %s inside the item named %s in the file.")
, szTemp, pszName);
hr=CreateStore(pSub, szTemp, szDesc, 0);
if (FAILED(hr))
break;
}
pSub->Release();
return hr;
}
/*
* CApp::WriteDescription
*
* Purpose:
* Creates a stream with the name SZDESCRIPTION in the given
* storage and writes into that stream the string identified
* by idsDesc that exists in the stringtable.
*
* Parameters:
* pIStorage IStorage * in which to create the stream.
* pszDesc LPTSTR describing the storage.
*
* Return Value:
* HRESULT NOERROR or an error code.
*/
HRESULT CApp::WriteDescription(IStorage *pIStorage, LPTSTR pszDesc)
{
HRESULT hr;
IStream *pIStream;
hr=pIStorage->CreateStream(SZDESCRIPTION, STGM_DIRECT
| STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pIStream);
if (FAILED(hr))
return hr;
hr=pIStream->Write(pszDesc
, (lstrlen(pszDesc)+1)*sizeof(TCHAR), NULL);
pIStream->Release();
return hr;
}
/*
* CFileObjectFactory::CFileObjectFactory
* CFileObjectFactory::~CFileObjectFactory
* CFileObjectFactory::QueryInterface
* CFileObjectFactory::AddRef
* CFileObjectFactory::Release
*
* Basic class factory members
*/
CFileObjectFactory::CFileObjectFactory(void)
{
m_cRef=0L;
return;
}
CFileObjectFactory::~CFileObjectFactory(void)
{
return;
}
STDMETHODIMP CFileObjectFactory::QueryInterface(REFIID riid
, PPVOID ppv)
{
*ppv=NULL;
if (IID_IUnknown==riid || IID_IClassFactory==riid)
*ppv=this;
if (NULL!=*ppv)
{
((LPUNKNOWN)*ppv)->AddRef();
return NOERROR;
}
return ResultFromScode(E_NOINTERFACE);
}
STDMETHODIMP_(ULONG) CFileObjectFactory::AddRef(void)
{
return ++m_cRef;
}
STDMETHODIMP_(ULONG) CFileObjectFactory::Release(void)
{
if (0L!=--m_cRef)
return m_cRef;
delete this;
return 0;
}
/*
* CFileObjectFactory::CreateInstance
*
* Purpose:
* Instantiates a LinkSrc object returning an interface pointer.
*
* Parameters:
* pUnkOuter LPUNKNOWN to the controlling IUnknown if we are
* being used in an aggregation.
* riid REFIID identifying the interface the caller
* desires to have for the new object.
* ppvObj PPVOID in which to store the desired
* interface pointer for the new object.
*
* Return Value:
* HRESULT NOERROR if successful, otherwise E_NOINTERFACE
* if we cannot support the requested interface.
*/
STDMETHODIMP CFileObjectFactory::CreateInstance(LPUNKNOWN pUnkOuter
, REFIID riid, PPVOID ppvObj)
{
PCFileObject pObj;
HRESULT hr;
*ppvObj=NULL;
hr=ResultFromScode(E_OUTOFMEMORY);
if (NULL!=pUnkOuter && IID_IUnknown!=riid)
return ResultFromScode(CLASS_E_NOAGGREGATION);
pObj=new CFileObject(pUnkOuter, ObjectDestroyed);
if (NULL==pObj)
{
//This starts shutdown if there are no other objects.
g_cObj++;
ObjectDestroyed();
return hr;
}
if (pObj->Init())
hr=pObj->QueryInterface(riid, ppvObj);
g_cObj++;
if (FAILED(hr))
{
delete pObj;
ObjectDestroyed(); //Handle shutdown cases.
}
return hr;
}
/*
* CFileObjectFactory::LockServer
*
* Purpose:
* Increments or decrements the lock count of the serving
* IClassFactory object. When the number of locks goes to
* zero and the number of objects is zero, we shut down the
* application.
*
* Parameters:
* fLock BOOL specifying whether to increment or
* decrement the lock count.
*
* Return Value:
* HRESULT NOERROR always.
*/
STDMETHODIMP CFileObjectFactory::LockServer(BOOL fLock)
{
if (fLock)
g_cLock++;
else
{
g_cLock--;
g_cObj++;
ObjectDestroyed();
}
return NOERROR;
}