Windows编程

开发平台：
Visual C++

MANDEL.C：源码内容
							
/****************************************************************************
                   Microsoft RPC Version 2.0
           Copyright Microsoft Corp. 1992, 1993, 1994- 1996
                        mandel Example
    FILE:       mandel.c
    PURPOSE:    Client side of the RPC distributed application
    COMMENTS:   Main code for the Windows Mandelbrot Set distributed
                drawing program.
****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#include <windows.h>      // Required for all Windows applications
#include <windowsx.h>     // Allow portability from Win16, Win32
#ifdef RPC
#include "mdlrpc.h"       // header file generated by the MIDL compiler
#endif
#include "mandel.h"
/* data structures */
#ifdef RPC
char szTitle[] = "Mandelbrot RPC";
#else
char szTitle[] = "Mandelbrot Standalone";
#endif
CPOINT      cptUL = { (double) -2.05, (double) 1.4 };
double      dPrec = (double) .01;
HANDLE      hInst;         // current instance
HWND        hWND;          // Main window handle
svr_table   SvrTable;
int         iLines = LINES;
int         fContinueZoom = TRUE;
int         fZoomIn       = TRUE;
// split current picture into 16 regions
// zoom on most complex region;  region with most colors represented
int         Histogram[4][4][NCOLORS+1] = {0};
int         ColorCount[4][4] = {0};
int         Max[4][4] = {0};
int         iHistMaxI = 2;
int         iHistMaxJ = 3;
RECT        rcZoom;
BOOL        fRectDefined = FALSE;
#ifdef RPC
int             fBound = FALSE;     // flag indicates whether bound to svr
unsigned char * pszUuid             = NULL;
unsigned char pszProtocolSequence[MAXPROTSEQ] = "ncacn_np";
unsigned char pszEndpoint[PATHLEN]            = "\pipe\mandel";
unsigned char * pszOptions          = NULL;
unsigned char * pszStringBinding;
unsigned char   pszNetworkAddress[UNCLEN+1] = {''};
#endif
/* function prototypes */
void     DoSomeWork(HWND, BOOL);
void     InitHistogram(void);
void     CalcHistogram(int, int, DWORD, DWORD);
void     PaintLine(HWND, svr_table *, HDC, int);
void     DrawRect(HWND, PRECT, BOOL, HDC);
COLORREF MapColor(DWORD, DWORD);
/*
 *  FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
 *
 *  PURPOSE: Calls initialization function, processes message loop
 *
 *  COMMENTS:
 *
 *      Windows recognizes this function by name as the initial entry point
 *      for the program.  This function calls the application initialization
 *      routine, if no other instance of the program is running, and always
 *      calls the instance initialization routine.  It then executes a message
 *      retrieval and dispatch loop that is the top-level control structure
 *      for the remainder of execution.  The loop is terminated when a WM_QUIT
 *      message is received, at which time this function exits the application
 *      instance by returning the value passed by PostQuitMessage().
 *
 *      If this function must abort before entering the message loop, it
 *      returns the conventional value NULL.
 */
int WINAPI WinMain(
    HINSTANCE hInstance,            /* current instance         */
    HINSTANCE hPrevInstance,        /* previous instance        */
    LPSTR lpCmdLine,                /* command line             */
    int nCmdShow)                   /* show-window type (open/icon) */
{
    MSG msg;
    UNREFERENCED_PARAMETER(lpCmdLine);
    if (!hPrevInstance)  /* Other instances of app running? */
        if (!InitApplication(hInstance))  /* Initialize shared things */
            return(FALSE);  /* Exits if unable to initialize */
    /* Perform initializations that apply to a specific instance */
    if (!InitInstance(hInstance, nCmdShow))
        return(FALSE);
    /* Acquire and dispatch messages until a WM_QUIT message is received. */
    while (GetMessage(&msg,        /* message structure              */
                      (HWND)NULL,  /* handle of window receiving the message */
                      0,           /* lowest message to examine      */
                      0))          /* highest message to examine     */
    {
        TranslateMessage(&msg);    /* Translates virtual key codes   */
        DispatchMessage(&msg);     /* Dispatches message to window   */
    }
    return(msg.wParam);  /* Returns the value from PostQuitMessage */
}
/*
 *  FUNCTION: InitApplication(HANDLE)
 *
 *  PURPOSE: Initializes window data and registers window class
 *
 *  COMMENTS:
 *
 *      This function is called at initialization time only if no other
 *      instances of the application are running.  This function performs
 *      initialization tasks that can be done once for any number of running
 *      instances.
 *
 *      In this case, we initialize a window class by filling out a data
 *      structure of type WNDCLASS and calling the Windows RegisterClass()
 *      function.  Since all instances of this application use the same window
 *      class, we only need to do this when the first instance is initialized.
 */
