Aprenda a criar uma classe STATIC para função de alarme com o autor de Jiang Chuan, Qi Gao
Introdução O controle de alarme é frequentemente visto em vários sistemas de controle industrial. Existem muitos métodos de alarme, que podem ser marcados por texto ou representados por gráficos. O princípio nada mais é do que construir um objeto de classe CDC e depois usar os vários básicos fornecidos. gráficos usando os atributos primitivos. Aqui faremos um programa que pode exibir o texto do alarme. Quando ocorre um alarme, podemos piscar o fundo para realizar a função.
Geralmente usamos métodos derivados para implementar esse tipo de processamento no texto.
Primeiro use o assistente VC para criar um projeto baseado em diálogo.
Em seguida, colocamos um controle STATIC na interface da caixa de diálogo e definimos a posição.
Os preparativos básicos para derivar uma classe baseada em CStatic chamada CStaticRectangle para nosso controle STATIC estão concluídos. Nossa próxima tarefa é adicionar conteúdo à nova classe derivada para obter o efeito de tela de alarme desejado.
De acordo com o que disse em meu último artigo, usando o método de buffer duplo, precisamos adicionar os três arquivos MemDC.h, AutoFont.h e AutoFont.cpp ao projeto. A classe AutoFont é um melhor encapsulamento da classe CFont. na Internet hoje. Os usuários não precisam considerar funções de API de criação complexas ao criar objetos CFont. Eles só precisam fazer algumas configurações simples de parâmetros para completar a função, então usamos esta classe aqui para implementar o controle de fonte do texto de alarme.
Definir objeto
//A definição da cor pode ser aumentada ou diminuída de acordo com a situação real.
#define COLOR_RED RGB(255,0,0)
#define COLOR_GREEN RGB(0,255,0)
protegido:
CBitmap *m_pBitmapOldBackground;//Esses três são usados para desenho de buffer duplo
CBitmap m_bitmapBackground;
CDC m_dcBackground;
CRect m_rectCtrl; //área de controle
curto nMillSec;
CAutoFont *m_pFnt; //Constrói a fonte do texto do alarme
público:
COLORREF m_BkColor; //Cor de fundo
COLORREF m_TextColor; //Cor do texto
CString strText; //Texto do alarme exibido
BOOL bGleam;//Se pisca
Inicialize variáveis no construtor:
CStaticRectangle::CStaticRectangle()
{
m_BkColor = COLOR_RED;
m_TextColor = RGB(255,128,64);
nMillSeg = 10;
bGleam = FALSO;
m_pFnt = novo CAutoFont("script oficial");
m_pFnt->SetHeight(28);
m_pFnt->SetWidth(12);
m_pFnt->SetBold(TRUE);
}
A memória é liberada no destruidor
CStaticRectangle::~CStaticRectangle()
{
se(m_pFnt)
excluir m_pFnt;
}
Para desenhar a função de alarme STATIC, precisamos apenas mapear a mensagem WM_PAINT e, em seguida, redesenhar a interface e exibir o texto.
void CStaticRectangle::OnPaint()
{
CPaintDC dc(this); // contexto do dispositivo para pintura
// TODO: Adicione seu código de manipulador de mensagens aqui
// Obtém a área de controle
GetClientRect (&m_rectCtrl);
CMemDC memDC(&dc, &m_rectCtrl);
if(m_dcBackground.GetSafeHdc()== NULO|| (m_bitmapBackground.m_hObject == NULO))
{
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ão chama CStatic::OnPaint() para pintar mensagens
}
A seguir, controlamos a exibição de informações relevantes. O que precisamos prestar atenção aqui é a exibição do nosso texto. Aqui precisamos calcular a posição da exibição do texto.
Podemos obter o CSize do texto por meio de pDC->GetTextExtent(); e então usar o retângulo do controle para obter a posição de exibição do texto.
O método usado aqui é exibi-lo no centro.
void CStaticRectangle::DrawRectangleBackground(CDC *pDC, CRect &rect)
{
CBrush brushFill, *pBrushOld;
int nXTamanho,nYTamanho;
CSize szText;
CFont *fOldFont;
nXSize = rect.Largura();
nYTamanho = rect.Altura();
pincelFill.DeleteObject();
brushFill.CreateSolidBrush(m_BkColor);
pBrushOld = pDC->SelectObject(&brushFill);
pDC->Retângulo(reto);
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->SelectObject(&fOldFont);
pincelFill.DeleteObject();
}
Se quisermos implementar a função de alarme, precisamos usar a função de temporizador para alterar a cor de fundo regularmente e depois atualizar a tela.
Neste ponto, o trabalho básico foi concluído. A próxima coisa a fazer é fornecer uma interface que os usuários possam modificar dinamicamente.
void CStaticRectangle::SetRectangleText(CStringstrVal)
{
isto->strText = strVal;
}
void CStaticRectangle::SetBackColor(UINT nStyle)//Define a cor de fundo
{
isto->m_BkColor = nStyle;
}
void CStaticRectangle::SetBkGleam(BOOL bShow)
{
if(isto->bGleam)
{
if(!bMostrar)
KillTimer(nMillSec);
}
outro
{
if(bMostrar)
SetTimer(nMillSec,750,NULL);
}
isto->bGleam = bShow;
}
Bem, agora que nossa classe funcional foi concluída, a próxima coisa a fazer é conectá-la ao CSTATIC na interface.
Crie uma variável associada ao controle STATIC (tipo de controle) por meio de CLASSWIZARD, modifique o tipo derivado para nosso CStaticRectangle e defina o efeito intermitente, e podemos ver o efeito.
Expandir
