Spiegazione del codice: codice generato dalla procedura guidata nei progetti per dispositivi Visual C++

Articolo
09/12/2008

Aggiornamento: novembre 2007

Le funzionalità e le procedura guidate di Visual C++ consentono di semplificare la maggior parte delle attività pratiche relative alla generazione di file di configurazione, file di progetto e applicazioni per dispositivi multipiattaforma. Di seguito viene fornita una descrizione del codice generato automaticamente dalla Creazione guidata progetto Win32 per Smart Device per estendere e modificare le applicazioni Windows in base alle proprie esigenze.

Codice generato dalla Creazione guidata progetto Win32 per Smart Device

Coloro che hanno familiarità con la programmazione desktop di Windows (win32) potranno facilmente individuare le principali routine generate automaticamente dalla procedura guidata.

In una tipica applicazione Windows per dispositivi, la voce principale si trova nel file <nomeprogetto>.cpp. Di seguito è riportato un listato di questo file.

Da un primo rapido esame, l'applicazione dispone delle seguenti funzionalità principali:

Funzione WinMain
Funzione MyRegisterClass
Funzione InitInstance
Una About Dialog

Ognuna di queste funzioni è illustrata negli esempi seguenti:

Funzione WinMain: int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow). Per ulteriori informazioni, vedere Funzione WinMain.

int WINAPI WinMain(HINSTANCE hInstance,
                HINSTANCE hPrevInstance,
                LPTSTR    lpCmdLine,
                int       nCmdShow)
{
      MSG msg;

      // Perform application initialization:
      if (!InitInstance(hInstance, nCmdShow)) 
      {
            return FALSE;
      }

Piattaforme Win32. Per ulteriori informazioni, vedere la classe Windows Platforms (CRT).

#ifndef WIN32_PLATFORM_WFSP
        HACCEL hAccelTable;
        hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_WIN32SMARTDEVICE);
#endif // !WIN32_PLATFORM_WFSP

Cicli di messaggi. Per ulteriori informazioni, vedere Message Handling and Command Targets.

        // Main message loop:
        while (GetMessage(&msg, NULL, 0, 0)) 
        {
#ifndef WIN32_PLATFORM_WFSP
            if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
#endif // !WIN32_PLATFORM_WFSP
            {
                  TranslateMessage(&msg);
                  DispatchMessage(&msg);
            }
      }

      return (int) msg.wParam;
}

La funzione MyRegisterClass viene utilizzata per registrare l'applicazione Windows.

//  FUNCTION: MyRegisterClass()
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
      WNDCLASS wc;

      wc.style         = CS_HREDRAW | CS_VREDRAW;
      wc.lpfnWndProc   = (WNDPROC)WndProc;
      wc.cbClsExtra    = 0;
      wc.cbWndExtra    = 0;
      wc.hInstance     = hInstance;
      wc.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32SMARTDEVICE));
      wc.hCursor       = 0;
      wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
      wc.lpszMenuName  = 0;
      wc.lpszClassName = szWindowClass;

      return RegisterClass(&wc);
}

InitInstance: FUNCTION InitInstance(HANDLE, int). Per ulteriori informazioni, vedere InitInstance Member Function.

WIN32_PLATFORM_WFSP viene utilizzata come condizione per Smartphone e WIN32_PLATFORM_PSPC per Pocket PC. È sempre possibile definire istruzioni condizionali personalizzate se si desidera differenziare ulteriormente.

// FUNCTION: InitInstance(HANDLE, int)
// PURPOSE: Saves instance handle and creates main window.
// COMMENTS:
// In this function, we save the instance handle in a global 
// variable and create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
    TCHAR szTitle[MAX_LOADSTRING];        
// title bar text
    TCHAR szWindowClass[MAX_LOADSTRING];  
// main window class name

    g_hInst = hInstance; 
// Store instance handle in your global variable.

#ifdef WIN32_PLATFORM_PSPC
    // SHInitExtraControls should be called once during your application's initialization to initialize any
    // of the Pocket PC special controls such as CAPEDIT and SIPPREF.
    SHInitExtraControls();
