Programación en Windows y MFCs

Programación en Windows
y MFCs
Tema 6
Grupo 46
TACC II
Curso 2008/09
1

Indice
Programación bajo Windows.
Introducción
Introducción.
Hola mundo!.
El API de Windows.
Introducción a las MFCs MFCs.
Arquitectura Documento/Vista.
Aspectos avanzados de las MFCs.
Bibliografía. g
2

Programación Bajo Windows
Proramación orientada a eventos eventos, en contraste con la programación
para MS-DOS, que es secuencial.
Evento: Algo que sucede en el sistema (click de ratón ratón, movimiento
de ratón, pulsación de una tecla, etc.)
Windows convierte estos eventos en mensajes (añaden información
a los eventos). P.ej.: cuando se hace click con el ratón, el mensaje
incluye las coordenadas, la ventana sobre la que se pulsó, etc.
Windows pasa el mensaje a la parte interesada (ej. la ventana sobre
la que se hizo click).
La aplicación puede obviar el mensaje, o puede tener código que la
haga reaccionar.
3

Programación Bajo Windows
Estructura genérica de una aplicación windows:
1. Iniciar la aplicación. p
Iniciar la aplicación y la instancia.
En las versiones de 32 bits se inicializa la aplicación cada vez que
se inicializa la instancia.
En las versiones de 16 bits sólo con la 1ª instancia (compartir
información, ahorro memoria).
Todas las aplicaciones tienen una o más ventanas (hay
excepciones excepciones, como los controladores de dispositivo)
dispositivo).
Clases (tipos) de ventanas definidas mediante parámetros. Registro
de la clase de ventana. Esto se hace al inicializar la aplicación.
Al inicializar la instancia, se crea una ventana de la clase definida.
HHay que ddar el l nombre b dde lla ventana, t sus coordenadas, d d
dimensiones, menú, etc.
2. Esperar que llegue algún mensaje.
33. Reaccionar ante el mensaje recibido recibido.
4. Volver a 2.
4

Programación Bajo Windows
Estructura genérica de una aplicación windows:
1. Iniciar la aplicación.
2. Esperar que llegue algún mensaje.
Bucle de captura de mensajes.
Filtrar los mensajes que van a la aplicación, adaptarlos y
hhacerlos l ll llegar a lla ventana t correspondiente. di t
Procedimiento de ventana, recibe mensaje y adopta uno u
otro comportamiento.
3. Reaccionar ante el mensaje recibido.
4. Volver a 2.
5

#include "stdafx.h"
#include
// Crear un proyecto win32 application vacío (o “Hello World” en VC 6.0)
LRESULT CALLBACK GGestorMensajes( M j (
{
HANDLE hW hWnd, d
UINT mensaje,
WPARAM wParam,
LPARAM lParam)
HDC hDc; // Device context
PAINTSTRUCT ps; // Estructura de dibujado
RECT rect; // Rectángulo cliente
switch (mensaje)
{
case WM_PAINT:
hD hDc = BBeginPaint((HWND)hWnd, i P i t((HWND)hW d &ps); & )
Hola Mundo!
GetClientRect((HWND)hWnd,&rect);
DrawText(hDc, TEXT("¡Hola Mundo!“), -1, &rect, DT_SINGLELINE|DT_CENTER|DT_VCENTER);
EndPaint((HWND)hWnd, &ps);
bbreak; k
case WM_DESTROY:
PostQuitMessage(0);
break;
ddefault: f lt return t DefWindowProc((HWND)hWnd,mensaje,wParam,lParam);
D fWi d P ((HWND)hW d j P lP )
}
return (NULL);
}
6

BOOL IniciaAplicacion (HINSTANCE hInstance)
{
WNDCLASS C SS wc;
}
Hola Mundo!
wc.style = CS_HREDRAW | CS_VREDRAW; //Estilo de la clase
wc wc.lpfnWndProc lpfnWndProc = (WNDPROC)GestorMensajes; // Procedimiento gestor
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance hI t = hInstance; hI t // Instancia I t i
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); // Icono de la ventana
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // cursor de la ventana
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE (HBRUSH)GetStockObject(WHITE_BRUSH); BRUSH); // Color de fondo
wc.lpszMenuName = NULL; // Nombre del menú asociado
wc.lpszClassName = TEXT("ClaseVentana“); // Nombre de la clase de la ventana
return (RegisterClass(&wc));
7

BOOL IniciaInstancia(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
Hola Mundo!
hWnd = CreateWindow(
TEXT("ClaseVentana“), // Clase de ventana a la que pertenece (caract. UNICODE)
TEXT("TACC II, grupo 46, curso 2008/09“),// Título de la ventana
WS_OVERLAPPEDWINDOW|WS_HSCROLL|WS_VSCROLL, _ | _ | _
// Estilo
CW_USEDEFAULT, // Posicion X por defecto
CW_USEDEFAULT, // Posicion Y por defecto
CW_USEDEFAULT, // Anchura por defecto
CW_USEDEFAULT, // Altura por defecto
NULL, // Sin ventana padre
NULL, // Sin menu
hInstance, // Instancia
NULL);
if (!hWnd) return FALSE;
// Parametros
ShowWindow(hWnd, nCmdShow); // dice cómo mostrar la ventana
UpdateWindow(hWnd);
return TRUE;
// actualiza la ventana: genera un evento WM_PAINT
}
8

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MSG Mensaje;
BOOL bret;
}
if (!hPrevInstance){
if (!IniciaAplicacion(hInstance)) return FALSE;
}
if (!IniciaInstancia(hInstance, nCmdShow)) return FALSE;
Hola Mundo!
while ((bret = GetMessage(&Mensaje, NULL, NULL, NULL)) != 0)
{
TranslateMessage(&Mensaje); // traduce de teclas convencionales a WM_CHAR
DispatchMessage(&Mensaje); // hace llegar el mensaje al proc. de ventana
}
return (Mensaje.wParam);
9

La clase de Ventana
typedef struct {
UINT style; // combinación de estilos de clase
WNDPROC lpfnWndProc; // Puntero al procedimiento de ventana
int cbClsExtra; // num. bytes extra a asignar seguidos a esta estructura
int cbWndExtra; // num. bytes extra a asignar seguidos a la instancia
HINSTANCE hInstance; // handle a la instancia que contiene el proc. ventana
HICON hIcon; // handle al icono de la clase (si NULL se da uno por def).
HCURSOR hCursor; // handle al cursor de la clase
HBRUSH hbrBackground; // handle a brocha para color de fondo, o un color
LPCTSTR lpszMenuName; // nombre del menú asociado
LPCTSTR lpszClassName; // nombre de la clase de ventana
} WNDCLASS, *PWNDCLASS;
Tipos de clases de ventana: del sistema (ej.: BUTTON, COMBOBOX,
etc etc.), ) globales y locales de aplicación aplicación.
Algunos estilos: CS_HREDRAW, CS_VREDRAW (redibuja la venta
entera si hay un cambio de tamaño horizontal), CS_NOCLOSE,.
La estructura WNDCLASSEX permite asociar un icono pequeño a la
ventana (RegisterClassEx).
10

Inicialización de la Instancia
HWND CreateWindow(
LPCTSTR lpClassName, // nombre registrado clase de ventana
LPCTSTR lpWindowName, // título de la ventana
DWORD dwStyle, // estilo de la ventana
iint t x, // posición i ió hhorizontal i t l dde lla ventana t
int y, // posición vertical de la ventana
int nWidth, // anchura de ventana
int nHeight nHeight, // altura de ventana
HWND hWndParent, // handle de la ventana padre
HMENU hMenu, // handle del menú de ventana
HINSTANCE hInstance hInstance, // handle a la instancia de la aplicación
LPVOID lpParam ); // puntero a parámetros.
CCreación ió dde una ventana t dde una clase l registrada. i t d
CreateWindowEx para estilos extendidos (ej.: layered
windows-> windows ventanas no rectangulares o que cambian de
forma)
11

Estilos de Ventana
WS_BORDER: ventana con borde fino.
WS_CAPTION: ventana con barra de título (incluye WS_BORDER).
WS WS_CHILD, CHILD WS WS_CHILDWINDOW CHILDWINDOW : ventana t hij hija ( (no puede d ttener menú ú ni i puede d usarse con
WS_POPUP).
WS_CLIPCHILDREN: Excluye el área ocupada por las ventanas hijas cuando se dibuja e la padre.
Se usa cuando se crea la ventana padre.
WS WS_CLIPSIBLINGS:
CLIPSIBLINGS:
WS_DISABLED: crea una ventana deshabilitada.
WS_DLGFRAME: ventana con borde igual al de las cajas de diálogo.
WS_GROUP: Primer control de un grupo.
WS_HSCROLL: ventana con scrooll horizonta.
WS_ICONIC, WS_MINIMIZE: ventana inicialmente minimizada.
WS_MAXIMIZE: ventana inicialmente maximizada.
WS_MAXIMIZEBOX, _ , WS_MINIMIZEBOX _
: ventana con botón de maximizar/minimizar.
WS_OVERLAPPED, WS_TILED; ventana con título y borde.
WS_OVERLAPPEDWINDOW, WS_TILEDWINDOW: ventana con estilos: WS_OVERLAPPED,
WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX, y
WS_MAXIMIZEBOX
WS_POPUP: ventana de pop-up.
WS_POPUPWINDOW : ventana de pop-up con WS_BORDER, WS_POPUP, y WS_SYSMENU
WS_SIZEBOX, WS_THICKFRAME: ventana con borde redimensionable.
WSS_S SYSMENU: S U ventana e ta a co con menú e ú de sste sistema. a
WS_TABSTOP: control que recibe el foco cuando se pulsa TAB.
WS_VISIBLE: ventana inicialmente visible.
12
WS_VSCROLL: ventana con barra de desplazamiento vertical.

Estilos de Ventana
Menú de sistema Barra de título Botones minimizar/
maximizar/cerrar
Area cliente
Scroll horizontal Scroll vertical
borde
13

Mensajes
MMensajes: j
typedef struct
{
HWND hwnd; // handle a la ventana que recibe el mensaje
UINT message; // identificador del mensaje
WPARAM wParam; // info adicional, dependiente del tipo de mensaje
LPARAM lParam; // info adicional, dependiente del tipo de mensaje
DWORD time; ; // instante en el que q el mensaje j fue enviado
POINT pt; // posición del cursor en coordenadas de pantalla
} MSG, *PMSG;
Todos los mensajes que envía windows empiezan
por WM WM_XXX XXX y están definidos en windows windows.h
h
14

GetMessage
GetMessage: Espera a que llegue un mensaje mensaje.
BOOL GetMessage( LPMSG lpMsg, HWND hWnd,
UINT wMsgFilterMin, UINT wMsgFilterMax );
lpMsg: Puntero a la estructura MSG que recibe el mensaje
hWnd: Handle de la ventana que recibe los mensajes.
wMsgFilterMin: Menor valor entero del mensaje a recibir (ej.:
WM_KEYFIRST, WM_MOUSEFIRST o WM_INPUT)
wMsgFilterMax: Mayor valor entero del mensaje a recibir (ej.:
WM_KEYFIRST, WM_MOUSEFIRST o WM_INPUT)
Retorno:
Si se devuelve un mensaje distinto de WM_QUIT, el valor es distinto de cero.
Si el mensaje es WM_QUIT, el valor es cero.
Si hay un error el valor es -1. Por ejemplo, esto sucede si hWnd es un handle
de ventana inválida o lpWnd es un puntero inválido inválido.
15

DispatchMessage
MSG
…
hwnd=h
…
hinstance=h
lpClassName = CN
WNDCLASS
…
lpszClassName = CN
…
lpfnWndProc=proc
DispatchMessage
…
hinstance=h1
lpClassName = CN
…
hinstance=h2
lpClassName = CN2
…
lpszClassName = CN2
…
lpfnWndProc=proc2
instancias de ventana
…
hinstance=h3
lpClassName=CN3
…
lpszClassName = CN3
…
lpfnWndProc=proc3
lpfnWndProc proc lpfnWndProc proc2 lpfnWndProc proc3
clases de ventana registradas
LRESULT CALLBACK proc (HANDLE LRESULT CALLBACK proc2 LRESULT CALLBACK proc3
hWnd, UINT mensaje, WPARAM (HANDLE hWnd, UINT (HANDLE hWnd, UINT
wParam, LPARAM lParam){..}
mensaje, WPARAM wParam, mensaje, WPARAM wParam, 16
LPARAM lParam){..}
LPARAM lParam){..}

Handles
Un identificador para los distintos objetos: ventanas ventanas,
controles (que son ventanas), ficheros, imágenes,
memoria, etc.
Similar a punteros: se obtienen y luego se destruyen.
17

Gestionar un nuevo evento
LRESULT CALLBACK GestorMensajes( HANDLE hWnd, hWnd
UINT mensaje,
WPARAM wParam,
LPARAM lParam)
{
HDC hDc; // Device context
//…
switch (mensaje)
{
case WM_LBUTTONDOWN:
MessageBox((HWND)hWnd, TEXT("Button click"), TEXT("dialogo"), MB_ICONHAND);
break;
default: return DefWindowProc((HWND)hWnd,mensaje,wParam,lParam);
}
return (NULL);
}
18

Juegos de Caracteres
~1890: 1890 BCDIC (6 bit bits->64 64 caracteres). t )
~1950: ASCII (7 ( bits->128 caracteres). )
ASCII extendido (8 bits->256 caracteres).
páginas páginas de códigos regionales para los últimos
128.
DBCS: DBCS: los primeros 128 bytes igual que
ASCII, los posteriores ocupan dos bytes.
U Unicode: i d 16 bit bits (65536 caracteres). t )
Sistema de doble anchura (wide char).
19

Caracteres Unicode
Tipo de datos wchar_t.
Ej.: j wchar_t _ nombre[50]=L”Bjarne [ ] j Stroustrup”. p
Mejor usar macros, que aseguran que el
programa funciona en Unicode o ASCII:
TCHAR * Nombre = TEXT(“Hola”);
20

La Notación Húngara
Convención para los nombres de variables (uso de prefijos), de tal
manera que al leerlos sepamos su tipo.
Después del prefijo se empieza por mayúsculas.
Ejemplo:
hWnd es un handle (h) a una ventana.
lpfnWndProc es un puntero (p) largo (l) a una función (fn).
Tipo de Dato Prefijo
char c
BYTE(unsigned char) by
short n
int i
int cuando indica coordenadas x, y
int cuando indica dimensiones cx, cyy
WORD (unsigned int) w
LONG (long) l
Tipo de Dato Prefijo
DWORD(unsigned long) dw
BOOL(int) o Flag b ó f
Handle h
Puntero p
Función fn
Cadena s
Cadena terminada en ‘\0’ sz

El API de Windows
Llamadas al sistema operativo operativo, almacenadas en DLLs DLLs.
Win32, WinSock, WinInet, ODBC, etc.
Dentro de Win32 se engloban como extensiones el resto de las API
que se puedan añadir a Windows.
Win32 proprociona un entorno de programación común a la
plataforma Windows: 3.1 (win32s), 95/98, NT4.0, 2000, CE, XP,
Vista Vista.
En algunas plataformas el win32 (p. ej. CE) no está implementada
en su totalidad totalidad.
Win32: CreateWindow(), RegisterClass(), ShowWindow(),
UpdateWindow() UpdateWindow(), DrawText() DrawText(), etc etc.
22

Win32
Varias categorías de funciones:
Administración de ventanas (en user32.dll)
Crear y administrar la GUI, despachar mensajes, administrar
ventanas ventanas, DDE. DDE
Ej.: CreateWindow(), RegisterClass(), ShowWindow()
Graphics Device Interface (GDI).
GGenerar salidas lid en di distintos ti t di dispositivos: iti pantalla, t ll iimpresora. PP.ej.: j
dibujar objetos.
Ej.: BeginPaint(), GetClientRect(), DrawText(), EndPaint().
MMedia di Control C t l Interface I t f (MCI) (MCI).
Reproducir y Grabar Audio, uso de vídeo, control de dispositivos
multimedia.
SServicios i i ddel l Si Sistema. t
Administración de memoria, archivos y procesos, funciones de trabajo
en red, información del sistema, IPC.
Remote Procedure Call (RPC).
23

Bibliotecas de Extensión
Proporcionan P i servicios i i a llas apliciones li i
fuera del ámbito del Win32.
Controles comunes.
Cuadros de diálogo comunes.
Descompresión de datos.
Administración de intercambio dinámico de
datos (DDE).
Instalación de archivos.
Intercambio dinámico de datos sobre redes.
...
24

Indice
Programación bajo Windows.
Introducción a las MFCs MFCs.
Introducción.
Ventana Ventana vacía sin el wizard wizard.
Uso del wizard.
Un Un vistazo a las clases de MFC MFC.
Mapas de Mensajes.
Menús Menús y Teclas Aceleradoras
Aceleradoras.
Diálogos Comunes.
Controles.
Controles.
Clases de utilidad
Arquitectura Documento/Vista.
Aspectos avanzados de las MFCs.
Bibliografía.
25

Microsoft Foundation Classes
El API para lla programación ió di directa dde aplicaciones li i Wi Windows d dda
acceso total a la funcionalidad del sistema operativo, pero es de
bajo nivel.
MFC es un framework que ofrece una serie de funciones,
constantes constantes, tipos de datos y clases que simplifica la creación de
aplicaciones para las distintas plataformas Windows.
Es la respuesta de Microsoft a frameworks de otras compañias
como OWL de Borland.
Visual C++ contiene un asistente (wizard) que facilita la creación de
aplicaciones MFC (generación de código).
26

Clases Básicas para la creación de ventanas
27

Secuencia de Creación de una Aplicación
28

Creación de una
Ventana en Blanco sin
el l wizard i d
#include "stdafx.h"
#i #include l d < f i h> // MFC core and d standard t d d components t Creación de una
#include // MFC extensions
// proyecto con Shared DLL
#ifdef _DEBUG
#define new DEBUG DEBUG_NEW NEW
#endif
class CMainFrame : public CFrameWnd {
public: p
CMainFrame() { Create(NULL, _T("Hellow World Application")); } // suele ir en OnCreate()
}; // se suele llamar a LoadFrame
class HelloWorldApp : public CWinApp {
public:
virtual i t l BOOL IInitInstance(); itI t ()
};
HelloWorldApp theApp; // Declarar un unico objecto CWinApp
BOOL HelloWorldApp::InitInstance()
{
CWinApp::InitInstance();
SetRegistryKey(_T("Hello g y y(_ ( World Application"));
pp ))
CMainFrame* pFrame = new CMainFrame;
if (!pFrame) return FALSE;
m_pMainWnd = pFrame;
pFrame->ShowWindow(SW_SHOW);
pFrame->UpdateWindow();
F U d t Wi d ()
return TRUE;
}
//NOTA: El WinMain está dentro del framework MFCs
29

