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 );

CWnd::FindWindow
static CWnd* PASCAL FindWindow( 
LPCTSTR lpszClassName, 
LPCTSTR lpszWindowName ); 

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

// 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());
    }

}

#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());
    }
}

// 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());
   }
}

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

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

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

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

#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

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;
    }
}

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

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;
}

ON_COMMAND(ID_FILE_PRINT, CFormView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CFormView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CFormView::OnFilePrintPreview)

  
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);
}

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);
}

// 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);
}

// 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();
}

// Generated message map functions
//{{AFX_MSG(CPasBougerDlg)
...
afx_msg void OnWindowPosChanging( WINDOWPOS* lpwndpos );
//}}AFX_MSG

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;
}

void CMainFrame::OnWindowPosChanging(WINDOWPOS* pWndPos)
{
if (IsWindowVisible())
{
pWndPos->flags |= SWP_NOMOVE;
pWndPos->flags |= SWP_NOSIZE;
}
}

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

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);