#include "toonzqt/functionviewer.h"

// TnzQt includes

#include "toonzqt/functionselection.h"

#include "toonzqt/functionpanel.h"

#include "toonzqt/functiontreeviewer.h"

#include "toonzqt/functionsheet.h"

#include "toonzqt/functionsegmentviewer.h"

#include "toonzqt/functiontoolbar.h"

#include "toonzqt/swatchviewer.h"

#include "toonzqt/dvscrollwidget.h"

// TnzLib includes

#include "toonz/tstageobjecttree.h"

#include "toonz/txsheet.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/fxdag.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/tcolumnfx.h"

#include "toonz/toonzscene.h"

#include "toonz/tproject.h"

#include "toonz/tscenehandle.h"

#include "toonz/sceneproperties.h"

// TnzBase includes

#include "tparamcontainer.h"

#include "tunit.h"

#include "tenv.h"

// TnzCore includes

#include "tstopwatch.h"

// Qt includes

#include <qpainter></qpainter>

#include <qmouseevent></qmouseevent>

#include <qwheelevent></qwheelevent>

#include <qboxlayout></qboxlayout>

#include <qpushbutton></qpushbutton>

#include <qstackedwidget></qstackedwidget>

#include <qlabel></qlabel>

#include <qtoolbar></qtoolbar>

#include <qaction></qaction>

using namespace DVGui;

TEnv::IntVar FunctionEditorToggleStatus("FunctionEditorToggleStatus", 0);

//=============================================================================

//

// FunctionPanel

//

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

