#include "toonzqt/functionsheet.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/functionviewer.h"

// TnzLib includes

#include "toonz/tframehandle.h"

#include "toonz/doubleparamcmd.h"

#include "toonz/preferences.h"

#include "toonz/toonzfolders.h"

#include "toonz/tstageobject.h"

// TnzBase includes

#include "tunit.h"

#include "../toonz/menubarcommandids.h"

// Qt includes

#include <qpainter></qpainter>

#include <qgridlayout></qgridlayout>

#include <qpaintevent></qpaintevent>

#include <qmenu></qmenu>

#include <qapplication>  //for drag&drop</qapplication>

#include <qdrag></qdrag>

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

//    Local namespace stuff

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

namespace {

const int cColumnDragHandleWidth = 8;

const int cGroupShortNameY =

    0;  //!< Column header's y pos for channel groups' short name tabs

const int cGroupLongNameY = 27;  //!< Same for its long name tabs

const int cChannelNameY = 50;  //!< Column header's y pos of channel name tabs,

                               //! up to the widget's height

const int cColHeadersEndY = 87;  //!< End of column headers y pos

}  // namespace

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

//    Function Sheet Tools

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

/*--- NumericalColumnsのセグメントの左側のバーをクリックしたとき ---*/

class MoveChannelsDragTool final : public Spreadsheet::DragTool {

  FunctionSheet *m_sheet;

  std::vector<keyframesetter *=""> m_setters;</keyframesetter>

  int m_oldRow;

  QRect m_selectedCells;

  int m_firstKeyframeRow;

public:

  MoveChannelsDragTool(FunctionSheet *sheet)

      : m_sheet(sheet), m_firstKeyframeRow(-1) {}

  void click(int row, int col, QMouseEvent *e) override {

    m_firstKeyframeRow                  = -1;

    FunctionTreeModel::Channel *channel = m_sheet->getChannel(col);

    if (!channel) return;

    TDoubleParam *curve = channel->getParam();

    int k0 = -1, k1 = -1;

    if (curve->isKeyframe(row))

      k0 = k1 = curve->getClosestKeyframe(row);

    else {

      k0 = curve->getPrevKeyframe(row);

      k1 = curve->getNextKeyframe(row);

    }

    // return if clicking outside of the segments

    if (k0 < 0 || k1 < 0) return;

    int r0 = tround(curve->keyframeIndexToFrame(k0));

    int r1 = tround(curve->keyframeIndexToFrame(k1));

    if (m_sheet->isSelectedCell(row, col)) {

      m_selectedCells = m_sheet->getSelectedCells();

      m_selectedCells.setTop(r0);

      m_selectedCells.setBottom(r1);

    } else

      m_selectedCells = QRect(col, r0, 1, r1 - r0 + 1);

    m_sheet->selectCells(m_selectedCells);

    /*---

シンプルに左のバーをクリックした場合はcolは1つだけ。

すでに複数Columnが選択されている上でその選択範囲内のセルの左バーをクリックした場合は

横（Column）幅は選択範囲に順ずるようになる。高さ(row)はクリックしたセグメントと同じになる。

---*/

    /*--- セグメントごとドラッグに備えてKeyFrameを格納する ---*/

    for (int col = m_selectedCells.left(); col <= m_selectedCells.right();

         ++col) {

      TDoubleParam *curve = m_sheet->getCurve(col);

      if (!curve) continue;

      KeyframeSetter *setter = new KeyframeSetter(curve);

      for (int k = 0; k < curve->getKeyframeCount(); k++) {

        int row = (int)curve->keyframeIndexToFrame(k);

        if (r0 <= row && row <= r1) {

          if (m_firstKeyframeRow < 0 || row < m_firstKeyframeRow)

            m_firstKeyframeRow = row;

          setter->selectKeyframe(k);

        }

      }

      m_setters.push_back(setter);

    }

    m_oldRow = row;

  }

  void drag(int row, int col, QMouseEvent *e) override {

    int d    = row - m_oldRow;

    m_oldRow = row;

    if (d + m_firstKeyframeRow < 0) d = -m_firstKeyframeRow;

    m_firstKeyframeRow += d;

    for (int i = 0; i < (int)m_setters.size(); i++)

      m_setters[i]->moveKeyframes(d, 0.0);

    m_selectedCells.translate(0, d);

    m_sheet->selectCells(m_selectedCells);

  }

