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. Hola mundo!. El API de Windows. Introducción a las MFCs. Arquitectura Documento/Vista. Aspectos avanzados de las MFCs. Bibliografía. 2

Programación Bajo Windows Proramación orientada a eventos, en contraste con la programación para MS-DOS, que es secuencial. Evento: Algo que sucede en el sistema (click de 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. 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, como los controladores de 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. Hay que dar el nombre de la ventana, sus coordenadas, d dimensiones, menú, etc. 2. Esperar que llegue algún mensaje. 3. Reaccionar ante el mensaje 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 hacerlos llegar a la ventana correspondiente. 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 <windows.h> // Crear un proyecto win32 application vacío (o Hello World en VC 6.0) LRESULT CALLBACK GestorMensajes( HANDLE hwnd, UINT mensaje, WPARAM wparam, LPARAM lparam) { HDC hdc; // Device context PAINTSTRUCT ps; // Estructura de dibujado RECT rect; // Rectángulo cliente Hola Mundo! switch (mensaje) { case WM_PAINT: hdc = BeginPaint((HWND)hWnd, i &ps); GetClientRect((HWND)hWnd,&rect); DrawText(hDc, TEXT(" Hola Mundo! ), -1, &rect, DT_SINGLELINE DT_CENTER DT_VCENTER); EndPaint((HWND)hWnd, &ps); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc((HWND)hWnd,mensaje,wParam,lParam); d P ) 6 return (NULL);

Hola Mundo! BOOL IniciaAplicacion (HINSTANCE hinstance) { WNDCLASS wc; wc.style = CS_HREDRAW CS_VREDRAW; //Estilo de la clase wc.lpfnwndproc = (WNDPROC)GestorMensajes; // Procedimiento gestor wc.cbclsextra = 0; wc.cbwndextra = 0; wc.hinstance = hinstance; // Instancia 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_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

Hola Mundo! BOOL IniciaInstancia(HINSTANCE hinstance, int ncmdshow) { HWND hwnd; 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); // Parametros if (!hwnd) return FALSE; ShowWindow(hWnd, ncmdshow); // dice cómo mostrar la ventana UpdateWindow(hWnd); // actualiza la ventana: genera un evento WM_PAINT return TRUE; 8

Hola Mundo! 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; 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.), globales y locales de 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 int x, // posición ió horizontal de la ventana int y, // posición vertical de la ventana int nwidth, // anchura de ventana int nheight, // altura de ventana HWND hwndparent, // handle de la ventana padre HMENU hmenu, // handle del menú de ventana HINSTANCE hinstance, // handle a la instancia de la aplicación LPVOID lpparam ); // puntero a parámetros. Creación de una ventana de una clase registrada. CreateWindowEx para estilos extendidos (ej.: layered 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_CHILD, WS_CHILDWINDOW : ventana hija (no puede tener menú ni puede 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_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. WS_SYSMENU: S ventana a con menú de sste sistema. 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 borde Area cliente Scroll horizontal Scroll vertical 13

Mensajes Mensajes: 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 el mensaje fue enviado POINT pt; // posición del cursor en coordenadas de pantalla MSG, *PMSG; Todos los mensajes que envía windows empiezan por WM_XXX y están definidos en windows.h 14

GetMessage GetMessage: Espera a que llegue un 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. 15

DispatchMessage MSG hwnd=h DispatchMessage instancias de ventana hinstance=h lpclassname = CN hinstance=h1 lpclassname = CN hinstance=h2 lpclassname = CN2 hinstance=h3 lpclassname=cn3 WNDCLASS lpszclassname = CN lpfnwndproc=proc lpszclassname = CN2 lpfnwndproc=proc2 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 wparam, LPARAM lparam){.. (HANDLE hwnd, UINT mensaje, WPARAM wparam, LPARAM lparam){.. (HANDLE hwnd, UINT mensaje, WPARAM wparam, 16 LPARAM lparam){..

Handles Un identificador para los distintos objetos: 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( { HDC hdc; // Device context // HANDLE hwnd, UINT mensaje, WPARAM wparam, LPARAM lparam) 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: BCDIC (6 bits->64 caracteres). ~1950: ASCII (7 bits->128 caracteres). ASCII extendido (8 bits->256 caracteres). páginas de códigos regionales para los últimos 128. DBCS: los primeros 128 bytes igual que ASCII, los posteriores ocupan dos bytes. Unicode: i d 16 bits (65536 caracteres). Sistema de doble anchura (wide char). 19

Caracteres Unicode Tipo de datos wchar_t. Ej.: wchar_t nombre[50]=l Bjarne Stroustrup. 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 Tipo de Dato Prefijo char c DWORD(unsigned long) dw BYTE(unsigned char) by BOOL(int) o Flag b ó f short n Handle h int i Puntero p int cuando indica coordenadas x, y Función fn int cuando indica dimensiones cx, cy Cadena s WORD (unsigned int) w Cadena terminada en \0 sz LONG (long) l

El API de Windows Llamadas al sistema operativo, almacenadas en 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. En algunas plataformas el win32 (p. ej. CE) no está implementada en su totalidad. Win32: CreateWindow(), RegisterClass(), ShowWindow(), UpdateWindow(), DrawText(), etc. 22

Win32 Varias categorías de funciones: Administración de ventanas (en user32.dll) Crear y administrar la GUI, despachar mensajes, administrar ventanas, DDE. Ej.: CreateWindow(), RegisterClass(), ShowWindow() Graphics Device Interface (GDI). Generar salidas en distintos t dispositivos: iti pantalla, impresora. P.ej.: dibujar objetos. Ej.: BeginPaint(), GetClientRect(), DrawText(), EndPaint(). Media Control Interface (MCI). Reproducir y Grabar Audio, uso de vídeo, control de dispositivos multimedia. Servicios i del Sistema. 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 a las apliciones 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. Introducción. Ventana vacía sin el wizard. Uso del wizard. Un vistazo a las clases de MFC. Mapas de Mensajes. Menús y Teclas Aceleradoras. Diálogos Comunes. Controles. Clases de utilidad Arquitectura Documento/Vista. Aspectos avanzados de las MFCs. Bibliografía. 25

Microsoft Foundation Classes El API para la programación directa de aplicaciones i Windows da acceso total a la funcionalidad del sistema operativo, pero es de bajo nivel. MFC es un framework que ofrece una serie de funciones, 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

#include "stdafx.h" #include <afxwin.h> // MFC core and standard d components Creación de una #include <afxext.h> // MFC extensions // proyecto con Shared DLL Ventana en Blanco sin #ifdef _DEBUG #define new DEBUG_NEW #endif el wizard class CMainFrame : public CFrameWnd { public: CMainFrame() { Create(NULL, _T("Hellow World Application")); // suele ir en OnCreate() ; // se suele llamar a LoadFrame class HelloWorldApp : public CWinApp { public: virtual BOOL InitInstance(); t ; HelloWorldApp theapp; // Declarar un unico objecto CWinApp BOOL HelloWorldApp::InitInstance() { CWinApp::InitInstance(); SetRegistryKey(_T("Hello y(_ ( World Application")); CMainFrame* pframe = new CMainFrame; if (!pframe) return FALSE; m_pmainwnd = pframe; pframe->showwindow(sw_show); pframe->updatewindow(); 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. 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? Definición i ió de nombres de los 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. 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 128 #define IDR_HelloMFCsTYPE 129 37

Uso del Asistente Estructura de la Aplicación WinMain(): 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. Si no hay mensajes, llama a onidle(), vacía por defecto. 38

39 Secuencia de Creación de una Aplicación

Uso del Asistente Estructura de la Aplicación: La clase ventana (CWnd) Casi todas las aplicaciones i tienen una o más ventanas. 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 ser NULL. Si la ventana es la principal, i usar CreateWindowEx(). nid: Identificador de la ventana. pcontext: t Puntero a un objeto de tipo CCreateContext, 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) CWnd agrupa acciones que se podían realizar sobre ventanas. Las hace más accesibles y seguras. Evita por ejemplo tener que pasar el handle como primer parámtero (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 Hereda de CWnd, es utilizado en aplicaciones i SDI. Tiene en su interior una ventana hija que normalmente será la ventana principal de la aplicación. La ventana marco interacciona con el usuario cambiando el 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ú, 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_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. 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 HWND HDC HMENU HPEN, HBRUSH, HFONT, HBITMAP, HPALETTE, HRGN HIMAGELIST SOCKET Clase de Objeto CWnd y derivadas CDC y derivadas CMenu CGdiObject CImageList 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_MESSAGE_MAP(). MAP(). Declaramos también los métodos que manejarán los mensajes mediante afx_msg: class CMainFrame : public CFrameWnd { public: CMainFrame(); protected: DECLARE_DYNAMIC(CMainFrame) DYNAMIC(CM // Funciones de asignación de mensajes generadas protected: afx_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 que definir el mapa de mensajes, 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_MSG_MAP MAP END_MESSAGE_MAP() Usado por versiones anteriores de Visual C++ Los mensajes no referenciados en la tabla se pasan a la clase 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: archivo de encabezado principal para la aplicación HelloMFCs #pragma once #ifndef AFXWIN_H #error "incluir 'stdafx.h h' antes de incluir este archivo para 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_MESSAGE_MAP() MAP() ; extern CHelloMFCsApp theapp; 46

#include "stdafx.h" #include "HelloMFCs.h" #include "MainFrm.h Uso del Asistente #ifdef _DEBUG #define new DEBUG_NEW #endif BEGIN_MESSAGE_MAP(CHelloMFCsApp, CWinApp) ON_COMMAND(ID_APP_ABOUT, &CHelloMFCsApp::OnAppAbout) END_MESSAGE_MAP() Código Generado: HelloMFCs.cpp (i) 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( y(_ T("Aplicaciones generadas con el Asistente para aplicaciones local")); CMainFrame* pframe = new CMainFrame; if (!pframe) return FALSE; m_pmainwnd = pframe; // Crear y cargar el marco con sus recursos pframe->loadframe(idr_mainframe, WS_OVERLAPPEDWINDOW FWS_ADDTOTITLE, 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 // para el comando Acerca de Uso del Asistente class CAboutDlg : public Cdialog { public: CAboutDlg(); // Datos del cuadro de diálogo enum { IDD = IDD_ABOUTBOX ; protected: Código Generado: HelloMFCs.cpp (ii) virtual void DoDataExchange(CDataExchange* g pdx); // Compatibilidad con DDX/DDV // Implementación protected: DECLARE_MESSAGE_MAP() ; CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) { void CAboutDlg::DoDataExchange(CDataExchange* g g pdx) { CDialog::DoDataExchange(pDX); BEGIN_ MESSAGE_ MAP(CAboutDlg, CDialog) END_MESSAGE_MAP() // Comando de la aplicación para ejecutar el cuadro de diálogo void CHelloMFCsApp::OnAppAbout() { CAboutDlg aboutdlg; aboutdlg.domodal(); 48

#pragma once #include "ChildView.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) DYNAMIC(CMainFrame) RUNTIME_CLASS en la arquitectura t // Reemplazos documento/vista) public: virtual BOOL PreCreateWindow(CREATESTRUCT& cs); virtual BOOL OnCmdMsg(UINT nid, int ncode, void* pextra, AFX_CMDHANDLERINFO CMDHANDLERINFO* phandlerinfo); // Implementación public: virtual ~CMainFrame(); #ifdef _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 m_wndview; // Funciones de asignación de mensajes generadas protected: afx_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_NEW #endif Uso del Asistente Código Generado: MainFrm.cpp (i) IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd) BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) ON_WM_CREATE() ON_WM_SETFOCUS() END_MESSAGE_MAP() static UINT indicators[] = {ID_SEPARATOR, ID_INDICATOR_CAPS, INDICATOR CAPS, ID_INDICATOR_NUM, INDICATOR NUM, ID_INDICATOR_SCRL, INDICATOR ; // 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(!cframewnd::precreatewindow(cs) C Wi d ) return FALSE; // TODO: modificar aquí la clase Window o los estilos cambiando CREATESTRUCT cs cs.dwexstyle &= ~WS_EX_CLIENTEDGE; cs.lpszclass = AfxRegisterWndClass(0); return TRUE; #ifdef f _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, dm ( ncode, pextra, phandlerinfo)) return TRUE; // De lo contrario, proceder con el control predeterminado 51 return CFrameWnd::OnCmdMsg(nID, ncode, pextra, phandlerinfo);

Uso del Asistente Código Generado: ChildView.h // ChildView.h: 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() 52

#include "stdafx.h" #include "HelloMFCs.h" #include "ChildView.h" Uso del Asistente Código Generado: ChildView.cpp #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; cs.dwexstyle = WS_EX_CLIENTEDGE; _ cs.style &= ~WS_BORDER; cs.lpszclass = AfxRegisterWndClass(CS_HREDRAW CS_VREDRAW CS_DBLCLKS, ::LoadCursor(NULL, IDC_ARROW), reinterpret_cast<hbrush>(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, 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. ReportError(): muestra la excepción en una ventana. GetErrorMessage(): descripción del error. Gestión de archivos: CFile. Contextos de dispositivo: CDC e hijas: Acceso al área completa de la ventana: CWindowDC. Dibujo en función del evento WM_PAINT: CPaintDC. Gestión de Objetos Gráficos: CGdiObject. Gestión de fuentes de letras: CFont. Gestión de mapas de bits de colores: CBitmap. Uso de Brochas: CBrush. Manejo de plumas: CPen. 56

Las clases MFC CCmdTarget: clase base para la gestión de mensajes. Clases documento: CDocument, con hijas: COleDocument, CHtmlEditDoc, etc. Gestión de comunicaciones OLE: COleObjectFactory, COleDataSource, COleDropTarget, etc. CWnd: Gestión de ventanas. CFrameWnd e hijas (ventana principal). CSplitterWnd (paneles de ventana). CControlBar (gestión de barras de control y estado): CToolBar, CStateBar, CReBar, CDialogBar. CDialog: gestión de ventanas de 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 Documento/Vista: CView. CEditView: Edición de textos. CHtmlView: Visualización de páginas HTML. Controles (heredan de CWnd): Texto estático (CStatic). Texto modificable (CEdit). Listas de elementos: CListBox, CCheckListBox, CDrawListBox, etc. Clases que no heredan de CObject: Clases de soporte (ej.: CWaitCursor), API servidor de Internet, sincronización, etc. 58