windows-xp/Source/XPSP1/NT/termsrv/common/trace/ezippy/zippywindow.cpp

/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    Zippy Main Window

Abstract:

    This class implements the main window for zippy as well as controlling
    its child windows.

Author:

    Marc Reyhner 8/28/2000

--*/

#include "stdafx.h"
#include "ZippyWindow.h"
#include "resource.h"
#include "eZippy.h"
#include "richedit.h"
#include "ModalDialog.h"
#include "TraceManager.h"
#include "OptionsDialog.h"


BOOL CZippyWindow::gm_Inited = FALSE;
ATOM CZippyWindow::gm_Atom = NULL;
UINT CZippyWindow::gm_FindMessageStringMsg = 0;

static DWORD CALLBACK SaveCallback(DWORD_PTR dwCookie,LPBYTE pbBuff,LONG cb,LONG *pcb);


#define TRC_PROC_FMT                    _T("%04.4lx")
#define SAVE_FILE_TYPE                  _T("Text Files (*.txt)\0*.txt\0")
#define SAVE_FILE_EXTENSION             _T("txt")
#define SAVE_CONF_FILE_TYPE             _T("Trace Configuration Files (*.tcf)\0*.tcf\0")
#define SAVE_CONF_FILE_EXTENSION        _T("tcf")
#define NUM_COLORS                      15
#define APPENDMUTEXNAME                 _T("Local\\MicrosoftTerminalServerTraceViewerAppendMutex")
#define ZIPPY_WINDOW_POS_VALUE          _T("WindowPosition")
#define WINDOW_DEF_TOP                  50
#define WINDOW_DEF_BOTTOM               530
#define WINDOW_DEF_RIGHT                690
#define WINDOW_DEF_LEFT                 50

// We use an 80 character buffer for find
// and replace operations.
#define FIND_REPLACE_BUFFER_SIZE        80

// This list of colors we cycle through.  Note if you change this
// list you need to update NUM_COLORS to the new count.
static COLORREF colors[NUM_COLORS] = {
    RGB(153,51,0),  /* Brown */
    RGB(0,51,102),  /* Dark Teal */
    RGB(51,51,153), /* Indigo */
    RGB(128,0,0),   /* Dark Red */
    RGB(255,102,0), /* Orange */
    RGB(0,128,0),   /* Green */
    RGB(0,0,255),   /* Blue */
    RGB(255,0,0),   /* Red */
    RGB(51,204,204),/* Acqua */
    RGB(128,0,128), /* Violet */
    RGB(255,0,255), /* Pink */
    RGB(255,255,0), /* Yellow */
    RGB(0,255,0),   /* Bright Green */
    RGB(0,255,255), /* Turquoise */
    RGB(204,153,255)/* Lavender */
    };

//
//  *** Public Class Members ***
//

CZippyWindow::CZippyWindow(
    )

/*++

Routine Description:

    The constructor simply initializes the class variables.

Arguments:

    None

Return value:
    
    None

--*/
{
    m_bIsTracing = TRUE;
    m_bIsStoringTraceData = FALSE;
    ZeroMemory(m_threadHistory,sizeof(m_threadHistory));
    m_nextThreadIndex = 0;
    m_nextThreadColor = 0;
    m_lastProcessId = 0;
    m_LastLogEndedInNewLine = TRUE;
    m_hWnd = NULL;
    m_hStatusWnd = NULL;
    m_hControlWnd = NULL;
    m_hWndFindReplace = NULL;
    m_lpSavedOutputStart = NULL;
    m_lpSavedOutputTail = NULL;
    ZeroMemory(&m_FindReplace,sizeof(m_FindReplace));
    ZeroMemory(m_SaveFile,sizeof(m_SaveFile));
    ZeroMemory(m_SaveConfFile,sizeof(m_SaveConfFile));
    ZeroMemory(m_LoadConfFile,sizeof(m_LoadConfFile));
}

CZippyWindow::~CZippyWindow(
    )

/*++

Routine Description:

    Cleans up any dynamicly allocated memory,

Arguments:

    None

Return value:
    
    None

--*/
{
    if (m_FindReplace.lpstrFindWhat) {
        HeapFree(GetProcessHeap(),0,m_FindReplace.lpstrFindWhat);
    }
    if (m_FindReplace.lpstrReplaceWith) {
        HeapFree(GetProcessHeap(),0,m_FindReplace.lpstrReplaceWith);
    }
}



DWORD CZippyWindow::Create(
    IN CTraceManager *rTracer
    )

/*++

Routine Description:

    Actually creates the zippy window.

Arguments:

    rTracer - A pointer to the trace manager

Return value:
    
    0 - Success

    Non zero - An error occurred creating the window

--*/
{
	DWORD dwResult;
    DWORD dwWindowStyleEx;
    DWORD dwWindowStyle;
    TCHAR wndTitle[MAX_STR_LEN];
    RECT wndRect;

    m_rTracer = rTracer;
	if (!gm_Inited) {
		dwResult = _InitClassStaticMembers();
		if (dwResult != ERROR_SUCCESS) {
			return dwResult;
		}
	}
    
    m_hAppendMutex = CreateMutex(NULL,FALSE,APPENDMUTEXNAME);

    m_FindReplace.lStructSize = sizeof(m_FindReplace);

    m_FindReplace.lpstrFindWhat = (LPTSTR)HeapAlloc(GetProcessHeap(),
        HEAP_ZERO_MEMORY,FIND_REPLACE_BUFFER_SIZE*sizeof(TCHAR));
    if (!m_FindReplace.lpstrFindWhat) {
        return GetLastError();
    }

    m_FindReplace.lpstrReplaceWith = (LPTSTR)HeapAlloc(GetProcessHeap(),
        HEAP_ZERO_MEMORY,FIND_REPLACE_BUFFER_SIZE*sizeof(TCHAR));
    if (!m_FindReplace.lpstrReplaceWith) {
        return GetLastError();
    }

    LoadStringSimple(IDS_ZIPPYWINDOWTITLE,wndTitle);
    
    GetSavedWindowPos(&wndRect);

    dwWindowStyleEx = WS_EX_WINDOWEDGE;
    dwWindowStyle = WS_OVERLAPPEDWINDOW|WS_CLIPSIBLINGS|WS_VISIBLE;
    m_hWnd = CreateWindowEx(dwWindowStyleEx, (LPTSTR)gm_Atom, wndTitle,
        dwWindowStyle, wndRect.left, wndRect.top, wndRect.right,
        wndRect.bottom,NULL,NULL,g_hInstance,this);
    if (!m_hWnd) {
        return GetLastError();
    }

	return ERROR_SUCCESS;
}

