home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWPart / Sources / FWProxy.cpp < prev    next >
Encoding:
Text File  |  1996-04-25  |  29.7 KB  |  981 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FRProxy.cpp
  4. //    Release Version:    $ ODF 1 $
  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. #if defined(__MWERKS__) && GENERATING68K
  125. // A hack to work around a bug
  126. #pragma import list somGetGlobalEnvironment
  127. #endif
  128.  
  129. //========================================================================================
  130. //    Runtime Info
  131. //========================================================================================
  132.  
  133. #ifdef FW_BUILD_MAC
  134. #pragma segment fw_embedding
  135. #endif
  136.  
  137.  
  138. //========================================================================================
  139. //    Constant
  140. //========================================================================================
  141.  
  142. typedef long FW_ProxyVersion;
  143. const FW_ProxyVersion FW_kProxyVersion = 0;
  144.  
  145. //========================================================================================
  146. //    Template Instantiations
  147. //========================================================================================
  148.  
  149. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollectionIterator, FW_MProxy)
  150. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollection, FW_MProxy)
  151.  
  152. #ifdef FW_USE_TEMPLATE_PRAGMAS
  153.  
  154. #pragma template_access public
  155. #pragma template FW_TOrderedCollection<FW_MProxy>
  156. #pragma template FW_TOrderedCollectionIterator<FW_MProxy>
  157.  
  158. #endif
  159.  
  160. //========================================================================================
  161. //    class FW_MProxy
  162. //========================================================================================
  163.  
  164. //----------------------------------------------------------------------------------------
  165. //    FW_MProxy::FW_MProxy
  166. //----------------------------------------------------------------------------------------
  167.  
  168. FW_MProxy::FW_MProxy(Environment* ev, 
  169.                     FW_CEmbeddingPart* part, 
  170.                     FW_CPresentation* presentation,
  171.                     FW_Boolean shown) :
  172.     fPart(part),
  173.     fPresentation(presentation),
  174.     fProxyFrames(NULL),
  175.     fClonedFrameID(kODNULLID),
  176.     fEmbeddedFacetCount(0),
  177.     fSelected(FALSE),
  178.     fShown(shown),
  179.     fDetached(TRUE),
  180.     fFrameGroup(0),
  181.     fSequenceNumber(0),
  182.     fDragging(FALSE)
  183. {
  184.     FW_ASSERT(fPart != NULL);
  185.     FW_ASSERT(fPresentation != NULL);
  186.     
  187.     fPart->PrivAddProxy(ev, this);
  188.     fDetached = FALSE;
  189.     
  190.     fProxyFrames = FW_NEW(FW_TOrderedCollection<FW_CProxyFrame>, ());
  191. }
  192.  
  193. //----------------------------------------------------------------------------------------
  194. //    FW_MProxy::~FW_MProxy
  195. //----------------------------------------------------------------------------------------
  196.  
  197. FW_MProxy::~FW_MProxy()
  198. {
  199.     Environment* ev = somGetGlobalEnvironment();
  200.  
  201.     if (!fDetached)
  202.         fPart->PrivRemoveProxy(ev, this);
  203.     
  204.     if (fProxyFrames)
  205.     {        
  206.         FW_CProxyFrame* proxyFrame;
  207.         while ((proxyFrame = fProxyFrames->First()) != NULL)
  208.         {
  209.             FW_ASSERT(proxyFrame->GetProxy(ev) == this);
  210.             PrivDeleteProxyFrame(ev, proxyFrame);
  211.         }
  212.             
  213.         delete fProxyFrames;
  214.         fProxyFrames = NULL;
  215.     }
  216. }
  217.  
  218. //----------------------------------------------------------------------------------------
  219. //     FW_MProxy::UsedShapeChanged
  220. //----------------------------------------------------------------------------------------
  221. //    The used shape of one of my embedded frame has changed
  222.  
  223. void FW_MProxy::UsedShapeChanged(Environment *ev, 
  224.                                     FW_CEmbeddingFrame* embeddingFrame,
  225.                                     ODFrame* odEmbeddedFrame)
  226. {
  227. FW_UNUSED(ev);
  228. FW_UNUSED(embeddingFrame);
  229. FW_UNUSED(odEmbeddedFrame);
  230. }
  231.  
  232. //----------------------------------------------------------------------------------------
  233. //     FW_MProxy::PrivSetFrameGroup
  234. //----------------------------------------------------------------------------------------
  235.  
  236. void FW_MProxy::PrivSetFrameGroup(Environment *ev, ODID frameGroup)
  237. {
  238.     fFrameGroup = frameGroup;
  239.     
  240.     FW_CProxyProxyFrameIterator ite(this);
  241.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  242.     {
  243.         proxyFrame->PrivSetFrameGroup(ev, frameGroup);
  244.     }
  245. }
  246.  
  247. //----------------------------------------------------------------------------------------
  248. //     FW_MProxy::ChangeSequenceNumber
  249. //----------------------------------------------------------------------------------------
  250.  
  251. void FW_MProxy::ChangeSequenceNumber(Environment *ev, ODID sequenceNumber)
  252. {
  253.     fSequenceNumber = sequenceNumber;
  254.     
  255.     FW_CProxyProxyFrameIterator ite(this);
  256.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  257.     {
  258.         proxyFrame->PrivChangeSequenceNumber(ev, fSequenceNumber);
  259.     }
  260. }
  261.  
  262. //----------------------------------------------------------------------------------------
  263. //    FW_MProxy::FrameShapeRequested
  264. //----------------------------------------------------------------------------------------
  265.  
  266. ODShape* FW_MProxy::FrameShapeRequested(Environment* ev, 
  267.                                         FW_CEmbeddingFrame* frame,
  268.                                         ODFrame* odEmbeddedFrame, 
  269.                                         ODShape* requestedFrameShape)
  270. {
  271. FW_UNUSED(frame);
  272. FW_UNUSED(odEmbeddedFrame);
  273.  
  274.     // ----- Simply grant the requested frame
  275.     requestedFrameShape->Acquire(ev);
  276.     return requestedFrameShape;
  277. }
  278.  
  279. //----------------------------------------------------------------------------------------
  280. //    FW_MProxy::AttachEmbeddedFrames
  281. //----------------------------------------------------------------------------------------
  282.  
  283. void FW_MProxy::AttachEmbeddedFrames(Environment *ev)
  284. {
  285.     FW_CProxyProxyFrameIterator ite(this);
  286.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  287.     {
  288.         proxyFrame->PrivAttach(ev);
  289.     }
  290.     
  291.     fPart->PrivAddProxy(ev, this);
  292.     fDetached = FALSE;
  293. }
  294.  
  295. //----------------------------------------------------------------------------------------
  296. //    FW_MProxy::DetachEmbeddedFrames
  297. //----------------------------------------------------------------------------------------
  298. //    At the end proxyFrames are only owned by the proxy
  299.  
  300. void FW_MProxy::DetachEmbeddedFrames(Environment *ev)
  301. {
  302.     FW_CProxyProxyFrameIterator ite(this);
  303.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  304.     {
  305.         proxyFrame->PrivDetach(ev);
  306.     }
  307.  
  308.     fPart->PrivRemoveProxy(ev, this);
  309.     fDetached = TRUE;
  310. }
  311.  
  312. //----------------------------------------------------------------------------------------
  313. //    FW_MProxy::RemoveEmbeddedFrames
  314. //----------------------------------------------------------------------------------------
  315. //    At the end this proxy doesn't have any proxyframes
  316. //    Attention: Use DetachEmbeddedFrames if you are supporting Undo
  317.  
  318. void FW_MProxy::RemoveEmbeddedFrames(Environment *ev)
  319. {
  320.     // ----- First detach them
  321.     DetachEmbeddedFrames(ev);
  322.     
  323.     // ----- Remove all the embedded frames -----
  324.     FW_CProxyFrame* proxyFrame ;
  325.     while ((proxyFrame = fProxyFrames->First()) != NULL)
  326.         PrivDeleteProxyFrame(ev, proxyFrame);
  327. }
  328.  
  329. //----------------------------------------------------------------------------------------
  330. //    FW_MProxy::HideShow
  331. //----------------------------------------------------------------------------------------
  332.  
  333. void FW_MProxy::HideShow(Environment *ev, FW_Boolean state)
  334. {
  335.     if (fShown != state)
  336.     {
  337.         fShown = state;
  338.  
  339.         FW_CProxyProxyFrameIterator ite(this);
  340.         for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  341.         {
  342.             state ? proxyFrame->CreateAllFacets(ev) : proxyFrame->RemoveAllFacets(ev);
  343.         }    
  344.         
  345.     }
  346. }
  347.  
  348. //----------------------------------------------------------------------------------------
  349. //    FW_MProxy::PrivDeleteProxyFrame
  350. //----------------------------------------------------------------------------------------
  351.  
  352. void FW_MProxy::PrivDeleteProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  353. {    
  354. FW_UNUSED(ev);
  355.     fProxyFrames->Remove(proxyFrame);
  356.     delete proxyFrame;
  357. }
  358.  
  359. //----------------------------------------------------------------------------------------
  360. //    FW_MProxy::PrivGetProxyFrame
  361. //----------------------------------------------------------------------------------------
  362.  
  363. FW_CProxyFrame* FW_MProxy::PrivGetProxyFrame(Environment* ev, ODStorageUnitID frameID) const
  364. {
  365.     FW_TOrderedCollectionIterator<FW_CProxyFrame> ite(fProxyFrames);
  366.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  367.     {
  368.         if (frameID == proxyFrame->GetFrameID(ev))
  369.             return proxyFrame;
  370.     }
  371.     
  372.     return NULL;
  373. }
  374.  
  375. //----------------------------------------------------------------------------------------
  376. //    FW_MProxy::PrivContainerIDToProxyFrame
  377. //----------------------------------------------------------------------------------------
  378. //    Returns a proxyframe knowing is container frame ID
  379.  
  380. FW_CProxyFrame* FW_MProxy::PrivContainerIDToProxyFrame(Environment* ev, ODStorageUnitID containerID) const
  381. {
  382.     FW_TOrderedCollectionIterator<FW_CProxyFrame> ite(fProxyFrames);
  383.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  384.     {
  385.         if (proxyFrame->IsAttached(ev) && containerID == proxyFrame->GetContainingFrameID(ev))
  386.             return proxyFrame;
  387.     }
  388.     
  389.     return NULL;
  390. }
  391.  
  392. //----------------------------------------------------------------------------------------
  393. //    FW_MProxy::GetEmbeddedFacetUnderMouse
  394. //----------------------------------------------------------------------------------------
  395. // 'mouse' in Frame coordinate system
  396.  
  397. ODFacet* FW_MProxy::GetEmbeddedFacetUnderMouse(Environment* ev, ODFacet* embeddingFacet, const FW_CPoint& mouse) const
  398. {    
  399.     ODPoint odMouse = mouse;
  400.  
  401.     FW_CEmbeddedODFacetsIterator ite(ev, this, embeddingFacet, kODFrontToBack);
  402.     for (ODFacet* odFacet = ite.First(ev); ite.IsNotComplete(ev); odFacet = ite.Next(ev))
  403.     {
  404.         if (odFacet->ContainsPoint(ev, &odMouse, NULL))
  405.             return odFacet;
  406.     }
  407.     
  408.     return NULL;
  409. }
  410.  
  411. //----------------------------------------------------------------------------------------
  412. //    FW_MProxy::SetSelectState
  413. //----------------------------------------------------------------------------------------
  414.  
  415. void FW_MProxy::SetSelectState(Environment* ev, FW_Boolean state)
  416. {
  417.     fSelected = state;
  418.     
  419.     // ----- Set the selected flag in facet -----
  420.     FW_CProxyEmbeddedFrameIterator ite(ev, this);
  421.     for (ODFrame* odEmbeddedFrame = ite.First(ev); ite.IsNotComplete(ev); odEmbeddedFrame = ite.Next(ev))
  422.     {
  423.         FW_CODFrameFacetIterator ite2(ev, odEmbeddedFrame);
  424.         for (ODFacet* facet = ite2.First(ev); ite2.IsNotComplete(ev); facet = ite2.Next(ev))
  425.             facet->SetSelected(ev, state);
  426.     }
  427. }
  428.  
  429. //----------------------------------------------------------------------------------------
  430. //    FW_MProxy::ChangeHighlight
  431. //----------------------------------------------------------------------------------------
  432. //    if embeddingFrame is NULL change the
  433. void FW_MProxy::ChangeHighlight(Environment* ev, ODHighlight highlight, FW_CEmbeddingFrame* embeddingFrame)
  434. {
  435.     FW_CProxyEmbeddedFrameIterator ite(ev, this);
  436.     for (ODFrame* odEmbeddedFrame = ite.First(ev); ite.IsNotComplete(ev); odEmbeddedFrame = ite.Next(ev))
  437.     {    
  438.         FW_Boolean doIt = (embeddingFrame == NULL);
  439.         if (!doIt)
  440.         {
  441.             FW_CAcquiredODFrame containingFrame = odEmbeddedFrame->AcquireContainingFrame(ev);
  442.             doIt = (containingFrame == embeddingFrame->GetODFrame(ev));
  443.         }
  444.         
  445.         if (doIt)
  446.         {
  447.             FW_CODFrameFacetIterator ite2(ev, odEmbeddedFrame);
  448.             for (ODFacet* facet = ite2.First(ev); ite2.IsNotComplete(ev); facet = ite2.Next(ev))
  449.                 facet->ChangeHighlight(ev, highlight);
  450.         }
  451.     }
  452. }
  453.  
  454. //----------------------------------------------------------------------------------------
  455. //    FW_MProxy::AcquireEmbeddedPart
  456. //----------------------------------------------------------------------------------------
  457.  
  458. ODPart* FW_MProxy::AcquireEmbeddedPart(Environment* ev) const
  459. {
  460.     // Should not be called when empty because proxys are automatically deleted
  461.     FW_ASSERT(fProxyFrames->Count() != 0);
  462.     
  463.     FW_CProxyFrame* proxyFrame = fProxyFrames->First();
  464.     
  465.     return proxyFrame->GetFrame(ev)->AcquirePart(ev);
  466. }
  467.  
  468. //----------------------------------------------------------------------------------------
  469. //    FW_MProxy::GetProxyFrame
  470. //----------------------------------------------------------------------------------------
  471. //    returns a proxyframe knowing its embedding frame
  472.  
  473. FW_CProxyFrame* FW_MProxy::GetProxyFrame(Environment* ev, FW_CEmbeddingFrame* embeddingFrame) const
  474. {
  475.     FW_CProxyProxyFrameIterator ite(this);
  476.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  477.     {
  478.         if (proxyFrame->GetContainingFrame(ev) == embeddingFrame)
  479.             return proxyFrame;
  480.     }
  481.     return NULL;
  482. }
  483.  
  484. //----------------------------------------------------------------------------------------
  485. //    FW_MProxy::AcquireEmbeddedFrame
  486. //----------------------------------------------------------------------------------------
  487. //    returns the embedded frame of this proxy (embedded) frame
  488.  
  489. ODFrame* FW_MProxy::AcquireEmbeddedFrame(Environment* ev, FW_CEmbeddingFrame* embeddingFrame) const
  490. {
  491.     ODFrame* embeddedFrame = NULL;
  492.     FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, embeddingFrame);
  493.     if (proxyFrame)
  494.     {
  495.         embeddedFrame = proxyFrame->GetFrame(ev);
  496.         embeddedFrame->Acquire(ev);
  497.     }
  498.     
  499.     return embeddedFrame;
  500. }
  501.  
  502. //----------------------------------------------------------------------------------------
  503. //    FW_MProxy::IsEmbeddedFrame
  504. //----------------------------------------------------------------------------------------
  505. //    returns true if the embeddedframe belongs to this proxy
  506.  
  507. FW_Boolean FW_MProxy::IsEmbeddedFrame(Environment* ev, ODFrame* embeddedFrame) const
  508. {
  509.     ODID frameID = embeddedFrame->GetID(ev);
  510.     FW_CProxyProxyFrameIterator ite(this);
  511.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  512.     {
  513.         if (proxyFrame->GetFrameID(ev) == frameID)
  514.             return TRUE;
  515.     }
  516.     
  517.     return FALSE;
  518. }
  519.  
  520. //----------------------------------------------------------------------------------------
  521. //    FW_MProxy::Externalize
  522. //----------------------------------------------------------------------------------------
  523.  
  524. void FW_MProxy::Externalize(Environment* ev, 
  525.                             ODStorageUnitView* destinationSUView, 
  526.                             FW_CCloneInfo* cloneInfo)
  527. {
  528.     // ----- Write first a version number -----
  529.     FW_CByteArray byteArray(&FW_kProxyVersion, sizeof(FW_ProxyVersion));
  530.     destinationSUView->SetValue(ev, byteArray);
  531.  
  532.     // ----- Write out the hide/show state -----
  533.     byteArray.Set(&fShown, sizeof(fShown));
  534.     destinationSUView->SetValue(ev, byteArray);    
  535.     
  536.     // ----- Write the SequenceNumber -----
  537.     byteArray.Set(&fSequenceNumber, sizeof(fSequenceNumber));
  538.     destinationSUView->SetValue(ev, byteArray);
  539.  
  540.     // ----- Write the frameGroup -----
  541.     byteArray.Set(&fFrameGroup, sizeof(fFrameGroup));
  542.     destinationSUView->SetValue(ev, byteArray);
  543.  
  544.     FW_CFrame* scopeFrame = (cloneInfo != NULL) ? cloneInfo->GetScopeFrame(ev) : NULL;
  545.     
  546.     // ----- Write the nymber of proxyframes -----
  547.     unsigned long count = 0;
  548.     if (scopeFrame != NULL)
  549.         count = 1;
  550.     else
  551.     {
  552.         // Count only the proxyFrame with a containing frame persistent
  553.         FW_CProxyProxyFrameIterator ite(this);
  554.         for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  555.         {
  556.             if (proxyFrame->GetContainingFrame(ev)->IsPersistent(ev))
  557.                 count++;
  558.         }
  559.     }
  560.     
  561.     FW_CByteArray byteArray2(&count, sizeof(unsigned long));
  562.     destinationSUView->SetValue(ev, byteArray2);
  563.     
  564.     // ----- Clone or write the proxyframe(s) -----
  565.     if (scopeFrame != NULL)
  566.     {    
  567. #ifdef FW_DEBUG
  568.         FW_CEmbeddingFrame* scopeEmbeddingFrame = FW_DYNAMIC_CAST(FW_CEmbeddingFrame, scopeFrame);
  569.         FW_ASSERT(scopeEmbeddingFrame);
  570.         FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, scopeEmbeddingFrame);
  571. #else
  572.         FW_CProxyFrame* proxyFrame = GetProxyFrame(ev, (FW_CEmbeddingFrame*)scopeFrame);
  573. #endif
  574.         FW_ASSERT(proxyFrame != NULL);
  575.         
  576.         FW_Boolean result = proxyFrame->ExternalizeProxyFrame(ev, destinationSUView, cloneInfo);
  577.         FW_ASSERT(result = TRUE);
  578.     }
  579.     else
  580.     {        
  581.         // ----- Externalize each persistent proxy Frame -----
  582.         FW_CProxyProxyFrameIterator ite2(this);
  583.         for (FW_CProxyFrame* proxyFrame = ite2.First(); ite2.IsNotComplete(); proxyFrame = ite2.Next())
  584.         {
  585.             FW_Boolean result = proxyFrame->ExternalizeProxyFrame(ev, destinationSUView, cloneInfo);
  586.             FW_ASSERT(result = TRUE);
  587.         }
  588.     }
  589. }
  590.  
  591. //----------------------------------------------------------------------------------------
  592. //    FW_MProxy::PrivPostClone
  593. //----------------------------------------------------------------------------------------
  594.  
  595. void FW_MProxy::PrivPostClone(Environment* ev, FW_CCloneInfo* cloneInfo) 
  596. {
  597.     if (fClonedFrameID == kODNULLID)
  598.         return;
  599.     
  600.     FW_CFrame* scopeFrame = cloneInfo->GetScopeFrame(ev);
  601.     
  602. //    ODDraft* myDraft = GetPart(ev)->GetDraft(ev);
  603.             
  604.     // ----- Get the new frame from my draft -----
  605. //    FW_CAcquiredODFrame aqODEmbeddedFrame = myDraft->AcquireFrame(ev, fClonedFrameID);
  606.     FW_CAcquiredODFrame aqODEmbeddedFrame = cloneInfo->GetToDraft(ev)->AcquireFrame(ev, fClonedFrameID);
  607.     FW_ASSERT(aqODEmbeddedFrame != NULL);
  608.     
  609.     // ----- Set the containing frame
  610.     aqODEmbeddedFrame->SetContainingFrame(ev, scopeFrame->GetODFrame(ev));
  611.  
  612.     // ----- Now we can embed it -----    
  613.     FW_CAcquiredODShape aqFrameShape = aqODEmbeddedFrame->AcquireFrameShape(ev, NULL);
  614.     FW_CAcquiredODPart aqPart = aqODEmbeddedFrame->AcquirePart(ev);
  615.     
  616.     fPresentation->Embed(ev, 
  617.                             aqPart,
  618.                             aqODEmbeddedFrame,
  619.                             (aqODEmbeddedFrame->GetStorageUnit(ev) != NULL) ? kODFrameObject : kODNonPersistentFrameObject,                     
  620.                             this,
  621.                             aqFrameShape,
  622.                             aqODEmbeddedFrame->GetViewType(ev),
  623.                             aqODEmbeddedFrame->GetPresentation(ev),
  624.                             aqODEmbeddedFrame->GetFrameGroup(ev),
  625.                             aqODEmbeddedFrame->IsOverlaid(ev),
  626.                             aqODEmbeddedFrame->IsSubframe(ev));
  627.  
  628.     // ----- Cloning done -----
  629.     fClonedFrameID = kODNULLID;
  630. }
  631.  
  632. //----------------------------------------------------------------------------------------
  633. //    FW_MProxy::Internalize
  634. //----------------------------------------------------------------------------------------
  635.  
  636. void FW_MProxy::Internalize(Environment* ev, 
  637.                             ODStorageUnitView* sourceSUView,
  638.                             FW_CCloneInfo *cloneInfo)
  639. {
  640.     FW_CByteArray byteArray;
  641.  
  642.     // ----- Read first the version number -----
  643.     FW_ProxyVersion version;
  644.     sourceSUView->GetValue(ev, sizeof(FW_ProxyVersion), byteArray);
  645.     byteArray.CopyBuffer(&version, sizeof(FW_ProxyVersion));
  646.     FW_ASSERT(version == FW_kProxyVersion);
  647.  
  648.     // ----- Read in the hide/show state -----
  649.     sourceSUView->GetValue(ev, sizeof(fShown), byteArray);
  650.     byteArray.CopyBuffer(&fShown, sizeof(fShown));
  651.  
  652.     // ----- Read in the Sequence Number -----
  653.     sourceSUView->GetValue(ev, sizeof(fSequenceNumber), byteArray);
  654.     byteArray.CopyBuffer(&fSequenceNumber, sizeof(fSequenceNumber));
  655.  
  656.     // ----- Read in the frameGroup -----
  657.     sourceSUView->GetValue(ev, sizeof(fFrameGroup), byteArray);
  658.     byteArray.CopyBuffer(&fFrameGroup, sizeof(fFrameGroup));
  659.     if (fFrameGroup != 0)
  660.         fPart->PrivSetNextFrameGroup(ev, fFrameGroup);
  661.     
  662.     // ----- Read the number of proxyframe -----
  663.     unsigned long count;
  664.     
  665.     sourceSUView->GetValue(ev, sizeof(unsigned long), byteArray);
  666.     byteArray.CopyBuffer(&count, sizeof(unsigned long));
  667.  
  668.     // ----- Clone or Read in the proxyframe(s) -----
  669.     if (cloneInfo != NULL)
  670.     {
  671.         FW_ASSERT(cloneInfo->GetScopeFrame(ev));
  672.         
  673.         if (cloneInfo->fClonedProxyList == NULL)
  674.             cloneInfo->fClonedProxyList = FW_NEW(FW_TOrderedCollection<FW_MProxy>, ());
  675.         
  676.         cloneInfo->fClonedProxyList->AddLast(this);
  677.             
  678.         FW_ASSERT(count == 1);        // if clone we should have only one embedded frame
  679.     
  680.         ODStorageUnitRef aSURef;
  681.         sourceSUView->GetValue(ev, sizeof(ODStorageUnitRef), byteArray);
  682.         byteArray.CopyBuffer(&aSURef, sizeof(ODStorageUnitRef));
  683.         
  684.         FW_ASSERT(sourceSUView->IsValidStorageUnitRef(ev, aSURef));
  685.     
  686.         ODStorageUnitID fromFrameID = sourceSUView->GetIDFromStorageUnitRef(ev, aSURef);
  687.         fClonedFrameID = cloneInfo->Clone(ev, fromFrameID, 0, 0);
  688.     }
  689.     else
  690.     {
  691.         for (unsigned long i = 0; i<count; i++)
  692.             this->PrivNewProxyFrame(ev, fPart, sourceSUView);
  693.     }
  694. }
  695.  
  696. //----------------------------------------------------------------------------------------
  697. //    FW_MProxy::SetEmbeddedFramesViewType
  698. //----------------------------------------------------------------------------------------
  699. //    ATTENTION: I am forcing the embedded frame to be in memory
  700.  
  701. void FW_MProxy::SetEmbeddedFramesViewType(Environment* ev, ODTypeToken viewType)
  702. {
  703.     FW_CProxyProxyFrameIterator ite(this);
  704.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  705.     {
  706.         proxyFrame->GetFrame(ev)->SetViewType(ev, viewType);
  707.     }
  708. }
  709.  
  710. //----------------------------------------------------------------------------------------
  711. //    FW_MProxy::ChangeExternalTransforms
  712. //----------------------------------------------------------------------------------------
  713.  
  714. void FW_MProxy::ChangeExternalTransforms(Environment* ev, FW_Fixed x, FW_Fixed y)
  715. {
  716.     if (fEmbeddedFacetCount != 0)
  717.     {
  718.         FW_CAcquiredODTransform transform = ::FW_NewODTransform(ev, FW_CPoint(x, y));
  719.         ChangeExternalTransforms(ev, transform);
  720.     }
  721. }
  722.  
  723. //----------------------------------------------------------------------------------------
  724. //    FW_MProxy::ChangeExternalTransforms
  725. //----------------------------------------------------------------------------------------
  726.  
  727. void FW_MProxy::ChangeExternalTransforms(Environment* ev, ODTransform* transform)
  728. {
  729.     FW_ASSERT(transform);
  730.     
  731.     if (fEmbeddedFacetCount == 0)
  732.         return;
  733.  
  734.     transform->Acquire(ev);
  735.     FW_CAcquiredODTransform aqTransform(transform);
  736.     
  737.     FW_CProxyProxyFrameIterator ite(this);
  738.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  739.     {
  740.         if (proxyFrame->IsFrameInMemory(ev))
  741.         {
  742.             FW_CAcquiredODTransform aqCopy;
  743.                 
  744.             if (transform == NULL)
  745.                 aqCopy = transform = aqTransform->Copy(ev);
  746.             
  747.             FW_CODFrameFacetIterator ite(ev, proxyFrame->GetFrame(ev));        
  748.             for (ODFacet* odFacet = ite.First(ev); ite.IsNotComplete(ev); odFacet = ite.Next(ev))
  749.             {
  750.                 odFacet->ChangeGeometry(ev, NULL, transform, NULL);
  751.             }    
  752.                             
  753.             transform = NULL;
  754.         }
  755.     }
  756. }
  757.  
  758. //----------------------------------------------------------------------------------------
  759. //    FW_MProxy::ReleaseAll
  760. //----------------------------------------------------------------------------------------
  761.  
  762. void FW_MProxy::ReleaseAll(Environment* ev)
  763. {
  764.     FW_CProxyProxyFrameIterator ite(this);
  765.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  766.     {
  767.         proxyFrame->Release(ev);
  768.     }
  769. }
  770.  
  771. //----------------------------------------------------------------------------------------
  772. //    FW_MProxy::ChangeFrameShapes
  773. //----------------------------------------------------------------------------------------
  774.  
  775. void FW_MProxy::ChangeFrameShapes(Environment* ev, FW_Fixed width, FW_Fixed height)
  776. {
  777.     FW_CProxyProxyFrameIterator ite(this);
  778.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  779.     {
  780.         if (proxyFrame->IsFrameInMemory(ev))
  781.         {
  782.             FW_CAcquiredODShape newFrameShape = ::FW_NewODShape(ev, FW_CRect(FW_kZeroPoint, width, height));
  783.             proxyFrame->GetFrame(ev)->ChangeFrameShape(ev, newFrameShape, NULL);
  784.         }
  785.     }
  786. }
  787.  
  788. //----------------------------------------------------------------------------------------
  789. //    FW_MProxy::ChangeFrameShapes
  790. //----------------------------------------------------------------------------------------
  791.  
  792. void FW_MProxy::ChangeFrameShapes(Environment* ev, ODShape* newShape)
  793. {
  794.     FW_ASSERT(newShape != NULL);
  795.     
  796.     FW_CProxyProxyFrameIterator ite(this);
  797.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  798.     {
  799.         if (proxyFrame->IsFrameInMemory(ev))
  800.         {
  801.             FW_CAcquiredODShape aqShape(newShape->Copy(ev));
  802.             proxyFrame->GetFrame(ev)->ChangeFrameShape(ev, aqShape, NULL);
  803.         }
  804.     }
  805. }
  806.  
  807. //----------------------------------------------------------------------------------------
  808. //    FW_MProxy::PrivAddProxyFrame
  809. //----------------------------------------------------------------------------------------
  810.  
  811. void FW_MProxy::PrivAddProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  812. {        
  813. #ifdef FW_DEBUG
  814.     FW_CProxyProxyFrameIterator ite(this);
  815.     for (FW_CProxyFrame* pf = ite.First(); ite.IsNotComplete(); pf = ite.Next())
  816.     {
  817.         if (pf == proxyFrame)
  818.             FW_DEBUG_MESSAGE("FW_MProxy::PrivAddProxyFrame ProxyFrame already attached");
  819.     }
  820. #else
  821. FW_UNUSED(ev);
  822. #endif
  823.  
  824.     FW_ASSERT(proxyFrame->GetProxy(ev) == this);
  825.     
  826.     fProxyFrames->AddLast(proxyFrame);
  827. }
  828.  
  829. //----------------------------------------------------------------------------------------
  830. //    FW_MProxy::AdjustBorderShape
  831. //----------------------------------------------------------------------------------------
  832. //    Shape is content coordinate and already intersected with the content shape
  833.  
  834. void FW_MProxy::AdjustBorderShape(Environment* ev, 
  835.                                     FW_CEmbeddingFrame* embeddingFrame, 
  836.                                     ODFacet* embeddedFacet, 
  837.                                     ODShape* shape)
  838. {
  839. FW_UNUSED(ev);
  840. FW_UNUSED(embeddingFrame);
  841. FW_UNUSED(embeddedFacet);
  842. FW_UNUSED(shape);
  843. }
  844.  
  845. //----------------------------------------------------------------------------------------
  846. //    FW_MProxy::ChangeLinkStatus
  847. //----------------------------------------------------------------------------------------
  848.  
  849. void FW_MProxy::ChangeLinkStatus(Environment* ev, ODLinkStatus linkStatus)
  850. {
  851.     FW_CProxyProxyFrameIterator iter(this);
  852.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  853.     {
  854.         ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);    // [HXL] Mary, could you avoid loading the frame
  855.         
  856.         if (linkStatus == kODInLinkSource)
  857.         {    // if frame is already in a destination, leave its status alone
  858.             if (embeddedFrame->GetLinkStatus(ev) != kODInLinkDestination)
  859.                 embeddedFrame->ChangeLinkStatus(ev, linkStatus);
  860.         }
  861.         else
  862.             embeddedFrame->ChangeLinkStatus(ev, linkStatus);
  863.     }
  864. }
  865.  
  866. //----------------------------------------------------------------------------------------
  867. //    FW_MProxy::PrivNewProxyFrame
  868. //----------------------------------------------------------------------------------------
  869.  
  870. FW_CProxyFrame* FW_MProxy::PrivNewProxyFrame(Environment* ev, 
  871.                                             FW_CEmbeddingPart* part,
  872.                                             ODStorageUnitView* suView)
  873. {
  874.     FW_CProxyFrame* proxyFrame = new FW_CProxyFrame(ev, this, part);
  875.  
  876.     FW_TRY
  877.     {    
  878.         if (proxyFrame->InternalizeProxyFrame(ev, suView, NULL))
  879.             this->PrivAddProxyFrame(ev, proxyFrame);
  880.         else
  881.         {
  882.             delete proxyFrame;
  883.             proxyFrame = NULL;
  884.         }
  885.     }
  886.     FW_CATCH_BEGIN 
  887.     FW_CATCH_EVERYTHING () 
  888.     {
  889.         delete proxyFrame;
  890.         FW_THROW_SAME ();
  891.     }
  892.     FW_CATCH_END
  893.     
  894.     return proxyFrame;
  895. }
  896.  
  897. //----------------------------------------------------------------------------------------
  898. //    FW_MProxy::PrivNewProxyFrame
  899. //----------------------------------------------------------------------------------------
  900.  
  901. FW_CProxyFrame* FW_MProxy::PrivNewProxyFrame(Environment* ev, 
  902.                                             FW_CEmbeddingPart* part, 
  903.                                             FW_CEmbeddingFrame* containingFrame, 
  904.                                             ODFrame* embeddedFrame)
  905. {
  906.     FW_CProxyFrame* proxyFrame = new FW_CProxyFrame(ev, this, part, containingFrame, embeddedFrame);
  907.     
  908.     // ----- Add it to the proxy frame list
  909.     this->PrivAddProxyFrame(ev, proxyFrame);
  910.     
  911.     return proxyFrame;
  912. }
  913.  
  914.  
  915. //----------------------------------------------------------------------------------------
  916. //    FW_MProxy::GetEmbeddedPartName
  917. //----------------------------------------------------------------------------------------
  918.  
  919. void FW_MProxy::GetEmbeddedPartName(Environment* ev, FW_CString& name) const
  920. {
  921.     name = "";
  922.     
  923.     ODIText* newName = NULL;
  924.     FW_VOLATILE(newName);
  925.     
  926.     FW_TRY
  927.     {    
  928.         FW_CAcquiredODPart embeddedPart = AcquireEmbeddedPart(ev);
  929.         newName = ::ODGetITextProp(ev, embeddedPart->GetStorageUnit(ev), kODPropName, kODMacIText, kODNULL);
  930.     }
  931.     FW_CATCH_BEGIN 
  932.     FW_CATCH_EVERYTHING () 
  933.     {
  934.         // exception consumed
  935.     }
  936.     FW_CATCH_END
  937.     
  938.     if (newName != NULL)
  939.     {
  940.         name.ReplaceAll(newName);
  941.         ::DisposeIText(newName);
  942.     }
  943. }
  944.  
  945. //----------------------------------------------------------------------------------------
  946. //    FW_MProxy::PrivSetDragging
  947. //----------------------------------------------------------------------------------------
  948. // call by FW_CEmbeddingFrame::PrivSetDragging
  949.  
  950. void FW_MProxy::PrivSetDragging(Environment* ev, FW_Boolean state)
  951. {
  952.     //     I only change the state of the embedded frame if
  953.     //    change to TRUE : I am selected (GetSelectState(ev) == TRUE)
  954.     //    change to FALSE : I was dragged (fDragging == TRUE)
  955.     
  956.     if (state ? GetSelectState(ev) : fDragging)
  957.     {
  958.         FW_CProxyProxyFrameIterator iter(this);
  959.         for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  960.         {
  961.             if (proxyFrame->IsFrameInMemory(ev))
  962.                 proxyFrame->GetFrame(ev)->SetDragging(ev, state);
  963.         }
  964.     }
  965.     
  966.     fDragging = state;            
  967. }
  968.  
  969. //----------------------------------------------------------------------------------------
  970. //    FW_MProxy::OpenInWindow
  971. //----------------------------------------------------------------------------------------
  972. //    Called by FW_CEmbeddingFrame::OpenSelection. Override it if for any reason you don't
  973. //    want to open all selected proxy (see ODFTable)
  974.  
  975. void FW_MProxy::OpenInWindow(Environment* ev, FW_CProxyFrame* proxyFrame)
  976. {
  977.     ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  978.     FW_CAcquiredODPart aqODPart = embeddedFrame->AcquirePart(ev);
  979.     aqODPart->Open(ev, embeddedFrame);    
  980. }
  981.