Robocik 3

// gl_teplate.c
// A template program for most WIGGLE applications

#include <windows.h>            // Window defines
#include <gl\gl.h>              // OpenGL
#include <gl\glu.h>             // GLU library
#include <math.h>                               // Define for sine and cosine
#include "resource.h"           // About box resource identifiers.

// Define a constant for the value of PI
#define GL_PI 3.1415f

double rot1,rot2,rot3;
int licznik;


// Color Palette handle
HPALETTE hPalette = NULL;


// Application name and instance storeage
static LPCTSTR lpszAppName = "GL TEMPLATE";
static HINSTANCE hInstance;

// Rotation amounts
static GLfloat xRot = 0.0f;
static GLfloat yRot = 0.0f;


// Declaration for Window procedure
LRESULT CALLBACK WndProc(   HWND    hWnd,
						 UINT    message,
						 WPARAM  wParam,
						 LPARAM  lParam);

// Dialog procedure for about box
BOOL APIENTRY AboutDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam);

// Set Pixel Format function - forward declaration
void SetDCPixelFormat(HDC hDC);


// Change viewing volume and viewport.  Called when window is resized
void ChangeSize(GLsizei w, GLsizei h)
{
	GLfloat nRange = 100.0f;

	// Prevent a divide by zero
	if(h == 0)
		h = 1;

	// Set Viewport to window dimensions
	glViewport(0, 0, w, h);

	// Reset coordinate system
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	// Establish clipping volume (left, right, bottom, top, near, far)
	if (w <= h)
		glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
	else
		glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}



// This function does any needed initialization on the rendering
// context.
void SetupRC()
{
	// STARY KOD
	// Light values and coordinates
	GLfloat  ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f };
	GLfloat  diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f };
	GLfloat  specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
	GLfloat	 lightPos[] = { 0.0f, 150.0f, 150.0f, 1.0f };
	GLfloat  specref[] =  { 1.0f, 1.0f, 1.0f, 1.0f };


	glEnable(GL_DEPTH_TEST);	// Hidden surface removal
	glFrontFace(GL_CCW);		// Counter clock-wise polygons face out
	glEnable(GL_CULL_FACE);		// Do not calculate inside of jet

	// Enable lighting
	glEnable(GL_LIGHTING);

	// Setup and enable light 0
	glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
	glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
	glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
	glEnable(GL_LIGHT0);

	// Enable color tracking
	glEnable(GL_COLOR_MATERIAL);

	// Set Material properties to follow glColor values
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	// All materials hereafter have full specular reflectivity
	// with a high shine
	glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
	glMateriali(GL_FRONT,GL_SHININESS,128);


	// White background
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
	// Black brush
	glColor3f(0.0,0.0,0.0);
	//STARY KOD - KONIEC





}

void walec(double h, double r)
{
	double angle,x,y;
	// podstawa cz 1
	glBegin(GL_TRIANGLE_FAN);
	glNormal3d(0,0,-1);
	glVertex3d(0.0f, 0.0f, 0.0f);
	for(angle = 0.0f; angle <= (2.0f*GL_PI); angle += (GL_PI/8.0f))
	{
		x = r*sin(angle);
		y = r*cos(angle);
		glVertex3d(x, y, 0.0);
	}
	glEnd();

	// łączenie

	glBegin(GL_QUAD_STRIP);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI); angle -= (GL_PI/8.0f))
	{
		x = r*sin(angle);
		y = r*cos(angle);
		glNormal3d(sin(angle),cos(angle),0.0);
		glVertex3d(x, y, h);
		glVertex3d(x, y, 0);
	}
	glEnd();

	// podstawa cz 2
	glBegin(GL_TRIANGLE_FAN);
	glNormal3d(0,0,1);
	glVertex3d(0.0f, 0.0f, h);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI); angle -= (GL_PI/8.0f))
	{
		x = r*sin(angle);
		y = r*cos(angle);
		glVertex3d(x, y, h);
	}
	glEnd();


}