VOID
CZippyWindow::AppendTextToWindow(
    IN DWORD processID,
    IN LPCTSTR text,
    IN UINT len
    )

/*++

Routine Description:

    Appends new trace data to the end of the rich edit contrl

Arguments:

    processID - Process ID of the process sending the debug string

    text - The data sent via OutputDebugString

    len - Length of the data

Return value:
    
    None

--*/
{
    UINT controlTextLength;
    CHARRANGE newSel;
    BOOL computeColor;
    BOOL setNewColor;
    CHARFORMAT newFormat;
    LPSAVEDOUTPUT lpSave;

    if (!m_bIsTracing) {
        return;
    }

    WaitForSingleObject(m_hAppendMutex,INFINITE);

    if (m_bIsStoringTraceData) {
        // This is kinda sketchy but what we do is to allocate room for the string
        // at the end of the structure. There shouldn't be any alignment problems
        // since we need to align on a short and the structure has no items
        // to get that off.
        lpSave = (LPSAVEDOUTPUT)HeapAlloc(GetProcessHeap(),0,sizeof(SAVEDOUTPUT) + 
            (sizeof(TCHAR) * (len+1)));
        if (!lpSave) {
            // eom error?
            goto CLEANUP_AND_EXIT;
        }
        lpSave->procID = processID;
        lpSave->text = (LPTSTR)((BYTE)lpSave + sizeof(SAVEDOUTPUT));
        _tcscpy(lpSave->text,text);
        lpSave->len = len;
        lpSave->next = NULL;

        if (!m_lpSavedOutputTail) {
            m_lpSavedOutputStart = lpSave;
        } else {
            m_lpSavedOutputTail->next = lpSave;
        }
        m_lpSavedOutputTail = lpSave;
        goto CLEANUP_AND_EXIT;
    }

    if (m_lastProcessId != processID ||
        m_LastLogEndedInNewLine) {
        computeColor = TRUE;
    } else {
        computeColor = FALSE;
    }

    setNewColor = ComputeNewColor(processID,text,len,&newFormat);

    m_LastLogEndedInNewLine = (text[len-1] == '\n') ? TRUE : FALSE;
    m_lastProcessId = processID;

    controlTextLength = (UINT)SendMessage(m_hControlWnd,WM_GETTEXTLENGTH,0,0);
    newSel.cpMin = controlTextLength;
    newSel.cpMax = controlTextLength+1;

    
    // set the new text
    SendMessage(m_hControlWnd,EM_EXSETSEL,0,(LPARAM)&newSel);
    if (setNewColor) {
        SendMessage(m_hControlWnd,EM_SETCHARFORMAT,SCF_SELECTION,(LPARAM)&newFormat);
    }
    SendMessage(m_hControlWnd,EM_REPLACESEL,0,(LPARAM)text);
    
CLEANUP_AND_EXIT:

    ReleaseMutex(m_hAppendMutex);
}

VOID
CZippyWindow::LoadConfFile(
    IN LPTSTR confFile
    )

/*++

Routine Description:

    This sets the tracing configuration using the given file

Arguments:

    confFile - File containing the tracing configuration

Return value:
    
    None

--*/
{
    _tcscpy(m_LoadConfFile,confFile);
    DoLoadConfInternal();
}

BOOL
CZippyWindow::IsDialogMessage(
    IN LPMSG lpMsg
    )

/*++

Routine Description:

    This calls IsDialogMessage on any non modal dialogs that this window
    is hosting to see if the message is for them

Arguments:

    lpMsg - Message to check if it is a dialog message

Return value:
    
    TRUE - The message did belong to a dialog

    FALSE - The message did not belong to a dialog

--*/
{
    if (IsWindow(m_hWndFindReplace)) {
        // The :: below is necessary to make it use the Win32 function
        // not our method
        return ::IsDialogMessage(m_hWndFindReplace,lpMsg);
    }
    return FALSE;
}

INT WINAPI
CZippyWindow::TranslateAccelerator(
    IN HACCEL hAccTable,
    IN LPMSG lpMsg
    )

/*++

Routine Description:

    This calls the win32 TranslateAccelerator to determine
    if the given message is an accelerator for this window

Arguments:

    hAccTable - Accelerator table to use

    lpMsg - Message to check

Return value:
    
    See Win32 TranslateAccelerator documentation

--*/
{
    // :: Necessary to get the win32 call.
    return ::TranslateAccelerator(m_hWnd,hAccTable,lpMsg);
}


//
//  *** Private Class Members ***
//

// static members


DWORD
CZippyWindow::_InitClassStaticMembers(
	)

/*++

Routine Description:

    Creates the window class for zippy and registers
    for the FINDMSGSTRING windows message

Arguments:

    None

Return value:
    
    0 - Success

    Non zero - Win32 error code

--*/
{
	WNDCLASS wndClass;
    HMODULE hLibrary;

    // We want to load RichEdit for the lifetime of our app.
    hLibrary = LoadLibrary(_T("Riched20.dll"));
    if (!hLibrary) {
        return GetLastError();
    }

    ZeroMemory(&wndClass,sizeof(wndClass));

	wndClass.style = CS_PARENTDC;
	wndClass.lpfnWndProc = _WindowProc;
    wndClass.hInstance = g_hInstance;
    wndClass.hIcon = (HICON)LoadImage(g_hInstance,MAKEINTRESOURCE(IDI_MAINFRAME),
        IMAGE_ICON,0,0,LR_SHARED);
    wndClass.hbrBackground = (HBRUSH)COLOR_WINDOWFRAME;
    wndClass.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
	wndClass.lpszClassName = _T("ZippyWindowClass");

    gm_Atom = RegisterClass(&wndClass);
    if (!gm_Atom) {
        return GetLastError();
    }

    gm_FindMessageStringMsg = RegisterWindowMessage(FINDMSGSTRING);
    if (!gm_FindMessageStringMsg) {
        return GetLastError();
    }

    gm_Inited = TRUE;

    return ERROR_SUCCESS;
}

LRESULT CALLBACK
CZippyWindow::_WindowProc(
    IN HWND hWnd,
    IN UINT uMsg,
    IN WPARAM wParam, 
    IN LPARAM lParam)

