Explication de code : code généré par l'Assistant dans les projets Smart Device Visual C++

Article
08/21/2008

Mise à jour : novembre 2007

Les fonctions et les Assistant de Visual C++ simplifient la plupart des tâches banales permettant la génération des applications Smart Device multiplateformes, des fichiers de configuration et des fichiers projet. Cette procédure pas à pas décrit le code généré automatiquement par l'Assistant Application Smart Device Windows 32 (1.0). Ainsi, vous pouvez développer et modifier facilement les applications Windows en fonction de vos besoins.

Code généré par l'Assistant pour une application Smart Device Windows 32

Si vous êtes familiarisé avec la programmation Windows (win32) pour les ordinateurs de bureau, ce code peut facilement détecter les principaux programmes courants générés pour vous par l'Assistant.

Dans une application Smart Device Windows classique, l'entrée principale se trouve dans le fichier <nomdevotreprojet>.cpp. Un exemple de ce fichier suit.

Vous pouvez rapidement voir que l'application a les fonctionnalités principales suivantes :

Fonction WinMain
Fonction MyRegisterClass
Fonction InitInstance
Fonction About Dialog

Chacune de ces fonctions est illustrée dans les exemples suivants :

Fonction WinMain : int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow). Pour plus d'information, consultez WinMain, fonction.

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

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

Plateformes Win32. Pour plus d'informations, consultez Windows Platforms (CRT).

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

Boucles de message. Pour plus d'informations, consultez 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 fonction MyRegisterClass enregistre l'application à fenêtres.

//  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) Pour plus d'informations, consultez InitInstance Member Function.

WIN32_PLATFORM_WFSP est utilisé comme condition pour Smartphone et WIN32_PLATFORM_PSPC pour Pocket PC. Vous pouvez toujours définir vos propres conditions pour établir une différentiation supplémentaire.

// 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;
}

Une boîte de dialogue À propos de est également générée pour votre application afin d'illustrer la génération d'autres boîtes de dialogue éventuellement nécessaires : 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

Certains des messages principaux, tels que WM_COMMAND, sont déjà inclus pour vous aider, ainsi qu'à des fins d'extensibilité. WinProc est inclus pour un système de traitement et les messages des entrées d'utilisateur : LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam. . Pour plus d'informations sur WinProc, consultez Vue d'ensemble de 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

Voir aussi

Référence

Général, Outils de périphérique, boîte de dialogue Options

Boîte à outils

Autres ressources

Développement de projets Smart Device Visual C++

Partager via

Explication de code : code généré par l'Assistant dans les projets Smart Device Visual C++

Code généré par l'Assistant pour une application Smart Device Windows 32

Voir aussi

Référence

Autres ressources

Ressources supplémentaires