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
19
  
char szIdentite[]="Microsoft Word"; 
CWnd* pWnd = CWnd::GetDesktopWindow( )->GetTopWindow( ); 
CWnd *pWndWord = 0; 
CString s,strWord; 
while( 1 ) 
{ 
    pWnd = pWnd->GetNextWindow(); 
    if ( pWnd == NULL ) break; 
    pWnd->GetWindowText( s ); 
    strWord=s; 
    if(strWord.Find(szIdentite)!=-1) 
    { 
        pWndWord = pWnd; 
        break; 
    } 
} 
if(pWndWord) 
::PostMessage(pWndWord->GetSafeHwnd(),WM_SYSCOMMAND, SC_CLOSE, 0L );

1
2
3
4
5
  
CWnd::FindWindow 
static CWnd* PASCAL FindWindow(  
LPCTSTR lpszClassName,  
LPCTSTR lpszWindowName );

1
2
  
CWnd *pWnd=CWnd::FindWindow( NULL,"MonProg");

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
  
// header .................. 
  
// la classe qui contient les données  
class CItem : public CObject 
{ 
  
public: 
    DECLARE_SERIAL( CItem ) 
  
    CItem(){Clear();} 
    //----------------------------- 
    ~CItem(){} 
    //----------------------------- 
     // constructeur de copie 
    CItem(const CItem &rItem) 
    { 
        CopyFrom(rItem); 
    } 
    //----------------------------- 
    // operateur d'affectation 
    const CItem& operator=(const CItem& Src) 
    { 
        CopyFrom(Src); 
        return *this; 
    } 
    //----------------------------- 
    // effacer les données. 
    void Clear() 
    { 
        m_strNom=""; 
        m_strPrenom=""; 
        m_strCdp=""; 
        m_strVille="";  
    } 
    //----------------------------- 
    // la methode de serialisation. 
    void Serialize(CArchive& ar) 
    { 
        if(ar.IsStoring()) 
            ar << m_strNom << m_strPrenom << m_strCdp <<m_strVille; 
        else 
            ar >> m_strNom >> m_strPrenom >> m_strCdp >> m_strVille; 
    } 
    //----------------------------- 
    // copier les données d'une source. 
    void CopyFrom(const CItem & Src ) 
    { 
        if(this==&Src) return; 
  
        Clear(); // clear eventuel. 
  
        m_strNom    =Src.m_strNom; 
        m_strPrenom =Src.m_strPrenom; 
        m_strCdp    =Src.m_strCdp; 
        m_strVille  =Src.m_strVille; 
   } 
    //----------------------------- 
    // dump pour test 
    CString GetStrDump() 
    { 
        return ( m_strNom + "/" +m_strPrenom + "/" + m_strCdp +"/" + m_strVille); 
    } 
  
    // les données. 
    CString m_strNom; 
    CString m_strPrenom; 
    CString m_strCdp; 
    CString m_strVille; 
}; 
  
template<> void AFXAPI SerializeElements<CItem> (CArchive& ar, CItem* pElements, int nCount); 
  
// la gestion d'un tableau de cette classe . 
typedef CArray<CItem,CItem&> CArrayItem; 
  
// Source......................... 
//--------------------------------------------------------------------------------------- 
// definition de la methode de serialisation de l'objet CItem pour le template CArray. 
template <>  void AFXAPI SerializeElements <CItem> ( CArchive& ar,  
    CItem* pItem, int nCount ) 
{ 
    for ( int i = 0; i < nCount; i++, pItem++ )             
        pItem->Serialize( ar );     
} 
  
IMPLEMENT_SERIAL( CItem, CObject, 0) 
  
void Test() 
{ 
// un element  
   CItem item; 
  
    item.m_strCdp="06800"; 
    item.m_strNom="farscape"; 
    item.m_strPrenom="???"; 
    item.m_strVille="Nice"; 
  
   // un tableau de l'element 
    CArrayItem arItem; 
  
     // remplissage. 
    arItem.Add(item); 
    for(int i=0;i<10;i++) 
    { 
        item.m_strNom.SetAt(0,'A'+i); 
        arItem.Add(item); 
    } 
     // archivage. 
    { 
        CFile File;     
        if(File.Open("MyArchive.arc", CFile::modeCreate | CFile::modeWrite )) 
        { 
            CArchive ar( &File, CArchive::store); 
            arItem.Serialize(ar); 
        } 
    } 
    // Lecture de l'archive. 
    arItem.RemoveAll(); 
    CFile File;     
    if(File.Open("MyArchive.arc", CFile::modeRead )) 
    { 
        CArchive ar( &File, CArchive::load); 
        arItem.Serialize(ar); 
    } 
    // verification du contenu. 
    for(i=0;i<arItem.GetSize();i++) 
    { 
        AfxMessageBox(arItem[i].GetStrDump()); 
    } 
  
}

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
#include <string> 
#include <sstream> 
#include <afxtempl.h> 
  
