Forcer la couleur d'un CStatic

Version imprimable

Bonjour,

J'aurais besoin d'un coup de pouce :king:

Je développe actuellement une application sous visual C6. Dans cette Appli, j'utilise un CStatic, en type Bitmap.

J'ai alloué une zone mémoire de la taille de ce bitmap. Je le met à jour quand cela est nécessaire (il s'agit d'un portage de moteur graphique).

Or au niveau couleur de ce CStatic, il m'arrive d'avoir tout et n'importe quoi :cry:

Comment fais -t'on pour fixer la couleur du bitmap??? J'aimerais la fixer juste avant de faire mon refresh, et ainsi, ne plus être embété..
Extrait de code de la fonction, qui met à jour :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Int lig; for (lig = 0; lig < 128; lig += 1) { memcpy(dlg.pPrivateBuffer + (lig * 32),RamEcran,30); RamEcran += 30; } //memcpy(dlg.pPrivateBuffer,RamEcran,Taille); //Couleur noir forcé pour le bitmap??? //rafraichissement du CStatic dlg.m_Picture1.Invalidate(TRUE);
Merci d'avance ;)

Essaye ca :

Copie ceci dans CTplCtrl.h :

Code:

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
 
#if !defined(AFX_CTPLCTRL_H__0E380150_021B_4DC2_BBFF_F4EF17DCC038__INCLUDED_)
#define AFX_CTPLCTRL_H__0E380150_021B_4DC2_BBFF_F4EF17DCC038__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
 
 
// include
/////////////////////////////////////////////////////////////////////////////
// Classe Template attributs couleurs 
template <class GENERIC_CTRLCOLOR>
class CTplCtrl2 : public GENERIC_CTRLCOLOR
{
// Construction
public:
    CTplCtrl2()
    {
        m_arClrCtlText[0]=::GetSysColor(COLOR_WINDOWTEXT); 
        m_arClrCtlText[1]=RGB(0  ,0  ,255); // LtBlue
        m_arClrCtlText[2]=RGB(128,0,0);    // Red.
        m_arClrCtlBkText[0]=::GetSysColor(COLOR_WINDOW); 
        m_arClrCtlBkText[1]=::GetSysColor(COLOR_WINDOW); 
        m_arClrCtlBkText[2]=::GetSysColor(COLOR_WINDOW); 
        for(int i=0;i<3;i++) 
        m_arHbrClrCtlBk[i]=::CreateSolidBrush(m_arClrCtlBkText[i]);
    }
 
   enum ModeColor
   {
    Normal,
    Disable,
    ReadOnly
   };
 
    void SetBkColor(COLORREF clrCtlBk = RGB(192, 192, 192), // couleur de fond
                    COLORREF clrCtlText = RGB(0, 0, 0),     // couleur d'écriture.
                    ModeColor eMode=Normal)                 // mode actif/Inactif/lecture seule.
    {
        m_arClrCtlText[eMode]=clrCtlText;
        m_arClrCtlBkText[eMode]=clrCtlBk;
        if(m_arHbrClrCtlBk[eMode])
            ::DeleteObject(m_arHbrClrCtlBk[eMode]); 
        m_arHbrClrCtlBk[eMode] = ::CreateSolidBrush(clrCtlBk);        
        if(m_hWnd) Invalidate();
    }
 
// Attributes
public:
 
    HBRUSH    m_arHbrClrCtlBk[3]; // brush de fond
    COLORREF  m_arClrCtlBkText[3];// couleur du fond.
    COLORREF  m_arClrCtlText[3];  // couleurs d'ecriture.  
 
// Operations
public:
 
    virtual ~CTplCtrl2()
    {
        for(int i=0;i<3;i++) 
        if(m_arHbrClrCtlBk[i]) ::DeleteObject(m_arHbrClrCtlBk[i]);
    };
 
