NovaMonoFix
Errores PHP
X
Usuario
Password
0 FPS

Tutorial WINAPI C++ 1.6 (Creación del ObjetoMarcador)

14 de Abril del 2010 por Josep Antoni Bover, 25 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++ 1.6 (Creación del ObjetoMarcador)

A partir de todo lo que vimos en el capitulo anterior la cosa esta en echarle imaginación. Ahora nos toca hacer un marcador para la calculadora que nos mostrara las operaciones y el resultado. La idea es hacer una parte para ver las operaciones que se están evaluando, y otra parte para mostrar el resultado actual de la operación.

Ademas este objeto sera el encargado de apuntar y resolver las operaciones de la calculadora, por lo que tambien se mostrara como responder a pulsaciones del teclado.

Al querer mostrar las operaciones independientemente del resultado nos va a hacer falta ingeniar un sistema para almacenar dichas operaciones con el mismo orden en que se han introducido.

Archivo : ObjetoMarcador.h
1
2
3
4
5
6
7
8
9
// Enumeracion de los tipos de datos para la calculadora
enum ObjetoMarcador_TipoDatos {
TipoDatos_INDEFINIDO = -1,
TipoDatos_Valor = 0,
TipoDatos_Suma = 1,
TipoDatos_Resta = 2,
TipoDatos_Multiplicacion = 3,
TipoDatos_Division = 4
};

Lo siguiente será crear un objeto que simbolice tanto un valor como una operación, pero ojo solo puede ser o un valor, o una operación. La idea es tener una lista de objetos que se irá ampliando a medida que se añadan valores o operaciones. De esta forma será fácil recrear la operación que se está evaluando en la calculadora.

Archivo : ObjetoMarcador.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
// Contenedor de una porción de datos de la calculadora
class ObjetoMarcador_Datos {
public: /////////////////////////// Miembros publicos
// -Constructor por defecto
ObjetoMarcador_Datos(void) {
_Tipo = TipoDatos_INDEFINIDO;
_Valor = 0.0f;
};
// -Constructor asignador de datos
ObjetoMarcador_Datos(const ObjetoMarcador_TipoDatos nTipo,
const double nValor = 0.0f) {
_Tipo = nTipo;
_Valor = nValor;
};
// -Destructor
~ObjetoMarcador_Datos(void) { };
// -Función que retorna el tipo
inline ObjetoMarcador_TipoDatos Tipo(void) const { return _Tipo; };
// -Función que retorna el valor
inline double Valor(void) const { return _Valor; };
private : ///////////////////////// Miembros privados
// -Valor
double _Valor;
// -Tipo de dato
ObjetoMarcador_TipoDatos _Tipo;
};

Esta clase tiene un constructor para indicarle que tipo de operación es, o en el caso de que sea un valor especificaremos el tipo correctamente y le pasaremos el valor en el segundo parámetro. Por lo demás todos sus miembros serán privados y solo podremos acceder a ellos para lectura.

Ahora que tenemos una implementación para almacenar los datos de la calculadora podemos proceder a crear la clase que va a contener el objeto marcador. Este objeto no requerirá eventos de mouse ni de teclado, aunque necesitaremos re-emplazar el Evento_Pintar , hacer unas funciones Pintar y Repintar, hacer unas funciones para que desde la ventana principal de la calculadora podamos añadir valores y operaciones, definir una lista que contenga todos los valores y operaciones, y hacer una función que calculara las operaciones y mostrara el resultado.

Archivo : ObjetoMarcador.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
// Clase que hereda ObjetoControl y se convierte en el marcador para nuestra calculadora
class ObjetoMarcador : public ObjetoControl {
public : /////////////////////////////// Miembros publicos
// -Constructor
ObjetoMarcador(void);
// -Destructor
~ObjetoMarcador(void);
// -Función para crear el control
HWND CrearMarcador( HWND hWndParent, const int cX, const int cY,
const int cAncho, const int cAlto,
COLORREF nColor_Texto = RGB(255, 255, 255),
COLORREF nColor_DegradadoSuperior = RGB(180, 180, 180),
COLORREF nColor_DegradadoInferior = RGB( 60, 60, 60),
COLORREF nColor_BordeExterno = RGB(128, 128, 128),
COLORREF nColor_BordeInterno = RGB(190, 190, 190) );
/////////////////////////////////////// Funciones de pintado
// -Función que enlaza con el evento WM_PAINT
LRESULT Evento_Pintar(HDC hDC, PAINTSTRUCT &PS);
// -Función que pinta todo el control
void Pintar(HDC hDC);
// -Función que repinta el control si es necesario
void Repintar(void);
/////////////////////////////////////// Funciones para los datos
// -Función que agrega un numero al valor actual
void AgregarNumero(const TCHAR Numero);
// -Función que agrega una coma decimal al valor actual
void AgregarPunto(void);
// -Función que borra el último caracter introducido
void BorrarCaracter(void);
// -Función que valida el valor actual, y agrega una operacion a la lista
void AgregarOperacion(const ObjetoMarcador_TipoDatos nTipo);
// -Función que imprime el resultado y borra la lista
void Resultado(void);
// -Función que borra la lista de operaciones y el valor actual
void CE(void);
/////////////////////////////////////// Aspecto grafico
// -Macro que crea funciones para asignar y obtener el COLORREF _Color_Texto
AGREGAR_COLOR(Color_Texto);
// -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 la función Fuente_Desactivada, y la variable HFONT _Fuente_Operaciones
AGREGAR_FUENTE(Fuente_Operaciones);
// -Macro que crea la función Fuente_Desactivada, y la variable HFONT _Fuente_Resultado
AGREGAR_FUENTE(Fuente_Resultado);
protected : //////////////////////////// Miembros privados
// -Función para quitar ceros que sobren a la izquierda
size_t _FormatearStr(TCHAR *String);
// -Función que borra todos los datos de la lista
void _BorrarLista(void);
// -Vector que contiene los valores y operaciones
std::vector<ObjetoMarcador_Datos *> _Lista;
// -Valor que indica si se ha introducido la coma decimal en el valor actual
bool _Punto;
// -Valor actual en string
TCHAR _ValorActual[256];
// -Tamaño del valor actual en caracteres.
size_t _TamValorActual;
};

