C:/Users/thebigMuh/Documents/Visual Studio 2005/Projects/Volumizer/Volumizer/OrthoWnd.cpp

Go to the documentation of this file.

#include "Volumizer.h"

ATOM RegisterOrthoClass(HINSTANCE hInstance)
{
        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX);

        wcex.style                      = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc        = OrthoProc;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hInstance          = hInstance;
        wcex.hIcon                      = NULL;
        wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground      = NULL;//(HBRUSH)(COLOR_ACTIVECAPTION);
        wcex.lpszMenuName       = NULL;
        wcex.lpszClassName      = L"OrthoWnd";
        wcex.hIconSm            = NULL;

        return RegisterClassEx(&wcex);
}

struct GLstruct {
        HDC hdc;                                                
        HGLRC hglrc;                                    
        float hHandleMin, hHandleMax;   
        float vHandleMin, vHandleMax;   
        float hQuadExt, vQuadExt;               
};

GLstruct GLfront, GLleft, GLtop;        

int xslice, yslice, zslice;                     
float *frontslice, *leftslice, *topslice;

void InitOrtho(HWND hWnd, GLstruct &cur)
{
        cur.hdc = GetDC(hWnd);

        PIXELFORMATDESCRIPTOR pfd = { 
    sizeof(PIXELFORMATDESCRIPTOR),    // size of this pfd 
    1,                                // version number 
    PFD_DRAW_TO_WINDOW |              // support window 
    PFD_SUPPORT_OPENGL |              // support OpenGL 
    PFD_DOUBLEBUFFER,                 // double buffered 
    PFD_TYPE_RGBA,                    // RGBA type 
    32,                               // 32-bit color depth 
    0, 0, 0, 0, 0, 0,                 // color bits ignored 
    0,                                // no alpha buffer 
    0,                                // shift bit ignored 
    0,                                // no accumulation buffer 
    0, 0, 0, 0,                       // accum bits ignored 
    32,                               // 32-bit z-buffer     
    0,                                // no stencil buffer 
    0,                                // no auxiliary buffer 
    PFD_MAIN_PLANE,                   // main layer 
    0,                                // reserved 
    0, 0, 0                           // layer masks ignored 
        }; 
        
        int  iPixelFormat; 

// TODO: Insert better pfd selecting code... too lazy now. //
        

        // get the device context's best, available pixel format match 
        iPixelFormat = ChoosePixelFormat(cur.hdc, &pfd); 
 
        // make that match the device context's current pixel format 
        SetPixelFormat(cur.hdc, iPixelFormat, &pfd); 

    if (cur.hglrc = wglCreateContext( cur.hdc ) ) 
        { 
        // try to make it the thread's current rendering context 
        wglMakeCurrent(cur.hdc, cur.hglrc) ; 
    } 

// All the basic things that never change //

        glEnable(GL_DEPTH_TEST);
        glEnable(GL_POINT_SMOOTH);
        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_TEXTURE_2D);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

        glDepthFunc(GL_LEQUAL);

        glClearColor(0.44f,0.44f,0.44f,0.0f);

        glLineWidth(1.0f);

        // init our font display lists
        HFONT neuro;

        neuro = CreateFontW(0, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_DONTCARE, L"Arial");

        SelectObject(cur.hdc, neuro);

        wglUseFontOutlines(cur.hdc, 0, 255, 1000, 0.0f, 0.0f,  
                WGL_FONT_LINES, NULL); 
}

void DeInitOrtho(HWND hWnd, GLstruct &cur)
{
// Kill the context & free it //
    if(cur.hglrc = wglGetCurrentContext()) { 
 
        // obtain its associated device context 
        cur.hdc = wglGetCurrentDC() ; 
 
        // make the rendering context not current 
        wglMakeCurrent(NULL, NULL) ; 
 
        // release the device context 
        ReleaseDC(hWnd, cur.hdc) ; 
 
        // delete the rendering context 
        wglDeleteContext(cur.hglrc); 
    } 
}

