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

Go to the documentation of this file.

#include "Volumizer.h"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;                                                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];                    // the main window class name

HWND wnd_main, wnd_splitter, wnd_3d, wnd_front, wnd_left, wnd_top, wnd_histogram, wnd_tool;

float brightness, contrast, gamma;                              

// Forward declarations of functions included in this code module:
ATOM                            RegisterMainClass(HINSTANCE hInstance);
BOOL                            InitInstance(HINSTANCE, int);
LRESULT CALLBACK        WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
        UNREFERENCED_PARAMETER(hPrevInstance);
        UNREFERENCED_PARAMETER(lpCmdLine);

        MSG msg;
        HACCEL hAccelTable;

        // Initialize global strings
        LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
        LoadString(hInstance, IDC_VOLUMIZER, szWindowClass, MAX_LOADSTRING);

        RegisterMainClass(hInstance);
        RegisterSplitterClass(hInstance);
        RegisterRayClass(hInstance);
        RegisterOrthoClass(hInstance);
        RegisterHistogramClass(hInstance);

        RegisterSwatchClass(hInstance);

        wnd_main = wnd_splitter = wnd_3d = wnd_top = wnd_front = wnd_left = NULL;
        brightness = 0.5f;
        contrast = 0.5f;
        gamma = 1.0f;

        InitOptions();
        CreateDefaultTransferFunction();

        // Perform application initialization:
        if (!InitInstance (hInstance, nCmdShow))
        {
                return FALSE;
        }

        hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_VOLUMIZER));

        // Main message loop:
        while (GetMessage(&msg, NULL, 0, 0))
        {
                if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
                {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                }
        }

        return (int) msg.wParam;
}



ATOM RegisterMainClass(HINSTANCE hInstance)
{
        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX);

        wcex.style                      = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc        = WndProc;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hInstance          = hInstance;
        wcex.hIcon                      = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_VOLUMIZER));
        wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground      = NULL;
        wcex.lpszMenuName       = MAKEINTRESOURCE(IDC_VOLUMIZER);
        wcex.lpszClassName      = szWindowClass;
        wcex.hIconSm            = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

        return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   wnd_main = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!wnd_main)
   {
      return FALSE;
   }

   ShowWindow(wnd_main, nCmdShow);
   UpdateWindow(wnd_main);

   return TRUE;
}

void GetOpenFile()
{
        OPENFILENAME ofn;
        ofn.lStructSize = sizeof(OPENFILENAME);
        ofn.hwndOwner = wnd_main;
        ofn.hInstance = NULL;
        ofn.lpstrFilter = L"Data File (*.dat)\0*.DAT\0All Files\0*.*\0\0";
        ofn.lpstrCustomFilter = NULL;
        ofn.nMaxCustFilter = 0;
        ofn.nFilterIndex = 1;
        ofn.lpstrFile = new wchar_t[500]; ofn.lpstrFile[0] = '\0';
        ofn.nMaxFile = 500;
        ofn.lpstrFileTitle = NULL;
        ofn.nMaxFileTitle = 0;
        ofn.lpstrInitialDir = NULL;
        ofn.lpstrTitle = NULL;
        ofn.Flags = OFN_DONTADDTORECENT | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST; 
        ofn.lpstrDefExt = NULL;
        ofn.pvReserved = NULL;
        ofn.dwReserved = 0;
        ofn.FlagsEx = 0;

        if (GetOpenFileName(&ofn))
        {
                LoadDataFile(ofn.lpstrFile);
        }
}

