w32win32.cpp

Windows CE 6.0 Word Application 源码

{
    return ::GlobalAlloc( uFlags, dwBytes );
}

HGLOBAL WINAPI CW32System::GlobalFree( HGLOBAL hMem )
{
    return hMem ? ::GlobalFree( hMem ) : NULL;
}

UINT WINAPI CW32System::GlobalFlags( HGLOBAL hMem )
{
    return ::GlobalFlags( hMem );
}

HGLOBAL WINAPI CW32System::GlobalReAlloc( HGLOBAL hMem, DWORD dwBytes, UINT uFlags )
{
    return ::GlobalReAlloc( hMem, dwBytes, uFlags );
}

DWORD WINAPI CW32System::GlobalSize( HGLOBAL hMem )
{
    return ::GlobalSize( hMem );
}

LPVOID WINAPI CW32System::GlobalLock( HGLOBAL hMem )
{
    return ::GlobalLock( hMem );
}

HGLOBAL WINAPI CW32System::GlobalHandle( LPCVOID pMem )
{
    return ::GlobalHandle( pMem );
}

BOOL WINAPI CW32System::GlobalUnlock( HGLOBAL hMem )
{
    return ::GlobalUnlock( hMem );
}

void CW32System::CheckChangeKeyboardLayout ( CTxtSelection *psel, BOOL fChangedFont )
{
    #pragma message ("Review : Incomplete")
    return;
}

void CW32System::CheckChangeFont (
    CTxtSelection *psel,
    CTxtEdit * const ped,
    BOOL fEnableReassign,   // @parm Do we enable CTRL key?
    const WORD lcID,        // @parm LCID from WM_ message
    UINT cpg                // @parm code page to use (could be ANSI for far east with IME off)
)
{
    #pragma message ("Review : Incomplete")
    return;
}

BOOL CW32System::FormatMatchesKeyboard( const CCharFormat *pFormat )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

HKL CW32System::GetKeyboardLayout( DWORD dwTId )
{
    return ::GetKeyboardLayout( dwTId );
}

int CW32System::GetKeyboardLayoutList ( int, HKL FAR * )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

enum DLL_ENUM{
    DLL_OLEAUT32,
    DLL_OLE32
};

static HINSTANCE hOleAut32 = NULL;
static HINSTANCE hOle32 = NULL;

static void SetProcAddr( void * &pfunc, DLL_ENUM which, char * fname )
{
    HINSTANCE hdll = NULL;
    EnterCriticalSection(&g_CriticalSection);
    if (pfunc == NULL)
    {
        switch (which) {
        case DLL_OLEAUT32 :
            if (hOleAut32 == NULL)
                hOleAut32 = W32->LoadLibrary(L"oleaut32.dll" );
            Assert( hOleAut32 != NULL );
            hdll = hOleAut32;
            break;
        case DLL_OLE32 :
            if (hOle32 == NULL)
                hOle32 = W32->LoadLibrary(L"ole32.dll" );
            Assert( hOle32 != NULL );
            hdll = hOle32;
            break;
        }
        Assert(hdll != NULL);
        pfunc = GetProcAddress( hdll, fname );
    }
    Assert(pfunc != NULL );
    LeaveCriticalSection(&g_CriticalSection);
}

void CW32System::FreeOle()
{
    if (hOleAut32 || hOle32) {
        EnterCriticalSection(&g_CriticalSection);
        if (hOleAut32 != NULL && FreeLibrary(hOleAut32)) {
            hOleAut32 = NULL;
        }
        if (hOle32 != NULL && FreeLibrary(hOle32)) {
            hOle32 = NULL;
        }
        LeaveCriticalSection(&g_CriticalSection);
    }
}

#define RE_OLEAUTAPI(name)      DECLSPEC_IMPORT HRESULT (STDAPICALLTYPE *name)
#define RE_OLEAUTAPI_(type, name)   DECLSPEC_IMPORT type (STDAPICALLTYPE *name)