template <class T,class U> 
class CArraySer: public CArray<T,U> 
{ 
  
public: 
  
    CArraySer(int line,bool b=true); 
    virtual ~CArraySer(); 
    virtual void Serialize(CArchive& ar); 
    void AFXAPI SerializeElts (CArchive& ar, T* pItem, int nCount); 
  
private: 
  
    bool isSerializable; 
                    // si true, alors CArraySer contient des objets sérialisables 
  
    std::string msg;  
                    // complément au message d'erreur affiché si on 
                    // tente de sérialiser des objets non-sérialisables 
}; 
  
  
  
template <class T,class U> 
CArraySer<T,U>::CArraySer(int line,bool b) 
{ 
    isSerializable = b; 
    std::ostringstream oss; 
    oss << "Erreur ligne " << line << " : CArraySer contient des objets non-sérialisables"; 
    msg = oss.str(); 
} 
  
  
  
template <class T,class U> 
CArraySer<T,U>::~CArraySer() 
{ 
  
} 
  
  
  
template <class T,class U> 
void AFXAPI CArraySer<T,U>::SerializeElts  ( CArchive& ar,T* pItem, int nCount ) 
{ 
    for ( int i = 0; i < nCount; i++, pItem++ )             
        pItem->Serialize( ar );     
} 
  
  
  
template<class T, class U> 
void CArraySer<T, U>::Serialize(CArchive& ar) 
{ 
    ASSERT_VALID(this); 
  
    if (isSerializable) 
    { 
        CObject::Serialize(ar); 
        if (ar.IsStoring()) 
        { 
            ar.WriteCount(GetSize()); 
        } 
        else 
        { 
            DWORD nOldSize = ar.ReadCount(); 
            SetSize(nOldSize, -1); 
        } 
        SerializeElts(ar, m_pData, GetSize()); 
    } 
    else 
    { 
        AfxMessageBox(msg.c_str()); 
    } 
}

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
// La macro peut-être mise dans le fichier citem.cpp s'il existe 
IMPLEMENT_SERIAL( CItem, CObject, 0) 
  
void Test() 
{ 
   // un element  
   CItem item; 
  
   item.m_strCdp="35200"; 
   item.m_strNom="Shakala"; 
   item.m_strPrenom="Bigboom"; 
   item.m_strVille="Rennes"; 
  
   // un tableau de l'element 
   CArraySer<CItem,CItem&> arItem(__LINE__); 
  
   // remplissage. 
   arItem.Add(item); 
   for(int i=0;i<10;i++) 
   { 
       item.m_strNom.SetAt(0,'A'+i); 
       arItem.Add(item); 
   } 
  
   // archivage. 
   { 
       CFile File;     
       if(File.Open("MyArchive.arc", CFile::modeCreate | CFile::modeWrite )) 
       { 
           CArchive ar( &File, CArchive::store); 
           arItem.Serialize(ar); 
       } 
   } 
  
   // Lecture de l'archive. 
   arItem.RemoveAll(); 
   CFile File;     
   if(File.Open("MyArchive.arc", CFile::modeRead )) 
   { 
       CArchive ar( &File, CArchive::load); 
       arItem.Serialize(ar); 
   } 
  
   // verification du contenu. 
   for(i=0;i<arItem.GetSize();i++) 
   { 
       AfxMessageBox(arItem[i].GetStrDump()); 
   } 
}

1
2
  
CMap<CString ,const char *,_InfosFolder* ,_InfosFolder *> m_mapFilter;

1
2
  
m_mapFilter.SetAt("clef", new _InfosFolder);

1
2
3
4
  
template<class TYPE > 
void AFXAPI DestructElements( TYPE* pElements,  
int nCount );

1
2
3
4
5
  
template <> void AFXAPI DestructElements <_InfosFolder *> ( _InfosFolder** pItem, int nCount ) 
{ 
    for ( int i = 0; i < nCount; i++, pItem++ ) delete *pItem;   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
#ifdef _DEBUG  
  
#define TRACK_ALLOC(_class) void *m_pNew;\ 
void* operator new(size_t nSize,LPCSTR lpszFileName,int nLine)\ 
{\ 
_class *p=static_cast<_class *>(::operator new(nSize, lpszFileName, nLine));\ 
p->m_pNew=p;return p;\ 
}\ 
bool IsAlloc(){return m_pNew==this;} 
  
#else 
  
#define TRACK_ALLOC(_class) void *m_pNew;\ 
void* operator new(size_t nSize)\ 
{\ 
_class *p=static_cast<_class *>(::operator new(nSize));\ 
p->m_pNew=p;return p;\ 
}\ 
bool IsAlloc(){return m_pNew==this;} 
  
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
  
struct _InfosFolder 
{ 
//.............. 
TRACK_ALLOC(_InfosFolder) 
}; 
template <> void AFXAPI DestructElements <_InfosFolder *> ( _InfosFolder** pItem, int nCount ) 
{ 
    for ( int i = 0; i < nCount; i++, pItem++ )             
    { 
        if(*pItem->IsAlloc()) delete *pItem; 
    } 
}

1
2
3
4
5
6
  
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#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
  
void CMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::RemoveAll() 
{ 
    ASSERT_VALID(this); 
    if (m_pHashTable != NULL) 
    { 
        // destroy elements (values and keys) 
        for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++) 
        { 
            CAssoc* pAssoc; 
            for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext) 
            { 
                DestructElements<VALUE>(&pAssoc->value, 1); 
                DestructElements<KEY>(&pAssoc->key, 1); 
            } 
        } 
    } 
    // free hash table 
    delete[] m_pHashTable; 
    m_pHashTable = NULL; 
  
    m_nCount = 0; 
    m_pFreeList = NULL; 
    m_pBlocks->FreeDataChain(); 
    m_pBlocks = NULL; 
}

