home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWPart / FWProxy.cpp < prev    next >
Encoding:
Text File  |  1996-09-17  |  38.4 KB  |  1,244 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FRProxy.cpp
  4. //    Release Version:    $ ODF 2 $
  5. //
  6. //    Copyright:    (c) 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "FWFrameW.hpp"
  11.  
  12. #ifndef FWPROXY_H
  13. #include "FWProxy.h"
  14. #endif
  15.  
  16. #ifndef FWPARTNG_H
  17. #include "FWPartng.h"
  18. #endif
  19.  
  20. #ifndef FWFRMING_H
  21. #include "FWFrming.h"
  22. #endif
  23.  
  24. #ifndef FWUTIL_H
  25. #include "FWUtil.h"
  26. #endif
  27.  
  28. #ifndef FWPXYFRM_H
  29. #include "FWPxyFrm.h"
  30. #endif
  31.  
  32. #ifndef FWPRESEN_H
  33. #include "FWPresen.h"
  34. #endif
  35.  
  36. #ifndef FWCLNINF_H
  37. #include "FWClnInf.h"
  38. #endif
  39.  
  40. #ifndef FWPXYITE_H
  41. #include "FWPxyIte.h"
  42. #endif
  43.  
  44. // ----- Graphic Includes -----
  45.  
  46. #ifndef FWPOINT_H
  47. #include "FWPoint.h"
  48. #endif
  49.  
  50. #ifndef FWODGEOM_H
  51. #include "FWODGeom.h"
  52. #endif
  53.  
  54. // ----- ODF Foundation Includes -----
  55.  
  56. #ifndef FWDEBUG_H
  57. #include "FWDebug.h"
  58. #endif
  59.  
  60. #ifndef FWBARRAY_H
  61. #include "FWBArray.h"
  62. #endif
  63.  
  64. #ifndef FWORDCOL_H
  65. #include "FWOrdCol.h"
  66. #endif
  67.  
  68. // ----- ODUtil Includes -----
  69.  
  70. #ifndef _ITEXT_
  71. #include "IText.h"
  72. #endif
  73.  
  74. #ifndef _STDTYPIO_
  75. #include "StdTypIO.h"
  76. #endif
  77.  
  78. // ----- OpenDoc Includes -----
  79.  
  80. #ifndef SOM_Module_OpenDoc_StdProps_defined
  81. #include <StdProps.xh>
  82. #endif
  83.  
  84. #ifndef SOM_Module_OpenDoc_StdTypes_defined
  85. #include <StdTypes.xh>
  86. #endif
  87.  
  88. #ifndef SOM_ODShape_xh
  89. #include <Shape.xh>
  90. #endif
  91.  
  92. #ifndef SOM_ODTransform_xh
  93. #include <Trnsform.xh>
  94. #endif
  95.  
  96. #ifndef SOM_ODWindow_xh
  97. #include <Window.xh>
  98. #endif
  99.  
  100. #ifndef SOM_ODFrame_xh
  101. #include <Frame.xh>
  102. #endif
  103.  
  104. #ifndef SOM_ODStorageUnit_xh
  105. #include <StorageU.xh>
  106. #endif
  107.  
  108. #ifndef SOM_ODStorageUnitView_xh
  109. #include <SUView.xh>
  110. #endif
  111.  
  112. #ifndef SOM_ODPart_xh
  113. #include <Part.xh>
  114. #endif
  115.  
  116. #ifndef SOM_ODFacet_xh
  117. #include <Facet.xh>
  118. #endif
  119.  
  120. #ifndef SOM_ODDraft_xh
  121. #include <Draft.xh>
  122. #endif
  123.  
  124. //========================================================================================
  125. //    Runtime Info
  126. //========================================================================================
  127.  
  128. #ifdef FW_BUILD_MAC
  129. #pragma segment fw_embedding
  130. #endif
  131.  
  132.  
  133. //========================================================================================
  134. //    Constant
  135. //========================================================================================
  136.  
  137. typedef long FW_ProxyVersion;
  138. const FW_ProxyVersion FW_kProxyVersion = 0;
  139.  
  140. //========================================================================================
  141. //    Template Instantiations
  142. //========================================================================================
  143.  
  144. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollectionIterator, FW_MProxy)
  145. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollection, FW_MProxy)
  146.  
  147. #ifdef FW_USE_TEMPLATE_PRAGMAS
  148.  
  149. #pragma template_access public
  150. #pragma template FW_TOrderedCollection<FW_MProxy>
  151. #pragma template FW_TOrderedCollectionIterator<FW_MProxy>
  152.  
  153. #endif
  154.  
  155. //========================================================================================
  156. //    class FW_MProxy
  157. //========================================================================================
  158.  
  159. //----------------------------------------------------------------------------------------
  160. //    FW_MProxy::FW_MProxy
  161. //----------------------------------------------------------------------------------------
  162.  
  163. FW_MProxy::FW_MProxy(Environment* ev, 
  164.                     FW_CEmbeddingPart* part, 
  165.                     FW_Boolean shown) :
  166.     fPart(part),
  167.     fProxyFrames(NULL),
  168.     fClonedFrameID(kODNULLID),
  169.     fEmbeddedFacetCount(0),
  170.     fSelected(FALSE),
  171.     fShown(shown),
  172.     fDetached(TRUE),
  173.     fFrameGroup(0),
  174.     fSequenceNumber(0)
  175. {
  176.     FW_ASSERT(fPart != NULL);
  177.     
  178.     fPart->PrivAddProxy(ev, this);
  179.     fDetached = FALSE;
  180.     
  181.     fProxyFrames = FW_NEW(FW_TOrderedCollection<FW_CProxyFrame>, ());
  182. }
  183.  
  184. //----------------------------------------------------------------------------------------
  185. //    FW_MProxy::~FW_MProxy
  186. //----------------------------------------------------------------------------------------
  187.  
  188. FW_MProxy::~FW_MProxy()
  189. {
  190.     FW_SOMEnvironment ev;
  191.  
  192.     if (!fDetached)
  193.         fPart->PrivRemoveProxy(ev, this);
  194.     
  195.     if (fProxyFrames)
  196.     {        
  197.         FW_CProxyFrame* proxyFrame;
  198.         while ((proxyFrame = fProxyFrames->First()) != NULL)
  199.         {
  200.             FW_ASSERT(proxyFrame->GetProxy(ev) == this);
  201.             PrivDeleteProxyFrame(ev, proxyFrame);
  202.         }
  203.             
  204.         delete fProxyFrames;
  205.         fProxyFrames = NULL;
  206.     }
  207. }
  208.  
  209. //----------------------------------------------------------------------------------------
  210. //     FW_MProxy::UsedShapeChanged
  211. //----------------------------------------------------------------------------------------
  212. //    The used shape of one of my embedded frame has changed
  213.  
  214. void FW_MProxy::UsedShapeChanged(Environment *ev, 
  215.                                     FW_CEmbeddingFrame* embeddingFrame,
  216.                                     ODFrame* odEmbeddedFrame)
  217. {
  218. FW_UNUSED(ev);
  219. FW_UNUSED(embeddingFrame);
  220. FW_UNUSED(odEmbeddedFrame);
  221. }
  222.  
  223. //----------------------------------------------------------------------------------------
  224. //     FW_MProxy::PrivSetFrameGroup
  225. //----------------------------------------------------------------------------------------
  226.  
  227. void FW_MProxy::PrivSetFrameGroup(Environment *ev, ODID frameGroup)
  228. {
  229.     fFrameGroup = frameGroup;
  230.     
  231.     FW_CProxyProxyFrameIterator ite(this);
  232.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  233.     {
  234.         proxyFrame->PrivSetFrameGroup(ev, frameGroup);
  235.     }
  236. }
  237.  
  238. //----------------------------------------------------------------------------------------
  239. //     FW_MProxy::ChangeSequenceNumber
  240. //----------------------------------------------------------------------------------------
  241.  
  242. void FW_MProxy::ChangeSequenceNumber(Environment *ev, ODID sequenceNumber)
  243. {
  244.     fSequenceNumber = sequenceNumber;
  245.     
  246.     FW_CProxyProxyFrameIterator ite(this);
  247.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  248.     {
  249.         proxyFrame->PrivChangeSequenceNumber(ev, fSequenceNumber);
  250.     }
  251. }
  252.  
  253. //----------------------------------------------------------------------------------------
  254. //    FW_MProxy::FrameShapeRequested
  255. //----------------------------------------------------------------------------------------
  256.  
  257. ODShape* FW_MProxy::FrameShapeRequested(Environment* ev, 
  258.                                         FW_CEmbeddingFrame* frame,
  259.                                         ODFrame* odEmbeddedFrame, 
  260.                                         ODShape* requestedFrameShape)
  261. {
  262. FW_UNUSED(frame);
  263. FW_UNUSED(odEmbeddedFrame);
  264.  
  265.     // ----- Simply grant the requested frame
  266.     requestedFrameShape->Acquire(ev);
  267.     return requestedFrameShape;
  268. }
  269.  
  270. //----------------------------------------------------------------------------------------
  271. //    FW_MProxy::AttachEmbeddedFrames
  272. //----------------------------------------------------------------------------------------
  273.  
  274. void FW_MProxy::AttachEmbeddedFrames(Environment *ev)
  275. {
  276.     FW_CProxyProxyFrameIterator ite(this);
  277.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  278.     {
  279.         proxyFrame->PrivAttach(ev);
  280.     }
  281.     
  282.     fPart->PrivAddProxy(ev, this);
  283.     fDetached = FALSE;
  284. }
  285.  
  286. //----------------------------------------------------------------------------------------
  287. //    FW_MProxy::ProxyFrameAdded
  288. //----------------------------------------------------------------------------------------
  289.  
  290. void FW_MProxy::ProxyFrameAdded(Environment *ev, FW_CProxyFrame* proxyFrame)
  291. {
  292. FW_UNUSED(ev);
  293. FW_UNUSED(proxyFrame);
  294. }
  295.  
  296. //----------------------------------------------------------------------------------------
  297. //    FW_MProxy::ProxyFrameRemoved
  298. //----------------------------------------------------------------------------------------
  299.  
  300. void FW_MProxy::ProxyFrameRemoved(Environment *ev, FW_CProxyFrame* proxyFrame)
  301. {
  302. FW_UNUSED(ev);
  303. FW_UNUSED(proxyFrame);
  304. }
  305.  
  306. //----------------------------------------------------------------------------------------
  307. //    FW_MProxy::DetachEmbeddedFrames
  308. //----------------------------------------------------------------------------------------
  309. //    At the end proxyFrames are only owned by the proxy
  310.  
  311. void FW_MProxy::DetachEmbeddedFrames(Environment *ev)
  312. {
  313.     FW_CProxyProxyFrameIterator ite(this);
  314.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  315.     {
  316.         proxyFrame->PrivDetach(ev);
  317.     }
  318.  
  319.     fPart->PrivRemoveProxy(ev, this);
  320.     fDetached = TRUE;
  321. }
  322.  
  323. //----------------------------------------------------------------------------------------
  324. //    FW_MProxy::RemoveEmbeddedFrames
  325. //----------------------------------------------------------------------------------------
  326. //    At the end this proxy doesn't have any proxyframes
  327. //    Attention: Use DetachEmbeddedFrames if you are supporting Undo
  328.  
  329. void FW_MProxy::RemoveEmbeddedFrames(Environment *ev)
  330. {
  331.     // ----- First detach them, if necessary
  332.     if (!fDetached)
  333.         DetachEmbeddedFrames(ev);
  334.     
  335.     // ----- Remove all the embedded frames -----
  336.     FW_CProxyFrame* proxyFrame ;
  337.     while ((proxyFrame = fProxyFrames->First()) != NULL)
  338.         PrivDeleteProxyFrame(ev, proxyFrame);
  339. }
  340.  
  341. //----------------------------------------------------------------------------------------
  342. //    FW_MProxy::HideShow
  343. //----------------------------------------------------------------------------------------
  344.  
  345. void FW_MProxy::HideShow(Environment *ev, FW_Boolean shown)
  346. {
  347.     if (fShown != shown)
  348.     {
  349.         fShown = shown;
  350.  
  351.         FW_CProxyProxyFrameIterator ite(this);
  352.         for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  353.         {
  354.             proxyFrame->SetPurgeable(ev, !shown);
  355.             if (!shown)
  356.                 proxyFrame->Purge(ev);
  357.         }
  358.     }
  359. }
  360.  
  361. //----------------------------------------------------------------------------------------
  362. //    FW_MProxy::PrivDeleteProxyFrame
  363. //----------------------------------------------------------------------------------------
  364.  
  365. void FW_MProxy::PrivDeleteProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  366. {    
  367. FW_UNUSED(ev);
  368.     fProxyFrames->Remove(proxyFrame);
  369.     ProxyFrameRemoved(ev, proxyFrame);
  370.     
  371.     delete proxyFrame;
  372. }
  373.  
  374. //----------------------------------------------------------------------------------------
  375. //    FW_MProxy::GetProxyFrame
  376. //----------------------------------------------------------------------------------------
  377.  
  378. FW_CProxyFrame* FW_MProxy::GetProxyFrame(Environment* ev, ODStorageUnitID frameID) const
  379. {
  380.     FW_TOrderedCollectionIterator<FW_CProxyFrame> ite(fProxyFrames);
  381.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  382.     {
  383.         if (frameID == proxyFrame->GetFrameID(ev))
  384.             return proxyFrame;
  385.     }
  386.     
  387.     return NULL;
  388. }
  389.  
  390. //----------------------------------------------------------------------------------------
  391. //    FW_MProxy::PrivContainerIDToProxyFrame
  392. //----------------------------------------------------------------------------------------
  393. //    Returns a proxyframe knowing is container frame ID
  394.  
  395. FW_CProxyFrame* FW_MProxy::PrivContainerIDToProxyFrame(Environment* ev, ODStorageUnitID containerID) const
  396. {
  397.     FW_TOrderedCollectionIterator<FW_CProxyFrame> ite(fProxyFrames);
  398.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  399.     {
  400.         if (proxyFrame->IsAttached(ev) && containerID == proxyFrame->GetContainingFrameID(ev))
  401.             return proxyFrame;
  402.     }
  403.     
  404.     return NULL;
  405. }
  406.  
  407. //----------------------------------------------------------------------------------------
  408. //    FW_MProxy::GetEmbeddedFacetUnderMouse
  409. //----------------------------------------------------------------------------------------
  410. // 'mouse' in Frame coordinate system
  411.  
  412. ODFacet* FW_MProxy::GetEmbeddedFacetUnderMouse(Environment* ev, ODFacet* embeddingFacet, const FW_CPoint& mouse) const
  413. {    
  414.     ODPoint odMouse = mouse;
  415.  
  416.     FW_CEmbeddedODFacetsIterator ite(ev, this, embeddingFacet, kODFrontToBack);
  417.     for (ODFacet* odFacet = ite.First(ev); ite.IsNotComplete(ev); odFacet = ite.Next(ev))
  418.     {
  419.         if (odFacet->ContainsPoint(ev, &odMouse, NULL))
  420.             return odFacet;
  421.     }
  422.     
  423.     return NULL;
  424. }
  425.  
  426. //----------------------------------------------------------------------------------------
  427. //    FW_MProxy::SetSelectState
  428. //----------------------------------------------------------------------------------------
  429.  
  430. void FW_MProxy::SetSelectState(Environment* ev, FW_Boolean state)
  431. {
  432.     fSelected = state;
  433.     
  434.     // ----- Set the selected flag in facet -----
  435.     FW_CProxyEmbeddedFrameIterator ite(ev, this);
  436.     for (ODFrame* odEmbeddedFrame = ite.First(ev); ite.IsNotComplete(ev); odEmbeddedFrame = ite.Next(ev))
  437.     {
  438.         FW_CODFrameFacetIterator ite2(ev, odEmbeddedFrame);
  439.         for (ODFacet* facet = ite2.First(ev); ite2.IsNotComplete(ev); facet = ite2.Next(ev))
  440.             facet->SetSelected(ev, state);
  441.     }
  442. }
  443.  
  444. //----------------------------------------------------------------------------------------
  445. //    FW_MProxy::ChangeHighlight
  446. //----------------------------------------------------------------------------------------
  447. //    if embeddingFrame is NULL change the
  448. void FW_MProxy::ChangeHighlight(Environment* ev, ODHighlight highlight, FW_CEmbeddingFrame* embeddingFrame)
  449. {
  450.     FW_CProxyProxyFrameIterator ite(this);
  451.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  452.     {
  453.         if ((embeddingFrame == NULL) || (proxyFrame->GetContainingFrame(ev) == embeddingFrame))
  454.         {
  455.             proxyFrame->ChangeHighlight(ev, highlight);
  456.         }
  457.     }
  458.     
  459. /*
  460.     FW_CProxyEmbeddedFrameIterator ite(ev, this);
  461.     for (ODFrame* odEmbeddedFrame = ite.First(ev); ite.IsNotComplete(ev); odEmbeddedFrame = ite.Next(ev))
  462.     {    
  463.         FW_Boolean doIt = (embeddingFrame == NULL);
  464.         if (!doIt)
  465.         {
  466.             FW_CAcquiredODFrame containingFrame = odEmbeddedFrame->AcquireContainingFrame(ev);
  467.             doIt = (containingFrame == embeddingFrame->GetODFrame(ev));
  468.         }
  469.         
  470.         if (doIt)
  471.         {
  472.             FW_CODFrameFacetIterator ite2(ev, odEmbeddedFrame);
  473.             for (ODFacet* facet = ite2.First(ev); ite2.IsNotComplete(ev); facet = ite2.Next(ev))
  474.                 facet->ChangeHighlight(ev, highlight);
  475.         }
  476.     }
  477. */
  478. }
  479.  
  480. //----------------------------------------------------------------------------------------
  481. //    FW_MProxy::AcquireEmbeddedPart
  482. //----------------------------------------------------------------------------------------
  483. //    if instantiate == FALSE try to find a proxyfrom already in memory to get the part. If can't
  484. //    find one then return NULL
  485.  
  486. ODPart* FW_MProxy::AcquireEmbeddedPart(Environment* ev, FW_Boolean instantiate) const
  487. {
  488.     // Should not be called when empty because proxys are automatically deleted
  489.     FW_ASSERT(fProxyFrames->Count() != 0);
  490.     
  491.     FW_CProxyFrame* proxyFrame = fProxyFrames->First();
  492.     if (instantiate == FALSE)
  493.     {
  494.         while (proxyFrame != NULL && !proxyFrame->IsFrameInMemory(ev))
  495.             proxyFrame = fProxyFrames->After(proxyFrame);
  496.     }
  497.     
  498.     if (proxyFrame == NULL)
  499.         return NULL;
  500.     else
  501.         return proxyFrame->GetFrame(ev)->AcquirePart(ev);
  502. }
  503.  
  504. //----------------------------------------------------------------------------------------
  505. //    FW_MProxy::GetProxyFrame
  506. //----------------------------------------------------------------------------------------
  507. //    returns a proxyframe knowing its embedding frame
  508.  
  509. FW_CProxyFrame* FW_MProxy::GetProxyFrame(Environment* ev, FW_CEmbeddingFrame* embeddingFrame) const
  510. {
  511.     FW_CProxyProxyFrameIterator ite(this);
  512.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  513.     {
  514.         if (proxyFrame->GetContainingFrame(ev) == embeddingFrame)
  515.             return proxyFrame;
  516.     }
  517.     return NULL;
  518. }
  519.  
  520. //----------------------------------------------------------------------------------------
  521. //    FW_MProxy::AcquireEmbeddedFrame
  522. //----------------------------------------------------------------------------------------
  523. //    returns the embedded frame of this proxy (embedded) frame. If instantiate == FALSE return
  524. //    NULL unless the frame is already instantiated.
  525.  
  526. ODFrame* FW_MProxy::AcquireEmbeddedFrame(Environment* ev, FW_CEmbeddingFrame* embeddingFrame, FW_Boolean instantiate) const
  527. {
  528.     ODFrame* embeddedFrame = NULL;
  529.     FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, embeddingFrame);
  530.     if (proxyFrame && (proxyFrame->IsFrameInMemory(ev) || instantiate == TRUE))
  531.     {
  532.         embeddedFrame = proxyFrame->GetFrame(ev);
  533.         embeddedFrame->Acquire(ev);
  534.     }
  535.     
  536.     return embeddedFrame;
  537. }
  538.  
  539. //----------------------------------------------------------------------------------------
  540. //    FW_MProxy::IsEmbeddedFrame
  541. //----------------------------------------------------------------------------------------
  542. //    returns true if the embeddedframe belongs to this proxy
  543.  
  544. FW_Boolean FW_MProxy::IsEmbeddedFrame(Environment* ev, ODFrame* embeddedFrame) const
  545. {
  546.     ODID frameID = embeddedFrame->GetID(ev);
  547.     FW_CProxyProxyFrameIterator ite(this);
  548.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  549.     {
  550.         if (proxyFrame->GetFrameID(ev) == frameID)
  551.             return TRUE;
  552.     }
  553.     
  554.     return FALSE;
  555. }
  556.  
  557. //----------------------------------------------------------------------------------------
  558. //    FW_MProxy::Externalize
  559. //----------------------------------------------------------------------------------------
  560.  
  561. void FW_MProxy::Externalize(Environment* ev, 
  562.                             ODStorageUnitView* destinationSUView, 
  563.                             FW_CCloneInfo* cloneInfo)
  564. {
  565.     // ----- Write first a version number -----
  566.     FW_CByteArray byteArray(&FW_kProxyVersion, sizeof(FW_ProxyVersion));
  567.     destinationSUView->SetValue(ev, byteArray);
  568.  
  569.     // ----- Write out the hide/show state -----
  570.     byteArray.Set(&fShown, sizeof(fShown));
  571.     destinationSUView->SetValue(ev, byteArray);    
  572.     
  573.     // ----- Write the SequenceNumber -----
  574.     byteArray.Set(&fSequenceNumber, sizeof(fSequenceNumber));
  575.     destinationSUView->SetValue(ev, byteArray);
  576.  
  577.     // ----- Write the frameGroup -----
  578.     byteArray.Set(&fFrameGroup, sizeof(fFrameGroup));
  579.     destinationSUView->SetValue(ev, byteArray);
  580.  
  581.     FW_CFrame* scopeFrame = (cloneInfo != NULL) ? cloneInfo->GetScopeFrame(ev) : NULL;
  582.     
  583.     // ----- Write the nymber of proxyframes -----
  584.     unsigned long count = 0;
  585.     if (scopeFrame != NULL)
  586.         count = 1;
  587.     else
  588.     {
  589.         // Count only the proxyFrame with a containing frame persistent
  590.         FW_CProxyProxyFrameIterator ite(this);
  591.         for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  592.         {
  593.             if (proxyFrame->GetContainingFrame(ev)->IsPersistent(ev))
  594.                 count++;
  595.         }
  596.     }
  597.     
  598.     FW_CByteArray byteArray2(&count, sizeof(unsigned long));
  599.     destinationSUView->SetValue(ev, byteArray2);
  600.     
  601.     // ----- Clone or write the proxyframe(s) -----
  602.     if (scopeFrame != NULL)
  603.     {    
  604. #ifdef FW_DEBUG
  605.         FW_CEmbeddingFrame* scopeEmbeddingFrame = FW_DYNAMIC_CAST(FW_CEmbeddingFrame, scopeFrame);
  606.         FW_ASSERT(scopeEmbeddingFrame);
  607.         FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, scopeEmbeddingFrame);
  608. #else
  609.         FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, (FW_CEmbeddingFrame*)scopeFrame);
  610. #endif
  611.         FW_ASSERT(proxyFrame != NULL);
  612.         
  613.         FW_Boolean result = proxyFrame->ExternalizeProxyFrame(ev, destinationSUView, cloneInfo);
  614.         FW_ASSERT(result = TRUE);
  615.     }
  616.     else
  617.     {        
  618.         // ----- Externalize each persistent proxy Frame -----
  619.         FW_CProxyProxyFrameIterator ite2(this);
  620.         for (FW_CProxyFrame* proxyFrame = ite2.First(); ite2.IsNotComplete(); proxyFrame = ite2.Next())
  621.         {
  622.             FW_Boolean result = proxyFrame->ExternalizeProxyFrame(ev, destinationSUView, cloneInfo);
  623.             FW_ASSERT(result = TRUE);
  624.         }
  625.     }
  626. }
  627.  
  628. //----------------------------------------------------------------------------------------
  629. //    FW_MProxy::Embed
  630. //----------------------------------------------------------------------------------------
  631.  
  632. FW_DECLARE_THROW_POINT (FW_MProxy_Embed);
  633.  
  634. void FW_MProxy::Embed(Environment *ev, 
  635.                     FW_CPresentation* embeddingPresentation,
  636.                     ODPart *embeddedPart,            // Might be null
  637.                     ODFrame* odEmbeddedFrame,        // Might be null
  638.                     ODType suggestedFrameType,        //    preferred frame type
  639.                     ODShape* frameShape,
  640.                     ODTypeToken viewType,
  641.                     ODTypeToken presentationType,
  642.                     ODID frameGroupID,
  643.                     FW_Boolean isOverlaid,
  644.                     FW_Boolean subFrame)
  645. {
  646. /*    Exception Handling
  647.     If an exception is thrown while we are partway through creating frames then we
  648.     have destroy all previously created frames.
  649. */
  650.     FW_ASSERT(frameShape);
  651.     FW_ASSERT(embeddingPresentation);
  652. #ifdef FW_DEBUG
  653.     if (odEmbeddedFrame == NULL)
  654.         FW_ASSERT(embeddedPart != NULL);
  655. #endif
  656.     
  657.     FW_CAcquiredODPart aqEmbeddedPart;
  658.     
  659.     ODFrame* passedInFrame = NULL;
  660.     ODFrame* sourceFrame = NULL;
  661.     ODFrame* newEmbeddedFrame = NULL;
  662.     
  663.     // ----- Force the frame type to be the one of the embedded frame ------
  664.     if (odEmbeddedFrame != NULL)
  665.         suggestedFrameType = (odEmbeddedFrame->GetStorageUnit(ev) != NULL) ? kODFrameObject : kODNonPersistentFrameObject; 
  666.     
  667.     // ----- Create an embedded frame for each of my display frame -----        
  668.     FW_TRY 
  669.     { // loop protection
  670.         FW_CPresentationFrameIterator ite(ev, embeddingPresentation);
  671.         for (FW_CEmbeddingFrame* embeddingFrame = (FW_CEmbeddingFrame*)ite.First(ev); ite.IsNotComplete(ev); embeddingFrame = (FW_CEmbeddingFrame*)ite.Next(ev))
  672.         {
  673.             FW_CProxyFrame* proxyFrame;
  674.             
  675.             FW_CAcquiredODShape aqItsShape(frameShape->Copy(ev));
  676.             
  677.             // ----- Create the frame -----
  678.             FW_Boolean isEmbeddedFrame = FALSE;
  679.             if (odEmbeddedFrame != NULL)
  680.             {
  681.                 FW_CAcquiredODFrame aqContainingFrame = odEmbeddedFrame->AcquireContainingFrame(ev);
  682.                 isEmbeddedFrame = (aqContainingFrame == embeddingFrame->GetODFrame(ev));
  683.             }
  684.                 
  685.             if (isEmbeddedFrame)
  686.             {
  687.                 // [HLX] I should not change the presentation and the view type of an existing embedded frame
  688. //                odEmbeddedFrame->ChangeViewType(ev, viewType);
  689. //                odEmbeddedFrame->ChangePresentation(ev, presentationType == NULL ? FW_CSession::Tokenize(ev, kODPresDefault) : presentationType);
  690.                 odEmbeddedFrame->SetFrameGroup(ev, frameGroupID);
  691.                 odEmbeddedFrame->ChangeSequenceNumber(ev, 0);
  692.                 odEmbeddedFrame->SetSubframe(ev, subFrame);
  693.                         
  694.                 newEmbeddedFrame = odEmbeddedFrame;
  695.                 passedInFrame = odEmbeddedFrame;
  696.                 odEmbeddedFrame = NULL;                    // We used it. Next time around we want to create a new frame
  697.                 
  698.                 proxyFrame = this->PrivNewProxyFrame(ev, (FW_CEmbeddingPart*)GetPart(ev), embeddingFrame, newEmbeddedFrame, TRUE);
  699.                 
  700.                 // Change the frame shape after we have a proxyFrame (only if necessary)
  701.                 FW_CAcquiredODShape aqFrameShape = newEmbeddedFrame->AcquireFrameShape(ev, NULL);
  702.                 if (!aqFrameShape->IsSameAs(ev, aqItsShape))
  703.                     newEmbeddedFrame->ChangeFrameShape(ev, aqItsShape, NULL);
  704.             }
  705.             else
  706.             {
  707.                 // It is better to acquire the part only when needed.
  708.                 if (embeddedPart == NULL)
  709.                 {
  710.                     aqEmbeddedPart = passedInFrame->AcquirePart(ev);
  711.                     embeddedPart = aqEmbeddedPart;
  712.                 }
  713.                 
  714.                 FW_CAcquiredODFrame embeddedODFrame = embeddingFrame->PrivCreateEmbeddedFrame(ev, 
  715.                                                                                         suggestedFrameType, 
  716.                                                                                         embeddedPart,
  717.                                                                                         aqItsShape, 
  718.                                                                                         NULL, 
  719.                                                                                         viewType, 
  720.                                                                                         presentationType, 
  721.                                                                                         isOverlaid, 
  722.                                                                                         subFrame);
  723.  
  724.                 // ----- Create the proxyFrame for this embedded frame -----
  725.                 proxyFrame = this->PrivNewProxyFrame(ev, embeddingFrame->GetPart(ev), embeddingFrame, embeddedODFrame, FALSE);
  726.  
  727.                 proxyFrame->PrivSetFrameGroup(ev, frameGroupID);
  728.                 newEmbeddedFrame = proxyFrame->GetFrame(ev);
  729.  
  730.             }
  731.             
  732.             // ----- Set the newly embedded frame's link status -----
  733.             newEmbeddedFrame->ChangeLinkStatus(ev, kODNotInLink);
  734.             
  735.             FW_TRY
  736.             {
  737.                 // ----- Attach source frames if needed -----
  738.                 // If we are creating two or more frames at the same time then this tells the embedded part
  739.                 // that those frames are supposed to display the same content.
  740.                 if (sourceFrame)
  741.                 {
  742.                     FW_ASSERT(embeddedPart);
  743.                     embeddedPart->AttachSourceFrame(ev, newEmbeddedFrame, sourceFrame);
  744.                 }
  745.                 sourceFrame = newEmbeddedFrame;
  746.                 
  747.                 // ----- Create its facets -----
  748.                 // We have to make sure not to leave a dangling frame if this fails
  749.                 FW_CHECK_THROW_POINT (FW_MProxy_Embed);
  750.                 // XXX if isEmbedded frame then we shouldn't destroy it (since we didn't create it)            
  751.                 proxyFrame->CreateAllFacets(ev);
  752.             }
  753.             FW_CATCH_BEGIN
  754.             FW_CATCH_EVERYTHING () {
  755.                 embeddingFrame->PrivRemoveEmbeddedFrame (ev, proxyFrame);
  756.                 FW_THROW_SAME ();
  757.             }
  758.             FW_CATCH_END
  759.         }
  760.     } // FW_TRY loop protection
  761.     FW_CATCH_BEGIN
  762.     FW_CATCH_EVERYTHING () {
  763.         // Work in reverse to clean up everything from previous passes through the loop. 
  764.         // That is if we completed two loops and failed partway through loop 3, assume that loop 3
  765.         // was cleaned up properly (in try/catch block above) and undo loops 1 and 2.
  766.         FW_THROW_SAME ();
  767.     }
  768.     FW_CATCH_END
  769.     
  770.     // ----- If we haven't use odEmbeddedFrame there is a problem -----
  771.     FW_ASSERT(odEmbeddedFrame == NULL);
  772. }
  773.  
  774. //----------------------------------------------------------------------------------------
  775. //    FW_MProxy::PrivPostClone
  776. //----------------------------------------------------------------------------------------
  777.  
  778. void FW_MProxy::PrivPostClone(Environment* ev, FW_CCloneInfo* cloneInfo) 
  779. {
  780.     if (fClonedFrameID == kODNULLID)
  781.         return;
  782.     
  783.     FW_CFrame* scopeFrame = cloneInfo->GetScopeFrame(ev);
  784.     FW_ASSERT(scopeFrame);
  785.                 
  786.     // ----- Get the new frame from my draft -----
  787.     FW_CAcquiredODFrame aqODEmbeddedFrame = cloneInfo->GetToDraft(ev)->AcquireFrame(ev, fClonedFrameID);
  788.     FW_ASSERT(aqODEmbeddedFrame != NULL);
  789.     
  790.     // ----- Set the containing frame
  791.     aqODEmbeddedFrame->SetContainingFrame(ev, scopeFrame->GetODFrame(ev));
  792.  
  793.     // ----- Now we can embed it -----    
  794.     FW_CAcquiredODShape aqFrameShape = aqODEmbeddedFrame->AcquireFrameShape(ev, NULL);
  795.     
  796.     Embed(ev, 
  797.         scopeFrame->GetPresentation(ev),
  798.         NULL,
  799.         aqODEmbeddedFrame,
  800.         (aqODEmbeddedFrame->GetStorageUnit(ev) != NULL) ? kODFrameObject : kODNonPersistentFrameObject,                     
  801.         aqFrameShape,
  802.         aqODEmbeddedFrame->GetViewType(ev),
  803.         aqODEmbeddedFrame->GetPresentation(ev),
  804.         aqODEmbeddedFrame->GetFrameGroup(ev),
  805.         aqODEmbeddedFrame->IsOverlaid(ev),
  806.         aqODEmbeddedFrame->IsSubframe(ev));
  807.  
  808.     // ----- Cloning done -----
  809.     fClonedFrameID = kODNULLID;
  810. }
  811.  
  812. //----------------------------------------------------------------------------------------
  813. //    FW_MProxy::Internalize
  814. //----------------------------------------------------------------------------------------
  815.  
  816. void FW_MProxy::Internalize(Environment* ev, 
  817.                             ODStorageUnitView* sourceSUView,
  818.                             FW_CCloneInfo *cloneInfo)
  819. {
  820.     FW_CByteArray byteArray;
  821.  
  822.     // ----- Read first the version number -----
  823.     FW_ProxyVersion version;
  824.     sourceSUView->GetValue(ev, sizeof(FW_ProxyVersion), byteArray);
  825.     byteArray.CopyBuffer(&version, sizeof(FW_ProxyVersion));
  826.     FW_ASSERT(version == FW_kProxyVersion);
  827.  
  828.     // ----- Read in the hide/show state -----
  829.     sourceSUView->GetValue(ev, sizeof(fShown), byteArray);
  830.     byteArray.CopyBuffer(&fShown, sizeof(fShown));
  831.  
  832.     // ----- Read in the Sequence Number -----
  833.     sourceSUView->GetValue(ev, sizeof(fSequenceNumber), byteArray);
  834.     byteArray.CopyBuffer(&fSequenceNumber, sizeof(fSequenceNumber));
  835.  
  836.     // ----- Read in the frameGroup -----
  837.     sourceSUView->GetValue(ev, sizeof(fFrameGroup), byteArray);
  838.     byteArray.CopyBuffer(&fFrameGroup, sizeof(fFrameGroup));
  839.     if (fFrameGroup != 0)
  840.         fPart->PrivSetNextFrameGroup(ev, fFrameGroup);
  841.     
  842.     // ----- Read the number of proxyframe -----
  843.     unsigned long count;
  844.     
  845.     sourceSUView->GetValue(ev, sizeof(unsigned long), byteArray);
  846.     byteArray.CopyBuffer(&count, sizeof(unsigned long));
  847.  
  848.     // ----- Clone or Read in the proxyframe(s) -----
  849.     if (cloneInfo != NULL)
  850.     {
  851.         FW_ASSERT(cloneInfo->GetScopeFrame(ev));
  852.         
  853.         if (cloneInfo->fClonedProxyList == NULL)
  854.             cloneInfo->fClonedProxyList = FW_NEW(FW_TOrderedCollection<FW_MProxy>, ());
  855.         
  856.         cloneInfo->fClonedProxyList->AddLast(this);
  857.             
  858.         FW_ASSERT(count == 1);        // if clone we should have only one embedded frame
  859.     
  860.         ODStorageUnitRef aSURef;
  861.         sourceSUView->GetValue(ev, sizeof(ODStorageUnitRef), byteArray);
  862.         byteArray.CopyBuffer(&aSURef, sizeof(ODStorageUnitRef));
  863.         
  864.         FW_ASSERT(sourceSUView->IsValidStorageUnitRef(ev, aSURef));
  865.     
  866.         ODStorageUnitID fromFrameID = sourceSUView->GetIDFromStorageUnitRef(ev, aSURef);
  867.         fClonedFrameID = cloneInfo->Clone(ev, fromFrameID, 0, 0);
  868.     }
  869.     else
  870.     {
  871.         for (unsigned long i = 0; i<count; i++)
  872.             this->PrivNewProxyFrame(ev, fPart, sourceSUView);
  873.     }
  874. }
  875.  
  876. //----------------------------------------------------------------------------------------
  877. //    FW_MProxy::ChangeEmbeddedFramesViewType
  878. //----------------------------------------------------------------------------------------
  879. //    ATTENTION: I am forcing the embedded frame to be in memory
  880.  
  881. void FW_MProxy::ChangeEmbeddedFramesViewType(Environment* ev, ODTypeToken viewType)
  882. {
  883.     FW_CProxyProxyFrameIterator ite(this);
  884.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  885.     {
  886.         proxyFrame->GetFrame(ev)->ChangeViewType(ev, viewType);
  887.     }
  888. }
  889.  
  890. //----------------------------------------------------------------------------------------
  891. //    FW_MProxy::ChangeExternalTransforms
  892. //----------------------------------------------------------------------------------------
  893.  
  894. void FW_MProxy::ChangeExternalTransforms(Environment* ev, FW_Fixed x, FW_Fixed y)
  895. {
  896.     if (fEmbeddedFacetCount != 0)
  897.     {
  898.         FW_CAcquiredODTransform transform = ::FW_NewODTransform(ev, FW_CPoint(x, y));
  899.         ChangeExternalTransforms(ev, transform);
  900.     }
  901. }
  902.  
  903. //----------------------------------------------------------------------------------------
  904. //    FW_MProxy::ChangeExternalTransforms
  905. //----------------------------------------------------------------------------------------
  906.  
  907. void FW_MProxy::ChangeExternalTransforms(Environment* ev, ODTransform* transform)
  908. {
  909.     FW_ASSERT(transform);
  910.     
  911.     if (fEmbeddedFacetCount == 0)
  912.         return;
  913.  
  914.     transform->Acquire(ev);
  915.     FW_CAcquiredODTransform aqTransform(transform);
  916.     
  917.     FW_CProxyProxyFrameIterator ite(this);
  918.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  919.     {
  920.         if (proxyFrame->IsFrameInMemory(ev))
  921.         {
  922.             FW_CAcquiredODTransform aqCopy;
  923.                 
  924.             if (transform == NULL)
  925.                 aqCopy = transform = aqTransform->Copy(ev);
  926.             
  927.             FW_CODFrameFacetIterator ite(ev, proxyFrame->GetFrame(ev));        
  928.             for (ODFacet* odFacet = ite.First(ev); ite.IsNotComplete(ev); odFacet = ite.Next(ev))
  929.             {
  930.                 odFacet->ChangeGeometry(ev, NULL, transform, NULL);
  931.             }    
  932.                             
  933.             transform = NULL;
  934.         }
  935.     }
  936. }
  937.  
  938. //----------------------------------------------------------------------------------------
  939. //    FW_MProxy::ReleaseAll
  940. //----------------------------------------------------------------------------------------
  941.  
  942. void FW_MProxy::ReleaseAll(Environment* ev)
  943. {
  944.     FW_CProxyProxyFrameIterator ite(this);
  945.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  946.     {
  947.         proxyFrame->Release(ev);
  948.     }
  949. }
  950.  
  951. //----------------------------------------------------------------------------------------
  952. //    FW_MProxy::ChangeFrameShapes
  953. //----------------------------------------------------------------------------------------
  954.  
  955. void FW_MProxy::ChangeFrameShapes(Environment* ev, FW_Fixed width, FW_Fixed height)
  956. {
  957.     FW_CProxyProxyFrameIterator ite(this);
  958.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  959.     {
  960.         if (proxyFrame->IsFrameInMemory(ev))
  961.         {
  962.             FW_CAcquiredODShape newFrameShape = ::FW_NewODShape(ev, FW_CRect(FW_kZeroPoint, width, height));
  963.             proxyFrame->GetFrame(ev)->ChangeFrameShape(ev, newFrameShape, NULL);
  964.         }
  965.     }
  966. }
  967.  
  968. //----------------------------------------------------------------------------------------
  969. //    FW_MProxy::ChangeFrameShapes
  970. //----------------------------------------------------------------------------------------
  971.  
  972. void FW_MProxy::ChangeFrameShapes(Environment* ev, ODShape* newShape)
  973. {
  974.     FW_ASSERT(newShape != NULL);
  975.     
  976.     FW_CProxyProxyFrameIterator ite(this);
  977.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  978.     {
  979.         if (proxyFrame->IsFrameInMemory(ev))
  980.         {
  981.             FW_CAcquiredODShape aqShape(newShape->Copy(ev));
  982.             proxyFrame->GetFrame(ev)->ChangeFrameShape(ev, aqShape, NULL);
  983.         }
  984.     }
  985. }
  986.  
  987. //----------------------------------------------------------------------------------------
  988. //    FW_MProxy::PrivAddProxyFrame
  989. //----------------------------------------------------------------------------------------
  990.  
  991. void FW_MProxy::PrivAddProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  992. {        
  993. #ifdef FW_DEBUG
  994.     FW_CProxyProxyFrameIterator ite(this);
  995.     for (FW_CProxyFrame* pf = ite.First(); ite.IsNotComplete(); pf = ite.Next())
  996.     {
  997.         if (pf == proxyFrame)
  998.             FW_DEBUG_MESSAGE("FW_MProxy::PrivAddProxyFrame ProxyFrame already attached");
  999.     }
  1000. #else
  1001. FW_UNUSED(ev);
  1002. #endif
  1003.  
  1004.     FW_ASSERT(proxyFrame->GetProxy(ev) == this);
  1005.     
  1006.     fProxyFrames->AddLast(proxyFrame);
  1007.     
  1008.     ProxyFrameAdded(ev, proxyFrame);
  1009. }
  1010.  
  1011. //----------------------------------------------------------------------------------------
  1012. //    FW_MProxy::AdjustBorderShape
  1013. //----------------------------------------------------------------------------------------
  1014. //    Shape is content coordinate and already intersected with the content shape. ATTENTION
  1015. //    shape can be NULL
  1016.  
  1017. void FW_MProxy::AdjustBorderShape(Environment* ev, 
  1018.                                     FW_CEmbeddingFrame* embeddingFrame, 
  1019.                                     ODFacet* embeddedFacet, 
  1020.                                     ODShape* shape)
  1021. {
  1022. FW_UNUSED(ev);
  1023. FW_UNUSED(embeddingFrame);
  1024. FW_UNUSED(embeddedFacet);
  1025. FW_UNUSED(shape);
  1026. }
  1027.  
  1028. //----------------------------------------------------------------------------------------
  1029. //    FW_MProxy::ChangeLinkStatus
  1030. //----------------------------------------------------------------------------------------
  1031.  
  1032. void FW_MProxy::ChangeLinkStatus(Environment* ev, ODLinkStatus linkStatus)
  1033. {
  1034.     FW_CProxyProxyFrameIterator iter(this);
  1035.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  1036.     {
  1037.         // Does not force frame to be internalized.
  1038.         proxyFrame->ChangeLinkStatus(ev, linkStatus);
  1039.     }
  1040. }
  1041.  
  1042. //----------------------------------------------------------------------------------------
  1043. //    FW_MProxy::CreateFacet
  1044. //----------------------------------------------------------------------------------------
  1045. //    CreateFacet should be called from your implementation of FW_MProxy::CreateFacets
  1046.  
  1047. ODFacet* FW_MProxy::CreateFacet(Environment* ev,
  1048.                                 ODFacet*        containingFacet,
  1049.                                 ODFrame*        embeddedFrame,
  1050.                                 ODShape*        clipShape,
  1051.                                 ODTransform*    externalTransform,
  1052.                                 ODCanvas*        canvas,
  1053.                                 ODCanvas*        biasCanvas,
  1054.                                 ODFacet*        siblingFacet,
  1055.                                 ODFramePosition    position)
  1056. {
  1057.     // I need to increment the number of facet before calling CreateEmbeddedFacet because
  1058.     //    if I am called back during CreateEmbeddedFacet the count won't be right
  1059.     
  1060.     fEmbeddedFacetCount++;
  1061.     ODFacet* newFacet = NULL;
  1062.     FW_VOLATILE(newFacet);
  1063.     
  1064.     FW_TRY
  1065.     {
  1066.         newFacet = containingFacet->CreateEmbeddedFacet(ev, 
  1067.                                                         embeddedFrame, 
  1068.                                                         clipShape, 
  1069.                                                         externalTransform,
  1070.                                                         canvas,
  1071.                                                         biasCanvas,
  1072.                                                         siblingFacet,
  1073.                                                         position);
  1074.         newFacet->SetSelected(ev, GetSelectState(ev));
  1075.         
  1076.         FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, embeddedFrame->GetID(ev));
  1077.         newFacet->ChangeHighlight(ev, proxyFrame->GetHighlight(ev));
  1078.     }
  1079.     FW_CATCH_BEGIN
  1080.     FW_CATCH_EVERYTHING () 
  1081.     {
  1082.         delete newFacet;    // in case SetSelected fails
  1083.         fEmbeddedFacetCount--;
  1084.         
  1085.         FW_THROW_SAME ();
  1086.     }
  1087.     FW_CATCH_END
  1088.     
  1089.     return newFacet;
  1090. }
  1091.  
  1092. //----------------------------------------------------------------------------------------
  1093. //    FW_MProxy::Reveal
  1094. //----------------------------------------------------------------------------------------
  1095. //    Attention: revealShape is in embeddingFrame frame coordinates
  1096.  
  1097. FW_Boolean FW_MProxy::Reveal(Environment *ev, 
  1098.                             FW_CEmbeddingFrame* embeddingFrame,
  1099.                             ODFrame* embeddedFrame, 
  1100.                             ODShape* revealShape)
  1101. {
  1102. FW_UNUSED(ev);
  1103. FW_UNUSED(embeddingFrame);
  1104. FW_UNUSED(embeddedFrame);
  1105. FW_UNUSED(revealShape);
  1106.  
  1107.     return FALSE;
  1108. }
  1109.  
  1110. //----------------------------------------------------------------------------------------
  1111. //    FW_MProxy::PrivNewProxyFrame
  1112. //----------------------------------------------------------------------------------------
  1113.  
  1114. FW_CProxyFrame* FW_MProxy::PrivNewProxyFrame(Environment* ev, 
  1115.                                             FW_CEmbeddingPart* part,
  1116.                                             ODStorageUnitView* suView)
  1117. {
  1118.     FW_CProxyFrame* proxyFrame = new FW_CProxyFrame(ev, this, part);
  1119.  
  1120.     FW_TRY
  1121.     {    
  1122.         if (proxyFrame->InternalizeProxyFrame(ev, suView, NULL))
  1123.             this->PrivAddProxyFrame(ev, proxyFrame);
  1124.         else
  1125.         {
  1126.             delete proxyFrame;
  1127.             proxyFrame = NULL;
  1128.         }
  1129.     }
  1130.     FW_CATCH_BEGIN 
  1131.     FW_CATCH_EVERYTHING () 
  1132.     {
  1133.         delete proxyFrame;
  1134.         FW_THROW_SAME ();
  1135.     }
  1136.     FW_CATCH_END
  1137.     
  1138.     return proxyFrame;
  1139. }
  1140.  
  1141. //----------------------------------------------------------------------------------------
  1142. //    FW_MProxy::PrivNewProxyFrame
  1143. //----------------------------------------------------------------------------------------
  1144.  
  1145. FW_CProxyFrame* FW_MProxy::PrivNewProxyFrame(Environment* ev, 
  1146.                                             FW_CEmbeddingPart* part, 
  1147.                                             FW_CEmbeddingFrame* containingFrame, 
  1148.                                             ODFrame* embeddedFrame,
  1149.                                             FW_Boolean saveLimboState)
  1150. {
  1151.     FW_Boolean wasInLimbo = saveLimboState ? embeddedFrame->IsInLimbo(ev) : FALSE;
  1152.     FW_CProxyFrame* proxyFrame = new FW_CProxyFrame(ev, this, part, containingFrame, embeddedFrame, wasInLimbo);
  1153.     
  1154.     // ----- Add it to the proxy frame list
  1155.     this->PrivAddProxyFrame(ev, proxyFrame);
  1156.     
  1157.     return proxyFrame;
  1158. }
  1159.  
  1160.  
  1161. //----------------------------------------------------------------------------------------
  1162. //    FW_MProxy::GetEmbeddedPartName
  1163. //----------------------------------------------------------------------------------------
  1164.  
  1165. void FW_MProxy::GetEmbeddedPartName(Environment* ev, FW_CString& name) const
  1166. {
  1167.     name = "";
  1168.     
  1169.     ODIText* newName = NULL;
  1170.     FW_VOLATILE(newName);
  1171.     
  1172.     FW_TRY
  1173.     {    
  1174.         FW_CAcquiredODPart embeddedPart = AcquireEmbeddedPart(ev);
  1175.         newName = ::ODGetITextProp(ev, embeddedPart->GetStorageUnit(ev), kODPropName, kODMacIText, kODNULL);
  1176.     }
  1177.     FW_CATCH_BEGIN 
  1178.     FW_CATCH_EVERYTHING () 
  1179.     {
  1180.         // exception consumed
  1181.     }
  1182.     FW_CATCH_END
  1183.     
  1184.     if (newName != NULL)
  1185.     {
  1186.         name.ReplaceAll(newName);
  1187.         ::DisposeIText(newName);
  1188.     }
  1189. }
  1190.  
  1191. //----------------------------------------------------------------------------------------
  1192. //    FW_MProxy::OpenInWindow
  1193. //----------------------------------------------------------------------------------------
  1194. //    Called by FW_CEmbeddingFrame::OpenSelection. Override it if for any reason you don't
  1195. //    want to open all selected proxy (see ODFTable)
  1196.  
  1197. void FW_MProxy::OpenInWindow(Environment* ev, FW_CProxyFrame* proxyFrame)
  1198. {
  1199.     ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  1200.     FW_CAcquiredODPart aqODPart = embeddedFrame->AcquirePart(ev);
  1201.     aqODPart->Open(ev, embeddedFrame);    
  1202. }
  1203.  
  1204. //---------------------------------------------------------------------------------------
  1205. //    FW_MProxy::Purge
  1206. //---------------------------------------------------------------------------------------
  1207.  
  1208. ODSize FW_MProxy::Purge(Environment *ev)
  1209. {
  1210.     ODSize freedSize = 0;
  1211.     
  1212.     // ----- Try purging all purgeable embedded frames -----
  1213.     FW_CProxyProxyFrameIterator ite(this);
  1214.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  1215.     {
  1216.         freedSize += proxyFrame->Purge(ev);
  1217.     }
  1218.     
  1219.     return freedSize;
  1220. }
  1221.  
  1222. //---------------------------------------------------------------------------------------
  1223. //    FW_MProxy::SetPurgeable
  1224. //---------------------------------------------------------------------------------------
  1225.  
  1226. void FW_MProxy::SetPurgeable(Environment *ev, FW_CEmbeddingFrame* frame, FW_Boolean purgeable)
  1227. {
  1228.     FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, frame);
  1229.     FW_ASSERT(proxyFrame);
  1230.     proxyFrame->SetPurgeable(ev, purgeable);
  1231. }
  1232.  
  1233. //---------------------------------------------------------------------------------------
  1234. //    FW_MProxy::NeedFacets
  1235. //---------------------------------------------------------------------------------------
  1236.  
  1237. FW_Boolean FW_MProxy::NeedFacets(Environment *ev, FW_CEmbeddingFrame* embeddingFrame) const
  1238. {
  1239. FW_UNUSED(ev);
  1240. FW_UNUSED(embeddingFrame);
  1241.  
  1242.     return TRUE;
  1243. }
  1244.