google.com, pub-1013500553222423, DIRECT, f08c47fec0942fa0 Ir al contenido principal

Programación Gráfica CAPITULO 2

Creación de una ventana Windows. 

Comenzamos con nuestro primer tutorial en el que veremos cómo crear una simple ventana Windows con un texto.


A continuación se muestra el código fuente del primer tutorial, en el que se muestra como crear una ventana en Windows. El código está comentado y no voy a entrar en detalles sobre la programación Windows, sólo os diré que todo está basado en el envío y recepción de mensajes. Un mensaje es cómo Windows trata los diferentes eventos que ocurren en el sistema.
Con lo cual para tratar los eventos, se declara una función gestora de Eventos/Mensajes WindowProc, con el especificador CALLBACK lo que quiere decir que dicha función es llamada por Windows, nosotros no decidimos en qué momento se ejecuta. Esta función, trata TODOS los mensajes de las ventanas creadas a partir de un tipo de ventana definida en la estructura WNDCLASSEX. En esta estructura, en el campo lpfnWndProc se le dice el nombre de la función que tratará los mensajes.
Mediante la función RegisterClassEx se declara un tipo de ventana que la identificaremos mediante un nombre, en nuestro caso mediante WINDOW_CLASS_NAME. Al crear una ventanta mediante CreateWindow se especifica a qué clase de ventana pertenece y de esta forma los mensajes (eventos) de esta ventana serán tratados por la función gestora de mensajes asociada a esa clase de ventana.

    #include 
    #include "resource.h"

    #define WINDOW_WIDTH        640
    #define WINDOW_HEIGHT       480
    #define BPP                 32      // Bits por pixel.

    #define WINDOW_CLASS_NAME   "MY_WINDOWS_CLASS"
    #define WINDOW_TITLE        "Tutorial 01 - Creación de una ventana Windows."

    bool g_bFullScreen;                 // Si está a pantalla completa.


    ///////////////////////////////////////////////////////////////////////////////
    ///     ShowError: Muestra un mensaje de error de Windows.
    ///
    ///     @param  int errorCode: Código de error cuyo mensaje mostraremos.
    ///
    ///     @return  nada
    ///////////////////////////////////////////////////////////////////////////////
    void ShowError(int errorCode)
    {
        LPTSTR msgError;
        DWORD  dwBufferLength;

        if ( errorCode != 0 )
        {
            dwBufferLength= FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                           FORMAT_MESSAGE_FROM_SYSTEM,
                                           NULL, errorCode,
                                           GetSystemDefaultLangID(),
                                           (LPTSTR) &msgError,
                                           0, NULL );
            if (dwBufferLength)
            {
                MessageBox(NULL,msgError,"Error:",MB_ICONERROR);
                LocalFree(msgError);
            }
        }
    }


    ///////////////////////////////////////////////////////////////////////////////
    ///     WindowProc: Procedimiento gestor de mensajes de la ventana.
    ///
    ///     @param  HWND hWnd: Handle de la ventana.
    ///     @param  UINT msg:  Mensaje recibido por la ventana.
    ///     @param  WPARAM wParam: Parte alta del parámtro recibido.
    ///     @param  LPARAM lParam: Parte baja del parámtro recibido.
    ///
    ///     @return  LRESULT CALLBACK: Valor retornado en función del mensaje procesado.
    ///////////////////////////////////////////////////////////////////////////////
    LRESULT CALLBACK WindowProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
    {
        switch( msg )
        {
            case WM_KEYDOWN:
                switch ( wParam )
                {
                    // Si se pulsa la tecla de escape.
                    case VK_ESCAPE:
                        SendMessage( hWnd, WM_CLOSE, 0L, 0L );  // Enviamos un mensaje WM_CLOSE
                        break;
                }
                return 0;

            case WM_KEYUP:
                return 0;

            case WM_MOVE:
                return 0;

            case WM_SIZE:
                return 0;

            case WM_MOUSEMOVE:
            case WM_LBUTTONDOWN:
            case WM_LBUTTONUP:
            case WM_RBUTTONDOWN:
            case WM_RBUTTONUP:
            case WM_MBUTTONDOWN:
            case WM_MBUTTONUP:
                return 0;

            case WM_SYSCOMMAND:
                switch (wParam)
                {
                    case SC_SCREENSAVE:
                    case SC_MONITORPOWER:
                        if ( g_bFullScreen )
                            return 0;   // No permitimos que salte el salvapantallas, ni el ahorro de energía.
                    default:
                        return DefWindowProc (hWnd, msg, wParam, lParam);
                }
                break;

            case WM_PAINT:
            {
                HDC         hdc;
                PAINTSTRUCT ps;

                hdc= BeginPaint( hWnd, &ps );

                TextOut ( hdc, 10, 5, "HOLA A TODOS...", strlen("HOLA A TODOS...") ) ;

                EndPaint( hWnd, &ps );

            }   return 0 ;


            case WM_CLOSE:
                DestroyWindow( hWnd );  // Enviamos un mensaje WM_DESTROY
                return 0;

            case WM_DESTROY:
                // Si estaba a pantalla completa, hay restaurar la resolución del escritorio.
                if ( g_bFullScreen )
                    ChangeDisplaySettings(NULL,0);

                PostQuitMessage(0);     // Enviamos un mensaje WM_QUIT
                return 0;

            default:
                return DefWindowProc( hWnd, msg, wParam, lParam );
        }
        return 0;
    }


    ///////////////////////////////////////////////////////////////////////////////
    ///     WinMain: Punto de entrada de la aplicación.
    ///
    ///     @param  HINSTANCE hInstance: Instancia.
    ///     @param  HINSTANCE hPrevInstance: Instancia anterior.
    ///     @param  LPSTR     lpCmdLine: Línea de comandos.
    ///     @param  int       nCmdShow: Cómo se mostrar la ventana (minimizada, maximizada...)
    ///
    ///     @return  int WINAPI: código devuelto por msg.wParam.
    ///////////////////////////////////////////////////////////////////////////////
    int WINAPI WinMain( HINSTANCE   hInstance,
                        HINSTANCE   hPrevInstance,
                        LPSTR       lpCmdLine,
                        int         nCmdShow)
    {
        WNDCLASSEX  winClass;
        HWND        hWnd;
        MSG         msg      = {0};
        int         codError =  0;

        DWORD       dwExStyle, dwStyle;
        POINT       windowPosition;

        try
        {
            // ¿FullScreen?
            if ( MessageBox( NULL, "¿Deseas ejecutar a pantalla completa?", "PREGUNTA:", MB_ICONQUESTION | MB_YESNO) == IDYES)
                g_bFullScreen= true;
            else
                g_bFullScreen= false;

            // Registramos la clase de ventana
            winClass.lpszClassName = WINDOW_CLASS_NAME;
            winClass.cbSize        = sizeof(WNDCLASSEX);
            winClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
            winClass.lpfnWndProc   = WindowProc;
            winClass.hInstance     = hInstance;
            winClass.hIcon         = LoadIcon  ( hInstance, MAKEINTRESOURCE(IDI_APP_ICON) );
            winClass.hIconSm       = LoadIcon  ( hInstance, MAKEINTRESOURCE(IDI_APP_ICON) );
            winClass.hCursor       = LoadCursor( NULL, IDC_ARROW );
            winClass.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
            winClass.lpszMenuName  = NULL;
            winClass.cbClsExtra    = 0;
            winClass.cbWndExtra    = 0;

            if( !RegisterClassEx(&winClass) )
                throw GetLastError();

            RECT desktopRect;
            GetWindowRect( GetDesktopWindow(), &desktopRect );

            if ( g_bFullScreen )
            {
                dwExStyle= WS_EX_TOPMOST;
                dwStyle  = WS_POPUP | WS_VISIBLE;
                windowPosition.x= 0;
                windowPosition.y= 0;
            }
            else
            {
                dwExStyle= WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
                dwStyle  = WS_OVERLAPPEDWINDOW;
                windowPosition.x= (desktopRect.right  - WINDOW_WIDTH )/2;
                windowPosition.y= (desktopRect.bottom - WINDOW_HEIGHT)/2;
            }

            // Creamos la ventana
            hWnd = CreateWindowEx( dwExStyle, WINDOW_CLASS_NAME, WINDOW_TITLE,
                                   dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                                   windowPosition.x, windowPosition.y,
                                   WINDOW_WIDTH, WINDOW_HEIGHT,
                                   NULL, NULL, hInstance, NULL );
            if( hWnd == NULL )
                throw GetLastError();

            // Mostramos la ventana.
            ShowWindow( hWnd, nCmdShow );

            // Forzamos el repintado.
            UpdateWindow( hWnd );

            // si es a pantalla completa, hay que cambiar la resolución del escritorio
            if ( g_bFullScreen )
            {
                DEVMODE dmScreenSettings;
                memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
                dmScreenSettings.dmSize         =   sizeof(dmScreenSettings);
                dmScreenSettings.dmPelsWidth    =   WINDOW_WIDTH;
                dmScreenSettings.dmPelsHeight   =   WINDOW_HEIGHT;
                dmScreenSettings.dmBitsPerPel   =   BPP;
                dmScreenSettings.dmFields       =   DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

                if ( ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL )
                    throw GetLastError();

                SetForegroundWindow(hWnd);  // Situamos la ventana en primer plano
            }
            SetFocus(hWnd);                 // Obtenemos el foco

            // Bucle principal
            while( msg.message != WM_QUIT )
            {
                if( GetMessage(&msg,NULL,0,0) )
                {
                    TranslateMessage( &msg );
                    DispatchMessage ( &msg );
                }
            }

            codError= msg.wParam;
        }
        catch (DWORD errorCode)
        {
            ShowError( errorCode );
            codError= (int)errorCode;
        }

        // Desregistramos la clase de ventana.
        UnregisterClass( WINDOW_CLASS_NAME, winClass.hInstance );

        return codError;
    }

