Newsgroup: it.comp.programmare.win32
Titolo: Aggiungere un menu con visual studio

Ho fatto una applicazione win32 senza mfc e volevo aggiungere un semplice
menu.
Ho creato una risorsa con Insert->Resource e ho creato il menu poi ho
salvato il menu in un file menu.rc.
Il file menu.rc al suo interno include il file resource.h dove sono definiti
le id del
menu.
Poi includo al mio progetto il file resource.h e
nella winmain quando definisco la classe finestra aggiungo il nome del menu
al campo del lpszMenuName.
Compilo il tutto ma quando eseguo l'applicazione il menu non c'e'.
Di fatto pero' ho notato che quando faccio un rebuild all il file .rc non
viene compilato, l'ho compilato separatamente e il file res non contiene
errori, ma il menu non se vede.
Grazie, e scusate la banalita' del post ma per me è importate.
Ciao.

usa LoadMenu() e SetMenu()
--
ciao
xaero


Si cosi' funziona, grazie.
Sai anche come mai quando apro il menu si nota che lo schermo viene
ridisegnato e come aggiungere ai sottomenu l'effetto
di selezione/deselezione.
Ciao.

 di selezione/deselezione.
a me non succede. posta il codice così vediamo.
per selezione/deselezione che intendi? i check a sx degli item?
se è così prova questo codice:
HMENU hMenuu = GetMenu(hWnd);
CheckMenuItem(hMenu, IDM_FILE_EXIT, MF_BYCOMMAND | MF_CHECKED);
--
ciao
xaero


ora provo, intanto posto il codice.
Premetto che so pochissimo di win32 e che fino ad adesso ho programmato
usando la libreria  glut
di opengl, ma il mio obbiettivo e' trasformare il mio progetto su console in
un applicazione per win32 con un po' di interfaccia.
Il codice:
#include "stdafx.h"
#include <windows.h>
#include "3dsftk.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include "Texture.h"
#include "BSP.h"
#include "camera.h"
#include "Mesh.h"
#include "World.h"
#include "resource.h"
#include <afxres.h>
char *className = "OpenGL";
char *windowName = "OpenGL Cube";
int winX = 0, winY = 0;
int winWidth = 256, winHeight = 256;
float Tangente[360];
float Coseno[360];
float Seno[360];
World W("mappa.3ds","cmap.3ds");
GLfloat light_position[] = {100 ,200, 50.0,0.0};
HDC hDC;
HGLRC hGLRC;
HPALETTE hPalette;
void init(){
   Calcola_sin_cos();
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_SMOOTH);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_CULL_FACE);
   glEnable(GL_NORMALIZE);
   // Visualizzazione corretta della profondita'
   glEnable(GL_DEPTH_TEST);
   W.Init();
   W.BuildWorld("Camera","cmap");
}
void redraw(void)
{
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
  // Setting Camera
   glLightfv(GL_LIGHT0,GL_POSITION,light_position);
   W.Control();// gestione dei tasti
   glPushMatrix();
   W.Draw(); // Disegna la scena
   glPopMatrix();
   SwapBuffers(hDC);
   glFinish();
}
void resize(void)
{
    /* set viewport to cover the window */
    glViewport(0, 0, (GLsizei) winWidth, (GLsizei) winHeight);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
    gluPerspective(W.Cam.fov,(GLfloat) winWidth/(GLfloat)
winHeight,W.Cam.near_plane,W.Cam.far_plane);
}
void setupPixelFormat(HDC hDC){
    PIXELFORMATDESCRIPTOR pfd = {
 sizeof(PIXELFORMATDESCRIPTOR), /* size */
 1,    /* version */
 PFD_SUPPORT_OPENGL |
 PFD_DRAW_TO_WINDOW |
 PFD_DOUBLEBUFFER,  /* support double-buffering */
 PFD_TYPE_RGBA,   /* color type */
 24,    /* prefered color depth */
 0, 0, 0, 0, 0, 0,  /* color bits (ignored) */
 0,    /* no alpha buffer */
 0,    /* alpha bits (ignored) */
 0,    /* no accumulation buffer */
 0, 0, 0, 0,   /* accum bits (ignored) */
 24,    /* depth buffer */
 0,    /* no stencil buffer */
 0,    /* no auxiliary buffers */
 PFD_MAIN_PLANE,   /* main layer */
 0,    /* reserved */
 0, 0, 0,   /* no layer, visible, damage masks */
    };
    int pixelFormat;
    pixelFormat = ChoosePixelFormat(hDC, &pfd);
    if (pixelFormat == 0) {
 MessageBox(WindowFromDC(hDC), "ChoosePixelFormat failed.", "Error",
  MB_ICONERROR | MB_OK);
 exit(1);
    }
    if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE) {
 MessageBox(WindowFromDC(hDC), "SetPixelFormat failed.", "Error",
  MB_ICONERROR | MB_OK);
 exit(1);
    }
}
void
setupPalette(HDC hDC)
{
    int pixelFormat = GetPixelFormat(hDC);
    PIXELFORMATDESCRIPTOR pfd;
    LOGPALETTE* pPal;
    int paletteSize;
    DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR),
