![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ole.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / h|
Return to ole.h CVS log | Up to [WindowsNT SDKs] / mstools / h |
1.1 root 1: /*****************************************************************************\
2: * *
3: * ole.h - Object Linking and Embedding functions, types, and definitions*
4: * *
5: * Version 1.0 *
6: * *
7: * NOTE: windows.h must be #included first *
8: * *
9: * Copyright (c) 1990-1992, Microsoft Corp. All rights reserved.*
10: * *
11: \*****************************************************************************/
12:
13: #ifndef _INC_OLE
14: #define _INC_OLE
15:
16:
17: #ifdef __cplusplus
18: extern "C" { /* Assume C declarations for C++ */
19: #endif /* __cplusplus */
20:
21: #define OLE_CONST
22:
23: #ifndef WINAPI
24: #define WINAPI FAR PASCAL
25: #endif
26:
27:
28: #define LRESULT LONG
29: #define HGLOBAL HANDLE
30:
31:
32: /* Object types */
33: #define OT_LINK 1L
34: #define OT_EMBEDDED 2L
35: #define OT_STATIC 3L
36:
37: /* activate verbs */
38: #define OLEVERB_PRIMARY 0
39:
40: /* target device info structure */
41: typedef struct _OLETARGETDEVICE
42: {
43: UINT otdDeviceNameOffset;
44: UINT otdDriverNameOffset;
45: UINT otdPortNameOffset;
46: UINT otdExtDevmodeOffset;
47: UINT otdExtDevmodeSize;
48: UINT otdEnvironmentOffset;
49: UINT otdEnvironmentSize;
50: BYTE otdData[1];
51: } OLETARGETDEVICE;
52: typedef OLETARGETDEVICE FAR* LPOLETARGETDEVICE;
53:
54: /* flags used in some methods */
55: #define OF_SET 0x0001
56: #define OF_GET 0x0002
57: #define OF_HANDLER 0x0004
58:
59: /* return codes for OLE functions */
60: typedef enum
61: {
62: OLE_OK, /* 0 Function operated correctly */
63:
64: OLE_WAIT_FOR_RELEASE, /* 1 Command has been initiated, client */
65: /* must wait for release. keep dispatching */
66: /* messages till OLE_RELESE in callback */
67:
68: OLE_BUSY, /* 2 Tried to execute a method while another */
69: /* method is in progress. */
70:
71: OLE_ERROR_PROTECT_ONLY, /* 3 Ole APIs are called in real mode */
72: OLE_ERROR_MEMORY, /* 4 Could not alloc or lock memory */
73: OLE_ERROR_STREAM, /* 5 (OLESTREAM) stream error */
74: OLE_ERROR_STATIC, /* 6 Non static object expected */
75: OLE_ERROR_BLANK, /* 7 Critical data missing */
76: OLE_ERROR_DRAW, /* 8 Error while drawing */
77: OLE_ERROR_METAFILE, /* 9 Invalid metafile */
78: OLE_ERROR_ABORT, /* 10 Client chose to abort metafile drawing */
79: OLE_ERROR_CLIPBOARD, /* 11 Failed to get/set clipboard data */
80: OLE_ERROR_FORMAT, /* 12 Requested format is not available */
81: OLE_ERROR_OBJECT, /* 13 Not a valid object */
82: OLE_ERROR_OPTION, /* 14 Invalid option(link update / render) */
83: OLE_ERROR_PROTOCOL, /* 15 Invalid protocol */
84: OLE_ERROR_ADDRESS, /* 16 One of the pointers is invalid */
85: OLE_ERROR_NOT_EQUAL, /* 17 Objects are not equal */
86: OLE_ERROR_HANDLE, /* 18 Invalid handle encountered */
87: OLE_ERROR_GENERIC, /* 19 Some general error */
88: OLE_ERROR_CLASS, /* 20 Invalid class */
89: OLE_ERROR_SYNTAX, /* 21 Command syntax is invalid */
90: OLE_ERROR_DATATYPE, /* 22 Data format is not supported */
91: OLE_ERROR_PALETTE, /* 23 Invalid color palette */
92: OLE_ERROR_NOT_LINK, /* 24 Not a linked object */
93: OLE_ERROR_NOT_EMPTY, /* 25 Client doc contains objects. */
94: OLE_ERROR_SIZE, /* 26 Incorrect buffer size passed to the api */
95: /* that places some string in caller's */
96: /* buffer */
97:
98: OLE_ERROR_DRIVE, /* 27 Drive letter in doc name is invalid */
99: OLE_ERROR_NETWORK, /* 28 Failed to establish connection to a */
100: /* network share on which the document */
101: /* is located */
102:
103: OLE_ERROR_NAME, /* 29 Invalid name(doc name, object name), */
104: /* etc.. passed to the APIs */
105:
106: OLE_ERROR_TEMPLATE, /* 30 Server failed to load template */
107: OLE_ERROR_NEW, /* 31 Server failed to create new doc */
108: OLE_ERROR_EDIT, /* 32 Server failed to create embedded */
109: /* instance */
110: OLE_ERROR_OPEN, /* 33 Server failed to open document, */
111: /* possible invalid link */
112:
113: OLE_ERROR_NOT_OPEN, /* 34 Object is not open for editing */
114: OLE_ERROR_LAUNCH, /* 35 Failed to launch server */
115: OLE_ERROR_COMM, /* 36 Failed to communicate with server */
116: OLE_ERROR_TERMINATE, /* 37 Error in termination */
117: OLE_ERROR_COMMAND, /* 38 Error in execute */
118: OLE_ERROR_SHOW, /* 39 Error in show */
119: OLE_ERROR_DOVERB, /* 40 Error in sending do verb, or invalid */
120: /* verb */
121: OLE_ERROR_ADVISE_NATIVE, /* 41 Item could be missing */
122: OLE_ERROR_ADVISE_PICT, /* 42 Item could be missing or server doesn't */
123: /* this format. */
124:
125: OLE_ERROR_ADVISE_RENAME, /* 43 Server doesn't support rename */
126: OLE_ERROR_POKE_NATIVE, /* 44 Failure of poking native data to server */
127: OLE_ERROR_REQUEST_NATIVE, /* 45 Server failed to render native data */
128: OLE_ERROR_REQUEST_PICT, /* 46 Server failed to render presentation */
129: /* data */
130: OLE_ERROR_SERVER_BLOCKED, /* 47 Trying to block a blocked server or */
131: /* trying to revoke a blocked server */
132: /* or document */
133:
134: OLE_ERROR_REGISTRATION, /* 48 Server is not registered in regestation */
135: /* data base */
136: OLE_ERROR_ALREADY_REGISTERED,/*49 Trying to register same doc multiple */
137: /* times */
138: OLE_ERROR_TASK, /* 50 Server or client task is invalid */
139: OLE_ERROR_OUTOFDATE, /* 51 Object is out of date */
140: OLE_ERROR_CANT_UPDATE_CLIENT,/* 52 Embed doc's client doesn't accept */
141: /* updates */
142: OLE_ERROR_UPDATE, /* 53 erorr while trying to update */
143: OLE_ERROR_SETDATA_FORMAT, /* 54 Server app doesn't understand the */
144: /* format given to its SetData method */
145: OLE_ERROR_STATIC_FROM_OTHER_OS,/* 55 trying to load a static object created */
146: /* on another Operating System */
147: OLE_ERROR_FILE_VER,
148:
149: /* Following are warnings */
150: OLE_WARN_DELETE_DATA = 1000 /* Caller must delete the data when he is */
151: /* done with it. */
152: } OLESTATUS;
153:
154:
155:
156: /* Codes for CallBack events */
157: typedef enum
158: {
159: OLE_CHANGED, /* 0 */
160: OLE_SAVED, /* 1 */
161: OLE_CLOSED, /* 2 */
162: OLE_RENAMED, /* 3 */
163: OLE_QUERY_PAINT, /* 4 Interruptible paint support */
164: OLE_RELEASE, /* 5 Object is released(asynchronous operation */
165: /* is completed) */
166: OLE_QUERY_RETRY /* 6 Query for retry when server sends busy ACK */
167: } OLE_NOTIFICATION;
168:
169: typedef enum
170: {
171: OLE_NONE, /* 0 no method active */
172: OLE_DELETE, /* 1 object delete */
173: OLE_LNKPASTE, /* 2 PasteLink(auto reconnect) */
174: OLE_EMBPASTE, /* 3 paste(and update) */
175: OLE_SHOW, /* 4 Show */
176: OLE_RUN, /* 5 Run */
177: OLE_ACTIVATE, /* 6 Activate */
178: OLE_UPDATE, /* 7 Update */
179: OLE_CLOSE, /* 8 Close */
180: OLE_RECONNECT, /* 9 Reconnect */
181: OLE_SETUPDATEOPTIONS, /* 10 setting update options */
182: OLE_SERVERUNLAUNCH, /* 11 server is being unlaunched */
183: OLE_LOADFROMSTREAM, /* 12 LoadFromStream(auto reconnect) */
184: OLE_SETDATA, /* 13 OleSetData */
185: OLE_REQUESTDATA, /* 14 OleRequestData */
186: OLE_OTHER, /* 15 other misc async operations */
187: OLE_CREATE, /* 16 create */
188: OLE_CREATEFROMTEMPLATE, /* 17 CreatefromTemplate */
189: OLE_CREATELINKFROMFILE, /* 18 CreateLinkFromFile */
190: OLE_COPYFROMLNK, /* 19 CopyFromLink(auto reconnect) */
191: OLE_CREATEFROMFILE, /* 20 CreateFromFile */
192: OLE_CREATEINVISIBLE /* 21 CreateInvisible */
193: } OLE_RELEASE_METHOD;
194:
195: /* rendering options */
196: typedef enum
197: {
198: olerender_none,
199: olerender_draw,
200: olerender_format
201: } OLEOPT_RENDER;
202:
203: /* standard clipboard format type */
204: typedef WORD OLECLIPFORMAT;
205:
206: /* Link update options */
207: typedef enum
208: {
209: oleupdate_always,
210: oleupdate_onsave,
211: #ifdef OLE_INTERNAL
212: oleupdate_oncall,
213: oleupdate_onclose
214: #else
215: oleupdate_oncall
216: #endif /* OLE_INTERNAL */
217: } OLEOPT_UPDATE;
218:
219: typedef HANDLE HOBJECT;
220: typedef LONG LHSERVER;
221: typedef LONG LHCLIENTDOC;
222: typedef LONG LHSERVERDOC;
223:
224: typedef struct _OLEOBJECT FAR* LPOLEOBJECT;
225: typedef struct _OLESTREAM FAR* LPOLESTREAM;
226: typedef struct _OLECLIENT FAR* LPOLECLIENT;
227:
228:
229: /* object method table definitions. */
230: typedef struct _OLEOBJECTVTBL
231: {
232: void FAR* (CALLBACK* QueryProtocol) (LPOLEOBJECT, LPSTR);
233: OLESTATUS (CALLBACK* Release) (LPOLEOBJECT);
234: OLESTATUS (CALLBACK* Show) (LPOLEOBJECT, BOOL);
235: OLESTATUS (CALLBACK* DoVerb) (LPOLEOBJECT, UINT, BOOL, BOOL);
236: OLESTATUS (CALLBACK* GetData) (LPOLEOBJECT, OLECLIPFORMAT, HANDLE FAR*);
237: OLESTATUS (CALLBACK* SetData) (LPOLEOBJECT, OLECLIPFORMAT, HANDLE);
238: OLESTATUS (CALLBACK* SetTargetDevice) (LPOLEOBJECT, HGLOBAL);
239: OLESTATUS (CALLBACK* SetBounds) (LPOLEOBJECT, OLE_CONST RECT FAR*);
240: OLECLIPFORMAT (CALLBACK* EnumFormats) (LPOLEOBJECT, OLECLIPFORMAT);
241: OLESTATUS (CALLBACK* SetColorScheme) (LPOLEOBJECT, OLE_CONST LOGPALETTE FAR*);
242: /* Server has to implement only the above methods. */
243:
244: #ifndef SERVERONLY
245: /* Extra methods required for client. */
246: OLESTATUS (CALLBACK* Delete) (LPOLEOBJECT);
247: OLESTATUS (CALLBACK* SetHostNames) (LPOLEOBJECT, LPSTR, LPSTR);
248: OLESTATUS (CALLBACK* SaveToStream) (LPOLEOBJECT, LPOLESTREAM);
249: OLESTATUS (CALLBACK* Clone) (LPOLEOBJECT, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
250: OLESTATUS (CALLBACK* CopyFromLink) (LPOLEOBJECT, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
251: OLESTATUS (CALLBACK* Equal) (LPOLEOBJECT, LPOLEOBJECT);
252: OLESTATUS (CALLBACK* CopyToClipboard) (LPOLEOBJECT);
253: OLESTATUS (CALLBACK* Draw) (LPOLEOBJECT, HDC, OLE_CONST RECT FAR*, OLE_CONST RECT FAR*, HDC);
254: OLESTATUS (CALLBACK* Activate) (LPOLEOBJECT, UINT, BOOL, BOOL, HWND, OLE_CONST RECT FAR*);
255: OLESTATUS (CALLBACK* Execute) (LPOLEOBJECT, HGLOBAL, UINT);
256: OLESTATUS (CALLBACK* Close) (LPOLEOBJECT);
257: OLESTATUS (CALLBACK* Update) (LPOLEOBJECT);
258: OLESTATUS (CALLBACK* Reconnect) (LPOLEOBJECT);
259:
260: OLESTATUS (CALLBACK* ObjectConvert) (LPOLEOBJECT, LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
261: OLESTATUS (CALLBACK* GetLinkUpdateOptions) (LPOLEOBJECT, OLEOPT_UPDATE FAR*);
262: OLESTATUS (CALLBACK* SetLinkUpdateOptions) (LPOLEOBJECT, OLEOPT_UPDATE);
263:
264: OLESTATUS (CALLBACK* Rename) (LPOLEOBJECT, LPSTR);
265: OLESTATUS (CALLBACK* QueryName) (LPOLEOBJECT, LPSTR, UINT FAR*);
266:
267: OLESTATUS (CALLBACK* QueryType) (LPOLEOBJECT, LONG FAR*);
268: OLESTATUS (CALLBACK* QueryBounds) (LPOLEOBJECT, RECT FAR*);
269: OLESTATUS (CALLBACK* QuerySize) (LPOLEOBJECT, DWORD FAR*);
270: OLESTATUS (CALLBACK* QueryOpen) (LPOLEOBJECT);
271: OLESTATUS (CALLBACK* QueryOutOfDate) (LPOLEOBJECT);
272:
273: OLESTATUS (CALLBACK* QueryReleaseStatus) (LPOLEOBJECT);
274: OLESTATUS (CALLBACK* QueryReleaseError) (LPOLEOBJECT);
275: OLE_RELEASE_METHOD (CALLBACK* QueryReleaseMethod)(LPOLEOBJECT);
276:
277: OLESTATUS (CALLBACK* RequestData) (LPOLEOBJECT, OLECLIPFORMAT);
278: OLESTATUS (CALLBACK* ObjectLong) (LPOLEOBJECT, UINT, LONG FAR*);
279:
280: /* This method is internal only */
281: OLESTATUS (CALLBACK* ChangeData) (LPOLEOBJECT, HANDLE, LPOLECLIENT, BOOL);
282: #endif /* !SERVERONLY */
283: } OLEOBJECTVTBL;
284: typedef OLEOBJECTVTBL FAR* LPOLEOBJECTVTBL;
285:
286: #ifndef OLE_INTERNAL
287: typedef struct _OLEOBJECT
288: {
289: LPOLEOBJECTVTBL lpvtbl;
290: } OLEOBJECT;
291: #endif
292:
293: /* ole client definitions */
294: typedef struct _OLECLIENTVTBL
295: {
296: int (CALLBACK* CallBack)(LPOLECLIENT, OLE_NOTIFICATION, LPOLEOBJECT);
297: } OLECLIENTVTBL;
298:
299: typedef OLECLIENTVTBL FAR* LPOLECLIENTVTBL;
300:
301: typedef struct _OLECLIENT
302: {
303: LPOLECLIENTVTBL lpvtbl;
304: } OLECLIENT;
305:
306: /* Stream definitions */
307: typedef struct _OLESTREAMVTBL
308: {
309: DWORD (CALLBACK* Get)(LPOLESTREAM, void FAR*, DWORD);
310: DWORD (CALLBACK* Put)(LPOLESTREAM, OLE_CONST void FAR*, DWORD);
311: } OLESTREAMVTBL;
312: typedef OLESTREAMVTBL FAR* LPOLESTREAMVTBL;
313:
314: typedef struct _OLESTREAM
315: {
316: LPOLESTREAMVTBL lpstbl;
317: } OLESTREAM;
318:
319: /* Public Function Prototypes */
320: OLESTATUS WINAPI OleDelete(LPOLEOBJECT);
321: OLESTATUS WINAPI OleRelease(LPOLEOBJECT);
322: OLESTATUS WINAPI OleSaveToStream(LPOLEOBJECT, LPOLESTREAM);
323: OLESTATUS WINAPI OleEqual(LPOLEOBJECT, LPOLEOBJECT );
324: OLESTATUS WINAPI OleCopyToClipboard(LPOLEOBJECT);
325: OLESTATUS WINAPI OleSetHostNames(LPOLEOBJECT, LPSTR, LPSTR);
326: OLESTATUS WINAPI OleSetTargetDevice(LPOLEOBJECT, HGLOBAL);
327: OLESTATUS WINAPI OleSetBounds(LPOLEOBJECT, const RECT FAR*);
328: OLESTATUS WINAPI OleSetColorScheme(LPOLEOBJECT, const LOGPALETTE FAR*);
329: OLESTATUS WINAPI OleQueryBounds(LPOLEOBJECT, RECT FAR*);
330: OLESTATUS WINAPI OleQuerySize(LPOLEOBJECT, DWORD FAR*);
331: OLESTATUS WINAPI OleDraw(LPOLEOBJECT, HDC, const RECT FAR*, const RECT FAR*, HDC);
332: OLESTATUS WINAPI OleQueryOpen(LPOLEOBJECT);
333: OLESTATUS WINAPI OleActivate(LPOLEOBJECT, UINT, BOOL, BOOL, HWND, const RECT FAR*);
334: OLESTATUS WINAPI OleExecute(LPOLEOBJECT, HGLOBAL, UINT);
335: OLESTATUS WINAPI OleClose(LPOLEOBJECT);
336: OLESTATUS WINAPI OleUpdate(LPOLEOBJECT);
337: OLESTATUS WINAPI OleReconnect(LPOLEOBJECT);
338: OLESTATUS WINAPI OleGetLinkUpdateOptions(LPOLEOBJECT, OLEOPT_UPDATE FAR*);
339: OLESTATUS WINAPI OleSetLinkUpdateOptions(LPOLEOBJECT, OLEOPT_UPDATE);
340: void FAR* WINAPI OleQueryProtocol(LPOLEOBJECT, LPSTR);
341: OLESTATUS WINAPI OleSetFileFormat(LHCLIENTDOC, LONG);
342:
343: /* Routines related to asynchronous operations. */
344: OLESTATUS WINAPI OleQueryReleaseStatus(LPOLEOBJECT);
345: OLESTATUS WINAPI OleQueryReleaseError(LPOLEOBJECT);
346: OLE_RELEASE_METHOD WINAPI OleQueryReleaseMethod(LPOLEOBJECT);
347:
348: OLESTATUS WINAPI OleQueryType(LPOLEOBJECT, LONG FAR*);
349:
350: /* LOWORD is major version, HIWORD is minor version */
351: DWORD WINAPI OleQueryClientVersion(void);
352: DWORD WINAPI OleQueryServerVersion(void);
353:
354: /* Converting to format (as in clipboard): */
355: OLECLIPFORMAT WINAPI OleEnumFormats(LPOLEOBJECT, OLECLIPFORMAT);
356: OLESTATUS WINAPI OleGetData(LPOLEOBJECT, OLECLIPFORMAT, HANDLE FAR*);
357: OLESTATUS WINAPI OleSetData(LPOLEOBJECT, OLECLIPFORMAT, HANDLE);
358: OLESTATUS WINAPI OleQueryOutOfDate(LPOLEOBJECT);
359: OLESTATUS WINAPI OleRequestData(LPOLEOBJECT, OLECLIPFORMAT);
360:
361: /* Query apis for creation from clipboard */
362: OLESTATUS WINAPI OleQueryLinkFromClip(LPSTR, OLEOPT_RENDER, OLECLIPFORMAT);
363: OLESTATUS WINAPI OleQueryCreateFromClip(LPSTR, OLEOPT_RENDER, OLECLIPFORMAT);
364:
365: /* Object creation functions */
366: OLESTATUS WINAPI OleCreateFromClip(LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
367: OLESTATUS WINAPI OleCreateLinkFromClip(LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
368: OLESTATUS WINAPI OleCreateFromFile(LPSTR, LPOLECLIENT, LPSTR, LPSTR, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
369: OLESTATUS WINAPI OleCreateLinkFromFile(LPSTR, LPOLECLIENT, LPSTR, LPSTR, LPSTR, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
370: OLESTATUS WINAPI OleLoadFromStream(LPOLESTREAM, LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
371: OLESTATUS WINAPI OleCreate(LPSTR, LPOLECLIENT, LPSTR, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
372: OLESTATUS WINAPI OleCreateInvisible(LPSTR, LPOLECLIENT, LPSTR, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT, BOOL);
373: OLESTATUS WINAPI OleCreateFromTemplate(LPSTR, LPOLECLIENT, LPSTR, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
374: OLESTATUS WINAPI OleClone(LPOLEOBJECT, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
375: OLESTATUS WINAPI OleCopyFromLink(LPOLEOBJECT, LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
376: OLESTATUS WINAPI OleObjectConvert(LPOLEOBJECT, LPSTR, LPOLECLIENT, LHCLIENTDOC, LPSTR, LPOLEOBJECT FAR*);
377: OLESTATUS WINAPI OleRename(LPOLEOBJECT, LPSTR);
378: OLESTATUS WINAPI OleQueryName(LPOLEOBJECT, LPSTR, UINT FAR*);
379: OLESTATUS WINAPI OleRevokeObject(LPOLECLIENT);
380: BOOL WINAPI OleIsDcMeta(HDC);
381:
382: /* client document API */
383: OLESTATUS WINAPI OleRegisterClientDoc(LPSTR, LPSTR, LONG, LHCLIENTDOC FAR*);
384: OLESTATUS WINAPI OleRevokeClientDoc(LHCLIENTDOC);
385: OLESTATUS WINAPI OleRenameClientDoc(LHCLIENTDOC, LPSTR);
386: OLESTATUS WINAPI OleRevertClientDoc(LHCLIENTDOC);
387: OLESTATUS WINAPI OleSavedClientDoc(LHCLIENTDOC);
388: OLESTATUS WINAPI OleEnumObjects(LHCLIENTDOC, LPOLEOBJECT FAR*);
389:
390: /* server usage definitions */
391: typedef enum {
392: OLE_SERVER_MULTI, /* multiple instances */
393: OLE_SERVER_SINGLE /* single instance(multiple document) */
394: } OLE_SERVER_USE;
395:
396: /* Server API */
397: typedef struct _OLESERVER FAR* LPOLESERVER;
398:
399: OLESTATUS WINAPI OleRegisterServer(LPSTR, LPOLESERVER, LHSERVER FAR*, HANDLE, OLE_SERVER_USE);
400: OLESTATUS WINAPI OleRevokeServer(LHSERVER);
401: OLESTATUS WINAPI OleBlockServer(LHSERVER);
402: OLESTATUS WINAPI OleUnblockServer(LHSERVER, BOOL FAR*);
403:
404: /* APIs to keep server open */
405: OLESTATUS WINAPI OleLockServer(LPOLEOBJECT, LHSERVER FAR*);
406: OLESTATUS WINAPI OleUnlockServer(LHSERVER);
407:
408: /* Server document API */
409:
410: typedef struct _OLESERVERDOC FAR* LPOLESERVERDOC;
411:
412: OLESTATUS WINAPI OleRegisterServerDoc(LHSERVER, LPSTR, LPOLESERVERDOC, LHSERVERDOC FAR*);
413: OLESTATUS WINAPI OleRevokeServerDoc(LHSERVERDOC);
414: OLESTATUS WINAPI OleRenameServerDoc(LHSERVERDOC, LPSTR);
415: OLESTATUS WINAPI OleRevertServerDoc(LHSERVERDOC);
416: OLESTATUS WINAPI OleSavedServerDoc(LHSERVERDOC);
417:
418: typedef struct _OLESERVERVTBL
419: {
420: OLESTATUS (CALLBACK* Open) (LPOLESERVER, LHSERVERDOC, LPSTR, LPOLESERVERDOC FAR*);
421: /* long handle to doc(privtate to DLL) */
422: /* lp to OLESERVER */
423: /* document name */
424: /* place holder for returning oledoc. */
425:
426: OLESTATUS (CALLBACK* Create)(LPOLESERVER, LHSERVERDOC, LPSTR, LPSTR, LPOLESERVERDOC FAR*);
427: /* long handle to doc(privtate to DLL) */
428: /* lp to OLESERVER */
429: /* lp class name */
430: /* lp doc name */
431: /* place holder for returning oledoc. */
432:
433: OLESTATUS (CALLBACK* CreateFromTemplate)(LPOLESERVER, LHSERVERDOC, LPSTR, LPSTR, LPSTR, LPOLESERVERDOC FAR*);
434: /* long handle to doc(privtate to DLL) */
435: /* lp to OLESERVER */
436: /* lp class name */
437: /* lp doc name */
438: /* lp template name */
439: /* place holder for returning oledoc. */
440:
441: OLESTATUS (CALLBACK* Edit) (LPOLESERVER, LHSERVERDOC, LPSTR, LPSTR, LPOLESERVERDOC FAR*);
442: /* long handle to doc(privtate to DLL) */
443: /* lp to OLESERVER */
444: /* lp class name */
445: /* lp doc name */
446: /* place holder for returning oledoc. */
447:
448: OLESTATUS (CALLBACK* Exit) (LPOLESERVER);
449: /* lp OLESERVER */
450:
451: OLESTATUS (CALLBACK* Release) (LPOLESERVER);
452: /* lp OLESERVER */
453:
454: OLESTATUS (CALLBACK* Execute)(LPOLESERVER, HGLOBAL);
455: /* lp OLESERVER */
456: /* handle to command strings */
457: } OLESERVERVTBL;
458: typedef OLESERVERVTBL FAR* LPOLESERVERVTBL;
459:
460: typedef struct _OLESERVER
461: {
462: LPOLESERVERVTBL lpvtbl;
463: } OLESERVER;
464:
465: typedef struct _OLESERVERDOCVTBL
466: {
467: OLESTATUS (CALLBACK* Save) (LPOLESERVERDOC);
468: OLESTATUS (CALLBACK* Close) (LPOLESERVERDOC);
469: OLESTATUS (CALLBACK* SetHostNames)(LPOLESERVERDOC, LPSTR, LPSTR);
470: OLESTATUS (CALLBACK* SetDocDimensions)(LPOLESERVERDOC, OLE_CONST RECT FAR*);
471: OLESTATUS (CALLBACK* GetObject) (LPOLESERVERDOC, LPSTR, LPOLEOBJECT FAR*, LPOLECLIENT);
472: OLESTATUS (CALLBACK* Release) (LPOLESERVERDOC);
473: OLESTATUS (CALLBACK* SetColorScheme)(LPOLESERVERDOC, OLE_CONST LOGPALETTE FAR*);
474: OLESTATUS (CALLBACK* Execute) (LPOLESERVERDOC, HGLOBAL);
475: } OLESERVERDOCVTBL;
476: typedef OLESERVERDOCVTBL FAR* LPOLESERVERDOCVTBL;
477:
478: typedef struct _OLESERVERDOC
479: {
480: LPOLESERVERDOCVTBL lpvtbl;
481: } OLESERVERDOC;
482:
483: #ifdef __cplusplus
484: }
485: #endif /* __cplusplus */
486:
487: #ifndef RC_INVOKED
488: #pragma pack()
489: #endif /* !RC_INVOKED */
490:
491: #endif /* !_INC_OLE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.