mirror of https://github.com/tongzx/nt5src
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.
1032 lines
36 KiB
1032 lines
36 KiB
/*
|
|
* clidemo.c - OLE client application sample code
|
|
*
|
|
* Created by Microsoft Corporation.
|
|
* (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved
|
|
*
|
|
*/
|
|
|
|
/***************************************************************************
|
|
* IMPORTANT - README:
|
|
* OLE client applications are windows programs which use the OLE client
|
|
* APIs. Therefore it is imperative that you understand how these APIs
|
|
* operate. Most importantly it is essential that you keep in mind which
|
|
* procedure calls result in asynchronous states: a state where the operation
|
|
* is not truely complete after a return from the call.
|
|
*
|
|
* Many functions produce asynchronous states, for example, OleActivate,
|
|
* OleClose, OleCopyFromLink, OleCreate ... Reference your SDK manual for
|
|
* a complete list.
|
|
*
|
|
* So whenever you call any of these library functions keep in mind that
|
|
* the operation is not necessarily complete once a return is made.
|
|
* These operations require communications with a server application. With
|
|
* OLE the inter-application communication is done through DDE. In order
|
|
* for a DDE conversation to complete several DDE messages need to be
|
|
* sent and recieved by both the server and client OLE DLLs. So, the
|
|
* asynchronous operations will not complete until the client application
|
|
* enters a message dipatch loop. Therefore, it is necessary to enter
|
|
* a dispatch loop and wait for completion. It is not necessary to block
|
|
* all other operation; however, it is very important to coordinate the
|
|
* user activity to prevent disastrous re-entry cases.
|
|
*
|
|
* In this application I have written a macro to prevent re-entry
|
|
* problems. Namely: ANY_OBJECT_BUSY which prevents a user from initiating
|
|
* an action which will result in an asynchronous call if there is an object
|
|
* already in an asynchronous state.
|
|
*
|
|
* The following is brief summary of the three macros:
|
|
*
|
|
* ANY_OBJECT_BUSY: checks to see if any object in the document is busy.
|
|
* This prevents a new document from being saved to file if there are
|
|
* objects in asynchronous states.
|
|
*
|
|
* So, the problem is that we have to enter a message dispatch loop in order
|
|
* to let DDE messages get through so that asynchronous operations can finish.
|
|
* And while we are in the message dispatch loops (WaitForObject or WaitForAllObjects)
|
|
* we have to prevent the user from doing things that can't be done when an
|
|
* object(s) is busy. Yes, it is confusing , but, the end result is a super
|
|
* cool application that can have linked and embbeded objects!
|
|
***************************************************************************/
|
|
|
|
//*** INCLUDES ***
|
|
|
|
#include <windows.h> //* WINDOWS
|
|
#include <ole.h> //* OLE structs and defines
|
|
#include <shellapi.h> //* Shell, drag and drop headers
|
|
|
|
#include "demorc.h" //* header for resource file
|
|
#include "global.h" //* global app variables
|
|
#include "clidemo.h" //* app includes:
|
|
#include "register.h"
|
|
#include "stream.h"
|
|
#include "object.h"
|
|
#include "dialog.h"
|
|
#include "utility.h"
|
|
|
|
//*** VARIABLES ***
|
|
|
|
//** Global
|
|
HANDLE hInst;
|
|
BOOL fRetry = FALSE;
|
|
HWND hwndFrame; //* main window
|
|
HANDLE hAccTable; //* accelerator table
|
|
CHAR szFrameClass[] = "CliDemo";//* main window class name
|
|
CHAR szItemClass[] = "ItemClass";//* item window class name
|
|
CHAR szAppName[CBMESSAGEMAX];//* Application name
|
|
INT iObjects = 0; //* object count
|
|
INT iObjectNumber = 0; //* object number for object name
|
|
CHAR szFileName[CBPATHMAX];
|
|
|
|
extern INT giXppli ;
|
|
extern INT giYppli ;
|
|
//* ClipBoard formats:
|
|
OLECLIPFORMAT vcfLink; //* "ObjectLink"
|
|
OLECLIPFORMAT vcfNative; //* "Native"
|
|
OLECLIPFORMAT vcfOwnerLink; //* "OwnerLink"
|
|
|
|
|
|
/***************************************************************************
|
|
* WinMain() - Main Windows routine
|
|
***************************************************************************/
|
|
int APIENTRY WinMain(
|
|
HINSTANCE hInstance,
|
|
HINSTANCE hPrevInst,
|
|
LPSTR lpCmdLine,
|
|
INT nCmdLine
|
|
){
|
|
hInst = hInstance;
|
|
|
|
if (!InitApplication(hInst)) //* register window classes
|
|
return FALSE;
|
|
|
|
if (!InitInstance(hInst)) //* create window instance
|
|
return FALSE;
|
|
|
|
OfnInit(hInst); //* setup to use <commdlg.dll>
|
|
|
|
//* register clipboard formats
|
|
//* used for OLE
|
|
vcfLink = (OLECLIPFORMAT)RegisterClipboardFormat("ObjectLink");
|
|
vcfNative = (OLECLIPFORMAT)RegisterClipboardFormat("Native");
|
|
vcfOwnerLink = (OLECLIPFORMAT)RegisterClipboardFormat("OwnerLink");
|
|
|
|
|
|
ShowWindow(hwndFrame, SW_SHOWNORMAL);
|
|
UpdateWindow(hwndFrame);
|
|
ProcessCmdLine(lpCmdLine);
|
|
|
|
while (ProcessMessage(hwndFrame, hAccTable)) ;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/***************************************************************************
|
|
* InitApplication()
|
|
*
|
|
* registers the window classes used by the application.
|
|
*
|
|
* Returns BOOL: - TRUE if successful.
|
|
***************************************************************************/
|
|
|
|
static BOOL InitApplication( //* ENTRY:
|
|
HANDLE hInst //* instance handle
|
|
){ //* LOCAL:
|
|
WNDCLASS wc; //* temp wind-class structure
|
|
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = (WNDPROC)FrameWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInst;
|
|
wc.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(ID_APPLICATION));
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
|
|
wc.lpszMenuName = MAKEINTRESOURCE(ID_APPLICATION);
|
|
wc.lpszClassName = szFrameClass;
|
|
|
|
if (!RegisterClass(&wc))
|
|
return FALSE;
|
|
//* application item class
|
|
wc.style = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
|
|
wc.lpfnWndProc = (WNDPROC)ItemWndProc;
|
|
wc.hIcon = NULL;
|
|
wc.cbWndExtra = sizeof(APPITEMPTR);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = szItemClass;
|
|
|
|
if (!RegisterClass(&wc))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* InitInstance()
|
|
*
|
|
* create the main application window.
|
|
*
|
|
* Returns BOOL: - TRUE if successful else FALSE.
|
|
***************************************************************************/
|
|
|
|
static BOOL InitInstance( //* ENTRY:
|
|
HANDLE hInst //* instance handel
|
|
){
|
|
HDC hDC ;
|
|
|
|
hAccTable = LoadAccelerators(hInst, MAKEINTRESOURCE(ID_APPLICATION));
|
|
|
|
if (!(hwndFrame =
|
|
CreateWindow(
|
|
szFrameClass, "",
|
|
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
NULL,
|
|
NULL,
|
|
hInst,
|
|
NULL
|
|
)))
|
|
return FALSE; //* ERROR return
|
|
|
|
LoadString(hInst, IDS_APPNAME, szAppName, CBMESSAGEMAX);
|
|
DragAcceptFiles(hwndFrame, TRUE); //* allow dragged and dropped files
|
|
|
|
hDC = GetDC (NULL); // Get the hDC of the desktop window
|
|
giXppli = GetDeviceCaps (hDC, LOGPIXELSX);
|
|
giYppli = GetDeviceCaps (hDC, LOGPIXELSY);
|
|
ReleaseDC (NULL, hDC);
|
|
|
|
|
|
|
|
return TRUE; //* SUCCESS return
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* ProcessCmdLine()
|
|
*
|
|
* process command line getting any command arguments.
|
|
***************************************************************************/
|
|
|
|
VOID ProcessCmdLine(LPSTR lpCmdLine)
|
|
{ //* LOCAL:
|
|
OFSTRUCT ofs;
|
|
|
|
|
|
if (*lpCmdLine)
|
|
{ //* look for file extension
|
|
LPSTR lpstrExt = lpCmdLine; //* pointer to file extension
|
|
|
|
while (*lpstrExt && *lpstrExt != '.')
|
|
lpstrExt = AnsiNext(lpstrExt);
|
|
|
|
lstrcpy(szFileName, lpCmdLine);
|
|
if (!(*lpstrExt)) //* append default extension
|
|
{
|
|
lstrcat(szFileName,".");
|
|
lstrcat(szFileName,szDefExtension);
|
|
}
|
|
//* get the files fully
|
|
OpenFile(szFileName, &ofs, OF_PARSE);//* qualified name
|
|
lstrcpy(szFileName, ofs.szPathName);
|
|
}
|
|
else
|
|
*szFileName = 0;
|
|
//* pass filename to main winproc
|
|
SendMessage(hwndFrame,WM_INIT,(WPARAM)0,(LPARAM)0);
|
|
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
* FrameWndProc()
|
|
*
|
|
* Message handler for the application frame window.
|
|
*
|
|
* Returns long - Variable, depends on message.
|
|
***************************************************************************/
|
|
|
|
LONG APIENTRY FrameWndProc( //* ENTRY:
|
|
HWND hwnd, //* standard wind-proc parameters
|
|
UINT msg,
|
|
DWORD wParam,
|
|
LONG lParam
|
|
){ //* LOCAL:
|
|
//* ^ Document file name
|
|
static LHCLIENTDOC lhcDoc; //* Document Handle
|
|
static LPOLECLIENT lpClient; //* pointer to client
|
|
static LPAPPSTREAM lpStream; //* pointer to stream vtbl
|
|
APPITEMPTR pItem; //* application item pointer
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INIT: //* user defined message
|
|
if (!InitAsOleClient(hInst, hwnd, szFileName, &lhcDoc, &lpClient, &lpStream))
|
|
DestroyWindow(hwnd);
|
|
break;
|
|
//* the following three messages are
|
|
//* used to avoid problems with OLE
|
|
//* see the comment in object.h
|
|
case WM_DELETE: //* user defined message
|
|
pItem = (APPITEMPTR) lParam; //* delete object
|
|
WaitForObject(pItem);
|
|
ObjDelete(pItem,OLE_OBJ_DELETE);
|
|
if (wParam)
|
|
cOleWait--;
|
|
break;
|
|
|
|
case WM_ERROR: //* user defined message
|
|
ErrorMessage(wParam); //* display error message
|
|
break;
|
|
|
|
case WM_RETRY: //* user defined message
|
|
RetryMessage((APPITEMPTR)lParam, RD_RETRY | RD_CANCEL);
|
|
break;
|
|
|
|
case WM_INITMENU:
|
|
UpdateMenu((HMENU)wParam);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
WORD wID = LOWORD(wParam);
|
|
|
|
pItem = GetTopItem();
|
|
|
|
switch (wID)
|
|
{
|
|
case IDM_NEW:
|
|
ANY_OBJECT_BUSY;
|
|
NewFile(szFileName,&lhcDoc,lpStream);
|
|
break;
|
|
|
|
case IDM_OPEN:
|
|
ANY_OBJECT_BUSY;
|
|
MyOpenFile(szFileName,&lhcDoc,lpClient,lpStream);
|
|
break;
|
|
|
|
case IDM_SAVE:
|
|
ANY_OBJECT_BUSY;
|
|
SaveFile(szFileName,lhcDoc,lpStream);
|
|
break;
|
|
|
|
case IDM_SAVEAS:
|
|
ANY_OBJECT_BUSY;
|
|
SaveasFile(szFileName,lhcDoc,lpStream);
|
|
break;
|
|
|
|
case IDM_ABOUT:
|
|
AboutBox();
|
|
break;
|
|
|
|
case IDM_INSERT:
|
|
ANY_OBJECT_BUSY;
|
|
ObjInsert(lhcDoc, lpClient);
|
|
break;
|
|
|
|
case IDM_INSERTFILE:
|
|
ANY_OBJECT_BUSY;
|
|
ObjCreateFromTemplate(lhcDoc,lpClient);
|
|
break;
|
|
|
|
case IDM_PASTE:
|
|
case IDM_PASTELINK:
|
|
ANY_OBJECT_BUSY;
|
|
ObjPaste(wID == IDM_PASTE,lhcDoc,lpClient);
|
|
break;
|
|
|
|
case IDM_LINKS:
|
|
ANY_OBJECT_BUSY;
|
|
pItem = GetTopItem();
|
|
LinkProperties();
|
|
break;
|
|
|
|
case IDM_EXIT:
|
|
ANY_OBJECT_BUSY;
|
|
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
|
|
break;
|
|
|
|
case IDM_COPY:
|
|
case IDM_CUT:
|
|
ANY_OBJECT_BUSY;
|
|
|
|
if (!ObjCopy(pItem))
|
|
{
|
|
ErrorMessage((wParam == IDM_CUT) ?
|
|
E_CLIPBOARD_CUT_FAILED : E_CLIPBOARD_COPY_FAILED);
|
|
break;
|
|
}
|
|
|
|
if (wParam == IDM_COPY)
|
|
break;
|
|
|
|
case IDM_CLEAR: //* CUT falls through to clear
|
|
ANY_OBJECT_BUSY;
|
|
ClearItem(pItem);
|
|
break;
|
|
|
|
case IDM_CLEARALL:
|
|
ANY_OBJECT_BUSY;
|
|
ClearAll(lhcDoc,OLE_OBJ_DELETE);
|
|
Dirty(DOC_DIRTY);
|
|
break;
|
|
|
|
default:
|
|
if( (wParam >= IDM_VERBMIN) && (wParam <= IDM_VERBMAX) )
|
|
{
|
|
ANY_OBJECT_BUSY;
|
|
ExecuteVerb(wParam - IDM_VERBMIN,pItem);
|
|
break;
|
|
}
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_DROPFILES:
|
|
ANY_OBJECT_BUSY;
|
|
ObjCreateWrap((HANDLE)wParam, lhcDoc, lpClient);
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
ANY_OBJECT_BUSY;
|
|
if (!SaveAsNeeded(szFileName, lhcDoc, lpStream))
|
|
break;
|
|
DeregDoc(lhcDoc);
|
|
DestroyWindow(hwnd);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
EndStream(lpStream);
|
|
EndClient(lpClient);
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
case WM_QUERYENDSESSION: //* don't let windows terminate
|
|
return (QueryEndSession(szFileName,lhcDoc, lpStream));
|
|
|
|
default:
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
return 0L;
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* InitAsOleClient()
|
|
*
|
|
* Initiates the creation of stream and client vtbls. These vtbls are very
|
|
* important for the proper operation of this application. The stream vtbl
|
|
* lets the OLE librarys know where the location of the stream I/O routines
|
|
* reside. The stream routines are used by OleLoadFromStream and the like.
|
|
* The client vtbl is used to hold the pointer to the CallBack function.
|
|
* IMPORTANT: both the client and the stream structures have pointers to
|
|
* vtbls which have the pointers to the functions. Therefore, it is
|
|
* necessary to allocate space for the vtbl and the client structure
|
|
* which has the pointer to the vtbl.
|
|
**************************************************************************/
|
|
|
|
static BOOL InitAsOleClient( //* ENTRY:
|
|
HANDLE hInstance, //* applicaion instance handle
|
|
HWND hwnd, //* main window handle
|
|
PSTR pFileName, //* document file name
|
|
LHCLIENTDOC *lhcDoc, //* pointer to document Handle
|
|
LPOLECLIENT *lpClient, //* pointer to client pointer
|
|
LPAPPSTREAM *lpStream //* pointer to APPSTREAM pointer
|
|
){
|
|
//* initiate client vtbl creation
|
|
if (!(*lpClient = InitClient(hInstance)))
|
|
{
|
|
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
//* initiate stream vtbl creation
|
|
if (!(*lpStream = InitStream(hInstance)))
|
|
{
|
|
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
|
|
if (*pFileName && RegDoc(pFileName,lhcDoc)
|
|
&& LoadFile(pFileName,*lhcDoc,*lpClient,*lpStream))
|
|
{
|
|
SetTitle(pFileName);
|
|
return TRUE; //* SUCCESS return
|
|
}
|
|
|
|
NewFile(pFileName, lhcDoc, *lpStream);
|
|
return TRUE; //* SUCCESS return
|
|
|
|
} //* SUCCESS return
|
|
|
|
/****************************************************************************
|
|
* InitClient()
|
|
*
|
|
* Initialize the OLE client structure, create and fill the OLECLIENTVTBL
|
|
* structure.
|
|
*
|
|
* Returns LPOLECLIENT - if successful a pointer to a client structure
|
|
* , otherwise NULL.
|
|
***************************************************************************/
|
|
|
|
static LPOLECLIENT InitClient( //* ENTRY:
|
|
HANDLE hInstance //* application instance handle
|
|
){ //* LOCAL:
|
|
LPOLECLIENT lpClient=NULL; //* pointer to client struct
|
|
//* Allocate vtbls
|
|
if (!(lpClient = (LPOLECLIENT)GlobalLock(
|
|
GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLECLIENT))
|
|
)))
|
|
goto Error; //* ERROR jump
|
|
|
|
if (!(lpClient->lpvtbl = (LPOLECLIENTVTBL)GlobalLock(
|
|
GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLECLIENTVTBL))
|
|
)))
|
|
goto Error; //* ERROR jump
|
|
//* set the CALLBACK function
|
|
//* pointer
|
|
lpClient->lpvtbl->CallBack = CallBack;
|
|
|
|
return lpClient; //* SUCCESS return
|
|
|
|
Error: //* ERROR Tag
|
|
|
|
ErrorMessage(E_FAILED_TO_ALLOC);
|
|
EndClient(lpClient); //* free any allocated space
|
|
|
|
return NULL; //* ERROR return
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* InitStream()
|
|
*
|
|
* Create and fill the STREAMVTBL. Create a stream structure and initialize
|
|
* pointer to stream vtbl.
|
|
*
|
|
* Returns LPAPPSTREAM - if successful a pointer to a stream structure
|
|
* , otherwise NULL .
|
|
***************************************************************************/
|
|
|
|
static LPAPPSTREAM InitStream( //* ENTRY:
|
|
HANDLE hInstance //* handle to application instance
|
|
){ //* LOCAL:
|
|
LPAPPSTREAM lpStream = NULL; //* pointer to stream structure
|
|
|
|
if (!(lpStream = (LPAPPSTREAM)GlobalLock(
|
|
GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(APPSTREAM))
|
|
)))
|
|
goto Error; //* ERROR jump
|
|
|
|
if (!(lpStream->olestream.lpstbl = (LPOLESTREAMVTBL)GlobalLock(
|
|
GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLESTREAMVTBL))
|
|
)))
|
|
goto Error; //* ERROR jump
|
|
|
|
//* set stream func. pointers
|
|
lpStream->olestream.lpstbl->Get = (DWORD ( CALLBACK *)(LPOLESTREAM, VOID FAR *, DWORD)) ReadStream;
|
|
lpStream->olestream.lpstbl->Put = (DWORD ( CALLBACK *)(LPOLESTREAM, OLE_CONST VOID FAR *, DWORD)) WriteStream;
|
|
|
|
return lpStream; //* SUCCESS return
|
|
|
|
Error: //* ERROR Tag
|
|
|
|
ErrorMessage(E_FAILED_TO_ALLOC);
|
|
EndStream(lpStream);
|
|
|
|
return NULL; //* ERROR return
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* UpdateMenu()
|
|
*
|
|
* Enabling or disable menuitems based upon program state.
|
|
***************************************************************************/
|
|
|
|
static VOID UpdateMenu( //* ENTRY:
|
|
HMENU hMenu //* menu handle to updated
|
|
){ //* LOCAL:
|
|
INT mf; //* generic menu flag
|
|
APPITEMPTR paItem; //* app item pointer
|
|
HMENU hSub;
|
|
//* there must be at least on object
|
|
//* for the following to be enabled
|
|
|
|
paItem = GetTopItem() ;
|
|
|
|
mf = (paItem ? MF_ENABLED : MF_GRAYED);
|
|
EnableMenuItem(hMenu, IDM_CUT, mf); //* i.e. Cut,Copy,Clear,Clearall...
|
|
EnableMenuItem(hMenu, IDM_COPY, mf);
|
|
EnableMenuItem(hMenu, IDM_CLEAR, mf);
|
|
EnableMenuItem(hMenu, IDM_CLEARALL, mf);
|
|
//* enable links option only if there
|
|
//* is at least one linked object
|
|
EnableMenuItem(hMenu, IDM_LINKS, MF_GRAYED);
|
|
for (; paItem; paItem = GetNextItem(paItem))
|
|
{
|
|
if (paItem->otObject == OT_LINK)
|
|
{
|
|
EnableMenuItem(hMenu, IDM_LINKS, MF_ENABLED);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hSub = GetSubMenu(hMenu,POS_EDITMENU))
|
|
UpdateObjectMenuItem(hSub);
|
|
|
|
if (OleQueryCreateFromClip(STDFILEEDITING, olerender_draw, 0) == OLE_OK)
|
|
EnableMenuItem(hMenu, IDM_PASTE, MF_ENABLED);
|
|
else if (OleQueryCreateFromClip(STATICP, olerender_draw, 0) == OLE_OK)
|
|
EnableMenuItem(hMenu, IDM_PASTE, MF_ENABLED);
|
|
else
|
|
EnableMenuItem(hMenu, IDM_PASTE, MF_GRAYED);
|
|
|
|
if (OleQueryLinkFromClip(STDFILEEDITING, olerender_draw, 0) == OLE_OK)
|
|
EnableMenuItem(hMenu, IDM_PASTELINK, MF_ENABLED);
|
|
else
|
|
EnableMenuItem(hMenu, IDM_PASTELINK, MF_GRAYED);
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* NewFile()
|
|
*
|
|
* Save the present document and open a new blank one.
|
|
***************************************************************************/
|
|
|
|
static VOID NewFile( //* ENTRY:
|
|
PSTR pFileName, //* open file name
|
|
LHCLIENTDOC *lhcptrDoc, //* pointer to client doc. handle
|
|
LPAPPSTREAM lpStream //* pointer to stream structure
|
|
){ //* LOCAL:
|
|
static CHAR szUntitled[CBMESSAGEMAX] = "";//* "(Untitled)" string
|
|
LHCLIENTDOC lhcDocNew; //* handle for new doc.
|
|
|
|
if (!(*szUntitled))
|
|
LoadString(hInst, IDS_UNTITLED, (LPSTR)szUntitled, CBMESSAGEMAX);
|
|
|
|
if (SaveAsNeeded(pFileName, *lhcptrDoc, lpStream))
|
|
{ //* try to register new document
|
|
if (!RegDoc(szUntitled, &lhcDocNew))
|
|
return; //* before deregistring the old one
|
|
DeregDoc(*lhcptrDoc);
|
|
*lhcptrDoc = lhcDocNew;
|
|
Dirty(DOC_CLEAN); //* new document is clean
|
|
lstrcpy(pFileName,szUntitled);
|
|
SetTitle(pFileName);
|
|
iObjectNumber = 0;
|
|
}
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* MyOpenFile()
|
|
*
|
|
* Open a file and load it. Notice that the new file is loaded before
|
|
* the old is removed. This is done to assure a succesful file load
|
|
* before removing an existing document.
|
|
***************************************************************************/
|
|
|
|
static VOID MyOpenFile( //* ENTRY:
|
|
PSTR pFileName, //* open file name
|
|
LHCLIENTDOC *lhcptrDoc, //* pointer to document handle
|
|
LPOLECLIENT lpClient, //* pointer to client structure
|
|
LPAPPSTREAM lpStream //* pointer to stream structure
|
|
){ //* LOCAL:
|
|
CHAR szNewFile[CBPATHMAX];//* new file name buffer
|
|
LHCLIENTDOC lhcDocNew; //* handle of new document
|
|
APPITEMPTR pItem; //* hold top item
|
|
|
|
if (SaveAsNeeded(pFileName, *lhcptrDoc, lpStream))
|
|
{
|
|
*szNewFile = 0;
|
|
|
|
if (!OfnGetName(hwndFrame, szNewFile, IDM_OPEN))
|
|
return; //* ERROR return
|
|
|
|
if (!RegDoc(szNewFile,&lhcDocNew))
|
|
return; //* ERROR return
|
|
|
|
pItem = GetTopItem();
|
|
ShowDoc(*lhcptrDoc,0); //* make old doc objects hidden.
|
|
//* try to load the new file before
|
|
if (!LoadFile(szNewFile, lhcDocNew, lpClient, lpStream))
|
|
{ //* before removing the old.
|
|
DeregDoc(lhcDocNew); //* restore old document if new
|
|
SetTopItem(pItem); //* file did not load
|
|
ShowDoc(*lhcptrDoc,1);
|
|
return; //* ERROR return
|
|
}
|
|
|
|
DeregDoc(*lhcptrDoc); //* deregister old document
|
|
*lhcptrDoc = lhcDocNew;
|
|
lstrcpy(pFileName,szNewFile);
|
|
SetTitle(pFileName); //* set new title
|
|
Dirty(DOC_CLEAN);
|
|
}
|
|
|
|
} //* SUCCESS return
|
|
|
|
/***************************************************************************
|
|
* SaveasFile()
|
|
*
|
|
* Prompt the user for a new file name. Write the document to the new
|
|
* filename.
|
|
***************************************************************************/
|
|
|
|
static VOID SaveasFile( //* ENTRY:
|
|
PSTR pFileName, //* old filename
|
|
LHCLIENTDOC lhcDoc, //* document handle
|
|
LPAPPSTREAM lpStream //* pointer to stream structure
|
|
){
|
|
CHAR szNewFile[CBPATHMAX];//* new file name
|
|
|
|
*szNewFile = 0; //* prompt user for new file name
|
|
if (!OfnGetName(hwndFrame, szNewFile, IDM_SAVEAS))
|
|
return; //* ERROR return
|
|
//* rename document
|
|
if (!SaveFile(szNewFile, lhcDoc, lpStream))
|
|
return;
|
|
|
|
if (Error(OleRenameClientDoc(lhcDoc, szNewFile)))
|
|
{
|
|
ErrorMessage(W_FAILED_TO_NOTIFY);
|
|
return; //* ERROR return
|
|
}
|
|
|
|
lstrcpy(pFileName,szNewFile);
|
|
SetTitle(pFileName);
|
|
|
|
} //* SUCCESS return
|
|
|
|
/***************************************************************************
|
|
* SaveFile()
|
|
*
|
|
* Save a compound document file. If the file is untitled, ask the user
|
|
* for a name and save the document to that file.
|
|
***************************************************************************/
|
|
|
|
static BOOL SaveFile( //* ENTRY:
|
|
PSTR pFileName, //* file to save document to
|
|
LHCLIENTDOC lhcDoc, //* OLE document handle
|
|
LPAPPSTREAM lpStream //* pointer to app. stream struct
|
|
){ //* LOCAL:
|
|
CHAR szNewFile[CBPATHMAX];//* New file name strings
|
|
CHAR szOemFileName[2*CBPATHMAX];
|
|
static CHAR szUntitled[CBMESSAGEMAX] = "";
|
|
int fh; //* file handle
|
|
|
|
*szNewFile = 0;
|
|
if (!(*szUntitled))
|
|
LoadString(hInst, IDS_UNTITLED, (LPSTR)szUntitled, CBMESSAGEMAX);
|
|
|
|
if (!lstrcmp(szUntitled, pFileName))//* get filename for the untitled case
|
|
{
|
|
if (!OfnGetName(hwndFrame, szNewFile, IDM_SAVEAS))
|
|
return FALSE; //* CANCEL return
|
|
lstrcpy(pFileName,szNewFile);
|
|
SetTitle(pFileName);
|
|
}
|
|
|
|
AnsiToOem(pFileName, szOemFileName);
|
|
if ((fh = _lcreat((LPSTR)szOemFileName, 0)) <= 0)
|
|
{
|
|
ErrorMessage(E_INVALID_FILENAME);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
|
|
lpStream->fh = fh;
|
|
//* save file on disk
|
|
if (!WriteToFile(lpStream))
|
|
{
|
|
_lclose(fh);
|
|
ErrorMessage(E_FAILED_TO_SAVE_FILE);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
_lclose(fh);
|
|
|
|
if (Error(OleSavedClientDoc(lhcDoc)))
|
|
{
|
|
ErrorMessage(W_FAILED_TO_NOTIFY);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
|
|
Dirty(DOC_CLEAN);
|
|
return TRUE; //* SUCCESS return
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* LoadFile()
|
|
*
|
|
* Load a document file from disk.
|
|
***************************************************************************/
|
|
|
|
static BOOL LoadFile( //* ENTRY:
|
|
PSTR pFileName, //* file name
|
|
LHCLIENTDOC lhcDoc, //* document handle
|
|
LPOLECLIENT lpClient, //* pointer to client structure
|
|
LPAPPSTREAM lpStream //* pointer to stream structure
|
|
){ //* LOCAL:
|
|
//* OEM file name
|
|
CHAR szOemFileName[2*CBPATHMAX];
|
|
int fh; //* file handle
|
|
INT iObjectNumberHold; //* hold object number
|
|
|
|
AnsiToOem(pFileName, szOemFileName);
|
|
if ((fh = _lopen(szOemFileName, OF_READ | OF_SHARE_DENY_WRITE)) == -1)
|
|
{
|
|
ErrorMessage(E_FAILED_TO_READ_FILE);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
|
|
lpStream->fh = fh;
|
|
|
|
iObjectNumberHold = iObjectNumber; //* save object number so it can
|
|
iObjectNumber = 0; //* be restored if read from file
|
|
//* fails
|
|
if (!ReadFromFile(lpStream, lhcDoc, lpClient))
|
|
{
|
|
_lclose(fh);
|
|
ErrorMessage(E_FAILED_TO_READ_FILE);
|
|
iObjectNumber = iObjectNumberHold;
|
|
return FALSE; //* ERROR return
|
|
}
|
|
_lclose(fh);
|
|
return TRUE; //* SUCCESS return
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* RegDoc()
|
|
*
|
|
* Register the client document with the OLE library.
|
|
**************************************************************************/
|
|
|
|
static BOOL RegDoc( //* ENTRY:
|
|
PSTR pFileName, //* file name
|
|
LHCLIENTDOC *lhcptrDoc //* pointer to client document handle
|
|
){
|
|
|
|
if (Error(OleRegisterClientDoc(szAppName, (LPSTR)pFileName, 0L, lhcptrDoc)))
|
|
{
|
|
ErrorMessage(W_FAILED_TO_NOTIFY);
|
|
return FALSE; //* ERROR return
|
|
}
|
|
return TRUE; //* SUCCESS return
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* DeregDoc()
|
|
*
|
|
* This function initiates the removal of all OLE objects from the
|
|
* current document and deregisters the document with the OLE library.
|
|
***************************************************************************/
|
|
|
|
static VOID DeregDoc( //* ENTRY:
|
|
LHCLIENTDOC lhcDoc //* client document handle
|
|
){
|
|
|
|
if (lhcDoc)
|
|
{ //* release all OLE objects
|
|
ClearAll(lhcDoc,OLE_OBJ_RELEASE); //* and remove them from the screen
|
|
WaitForAllObjects();
|
|
if (Error(OleRevokeClientDoc(lhcDoc)))
|
|
ErrorMessage(W_FAILED_TO_NOTIFY);
|
|
}
|
|
|
|
} //* SUCCESS return
|
|
|
|
/***************************************************************************
|
|
* ClearAll()
|
|
*
|
|
* This function will destroy all of the item windows in the current
|
|
* document and delete all OLE objects. The loop is basically an enum
|
|
* of all child windows.
|
|
**************************************************************************/
|
|
|
|
static VOID ClearAll( //* ENTRY:
|
|
LHCLIENTDOC lhcDoc, //* application document handle
|
|
BOOL fDelete //* Delete / Release
|
|
){ //* LOCAL:
|
|
APPITEMPTR pItemNext; //* working handles
|
|
APPITEMPTR pItem; //* pointer to application item
|
|
|
|
pItem = GetTopItem();
|
|
|
|
while (pItem)
|
|
{
|
|
pItemNext = GetNextItem(pItem);
|
|
if (pItem->lhcDoc == lhcDoc)
|
|
ObjDelete(pItem, fDelete);
|
|
pItem = pItemNext;
|
|
}
|
|
|
|
}
|
|
//* SUCCESS return
|
|
/***************************************************************************
|
|
* ClearItem()
|
|
*
|
|
* This function will destroy an item window, and make the
|
|
* next window active.
|
|
**************************************************************************/
|
|
|
|
VOID FAR ClearItem( //* ENTRY:
|
|
APPITEMPTR pItem //* application item pointer
|
|
){
|
|
|
|
pItem->fVisible = FALSE;
|
|
SetTopItem(GetNextActiveItem());
|
|
ObjDelete(pItem, OLE_OBJ_DELETE);
|
|
Dirty(DOC_DIRTY);
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* SaveAsNeeded()
|
|
*
|
|
* This function will have the file saved if and only
|
|
* if the document has been modified. If the fDirty flag has
|
|
* been set to TRUE, then the document needs to be saved.
|
|
*
|
|
* Returns: BOOL - TRUE if document doesn't need saving or if the
|
|
* document has been saved successfully.
|
|
***************************************************************************/
|
|
|
|
static BOOL SaveAsNeeded( //* ENTRY:
|
|
PSTR pFileName, //* file to save
|
|
LHCLIENTDOC lhcDoc, //* OLE doc handle
|
|
LPAPPSTREAM lpStream //* pointer to OLE stream vtbl ...
|
|
){ //* LOCAL:
|
|
CHAR sz[CBMESSAGEMAX]; //* work strings
|
|
CHAR sz2[CBMESSAGEMAX + CBPATHMAX];
|
|
|
|
if (Dirty(DOC_QUERY)) //* if doc is clean don't bother
|
|
{
|
|
|
|
LoadString(hInst, IDS_MAYBESAVE, sz, CBMESSAGEMAX);
|
|
wsprintf(sz2, sz, (LPSTR)pFileName );
|
|
|
|
switch (MessageBox(hwndFrame, sz2, szAppName, MB_YESNOCANCEL | MB_ICONQUESTION))
|
|
{
|
|
|
|
case IDCANCEL:
|
|
return FALSE; //* CANCEL return
|
|
|
|
case IDYES:
|
|
return (SaveFile(pFileName,lhcDoc,lpStream));
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return TRUE; //* SUCCESS return
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* SetTitle()
|
|
*
|
|
* Set the window caption to the current file name. If szFileName is
|
|
* NULL, the caption will be set to "(Untitled)".
|
|
***************************************************************************/
|
|
|
|
static VOID SetTitle( //* ENTRY:
|
|
PSTR pFileName //* file name
|
|
){ //* LOCAL
|
|
//* window title string
|
|
CHAR szTitle[CBMESSAGEMAX + CBPATHMAX];
|
|
|
|
wsprintf(szTitle, "%s - %s", (LPSTR)szAppName, (LPSTR)pFileName);
|
|
SetWindowText(hwndFrame, szTitle);
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
* EndClient()
|
|
*
|
|
* Perform cleanup prior to app termination. The OLECLIENT
|
|
* memory blocks and procedure instance thunks freed.
|
|
**************************************************************************/
|
|
|
|
static VOID EndStream( //* ENTRY:
|
|
LPAPPSTREAM lpStream //* pointer to stream structure
|
|
){ //* LOCAL:
|
|
HANDLE hGeneric; //* temp handle
|
|
|
|
if (lpStream) //* is there a STREAM struct?
|
|
{
|
|
if (lpStream->olestream.lpstbl)
|
|
{
|
|
FreeProcInstance((FARPROC)lpStream->olestream.lpstbl->Get);
|
|
FreeProcInstance((FARPROC)lpStream->olestream.lpstbl->Put);
|
|
hGeneric = GlobalHandle((LPSTR)lpStream->olestream.lpstbl);
|
|
GlobalUnlock(hGeneric);
|
|
GlobalFree(hGeneric);
|
|
}
|
|
hGeneric = GlobalHandle((LPSTR)lpStream);
|
|
GlobalUnlock(hGeneric);
|
|
GlobalFree(hGeneric);
|
|
}
|
|
|
|
} //* SUCCESS return
|
|
|
|
/***************************************************************************
|
|
* EndClient()
|
|
*
|
|
* Perform cleanup prior to app termination. The OLECLIENT
|
|
* memory blocks and procedure instance thunks are freed.
|
|
**************************************************************************/
|
|
|
|
static VOID EndClient( //* ENTRY:
|
|
LPOLECLIENT lpClient //* pointer to client structure
|
|
){ //* LOCAL:
|
|
HANDLE hGeneric; //* temp handle
|
|
|
|
if (lpClient) //* is there a client structure
|
|
{
|
|
if (lpClient->lpvtbl)
|
|
{
|
|
FreeProcInstance(lpClient->lpvtbl->CallBack);
|
|
hGeneric = GlobalHandle((LPSTR)lpClient->lpvtbl);
|
|
GlobalUnlock(hGeneric);
|
|
GlobalFree(hGeneric);
|
|
}
|
|
hGeneric = GlobalHandle((LPSTR)lpClient);
|
|
GlobalUnlock(hGeneric);
|
|
GlobalFree(hGeneric);
|
|
}
|
|
|
|
} //* SUCCESS return
|
|
|
|
/****************************************************************************
|
|
* QueryEndSession()
|
|
***************************************************************************/
|
|
|
|
static LONG QueryEndSession( //* ENTRY:
|
|
PSTR pFileName, //* document name
|
|
LHCLIENTDOC lhcDoc, //* client document handle
|
|
LPAPPSTREAM lpStream //* application stream pointer
|
|
){ //* LOCAL:
|
|
APPITEMPTR pItem; //* application item pointer
|
|
|
|
|
|
for (pItem = GetTopItem(); pItem; pItem = GetNextItem(pItem))
|
|
if (OleQueryOpen(pItem->lpObject) == OLE_OK)
|
|
{
|
|
MessageBox(hwndFrame,"Exit CliDemo before closing Windows",
|
|
szAppName, MB_OK | MB_ICONSTOP);
|
|
return 0L;
|
|
}
|
|
|
|
if (!SaveAsNeeded(pFileName, lhcDoc, lpStream))
|
|
return 0L;
|
|
DeregDoc(lhcDoc);
|
|
return 1L;
|
|
|
|
}
|
|
|