home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / inole2 / chap24 / patron / iipsite.cpp < prev    next >
C/C++ Source or Header  |  1995-05-03  |  13KB  |  516 lines
  1. /*
  2.  * IIPSITE.CPP
  3.  * Patron Chapter 24
  4.  *
  5.  * IOleInPlaceSite interface implementation for Patron
  6.  *
  7.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  8.  *
  9.  * Kraig Brockschmidt, Microsoft
  10.  * Internet  :  kraigb@microsoft.com
  11.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  12.  */
  13.  
  14.  
  15. #include "patron.h"
  16.  
  17.  
  18. BOOL        g_fSwitchingActive=FALSE;
  19.  
  20. /*
  21.  * CImpIOleInPlaceSite::CImpIOleInPlaceSite
  22.  * CImpIOleInPlaceSite::~CImpIOleInPlaceSite
  23.  *
  24.  * Parameters (Constructor):
  25.  *  pTen            PCTenant of the tenant we're in.
  26.  *  pUnkOuter       LPUNKNOWN to which we delegate.
  27.  */
  28.  
  29. CImpIOleInPlaceSite::CImpIOleInPlaceSite(PCTenant pTen
  30.     , LPUNKNOWN pUnkOuter)
  31.     {
  32.     m_cRef=0;
  33.     m_pTen=pTen;
  34.     m_pUnkOuter=pUnkOuter;
  35.     return;
  36.     }
  37.  
  38. CImpIOleInPlaceSite::~CImpIOleInPlaceSite(void)
  39.     {
  40.     return;
  41.     }
  42.  
  43.  
  44.  
  45. /*
  46.  * CImpIOleInPlaceSite::QueryInterface
  47.  * CImpIOleInPlaceSite::AddRef
  48.  * CImpIOleInPlaceSite::Release
  49.  *
  50.  * Purpose:
  51.  *  IUnknown members for CImpIOleInPlaceSite object.
  52.  */
  53.  
  54. STDMETHODIMP CImpIOleInPlaceSite::QueryInterface(REFIID riid
  55.     , PPVOID ppv)
  56.     {
  57.     return m_pUnkOuter->QueryInterface(riid, ppv);
  58.     }
  59.  
  60.  
  61. STDMETHODIMP_(ULONG) CImpIOleInPlaceSite::AddRef(void)
  62.     {
  63.     ++m_cRef;
  64.     return m_pUnkOuter->AddRef();
  65.     }
  66.  
  67. STDMETHODIMP_(ULONG) CImpIOleInPlaceSite::Release(void)
  68.     {
  69.     --m_cRef;
  70.     return m_pUnkOuter->Release();
  71.     }
  72.  
  73.  
  74.  
  75.  
  76. /*
  77.  * CImpIOleInPlaceActiveObject::GetWindow
  78.  *
  79.  * Purpose:
  80.  *  Retrieves the handle of the window associated with the object
  81.  *  on which this interface is implemented.
  82.  *
  83.  * Parameters:
  84.  *  phWnd           HWND * in which to store the window handle.
  85.  *
  86.  * Return Value:
  87.  *  HRESULT         NOERROR if successful, E_FAIL if there is no
  88.  *                  window.
  89.  */
  90.  
  91. STDMETHODIMP CImpIOleInPlaceSite::GetWindow(HWND *phWnd)
  92.     {
  93.     *phWnd=m_pTen->m_hWnd;
  94.     return NOERROR;
  95.     }
  96.  
  97.  
  98.  
  99.  
  100. /*
  101.  * CImpIOleInPlaceActiveObject::ContextSensitiveHelp
  102.  *
  103.  * Purpose:
  104.  *  Instructs the object on which this interface is implemented to
  105.  *  enter or leave a context-sensitive help mode.
  106.  *
  107.  * Parameters:
  108.  *  fEnterMode      BOOL TRUE to enter the mode, FALSE otherwise.
  109.  *
  110.  * Return Value:
  111.  *  HRESULT         NOERROR
  112.  */
  113.  
  114. STDMETHODIMP CImpIOleInPlaceSite::ContextSensitiveHelp
  115.     (BOOL fEnterMode)
  116.     {
  117.     return NOERROR;
  118.     }
  119.  
  120.  
  121.  
  122.  
  123. /*
  124.  * CImpIOleInPlaceSite::CanInPlaceActivate
  125.  *
  126.  * Purpose:
  127.  *  Answers the server whether or not we can currently in-place
  128.  *  activate its object.  By implementing this interface we say
  129.  *  that we support in-place activation, but through this function
  130.  *  we indicate whether the object can currently be activated
  131.  *  in-place.  Iconic aspects, for example, cannot, meaning we
  132.  *  return S_FALSE.
  133.  *
  134.  * Parameters:
  135.  *  None
  136.  *
  137.  * Return Value:
  138.  *  HRESULT         NOERROR if we can in-place activate the object
  139.  *                  in this site, S_FALSE if not.
  140.  */
  141.  
  142. STDMETHODIMP CImpIOleInPlaceSite::CanInPlaceActivate(void)
  143.     {
  144.     if (DVASPECT_CONTENT!=m_pTen->m_fe.dwAspect)
  145.         return ResultFromScode(S_FALSE);
  146.  
  147.     if (TENANTTYPE_EMBEDDEDOBJECT!=m_pTen->m_tType)
  148.         return ResultFromScode(S_FALSE);
  149.  
  150.     //CHAPTER24MOD
  151.     if (m_pTen->m_pPG->m_fDesignMode)
  152.         return ResultFromScode(S_FALSE);
  153.     //End CHAPTER24MOD
  154.  
  155.     return NOERROR;
  156.     }
  157.  
  158.  
  159.  
  160.  
  161. /*
  162.  * CImpIOleInPlaceSite::OnInPlaceActivate
  163.  *
  164.  * Purpose:
  165.  *  Informs the container that an object is being activated in-place
  166.  *  such that the container can prepare appropriately.  The
  167.  *  container does not, however, make any user interface changes at
  168.  *  this point.  See OnUIActivate.
  169.  *
  170.  * Parameters:
  171.  *  None
  172.  *
  173.  * Return Value:
  174.  *  HRESULT         NOERROR or an appropriate error code.
  175.  */
  176.  
  177. STDMETHODIMP CImpIOleInPlaceSite::OnInPlaceActivate(void)
  178.     {
  179.     //CHAPTER24MOD
  180.     m_pTen->m_fPendingDeactivate=FALSE;
  181.     //End CHAPTER24MOD
  182.  
  183.     //m_pIOleIPObject is our in-place flag.
  184.     m_pTen->m_pObj->QueryInterface(IID_IOleInPlaceObject
  185.         , (PPVOID)&m_pTen->m_pIOleIPObject);
  186.  
  187.     return NOERROR;
  188.     }
  189.  
  190.  
  191.  
  192.  
  193. /*
  194.  * CImpIOleInPlaceSite::OnInPlaceDeactivate
  195.  *
  196.  * Purpose:
  197.  *  Notifies the container that the object has deactivated itself
  198.  *  from an in-place state.  Opposite of OnInPlaceActivate.  The
  199.  *  container does not change any UI at this point.
  200.  *
  201.  * Parameters:
  202.  *  None
  203.  *
  204.  * Return Value:
  205.  *  HRESULT         NOERROR or an appropriate error code.
  206.  */
  207.  
  208. STDMETHODIMP CImpIOleInPlaceSite::OnInPlaceDeactivate(void)
  209.     {
  210.     /*
  211.      * Since we don't have an Undo command, we can tell the object
  212.      * right away to discard its Undo state.
  213.      */
  214.     m_pTen->Activate(OLEIVERB_DISCARDUNDOSTATE, NULL);
  215.     ReleaseInterface(m_pTen->m_pIOleIPObject);
  216.     return NOERROR;
  217.     }
  218.  
  219.  
  220.  
  221.  
  222. /*
  223.  * CImpIOleInPlaceSite::OnUIActivate
  224.  *
  225.  * Purpose:
  226.  *  Informs the container that the object is going to start munging
  227.  *  around with user interface, like replacing the menu.  The
  228.  *  container should remove any relevant UI in preparation.
  229.  *
  230.  * Parameters:
  231.  *  None
  232.  *
  233.  * Return Value:
  234.  *  HRESULT         NOERROR or an appropriate error code.
  235.  */
  236.  
  237. STDMETHODIMP CImpIOleInPlaceSite::OnUIActivate(void)
  238.     {
  239.     PCPatronDoc     pDoc;
  240.  
  241.     m_pTen->m_pPG->m_fAddUI=FALSE;
  242.  
  243.     //CHAPTER24MOD
  244.     m_pTen->m_fPendingDeactivate=FALSE;
  245.     //End CHAPTER24MOD
  246.  
  247.     pDoc=(PCPatronDoc)SendMessage(GetParent(m_pTen->m_hWnd)
  248.         , DOCM_PDOCUMENT, 0, 0L);
  249.  
  250.     /*
  251.      * Change the currently selected tenant in the page.  This
  252.      * will UIDeactivate the currently UI Active tenant.
  253.      */
  254.     g_fSwitchingActive=TRUE;
  255.     m_pTen->m_pPG->m_pPageCur->SwitchActiveTenant(m_pTen);
  256.     g_fSwitchingActive=FALSE;
  257.  
  258.     //Hide the frame tools if necessary.
  259.     g_pFR->ShowUIAndTools(pDoc->NoObjectFrameTools(0, FALSE), FALSE);
  260.     return NOERROR;
  261.     }
  262.  
  263.  
  264.  
  265.  
  266. /*
  267.  * CImpIOleInPlaceSite::OnUIDeactivate
  268.  *
  269.  * Purpose:
  270.  *  Informs the container that the object is deactivating its
  271.  *  in-place user interface at which time the container may
  272.  *  reinstate its own.  Opposite of OnUIActivate.
  273.  *
  274.  * Parameters:
  275.  *  fUndoable       BOOL indicating if the object will actually
  276.  *                  perform an Undo if the container calls
  277.  *                  ReactivateAndUndo.
  278.  *
  279.  * Return Value:
  280.  *  HRESULT         NOERROR or an appropriate error code.
  281.  */
  282.  
  283. STDMETHODIMP CImpIOleInPlaceSite::OnUIDeactivate(BOOL fUndoable)
  284.     {
  285.     PCDocument  pDoc;
  286.     MSG         msg;
  287.  
  288.     /*
  289.      * Ignore this notification if we're switching between
  290.      * multiple active objects.
  291.      */
  292.     if (g_fSwitchingActive)
  293.         return NOERROR;
  294.  
  295.     //If in shutdown (NULL storage), don't check messages.
  296.     if (NULL==m_pTen->m_pIStorage)
  297.         {
  298.         g_pFR->ReinstateUI();
  299.         return NOERROR;
  300.         }
  301.  
  302.     pDoc=(PCDocument)SendMessage(GetParent(m_pTen->m_hWnd)
  303.         , DOCM_PDOCUMENT, 0, 0L);
  304.  
  305.     //If there's a pending double-click, delay showing our UI
  306.     if (!PeekMessage(&msg, pDoc->Window(), WM_LBUTTONDBLCLK
  307.         , WM_LBUTTONDBLCLK, PM_NOREMOVE | PM_NOYIELD))
  308.         {
  309.         //Turn everything back on.
  310.         g_pFR->ReinstateUI();
  311.         }
  312.     else
  313.         m_pTen->m_pPG->m_fAddUI=TRUE;
  314.  
  315.     SetFocus(pDoc->Window());
  316.     return NOERROR;
  317.     }
  318.  
  319.  
  320.  
  321.  
  322. /*
  323.  * CImpIOleInPlaceSite::DeactivateAndUndo
  324.  *
  325.  * Purpose:
  326.  *  If immediately after activation the object does an Undo, the
  327.  *  action being undone is the activation itself, and this call
  328.  *  informs the container that this is, in fact, what happened.
  329.  *  The container should call IOleInPlaceObject::UIDeactivate.
  330.  *
  331.  * Parameters:
  332.  *  None
  333.  *
  334.  * Return Value:
  335.  *  HRESULT         NOERROR or an appropriate error code.
  336.  */
  337.  
  338. STDMETHODIMP CImpIOleInPlaceSite::DeactivateAndUndo(void)
  339.     {
  340.     //CHAPTER24MOD
  341.     /*
  342.      * Note that we don't pay attention to the locking
  343.      * from IOleControlSite::LockInPlaceActive since only
  344.      * the object calls this function and should know
  345.      * that it's going to be deactivated.
  346.      */
  347.     //End CHAPTER24MOD
  348.  
  349.     m_pTen->m_pIOleIPObject->InPlaceDeactivate();
  350.     return NOERROR;
  351.     }
  352.  
  353.  
  354.  
  355.  
  356. /*
  357.  * CImpIOleInPlaceSite::DiscardUndoState
  358.  *
  359.  * Purpose:
  360.  *  Informs the container that something happened in the object
  361.  *  that means the container should discard any undo information
  362.  *  it currently maintains for the object.
  363.  *
  364.  * Parameters:
  365.  *  None
  366.  *
  367.  * Return Value:
  368.  *  HRESULT         NOERROR or an appropriate error code.
  369.  */
  370.  
  371. STDMETHODIMP CImpIOleInPlaceSite::DiscardUndoState(void)
  372.     {
  373.     return ResultFromScode(E_NOTIMPL);
  374.     }
  375.  
  376.  
  377.  
  378.  
  379. /*
  380.  * CImpIOleInPlaceSite::GetWindowContext
  381.  *
  382.  * Purpose:
  383.  *  Provides an in-place object with pointers to the frame and
  384.  *  document level in-place interfaces (IOleInPlaceFrame and
  385.  *  IOleInPlaceUIWindow) such that the object can do border
  386.  *  negotiation and so forth.  Also requests the position and
  387.  *  clipping rectangles of the object in the container and a
  388.  *  pointer to an OLEINPLACEFRAME info structure which contains
  389.  *  accelerator information.
  390.  *
  391.  *  Note that the two interfaces this call returns are not
  392.  *  available through QueryInterface on IOleInPlaceSite since they
  393.  *  live with the frame and document, but not the site.
  394.  *
  395.  * Parameters:
  396.  *  ppIIPFrame      LPOLEINPLACEFRAME * in which to return the
  397.  *                  AddRef'd pointer to the container's
  398.  *                  IOleInPlaceFrame.
  399.  *  ppIIPUIWindow   LPOLEINPLACEUIWINDOW * in which to return
  400.  *                  the AddRef'd pointer to the container document's
  401.  *                  IOleInPlaceUIWindow.
  402.  *  prcPos          LPRECT in which to store the object's position.
  403.  *  prcClip         LPRECT in which to store the object's visible
  404.  *                  region.
  405.  *  pFI             LPOLEINPLACEFRAMEINFO to fill with accelerator
  406.  *                  stuff.
  407.  *
  408.  * Return Value:
  409.  *  HRESULT         NOERROR
  410.  */
  411.  
  412. STDMETHODIMP CImpIOleInPlaceSite::GetWindowContext
  413.     (LPOLEINPLACEFRAME *ppIIPFrame, LPOLEINPLACEUIWINDOW
  414.     *ppIIPUIWindow, LPRECT prcPos, LPRECT prcClip
  415.     , LPOLEINPLACEFRAMEINFO pFI)
  416.     {
  417.     PCPatronDoc     pDoc;
  418.     RECTL           rcl;
  419.  
  420.     *ppIIPUIWindow=NULL;
  421.  
  422.     *ppIIPFrame=(LPOLEINPLACEFRAME)g_pFR;
  423.     g_pFR->AddRef();
  424.  
  425.     pDoc=(PCPatronDoc)SendMessage(GetParent(m_pTen->m_hWnd)
  426.         , DOCM_PDOCUMENT, 0, 0L);
  427.  
  428.     if (NULL!=pDoc)
  429.         {
  430.         pDoc->QueryInterface(IID_IOleInPlaceUIWindow
  431.             , (PPVOID)ppIIPUIWindow);
  432.         }
  433.  
  434.     //Now get the rectangles and frame information.
  435.     m_pTen->RectGet(&rcl, TRUE);
  436.     RECTFROMRECTL(*prcPos, rcl);
  437.  
  438.     //Include scroll position here.
  439.     OffsetRect(prcPos, -(int)m_pTen->m_pPG->m_xPos
  440.         , -(int)m_pTen->m_pPG->m_yPos);
  441.  
  442.     SetRect(prcClip, 0, 0, 32767, 32767);
  443.  
  444.     pFI->cb=sizeof(OLEINPLACEFRAMEINFO);
  445.    #ifdef MDI
  446.     pFI->fMDIApp=TRUE;
  447.    #else
  448.     pFI->fMDIApp=FALSE;
  449.    #endif
  450.  
  451.     pFI->hwndFrame=g_pFR->Window();
  452.  
  453.     pFI->haccel=g_pFR->m_hAccelIP;
  454.     pFI->cAccelEntries=CINPLACEACCELERATORS;
  455.  
  456.     return NOERROR;
  457.     }
  458.  
  459.  
  460.  
  461.  
  462. /*
  463.  * CImpIOleInPlaceSite::Scroll
  464.  *
  465.  * Purpose:
  466.  *  Asks the container to scroll the document, and thus the object,
  467.  *  by the given amounts in the sz parameter.
  468.  *
  469.  * Parameters:
  470.  *  sz              SIZE containing signed horizontal and vertical
  471.  *                  extents by which the container should scroll.
  472.  *                  These are in device units.
  473.  *
  474.  * Return Value:
  475.  *  HRESULT         NOERROR
  476.  */
  477.  
  478. STDMETHODIMP CImpIOleInPlaceSite::Scroll(SIZE sz)
  479.     {
  480.     int         x, y;
  481.  
  482.     x=m_pTen->m_pPG->m_xPos+sz.cx;
  483.     y=m_pTen->m_pPG->m_yPos+sz.cy;
  484.  
  485.     SendScrollPosition(m_pTen->m_hWnd, WM_HSCROLL, x);
  486.     SendScrollPosition(m_pTen->m_hWnd, WM_VSCROLL, y);
  487.     return NOERROR;
  488.     }
  489.  
  490.  
  491.  
  492.  
  493. /*
  494.  * CImpIOleInPlaceSite::OnPosRectChange
  495.  *
  496.  * Purpose:
  497.  *  Informs the container that the in-place object was resized.
  498.  *  The container must call IOleInPlaceObject::SetObjectRects.
  499.  *  This does not change the site's rectangle in any case.
  500.  *
  501.  * Parameters:
  502.  *  prcPos          LPCRECT containing the new size of the object.
  503.  *
  504.  * Return Value:
  505.  *  HRESULT         NOERROR
  506.  */
  507.  
  508. STDMETHODIMP CImpIOleInPlaceSite::OnPosRectChange(LPCRECT prcPos)
  509.     {
  510.     if (NULL!=prcPos)
  511.         m_pTen->m_rcPos=*prcPos;
  512.  
  513.     m_pTen->UpdateInPlaceObjectRects(prcPos, FALSE);
  514.     return NOERROR;
  515.     }
  516.