w32win32.cpp

Windows CE 6.0 Word Application 源码

    LPFORMATETC pfetc,
    IOleClientSite *psite,
    IStorage *pstg,
    void **ppv
)
{
    static void *pOleCreateStaticFromData = NULL;
    if (pOleCreateStaticFromData == NULL)
        SetProcAddr( pOleCreateStaticFromData, DLL_OLE32, "OleCreateStaticFromData" );
    return ((OCSFD_CAST)pOleCreateStaticFromData)
        (pdo, rid, renderopt, pfetc, psite, pstg, ppv);
}

typedef RE_OLE32API(OD_CAST)(IUnknown *, DWORD, HDC, LPCRECT);
HRESULT CW32System::OleDraw ( IUnknown *punk, DWORD dwAspect, HDC hdc, LPCRECT prect )
{
    static void *pOleDraw = NULL;
    if (pOleDraw == NULL)
        SetProcAddr( pOleDraw, DLL_OLE32, "OleDraw" );
    return ((OD_CAST)pOleDraw)(punk, dwAspect, hdc, prect);
}

typedef RE_OLE32API(OSCO_CAST)(IUnknown *, BOOL);
HRESULT CW32System::OleSetContainedObject ( IUnknown *punk, BOOL fContained )
{
    static void *pOleSetContainedObject = NULL;
    if (pOleSetContainedObject == NULL)
        SetProcAddr( pOleSetContainedObject, DLL_OLE32, "OleSetContainedObject" );
    return ((OSCO_CAST)pOleSetContainedObject)(punk, fContained);
}

typedef RE_OLE32API(CDO_CAST)(IUnknown *, DWORD);
HRESULT CW32System::CoDisconnectObject ( IUnknown *punk, DWORD dwres )
{
    static void *pCoDisconnectObject = NULL;
    if (pCoDisconnectObject == NULL)
        SetProcAddr( pCoDisconnectObject, DLL_OLE32, "CoDisconnectObject" );
    return ((CDO_CAST)pCoDisconnectObject)(punk, dwres);
}

typedef RE_OLE32API(WFUTS_CAST)(IStorage *, CLIPFORMAT, LPOLESTR);
HRESULT CW32System::WriteFmtUserTypeStg ( IStorage *pstg, CLIPFORMAT cf, LPOLESTR pstr)
{
    static void *pWriteFmtUserTypeStg = NULL;
    if (pWriteFmtUserTypeStg == NULL)
        SetProcAddr( pWriteFmtUserTypeStg, DLL_OLE32, "WriteFmtUserTypeStg" );
    return ((WFUTS_CAST)pWriteFmtUserTypeStg)(pstg, cf, pstr);
}

typedef RE_OLE32API(WCS_CAST)(IStorage *, REFCLSID);
HRESULT CW32System::WriteClassStg ( IStorage *pstg, REFCLSID rid )
{
    static void *pWriteClassStg = NULL;
    if (pWriteClassStg == NULL)
        SetProcAddr( pWriteClassStg, DLL_OLE32, "WriteClassStg" );
    return ((WCS_CAST)pWriteClassStg)(pstg, rid);
}

typedef RE_OLE32API(SCS_CAST)(IStorage *, BOOL);
HRESULT CW32System::SetConvertStg ( IStorage *pstg, BOOL fConv )
{
    static void *pSetConvertStg = NULL;
    if (pSetConvertStg == NULL)
        SetProcAddr( pSetConvertStg, DLL_OLE32, "SetConvertStg" );
    return ((SCS_CAST)pSetConvertStg)(pstg, fConv);
}

typedef RE_OLE32API(RFUTS_CAST)(IStorage *, CLIPFORMAT *, LPOLESTR *);
HRESULT CW32System::ReadFmtUserTypeStg ( IStorage *pstg, CLIPFORMAT *pcf, LPOLESTR *pstr )
{
    static void *pReadFmtUserTypeStg = NULL;
    if (pReadFmtUserTypeStg == NULL)
        SetProcAddr( pReadFmtUserTypeStg, DLL_OLE32, "ReadFmtUserTypeStg" );
    return ((RFUTS_CAST)pReadFmtUserTypeStg)(pstg, pcf, pstr);
}