BOOL InitApplication(HANDLE hInstance)    /* current instance */
{
    WNDCLASS  wc;
    /* Fill in window class structure with parameters that describe the       */
    /* main window.                                                           */
    wc.style = 0;                       /* Class style(s).                    */
    wc.lpfnWndProc = (WNDPROC)MainWndProc;
                                        /* Function to retrieve messages for  */
                                        /* windows of this class.             */
    wc.cbClsExtra = 0;                  /* No per-class extra data.           */
    wc.cbWndExtra = 0;                  /* No per-window extra data.          */
    wc.hInstance = hInstance;           /* Application that owns the class.   */
    wc.hIcon = LoadIcon(hInstance, "RPC_ICON");
    wc.hCursor = LoadCursor(0, IDC_ARROW);
    wc.hbrBackground = GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName =  "MandelMenu";    /* Name of menu resource in .RC file. */
    wc.lpszClassName = "MandelClass";   /* Name used in call to CreateWindow. */
    /* Register the window class and return success/failure code. */
    return(RegisterClass(&wc));
}
/*
 *  FUNCTION:  InitInstance(HANDLE, int)
 *
 *  PURPOSE:  Saves instance handle and creates main window.
 *
 *  COMMENTS:
 *
 *      This function is called at initialization time for every instance of
 *      this application.  This function performs initialization tasks that
 *      cannot be shared by multiple instances.
 *
 *      In this case, we save the instance handle in a static variable and
 *      create and display the main program window.
 */
BOOL InitInstance(HANDLE   hInstance,   /* Current instance identifier.       */
                  int      nCmdShow)    /* Param for first ShowWindow() call. */
{
    HMENU           hMenu;
    RECT            rc;
    /* Save the instance handle in static variable, which will be used in  */
    /* many subsequence calls from this application to Windows.            */
    hInst = hInstance;
    /* Create a main window for this application instance.  */
    hWND = CreateWindow(
               "MandelClass",        /* See RegisterClass() call.          */
               szTitle,              /* Text for window title bar.         */
               WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_BORDER | WS_MINIMIZEBOX,
               CW_USEDEFAULT,        /* Default horizontal position.       */
               CW_USEDEFAULT,        /* Default vertical position.         */
               WIDTH,                /* Default width.                     */
               HEIGHT,               /* Default height.                    */
               (HWND) NULL,          /* Overlapped windows have no parent. */
               (HMENU) NULL,         /* Use the window class menu.         */
               hInstance,            /* This instance owns this window.    */
               (LPVOID) NULL         /* Pointer not needed.                */
           );
    /* If window could not be created, return "failure" */
    if (!hWND)
        return(FALSE);
    /* Make the window visible; update its client area; and return "success" */
    ShowWindow(hWND, nCmdShow);  /* Show the window                */
    UpdateWindow(hWND);          /* Sends WM_PAINT message         */
    rc.top = rc.left = 0;
    rc.bottom = HEIGHT-1;
    rc.right = WIDTH-1;
    SetNewCalc(cptUL, dPrec, rc);
    hMenu = GetMenu(hWND);
#ifndef RPC
    EnableMenuItem(hMenu, IDM_SERVER, MF_GRAYED);  /* disable option */
#endif
    return(TRUE);               /* Returns the value from PostQuitMessage */
}
/*
 *  FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
 *
 *  PURPOSE:  Processes messages
 *
 *  MESSAGES:
 *      WM_COMMAND    - application menu
 *      WM_DESTROY    - destroy window
 *
 *  COMMENTS:
 */
