FAQ VC++ et MFCConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
void CMyDlg::OnOK()  
{  
     m_nIndiceSel = m_ListBox.GetCurSel();  
     if(m_nIndiceSel!=-1)  
     m_ListBox.GetText( m_nIndiceSel,m_strSel );  
     CDialog::OnOK();  
}  
void CMyView::OnShowDialog()  
{  
   CMyDlg dlg ;  
   if (dlg.DoModal()==IDOK)  
   {  
      CString str ;  
      str.Format("%d:",dlg.m_nIndiceSel) ;  
      AfxMessageBox(str+dlg.m_strSel) ;  
   }  
}

1
2
3
  
CWnd::OnCommand 
virtual BOOL OnCommand(WPARAM wParam,LPARAM lParam );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  
BOOL CAboutDlg::OnCommand(WPARAM wParam, LPARAM lParam)  
{ 
    // TODO: Add your specialized code here and/or call the base class 
    CWnd *pWnd = GetFocus(); 
    switch(wParam) 
    { 
      case IDOK: if(pWnd!=GetDlgItem(IDOK)) 
                 { 
                      return FALSE; 
                 } 
                 break; 
  
      case IDCANCEL:if(pWnd!=GetDlgItem(IDCANCEL)) 
                    { 
                        return FALSE; 
                    } 
                    break; 
    } 
    return CDialog::OnCommand(wParam, lParam); 
}

1
2
3
  
CWnd::PreTranslateMessage 
virtual BOOL PreTranslateMessage( MSG* pMsg );

1
2
3
4
5
6
7
8
9
10
  
BOOL CAboutDlg::PreTranslateMessage(MSG* pMsg)  
{ 
  if(pMsg->message == WM_KEYDOWN) 
  { 
    if(pMsg->wParam == VK_ESCAPE)  return TRUE; 
    if(pMsg->wParam == VK_RETURN)  return TRUE; 
  } 
  return CDialog::PreTranslateMessage(pMsg); 
}

1
2
3
  
virtual void OnOK(); 
virtual void OnCancel();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
  
class CDlg1: public CDialog  
{ 
public: 
CDlg1(CWnd* pParent = NULL);// standard constructor 
        // Generated message map functions 
//{{AFX_MSG(CDlg1) 
virtual BOOL OnInitDialog(); 
afx_msg void OnButton1(); 
//}}AFX_MSG 
DECLARE_MESSAGE_MAP() 
}; 
  
class CDlg2: public CDialog  
{ 
public: 
    CDlg2(CWnd* pParent = NULL);// standard constructor 
// Generated message map functions 
//{{AFX_MSG(CDlg2) 
    virtual BOOL OnInitDialog(); 
    virtual void OnOK(); 
//}}AFX_MSG 
DECLARE_MESSAGE_MAP() 
public: 
}; 
// appel dlg1 
CDlg1 dlg; 
dlg.DoModal(); 
  
void CDlg1::OnButton1()  
{ 
    // TODO: Add your control notification handler code here 
    CDlg2 dlg(this); // fournit comme parent CDlg1 par exemple  
                            // ou alors affectation à une variable interne. 
                            // par un accesseur etc... 
    dlg.DoModal();  
} 
  
void CDlg2::OnOK()  
{ 
    // TODO: Add extra validation here 
    CDlg1 *pDlg=( CDlg1 *)GetParent(); 
    // Maintenant j'ai accès à la boite de dialogue CDlg1. 
  
   CDialog::OnOK(); 
}

1
2
3
4
5
6
7
void CTestDlgDlg::OnButton1()  
{ 
    // TODO: Add your control notification handler code here 
    CDialog1 dlg; 
    dlg.m_strEdit1="coucou" ; 
    dlg.DoModal(); 
}

1
2
3
4
5
6
7
8
9
BOOL CDialog1::OnInitDialog()  
{ 
    CDialog::OnInitDialog(); 
  
    // TODO: Add extra initialization here 
    UpdateData(FALSE); // mise à jour des contrôles 
    return TRUE;  // return TRUE unless you set the focus to a control 
                  // EXCEPTION: OCX Property Pages should return FALSE 
}

1
2
3
4
CDialog1 Dlg; 
Dlg.m_Listbox.AddString("essai"); 
Dlg.m_Listbox.AddString("essai1"); 
Dlg.DoModal();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class CMyListBox : public CListBox 
{ 
// Construction 
public: 
    CMyListBox(); 
  
// Attributes 
public: 
  
    int  AddString( LPCTSTR lpszItem ); 
  
// Operations 
public: 
    CStringArray m_strArray; 
  
    // Overrides 
    // ClassWizard generated virtual function overrides 
    //{{AFX_VIRTUAL(CMyListBox) 
public: 
protected: 
    virtual void PreSubclassWindow(); 
    //}}AFX_VIRTUAL 
  
// Implementation 
public: 
    virtual ~CMyListBox(); 
  
// Generated message map functions 
protected: 
    //{{AFX_MSG(CMyListBox) 
    //}}AFX_MSG 
    DECLARE_MESSAGE_MAP() 
}; 
  
