problems drawing with the mouse

Hello friends
I want to program with windows98 and opengl
In my program, i draw some lines (first, i load this lines with differentes names), and after i prick with the mouse in my windows of opengl.
Then, my program, in “pulsaraton” procedure open a little window beneath the point where i prick (glupickmatrix) with my mouse. And my program should sense if there is any line in this little window. If there is any line, then varying hit=1, but my program don´t sense any line. Why?
I post a copy of my program.
Thank´s for helping.

/*
** Simple Color Index Example
*/

#define STRICT
#define BUFFER_LENGTH 64
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>
#include <stdio.h>
#define A 1
#define B 2
#define C 3
#define D 4
#define E 5
#define F 6

LRESULT APIENTRY WindProc(HWND,UINT,WPARAM,LPARAM);
void pulsaraton (float , float );
void prueba11(GLuint *pselectBuff);

GLfloat x1, y11;
GLfloat aspect;
bool sem, sem1=false, sem2=false, sem3=false, sem4=false, sem5=false, sem6=false;
char *className = “OpenGL”;
char *windowName = “Simple Color Index”;
int winX = 0, winY = 0;
int winWidth = 300, winHeight =300;
HDC hDC;
HGLRC hGLRC;
HPALETTE hPalette;
HINSTANCE hInst;

void (*idleFunc)(void);

/* Struct used to manage color ramps /
struct colorIndexState {
GLfloat amb[3]; /
ambient color / bottom of ramp /
//luz proveniente de todas las direcciones
GLfloat diff[3]; /
diffuse color / middle of ramp /
//luz proveniente de una direccion y apenas rebota.
//Es absorbida por la superficie
GLfloat spec[3]; /
specular color / top of ramp /
//luz proveniente de una direccion y rebota en
//una direccion preferentemente
GLfloat ratio; /
ratio of diffuse to specular in ramp /
GLint indexes[3]; /
where ramp was placed in palette */
};

/*
** Each entry in this array corresponds to a color ramp in the
** palette. The indexes member of each struct is updated to
** reflect the placement of the color ramp in the palette.
*/
#define NUM_COLORS (sizeof(colors) / sizeof(colors[0]))
struct colorIndexState colors[] = {
{
{ 1.0F, 1.0F, 0.0F },
{ 0.1F, 0.6F, 0.3F },
{ 1.0F, 1.0F, 1.0F },
0.00F, { 0, 0, 0 },
},
{
{ 0.0F, 0.0F, 0.0F },
{ 0.0F, 0.2F, 0.5F },
{ 1.0F, 1.0F, 1.0F },
0.75F, { 0, 0, 0 },
},
{
{ 0.0F, 0.05F, 0.05F },
{ 0.6F, 0.0F, 0.8F },
{ 1.0F, 1.0F, 1.0F },
0.75F, { 0, 0, 0 },
},
};

void
drawTorus(void)

{
int i;
if (i & 1) {
glMaterialiv(GL_FRONT, GL_COLOR_INDEXES, colors[0].indexes);
}
else {
glMaterialiv(GL_FRONT, GL_COLOR_INDEXES, colors[1].indexes);
}

glBegin(GL_LINES);
	if (sem) {
	glVertex2f(0, 0);//dibuja las lineas normales
	glVertex2f(3, -1);
	glVertex2f(0, 0);//dibuja las lineas normales
	glVertex2f(1,-3);
	}
glEnd();

glBegin(GL_LINES);
	glVertex2f(0.0, 0.0);
	glVertex2f(x1, y11);

	glInitNames();
	glPushName(0);

	glLoadName(A);
	glVertex2f(0.0, 0.0);
	glVertex2f(2.0, -2.0);

	glLoadName(B);
	glVertex2f(2.0, -2.0);
	glVertex2f(0.0, -2.0);
	
	glLoadName(C);
	glVertex2f(2.0, -2.0);
	glVertex2f(2.0, 0.0);
	
	glLoadName(D);
	glVertex2f(2.0, 0.0);
	glVertex2f(0.0, -0.0);

	glLoadName(E);
	glVertex2f(0.0, 0.0);
	glVertex2f(0.0, -2.0);
	
	glLoadName(F);
	glVertex2f(0.0, -2.0);
	glVertex2f(2.0, 0.0);
glEnd();

glBegin(GL_LINES);
	if (sem1){
	glVertex2f(0.0, 0.0);
	glVertex2f(3.0, -0.0);
	}

	if (sem2){
	glVertex2f(0.0, -1.0);
	glVertex2f(3.0, -1.0);
	}

	if (sem3){
	glVertex2f(0.0, -2.0);
	glVertex2f(3.0, -2.0);
	}

	if (sem4){
	glVertex2f(0.0, -3.0);
	glVertex2f(3.0, -3.0);
	}

	if (sem5){
	glVertex2f(0.0, -0.0);
	glVertex2f(5.0, -9.0);
	}

glEnd();

	glPopMatrix();

return;

}

