#include <tools modifierclone.h="" modifiers=""></tools>

//*****************************************************************************************

//    TModifierClone::Interpolator implementation

//*****************************************************************************************

TTrackPoint TModifierClone::Interpolator::interpolateFromOriginal(double originalIndex)

  { return transform.apply( track.calcPointFromOriginal(originalIndex) ); }

TTrackPoint TModifierClone::Interpolator::interpolate(double index)

  { return interpolateFromOriginal(track.originalIndexByIndex(index)); }

//*****************************************************************************************

//    TModifierClone implementation

//*****************************************************************************************

TModifierClone::TModifierClone(bool keepOriginals, int skipFirst, int skipLast):

  keepOriginals(keepOriginals), skipFirst(skipFirst), skipLast(skipLast) { }

void TModifierClone::modifyTrack(const TTrack &track,

                                 TTrackList &outTracks)

{

  if (!track.handler) {

    Handler *handler = new Handler();

    track.handler = handler;

    if (keepOriginals) {

      handler->original = new TTrack(track);

      new TTrackIntrOrig(*handler->original);

    }

    for(TTrackTransformList::const_iterator i = transforms.begin(); i != transforms.end(); ++i) {

      handler->tracks.push_back(new TTrack(track));

      TTrack &subTrack = *handler->tracks.back();

      new Interpolator(subTrack, *i);

    }

  }

  Handler *handler = dynamic_cast<handler*>(track.handler.getPointer());</handler*>

  if (!handler)

    return;

  if (handler->original)

    outTracks.push_back(handler->original);

  outTracks.insert(outTracks.end(), handler->tracks.begin(), handler->tracks.end());

  if (!track.changed())

    return;

  int start = track.size() - track.pointsAdded;

  if (start < 0) start = 0;

  // process original

  if (handler->original) {

    TTrack &subTrack = *handler->original;

    subTrack.truncate(start);

    for (int i = start; i < track.size(); ++i)

      subTrack.push_back(subTrack.pointFromOriginal(i), false);

    subTrack.fix_to(track.fixedSize());

  }

  // process sub-tracks

  for(TTrackList::iterator i = handler->tracks.begin(); i != handler->tracks.end(); ++i) {

    TTrack &subTrack = **i;

    Interpolator *intr = dynamic_cast<interpolator*>(subTrack.getInterpolator().getPointer());</interpolator*>

    if (!intr)

      continue;

    subTrack.truncate(start);

    for (int i = start; i < track.size(); ++i)

      subTrack.push_back(intr->interpolateFromOriginal(i), false);

    subTrack.fix_to(track.fixedSize());

  }

  track.resetChanges();

}

void TModifierClone::modifyTracks(

  const TTrackList &tracks,

  TTrackList &outTracks )

{

  int cnt = (int)tracks.size();

  int i0 = skipFirst;

  int i1 = cnt - skipLast;

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

    if (i0 <= i && i < i1) modifyTrack(*tracks[i], outTracks);

      else TInputModifier::modifyTrack(*tracks[i], outTracks);

}