/*
==============================================================================

  Application:

            Microsoft Windows NT (TM) Performance Monitor

  File:
            intrline.c -- IntervalLine custom control.

  Copyright 1992, Microsoft Corporation. All Rights Reserved.
==============================================================================
*/


/*


Basic Information
-----------------

An ILine (Interval Line) control is a horizontally-sliding device; the user
can slide the start position and end position independently by dragging
either "grab" bar, or move them simultaneously by dragging the center grab
bar. An ILine control is used in the Input Log dialog of Perfmon, but could
be used anywhere. The control allows the user to specify the start, end and
duration of playback within the range of previously-logged data.


ILine Parts
-----------

     iBeginValue                                            iEndValue
     |      iStartValue                        iStopValue           |
     |      |                                           |           |
     v      v                                           v           v
     +------+-+---------------------------------------+-+-----------+
     |      |X|                                       |X|           |
     |      |X|                                       |X|           |
     +------+-+---------------------------------------+-+-----------+
             ^                    ^                    ^
             Start grab bar       Center grab bar      Stop grab bar


ILine Terminology
-----------------

All external routines are designated by the prefix ILine-.
Internal routines are designated by the prefix IL-.

The suffix -Value represents an integer in the user-supplied domain.
The suffix -Pixel represents an integer location on the screen.

Note that the range of the IntervalLine is represented by "Begin" and
"End", while the the currently selected interval is represented by
"Start" and "Stop".


Implementation Notes
--------------------

ILine is a custom control, but does not have all the messages
normally associated with a full-fledged control type like "button".
In particular, it doesn't have a keyboard interface or ask it's parent
for color choices. It also doesn't have the functions needed for interfacing
with the dialog editor custom control menu.

An ILine control is designed to work with an integer range of values
specified by the user of the control. These values should have meaning to
the caller. The caller can specify the minimum value of the range
(iBeginValue), the maximum value of the range (iEndValue), and the current
starting and stopping values (iStartValue and iStopValue).

These values are set with a function-based interface. (ILSetXXX).

The code distinguishes between the *values* for the begin, end, start, and
stop, and the *pixels* which represent locations on the control for these
values.

Various bits of the control style allow for changing the control's
behavior.

To allow for multiple ILine controls, all data used by each ILine
instance is allocated from the heap and associated with the control.
The allocation is done in OnCreate and the freeing in OnDestroy. The
instance data is contained in the ILINE structure. Each message handler
retrieves this instance data with the ILData function.

*/


//==========================================================================//
//                                  Includes                                //
//==========================================================================//


#include "perfmon.h"
#include "utils.h"
#include "intrline.h"
#include "pmemory.h"        // for MemoryXXX (mallloc-type) routines

BOOL  IntrLineFocus ;

//==========================================================================//
//                                  Constants                               //
//==========================================================================//


#define dwILineClassStyle     (CS_HREDRAW | CS_VREDRAW)
#define iILineClassExtra      (0)
#define iILineWindowExtra     (sizeof (PILINE))
#define dwILineWindowStyle    (WS_CHILD | WS_VISIBLE)


#define ILModeNone            0
#define ILModeLeft            1
#define ILModeCenter          2
#define ILModeRight           3

#define TO_THE_END            0x7FFFFFFFL

//==========================================================================//
//                                  Typedefs                                //
//==========================================================================//


// The instance data for each IL window.  One of these is allocated for each
// window in the window's OnCreate processing and free'd in OnDestroy.
typedef struct ILINESTRUCT
   {  // ILINE
   int            iBeginValue ;        // user-supplied lowest range
   int            iEndValue ;          // user-supplied highest range
   int            iStartValue ;        // current start of selected interval
   int            iStopValue ;         // current end of selected interval
   int            iGranularityValue ;
   int            iMinimumRangeValue ;

   RECT           rectBorder ;
   RECT           rectLeftBk ;
   RECT           rectLeftGrab ;
   RECT           rectCenterGrab ;
   RECT           rectRightGrab ;
   RECT           rectRightBk ;

   HBRUSH         hBrushBk ;

   POINTS         ptsMouse ;
   int            iMode ;              // who is being tracked?
   } ILINE ;

typedef ILINE *PILINE ;


//==========================================================================//
//                                   Macros                                 //
//==========================================================================//


