1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/**
* Windows API header module
*
* Translated from MinGW Windows headers
*
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(DRUNTIMESRC core/sys/windows/_objbase.d)
*/
module core.sys.windows.objbase;
version (Windows):
@system:
pragma(lib, "ole32");
import core.sys.windows.cguid, core.sys.windows.objidl, core.sys.windows.unknwn, core.sys.windows.wtypes;
import core.sys.windows.basetyps, core.sys.windows.objfwd, core.sys.windows.rpcdce, core.sys.windows.winbase,
core.sys.windows.windef;
// DAC: Not needed for D?
//MACRO #define LISet32(li, v) ((li).HighPart=(v)<0?-1:0, (li).LowPart=(v))
//MACRO #define ULISet32(li, v) ((li).HighPart=0, (li).LowPart=(v))
enum CLSCTX_ALL = CLSCTX.CLSCTX_INPROC_SERVER|CLSCTX.CLSCTX_INPROC_HANDLER|CLSCTX.CLSCTX_LOCAL_SERVER;
enum CLSCTX_INPROC = CLSCTX.CLSCTX_INPROC_SERVER|CLSCTX.CLSCTX_INPROC_HANDLER;
enum CLSCTX_SERVER = CLSCTX.CLSCTX_INPROC_SERVER|CLSCTX.CLSCTX_LOCAL_SERVER|CLSCTX.CLSCTX_REMOTE_SERVER;
enum MARSHALINTERFACE_MIN=500;
enum CWCSTORAGENAME=32;
enum STGM_DIRECT = 0;
enum STGM_TRANSACTED = 0x10000L;
enum STGM_SIMPLE = 0x8000000L;
enum STGM_READ = 0;
enum STGM_WRITE = 1;
enum STGM_READWRITE = 2;
enum STGM_SHARE_DENY_NONE = 0x40;
enum STGM_SHARE_DENY_READ = 0x30;
enum STGM_SHARE_DENY_WRITE = 0x20;
enum STGM_SHARE_EXCLUSIVE = 0x10;
enum STGM_PRIORITY = 0x40000L;
enum STGM_DELETEONRELEASE = 0x4000000;
enum STGM_NOSCRATCH = 0x100000;
enum STGM_CREATE = 0x1000;
enum STGM_CONVERT = 0x20000;
enum STGM_NOSNAPSHOT = 0x200000;
enum STGM_FAILIFTHERE = 0;
enum ASYNC_MODE_COMPATIBILITY = 1;
enum ASYNC_MODE_DEFAULT = 0;
enum STGTY_REPEAT = 256;
enum STG_TOEND = 0xFFFFFFFF;
enum STG_LAYOUT_SEQUENTIAL = 0;
enum STG_LAYOUT_INTERLEAVED = 1;
enum COM_RIGHTS_EXECUTE = 1;
enum COM_RIGHTS_SAFE_FOR_SCRIPTING = 2;
enum STGOPTIONS_VERSION = 2;
enum STGFMT {
STGFMT_STORAGE = 0,
STGFMT_FILE = 3,
STGFMT_ANY = 4,
STGFMT_DOCFILE = 5
}
struct STGOPTIONS {
USHORT usVersion;
USHORT reserved;
ULONG ulSectorSize;
const(WCHAR)* pwcsTemplateFile;
}
enum REGCLS {
REGCLS_SINGLEUSE = 0,
REGCLS_MULTIPLEUSE = 1,
REGCLS_MULTI_SEPARATE = 2
}
/*
BOOL IsEqualGUID(GUID rguid1, GUID rguid2) {
return rguid1 == rguid2;
}
*/
extern (Windows) BOOL IsEqualGUID(
REFGUID rguid1,
REFGUID rguid2
);
alias IsEqualGUID IsEqualIID;
alias IsEqualGUID IsEqualCLSID;
enum COINIT {
COINIT_APARTMENTTHREADED = 2,
COINIT_MULTITHREADED = 0,
COINIT_DISABLE_OLE1DDE = 4,
COINIT_SPEED_OVER_MEMORY = 8
}
enum STDMSHLFLAGS {
SMEXF_SERVER = 1,
SMEXF_HANDLER
}
extern(Windows) {
alias HRESULT function(REFCLSID, REFIID, PVOID*) LPFNGETCLASSOBJECT;
alias HRESULT function() LPFNCANUNLOADNOW;
DWORD CoBuildVersion();
HRESULT CoInitialize(PVOID);
HRESULT CoInitializeEx(LPVOID, DWORD);
void CoUninitialize();
HRESULT CoGetMalloc(DWORD, LPMALLOC*);
DWORD CoGetCurrentProcess();
HRESULT CoRegisterMallocSpy(LPMALLOCSPY);
HRESULT CoRevokeMallocSpy();
HRESULT CoCreateStandardMalloc(DWORD, IMalloc*);
//#ifdef DBG
ULONG DebugCoGetRpcFault();
void DebugCoSetRpcFault(ULONG);
//#endif
HRESULT CoGetClassObject(REFCLSID, DWORD, COSERVERINFO*, REFIID, PVOID*);
HRESULT CoRegisterClassObject(REFCLSID, LPUNKNOWN, DWORD, DWORD, PDWORD);
HRESULT CoRevokeClassObject(DWORD);
HRESULT CoGetMarshalSizeMax(ULONG*, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
HRESULT CoMarshalInterface(LPSTREAM, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
HRESULT CoUnmarshalInterface(LPSTREAM, REFIID, PVOID*);
HRESULT CoMarshalHresult(LPSTREAM, HRESULT);
HRESULT CoUnmarshalHresult(LPSTREAM, HRESULT*);
HRESULT CoReleaseMarshalData(LPSTREAM);
HRESULT CoDisconnectObject(LPUNKNOWN, DWORD);
HRESULT CoLockObjectExternal(LPUNKNOWN, BOOL, BOOL);
HRESULT CoGetStandardMarshal(REFIID, LPUNKNOWN, DWORD, PVOID, DWORD, LPMARSHAL*);
HRESULT CoGetStdMarshalEx(LPUNKNOWN, DWORD, LPUNKNOWN*);
BOOL CoIsHandlerConnected(LPUNKNOWN);
BOOL CoHasStrongExternalConnections(LPUNKNOWN);
HRESULT CoMarshalInterThreadInterfaceInStream(REFIID, LPUNKNOWN, LPSTREAM*);
HRESULT CoGetInterfaceAndReleaseStream(LPSTREAM, REFIID, PVOID*);
HRESULT CoCreateFreeThreadedMarshaler(LPUNKNOWN, LPUNKNOWN*);
HINSTANCE CoLoadLibrary(LPOLESTR, BOOL);
void CoFreeLibrary(HINSTANCE);
void CoFreeAllLibraries();
void CoFreeUnusedLibraries();
HRESULT CoCreateInstance(REFCLSID, LPUNKNOWN, DWORD, REFIID, PVOID*);
HRESULT CoCreateInstanceEx(REFCLSID, IUnknown, DWORD, COSERVERINFO*, DWORD, MULTI_QI*);
HRESULT StringFromCLSID(REFCLSID, LPOLESTR*);
HRESULT CLSIDFromString(LPOLESTR, LPCLSID);
HRESULT StringFromIID(REFIID, LPOLESTR*);
HRESULT IIDFromString(LPOLESTR, LPIID);
BOOL CoIsOle1Class(REFCLSID);
HRESULT ProgIDFromCLSID(REFCLSID, LPOLESTR*);
HRESULT CLSIDFromProgID(LPCOLESTR, LPCLSID);
int StringFromGUID2(REFGUID, LPOLESTR, int);
HRESULT CoCreateGuid(GUID*);
BOOL CoFileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD);
BOOL CoDosDateTimeToFileTime(WORD, WORD, FILETIME*);
HRESULT CoFileTimeNow(FILETIME*);
HRESULT CoRegisterMessageFilter(LPMESSAGEFILTER, LPMESSAGEFILTER*);
HRESULT CoGetTreatAsClass(REFCLSID, LPCLSID);
HRESULT CoTreatAsClass(REFCLSID, REFCLSID);
HRESULT DllGetClassObject(REFCLSID, REFIID, PVOID*);
HRESULT DllCanUnloadNow();
PVOID CoTaskMemAlloc(SIZE_T);
PVOID CoTaskMemRealloc(PVOID, SIZE_T);
void CoTaskMemFree(PVOID);
HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*);
HRESULT CreateDataCache(LPUNKNOWN, REFCLSID, REFIID, PVOID*);
HRESULT StgCreateDocfile(const(OLECHAR)*, DWORD, DWORD, IStorage*);
HRESULT StgCreateDocfileOnILockBytes(ILockBytes, DWORD, DWORD, IStorage*);
HRESULT StgOpenStorage(const(OLECHAR)*, IStorage, DWORD, SNB, DWORD, IStorage*);
HRESULT StgOpenStorageOnILockBytes(ILockBytes, IStorage, DWORD, SNB, DWORD, IStorage*);
HRESULT StgIsStorageFile(const(OLECHAR)*);
HRESULT StgIsStorageILockBytes(ILockBytes);
HRESULT StgSetTimes(OLECHAR *, FILETIME *, FILETIME *, FILETIME *);
HRESULT StgCreateStorageEx(const(WCHAR)*, DWORD, DWORD, DWORD, STGOPTIONS*, void*, REFIID, void**);
HRESULT StgOpenStorageEx(const(WCHAR)*, DWORD, DWORD, DWORD, STGOPTIONS*, void*, REFIID, void**);
HRESULT BindMoniker(LPMONIKER, DWORD, REFIID, PVOID*);
HRESULT CoGetObject(LPCWSTR, BIND_OPTS*, REFIID, void**);
HRESULT MkParseDisplayName(LPBC, LPCOLESTR, ULONG*, LPMONIKER*);
HRESULT MonikerRelativePathTo(LPMONIKER, LPMONIKER, LPMONIKER*, BOOL);
HRESULT MonikerCommonPrefixWith(LPMONIKER, LPMONIKER, LPMONIKER*);
HRESULT CreateBindCtx(DWORD, LPBC*);
HRESULT CreateGenericComposite(LPMONIKER, LPMONIKER, LPMONIKER*);
HRESULT GetClassFile (LPCOLESTR, CLSID*);
HRESULT CreateFileMoniker(LPCOLESTR, LPMONIKER*);
HRESULT CreateItemMoniker(LPCOLESTR, LPCOLESTR, LPMONIKER*);
HRESULT CreateAntiMoniker(LPMONIKER*);
HRESULT CreatePointerMoniker(LPUNKNOWN, LPMONIKER*);
HRESULT GetRunningObjectTable(DWORD, LPRUNNINGOBJECTTABLE*);
HRESULT CoInitializeSecurity(PSECURITY_DESCRIPTOR, LONG, SOLE_AUTHENTICATION_SERVICE*, void*, DWORD, DWORD, void*, DWORD, void*);
HRESULT CoGetCallContext(REFIID, void**);
HRESULT CoQueryProxyBlanket(IUnknown*, DWORD*, DWORD*, OLECHAR**, DWORD*, DWORD*, RPC_AUTH_IDENTITY_HANDLE*, DWORD*);
HRESULT CoSetProxyBlanket(IUnknown*, DWORD, DWORD, OLECHAR*, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE, DWORD);
HRESULT CoCopyProxy(IUnknown*, IUnknown**);
HRESULT CoQueryClientBlanket(DWORD*, DWORD*, OLECHAR**, DWORD*, DWORD*, RPC_AUTHZ_HANDLE*, DWORD*);
HRESULT CoImpersonateClient();
HRESULT CoRevertToSelf();
HRESULT CoQueryAuthenticationServices(DWORD*, SOLE_AUTHENTICATION_SERVICE**);
HRESULT CoSwitchCallContext(IUnknown*, IUnknown**);
HRESULT CoGetInstanceFromFile(COSERVERINFO*, CLSID*, IUnknown*, DWORD, DWORD, OLECHAR*, DWORD, MULTI_QI*);
HRESULT CoGetInstanceFromIStorage(COSERVERINFO*, CLSID*, IUnknown*, DWORD, IStorage*, DWORD, MULTI_QI*);
ULONG CoAddRefServerProcess();
ULONG CoReleaseServerProcess();
HRESULT CoResumeClassObjects();
HRESULT CoSuspendClassObjects();
HRESULT CoGetPSClsid(REFIID, CLSID*);
HRESULT CoRegisterPSClsid(REFIID, REFCLSID);
}
|
