FAQ VC++ et MFCConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
/*static */void CMyApp ::PumpMessages()  
{  
   // Handle dialog messages  
    MSG msg;  
    while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))  
    {  
        if (!AfxGetApp()->PreTranslateMessage(&msg))  
      {  
         ::TranslateMessage(&msg);  
         ::DispatchMessage(&msg);  
     }             
     AfxGetApp()->OnIdle(0);   // updates user interface  
    AfxGetApp()->OnIdle(1);   // frees temporary objects  
    }  
}

1
2
  
((CMDIFrameWnd *)AfxGetMainWnd())->GetActiveFrame( )->GetActiveView();

1
2
  
CView* CFrameWnd::GetActiveView( ) const;

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
CWnd *FindInstanceView(CRuntimeClass *pViewClass) 
{ 
    CWinApp* pApp = AfxGetApp();         
    // parcourir tous les templates 
    CDocTemplate* pTemplate; 
    POSITION pos = pApp->GetFirstDocTemplatePosition(); 
    while (pos != NULL) 
    { 
        pTemplate = pApp->GetNextDocTemplate(pos); 
        ASSERT(pTemplate); 
  
        // tous les documents du template. 
        POSITION pos2 = pTemplate->GetFirstDocPosition(); 
        while (pos2) 
        { 
            CDocument* pDoc = pTemplate->GetNextDoc(pos2); 
            ASSERT(pDoc); 
  
            // toutes les vues du document 
            POSITION pos3 = pDoc->GetFirstViewPosition(); 
            while (pos3 != NULL) 
            { 
                CView* pView = pDoc->GetNextView(pos3); 
                ASSERT(pView); 
                if (::IsWindow(pView->GetSafeHwnd())) 
                { 
                    if(pView->IsKindOf(pViewClass)) 
                    { 
                        return pView; 
                    }                     
                } 
            } 
        } 
    } 
    return NULL; 
}

1
2
3
4
5
6
CTestMdiView *pView; 
if((pView=static_cast<CTestMdiView *>(FindClassView(RUNTIME_CLASS(CTestMdiView))))) 
{ 
    TRACE("\nInstance de la classe trouvée"); 
    static_cast<CMDIChildWnd *>(pView->GetParentFrame())->ActivateFrame(SW_RESTORE); 
}

1
2
  
\nExts\nExts\nFichiers (*.txt)\n.txt\nExts.Doc\nExts Doc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
IDR_TESTMDTYPE <windowTitle>\n<docName>\n<fileNewName>\n 
                    <filterName>\n <filterExt>\n<regFileTypeID>\n 
                    <regFileTypeName>\n <filterMacExt(filterWinExt)>\n 
                    <filterMacName(filterWinName)> 
  
IDR_TESTMDTYPE \nExts\nExts\nFichiers (*.txt ;*.doc)\n.txt; 
                                  .doc\Exts.Document.1\nExts Document\nExts\nExts Fichiers 
  
      <windowTitle>           Exts 
      <docName>              Exts 
      <fileNewName>        Exts 
      <filterName>             Fichiers (*.txt) 
      <filterExt>                  . txt 
      <regFileTypeId>        Exts.Document.1 
      <regFileTypeName>  Exts Document 
      <filterMacExt>           Exts 
      <filterMacName>      Exts Fichiers 
  
 <item> voir Note MSDN:</item> 
<b>INFO: Format of the Document Template String 
Q129095 
</b>

1
2
3
4
5
6
7
8
  
CMultiDocTemplate* pDocTemplate; 
pDocTemplate = new CMultiDocTemplate( 
IDR_TESTMDTYPE, 
RUNTIME_CLASS(CTestMdiDoc), 
RUNTIME_CLASS(CChildFrame), // custom MDI child frame 
RUNTIME_CLASS(CTestMdiView)); 
AddDocTemplate(pDocTemplate);

1
2
3
  
<b>HOWTO: How to Support Two File Extensions per MFC Document Type 
Q141921</b>

1
2
3
  
// CMultiDocTemplate * m_pTplEditView; dans le header. 
m_pTplEditView->OpenDocumentFile(NULL) ;

1
2
3
4
5
6
7
  
// CTestMdiApp message handlers 
void CTestMdiApp::OnFileNew()  
{ 
      // TODO: Add your command handler code here 
       OpenDocumentFile(RUNTIME_CLASS(CTestMdiView)); 
}

1
2
3
4
5
6
  
void CTestMdiApp::OnFileNew()  
{ 
      // TODO: Add your command handler code here 
       m_pTplEditView->OpenDocumentFile(NULL) ; 
}

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
  
