FAQ VC++ et MFCConsultez toutes les FAQ

1
2
3
  
CComboBox::AddString 
int AddString( LPCTSTR lpszString );

1
2
3
4
5
6
7
8
  
CString str; 
int nIndex; 
for (int i=0;i < 20;i++) 
{ 
   str.Format("Ma chaîne %d"), i); 
   nIndex=MyComboBox.AddString( str ); 
}

1
2
3
  
CComboBox::InsertString 
int InsertString( int nIndex, LPCTSTR lpszString );

1
2
3
  
CComboBox::SetCurSel 
int SetCurSel( int nSelect );

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

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

1
2
3
  
CComboBox::GetCurSel 
int GetCurSel( ) const;

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

1
2
3
4
5
  
CString str ; 
int nIndex = MyComboBox.GetCurSel(); 
if(nIndex!=LB_ERR) MyComboBox.GetLBText(nIndex,str); 
AfxMessageBox(str);

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

1
2
3
4
5
6
  
// 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”);

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

1
2
3
4
5
6
7
  
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() ;

1
2
3
  
//CComboBox::ResetContent 
void ResetContent( );

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
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);

1
2
3
4
5
6
  
void CMyCombo::PreSubclassWindow()  
{  
   m_MyEdit.SubclassDlgItem(1001, this);  
   CComboBox::PreSubclassWindow();  
}

1
2
3
4
5
// Mettre la combobox en lecture seule : 
CEdit *pEdit = static_cast<CEdit*> (m_maCombo.GetWindow (GW_CHILD)); 
  
if (pEdit) 
    pEdit->SetReadOnly(TRUE);

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

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#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

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

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