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