LONG APIENTRY MainWndProc(
    HWND hWnd,               /* window handle               */
    UINT message,            /* type of message             */
    UINT wParam,             /* additional information      */
    LONG lParam)             /* additional information      */
{
    DLGPROC lpProc;          /* pointer to the dialog box function */
    PAINTSTRUCT ps;
    HDC hdc;
    static HDC     hdcMem;
    static HBITMAP hbmMem;
    static int     width;
    static int     height;
    RECT           rc;
    static BOOL    fButtonDown = FALSE;
    static POINT   pSelected;
    POINT          pMove;
    int            iWidthNew;
    int            iHeightNew;
    static int     miOldLines;
    double         scaling;
    switch (message) {
    case WM_CREATE:
#ifdef WIN16
        RpcWinSetYieldInfo (hWnd, FALSE, 0, 0L); // To make TCP/IP happy
#else
        PostMessage(hWnd, WM_COMMAND, IDM_BIND, 0L);    // bind to server
#endif
        if (!InitRemote(hWnd))
            return(FALSE);
        InitHistogram();
        hdc = GetDC(hWnd);
        hdcMem = CreateCompatibleDC(hdc);
        GetWindowRect(hWnd, &rc);
        width = rc.right - rc.left;
        height = rc.bottom - rc.top;
        hbmMem = CreateCompatibleBitmap(hdc, width, height);
        SelectObject(hdcMem, hbmMem);
        ReleaseDC(hWnd,hdc);
        rc.left = rc.top = 0;
        rc.right = width+1;
        rc.bottom = height + 1;
        FillRect(hdcMem, &rc, GetStockObject(WHITE_BRUSH));
        CheckMenuItem(GetMenu(hWnd), IDM_4LINES, MF_CHECKED);
        CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_CHECKED);
        miOldLines = IDM_4LINES;  // save to uncheck
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        BitBlt(hdc,
               ps.rcPaint.left,
               ps.rcPaint.top,
               ps.rcPaint.right - ps.rcPaint.left,
               ps.rcPaint.bottom - ps.rcPaint.top,
               hdcMem,
               ps.rcPaint.left,
               ps.rcPaint.top,
               SRCCOPY);
        EndPaint(hWnd, &ps);
        break;
    case WM_COMMAND:  // message: command from application menu
        switch(wParam) {
        case IDM_BIND:
#ifdef RPC
            if (Bind(hWnd) != RPC_S_OK)
                PostMessage(hWnd, WM_DESTROY, 0, 0L);
#endif
            break;
        case IDM_ABOUT:
            lpProc = MakeProcInstance(About, hInst);
            DialogBox(hInst,       // current instance
                      "AboutBox",  // resource to use
                      hWnd,        // parent handle
                      lpProc);     // About() instance address
            FreeProcInstance(lpProc);
            break;
        case IDM_ZOOMOUT:
            if (dPrec > (double)MAXPREC)  // don't allow the zoom out
                break;
            rcZoom.left = WIDTH/4 + (WIDTH/8);  // center square
            rcZoom.top   = HEIGHT/4 + (HEIGHT/8);
            rcZoom.right = rcZoom.left + (WIDTH/4);
            rcZoom.bottom = rcZoom.top + (HEIGHT/4);
            cptUL.real -= (rcZoom.left * dPrec); // inverse of zoom in
            cptUL.imag += (rcZoom.top * dPrec);
            iWidthNew = (rcZoom.right - rcZoom.left + 1);
            iHeightNew = (rcZoom.bottom - rcZoom.top + 1);
            scaling = ((double) ((iWidthNew > iHeightNew) ? iWidthNew : iHeightNew) / (double) width);
            dPrec /= scaling;
            rc.left = rc.top = 0;
            rc.bottom = height - 1;
            rc.right = width - 1;
            SetNewCalc(cptUL, dPrec, rc);
            fRectDefined = FALSE;
            DoSomeWork(hWnd, FALSE);
            break;
        case IDM_ZOOMIN:  // zoom in on selected rectangle
            // if no rectangle, don't zoom in
            if (!fRectDefined)
                break;
            if (dPrec < (double)MINPREC)  // don't allow zoom in
                break;
            DrawRect(hWnd, &rcZoom, TRUE, hdcMem);  // draw new rect
            // calculate new upper-left
            cptUL.real += (rcZoom.left * dPrec);
            cptUL.imag -= (rcZoom.top * dPrec);
            iWidthNew = (rcZoom.right - rcZoom.left + 1);
            iHeightNew = (rcZoom.bottom - rcZoom.top + 1);
            scaling = ((double) ((iWidthNew > iHeightNew) ? iWidthNew : iHeightNew) / (double) width);
            dPrec *= scaling;
            rc.left = rc.top = 0;
            rc.bottom = height - 1;
            rc.right = width - 1;
            SetNewCalc(cptUL, dPrec, rc);
            IncPictureID();
            fRectDefined = FALSE;
            DoSomeWork(hWnd, FALSE);
            break;
        case IDM_CONTINUOUS:  // continuous zoom in
            if (fContinueZoom == TRUE) {
                CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_UNCHECKED);
                fContinueZoom = FALSE;
            }
            else {
                CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_CHECKED);
                fContinueZoom = TRUE;
            }
            break;
        case IDM_REDRAW:
            if (fContinueZoom == TRUE)
                InitHistogram();
            rc.left = rc.top = 0;
            rc.right = width+1;
            rc.bottom = height + 1;
            FillRect(hdcMem, &rc, GetStockObject(WHITE_BRUSH));
            InvalidateRect(hWnd, NULL, TRUE);
            rc.left = rc.top = 0;
            rc.bottom = height - 1;
            rc.right = width - 1;
            SetNewCalc( cptUL, dPrec, rc);
            fRectDefined = FALSE;
            DoSomeWork(hWnd, FALSE);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            FreeDrawBuffer();
            break;
        case IDM_TOP:
            cptUL.real = (double) -2.05;
            cptUL.imag = (double) 1.4;
            dPrec = .01;
            rc.left = rc.top = 0;
            rc.bottom = height - 1;
            rc.right = width - 1;
            SetNewCalc(cptUL, dPrec, rc);
            ResetPictureID();  // incremented past original
            fRectDefined = FALSE;
            DoSomeWork(hWnd, FALSE);
            break;
        case IDM_1LINE:
        case IDM_2LINES:
        case IDM_4LINES:
            CheckMenuItem(GetMenu(hWnd), miOldLines, MF_UNCHECKED);
            miOldLines = wParam;
            switch(wParam) {
            case IDM_1LINE:
                iLines = 1;
                break;
            case IDM_2LINES:
                iLines = 2;
                break;
            case IDM_4LINES:
                iLines = 4;
                break;
            }
            CheckMenuItem(GetMenu(hWnd), miOldLines, MF_CHECKED);
            break;