typedef RE_OLEAUTAPI(LRTL_CAST)(REFGUID, WORD, WORD, LCID, ITypeLib **);
HRESULT CW32System::LoadRegTypeLib (
    REFGUID rguid,
    WORD wmajor,
    WORD wminor,
    LCID lcid,
    ITypeLib ** pptlib
)
{
    static void *pLoadRegTypeLib = NULL;
    if (pLoadRegTypeLib == NULL)
        SetProcAddr( pLoadRegTypeLib, DLL_OLEAUT32, "LoadRegTypeLib" );
    return ((LRTL_CAST)pLoadRegTypeLib)(rguid, wmajor, wminor, lcid, pptlib);
}

typedef RE_OLEAUTAPI(LTL_CAST)(const OLECHAR *, ITypeLib **);
HRESULT CW32System::LoadTypeLib ( const OLECHAR *szfile, ITypeLib **pptlib )
{
    static void *pLoadTypeLib = NULL;
    if (pLoadTypeLib == NULL)
        SetProcAddr( pLoadTypeLib, DLL_OLEAUT32, "LoadTypeLib" );
    return ((LTL_CAST)pLoadTypeLib)(szfile, pptlib);
}

typedef RE_OLEAUTAPI_(BSTR, SAS_CAST)(const OLECHAR *);
BSTR CW32System::SysAllocString ( const OLECHAR * sz )
{
    static void *pSysAllocString = NULL;
    if (pSysAllocString == NULL)
        SetProcAddr( pSysAllocString, DLL_OLEAUT32, "SysAllocString" );
    return ((SAS_CAST)pSysAllocString)(sz);
}

typedef RE_OLEAUTAPI_(BSTR, SASL_CAST)(const OLECHAR *, UINT);
BSTR CW32System::SysAllocStringLen ( const OLECHAR *pch, UINT cch )
{
    static void *pSysAllocStringLen = NULL;
    if (pSysAllocStringLen == NULL)
        SetProcAddr( pSysAllocStringLen, DLL_OLEAUT32, "SysAllocStringLen" );
    return ((SASL_CAST)pSysAllocStringLen)(pch, cch);
}

typedef RE_OLEAUTAPI_(void, SFS_CAST)(BSTR);
void CW32System::SysFreeString ( BSTR bstr )
{
    static void *pSysFreeString = NULL;
    if (pSysFreeString == NULL)
        SetProcAddr( pSysFreeString, DLL_OLEAUT32, "SysFreeString" );
    ((SFS_CAST)pSysFreeString)(bstr);
}

typedef RE_OLEAUTAPI_(UINT, SSL_CAST)(BSTR);
UINT CW32System::SysStringLen ( BSTR bstr )
{
    static void *pSysStringLen = NULL;
    if (pSysStringLen == NULL)
        SetProcAddr( pSysStringLen, DLL_OLEAUT32, "SysStringLen" );
    return ((SSL_CAST)pSysStringLen)(bstr);
}

typedef RE_OLEAUTAPI_(void, VI_CAST)(VARIANTARG *);
void CW32System::VariantInit ( VARIANTARG * pvarg )
{
    static void *pVariantInit = NULL;
    if (pVariantInit == NULL)
        SetProcAddr( pVariantInit, DLL_OLEAUT32, "VariantInit" );
    ((VI_CAST)pVariantInit)(pvarg);
}

#define RE_OLE32API(name)       DECLSPEC_IMPORT HRESULT (STDAPICALLTYPE *name)
#define RE_OLE32API_(type, name) DECLSPEC_IMPORT type (STDAPICALLTYPE *name)

typedef RE_OLE32API(OCFD_CAST)(LPDATAOBJECT, REFIID, DWORD,
                               LPFORMATETC, LPOLECLIENTSITE,
                               LPSTORAGE, void **);
HRESULT CW32System::OleCreateFromData (
    LPDATAOBJECT pDataObj,
    REFIID riid,
    DWORD renderopt,
    LPFORMATETC pfetc,
    LPOLECLIENTSITE pClientSite,
    LPSTORAGE pStg,
    void **ppvObj
)
{
    static void *pOleCreateFromData = NULL;
    if (pOleCreateFromData == NULL)
        SetProcAddr( pOleCreateFromData, DLL_OLE32, "OleCreateFromData" );
    return ((OCFD_CAST)pOleCreateFromData)(pDataObj, riid, renderopt, pfetc, pClientSite, pStg, ppvObj);
}

