able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/perfmon/intrline.c

1085 lines
29 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
==============================================================================
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)) ;
}
Reference in a new issue Copy permalink