/*****************************************************************/

void
pulsaraton (float x, float y)
{

GLuint selectBuff[BUFFER_LENGTH];
GLint hits, viewport[4];

glSelectBuffer(BUFFER_LENGTH, selectBuff);
glGetIntegerv(GL_VIEWPORT, viewport);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glRenderMode(GL_SELECT);
glLoadIdentity();
glTranslatef(-1.0, 1.0, 0.0);
gluPickMatrix(x, y, 0.5, 0.5, viewport);
gluPerspective(45.0f, aspect, 1.0, 3.0);
drawTorus();

hits = glRenderMode(GL_RENDER);

if (hits==1);
prueba11(selectBuff);

glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);

}

void
prueba11(GLuint *pselectBuff)
{

int id = pselectBuff[3];
switch(id)
{

case 1:
sem1=true;
break;

case 2:
sem2=true;
break;

case 3:
sem3=true;
break;

case 4:
sem4=true;
break;

case 5:
sem5=true;
break;

case 6:
sem6=true;
break;

}
sem=true;
drawTorus();
return;

}

void
setProjection(void)
{

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glTranslatef(-1.0, 1.0, 0.0);

if (winWidth &gt; winHeight)
aspect = (GLfloat)winWidth / (GLfloat) winHeight;
else 
aspect =  (GLfloat)winHeight / (GLfloat) winWidth;

gluPerspective(45.0f, aspect, 1.0, 3.0);


glMatrixMode(GL_MODELVIEW);

}

void
init(void)
{
GLfloat matShine = 5.00F;
GLfloat light0Pos[4] = { 0.00F, 0.00F, 0.00F, 1.00F };

glClearIndex((GLfloat) colors[2].indexes[1]);//cambia el color del 
											//fondo
//elige el color del fondo en el mode color-index

setProjection();
glTranslatef(0.0F, 0.0F, -2.5F);//translada los objetos
//glTranslatef(TYPE x, TYPE y, TYPE z);
//translada un objeto x unidades en el eje x.....

glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, matShine);
//define las propiedades del material respecto a la luz
//glMaterialf(GLenum face, GLenum pname, TYPE param);
//face puede ser GL_FRONT, GL_BACK, o GL_FRONT_AND_BACK para 
//indicar que cara es aplicada. En pname definimos que propiedad 
//es aplicada, y en param definimos el valor de la propiedad
glLightfv(GL_LIGHT0, GL_POSITION, light0Pos);
//glLightfv(GL_enum light, GLenum pname, TYPE param);
//crea una luz, definida por GLenum que puede ser (GL_LIGHT0, 
//GL_LIGHT1....o GL_LIGHT7).Las caracteristicas de la luz las 
//define pname (puede ser entre otros GL_AMBIENT, GL_DIFUSSE...)
//y el valor de la caracteristica esta en param
glEnable(GL_LIGHT0);


glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);

}

void
doRedraw(void)
{
static GLfloat x, y, z;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glClear(mask) limpia los buffers especificados en mask

glPushMatrix();//mete todas las matrices en curso en el
//primer nivel de la pila


drawTorus();

glPopMatrix();//saca la matriz superior fuera de la pila, 
//destruyendose el contenido de esta matriz. La siguiente 
//matriz pasa a ser la nueva matriz superior

SwapBuffers(hDC);

}

void
redraw(void)
{
idleFunc = doRedraw;
}

void
resize(void)
{
setProjection();
glViewport(0, 0, winWidth, winHeight);
//define una ventana donde son dibujados los objetos
//glViewport(x, y, Width, Height);
//(x, y) el punto inferior-izquierdo
//Width, Height : la altura y anchura de la ventana
}

