#include "toonzqt/spreadsheetviewer.h"

#include "toonzqt/gutil.h"

#include "toonz/tframehandle.h"

#include <qkeyevent></qkeyevent>

#include <qwheelevent></qwheelevent>

#include <qlabel></qlabel>

#include <qscrollbar></qscrollbar>

#include <qpainter></qpainter>

#include <qgridlayout></qgridlayout>

#include <qpaintevent></qpaintevent>

#include <qtooltip></qtooltip>

#include <assert.h></assert.h>

#include <qmainwindow></qmainwindow>

#include <qdockwidget></qdockwidget>

namespace Spreadsheet

{

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

FrameScroller::FrameScroller()

{

}

FrameScroller::~FrameScroller()

{

}

void FrameScroller::connectScroller(FrameScroller *scroller)

{

	if (scroller != this && !m_connectedScrollers.contains(scroller)) {

		m_connectedScrollers.append(scroller);

		scroller->connectScroller(this);

		QScrollBar *sb0 = getFrameScrollArea()->verticalScrollBar();

		QScrollBar *sb1 = scroller->getFrameScrollArea()->verticalScrollBar();

		QObject::connect(sb0, SIGNAL(valueChanged(int)), sb1, SLOT(setValue(int)));

		QObject::connect(sb1, SIGNAL(valueChanged(int)), sb0, SLOT(setValue(int)));

	}

}

void FrameScroller::disconnectScroller(FrameScroller *scroller)

{

	if (m_connectedScrollers.contains(scroller)) {

		m_connectedScrollers.removeAll(scroller);

		scroller->disconnectScroller(this);

		QScrollBar *sb0 = getFrameScrollArea()->verticalScrollBar();

		QScrollBar *sb1 = scroller->getFrameScrollArea()->verticalScrollBar();

		QObject::disconnect(sb0, SIGNAL(valueChanged(int)), sb1, SLOT(setValue(int)));

		QObject::disconnect(sb1, SIGNAL(valueChanged(int)), sb0, SLOT(setValue(int)));

	}

}

bool FrameScroller::isScrollerConnected(FrameScroller *scroller)

{

	return m_connectedScrollers.contains(scroller);

}

static QList<framescroller *=""> frameScrollers;</framescroller>

void FrameScroller::registerFrameScroller()

{

	if (!frameScrollers.contains(this)) {

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

			connectScroller(frameScrollers[i]);

		frameScrollers.append(this);

	}

}

void FrameScroller::unregisterFrameScroller()

{

	if (frameScrollers.contains(this)) {

		frameScrollers.removeAll(this);

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

			disconnectScroller(frameScrollers[i]);

	}

}

void FrameScroller::prepareToScroll(int dy)

{

	if (dy == 0)

		return;

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

		if (frameScrollers[i] != this)

			frameScrollers[i]->onPrepareToScroll(dy);

}

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

void SetFrameDragTool::click(int row, int col, QMouseEvent *e)

{

	m_frameHandle->setFrame(row);

}

void SetFrameDragTool::drag(int row, int col, QMouseEvent *e)

{

	if (row < 0)

		row = 0;

	m_frameHandle->setFrame(row);

}

void SetFrameDragTool::release(int row, int col, QMouseEvent *e)

{

}

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

//

// SelectionDragTool

//

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

SelectionDragTool::SelectionDragTool(SpreadsheetViewer *viewer)

	: m_viewer(viewer), m_firstRow(-1), m_firstCol(-1)

{

}

void SelectionDragTool::click(int row, int col, QMouseEvent *e)

{

	m_firstCol = col;

	m_firstRow = row;

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

	m_viewer->selectCells(selectedCells);

}

void SelectionDragTool::drag(int row, int col, QMouseEvent *e)

{

	int r0 = qMin(row, m_firstRow);

	int r1 = qMax(row, m_firstRow);

	int c0 = qMin(col, m_firstCol);

	int c1 = qMax(col, m_firstCol);

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

	m_viewer->selectCells(selectedCells);

}

void SelectionDragTool::release(int row, int col, QMouseEvent *e)

{

}

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

PanTool::PanTool(Spreadsheet::GenericPanel *panel)