  void release(int row, int col, QMouseEvent *e) override {

    for (int i = 0; i < (int)m_setters.size(); i++) delete m_setters[i];

    m_setters.clear();

  }

};

//-----------------------------------------------------------------------------

/*--- NumericalColumnsのセル部分をクリックしたとき ---*/

class FunctionSheetSelectionTool final : public Spreadsheet::DragTool {

  int m_firstRow, m_firstCol;

  FunctionSheet *m_sheet;

public:

  FunctionSheetSelectionTool(FunctionSheet *sheet)

      : m_sheet(sheet), m_firstRow(-1), m_firstCol(-1) {}

  void click(int row, int col, QMouseEvent *e) override {

    if (0 != (e->modifiers() & Qt::ShiftModifier) &&

        !m_sheet->getSelectedCells().isEmpty()) {

      QRect selectedCells = m_sheet->getSelectedCells();

      if (col < selectedCells.center().x()) {

        m_firstCol = selectedCells.right();

        selectedCells.setLeft(col);

      } else {

        m_firstCol = selectedCells.left();

        selectedCells.setRight(col);

      }

      if (row < selectedCells.center().y()) {

        m_firstRow = selectedCells.bottom();

        selectedCells.setTop(row);

      } else {

        m_firstRow = selectedCells.top();

        selectedCells.setBottom(row);

      }

      m_sheet->selectCells(selectedCells);

    } else {

      // regular click, no shift

      m_firstCol = col;

      m_firstRow = row;

      QRect selectedCells(col, row, 1, 1);

      m_sheet->selectCells(selectedCells);

    }

  }

  void drag(int row, int col, QMouseEvent *e) override {

    if (row < 0) row = 0;

    if (col < 0) col = 0;

    int r0 = std::min(row, m_firstRow);

    int r1 = std::max(row, m_firstRow);

    int c0 = std::min(col, m_firstCol);

    int c1 = std::max(col, m_firstCol);

    QRect selectedCells(c0, r0, c1 - c0 + 1, r1 - r0 + 1);

    m_sheet->selectCells(selectedCells);

  }

  void release(int row, int col, QMouseEvent *e) override {

    if (row == m_firstRow && col == m_firstCol) {

      if (Preferences::instance()->isMoveCurrentEnabled())

        m_sheet->setCurrentFrame(row);

      FunctionTreeModel::Channel *channel = m_sheet->getChannel(col);

      if (channel) channel->setIsCurrent(true);

    }

  }

};

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

//    FunctionSheetRowViewer  implementation

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

FunctionSheetRowViewer::FunctionSheetRowViewer(FunctionSheet *parent)

    : Spreadsheet::RowPanel(parent), m_sheet(parent) {

  setMinimumSize(QSize(100, 100));

  setMouseTracking(true);

  setFocusPolicy(Qt::NoFocus);

}

//-----------------------------------------------------------------------------

void FunctionSheetRowViewer::paintEvent(QPaintEvent *e) {

  // calls GenericPanel's event

  Spreadsheet::RowPanel::paintEvent(e);

}

//-----------------------------------------------------------------------------

void FunctionSheetRowViewer::mousePressEvent(QMouseEvent *e) {

  // calls GenericPanel's event

  Spreadsheet::RowPanel::mousePressEvent(e);

}

//-----------------------------------------------------------------------------

void FunctionSheetRowViewer::mouseMoveEvent(QMouseEvent *e) {

  // calls GenericPanel's event

  Spreadsheet::RowPanel::mouseMoveEvent(e);

}

//-----------------------------------------------------------------------------

void FunctionSheetRowViewer::mouseReleaseEvent(QMouseEvent *e) {

  Spreadsheet::RowPanel::mouseReleaseEvent(e);

}

//-----------------------------------------------------------------------------

void FunctionSheetRowViewer::contextMenuEvent(QContextMenuEvent *event) {

  QMenu *menu                = new QMenu(this);

  CommandManager *cmdManager = CommandManager::instance();

  menu->addAction(cmdManager->getAction(MI_InsertSceneFrame));

  menu->addAction(cmdManager->getAction(MI_RemoveSceneFrame));

  menu->addAction(cmdManager->getAction(MI_InsertGlobalKeyframe));

  menu->addAction(cmdManager->getAction(MI_RemoveGlobalKeyframe));

  menu->exec(event->globalPos());

}

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