void DrawOrtho(HWND hWnd)
{
        GLstruct cur;

        if (hWnd == wnd_front)
                cur = GLfront;

        if (hWnd == wnd_left)
                cur = GLleft;

        if (hWnd == wnd_top)
                cur = GLtop;

        wglMakeCurrent(cur.hdc, cur.hglrc);

        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        glViewport(0, 0, clientRect.right, clientRect.bottom);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        gluOrtho2D(-windowaspect, windowaspect, -1.0f, 1.0f);

        glMatrixMode(GL_MODELVIEW);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        if (voldat)
        {
                float aspect = 1.0f;

                char infotext[50];

                if (hWnd == wnd_front)
                {
                        aspect = (float)volx / (float)volz;

                        _snprintf_s(infotext, 50, 50, "Front, slice %d of %d", yslice + 1, voly);
                }
                if (hWnd == wnd_left)
                {
                        aspect = (float)voly / (float)volz;

                        _snprintf_s(infotext, 50, 50, "Left, slice %d of %d", xslice + 1, volx);
                }
                if (hWnd == wnd_top)
                {
                        aspect = (float)volx / (float)voly;

                        _snprintf_s(infotext, 50, 50, "Top, slice %d of %d", zslice + 1, volz);
                }

                float extx, exty;

                if (aspect < windowaspect)
                {
                        extx = aspect; exty = 1.0f;
                }
                else
                {
                        extx = windowaspect; exty = windowaspect / aspect;
                }

                glEnable(GL_TEXTURE_2D);

                glBindTexture(GL_TEXTURE_2D, 1);

                glBegin(GL_QUADS);
                        glColor3f(1.0f, 1.0f, 1.0f);

                        glTexCoord2f(1.0f, 1.0f); glVertex2f(-extx, exty);
                        glTexCoord2f(1.0f, 0.0f); glVertex2f(extx, exty);
                        glTexCoord2f(0.0f, 0.0f); glVertex2f(extx, -exty);
                        glTexCoord2f(0.0f, 1.0f); glVertex2f(-extx, -exty);

                glEnd();

                glDisable(GL_TEXTURE_2D);

                glPushMatrix();
                        glTranslatef(-windowaspect, 0.88f, 0.1f);
                        glScalef(0.12f, 0.12f, 0.12f);
                        glListBase(1000);
                        glColor3f(1.0f, 1.0f, 1.0f);

                        glCallLists((int)strlen(infotext), GL_UNSIGNED_BYTE, infotext);
                glPopMatrix();

                if (hWnd == wnd_front)
                {
                        GLfront.hQuadExt = extx;
                        GLfront.vQuadExt = exty;

                        // draw x and z axis handles
                        glBegin(GL_LINES);
                                glColor3f(1.0f, 0.0f, 0.0f);

                                float xpos = (float)xslice / (float)volx;
                                xpos = extx - (xpos * extx * 2.0f);

                                glVertex3f(xpos, -1.0f, 0.1f);
                                glVertex3f(xpos, 1.0f, 0.1f);
                                glVertex3f(xpos - 2.0f * extx / (float)volx, -1.0f, 0.1f);
                                glVertex3f(xpos - 2.0f * extx / (float)volx, 1.0f, 0.1f);

                                glColor3f(0.0f, 0.0f, 1.0f);
                                float zpos = (float)zslice / (float)volz;
                                zpos = -exty + (zpos * exty * 2.0f);

                                glVertex3f(-windowaspect, zpos, 0.1f);
                                glVertex3f(windowaspect, zpos, 0.1f);
                                glVertex3f(-windowaspect, zpos + 2.0f * exty / (float)volz, 0.1f);
                                glVertex3f(windowaspect, zpos + 2.0f * exty / (float)volz, 0.1f);

                                // fill Handle values
                                GLfront.hHandleMax = xpos;
                                GLfront.hHandleMin = xpos - 2.0f * extx / (float)volx;

                                GLfront.vHandleMax = -zpos;
                                GLfront.vHandleMin = -zpos - 2.0f * exty / (float)volz;
                        glEnd();
                }
                if (hWnd == wnd_left)
                {
                        GLleft.hQuadExt = extx;
                        GLleft.vQuadExt = exty;

                        // draw y and z axis handles
                        glBegin(GL_LINES);
                                glColor3f(0.0f, 1.0f, 0.0f);

                                float ypos = (float)yslice / (float)voly;
                                ypos = extx - (ypos * extx * 2.0f);

                                glVertex3f(ypos, -1.0f, 0.1f);
                                glVertex3f(ypos, 1.0f, 0.1f);
                                glVertex3f(ypos - 2.0f * extx / (float)voly, -1.0f, 0.1f);
                                glVertex3f(ypos - 2.0f * extx / (float)voly, 1.0f, 0.1f);

                                glColor3f(0.0f, 0.0f, 1.0f);
                                float zpos = (float)zslice / (float)volz;
                                zpos = -exty + (zpos * exty * 2.0f);

                                glVertex3f(-windowaspect, zpos, 0.1f);
                                glVertex3f(windowaspect, zpos, 0.1f);
                                glVertex3f(-windowaspect, zpos + 2.0f * exty / (float)volz, 0.1f);
                                glVertex3f(windowaspect, zpos + 2.0f * exty / (float)volz, 0.1f);

                                // fill Handle values
                                GLleft.hHandleMax = ypos;
                                GLleft.hHandleMin = ypos - 2.0f * extx / (float)voly;

                                GLleft.vHandleMax = -zpos;
                                GLleft.vHandleMin = -zpos - 2.0f * exty / (float)volz;
                        glEnd();
                }
                if (hWnd == wnd_top)
                {
                        GLtop.hQuadExt = extx;
                        GLtop.vQuadExt = exty;

                        // draw x and y axis handles
                        glBegin(GL_LINES);
                                glColor3f(1.0f, 0.0f, 0.0f);

                                float xpos = (float)xslice / (float)volx;
                                xpos = extx - (xpos * extx * 2.0f);

                                glVertex3f(xpos, -1.0f, 0.1f);
                                glVertex3f(xpos, 1.0f, 0.1f);
                                glVertex3f(xpos - 2.0f * extx / (float)volx, -1.0f, 0.1f);
                                glVertex3f(xpos - 2.0f * extx / (float)volx, 1.0f, 0.1f);

                                glColor3f(0.0f, 1.0f, 0.0f);

                                float ypos = (float)yslice / (float)voly;
                                ypos = -exty + (ypos * exty * 2.0f);

                                glVertex3f(-windowaspect, ypos, 0.1f);
                                glVertex3f(windowaspect, ypos, 0.1f);
                                glVertex3f(-windowaspect, ypos + 2.0f * exty / (float)voly, 0.1f);
                                glVertex3f(windowaspect, ypos + 2.0f * exty / (float)voly, 0.1f);

                                // fill Handle values
                                GLtop.hHandleMax = xpos;
                                GLtop.hHandleMin = xpos - 2.0f * extx / (float)volx;

                                GLtop.vHandleMax = -ypos;
                                GLtop.vHandleMin = -ypos - 2.0f * exty / (float)voly;
                        glEnd();
                }
        }

        glFinish();

        SwapBuffers(cur.hdc);
}