FunctionViewer::FunctionViewer(QWidget *parent, Qt::WindowFlags flags)

    : QSplitter(parent)

    , m_xshHandle(0)

    , m_frameHandle(0)

    , m_objectHandle(0)

    , m_fxHandle(0)

    , m_columnHandle(0)

    , m_curve(0)

    , m_selection(new FunctionSelection())

    , m_sceneHandle(0) {

  setObjectName("FunctionEditor");

  // Prepare local timeline

  m_localFrame.setFrame(0);

  setFocusPolicy(Qt::NoFocus);

  m_toggleStart = Preferences::instance()->getFunctionEditorToggle();

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup) {

    m_functionGraph    = new FunctionPanel(this, false);

    m_numericalColumns = new FunctionSheet(this, true);

  } else if (m_toggleStart == Preferences::FunctionEditorToggle::

                                  ToggleBetweenGraphAndSpreadsheet) {

    m_functionGraph    = new FunctionPanel(this, false);

    m_numericalColumns = new FunctionSheet(this, false);

  } else {

    // default values are graph is floating

    // and spreadsheet is not floating

    m_functionGraph    = new FunctionPanel(this);

    m_numericalColumns = new FunctionSheet(this);

  }

  m_treeView = new FunctionTreeView(this);

  m_toolbar = new FunctionToolbar;

  m_segmentViewer =

      new FunctionSegmentViewer(this, m_numericalColumns, m_functionGraph);

  QWidget *leftPanel  = new QWidget();

  QWidget *rightPanel = new QWidget();

  //----

  m_treeView->resize(150, m_treeView->size().height());

  m_treeView->setMinimumWidth(0);

  m_treeView->setIconSize(QSize(21, 18));

  FunctionTreeModel *ftModel =

      dynamic_cast<functiontreemodel *="">(m_treeView->model());</functiontreemodel>

  m_functionGraph->setModel(ftModel);

  m_numericalColumns->setModel(ftModel);

  m_functionGraph->setSelection(getSelection());

  m_numericalColumns->setSelection(getSelection());

  m_numericalColumns->setViewer(this);

  m_toolbar->setSelection(m_selection);

  m_toolbar->setFocusPolicy(Qt::NoFocus);

  m_toolbar->setFrameHandle(

      &m_localFrame);  // The function editor adopts an internal timeline

  m_functionGraph->setFrameHandle(

      &m_localFrame);  // synchronized among its various sub-widgets.

  m_numericalColumns->setFrameHandle(

      &m_localFrame);  // In case an external m_frameHandle is specified,

                       // it synchronizes with that, too.

  //---- layout

  QString layout = Preferences::instance()->getLoadedXsheetLayout();

  bool toolBarOnBottom =

      layout == QString("Minimum") &&

      Preferences::instance()->isExpandFunctionHeaderEnabled() &&

      m_toggleStart !=

          Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup;

  m_leftLayout = new QVBoxLayout();

  m_leftLayout->setMargin(0);

  m_leftLayout->setSpacing(0);

  {

    if (!toolBarOnBottom) m_leftLayout->addWidget(m_toolbar);

    m_spacing = 35;

    if (layout == QString("Compact"))

      m_spacing -= 18;

    else if (toolBarOnBottom) {

      m_spacing = 3;  // m_spacing is used for the height of spacer widget

      m_leftLayout->addSpacing(m_spacing);

    }

    if (m_toggleStart !=

        Preferences::FunctionEditorToggle::ShowGraphEditorInPopup)

      m_leftLayout->addWidget(m_functionGraph);

    if (m_toggleStart !=

        Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup)

      m_leftLayout->addWidget(m_numericalColumns);

    // display the toolbar on the bottom in Minimum layout

    if (toolBarOnBottom) m_leftLayout->addWidget(m_toolbar);

  }

  leftPanel->setLayout(m_leftLayout);

  addWidget(leftPanel);

  QVBoxLayout *rightLayout = new QVBoxLayout();

  rightLayout->setMargin(0);

  rightLayout->setSpacing(5);

  {

    rightLayout->addWidget(m_segmentViewer, 0);

    rightLayout->addWidget(m_treeView, 1);

  }

  rightPanel->setLayout(rightLayout);

  addWidget(rightPanel);

  //--- set the splitter's default size

  setSizes(QList<int>() << 500 << 200);</int>

  setStretchFactor(0, 5);

  setStretchFactor(1, 2);

  //---- signal-slot connections

  bool ret = true;

  ret      = ret && connect(m_toolbar, SIGNAL(numericalColumnToggled()), this,

                            SLOT(toggleMode()));

  ret      = ret && connect(ftModel, SIGNAL(activeChannelsChanged()),

                            m_functionGraph, SLOT(update()));

  ret      = ret && connect(ftModel, SIGNAL(activeChannelsChanged()),

                            m_numericalColumns, SLOT(updateAll()));

  ret      = ret && connect(ftModel, SIGNAL(curveChanged(bool)), m_treeView,

                            SLOT(update()));

  ret = ret && connect(ftModel, SIGNAL(curveChanged(bool)), m_functionGraph,

                       SLOT(update()));

  ret = ret && connect(ftModel, SIGNAL(curveChanged(bool)), m_numericalColumns,

                       SLOT(updateAll()));

  ret = ret && connect(ftModel, SIGNAL(curveSelected(TDoubleParam *)), this,

                       SLOT(onCurveSelected(TDoubleParam *)));

  ret = ret && connect(ftModel, SIGNAL(curveChanged(bool)), m_segmentViewer,

                       SLOT(onCurveChanged()));

  ret = ret && connect(ftModel, SIGNAL(curveChanged(bool)), this,

                       SLOT(onCurveChanged(bool)));

  ret = ret && connect(&m_localFrame, SIGNAL(frameSwitched()), this,

                       SLOT(onFrameSwitched()));

  ret = ret && connect(getSelection(), SIGNAL(selectionChanged()), this,

                       SLOT(onSelectionChanged()));

  ret = ret && connect(m_functionGraph, SIGNAL(keyframeSelected(double)),

                       m_toolbar, SLOT(setFrame(double)));

  ret = ret && connect(m_treeView, SIGNAL(switchCurrentObject(TStageObject *)),

                       this, SLOT(doSwitchCurrentObject(TStageObject *)));

  ret = ret && connect(m_treeView, SIGNAL(switchCurrentFx(TFx *)), this,

                       SLOT(doSwitchCurrentFx(TFx *)));

  ret = ret &&

        connect(ftModel,

                SIGNAL(currentChannelChanged(FunctionTreeModel::Channel *)),

                m_numericalColumns,

                SLOT(onCurrentChannelChanged(FunctionTreeModel::Channel *)));

  assert(ret);

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup) {

    m_numericalColumns->hide();

    if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem())

      spacer->changeSize(0, 0);

  } else {

    bool toolBarVisible =

        Preferences::instance()->isShowXSheetToolbarEnabled() &&

        Preferences::instance()->isExpandFunctionHeaderEnabled();

    if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem()) {

      spacer->changeSize(1, m_spacing + ((toolBarVisible) ? 10 : 0),

                         QSizePolicy::Fixed, QSizePolicy::Fixed);

      spacer->invalidate();

    } else

      m_leftLayout->setSpacing(m_spacing + ((toolBarVisible) ? 30 : 0));

    if (m_toggleStart ==

        Preferences::FunctionEditorToggle::ShowGraphEditorInPopup) {

      m_functionGraph->hide();

    }

  }

}

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