// Width of the start and stob grab bars
#define ILGrabWidth()      \
   (xScrollThumbWidth)


// A rectangle is "drawable" if it has both nonzero width and height
#define RectDrawable(lpRect)           \
   ((lpRect->right - lpRect->left) &&  \
    (lpRect->bottom - lpRect->top))


//======================================//
// ILine Accessor Macros                //
//======================================//

// These macros reference fields in the ILine structure and should be
// used in place of direct reference to the fields. This makes the code
// easier to read and allows modification of the underlying structure.

// You can use these macros to both get and set the fields.

#define ILBegin(pILine)    \
   (pILine->iBeginValue)

#define ILEnd(pILine)      \
   (pILine->iEndValue)

#define ILStart(pILine)    \
   (pILine->iStartValue)

#define ILStop(pILine)     \
   (pILine->iStopValue)

#define ILMode(pILine)     \
   (pILine->iMode)


//======================================//
// ILine Pseudo-Accessor Macros         //
//======================================//

// These macros are used to get values which don't correspond to a single
// field. You can get the value with these macros but can't set it.

#define ILWidth(pILine)    \
   (pILine->rectBorder.right)

#define ILRange(pILine)    \
   (ILEnd (pILine) - ILBegin (pILine))

#define ILStartPixel(pILine) \
   (pILine->rectLeftGrab.left)

#define ILStopPixel(pILine)   \
   (pILine->rectRightGrab.right)


//==========================================================================//
//                              Local Functions                             //
//==========================================================================//


void static ILNotifyChange (HWND hWnd,
                            PILINE pILine)
   {  // ILNotifyChange
   HWND           hWndParent ;

   hWndParent = WindowParent (hWnd) ;

   if (hWndParent)
      SendMessage (hWndParent, WM_COMMAND,
                   (WPARAM) WindowID (hWnd),
                   (LPARAM) hWnd) ;
   }  // ILNotifyChange


BOOL ILGrabRect (IN PILINE pILine,
                 OUT LPRECT lpRect)
/*
   Effect:        Return in lpRect the rectangle representing the position
                  of the grab bar currently being tracked.
*/
   {  // ILGrabRect
   switch (ILMode (pILine))
      {  // switch
      case ILModeLeft:
         *lpRect = pILine->rectLeftGrab ;
         return (TRUE) ;
         break ;

      case ILModeRight:
         *lpRect = pILine->rectRightGrab ;
         return (TRUE) ;
         break ;

      case ILModeCenter:
         *lpRect = pILine->rectCenterGrab ;
         return (TRUE) ;
         break ;

      case ILModeNone:
         lpRect->left = 0 ;
         lpRect->top = 0 ;
         lpRect->right = 0 ;
         lpRect->bottom = 0 ;
         return (FALSE) ;
         break ;
      }  // switch

    // return FALSE if it falls through to here
    return FALSE;
   }  // ILGrabRect


PILINE ILData (HWND hWndIL)
   {
   return ((PILINE) GetWindowLongPtr (hWndIL, 0)) ;
   }


PILINE AllocateILData (HWND hWndIL)
   {
   PILINE         pILine ;

   pILine = MemoryAllocate (sizeof (ILINE)) ;
   SetWindowLongPtr (hWndIL, 0, (LONG_PTR) pILine) ;

   return (pILine) ;
   }


void static DrawGrab (HDC hDC,
                      LPRECT lpRectGrab,
                      BOOL bDown)
   {  // DrawGrab
   if (!RectDrawable (lpRectGrab))
      return ;

   if (bDown)
      ThreeDConcave1 (hDC,
                     lpRectGrab->left,
                     lpRectGrab->top,
                     lpRectGrab->right,
                     lpRectGrab->bottom) ;
   else
      ThreeDConvex1 (hDC,
                    lpRectGrab->left,
                    lpRectGrab->top,
                    lpRectGrab->right,
                    lpRectGrab->bottom) ;
   }  // DrawGrab


int ILValueToPixel (PILINE pILine,
                    int iValue)
   {
   int            xPixel ;

   if (ILRange (pILine))
      xPixel = MulDiv (iValue, ILWidth (pILine), ILRange (pILine)) ;
   else
      xPixel = 0 ;

   return (PinExclusive (xPixel, 0, pILine->rectBorder.right)) ;
   }