Pensad que los valores los introduciremos vía teclado o con los botones, y la única forma de saber cuándo se ha terminado de introducir un valor es cuando se añade una operación.
Por ejemplo pulsamos el botón 1, el botón 2, el botón 3, y el botón +. Hasta que no se ha pulsado el botón + no podemos saber si el valor esta completo, en vez de pulsar el botón + se podría pulsar el botón 4, con lo que el valor en vez de ser 123 seria 1234. Por ello tenemos la función AgregarNumero la cual ira almacenando los números que se pulsen, la función AgregarPunto que agregara una coma decimal, y la función AgregarOperacion que añadirá el valor y la operación a la lista.

En el tutorial anterior creamos y pintamos el control de una forma similar, así que omitiré las clases para colores y fuentes, la función CrearMarcador y las funciones de repintado.

Ahora pasemos a ver el núcleo de las operaciones para la calculadora, empezaremos por la función AgregarNumero :

Archivo : ObjetoMarcador.cpp
1
2
3
4
5
6
7
8
// Función que agrega un numero al valor actual
void ObjetoMarcador::AgregarNumero(const TCHAR Numero) {
if (Numero == TEXT('0') && _TamValorActual == 0) return;
_ValorActual[_TamValorActual] = Numero;
_TamValorActual ++;
_ValorActual[_TamValorActual] = TEXT('\0');
Repintar();
};

Esta función básicamente agrega un numero al string que contiene el valor actual, lo único destacable es que si el numero que se va a agregar es 0 y no hay caracteres en el valor actual, este valor no se añadirá ya que los ceros a la izquierda no nos sirven de nada. Ahora veamos la función AgregarPunto :

Archivo : ObjetoMarcador.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Funcion que agrega una coma decimal al valor acutal
void ObjetoMarcador::AgregarPunto(void) {
if (_Punto == true) {
MessageBeep(-1);
return;
}
// Si no hay nada agregamos un cero
if (_TamValorActual == 0) {
_ValorActual[_TamValorActual] = TEXT('0');
_TamValorActual ++;
}
_ValorActual[_TamValorActual] = TEXT('.');
_TamValorActual ++;
_ValorActual[_TamValorActual] = TEXT('\0');
_Punto = true;
Repintar();
};

En esta función lo primero que hacemos es mirar el valor _Punto, ya que si esta en true quiere decir que ya hay una coma decimal en el valor actual, y por lo tanto no debemos añadir más. En segundo lugar, si no hay ningún carácter añadiremos un cero al valor actual. Y por último se añade un punto al valor, y se asigna _Punto a true. Veamos la función AgregarOperacion :

Archivo : ObjetoMarcador.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Función que agrega una operación
void ObjetoMarcador::AgregarOperacion(const ObjetoMarcador_TipoDatos nTipo) {
// Convertimos el _ValorActual a un numero decimal
double nValor = _wtof(_ValorActual);
// Si el valor es 0 no agregamos nada
if (nValor == 0.0f) return;
// Añadimos el valor a la lista
ObjetoMarcador_Datos *nDatosValor = new ObjetoMarcador_Datos(TipoDatos_Valor, nValor);
_Lista.push_back(nDatosValor);
// Añadimos la operacion a la lista
ObjetoMarcador_Datos *nDatosOperacion = new ObjetoMarcador_Datos(nTipo);
_Lista.push_back(nDatosOperacion);
_ValorActual[0] = TEXT('0');
_ValorActual[1] = TEXT('\0');
_TamValorActual = 0;
_Punto = false;
Repintar();
};

Lo primero es determinar si el valor no es cero para añadirlo a la lista. Si el valor es válido creamos una clase ObjetoMarcador_Datos en la que almacenamos el valor actual, luego creamos otra clase ObjetoMarcador_Datos en la que añadimos la operación que se va a realizar. Por último borramos el contenido de _ValorActual, y asignamos _Punto a false, de forma que podamos empezar a añadir un nuevo valor actual.