/*++

Routine Description:

    Static version of the window proc.  On WM_CREATE it calls OnCreate,
    otherwise it calls the non-static window proc

Arguments:

    See Win32 Window Proc docs

Return value:
    
    Message specific.  See individual handlers for detail.

--*/
{
    CZippyWindow *theClass;

    if (uMsg == WM_CREATE) {
        SetLastError(0);
        theClass = (CZippyWindow *)((LPCREATESTRUCT)lParam)->lpCreateParams;
        SetWindowLongPtr(hWnd,GWLP_USERDATA,(LONG_PTR)theClass);
        if (GetLastError()) {
            return -1;
        }
        return theClass->OnCreate(hWnd);
    }
    theClass = (CZippyWindow*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
    if (theClass) {
        return theClass->WindowProc(hWnd,uMsg,wParam,lParam);
    } else {
        return DefWindowProc(hWnd,uMsg,wParam,lParam);
    }
}

LRESULT CALLBACK
CZippyWindow::WindowProc(
    IN HWND hWnd,
    IN UINT uMsg,
    IN WPARAM wParam, 
    IN LPARAM lParam)

/*++

Routine Description:

    Non-static window proc.  Either calls the default window proc or
    refers to the individual message handlers

Arguments:

    See Win32 Window Proc docs

Return value:
    
    Message specific.  See individual handlers for detail.

--*/
{
    
    LRESULT retCode = 0;

    switch (uMsg) {
    case WM_COMMAND:
        OnCommand(wParam,lParam);
        break;
    case WM_SETFOCUS:
        OnSetFocus();
        break;
    case WM_SIZE:
        OnSize(LOWORD(lParam),HIWORD(lParam));
        break;
    case WM_INITMENUPOPUP:
        OnInitMenuPopup(wParam,lParam);
        break;
    case WM_MENUSELECT:
        OnMenuSelect(wParam,lParam);
        break;
    case WM_CLOSE:
        OnClose();
        break;
    case WM_DESTROY:
        OnDestroy();
        break;
    default:
        if (uMsg == gm_FindMessageStringMsg) {
            OnFindMessageString(lParam);
        } else {
            retCode = DefWindowProc(hWnd,uMsg,wParam,lParam);
        }
        break;
    }

    return retCode;
}


LRESULT
CZippyWindow::OnCreate(
    IN HWND hWnd
    )

/*++

Routine Description:

    Creates the child windows and sets their initial parameters

Arguments:

    hWnd - Pointer to the new main window

Return value:
    
    0 - Window was created

    -1 - Error occurred

--*/
{
    DWORD dwStyle;
    CHARFORMAT charFormat;
    TCHAR readyString[MAX_STR_LEN];

    dwStyle = WS_CHILD|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL|ES_SUNKEN|
        ES_MULTILINE|ES_LEFT|ES_AUTOHSCROLL|ES_AUTOVSCROLL|ES_NOHIDESEL;
    m_hControlWnd = CreateWindow(RICHEDIT_CLASS,_T(""),
        dwStyle,0,0,0,0,hWnd,NULL,g_hInstance,NULL);
    if (!m_hControlWnd) {
        return -1;
    }
    
    dwStyle = SBARS_SIZEGRIP|WS_CHILD|WS_VISIBLE;

    m_hStatusWnd = CreateWindow(STATUSCLASSNAME,NULL,dwStyle,0,0,0,0,hWnd,NULL,
        g_hInstance,NULL);
    if (!m_hStatusWnd) {
        return -1;
    }

    LoadStringSimple(IDS_STATUSBARREADY,readyString);
    SendMessage(m_hStatusWnd,SB_SETTEXT,0|SBT_NOBORDERS,(LPARAM)readyString);


    charFormat.cbSize = sizeof(charFormat);
    charFormat.dwMask = CFM_FACE|CFM_SIZE;
    charFormat.yHeight = ZIPPY_FONT_SIZE*20;
    _tcscpy(charFormat.szFaceName,ZIPPY_FONT);

    // 4 billion characters should be a large enough limit...
    SendMessage(m_hControlWnd,EM_EXLIMITTEXT,0,0xFFFFFFFF);

    SendMessage(m_hControlWnd,EM_SETCHARFORMAT,SCF_ALL,(LPARAM)&charFormat);

    SendMessage(m_hControlWnd,EM_SETMODIFY,FALSE,0);

    SendMessage(m_hControlWnd,EM_EMPTYUNDOBUFFER,0,0);


    return 0;
}

VOID
CZippyWindow::OnMenuSelect(
    IN WPARAM wParam,
    IN LPARAM lParam
    )

/*++

Routine Description:

    Sets the help string in the status bar for the selected menu.

Arguments:

    wParam - menu itemid (LOWORD) and flags (HIWORD)

    lParam - menu handle

Return value:
    
    None

--*/
{
    UINT item;
    UINT flags;
    HMENU hMenu;
    TCHAR statusMessage[MAX_STR_LEN];

    item = LOWORD(wParam);
    flags = HIWORD(wParam);
    hMenu = (HMENU)lParam;

    if (!item && flags == 0xFFFF) {
        // the menu was closed.  Go back to the ready string.
        LoadStringSimple(IDS_STATUSBARREADY,statusMessage);
        SendMessage(m_hStatusWnd,SB_SETTEXT,0|SBT_NOBORDERS,(LPARAM)statusMessage);
        return;
    }
    if (flags & MF_POPUP) {
        statusMessage[0] = 0;
    } else if (!LoadStringSimple(item,statusMessage)) {
        // if we can't find the help string use the empty string.
        statusMessage[0] = 0;
    }
    SendMessage(m_hStatusWnd,SB_SETTEXT,0|SBT_NOBORDERS,(LPARAM)statusMessage);

}

VOID
CZippyWindow::OnSize(
    IN INT width,
    IN INT height
    )

/*++

Routine Description:

    Resizes client windows to reflect the new size of the main window

Arguments:

    width - New width of the client area

    height - New height of the client area

Return value:
    
    None

--*/
{
    RECT statusBarArea;
    UINT statusBarHeight;
    RECT wndRect;

    if (!(width==0&&height==0)) {
        if (GetWindowRect(m_hWnd,&wndRect)) {
            SaveWindowPos(&wndRect);
        }
    }
    if (IsWindowVisible(m_hStatusWnd)) {
        GetWindowRect(m_hStatusWnd,&statusBarArea);
        statusBarHeight = statusBarArea.bottom - statusBarArea.top;

        SetWindowPos(m_hControlWnd,NULL,0,0,width,height-statusBarHeight,SWP_NOZORDER);
        
        // the status bar autosizes.  We just need to tell it that it should
        SetWindowPos(m_hStatusWnd,NULL,0,0,0,0,SWP_NOZORDER);
    } else {
        SetWindowPos(m_hControlWnd,NULL,0,0,width,height,SWP_NOZORDER);
    }
}

VOID
CZippyWindow::OnSetFocus(
    )

/*++

Routine Description:

    When we get focus we kick it down to the rich edit control

Arguments:

    None

Return value:
    
    None

--*/
{
    SetFocus(m_hControlWnd);
}

VOID
CZippyWindow::OnInitMenuPopup(
    IN WPARAM wParam,
    IN LPARAM lParam
    )

/*++

Routine Description:

    When the user opens the menus we need to specify
    which are disabled and which are checked. Note that
    the menu id's are hard coded.  I've commented which
    corespond to which for the switch statement

Arguments:

    wParam - The menu handle

    lParam - (loword) the menu item id

Return value:
    
    None

--*/
{
    HMENU hMenu;
    WORD item;
    
    item = LOWORD(lParam);
    hMenu = (HMENU)wParam;

    switch (item) {
        case 1: // Edit Menu
            UINT canUndo;
            UINT canRedo;
            UINT cutCopyEnabled;
            UINT pasteEnabled;
            UINT selectAllEnabled;
            UINT findEnabled;
            UINT findNextEnabled;
            UINT replaceEnabled;
            LRESULT textLength;
            CHARRANGE selRegion;

            if (SendMessage(m_hControlWnd,EM_CANUNDO,0,0)) {
                canUndo = MF_ENABLED;
            } else {
                canUndo = MF_GRAYED;
            }
            if (SendMessage(m_hControlWnd,EM_CANREDO,0,0)) {
                canRedo = MF_ENABLED;
            } else {
                canRedo = MF_GRAYED;
            }

            textLength = SendMessage(m_hControlWnd,WM_GETTEXTLENGTH,0,0);
            if (textLength == 0) {
                selectAllEnabled = MF_GRAYED;
                findEnabled = MF_GRAYED;
                findNextEnabled = MF_GRAYED;
                replaceEnabled = MF_GRAYED;
            } else {
                selectAllEnabled = MF_ENABLED;
                findEnabled = MF_ENABLED;
                replaceEnabled = MF_ENABLED;
                if (m_FindReplace.lpstrFindWhat[0] != 0) {
                    findNextEnabled = MF_ENABLED;
                } else {
                    findNextEnabled = MF_GRAYED;
                }
            }
                            
            SendMessage(m_hControlWnd,EM_EXGETSEL,0,(LPARAM)&selRegion);
            if (selRegion.cpMax == selRegion.cpMin) {
                cutCopyEnabled = MF_GRAYED;
            } else {
                cutCopyEnabled = MF_ENABLED;
                // override select all since they selected the next character
                // to be typed
                selectAllEnabled = MF_ENABLED;
            }

            if (SendMessage(m_hControlWnd,EM_CANPASTE,0,0)) {
                pasteEnabled = MF_ENABLED;
            } else {
                pasteEnabled = MF_GRAYED;
            }
            
            EnableMenuItem(hMenu,ID_EDIT_UNDO,MF_BYCOMMAND|canUndo);
            EnableMenuItem(hMenu,ID_EDIT_REDO,MF_BYCOMMAND|canRedo);
            EnableMenuItem(hMenu,ID_EDIT_CUT,MF_BYCOMMAND|cutCopyEnabled);
            EnableMenuItem(hMenu,ID_EDIT_COPY,MF_BYCOMMAND|cutCopyEnabled);
            EnableMenuItem(hMenu,ID_EDIT_PASTE,MF_BYCOMMAND|pasteEnabled);
            EnableMenuItem(hMenu,ID_EDIT_SELECTALL,MF_BYCOMMAND|selectAllEnabled);
            EnableMenuItem(hMenu,ID_EDIT_FIND,MF_BYCOMMAND|findEnabled);
            EnableMenuItem(hMenu,ID_EDIT_FINDNEXT,MF_BYCOMMAND|findNextEnabled);
            EnableMenuItem(hMenu,ID_EDIT_REPLACE,MF_BYCOMMAND|replaceEnabled);
            break;
        case 2: // View Menu
            UINT statusBarChecked;

            if (IsWindowVisible(m_hStatusWnd)) {
                statusBarChecked = MF_CHECKED;
            } else {
                statusBarChecked = MF_UNCHECKED;
            }
            CheckMenuItem(hMenu,ID_VIEW_STATUSBAR,MF_BYCOMMAND|statusBarChecked);
            
            break;
        case 3: // Monitoring Menu
            UINT startActivated;
            UINT stopActivated;

            if (m_bIsTracing) {
                startActivated = MF_GRAYED;
                stopActivated = MF_ENABLED;
            } else {
                startActivated = MF_ENABLED;
                stopActivated = MF_GRAYED;
            }

            EnableMenuItem(hMenu,ID_MONITORING_START,MF_BYCOMMAND|startActivated);
            EnableMenuItem(hMenu,ID_MONITORING_STOP,MF_BYCOMMAND|stopActivated);
            // record is activated when stop is.
            EnableMenuItem(hMenu,ID_MONITORING_RECORD,MF_BYCOMMAND|stopActivated);
            break;
    }
}

VOID
CZippyWindow::OnFindMessageString(
    IN LPARAM lParam
    )

/*++

Routine Description:

    This handles a message from the find/replace
    dialog when a user hits a button

Arguments:

    lParam - LPFINDREPLACE struct for the dialog

Return value:
    
    None

--*/
{
    LPFINDREPLACE lpFindReplace;
    
    lpFindReplace = (LPFINDREPLACE)lParam;

    if (lpFindReplace->Flags & FR_DIALOGTERM) {
        // the dialog is closing
        m_hWndFindReplace = NULL;
    } else if (lpFindReplace->Flags & FR_FINDNEXT) {
        // the user selected find
        DoFindNext(lpFindReplace);
    } else if (lpFindReplace->Flags & FR_REPLACE) {
        DoReplace(lpFindReplace);
    } else if (lpFindReplace->Flags & FR_REPLACEALL) {
        DoReplaceAll(lpFindReplace);
    }
}

VOID
CZippyWindow::OnClose(
    )

/*++

Routine Description:

    When we receive a close window request we prompt
    the user to sace the trace if they have changed it.

Arguments:

    None

Return value:
    
    None

--*/
{
    INT result;
    TCHAR dlgMessage[MAX_STR_LEN];
    TCHAR dlgTitle[MAX_STR_LEN];

    if (SendMessage(m_hControlWnd,EM_GETMODIFY,0,0)) {
        LoadStringSimple(IDS_SAVEFILEPROMPT,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        result = MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_YESNOCANCEL|MB_ICONQUESTION);
        switch (result) {
        case IDYES:
            OnSave();
            if (SendMessage(m_hControlWnd,EM_GETMODIFY,0,0)) {
                // if there was an error saving we will try again.
                PostMessage(m_hWnd,WM_CLOSE,0,0);
                return;
            }
        case IDNO:
            DestroyWindow(m_hWnd);
            break;
        }
    } else {
        DestroyWindow(m_hWnd);
    }
}

VOID
CZippyWindow::OnDestroy(
    )

/*++

Routine Description:

    When the main window exits we halt the message loop

Arguments:

    None

Return value:
    
    None

--*/
{
    // If we don't clean up the tracing stuff here. There is a long
    // delay exiting for some reason.
    CTraceManager::_CleanupTraceManager();
    PostQuitMessage(0);
}



VOID
CZippyWindow::OnCommand(
    IN WPARAM wParam,
    IN LPARAM lParam
    )

/*++

Routine Description:

    Below is WM_COMMAND and all the handler functions.
    The individual handler funcitons are not
    that interesting so I didn't individually comment them.

Arguments:

    wParam - (loword) command the user selected

    lParam - not used but it is the control

Return value:
    
    None

--*/
{
    WORD command;

    command = LOWORD(wParam);

    switch (command) {
    case ID_FILE_SAVE:
        OnSave();
        break;
    case ID_FILE_SAVEAS:
        OnSaveAs();
        break;
    case ID_FILE_LOADCONF:
        OnLoadConfiguration();
        break;
    case ID_FILE_SAVECONF:
        OnSaveConfiguration();
        break;
    case ID_FILE_SAVECONFAS:
        OnSaveConfigurationAs();
        break;
    case ID_FILE_EXIT:
        OnExit();
        break;
    case ID_EDIT_UNDO:
        OnUndo();
        break;
    case ID_EDIT_REDO:
        OnRedo();
        break;
    case ID_EDIT_CUT:
        OnCut();
        break;
    case ID_EDIT_COPY:
        OnCopy();
        break;
    case ID_EDIT_PASTE:
        OnPaste();
        break;
    case ID_EDIT_FIND:
        OnFind();
        break;
    case ID_EDIT_FINDNEXT:
        OnFindNext();
        break;
    case ID_EDIT_REPLACE:
        OnReplace();
        break;
    case ID_EDIT_SELECTALL:
        OnSelectAll();
        break;
    case ID_VIEW_STATUSBAR:
        OnChangeStatusBar();
        break;
    case ID_MONITORING_START:
        OnStartTracing();
        break;
    case ID_MONITORING_STOP:
        OnStopTracing();
        break;
    case ID_MONITORING_RECORD:
        OnRecordTracing();
        break;
    case ID_MONITORING_CLEARSCREEN:
        OnClearScreen();
        break;
    case ID_MONITORING_RESETTRACEFILES:
        OnResetTraceFiles();
        break;
    case ID_MONITORING_PREFERENCES:
        OnPreferences();
        break;
    case ID_HELP_ABOUTEZIPPY:
        OnAbout();
        break;
    }
}

VOID CZippyWindow::OnSave()
{
    if (m_SaveFile[0] == 0) {
        // if we don't have a file name do the
        // Save As version
        OnSaveAs();
    } else {
        DoSaveInternal();
    }
}

VOID CZippyWindow::OnSaveAs()
{
    OPENFILENAME fileInfo;
    BOOL bResult;

    ZeroMemory(&fileInfo,sizeof(fileInfo));

    fileInfo.lStructSize = sizeof(fileInfo);
    fileInfo.hwndOwner = m_hWnd;
    fileInfo.hInstance = g_hInstance;
    fileInfo.lpstrFilter = SAVE_FILE_TYPE;
    fileInfo.lpstrFile = m_SaveFile;
    fileInfo.nMaxFile = MAX_STR_LEN;
    fileInfo.Flags = OFN_OVERWRITEPROMPT;
    fileInfo.lpstrDefExt = SAVE_FILE_EXTENSION;

    bResult = GetSaveFileName(&fileInfo);
    if (!bResult) {
        return;
    }

    DoSaveInternal();
}

VOID CZippyWindow::OnLoadConfiguration()
{
    OPENFILENAME fileInfo;
    BOOL bResult;

    ZeroMemory(&fileInfo,sizeof(fileInfo));

    fileInfo.lStructSize = sizeof(fileInfo);
    fileInfo.hwndOwner = m_hWnd;
    fileInfo.hInstance = g_hInstance;
    fileInfo.lpstrFilter = SAVE_CONF_FILE_TYPE;
    fileInfo.lpstrFile = m_LoadConfFile;
    fileInfo.nMaxFile = MAX_STR_LEN;
    fileInfo.Flags = OFN_FILEMUSTEXIST;
    fileInfo.lpstrDefExt = SAVE_CONF_FILE_EXTENSION;

    bResult = GetOpenFileName(&fileInfo); 
    if (!bResult) {
        return;
    }

    DoLoadConfInternal();
}

VOID CZippyWindow::OnSaveConfiguration()
{
    if (m_SaveConfFile[0] == 0) {
        // if we don't have a file name do the
        // Save As version
        OnSaveConfigurationAs();
    } else {
        DoSaveConfInternal();
    }
}

VOID CZippyWindow::OnSaveConfigurationAs()
{
    OPENFILENAME fileInfo;
    BOOL bResult;

    ZeroMemory(&fileInfo,sizeof(fileInfo));

    fileInfo.lStructSize = sizeof(fileInfo);
    fileInfo.hwndOwner = m_hWnd;
    fileInfo.hInstance = g_hInstance;
    fileInfo.lpstrFilter = SAVE_CONF_FILE_TYPE;
    fileInfo.lpstrFile = m_SaveConfFile;
    fileInfo.nMaxFile = MAX_STR_LEN;
    fileInfo.Flags = OFN_OVERWRITEPROMPT;
    fileInfo.lpstrDefExt = SAVE_CONF_FILE_EXTENSION;

    bResult = GetSaveFileName(&fileInfo);
    if (!bResult) {
        return;
    }

    DoSaveConfInternal();
    
}

VOID CZippyWindow::OnExit()
{
    PostMessage(m_hWnd,WM_CLOSE,0,0);
}

// All the edit menu commands.  Except for select all they just call the
// corresponding message in the rich edit control. Select all has to
// manually set the selection

VOID CZippyWindow::OnUndo()
{
    SendMessage(m_hControlWnd,WM_UNDO,0,0);
}

VOID CZippyWindow::OnRedo()
{
    SendMessage(m_hControlWnd,EM_REDO,0,0);
}

VOID CZippyWindow::OnCut()
{
    SendMessage(m_hControlWnd,WM_CUT,0,0);
}

VOID CZippyWindow::OnCopy()
{
    SendMessage(m_hControlWnd,WM_COPY,0,0);
}

VOID CZippyWindow::OnPaste()
{
    SendMessage(m_hControlWnd,WM_PASTE,0,0);
}

VOID CZippyWindow::OnSelectAll()
{
    CHARRANGE selection;
    
    selection.cpMin = 0;
    selection.cpMax = -1;

    SendMessage(m_hControlWnd,EM_EXSETSEL,0,(LPARAM)&selection);
}

VOID CZippyWindow::OnFind()
{
    CHARRANGE currentSel;
    TEXTRANGE textRange;

    if (IsWindow(m_hWndFindReplace) && !m_bIsFindNotReplace) {
        // If they were in a replace dialog we destroy it and then
        // start over with a find dialog
        DestroyWindow(m_hWndFindReplace);
        m_hWndFindReplace = NULL;
    }
    if (!IsWindow(m_hWndFindReplace)) {
        SendMessage(m_hControlWnd,EM_EXGETSEL,0,(LPARAM)&currentSel);
    
        textRange.chrg.cpMin = currentSel.cpMin;
        if (currentSel.cpMax - currentSel.cpMin >=  FIND_REPLACE_BUFFER_SIZE) {
            textRange.chrg.cpMax = currentSel.cpMin + FIND_REPLACE_BUFFER_SIZE-1;
        } else {
            textRange.chrg.cpMax = currentSel.cpMax;
        }
        textRange.lpstrText = m_FindReplace.lpstrFindWhat;

        SendMessage(m_hControlWnd,EM_GETTEXTRANGE,0,(LPARAM)&textRange);

        m_bIsFindNotReplace = TRUE;
        m_FindReplace.hwndOwner = m_hWnd;
        m_FindReplace.hInstance = g_hInstance;
        m_FindReplace.Flags = FR_DOWN|FR_HIDEUPDOWN;
        m_FindReplace.wFindWhatLen = FIND_REPLACE_BUFFER_SIZE;
        m_hWndFindReplace = FindText(&m_FindReplace);
    } else {
        SetActiveWindow(m_hWndFindReplace);
    }

}

VOID CZippyWindow::OnFindNext()
{
    DoFindNext(&m_FindReplace);
}

VOID CZippyWindow::OnReplace()
{
    CHARRANGE currentSel;
    TEXTRANGE textRange;

    if (IsWindow(m_hWndFindReplace) && m_bIsFindNotReplace) {
        // If they were in a replace dialog we destroy it and then
        // start over with a find dialog
        DestroyWindow(m_hWndFindReplace);
        m_hWndFindReplace = NULL;
    }
    if (!IsWindow(m_hWndFindReplace)) {
        SendMessage(m_hControlWnd,EM_EXGETSEL,0,(LPARAM)&currentSel);
    
        textRange.chrg.cpMin = currentSel.cpMin;
        if (currentSel.cpMax - currentSel.cpMin >=  FIND_REPLACE_BUFFER_SIZE) {
            textRange.chrg.cpMax = currentSel.cpMin + FIND_REPLACE_BUFFER_SIZE-1;
        } else {
            textRange.chrg.cpMax = currentSel.cpMax;
        }
        textRange.lpstrText = m_FindReplace.lpstrFindWhat;
        SendMessage(m_hControlWnd,EM_GETTEXTRANGE,0,(LPARAM)&textRange);
        
        m_bIsFindNotReplace = FALSE;
        m_FindReplace.hwndOwner = m_hWnd;
        m_FindReplace.hInstance = g_hInstance;
        m_FindReplace.Flags = FR_DOWN;
        m_FindReplace.wFindWhatLen = FIND_REPLACE_BUFFER_SIZE;
        m_FindReplace.wReplaceWithLen = FIND_REPLACE_BUFFER_SIZE;
        m_hWndFindReplace = ReplaceText(&m_FindReplace);
    } else {
        SetActiveWindow(m_hWndFindReplace);
    }
}

VOID CZippyWindow::OnChangeStatusBar()
{
    RECT clientRect;
    
    if (IsWindowVisible(m_hStatusWnd)) {
        ShowWindow(m_hStatusWnd,SW_HIDE);
    } else {
        ShowWindow(m_hStatusWnd,SW_SHOW);
    }
    // we do this to make the client windows resize themselves
    // around the status bar

    GetClientRect(m_hWnd,&clientRect);
    OnSize(clientRect.right,clientRect.bottom);
}

VOID CZippyWindow::OnStartTracing()
{
    m_bIsTracing = TRUE;
}

VOID CZippyWindow::OnStopTracing()
{
    m_bIsTracing = FALSE;
}

VOID CZippyWindow::OnRecordTracing()
{
    CModalOkDialog recordDialog;
    LPSAVEDOUTPUT lpTemp;

    m_bIsStoringTraceData = TRUE;
    recordDialog.DoModal(MAKEINTRESOURCE(IDD_RECORDTRACE),m_hWnd);

    WaitForSingleObject(m_hAppendMutex,INFINITE);

    m_bIsStoringTraceData = FALSE;
    while (m_lpSavedOutputStart) {
        AppendTextToWindow(m_lpSavedOutputStart->procID,
            m_lpSavedOutputStart->text,m_lpSavedOutputStart->len);
        lpTemp = m_lpSavedOutputStart;
        m_lpSavedOutputStart = m_lpSavedOutputStart->next;
        HeapFree(GetProcessHeap(),0,lpTemp);
    }
    m_lpSavedOutputTail = NULL;

    ReleaseMutex(m_hAppendMutex);
}

VOID CZippyWindow::OnClearScreen()
{
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];

    LoadStringSimple(IDS_CLEARCONFIRMTITLE,dlgTitle);
    LoadStringSimple(IDS_CLEARCONFIRMMESSAGE,dlgMessage);

    if (IDYES != MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_YESNO)) {
        return;
    }

    OnSelectAll();
    SendMessage(m_hControlWnd, EM_REPLACESEL,FALSE,(LPARAM)_T(""));
}