	: m_panel(panel), m_viewer(panel->getViewer()), m_lastPos()

{

}

void PanTool::click(int row, int col, QMouseEvent *e)

{

	m_lastPos = e->pos(); // m_panel->mapToGlobal(e->pos());

}

void PanTool::drag(int row, int col, QMouseEvent *e)

{

	QPoint pos = e->pos(); // m_panel->mapToGlobal(e->pos());

	//QPoint delta = p - m_lastPos;

	//m_lastPos = p;

	// QToolTip::showText(p,"delta="+QString::number(delta.x())+","+QString::number(delta.y()));

	m_viewer->scroll(m_lastPos - pos);

}

void PanTool::release(int row, int col, QMouseEvent *e)

{

	//QToolTip::hideText();

}

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

#if QT_VERSION >= 0x050500

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

#else

ScrollArea::ScrollArea(QWidget *parent, Qt::WFlags flags)

#endif

	: QScrollArea(parent)

{

	setFrameStyle(QFrame::Panel | QFrame::Raised);

	setLineWidth(6);

	setContentsMargins(10, 10, 10, 10);

}

ScrollArea::~ScrollArea()

{

}

void ScrollArea::keyPressEvent(QKeyEvent *e)

{

	e->ignore();

}

void ScrollArea::wheelEvent(QWheelEvent *e)

{

	e->ignore();

}

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

GenericPanel::GenericPanel(SpreadsheetViewer *viewer)

	: QWidget(viewer), m_viewer(viewer), m_dragTool(0)

{

	setFocusPolicy(Qt::NoFocus);

}

GenericPanel::~GenericPanel()

{

}

void GenericPanel::paintEvent(QPaintEvent *e)

{

	QPainter p(this);

	p.setPen(m_viewer->getLightLineColor());

	for (int c = 0;; c++) {

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

		if (x > width())

			break;

		p.drawLine(x, 0, x, height());

	}

	for (int r = 0;; r++) {

		int y = getViewer()->rowToY(r);

		if (y > height())

			break;

		p.drawLine(0, y, width(), y);

	}

	p.setPen(Qt::magenta);

	p.drawLine(e->rect().topLeft(), e->rect().bottomRight());

}

void GenericPanel::mousePressEvent(QMouseEvent *e)

{

	assert(!m_dragTool);

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

		m_dragTool = new PanTool(this);

	else

		m_dragTool = createDragTool(e);

	int row = getViewer()->yToRow(e->pos().y());

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

	if (m_dragTool)

		m_dragTool->click(row, col, e);

}

void GenericPanel::mouseReleaseEvent(QMouseEvent *e)

{

	int row = getViewer()->yToRow(e->pos().y());

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

	m_viewer->stopAutoPan();

	if (m_dragTool) {

		m_dragTool->release(row, col, e);

		delete m_dragTool;

		m_dragTool = 0;

	}

}

void GenericPanel::mouseMoveEvent(QMouseEvent *e)

{

	int row = getViewer()->yToRow(e->pos().y());

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

	if (e->buttons() != 0 && m_dragTool != 0) {

		if ((e->buttons() & Qt::LeftButton) != 0 && !visibleRegion().contains(e->pos())) {

			QRect bounds = visibleRegion().boundingRect();

			m_viewer->setAutoPanSpeed(bounds, e->pos());

		} else

			m_viewer->stopAutoPan();

		m_dragTool->drag(row, col, e);

	}

}

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

RowPanel::RowPanel(SpreadsheetViewer *viewer)

