Move TimeTrack's upper and lower range into new BoundedEnvelope...

... confusingly, Envelope already carried its own limiting values, but those
in the TimeTrack were not guaranteed to be the same.

I'm just preserving behavior as I break file dependencies and won't try to fix
that confusion now.

src/Envelope.h

@@ -69,7 +69,7 @@ private:
 typedef std::vector<EnvPoint> EnvArray;
 struct TrackPanelDrawingContext;
 
-class Envelope final : public XMLTagHandler {
+class Envelope /* not final */ : public XMLTagHandler {
 public:
    // Envelope can define a piecewise linear function, or piecewise exponential.
    Envelope(bool exponential, double minValue, double maxValue, double defaultValue);
@@ -264,4 +264,29 @@ inline void EnvPoint::SetVal( Envelope *pEnvelope, double val )
    mVal = val;
 }
 
+/*
+PRL: This class gives access to all the important numerical data in a TimeTrack,
+without need for the entire TimeTrack.
+
+Confusingly, Envelope already carried its own limiting values, but those
+in the TimeTrack were not guaranteed to be the same.
+
+I'm just preserving behavior as I break file dependencies and won't try to fix
+that confusion now.
+*/
+class BoundedEnvelope final : public Envelope
+{
+public:
+   using Envelope::Envelope;
+
+   double GetRangeLower() const { return mRangeLower; }
+   double GetRangeUpper() const { return mRangeUpper; }
+
+   void SetRangeLower(double lower) { mRangeLower = lower; }
+   void SetRangeUpper(double upper) { mRangeUpper = upper; }
+
+private:
+   double mRangeLower{}, mRangeUpper{};
+};
+
 #endif

src/TimeTrack.cpp

@@ -58,11 +58,11 @@ TimeTrack::TimeTrack(const std::shared_ptr<DirManager> &projDirManager, const Zo
 {
    mHeight = 100;
 
-   mRangeLower = 0.9;
-   mRangeUpper = 1.1;
+   SetRangeLower( 0.9 );
+   SetRangeUpper( 1.1 );
    mDisplayLog = false;
 
-   mEnvelope = std::make_unique<Envelope>(true, TIMETRACK_MIN, TIMETRACK_MAX, 1.0);
+   mEnvelope = std::make_unique<BoundedEnvelope>(true, TIMETRACK_MIN, TIMETRACK_MAX, 1.0);
    mEnvelope->SetTrackLen(DBL_MAX);
    mEnvelope->SetOffset(0);
 
@@ -84,10 +84,10 @@ TimeTrack::TimeTrack(const TimeTrack &orig, double *pT0, double *pT1)
    auto len = DBL_MAX;
    if (pT0 && pT1) {
       len = *pT1 - *pT0;
-      mEnvelope = std::make_unique<Envelope>( *orig.mEnvelope, *pT0, *pT1 );
+      mEnvelope = std::make_unique<BoundedEnvelope>( *orig.mEnvelope, *pT0, *pT1 );
    }
    else
-      mEnvelope = std::make_unique<Envelope>( *orig.mEnvelope );
+      mEnvelope = std::make_unique<BoundedEnvelope>( *orig.mEnvelope );
    mEnvelope->SetTrackLen( len );
    mEnvelope->SetOffset(0);
 
@@ -113,6 +113,26 @@ TimeTrack::~TimeTrack()
 {
 }
 
+double TimeTrack::GetRangeLower() const
+{
+   return mEnvelope->GetRangeLower();
+}
+
+double TimeTrack::GetRangeUpper() const
+{
+   return mEnvelope->GetRangeUpper();
+}
+
+void TimeTrack::SetRangeLower(double lower)
+{
+   mEnvelope->SetRangeLower( lower );
+}
+
+void TimeTrack::SetRangeUpper(double upper)
+{
+   mEnvelope->SetRangeUpper( upper );
+}
+
 Track::Holder TimeTrack::Cut( double t0, double t1 )
 {
    auto result = Copy( t0, t1, false );
@@ -207,12 +227,12 @@ bool TimeTrack::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
             mMinimized = (nValue != 0);
          else if (!wxStrcmp(attr, wxT("rangelower")))
          {
-            mRangeLower = Internat::CompatibleToDouble(value);
+            SetRangeLower( Internat::CompatibleToDouble(value) );
             mRescaleXMLValues = false;
          }
          else if (!wxStrcmp(attr, wxT("rangeupper")))
          {
-            mRangeUpper = Internat::CompatibleToDouble(value);
+            SetRangeUpper( Internat::CompatibleToDouble(value) );
             mRescaleXMLValues = false;
          }
          else if (!wxStrcmp(attr, wxT("displaylog")) &&
@@ -242,7 +262,7 @@ void TimeTrack::HandleXMLEndTag(const wxChar * WXUNUSED(tag))
    if(mRescaleXMLValues)
    {
       mRescaleXMLValues = false;
-      mEnvelope->RescaleValues(mRangeLower, mRangeUpper);
+      mEnvelope->RescaleValues(GetRangeLower(), GetRangeUpper());
       mEnvelope->SetRange(TIMETRACK_MIN, TIMETRACK_MAX);
    }
 }
@@ -265,8 +285,8 @@ void TimeTrack::WriteXML(XMLWriter &xmlFile) const
    //xmlFile.WriteAttr(wxT("offset"), mOffset, 8);
    xmlFile.WriteAttr(wxT("height"), GetActualHeight());
    xmlFile.WriteAttr(wxT("minimized"), GetMinimized());
-   xmlFile.WriteAttr(wxT("rangelower"), mRangeLower, 12);
-   xmlFile.WriteAttr(wxT("rangeupper"), mRangeUpper, 12);
+   xmlFile.WriteAttr(wxT("rangelower"), GetRangeLower(), 12);
+   xmlFile.WriteAttr(wxT("rangeupper"), GetRangeUpper(), 12);
    xmlFile.WriteAttr(wxT("displaylog"), GetDisplayLog());
    xmlFile.WriteAttr(wxT("interpolatelog"), GetInterpolateLog());
 
@@ -324,14 +344,15 @@ void TimeTrack::Draw
    wxPen &pen = highlight ? AColor::uglyPen : AColor::envelopePen;
    dc.SetPen( pen );
 
-   double logLower = log(std::max(1.0e-7, mRangeLower)), logUpper = log(std::max(1.0e-7, mRangeUpper));
+   double logLower = log(std::max(1.0e-7, GetRangeLower())),
+      logUpper = log(std::max(1.0e-7, GetRangeUpper()));
    for (int x = 0; x < mid.width; x++)
       {
          double y;
          if(mDisplayLog)
             y = (double)mid.height * (logUpper - log(envValues[x])) / (logUpper - logLower);
          else
-            y = (double)mid.height * (mRangeUpper - envValues[x]) / (mRangeUpper - mRangeLower);
+            y = (double)mid.height * (GetRangeUpper() - envValues[x]) / (GetRangeUpper() - GetRangeLower());
          int thisy = r.y + (int)y;
          AColor::Line(dc, mid.x + x, thisy - 1, mid.x + x, thisy+2);
       }

src/TimeTrack.h

@@ -16,7 +16,7 @@
 #include <algorithm>
 
 class wxRect;
-class Envelope;
+class BoundedEnvelope;
 class Ruler;
 class ZoomInfo;
 struct TrackPanelDrawingContext;
@@ -80,8 +80,8 @@ class TimeTrack final : public Track {
 
    // Access the track's speed envelope
 
-   Envelope *GetEnvelope() { return mEnvelope.get(); }
-   const Envelope *GetEnvelope() const { return mEnvelope.get(); }
+   BoundedEnvelope *GetEnvelope() { return mEnvelope.get(); }
+   const BoundedEnvelope *GetEnvelope() const { return mEnvelope.get(); }
 
    //Note: The meaning of this function has changed (December 2012)
    //Previously this function did something that was close to the opposite (but not entirely accurate).
@@ -117,11 +117,11 @@ class TimeTrack final : public Track {
 
    // Get/Set the speed-warping range, as percentage of original speed (e.g. 90%-110%)
 
-   double GetRangeLower() const { return mRangeLower; }
-   double GetRangeUpper() const { return mRangeUpper; }
+   double GetRangeLower() const;
+   double GetRangeUpper() const;
 
-   void SetRangeLower(double lower) { mRangeLower = lower; }
-   void SetRangeUpper(double upper) { mRangeUpper = upper; }
+   void SetRangeLower(double lower);
+   void SetRangeUpper(double upper);
 
    bool GetDisplayLog() const { return mDisplayLog; }
    void SetDisplayLog(bool displayLog) { mDisplayLog = displayLog; }
@@ -135,10 +135,8 @@ class TimeTrack final : public Track {
    TrackKind GetKind() const override { return TrackKind::Time; }
 
    const ZoomInfo  *const mZoomInfo;
-   std::unique_ptr<Envelope> mEnvelope;
+   std::unique_ptr<BoundedEnvelope> mEnvelope;
    std::unique_ptr<Ruler> mRuler;
-   double           mRangeLower;
-   double           mRangeUpper;
    bool             mDisplayLog;
    bool             mRescaleXMLValues; // needed for backward-compatibility with older project files