void szescian(void)
{
	glBegin(GL_QUADS);


	glColor3d(1,0.5,0);
	//pomarancz
	glNormal3d(0,0,1);
	glVertex3d( 20, 20, 20);
	glVertex3d(-20, 20, 20);
	glVertex3d(-20,-20, 20);
	glVertex3d( 20,-20, 20);

	glColor3d(0,1,0);
	glNormal3d(0,-1,0);
	//zielony
	glVertex3d(-20,-20, 20);
	glVertex3d(-20,-20,-20);
	glVertex3d( 20,-20,-20);
	glVertex3d( 20,-20, 20);

	glColor3d(0,0.5,1);
	glNormal3d(1,0,0);
	//niebieski
	glVertex3d( 20, 20, 20);
	glVertex3d( 20,-20, 20);
	glVertex3d( 20,-20,-20);
	glVertex3d( 20, 20,-20);

	glColor3d(0,1,0);
	glNormal3d(0,1,0);
	//zielony
	glVertex3d(-20, 20,-20);
	glVertex3d(-20, 20, 20);
	glVertex3d( 20, 20, 20);
	glVertex3d( 20, 20,-20);

	glColor3d(1,0.5,0);
	glNormal3d(0,0,-1);
	//pomarancz
	glVertex3d( 20, 20,-20);
	glVertex3d( 20,-20,-20);
	glVertex3d(-20,-20,-20);
	glVertex3d(-20, 20,-20);

	glColor3d(0,0.5,1);
	glNormal3d(-1,0,0);
	//niebieski
	glVertex3d(-20,-20,-20);
	glVertex3d(-20,-20, 20);
	glVertex3d(-20, 20, 20);
	glVertex3d(-20, 20,-20);

	glEnd();
}

void ramie(double r1, double r2, double h, double d)
{
	double angle,x,y;
	glBegin(GL_TRIANGLE_FAN);
	glNormal3d(0,0,1);
	glVertex3d(0.0f, 0.0f, 0.0f);
	for(angle = 0.0f; angle <= (2.0f*GL_PI)/2; angle += (GL_PI/8.0f))
	{
		x = r1*sin(angle);
		y = r1*cos(angle);
		glVertex3d(x, y, 0.0);
	}
	glEnd();

	glBegin(GL_QUAD_STRIP);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI)/2; angle -= (GL_PI/8.0f))
	{
		x = r1*sin(angle);
		y = r1*cos(angle);
		glNormal3d(sin(angle),cos(angle),0.0);
		glVertex3d(-x, -y, h);
		glVertex3d(-x, -y, 0);
	}
	glEnd();

	glBegin(GL_TRIANGLE_FAN);
	glNormal3d(0.0,0.0,1.0);
	glVertex3d(0.0f, 0.0f, h);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI)/2; angle -= (GL_PI/8.0f))
	{
		x = r1*sin(angle);
		y = r1*cos(angle);
		glVertex3d(-x, -y, h);
	}
	glEnd();

	////////////////////////////////////////////////////////////////////

	glBegin(GL_TRIANGLE_FAN);
	glNormal3d(0,0,1);
	glVertex3d(0.0f - d, 0.0f, 0.0f);
	for(angle = 0.0f; angle <= (2.0f*GL_PI)/2; angle += (GL_PI/8.0f))
	{
		x = -r2*sin(angle);
		y = -r2*cos(angle);
		glVertex3d(x - d, y, 0.0);
	}
	glEnd();

	glBegin(GL_QUAD_STRIP);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI)/2; angle -= (GL_PI/8.0f))
	{
		x = r2*sin(angle);
		y = r2*cos(angle);
		glNormal3d(sin(angle),cos(angle),0.0);
		glVertex3d(x-d, y, h);
		glVertex3d(x-d, y, 0);
	}
	glEnd();

	glBegin(GL_TRIANGLE_FAN);
	glVertex3d(0.0f -d , 0.0f, h);
	glNormal3d(0.0,0.0,1.0);
	for(angle = 0.0f; angle >= -(2.0f*GL_PI)/2; angle -= (GL_PI/8.0f))
	{
		x = -r2*sin(angle);
		y = -r2*cos(angle);
		glVertex3d(-x -d , -y, h);
	}
	glEnd();

	////////////////////////////////////////////////////////////////////
	glBegin(GL_LINES);


	// pierwsza sciana
	glBegin(GL_QUADS);
	glVertex3d(0.0f, 0.0f + r1, 0.0f);
	glVertex3d(0.0f -d, 0.0f + r2, 0.0f);

	glVertex3d(0.0f, 0.0f + r1, 0.0f + h);
	glVertex3d(0.0f -d, 0.0f + r2, 0.0f + h);

	glVertex3d(0.0f, 0.0f - r1, 0.0f);
	glVertex3d(0.0f -d, 0.0f - r2, 0.0f);

	glVertex3d(0.0f, 0.0f - r1, 0.0f + h);
	glVertex3d(0.0f -d, 0.0f - r2, 0.0f + h);

	glEnd();

}