Uso del Asistente
Configuración Inicial de la Aplicación
File/new Project; seleccionar MFC Application
30

Uso del Asistente
Configuración Inicial de la Aplicación
Configurar el tipo de
aplicación:
•Single document
•Sin soporte de
arquitectura
Documento/Vista
Documento/Vista.
•MFC en librería estática
(incluye en el exe las
DLLs necesarias)
31

Uso del Asistente
Configuración Inicial de la Aplicación
Configurar el soporte para BBDD
32

Uso del Asistente
Configuración Inicial de la Aplicación
Configurar la interfaz de usuario
33

Uso del Asistente
Configuración Inicial de la Aplicación
Configurar nombre de las clases y de los ficheros que se van a generar
34

Uso del Asistente
Aplicación Generada
35

Uso del Asistente
¿Qué ficheros se han generado?
• DDefinición fi i ió dde nombres b dde llos
recursos, para
poder ser usados por la aplicación.
Fichero de recursos (.rc ( y .rc2). )
Clase de la ventana de trabajo (hereda de CWnd),
dentro de la ventana marco
Clase Aplicación (hereda de CWinApp)
Clase de la ventana marco (hereda de CFrameWnd)
• Cabeceras precompiladas. “stdafx.h” incluye las
cabeceras comunes del sistema sistema. Se ha de incluir
antes que cualquier otra
36

Uso del Asistente
Recursos de la Aplicación
Resource.h
#define IDD_ABOUTBOX 100
#define IDP_OLE_INIT_FAILED 100
#define IDR_MAINFRAME IDR MAINFRAME 128
#define IDR_HelloMFCsTYPE 129
37

Uso del Asistente
Estructura de la Aplicación
Wi WinMain(): M i ()
Dentro del framework.
Se llama a métodos miembros del único objeto de tipo CWinApp:
InitApplication(): Normalmente no hay que tocar este método.
InitInstance(): Tareas generales de la aplicación, ej: inicializar OLE.
Después se crean las ventanas de la aplicación, y se hacen visibles
(ShowWindow())
Run(): Que implementa al bucle de mensajes hasta que llega WM_QUIT.
CWinApp:
Clase que hay que subclasificar, se debe crear un objeto único global.
Procesa mensajes hasta que llega WM_QUIT, momento en el que
ejecuta ExitInstance() por defecto defecto.
Si no hay mensajes, llama a onIdle(), vacía por defecto.
38

Seccuenccia
dee
Creaciónn
de
unaa
Apliicacióón
39