Ahora veamos la función BorrarCaracter :

Archivo : ObjetoMarcador.cpp
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
// Función que borra el último caracter
void ObjetoMarcador::BorrarCaracter(void) {
// Hay un caracter en el valor actual
if (_TamValorActual == 1) {
_ValorActual[0] = TEXT('0');
_ValorActual[1] = TEXT('\0');
_TamValorActual = 0;
_Punto = false;
}
// Hay caracteres en el valor actual
else if (_TamValorActual > 1) {
_TamValorActual --;
if (_ValorActual[_TamValorActual] == TEXT('.')) _Punto = false;
_ValorActual[_TamValorActual] = TEXT('\0');
}
else { // Sin caracteres que borrar en el valor actual
size_t TamLista = _Lista.size();
// Miramos si hay mas valores en la lista de valores
if (TamLista > 1) {
_TamValorActual = swprintf_s(_ValorActual, 256, TEXT("%f"), _Lista[TamLista - 2]->Valor());
_TamValorActual = _FormatearStr(_ValorActual);
delete _Lista[TamLista -1];
delete _Lista[TamLista -2];
_Lista.resize(TamLista -2);
_Punto = false;
// Miramos si el nuevo valor tiene una coma decimal
for (size_t n = 0; n < _TamValorActual; n++) {
if (_ValorActual[n] == TEXT('.')) _Punto = true;
}
}
else { // No hay mas valores en la lista, reafirmamos el valor 0
_ValorActual[0] = TEXT('0');
_ValorActual[1] = TEXT('\0');
_TamValorActual = 0;
}
}
Repintar();
};

Lo primero que miramos en esta función es si el tamaño de valor actual es 1, y en ese caso asignamos un cero a valor actual y a su tamaño. En caso de que el valor actual sea mas grande que uno, borramos el ultimo carácter y nos fijamos si era un punto para asignar correctamente el valor _Punto.

Y si llegamos al caso de que valor actual es 0 quiere decir que no tenemos mas caracteres en el valor actual, pero puede que tengamos valores y operaciones en la lista, así que miramos el tamaño de la lista. Si el tamaño de la lista es mas grande que 1 lo que hacemos es asignar el ultimo valor de la lista al valor actual, y eliminar tanto la operación como el ultimo valor de la lista.

Por último nos queda ver la función Resultado :

Archivo : ObjetoMarcador.cpp
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
// Función que calcula el resultado, y reinicia todos los valores.
void ObjetoMarcador::Resultado(void) {
double Op1 = 0.0f;
double Op2 = 0.0f;
double nValor = _wtof(_ValorActual);
size_t i;
if (nValor == 0.0f) return;
// Añadimos el valor a la lista
ObjetoMarcador_Datos *nDatosValor = new ObjetoMarcador_Datos(TipoDatos_Valor, nValor);
_Lista.push_back(nDatosValor);
// Realizamos toda la serie de operaciones
Op1 = _Lista[0]->Valor();
for (i = 1; i < _Lista.size() -1; i += 2) {
Op2 = _Lista[i + 1]->Valor();
switch (_Lista[i]->Tipo()) {
case TipoDatos_Suma : Op1 = Op1 + Op2; break;
case TipoDatos_Resta : Op1 = Op1 - Op2; break;
case TipoDatos_Multiplicacion : Op1 = Op1 * Op2; break;
case TipoDatos_Division : Op1 = Op1 / Op2; break;
}
}
// Formateamos el resultado y lo introducimos en _ValorActual
swprintf_s(_ValorActual, 256, TEXT("%f"), Op1);
_TamValorActual = _FormatearStr(_ValorActual);
_Punto = false;
for (i = 0; i < _TamValorActual; i++) {
if (_ValorActual[i] == TEXT('.')) _Punto = true;
}
Repintar();
_BorrarLista();
}

Para mostrar correctamente toda la operación lo primero que hacemos es añadir el valor actual a la lista, luego hacemos un bucle que revisa todos los valores a partir de la segunda posición de la lista. La lista contiene los datos de la siguiente forma : VALOR, OPERACION, VALOR, OPERACION, VALOR, etc.. asi que si partimos del primer valor, sabemos que luego siempre vendrá una operación y un segundo valor. Por último formateamos correctamente el resultado, miramos si contiene una coma decimal para asignar el valor _Punto, repintamos el control, y borramos la lista de operaciones para comenzar una nueva lista.

Llegados a este punto ya hemos visto lo más importante a la hora de crear nuestro marcador. Si deseáis ver el marcador funcionando podéis descargar los ejemplos de este tutorial y echar un vistazo al ejemplo numero 6 :

La siguiente y última parte del tutorial será el punto y final para la calculadora, y consistirá en enlazar todo lo hecho anteriormente para ensamblar la aplicación : 1.7 - Terminando la calculadora

Descargar tutorial WinAPI completo Calculadora compilada