	: GenericPanel(viewer), m_xa(12)

{

}

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

DragTool *RowPanel::createDragTool(QMouseEvent *)

{

	TFrameHandle *frameHandle = getViewer()->getFrameHandle();

	if (frameHandle)

		return new SetFrameDragTool(frameHandle);

	else

		return 0;

}

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

void RowPanel::drawRows(QPainter &p, int r0, int r1)

{

#ifdef WIN32

	static QFont font("Arial", 9, QFont::Bold);

#else

	static QFont font("Helvetica", 9, QFont::Bold);

#endif

	p.setFont(font);

	QRect visibleRect = visibleRegion().boundingRect();

	int x0 = visibleRect.left();

	int x1 = visibleRect.right();

	int y0 = visibleRect.top();

	int y1 = visibleRect.bottom();

	int r;

	for (r = r0; r <= r1; r++) {

		int y = getViewer()->rowToY(r);

		//draw horizontal line

		QColor color = (getViewer()->isMarkRow(r)) ? getViewer()->getMarkerLineColor() : getViewer()->getLightLineColor();

		p.setPen(color);

		p.drawLine(x0, y, x1, y);

		//draw numbers

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

		QString number = QString::number(r + 1);

		p.drawText(QRect(x0, y + 1, width(), 18), Qt::AlignHCenter | Qt::AlignBottom, number);

	}

	// erase the marker interval at upper-end

	if (r0 == 0) {

		p.setPen(getViewer()->getLightLineColor());

		p.drawLine(x0, getViewer()->rowToY(0), x1, getViewer()->rowToY(0));

	}

}

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

void RowPanel::drawCurrentRowGadget(QPainter &p, int r0, int r1)

{

	int currentRow = getViewer()->getCurrentRow();

	int y = getViewer()->rowToY(currentRow);

	if (currentRow < r0 || r1 < currentRow)

		return;

	p.fillRect(1, y + 1, width() - 2, 19, getViewer()->getCurrentRowBgColor());

}

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

void RowPanel::paintEvent(QPaintEvent *e)

{

	QRect toBeUpdated = e->rect();

	QPainter p(this);

	// range di righe visibili

	int r0 = getViewer()->yToRow(toBeUpdated.top());

	int r1 = getViewer()->yToRow(toBeUpdated.bottom());

	p.setClipRect(toBeUpdated);

	p.fillRect(toBeUpdated, QBrush(getViewer()->getLightLightBGColor()));

	drawCurrentRowGadget(p, r0, r1);

	drawRows(p, r0, r1);

}

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

ColumnPanel::ColumnPanel(SpreadsheetViewer *viewer)

	: GenericPanel(viewer)

{

}

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

CellPanel::CellPanel(SpreadsheetViewer *viewer)

	: GenericPanel(viewer)

{

}

DragTool *CellPanel::createDragTool(QMouseEvent *)

{

	// FunctionSheetCellViewer::createDragTool is called instead

	// when clicking on the CellPanel in NumericalColumns

	return new SelectionDragTool(getViewer());

}

void CellPanel::paintEvent(QPaintEvent *e)

{

	QPainter painter(this);

	QRect toBeUpdated = e->rect();

	painter.setClipRect(toBeUpdated);

	int x0 = toBeUpdated.left() - 1;

	int y0 = toBeUpdated.top();

	int x1 = toBeUpdated.right(), y1 = toBeUpdated.bottom();

	// visible rows range

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

	int r1 = getViewer()->yToRow(y1);

	// visible columns range

	int c0 = getViewer()->xToColumn(x0);

	int c1 = getViewer()->xToColumn(x1);

	// cambia colore alle celle prima di rowCount()

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

	//fill with bg color

	painter.fillRect(toBeUpdated, getViewer()->getLightLightBGColor());

	//scene range bg

	int yLast = getViewer()->rowToY(rowCount);

	if (yLast < y1)

		painter.fillRect(x0, y0, x1 - x0, yLast - y0, getViewer()->getBGColor());

	else

		painter.fillRect(toBeUpdated, getViewer()->getBGColor());

	//draw cells

	drawCells(painter, r0, c0, r1, c1);

	// draw columns

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

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

		int x = getViewer()->columnToX(col);

		painter.drawLine(x, y0, x, y1);

	}

	// draw rows