Uso del Asistente
Estructura de la Aplicación: La clase ventana (CWnd)
CCasi i ttodas d llas aplicaciones li i ti tienen una o más á ventanas. t
La clase base es CWnd.
Contiene un handle a la ventana física de Windows.
La ventana física se crea mediante Create(), se destruye con el
destructor de la subclase de CWnd. Parámetros de Create():
lpszClassName: nombre de la clase registrada con
AfxRegisterWindowClass() o NULL (atributos por defecto).
lpszWindowName: nombre de la ventana.
dwStyle: Estilo de la ventana a crear.
rect: Referencia a un objeto constante de tipo RECT, para indicar
posición y tamaño de la ventana.
pParentWindow: puntero al objecto CWnd padre de la ventana. No
puede d ser NULL NULL. Si lla ventana es lla principal, i i l usar
CreateWindowEx().
nId: Identificador de la ventana.
pContext: C t t PPuntero t a un objeto bj t dde ti tipo CC CCreateContext, t C t t para
asociar vistas y documentos a la ventana, puede ser NULL.
40

Uso del Asistente
Estructura de la Aplicación: La clase ventana (CWnd)
CW CWndd agrupa acciones i que se podían dí realizar li sobre b ventanas. t
Las hace más accesibles y seguras.
Evita por p ejemplo j p tener qque ppasar el handle como primer p parámtero p
(almacenado en el atributo m_hWnd).
Ejemplo:
los métodos de CWnd:
void CWnd::MoveWindow( int x, int y,
int nWidth, int nHeight,
BOOL bRepaint = TRUE );
void CWnd::MoveWindow( LPCRECT lpRect,
BOOL bRepaint = TRUE );
encapsulan la llamada a la API de Windows:
BOOL MoveWindow( HWND hWnd, int X, int Y,
int nWidth, int nHeight,
BOOL bRepaint);
41

Uso del Asistente
Estructura de la Aplicación: La clase CFrameWnd
HHereda d dde CW CWnd, d es utilizado tili d en aplicaciones li i SDI SDI.
Tiene en su interior una ventana hija que normalmente será la ventana
principal de la aplicación.
La ventana entana marco interacciona con el usuario s ario cambiando el tamaño tamaño,
moviéndose, etc., y gestiona estos cambios provocando modificaciones en
la ventana hija.
Para crear una ventana marco:
Create(),
LoadFrame(), que toma menos parámetros. Toma valores por defecto
de los recursos que se le pasan como parámetros: menú menú, título título, icono y
tabla de teclas acelaradoras.
virtual BOOL LoadFrame( UINT nIDResource,
DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,
CWnd* pParentWnd = NULL, CCreateContext* pContext = NULL );
Se destruye llamando a DestroyWindow().
Sus clases derivadas deben declarar DECLARE DECLARE_DYNCREATE() DYNCREATE() (gestión
dinámica de clases) si se usa la arquitectura documento/vista, y poner
IMPLEMENT_DYNCREATE() en la implementación.
42

Uso del Asistente
Handles
Las clases de la MFC ocultan los handles (CWnd::m_hWnd), para facilitar
su uso uso.
Se pueden construir objetos a partir de elementos gráficos ya construidos:
static CWnd* PASCAL FromHandle( HWND hWnd ) );
El objeto devuelto es temporal (eliminado en próxima llamada a OnIdle()).
Clases que encapsulan handles a objetos gráficos:
Elemento Gráfico Clase de Objeto
HWND CWnd y derivadas
HDC CDC y derivadas
HMENU CMenu
HPEN, HBRUSH, HFONT, HBITMAP,
HPALETTE, HRGN
CGdiObject
HIMAGELIST CImageList
SOCKET CSocket
43

Uso del Asistente
¿Dónde está el bucle de eventos?
Tabla con los elementos a manejar: el mapa de mensajes.
Mediante Macros, normalmente insertadas por el asistente.
Declaración del mapa de mensajes en la clase:
DECLARE DECLARE_MESSAGE_MAP().
MESSAGE MAP().
Declaramos también los métodos que manejarán los mensajes
mediante afx_msg:
class CMainFrame : public CFrameWnd {
public: CMainFrame();
protected:
DECLARE DECLARE_DYNAMIC(CMainFrame)
DYNAMIC(CM i F )
// Funciones de asignación de mensajes generadas
protected:
}; }
afx afx_msg msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnSetFocus(CWnd *pOldWnd);
DECLARE_MESSAGE_MAP()
44

Uso del Asistente
¿Dónde está el bucle de eventos?
Una vez declarado, , hay y que q definir el mapa p de mensajes, j , y
enlazar
cada mensaje con la función que la va a procesar.
En el fichero de implementación (.cpp) se añade:
BEGIN_MESSAGE_MAP()
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE() Mensajes que
ON_WM_SETFOCUS() se van a tratar
//}}AFX //}}AFX_MSG_MAP MSG MAP
END_MESSAGE_MAP()
Usado por versiones
anteriores de Visual C++ C
LLos mensajes j no referenciados f i d en lla ttabla bl se pasan a lla clase l
padre (o a la clase de la ventana contenedora), y así sucesivamente
hasta que se trate por algún ancestro.
45

Uso del Asistente
Código Generado: HelloMFCs.h
// HelloMFCs.h: HelloMFCs h: archivo de encabezado principal para la aplicación HelloMFCs
#pragma once
#ifndef __AFXWIN_H__
#error "incluir incluir 'stdafx stdafx.h h' antes de incluir este archivo para PCH" PCH
#endif
#include "resource.h" // Símbolos principales
class CHelloMFCsApp : public CWinApp {
public: CHelloMFCsApp();
// Reemplazos
public:
virtual BOOL InitInstance();
// Implementación
public:
};
afx_msg void OnAppAbout();
DECLARE DECLARE_MESSAGE_MAP()
MESSAGE MAP()
extern CHelloMFCsApp theApp;
46

#include "stdafx.h"
#include "HelloMFCs.h"
#include "MainFrm.h“
#ifdef _DEBUG DEBUG Uso del Asistente
#define new DEBUG_NEW
#endif
Código Generado: HelloMFCs.cpp (i)
BEGIN_MESSAGE_MAP(CHelloMFCsApp, CWinApp)
ON_COMMAND(ID_APP_ABOUT, &CHelloMFCsApp::OnAppAbout)
END_MESSAGE_MAP()
CHelloMFCsApp::CHelloMFCsApp() {
// TODO: agregar aquí el código de construcción, Colocar toda la inicialización importante en InitInstance }
CHelloMFCsApp theApp; // El único objeto CHelloMFCsApp
// Inicialización de CHelloMFCsApp
BOOL CHelloMFCsApp::InitInstance() {
}
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls);
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
CWinApp::InitInstance();
if (!AfxOleInit()) {// Inicializar bibliotecas OLE
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE; }
AfxEnableControlContainer();
SetRegistryKey( g y y(_ T("Aplicaciones ( p ggeneradas con el Asistente ppara aplicaciones p local")); ));
CMainFrame* pFrame = new CMainFrame;
if (!pFrame) return FALSE;
m_pMainWnd = pFrame;
// Crear y cargar el marco con sus recursos
pFrame pFrame->LoadFrame(IDR_MAINFRAME, >LoadFrame(IDR MAINFRAME WS WS_OVERLAPPEDWINDOW OVERLAPPEDWINDOW | FWS FWS_ADDTOTITLE, ADDTOTITLE NULL NULL,NULL); NULL);
pFrame->ShowWindow(SW_SHOW); // Se ha inicializado la única ventana; mostrarla y actualizarla
pFrame->UpdateWindow();
return TRUE;
47

Cuadro de diálogo CAboutDlg utilizado
// para el comando Acerca de
class CAboutDlg : public Cdialog {
public: CAboutDlg();
// Datos del cuadro de diálogo
enum { IDD = IDD_ABOUTBOX };
protected:
Uso del Asistente
Código Generado: HelloMFCs.cpp (ii)
virtual void DoDataExchange(CDataExchange* g ( g p pDX); ); // Compatibilidad p con DDX/DDV
// Implementación
protected:
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) {}
void CAboutDlg::DoDataExchange(CDataExchange* g g ( g p pDX) ) {
CDialog::DoDataExchange(pDX);
}
BEGIN_MESSAGE_ MAP(CAboutDlg, ( g, CDialog) g)
END_MESSAGE_MAP()
// Comando de la aplicación para ejecutar el cuadro de diálogo
void CHelloMFCsApp::OnAppAbout() pp pp () {
CAboutDlg aboutDlg;
aboutDlg.DoModal();
}
48

#pragma once
#include "ChildView ChildView.h h"
Uso del Asistente
Código Generado: MainFrm.h (i)
class CMainFrame : public CFrameWnd {
Permite acceder a información en tiempo de
public: CMainFrame();
ejecución a la clase (puede usarse la macro
protected: DECLARE_DYNAMIC(CMainFrame)
DECLARE DYNAMIC(CMainFrame)
RUNTIME RUNTIME_CLASS CLASS en lla arquitectura it t
// Reemplazos
documento/vista)
public:
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
virtual BOOL OnCmdMsg(UINT nID, nID int nCode, nCode void void* pExtra pExtra, AFX AFX_CMDHANDLERINFO CMDHANDLERINFO* pHandlerInfo);
// Implementación
public:
virtual ~CMainFrame();
#ifdef _DEBUG DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected: // Miembros incrustados de la barra de control
CStatusBar m_wndStatusBar;
CToolBar m_wndToolBar;
CChildView mm_wndView; wndView;
// Funciones de asignación de mensajes generadas
protected:
afx afx_msg msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnSetFocus(CWnd *pOldWnd);
DECLARE_MESSAGE_MAP()
};
49

#include "stdafx.h"
#include "HelloMFCs.h“
#include "MainFrm.h“
#ifdef _DEBUG
#define new DEBUG DEBUG_NEW NEW
#endif
IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
ON_WM_CREATE()
ON_WM_SETFOCUS()
END_MESSAGE_MAP()
Uso del Asistente
Código Generado: MainFrm.cpp (i)
static UINT indicators[] = {ID {ID_SEPARATOR, SEPARATOR, ID ID_INDICATOR_CAPS, INDICATOR CAPS, ID_INDICATOR_NUM, ID INDICATOR NUM, ID ID_INDICATOR_SCRL, INDICATOR SCRL, };
// Construcción y destrucción de CMainFrame
CMainFrame::CMainFrame() {// TODO: agregar aquí el código de inicialización de miembros }
CMainFrame::~CMainFrame() { }
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
// Crear una vista para ocupar el área de cliente del marco
if (!m_wndView.Create(NULL, NULL, AFX_WS_DEFAULT_VIEW, CRect(0, 0, 0, 0), this, AFX_IDW_PANE_FIRST, NULL)) {
TRACE0("No se pudo crear la ventana de vista\n");
return -1; }
if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
| CBRS_ GRIPPER | CBRS_ TOOLTIPS | CBRS_ FLYBY | CBRS_SIZE_ DYNAMIC) )|| ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {
TRACE0("No se pudo crear la barra de herramientas\n"); return -1; /* no se pudo crear */ }
if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT))) {
TRACE0("No se pudo crear la barra de estado\n"); return -1; /* No se pudo crear */}
// TODO: eliminar estas tres líneas si no desea que la barra de herramientas se pueda acoplar
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);
return 0; }
50