typedef RE_OLE32API_(void, CTMF_CAST)(LPVOID);
void CW32System::CoTaskMemFree ( LPVOID pv )
{
    static void *pCoTaskMemFree = NULL;
    if (pCoTaskMemFree == NULL)
        SetProcAddr( pCoTaskMemFree, DLL_OLE32, "CoTaskMemFree" );
    ((CTMF_CAST)pCoTaskMemFree)(pv);
}

typedef RE_OLE32API(CBC_CAST)(DWORD, LPBC *);
HRESULT CW32System::CreateBindCtx ( DWORD reserved, LPBC * ppbc )
{
    static void *pCreateBindCtx = NULL;
    if (pCreateBindCtx == NULL)
        SetProcAddr( pCreateBindCtx, DLL_OLE32, "CreateBindCtx" );
    return ((CBC_CAST)pCreateBindCtx)(reserved, ppbc);
}

typedef RE_OLE32API_(HANDLE, ODD_CAST)(HANDLE, CLIPFORMAT, UINT);
HANDLE CW32System::OleDuplicateData ( HANDLE hSrc, CLIPFORMAT cfFormat, UINT uFlags )
{
    static void *pOleDuplicateData = NULL;
    if (pOleDuplicateData == NULL)
        SetProcAddr( pOleDuplicateData, DLL_OLE32, "OleDuplicateData" );
    return ((ODD_CAST)pOleDuplicateData)(hSrc, cfFormat, uFlags);
}

typedef RE_OLE32API(CTAC_CAST)(REFCLSID, REFCLSID);
HRESULT CW32System::CoTreatAsClass ( REFCLSID clsidold, REFCLSID clsidnew )
{
    static void *pCoTreatAsClass = NULL;
    if (pCoTreatAsClass == NULL)
        SetProcAddr( pCoTreatAsClass, DLL_OLE32, "CoTreatAsClass" );
    return ((CTAC_CAST)pCoTreatAsClass)(clsidold, clsidnew);
}

typedef RE_OLE32API(PIFC_CAST)(REFCLSID, LPOLESTR *);
HRESULT CW32System::ProgIDFromCLSID ( REFCLSID clsid, LPOLESTR * lplpszProgId )
{
    static void *pProgIDFromCLSID = NULL;
    if (pProgIDFromCLSID == NULL)
        SetProcAddr( pProgIDFromCLSID, DLL_OLE32, "ProgIDFromCLSID" );
    return ((PIFC_CAST)pProgIDFromCLSID)(clsid, lplpszProgId);
}

typedef RE_OLE32API(OCITO_CAST)(LPSTORAGE, LPOLESTREAM);
HRESULT CW32System::OleConvertIStorageToOLESTREAM ( LPSTORAGE pstg, LPOLESTREAM lpolestream)
{
    static void *pOleConvertIStorageToOLESTREAM = NULL;
    if (pOleConvertIStorageToOLESTREAM == NULL)
        SetProcAddr( pOleConvertIStorageToOLESTREAM, DLL_OLE32, "OleConvertIStorageToOLESTREAM" );
    return ((OCITO_CAST)pOleConvertIStorageToOLESTREAM)(pstg, lpolestream);
}

typedef RE_OLE32API(OCITOX_CAST)(LPSTORAGE, CLIPFORMAT, LONG, LONG, DWORD, LPSTGMEDIUM, LPOLESTREAM);
HRESULT CW32System::OleConvertIStorageToOLESTREAMEx (
    LPSTORAGE pstg,
    CLIPFORMAT cf,
    LONG lwidth,
    LONG lheight,
    DWORD dwsize,
    LPSTGMEDIUM pmedium,
    LPOLESTREAM lpolestream
)
{
    static void *pOleConvertIStorageToOLESTREAMEx = NULL;
    if (pOleConvertIStorageToOLESTREAMEx == NULL)
        SetProcAddr( pOleConvertIStorageToOLESTREAMEx, DLL_OLE32, "OleConvertIStorageToOLESTREAMEx" );
    return ((OCITOX_CAST)pOleConvertIStorageToOLESTREAMEx)
        (pstg,cf, lwidth, lheight, dwsize, pmedium, lpolestream);
}

