home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / src / oledlgs3.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-16  |  10.9 KB  |  431 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_OLE2_SEG
  14. #pragma code_seg(AFX_OLE2_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. #define new DEBUG_NEW
  23.  
  24. UINT CALLBACK
  25. AfxOleHookProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
  26.  
  27. ////////////////////////////////////////////////////////////////////////////
  28. // EditProperties dialog wrapper
  29.  
  30. COlePropertiesDialog::COlePropertiesDialog(
  31.     COleClientItem* pItem, UINT nScaleMin, UINT nScaleMax, CWnd* pParentWnd)
  32.     : COleDialog(pParentWnd), m_xLinkInfo(NULL)
  33. {
  34.     ASSERT_VALID(pItem);
  35.  
  36.     memset(&m_op, 0, sizeof(m_op)); // initialize structure to 0/NULL
  37.  
  38.     // fill in common part
  39.     m_op.cbStruct = sizeof(m_op);
  40.     m_op.dwFlags = 0;
  41.     if (AfxHelpEnabled())
  42.         m_op.dwFlags |= OPF_SHOWHELP;
  43.     m_nIDHelp = AFX_IDD_OBJECTPROPERTIES;
  44.  
  45.     // specific to this dialog
  46.     memset(&m_gp, 0, sizeof(m_gp));
  47.     m_gp.cbStruct = sizeof(m_gp);
  48.     m_gp.lpfnHook = AfxOleHookProc;
  49.     m_gp.dwFlags = 0;
  50.  
  51.     memset(&m_vp, 0, sizeof(m_vp));
  52.     m_vp.cbStruct = sizeof(m_vp);
  53.     m_vp.lpfnHook = AfxOleHookProc;
  54.     m_vp.dwFlags = 0;
  55.     m_vp.nScaleMin = nScaleMin;
  56.     m_vp.nScaleMax = nScaleMax;
  57.  
  58.     memset(&m_lp, 0, sizeof(m_lp));
  59.     m_lp.cbStruct = sizeof(m_lp);
  60.     m_lp.lpfnHook = AfxOleHookProc;
  61.     m_lp.dwFlags = 0;
  62.  
  63.     m_op.lpObjInfo = &m_xOleUIObjInfo;
  64.     m_op.lpLinkInfo = &m_xLinkInfo;
  65.     m_op.dwLink = (DWORD)pItem;
  66.     m_op.dwObject = (DWORD)pItem;
  67.     m_op.lpGP = &m_gp; m_op.lpVP = &m_vp;
  68.     if (pItem->GetType() == OT_LINK)
  69.     {
  70.         m_op.dwFlags |= OPF_OBJECTISLINK;
  71.         m_op.lpLP = &m_lp;
  72.     }
  73.     memset(&m_psh, 0, sizeof(m_psh));
  74.     m_psh.dwSize = sizeof(PROPSHEETHEADER);
  75.     m_op.lpPS = &m_psh;
  76. }
  77.  
  78. int COlePropertiesDialog::DoModal()
  79. {
  80.     ASSERT_VALID(this);
  81.     ASSERT(m_gp.lpfnHook != NULL);  // can still be a user hook
  82.     ASSERT(m_vp.lpfnHook != NULL);  // can still be a user hook
  83.     ASSERT(m_lp.lpfnHook != NULL);  // can still be a user hook
  84.  
  85.     // disable scale if OnApplyScale not implemented
  86.     if (!OnApplyScale(NULL, -1, FALSE))
  87.         m_op.lpVP->dwFlags |= VPF_DISABLESCALE;
  88.  
  89.     // invoke the dialog
  90.     m_op.lpPS->hwndParent = PreModal();
  91.     int iResult = MapResult(::OleUIObjectProperties(&m_op));
  92.     PostModal();
  93.     return iResult;
  94. }
  95.  
  96. BOOL COlePropertiesDialog::OnInitDialog()
  97. {
  98.     BOOL bResult = COleDialog::OnInitDialog();
  99.  
  100.     // automatic centering doesn't work for this dialog
  101.     if (!(GetStyle() & WS_CHILD))
  102.         CenterWindow();
  103.  
  104.     return bResult;
  105. }
  106.  
  107. STDMETHODIMP_(ULONG) COlePropertiesDialog::XOleUIObjInfo::AddRef()
  108. {
  109.     return 0;
  110. }
  111.  
  112. STDMETHODIMP_(ULONG) COlePropertiesDialog::XOleUIObjInfo::Release()
  113. {
  114.     return 0;
  115. }
  116.  
  117. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::QueryInterface(
  118.     REFIID, LPVOID*)
  119. {
  120.     return E_NOTIMPL;
  121. }
  122.  
  123. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::GetObjectInfo(
  124.     DWORD dwObject, DWORD* lpdwObjSize, LPTSTR* lplpszLabel,
  125.     LPTSTR* lplpszType, LPTSTR* lplpszShortType, LPTSTR* lplpszLocation)
  126. {
  127.     COleClientItem* pItem = (COleClientItem*)dwObject;
  128.     ASSERT_VALID(pItem);
  129.     BOOL bIsLink = (pItem->GetType() == OT_LINK);
  130.  
  131.     if (lpdwObjSize != NULL)
  132.     {
  133.         ASSERT(pItem->m_lpStorage != NULL);
  134.  
  135.         // try ILockBytes first, then IStorage
  136.         STATSTG statStg;
  137.         if ((pItem->m_lpLockBytes == NULL ||
  138.             pItem->m_lpLockBytes->Stat(&statStg, STATFLAG_NONAME) != S_OK) &&
  139.             pItem->m_lpStorage->Stat(&statStg, STATFLAG_NONAME) != S_OK)
  140.         {
  141.             *lpdwObjSize = 0xFFFFFFFF;
  142.         }
  143.         else
  144.         {
  145.             ASSERT(statStg.pwcsName == NULL);
  146.             if (statStg.cbSize.HighPart > 0)
  147.                 *lpdwObjSize = 0xFFFFFFFE;
  148.             else if (statStg.cbSize.LowPart == 0)
  149.                 *lpdwObjSize = 0xFFFFFFFF;
  150.             else
  151.                 *lpdwObjSize = statStg.cbSize.LowPart;
  152.         }
  153.     }
  154.  
  155.     if (lplpszLabel != NULL)
  156.     {
  157.         TCHAR szFormatLink[128];
  158.         AfxLoadString(AFX_IDS_PASTELINKEDTYPE, szFormatLink, _countof(szFormatLink));
  159.         TCHAR szFormatObj[] = _T("%s");
  160.         LPTSTR lpszFormat = bIsLink ? szFormatLink : szFormatObj;
  161.         CString strType;
  162.         pItem->GetUserType(USERCLASSTYPE_FULL, strType);
  163.         CString strResult;
  164.         strResult.Format(lpszFormat, (LPCTSTR)strType);
  165.         *lplpszLabel = AfxAllocTaskString(strResult);
  166.     }
  167.  
  168.     if (lplpszType != NULL)
  169.     {
  170.         LPOLESTR lpOleStr;
  171.         pItem->m_lpObject->GetUserType(USERCLASSTYPE_FULL, &lpOleStr);
  172.         *lplpszType = TASKSTRINGOLE2T(lpOleStr);
  173.     }
  174.  
  175.     if (lplpszShortType != NULL)
  176.     {
  177.         LPOLESTR lpOleStr;
  178.         pItem->m_lpObject->GetUserType(USERCLASSTYPE_SHORT, &lpOleStr);
  179.         *lplpszShortType = TASKSTRINGOLE2T(lpOleStr);
  180.     }
  181.  
  182.     if (lplpszLocation != NULL)
  183.     {
  184.         if (bIsLink)
  185.         {
  186.             LPOLELINK lpOleLink = NULL;
  187.             pItem->m_lpObject->QueryInterface(IID_IOleLink, (LPVOID*)&lpOleLink);
  188.             ASSERT(lpOleLink != NULL);
  189.             LPOLESTR lpOleStr;
  190.             lpOleLink->GetSourceDisplayName(&lpOleStr);
  191.             *lplpszLocation = TASKSTRINGOLE2T(lpOleStr);
  192.             lpOleLink->Release();
  193.         }
  194.         else
  195.         {
  196.             CDocument* pDoc = (CDocument*)pItem->GetDocument();
  197.             CString strLocation = pDoc->GetPathName();
  198.             if (strLocation.IsEmpty())
  199.                 strLocation = pDoc->GetTitle();
  200.             *lplpszLocation = AfxAllocTaskString(strLocation);
  201.         }
  202.     }
  203.  
  204.     return S_OK;
  205. }
  206.  
  207. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::GetConvertInfo(
  208.     DWORD dwObject, CLSID* lpClassID, WORD* lpwFormat,
  209.     CLSID*, LPCLSID*, UINT*)
  210. {
  211.     COleClientItem* pItem = (COleClientItem*)dwObject;
  212.     ASSERT_VALID(pItem);
  213.  
  214.     if (lpClassID != NULL)
  215.     {
  216.         if (pItem->GetType() == OT_LINK ||
  217.             S_OK != ReadClassStg(pItem->m_lpStorage, lpClassID))
  218.         {
  219.             pItem->GetClassID(lpClassID);
  220.         }
  221.     }
  222.     if (lpwFormat != NULL)
  223.     {
  224.         *lpwFormat = 0;
  225.         CLIPFORMAT cf;
  226.         if (ReadFmtUserTypeStg(pItem->m_lpStorage, &cf, NULL) == S_OK)
  227.             *lpwFormat = (WORD)cf;
  228.     }
  229.  
  230.     // Note: leave rest at default
  231.  
  232.     return S_OK;
  233. }
  234.  
  235. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::ConvertObject(
  236.     DWORD dwObject, REFCLSID clsidNew)
  237. {
  238.     COleClientItem* pItem = (COleClientItem*)dwObject;
  239.     ASSERT_VALID(pItem);
  240.  
  241.     if (!pItem->ConvertTo(clsidNew))
  242.     {
  243.         AfxMessageBox(AFX_IDP_FAILED_TO_CONVERT,
  244.             MB_OK | MB_ICONEXCLAMATION);
  245.         return E_FAIL;
  246.     }
  247.     return S_OK;
  248. }
  249.  
  250. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::GetViewInfo(
  251.     DWORD dwObject, HGLOBAL* phMetaPict, DWORD* pdvAspect, int* pnCurrentScale)
  252. {
  253.     COleClientItem* pItem = (COleClientItem*)dwObject;
  254.     ASSERT_VALID(pItem);
  255.  
  256.     if (phMetaPict != NULL)
  257.         *phMetaPict = pItem->GetIconicMetafile();
  258.  
  259.     if (pdvAspect != NULL)
  260.         *pdvAspect = pItem->GetDrawAspect();
  261.  
  262.     if (pnCurrentScale != NULL)
  263.         *pnCurrentScale = 100;  // 100% (arbitrary for now)
  264.  
  265.     return S_OK;
  266. }
  267.  
  268. STDMETHODIMP COlePropertiesDialog::XOleUIObjInfo::SetViewInfo(
  269.     DWORD dwObject, HGLOBAL hMetaPict, DWORD dvAspect,
  270.     int nCurrentScale, BOOL bRelativeToOrig)
  271. {
  272.     METHOD_PROLOGUE_EX_(COlePropertiesDialog, OleUIObjInfo)
  273.     COleClientItem* pItem = (COleClientItem*)dwObject;
  274.     ASSERT_VALID(pItem);
  275.  
  276.     // handle aspect changes
  277.     if (dvAspect != -1)
  278.     {
  279.         pItem->OnChange(OLE_CHANGED_ASPECT, dvAspect);
  280.         pItem->SetDrawAspect((DVASPECT)dvAspect);
  281.  
  282.         // force scale to 100% when changing aspects
  283.         if (dvAspect == DVASPECT_ICON)
  284.         {
  285.             nCurrentScale = 100;
  286.             bRelativeToOrig = TRUE;
  287.         }
  288.         else if (nCurrentScale == -1)
  289.         {
  290.             nCurrentScale = 100;
  291.             bRelativeToOrig = FALSE;
  292.         }
  293.     }
  294.  
  295.     // handle icon representation changes
  296.     if (hMetaPict != NULL)
  297.     {
  298.         pItem->SetIconicMetafile(hMetaPict);
  299.         if (pItem->GetDrawAspect() == DVASPECT_ICON)
  300.             pItem->OnChange(OLE_CHANGED, (DWORD)DVASPECT_ICON);
  301.     }
  302.  
  303.     // handle scale changes
  304.     if (nCurrentScale != -1)
  305.     {
  306.         pThis->OnApplyScale(pItem, nCurrentScale, bRelativeToOrig);
  307.     }
  308.  
  309.     return S_OK;
  310. }
  311.  
  312. BOOL COlePropertiesDialog::OnApplyScale(COleClientItem*, int, BOOL)
  313. {
  314.     // Note: no default implementation. Must override or scaling
  315.     //  controls will be disabled during the DoModal call.
  316.  
  317.     return FALSE;
  318. }
  319.  
  320. /////////////////////////////////////////////////////////////////////////////
  321. // COlePropertiesDialog diagnostics
  322.  
  323. #ifdef _DEBUG
  324.  
  325. void COlePropertiesDialog::Dump(CDumpContext& dc) const
  326. {
  327.     COleDialog::Dump(dc);
  328. }
  329.  
  330. void COlePropertiesDialog::AssertValid() const
  331. {
  332.     COleDialog::AssertValid();
  333.     ASSERT(m_op.cbStruct == sizeof(m_op));
  334.     ASSERT(m_gp.cbStruct == sizeof(m_gp));
  335.     ASSERT(m_vp.cbStruct == sizeof(m_vp));
  336.     ASSERT(m_lp.cbStruct == sizeof(m_lp));
  337. }
  338.  
  339. #endif
  340.  
  341. ////////////////////////////////////////////////////////////////////////////
  342. // ChangeSource dialog wrapper
  343.  
  344. COleChangeSourceDialog::COleChangeSourceDialog(COleClientItem* pItem,
  345.     CWnd* pParentWnd) : COleDialog(pParentWnd), m_xLinkInfo(NULL)
  346. {
  347.     ASSERT_VALID(pItem);
  348.  
  349.     memset(&m_cs, 0, sizeof(m_cs)); // initialize structure to 0/NULL
  350.  
  351.     // fill in common part
  352.     m_cs.cbStruct = sizeof(m_cs);
  353.     m_cs.dwFlags = 0;
  354.     if (AfxHelpEnabled())
  355.         m_cs.dwFlags |= CSF_SHOWHELP;
  356.     m_cs.lpfnHook = AfxOleHookProc;
  357.     m_nIDHelp = AFX_IDD_CHANGESOURCE;
  358.  
  359.     // specific to this dialog
  360.     m_cs.lpOleUILinkContainer = &m_xLinkInfo;
  361.     m_cs.dwLink = (DWORD)pItem;
  362. }
  363.  
  364. int COleChangeSourceDialog::DoModal()
  365. {
  366.     ASSERT_VALID(this);
  367.     ASSERT(m_cs.lpfnHook != NULL);  // can still be a user hook
  368.  
  369.     m_cs.hWndOwner = PreModal();
  370.     int iResult = MapResult(::OleUIChangeSource(&m_cs));
  371.     PostModal();
  372.     return iResult;
  373. }
  374.  
  375. void COleChangeSourceDialog::PreInitDialog()
  376. {
  377.     // automatic centering doesn't work for this dialog
  378.     if (!(GetStyle() & WS_CHILD))
  379.         CenterWindow();
  380. }
  381.  
  382. COleChangeSourceDialog::~COleChangeSourceDialog()
  383. {
  384.     CoTaskMemFree(m_cs.lpszTo);
  385.     CoTaskMemFree(m_cs.lpszFrom);
  386.     CoTaskMemFree(m_cs.lpszDisplayName);
  387. }
  388.  
  389. /////////////////////////////////////////////////////////////////////////////
  390. // COleChangeSourceDialog diagnostics
  391.  
  392. #ifdef _DEBUG
  393.  
  394. void COleChangeSourceDialog::Dump(CDumpContext& dc) const
  395. {
  396.     COleDialog::Dump(dc);
  397.  
  398.     dc << "m_cs.cbStruct = " << m_cs.cbStruct;
  399.     dc << "\nm_cs.dwFlags = " << (LPVOID)m_cs.dwFlags;
  400.     dc << "\nm_cs.hWndOwner = " << (UINT)m_cs.hWndOwner;
  401.     dc << "\nm_cs.lpszCaption = " << m_cs.lpszCaption;
  402.     dc << "\nm_cs.lCustData = " << (LPVOID)m_cs.lCustData;
  403.     dc << "\nm_cs.hInstance = " << (UINT)m_cs.hInstance;
  404.     dc << "\nm_cs.lpszTemplate = " << (LPVOID)m_cs.lpszTemplate;
  405.     dc << "\nm_cs.hResource = " << (UINT)m_cs.hResource;
  406.     if (m_cs.lpfnHook == AfxOleHookProc)
  407.         dc << "\nhook function set to standard MFC hook function";
  408.     else
  409.         dc << "\nhook function set to non-standard hook function";
  410.  
  411.     dc << "\n";
  412. }
  413.  
  414. void COleChangeSourceDialog::AssertValid() const
  415. {
  416.     COleDialog::AssertValid();
  417.     ASSERT(m_cs.cbStruct == sizeof(m_cs));
  418.     ASSERT(m_cs.lpfnHook != NULL);
  419. }
  420.  
  421. #endif
  422.  
  423. #ifdef AFX_INIT_SEG
  424. #pragma code_seg(AFX_INIT_SEG)
  425. #endif
  426.  
  427. IMPLEMENT_DYNAMIC(COlePropertiesDialog, COleDialog)
  428. IMPLEMENT_DYNAMIC(COleChangeSourceDialog, COleDialog)
  429.  
  430. /////////////////////////////////////////////////////////////////////////////
  431.