home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / inole2 / chap12 / cosmo / document.cpp < prev    next >
C/C++ Source or Header  |  1995-05-03  |  21KB  |  986 lines
  1. /*
  2.  * DOCUMENT.CPP
  3.  * Cosmo Chapter 12
  4.  *
  5.  * Implementation of the CCosmoDoc derivation of CDocument as
  6.  * well as an implementation of CPolylineAdviseSink.
  7.  *
  8.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  9.  *
  10.  * Kraig Brockschmidt, Microsoft
  11.  * Internet  :  kraigb@microsoft.com
  12.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  13.  */
  14.  
  15.  
  16. #include "cosmo.h"
  17.  
  18.  
  19. /*
  20.  * CCosmoDoc::CCosmoDoc
  21.  * CCosmoDoc::~CCosmoDoc
  22.  *
  23.  * Constructor Parameters:
  24.  *  hInst           HINSTANCE of the application.
  25.  *  pFR             PCFrame of the frame object.
  26.  *  pAdv            PCDocumentAdviseSink to notify on events
  27.  */
  28.  
  29. CCosmoDoc::CCosmoDoc(HINSTANCE hInst, PCFrame pFR
  30.     , PCDocumentAdviseSink pAdv)
  31.     : CDocument(hInst, pFR, pAdv)
  32.     {
  33.     m_pPL=NULL;
  34.     m_pPLAdv=NULL;
  35.     m_uPrevSize=SIZE_RESTORED;
  36.     return;
  37.     }
  38.  
  39.  
  40. CCosmoDoc::~CCosmoDoc(void)
  41.     {
  42.     //Clean up the allocations we did in Init
  43.     if (NULL!=m_pPL)
  44.         delete m_pPL;
  45.  
  46.     if (NULL!=m_pPLAdv)
  47.         delete m_pPLAdv;
  48.  
  49.     return;
  50.     }
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57. /*
  58.  * CCosmoDoc::Init
  59.  *
  60.  * Purpose:
  61.  *  Initializes an already created document window.  The client
  62.  *  actually creates the window for us, then passes that here for
  63.  *  further initialization.
  64.  *
  65.  * Parameters:
  66.  *  pDI             PDOCUMENTINIT containing initialization
  67.  *                  parameters.
  68.  *
  69.  * Return Value:
  70.  *  BOOL            TRUE if the function succeeded, FALSE otherwise.
  71.  */
  72.  
  73. BOOL CCosmoDoc::Init(PDOCUMENTINIT pDI)
  74.     {
  75.     RECT        rc;
  76.  
  77.     //Change the stringtable range to our customization.
  78.     pDI->idsMin=IDS_DOCUMENTMIN;
  79.     pDI->idsMax=IDS_DOCUMENTMAX;
  80.  
  81.     //Do default initialization
  82.     if (!CDocument::Init(pDI))
  83.         return FALSE;
  84.  
  85.     //Add the Polyline stuff we need.
  86.     m_pPLAdv=new CPolylineAdviseSink(this);
  87.     m_pPL   =new CPolyline(m_hInst);
  88.  
  89.     //Attempt to create our contained Polyline.
  90.     GetClientRect(m_hWnd, &rc);
  91.     InflateRect(&rc, -8, -8);
  92.  
  93.     if (!m_pPL->Init(m_hWnd, &rc, WS_CHILD | WS_VISIBLE
  94.         , ID_POLYLINE, m_pPLAdv))
  95.         return FALSE;
  96.  
  97.     return TRUE;
  98.     }
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106. /*
  107.  * CCosmoDoc::FMessageHook
  108.  *
  109.  * Purpose:
  110.  *  Processes WM_SIZE for the document so we can resize
  111.  *  the Polyline.
  112.  *
  113.  * Parameters:
  114.  *  <WndProc Parameters>
  115.  *  pLRes           LRESULT * in which to store the return
  116.  *                  value for the message.
  117.  *
  118.  * Return Value:
  119.  *  BOOL            TRUE to prevent further processing,
  120.  *                  FALSE otherwise.
  121.  */
  122.  
  123. BOOL CCosmoDoc::FMessageHook(HWND hWnd, UINT iMsg, WPARAM wParam
  124.     , LPARAM lParam, LRESULT *pLRes)
  125.     {
  126.     UINT        dx, dy;
  127.     RECT        rc;
  128.  
  129.     *pLRes=0;
  130.  
  131.     if (WM_SIZE==iMsg)
  132.         {
  133.         //Don't effect the Polyline size to or from minimized state.
  134.         if (SIZE_MINIMIZED!=wParam && SIZE_MINIMIZED !=m_uPrevSize)
  135.             {
  136.             //When we change size, resize any Polyline we hold.
  137.             dx=LOWORD(lParam);
  138.             dy=HIWORD(lParam);
  139.  
  140.             /*
  141.              * If we are getting WM_SIZE in response to a Polyline
  142.              * notification, then don't resize the Polyline window
  143.              * again.
  144.              */
  145.             if (!m_fNoSize && NULL!=m_pPL)
  146.                 {
  147.                 //Resize the polyline to fit the new client
  148.                 SetRect(&rc, 8, 8, dx-8, dy-8);
  149.                 m_pPL->RectSet(&rc, FALSE);
  150.  
  151.                 /*
  152.                  * We consider sizing something that makes the file
  153.                  * dirty, but not until we've finished the create
  154.                  * process, which is why we set fNoDirty to FALSE
  155.                  * in WM_CREATE since we get a WM_SIZE on the first
  156.                  * creation.
  157.                  */
  158.                 if (!m_fNoDirty)
  159.                     FDirtySet(TRUE);
  160.  
  161.                 SetRect(&rc, 0, 0, dx, dy);
  162.  
  163.                 if (NULL!=m_pAdv)
  164.                     m_pAdv->OnSizeChange(this, &rc);
  165.  
  166.                 m_fNoDirty=FALSE;
  167.                 }
  168.             }
  169.  
  170.         m_uPrevSize=wParam;
  171.         }
  172.  
  173.     /*
  174.      * We return FALSE even on WM_SIZE so we can let the default
  175.      * procedure handle maximized MDI child windows appropriately.
  176.      */
  177.     return FALSE;
  178.     }
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187. /*
  188.  * CCosmoDoc::Clear
  189.  *
  190.  * Purpose:
  191.  *  Sets all contents in the document back to defaults with
  192.  *  no filename.
  193.  *
  194.  * Paramters:
  195.  *  None
  196.  *
  197.  * Return Value:
  198.  *  None
  199.  */
  200.  
  201. void CCosmoDoc::Clear(void)
  202.     {
  203.     //Completely reset the polyline
  204.     m_pPL->New();
  205.  
  206.     CDocument::Clear();
  207.     m_lVer=0;
  208.     return;
  209.     }
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216. /*
  217.  * CCosmoDoc::Load
  218.  *
  219.  * Purpose:
  220.  *  Loads a given document without any user interface overwriting
  221.  *  the previous contents of the Polyline window.  We do this by
  222.  *  opening the file and telling the Polyline to load itself from
  223.  *  that file.
  224.  *
  225.  * Parameters:
  226.  *  fChangeFile     BOOL indicating if we're to update the window
  227.  *                  title and the filename from using this file.
  228.  *  pszFile         LPTSTR to the filename to load, NULL if the file
  229.  *                  is new and untitled.
  230.  *
  231.  * Return Value:
  232.  *  UINT            An error value from DOCERR_*
  233.  */
  234.  
  235. UINT CCosmoDoc::Load(BOOL fChangeFile, LPTSTR pszFile)
  236.     {
  237.     HRESULT         hr;
  238.     LPSTORAGE       pIStorage;
  239.  
  240.     if (NULL==pszFile)
  241.         {
  242.         //For a new untitled document, just rename ourselves.
  243.         Rename(NULL);
  244.         m_lVer=VERSIONCURRENT;
  245.         return DOCERR_NONE;
  246.         }
  247.  
  248.     /*
  249.      * If not a Compound File, open the file using STGM_CONVERT in
  250.      * transacted mode to see old files as a storage with one stream
  251.      * called "CONTENTS" (which is conveniently the name we use
  252.      * in the new files).  We must use STGM_TRANSACTED here or else
  253.      * the old file will be immediately converted on disk:  we only
  254.      * want a converted image in memory from which to read.  In
  255.      * addition, note that we need STGM_READWRITE as well since
  256.      * conversion is inherently a write operation.
  257.      */
  258.  
  259.     pIStorage=NULL;
  260.  
  261.     if (NOERROR!=StgIsStorageFile(pszFile))
  262.         {
  263.         hr=StgCreateDocfile(pszFile,STGM_TRANSACTED | STGM_READWRITE
  264.             | STGM_CONVERT | STGM_SHARE_EXCLUSIVE, 0, &pIStorage);
  265.  
  266.         if (FAILED(hr))
  267.             {
  268.             //If denied write access, try to load the old way
  269.             if (STG_E_ACCESSDENIED==GetScode(hr))
  270.                 m_lVer=m_pPL->ReadFromFile(pszFile);
  271.             else
  272.                 return DOCERR_COULDNOTOPEN;
  273.             }
  274.         }
  275.     else
  276.         {
  277.         hr=StgOpenStorage(pszFile, NULL, STGM_DIRECT | STGM_READ
  278.             | STGM_SHARE_EXCLUSIVE, NULL, 0, &pIStorage);
  279.  
  280.         if (FAILED(hr))
  281.             return DOCERR_COULDNOTOPEN;
  282.         }
  283.  
  284.     if (NULL!=pIStorage)
  285.         {
  286.         m_lVer=m_pPL->ReadFromStorage(pIStorage);
  287.         pIStorage->Release();
  288.         }
  289.  
  290.     if (POLYLINE_E_READFAILURE==m_lVer)
  291.         return DOCERR_READFAILURE;
  292.  
  293.     if (POLYLINE_E_UNSUPPORTEDVERSION==m_lVer)
  294.         return DOCERR_UNSUPPORTEDVERSION;
  295.  
  296.     if (fChangeFile)
  297.         Rename(pszFile);
  298.  
  299.     //Importing a file makes things dirty
  300.     FDirtySet(!fChangeFile);
  301.  
  302.     return DOCERR_NONE;
  303.     }
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311. /*
  312.  * CCosmoDoc::Save
  313.  *
  314.  * Purpose:
  315.  *  Writes the file to a known filename, requiring that the user has
  316.  *  previously used FileOpen or FileSaveAs to provide a filename.
  317.  *
  318.  * Parameters:
  319.  *  uType           UINT indicating the type of file the user
  320.  *                  requested to save in the File Save As dialog.
  321.  *  pszFile         LPTSTR under which to save.  If NULL, use the
  322.  *                  current name.
  323.  *
  324.  * Return Value:
  325.  *  UINT            An error value from DOCERR_*
  326.  */
  327.  
  328. UINT CCosmoDoc::Save(UINT uType, LPTSTR pszFile)
  329.     {
  330.     LONG        lVer, lRet;
  331.     UINT        uTemp;
  332.     BOOL        fRename=TRUE;
  333.     HRESULT     hr;
  334.     LPSTORAGE   pIStorage;
  335.  
  336.     if (NULL==pszFile)
  337.         {
  338.         fRename=FALSE;
  339.         pszFile=m_szFile;
  340.         }
  341.  
  342.     /*
  343.      * Type 1 is the current version, type 2 is version 1.0 of the
  344.      * Polyline so we use this to send the right version to
  345.      * CPolyline::WriteToFile/WriteToStorage.
  346.      */
  347.  
  348.     switch (uType)
  349.         {
  350.         case 0:         //From Save, use loaded version.
  351.             lVer=m_lVer;
  352.             break;
  353.  
  354.         case 1:
  355.             lVer=VERSIONCURRENT;
  356.             break;
  357.  
  358.         case 2:
  359.             lVer=MAKELONG(0, 1);    //1.0
  360.             break;
  361.  
  362.         default:
  363.             return DOCERR_UNSUPPORTEDVERSION;
  364.         }
  365.  
  366.     /*
  367.      * If the version the user wants to save is different from the
  368.      * version that we loaded and m_lVer is not zero (new doc),
  369.      * then inform the user of the version change and verify.
  370.      */
  371.     if (0!=m_lVer && m_lVer!=lVer)
  372.         {
  373.         TCHAR       szMsg[128];
  374.  
  375.         wsprintf(szMsg, PSZ(IDS_VERSIONCHANGE)
  376.             , (UINT)HIWORD(m_lVer), (UINT)LOWORD(m_lVer)
  377.             , (UINT)HIWORD(lVer), (UINT)LOWORD(lVer));
  378.  
  379.         uTemp=MessageBox(m_hWnd, szMsg, PSZ(IDS_DOCUMENTCAPTION)
  380.             , MB_YESNOCANCEL);
  381.  
  382.         if (IDCANCEL==uTemp)
  383.             return DOCERR_CANCELLED;
  384.  
  385.         //If the user won't upgrade, revert to loaded version.
  386.         if (IDNO==uTemp)
  387.             lVer=m_lVer;
  388.         }
  389.  
  390.     /*
  391.      * For 1.0 files, still use the old code.  For new files, use
  392.      * storages instead
  393.      */
  394.     if (lVer==MAKELONG(0, 1))
  395.         lRet=m_pPL->WriteToFile(pszFile, lVer);
  396.     else
  397.         {
  398.         hr=StgCreateDocfile(pszFile, STGM_DIRECT | STGM_READWRITE
  399.             | STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &pIStorage);
  400.  
  401.         if (FAILED(hr))
  402.             return DOCERR_COULDNOTOPEN;
  403.  
  404.         //Mark this as one of our class
  405.         WriteClassStg(pIStorage, CLSID_CosmoFigure);
  406.  
  407.         //Write user-readable class information
  408.         WriteFmtUserTypeStg(pIStorage, m_cf
  409.             , PSZ(IDS_CLIPBOARDFORMAT));
  410.  
  411.         lRet=m_pPL->WriteToStorage(pIStorage, lVer);
  412.         pIStorage->Release();
  413.         }
  414.  
  415.     if (POLYLINE_E_NONE!=lRet)
  416.         return DOCERR_WRITEFAILURE;
  417.  
  418.     //Saving makes us clean
  419.     FDirtySet(FALSE);
  420.  
  421.     //Update the known version of this document.
  422.     m_lVer=lVer;
  423.  
  424.     if (fRename)
  425.         Rename(pszFile);
  426.  
  427.     return DOCERR_NONE;
  428.     }
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435. /*
  436.  * CCosmoDoc::Undo
  437.  *
  438.  * Purpose:
  439.  *  Reverses a previous action.
  440.  *
  441.  * Parameters:
  442.  *  None
  443.  *
  444.  * Return Value:
  445.  *  None
  446.  */
  447.  
  448. void CCosmoDoc::Undo(void)
  449.     {
  450.     m_pPL->Undo();
  451.     return;
  452.     }
  453.  
  454.  
  455.  
  456.  
  457.  
  458.  
  459. /*
  460.  * CCosmoDoc::Clip
  461.  *
  462.  * Purpose:
  463.  *  Places a private format, a metafile, and a bitmap of the display
  464.  *  on the clipboard, optionally implementing Cut by deleting the
  465.  *  data in the current window after rendering.
  466.  *
  467.  * Parameters:
  468.  *  hWndFrame       HWND of the main window.
  469.  *  fCut            BOOL indicating cut (TRUE) or copy (FALSE).
  470.  *
  471.  * Return Value:
  472.  *  BOOL            TRUE if successful, FALSE otherwise.
  473.  */
  474.  
  475. BOOL CCosmoDoc::Clip(HWND hWndFrame, BOOL fCut)
  476.     {
  477.     BOOL            fRet=TRUE;
  478.     HGLOBAL         hMem;
  479.     UINT            i;
  480.     static UINT     rgcf[3]={0, CF_METAFILEPICT, CF_BITMAP};
  481.     const UINT      cFormats=3;
  482.  
  483.     //CHAPTER12MOD
  484.     static DWORD    rgtm[3]={TYMED_HGLOBAL, TYMED_MFPICT, TYMED_GDI};
  485.     LPDATAOBJECT    pIDataObject;
  486.     HRESULT         hr;
  487.     STGMEDIUM       stm;
  488.     FORMATETC       fe;
  489.  
  490.     hr=CoCreateInstance(CLSID_DataTransferObject
  491.         , NULL, CLSCTX_INPROC_SERVER
  492.         , IID_IDataObject, (PPVOID)&pIDataObject);
  493.  
  494.     if (FAILED(hr))
  495.         return NULL;
  496.     //End CHAPTER12MOD
  497.  
  498.     rgcf[0]=m_cf;
  499.  
  500.     for (i=0; i < cFormats; i++)
  501.         {
  502.         //Copy private data first.
  503.         hMem=RenderFormat(rgcf[i]);
  504.  
  505.         if (NULL!=hMem)
  506.             {
  507.             //CHAPTER12MOD
  508.             stm.hGlobal=hMem;
  509.             stm.tymed=rgtm[i];
  510.             stm.pUnkForRelease=NULL;
  511.  
  512.             SETDefFormatEtc(fe, rgcf[i], rgtm[i]);
  513.             pIDataObject->SetData(&fe, &stm, TRUE);
  514.             //End CHAPTER12MOD
  515.             }
  516.         }
  517.  
  518.     //CHAPTER12MOD
  519.     fRet=SUCCEEDED(OleSetClipboard(pIDataObject));
  520.     pIDataObject->Release();
  521.     //End CHAPTER12MOD
  522.  
  523.     //Delete our current data if "cut" succeeded.
  524.     if (fRet && fCut)
  525.         {
  526.         m_pPL->New();
  527.         FDirtySet(TRUE);
  528.         }
  529.  
  530.     return fRet;
  531.     }
  532.  
  533.  
  534.  
  535.  
  536.  
  537. /*
  538.  * CCosmoDoc::RenderFormat
  539.  *
  540.  * Purpose:
  541.  *  Renders a specific clipboard format into global memory.
  542.  *
  543.  * Parameters:
  544.  *  cf              UINT format to render.
  545.  *
  546.  * Return Value:
  547.  *  HGLOBAL         Global memory handle containing the data.
  548.  */
  549.  
  550. HGLOBAL CCosmoDoc::RenderFormat(UINT cf)
  551.     {
  552.     HGLOBAL     hMem;
  553.  
  554.     if (cf==m_cf)
  555.         {
  556.         m_pPL->DataGetMem(VERSIONCURRENT, &hMem);
  557.         return hMem;
  558.         }
  559.  
  560.     switch (cf)
  561.         {
  562.         case CF_METAFILEPICT:
  563.             return m_pPL->RenderMetafilePict();
  564.  
  565.         case CF_BITMAP:
  566.             return (HGLOBAL)m_pPL->RenderBitmap();
  567.         }
  568.  
  569.     return NULL;
  570.     }
  571.  
  572.  
  573.  
  574.  
  575.  
  576.  
  577.  
  578. /*
  579.  * CCosmoDoc::FQueryPaste
  580.  *
  581.  * Purpose:
  582.  *  Determines if we can paste data from the clipboard.
  583.  *
  584.  * Parameters:
  585.  *  None
  586.  *
  587.  * Return Value:
  588.  *  BOOL            TRUE if data is available, FALSE otherwise.
  589.  */
  590.  
  591. BOOL CCosmoDoc::FQueryPaste(void)
  592.     {
  593.     //CHAPTER12MOD
  594.     LPDATAOBJECT    pIDataObject;
  595.     BOOL            fRet;
  596.  
  597.     if (FAILED(OleGetClipboard(&pIDataObject)))
  598.         return FALSE;
  599.  
  600.     fRet=FQueryPasteFromData(pIDataObject);
  601.     pIDataObject->Release();
  602.     return fRet;
  603.     //End CHAPTER12MOD
  604.     }
  605.  
  606.  
  607.  
  608. //CHAPTER12MOD
  609. /*
  610.  * CCosmoDoc::FQueryPasteFromData
  611.  * (Protected)
  612.  *
  613.  * Purpose:
  614.  *  Determines if we can paste data from a data object.
  615.  *
  616.  * Parameters:
  617.  *  pIDataObject    LPDATAOBJECT from which we might want to paste.
  618.  *
  619.  * Return Value:
  620.  *  BOOL            TRUE if data is available, FALSE otherwise.
  621.  */
  622.  
  623. BOOL CCosmoDoc::FQueryPasteFromData(LPDATAOBJECT pIDataObject)
  624.     {
  625.     FORMATETC       fe;
  626.  
  627.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  628.     return (NOERROR==pIDataObject->QueryGetData(&fe));
  629.     }
  630. //End CHAPTER12MOD
  631.  
  632.  
  633.  
  634.  
  635. /*
  636.  * CCosmoDoc::Paste
  637.  *
  638.  * Purpose:
  639.  *  Retrieves the private data format from the clipboard and sets it
  640.  *  to the current figure in the editor window.
  641.  *
  642.  *  Note that if this function is called, then the clipboard format
  643.  *  is available because the Paste menu item is only enabled if the
  644.  *  format is present.
  645.  *
  646.  * Parameters:
  647.  *  hWndFrame       HWND of the main window.
  648.  *
  649.  * Return Value:
  650.  *  BOOL            TRUE if successful, FALSE otherwise.
  651.  */
  652.  
  653. BOOL CCosmoDoc::Paste(HWND hWndFrame)
  654.     {
  655.     //CHAPTER12MOD
  656.     LPDATAOBJECT    pIDataObject;
  657.     BOOL            fRet;
  658.  
  659.     if (FAILED(OleGetClipboard(&pIDataObject)))
  660.         return FALSE;
  661.  
  662.     fRet=PasteFromData(pIDataObject);
  663.     pIDataObject->Release();
  664.  
  665.     //End CHAPTER12MOD
  666.     return fRet;
  667.     }
  668.  
  669.  
  670.  
  671.  
  672. //CHAPTER12MOD
  673. /*
  674.  * CCosmoDoc::PasteFromData
  675.  * (Protected)
  676.  *
  677.  * Purpose:
  678.  *  Retrieves the private data format from a data object and sets
  679.  *  it to the current figure in the editor window.
  680.  *
  681.  * Parameters:
  682.  *  pIDataObject    LPDATAOBJECT from which to paste.
  683.  *
  684.  * Return Value:
  685.  *  BOOL            TRUE if successful, FALSE otherwise.
  686.  */
  687.  
  688. BOOL CCosmoDoc::PasteFromData(LPDATAOBJECT pIDataObject)
  689.     {
  690.     FORMATETC       fe;
  691.     STGMEDIUM       stm;
  692.     BOOL            fRet;
  693.  
  694.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  695.     fRet=SUCCEEDED(pIDataObject->GetData(&fe, &stm));
  696.  
  697.     if (fRet && NULL!=stm.hGlobal)
  698.         {
  699.         m_pPL->DataSetMem(stm.hGlobal, FALSE, FALSE, TRUE);
  700.         ReleaseStgMedium(&stm);
  701.         FDirtySet(TRUE);
  702.         }
  703.  
  704.     return fRet;
  705.     }
  706. //End CHAPTER12MOD
  707.  
  708.  
  709.  
  710.  
  711. /*
  712.  * CCosmoDoc::ColorSet
  713.  *
  714.  * Purpose:
  715.  *  Changes a color used in our contained Polyline.
  716.  *
  717.  * Parameters:
  718.  *  iColor          UINT index of the color to change.
  719.  *  cr              COLORREF new color.
  720.  *
  721.  * Return Value:
  722.  *  COLORREF        Previous color for the given index.
  723.  */
  724.  
  725. COLORREF CCosmoDoc::ColorSet(UINT iColor, COLORREF cr)
  726.     {
  727.     return m_pPL->ColorSet(iColor, cr);
  728.     }
  729.  
  730.  
  731.  
  732.  
  733.  
  734. /*
  735.  * CCosmoDoc::ColorGet
  736.  *
  737.  * Purpose:
  738.  *  Retrieves a color currently in use in the Polyline.
  739.  *
  740.  * Parameters:
  741.  *  iColor          UINT index of the color to retrieve.
  742.  *
  743.  * Return Value:
  744.  *  COLORREF        Current color for the given index.
  745.  */
  746.  
  747. COLORREF CCosmoDoc::ColorGet(UINT iColor)
  748.     {
  749.     return m_pPL->ColorGet(iColor);
  750.     }
  751.  
  752.  
  753.  
  754.  
  755.  
  756.  
  757. /*
  758.  * CCosmoDoc::LineStyleSet
  759.  *
  760.  * Purpose:
  761.  *  Changes the line style currently used in the Polyline
  762.  *
  763.  * Parameters:
  764.  *  iStyle          UINT index of the new line style to use.
  765.  *
  766.  * Return Value:
  767.  *  UINT            Previous line style.
  768.  */
  769.  
  770.  
  771. UINT CCosmoDoc::LineStyleSet(UINT iStyle)
  772.     {
  773.     return m_pPL->LineStyleSet(iStyle);
  774.     }
  775.  
  776.  
  777.  
  778.  
  779.  
  780.  
  781.  
  782. /*
  783.  * CCosmoDoc::LineStyleGet
  784.  *
  785.  * Purpose:
  786.  *  Retrieves the line style currently used in the Polyline
  787.  *
  788.  * Parameters:
  789.  *  None
  790.  *
  791.  * Return Value:
  792.  *  UINT            Current line style.
  793.  */
  794.  
  795.  
  796. UINT CCosmoDoc::LineStyleGet(void)
  797.     {
  798.     if (NULL==m_pPL)    //m_pPL might not be valid yet
  799.         return 0L;
  800.  
  801.     return m_pPL->LineStyleGet();
  802.     }
  803.  
  804.  
  805.  
  806.  
  807.  
  808.  
  809.  
  810.  
  811. /*
  812.  * CPolylineAdviseSink::CPolylineAdviseSink
  813.  * CPolylineAdviseSink::~CPolylineAdviseSink
  814.  *
  815.  * Constructor Parameters:
  816.  *  pv              LPVOID to store in this object
  817.  */
  818.  
  819. CPolylineAdviseSink::CPolylineAdviseSink(LPVOID pv)
  820.     {
  821.     m_pv=pv;
  822.     return;
  823.     }
  824.  
  825.  
  826. CPolylineAdviseSink::~CPolylineAdviseSink(void)
  827.     {
  828.     return;
  829.     }
  830.  
  831.  
  832.  
  833.  
  834.  
  835. /*
  836.  * CPolylineAdviseSink::OnPointChange
  837.  *
  838.  * Purpose:
  839.  *  Informs the document that the polyline added or removed a point.
  840.  *
  841.  * Parameters:
  842.  *  None
  843.  *
  844.  * Return Value:
  845.  *  None
  846.  */
  847.  
  848. void CPolylineAdviseSink::OnPointChange(void)
  849.     {
  850.     PCDocument      pDoc=(PCDocument)m_pv;
  851.  
  852.     pDoc->FDirtySet(TRUE);
  853.     return;
  854.     }
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861. /*
  862.  * CPolylineAdviseSink::OnSizeChange
  863.  *
  864.  * Purpose:
  865.  *  Informs the document that the polyline changed size.
  866.  *
  867.  * Parameters:
  868.  *  None
  869.  *
  870.  * Return Value:
  871.  *  None
  872.  */
  873.  
  874. void CPolylineAdviseSink::OnSizeChange(void)
  875.     {
  876.     PCCosmoDoc      pDoc=(PCCosmoDoc)m_pv;
  877.     RECT            rc;
  878.     DWORD           dwStyle;
  879.  
  880.     /*
  881.      * Polyline window is informing us that it changed size in
  882.      * response to setting it's data.  Therefore we have to
  883.      * size ourselves accordingly but without moving the screen
  884.      * position of the polyline window.
  885.      */
  886.  
  887.     pDoc->m_fNoSize=TRUE;
  888.  
  889.     //Set the document window size.
  890.     GetWindowRect(pDoc->m_pPL->Window(), &rc);
  891.     InflateRect(&rc, 8, 8);
  892.  
  893.     //Adjust for a window sans menu
  894.     dwStyle=GetWindowLong(pDoc->m_hWnd, GWL_STYLE);
  895.     AdjustWindowRect(&rc, dwStyle, FALSE);
  896.  
  897.     SetWindowPos(pDoc->m_hWnd, NULL, 0, 0, rc.right-rc.left
  898.         , rc.bottom-rc.top, SWP_NOMOVE | SWP_NOZORDER);
  899.  
  900.     if (NULL!=pDoc->m_pAdv)
  901.         pDoc->m_pAdv->OnSizeChange(pDoc, &rc);
  902.  
  903.     pDoc->m_fNoSize=FALSE;
  904.     pDoc->FDirtySet(TRUE);
  905.  
  906.     return;
  907.     }
  908.  
  909.  
  910.  
  911.  
  912.  
  913. /*
  914.  * CPolylineAdviseSink::OnDataChange
  915.  *
  916.  * Purpose:
  917.  *  Informs the document that the polyline data changed.
  918.  *
  919.  * Parameters:
  920.  *  None
  921.  *
  922.  * Return Value:
  923.  *  None
  924.  */
  925.  
  926. void CPolylineAdviseSink::OnDataChange(void)
  927.     {
  928.     PCCosmoDoc      pDoc=(PCCosmoDoc)m_pv;
  929.  
  930.     if (NULL!=pDoc->m_pAdv)
  931.         pDoc->m_pAdv->OnDataChange(pDoc);
  932.  
  933.     pDoc->FDirtySet(TRUE);
  934.     return;
  935.     }
  936.  
  937.  
  938.  
  939.  
  940.  
  941. /*
  942.  * CPolylineAdviseSink::OnColorChange
  943.  *
  944.  * Purpose:
  945.  *  Informs the document that the polyline data changed a color.
  946.  *
  947.  * Parameters:
  948.  *  None
  949.  *
  950.  * Return Value:
  951.  *  None
  952.  */
  953.  
  954. void CPolylineAdviseSink::OnColorChange(void)
  955.     {
  956.     PCCosmoDoc      pDoc=(PCCosmoDoc)m_pv;
  957.  
  958.     pDoc->FDirtySet(TRUE);
  959.     return;
  960.     }
  961.  
  962.  
  963.  
  964.  
  965.  
  966. /*
  967.  * CPolylineAdviseSink::OnLineStyleChange
  968.  *
  969.  * Purpose:
  970.  *  Informs the document that the polyline changed its line style.
  971.  *
  972.  * Parameters:
  973.  *  None
  974.  *
  975.  * Return Value:
  976.  *  None
  977.  */
  978.  
  979. void CPolylineAdviseSink::OnLineStyleChange(void)
  980.     {
  981.     PCCosmoDoc      pDoc=(PCCosmoDoc)m_pv;
  982.  
  983.     pDoc->FDirtySet(TRUE);
  984.     return;
  985.     }
  986.