EqualizationPanel Class Reference

EqualizationPanel is used with EqualizationDialog and controls a graph for EffectEqualization. We should look at amalgamating the various graphing code, such as provided by FreqWindow and FilterPanel. More...

#include <Equalization.h>

Inheritance diagram for EqualizationPanel:

Public Member Functions
	EqualizationPanel (wxWindow *parent, wxWindowID winid, EffectEqualization *effect)
	~EqualizationPanel ()
bool	AcceptsFocus () const
bool	AcceptsFocusFromKeyboard () const
void	ForceRecalc ()
Public Member Functions inherited from wxPanelWrapper
	wxPanelWrapper ()
	wxPanelWrapper (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const wxString &name=_("Panel"))
bool	Create (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const wxString &name=_("Panel"))
Public Member Functions inherited from wxTabTraversalWrapper< wxPanel >
	wxTabTraversalWrapper (Args &&...args)

Private Member Functions
void	Recalc ()
void	OnMouseEvent (wxMouseEvent &event)
void	OnCaptureLost (wxMouseCaptureLostEvent &event)
void	OnPaint (wxPaintEvent &event)
void	OnSize (wxSizeEvent &event)

Private Attributes
wxWindow *	mParent
EffectEqualization *	mEffect
std::unique_ptr< EnvelopeEditor >	mLinEditor
std::unique_ptr< EnvelopeEditor >	mLogEditor
bool	mRecalcRequired
std::unique_ptr< wxBitmap >	mBitmap
wxRect	mEnvRect
int	mWidth
int	mHeight
Floats	mOutr
Floats	mOuti

Detailed Description

EqualizationPanel is used with EqualizationDialog and controls a graph for EffectEqualization. We should look at amalgamating the various graphing code, such as provided by FreqWindow and FilterPanel.

Definition at line 283 of file Equalization.h.

Constructor & Destructor Documentation

EqualizationPanel::EqualizationPanel	(	wxWindow *	parent,
		wxWindowID	winid,
		EffectEqualization *	effect
	)

Definition at line 2840 of file Equalization.cpp.

:  wxPanelWrapper(parent, winid)
{
   mParent = parent;
   mEffect = effect;

   mBitmap = NULL;
   mWidth = 0;
   mHeight = 0;

   mLinEditor = std::make_unique<EnvelopeEditor>(*mEffect->mLinEnvelope, false);
   mLogEditor = std::make_unique<EnvelopeEditor>(*mEffect->mLogEnvelope, false);
   mEffect->mEnvelope->Flatten(0.);
   mEffect->mEnvelope->SetTrackLen(1.0);

   ForceRecalc();
}

EqualizationPanel::~EqualizationPanel

(

)

Definition at line 2859 of file Equalization.cpp.

{
   if(HasCapture())
      ReleaseMouse();
}

Member Function Documentation

bool EqualizationPanel::AcceptsFocus ( ) const

inline

Definition at line 291 of file Equalization.h.

{ return false; }

bool EqualizationPanel::AcceptsFocusFromKeyboard ( ) const

inline

Definition at line 293 of file Equalization.h.

{ return false; }

void EqualizationPanel::ForceRecalc

(

)

Definition at line 2865 of file Equalization.cpp.

References mRecalcRequired.

Referenced by EffectEqualization::ForceRecalc(), and OnMouseEvent().

{
   mRecalcRequired = true;
   Refresh(false);
}

void EqualizationPanel::OnCaptureLost ( wxMouseCaptureLostEvent &  event )

private

Definition at line 3089 of file Equalization.cpp.

{
   if (HasCapture())
   {
      ReleaseMouse();
   }
}

void EqualizationPanel::OnMouseEvent ( wxMouseEvent &  event )

private

Definition at line 3062 of file Equalization.cpp.

References EffectEqualization::EnvelopeUpdated(), ForceRecalc(), EffectEqualization::mdBMax, EffectEqualization::mdBMin, EffectEqualization::mDrawMode, mEffect, mEnvRect, EffectEqualization::mLin, mLinEditor, and mLogEditor.

{
   if (!mEffect->mDrawMode)
   {
      return;
   }

   if (event.ButtonDown() && !HasCapture())
   {
      CaptureMouse();
   }

   auto &pEditor = (mEffect->mLin ? mLinEditor : mLogEditor);
   if (pEditor->MouseEvent(event, mEnvRect, ZoomInfo(0.0, mEnvRect.width),
      false, 0.0,
      mEffect->mdBMin, mEffect->mdBMax))
   {
      mEffect->EnvelopeUpdated();
      ForceRecalc();
   }

   if (event.ButtonUp() && HasCapture())
   {
      ReleaseMouse();
   }
}

void EqualizationPanel::OnPaint ( wxPaintEvent &  event )

private

Definition at line 2886 of file Equalization.cpp.