typedef RE_OLE32API(OS_CAST)(LPPERSISTSTORAGE, LPSTORAGE, BOOL);
HRESULT CW32System::OleSave ( LPPERSISTSTORAGE pPS, LPSTORAGE pstg, BOOL fSameAsLoad )
{
    static void *pOleSave = NULL;
    if (pOleSave == NULL)
        SetProcAddr( pOleSave, DLL_OLE32, "OleSave" );
    return ((OS_CAST)pOleSave)(pPS, pstg, fSameAsLoad);
}

typedef RE_OLE32API(SCDOI_CAST)(ILockBytes *, DWORD, DWORD, IStorage **);
HRESULT CW32System::StgCreateDocfileOnILockBytes (
    ILockBytes *plkbyt,
    DWORD grfmode,
    DWORD res,
    IStorage **ppstg
)
{
    static void *pStgCreateDocfileOnILockBytes = NULL;
    if (pStgCreateDocfileOnILockBytes == NULL)
        SetProcAddr( pStgCreateDocfileOnILockBytes, DLL_OLE32, "StgCreateDocfileOnILockBytes" );
    return ((SCDOI_CAST)pStgCreateDocfileOnILockBytes)(plkbyt, grfmode, res, ppstg);
}

typedef RE_OLE32API(CIOH_CAST)(HGLOBAL, BOOL, ILockBytes **);
HRESULT CW32System::CreateILockBytesOnHGlobal ( HGLOBAL hGlobal, BOOL fDel, ILockBytes **pplkbyt )
{
    static void *pCreateILockBytesOnHGlobal = NULL;
    if (pCreateILockBytesOnHGlobal == NULL)
        SetProcAddr( pCreateILockBytesOnHGlobal, DLL_OLE32, "CreateILockBytesOnHGlobal" );
    return ((CIOH_CAST)pCreateILockBytesOnHGlobal)(hGlobal, fDel, pplkbyt);
}

typedef RE_OLE32API(OCLTF_CAST)(LPCOLESTR, REFIID, DWORD, LPFORMATETC,
                                LPOLECLIENTSITE, LPSTORAGE, void **);
HRESULT CW32System::OleCreateLinkToFile(
    LPCOLESTR pstr,
    REFIID rid,
    DWORD renderopt,
    LPFORMATETC pfetc,
    LPOLECLIENTSITE psite,
    LPSTORAGE pstg,
    void **ppstg
)
{
    static void *pOleCreateLinkToFile = NULL;
    if (pOleCreateLinkToFile == NULL)
        SetProcAddr( pOleCreateLinkToFile, DLL_OLE32, "OleCreateLinkToFile" );
    return ((OCLTF_CAST)pOleCreateLinkToFile)(pstr, rid, renderopt, pfetc, psite, pstg, ppstg);
}

typedef RE_OLE32API_(LPVOID, CTMA_CAST)(ULONG);
LPVOID CW32System::CoTaskMemAlloc ( ULONG cb )
{
    static void *pCoTaskMemAlloc = NULL;
    if (pCoTaskMemAlloc == NULL)
        SetProcAddr( pCoTaskMemAlloc, DLL_OLE32, "CoTaskMemAlloc" );
    return ((CTMA_CAST)pCoTaskMemAlloc)(cb);
}

typedef RE_OLE32API_(LPVOID, CTMR_CAST)(LPVOID, ULONG);
LPVOID CW32System::CoTaskMemRealloc ( LPVOID pv, ULONG cv)
{
    static void *pCoTaskMemRealloc = NULL;
    if (pCoTaskMemRealloc == NULL)
        SetProcAddr( pCoTaskMemRealloc, DLL_OLE32, "CoTaskMemRealloc" );
    return ((CTMR_CAST)pCoTaskMemRealloc)(pv, cv);
}

typedef RE_OLE32API(OI_CAST)(LPVOID);
HRESULT CW32System::OleInitialize ( LPVOID pvres )
{
    static void *pOleInitialize = NULL;
    if (pOleInitialize == NULL)
        SetProcAddr( pOleInitialize, DLL_OLE32, "OleInitialize" );
    return ((OI_CAST)pOleInitialize)(pvres);
}