#endif // WIN32_PLATFORM_PSPC

    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); 
    LoadString(hInstance, IDC_WIN32SMARTDEVICE, szWindowClass, MAX_LOADSTRING);

#if defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)
    //If it is already running, then focus on the window, and exit.
    hWnd = FindWindow(szWindowClass, szTitle);  
    if (hWnd) 
    {
        // Set the focus to the foremost child window.
        // The "| 0x00000001" is used to bring any owned windows
        //to the foreground and activate them.
        SetForegroundWindow((HWND)((ULONG) hWnd | 0x00000001));
        return 0;
    } 
#endif // WIN32_PLATFORM_PSPC || WIN32_PLATFORM_WFSP

    if (!MyRegisterClass(hInstance, szWindowClass))
    {
      return FALSE;
    }

    hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

    if (!hWnd)
    {
        return FALSE;
    }

#ifdef WIN32_PLATFORM_PSPC
    // When the main window is created using CW_USEDEFAULT, 
    // the height of the menubar is not taken into account. 
    // So the generated code resizes the window after creating it.
    if (g_hWndMenuBar)
    {
        RECT rc;
        RECT rcMenuBar;

        GetWindowRect(hWnd, &rc);
        GetWindowRect(g_hWndMenuBar, &rcMenuBar);
        rc.bottom -= (rcMenuBar.bottom - rcMenuBar.top);

        MoveWindow(hWnd, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, FALSE);
    }
#endif // WIN32_PLATFORM_PSPC

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);


    return TRUE;
}

Viene inoltre generata una finestra di dialogo Informazioni su relativa all'applicazione per illustrare come compilare eventuali altre finestre di dialogo: LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

// win32smartdevice.cpp : Defines the entry point for the application.
#include "stdafx.h"
#include "win32smartdevice.h"
#include <windows.h>
#include <commctrl.h>

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE               g_hInst;                
// Current instance:
HWND                    g_hWndMenuBar;          
// Menu bar handle

// Forward declarations of functions included in this code module:
ATOM              MyRegisterClass(HINSTANCE, LPTSTR);
BOOL              InitInstance(HINSTANCE, int);
LRESULT CALLBACK  WndProc(HWND, UINT, WPARAM, LPARAM);
#ifndef WIN32_PLATFORM_WFSP
LRESULT CALLBACK  About(HWND, UINT, WPARAM, LPARAM);
#endif 
// !WIN32_PLATFORM_WFSP
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//  PURPOSE:  Processes messages for the main window.
//  WM_COMMAND    - process the application menu
//  WM_PAINT      - Paint the main window
//  WM_DESTROY    - post a quit message and return

Alcuni dei messaggi principali, ad esempio WM_COMMAND sono già inclusi per Extensibility. WinProc è inlcuso per un sistema di elaborazione e per i messaggi di input dell'utente: LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam. Per ulteriori informazioni su WinProc, vedere Cenni preliminari su Windows.

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;
        HGDIOBJ  hbrWhite, hbrGray; 
        POINT aptStar[6] = {50,2, 2,98, 98,33, 2,33, 98,98, 50,2}; 

#if defined(SHELL_AYGSHELL) && !defined(WIN32_PLATFORM_WFSP)
    static SHACTIVATEINFO s_sai;
