able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/dshow/mfvideo/tvplayer/msmfcnt/msmfsldr.cpp

1203 lines
42 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*************************************************************************/
/* 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 = 4.0f;
m_fKeyDecrement = 2.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(){
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;
// DRAW THE BACKGROUND
if (::IsWindow(m_hWnd) && m_blitType != DISABLE) {
// TODO: Optimaze palette handling
#if 0
HPALETTE hNewPal = m_pBitmap[m_nEntry]->GetPal();
if(hNewPal){
HPALETTE hPal = ::SelectPalette(di.hdcDraw, hNewPal, TRUE);
::RealizePalette(di.hdcDraw);
}/* end of if statement */
#endif
COLORREF clr;
HPALETTE hNewPal = m_pBackBitmap[m_nEntry]->GetPal();
::OleTranslateColor (m_clrBackColor, hNewPal, &clr);
// fill background of specific color
HBRUSH hbrBack = ::CreateSolidBrush(clr);
//::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, NULL,
&rcClient, m_blitType);
}
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, NULL,
&rcThumb, m_blitType);
} /* 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: 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);
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);
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);
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){
bHandled = FALSE;
LONG lRes = 0;
LONG xPos = m_rcThumb.left + m_lThumbWidth /2;
switch(wParam){
case VK_RETURN:
case VK_SPACE:
break;
case VK_LEFT: m_fValue -= m_fKeyDecrement; FitValue();
break;
case VK_RIGHT: m_fValue += m_fKeyIncrement; FitValue();
break;
}/* end of switch statement */
RecalculateTumbPos();
Fire_OnClick(); // we clicked on it, it does not meen
// we did change the value of it
SetSliderState(SldrState::Static);
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 S_OK;
}/* 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, GetUnknown(),fGrayOut ,m_blitType);
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, GetUnknown(),fGrayOut ,m_blitType);
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 */
/*************************************************************************/
Reference in a new issue Copy permalink