// header 
class CExMultiDocTemplate : public CMultiDocTemplate 
{ 
    DECLARE_DYNAMIC(CExMultiDocTemplate) 
    // Constructors 
public: 
   CExMultiDocTemplate(UINT nIDResource, 
                       CRuntimeClass* pDocClass, 
                       CRuntimeClass* pFrameClass, 
                       CRuntimeClass* pViewClass): 
   CMultiDocTemplate(nIDResource,pDocClass,pFrameClass,pViewClass){} 
  
   CRuntimeClass* GetDocClass()   {return m_pDocClass;} 
   CRuntimeClass* GetFrameClass() {return m_pFrameClass;} 
   CRuntimeClass* GetViewClass()  {return m_pViewClass;} 
   UINT GetnIDResource()          {return m_nIDResource;} 
}; 
  
// .cpp 
IMPLEMENT_DYNAMIC(CExMultiDocTemplate,CMultiDocTemplate) 
CDocument *CTestMdiApp::OpenDocumentFile(CRuntimeClass *pClassView, 
                                         LPCTSTR lpszPathName/*=NULL*/,  
                                         BOOL bMakeVisible /*= TRUE*/ ) 
{ 
    // parcourir tous les templates 
    CDocTemplate* pTemplate; 
    POSITION pos = GetFirstDocTemplatePosition(); 
    while (pos != NULL) 
    { 
        pTemplate = GetNextDocTemplate(pos); 
        ASSERT(pTemplate); 
        if(pTemplate->IsKindOf(RUNTIME_CLASS(CExMultiDocTemplate))) 
        { 
            if(((CExMultiDocTemplate *)pTemplate)->GetViewClass()==pClassView) 
                 return pTemplate->OpenDocumentFile(lpszPathName,bMakeVisible); 
        } 
    } 
    return NULL; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  
CExMultiDocTemplate *pTemplate; 
pTemplate = new CExMultiDocTemplate( 
IDR_TESTMDTYPE, 
RUNTIME_CLASS(CTestMdiDoc), 
RUNTIME_CLASS(CChildFrame), // custom MDI child frame 
RUNTIME_CLASS(CTestMdiView)); 
AddDocTemplate(pTemplate); 
  
pTemplate= new CExMultiDocTemplate( 
                            IDR_TESTMDTYPE, 
                            RUNTIME_CLASS(CTestMdiDoc), 
                            RUNTIME_CLASS(CChildFrame), // custom MDI child frame 
                            RUNTIME_CLASS(CEditView)); 
AddDocTemplate(pTemplate);

1
2
3
4
5
6
7
8
  
void CMainFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)  
{  
   // TODO: Add your message handler code here and/or call default             
    lpMMI->ptMinTrackSize.x = 320;  
    lpMMI->ptMinTrackSize.y = 240;                  
    CMDIFrameWnd::OnGetMinMaxInfo(lpMMI);  
}

1
2
3
4
5
  
BOOL SetCursorPos( 
  int X,  // horizontal position 
  int Y   // vertical position 
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
void CTestMdiView::OnMouseMove(UINT nFlags, CPoint point) 
{ 
   // TODO: Add your message handler code here and/or call default 
  
   if(!m_bMouseSetPos) // pour éviter la réentrance dans le message ! 
   {       
      CPoint pt=point; 
      pt.x = 100;          // fixer x a 100 pixels coté client  
      ClientToScreen(&pt); // conversion en coordonnées fenêtre 
      ::SetCursorPos(pt.x,pt.y); // fixe la position de la souris 
      m_bMouseSetPos=true;    // initialise le flag  
   } 
   else m_bMouseSetPos=false; // reset du flag  
  
   CFormView::OnMouseMove(nFlags, point); 
} 
m_bMouseSetPos=false; // à initialiser dans le constructeur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
BEGIN_MESSAGE_MAP(CTestMdiApp, CWinApp) 
//{{AFX_MSG_MAP(CTestMdiApp) 
ON_COMMAND(ID_APP_ABOUT, OnAppAbout) 
ON_COMMAND(ID_FILE_NEW, OnFileNew) // redéfinition par classWizard 
//}}AFX_MSG_MAP 
// Standard file based document commands 
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen) 
// Standard print setup command 
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup) 
END_MESSAGE_MAP() 
  
// CTestMdiApp message handlers 
void CTestMdiApp::OnFileNew()  
{ 
    // TODO: Add your command handler code here 
    m_pTplEditView->OpenDocumentFile(NULL) ; 
}

1
2
3
4
5
  
//CCommandLineInfo cmdInfo; 
//ParseCommandLine(cmdInfo); 
// Dispatch commands specified on the command line 
//if (!ProcessShellCommand(cmdInfo)) return FALSE;

