CComboBox::AddString
int AddString( LPCTSTR lpszString );

CString str;
int nIndex;
for (int i=0;i < 20;i++)
{
   str.Format("Ma chaîne %d"), i);
   nIndex=MyComboBox.AddString( str );
}

CComboBox::InsertString
int InsertString( int nIndex, LPCTSTR lpszString );

CComboBox::SetCurSel
int SetCurSel( int nSelect );

int nCount = MyComboBox.GetCount();
if (nCount > 0) MyComboBox.SetCurSel(nCount-1);

void CMyComboBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
    // TODO: Add your code to draw the specified item
    ASSERT(lpDrawItemStruct->CtlType == ODT_COMBOBOX);
    // permet dans le cas ou le contrôle est chargé dans l'éditeur de ressources 
    //d'initialisé itemdata correctement
    // m_bInit:variable de type bool a mettre a true dans le constructeur.
    if(m_bInit && (GetStyle() & CBS_HASSTRINGS)) 
    {
        for(int i=0;i<GetCount() ;i++) SetItemData(i,i);
    }
    m_bInit=false;
    LPCTSTR lpszText=NULL ;
    CString str;
    // si le style est <> de CBS_HASSTRINGS on considère que la valeur à afficher 
    //est dans ItemData.
    if(lpDrawItemStruct->itemID!=CB_ERR && !(GetStyle() & CBS_HASSTRINGS))
        lpszText=(LPCTSTR) lpDrawItemStruct->itemData;
    else
    {
        // Récupération de la chaîne grâce à l'index stocké dans ItemData.
        GetLBText(lpDrawItemStruct->itemData,str);
        lpszText= str;
    }
    ASSERT(lpszText != NULL);
    CDC dc;
    dc.Attach(lpDrawItemStruct->hDC);
    // Sauvegarde des anciennes valeurs
    COLORREF crOldTextColor = dc.GetTextColor();
    COLORREF crOldBkColor = dc.GetBkColor();
    // Traitement couleurs quand l'item est sélectionné.
    if ((lpDrawItemStruct->itemAction | ODA_SELECT) &&
      (lpDrawItemStruct->itemState  & ODS_SELECTED))
    {
        // couleur d'ecriture
        dc.SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
        // couleur de fond 
        dc.SetBkColor(::GetSysColor(COLOR_HIGHLIGHT));
        // pareil pour le fond.
        dc.FillSolidRect(&lpDrawItemStruct->rcItem,
            ::GetSysColor(COLOR_HIGHLIGHT));
    }
    else
    {
        // couleur de fond de la zone hors sélection
        dc.FillSolidRect(&lpDrawItemStruct->rcItem, crOldBkColor);
    }
    // ecriture du texte.
    dc.DrawText(
      lpszText,
      strlen(lpszText),
      &lpDrawItemStruct->rcItem,DT_SINGLELINE);

    // Restitution des valeurs d'origines
    dc.SetTextColor(crOldTextColor);
    dc.SetBkColor(crOldBkColor);
    dc.Detach();
} 

CComboBox::GetCurSel
int GetCurSel( ) const;

CComboBox::GetLBText
int GetLBText( int nIndex, LPTSTR lpszText ) const;
void GetLBText( int nIndex, CString& rString ) const;

CString str ;
int nIndex = MyComboBox.GetCurSel();
if(nIndex!=LB_ERR) MyComboBox.GetLBText(nIndex,str);
AfxMessageBox(str);

CComboBox::FindString
int FindString( int nStartAfter, LPCTSTR lpszString ) const;

// selection de la chaîne ligne 1
MyComboBox.SetCurSel(MyComboBox.FindString(0, ?Ligne 1?));

// que l'on peut aussi faire de la manière suivante:
MyComboBox. SelectString(0,?Ligne 1?);

// prototype de la méthode:
// CComboBox::DeleteString
int DeleteString( UINT nIndex );

for (int i=MyComboBox.GetCount()-1; i>=0 ;i--)
{
   MyComboBox.DeleteString( i );
}
// Ce même code peut être écrit de la manière suivante :
MyComboBox.ResetContent() ;

//CComboBox::ResetContent
void ResetContent( );

/*CImageList*/ m_ImageList.Create(16, 16, ILC_COLOR, 2, 2);
m_ImageList.Add(&Bitmap1);
m_ImageList.Add(&Bitmap2);
m_ImageList.Add(&Bitmap3);

COMBOBOXEXITEM     cbi;
CString            str;
int                   i=0;

cbi.mask = CBEIF_IMAGE | CBEIF_INDENT | CBEIF_OVERLAY |
     CBEIF_SELECTEDIMAGE | CBEIF_TEXT;