VOID CZippyWindow::OnResetTraceFiles()
{
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];

    LoadStringSimple(IDS_CONFIRMRESETTRACETITLE,dlgTitle);
    LoadStringSimple(IDS_CONFIRMRESETTRACEMESSAGE,dlgMessage);

    if (IDYES != MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_YESNO)) {
        return;
    }

    m_rTracer->TRC_ResetTraceFiles();
}

VOID CZippyWindow::OnPreferences()
{
    COptionsDialog optionsDialog(m_rTracer);

    optionsDialog.DoDialog(m_hWnd);
}

VOID CZippyWindow::OnAbout()
{
    HICON appIcon;
    TCHAR appTitle[MAX_STR_LEN];
    TCHAR appOtherStuff[MAX_STR_LEN];

    LoadStringSimple(IDS_ABOUTAPPTITLE,appTitle);
    LoadStringSimple(IDS_ABOUTOTHERSTUFF,appOtherStuff);
    appIcon = (HICON)LoadImage(g_hInstance,MAKEINTRESOURCE(IDI_MAINFRAME),
        IMAGE_ICON,0,0,LR_SHARED);
    
    if( NULL != appIcon )
    {
      ShellAbout(m_hWnd,appTitle,appOtherStuff,appIcon);
    
    // even though the icon is shared we should destroy it to keep the reference
    // count somewhat sane.
      DestroyIcon(appIcon);
    }
}