typedef RE_OLE32API_(void, OUI_CAST)( void );
void CW32System::OleUninitialize ( void )
{
    static void *pOleUninitialize = NULL;
    if (pOleUninitialize == NULL)
        SetProcAddr( pOleUninitialize, DLL_OLE32, "OleUninitialize" );
    ((OUI_CAST)pOleUninitialize)();
}

typedef RE_OLE32API(OSC_CAST)(IDataObject *);
HRESULT CW32System::OleSetClipboard ( IDataObject *pdo )
{
    static void *pOleSetClipboard = NULL;
    if (pOleSetClipboard == NULL)
        SetProcAddr( pOleSetClipboard, DLL_OLE32, "OleSetClipboard" );
    return ((OSC_CAST)pOleSetClipboard)(pdo);
}

typedef RE_OLE32API(OFC_CAST)(void);
HRESULT CW32System::OleFlushClipboard ( void )
{
    static void *pOleFlushClipboard = NULL;
    if (pOleFlushClipboard == NULL)
        SetProcAddr( pOleFlushClipboard, DLL_OLE32, "OleFlushClipboard" );
    return ((OFC_CAST)pOleFlushClipboard)();
}

typedef RE_OLE32API(OICC_CAST)(IDataObject *);
HRESULT CW32System::OleIsCurrentClipboard ( IDataObject *pdo )
{
    static void *pOleIsCurrentClipboard = NULL;
    if (pOleIsCurrentClipboard == NULL)
        SetProcAddr( pOleIsCurrentClipboard, DLL_OLE32, "OleIsCurrentClipboard" );
    return ((OICC_CAST)pOleIsCurrentClipboard)(pdo);
}

typedef RE_OLE32API(DDD_CAST)(IDataObject *, IDropSource *,
            DWORD, DWORD *);
HRESULT CW32System::DoDragDrop ( IDataObject *pdo, IDropSource *pds, DWORD dweffect, DWORD *pdweffect )
{
    static void *pDoDragDrop = NULL;
    if (pDoDragDrop == NULL)
        SetProcAddr( pDoDragDrop, DLL_OLE32, "DoDragDrop" );
    return ((DDD_CAST)pDoDragDrop)(pdo, pds, dweffect, pdweffect);
}

typedef RE_OLE32API(OGC_CAST)(IDataObject **);
HRESULT CW32System::OleGetClipboard ( IDataObject **ppdo )
{
    static void *pOleGetClipboard = NULL;
    if (pOleGetClipboard == NULL)
        SetProcAddr( pOleGetClipboard, DLL_OLE32, "OleGetClipboard" );
    return ((OGC_CAST)pOleGetClipboard)(ppdo);
}

typedef RE_OLE32API(RDD_CAST)(HWND, IDropTarget *);
HRESULT CW32System::RegisterDragDrop ( HWND hwnd, IDropTarget *pdt )
{
    static void *pRegisterDragDrop = NULL;
    if (pRegisterDragDrop == NULL)
        SetProcAddr( pRegisterDragDrop, DLL_OLE32, "RegisterDragDrop" );
    return ((RDD_CAST)pRegisterDragDrop)(hwnd, pdt);
}

typedef RE_OLE32API(OCLFD_CAST)(IDataObject *, REFIID, DWORD,
                                LPFORMATETC, IOleClientSite *,
                                IStorage *, void **);
HRESULT CW32System::OleCreateLinkFromData (
    IDataObject *pdo,
    REFIID rid,
    DWORD renderopt,
    LPFORMATETC pfetc,
    IOleClientSite *psite,
    IStorage *pstg,
    void **ppv
)
{
    static void *pOleCreateLinkFromData = NULL;
    if (pOleCreateLinkFromData == NULL)
        SetProcAddr( pOleCreateLinkFromData, DLL_OLE32, "OleCreateLinkFromData" );
    return ((OCLFD_CAST)pOleCreateLinkFromData)
        (pdo, rid, renderopt, pfetc, psite, pstg, ppv);
}

typedef RE_OLE32API(OCSFD_CAST)(IDataObject *, REFIID, DWORD,
                                LPFORMATETC, IOleClientSite *,
                                IStorage *, void **);
HRESULT CW32System::OleCreateStaticFromData (
    IDataObject *pdo,
    REFIID rid,
    DWORD renderopt,