FunctionViewer::~FunctionViewer() {

  delete m_selection;

  m_toolbar->setFrameHandle(0);

}

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

void FunctionViewer::showEvent(QShowEvent *) {

  refreshModel();

  // Connect handles

  bool ret = true;

  if (m_xshHandle) {

    ret = ret && connect(m_xshHandle, SIGNAL(xsheetChanged()), this,

                         SLOT(refreshModel()));

    ret = ret && connect(m_xshHandle, SIGNAL(xsheetSwitched()), this,

                         SLOT(rebuildModel()));

  }

  if (m_frameHandle) {

    ret = ret && connect(m_frameHandle, SIGNAL(frameSwitched()), this,

                         SLOT(propagateExternalSetFrame()));

    ret = ret && connect(m_frameHandle, SIGNAL(triggerNextKeyframe(QWidget *)),

                         m_toolbar, SLOT(onNextKeyframe(QWidget *)));

    ret = ret && connect(m_frameHandle, SIGNAL(triggerPrevKeyframe(QWidget *)),

                         m_toolbar, SLOT(onPrevKeyframe(QWidget *)));

  }

  if (m_objectHandle) {

    ret = ret && connect(m_objectHandle, SIGNAL(objectSwitched()), this,

                         SLOT(onStageObjectSwitched()));

    ret = ret && connect(m_objectHandle, SIGNAL(objectChanged(bool)), this,

                         SLOT(onStageObjectChanged(bool)));

  }

  if (m_fxHandle)

    ret = ret &&

          connect(m_fxHandle, SIGNAL(fxSwitched()), this, SLOT(onFxSwitched()));

  // display animated channels when the scene is switched

  if (m_sceneHandle) {

    ret = ret && connect(m_sceneHandle, SIGNAL(sceneSwitched()), m_treeView,

                         SLOT(displayAnimatedChannels()));

    ret = ret &&

          connect(m_sceneHandle, SIGNAL(preferenceChanged(const QString &)),

                  this, SLOT(onPreferenceChanged(const QString &)));

  }

  assert(ret);

  m_treeView->setExpanded(m_treeView->model()->index(0, 0), true);

  m_treeView->setExpanded(m_treeView->model()->index(1, 0), true);

  FunctionTreeModel *ftm =

      static_cast<functiontreemodel *="">(m_treeView->model());</functiontreemodel>

  if (m_objectHandle) {

    assert(m_xshHandle);

    TXsheet *xsh = m_xshHandle->getXsheet();

    const TStageObjectId &objId = m_objectHandle->getObjectId();

    ftm->setCurrentStageObject((objId == TStageObjectId::NoneId)

                                   ? (TStageObject *)0

                                   : xsh->getStageObject(objId));

  }

  if (m_fxHandle) ftm->setCurrentFx(m_fxHandle->getFx());

  onPreferenceChanged("");

}

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

void FunctionViewer::hideEvent(QHideEvent *) {

  if (m_xshHandle) m_xshHandle->disconnect(this);

  if (m_frameHandle) {

    m_frameHandle->disconnect(this);

    m_frameHandle->disconnect(m_toolbar);

  }

  if (m_objectHandle) m_objectHandle->disconnect(this);

  if (m_fxHandle) m_fxHandle->disconnect(this);

  if (m_sceneHandle) m_sceneHandle->disconnect(this);

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowGraphEditorInPopup) {

    if (m_functionGraph->isVisible()) m_functionGraph->hide();

  }

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup) {

    if (m_numericalColumns->isVisible()) m_numericalColumns->hide();

  }

}

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

