katetextfolding.cpp

Go to the documentation of this file.

/*  This file is part of the Kate project.
 *
 *  Copyright (C) 2013 Christoph Cullmann <cullmann@kde.org>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 */

#include "katetextfolding.h"
#include "katetextbuffer.h"
#include "katetextrange.h"

namespace Kate {
  
TextFolding::FoldingRange::FoldingRange (TextBuffer &buffer, const KTextEditor::Range &range, FoldingRangeFlags _flags)
  : start (new TextCursor (buffer, range.start(), KTextEditor::MovingCursor::MoveOnInsert))
  , end (new TextCursor (buffer, range.end(), KTextEditor::MovingCursor::MoveOnInsert))
  , parent (0)
  , flags (_flags)
  , id (-1)
{
}
  
TextFolding::FoldingRange::~FoldingRange ()
{
  delete start;
  delete end;
  qDeleteAll (nestedRanges);
}
  
TextFolding::TextFolding (TextBuffer &buffer)
  : QObject ()
  , m_buffer (buffer)
  , m_idCounter (-1)
{
  connect (&m_buffer, SIGNAL(cleared()), SLOT(clear()));
}

TextFolding::~TextFolding ()
{
  qDeleteAll (m_foldingRanges);
}

void TextFolding::clear ()
{
  m_idCounter = -1;
  
  if (m_foldingRanges.isEmpty()) {
    Q_ASSERT (m_idToFoldingRange.isEmpty());
    Q_ASSERT (m_foldedFoldingRanges.isEmpty());
    return;
  }
  
  m_idToFoldingRange.clear();
  m_foldedFoldingRanges.clear();
  qDeleteAll (m_foldingRanges);
  m_foldingRanges.clear ();
  
  emit foldingRangesChanged ();
}

qint64 TextFolding::newFoldingRange (const KTextEditor::Range &range, FoldingRangeFlags flags)
{
  if (!range.isValid() || range.isEmpty())
    return -1;
  
  FoldingRange *newRange = new FoldingRange (m_buffer, range, flags);
  
  if (    !newRange->start->isValid()
       || !newRange->end->isValid()
       || !insertNewFoldingRange (0 /* no parent here */, m_foldingRanges, newRange)) {
    delete newRange;
    return -1;
  }

  newRange->id = ++m_idCounter;
  if (newRange->id < 0)
    newRange->id = m_idCounter = 0;
  
  m_idToFoldingRange.insert (newRange->id, newRange);
  
  bool updated = updateFoldedRangesForNewRange (newRange);
  
  if (!updated)
    emit foldingRangesChanged ();
  
  return newRange->id;
}

KTextEditor::Range TextFolding::foldingRange(qint64 id) const
{
  FoldingRange* range = m_idToFoldingRange.value (id);
  if (!range)
    return KTextEditor::Range::invalid();

  return KTextEditor::Range(range->start->toCursor(), range->end->toCursor());
}

bool TextFolding::foldRange (qint64 id)
{
  FoldingRange *range = m_idToFoldingRange.value (id);
  if (!range)
    return false;
  
  if (range->flags & Folded)
    return true;
  
  range->flags |= Folded;
  updateFoldedRangesForNewRange (range);
  return true;
}
                      
bool TextFolding::unfoldRange (qint64 id, bool remove)
{
  FoldingRange *range = m_idToFoldingRange.value (id);
  if (!range)
    return false;
  
  if (!remove && !(range->flags & Folded))
    return true;
  
  const bool deleteRange = remove || !(range->flags & Persistent);
  
  if (deleteRange) {
    m_idToFoldingRange.remove (id);
    
    FoldingRange::Vector &parentVector = range->parent ? range->parent->nestedRanges : m_foldingRanges;
    FoldingRange::Vector newParentVector;
    Q_FOREACH (FoldingRange *curRange, parentVector) {
      if (curRange == range) {
        Q_FOREACH (FoldingRange *newRange, range->nestedRanges) {
          newRange->parent = range->parent;
          newParentVector.push_back (newRange);
        }
      
        continue;
      }
      
      newParentVector.push_back (curRange);
    }
    parentVector = newParentVector;
  }
  
  bool updated = false;
  if (range->flags & Folded) {
    range->flags &= ~Folded;
    updated = updateFoldedRangesForRemovedRange (range);
  }
  
  if (!updated)
    emit foldingRangesChanged ();
  
  if (deleteRange) {
    range->nestedRanges.clear ();
    delete range;
  }
  
  return true;
}
    
bool TextFolding::isLineVisible (int line, qint64 *foldedRangeId) const
{
  if (m_foldedFoldingRanges.isEmpty())
    return true;
  
  FoldingRange::Vector::const_iterator upperBound = qUpperBound (m_foldedFoldingRanges.begin(), m_foldedFoldingRanges.end(), line, compareRangeByStartWithLine);
  if (upperBound != m_foldedFoldingRanges.begin())
    --upperBound;
  
  const bool hidden = (((*upperBound)->end->line() >= line) && (line > (*upperBound)->start->line()));
  
  if (foldedRangeId)
    (*foldedRangeId) = hidden ? (*upperBound)->id : -1;
  
  return !hidden;
}

void TextFolding::ensureLineIsVisible (int line)
{
  if (m_foldedFoldingRanges.isEmpty())
    return;
  
  qint64 foldedRangeId = -1;
  while (!isLineVisible (line, &foldedRangeId)) {
    Q_ASSERT (foldedRangeId >= 0);
    
    const bool unfolded = unfoldRange (foldedRangeId);
    (void) unfolded;
    Q_ASSERT (unfolded);
  }
}

int TextFolding::visibleLines () const
{
  int visibleLines = m_buffer.lines();
  
  if (m_foldedFoldingRanges.isEmpty())
    return visibleLines;
  
  Q_FOREACH (FoldingRange *range, m_foldedFoldingRanges)
    visibleLines -= (range->end->line() - range->start->line());
    
  Q_ASSERT (visibleLines > 0);
  return visibleLines;
}

int TextFolding::lineToVisibleLine (int line) const
{
  Q_ASSERT (line >= 0);
  
  int visibleLine = line;
  
  if (m_foldedFoldingRanges.isEmpty() || (line == 0))
    return visibleLine;
  
  int seenVisibleLines = 0;
  int lastLine = 0;
  Q_FOREACH (FoldingRange *range, m_foldedFoldingRanges) {
    if (range->start->line() >= line)
      break;
    
    seenVisibleLines += (range->start->line() - lastLine);
    lastLine = range->end->line();
    
    if (line <= range->end->line())
      return seenVisibleLines;
    
    visibleLine -= (range->end->line() - range->start->line());
  }
  
  Q_ASSERT (visibleLine >= 0);
  return visibleLine;
}
    
int TextFolding::visibleLineToLine (int visibleLine) const
{
  Q_ASSERT (visibleLine >= 0);
  
  int line = visibleLine;
  
  if (m_foldedFoldingRanges.isEmpty() || (visibleLine == 0))
    return line;
  
  int seenVisibleLines = 0;
  int lastLine = 0;
  int lastLineVisibleLines = 0;
  Q_FOREACH (FoldingRange *range, m_foldedFoldingRanges) {
    lastLineVisibleLines = seenVisibleLines;
    seenVisibleLines += (range->start->line() - lastLine);
    
    if (seenVisibleLines >= visibleLine)
      break;
    
    lastLine = range->end->line();
  }
  
  if (seenVisibleLines < visibleLine)
    lastLineVisibleLines = seenVisibleLines;
  
  line = (lastLine + (visibleLine - lastLineVisibleLines));
  Q_ASSERT (line >= 0);
  return line;
}

QVector<QPair<qint64, TextFolding::FoldingRangeFlags> > TextFolding::foldingRangesStartingOnLine (int line) const
{
  QVector<QPair<qint64, TextFolding::FoldingRangeFlags> > results;
  
  foldingRangesStartingOnLine (results, m_foldingRanges, line);
  
  return results;
}

void TextFolding::foldingRangesStartingOnLine (QVector<QPair<qint64, FoldingRangeFlags> > &results, const TextFolding::FoldingRange::Vector &ranges, int line) const
{
  if (ranges.isEmpty())
    return;
  
  FoldingRange::Vector::const_iterator lowerBound = qLowerBound (ranges.begin(), ranges.end(), line, compareRangeByLineWithStart);
  
  FoldingRange::Vector::const_iterator upperBound = qUpperBound (ranges.begin(), ranges.end(), line, compareRangeByStartWithLine);

  if ((lowerBound != ranges.begin()) && ((*(lowerBound-1))->end->line() >= line))
    --lowerBound;
  
  for (FoldingRange::Vector::const_iterator it = lowerBound; it != upperBound; ++it) {
    if ((*it)->start->line() == line)
      results.push_back (qMakePair((*it)->id, (*it)->flags));
    
    foldingRangesStartingOnLine (results, (*it)->nestedRanges, line);
  }
}

QString TextFolding::debugDump () const
{
  return QString ("tree %1 - folded %2").arg (debugDump (m_foldingRanges, true)).arg(debugDump (m_foldedFoldingRanges, false));
}

void TextFolding::debugPrint (const QString &title) const
{
  // print title + content
  printf ("%s\n    %s\n", qPrintable (title), qPrintable(debugDump()));
}

QString TextFolding::debugDump (const TextFolding::FoldingRange::Vector &ranges, bool recurse)
{
  QString dump;
  Q_FOREACH (FoldingRange *range, ranges) {
    if (!dump.isEmpty())
      dump += " ";
    
    dump += QString ("[%1:%2 %3%4 ").arg (range->start->line()).arg(range->start->column()).arg((range->flags & Persistent) ? "p" : "").arg((range->flags & Folded) ? "f" : "");
    
    if (recurse) {
      QString inner = debugDump (range->nestedRanges, recurse);
      if (!inner.isEmpty())
        dump += inner + " ";
    }
    
    dump += QString ("%1:%2]").arg (range->end->line()).arg(range->end->column());
  }
  return dump;
}

bool TextFolding::insertNewFoldingRange (FoldingRange *parent, FoldingRange::Vector &existingRanges, FoldingRange *newRange)
{
  FoldingRange::Vector::iterator lowerBound = qLowerBound (existingRanges.begin(), existingRanges.end(), newRange, compareRangeByStart);
  
  FoldingRange::Vector::iterator upperBound = qUpperBound (existingRanges.begin(), existingRanges.end(), newRange, compareRangeByEnd);

  if ((lowerBound != existingRanges.begin()) && ((*(lowerBound-1))->end->toCursor() > newRange->start->toCursor()))
    --lowerBound;
  
  if (lowerBound == upperBound) {
    if ((lowerBound == existingRanges.end()) || (newRange->start->toCursor() >= (*lowerBound)->end->toCursor()) || (newRange->end->toCursor() <= (*lowerBound)->start->toCursor())) {
      existingRanges.insert (lowerBound, newRange);
      newRange->parent = parent;
      
      return true;
    }
    
    if ((newRange->start->toCursor() >= (*lowerBound)->start->toCursor()) && (newRange->end->toCursor() <= (*lowerBound)->end->toCursor()))
      return insertNewFoldingRange ((*lowerBound), (*lowerBound)->nestedRanges, newRange);
    
  }
  
  FoldingRange::Vector::iterator it = lowerBound;
  bool includeUpperBound = false;
  FoldingRange::Vector nestedRanges;
  while (it != existingRanges.end()) {
    if (it == upperBound) {
      if (newRange->end->toCursor() <= (*upperBound)->start->toCursor())
        break;
      else
        includeUpperBound = true;
    }
    
    if (!((newRange->start->toCursor() <= (*it)->start->toCursor()) && (newRange->end->toCursor() >= (*it)->end->toCursor())))
      return false;
    
    nestedRanges.push_back ((*it));
      
    if (it == upperBound)
      break;
    
    ++it;
  }
  
  it = existingRanges.erase (lowerBound, includeUpperBound ? (upperBound+1) : upperBound);
  existingRanges.insert (it, newRange);
  newRange->nestedRanges = nestedRanges;
  
  newRange->parent = parent;
  Q_FOREACH (FoldingRange *range, newRange->nestedRanges)
    range->parent = newRange;
  
  return true;
}

bool TextFolding::compareRangeByStart (FoldingRange *a, FoldingRange *b)
{
  return a->start->toCursor() < b->start->toCursor();
}

bool TextFolding::compareRangeByEnd (FoldingRange *a, FoldingRange *b)
{
  return a->end->toCursor() < b->end->toCursor();
}

bool TextFolding::compareRangeByStartWithLine (int line, FoldingRange *range)
{
  return (line < range->start->line());
}

bool TextFolding::compareRangeByLineWithStart (FoldingRange *range, int line)
{
  return (range->start->line() < line);
}

bool TextFolding::updateFoldedRangesForNewRange (TextFolding::FoldingRange *newRange)
{
  if (!(newRange->flags & Folded))
    return false;
  
  TextFolding::FoldingRange *parent = newRange->parent;
  while (parent) {
    if (parent->flags & Folded)
      return false;
    
    parent = parent->parent;
  }
  
  FoldingRange::Vector newFoldedFoldingRanges;
  bool newRangeInserted = false;
  Q_FOREACH (FoldingRange *range, m_foldedFoldingRanges) {
    if ((newRange->start->toCursor() <= range->start->toCursor()) && (newRange->end->toCursor() >= range->end->toCursor()))
      continue;
    
    if (!newRangeInserted && (range->start->toCursor() >= newRange->end->toCursor())) {
      newFoldedFoldingRanges.push_back (newRange);
      newRangeInserted = true;
    }
    
    newFoldedFoldingRanges.push_back (range);
  }
  
  if (!newRangeInserted)
    newFoldedFoldingRanges.push_back (newRange);
  
  m_foldedFoldingRanges = newFoldedFoldingRanges;
  
  emit foldingRangesChanged ();
  
  return true;
}

bool TextFolding::updateFoldedRangesForRemovedRange (TextFolding::FoldingRange *oldRange)
{
  if (oldRange->flags & Folded)
    return false;
  
  TextFolding::FoldingRange *parent = oldRange->parent;
  while (parent) {
    if (parent->flags & Folded)
      return false;
    
    parent = parent->parent;
  }
  
  FoldingRange::Vector newFoldedFoldingRanges;
  Q_FOREACH (FoldingRange *range, m_foldedFoldingRanges) {
    if (range == oldRange) {
      appendFoldedRanges (newFoldedFoldingRanges, oldRange->nestedRanges);
      continue;
    }
    
    newFoldedFoldingRanges.push_back (range);
  }
  
  m_foldedFoldingRanges = newFoldedFoldingRanges;
  
  emit foldingRangesChanged ();
  
  return true;
}

void TextFolding::appendFoldedRanges (TextFolding::FoldingRange::Vector &newFoldedFoldingRanges, const TextFolding::FoldingRange::Vector &ranges) const
{
  Q_FOREACH (FoldingRange *range, ranges) {
    if (range->flags & Folded) {
      newFoldedFoldingRanges.push_back (range);
      continue;
    }
    
    appendFoldedRanges (newFoldedFoldingRanges, range->nestedRanges);
  }
}

QVariantList TextFolding::exportFoldingRanges () const
{
  QVariantList folds;
  exportFoldingRanges (m_foldingRanges, folds);
  return folds;
}

void TextFolding::exportFoldingRanges (const TextFolding::FoldingRange::Vector &ranges, QVariantList &folds)
{
  Q_FOREACH (FoldingRange *range, ranges) {
    QVariantMap rangeMap;
    rangeMap["startLine"] = range->start->line();
    rangeMap["startColumn"] = range->start->column();
    rangeMap["endLine"] = range->end->line();
    rangeMap["endColumn"] = range->end->column();
    rangeMap["flags"] = (int)range->flags;
    folds.append (rangeMap);
    
    exportFoldingRanges (range->nestedRanges, folds);
  }
}

void TextFolding::importFoldingRanges (const QVariantList &folds)
{
  Q_FOREACH (QVariant rangeVariant, folds) {
    QVariantMap rangeMap = rangeVariant.toMap ();
    
    KTextEditor::Cursor start (rangeMap["startLine"].toInt(), rangeMap["startColumn"].toInt());
    KTextEditor::Cursor end (rangeMap["endLine"].toInt(), rangeMap["endColumn"].toInt());
    
    int rawFlags = rangeMap["flags"].toInt();
    FoldingRangeFlags flags;
    if (rawFlags & Persistent)
      flags = Persistent;
    if (rawFlags & Folded)
      flags = Folded;
    
    newFoldingRange (KTextEditor::Range (start, end), flags);
  }
}

}