int ILPixelToValue (PILINE pILine,
                    int xPixel)
   {
   int            iValue ;

   if (ILWidth (pILine))
      iValue = MulDiv (xPixel, ILRange (pILine), ILWidth (pILine)) ;
   else
      iValue = 0 ;

   return (PinInclusive (iValue, ILBegin (pILine), ILEnd (pILine))) ;
   }


void static ILCalcPositions (HWND hWnd,
                             PILINE pILine)
/*
   Effect:        Determine and set all of the physical rectangles of ILine,
                  based on the current size of the ILine window and the
                  current logical Start, Stop, Begin, and End values.
*/
   {  // ILCalcPositions
   int            xStart, xStop ;
   int            yHeight ;

   GetClientRect (hWnd, &pILine->rectBorder) ;
   yHeight = pILine->rectBorder.bottom ;

   xStart = ILValueToPixel (pILine, ILStart (pILine)) ;
   xStop = ILValueToPixel (pILine, ILStop (pILine)) ;

   pILine->rectLeftBk.left = 1 ;
   pILine->rectLeftBk.top = 1 ;
   pILine->rectLeftBk.right = xStart ;
   pILine->rectLeftBk.bottom = yHeight - 1 ;

   pILine->rectLeftGrab.left = xStart ;
   pILine->rectLeftGrab.top = 1 ;
   pILine->rectLeftGrab.right = xStart + ILGrabWidth () ;
   pILine->rectLeftGrab.bottom = yHeight - 1 ;

   pILine->rectRightBk.left = xStop ;
   pILine->rectRightBk.top = 1 ;
   pILine->rectRightBk.right = pILine->rectBorder.right - 1 ;
   pILine->rectRightBk.bottom = yHeight - 1 ;

   pILine->rectRightGrab.left = xStop - ILGrabWidth () ;
   pILine->rectRightGrab.top = 1 ;
   pILine->rectRightGrab.right = xStop ;
   pILine->rectRightGrab.bottom = yHeight - 1 ;

   pILine->rectCenterGrab.left = pILine->rectLeftGrab.right ;
   pILine->rectCenterGrab.top = 1 ;
   pILine->rectCenterGrab.right = pILine->rectRightGrab.left ;
   pILine->rectCenterGrab.bottom = yHeight - 1 ;

   if (pILine->rectLeftGrab.right > pILine->rectRightGrab.left)
      {
      pILine->rectLeftGrab.right = pILine->rectLeftGrab.left +
                                   (xStop - xStart) / 2 ;
      pILine->rectRightGrab.left = pILine->rectLeftGrab.right ;
      pILine->rectCenterGrab.left = 0 ;
      pILine->rectCenterGrab.right = 0 ;
      }
   }  // ILCalcPositions


void static ILDraw (HDC hDC,
                    PILINE pILine,
                    LPRECT lpRectUpdate)
/*
   Effect:        Draw the image of pILine on hDC.  Draw at least the
                  portions within rectUpdate.

   Called By:     OnPaint, OnMouseMove.
*/
   {  // ILDraw
   HBRUSH hBrush = GetStockObject (BLACK_BRUSH);

   if (!hBrush)
        return;
   //=============================//
   // Draw Border                 //
   //=============================//

   FrameRect (hDC, &pILine->rectBorder, hBrush);

   //=============================//
   // Draw Background             //
   //=============================//

   FillRect (hDC, &pILine->rectLeftBk, pILine->hBrushBk) ;
   FillRect (hDC, &pILine->rectRightBk, pILine->hBrushBk) ;

   //=============================//
   // Draw Range Grabs            //
   //=============================//

   DrawGrab (hDC, &pILine->rectLeftGrab,
             ILMode (pILine) == ILModeLeft) ;
   DrawGrab (hDC, &pILine->rectRightGrab,
             ILMode (pILine) == ILModeRight) ;

   //=============================//
   // Draw Center Grab            //
   //=============================//

   DrawGrab (hDC, &pILine->rectCenterGrab,
             ILMode (pILine) == ILModeCenter) ;
   }  // ILDraw