//
//  *** Private Helper Functions ***
//

//
// Computes the color for the given debut output.  It parses the text to dtermine
// what the thread id is and then either retrieves the color for that thread or
// picks a new color
//
BOOL CZippyWindow::ComputeNewColor(DWORD processID, LPCTSTR text, UINT len, CHARFORMAT *lpFormat)
{
    LPTSTR procIdStr;
    DWORD threadId;
    LPCTSTR procBase;
    UINT maxStrLen;
    BOOL bSuccess;
    UINT threadLen;
    LPTHREADCOLOR newColor;

    procIdStr = NULL;
    bSuccess = TRUE;

    // first we will just make sure the format struct is in a safe state.
    lpFormat->cbSize = sizeof(CHARFORMAT);
    lpFormat->dwMask = 0;

    maxStrLen = sizeof(DWORD) * 2;
    
    procIdStr = (LPTSTR)HeapAlloc(GetProcessHeap(),0,sizeof(TCHAR) * (maxStrLen+1));
    if (!procIdStr) {
        bSuccess = FALSE;
        goto CLEANUP_AND_EXIT;
    }

    wsprintf(procIdStr,TRC_PROC_FMT,processID);

    procBase = _tcsstr(text,procIdStr);
    if (!procBase) {
        bSuccess = FALSE;
        goto CLEANUP_AND_EXIT;
    }

    procBase += _tcslen(procIdStr);

    if (*procBase != ':') {
        bSuccess = FALSE;
        goto CLEANUP_AND_EXIT;
    }
    procBase++;

    threadLen = 0;
    while (_istxdigit(*(procBase + threadLen))) {
        threadLen++;
    }
    if (!threadLen) {
        bSuccess = FALSE;
        goto CLEANUP_AND_EXIT;
    }
   
    threadId = ConvertHexStrToDword(procBase,threadLen);
    
    newColor = FindColorForThread(processID,threadId);

    lpFormat->crTextColor = newColor->color;
    lpFormat->dwEffects = 0;
    lpFormat->dwMask = CFM_COLOR;

CLEANUP_AND_EXIT:
    
    if (procIdStr) {
        HeapFree(GetProcessHeap(),0,procIdStr);
    }

    return bSuccess;
}