//    FunctionSheetColumnHeadViewer  implementation

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

FunctionSheetColumnHeadViewer::FunctionSheetColumnHeadViewer(

    FunctionSheet *parent)

    : Spreadsheet::ColumnPanel(parent), m_sheet(parent), m_draggingChannel(0) {

  setMouseTracking(true);  // for updating the tooltip

  setFocusPolicy(Qt::NoFocus);

}

//-----------------------------------------------------------------------------

void FunctionSheetColumnHeadViewer::paintEvent(QPaintEvent *e) {

  QPainter painter(this);

  QRect toBeUpdated = e->rect();

  painter.setClipRect(toBeUpdated);

  // visible columns range

  CellRange visible = getViewer()->xyRectToRange(toBeUpdated);

  int c0            = visible.from().layer();

  int c1            = visible.to().layer();

  if (c0 > c1) return;

  int n = c1 - c0 + 1 + 2;

  FunctionTreeModel::ChannelGroup *currentGroup = 0;

  /*--- Display range + right and left 1 column range ChannelGroup. If there is

   * none, put 0

   * ---*/

  std::vector<functiontreemodel::channelgroup *=""> channelGroups(n);</functiontreemodel::channelgroup>

  for (int i = 0; i < n; ++i) {

    channelGroups[i] = 0;

    int c = c0 - 1 + i;

    if (c < 0) continue;

    FunctionTreeModel::Channel *channel = m_sheet->getChannel(c);

    if (!channel) continue;

    channelGroups[i] = channel->getChannelGroup();

    if (!currentGroup && channel->isCurrent()) currentGroup = channelGroups[i];

  }

  int y0 = 0;

  int y1 = 17;  // needs work

  int y2 = 34;

  int y3 = 53;

  /*--- Fill header with background color ---*/

  for (int c = c0; c <= c1; c++) {

    FunctionTreeModel::Channel *channel = m_sheet->getChannel(c);

    if (!channel) break;

    int x0 = getViewer()->columnToX(c);

    int x1 = getViewer()->columnToX(c + 1) - 1;

    // Column Width

    int width = x1 - x0 + 1;

    painter.fillRect(x0, y0, width, y3 - y0, getViewer()->getBGColor());

  }

  for (int c = c0; c <= c1; ++c) {

    FunctionTreeModel::Channel *channel = m_sheet->getChannel(c);

    if (!channel) {

      if (c != c0) {

        // draw "the end" border

        int x0 = getViewer()->columnToX(c);

        painter.setPen(getViewer()->getColumnHeaderBorderColor());

        painter.drawLine(x0, y0, x0, y3);

      }

      break;

    }

    int i = c - c0 + 1;

    /*---- Channel Column of the current Column and the preceding and following

     * Columns ---*/

    FunctionTreeModel::ChannelGroup *prevGroup = channelGroups[c - c0],

                                    *group     = channelGroups[c - c0 + 1],

                                    *nextGroup = channelGroups[c - c0 + 2];

    /*---- If the group is different from the before and after, flags are set

     * respectively ---*/

    bool firstGroupColumn = prevGroup != group;

    bool lastGroupColumn  = nextGroup != group;

    /*--- The left and right coordinates of the current column ---*/

    int x0 = getViewer()->columnToX(c);

    int x1 = getViewer()->columnToX(c + 1) - 1;

    // Column width

    int width = x1 - x0 + 1;

    QRect selectedRect = m_sheet->getSelectedCells();

    bool isSelected =

        (selectedRect.left() <= c && c <= selectedRect.right()) ? true : false;

    // paint with light color if selected

    if (isSelected)

      painter.fillRect(x0, y1, width, y3 - y1,

                       getViewer()->getCurrentRowBgColor());

    // draw horizonntal lines

    painter.setPen(QPen(getViewer()->getColumnHeaderBorderColor(), 3));

    painter.drawLine(x0, y0, x1, y0);

    painter.setPen(getViewer()->getColumnHeaderBorderColor());

    painter.drawLine(x0, y1, x1, y1);

    // draw vertical bar

    painter.fillRect(x0, y1, 6, y3 - y1,

                     getViewer()->getColumnHeaderBorderColor());

    if (firstGroupColumn)

      painter.fillRect(x0, y0, 6, y1 - y0,

                       getViewer()->getColumnHeaderBorderColor());

    // channel name

    painter.setPen(getViewer()->getTextColor());

    if (channel->isCurrent())

      painter.setPen(m_sheet->getViewer()->getCurrentTextColor());

    QString text = channel->getShortName();

    int d        = 8;

    painter.drawText(x0 + d, y1, width - d, y3 - y1 + 1,

                     Qt::TextWrapAnywhere | Qt::AlignLeft | Qt::AlignVCenter,

                     text);

    // group name

    if (firstGroupColumn) {

      int tmpwidth = (lastGroupColumn) ? width : width * 2;

      painter.setPen(getViewer()->getTextColor());

      if (group == currentGroup)

        painter.setPen(m_sheet->getViewer()->getCurrentTextColor());

      text = group->getShortName();

      painter.drawText(x0 + d, y0, tmpwidth - d, y1 - y0 + 1,

                       Qt::AlignLeft | Qt::AlignVCenter, text);

    }

  }

}