BOOL CALLBACK ToolBarProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
        char ntext[20];

        switch (uMsg)
        {
        case WM_INITDIALOG:
                SendMessage(GetDlgItem(hwndDlg, IDC_BRIGHT), WM_SETTEXT, 0, (LPARAM)L"0.50");
                SendMessage(GetDlgItem(hwndDlg, IDC_BRIGHT_SLIDE), TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0,100));
                SendMessage(GetDlgItem(hwndDlg, IDC_BRIGHT_SLIDE), TBM_SETPOS, (WPARAM)TRUE, (LPARAM)50);

                SendMessage(GetDlgItem(hwndDlg, IDC_CONTRAST), WM_SETTEXT, 0, (LPARAM)L"0.50");
                SendMessage(GetDlgItem(hwndDlg, IDC_CONTRAST_SLIDE), TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0,100));
                SendMessage(GetDlgItem(hwndDlg, IDC_CONTRAST_SLIDE), TBM_SETPOS, (WPARAM)TRUE, 50);

                SendMessage(GetDlgItem(hwndDlg, IDC_GAMMA), WM_SETTEXT, 0, (LPARAM)L"1.00");
                SendMessage(GetDlgItem(hwndDlg, IDC_GAMMA_SLIDE), TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0,40));
                SendMessage(GetDlgItem(hwndDlg, IDC_GAMMA_SLIDE), TBM_SETPOS, (WPARAM)TRUE, 10);

                return TRUE;
        case WM_HSCROLL:
                if (LOWORD(wParam) == SB_ENDSCROLL)
                        return 0;

                if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_BRIGHT_SLIDE))
                {
                        brightness = (float)(SendMessage((HWND)lParam, TBM_GETPOS, 0, 0)) / 100.0f;
                        swprintf((LPWSTR)ntext, L"%1.2f", brightness);
                        SendMessage(GetDlgItem(hwndDlg, IDC_BRIGHT), WM_SETTEXT, 0, (LPARAM)ntext);

                        brightness = clamp(brightness, 0.0001f, 0.9999f);

                        if (LOWORD(wParam) != SB_THUMBTRACK)
                        {
                                ShovelData();
                        }
                }

                if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_CONTRAST_SLIDE))
                {
                        contrast = (float)SendMessage((HWND)lParam, TBM_GETPOS, 0, 0) / 100.0f;
                        swprintf((LPWSTR)ntext, L"%1.2f", contrast);
                        SendMessage(GetDlgItem(hwndDlg, IDC_CONTRAST), WM_SETTEXT, 0, (LPARAM)ntext);

                        contrast = clamp(contrast, 0.0001f, 0.9999f);

                        if (LOWORD(wParam) != SB_THUMBTRACK)
                        {
                                ShovelData();
                        }
                }

                if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_GAMMA_SLIDE))
                {
                        gamma = (float)SendMessage((HWND)lParam, TBM_GETPOS, 0, 0) / 10.0f;
                        swprintf((LPWSTR)ntext, L"%1.2f", gamma);
                        SendMessage(GetDlgItem(hwndDlg, IDC_GAMMA), WM_SETTEXT, 0, (LPARAM)ntext);

                        if (LOWORD(wParam) != SB_THUMBTRACK)
                        {
                                ShovelData();
                        }
                }
                return 0;
        case WM_COMMAND:
                break;
        }
        return FALSE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        PAINTSTRUCT ps;
        HDC hdc;
        RECT crect;

        switch (message)
        {
        case WM_MOUSEWHEEL:
                // catch mousewheel movement and forward to child windows
                POINT cpos;

                GetCursorPos(&cpos);

                // check each window if the cursor is in it
                GetWindowRect(wnd_front, &crect);
                if (cpos.x > crect.left && cpos.x < crect.right &&
                        cpos.y > crect.top && cpos.y < crect.bottom)
                {
                        PostMessage(wnd_front, WM_MOUSEWHEEL, wParam, lParam);
                }

                GetWindowRect(wnd_left, &crect);
                if (cpos.x > crect.left && cpos.x < crect.right &&
                        cpos.y > crect.top && cpos.y < crect.bottom)
                {
                        PostMessage(wnd_left, WM_MOUSEWHEEL, wParam, lParam);
                }

                GetWindowRect(wnd_top, &crect);
                if (cpos.x > crect.left && cpos.x < crect.right &&
                        cpos.y > crect.top && cpos.y < crect.bottom)
                {
                        PostMessage(wnd_top, WM_MOUSEWHEEL, wParam, lParam);
                }

                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                // Parse the menu selections:
                switch (wmId)
                {
                case IDM_ABOUT:
                        DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                        break;
                case IDM_EXIT:
                        DestroyWindow(hWnd);
                        break;
                case ID_FILE_OPEN:
                        GetOpenFile();
                        break;
                case ID_FILE_OPTIONS:
                        DialogBox(hInst, MAKEINTRESOURCE(IDD_OPTIONS), hWnd, OptionsProc);
                        break;
                default:
                        return DefWindowProc(hWnd, message, wParam, lParam);
                }
                break;
        case WM_PAINT:
                hdc = BeginPaint(hWnd, &ps);
                EndPaint(hWnd, &ps);
                break;
        case WM_SIZE:
                // post the size message to our splitter, it takes care of
                // resizing the child windows
                if (wnd_splitter)
                {
                        PostMessage(wnd_splitter, WM_SIZE, 0, 0);
                }
                // resize the toolbar
                GetClientRect(hWnd, &crect);

                SetWindowPos(wnd_tool, NULL, 0, 0, crect.right, TOOL_HEIGHT, SWP_NOMOVE);
                break;
        case WM_CREATE:
                // create the toolbar
                wnd_tool = CreateDialog(hInst, MAKEINTRESOURCE(IDD_TOOL), hWnd, ToolBarProc);
                // create the main splitter
                wnd_splitter = CreateWindowEx(WS_EX_WINDOWEDGE,
                        L"SplitterWnd",
                        L"",
                        WS_CHILD,
                        300,
                        TOOL_HEIGHT,
                        SPLITTER_WIDTH,
                        500,
                        hWnd,
                        NULL, NULL, NULL);
                // create the right ray casting window
                wnd_3d = CreateWindowEx(WS_EX_CLIENTEDGE,
                        L"RayWnd",
                        L"",
                        WS_CHILD,
                        300 + SPLITTER_WIDTH, TOOL_HEIGHT, 500, 500, hWnd,
                        NULL, NULL, NULL);

                //create the three orthographic views
                wnd_front = CreateWindowEx(WS_EX_CLIENTEDGE,
                        L"OrthoWnd",
                        L"",
                        WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                        0, TOOL_HEIGHT, 300, 200, hWnd,
                        NULL, NULL, NULL);
                wnd_left = CreateWindowEx(WS_EX_CLIENTEDGE,
                        L"OrthoWnd",
                        L"",
                        WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                        0, 300, 200, 200, hWnd,
                        NULL, NULL, NULL);
                wnd_top = CreateWindowEx(WS_EX_CLIENTEDGE,
                        L"OrthoWnd",
                        L"",
                        WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                        0, 300, 200, 200, hWnd,
                        NULL, NULL, NULL);
                wnd_histogram = CreateWindowEx(WS_EX_CLIENTEDGE,
                        L"HistogramWnd",
                        L"",
                        WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                        0, 300, 200, 200, hWnd,
                        NULL, NULL, NULL);

                ShowWindow(wnd_splitter, SW_SHOW);
                ShowWindow(wnd_3d, SW_SHOW);

                ShowWindow(wnd_front, SW_SHOW);
                ShowWindow(wnd_left, SW_SHOW);
                ShowWindow(wnd_top, SW_SHOW);

                ShowWindow(wnd_histogram, SW_SHOW);

                break;
        case WM_DESTROY:
                PostQuitMessage(0);
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;
}

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
        UNREFERENCED_PARAMETER(lParam);
        switch (message)
        {
        case WM_INITDIALOG:
                return (INT_PTR)TRUE;

        case WM_COMMAND:
                if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
                {
                        EndDialog(hDlg, LOWORD(wParam));
                        return (INT_PTR)TRUE;
                }
                break;
        }
        return (INT_PTR)FALSE;
}

---