//*****************************************************************************
//
//! Handles messages for a slider widget.
//!
//! \param psWidget is a pointer to the slider widget.
//! \param ui32Msg is the message.
//! \param ui32Param1 is the first parameter to the message.
//! \param ui32Param2 is the second parameter to the message.
//!
//! This function receives messages intended for this slider widget and
//! processes them accordingly. The processing of the message varies based on
//! the message in question.
//!
//! Unrecognized messages are handled by calling WidgetDefaultMsgProc().
//!
//! \return Returns a value appropriate to the supplied message.
//
//*****************************************************************************
int32_t
SliderMsgProc(tWidget *psWidget, uint32_t ui32Msg, uint32_t ui32Param1,
uint32_t ui32Param2)
{
//
// Check the arguments.
//
ASSERT(psWidget);
//
// Determine which message is being sent.
//
switch(ui32Msg)
{
//
// The widget paint request has been sent.
//
case WIDGET_MSG_PAINT:
{
//
// Handle the widget paint request.
//
SliderPaint(psWidget, &(psWidget->sPosition));
//
// Return one to indicate that the message was successfully
// processed.
//
return(1);
}
//
// One of the pointer requests has been sent.
//
case WIDGET_MSG_PTR_DOWN:
case WIDGET_MSG_PTR_MOVE:
case WIDGET_MSG_PTR_UP:
{
//
// Handle the pointer request, returning the appropriate value.
//
return(SliderClick(psWidget, ui32Msg, ui32Param1, ui32Param2));
}
//
// An unknown request has been sent.
//
default:
{
//
// Let the default message handler process this message.
//
return(WidgetDefaultMsgProc(psWidget, ui32Msg, ui32Param1,
ui32Param2));
}
}
}
//*****************************************************************************
//
//! Handles pointer events for slider.
//!
//! \param pWidget is a pointer to the slider widget.
//! \param ulMsg is the pointer event message.
//! \param lX is the X coordinate of the pointer event.
//! \param lY is the Y coordinate of the pointer event.
//!
//! This function processes pointer event messages for a slider. This is
//! called in response to a \b #WIDGET_MSG_PTR_DOWN, \b #WIDGET_MSG_PTR_MOVE,
//! and \b #WIDGET_MSG_PTR_UP messages.
//!
//! If the message is \b #WIDGET_MSG_PTR_MOVE or is \b #WIDGET_MSG_PTR_DOWN and
//! the coordinates are within the bounds of the slider, the slider value is
//! updated and, if changed, the slider's OnChange callback function is called.
//!
//! \return Returns 1 if the message was consumed by the slider and 0
//! otherwise.
//
//*****************************************************************************
static long
SliderClick(tWidget *pWidget, unsigned long ulMsg, long lX, long lY)
{
tSliderWidget *pSlider;
tRectangle sRedrawRect;
short sPos;
long lNewVal;
//
// Check the arguments.
//
ASSERT(pWidget);
//
// Convert the generic widget pointer into a slider widget pointer.
//
pSlider = (tSliderWidget *)pWidget;
//
// If the slider is locked, ignore all pointer messages.
//
if(pSlider->ulStyle & SL_STYLE_LOCKED)
{
return(0);
}
//
// See if the given coordinates are within the extents of the slider.
//
if((ulMsg == WIDGET_MSG_PTR_MOVE) ||
((ulMsg == WIDGET_MSG_PTR_DOWN) &&
(lX >= pWidget->sPosition.sXMin) &&
(lX <= pWidget->sPosition.sXMax) &&
(lY >= pWidget->sPosition.sYMin) &&
(lY <= pWidget->sPosition.sYMax)))
{
//
// Map the pointer position to a slider value.
//
lNewVal = SliderPositionToValue(pSlider,
(pSlider->ulStyle & SL_STYLE_VERTICAL) ? lY : lX);
//
// Convert back to ensure that the dirty rectangle we calculate here
// uses the same values as will be used when the widget is next
// painted.
//
sPos = SliderValueToPosition(pSlider, lNewVal);
//
// Did the value change?
//
if(lNewVal != pSlider->lValue)
{
//
// Yes - the value changed so report it to the app and redraw the
// slider.
//
if(pSlider->pfnOnChange)
{
(pSlider->pfnOnChange)(pWidget, lNewVal);
}
//
// Determine the rectangle that we need to redraw to update the
// slider to the new position.
//
if(pSlider->ulStyle & SL_STYLE_VERTICAL)
{
//
// Vertical slider case.
//
sRedrawRect.sYMin = min(pSlider->sPos, sPos);
sRedrawRect.sYMax = max(pSlider->sPos, sPos);
sRedrawRect.sXMin = pWidget->sPosition.sXMin;
sRedrawRect.sXMax = pWidget->sPosition.sXMax;
}
else
{
//
// Horizontal slider case.
//
sRedrawRect.sXMin = min(pSlider->sPos, sPos);
sRedrawRect.sXMax = max(pSlider->sPos, sPos);
sRedrawRect.sYMin = pWidget->sPosition.sYMin;
sRedrawRect.sYMax = pWidget->sPosition.sYMax;
}
//
// Update the widget value and position.
//
pSlider->lValue = lNewVal;
pSlider->sPos = sPos;
//
// Redraw the area of the control that has changed.
//
SliderPaint(pWidget, &sRedrawRect);
}
//
// These coordinates are within the extents of the slider widget.
//
return(1);
}
//
// These coordinates are not within the extents of the slider widget.
//
return(0);
}