typedef RE_OLE32API(RCS_CAST)(IStorage *, CLSID *);
HRESULT CW32System::ReadClassStg ( IStorage *pstg, CLSID *pclsid )
{
    static void *pReadClassStg = NULL;
    if (pReadClassStg == NULL)
        SetProcAddr( pReadClassStg, DLL_OLE32, "ReadClassStg" );
    return ((RCS_CAST)pReadClassStg)(pstg, pclsid);
}

typedef RE_OLE32API(OR_CAST)(IUnknown *);
HRESULT CW32System::OleRun ( IUnknown *punk )
{
    static void *pOleRun = NULL;
    if (pOleRun == NULL)
        SetProcAddr( pOleRun, DLL_OLE32, "OleRun" );
    return ((OR_CAST)pOleRun)(punk);
}

typedef RE_OLE32API(RevDD_CAST)(HWND);
HRESULT CW32System::RevokeDragDrop ( HWND hwnd )
{
    static void *pRevokeDragDrop = NULL;
    if (pRevokeDragDrop == NULL)
        SetProcAddr( pRevokeDragDrop, DLL_OLE32, "RevokeDragDrop" );
    return ((RevDD_CAST)pRevokeDragDrop)(hwnd);
}

typedef RE_OLE32API(CSOH_CAST)(HGLOBAL, BOOL, IStream **);
HRESULT CW32System::CreateStreamOnHGlobal ( HGLOBAL hglobal, BOOL fDel, IStream **ppstrm )
{
    static void *pCreateStreamOnHGlobal = NULL;
    if (pCreateStreamOnHGlobal == NULL)
        SetProcAddr( pCreateStreamOnHGlobal, DLL_OLE32, "CreateStreamOnHGlobal" );
    return ((CSOH_CAST)pCreateStreamOnHGlobal)(hglobal, fDel, ppstrm);
}

typedef RE_OLE32API(GHFS_CAST)(IStream *, HGLOBAL *);
HRESULT CW32System::GetHGlobalFromStream ( IStream *pstrm, HGLOBAL *phglobal )
{
    static void *pGetHGlobalFromStream = NULL;
    if (pGetHGlobalFromStream == NULL)
        SetProcAddr( pGetHGlobalFromStream, DLL_OLE32, "GetHGlobalFromStream" );
    return ((GHFS_CAST)pGetHGlobalFromStream)(pstrm, phglobal);
}

typedef RE_OLE32API(OCDH_CAST)(REFCLSID, IUnknown *, REFIID, void **);
HRESULT CW32System::OleCreateDefaultHandler (
    REFCLSID clsid,
    IUnknown *punk,
    REFIID riid,
    void **ppv
)
{
    static void *pOleCreateDefaultHandler = NULL;
    if (pOleCreateDefaultHandler == NULL)
        SetProcAddr( pOleCreateDefaultHandler, DLL_OLE32, "OleCreateDefaultHandler" );
    return ((OCDH_CAST)pOleCreateDefaultHandler)(clsid, punk, riid, ppv);
}

typedef RE_OLE32API(CFPI_CAST)(LPCOLESTR, LPCLSID);
HRESULT CW32System::CLSIDFromProgID ( LPCOLESTR pstr, LPCLSID pclsid )
{
    static void *pCLSIDFromProgID = NULL;
    if (pCLSIDFromProgID == NULL)
        SetProcAddr( pCLSIDFromProgID, DLL_OLE32, "CLSIDFromProgID" );
    return ((CFPI_CAST)pCLSIDFromProgID)(pstr, pclsid);
}

typedef RE_OLE32API(OCOTI_CAST)(LPOLESTREAM, IStorage *,
                                const DVTARGETDEVICE *);