copias y pegas

Comentarios

Entradas populares de este blog

Audaces vestuario 7.0 [Español] [Moda]

Archivo 95 mb aprox idioma español Requisitos WinXP El sistema Audaces Vestuario es la solución para la industria de la confección, desarrollado especialmente para agilizar los procesos de Diseño, Escalado, Trazo y Corte. Se compone de dos módulos, uno de Patrones y uno de Trazo. Patrones Audaces Patrones es un modulo realmente fácil de utilizar. El diseñador crea los moldes directamente en la pantalla del computador,sin uso de la mesa digitalizadora, de una forma rapida y eficiente,usando las innumerables herramientas de diseño disponibles.Adicionalmente, proporcionara la creación de moldes base dentro de los estándares técnicos de la industria, o sea con tablas de medidas,áreas de costura acondicionadas a los equipos de producción, estudios de encogimientos, etc. Escalado En Audaces Patrones se escalan los moldes con facilidad, precisión rapidez y seguridad. Trazo Audaces Trazo elabora Trazos con excelente aprovechamiento en pocos minutos. A través del Trazo automático, y pe

3DS Max 2009 + Modelos 3D Max

es un poco pesado 1.66  Gb , pero vale la pena, ademas de ser curso para el 3dmax 2009, no es la ultima version pero se ve muy bien.  INTERCAMBIABLES http://www.storage.to/get/oSKa4RUI/Curso3dsMx2009byultrablanco85.part01.rar   http://www.storage.to/get/cU6pomba/Curso3dsMx2009byultrablanco85.part02.rar   http://www.storage.to/get/zUEodx6k/Curso3dsMx2009byultrablanco85.part03.rar   http://www.storage.to/get/aOKZ8jSl/Curso3dsMx2009byultrablanco85.part04.rar   http://www.storage.to/get/xcEWst5k/Curso3dsMx2009byultrablanco85.part05.rar   http://www.storage.to/get/PMNryNdS/Curso3dsMx2009byultrablanco85.part06.rar   http://www.storage.to/get/g4N2WmTb/Curso3dsMx2009byultrablanco85.part07.rar   http://www.storage.to/get/ONYl2qzI/Curso3dsMx2009byultrablanco85.part08.rar   http://www.storage.to/get/ENgVT10L/Curso3dsMx2009byultrablanco85.part09.rar   http://rapidshare.com/files/290793282/Curso3dsMx2009byultrablanco85.part01.rar   http://rapidshare.com/files/290790014/Curso3dsMx2009byultra

Casa V / Plan B

Vista aérea Ubicación:  Urbanización Aposentos, Sabana de Bogotá, Colombia Arquitectos: Plan B Arquitectos (Felipe Mesa) + Giancarlo Mazzanti Arquitectos Colaboradores:  Viviana Peña, Jose Orozco, Jaime Borbón, Andrés Sarmiento, Juan Pablo Buitrago Constructor:  Jaime Pizarro Ingeniero Calculista:  Nicolás Parra Diseño:  2006-2007 Construcción:  2008-2009 AnigraficS3D © Rodrigo Dávila Casa para disfrutar de un jardín nativo y de la vista lejana de un humedal. Municipio de Sopó, en cercanías a Bogotá. a. Riesgos Desplegar la casa a lo largo de la alta inclinación del solar, evitando la presencia volumétrica en favor de una extensión horizontal ramificada. Vincular la configuración molecular deformable del vidrio con la disposición geométrica de la casa. Ensayos Vidrios Esquemas b. Geometría La estructura molecular del vidrio, flexible, deformable y modular definirá la estrategia geométrica de la planta y de las transformaciones que ocurren en el proceso de diseño. Los hec