Uso del Asistente
Código Generado: MainFrm.cpp (ii)
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) {
// se llama por las MFCs antes de crear físicamente la ventana. se devuelve != 0 si la creación debe continuar, 0
en otro caso.
if( !CF !CFrameWnd::PreCreateWindow(cs) W d P C Wi d ( ) ) return FALSE FALSE;
// TODO: modificar aquí la clase Window o los estilos cambiando CREATESTRUCT cs
}
cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
cs.lpszClass l Cl = Af AfxRegisterWndClass(0);
R i t W dCl (0)
return TRUE;
#ifd #ifdef f _DEBUG DEBUG
void CMainFrame::AssertValid() const { CFrameWnd::AssertValid();}
void CMainFrame::Dump(CDumpContext& dc) const { CFrameWnd::Dump(dc); }
#endif //_DEBUG
void CMainFrame::OnSetFocus(CWnd* /*pOldWnd*/) {
// enviar foco a la ventana de vista
m_wndView.SetFocus();
}
BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) {
// Permitir que la vista se interrumpa primero en el comando
if ( (m_wndView.OnCmdMsg(nID, dVi O C dM ( ID nCode, C d pExtra, E t pHandlerInfo)) H dl I f )) return t TRUE TRUE;
// De lo contrario, proceder con el control predeterminado
51
return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}

ChildView.h: ChildView h: interfaz de la clase CChildView
//
#pragma once
// Ventana de CChildView
class CChildView : public CWnd {
// Construcción
public: CChildView();
// Atributos
public:
// Operaciones
public:
// Reemplazos
protected:
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
// Implementación
public:
virtual ~CChildView();
// Funciones de asignación de mensajes generadas
protected:
};
afx_msg void OnPaint();
DECLARE_MESSAGE_MAP()
Uso del Asistente
Código Generado: ChildView.h
52

#include "stdafx.h"
#include "HelloMFCs.h"
#include "ChildView ChildView.h h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
CChildView::CChildView() { }
CChildView::~CChildView() { }
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON_WM_PAINT()
END_MESSAGE_MAP()
// Controladores de mensaje de CChildView
BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs) {
if (!CWnd::PreCreateWindow(cs)) return FALSE;
}
Uso del Asistente
Código Generado: ChildView.cpp
cs.dwExStyle y |= | WS_EX_CLIENTEDGE;
_ _
cs.style &= ~WS_BORDER;
cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,
::LoadCursor(NULL, IDC_ARROW), reinterpret_cast(COLOR_WINDOW+1), NULL);
return TRUE;
void CChildView::OnPaint() {}
53

Uso del Asistente
Modificando la aplicación
void CChildView::OnPaint() ()
{
CPaintDC dc(this); // Contexto de dispositivo para dibujo
dc.Rectangle(200, g ( , 200, , 300, , 320); );
dc.DrawText( "Hola MFCs!", -1,
CRect( 200, 200, 300, 320),
DT_SINGLELINE|DT_CENTER|
DT_ VCENTER); );
}
54

Bucle de Mensajes

Las clases MFC
Arbol jerárquico de clases, con raíz CObject.
CObject permite persistencia (serialize()), chequeo de consistencia de
atributos (AssertValid()), …
Gestión de excepciones: heredan de CException
CException.
ReportError(): muestra la excepción en una ventana.
GetErrorMessage(): descripción del error.
Gestión de archivos: CFile.
Contextos de dispositivo: CDC e hijas:
AAcceso al l áárea completa l t dde lla ventana: t CWi CWindowDC. d DC
Dibujo en función del evento WM_PAINT: CPaintDC.
Gestión de Objetos j Gráficos: CGdiObject. j
Gestión de fuentes de letras: CFont.
Gestión de mapas de bits de colores: CBitmap.
Uso de Brochas: CBrush CBrush.
Manejo de plumas: CPen.
56

Las clases MFC
CC CCmdTarget: dT t clase l bbase para lla gestión ió dde mensajes. j
Clases documento: CDocument, con hijas: COleDocument,
CHtmlEditDoc, , etc.
Gestión de comunicaciones OLE: COleObjectFactory,
COleDataSource, COleDropTarget, etc.
CW CWnd: d Gestión G tió dde ventanas. t
CFrameWnd e hijas (ventana principal).
CSplitterWnd p (p (paneles de ventana). )
CControlBar (gestión de barras de control y estado): CToolBar,
CStateBar, CReBar, CDialogBar.
CDialog: gestión de ventanas de diálogo. diálogo CColorDialog (selección
de colores), CPrintDialog (imprimir), CFileDialog (elegir un fichero),
CFontDialog (selección de fuentes).
57

Las clases MFC
Gestión de vistas en la arquitectura q Documento/Vista:
CView.
CEditView: Edición de textos.
CHtmlView: Visualización de páginas HTML.
Controles (heredan de CWnd):
Texto estático (CS (CStatic). )
Texto modificable (CEdit).
Listas de elementos: CListBox, CListBox CCheckListBox CCheckListBox, CDrawListBox
CDrawListBox,
etc.
Clases que no heredan de CObject: Clases de soporte
(ej.: CWaitCursor), API servidor de Internet,
sincronización, etc.
58

Las clases MFC
59

CObject
Las
clases
MFC
CCmdTarget
60

ject
COb
Las clases MFC
61

Mapas de Mensajes
Subclases de CCmdTarget.
Declaración del mapa de mensajes: DECLARE_MESSAGE_MAP(),
que nos crea:
Un vector de mensajes privado ( (_messageEntries).
messageEntries)
Un puntero protegido al inicio del vector (messageMap).
Método virtual GetMessageMap(), que devuelve el contenido de
messageMap. M
Declaración de los métodos que gestionarán los eventos (precederlos
de afx_msg). g)
Definir la lista que relaciona eventos con las funciones que los
gestionan:
BEGIN BEGIN_MESSAGE_MAP(clase,claseBase)
MESSAGE MAP(clase claseBase)
Sintaxis que depende del tipo de evento: comando, ventana o controles.
END_MESSAGE_MAP()
62

Mensajes de Ventana
110 tipos de mensajes, producidos por la ventana que
estamos gestionando.
EEmpiezan i por WM WM_XX XX ( (excepto t WM WM_COMMAND).
COMMAND)
Se definen en la lista con ON_+.
Ej Ejemplo, l para WM WM_PAINT, PAINT WM WM_RBUTTON_DOWN:
RBUTTON DOWN
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON ON_WM_PAINT()
WM PAINT()
ON_WM_RBUTTON_DOWN()
END_MESSAGE_MAP()
Se llama a OnPaint() y a OnRButtonDown(UINT, CPoint).
Podemos usar el asistente para gestionar esta lista.
63

Mensajes de Ventana
Ejemplo: Capturar el evento WM_LBUTTONDOWN
//ChildView //ChildView.h h
class CChildView : public CWnd
{
public:
CChildView();
protected: p
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
CPoint lastClicked;
// Implementación
public:
virtual ~CChildView();
// Funciones de asignación de mensajes generadas
protected:
afx_msg void OnPaint();
DECLARE_MESSAGE_MAP()
public: bli
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
};
64

Mensajes de Ventana
Ejemplo: Capturar el evento WM_LBUTTONDOWN
//ChildView.cpp
CChildView::CChildView() : lastClicked ( (-1, 1 -1) 1) {}
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON_WM_PAINT()
ON_WM_LBUTTONDOWN()
END END_MESSAGE_MAP()
MESSAGE MAP()
void CChildView::OnPaint() {
CPaintDC dc(this); // Contexto de dispositivo para dibujo
}
dc.Rectangle(200, 200, 300, 320);
dc.DrawText( "Hola MFCs!", -1, CRect( 200, 200, 300, 320),
DT DT_SINGLELINE|DT_CENTER|DT_VCENTER);
SINGLELINE|DT CENTER|DT VCENTER);
if (lastClicked.x>=0 && lastClicked.y>0)
dc.TextOut( lastClicked.x, lastClicked.y, "click");
void CChildView::OnLButtonDown(UINT nFlags, CPoint point) {
lastClicked=point;
InvalidateRect(NULL);
CW CWnd::OnLButtonDown(nFlags, d O LB tt D ( Fl point); i t)
}
65

Mensajes de Ventana
Ejemplo: Capturar el evento WM_LBUTTONDOWN
66

Mensajes de Controles
EEventos t que lanza l lla ventana t hij hija al l padre d que lla
contiene.
Ejemplo: el control de edición manda el mensaje
EN_CHANGE cuando se modifica el texto que contiene.
Tipos: p
ON_BN_XX: mensajes de botones.
ON_EN_XX: mensajes de editores.
ON ON_CB_XX: CB XX mensajes j dde combo-boxes. b b
ON_LBN_XX: mensajes de listas.
Se mandan mediante el mensaje WM WM_COMMAND.
COMMAND
WM_NOTIFY, ON_NOTIFY() para que la función que
gestiona el evento reciba parámetros.
67

Mensajes de Comando
Provienen de menús, barras de herramientas,
teclas aceleradoras y botones.
Macro ON_COMMAND(evento,metodo).
BEGIN BEGIN_MESSAGE_MAP(CHelloMFCsApp, MESSAGE MAP(CH ll MFC A CWinApp) CWi A )
ON_COMMAND(ID_APP_ABOUT, &CHelloMFCsApp::OnAppAbout)
END_MESSAGE_MAP()
68

Mensajes de Comando
Ejemplo: Añadir un elemento de Menú
69

Mensajes de Comando
Ejemplo: Añadir el Gestor de Eventos
70

#pragma once
// Ventana de CChildView
class CChildView : public CWnd{
public:
CChildView();
protected: p
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
private:
const int numColores;
UINT * const CodigoColor; g
CPoint lastClicked;
int currentColor;
// Implementación
p
public:
virtual ~CChildView();
protected:
public:
public:
};
Mensajes de Comando
// Funciones de asignación g de mensajes j ggeneradas
afx_msg void OnPaint();
DECLARE_MESSAGE_MAP()
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnCambiacolor();
Ejemplo: ChildView.h
71

