![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clidemo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ole / clidemo|
Return to clidemo.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ole / clidemo |
1.1 root 1: /*
2: * clidemo.c - OLE client application sample code
3: *
4: * Created by Microsoft Corporation.
5: * (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved
6: *
7: */
8:
9: /***************************************************************************
10: * IMPORTANT - README:
11: * OLE client applications are windows programs which use the OLE client
12: * APIs. Therefore it is imperative that you understand how these APIs
13: * operate. Most importantly it is essential that you keep in mind which
14: * procedure calls result in asynchronous states: a state where the operation
15: * is not truely complete after a return from the call.
16: *
17: * Many functions produce asynchronous states, for example, OleActivate,
18: * OleClose, OleCopyFromLink, OleCreate ... Reference your SDK manual for
19: * a complete list.
20: *
21: * So whenever you call any of these library functions keep in mind that
22: * the operation is not necessarily complete once a return is made.
23: * These operations require communications with a server application. With
24: * OLE the inter-application communication is done through DDE. In order
25: * for a DDE conversation to complete several DDE messages need to be
26: * sent and recieved by both the server and client OLE DLLs. So, the
27: * asynchronous operations will not complete until the client application
28: * enters a message dipatch loop. Therefore, it is necessary to enter
29: * a dispatch loop and wait for completion. It is not necessary to block
30: * all other operation; however, it is very important to coordinate the
31: * user activity to prevent disastrous re-entry cases.
32: *
33: * In this application I have written a macro to prevent re-entry
34: * problems. Namely: ANY_OBJECT_BUSY which prevents a user from initiating
35: * an action which will result in an asynchronous call if there is an object
36: * already in an asynchronous state.
37: *
38: * The following is brief summary of the three macros:
39: *
40: * ANY_OBJECT_BUSY: checks to see if any object in the document is busy.
41: * This prevents a new document from being saved to file if there are
42: * objects in asynchronous states.
43: *
44: * So, the problem is that we have to enter a message dispatch loop in order
45: * to let DDE messages get through so that asynchronous operations can finish.
46: * And while we are in the message dispatch loops (WaitForObject or WaitForAllObjects)
47: * we have to prevent the user from doing things that can't be done when an
48: * object(s) is busy. Yes, it is confusing , but, the end result is a super
49: * cool application that can have linked and embbeded objects!
50: ***************************************************************************/
51:
52: //*** INCLUDES ***
53:
54: #include <windows.h> //* WINDOWS
55: #include <ole.h> //* OLE structs and defines
56: #include <shellapi.h> //* Shell, drag and drop headers
57:
58: #include "demorc.h" //* header for resource file
59: #include "global.h" //* global app variables
60: #include "clidemo.h" //* app includes:
61: #include "register.h"
62: #include "stream.h"
63: #include "object.h"
64: #include "dialog.h"
65: #include "utility.h"
66:
67: //*** VARIABLES ***
68:
69: //** Global
70: HANDLE hInst;
71: BOOL fRetry = FALSE;
72: HWND hwndFrame; //* main window
73: HANDLE hAccTable; //* accelerator table
74: CHAR szFrameClass[] = "CliDemo";//* main window class name
75: CHAR szItemClass[] = "ItemClass";//* item window class name
76: CHAR szAppName[CBMESSAGEMAX];//* Application name
77: INT iObjects = 0; //* object count
78: INT iObjectNumber = 0; //* object number for object name
79: CHAR szFileName[CBPATHMAX];
80: //* ClipBoard formats:
81: OLECLIPFORMAT vcfLink; //* "ObjectLink"
82: OLECLIPFORMAT vcfNative; //* "Native"
83: OLECLIPFORMAT vcfOwnerLink; //* "OwnerLink"
84:
85:
86: /***************************************************************************
87: * WinMain() - Main Windows routine
88: ***************************************************************************/
89:
90: int WinMain(
91: HANDLE hInstance,
92: HANDLE hPrevInst,
93: LPSTR lpCmdLine,
94: INT nCmdLine
95: ){
96: hInst = hInstance;
97:
98: if (!InitApplication(hInst)) //* register window classes
99: return FALSE;
100:
101: if (!InitInstance(hInst)) //* create window instance
102: return FALSE;
103:
104: OfnInit(hInst); //* setup to use <commdlg.dll>
105:
106: //* register clipboard formats
107: //* used for OLE
108: vcfLink = RegisterClipboardFormat("ObjectLink");
109: vcfNative = RegisterClipboardFormat("Native");
110: vcfOwnerLink = RegisterClipboardFormat("OwnerLink");
111:
112:
113: ShowWindow(hwndFrame, SW_SHOWNORMAL);
114: UpdateWindow(hwndFrame);
115: ProcessCmdLine(lpCmdLine);
116:
117: while (ProcessMessage(hwndFrame, hAccTable)) ;
118:
119: return FALSE;
120: }
121:
122: /***************************************************************************
123: * InitApplication()
124: *
125: * registers the window classes used by the application.
126: *
127: * Returns BOOL: - TRUE if successful.
128: ***************************************************************************/
129:
130: static BOOL InitApplication( //* ENTRY:
131: HANDLE hInst //* instance handle
132: ){ //* LOCAL:
133: WNDCLASS wc; //* temp wind-class structure
134:
135: wc.style = NULL;
136: wc.lpfnWndProc = (WNDPROC)FrameWndProc;
137: wc.cbClsExtra = 0;
138: wc.cbWndExtra = 0;
139: wc.hInstance = hInst;
140: wc.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(ID_APPLICATION));
141: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
142: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
143: wc.lpszMenuName = MAKEINTRESOURCE(ID_APPLICATION);
144: wc.lpszClassName = szFrameClass;
145:
146: if (!RegisterClass(&wc))
147: return FALSE;
148: //* application item class
149: wc.style = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
150: wc.lpfnWndProc = (WNDPROC)ItemWndProc;
151: wc.hIcon = NULL;
152: wc.cbWndExtra = sizeof(APPITEMPTR);
153: wc.lpszMenuName = NULL;
154: wc.lpszClassName = szItemClass;
155:
156: if (!RegisterClass(&wc))
157: return FALSE;
158:
159: return TRUE;
160:
161: }
162:
163: /***************************************************************************
164: * InitInstance()
165: *
166: * create the main application window.
167: *
168: * Returns BOOL: - TRUE if successful else FALSE.
169: ***************************************************************************/
170:
171: static BOOL InitInstance( //* ENTRY:
172: HANDLE hInst //* instance handel
173: ){
174:
175: hAccTable = LoadAccelerators(hInst, MAKEINTRESOURCE(ID_APPLICATION));
176:
177: if (!(hwndFrame =
178: CreateWindow(
179: szFrameClass, "",
180: WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
181: CW_USEDEFAULT, CW_USEDEFAULT,
182: CW_USEDEFAULT, CW_USEDEFAULT,
183: NULL,
184: NULL,
185: hInst,
186: NULL
187: )))
188: return FALSE; //* ERROR return
189:
190: LoadString(hInst, IDS_APPNAME, szAppName, CBMESSAGEMAX);
191: DragAcceptFiles(hwndFrame, TRUE); //* allow dragged and dropped files
192:
193:
194: return TRUE; //* SUCCESS return
195:
196: }
197:
198: /***************************************************************************
199: * ProcessCmdLine()
200: *
201: * process command line getting any command arguments.
202: ***************************************************************************/
203:
204: VOID ProcessCmdLine(LPSTR lpCmdLine)
205: { //* LOCAL:
206: OFSTRUCT ofs;
207:
208:
209: if (*lpCmdLine)
210: { //* look for file extension
211: LPSTR lpstrExt = lpCmdLine; //* pointer to file extension
212:
213: while (*lpstrExt && *lpstrExt != '.')
214: lpstrExt = AnsiNext(lpstrExt);
215:
216: lstrcpy(szFileName, lpCmdLine);
217: if (!(*lpstrExt)) //* append default extension
218: {
219: lstrcat(szFileName,".");
220: lstrcat(szFileName,szDefExtension);
221: }
222: //* get the files fully
223: OpenFile(szFileName, &ofs, OF_PARSE);//* qualified name
224: lstrcpy(szFileName, ofs.szPathName);
225: }
226: else
227: *szFileName = NULL;
228: //* pass filename to main winproc
229: SendMessage(hwndFrame,WM_INIT,NULL,(LONG)NULL);
230:
231: }
232:
233:
234: /***************************************************************************
235: * FrameWndProc()
236: *
237: * Message handler for the application frame window.
238: *
239: * Returns long - Variable, depends on message.
240: ***************************************************************************/
241:
242: LONG APIENTRY FrameWndProc( //* ENTRY:
243: HWND hwnd, //* standard wind-proc parameters
244: UINT msg,
245: DWORD wParam,
246: LONG lParam
247: ){ //* LOCAL:
248: //* ^ Document file name
249: static LHCLIENTDOC lhcDoc; //* Document Handle
250: static LPOLECLIENT lpClient; //* pointer to client
251: static LPAPPSTREAM lpStream; //* pointer to stream vtbl
252: APPITEMPTR pItem; //* application item pointer
253:
254: switch (msg)
255: {
256: case WM_INIT: //* user defined message
257: if (!InitAsOleClient(hInst, hwnd, szFileName, &lhcDoc, &lpClient, &lpStream))
258: DestroyWindow(hwnd);
259: break;
260: //* the following three messages are
261: //* used to avoid problems with OLE
262: //* see the comment in object.h
263: case WM_DELETE: //* user defined message
264: pItem = (APPITEMPTR) wParam; //* delete object
265: WaitForObject(pItem);
266: ObjDelete(pItem,OLE_OBJ_DELETE);
267: if (lParam)
268: cOleWait--;
269: break;
270:
271: case WM_ERROR: //* user defined message
272: ErrorMessage(wParam); //* display error message
273: break;
274:
275: case WM_RETRY: //* user defined message
276: RetryMessage((APPITEMPTR)wParam, RD_RETRY | RD_CANCEL);
277: break;
278:
279: case WM_INITMENU:
280: UpdateMenu((HMENU)wParam);
281: break;
282:
283: case WM_COMMAND:
284: {
285: WORD wID = LOWORD(wParam);
286:
287: pItem = GetTopItem();
288:
289: switch (wID)
290: {
291: case IDM_NEW:
292: ANY_OBJECT_BUSY;
293: NewFile(szFileName,&lhcDoc,lpStream);
294: break;
295:
296: case IDM_OPEN:
297: ANY_OBJECT_BUSY;
298: MyOpenFile(szFileName,&lhcDoc,lpClient,lpStream);
299: break;
300:
301: case IDM_SAVE:
302: ANY_OBJECT_BUSY;
303: SaveFile(szFileName,lhcDoc,lpStream);
304: break;
305:
306: case IDM_SAVEAS:
307: ANY_OBJECT_BUSY;
308: SaveasFile(szFileName,lhcDoc,lpStream);
309: break;
310:
311: case IDM_ABOUT:
312: AboutBox();
313: break;
314:
315: case IDM_INSERT:
316: ANY_OBJECT_BUSY;
317: ObjInsert(lhcDoc, lpClient);
318: break;
319:
320: case IDM_INSERTFILE:
321: ANY_OBJECT_BUSY;
322: ObjCreateFromTemplate(lhcDoc,lpClient);
323: break;
324:
325: case IDM_PASTE:
326: case IDM_PASTELINK:
327: ANY_OBJECT_BUSY;
328: ObjPaste(wID == IDM_PASTE,lhcDoc,lpClient);
329: break;
330:
331: case IDM_LINKS:
332: ANY_OBJECT_BUSY;
333: pItem = GetTopItem();
334: LinkProperties();
335: break;
336:
337: case IDM_EXIT:
338: ANY_OBJECT_BUSY;
339: SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
340: break;
341:
342: case IDM_COPY:
343: case IDM_CUT:
344: ANY_OBJECT_BUSY;
345:
346: if (!ObjCopy(pItem))
347: {
348: ErrorMessage((wParam == IDM_CUT) ?
349: E_CLIPBOARD_CUT_FAILED : E_CLIPBOARD_COPY_FAILED);
350: break;
351: }
352:
353: if (wParam == IDM_COPY)
354: break;
355:
356: case IDM_CLEAR: //* CUT falls through to clear
357: ANY_OBJECT_BUSY;
358: ClearItem(pItem);
359: break;
360:
361: case IDM_CLEARALL:
362: ANY_OBJECT_BUSY;
363: ClearAll(lhcDoc,OLE_OBJ_DELETE);
364: Dirty(DOC_DIRTY);
365: break;
366:
367: default:
368: if( (wParam >= IDM_VERBMIN) && (wParam <= IDM_VERBMAX) )
369: {
370: ANY_OBJECT_BUSY;
371: ExecuteVerb(wParam - IDM_VERBMIN,pItem);
372: break;
373: }
374: return DefWindowProc(hwnd, msg, wParam, lParam);
375: }
376: break;
377: }
378:
379: case WM_DROPFILES:
380: ANY_OBJECT_BUSY;
381: ObjCreateWrap((HANDLE)wParam, lhcDoc, lpClient);
382: break;
383:
384: case WM_CLOSE:
385: ANY_OBJECT_BUSY;
386: if (!SaveAsNeeded(szFileName, lhcDoc, lpStream))
387: break;
388: DeregDoc(lhcDoc);
389: DestroyWindow(hwnd);
390: break;
391:
392: case WM_DESTROY:
393: EndStream(lpStream);
394: EndClient(lpClient);
395: PostQuitMessage(0);
396: break;
397:
398: case WM_QUERYENDSESSION: //* don't let windows terminate
399: return (QueryEndSession(szFileName,lhcDoc, lpStream));
400:
401: default:
402: return DefWindowProc(hwnd, msg, wParam, lParam);
403: }
404: return 0L;
405:
406: }
407:
408: /***************************************************************************
409: * InitAsOleClient()
410: *
411: * Initiates the creation of stream and client vtbls. These vtbls are very
412: * important for the proper operation of this application. The stream vtbl
413: * lets the OLE librarys know where the location of the stream I/O routines
414: * reside. The stream routines are used by OleLoadFromStream and the like.
415: * The client vtbl is used to hold the pointer to the CallBack function.
416: * IMPORTANT: both the client and the stream structures have pointers to
417: * vtbls which have the pointers to the functions. Therefore, it is
418: * necessary to allocate space for the vtbl and the client structure
419: * which has the pointer to the vtbl.
420: **************************************************************************/
421:
422: static BOOL InitAsOleClient( //* ENTRY:
423: HANDLE hInstance, //* applicaion instance handle
424: HWND hwnd, //* main window handle
425: PSTR pFileName, //* document file name
426: LHCLIENTDOC *lhcDoc, //* pointer to document Handle
427: LPOLECLIENT *lpClient, //* pointer to client pointer
428: LPAPPSTREAM *lpStream //* pointer to APPSTREAM pointer
429: ){
430: //* initiate client vtbl creation
431: if (!(*lpClient = InitClient(hInstance)))
432: {
433: SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
434: return FALSE; //* ERROR return
435: }
436: //* initiate stream vtbl creation
437: if (!(*lpStream = InitStream(hInstance)))
438: {
439: SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
440: return FALSE; //* ERROR return
441: }
442:
443: if (*pFileName && RegDoc(pFileName,lhcDoc)
444: && LoadFile(pFileName,*lhcDoc,*lpClient,*lpStream))
445: {
446: SetTitle(pFileName);
447: return TRUE; //* SUCCESS return
448: }
449:
450: NewFile(pFileName, lhcDoc, *lpStream);
451: return TRUE; //* SUCCESS return
452:
453: } //* SUCCESS return
454:
455: /****************************************************************************
456: * InitClient()
457: *
458: * Initialize the OLE client structure, create and fill the OLECLIENTVTBL
459: * structure.
460: *
461: * Returns LPOLECLIENT - if successful a pointer to a client structure
462: * , otherwise NULL.
463: ***************************************************************************/
464:
465: static LPOLECLIENT InitClient( //* ENTRY:
466: HANDLE hInstance //* application instance handle
467: ){ //* LOCAL:
468: LPOLECLIENT lpClient=NULL; //* pointer to client struct
469: //* Allocate vtbls
470: if (!(lpClient = (LPOLECLIENT)GlobalLock(
471: GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLECLIENT))
472: )))
473: goto Error; //* ERROR jump
474:
475: if (!(lpClient->lpvtbl = (LPOLECLIENTVTBL)GlobalLock(
476: GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLECLIENTVTBL))
477: )))
478: goto Error; //* ERROR jump
479: //* set the CALLBACK function
480: //* pointer
481: lpClient->lpvtbl->CallBack = CallBack;
482:
483: return lpClient; //* SUCCESS return
484:
485: Error: //* ERROR Tag
486:
487: ErrorMessage(E_FAILED_TO_ALLOC);
488: EndClient(lpClient); //* free any allocated space
489:
490: return NULL; //* ERROR return
491:
492: }
493:
494: /****************************************************************************
495: * InitStream()
496: *
497: * Create and fill the STREAMVTBL. Create a stream structure and initialize
498: * pointer to stream vtbl.
499: *
500: * Returns LPAPPSTREAM - if successful a pointer to a stream structure
501: * , otherwise NULL .
502: ***************************************************************************/
503:
504: static LPAPPSTREAM InitStream( //* ENTRY:
505: HANDLE hInstance //* handle to application instance
506: ){ //* LOCAL:
507: LPAPPSTREAM lpStream = NULL; //* pointer to stream structure
508:
509: if (!(lpStream = (LPAPPSTREAM)GlobalLock(
510: GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(APPSTREAM))
511: )))
512: goto Error; //* ERROR jump
513:
514: if (!(lpStream->olestream.lpstbl = (LPOLESTREAMVTBL)GlobalLock(
515: GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(OLESTREAMVTBL))
516: )))
517: goto Error; //* ERROR jump
518:
519: //* set stream func. pointers
520: lpStream->olestream.lpstbl->Get = (DWORD ( CALLBACK *)(LPOLESTREAM, VOID FAR *, DWORD)) ReadStream;
521: lpStream->olestream.lpstbl->Put = (DWORD ( CALLBACK *)(LPOLESTREAM, OLE_CONST VOID FAR *, DWORD)) WriteStream;
522:
523: return lpStream; //* SUCCESS return
524:
525: Error: //* ERROR Tag
526:
527: ErrorMessage(E_FAILED_TO_ALLOC);
528: EndStream(lpStream);
529:
530: return NULL; //* ERROR return
531:
532: }
533:
534: /***************************************************************************
535: * UpdateMenu()
536: *
537: * Enabling or disable menuitems based upon program state.
538: ***************************************************************************/
539:
540: static VOID UpdateMenu( //* ENTRY:
541: HMENU hMenu //* menu handle to updated
542: ){ //* LOCAL:
543: INT mf; //* generic menu flag
544: APPITEMPTR paItem; //* app item pointer
545: HMENU hSub;
546: //* there must be at least on object
547: //* for the following to be enabled
548:
549: paItem = GetTopItem() ;
550:
551: mf = (paItem ? MF_ENABLED : MF_GRAYED);
552: EnableMenuItem(hMenu, IDM_CUT, mf); //* i.e. Cut,Copy,Clear,Clearall...
553: EnableMenuItem(hMenu, IDM_COPY, mf);
554: EnableMenuItem(hMenu, IDM_CLEAR, mf);
555: EnableMenuItem(hMenu, IDM_CLEARALL, mf);
556: //* enable links option only if there
557: //* is at least one linked object
558: EnableMenuItem(hMenu, IDM_LINKS, MF_GRAYED);
559: for (; paItem; paItem = GetNextItem(paItem))
560: {
561: if (paItem->otObject == OT_LINK)
562: {
563: EnableMenuItem(hMenu, IDM_LINKS, MF_ENABLED);
564: break;
565: }
566: }
567:
568: if (hSub = GetSubMenu(hMenu,POS_EDITMENU))
569: UpdateObjectMenuItem(hSub);
570:
571: if (OleQueryCreateFromClip(STDFILEEDITING, olerender_draw, 0) == OLE_OK)
572: EnableMenuItem(hMenu, IDM_PASTE, MF_ENABLED);
573: else if (OleQueryCreateFromClip(STATICP, olerender_draw, 0) == OLE_OK)
574: EnableMenuItem(hMenu, IDM_PASTE, MF_ENABLED);
575: else
576: EnableMenuItem(hMenu, IDM_PASTE, MF_GRAYED);
577:
578: if (OleQueryLinkFromClip(STDFILEEDITING, olerender_draw, 0) == OLE_OK)
579: EnableMenuItem(hMenu, IDM_PASTELINK, MF_ENABLED);
580: else
581: EnableMenuItem(hMenu, IDM_PASTELINK, MF_GRAYED);
582:
583: }
584:
585: /***************************************************************************
586: * NewFile()
587: *
588: * Save the present document and open a new blank one.
589: ***************************************************************************/
590:
591: static VOID NewFile( //* ENTRY:
592: PSTR pFileName, //* open file name
593: LHCLIENTDOC *lhcptrDoc, //* pointer to client doc. handle
594: LPAPPSTREAM lpStream //* pointer to stream structure
595: ){ //* LOCAL:
596: static CHAR szUntitled[CBMESSAGEMAX] = "";//* "(Untitled)" string
597: LHCLIENTDOC lhcDocNew; //* handle for new doc.
598:
599: if (!(*szUntitled))
600: LoadString(hInst, IDS_UNTITLED, (LPSTR)szUntitled, CBMESSAGEMAX);
601:
602: if (SaveAsNeeded(pFileName, *lhcptrDoc, lpStream))
603: { //* try to register new document
604: if (!RegDoc(szUntitled, &lhcDocNew))
605: return; //* before deregistring the old one
606: DeregDoc(*lhcptrDoc);
607: *lhcptrDoc = lhcDocNew;
608: Dirty(DOC_CLEAN); //* new document is clean
609: lstrcpy(pFileName,szUntitled);
610: SetTitle(pFileName);
611: iObjectNumber = 0;
612: }
613:
614: }
615:
616: /***************************************************************************
617: * MyOpenFile()
618: *
619: * Open a file and load it. Notice that the new file is loaded before
620: * the old is removed. This is done to assure a succesful file load
621: * before removing an existing document.
622: ***************************************************************************/
623:
624: static VOID MyOpenFile( //* ENTRY:
625: PSTR pFileName, //* open file name
626: LHCLIENTDOC *lhcptrDoc, //* pointer to document handle
627: LPOLECLIENT lpClient, //* pointer to client structure
628: LPAPPSTREAM lpStream //* pointer to stream structure
629: ){ //* LOCAL:
630: CHAR szNewFile[CBPATHMAX];//* new file name buffer
631: LHCLIENTDOC lhcDocNew; //* handle of new document
632: APPITEMPTR pItem; //* hold top item
633:
634: if (SaveAsNeeded(pFileName, *lhcptrDoc, lpStream))
635: {
636: *szNewFile = NULL;
637:
638: if (!OfnGetName(hwndFrame, szNewFile, IDM_OPEN))
639: return; //* ERROR return
640:
641: if (!RegDoc(szNewFile,&lhcDocNew))
642: return; //* ERROR return
643:
644: pItem = GetTopItem();
645: ShowDoc(*lhcptrDoc,0); //* make old doc objects hidden.
646: //* try to load the new file before
647: if (!LoadFile(szNewFile, lhcDocNew, lpClient, lpStream))
648: { //* before removing the old.
649: DeregDoc(lhcDocNew); //* restore old document if new
650: SetTopItem(pItem); //* file did not load
651: ShowDoc(*lhcptrDoc,1);
652: return; //* ERROR return
653: }
654:
655: DeregDoc(*lhcptrDoc); //* deregister old document
656: *lhcptrDoc = lhcDocNew;
657: lstrcpy(pFileName,szNewFile);
658: SetTitle(pFileName); //* set new title
659: Dirty(DOC_CLEAN);
660: }
661:
662: } //* SUCCESS return
663:
664: /***************************************************************************
665: * SaveasFile()
666: *
667: * Prompt the user for a new file name. Write the document to the new
668: * filename.
669: ***************************************************************************/
670:
671: static VOID SaveasFile( //* ENTRY:
672: PSTR pFileName, //* old filename
673: LHCLIENTDOC lhcDoc, //* document handle
674: LPAPPSTREAM lpStream //* pointer to stream structure
675: ){
676: CHAR szNewFile[CBPATHMAX];//* new file name
677:
678: *szNewFile = NULL; //* prompt user for new file name
679: if (!OfnGetName(hwndFrame, szNewFile, IDM_SAVEAS))
680: return; //* ERROR return
681: //* rename document
682: if (!SaveFile(szNewFile, lhcDoc, lpStream))
683: return;
684:
685: if (Error(OleRenameClientDoc(lhcDoc, szNewFile)))
686: {
687: ErrorMessage(W_FAILED_TO_NOTIFY);
688: return; //* ERROR return
689: }
690:
691: lstrcpy(pFileName,szNewFile);
692: SetTitle(pFileName);
693:
694: } //* SUCCESS return
695:
696: /***************************************************************************
697: * SaveFile()
698: *
699: * Save a compound document file. If the file is untitled, ask the user
700: * for a name and save the document to that file.
701: ***************************************************************************/
702:
703: static BOOL SaveFile( //* ENTRY:
704: PSTR pFileName, //* file to save document to
705: LHCLIENTDOC lhcDoc, //* OLE document handle
706: LPAPPSTREAM lpStream //* pointer to app. stream struct
707: ){ //* LOCAL:
708: CHAR szNewFile[CBPATHMAX];//* New file name strings
709: CHAR szOemFileName[2*CBPATHMAX];
710: static CHAR szUntitled[CBMESSAGEMAX] = "";
711: int fh; //* file handle
712:
713: *szNewFile = NULL;
714: if (!(*szUntitled))
715: LoadString(hInst, IDS_UNTITLED, (LPSTR)szUntitled, CBMESSAGEMAX);
716:
717: if (!lstrcmp(szUntitled, pFileName))//* get filename for the untitled case
718: {
719: if (!OfnGetName(hwndFrame, szNewFile, IDM_SAVEAS))
720: return FALSE; //* CANCEL return
721: lstrcpy(pFileName,szNewFile);
722: SetTitle(pFileName);
723: }
724:
725: AnsiToOem(pFileName, szOemFileName);
726: if ((fh = _lcreat((LPSTR)szOemFileName, 0)) <= 0)
727: {
728: ErrorMessage(E_INVALID_FILENAME);
729: return FALSE; //* ERROR return
730: }
731:
732: lpStream->fh = fh;
733: //* save file on disk
734: if (!WriteToFile(lpStream))
735: {
736: _lclose(fh);
737: ErrorMessage(E_FAILED_TO_SAVE_FILE);
738: return FALSE; //* ERROR return
739: }
740: _lclose(fh);
741:
742: if (Error(OleSavedClientDoc(lhcDoc)))
743: {
744: ErrorMessage(W_FAILED_TO_NOTIFY);
745: return FALSE; //* ERROR return
746: }
747:
748: Dirty(DOC_CLEAN);
749: return TRUE; //* SUCCESS return
750:
751: }
752:
753: /***************************************************************************
754: * LoadFile()
755: *
756: * Load a document file from disk.
757: ***************************************************************************/
758:
759: static BOOL LoadFile( //* ENTRY:
760: PSTR pFileName, //* file name
761: LHCLIENTDOC lhcDoc, //* document handle
762: LPOLECLIENT lpClient, //* pointer to client structure
763: LPAPPSTREAM lpStream //* pointer to stream structure
764: ){ //* LOCAL:
765: //* OEM file name
766: CHAR szOemFileName[2*CBPATHMAX];
767: int fh; //* file handle
768: INT iObjectNumberHold; //* hold object number
769:
770: AnsiToOem(pFileName, szOemFileName);
771: if ((fh = _lopen(szOemFileName, OF_READ | OF_SHARE_DENY_WRITE)) == -1)
772: {
773: ErrorMessage(E_FAILED_TO_READ_FILE);
774: return FALSE; //* ERROR return
775: }
776:
777: lpStream->fh = fh;
778:
779: iObjectNumberHold = iObjectNumber; //* save object number so it can
780: iObjectNumber = 0; //* be restored if read from file
781: //* fails
782: if (!ReadFromFile(lpStream, lhcDoc, lpClient))
783: {
784: _lclose(fh);
785: ErrorMessage(E_FAILED_TO_READ_FILE);
786: iObjectNumber = iObjectNumberHold;
787: return FALSE; //* ERROR return
788: }
789: return TRUE; //* SUCCESS return
790:
791: }
792:
793: /***************************************************************************
794: * RegDoc()
795: *
796: * Register the client document with the OLE library.
797: **************************************************************************/
798:
799: static BOOL RegDoc( //* ENTRY:
800: PSTR pFileName, //* file name
801: LHCLIENTDOC *lhcptrDoc //* pointer to client document handle
802: ){
803:
804: if (Error(OleRegisterClientDoc(szAppName, (LPSTR)pFileName, 0L, lhcptrDoc)))
805: {
806: ErrorMessage(W_FAILED_TO_NOTIFY);
807: return FALSE; //* ERROR return
808: }
809: return TRUE; //* SUCCESS return
810:
811: }
812:
813: /****************************************************************************
814: * DeregDoc()
815: *
816: * This function initiates the removal of all OLE objects from the
817: * current document and deregisters the document with the OLE library.
818: ***************************************************************************/
819:
820: static VOID DeregDoc( //* ENTRY:
821: LHCLIENTDOC lhcDoc //* client document handle
822: ){
823:
824: if (lhcDoc)
825: { //* release all OLE objects
826: ClearAll(lhcDoc,OLE_OBJ_RELEASE); //* and remove them from the screen
827: WaitForAllObjects();
828: if (Error(OleRevokeClientDoc(lhcDoc)))
829: ErrorMessage(W_FAILED_TO_NOTIFY);
830: }
831:
832: } //* SUCCESS return
833:
834: /***************************************************************************
835: * ClearAll()
836: *
837: * This function will destroy all of the item windows in the current
838: * document and delete all OLE objects. The loop is basically an enum
839: * of all child windows.
840: **************************************************************************/
841:
842: static VOID ClearAll( //* ENTRY:
843: LHCLIENTDOC lhcDoc, //* application document handle
844: BOOL fDelete //* Delete / Release
845: ){ //* LOCAL:
846: APPITEMPTR pItemNext; //* working handles
847: APPITEMPTR pItem; //* pointer to application item
848:
849: pItem = GetTopItem();
850:
851: while (pItem)
852: {
853: pItemNext = GetNextItem(pItem);
854: if (pItem->lhcDoc == lhcDoc)
855: ObjDelete(pItem, fDelete);
856: pItem = pItemNext;
857: }
858:
859: }
860: //* SUCCESS return
861: /***************************************************************************
862: * ClearItem()
863: *
864: * This function will destroy an item window, and make the
865: * next window active.
866: **************************************************************************/
867:
868: VOID FAR ClearItem( //* ENTRY:
869: APPITEMPTR pItem //* application item pointer
870: ){
871:
872: pItem->fVisible = FALSE;
873: SetTopItem(GetNextActiveItem());
874: ObjDelete(pItem, OLE_OBJ_DELETE);
875: Dirty(DOC_DIRTY);
876:
877: }
878:
879: /****************************************************************************
880: * SaveAsNeeded()
881: *
882: * This function will have the file saved if and only
883: * if the document has been modified. If the fDirty flag has
884: * been set to TRUE, then the document needs to be saved.
885: *
886: * Returns: BOOL - TRUE if document doesn't need saving or if the
887: * document has been saved successfully.
888: ***************************************************************************/
889:
890: static BOOL SaveAsNeeded( //* ENTRY:
891: PSTR pFileName, //* file to save
892: LHCLIENTDOC lhcDoc, //* OLE doc handle
893: LPAPPSTREAM lpStream //* pointer to OLE stream vtbl ...
894: ){ //* LOCAL:
895: CHAR sz[CBMESSAGEMAX]; //* work strings
896: CHAR sz2[CBMESSAGEMAX + CBPATHMAX];
897:
898: if (Dirty(DOC_QUERY)) //* if doc is clean don't bother
899: {
900:
901: LoadString(hInst, IDS_MAYBESAVE, sz, CBMESSAGEMAX);
902: wsprintf(sz2, sz, (LPSTR)pFileName );
903:
904: switch (MessageBox(hwndFrame, sz2, szAppName, MB_YESNOCANCEL | MB_ICONQUESTION))
905: {
906:
907: case IDCANCEL:
908: return FALSE; //* CANCEL return
909:
910: case IDYES:
911: return (SaveFile(pFileName,lhcDoc,lpStream));
912:
913: default:
914: break;
915: }
916: }
917: return TRUE; //* SUCCESS return
918:
919: }
920:
921: /****************************************************************************
922: * SetTitle()
923: *
924: * Set the window caption to the current file name. If szFileName is
925: * NULL, the caption will be set to "(Untitled)".
926: ***************************************************************************/
927:
928: static VOID SetTitle( //* ENTRY:
929: PSTR pFileName //* file name
930: ){ //* LOCAL
931: //* window title string
932: CHAR szTitle[CBMESSAGEMAX + CBPATHMAX];
933:
934: wsprintf(szTitle, "%s - %s", (LPSTR)szAppName, (LPSTR)pFileName);
935: SetWindowText(hwndFrame, szTitle);
936:
937: }
938:
939: /***************************************************************************
940: * EndClient()
941: *
942: * Perform cleanup prior to app termination. The OLECLIENT
943: * memory blocks and procedure instance thunks freed.
944: **************************************************************************/
945:
946: static VOID EndStream( //* ENTRY:
947: LPAPPSTREAM lpStream //* pointer to stream structure
948: ){ //* LOCAL:
949: HANDLE hGeneric; //* temp handle
950:
951: if (lpStream) //* is there a STREAM struct?
952: {
953: if (lpStream->olestream.lpstbl)
954: {
955: FreeProcInstance((FARPROC)lpStream->olestream.lpstbl->Get);
956: FreeProcInstance((FARPROC)lpStream->olestream.lpstbl->Put);
957: hGeneric = GlobalHandle((LPSTR)lpStream->olestream.lpstbl);
958: GlobalUnlock(hGeneric);
959: GlobalFree(hGeneric);
960: }
961: hGeneric = GlobalHandle((LPSTR)lpStream);
962: GlobalUnlock(hGeneric);
963: GlobalFree(hGeneric);
964: }
965:
966: } //* SUCCESS return
967:
968: /***************************************************************************
969: * EndClient()
970: *
971: * Perform cleanup prior to app termination. The OLECLIENT
972: * memory blocks and procedure instance thunks are freed.
973: **************************************************************************/
974:
975: static VOID EndClient( //* ENTRY:
976: LPOLECLIENT lpClient //* pointer to client structure
977: ){ //* LOCAL:
978: HANDLE hGeneric; //* temp handle
979:
980: if (lpClient) //* is there a client structure
981: {
982: if (lpClient->lpvtbl)
983: {
984: FreeProcInstance(lpClient->lpvtbl->CallBack);
985: hGeneric = GlobalHandle((LPSTR)lpClient->lpvtbl);
986: GlobalUnlock(hGeneric);
987: GlobalFree(hGeneric);
988: }
989: hGeneric = GlobalHandle((LPSTR)lpClient);
990: GlobalUnlock(hGeneric);
991: GlobalFree(hGeneric);
992: }
993:
994: } //* SUCCESS return
995:
996: /****************************************************************************
997: * QueryEndSession()
998: ***************************************************************************/
999:
1000: static LONG QueryEndSession( //* ENTRY:
1001: PSTR pFileName, //* document name
1002: LHCLIENTDOC lhcDoc, //* client document handle
1003: LPAPPSTREAM lpStream //* application stream pointer
1004: ){ //* LOCAL:
1005: APPITEMPTR pItem; //* application item pointer
1006:
1007:
1008: for (pItem = GetTopItem(); pItem; pItem = GetNextItem(pItem))
1009: if (OleQueryOpen(pItem->lpObject) == OLE_OK)
1010: {
1011: MessageBox(hwndFrame,"Exit CliDemo before closing Windows",
1012: szAppName, MB_OK | MB_ICONSTOP);
1013: return 0L;
1014: }
1015:
1016: if (!SaveAsNeeded(pFileName, lhcDoc, lpStream))
1017: return 0L;
1018: DeregDoc(lhcDoc);
1019: return 1L;
1020:
1021: }
1022:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.