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

// TnzTools includes

#include <tools tool.h=""></tools>

// TnzLib includes

#include <toonz tapplication.h=""></toonz>

#include <toonz txshlevelhandle.h=""></toonz>

#include <toonz txsheethandle.h=""></toonz>

#include <toonz txsheet.h=""></toonz>

#include <toonz tframehandle.h=""></toonz>

#include <toonz tobjecthandle.h=""></toonz>

#include <toonz dpiscale.h=""></toonz>

// TnzCore includes

#include <tgl.h></tgl.h>

#include <tmetaimage.h></tmetaimage.h>

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

//    TModifierAssistants::Modifier implementation

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

TModifierAssistants::Modifier::Modifier(TTrackHandler &handler):

  TTrackModifier(handler),

  initialized()

{ }

TTrackPoint

TModifierAssistants::Modifier::calcPoint(double originalIndex) {

  TTrackPoint p = TTrackModifier::calcPoint(originalIndex);

  return guidelines.empty() ? p : guidelines.front()->smoothTransformPoint(p);

}

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

//    TModifierAssistants implementation

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

TModifierAssistants::TModifierAssistants(bool drawOnly):

  drawOnly(drawOnly),

  sensitiveLength(50.0) { }

bool

TModifierAssistants::scanAssistants(

  const TPointD *positions,

  int positionsCount,

  TGuidelineList *outGuidelines,

  bool draw,

  bool enabledOnly ) const

{

  bool found = false;

  if (TInputManager *manager = getManager())

  if (TInputHandler *handler = manager->getHandler())

  if (TTool *tool = handler->inputGetTool())

  if (TToolViewer *viewer = tool->getViewer())

  if (TApplication *application = tool->getApplication())

  if (TXshLevelHandle *levelHandle = application->getCurrentLevel())

  if (TXshLevel *level = levelHandle->getLevel())

  if (TXshSimpleLevel *simpleLevel = level->getSimpleLevel())

  if (TFrameHandle *frameHandle = application->getCurrentFrame())

  if (TXsheetHandle *XsheetHandle = application->getCurrentXsheet())

  if (TXsheet *Xsheet = XsheetHandle->getXsheet())

  {

    TPointD dpiScale = getCurrentDpiScale(simpleLevel, tool->getCurrentFid());

    bool findGuidelines = (positions && positionsCount > 0 && outGuidelines);

    bool doSomething = findGuidelines || draw;

    int frame = frameHandle->getFrame();

    int count = Xsheet->getColumnCount();

    TAffine worldToTrack;

    worldToTrack.a11 /= dpiScale.x;

    worldToTrack.a22 /= dpiScale.y;

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

      if (TXshColumn *column = Xsheet->getColumn(i))

      if (column->isCamstandVisible())

      if (column->isPreviewVisible())

      if (TImageP image = Xsheet->getCell(frame, i).getImage(false))

      if (image->getType() == TImage::META)

      if (TMetaImage *metaImage = dynamic_cast<tmetaimage*>(image.getPointer()))</tmetaimage*>

      {

        TAffine imageToTrack = worldToTrack * tool->getColumnMatrix(i);

        if (draw) { glPushMatrix(); tglMultMatrix(imageToTrack); }

        TMetaImage::Reader reader(*metaImage);

        for(TMetaObjectListCW::iterator i = reader->begin(); i != reader->end(); ++i)

          if (*i)

          if (const TAssistant *assistant = (*i)->getHandler<tassistant>())</tassistant>

          if (!enabledOnly || assistant->getEnabled())

          {

            found = true;

            if (findGuidelines)

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

                assistant->getGuidelines(positions[i], imageToTrack, *outGuidelines);

            if (draw) assistant->draw(viewer, !drawOnly);

            if (!doSomething) return true;

          }

        if (draw) glPopMatrix();

      }

  }

  return found;

}

void

TModifierAssistants::modifyTrack(

  const TTrack &track,

  TTrackList &outTracks )