	int currentRow = getViewer()->getCurrentRow();

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

		int y = getViewer()->rowToY(r);

		QColor color = getViewer()->isMarkRow(r) ? getViewer()->getMarkerLineColor() : getViewer()->getLightLineColor();

		painter.setPen(color);

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

	}

	// erase the marker interval at upper-end

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

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

}

} // namespace Spreadsheet

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

SpreadsheetViewer::SpreadsheetViewer(QWidget *parent)

	: QFrame(parent), m_columnScrollArea(0), m_rowScrollArea(0), m_cellScrollArea(0), m_frameHandle(0), m_columnWidth(50), m_rowHeight(20), m_timerId(0), m_autoPanSpeed(0, 0), m_lastAutoPanPos(0, 0), m_rowCount(0), m_columnCount(0), m_currentRow(0), m_markRowDistance(6), m_markRowOffset(0), m_isComputingSize(false)

{

	setFocusPolicy(Qt::NoFocus);

	setFrameStyle(QFrame::StyledPanel);

	setObjectName("Viewer");

	//column header

	m_columnScrollArea = new Spreadsheet::ScrollArea;

	m_columnScrollArea->setObjectName("ScrollArea");

	m_columnScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	m_columnScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	m_columnScrollArea->setFocusPolicy(Qt::NoFocus);

	//row area

	m_rowScrollArea = new Spreadsheet::ScrollArea;

	m_rowScrollArea->setObjectName("ScrollArea");

	m_rowScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	m_rowScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	m_rowScrollArea->setFocusPolicy(Qt::NoFocus);

	//cell area

	m_cellScrollArea = new Spreadsheet::ScrollArea;

	m_cellScrollArea->setObjectName("ScrollArea");

	m_cellScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

	m_cellScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

	m_cellScrollArea->horizontalScrollBar()->setObjectName("XsheetScrollBar");

	m_cellScrollArea->verticalScrollBar()->setObjectName("XsheetScrollBar");

	m_cellScrollArea->setFocusPolicy(Qt::NoFocus);

	m_columnScrollArea->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));

	m_rowScrollArea->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored));

	m_rowScrollArea->setFixedWidth(30);

	m_columnScrollArea->setFixedHeight(m_rowHeight * 3 - 3);

	//m_columnScrollArea->setFixedHeight(m_rowHeight * 3 + 60 - 63);

	//---- layout

	QGridLayout *layout = new QGridLayout();

	layout->setMargin(0);

	layout->setSpacing(0);

	{

		layout->addWidget(m_columnScrollArea, 0, 1);

		layout->addWidget(m_rowScrollArea, 1, 0);

		layout->addWidget(m_cellScrollArea, 1, 1, 2, 2);

		//upper-right

		QWidget *w = new QWidget(this);

		w->setFixedSize(QSize(20, m_rowHeight * 3 + 60 - 63));

		layout->addWidget(w, 0, 2);

		//lower-left

		w = new QWidget(this);

		w->setFixedSize(QSize(30, 20));

		layout->addWidget(w, 2, 0);

		layout->setColumnStretch(0, 0);

		layout->setColumnStretch(1, 1);

		layout->setColumnStretch(2, 0);

		layout->setRowStretch(0, 0);

		layout->setRowStretch(1, 1);

		layout->setRowStretch(2, 0);

	}

	setLayout(layout);

	//---signal-slot connections

	// vertical slider: cell <=> row

	connect(m_rowScrollArea->verticalScrollBar(), SIGNAL(valueChanged(int)),

			m_cellScrollArea->verticalScrollBar(), SLOT(setValue(int)));

	connect(m_cellScrollArea->verticalScrollBar(), SIGNAL(valueChanged(int)),

			m_rowScrollArea->verticalScrollBar(), SLOT(setValue(int)));

	// horizontal slider: cell <=> column

	connect(m_columnScrollArea->horizontalScrollBar(), SIGNAL(valueChanged(int)),

			m_cellScrollArea->horizontalScrollBar(), SLOT(setValue(int)));

	connect(m_cellScrollArea->horizontalScrollBar(), SIGNAL(valueChanged(int)),

			m_columnScrollArea->horizontalScrollBar(), SLOT(setValue(int)));

	connect(m_cellScrollArea->verticalScrollBar(), SIGNAL(valueChanged(int)),

			SLOT(onVSliderChanged(int)));

	connect(m_cellScrollArea->horizontalScrollBar(), SIGNAL(valueChanged(int)),

			SLOT(onHSliderChanged(int)));

}