References ThemeBase::Colour(), Ruler::DrawGrid(), Envelope::DrawPoints(), Envelope::GetValues(), EffectEqualization::IsLinear(), AColor::Line(), LINEAR_TO_DB, lrint, M_PI, mBitmap, EffectEqualization::mdBMax, EffectEqualization::mdBMin, EffectEqualization::mdBRuler, EffectEqualization::mDraw, EffectEqualization::mDrawGrid, mEffect, EffectEqualization::mEnvelope, mEnvRect, EffectEqualization::mFilterFuncI, EffectEqualization::mFilterFuncR, EffectEqualization::mFreqRuler, mHeight, EffectEqualization::mHiFreq, EffectEqualization::mLoFreq, EffectEqualization::mM, mOutr, mRecalcRequired, mWidth, EffectEqualization::mWindowSize, PANELBORDER, Recalc(), RulerPanel::ruler, and theTheme.

{
   wxPaintDC dc(this);
   if(mRecalcRequired) {
      Recalc();
      mRecalcRequired = false;
   }
   int width, height;
   GetSize(&width, &height);

   if (!mBitmap || mWidth!=width || mHeight!=height)
   {
      mWidth = width;
      mHeight = height;
      mBitmap = std::make_unique<wxBitmap>(mWidth, mHeight);
   }

   wxBrush bkgndBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));

   wxMemoryDC memDC;
   memDC.SelectObject(*mBitmap);

   wxRect bkgndRect;
   bkgndRect.x = 0;
   bkgndRect.y = 0;
   bkgndRect.width = mWidth;
   bkgndRect.height = mHeight;
   memDC.SetBrush(bkgndBrush);
   memDC.SetPen(*wxTRANSPARENT_PEN);
   memDC.DrawRectangle(bkgndRect);

   bkgndRect.y = mHeight;
   memDC.DrawRectangle(bkgndRect);

   wxRect border;
   border.x = 0;
   border.y = 0;
   border.width = mWidth;
   border.height = mHeight;

   memDC.SetBrush(*wxWHITE_BRUSH);
   memDC.SetPen(*wxBLACK_PEN);
   memDC.DrawRectangle(border);

   mEnvRect = border;
   mEnvRect.Deflate(PANELBORDER, PANELBORDER);

   // Pure blue x-axis line
   memDC.SetPen(wxPen(theTheme.Colour( clrGraphLines ), 1, wxSOLID));
   int center = (int) (mEnvRect.height * mEffect->mdBMax/(mEffect->mdBMax-mEffect->mdBMin) + .5);
   AColor::Line(memDC,
      mEnvRect.GetLeft(), mEnvRect.y + center,
      mEnvRect.GetRight(), mEnvRect.y + center);

   // Draw the grid, if asked for.  Do it now so it's underneath the main plots.
   if( mEffect->mDrawGrid )
   {
      mEffect->mFreqRuler->ruler.DrawGrid(memDC, mEnvRect.height, true, true, PANELBORDER, PANELBORDER);
      mEffect->mdBRuler->ruler.DrawGrid(memDC, mEnvRect.width, true, true, PANELBORDER, PANELBORDER);
   }

   // Med-blue envelope line
   memDC.SetPen(wxPen(theTheme.Colour(clrGraphLines), 3, wxSOLID));

   // Draw envelope
   int x, y, xlast = 0, ylast = 0;
   {
      Doubles values{ size_t(mEnvRect.width) };
      mEffect->mEnvelope->GetValues(values.get(), mEnvRect.width, 0.0, 1.0 / mEnvRect.width);
      bool off = false, off1 = false;
      for (int i = 0; i < mEnvRect.width; i++)
      {
         x = mEnvRect.x + i;
         y = lrint(mEnvRect.height*((mEffect->mdBMax - values[i]) / (mEffect->mdBMax - mEffect->mdBMin)) + .25); //needs more optimising, along with'what you get'?
         if (y >= mEnvRect.height)
         {
            y = mEnvRect.height - 1;
            off = true;
         }
         else
         {
            off = false;
            off1 = false;
         }
         if ((i != 0) & (!off1))
         {
            AColor::Line(memDC, xlast, ylast,
               x, mEnvRect.y + y);
         }
         off1 = off;
         xlast = x;
         ylast = mEnvRect.y + y;
      }
   }

   //Now draw the actual response that you will get.
   //mFilterFunc has a linear scale, window has a log one so we have to fiddle about
   memDC.SetPen(wxPen(theTheme.Colour( clrResponseLines ), 1, wxSOLID));
   double scale = (double)mEnvRect.height/(mEffect->mdBMax-mEffect->mdBMin);   //pixels per dB
   double yF;   //gain at this freq
   double delta = mEffect->mHiFreq / (((double)mEffect->mWindowSize / 2.));   //size of each freq bin

   bool lin = mEffect->IsLinear();   // log or lin scale?

   double loLog = log10(mEffect->mLoFreq);
   double step = lin ? mEffect->mHiFreq : (log10(mEffect->mHiFreq) - loLog);
   step /= ((double)mEnvRect.width-1.);
   double freq;   //actual freq corresponding to x position
   int halfM = (mEffect->mM - 1) / 2;
   int n;   //index to mFreqFunc
   for(int i=0; i<mEnvRect.width; i++)
   {
      x = mEnvRect.x + i;
      freq = lin ? step*i : pow(10., loLog + i*step);   //Hz
      if( ( lin ? step : (pow(10., loLog + (i+1)*step)-freq) ) < delta)
      {   //not enough resolution in FFT
         // set up for calculating cos using recurrance - faster than calculating it directly each time
         double theta = M_PI*freq/mEffect->mHiFreq;   //radians, normalized
         double wtemp = sin(0.5 * theta);
         double wpr = -2.0 * wtemp * wtemp;
         double wpi = -1.0 * sin(theta);
         double wr = cos(theta*halfM);
         double wi = sin(theta*halfM);

         yF = 0.;
         for(int j=0;j<halfM;j++)
         {
            yF += 2. * mOutr[j] * wr;  // This works for me, compared to the previous version.  Compare wr to cos(theta*(halfM-j)).  Works for me.  Keep everything as doubles though.
            // do recurrance
            wr = (wtemp = wr) * wpr - wi * wpi + wr;
            wi = wi * wpr + wtemp * wpi + wi;
         }
         yF += mOutr[halfM];
         yF = fabs(yF);
         if(yF!=0.)
            yF = LINEAR_TO_DB(yF);
         else
            yF = mEffect->mdBMin;
      }
      else
      {   //use FFT, it has enough resolution
         n = (int)(freq/delta + .5);
         if(pow(mEffect->mFilterFuncR[n],2)+pow(mEffect->mFilterFuncI[n],2)!=0.)
            yF = 10.0*log10(pow(mEffect->mFilterFuncR[n],2)+pow(mEffect->mFilterFuncI[n],2));   //10 here, a power
         else
            yF = mEffect->mdBMin;
      }
      if(yF < mEffect->mdBMin)
         yF = mEffect->mdBMin;
      yF = center-scale*yF;
      if(yF>mEnvRect.height)
         yF = mEnvRect.height - 1;
      if(yF<0.)
         yF=0.;
      y = (int)(yF+.5);

      if (i != 0)
      {
         AColor::Line(memDC, xlast, ylast, x, mEnvRect.y + y);
      }
      xlast = x;
      ylast = mEnvRect.y + y;
   }

   memDC.SetPen(*wxBLACK_PEN);
   if( mEffect->mDraw->GetValue() )
   {
      TrackPanelDrawingContext context{ memDC, {}, {} };
      mEffect->mEnvelope->DrawPoints(
         context, mEnvRect, ZoomInfo(0.0, mEnvRect.width-1), false, 0.0,
      mEffect->mdBMin, mEffect->mdBMax, false);
   }

   dc.Blit(0, 0, mWidth, mHeight, &memDC, 0, 0, wxCOPY, FALSE);
}