//-----------------------------------------------------------------------------

/*! update tooltips

 */

void FunctionSheetColumnHeadViewer::mouseMoveEvent(QMouseEvent *e) {

  if ((e->buttons() & Qt::MidButton) && m_draggingChannel &&

      (e->pos() - m_dragStartPosition).manhattanLength() >=

          QApplication::startDragDistance()) {

    QDrag *drag         = new QDrag(this);

    QMimeData *mimeData = new QMimeData;

    mimeData->setText(m_draggingChannel->getExprRefName());

    drag->setMimeData(mimeData);

    static const QPixmap cursorPixmap(":Resources/dragcursor_exp_text.png");

    drag->setDragCursor(cursorPixmap, Qt::MoveAction);

    Qt::DropAction dropAction = drag->exec();

    return;

  }

  // get the column under the cursor

  int col = getViewer()->xyToPosition(e->pos()).layer();

  FunctionTreeModel::Channel *channel = m_sheet->getChannel(col);

  if (!channel) {

    setToolTip(QString(""));

  } else

    setToolTip(channel->getExprRefName());

  // modify selected channel by left dragging

  if (m_clickedColumn >= 0 && channel && e->buttons() & Qt::LeftButton) {

    int fromC      = std::min(m_clickedColumn, col);

    int toC        = std::max(m_clickedColumn, col);

    int lastKeyPos = 0;

    for (int c = fromC; c <= toC; c++) {

      FunctionTreeModel::Channel *tmpChan = m_sheet->getChannel(c);

      if (!tmpChan) continue;

      std::set<double> frames;</double>

      tmpChan->getParam()->getKeyframes(frames);

      if (!frames.empty())

        lastKeyPos = std::max(lastKeyPos, (int)*frames.rbegin());

    }

    QRect rect(std::min(m_clickedColumn, col), 0,

               std::abs(col - m_clickedColumn) + 1, lastKeyPos + 1);

    getViewer()->selectCells(rect);

  }

}

//-----------------------------------------------------------------------------