#ifdef RPC
        case IDM_PROTSEQ:
            lpProc = MakeProcInstance(Protseq, hInst);
            DialogBox(hInst,        // current instance
                      "ProtseqBox", // resource to use
                      hWnd,         // parent handle
                      lpProc);      // Server instance address
            FreeProcInstance(lpProc);
            break;
        case IDM_SERVER:
            lpProc = MakeProcInstance(Server, hInst);
            DialogBox(hInst,         // current instance
                      "ServerBox",   // resource to use
                      hWnd,          // parent handle
                      lpProc);       // Server  instance address
            FreeProcInstance(lpProc);
            break;
        case IDM_ENDPOINT:
            lpProc = MakeProcInstance(Endpoint, hInst);
            DialogBox(hInst,        // current instance
                      "EndpointBox",// resource to use
                      hWnd,         // parent handle
                      lpProc);      // Server instance address
            FreeProcInstance(lpProc);
            break;
#endif
        case IDM_GO:
                SetTimer(hWnd, 1, POLL_TIME, NULL);  // set timer for polls
            EnableMenuItem(GetMenu(hWnd), IDM_GO, MF_GRAYED);   // disable GO
            break;
        default:  // Lets Windows process it
            return(DefWindowProc(hWnd, message, wParam, lParam));
        }
        break;
    case WM_DESTROY:  // message: window being destroyed
        PostQuitMessage(0);
        DeleteDC(hdcMem);
        DeleteObject(hbmMem);
        break;
    case WM_DOSOMEWORK:  // do another slice of calculation work
        DoSomeWork(hWnd, FALSE);
        break;
    case WM_PAINTLINE:  // The shared buffer contains a line of data; draw it
        PaintLine(hWnd,
                  &SvrTable,
                  hdcMem,
                  height);
        break;
    case WM_TIMER:  // timer means we should do another slice of work
        DoSomeWork(hWnd, TRUE);
        break;
    case WM_LBUTTONDOWN:  // left button down; start to define a zoom rectangle
        if (fRectDefined)
            DrawRect(hWnd, &rcZoom, FALSE, hdcMem);  // undraw old rectangle
        // initialize rectangle
        rcZoom.left = rcZoom.right = pSelected.x = LOWORD(lParam);
        rcZoom.top = rcZoom.bottom = pSelected.y = HIWORD(lParam);
        // draw the new rectangle
        DrawRect(hWnd, &rcZoom, TRUE, hdcMem);
        fRectDefined = TRUE;
        fButtonDown = TRUE;
        SetCapture(hWnd);  // capture all mouse events
        break;
    case WM_MOUSEMOVE:  // mouse move
        // if the button is down, change the rect
        if (!fButtonDown)
            break;
        DrawRect(hWnd, &rcZoom, FALSE, hdcMem);  // undraw old rect
        pMove.x = LOWORD(lParam);
        pMove.y = HIWORD(lParam);
        // update the selection rectangle
        if (pMove.x <= pSelected.x)
            rcZoom.left = pMove.x;
        if (pMove.x >= pSelected.x)
            rcZoom.right = pMove.x;
        if (pMove.y <= pSelected.y)
            rcZoom.top = pMove.y;
        if (pMove.y >= pSelected.y)
            rcZoom.bottom = pMove.y;
        DrawRect(hWnd, &rcZoom, TRUE, hdcMem);  // draw new rect
        break;
    case WM_LBUTTONUP:  // button up; end selection
        fButtonDown = FALSE;
        ReleaseCapture();
        break;
    default:  // Passes it on if unproccessed
        return(DefWindowProc(hWnd, message, wParam, lParam));
    }
    return(0L);
}
/*
 *  FUNCTION: About(HWND, unsigned, WORD, LONG)
 *
 *  PURPOSE:  Processes messages for "About" dialog box
 *
 *  MESSAGES:
 *
 *      WM_INITDIALOG - initialize dialog box
 *      WM_COMMAND    - Input received
 *
 *  COMMENTS:
 *
 *      No initialization is needed for this particular dialog box, but TRUE
 *      must be returned to Windows.
 *
 *      Wait for user to click on "Ok" button, then close the dialog box.
 */
