home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2002 March / PCWMAR02.iso / software / turbocad / v8trial / TurboCADv8ProfessionalNoReg.exe / Data.Cab / F37594_Merge.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-10-26  |  29.1 KB  |  1,553 lines
  1. /******************************************************************/
  2. /*                                                                */
  3. /*                      TurboCAD for Windows                      */
  4. /*                   Copyright (c) 1993 - 2001                    */
  5. /*             International Microcomputer Software, Inc.         */
  6. /*                            (IMSI)                              */
  7. /*                      All rights reserved.                      */
  8. /*                                                                */
  9. /******************************************************************/
  10.  
  11. // Merge.cpp: implementation of the CMerge class.
  12. //
  13. // CMerge class performs insertion one drawing
  14. // in another (with merge line styles, brush styles etc.)
  15. //////////////////////////////////////////////////////////////////////
  16.  
  17. #include "stdafx.h"
  18. #include "InsTool.h"
  19. #include "InsSymb.h"
  20. #include "TDialog.h"
  21.  
  22. #ifdef _DEBUG
  23. #undef THIS_FILE
  24. static char THIS_FILE[]=__FILE__;
  25. #define new DEBUG_NEW
  26. #endif
  27.  
  28. template <class IStyles, class IStyle> HRESULT StylesMerge(IStyles *pISrc, IStyles *pITrg, CMerge* pMerge)
  29. {
  30.     HRESULT hr = E_FAIL;
  31.     BSTR bstrName = NULL;
  32.     COleVariant varItem;
  33.     long lCnt = 0;
  34.     long lItem = 0;
  35.     IStyle* pIStyle = NULL;
  36.  
  37.     try
  38.     {
  39.         hr = pISrc->get_Count(&lCnt);
  40.         CHECK_HRESULT(hr);
  41.  
  42.         for (lItem = 0; lItem < lCnt; lItem++)
  43.         {
  44.             varItem = lItem;
  45.             hr = pISrc->get_Item(&varItem, &pIStyle);
  46.             CHECK_HRESULT(hr);
  47.  
  48.             hr = pMerge->StyleMerge(pIStyle);
  49.             CHECK_HRESULT(hr);
  50.  
  51.             ::SysFreeString(bstrName);
  52.             bstrName = NULL;
  53.  
  54.             pIStyle->Release();
  55.             pIStyle = NULL;
  56.         }
  57.         hr = S_OK;
  58.     }
  59.     catch (...)
  60.     {
  61.     }
  62.  
  63.     _clearfp();
  64.  
  65.     if (bstrName != NULL)
  66.         ::SysFreeString(bstrName);
  67.  
  68.     if (pIStyle != NULL)
  69.         pIStyle->Release();
  70.  
  71.     return hr;
  72. }
  73.  
  74.  
  75. void CMapStyles::CleanAll()
  76. {
  77.     long lInd = 0;
  78.     Style *pStyle = NULL;
  79.     POSITION pos = GetStartPosition();
  80.     while (pos != NULL)
  81.     {
  82.         GetNextAssoc(pos, lInd, pStyle);
  83.         if (pStyle != NULL)
  84.             pStyle->Release();
  85.     }
  86.     RemoveAll();
  87. }
  88.  
  89. void CMapLineStyles::CleanAll()
  90. {
  91.     long lInd = 0;
  92.     LineStyle *pLineStyle = NULL;
  93.     POSITION pos = GetStartPosition();
  94.     while (pos != NULL)
  95.     {
  96.         GetNextAssoc(pos, lInd, pLineStyle);
  97.         if (pLineStyle != NULL)
  98.             pLineStyle->Release();
  99.     }
  100.     RemoveAll();
  101. }
  102.  
  103. void CMapBrushStyles::CleanAll()
  104. {
  105.     long lInd = 0;
  106.     BrushStyle *pBrushStyle = NULL;
  107.     POSITION pos = GetStartPosition();
  108.     while (pos != NULL)
  109.     {
  110.         GetNextAssoc(pos, lInd, pBrushStyle);
  111.         if (pBrushStyle != NULL)
  112.             pBrushStyle->Release();
  113.     }
  114.     RemoveAll();
  115. }
  116.  
  117. void CMapBlocks::CleanAll()
  118. {
  119.     long lInd = 0;
  120.     Block *pBlock = NULL;
  121.     POSITION pos = GetStartPosition();
  122.     while (pos != NULL)
  123.     {
  124.         GetNextAssoc(pos, lInd, pBlock);
  125.         if (pBlock != NULL)
  126.             pBlock->Release();
  127.     }
  128.     RemoveAll();
  129. }
  130.  
  131. void CMapLayers::CleanAll()
  132. {
  133.     long lInd = 0;
  134.     Layer *pLayer = NULL;
  135.     POSITION pos = GetStartPosition();
  136.     while (pos != NULL)
  137.     {
  138.         GetNextAssoc(pos, lInd, pLayer);
  139.         if (pLayer != NULL)
  140.             pLayer->Release();
  141.     }
  142.     RemoveAll();
  143. }
  144.  
  145. void CArrBlock::CleanAll()
  146. {
  147.     int lCount = GetSize();
  148.     Block *pBlock = NULL;
  149.     for (int iInd = 0; iInd < lCount; iInd++)
  150.     {
  151.         pBlock = GetAt(iInd);
  152.         if (pBlock != NULL)
  153.             pBlock->Release();
  154.     }
  155. }
  156.  
  157. void CArrLayer::CleanAll()
  158. {
  159.     int lCount = GetSize();
  160.     Layer *pLayer = NULL;
  161.     for (int iInd = 0; iInd < lCount; iInd++)
  162.     {
  163.         pLayer = GetAt(iInd);
  164.         if (pLayer != NULL)
  165.             pLayer->Release();
  166.     }
  167. }
  168.  
  169. //////////////////////////////////////////////////////////////////////
  170. // Construction/Destruction
  171. //////////////////////////////////////////////////////////////////////
  172.  
  173. CMerge::CMerge() :
  174. m_bInit(FALSE),
  175. m_pIDwgSrc(NULL),
  176. m_pStylesSrc(NULL),
  177. m_pLineStylesSrc(NULL),
  178. m_pBrushStylesSrc(NULL),
  179. m_pBlksSrc(NULL),
  180. m_pGrsSrc(NULL),
  181. m_pSelSrc(NULL),
  182. m_pIDwgTrg(NULL),
  183. m_pStylesTrg(NULL),
  184. m_pLineStylesTrg(NULL),
  185. m_pBrushStylesTrg(NULL),
  186. m_pBlksTrg(NULL),
  187. m_pGrsTrg(NULL),
  188. m_pIGrMerge(NULL),
  189. m_pLayersSrc(NULL),
  190. m_pLayersTrg(NULL)
  191. {
  192. }
  193.  
  194. CMerge::~CMerge()
  195. {
  196.     CleanAll();
  197. }
  198.  
  199. void CMerge::CleanAll()
  200. {
  201.  
  202.     RELEASE(m_pStylesSrc)
  203.     RELEASE(m_pLineStylesSrc)
  204.     RELEASE(m_pBrushStylesSrc)
  205.     RELEASE(m_pBlksSrc)
  206.     RELEASE(m_pGrsSrc)
  207.     RELEASE(m_pSelSrc)
  208.     RELEASE(m_pLayersSrc)
  209.  
  210.     RELEASE(m_pIDwgSrc)
  211.  
  212.     RELEASE(m_pStylesTrg)
  213.     RELEASE(m_pLineStylesTrg)
  214.     RELEASE(m_pBrushStylesTrg)
  215.     RELEASE(m_pBlksTrg)
  216.     RELEASE(m_pGrsTrg)
  217.     RELEASE(m_pLayersTrg)
  218.  
  219.     RELEASE(m_pIDwgTrg)
  220.  
  221.     RELEASE(m_pIGrMerge)
  222.  
  223.     m_bInit = FALSE;
  224.  
  225. }
  226.  
  227. HRESULT CMerge::Init(IDrawing *pIDwgSrc, IDrawing *pIDwgTrg, BOOL bSel)
  228. {
  229.     HRESULT hRes = E_FAIL;
  230.     COleVariant varType((const long)imsiGroup);
  231.     if (pIDwgSrc == NULL
  232.         || pIDwgTrg == NULL)
  233.         return hRes;
  234.  
  235.     if (m_bInit)
  236.         CleanAll();
  237.         HMODULE    hDBAPI = NULL;
  238.         hDBAPI = GetModuleHandle(DBAPI80);
  239.         if (hDBAPI == NULL)
  240.         {
  241.             hDBAPI = GetModuleHandle(DBAPI70);
  242.  
  243.             if (hDBAPI == NULL)
  244.             {
  245.                 hDBAPI = GetModuleHandle(DBAPI60);
  246.             }        
  247.         }
  248.  
  249.     m_pfnDwgGetGraphic = (DRAWINGGETGRAPHIC)GetProcAddress(hDBAPI, _T("DrawingGetPaperRoot"));
  250.     if (m_pfnDwgGetGraphic == NULL)                                                    
  251.         return hRes;
  252.  
  253.     m_pfnGrGetDispatch = (GRAPHICGETDISPATCH)GetProcAddress(hDBAPI, _T("GraphicGetDispatch"));
  254.     if (m_pfnGrGetDispatch == NULL)                                                    
  255.         return hRes;
  256.  
  257.     try
  258.     {
  259.         m_pIDwgSrc = pIDwgSrc;
  260.         m_pIDwgSrc->AddRef();
  261.  
  262.         hRes = m_pIDwgSrc->get_Styles(&m_pStylesSrc);
  263.         CHECK_HRESULT(hRes)
  264.  
  265.         hRes = m_pIDwgSrc->get_LineStyles(&m_pLineStylesSrc);
  266.         CHECK_HRESULT(hRes)
  267.  
  268.         hRes = m_pIDwgSrc->get_BrushStyles(&m_pBrushStylesSrc);
  269.         CHECK_HRESULT(hRes)
  270.  
  271.         hRes = m_pIDwgSrc->get_Blocks(&m_pBlksSrc);
  272.         CHECK_HRESULT(hRes)
  273.  
  274.         hRes = m_pIDwgSrc->get_Layers(&m_pLayersSrc);
  275.         CHECK_HRESULT(hRes)
  276.  
  277.         m_bSel = bSel;
  278.         if (m_bSel)
  279.             hRes = m_pIDwgSrc->get_Selection(&m_pSelSrc);
  280.         CHECK_HRESULT(hRes)
  281.  
  282.         hRes = m_pIDwgSrc->get_Graphics(&m_pGrsSrc);
  283.         CHECK_HRESULT(hRes)
  284.  
  285.         m_pIDwgTrg = pIDwgTrg;
  286.         m_pIDwgTrg->AddRef();
  287.  
  288.         hRes = m_pIDwgTrg->get_Styles(&m_pStylesTrg);
  289.         CHECK_HRESULT(hRes)
  290.  
  291.         hRes = m_pIDwgTrg->get_LineStyles(&m_pLineStylesTrg);
  292.         CHECK_HRESULT(hRes)
  293.  
  294.         hRes = m_pIDwgTrg->get_BrushStyles(&m_pBrushStylesTrg);
  295.         CHECK_HRESULT(hRes)
  296.  
  297.         hRes = m_pIDwgTrg->get_Blocks(&m_pBlksTrg);
  298.         CHECK_HRESULT(hRes)
  299.  
  300.         hRes = m_pIDwgTrg->get_Layers(&m_pLayersTrg);
  301.         CHECK_HRESULT(hRes)
  302.  
  303.         hRes = m_pIDwgTrg->get_Graphics(&m_pGrsTrg);
  304.         CHECK_HRESULT(hRes)
  305.  
  306.         hRes = m_pGrsTrg->Add(&varType,
  307.                               &varMissing,
  308.                               &varMissing,
  309.                               &varMissing,
  310.                               &varMissing,
  311.                               &varMissing,
  312.                               &m_pIGrMerge);
  313.         CHECK_HRESULT(hRes)
  314.  
  315.         m_pGrsTrg->Release();
  316.         m_pGrsTrg = NULL;
  317.  
  318.         hRes = m_pIGrMerge->get_Graphics(&m_pGrsTrg);
  319.         CHECK_HRESULT(hRes)
  320.  
  321.         m_bInit = TRUE;
  322.         hRes = S_OK;
  323.     }
  324.     catch (...)
  325.     {
  326.         CleanAll();
  327.         _clearfp();
  328.     }
  329.  
  330.     return hRes;
  331. }
  332.  
  333.  
  334. HRESULT CMerge::InitA(IDrawing *pIDwgSrc, IDrawing *pIDwgTrg)
  335. {
  336.     HRESULT hRes = E_FAIL;
  337.     if (pIDwgSrc == NULL
  338.         || pIDwgTrg == NULL)
  339.         return hRes;
  340.  
  341.     HMODULE hDBAPI = NULL;//GetModuleHandle(DBAPI);
  342.     hDBAPI = GetModuleHandle(DBAPI80);
  343.     if (hDBAPI == NULL)
  344.     {
  345.         hDBAPI = GetModuleHandle(DBAPI70);
  346.         if (hDBAPI == NULL)
  347.         {
  348.             hDBAPI = GetModuleHandle(DBAPI60);
  349.         }        
  350.     }
  351.  
  352.     m_pfnDwgGetGraphic = (DRAWINGGETGRAPHIC)GetProcAddress(hDBAPI, _T("DrawingGetPaperRoot"));
  353.     if (m_pfnDwgGetGraphic == NULL)                                                    
  354.         return hRes;
  355.  
  356.     m_pfnGrGetDispatch = (GRAPHICGETDISPATCH)GetProcAddress(hDBAPI, _T("GraphicGetDispatch"));
  357.     if (m_pfnGrGetDispatch == NULL)                                                    
  358.         return hRes;
  359.  
  360.     try
  361.     {
  362.         m_pIDwgSrc = pIDwgSrc;
  363.         m_pIDwgSrc->AddRef();
  364.  
  365.         hRes = m_pIDwgSrc->get_Styles(&m_pStylesSrc);
  366.         CHECK_HRESULT(hRes)
  367.  
  368.         hRes = m_pIDwgSrc->get_LineStyles(&m_pLineStylesSrc);
  369.         CHECK_HRESULT(hRes)
  370.  
  371.         hRes = m_pIDwgSrc->get_BrushStyles(&m_pBrushStylesSrc);
  372.         CHECK_HRESULT(hRes)
  373.  
  374.         hRes = m_pIDwgSrc->get_Blocks(&m_pBlksSrc);
  375.         CHECK_HRESULT(hRes)
  376.  
  377.         hRes = m_pIDwgSrc->get_Layers(&m_pLayersSrc);
  378.         CHECK_HRESULT(hRes)
  379.  
  380.  
  381.         m_pIDwgTrg = pIDwgTrg;
  382.         m_pIDwgTrg->AddRef();
  383.  
  384.         hRes = m_pIDwgTrg->get_Styles(&m_pStylesTrg);
  385.         CHECK_HRESULT(hRes)
  386.  
  387.         hRes = m_pIDwgTrg->get_LineStyles(&m_pLineStylesTrg);
  388.         CHECK_HRESULT(hRes)
  389.  
  390.         hRes = m_pIDwgTrg->get_BrushStyles(&m_pBrushStylesTrg);
  391.         CHECK_HRESULT(hRes)
  392.  
  393.         hRes = m_pIDwgTrg->get_Blocks(&m_pBlksTrg);
  394.         CHECK_HRESULT(hRes)
  395.  
  396.         hRes = m_pIDwgTrg->get_Layers(&m_pLayersTrg);
  397.         CHECK_HRESULT(hRes)
  398.  
  399.         m_bInit = TRUE;
  400.         hRes = S_OK;
  401.     }
  402.     catch (...)
  403.     {
  404.         CleanAll();
  405.         _clearfp();
  406.     }
  407.  
  408.     return hRes;
  409. }
  410.  
  411.  
  412. HRESULT CMerge::Run(IGraphic **ppIGrMerge, BOOL bGrsOnly)
  413. {
  414.     HRESULT hRes = E_FAIL;
  415.     if (!m_bInit)
  416.         return hRes;
  417.  
  418.     *ppIGrMerge = NULL;
  419.  
  420.     Graphics *pGrsSrc = NULL;
  421.     Graphics *pGrsTrg = NULL;
  422.  
  423.     try
  424.     {
  425.         if (!bGrsOnly)
  426.         {
  427.             hRes = MergeStyles();
  428.             CHECK_HRESULT(hRes)
  429.  
  430.             hRes = MergeLineStyles();
  431.             CHECK_HRESULT(hRes)
  432.  
  433.             hRes = MergeBrushStyles();
  434.             CHECK_HRESULT(hRes)
  435.  
  436.             hRes = MergeLayers();
  437.             CHECK_HRESULT(hRes)
  438.  
  439.             hRes = MergeBlocks();
  440.             CHECK_HRESULT(hRes)
  441.         }
  442.         if (!m_bSel)
  443.             hRes = MergeGraphics(m_pGrsSrc, m_pGrsTrg);
  444.         else
  445.             hRes = MergeSelGraphics();
  446.         CHECK_HRESULT(hRes)
  447.  
  448.         hRes = CorrectGraphic(m_pIGrMerge);
  449.         CHECK_HRESULT(hRes)
  450.  
  451.     }
  452.     catch (...)
  453.     {
  454.         m_pIGrMerge->Delete();
  455.         m_pIGrMerge = NULL;
  456.  
  457.         CleanAddedBlocks();
  458.         CleanAddedLayers();
  459.         _clearfp();
  460.     }
  461.  
  462.     if (ppIGrMerge != NULL
  463.         && m_pIGrMerge != NULL)
  464.     {
  465.         *ppIGrMerge = m_pIGrMerge;
  466.         (*ppIGrMerge)->AddRef();
  467.     }
  468.     return hRes;
  469. }
  470.  
  471. HRESULT CMerge::RunA() // merge only styles, blocks, layers (not gaphics).
  472. {
  473.     HRESULT hRes = E_FAIL;
  474.     if (!m_bInit)
  475.         return hRes;
  476.  
  477.     try
  478.     {
  479.         hRes = MergeStyles();
  480.         CHECK_HRESULT(hRes)
  481.  
  482.         hRes = MergeLineStyles();
  483.         CHECK_HRESULT(hRes)
  484.  
  485.         hRes = MergeBrushStyles();
  486.         CHECK_HRESULT(hRes)
  487.  
  488.         hRes = MergeLayers();
  489.         CHECK_HRESULT(hRes)
  490.  
  491.         hRes = MergeBlocks();
  492.         CHECK_HRESULT(hRes)
  493.     }
  494.     catch (...)
  495.     {
  496.         CleanAddedBlocks();
  497.         CleanAddedLayers();
  498.         _clearfp();
  499.     }
  500.  
  501.     return hRes;
  502. }
  503.  
  504. HRESULT CMerge::StyleMerge(IUnknown *pIUnkStyle)
  505. {
  506.     HRESULT hRes = E_FAIL;
  507.     Style *pStyle = NULL;
  508.     LineStyle *pLineStyle = NULL;
  509.     BrushStyle *pBrushStyle = NULL;
  510.  
  511.     try
  512.     {
  513.         hRes = pIUnkStyle->QueryInterface(IID_Style, (void**)&pStyle);
  514.         if (SUCCEEDED(hRes))
  515.         {
  516.             hRes = MergeStyle(pStyle);
  517.             CHECK_HRESULT(hRes)
  518.         }
  519.  
  520.         if (FAILED(hRes))
  521.         {
  522.             hRes = pIUnkStyle->QueryInterface(IID_LineStyle, (void**)&pLineStyle);
  523.             if (SUCCEEDED(hRes))
  524.             {
  525.                 hRes = MergeLineStyle(pLineStyle);
  526.                 CHECK_HRESULT(hRes)
  527.             }
  528.         }
  529.  
  530.         if (FAILED(hRes))
  531.         {
  532.             hRes = pIUnkStyle->QueryInterface(IID_BrushStyle, (void**)&pBrushStyle);
  533.             if (SUCCEEDED(hRes))
  534.             {
  535.                 hRes = MergeBrushStyle(pBrushStyle);
  536.                 CHECK_HRESULT(hRes)
  537.             }
  538.         }
  539.     }
  540.     catch (...)
  541.     {
  542.         _clearfp();
  543.     }
  544.  
  545.     if (pStyle != NULL)
  546.         pStyle->Release();
  547.  
  548.     if (pLineStyle != NULL)
  549.         pLineStyle->Release();
  550.  
  551.     if (pBrushStyle != NULL)
  552.         pBrushStyle->Release();
  553.  
  554.     return hRes;
  555. }
  556.  
  557. HRESULT CMerge::MergeStyle(Style *pStSrc)
  558. {
  559.     HRESULT hRes = E_FAIL;
  560.  
  561.     BSTR bstrName = NULL;
  562.     CComVariant varItem;
  563.     Style *pStTrg = NULL;
  564.  
  565.     try
  566.     {
  567.         hRes = pStSrc->get_Name(&bstrName);
  568.         CHECK_HRESULT(hRes);
  569.  
  570.         varItem = bstrName;
  571.         hRes = m_pStylesTrg->get_Item(&varItem, &pStTrg);
  572.  
  573.     }
  574.     catch (...)
  575.     {
  576.         _clearfp();
  577.     }
  578.  
  579.     if (pStTrg != NULL)
  580.         pStTrg->Release();
  581.     return hRes;
  582. }
  583.  
  584. HRESULT CMerge::MergeStyles()
  585. {
  586.     HRESULT hRes = E_FAIL;
  587.     if (!m_bInit)
  588.         return hRes;
  589.  
  590.     try
  591.     {
  592.         hRes = StylesMerge<Styles, Style>(m_pStylesSrc, m_pStylesTrg, this);
  593.     }
  594.     catch (...)
  595.     {
  596.         _clearfp();
  597.     }
  598.  
  599.     return hRes;
  600. }
  601.  
  602. HRESULT CMerge::MergeLineStyle(LineStyle *pLineStSrc)
  603. {
  604.     HRESULT hRes = E_FAIL;
  605.  
  606.     CComVariant varItem;
  607.     CComVariant varDashes;
  608.     CComVariant varDescription;
  609.  
  610.     BSTR bstrName = NULL;
  611.     CString cstrDescription(_T("Added brushstyle"));//# Non-localizable string#
  612.     BSTR bstrDescription = cstrDescription.AllocSysString();
  613.  
  614.     LineStyle *pLineStTrg = NULL;
  615.     long lIndex = 0;
  616.  
  617.     try
  618.     {
  619.         hRes = pLineStSrc->get_Name(&bstrName);
  620.         CHECK_HRESULT(hRes);
  621.  
  622.         varItem = bstrName;
  623.         hRes = m_pLineStylesTrg->get_Item(&varItem, &pLineStTrg);
  624.  
  625.         if (FAILED(hRes))
  626.         {
  627.             hRes = pLineStSrc->GetDashes(&varDashes);
  628.             CHECK_HRESULT(hRes);
  629.  
  630.             varDescription = bstrDescription;
  631.  
  632.             hRes = m_pLineStylesTrg->Add(bstrName, &varDashes, &varDescription, &pLineStTrg);
  633.             CHECK_HRESULT(hRes);
  634.         }
  635.  
  636.         hRes = pLineStSrc->get_Index(&lIndex);
  637.         CHECK_HRESULT(hRes);
  638.  
  639.         m_mapLineStyles.SetAt(lIndex, pLineStTrg);
  640.         pLineStTrg->AddRef();
  641.     }
  642.     catch (...)
  643.     {
  644.         _clearfp();
  645.     }
  646.  
  647.     if (pLineStTrg != NULL)
  648.         pLineStTrg->Release();
  649.  
  650.     if (bstrDescription != NULL)
  651.         ::SysFreeString(bstrDescription);
  652.     return hRes;
  653. }
  654.  
  655. HRESULT CMerge::MergeLineStyles()
  656. {
  657.     HRESULT hRes = E_FAIL;
  658.     if (!m_bInit)
  659.         return hRes;
  660.  
  661.     try
  662.     {
  663.         hRes = StylesMerge<LineStyles, LineStyle>(m_pLineStylesSrc, m_pLineStylesTrg, this);
  664.         hRes = S_OK;
  665.     }
  666.     catch (...)
  667.     {
  668.         _clearfp();
  669.     }
  670.  
  671.     return hRes;
  672. }
  673.  
  674. HRESULT CMerge::MergeBrushStyles()
  675. {
  676.     HRESULT hRes = E_FAIL;
  677.     if (!m_bInit)
  678.         return hRes;
  679.  
  680.     try
  681.     {
  682.         hRes = StylesMerge<BrushStyles, BrushStyle>(m_pBrushStylesSrc, m_pBrushStylesTrg, this);
  683.     }
  684.     catch (...)
  685.     {
  686.         _clearfp();
  687.     }
  688.  
  689.     return hRes;
  690. }
  691.  
  692. HRESULT CMerge::MergeBrushStyle(BrushStyle *pBrStSrc)
  693. {
  694.     HRESULT hRes = E_FAIL;
  695.  
  696.     BSTR bstrName = NULL;
  697.     CComVariant varItem;
  698.     BrushStyle *pBrStTrg = NULL;
  699.     long lIndex = 0;
  700.     try
  701.     {
  702.         hRes = pBrStSrc->get_Name(&bstrName);
  703.         CHECK_HRESULT(hRes);
  704.  
  705.         varItem = bstrName;
  706.         hRes = m_pBrushStylesTrg->get_Item(&varItem, &pBrStTrg);
  707.         if (SUCCEEDED(hRes))
  708.         {
  709.             hRes = pBrStSrc->get_Index(&lIndex);
  710.             m_mapBrushStyles.SetAt(lIndex, pBrStTrg);
  711.             pBrStTrg->AddRef();
  712.         }
  713.         hRes = S_OK;
  714.     }
  715.     catch (...)
  716.     {
  717.         _clearfp();
  718.     }
  719.  
  720.     if (pBrStTrg != NULL)
  721.         pBrStTrg->Release();
  722.     return hRes;
  723. }
  724.  
  725. HRESULT CMerge::MergeLayer(Layer *pLyrSrc, Layer** ppLyrTrg)
  726. {
  727.     HRESULT hRes = E_FAIL;
  728.     if (!m_bInit)
  729.         return hRes;
  730.  
  731.     BSTR bstrName = NULL;
  732.     COleVariant varName;
  733.  
  734.     long lIndex = 0;
  735.     COleVariant varIndex;
  736.  
  737.     COleVariant varVisible(varMissing);
  738.     COleVariant varEditable(varMissing);
  739.     COleVariant varFrozen(varMissing);
  740.     COleVariant varColor(varMissing);
  741.     COleVariant varZOrder(varMissing);
  742.  
  743.     IMSI_COLOR color = 0;
  744.     IMSI_BOOL bEditable = TRUE;
  745.     IMSI_BOOL bFrozen = FALSE;
  746.     IMSI_BOOL bVisible = TRUE;
  747.     long lZOrder = 0;
  748.  
  749.     COleVariant varLineStyle(varMissing);
  750.     COleVariant varBrushStyle(varMissing);
  751.     COleVariant varStyle(varMissing);
  752.  
  753.     BrushStyle* pBrushStyle = NULL;
  754.     LineStyle* pLineStyle = NULL;
  755.     Style* pStyle = NULL;
  756.  
  757.     try
  758.     {
  759.         hRes = pLyrSrc->get_Name(&bstrName);
  760.         CHECK_HRESULT(hRes)
  761.  
  762.         varName = bstrName;
  763.         hRes = m_pLayersTrg->get_Item(&varName, ppLyrTrg);
  764.         if (FAILED(hRes))
  765.         {
  766.             hRes = pLyrSrc->get_LineStyle(&pLineStyle);
  767.             CHECK_HRESULT(hRes)
  768.  
  769.             hRes = pLineStyle->get_Index(&lIndex);
  770.             pLineStyle->Release();
  771.             pLineStyle = NULL;
  772.             if (m_mapLineStyles.Lookup(lIndex, pLineStyle))
  773.             {
  774.                 varLineStyle.vt = VT_DISPATCH;
  775.                 varLineStyle.pdispVal = (IDispatch *)pLineStyle;
  776.                 pLineStyle->AddRef();
  777.             }
  778.  
  779.             hRes = pLyrSrc->get_Color(&color);
  780.             CHECK_HRESULT(hRes)
  781.             varColor = color;
  782.  
  783.             hRes = pLyrSrc->get_Editable(&bEditable);
  784.             CHECK_HRESULT(hRes)
  785.             varEditable.vt = VT_BOOL;
  786.             varEditable.bVal = bEditable;
  787.  
  788.             hRes = pLyrSrc->get_Frozen(&bFrozen);
  789.             CHECK_HRESULT(hRes)
  790.             varFrozen.vt = VT_BOOL;
  791.             varFrozen.bVal = bFrozen;
  792.  
  793.             hRes = pLyrSrc->get_Visible(&bVisible);
  794.             CHECK_HRESULT(hRes)
  795.             varVisible.vt = VT_BOOL;
  796.             varVisible.bVal = bVisible;
  797.  
  798.             hRes = pLyrSrc->get_ZOrder(&lZOrder);
  799.             CHECK_HRESULT(hRes)
  800.             varZOrder = lZOrder;
  801.  
  802.             hRes = m_pLayersTrg->Add(bstrName,
  803.                                      &varVisible,
  804.                                      &varEditable,
  805.                                      &varFrozen,
  806.                                      &varColor,
  807.                                      &varLineStyle,
  808.                                      &varBrushStyle,
  809.                                      &varStyle,
  810.                                       &varZOrder,
  811.                                      ppLyrTrg);
  812.             CHECK_HRESULT(hRes)
  813.  
  814.             m_arrLyrs.Add((*ppLyrTrg));
  815.             (*ppLyrTrg)->AddRef();
  816.         }
  817.  
  818.         hRes = S_OK;
  819.     }
  820.     catch (...)
  821.     {
  822.         _clearfp();
  823.     }
  824.  
  825.     if (bstrName != NULL)
  826.         ::SysFreeString(bstrName);
  827.  
  828.     if (pBrushStyle != NULL)
  829.         pBrushStyle->Release();
  830.  
  831.     if (pStyle != NULL)
  832.         pStyle->Release();
  833.  
  834.     return hRes;
  835. }
  836.  
  837. HRESULT CMerge::MergeLayers()
  838. {
  839.     HRESULT hRes = E_FAIL;
  840.     if (!m_bInit)
  841.         return hRes;
  842.  
  843.     Layer *pLyrSrc = NULL;
  844.     Layer *pLyrTrg = NULL;
  845.  
  846.     try
  847.     {
  848.         long lCount = 0;
  849.         hRes = m_pLayersSrc->get_Count(&lCount);
  850.         CHECK_HRESULT(hRes)
  851.  
  852.         long lItem = 0;
  853.         COleVariant varItem(lItem);
  854.         for (lItem = 0; lItem < lCount; lItem++)
  855.         {
  856.             varItem = lItem;
  857.             hRes = m_pLayersSrc->get_Item(&varItem, &pLyrSrc);
  858.             CHECK_HRESULT(hRes)
  859.  
  860.             hRes = MergeLayer(pLyrSrc, &pLyrTrg);
  861.             CHECK_HRESULT(hRes)
  862.  
  863.             m_mapLayers.SetAt(lItem, pLyrTrg);
  864.             pLyrTrg = NULL;
  865.  
  866.             pLyrSrc->Release();
  867.             pLyrSrc = NULL;
  868.         }
  869.  
  870.         hRes = S_OK;
  871.     }
  872.     catch (...)
  873.     {
  874.         _clearfp();
  875.     }
  876.  
  877.     if (pLyrSrc != NULL)
  878.         pLyrSrc->Release();
  879.  
  880.     if (pLyrTrg != NULL)
  881.         pLyrTrg->Release();
  882.  
  883.     return hRes;
  884. }
  885.  
  886. HRESULT CMerge::MergeBlock(Block *pBlkSrc, Block** ppBlkTrg)
  887. {
  888.     HRESULT hRes = E_FAIL;
  889.     if (!m_bInit)
  890.         return hRes;
  891.  
  892.     BSTR bstrName = NULL;
  893.     COleVariant varName;
  894.  
  895.     IVertex *pIVrt = NULL;
  896.  
  897.     IDispatch *pIDisp = NULL;
  898.     Graphics *pGrsSrc = NULL;
  899.     IGraphic *pIGrSrc = NULL;
  900.  
  901.     COleVariant varX(0L);
  902.     COleVariant varY(0L);
  903.     COleVariant varZ(0L);
  904.  
  905.     long lIndex = 0;
  906.     COleVariant varIndex;
  907.  
  908.     IGraphic *pIGrTrg = NULL;
  909.  
  910.     try
  911.     {
  912.         hRes = pBlkSrc->get_Name(&bstrName);
  913.         CHECK_HRESULT(hRes)
  914.  
  915.         varName = bstrName;
  916.         hRes = m_pBlksTrg->get_Item(&varName, ppBlkTrg);
  917.         if (FAILED(hRes))
  918.         {
  919.             hRes = pBlkSrc->get_Anchor(&pIVrt);
  920.             if (SUCCEEDED(hRes))
  921.             {
  922.                 double x = 0;
  923.                 hRes = pIVrt->get_X(&x);
  924.                 CHECK_HRESULT(hRes)
  925.                 varX = x;
  926.  
  927.                 double y = 0;
  928.                 hRes = pIVrt->get_Y(&y);
  929.                 CHECK_HRESULT(hRes)
  930.                 varY = y;
  931.  
  932.                 double z = 0;
  933.                 hRes = pIVrt->get_Z(&z);
  934.                 CHECK_HRESULT(hRes)
  935.                 varZ = z;
  936.             }
  937.  
  938.             hRes = pBlkSrc->get_Graphics(&pGrsSrc);
  939.             CHECK_HRESULT(hRes)
  940.  
  941.             hRes = pGrsSrc->get_Parent(&pIDisp);
  942.             CHECK_HRESULT(hRes)
  943.  
  944.             hRes = pIDisp->QueryInterface(IID_IGraphic, (void**)&pIGrSrc);
  945.             CHECK_HRESULT(hRes)
  946.  
  947.             hRes = pIGrSrc->Duplicate(&pIGrTrg);
  948.             CHECK_HRESULT(hRes)
  949.  
  950.             hRes = m_pGrsTrg->AddGraphic(pIGrTrg, &varMissing, &varMissing);
  951.             CHECK_HRESULT(hRes)
  952.  
  953.             hRes = CorrectGraphic(pIGrTrg, FALSE);
  954.             CHECK_HRESULT(hRes)
  955.  
  956.             hRes = m_pBlksTrg->Add(bstrName,
  957.                                    pIGrTrg,
  958.                                    &varX,
  959.                                    &varY,
  960.                                    &varZ,
  961.                                    &varFalse,
  962.                                    &varFalse,
  963.                                    NULL,
  964.                                    ppBlkTrg);
  965.             CHECK_HRESULT(hRes)
  966.  
  967.             hRes = pIGrTrg->Delete();
  968.             CHECK_HRESULT(hRes)
  969.  
  970.             m_arrBlks.Add((*ppBlkTrg));
  971.             (*ppBlkTrg)->AddRef();
  972.         }
  973.  
  974.         hRes = S_OK;
  975.     }
  976.     catch (...)
  977.     {
  978.         _clearfp();
  979.     }
  980.  
  981.     if (bstrName != NULL)
  982.         ::SysFreeString(bstrName);
  983.  
  984.     if (pIVrt != NULL)
  985.         pIVrt->Release();
  986.  
  987.     if (pGrsSrc != NULL)
  988.         pGrsSrc->Release();
  989.  
  990.     if (pIGrSrc != NULL)
  991.         pIGrSrc->Release();
  992.  
  993.     if (pIDisp != NULL)
  994.         pIDisp->Release();
  995.  
  996.     if (pIGrTrg != NULL)
  997.         pIGrTrg->Release();
  998.  
  999.     return hRes;
  1000. }
  1001.  
  1002. HRESULT CMerge::MergeBlocks()
  1003. {
  1004.     HRESULT hRes = E_FAIL;
  1005.     if (!m_bInit)
  1006.         return hRes;
  1007.  
  1008.     Properties *pProps = NULL;
  1009.     Property *pProp = NULL;
  1010.  
  1011.     CString cstrProp(_T("TileMode"));//# Non-localizable string#
  1012.     COleVariant varProp(cstrProp);
  1013.     COleVariant varValOld;
  1014.  
  1015.     COleVariant varValMS;
  1016.     varValMS.vt = VT_I2;
  1017.     varValMS.iVal = 1;
  1018.     COleVariant varValPS;
  1019.     varValPS.vt = VT_I2;
  1020.     varValPS.iVal = 0;
  1021.     IDispatch *pIGrRoot = NULL;
  1022.  
  1023.     Block *pBlkSrc = NULL;
  1024.     Block *pBlkTrg = NULL;
  1025.  
  1026.  
  1027.     Graphics *pGrs = NULL;
  1028.     pGrs = m_pGrsTrg;
  1029.  
  1030.     try
  1031.     {
  1032.         hRes = m_pIDwgTrg->get_Properties(&pProps);
  1033.         CHECK_HRESULT(hRes)
  1034.  
  1035.         hRes = pProps->get_Item(&varProp, &pProp);
  1036.         CHECK_HRESULT(hRes)
  1037.  
  1038.         hRes = pProp->get_Value(0, &varValOld);
  1039.         CHECK_HRESULT(hRes)
  1040.  
  1041.         if (varValOld == varValPS)
  1042.         {
  1043.             long lDwg = 0;
  1044.             hRes = m_pIDwgTrg->get__Handle(&lDwg);
  1045.             CHECK_HRESULT(hRes)
  1046.  
  1047.             long lRoot = (*m_pfnDwgGetGraphic)(lDwg);
  1048.             if (lRoot == 0)
  1049.                 throw E_FAIL;
  1050.  
  1051.             pIGrRoot = (*m_pfnGrGetDispatch)(lRoot, NULL);
  1052.             if (pIGrRoot == 0)
  1053.                 throw E_FAIL;
  1054.  
  1055.             hRes = pProp->put_Value(0, &varValMS);
  1056.             CHECK_HRESULT(hRes)
  1057.         }
  1058.  
  1059.         hRes = m_pIDwgTrg->get_Graphics(&m_pGrsTrg);
  1060.         CHECK_HRESULT(hRes)
  1061.  
  1062.         long lCount = 0;
  1063.         hRes = m_pBlksSrc->get_Count(&lCount);
  1064.         CHECK_HRESULT(hRes)
  1065.  
  1066.         long lItem = 0;
  1067.         COleVariant varItem(lItem);
  1068.         for (lItem = 0; lItem < lCount; lItem++)
  1069.         {
  1070.             varItem = lItem;
  1071.             hRes = m_pBlksSrc->get_Item(&varItem, &pBlkSrc);
  1072.             CHECK_HRESULT(hRes)
  1073.  
  1074.             hRes = MergeBlock(pBlkSrc, &pBlkTrg);
  1075.             CHECK_HRESULT(hRes)
  1076.  
  1077.             m_mapBlks.SetAt(lItem, pBlkTrg);
  1078.             pBlkTrg = NULL;
  1079.  
  1080.             pBlkSrc->Release();
  1081.             pBlkSrc = NULL;
  1082.         }
  1083.  
  1084.         hRes = CorrectAddedBlocks();
  1085.         CHECK_HRESULT(hRes);
  1086.  
  1087.         if (varValOld == varValPS)
  1088.         {
  1089.             hRes = pProp->put_Value(0, &varValOld);
  1090.             CHECK_HRESULT(hRes);
  1091.  
  1092.             m_pGrsTrg->Release();
  1093.             m_pGrsTrg = NULL;
  1094.  
  1095.             hRes = m_pIDwgTrg->get_Graphics(&m_pGrsTrg); // it is need to call DrawingUpdateCurrentRoot
  1096.             CHECK_HRESULT(hRes);
  1097.         }
  1098.  
  1099.         hRes = S_OK;
  1100.     }
  1101.     catch (...)
  1102.     {
  1103.         TRACE_EXCEPTION("CMerge::MergeBlocks")
  1104.         _clearfp();
  1105.  
  1106.     }
  1107.  
  1108.     if (pIGrRoot != NULL)
  1109.         pIGrRoot->Release();
  1110.  
  1111.     if (m_pGrsTrg != NULL)
  1112.         m_pGrsTrg->Release();
  1113.  
  1114.     m_pGrsTrg = pGrs;
  1115.  
  1116.     if (pProp != NULL)
  1117.         pProp->Release();
  1118.  
  1119.     if (pProps != NULL)
  1120.         pProps->Release();
  1121.  
  1122.     if (pBlkSrc != NULL)
  1123.         pBlkSrc->Release();
  1124.  
  1125.     if (pBlkTrg != NULL)
  1126.         pBlkTrg->Release();
  1127.  
  1128.     return hRes;
  1129. }
  1130.  
  1131. HRESULT CMerge::MergeSelGraphics()
  1132. {
  1133.     HRESULT hRes = E_FAIL;
  1134.     if (!m_bInit)
  1135.         return hRes;
  1136.  
  1137.     IGraphic *pIGrSrc = NULL;
  1138.     IGraphic *pIGrTrg = NULL;
  1139.  
  1140.     long lCount = 0;
  1141.     long lItem = 0;
  1142.     COleVariant varItem(lItem);
  1143.  
  1144.     long lInd = 0;
  1145.     COleVariant varInd(lInd);
  1146.  
  1147.     try
  1148.     {
  1149.         hRes = m_pSelSrc->get_Count(&lCount);
  1150.         CHECK_HRESULT(hRes)
  1151.  
  1152.         for (lItem = 0; lItem < lCount; lItem++)
  1153.         {
  1154.             varItem = lItem;
  1155.             hRes = m_pSelSrc->get_Item(&varItem, &pIGrSrc);
  1156.             CHECK_HRESULT(hRes)
  1157.  
  1158.             hRes = pIGrSrc->Duplicate(&pIGrTrg);
  1159.             CHECK_HRESULT(hRes)
  1160.  
  1161.             hRes = pIGrTrg->get_Index(&lInd);
  1162.             CHECK_HRESULT(hRes)
  1163.  
  1164.             hRes = pIGrTrg->Release();
  1165.             CHECK_HRESULT(hRes)
  1166.  
  1167.             pIGrTrg = NULL;
  1168.  
  1169.             varInd = lInd;
  1170.             hRes = m_pGrsSrc->Remove(&varInd, &pIGrTrg);
  1171.             CHECK_HRESULT(hRes)
  1172.  
  1173.             hRes = pIGrTrg->put_ID(0);
  1174.             CHECK_HRESULT(hRes)
  1175.  
  1176.             hRes = m_pGrsTrg->AddGraphic(pIGrTrg, &varMissing, &varMissing);
  1177.  
  1178.             pIGrTrg->Release();
  1179.             pIGrTrg = NULL;
  1180.         }
  1181.     }
  1182.     catch (...)
  1183.     {
  1184.         _clearfp();
  1185.     }
  1186.  
  1187.     if (pIGrSrc != NULL)
  1188.         pIGrSrc->Release();
  1189.  
  1190.     if (pIGrTrg != NULL)
  1191.         pIGrTrg->Release();
  1192.     return hRes;
  1193. }
  1194.  
  1195. HRESULT CMerge::MergeGraphics(Graphics *pGrsSrc, Graphics *pGrsTrg)
  1196. {
  1197.     HRESULT hRes = E_FAIL;
  1198.     if (!m_bInit)
  1199.         return hRes;
  1200.  
  1201.     IGraphic *pIGrSrc = NULL;
  1202.     IGraphic *pIGrTrg = NULL;
  1203.  
  1204.     long lCount = 0;
  1205.     long lItem = 0;
  1206.     COleVariant varItem(lItem);
  1207.  
  1208.     long lInd = 0;
  1209.     COleVariant varInd(lInd);
  1210.  
  1211.     try
  1212.     {
  1213.         hRes = m_pGrsSrc->get_Count(&lCount);
  1214.         CHECK_HRESULT(hRes)
  1215.  
  1216.         for (lItem = 0; lItem < lCount; lItem++)
  1217.         {
  1218.             varItem = lItem;
  1219.             hRes = m_pGrsSrc->get_Item(&varItem, &pIGrSrc);
  1220.             CHECK_HRESULT(hRes)
  1221.             ImsiGraphicType GrType;
  1222.             hRes = pIGrSrc->get_TypeByValue(&GrType);
  1223.             CHECK_HRESULT(hRes)
  1224.  
  1225.             BSTR bstrGrType;
  1226.             hRes = pIGrSrc->get_Type(&bstrGrType);
  1227.             CHECK_HRESULT(hRes)
  1228.             CString cstrGrType;
  1229.             cstrGrType = bstrGrType; 
  1230.             ::SysFreeString(bstrGrType);
  1231.             bstrGrType = NULL;        
  1232.  
  1233.             if(    cstrGrType != "TCLight")//# Non-localizable string#
  1234.             {
  1235.                 if (GrType != imsiViewport && GrType != imsiOleObject) // ViewPorts and OLE objects are excluded from merge
  1236.                 {
  1237.                     hRes = pIGrSrc->Duplicate(&pIGrTrg);
  1238.                     CHECK_HRESULT(hRes)
  1239.  
  1240.                     hRes = pIGrTrg->get_Index(&lInd);
  1241.                     CHECK_HRESULT(hRes)
  1242.  
  1243.                     hRes = pIGrTrg->Release();
  1244.                     CHECK_HRESULT(hRes)
  1245.  
  1246.                     pIGrTrg = NULL;
  1247.  
  1248.                     varInd = lInd;
  1249.                     hRes = m_pGrsSrc->Remove(&varInd, &pIGrTrg);
  1250.                     CHECK_HRESULT(hRes)
  1251.  
  1252.                     hRes = pIGrTrg->put_ID(0);
  1253.                     CHECK_HRESULT(hRes)
  1254.  
  1255.                     hRes = m_pGrsTrg->AddGraphic(pIGrTrg, &varMissing, &varMissing);
  1256.  
  1257.                     pIGrTrg->Release();
  1258.                     pIGrTrg = NULL;
  1259.                 }
  1260.             }
  1261.             pIGrSrc->Release();
  1262.             pIGrSrc = NULL;
  1263.  
  1264.         }
  1265.     }
  1266.     catch (...)
  1267.     {
  1268.         _clearfp();
  1269.     }
  1270.  
  1271.     if (pIGrSrc != NULL)
  1272.         pIGrSrc->Release();
  1273.  
  1274.     if (pIGrTrg != NULL)
  1275.         pIGrTrg->Release();
  1276.  
  1277.     return hRes;
  1278. }
  1279.  
  1280. HRESULT CMerge::CorrectAddedBlocks()
  1281. {
  1282.     HRESULT hRes = E_FAIL;
  1283.     if (!m_bInit)
  1284.         return hRes;
  1285.  
  1286.     hRes = S_OK;
  1287.     int iCount = m_arrBlks.GetSize();
  1288.     int iInd = 0;
  1289.     Block *pBlk = NULL;
  1290.  
  1291.     Graphics *pGrs = NULL;
  1292.     IDispatch *pIDisp = NULL;
  1293.     IGraphic *pIGr = NULL;
  1294.  
  1295.  
  1296.     for (iInd = 0; iInd < iCount; iInd++)
  1297.     {
  1298.         pBlk = m_arrBlks[iInd];
  1299.         if (pBlk != NULL)
  1300.         {
  1301.             try
  1302.             {
  1303.                 hRes = pBlk->get_Graphics(&pGrs);
  1304.                 CHECK_HRESULT(hRes)
  1305.  
  1306.                 hRes = pGrs->get_Parent(&pIDisp);
  1307.                 CHECK_HRESULT(hRes)
  1308.  
  1309.                 hRes = pIDisp->QueryInterface(IID_IGraphic, (void **)&pIGr);
  1310.                 CHECK_HRESULT(hRes)
  1311.  
  1312.                 hRes = CorrectGraphic(pIGr);
  1313.                 CHECK_HRESULT(hRes)
  1314.             }
  1315.             catch (...)
  1316.             {
  1317.                 pBlk->Delete();
  1318.                 pBlk->Release();
  1319.                 m_arrBlks[iInd] = NULL;
  1320.             }
  1321.  
  1322.             if (pIDisp != NULL)
  1323.                 pIDisp->Release();
  1324.  
  1325.             if (pGrs != NULL)
  1326.                 pGrs->Release();
  1327.  
  1328.             if (pIGr != NULL)
  1329.                 pIGr->Release();
  1330.         }
  1331.     }
  1332.     return hRes;
  1333. }
  1334.  
  1335. void CMerge::CleanAddedBlocks()
  1336. {
  1337.     if (!m_bInit)
  1338.         return ;
  1339.  
  1340.     try
  1341.     {
  1342.  
  1343.     }
  1344.     catch (...)
  1345.     {
  1346.         _clearfp();
  1347.     }
  1348. }
  1349.  
  1350. void CMerge::CleanAddedLayers()
  1351. {
  1352.     if (!m_bInit)
  1353.         return ;
  1354.  
  1355.     try
  1356.     {
  1357.  
  1358.     }
  1359.     catch (...)
  1360.     {
  1361.         _clearfp();
  1362.     }
  1363. }
  1364.  
  1365. HRESULT CMerge::CorrectGraphic(IGraphic * pIGr, BOOL bCorrectInserts)
  1366. {
  1367.     HRESULT hRes = E_FAIL;
  1368.     if (!m_bInit)
  1369.         return hRes;
  1370.  
  1371.     CString cstrType;
  1372.     BSTR bstrType = NULL;
  1373.  
  1374.     Block *pBlkSrc = NULL;
  1375.     Block *pBlkTrg = NULL;
  1376.  
  1377.     Layer *pLyr = NULL;
  1378.     long lIndex = 0;
  1379.  
  1380.     CString cstrDefLayer("0");
  1381.     BSTR bstrDefLayer = cstrDefLayer.AllocSysString();
  1382.  
  1383.     CString cstrDefLineSt("CONTINUOUS");//# Non-localizable string#
  1384.     BSTR bstrDefLineSt = cstrDefLineSt.AllocSysString();
  1385.  
  1386.     CString cstrDefBrushSt("SOLID");//# Non-localizable string#
  1387.     BSTR bstrDefBrushSt = cstrDefBrushSt.AllocSysString();
  1388.  
  1389.     COleVariant varLayer;
  1390.     COleVariant varLineSt;
  1391.     COleVariant varBrushSt;
  1392.  
  1393.     Graphics *pGrs = NULL;
  1394.     IGraphic *pIGrC = NULL;
  1395.  
  1396.     LineStyle *pLineSt = NULL;
  1397.     BrushStyle *pBrushSt = NULL;
  1398.  
  1399.     try
  1400.     {
  1401.         // TODO : to correct Styles, LineStyles, BrushStyles
  1402.         hRes = pIGr->get_Layer(&pLyr);
  1403.         if (SUCCEEDED(hRes))
  1404.         {
  1405.             hRes = pLyr->get_Index(&lIndex);
  1406.             CHECK_HRESULT(hRes)
  1407.  
  1408.             pLyr->Release();
  1409.             pLyr = NULL;
  1410.  
  1411.             if (m_mapLayers.Lookup(lIndex, pLyr))
  1412.             {
  1413.                 varLayer.vt = VT_DISPATCH;
  1414.                 varLayer.pdispVal = (IDispatch *)pLyr;
  1415.                 pLyr->AddRef();
  1416.             }
  1417.             else
  1418.                 varLayer = bstrDefLayer;
  1419.  
  1420.             hRes = pIGr->put_Layer(varLayer);
  1421.         }
  1422.  
  1423.         hRes = pIGr->get_LineStyle(&pLineSt);
  1424.         if (SUCCEEDED(hRes))
  1425.         {
  1426.             long lID = 0;
  1427.             hRes = pLineSt->get__TableEntryID(&lID);
  1428.             if (((short)lID) > 0)
  1429.             {
  1430.                 hRes = pLineSt->get_Index(&lIndex);
  1431.                 CHECK_HRESULT(hRes)
  1432.  
  1433.                 pLineSt->Release();
  1434.                 pLyr = NULL;
  1435.  
  1436.                 if (m_mapLineStyles.Lookup(lIndex, pLineSt))
  1437.                 {
  1438.                     varLineSt.vt = VT_DISPATCH;
  1439.                     varLineSt.pdispVal = (IDispatch *)pLineSt;
  1440.                     pLineSt->AddRef();
  1441.                 }
  1442.                 else
  1443.                     varLineSt = bstrDefLineSt;
  1444.  
  1445.                 hRes = pIGr->put_LineStyle(varLineSt);
  1446.             }
  1447.         }
  1448.  
  1449.         hRes = pIGr->get_BrushStyle(&pBrushSt);
  1450.         if (SUCCEEDED(hRes))
  1451.         {
  1452.             long lID = 0;
  1453.             hRes = pBrushSt->get__TableEntryID(&lID);
  1454.             if (((short)lID) > 0)
  1455.             {
  1456.                 hRes = pBrushSt->get_Index(&lIndex);
  1457.                 if (SUCCEEDED(hRes))
  1458.                 {
  1459.                     pBrushSt->Release();
  1460.                     pLyr = NULL;
  1461.  
  1462.                     if (m_mapBrushStyles.Lookup(lIndex, pBrushSt))
  1463.                     {
  1464.                         varLineSt.vt = VT_DISPATCH;
  1465.                         varLineSt.pdispVal = (IDispatch *)pBrushSt;
  1466.                         pBrushSt->AddRef();
  1467.                     }
  1468.                     else
  1469.                         varBrushSt = bstrDefBrushSt;
  1470.                 }
  1471.                 else
  1472.                     varBrushSt = bstrDefBrushSt;
  1473.  
  1474.                 hRes = pIGr->put_BrushStyle(varBrushSt);
  1475.             }
  1476.         }
  1477.  
  1478.         hRes = pIGr->get_Type(&bstrType);
  1479.         CHECK_HRESULT(hRes)
  1480.  
  1481.         cstrType = bstrType;
  1482.         if (cstrType.CompareNoCase("Insert") == 0)//# Non-localizable string#
  1483.         {
  1484.             if (bCorrectInserts)
  1485.             {
  1486.                 hRes = pIGr->get_Block(&pBlkSrc);
  1487.                 CHECK_HRESULT(hRes)
  1488.  
  1489.                 long lIndex = 0;
  1490.                 hRes = pBlkSrc->get_Index(&lIndex);
  1491.                 CHECK_HRESULT(hRes)
  1492.  
  1493.                 if (m_mapBlks.Lookup(lIndex, pBlkTrg))
  1494.                 {
  1495.                     hRes = pIGr->put_Block(pBlkTrg);
  1496.                     CHECK_HRESULT(hRes)
  1497.                 }
  1498.             }
  1499.         }
  1500.         else
  1501.         {
  1502.             
  1503.             if (cstrType.CompareNoCase("Group") == 0)
  1504.             {
  1505.                 hRes = pIGr->get_Graphics(&pGrs);
  1506.                 CHECK_HRESULT(hRes)
  1507.  
  1508.                 long lCount = 0;
  1509.                 long lItem = 0;
  1510.                 COleVariant varItem(lItem);
  1511.  
  1512.                 hRes = pGrs->get_Count(&lCount);
  1513.                 CHECK_HRESULT(hRes)
  1514.  
  1515.                 for (lItem = 0; lItem < lCount; lItem++)
  1516.                 {
  1517.                     varItem = lItem;
  1518.                     hRes = pGrs->get_Item(&varItem, &pIGrC);
  1519.                     CHECK_HRESULT(hRes)
  1520.  
  1521.                     short iCosm = 0;
  1522.                     hRes = pIGrC->get_Cosmetic(&iCosm);
  1523.                     if (!iCosm)
  1524.                     {
  1525.                         hRes = CorrectGraphic(pIGrC);
  1526.                         CHECK_HRESULT(hRes)
  1527.                     }
  1528.                     pIGrC->Release();
  1529.                     pIGrC = NULL;
  1530.                 }
  1531.             }
  1532.         }
  1533.     }
  1534.     catch (...)
  1535.     {
  1536.         _clearfp();
  1537.     }
  1538.  
  1539.     varLayer.Clear();
  1540.  
  1541.     if (pBlkSrc != NULL)
  1542.         pBlkSrc->Release();
  1543.  
  1544.     if (pIGrC != NULL)
  1545.         pIGrC->Release();
  1546.  
  1547.     if (pGrs != NULL)
  1548.         pGrs->Release();
  1549.  
  1550.     return hRes;
  1551. }
  1552.  
  1553.