开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
OUTLINE.H
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：34k
源码类别：

Windows编程

开发平台：

Visual C++

OUTLINE.H：源码内容
  1. /*************************************************************************
  2. **
  3. **    OLE 2 Sample Code
  4. **
  5. **    outline.h
  6. **
  7. **    This file contains file contains data structure defintions,
  8. **    function prototypes, constants, etc. used by the Outline series
  9. **    of sample applications:
  10. **          Outline  -- base version of the app (without OLE functionality)
  11. **          SvrOutl  -- OLE 2.0 Server sample app
  12. **          CntrOutl -- OLE 2.0 Containter (Container) sample app
  13. **          ISvrOtl  -- OLE 2.0 Server sample app
  14. **          CntrOutl -- OLE 2.0 Containter (Container) sample app
  15. **
  16. **    (c) Copyright Microsoft Corp. 1992 - 1996 All Rights Reserved
  17. **
  18. **    For structures which we read from and write to disk we define shadow
  19. **    structures (with the _ONDISK suffix) that allow us to maintain
  20. **    16-bit Windows and Macintosh compatibility.
  21. **
  22. *************************************************************************/
  24. #if !defined( _OUTLINE_H_ )
  25. #define _OUTLINE_H_
  27. #if !defined( RC_INVOKED )
  28. #pragma message ("INCLUDING OUTLINE.H from " __FILE__)
  29. #endif  /* RC_INVOKED */
  31. // use strict ANSI standard (for DVOBJ.H)
  32. #define NONAMELESSUNION
  34. // use system defined bitmap, this line must go before windows.h
  35. #define OEMRESOURCE
  37. #ifdef WIN32
  38. #define EXPORT
  40. #define _fstrchr strchr
  42. #else
  43. #define EXPORT _export
  44. #endif
  46. #define SDI_VERSION         1   // ONLY SDI version is currently supported
  48. #if defined( OLE_SERVER ) || defined( OLE_CNTR )
  49. #define OLE_VERSION         1
  50. #define USE_DRAGDROP        1   // enable drag/drop code in OLE versions
  51. #define USE_MSGFILTER       1   // enable IMessageFilter implementation
  52. #endif
  54. #define USE_HEADING         1   // enable the row/col headings
  55. #define USE_STATUSBAR       1   // enable status bar window
  56. #define USE_FRAMETOOLS      1   // enable the toolbar
  57. #ifndef WIN32   //BUGBUG32
  58. #define USE_CTL3D           1   // enable 3D looking dialogs
  59. #endif
  61. #define STRICT  1
  62. #include <windows.h>
  63. #include <string.h>
  64. #include <commdlg.h>
  65. #include <ole2.h>
  66. #include <olestd.h>
  67. #include "outlrc.h"
  70. #define APPMAJORVERSIONNO   3   // major no. incremented for major releases
  71.                         //  (eg. when an incompatible change is made
  72.                         //  to the storage format)
  73. #define APPMINORVERSIONNO   5   // minor no. incremented for minor releases
  76. /* Definition of SCALEFACTOR */
  77. typedef struct tagSCALEFACTOR {
  78.    ULONG       dwSxN;      // numerator in x direction
  79.    ULONG       dwSxD;      // denominator in x direction
  80.    ULONG       dwSyN;      // numerator in y direction
  81.    ULONG       dwSyD;      // denominator in y direction
  82. } SCALEFACTOR, FAR* LPSCALEFACTOR;
  85. #if defined( USE_FRAMETOOLS )
  86. #include "frametls.h"
  87. #endif
  89. #if defined( USE_HEADING )
  90. #include "heading.h"
  91. #endif
  93. /* max line height (in pixels) allowed in a listbox */
  94. #define LISTBOX_HEIGHT_LIMIT    255
  97. #define MAXSTRLEN   80      // max string len in bytes
  98. #define MAXNAMESIZE 30      // max length of names
  99. #define MAXFORMATSIZE   10  // max length of DEFDOCFORMAT (actually size is 5)
  100. #define TABWIDTH        2000 // 2000 in Himetric units, i.e. 2cm
  101. #define DEFFONTPTSIZE   12
  102. #define DEFFONTSIZE     ((DEFFONTPTSIZE*HIMETRIC_PER_INCH)/PTS_PER_INCH)
  103. #define DEFFONTFACE     "Times New Roman"
  105. #ifdef WIN32S
  106. #define OUTLINEDOCFORMAT    OLESTR("Outline32")     // CF_Outline format name
  107. #else
  108. #define OUTLINEDOCFORMAT    OLESTR("Outline")       // CF_Outline format name
  109. #endif
  111. #define IS_FILENAME_DELIM(c)    ( (c) == '\' || (c) == '/' || (c) == ':' )
  112. // REVIEW: some of these strings should be loaded from a resource file
  113. #define UNTITLED    OLESTR("Outline")   // title used for untitled document
  114. #define HITTESTDELTA    5
  116. /* Macro to get a random integer within a specified range */
  117. #define getrandom( min, max ) ((rand() % (int)(((max)+1) - (min))) + (min))
  120. // REVIEW: should load strings from string resource file
  121. #ifdef TEST32
  123. #define APPFILENAMEFILTER   "Outline Files (*.OLT)|*.olt|All files (*.*)|*.*|"
  124. #define DEFEXTENSION    "olt"           // Default file extension
  126. #else
  128. #define APPFILENAMEFILTER   "Outline Files (*.OLN)|*.oln|All files (*.*)|*.*|"
  129. #define DEFEXTENSION    "oln"           // Default file extension
  131. #endif //TEST32
  133. /* forward type references */
  134. typedef struct tagOUTLINEDOC FAR* LPOUTLINEDOC;
  135. typedef struct tagTEXTLINE FAR* LPTEXTLINE;
  138. typedef enum tagLINETYPE {
  139.    UNKNOWNLINETYPE,
  140.    TEXTLINETYPE,
  141.    CONTAINERLINETYPE
  142. } LINETYPE;
  145. /*************************************************************************
  146. ** class LINE
  147. **    The class LINE is an abstract base class. Instances of class LINE
  148. **    are NOT created; only instances of the concrete subclasses of
  149. **    LINE can be created. In the base app version and the OLE 2.0
  150. **    server-only version only TEXTLINE objects can be created. In the
  151. **    OLE 2.0 client app version either TEXTLINE objects or CONTAINERLINE
  152. **    objects can be created. The LINE class has all fields and methods
  153. **    that are common independent of which subclass of LINE is used.
  154. **    Each LINE object that is created in added to the LINELIST of the
  155. **    OUTLINEDOC document.
  156. *************************************************************************/
  158. typedef struct tagLINE {
  159.    LINETYPE    m_lineType;
  160.    UINT        m_nTabLevel;
  161.    UINT        m_nTabWidthInHimetric;
  162.    UINT        m_nWidthInHimetric;
  163.    UINT        m_nHeightInHimetric;
  164.    BOOL        m_fSelected;        // does line have selection feedback
  166. #if defined( USE_DRAGDROP )
  167.    BOOL        m_fDragOverLine;    // does line have drop target feedback
  168. #endif
  169. } LINE, FAR* LPLINE;
  171. /* Line methods (functions) */
  172. void Line_Init(LPLINE lpLine, int nTab, HDC hDC);
  173. void Line_Delete(LPLINE lpLine);
  174. BOOL Line_CopyToDoc(LPLINE lpSrcLine, LPOUTLINEDOC lpDestDoc, int nIndex);
  175. BOOL Line_Edit(LPLINE lpLine, HWND hWndDoc, HDC hDC);
  176. void Line_Draw(
  177.       LPLINE      lpLine,
  178.       HDC         hDC,
  179.       LPRECT      lpRect,
  180.       LPRECT      lpRectWBounds,
  181.       BOOL        fHighlight
  182. );
  183. void Line_DrawToScreen(
  184.       LPLINE      lpLine,
  185.       HDC         hDC,
  186.       LPRECT      lprcPix,
  187.       UINT        itemAction,
  188.       UINT        itemState,
  189.       LPRECT      lprcDevice
  190. );
  191. void Line_DrawSelHilight(LPLINE lpLine, HDC hDC, LPRECT lpRect, UINT itemAction, UINT itemState);
  192. void Line_DrawFocusRect(LPLINE lpLine, HDC hDC, LPRECT lpRect, UINT itemAction, UINT itemState);
  193. void Line_Unindent(LPLINE lpLine, HDC hDC);
  194. void Line_Indent(LPLINE lpLine, HDC hDC);
  195. LINETYPE Line_GetLineType(LPLINE lpLine);
  196. UINT Line_GetTotalWidthInHimetric(LPLINE lpLine);
  197. void Line_SetWidthInHimetric(LPLINE lpLine, int nWidth);
  198. UINT Line_GetWidthInHimetric(LPLINE lpLine);
  199. UINT Line_GetHeightInHimetric(LPLINE lpLine);
  200. void Line_SetHeightInHimetric(LPLINE lpLine, int nHeight);
  201. UINT Line_GetTabLevel(LPLINE lpLine);
  202. int Line_GetTextLen(LPLINE lpLine);
  203. void Line_GetTextData(LPLINE lpLine, LPOLESTR lpszBuf);
  204. BOOL Line_GetOutlineData(LPLINE lpLine, LPTEXTLINE lpBuf);
  205. int Line_CalcTabWidthInHimetric(LPLINE lpLine, HDC hDC);
  206. BOOL Line_SaveToStg(LPLINE lpLine, UINT uFormat, LPSTORAGE lpSrcStg, LPSTORAGE lpDestStg, LPSTREAM lpLLStm, BOOL fRemember);
  207. LPLINE Line_LoadFromStg(LPSTORAGE lpSrcStg, LPSTREAM lpLLStm, LPOUTLINEDOC lpDestDoc);
  208. void Line_DrawDragFeedback(LPLINE lpLine, HDC hDC, LPRECT lpRect, UINT itemState );
  209. BOOL Line_IsSelected(LPLINE lpLine);
  212. /*************************************************************************
  213. ** class TEXTLINE : LINE
  214. **    The class TEXTLINE is a concrete subclass of the abstract base
  215. **    class LINE. The TEXTLINE class holds a string that can be edited
  216. **    by the user. In the base app version and the OLE 2.0
  217. **    server-only version only TEXTLINE objects can be created. In the
  218. **    OLE 2.0 client app version either TEXTLINE objects or CONTAINERLINE
  219. **    objects can be created. The TEXTLINE class inherits all fields
  220. **    from the LINE class. This inheritance is achieved by including a
  221. **    member variable of type LINE as the first field in the TEXTLINE
  222. **    structure. Thus a pointer to a TEXTLINE object can be cast to be
  223. **    a pointer to a LINE object.
  224. **    Each TEXTLINE object that is created in added to the LINELIST of
  225. **    the associated OUTLINEDOC document.
  226. *************************************************************************/
  228. typedef struct tagTEXTLINE {
  229.    LINE m_Line;        // TextLine inherits all fields of Line
  231.    UINT m_nLength;
  232.    char m_szText[MAXSTRLEN+1];
  233. } TEXTLINE;
  235. LPTEXTLINE TextLine_Create(HDC hDC, UINT nTab, LPSTR szText);
  236. void TextLine_Init(LPTEXTLINE lpTextLine, int nTab, HDC hDC);
  237. void TextLine_CalcExtents(LPTEXTLINE lpLine, HDC hDC);
  238. void TextLine_SetHeightInHimetric(LPTEXTLINE lpTextLine, int nHeight);
  239. void TextLine_Delete(LPTEXTLINE lpLine);
  240. BOOL TextLine_Edit(LPTEXTLINE lpLine, HWND hWndDoc, HDC hDC);
  241. void TextLine_Draw(
  242.       LPTEXTLINE  lpTextLine,
  243.       HDC         hDC,
  244.       LPRECT      lpRect,
  245.       LPRECT      lpRectWBounds,
  246.       BOOL        fHighlight
  247. );
  248. void TextLine_DrawSelHilight(LPTEXTLINE lpTextLine, HDC hDC, LPRECT lpRect, UINT itemAction, UINT itemState);
  249. BOOL TextLine_Copy(LPTEXTLINE lpSrcLine, LPTEXTLINE lpDestLine);
  250. BOOL TextLine_CopyToDoc(LPTEXTLINE lpSrcLine, LPOUTLINEDOC lpDestDoc, int nIndex);
  251. int TextLine_GetTextLen(LPTEXTLINE lpTextLine);
  252. void TextLine_GetTextData(LPTEXTLINE lpTextLine, LPSTR lpszBuf);
  253. BOOL TextLine_GetOutlineData(LPTEXTLINE lpTextLine, LPTEXTLINE lpBuf);
  254. BOOL TextLine_SaveToStm(LPTEXTLINE lpLine, LPSTREAM lpLLStm);
  255. LPLINE TextLine_LoadFromStg(LPSTORAGE lpSrcStg, LPSTREAM lpLLStm, LPOUTLINEDOC lpDestDoc);
  259. /*************************************************************************
  260. ** class LINERANGE
  261. **    The class LINERANGE is a supporting object used to describe a
  262. **    particular range in an OUTLINEDOC. A range is defined by a starting
  263. **    line index and an ending line index.
  264. *************************************************************************/
  266. typedef struct tagLINERANGE {
  267.    signed short    m_nStartLine;
  268.    signed short    m_nEndLine;
  269. } LINERANGE, FAR* LPLINERANGE;
  272. /*************************************************************************
  273. ** class OUTLINENAME
  274. **    The class OUTLINENAME stores a particular named selection in the
  275. **    OUTLINEDOC document. The NAMETABLE class holds all of the names
  276. **    defined in a particular OUTLINEDOC document. Each OUTLINENAME
  277. **    object has a string as its key and a starting line index and an
  278. **    ending line index for the named range.
  279. *************************************************************************/
  281. typedef struct tagOUTLINENAME {
  282.    OLECHAR         m_szName[MAXNAMESIZE+1];
  283.    signed short    m_nStartLine;  // must be signed for table update
  284.    signed short    m_nEndLine;    // functions to work
  285. } OUTLINENAME, FAR* LPOUTLINENAME;
  287. void OutlineName_SetName(LPOUTLINENAME lpOutlineName, LPOLESTR lpszName);
  288. void OutlineName_SetSel(LPOUTLINENAME lpOutlineName, LPLINERANGE lplrSel, BOOL fRangeModified);
  289. void OutlineName_GetSel(LPOUTLINENAME lpOutlineName, LPLINERANGE lplrSel);
  290. BOOL OutlineName_SaveToStg(LPOUTLINENAME lpOutlineName, LPLINERANGE lplrSel, UINT uFormat, LPSTREAM lpNTStm, BOOL FAR* lpfNameSaved);
  292. BOOL OutlineName_SaveToStg(LPOUTLINENAME lpOutlineName, LPLINERANGE lplrSel, UINT uFormat, LPSTREAM lpNTStm, BOOL FAR* lpfNameSaved);
  293. BOOL OutlineName_LoadFromStg(LPOUTLINENAME lpOutlineName, LPSTREAM lpNTStm);
  296. /*************************************************************************
  297. ** class OUTLINENAMETABLE
  298. **    OUTLINENAMETABLE manages the table of named selections in the
  299. **    OUTLINEDOC document. Each OUTLINENAMETABLE entry has a string as its key
  300. **    and a starting line index and an ending line index for the
  301. **    named range. There is always one instance of OUTLINENAMETABLE for each
  302. **    OUTLINEDOC created.
  303. *************************************************************************/
  305. typedef struct tagOUTLINENAMETABLE {
  306.    HWND        m_hWndListBox;
  307.    int         m_nCount;
  308. } OUTLINENAMETABLE, FAR* LPOUTLINENAMETABLE;
  310. /* OutlineNameTable methods (functions) */
  311. BOOL OutlineNameTable_Init(LPOUTLINENAMETABLE lpOutlineNameTable, LPOUTLINEDOC lpOutlineDoc);
  312. void OutlineNameTable_Destroy(LPOUTLINENAMETABLE lpOutlineNameTable);
  313. void OutlineNameTable_ClearAll(LPOUTLINENAMETABLE lpOutlineNameTable);
  314. LPOUTLINENAME OutlineNameTable_CreateName(LPOUTLINENAMETABLE lpOutlineNameTable);
  315. void OutlineNameTable_AddName(LPOUTLINENAMETABLE lpOutlineNameTable, LPOUTLINENAME lpOutlineName);
  316. void OutlineNameTable_DeleteName(LPOUTLINENAMETABLE lpOutlineNameTable, int nIndex);
  317. int OutlineNameTable_GetNameIndex(LPOUTLINENAMETABLE lpOutlineNameTable, LPOUTLINENAME lpOutlineName);
  318. LPOUTLINENAME OutlineNameTable_GetName(LPOUTLINENAMETABLE lpOutlineNameTable, int nIndex);
  319. LPOUTLINENAME OutlineNameTable_FindName(LPOUTLINENAMETABLE lpOutlineNameTable, LPOLESTR lpszName);
  320. LPOUTLINENAME OutlineNameTable_FindNamedRange(LPOUTLINENAMETABLE lpOutlineNameTable, LPLINERANGE lplrSel);
  321. int OutlineNameTable_GetCount(LPOUTLINENAMETABLE lpOutlineNameTable);
  322. void OutlineNameTable_AddLineUpdate(LPOUTLINENAMETABLE lpOutlineNameTable, int nAddIndex);
  323. void OutlineNameTable_DeleteLineUpdate(LPOUTLINENAMETABLE lpOutlineNameTable, int nDeleteIndex);
  324. BOOL OutlineNameTable_LoadFromStg(LPOUTLINENAMETABLE lpOutlineNameTable, LPSTORAGE lpSrcStg);
  325. BOOL OutlineNameTable_SaveSelToStg(
  326.       LPOUTLINENAMETABLE      lpOutlineNameTable,
  327.       LPLINERANGE             lplrSel,
  328.       UINT                    uFormat,
  329.       LPSTREAM                lpNTStm
  330. );
  333. /*************************************************************************
  334. ** class LINELIST
  335. **    The class LINELIST manages the list of Line objects in the
  336. **    OUTLINEDOC document. This class uses a Window's Owner-draw ListBox
  337. **    to hold the list of LINE objects. There is always one instance of
  338. **    LINELIST for each OUTLINEDOC created.
  339. *************************************************************************/
  341. typedef struct tagLINELIST {
  342.    HWND            m_hWndListBox;  // hWnd of OwnerDraw listbox
  343.    int             m_nNumLines;        // number of lines in LineList
  344.    int             m_nMaxLineWidthInHimetric;  // max width of listbox
  345.    LPOUTLINEDOC    m_lpDoc;        // ptr to associated OutlineDoc
  346.    LINERANGE       m_lrSaveSel;    // selection saved on WM_KILLFOCUS
  348. #if defined( USE_DRAGDROP )
  349.    int             m_iDragOverLine;    // line index w/ drop target feedback
  350. #endif
  351. } LINELIST, FAR* LPLINELIST;
  353. /* LineList methods (functions) */
  354. BOOL LineList_Init(LPLINELIST lpLL, LPOUTLINEDOC lpOutlineDoc);
  355. void LineList_Destroy(LPLINELIST lpLL);
  356. void LineList_AddLine(LPLINELIST lpLL, LPLINE lpLine, int nIndex);
  357. void LineList_DeleteLine(LPLINELIST lpLL, int nIndex);
  358. void LineList_ReplaceLine(LPLINELIST lpLL, LPLINE lpLine, int nIndex);
  359. int LineList_GetLineIndex(LPLINELIST lpLL, LPLINE lpLine);
  360. LPLINE LineList_GetLine(LPLINELIST lpLL, int nIndex);
  361. void LineList_SetFocusLine ( LPLINELIST lpLL, WORD wIndex );
  362. BOOL LineList_GetLineRect(LPLINELIST lpLL, int nIndex, LPRECT lpRect);
  363. int LineList_GetFocusLineIndex(LPLINELIST lpLL);
  364. int LineList_GetCount(LPLINELIST lpLL);
  365. BOOL LineList_SetMaxLineWidthInHimetric(
  366.       LPLINELIST lpLL,
  367.       int nWidthInHimetric
  368. );
  369. void LineList_ScrollLineIntoView(LPLINELIST lpLL, int nIndex);
  370. int LineList_GetMaxLineWidthInHimetric(LPLINELIST lpLL);
  371. BOOL LineList_RecalcMaxLineWidthInHimetric(
  372.       LPLINELIST          lpLL,
  373.       int                 nWidthInHimetric
  374. );
  375. void LineList_CalcSelExtentInHimetric(
  376.       LPLINELIST          lpLL,
  377.       LPLINERANGE         lplrSel,
  378.       LPSIZEL             lpsizel
  379. );
  380. HWND LineList_GetWindow(LPLINELIST lpLL);
  381. HDC LineList_GetDC(LPLINELIST lpLL);
  382. void LineList_ReleaseDC(LPLINELIST lpLL, HDC hDC);
  383. void LineList_SetLineHeight(LPLINELIST lpLL,int nIndex,int nHeightInHimetric);
  384. void LineList_ReScale(LPLINELIST lpLL, LPSCALEFACTOR lpscale);
  385. void LineList_SetSel(LPLINELIST lpLL, LPLINERANGE lplrSel);
  386. int LineList_GetSel(LPLINELIST lpLL, LPLINERANGE lplrSel);
  387. void LineList_RemoveSel(LPLINELIST lpLL);
  388. void LineList_RestoreSel(LPLINELIST lpLL);
  389. void LineList_SetRedraw(LPLINELIST lpLL, BOOL fEnableDraw);
  390. void LineList_ForceRedraw(LPLINELIST lpLL, BOOL fErase);
  391. void LineList_ForceLineRedraw(LPLINELIST lpLL, int nIndex, BOOL fErase);
  392. int LineList_CopySelToDoc(
  393.       LPLINELIST              lpSrcLL,
  394.       LPLINERANGE             lplrSel,
  395.       LPOUTLINEDOC            lpDestDoc
  396. );
  397. BOOL LineList_SaveSelToStg(
  398.       LPLINELIST              lpLL,
  399.       LPLINERANGE             lplrSel,
  400.       UINT                    uFormat,
  401.       LPSTORAGE               lpSrcStg,
  402.       LPSTORAGE               lpDestStg,
  403.       LPSTREAM                lpLLStm,
  404.       BOOL                    fRemember
  405. );
  406. BOOL LineList_LoadFromStg(
  407.       LPLINELIST              lpLL,
  408.       LPSTORAGE               lpSrcStg,
  409.       LPSTREAM                lpLLStm
  410. );
  412. #if defined( USE_DRAGDROP )
  413. void LineList_SetFocusLineFromPointl( LPLINELIST lpLL, POINTL pointl );
  414. void LineList_SetDragOverLineFromPointl ( LPLINELIST lpLL, POINTL pointl );
  415. void LineList_Scroll(LPLINELIST lpLL, DWORD dwScrollDir);
  416. int LineList_GetLineIndexFromPointl(LPLINELIST lpLL, POINTL pointl);
  417. void LineList_RestoreDragFeedback(LPLINELIST lpLL);
  418. #endif
  420. LRESULT FAR PASCAL LineListWndProc(
  421.    HWND   hWnd,
  422.    UINT   Message,
  423.    WPARAM wParam,
  424.    LPARAM lParam
  425. );
  428. // Document initialization type
  429. #define DOCTYPE_UNKNOWN     0   // new doc created but not yet initialized
  430. #define DOCTYPE_NEW         1   // init from scratch (new doc)
  431. #define DOCTYPE_FROMFILE    2   // init from a file (open doc)
  435. /*************************************************************************
  436. ** class OUTLINEDOC
  437. **    There is one instance of the OutlineDoc class created per
  438. **    document open in the app. The SDI version of the app supports one
  439. **    OUTLINEDOC at a time. The MDI version of the app can manage
  440. **    multiple documents at one time.
  441. *************************************************************************/
  443. /* Definition of OUTLINEDOC */
  444. typedef struct tagOUTLINEDOC {
  445.    LINELIST    m_LineList;         // list of lines in the doc
  446.    LPOUTLINENAMETABLE m_lpNameTable;   // table of names in the doc
  447.    HWND        m_hWndDoc;          // client area window for the Doc
  448.    int         m_docInitType;      // is doc new or loaded from a file?
  449.    BOOL        m_fDataTransferDoc; // is doc created for copy | drag/drop
  450.    CLIPFORMAT  m_cfSaveFormat;      // format used to save the doc
  451.    OLECHAR     m_szFileName[256];  // associated file; "(Untitled)" if none
  452.    LPOLESTR    m_lpszDocTitle;     // name of doc to appear in window title
  453.    BOOL        m_fModified;        // is the doc dirty (needs to be saved)?
  454.    UINT        m_nDisableDraw;     // enable/disable updating the display
  455.    SCALEFACTOR m_scale;            // current scale factor of the doc
  456.    int         m_nLeftMargin;      // left margin in Himetric
  457.    int         m_nRightMargin;     // right margin in Himetric
  458.    UINT        m_uCurrentZoom;     // cur. zoom (used for menu checking)
  459.    UINT        m_uCurrentMargin;   // cur. margin (used for menu checking)
  460. #if defined( USE_HEADING )
  461.    HEADING     m_heading;
  462. #endif
  464. #if defined( USE_FRAMETOOLS )
  465.    LPFRAMETOOLS m_lpFrameTools;    // ptr to frame tools used by this doc
  466. #endif
  468. } OUTLINEDOC;
  470. /* OutlineDoc methods (functions) */
  472. BOOL OutlineDoc_Init(LPOUTLINEDOC lpOutlineDoc, BOOL fDataTransferDoc);
  473. BOOL OutlineDoc_InitNewFile(LPOUTLINEDOC lpOutlineDoc);
  474. LPOUTLINENAMETABLE OutlineDoc_CreateNameTable(LPOUTLINEDOC lpOutlineDoc);
  475. void OutlineDoc_Destroy(LPOUTLINEDOC lpOutlineDoc);
  476. BOOL OutlineDoc_Close(LPOUTLINEDOC lpOutlineDoc, DWORD dwSaveOption);
  477. void OutlineDoc_ShowWindow(LPOUTLINEDOC lpOutlineDoc);
  478. void OutlineDoc_FrameWindowResized(
  479.       LPOUTLINEDOC        lpOutlineDoc,
  480.       LPRECT              lprcFrameRect,
  481.       LPBORDERWIDTHS      lpFrameToolWidths
  482. );
  484. void OutlineDoc_ClearCommand(LPOUTLINEDOC lpOutlineDoc);
  485. void OutlineDoc_CutCommand(LPOUTLINEDOC lpOutlineDoc);
  486. void OutlineDoc_CopyCommand(LPOUTLINEDOC lpOutlineDoc);
  487. void OutlineDoc_ClearAllLines(LPOUTLINEDOC lpOutlineDoc);
  488. LPOUTLINEDOC OutlineDoc_CreateDataTransferDoc(LPOUTLINEDOC lpSrcOutlineDoc);
  489. void OutlineDoc_PasteCommand(LPOUTLINEDOC lpOutlineDoc);
  490. int OutlineDoc_PasteOutlineData(LPOUTLINEDOC lpOutlineDoc, HGLOBAL hOutline, int nStartIndex);
  491. int OutlineDoc_PasteTextData(LPOUTLINEDOC lpOutlineDoc, HGLOBAL hText, int nStartIndex);
  492. void OutlineDoc_AddTextLineCommand(LPOUTLINEDOC lpOutlineDoc);
  493. void OutlineDoc_AddTopLineCommand(
  494.       LPOUTLINEDOC        lpOutlineDoc,
  495.       UINT                nHeightInHimetric
  496. );
  497. void OutlineDoc_EditLineCommand(LPOUTLINEDOC lpOutlineDoc);
  498. void OutlineDoc_IndentCommand(LPOUTLINEDOC lpOutlineDoc);
  499. void OutlineDoc_UnindentCommand(LPOUTLINEDOC lpOutlineDoc);
  500. void OutlineDoc_SetLineHeightCommand(LPOUTLINEDOC lpDoc);
  501. void OutlineDoc_SelectAllCommand(LPOUTLINEDOC lpOutlineDoc);
  502. void OutlineDoc_DefineNameCommand(LPOUTLINEDOC lpOutlineDoc);
  503. void OutlineDoc_GotoNameCommand(LPOUTLINEDOC lpOutlineDoc);
  505. void OutlineDoc_Print(LPOUTLINEDOC lpOutlineDoc, HDC hDC);
  506. BOOL OutlineDoc_SaveToFile(LPOUTLINEDOC lpOutlineDoc, LPCOLESTR lpszFileName, UINT uFormat, BOOL fRemember);
  507. void OutlineDoc_AddLine(LPOUTLINEDOC lpOutlineDoc, LPLINE lpLine, int nIndex);
  508. void OutlineDoc_DeleteLine(LPOUTLINEDOC lpOutlineDoc, int nIndex);
  509. void OutlineDoc_AddName(LPOUTLINEDOC lpOutlineDoc, LPOUTLINENAME lpOutlineName);
  510. void OutlineDoc_DeleteName(LPOUTLINEDOC lpOutlineDoc, int nIndex);
  511. void OutlineDoc_Resize(LPOUTLINEDOC lpDoc, LPRECT lpRect);
  512. LPOUTLINENAMETABLE OutlineDoc_GetNameTable(LPOUTLINEDOC lpOutlineDoc);
  513. LPLINELIST OutlineDoc_GetLineList(LPOUTLINEDOC lpOutlineDoc);
  514. int OutlineDoc_GetNameCount(LPOUTLINEDOC lpOutlineDoc);
  515. int OutlineDoc_GetLineCount(LPOUTLINEDOC lpOutlineDoc);
  516. void OutlineDoc_SetTitle(LPOUTLINEDOC lpOutlineDoc, BOOL fMakeUpperCase);
  517. BOOL OutlineDoc_CheckSaveChanges(
  518.       LPOUTLINEDOC        lpOutlineDoc,
  519.       LPDWORD             lpdwSaveOption
  520. );
  521. BOOL OutlineDoc_IsModified(LPOUTLINEDOC lpOutlineDoc);
  522. void OutlineDoc_SetModified(LPOUTLINEDOC lpOutlineDoc, BOOL fModified, BOOL fDataChanged, BOOL fSizeChanged);
  523. void OutlineDoc_SetRedraw(LPOUTLINEDOC lpOutlineDoc, BOOL fEnableDraw);
  524. BOOL OutlineDoc_LoadFromFile(LPOUTLINEDOC lpOutlineDoc, LPOLESTR szFileName);
  525. BOOL OutlineDoc_SaveSelToStg(
  526.       LPOUTLINEDOC        lpOutlineDoc,
  527.       LPLINERANGE         lplrSel,
  528.       UINT                uFormat,
  529.       LPSTORAGE           lpDestStg,
  530.       BOOL                fSameAsLoad,
  531.       BOOL                fRemember
  532. );
  533. BOOL OutlineDoc_LoadFromStg(LPOUTLINEDOC lpOutlineDoc, LPSTORAGE lpSrcStg);
  534. BOOL OutlineDoc_SetFileName(LPOUTLINEDOC lpOutlineDoc, LPOLESTR lpszFileName, LPSTORAGE lpNewStg);
  535. HWND OutlineDoc_GetWindow(LPOUTLINEDOC lpOutlineDoc);
  536. void OutlineDoc_SetSel(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel);
  537. int OutlineDoc_GetSel(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel);
  538. void OutlineDoc_ForceRedraw(LPOUTLINEDOC lpOutlineDoc, BOOL fErase);
  539. void OutlineDoc_RenderFormat(LPOUTLINEDOC lpOutlineDoc, UINT uFormat);
  540. void OutlineDoc_RenderAllFormats(LPOUTLINEDOC lpOutlineDoc);
  541. HGLOBAL OutlineDoc_GetOutlineData(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel);
  542. HGLOBAL OutlineDoc_GetTextData(LPOUTLINEDOC lpOutlineDoc, LPLINERANGE lplrSel);
  543. void OutlineDoc_DialogHelp(HWND hDlg, WPARAM wDlgID);
  544. void OutlineDoc_SetCurrentZoomCommand(
  545.       LPOUTLINEDOC        lpOutlineDoc,
  546.       UINT                uCurrentZoom
  547. );
  548. UINT OutlineDoc_GetCurrentZoomMenuCheck(LPOUTLINEDOC lpOutlineDoc);
  549. void OutlineDoc_SetScaleFactor(
  550.       LPOUTLINEDOC        lpOutlineDoc,
  551.       LPSCALEFACTOR       lpscale,
  552.       LPRECT              lprcDoc
  553. );
  554. LPSCALEFACTOR OutlineDoc_GetScaleFactor(LPOUTLINEDOC lpDoc);
  555. void OutlineDoc_SetCurrentMarginCommand(
  556.       LPOUTLINEDOC        lpOutlineDoc,
  557.       UINT                uCurrentMargin
  558. );
  559. UINT OutlineDoc_GetCurrentMarginMenuCheck(LPOUTLINEDOC lpOutlineDoc);
  560. void OutlineDoc_SetMargin(LPOUTLINEDOC lpDoc, int nLeftMargin, int nRightMargin);
  561. LONG OutlineDoc_GetMargin(LPOUTLINEDOC lpDoc);
  564. #if defined( USE_FRAMETOOLS )
  565. void OutlineDoc_AddFrameLevelTools(LPOUTLINEDOC lpOutlineDoc);
  566. void OutlineDoc_SetFormulaBarEditText(
  567.       LPOUTLINEDOC            lpOutlineDoc,
  568.       LPLINE                  lpLine
  569. );
  570. void OutlineDoc_SetFormulaBarEditFocus(
  571.       LPOUTLINEDOC            lpOutlineDoc,
  572.       BOOL                    fEditFocus
  573. );
  574. BOOL OutlineDoc_IsEditFocusInFormulaBar(LPOUTLINEDOC lpOutlineDoc);
  575. void OutlineDoc_UpdateFrameToolButtons(LPOUTLINEDOC lpOutlineDoc);
  576. #endif  // USE_FRAMETOOLS
  578. #if defined( USE_HEADING )
  579. LPHEADING OutlineDoc_GetHeading(LPOUTLINEDOC lpOutlineDoc);
  580. void OutlineDoc_ShowHeading(LPOUTLINEDOC lpOutlineDoc, BOOL fShow);
  581. #endif  // USE_HEADING
  583. /*************************************************************************
  584. ** class OUTLINEAPP
  585. **    There is one instance of the OUTLINEAPP class created per running
  586. **    application instance. This object holds many fields that could
  587. **    otherwise be organized as global variables.
  588. *************************************************************************/
  590. /* Definition of OUTLINEAPP */
  591. typedef struct tagOUTLINEAPP {
  592.    HWND            m_hWndApp;        // top-level frame window for the App
  593.    HMENU           m_hMenuApp;       // handle to frame level menu for App
  594.    HACCEL          m_hAccelApp;
  595.    HACCEL          m_hAccelFocusEdit;// Accelerator when Edit in Focus
  596.    LPOUTLINEDOC    m_lpDoc;          // main SDI document visible to user
  597.    LPOUTLINEDOC    m_lpClipboardDoc; // hidden doc for snapshot of copied sel
  598.    HWND            m_hWndStatusBar;  // window for the status bar
  599.    HCURSOR         m_hcursorSelCur;  // cursor used to select lines
  600.    HINSTANCE       m_hInst;
  601.    PRINTDLG        m_PrintDlg;
  602.    HFONT           m_hStdFont;       // font used for TextLines
  603.    UINT            m_cfOutline;      // clipboard format for Outline data
  604.    HACCEL          m_hAccel;
  605.    HWND            m_hWndAccelTarget;
  606.    FARPROC         m_ListBoxWndProc; // orig listbox WndProc for subclassing
  608. #if defined ( USE_FRAMETOOLS ) || defined ( INPLACE_CNTR )
  609.    BORDERWIDTHS    m_FrameToolWidths;  // space required by frame-level tools
  610. #endif  // USE_FRAMETOOLS || INPLACE_CNTR
  612. #if defined( USE_FRAMETOOLS )
  613.    FRAMETOOLS      m_frametools;     // frame tools (button & formula bars)
  614. #endif  // USE_FRAMETOOLS
  616. } OUTLINEAPP, FAR* LPOUTLINEAPP;
  618. /* OutlineApp methods (functions) */
  619. BOOL OutlineApp_InitApplication(LPOUTLINEAPP lpOutlineApp, HINSTANCE hInst);
  620. BOOL OutlineApp_InitInstance(LPOUTLINEAPP lpOutlineApp, HINSTANCE hInst, int nCmdShow);
  621. BOOL OutlineApp_ParseCmdLine(LPOUTLINEAPP lpOutlineApp, LPSTR lpszCmdLine, int nCmdShow);
  622. void OutlineApp_Destroy(LPOUTLINEAPP lpOutlineApp);
  623. LPOUTLINEDOC OutlineApp_CreateDoc(
  624.       LPOUTLINEAPP    lpOutlineApp,
  625.       BOOL            fDataTransferDoc
  626. );
  627. HWND OutlineApp_GetWindow(LPOUTLINEAPP lpOutlineApp);
  628. HWND OutlineApp_GetFrameWindow(LPOUTLINEAPP lpOutlineApp);
  629. HINSTANCE OutlineApp_GetInstance(LPOUTLINEAPP lpOutlineApp);
  630. LPOUTLINENAME OutlineApp_CreateName(LPOUTLINEAPP lpOutlineApp);
  631. void OutlineApp_DocUnlockApp(LPOUTLINEAPP lpOutlineApp, LPOUTLINEDOC lpOutlineDoc);
  632. void OutlineApp_InitMenu(LPOUTLINEAPP lpOutlineApp, LPOUTLINEDOC lpDoc, HMENU hMenu);
  633. void OutlineApp_GetFrameRect(LPOUTLINEAPP lpOutlineApp, LPRECT lprcFrameRect);
  634. void OutlineApp_GetClientAreaRect(
  635.       LPOUTLINEAPP        lpOutlineApp,
  636.       LPRECT              lprcClientAreaRect
  637. );
  638. void OutlineApp_GetStatusLineRect(
  639.       LPOUTLINEAPP        lpOutlineApp,
  640.       LPRECT              lprcStatusLineRect
  641. );
  642. void OutlineApp_ResizeWindows(LPOUTLINEAPP lpOutlineApp);
  643. void OutlineApp_ResizeClientArea(LPOUTLINEAPP lpOutlineApp);
  644. void OutlineApp_AboutCommand(LPOUTLINEAPP lpOutlineApp);
  645. void OutlineApp_NewCommand(LPOUTLINEAPP lpOutlineApp);
  646. void OutlineApp_OpenCommand(LPOUTLINEAPP lpOutlineApp);
  647. void OutlineApp_PrintCommand(LPOUTLINEAPP lpOutlineApp);
  648. BOOL OutlineApp_SaveCommand(LPOUTLINEAPP lpOutlineApp);
  649. BOOL OutlineApp_SaveAsCommand(LPOUTLINEAPP lpOutlineApp);
  650. BOOL OutlineApp_CloseAllDocsAndExitCommand(
  651.       LPOUTLINEAPP        lpOutlineApp,
  652.       BOOL                fForceEndSession
  653. );
  654. void OutlineApp_DestroyWindow(LPOUTLINEAPP lpOutlineApp);
  656. #if defined( USE_FRAMETOOLS )
  657. void OutlineApp_SetBorderSpace(
  658.       LPOUTLINEAPP        lpOutlineApp,
  659.       LPBORDERWIDTHS      lpBorderWidths
  660. );
  661. LPFRAMETOOLS OutlineApp_GetFrameTools(LPOUTLINEAPP lpOutlineApp);
  662. void OutlineApp_SetFormulaBarAccel(
  663.       LPOUTLINEAPP            lpOutlineApp,
  664.       BOOL                    fEditFocus
  665. );
  666. #endif  // USE_FRAMETOOLS
  668. void OutlineApp_SetStatusText(LPOUTLINEAPP lpOutlineApp, LPOLESTR lpszMessage);
  669. LPOUTLINEDOC OutlineApp_GetActiveDoc(LPOUTLINEAPP lpOutlineApp);
  670. HMENU OutlineApp_GetMenu(LPOUTLINEAPP lpOutlineApp);
  671. HFONT OutlineApp_GetActiveFont(LPOUTLINEAPP lpOutlineApp);
  672. HDC OutlineApp_GetPrinterDC(LPOUTLINEAPP lpApp);
  673. void OutlineApp_PrinterSetupCommand(LPOUTLINEAPP lpOutlineApp);
  674. void OutlineApp_ErrorMessage(LPOUTLINEAPP lpOutlineApp, LPOLESTR lpszMsg);
  675. void OutlineApp_GetAppVersionNo(LPOUTLINEAPP lpOutlineApp, int narrAppVersionNo[]);
  676. void OutlineApp_GetAppName(LPOUTLINEAPP lpOutlineApp, LPOLESTR lpszAppName);
  677. BOOL OutlineApp_VersionNoCheck(LPOUTLINEAPP lpOutlineApp, LPOLESTR lpszAppName, int narrAppVersionNo[]);
  678. void OutlineApp_SetEditText(LPOUTLINEAPP lpApp);
  679. void OutlineApp_SetFocusEdit(LPOUTLINEAPP lpApp, BOOL bFocusEdit);
  680. BOOL OutlineApp_GetFocusEdit(LPOUTLINEAPP lpApp);
  681. void OutlineApp_ForceRedraw(LPOUTLINEAPP lpOutlineApp, BOOL fErase);
  683. /* struct definition for persistant data storage of OutlineDoc data */
  685. #pragma pack(push, 2)
  686. typedef struct tagOUTLINEDOCHEADER_ONDISK {
  687.         OLECHAR     m_szFormatName[32];
  688.         short       m_narrAppVersionNo[2];
  689.         USHORT      m_fShowHeading;
  690.         DWORD       m_reserved1;            // space reserved for future use
  691.         DWORD       m_reserved2;            // space reserved for future use
  692.         DWORD       m_reserved3;            // space reserved for future use
  693.         DWORD       m_reserved4;            // space reserved for future use
  694. } OUTLINEDOCHEADER_ONDISK, FAR* LPOUTLINEDOCHEADER_ONDISK;
  695. #pragma pack(pop)
  697. typedef struct tagOUTLINEDOCHEADER {
  698.    OLECHAR     m_szFormatName[32];
  699.    int         m_narrAppVersionNo[2];
  700.    BOOL        m_fShowHeading;
  701.    DWORD       m_reserved1;            // space reserved for future use
  702.    DWORD       m_reserved2;            // space reserved for future use
  703.    DWORD       m_reserved3;            // space reserved for future use
  704.    DWORD       m_reserved4;            // space reserved for future use
  705. } OUTLINEDOCHEADER, FAR* LPOUTLINEDOCHEADER;
  707. #pragma pack(push,2)
  708. typedef struct tagLINELISTHEADER_ONDISK {
  709.         USHORT      m_nNumLines;
  710.         DWORD       m_reserved1;            // space reserved for future use
  711.         DWORD       m_reserved2;            // space reserved for future use
  712. } LINELISTHEADER_ONDISK, FAR* LPLINELISTHEADER_ONDISK;
  713. #pragma pack(pop)
  716. typedef struct tagLINELISTHEADER {
  717.    int         m_nNumLines;
  718.    DWORD       m_reserved1;            // space reserved for future use
  719.    DWORD       m_reserved2;            // space reserved for future use
  720. } LINELISTHEADER, FAR* LPLINELISTHEADER;
  722. #pragma pack(push,2)
  723. typedef struct tagLINERECORD_ONDISK {
  724.         USHORT      m_lineType;
  725.         USHORT      m_nTabLevel;
  726.         USHORT      m_nTabWidthInHimetric;
  727.         USHORT      m_nWidthInHimetric;
  728.         USHORT      m_nHeightInHimetric;
  729.         DWORD       m_reserved;         // space reserved for future use
  730. } LINERECORD_ONDISK, FAR* LPLINERECORD_ONDISK;
  731. #pragma pack(pop)
  733. typedef struct tagLINERECORD {
  734.    LINETYPE    m_lineType;
  735.    UINT        m_nTabLevel;
  736.    UINT        m_nTabWidthInHimetric;
  737.    UINT        m_nWidthInHimetric;
  738.    UINT        m_nHeightInHimetric;
  739.    DWORD       m_reserved;         // space reserved for future use
  740. } LINERECORD, FAR* LPLINERECORD;
  743. /* Function prototypes in main.c */
  744. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  745.                   LPSTR lpszCmdLine, int nCmdShow);
  746. BOOL MyTranslateAccelerator(LPMSG lpmsg);
  747. int GetAccelItemCount(HACCEL hAccel);
  749. LRESULT CALLBACK EXPORT AppWndProc(HWND hWnd, UINT Message, WPARAM wParam,
  750.                   LPARAM lParam);
  751. LRESULT CALLBACK EXPORT DocWndProc(HWND hWnd, UINT Message, WPARAM wParam,
  752.                   LPARAM lParam);
  754. /* Function prototypes in outldlgs.c */
  755. BOOL InputTextDlg(HWND hWnd, LPSTR lpszText, LPSTR lpszDlgTitle);
  756. BOOL CALLBACK EXPORT AddEditDlgProc(HWND, UINT, WPARAM, LPARAM);
  757. BOOL CALLBACK EXPORT SetLineHeightDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam);
  758. BOOL CALLBACK EXPORT DefineNameDlgProc(HWND, UINT, WPARAM, LPARAM);
  759. BOOL CALLBACK EXPORT GotoNameDlgProc(HWND, UINT, WPARAM, LPARAM);
  760. void NameDlg_LoadComboBox(LPOUTLINENAMETABLE lpOutlineNameTable,HWND hCombo);
  761. void NameDlg_LoadListBox(LPOUTLINENAMETABLE lpOutlineNameTable,HWND hListBox);
  762. void NameDlg_AddName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, LPOLESTR lpszName, LPLINERANGE lplrSel);
  763. void NameDlg_UpdateName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, int nIndex, LPOLESTR lpszName, LPLINERANGE lplrSel);
  764. void NameDlg_DeleteName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, UINT nIndex);
  765. BOOL CALLBACK EXPORT AboutDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam);
  767. /* Function prototypes in outldata.c */
  768. LPVOID New(DWORD lSize);
  769. void Delete(LPVOID p);
  771. /* Function prototypes in outlprnt.c */
  772. BOOL CALLBACK EXPORT AbortProc (HDC hdc, WORD reserved);
  773. BOOL CALLBACK EXPORT PrintDlgProc(HWND hwnd, WORD msg, WORD wParam, LONG lParam);
  775. /* Function prototypes in debug.c */
  776. void SetDebugLevelCommand(void);
  777. void TraceDebug(HWND, int);
  779. /*************************************************************************
  780. ** DEBUG ASSERTION ROUTINES
  781. *************************************************************************/
  783. #ifdef DBG
  784. #include "assert.h"
  785. #define FnAssert(lpstrExpr, lpstrMsg, lpstrFileName, iLine)     
  786.         (_assert(lpstrMsg ? lpstrMsg : lpstrExpr,               
  787.                  lpstrFileName,                                 
  788.                  iLine), NOERROR)
  789. #endif //DBG
  791. #if defined( OLE_VERSION )
  792. #include "oleoutl.h"
  794. #endif  // OLE_VERSION
  797. #endif // _OUTLINE_H_