able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/conf/audiolvl.cpp

1194 lines
26 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#include "resource.h"
#include "AudioLvl.h"
static const int g_nAudIconWidth = 16;
static const int g_nAudIconHeight = 16;
static const int g_nAudChkbWidth = 13;
static const int g_nAudChkbHeight = 13;
static const int g_nAudChkbXMargin = 13;
static const int g_nAudChkbYMargin = 12;
static const int g_nAudIconXMargin = g_nAudChkbXMargin + g_nAudChkbWidth + 3;
static const int g_nAudIconYMargin = 10;
static const int g_nAudMeterXMargin = g_nAudIconXMargin + g_nAudIconWidth + 5;
static const int g_nAudMeterHeight = 7;
static const int g_nAudMeterYMargin = g_nAudIconYMargin + (g_nAudMeterHeight/2);
static const int g_nAudMeterRightMargin = 5; // 5 pixels from end
static const int g_nAudTrkRangeMin = 0;
static const int g_nAudTrkRangeMax = 99;
static const int g_nAudTrkRangeSeg = 0xFFFF / g_nAudTrkRangeMax;
static const int g_nAudTrkTickFreq = 20;
static const int g_nAudTrkRightGap = 3;
static const int g_nAudTrkXMargin = g_nAudIconXMargin + g_nAudIconWidth + 5;
static const int g_nAudTrkYMargin = 2;
static const int g_nAudTrkHeight = 25;
static const int g_nAudTrkMinWidth = 50;
static const int RECTANGLE_WIDTH = 10;
static const int RECTANGLE_LEADING = 1;
static inline WORD ScaleMixer(DWORD dwVol)
{
// NOTE: the "+ g_nAudTrkRangeSeg - 1" provides for a correction that
// takes place while truncating the position when we are setting the
// volume. See bug 1634
return (((LOWORD(dwVol) + g_nAudTrkRangeSeg - 1) *
g_nAudTrkRangeMax) / 0xFFFF);
}
CAudioLevel::CAudioLevel(CAudioControl *pAudioControl) :
m_hwndParent(NULL),
m_hwndMicTrack(NULL),
m_hwndMicTrackTT(NULL),
m_hwndSpkTrack(NULL),
m_hwndSpkTrackTT(NULL),
m_hIconMic(NULL),
m_hIconSpkr(NULL),
m_hwndChkbRecMute(NULL),
m_hwndChkbSpkMute(NULL),
m_hwndChkbRecMuteTT(NULL),
m_hwndChkbSpkMuteTT(NULL),
m_fVisible(FALSE),
m_fMicTrkVisible(TRUE),
m_fSpkTrkVisible(TRUE),
m_dwMicTrackPos(0xFFFFFFFF),
m_dwSpkTrackPos(0xFFFFFFFF),
m_dwMicLvl(0),
m_dwSpkLvl(0),
m_hGreyBrush(NULL), m_hBlackBrush(NULL), m_hRedBrush(NULL),
m_hGreenBrush(NULL), m_hYellowBrush(NULL), m_hHiLitePen(NULL),
m_hShadowPen(NULL), m_hDkShadowPen(NULL), m_hLitePen(NULL)
{
ClearStruct(&m_rect);
m_pAudioControl = pAudioControl;
// load icons
m_hIconSpkr = (HICON) ::LoadImage( ::GetInstanceHandle(),
MAKEINTRESOURCE(IDI_SPKEMPTY),
IMAGE_ICON,
g_nAudIconWidth,
g_nAudIconHeight,
LR_DEFAULTCOLOR | LR_SHARED);
m_hIconMic = (HICON) ::LoadImage( ::GetInstanceHandle(),
MAKEINTRESOURCE(IDI_MICEMPTY),
IMAGE_ICON,
g_nAudIconWidth,
g_nAudIconHeight,
LR_DEFAULTCOLOR | LR_SHARED);
// create the brushes used for painting the signal level
CreateBrushes();
}
CAudioLevel::~CAudioLevel()
{
if (m_hGreyBrush)
DeleteObject(m_hGreyBrush);
if (m_hRedBrush)
DeleteObject(m_hRedBrush);
if (m_hYellowBrush)
DeleteObject(m_hYellowBrush);
if (m_hGreenBrush)
DeleteObject(m_hGreenBrush);
if (m_hBlackBrush)
DeleteObject(m_hBlackBrush);
if (m_hHiLitePen)
DeleteObject(m_hHiLitePen);
if (m_hDkShadowPen)
DeleteObject(m_hDkShadowPen);
if (m_hShadowPen)
DeleteObject(m_hShadowPen);
if (m_hLitePen)
DeleteObject(m_hLitePen);
}
CAudioLevel::Create(HWND hwndParent)
{
BOOL fCanSetRecVolume, fCanSetSpkVolume;
BOOL fCheck;
m_hwndParent = hwndParent;
m_hwndParentParent = GetParent(hwndParent);
fCanSetRecVolume = m_pAudioControl->CanSetRecorderVolume();
fCanSetSpkVolume = m_pAudioControl->CanSetSpeakerVolume();
// create the mute check box for microphone
m_hwndChkbRecMute = ::CreateWindow( _TEXT("BUTTON"),
g_szEmpty,
WS_CHILD | WS_CLIPSIBLINGS |
BS_AUTOCHECKBOX,
0, 0, 0, 0,
m_hwndParent,
(HMENU) IDM_MUTE_MICROPHONE,
GetInstanceHandle(),
NULL);
if (m_hwndChkbRecMute != NULL)
{
// mute is initially off
fCheck = !(m_pAudioControl->IsRecMuted());
::SendMessage(m_hwndChkbRecMute, BM_SETCHECK, fCheck, 0);
// create the tool tip
m_hwndChkbRecMuteTT = CreateWindowEx(0,
TOOLTIPS_CLASS,
(LPSTR) NULL,
0, // styles
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
m_hwndParent,
(HMENU) NULL,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndChkbRecMuteTT)
{
TOOLINFO ti;
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS | TTF_IDISHWND;
ti.hwnd = m_hwndParent;
ti.hinst = ::GetInstanceHandle();
ti.uId = (UINT) m_hwndChkbRecMute;
ti.lpszText = (LPTSTR) IDS_AUDIO_REC_MUTE_TT;
::SendMessage( m_hwndChkbRecMuteTT, TTM_ADDTOOL, 0,
(LPARAM) (LPTOOLINFO) &ti);
}
}
// create the mute check box for speaker
m_hwndChkbSpkMute = ::CreateWindow( _TEXT("BUTTON"),
g_szEmpty,
WS_CHILD | WS_CLIPSIBLINGS
| BS_AUTOCHECKBOX,
0, 0, 0, 0,
m_hwndParent,
(HMENU) IDM_MUTE_SPEAKER,
GetInstanceHandle(),
NULL);
if (NULL != m_hwndChkbSpkMute)
{
// set appropriate mute status in microphone's mute check box
fCheck = !(m_pAudioControl->IsSpkMuted());
// Mute is off - so check it
::SendMessage(m_hwndChkbSpkMute, BM_SETCHECK, fCheck, 0);
// create the tool tip
m_hwndChkbSpkMuteTT = CreateWindowEx(0,
TOOLTIPS_CLASS,
(LPSTR) NULL,
0, // styles
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
m_hwndParent,
(HMENU) NULL,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndChkbSpkMuteTT)
{
TOOLINFO ti;
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS | TTF_IDISHWND;
ti.hwnd = m_hwndParent;
ti.hinst = ::GetInstanceHandle();
ti.uId = (UINT) m_hwndChkbSpkMute;
ti.lpszText = (LPTSTR) IDS_AUDIO_SPK_MUTE_TT;
::SendMessage( m_hwndChkbSpkMuteTT, TTM_ADDTOOL, 0,
(LPARAM) (LPTOOLINFO) &ti);
}
}
// create the mic level trackbar:
m_hwndMicTrack = ::CreateWindowEx( 0L,
TRACKBAR_CLASS,
g_szEmpty,
WS_CHILD | WS_CLIPSIBLINGS
| TBS_HORZ | TBS_NOTICKS | TBS_BOTH
| (fCanSetRecVolume ? 0 : WS_DISABLED),
0, 0, 0, 0,
m_hwndParent,
(HMENU) ID_AUDIODLG_MIC_TRACK,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndMicTrack)
{
::SendMessage( m_hwndMicTrack,
TBM_SETRANGE,
FALSE,
MAKELONG(g_nAudTrkRangeMin, g_nAudTrkRangeMax));
::SendMessage( m_hwndMicTrack,
TBM_SETTICFREQ,
g_nAudTrkTickFreq,
g_nAudTrkRangeMin);
WORD wPos = (g_nAudTrkRangeMax - g_nAudTrkRangeMin) / 2;
if (fCanSetRecVolume)
{
wPos = ScaleMixer(m_pAudioControl->GetRecorderVolume());
}
::SendMessage( m_hwndMicTrack,
TBM_SETPOS,
TRUE,
wPos);
m_hwndMicTrackTT = CreateWindowEx( 0,
TOOLTIPS_CLASS,
(LPSTR) NULL,
0, // styles
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
m_hwndParent,
(HMENU) NULL,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndMicTrackTT)
{
TOOLINFO ti;
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS | TTF_IDISHWND;
ti.hwnd = m_hwndParent;
ti.hinst = ::GetInstanceHandle();
ti.uId = (UINT) m_hwndMicTrack;
ti.lpszText = (LPTSTR) IDS_AUDIO_MIC_TRACK_TT;
::SendMessage(m_hwndMicTrackTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
}
}
// create the speaker level trackbar:
m_hwndSpkTrack = ::CreateWindowEx( 0L,
TRACKBAR_CLASS,
g_szEmpty,
WS_CHILD | WS_CLIPSIBLINGS
| TBS_HORZ | TBS_NOTICKS | TBS_BOTH
| (fCanSetSpkVolume ? 0 : WS_DISABLED),
0, 0, 0, 0,
m_hwndParent,
(HMENU) ID_AUDIODLG_SPKR_TRACK,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndSpkTrack)
{
::SendMessage( m_hwndSpkTrack,
TBM_SETRANGE,
FALSE,
MAKELONG(g_nAudTrkRangeMin, g_nAudTrkRangeMax));
::SendMessage( m_hwndSpkTrack,
TBM_SETTICFREQ,
g_nAudTrkTickFreq,
g_nAudTrkRangeMin);
WORD wPos = (g_nAudTrkRangeMax - g_nAudTrkRangeMin) / 2;
if (fCanSetSpkVolume)
{
wPos = ScaleMixer(m_pAudioControl->GetSpeakerVolume());
}
::SendMessage( m_hwndSpkTrack,
TBM_SETPOS,
TRUE,
wPos);
m_hwndSpkTrackTT = CreateWindowEx( 0,
TOOLTIPS_CLASS,
(LPSTR) NULL,
0, // styles
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
m_hwndParent,
(HMENU) NULL,
::GetInstanceHandle(),
NULL);
if (NULL != m_hwndSpkTrackTT)
{
TOOLINFO ti;
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS | TTF_IDISHWND;
ti.hwnd = m_hwndParent;
ti.hinst = ::GetInstanceHandle();
ti.uId = (UINT) m_hwndSpkTrack;
ti.lpszText = (LPTSTR) IDS_AUDIO_SPK_TRACK_TT;
::SendMessage(m_hwndSpkTrackTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
}
}
return TRUE;
}
BOOL CAudioLevel::ForwardSysChangeMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CreateBrushes();
if (NULL != m_hwndMicTrack)
{
::SendMessage(m_hwndMicTrack, uMsg, wParam, lParam);
}
if (NULL != m_hwndSpkTrack)
{
::SendMessage(m_hwndSpkTrack, uMsg, wParam, lParam);
}
return TRUE;
}
BOOL CAudioLevel::CreateBrushes()
{
// the background color may change on us!
COLORREF GreyColor = GetSysColor(COLOR_3DFACE);
COLORREF BlackColor = GetSysColor(COLOR_BTNTEXT);
const COLORREF RedColor = RGB(255,0,0);
const COLORREF YellowColor = RGB(255,255,0);
const COLORREF GreenColor = RGB(0,255,0);
COLORREF ShadowColor = GetSysColor(COLOR_3DSHADOW);
COLORREF HiLiteColor = GetSysColor(COLOR_3DHIGHLIGHT);
COLORREF LiteColor = GetSysColor(COLOR_3DLIGHT);
COLORREF DkShadowColor = GetSysColor(COLOR_3DDKSHADOW);
if (m_hGreyBrush)
{
DeleteObject(m_hGreyBrush);
}
m_hGreyBrush = CreateSolidBrush(GreyColor);
if (m_hBlackBrush)
{
DeleteObject(m_hBlackBrush);
}
m_hBlackBrush = CreateSolidBrush(BlackColor);
if (m_hHiLitePen)
{
DeleteObject(m_hHiLitePen);
}
m_hHiLitePen = CreatePen(PS_SOLID, 0, HiLiteColor);
if (m_hLitePen)
{
DeleteObject(m_hLitePen);
}
m_hLitePen = CreatePen(PS_SOLID, 0, LiteColor);
if (m_hDkShadowPen)
{
DeleteObject(m_hDkShadowPen);
}
m_hDkShadowPen = CreatePen(PS_SOLID, 0, DkShadowColor);
if (m_hShadowPen)
{
DeleteObject(m_hShadowPen);
}
m_hShadowPen = CreatePen(PS_SOLID, 0, ShadowColor);
// red, yellow, green will never change
if (!m_hRedBrush)
m_hRedBrush = CreateSolidBrush (RedColor);
if (!m_hGreenBrush)
m_hGreenBrush = CreateSolidBrush(GreenColor);
if (!m_hYellowBrush)
m_hYellowBrush = CreateSolidBrush(YellowColor);
return TRUE;
}
BOOL CAudioLevel::OnCommand(WPARAM wParam, LPARAM lParam)
{
LRESULT lCheck;
BOOL fSpeaker;
switch (LOWORD(wParam))
{
default:
return FALSE;
case IDM_MUTE_MICROPHONE_ACCEL:
lCheck = BST_CHECKED;
fSpeaker = FALSE;
break;
case IDM_MUTE_MICROPHONE:
lCheck = BST_UNCHECKED;
fSpeaker = FALSE;
break;
case IDM_MUTE_SPEAKER_ACCEL:
lCheck = BST_CHECKED;
fSpeaker = TRUE;
break;
case IDM_MUTE_SPEAKER:
lCheck = BST_UNCHECKED;
fSpeaker = TRUE;
break;
}
BOOL fMute = (lCheck == ::SendMessage(
fSpeaker ? m_hwndChkbSpkMute : m_hwndChkbRecMute,
BM_GETCHECK, 0, 0));
m_pAudioControl->MuteAudio(fSpeaker, fMute);
return TRUE;
}
BOOL CAudioLevel::ShiftFocus(HWND hwndCur, BOOL fForward)
{
BOOL bRet = FALSE;
HWND aHwnds[] = {m_hwndChkbSpkMute,m_hwndSpkTrack,m_hwndChkbRecMute,m_hwndMicTrack};
int nSizeArray = ARRAY_ELEMENTS(aHwnds);
int nIndex, nSelect;
HWND hwndNewFocus=NULL;
if (m_fVisible)
{
if (hwndCur == NULL)
{
hwndNewFocus = m_hwndSpkTrack;
}
else
{
for (nIndex = 0; nIndex < nSizeArray; nIndex++)
{
if (aHwnds[nIndex] == hwndCur)
{
nSelect = (nIndex + (fForward ? 1 : -1)) % nSizeArray;
if (nSelect < 0)
nSelect += nSizeArray;
hwndNewFocus = aHwnds[nSelect];
break;
}
}
}
if (hwndNewFocus)
{
SetFocus(hwndNewFocus);
bRet = TRUE;
}
}
return bRet;
}
BOOL CAudioLevel::IsChildWindow(HWND hwnd)
{
if (hwnd)
{
if ((hwnd == m_hwndSpkTrack) || (hwnd == m_hwndMicTrack) ||
(hwnd == m_hwndChkbRecMute) || (hwnd == m_hwndChkbSpkMute))
{
return TRUE;
}
}
return FALSE;
}
BOOL CAudioLevel::OnMuteChange(BOOL fSpeaker, BOOL fMute)
{
SendMessage(fSpeaker ? m_hwndChkbSpkMute : m_hwndChkbRecMute,
BM_SETCHECK, fMute ? BST_UNCHECKED : BST_CHECKED, 0);
return TRUE;
}
BOOL CAudioLevel::OnPaint(PAINTSTRUCT* pps)
{
if (m_fVisible)
{
ASSERT(pps);
ASSERT(pps->hdc);
PaintIcons(pps->hdc);
}
return TRUE;
}
BOOL CAudioLevel::PaintChannel(BOOL fSpeaker, HDC hdc)
{
BOOL bGotDC = FALSE;
DWORD dwVolume;
int nVuWidth, nDiff;
RECT rect, rectDraw;
HBRUSH hCurrentBrush;
HPEN hOldPen;
int nRects;
int nRectangleWidth;
int nIndex;
const int NUM_RECTANGLES_MAX = 16;
const int NUM_RECTANGLES_MIN = 6;
int nRectsTotal;
bool bTransmitting;
POINT ptOld, pt;
if (fSpeaker)
{
dwVolume = LOWORD(m_dwSpkLvl);
bTransmitting = HIWORD(m_dwSpkLvl) & SIGNAL_STATUS_TRANSMIT;
}
else
{
dwVolume = LOWORD(m_dwMicLvl);
bTransmitting = HIWORD(m_dwMicLvl) & SIGNAL_STATUS_TRANSMIT;
}
if (!hdc)
{
if ((fSpeaker) && (m_hwndSpkTrack))
hdc = GetDC(m_hwndSpkTrack);
else if (m_hwndMicTrack)
hdc = GetDC(m_hwndMicTrack);
bGotDC = TRUE;
}
if (!hdc)
return FALSE;
// rectangle leading is 1
if (dwVolume > 100)
dwVolume = 100;
if (fSpeaker)
rect = m_rcChannelSpk;
else
rect = m_rcChannelMic;
nVuWidth = rect.right - rect.left;
if (nVuWidth < (NUM_RECTANGLES_MIN*2))
return FALSE;
// "rect" represents the edges of the meter's outer rectangle
// compute the number of individual rectangles to use
// we do the computation this way so that sizing the rebar band
// makes the size changes consistant
nRectsTotal = NUM_RECTANGLES_MAX;
nRectsTotal = (nVuWidth + (g_nAudMeterHeight - 1)) / g_nAudMeterHeight;
nRectsTotal = min(nRectsTotal, NUM_RECTANGLES_MAX);
nRectsTotal = max(nRectsTotal, NUM_RECTANGLES_MIN);
// nRectangleWidth - width of colored rectangle - no leading
nRectangleWidth = ((nVuWidth-2)/nRectsTotal) - 1;
// nVuWidth - width of entire VU meter including edges
nVuWidth = (nRectangleWidth + 1)*nRectsTotal + 2;
// re-adjust meter size to be an integral number of rects
nDiff = rect.right - (rect.left + nVuWidth);
rect.right = rect.left + nVuWidth;
// center vu-meter across whole channel area so that the
// slider's thumb is always covering some portion of the channel
rect.left += (nDiff/2);
rect.right += (nDiff/2);
// draw the 3D frame border
hOldPen = (HPEN) SelectObject (hdc, m_hHiLitePen);
MoveToEx(hdc, rect.right, rect.top, &ptOld);
LineTo(hdc, rect.right, rect.bottom);
LineTo(hdc, rect.left-1, rect.bottom); // -1 because LineTo stops just short of this point
SelectObject(hdc, m_hShadowPen);
MoveToEx(hdc, rect.left, rect.bottom-1, &pt);
LineTo(hdc, rect.left, rect.top);
LineTo(hdc, rect.right, rect.top);
SelectObject(hdc, m_hDkShadowPen);
MoveToEx(hdc, rect.left+1, rect.bottom-2, &pt);
LineTo(hdc, rect.left+1, rect.top+1);
LineTo(hdc, rect.right-1, rect.top+1);
SelectObject(hdc, m_hLitePen);
MoveToEx(hdc, rect.left+1, rect.bottom-1, &pt);
LineTo(hdc, rect.right-1, rect.bottom-1);
LineTo(hdc, rect.right-1, rect.top);
SelectObject(hdc, m_hShadowPen);
// the top and left of the meter has a 2 line border
// the bottom and right of the meter has a 2 line border
rectDraw.top = rect.top + 2;
rectDraw.bottom = rect.bottom - 1 ;
rectDraw.left = rect.left + 2;
rectDraw.right = rectDraw.left + nRectangleWidth;
// how many colored rectangles do we draw ?
nRects = (dwVolume * nRectsTotal) / 100;
// not transmitting - don't show anything
if ((false == bTransmitting) && (false == fSpeaker))
nRects = 0;
// transmitting or receiving something very quiet -
// light up at least one rectangle
else if ((bTransmitting) && (nRects == 0))
nRects = 1;
hCurrentBrush = m_hGreenBrush;
for (nIndex = 0; nIndex < nRectsTotal; nIndex++)
{
// far left fourth of the bar is green
// right fourth of the bar is red
// middle is yellow
if (nIndex > ((nRectsTotal*3)/4))
hCurrentBrush = m_hRedBrush;
else if (nIndex >= nRectsTotal/2)
hCurrentBrush = m_hYellowBrush;
if (nIndex >= nRects)
hCurrentBrush = m_hGreyBrush;
FillRect(hdc, &rectDraw, hCurrentBrush);
if (nIndex != (nRectsTotal-1))
{
MoveToEx(hdc, rectDraw.left + nRectangleWidth, rectDraw.top, &pt);
LineTo(hdc, rectDraw.left + nRectangleWidth, rectDraw.bottom);
}
rectDraw.left += nRectangleWidth + 1; // +1 for the leading
rectDraw.right = rectDraw.left + nRectangleWidth;
}
MoveToEx(hdc, ptOld.x, ptOld.y, &pt);
SelectObject (hdc, hOldPen);
if (bGotDC)
{
DeleteDC(hdc);
}
return TRUE;
}
BOOL CAudioLevel::OnTimer(WPARAM wTimerID)
{
DWORD dwLevel;
if (m_fVisible && (NULL != m_pAudioControl))
{
dwLevel = m_pAudioControl->GetAudioSignalLevel(FALSE /*fSpeaker*/); // This level ranges from 0-100
if (dwLevel != m_dwMicLvl)
{
m_dwMicLvl = dwLevel;
// HACK: SETRANGEMAX is the only way to force the slider to update itself...
SendMessage(m_hwndMicTrack, TBM_SETRANGEMAX, TRUE, g_nAudTrkRangeMax);
}
dwLevel = m_pAudioControl->GetAudioSignalLevel(TRUE /*fSpeaker*/); // This level ranges from 0-100
if (dwLevel != m_dwSpkLvl)
{
m_dwSpkLvl = dwLevel;
SendMessage(m_hwndSpkTrack, TBM_SETRANGEMAX, TRUE, g_nAudTrkRangeMax);
}
}
return TRUE;
}
// returns the coordinates of where one of the icons should be drawn
BOOL CAudioLevel::GetIconArea(BOOL fSpeaker, RECT *pRect)
{
int nIconY;
int nLeftMic;
int nLeftSpk;
nIconY = (m_rect.bottom - m_rect.top - g_nAudIconHeight - 1) / 2;
pRect->top = m_rect.top + nIconY;
pRect->bottom = pRect->top + g_nAudIconHeight;
if (fSpeaker)
{
pRect->left = m_rect.left + ((m_rect.right - m_rect.left) / 2) + g_nAudIconXMargin;
}
else
{
pRect->left = m_rect.left + g_nAudIconXMargin;
}
pRect->right = pRect->left + g_nAudIconWidth;
return TRUE;
}
BOOL CAudioLevel::PaintIcons(HDC hdc)
{
int nIconY;
ASSERT(hdc);
RECT rect;
if (NULL != m_hIconMic)
{
GetIconArea(FALSE, &rect);
DrawIconEx( hdc,
rect.left,
rect.top,
m_hIconMic,
rect.right - rect.left,
rect.bottom - rect.top,
0,
NULL,
DI_NORMAL);
}
if (NULL != m_hIconSpkr)
{
GetIconArea(TRUE, &rect);
DrawIconEx( hdc,
rect.left,
rect.top,
m_hIconSpkr,
rect.right - rect.left,
rect.bottom - rect.top,
0,
NULL,
DI_NORMAL);
}
return TRUE;
}
BOOL CAudioLevel::OnDeviceStatusChanged(BOOL fSpeaker, UINT uEvent, UINT uSubCode)
{
UINT uIconID;
HICON *phIcon;
UINT *puIconID;
RECT rectInvalid;
switch (uEvent)
{
case NM_STREAMEVENT_DEVICE_CLOSED:
{
uIconID = fSpeaker ? IDI_SPKEMPTY : IDI_MICEMPTY;
break;
}
case NM_STREAMEVENT_DEVICE_OPENED:
{
uIconID = fSpeaker ? IDI_SPEAKER : IDI_MICFONE;
break;
}
case NM_STREAMEVENT_DEVICE_FAILURE:
{
uIconID = fSpeaker ? IDI_SPKERROR : IDI_MICERROR;
break;
}
default:
return FALSE;
}
phIcon = fSpeaker ? &m_hIconSpkr : &m_hIconMic;
puIconID = fSpeaker ? &m_uIconSpkrID : &m_uIconMicID;
if (*puIconID == uIconID)
return TRUE;
*phIcon = (HICON) ::LoadImage( ::GetInstanceHandle(),
MAKEINTRESOURCE(uIconID),
IMAGE_ICON,
g_nAudIconWidth,
g_nAudIconHeight,
LR_DEFAULTCOLOR | LR_SHARED);
// invalidate the icon regions
if (m_hwndParentParent)
{
RECT rect;
GetIconArea(fSpeaker, &rect);
::MapWindowPoints(m_hwndParent, m_hwndParentParent, (LPPOINT) &rect, 2);
::InvalidateRect(m_hwndParentParent, &rect, TRUE /* erase bkgnd */);
::UpdateWindow(m_hwndParentParent);
}
return TRUE;
}
BOOL CAudioLevel::Resize(int nLeft, int nTop, int nWidth, int nHeight)
{
int nCBY, nTBY; // checkbox, trackbar, and Icon y positions
// Disable redraws:
ASSERT(m_hwndChkbRecMute && m_hwndChkbSpkMute && m_hwndMicTrack && m_hwndSpkTrack);
if (m_fVisible)
{
::SendMessage(m_hwndChkbRecMute, WM_SETREDRAW, FALSE, 0);
::SendMessage(m_hwndChkbSpkMute, WM_SETREDRAW, FALSE, 0);
::SendMessage(m_hwndMicTrack, WM_SETREDRAW, FALSE, 0);
::SendMessage(m_hwndSpkTrack, WM_SETREDRAW, FALSE, 0);
}
m_rect.left = nLeft;
m_rect.top = nTop;
m_rect.right = nLeft + nWidth;
m_rect.bottom = nTop + nHeight;
nCBY = (m_rect.bottom - m_rect.top - g_nAudChkbHeight) / 2;
if (nCBY < 0)
nCBY = 0;
// "+1" so the trackbar is better centered with the checkbox and icon
nTBY = (m_rect.bottom - m_rect.top - g_nAudTrkHeight + 1) / 2;
if (nTBY < 0)
nTBY = 0;
int nHalfPoint = nLeft + (nWidth / 2);
if (NULL != m_hwndChkbRecMute)
{
::MoveWindow( m_hwndChkbRecMute,
nLeft + g_nAudChkbXMargin,
nTop + nCBY,
g_nAudChkbWidth,
g_nAudChkbHeight,
TRUE /* repaint */);
}
if (NULL != m_hwndChkbSpkMute)
{
::MoveWindow( m_hwndChkbSpkMute,
nHalfPoint + g_nAudChkbXMargin,
nTop + nCBY,
g_nAudChkbWidth,
g_nAudChkbHeight,
TRUE /* repaint */);
}
m_fMicTrkVisible = m_fVisible;
if (NULL != m_hwndMicTrack)
{
int nMicTrkWidth = nHalfPoint - g_nAudTrkRightGap - (nLeft + g_nAudTrkXMargin);
::MoveWindow( m_hwndMicTrack,
nLeft + g_nAudTrkXMargin,
nTop + nTBY,
nMicTrkWidth,
g_nAudTrkHeight,
FALSE /* don't repaint */);
m_fMicTrkVisible = (nMicTrkWidth > g_nAudTrkMinWidth);
}
m_fSpkTrkVisible = m_fVisible;
if (NULL != m_hwndSpkTrack)
{
int nSpkTrkWidth = nLeft + nWidth - g_nAudTrkRightGap
- (nHalfPoint + g_nAudTrkXMargin);
::MoveWindow( m_hwndSpkTrack,
nHalfPoint + g_nAudTrkXMargin,
nTop + nTBY,
nSpkTrkWidth,
g_nAudTrkHeight,
FALSE /* don't repaint */);
m_fSpkTrkVisible = (nSpkTrkWidth > g_nAudTrkMinWidth);
}
// enable redraws
if (m_fVisible)
{
::SendMessage(m_hwndChkbRecMute, WM_SETREDRAW, TRUE, 0);
::SendMessage(m_hwndChkbSpkMute, WM_SETREDRAW, TRUE, 0);
// Enable redraws:
if (m_fMicTrkVisible)
{
::SendMessage(m_hwndMicTrack, WM_SETREDRAW, TRUE, 0);
}
if (m_fSpkTrkVisible)
{
::SendMessage(m_hwndSpkTrack, WM_SETREDRAW, TRUE, 0);
}
// Force the title area to repaint:
::InvalidateRect(m_hwndChkbRecMute, NULL, TRUE /* erase bkgnd */);
::InvalidateRect(m_hwndChkbSpkMute, NULL, TRUE /* erase bkgnd */);
::InvalidateRect(m_hwndMicTrack, NULL, TRUE /* erase bkgnd */);
::InvalidateRect(m_hwndSpkTrack, NULL, TRUE /* erase bkgnd */);
ASSERT(m_hwndParent);
ASSERT(m_hwndParentParent);
RECT rctTemp = m_rect;
::MapWindowPoints(m_hwndParent, m_hwndParentParent, (LPPOINT) &rctTemp, 2);
::InvalidateRect(m_hwndParentParent, &rctTemp, TRUE /* erase bkgnd */);
::UpdateWindow(m_hwndParentParent);
}
return TRUE;
}
BOOL CAudioLevel::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT *plRet)
{
LPNMCUSTOMDRAW pCustomDraw;
BOOL bRet = FALSE, fSpeaker;
RECT *pChannelRect;
*plRet = 0;
fSpeaker = (wParam == ID_AUDIODLG_SPKR_TRACK);
if (fSpeaker)
{
pChannelRect = &m_rcChannelSpk;
}
else
{
pChannelRect = &m_rcChannelMic;
}
pCustomDraw = (LPNMCUSTOMDRAW)lParam;
switch (pCustomDraw->dwDrawStage)
{
case CDDS_PREPAINT:
bRet = TRUE;
*plRet = CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT;
break;
case CDDS_ITEMPREPAINT:
if (pCustomDraw->dwItemSpec == TBCD_CHANNEL)
{
*plRet = CDRF_SKIPDEFAULT;
bRet = TRUE;
pCustomDraw->rc.top -= 2;
pCustomDraw->rc.bottom += 2;
*pChannelRect = pCustomDraw->rc;
PaintChannel(fSpeaker, pCustomDraw->hdc);
}
break;
default:
break;
}
return bRet;
}
BOOL CAudioLevel::OnScroll(WPARAM wParam, LPARAM lParam)
{
BOOL bRet = FALSE;
if ((HWND) lParam == m_hwndMicTrack)
{
DWORD dwCurMicTrackPos = ::SendMessage((HWND) lParam, TBM_GETPOS, 0, 0);
if (m_dwMicTrackPos != dwCurMicTrackPos)
{
m_dwMicTrackPos = dwCurMicTrackPos;
m_pAudioControl->SetRecorderVolume(
(m_dwMicTrackPos * 0xFFFF) / g_nAudTrkRangeMax);
}
bRet = TRUE;
}
else if ((HWND) lParam == m_hwndSpkTrack)
{
DWORD dwCurSpkTrackPos = ::SendMessage((HWND) lParam, TBM_GETPOS, 0, 0);
if (m_dwSpkTrackPos != dwCurSpkTrackPos)
{
m_dwSpkTrackPos = dwCurSpkTrackPos;
m_pAudioControl->SetSpeakerVolume(
(m_dwSpkTrackPos * 0xFFFF) / g_nAudTrkRangeMax);
}
bRet = TRUE;
}
return bRet;
}
BOOL CAudioLevel::OnLevelChange(BOOL fSpeaker, DWORD dwVolume)
{
if (fSpeaker)
{
if (NULL != m_hwndSpkTrack)
{
DWORD dwTrackPos = ScaleMixer(dwVolume);
if (m_dwSpkTrackPos != dwTrackPos)
{
m_dwSpkTrackPos = dwTrackPos;
TRACE_OUT(("Setting Spk Volume to %d", m_dwSpkTrackPos));
::SendMessage( m_hwndSpkTrack,
TBM_SETPOS,
TRUE,
m_dwSpkTrackPos);
}
}
}
else
{
if (NULL != m_hwndMicTrack)
{
DWORD dwTrackPos = ScaleMixer(dwVolume);
if (m_dwMicTrackPos != dwTrackPos)
{
m_dwMicTrackPos = dwTrackPos;
TRACE_OUT(("Setting Mic Volume to %d", m_dwMicTrackPos));
::SendMessage( m_hwndMicTrack,
TBM_SETPOS,
TRUE,
m_dwMicTrackPos);
}
}
}
return TRUE;
}
BOOL CAudioLevel::OnDeviceChanged(void)
{
ASSERT(m_pAudioControl);
EnableWindow(m_hwndMicTrack, m_pAudioControl->CanSetRecorderVolume());
EnableWindow(m_hwndSpkTrack, m_pAudioControl->CanSetSpeakerVolume());
return TRUE;
}
BOOL CAudioLevel::Show(BOOL fVisible)
{
m_fVisible = fVisible;
if (m_fVisible)
{
// Start mic sensitivity timer:
::SetTimer(m_hwndParent, AUDIODLG_MIC_TIMER, AUDIODLG_MIC_TIMER_PERIOD, NULL);
}
else
{
// Stop mic sensitivity timer:
::KillTimer(m_hwndParent, AUDIODLG_MIC_TIMER);
}
// Hide or show all windows:
if (NULL != m_hwndChkbRecMute)
{
::ShowWindow(m_hwndChkbRecMute, fVisible ? SW_SHOW : SW_HIDE);
}
if (NULL != m_hwndChkbSpkMute)
{
::ShowWindow(m_hwndChkbSpkMute, fVisible ? SW_SHOW : SW_HIDE);
}
if (NULL != m_hwndMicTrack)
{
::ShowWindow(m_hwndMicTrack, (fVisible && m_fMicTrkVisible) ? SW_SHOW : SW_HIDE);
}
if (NULL != m_hwndSpkTrack)
{
::ShowWindow(m_hwndSpkTrack, (fVisible && m_fSpkTrkVisible) ? SW_SHOW : SW_HIDE);
}
return TRUE;
}
Reference in a new issue Copy permalink