void FunctionSheetColumnHeadViewer::mousePressEvent(QMouseEvent *e) {

  QPoint pos                          = e->pos();

  int currentC                        = getViewer()->xyToPosition(pos).layer();

  FunctionTreeModel::Channel *channel = m_sheet->getChannel(currentC);

  if (!channel) {

    m_clickedColumn = -1;

    return;

  }

  if (e->button() == Qt::MidButton) {

    m_draggingChannel   = channel;

    m_dragStartPosition = e->pos();

    return;

  } else

    channel->setIsCurrent(true);

  m_draggingChannel = 0;

  if (e->button() == Qt::LeftButton) {

    int lastKeyPos = 0;

    // if the current selection does not contain the first cell in m_firstColumn

    // then we assume that the selection has been modified and treat shift+click

    // as normal click.

    if (getViewer()->getSelectedCells().contains(m_clickedColumn, 0) &&

        (e->modifiers() & Qt::ShiftModifier)) {

      int fromC = std::min(m_clickedColumn, currentC);

      int toC   = std::max(m_clickedColumn, currentC);

      for (int c = fromC; c <= toC; c++) {

        FunctionTreeModel::Channel *tmpChan = m_sheet->getChannel(c);

        if (!tmpChan) continue;

        std::set<double> frames;</double>

        tmpChan->getParam()->getKeyframes(frames);

        if (!frames.empty())

          lastKeyPos = std::max(lastKeyPos, (int)*frames.rbegin());

      }

    } else {

      // Open folder

      FunctionTreeModel::ChannelGroup *channelGroup =

          channel->getChannelGroup();

      if (!channelGroup->isOpen())

        channelGroup->getModel()->setExpandedItem(channelGroup->createIndex(),

                                                  true);

      // Select all segment

      std::set<double> frames;</double>

      channel->getParam()->getKeyframes(frames);

      if (!frames.empty()) lastKeyPos = (int)*frames.rbegin();

      m_clickedColumn = currentC;

    }

    QRect rect(std::min(m_clickedColumn, currentC), 0,

               std::abs(currentC - m_clickedColumn) + 1, lastKeyPos + 1);

    getViewer()->selectCells(rect);

  }

  // Switch selection before opening the context menu

  // if the clicked column is out of the selection

  else if (e->button() == Qt::RightButton) {

    QRect selectedCell = getViewer()->getSelectedCells();

    if (selectedCell.left() > currentC || selectedCell.right() < currentC) {

      int lastKeyPos = 0;

      std::set<double> frames;</double>

      channel->getParam()->getKeyframes(frames);

      if (!frames.empty()) lastKeyPos = (int)*frames.rbegin();

      getViewer()->selectCells(QRect(currentC, 0, 1, lastKeyPos + 1));

    }

  }

}

//-----------------------------------------------------------------------------

void FunctionSheetColumnHeadViewer::contextMenuEvent(QContextMenuEvent *ce) {

  // First, select column under cursor

  const QPoint &pos = ce->pos();

  int cursorCol     = getViewer()->xyToPosition(pos).layer();

  if (cursorCol < 0 || cursorCol >= m_sheet->getChannelCount()) return;

  FunctionTreeModel::Channel *channel = m_sheet->getChannel(cursorCol);

  if (!channel) return;

  // Ok, now let's summon a context menu with appropriate options

  FunctionViewer *fv = m_sheet->getViewer();

  if (!fv) {

    assert(fv);

    return;

  }

  const QPoint &globalPos = mapToGlobal(pos);

  if (pos.y() >= cChannelNameY)

    fv->openContextMenu(channel, globalPos);

  else {

    FunctionTreeModel::ChannelGroup *group = channel->getChannelGroup();

    // In this case, commands are different from the tree view. Rather than

    // showing in the tree,

    // channels get ACTIVATED

    QMenu menu;

    QAction showAnimatedOnly(FunctionTreeView::tr("Show Animated Only"), 0);

    QAction showAll(FunctionTreeView::tr("Show All"), 0);

    QAction hideSelected(FunctionTreeView::tr("Hide Selected"), 0);

    menu.addAction(&showAnimatedOnly);

    menu.addAction(&showAll);

    menu.addAction(&hideSelected);

    // execute menu

    QAction *action = menu.exec(globalPos);

    // Process action

    if (action == &showAll) {

      int c, cCount = group->getChildCount();

      for (c = 0; c != cCount; ++c) {

        FunctionTreeModel::Channel *channel =

            dynamic_cast<functiontreemodel::channel *="">(group->getChild(c));</functiontreemodel::channel>

        if (channel && !channel->isHidden()) channel->setIsActive(true);

      }

    } else if (action == &showAnimatedOnly) {

      int c, cCount = group->getChildCount();

      for (c = 0; c != cCount; ++c) {

        FunctionTreeModel::Channel *channel =

            dynamic_cast<functiontreemodel::channel *="">(group->getChild(c));</functiontreemodel::channel>

        if (channel && !channel->isHidden())

          channel->setIsActive(channel->isAnimated());

      }

    } else if (action == &hideSelected) {

      QRect selectedCells = getViewer()->getSelectedCells();

      // hide the selected columns from the right to the left

      for (int col = selectedCells.right(); col >= selectedCells.left();

           col--) {

        FunctionTreeModel::Channel *chan = m_sheet->getChannel(col);

        if (chan) chan->setIsActive(false);

      }

      // clear cell selection

      getViewer()->selectCells(QRect());

    } else

      return;

    fv->update();

  }

}

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