//
// This converts a hex string to the equivalent DWORD value for example
// the string "FF" would cause the function to return 0xFF (255)
//
DWORD CZippyWindow::ConvertHexStrToDword(LPCTSTR str, UINT strLen)
{
    DWORD total;
    TCHAR current;
    INT currentValue;

    total = 0;
    if (strLen == 0) {
        strLen = _tcslen(str);
    }

    while (strLen-- > 0) {
        current = *(str++);
        if (_istdigit(current)) {
            currentValue = current - '0';
        } else {
            current = (TCHAR)tolower((INT)current);
            currentValue = 10 + (current - 'a');
        }
        total = (total * 16) + currentValue;
    }

    return total;
}

// This looks up the color for the given thread.  If the thread has not been
// seen before a new color is picked and the color for the thread is saved.
LPTHREADCOLOR CZippyWindow::FindColorForThread(DWORD processId, DWORD threadId)
{
    int i = 0;
    LPTHREADCOLOR lpThreadColor;

    for (i=0;i<COLOR_HISTORY_COUNT;i++) {
        if (m_threadHistory[i].threadId == threadId &&
            m_threadHistory[i].processId == processId) {
            return &m_threadHistory[i];
        }
    }
    // else this is the first time we saw the thread

    lpThreadColor = &m_threadHistory[m_nextThreadIndex++];
    if (m_nextThreadIndex == COLOR_HISTORY_COUNT) {
        m_nextThreadIndex = 0;
    }
    lpThreadColor->processId = processId;
    lpThreadColor->threadId = threadId;
    lpThreadColor->color = colors[m_nextThreadColor++];
    if (m_nextThreadColor == NUM_COLORS) {
        m_nextThreadColor = 0;
    }

    return lpThreadColor;
}