#if 0
void ILPageLeftRight (HWND hWnd,
                      PILINE pILine,
                      BOOL bLeft)
   {  // ILPageLeftRight
   int            iStart, iStop, iMove ;
   HDC            hDC ;

   iStart = ILStart (pILine) ;
   iStop = ILStop (pILine) ;

   if (ILRange (pILine) >= 10)
      iMove = ILRange (pILine) / 10 ;
   else
      iMove = 1 ;

   if (bLeft)
      iMove = -iMove ;

   iStart += iMove ;
   iStop += iMove ;

   ILineSetStart (hWnd, iStart) ;
   ILineSetStop (hWnd, iStop) ;

   hDC = GetDC (hWnd) ;
   ILDraw (hDC, pILine, &pILine->rectBorder) ;
   ReleaseDC (hWnd, hDC) ;

   ILNotifyChange (hWnd, pILine) ;
   }  // ILPageLeftRight
#endif

void ILMoveLeftRight (HWND hWnd,
                      BOOL bStart,
                      BOOL bLeft,
                      int  MoveAmt)
   {  // ILPageLeftRight
   int            iStart, iStop, iMove ;
   int            iBegin, iEnd ;
   HDC            hDC ;
   PILINE         pILine ;

   pILine = ILData (hWnd) ;
   iStart = ILStart (pILine) ;
   iStop = ILStop (pILine) ;
   iBegin = ILBegin (pILine) ;
   iEnd = ILEnd (pILine) ;

   iMove = MoveAmt ;
   if (bLeft)
      iMove = -iMove ;

   if (bStart)
      {
      if (MoveAmt == TO_THE_END)
         {
         iStart = iBegin ;
         }
      else
         {
         iStart += iMove ;
         if (iStart >= iStop)
            {
            return;
            }
         }

      ILineSetStart (hWnd, iStart) ;
      }
   else
      {
      if (MoveAmt == TO_THE_END)
         {
         iStop = iEnd ;
         }
      else
         {
         iStop += iMove ;
         if (iStart >= iStop)
            {
            return;
            }
         }

      ILineSetStop (hWnd, iStop) ;
      }

   hDC = GetDC (hWnd) ;
   if (hDC) {
       ILDraw (hDC, pILine, &pILine->rectBorder) ;
       ReleaseDC (hWnd, hDC) ;
   }

   ILNotifyChange (hWnd, pILine) ;
   }  // ILMoveLeftRight

static BOOL OnKeyDown (HWND hWnd,
                       WPARAM wParam)
   {
   BOOL bHandle = TRUE ;
   BOOL bStart ;
   BOOL bLeftDirection ;
   BOOL bShiftKeyDown ;

   if (wParam == VK_LEFT || wParam == VK_RIGHT)
      {
      bShiftKeyDown = (GetKeyState (VK_SHIFT) < 0) ;

      if (!bShiftKeyDown)
         {
         if (wParam == VK_LEFT)
            {
            // Left Arrow --> move Start Edge Left
            bStart = TRUE ;
            bLeftDirection = TRUE ;
            }
         else
            {
            // Right Arrow --> move Stop Edge Right
            bStart = FALSE ;
            bLeftDirection = FALSE ;
            }
         }
      else
         {
         if (wParam == VK_LEFT)
            {
            // Shift Left Arrow --> move Stop Edge Left
            bStart = FALSE ;
            bLeftDirection = TRUE ;
            }
         else
            {
            // Shift Right Arrow --> move Start Edge Right
            bStart = TRUE ;
            bLeftDirection = FALSE ;
            }
         }
      ILMoveLeftRight (hWnd, bStart, bLeftDirection, 1) ;
      }
   else if (wParam == VK_HOME)
      {
      // move iStart all the way the Left
      ILMoveLeftRight (hWnd, TRUE, TRUE, TO_THE_END) ;
      }
   else if (wParam == VK_END)
      {
      // move iStop all the way the right
      ILMoveLeftRight (hWnd, FALSE, FALSE, TO_THE_END) ;
      }
   else
      {
      bHandle = FALSE ;
      }
   return (bHandle) ;

   }  // OnKeyDown

void StartGrab (HWND hWnd,
                PILINE pILine)
   {  // StartGrab
   RECT           rectUpdate ;
   HDC            hDC ;

   SetCapture (hWnd) ;
   ILGrabRect (pILine, &rectUpdate) ;

   hDC = GetDC (hWnd) ;
   if (hDC) {
       ILDraw (hDC, pILine, &rectUpdate) ;
       ReleaseDC (hWnd, hDC) ;
   }  // StartGrab
}