HRESULT CW32System::OleConvertOLESTREAMToIStorage (
    LPOLESTREAM pstrm,
    IStorage *pstg,
    const DVTARGETDEVICE *ptd
)
{
    static void *pOleConvertOLESTREAMToIStorage = NULL;
    if (pOleConvertOLESTREAMToIStorage == NULL)
        SetProcAddr( pOleConvertOLESTREAMToIStorage, DLL_OLE32, "OleConvertOLESTREAMToIStorage" );
    return ((OCOTI_CAST)pOleConvertOLESTREAMToIStorage)(pstrm, pstg, ptd);
}

typedef RE_OLE32API(OL_CAST)(IStorage *, REFIID, IOleClientSite *, void **);
HRESULT CW32System::OleLoad (
    IStorage *pstg,
    REFIID riid,
    IOleClientSite *psite,
    void **ppv
)
{
    static void *pOleLoad = NULL;
    if (pOleLoad == NULL)
        SetProcAddr( pOleLoad, DLL_OLE32, "OleLoad" );
    return ((OL_CAST)pOleLoad)(pstg, riid, psite, ppv);
}

typedef RE_OLE32API(RSM_CAST)(LPSTGMEDIUM);
HRESULT CW32System::ReleaseStgMedium ( LPSTGMEDIUM pmedium )
{
    static void *pReleaseStgMedium = NULL;
    if (pReleaseStgMedium == NULL)
        SetProcAddr( pReleaseStgMedium, DLL_OLE32, "ReleaseStgMedium" );
    return ((RSM_CAST)pReleaseStgMedium)(pmedium);
}

BOOL CW32System::ImmInitialize( void )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

void CW32System::ImmTerminate( void )
{
    #pragma message ("Review : Incomplete")
    return;
}

// GuyBark: Use the system calls on Windows CE. So emulate that here for NT.
#ifndef PWD_JUPITER

LONG CW32System::ImmGetCompositionStringA ( HIMC, DWORD, LPVOID, DWORD )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

HIMC CW32System::ImmGetContext ( HWND )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

BOOL CW32System::ImmSetCompositionFontA ( HIMC, LPLOGFONTA )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::ImmSetCompositionWindow ( HIMC, LPCOMPOSITIONFORM )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::ImmReleaseContext ( HWND, HIMC )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

DWORD CW32System::ImmGetProperty ( HKL, DWORD )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

BOOL CW32System::ImmGetCandidateWindow ( HIMC, DWORD, LPCANDIDATEFORM )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::ImmSetCandidateWindow ( HIMC, LPCANDIDATEFORM )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::ImmNotifyIME ( HIMC, DWORD, DWORD, DWORD )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

HIMC CW32System::ImmAssociateContext ( HWND, HIMC )
{
    #pragma message ("Review : Incomplete")
    return NULL;
}

UINT CW32System::ImmGetVirtualKey ( HWND )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

HIMC CW32System::ImmEscape ( HKL, HIMC, UINT, LPVOID )
{
    #pragma message ("Review : Incomplete")
    return NULL;
}

LONG CW32System::ImmGetOpenStatus ( HIMC )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

BOOL CW32System::ImmGetConversionStatus ( HIMC, LPDWORD, LPDWORD )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

#endif // !PWD_JUPITER

BOOL CW32System::FSupportSty ( UINT, UINT )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

const IMESTYLE * CW32System::PIMEStyleFromAttr ( const UINT )
{
    #pragma message ("Review : Incomplete")
    return NULL;
}

const IMECOLORSTY * CW32System::PColorStyleTextFromIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return NULL;
}

const IMECOLORSTY * CW32System::PColorStyleBackFromIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return NULL;
}

BOOL CW32System::FBoldIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::FItalicIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

BOOL CW32System::FUlIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return FALSE;
}

UINT CW32System::IdUlIMEStyle ( const IMESTYLE * )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

COLORREF CW32System::RGBFromIMEColorStyle ( const IMECOLORSTY * )
{
    #pragma message ("Review : Incomplete")
    return 0;
}