// This handles actually saving the document.
VOID CZippyWindow::DoSaveInternal()
{
    HANDLE saveFile;
    EDITSTREAM saveStream;
    LRESULT bytesSaved;
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];

    saveFile = CreateFile(m_SaveFile,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,
        0,NULL);
    if (saveFile==INVALID_HANDLE_VALUE) {
        LoadStringSimple(IDS_FILEOPENERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
        return;
    }

    saveStream.dwCookie = (DWORD_PTR)saveFile;
    saveStream.dwError = 0;
    saveStream.pfnCallback = SaveCallback;

    bytesSaved = SendMessage(m_hControlWnd,EM_STREAMOUT,SF_TEXT,(LPARAM)&saveStream);

    CloseHandle(saveFile);

    if (saveStream.dwError != 0) {
        LoadStringSimple(IDS_FILESAVEERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
    } else {
        SendMessage(m_hControlWnd,EM_SETMODIFY,FALSE,0);
    }


}

// This is a private callback function which rich edit calls when
// saving out the document
static DWORD CALLBACK
SaveCallback(DWORD_PTR dwCookie,LPBYTE pbBuff,LONG cb,LONG *pcb)
{
    HANDLE fileHandle;

    fileHandle = (HANDLE)dwCookie;

    if (!WriteFile(fileHandle,pbBuff,cb,(PULONG)pcb,NULL)) {
        return GetLastError();
    }
    return 0;
}

// As the function name says this does a find next operation
// on the rich edit control
BOOL CZippyWindow::DoFindNext(LPFINDREPLACE lpFindReplace)
{
    FINDTEXTEX findText;
    WPARAM searchOptions;
    CHARRANGE currentSel;
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];

    SendMessage(m_hControlWnd,EM_EXGETSEL,0,(LPARAM)&currentSel);
    findText.chrg.cpMin = currentSel.cpMax;
    findText.chrg.cpMax = -1;
    
    findText.lpstrText = lpFindReplace->lpstrFindWhat;

    searchOptions = FR_DOWN;
    if (lpFindReplace->Flags & FR_MATCHCASE) {
        searchOptions |= FR_MATCHCASE;
    }
    if (lpFindReplace->Flags & FR_WHOLEWORD) {
        searchOptions |= FR_WHOLEWORD;
    }
    
    if (0 <= SendMessage(m_hControlWnd, EM_FINDTEXTEX,searchOptions,
        (LPARAM)&findText)) {
        SendMessage(m_hControlWnd, EM_EXSETSEL,0,(LPARAM)&findText.chrgText);
    } else {
        LoadStringSimple(IDS_SEARCHFAILURE,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWndFindReplace,dlgMessage,dlgTitle,MB_OK);

        return FALSE;
    }

    return TRUE;
    
}