BOOL APIENTRY About(
    HWND hDlg,              /* window handle of the dialog box */
    UINT message,           /* type of message                 */
    UINT wParam,            /* message-specific information    */
    LONG lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message) {
    case WM_INITDIALOG:     /* message: initialize dialog box  */
        return(TRUE);
    case WM_COMMAND:        /* message: received a command     */
        if (wParam == IDOK || wParam == IDCANCEL)
        {
            EndDialog(hDlg, TRUE);    /* Exits the dialog box  */
            return(TRUE);
        }
        break;
    }
    return(FALSE);          /* Didn't process a message        */
}
/*
 *  FUNCTION: Protseq(HWND, unsigned, WORD, LONG)
 *
 *  PURPOSE:  Processes messages for "Protseq" dialog box
 *
 *  MESSAGES:
 *
 *      WM_INITDIALOG - initialize dialog box
 *      WM_COMMAND    - Input received
 *
 *  COMMENTS:
 *
 *      No initialization is needed for this particular dialog box, but TRUE
 *      must be returned to Windows.
 *
 *      Wait for user to click on "Ok" button, then close the dialog box.
 */
BOOL APIENTRY Protseq(
    HWND hDlg,               /* window handle of the dialog box */
    UINT message,            /* type of message             */
    UINT wParam,             /* message-specific information    */
    LONG lParam)
{
    UNREFERENCED_PARAMETER(lParam);
#ifdef RPC
    switch (message) {
    case WM_INITDIALOG:    // message: initialize dialog box
        SetDlgItemText((HANDLE)hDlg, IDD_PROTSEQNAME, pszProtocolSequence);
        return(TRUE);
    case WM_COMMAND:       // message: received a command
        switch(wParam) {
        case IDCANCEL:     // System menu close command?
            EndDialog(hDlg, FALSE);
            return(TRUE);
        case IDOK:         // "OK" box selected?
            GetDlgItemText(hDlg, IDD_PROTSEQNAME, pszProtocolSequence, MAXPROTSEQ);
            if (Bind(hDlg) != RPC_S_OK) {
                EndDialog(hDlg, FALSE);
                return(FALSE);
            }
                KillTimer(hWND, 1);  // stop timer for polls
            EnableMenuItem(GetMenu(hWND), IDM_GO, MF_ENABLED);  // enable GO
            EndDialog(hDlg, TRUE);
            return(TRUE);
        }
    }
#endif
    return(FALSE);  // Didn't process a message
}
/*
 *  FUNCTION: Server(HWND, unsigned, WORD, LONG)
 *
 *  PURPOSE:  Processes messages for "Server" dialog box
 *
 *  MESSAGES:
 *
 *      WM_INITDIALOG - initialize dialog box
 *      WM_COMMAND    - Input received
 *
 *  COMMENTS:
 *
 *      No initialization is needed for this particular dialog box, but TRUE
 *      must be returned to Windows.
 *
 *      Wait for user to click on "Ok" button, then close the dialog box.
 */