CONVERTMODE WINAPI CW32System::DetermineConvertMode( BYTE tmCharSet )
{
    #pragma message ("Review : Incomplete")
    return CM_NONE;
}

void WINAPI CW32System::CalcUnderlineInfo( CCcs *pcccs, TEXTMETRIC *ptm )
{
    OUTLINETEXTMETRICA *potm;
    unsigned cb;
    CTempBuf tb;

    if (ptm->tmPitchAndFamily & TMPF_TRUETYPE)
    {
        cb = GetOutlineTextMetricsA(pcccs->_hdc, 0, NULL);

        if ((cb != 0)
            && ((potm = (OUTLINETEXTMETRICA *) tb.GetBuf(cb)) != NULL)
            && GetOutlineTextMetricsA(pcccs->_hdc, cb, potm))
        {
            pcccs->_dyULOffset = -potm->otmsUnderscorePosition;
            pcccs->_dyULWidth = max(1, potm->otmsUnderscoreSize);
            pcccs->_dySOOffset = -potm->otmsStrikeoutPosition;
            pcccs->_dySOWidth = max(1, potm->otmsStrikeoutSize);
            return;
        }
    }

    // Default calculation of size of underline
    SHORT dyDescent = pcccs->_yDescent;

    if (0 == dyDescent)
    {
        dyDescent = pcccs->_yHeight >> 3;
    }

    pcccs->_dyULWidth = max(1, dyDescent / 4);
    pcccs->_dyULOffset = (dyDescent - 3 * pcccs->_dyULWidth + 1) / 2;

    if ((0 == pcccs->_dyULOffset) && (dyDescent > 1))
    {
        pcccs->_dyULOffset = 1;
    }

    pcccs->_dySOOffset = -ptm->tmAscent / 3;
    pcccs->_dySOWidth = pcccs->_dyULWidth;

    return;
}

BOOL WINAPI CW32System::ShowScrollBar( HWND hWnd, int wBar, BOOL bShow, LONG )
{
    return ::ShowScrollBar( hWnd, wBar, bShow );
}

BOOL WINAPI CW32System::EnableScrollBar( HWND hWnd, UINT wSBflags, UINT wArrows )
{
    return ::EnableScrollBar( hWnd, wSBflags, wArrows );
}

BOOL WINAPI CW32System::REExtTextOut(
    CONVERTMODE cm,
    UINT uiCodePage,
    HDC hdc,
    int x,
    int y,
    UINT fuOptions,
    CONST RECT *lprc,
    const WCHAR *lpString,
    UINT cbCount,
    CONST INT *lpDx,
    BOOL  FEFontOnNonFEWin95
)
{
    #pragma message ("Review : Incomplete")
    return ExtTextOut(hdc, x, y, fuOptions, lprc, lpString, cbCount, lpDx);
}

BOOL WINAPI CW32System::REGetCharWidth(
    HDC hdc,
    UINT iChar,
    LPINT pAns,
    UINT        // For Windows CE the code page is not used
                //  as the A version is not called.
)
{
    #pragma message ("Review : Incomplete")

   TCHAR buff[2];
   SIZE  sz;

    buff[0] = iChar;
    buff[1] = 0;

    if (GetTextExtentPoint32(hdc, buff, 1, &sz))
    {
        *pAns = sz.cx;

        Assert(*pAns > 0);
        return TRUE;
    }

    return FALSE;
}

BOOL WINAPI CW32System::IsEnhancedMetafileDC( HDC hDC )
{
    BOOL    fEMFDC = FALSE;
    DWORD   dwObjectType;

    dwObjectType = ::GetObjectType( hDC );

    if ( OBJ_ENHMETADC == dwObjectType || OBJ_ENHMETAFILE == dwObjectType )
        fEMFDC = TRUE;
    else if ( OBJ_DC == dwObjectType )
    {
        // HACK Alert,  Enhanced Metafile DC does not support any Escape function
        // and shoudl return 0.
        int iEscapeFuction = QUERYESCSUPPORT;

        if ( Escape( hDC, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&iEscapeFuction, NULL) == 0 )