//    FunctionSheetCellViewer  implementation

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

FunctionSheetCellViewer::FunctionSheetCellViewer(FunctionSheet *parent)

    : Spreadsheet::CellPanel(parent)

    , m_sheet(parent)

    , m_editRow(0)

    , m_editCol(0) {

  m_lineEdit = new DVGui::LineEdit(this);

  // lineEdit->setGeometry(10,10,100,30);

  m_lineEdit->hide();

  bool ret = connect(m_lineEdit, SIGNAL(editingFinished()), this,

                     SLOT(onCellEditorEditingFinished()));

  ret      = ret && connect(m_lineEdit, SIGNAL(mouseMoved(QMouseEvent *)), this,

                       SLOT(onMouseMovedInLineEdit(QMouseEvent *)));

  assert(ret);

  setMouseTracking(true);

  setFocusProxy(m_lineEdit);

}

//-----------------------------------------------------------------------------

/*! Called when the cell panel is left/right-clicked

 */

Spreadsheet::DragTool *FunctionSheetCellViewer::createDragTool(QMouseEvent *e) {

  CellPosition cellPosition = getViewer()->xyToPosition(e->pos());

  int row                   = cellPosition.frame();

  int col                   = cellPosition.layer();

  bool isEmpty              = true;

  TDoubleParam *curve       = m_sheet->getCurve(col);

  if (curve) {

    int kCount = curve->getKeyframeCount();

    if (kCount > 0) {

      int row0 = (int)curve->keyframeIndexToFrame(0);

      int row1 = (int)curve->keyframeIndexToFrame(kCount - 1);

      isEmpty  = row < row0 || row > row1;

    }

  }

  if (!isEmpty) {

    int x = e->pos().x() - getViewer()->columnToX(col);

    if (0 <= x && x < cColumnDragHandleWidth + 9)

      return new MoveChannelsDragTool(m_sheet);

  }

  return new FunctionSheetSelectionTool(m_sheet);

  // return Spreadsheet::CellPanel::createDragTool(e);

}

//-----------------------------------------------------------------------------