void FunctionViewer::openContextMenu(TreeModel::Item *item,

                                     const QPoint &globalPos) {

  m_treeView->openContextMenu(item, globalPos);

}

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

void FunctionViewer::rebuildModel() {

  getSelection()->selectNone();

  onCurveSelected(0);

  m_functionGraph->getModel()->resetAll();

  refreshModel();

  m_treeView->displayAnimatedChannels();

}

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

void FunctionViewer::refreshModel() {

  TXsheet *xsh = m_xshHandle ? m_xshHandle->getXsheet() : 0;

  m_functionGraph->getModel()->refreshData(xsh);

  if (xsh) {

    int rowCount = xsh->getFrameCount();

    m_numericalColumns->setRowCount(rowCount);

    m_numericalColumns->updateAll();

    ToonzScene *scene = xsh->getScene();

    if (!scene)  // This seems wrong. It should rather be

      return;    // asserted - though I'm not touching it now...

    TFilePath scenePath = scene->getScenePath().getParentDir();

    if (scene->isUntitled())

      scenePath =

          TProjectManager::instance()->getCurrentProject()->getScenesPath();

    m_treeView->setCurrentScenePath(scenePath);

    int distance, offset, secDistance;

    scene->getProperties()->getMarkers(distance, offset, secDistance);

    m_numericalColumns->setMarkRow(distance, offset, secDistance);

  }

  m_treeView->updateAll();

  m_toolbar->setCurve(0);

}

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

void FunctionViewer::setXsheetHandle(TXsheetHandle *xshHandle) {

  if (xshHandle == m_xshHandle) return;

  if (m_xshHandle) m_xshHandle->disconnect(this);

  m_xshHandle = xshHandle;

  m_segmentViewer->setXsheetHandle(xshHandle);

  m_treeView->setXsheetHandle(xshHandle);

  m_numericalColumns->setXsheetHandle(xshHandle);

  if (m_xshHandle && isVisible()) {

    TXsheet *xsh = m_xshHandle->getXsheet();

    m_functionGraph->getModel()->refreshData(xsh);

    bool ret = connect(m_xshHandle, SIGNAL(xsheetChanged()), this,

                       SLOT(refreshModel()));

    assert(ret);

  }

}

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

void FunctionViewer::setFrameHandle(TFrameHandle *frameHandle) {

  if (m_frameHandle == frameHandle) return;

  if (m_frameHandle) m_frameHandle->disconnect(this);

  m_frameHandle = frameHandle;

  if (m_frameHandle && isVisible()) {

    bool ret = connect(m_frameHandle, SIGNAL(frameSwitched()), this,

                       SLOT(propagateExternalSetFrame()));

    assert(ret);

  }

}

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

void FunctionViewer::setObjectHandle(TObjectHandle *objectHandle) {

  if (objectHandle == m_objectHandle) return;

  if (m_objectHandle) m_objectHandle->disconnect(this);

  m_objectHandle = objectHandle;

  if (m_objectHandle && isVisible()) {

    m_treeView->updateAll();

    bool ret = true;

    ret      = connect(m_objectHandle, SIGNAL(objectSwitched()), this,

                       SLOT(onStageObjectSwitched())) &&

          ret;

    ret = connect(m_objectHandle, SIGNAL(objectChanged(bool)), this,

                  SLOT(onStageObjectChanged(bool))) &&

          ret;

    assert(ret);

  }

  FunctionTreeModel *ftModel =

      static_cast<functiontreemodel *="">(m_treeView->model());</functiontreemodel>

  if (ftModel) ftModel->setObjectHandle(objectHandle);

}

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

