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

#include <Equalization.h>

Inheritance diagram for EqualizationPanel:

[legend]

Collaboration diagram for EqualizationPanel:

[legend]

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 TranslatableString &name=XO("Panel"))

bool	Create (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL\|wxNO_BORDER, const TranslatableString &name=XO("Panel"))

void	SetLabel (const TranslatableString &label)

void	SetName (const TranslatableString &name)

void	SetToolTip (const TranslatableString &toolTip)

void	SetName ()

Public Member Functions inherited from wxTabTraversalWrapper< wxPanel >
	wxTabTraversalWrapper (Args &&... args)

	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete

	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete

wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete

wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

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 FrequencyPlotDialog and FilterPanel.

Definition at line 300 of file Equalization.h.

Constructor & Destructor Documentation

◆ EqualizationPanel()

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

Definition at line 3072 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::~EqualizationPanel ( )

Definition at line 3091 of file Equalization.cpp.

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

Member Function Documentation

◆ AcceptsFocus()

bool EqualizationPanel::AcceptsFocus ( ) const

inline

Definition at line 308 of file Equalization.h.

308 { return false; }

◆ AcceptsFocusFromKeyboard()

bool EqualizationPanel::AcceptsFocusFromKeyboard ( ) const

inline

Definition at line 310 of file Equalization.h.

310 { return false; }

◆ ForceRecalc()

void EqualizationPanel::ForceRecalc ( )

Definition at line 3097 of file Equalization.cpp.

 {
    mRecalcRequired = true;
    Refresh(false);
 }

References mRecalcRequired.

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

Here is the caller graph for this function:

◆ OnCaptureLost()

void EqualizationPanel::OnCaptureLost ( wxMouseCaptureLostEvent & event )

private

Definition at line 3328 of file Equalization.cpp.

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

◆ OnMouseEvent()

void EqualizationPanel::OnMouseEvent ( wxMouseEvent & event )

private

Definition at line 3301 of file Equalization.cpp.

 {
    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();
    }
 }

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

Here is the call graph for this function:

◆ OnPaint()

void EqualizationPanel::OnPaint ( wxPaintEvent & event )

private

Definition at line 3118 of file Equalization.cpp.

 {
    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,24);
    }
  
    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, wxPENSTYLE_SOLID));
    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, wxPENSTYLE_SOLID));
  
    // 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, wxPENSTYLE_SOLID));
    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 recurrence - 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 recurrence
             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->mDrawMode )
    {
       ZoomInfo zoomInfo( 0.0, mEnvRect.width-1 );
  
       // Back pointer to TrackPanel won't be needed in the one drawing
       // function we use here
       TrackArtist artist( nullptr );
  
       artist.pZoomInfo = &zoomInfo;
       TrackPanelDrawingContext context{ memDC, {}, {}, &artist  };
       EnvelopeEditor::DrawPoints( *mEffect->mEnvelope,
          context, mEnvRect, false, 0.0,
       mEffect->mdBMin, mEffect->mdBMax, false);
    }
  
    dc.Blit(0, 0, mWidth, mHeight, &memDC, 0, 0, wxCOPY, FALSE);
 }

Here is the call graph for this function:

◆ OnSize()

void EqualizationPanel::OnSize ( wxSizeEvent & event )

private

Definition at line 3112 of file Equalization.cpp.

 {
    Refresh( false );
 }

◆ Recalc()

void EqualizationPanel::Recalc ( )

private

Definition at line 3103 of file Equalization.cpp.

 {
    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());
 }

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

Referenced by OnPaint().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mBitmap

std::unique_ptr<wxBitmap> EqualizationPanel::mBitmap

private

Definition at line 335 of file Equalization.h.

Referenced by OnPaint().

◆ mEffect

EffectEqualization* EqualizationPanel::mEffect

private

Definition at line 330 of file Equalization.h.

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

◆ mEnvRect

wxRect EqualizationPanel::mEnvRect

private

Definition at line 336 of file Equalization.h.

Referenced by OnMouseEvent(), and OnPaint().

◆ mHeight

int EqualizationPanel::mHeight

private

Definition at line 338 of file Equalization.h.

Referenced by OnPaint().

◆ mLinEditor

std::unique_ptr<EnvelopeEditor> EqualizationPanel::mLinEditor

private

Definition at line 331 of file Equalization.h.

Referenced by OnMouseEvent().

◆ mLogEditor

std::unique_ptr<EnvelopeEditor> EqualizationPanel::mLogEditor

private

Definition at line 331 of file Equalization.h.

Referenced by OnMouseEvent().

◆ mOuti

Floats EqualizationPanel::mOuti

private

Definition at line 342 of file Equalization.h.

Referenced by Recalc().

◆ mOutr

Floats EqualizationPanel::mOutr

private

Definition at line 342 of file Equalization.h.

Referenced by OnPaint(), and Recalc().

◆ mParent

wxWindow* EqualizationPanel::mParent

private

Definition at line 329 of file Equalization.h.

◆ mRecalcRequired

bool EqualizationPanel::mRecalcRequired

private

Definition at line 333 of file Equalization.h.

Referenced by ForceRecalc(), and OnPaint().

◆ mWidth

int EqualizationPanel::mWidth

private

Definition at line 337 of file Equalization.h.

Referenced by OnPaint().

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EqualizationPanel()

◆ ~EqualizationPanel()

Member Function Documentation

◆ AcceptsFocus()

◆ AcceptsFocusFromKeyboard()

◆ ForceRecalc()

◆ OnCaptureLost()

◆ OnMouseEvent()

◆ OnPaint()

◆ OnSize()

◆ Recalc()

Member Data Documentation

◆ mBitmap

◆ mEffect

◆ mEnvRect

◆ mHeight

◆ mLinEditor

◆ mLogEditor

◆ mOuti

◆ mOutr

◆ mParent

◆ mRecalcRequired

◆ mWidth