/*****************************************************************/

void
setupPalette(HDC hDC)
{
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE* pPal;
int pixelFormat = GetPixelFormat(hDC);
int paletteSize;

DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

/*
** Determine if a palette is needed and if so what size.
*/
if (pfd.dwFlags & PFD_NEED_PALETTE | |
	pfd.iPixelType == PFD_TYPE_COLORINDEX) {
paletteSize = 1 &lt;&lt; pfd.cColorBits;
if (paletteSize &gt; 4096) {
    paletteSize = 4096;
}
} else {
return;
}

pPal = (LOGPALETTE*)
malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal-&gt;palVersion = 0x300;
pPal-&gt;palNumEntries = paletteSize;

/*
** Fill the logical palette with color ramps.
**
** Set up the logical palette so that it can be realized
** into the system palette as an identity palette.
**
** 1) The default static entries should be present and at the right
**    location.  The easiest way to do this is to grab them from
**    the current system palette.
**
** 2) All non-static entries should be initialized to unique values.
**    The easiest way to do this is to ensure that all of the non-static
**    entries have the PC_NOCOLLAPSE flag bit set.
*/
{
int numRamps = NUM_COLORS;
int rampSize = (paletteSize - 20) / numRamps;
int extra = (paletteSize - 20) - (numRamps * rampSize);
int i, r;

/*
** Initialize static entries by copying them from the
** current system palette.
*/
GetSystemPaletteEntries(hDC, 0, paletteSize, &pPal-&gt;palPalEntry[0]);

/*
** Fill in non-static entries with desired colors.
*/
for (r=0; r&lt;numRamps; ++r) {
    int rampBase = r * rampSize + 10;
    PALETTEENTRY *pe = &pPal-&gt;palPalEntry[rampBase];
    int diffSize = (int) (rampSize * colors[r].ratio);
    int specSize = rampSize - diffSize;

    for (i=0; i&lt;rampSize; ++i) {
	GLfloat *c0, *c1;
	GLint a;

	if (i &lt; diffSize) {
	    c0 = colors[r].amb;
	    c1 = colors[r].diff;
	    a = (i * 255) / (diffSize - 1);
	} else {
	    c0 = colors[r].diff;
	    c1 = colors[r].spec;
	    a = ((i - diffSize) * 255) / (specSize - 1);
	}

	pe[i].peRed = (BYTE) (a * (c1[0] - c0[0]) + 255 * c0[0]);
	pe[i].peGreen = (BYTE) (a * (c1[1] - c0[1]) + 255 * c0[1]);
	pe[i].peBlue = (BYTE) (a * (c1[2] - c0[2]) + 255 * c0[2]);
	pe[i].peFlags = PC_NOCOLLAPSE;
    }

    colors[r].indexes[0] = rampBase;
    colors[r].indexes[1] = rampBase + (diffSize-1);
    colors[r].indexes[2] = rampBase + (rampSize-1);
}

/*
** Initialize any remaining non-static entries.
*/
for (i=0; i&lt;extra; ++i) {
    int index = numRamps*rampSize+10+i;
    PALETTEENTRY *pe = &pPal-&gt;palPalEntry[index];

    pe-&gt;peRed = (BYTE) 0;
    pe-&gt;peGreen = (BYTE) 0;
    pe-&gt;peBlue = (BYTE) 0;
    pe-&gt;peFlags = PC_NOCOLLAPSE;
}
}

hPalette = CreatePalette(pPal);
free(pPal);

if (hPalette) {
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
}

}

void
setupPixelFormat(HDC hDC)
{
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), /* size of this pfd /
1, /
version num /
PFD_DRAW_TO_WINDOW | /
support window /
PFD_SUPPORT_OPENGL | /
support OpenGL /
PFD_DOUBLEBUFFER, /
support double-buffering /
PFD_TYPE_COLORINDEX, /
color index mode /
8, /
8-bit 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) /
16, /
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 SelectedPixelFormat;
BOOL retVal;

SelectedPixelFormat = ChoosePixelFormat(hDC, &pfd);
if (SelectedPixelFormat == 0) {
MessageBox(WindowFromDC(hDC),
	"ChoosePixelFormat failed

"
"This application works best with an 8-bit
"
"(256 color) display mode
",
“Error”,
MB_ICONERROR | MB_OK);
exit(1);
}

retVal = SetPixelFormat(hDC, SelectedPixelFormat, &pfd);
if (retVal != TRUE) {
MessageBox(WindowFromDC(hDC), "SetPixelFormat failed", "Error",
	MB_ICONERROR | MB_OK);
exit(1);
}

}

//*****************************//

