FAQ VC++ et MFCConsultez toutes les FAQ

1
2
  
AfxGetApp() ;

1
2
  
CWinApp* AfxGetApp( );

1
2
  
AfxGetApp()->m_lpCmdLine

1
2
3
4
  
AfxGetAppName() ; 
// ou  
AfxGetApp()->m_pszAppName

1
2
3
4
5
6
7
8
// trouver le nom (uniquement) de l'executable 
void GetNom(char *nom, DWORD taille) 
{ 
char *c; 
c = nom + GetModuleFileName(NULL,nom,taille); 
while(*c!='\\') c--; 
strcpy(nom,++c); 
}

1
2
3
4
5
6
7
// trouver le nom (uniquement) de l'executable (CString) 
CString CGetNom(char *nom, DWORD taille) 
{ 
GetModuleFileName(NULL,nom,taille); 
CString Cnom(nom); 
return Cnom.Mid(Cnom.ReverseFind('\\')+1); 
}

1
2
3
4
5
6
7
  
char nom[MAX_PATH]; 
GetNom(nom,MAX_PATH); 
  
// ou 
char nom[MAX_PATH]; 
CString Cnom = CGetNom(nom, MAX_PATH);

1
2
3
4
5
6
7
8
9
10
  
// trouver le chemin (uniquement) de l'application 
void GetChemin(char *chemin, DWORD taille) 
{ 
char *c; 
c = chemin + GetModuleFileName(NULL,chemin,taille); 
while(*c!='\\') 
c--; 
*c=0; 
}

1
2
3
4
5
6
7
8
  
// trouver le chemin (uniquement) de l'application (CString) 
CString CGetChemin(char *chemin, DWORD taille) 
{ 
GetModuleFileName(NULL,chemin,taille); 
CString Cchemin(chemin); 
return Cchemin.Mid(0,Cchemin.ReverseFind('\\')); 
}

1
2
3
4
5
6
char chemin[MAX_PATH]; 
GetChemin(chemin, MAX_PATH); 
  
// ou 
CString Cchemin = CGetChemin(chemin, MAX_PATH); 
AfxMessageBox(Cchemin);

1
2
3
4
5
6
7
  
// a rajouter pour la définition  
#include <afxpriv.h>  
  
pMainFrame->ShowWindow(m_nCmdShow); 
pMainFrame->UpdateWindow(); 
AfxSetWindowText(m_pMainWnd->m_hWnd,"TestSDI- Farscape");

1
2
3
4
  
m_nCmdShow = SW_SHOWMAXIMIZED ; 
m_pMainWnd->ShowWindow(m_nCmdShow); 
m_pMainWnd->UpdateWindow();

1
2
  
CWnd* AfxGetMainWnd( );

1
2
  
CMyMainFrame *p=(CMyMainFrame *)AfxGetMainWnd() ;

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
  
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(RUNTIME_CLASS(CFormView))) 
                { 
                // une forme view 
                } 
                else 
                if(pView->IsKindOf(RUNTIME_CLASS(CScrollView))) 
                { 
                // une  Scrollview 
                } 
                else 
                if(pView->IsKindOf(RUNTIME_CLASS(CView))) 
                { 
                    // une  view 
                } 
            } 
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  
// déclaration d'une section TestApp 
  
#pragma data_seg("TestApp")  
  
// la variable commune a tous les process 
LONG nCtApp = -1;  
#pragma data_seg() 
  
// directive pour le link. 
  
#pragma comment(linker, "/section:TestApp,rws")  
  
// Test incrémentation de la variable.  
  
bool bFirstInstance =  (InterlockedIncrement(&nCtApp) == 0); 
if(!bFirstInstance) 
{ 
       // erreur le prog est déjà lancé. 
}

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
  
// .h 
// 
class CSdisamplesApp : public CWinApp 
{ 
public: 
CSdisamplesApp(); 
    ~CSdisamplesApp(); 
    CMutex     m_Mutex; 
    bool       m_bLock; 
    //................ 
  
// .cpp 
CSdisamplesApp::CSdisamplesApp():m_bLock(false),m_Mutex(FALSE,"SDISAMPLE") 
{ 
// TODO: add construction code here, 
// Place all significant initialization in InitInstance 
} 
CSdisamplesApp::~CSdisamplesApp() 
{ 
// Destruct 
    if(m_bLock) m_Mutex.Unlock();     
}     
BOOL CSdisamplesApp::InitInstance() 
{     
    if(!(m_bLock=m_Mutex.Lock(0))) 
    { 
        AfxMessageBox("Application active"); 
        return(0); 
    } 
//................

1
2
  
void RegisterShellFileTypes( BOOL bCompat = FALSE );

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
  
BOOL CMyApp::InitInstance()  
{  
   // ...  
  
   CMultiDocTemplate* pDocTemplate;  
   pDocTemplate = new CMultiDocTemplate(  
      IDR_MYTYPE,  
      RUNTIME_CLASS(CMyDoc),  
      RUNTIME_CLASS(CMDIChildWnd),        // standard MDI child frame  
      RUNTIME_CLASS(CMyView));  
   AddDocTemplate(pDocTemplate);  
  
   // Create main MDI Frame window.  
   CMainFrame* pMainFrame = new CMainFrame;  
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME))  
      return FALSE;  
   // Save the pointer to the main frame window.  This is the  
   // only way the framework will have knowledge of what the  
   // main frame window is.  
   m_pMainWnd = pMainFrame;  
  
