Download - VP Lab Exercise
-
7/30/2019 VP Lab Exercise
1/75
Ex.No:1 KEYBOARD AND MOUSE EVENTS
Coding:
#include
LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE h,HINSTANCE hp,LPSTR lps,int in)
{
WNDCLASS wc;
HWND hw;
MSG ms;
wc.style=CS_HREDRAW|CS_VREDRAW;
wc.cbClsExtra=0;
wc.cbWndExtra=0;
wc.hbrBackground=(HBRUSH)GetStockObject(BLACK_BRUSH);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
wc.hInstance=h;
wc.lpfnWndProc=WndProc;
wc.lpszClassName="window";
wc.lpszMenuName=NULL;
RegisterClass(&wc);
hw=CreateWindow("window","MY FIRST
WINDOW",WS_OVERLAPPEDWINDOW,0,0,300,300,NULL,NULL,h,NULL);
ShowWindow(hw,in);
UpdateWindow(hw);
while(GetMessage(&ms,hw,0,0))
{
-
7/30/2019 VP Lab Exercise
2/75
TranslateMessage(&ms);
DispatchMessage(&ms);
}
return ms.wParam;
}
LRESULT CALLBACK WndProc(HWND hw,UINT ms,WPARAM w,LPARAM l)
{
HDC hdc;
switch(ms)
{
acase WM_LBUTTONDOWN:
hdc=GetDC(hw);
TextOut(hdc,10,10,TEXT("LEFT BUTTON PRESSED"),25);
ReleaseDC(hw,hdc);
return 0;
case WM_LBUTTONUP:
hdc=GetDC(hw);
TextOut(hdc,10,50,TEXT("LEFT BUTTON RELEASED"),25);
case WM_RBUTTONDOWN:
hdc=GetDC(hw);
TextOut(hdc,10,70,TEXT("RIGHT BUTTON PRESSED"),25);
ReleaseDC(hw,hdc);
return 0;
case WM_RBUTTONUP:
hdc=GetDC(hw);
-
7/30/2019 VP Lab Exercise
3/75
TextOut(hdc,10,100,TEXT("RIGHT BUTTON RELEASED"),25);
ReleaseDC(hw,hdc);
return 0;
case WM_KEYDOWN:
switch(w)
{
case VK_END:
MessageBox(hw,"YOU PRESSED END KEY","ERROR",MB_OK);
break;
case VK_HOME:
MessageBox(hw,"YOU PRESSED HOME KEY","ERROR",MB_OK);
break;
case VK_INSERT:
MessageBox(hw,"YOU PRESSED INSERT KEY","ERROR",MB_OK);
break;
case VK_DELETE:
MessageBox(hw,"YOU PRESSED DELETE KEY","ERROR",MB_OK);
break;
}
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hw,ms,w,l);}
-
7/30/2019 VP Lab Exercise
4/75
Output:
-
7/30/2019 VP Lab Exercise
5/75
Ex.No:2 DIALOG BASED APPLICATION
Coding:
// dbDlg.cpp : implementation file//
#include "stdafx.h"
#include "db.h"
#include "dbDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
-
7/30/2019 VP Lab Exercise
6/75
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CDbDlg dialog
-
7/30/2019 VP Lab Exercise
7/75
CDbDlg::CDbDlg(CWnd* pParent /*=NULL*/)
: CDialog(CDbDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CDbDlg)
m_nOperation = -1;
m_dFirst = 0.0;
m_dSecond = 0.0;
m_dResult = 0.0;
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CDbDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDbDlg)
DDX_Radio(pDX, IDC_OPERATION, m_nOperation);
DDX_Text(pDX, IDC_FIRST, m_dFirst);
DDX_Text(pDX, IDC_SECOND, m_dSecond);
DDX_Text(pDX, IDC_RESULT, m_dResult);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CDbDlg, CDialog)
//{{AFX_MSG_MAP(CDbDlg)
ON_WM_SYSCOMMAND()
-
7/30/2019 VP Lab Exercise
8/75
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_COMPUTE, OnCompute)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CDbDlg message handlers
BOOL CDbDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
-
7/30/2019 VP Lab Exercise
9/75
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
}
void CDbDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CDbDlg::OnPaint()
{
if (IsIconic())
-
7/30/2019 VP Lab Exercise
10/75
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CDbDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CDbDlg::OnCompute()
-
7/30/2019 VP Lab Exercise
11/75
{
UpdateData(TRUE);
switch(m_nOperation)
{
case 0:
//add
m_dResult=m_dFirst + m_dSecond;
break;
case 1:
//subtract
m_dResult=m_dFirst - m_dSecond;
break;
case 2:
//multiply
m_dResult=m_dFirst * m_dSecond;
break;
case 3:
//divide
if(m_dSecond!=0.0)
{
m_dResult=m_dFirst / m_dSecond;
}
else
{
//For Error Message Box
-
7/30/2019 VP Lab Exercise
12/75
AfxMessageBox("Divide by zero");
m_dResult=0.0;
}
break;
default:
TRACE("default;m_nOperation=%d\n",m_nOperation);
}
UpdateData(FALSE);
}
Output:
-
7/30/2019 VP Lab Exercise
13/75
Ex.No:3 MDI APPLICATION
Coding:
// ChildView.h : interface of the CChildView class//
/////////////////////////////////////////////////////////////////////////////
#if!defined(AFX_CHILDVIEW_H__A95C210D_6A6D_4D8F_B877_C4038479ABCA__INCLUDED)
#define AFX_CHILDVIEW_H__A95C210D_6A6D_4D8F_B877_C4038479ABCA__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CChildView window
class CChildView : public CWnd
{
// Construction
public:
CChildView();
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CChildView)
protected:
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
-
7/30/2019 VP Lab Exercise
14/75
// Implementation
public:
virtual ~CChildView();
// Generated message map functions
protected:
//{{AFX_MSG(CChildView)
afx_msg void OnPaint();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
private:
CRect m_rectEllipse;
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_CHILDVIEW_H__A95C210D_6A6D_4D8F_B877_C4038479ABCA__INCLUDED_)
// ChildView.cpp : implementation of the CChildView class//
#include "stdafx.h"
#include "MdiEx1.h"
#include "ChildView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
-
7/30/2019 VP Lab Exercise
15/75
/////////////////////////////////////////////////////////////////////////////
// CChildView
CChildView::CChildView() :m_rectEllipse(200,200,15,30)
{
}
CChildView::~CChildView()
{
}
BEGIN_MESSAGE_MAP(CChildView,CWnd )
//{{AFX_MSG_MAP(CChildView)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CChildView message handlers
BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs)
{
if (!CWnd::PreCreateWindow(cs))
return FALSE;
cs.dwExStyle |= WS_EX_CLIENTEDGE;
cs.style &= ~WS_BORDER;
cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,
::LoadCursor(NULL, IDC_ARROW), HBRUSH(COLOR_WINDOW+1), NULL);
return TRUE;
}
void CChildView::OnPaint()
-
7/30/2019 VP Lab Exercise
16/75
{
CPaintDC dc(this); // device context for painting
dc.TextOut(0,0,"Chendhuran");
dc.Rectangle(m_rectEllipse);
}
Output:
-
7/30/2019 VP Lab Exercise
17/75
Ex.No:4 THREADS
Coding:
#if
!defined(AFX_COMPUTEDLG_H__92A3AEA5_1634_456F_B880_5BAC9C191821__INCLUDED_)
#define AFX_COMPUTEDLG_H__92A3AEA5_1634_456F_B880_5BAC9C191821__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// ComputeDlg.h : header file//
/////////////////////////////////////////////////////////////////////////////
// CComputeDlg dialog
class CComputeDlg : public CDialog
{
// Construction
public:
CComputeDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CComputeDlg)
enum { IDD = IDD_DIALOG1 };
// NOTE: the ClassWizard will add data members here
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CComputeDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
-
7/30/2019 VP Lab Exercise
18/75
//}}AFX_VIRTUAL
private:
int m_nTimer;
int m_nCount;
enum { nMaxCount = 10000 };
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CComputeDlg)
afx_msg void OnTimer(UINT nIDEvent);
afx_msg void OnStart();
virtual void OnCancel();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_COMPUTEDLG_H__92A3AEA5_1634_456F_B880_5BAC9C191821__INCLUDED_)
// ComputeDlg.cpp : implementation file
#include "stdafx.h"
#include "Thread.h"
#include "ComputeDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
-
7/30/2019 VP Lab Exercise
19/75
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CComputeDlg dialog
CComputeDlg::CComputeDlg(CWnd* pParent /*=NULL*/)
: CDialog(CComputeDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CComputeDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
m_nCount = 0;
}
void CComputeDlg::DoDataExchange(CDataExchange* pDX)
{CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CComputeDlg)
// NOTE: the ClassWizard will add DDX and DDV calls here
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CComputeDlg, CDialog)
//{{AFX_MSG_MAP(CComputeDlg)
ON_WM_TIMER()
ON_BN_CLICKED(IDC_START, OnStart)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CComputeDlg message handlers
-
7/30/2019 VP Lab Exercise
20/75
void CComputeDlg::OnStart()
{
MSG message;
m_nTimer = SetTimer(1, 100, NULL);
ASSERT(m_nTimer != 0);
GetDlgItem(IDC_START)->EnableWindow(FALSE);
volatile int nTemp;
for (m_nCount = 0; m_nCount < nMaxCount; m_nCount++)
{
for (nTemp = 0; nTemp < 100; nTemp++) { }
if(::PeekMessage(&message, NULL, 0, 0, PM_REMOVE))
{ ::TranslateMessage(&message);
::DispatchMessage(&message);
}
}
CDialog::OnOK();
}
void CComputeDlg::OnTimer(UINT nIDEvent)
{
CProgressCtrl* pBar = (CProgressCtrl*)GetDlgItem(IDC_PROGRESS1);
pBar->SetPos(m_nCount * 10000 / nMaxCount);
}
void CComputeDlg::OnCancel()
{
TRACE("entering CComputeDlg::OnCancel\n");
if(m_nCount == 0)
-
7/30/2019 VP Lab Exercise
21/75
{
CDialog::OnCancel();
}
else
{
m_nCount = nMaxCount;
}
}
// ThreadView.cpp : implementation of the CThreadView class
#include "stdafx.h"
#include "Thread.h"
#include "ThreadDoc.h"
#include "ThreadView.h"
#include "ComputeDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CThreadView
IMPLEMENT_DYNCREATE(CThreadView, CView)
BEGIN_MESSAGE_MAP(CThreadView, CView)
//{{AFX_MSG_MAP(CThreadView)
ON_WM_LBUTTONDOWN()
-
7/30/2019 VP Lab Exercise
22/75
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CThreadView construction/destruction
CThreadView::CThreadView()
{
// TODO: add construction code here
}
CThreadView::~CThreadView()
{
}
BOOL CThreadView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CThreadView drawing
void CThreadView::OnDraw(CDC* pDC)
{
pDC->TextOut(0,0,"Press the left mouse button here.");
}
/////////////////////////////////////////////////////////////////////////////
// CThreadView diagnostics
#ifdef _DEBUG
-
7/30/2019 VP Lab Exercise
23/75
void CThreadView::AssertValid() const
{
CView::AssertValid();
}
void CThreadView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CThreadDoc* CThreadView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CThreadDoc)));
return (CThreadDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CThreadView message handlers
void CThreadView::OnLButtonDown(UINT nFlags, CPoint point)
{
CComputeDlg dlg;
dlg.DoModal();
}
-
7/30/2019 VP Lab Exercise
24/75
Output:
-
7/30/2019 VP Lab Exercise
25/75
Ex.No:5 DOCUMENT VIEW ARCHITECTURE
Coding:
// dvaView.h : interface of the CDvaView class
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_DVAVIEW_H__A638B869_17F8_439B_AAC4_45EF008A67E9__INCLUDED_)
#define AFX_DVAVIEW_H__A638B869_17F8_439B_AAC4_45EF008A67E9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CDvaView : public CView
{
protected: // create from serialization only
CDvaView();
DECLARE_DYNCREATE(CDvaView)
public:
CPoint old;
// Attributes
public:
CDvaDoc* GetDocument();
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CDvaView)
public:
-
7/30/2019 VP Lab Exercise
26/75
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CDvaView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CDvaView)
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
#ifndef _DEBUG // debug version in dvaView.cpp
inline CDvaDoc* CDvaView::GetDocument()
{ return (CDvaDoc*)m_pDocument; }
#endif
-
7/30/2019 VP Lab Exercise
27/75
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //!defined(AFX_DVAVIEW_H__A638B869_17F8_439B_AAC4_45EF008A67E9__INCLUDED_)
// dvaView.cpp : implementation of the CDvaView class
#include "stdafx.h"
#include "dva.h"
#include "dvaDoc.h"
#include "dvaView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CDvaView
IMPLEMENT_DYNCREATE(CDvaView, CView)
BEGIN_MESSAGE_MAP(CDvaView, CView)
//{{AFX_MSG_MAP(CDvaView)
ON_WM_MOUSEMOVE()
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()
-
7/30/2019 VP Lab Exercise
28/75
/////////////////////////////////////////////////////////////////////////////
// CDvaView construction/destruction
CDvaView::CDvaView()
{
// TODO: add construction code here
}
CDvaView::~CDvaView()
{
}
BOOL CDvaView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CDvaView drawing
void CDvaView::OnDraw(CDC* pDC)
{
CDvaDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
}
/////////////////////////////////////////////////////////////////////////////
// CDvaView printing
BOOL CDvaView::OnPreparePrinting(CPrintInfo* pInfo)
-
7/30/2019 VP Lab Exercise
29/75
{
// default preparation
return DoPreparePrinting(pInfo);
}
void CDvaView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add extra initialization before printing
}
void CDvaView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add cleanup after printing
}
/////////////////////////////////////////////////////////////////////////////
// CDvaView diagnostics
#ifdef _DEBUG
void CDvaView::AssertValid() const
{
CView::AssertValid();
}
void CDvaView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CDvaDoc* CDvaView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDvaDoc)));
-
7/30/2019 VP Lab Exercise
30/75
return (CDvaDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CDvaView message handlers
void CDvaView::OnMouseMove(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CView::OnMouseMove(nFlags, point);
CClientDC dc(this);
if(nFlags==MK_LBUTTON)
{
dc.MoveTo(old.x,old.y);
dc.LineTo(point.x,point.y);
old=point;
}
}
Output:
-
7/30/2019 VP Lab Exercise
31/75
Ex.No:6 DYNAMIC CONTROLS
Coding:
STDMETHODIMP CTEST_ATL::add(long a, long b, long *c)
{
*c=a+b;
return S_OK;
}
Private Sub Command1_Click()
Dim a As MY_ATLLib.TEST_ATL
Set a = New TEST_ATL
Dim x As Long
a.Add 20, 30, x
MsgBox ("20 + 30 =" & x)
End Sub
-
7/30/2019 VP Lab Exercise
32/75
Ex.No:7A MENUS AND KEYBOARD ACCELERATORS
Coding:
// menukeyDoc.h : interface of the CMenukeyDoc class
//
/////////////////////////////////////////////////////////////////////////////
#if
!defined(AFX_MENUKEYDOC_H__FB11C03A_C46E_4BD7_87B6_1A8F1C1846B4__INCLUDED_)
#define AFX_MENUKEYDOC_H__FB11C03A_C46E_4BD7_87B6_1A8F1C1846B4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CMenukeyDoc : public CDocument
{
public:
CString m_strText;
protected: // create from serialization only
CMenukeyDoc();
DECLARE_DYNCREATE(CMenukeyDoc)
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CMenukeyDoc)
public:
virtual BOOL OnNewDocument();
-
7/30/2019 VP Lab Exercise
33/75
virtual void Serialize(CArchive& ar);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CMenukeyDoc();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CMenukeyDoc)
afx_msg void OnEditClearAll();
afx_msg void OnUpdateEditClearAll(CCmdUI* pCmdUI);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_MENUKEYDOC_H__FB11C03A_C46E_4BD7_87B6_1A8F1C1846B4__INCLUDED_)
// menukeyDoc.cpp : implementation of the CMenukeyDoc class
//
#include "stdafx.h"
#include "menukey.h"
-
7/30/2019 VP Lab Exercise
34/75
#include "menukeyDoc.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMenukeyDoc
IMPLEMENT_DYNCREATE(CMenukeyDoc, CDocument)
BEGIN_MESSAGE_MAP(CMenukeyDoc, CDocument)
//{{AFX_MSG_MAP(CMenukeyDoc)
ON_COMMAND(ID_EDIT_CLEAR_ALL, OnEditClearAll)
ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR_ALL, OnUpdateEditClearAll)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMenukeyDoc construction/destruction
CMenukeyDoc::CMenukeyDoc()
{
// TODO: add one-time construction code here
}
CMenukeyDoc::~CMenukeyDoc()
{
}
BOOL CMenukeyDoc::OnNewDocument()
{
-
7/30/2019 VP Lab Exercise
35/75
if (!CDocument::OnNewDocument())
return FALSE;
m_strText = "Welcome Message from Document";
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CMenukeyDoc serialization
void CMenukeyDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// TODO: add storing code here
}
else
{
// TODO: add loading code here
}
}
/////////////////////////////////////////////////////////////////////////////
// CMenukeyDoc diagnostics
#ifdef _DEBUG
void CMenukeyDoc::AssertValid() const
{
CDocument::AssertValid();
}
void CMenukeyDoc::Dump(CDumpContext& dc) const
-
7/30/2019 VP Lab Exercise
36/75
{
CDocument::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMenukeyDoc commands
void CMenukeyDoc::OnEditClearAll()
{
m_strText.Empty();
}
void CMenukeyDoc::OnUpdateEditClearAll(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!m_strText.IsEmpty());
}
// menukeyView.h : interface of the CMenukeyView class
//
/////////////////////////////////////////////////////////////////////////////
#if
!defined(AFX_MENUKEYVIEW_H__40F159D9_4F49_4D42_BEC1_BB50659C14C2__INCLUDED_
)
#define AFX_MENUKEYVIEW_H__40F159D9_4F49_4D42_BEC1_BB50659C14C2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CMenukeyView : public CView
{
public:
-
7/30/2019 VP Lab Exercise
37/75
CRichEditCtrl m_rich;
protected: // create from serialization only
CMenukeyView();
DECLARE_DYNCREATE(CMenukeyView)
// Attributes
public:
CMenukeyDoc* GetDocument();
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CMenukeyView)
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CMenukeyView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
-
7/30/2019 VP Lab Exercise
38/75
protected:
//{{AFX_MSG(CMenukeyView)
afx_msg void OnTransferGetdata();
afx_msg void OnTransferStoredata();
afx_msg void OnUpdateTransferStoredata(CCmdUI* pCmdUI);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnSize(UINT nType, int cx, int cy);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
#ifndef _DEBUG // debug version in menukeyView.cpp
inline CMenukeyDoc* CMenukeyView::GetDocument()
{ return (CMenukeyDoc*)m_pDocument; }
#endif
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_MENUKEYVIEW_H__40F159D9_4F49_4D42_BEC1_BB50659C14C2__INCLUDED_
)
// menukeyView.cpp : implementation of the CMenukeyView class
//
#include "stdafx.h"
#include "menukey.h"
#include "menukeyDoc.h"
#include "menukeyView.h"
#ifdef _DEBUG
-
7/30/2019 VP Lab Exercise
39/75
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMenukeyView
IMPLEMENT_DYNCREATE(CMenukeyView, CView)
BEGIN_MESSAGE_MAP(CMenukeyView, CView)
//{{AFX_MSG_MAP(CMenukeyView)
ON_COMMAND(ID_TRANSFER_GETDATA, OnTransferGetdata)
ON_COMMAND(ID_TRANSFER_STOREDATA, OnTransferStoredata)
ON_UPDATE_COMMAND_UI(ID_TRANSFER_STOREDATA, OnUpdateTransferStoredata)
ON_WM_CREATE()
ON_WM_SIZE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMenukeyView construction/destruction
CMenukeyView::CMenukeyView()
{
// TODO: add construction code here
}
CMenukeyView::~CMenukeyView()
{
}
BOOL CMenukeyView::PreCreateWindow(CREATESTRUCT& cs)
-
7/30/2019 VP Lab Exercise
40/75
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CMenukeyView drawing
void CMenukeyView::OnDraw(CDC* pDC)
{
CMenukeyDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
}
/////////////////////////////////////////////////////////////////////////////
// CMenukeyView diagnostics
#ifdef _DEBUG
void CMenukeyView::AssertValid() const
{
CView::AssertValid();
}
void CMenukeyView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CMenukeyDoc* CMenukeyView::GetDocument() // non-debug version is inline
-
7/30/2019 VP Lab Exercise
41/75
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMenukeyDoc)));
return (CMenukeyDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMenukeyView message handlers
void CMenukeyView::OnTransferGetdata()
{
CMenukeyDoc* pDoc = GetDocument();
m_rich.SetWindowText(pDoc->m_strText);
m_rich.SetModify(FALSE);
}
void CMenukeyView::OnTransferStoredata()
{
CMenukeyDoc* pDoc = GetDocument();
m_rich.GetWindowText(pDoc->m_strText);
m_rich.SetModify(FALSE);
}
void CMenukeyView::OnUpdateTransferStoredata(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_rich.GetModify());
}
int CMenukeyView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
CRect rect(0, 0, 0, 0);
-
7/30/2019 VP Lab Exercise
42/75
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
m_rich.Create(ES_AUTOVSCROLL | ES_MULTILINE | ES_WANTRETURN | WS_CHILD |
WS_VISIBLE | WS_VSCROLL, rect, this, 1);
return 0;
}
void CMenukeyView::OnSize(UINT nType, int cx, int cy)
{
CRect rect;
CView::OnSize(nType, cx, cy);
GetClientRect(rect);
m_rich.SetWindowPos(&wndTop, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
SWP_SHOWWINDOW);
}
Output:
-
7/30/2019 VP Lab Exercise
43/75
TOOLBAR AND TOOLTIP
Coding:
// toolbardemoView.h : interface of the CToolbardemoView class
/////////////////////////////////////////////////////////////////////////////
#if
!defined(AFX_TOOLBARDEMOVIEW_H__046F901A_C758_4ECA_AAAB_B028F391B7F7
__INCLUDED_)
#define
AFX_TOOLBARDEMOVIEW_H__046F901A_C758_4ECA_AAAB_B028F391B7F7__INCL
UDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CToolbardemoView : public CView
{
private:
CRect m_rect;
BOOL m_bCircle;
BOOL m_bPattern;
protected: // create from serialization only
CToolbardemoView();
DECLARE_DYNCREATE(CToolbardemoView)
// Attributes
public:
CToolbardemoDoc* GetDocument();
// Operations
-
7/30/2019 VP Lab Exercise
44/75
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CToolbardemoView)
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CToolbardemoView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CToolbardemoView)
afx_msg void OnDrawSquare();
afx_msg void OnUpdateDrawSquare(CCmdUI* pCmdUI);
afx_msg void OnDrawCircle();
afx_msg void OnUpdateDrawCircle(CCmdUI* pCmdUI);
afx_msg void OnDrawPattern();
-
7/30/2019 VP Lab Exercise
45/75
afx_msg void OnUpdateDrawPattern(CCmdUI* pCmdUI);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
#ifndef _DEBUG // debug version in toolbardemoView.cpp
inline CToolbardemoDoc* CToolbardemoView::GetDocument()
{ return (CToolbardemoDoc*)m_pDocument; }
#endif
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_TOOLBARDEMOVIEW_H__046F901A_C758_4ECA_AAAB_B028F391B7F7
__INCLUDED_)
// toolbardemoView.cpp : implementation of the CToolbardemoView class
//
#include "stdafx.h"
#include "toolbardemo.h"
#include "toolbardemoDoc.h"
#include "toolbardemoView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
-
7/30/2019 VP Lab Exercise
46/75
// CToolbardemoView
IMPLEMENT_DYNCREATE(CToolbardemoView, CView)
BEGIN_MESSAGE_MAP(CToolbardemoView, CView)
//{{AFX_MSG_MAP(CToolbardemoView)
ON_COMMAND(ID_DRAW_SQUARE, OnDrawSquare)
ON_UPDATE_COMMAND_UI(ID_DRAW_SQUARE, OnUpdateDrawSquare)
ON_COMMAND(ID_DRAW_CIRCLE, OnDrawCircle)
ON_UPDATE_COMMAND_UI(ID_DRAW_CIRCLE, OnUpdateDrawCircle)
ON_COMMAND(ID_DRAW_PATTERN, OnDrawPattern)
ON_UPDATE_COMMAND_UI(ID_DRAW_PATTERN, OnUpdateDrawPattern)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CToolbardemoView construction/destruction
CToolbardemoView::CToolbardemoView():m_rect(0,0,100,100)
{
m_bCircle=TRUE;
m_bPattern=FALSE;
}
CToolbardemoView::~CToolbardemoView()
{
}
BOOL CToolbardemoView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
-
7/30/2019 VP Lab Exercise
47/75
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CToolbardemoView drawing
void CToolbardemoView::OnDraw(CDC* pDC)
{
CToolbardemoDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
CBrush brush(HS_VERTICAL,0L);
if(m_bPattern)
{
pDC->SelectObject(&brush);
}
else
{
pDC->SelectStockObject(WHITE_BRUSH);
}
if(m_bCircle)
{
pDC->Ellipse(m_rect);
}
else
{
pDC->Rectangle(m_rect);
-
7/30/2019 VP Lab Exercise
48/75
}
pDC->SelectStockObject(WHITE_BRUSH);
}
/////////////////////////////////////////////////////////////////////////////
// CToolbardemoView diagnostics
#ifdef _DEBUG
void CToolbardemoView::AssertValid() const
{
CView::AssertValid();
}
void CToolbardemoView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CToolbardemoDoc* CToolbardemoView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CToolbardemoDoc)));
return (CToolbardemoDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CToolbardemoView message handlers
void CToolbardemoView::OnDrawSquare()
{
m_bCircle=FALSE;
-
7/30/2019 VP Lab Exercise
49/75
m_rect+=CPoint(25,25);
InvalidateRect(m_rect);
}
void CToolbardemoView::OnUpdateDrawSquare(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_bCircle);
}
void CToolbardemoView::OnDrawCircle()
{
m_bCircle=TRUE;
m_rect+=CPoint(25,25);
InvalidateRect(m_rect);
}
void CToolbardemoView::OnUpdateDrawCircle(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!m_bCircle);
}
void CToolbardemoView::OnDrawPattern()
{
m_bPattern^=1;
}
void CToolbardemoView::OnUpdateDrawPattern(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_bPattern);
}
-
7/30/2019 VP Lab Exercise
50/75
Output:
-
7/30/2019 VP Lab Exercise
51/75
Ex.No:8 ACTIVE X CONTROLS
Coding:
activexDialog.h
//{{AFX_INCLUDES()
#include "calendar.h"
//}}AFX_INCLUDES
#if!defined(AFX_ACTIVEXDIALOG_H__92769575_3752_49C8_93BE_C0FA20506459__INCLUDED_)
#define AFX_ACTIVEXDIALOG_H__92769575_3752_49C8_93BE_C0FA20506459__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// ActiveXDialog.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CActiveXDialog dialog
class CActiveXDialog : public CDialog
-
7/30/2019 VP Lab Exercise
52/75
{
// Construction
public:
CActiveXDialog(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CActiveXDialog)
enum { IDD = IDD_ACTIVEXDIALOG }
CCalendarm_calendar;
shortm_sDay;
shortm_sMonth;
shortm_sYear;
//}}AFX_DATA
COleVariant m_varValue;
unsigned long m_BackColor;
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CActiveXDialog)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CActiveXDialog)
virtual BOOL OnInitDialog();
afx_msg void OnNewMonthCalendar1();
-
7/30/2019 VP Lab Exercise
53/75
afx_msg void OnSelectdate();
afx_msg void OnNextweek();
virtual void OnOK();
DECLARE_EVENTSINK_MAP()
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_ACTIVEXDIALOG_H__92769575_3752_49C8_93BE_C0FA20506459__INCLUDED_)
// ActiveXDialog.cpp : implementation file
//
#include "stdafx.h"
#include "active.h"
#include "ActiveXDialog.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CActiveXDialog dialog
CActiveXDialog::CActiveXDialog(CWnd* pParent /*=NULL*/)
:CDialog(CActiveXDialog::IDD, pParent)
{
-
7/30/2019 VP Lab Exercise
54/75
//{{AFX_DATA_INIT(CActiveXDialog)
m_sDay = 0;
m_sMonth = 0;
m_sYear = 0;
//}}AFX_DATA_INIT
m_BackColor = 0x8000000F;
}
void CActiveXDialog::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CActiveXDialog)
DDX_Control(pDX, IDC_CALENDAR1, m_calendar);
DDX_Text(pDX, IDC_DAY, m_sDay);
DDX_Text(pDX, IDC_MONTH, m_sMonth);
DDX_Text(pDX, IDC_YEAR, m_sYear);
DDX_Control(pDX,IDC_CALENDAR1,m_calendar);
DDX_OCColor(pDX,IDC_CALENDAR1,DISPID_BACKCOLOR,m_BackColor);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CActiveXDialog, CDialog)
//{{AFX_MSG_MAPCActiveXDialog)
ON_BN_CLICKED(IDC_SELECTDATE, OnSelectdate)
ON_BN_CLICKED(IDC_NEXTWEEK, OnNextweek)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
-
7/30/2019 VP Lab Exercise
55/75
// CActiveXDialog message handlers
BEGIN_EVENTSINK_MAP(CActiveXDialog, CDialog)
//{{AFX_EVENTSINK_MAP(CActiveXDialog)
ON_EVENT(CActiveXDialog, IDC_CALENDAR1, 3 /* NewMonth */, OnNewMonthCalendar1,
VTS_NONE)
//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()
BOOL CActiveXDialog::OnInitDialog()
{
CDialog::OnInitDialog();
m_calendar.SetValue(m_varValue);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CActiveXDialog::OnNewMonthCalendar1()
{
AfxMessageBox("EVENT:ActiveXDialog::OnNewMonthCalender1");
}
void CActiveXDialog::OnSelectdate()
{
CDataExchange dx(this,TRUE);
DDX_Text(&dx,IDC_DAY,m_sDay);
DDX_Text(&dx,IDC_MONTH,m_sMonth);
DDX_Text(&dx,IDC_YEAR,m_sYear);
m_calendar.SetDay(m_sDay);
m_calendar.SetMonth(m_sMonth);
m_calendar.SetYear(m_sYear);
-
7/30/2019 VP Lab Exercise
56/75
}
void CActiveXDialog::OnNextweek()
{
m_calendar.NextWeek();
}
void CActiveXDialog::OnOK()
{
CDialog::OnOK();
m_varValue = m_calendar.GetValue();
}
// activeView.cpp : implementation of the CActiveView class
//
#include "stdafx.h"
#include "active.h"
#include "activeDoc.h"
#include "activeView.h"
#include "ActiveXDialog.h""
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CActiveView
IMPLEMENT_DYNCREATE(CActiveView, CView)
BEGIN_MESSAGE_MAP(CActiveView, CView)
-
7/30/2019 VP Lab Exercise
57/75
//{{AFX_MSG_MAP(CActiveView)
ON_WM_LBUTTONDOWN()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CActiveView construction/destruction
CActiveView::CActiveView()
{
// TODO: add construction code here
}
CActiveView::~CActiveView()
{}
BOOL CActiveView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CActiveView drawing
void CActiveView::OnDraw(CDC* pDC)
{
pDC->TextOut(0,0,"Press the left mouse button here");
}
/////////////////////////////////////////////////////////////////////////////
// CActiveView diagnostics
-
7/30/2019 VP Lab Exercise
58/75
#ifdef _DEBUG
void CActiveView::AssertValid() const
{
CView::AssertValid();
}
void CActiveView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CActiveDoc* CActiveView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CActiveDoc)));
return (CActiveDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CActiveView message handlers
void CActiveView::OnLButtonDown(UINT nFlags, CPoint point)
{
CActiveXDialog dlg;
dlg.m_BackColor=RGB(255,251,240);
COleDateTime today=COleDateTime::GetCurrentTime();
dlg.m_varValue=COleDateTime(today.GetYear(),today.GetMonth(),today.GetDay(),0,0,0);
if(dlg.DoModal()==IDOK)
{
COleDateTime date(dlg.m_varValue);
-
7/30/2019 VP Lab Exercise
59/75
AfxMessageBox(date.Format("%B %d,%Y"));
}
}
Output:
-
7/30/2019 VP Lab Exercise
60/75
Ex.No:9 DATABASE ACCESS THROUGH ODBC
Coding:
// exno9View.cpp : implementation of the CExno9View class
//
#include "stdafx.h"
#include "exno9.h"
#include "exno9Set.h"
#include "exno9Doc.h"
#include "exno9View.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CExno9View
IMPLEMENT_DYNCREATE(CExno9View, CRecordView)
-
7/30/2019 VP Lab Exercise
61/75
BEGIN_MESSAGE_MAP(CExno9View, CRecordView)
//{{AFX_MSG_MAP(CExno9View)
ON_BN_CLICKED(IDC_BUTTON1, OnButton1)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CRecordView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CRecordView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CRecordView::OnFilePrintPreview)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CExno9View construction/destruction
CExno9View::CExno9View()
: CRecordView(CExno9View::IDD)
{
//{{AFX_DATA_INIT(CExno9View)
m_pSet = NULL;
m_text1 = _T("");
m_text2 = _T("");
//}}AFX_DATA_INIT
// TODO: add construction code here
}
CExno9View::~CExno9View()
{
}
void CExno9View::DoDataExchange(CDataExchange* pDX)
{
-
7/30/2019 VP Lab Exercise
62/75
CRecordView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CExno9View)
DDX_Text(pDX, IDC_EDIT1, m_text1);
DDX_Text(pDX, IDC_EDIT2, m_text2);
//}}AFX_DATA_MAP
}
BOOL CExno9View::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CRecordView::PreCreateWindow(cs);
}
void CExno9View::OnInitialUpdate()
{
m_pSet = &GetDocument()->m_exno9Set;
CRecordView::OnInitialUpdate();
GetParentFrame()->RecalcLayout();
ResizeParentToFit();
}
/////////////////////////////////////////////////////////////////////////////
// CExno9View printing
BOOL CExno9View::OnPreparePrinting(CPrintInfo* pInfo)
{
// default preparation
return DoPreparePrinting(pInfo);
}
-
7/30/2019 VP Lab Exercise
63/75
void CExno9View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add extra initialization before printing
}
void CExno9View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add cleanup after printing
}
/////////////////////////////////////////////////////////////////////////////
// CExno9View diagnostics
#ifdef _DEBUG
void CExno9View::AssertValid() const
{
CRecordView::AssertValid();
}
void CExno9View::Dump(CDumpContext& dc) const
{
CRecordView::Dump(dc);
}
CExno9Doc* CExno9View::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CExno9Doc)));
return (CExno9Doc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
-
7/30/2019 VP Lab Exercise
64/75
// CExno9View database support
CRecordset* CExno9View::OnGetRecordset()
{
return m_pSet;
}
/////////////////////////////////////////////////////////////////////////////
// CExno9View message handlers
void CExno9View::OnButton1()
{
m_text1=m_pSet->m_Book_Name;
UpdateData(false);
m_text2=m_pSet->m_Each_Cost;
UpdateData(false);
}
Output:
-
7/30/2019 VP Lab Exercise
65/75
Ex.No:10 CREATING DLL
Coding:
// MyClass.cpp: implementation of the CMyClass class.
//
//////////////////////////////////////////////////////////////////////
-
7/30/2019 VP Lab Exercise
66/75
#include "stdafx.h"
#include "MyDll.h"
#include "MyClass.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CMyClass::CMyClass()
{
}
CMyClass::~CMyClass()
{
}
CString CMyClass::SayHello(CString strName)
{
return "Hello"+ strName;
}
// MyClass.h: interface for the CMyClass class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_MYCLASS_H__46E97A1F_2212_4182_885F_D489C6B0EEC4__INCLUDED_)
#define AFX_MYCLASS_H__46E97A1F_2212_4182_885F_D489C6B0EEC4__INCLUDED_
-
7/30/2019 VP Lab Exercise
67/75
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CMyClass
{
public:
_declspec(dllexport)CString SayHello(CString strName);
_declspec(dllexport)CMyClass();
_declspec(dllexport)virtual ~CMyClass();
};
#endif //
!defined(AFX_MYCLASS_H__46E97A1F_2212_4182_885F_D489C6B0EEC4__INCLUDED_)
// TestDllDlg.cpp : implementation file
//
#include "stdafx.h"
#include "TestDll.h"
#include "TestDllDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
-
7/30/2019 VP Lab Exercise
68/75
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
-
7/30/2019 VP Lab Exercise
69/75
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestDllDlg dialog
CTestDllDlg::CTestDllDlg(CWnd* pParent /*=NULL*/)
: CDialog(CTestDllDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CTestDllDlg)
m_edit = _T("");
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CTestDllDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CTestDllDlg)
DDX_Text(pDX, IDC_NAME, m_edit);
//}}AFX_DATA_MAP
}
-
7/30/2019 VP Lab Exercise
70/75
BEGIN_MESSAGE_MAP(CTestDllDlg, CDialog)
//{{AFX_MSG_MAP(CTestDllDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestDllDlg message handlers
BOOL CTestDllDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
-
7/30/2019 VP Lab Exercise
71/75
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE);// Set big icon
SetIcon(m_hIcon, FALSE);// Set small icon
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
}
void CTestDllDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CTestDllDlg::OnPaint()
-
7/30/2019 VP Lab Exercise
72/75
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CTestDllDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
-
7/30/2019 VP Lab Exercise
73/75
void CTestDllDlg::OnOK()
{
UpdateData(true);
CString str=objMyClass.SayHello(m_edit);
AfxMessageBox(str);
}
// TestDllDlg.h : header file
//
#include "z:\MyDll\MyClass.h"
#if
!defined(AFX_TESTDLLDLG_H__F91ED0AE_7208_4844_9E0B_A3FCB470A634__INCLUDED_)
#define AFX_TESTDLLDLG_H__F91ED0AE_7208_4844_9E0B_A3FCB470A634__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CTestDllDlg dialog
class CTestDllDlg : public CDialog
{
// Construction
public:
CMyClass objMyClass;
CTestDllDlg(CWnd* pParent = NULL);// standard constructor
// Dialog Data
//{{AFX_DATA(CTestDllDlg)
enum { IDD = IDD_TESTDLL_DIALOG };
-
7/30/2019 VP Lab Exercise
74/75
CStringm_edit;
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CTestDllDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX);// DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CTestDllDlg)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
virtual void OnOK();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif //
!defined(AFX_TESTDLLDLG_H__F91ED0AE_7208_4844_9E0B_A3FCB470A634__INCLUDED_)
Output:
-
7/30/2019 VP Lab Exercise
75/75