// This does a replace operation on the control
BOOL CZippyWindow::DoReplace(LPFINDREPLACE lpFindReplace)
{
    FINDTEXTEX findText;
    WPARAM searchOptions;
    CHARRANGE currentSel;
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];

    SendMessage(m_hControlWnd,EM_EXGETSEL,0,(LPARAM)&currentSel);
    findText.chrg.cpMin = currentSel.cpMin;
    findText.chrg.cpMax = -1;
    
    findText.lpstrText = lpFindReplace->lpstrFindWhat;

    searchOptions = FR_DOWN;
    if (lpFindReplace->Flags & FR_MATCHCASE) {
        searchOptions |= FR_MATCHCASE;
    }
    if (lpFindReplace->Flags & FR_WHOLEWORD) {
        searchOptions |= FR_WHOLEWORD;
    }
    
    if (-1 == SendMessage(m_hControlWnd, EM_FINDTEXTEX,searchOptions,
        (LPARAM)&findText)) {
        // if we can't find what they were looking for just give up.
        LoadStringSimple(IDS_SEARCHFAILURE,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);
        
        MessageBox(m_hWndFindReplace,dlgMessage,dlgTitle,MB_OK);
        return FALSE;
    }

    if (currentSel.cpMin == findText.chrgText.cpMin && 
        currentSel.cpMax == findText.chrgText.cpMax) {
        SendMessage(m_hControlWnd,EM_REPLACESEL,0,(LPARAM)lpFindReplace->lpstrReplaceWith);
        // Now select the next occurrence
        return DoFindNext(lpFindReplace);
    } else {
        // They weren't on what they were searching for so select it.
        SendMessage(m_hControlWnd, EM_EXSETSEL,0,(LPARAM)&findText.chrgText);
    }

    return TRUE;

}

// This loops on DoReplace until DoReplace returns FALSE
VOID CZippyWindow::DoReplaceAll(LPFINDREPLACE lpFindReplace)
{
    while (DoReplace(lpFindReplace));
}

// This actually saves the traceconfiguration.  We just write
// out the binary config structure to the file
VOID CZippyWindow::DoSaveConfInternal()
{
    HANDLE saveFile;
    TRC_CONFIG trcConfig;
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];
    DWORD bytesWritten;

    saveFile = CreateFile(m_SaveConfFile,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,
        0,NULL);
    if (saveFile==INVALID_HANDLE_VALUE) {
        LoadStringSimple(IDS_FILEOPENERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
        return;
    }

    m_rTracer->GetCurrentConfig(&trcConfig);

    if (!WriteFile(saveFile,&trcConfig,sizeof(trcConfig),&bytesWritten,NULL) ||
        bytesWritten != sizeof(trcConfig)) {
        
        LoadStringSimple(IDS_FILESAVEERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
    }
   
    CloseHandle(saveFile);

}

// This reads in the binary configuration structure and then
// sets it as the current tracing config
VOID CZippyWindow::DoLoadConfInternal()
{
    HANDLE openFile;
    DWORD bytesRead;
    TRC_CONFIG trcConfig;
    TCHAR dlgTitle[MAX_STR_LEN];
    TCHAR dlgMessage[MAX_STR_LEN];
    

    openFile = CreateFile(m_LoadConfFile,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
        0,NULL);
    if (openFile==INVALID_HANDLE_VALUE) {
        LoadStringSimple(IDS_FILELOADOPENERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
        return;
    }

    if (!ReadFile(openFile,&trcConfig,sizeof(trcConfig),&bytesRead,NULL)||
        bytesRead != sizeof(trcConfig)) {
        LoadStringSimple(IDS_FILELOADERROR,dlgMessage);
        LoadStringSimple(IDS_ZIPPYWINDOWTITLE,dlgTitle);

        MessageBox(m_hWnd,dlgMessage,dlgTitle,MB_OK|MB_ICONERROR);
    }
    
    m_rTracer->SetCurrentConfig(&trcConfig);

}

// Reads the saved window position in from the registry.
VOID CZippyWindow::GetSavedWindowPos(LPRECT savedPos)
{
    DWORD dwResult;
    DWORD dwSize;
    DWORD dwType;
    RECT rect;
    HKEY hKey;
    
    savedPos->top = WINDOW_DEF_TOP;
    savedPos->bottom = WINDOW_DEF_BOTTOM;
    savedPos->left = WINDOW_DEF_LEFT;
    savedPos->right = WINDOW_DEF_RIGHT;

    dwResult = RegOpenKeyEx(HKEY_CURRENT_USER,ZIPPY_REG_KEY,0,
        KEY_QUERY_VALUE,&hKey);
    if (dwResult) {
        return;
    }
    dwSize = sizeof(RECT);
    dwResult = RegQueryValueEx(hKey,ZIPPY_WINDOW_POS_VALUE,NULL,&dwType,
        (LPBYTE)&rect,&dwSize);
    RegCloseKey(hKey);
    if (dwResult||dwSize != sizeof(RECT)||dwType!=REG_BINARY) {
        return;
    }

    *savedPos = rect;
}

// Saves the window position out to the registry
VOID CZippyWindow::SaveWindowPos(LPRECT newPos)
{
    DWORD dwResult;
    HKEY hKey;

    dwResult = RegCreateKeyEx(HKEY_CURRENT_USER,ZIPPY_REG_KEY,0,_T(""),0,
        KEY_SET_VALUE,NULL,&hKey,NULL);
    if (dwResult) {
        return;
    }

    RegSetValueEx(hKey,ZIPPY_WINDOW_POS_VALUE,0,REG_BINARY,
        (LPBYTE)newPos,sizeof(RECT));
    
    RegCloseKey(hKey);
}