   // enable file manager drag/drop and DDE Execute open  
   EnableShellOpen();  
   RegisterShellFileTypes();  
   // ...  
  
   // Show the   main window using the nCmdShow parameter  
   // passed to the application when it was first launched.  
   pMainFrame->ShowWindow(m_nCmdShow);  
   pMainFrame->UpdateWindow();  
  
   // ...  
}

AfxGetApp()->m_lpCmdLine.

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
  
BOOL CSampleSDIApp::InitInstance() 
{ 
    AfxEnableControlContainer(); 
  
    char szName[MAX_PATH];     
    GetModuleFileName(NULL,szName,MAX_PATH); 
  
    CArray<CString ,const char *> argv; // attention il faut mettre #include <afxtempl.h> dans stdafx.h 
  
    char *szArg=strtok(m_lpCmdLine," "); 
  
    argv.Add(szName); // argv[0]=path de l'application. 
    if(szArg)  
    { 
        do 
       { 
          argv.Add(szArg); 
       } 
       while(szArg=strtok(NULL," ")); 
   } 
  
    int argc=argv.GetSize(); 
    for(int i=0;i<argc;i++) 
    { 
        TRACE("\nArgv[%d]=%s",i,argv[i]); 
    } 
//..........................

1
2
3
4
  
CMyApp *pApp=static_cast<CMyApp *>(AfxGetApp()); 
pApp->m_Global.MyFunction();     //exemple de fonction globale  
CListCtrm &rList=pApp->m_Global.GetLisCtrl(); // variable globale.

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
  
namespace Singleton { 
  
class MyClass 
{ 
    private: static MyClass*  m_pUniqueInstance; 
    private: static CMutex      m_LockInstance; // warning -> :#include <afxmt.h> 
  
    private: MyClass(const MyClass&); // Disable copy constructor 
    private: void operator=(const MyClass&); // Disable assignment operator 
  
    private: MyClass() 
    { 
        // Initialisations 
    } 
    private: ~MyClass() 
    {  
        m_pUniqueInstance = 0; 
    } 
    public: static MyClass &GetInstance() 
    { 
        if (m_pUniqueInstance == 0) 
        {             
            m_LockInstance.Lock(); 
            if (m_pUniqueInstance == 0) 
                m_pUniqueInstance = new MyClass(); 
            m_LockInstance.Unlock(); 
        }         
        return *m_pUniqueInstance; 
    } 
    public: static void FreeInstance() 
    { 
        m_LockInstance.Lock(); 
        delete m_pUniqueInstance; 
        m_LockInstance.Unlock(); 
    } 
    // users functions.     
    void UserFunction() 
   { 
        ASSERT(m_pUniqueInstance); 
   } 
  
}; 
  
} 
// namespace Singleton 
// init static data 
CMutex     Singleton::MyClass::m_LockInstance; 
Singleton::MyClass*  Singleton::MyClass::m_pUniqueInstance=NULL; 
  
// utilisation. 
Singleton::MyClass &theClass=Singleton::MyClass::GetInstance(); 
theClass.UserFunction(); 
// ou 
Singleton::MyClass::GetInstance().UserFunction(); 
// libération 
Singleton::MyClass::FreeInstance();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
void CWinApp::LoadStdProfileSettings(UINT nMaxMRU) 
{ 
    ASSERT_VALID(this); 
    ASSERT(m_pRecentFileList == NULL); 
  
    if (nMaxMRU != 0) 
    { 
        // create file MRU since nMaxMRU not zero 
        m_pRecentFileList = new CRecentFileList(0, _afxFileSection, _afxFileEntry, 
            nMaxMRU); 
        m_pRecentFileList->ReadList(); 
    } 
    // 0 by default means not set 
    m_nNumPreviewPages = GetProfileInt(_afxPreviewSection, _afxPreviewEntry, 0); 
}

1
2
3
4
5
6
7
8
  
class CMyApp : public CWinApp 
{ 
public: 
    CMyApp (); 
    inline CRecentFileList *GetRecentFileList(){return m_pRecentFileList;} 
//... 
};

1
2
  
#include <afxadv.h>

1
2
3
4
5
6
7
8
9
10
  
void CTestToolBarView::OnInitialUpdate() 
{ 
//... 
  CMyApp *TheApp=static_cast<CMyApp *>(AfxGetApp()); 
  
    CString str; 
    for( int i=0;TheApp->GetRecentFileList()->GetSize( );i++) 
        str=(*TheApp->GetRecentFileList())[i]; 
}