Aprenda a crear una clase ESTÁTICA para la función de alarma con el autor de Jiang Chuan, Qi Gao
Introducción El control de alarma se ve a menudo en varios sistemas de control industrial. Hay muchos métodos para generar alarmas, que pueden marcarse mediante texto o representarse mediante gráficos. El principio no es más que construir un objeto de clase CDC y luego usar los diversos elementos básicos proporcionados. gráficos usando los atributos primitivos Aquí crearemos un programa que puede mostrar texto de alarma. Cuando ocurre una alarma, podemos hacer parpadear el fondo para lograr la función.
Generalmente utilizamos métodos derivados para implementar este tipo de procesamiento en el texto.
Primero use el asistente de VC para crear un proyecto basado en diálogos.
Luego colocamos un control ESTÁTICO en la interfaz del cuadro de diálogo y configuramos la posición.
Los preparativos básicos para derivar una clase basada en CStatic llamada CStaticRectangle para nuestro control STATIC están completos. Nuestra siguiente tarea es agregar contenido a la nueva clase derivada para lograr el efecto de pantalla de alarma deseado.
Según lo que dije en mi último artículo, usando el método de doble almacenamiento en búfer, necesitamos agregar los tres archivos MemDC.h, AutoFont.h y AutoFont.cpp al proyecto. La clase AutoFont es una mejor encapsulación de la clase CFont. En Internet hoy en día, los usuarios no necesitan considerar funciones API de creación complejas al crear objetos CFont. Solo necesitan realizar algunas configuraciones de parámetros simples para completar la función, por lo que usamos esta clase aquí para implementar el control de fuente del texto de alarma.
Definir objeto
//La definición de color se puede aumentar o disminuir según la situación real.
#definir COLOR_RED RGB(255,0,0)
#definir COLOR_VERDE RGB(0,255,0)
protegido:
CBitmap *m_pBitmapOldBackground;//Estos tres se utilizan para dibujar con doble búfer
CBitmap m_bitmapBackground;
CDC m_dcBackground;
CRect m_rectCtrl; // área de control
short nMillSec; //Temporizador
CAutoFont *m_pFnt; //Construir fuente de texto de alarma
público:
COLORREF m_BkColor;//Color de fondo
COLORREF m_TextColor;//Color del texto
CString strText; //Texto de alarma mostrado
BOOL bGleam;//Si parpadea
Inicializar variables en el constructor:
CStaticRectangle::CStaticRectangle()
{
m_BkColor = COLOR_RED;
m_TextColor = RGB(255,128,64);
nMillSec = 10;
bBrillo = FALSO;
m_pFnt = new CAutoFont("script oficial");
m_pFnt->SetHeight(28);
m_pFnt->SetWidth(12);
m_pFnt->SetBold(VERDADERO);
}
La memoria se libera en el destructor.
CStaticRectangle::~CStaticRectangle()
{
si(m_pFnt)
eliminar m_pFnt;
}
Para dibujar la función de alarma ESTÁTICA, solo necesitamos asignar el mensaje WM_PAINT y luego volver a dibujar la interfaz y mostrar el texto.
vacío CStaticRectangle::OnPaint()
{
CPaintDC dc(this); // contexto del dispositivo para pintar
// TODO: Añade aquí el código del controlador de mensajes
// Obtener el área de control
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);
// No llames a CStatic::OnPaint() para pintar mensajes
}
A continuación, controlamos la visualización de información relevante. A lo que debemos prestar atención aquí es a la visualización de nuestro texto. Aquí debemos calcular la posición de la visualización del texto.
Podemos obtener el CSize del texto a través de pDC->GetTextExtent(); y luego usar el rect del control para obtener la posición de visualización del texto.
El método utilizado aquí es mostrarlo en el centro.
void CStaticRectangle::DrawRectangleBackground(CDC *pDC, CRect &rect)
{
CBrush brushFill, *pBrushOld;
int nXTamaño,nYTamaño;
CTamaño szText;
Fuente CF *fOldFont;
nXSize = rect.Width();
nYSize = rect.Height();
brushFill.DeleteObject();
brushFill.CreateSolidBrush(m_BkColor);
pBrushOld = pDC->SelectObject(&brushFill);
pDC->Rectángulo(rect);
pDC->SetBkColor(m_BkColor);
pDC->SetTextColor(m_TextColor);
fOldFont = (CFont *)pDC->SelectObject(m_pFnt);
szText = pDC->GetTextExtent(strText);
nXTamaño = (nXTamaño - szText.cx)/2;
nYSize = (nYSize - szText.cy)/2;
pDC->TextOut(nXSize,nYSize,strText);
pDC->SelectObject(pBrushOld);
pDC->SelectObject(&fOldFont);
brushFill.DeleteObject();
}
Si queremos implementar la función de alarma, debemos usar la función de temporizador para cambiar el color de fondo regularmente y luego actualizar la pantalla.
En este punto, el trabajo básico se ha completado. Lo siguiente que debe hacer es proporcionar una interfaz que los usuarios puedan modificar dinámicamente.
vacío CStaticRectangle::SetRectangleText(CString strVal)
{
esto->strText = strVal;
}
void CStaticRectangle::SetBackColor(UINT nStyle)//Establece el color de fondo
{
this->m_BkColor = nEstilo;
}
vacío CStaticRectangle::SetBkGleam(BOOL bShow)
{
si(esto->bGleam)
{
si(!bMostrar)
KillTimer(nMillSec);
}
demás
{
si(bMostrar)
SetTimer(nMillSec,750,NULL);
}
esto->bGleam = bMostrar;
}
Bueno, ahora que nuestra clase funcional ha sido completada, lo siguiente que debemos hacer es conectarla con CSTATIC en la interfaz.
Cree una variable asociada al control ESTÁTICO (tipo de control) a través de CLASSWIZARD, luego modifique el tipo derivado a nuestro CStaticRectangle y configure el efecto de parpadeo, y podremos ver el efecto.
Expandir