void FunctionSheetCellViewer::drawCells(QPainter &painter, int r0, int c0,

                                        int r1, int c1) {

  // key frames

  QColor KeyFrameColor         = getViewer()->getKeyFrameColor();

  QColor KeyFrameBorderColor   = getViewer()->getKeyFrameBorderColor();

  QColor SelectedKeyFrameColor = getViewer()->getSelectedKeyFrameColor();

  // inbetween

  QColor InBetweenColor         = getViewer()->getInBetweenColor();

  QColor InBetweenBorderColor   = getViewer()->getInBetweenBorderColor();

  QColor SelectedInBetweenColor = getViewer()->getSelectedInBetweenColor();

  // empty cells

  QColor SelectedEmptyColor = getViewer()->getSelectedEmptyColor();

  // empty cells in scene frame range

  QColor SelectedSceneRangeEmptyColor =

      getViewer()->getSelectedSceneRangeEmptyColor();

  // top and bottom pos

  int y0 = getViewer()->rowToY(r0);

  int y1 = getViewer()->rowToY(r1 + 1) - 1;

  for (int c = c0; c <= c1; c++) {

    TDoubleParam *curve = m_sheet->getCurve(c);

    /*--- もしカラムcにパラメータが無ければcurveには０が返る ---*/

    if (!curve) continue;

    // left and right pos

    int x0 = getViewer()->columnToX(c);

    int x1 = getViewer()->columnToX(c + 1) - 1;

    // find the curve keyframe range

    int kr0 = 0, kr1 = -1;

    int kCount = curve->getKeyframeCount();

    if (kCount > 0) {

      kr0 = curve->keyframeIndexToFrame(0);

      kr1 = curve->keyframeIndexToFrame(kCount - 1);

    }

    // get the unit

    TMeasure *measure = curve->getMeasure();

    const TUnit *unit = measure ? measure->getCurrentUnit() : 0;

    bool isStageObjectCycled = false;

    TStageObject *obj        = m_sheet->getStageObject(c);

    if (obj && obj->isCycleEnabled()) isStageObjectCycled = true;

    bool isParamCycled = curve->isCycleEnabled();

    int rowCount       = getViewer()->getRowCount();

    // draw each cell

    for (int row = r0; row <= r1; row++) {

      int ya = m_sheet->rowToY(row);

      int yb = m_sheet->rowToY(row + 1) - 1;

      bool isSelected = getViewer()->isSelectedCell(row, c);

      double value = (isStageObjectCycled)

                         ? curve->getValue(obj->paramsTime((double)row))

                         : curve->getValue(row);

      if (unit) value = unit->convertTo(value);

      enum { None, Key, Inbetween, CycleRange } drawValue = None;

      QRect cellRect(x0, ya, x1 - x0 + 1, yb - ya + 1);

      QRect borderRect(x0, ya, 7, yb - ya + 1);

      QColor cellColor, borderColor;

      /*--- キーフレーム間の範囲だけ色をつける ---*/

      if (kr0 <= row && row <= kr1) {

        if (curve->isKeyframe(row)) {

          cellColor   = (isSelected) ? SelectedKeyFrameColor : KeyFrameColor;

          borderColor = KeyFrameBorderColor;

        } else {

          cellColor   = (isSelected) ? SelectedInBetweenColor : InBetweenColor;

          borderColor = InBetweenBorderColor;

          // when the inbetween values are hidden, change the cell colors to

          // semi-transparent if the frame is in middle of the value step

          if (!m_sheet->isIbtwnValueVisible()) {

            TDoubleKeyframe kf =

                curve->getKeyframe(curve->getPrevKeyframe(row));

            int step = kf.m_step;

            if (step > 1 && (row - (int)std::floor(kf.m_frame)) % step != 0)

              cellColor.setAlpha(128);

          }

        }

        painter.setPen(Qt::NoPen);

        painter.fillRect(cellRect, cellColor);

        painter.fillRect(borderRect, borderColor);

        // display whether segment are Linked

        if (curve->isKeyframe(row)) {

          TDoubleKeyframe kf = curve->getKeyframeAt(row);

          // if the segments are NOT linked, then cut off the side bar

          if (!kf.m_linkedHandles) {

            int rowCenterPos = (ya + yb) / 2;

            QPoint points[4] = {

                QPoint(x0, rowCenterPos), QPoint(x0 + 7, rowCenterPos + 3),

                QPoint(x0 + 7, rowCenterPos - 3), QPoint(x0, rowCenterPos)};

            QBrush oldBrush = painter.brush();

            painter.setBrush(QBrush(cellColor));

            painter.drawPolygon(points, 4);

            painter.setBrush(oldBrush);

          }

        }

        drawValue = (curve->isKeyframe(row))

                        ? Key

                        : (m_sheet->isIbtwnValueVisible()) ? Inbetween : None;

      }

      // empty cells

      else {

        // show values for cycled parameter.

        // cycle option can be set in two ways; one is as TStageObject,

        // the other is as TDoubleParam.

        // - TStageObject cycle literally cycles values with no offset.

        //   Applied to all transformation parameters of the cycled object.

        // - TDoubleParam cycle includes value offset so that the curve

        //   connects smoothly.

        // - TStageObject cycle option has a priority to TDoubleParam one.

        // (see TStageObject::paramsTime() in tstageobject.cpp)

        if (kCount > 0 && row > kr1 && (isStageObjectCycled || isParamCycled) &&

            (row < rowCount)) {

          drawValue = CycleRange;

        }

        // empty and selected cell

        if (isSelected) {

          cellColor = (row >= rowCount) ? SelectedEmptyColor

                                        : SelectedSceneRangeEmptyColor;

          painter.setPen(Qt::NoPen);

          painter.fillRect(cellRect, cellColor);

        }

      }

      if (drawValue != None) {

        // draw cell value

        if (drawValue == Key || drawValue == Inbetween)

          painter.setPen(getViewer()->getTextColor());

        else {

          QColor semiTranspTextColor = getViewer()->getTextColor();

          semiTranspTextColor.setAlpha(128);

          painter.setPen(semiTranspTextColor);

        }

        /*--- 整数から小数点以下3桁以内の場合はそれ以降の0000を描かない ---*/

        QString text;

        double thousandValue = value * 1000.0;

        if (areAlmostEqual(thousandValue, (double)tround(thousandValue),

                           0.0001)) {

          text = QString::number(value, 'f', 3);

          while (text.endsWith("0")) {

            text.chop(1);

            if (text.endsWith(".")) {

              text.chop(1);

              break;

            }

          }

        } else {

          text = QString::number(value, 'f', 4);

          text.truncate(5);

          text.append("~");

        }

        QString fontName = Preferences::instance()->getInterfaceFont();

        if (fontName == "") {

#ifdef _WIN32

          fontName = "Arial";

#else

          fontName = "Helvetica";

#endif

        }

        static QFont font(fontName, -1);

        font.setBold(drawValue == Key);

        font.setPixelSize(12);

        painter.setFont(font);

        painter.drawText(cellRect.adjusted(10, 0, 0, 0),

                         Qt::AlignVCenter | Qt::AlignLeft, text);

      }

    }

    if (kCount > 0 && (isStageObjectCycled || isParamCycled)) {

      // draw the row zigzag

      int ymax           = m_sheet->rowToY(r1 + 1);

      int qx             = x0 + 4;

      int qy             = m_sheet->rowToY(kr1 + 1);

      int zig            = 2;

      QColor zigzagColor = (isStageObjectCycled) ? getViewer()->getTextColor()

                                                 : KeyFrameBorderColor;

      painter.setPen(zigzagColor);

      painter.drawLine(QPoint(qx, qy), QPoint(qx - zig, qy + zig));

      qy += zig;

      while (qy < ymax) {

        painter.drawLine(QPoint(qx - zig, qy), QPoint(qx + zig, qy + 2 * zig));

        painter.drawLine(QPoint(qx + zig, qy + 2 * zig),

                         QPoint(qx - zig, qy + 4 * zig));

        qy += 4 * zig;

      }

    }

  }

}

