开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
OBJ.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：31k
源码类别：

Windows编程

开发平台：

Visual C++

OBJ.CPP：源码内容
  1. //**********************************************************************
  2. // File name: obj.cpp
  3. //
  4. //    Implementation file for the CSimpSvrApp Class
  5. //
  6. // Functions:
  7. //
  8. //    See obj.h for a list of member functions.
  9. //
  10. // Copyright (c) 1993-1997 Microsoft Corporation. All rights reserved.
  11. //**********************************************************************
  13. #include "pre.h"
  14. #include "obj.h"
  15. #include "ioo.h"
  16. #include "ido.h"
  17. #include "ips.h"
  18. #include "icf.h"
  19. #include "ioipao.h"
  20. #include "ioipo.h"
  21. #include "app.h"
  22. #include "doc.h"
  24. //**********************************************************************
  25. //
  26. // CSimpSvrObj::QueryInterface
  27. //
  28. // Purpose:
  29. //
  30. //      Used for interface negotiation at the "Object" level.
  31. //
  32. // Parameters:
  33. //
  34. //      REFIID riid         -   A reference to the interface that is
  35. //                              being queried.
  36. //
  37. //      LPVOID FAR* ppvObj  -   An out parameter to return a pointer to
  38. //                              the interface.
  39. //
  40. // Return Value:
  41. //
  42. //      S_OK          -   The interface is supported.
  43. //      E_NOINTERFACE -   The interface is not supported
  44. //
  45. // Function Calls:
  46. //      Function                    Location
  47. //
  48. //      OutputDebugString           Windows API
  49. //                   OLE API
  50. //      IUnknown::AddRef            OBJ.CPP, IOO.CPP, IDO.CPP, IPS.CPP
  51. //                                  IOIPO.CPP, IOIPAO.CPP
  52. //
  53. // Comments:
  54. //
  55. //
  56. //********************************************************************
  58. STDMETHODIMP CSimpSvrObj::QueryInterface ( REFIID riid, LPVOID FAR* ppvObj)
  59. {
  60.         OutputDebugString("In CSimpSvrObj::QueryInterfacern");
  62.         SCODE sc = S_OK;
  64.         if (riid == IID_IUnknown)
  65.                 *ppvObj = this;
  66.         else if (riid == IID_IOleObject)
  67.                 *ppvObj = &m_OleObject;
  68.         else if (riid == IID_IDataObject)
  69.                 *ppvObj = &m_DataObject;
  70.         else if ( (riid == IID_IPersistStorage) || (riid == IID_IPersist) )
  71.                 *ppvObj = &m_PersistStorage;
  72.         else if (riid == IID_IOleInPlaceObject)
  73.                 *ppvObj = &m_OleInPlaceObject;
  74.         else if (riid == IID_IOleInPlaceActiveObject)
  75.                 *ppvObj = &m_OleInPlaceActiveObject;
  76.         else if (riid == IID_IExternalConnection)
  77.                  *ppvObj = &m_ExternalConnection;
  78.         else
  79.                 {
  80.                 *ppvObj = NULL;
  81.                 sc = E_NOINTERFACE;
  82.                 }
  84.         if (*ppvObj)
  85.                 ((LPUNKNOWN)*ppvObj)->AddRef();
  87.         return  sc ;
  88. };
  90. //**********************************************************************
  91. //
  92. // CSimpSvrObj::AddRef
  93. //
  94. // Purpose:
  95. //
  96. //      Adds to the reference count at the Object level.
  97. //
  98. // Parameters:
  99. //
  100. //      None
  101. //
  102. // Return Value:
  103. //
  104. //      ULONG   -   The new reference count of the Object.
  105. //
  106. // Function Calls:
  107. //      Function                    Location
  108. //
  109. //      OutputDebugString           Windows API
  110. //
  111. // Comments:
  112. //
  113. //      Due to the reference counting model that is used in this
  114. //      implementation, this reference count is the sum of the
  115. //      reference counts on all interfaces
  116. //
  117. //********************************************************************
  119. STDMETHODIMP_(ULONG) CSimpSvrObj::AddRef ()
  120. {
  121.         OutputDebugString("In CSimpSvrObj::AddRefrn");
  123.         m_lpDoc->AddRef();
  125.         return ++m_nCount;
  126. };
  128. //**********************************************************************
  129. //
  130. // CSimpSvrObj::Release
  131. //
  132. // Purpose:
  133. //
  134. //      Decrements the reference count at this level
  135. //
  136. // Parameters:
  137. //
  138. //      None
  139. //
  140. // Return Value:
  141. //
  142. //      ULONG   -   The new reference count of the object.
  143. //
  144. // Function Calls:
  145. //      Function                    Location
  146. //
  147. //      OutputDebugString           Windows API
  148. //
  149. // Comments:
  150. //
  151. //      Due to the reference counting model that is used in this
  152. //      implementation, this reference count is the sum of the
  153. //      reference counts on all interfaces
  154. //
  155. //********************************************************************
  157. STDMETHODIMP_(ULONG) CSimpSvrObj::Release ()
  158. {
  159.         OutputDebugString("In CSimpSvrObj::Releasern");
  161.         m_lpDoc->Release();
  163.         if (--m_nCount == 0) {
  164.                 delete this;
  165.         return 0;
  166.     }
  168.         return m_nCount;
  169. };
  171. //**********************************************************************
  172. //
  173. // CSimpSvrObj::CSimpSvrObj
  174. //
  175. // Purpose:
  176. //
  177. //      Constructor for CSimpSvrObj
  178. //
  179. // Parameters:
  180. //
  181. //      CSimpSvrDoc FAR * lpSimpSvrDoc - ptr to the doc object
  182. //
  183. // Return Value:
  184. //
  185. //      None
  186. //
  187. // Function Calls:
  188. //      Function                    Location
  189. //
  190. //
  191. // Comments:
  192. //
  193. //
  194. //********************************************************************
  195. #pragma warning (disable : 4355) // "this" used in base initializer list warning.  This
  196.                                                                  // can be disabled because we are not using "this" in
  197.                                                                  // the constructor for these objects, rather we are
  198.                                                                  // just storing it for future use...
  199. CSimpSvrObj::CSimpSvrObj(CSimpSvrDoc FAR * lpSimpSvrDoc) : m_OleObject(this),
  200.                                                                                                                    m_DataObject(this),
  201.                                                                                                                    m_PersistStorage(this),
  202.                                                                                                                    m_OleInPlaceActiveObject(this),
  203.                                                                                                                    m_OleInPlaceObject(this),
  204.                                                                                                                    m_ExternalConnection(this)
  205. #pragma warning (default : 4355) // Turn the warning back on
  207. {
  208.         m_lpDoc = lpSimpSvrDoc;
  209.         m_nCount = 0;
  210.         m_fInPlaceActive = FALSE;
  211.         m_fInPlaceVisible = FALSE;
  212.         m_fUIActive = FALSE;
  213.         m_hmenuShared = NULL;
  214.         m_hOleMenu = NULL;
  216.         m_dwRegister = 0;
  218.         m_lpFrame = NULL;
  219.         m_lpCntrDoc = NULL;
  221.         m_lpStorage = NULL;
  222.         m_lpColorStm = NULL;
  223.         m_lpSizeStm = NULL;
  224.         m_lpOleClientSite = NULL;
  225.         m_lpOleAdviseHolder = NULL;
  226.         m_lpDataAdviseHolder = NULL;
  227.         m_lpIPSite = NULL;
  229.         m_red = 128;
  230.         m_green = 0;
  231.         m_blue = 0;
  233.         m_size.x = 100;
  234.         m_size.y = 100;
  236.         m_xOffset = 0;
  237.         m_yOffset = 0;
  239.         m_scale = (float) 1.0;
  241.         m_fSaveWithSameAsLoad = FALSE;
  242.         m_fNoScribbleMode = FALSE;
  244. }
  246. //**********************************************************************
  247. //
  248. // CSimpSvrObj::~CSimpSvrObj
  249. //
  250. // Purpose:
  251. //
  252. //      Destructor for CSimpSvrObj
  253. //
  254. // Parameters:
  255. //
  256. //      None
  257. //
  258. // Return Value:
  259. //
  260. //
  261. //
  262. // Function Calls:
  263. //      Function                    Location
  264. //
  265. //      OutputDebugString           Windows API
  266. //      PostMessage                 Windows API
  267. //      CSimpSvrDoc::GetApp         DOC.H
  268. //      CSimpSvrDoc::GethAppWnd     DOC.H
  269. //      CSimpSvrDoc::ClearObj       DOC.H
  270. //      CSimpSvrApp::IsStartedByOle APP.CPP
  271. //
  272. // Comments:
  273. //
  274. //
  275. //********************************************************************
  277. CSimpSvrObj::~CSimpSvrObj()
  278. {
  279.         OutputDebugString("In CSimpSvrObj's Destructor rn");
  281.         // if we were started by ole, post ourselves a close message
  282.         if (m_lpDoc->GetApp()->IsStartedByOle())
  283.                 PostMessage(m_lpDoc->GethAppWnd(), WM_SYSCOMMAND, SC_CLOSE, 0L);
  285.         // clear the OBJ ptr in the doc class
  286.         m_lpDoc->ClearObj();
  288. }
  290. //**********************************************************************
  291. //
  292. // CSimpSvrObj::Draw
  293. //
  294. // Purpose:
  295. //
  296. //      Draws the object into an arbitrary DC
  297. //
  298. // Parameters:
  299. //
  300. //      HDC hDC - DC to draw into
  301. //
  302. // Return Value:
  303. //
  304. //      NONE
  305. //
  306. // Function Calls:
  307. //      Function                    Location
  308. //
  309. //      OutputDebugString           Windows API
  310. //      CreateBrushIndirect         Windows API
  311. //      SelectObject                Windows API
  312. //      Rectangle                   Windows API
  313. //      DeleteObject                Windows API
  314. //
  315. // Comments:
  316. //
  317. //
  318. //********************************************************************
  320. void CSimpSvrObj::Draw (HDC hDC, BOOL m_fMeta)
  321. {
  322.         LOGBRUSH lb;
  324.         OutputDebugString("In CSimpSvrObj::Drawrn");
  326.         char szBuffer[255];
  327.         wsprintf(szBuffer,"Drawing Scale %3drn",m_scale);
  328.         OutputDebugString(szBuffer);
  330.         if (!m_fMeta)
  331.                 {
  332.                 SetMapMode(hDC, MM_ANISOTROPIC);
  333.                 //@@WTK WIN32, UNICODE
  334.                 //SetWindowOrg(hDC, (int)(m_xOffset/m_scale), (int)(m_yOffset/m_scale));
  335.                 SetWindowOrgEx(hDC, (int)(m_xOffset/m_scale),
  336.                         (int)(m_yOffset/m_scale), NULL);
  337.                 //@@WTK WIN32, UNICODE
  338.                 //SetWindowExt(hDC, m_size.x, m_size.y);
  339.                 SetWindowExtEx(hDC, m_size.x, m_size.y, NULL);
  340.                 //@@WTK WIN32, UNICODE
  341.                 //SetViewportExt(hDC, (int)(m_size.x*m_scale), (int)(m_size.y*m_scale));
  342.                 SetViewportExtEx(hDC, (int)(m_size.x*m_scale),
  343.                         (int)(m_size.y*m_scale), NULL);
  344.                 }
  346.         // fill out a LOGBRUSH
  347.         lb.lbStyle = BS_SOLID;
  348.         lb.lbColor = RGB(m_red, m_green, m_blue);
  349.         lb.lbHatch = 0;
  351.         // create the brush
  352.         HBRUSH hBrush = CreateBrushIndirect(&lb);
  354.         // select the brush
  355.         HBRUSH hOldBrush = (HBRUSH) SelectObject(hDC, hBrush);
  356.         HPEN hPen = CreatePen(PS_INSIDEFRAME, 6, RGB(0, 0, 0));
  358.         HPEN hOldPen = (HPEN) SelectObject(hDC, hPen);
  360.         // draw the rectangle
  361.         Rectangle (hDC, 0, 0, m_size.x, m_size.y);
  363.         // restore the pen
  364.         hPen = (HPEN) SelectObject(hDC, hOldPen);
  366.         // free the pen
  367.         DeleteObject(hPen);
  369.         // restore the old brush
  370.         hBrush = (HBRUSH) SelectObject(hDC, hOldBrush);
  372.         // free the brush
  373.         DeleteObject(hBrush);
  374. }
  376. //**********************************************************************
  377. //
  378. // CSimpSvrObj::GetMetaFilePict
  379. //
  380. // Purpose:
  381. //
  382. //      Returns a handle to a metafile representation of the object.
  383. //
  384. // Parameters:
  385. //
  386. //      None
  387. //
  388. // Return Value:
  389. //
  390. //      Handle to the metafile.
  391. //
  392. // Function Calls:
  393. //      Function                        Location
  394. //
  395. //      OutputDebugString               Windows API
  396. //      GlobalAlloc                     Windows API
  397. //      GlobalLock                      Windows API
  398. //      SetWindowOrg                    Windows API
  399. //      SetWindowExt                    Windows API
  400. //      CreateMetaFile                  Windows API
  401. //      CloseMetaFile                   Windows API
  402. //      GlobalUnlock                    Windows API
  403. //      XformWidthInPixelsToHimetric    OLESTD
  404. //      XformHeightInPixelsToHimetric   OLESTD
  405. //      CSimpSvrObj::Draw               OBJ.CPP
  406. //
  407. // Comments:
  408. //
  409. //
  410. //********************************************************************
  412. HANDLE CSimpSvrObj::GetMetaFilePict()
  413. {
  414.         HANDLE hMFP;
  415.         METAFILEPICT FAR * lpMFP;
  416.         POINT pt;
  418.         OutputDebugString("In CSimpSvrObj::GetMetaFilePictrn");
  420.         // allocate the memory for the METAFILEPICT structure
  421.         hMFP = GlobalAlloc (GMEM_SHARE | GHND, sizeof (METAFILEPICT) );
  422.         lpMFP = (METAFILEPICT FAR*) GlobalLock(hMFP);
  424.         // get the size of the object in HIMETRIC
  425.         pt.x = XformWidthInPixelsToHimetric(NULL, m_size.x);
  426.         pt.y = XformHeightInPixelsToHimetric(NULL, m_size.y);
  428.         // fill out the METAFILEPICT structure
  429.         lpMFP->mm = MM_ANISOTROPIC;
  430.         lpMFP->xExt = pt.x;
  431.         lpMFP->yExt = pt.y;
  433.         // Create the metafile
  434.         HDC hDC = CreateMetaFile(NULL);
  436.         //@@WTK WIN32, UNICODE
  437.         //SetWindowOrg (hDC, 0, 0);
  438.         SetWindowOrgEx (hDC, 0, 0, NULL);
  439.         //@@WTK WIN32, UNICODE
  440.         //SetWindowExt (hDC, m_size.x,
  441.         SetWindowExtEx (hDC, m_size.x,
  442.                                            m_size.y, NULL);
  444.         Draw(hDC);
  446.         lpMFP->hMF = CloseMetaFile(hDC);
  448.         // unlock the metafilepict
  449.         GlobalUnlock(hMFP);
  451.         return hMFP;
  452. }
  455. //**********************************************************************
  456. //
  457. // CSimpSvrObj::SaveToStorage
  458. //
  459. // Purpose:
  460. //
  461. //      Saves the object to the passed storage
  462. //
  463. // Parameters:
  464. //
  465. //      LPSTORAGE lpStg - Storage in which to save the object
  466. //
  467. // Return Value:
  468. //
  469. //      None
  470. //
  471. // Function Calls:
  472. //      Function                    Location
  473. //
  474. //      OutputDebugString           Windows API
  475. //      IStorage::CreateStream      OLE
  476. //      IStream::Write              OLE
  477. //      IStream::Release            OLE
  478. //
  479. // Comments:
  480. //
  481. //      A real app will want to do better error checking / returning
  482. //
  483. //********************************************************************
  485. void CSimpSvrObj::SaveToStorage (LPSTORAGE lpStg, BOOL fSameAsLoad)
  486. {
  487.         OutputDebugString("In CSimpSvrObj::SaveToStoragern");
  489.         LPSTREAM lpTempColor, lpTempSize;
  491.         if (!fSameAsLoad)
  492.                 m_PersistStorage.CreateStreams( lpStg, &lpTempColor, &lpTempSize);
  493.         else
  494.                 {
  495.                 lpTempColor = m_lpColorStm;
  496.                 lpTempColor->AddRef();
  497.                 lpTempSize = m_lpSizeStm;
  498.                 lpTempSize->AddRef();
  499.                 }
  501.         ULARGE_INTEGER uli;
  503.         uli.LowPart = 0;
  504.         uli.HighPart = 0;
  506.         lpTempColor->SetSize(uli);
  507.         lpTempSize->SetSize(uli);
  509.         LARGE_INTEGER li;
  511.         li.LowPart = 0;
  512.         li.HighPart = 0;
  514.         lpTempColor->Seek(li, STREAM_SEEK_SET, NULL);
  515.         lpTempSize->Seek(li, STREAM_SEEK_SET, NULL);
  517.         // write the colors to the stream
  518.         lpTempColor->Write(&m_red, sizeof(m_red), NULL);
  519.         lpTempColor->Write(&m_green, sizeof(m_green), NULL);
  520.         lpTempColor->Write(&m_blue, sizeof(m_blue), NULL);
  522.         // write the size to the stream
  523.         lpTempSize->Write(&m_size, sizeof(m_size), NULL);
  525.         lpTempColor->Release();
  526.         lpTempSize->Release();
  527. }
  529. //**********************************************************************
  530. //
  531. // CSimpSvrObj::LoadFromStorage
  532. //
  533. // Purpose:
  534. //
  535. //      Loads the object from the passed storage
  536. //
  537. // Parameters:
  538. //
  539. //      LPSTORAGE lpStg     - Storage in which to load the object from
  540. //
  541. // Return Value:
  542. //
  543. //      None.
  544. //
  545. // Function Calls:
  546. //      Function                    Location
  547. //
  548. //      OutputDebugString           Windows API
  549. //      IStorage::OpenStream        OLE
  550. //      IStream::Read               OLE
  551. //      IStream::Release            OLE
  552. //
  553. // Comments:
  554. //
  555. //
  556. //********************************************************************
  558. void CSimpSvrObj::LoadFromStorage ()
  559. {
  560.         OutputDebugString("In CSimpSvrObj::LoadFromStoragern");
  562.         // Read the colors
  563.         m_lpColorStm->Read(&m_red, sizeof(m_red), NULL);
  564.         m_lpColorStm->Read(&m_green, sizeof(m_green), NULL);
  565.         m_lpColorStm->Read(&m_blue, sizeof(m_blue), NULL);
  567.         // read the size
  568.         m_lpSizeStm->Read(&m_size, sizeof(m_size), NULL);
  570. }
  572. //**********************************************************************
  573. //
  574. // CSimpSvrObj::DoInPlaceActivate
  575. //
  576. // Purpose:
  577. //
  578. //      Does the inplace activation for the object
  579. //
  580. // Parameters:
  581. //
  582. //      LONG lVerb  - Verb that caused this function to be called
  583. //
  584. // Return Value:
  585. //
  586. //      TRUE/FALSE depending on success or failure.
  587. //
  588. // Function Calls:
  589. //      Function                                Location
  590. //
  591. //      IOleClientSite::QueryInterface          Container
  592. //      IOleClientSite::ShowObject              Container
  593. //      IOleInPlaceSite::CanInPlaceActivate     Container
  594. //      IOleInPlaceSite::Release                Container
  595. //      IOleInPlaceSite::OnInPlaceActivate      Container
  596. //      IOleInPlaceSite::GetWindow              Container
  597. //      IOleInPlaceSite::GetWindowContext       Container
  598. //      IOleInPlaceSite::OnUIActivate           Container
  599. //      IOleInPlaceSite::Release                Container
  600. //      IOleInPlaceFrame::SetActiveObject       Container
  601. //      IOleInPlaceUIWindow::SetActiveObject    Container
  602. //      OutputDebugString                       Windows API
  603. //      ShowWindow                              Windows API
  604. //      SetParent                               Windows API
  605. //      IntersectRect                           Windows API
  606. //      OffsetRect                              Windows API
  607. //      MoveWindow                              Windows API
  608. //      CopyRect                                Windows API
  609. //      SetFocus                                Windows API
  610. //      SetHatchWindowSize                      OLE2UI
  611. //      CSimpSvrObj::AssembleMenus              OBJ.CPP
  612. //      CSimpSvrObj::AddFrameLevelUI            OBJ.CPP
  613. //
  614. //
  615. // Comments:
  616. //
  617. //      Be sure to read TECHNOTES.WRI included with the OLE SDK
  618. //      for details on implementing inplace activation.
  619. //
  620. //********************************************************************
  622. BOOL CSimpSvrObj::DoInPlaceActivate (LONG lVerb)
  623. {
  624.         BOOL retval = FALSE;
  625.         RECT posRect, clipRect;
  628.         OutputDebugString("In CSimpSvrObj::DoInPlaceActivatern");
  630.         // if not currently in place active
  631.         if (!m_fInPlaceActive)
  632.                 {
  633.                 // get the inplace site
  634.                 if (m_lpOleClientSite->QueryInterface(IID_IOleInPlaceSite,
  635.                                                                                           (LPVOID FAR *)&m_lpIPSite) != NOERROR)
  636.                         goto error;
  639.                 // if the inplace site could not be obtained, or refuses to inplace
  640.                 // activate then goto error.
  641.                 if (m_lpIPSite == NULL || m_lpIPSite->CanInPlaceActivate() != NOERROR)
  642.                         {
  643.                         if (m_lpIPSite)
  644.                                 m_lpIPSite->Release();
  645.                         m_lpIPSite == NULL;
  646.                         goto error;
  647.                         }
  649.                 // tell the site that we are activating.
  650.                 m_lpIPSite->OnInPlaceActivate();
  651.                 m_fInPlaceActive = TRUE;
  652.                 }
  654.         // if not currently inplace visibl
  655.         if (!m_fInPlaceVisible)
  656.                 {
  657.                 m_fInPlaceVisible = TRUE;
  659.                 // get the window handle of the site
  660.                 m_lpIPSite->GetWindow(&m_hWndParent);
  662.                 // get window context from the container
  663.                 m_lpIPSite->GetWindowContext ( &m_lpFrame,
  664.                                                                          &m_lpCntrDoc,
  665.                                                                          &posRect,
  666.                                                                          &clipRect,
  667.                                                                          &m_FrameInfo);
  669.                 // show the hatch window
  670.                 m_lpDoc->ShowHatchWnd();
  672.                 // Set the parenting
  673.                 SetParent (m_lpDoc->GethHatchWnd(), m_hWndParent);
  674.                 SetParent (m_lpDoc->GethDocWnd(), m_lpDoc->GethHatchWnd());
  676.                 // tell the client site to show the object
  677.                 m_lpOleClientSite->ShowObject();
  679.                 RECT resRect;
  681.                 // figure out the "real" size of the object
  682.                 IntersectRect(&resRect, &posRect, &clipRect);
  683.                 CopyRect(&m_posRect, &posRect);
  685.                 POINT pt;
  687.                 // adjust our hatch window size
  688.                 SetHatchWindowSize ( m_lpDoc->GethHatchWnd(),
  689.                                                          &resRect,
  690.                                                          &posRect,
  691.                                                          &pt);
  693.                 // calculate the actual object rect inside the hatchwnd.
  694.                 OffsetRect (&resRect, pt.x, pt.y);
  696.                 // move the object window
  697.                 MoveWindow(m_lpDoc->GethDocWnd(),
  698.                                    resRect.left,
  699.                                    resRect.top,
  700.                                    resRect.right - resRect.left,
  701.                                    resRect.bottom - resRect.top,
  702.                                    FALSE);
  704.                 // create the combined window
  705.                 AssembleMenus();
  706.                 }
  708.         // if not UIActive
  709.         if (!m_fUIActive)
  710.                 {
  711.                 m_fUIActive = TRUE;
  713.                 // tell the inplace site that we are activating
  714.                 m_lpIPSite->OnUIActivate();
  716.                 // set the focus to our object window
  717.                 SetFocus(m_lpDoc->GethDocWnd());
  719.                 // set the active object on the frame
  720.                 //@@WTK WIN32, UNICODE
  721.                 //m_lpFrame->SetActiveObject(&m_OleInPlaceActiveObject, "Simple OLE 2.0 Server");
  722.                 m_lpFrame->SetActiveObject(&m_OleInPlaceActiveObject, OLESTR("Simple OLE 2.0 Server"));
  724.                 // set the active object on the Doc, if available.
  725.                 if (m_lpCntrDoc)
  726.                         //@@WTK WIN32, UNICODE
  727.                         //m_lpCntrDoc->SetActiveObject(&m_OleInPlaceActiveObject, "Simple OLE 2.0 Server");
  728.                         m_lpCntrDoc->SetActiveObject(&m_OleInPlaceActiveObject, OLESTR("Simple OLE 2.0 Server"));
  730.                 // add the frame level UI.
  731.                 AddFrameLevelUI();
  732.                 }
  734.         retval = TRUE;
  735. error:
  736.         return retval;
  737. }
  739. //**********************************************************************
  740. //
  741. // CSimpSvrObj::AssembleMenus
  742. //
  743. // Purpose:
  744. //
  745. //      Creates the combined menus used during inplace activation.
  746. //
  747. // Parameters:
  748. //
  749. //      None
  750. //
  751. // Return Value:
  752. //
  753. //      None
  754. //
  755. // Function Calls:
  756. //      Function                        Location
  757. //
  758. //      OutputDebugString               Windows API
  759. //      CreateMenu                      Windows API
  760. //      IOleInPlaceFrame::InsertMenus   Container
  761. //      InsertMenu                      Windows API
  762. //      DestroyMenu                     Windows API
  763. //      OleCreateMenuDescriptor         OLE API
  764. //
  765. // Comments:
  766. //
  767. //
  768. //********************************************************************
  770. void CSimpSvrObj::AssembleMenus()
  771. {
  772.         OutputDebugString("In CSimpSvrObj::AssembleMenusrn");
  773.         OLEMENUGROUPWIDTHS menugroupwidths;
  775.         m_hmenuShared = NULL;
  777.         //  Create the menu resource
  778.         m_hmenuShared = CreateMenu();
  780.         // have the contaner insert its menus
  781.         if (m_lpFrame->InsertMenus (m_hmenuShared, &menugroupwidths) == NOERROR)
  782.                 {
  783.                 int nFirstGroup = (int) menugroupwidths.width[0];
  785.                 // insert the server menus
  786.                 //@@WTK WIN32, UNICODE
  787.                 //InsertMenu( m_hmenuShared, nFirstGroup, MF_BYPOSITION | MF_POPUP, m_lpDoc->GetApp()->GetColorMenu(), "&Color");
  788.                 InsertMenu( m_hmenuShared, nFirstGroup, MF_BYPOSITION | MF_POPUP,
  789.                         (UINT)m_lpDoc->GetApp()->GetColorMenu(), "&Color");
  790.                 menugroupwidths.width[1] = 1;
  791.                 menugroupwidths.width[3] = 0;
  792.                 menugroupwidths.width[5] = 0;
  793.                 }
  794.         else
  795.                 {
  796.                 // Destroy the menu resource
  797.                 DestroyMenu(m_hmenuShared);
  798.                 m_hmenuShared = NULL;
  799.                 }
  801.         // tell OLE to create the menu descriptor
  802.         m_hOleMenu = OleCreateMenuDescriptor(m_hmenuShared, &menugroupwidths);
  803. }
  805. //**********************************************************************
  806. //
  807. // CSimpSvrObj::AddFrameLevelUI
  808. //
  809. // Purpose:
  810. //
  811. //      Adds the Frame level user interface
  812. //
  813. // Parameters:
  814. //
  815. //      None
  816. //
  817. // Return Value:
  818. //
  819. //      None
  820. //
  821. // Function Calls:
  822. //      Function                    Location
  823. //
  824. //      OutputDebugString                   Windows API
  825. //      IOleInPlaceFrame::SetMenu           Container
  826. //      IOleInPlaceFrame::SetBorderSpace    Container
  827. //      IOleInPlaceUIWindow::SetBorderSpace Container
  828. //      CSimpSvrDoc::GethDocWnd             DOC.H
  829. //
  830. // Comments:
  831. //
  832. //
  833. //********************************************************************
  835. void CSimpSvrObj::AddFrameLevelUI()
  836. {
  837.         OutputDebugString("In CSimpSvrObj::AddFrameLevelUIrn");
  839.         // add the combined menu
  840.         m_lpFrame->SetMenu(m_hmenuShared, m_hOleMenu, m_lpDoc->GethDocWnd());
  842.         // do hatched border
  843.         SetParent (m_lpDoc->GethHatchWnd(), m_hWndParent);
  844.         SetParent (m_lpDoc->GethDocWnd(), m_lpDoc->GethHatchWnd());
  846.         // set the border space.  Normally we would negotiate for toolbar
  847.         // space at this point.  Since this server doesn't have a toolbar,
  848.         // this isn't needed...
  849.         if (m_lpFrame)
  850.                 m_lpFrame->SetBorderSpace(NULL);
  852.         if (m_lpCntrDoc)
  853.                 m_lpCntrDoc->SetBorderSpace(NULL);
  854. }
  856. //**********************************************************************
  857. //
  858. // CSimpSvrObj::DoInPlaceHide
  859. //
  860. // Purpose:
  861. //
  862. //      Hides the object while inplace actvie
  863. //
  864. // Parameters:
  865. //
  866. //      None
  867. //
  868. // Return Value:
  869. //
  870. //      None
  871. //
  872. // Function Calls:
  873. //      Function                        Location
  874. //
  875. //      OutputDebugString               Windows API
  876. //      SetParent                       Windows API
  877. //      CSimpSvrDoc::GethDocWnd         DOC.H
  878. //      CSimpSvrDoc::GethAppWnd         DOC.H
  879. //      CSimpSvrDoc::GethHatchWnd       DOC.H
  880. //      CSimpSvrObj::DisassembleMenus   OBJ.CPP
  881. //      IOleInPlaceFrame::Release       Container
  882. //      IOleInPlaceUIWindow::Release    Container
  883. //
  884. //
  885. // Comments:
  886. //
  887. //      Be sure to read TECHNOTES.WRI included with the OLE SDK
  888. //      for details on implementing inplace activation.
  889. //
  890. //********************************************************************
  892. void CSimpSvrObj::DoInPlaceHide()
  893. {
  894.         OutputDebugString("In CSimpSvrObj::DoInPlaceHidern");
  896.         // if we aren't inplace visible, then this routine is a NOP,
  897.         if (!m_fInPlaceVisible)
  898.                 return;
  900.         m_fInPlaceVisible = FALSE;
  902.         // change the parenting
  903.         SetParent (m_lpDoc->GethDocWnd(), m_lpDoc->GethAppWnd());
  904.         SetParent (m_lpDoc->GethHatchWnd(),m_lpDoc->GethDocWnd());
  906.         // rip down the combined menus
  907.         DisassembleMenus();
  909.         // release the inplace frame
  910.         m_lpFrame->Release();
  912.         m_lpFrame = NULL;  // only holding one ref. to frame.
  914.         // release the UIWindow if it is there.
  915.         if (m_lpCntrDoc)
  916.                 m_lpCntrDoc->Release();
  918.         m_lpCntrDoc = NULL;
  920. }
  922. //**********************************************************************
  923. //
  924. // CSimpSvrObj::DisassembleMenus
  925. //
  926. // Purpose:
  927. //
  928. //      Disassembles the combined menus used in inplace activation
  929. //
  930. // Parameters:
  931. //
  932. //      None
  933. //
  934. // Return Value:
  935. //
  936. //      None
  937. //
  938. // Function Calls:
  939. //      Function                    Location
  940. //
  941. //      OutputDebugString               Windows API
  942. //      OleDestroyMenuDescriptor        OLE API
  943. //      RemoveMenu                      Windows API
  944. //      IOleInPlaceFrame::RemoveMenus   Container
  945. //      DestroyMenu                     Windows API
  946. //
  947. // Comments:
  948. //
  949. //      Be sure to read TECHNOTES.WRI included with the OLE SDK
  950. //      for details on implementing inplace activation.
  951. //
  952. //********************************************************************
  954. void CSimpSvrObj::DisassembleMenus()
  955. {
  956.         // destroy the menu descriptor
  957.         OleDestroyMenuDescriptor(m_hOleMenu);
  959.         if (m_hmenuShared)
  960.                 {
  961.                 // remove the menus that we added
  962.                 RemoveMenu( m_hmenuShared, 1, MF_BYPOSITION);
  964.                 // have the container remove its menus
  965.                 m_lpFrame->RemoveMenus(m_hmenuShared);
  967.                 // Destroy the menu resource
  968.                 DestroyMenu(m_hmenuShared);
  970.                 m_hmenuShared = NULL;
  971.                 }
  972. }
  974. //**********************************************************************
  975. //
  976. // CSimpSvrObj::SendOnDataChange
  977. //
  978. // Purpose:
  979. //
  980. //      Uses the data advise holder to send a data change, then updates
  981. //      the ROT to note the time of change.
  982. //
  983. // Parameters:
  984. //
  985. //      None
  986. //
  987. // Return Value:
  988. //
  989. //      None
  990. //
  991. // Function Calls:
  992. //      Function                                Location
  993. //
  994. //      IDataAdviseHolder::SendOnDataChange     OLE API
  995. //      GetRunningObjectTable                   OLE API
  996. //      CoFileTimeNow                           OLE API
  997. //      IRunningObjectTable::NoteChangeTime     OLE API
  998. //
  999. // Comments:
  1000. //
  1001. //
  1002. //********************************************************************
  1004. void CSimpSvrObj::SendOnDataChange()
  1005. {
  1006.         if (m_lpDataAdviseHolder)
  1007.                 m_lpDataAdviseHolder->SendOnDataChange( (LPDATAOBJECT)&m_DataObject, 0, 0);
  1009.         LPRUNNINGOBJECTTABLE lpRot;
  1011.         GetRunningObjectTable(0, &lpRot);
  1013.         if ( lpRot && m_dwRegister)
  1014.                 {
  1015.                 FILETIME ft;
  1016.                 CoFileTimeNow(&ft);
  1018.                 lpRot->NoteChangeTime(m_dwRegister, &ft);
  1019.                 lpRot->Release();
  1020.                 }
  1021. }
  1023. //**********************************************************************
  1024. //
  1025. // CSimpSvrObj::DeactivateUI
  1026. //
  1027. // Purpose:
  1028. //
  1029. //      Breaks down the inplace ui
  1030. //
  1031. // Parameters:
  1032. //
  1033. //      None
  1034. //
  1035. // Return Value:
  1036. //
  1037. //      None
  1038. //
  1039. // Function Calls:
  1040. //      Function                                Location
  1041. //
  1042. //      SetParent                               Windows API
  1043. //      IOleInPlaceUIWindow::SetActiveObject    Container
  1044. //      IOleInPlaceFrame::SetActiveObject       Container
  1045. //      IOleInPlaceSite::UIDeactivate           Container
  1046. //
  1047. // Comments:
  1048. //
  1049. //
  1050. //********************************************************************
  1052. void CSimpSvrObj::DeactivateUI()
  1053. {
  1054.         // if not UI active, or no pointer to IOleInPlaceFrame, then
  1055.         // return NOERROR
  1056.         if (!(m_fUIActive || m_lpFrame))
  1057.                 return;
  1058.         else
  1059.                 {
  1060.                 m_fUIActive = FALSE;
  1062.                 // remove hatching
  1063.                 SetParent (m_lpDoc->GethDocWnd(), m_lpDoc->GethAppWnd());
  1064.                 SetParent (m_lpDoc->GethHatchWnd(),m_lpDoc->GethDocWnd());
  1066.                 // if in an MDI container, call SetActiveObject on the DOC.
  1067.                 if (m_lpCntrDoc)
  1068.                         m_lpCntrDoc->SetActiveObject(NULL, NULL);
  1070.                 m_lpFrame->SetActiveObject(NULL, NULL);
  1072.                 // tell the container that our UI is going away.
  1073.                 if (m_lpIPSite)
  1074.                         m_lpIPSite->OnUIDeactivate(FALSE);
  1075.                 }
  1076. }