void EndGrab (HWND hWnd,
              PILINE pILine)
/*
   Internals:     Set the mode to null after getting the grab rectangle
                  so ILGrabRect knows which grab bar to get.
*/
   {
   RECT           rectUpdate ;
   HDC            hDC ;

   ReleaseCapture () ;

   ILGrabRect (pILine, &rectUpdate) ;
   ILMode (pILine) = ILModeNone ;

   hDC = GetDC (hWnd) ;
   if (hDC) {
       ILDraw (hDC, pILine, &rectUpdate) ;
       ReleaseDC  (hWnd, hDC) ;
   }
}


//==========================================================================//
//                              Message Handlers                            //
//==========================================================================//


void static OnPaint (HWND hWnd)
   {
   PAINTSTRUCT    ps ;
   HDC            hDC ;
   PILINE         pILine ;

   pILine = ILData (hWnd) ;
   hDC = BeginPaint (hWnd, &ps) ;

   ILDraw (hDC, pILine, &ps.rcPaint) ;

   EndPaint (hWnd, &ps) ;
   }


void static OnCreate (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = AllocateILData (hWnd) ;
   ILBegin (pILine) =  0 ;
   ILEnd (pILine) =  100 ;
   ILStart (pILine) =  0 ;
   ILStop (pILine) = 100 ;
   ILMode (pILine) = ILModeNone ;

   pILine->hBrushBk = CreateSolidBrush (crBlue) ;
   ILCalcPositions (hWnd, pILine) ;
   }


void static OnDestroy (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   IntrLineFocus = FALSE ;
   DeleteBrush (pILine->hBrushBk) ;
   MemoryFree (pILine) ;
   }


void static OnLButtonUp (HWND hWnd)
   {  // OnLButtonUp
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   if (ILMode (pILine) == ILModeNone)
      return ;

   EndGrab (hWnd, pILine) ;
   }  // OnLButtonUp


void static OnMouseMove (HWND hWnd,
                         POINTS ptsMouse)
/*
   Effect:        Handle any actions needed when the mouse moves in the
                  ILine hWnd's client area or while the mouse is captured.
                  In particular, if we are tracking one of the grab bars,
                  determine if the mouse movement represents a logical value
                  change and move the grab bar accordingly.

   Called By:     ILineWndProc, in response to a WM_MOUSEMOVE message.

   See Also:      OnLButtonDown, OnLButtonUp.

   Note:          This function has multiple return points.

   Note:          Since we have captured the mouse, we receive mouse msgs
                  even when the mouse is outside our client area, but still
                  in client coordinates. Thus we can have negative mouse
                  coordinates. That is why we convert the lParam of the
                  mouse msg into a POINTS structure rather than 2 WORDS.


   Internals:     Remember that an IntervalLine can only take on integral
                  values in the user-supplied range. Therefore we do our
                  movement calculation in user values, not pixels. We
                  determine what the logical value would be for the previous
                  (last mouse move) and current mouse position. If these
                  LOGICAL values differ, we attempt an adjustment of the
                  grab bar by that logical amount.  This way the grab
                  values assume on integral positions and the calculations
                  are simplified.

                  If we calculated by pixel movement, and then shifted the
                  bar into the nearest integal position, we would encounter
                  rounding problems. In particular, when tracking the center
                  grab bar, if we moved both start and stop by the same
                  amount of PIXELS, then converted to LOGICAL values, we
                  might find our center bar shrinking and growing while
                  the bar moves.
*/
   {
   int            iMousePrevious, iMouseCurrent ;
   int            iMouseMove ;
   PILINE         pILine ;
   HDC            hDC ;

   //=============================//
   // Are we tracking?            //
   //=============================//

   pILine = ILData (hWnd) ;
   if (ILMode (pILine) == ILModeNone)
      return ;

   //=============================//
   // Calc LOGICAL mouse movement //
   //=============================//

   ptsMouse.x = PinInclusive ((INT)ptsMouse.x,
                              (INT)pILine->rectBorder.left,
                              (INT)pILine->rectBorder.right) ;

   iMousePrevious = ILPixelToValue (pILine, pILine->ptsMouse.x) ;
   iMouseCurrent = ILPixelToValue (pILine, ptsMouse.x) ;

   iMouseMove = iMouseCurrent - iMousePrevious ;
   if (!iMouseMove)
      return ;

   //=============================//
   // Move grab bar positions     //
   //=============================//

   switch (ILMode (pILine))
      {  // switch
      case ILModeLeft:
         ILStart (pILine) += iMouseMove ;
         ILStart (pILine) = min (ILStart (pILine), ILStop (pILine) - 1) ;
         break ;

      case ILModeCenter:
         // Before we slide the center grab bar we need to see if the
         // desired movement amount would send either end out of bounds,
         // and reduce the movement accordingly.

         if (ILStart (pILine) + iMouseMove < ILBegin (pILine))
            iMouseMove = ILBegin (pILine) - ILStart (pILine) ;
         if (ILStop (pILine) + iMouseMove > ILEnd (pILine))
            iMouseMove = ILEnd (pILine) - ILStop (pILine) ;

         ILStart (pILine) += iMouseMove ;
         ILStop (pILine) += iMouseMove ;
         break ;

      case ILModeRight:
         ILStop (pILine) += iMouseMove ;
         ILStop (pILine) = max (ILStart (pILine) + 1, ILStop (pILine)) ;
         break ;
      }  // switch


   //=============================//
   // Keep grab bars in range     //
   //=============================//


   ILStart (pILine) = PinInclusive (ILStart (pILine),
                                    ILBegin (pILine), ILEnd (pILine)) ;
   ILStop (pILine) = PinInclusive (ILStop (pILine),
                                   ILBegin (pILine), ILEnd (pILine)) ;

   //=============================//
   // Determine pixel pos, draw   //
   //=============================//

   ILCalcPositions (hWnd, pILine) ;

   hDC = GetDC (hWnd) ;
   if (hDC) {
       ILDraw (hDC, pILine, &pILine->rectBorder) ;
       ReleaseDC (hWnd, hDC) ;
   }

   pILine->ptsMouse = ptsMouse ;
   ILNotifyChange (hWnd, pILine) ;
   }  // OnMouseMove


