{

MeterAx(wxWindow * window);

virtual ~ MeterAx();

// Performs the default action. childId is 0 (the action for this object)

// or > 0 (the action for a child).

// Return wxACC_NOT_SUPPORTED if there is no default action for this

// window (e.g. an edit control).

wxAccStatus DoDefaultAction(int childId) override;

// Retrieves the address of an IDispatch interface for the specified child.

// All objects must support this property.

wxAccStatus GetChild(int childId, wxAccessible** child) override;

// Gets the number of children.

wxAccStatus GetChildCount(int* childCount) override;

// Gets the default action for this object (0) or > 0 (the action for a child).

// Return wxACC_OK even if there is no action. actionName is the action, or the empty

// string if there is no action.

// The retrieved string describes the action that is performed on an object,

// not what the object does as a result. For example, a toolbar button that prints

// a document has a default action of "Press" rather than "Prints the current document."

wxAccStatus GetDefaultAction(int childId, wxString *actionName) override;

// Returns the description for this object or a child.

wxAccStatus GetDescription(int childId, wxString *description) override;

// Gets the window with the keyboard focus.

// If childId is 0 and child is NULL, no object in

// this subhierarchy has the focus.

// If this object has the focus, child should be 'this'.

wxAccStatus GetFocus(int *childId, wxAccessible **child) override;

// Returns help text for this object or a child, similar to tooltip text.

wxAccStatus GetHelpText(int childId, wxString *helpText) override;

// Returns the keyboard shortcut for this object or child.

// Return e.g. ALT+K

wxAccStatus GetKeyboardShortcut(int childId, wxString *shortcut) override;

// Returns the rectangle for this object (id = 0) or a child element (id > 0).

// rect is in screen coordinates.

wxAccStatus GetLocation(wxRect& rect, int elementId) override;

// Gets the name of the specified object.

wxAccStatus GetName(int childId, wxString *name) override;

// Returns a role constant.

wxAccStatus GetRole(int childId, wxAccRole *role) override;

// Gets a variant representing the selected children

// of this object.

// Acceptable values:

// - a null variant (IsNull() returns TRUE)

// - a list variant (GetType() == wxT("list"))

// - an integer representing the selected child element,

// or 0 if this object is selected (GetType() == wxT("long"))

// - a "void*" pointer to a wxAccessible child object

wxAccStatus GetSelections(wxVariant *selections) override;

// Returns a state constant.

wxAccStatus GetState(int childId, long* state) override;

// Returns a localized string representing the value for the object

// or child.

wxAccStatus GetValue(int childId, wxString* strValue) override;

{

wxString output; // somewhere to build up a string in

output = wxString::Format(wxT("Meter update msg: %i channels, %i samples\n"), \

kMaxMeterBars, numFrames);

for (int i = 0; i<kMaxMeterBars; i++)

{ // for each channel of the meters

output += wxString::Format(wxT("%f peak, %f rms "), peak[i], rms[i]);

if (clipping[i])

output += wxString::Format(wxT("clipped "));

else

output += wxString::Format(wxT("no clip "));

output += wxString::Format(wxT("%i head, %i tail\n"), headPeakCount[i], tailPeakCount[i]);

}

return output;

{

for (int i = 0; i<kMaxMeterBars; i++)

{

if (clipping[i] || (headPeakCount[i] > 0) || (tailPeakCount[i] > 0))

return toString();

}

return wxT("");

mBufferSize(maxLen)

{

Clear();

{

mStart = 0;

mEnd = 0;

{

// mStart can be greater than mEnd because it is all mod mBufferSize

wxASSERT( (mEnd + mBufferSize - mStart) >= 0 );

int len = (mEnd + mBufferSize - mStart) % mBufferSize;

// Never completely fill the queue, because then the

// state is ambiguous (mStart==mEnd)

if (len + 1 >= (int)(mBufferSize))

return false;

//wxLogDebug(wxT("Put: %s"), msg.toString());

mBuffer[mEnd] = msg;

mEnd = (mEnd+1)%mBufferSize;

return true;

{

int len = (mEnd + mBufferSize - mStart) % mBufferSize;

if (len == 0)

return false;

msg = mBuffer[mStart];

mStart = (mStart+1)%mBufferSize;

return true;

wxWindow* parent, wxWindowID id,

bool isInput,

const wxPoint& pos /*= wxDefaultPosition*/,

const wxSize& size /*= wxDefaultSize*/,

Style style /*= HorizontalStereo*/,

float fDecayRate /*= 60.0f*/)

: MeterPanelBase(parent, id, pos, size, wxTAB_TRAVERSAL | wxNO_BORDER | wxWANTS_CHARS),

mProject(project),

mQueue(1024),

mWidth(size.x),

mHeight(size.y),

mIsInput(isInput),

mDesiredStyle(style),

mGradient(true),

mDB(true),

mDBRange(ENV_DB_RANGE),

mDecay(true),

mDecayRate(fDecayRate),

mClip(true),

mNumPeakSamplesToClip(3),

mPeakHoldDuration(3),

mT(0),

mRate(0),

mMonitoring(false),

mActive(false),

mNumBars(0),

mLayoutValid(false),

mBitmap{},

mIcon{},

mAccSilent(false)

{

// i18n-hint: Noun (the meter is used for playback or record level monitoring)

SetName( XO("Meter") );

// Suppress warnings about the header file

wxUnusedVar(SpeakerMenu_xpm);

wxUnusedVar(MicMenu_xpm);

wxUnusedVar(PrefStyles);

mStyle = mDesiredStyle;

mIsFocused = false;

#if wxUSE_ACCESSIBILITY

SetAccessible(safenew MeterAx(this));

#endif

// Do this BEFORE UpdatePrefs()!

mRuler.SetFonts(GetFont(), GetFont(), GetFont());

mRuler.SetFlip(mStyle != MixerTrackCluster);

mRuler.SetLabelEdges(true);

//mRuler.SetTickColour( wxColour( 0,0,255 ) );

UpdatePrefs();

wxColour backgroundColour = theTheme.Colour( clrMedium);

mBkgndBrush = wxBrush(backgroundColour, wxBRUSHSTYLE_SOLID);

SetBackgroundColour( backgroundColour );

mPeakPeakPen = wxPen(theTheme.Colour( clrMeterPeak), 1, wxPENSTYLE_SOLID);

mDisabledPen = wxPen(theTheme.Colour( clrMeterDisabledPen), 1, wxPENSTYLE_SOLID);

if (mIsInput) {

wxTheApp->Bind(EVT_AUDIOIO_MONITOR,

&MeterPanel::OnAudioIOStatus,

this);

wxTheApp->Bind(EVT_AUDIOIO_CAPTURE,

&MeterPanel::OnAudioIOStatus,

this);

mPen = wxPen( theTheme.Colour( clrMeterInputPen ), 1, wxPENSTYLE_SOLID);

mBrush = wxBrush( theTheme.Colour( clrMeterInputBrush ), wxBRUSHSTYLE_SOLID);

mRMSBrush = wxBrush( theTheme.Colour( clrMeterInputRMSBrush ), wxBRUSHSTYLE_SOLID);

mClipBrush = wxBrush( theTheme.Colour( clrMeterInputClipBrush ), wxBRUSHSTYLE_SOLID);

}

else {

// Register for AudioIO events

wxTheApp->Bind(EVT_AUDIOIO_PLAYBACK,

&MeterPanel::OnAudioIOStatus,

this);

mPen = wxPen( theTheme.Colour( clrMeterOutputPen ), 1, wxPENSTYLE_SOLID);

mBrush = wxBrush( theTheme.Colour( clrMeterOutputBrush ), wxBRUSHSTYLE_SOLID);

mRMSBrush = wxBrush( theTheme.Colour( clrMeterOutputRMSBrush ), wxBRUSHSTYLE_SOLID);

mClipBrush = wxBrush( theTheme.Colour( clrMeterOutputClipBrush ), wxBRUSHSTYLE_SOLID);

}

// No longer show a difference in the background colour when not monitoring.

// We have the tip instead.

mDisabledBkgndBrush = mBkgndBrush;

// MixerTrackCluster style has no menu, so disallows SetStyle, so never needs icon.

if (mStyle != MixerTrackCluster)

{

if(mIsInput)

{

//mIcon = NEW wxBitmap(MicMenuNarrow_xpm);

mIcon = std::make_unique<wxBitmap>(wxBitmap(theTheme.Bitmap(bmpMic)));

}

else

{

//mIcon = NEW wxBitmap(SpeakerMenuNarrow_xpm);

mIcon = std::make_unique<wxBitmap>(wxBitmap(theTheme.Bitmap(bmpSpeaker)));

}

}

mTimer.SetOwner(this, OnMeterUpdateID);

// TODO: Yikes. Hard coded sample rate.

// JKC: I've looked at this, and it's benignish. It just means that the meter

// balistics are right for 44KHz and a bit more frisky than they should be

// for higher sample rates.

Reset(44100.0, true);

{

mDBRange = gPrefs->Read(ENV_DB_KEY, ENV_DB_RANGE);

mMeterRefreshRate =

std::max(MIN_REFRESH_RATE, std::min(MAX_REFRESH_RATE,

gPrefs->Read(Key(wxT("RefreshRate")), 30)));

mGradient = gPrefs->Read(Key(wxT("Bars")), wxT("Gradient")) == wxT("Gradient");

mDB = gPrefs->Read(Key(wxT("Type")), wxT("dB")) == wxT("dB");

mMeterDisabled = gPrefs->Read(Key(wxT("Disabled")), (long)0);

if (mDesiredStyle != MixerTrackCluster)

{

wxString style = gPrefs->Read(Key(wxT("Style")));

if (style == wxT("AutomaticStereo"))

{

mDesiredStyle = AutomaticStereo;

}

else if (style == wxT("HorizontalStereo"))

{

mDesiredStyle = HorizontalStereo;

}

else if (style == wxT("VerticalStereo"))

{

mDesiredStyle = VerticalStereo;

}

else

{

mDesiredStyle = AutomaticStereo;

}

}

// Set the desired orientation (resets ruler orientation)

SetActiveStyle(mDesiredStyle);

// Reset to ensure NEW size is retrieved when language changes

mLeftSize = wxSize(0, 0);

mRightSize = wxSize(0, 0);

Reset(mRate, false);

mLayoutValid = false;

Refresh(false);

{

static int value = wxNewId();

return value;

{

if (id == MeterPrefsID())

UpdatePrefs();

{

#if defined(__WXMAC__)

auto paintDC = std::make_unique<wxPaintDC>(this);

#else

std::unique_ptr<wxDC> paintDC{ wxAutoBufferedPaintDCFactory(this) };

#endif

wxDC & destDC = *paintDC;

wxColour clrText = theTheme.Colour( clrTrackPanelText );

wxColour clrBoxFill = theTheme.Colour( clrMedium );

if (mLayoutValid == false || (mStyle == MixerTrackCluster ))

{

// Create a NEW one using current size and select into the DC

mBitmap = std::make_unique<wxBitmap>();

mBitmap->Create(mWidth, mHeight, destDC);

wxMemoryDC dc;

dc.SelectObject(*mBitmap);

// Go calculate all of the layout metrics

HandleLayout(dc);

// Start with a clean background

// LLL: Should research USE_AQUA_THEME usefulness...

#ifdef EXPERIMENTAL_THEMING

//if( !mMeterDisabled )

//{

// mBkgndBrush.SetColour( GetParent()->GetBackgroundColour() );

//}

#endif

mBkgndBrush.SetColour( GetBackgroundColour() );

dc.SetPen(*wxTRANSPARENT_PEN);

dc.SetBrush(mBkgndBrush);

dc.DrawRectangle(0, 0, mWidth, mHeight);

// MixerTrackCluster style has no icon or L/R labels

if (mStyle != MixerTrackCluster)

{

bool highlight = InIcon();

dc.DrawBitmap( theTheme.Bitmap( highlight ?

bmpHiliteUpButtonSmall : bmpUpButtonSmall ),

mIconRect.GetPosition(), false );

dc.DrawBitmap(*mIcon, mIconRect.GetPosition(), true);

dc.SetFont(GetFont());

dc.SetTextForeground( clrText );

dc.SetTextBackground( clrBoxFill );

dc.DrawText(mLeftText, mLeftTextPos.x, mLeftTextPos.y);

dc.DrawText(mRightText, mRightTextPos.x, mRightTextPos.y);

}

// Setup the colors for the 3 sections of the meter bars

wxColor green(117, 215, 112);

wxColor yellow(255, 255, 0);

wxColor red(255, 0, 0);

// Bug #2473 - (Sort of) Hack to make text on meters more

// visible with darker backgrounds. It would be better to have

// different colors entirely and as part of the theme.

if (GetBackgroundColour().GetLuminance() < 0.25)

{

green = wxColor(117-100, 215-100, 112-100);

yellow = wxColor(255-100, 255-100, 0);

red = wxColor(255-100, 0, 0);

}

else if (GetBackgroundColour().GetLuminance() < 0.50)

{

green = wxColor(117-50, 215-50, 112-50);

yellow = wxColor(255-50, 255-50, 0);

red = wxColor(255-50, 0, 0);

}

// Draw the meter bars at maximum levels

for (unsigned int i = 0; i < mNumBars; i++)

{

// Give it a recessed look

AColor::Bevel(dc, false, mBar[i].b);

// Draw the clip indicator bevel

if (mClip)

{

AColor::Bevel(dc, false, mBar[i].rClip);

}

// Cache bar rect

wxRect r = mBar[i].r;

if (mGradient)

{

// Calculate the size of the two gradiant segments of the meter

double gradw;

double gradh;

if (mDB)

{

gradw = (double) r.GetWidth() / mDBRange * 6.0;

gradh = (double) r.GetHeight() / mDBRange * 6.0;

}

else

{

gradw = (double) r.GetWidth() / 100 * 25;

gradh = (double) r.GetHeight() / 100 * 25;

}

if (mBar[i].vert)

{

// Draw the "critical" segment (starts at top of meter and works down)

r.SetHeight(gradh);

dc.GradientFillLinear(r, red, yellow, wxSOUTH);

// Draw the "warning" segment

r.SetTop(r.GetBottom());

dc.GradientFillLinear(r, yellow, green, wxSOUTH);

// Draw the "safe" segment

r.SetTop(r.GetBottom());

r.SetBottom(mBar[i].r.GetBottom());

dc.SetPen(*wxTRANSPARENT_PEN);

dc.SetBrush(green);

dc.DrawRectangle(r);

}

else

{

// Draw the "safe" segment

r.SetWidth(r.GetWidth() - (int) (gradw + gradw + 0.5));

dc.SetPen(*wxTRANSPARENT_PEN);

dc.SetBrush(green);

dc.DrawRectangle(r);

// Draw the "warning" segment

r.SetLeft(r.GetRight() + 1);

r.SetWidth(floor(gradw));

dc.GradientFillLinear(r, green, yellow);

// Draw the "critical" segment

r.SetLeft(r.GetRight() + 1);

r.SetRight(mBar[i].r.GetRight());

dc.GradientFillLinear(r, yellow, red);

}

#ifdef EXPERIMENTAL_METER_LED_STYLE

if (!mBar[i].vert)

{

wxRect r = mBar[i].r;

wxPen BackgroundPen;

BackgroundPen.SetColour( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE) );

dc.SetPen( BackgroundPen );

int i;

for(i=0;i<r.width;i++)

{

// 2 pixel spacing between the LEDs

if( (i%7)<2 ){

AColor::Line( dc, i+r.x, r.y, i+r.x, r.y+r.height );

} else {

// The LEDs have triangular ends.

// This code shapes the ends.

int j = abs( (i%7)-4);

AColor::Line( dc, i+r.x, r.y, i+r.x, r.y+j +1);

AColor::Line( dc, i+r.x, r.y+r.height-j, i+r.x, r.y+r.height );

}

}

}

#endif

}

}

mRuler.SetTickColour( clrText );

dc.SetTextForeground( clrText );

// Draw the ruler

#ifndef EXPERIMENTAL_DA

mRuler.Draw(dc);

#endif

// Bitmap created...unselect

dc.SelectObject(wxNullBitmap);

}

// Copy predrawn bitmap to the dest DC

destDC.DrawBitmap(*mBitmap, 0, 0);

// Go draw the meter bars, Left & Right channels using current levels

for (unsigned int i = 0; i < mNumBars; i++)

{

DrawMeterBar(destDC, &mBar[i]);

}

destDC.SetTextForeground( clrText );

#ifndef EXPERIMENTAL_DA

// We can have numbers over the bars, in which case we have to draw them each time.

if (mStyle == HorizontalStereoCompact || mStyle == VerticalStereoCompact)

{

mRuler.SetTickColour( clrText );

// If the text colour is too similar to the meter colour, then we need a background

// for the text. We require a total of at least one full-scale RGB difference.

int d = theTheme.ColourDistance( clrText, theTheme.Colour( clrMeterOutputRMSBrush ) );

if( d < 256 )

{

destDC.SetBackgroundMode( wxSOLID );

destDC.SetTextBackground( clrBoxFill );

}

mRuler.Draw(destDC);

}

#endif

// Let the user know they can click to start monitoring

if( mIsInput && !mActive )

{

destDC.SetFont( GetFont() );

wxArrayStringEx texts{

_("Click to Start Monitoring") ,

_("Click for Monitoring") ,

_("Click to Start") ,

_("Click") ,

};

for( size_t i = 0, cnt = texts.size(); i < cnt; i++ )

{

wxString Text = wxT(" ") + texts[i] + wxT(" ");

wxSize Siz = destDC.GetTextExtent( Text );

Siz.SetWidth( Siz.GetWidth() + gap );

Siz.SetHeight( Siz.GetHeight() + gap );

if( mBar[0].vert)

{

if( Siz.GetWidth() < mBar[0].r.GetHeight() )

{

wxRect r( mBar[1].b.GetLeft() - (int) (Siz.GetHeight() / 2.0) + 0.5,

mBar[0].r.GetTop() + (int) ((mBar[0].r.GetHeight() - Siz.GetWidth()) / 2.0) + 0.5,

Siz.GetHeight(),

Siz.GetWidth() );

destDC.SetBrush( wxBrush( clrBoxFill ) );

destDC.SetPen( *wxWHITE_PEN );

destDC.DrawRectangle( r );

destDC.SetBackgroundMode( wxTRANSPARENT );

r.SetTop( r.GetBottom() + (gap / 2) );

destDC.SetTextForeground( clrText );

destDC.DrawRotatedText( Text, r.GetPosition(), 90 );

break;

}

}

else

{

if( Siz.GetWidth() < mBar[0].r.GetWidth() )

{

wxRect r( mBar[0].r.GetLeft() + (int) ((mBar[0].r.GetWidth() - Siz.GetWidth()) / 2.0) + 0.5,

mBar[1].b.GetTop() - (int) (Siz.GetHeight() / 2.0) + 0.5,

Siz.GetWidth(),

Siz.GetHeight() );

destDC.SetBrush( wxBrush( clrBoxFill ) );

destDC.SetPen( *wxWHITE_PEN );

destDC.DrawRectangle( r );

destDC.SetBackgroundMode( wxTRANSPARENT );

r.SetLeft( r.GetLeft() + (gap / 2) );

r.SetTop( r.GetTop() + (gap / 2));

destDC.SetTextForeground( clrText );

destDC.DrawText( Text, r.GetPosition() );

break;

}

}

}

}

if (mIsFocused)

{

wxRect r = mIconRect;

AColor::DrawFocus(destDC, r.Inflate(1, 1));

}

{

GetClientSize(&mWidth, &mHeight);

mLayoutValid = false;

Refresh();

{

auto point = pEvent ? pEvent->GetPosition() : ScreenToClient(::wxGetMousePosition());

return mIconRect.Contains(point);

{

bool shouldHighlight = InIcon(&evt);

if ((evt.GetEventType() == wxEVT_MOTION || evt.Entering() || evt.Leaving()) &&

(mHighlighted != shouldHighlight)) {

mHighlighted = shouldHighlight;

mLayoutValid = false;

Refresh();

}

if (mStyle == MixerTrackCluster) // MixerTrackCluster style has no menu.

return;

#if wxUSE_TOOLTIPS // Not available in wxX11

if (evt.Leaving()){

ProjectStatus::Get( *mProject ).Set({});

}

else if (evt.Entering()) {

// Display the tooltip in the status bar

wxToolTip * pTip = this->GetToolTip();

if( pTip ) {

auto tipText = Verbatim( pTip->GetTip() );

ProjectStatus::Get( *mProject ).Set(tipText);

}

}

#endif

if (evt.RightDown() ||

(evt.ButtonDown() && InIcon(&evt)))

{

wxMenu menu;

// Note: these should be kept in the same order as the enum

if (mIsInput) {

wxMenuItem *mi;

if (mMonitoring)

mi = menu.Append(OnMonitorID, _("Stop Monitoring"));

else

mi = menu.Append(OnMonitorID, _("Start Monitoring"));

mi->Enable(!mActive || mMonitoring);

}

menu.Append(OnPreferencesID, _("Options..."));

if (evt.RightDown()) {

ShowMenu(evt.GetPosition());

}

else {

ShowMenu(wxPoint(mIconRect.x + 1, mIconRect.y + mIconRect.height + 1));

}

}

else if (evt.LeftDown()) {

if (mIsInput) {

if (mActive && !mMonitoring) {

Reset(mRate, true);

}

else {

StartMonitoring();

}

}

else {

Reset(mRate, true);

}

}

{

#if defined(__WXMSW__)

if (mHadKeyDown)

#endif

if (mStyle != MixerTrackCluster) // MixerTrackCluster style has no menu.

{

ShowMenu(wxPoint(mIconRect.x + 1, mIconRect.y + mIconRect.height + 1));

}

else

{

evt.Skip();

}

#if defined(__WXMSW__)

mHadKeyDown = false;

#endif

{

switch (evt.GetKeyCode())

{

// These are handled in the OnKeyUp handler because, on Windows at least, the

// key up event will be passed on to the menu if we show it here. This causes

// the default sound to be heard if assigned.

//

// But, again on Windows, when the user selects a menu item, it is handled by

// the menu and the key up event is passed along to our OnKeyUp() handler, so

// we have to ignore it, otherwise we'd just show the menu again.

case WXK_RETURN:

case WXK_NUMPAD_ENTER:

case WXK_WINDOWS_MENU:

case WXK_MENU:

#if defined(__WXMSW__)

mHadKeyDown = true;

#endif

break;

case WXK_RIGHT:

Navigate(wxNavigationKeyEvent::IsForward);

break;

case WXK_LEFT:

Navigate(wxNavigationKeyEvent::IsBackward);

break;

case WXK_TAB:

if (evt.ShiftDown())

Navigate(wxNavigationKeyEvent::IsBackward);

else

Navigate(wxNavigationKeyEvent::IsForward);

break;

default:

evt.Skip();

break;

}

{

switch (evt.GetKeyCode())

{

case WXK_RETURN:

case WXK_NUMPAD_ENTER:

#if defined(__WXMSW__)

if (mHadKeyDown)

#endif

if (mStyle != MixerTrackCluster) // MixerTrackCluster style has no menu.

{

ShowMenu(wxPoint(mIconRect.x + 1, mIconRect.y + mIconRect.height + 1));

}

#if defined(__WXMSW__)

mHadKeyDown = false;

#endif

break;

default:

evt.Skip();

break;

}

{

mIsFocused = true;

Refresh(false);

{

mIsFocused = false;

Refresh(false);

{

if (mStyle != newStyle && mDesiredStyle == AutomaticStereo)

{

SetActiveStyle(newStyle);

mLayoutValid = false;

Refresh(false);

}

{

mT = 0;

mRate = sampleRate;

for (int j = 0; j < kMaxMeterBars; j++)

{

ResetBar(&mBar[j], resetClipping);

}

// wxTimers seem to be a little unreliable - sometimes they stop for

// no good reason, so this "primes" it every now and then...

mTimer.Stop();

// While it's stopped, empty the queue

mQueue.Clear();

mLayoutValid = false;

mTimer.Start(1000 / mMeterRefreshRate);

Refresh(false);

{

if (z > 1.0)

return 1.0;

else if (z < 0.0)

return 0.0;

else

return z;

{

double db;

if (v > 0)

db = LINEAR_TO_DB(fabs(v));

else

db = -999;

return ClipZeroToOne((db + range) / range);

{

float *sptr = sampleData;

auto num = std::min(numChannels, mNumBars);

MeterUpdateMsg msg;

memset(&msg, 0, sizeof(msg));

msg.numFrames = numFrames;

for(int i=0; i<numFrames; i++) {

for(unsigned int j=0; j<num; j++) {

msg.peak[j] = floatMax(msg.peak[j], fabs(sptr[j]));