Apprenez à créer une classe STATIC pour la fonction d'alarme avec l'auteur de Jiang Chuan, Qi Gao
Introduction Le contrôle des alarmes est souvent observé dans divers systèmes de contrôle industriels. Il existe de nombreuses méthodes d'alarme, qui peuvent être marquées par du texte ou représentées par des graphiques. Le principe n'est rien de plus que de construire un objet de classe CDC puis d'utiliser les différentes bases fournies. graphiques utilisant les attributs primitifs. Ici, nous allons créer un programme qui peut afficher le texte d'une alarme lorsqu'une alarme se produit, nous pouvons faire clignoter l'arrière-plan pour réaliser la fonction.
Nous utilisons généralement des méthodes dérivées pour mettre en œuvre ce type de traitement dans le texte.
Utilisez d’abord l’assistant VC pour créer un projet basé sur une boîte de dialogue.
Ensuite, nous plaçons un contrôle STATIC sur l'interface de la boîte de dialogue et définissons la position.
Les préparatifs de base pour dériver une classe basée sur CStatic nommée CStaticRectangle pour notre contrôle STATIC sont terminés. Notre prochaine tâche consiste à ajouter du contenu à la nouvelle classe dérivée pour obtenir l'effet d'écran d'alarme souhaité.
D'après ce que j'ai dit dans mon dernier article, en utilisant la méthode du double buffering, nous devons ajouter les trois fichiers MemDC.h, AutoFont.h et AutoFont.cpp au projet. La classe AutoFont est une meilleure encapsulation de la classe CFont. sur Internet aujourd'hui. Les utilisateurs n'ont pas besoin de prendre en compte les fonctions API de création complexes lors de la création d'objets CFont. Ils n'ont besoin que de définir quelques paramètres simples pour terminer la fonction, nous utilisons donc cette classe ici pour implémenter le contrôle des polices du texte d'alarme.
Définir un objet
//La définition de la couleur peut être augmentée ou diminuée en fonction de la situation réelle.
#définir COLOR_RED RVB (255,0,0)
#définir COULEUR_GREEN RVB(0,255,0)
protégé:
CBitmap *m_pBitmapOldBackground;//Ces trois sont utilisés pour le dessin à double tampon
CBitmap m_bitmapBackground;
CDC m_dcBackground ;
CRect m_rectCtrl; // zone de contrôle
court nMillSec; //Minuterie
CAutoFont *m_pFnt; //Construire la police du texte d'alarme
publique:
COLORREF m_BkColor;//Couleur de fond
COLORREF m_TextColor;//Couleur du texte
CString strText; //Texte d'alarme affiché
BOOL bGleam;//S'il clignote
Initialisez les variables dans le constructeur :
CStaticRectangle ::CStaticRectangle()
{
m_BkColor = COULEUR_ROUGE ;
m_TextColor = RVB (255 128,64 );
nMillSec = 10 ;
bGleam = FAUX ;
m_pFnt = new CAutoFont("script officiel");
m_pFnt->SetHeight(28);
m_pFnt->SetWidth(12);
m_pFnt->SetBold(TRUE);
}
La mémoire est libérée dans le destructeur
CStaticRectangle ::~CStaticRectangle()
{
si(m_pFnt)
supprimer m_pFnt ;
}
Pour dessiner la fonction d'alarme STATIC, il suffit de mapper le message WM_PAINT, puis de redessiner l'interface et d'afficher le texte.
annuler CStaticRectangle :: OnPaint ()
{
CPaintDC dc(this); // contexte de périphérique pour la peinture
// À FAIRE : Ajoutez votre code de gestionnaire de messages ici
// Récupère la zone de contrôle
GetClientRect (&m_rectCtrl);
CMemDC memDC(&dc, &m_rectCtrl);
if(m_dcBackground.GetSafeHdc()== NULL|| (m_bitmapBackground.m_hObject == NULL))
{
m_dcBackground.CreateCompatibleDC(&dc);
m_bitmapBackground.CreateCompatibleBitmap(&dc, m_rectCtrl.Width(), m_rectCtrl.Height()) ;
m_pBitmapOldBackground = m_dcBackground.SelectObject(&m_bitmapBackground);
}
DrawRectangleBackground(&m_dcBackground, m_rectCtrl);
memDC.BitBlt(0, 0, m_rectCtrl.Width(), m_rectCtrl.Height(),
&m_dcBackground, 0, 0, SRCCOPY);
// N'appelle pas CStatic::OnPaint() pour peindre les messages
}
Ensuite, nous contrôlons l'affichage des informations pertinentes. Ce à quoi nous devons faire attention ici, c'est l'affichage de notre texte. Ici, nous devons calculer la position de l'affichage du texte.
Nous pouvons obtenir la taille C du texte via pDC->GetTextExtent();, puis utiliser le rect du contrôle pour obtenir la position d'affichage du texte.
La méthode utilisée ici est de l'afficher au centre.
void CStaticRectangle :: DrawRectangleBackground (CDC *pDC, CRect &rect)
{
CBrush brushFill, *pBrushOld;
int nXTaille,nYSize;
CTaille szText ;
CFont *fOldFont;
nXSize = rect.Width();
nYSize = rect.Hauteur();
brushFill.DeleteObject();
brushFill.CreateSolidBrush(m_BkColor);
pBrushOld = pDC->SelectObject(&brushFill);
pDC->Rectangle(rect);
pDC->SetBkColor(m_BkColor);
pDC->SetTextColor(m_TextColor);
fOldFont = (CFont *)pDC->SelectObject(m_pFnt);
szText = pDC->GetTextExtent(strText);
nXSize = (nXSize - szText.cx)/2;
nYSize = (nYSize - szText.cy)/2;
pDC->TextOut(nXSize,nYSize,strText);
pDC-> SelectObject (pBrushOld);
pDC->SélectionnerObjet(&fOldFont);
brushFill.DeleteObject();
}
Si nous voulons implémenter la fonction d'alarme, nous devons utiliser la fonction minuterie pour changer régulièrement la couleur d'arrière-plan, puis actualiser l'affichage.
À ce stade, le travail de base est terminé. La prochaine chose à faire est de fournir une interface que les utilisateurs peuvent modifier dynamiquement.
void CStaticRectangle :: SetRectangleText (CString strVal)
{
this->strText = strVal;
}
void CStaticRectangle::SetBackColor(UINT nStyle)//Définir la couleur d'arrière-plan
{
this->m_BkColor = nStyle;
}
void CStaticRectangle :: SetBkGleam (BOOL bShow)
{
si(this->bGleam)
{
si(!bAfficher)
KillTimer(nMillSec);
}
autre
{
si (bAfficher)
SetTimer(nMillSec,750,NULL);
}
this->bGleam = bShow;
}
Eh bien, maintenant que notre classe fonctionnelle est terminée, la prochaine chose à faire est de la connecter avec CSTATIC sur l'interface.
Créez une variable associée au contrôle STATIC (type de contrôle) via CLASSWIZARD, puis modifiez le type dérivé en notre CStaticRectangle et définissez l'effet clignotant, et nous pouvons voir l'effet.
Développer
