_EXAMINING SYMANTEC C++ 7.0_
by Ira Rodens

Listing One

// contaivw.cpp : implementation of the CcontainView class
// Copyright (c) Ira Rodens , 1995. All Rights Reserved.

#include "stdafx.h"
#include "contain.h"

#include "contadoc.h"
#include "cntritem.h"
#include "contaivw.h"
#include "crectsel.h"

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

//////// CcontainView ////////
IMPLEMENT_DYNCREATE(CcontainView, CScrollView)
BEGIN_MESSAGE_MAP(CcontainView, CScrollView)
    //{{AFX_MSG_MAP(CcontainView)
    ON_WM_SETFOCUS()
    ON_WM_SIZE()
    ON_COMMAND(ID_OLE_INSERT_NEW, OnInsertObject)
    ON_COMMAND(ID_CANCEL_EDIT, OnCancelEdit)
    ON_WM_LBUTTONDOWN()
    ON_WM_SETCURSOR()
    ON_WM_INITMENUPOPUP()
    ON_COMMAND(ID_EDIT_CUT,OnEditCut)
    ON_COMMAND(ID_EDIT_COPY,OnEditCopy)
    ON_COMMAND(ID_EDIT_PASTE,OnEditPaste)
    ON_UPDATE_COMMAND_UI(ID_EDIT_CUT,OnUpdateEditCut)
    ON_UPDATE_COMMAND_UI(ID_EDIT_COPY,OnUpdateEditCopy)
    ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE,OnUpdateEditPaste)
    //}}AFX_MSG_MAP
    // Standard printing commands
    ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