void static OnLButtonDown (HWND hWnd,
                           POINTS ptsMouse)
   {
   PILINE         pILine ;
   POINT          ptMouse ;

   pILine = ILData (hWnd) ;

   pILine->ptsMouse = ptsMouse ;
   ptMouse.x = ptsMouse.x ;
   ptMouse.y = ptsMouse.y ;

#if 0
   // Russ said this is bad, so don't do it
   if (PtInRect (&pILine->rectLeftBk, ptMouse))
      ILPageLeftRight (hWnd, pILine, TRUE) ;

   else if (PtInRect (&pILine->rectRightBk, ptMouse))
      ILPageLeftRight (hWnd, pILine, FALSE) ;

   else if (PtInRect (&pILine->rectLeftGrab, ptMouse))
#endif
   if (PtInRect (&pILine->rectLeftGrab, ptMouse) ||
       PtInRect (&pILine->rectLeftBk, ptMouse))
      {
      ILMode (pILine) = ILModeLeft ;
      StartGrab (hWnd, pILine) ;
      }

   else if (PtInRect (&pILine->rectRightGrab, ptMouse) ||
            PtInRect (&pILine->rectRightBk, ptMouse))
      {
      ILMode (pILine) = ILModeRight ;
      StartGrab (hWnd, pILine) ;
      }

   else if (PtInRect (&pILine->rectCenterGrab, ptMouse))
      {
      ILMode (pILine) = ILModeCenter ;
      StartGrab (hWnd, pILine) ;
      }
   }


void static OnSize (HWND hWnd, WORD xWidth, WORD yHeight)
   {  // OnSize
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   ILCalcPositions (hWnd, pILine) ;
   }  // OnSize


//==========================================================================//
//                             Exported Functions                           //
//==========================================================================//


LRESULT
FAR
PASCAL
ILineWndProc (
              HWND hWnd,
              unsigned msg,
              WPARAM wParam,
              LPARAM lParam
              )