SpreadsheetViewer::~SpreadsheetViewer()

{

}

void SpreadsheetViewer::setFrameHandle(TFrameHandle *frameHandle)

{

	if (m_frameHandle == frameHandle)

		return;

	if (m_frameHandle)

		m_frameHandle->disconnect(this);

	m_frameHandle = frameHandle;

	if (isVisible() && m_frameHandle) {

		connect(m_frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));

		update();

	}

}

void SpreadsheetViewer::setRowsPanel(Spreadsheet::RowPanel *rows)

{

	m_rowScrollArea->setWidget(rows);

}

void SpreadsheetViewer::setColumnsPanel(Spreadsheet::ColumnPanel *columns)

{

	m_columnScrollArea->setWidget(columns);

	// columns->setFixedHeight(200);

}

void SpreadsheetViewer::setCellsPanel(Spreadsheet::CellPanel *cells)

{

	m_cellScrollArea->setWidget(cells);

}

void SpreadsheetViewer::setRowCount(int rowCount)

{

	if (m_rowCount != rowCount) {

		m_rowCount = rowCount;

		refreshContentSize(0, 0);

	}

}

void SpreadsheetViewer::setColumnCount(int columnCount)

{

	if (m_columnCount != columnCount) {

		m_columnCount = columnCount;

		refreshContentSize(0, 0);

	}

}

void SpreadsheetViewer::scroll(QPoint delta)

{

	refreshContentSize(delta.x(), delta.y());

	prepareToScroll(delta.y());

	if (delta.y() != 0) {

		QScrollBar *vSc = m_cellScrollArea->verticalScrollBar();

		vSc->setValue(vSc->value() + delta.y());

	}

	if (delta.x() != 0) {

		QScrollBar *hSc = m_cellScrollArea->horizontalScrollBar();

		hSc->setValue(hSc->value() + delta.x());

	}

}

void SpreadsheetViewer::setAutoPanSpeed(const QPoint &speed)

{

	bool wasAutoPanning = isAutoPanning();

	m_autoPanSpeed = speed;

	if (isAutoPanning() && !wasAutoPanning && m_timerId == 0)

		m_timerId = startTimer(40);

	else if (!isAutoPanning() && wasAutoPanning && m_timerId != 0) {

		killTimer(m_timerId);

		m_timerId = 0;

	}

}

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

int getAutoPanSpeed(int pixels)

{

	int f = 40;

	return tmin(100, (f - 1 + pixels * f) / 100);

}

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

void SpreadsheetViewer::setAutoPanSpeed(const QRect &widgetBounds, const QPoint &mousePos)

{

	QPoint speed;

	int limit = 100, factor = 30;

	if (mousePos.x() < widgetBounds.left())

		speed.setX(-getAutoPanSpeed(widgetBounds.left() - mousePos.x()));

	else if (mousePos.x() > widgetBounds.right())

		speed.setX(getAutoPanSpeed(mousePos.x() - widgetBounds.right()));

	if (mousePos.y() < widgetBounds.top())

		speed.setY(-getAutoPanSpeed(widgetBounds.top() - mousePos.y()));

	else if (mousePos.y() > widgetBounds.bottom())

		speed.setY(getAutoPanSpeed(mousePos.y() - widgetBounds.bottom()));

	setAutoPanSpeed(speed);

	m_lastAutoPanPos = mousePos;

}

/*!Shift is a consequence of style sheet border.*/