1
2
3
4
  
ON_COMMAND(ID_FILE_PRINT, CFormView::OnFilePrint) 
ON_COMMAND(ID_FILE_PRINT_DIRECT, CFormView::OnFilePrint) 
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CFormView::OnFilePrintPreview)

1
2
3
4
5
6
7
8
9
10
  
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
  if (cs.hMenu!=NULL) 
    { 
        ::DestroyMenu(cs.hMenu);      // delete menu if loaded 
        cs.hMenu = NULL;              // no menu for this window 
    } 
    return CFrameWnd::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
  
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) 
{ 
  if (cs.hMenu!=NULL) 
    { 
        ::DestroyMenu(cs.hMenu);      // delete menu if loaded 
        cs.hMenu = NULL;              // no menu for this window 
    } 
    return CMDIFrameWnd::PreCreateWindow(cs); 
} 
BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)  
{ 
// TODO: Add your specialized code here and/or call the base class 
  
    return CreateClient(lpcs,NULL); // a la place de la ligne ci-dessus 
//return CMDIFrameWnd::OnCreateClient(lpcs, pContext); 
} 
BOOL CMainFrame::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)  
{ 
// TODO: Add your specialized code here and/or call the base class 
  
return CFrameWnd::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext); 
//return CMDIFrameWnd::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// fonction de la classe dérivée de CDocument 
void CMyDoc::ModifData(CString strName,CString strLevel,CString strLoc,CTime tDate) 
{ 
   // m_pData est une donnée membre de CMyDoc 
   m_pData->SetName(strName); 
   m_pData->SetLevel(strLevel); 
   m_pData->SetPlace(strLoc); 
   m_pData->SetDate(tDate); 
  
   // les données du document ont été modifiées 
   SetModifiedFlag(); 
  
   // mise à jour des vues sur le document 
   UpdateAllViews(NULL); 
}

1
2
3
4
5
6
7
8
9
10
11
12
// modification des données de CMyDoc dans une vue 
void CMyView::MyFunction() 
{ 
   CMyDoc * pDoc = static_cast<CMyDoc*>(GetDocument()); 
  
   // appel de la fonction modificant les données du document 
   pDoc->ModifData("Nom","Niveau","Localisation",CTime::GetCurrentTime()); 
  
   // si on n'avait pas écrit la fonction CMyDoc::ModifData(...), 
   // on aurait géré les modifications du document ici et écrit : 
   // pDoc->SetModifiedFlag(); 
}

1
2
3
4
5
6
  
// Generated message map functions 
//{{AFX_MSG(CPasBougerDlg) 
... 
afx_msg void OnWindowPosChanging( WINDOWPOS* lpwndpos ); 
//}}AFX_MSG

1
2
3
4
5
6
7
8
9
10
11
12
13
BEGIN_MESSAGE_MAP(CPasBougerDlg, CDialog) 
//{{AFX_MSG_MAP(CPasBougerDlg) 
... 
ON_WM_WINDOWPOSCHANGING() 
//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
  
... 
void CPasBougerDlg::OnWindowPosChanging(WINDOWPOS* pWndPos) 
{ 
if (IsWindowVisible()) 
pWndPos->flags |= SWP_NOMOVE; 
}

1
2
3
4
5
6
7
8
9
  
void CMainFrame::OnWindowPosChanging(WINDOWPOS* pWndPos) 
{ 
if (IsWindowVisible()) 
{ 
pWndPos->flags |= SWP_NOMOVE; 
pWndPos->flags |= SWP_NOSIZE; 
} 
}

1
2
mfcPlusWinforms::mfcWinForm dlg; 
dlg.ShowDialog(); // pour qu'elle se comporte comme une dialog

1
2
3
4
5
6
7
CRect Rect; 
    GetParentFrame()->GetWindowRect(&Rect); 
    GetParentFrame()->SetWindowPos( NULL,0,0,Rect.Width(),Rect.Height()/2,SWP_NOMOVE | SWP_NOZORDER); // 
    SIZE size; 
    size.cx=Rect.Width(); 
    size.cy=Rect.Height()/2; 
    SetScaleToFitSize(size);