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 / chap05 / cocosmo / document.cpp < prev    next >
C/C++ Source or Header  |  1995-05-03  |  18KB  |  911 lines
  1. /*
  2.  * DOCUMENT.CPP
  3.  * Component Cosmo Chapter 5
  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 "cocosmo.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.  
  37.     //CHAPTER5MOD
  38.     m_pIConnectPt=NULL;
  39.     m_dwCookie=0;
  40.     //End CHAPTER5MOD
  41.     return;
  42.     }
  43.  
  44.  
  45. CCosmoDoc::~CCosmoDoc(void)
  46.     {
  47.     //CHAPTER5MOD
  48.     if (NULL!=m_pIConnectPt)
  49.         {
  50.         m_pIConnectPt->Unadvise(m_dwCookie);
  51.         ReleaseInterface(m_pIConnectPt);
  52.         }
  53.  
  54.     ReleaseInterface(m_pPL);
  55.     ReleaseInterface(m_pPLAdv);
  56.  
  57.     CoFreeUnusedLibraries();
  58.     //End CHAPTER5MOD
  59.  
  60.     //The client takes care of destroying document windows.
  61.     return;
  62.     }
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69. /*
  70.  * CCosmoDoc::Init
  71.  *
  72.  * Purpose:
  73.  *  Initializes an already created document window.  The client
  74.  *  actually creates the window for us, then passes that here for
  75.  *  further initialization.
  76.  *
  77.  * Parameters:
  78.  *  pDI             PDOCUMENTINIT containing initialization
  79.  *                  parameters.
  80.  *
  81.  * Return Value:
  82.  *  BOOL            TRUE if the function succeeded, FALSE otherwise.
  83.  */
  84.  
  85. BOOL CCosmoDoc::Init(PDOCUMENTINIT pDI)
  86.     {
  87.     RECT                        rc;
  88.     HRESULT                     hr;
  89.     //CHAPTER5MOD
  90.     IConnectionPointContainer  *pCPC;
  91.     //EndCHAPTER5MOD
  92.  
  93.     //Change the stringtable range to our customization.
  94.     pDI->idsMin=IDS_DOCUMENTMIN;
  95.     pDI->idsMax=IDS_DOCUMENTMAX;
  96.  
  97.     //Do default initialization
  98.     if (!CDocument::Init(pDI))
  99.         return FALSE;
  100.  
  101.     //CHAPTER5MOD
  102.     //Create the Polyline component
  103.     hr=CoCreateInstance(CLSID_Polyline5, NULL, CLSCTX_INPROC_SERVER
  104.         , IID_IPolyline5, (PPVOID)&m_pPL);
  105.  
  106.     if (FAILED(hr))
  107.         {
  108.         //Warn that we could not load the Polyline
  109.         MessageBox(pDI->hWndDoc, PSZ(IDS_NOPOLYLINE)
  110.             , PSZ(IDS_CAPTION), MB_OK);
  111.         return FALSE;
  112.         }
  113.  
  114.     //Initialize the contained Polyline which creates a window.
  115.     GetClientRect(m_hWnd, &rc);
  116.     InflateRect(&rc, -8, -8);
  117.  
  118.     if (FAILED(m_pPL->Init(m_hWnd, &rc, WS_CHILD | WS_VISIBLE
  119.         , ID_POLYLINE)))
  120.         return FALSE;
  121.  
  122.     //Set up an advise on the Polyline.
  123.     m_pPLAdv=new CPolylineAdviseSink(this);
  124.     m_pPLAdv->AddRef();
  125.  
  126.     if (SUCCEEDED(m_pPL->QueryInterface(IID_IConnectionPointContainer
  127.         , (PPVOID)&pCPC)))
  128.         {
  129.         if (SUCCEEDED(pCPC->FindConnectionPoint
  130.             (IID_IPolylineAdviseSink5, &m_pIConnectPt)))
  131.             {
  132.             m_pIConnectPt->Advise((LPUNKNOWN)m_pPLAdv, &m_dwCookie);
  133.             }
  134.  
  135.         pCPC->Release();
  136.         }
  137.     //End CHAPTER5MOD
  138.  
  139.     return TRUE;
  140.     }
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148. /*
  149.  * CCosmoDoc::FMessageHook
  150.  *
  151.  * Purpose:
  152.  *  Processes WM_SIZE for the document so we can resize
  153.  *  the Polyline.
  154.  *
  155.  * Parameters:
  156.  *  <WndProc Parameters>
  157.  *  pLRes           LRESULT * in which to store the return
  158.  *                  value for the message.
  159.  *
  160.  * Return Value:
  161.  *  BOOL            TRUE to prevent further processing,
  162.  *                  FALSE otherwise.
  163.  */
  164.  
  165. BOOL CCosmoDoc::FMessageHook(HWND hWnd, UINT iMsg, WPARAM wParam
  166.     , LPARAM lParam, LRESULT *pLRes)
  167.     {
  168.     UINT        dx, dy;
  169.     RECT        rc;
  170.  
  171.     *pLRes=0;
  172.  
  173.     if (WM_SIZE==iMsg)
  174.         {
  175.         //Don't effect the Polyline size to or from minimized state.
  176.         if (SIZE_MINIMIZED!=wParam && SIZE_MINIMIZED !=m_uPrevSize)
  177.             {
  178.             //When we change size, resize any Polyline we hold.
  179.             dx=LOWORD(lParam);
  180.             dy=HIWORD(lParam);
  181.  
  182.             /*
  183.              * If we are getting WM_SIZE in response to a Polyline
  184.              * notification, then don't resize the Polyline window
  185.              * again.
  186.              */
  187.             if (!m_fNoSize && NULL!=m_pPL)
  188.                 {
  189.                 //Resize the polyline to fit the new client
  190.                 SetRect(&rc, 8, 8, dx-8, dy-8);
  191.                 m_pPL->RectSet(&rc, FALSE);
  192.  
  193.                 /*
  194.                  * We consider sizing something that makes the file
  195.                  * dirty, but not until we've finished the create
  196.                  * process, which is why we set fNoDirty to FALSE
  197.                  * in WM_CREATE since we get a WM_SIZE on the first
  198.                  * creation.
  199.                  */
  200.                 if (!m_fNoDirty)
  201.                     FDirtySet(TRUE);
  202.  
  203.                 SetRect(&rc, 0, 0, dx, dy);
  204.  
  205.                 if (NULL!=m_pAdv)
  206.                     m_pAdv->OnSizeChange(this, &rc);
  207.  
  208.                 m_fNoDirty=FALSE;
  209.                 }
  210.             }
  211.  
  212.         m_uPrevSize=wParam;
  213.         }
  214.  
  215.     /*
  216.      * We return FALSE even on WM_SIZE so we can let the default
  217.      * procedure handle maximized MDI child windows appropriately.
  218.      */
  219.     return FALSE;
  220.     }
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229. /*
  230.  * CCosmoDoc::Clear
  231.  *
  232.  * Purpose:
  233.  *  Sets all contents in the document back to defaults with
  234.  *  no filename.
  235.  *
  236.  * Paramters:
  237.  *  None
  238.  *
  239.  * Return Value:
  240.  *  None
  241.  */
  242.  
  243. void CCosmoDoc::Clear(void)
  244.     {
  245.     //Completely reset the polyline
  246.     m_pPL->New();
  247.  
  248.     CDocument::Clear();
  249.     return;
  250.     }
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257. /*
  258.  * CCosmoDoc::Load
  259.  *
  260.  * Purpose:
  261.  *  Loads a given document without any user interface overwriting
  262.  *  the previous contents of the Polyline window.  We do this by
  263.  *  opening the file and telling the Polyline to load itself from
  264.  *  that file.
  265.  *
  266.  * Parameters:
  267.  *  fChangeFile     BOOL indicating if we're to update the window
  268.  *                  title and the filename from using this file.
  269.  *  pszFile         LPTSTR to the filename to load, NULL if the file
  270.  *                  is new and untitled.
  271.  *
  272.  * Return Value:
  273.  *  UINT            An error value from DOCERR_*
  274.  */
  275.  
  276. UINT CCosmoDoc::Load(BOOL fChangeFile, LPTSTR pszFile)
  277.     {
  278.     HRESULT         hr;
  279.  
  280.     if (NULL==pszFile)
  281.         {
  282.         //For a new untitled document, just rename ourselves.
  283.         Rename(NULL);
  284.         return DOCERR_NONE;
  285.         }
  286.  
  287.     //CHAPTER5MOD
  288.     hr=m_pPL->ReadFromFile(pszFile);
  289.  
  290.     if (POLYLINE_E_READFAILURE==GetScode(hr))
  291.         return DOCERR_READFAILURE;
  292.     //End CHAPTER5MOD
  293.  
  294.     if (fChangeFile)
  295.         Rename(pszFile);
  296.  
  297.     //Importing a file makes things dirty
  298.     FDirtySet(!fChangeFile);
  299.  
  300.     return DOCERR_NONE;
  301.     }
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309. /*
  310.  * CCosmoDoc::Save
  311.  *
  312.  * Purpose:
  313.  *  Writes the file to a known filename, requiring that the user has
  314.  *  previously used FileOpen or FileSaveAs to provide a filename.
  315.  *
  316.  * Parameters:
  317.  *  uType           UINT indicating the type of file the user
  318.  *                  requested to save in the File Save As dialog.
  319.  *  pszFile         LPTSTR under which to save.  If NULL, use the
  320.  *                  current name.
  321.  *
  322.  * Return Value:
  323.  *  UINT            An error value from DOCERR_*
  324.  */
  325.  
  326. UINT CCosmoDoc::Save(UINT uType, LPTSTR pszFile)
  327.     {
  328.     BOOL                fRename=TRUE;
  329.     //CHAPTER5MOD
  330.     HRESULT             hr;
  331.     //End CHAPTER5MOD
  332.  
  333.     if (NULL==pszFile)
  334.         {
  335.         fRename=FALSE;
  336.         pszFile=m_szFile;
  337.         }
  338.  
  339.     /*
  340.      * In Component Cosmo, we only deal with one version of data,
  341.      * so all the code in Chapter 1 Cosmo that dealt with 1.0 and
  342.      * 2.0 files has been removed.
  343.      */
  344.  
  345.     //CHAPTER5MOD
  346.     hr=m_pPL->WriteToFile(pszFile);
  347.  
  348.     if (FAILED(hr))
  349.         return DOCERR_WRITEFAILURE;
  350.     //End CHAPTER5MOD
  351.  
  352.     //Saving makes us clean
  353.     FDirtySet(FALSE);
  354.  
  355.     if (fRename)
  356.         Rename(pszFile);
  357.  
  358.     return DOCERR_NONE;
  359.     }
  360.  
  361.  
  362.  
  363.  
  364.  
  365.  
  366. /*
  367.  * CCosmoDoc::Undo
  368.  *
  369.  * Purpose:
  370.  *  Reverses a previous action.
  371.  *
  372.  * Parameters:
  373.  *  None
  374.  *
  375.  * Return Value:
  376.  *  None
  377.  */
  378.  
  379. void CCosmoDoc::Undo(void)
  380.     {
  381.     m_pPL->Undo();
  382.     return;
  383.     }
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390. /*
  391.  * CCosmoDoc::Clip
  392.  *
  393.  * Purpose:
  394.  *  Places a private format, a metafile, and a bitmap of the display
  395.  *  on the clipboard, optionally implementing Cut by deleting the
  396.  *  data in the current window after rendering.
  397.  *
  398.  * Parameters:
  399.  *  hWndFrame       HWND of the main window.
  400.  *  fCut            BOOL indicating cut (TRUE) or copy (FALSE).
  401.  *
  402.  * Return Value:
  403.  *  BOOL            TRUE if successful, FALSE otherwise.
  404.  */
  405.  
  406. BOOL CCosmoDoc::Clip(HWND hWndFrame, BOOL fCut)
  407.     {
  408.     BOOL            fRet=TRUE;
  409.     HGLOBAL         hMem;
  410.     UINT            i;
  411.  
  412.     //This array is so we can loop over the formats we provide.
  413.     static UINT     rgcf[3]={0, CF_METAFILEPICT, CF_BITMAP};
  414.     const UINT      cFormats=3;
  415.  
  416.     if (!OpenClipboard(hWndFrame))
  417.         return FALSE;
  418.  
  419.     //Clean out whatever junk is in the clipboard.
  420.     EmptyClipboard();
  421.  
  422.     rgcf[0]=m_cf;
  423.  
  424.     for (i=0; i < cFormats; i++)
  425.         {
  426.         //Copy private data first.
  427.         hMem=RenderFormat(rgcf[i]);
  428.  
  429.         if (NULL!=hMem)
  430.             SetClipboardData(rgcf[i], hMem);
  431.         else
  432.             fRet &=FALSE;
  433.         }
  434.  
  435.     //Free clipboard ownership.
  436.     CloseClipboard();
  437.  
  438.     //Delete our current data if copying succeeded.
  439.     if (fRet && fCut)
  440.         {
  441.         m_pPL->New();
  442.         FDirtySet(TRUE);
  443.         }
  444.  
  445.     return fRet;
  446.     }
  447.  
  448.  
  449.  
  450.  
  451.  
  452. /*
  453.  * CCosmoDoc::RenderFormat
  454.  *
  455.  * Purpose:
  456.  *  Renders a specific clipboard format into global memory.
  457.  *
  458.  * Parameters:
  459.  *  cf              UINT format to render.
  460.  *
  461.  * Return Value:
  462.  *  HGLOBAL         Global memory handle containing the data.
  463.  */
  464.  
  465. HGLOBAL CCosmoDoc::RenderFormat(UINT cf)
  466.     {
  467.     HGLOBAL     hMem;
  468.  
  469.     if (cf==m_cf)
  470.         {
  471.         //CHAPTER5MOD
  472.         m_pPL->DataGetMem(&hMem);
  473.         //End CHAPTER5MOD
  474.         return hMem;
  475.         }
  476.  
  477.     switch (cf)
  478.         {
  479.         case CF_METAFILEPICT:
  480.             //CHAPTER5MOD
  481.             m_pPL->RenderMetafilePict(&hMem);
  482.             return hMem;
  483.             //End CHAPTER5MOD
  484.  
  485.         case CF_BITMAP:
  486.             m_pPL->RenderBitmap((HBITMAP *)&hMem);
  487.             return hMem;
  488.         }
  489.  
  490.     return NULL;
  491.     }
  492.  
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499. /*
  500.  * CCosmoDoc::FQueryPaste
  501.  *
  502.  * Purpose:
  503.  *  Determines if we can paste data from the clipboard.
  504.  *
  505.  * Parameters:
  506.  *  None
  507.  *
  508.  * Return Value:
  509.  *  BOOL            TRUE if data is available, FALSE otherwise.
  510.  */
  511.  
  512. BOOL CCosmoDoc::FQueryPaste(void)
  513.     {
  514.     return IsClipboardFormatAvailable(m_cf);
  515.     }
  516.  
  517.  
  518.  
  519.  
  520.  
  521. /*
  522.  * CCosmoDoc::Paste
  523.  *
  524.  * Purpose:
  525.  *  Retrieves the private data format from the clipboard and sets it
  526.  *  to the current figure in the editor window.
  527.  *
  528.  *  Note that if this function is called, then the clipboard format
  529.  *  is available because the Paste menu item is only enabled if the
  530.  *  format is present.
  531.  *
  532.  * Parameters:
  533.  *  hWndFrame       HWND of the main window.
  534.  *
  535.  * Return Value:
  536.  *  BOOL            TRUE if successful, FALSE otherwise.
  537.  */
  538.  
  539. BOOL CCosmoDoc::Paste(HWND hWndFrame)
  540.     {
  541.     HGLOBAL         hMem;
  542.     PPOLYLINEDATA   ppl;
  543.     BOOL            fRet=FALSE;
  544.  
  545.     if (!OpenClipboard(hWndFrame))
  546.         return FALSE;
  547.  
  548.     hMem=GetClipboardData(m_cf);
  549.  
  550.     if (NULL!=hMem)
  551.         {
  552.         ppl=(PPOLYLINEDATA)GlobalLock(hMem);
  553.  
  554.         //TRUE in wParam to cause PLN_SIZECHANGE notification
  555.         m_pPL->DataSet(ppl, FALSE, TRUE);
  556.         GlobalUnlock(hMem);
  557.  
  558.         FDirtySet(TRUE);
  559.         fRet=TRUE;
  560.         }
  561.  
  562.     CloseClipboard();
  563.     return fRet;
  564.     }
  565.  
  566.  
  567.  
  568.  
  569.  
  570.  
  571. /*
  572.  * CCosmoDoc::ColorSet
  573.  *
  574.  * Purpose:
  575.  *  Changes a color used in our contained Polyline.
  576.  *
  577.  * Parameters:
  578.  *  iColor          UINT index of the color to change.
  579.  *  cr              COLORREF new color.
  580.  *
  581.  * Return Value:
  582.  *  COLORREF        Previous color for the given index.
  583.  */
  584.  
  585. COLORREF CCosmoDoc::ColorSet(UINT iColor, COLORREF cr)
  586.     {
  587.     //CHAPTER5MOD
  588.     COLORREF    crRet;
  589.  
  590.     m_pPL->ColorSet(iColor, cr, &crRet);
  591.     return crRet;
  592.     //End CHAPTER5MOD
  593.     }
  594.  
  595.  
  596.  
  597.  
  598.  
  599. /*
  600.  * CCosmoDoc::ColorGet
  601.  *
  602.  * Purpose:
  603.  *  Retrieves a color currently in use in the Polyline.
  604.  *
  605.  * Parameters:
  606.  *  iColor          UINT index of the color to retrieve.
  607.  *
  608.  * Return Value:
  609.  *  COLORREF        Current color for the given index.
  610.  */
  611.  
  612. COLORREF CCosmoDoc::ColorGet(UINT iColor)
  613.     {
  614.     //CHAPTER5MOD
  615.     COLORREF    crRet;
  616.  
  617.     m_pPL->ColorGet(iColor, &crRet);
  618.     return crRet;
  619.     //End CHAPTER5MOD
  620.     }
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627. /*
  628.  * CCosmoDoc::LineStyleSet
  629.  *
  630.  * Purpose:
  631.  *  Changes the line style currently used in the Polyline
  632.  *
  633.  * Parameters:
  634.  *  iStyle          UINT index of the new line style to use.
  635.  *
  636.  * Return Value:
  637.  *  UINT            Previous line style.
  638.  */
  639.  
  640. UINT CCosmoDoc::LineStyleSet(UINT iStyle)
  641.     {
  642.     //CHAPTER5MOD
  643.     UINT    i;
  644.  
  645.     m_pPL->LineStyleSet(iStyle, &i);
  646.     return i;
  647.     //End CHAPTER5MOD
  648.     }
  649.  
  650.  
  651.  
  652.  
  653.  
  654.  
  655.  
  656. /*
  657.  * CCosmoDoc::LineStyleGet
  658.  *
  659.  * Purpose:
  660.  *  Retrieves the line style currently used in the Polyline
  661.  *
  662.  * Parameters:
  663.  *  None
  664.  *
  665.  * Return Value:
  666.  *  UINT            Current line style.
  667.  */
  668.  
  669.  
  670. UINT CCosmoDoc::LineStyleGet(void)
  671.     {
  672.     //CHAPTER5MOD
  673.     UINT    i=0;
  674.  
  675.     //m_pPL might not be valid yet.
  676.     if (NULL!=m_pPL)
  677.         m_pPL->LineStyleGet(&i);
  678.  
  679.     return i;
  680.     //End CHAPTER5MOD
  681.     }
  682.  
  683.  
  684.  
  685.  
  686.  
  687.  
  688.  
  689. /*
  690.  * CPolylineAdviseSink::CPolylineAdviseSink
  691.  * CPolylineAdviseSink::~CPolylineAdviseSink
  692.  *
  693.  * Constructor Parameters:
  694.  *  pDoc            PCCosmoDoc to store in this object
  695.  */
  696.  
  697. CPolylineAdviseSink::CPolylineAdviseSink(PCCosmoDoc pDoc)
  698.     {
  699.     //CHAPTER5MOD
  700.     m_pDoc=pDoc;
  701.     m_cRef=0;
  702.     AddRef();
  703.     //End CHAPTER5MOD
  704.     return;
  705.     }
  706.  
  707.  
  708. CPolylineAdviseSink::~CPolylineAdviseSink(void)
  709.     {
  710.     return;
  711.     }
  712.  
  713.  
  714.  
  715.  
  716. //CHAPTER5MOD
  717. /*
  718.  * CPolylineAdviseSink::QueryInterface
  719.  * CPolylineAdviseSink::AddRef
  720.  * CPolylineAdviseSink::Release
  721.  *
  722.  * Purpose:
  723.  *  IUnknown members for this IPolylineAdviseSink implementations.
  724.  */
  725.  
  726. STDMETHODIMP CPolylineAdviseSink::QueryInterface(REFIID riid
  727.     , PPVOID ppv)
  728.     {
  729.     *ppv=NULL;
  730.  
  731.     if (IID_IUnknown==riid || IID_IPolylineAdviseSink5==riid)
  732.         *ppv=this;
  733.  
  734.     if (NULL!=*ppv)
  735.         {
  736.         ((LPUNKNOWN)*ppv)->AddRef();
  737.         return NOERROR;
  738.         }
  739.  
  740.     return ResultFromScode(S_FALSE);
  741.     }
  742.  
  743.  
  744. STDMETHODIMP_(ULONG) CPolylineAdviseSink::AddRef(void)
  745.     {
  746.     return ++m_cRef;
  747.     }
  748.  
  749.  
  750. STDMETHODIMP_(ULONG) CPolylineAdviseSink::Release(void)
  751.     {
  752.     if (0L!=--m_cRef)
  753.         return m_cRef;
  754.  
  755.     delete this;
  756.     return 0;
  757.     }
  758. //End CHAPTER5MOD
  759.  
  760.  
  761.  
  762.  
  763. /*
  764.  * CPolylineAdviseSink::OnPointChange
  765.  *
  766.  * Purpose:
  767.  *  Informs the document that the polyline added or removed a point.
  768.  *
  769.  * Parameters:
  770.  *  None
  771.  *
  772.  * Return Value:
  773.  *  None
  774.  */
  775.  
  776. STDMETHODIMP_(void) CPolylineAdviseSink::OnPointChange(void)
  777.     {
  778.     m_pDoc->FDirtySet(TRUE);
  779.     return;
  780.     }
  781.  
  782.  
  783.  
  784.  
  785.  
  786.  
  787. /*
  788.  * CPolylineAdviseSink::OnSizeChange
  789.  *
  790.  * Purpose:
  791.  *  Informs the document that the polyline changed size.
  792.  *
  793.  * Parameters:
  794.  *  None
  795.  *
  796.  * Return Value:
  797.  *  None
  798.  */
  799.  
  800. STDMETHODIMP_(void) CPolylineAdviseSink::OnSizeChange(void)
  801.     {
  802.     RECT            rc;
  803.     DWORD           dwStyle;
  804.  
  805.     //CHAPTER5MOD
  806.     HWND            hWnd;
  807.  
  808.     /*
  809.      * Polyline window is informing us that it changed size in
  810.      * response to setting it's data.  Therefore we have to
  811.      * size ourselves accordingly but without moving the screen
  812.      * position of the polyline window.
  813.      */
  814.  
  815.     m_pDoc->m_fNoSize=TRUE;
  816.  
  817.     //Set the document window size.
  818.     //CHAPTER5MOD
  819.     m_pDoc->m_pPL->Window(&hWnd);
  820.     //End CHAPTER5MOD
  821.     GetWindowRect(hWnd, &rc);
  822.     InflateRect(&rc, 8, 8);
  823.  
  824.     //Adjust for a window sans menu
  825.     dwStyle=GetWindowLong(m_pDoc->m_hWnd, GWL_STYLE);
  826.     AdjustWindowRect(&rc, dwStyle, FALSE);
  827.  
  828.     SetWindowPos(m_pDoc->m_hWnd, NULL, 0, 0, rc.right-rc.left
  829.         , rc.bottom-rc.top, SWP_NOMOVE | SWP_NOZORDER);
  830.  
  831.     if (NULL!=m_pDoc->m_pAdv)
  832.         m_pDoc->m_pAdv->OnSizeChange(m_pDoc, &rc);
  833.  
  834.     m_pDoc->m_fNoSize=FALSE;
  835.     m_pDoc->FDirtySet(TRUE);
  836.  
  837.     return;
  838.     }
  839.  
  840.  
  841.  
  842.  
  843.  
  844. /*
  845.  * CPolylineAdviseSink::OnDataChange
  846.  *
  847.  * Purpose:
  848.  *  Informs the document that the polyline data changed.
  849.  *
  850.  * Parameters:
  851.  *  None
  852.  *
  853.  * Return Value:
  854.  *  None
  855.  */
  856.  
  857. STDMETHODIMP_(void) CPolylineAdviseSink::OnDataChange(void)
  858.     {
  859.     if (NULL!=m_pDoc->m_pAdv)
  860.         m_pDoc->m_pAdv->OnDataChange(m_pDoc);
  861.  
  862.     m_pDoc->FDirtySet(TRUE);
  863.     return;
  864.     }
  865.  
  866.  
  867.  
  868.  
  869.  
  870. /*
  871.  * CPolylineAdviseSink::OnColorChange
  872.  *
  873.  * Purpose:
  874.  *  Informs the document that the polyline data changed a color.
  875.  *
  876.  * Parameters:
  877.  *  None
  878.  *
  879.  * Return Value:
  880.  *  None
  881.  */
  882.  
  883. STDMETHODIMP_(void) CPolylineAdviseSink::OnColorChange(void)
  884.     {
  885.     m_pDoc->FDirtySet(TRUE);
  886.     return;
  887.     }
  888.  
  889.  
  890.  
  891.  
  892.  
  893. /*
  894.  * CPolylineAdviseSink::OnLineStyleChange
  895.  *
  896.  * Purpose:
  897.  *  Informs the document that the polyline changed its line style.
  898.  *
  899.  * Parameters:
  900.  *  None
  901.  *
  902.  * Return Value:
  903.  *  None
  904.  */
  905.  
  906. STDMETHODIMP_(void) CPolylineAdviseSink::OnLineStyleChange(void)
  907.     {
  908.     m_pDoc->FDirtySet(TRUE);
  909.     return;
  910.     }
  911.