&pfd);
    if (pfd.dwFlags & PFD_NEED_PALETTE) {
 paletteSize = 1 << pfd.cColorBits;
    } else {
 return;
    }
    pPal = (LOGPALETTE*)
 malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
    pPal->palVersion = 0x300;
    pPal->palNumEntries = paletteSize;
    /* build a simple RGB color palette */
    {
 int redMask = (1 << pfd.cRedBits) - 1;
 int greenMask = (1 << pfd.cGreenBits) - 1;
 int blueMask = (1 << pfd.cBlueBits) - 1;
 int i;
 for (i=0; i<paletteSize; ++i) {
     pPal->palPalEntry[i].peRed =
      (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
     pPal->palPalEntry[i].peGreen =
      (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
     pPal->palPalEntry[i].peBlue =
      (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
     pPal->palPalEntry[i].peFlags = 0;
 }
    }
    hPalette = CreatePalette(pPal);
    free(pPal);
    if (hPalette) {
 SelectPalette(hDC, hPalette, FALSE);
 RealizePalette(hDC);
    }
}
LRESULT APIENTRY
WndProc(
    HWND hWnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (message) {
 case WM_CREATE:
 /* initialize OpenGL rendering */
 hDC = GetDC(hWnd);
 setupPixelFormat(hDC);
 setupPalette(hDC);
 hGLRC = wglCreateContext(hDC);
 wglMakeCurrent(hDC, hGLRC);
 init();
 return 0;
    case WM_DESTROY:
 /* finish OpenGL rendering */
 if (hGLRC) {
     wglMakeCurrent(NULL, NULL);
     wglDeleteContext(hGLRC);
 }
 if (hPalette) {
     DeleteObject(hPalette);
 }
 ReleaseDC(hWnd, hDC);
 PostQuitMessage(0);
 return 0;
    case WM_SIZE:
 /* track window size changes */
 if (hGLRC) {
     winWidth = (int) LOWORD(lParam);
     winHeight = (int) HIWORD(lParam);
     resize();
     return 0;
 }
    case WM_PALETTECHANGED:
 /* realize palette if this is *not* the current window */
 if (hGLRC && hPalette && (HWND) wParam != hWnd) {
     UnrealizeObject(hPalette);
     SelectPalette(hDC, hPalette, FALSE);
     RealizePalette(hDC);
     redraw();
     break;
 }
 break;
    case WM_QUERYNEWPALETTE:
 /* realize palette if this is the current window */
 if (hGLRC && hPalette) {
     UnrealizeObject(hPalette);
     SelectPalette(hDC, hPalette, FALSE);
     RealizePalette(hDC);
     redraw();
     return TRUE;
 }
 break;
    case WM_KEYDOWN:
 W.UpdatekeyDown(wParam);
 break;
 case WM_KEYUP:
 W.UpdatekeyUp(wParam);
 break;
 case WM_COMMAND:
  switch(LOWORD(wParam)){
  case ID_FILE_EXIT:exit(0);break;
  case ID_VIEW_WIREFRAME:
   glDisable(GL_LIGHTING);
   glPolygonMode(GL_FRONT,GL_LINE);
  break;
  case ID_VIEW_SMOOTH:
   glEnable(GL_LIGHTING);
   glPolygonMode(GL_FRONT,GL_FILL);
  break;
  }
 break;
 case WM_PAINT:
 {
 if (hGLRC) {
 redraw();
 }
 return 0;
 }
 break;
    case WM_CHAR:
 /* handle keyboard input */
 switch ((int)wParam) {
 case VK_ESCAPE:
     DestroyWindow(hWnd);
     return 0;
 default:
     break;
 }
 break;
    default:
 break;
    }
    return DefWindowProc(hWnd, message, wParam, lParam);
}
int APIENTRY
WinMain(
    HINSTANCE hCurrentInst,
    HINSTANCE hPreviousInst,
    LPSTR lpszCmdLine,
    int nCmdShow)
{
    WNDCLASS wndClass;
    HWND hWnd;
    MSG msg;
    /* register window class */
    wndClass.style = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc = WndProc;
    wndClass.cbClsExtra = 0;
    wndClass.cbWndExtra = 0;
    wndClass.hInstance = hCurrentInst;
    wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndClass.lpszMenuName = NULL;
    wndClass.lpszClassName = className;
    wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
 RegisterClass(&wndClass);
    /* create window */
    hWnd = CreateWindow(
 className, windowName,
 WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
 winX, winY, winWidth, winHeight,
 NULL, NULL, hCurrentInst, NULL);
 HMENU menu=LoadMenu(hCurrentInst,MAKEINTRESOURCE(IDR_MENU1));
 SetMenu(hWnd,menu);
 /* display window */
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    /* process messages */
    while (GetMessage(&msg, NULL, 0, 0) == TRUE) {
 TranslateMessage(&msg);
 DispatchMessage(&msg);
    }
    return msg.wParam;
}