void BuildOrthoSlice(HWND hWnd)
{

        if (voldat)
        {
                if (hWnd == wnd_front)
                {
                        frontslice = new float[volx * volz];

                        for (unsigned int x = 0; x < volx; x++)
                        {
                                for (unsigned int z = 0; z < volz; z++)
                                {
                                        frontslice[x*volz + z] = voldat[x + yslice*volx + z*volx*voly];
                                }
                        }

                        wglMakeCurrent(GLfront.hdc, GLfront.hglrc);

                        float *fronttex = new float[512*512];

                        gluScaleImage(GL_LUMINANCE,
                                volz, volx, GL_FLOAT, frontslice,
                                512, 512, GL_FLOAT, fronttex);

                        glBindTexture(GL_TEXTURE_2D, 1);

                        glTexImage2D(GL_TEXTURE_2D,
                                0,
                                GL_LUMINANCE,
                                512,
                                512,
                                0,
                                GL_LUMINANCE,
                                GL_FLOAT,
                                fronttex);

                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering

                        delete [] fronttex;
                        delete [] frontslice;
                }
                if (hWnd == wnd_left)
                {
                        leftslice = new float[voly * volz];

                        for (unsigned int y = 0; y < voly; y++)
                        {
                                for (unsigned int z = 0; z < volz; z++)
                                {
                                        leftslice[y*volz + z] = voldat[xslice + y*volx + z*voly*volx];
                                }
                        }

                        wglMakeCurrent(GLleft.hdc, GLleft.hglrc);

                        float *lefttex = new float[512*512];

                        gluScaleImage(GL_LUMINANCE,
                                volz, voly, GL_FLOAT, leftslice,
                                512, 512, GL_FLOAT, lefttex);

                        glBindTexture(GL_TEXTURE_2D, 1);

                        glTexImage2D(GL_TEXTURE_2D,
                                0,
                                GL_LUMINANCE,
                                512,
                                512,
                                0,
                                GL_LUMINANCE,
                                GL_FLOAT,
                                lefttex);

                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering

                        delete [] leftslice;
                        delete [] lefttex;
                }
                if (hWnd == wnd_top)
                {
                        topslice = new float[512 * 512];

                        for (unsigned int x = 0; x < volx; x++)
                        {
                                for (unsigned int y = 0; y < voly; y++)
                                {
                                        topslice[x*voly + y] = voldat[x + y*volx + zslice*voly*volx];
                                }
                        }

                        wglMakeCurrent(GLtop.hdc, GLtop.hglrc);

                        float *toptex = new float[512*512];

                        gluScaleImage(GL_LUMINANCE,
                                voly, volx, GL_FLOAT, topslice,
                                512, 512, GL_FLOAT, toptex);

                        glBindTexture(GL_TEXTURE_2D, 1);

                        glTexImage2D(GL_TEXTURE_2D,
                                0,
                                GL_LUMINANCE,
                                512,
                                512,
                                0,
                                GL_LUMINANCE,
                                GL_FLOAT,
                                toptex);

                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering

                        delete [] toptex;
                        delete [] topslice;
                }
        }
}