CChildView::CChildView() : numColores (4),
CodigoColor (new UINT[numColores]), currentColor(0) {
lastClicked = CPoint(-1, -1);
}
CCodigoColor[0] di C l [0] = RGB(0 RGB(0, 00, 0) 0); // Bl Black k
CodigoColor[1] = RGB(255, 0, 0); // Red
CodigoColor[2] = RGB(0, 255, 0); // Green
CodigoColor[3] = RGB(0, 0, 255); // Blue
Mensajes de Comando
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON_WM_PAINT()
ON ON_WM_LBUTTONDOWN()
WM LBUTTONDOWN()
ON_COMMAND(ID_CAMBIACOLOR, &CChildView::OnCambiacolor)
END_MESSAGE_MAP()
Ejemplo: ChildView.cpp
void id CChildVi CChildView::OnPaint() O P i t() {
CPaintDC dc(this); // Contexto de dispositivo para dibujo
dc.Rectangle(200, 200, 300, 320);
dc.DrawText( "Hola MFCs!", -1, CRect( 200, 200, 300, 320),DT_SINGLELINE|DT_CENTER|DT_VCENTER);
if (l (lastClicked.x>=0 tCli k d 0 && llastClicked.y>0) tCli k d 0) {
}
}
dc.SetTextColor(CodigoColor[currentColor]);
dc.DrawText( "Click", -1, CRect( lastClicked, CPoint(lastClicked.x+50, lastClicked.y+20)),
DT_SINGLELINE|DT_CENTER|DT_VCENTER);
void CChildView::OnCambiacolor() { currentColor = (currentColor + 1) % numColores; }
72

Mensajes de Comando
Resultado
CChildView::~CChildView()
{
delete [ ] CodigoColor;
}
73

Aplicaciones basadas en diálogos
Se pueden crear aplicaciones basadas en
diálogo.
Por defecto sin menús ni teclas aceleradoras.
Para implementar aplicaciones sencillas,
basadas en formularios de toma de datos.
La ventana principal hereda de CDialog CDialog, o de
CDHTMLDialog (para mostrar páginas en
HTML) HTML).

MapasdeDatos
Mapas de Datos
Intercambio I t bi de d Datos D t de d Diálogo Diál (DDX). (DDX)
Asociar variables a controles del diálogo g
para intercambiar información.
Por Por valor (las variables contienen el valor
del control) o por referencia (control).
UpdateData(FALSE) UpdateData(FALSE) actualiza los
controles a partir de las variables.
UpdateData(TRUE) actualiza las variables
a partir del contenido de los controles.
75

MapasdeDatos
Mapas de Datos
Ejemplo
76

MapasdeDatos
Mapas de Datos
Ejemplo
77

#pragma once
MapasdeDatos
Mapas de Datos
CSimpleDlg.h
// Cuadro de diálogo g de CSimpleDlg p g
class CSimpleDlg : public Cdialog {
// Construcción
public:
CSimpleDlg(CWnd* p g( p pParent = NULL); ); // Constructor estándar
// Datos del cuadro de diálogo
enum { IDD = IDD_SIMPLEDIALOGO_DIALOG };
protected:
virtual void DoDataExchange(CDataExchange* g ( g p pDX); ) // Compatibilidad p con DDX/DDV
// Implementación
protected:
HICON m_hIcon;
// Funciones de asignación g de mensajes j ggeneradas
virtual BOOL OnInitDialog();
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
DECLARE_MESSAGE_MAP()
_ _ ()
private:
CString strUsrName; // Nombre del usuario
CString strSaludo; // Saludo
public:
afx_msg void OnEnChangeNombre();
afx_msg void OnBnClickedOk();
afx_msg void OnEnKillfocusNombre();
};
78

CSi CSimpleDlg::CSimpleDlg(CWnd* l Dl CSi l Dl (CW d* pParent P t /*=NULL*/) /* NULL*/)
: CDialog(CSimpleDlg::IDD, pParent)
, strUsrName(_T(""))
, strSaludo(_T(""))
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void id CSi CSimpleDlg::DoDataExchange(CDataExchange* l Dl D D t E h (CD t E h * pDX) DX)
{
CDialog::DoDataExchange(pDX);
DDX_Text(pDX, IDC_NOMBRE, strUsrName);
DDV DDV_MaxChars(pDX, M Ch ( DX strUsrName, t U N 128); 128)
DDX_Text(pDX, IDC_SALUDO, strSaludo);
}
BEGIN BEGIN_MESSAGE_MAP(CSimpleDlg, MESSAGE MAP(CSi l Dl CDi CDialog) l )
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
MapasdeDatos
Mapas de Datos
ON ON_EN_CHANGE(IDC_NOMBRE, EN CHANGE(IDC NOMBRE &CSi &CSimpleDlg::OnEnChangeNombre)
l Dl O E Ch N b )
ON_BN_CLICKED(IDOK, &CSimpleDlg::OnBnClickedOk)
ON_EN_KILLFOCUS(IDC_NOMBRE, &CSimpleDlg::OnEnKillfocusNombre)
END_MESSAGE_MAP()
CSimpleDlg.cpp (i)
79

MapasdeDatos
Mapas de Datos
CSimpleDlg.cpp (i)
void CSimpleDlg::OnBnClickedOk()
{
// TODO: Add your control notification handler code here
//OnOK();
}
UpdateData(TRUE);
p ( );
strSaludo = "Hola "+strUsrName+"!";
UpdateData(FALSE);
void CSimpleDlg::OnEnKillfocusNombre()
{ // si ponemos este código en EN_CHANGE, se actualiza en tiempo de ejecución
UpdateData(TRUE);
strSaludo = "Hola "+strUsrName+"!";
UpdateData(FALSE);
}
80

Menús
Se pueden crear en el editor de recursos recursos.
El asistente crea un menú estático en la ventana marco (mismo
identificador que la tabla aceleradora y el icono).
Se cargan todos los recursos en InitInstance():
pFrame->LoadFrame(IDR_MAINFRAME,
WS_ OVERLAPPEDWINDOW |FWS | _ ADDTOTITLE, , NULL,NULL); , );
Elementos del menú de dos tipos:
pop-up (abren otros menús).
activos, que generan un mensaje de comando a la aplicación.
Normalmente a través del asistente.
DDos mensajes: j COMMAND y UPDATE_COMMAND_UI.
UPDATE COMMAND UI
El último permite cambiar el aspecto del item de menú (cambiar
texto, añadir un check, etc.)
81

Menús
Ejemplo
CChildView::CChildView() : numColores (4), CodigoColor (new UINT[numColores]),
currentColor(0), NombreColor(new CString[numColores]) {
lastClicked = CPoint(-1, -1);
CodigoColor[0] = RGB(0, 0, 0); // Black
//…
NombreColor[0] = "Negro";
//…
}
CChildView::~CChildView() {
delete [] CodigoColor;
delete [] NombreColor;
}
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON_WM_PAINT()
ON ON_WM_LBUTTONDOWN()
WM LBUTTONDOWN()
ON_COMMAND(ID_CAMBIACOLOR, &CChildView::OnCambiacolor)
ON_UPDATE_COMMAND_UI(ID_CAMBIACOLOR, &CChildView::OnUpdateCambiacolor)
END_MESSAGE_MAP()
void CChildView::OnUpdateCambiacolor(CCmdUI *pCmdUI) {
pCmdUI->SetText("Cambia Color a "+NombreColor[(currentColor+1)%numColores]);
}
82

CMenu
Para cambiar entre distintos menús, o cargar
uno dinámicamente se usa la clase CMenu.
Enmascara un HMENU (en m_hMenu).
Asignación a la ventana con SetMenu().
Algunas funciones miembro:
LoadMenu(): LoadMenu(): carga un menú creado como un recurso recurso.
CreateMenu(), CreatePopupMenu(): crea un menú
vacío (normal y emergente).
Attach(): Asocia un CMenu a un recurso identificado por
su HMENU.
83

Menús
Ejemplo: Añadir un Menú a un Diálogo
1
2
3
84

Menús
Ejemplo: Añadir un Menú a un Diálogo
11. Crear el menú en el editor de recursos
(ID=IDR_SIMPLEDIALOG).
22. Añ Añadir di un atributo t ib t dde ti tipo CM CMenu a lla clase l CSi CSimpleDlg, l Dl
gestión de items de menú.
class CSimpleDlg : public CDialog {
…
private:
CMenu menu;
CListBox fileListBox; // DDX, control
public:
afx_msg g void OnFicheroSeleccionar(); (); // gestión g de items de menú
afx_msg void OnFicheroSalir();
};
85

CSimpleDlg::CSimpleDlg(CWnd* pParent /*=NULL*/)
: CDialog(CSimpleDlg::IDD, pParent), strUsrName(_T("")), strSaludo(_T("")), menu() {
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
Menús
}
void CSimpleDlg::DoDataExchange(CDataExchange* pDX) {
CDialog::DoDataExchange(pDX);
DDX_Text(pDX, _ (p IDC_NOMBRE, _ strUsrName); )
DDV_MaxChars(pDX, strUsrName, 12);
DDX_Text(pDX, IDC_SALUDO, strSaludo);
DDX_Control(pDX, IDC_FICHEROS, fileListBox);
}
Menús
CSimpleDlg.cpp
BEGIN_MESSAGE_MAP(CSimpleDlg, CDialog)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON() ()
//}}AFX_MSG_MAP
ON_EN_CHANGE(IDC_NOMBRE, &CSimpleDlg::OnEnChangeNombre)
ON_BN_CLICKED(IDOK, &CSimpleDlg::OnBnClickedOk)
ON_EN_KILLFOCUS(IDC_NOMBRE, &CSimpleDlg::OnEnKillfocusNombre)
ON_COMMAND(ID_FICHERO_SELECCIONAR, &CSimpleDlg::OnFicheroSeleccionar)
ON_COMMAND(ID_FICHERO_SALIR, &CSimpleDlg::OnFicheroSalir)
END_MESSAGE_MAP()
BOOL CSimpleDlg::OnInitDialog() {
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE); // Establecer icono grande
}
SetIcon(m_hIcon, FALSE); // Establecer icono pequeño
menu.LoadMenu(IDR_SIMPLEDIALOGO);
SetMenu(&menu);
return TRUE; // Devuelve TRUE a menos que establezca el foco en un control
86

Menús
CSimpleDlg.cpp
void CSimpleDlg::OnFicheroSeleccionar()
{
LPCTSTR C S szCppFilters= C "C++ C Files (* (*.cpp)|*.cpp|All )|* | Files (* (*.*)|*.*||"; *)|* *||
CFileDialog fd(TRUE, "Cpp", "*.cpp",
OFN OFN_FILEMUSTEXIST| FILEMUSTEXIST| OFN_HIDEREADONLY, OFN HIDEREADONLY szCppFilters, szCppFilters this);
if( fd.DoModal ()==IDOK ) {
CString pathName = fd.GetPathName();
UpdateData(TRUE);
fil fileListBox.AddString(pathName);
Li tB AddSt i ( thN )
UpdateData(FALSE);
}
}
void CSimpleDlg::OnFicheroSalir() {
PostMessage(WM_QUIT);
}
87

