1245 lines
44 KiB
C++
1245 lines
44 KiB
C++
/*************************************************************************/
|
|
/* Copyright (C) 1999 Microsoft Corporation */
|
|
/* File: MSMFSldr.cpp */
|
|
/* Description: Implementation of CMSMFSldr */
|
|
/* Author: David Janecek */
|
|
/*************************************************************************/
|
|
#include "stdafx.h"
|
|
#include "MSMFCnt.h"
|
|
#include "MSMFSldr.h"
|
|
|
|
#define RECTWIDTH(lpRect) ((lpRect)->right - (lpRect)->left)
|
|
#define RECTHEIGHT(lpRect) ((lpRect)->bottom - (lpRect)->top)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMSMFSldr
|
|
|
|
/*************************************************************************/
|
|
/* Function: CMSMFSldr */
|
|
/*************************************************************************/
|
|
CMSMFSldr::CMSMFSldr(){
|
|
|
|
Init();
|
|
for(INT i = 0; i < cgMaxSldrStates; i++){
|
|
|
|
m_pThumbBitmap[i] = new CBitmap;
|
|
m_pBackBitmap[i] = new CBitmap;
|
|
}/* end of for loop */
|
|
|
|
}/* end of function CMSMFSldr */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Init */
|
|
/* Description: Initializes variable states. */
|
|
/*************************************************************************/
|
|
void CMSMFSldr::Init(){
|
|
|
|
m_nEntry = SldrState::Static;
|
|
m_fValue =0.2f;
|
|
m_fMin =0;
|
|
m_fMax = 100;
|
|
m_lXOffset = 5;
|
|
m_lYOffset = 2;
|
|
m_fKeyIncrement = 1.0f;
|
|
m_fKeyDecrement = 1.0f;
|
|
m_lThumbWidth = 8;
|
|
m_clrBackColor = ::GetSysColor(COLOR_BTNFACE);
|
|
|
|
::ZeroMemory(&m_rcThumb, sizeof(RECT));
|
|
}/* end of function Init */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ~CMSMFSldr */
|
|
/* Description: Cleanup the stuff we allocated here rest will be done */
|
|
/* in the button destructor. */
|
|
/*************************************************************************/
|
|
CMSMFSldr::~CMSMFSldr(){
|
|
|
|
ATLTRACE(TEXT("In the SLIDER Object destructor!\n"));
|
|
for(INT i = 0; i < cgMaxSldrStates; i++){
|
|
|
|
delete m_pThumbBitmap[i];
|
|
delete m_pBackBitmap[i];
|
|
m_pBackBitmap[i] = NULL;
|
|
m_pThumbBitmap[i] = NULL;
|
|
}/* end of for loop */
|
|
|
|
Init();
|
|
}/* end of function CMSMFSldr */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDraw */
|
|
/* Description: Does the basic drawing */
|
|
/* First draws the background the the thumb at the specific position. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::OnDraw(ATL_DRAWINFO& di){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
BOOL bRet = TRUE;
|
|
HDC hdc = di.hdcDraw;
|
|
RECT rcClient = *(RECT*)di.prcBounds;
|
|
|
|
HPALETTE hNewPal = m_pBackBitmap[m_nEntry]->GetPal();;
|
|
|
|
if (::IsWindow(m_hWnd)){ // is not windowless
|
|
|
|
CBitmap::SelectRelizePalette(di.hdcDraw, hNewPal);
|
|
}/* end of if statement */
|
|
|
|
|
|
// DRAW THE BACKGROUND
|
|
if (::IsWindow(m_hWnd) && m_blitType != DISABLE) {
|
|
|
|
COLORREF clr;
|
|
::OleTranslateColor (m_clrBackColor, hNewPal, &clr);
|
|
|
|
// fill background of specific color
|
|
HBRUSH hbrBack = ::CreateSolidBrush(clr);
|
|
|
|
if(NULL == hbrBack){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
//::FillRect(hdc, &rcClient, hbrBack);
|
|
::FillRect(di.hdcDraw, (LPRECT)di.prcBounds, hbrBack);
|
|
::DeleteObject(hbrBack);
|
|
}/* end of if statement */
|
|
|
|
if (m_pBackBitmap[m_nEntry]){
|
|
|
|
bRet = m_pBackBitmap[m_nEntry]->PaintTransparentDIB(hdc, &rcClient,
|
|
&rcClient);
|
|
}
|
|
else {
|
|
|
|
COLORREF clr;
|
|
::OleTranslateColor (m_clrBackColor, m_pBackBitmap[m_nEntry]->GetPal(), &clr);
|
|
|
|
HBRUSH hbrBack = ::CreateSolidBrush(clr);
|
|
::FillRect(hdc, &rcClient, hbrBack);
|
|
::DeleteObject(hbrBack);
|
|
}/* end of if statement */
|
|
|
|
// DRAW THE THUMB
|
|
#if 0 // just for debugging purposes
|
|
COLORREF clr = RGB(0xff, 0, 0);
|
|
|
|
HBRUSH hbrBack = ::CreateSolidBrush(clr);
|
|
::FillRect(hdc, &m_rcThumb, hbrBack);
|
|
::DeleteObject(hbrBack);
|
|
#endif
|
|
|
|
if (m_pBackBitmap[m_nEntry]){
|
|
|
|
RECT rcThumb = m_rcThumb;
|
|
|
|
if(!m_bWndLess){
|
|
|
|
ATLASSERT(::IsWindow(m_hWnd));
|
|
|
|
::OffsetRect(&rcThumb, -m_rcPos.left, -m_rcPos.top);
|
|
}/* end of if statement */
|
|
|
|
bRet = m_pThumbBitmap[m_nEntry]->PaintTransparentDIB(hdc, &rcThumb,
|
|
&rcThumb);
|
|
} /* end of if statement */
|
|
|
|
hr = GetFocus();
|
|
|
|
// THIS ASSUMES WE ARE REPAINTING THE WHOLE CONTROL
|
|
// WHICH IS WHAT ATL AT THIS INCARNATION DOES
|
|
if(S_OK == hr){
|
|
|
|
::DrawFocusRect(hdc, &rcClient);
|
|
}/* end of if statement */
|
|
|
|
if(!bRet){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
return (hr);
|
|
}/* end of function OnDraw */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSize */
|
|
/* Description: Handles the onsize message if we are self contained. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnSize(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
bHandled = true;
|
|
|
|
RecalculateTumbPos();
|
|
|
|
//ATLASSERT(FALSE); // move the code from SetObjectRects in here
|
|
|
|
return 0;
|
|
}/* end of function OnSize */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDispChange */
|
|
/* Description: Forwards this message to all the controls. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnDispChange(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
LONG lRes =0;
|
|
|
|
long cBitsPerPixel = (long) wParam;
|
|
long cxScreen = LOWORD(lParam);
|
|
long cyScreen = HIWORD(lParam);
|
|
|
|
for (int i=0; i<cgMaxSldrStates; i++) {
|
|
if (m_pThumbBitmap[i])
|
|
m_pThumbBitmap[i]->OnDispChange(cBitsPerPixel, cxScreen, cyScreen);
|
|
}
|
|
for (i=0; i<cgMaxSldrStates; i++) {
|
|
if (m_pBackBitmap[i])
|
|
m_pBackBitmap[i]->OnDispChange(cBitsPerPixel, cxScreen, cyScreen);
|
|
}
|
|
|
|
return(lRes);
|
|
}/* end of function OnDispChange */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSetFocus */
|
|
/* Description: If we are in disabled state SetFocus(false) */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnSetFocus(UINT msg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
if (m_nEntry == SldrState::Disabled){
|
|
|
|
if(GetFocus() == S_OK){
|
|
|
|
SetFocus(false);
|
|
}/* end of if statement */
|
|
|
|
FireViewChange();
|
|
return(-1);
|
|
}/* end of if statement */
|
|
|
|
FireViewChange();
|
|
return 0;
|
|
}/* end of function OnSetFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnKillFocus */
|
|
/* Description: If we are in disabled state SetFocus(false) */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnKillFocus(UINT msg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
FireViewChange();
|
|
return 0;
|
|
}/* end of function OnKillFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnButtonDown */
|
|
/* Description: Handles when buttons is selected. Captures the mouse */
|
|
/* movents (supported for windowless, via interfaces). */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnButtonDown(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
if (m_nEntry == SldrState::Disabled){
|
|
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
LONG xPos = GET_X_LPARAM(lParam);
|
|
LONG yPos = GET_Y_LPARAM(lParam);
|
|
|
|
if(PtOnSlider(xPos, yPos)){
|
|
|
|
if(SldrState::Hover != m_nEntry){
|
|
// in hover case we already have captured the mouse, so do not do
|
|
// that again
|
|
SetCapture(true); // capture the mouse messages
|
|
}/* end of if statement */
|
|
|
|
OffsetX(xPos);
|
|
SetThumbPos(xPos);
|
|
SetSliderState(SldrState::Push);
|
|
}/* end of if statement */
|
|
|
|
Fire_OnMouseDown();
|
|
|
|
return 0;
|
|
}/* end of function OnButtonDown */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnButtonUp */
|
|
/* Description: Releases the capture, updates the button visual state, */
|
|
/* and if release on the buttons image fire the event. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnButtonUp(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
LONG lRes = 0;
|
|
|
|
if (m_nEntry == SldrState::Disabled){
|
|
|
|
ForwardWindowMessage(WM_USER_FOCUS, (WPARAM) m_hWnd, 0, lRes);
|
|
ForwardWindowMessage(WM_USER_ENDHELP, (WPARAM) m_hWnd, 0, lRes);
|
|
|
|
return lRes;
|
|
}/* end of if statement */
|
|
|
|
|
|
LONG xPos = GET_X_LPARAM(lParam);
|
|
LONG yPos = GET_Y_LPARAM(lParam);
|
|
|
|
bool bOnButtonImage = PtOnSlider(xPos, yPos);
|
|
bool bFire = (m_nEntry == SldrState::Push);
|
|
|
|
if(bOnButtonImage){
|
|
|
|
SetSliderState(SldrState::Static); //change to static even
|
|
SetCapture(false); // release the capture of the mouse messages
|
|
}
|
|
else {
|
|
|
|
SetSliderState(SldrState::Static);
|
|
// do it only when we do not hower, if we hower, then keep the capture
|
|
SetCapture(false); // release the capture of the mouse messages
|
|
}/* end of if statement */
|
|
|
|
if (bFire){
|
|
|
|
if(bOnButtonImage){
|
|
|
|
OffsetX(xPos);
|
|
SetThumbPos(xPos);
|
|
Fire_OnClick();
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
Fire_OnMouseUp();
|
|
|
|
ForwardWindowMessage(WM_USER_FOCUS, (WPARAM) m_hWnd, 0, lRes);
|
|
ForwardWindowMessage(WM_USER_ENDHELP, (WPARAM) m_hWnd, 0, lRes);
|
|
|
|
return lRes;
|
|
}/* end of function OnButtonUp */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnMouseMove */
|
|
/* Description: Check if we were captured/pushed the do not do much, */
|
|
/* otherwise do the hit detection and see if we are in static or hower */
|
|
/* state. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnMouseMove(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
if (m_nEntry == SldrState::Disabled)
|
|
return 0;
|
|
|
|
LONG xPos = GET_X_LPARAM(lParam);
|
|
LONG yPos = GET_Y_LPARAM(lParam);
|
|
|
|
bool fPointOnSlider = PtOnSlider(xPos, yPos);
|
|
|
|
if (m_nEntry != SldrState::Push){
|
|
|
|
if(fPointOnSlider){
|
|
if(SldrState::Hover != m_nEntry || S_OK != GetCapture()){
|
|
|
|
SetCapture(true); // capture the mouse messages
|
|
SetSliderState(SldrState::Hover);
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
|
|
if(SldrState::Static != m_nEntry){
|
|
|
|
SetCapture(false); // release the capture of the mouse messages
|
|
SetSliderState(SldrState::Static);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
if(fPointOnSlider){
|
|
|
|
OffsetX(xPos);
|
|
SetThumbPos(xPos);
|
|
FireViewChange();
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return 0;
|
|
}/* end of function OnMouseMove */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnKeyDown */
|
|
/* Description: Depresses the button. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
bHandled = FALSE;
|
|
LONG lRes = 0;
|
|
|
|
switch(wParam){
|
|
|
|
case VK_RETURN:
|
|
case VK_SPACE:
|
|
case VK_LEFT:
|
|
case VK_RIGHT:
|
|
|
|
//SetSliderState(SldrState::Push);
|
|
bHandled = TRUE;
|
|
break;
|
|
}/* end of if statement */
|
|
return(lRes);
|
|
}/* end of function OnKeyDown */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnKeyUp */
|
|
/* Description: Distrubutes the keyboard messages properly. */
|
|
/*************************************************************************/
|
|
LRESULT CMSMFSldr::OnKeyUp(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
LONG lRes = 0;
|
|
bHandled = FALSE;
|
|
FLOAT m_fTmpValue = m_fValue;
|
|
|
|
bool fFireClick = false;
|
|
|
|
switch(wParam){
|
|
|
|
case VK_RETURN:
|
|
case VK_SPACE:
|
|
fFireClick = true;
|
|
break;
|
|
|
|
case VK_LEFT: m_fValue -= m_fKeyDecrement; FitValue();
|
|
fFireClick = true;
|
|
break;
|
|
|
|
case VK_RIGHT: m_fValue += m_fKeyIncrement; FitValue();
|
|
fFireClick = true;
|
|
break;
|
|
}/* end of switch statement */
|
|
|
|
if(fFireClick){
|
|
|
|
RecalculateTumbPos();
|
|
|
|
Fire_OnClick(); // we clicked on it, it does not meen
|
|
// we did change the value of it
|
|
if(m_fTmpValue != m_fValue){
|
|
|
|
Fire_OnValueChange(m_fValue);
|
|
}/* end of if statement */
|
|
//SetSliderState(SldrState::Static);
|
|
|
|
bHandled = TRUE;
|
|
}/* end of if statement */
|
|
|
|
return(lRes);
|
|
}/* end of function OnKeyUp */
|
|
|
|
/*************************************************************/
|
|
/* Function: FitValue */
|
|
/* Description: Fits the xVal inside the params. */
|
|
/*************************************************************/
|
|
HRESULT CMSMFSldr::FitValue(){
|
|
|
|
if(m_fValue < m_fMin){
|
|
|
|
m_fValue = m_fMin;
|
|
}/* end of if statement */
|
|
|
|
if(m_fValue > m_fMax){
|
|
|
|
m_fValue = m_fMax;
|
|
}/* end of if statement */
|
|
|
|
return(S_OK);
|
|
}/* end of function FitValue */
|
|
|
|
/*************************************************************/
|
|
/* Name: SetObjectRects */
|
|
/* Description: Update thumbnail rect object is being moved */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMSMFSldr::SetObjectRects(LPCRECT prcPos,LPCRECT prcClip){
|
|
// Call the default method first
|
|
IOleInPlaceObjectWindowlessImpl<CMSMFSldr>::SetObjectRects(prcPos, prcClip);
|
|
|
|
RecalculateTumbPos();
|
|
|
|
return UpdateTooltipRect(prcPos);
|
|
}/* end of function SetObjectRects */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PutThumbImage */
|
|
/* Description: Sets the image to thumb. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::PutThumbImage(BSTR strFilename, int nEntry){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_bstrThumbFilename[nEntry] = strFilename;
|
|
|
|
// figure out if we need to gray out the image
|
|
|
|
bool fGrayOut = false;
|
|
|
|
if(SldrState::Disabled == nEntry){
|
|
|
|
fGrayOut = gcfGrayOut;
|
|
}/* end of if statement */
|
|
|
|
hr = m_pThumbBitmap[nEntry]->PutImage(strFilename, m_hRes, TRUE, m_blitType, NORMAL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(nEntry == m_nEntry ){
|
|
// we are updating image that is being used, refresh it
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Redrawing the image\n"));
|
|
InvalidateRgn(); // our helper function
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function PutThumbImage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PutBackImage */
|
|
/* Description: Sets the image to Back. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::PutBackImage(BSTR strFilename, int nEntry){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_bstrBackFilename[nEntry] = strFilename;
|
|
|
|
bool fGrayOut = false;
|
|
|
|
if(SldrState::Disabled == nEntry){
|
|
|
|
fGrayOut = gcfGrayOut; // TODO some more complex stuff if we get custom disable
|
|
// images
|
|
}/* end of if statement */
|
|
|
|
hr = m_pBackBitmap[nEntry]->PutImage(strFilename, m_hRes, TRUE, m_blitType, NORMAL);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(nEntry == m_nEntry ){
|
|
// we are updating image that is being used, refresh it
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Redrawing the image\n"));
|
|
InvalidateRgn(); // our helper function
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function PutBackImage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_Value */
|
|
/* Description: Get the current value. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_Value(float *pVal){
|
|
|
|
*pVal = m_fValue;
|
|
|
|
return S_OK;
|
|
}/* end of function get_Value */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_Value */
|
|
/* Description: Sets the current value */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_Value(float newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(newVal < m_fMin || newVal > m_fMax){
|
|
|
|
hr = E_INVALIDARG;
|
|
return (hr);
|
|
}/* end of if statement */
|
|
|
|
if(newVal == m_fValue){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_fValue = newVal;
|
|
|
|
RecalculateTumbPos(); // apply the new position to the tumb rect and invalidate
|
|
|
|
return (hr);
|
|
}/* end of function put_Value */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_Min */
|
|
/* Description: Gets the minimum value on which the rect should expand */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_Min(float *pVal){
|
|
|
|
*pVal = m_fMin;
|
|
return S_OK;
|
|
}/* end of function get_Min */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_Max */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_Min(float newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_fMin = newVal;
|
|
hr = RecalculateTumbPos(); // apply the new position to the tumb rect and invalidate
|
|
|
|
//ATLASSERT(SUCCEEDED(hr));
|
|
|
|
return (S_OK);
|
|
}/* end of function put_Min */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_Max */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_Max(float *pVal){
|
|
|
|
*pVal = m_fMax;
|
|
return S_OK;
|
|
}/* end of function get_Max */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_Max */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_Max(float newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_fMax = newVal;
|
|
hr = RecalculateTumbPos(); // apply the new position to the tumb rect and invalidate
|
|
|
|
//ATLASSERT(SUCCEEDED(hr));
|
|
|
|
return (S_OK);
|
|
}/* end of function put_Max */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_XOffset */
|
|
/* Descriptoin: The part we do not draw on, end of the rail.. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_XOffset(LONG *pVal){
|
|
|
|
*pVal = m_lXOffset;
|
|
return S_OK;
|
|
}/* end of function get_XOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_XOffset */
|
|
/* Description: Adjust it, cache our new FLOAT offset and recalculate */
|
|
/* the position. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_XOffset(LONG newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_lXOffset = newVal;
|
|
|
|
hr = RecalculateTumbPos(); // apply the new position to the tumb rect and invalidate
|
|
|
|
//ATLASSERT(SUCCEEDED(hr));
|
|
|
|
return (S_OK);
|
|
}/* end of function put_XOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_Offset */
|
|
/* Descriptoin: The part we do not draw on, end of the rail.. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_YOffset(LONG *pVal){
|
|
|
|
*pVal = m_lYOffset;
|
|
return S_OK;
|
|
}/* end of function get_YOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_YOffset */
|
|
/* Description: Adjust it, cache our new FLOAT offset and recalculate */
|
|
/* the position. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_YOffset(LONG newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_lYOffset = newVal;
|
|
|
|
m_rcThumb.top = m_rcPos.top - m_lYOffset;
|
|
m_rcThumb.bottom = m_rcPos.bottom - m_lYOffset;
|
|
|
|
FireViewChange();
|
|
|
|
return (hr);
|
|
}/* end of function put_YOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbWidth */
|
|
/* Descriptoin: Width of the thumb. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbWidth(LONG *pVal){
|
|
|
|
*pVal = m_lThumbWidth;
|
|
return S_OK;
|
|
}/* end of function get_YOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbWidth */
|
|
/* Description: Sets the thumb width. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbWidth(LONG newVal){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_lThumbWidth = newVal;
|
|
|
|
RecalculateTumbPos();
|
|
|
|
return (S_OK);
|
|
}/* end of function put_YOffset */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbStatic */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbStatic(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrThumbFilename[SldrState::Static].Copy();
|
|
return S_OK;
|
|
}/* end of function get_ThumbStatic */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbStatic */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbStatic(BSTR strFilename){
|
|
|
|
if (!m_bstrThumbFilename[SldrState::Disabled]){
|
|
|
|
PutThumbImage(strFilename, SldrState::Disabled);
|
|
}/* end of if statement */
|
|
|
|
return (PutThumbImage(strFilename, SldrState::Static));
|
|
}/* end of function put_ThumbStatic */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbHover */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbHover(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrThumbFilename[SldrState::Hover].Copy();
|
|
|
|
return S_OK;
|
|
}/* end of function get_ThumbHover */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbHover */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbHover(BSTR strFilename){
|
|
|
|
return (PutThumbImage(strFilename, SldrState::Hover));
|
|
}/* end of function put_ThumbHover */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbPush */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbPush(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrThumbFilename[SldrState::Push].Copy();
|
|
return S_OK;
|
|
}/* end of function get_ThumbPush */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbPush */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbPush(BSTR strFilename){
|
|
|
|
return (PutThumbImage(strFilename, SldrState::Push));
|
|
}/* end of function put_ThumbPush */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbDisabled */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbDisabled(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrThumbFilename[SldrState::Disabled].Copy();
|
|
return S_OK;
|
|
}/* end of function get_ThumbDisabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbDisabled */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbDisabled(BSTR strFilename){
|
|
|
|
return (PutThumbImage(strFilename, SldrState::Disabled));
|
|
}/* end of function put_ThumbDisabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ThumbActive */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ThumbActive(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrThumbFilename[SldrState::Active].Copy();
|
|
return S_OK;
|
|
}/* end of function get_ThumbActive */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ThumbActive */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ThumbActive(BSTR strFilename){
|
|
|
|
return (PutThumbImage(strFilename, SldrState::Active));
|
|
}/* end of function put_ThumbActive */
|
|
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackStatic */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_BackStatic(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackFilename[SldrState::Static].Copy();
|
|
return S_OK;
|
|
}/* end of function get_BackStatic */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackStatic */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_BackStatic(BSTR strFilename){
|
|
|
|
if (!m_bstrBackFilename[SldrState::Disabled]){
|
|
|
|
PutBackImage(strFilename, SldrState::Disabled);
|
|
}/* end of if statement */
|
|
|
|
return (PutBackImage(strFilename, SldrState::Static));
|
|
}/* end of function put_BackStatic */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackHover */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_BackHover(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackFilename[SldrState::Hover].Copy();
|
|
|
|
return S_OK;
|
|
}/* end of function get_BackHover */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackHover */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_BackHover(BSTR strFilename){
|
|
|
|
return (PutBackImage(strFilename, SldrState::Hover));
|
|
}/* end of function put_BackHover */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackPush */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_BackPush(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackFilename[SldrState::Push].Copy();
|
|
return S_OK;
|
|
}/* end of function get_BackPush */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackPush */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_BackPush(BSTR strFilename){
|
|
|
|
return (PutBackImage(strFilename, SldrState::Push));
|
|
}/* end of function put_BackPush */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackDisabled */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_BackDisabled(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackFilename[SldrState::Disabled].Copy();
|
|
return S_OK;
|
|
}/* end of function get_BackDisabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackDisabled */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_BackDisabled(BSTR strFilename){
|
|
|
|
return (PutBackImage(strFilename, SldrState::Disabled));
|
|
}/* end of function put_BackDisabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackActive */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_BackActive(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackFilename[SldrState::Active].Copy();
|
|
return S_OK;
|
|
}/* end of function get_BackActive */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackActive */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_BackActive(BSTR strFilename){
|
|
|
|
return (PutBackImage(strFilename, SldrState::Active));
|
|
}/* end of function put_BackActive */
|
|
|
|
/*************************************************************/
|
|
/* Function: get_SldrState */
|
|
/* Description: Gets current slider state. */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_SldrState(long *pVal){
|
|
|
|
*pVal = (long) m_nEntry;
|
|
return S_OK;
|
|
}/* end of function get_SldrState */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_SldrState */
|
|
/* Description: Sets slider state. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_SldrState(long newVal){
|
|
|
|
HRESULT hr = SetSliderState((SldrState)newVal);
|
|
return (hr);
|
|
}/* end of function put_SldrState */
|
|
|
|
/*************************************************************/
|
|
/* Function: get_Disable */
|
|
/* Description: Returns OLE-BOOL if disabled or enabled. */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_Disable(VARIANT_BOOL *pVal){
|
|
|
|
*pVal = SldrState::Disabled == m_nEntry ? VARIANT_TRUE : VARIANT_FALSE;
|
|
return S_OK;
|
|
}/* end of function get_Disable */
|
|
|
|
/*************************************************************/
|
|
/* Function: put_Disable */
|
|
/* Description: Disable or enable the buttons (disabled */
|
|
/* are greyed out and do not except mouse clicks). */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_Disable(VARIANT_BOOL newVal){
|
|
|
|
SldrState sldrSt = VARIANT_FALSE == newVal ? SldrState::Static : SldrState::Disabled;
|
|
HRESULT hr = SetSliderState(sldrSt);
|
|
|
|
return (hr);
|
|
}/* end of function put_Disable */
|
|
|
|
/*************************************************************************/
|
|
/* HELPER Functions */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: RecalculateTumbPos */
|
|
/* Description: Centers the rect around x value. */
|
|
/* This one calculate the thumb rectangle x position. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::RecalculateTumbPos(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// offset the rect depending on the y value
|
|
m_rcThumb.top = m_rcPos.top + m_lYOffset;
|
|
m_rcThumb.bottom = m_rcPos.bottom - m_lYOffset;
|
|
|
|
// just offset x coordibate of the thumb the rect depening on the new xValue
|
|
// calculate the length
|
|
FLOAT flLengthU = m_fMax - m_fMin; // length in units
|
|
FLOAT flLengthR = (FLOAT)RECTWIDTH(&m_rcPos) - 2* m_lXOffset;
|
|
|
|
// calcalate the center of the thumb in RECT coordinates
|
|
FLOAT fPos = (m_fValue - m_fMin) * flLengthR / flLengthU;
|
|
// fPos is at the center of the thumb
|
|
|
|
LONG lThumbWidthHalf = m_lThumbWidth/2;
|
|
|
|
LONG lPos = (INT)fPos + m_lXOffset + m_rcPos.left;
|
|
|
|
if(lPos < (m_rcPos.left + lThumbWidthHalf) || lPos > (m_rcPos.right - lThumbWidthHalf)){
|
|
|
|
// we are of the rectangle
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
LONG lOldPos = m_rcThumb.left + lThumbWidthHalf;
|
|
|
|
if(lOldPos == lPos){
|
|
|
|
// thumb is in the same position as before so lets not bother with it
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_rcThumb.left = lPos - lThumbWidthHalf;
|
|
m_rcThumb.right = lPos + lThumbWidthHalf;
|
|
|
|
FireViewChange();
|
|
|
|
return(hr);
|
|
}/* end of function RecalculateTumbPos */
|
|
|
|
/*************************************************************************/
|
|
/* Function: RecalculateValue */
|
|
/* Description: Recalculates the slider value, since the thumb rect has */
|
|
/* changed. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::RecalculateValue(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// calculate the length
|
|
FLOAT flLengthU = m_fMax - m_fMin; // length in units
|
|
FLOAT flLengthR = (FLOAT)RECTWIDTH(&m_rcPos) - 2* m_lXOffset;
|
|
|
|
LONG lThumbXPos = m_rcThumb.left + m_lThumbWidth/2;
|
|
lThumbXPos -= m_rcPos.left + m_lXOffset; // shift it over to 0 origin at left offset
|
|
|
|
// calcalate the center of the thumb in VALUE coordinates
|
|
FLOAT fPos = m_fMin + (lThumbXPos) * flLengthU / flLengthR;
|
|
// fPos is at the center of the thumb
|
|
|
|
if(fPos < (m_fMin) || fPos > (m_fMax)){
|
|
|
|
// we are of the rectangle
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_fValue = fPos;
|
|
|
|
// Fire Event that we have changed our value
|
|
|
|
return(hr);
|
|
}/* end of function RecalculateValue */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetSliderState */
|
|
/* Description: Sets the button states forces redraw. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::SetSliderState(SldrState sldrState){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
bool fRedraw = false;
|
|
|
|
if(sldrState != m_nEntry ){
|
|
|
|
fRedraw = true;
|
|
}/* end of if statement */
|
|
|
|
m_nEntry = sldrState;
|
|
|
|
if(fRedraw){
|
|
|
|
if (m_nEntry == SldrState::Disabled){
|
|
|
|
SetFocus(false); // disable the focus
|
|
SetCapture(false);
|
|
}/* end of if statement */
|
|
|
|
// we are updating image that is being used, refresh it
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Redrawing the image\n"));
|
|
FireViewChange(); // update the display
|
|
//InvalidateRgn(); // our helper function
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetSliderState */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PtOnSlider */
|
|
/* Description: Uses helper to do the same. */
|
|
/*************************************************************************/
|
|
bool CMSMFSldr::PtOnSlider(LONG x, LONG y){
|
|
|
|
POINT pos = {x, y};
|
|
return(PtOnSlider(pos));
|
|
}/* end of function PtOnSlider */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PtOnSlider */
|
|
/* Description: Determines if the point is located on the slider. */
|
|
/* TODO: Needs to be modified when we will handle transparent color. */
|
|
/*************************************************************************/
|
|
bool CMSMFSldr::PtOnSlider(POINT pos){
|
|
|
|
RECT rc;
|
|
bool bRet = false;
|
|
|
|
if(m_bWndLess){
|
|
|
|
rc = m_rcPos;
|
|
}
|
|
else {
|
|
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return(bRet);
|
|
}/* end of if statement */
|
|
|
|
::GetClientRect(m_hWnd, &rc);
|
|
}/* end of if statement */
|
|
|
|
bRet = PtInRect(&rc, pos) ? true : false;
|
|
|
|
//TODO: Add also if we are on bitmap itsels possibly
|
|
|
|
#ifdef _DEBUG
|
|
if(bRet)
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Point x = %d y = %d in Rect left = %d top %d right %d bottom %d\n"),
|
|
pos.x, pos.y, m_rcPos.left, m_rcPos.top, m_rcPos.right, m_rcPos.bottom);
|
|
else
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Point x = %d y = %d NOT ON RECT Rect left = %d top %d right %d bottom %d\n"),
|
|
pos.x, pos.y, m_rcPos.left, m_rcPos.top, m_rcPos.right, m_rcPos.bottom);
|
|
#endif
|
|
|
|
return(bRet);
|
|
}/* end of function PtOnSlider */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PtOnThumb */
|
|
/* Description: Uses helper to do the same. */
|
|
/*************************************************************************/
|
|
bool CMSMFSldr::PtOnThumb(LONG x, LONG y){
|
|
|
|
POINT pos = {x, y};
|
|
return(PtOnThumb(pos));
|
|
}/* end of function PtOnThumb */
|
|
|
|
/*************************************************************************/
|
|
/* Function: PtOnThumb */
|
|
/* Description: Determines if the point is located on the slider. */
|
|
/* TODO: Needs to be modified when we will handle transparent color. */
|
|
/*************************************************************************/
|
|
bool CMSMFSldr::PtOnThumb(POINT pos){
|
|
|
|
RECT rc;
|
|
bool bRet = false;
|
|
|
|
if(m_bWndLess){
|
|
|
|
rc = m_rcPos;
|
|
}
|
|
else {
|
|
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return(bRet);
|
|
}/* end of if statement */
|
|
|
|
::GetClientRect(m_hWnd, &rc);
|
|
}/* end of if statement */
|
|
|
|
bRet = PtInRect(&rc, pos) ? true : false;
|
|
|
|
return(bRet);
|
|
}/* end of function PtOnThumb */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OffsetX */
|
|
/* Description: Adjusts the x position for windows case when we are 0,0 */
|
|
/* based. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::OffsetX(LONG& xPos){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
ATLASSERT(::IsWindow(m_hWnd));
|
|
|
|
xPos = m_rcPos.left + xPos;
|
|
|
|
return(hr);
|
|
}/* end of function OffsetX */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetThumbPos */
|
|
/* Description: Sets the thumb position. */
|
|
/*************************************************************************/
|
|
HRESULT CMSMFSldr::SetThumbPos(LONG xPos){
|
|
|
|
HRESULT hr = S_FALSE;
|
|
|
|
//MOVE THE THUMB TO THIS X POSITION
|
|
long ThumbWidthHalf = m_lThumbWidth /2;
|
|
|
|
// see if the positions are the same
|
|
if(m_rcThumb.left + ThumbWidthHalf != xPos){
|
|
|
|
// see if we are with offset regions
|
|
if((xPos > (m_rcPos.left + m_lXOffset)) &&
|
|
(xPos < (m_rcPos.right - m_lXOffset))){
|
|
|
|
m_rcThumb.left = xPos - ThumbWidthHalf;
|
|
m_rcThumb.right = xPos + ThumbWidthHalf;
|
|
hr = RecalculateValue();
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
Fire_OnValueChange(m_fValue); // fire to the container that we are chaning the value
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
|
|
hr = E_FAIL; // not in the offset any more
|
|
}/* end of if statement*/
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetThumbPos */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ArrowKeyIncrement */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ArrowKeyIncrement(FLOAT *pVal){
|
|
|
|
*pVal = m_fKeyIncrement;
|
|
return S_OK;
|
|
}/* end of function get_ArrowKeyIncrement */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ArrowKeyIncrement */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ArrowKeyIncrement(FLOAT newVal){
|
|
|
|
m_fKeyIncrement = newVal;
|
|
return S_OK;
|
|
}/* end of function put_ArrowKeyIncrement */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ArrowKeyDecrement */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::get_ArrowKeyDecrement(float *pVal){
|
|
|
|
*pVal = m_fKeyDecrement;
|
|
return S_OK;
|
|
}/* end of function get_ArrowKeyDecrement */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ArrowKeyDecrement */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMSMFSldr::put_ArrowKeyDecrement(float newVal){
|
|
|
|
m_fKeyDecrement = newVal;
|
|
return S_OK;
|
|
}/* end of function put_ArrowKeyDecrement */
|
|
|
|
/*************************************************************************/
|
|
/* End of file: MSMFSldr.cpp */
|
|
/*************************************************************************/
|