/*
   Note:          This function must be declared in the application's
                  linker-definition file, perfmon.def file.
*/
   {  // ILineWndProc
   BOOL           bCallDefWindowProc ;
   POINTS         ptsMouse ;
   LRESULT        lReturnValue ;

   bCallDefWindowProc = FALSE ;
   lReturnValue = 0L ;

   switch (msg)
      {  // switch
      case WM_CREATE:
         OnCreate (hWnd) ;
         break ;

      case WM_DESTROY:
         OnDestroy (hWnd) ;
         break ;

      case WM_LBUTTONDOWN:
         // See the note in OnMouseMove for why we are using POINTS
         SetFocus (hWnd) ;
         ptsMouse = MAKEPOINTS (lParam) ;
         OnLButtonDown (hWnd, ptsMouse) ;
         break ;

      case WM_LBUTTONUP:
         OnLButtonUp (hWnd) ;
         break ;

      case WM_SETFOCUS:
      case WM_KILLFOCUS:
         {
         PILINE         pILine ;

         IntrLineFocus = (msg == WM_SETFOCUS) ;

         pILine = ILData (hWnd) ;
         ILNotifyChange (hWnd, pILine) ;
         }
         return 0 ;


      case WM_MOUSEMOVE:
         // See the note in OnMouseMove for why we are using POINTS
         ptsMouse = MAKEPOINTS (lParam) ;
         OnMouseMove (hWnd, ptsMouse) ;
         break ;

      case WM_KEYDOWN:
         if (!OnKeyDown (hWnd, wParam))
            {
            bCallDefWindowProc = TRUE ;
            }
         break ;

      case WM_GETDLGCODE:
         // We want to handle Arrow keys input.  If we don't specify this
         // the dialog will not pass arrow keys to us.
         return (DLGC_WANTARROWS) ;
         break ;

      case WM_PAINT:
         OnPaint (hWnd) ;
         break ;

      case WM_SIZE:
         OnSize (hWnd, LOWORD (lParam), HIWORD (lParam)) ;

      default:
         bCallDefWindowProc = TRUE ;
      }  // switch

   if (bCallDefWindowProc)
      lReturnValue = DefWindowProc (hWnd, msg, wParam, lParam) ;

   return (lReturnValue) ;
   }  // ILineWndProc



BOOL ILineInitializeApplication (void)
/*
   Effect:        Perform all initializations required before an application
                  can create an IntervalLine. In particular, register the
                  IntervalLine window class.

   Called By:     The application, in its InitializeApplication routine.

   Returns:       Whether the class could be registered.
*/
   {  // ILineInitializeApplication
   WNDCLASS       wc ;

   wc.style =           dwILineClassStyle ;
   wc.lpfnWndProc =     ILineWndProc ;
   wc.cbClsExtra =      iILineClassExtra ;
   wc.cbWndExtra =      iILineWindowExtra ;
   wc.hInstance =       hInstance ;
   wc.hIcon =           NULL ;
   wc.hCursor =         LoadCursor (NULL, IDC_ARROW) ;
   wc.hbrBackground =   NULL ;
   wc.lpszMenuName =    NULL ;
   wc.lpszClassName =   szILineClass ;

   return (RegisterClass (&wc)) ;
   }  // ILineInitializeApplication


void ILineSetRange (HWND hWnd, int iBegin, int iEnd)
   {  // ILineSetRange
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   ILBegin (pILine) = iBegin ;
   ILEnd (pILine) = iEnd ;

   ILCalcPositions (hWnd, pILine) ;
   }  // ILineSetRange


void ILineSetStart (HWND hWnd, int iStart)
   {  // ILineSetStart
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   iStart = PinInclusive (iStart, ILBegin (pILine), ILEnd (pILine)) ;
   ILStart (pILine) = iStart ;

   ILCalcPositions (hWnd, pILine) ;
   }  // ILineSetStart



void ILineSetStop (HWND hWnd, int iStop)
   {  // ILineSetStop
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   iStop = PinInclusive (iStop, ILBegin (pILine), ILEnd (pILine)) ;
   ILStop (pILine) = iStop ;

   ILCalcPositions (hWnd, pILine) ;
   }  // ILineSetStop


int ILineXStart (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   return (pILine->rectLeftGrab.left) ;
   }


int ILineXStop (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   return (pILine->rectRightGrab.right) ;
   }


int ILineStart (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   return  (ILStart (pILine)) ;
   }


int ILineStop (HWND hWnd)
   {
   PILINE         pILine ;

   pILine = ILData (hWnd) ;

   return  (ILStop (pILine)) ;
   }