void EqualizationPanel::OnSize ( wxSizeEvent &  event )

private

Definition at line 2880 of file Equalization.cpp.

{
   Refresh( false );
}

void EqualizationPanel::Recalc ( )

private

Definition at line 2871 of file Equalization.cpp.

References EffectEqualization::CalcFilter(), InverseRealFFT(), mEffect, EffectEqualization::mFilterFuncI, EffectEqualization::mFilterFuncR, mOuti, mOutr, and EffectEqualization::mWindowSize.

Referenced by OnPaint().

{
   mOutr = Floats{ mEffect->mWindowSize };
   mOuti = Floats{ mEffect->mWindowSize };

   mEffect->CalcFilter();   //to calculate the actual response
   InverseRealFFT(mEffect->mWindowSize, mEffect->mFilterFuncR.get(), mEffect->mFilterFuncI.get(), mOutr.get());
}

Member Data Documentation

std::unique_ptr<wxBitmap> EqualizationPanel::mBitmap

private

Definition at line 318 of file Equalization.h.

Referenced by OnPaint().

EffectEqualization* EqualizationPanel::mEffect

private

Definition at line 313 of file Equalization.h.

Referenced by OnMouseEvent(), OnPaint(), and Recalc().

wxRect EqualizationPanel::mEnvRect

private

Definition at line 319 of file Equalization.h.

Referenced by OnMouseEvent(), and OnPaint().

int EqualizationPanel::mHeight

private

Definition at line 321 of file Equalization.h.

Referenced by OnPaint().

std::unique_ptr<EnvelopeEditor> EqualizationPanel::mLinEditor

private

Definition at line 314 of file Equalization.h.

Referenced by OnMouseEvent().

std::unique_ptr<EnvelopeEditor> EqualizationPanel::mLogEditor

private

Definition at line 314 of file Equalization.h.

Referenced by OnMouseEvent().

Floats EqualizationPanel::mOuti

private

Definition at line 325 of file Equalization.h.

Referenced by Recalc().

Floats EqualizationPanel::mOutr

private

Definition at line 325 of file Equalization.h.

Referenced by OnPaint(), and Recalc().

wxWindow* EqualizationPanel::mParent

private

Definition at line 312 of file Equalization.h.

bool EqualizationPanel::mRecalcRequired

private

Definition at line 316 of file Equalization.h.

Referenced by ForceRecalc(), and OnPaint().

int EqualizationPanel::mWidth

private

Definition at line 320 of file Equalization.h.

Referenced by OnPaint().

---

The documentation for this class was generated from the following files:

• Equalization.h
• Equalization.cpp