void robot(double d1, double d2, double d3)
{
	glColor3d(1,0,0);
	glPushMatrix();

	glRotated(-90,1.0,0.0,0.0);
	glTranslated(0.0,0.0,-50.0);
	walec(5,30);

	glTranslated(0.0,0.0,5.0);
	walec(40,10);

	glTranslated(0,0,40);
	glRotated(d1,0,0,1);
	walec(40,10);

	glTranslated(0,0,40);
	glRotated(90,0,1,0);
	glTranslated(0,0,-20);
	walec(40,10);

	glTranslated(0,0,+40);
	glRotated(90+d2,0,0,1);
	ramie(15,10,5,30);

	glTranslated(-30,0,-5);
	//glRotated(d3,0,0,1);
	//ramie(15,10,5,30);
	glPopMatrix();


}

void dwa_roboty(void)
{
	glPushMatrix();
	glTranslated(-50,0,0);
	robot(rot1,rot2,rot3);
	glPopMatrix();
	/*
	glPushMatrix();
	glTranslated(50,0,0);
	//glRotated(180,0,1,0);
	robot(rot1,rot2,rot3);
	glPopMatrix();
	*/





}
// Called to draw scene
void RenderScene(void)
{
	// Clear the window and the depth buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_CULL_FACE);
	// Save matrix state and do the rotation
	glPushMatrix();
	glRotatef(xRot, 1.0f, 0.0f, 0.0f);
	glRotatef(yRot, 0.0f, 1.0f, 0.0f);


	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	// WYWOLANIE FUNKCJI ROBOTA
	 robot(rot1,rot2,rot3);

	//szescian();

	// All obiect are shown as nets
	glPolygonMode(GL_BACK,GL_LINE);



	/////////////////////////////////////////////////////
	/////////////////////////////////////////////////////
	// Restore transformations
	glPopMatrix();

	// Flush drawing commands
	glFlush();
}


// Select the pixel format for a given device context
void SetDCPixelFormat(HDC hDC)
{
	int nPixelFormat;

	static PIXELFORMATDESCRIPTOR pfd = {
		sizeof(PIXELFORMATDESCRIPTOR),  // Size of this structure
		1,                                                              // Version of this structure
		PFD_DRAW_TO_WINDOW |                    // Draw to Window (not to bitmap)
		PFD_SUPPORT_OPENGL |                                    // Support OpenGL calls in window
		PFD_DOUBLEBUFFER,                       // Double buffered
		PFD_TYPE_RGBA,                          // RGBA Color mode
		24,                                     // Want 24bit color
		0,0,0,0,0,0,                            // Not used to select mode
		0,0,                                    // Not used to select mode
		0,0,0,0,0,                              // Not used to select mode
		32,                                     // Size of depth buffer
		0,                                      // Not used to select mode
		0,                                      // Not used to select mode
		PFD_MAIN_PLANE,                         // Draw in main plane
		0,                                      // Not used to select mode
		0,0,0 };                                // Not used to select mode

		// Choose a pixel format that best matches that described in pfd
		nPixelFormat = ChoosePixelFormat(hDC, &pfd);

		// Set the pixel format for the device context
		SetPixelFormat(hDC, nPixelFormat, &pfd);
}