1
2
3
4
5
6
7
8
9
10
  
BOOL CMainFrame::OnCommand(WPARAM wParam, LPARAM lParam)  
{ 
    // TODO: Add your specialized code here and/or call the base class 
    if(LOWORD(wParam)==ID_FILE_SAVE) 
    { 
        AfxMessageBox("Msg:ID_FILE_SAVE"); 
    } 
    return CMDIFrameWnd::OnCommand(wParam, lParam); 
}

1
2
3
  
CFrameWnd::GetActiveDocument 
virtual CDocument* GetActiveDocument( );

1
2
3
4
5
  
// dans la view sur l'appel d'un bouton par exemple. 
CMainFrame * pMain=(CMainFrame *)AfxGetMainWnd(); 
pMain->SendMessage(WM_COMMAND, ID_VIEW_TOOLBAR, 0L); 
pMain->SendMessage(WM_COMMAND, ID_VIEW_STATUS_BAR,0L);

1
2
3
4
5
6
7
8
9
10
11
12
13
  
void CTestSDIView::OnButton1() 
{ 
   // TODO: Add your control notification handler code here 
    // Récupération de la taille de la mainframe 
    CRect  RectFrame; 
    AfxGetMainWnd()->GetWindowRect(&RectFrame); 
    // changement de taille +100 en hauteur et largeur. 
    AfxGetMainWnd()->SetWindowPos(NULL,0,0, 
                                       RectFrame.Width()+100, 
                                       RectFrame.Height()+100, 
                                       SWP_NOMOVE | SWP_NOZORDER); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
CMainFrame::~CMainFrame() 
{ 
    if (m_HideWnd.m_hWnd != NULL) m_HideWnd.DestroyWindow(); 
} 
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
    //CWnd m_HideWnd ; comme donnée membre de la classe CMainFrame. 
  
    if (!CFrameWnd::PreCreateWindow(cs)) 
    return FALSE; 
  
    if(m_HideWnd.m_hWnd==NULL) 
   { 
        if (!m_HideWnd.CreateEx(0, AfxRegisterWndClass(0), _T(""), WS_POPUP, 
       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
       NULL, 0)) 
      return FALSE; 
   } 
   cs.hwndParent = m_HideWnd.m_hWnd; 
   return TRUE; 
}

1
2
3
4
5
  
GetParentFrame()->RecalcLayout();  
ResizeParentToFit();  
CRect Rect ; 
GetClientRect(&Rect) ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
typedef struct tagCREATESTRUCT { 
    LPVOID lpCreateParams; 
    HINSTANCE hInstance; 
    HMENU hMenu; 
    HWND hwndParent; 
    int cy; 
    int cx; 
    int y; 
    int x; 
    LONG style; 
    LPCTSTR lpszName; 
    LPCTSTR lpszClass; 
    DWORD dwExStyle; 
} CREATESTRUCT, *LPCREATESTRUCT;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
    // Fenêtre sans boutons min/max et bords dimensionnables 
    cs.style = WS_OVERLAPPED | WS_SYSMENU | WS_BORDER; 
  
    // Dimensionne au 1/3 de la taille de l'écran la fenêtre, et la centre 
    cs.cy = ::GetSystemMetrics(SM_CYSCREEN) / 3; 
    cs.cx = ::GetSystemMetrics(SM_CXSCREEN) / 3; 
    cs.y = ((cs.cy * 3) - cs.cy) / 2; 
    cs.x = ((cs.cx * 3) - cs.cx) / 2; 
  
    // Appelle la fonction de la classe mère 
    return CFrameWnd::PreCreateWindow(cs); 
}

1
2
3
4
5
6
7
8
BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
    // Crée une fenêtre sans bouton Maximiser 
    cs.style &= ~WS_MAXIMIZEBOX; 
  
    // Appelle la fonction de la classe mère 
    return CMDIChildWnd::PreCreateWindow(cs); 
}

1
2
3
4
  
_AFXWIN_INLINE CWnd* AFXAPI AfxGetMainWnd() 
    { CWinThread* pThread = AfxGetThread(); 
        return pThread != NULL ? pThread->GetMainWnd() : NULL; }

1
2
3
4
5
6
7
8
  
CWinThread* AFXAPI AfxGetThread() 
{ 
  // check for current thread in module thread state 
  AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState(); 
  CWinThread* pThread = pState->m_pCurrentWinThread; 
  return pThread; 
}

1
2
3
4
5
6
7
8
9
10
11
  