void FunctionViewer::setFxHandle(TFxHandle *fxHandle) {

  if (fxHandle == m_fxHandle) return;

  if (m_fxHandle) m_fxHandle->disconnect(this);

  m_fxHandle = fxHandle;

  if (isVisible()) {

    m_treeView->updateAll();

    bool ret =

        connect(m_fxHandle, SIGNAL(fxSwitched()), this, SLOT(onFxSwitched()));

    assert(ret);

  }

  FunctionTreeModel *ftModel =

      static_cast<functiontreemodel *="">(m_treeView->model());</functiontreemodel>

  if (ftModel) ftModel->setFxHandle(fxHandle);

}

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

void FunctionViewer::setColumnHandle(TColumnHandle *columnHandle) {

  if (columnHandle == m_columnHandle) return;

  m_columnHandle = columnHandle;

  if (isVisible()) m_treeView->updateAll();

}

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

void FunctionViewer::onFrameSwitched() {

  int frame = m_localFrame.getFrame();

  m_segmentViewer->setSegmentByFrame(m_curve, frame);

  if (m_frameHandle) m_frameHandle->setFrame(frame);

}

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

void FunctionViewer::toggleMode() {

  if (isHidden()) return;

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowGraphEditorInPopup) {

    if (m_functionGraph->isVisible()) {

      m_functionGraph->hide();

    } else {

      m_functionGraph->show();

    }

  } else if (m_toggleStart == Preferences::FunctionEditorToggle::

                                  ShowFunctionSpreadsheetInPopup) {

    if (m_numericalColumns->isVisible()) {

      m_numericalColumns->hide();

    } else {

      m_numericalColumns->show();

    }

  } else if (m_toggleStart == Preferences::FunctionEditorToggle::

                                  ToggleBetweenGraphAndSpreadsheet) {

    if (m_functionGraph->isVisible()) {

      m_functionGraph->hide();

      m_numericalColumns->show();

      bool toolBarVisible =

          Preferences::instance()->isShowXSheetToolbarEnabled() &&

          Preferences::instance()->isExpandFunctionHeaderEnabled();

      if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem()) {

        spacer->changeSize(1, m_spacing + ((toolBarVisible) ? 10 : 0),

                           QSizePolicy::Fixed, QSizePolicy::Fixed);

        spacer->invalidate();

        m_numericalColumns->updateHeaderHeight();

        m_leftLayout->setSpacing(0);

      } else

        m_leftLayout->setSpacing(m_spacing + ((toolBarVisible) ? 30 : 0));

      updateGeometry();

      m_toggleStatus = 0;

    } else {

      m_functionGraph->show();

      m_numericalColumns->hide();

      m_leftLayout->setSpacing(0);

      if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem()) {

        spacer->changeSize(0, 0);

        spacer->invalidate();

      }

      m_toggleStatus = 1;

    }

  }

}

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

void FunctionViewer::onCurveChanged(bool isDragging) {

  if (m_objectHandle) m_objectHandle->notifyObjectIdChanged(isDragging);

  // emit signal if the current channel belongs to Fx in order to update the

  // preview fx

  if (m_fxHandle) {

    FunctionTreeModel *ftModel =

        dynamic_cast<functiontreemodel *="">(m_treeView->model());</functiontreemodel>

    if (ftModel) {

      FunctionTreeModel::Channel *currChan = ftModel->getCurrentChannel();

      if (currChan) {

        // カレントチャンネルがFxChannelGroupに含まれていたらEmit

        FxChannelGroup *fxChanGroup =

            dynamic_cast<fxchannelgroup *="">(currChan->getChannelGroup());</fxchannelgroup>

        if (fxChanGroup) m_fxHandle->notifyFxChanged();

      }

    }

  }

}

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

void FunctionViewer::onCurveSelected(TDoubleParam *curve) {

  m_curve = curve;

  m_toolbar->setCurve(curve);

  QPair<tdoubleparam *,="" int=""> selectedSegment =</tdoubleparam>

      getSelection()->getSelectedSegment();

  if (selectedSegment.first)

    m_segmentViewer->setSegment(selectedSegment.first, selectedSegment.second);

  else

    m_segmentViewer->setSegment(m_curve, -1);

}

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

void FunctionViewer::onValueFieldChanged() {}

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

