Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
shole.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 34k
Category:

Windows Kernel

Development Platform:

Visual C++

shole.cpp：Code Content
  1. #include "shole.h"
  2. #include "ids.h"
  3. #include "scguid.h"
  5. #define CLONE_IT_IF_READONLY
  7. class CShClientSite : public IOleClientSite, public IAdviseSink2
  8. {
  9. public:
  10.     CShClientSite(HWND hwndOwner, LPCTSTR pszCmdLine);
  11.     LPCTSTR  ParseCmdLine(LPCTSTR pszCmdLine);
  12.     HRESULT Load();
  13.     HRESULT DoVerb(LONG iVerb);
  14.     void    CloseOleObject();
  15.     void    ReleaseOleObject();
  16.     void    ReleaseStorage(void);
  17.     void    MaySaveAs(void);
  18.     void    Draw(HWND hwnd, HDC hdc);
  19.     void    GetFileName(LPTSTR szFile, UINT cchMax);
  20.     void    Quit(void) { _hwndOwner = NULL ; _fQuit = TRUE; }
  21.     BOOL    FContinue(void) { return !_fQuit; }
  23.     // IUnKnown
  24.     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID,void **);
  25.     virtual ULONG STDMETHODCALLTYPE AddRef(void);
  26.     virtual ULONG STDMETHODCALLTYPE Release(void);
  28.     // IOleClientSite
  29.     virtual HRESULT STDMETHODCALLTYPE SaveObject(void);
  30.     virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD, DWORD, IMoniker **);
  31.     virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer **);
  32.     virtual HRESULT STDMETHODCALLTYPE ShowObject(void);
  33.     virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL fShow);
  34.     virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout(void);
  36.     // IAdviseSink2
  37.     virtual void STDMETHODCALLTYPE OnDataChange(FORMATETC *,STGMEDIUM *);
  38.     virtual void STDMETHODCALLTYPE OnViewChange(DWORD dwAspect,LONG lindex);
  39.     virtual void STDMETHODCALLTYPE OnRename(IMoniker *pmk);
  40.     virtual void STDMETHODCALLTYPE OnSave(void);
  41.     virtual void STDMETHODCALLTYPE OnClose(void);
  42.     virtual void STDMETHODCALLTYPE OnLinkSrcChange(IMoniker *pmk);
  44. protected:
  45.     ~CShClientSite();
  47.     UINT                _cRef;
  48.     HWND                _hwndOwner;
  49.     LPSTORAGE           _pstgDoc;       // document
  50.     LPSTORAGE           _pstg;          // the embedding (only one)
  51.     LPPERSISTSTORAGE    _ppstg;
  52.     LPOLEOBJECT         _pole;
  53.     BOOL                _fDirty:1;
  54.     BOOL                _fNeedToSave:1;
  55.     BOOL                _fReadOnly:1;
  56.     BOOL                _fCloned:1;
  57.     BOOL                _fQuit:1;
  58.     BOOL                _fCloseImmediately:1;
  59.     DWORD               _dwConnection;  // non-zero, if valid
  60.     WCHAR               _wszFileName[MAX_PATH];
  61. };
  62. typedef CShClientSite * LPSHCLIENTSITE;
  64. const TCHAR c_szAppName[] = TEXT("ShellOleViewer");
  65. LRESULT CALLBACK ShWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
  66. void DisplayError(HWND hwndOwner, HRESULT hres, UINT idsMsg, LPCTSTR szFileName);
  68. HINSTANCE g_hinst = NULL;
  70. extern "C"
  71. BOOL APIENTRY LibMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
  72. {
  73.     switch(dwReason) {
  74.     case DLL_PROCESS_ATTACH:
  75.         g_hinst = (HINSTANCE)hDll;
  76.         DisableThreadLibraryCalls(g_hinst);
  77.         break;
  79.     default:
  80.         break;
  81.     }
  83.     return TRUE;
  84. }
  86. void WINAPI
  87. OpenScrap_RunDLL_Common(HWND hwndStub, HINSTANCE hInstApp, LPTSTR pszCmdLine, int nCmdShow)
  88. {
  89.     CShClientSite_RegisterClass();
  91.     HWND hwndClientSite = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_OVERLAPPEDWINDOW,
  92.                                    c_szAppName,
  93. #ifdef DEBUG
  94.                                    TEXT("(Debug only) SHOLE.EXE"),
  95.                                    WS_VISIBLE | WS_OVERLAPPEDWINDOW,
  96. #else
  97.                                    TEXT(""),
  98.                                    WS_OVERLAPPEDWINDOW,
  99. #endif
  100.                                    CW_USEDEFAULT, CW_USEDEFAULT,
  101.                                    128, 128, NULL, NULL, g_hinst, NULL);
  102.     if (hwndClientSite)
  103.     {
  104.         HRESULT hres;
  106.         hres = OleInitialize(NULL);
  107.         if (SUCCEEDED(hres))
  108.         {
  109.             DWORD dwTick;
  110.             LPSHCLIENTSITE pscs= new CShClientSite(hwndClientSite, pszCmdLine);
  112.             if (pscs)
  113.             {
  114.                 UINT cRef;
  116. hres = pscs->Load();
  117. if (SUCCEEDED(hres)) {
  118.     hres = pscs->DoVerb(OLEIVERB_OPEN);
  119. }
  121.                 if (hres == S_OK)
  122.                 {
  123.                     MSG msg;
  124.                     while (pscs->FContinue() && GetMessage(&msg, NULL, 0, 0))
  125.                     {
  126.                         TranslateMessage(&msg);
  127.                         DispatchMessage(&msg);
  128.                     }
  129.                 }
  130.                 else
  131.                 {
  132.                     // DoVerb failed.
  134.                     if (FAILED(hres) || (hres>=IDS_HRES_MIN && hres<IDS_HRES_MAX))
  135.                     {
  136.                         TCHAR szFile[MAX_PATH];
  137.                         pscs->GetFileName(szFile, ARRAYSIZE(szFile));
  138.                         DisplayError(hwndClientSite, hres, IDS_ERR_DOVERB, szFile);
  139.                     }
  140.                     DestroyWindow(hwndClientSite);
  141.                 }
  143.                 //
  144.                 //  We call them just in case, the following Release
  145.                 // does not release the object.
  146.                 //
  147.                 pscs->ReleaseOleObject();
  148.                 pscs->ReleaseStorage();
  149.                 pscs->MaySaveAs();
  151.                 cRef = pscs->Release();
  152.                 Assert(cRef==0);
  153.             }
  155.             DebugMsg(DM_TRACE, TEXT("so TR - WinMain About to call OleUninitialize"));
  156.             dwTick = GetCurrentTime();
  157.             OleUninitialize();
  158.             DebugMsg(DM_TRACE, TEXT("so TR - WinMain OleUninitialize took %d ticks"), GetCurrentTime()-dwTick);
  159.         }
  161.         if (IsWindow(hwndClientSite)) {
  162.             DebugMsg(DM_WARNING, TEXT("so WA - WinMain IsWindow(hwndClientSite) is still TRUE"));
  163.             DestroyWindow(hwndClientSite);
  164.         }
  165.     }
  166. }
  168. extern "C" void WINAPI
  169. OpenScrap_RunDLL(HWND hwndStub, HINSTANCE hAppInstance, LPSTR lpszCmdLine, int nCmdShow)
  170. {
  171. #ifdef UNICODE
  172.     UINT iLen = lstrlenA(lpszCmdLine)+1;
  173.     LPWSTR  lpwszCmdLine;
  175.     lpwszCmdLine = (LPWSTR)LocalAlloc(LPTR,iLen*sizeof(WCHAR));
  176.     if (lpwszCmdLine)
  177.     {
  178.         MultiByteToWideChar(CP_ACP, 0,
  179.                             lpszCmdLine, -1,
  180.                             lpwszCmdLine, iLen);
  181.         OpenScrap_RunDLL_Common( hwndStub,
  182.                                  hAppInstance,
  183.                                  lpwszCmdLine,
  184.                                  nCmdShow );
  185.         LocalFree(lpwszCmdLine);
  186.     }
  187. #else
  188.     OpenScrap_RunDLL_Common( hwndStub,
  189.                              hAppInstance,
  190.                              lpszCmdLine,
  191.                              nCmdShow );
  192. #endif
  193. }
  195. extern "C" void WINAPI
  196. OpenScrap_RunDLLW(HWND hwndStub, HINSTANCE hAppInstance, LPWSTR lpwszCmdLine, int nCmdShow)
  197. {
  198. #ifdef UNICODE
  199.     OpenScrap_RunDLL_Common( hwndStub,
  200.                              hAppInstance,
  201.                              lpwszCmdLine,
  202.                              nCmdShow );
  203. #else
  204.     UINT iLen = WideCharToMultiByte(CP_ACP, 0,
  205.                                     lpwszCmdLine, -1,
  206.                                     NULL, 0, NULL, NULL)+1;
  207.     LPSTR  lpszCmdLine;
  209.     lpszCmdLine = (LPSTR)LocalAlloc(LPTR,iLen);
  210.     if (lpszCmdLine)
  211.     {
  212.         WideCharToMultiByte(CP_ACP, 0,
  213.                             lpwszCmdLine, -1,
  214.                             lpszCmdLine, iLen,
  215.                             NULL, NULL);
  216.         OpenScrap_RunDLL_Common( hwndStub,
  217.                                  hAppInstance,
  218.                                  lpszCmdLine,
  219.                                  nCmdShow );
  220.         LocalFree(lpszCmdLine);
  221.     }
  222. #endif
  223. }
  224. #ifdef DEBUG
  225. //
  226. // Type checking
  227. //
  228. static RUNDLLPROCA lpfnRunDLLA=OpenScrap_RunDLL;
  229. static RUNDLLPROCW lpfnRunDLLW=OpenScrap_RunDLLW;
  230. #endif
  232. void DisplayError(HWND hwndOwner, HRESULT hres, UINT idsMsg, LPCTSTR pszFileName)
  233. {
  234.     TCHAR szErrMsg[MAX_PATH*2];
  235.     TCHAR szFancyErr[MAX_PATH*2];
  236.     HRSRC hrsrc;
  238.     if (HIWORD(hres))
  239.     {
  240.         BOOL fSuccess = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
  241.                   NULL,
  242.                   hres,
  243.                   0,
  244.                   szErrMsg,
  245.                   ARRAYSIZE(szErrMsg),
  246.                   (va_list *)&pszFileName);
  247.         if (!fSuccess) {
  248.             idsMsg++;   // map IDS_ERR_DOVERB to IDS_ERR_DOVERB_F
  249.         }
  250.     } else {
  251.         LoadString(g_hinst, LOWORD(hres), szErrMsg, ARRAYSIZE(szErrMsg));
  252.     }
  254.     szFancyErr[0] = TEXT('');
  255.     hrsrc = FindResource(g_hinst, MAKEINTRESOURCE(IDR_FANCYERR), RT_RCDATA);
  256.     if (hrsrc)
  257.     {
  258.         HGLOBAL hmem = LoadResource(g_hinst, hrsrc);
  259.         if (hmem)
  260.         {
  261.             HRESULT* phres = (HRESULT*)LockResource(hmem);
  262.             if (phres)
  263.             {
  264.                 UINT i;
  265.                 LPTSTR pszLoad = szFancyErr;
  266.                 int cchLeft = ARRAYSIZE(szFancyErr);
  267.                 for (i=0; phres[i] && cchLeft>0; i++) {
  268.                     if (phres[i] == hres)
  269.                     {
  270.                         int cchRead;
  271.                         cchRead = LoadString(g_hinst, IDS_FANCYERR+i, pszLoad, cchLeft);
  272.                         pszLoad += cchRead;
  273.                         cchLeft -= cchRead;
  274.                     }
  275.                 }
  277.                 //
  278.                 // If we have a fancy error message, hide ugly message
  279.                 // from FormatMessage.
  280.                 //
  281.                 if (szFancyErr[0]) {
  282.                     szErrMsg[0] = TEXT('');
  283.                 }
  284.             }
  285.         }
  286.     }
  288.     ShellMessageBox(g_hinst,
  289.                     hwndOwner,
  290.                     MAKEINTRESOURCE(idsMsg),
  291.                     MAKEINTRESOURCE(IDS_TITLE_ERR),
  292.                     MB_OK | MB_ICONWARNING | MB_SETFOREGROUND,
  293.                     pszFileName,
  294.                     szErrMsg,
  295.                     szFancyErr,
  296.                     hres);
  297. }
  300. void CShClientSite::CloseOleObject()
  301. {
  302.     if (_pole)
  303.         _pole->Close(OLECLOSE_NOSAVE);
  304. }
  306. void CShClientSite::ReleaseOleObject()
  307. {
  308.     UINT cRef;
  309.     if (_pole)
  310.     {
  311.         if (_dwConnection) {
  312.             _pole->Unadvise(_dwConnection);
  313.             _dwConnection = 0;
  314.         }
  315.         _pole->SetClientSite(NULL);
  316.         cRef = _pole->Release();
  317.         DebugMsg(DM_TRACE, TEXT("so - TR SCS::ReleaseOleObject IOleObj::Rel returned (%d)"), cRef);
  318.         _pole=NULL;
  319.     }
  321.     if (_ppstg)
  322.     {
  323.         cRef=_ppstg->Release();
  324.         _ppstg=NULL;
  325.         DebugMsg(DM_TRACE, TEXT("so TR - SCS::ReleaseOleObject IPSTG::Release returned (%x)"), cRef);
  326.     }
  327. }
  329. void CShClientSite::ReleaseStorage(void)
  330. {
  331.     UINT cRef;
  333.     if (_pstg)
  334.     {
  335.         cRef=_pstg->Release();
  336.         _pstg=NULL;
  337.         DebugMsg(DM_TRACE, TEXT("so TR - SCS::ReleaseStorage _pstg->Release returned (%x)"), cRef);
  338.     }
  340.     if (_pstgDoc)
  341.     {
  342.         cRef=_pstgDoc->Release();
  343.         _pstgDoc=NULL;
  344.         DebugMsg(DM_TRACE, TEXT("so TR - SCS::ReleaseStorage _pstgDoc->Release returned (%x)"), cRef);
  345.     }
  346. }
  348. void CShClientSite::MaySaveAs()
  349. {
  350.     DebugMsg(DM_TRACE, TEXT("so TR - SCS::MaySaveAs called (%d,%d)"), _fCloned, _fNeedToSave);
  351.     if (_fCloned)
  352.     {
  353.         TCHAR szTempFile[MAX_PATH];
  354. #ifdef UNICODE
  355.         lstrcpyn(szTempFile,_wszFileName,ARRAYSIZE(szTempFile));
  356. #else
  357.         WideCharToMultiByte(CP_ACP, 0, _wszFileName, -1, szTempFile, ARRAYSIZE(szTempFile), NULL, NULL);
  358. #endif
  360.         UINT id = IDNO;
  361.         if (_fNeedToSave)
  362.         {
  363.             id= ShellMessageBox(g_hinst,
  364.                         _hwndOwner,
  365.                         MAKEINTRESOURCE(IDS_WOULDYOUSAVEAS),
  366.                         MAKEINTRESOURCE(IDS_TITLE),
  367.                         MB_YESNO | MB_ICONQUESTION | MB_SETFOREGROUND,
  368.                         NULL);
  369.         }
  371.         DebugMsg(DM_TRACE, TEXT("so TR - SCS::MaySaveAs id==%d"), id);
  373.         if (id==IDYES)
  374.         {
  375.             TCHAR szDesktop[MAX_PATH];
  376.             SHGetSpecialFolderPath(NULL, szDesktop, CSIDL_DESKTOP, FALSE);
  378.             BOOL fContinue;
  379.             do
  380.             {
  381.                 fContinue = FALSE;
  383.                 TCHAR szFile[MAX_PATH];
  384.                 TCHAR szFilter[64];
  385.                 szFile[0] = TEXT('');
  386.                 LoadString(g_hinst, IDS_SCRAPFILTER, szFilter, ARRAYSIZE(szFilter));
  388.                 OPENFILENAME of = {
  389.                     SIZEOF(OPENFILENAME), // DWORD        lStructSize;
  390.                     _hwndOwner,               // HWND         hwndOwner;
  391.                     NULL,                     // HINSTANCE    hInstance;
  392.                     szFilter,         // LPCSTR       lpstrFilter;
  393.                     NULL,                     // LPSTR        lpstrCustomFilter;
  394.                     0,                // DWORD        nMaxCustFilter;
  395.                     1,                // DWORD        nFilterIndex;
  396.                     szFile,           // LPSTR        lpstrFile;
  397.                     ARRAYSIZE(szFile),    // DWORD        nMaxFile;
  398.                     NULL,                     // LPSTR        lpstrFileTitle;
  399.                     0,                // DWORD        nMaxFileTitle;
  400.                     szDesktop,        // LPCSTR       lpstrInitialDir;
  401.                     NULL,                     // LPCSTR       lpstrTitle;
  402.                     OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT
  403.                      | OFN_NOREADONLYRETURN | OFN_PATHMUSTEXIST,
  404.                                           // DWORD        Flags;
  405.                     0,                // WORD         nFileOffset;
  406.                     0,                // WORD         nFileExtension;
  407.                     TEXT("shs"),                      // LPCSTR       lpstrDefExt;
  408.                     NULL,                     // LPARAM       lCustData;
  409.                     NULL,                     // LPOFNHOOKPROC lpfnHook;
  410.                     NULL,                     // LPCSTR       lpTemplateName;
  411.                 };
  413.                 if (GetSaveFileName(&of))
  414.                 {
  415.                     DeleteFile(szFile);
  416.                     BOOL fRet = MoveFile(szTempFile, szFile);
  417.                     if (fRet)
  418.                     {
  419.                         // Indicated that the temp file is moved
  420.                         szTempFile[0] = TEXT('');
  421.                     }
  422.                     else
  423.                     {
  424.                         id = ShellMessageBox(g_hinst,
  425.                                 _hwndOwner,
  426.                                 MAKEINTRESOURCE(IDS_MOVEFAILED),
  427.                                 MAKEINTRESOURCE(IDS_TITLE),
  428.                                 MB_YESNO | MB_ICONWARNING | MB_SETFOREGROUND);
  429.                         if (id==IDYES)
  430.                         {
  431.                             fContinue = TRUE;
  432.                         }
  433.                     }
  434.                 }
  435.             } while (fContinue);
  436.         }
  438.         // If the temp file is not moved, delete it.
  439.         if (szTempFile[0])
  440.         {
  441.             DeleteFile(szTempFile);
  442.         }
  443.     }
  444. }
  446. void CShClientSite::Draw(HWND hwnd, HDC hdc)
  447. {
  448.     if (_ppstg)
  449.     {
  450.         HRESULT hres;
  451.         RECT rc;
  453.         GetClientRect(hwnd, &rc);
  455.         hres = OleDraw(_ppstg, DVASPECT_ICON, hdc, &rc);
  456.         DebugMsg(DM_TRACE, TEXT("so TR - SCS::Draw OleDraw(DVASPECT_ICON) returned %x"), hres);
  458.         if (FAILED(hres))
  459.         {
  460.             LPVIEWOBJECT2 pview;
  461.             hres = _ppstg->QueryInterface(IID_IViewObject2, (LPVOID*)&pview);
  462.             if (SUCCEEDED(hres))
  463.             {
  464.                 SIZE size;
  465.                 hres = pview->GetExtent(DVASPECT_CONTENT, (DWORD)-1,
  466.                                         (DVTARGETDEVICE*)NULL, &size);
  467.                 DebugMsg(DM_TRACE, TEXT("so TR - SCS::Draw IVO2::GetExtent returned %x"), hres);
  468.                 if (SUCCEEDED(hres))
  469.                 {
  470.                     int mmOld = SetMapMode(hdc, MM_HIMETRIC);
  471.                     LPtoDP(hdc, (LPPOINT)&size, 1);
  472.                     rc.right = size.cx;
  473.                     rc.bottom = -size.cy;
  474.                     SetMapMode(hdc, mmOld);
  475.                 }
  476.                 pview->Release();
  477.             }
  478.             hres = OleDraw(_ppstg, DVASPECT_CONTENT, hdc, &rc);
  479.             DebugMsg(DM_TRACE, TEXT("so TR - SCS::Draw OleDraw(DVASPECT_CONTENT,%d,%d) returned %x"),
  480.                         hres, rc.right, rc.bottom);
  481.         }
  483.         LPOLELINK plink;
  484.         if (SUCCEEDED(hres = _ppstg->QueryInterface(IID_IOleLink, (LPVOID *)&plink)))
  485.         {
  486.             LPOLESTR pwsz;
  487.             hres = plink->GetSourceDisplayName(&pwsz);
  488.             if (SUCCEEDED(hres))
  489.             {
  490. #ifdef UNICODE
  491.                 TextOut(hdc, 0, 0, pwsz, lstrlen(pwsz));
  492. #else
  493.                 TCHAR szDisplayName[256] = TEXT("##ERROR##");
  494.                 WideCharToMultiByte(CP_ACP, 0, pwsz, -1, szDisplayName, ARRAYSIZE(szDisplayName), NULL, NULL);
  495.                 TextOut(hdc, 0, 0, szDisplayName, lstrlen(szDisplayName));
  496. #endif
  497.                 CoTaskMemFree(pwsz);
  498.             }
  499.             else
  500.             {
  501.                 DebugMsg(DM_TRACE, TEXT("so TR SCS:Draw IMK:GetSDN failed %x"), hres);
  502.             }
  503.             plink->Release();
  504.         }
  505.         else
  506.         {
  507.             DebugMsg(DM_TRACE, TEXT("so TR SCS:Draw IPSTG:QI failed %x"), hres);
  508.         }
  509.     }
  510. }
  512. STDMETHODIMP CShClientSite::QueryInterface(REFIID riid,
  513.         void **ppvObject)
  514. {
  515.     HRESULT hres;
  516.     if (IsEqualGUID(riid, CLSID_CShClientSite)) {
  517.         _cRef++;
  518.         *ppvObject = this;
  519.         hres = NOERROR;
  520.     }
  521.     else if (IsEqualGUID(riid, IID_IOleClientSite) || IsEqualGUID(riid, IID_IUnknown)) {
  522.         _cRef++;
  523.         *ppvObject = (LPOLECLIENTSITE)this;
  524.         hres = NOERROR;
  525.     }
  526.     else if (IsEqualGUID(riid, IID_IAdviseSink) || IsEqualGUID(riid, IID_IAdviseSink2)) {
  527.         _cRef++;
  528.         *ppvObject = (LPADVISESINK2)this;
  529.         hres = NOERROR;
  530.     }
  531.     else
  532.     {
  533.         *ppvObject = NULL;
  534.         hres = ResultFromScode(E_NOINTERFACE);
  535.     }
  536.     return hres;
  537. }
  539. STDMETHODIMP_(ULONG) CShClientSite::AddRef(void)
  540. {
  541.     return ++_cRef;
  542. }
  544. STDMETHODIMP_(ULONG) CShClientSite::Release(void)
  545. {
  546.     if (--_cRef>0) {
  547.         return _cRef;
  548.     }
  550.     delete this;
  551.     return 0;
  552. }
  555. void Scrap_UpdateCachedData(LPSTORAGE pstgDoc, LPOLEOBJECT pole, LPPERSIST pps)
  556. {
  557.     extern void Scrap_CacheClipboardData(LPSTORAGE pstgDoc, LPDATAOBJECT pdtobj, LPPERSIST pps);
  558.     DebugMsg(DM_TRACE, TEXT("so TR - S_UCD called"));
  559.     if (pstgDoc && pole && pps)
  560.     {
  561.         IDataObject *pdtobj = NULL;
  562.         HRESULT hres = pole->QueryInterface(IID_IDataObject, (LPVOID*)&pdtobj);
  563.         if (SUCCEEDED(hres)) {
  564.             DebugMsg(DM_TRACE, TEXT("so TR - S_UCD QI succeeded"));
  565.             Scrap_CacheClipboardData(pstgDoc, pdtobj, pps);
  566.             pdtobj->Release();
  567.         }
  568.     }
  569. }
  571. STDMETHODIMP CShClientSite::SaveObject(void)
  572. {
  573.     DebugMsg(DM_TRACE, TEXT("sc TR - CSCS::SaveObject called"));
  574.     //
  575.     // NOTES: We need to update the cache here.
  576.     //  Doing so on ::OnSave does not work (async)
  577.     //  Doing so on ::OnClose is too late.
  578.     //
  579.     Scrap_UpdateCachedData(_pstgDoc, _pole, _ppstg);
  581.     HRESULT hres;
  582.     if (_pstg && _ppstg)
  583.     {
  584.         hres = OleSave(_ppstg, _pstg, TRUE);
  585.         if (SUCCEEDED(hres))
  586.         {
  587.             hres = _ppstg->SaveCompleted(NULL);
  588.         }
  589.     }
  590.     else
  591.     {
  592.         hres = ResultFromScode(E_FAIL);
  593.     }
  594.     return hres;
  595. }
  597. STDMETHODIMP CShClientSite::GetMoniker(DWORD dwAssign,
  598.     DWORD dwWhichMoniker,
  599.     IMoniker **ppmk)
  600. {
  601.     HRESULT hres;
  603.     *ppmk = NULL;
  605.     switch(dwWhichMoniker)
  606.     {
  607.     case OLEWHICHMK_CONTAINER:
  608.         hres = CreateFileMoniker(_wszFileName, ppmk);
  609.         break;
  611.     case OLEWHICHMK_OBJREL:
  612.         hres = CreateItemMoniker(L"\", L"Object", ppmk);
  613.         break;
  615.     case OLEWHICHMK_OBJFULL:
  616.         {
  617.             LPMONIKER pmkItem;
  618.             hres = CreateItemMoniker(L"\", L"Object", &pmkItem);
  619.             if (SUCCEEDED(hres))
  620.             {
  621.                 LPMONIKER pmkDoc;
  622.                 hres = CreateFileMoniker(_wszFileName, &pmkDoc);
  623.                 if (SUCCEEDED(hres))
  624.                 {
  625.                     hres = CreateGenericComposite(pmkDoc, pmkItem, ppmk);
  626.                     pmkDoc->Release();
  627.                 }
  628.                 pmkItem->Release();
  629.             }
  630.         }
  631.         break;
  633.     default:
  634.         hres = ResultFromScode(E_INVALIDARG);
  635.     }
  637.     return hres;
  638. }
  640. STDMETHODIMP CShClientSite::GetContainer(
  641.     IOleContainer **ppContainer)
  642. {
  643.     *ppContainer = NULL;
  644.     return ResultFromScode(E_NOINTERFACE);
  645. }
  647. STDMETHODIMP CShClientSite::ShowObject(void)
  648. {
  649.     return NOERROR;
  650. }
  652. STDMETHODIMP CShClientSite::OnShowWindow(BOOL fShow)
  653. {
  654.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnShowWindow called with %d"), fShow);
  655.     return NOERROR;
  656. }
  658. STDMETHODIMP CShClientSite::RequestNewObjectLayout(void)
  659. {
  660.     return ResultFromScode(E_NOTIMPL);
  661. }
  663. //
  664. // _cRef <- 2 because _hwndOwner has a reference count as well.
  665. //
  666. CShClientSite::CShClientSite(HWND hwndOwner, LPCTSTR pszCmdLine)
  667.                 : _cRef(2), _hwndOwner(hwndOwner),
  668.                   _pstgDoc(NULL), _pstg(NULL), _ppstg(NULL), _pole(NULL),
  669.                   _fDirty(FALSE), _fNeedToSave(FALSE),
  670.                   _fReadOnly(FALSE), _fCloned(FALSE), _fCloseImmediately(FALSE),
  671.                   _fQuit(FALSE)
  672. {
  673.     LPCTSTR pszFileName = ParseCmdLine(pszCmdLine);
  675. //
  676. // We'd better deal with quoted LFN name.
  677. //
  678. #ifdef NASHVILLE
  679.     //
  680.     // Strip out quotes if exists.
  681.     //
  682.     TCHAR szT[MAX_PATH];
  683.     if (*pszFileName==TEXT('"'))
  684.     {
  685.         lstrcpy(szT, pszFileName+1);
  686.         LPTSTR pszT = CharPrev(szT, szT+lstrlen(szT));
  687.         if (*pszT==TEXT('"')) {
  688.             *pszT=TEXT('');
  689.         }
  690.         pszFileName = szT;
  691.     }
  692. #endif // NASHVILLE
  694. #ifdef UNICODE
  695.     lstrcpyn(_wszFileName, pszFileName, ARRAYSIZE(_wszFileName));
  696. #else
  697.     MultiByteToWideChar(CP_ACP, 0, pszFileName, lstrlen(pszFileName)+1,
  698.                         _wszFileName, ARRAYSIZE(_wszFileName));
  699. #endif
  701.     Assert(_hwndOwner)
  702.     SetWindowLongPtr(_hwndOwner, GWLP_USERDATA, (LPARAM)this);
  703. }
  705. CShClientSite::~CShClientSite()
  706. {
  707.     ReleaseOleObject();
  708.     ReleaseStorage();
  709.     DebugMsg(DM_TRACE, TEXT("sc - CShClientSite is being deleted"));
  710. }
  712. LPCTSTR _SkipSpace(LPCTSTR psz)
  713. {
  714.     while(*psz==TEXT(' '))
  715.         psz++;
  716.     return psz;
  717. }
  719. LPCTSTR CShClientSite::ParseCmdLine(LPCTSTR pszCmdLine)
  720. {
  721.     for (LPCTSTR psz = _SkipSpace(pszCmdLine);
  722.          (*psz == TEXT('/') || *psz == TEXT('-')) && *++psz;
  723.          psz = _SkipSpace(psz))
  724.     {
  725.         switch(*psz++)
  726.         {
  727.         case TEXT('r'):
  728.         case TEXT('R'):
  729.             _fReadOnly = TRUE;
  730.             break;
  732.         case TEXT('x'):
  733.         case TEXT('X'):
  734.             _fCloseImmediately = TRUE;
  735.             break;
  736.         }
  737.     }
  739.     return psz;
  740. }
  742. void CShClientSite::GetFileName(LPTSTR szFile, UINT cchMax)
  743. {
  744. #ifdef UNICODE
  745.     lstrcpyn(szFile, _wszFileName, cchMax);
  746. #else
  747.     WideCharToMultiByte(CP_ACP, 0, _wszFileName, -1, szFile, cchMax, NULL, NULL);
  748. #endif
  749. }
  750. const WCHAR c_wszContents[] = WSTR_SCRAPITEM;
  752. //
  753. // Returns:
  754. //      S_OK, succeeded. Start the message loop.
  755. //      S_FALSE, succeeded. Release the object.
  756. //      Others, failed.
  757. //
  758. HRESULT CShClientSite::Load()
  759. {
  760.     HRESULT hres;
  761.     DWORD wStgm;
  763.     // Must be called only once.
  764.     if (_pstgDoc) {
  765.         return ResultFromScode(E_UNEXPECTED);
  766.     }
  768.     wStgm = _fReadOnly ?
  769.                 (STGM_READ | STGM_SHARE_DENY_WRITE) :
  770.                 (STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE);
  771.     hres = StgIsStorageFile(_wszFileName);
  772.     if (hres != S_OK)
  773.     {
  774.         if (hres==S_FALSE) {
  775.             hres = IDS_HRES_INVALID_SCRAPFILE;
  776.         }
  777.         return hres;
  778.     }
  780.     hres = StgOpenStorage(_wszFileName, NULL, wStgm, NULL, 0, &_pstgDoc);
  782. #ifndef CLONE_IT_IF_READONLY
  783.     //
  784.     //  If we are opening without read-only flag and StgOpenStorage failed
  785.     // with STG_E_ACCESSDENIED, retry it with read-only mode.
  786.     //
  787.     if ((hres==STG_E_ACCESSDENIED) && !_fReadOnly)
  788.     {
  789.         DebugMsg(DM_TRACE, TEXT("so TR - CSCS::DoVerb first StgOpenStorage failed, retrying it in read-only mode"));
  790.         _fReadOnly = TRUE;
  791.         wStgm = (STGM_READ | STGM_SHARE_DENY_WRITE);
  792.         hres = StgOpenStorage(_wszFileName, NULL, wStgm, NULL, 0, &_pstgDoc);
  793.     }
  794. #else // CLONE_IT_IF_READONLY
  795.     //
  796.     //  If we are opening without read-only flag and StgOpenStorage failed
  797.     // with STG_E_ACCESSDENIED, retry it with read-only mode.
  798.     //
  799.     if ((hres==STG_E_ACCESSDENIED) && !_fReadOnly)
  800.     {
  801.         LPSTORAGE pstgRead;
  802.         DebugMsg(DM_TRACE, TEXT("so TR - CSCS::DoVerb first StgOpenStorage failed, retrying it in read-only mode"));
  803.         hres = StgOpenStorage(_wszFileName, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &pstgRead);
  804.         if (SUCCEEDED(hres))
  805.         {
  806.             TCHAR szDesktop[MAX_PATH];
  807.             TCHAR szTempFile[MAX_PATH];
  808.             SHGetSpecialFolderPath(_hwndOwner, szDesktop, CSIDL_DESKTOP, FALSE);
  809.             GetTempFileName(szDesktop, TEXT("Sh"), 0, szTempFile);
  810. #ifdef UNICODE
  811.             lstrcpyn(_wszFileName,szTempFile,ARRAYSIZE(szTempFile));
  812. #else
  813.             MultiByteToWideChar(CP_ACP, 0, szTempFile, -1, _wszFileName, ARRAYSIZE(_wszFileName));
  814. #endif
  816.             hres = StgCreateDocfile(_wszFileName,
  817.                             STGM_DIRECT | STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
  818.                             0, &_pstgDoc);
  819.             if (SUCCEEDED(hres))
  820.             {
  821.                 hres = pstgRead->CopyTo(0, NULL, NULL, _pstgDoc);
  822.                 _pstgDoc->Release();
  823.                 _pstgDoc = NULL;
  825.                 if (SUCCEEDED(hres))
  826.                 {
  827.                     hres = StgOpenStorage(_wszFileName, NULL, wStgm, NULL, 0, &_pstgDoc);
  828.                     if (SUCCEEDED(hres))
  829.                     {
  830.                         _fCloned = TRUE;
  831.                     }
  832.                 }
  833.                 else
  834.                 {
  835.                     DeleteFile(szTempFile);
  836.                 }
  837.             }
  838.             pstgRead->Release();
  839.         }
  840.     }
  841. #endif // CLONE_IT_IF_READONLY
  843.     if (SUCCEEDED(hres))
  844.     {
  845.         if (_fReadOnly) {
  846.             wStgm = STGM_READ|STGM_SHARE_EXCLUSIVE;
  847.         }
  848.         hres = _pstgDoc->OpenStorage(c_wszContents, NULL, wStgm, NULL, 0, &_pstg);
  849.         if (SUCCEEDED(hres))
  850.         {
  851.             hres = OleLoad(_pstg, IID_IPersistStorage, this, (LPVOID *)&_ppstg);
  852.         }
  853.         else
  854.         {
  855.             DebugMsg(DM_TRACE, TEXT("so ER - CSCS::DoVerb _pstgDoc->OpenStorage failed %x"), hres);
  857.             //
  858.             // Notes: If we just return this hres as is, the user will see
  859.             //  "Can't open file, FOO.SHS", which is bogus. We need to
  860.             //  translate it into a much informative message.
  861.             //
  862.             hres = IDS_HRES_INVALID_SCRAPFILE;
  863.         }
  864.     }
  865.     else
  866.     {
  867.         DebugMsg(DM_TRACE, TEXT("so ER - CSCS::DoVerb StgOpenStg failed %x"), hres);
  868.     }
  870.     return hres;
  871. }
  875. HRESULT CShClientSite::DoVerb(LONG iVerb)
  876. {
  877.     HRESULT hres;
  878.     hres = _ppstg->QueryInterface(IID_IOleObject, (LPVOID *)&_pole);
  880.     if (SUCCEEDED(hres))
  881.     {
  882. hres = _pole->Advise(this, &_dwConnection);
  883. DebugMsg(DM_TRACE, TEXT("so TR - CSCS::DoVerb IOleObject::Advise returned %x"), hres);
  884. if (SUCCEEDED(hres))
  885. {
  886.     TCHAR szTitle[MAX_PATH];
  887.     WCHAR wszTitle[MAX_PATH];
  888.     LoadString(g_hinst, IDS_TITLE, szTitle, ARRAYSIZE(szTitle));
  889. #ifdef UNICODE
  890.     lstrcpyn(wszTitle,szTitle,ARRAYSIZE(wszTitle));
  891. #else
  892.     MultiByteToWideChar(CP_ACP, 0, szTitle, lstrlen(szTitle)+1,
  893.     wszTitle, ARRAYSIZE(wszTitle));
  894. #endif
  896.     GetFileName(szTitle, ARRAYSIZE(szTitle));
  897.     LPCWSTR pwszDisplayName = _wszFileName;
  898. #ifndef UNICODE
  899.     WCHAR wszDisplayName[MAX_PATH];
  900. #endif
  901.     SHFILEINFO info;
  902.     DWORD_PTR result = SHGetFileInfo(szTitle, 0,
  903. &info, SIZEOF(info), SHGFI_DISPLAYNAME);
  905.     if(result && *info.szDisplayName)
  906.     {
  907. #ifdef UNICODE
  908. pwszDisplayName = info.szDisplayName;
  909. #else
  910. MultiByteToWideChar(CP_ACP, 0,
  911. info.szDisplayName, -1,
  912. wszDisplayName, ARRAYSIZE(wszDisplayName));
  913. pwszDisplayName = wszDisplayName;
  914. #endif
  915.     }
  917.     _pole->SetHostNames(wszTitle, pwszDisplayName);
  919.     //
  920.     // OLEBUG? Unless _hwndOwner has the input focus, 16-bit
  921.     //  server won't get the input focus.
  922.     //
  923.     SetFocus(_hwndOwner);
  925.     hres = _pole->DoVerb(iVerb, NULL, this, 0, _hwndOwner, NULL);
  926.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::DoVerb IOleObject::DoVerb returned %x"), hres);
  927.     if (SUCCEEDED(hres) && _fCloseImmediately) {
  928. hres = S_FALSE;
  929.     }
  930. }
  931.     }
  932.     else
  933.     {
  934. DebugMsg(DM_TRACE, TEXT("so ER - CSCS::DoVerb IPSTG::QI failed %x"), hres);
  935.     }
  936.     return hres;
  937. }
  939. STDMETHODIMP_(void) CShClientSite::OnDataChange(FORMATETC *pFormatetc, STGMEDIUM *pStgmed)
  940. {
  941.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnDataChange called"));
  942.     _fDirty = TRUE;
  943. }
  945. STDMETHODIMP_(void) CShClientSite::OnViewChange(DWORD dwAspect, LONG lindex)
  946. {
  947.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnViewChange called"));
  948.     _fDirty = TRUE;
  949. }
  951. STDMETHODIMP_(void) CShClientSite::OnRename(IMoniker *pmk)
  952. {
  953.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnRename called"));
  954.     _fDirty = TRUE;
  955. }
  957. STDMETHODIMP_(void) CShClientSite::OnSave(void)
  958. {
  959.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnSave called"));
  960.     _fNeedToSave = TRUE;
  961. }
  963. STDMETHODIMP_(void) CShClientSite::OnClose(void)
  964. {
  965.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnClose called"));
  966.     if (_fNeedToSave /* && _fDirty */)
  967.     {
  968.         HRESULT hres;
  969.         hres=OleSave(_ppstg, _pstg, TRUE);      // fSameStorage=TRUE
  970.         DebugMsg(DM_TRACE, TEXT("so TR - CSCS:OnClose OleSave returned (%x)"), hres);
  971.         hres=_ppstg->HandsOffStorage();
  972.         DebugMsg(DM_TRACE, TEXT("so TR - CSCS:OnClose IPS:HandsOffStorage returned (%x)"), hres);
  973.         if (SUCCEEDED(hres))
  974.         {
  975.             hres = _pstg->Commit(STGC_OVERWRITE);
  976.             DebugMsg(DM_TRACE, TEXT("so TR - CSCS:OnClose _psg->Commit returned (%x)"), hres);
  977.             hres = _pstgDoc->Commit(STGC_OVERWRITE);
  978.             DebugMsg(DM_TRACE, TEXT("so TR - CSCS:OnClose _psgDoc->Commit returned (%x)"), hres);
  979.         }
  980.     }
  982.     //
  983.     // WARNING:
  984.     //
  985.     //  OLE1 server pukes if we release object here. However, we need to
  986.     // call IOleObject::UnAdvice and IOleObject::SetClientSite(NULL) here
  987.     // to avoid memory leak (RPC keeps 3 reference counts to IOleClientSite
  988.     // if we delay it as well).
  989.     //
  990.     // ReleaseOleObject();
  991.     //
  992.     if (_dwConnection) {
  993.         _pole->Unadvise(_dwConnection);
  994.         _dwConnection = 0;
  995.     }
  996.     _pole->SetClientSite(NULL);
  998.     PostMessage(_hwndOwner, WM_USER, 0, 0);
  999. }
  1001. STDMETHODIMP_(void) CShClientSite::OnLinkSrcChange
  1002. (
  1003.     IMoniker *pmk
  1004. )
  1005. {
  1006.     DebugMsg(DM_TRACE, TEXT("so TR - CSCS::OnLinkSrcChange called"));
  1007.     _fDirty = TRUE;
  1008. }
  1010. LRESULT CALLBACK ShWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1011. {
  1012.     PAINTSTRUCT ps;
  1013.     HDC hdc;
  1014.     LPSHCLIENTSITE pscs = (LPSHCLIENTSITE)GetWindowLongPtr(hwnd, GWLP_USERDATA);
  1016.     switch(uMsg)
  1017.     {
  1018.     case WM_PAINT:
  1019.         hdc = BeginPaint(hwnd, &ps);
  1020.         if (pscs && IsWindowVisible(hwnd))
  1021.         {
  1022.             pscs->Draw(hwnd, hdc);
  1023.         }
  1024.         EndPaint(hwnd, &ps);
  1025.         break;
  1027.     case WM_CLOSE:
  1028.         if (pscs)
  1029.         {
  1030.             pscs->CloseOleObject();
  1031.             DestroyWindow(hwnd);
  1032.         }
  1033.         break;
  1035.     case WM_USER:
  1036.         if (pscs)
  1037.         {
  1038.             pscs->ReleaseOleObject();
  1039.             PostMessage(hwnd, WM_CLOSE, 0, 0);
  1040.         }
  1041.         break;
  1043.     case WM_DESTROY:
  1044.         DebugMsg(DM_WARNING, TEXT("so WA - ShWndProc processing WM_DESTROY"));
  1045.         if (pscs)
  1046.         {
  1047.             pscs->Quit();
  1048.             pscs->Release();
  1049.             SetWindowLongPtr(hwnd, GWLP_USERDATA, 0);
  1050.         }
  1051.         else
  1052.         {
  1053.             DebugMsg(DM_WARNING, TEXT("so WA - ShWndProc pscs==NULL on WM_DESTROY"));
  1054.         }
  1056. #if 0
  1057.         //
  1058.         // Process all the pending messages, before we post WM_QUIT message.
  1059.         //
  1060.         MSG msg;
  1061.         while (PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
  1062.         {
  1063.             TranslateMessage(&msg);
  1064.             DispatchMessage(&msg);
  1065.         }
  1066. #endif
  1068.         break;
  1070.     default:
  1071.         return DefWindowProc(hwnd, uMsg, wParam, lParam);
  1072.     }
  1073.     return 0;
  1074. }
  1076. //===========================================================================
  1077. // Global functions
  1078. //===========================================================================
  1080. void CShClientSite_RegisterClass()
  1081. {
  1082.     WNDCLASS wc;
  1084.     // wc.cbSize     = SIZEOF(WNDCLASSEX);
  1085.     wc.style         = CS_DBLCLKS|CS_VREDRAW|CS_HREDRAW ;
  1086.     wc.lpfnWndProc   = ShWndProc ;
  1087.     wc.cbClsExtra    = 0;
  1088.     wc.cbWndExtra    = SIZEOF(LPSHCLIENTSITE) + SIZEOF(LPVOID);
  1089.     wc.hInstance     = g_hinst ;
  1090.     wc.hIcon         = NULL ;
  1091.     wc.hCursor       = LoadCursor(NULL, IDC_ARROW) ;
  1092.     wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH) ;
  1093.     wc.lpszMenuName  = NULL ;
  1094.     wc.lpszClassName = c_szAppName ;
  1095.     // wc.hIconSm    = NULL;
  1097.     RegisterClass(&wc);
  1098. }
  1100. IOleClientSite* CShClientSite_Create(HWND hwndOwner, LPCTSTR pszFileName)
  1101. {
  1102.     DebugMsg(DM_TRACE, TEXT("sc TR:CShClientSite_Create called with %s"), pszFileName);
  1103.     CShClientSite* that = new CShClientSite(hwndOwner, pszFileName);
  1104.     HRESULT hres = that->Load();
  1105.     DebugMsg(DM_TRACE, TEXT("sc TRACE: CShClientSite::Load returned %x"), hres);
  1106.     return that;
  1107. }
  1109. void CShClientSite_Release(IOleClientSite* pcli)
  1110. {
  1111.     CShClientSite* pscs;
  1112.     if (SUCCEEDED(pcli->QueryInterface(CLSID_CShClientSite, (void**)&pscs)))
  1113.     {
  1114. pscs->ReleaseOleObject();
  1115. pscs->ReleaseStorage();
  1116. pscs->MaySaveAs();
  1117. pscs->Release();
  1118.     }
  1119.     UINT cRef = pcli->Release();
  1120.     Assert(cRef==0);
  1121. }