cbi.iItem = i;
str.Format(_T("Item %02d"), i);
cbi.pszText = (LPTSTR)(LPCTSTR)str;
cbi.cchTextMax = str.GetLength();
cbi.iImage = 0;
cbi.iSelectedImage = 1;
cbi.iOverlay = 2;
cbi.iIndent = 0; 

m_ComboEx.InsertItem(&cbi);

void CMyCombo::PreSubclassWindow() 
{ 
   m_MyEdit.SubclassDlgItem(1001, this); 
   CComboBox::PreSubclassWindow(); 
} 

// Mettre la combobox en lecture seule :
CEdit *pEdit = static_cast<CEdit*> (m_maCombo.GetWindow (GW_CHILD));

if (pEdit)
    pEdit->SetReadOnly(TRUE);

class CComboBoxLS : public CComboBox
{
#pragma region Attributs
protected :
    /// <summary>Index de la sélection dans la liste.</summary>
    int m_posSel;

    /// <summary>Indique si la combobox est en lecture seule ou non.</summary>
    bool m_lectureSeule;

    /// <summary>Indique si la combobox a l'aspect grisé de la lecture seule ou non.</summary>
    bool m_grise;

    /// <summary>Sauvegarde éventuelle du paramétrage Tabstop du contrôle.</summary>
    bool m_tabStop;

    /// <summary>Champ de saisie associé à la combobox.</summary>
    CEdit m_edit;
#pragma endregion

#pragma region Constructeurs & destructeur
public :
    /// <summary>Construit une instance de combobox.</summary>
    CComboBoxLS();

    /// <summary>Libère la mémoire occupée par l'objet.</summary>
    virtual ~CComboBoxLS() {};
#pragma endregion

#pragma region Accesseurs
public :
    /// <summary>Indique si la combobox est en lecture seule ou non.</summary>
    /// <returns><c>TRUE</c> si la combobox est en lecture seule, <c>FALSE</c> sinon.</returns>
    BOOL GetReadOnly() { return m_lectureSeule; };

    /// <summary>Change le mode d'accès à la combobox : lecture seule ou mode normal.</summary>
    /// <param name='valeur'><c>TRUE</c> pour passer en lecture seule, <c>FALSE</c> pour passer en mode normal.</param>
    /// <returns><c>TRUE</c> si la modification s'est correctement effectuée, <c>FALSE</c> si une erreur
    /// est intervenue.</returns>
    BOOL SetReadOnly(BOOL valeur = TRUE);
#pragma endregion

#pragma region Méthodes
public :
    /// <summary>Ajoute un élément à la fin de la liste déroulable.</summary>
    /// <param name='texte'>Libellé de l'élément à ajouter.</param>
    /// <returns>Position dans la liste de l'élément ajouté, ou <c>CB_ERR</c> en cas d'échec de l'ajout,
    /// ou <c>CB_ERRSPACE</c> si l'espace est insuffisant dans la liste pour ajouter l'élément.</returns>
    int AddString(LPCTSTR texte);

    /// <summary>Ajoute un élément à la liste déroulable à une position donnée.</summary>
    /// <param name='index'>Index (en base 0) de l'élément à insérer, ou <c>-1</c> pour l'ajouter en fin de liste.</param>
    /// <param name='texte'>Libellé de l'élément à ajouter.</param>
    /// <returns>Position dans la liste de l'élément inséré, ou <c>CB_ERR</c> en cas d'échec de l'insertion,
    /// ou <c>CB_ERRSPACE</c> si l'espace est insuffisant dans la liste pour ajouter l'élément.</returns>
    int InsertString(int index, LPCTSTR texte);

    /// <summary>Change la sélection de la combobox en fonction de l'index passé en paramètre.</summary>
    /// <param name='index'>Index (en base 0) de l'élément à sélectionner, ou <c>-1</c> pour ne rien
    /// sélectionner.</param>
    /// <returns>Index (en base 0) de la nouvelle sélection, ou <c>CB_ERR</c> si la sélection a échoué
    /// ou si aucun élément n'a été sélectionné.</returns>
    int SetCurSel(int index)
    {
        m_posSel = CComboBox::SetCurSel(index);
        return m_posSel;
    };

    /// <summary>Recherche dans la liste un libellé commençant par la chaîne de caractères passée en paramètre.
    /// Si un libellé est ainsi trouvé, l'élément correspondant dans la liste est sélectionné.</summary>
    /// <param name='posDepart'>Index de départ de la recherche (en base 0). <c>-1</c> pour une recherche
    /// dans toute la liste.</param>
    /// <param name='texte'>Chaîne de caractères devant correspondre au moins au début du libellé recherché.</param>
    /// <returns>Index de l'élément sélectionné si le libellé a été trouvé, ou <c>CB_ERR</c> en cas d'échec
    /// de la recherche.</returns>
    int SelectString(int posDepart, LPCTSTR texte);