int GropeForHandle(HWND hWnd)
{
        POINT cpos;
        int handle = 0;

        GetCursorPos(&cpos);

        // fill the four handle minima/maxima
        // with the correct values
        if (hWnd == wnd_front)
        {
                ScreenToClient(wnd_front, &cpos);

                wglMakeCurrent(GLfront.hdc, GLfront.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                if (ox >= GLfront.hHandleMin &&
                        ox <= GLfront.hHandleMax)
                        handle |= 1;

                if (oy >= GLfront.vHandleMin &&
                        oy <= GLfront.vHandleMax)
                        handle |= 2;
        }
        if (hWnd == wnd_left)
        {
                ScreenToClient(wnd_left, &cpos);

                wglMakeCurrent(GLleft.hdc, GLleft.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                if (ox >= GLleft.hHandleMin &&
                        ox <= GLleft.hHandleMax)
                        handle |= 1;

                if (oy >= GLleft.vHandleMin &&
                        oy <= GLleft.vHandleMax)
                        handle |= 2;
        }
        if (hWnd == wnd_top)
        {
                ScreenToClient(wnd_top, &cpos);

                wglMakeCurrent(GLtop.hdc, GLtop.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                if (ox >= GLtop.hHandleMin &&
                        ox <= GLtop.hHandleMax)
                        handle |= 1;

                if (oy >= GLtop.vHandleMin &&
                        oy <= GLtop.vHandleMax)
                        handle |= 2;
        }

        if (handle == 1)
                SetCursor(LoadCursor(NULL, IDC_SIZEWE));
        else if (handle == 2)
                SetCursor(LoadCursor(NULL, IDC_SIZENS));
        else if (handle == 3)
                SetCursor(LoadCursor(NULL, IDC_SIZEALL));

        return handle;
}

void MoveHandle(HWND hWnd, int handle)
{
        POINT cpos;

        GetCursorPos(&cpos);

        if (hWnd == wnd_front)
        {
                ScreenToClient(wnd_front, &cpos);

                wglMakeCurrent(GLfront.hdc, GLfront.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                // front window
                if (handle & 1)
                {
                        // vertical bar
                        
                        if (ox < -GLfront.hQuadExt)
                                xslice = volx - 1;
                        else if (ox > GLfront.hQuadExt)
                                xslice = 0;
                        else
                                xslice = (int)((1.0f - (ox + GLfront.hQuadExt) / (2.0f * GLfront.hQuadExt)) * volx);

                        BuildOrthoSlice(wnd_left);
                }

                if (handle & 2)
                {
                        // horizontal bar

                        if (oy < -GLfront.vQuadExt)
                                zslice = volz - 1;
                        else if (oy > GLfront.vQuadExt)
                                zslice = 0;
                        else
                                zslice = (int)((1.0f - (oy + GLfront.vQuadExt) / (2.0f * GLfront.vQuadExt)) * volz);

                        BuildOrthoSlice(wnd_top);
                }
        }
        if (hWnd == wnd_left)
        {
                ScreenToClient(wnd_left, &cpos);

                wglMakeCurrent(GLleft.hdc, GLleft.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                // left window
                if (handle & 1)
                {
                        // vertical bar
                        
                        if (ox < -GLleft.hQuadExt)
                                yslice = voly - 1;
                        else if (ox > GLleft.hQuadExt)
                                yslice = 0;
                        else
                                yslice = (int)((1.0f - (ox + GLleft.hQuadExt) / (2.0f * GLleft.hQuadExt)) * voly);

                        BuildOrthoSlice(wnd_front);
                }

                if (handle & 2)
                {
                        // horizontal bar

                        if (oy < -GLleft.vQuadExt)
                                zslice = volz - 1;
                        else if (oy > GLleft.vQuadExt)
                                zslice = 0;
                        else
                                zslice = (int)((1.0f - (oy + GLleft.vQuadExt) / (2.0f * GLleft.vQuadExt)) * volz);

                        BuildOrthoSlice(wnd_top);
                }
        }
        if (hWnd == wnd_top)
        {
                ScreenToClient(wnd_top, &cpos);

                wglMakeCurrent(GLtop.hdc, GLtop.hglrc);

                double mvm[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
                double pm[16];
                glGetDoublev(GL_PROJECTION_MATRIX, pm);
                int view[4];
                glGetIntegerv(GL_VIEWPORT, view);

                double ox, oy, oz;

                gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

                // left window
                if (handle & 1)
                {
                        // vertical bar
                        
                        if (ox < -GLtop.hQuadExt)
                                xslice = volx - 1;
                        else if (ox > GLtop.hQuadExt)
                                xslice = 0;
                        else
                                xslice = (int)((1.0f - (ox + GLtop.hQuadExt) / (2.0f * GLtop.hQuadExt)) * volx);

                        BuildOrthoSlice(wnd_left);
                }

                if (handle & 2)
                {
                        // horizontal bar

                        if (oy < -GLtop.vQuadExt)
                                yslice = volz - 1;
                        else if (oy > GLtop.vQuadExt)
                                yslice = 0;
                        else
                                yslice = (int)((1.0f - (oy + GLtop.vQuadExt) / (2.0f * GLtop.vQuadExt)) * voly);

                        BuildOrthoSlice(wnd_front);
                }
        }
        DrawOrtho(wnd_front);
        DrawOrtho(wnd_left);
        DrawOrtho(wnd_top);
}

void ShiftSlice(HWND hWnd, int amt)
{
        if (hWnd == wnd_front)
        {
                yslice += amt;

                if (yslice < 0) yslice = 0;
                if ((unsigned int)yslice >= voly)       yslice = voly - 1;

                BuildOrthoSlice(wnd_front);
        }

        if (hWnd == wnd_left)
        {
                xslice += amt;

                if (xslice < 0) xslice = 0;
                if ((unsigned int)xslice >= volx)       xslice = volx - 1;

                BuildOrthoSlice(wnd_left);
        }

        if (hWnd == wnd_top)
        {
                zslice += amt;
                
                if (zslice < 0) zslice = 0;
                if ((unsigned int)zslice >= volz)       zslice = volz - 1;

                BuildOrthoSlice(wnd_top);
        }

        DrawOrtho(wnd_front);
        DrawOrtho(wnd_left);
        DrawOrtho(wnd_top);
}

LRESULT CALLBACK OrthoProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        PAINTSTRUCT ps;
        HDC hdc;
        int zDelta, fwKeys;
        static int handle;
        static POINT spos;

        switch (message)
        {
        case WM_LBUTTONDOWN:
                handle = GropeForHandle(hWnd);
                SetCapture(hWnd);
                GetCursorPos(&spos);
                break;
        case WM_LBUTTONUP:
                ReleaseCapture();
        case WM_MOUSEMOVE:
                if (GetCapture() == hWnd)
                {
                        if (handle)
                        {
                                MoveHandle(hWnd, handle);

                        }
                        else
                        {
                                POINT mpos;

                                GetCursorPos(&mpos);

                                int diff = (spos.x - mpos.x) + (spos.y - mpos.y);

                                ShiftSlice(hWnd, diff);

                                spos = mpos;
                        }
                }
                else
                {
                        GropeForHandle(hWnd);
                }
                break;
        case WM_MOUSEWHEEL:
                if (!voldat)
                        break;

                zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
                fwKeys = GET_KEYSTATE_WPARAM(wParam);

                if (fwKeys & MK_SHIFT)
                        fwKeys = 10;
                else 
                        fwKeys = 1;

                fwKeys *= (zDelta > 0?1:-1);

                ShiftSlice(hWnd, fwKeys);

                break;
        case WM_PAINT:
                hdc = BeginPaint(hWnd, &ps);
                if (hWnd == wnd_front)
                        DrawOrtho(hWnd);
                if (hWnd == wnd_left)
                        DrawOrtho(hWnd);
                if (hWnd == wnd_top)
                        DrawOrtho(hWnd);
                EndPaint(hWnd, &ps);
                break;
        case WM_SHOWWINDOW:
                if (hWnd == wnd_front)
                        InitOrtho(wnd_front, GLfront);
                if (hWnd == wnd_left)
                        InitOrtho(wnd_left, GLleft);
                if (hWnd == wnd_top)
                        InitOrtho(wnd_top, GLtop);
                break;
        case WM_DESTROY:
                if (hWnd == wnd_front)
                        DeInitOrtho(wnd_front, GLfront);
                if (hWnd == wnd_left)
                        DeInitOrtho(wnd_left, GLleft);
                if (hWnd == wnd_top)
                        DeInitOrtho(wnd_top, GLtop);
                PostQuitMessage(0);
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;
}

---