    HBRUSH CtlColor(CDC* pDC, UINT nCtlColor)
    {
        bool bCEdit=(IsKindOf(RUNTIME_CLASS(CEdit))?true:false);
        HBRUSH hbr=NULL;
        ModeColor eMode=Normal;
        if(GetStyle() & ES_READONLY) eMode=ReadOnly;
        if(!IsWindowEnabled()) eMode=Disable;
 
        // TODO: Change any attributes of the DC here
        pDC->SetTextColor(m_arClrCtlText[eMode]);
 
        // Fixe le fond en transparent  pour le texte
        if(!bCEdit) pDC->SetBkMode(TRANSPARENT);
        else pDC->SetBkColor(m_arClrCtlBkText[eMode]);
 
        // retourne le handle de la brush pour le fond si il existe.
        if(m_arHbrClrCtlBk[eMode]) hbr = m_arHbrClrCtlBk[eMode]; 
 
        // TODO: Return a different brush if the default is not desired
        return hbr;
    }
 
    virtual BOOL OnChildNotify( UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pLResult )
    {       
        // interception du message reflect
        if(message >= WM_CTLCOLORMSGBOX && message <= WM_CTLCOLORSTATIC)
        {            
            UINT nCtlType = message - WM_CTLCOLORMSGBOX;
            ASSERT(nCtlType >= CTLCOLOR_MSGBOX);
            ASSERT(nCtlType <= CTLCOLOR_STATIC);
 
            CDC dcTemp; dcTemp.m_hDC = (HDC)wParam;
 
            HBRUSH hbr = CtlColor(&dcTemp, nCtlType);
            // fast detach of temporary objects
            dcTemp.m_hDC = NULL;
            *pLResult = (LRESULT)hbr;
            return TRUE;
        }
        return GENERIC_CTRLCOLOR::OnChildNotify( message,wParam, lParam,pLResult );
    } 
};
 
 
#endif

Ensuite dans ton dlg.h tu mets :

Code:

1
2
3
 
/* new type of static -- for change the background and text color */
typedef CTplCtrl2<CStatic> CStaticEx;

+

Dans tes variables :

Code:

1
2
 
CStaticEx pPrivateBuffer;

Pour finir :

Code:

1
2
 
pPrivateBuffer.SetBkColor(RGB(223,223,223) , RGB(0,0,0) );

En esperant que ca fonctionne pour toi ! :roll:

16/04/2009, 14h28
Xaladra

Merci bien.. mais .. ca marche pas :(:(:piou:

peut on forcer un bitmap via les structure "BITMAPINFOHEADER" et "BITMAPINFO" a être monochrome, c'est a dire soir noir soit blanc...??

Actuellement, lors du lancement de l'application, je peux parcourir, à chaque lancement, l'ensemble des couleurs de l'arc en ciel :)

Problème résolu pour forcer la couleur du bitmap

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
typedef struct 
{
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColor[2]; //exactly three colors in the palette
}SIBITMAPINFO;
 
static const BITMAPINFOHEADER bmiHeader=
{			
	sizeof(BITMAPINFOHEADER),
	240,  // largeur
	-128,  // hauteur
	1,
	1,  // pour du 24 bits par pixel
	BI_RGB,
	0,0,0,0,0
};

A l'initialisation "OnInitDialog, copier le code suivant pour initialiser le Bitmap en monochrome + définir les deux couleurs utilisés par le bitmal (ici blanc/noir)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
       SIBITMAPINFO bmi = {0};
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = 240;
	bmi.bmiHeader.biHeight = -128; // positive number == bottom-up DIB
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 1;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biClrUsed = 2; // only three colors are in the palette
 
 
 
	// define the three colors in the palette (R, G and B)
	bmi.bmiColor[0].rgbRed = 255;
	bmi.bmiColor[0].rgbGreen = 255;
	bmi.bmiColor[0].rgbBlue = 255;
	bmi.bmiColor[0].rgbReserved = 0;
 
	bmi.bmiColor[1].rgbRed = 0;
	bmi.bmiColor[1].rgbGreen = 0;
	bmi.bmiColor[1].rgbBlue = 0;
	bmi.bmiColor[1].rgbReserved = 0;