BOOL APIENTRY Server(
    HWND hDlg,               /* window handle of the dialog box */
    UINT message,            /* type of message             */
    UINT wParam,             /* message-specific information    */
    LONG lParam)
{
    UNREFERENCED_PARAMETER(lParam);
#ifdef RPC
    switch (message) {
    case WM_INITDIALOG:      /* message: initialize dialog box */
        SetDlgItemText(hDlg, IDD_SERVERNAME, pszNetworkAddress);
        return(TRUE);
    case WM_COMMAND:         /* message: received a command    */
        switch(wParam) {
        case IDCANCEL:       /* System menu close command?     */
            EndDialog(hDlg, FALSE);
            return(TRUE);
        case IDOK:            /* "OK" box selected?            */
            GetDlgItemText( hDlg, IDD_SERVERNAME, pszNetworkAddress, UNCLEN);
            if (Bind(hDlg) != RPC_S_OK) {
                EndDialog(hDlg, FALSE);
                return(FALSE);
            }
                KillTimer(hWND, 1);  // stop timer for polls
            EnableMenuItem(GetMenu(hWND), IDM_GO, MF_ENABLED);  // enable GO
            EndDialog(hDlg, TRUE);
            return(TRUE);
        }
    }
#endif
    return(FALSE);           /* Didn't process a message      */
}
/*
 *  FUNCTION: Endpoint(HWND, unsigned, WORD, LONG)
 *
 *  PURPOSE:  Processes messages for "Endpoint" dialog box
 *
 *  MESSAGES:
 *
 *      WM_INITDIALOG - initialize dialog box
 *      WM_COMMAND    - Input received
 *
 *  COMMENTS:
 *
 *      No initialization is needed for this particular dialog box, but TRUE
 *      must be returned to Windows.
 *
 *      Wait for user to click on "Ok" button, then close the dialog box.
 */
BOOL APIENTRY Endpoint(
    HWND hDlg,               /* window handle of the dialog box */
    UINT message,            /* type of message             */
    UINT wParam,             /* message-specific information    */
    LONG lParam)
{
    UNREFERENCED_PARAMETER(lParam);
#ifdef RPC
    switch (message) {
    case WM_INITDIALOG:    // message: initialize dialog box
        SetDlgItemText(hDlg, IDD_ENDPOINTNAME, pszEndpoint);
        return(TRUE);
    case WM_COMMAND:       // message: received a command
        switch(wParam) {
        case IDCANCEL:
            EndDialog(hDlg, FALSE);
            return(TRUE);
        case IDOK:
            GetDlgItemText(hDlg, IDD_ENDPOINTNAME, pszEndpoint, PATHLEN);
            if (Bind(hDlg) != RPC_S_OK) {
                EndDialog(hDlg, FALSE);
                return(FALSE);
            }
                KillTimer(hWND, 1);  // stop timer for polls
            EnableMenuItem(GetMenu(hWND), IDM_GO, MF_ENABLED);  // enable GO
            EndDialog(hDlg, TRUE);
            return(TRUE);
        }
    }
#endif
    return(FALSE);  // Didn't process a message
}
/*
 *  DoSomeWork --
 *
 *  This function does our work for us. It does it in little pieces, and
 *  will schedule itself as it sees fit.
 */
void
DoSomeWork(HWND    hwnd,
           BOOL    fTimer)
{
    static WORD   wIteration = 0;
    if (fTimer) {
        wIteration++;
        // on every nth tick, we send out a poll
        if (wIteration == 120) {  // tune this?
            wIteration = 0;
            return;
        }
        // on the half-poll, we check for responses
        if ((wIteration == 2) || (wIteration == 10)) {
            return;
        }
    }
    if (CheckDrawStatus(hwnd))
        SendMessage(hwnd, WM_DOSOMEWORK, 0, 0L);
    return;
}
/*
 *  DrawRect --
 *
 *  This function draws (or undraws) the zoom rectangle.
 */
void
DrawRect(HWND      hwnd,
         PRECT     prc,
         BOOL      fDrawIt,
         HDC       hdcBM)
{
    HDC     hdc;
    DWORD   dwRop;
    hdc = GetDC(hwnd);
    if (fDrawIt)
        dwRop = NOTSRCCOPY;
    else
        dwRop = SRCCOPY;
    // top side
    BitBlt(hdc, prc->left, prc->top, (prc->right - prc->left) + 1,
           1, hdcBM, prc->left, prc->top, dwRop);
    // bottom side
    BitBlt(hdc, prc->left, prc->bottom, (prc->right - prc->left) + 1,
           1, hdcBM, prc->left, prc->bottom, dwRop);
    // left side
    BitBlt(hdc,prc->left, prc->top, 1, (prc->bottom - prc->top) + 1,
           hdcBM, prc->left, prc->top, dwRop);
    // right side
    BitBlt(hdc,prc->right, prc->top, 1, (prc->bottom - prc->top) + 1,
           hdcBM, prc->right, prc->top, dwRop);
    ReleaseDC(hwnd, hdc);
}
/*
 *  PaintLine --
 *
 *  This function paints a buffer of data into the bitmap.
 */