int CMyListBox::AddString(LPCTSTR lpszItem) 
{ 
    // si la listbox est valide appel de la fonction d'origine.  
    if(m_hWnd!=NULL) return CListBox::AddString(lpszItem); 
    m_strArray.Add(lpszItem); 
    return LB_ERR; 
} 
void CMyListBox::PreSubclassWindow()  
{ 
    // TODO: Add your specialized code here and/or call the base class 
    CListBox::PreSubclassWindow();     
    for(int i=0; i<m_strArray.GetSize(); i++) 
        AddString(m_strArray[i]); 
}

1
2
3
4
5
6
7
  
void CMyFormView::OnButtonMachin() // c'est un exemple bien sur ...  
{  
 CMyDialog Dlg(this) 
  
Dlg.DoModal();  
}

1
2
3
4
5
6
  
BOOL CMyDialog::OnInitDialog()  
{  
   CDialog::OnInitDialog();  
   CMyFormView *pView=static_cast< CMyFormView *>(GetParent());  
//&#8230;&#8230;&#8230;&#8230;&#8230;

1
2
3
4
5
6
  
BOOL CMyDialog::OnInitDialog()  
{  
   CDialog::OnInitDialog();  
   CMyFormView *pView=static_cast< CMyFormView *>(m_pParentWnd);  
//&#8230;&#8230;&#8230;&#8230;&#8230;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//----------------------------------------------------------- 
CDialog *CSwitchDlgDlg::CreatePage(UINT nPlaceCtrlId,UINT nDialogID,CRuntimeClass *pClass/*=NULL*/) 
{ 
    CDialog *pDlg=NULL; 
    if(pClass) pDlg=reinterpret_cast<CDialog *>(pClass->CreateObject()); 
    else   pDlg= new CDialog; 
  
    pDlg->Create(nDialogID,this); 
  
    ASSERT(IsWindow(pDlg->m_hWnd)); 
  
    CRect rect; 
    CWnd *pWnd = GetDlgItem(nPlaceCtrlId); 
    ASSERT(pWnd != NULL); 
    ASSERT(IsWindow(pWnd->m_hWnd)); 
    pWnd->GetWindowRect(&rect); 
    ScreenToClient(&rect); 
    pDlg->SetWindowPos(NULL, rect.left, rect.top, 0, 0,  
                        SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE ); 
    pDlg->EnableWindow(TRUE); 
  
    return pDlg; 
}

1
2
3
4
5
6
7
// desactive 
pDlg->ShowWindow(SW_HIDE); 
pDlg->EnableWindow(FALSE); 
  
// active l'autre fenetre 
pDlg2->ShowWindow(SW_SHOW); 
pDlg2->EnableWindow(TRUE);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
CMyDialog::CMyDialog(CWnd* pParent /*=NULL*/) 
  : CDialog(CMyDialog::IDD, pParent) 
{ 
    /*bool*/ m_bShow = false; 
} 
void CMyDialog::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)  
{ 
  if(!m_bShow) lpwndpos->flags &= ~SWP_SHOWWINDOW; 
  CDialog::OnWindowPosChanging(lpwndpos); 
} 
void CMyDialog::SetShowWindow() 
{ 
 m_bShow = true; 
 ShowWindow(SW_SHOW); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// le header 
class CTestDlg : public CDialog 
{ 
// Construction 
public: 
  
    CTestDlg(CWnd* pParent = NULL);   // standard constructor 
  
// Dialog Data 
//{{AFX_DATA(CTestDlg) 
    enum { IDD = IDD_DIALOGTEST }; 
// NOTE: the ClassWizard will add data members here 
//}}AFX_DATA 
  
public: 
    bool  m_bFirstInit; 
  
// Overrides 
// ClassWizard generated virtual function overrides 
//{{AFX_VIRTUAL(CTestDlg) 
  
protected: 
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support 
//}}AFX_VIRTUAL 
  
LRESULT OnRunTest(UINT wParam,LONG lParam); 
  
// Implementation 
protected: 
    // Generated message map functions 
    //{{AFX_MSG(CTestDlg) 
    afx_msg void OnPaint(); 
    //}}AFX_MSG 
    DECLARE_MESSAGE_MAP() 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// la partie .cpp 
#define WM_RUNTEST WM_USER+100 
CTestDlg::CTestDlg(CWnd* pParent /*=NULL*/) 
: CDialog(CTestDlg::IDD, pParent) 
{ 
    //{{AFX_DATA_INIT(CTestDlg) 
    // NOTE: the ClassWizard will add member initialization here 
    //}}AFX_DATA_INIT 
    m_bFirstInit=true; 
} 
void CTestDlg::DoDataExchange(CDataExchange* pDX) 
{ 
    CDialog::DoDataExchange(pDX); 
    //{{AFX_DATA_MAP(CTestDlg) 
    // NOTE: the ClassWizard will add DDX and DDV calls here 
    //}}AFX_DATA_MAP 
} 
  
BEGIN_MESSAGE_MAP(CTestDlg, CDialog) 
//{{AFX_MSG_MAP(CTestDlg) 
ON_WM_PAINT() 
//}}AFX_MSG_MAP 
ON_MESSAGE(WM_RUNTEST,OnRunTest) 
END_MESSAGE_MAP() 
///////////////////////////////////////////////////////////////////////////// 
// CTestDlg message handlers 
void CTestDlg::OnPaint()  
{ 
    CPaintDC dc(this); // device context for painting 
  
    // TODO: Add your message handler code here 
    if(m_bFirstInit) PostMessage(WM_RUNTEST); 
    m_bFirstInit=false; 
    // Do not call CDialog::OnPaint() for painting messages 
} 
LRESULT CTestDlg::OnRunTest(UINT wParam, LONG lParam)  
{ 
    // votre Traitement  
    // 
    // 
    return 0L; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
  
int CMyDialog::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{ 
  if(CDialog::OnCreate(lpCreateStruct) == -1) 
    return -1; 
  
  // TODO: Add your specialized creation code here 
  SetWindowLong(this->m_hWnd, 
                GWL_STYLE, 
                GetWindowLong(this->m_hWnd, GWL_STYLE) | WS_MINIMIZEBOX | WS_MAXIMIZEBOX); 
  
  return 0; 
}

1
2
  
ModifyStyle(0,WS_MINIMIZEBOX | WS_MAXIMIZEBOX);

1
2
3
4
5
6
7
8
9
  
BOOL CTestToolDialogDlg::OnInitDialog() 
{ 
CDialog::OnInitDialog(); 
  
    ModifyStyleEx( WS_EX_APPWINDOW, WS_EX_TOOLWINDOW ); 
........... 
return TRUE;  // return TRUE  unless you set the focus to a control 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
  
void CTestDlg::OnInitMenuPopup(CMenu *pPopupMenu, UINT nIndex,BOOL bSysMenu) 
{ 
    ASSERT(pPopupMenu != NULL); 
    // Check the enabled state of various menu items. 
  
    CCmdUI state; 
    state.m_pMenu = pPopupMenu; 
    ASSERT(state.m_pOther == NULL); 
    ASSERT(state.m_pParentMenu == NULL); 
  
    // Determine if menu is popup in top-level menu and set m_pOther to 
    // it if so (m_pParentMenu == NULL indicates that it is secondary popup). 
    HMENU hParentMenu; 
    if (AfxGetThreadState()->m_hTrackingMenu == pPopupMenu->m_hMenu) 
        state.m_pParentMenu = pPopupMenu;    // Parent == child for tracking popup. 
    else if ((hParentMenu = ::GetMenu(m_hWnd)) != NULL) 
    { 
        CWnd* pParent = this; 
           // Child windows don't have menus--need to go to the top! 
        if (pParent != NULL && 
           (hParentMenu = ::GetMenu(pParent->m_hWnd)) != NULL) 
        { 
           int nIndexMax = ::GetMenuItemCount(hParentMenu); 
           for (int nIndex = 0; nIndex < nIndexMax; nIndex++) 
           { 
            if (::GetSubMenu(hParentMenu, nIndex) == pPopupMenu->m_hMenu) 
            { 
                // When popup is found, m_pParentMenu is containing menu. 
                state.m_pParentMenu = CMenu::FromHandle(hParentMenu); 
                break; 
            } 
           } 
        } 
    } 
  
    state.m_nIndexMax = pPopupMenu->GetMenuItemCount(); 
    for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax; 
      state.m_nIndex++) 
    { 
        state.m_nID = pPopupMenu->GetMenuItemID(state.m_nIndex); 
        if (state.m_nID == 0) 
           continue; // Menu separator or invalid cmd - ignore it. 
  
        ASSERT(state.m_pOther == NULL); 
        ASSERT(state.m_pMenu != NULL); 
        if (state.m_nID == (UINT)-1) 
        { 
           // Possibly a popup menu, route to first item of that popup. 
           state.m_pSubMenu = pPopupMenu->GetSubMenu(state.m_nIndex); 
           if (state.m_pSubMenu == NULL || 
            (state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 || 
            state.m_nID == (UINT)-1) 
           { 
            continue;       // First item of popup can't be routed to. 
           } 
           state.DoUpdate(this, TRUE);   // Popups are never auto disabled. 
        } 
        else 
        { 
           // Normal menu item. 
           // Auto enable/disable if frame window has m_bAutoMenuEnable 
           // set and command is _not_ a system command. 
           state.m_pSubMenu = NULL; 
           state.DoUpdate(this, FALSE); 
        } 
  
        // Adjust for menu deletions and additions. 
        UINT nCount = pPopupMenu->GetMenuItemCount(); 
        if (nCount < state.m_nIndexMax) 
        { 
           state.m_nIndex -= (state.m_nIndexMax - nCount); 
           while (state.m_nIndex < nCount && 
            pPopupMenu->GetMenuItemID(state.m_nIndex) == state.m_nID) 
           { 
            state.m_nIndex++; 
           } 
        } 
        state.m_nIndexMax = nCount; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  
BOOL CAboutDlg::OnInitDialog()  
{ 
    CDialog::OnInitDialog(); 
  
// TODO: Add extra initialization here 
  
m_pBrush= new CBrush; 
m_pBrush->CreateSolidBrush(RGB(187,221,255)); 
  
ModifyStyleEx(0,WS_EX_LAYERED); 
SetLayeredWindowAttributes(m_hWnd,RGB(187,221,255),180,LWA_ALPHA); 
  
return TRUE;  // return TRUE unless you set the focus to a control 
              // EXCEPTION: OCX Property Pages should return FALSE 
} 
HBRUSH CAboutDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)  
{ 
//HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor); 
// TODO: Change any attributes of the DC here 
// TODO: Return a different brush if the default is not desired 
return static_cast<HBRUSH>(*m_pBrush); 
//return hbr; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// la classe Dialog : 
class CTestsDiversDlg : public CDialog 
{ 
// Construction 
public: 
    CTestsDiversDlg(CWnd* pParent= NULL);// standard constructor 
  
    // Dialog Data 
    //................................................ 
    CPicture m_Picture; // la variable picture 
  
// Implementation 
protected: 
  
// Generated message map functions 
//{{AFX_MSG(CTestsDiversDlg) 
    virtual BOOL OnInitDialog(); 
    afx_msg void OnSysCommand(UINT nID, LPARAM lParam); 
    afx_msg void OnPaint(); 
    afx_msg HCURSOR OnQueryDragIcon(); 
    afx_msg BOOL OnEraseBkgnd(CDC* pDC); // le message 
//}}AFX_MSG 
  
    DECLARE_MESSAGE_MAP() 
}; 
//----------------------------------------------------------------------------------- 
// le code 
BEGIN_MESSAGE_MAP(CTestsDiversDlg, CDialog) 
//{{AFX_MSG_MAP(CTestsDiversDlg) 
ON_WM_SYSCOMMAND() 
ON_WM_PAINT() 
ON_WM_QUERYDRAGICON() 
ON_WM_ERASEBKGND() // le message rajoute par classwizard 
//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
  
BOOL CTestsDiversDlg::OnEraseBkgnd(CDC* pDC)  
{ 
    // TODO: Add your message handler code here and/or call default 
    if(m_Picture.m_IPicture)    
    { 
        CRect rect; 
        GetClientRect(&rect); 
        m_Picture.UpdateSizeOnDC(pDC); // Get Picture Dimentions In Pixels 
  
        m_Picture.Show(pDC, CPoint(0,0), CPoint(m_Picture.m_Width, 
                        m_Picture.m_Height), 0,0); 
        m_Picture.Show(pDC,rect); // Change Original Dimentions  
  
        return FALSE; 
    }    
    return CDialog::OnEraseBkgnd(pDC); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
BOOL CTestDlg::OnInitDialog() 
{ 
    CDialog::OnInitDialog(); 
 // .................................... 
 //........................................ 
    CRect rect; 
    GetWindowRect( rect ); 
    ::SetWindowPos(m_hWnd , 
                    HWND_TOPMOST, 
                    rect.left,       
                    rect.top,        
                    rect.Width(), 
                    rect.Height(),   
                    SWP_SHOWWINDOW); 
  
    return TRUE;  // return TRUE  unless you set the focus to a control 
}

1
2
3
4
VERIFY (bm.Attach (::LoadImage (::AfxFindResourceHandle( 
 MAKEINTRESOURCE (inBitmapID), RT_BITMAP), 
 MAKEINTRESOURCE (inBitmapID), IMAGE_BITMAP, 0, 0, 
 (LR_DEFAULTSIZE | LR_CREATEDIBSECTION))))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#include <afxctl.h> 
  
CBitmap *CopyScreenToBitmap(LPRECT lpRect) 
{ 
    CDC     SrcDC, MemDC; 
    int     nX, nY, nX2, nY2;       
    int     nWidth, nHeight;        
    int     xScrn, yScrn;           
  
    CBitmap *   pOldBitmap ,*pBitmap; 
  
    if (IsRectEmpty(lpRect)) return NULL;       
  
    SrcDC.CreateDC("DISPLAY", NULL, NULL, NULL);         
    MemDC.CreateCompatibleDC(&SrcDC); 
  
    nX = lpRect->left;      
    nY = lpRect->top;      
    nX2 = lpRect->right;      
    nY2 = lpRect->bottom; 
  
    xScrn = SrcDC.GetDeviceCaps(HORZRES);      
    yScrn = SrcDC.GetDeviceCaps(VERTRES);       
  
    if (nX < 0) nX = 0;         
    if (nY < 0) nY = 0;      
    if (nX2 > xScrn) nX2 = xScrn;       
    if (nY2 > yScrn) nY2 = yScrn;       
    nWidth = nX2 - nX;      
    nHeight = nY2 - nY;       
  
    pBitmap=new CBitmap; 
    pBitmap->CreateCompatibleBitmap(&SrcDC,nWidth, nHeight);       
  
    pOldBitmap =MemDC.SelectObject (pBitmap);           
    MemDC.BitBlt(0, 0, nWidth, nHeight, &SrcDC, nX, nY, SRCCOPY);      
  
    pBitmap = MemDC.SelectObject( pOldBitmap);        
    MemDC.DeleteDC();      
    SrcDC.DeleteDC();       
  
    return (pBitmap);  
} 
  
CBitmap *CopyWindowToBitmap(CWnd* pWnd ,bool bWindowClient) 
{ 
    CBitmap *pBitmap=NULL; 
    if(!pWnd->m_hWnd) return NULL; 
  
    RECT    rectWnd;  
    pWnd->GetWindowRect(&rectWnd); 
    if(!bWindowClient) return CopyScreenToBitmap(&rectWnd); 
  
    RECT rectClient;              
    POINT pt1, pt2;              
    pWnd->GetClientRect(&rectClient); 
    pt1.x = rectClient.left;              
    pt1.y = rectClient.top;              
    pt2.x = rectClient.right;              
    pt2.y = rectClient.bottom;              
  
    pWnd->ClientToScreen(&pt1);              
    pWnd->ClientToScreen(&pt2);              
    rectClient.left = pt1.x;              
    rectClient.top = pt1.y;              
    rectClient.right = pt2.x;              
    rectClient.bottom = pt2.y;   
  
    return CopyScreenToBitmap(&rectClient);    
} 
  
void PrintBmp(CBitmap *pBmp) 
{ 
    // mise a jour le 15/01/2005 :ajuste le bitmap sur la totalité de la feuille et edite en mode paysage.  
    CDC             dc; 
    CPrintDialog    printDlg(FALSE); 
  
    // selection de l'imprimante. 
    if (printDlg.DoModal() == IDCANCEL)   return; 
  
    DEVMODE FAR *pDevMode=(DEVMODE FAR *)::GlobalLock(printDlg.GetDevMode()); 
  
    // set orientation to landscape 
    pDevMode->dmOrientation=DMORIENT_LANDSCAPE; 
    ::GlobalUnlock(printDlg.GetDevMode()); 
  
    HDC hdc =printDlg.CreatePrinterDC(); 
  
    //dc.Attach(printDlg.GetPrinterDC()); sinon le mode paysage ne fonctionne pas 
  
    dc.Attach(hdc); 
    dc.m_bPrinting = TRUE; // dc d'impression. 
  
    // titre du document = titre application 
    CString strTitle;    
    strTitle.LoadString(AFX_IDS_APP_TITLE); 
  
    DOCINFO di; 
    ::ZeroMemory (&di, sizeof (DOCINFO)); 
  
    di.cbSize = sizeof (DOCINFO);    
    di.lpszDocName = strTitle; 
  
    // debut d'impression 
    if(dc.StartDoc( &di )) 
    {      
        // debut page 
        dc.StartPage(); 
  
        // surface d'impression 
        CRect rectDraw; 
        rectDraw.SetRect(0, 0, 
            dc.GetDeviceCaps(HORZRES), 
            dc.GetDeviceCaps(VERTRES)); 
  
        // infos bitmap 
        BITMAP bmpInfo; 
        pBmp->GetBitmap(&bmpInfo); 
  
        // creation d'un objet CPictureHolder pour avoir un dib. 
        CPictureHolder picture; 
        picture.CreateFromBitmap(pBmp); 
  
        // rectangle d'impression       
        int ncoefy=(rectDraw.Height()/bmpInfo.bmHeight); 
  
        // centrer l'image sur la feuille 
        int nX = rectDraw.left + (rectDraw.Width() - (bmpInfo.bmWidth*ncoefy)) / 2; 
        int nY = rectDraw.top + (rectDraw.Height() - (bmpInfo.bmHeight*ncoefy)) / 2; 
  
        CRect rect;       
        rect.SetRect(CPoint(nX,nY),CPoint(nX+(bmpInfo.bmWidth*ncoefy),nY+(bmpInfo.bmHeight*ncoefy))); 
  
        // affichage final 
        picture.Render(&dc,rect,rect); 
  
        dc.EndPage(); // fin de page 
        dc.EndDoc();  // fin du document 
    }    
    else dc.AbortDoc(); // erreur d'impression 
    dc.Detach();        // liberation dc d'impression. 
    DeleteObject(hdc);  
} 
  
// contexte d'utilisation : dans une boite de dialogue ou view etc.. 
CBitmap *pBmp=CopyWindowToBitmap(this,true); 
PrintBmp(pBmp);     
pBmp->DeleteObject(); 
delete pBmp;

1
2
3
pDlg = new CMyDlg(this); 
pDlg->Create(CMyDlg ::IDD,this); 
pDlg->ShowWindow(SW_SHOW);

1
2
3
4
  
pDlg = new CMyDlg(this); 
pDlg->Create(CMyDlg ::IDD,this); 
pDlg->ShowWindow(SW_SHOW);

1
2
3
  
CWnd::PostNcDestroy 
virtual void PostNcDestroy( );

1
2
3
4
5
6
  
void CMyDlg :: PostNcDestroy( ) 
{ 
CDialog::PostNcDestroy(); 
delete this; 
}

1
2
pixelX = (dialogunitX * baseunitX) / 4 
pixelY = (dialogunitY * baseunitY) / 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BOOL CAboutDlg::OnInitDialog()  
{ 
    CDialog::OnInitDialog(); 
  
    // TODO: Add extra initialization here 
  
   CRect rc( 0, 0, 4, 8 ); 
   MapDialogRect( &rc ); 
   int baseUnitY = rc.bottom; 
   int baseUnitX = rc.right; 
   TRACE("baseUnitX = %d\n", baseUnitX ); 
   TRACE("baseUnitY = %d\n", baseUnitY ); 
  
    // si ma boîte de dialogue fait 300 x 300 unité on aura : 
  
   TRACE("PixelX = %d\n", (baseUnitX *300)/4);  
   TRACE("PixelY = %d\n", (baseUnitY *300)/8 ); 
  
    return TRUE;  // return TRUE unless you set the focus to a control 
                // EXCEPTION: OCX Property Pages should return FALSE 
}

1
2
3
AFX_MANAGE_STATE(AfxGetStaticModuleState()); 
CMyLocalDialog dlg; 
dlg.DoModal();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// .h  
class CDynamicDlg : public CDialog 
{ 
// Construction 
public: 
    DECLARE_DYNCREATE(CDynamicDlg) 
    CDynamicDlg(); 
    CDynamicDlg(int x,int y,int cx,int cy,const char *szTitle,CWnd* pParent = NULL);// standard constructor 
  
    ~CDynamicDlg(); 
// Dialog Data 
//{{AFX_DATA(CDynamicDlg) 
// NOTE: the ClassWizard will add data members here 
//}}AFX_DATA 
    void SetDynamicDlg(int x,int y,int cx,int cy,const char *szTitle,CWnd* pParent = NULL); 
// Implementation 
private: 
    HGLOBAL m_hgbl; 
protected: 
  
// Generated message map functions 
//{{AFX_MSG(CDynamicDlg) 
// NOTE: the ClassWizard will add member functions here 
//}}AFX_MSG 
    DECLARE_MESSAGE_MAP() 
}; 
// .cpp 
///////////////////////////////////////////////////////////////////////////// 
// CDynamicDlg dialog 
  
IMPLEMENT_DYNCREATE(CDynamicDlg,CDialog) 
  
CDynamicDlg::CDynamicDlg() 
{ 
    m_hgbl=NULL; 
} 
CDynamicDlg::CDynamicDlg(int x,int y,int cx,int cy,const char *szTitle,CWnd* pParent /*=NULL*/) 
: CDialog() 
{ 
    //{{AFX_DATA_INIT(CDynamicDlg) 
    // NOTE: the ClassWizard will add member initialization here 
    //}}AFX_DATA_INIT  
    m_hgbl=NULL; 
    SetDynamicDlg(x,y,cx,cy,szTitle,pParent); 
} 
  
void CDynamicDlg::SetDynamicDlg(int x,int y,int cx,int cy,const char *szTitle,CWnd* pParent /*=NULL*/) 
{ 
    //  
    LPDLGTEMPLATE lpdt; 
    LPWORD lpw; 
  
    if(m_hgbl) GlobalFree(m_hgbl); 
    m_hDialogTemplate=NULL; 
    m_hgbl=GlobalAlloc(GMEM_ZEROINIT,1024); 
    lpdt = (LPDLGTEMPLATE)GlobalLock(m_hgbl); 
  
    lpdt->style = WS_POPUP | WS_BORDER | WS_SYSMENU | DS_MODALFRAME | WS_CAPTION; 
    lpdt->cdit = 0; 
    lpdt->x = x; 
    lpdt->y = y; 
    lpdt->cx = cx; 
    lpdt->cy = cy; 
    lpw=(LPWORD) (lpdt+1); 
    *lpw++=0; 
    *lpw++=0; 
    while(*szTitle) *lpw++=*szTitle++; 
    *lpw++=0; 
  
    GlobalUnlock(m_hgbl); 
    InitModalIndirect(m_hgbl); 
} 
  
CDynamicDlg::~CDynamicDlg() 
{ 
    if(m_hgbl) GlobalFree(m_hgbl); 
}  
  
BEGIN_MESSAGE_MAP(CDynamicDlg, CDialog) 
//{{AFX_MSG_MAP(CDynamicDlg) 
// NOTE: the ClassWizard will add message map macros here 
//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
///////////////////////////////////////////////////////////////////////////// 
// CDynamicDlg message handlers

1
2
3
CDynamicDlg dlg; 
dlg.SetDynamicDlg(0,0,100,200,"essai",this); 
dlg.DoModal();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  
class CTestDlg : public CDialog 
{ 
// Construction 
public: 
    // le constructeur d'origine est modifié pour le passage de la variable a partager. 
    CTestDlg(CStringList &rStringList,CWnd* pParent = NULL);   // standard constructor 
  
// Dialog Data 
    //{{AFX_DATA(CTestDlg) 
    enum { IDD = IDD_DIALOG1 }; 
        // NOTE: the ClassWizard will add data members here 
    //}}AFX_DATA 
  
CStringList &m_rStringList; // la donnée membre dans la dialogue.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
  
CTestDlg::CTestDlg(CStringList &rStringList,CWnd* pParent /*=NULL*/) 
    : CDialog(CTestDlg::IDD, pParent),m_rStringList(rStringList) 
{ 
    //{{AFX_DATA_INIT(CTestDlg) 
        // NOTE: the ClassWizard will add member initialization here 
    //}}AFX_DATA_INIT 
} 
BOOL CTestDlg::OnInitDialog()  
{ 
    CDialog::OnInitDialog(); 
  
    // TODO: Add extra initialization here 
// j'affiche en debug le contenu de mon containeur  
#ifdef _DEBUG 
   for(POSITION pos = m_rStringList.GetHeadPosition(); pos != NULL; ) 
   { 
    afxDump << m_rStringList.GetNext( pos ) << "\n"; 
   } 
#endif 
    // je rajoute un élément 
    m_rStringList.AddTail("essai dlg"); 
    return TRUE;  // return TRUE unless you set the focus to a control 
                  // EXCEPTION: OCX Property Pages should return FALSE 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
void CTestToolBarView::OnInitialUpdate() 
{ 
    CFormView::OnInitialUpdate(); 
    ResizeParentToFit(); 
  
    CStringList rStringList; 
  
    rStringList.AddTail("essai"); 
    rStringList.AddTail("essai2"); 
    rStringList.AddTail("essai3"); 
  
    CTestDlg Dlg(rStringList);// passage de la variable dans le constructeur. 
    Dlg.DoModal(); 
  
   // affichage du containeur 
    #ifdef _DEBUG 
    for(POSITION pos = rStringList.GetHeadPosition(); pos != NULL; ) 
    { 
     afxDump << rStringList.GetNext( pos ) << "\n"; 
    } 
#endif 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
  
#include <afxpriv.h> 
int CDlgMyDlg::DoModal(int x,int y) 
{ 
   CDialogTemplate dlgTemp; 
   int             nResult; 
  
   // lecture du template d'origine 
   if (!dlgTemp.Load(MAKEINTRESOURCE(IDD))) return -1; 
  
  
   // fonte par defaut 
//   dlgTemp.SetFont("MS Sans Serif", 8); eventuel changement de fonte 
  
   // pointeur sur le dialogue template modifié 
   LPSTR pdata = reinterpret_cast<LPSTR>(GlobalLock(dlgTemp.m_hTemplate)); 
  
   DLGTEMPLATE* pTemplate = reinterpret_cast<DLGTEMPLATE*>(pdata); 
  
   pTemplate->x=x; // changement des coordonnées x,y 
   pTemplate->y=y; 
  
   m_lpszTemplateName = NULL; 
   InitModalIndirect(pdata); 
  
   // appel domodal  
   nResult = CDialog::DoModal(); 
  
   // liberation du template modifié 
   GlobalUnlock(dlgTemp.m_hTemplate); 
  
   return nResult;

1
2
3
  
CDlgMyDlg Dlg; 
Dlg.DoModal(100,200);

1
2
  
HACCEL  m_hTable;

1
2
  
m_hTable = LoadAccelerators(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_MAINFRAME));

1
2
3
4
5
6
7
  
BOOL CMyDialog::PreTranslateMessage(MSG* pMsg) 
 { 
   if (m_hTable  && ::TranslateAccelerator(m_hWnd, m_hTable, pMsg)) 
              return(TRUE); 
      return CDialog::PreTranslateMessage(pMsg); 
}

1
2
3
4
5
6
7
8
9
  
BOOL 
DlgOne::OnInitDialog() 
{ 
    CDialog::OnInitDialog(); 
    ancre.ModifyStyleEx(0, WS_EX_CONTROLPARENT); 
    DlgTwo.Create(IDD_DIAGTWO, &ancre); 
  
}

1
2
3
4
5
6
7
8
  
class CDlgTest : public CDialog 
{ 
// Construction 
public: 
    DECLARE_DYNCREATE(CDlgTest) 
    CDlgTest(CWnd* pParent = NULL);   // standard constructor 
/....

1
2
3
4
5
6
7
8
9
10
11
  
///////////////////////////////////////////////////////////////////////////// 
// CDlgTest dialog 
  
IMPLEMENT_DYNCREATE(CDlgTest, CDialog) 
CDlgTest::CDlgTest(CWnd* pParent /*=NULL*/) 
    : CDialog(CDlgTest::IDD, pParent) 
{ 
    //{{AFX_DATA_INIT(CDlgTest) 
    //}}AFX_DATA_INIT 
}

1
2
3
4
5
  
    CDlgTest *pDlg; 
    pDlg = new CDlgTest(); 
    pDlg->Create(CDlgTest ::IDD,AfxGetMainWnd()); 
    pDlg->ShowWindow(SW_SHOW);

1
2
3
4
5
6
7
8
9
10
11
12
  
CWnd* pChild;         
    pChild = AfxGetMainWnd()->GetWindow(GW_HWNDFIRST); 
    while (pChild != NULL) 
    { 
        if(pChild->IsKindOf(RUNTIME_CLASS(CDlgTest))) 
        { 
            TRACE("\nCDialog Find:%x,%x",pChild,pChild->m_hWnd); // la dialogue est trouvée !!! 
            break; 
        } 
        pChild = pChild->GetWindow(GW_HWNDNEXT); 
    }

1
2
3
4
5
6
7
8
9
10
11
12
  
BOOL CSimpleDlg::OnInitDialog() 
{ 
   CDialog::OnInitDialog(); 
  
   // TODO: Add extra initialization here 
   m_cMyEdit.SetWindowText(_T("My Name")); // Initialize control values 
   m_cMyList.ShowWindow(SW_HIDE);      // Show or hide a control, etc. 
  
   return TRUE;  // return TRUE unless you set the focus to a control 
   // EXCEPTION: OCX Property Pages should return FALSE 
}

1
2
3
4
5
6
7
8
9
10
11
12
  
BOOL CSimpleDlg::OnInitDialog() 
{ 
   CDialog::OnInitDialog(); 
  
   // TODO: Add extra initialization here 
   m_cMyEdit.SetWindowText(_T("My Name")); // Initialize control values 
   m_cMyEdit.SetFocus(); 
  
   return FALSE;  // return TRUE unless you set the focus to a control 
   // EXCEPTION: OCX Property Pages should return FALSE 
}