NovaMonoFix
Errores PHP
X
Usuario
Password
0 FPS

Tutorial WinAPI C++ 3.1 Creación del ObjetoBarraProgreso

06 de Noviembre del 2010 por Josep Antoni Bover, 22 visitas, 0 comentarios, 0 votos
Categorías : Windows, Programación, C y C++.
La web está en segundo plano, animación en pausa.
Cargando animación...
Tutorial WinAPI C++ 3.1 Creación del ObjetoBarraProgreso

En este tutorial nos vamos a hacer nuestra barra de progreso desde cero, que se usara en el instalador final para mostrar el progreso de instalación.

Al ser un control 'visual' que no requiere interaccion por parte del usuario, sera bastante facil de programar. Lo unico que tenemos que tener claro es que la barra puede ser vertical o horizontal, y esto se decidira por su forma inicial al crearla. Por ejemplo si creamos una barra de 200 pixeles de ancho por 10 de alto, esta barra sera horizontal.

En primer lugar creamos la clase ObjetoBarraProgreso que heredara de ObjetoControl, y definimos sus miembros. Vamos a necesitar varios miembros para asignar/obtener el mínimo, el valor y el máximo de la barra, además de los colores para el control :

Archivo : ObjetoBarraProgreso.h
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
// Clase que hereda ObjetoControl y se centra en las funciones
// de la clase ObjetoBarraProgreso
class ObjetoBarraProgreso : public ObjetoControl {
public : //////// Miembros publicos
// -Constructor
ObjetoBarraProgreso(void);
// -Destructor
~ObjetoBarraProgreso(void);
// -Función para crear la progressbar
HWND CrearBarraProgreso( HWND hWndParent, const UINT nID,
// Posición y tamaño
const int cX, const int cY,
const int cAncho, const int cAlto,
// Valores y colores por defecto
const float nMin = 0.0f, const float nMax = 100.0f,
const float nValor = 0.0f,
COLORREF ColorDegradadoSuperior= RGB(200, 200, 200),
COLORREF ColorDegradadoInferior= RGB(100, 100, 100),
COLORREF ColorBordeExterno = RGB(128, 128, 128),
COLORREF ColorBordeInterno = RGB(192, 192, 192),
COLORREF ColorFondo = RGB(220, 220, 220)
/* FIN declaración CrearBarraProgreso */ );
// -Función para asignar el minimo de la progressbar
void Minimo(const float nMinimo, const bool nRepintar = false);
// -Función para obtener el minimo de la progressbar
inline float Minimo(void) const { return _Minimo; };
// -Función para asignar el maximo de la progressbar
void Maximo(const float nMaximo, const bool nRepintar = false);
// -Función para obtener el maximo de la progressbar
inline float Maximo(void) const { return _Maximo; };
// -Función para asignar el valor de la progressbar
void Valor(const float nValor, const bool nRepintar = true);
// -Función para obtener el valor de la progressbar
// (ojo que devuelve UINT)
inline float Valor(void) const { return _Valor; };
// -Función que repinta el control
void Repintar(void);
// -Función que pinta el control
LRESULT Evento_Pintar(HDC hDC, PAINTSTRUCT &PS);
//////////////// Colores
// -Macro que crea funciones para asignar y obtener
// el COLORREF _Color_DegradadoSuperior
AGREGAR_COLOR(Color_DegradadoSuperior);
// -Macro que crea funciones para asignar y obtener
// el COLORREF _Color_DegradadoInferior
AGREGAR_COLOR(Color_DegradadoInferior);
// -Macro que crea funciones para asignar y obtener
// el COLORREF _Color_BordeExterno
AGREGAR_COLOR(Color_BordeExterno);
// -Macro que crea funciones para asignar y obtener
// el COLORREF _Color_BordeInterno
AGREGAR_COLOR(Color_BordeInterno);
// -Macro que crea funciones para asignar y obtener
// el COLORREF _Color_Fondo
AGREGAR_COLOR(Color_Fondo);
protected : ///// Miembros protegidos
float _Minimo;
float _Maximo;
float _Valor;
};

Podríamos haber hecho que mínimo siempre fuera 0 y máximo siempre fuera 100, pero me parece interesante poder asignar esos valores y que la barra calcule el porcentaje, ya que nos ahorrara código para calcular el porcentaje en la aplicación final. Pensad por ejemplo que tenemos 433 archivos y queremos mostrar el porcentaje completado, si la barra tuviera mínimo 0 y máximo 100, la aplicación sería la encargada de calcular el porcentaje, en cambio al hacer que el mínimo y el máximo sean variables de forma que el ObjetoBarraProgreso tenga que calcularlos internamente, nos ahorramos tener que escribir un código para calcular el porcentaje en la aplicación.