CWinThread* AFXAPI AfxGetThread() 
{ 
  // check for current thread in module thread state 
  AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState(); 
  CWinThread* pThread = pState->m_pCurrentWinThread; 
  //if no CWinThread for the module, then use the global app 
  if (pThread == NULL) 
      pThread = AfxGetApp(); 
  return pThread; 
}

1
2
  
AfxGetApp()->GetMainWnd();

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
  
void CChildFrame::OnWindowPosChanging(WINDOWPOS* lpwndpos) 
{ 
    if(!m_rect.IsRectEmpty())    // empeche de bouger... 
    { 
        lpwndpos->x=m_rect.left; 
        lpwndpos->y=m_rect.top;     
        CRect rectBarPos; 
        static_cast<CMainFrame *>(AfxGetMainWnd())->m_wndToolBar.GetWindowRect(&rectBarPos); 
        lpwndpos->y-=rectBarPos.Height(); 
  
    } 
    CMDIChildWnd::OnWindowPosChanging(lpwndpos); 
  
    // TODO: Add your message handler code here 
} 
//------------------------------------------------------------ 
void CChildFrame::OnSize(UINT nType, int cx, int cy) 
{ 
    CMDIChildWnd::OnSize(nType, cx, cy); 
    if(m_rect.IsRectEmpty()) // position initiale 
    { 
        GetWindowRect(&m_rect); 
        AfxGetMainWnd()->ScreenToClient(&m_rect); 
    } 
    // TODO: Add your message handler code here 
}

1
2
3
4
5
6
7
8
  
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
    // TODO: Modify the Window class or styles here by modifying 
    //  the CREATESTRUCT cs     
    cs.style |=(WS_VSCROLL | WS_HSCROLL);     
    return CMDIFrameWnd::PreCreateWindow(cs); 
}

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
  
//CArray <CView *,CView *> m_arView; a déclarer comme variable membre de la classe. 
//----------------------------------------------- 
void CMainFrame::ActiveFormView(int n) 
{ 
	VERIFY(n<m_arView.GetCount()); 
  
	CView* pActiveView = GetActiveView(); 
	CView *pNewView = m_arView[n]; 
  
    UINT temp = ::GetWindowLong(pActiveView->m_hWnd, GWL_ID); 
    ::SetWindowLong(pActiveView->m_hWnd, GWL_ID, 
    ::GetWindowLong(pNewView->m_hWnd, GWL_ID)); 
    ::SetWindowLong(pNewView->m_hWnd, GWL_ID, temp); 
  
    pActiveView->ShowWindow(SW_HIDE); 
    pNewView->ShowWindow(SW_SHOW); 
    SetActiveView(pNewView); 
    RecalcLayout(); 
    pNewView->Invalidate(); 
} 
//----------------------------------------------- 
CView *CMainFrame::AddView(CRuntimeClass *pClassView) 
{ 
	CView* pView = static_cast<CView *>(pClassView->CreateObject()); 
	CView* pActiveView = GetActiveView(); 
  
	if(!m_arView.GetCount()) m_arView.Add(pActiveView); 
  
    CDocument* pCurrentDoc = GetActiveDocument(); 
  
    CCreateContext newContext; 
    newContext.m_pNewViewClass = NULL; 
    newContext.m_pNewDocTemplate = NULL; 
    newContext.m_pLastView = NULL; 
    newContext.m_pCurrentFrame = NULL; 
    newContext.m_pCurrentDoc = pCurrentDoc; 
  
    CRect rect(0, 0, 0, 0);  
    pView->Create(NULL, NULL,(AFX_WS_DEFAULT_VIEW & ~WS_VISIBLE),rect, this, 
				AFX_IDW_PANE_FIRST + m_arView.GetCount(), &newContext); 
	m_arView.Add(pView); 
	pView->OnInitialUpdate(); 
	return pView; 
}

1
2
3
4
5
6
7
8
  
  
	// La seule fenêtre a été initialisée et peut donc être affichée et mise à jour 
	m_pMainWnd->ShowWindow(SW_SHOW); 
	m_pMainWnd->UpdateWindow(); 
	// appelle DragAcceptFiles uniquement s'il y a un suffixe 
	//  Dans une application SDI, cet appel doit avoir lieu juste après ProcessShellCommand 
	static_cast<CMainFrame*>(m_pMainWnd)->AddView(RUNTIME_CLASS(CEditView));

1
2
3
4
5
6
7
8
9
10
11
  
void CMainFrame::OnFenetre1() 
{ 
	// TODO: Add your command handler code here 
	ActiveFormView(0); 
} 
void CMainFrame::OnFenetre2() 
{ 
	// TODO: Add your command handler code here 
	ActiveFormView(1); 
}