{

  if (!track.handler) {

    track.handler = new TTrackHandler(track);

    Modifier *modifier = new Modifier(*track.handler);

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

  }

  outTracks.push_back(track.handler->tracks.front());

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

  if (!track.changed())

    return;

  Modifier *modifier = dynamic_cast<modifier*>(subTrack.modifier.getPointer());</modifier*>

  if (!modifier)

    return;

  // remove points

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

  if (start < 0) start = 0;

  if (!drawOnly && start <= 0) {

    modifier->guidelines.clear();

    scanAssistants(&track[0].position, 1, &modifier->guidelines, false, true);

  }

  bool fixed = subTrack.fixedSize() || modifier->guidelines.size() <= 1;

  // select guideline

  if (!fixed)

  if (TInputManager *manager = getManager())

  if (TInputHandler *handler = manager->getHandler())

  if (TTool *tool = handler->inputGetTool())

  if (TToolViewer *viewer = tool->getViewer()) {

    TAffine trackToScreen = tool->getMatrix();

    if (tool->getToolType() & TTool::LevelTool)

      if (TObjectHandle *objHandle = TTool::getApplication()->getCurrentObject())

        if (!objHandle->isSpline())

          trackToScreen *= TScale(viewer->getDpiScale().x, viewer->getDpiScale().y);

    trackToScreen *= viewer->get3dViewMatrix().get2d();

    TGuidelineP guideline = TGuideline::findBest(modifier->guidelines, track, trackToScreen, fixed);

    if (guideline != modifier->guidelines.front())

      for(int i = 1; i < (int)modifier->guidelines.size(); ++i)

        if (modifier->guidelines[i] == guideline) {

          std::swap(modifier->guidelines[i], modifier->guidelines.front());

          start = 0;

          break;

        }

  }

  // add points

  subTrack.truncate(start);

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

    subTrack.push_back( modifier->calcPoint(i), false );

  // fix points

  if (fixed || track.fixedFinished())

    subTrack.fix_to(track.fixedSize());

  track.resetChanges();

}

TRectD

TModifierAssistants::calcDrawBounds(const TTrackList&, const THoverList&) {

  if (scanAssistants(NULL, 0, NULL, false, false))

    return TConsts::infiniteRectD;

  return TRectD();

}

void

TModifierAssistants::drawTrack(const TTrack &track) {

  if (!track.handler) return;

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

  if (Modifier *modifier = dynamic_cast<modifier*>(subTrack.modifier.getPointer())) {</modifier*>

    const TGuidelineList &guidelines = modifier->guidelines;

    if (!guidelines.empty()) {

      guidelines.front()->draw(true);

      for(TGuidelineList::const_iterator i = guidelines.begin() + 1; i != guidelines.end(); ++i)

        (*i)->draw();

    }

  }

}

void

TModifierAssistants::draw(const TTrackList &tracks, const THoverList &hovers) {

  THoverList allHovers;

  allHovers.reserve(hovers.size() + tracks.size());

  if (tracks.empty()) // hide hovers if track exists

    allHovers.insert(allHovers.end(), hovers.begin(), hovers.end());

  for(TTrackList::const_iterator i = tracks.begin(); i != tracks.end(); ++i)

    if ((*i)->handler && !(*i)->handler->tracks.empty() && !(*i)->handler->tracks.front()->empty())

      allHovers.push_back( (*i)->handler->tracks.front()->back().position );

  // draw assistants

  TGuidelineList guidelines;

  scanAssistants(

    allHovers.empty() ? NULL : &allHovers.front(),

    (int)allHovers.size(),

    &guidelines,

    true,

    false );

  // draw guidelines

  for(TGuidelineList::const_iterator i = guidelines.begin(); i != guidelines.end(); ++i)

    (*i)->draw(false, !drawOnly);

  // draw tracks

  TInputModifier::drawTracks(tracks);

}