El ObjetoBarraProgreso es un control que no requiere acciones del usuario por lo que será bastante fácil de programar, ya que no necesitamos responder a la mayoría de eventos. El único evento que necesitaremos re-escribir es el Evento_Pintar :

Archivo : ObjetoBarraProgreso.h
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
LRESULT ObjetoBarraProgreso::Evento_Pintar(HDC hDC, PAINTSTRUCT &PS) {
RECT RC;
GetClientRect(_hWnd, &RC);
// 1 - Creación de un buffer para el pintado
HDC Buffer = CreateCompatibleDC(hDC);
HBITMAP Bmp = CreateCompatibleBitmap(hDC, RC.right, RC.bottom);
HBITMAP Viejo = static_cast<HBITMAP>(SelectObject(Buffer, Bmp));
HRGN Region = CreateRoundRectRgn(0, 0, RC.right, RC.bottom, REDONDEAMIENTO, REDONDEAMIENTO);
HFONT VFuente = NULL;
RECT Degradado = { RC.left + 2, RC.top +2, RC.right -4, RC.bottom -4 };
float Parte = 0.0f;
bool EsVertical = (RC.right < RC.bottom);
// 2 -Calculamos los pixeles necesarios por cada parte
float TotalValores = 0.0f;
if (EsVertical == true) {
// (RC.bottom - 4) = Alto utilizable en pixeles del control
// (_Maximo - _Minimo) = Total de valores a recorrer
// (Alto / Total varlores) = Parte por valor
float AltoU = static_cast<float>(RC.bottom - 4);
TotalValores = (_Maximo - _Minimo);
if (TotalValores > AltoU) Parte = TotalValores / AltoU;
else Parte = AltoU / TotalValores;
Degradado.top = Degradado.bottom - static_cast<int>(Parte * (_Valor - _Minimo));
}
else {
// (RC.right - 4) = Ancho utilizable en pixeles del control
// (_Maximo - _Minimo) = Total de valores a recorrer
// (Ancho / Total varlores) = Parte por valor
float AnchoU = static_cast<float>(RC.right - 4);
TotalValores = (_Maximo - _Minimo);
if (TotalValores > AnchoU) Parte = TotalValores / AnchoU;
else Parte = AnchoU / TotalValores;
Degradado.right = static_cast<int>(Parte * (_Valor - _Minimo));
}
// 3 - Pintamos el fondo
HBRUSH Brocha = CreateSolidBrush(_Color_Fondo);
FillRect(Buffer, &RC, Brocha);
DeleteObject(Brocha);
// 4 - Pintamos la barra de progreso con un degradado
TRIVERTEX GCVertex[2];
GRADIENT_RECT tGRect;
GCVertex[0].Red = RGB_OBTENER_R(_Color_DegradadoSuperior);
GCVertex[0].Green = RGB_OBTENER_G(_Color_DegradadoSuperior);
GCVertex[0].Blue = RGB_OBTENER_B(_Color_DegradadoSuperior);
GCVertex[0].x = Degradado.left;
GCVertex[0].y = Degradado.top;
GCVertex[1].Red = RGB_OBTENER_R(_Color_DegradadoInferior);
GCVertex[1].Green = RGB_OBTENER_G(_Color_DegradadoInferior);
GCVertex[1].Blue = RGB_OBTENER_B(_Color_DegradadoInferior);
GCVertex[1].x = Degradado.right + 2;
GCVertex[1].y = Degradado.bottom + 2;
tGRect.UpperLeft = 0;
tGRect.LowerRight = 1;
GradientFill(Buffer, GCVertex, 2, &tGRect, 1, (EsVertical) ? GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V);
// 5 - Pintamos el borde
Brocha = CreateSolidBrush(_Color_BordeInterno);
FrameRgn(Buffer, Region, Brocha, 2, 2);
DeleteObject(Brocha);
Brocha = CreateSolidBrush(_Color_BordeExterno);
FrameRgn(Buffer, Region, Brocha, 1, 1);
DeleteObject(Brocha);
// 6 - Pintamos el Buffer en el DC de la barra de progreso
BitBlt(hDC, 0, 0, RC.right, RC.bottom, Buffer, 0, 0, SRCCOPY);
// 7 - Selecciono los objetos originales del Buffer y elimino objetos gdi de la memoria
SelectObject(Buffer, VFuente);
SelectObject(Buffer, Viejo);
DeleteObject(Region);
DeleteObject(Bmp);
DeleteDC(Buffer);
return 0;
}

Veamos la función en 7 pasos :

Con esto ya tenemos un control al que le podemos especificar mínimo, máximo y valor para que nos pinte una barra.

Aunque no viene a cuento para el instalador, pensad que podríamos crear un ObjetoBarraDesplazamiento que herede de este control, y incluya eventos del mouse para que el usuario pudiera posicionar la barra manualmente.

Llegados a este punto ya podemos pasar al siguiente tutorial 3.2 Common Dialogs.