void
PaintLine(HWND        hwnd,
          svr_table * pst,
          HDC         hdcBM,
          int         cHeight)
{
    LPWORD  pwDrawData;
    int     y;
    int     x;
    DWORD   dwThreshold;
    RECT    rc;
    WORD    lines;
    lines  = (WORD) pst->cLines;
    // picture ID had better match, or else we skip it
    if (CheckDrawingID(pst->cPicture))
    {
        // figure out our threshold
        dwThreshold = QueryThreshold();
        // get a pointer to the draw buffer
        pwDrawData = (LPWORD) LockDrawBuffer();
        if (pwDrawData == NULL) {
            ReturnDrawBuffer();
            return;
        }
        // starting x coordinate
        x = (int) pst->dwLine;
        // now loop through the rectangle
        while (lines-- > 0)
        {
            // bottom to top, since that's the order of the data in the buffer
            y = (int) cHeight-1;
            while (y >= 0)
            {
                // draw a pixel
                SetPixel(hdcBM, x,y, MapColor(*pwDrawData, dwThreshold));
                if (fContinueZoom == TRUE)
                    CalcHistogram(x, y, *pwDrawData, dwThreshold);
                // now increment buffer pointer and y coord
                y--;
                pwDrawData++;
            }
            // increment X coordinate
            x++;
        }
        // figure out the rectangle to invalidate
        rc.top = 0;
        rc.bottom = cHeight;
        rc.left = (int)(pst->dwLine);
        rc.right = (int)(pst->dwLine) + pst->cLines;
        UnlockDrawBuffer();
        // and invalidate it on the screen so we redraw it
        InvalidateRect(hwnd, &rc, FALSE);
    }
    // free this for someone else to use
    ReturnDrawBuffer();
    // and change the pipe state, if necessary
    if (pst->iStatus == SS_PAINTING)
        pst->iStatus = SS_IDLE;
}
#define CLR_BLACK       RGB(0,0,0)
#define CLR_DARKBLUE    RGB(0,0,127)
#define CLR_BLUE        RGB(0,0,255)
#define CLR_CYAN        RGB(0,255,255)
#define CLR_DARKGREEN   RGB(0,127,0)
#define CLR_GREEN       RGB(0,255,0)
#define CLR_YELLOW      RGB(255,255,0)
#define CLR_RED         RGB(255,0,0)
#define CLR_DARKRED     RGB(127,0,0)
#define CLR_WHITE       RGB(255,255,255)
#define CLR_PALEGRAY    RGB(194,194,194)
#define CLR_DARKGRAY    RGB(127,127,127)
static COLORREF ColorMapTable[] = {     // size = NCOLORS
    CLR_DARKBLUE,
    CLR_BLUE,
    CLR_CYAN,
    CLR_DARKGREEN,
    CLR_GREEN,
    CLR_YELLOW,
    CLR_RED,
    CLR_DARKRED,
    CLR_WHITE,
    CLR_PALEGRAY,
    CLR_DARKGRAY};
/*
 *  MapColor --
 *
 *  This function maps an iteration count into a corresponding RGB color.
 */
COLORREF
MapColor(DWORD  dwIter,
         DWORD  dwThreshold)
{
    /* if it's beyond the threshold, call it black */
    if (dwIter >= dwThreshold) {
        return(CLR_BLACK);
    }
    /* get a modulus based on the number of colors */
    dwIter = (dwIter / 3) % NCOLORS; // 11;
    /* and return the appropriate color */
    return(ColorMapTable[dwIter]);
}
/*
 * CalcHistogram --
 *
 * This function is used to select the region that is the
 * most complex and will be used to zoom in for the next picture;
 * it contains the most colors.  The number of colors are counted.
 */