    /// <summary>Supprime un élément de la liste en fonction de sa position.</summary>
    /// <param name='index'>Index (en base 0) de l'élément à supprimer.</param>
    /// <returns>Nombre d'éléments restant dans la liste (si <c>>= 0</c>), ou <c>CB_ERR</c> si l'élément
    /// recherché n'a pas été trouvé.</returns>
    int DeleteString(UINT index);

    /// <summary>Vide la liste déroulable de tous ses éléments.</summary>
    void ResetContent()
    {
        CComboBox::ResetContent();
        SetLectureSeule();
    };

protected :
    DECLARE_MESSAGE_MAP()

    /// <summary>Change le mode d'accès à la combobox : lecture seule ou mode normal.</summary>
    /// <param name='valeur'><c>true</c> pour passer en lecture seule, <c>false</c> pour passer en mode normal.</param>
    /// <returns><c>true</c> si la modification s'est correctement effectuée, <c>false</c> si une erreur
    /// est intervenue.</returns>
    /// <remarks>Cette méthode est utilisée entre autres par <c>SetReadOnly</c>, qui, en plus, garde en mémoire
    /// l'état de la combobox, ce qui n'est pas le cas de cette méthode.</remarks>
    bool SetLectureSeule(bool valeur = true);

    virtual void PreSubclassWindow()
    {
        m_edit.SubclassDlgItem(1001, this);
        CComboBox::PreSubclassWindow();
    };

    afx_msg HBRUSH CtlColor(CDC *pDC, UINT /*nCtlColor*/);
    virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo);
#pragma endregion
};

#include "ComboBoxLS.h"
#pragma region Constructeurs & destructeur

CComboBoxLS::CComboBoxLS()
{
    m_posSel = -1;
    m_lectureSeule    = m_grise = false;
    m_tabStop        = true;
}

#pragma endregion

#pragma region Accesseurs

BOOL CComboBoxLS::SetReadOnly(BOOL valeur /*= TRUE*/)
{
    bool val = (valeur == TRUE);

    if (val == m_lectureSeule)
        return TRUE;

    BOOL resu = SetLectureSeule(val);

    if (resu)
        m_lectureSeule = val;

    return resu;
}

#pragma endregion

#pragma region Méthodes

BEGIN_MESSAGE_MAP(CComboBoxLS, CComboBox)
    ON_WM_CTLCOLOR_REFLECT()
END_MESSAGE_MAP()

int CComboBoxLS::AddString(LPCTSTR texte)
{
    int resu = CComboBox::AddString(texte);

    if ((resu != CB_ERR) && (resu != CB_ERRSPACE) && !m_lectureSeule && GetCount())
        SetLectureSeule(false);

    return resu;
}

int CComboBoxLS::InsertString(int index, LPCTSTR texte)
{
    int resu = CComboBox::InsertString(index, texte);

    if ((resu != CB_ERR) && (resu != CB_ERRSPACE) && !m_lectureSeule && GetCount())
        SetLectureSeule(false);

    return resu;
}

int CComboBoxLS::SelectString(int posDepart, LPCTSTR texte)
{
    int resu = CComboBox::SelectString(posDepart, texte);

    if (resu != CB_ERR)
        m_posSel = resu;

    return resu;
}

int CComboBoxLS::DeleteString(UINT index)
{
    int resu = CComboBox::DeleteString(index);

    if ((resu != CB_ERR) && !GetCount())
        SetLectureSeule();

    return resu;
}

bool CComboBoxLS::SetLectureSeule(bool valeur /*= true*/)
{
    if (m_grise == valeur)
        return true;

    if (IsWindow(m_edit.m_hWnd) && !m_edit.SetReadOnly(valeur))
        return false;

    if (IsWindow(m_hWnd))
        if (valeur)
        {
            m_tabStop = (GetStyle() & WS_TABSTOP)? true : false;
            ModifyStyle(WS_TABSTOP, 0);
        }
        else if (m_tabStop)
            ModifyStyle(0, WS_TABSTOP);

    m_grise = valeur;
    Invalidate();    // Déclenche la méthode CtlColor.
    return true;
}

HBRUSH CComboBoxLS::CtlColor(CDC *pDC, UINT /*nCtlColor*/)
{
    // Réglage de la couleur de fond en fonction du mode d'accès.
    if (IsWindowEnabled() && !m_grise)
    {
        pDC->SetBkColor(GetSysColor(COLOR_WINDOW));
        return GetSysColorBrush(COLOR_WINDOW);
    }
    else
    {
        pDC->SetBkColor(GetSysColor(COLOR_BTNFACE));
        return GetSysColorBrush(COLOR_BTNFACE);
    }
}