////// CcontainView construction/destruction ////// 
CcontainView::CcontainView()
    : CScrollView()
{
    m_pSelection = NULL;
    m_pSelectRect = NULL;
}
CcontainView::~CcontainView()
{
    if (m_pSelectRect) delete m_pSelectRect;
}
/////// CcontainView drawing /////// 
void CcontainView::OnDraw(CDC* pDC)
{
    CcontainCntrItem*   pItem;
    CcontainDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    POSITION pos = pDoc->GetStartPosition();
    CPoint  ptScroll = -GetScrollPosition();
    while ((pItem = (CcontainCntrItem*)pDoc->GetNextClientItem(pos)) != NULL) {
        pItem -> Draw(pDC,ptScroll);
    }
    if (m_pSelectRect != NULL) {
        m_pSelectRect->Draw(pDC, ptScroll);
    }
}
void CcontainView::OnInitialUpdate()
{
    SIZE    size;
// Set size for 8.5 X 11 inch paper    
    const double width = 8.5 ;
    const double height = 11 ;
    CView::OnInitialUpdate();
    m_pSelection = NULL;    // initialize selection
    if (m_pSelectRect) {
        delete m_pSelectRect;
        m_pSelectRect = NULL;
    }      
    ShowScrollBar(SB_BOTH,TRUE);
// set for standard 8.5 X 11 inch paper   
    CWindowDC cDC(NULL);
    size.cx = (int)(width * (double)cDC.GetDeviceCaps(LOGPIXELSX));
    size.cy = (int)(height * (double)cDC.GetDeviceCaps(LOGPIXELSY));
    SetScrollSizes(MM_TEXT,size);
    
}
/////// CcontainView printing /////// 
BOOL CcontainView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}
void CcontainView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
    // TODO: add extra initialization before printing
}
void CcontainView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
    // TODO: add cleanup after printing
}
/////// OLE Client support and commands /////// 
BOOL CcontainView::IsSelected(const CObject* pDocItem) const
{
    // The implementation below is adequate if your selection consists of
    //  only CcontainCntrItem objects.  To handle different selection
    //  mechanisms, the implementation here should be replaced.
    return pDocItem == m_pSelection;
}
void CcontainView::OnInsertObject()
{
    // Invoke the standard Insert Object dialog box to obtain information
    //  for new CcontainCntrItem object.
    COleInsertDialog dlg;
    if (dlg.DoModal() != IDOK)
        return;
    BeginWaitCursor();
    CcontainCntrItem* pItem = NULL;
    TRY
    {
        // Create new item connected to this document.
        CcontainDoc* pDoc = GetDocument();
        ASSERT_VALID(pDoc);
        pItem = new CcontainCntrItem(pDoc);
        ASSERT_VALID(pItem);
        // Initialize the item from the dialog data.
        if (!dlg.CreateItem(pItem))
            AfxThrowMemoryException();  // any exception will do
        ASSERT_VALID(pItem);
        // If item created from class list (not from file) then launch
        //  the server to edit the item.
        if (dlg.GetSelectionType() == COleInsertDialog::createNewItem)
            pItem->DoVerb(OLEIVERB_SHOW, this);
        ASSERT_VALID(pItem);
        pDoc->UpdateAllViews(NULL);
    }
    CATCH(CException, e)
    {
        if (pItem != NULL)
        {
            ASSERT_VALID(pItem);
            pItem->Delete();
        }
        AfxMessageBox(IDP_FAILED_TO_CREATE);
    }
    END_CATCH
    EndWaitCursor();
}
// The following command handler provides the standard keyboard
//  user interface to cancel an in-place editing session.
void CcontainView::OnCancelEdit()
{
    // Close any in-place active item on this view.
    COleClientItem* pActiveItem=GetDocument()->GetInPlaceActiveItem(this);
    if (pActiveItem != NULL)
    {
        pActiveItem->Close();
    }
    ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
}
// Special handling of OnSetFocus and OnSize are required for a container
//  when an object is being edited in-place.
void CcontainView::OnSetFocus(CWnd* pOldWnd)
{
    COleClientItem* pActiveItem= GetDocument()->GetInPlaceActiveItem(this);
    if (pActiveItem != NULL &&
        pActiveItem->GetItemState() == COleClientItem::activeUIState)
    {
        // need to set focus to this item if it is in the same view
        CWnd* pWnd = pActiveItem->GetInPlaceWindow();
        if (pWnd != NULL)
        {
            pWnd->SetFocus();   // don't call the base class
            return;
        }
    }
    CView::OnSetFocus(pOldWnd);
}
void CcontainView::OnSize(UINT nType, int cx, int cy)
{
    CView::OnSize(nType, cx, cy);
    UpdateBars();
    COleClientItem* pActiveItem= GetDocument()->GetInPlaceActiveItem(this);
    if (pActiveItem != NULL)
        pActiveItem->SetItemRects();
}
////// CcontainView diagnostics /////// 
#ifdef _DEBUG
void CcontainView::AssertValid() const
{
    ASSERT (!((m_pSelection && !m_pSelectRect) || 
        (!m_pSelection && m_pSelectRect)));
    CView::AssertValid();
}
void CcontainView::Dump(CDumpContext& dc) const
{
    CView::Dump(dc);
}
CcontainDoc* CcontainView::GetDocument() // non-debug version is inline
{
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CcontainDoc)));
    return (CcontainDoc*)m_pDocument;
}
#endif //_DEBUG
/////// CcontainView message handlers /////// 
void CcontainView::OnLButtonDown(UINT nFlags, CPoint point)
{
    CcontainCntrItem*   pNewSelection;
    CcontainCntrItem*   pItem;
    COleClientItem  *   pActive;
    CcontainDoc* pDoc = GetDocument();
    if ((pActive = pDoc->GetInPlaceActiveItem(this)) != NULL) {
        pActive -> Close();
        ASSERT (pDoc->GetInPlaceActiveItem(this) == NULL);
        return;
    }
    CPoint  ptScroll = GetScrollPosition();
    CPoint  ptMouse ;
    ptMouse.x = point.x + ptScroll.x;
    ptMouse.y = point.y + ptScroll.y;
    
    if (m_pSelectRect) {
        if (m_pSelectRect->HitTest(point) != CRectTracker::hitNothing) {
            CRect rctOld;
// Find original rectangle          
            m_pSelectRect->GetTrueRectangle(rctOld,-ptScroll);
// Resize/move object           
            m_pSelectRect->Track(this,point,ptScroll);
// Redraw original location 
            InvalidateRect(&rctOld);
// Draw object in new location 
            {
                CClientDC   dc(this);              
                m_pSelection -> Draw(&dc,ptScroll);
                m_pSelectRect -> Draw(&dc,ptScroll);
            }            
            return;
        }
    }
    pNewSelection = NULL;
    POSITION pos = pDoc->GetStartPosition();
    while ((pItem = (CcontainCntrItem*)pDoc->GetNextClientItem(pos)) != NULL) {
        if ((pItem->GetRect()).PtInRect(ptMouse)) {
            pNewSelection = pItem;
            break;
        }
    }
    ChangeSelection(pNewSelection);
}
BOOL CcontainView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
    BOOL bAns = FALSE;
    if ((pWnd != this) || (nHitTest != HTCLIENT)) {
        ::SetCursor(::LoadCursor(NULL,IDC_ARROW));
    }      
    else if (m_pSelectRect) {
        CPoint ptScroll = GetScrollPosition();
        bAns = m_pSelectRect->SetCursor(pWnd,nHitTest,ptScroll);
    }
    if (!bAns) {
        ::SetCursor(::LoadCursor(NULL,IDC_CROSS));
    }
    return TRUE;
}
void CcontainView::OnEditCut()
{
    OnEditCopy();
    DeleteSelection();
}
void CcontainView::OnEditCopy()
{
    m_pSelection -> CopyToClipboard();
}
void CcontainView::OnEditPaste()
{
    CcontainCntrItem *pObject = new CcontainCntrItem(GetDocument());
    if (!pObject -> CreateFromClipboard()) delete pObject;
}
void CcontainView::DeleteSelection()
{
    if (m_pSelection != NULL) {
        CRect   rctObj;
        m_pSelectRect -> GetTrueRectangle(rctObj,-GetScrollPosition());
        delete m_pSelection;
        m_pSelection = NULL;
        delete m_pSelectRect;
        m_pSelectRect = NULL;
        InvalidateRect ((LPRECT)&rctObj,TRUE);
    }     
}
void CcontainView::ChangeSelection(CcontainCntrItem *pNewSelection)
{
    if (pNewSelection != m_pSelection) {
        CPoint  ptScroll = GetScrollPosition();
        if (m_pSelectRect) {
            CRect   rctOld;
            m_pSelectRect->GetTrueRectangle(rctOld,ptScroll);
            InvalidateRect(&rctOld);
            delete m_pSelectRect;
            m_pSelectRect = NULL;
        }
        m_pSelection = pNewSelection;
        if (m_pSelection) {
            m_pSelectRect = new CRectSelect(m_pSelection);
            {
                CClientDC   dc(this);
                m_pSelectRect->Draw(&dc,ptScroll);
            }
        }
    }     
}
void CcontainView::OnUpdateEditCut(CCmdUI *pCmdUI)
{
    pCmdUI -> Enable(m_pSelection != NULL);
}
void CcontainView::OnUpdateEditCopy(CCmdUI *pCmdUI)
{
    pCmdUI -> Enable(m_pSelection != NULL);
}
void CcontainView::OnUpdateEditPaste(CCmdUI *pCmdUI)
{
   BOOL bFlag=CcontainCntrItem::CanPaste() || CcontainCntrItem::CanPasteLink();
   pCmdUI -> Enable(bFlag);
}


Listing Two

extern struct X { int member;
    X();        // try commenting out this line
} x;
struct X test() { return x; }


Listing Three

class Heap {
static void *heap;
static size_t heapleft;
public:
static inline void *malloc(size_t size)
{   void *p;
    if (heapleft < size)
    {   size_t newsize = (size + 4095) & ~4095;
    p = malloc(newsize);
    if (!p) return p;
    heapleft = newsize;
    heap = p;
    }
    p = heap;
    *(char **)&heap += size;
    heapleft -= size;
    return p;
}
static inline void *calloc(size_t size)
{   void *p;
    p = malloc(size);
    return p ? memset(p,0,size) : p;
}
static inline void free(void *p) { }
};