int SpreadsheetViewer::xToColumn(int x) const

{

	return (x + 1) / m_columnWidth;

}

/*!Shift is a consequence of style sheet border.*/

int SpreadsheetViewer::columnToX(int col) const

{

	return (col * m_columnWidth) - 1;

}

/*!Shift is a consequence of style sheet border.*/

int SpreadsheetViewer::yToRow(int y) const

{

	return (y + 1) / m_rowHeight;

}

/*!Shift is a consequence of style sheet border.*/

int SpreadsheetViewer::rowToY(int row) const

{

	return (row * m_rowHeight) - 1;

}

bool SpreadsheetViewer::refreshContentSize(int scrollDx, int scrollDy)

{

	QSize viewportSize = m_cellScrollArea->viewport()->size();

	QPoint offset = m_cellScrollArea->widget()->pos();

	offset = QPoint(qMin(0, offset.x() - scrollDx), qMin(0, offset.y() - scrollDy));

	QSize contentSize(columnToX(m_columnCount + 1), rowToY(m_rowCount + 1));

	QSize actualSize(contentSize);

	int x = viewportSize.width() - offset.x();

	int y = viewportSize.height() - offset.y();

	if (x > actualSize.width())

		actualSize.setWidth(x);

	if (y > actualSize.height())

		actualSize.setHeight(y);

	if (actualSize == m_cellScrollArea->widget()->size())

		return false;

	else {

		m_isComputingSize = true;

		m_cellScrollArea->widget()->setFixedSize(actualSize);

		m_rowScrollArea->widget()->setFixedSize(

			m_rowScrollArea->viewport()->width(),

			actualSize.height());

		m_columnScrollArea->widget()->setFixedSize(

			actualSize.width(),

			m_columnScrollArea->viewport()->height());

		m_isComputingSize = false;

		return true;

	}

}

void SpreadsheetViewer::showEvent(QShowEvent *)

{

	int viewportHeight = m_cellScrollArea->height();

	int contentHeight = rowToY(m_rowCount * 0 + 50);

	QScrollBar *vSc = m_cellScrollArea->verticalScrollBar();

	int actualContentHeight = qMax(contentHeight, vSc->value() + viewportHeight);

	m_rowScrollArea->widget()->setFixedHeight(actualContentHeight);

	m_cellScrollArea->widget()->setFixedHeight(actualContentHeight);

	if (m_frameHandle)

		connect(m_frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));

	// updateAreasSize();

}

void SpreadsheetViewer::hideEvent(QHideEvent *)

{

	if (m_frameHandle)

		m_frameHandle->disconnect(this);

}

void SpreadsheetViewer::resizeEvent(QResizeEvent *e)

{

	QFrame::resizeEvent(e);

	refreshContentSize(0, 0);

	/*

	int w = width();

	int h = height();

  int hSpacing = 4;

  int vSpacing = 4;

  int x = m_rowScrollAreaWidth + hSpacing;

  int y = m_columnScrollAreaHeight + vSpacing;

	m_cellScrollArea->setGeometry(x,y, w-x, h-y);

  int sh = m_cellScrollArea->horizontalScrollBar()->height();

  int sw = m_cellScrollArea->verticalScrollBar()->width();

	m_columnScrollArea->setGeometry(x, 0, w-x-sw, m_columnScrollAreaHeight);

  m_rowScrollArea->setGeometry(0, y, m_rowScrollAreaWidth, h-y-sh);

  updateSizeToScroll(0,0); //Non updateAreeSize() perche' si deve tener conto degli scrollbar.

*/

}

void SpreadsheetViewer::wheelEvent(QWheelEvent *e)

{

	scroll(QPoint(0, -e->delta()));

}

void SpreadsheetViewer::timerEvent(QTimerEvent *e)

{

	if (!isAutoPanning())

		return;

	scroll(m_autoPanSpeed);

	m_lastAutoPanPos += m_autoPanSpeed;

	/*

  if(m_dragTool)

  {

    QMouseEvent mouseEvent(QEvent::MouseMove, m_lastAutoPanPos, Qt::NoButton, 0, 0);

    m_dragTool->onDrag(&mouseEvent);

  }

  */

}