Menús
Ejemplo: Añadir un Menú Emergente Dinámico
class CSimpleDlg : public CDialog
{
private:
public:
};
// …
CMenu pmenu;
afx_msg g void OnRButtonDown(UINT ( nFlags, g , CPoint p point); ); //con asistente
afx_msg void OnItem1(); // a mano
88

CSimpleDlg::CSimpleDlg(CWnd* pParent /*=NULL*/)
Menús
: CDialog(CSimpleDlg::IDD, pParent)
, strUsrName(_T("")) , strSaludo(_T("")) , menu(), pmenu() {
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); CSimpleDlg.cpp
}
BEGIN_MESSAGE_ MAP(CSimpleDlg, ( p g, CDialog) g)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
// …
ON_COMMAND(ID_FICHERO_SELECCIONAR, &CSimpleDlg::OnFicheroSeleccionar)
ON_COMMAND(ID_FICHERO_SALIR, &CSimpleDlg::OnFicheroSalir)
ON_COMMAND(ID_FICHERO_SALIR+1, &CSimpleDlg::OnItem1)
ON ON_WM_RBUTTONDOWN()
WM RBUTTONDOWN()
END_MESSAGE_MAP()
BOOL CSimpleDlg::OnInitDialog() {
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE); // Establecer icono grande
SetIcon(m_hIcon, FALSE); // Establecer icono pequeño
menu.LoadMenu(IDR ( _ SIMPLEDIALOGO); );
SetMenu(&menu);
pmenu.CreatePopupMenu();
pmenu.AppendMenu(MF_STRING, ID_FICHERO_SALIR+1, "Item 1");
pmenu pmenu.AppendMenu(MF_STRING, AppendMenu(MF STRING ID ID_FICHERO_SELECCIONAR, FICHERO SELECCIONAR "Seleccionar Seleccionar Fichero"); Fichero );
pmenu.AppendMenu(MF_STRING, ID_FICHERO_SALIR, "Salir");
return TRUE; // Devuelve TRUE a menos que establezca el foco en un control
}
89

Menús
CSimpleDlg.cpp
void CSimpleDlg::OnFicheroSalir()
{
// TODO: TODO Add your command d hhandler dl code d hhere
PostMessage(WM_QUIT);
}
void CSimpleDlg::OnRButtonDown(UINT nFlags, CPoint point)
{
ClientToScreen(&point);
pmenu.TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this);
}
void CSimpleDlg::OnItem1()
{
AfxMessageBox("Item AfxMessageBox( Item 1 1"); );
}
90

Menús
Ejemplo: Añadir un Menú Emergente Dinámico
En realidad lo que hemos hecho es un “menú
contextual”.
PPara ello ll bbasta t con capturar t el l mensaje j
WM_CONTEXTMENU.
void id CSimpleDlg::OnContextMenu(CWnd* CSi l Dl O C t tM (CW d* pWnd, W d CP CPoint i t point) i t)
{
pmenu.TrackPopupMenu(TPM_LEFTALIGN, point.x, point. y, this);
}
Si no mostramos un menú, debemos llamar a
CWnd::OnContextMenu(pWnd CWnd::OnContextMenu(pWnd, point) antes de salir salir.
91

Teclas Aceleradoras
Asociar una combinación de teclas a un comando.
Si se usa el asistente, la definición de teclas
aceleradoras l d se carga en lla ventana t marco con lla
llamada a LoadFrame().
92

Teclas Aceleradoras
Las tablas aceleradoras no funcionan con aplicaciones
basadas en diálogo, ya que su bucle de mensajes no
llama a TranslateAccelerator()
TranslateAccelerator().
class CSimpleApp : public CWinApp
{
private:
public: bli
HACCEL m_haccel; // añadir handle a tabla aceleradora
CSimpleApp();
// Reemplazos
public:
virtual BOOL InitInstance();
BOOL ProcessMessageFilter(int code, LPMSG lpMsg); // sobreescribir
DECLARE DECLARE_MESSAGE_MAP()
MESSAGE MAP()
};
93

BOOL CSimpleApp::InitInstance() {
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls); Teclas Aceleradoras
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
CWinApp::InitInstance();
AfxEnableControlContainer(); ();
SetRegistryKey(_T("Aplicaciones generadas con el Asistente para aplicaciones local"));
m_haccel=::LoadAccelerators(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_ACCELERATOR1));
CSimpleDlg dlg;
m_ppMainWnd = &dlg; g;
INT_PTR nResponse = dlg.DoModal();
if (nResponse == IDOK) {
// TODO: insertar aquí el código para controlar cuándo se descarta el cuadro de diálogo con Aceptar
}
else if (nResponse == IDCANCEL) {
// TODO: insertar aquí el código para controlar cuándo se descarta el cuadro de diálogo con Cancelar
}
return FALSE;
}
BOOL CSimpleApp::ProcessMessageFilter(int code, LPMSG lpMsg) {
if (code ( < 0) ) CWinApp::ProcessMessageFilter(code, pp g ( , lpMsg); p g);
if(m_haccel)
{
if (::TranslateAccelerator(m_pMainWnd->m_hWnd, m_haccel, lpMsg))
return(TRUE); ( );
}
return CWinApp::ProcessMessageFilter(code, lpMsg);
}
94

Teclas Aceleradoras
Este podría ser un bucle de mensajes con llamada a las
tteclas l aceleradoras: l d
int WINAPI WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR lpCmdLine, int nCmdShow) {
MSG msg;
BOOL bRet;
//…
while ( (bRet = GetMessage(&msg, (HWND) NULL, 0, 0)) != 0) {
if (bRet (bR t == -1) 1) {
// handle the error and possibly exit
}
else { // Check for accelerator keystrokes.
if (!TranslateAccelerator(
hwndMain, // handle to receiving window
haccel, // handle to active accelerator table
&msg)) // message data
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
//…
}
95

Diálogos
Las MFCs contienen diálogos preconstruidos
que pueden ser usados directamente por el
usuario.
Para crear un diálogo: g
Se usa el editor de recursos.
DoModal() () muestra el diálogo g de manera modal.
Devuelve un UINT con la razón por la que se cerró
(ej.: IDCANCEL o IDOK).
Los no modales se crean como si fueran una ventana
(Create()).
96

Ejemplo: Añadir un Diálogo
Se añade un nuevo elemento al menú
y a la tabla aceleradora
void CSimpleDlg::OnFicheroDialogo() {
CDialogoEjemplo dlg(this);
dlg dlg.DoModal(); DoModal();
}
Creado usando el
editor de recursos.
SSe crea una clase l que
herede de CDialog
con el asistente asistente.
class CDialogoEjemplo : public CDialog {
DECLARE_DYNAMIC(CDialogoEjemplo)
public:
CDialogoEjemplo(CWnd* CDialogoEjemplo(CWnd pParent = NULL);
virtual ~CDialogoEjemplo();
enum { IDD = IDD_DIALOG1 };
protected:
virtual void
DoDataExchange(CDataExchange* pDX);
DECLARE_MESSAGE_MAP()
};
97

Diálogos Predefinidos
CC CColorDialog: l Di l permite i seleccionar l i un
color.
CFileDialog: permite seleccionar
ficheros.
CFindReplaceDialog: permite realizar
búsqueda o buscar/reemplazar (no
modal, se crea con Create()). 98

Diálogos Predefinidos
CFontDialog: permite elegir una
fuente.
CPrintDialog: permite imprimir y
configurar la impresión.
CPageSetupDialog: permite
imprimir y
99

Controles
Las MFC ponen a nuestra disposición un
gran g número de controles qque simplifican p
la creación de aplicaciones.
Los Los controles mandan notificaciones a la
ventana padre (ej.: el control de edición
manda EN_CHANGE C G cuando cambia el
texto). )
100

Controles predefinidos MFC
CAnimateCtrl: public CWnd: Permite
mostrar un vídeo en formato AVI.
void CAboutDlg::OnBnClickedButton1()
{
avi_player.Open(IDR_AVI1);
avi avi_player.Play(0, player Play(0 -1 -1, -1);
}
101

Controles predefinidos MFC
CButton: permite gestionar botones.
Eventos: BN BN_CLICKED, CLICKED, BN BN_DOUBLECLICKED.
DOUBLECLICKED.
Métodos: GetState(), SetState(), SetCursor(), GetCursor().
void CAboutDlg::OnBnClickedMessage()
{
anim.Stop();
AfxMessageBox("Stop!");
}
102

Controles predefinidos MFC
CBit CBitmapButton: B tt SSe crea un botón b tó normal l en el l
editor de recursos y:
se selecciona OwnerDraw=true
OwnerDraw true.
en el caption se pone una descripción (ej: BOTON).
Se crean de 1 a 4 bitmaps:
ID=“BOTONU”, bitmap normal.
ID=“BOTONF”, bitmap foco de teclado.
ID=“BOTONX”, , bitmap p botón desactivado.
ID=“BOTOND”, bitmap botón pulsado.
Se crea un objeto de la clase CBitmapButton como
miembro del diálogo diálogo.
En la inicialización del diálogo (OnInitDialog()) se llama
a AutoLoad().
103

Ejemplo
class CAboutDlg : public CDialog {
public:
CAboutDlg();
CBitmapButton
//…
virtual void DoDataExchange(CDataExchange* pDX); // Compatibilidad con DDX/DDV
// Implementación
protected:
DECLARE_MESSAGE_MAP()
private: i t
CAnimateCtrl anim;
CBitmapButton BClose;
public:
afx_msg f void id OOnBnClickedStart(); B Cli k dSt t()
afx_msg void OnBnClickedMessage();
public:
BOOL OnInitDialog();
};
void CAboutDlg::DoDataExchange(CDataExchange* pDX) {
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, IDC_ANIMATE1, anim);
DDX DDX_Control(pDX, C t l( DX IDMESSAGE, IDMESSAGE BCl BClose); )
}
//…
BOOL CAboutDlg::OnInitDialog() {
BCl BClose.AutoLoad(IDMESSAGE, A t L d(IDMESSAGE this); thi )
CDialog::OnInitDialog();
return FALSE;
}
104

Controles predefinidos MFC
CListBox:
Listas
Datos iniciales (en “OnInitDialog”)
Selección simple o múltiple
Métodos:
int GetCurSel();
int SetCurSel(int nSelect);
int AddString(LPCTSTR lpszItem);
int InsertString(int nIndex,
LPCTSTR lpszItem);
Ejemplo
void CSimpleDlg::OnLbnKillfocusList1()
{
int sel = nameListBox.GetCurSel();
if (sel>-1) {
CString str;
nameListBox.GetText(sel,str);
Af AfxMessageBox("Selected M B ("S l t d It Item: " "+str); t )
}
105
}

Controles predefinidos MFC
CC CComboBox: b B
Simple (lista siempre visible), Drop-down (permite editar), Drop-
Down List.
Métodos:
GetCount(): número de elementos que tiene la lista.
GetCurSel()/SetCurSel(): obtiene/establece el número de orden del
elemento seleccionado.
SetItemData()/GetItemData(): lee el valor asignado a un
determinado elemento de la lisa.
AddString()/DeleteString()/InsertString(). También se pueden cargar
valores estáticos en el campo “Data” del editor de recursos
(separados mediante ;)
Dir().
CComboBoxEx: permite introducir imágenes en los
elementos a seleccionar, entre otras mejoras.
106

Controles predefinidos MFC
CD CDataTimeCtrl. t Ti Ct l
CEdit.
CHeaderCtrl
CHeaderCtrl.
CHotKeyCtrl.
CIpAddressCtrl
CIpAddressCtrl.
CCheckListBox.
CDragListBox
CDragListBox.
CListCtrl.
CMonthCalCtrl.
COleControl.
CProgressCtrl.
107

Controles predefinidos MFC
CR CReBarCtrl. B Ct l
CRichEditCtrl.
CScrollBar CScrollBar.
CSliderCtrl.
CSpinButtonCtrl
CSpinButtonCtrl.
CStatic.
CStatusBarCtrl
CStatusBarCtrl.
CTabCtrl.
CToolBarCtrl
CToolBarCtrl.
CToolTipCtrl.
CTreeCtrl CTreeCtrl.
108

Clases de Utilidad
Cadenas de caracteres
CString CString.
Caracteres unicode vs. ascii.
Definiciones de un “const char*”
typedef wchar_t wchar t WCHAR;
// “wchar_t” es un char “Unicode” (2 bytes)
// o “ANSI” (1 byte) dependiendo de
// la opción señalada para el proyecto
typedef __nullterminated CONST WCHAR *LPCWSTR;
typedef LPCWSTR LPCTSTR;
Conversiones. Ejemplo: j p
LPCTSTR t;
// si tenemos “opción Unicode” es un error: t="abc";
CString c1("abc");
c1="def"; 1 "d f"
t=c1;
// correcto ya que hace un casting implícito
// y está definido un operador p de casting g
109

Clases de Utilidad
Cadenas de caracteres
// sobrecarga de =, +=, + etc
CString s;
s="Hola”;
s= Hola ;
s+=“ soy yo”;
cout

Clases de Utilidad
Contenedores
Similares a los contenedores de la STL.
Definiciones en afxtempl.h (que debemos incluir en
stdafx.h). td f h)
Los templates admiten dos parámetros: el tipo de dato, y
el tipo para referirse a él (quizá una referencia) referencia).
Contenedor Clase Puntero
Vectores CArray CTypedPtrArray
Listas CList CTypedPtrList
Diccionario CMap CTypedPtrMap