int APIENTRY
WinMain(
HINSTANCE hCurrentInst,//hThisInst,
HINSTANCE hPreviousInst,// hPrevInst,
LPSTR lpszCmdLine,// lpszArgs,
int nCmdShow)// nWinMode)
{

WNDCLASS wndClass;
HWND hWnd;
MSG msg;
//HANDLE hAccel;


/* Define and register a window class */
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WindProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hCurrentInst;
wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndClass.lpszMenuName = "MYMENU";
wndClass.lpszClassName = className;

if (!RegisterClass(&wndClass)) return 0;


/* Figure out a default size for the window */
winWidth = GetSystemMetrics(SM_CYSCREEN) / 3;
winHeight = GetSystemMetrics(SM_CYSCREEN) / 3;

/* Create a window of the previously defined class */
hWnd = CreateWindow(
className,		/* Window class's name */
windowName,		/* Title bar text */
WS_OVERLAPPEDWINDOW |	/* The window's style */
WS_CLIPCHILDREN |
WS_CLIPSIBLINGS,
winX, winY,		/* Position */
winWidth, winHeight,	/* Size */
NULL,			/* Parent window's handle */
NULL,			/* Menu handle */
hCurrentInst,		/* Instance handle */
NULL);			/* No additional data */

/* Map the window to the screen */
ShowWindow(hWnd, nCmdShow);

/* Force the window to repaint itself */
UpdateWindow(hWnd);


/* Process Messages */
while (1) {
/* execute the idle function while there are no messages to process */
while (idleFunc && 
	PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) == FALSE)
{
    (*idleFunc)();
}
if (GetMessage(&msg, NULL, 0, 0) != TRUE) {
    break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}

return msg.wParam;

}

//*****************************//
LRESULT APIENTRY
WindProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

switch (message) {



case WM_CREATE:
/*
** Set up for OpenGL rendering.  Bind the rendering context to
** the same device context that the palette will be selected into.
*/
hDC = GetDC(hWnd);
setupPixelFormat(hDC);
setupPalette(hDC);
hGLRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hGLRC);
init();
idleFunc = doRedraw;
return 0;

case WM_DESTROY:
/*
** Finish OpenGL rendering.
*/
idleFunc = NULL;
if (hGLRC) {
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hGLRC);
}
ReleaseDC(hWnd, hDC);
PostQuitMessage(0);
return 0;
case WM_SIZE:
if (hGLRC) {
    winWidth = (int) LOWORD(lParam);
    winHeight = (int) HIWORD(lParam);

    resize();
    return 0;
}

case WM_PALETTECHANGED:
/*
** Update palette mapping if this *is not* the active window.
*/
if (hGLRC && hPalette && (HWND) wParam != hWnd) {
    UnrealizeObject(hPalette);
    SelectPalette(hDC, hPalette, FALSE);
    RealizePalette(hDC);
    redraw();
    return 0;
}
break;

case WM_QUERYNEWPALETTE:
/*
** Update palette mapping if this *is* the active window.
*/
if (hGLRC && hPalette) {
    UnrealizeObject(hPalette);
    SelectPalette(hDC, hPalette, FALSE);
    RealizePalette(hDC);
    redraw();
    return TRUE;
}

break;

case WM_PAINT:
/*
** Update the window.  Don't use the device context returned by
** BeginPaint as it won't have the right palette selected into it.
*/
if (hGLRC) {
    PAINTSTRUCT ps;

    BeginPaint(hWnd, &ps);
	redraw();
	EndPaint(hWnd, &ps);
    return 0;
}
break;

case WM_RBUTTONDOWN:
GLfloat d, e;

	  d = LOWORD(lParam);
	  d=d/83;
	  x1=d;
	
	  e = HIWORD(lParam);
	  e=e/83;
	 
	 y11=-e;
	  pulsaraton(x1, y11);
	  break;

}

/* Deal with any unprocessed messages */
return DefWindowProc(hWnd, message, wParam, lParam);

}