void SpreadsheetViewer::keyPressEvent(QKeyEvent *e)

{

	int frameCount = m_rowCount;

	int row = m_frameHandle->getFrame();

	if (e->key() == Qt::Key_Up && row > 0) { //Row = frame precedente a quello settato

		m_frameHandle->setFrame(row - 1);

		return;

	} else if (e->key() == Qt::Key_Down) { //Row = frame successivo a quello settato

		m_frameHandle->setFrame(row + 1);

		return;

	} else if (e->key() == '0') {

		QWidget *panel = parentWidget();

		QWidget *panelParent = panel->parentWidget();

		while (panelParent != 0 && dynamic_cast<qmainwindow *="">(panelParent) == 0) {</qmainwindow>

			panel = panelParent;

			panelParent = panel->parentWidget();

		}

		if (panelParent) {

			QList<qdockwidget *=""> panels = panelParent->findChildren<qdockwidget *="">();</qdockwidget></qdockwidget>

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

				QWidget *w = panels[i];

			}

		}

		return;

	}

	int y = 0;

	QRect visibleRect = m_cellScrollArea->widget()->visibleRegion().boundingRect();

	int visibleRowCount = visibleRect.height() / m_rowHeight;

	if (e->key() == Qt::Key_PageUp) //Setto la visualizzazione della pagina precedente

		y = visibleRect.top() - (visibleRowCount + 1) * m_rowHeight;

	else if (e->key() == Qt::Key_PageDown) //Setto la visualizzazione della pagina successiva

		y = visibleRect.bottom() + (visibleRowCount + 1) * m_rowHeight;

	else if (e->key() == Qt::Key_Home)

		y = 0;

	else if (e->key() == Qt::Key_End)

		y = (frameCount + 1) * m_rowHeight;

	else

		return;

	int deltaY = 0;

	if (y < visibleRect.top())

		deltaY = y - visibleRect.top();

	else

		deltaY = y - visibleRect.bottom();

	scroll(QPoint(0, deltaY));

}

void SpreadsheetViewer::frameSwitched()

{

}

/*

void SpreadsheetViewer::updateAllAree()

{

}

void SpreadsheetViewer::updateCellColumnAree()

{

}

void SpreadsheetViewer::updateCellRowAree()

{

}

*/

void SpreadsheetViewer::updateAreas()

{

}

void SpreadsheetViewer::onVSliderChanged(int)

{

	if (!m_isComputingSize)

		refreshContentSize(0, 0);

	/*

  QScrollBar *vSc = m_cellScrollArea->verticalScrollBar();

  int h = qMax(vSc->value() + m_cellScrollArea->height(), rowToY(getRowCount()));

  if(m_cellScrollArea->widget())

    m_cellScrollArea->widget()->setFixedHeight(h);

  if(m_rowScrollArea->widget())

    m_rowScrollArea->widget()->setFixedHeight(h);

    */

	/*

  int viewportHeight = m_cellScrollArea->height();

  int contentHeight = rowToY(m_rowCount*0 + 50);

  QScrollBar *vSc = m_cellScrollArea->verticalScrollBar();

  int actualContentHeight = qMax(contentHeight, vSc->value() + viewportHeight);

  m_rowScrollArea->widget()->setFixedHeight(actualContentHeight);

  m_cellScrollArea->widget()->setFixedHeight(actualContentHeight);

*/

}

void SpreadsheetViewer::onHSliderChanged(int)

{

	if (!m_isComputingSize)

		refreshContentSize(0, 0);

}

void SpreadsheetViewer::ensureVisibleCol(int col)

{

	int x = columnToX(col) + m_columnWidth / 2;

	int vertValue = m_cellScrollArea->verticalScrollBar()->value();

	m_cellScrollArea->ensureVisible(x, vertValue, m_columnWidth / 2, 0);

}