#endif // SHELL_AYGSHELL && !WIN32_PLATFORM_WFSP
    switch (message) 
    {
        case WM_COMMAND:
            wmId    = LOWORD(wParam); 
            wmEvent = HIWORD(wParam); 
            // Parse the menu selections:
            switch (wmId)
            {
#ifndef WIN32_PLATFORM_WFSP
                case IDM_HELP_ABOUT:
                    DialogBox(g_hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
                    break;
#endif // !WIN32_PLATFORM_WFSP
#ifdef WIN32_PLATFORM_WFSP
                case IDM_OK:
                    DestroyWindow(hWnd);
                    break;
#endif // WIN32_PLATFORM_WFSP
#ifndef WIN32_PLATFORM_WFSP
                case IDM_OK:
                    SendMessage (hWnd, WM_CLOSE, 0, 0);                       
                    break;
#endif // !WIN32_PLATFORM_WFSP
                default:
                    return DefWindowProc(hWnd, message, wParam, lParam);
            }
            break;
        case WM_CREATE:
#ifdef SHELL_AYGSHELL
            SHMENUBARINFO mbi;

            memset(&mbi, 0, sizeof(SHMENUBARINFO));
            mbi.cbSize     = sizeof(SHMENUBARINFO);
            mbi.hwndParent = hWnd;
            mbi.nToolBarId = IDR_MENU;
            mbi.hInstRes   = g_hInst;

            if (!SHCreateMenuBar(&mbi)) 
            {
                g_hWndMenuBar = NULL;
            }
            else
            {
                g_hWndMenuBar = mbi.hwndMB;
            }

#ifndef WIN32_PLATFORM_WFSP
            // Initialize the shell activate info structure
            memset(&s_sai, 0, sizeof (s_sai));
            s_sai.cbSize = sizeof (s_sai);
#endif // !WIN32_PLATFORM_WFSP
#endif // SHELL_AYGSHELL
      hbrWhite = GetStockObject(WHITE_BRUSH); 
        hbrGray  = GetStockObject(GRAY_BRUSH); 
        return 0L; 
break;
        case WM_PAINT:
         RECT  rc;
       hdc = BeginPaint(hWnd, &ps); 
       GetClientRect(hWnd, &rc); 
       Polyline(hdc, aptStar, 6); 
       EndPaint(hWnd, &ps); 
       return 0L; 

            break;
        case WM_DESTROY:
#ifdef SHELL_AYGSHELL
            CommandBar_Destroy(g_hWndMenuBar);
#endif // SHELL_AYGSHELL
            PostQuitMessage(0);
            break;

#if defined(SHELL_AYGSHELL) && !defined(WIN32_PLATFORM_WFSP)
        case WM_ACTIVATE:
            // Notify shell of your activate message.
            SHHandleWMActivate(hWnd, wParam, lParam, &s_sai, FALSE);
            break;
        case WM_SETTINGCHANGE:
            SHHandleWMSettingChange(hWnd, wParam, lParam, &s_sai);
            break;
#endif // SHELL_AYGSHELL && !WIN32_PLATFORM_WFSP

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

#ifndef WIN32_PLATFORM_WFSP
// Message handler for about box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_INITDIALOG:
#ifdef SHELL_AYGSHELL
            {
                // Create a Done button and size it.  
                SHINITDLGINFO shidi;
                shidi.dwMask = SHIDIM_FLAGS;
                shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN | SHIDIF_EMPTYMENU;
                shidi.hDlg = hDlg;
                SHInitDialog(&shidi);
            }
#endif // SHELL_AYGSHELL

            return TRUE;

        case WM_COMMAND:
#ifdef SHELL_AYGSHELL
            if (LOWORD(wParam) == IDOK)
#endif
            {
                EndDialog(hDlg, LOWORD(wParam));
                return TRUE;
            }
            break;

        case WM_CLOSE:
            EndDialog(hDlg, message);
            return TRUE;

#ifdef _DEVICE_RESOLUTION_AWARE
        case WM_SIZE:
            {
            DRA::RelayoutDialog(
                  g_hInst, 
                  hDlg, 
                  DRA::GetDisplayMode() != DRA::Portrait ? MAKEINTRESOURCE(IDD_ABOUTBOX_WIDE) : MAKEINTRESOURCE(IDD_ABOUTBOX));
            }
            break;
#endif
    }
    return FALSE;
}
#endif // !WIN32_PLATFORM_WFSP

Vedere anche

Riferimenti

Generale, Strumenti dispositivo, finestra di dialogo Opzioni

Casella degli strumenti

Altre risorse

Sviluppo di progetti Visual C++ per dispositivi

Condividi tramite

Spiegazione del codice: codice generato dalla procedura guidata nei progetti per dispositivi Visual C++

Codice generato dalla Creazione guidata progetto Win32 per Smart Device

Vedere anche

Riferimenti

Altre risorse

Risorse aggiuntive