void
CalcHistogram(int    x,
              int    y,
              DWORD  dwIter,
              DWORD  dwThreshold)
{
    /* if it's beyond the threshold, call it black */
    if (dwIter >= dwThreshold) {
        Histogram[x/(WIDTH/4)][y/(HEIGHT/4)][NCOLORS]++;
        return;
    }
    /* get a modulus based on the number of colors */
    dwIter = (dwIter / 3) % NCOLORS; // 11;
    /* and bump the count for the appropriate color */
    Histogram[x/(WIDTH/4)][y/(HEIGHT/4)][dwIter]++;  // region of map
    return;
}
/*
 * InitHistogram --
 *
 * This function initializes the histogram data structures.
 */
void InitHistogram(void)
{
    int i, j, k;
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            for (k = 0; k <= NCOLORS; k++)
                Histogram[i][j][k] = 0;  // count of colors
}
/*
 * CountHistogram --
 *
 * This function determines the number of colors represented
 * within a region.  The region with the most colors is
 * selected using the maxi and maxj values.  X and Y coordinates
 * corresponding to these regions are stored in the HistRegion
 * table and are used for the next picture.
 */
void CountHistogram(void)
{
    int i, j, k;
    /* count the number of colors in each region */
    /* find the color that dominates each region */
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            ColorCount[i][j] = 0;
            Max[i][j] = 0;
            for (k = 0; k <= NCOLORS; k++) {
                if (Histogram[i][j][k] > Max[i][j])
                    Max[i][j] = Histogram[i][j][k];
                if (Histogram[i][j][k] != 0)  // count of colors
                    ColorCount[i][j]++;
            }
        }
    }
    iHistMaxI = 0;
    iHistMaxJ = 0;
    /* if several regions have the same number of colors,        */
    /* select the region with the most variety: the smallest max */
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            if (   (ColorCount[i][j] >= ColorCount[iHistMaxI][iHistMaxJ])
                && (Max[i][j] < Max[iHistMaxI][iHistMaxJ]) ) {
                iHistMaxI = i;
                iHistMaxJ = j;
            }
        }
    }
    InitHistogram();  // initialize for next time
}
#ifdef RPC
void __RPC_FAR * __RPC_API midl_user_allocate(size_t len)
{
    UNREFERENCED_PARAMETER(len);
    return(NULL);
}
void __RPC_API midl_user_free(void __RPC_FAR * ptr)
{
    UNREFERENCED_PARAMETER(ptr);
    return;
}
/*
 *  FUNCTION: Bind(HWND)
 *
 *  PURPOSE:  Make RPC API calls to bind to the server application
 *
 *  COMMENTS:
 *
 *      The binding calls are made from InitInstance() and whenever
 *      the user changes the server name or endpoint. If the bind
 *      operation is successful, the global flag fBound is set to TRUE.
 *
 *      The global flag fBound is used to determine whether to call
 *      the RPC API function RpcBindingFree.
 */
RPC_STATUS Bind(HWND hWnd)
{
    RPC_STATUS status;
    char pszFail[MSGLEN];
    if (fBound == TRUE) {  // unbind only if bound
        status = RpcStringFree(&pszStringBinding);
        if (status) {
            sprintf(pszFail, "RpcStringFree failed 0x%x", status);
            MessageBox(hWnd,
                       pszFail,
                       "RPC Sample Application",
                       MB_ICONSTOP);
            return(status);
        }
        status = RpcBindingFree(&hMandel);
        if (status) {
            sprintf(pszFail, "RpcBindingFree failed 0x%x", status);
            MessageBox(hWnd,
                       pszFail,
                       "RPC Sample Application",
                       MB_ICONSTOP);
            return(status);
        }
        fBound = FALSE;  // unbind successful; reset flag
    }
    status = RpcStringBindingCompose(pszUuid,
                                     pszProtocolSequence,
                                     pszNetworkAddress,
                                     pszEndpoint,
                                     pszOptions,
                                     &pszStringBinding);
    if (status) {
        sprintf(pszFail, "RpcStringBindingCompose returned: (0x%x)nNetwork Address = %sn",
              status, pszNetworkAddress);
        MessageBox(hWnd, pszFail, "RPC Sample Application", MB_ICONINFORMATION);
        return(status);
    }
    status = RpcBindingFromStringBinding(pszStringBinding,
                                         &hMandel);
    if (status) {
        sprintf(pszFail, "RpcBindingFromStringBinding returned: (0x%x)nString = %sn",
             status, pszStringBinding);
        MessageBox(hWnd, pszFail, "RPC Sample Application", MB_ICONINFORMATION);
        return(status);
    }
    fBound = TRUE;  // bind successful; reset flag
    return(status);
}
#endif
/* end mandel.c */

						