Robocik_OpenGL_2

// 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;
    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();
    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();

    glBegin(GL_TRIANGLE_FAN);
    glNormal3d(0.0,0.0,1.0);
    glVertex3d(0.0f, 0.0f, 0.0f + 1);
    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+1);
    }
    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, 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, 0.0 +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, 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, 0.0 +h);
    }
    glEnd();

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

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