//-----------------------------------------------------------------------------

void FunctionSheetCellViewer::mouseDoubleClickEvent(QMouseEvent *e) {

  CellPosition cellPosition = getViewer()->xyToPosition(e->pos());

  int row                   = cellPosition.frame();

  int col                   = cellPosition.layer();

  int x0, y0, x1, y1;

  x0 = getViewer()->columnToX(col);

  x1 = getViewer()->columnToX(col + 1) - 1;

  y0 = getViewer()->rowToY(row);

  y1 = getViewer()->rowToY(row + 1) - 1;

  m_editRow = row;

  m_editCol = col;

  TDoubleParam *curve = m_sheet->getCurve(col);

  if (curve) {

    double v          = curve->getValue(row);

    TMeasure *measure = curve->getMeasure();

    const TUnit *unit = measure ? measure->getCurrentUnit() : 0;

    if (unit) v = unit->convertTo(v);

    m_currentValue = v;

    m_lineEdit->setText(QString::number(v, 'f', 4));

    // in order to put the cursor to the left end

    m_lineEdit->setSelection(m_lineEdit->text().length(),

                             -m_lineEdit->text().length());

  } else

    m_lineEdit->setText("");

  QString fontName = Preferences::instance()->getInterfaceFont();

  if (fontName == "") {

#ifdef _WIN32

    fontName = "Arial";

#else

    fontName = "Helvetica";

#endif

  }

  static QFont font(fontName, 9, QFont::Normal);

  m_lineEdit->setFont(font);

  m_lineEdit->setGeometry(x0 - 2, y0 - 2, x1 - x0 + 1 + 4,

                          y1 - y0 + 1 + 4);  // x0,y0,x1-x0+1,y0-y1+1);

  m_lineEdit->show();

  m_lineEdit->raise();

  m_lineEdit->setFocus();

}

//-----------------------------------------------------------------------------

void FunctionSheetCellViewer::onCellEditorEditingFinished() {

  QString text = m_lineEdit->text();

  if (!text.isEmpty() &&

      (m_lineEdit->isReturnPressed() || m_lineEdit->getMouseDragEditing())) {

    double value        = text.toDouble();

    TDoubleParam *curve = m_sheet->getCurve(m_editCol);

    if (curve) {

      TMeasure *measure = curve->getMeasure();

      const TUnit *unit = measure ? measure->getCurrentUnit() : 0;

      if (unit) value = unit->convertFrom(value);

      KeyframeSetter::setValue(curve, m_editRow, value);

    }

  }

  m_lineEdit->hide();

  m_lineEdit->clearFocus();

  m_sheet->setFocus();

  update();

}