Clases de Utilidad
Contenedores: CArray
Si Similar il a vector t dde lla STL STL.
template < class TYPE, class ARG_TYPE =
const TYPE& > class CArray : public
CObject
ARG_TYPE es el tipo que se usa para
acceder a los elementos almacenados.
Ej Ejemplo l
CArray myArray;
Tamaño:
//Addelementstothearray
// Add elements to the array.
GetCount(), GetSize(), GetUpperBound(), for (int i=0;i < 10;i++)
IsEmpty(), SetSize().
myArray.Add( CPoint(i, 2*i) );
Operaciones:
p
FreeExtra(), RemoveAll(), RelocateElements().
Aumentando el Array:
Add(), (), Append(), pp (), Copy(), py(), SetAtGrow(). ()
Inserción/eliminación:
InsertAt(), RemoveAt()
Operadores:
Acceso/modificación con el operador [].
// Modify all the points in the array.
for (i=0;i

Clases de Utilidad
Contenedores: CList
ttemplate TYPE& class l CLi CList t : public bli CObj CObject t
Iteración: CList myList; y ;
POSITION pos = myList.GetHeadPosition();
while( pos != NULL ) {
}
CMiClase& clase = myList.GetNext( pos );
// //...
IInserción: ió myList.InsertAfter(myList.GetTailPosition(), Li t I tAft ( Li t G tT ilP iti () elem); l )
Eliminación: myList myList.RemoveAt(pos);
RemoveAt(pos);
113

Clases de Utilidad
Contenedores: CMap
template< l class l KEY KEY, class l
ARG_KEY, class VALUE, class
ARG_VALUE >class CMap : public
CObject
Operaciones:
GetHashTableSize()
GetHashTableSize(),
GetNextAssoc(), PGetNextAssoc(),
GetStartPosition(), PGetFirstAssoc(),
InitHashTable() InitHashTable(), Lookup() Lookup(),
PLookup(), operator[], RemoveAll(),
RemoveKey(), SetAt().
Estado:
GetCount(), GetSize(), IsEmpty().
Miembros de Datos:
CMap::CPair
CM CMap i t i t CP i t CP i t myMap; M
int i;
myMap.InitHashTable( 257 );
// Add 10 elements to the map.
for (i=0;i < 200;i++)
myMap[i] = CPoint(i, i);
// Remove the elements with even
// key values.
CPoint pt;
f for (i=0; (i 0 myMap.Lookup( M L k ( ii, pt t ) ;i+=2) i+ 2)
{
myMap.RemoveKey( i );
}
Ejemplo

Clases de Utilidad
Contenedores de punteros
Si queremos tener listas de objetos heterogeneos
heterogeneos.
No podemos usar los contenedores anteriores, ya que si
queremos q serializar una lista a disco, se copiarían p los
punteros, y no los objetos.
Por ello, MFC duplica los contenedores para la gestión de
punteros punteros.
template< class BASE_CLASS, class TYPE > class
CTypedPtrList : public BASE_CLASS
BASE BASE_CLASS: CLASS ti tipo ddel l que se hhereda d para construir t i el l
template.
CObList si los elementos heredan de CObject (se pueden serializar).
CPtrList en otro caso. caso
TYPE: tipo de los elementos que insertamos.
Similar para arrays.

typedef CTypedPtrList CMyList;
CMyList ml;
CMyObject* y j pMyObject y j = new CMyObject(); y j ()
ml.AddTail(pMyObject);
CFileException e;
CFile myFile;
myFile.Open("MyFile.txt",
CFile::modeCreate|CFile::modeWrite, &e);
CArchive ar(&myFile, CArchive::store);
ml.Serialize(ar);
ar.Close();
myFile.Close();
while (!ml.IsEmpty())
{
delete ml.GetHead();
ml.RemoveHead();
}
Clases de Utilidad
Contenedores de punteros, ejemplo
//=====================
// //where h CMyObject CM Obj t iis ddefined fi d bby th the ffollowing ll i fil files:
//CMyObject.h
class CMyObject : public Cobject {
public: bli
int i;
void Serialize(CArchive& ar);
CMyObject() { i = 9876;}
protected: t t d
DECLARE_SERIAL(CMyObject)
};
//CM //CMyObject.cpp Obj t
#include "stdafx.h"
#include "CMyObject.h"
IMPLEMENT IMPLEMENT_SERIAL(CMyObject, SERIAL(CM Obj t CObject, CObj t 0)
void CMyObject::Serialize(CArchive& ar) {
CObject::Serialize( ar );
if( ar.IsStoring() )
ar > i;
}

Clases de Utilidad
Contenedores de punteros: CTypedPtrMap
ttemplate< l t < class l BASE_CLASS, BASE CLASS class l KEY KEY, class l VALUE > class l
CTypedPtrMap : public BASE_CLASS
BASE_CLASS: clase base del diccionario, puede ser, en función de
llos tipos ti de d la l clave l y elementos l t a almacenar: l
CMapPtrToPtr,
CMapPtrToWord,
CMapWordToPtr,
CMapStringToPtr
CMapStringToString
p g g
CMapWordToOb
CMapWordToPtr
KEY: tipo de la clave. clave
VALUE: tipo de los elementos a almacenar (suele ser un
puntero).
Ej.: typedef CTypedPtrMap MapaAMiObjeto;

Indice
PProgramación ió bbajo j Wi Windows. d
Introducción a las MFCs.
A Arquitectura it t Documento/Vista.
D t /Vi t
Introducción.
SDI y MDI.
Plantillas Plantillas de documento.
documento
Ejemplo.
D Documento, t serialización. i li ió
Bibliografía.
118

Arquitectura Documento Vista
SSeparar lla visualización i li ió ( (vista) i ) dde llos d datos (d (documento). )
Similar al patrón “Model-View-Controler”.
El asistente genera clases que heredan de: CFrameWnd CFrameWnd, CView y
CDocument.
CView es abstracta. Otra posibilidad es usar como base una vista
predefinida: d fi id
CEditView (edición de texto básica). Esta se puede usar directamente.
CRichEditView (permite formateo de texto).
CScrollView (scroll vertical y horizontal).
CListView (listas de elementos).
CTreeView (árbol de elementos) elementos).
CFormView (similar a un cuadro de diálogo).
CDaoRecordView (similar a cuadro de diálogo pero para control de
BBDD) BBDD).
CCtrolView (se pueden incluir otras vistas dentro).
119

SDI y MDI
Single Document Interface: Un solo tipo de documento documento.
Multiple Document Interface: Varios tipos de documento.
Una aplicación SDI Una aplicación MDI
120

Las plantillas de documento
El documento, el marco y la vista se relacionan usando plantillas de
documento, que heredan de CDocTemplate.
CSingleDocTemplate y CMultiDocTemplate para SDI y MDI.
BOOL CSDI2App::InitInstance() CSDI2A I itI t () {
//…
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
}
RUNTIME RUNTIME_CLASS(CSDI2Doc),
CLASS(CSDI2D )
RUNTIME_CLASS(CMainFrame), // Ventana de marco SDI principal
RUNTIME_CLASS(CSDI2View));
if (!pDocTemplate) return FALSE;
AddD AddDocTemplate(pDocTemplate);
T l t ( D T l t )
EnableShellOpen();
RegisterShellFileTypes(TRUE);
// …
RUNTIME_CLASS devuelve un struct CRuntimeClass *.
Nota: Sólo se puede obtener esta información de subclases de CObject que
hayan sido declaradas DECLARE_DYNAMIC, DECLARE_DYNCREATE o
DECLARE_SERIAL.
121

Las plantillas de documento
Una plantilla de documento por cada tipo de documento
soportado, y es responsable de crear y gestionar los
documentos de ese tipo tipo.
La plantilla contiene el ID con los recursos (menú, icono,
tablas aceleradoras).
aceleradoras)
Contiene también strings con el nombre del tipo de
documento, docu e o, la a eextensión e s ó de sus ficheros, c e os, eetc. c
EnableShellOpen(): permite abrir ficheros de datos
haciendo doble click en ellos en el explorador. p
RegisterShellFileTypes(cCompat): Registra los tipos de
documentos en el explorador. Si bCompat==TRUE
entonces se pueden imprimir los ficheros desde el
explorador.
122