// If necessary, creates a 3-3-2 palette for the device context listed.
HPALETTE GetOpenGLPalette(HDC hDC)
{
	HPALETTE hRetPal = NULL;        // Handle to palette to be created
	PIXELFORMATDESCRIPTOR pfd;      // Pixel Format Descriptor
	LOGPALETTE *pPal;                       // Pointer to memory for logical palette
	int nPixelFormat;                       // Pixel format index
	int nColors;                            // Number of entries in palette
	int i;                                          // Counting variable
	BYTE RedRange,GreenRange,BlueRange;
	// Range for each color entry (7,7,and 3)


	// Get the pixel format index and retrieve the pixel format description
	nPixelFormat = GetPixelFormat(hDC);
	DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

	// Does this pixel format require a palette?  If not, do not create a
	// palette and just return NULL
	if(!(pfd.dwFlags & PFD_NEED_PALETTE))
		return NULL;

	// Number of entries in palette.  8 bits yeilds 256 entries
	nColors = 1 << pfd.cColorBits;

	// Allocate space for a logical palette structure plus all the palette entries
	pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +nColors*sizeof(PALETTEENTRY));

	// Fill in palette header
	pPal->palVersion = 0x300;               // Windows 3.0
	pPal->palNumEntries = nColors; // table size

	// Build mask of all 1's.  This creates a number represented by having
	// the low order x bits set, where x = pfd.cRedBits, pfd.cGreenBits, and
	// pfd.cBlueBits.
	RedRange = (1 << pfd.cRedBits) -1;
	GreenRange = (1 << pfd.cGreenBits) - 1;
	BlueRange = (1 << pfd.cBlueBits) -1;

	// Loop through all the palette entries
	for(i = 0; i < nColors; i++)
	{
		// Fill in the 8-bit equivalents for each component
		pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange;
		pPal->palPalEntry[i].peRed = (unsigned char)(
			(double) pPal->palPalEntry[i].peRed * 255.0 / RedRange);

		pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange;
		pPal->palPalEntry[i].peGreen = (unsigned char)(
			(double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange);

		pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange;
		pPal->palPalEntry[i].peBlue = (unsigned char)(
			(double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange);

		pPal->palPalEntry[i].peFlags = (unsigned char) NULL;
	}


	// Create the palette
	hRetPal = CreatePalette(pPal);

	// Go ahead and select and realize the palette for this device context
	SelectPalette(hDC,hRetPal,FALSE);
	RealizePalette(hDC);

	// Free the memory used for the logical palette structure
	free(pPal);

	// Return the handle to the new palette
	return hRetPal;
}


// Entry point of all Windows programs
int APIENTRY WinMain(   HINSTANCE       hInst,
					 HINSTANCE       hPrevInstance,
					 LPSTR           lpCmdLine,
					 int                     nCmdShow)
{
	MSG             msg;            // Windows message structure
	WNDCLASS        wc;             // Windows class structure
	HWND            hWnd;           // Storeage for window handle

	hInstance = hInst;

	// Register Window style
	wc.style                = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc          = (WNDPROC) WndProc;
	wc.cbClsExtra           = 0;
	wc.cbWndExtra           = 0;
	wc.hInstance            = hInstance;
	wc.hIcon                = NULL;
	wc.hCursor              = LoadCursor(NULL, IDC_ARROW);

	// No need for background brush for OpenGL window
	wc.hbrBackground        = NULL;

	wc.lpszMenuName         = MAKEINTRESOURCE(IDR_MENU);
	wc.lpszClassName        = lpszAppName;

	// Register the window class
	if(RegisterClass(&wc) == 0)
		return FALSE;


	// Create the main application window
	hWnd = CreateWindow(
		lpszAppName,
		lpszAppName,

		// OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,

		// Window position and size
		50, 50,
		400, 400,
		NULL,
		NULL,
		hInstance,
		NULL);

	// If window was not created, quit
	if(hWnd == NULL)
		return FALSE;


	// Display the window
	ShowWindow(hWnd,SW_SHOW);
	UpdateWindow(hWnd);

	// Process application messages until the application closes
	while( GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return msg.wParam;
}




// Window procedure, handles all messages for this program
LRESULT CALLBACK WndProc(       HWND    hWnd,
						 UINT    message,
						 WPARAM  wParam,
						 LPARAM  lParam)
{
	static HGLRC hRC;               // Permenant Rendering context
	static HDC hDC;                 // Private GDI Device context

	switch (message)
	{
		// Window creation, setup for OpenGL
	case WM_TIMER:
		if(wParam==101)
		{
			licznik++;
			if(licznik<15)
			{
				rot2+=4.0;
			}

			if(licznik>15 && licznik < 30)
			{
				rot2-=4.0;
			}

			if(licznik>30)
			{licznik=0;}
			InvalidateRect(hWnd,NULL,FALSE);
		}
		break;

	case WM_CREATE:

		SetTimer(hWnd,101,30,NULL);
		// Store the device context
		hDC = GetDC(hWnd);

		// Select the pixel format
		SetDCPixelFormat(hDC);

		// Create palette if needed
		hPalette = GetOpenGLPalette(hDC);

		// Create the rendering context and make it current
		hRC = wglCreateContext(hDC);
		wglMakeCurrent(hDC, hRC);

		// Call OpenGL setup code
		SetupRC();

		break;

		// Window is being destroyed, cleanup
	case WM_DESTROY:

		KillTimer(hWnd,101);
		// Deselect the current rendering context and delete it
		wglMakeCurrent(hDC,NULL);
		wglDeleteContext(hRC);

		ReleaseDC(hWnd,hDC);

		// Delete the palette if it was created
		if(hPalette != NULL)
			DeleteObject(hPalette);


		// Tell the application to terminate after the window
		// is gone.
		PostQuitMessage(0);
		break;

		// Window is resized.
	case WM_SIZE:
		// Call our function which modifies the clipping
		// volume and viewport
		ChangeSize(LOWORD(lParam), HIWORD(lParam));
		break;


		// The painting function.  This message sent by Windows
		// whenever the screen needs updating.
	case WM_PAINT:
		{
			// Call OpenGL drawing code
			RenderScene();

			SwapBuffers(hDC);

			// Validate the newly painted client area
			ValidateRect(hWnd,NULL);
		}
		break;


		// Windows is telling the application that it may modify
		// the system palette.  This message in essance asks the
		// application for a new palette.
	case WM_QUERYNEWPALETTE:
		// If the palette was created.
		if(hPalette)
		{
			int nRet;

			// Selects the palette into the current device context
			SelectPalette(hDC, hPalette, FALSE);

			// Map entries from the currently selected palette to
			// the system palette.  The return value is the number
			// of palette entries modified.
			nRet = RealizePalette(hDC);

			// Repaint, forces remap of palette in current window
			InvalidateRect(hWnd,NULL,FALSE);

			return nRet;
		}
		break;


		// This window may set the palette, even though it is not the
		// currently active window.
	case WM_PALETTECHANGED:
		// Don't do anything if the palette does not exist, or if
		// this is the window that changed the palette.
		if((hPalette != NULL) && ((HWND)wParam != hWnd))
		{
			// Select the palette into the device context
			SelectPalette(hDC,hPalette,FALSE);

			// Map entries to system palette
			RealizePalette(hDC);

			// Remap the current colors to the newly realized palette
			UpdateColors(hDC);
			return 0;
		}
		break;


		// Key press, check for arrow keys to do cube rotation.
	case WM_KEYDOWN:
		{
			if(wParam == VK_UP)
				xRot-= 5.0f;

			if(wParam == VK_DOWN)
				xRot += 5.0f;

			if(wParam == VK_LEFT)
				yRot -= 5.0f;

			if(wParam == VK_RIGHT)
				yRot += 5.0f;

			if(xRot > 356.0f)
				xRot = 0.0f;

			if(xRot < -1.0f)
				xRot = 355.0f;

			if(yRot > 356.0f)
				yRot = 0.0f;

			if(yRot < -1.0f)
				yRot = 355.0f;

			if(wParam == '1')
				rot1 -= 5.0f;

			if(wParam == '2')
				rot1 += 5.0f;

			if(wParam == '3')
				rot2 -= 5.0f;

			if(wParam == '4')
				rot2 += 5.0f;

			if(wParam == '5')
				rot3 -= 5.0f;

			if(wParam == '6')
				rot3 += 5.0f;

			InvalidateRect(hWnd,NULL,FALSE);
		}
		break;

		// A menu command
	case WM_COMMAND:
		{
			HANDLE hMenu = GetMenu(hWnd);

			switch(LOWORD(wParam))
			{
				// Exit the program
			case ID_FILE_EXIT:
				DestroyWindow(hWnd);
				break;

				// Display the about box
			case ID_HELP_ABOUT:
				DialogBox (hInstance,
					MAKEINTRESOURCE(IDD_DIALOG_ABOUT),
					hWnd,
					AboutDlgProc);
				break;

			}
		}
		break;


	default:   // Passes it on if unproccessed
		return (DefWindowProc(hWnd, message, wParam, lParam));

	}

	return (0L);
}




// Dialog procedure.
BOOL APIENTRY AboutDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam)
{

	switch (message)
	{
		// Initialize the dialog box
	case WM_INITDIALOG:
		{
			int i;
			GLenum glError;

			// glGetString demo
			SetDlgItemText(hDlg,IDC_OPENGL_VENDOR,(LPCSTR)glGetString(GL_VENDOR));
			SetDlgItemText(hDlg,IDC_OPENGL_RENDERER,(LPCSTR)glGetString(GL_RENDERER));
			SetDlgItemText(hDlg,IDC_OPENGL_VERSION,(LPCSTR)glGetString(GL_VERSION));
			SetDlgItemText(hDlg,IDC_OPENGL_EXTENSIONS,(LPCSTR)glGetString(GL_EXTENSIONS));

			// gluGetString demo
			SetDlgItemText(hDlg,IDC_GLU_VERSION,(LPCSTR)gluGetString(GLU_VERSION));
			SetDlgItemText(hDlg,IDC_GLU_EXTENSIONS,(LPCSTR)gluGetString(GLU_EXTENSIONS));


			// Display any recent error messages
			i = 0;
			do {
				glError = glGetError();
				SetDlgItemText(hDlg,IDC_ERROR1+i,(LPCSTR)gluErrorString(glError));
				i++;
			}
			while(i < 6 && glError != GL_NO_ERROR);


			return (TRUE);
		}
		break;

		// Process command messages
	case WM_COMMAND:
		{
			// Validate and Make the changes
			if(LOWORD(wParam) == IDOK)
				EndDialog(hDlg,TRUE);
		}
		break;

		// Closed from sysbox
	case WM_CLOSE:
		EndDialog(hDlg,TRUE);
		break;
	}

	return FALSE;
}