![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outldoc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline|
Return to outldoc.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Sample Code
4: **
5: ** outldoc.c
6: **
7: ** This file contains OutlineDoc functions.
8: **
9: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
10: **
11: *************************************************************************/
12:
13: #include "outline.h"
14: #include <ole2ui.h>
15:
16: #if !defined( OLE_VERSION )
17: #include <commdlg.h>
18: #endif
19:
20:
21: OLEDBGDATA
22:
23: extern LPOUTLINEAPP g_lpApp;
24:
25: // REVIEW: should use string resource for messages
26: char ErrMsgDocWnd[] = "Can't create Document Window!";
27: char ErrMsgFormatNotSupported[] = "Clipboard format not supported!";
28: char MsgSaveFile[] = "Save existing file ?";
29: char ErrMsgSaving[] = "Error in saving file!";
30: char ErrMsgOpening[] = "Error in opening file!";
31: char ErrMsgFormat[] = "Improper file format!";
32: char ErrOutOfMemory[] = "Error: out of memory!";
33: static char ErrMsgPrint[] = "Printing Error!";
34:
35: static BOOL fCancelPrint; // TRUE if the user has canceled the print job
36: static HWND hWndPDlg; // Handle to the cancel print dialog
37:
38:
39: /* OutlineDoc_Init
40: * ---------------
41: *
42: * Initialize the fields of a new OutlineDoc object. The object is initially
43: * not associated with a file or an (Untitled) document. This function sets
44: * the docInitType to DOCTYPE_UNKNOWN. After calling this function the
45: * caller should call:
46: * 1. OutlineDoc_InitNewFile to set the OutlineDoc to (Untitled)
47: * 2. OutlineDoc_LoadFromFile to associate the OutlineDoc with a file.
48: * This function creates a new window for the document.
49: *
50: * NOTE: the window is initially created with a NIL size. it must be
51: * sized and positioned by the caller. also the document is initially
52: * created invisible. the caller must call OutlineDoc_ShowWindow
53: * after sizing it to make the document window visible.
54: */
55: BOOL OutlineDoc_Init(LPOUTLINEDOC lpOutlineDoc, BOOL fDataTransferDoc)
56: {
57: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
58:
59: #if defined( INPLACE_CNTR )
60: lpOutlineDoc->m_hWndDoc = CreateWindow(
61: DOCWNDCLASS, // Window class name
62: NULL, // Window's title
63:
64: /* OLE2NOTE: an in-place contanier MUST use
65: ** WS_CLIPCHILDREN window style for the window
66: ** that it uses as the parent for the server's
67: ** in-place active window so that its
68: ** painting does NOT interfere with the painting
69: ** of the server's in-place active child window.
70: */
71:
72: WS_CLIPCHILDREN |
73: WS_CHILDWINDOW,
74: 0, 0,
75: 0, 0,
76: lpOutlineApp->m_hWndApp,// Parent window's handle
77: (HMENU)1, // child window id
78: lpOutlineApp->m_hInst, // Instance of window
79: NULL); // Create struct for WM_CREATE
80:
81: #else
82:
83: lpOutlineDoc->m_hWndDoc = CreateWindow(
84: DOCWNDCLASS, // Window class name
85: NULL, // Window's title
86: WS_CHILDWINDOW,
87: 0, 0,
88: 0, 0,
89: lpOutlineApp->m_hWndApp,// Parent window's handle
90: (HMENU)1, // child window id
91: lpOutlineApp->m_hInst, // Instance of window
92: NULL); // Create struct for WM_CREATE
93: #endif
94:
95: if(! lpOutlineDoc->m_hWndDoc) {
96: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgDocWnd);
97: return FALSE;
98: }
99:
100: SetWindowLong(lpOutlineDoc->m_hWndDoc, 0, (LONG) lpOutlineDoc);
101:
102: if (! LineList_Init(&lpOutlineDoc->m_LineList, lpOutlineDoc))
103: return FALSE;
104:
105: lpOutlineDoc->m_lpNameTable = OutlineDoc_CreateNameTable(lpOutlineDoc);
106: if (! lpOutlineDoc->m_lpNameTable )
107: return FALSE;
108:
109: lpOutlineDoc->m_docInitType = DOCTYPE_UNKNOWN;
110: lpOutlineDoc->m_cfSaveFormat = lpOutlineApp->m_cfOutline;
111: lpOutlineDoc->m_szFileName[0] = '\0';
112: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName;
113: lpOutlineDoc->m_fDataTransferDoc = fDataTransferDoc;
114: lpOutlineDoc->m_uCurrentZoom = IDM_V_ZOOM_100;
115: lpOutlineDoc->m_scale.dwSxN = (DWORD) 1;
116: lpOutlineDoc->m_scale.dwSxD = (DWORD) 1;
117: lpOutlineDoc->m_scale.dwSyN = (DWORD) 1;
118: lpOutlineDoc->m_scale.dwSyD = (DWORD) 1;
119: lpOutlineDoc->m_uCurrentMargin = IDM_V_SETMARGIN_0;
120: lpOutlineDoc->m_nLeftMargin = 0;
121: lpOutlineDoc->m_nRightMargin = 0;
122: lpOutlineDoc->m_nDisableDraw = 0;
123: OutlineDoc_SetModified(lpOutlineDoc, FALSE, FALSE, FALSE);
124:
125: #if defined( USE_HEADING )
126: if (! fDataTransferDoc) {
127: if (!Heading_Create((LPHEADING)&lpOutlineDoc->m_heading,
128: lpOutlineDoc->m_hWndDoc, lpOutlineApp->m_hInst)) {
129: return FALSE;
130:
131: }
132: }
133: #endif // USE_HEADING
134:
135: #if defined( USE_FRAMETOOLS )
136: if (! fDataTransferDoc) {
137: lpOutlineDoc->m_lpFrameTools = OutlineApp_GetFrameTools(lpOutlineApp);
138: FrameTools_AssociateDoc(
139: lpOutlineDoc->m_lpFrameTools,
140: lpOutlineDoc
141: );
142: }
143: #endif // USE_FRAMETOOLS
144:
145: #if defined( OLE_VERSION )
146: /* OLE2NOTE: perform initialization required for OLE */
147: if (! OleDoc_Init((LPOLEDOC)lpOutlineDoc, fDataTransferDoc))
148: return FALSE;
149: #endif // OLE_VERSION
150:
151: return TRUE;
152: }
153:
154:
155: /* OutlineDoc_InitNewFile
156: * ----------------------
157: *
158: * Initialize the OutlineDoc object to be a new (Untitled) document.
159: * This function sets the docInitType to DOCTYPE_NEW.
160: */
161: BOOL OutlineDoc_InitNewFile(LPOUTLINEDOC lpOutlineDoc)
162: {
163: #if defined( OLE_VERSION )
164: // OLE2NOTE: call OLE version of this function instead
165: return OleDoc_InitNewFile((LPOLEDOC)lpOutlineDoc);
166:
167: #else
168:
169: OleDbgAssert(lpOutlineDoc->m_docInitType == DOCTYPE_UNKNOWN);
170:
171: // set file name to untitled
172: // REVIEW: should load from string resource
173: lstrcpy(lpOutlineDoc->m_szFileName, UNTITLED);
174: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName;
175: lpOutlineDoc->m_docInitType = DOCTYPE_NEW;
176:
177: if (! lpOutlineDoc->m_fDataTransferDoc)
178: OutlineDoc_SetTitle(lpOutlineDoc);
179:
180: return TRUE;
181:
182: #endif // BASE OUTLINE VERSION
183: }
184:
185:
186: /* OutlineDoc_CreateNameTable
187: * --------------------------
188: *
189: * Allocate a new NameTable of the appropriate type. Each document has
190: * a NameTable and a LineList.
191: * OutlineDoc --> creates standard OutlineNameTable type name tables.
192: * ServerDoc --> creates enhanced SeverNameTable type name tables.
193: *
194: * Returns lpNameTable for successful, NULL if error.
195: */
196: LPOUTLINENAMETABLE OutlineDoc_CreateNameTable(LPOUTLINEDOC lpOutlineDoc)
197: {
198: LPOUTLINENAMETABLE lpOutlineNameTable;
199:
200: lpOutlineNameTable = (LPOUTLINENAMETABLE)New(
201: (DWORD)sizeof(OUTLINENAMETABLE)
202: );
203:
204: if (! OleDbgVerifySz(lpOutlineNameTable != NULL,
205: "Error allocating NameTable"))
206: return NULL;
207:
208: // initialize new NameTable
209: if (! OutlineNameTable_Init(lpOutlineNameTable, lpOutlineDoc) )
210: goto error;
211:
212: return lpOutlineNameTable;
213:
214: error:
215: if (lpOutlineNameTable)
216: Delete(lpOutlineNameTable);
217: return NULL;
218: }
219:
220:
221: /* OutlineDoc_ClearCommand
222: * -----------------------
223: *
224: * Delete selection in list box by calling OutlineDoc_Delete
225: */
226: void OutlineDoc_ClearCommand(LPOUTLINEDOC lpOutlineDoc)
227: {
228: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
229: int i;
230: int nNumSel;
231: LINERANGE lrSel;
232:
233: nNumSel=LineList_GetSel(lpLL, (LPLINERANGE)&lrSel);
234:
235: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
236: for(i = 0; i < nNumSel; i++)
237: OutlineDoc_DeleteLine(lpOutlineDoc, lrSel.m_nStartLine);
238: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
239:
240: LineList_RecalcMaxLineWidthInHimetric(lpLL, 0);
241: }
242:
243:
244: /* OutlineDoc_CutCommand
245: * ---------------------
246: *
247: * Cut selection to clipboard
248: */
249: void OutlineDoc_CutCommand(LPOUTLINEDOC lpOutlineDoc)
250: {
251: OutlineDoc_CopyCommand(lpOutlineDoc);
252: OutlineDoc_ClearCommand(lpOutlineDoc);
253: }
254:
255:
256: /* OutlineDoc_CopyCommand
257: * ----------------------
258: * Copy selection to clipboard.
259: * Post to the clipboard the formats that the app can render.
260: * the actual data is not rendered at this time. using the
261: * delayed rendering technique, Windows will send the clipboard
262: * owner window either a WM_RENDERALLFORMATS or a WM_RENDERFORMAT
263: * message when the actual data is requested.
264: *
265: * OLE2NOTE: the normal delayed rendering technique where Windows
266: * sends the clipboard owner window either a WM_RENDERALLFORMATS or
267: * a WM_RENDERFORMAT message when the actual data is requested is
268: * NOT exposed to the app calling OleSetClipboard. OLE internally
269: * creates its own window as the clipboard owner and thus our app
270: * will NOT get these WM_RENDER messages.
271: */
272: void OutlineDoc_CopyCommand(LPOUTLINEDOC lpSrcOutlineDoc)
273: {
274: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
275: LPOUTLINEDOC lpClipboardDoc;
276:
277: #if defined( OLE_VERSION )
278:
279: /* squirrel away a copy of the current selection to the ClipboardDoc */
280: lpClipboardDoc = OutlineDoc_CreateDataTransferDoc(lpSrcOutlineDoc);
281:
282: if (! lpClipboardDoc)
283: return; // Error: could not create DataTransferDoc
284:
285: lpOutlineApp->m_lpClipboardDoc = (LPOUTLINEDOC)lpClipboardDoc;
286:
287: /* OLE2NOTE: initially the Doc object is created with a 0 ref
288: ** count. in order to have a stable Doc object during the
289: ** process of initializing the Doc instance and transfering it
290: ** to the clipboard, we intially AddRef the Doc ref cnt and later
291: ** Release it. This initial AddRef is artificial; it is simply
292: ** done to guarantee that a harmless QueryInterface followed by
293: ** a Release does not inadvertantly force our object to destroy
294: ** itself prematurely.
295: */
296: OleDoc_AddRef((LPOLEDOC)lpClipboardDoc);
297:
298: /* OLE2NOTE: the OLE 2.0 style to put data onto the clipboard is to
299: ** give the clipboard a pointer to an IDataObject interface that
300: ** is able to statisfy IDataObject::GetData calls to render
301: ** data. in our case we give the pointer to the ClipboardDoc
302: ** which holds a cloned copy of the current user's selection.
303: */
304: OLEDBG_BEGIN2("OleSetClipboard called\r\n")
305: OleSetClipboard((LPDATAOBJECT)&((LPOLEDOC)lpClipboardDoc)->m_DataObject);
306: OLEDBG_END2
307:
308: OleDoc_Release((LPOLEDOC)lpClipboardDoc); // rel artificial AddRef above
309:
310: #else
311:
312: OpenClipboard(lpSrcOutlineDoc->m_hWndDoc);
313: EmptyClipboard();
314:
315: /* squirrel away a copy of the current selection to the ClipboardDoc */
316: lpClipboardDoc = OutlineDoc_CreateDataTransferDoc(lpSrcOutlineDoc);
317:
318: if (! lpClipboardDoc)
319: return; // Error: could not create DataTransferDoc
320:
321: lpOutlineApp->m_lpClipboardDoc = (LPOUTLINEDOC)lpClipboardDoc;
322:
323: SetClipboardData(lpOutlineApp->m_cfOutline, NULL);
324: SetClipboardData(CF_TEXT, NULL);
325:
326: CloseClipboard();
327:
328: #endif
329: }
330:
331:
332: /* OutlineDoc_ClearAllLines
333: * ------------------------
334: *
335: * Delete all lines in the document.
336: */
337: void OutlineDoc_ClearAllLines(LPOUTLINEDOC lpOutlineDoc)
338: {
339: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
340: int i;
341:
342: for(i = 0; i < lpLL->m_nNumLines; i++)
343: OutlineDoc_DeleteLine(lpOutlineDoc, 0);
344:
345: LineList_RecalcMaxLineWidthInHimetric(lpLL, 0);
346: }
347:
348:
349: /* OutlineDoc_CreateDataTransferDoc
350: * --------------------------------
351: *
352: * Create a document to be use to transfer data (either via a
353: * drag/drop operation of the clipboard). Copy the selection of the
354: * source doc to the data transfer document. A data transfer document is
355: * the same as a document that is created by the user except that it is
356: * NOT made visible to the user. it is specially used to hold a copy of
357: * data that the user should not be able to change.
358: *
359: * OLE2NOTE: in the OLE version the data transfer document is used
360: * specifically to provide an IDataObject* that renders the data copied.
361: */
362: LPOUTLINEDOC OutlineDoc_CreateDataTransferDoc(LPOUTLINEDOC lpSrcOutlineDoc)
363: {
364: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
365: LPOUTLINEDOC lpDestOutlineDoc;
366: LPLINELIST lpSrcLL = &lpSrcOutlineDoc->m_LineList;
367: LINERANGE lrSel;
368: int nCopied;
369:
370: lpDestOutlineDoc = OutlineApp_CreateDoc(lpOutlineApp, TRUE);
371: if (! lpDestOutlineDoc) return NULL;
372:
373: // set the ClipboardDoc to an (Untitled) doc.
374: if (! OutlineDoc_InitNewFile(lpDestOutlineDoc))
375: goto error;
376:
377: LineList_GetSel(lpSrcLL, (LPLINERANGE)&lrSel);
378: nCopied = LineList_CopySelToDoc(
379: lpSrcLL,
380: (LPLINERANGE)&lrSel,
381: lpDestOutlineDoc
382: );
383:
384: #if defined( OLE_SERVER )
385: {
386: LPOLEDOC lpSrcOleDoc = (LPOLEDOC)lpSrcOutlineDoc;
387: LPOLEDOC lpDestOleDoc = (LPOLEDOC)lpDestOutlineDoc;
388: LPSERVERDOC lpDestServerDoc = (LPSERVERDOC)lpDestOutlineDoc;
389: LPMONIKER lpmkDoc = NULL;
390: LPMONIKER lpmkItem = NULL;
391:
392: /* If source document is able to provide a moniker, then the
393: ** destination document (lpDestOutlineDoc) should offer
394: ** CF_LINKSOURCE via its IDataObject interface that it gives
395: ** to the clipboard or the drag/drop operation.
396: **
397: ** OLE2NOTE: we want to ask the source document if it can
398: ** produce a moniker, but we do NOT want to FORCE moniker
399: ** assignment at this point. we only want to FORCE moniker
400: ** assignment later if a Paste Link occurs (ie. GetData for
401: ** CF_LINKSOURCE). if the source document is able to give
402: ** a moniker, then we store a pointer to the source document
403: ** so we can ask it at a later time to get the moniker. we
404: ** also save the range of the current selection so we can
405: ** generate a proper item name later when Paste Link occurs.
406: ** Also we need to give a string which identifies the source
407: ** of the copy in the CF_OBJECTDESCRIPTOR format. this
408: ** string is used to display in the PasteSpecial dialog. we
409: ** get and store a TEMPFORUSER moniker which identifies the
410: ** source of copy.
411: */
412: lpDestOleDoc->m_lpSrcDocOfCopy = lpSrcOleDoc;
413: lpmkDoc = OleDoc_GetFullMoniker(lpSrcOleDoc, GETMONIKER_TEMPFORUSER);
414: if (lpmkDoc != NULL) {
415: lpDestOleDoc->m_fLinkSourceAvail = TRUE;
416: lpDestServerDoc->m_lrSrcSelOfCopy = lrSel;
417: OleStdRelease((LPUNKNOWN)lpmkDoc);
418: }
419: }
420:
421: #elif defined( OLE_CNTR )
422: {
423: LPOLEDOC lpSrcOleDoc = (LPOLEDOC)lpSrcOutlineDoc;
424: LPOLEDOC lpDestOleDoc = (LPOLEDOC)lpDestOutlineDoc;
425: LPCONTAINERDOC lpDestContainerDoc = (LPCONTAINERDOC)lpDestOutlineDoc;
426:
427: /* If one line was copied from the source document, and it was a
428: ** single OLE object, then the destination document should
429: ** offer additional data formats to allow the transfer of
430: ** the OLE object via IDataObject::GetData. Specifically, the
431: ** following additional data formats are offered if a single
432: ** OLE object is copied:
433: ** CF_EMBEDDEDOBJECT
434: ** CF_OBJECTDESCRIPTOR (should be given even w/o object)
435: ** CF_METAFILEPICT (note: dwAspect depends on object)
436: ** CF_LINKSOURCE -- if linking is possible
437: ** CF_LINKSOURCEDESCRIPTOR -- if linking is possible
438: **
439: ** optionally the container may give
440: ** <data format available in OLE object's cache>
441: */
442:
443: if (nCopied == 1) {
444: LPOLEOBJECT lpSrcOleObj;
445: LPCONTAINERLINE lpSrcContainerLine;
446: DWORD dwStatus;
447:
448: lpSrcContainerLine = (LPCONTAINERLINE)LineList_GetLine(
449: lpSrcLL,
450: lrSel.m_nStartLine
451: );
452:
453: lpDestOleDoc->m_lpSrcDocOfCopy = lpSrcOleDoc;
454:
455: if ((((LPLINE)lpSrcContainerLine)->m_lineType==CONTAINERLINETYPE)
456: && ((lpSrcOleObj=lpSrcContainerLine->m_lpOleObj)!=NULL)) {
457:
458: lpDestContainerDoc->m_fEmbeddedObjectAvail = TRUE;
459: lpSrcOleObj->lpVtbl->GetUserClassID(
460: lpSrcOleObj,
461: &lpDestContainerDoc->m_clsidOleObjCopied
462: );
463: lpDestContainerDoc->m_dwAspectOleObjCopied =
464: lpSrcContainerLine->m_dwDrawAspect;
465:
466: /* OLE2NOTE: if the object is allowed to be linked
467: ** to from the inside (ie. we are allowed to
468: ** give out a moniker which binds to the running
469: ** OLE object), then we want to offer
470: ** CF_LINKSOURCE format. if the object is an OLE
471: ** 2.0 embedded object then it is allowed to be
472: ** linked to from the inside. if the object is
473: ** either an OleLink or an OLE 1.0 embedding
474: ** then it can not be linked to from the inside.
475: ** if we were a container/server app then we
476: ** could offer linking to the outside of the
477: ** object (ie. a pseudo object within our
478: ** document). we are a container only app that
479: ** does not support linking to ranges of its data.
480: */
481:
482: lpSrcOleObj->lpVtbl->GetMiscStatus(
483: lpSrcOleObj,
484: DVASPECT_CONTENT, /* aspect is not important */
485: (LPDWORD)&dwStatus
486: );
487: if (! (dwStatus & OLEMISC_CANTLINKINSIDE)) {
488: /* Our container supports linking to an embedded
489: ** object. We want the lpDestContainerDoc to
490: ** offer CF_LINKSOURCE via the IDataObject
491: ** interface that it gives to the clipboard or
492: ** the drag/drop operation. The link source will
493: ** be identified by a composite moniker
494: ** comprised of the FileMoniker of the source
495: ** document and an ItemMoniker which identifies
496: ** the OLE object inside the container. we do
497: ** NOT want to force moniker assignment to the
498: ** OLE object now (at copy time); we only want
499: ** to FORCE moniker assignment later if a Paste
500: ** Link occurs (ie. GetData for CF_LINKSOURCE).
501: ** thus we store a pointer to the source document
502: ** and the source ContainerLine so we can
503: ** generate a proper ItemMoniker later when
504: ** Paste Link occurs.
505: */
506: lpDestOleDoc->m_fLinkSourceAvail = TRUE;
507: lpDestContainerDoc->m_lpSrcContainerLine =
508: lpSrcContainerLine;
509: }
510: }
511: }
512: }
513:
514: #endif
515:
516: return lpDestOutlineDoc;
517:
518: error:
519: if (lpDestOutlineDoc)
520: OutlineDoc_Destroy(lpDestOutlineDoc);
521:
522: return NULL;
523: }
524:
525:
526: /* OutlineDoc_PasteCommand
527: * -----------------------
528: *
529: * Paste lines from clipboard
530: */
531: void OutlineDoc_PasteCommand(LPOUTLINEDOC lpOutlineDoc)
532: {
533: #if defined( OLE_VERSION )
534: // Call OLE version of this function instead
535: OleDoc_PasteCommand((LPOLEDOC)lpOutlineDoc);
536:
537: #else
538:
539: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
540: LPLINELIST lpLL = (LPLINELIST)&lpOutlineDoc->m_LineList;
541: int nIndex;
542: int nCount;
543: HGLOBAL hData;
544: LINERANGE lrSel;
545: UINT uFormat;
546:
547: if (LineList_GetCount(lpLL) == 0)
548: nIndex = -1; // pasting to empty list
549: else
550: nIndex=LineList_GetFocusLineIndex(lpLL);
551:
552: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
553:
554: OpenClipboard(lpOutlineDoc->m_hWndDoc);
555:
556: uFormat = 0;
557: while(uFormat = EnumClipboardFormats(uFormat)) {
558: if(uFormat == lpOutlineApp->m_cfOutline) {
559: hData = GetClipboardData(lpOutlineApp->m_cfOutline);
560: nCount = OutlineDoc_PasteOutlineData(lpOutlineDoc, hData, nIndex);
561: break;
562: }
563: if(uFormat == CF_TEXT) {
564: hData = GetClipboardData(CF_TEXT);
565: nCount = OutlineDoc_PasteTextData(lpOutlineDoc, hData, nIndex);
566: break;
567: }
568: }
569:
570: lrSel.m_nStartLine = nIndex + nCount;
571: lrSel.m_nEndLine = nIndex + 1;
572: LineList_SetSel(lpLL, &lrSel);
573: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
574:
575: CloseClipboard();
576:
577: #endif // ! OLE_VERSION
578: }
579:
580:
581: /* OutlineDoc_PasteOutlineData
582: * ---------------------------
583: *
584: * Put an array of Line Objects (stored in hOutline) into the document
585: *
586: * Return the number of items added
587: */
588: int OutlineDoc_PasteOutlineData(LPOUTLINEDOC lpOutlineDoc, HGLOBAL hOutline, int nStartIndex)
589: {
590: int nCount;
591: int i;
592: LPTEXTLINE arrLine;
593:
594: nCount = (int) GlobalSize(hOutline) / sizeof(TEXTLINE);
595: arrLine = (LPTEXTLINE)GlobalLock(hOutline);
596: if (!arrLine)
597: return 0;
598:
599: for(i = 0; i < nCount; i++)
600: Line_CopyToDoc((LPLINE)&arrLine[i], lpOutlineDoc, nStartIndex+i);
601:
602: GlobalUnlock(hOutline);
603:
604: return nCount;
605: }
606:
607:
608: /* OutlineDoc_PasteTextData
609: * ------------------------
610: *
611: * Build Line Objects from the strings (separated by '\n') in hText
612: * and put them into the document
613: */
614: int OutlineDoc_PasteTextData(LPOUTLINEDOC lpOutlineDoc, HGLOBAL hText, int nStartIndex)
615: {
616: LPLINELIST lpLL = (LPLINELIST)&lpOutlineDoc->m_LineList;
617: HDC hDC;
618: LPSTR lpszText;
619: LPSTR lpszEnd;
620: LPTEXTLINE lpLine;
621: int nLineCount;
622: int i;
623: UINT nTab;
624: char szBuf[MAXSTRLEN+1];
625:
626: lpszText=(LPSTR)GlobalLock(hText);
627: if(!lpszText)
628: return 0;
629:
630: lpszEnd = lpszText + lstrlen(lpszText);
631: nLineCount=0;
632:
633: while(*lpszText && (lpszText<lpszEnd)) {
634:
635: // count the tab level
636: nTab = 0;
637: while((*lpszText == '\t') && (lpszText<lpszEnd)) {
638: nTab++;
639: lpszText++;
640: }
641:
642: // collect the text string character by character
643: for(i=0; (i<MAXSTRLEN) && (lpszText<lpszEnd); i++) {
644: if ((! *lpszText) || (*lpszText == '\n'))
645: break;
646: szBuf[i] = *lpszText++;
647: }
648: szBuf[i] = 0;
649: lpszText++;
650: if ((i > 0) && (szBuf[i-1] == '\r'))
651: szBuf[i-1] = 0; // remove carriage return at the end
652:
653: hDC = LineList_GetDC(lpLL);
654: lpLine = TextLine_Create(hDC, nTab, szBuf);
655: LineList_ReleaseDC(lpLL, hDC);
656:
657: OutlineDoc_AddLine(
658: lpOutlineDoc,
659: (LPLINE)lpLine,
660: nStartIndex + nLineCount
661: );
662: nLineCount++;
663:
664: }
665:
666: GlobalUnlock(hText);
667:
668: return nLineCount;
669: }
670:
671:
672: /* OutlineDoc_AddTextLineCommand
673: * -----------------------------
674: *
675: * Add a new text line following the current focus line.
676: */
677: void OutlineDoc_AddTextLineCommand(LPOUTLINEDOC lpOutlineDoc)
678: {
679: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
680: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
681: HDC hDC;
682: int nIndex = LineList_GetFocusLineIndex(lpLL);
683: char szBuf[MAXSTRLEN+1];
684: UINT nTab = 0;
685: LPLINE lpLine;
686: LPTEXTLINE lpTextLine;
687:
688: szBuf[0] = '\0';
689:
690: #if defined( USE_FRAMETOOLS )
691: FrameTools_FB_GetEditText(
692: lpOutlineDoc->m_lpFrameTools, szBuf, sizeof(szBuf));
693: #else
694: if (! InputTextDlg(lpOutlineDoc->m_hWndDoc, szBuf, "Add Line"))
695: return;
696: #endif
697:
698: hDC = LineList_GetDC(lpLL);
699: lpLine = LineList_GetLine(lpLL, nIndex);
700: if (lpLine)
701: nTab = Line_GetTabLevel(lpLine);
702:
703: lpTextLine=TextLine_Create(hDC, nTab, szBuf);
704: LineList_ReleaseDC(lpLL, hDC);
705:
706: if (! lpTextLine) {
707: OutlineApp_ErrorMessage(lpOutlineApp, ErrOutOfMemory);
708: return;
709: }
710: OutlineDoc_AddLine(lpOutlineDoc, (LPLINE)lpTextLine, nIndex);
711: }
712:
713:
714: /* OutlineDoc_AddTopLineCommand
715: * ----------------------------
716: *
717: * Add a top (margin) line as the first line in the LineList.
718: * (do not change the current selection)
719: */
720: void OutlineDoc_AddTopLineCommand(
721: LPOUTLINEDOC lpOutlineDoc,
722: UINT nHeightInHimetric
723: )
724: {
725: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
726: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
727: HDC hDC = LineList_GetDC(lpLL);
728: LPTEXTLINE lpTextLine = TextLine_Create(hDC, 0, NULL);
729: LPLINE lpLine = (LPLINE)lpTextLine;
730: LINERANGE lrSel;
731: int nNumSel;
732:
733: LineList_ReleaseDC(lpLL, hDC);
734:
735: if (! lpTextLine) {
736: OutlineApp_ErrorMessage(lpOutlineApp, ErrOutOfMemory);
737: return;
738: }
739:
740: Line_SetHeightInHimetric(lpLine, nHeightInHimetric);
741:
742: nNumSel=LineList_GetSel(lpLL, (LPLINERANGE)&lrSel);
743: if (nNumSel > 0) {
744: // adjust current selection to keep equivalent selection
745: lrSel.m_nStartLine += 1;
746: lrSel.m_nEndLine += 1;
747: }
748: OutlineDoc_AddLine(lpOutlineDoc, lpLine, -1);
749: if (nNumSel > 0)
750: LineList_SetSel(lpLL, (LPLINERANGE)&lrSel);
751: else
752: LineList_RemoveSel(lpLL);
753: }
754:
755:
756: #if defined( USE_FRAMETOOLS )
757:
758:
759: /* OutlineDoc_SetFormulaBarEditText
760: * --------------------------------
761: *
762: * Fill the edit control in the formula with the text string from a
763: * TextLine in focus.
764: */
765: void OutlineDoc_SetFormulaBarEditText(
766: LPOUTLINEDOC lpOutlineDoc,
767: LPLINE lpLine
768: )
769: {
770: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
771: char cBuf[MAXSTRLEN+1];
772:
773: if (! lpOutlineDoc || ! lpOutlineDoc->m_lpFrameTools)
774: return;
775:
776: if (Line_GetLineType(lpLine) != TEXTLINETYPE) {
777: FrameTools_FB_SetEditText(lpOutlineDoc->m_lpFrameTools, NULL);
778: } else {
779: TextLine_GetTextData((LPTEXTLINE)lpLine, (LPSTR)cBuf);
780: FrameTools_FB_SetEditText(lpOutlineDoc->m_lpFrameTools, (LPSTR)cBuf);
781: }
782: }
783:
784:
785: /* OutlineDoc_SetFormulaBarEditFocus
786: * ---------------------------------
787: *
788: * Setup for formula bar to gain or loose edit focus.
789: * if gaining focus, setup up special accelerator table and scroll line
790: * into view.
791: * else restore normal accelerator table.
792: */
793: void OutlineDoc_SetFormulaBarEditFocus(
794: LPOUTLINEDOC lpOutlineDoc,
795: BOOL fEditFocus
796: )
797: {
798: LPLINELIST lpLL;
799: int nFocusIndex;
800:
801: if (! lpOutlineDoc || ! lpOutlineDoc->m_lpFrameTools)
802: return;
803:
804: lpOutlineDoc->m_lpFrameTools->m_fInFormulaBar = fEditFocus;
805:
806: if (fEditFocus && lpOutlineDoc->m_lpFrameTools) {
807: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
808:
809: nFocusIndex = LineList_GetFocusLineIndex(lpLL);
810: LineList_ScrollLineIntoView(lpLL, nFocusIndex);
811: FrameTools_FB_FocusEdit(lpOutlineDoc->m_lpFrameTools);
812: }
813:
814: OutlineApp_SetFormulaBarAccel((LPOUTLINEAPP)g_lpApp, fEditFocus);
815: }
816:
817:
818: /* OutlineDoc_IsEditFocusInFormulaBar
819: ** ----------------------------------
820: ** Returns TRUE if edit focus is currently in the formula bar
821: ** else FALSE if not.
822: */
823: BOOL OutlineDoc_IsEditFocusInFormulaBar(LPOUTLINEDOC lpOutlineDoc)
824: {
825: if (! lpOutlineDoc || ! lpOutlineDoc->m_lpFrameTools)
826: return FALSE;
827:
828: return lpOutlineDoc->m_lpFrameTools->m_fInFormulaBar;
829: }
830:
831:
832: /* OutlineDoc_UpdateFrameToolButtons
833: ** ---------------------------------
834: ** Update the Enable/Disable states of the buttons in the formula
835: ** bar and button bar.
836: */
837: void OutlineDoc_UpdateFrameToolButtons(LPOUTLINEDOC lpOutlineDoc)
838: {
839: if (! lpOutlineDoc || ! lpOutlineDoc->m_lpFrameTools)
840: return;
841: FrameTools_UpdateButtons(lpOutlineDoc->m_lpFrameTools, lpOutlineDoc);
842: }
843: #endif // USE_FRAMETOOLS
844:
845:
846: /* OutlineDoc_EditLineCommand
847: * --------------------------
848: *
849: * Edit the current focus line.
850: */
851: void OutlineDoc_EditLineCommand(LPOUTLINEDOC lpOutlineDoc)
852: {
853: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
854: HDC hDC = LineList_GetDC(lpLL);
855: int nIndex = LineList_GetFocusLineIndex(lpLL);
856: LPLINE lpLine = LineList_GetLine(lpLL, nIndex);
857: int nOrgLineWidthInHimetric = Line_GetTotalWidthInHimetric(lpLine);
858: int nNewLineWidthInHimetric;
859: BOOL fSizeChanged;
860:
861: if (Line_Edit(lpLine, lpOutlineDoc->m_hWndDoc, hDC)) {
862: nNewLineWidthInHimetric = Line_GetTotalWidthInHimetric(lpLine);
863:
864: if (nNewLineWidthInHimetric > nOrgLineWidthInHimetric) {
865: fSizeChanged = LineList_SetMaxLineWidthInHimetric(
866: lpLL,
867: nNewLineWidthInHimetric
868: );
869: } else {
870: fSizeChanged = LineList_RecalcMaxLineWidthInHimetric(
871: lpLL,
872: nOrgLineWidthInHimetric
873: );
874: }
875:
876: #if defined( OLE_SERVER )
877: /* Update Name Table */
878: ServerNameTable_EditLineUpdate(
879: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable,
880: nIndex
881: );
882: #endif
883:
884: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, fSizeChanged);
885:
886: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
887: }
888: LineList_ReleaseDC(lpLL, hDC);
889: }
890:
891:
892: /* OutlineDoc_IndentCommand
893: * ------------------------
894: *
895: * Indent selection of lines
896: */
897: void OutlineDoc_IndentCommand(LPOUTLINEDOC lpOutlineDoc)
898: {
899: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
900: LPLINE lpLine;
901: HDC hDC = LineList_GetDC(lpLL);
902: int i;
903: int nIndex;
904: int nNumSel;
905: LINERANGE lrSel;
906: BOOL fSizeChanged = FALSE;
907:
908: nNumSel=LineList_GetSel(lpLL, (LPLINERANGE)&lrSel);
909:
910: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
911:
912: for(i = 0; i < nNumSel; i++) {
913: nIndex = lrSel.m_nStartLine + i;
914: lpLine=LineList_GetLine(lpLL, nIndex);
915: lpLine=LineList_GetLine(lpLL, lrSel.m_nStartLine + i);
916: Line_Indent(lpLine, hDC);
917: if (LineList_SetMaxLineWidthInHimetric(lpLL,
918: Line_GetTotalWidthInHimetric(lpLine))) {
919: fSizeChanged = TRUE;
920: }
921: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
922:
923: #if defined( OLE_SERVER )
924: /* Update Name Table */
925: ServerNameTable_EditLineUpdate(
926: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable,
927: nIndex
928: );
929: #endif
930:
931: }
932:
933: LineList_ReleaseDC(lpLL, hDC);
934:
935: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, fSizeChanged);
936: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
937: }
938:
939:
940: /* OutlineDoc_UnindentCommand
941: * --------------------------
942: *
943: * Unindent selection of lines
944: */
945: void OutlineDoc_UnindentCommand(LPOUTLINEDOC lpOutlineDoc)
946: {
947: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
948: LPLINE lpLine;
949: HDC hDC = LineList_GetDC(lpLL);
950: int nOrgLineWidthInHimetric;
951: int nOrgMaxLineWidthInHimetric = 0;
952: int i;
953: int nIndex;
954: int nNumSel;
955: LINERANGE lrSel;
956: BOOL fSizeChanged;
957:
958: nNumSel=LineList_GetSel(lpLL, (LPLINERANGE)&lrSel);
959:
960: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
961:
962: for(i = 0; i < nNumSel; i++) {
963: nIndex = lrSel.m_nStartLine + i;
964: lpLine=LineList_GetLine(lpLL, nIndex);
965: nOrgLineWidthInHimetric = Line_GetTotalWidthInHimetric(lpLine);
966: nOrgMaxLineWidthInHimetric =
967: (nOrgLineWidthInHimetric > nOrgMaxLineWidthInHimetric ?
968: nOrgLineWidthInHimetric : nOrgMaxLineWidthInHimetric);
969: Line_Unindent(lpLine, hDC);
970: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
971:
972: #if defined( OLE_SERVER )
973: /* Update Name Table */
974: ServerNameTable_EditLineUpdate(
975: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable,
976: nIndex
977: );
978: #endif
979:
980: }
981:
982: LineList_ReleaseDC(lpLL, hDC);
983:
984: fSizeChanged = LineList_RecalcMaxLineWidthInHimetric(
985: lpLL,
986: nOrgMaxLineWidthInHimetric
987: );
988:
989: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, fSizeChanged);
990: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
991: }
992:
993:
994: /* OutlineDoc_SetLineHeightCommand
995: * -------------------------------
996: *
997: * Set height of the selection of lines
998: */
999: void OutlineDoc_SetLineHeightCommand(LPOUTLINEDOC lpOutlineDoc)
1000: {
1001: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1002: LPLINELIST lpLL;
1003: HDC hDC;
1004: LPLINE lpLine;
1005: int nNewHeight;
1006: int i;
1007: int nIndex;
1008: int nNumSel;
1009: LINERANGE lrSel;
1010: BOOL fSizeChanged;
1011:
1012:
1013: if (!lpOutlineDoc)
1014: return;
1015:
1016: lpLL = &lpOutlineDoc->m_LineList;
1017: nNumSel=LineList_GetSel(lpLL, (LPLINERANGE)&lrSel);
1018: lpLine = LineList_GetLine(lpLL, lrSel.m_nStartLine);
1019: nNewHeight = Line_GetHeightInHimetric(lpLine);
1020:
1021:
1022: DialogBoxParam(
1023: lpOutlineApp->m_hInst,
1024: (LPSTR)"SetLineHeight",
1025: lpOutlineDoc->m_hWndDoc,
1026: (DLGPROC)SetLineHeightDlgProc,
1027: (LPARAM)(LPINT)&nNewHeight
1028: );
1029:
1030: if (nNewHeight == 0)
1031: return; /* user hit cancel */
1032:
1033: hDC = LineList_GetDC(lpLL);
1034:
1035: for (i = 0; i < nNumSel; i++) {
1036: nIndex = lrSel.m_nStartLine + i;
1037: lpLine=LineList_GetLine(lpLL, nIndex);
1038: if (nNewHeight == -1) {
1039: switch (Line_GetLineType(lpLine)) {
1040:
1041: case TEXTLINETYPE:
1042:
1043: TextLine_CalcExtents((LPTEXTLINE)lpLine, hDC);
1044: break;
1045:
1046: #if defined( OLE_CNTR )
1047: case CONTAINERLINETYPE:
1048:
1049: Line_SetHeightInHimetric(lpLine, -1);
1050: break;
1051: #endif
1052:
1053: }
1054: }
1055: else
1056: Line_SetHeightInHimetric(lpLine, nNewHeight);
1057:
1058:
1059: LineList_SetLineHeight(lpLL, nIndex,
1060: Line_GetHeightInHimetric(lpLine));
1061: }
1062:
1063: LineList_ReleaseDC(lpLL, hDC);
1064: fSizeChanged = LineList_RecalcMaxLineWidthInHimetric(lpLL, 0);
1065:
1066: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, fSizeChanged);
1067: LineList_ForceRedraw(lpLL, TRUE);
1068: }
1069:
1070:
1071:
1072: /* OutlineDoc_SelectAllCommand
1073: * ---------------------------
1074: *
1075: * Select all the lines in the document.
1076: */
1077: void OutlineDoc_SelectAllCommand(LPOUTLINEDOC lpOutlineDoc)
1078: {
1079: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
1080: LINERANGE lrSel;
1081:
1082: lrSel.m_nStartLine = 0;
1083: lrSel.m_nEndLine = LineList_GetCount(lpLL) - 1;
1084: LineList_SetSel(lpLL, &lrSel);
1085: }
1086:
1087:
1088: /* OutlineDoc_DefineNameCommand
1089: * ----------------------------
1090: *
1091: * Define a name in the document
1092: */
1093: void OutlineDoc_DefineNameCommand(LPOUTLINEDOC lpOutlineDoc)
1094: {
1095: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1096:
1097: DialogBoxParam(
1098: lpOutlineApp->m_hInst,
1099: (LPSTR)"DefineName",
1100: lpOutlineDoc->m_hWndDoc,
1101: (DLGPROC)DefineNameDlgProc,
1102: (LPARAM) lpOutlineDoc
1103: );
1104: }
1105:
1106:
1107: /* OutlineDoc_GotoNameCommand
1108: * --------------------------
1109: *
1110: * Goto a predefined name in the document
1111: */
1112: void OutlineDoc_GotoNameCommand(LPOUTLINEDOC lpOutlineDoc)
1113: {
1114: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1115:
1116: DialogBoxParam(
1117: lpOutlineApp->m_hInst,
1118: (LPSTR)"GotoName",
1119: lpOutlineDoc->m_hWndDoc,
1120: (DLGPROC)GotoNameDlgProc,
1121: (LPARAM)lpOutlineDoc
1122: );
1123: }
1124:
1125:
1126: /* OutlineDoc_ShowWindow
1127: * ---------------------
1128: *
1129: * Show the window of the document to the user.
1130: */
1131: void OutlineDoc_ShowWindow(LPOUTLINEDOC lpOutlineDoc)
1132: {
1133: if (! OleDbgVerifySz(lpOutlineDoc->m_docInitType != DOCTYPE_UNKNOWN,
1134: "OutlineDoc_ShowWindow: can't show unitialized document\r\n")) {
1135: return;
1136: }
1137:
1138: #if defined( OLE_VERSION )
1139: // Call OLE version of this function instead
1140: OleDoc_ShowWindow((LPOLEDOC)lpOutlineDoc);
1141: #else
1142: ShowWindow(lpOutlineDoc->m_hWndDoc, SW_SHOWNORMAL);
1143: SetFocus(lpOutlineDoc->m_hWndDoc);
1144: #endif
1145: }
1146:
1147:
1148: #if defined( USE_FRAMETOOLS )
1149:
1150: void OutlineDoc_AddFrameLevelTools(LPOUTLINEDOC lpOutlineDoc)
1151: {
1152: #if defined( INPLACE_CNTR )
1153: // Call OLE In-Place Container version of this function instead
1154: ContainerDoc_AddFrameLevelTools((LPCONTAINERDOC)lpOutlineDoc);
1155:
1156: #else // ! INPLACE_CNTR
1157: RECT rcFrameRect;
1158: BORDERWIDTHS frameToolWidths;
1159:
1160: #if defined( INPLACE_SVR )
1161: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
1162: LPOLEINPLACEFRAME lpTopIPFrame=ServerDoc_GetTopInPlaceFrame(lpServerDoc);
1163:
1164: // if in-place active, add our tools to our in-place container's frame.
1165: if (lpTopIPFrame) {
1166: ServerDoc_AddFrameLevelTools(lpServerDoc);
1167: return;
1168: }
1169: #endif // INPLACE_SVR
1170:
1171: OutlineApp_GetFrameRect(g_lpApp, (LPRECT)&rcFrameRect);
1172: FrameTools_GetRequiredBorderSpace(
1173: lpOutlineDoc->m_lpFrameTools,
1174: (LPBORDERWIDTHS)&frameToolWidths
1175: );
1176: OutlineApp_SetBorderSpace(g_lpApp, (LPBORDERWIDTHS)&frameToolWidths);
1177: FrameTools_AttachToFrame(
1178: lpOutlineDoc->m_lpFrameTools, OutlineApp_GetWindow(g_lpApp));
1179: FrameTools_Move(lpOutlineDoc->m_lpFrameTools, (LPRECT)&rcFrameRect);
1180: #endif // ! INPLACE_CNTR
1181:
1182: }
1183:
1184: #endif // USE_FRAMETOOLS
1185:
1186:
1187: /* OutlineDoc_GetWindow
1188: * --------------------
1189: *
1190: * Get the window handle of the document.
1191: */
1192: HWND OutlineDoc_GetWindow(LPOUTLINEDOC lpOutlineDoc)
1193: {
1194: if(! lpOutlineDoc) return NULL;
1195: return lpOutlineDoc->m_hWndDoc;
1196: }
1197:
1198:
1199: /* OutlineDoc_AddLine
1200: * ------------------
1201: *
1202: * Add one line to the Document's LineList
1203: */
1204: void OutlineDoc_AddLine(LPOUTLINEDOC lpOutlineDoc, LPLINE lpLine, int nIndex)
1205: {
1206: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
1207:
1208: LineList_AddLine(lpLL, lpLine, nIndex);
1209:
1210: /* Update Name Table */
1211: OutlineNameTable_AddLineUpdate(lpOutlineDoc->m_lpNameTable, nIndex);
1212:
1213: #if defined( INPLACE_CNTR )
1214: {
1215: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
1216: /* OLE2NOTE: after adding a line we need to
1217: ** update the PosRect of the In-Place active
1218: ** objects (if any) that follow the added line.
1219: ** NOTE: nIndex is index of line before new line.
1220: ** nIndex+1 is index of new line
1221: ** nIndex+2 is index of line after new line.
1222: */
1223: ContainerDoc_UpdateInPlaceObjectRects(lpContainerDoc, nIndex+2);
1224: }
1225: #endif
1226:
1227: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, TRUE);
1228: }
1229:
1230:
1231: /* OutlineDoc_DeleteLine
1232: * ---------------------
1233: *
1234: *
1235: * Delete one line from the document's LineList
1236: */
1237: void OutlineDoc_DeleteLine(LPOUTLINEDOC lpOutlineDoc, int nIndex)
1238: {
1239: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
1240:
1241: LineList_DeleteLine(lpLL, nIndex);
1242:
1243: /* Update Name Table */
1244: OutlineNameTable_DeleteLineUpdate(lpOutlineDoc->m_lpNameTable, nIndex);
1245:
1246: #if defined( INPLACE_CNTR )
1247: {
1248: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
1249: /* OLE2NOTE: after deleting a line we need to
1250: ** update the PosRect of the In-Place active
1251: ** objects (if any).
1252: */
1253: ContainerDoc_UpdateInPlaceObjectRects(lpContainerDoc, nIndex);
1254: }
1255: #endif
1256:
1257: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, TRUE);
1258: }
1259:
1260:
1261: /* OutlineDoc_AddName
1262: * ------------------
1263: *
1264: * Add a Name to the Document's NameTable
1265: */
1266: void OutlineDoc_AddName(LPOUTLINEDOC lpOutlineDoc, LPOUTLINENAME lpOutlineName)
1267: {
1268: LPOUTLINENAMETABLE lpOutlineNameTable = lpOutlineDoc->m_lpNameTable;
1269:
1270: OutlineNameTable_AddName(lpOutlineNameTable, lpOutlineName);
1271:
1272: OutlineDoc_SetModified(lpOutlineDoc, TRUE, FALSE, FALSE);
1273: }
1274:
1275:
1276: /* OutlineDoc_DeleteName
1277: * ---------------------
1278: *
1279: *
1280: * Delete Name from the document's NameTable
1281: */
1282: void OutlineDoc_DeleteName(LPOUTLINEDOC lpOutlineDoc, int nIndex)
1283: {
1284: LPOUTLINENAMETABLE lpOutlineNameTable = lpOutlineDoc->m_lpNameTable;
1285:
1286: OutlineNameTable_DeleteName(lpOutlineNameTable, nIndex);
1287:
1288: OutlineDoc_SetModified(lpOutlineDoc, TRUE, FALSE, FALSE);
1289: }
1290:
1291:
1292: /* OutlineDoc_Destroy
1293: * ------------------
1294: *
1295: * Free all memory that had been allocated for a document.
1296: * this destroys the LineList & NameTable of the document.
1297: */
1298: void OutlineDoc_Destroy(LPOUTLINEDOC lpOutlineDoc)
1299: {
1300: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
1301: #if defined( OLE_VERSION )
1302: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1303: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc;
1304:
1305: if (lpOleDoc->m_fObjIsDestroying)
1306: return; // doc destruction is in progress
1307: #endif // OLE_VERSION
1308:
1309: OLEDBG_BEGIN3("OutlineDoc_Destroy\r\n");
1310:
1311: #if defined( OLE_VERSION )
1312:
1313: /* OLE2NOTE: in order to guarantee that the application does not
1314: ** prematurely exit before the destruction of the document is
1315: ** complete, we intially AddRef the App refcnt later Release it.
1316: ** This initial AddRef is artificial; it simply guarantees that
1317: ** the app object does not get destroyed until the end of this
1318: ** routine.
1319: */
1320: OleApp_AddRef(lpOleApp);
1321:
1322: /* OLE2NOTE: perform processing required for OLE */
1323: OleDoc_Destroy(lpOleDoc);
1324: #endif
1325:
1326: LineList_Destroy(lpLL);
1327: OutlineNameTable_Destroy(lpOutlineDoc->m_lpNameTable);
1328:
1329: #if defined( USE_HEADING )
1330: if (! lpOutlineDoc->m_fDataTransferDoc)
1331: Heading_Destroy((LPHEADING)&lpOutlineDoc->m_heading);
1332: #endif
1333:
1334: #if defined( USE_FRAMETOOLS )
1335: if (! lpOutlineDoc->m_fDataTransferDoc)
1336: FrameTools_AssociateDoc(lpOutlineDoc->m_lpFrameTools, NULL);
1337: #endif // USE_FRAMETOOLS
1338:
1339: DestroyWindow(lpOutlineDoc->m_hWndDoc);
1340: Delete(lpOutlineDoc); // free memory for doc itself
1341:
1342: OleDbgOut1("@@@@ DOC DESTROYED\r\n");
1343:
1344: #if defined( OLE_VERSION )
1345: OleApp_Release(lpOleApp); // release artificial AddRef above
1346: #endif
1347:
1348: OLEDBG_END3
1349: }
1350:
1351:
1352: /* OutlineDoc_ReSize
1353: * -----------------
1354: *
1355: * Resize the document and its components
1356: *
1357: * Parameter:
1358: * lpRect the new size of the document. Use current size if NULL
1359: */
1360: void OutlineDoc_Resize(LPOUTLINEDOC lpOutlineDoc, LPRECT lpRect)
1361: {
1362: RECT rect;
1363: LPLINELIST lpLL;
1364:
1365: #if defined( USE_HEADING )
1366: LPHEADING lphead;
1367: #endif // USE_HEADING
1368:
1369: LPSCALEFACTOR lpscale;
1370: HWND hWndLL;
1371:
1372: if (!lpOutlineDoc)
1373: return;
1374:
1375: lpLL = (LPLINELIST)&lpOutlineDoc->m_LineList;
1376: lpscale = (LPSCALEFACTOR)&lpOutlineDoc->m_scale;
1377: hWndLL = LineList_GetWindow(lpLL);
1378:
1379: if (lpRect) {
1380: CopyRect((LPRECT)&rect, lpRect);
1381: MoveWindow(lpOutlineDoc->m_hWndDoc, rect.left, rect.top,
1382: rect.right-rect.left, rect.bottom-rect.top, TRUE);
1383: }
1384:
1385: GetClientRect(lpOutlineDoc->m_hWndDoc, (LPRECT)&rect);
1386:
1387: #if defined( USE_HEADING )
1388: lphead = OutlineDoc_GetHeading(lpOutlineDoc);
1389: rect.left += Heading_RH_GetWidth(lphead, lpscale);
1390: rect.top += Heading_CH_GetHeight(lphead, lpscale);
1391: #endif // USE_HEADING
1392:
1393: if (lpLL) {
1394: MoveWindow(hWndLL, rect.left, rect.top,
1395: rect.right-rect.left, rect.bottom-rect.top, TRUE);
1396: }
1397:
1398: #if defined( USE_HEADING )
1399: if (lphead)
1400: Heading_Move(lphead, lpOutlineDoc->m_hWndDoc, lpscale);
1401: #endif // USE_HEADING
1402:
1403: #if defined( INPLACE_CNTR )
1404: ContainerDoc_UpdateInPlaceObjectRects((LPCONTAINERDOC)lpOutlineDoc, 0);
1405: #endif
1406: }
1407:
1408:
1409: /* OutlineDoc_GetNameTable
1410: * -----------------------
1411: *
1412: * Get nametable associated with the line list
1413: */
1414: LPOUTLINENAMETABLE OutlineDoc_GetNameTable(LPOUTLINEDOC lpOutlineDoc)
1415: {
1416: if (!lpOutlineDoc)
1417: return NULL;
1418: else
1419: return lpOutlineDoc->m_lpNameTable;
1420: }
1421:
1422:
1423: /* OutlineDoc_GetLineList
1424: * ----------------------
1425: *
1426: * Get listlist associated with the OutlineDoc
1427: */
1428: LPLINELIST OutlineDoc_GetLineList(LPOUTLINEDOC lpOutlineDoc)
1429: {
1430: if (!lpOutlineDoc)
1431: return NULL;
1432: else
1433: return (LPLINELIST)&lpOutlineDoc->m_LineList;
1434: }
1435:
1436:
1437: /* OutlineDoc_GetNameCount
1438: * -----------------------
1439: *
1440: * Return number of names in table
1441: */
1442: int OutlineDoc_GetNameCount(LPOUTLINEDOC lpOutlineDoc)
1443: {
1444: return OutlineNameTable_GetCount(lpOutlineDoc->m_lpNameTable);
1445: }
1446:
1447:
1448: /* OutlineDoc_GetLineCount
1449: * -----------------------
1450: *
1451: * Return number of lines in the LineList
1452: */
1453: int OutlineDoc_GetLineCount(LPOUTLINEDOC lpOutlineDoc)
1454: {
1455: return LineList_GetCount(&lpOutlineDoc->m_LineList);
1456: }
1457:
1458:
1459: /* OutlineDoc_SetFileName
1460: * ----------------------
1461: *
1462: * Set the filename of a document.
1463: *
1464: * OLE2NOTE: If the ServerDoc has a valid filename then, the object is
1465: * registered in the running object table (ROT). if the name of the doc
1466: * changes (eg. via SaveAs) then the previous registration must be revoked
1467: * and the document re-registered under the new name.
1468: */
1469: BOOL OutlineDoc_SetFileName(LPOUTLINEDOC lpOutlineDoc, LPSTR lpszNewFileName, LPSTORAGE lpNewStg)
1470: {
1471: if (! OleDbgVerifySz(lpszNewFileName != NULL,
1472: "Can't reset doc to Untitled!"))
1473: return FALSE;
1474:
1475: #if defined( OLE_CNTR )
1476: {
1477: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
1478:
1479: /* OLE2NOTE: the container version of the application keeps its
1480: ** storage open at all times. if the document's storage is not
1481: ** open, then open it.
1482: */
1483:
1484: if (lpNewStg) {
1485:
1486: /* CASE 1 -- document is being loaded from a file. lpNewStg is
1487: ** still open from the OutlineDoc_LoadFromFile function.
1488: */
1489:
1490: lpOutlineDoc->m_docInitType = DOCTYPE_FROMFILE;
1491:
1492: } else {
1493:
1494: /* CASE 2 -- document is being associated with a valid file
1495: ** that is not yet open. thus we must now open the file.
1496: */
1497:
1498: if (lpOutlineDoc->m_docInitType == DOCTYPE_FROMFILE &&
1499: lstrcmp(lpOutlineDoc->m_szFileName,lpszNewFileName)==0) {
1500:
1501: /* CASE 2a -- new filename is same as current file. if the
1502: ** stg is already open, then the lpStg is still valid.
1503: ** if it is not open, then open it.
1504: */
1505: if (! lpContainerDoc->m_lpStg) {
1506: lpContainerDoc->m_lpStg = OleStdOpenRootStorage(
1507: lpszNewFileName,
1508: STGM_READWRITE | STGM_SHARE_DENY_WRITE
1509: );
1510: if (! lpContainerDoc->m_lpStg) return FALSE;
1511: }
1512:
1513: } else {
1514:
1515: /* CASE 2b -- new filename is NOT same as current file.
1516: ** a SaveAs operation is pending. open the new file and
1517: ** hold the storage pointer in m_lpNewStg. the
1518: ** subsequent call to Doc_SaveToFile will save the
1519: ** document into the new storage pointer and release the
1520: ** old storage pointer.
1521: */
1522:
1523: lpOutlineDoc->m_docInitType = DOCTYPE_FROMFILE;
1524:
1525: lpContainerDoc->m_lpNewStg = OleStdCreateRootStorage(
1526: lpszNewFileName,
1527: STGM_READWRITE | STGM_SHARE_DENY_WRITE | STGM_CREATE
1528: );
1529: if (! lpContainerDoc->m_lpNewStg) return FALSE;
1530: }
1531: }
1532: }
1533: #endif // OLE_CNTR
1534:
1535: if (lpOutlineDoc->m_docInitType != DOCTYPE_FROMFILE ||
1536: lstrcmp(lpOutlineDoc->m_szFileName, lpszNewFileName) != 0) {
1537:
1538: /* A new valid file name is being associated with the document */
1539:
1540: lstrcpy(lpOutlineDoc->m_szFileName, lpszNewFileName);
1541: lpOutlineDoc->m_docInitType = DOCTYPE_FROMFILE;
1542:
1543: // set lpszDocTitle to point to filename without path
1544: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName +
1545: lstrlen(lpOutlineDoc->m_szFileName) - 1;
1546: while (lpOutlineDoc->m_lpszDocTitle > lpOutlineDoc->m_szFileName
1547: && ! IS_FILENAME_DELIM(lpOutlineDoc->m_lpszDocTitle[-1])) {
1548: lpOutlineDoc->m_lpszDocTitle--;
1549: }
1550:
1551: OutlineDoc_SetTitle(lpOutlineDoc);
1552:
1553: #if defined( OLE_VERSION )
1554: {
1555: /* OLE2NOTE: both containers and servers must properly
1556: ** register in the RunningObjectTable. if the document
1557: ** is performing a SaveAs operation, then it must
1558: ** re-register in the ROT with the new moniker. in
1559: ** addition any embedded object, pseudo objects, and/or
1560: ** linking clients must be informed that the document's
1561: ** moniker has changed.
1562: */
1563:
1564: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc;
1565:
1566: if (lpOleDoc->m_lpFileMoniker) {
1567: OleStdRelease((LPUNKNOWN)lpOleDoc->m_lpFileMoniker);
1568: lpOleDoc->m_lpFileMoniker = NULL;
1569: }
1570:
1571: CreateFileMoniker(lpszNewFileName,&lpOleDoc->m_lpFileMoniker);
1572: OleDoc_DocRenamedUpdate(lpOleDoc, lpOleDoc->m_lpFileMoniker);
1573: }
1574: #endif // OLE_VERSION
1575:
1576: }
1577:
1578: return TRUE;
1579: }
1580:
1581:
1582: /* OutlineDoc_SetTitle
1583: * -------------------
1584: *
1585: * Set window text to be current filename.
1586: * The following window hierarchy exits:
1587: * hWndApp
1588: * hWndDoc
1589: * hWndListBox
1590: * The frame window is the window which gets the title.
1591: */
1592: void OutlineDoc_SetTitle(LPOUTLINEDOC lpOutlineDoc)
1593: {
1594: HWND hWnd;
1595: char szText[256];
1596:
1597: if (!lpOutlineDoc->m_hWndDoc) return;
1598: if ((hWnd = GetParent(lpOutlineDoc->m_hWndDoc)) == NULL) return;
1599:
1600: lstrcpy(szText, APPNAME);
1601: lstrcat(szText," - ");
1602: lstrcat(szText, (LPSTR)lpOutlineDoc->m_lpszDocTitle);
1603:
1604: SetWindowText(hWnd,szText);
1605: }
1606:
1607:
1608: /* OutlineDoc_Close
1609: * ----------------
1610: *
1611: * Close active document. If modified, prompt the user if
1612: * he wants to save.
1613: *
1614: * Returns:
1615: * FALSE -- user canceled the closing of the doc.
1616: * TRUE -- the doc was successfully closed
1617: */
1618: BOOL OutlineDoc_Close(LPOUTLINEDOC lpOutlineDoc, DWORD dwSaveOption)
1619: {
1620: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1621:
1622: #if defined( OLE_VERSION )
1623: /* OLE2NOTE: call OLE specific function instead */
1624: return OleDoc_Close((LPOLEDOC)lpOutlineDoc, dwSaveOption);
1625:
1626: #else
1627:
1628: if (! lpOutlineDoc)
1629: return TRUE; // active doc's are already destroyed
1630:
1631: if (! OutlineDoc_CheckSaveChanges(lpOutlineDoc, dwSaveOption))
1632: return FALSE; // abort closing the doc
1633:
1634: OutlineDoc_Destroy(lpOutlineDoc);
1635:
1636: OutlineApp_DocUnlockApp(lpOutlineApp, lpOutlineDoc);
1637:
1638: return TRUE;
1639:
1640: #endif // ! OLE_VERSION
1641: }
1642:
1643:
1644: /* OutlineDoc_CheckSaveChanges
1645: * ---------------------------
1646: *
1647: * Check if the document has been modified. if so, prompt the user if
1648: * the changes should be saved. if yes save them.
1649: * Returns TRUE if the doc is safe to close (user answered Yes or No)
1650: * FALSE if the user canceled the save changes option.
1651: */
1652: BOOL OutlineDoc_CheckSaveChanges(LPOUTLINEDOC lpOutlineDoc, DWORD dwSaveOption)
1653: {
1654: int nResponse;
1655:
1656: if (dwSaveOption == OLECLOSE_NOSAVE) {
1657: return TRUE;
1658: }
1659:
1660: if(! OutlineDoc_IsModified(lpOutlineDoc))
1661: return TRUE; // saving is not necessary
1662:
1663: /* OLE2NOTE: our document is dirty so it needs to be saved. if
1664: ** OLECLOSE_PROMPTSAVE the user should be prompted to see if the
1665: ** document should be saved. is specified but the document is NOT
1666: ** visible to the user, then the user can NOT be prompted. in
1667: ** the situation the document should be saved without prompting.
1668: ** if OLECLOSE_SAVEIFDIRTY is specified then, the document
1669: ** should also be saved without prompting.
1670: */
1671: if (dwSaveOption == OLECLOSE_PROMPTSAVE &&
1672: IsWindowVisible(lpOutlineDoc->m_hWndDoc)) {
1673:
1674: // prompt the user to see if changes should be saved.
1675: nResponse = MessageBox(
1676: g_lpApp->m_hWndApp,
1677: MsgSaveFile,
1678: APPNAME,
1679: MB_ICONQUESTION | MB_YESNOCANCEL
1680: );
1681: if(nResponse==IDCANCEL)
1682: return FALSE; // close is canceled
1683: if(nResponse==IDNO)
1684: return TRUE; // don't save, but is ok to close
1685: } else if (dwSaveOption != OLECLOSE_SAVEIFDIRTY) {
1686: return TRUE; // unknown dwSaveOption; close w/o saving
1687: }
1688:
1689: #if defined( OLE_SERVER )
1690:
1691: if (lpOutlineDoc->m_docInitType == DOCTYPE_EMBEDDED) {
1692: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
1693: HRESULT hrErr;
1694:
1695: /* OLE2NOTE: Update the container before closing without prompting
1696: ** the user. To update the container, we must ask our container
1697: ** to save us.
1698: */
1699: OleDbgAssert(lpServerDoc->m_lpOleClientSite != NULL);
1700: OLEDBG_BEGIN2("IOleClientSite::SaveObject called\r\n")
1701: hrErr = lpServerDoc->m_lpOleClientSite->lpVtbl->SaveObject(
1702: lpServerDoc->m_lpOleClientSite
1703: );
1704: OLEDBG_END2
1705:
1706: if (hrErr != NOERROR) {
1707: OleDbgOutHResult("IOleClientSite::SaveObject returned", hrErr);
1708: return FALSE;
1709: }
1710:
1711: return TRUE; // doc is safe to be closed
1712:
1713: } else
1714:
1715: #endif // OLE_SERVER
1716:
1717: {
1718: return OutlineApp_SaveCommand(g_lpApp);
1719: }
1720: }
1721:
1722:
1723: /* OutlineDoc_IsModified
1724: * ---------------------
1725: *
1726: * Return modify flag of OUTLINEDOC
1727: */
1728: BOOL OutlineDoc_IsModified(LPOUTLINEDOC lpOutlineDoc)
1729: {
1730: if (lpOutlineDoc->m_fModified)
1731: return lpOutlineDoc->m_fModified;
1732:
1733: #if defined( OLE_CNTR )
1734: {
1735: /* OLE2NOTE: if there are OLE objects, then we must ask if any of
1736: ** them are dirty. if so we must consider our document
1737: ** as modified.
1738: */
1739: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
1740: LPLINELIST lpLL;
1741: int nLines;
1742: int nIndex;
1743: LPLINE lpLine;
1744: HRESULT hrErr;
1745:
1746: lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
1747: nLines = LineList_GetCount(lpLL);
1748:
1749: for (nIndex = 0; nIndex < nLines; nIndex++) {
1750: lpLine = LineList_GetLine(lpLL, nIndex);
1751: if (!lpLine)
1752: break;
1753: if (Line_GetLineType(lpLine) == CONTAINERLINETYPE) {
1754: LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
1755: if (lpContainerLine->m_lpPersistStg) {
1756: hrErr = lpContainerLine->m_lpPersistStg->lpVtbl->IsDirty(
1757: lpContainerLine->m_lpPersistStg);
1758: if (hrErr == NOERROR) {
1759: return TRUE;
1760: }
1761: }
1762: }
1763: }
1764: }
1765: #endif
1766: return FALSE;
1767: }
1768:
1769:
1770: /* OutlineDoc_SetModified
1771: * ----------------------
1772: *
1773: * Set the modified flag of the document
1774: *
1775: */
1776: void OutlineDoc_SetModified(LPOUTLINEDOC lpOutlineDoc, BOOL fModified, BOOL fDataChanged, BOOL fSizeChanged)
1777: {
1778: lpOutlineDoc->m_fModified = fModified;
1779:
1780: #if defined( OLE_VERSION )
1781: if (! lpOutlineDoc->m_fDataTransferDoc) {
1782: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc;
1783: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1784: LPOLEDOC lpClipboardDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc;
1785: #if defined( OLE_SERVER )
1786: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
1787:
1788: /* OLE2NOTE: if the document has changed, then broadcast the change
1789: ** to all clients who have set up Advise connections. notify
1790: ** them that our data (and possibly also our extents) have
1791: ** changed.
1792: */
1793: if (fDataChanged) {
1794: lpServerDoc->m_fDataChanged = TRUE;
1795: lpServerDoc->m_fSizeChanged = fSizeChanged;
1796: lpServerDoc->m_fSendDataOnStop = TRUE;
1797:
1798: ServerDoc_SendAdvise(
1799: lpServerDoc,
1800: OLE_ONDATACHANGE,
1801: NULL, /* lpmkDoc -- not relevant here */
1802: 0 /* advf -- no flags necessary */
1803: );
1804: }
1805: #endif // OLE_SERVER
1806:
1807: /* OLE2NOTE: if the document that is the source of data on the
1808: ** clipborad has been edited, then the copied data is no
1809: ** longer considered a valid potential link source. disable
1810: ** the offering of CF_LINKSOURCE from the clipboard
1811: ** document. this avoids problems that arise when the
1812: ** editing operation changes or deletes the original data
1813: ** copied.
1814: */
1815: if (lpClipboardDoc
1816: && fDataChanged // line data has changed
1817: && lpClipboardDoc->m_lpSrcDocOfCopy == (LPOLEDOC)lpOutlineDoc) {
1818: lpClipboardDoc->m_fLinkSourceAvail = FALSE;
1819:
1820: /* OLE2NOTE: since we are changing the list of formats on
1821: ** the clipboard (ie. removing CF_LINKSOURCE), we must
1822: ** call OleSetClipboard again. to be sure that the
1823: ** clipboard datatransfer document object does not get
1824: ** destroyed we will guard the call to OleSetClipboard
1825: ** within a pair of AddRef/Release.
1826: */
1827: OleDoc_AddRef((LPOLEDOC)lpClipboardDoc); // guard obj life-time
1828:
1829: OLEDBG_BEGIN2("OleSetClipboard called\r\n")
1830: OleSetClipboard(
1831: (LPDATAOBJECT)&((LPOLEDOC)lpClipboardDoc)->m_DataObject);
1832: OLEDBG_END2
1833:
1834: OleDoc_Release((LPOLEDOC)lpClipboardDoc); // rel. AddRef above
1835: }
1836: }
1837: #endif // OLE_VERSION
1838: }
1839:
1840:
1841: /* OutlineDoc_SetRedraw
1842: * --------------------
1843: *
1844: * Enable/Disable the redraw of the document on screen.
1845: * The calls to SetRedraw counted so that nested calls can be handled
1846: * properly. calls to SetRedraw must be balanced.
1847: *
1848: * fEnbaleDraw = TRUE - enable redraw
1849: * FALSE - disable redraw
1850: */
1851: void OutlineDoc_SetRedraw(LPOUTLINEDOC lpOutlineDoc, BOOL fEnableDraw)
1852: {
1853: static HCURSOR hPrevCursor = NULL;
1854:
1855: if (fEnableDraw) {
1856: if (lpOutlineDoc->m_nDisableDraw == 0)
1857: return; // already enabled; no state transition
1858:
1859: if (--lpOutlineDoc->m_nDisableDraw > 0)
1860: return; // drawing should still be disabled
1861: } else {
1862: if (lpOutlineDoc->m_nDisableDraw++ > 0)
1863: return; // already disabled; no state transition
1864: }
1865:
1866: if (lpOutlineDoc->m_nDisableDraw > 0) {
1867: // this may take a while, put up hourglass cursor
1868: hPrevCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
1869: } else {
1870: if (hPrevCursor) {
1871: SetCursor(hPrevCursor); // restore original cursor
1872: hPrevCursor = NULL;
1873: }
1874: }
1875:
1876: #if defined( OLE_SERVER )
1877: /* OLE2NOTE: for the Server version, while Redraw is disabled
1878: ** postpone sending advise notifications until Redraw is re-enabled.
1879: */
1880: {
1881: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
1882: LPSERVERNAMETABLE lpServerNameTable =
1883: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable;
1884:
1885: if (lpOutlineDoc->m_nDisableDraw == 0) {
1886: /* drawing is being Enabled. if changes occurred while drawing
1887: ** was disabled, then notify clients now.
1888: */
1889: if (lpServerDoc->m_fDataChanged)
1890: ServerDoc_SendAdvise(
1891: lpServerDoc,
1892: OLE_ONDATACHANGE,
1893: NULL, /* lpmkDoc -- not relevant here */
1894: 0 /* advf -- no flags necessary */
1895: );
1896:
1897: /* OLE2NOTE: send pending change notifications for pseudo objs. */
1898: ServerNameTable_SendPendingAdvises(lpServerNameTable);
1899:
1900: }
1901: }
1902: #endif // OLE_SERVER
1903:
1904: #if defined( OLE_CNTR )
1905: /* OLE2NOTE: for the Container version, while Redraw is disabled
1906: ** postpone updating the extents of OLE objects until Redraw is
1907: ** re-enabled.
1908: */
1909: {
1910: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
1911:
1912: /* Update the extents of any OLE object that is marked that
1913: ** its size may have changed. when an
1914: ** IAdviseSink::OnViewChange notification is received,
1915: ** the corresponding ContainerLine is marked
1916: ** (m_fDoGetExtent==TRUE) and a message
1917: ** (WM_U_UPDATEOBJECTEXTENT) is posted to the document
1918: ** indicating that there are dirty objects.
1919: */
1920: if (lpOutlineDoc->m_nDisableDraw == 0)
1921: ContainerDoc_UpdateExtentOfAllOleObjects(lpContainerDoc);
1922: }
1923: #endif // OLE_CNTR
1924:
1925: // enable/disable redraw of the LineList listbox
1926: LineList_SetRedraw(&lpOutlineDoc->m_LineList, fEnableDraw);
1927: }
1928:
1929:
1930: /* OutlineDoc_SetSel
1931: * -----------------
1932: *
1933: * Set the selection in the documents's LineList
1934: */
1935: void OutlineDoc_SetSel(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel)
1936: {
1937: LineList_SetSel(&lpOutlineDoc->m_LineList, lplrSel);
1938: }
1939:
1940:
1941: /* OutlineDoc_GetSel
1942: * -----------------
1943: *
1944: * Get the selection in the documents's LineList.
1945: *
1946: * Returns the count of items selected
1947: */
1948: int OutlineDoc_GetSel(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel)
1949: {
1950: return LineList_GetSel(&lpOutlineDoc->m_LineList, lplrSel);
1951: }
1952:
1953:
1954: /* OutlineDoc_ForceRedraw
1955: * ----------------------
1956: *
1957: * Force the document window to repaint.
1958: */
1959: void OutlineDoc_ForceRedraw(LPOUTLINEDOC lpOutlineDoc, BOOL fErase)
1960: {
1961: if (!lpOutlineDoc)
1962: return;
1963:
1964: LineList_ForceRedraw(&lpOutlineDoc->m_LineList, fErase);
1965: Heading_CH_ForceRedraw(&lpOutlineDoc->m_heading, fErase);
1966: Heading_RH_ForceRedraw(&lpOutlineDoc->m_heading, fErase);
1967: }
1968:
1969:
1970: /* OutlineDoc_RenderFormat
1971: * -----------------------
1972: *
1973: * Render a clipboard format supported by ClipboardDoc
1974: */
1975: void OutlineDoc_RenderFormat(LPOUTLINEDOC lpOutlineDoc, UINT uFormat)
1976: {
1977: HGLOBAL hData = NULL;
1978:
1979: if (uFormat == g_lpApp->m_cfOutline)
1980: hData = OutlineDoc_GetOutlineData(lpOutlineDoc, NULL);
1981:
1982: else if (uFormat == CF_TEXT)
1983: hData = OutlineDoc_GetTextData(lpOutlineDoc, NULL);
1984:
1985: else {
1986: OutlineApp_ErrorMessage(g_lpApp, ErrMsgFormatNotSupported);
1987: return;
1988: }
1989:
1990: SetClipboardData(uFormat, hData);
1991: }
1992:
1993:
1994: /* OutlineDoc_RenderAllFormats
1995: * ---------------------------
1996: *
1997: * Render all formats supported by ClipboardDoc
1998: */
1999: void OutlineDoc_RenderAllFormats(LPOUTLINEDOC lpOutlineDoc)
2000: {
2001: HGLOBAL hData = NULL;
2002:
2003: OpenClipboard(lpOutlineDoc->m_hWndDoc);
2004:
2005: hData = OutlineDoc_GetOutlineData(lpOutlineDoc, NULL);
2006: SetClipboardData(g_lpApp->m_cfOutline, hData);
2007:
2008: hData = OutlineDoc_GetTextData(lpOutlineDoc, NULL);
2009: SetClipboardData(CF_TEXT, hData);
2010:
2011: CloseClipboard();
2012: }
2013:
2014:
2015:
2016: /* OutlineDoc_GetOutlineData
2017: * -------------------------
2018: *
2019: * Return a handle to an array of TextLine objects for the desired line
2020: * range.
2021: * NOTE: if lplrSel == NULL, then all lines are returned
2022: *
2023: */
2024: HGLOBAL OutlineDoc_GetOutlineData(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel)
2025: {
2026: HGLOBAL hOutline = NULL;
2027: LPLINELIST lpLL=(LPLINELIST)&lpOutlineDoc->m_LineList;
2028: LPLINE lpLine;
2029: LPTEXTLINE arrLine;
2030: int i;
2031: int nStart = (lplrSel ? lplrSel->m_nStartLine : 0);
2032: int nEnd =(lplrSel ? lplrSel->m_nEndLine : LineList_GetCount(lpLL)-1);
2033: int nLines = nEnd - nStart + 1;
2034: int nCopied = 0;
2035:
2036: hOutline=GlobalAlloc(GMEM_SHARE | GMEM_ZEROINIT,sizeof(TEXTLINE)*nLines);
2037:
2038: if (! hOutline) return NULL;
2039:
2040: arrLine=(LPTEXTLINE)GlobalLock(hOutline);
2041:
2042: for (i = nStart; i <= nEnd; i++) {
2043: lpLine=LineList_GetLine(lpLL, i);
2044: if (Line_GetOutlineData(lpLine, &arrLine[nCopied]))
2045: nCopied++;
2046: }
2047:
2048: GlobalUnlock(hOutline);
2049:
2050: return hOutline;
2051: }
2052:
2053:
2054:
2055: /* OutlineDoc_GetTextData
2056: * ----------------------
2057: *
2058: * Return a handle to an object's data in text form for the desired line
2059: * range.
2060: * NOTE: if lplrSel == NULL, then all lines are returned
2061: *
2062: */
2063: HGLOBAL OutlineDoc_GetTextData(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel)
2064: {
2065: LPLINELIST lpLL=(LPLINELIST)&lpOutlineDoc->m_LineList;
2066: LPLINE lpLine;
2067: HGLOBAL hText = NULL;
2068: LPSTR lpszText = NULL;
2069: DWORD dwMemSize=0;
2070: int i,j;
2071: int nStart = (lplrSel ? lplrSel->m_nStartLine : 0);
2072: int nEnd =(lplrSel ? lplrSel->m_nEndLine : LineList_GetCount(lpLL)-1);
2073: int nTabLevel;
2074:
2075: // calculate memory size required
2076: for(i = nStart; i <= nEnd; i++) {
2077: lpLine=LineList_GetLine(lpLL, i);
2078:
2079: dwMemSize += Line_GetTabLevel(lpLine);
2080: dwMemSize += Line_GetTextLen(lpLine);
2081:
2082: dwMemSize += 2; // add 1 for '\r\n' at the end of each line
2083: }
2084: dwMemSize++; // add 1 for '\0' at the end of string
2085:
2086: if(!(hText = GlobalAlloc(GMEM_SHARE | GMEM_ZEROINIT, dwMemSize)))
2087: return NULL;
2088:
2089: if(!(lpszText = (LPSTR)GlobalLock(hText)))
2090: return NULL;
2091:
2092: // put line text to memory
2093: for(i = nStart; i <= nEnd; i++) {
2094: lpLine=LineList_GetLine(lpLL, i);
2095:
2096: nTabLevel=Line_GetTabLevel(lpLine);
2097: for(j = 0; j < nTabLevel; j++)
2098: *lpszText++='\t';
2099:
2100: Line_GetTextData(lpLine, lpszText);
2101: while(*lpszText)
2102: lpszText++; // advance to end of string
2103:
2104: *lpszText++ = '\r';
2105: *lpszText++ = '\n';
2106: }
2107:
2108: GlobalUnlock (hText);
2109:
2110: return hText;
2111: }
2112:
2113:
2114: /* OutlineDoc_SaveToFile
2115: * ---------------------
2116: *
2117: * Save the document to a file with the same name as stored in the
2118: * document
2119: */
2120: BOOL OutlineDoc_SaveToFile(LPOUTLINEDOC lpOutlineDoc, LPCSTR lpszFileName, UINT uFormat, BOOL fRemember)
2121: {
2122: #if defined( OLE_CNTR )
2123: // Call OLE container specific function instead
2124: return ContainerDoc_SaveToFile(
2125: (LPCONTAINERDOC)lpOutlineDoc,
2126: lpszFileName,
2127: uFormat,
2128: fRemember
2129: );
2130:
2131: #else
2132:
2133: LPSTORAGE lpDestStg = NULL;
2134: HRESULT hrErr;
2135: BOOL fStatus;
2136:
2137: if (fRemember) {
2138: if (lpszFileName) {
2139: fStatus = OutlineDoc_SetFileName(
2140: lpOutlineDoc,
2141: (LPSTR)lpszFileName,
2142: NULL
2143: );
2144: if (! fStatus) goto error;
2145: } else
2146: lpszFileName = lpOutlineDoc->m_szFileName; // use cur. file name
2147: } else if (! lpszFileName) {
2148: goto error;
2149: }
2150:
2151: hrErr = StgCreateDocfile(
2152: lpszFileName,
2153: STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE|STGM_CREATE,
2154: 0,
2155: &lpDestStg
2156: );
2157:
2158: if (! OleDbgVerifySz(hrErr == NOERROR, "Could not create Docfile"))
2159: goto error;
2160:
2161: #if defined( OLE_SERVER )
2162:
2163: /* OLE2NOTE: we must be sure to write our class ID into our
2164: ** storage. this information is used by OLE to determine the
2165: ** class of the data stored in our storage. Even for top
2166: ** "file-level" objects this information should be written to
2167: ** the file.
2168: */
2169: if(WriteClassStg(lpDestStg, &CLSID_APP) != NOERROR)
2170: goto error;
2171: #endif
2172:
2173: fStatus = OutlineDoc_SaveSelToStg(
2174: lpOutlineDoc,
2175: NULL,
2176: uFormat,
2177: lpDestStg,
2178: fRemember
2179: );
2180: if (! fStatus) goto error;
2181:
2182: OleStdRelease((LPUNKNOWN)lpDestStg);
2183:
2184: if (fRemember)
2185: OutlineDoc_SetModified(lpOutlineDoc, FALSE, FALSE, FALSE);
2186:
2187: #if defined( OLE_SERVER )
2188:
2189: /* OLE2NOTE: (SERVER-ONLY) inform any linking clients that the
2190: ** document has been saved. in addition, any currently active
2191: ** pseudo objects should also inform their clients.
2192: */
2193: ServerDoc_SendAdvise (
2194: (LPSERVERDOC)lpOutlineDoc,
2195: OLE_ONSAVE,
2196: NULL, /* lpmkDoc -- not relevant here */
2197: 0 /* advf -- not relevant here */
2198: );
2199:
2200: #endif
2201:
2202: return TRUE;
2203:
2204: error:
2205: if (lpDestStg)
2206: OleStdRelease((LPUNKNOWN)lpDestStg);
2207:
2208: OutlineApp_ErrorMessage(g_lpApp, ErrMsgSaving);
2209: return FALSE;
2210:
2211: #endif // ! OLE_CNTR
2212: }
2213:
2214:
2215: /* OutlineDoc_LoadFromFile
2216: * -----------------------
2217: *
2218: * Load a document from a file
2219: */
2220: BOOL OutlineDoc_LoadFromFile(LPOUTLINEDOC lpOutlineDoc, LPSTR lpszFileName)
2221: {
2222: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
2223: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
2224: HRESULT hrErr;
2225: SCODE sc;
2226: LPSTORAGE lpSrcStg;
2227: BOOL fStatus;
2228:
2229: hrErr = StgOpenStorage(lpszFileName,
2230: NULL,
2231: #if defined( OLE_CNTR )
2232: STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE,
2233: #else
2234: STGM_READ | STGM_SHARE_DENY_WRITE,
2235: #endif
2236: NULL,
2237: 0,
2238: &lpSrcStg
2239: );
2240:
2241: if ((sc = GetScode(hrErr)) == STG_E_FILENOTFOUND) {
2242: OutlineApp_ErrorMessage(lpOutlineApp, "File not found");
2243: return FALSE;
2244: } else if (sc == STG_E_FILEALREADYEXISTS) {
2245: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgFormat);
2246: return FALSE;
2247: } else if (sc != S_OK) {
2248: OleDbgOutScode("StgOpenStorage returned", sc);
2249: OutlineApp_ErrorMessage(
2250: lpOutlineApp,
2251: "File already in use--could not be opened"
2252: );
2253: return FALSE;
2254: }
2255:
2256: if(! OutlineDoc_LoadFromStg(lpOutlineDoc, lpSrcStg)) goto error;
2257:
2258: fStatus = OutlineDoc_SetFileName(lpOutlineDoc, lpszFileName, lpSrcStg);
2259: if (! fStatus) goto error;
2260:
2261: OutlineDoc_ForceRedraw(lpOutlineDoc, TRUE);
2262:
2263: OleStdRelease((LPUNKNOWN)lpSrcStg);
2264:
2265:
2266: return TRUE;
2267:
2268: error:
2269: OleStdRelease((LPUNKNOWN)lpSrcStg);
2270: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgOpening);
2271: // REVIEW: is this the proper error handling here?
2272: return FALSE;
2273: }
2274:
2275:
2276:
2277: /* OutlineDoc_LoadFromStg
2278: * ----------------------
2279: *
2280: * Load entire document from an open IStorage pointer (lpSrcStg)
2281: * Return TRUE if ok, FALSE if error.
2282: */
2283: BOOL OutlineDoc_LoadFromStg(LPOUTLINEDOC lpOutlineDoc, LPSTORAGE lpSrcStg)
2284: {
2285: HRESULT hrErr;
2286: BOOL fStatus;
2287: ULONG nRead;
2288: LINERANGE lrSel = { 0, 0 };
2289: LPSTREAM lpLLStm;
2290: OUTLINEDOCHEADER docRecord;
2291:
2292: hrErr = lpSrcStg->lpVtbl->OpenStream(
2293: lpSrcStg,
2294: "LineList",
2295: NULL,
2296: STGM_READ | STGM_SHARE_EXCLUSIVE,
2297: 0,
2298: &lpLLStm
2299: );
2300:
2301: if (! OleDbgVerifySz(hrErr == NOERROR,"Could not open LineList stream")) {
2302: OleDbgOutHResult("Open LineList Stream returned", hrErr);
2303: goto error;
2304: }
2305:
2306: /* read OutlineDoc header record */
2307: hrErr = lpLLStm->lpVtbl->Read(
2308: lpLLStm,
2309: (LPVOID)&docRecord,
2310: sizeof(OUTLINEDOCHEADER),
2311: &nRead
2312: );
2313:
2314: if (! OleDbgVerifySz(hrErr == NOERROR,
2315: "Could not read LineList header from LineList stream"))
2316: goto error;
2317:
2318: fStatus = OutlineApp_VersionNoCheck(
2319: g_lpApp,
2320: docRecord.m_szFormatName,
2321: docRecord.m_narrAppVersionNo
2322: );
2323:
2324: /* storage is an incompatible version; file can not be read */
2325: if (! fStatus)
2326: goto error;
2327:
2328: lpOutlineDoc->m_heading.m_fShow = docRecord.m_fShowHeading;
2329:
2330: #if defined( OLE_SERVER )
2331: {
2332: // Load ServerDoc specific data
2333: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
2334: #if defined( SVR_TREATAS )
2335: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
2336: CLSID clsid;
2337: CLIPFORMAT cfFmt;
2338: LPSTR lpszType;
2339: #endif // SVR_TREATAS
2340:
2341: lpServerDoc->m_nNextRangeNo = (ULONG)docRecord.m_reserved1;
2342:
2343: #if defined( SVR_TREATAS )
2344: /* OLE2NOTE: if the Server is capable of supporting "TreatAs"
2345: ** (aka. ActivateAs), it must read the class that is written
2346: ** into the storage. if this class is NOT the app's own
2347: ** class ID, then this is a TreatAs operation. the server
2348: ** then must faithfully pretend to be the class that is
2349: ** written into the storage. it must also faithfully write
2350: ** the data back to the storage in the SAME format as is
2351: ** written in the storage.
2352: **
2353: ** SVROUTL and ISVROTL can emulate each other. they have the
2354: ** simplification that they both read/write the identical
2355: ** format. thus for these apps no actual conversion of the
2356: ** native bits is actually required.
2357: */
2358: lpServerDoc->m_clsidTreatAs = CLSID_NULL;
2359: if (OleStdGetTreatAsFmtUserType(&CLSID_APP, lpSrcStg, &clsid,
2360: (CLIPFORMAT FAR*)&cfFmt, (LPSTR FAR*)&lpszType)) {
2361:
2362: if (cfFmt == lpOutlineApp->m_cfOutline) {
2363: // We should perform TreatAs operation
2364: if (lpServerDoc->m_lpszTreatAsType)
2365: OleStdFreeString(lpServerDoc->m_lpszTreatAsType, NULL);
2366:
2367: lpServerDoc->m_clsidTreatAs = clsid;
2368: ((LPOUTLINEDOC)lpServerDoc)->m_cfSaveFormat = cfFmt;
2369: lpServerDoc->m_lpszTreatAsType = lpszType;
2370:
2371: OleDbgOut3("OutlineDoc_LoadFromStg: TreateAs ==> '");
2372: OleDbgOutNoPrefix3(lpServerDoc->m_lpszTreatAsType);
2373: OleDbgOutNoPrefix3("'\r\n");
2374: } else {
2375: // ERROR: we ONLY support TreatAs for CF_OUTLINE format
2376: OleDbgOut("SvrDoc_PStg_InitNew: INVALID TreatAs Format\r\n");
2377: OleStdFreeString(lpszType, NULL);
2378: }
2379: }
2380: #endif // SVR_TREATAS
2381: }
2382: #elif defined( OLE_CNTR )
2383: {
2384: // Load ContainerDoc specific data
2385: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
2386:
2387: lpContainerDoc->m_nNextObjNo = (ULONG)docRecord.m_reserved2;
2388: }
2389: #endif
2390:
2391: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
2392:
2393: if(! LineList_LoadFromStg(&lpOutlineDoc->m_LineList, lpSrcStg, lpLLStm))
2394: goto error;
2395: if(! OutlineNameTable_LoadFromStg(lpOutlineDoc->m_lpNameTable, lpSrcStg))
2396: goto error;
2397:
2398: OutlineDoc_SetModified(lpOutlineDoc, FALSE, FALSE, FALSE);
2399: OutlineDoc_SetSel(lpOutlineDoc, &lrSel);
2400:
2401: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
2402:
2403: OleStdRelease((LPUNKNOWN)lpLLStm);
2404:
2405: #if defined( OLE_CNTR )
2406: {
2407: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
2408:
2409: /* A ContainerDoc keeps its storage open at all times. it is necessary
2410: * to AddRef the lpSrcStg in order to hang on to it.
2411: */
2412: if (lpContainerDoc->m_lpStg) {
2413: OleStdVerifyRelease((LPUNKNOWN)lpContainerDoc->m_lpStg,
2414: "Doc Storage not released properly");
2415: }
2416: lpSrcStg->lpVtbl->AddRef(lpSrcStg);
2417: lpContainerDoc->m_lpStg = lpSrcStg;
2418: }
2419: #endif // OLE_CNTR
2420:
2421: return TRUE;
2422:
2423: error:
2424: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
2425: if (lpLLStm)
2426: OleStdRelease((LPUNKNOWN)lpLLStm);
2427: return FALSE;
2428: }
2429:
2430:
2431: /* OutlineDoc_SaveSelToStg
2432: * -----------------------
2433: *
2434: * Save the specified selection of document into file. All lines
2435: * within the selection along with any names completely contained within the
2436: * selection will be written
2437: *
2438: * Return TRUE if ok, FALSE if error
2439: */
2440: BOOL OutlineDoc_SaveSelToStg(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel, UINT uFormat, LPSTORAGE lpDestStg, BOOL fRemember)
2441: {
2442: HRESULT hrErr = NOERROR;
2443: LPSTREAM lpLLStm = NULL;
2444: ULONG nWritten;
2445: BOOL fStatus;
2446: OUTLINEDOCHEADER docRecord;
2447: HCURSOR hPrevCursor;
2448:
2449: #if defined( OLE_VERSION )
2450: LPSTR lpszUserType;
2451:
2452: /* OLE2NOTE: we must be sure to write the information required for
2453: ** OLE into our docfile. this includes user type
2454: ** name, data format, etc. Even for top "file-level" objects
2455: ** this information should be written to the file. Both
2456: ** containters and servers should write this information.
2457: */
2458:
2459: #if defined( OLE_SERVER ) && defined( SVR_TREATAS )
2460: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
2461:
2462: /* OLE2NOTE: if the Server is emulating another class (ie.
2463: ** "TreatAs" aka. ActivateAs), it must write the same user type
2464: ** name and format that was was originally written into the
2465: ** storage rather than its own user type name.
2466: **
2467: ** SVROUTL and ISVROTL can emulate each other. they have the
2468: ** simplification that they both read/write the identical
2469: ** format. thus for these apps no actual conversion of the
2470: ** native bits is actually required.
2471: */
2472: if (! IsEqualCLSID(&lpServerDoc->m_clsidTreatAs, &CLSID_NULL))
2473: lpszUserType = lpServerDoc->m_lpszTreatAsType;
2474: else
2475: #endif
2476: lpszUserType = (LPSTR)FULLUSERTYPENAME;
2477:
2478:
2479: hrErr = WriteFmtUserTypeStg(
2480: lpDestStg,
2481: uFormat,
2482: lpszUserType
2483: );
2484: if(hrErr != NOERROR) goto error;
2485: #endif // OLE_VERSION
2486:
2487: // this may take a while, put up hourglass cursor
2488: hPrevCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
2489:
2490: hrErr = lpDestStg->lpVtbl->CreateStream(
2491: lpDestStg,
2492: "LineList",
2493: STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
2494: 0,
2495: 0,
2496: &lpLLStm
2497: );
2498: if (! OleDbgVerifySz(hrErr==NOERROR,"Could not create LineList stream"))
2499: goto error;
2500:
2501: _fmemset((LPOUTLINEDOCHEADER)&docRecord,0,sizeof(OUTLINEDOCHEADER));
2502: GetClipboardFormatName(
2503: uFormat,
2504: docRecord.m_szFormatName,
2505: sizeof(docRecord.m_szFormatName)
2506: );
2507: OutlineApp_GetAppVersionNo(g_lpApp, docRecord.m_narrAppVersionNo);
2508:
2509: docRecord.m_fShowHeading = lpOutlineDoc->m_heading.m_fShow;
2510:
2511: #if defined( OLE_SERVER )
2512: {
2513: // Store ServerDoc specific data
2514: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
2515:
2516: docRecord.m_reserved1 = (DWORD)lpServerDoc->m_nNextRangeNo;
2517: }
2518: #elif defined( OLE_CNTR )
2519: {
2520: // Store ContainerDoc specific data
2521: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
2522:
2523: docRecord.m_reserved2 = (DWORD)lpContainerDoc->m_nNextObjNo;
2524: }
2525: #endif
2526:
2527: /* write OutlineDoc header record */
2528: hrErr = lpLLStm->lpVtbl->Write(
2529: lpLLStm,
2530: (LPVOID)&docRecord,
2531: sizeof(OUTLINEDOCHEADER),
2532: &nWritten
2533: );
2534: if (! OleDbgVerifySz(hrErr == NOERROR,
2535: "Could not write OutlineDoc header to LineList stream"))
2536: goto error;
2537:
2538: // Save LineList
2539: /* OLE2NOTE: A ContainerDoc keeps its storage open at all times. It is
2540: ** necessary to pass the current open storage (lpContainerDoc->m_lpStg)
2541: ** to the LineList_SaveSelToStg method so that currently written data
2542: ** for any embeddings is also saved to the new destination
2543: ** storage. The data required by a contained object is both the
2544: ** ContainerLine information and the associated sub-storage that is
2545: ** written directly by the embedded object.
2546: */
2547: fStatus = LineList_SaveSelToStg(
2548: &lpOutlineDoc->m_LineList,
2549: lplrSel,
2550: uFormat,
2551: #if defined( OLE_CNTR )
2552: ((LPCONTAINERDOC)lpOutlineDoc)->m_lpStg,
2553: #else
2554: NULL,
2555: #endif
2556: lpDestStg,
2557: lpLLStm,
2558: fRemember
2559: );
2560: if (! fStatus) goto error;
2561:
2562: // Save associated NameTable
2563: fStatus = OutlineNameTable_SaveSelToStg(
2564: lpOutlineDoc->m_lpNameTable,
2565: lplrSel,
2566: uFormat,
2567: lpDestStg
2568: );
2569:
2570: if (! fStatus) goto error;
2571:
2572: OleStdRelease((LPUNKNOWN)lpLLStm);
2573: lpOutlineDoc->m_cfSaveFormat = uFormat; // remember format used to save
2574:
2575: SetCursor(hPrevCursor); // restore original cursor
2576: return TRUE;
2577:
2578: error:
2579: if (lpLLStm)
2580: OleStdRelease((LPUNKNOWN)lpLLStm);
2581:
2582: SetCursor(hPrevCursor); // restore original cursor
2583: return FALSE;
2584: }
2585:
2586:
2587: /* OutlineDoc_Print
2588: * ----------------
2589: * Prints the contents of the list box in HIMETRIC mapping mode. Origin
2590: * remains to be the upper left corner and the print proceeds down the
2591: * page using a negative y-cordinate.
2592: *
2593: */
2594: void OutlineDoc_Print(LPOUTLINEDOC lpOutlineDoc, HDC hDC)
2595: {
2596: LPLINELIST lpLL = &lpOutlineDoc->m_LineList;
2597: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
2598: WORD nIndex;
2599: WORD nTotal;
2600: int dy;
2601: BOOL fError = FALSE;
2602: LPLINE lpLine;
2603: RECT rcLine;
2604: RECT rcPix;
2605: RECT rcHim;
2606: RECT rcWindowOld;
2607: RECT rcViewportOld;
2608: HFONT hOldFont;
2609: DOCINFO di; /* Document information for StartDoc function */
2610:
2611: /* Get dimension of page */
2612: rcPix.left = 0;
2613: rcPix.top = 0;
2614: rcPix.right = GetDeviceCaps(hDC, HORZRES);
2615: rcPix.bottom = GetDeviceCaps(hDC, VERTRES);
2616:
2617: SetDCToDrawInHimetricRect(hDC, (LPRECT)&rcPix, (LPRECT)&rcHim,
2618: (LPRECT)&rcWindowOld, (LPRECT)&rcViewportOld);
2619:
2620: // Set the default font size, and font face name
2621: hOldFont = SelectObject(hDC, lpOutlineApp->m_hStdFont);
2622:
2623: /* Get the lines in document */
2624: nIndex = 0;
2625: nTotal = LineList_GetCount(lpLL);
2626:
2627: /* Create the Cancel dialog */
2628: // REVIEW: should load dialog title from string resource file
2629: hWndPDlg = CreateDialog (
2630: lpOutlineApp->m_hInst,
2631: "Print",
2632: lpOutlineApp->m_hWndApp,
2633: (DLGPROC)PrintDlgProc
2634: );
2635:
2636: if(!hWndPDlg)
2637: goto getout;
2638:
2639: /* Allow the app. to inform GDI of the abort function to call */
2640: if(SetAbortProc(hDC, (ABORTPROC)AbortProc) < 0) {
2641: fError = TRUE;
2642: goto getout3;
2643: }
2644:
2645: /* Disable the main application window */
2646: EnableWindow (lpOutlineApp->m_hWndApp, FALSE);
2647:
2648: // initialize the rectangle for the first line
2649: rcLine.left = rcHim.left;
2650: rcLine.bottom = rcHim.top;
2651:
2652: /* Initialize the document */
2653: fCancelPrint = FALSE;
2654:
2655: di.cbSize = sizeof(di);
2656: di.lpszDocName = lpOutlineDoc->m_lpszDocTitle;
2657: di.lpszOutput = NULL;
2658:
2659: if(StartDoc(hDC, (DOCINFO FAR*)&di) <= 0) {
2660: fError = TRUE;
2661: OleDbgOut2("StartDoc error\n");
2662: goto getout5;
2663: }
2664:
2665: if(StartPage(hDC) <= 0) { // start first page
2666: fError = TRUE;
2667: OleDbgOut2("StartPage error\n");
2668: goto getout2;
2669: }
2670:
2671: /* While more lines print out the text */
2672: while(nIndex < nTotal) {
2673: lpLine = LineList_GetLine(lpLL, nIndex);
2674: dy = Line_GetHeightInHimetric(lpLine);
2675:
2676: /* Reached end of page. Tell the device driver to eject a page */
2677: if(rcLine.bottom - dy < rcHim.bottom) {
2678: if (EndPage(hDC) < 0) {
2679: fError=TRUE;
2680: OleDbgOut2("EndPage error\n");
2681: goto getout2;
2682: }
2683:
2684: // NOTE: Reset the Mapping mode of DC
2685: SetDCToDrawInHimetricRect(hDC, (LPRECT)&rcPix, (LPRECT)&rcHim,
2686: (LPRECT)&rcWindowOld, (LPRECT)&rcViewportOld);
2687:
2688: // Set the default font size, and font face name
2689: SelectObject(hDC, lpOutlineApp->m_hStdFont);
2690:
2691: if (StartPage(hDC) <= 0) {
2692: fError=TRUE;
2693: OleDbgOut2("StartPage error\n");
2694: goto getout2;
2695: }
2696:
2697: rcLine.bottom = rcHim.top;
2698: }
2699:
2700: rcLine.top = rcLine.bottom;
2701: rcLine.bottom -= dy;
2702: rcLine.right = rcLine.left + Line_GetWidthInHimetric(lpLine);
2703:
2704: /* Print the line */
2705: Line_Draw(lpLine, hDC, &rcLine);
2706:
2707: OleDbgOut2("a line is drawn\n");
2708:
2709: /* Test and see if the Abort flag has been set. If yes, exit. */
2710: if (fCancelPrint)
2711: goto getout2;
2712:
2713: /* Move down the page */
2714: nIndex++;
2715: }
2716:
2717: {
2718: char szBuf[255];
2719: int nCode;
2720:
2721: /* Eject the last page. */
2722: if((nCode = EndPage(hDC)) < 0) {
2723: wsprintf(szBuf, "EndPage error code is %d\n", nCode);
2724: OleDbgOut2(szBuf);
2725: fError=TRUE;
2726: goto getout2;
2727: }
2728: }
2729:
2730:
2731: /* Complete the document. */
2732: if(EndDoc(hDC) < 0) {
2733: fError=TRUE;
2734: OleDbgOut2("EndDoc error\n");
2735:
2736: getout2:
2737: /* Ran into a problem before NEWFRAME? Abort the document */
2738: AbortDoc(hDC);
2739: }
2740:
2741: getout5:
2742: /* Re-enable main app. window */
2743: EnableWindow (lpOutlineApp->m_hWndApp, TRUE);
2744:
2745: getout3:
2746: /* Close the cancel dialog */
2747: DestroyWindow (hWndPDlg);
2748:
2749: getout:
2750:
2751: /* Error? make sure the user knows... */
2752: if(fError || CommDlgExtendedError())
2753: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgPrint);
2754:
2755: SelectObject(hDC, hOldFont);
2756: }
2757:
2758:
2759:
2760:
2761:
2762: /* OutlineDoc_DialogHelp
2763: * ---------------------
2764: *
2765: * Show help message for ole2ui dialogs.
2766: *
2767: * Parameters:
2768: *
2769: * hDlg HWND to the dialog the help message came from - use
2770: * this in the call to WinHelp/MessageBox so that
2771: * activation/focus goes back to the dialog, and not the
2772: * main window.
2773: *
2774: * wParam ID of the dialog (so we know what type of dialog it is).
2775: */
2776: void OutlineDoc_DialogHelp(HWND hDlg,
2777: WPARAM wDlgID)
2778: {
2779:
2780: char szMessageBoxText[64];
2781:
2782: if (!IsWindow(hDlg)) // don't do anything if we've got a bogus hDlg.
2783: return;
2784:
2785: lstrcpy(szMessageBoxText, "Help Message for ");
2786:
2787: switch (wDlgID)
2788: {
2789:
2790: case IDD_CONVERT:
2791: lstrcat(szMessageBoxText, "Convert");
2792: break;
2793:
2794: case IDD_CHANGEICON:
2795: lstrcat(szMessageBoxText, "Change Icon");
2796: break;
2797:
2798: case IDD_INSERTOBJECT:
2799: lstrcat(szMessageBoxText, "Insert Object");
2800: break;
2801:
2802: case IDD_PASTESPECIAL:
2803: lstrcat(szMessageBoxText, "Paste Special");
2804: break;
2805:
2806: case IDD_EDITLINKS:
2807: lstrcat(szMessageBoxText, "Edit Links");
2808: break;
2809:
2810: default:
2811: lstrcat(szMessageBoxText, "Unknown");
2812: break;
2813: }
2814:
2815: lstrcat(szMessageBoxText, " Dialog.");
2816:
2817: // You'd probably really a call to WinHelp here.
2818: MessageBox(hDlg, szMessageBoxText, "Help", MB_OK);
2819:
2820: return;
2821: }
2822:
2823:
2824: /* OutlineDoc_SetCurrentZoomCommand
2825: * --------------------------------
2826: *
2827: * Set current zoom level to be checked in the menu.
2828: * Set the corresponding scalefactor for the document.
2829: */
2830: void OutlineDoc_SetCurrentZoomCommand(
2831: LPOUTLINEDOC lpOutlineDoc,
2832: UINT uCurrentZoom
2833: )
2834: {
2835: SCALEFACTOR scale;
2836:
2837: if (!lpOutlineDoc)
2838: return;
2839:
2840: lpOutlineDoc->m_uCurrentZoom = uCurrentZoom;
2841:
2842: switch (uCurrentZoom) {
2843:
2844: #if !defined( OLE_CNTR )
2845: case IDM_V_ZOOM_400:
2846: scale.dwSxN = (DWORD) 4;
2847: scale.dwSxD = (DWORD) 1;
2848: scale.dwSyN = (DWORD) 4;
2849: scale.dwSyD = (DWORD) 1;
2850: break;
2851:
2852: case IDM_V_ZOOM_300:
2853: scale.dwSxN = (DWORD) 3;
2854: scale.dwSxD = (DWORD) 1;
2855: scale.dwSyN = (DWORD) 3;
2856: scale.dwSyD = (DWORD) 1;
2857: break;
2858:
2859: case IDM_V_ZOOM_200:
2860: scale.dwSxN = (DWORD) 2;
2861: scale.dwSxD = (DWORD) 1;
2862: scale.dwSyN = (DWORD) 2;
2863: scale.dwSyD = (DWORD) 1;
2864: break;
2865: #endif // !OLE_CNTR
2866:
2867: case IDM_V_ZOOM_100:
2868: scale.dwSxN = (DWORD) 1;
2869: scale.dwSxD = (DWORD) 1;
2870: scale.dwSyN = (DWORD) 1;
2871: scale.dwSyD = (DWORD) 1;
2872: break;
2873:
2874: case IDM_V_ZOOM_75:
2875: scale.dwSxN = (DWORD) 3;
2876: scale.dwSxD = (DWORD) 4;
2877: scale.dwSyN = (DWORD) 3;
2878: scale.dwSyD = (DWORD) 4;
2879: break;
2880:
2881: case IDM_V_ZOOM_50:
2882: scale.dwSxN = (DWORD) 1;
2883: scale.dwSxD = (DWORD) 2;
2884: scale.dwSyN = (DWORD) 1;
2885: scale.dwSyD = (DWORD) 2;
2886: break;
2887:
2888: case IDM_V_ZOOM_25:
2889: scale.dwSxN = (DWORD) 1;
2890: scale.dwSxD = (DWORD) 4;
2891: scale.dwSyN = (DWORD) 1;
2892: scale.dwSyD = (DWORD) 4;
2893: break;
2894: }
2895:
2896: OutlineDoc_SetScaleFactor(lpOutlineDoc, (LPSCALEFACTOR)&scale, NULL);
2897: }
2898:
2899:
2900: /* OutlineDoc_GetCurrentZoomMenuCheck
2901: * ----------------------------------
2902: *
2903: * Get current zoom level to be checked in the menu.
2904: */
2905: UINT OutlineDoc_GetCurrentZoomMenuCheck(LPOUTLINEDOC lpOutlineDoc)
2906: {
2907: return lpOutlineDoc->m_uCurrentZoom;
2908: }
2909:
2910:
2911: /* OutlineDoc_SetScaleFactor
2912: * -------------------------
2913: *
2914: * Set the scale factor of the document which will affect the
2915: * size of the document on the screen
2916: *
2917: * Parameters:
2918: *
2919: * scale structure containing x and y scales
2920: */
2921: void OutlineDoc_SetScaleFactor(
2922: LPOUTLINEDOC lpOutlineDoc,
2923: LPSCALEFACTOR lpscale,
2924: LPRECT lprcDoc
2925: )
2926: {
2927: LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
2928: HWND hWndLL = LineList_GetWindow(lpLL);
2929:
2930: if (!lpOutlineDoc || !lpscale)
2931: return;
2932:
2933: InvalidateRect(hWndLL, NULL, TRUE);
2934:
2935: lpOutlineDoc->m_scale = *lpscale;
2936: LineList_ReScale((LPLINELIST)&lpOutlineDoc->m_LineList, lpscale);
2937:
2938: #if defined( USE_HEADING )
2939: Heading_ReScale((LPHEADING)&lpOutlineDoc->m_heading, lpscale);
2940: #endif
2941:
2942: OutlineDoc_Resize(lpOutlineDoc, lprcDoc);
2943: }
2944:
2945:
2946: /* OutlineDoc_GetScaleFactor
2947: * -------------------------
2948: *
2949: * Retrieve the scale factor of the document
2950: *
2951: * Parameters:
2952: *
2953: */
2954: LPSCALEFACTOR OutlineDoc_GetScaleFactor(LPOUTLINEDOC lpOutlineDoc)
2955: {
2956: if (!lpOutlineDoc)
2957: return NULL;
2958:
2959: return (LPSCALEFACTOR)&lpOutlineDoc->m_scale;
2960: }
2961:
2962:
2963: /* OutlineDoc_SetCurrentMarginCommand
2964: * ----------------------------------
2965: *
2966: * Set current Margin level to be checked in the menu.
2967: */
2968: void OutlineDoc_SetCurrentMarginCommand(
2969: LPOUTLINEDOC lpOutlineDoc,
2970: UINT uCurrentMargin
2971: )
2972: {
2973: if (!lpOutlineDoc)
2974: return;
2975:
2976: lpOutlineDoc->m_uCurrentMargin = uCurrentMargin;
2977:
2978: switch (uCurrentMargin) {
2979: case IDM_V_SETMARGIN_0:
2980: OutlineDoc_SetMargin(lpOutlineDoc, 0, 0);
2981: break;
2982:
2983: case IDM_V_SETMARGIN_1:
2984: OutlineDoc_SetMargin(lpOutlineDoc, 1000, 1000);
2985: break;
2986:
2987: case IDM_V_SETMARGIN_2:
2988: OutlineDoc_SetMargin(lpOutlineDoc, 2000, 2000);
2989: break;
2990:
2991: case IDM_V_SETMARGIN_3:
2992: OutlineDoc_SetMargin(lpOutlineDoc, 3000, 3000);
2993: break;
2994:
2995: case IDM_V_SETMARGIN_4:
2996: OutlineDoc_SetMargin(lpOutlineDoc, 4000, 4000);
2997: break;
2998: }
2999: }
3000:
3001:
3002: /* OutlineDoc_GetCurrentMarginMenuCheck
3003: * ------------------------------------
3004: *
3005: * Get current Margin level to be checked in the menu.
3006: */
3007: UINT OutlineDoc_GetCurrentMarginMenuCheck(LPOUTLINEDOC lpOutlineDoc)
3008: {
3009: return lpOutlineDoc->m_uCurrentMargin;
3010: }
3011:
3012:
3013: /* OutlineDoc_SetMargin
3014: * --------------------
3015: *
3016: * Set the left and right margin of the document
3017: *
3018: * Parameters:
3019: * nLeftMargin - left margin in Himetric values
3020: * nRightMargin - right margin in Himetric values
3021: */
3022: void OutlineDoc_SetMargin(LPOUTLINEDOC lpOutlineDoc, int nLeftMargin, int nRightMargin)
3023: {
3024: LPLINELIST lpLL;
3025: int nMaxWidthInHim;
3026:
3027: if (!lpOutlineDoc)
3028: return;
3029:
3030: lpOutlineDoc->m_nLeftMargin = nLeftMargin;
3031: lpOutlineDoc->m_nRightMargin = nRightMargin;
3032: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
3033:
3034: // Force recalculation of Horizontal extent
3035: nMaxWidthInHim = LineList_GetMaxLineWidthInHimetric(lpLL);
3036: LineList_SetMaxLineWidthInHimetric(lpLL, -nMaxWidthInHim);
3037:
3038: #if defined( INPLACE_CNTR )
3039: ContainerDoc_UpdateInPlaceObjectRects((LPCONTAINERDOC)lpOutlineDoc, 0);
3040: #endif
3041:
3042: OutlineDoc_ForceRedraw(lpOutlineDoc, TRUE);
3043: }
3044:
3045:
3046: /* OutlineDoc_GetMargin
3047: * --------------------
3048: *
3049: * Get the left and right margin of the document
3050: *
3051: * Parameters:
3052: * nLeftMargin - left margin in Himetric values
3053: * nRightMargin - right margin in Himetric values
3054: *
3055: * Returns:
3056: * low order word - left margin
3057: * high order word - right margin
3058: */
3059: LONG OutlineDoc_GetMargin(LPOUTLINEDOC lpOutlineDoc)
3060: {
3061: if (!lpOutlineDoc)
3062: return 0;
3063:
3064: return MAKELONG(lpOutlineDoc->m_nLeftMargin, lpOutlineDoc->m_nRightMargin);
3065: }
3066:
3067: #if defined( USE_HEADING )
3068:
3069: /* OutlineDoc_GetHeading
3070: * ---------------------
3071: *
3072: * Get Heading Object in OutlineDoc
3073: */
3074: LPHEADING OutlineDoc_GetHeading(LPOUTLINEDOC lpOutlineDoc)
3075: {
3076: if (!lpOutlineDoc || lpOutlineDoc->m_fDataTransferDoc)
3077: return NULL;
3078: else
3079: return (LPHEADING)&lpOutlineDoc->m_heading;
3080: }
3081:
3082:
3083: /* OutlineDoc_ShowHeading
3084: * ----------------------
3085: *
3086: * Show/Hide document row/column headings.
3087: */
3088: void OutlineDoc_ShowHeading(LPOUTLINEDOC lpOutlineDoc, BOOL fShow)
3089: {
3090: LPHEADING lphead = OutlineDoc_GetHeading(lpOutlineDoc);
3091: #if defined( INPLACE_SVR )
3092: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
3093: #endif
3094:
3095: if (! lphead)
3096: return;
3097:
3098: Heading_Show(lphead, fShow);
3099:
3100: #if defined( INPLACE_SVR )
3101: if (lpServerDoc->m_fUIActive) {
3102: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
3103:
3104: /* OLE2NOTE: our extents have NOT changed; only our the size of
3105: ** our object-frame adornments is changing. we can use the
3106: ** current PosRect and ClipRect and simply resize our
3107: ** windows WITHOUT informing our in-place container.
3108: */
3109: ServerDoc_ResizeInPlaceWindow(
3110: lpServerDoc,
3111: (LPRECT)&(lpIPData->rcPosRect),
3112: (LPRECT)&(lpIPData->rcClipRect)
3113: );
3114: } else
3115: #else // !INPLACE_SVR
3116:
3117: OutlineDoc_Resize(lpOutlineDoc, NULL);
3118:
3119: #if defined( INPLACE_CNTR )
3120: ContainerDoc_UpdateInPlaceObjectRects((LPCONTAINERDOC)lpOutlineDoc, 0);
3121: #endif // INPLACE_CNTR
3122:
3123: #endif // INPLACE_SVR
3124:
3125: OutlineDoc_ForceRedraw(lpOutlineDoc, TRUE);
3126: }
3127:
3128: #endif // USE_HEADING
3129:
3130:
3131: /* AbortProc
3132: * ---------
3133: * AborProc is called by GDI print code to check for user abort.
3134: */
3135: BOOL FAR PASCAL EXPORT AbortProc (HDC hdc, WORD reserved)
3136: {
3137: MSG msg;
3138:
3139: /* Allow other apps to run, or get abort messages */
3140: while(! fCancelPrint && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
3141: if(!hWndPDlg || !IsDialogMessage (hWndPDlg, &msg)) {
3142: TranslateMessage (&msg);
3143: DispatchMessage (&msg);
3144: }
3145: }
3146: return !fCancelPrint;
3147: }
3148:
3149:
3150: /* PrintDlgProc
3151: * ------------
3152: * Dialog function for the print cancel dialog box.
3153: *
3154: * RETURNS : TRUE - OK to abort/ not OK to abort
3155: * FALSE - otherwise.
3156: */
3157: BOOL FAR PASCAL EXPORT PrintDlgProc(
3158: HWND hwnd,
3159: WORD msg,
3160: WORD wParam,
3161: LONG lParam
3162: )
3163: {
3164: switch (msg) {
3165: case WM_COMMAND:
3166: /* abort printing if the only button gets hit */
3167: fCancelPrint = TRUE;
3168: return TRUE;
3169: }
3170:
3171: return FALSE;
3172: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.