Ignore:
Timestamp:
Jun 26, 1999, 9:20:19 AM (26 years ago)
Author:
davidr
Message:

Moved stubs to stubs.cpp

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ole32/ole32.cpp

    r97 r200  
    1 /* $Id: ole32.cpp,v 1.4 1999-06-10 17:05:54 phaller Exp $ */
    2 
    31/*
    42 *
    … …  
    1412 */
    1513
    16 // ><DJR 17.05.99 Force to use C-interfaces for now to prevent CALLBACK definition compiler error
    17 #define CINTERFACE
     14#include "ole32.h"
    1815
    19 // ><DJR 17.05.99 Move standard includes to before os2win.h [memcmp]
    20 #include <stdarg.h>
    21 #include <stdio.h>
    22 #include <stdlib.h>
    23 #include <string.h>
    24 #include <memory.h>
    25 
    26 // ><DJR 17.05.99 Prevent CALLCONV becoming _System
    27 #include <winbase.h>
    28 #include <uniconv.h>
    29 #undef CALLCONV
    30 
    31 #include <os2win.h>
    32 #include <ole2ver.h>
    33 #include <ole.h>
    34 
    35 #include "wine/obj_base.h"
    36 #include "wine/obj_misc.h"
    37 #include "wine/obj_inplace.h"
    38 #include "wine/obj_dataobject.h"
    39 #include "wine/obj_oleobj.h"
    40 #include "wine/obj_marshal.h"
    41 #include "wine/obj_moniker.h"
    42 #include "wine/obj_clientserver.h"
    43 #include "wine/obj_dragdrop.h"
    44 
    45 //*******************************************************************************
    46 //*******************************************************************************
    47 HRESULT WIN32API CLSIDFromProgID(LPCOLESTR lpszProgID, LPCLSID pclsid)
    48 {
    49    dprintf(("CLSIDFromProgID- stub\n"));
    50    return OLE_ERROR_GENERIC;
    51 }
    52 //*******************************************************************************
    53 //*******************************************************************************
    54 HRESULT WIN32API CLSIDFromString(LPCOLESTR lpsz, LPCLSID pclisid)
    55 {
    56    dprintf(("CLSIDFromString- stub\n"));
    57    return OLE_ERROR_GENERIC;
    58 }
    59 //*******************************************************************************
    60 //*******************************************************************************
     16// ----------------------------------------------------------------------
     17// CoBuildVersion()
     18// ----------------------------------------------------------------------
    6119DWORD WIN32API CoBuildVersion()
    6220{
    63    dprintf(("CoBuildVersion, obsolete\n"));
    64    return 0;
    65 }
    66 //*******************************************************************************
    67 //*******************************************************************************
    68 HRESULT WIN32API CoCreateFreeThreadedMarshaler(LPUNKNOWN punkOuter,
    69                                                   LPUNKNOWN *ppunkMarshaler)
    70 {
    71    dprintf(("CoCreateFreeThreadedMarshaler- stub\n"));
    72    return E_OUTOFMEMORY;
    73 }
    74 //*******************************************************************************
    75 //*******************************************************************************
    76 HRESULT WIN32API CoCreateGuid(GUID *pguid)
    77 {
    78    dprintf(("CoCreateGuid - partial\n"));
    79    memset(pguid, 0, sizeof(GUID));      //TODO: should be random GUID
    80    return S_OK;
    81 }
    82 //*******************************************************************************
    83 //*******************************************************************************
    84 HRESULT WIN32API CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
    85                                      DWORD dwClsContext, REFIID riid,
    86                                      LPVOID *ppv)
    87 {
    88    dprintf(("CoCreateInstance - stub\n"));
    89    return REGDB_E_CLASSNOTREG;
    90 }
    91 //*******************************************************************************
    92 //*******************************************************************************
    93 HRESULT WIN32API CoDisconnectObject(IUnknown *pUnk, DWORD dwReserved)
    94 {
    95    dprintf(("CoDisconnectObject - stub\n"));
    96    return S_OK;
    97 }
    98 //*******************************************************************************
    99 //*******************************************************************************
    100 BOOL WIN32API CoDosDateTimeToFileTime(WORD nDosDate, WORD nDosTime,
    101                                          FILETIME *lpFileTime)
    102 {
    103    dprintf(("CoDosDateTimeToFileTime, redundant\n"));
    104    return DosDateTimeToFileTime(nDosDate, nDosTime, lpFileTime);
    105 }
    106 //*******************************************************************************
    107 //*******************************************************************************
    108 HRESULT WIN32API CoFileTimeNow(FILETIME *lpFileTime)
    109 {
    110  SYSTEMTIME systime;
    111 
    112    dprintf(("CoFileTimeNow\n"));
    113    GetSystemTime(&systime);
    114    return SystemTimeToFileTime(&systime, lpFileTime);
    115 }
    116 //*******************************************************************************
    117 //*******************************************************************************
    118 BOOL WIN32API CoFileTimeToDosDateTime(FILETIME *lpFileTime, LPWORD lpDosDate,
    119                                          LPWORD lpDosTime)
    120 {
    121    dprintf(("CoFileTimeToDosDateTime\n"));
    122    return FileTimeToDosDateTime(lpFileTime, lpDosDate, lpDosTime);
    123 }
    124 //*******************************************************************************
    125 //Frees all libs loaded with CoLoadLibrary
    126 //*******************************************************************************
    127 void WIN32API CoFreeAllLibraries()
    128 {
    129    dprintf(("CoFreeAllLibraries - stub\n"));
    130    return ;
    131 }
    132 //*******************************************************************************
    133 //*******************************************************************************
    134 void WIN32API CoFreeLibrary(HINSTANCE hInst)
    135 {
    136    dprintf(("CoFreeLibrary\n"));
    137    FreeLibrary(hInst);
    138 }
    139 //*******************************************************************************
    140 //*******************************************************************************
    141 void WIN32API CoFreeUnusedLibraries()
    142 {
    143    dprintf(("CoFreeUnusedLibraries - stub\n"));
    144    return ;
    145 }
    146 //*******************************************************************************
    147 //*******************************************************************************
    148 HRESULT WIN32API CoGetCallerTID()
    149 {
    150    dprintf(("CoGetCallerTID, UNKNOWN API - stub\n"));
    151    return 0;
    152 }
    153 //*******************************************************************************
    154 //*******************************************************************************
    155 //HRESULT WIN32API CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo, REFIID riid, LPVOID *ppv)
    156 HRESULT WIN32API CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pServerInfo, REFIID riid, LPVOID *ppv)
    157 {
    158    dprintf(("CoGetClassObject - stub\n"));
    159    return REGDB_E_CLASSNOTREG;
    160 }
    161 //*******************************************************************************
    162 //*******************************************************************************
    163 HRESULT WIN32API CoGetCurrentLogicalThreadId()
    164 {
    165    dprintf(("CoGetCurrentLogicalThreadId, UNKNOWN API - stub\n"));
    166    return 0;
    167 }
    168 //*******************************************************************************
    169 //*******************************************************************************
    170 DWORD WIN32API CoGetCurrentProcess()
    171 {
    172    dprintf(("CoGetCurrentProcess - stub\n"));
    173    return 666;
    174 }
    175 //*******************************************************************************
    176 //*******************************************************************************
    177 HRESULT WIN32API CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid,
    178                                                    LPVOID *ppv)
    179 {
    180    dprintf(("CoGetInterfaceAndReleaseStream - stub\n"));
    181    return E_INVALIDARG;
    182 }
    183 //*******************************************************************************
    184 //*******************************************************************************
    185 HRESULT WIN32API CoGetMalloc(DWORD dwMemContext, LPMALLOC *ppMalloc)
    186 {
    187    dprintf(("CoGetMalloc - stub\n"));
    188    return E_OUTOFMEMORY;
    189 }
    190 //*******************************************************************************
    191 //*******************************************************************************
    192 HRESULT WIN32API CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk,
    193                                         DWORD dwDestContext, LPVOID pvDestContext,
    194                                         DWORD mshlflags)
    195 {
    196    dprintf(("CoGetMarshalSizeMax - stub\n"));
    197    return CO_E_NOTINITIALIZED;
    198 }
    199 //*******************************************************************************
    200 //*******************************************************************************
    201 HRESULT WIN32API CoGetPSClsid(REFIID riid, CLSID *pclsid)
    202 {
    203    dprintf(("CoGetPSClsid - stub\n"));
    204    return E_OUTOFMEMORY;
    205 }
    206 //*******************************************************************************
    207 //*******************************************************************************
    208 HRESULT WIN32API CoGetStandardMarshal(REFIID riid, IUnknown *pUnk, DWORD dwDestContext,
    209                                          LPVOID pvDestContext, DWORD mshlflags,
    210                                          LPMARSHAL *ppMarshal)
    211 {
    212    dprintf(("CoGetStandardMarshal - stub\n"));
    213    return E_OUTOFMEMORY;
    214 }
    215 //*******************************************************************************
    216 //*******************************************************************************
    217 HRESULT WIN32API CoGetState()
    218 {
    219    dprintf(("CoGetState, UNKNOWN API - stub\n"));
    220    return 0;
    221 }
    222 //*******************************************************************************
    223 //*******************************************************************************
    224 HRESULT WIN32API CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pclsidNew)
    225 {
    226    dprintf(("CoGetTreatAsClass - stub\n"));
    227    return S_FALSE;
    228 }
    229 //*******************************************************************************
    230 //*******************************************************************************
    231 HRESULT WIN32API CoInitialize(LPVOID lpReserved)
    232 {
    233    dprintf(("CoInitialize, UNKNOWN API - stub\n"));
    234    return 0;
    235 }
    236 //*******************************************************************************
    237 //*******************************************************************************
    238 HRESULT WIN32API CoInitializeWOW()
    239 {
    240    dprintf(("CoInitializeWOW, UNKNOWN API - stub\n"));
    241    return 0;
    242 }
    243 //*******************************************************************************
    244 //*******************************************************************************
    245 BOOL WIN32API CoIsHandlerConnected(LPUNKNOWN pUnk)
    246 {
    247    dprintf(("CoIsHandlerConnected - stub\n"));
    248    return FALSE;
    249 }
    250 //*******************************************************************************
    251 //*******************************************************************************
    252 BOOL WIN32API CoIsOle1Class(REFCLSID rclsid)
    253 {
    254    dprintf(("CoIsOle1Class - stub\n"));
    255    return S_FALSE;
    256 }
    257 //*******************************************************************************
    258 //*******************************************************************************
    259 HINSTANCE WIN32API CoLoadLibrary(LPSTR lpszLibName, BOOL bAutoFree)
    260 {
    261    dprintf(("CoLoadLibrary\n"));
    262    return LoadLibraryA(lpszLibName);
    263 }
    264 //*******************************************************************************
    265 //*******************************************************************************
    266 HRESULT WIN32API CoLockObjectExternal(IUnknown *pUnk, BOOL fLock, BOOL fLastUnlockReleases)
    267 {
    268    dprintf(("CoLockObjectExternal - stub\n"));
    269    return E_OUTOFMEMORY;
    270 }
    271 //*******************************************************************************
    272 //*******************************************************************************
    273 HRESULT WIN32API CoMarshalHresult(IStream *pStm, HRESULT hresult)
    274 {
    275    dprintf(("CoMarshalHresult - stub\n"));
    276    return E_OUTOFMEMORY;
    277 }
    278 //*******************************************************************************
    279 //*******************************************************************************
    280 HRESULT WIN32API CoMarshalInterThreadInterfaceInStream(REFIID riid,
    281                                                           LPUNKNOWN pUnk,
    282                                                           LPSTREAM *ppStm)
    283 {
    284    dprintf(("CoMarshalInterThreadInterfaceInStream - stub\n"));
    285    return E_OUTOFMEMORY;
    286 }
    287 //*******************************************************************************
    288 //*******************************************************************************
    289 HRESULT WIN32API CoMarshalInterface(IStream *pStm, REFIID riid, IUnknown *pUnk,
    290                                        DWORD dwDestContext, void *pvDestContext,
    291                                        DWORD mshlflags)
    292 {
    293    dprintf(("CoMarshalInterface - stub\n"));
    294    return E_OUTOFMEMORY;
    295 }
    296 //*******************************************************************************
    297 //*******************************************************************************
    298 HRESULT WIN32API CoQueryReleaseObject()
    299 {
    300    dprintf(("CoQueryReleaseObject, UNKNOWN API - stub\n"));
    301    return 0;
    302 }
    303 //*******************************************************************************
    304 //*******************************************************************************
    305 HRESULT WIN32API CoRegisterClassObject(REFCLSID rclsid, IUnknown *pUnk,
    306                                           DWORD dwClsContext, DWORD flags,
    307                                           LPDWORD lpdwRegister)
    308 {
    309    dprintf(("CoRegisterClassObject - stub\n"));
    310    return E_OUTOFMEMORY;
    311 }
    312 //*******************************************************************************
    313 //*******************************************************************************
    314 HRESULT WIN32API CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy)
    315 {
    316    dprintf(("CoRegisterMallocSpy - stub\n"));
    317    return CO_E_OBJISREG;
    318 }
    319 //*******************************************************************************
    320 //*******************************************************************************
    321 HRESULT WIN32API CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter,
    322                                             LPMESSAGEFILTER *lplpMessageFilter)
    323 {
    324    dprintf(("CoRegisterMessageFilter - stub\n"));
    325    return S_FALSE;
    326 }
    327 //*******************************************************************************
    328 //*******************************************************************************
    329 HRESULT WIN32API CoReleaseMarshalData(IStream *pStm)
    330 {
    331    dprintf(("CoReleaseMarshalData - stub\n"));
    332    return E_OUTOFMEMORY;
    333 }
    334 //*******************************************************************************
    335 //*******************************************************************************
    336 HRESULT WIN32API CoRevokeClassObject(DWORD dwRegister)
    337 {
    338    dprintf(("CoRevokeClassObject - stub\n"));
    339    return E_OUTOFMEMORY;
    340 }
    341 //*******************************************************************************
    342 //*******************************************************************************
    343 HRESULT WIN32API CoRevokeMallocSpy()
    344 {
    345    dprintf(("CoRevokeMallocSpy - stub\n"));
    346    return E_ACCESSDENIED;
    347 }
    348 //*******************************************************************************
    349 //*******************************************************************************
    350 HRESULT WIN32API CoSetState()
    351 {
    352    dprintf(("CoSetState, UNKNOWN API - stub\n"));
    353    return 0;
    354 }
    355 //*******************************************************************************
    356 //*******************************************************************************
    357 LPVOID WIN32API CoTaskMemAlloc(ULONG cb)
    358 {
    359    dprintf(("CoTaskMemAlloc\n"));
    360    return malloc(cb);
    361 }
    362 //*******************************************************************************
    363 //*******************************************************************************
    364 void WIN32API CoTaskMemFree(void *pv)
    365 {
    366    dprintf(("CoTaskMemFree\n"));
    367    free(pv);
    368    return;
    369 }
    370 //*******************************************************************************
    371 //*******************************************************************************
    372 LPVOID WIN32API CoTaskMemRealloc(LPVOID pv, ULONG cb)
    373 {
    374    dprintf(("CoTaskMemRealloc - stub\n"));
    375    return NULL;
    376 }
    377 //*******************************************************************************
    378 //*******************************************************************************
    379 HRESULT WIN32API CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
    380 {
    381    dprintf(("CoTreatAsClass - stub\n"));
    382    return E_INVALIDARG;
    383 }
    384 //*******************************************************************************
    385 //*******************************************************************************
    386 void WIN32API CoUninitialize()
    387 {
    388    dprintf(("CoUninitialize - stub\n"));
    389    return ;
    390 }
    391 //*******************************************************************************
    392 //*******************************************************************************
    393 void WIN32API CoUnloadingWOW()
    394 {
    395    dprintf(("CoUnloadingWOW, UNKNOWN API - stub\n"));
    396    return ;
    397 }
    398 //*******************************************************************************
    399 //*******************************************************************************
    400 HRESULT WIN32API CoUnmarshalHresult(LPSTREAM pStm, HRESULT *phresult)
    401 {
    402    dprintf(("CoUnmarshalHresult - stub\n"));
    403    return S_OK;
    404 }
    405 //*******************************************************************************
    406 //*******************************************************************************
    407 HRESULT WIN32API CoUnmarshalInterface(IStream *pSTm, REFIID riid, void **ppv)
    408 {
    409    dprintf(("CoUnmarshalInterface - stub\n"));
    410    return S_OK;
     21    dprintf(("OLE32.CoBuildVersion\n"));
     22    return (rmm<<16)+rup;
    41123}
    41224
    413 //******************************************************************************
    414 //******************************************************************************
    415 void WIN32API OleUninitialize(void)
    416 {
    417   dprintf(("OleUninitialize - stub\n"));
    418   return;
    419 }
    420 //******************************************************************************
    421 //******************************************************************************
    422 HRESULT WIN32API BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult,
    423                                 LPVOID *ppvResult)
    424 {
    425    dprintf(("BindMoniker- stub\n"));
    426    return MK_E_NOOBJECT;
    427 }
    428 //*******************************************************************************
    429 //*******************************************************************************
    430 HRESULT WIN32API CreateAntiMoniker(LPMONIKER *ppmk)
    431 {
    432    dprintf(("CreateAntiMoniker - stub\n"));
    433    return E_OUTOFMEMORY;
    434 }
    435 //*******************************************************************************
    436 //*******************************************************************************
    437 HRESULT WIN32API CreateBindCtx(DWORD reserved, LPBC *ppbc)
    438 {
    439    dprintf(("CreateBindCtx - stub\n"));
    440    return E_OUTOFMEMORY;
    441 }
    442 //*******************************************************************************
    443 //*******************************************************************************
    444 HRESULT WIN32API CreateDataAdviseHolder(IDataAdviseHolder **ppDAHolder)
    445 {
    446    dprintf(("CreateDataAdviseHolder - stub\n"));
    447    return E_OUTOFMEMORY;
    448 }
    449 //*******************************************************************************
    450 //*******************************************************************************
    451 HRESULT WIN32API CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid,
    452                                     REFIID riid, LPVOID *ppvObj)
    453 {
    454    dprintf(("CreateDataCache - stub\n"));
    455    return E_OUTOFMEMORY;
    456 }
    457 //*******************************************************************************
    458 //*******************************************************************************
    459 HRESULT WIN32API CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER *ppmk)
    460 {
    461    dprintf(("CreateFileMoniker - stub\n"));
    462    return E_OUTOFMEMORY;
    463 }
    464 //*******************************************************************************
    465 //*******************************************************************************
    466 HRESULT WIN32API CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest,
    467                                            LPMONIKER *ppmkComposite)
    468 {
    469    dprintf(("CreateGenericComposite - stub\n"));
    470    return E_OUTOFMEMORY;
    471 }
    472 //*******************************************************************************
    473 //*******************************************************************************
    474 HRESULT WIN32API CreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease,
    475                                               ILockBytes **ppkLkbyt)
    476 {
    477    dprintf(("CreateILockBytesOnHGlobal - stub\n"));
    478    return E_OUTOFMEMORY;
    479 }
    480 //*******************************************************************************
    481 //*******************************************************************************
    482 HRESULT WIN32API CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER *ppmk)
    483 {
    484    dprintf(("CreateItemMoniker - stub\n"));
    485    return E_OUTOFMEMORY;
    486 }
    487 //*******************************************************************************
    488 //*******************************************************************************
    489 HRESULT WIN32API CreateOleAdviseHolder(IOleAdviseHolder ppOAHolder)
    490 {
    491    dprintf(("CreateOleAdviseHolder - stub\n"));
    492    return E_OUTOFMEMORY;
    493 }
    494 //*******************************************************************************
    495 //*******************************************************************************
    496 HRESULT WIN32API CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER *ppmk)
    497 {
    498    dprintf(("CreatePointerMoniker - stub\n"));
    499    return E_OUTOFMEMORY;
    500 }
    501 //*******************************************************************************
    502 //*******************************************************************************
    503 HRESULT WIN32API CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease,
    504                                           LPSTREAM *ppstm)
    505 {
    506    dprintf(("CreateStreamOnHGlobal - stub\n"));
    507    return E_OUTOFMEMORY;
    508 }
    509 //*******************************************************************************
    510 //*******************************************************************************
    511 HRESULT WIN32API DllDebugObjectRPCHook()
    512 {
    513    dprintf(("DllDebugObjectRPCHook, UNKNOWN API - stub\n"));
    514    return 0;
    515 }
    516 //*******************************************************************************
    517 //*******************************************************************************
    518 HRESULT WIN32API DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
    519 {
    520    dprintf(("DllGetClassObject - stub\n"));
    521    return E_OUTOFMEMORY;
    522 }
    523 //*******************************************************************************
    524 //*******************************************************************************
    525 HRESULT WIN32API DllGetClassObjectWOW()
    526 {
    527    dprintf(("DllGetClassObjectWOW, UNKNOWN API - stub\n"));
    528    return 0;
    529 }
    530 //*******************************************************************************
    531 //*******************************************************************************
    532 HRESULT WIN32API DoDragDrop(IDataObject *pDataObject, IDropSource *pDropSource,
    533                                DWORD dwOKEffect, DWORD *pdwEffect)
    534 {
    535    dprintf(("DoDragDrop - stub\n"));
    536    return E_OUTOFMEMORY;
    537 }
    538 //*******************************************************************************
    539 //*******************************************************************************
    540 HRESULT WIN32API EnableHookObject()
    541 {
    542    dprintf(("EnableHookObject, UNKNOWN API - stub\n"));
    543    return 0;
    544 }
    545 //*******************************************************************************
    546 //*******************************************************************************
    547 HRESULT WIN32API GetClassFile(LPCWSTR szFileName, CLSID *pclsid)
    548 {
    549    dprintf(("GetClassFile - stub\n"));
    550    return MK_E_CANTOPENFILE;
    551 }
    552 //*******************************************************************************
    553 //*******************************************************************************
    554 HRESULT WIN32API GetConvertStg(IStorage *pStg)
    555 {
    556    dprintf(("GetConvertStg - stub\n"));
    557    return STG_E_ACCESSDENIED;
    558 }
    559 //*******************************************************************************
    560 //*******************************************************************************
    561 HRESULT WIN32API GetDocumentBitStg()
    562 {
    563    dprintf(("GetDocumentBitStg, UNKNOWN API - stub\n"));
    564    return 0;
    565 }
    566 //*******************************************************************************
    567 //*******************************************************************************
    568 HRESULT WIN32API GetHGlobalFromILockBytes(ILockBytes *pLkbyt, HGLOBAL *phglobal)
    569 {
    570    dprintf(("GetHGlobalFromILockBytes - stub\n"));
    571    return E_INVALIDARG;
    572 }
    573 //*******************************************************************************
    574 //*******************************************************************************
    575 HRESULT WIN32API GetHGlobalFromStream(IStream *pstm, HGLOBAL *phglobal)
    576 {
    577    dprintf(("GetHGlobalFromStream - stub\n"));
    578    return E_INVALIDARG;
    579 }
    580 //*******************************************************************************
    581 //*******************************************************************************
    582 HRESULT WIN32API GetHookInterface()
    583 {
    584    dprintf(("GetHookInterface, UNKNOWN API - stub\n"));
    585    return 0;
    586 }
    587 //*******************************************************************************
    588 //*******************************************************************************
    589 //HRESULT WIN32API GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
    590 HRESULT WIN32API GetRunningObjectTable(DWORD reserved, LPVOID *pprot)
    591 {
    592    dprintf(("GetRunningObjectTable - stub\n"));
    593    return E_UNEXPECTED;
    594 }
    595 //*******************************************************************************
    596 //*******************************************************************************
    597 HRESULT WIN32API IIDFromString(LPSTR lpsz, LPIID lpiid)
    598 {
    599    dprintf(("IIDFromString - stub\n"));
    600    return E_INVALIDARG;
    601 }
    602 //*******************************************************************************
    603 //*******************************************************************************
    604 BOOL WIN32API IsAccelerator(HACCEL hAccel, INT cAccelEntries, LPMSG lpMsg,
    605                                WORD *lpwCmd)
    606 {
    607    dprintf(("IsAccelerator - stub\n"));
    608    return FALSE;
    609 }
    610 //*******************************************************************************
    611 //*******************************************************************************
    612 BOOL WIN32API CONCRETE_IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
    613 {
    614    dprintf(("IsEqualGUID - stub\n"));
    615    return FALSE;
    616 }
    617 //*******************************************************************************
    618 //*******************************************************************************
    619 HRESULT WIN32API IsValidIid(DWORD Iid)
    620 {
    621    dprintf(("IsValidIid, obsolete - stub\n"));
    622    return E_INVALIDARG;
    623 }
    624 //*******************************************************************************
    625 //*******************************************************************************
    626 HRESULT WIN32API IsValidInterface(DWORD interface_)
    627 {
    628    dprintf(("IsValidInterface, obsolete - stub\n"));
    629    return E_INVALIDARG;
    630 }
    631 //*******************************************************************************
    632 //*******************************************************************************
    633 HRESULT WIN32API IsValidPtrIn(DWORD ptrIn)
    634 {
    635    dprintf(("IsValidPtrIn, obsolete - stub\n"));
    636    return E_INVALIDARG;
    637 }
    638 //*******************************************************************************
    639 //*******************************************************************************
    640 HRESULT WIN32API IsValidPtrOut(DWORD ptrOut)
    641 {
    642    dprintf(("IsValidPtrOut, obsolete - stub\n"));
    643    return E_INVALIDARG;
    644 }
    645 //*******************************************************************************
    646 //*******************************************************************************
    647 HRESULT WIN32API MkParseDisplayName(LPBC pbc, LPSTR szUserName, ULONG *lpchEaten,
    648                                         LPMONIKER *ppmk)
    649 {
    650    dprintf(("MkParseDisplayName - stub\n"));
    651    return E_OUTOFMEMORY;
    652 }
    653 //*******************************************************************************
    654 //*******************************************************************************
    655 HRESULT WIN32API MonikerCommonPrefixWith(LPMONIKER pmkThis, LPMONIKER pmkOther,
    656                                             LPMONIKER *ppmkCommon)
    657 {
    658    dprintf(("MonikerCommonPrefixWith - stub\n"));
    659    return E_OUTOFMEMORY;
    660 }
    661 //*******************************************************************************
    662 //*******************************************************************************
    663 HRESULT WIN32API MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest,
    664                                           LPMONIKER *ppmkRelPath, BOOL dwReserved )
    665 {
    666    dprintf(("MonikerRelativePathTo - stub\n"));
    667    return E_OUTOFMEMORY;
    668 }
    669 //*******************************************************************************
    670 //*******************************************************************************
    671 DWORD WIN32API OleBuildVersion()
    672 {
    673    dprintf(("OleBuildVersion, obsolete - stub\n"));
    674    return 666;
    675 }
    676 //*******************************************************************************
    677 //*******************************************************************************
    678 HRESULT WIN32API OleConvertIStorageToOLESTREAM(IStorage *pStg, LPOLESTREAM lpolestream)
    679 {
    680    dprintf(("OleConvertIStorageToOLESTREAM - stub\n"));
    681    return E_INVALIDARG;
    682 }
    683 //*******************************************************************************
    684 //*******************************************************************************
    685 HRESULT WIN32API OleConvertIStorageToOLESTREAMEx(LPSTORAGE      pStg,
    686                                                  CLIPFORMAT     ctFormat,
    687                                                  LONG           lWidth,
    688                                                  LONG           lHeight,
    689                                                  DWORD          dwSize,
    690                                                  LPSTGMEDIUM    pmedium,
    691                                                  LPOLESTREAM    lpolestream)
    692 {
    693    dprintf(("OleConvertIStorageToOLESTREAMEx - stub\n"));
    694    return(E_INVALIDARG);
    695 }
    696 //*******************************************************************************
    697 //*******************************************************************************
    698 HRESULT WIN32API OleConvertOLESTREAMToIStorage(LPOLESTREAM lpolestream,
    699                                                   IStorage *pstg,
    700                                                   const DVTARGETDEVICE *ptd)
    701 {
    702    dprintf(("OleConvertOLESTREAMToIStorage - stub\n"));
    703    return(E_INVALIDARG);
    704 }
    705 //*******************************************************************************
    706 //*******************************************************************************
    707 HRESULT WIN32API OleConvertOLESTREAMToIStorageEx(LPOLESTREAM    lpolestream,
    708                                                  LPSTORAGE      pstg,
    709                                                  CLIPFORMAT *   ctFormat,
    710                                                  LONG *         plWidth,
    711                                                  LONG *         plHeight,
    712                                                  DWORD *        pdwSize,
    713                                                  LPSTGMEDIUM    pmedium)
    714 {
    715    dprintf(("OleConvertOLESTREAMToIStorageEx - stub\n"));
    716    return(E_OUTOFMEMORY);
    717 }
    718 //*******************************************************************************
    719 //*******************************************************************************
    720 HRESULT WIN32API OleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt,
    721                               FORMATETC *pFormatEtc, IOleClientSite *pClientSite,
    722                               IStorage *pStg, void **ppvObject)
    723 {
    724    dprintf(("OleCreate - stub\n"));
    725    return(E_OUTOFMEMORY);
    726 }
    727 //*******************************************************************************
    728 //*******************************************************************************
    729 HRESULT WIN32API OleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter,
    730                                             REFIID riid, LPVOID *ppvObj)
    731 {
    732    dprintf(("OleCreateDefaultHandler - stub\n"));
    733    return(E_OUTOFMEMORY);
    734 }
    735 //*******************************************************************************
    736 //*******************************************************************************
    737 HRESULT WIN32API OleCreateEmbeddingHelper(REFCLSID clsid, LPUNKNOWN pUnkOuter,
    738                                              DWORD flags, LPCLASSFACTORY pCF,
    739                                              REFIID riid, LPVOID *ppvObj)
    740 {
    741    dprintf(("OleCreateEmbeddingHelper - stub\n"));
    742    return(E_OUTOFMEMORY);
    743 }
    744 //*******************************************************************************
    745 //*******************************************************************************
    746 HRESULT WIN32API OleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
    747                                       DWORD renderopt, LPFORMATETC pFormatEtc,
    748                                       LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
    749                                       LPVOID *ppvObj)
    750 {
    751    dprintf(("OleCreateFromData - stub\n"));
    752    return(DV_E_FORMATETC);
    753 }
    754 //*******************************************************************************
    755 //*******************************************************************************
    756 HRESULT WIN32API OleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName,
    757                                       REFIID riid,
    758                                       DWORD renderopt, LPFORMATETC pFormatEtc,
    759                                       LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
    760                                       LPVOID *ppvObj)
    761 {
    762    dprintf(("OleCreateFromFile - stub\n"));
    763    return(E_OUTOFMEMORY);
    764 }
    765 //*******************************************************************************
    766 //*******************************************************************************
    767 HRESULT WIN32API OleCreateLink(LPMONIKER lpmkLinkSrc, REFIID riid,
    768                                   DWORD renderopt, LPFORMATETC pFormatEtc,
    769                                   LPOLECLIENTSITE lpClientSite, LPSTORAGE pStg,
    770                                   LPVOID *ppvObj)
    771 {
    772    dprintf(("OleCreateLink - stub\n"));
    773    return(E_OUTOFMEMORY);
    774 }
    775 //*******************************************************************************
    776 //*******************************************************************************
    777 HRESULT WIN32API OleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
    778                                           DWORD renderopt, LPFORMATETC pFormatEtc,
    779                                           LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
    780                                           LPVOID *ppvObj)
    781 {
    782    dprintf(("OleCreateLinkFromData - stub\n"));
    783    return(E_OUTOFMEMORY);
    784 }
    785 //*******************************************************************************
    786 //*******************************************************************************
    787 HRESULT WIN32API OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt,
    788                                         LPFORMATETC pFormatEtc, IOleClientSite *pClientSite,
    789                                         IStorage *pStg, void **ppvObj)
    790 {
    791    dprintf(("OleCreateLinkToFile - stub\n"));
    792    return(STG_E_FILENOTFOUND);
    793 }
    794 //*******************************************************************************
    795 //*******************************************************************************
    796 HOLEMENU WIN32API OleCreateMenuDescriptor(HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
    797 {
    798    dprintf(("OleCreateMenuDescriptor - stub\n"));
    799    return(NULL);
    800 }
    801 //*******************************************************************************
    802 //*******************************************************************************
    803 HRESULT WIN32API OleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
    804                                             DWORD renderopt, LPFORMATETC pFormatEtc,
    805                                             LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
    806                                             LPVOID *ppvObj)
    807 {
    808    dprintf(("OleCreateStaticFromData - stub\n"));
    809    return(E_OUTOFMEMORY);
    810 }
    811 //*******************************************************************************
    812 //*******************************************************************************
    813 HRESULT WIN32API OleDestroyMenuDescriptor(HOLEMENU holemenu)
    814 {
    815    dprintf(("OleDestroyMenuDescriptor - stub\n"));
    816    return E_OUTOFMEMORY;
    817 }
    818 //*******************************************************************************
    819 //*******************************************************************************
    820 HRESULT WIN32API OleDoAutoConvert(IStorage *pStg, LPCLSID pClsidNew)
    821 {
    822    dprintf(("OleDoAutoConvert - stub\n"));
    823    return(E_OUTOFMEMORY);
    824 }
    825 //*******************************************************************************
    826 //*******************************************************************************
    827 HRESULT WIN32API OleDraw(IUnknown *pUnk, DWORD dwAspect, HDC hdcDraw,
    828                             LPCRECT lprcBounds)
    829 {
    830    dprintf(("OleDraw - stub\n"));
    831    return(E_INVALIDARG);
    832 }
    833 //*******************************************************************************
    834 //*******************************************************************************
    835 HANDLE WIN32API OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags)
    836 {
    837    dprintf(("OleDuplicateData - stub\n"));
    838    return(NULL);
    839 }
    840 //*******************************************************************************
    841 //*******************************************************************************
    842 HRESULT WIN32API OleFlushClipboard()
    843 {
    844    dprintf(("OleFlushClipboard - stub\n"));
    845    return(S_OK);
    846 }
    847 //*******************************************************************************
    848 //*******************************************************************************
    849 HRESULT WIN32API OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
    850 {
    851    dprintf(("OleGetAutoConvert - stub\n"));
    852    return(E_OUTOFMEMORY);
    853 }
    854 //*******************************************************************************
    855 //*******************************************************************************
    856 HRESULT WIN32API OleGetClipboard(IDataObject **ppDataObj)
    857 {
    858    dprintf(("OleGetClipboard - stub\n"));
    859    return(E_OUTOFMEMORY);
    860 }
    861 //*******************************************************************************
    862 //*******************************************************************************
    863 HGLOBAL WIN32API OleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
    864 {
    865    dprintf(("OleGetIconOfClass - stub\n"));
    866    return(NULL);
    867 }
    868 //*******************************************************************************
    869 //*******************************************************************************
    870 HGLOBAL WIN32API OleGetIconOfFile(LPOLESTR lpszPath, BOOL fUseTypeAsLabel)
    871 {
    872    dprintf(("OleGetIconOfFile - stub\n"));
    873    return(NULL);
    874 }
    875 //*******************************************************************************
    876 //*******************************************************************************
    877 HRESULT WIN32API OleInitialize(LPVOID pvReserved)
    878 {
    879    dprintf(("OleInitialize - stub\n"));
    880 //   return(E_OUTOFMEMORY);
    881    return(0);
    882 }
    883 //*******************************************************************************
    884 //*******************************************************************************
    885 HRESULT WIN32API OleInitializeWOW()
    886 {
    887    dprintf(("OleInitializeWOW, UNKNOWN API - stub\n"));
    888    return(E_OUTOFMEMORY);
    889 }
    890 //*******************************************************************************
    891 //*******************************************************************************
    892 HRESULT WIN32API OleIsCurrentClipboard(IDataObject *pDataObject)
    893 {
    894    dprintf(("OleIsCurrentClipboard - stub\n"));
    895    return(S_FALSE);
    896 }
    897 //*******************************************************************************
    898 //*******************************************************************************
    899 BOOL WIN32API OleIsRunning(LPOLEOBJECT pObject)
    900 {
    901    dprintf(("OleIsRunning - stub\n"));
    902    return(FALSE);
    903 }
    904 //*******************************************************************************
    905 //*******************************************************************************
    906 HRESULT WIN32API OleLoad(IStorage *pStg, REFIID riid, IOleClientSite *pClientSite,
    907                             LPVOID *ppvObj)
    908 {
    909    dprintf(("OleLoad - stub\n"));
    910    return(E_OUTOFMEMORY);
    911 }
    912 //*******************************************************************************
    913 //*******************************************************************************
    914 HRESULT WIN32API OleLoadFromStream(IStream *pStm, REFIID riid, void *ppvObj)
    915 {
    916    dprintf(("OleLoadFromStream - stub\n"));
    917    return(E_OUTOFMEMORY);
    918 }
    919 //*******************************************************************************
    920 //*******************************************************************************
    921 HRESULT WIN32API OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
    922 {
    923    dprintf(("OleLockRunning - stub\n"));
    924    return(E_OUTOFMEMORY);
    925 }
    926 //*******************************************************************************
    927 //*******************************************************************************
    928 HGLOBAL WIN32API OleMetafilePictFromIconAndLabel(HICON hIcon, LPOLESTR lpszLabel,
    929                                                     LPOLESTR lpszSourceFile,
    930                                                     UINT iIconIndex)
    931 {
    932    dprintf(("OleMetafilePictFromIconAndLabel - stub\n"));
    933    return(NULL);
    934 }
    935 //*******************************************************************************
    936 //*******************************************************************************
    937 HRESULT WIN32API OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL fVisible)
    938 {
    939    dprintf(("OleNoteObjectVisible - stub\n"));
    940    return(E_OUTOFMEMORY);
    941 }
    942 //*******************************************************************************
    943 //*******************************************************************************
    944 HRESULT WIN32API OleQueryCreateFromData(IDataObject *pSrcDataObject)
    945 {
    946    dprintf(("OleQueryCreateFromData - stub\n"));
    947    return(S_FALSE);
    948 }
    949 //*******************************************************************************
    950 //*******************************************************************************
    951 HRESULT WIN32API OleQueryLinkFromData(IDataObject *pSrcDataObject)
    952 {
    953    dprintf(("OleQueryLinkFromData - stub\n"));
    954    return(S_FALSE);
    955 }
    956 //*******************************************************************************
    957 //*******************************************************************************
    958 HRESULT WIN32API OleRegEnumFormatEtc(REFCLSID clsid, DWORD dwDirection,
    959                                         LPENUMFORMATETC *ppenumFormatetc)
    960 {
    961    dprintf(("OleRegEnumFormatEtc - stub\n"));
    962    return(E_OUTOFMEMORY);
    963 }
    964 //*******************************************************************************
    965 //*******************************************************************************
    966 HRESULT WIN32API OleRegEnumVerbs(REFCLSID clsid, LPENUMOLEVERB *ppenumOleVerb)
    967 {
    968    dprintf(("OleRegEnumVerbs - stub\n"));
    969    return(E_OUTOFMEMORY);
    970 }
    971 //*******************************************************************************
    972 //*******************************************************************************
    973 HRESULT WIN32API OleRegGetMiscStatus(REFCLSID clsid, DWORD dwAspect, DWORD *pdwStatus)
    974 {
    975    dprintf(("OleRegGetMiscStatus - stub\n"));
    976    return(E_OUTOFMEMORY);
    977 }
    978 //*******************************************************************************
    979 //*******************************************************************************
    980 HRESULT WIN32API OleRegGetUserType(REFCLSID clsid, DWORD dwFormOfType,
    981                                       LPOLESTR *pszUserType)
    982 {
    983    dprintf(("OleRegGetUserType - stub\n"));
    984    return(E_OUTOFMEMORY);
    985 }
    986 //*******************************************************************************
    987 //*******************************************************************************
    988 HRESULT WIN32API OleRun(LPUNKNOWN pUnknown)
    989 {
    990    dprintf(("OleRun - stub\n"));
    991    return(E_UNEXPECTED);
    992 }
    993 //*******************************************************************************
    994 //*******************************************************************************
    995 HRESULT WIN32API OleSave(IPersistStorage *pPS, IStorage *pStg, BOOL fSameAsLoad)
    996 {
    997    dprintf(("OleSave - stub\n"));
    998    return(STG_E_MEDIUMFULL);
    999 }
    1000 //*******************************************************************************
    1001 //*******************************************************************************
    1002 HRESULT WIN32API OleSaveToStream(IPersistStorage *pPS, IStream *pStm)
    1003 {
    1004    dprintf(("OleSaveToStream - stub\n"));
    1005    return(STG_E_MEDIUMFULL);
    1006 }
    1007 //*******************************************************************************
    1008 //*******************************************************************************
    1009 HRESULT WIN32API OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
    1010 {
    1011    dprintf(("OleSetAutoConvert - stub\n"));
    1012    return(E_OUTOFMEMORY);
    1013 }
    1014 //*******************************************************************************
    1015 //*******************************************************************************
    1016 HRESULT WIN32API OleSetClipboard(IDataObject *pDataObj)
    1017 {
    1018    dprintf(("OleSetClipboard - stub\n"));
    1019    return(E_OUTOFMEMORY);
    1020 }
    1021 //*******************************************************************************
    1022 //*******************************************************************************
    1023 HRESULT WIN32API OleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained)
    1024 {
    1025    dprintf(("OleSetContainedObject - stub\n"));
    1026    return(E_OUTOFMEMORY);
    1027 }
    1028 //*******************************************************************************
    1029 //*******************************************************************************
    1030 HRESULT WIN32API OleSetMenuDescriptor(HOLEMENU holemenu, HWND hwndFrame,
    1031                                          HWND hwndActiveObject,
    1032                                          LPOLEINPLACEFRAME lpFrame,
    1033                                          LPOLEINPLACEACTIVEOBJECT lpActiveObj)
    1034 {
    1035    dprintf(("OleSetMenuDescriptor - stub\n"));
    1036    return(E_FAIL);
    1037 }
    1038 //*******************************************************************************
    1039 //*******************************************************************************
    1040 HRESULT WIN32API OleTranslateAccelerator(LPOLEINPLACEFRAME lpFrame,
    1041                                             LPOLEINPLACEFRAMEINFO lpFrameInfo,
    1042                                             LPMSG lpmsg)
    1043 {
    1044    dprintf(("OleTranslateAccelerator - stub\n"));
    1045    return(S_FALSE);
    1046 }
    1047 //*******************************************************************************
    1048 //*******************************************************************************
    1049 HRESULT WIN32API OpenOrCreateStream()
    1050 {
    1051    dprintf(("OpenOrCreateStream, UNKNOWN API - stub\n"));
    1052    return(E_OUTOFMEMORY);
    1053 }
    1054 //*******************************************************************************
    1055 //*******************************************************************************
    1056 HRESULT WIN32API ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *lplpszProgID)
    1057 {
    1058    dprintf(("ProgIDFromCLSID - stub\n"));
    1059    return(REGDB_E_CLASSNOTREG);
    1060 }
    1061 //*******************************************************************************
    1062 //*******************************************************************************
    1063 HRESULT WIN32API ReadClassStg(IStorage *pStg, CLSID *pclsid)
    1064 {
    1065    dprintf(("ReadClassStg - stub\n"));
    1066    return(E_OUTOFMEMORY);
    1067 }
    1068 //*******************************************************************************
    1069 //*******************************************************************************
    1070 HRESULT WIN32API ReadClassStm(IStream *pStm, CLSID *pclsid)
    1071 {
    1072    dprintf(("ReadClassStm - stub\n"));
    1073    return(STG_E_READFAULT);
    1074 }
    1075 //*******************************************************************************
    1076 //*******************************************************************************
    1077 HRESULT WIN32API ReadFmtUserTypeStg(IStorage *pStg, CLIPFORMAT *pcf,
    1078                                        LPWSTR *lplpszUserType)
    1079 {
    1080    dprintf(("ReadFmtUserTypeStg - stub\n"));
    1081    return(E_OUTOFMEMORY);
    1082 }
    1083 //*******************************************************************************
    1084 //*******************************************************************************
    1085 HRESULT WIN32API ReadOleStg()
    1086 {
    1087    dprintf(("ReadOleStg, UNKNOWN API - stub\n"));
    1088    return(E_OUTOFMEMORY);
    1089 }
    1090 //*******************************************************************************
    1091 //*******************************************************************************
    1092 HRESULT WIN32API ReadStringStream()
    1093 {
    1094    dprintf(("ReadStringStream, UNKNOWN API - stub\n"));
    1095    return(E_OUTOFMEMORY);
    1096 }
    1097 //*******************************************************************************
    1098 //*******************************************************************************
    1099 HRESULT WIN32API RegisterDragDrop(HWND hwnd, IDropTarget *pDropTarget)
    1100 {
    1101    dprintf(("RegisterDragDrop - stub\n"));
    1102    return(E_OUTOFMEMORY);
    1103 }
    1104 //*******************************************************************************
    1105 //*******************************************************************************
    1106 void WIN32API ReleaseStgMedium(STGMEDIUM *pmedium)
    1107 {
    1108    dprintf(("ReleaseStgMedium - stub\n"));
    1109    return;
    1110 }
    1111 //*******************************************************************************
    1112 //*******************************************************************************
    1113 HRESULT WIN32API RevokeDragDrop(HWND hwnd)
    1114 {
    1115    dprintf(("RevokeDragDrop - stub\n"));
    1116    return(E_OUTOFMEMORY);
    1117 }
    1118 //*******************************************************************************
    1119 //*******************************************************************************
    1120 HRESULT WIN32API SetConvertStg(IStorage *pStg, BOOL fConvert)
    1121 {
    1122    dprintf(("SetConvertStg - stub\n"));
    1123    return(E_OUTOFMEMORY);
    1124 }
    1125 //*******************************************************************************
    1126 //*******************************************************************************
    1127 HRESULT WIN32API StgCreateDocfile(const WCHAR *pwcsName, DWORD grfMode,
    1128                                      DWORD reserved, IStorage **ppstgOpen)
    1129 {
    1130    dprintf(("StgCreateDocfile - stub\n"));
    1131    return(STG_E_INSUFFICIENTMEMORY);
    1132 }
    1133 //*******************************************************************************
    1134 //*******************************************************************************
    1135 HRESULT WIN32API SetDocumentBitStg()
    1136 {
    1137    dprintf(("SetDocumentBitStg, UNKNOWN API - stub\n"));
    1138    return(E_OUTOFMEMORY);
    1139 }
    1140 //*******************************************************************************
    1141 //*******************************************************************************
    1142 HRESULT WIN32API StgCreateDocfileOnILockBytes(ILockBytes *plkbyt, DWORD grfMode,
    1143                                                  DWORD reserved, IStorage **ppstgOpen)
    1144 {
    1145    dprintf(("StgCreateDocfileOnILockBytes - stub\n"));
    1146    return(STG_E_INSUFFICIENTMEMORY);
    1147 }
    1148 //*******************************************************************************
    1149 //*******************************************************************************
    1150 HRESULT WIN32API StgIsStorageFile(const WCHAR *pwcsName)
    1151 {
    1152    dprintf(("StgIsStorageFile - stub\n"));
    1153    return(S_FALSE);
    1154 }
    1155 //*******************************************************************************
    1156 //*******************************************************************************
    1157 HRESULT WIN32API StgIsStorageILockBytes(ILockBytes *plkbyt)
    1158 {
    1159    dprintf(("StgIsStorageILockBytes - stub\n"));
    1160    return(S_FALSE);
    1161 }
    1162 //*******************************************************************************
    1163 //*******************************************************************************
    1164 HRESULT WIN32API StgOpenStorage(const WCHAR *pwcsName, IStorage *pstgPriority,
    1165                                    DWORD grfMode, SNB snbExclude, DWORD reserved,
    1166                                    IStorage **ppstgOpen)
    1167 {
    1168    dprintf(("StgOpenStorage - stub\n"));
    1169    return(STG_E_INSUFFICIENTMEMORY);
    1170 }
    1171 //*******************************************************************************
    1172 //*******************************************************************************
    1173 HRESULT WIN32API StgOpenStorageOnILockBytes(ILockBytes *plkbyt,
    1174                                                IStorage *pstgPriority,
    1175                                                DWORD grfMode, SNB snbExclude,
    1176                                                DWORD reserved,
    1177                                                IStorage **ppstgOpen)
    1178 {
    1179    dprintf(("StgOpenStorageOnILockBytes - stub\n"));
    1180    return(STG_E_INSUFFICIENTMEMORY);
    1181 }
    1182 //*******************************************************************************
    1183 //*******************************************************************************
    1184 HRESULT WIN32API StgSetTimes(WCHAR const *lpszName, FILETIME const *pctime,
    1185                                 FILETIME const *patime, FILETIME const *pmtime)
    1186 {
    1187    dprintf(("StgSetTimes - stub\n"));
    1188    return(STG_E_FILENOTFOUND);
    1189 }
    1190 //*******************************************************************************
    1191 //Freed in CoTaskMemFree
    1192 //*******************************************************************************
    1193 HRESULT WIN32API StringFromCLSID(REFCLSID rclsid, LPOLESTR *ppsz)
    1194 {
    1195  char   szclass[64];
    1196  WCHAR *szclsid = (WCHAR *)malloc(64*sizeof(WCHAR));
    1197 
    1198    dprintf(("StringFromCLSID\n"));
    1199 
    1200    sprintf(szclass, "[%8X-%4X-%4X-%4X-%4X%8X]", rclsid.Data1, rclsid.Data2, rclsid.Data3,
    1201            *(WORD *)rclsid.Data4, *(WORD *)&rclsid.Data4[2], *(DWORD *)&rclsid.Data4[4]);
    1202    AsciiToUnicode(szclass, szclsid);
    1203    *ppsz = (LPOLESTR)szclsid;
    1204    return(S_OK);
    1205 }
    1206 //*******************************************************************************
    1207 //*******************************************************************************
    1208 int WIN32API StringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax)
    1209 {
    1210  char szclsid[64];
    1211 
    1212    dprintf(("StringFromGUID2\n"));
    1213    if(cbMax < 55)
    1214         return(0);
    1215 
    1216    sprintf(szclsid, "[%8X-%4X-%4X-%4X-%4X%8X]", rguid.Data1, rguid.Data2, rguid.Data3,
    1217            *(WORD *)rguid.Data4, *(WORD *)&rguid.Data4[2], *(DWORD *)&rguid.Data4[4]);
    1218    AsciiToUnicode(szclsid, lpsz);
    1219    return(55);  //including 0 terminator
    1220 }
    1221 //*******************************************************************************
    1222 //Freed in CoTaskMemFree
    1223 //*******************************************************************************
    1224 HRESULT WIN32API StringFromIID(REFIID riid, LPOLESTR *lplpsz)
    1225 {
    1226  char   szclass[64];
    1227  WCHAR *szclsid = (WCHAR *)malloc(64*sizeof(WCHAR));
    1228 
    1229    dprintf(("StringFromIID\n"));
    1230 
    1231    sprintf(szclass, "[%8X-%4X-%4X-%4X-%4X%8X]", riid.Data1, riid.Data2, riid.Data3,
    1232            *(WORD *)riid.Data4, *(WORD *)&riid.Data4[2], *(DWORD *)&riid.Data4[4]);
    1233 
    1234    AsciiToUnicode(szclass, szclsid);
    1235    *lplpsz = (LPOLESTR)szclsid;
    1236    return(S_OK);
    1237 }
    1238 //*******************************************************************************
    1239 //*******************************************************************************
    1240 HRESULT WIN32API UtConvertDvtd16toDvtd32()
    1241 {
    1242    dprintf(("UtConvertDvtd16toDvtd32, UNKNOWN API - stub\n"));
    1243    return(E_OUTOFMEMORY);
    1244 }
    1245 //*******************************************************************************
    1246 //*******************************************************************************
    1247 HRESULT WIN32API UtConvertDvtd32toDvtd16()
    1248 {
    1249    dprintf(("UtConvertDvtd32toDvtd16, UNKNOWN API - stub\n"));
    1250    return(E_OUTOFMEMORY);
    1251 }
    1252 //*******************************************************************************
    1253 //*******************************************************************************
    1254 HRESULT WIN32API UtGetDvtd16Info()
    1255 {
    1256    dprintf(("UtGetDvtd16Info, UNKNOWN API - stub\n"));
    1257    return(E_OUTOFMEMORY);
    1258 }
    1259 //*******************************************************************************
    1260 //*******************************************************************************
    1261 HRESULT WIN32API UtGetDvtd32Info()
    1262 {
    1263    dprintf(("UtGetDvtd32Info, UNKNOWN API - stub\n"));
    1264    return(E_OUTOFMEMORY);
    1265 }
    1266 //*******************************************************************************
    1267 //*******************************************************************************
    1268 HRESULT WIN32API WriteClassStg(IStorage *pStg, REFCLSID rclsid)
    1269 {
    1270    dprintf(("WriteClassStg - stub\n"));
    1271    return(STG_E_MEDIUMFULL);
    1272 }
    1273 //*******************************************************************************
    1274 //*******************************************************************************
    1275 HRESULT WIN32API WriteClassStm(IStream *pStm, REFCLSID rclsid)
    1276 {
    1277    dprintf(("WriteClassStm - stub\n"));
    1278    return(STG_E_MEDIUMFULL);
    1279 }
    1280 //*******************************************************************************
    1281 //*******************************************************************************
    1282 HRESULT WIN32API WriteFmtUserTypeStg(IStorage *pStg, CLIPFORMAT cf, LPWSTR *lpszUserType)
    1283 {
    1284    dprintf(("WriteFmtUserTypeStg - stub\n"));
    1285    return(STG_E_MEDIUMFULL);
    1286 }
    1287 //*******************************************************************************
    1288 //*******************************************************************************
    1289 HRESULT WIN32API WriteOleStg()
    1290 {
    1291    dprintf(("WriteOleStg, UNKNOWN API - stub\n"));
    1292    return(E_OUTOFMEMORY);
    1293 }
    1294 //*******************************************************************************
    1295 //*******************************************************************************
    1296 HRESULT WIN32API WriteStringStream()
    1297 {
    1298    dprintf(("WriteStringStream, UNKNOWN API - stub\n"));
    1299    return(E_OUTOFMEMORY);
    1300 }
    1301 //*******************************************************************************
    1302 //*******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.