void FunctionViewer::onXsheetChanged() {

  TXsheet *xsh = m_xshHandle->getXsheet();

  int rowCount = xsh->getFrameCount();

  m_numericalColumns->setRowCount(rowCount);

}

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

void FunctionViewer::onStageObjectSwitched() {

  TXsheet *xsh = m_xshHandle->getXsheet();

  const TStageObjectId &objId = m_objectHandle->getObjectId();

  TStageObject *obj           = (objId == TStageObjectId::NoneId)

                                    ? (TStageObject *)0

                                    : xsh->getStageObject(objId);

  static_cast<functiontreemodel *="">(m_treeView->model())</functiontreemodel>

      ->setCurrentStageObject(obj);

  m_treeView->updateAll();

  m_functionGraph->update();

}

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

void FunctionViewer::onStageObjectChanged(bool isDragging) {

  TXsheet *xsh = m_xshHandle->getXsheet();

  const TStageObjectId &objId = m_objectHandle->getObjectId();

  TStageObject *obj           = (objId == TStageObjectId::NoneId)

                                    ? (TStageObject *)0

                                    : xsh->getStageObject(objId);

  static_cast<functiontreemodel *="">(m_treeView->model())</functiontreemodel>

      ->setCurrentStageObject(obj);

  if (!isDragging) {

    m_treeView->updateAll();

    m_numericalColumns->updateAll();

  }

  m_functionGraph->update();

}

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

void FunctionViewer::onFxSwitched() {

  TFx *fx              = m_fxHandle->getFx();

  TZeraryColumnFx *zfx = dynamic_cast<tzerarycolumnfx *="">(fx);</tzerarycolumnfx>

  if (zfx) fx = zfx->getZeraryFx();

  static_cast<functiontreemodel *="">(m_treeView->model())->setCurrentFx(fx);</functiontreemodel>

  m_treeView->updateAll();

  m_functionGraph->update();

}

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

void FunctionViewer::onSelectionChanged() {

  QPair<tdoubleparam *,="" int=""> selectedSegment =</tdoubleparam>

      getSelection()->getSelectedSegment();

  if (selectedSegment.first) {

    if (selectedSegment.first != m_curve) {

      m_curve = selectedSegment.first;

      m_toolbar->setCurve(selectedSegment.first);

    }

    m_segmentViewer->setSegment(selectedSegment.first, selectedSegment.second);

  } else {

    m_segmentViewer->setSegment(m_curve, -1);

  }

  // update curves

  if (m_functionGraph->isVisible() && !m_functionGraph->hasFocus())

    m_functionGraph->update();

}

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

void FunctionViewer::doSwitchCurrentObject(TStageObject *obj) {

  TStageObjectId id = obj->getId();

  if (id.isColumn())

    m_columnHandle->setColumnIndex(id.getIndex());

  else

    m_objectHandle->setObjectId(id);

}

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

void FunctionViewer::onPreferenceChanged(const QString &prefName) {

  if (prefName != "XSheetToolbar" && !prefName.isEmpty()) return;

  if (!Preferences::instance()->isExpandFunctionHeaderEnabled()) return;

  if (m_toggleStart ==

      Preferences::FunctionEditorToggle::ShowFunctionSpreadsheetInPopup)

    return;

  if (m_toggleStart ==

          Preferences::FunctionEditorToggle::ToggleBetweenGraphAndSpreadsheet &&

      m_toggleStatus == 1) {

    m_numericalColumns->hide();

    m_functionGraph->show();

    m_leftLayout->setSpacing(0);

    if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem()) {

      spacer->changeSize(0, 0);

      spacer->invalidate();

    }

    return;

  }

  // spreadsheet is shown

  bool toolBarVisible =

      Preferences::instance()->isShowXSheetToolbarEnabled() &&

      Preferences::instance()->isExpandFunctionHeaderEnabled();

  m_functionGraph->hide();

  m_numericalColumns->show();

  if (QSpacerItem *spacer = m_leftLayout->itemAt(0)->spacerItem()) {

    spacer->changeSize(1, m_spacing + ((toolBarVisible) ? 10 : 0),

                       QSizePolicy::Fixed, QSizePolicy::Fixed);

    spacer->invalidate();

    m_numericalColumns->updateHeaderHeight();

    m_leftLayout->setSpacing(0);

  } else

    m_leftLayout->setSpacing(m_spacing + ((toolBarVisible) ? 30 : 0));

  updateGeometry();

}

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

