source: trunk/MFCtooling/TestProg/TestProgView.cpp @ 1674

// TestProgView.cpp : implementation of the CTestProgView class
//

#include "stdafx.h"
#include "TestProg.h"

#include "TestProgDoc.h"
#include "CntrItem.h"
#include "TestProgView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CTestProgView

IMPLEMENT_DYNCREATE(CTestProgView, CView)

BEGIN_MESSAGE_MAP(CTestProgView, CView)
        ON_WM_DESTROY()
        ON_WM_SETFOCUS()
        ON_WM_SIZE()
        ON_COMMAND(ID_OLE_INSERT_NEW, &CTestProgView::OnInsertObject)
        ON_COMMAND(ID_CANCEL_EDIT_CNTR, &CTestProgView::OnCancelEditCntr)
        ON_COMMAND(ID_FILE_PRINT, &CTestProgView::OnFilePrint)
        ON_COMMAND(ID_CANCEL_EDIT_SRVR, &CTestProgView::OnCancelEditSrvr)
        ON_COMMAND(ID_FILE_PRINT_DIRECT, &CView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CView::OnFilePrintPreview)
END_MESSAGE_MAP()

// CTestProgView construction/destruction

CTestProgView::CTestProgView()
{
        m_pSelection = NULL;
        // TODO: add construction code here

}

CTestProgView::~CTestProgView()
{
}

BOOL CTestProgView::PreCreateWindow(CREATESTRUCT& cs)
{
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs

        return CView::PreCreateWindow(cs);
}

// CTestProgView drawing

void CTestProgView::OnDraw(CDC* pDC)
{
        if (!pDC)
                return;

        CTestProgDoc* pDoc = GetDocument();
        ASSERT_VALID(pDoc);
        if (!pDoc)
                return;

        // TODO: add draw code for native data here
        // TODO: also draw all OLE items in the document

        // Draw the selection at an arbitrary position.  This code should be
        //  removed once your real drawing code is implemented.  This position
        //  corresponds exactly to the rectangle returned by CTestProgCntrItem,
        //  to give the effect of in-place editing.

        // TODO: remove this code when final draw code is complete.
        if (m_pSelection != NULL)
        {
                CSize size;
                CRect rect(10, 10, 210, 210);
                
                if (m_pSelection->GetExtent(&size, m_pSelection->m_nDrawAspect))
                {
                        pDC->HIMETRICtoLP(&size);
                        rect.right = size.cx + 10;
                        rect.bottom = size.cy + 10;
                }
                m_pSelection->Draw(pDC, rect);
        }
}

void CTestProgView::OnInitialUpdate()
{
        CView::OnInitialUpdate();


        // TODO: remove this code when final selection model code is written
        m_pSelection = NULL;    // initialize selection

}


// CTestProgView printing

BOOL CTestProgView::OnPreparePrinting(CPrintInfo* pInfo)
{
        // default preparation
        return DoPreparePrinting(pInfo);
}

void CTestProgView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add extra initialization before printing
}

void CTestProgView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add cleanup after printing
}

void CTestProgView::OnDestroy()
{
        // Deactivate the item on destruction; this is important
        // when a splitter view is being used
   COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
   if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
   {
      pActiveItem->Deactivate();
      ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
   }
   CView::OnDestroy();
}



// OLE Client support and commands

BOOL CTestProgView::IsSelected(const CObject* pDocItem) const
{
        // The implementation below is adequate if your selection consists of
        //  only CTestProgCntrItem objects.  To handle different selection
        //  mechanisms, the implementation here should be replaced

        // TODO: implement this function that tests for a selected OLE client item

        return pDocItem == m_pSelection;
}

void CTestProgView::OnInsertObject()
{
        // Invoke the standard Insert Object dialog box to obtain information
        //  for new CTestProgCntrItem object
        COleInsertDialog dlg;
        if (dlg.DoModal() != IDOK)
                return;

        BeginWaitCursor();

        CTestProgCntrItem* pItem = NULL;
        TRY
        {
                // Create new item connected to this document
                CTestProgDoc* pDoc = GetDocument();
                ASSERT_VALID(pDoc);
                pItem = new CTestProgCntrItem(pDoc);
                ASSERT_VALID(pItem);

                // Initialize the item from the dialog data
                if (!dlg.CreateItem(pItem))
                        AfxThrowMemoryException();  // any exception will do
                ASSERT_VALID(pItem);
                
        if (dlg.GetSelectionType() == COleInsertDialog::createNewItem)
                        pItem->DoVerb(OLEIVERB_SHOW, this);

                ASSERT_VALID(pItem);
                // As an arbitrary user interface design, this sets the selection
                //  to the last item inserted

                // TODO: reimplement selection as appropriate for your application
                m_pSelection = pItem;   // set selection to last inserted item
                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.  Here,
//  the container (not the server) causes the deactivation
void CTestProgView::OnCancelEditCntr()
{
        // 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 CTestProgView::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 CTestProgView::OnSize(UINT nType, int cx, int cy)
{
        CView::OnSize(nType, cx, cy);
        COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
        if (pActiveItem != NULL)
                pActiveItem->SetItemRects();
}

void CTestProgView::OnFilePrint()
{
        //By default, we ask the Active document to print itself
        //using IOleCommandTarget. If you don't want this behavior
        //remove the call to COleDocObjectItem::DoDefaultPrinting.
        //If the call fails for some reason, we will try printing
        //the docobject using the IPrint interface.
        CPrintInfo printInfo;
        ASSERT(printInfo.m_pPD != NULL); 
        if (S_OK == COleDocObjectItem::DoDefaultPrinting(this, &printInfo))
                return;
        
        CView::OnFilePrint();

}



// OLE Server support

// The following command handler provides the standard keyboard
//  user interface to cancel an in-place editing session.  Here,
//  the server (not the container) causes the deactivation
void CTestProgView::OnCancelEditSrvr()
{
        GetDocument()->OnDeactivateUI(FALSE);
}


// CTestProgView diagnostics

#ifdef _DEBUG
void CTestProgView::AssertValid() const
{
        CView::AssertValid();
}

void CTestProgView::Dump(CDumpContext& dc) const
{
        CView::Dump(dc);
}

CTestProgDoc* CTestProgView::GetDocument() const // non-debug version is inline
{
        ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTestProgDoc)));
        return (CTestProgDoc*)m_pDocument;
}
#endif //_DEBUG


// CTestProgView message handlers