BOOL CComboBoxLS::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
    if (nCode == CBN_SELCHANGE)
    {
        // La notification CBN_SELCHANGE (changement de sélection dans la liste de la combobox)
        // ne doit être envoyée à la fenêtre parent que dans le cas où la sélection a changé et où
        // la combobox n'est pas en lecture seule.
        int pos = GetCurSel();

        if (pos == m_posSel)
        {
            // La sélection n'a pas changé ; on n'envoie pas la notification.
            ShowDropDown(FALSE);
            return TRUE;
        }

        if (m_lectureSeule)
        {
            // La combobox est en lecture seule ;
            // on annule la modification et on n'envoie pas la notification.
            ShowDropDown(FALSE);
            CComboBox::SetCurSel(m_posSel);
            return TRUE;
        }
        else
            // La combobox n'est pas en lecture seule ;
            // on enregistre la nouvelle sélection, puis on envoie la notification.
            m_posSel = pos;
    }

    // Transmission de la notification.
    return CComboBox::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}

#pragma endregion

// From Paul S. Vickery
BOOL MyClass::RecreateComboBox(CComboBox* pCombo, LPVOID lpParam/*=0*/)
{
    if (pCombo == NULL)
        return FALSE;
    if (pCombo->GetSafeHwnd() == NULL)
        return FALSE;
    
    CWnd* pParent = pCombo->GetParent();
    if (pParent == NULL)
        return FALSE;
    
    // get current attributes
    DWORD dwStyle = pCombo->GetStyle();
    DWORD dwStyleEx = pCombo->GetExStyle();
    CRect rc;
    pCombo->GetDroppedControlRect(&rc);
    pParent->ScreenToClient(&rc);// map to client co-ords
    UINT nID = pCombo->GetDlgCtrlID();
    CFont* pFont = pCombo->GetFont();
    CWnd* pWndAfter = pCombo->GetNextWindow(GW_HWNDPREV);
    
    // get the currently selected text (and whether it is a valid list selection)
    CString sCurText;
    int nCurSel = pCombo->GetCurSel();
    BOOL bItemSelValid = nCurSel != -1;
    if (bItemSelValid)
        pCombo->GetLBText(nCurSel, sCurText);
    else
        pCombo->GetWindowText(sCurText);
    
    // copy the combo box items into a temp combobox (not sorted)
    // along with each item's data
    CComboBox comboNew;
    if (! comboNew.CreateEx(dwStyleEx, _T("COMBOBOX"), _T(""), 
        dwStyle, rc, pParent, nID, lpParam))
        return FALSE;
    comboNew.SetFont(pFont);
    int nNumItems = pCombo->GetCount();
    for (int n = 0; n < nNumItems; n++)
    {
        CString sText;
        pCombo->GetLBText(n, sText);
        int nNewIndex = comboNew.AddString(sText);
        comboNew.SetItemData(nNewIndex, pCombo->GetItemData(n));
    }
    // re-set selected text
    if (bItemSelValid)
        comboNew.SetCurSel(comboNew.FindStringExact(-1, sCurText));
    else
        comboNew.SetWindowText(sCurText);
    
    // destroy the existing window, then attach the new one
    pCombo->DestroyWindow();
    HWND hwnd = comboNew.Detach();
    pCombo->Attach(hwnd);
    
    // position correctly in z-order
    pCombo->SetWindowPos(pWndAfter == NULL ? 
        &CWnd::wndBottom : 
    pWndAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    return TRUE;
}

// From Unknown :?
void MyClass::set_DropDownSize(CComboBoxExt& box, UINT LinesToDisplay)
{
    ASSERT(IsWindow(box));// Window must exist or SetWindowPos won't work

    CRect cbSize;// current size of combo box
    int Height;            // new height for drop-down portion of combo box

    box.GetClientRect(cbSize);
    Height = box.GetItemHeight(-1);      // start with size of the edit-box portion
    Height += box.GetItemHeight(0) * LinesToDisplay;// add height of lines of text

    // Note: The use of SM_CYEDGE assumes that we're using Windows '95
    // Now add on the height of the border of the edit box
    Height += GetSystemMetrics(SM_CYEDGE) * 2; // top & bottom edges

    // The height of the border of the drop-down box
    Height += GetSystemMetrics(SM_CYEDGE) * 2; // top & bottom edges

    // now set the size of the window
    box.SetWindowPos(NULL,            // not relative to any other windows
        0, 0,                         // TopLeft corner doesn't change
        cbSize.right, Height,         // existing width, new height
        SWP_NOMOVE | SWP_NOZORDER     // don't move box or change z-ordering.
        );
}