void FunctionViewer::doSwitchCurrentFx(TFx *fx) {

  if (!fx) {

    m_fxHandle->setFx(0);

    return;

  }

  if (fx->isZerary()) {

    TXsheet *xsh = m_xshHandle->getXsheet();

    int i, columnCount = xsh->getColumnCount();

    for (i = 0; i < columnCount; i++) {

      TXshColumn *column = xsh->getColumn(i);

      TXshZeraryFxColumn *zfx =

          dynamic_cast<txshzeraryfxcolumn *="">(xsh->getColumn(i));</txshzeraryfxcolumn>

      if (!zfx) continue;

      if (zfx->getZeraryColumnFx()->getZeraryFx() == fx) {

        fx = zfx->getZeraryColumnFx();

        m_columnHandle->setColumnIndex(i);

        break;

      }

    }

  }

  // Forbid update of the swatch upon column switch. This would generate

  // a useless render...

  SwatchViewer::suspendRendering(true, false);

  int columnIndex = fx->getReferenceColumnIndex();

  if (columnIndex >= 0) m_columnHandle->setColumnIndex(columnIndex);

  SwatchViewer::suspendRendering(false);

  m_fxHandle->setFx(fx);

  emit editObject();

}

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

void FunctionViewer::propagateExternalSetFrame() {

  assert(m_frameHandle);

  m_localFrame.setFrame(m_frameHandle->getFrame());

}

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

void FunctionViewer::addParameter(TParam *parameter, const TFilePath &folder) {

  static_cast<functiontreemodel *="">(m_treeView->model())</functiontreemodel>

      ->addParameter(parameter, folder);

}

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

void FunctionViewer::setFocusColumnsOrGraph() {

  m_numericalColumns->setFocus();

}

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

void FunctionViewer::clearFocusColumnsAndGraph() {

  m_functionGraph->clearFocus();

  m_numericalColumns->clearFocus();

}

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

bool FunctionViewer::columnsOrGraphHasFocus() {

  return m_functionGraph->hasFocus() ||

         m_numericalColumns->anyWidgetHasFocus() ||

         m_toolbar->anyWidgetHasFocus() || m_segmentViewer->anyWidgetHasFocus();

}

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

void FunctionViewer::setSceneHandle(TSceneHandle *sceneHandle) {

  m_sceneHandle = sceneHandle;

}

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

bool FunctionViewer::isExpressionPageActive() {

  return m_segmentViewer->isExpressionPageActive();

}

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

void FunctionViewer::save(QSettings &settings) const {

  settings.setValue("toggleStatus", m_toggleStatus);

  settings.setValue("showIbtwnValuesInSheet",

                    m_numericalColumns->isIbtwnValueVisible());

  settings.setValue("syncSize", m_numericalColumns->isSyncSize());

}

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

void FunctionViewer::load(QSettings &settings) {

  QVariant toggleStatus = settings.value("toggleStatus");

  if (toggleStatus.canConvert(QVariant::Int)) {

    m_toggleStatus = toggleStatus.toInt();

  }

  bool ibtwnVisible = settings

                          .value("showIbtwnValuesInSheet",

                                 m_numericalColumns->isIbtwnValueVisible())

                          .toBool();

  m_numericalColumns->setIbtwnValueVisible(ibtwnVisible);

  bool syncSize =

      settings.value("syncSize", m_numericalColumns->isSyncSize()).toBool();

  m_numericalColumns->setSyncSize(syncSize);

}

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

QColor FunctionViewer::getCurrentTextColor() const {

  // get colors

  TPixel currentColumnPixel;

  Preferences::instance()->getCurrentColumnData(currentColumnPixel);

  QColor currentColumnColor((int)currentColumnPixel.r,

                            (int)currentColumnPixel.g,

                            (int)currentColumnPixel.b, 255);

  return currentColumnColor;

}