Arquitectura Documento Vista
Ejemplo
123

Arquitectura Documento Vista
Ejemplo
St String i asociado i d a la l aplicación li ió IDR IDR_MAINFRAME
MAINFRAME
7 pedazos:
Vista derivada de CFormView.
Se crea también un diálogo vacío
en el editor de recursos:
124

El Documento
Encargado de gestionar los datos, incluido su grabación y
recuperación del disco.
virtual BOOL OnNewDocument(); se llama cuando se va a
crear un nuevo fichero (sobreescribirlo permite chequear si
queremos dejar crearlo o no).
virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
se llama cuando se va a abrir un fichero.
virtual void OnCloseDocument(); se llama cuando se va a
cerrar un fichero fichero.
virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
se llama cuando se va a salvar un documento.
void SetModifiedFlag(BOOL bModified = TRUE); marca
el documento como cambiado.
BOOL IsModified(); comprueba si un documento está
modificado. 125

Colaboración de Objetos en la
Aplicación
AAcceso a unos objetos bj t ddesde d otros: t
Obj Objeto Mé Método d
Documento GetFirstViewPosition()/GetNextView()
Documento GetDocTemplate()
Vista GetDocument()
Vista GetParentFrame()
Ventana marco del documento GetActiveView()
Ventana marco del documento GetActiveDocument()
Ventana principal (MDI) MDIGetActive()
Ventana marco GetActiveFrame()

Colaboración de Objetos en la
Aplicación
CWinApp pp
1
1
m_pMainWnd
CFrameWnd
1
1
CView
1..*
getParent();
1
CDocument
getActiveView();
g ();
{POSITION p=GetFirstViewPosition();
GetNextView(p);}
getDocument();
g ();

Arquitectura Documento Vista
Serialización
GGuardar/leer d /l los l ddatos dde di disco.
virtual void Serialize(CArchive& ar); provisto por CObject.
Sirve para leer y escribir. escribir
Se usan los operadores > sobre el CArchive.
void CSDI2Doc::Serialize(CArchive& ar) {
POSITION pos = GetFirstViewPosition(); // m_viewList contiene lista punteros a vistas
CSDI2View* pView = dynamic_cast(GetNextView(pos));
if (ar.IsStoring()){
}
}
else {
}
pView->UpdateData(TRUE);
pView >UpdateData(TRUE);
ar nombre;
ar direccion;
ar edad;
ar >> pView->nombre;
ar >> pView->direccion;
ar >> pView pView->edad; >edad;
pView->UpdateData(FALSE);
128

Arquitectura Documento Vista
Serialización
class CSDI2Doc : public CDocument {
//..
private: p
CSDI2View* pView;
CSDI2View* getView();
// …
};
inline CSDI2View* CSDI2Doc::getView(){
if (!pView) {
}
return pView;
}
void CSDI2Doc::Serialize(CArchive& ar){
getView();
POSITION pos p = GetFirstViewPosition(); ();
pView = dynamic_cast(GetNextView(pos));
if (ar.IsStoring()) {
pView->UpdateData(TRUE);
p p ( )
ar nombre direccion edad;
}
else {
ar >> pView->nombre >> pView->direccion >> pView->edad;
pView->UpdateData(FALSE);
}
}
// el evento salvar llama por defecto a la serialización del documento
129

Arquitectura q Documento Vista
Creación de un nuevo documento
BOOL CSDI2Doc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return t FALSE; FALSE
}
// TODO: agregar aquí código de reinicio
// (los documentos SDI volverán a utilizar este documento)
getView()->nombre="";
pView->direccion="";
pView pView->edad=0; >edad=0;
pView->UpdateData(FALSE);
return TRUE;
130

Ejemplo

Indice
Programación g bajo j Windows.
Introducción a las MFCs.
Arquitectura Documento/Vista
Documento/Vista.
Aspectos avanzados de las MFCs.
Diálogos no modales.
Creación Creación dinámica de widgets. widgets
Registro.
Otros aspectos de las MFCs.
Bibliografía
Bibliografía.
132

Diálogos No Modales
PPara ejecutar j t diálogos diál en fformal l modal, d l
simplemente hay que llamar al método
DoModal().
Para crear un diálogo no modal, hay que
hacerlo como si fuera una ventana cualquiera,
mediante Create().
Esto crea el diálogo y continúa la ejecución.
Por tanto el diálogo se debe crear usando memoria
dinámica!
Liberación de la memoria en OnNcDestroy() y() del
diálogo. Aquí se pueden pasar datos a la
ventana principal.
133

void CGraficosSDIApp::OnAppAbout() {
}
Diálogos No Modales
if (!pAboutDlg) {
Ejemplo: About No Modal
pAboutDlg = new CAboutDlg(); // puntero miembro
pAboutDlg->Create( MAKEINTRESOURCE(CAboutDlg::IDD), // string con ID
CWnd::GetDesktopWindow()); // puntero al escritorio,
// evita que el diálogo esté siempre encima
pAboutDlg->ShowWindow(SW_SHOW);
}
else pAboutDlg->SetForegroundWindow(); // el diálogo ya existía, llevarlo al frente
void CGraficosSDIApp::CloseDialog() { // acciones al cerrar el diálogo
pAboutDlg g = 0; // simplemente apunta a NULL
}
void CAboutDlg::OnNcDestroy() { // último mensaje que se recibe antes de cerrar
CDialog::OnNcDestroy();
((CGraficosSDIApp*)AfxGetApp())->CloseDialog(); // avisar a la aplicación, podríamos avisar a la ventana padre
// otra posibilidad es mandarle un mensaje definido por el
// usuario con GetParent()->PostMessage(WM_USR,0,0)
delete this; // importante: borramos la memoria dinámica
}
void CAboutDlg::OnOK() { // importante sobreescribir si se tiene un IDOK, ya que por defecto MFC llama a
// EndDialog(), que sólo vale para DoModal()
if(UpdateData(true))
DestroyWindow();
}

Creación dinámica de widgets
void CSDI2View::OnBnClickedButton1()
{
CButton* pButton=new CButton;
pButton->Create("Submit",
pButton Create( Submit ,
WS_CHILD | WS_VISIBLE,
CRect(170, 120, 270, 143),
this, ,
0x302); // un ID
}
135

Registro
La mayoría de las aplicaciones dejan cierto grado de customización al
usuario.
Por ejemplo: posición y tamaño de la ventana ventana, posición de las barras
de controles, etc.
Guardar esta información de configuración en el registro (hasta
windows 3.11, esta información se guardaba en ficheros INI).
En InitInstance() se llama a SetRegistryKey() SetRegistryKey(), para establecer una
clave (se crea debajo de HKEY_CURRENT_USER/software).
SetRegistryKey() asigna valor al atributo m_pszRegistryKey de la clase
CWinApp. pp
El resto de llamadas del API (GetProfileString(), GetProfileInt(),
WriteProfileString(), g() WriteProfileInt()) ())
utilizan dichos métodos.

Registro
BOOL CGraficosSDIApp::InitInstance()
{
//…
SetRegistryKey(_T("GraficosSDI"));
LoadStdProfileSettings(4); // Cargar opciones de archivo INI estándar
// (incluidas las de la lista MRU)
//…
}
Normalmente se leerá la información del registro en
“OnCreate()” de la ventana marco.
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
WINDOWPLACEMENT PosVen;
if (LeePosicionVentana(&PosVen)) SetWindowPlacement(&PosVen);
//…
}

Registro
bool CMainFrame::LeePosicionVentana(LPWINDOWPLACEMENT pPosVen)
{
CString strClave = AfxGetApp()->GetProfileString(_T("Arranque"), _T("Posicion"));
if (strClave.IsEmpty()) return false;
int numDatos = sscanf_s(strClave, "%u,%u,%d,%d,%d,%d,%d,%d,%d,%d",
&pPosVen->flags, &pPosVen->showCmd, &pPosVen->ptMinPosition.x,
&pPosVen->ptMinPosition.y, &pPosVen->ptMaxPosition.x, &pPosVen->ptMaxPosition.y,
&pPosVen->rcNormalPosition.left, &pPosVen->rcNormalPosition.top,
&pPosVen->rcNormalPosition.right, &pPosVen->rcNormalPosition.bottom);
if (numDatos != 10) return false;
pPosVen->length=sizeof(pPosVen);
return true;
}

Registro
void id CM CMainFrame::OnClose()
i F O Cl ()
{
WINDOWPLACEMENT PosVen;
PosVen.length=sizeof(PosVen);
if (G (GetWindowPlacement(&PosVen))
tWi d Pl t(&P V ))
{
if (PosVen.showCmd!=SW_SHOWMINIMIZED)
EscribirPosicionVentana(&PosVen);
}
}
CFrameWnd::OnClose();
void CMainFrame::EscribirPosicionVentana(LPWINDOWPLACEMENT pPosVen)
{
TCHAR szBuffer[8*6+2*5+9+1];
}
wsprintf(szBuffer, i tf( B ff "%u,%u,%d,%d,%d,%d,%d,%d,%d,%d",
"% % %d%d%d%d%d%d%d%d"
pPosVen->flags, pPosVen->showCmd, pPosVen->ptMinPosition.x,
pPosVen->ptMinPosition.y, pPosVen->ptMaxPosition.x, pPosVen->ptMaxPosition.y,
pPosVen->rcNormalPosition.left, pPosVen->rcNormalPosition.top,
pPosVen->rcNormalPosition.right, P V > N lP iti i ht pPosVen->rcNormalPosition.bottom);
P V > N lP iti b tt )
AfxGetApp()->WriteProfileString(_T("Arranque"), _T("Posicion"), szBuffer);

Otros aspectos de las MFCs
Bases de datos
Sincronización
Sincronización
Windows sockets
Servicios Internet
140

Indice
Programación bajo Windows.
Introducción Introducción a las MFCs. MFCs
Arquitectura Documento/Vista.
Aspectos avanzados de las MFCs.
Bibliografía
Bibliografía.
141

Bibliografía
MSDN (ayuda en línea) línea).
“Programación Avanzada en Windows 2000 con Visual
C++ y MFC”. Pascual, J., Charte, F., Segarra, g M. J., de
Antonio, A., Clavijo, J. A. McGraw Hill. 2000.
MFC:
http://www http://www.functionx.com/visualc/
functionx com/visualc/
http://www.dcp.com.ar/mfc/indice.htm
http://www.uta.fi/~jl/pguibook/
http://www http://www.samspublishing.com/library/library.asp?b=Visual_C_
samspublishing com/library/library asp?b Visual C
PlusPlus&rl=1 (libro “Visual C++ Unleashed”)
Documentación MFC al estilo de javadoc:
http://www http://www.cppdoc.com/example/mfc/mfc.html
cppdoc com/example/mfc/mfc html
Controles
http://www.functionx.com/visualc/controls/
142