#pragma once

#ifndef SPREADSHEETVIEWER_H

#define SPREADSHEETVIEWER_H

#include "tcommon.h"

#include <qframe></qframe>

#include <qscrollarea></qscrollarea>

#undef DVAPI

#undef DVVAR

#ifdef TOONZQT_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

// forward declaration

class TFrameHandle;

class SpreadsheetViewer;

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

namespace Spreadsheet

{

// forward declaration

class GenericPanel;

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

class DVAPI FrameScroller

{

	QList<framescroller *=""> m_connectedScrollers;</framescroller>

public:

	FrameScroller();

	virtual ~FrameScroller();

	void connectScroller(FrameScroller *scroller);

	void disconnectScroller(FrameScroller *scroller);

	bool isScrollerConnected(FrameScroller *scroller);

	virtual QScrollArea *getFrameScrollArea() const = 0;

	void registerFrameScroller();

	void unregisterFrameScroller();

	void prepareToScroll(int dy);

	virtual void onPrepareToScroll(int dy) {}

};

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

class DVAPI DragTool

{

public:

	DragTool() {}

	virtual ~DragTool() {}

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

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

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

};

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

class DVAPI SetFrameDragTool : public DragTool

{

	TFrameHandle *m_frameHandle;

public:

	SetFrameDragTool(TFrameHandle *frameHandle) : m_frameHandle(frameHandle) {}

	void click(int row, int col, QMouseEvent *e);

	void drag(int row, int col, QMouseEvent *e);

	void release(int row, int col, QMouseEvent *e);

};

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

class DVAPI SelectionDragTool : public DragTool

{

	SpreadsheetViewer *m_viewer;

	int m_firstRow, m_firstCol;

public:

	SelectionDragTool(SpreadsheetViewer *viewer);

	void click(int row, int col, QMouseEvent *e);

	void drag(int row, int col, QMouseEvent *e);

	void release(int row, int col, QMouseEvent *e);

};

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

class DVAPI PanTool : public DragTool

{

	SpreadsheetViewer *m_viewer;

	GenericPanel *m_panel;

	QPoint m_lastPos;

public:

	PanTool(GenericPanel *panel);

	void click(int row, int col, QMouseEvent *e);

	void drag(int row, int col, QMouseEvent *e);

	void release(int row, int col, QMouseEvent *e);

};

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

class DVAPI ScrollArea : public QScrollArea

{

	Q_OBJECT

public:

#if QT_VERSION >= 0x050500

	ScrollArea(QWidget *parent = 0, Qt::WindowFlags flags = 0);

#else

	ScrollArea(QWidget *parent = 0, Qt::WFlags flags = 0);

#endif

	virtual ~ScrollArea();

protected:

	// keyPressEvent and wheelEvent are ignored by the ScrollArea

	// and therefore they are handled by the parent (Viewer)

	void keyPressEvent(QKeyEvent *e);

	void wheelEvent(QWheelEvent *e);

};

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

class DVAPI GenericPanel : public QWidget

{

	Q_OBJECT

	SpreadsheetViewer *m_viewer;

	DragTool *m_dragTool;

public:

	GenericPanel(SpreadsheetViewer *viewer);

	virtual ~GenericPanel();

	SpreadsheetViewer *getViewer() const { return m_viewer; }

	virtual DragTool *createDragTool(QMouseEvent *) { return 0; };

protected:

	void paintEvent(QPaintEvent *);

	void mousePressEvent(QMouseEvent *);

	void mouseReleaseEvent(QMouseEvent *);

	void mouseMoveEvent(QMouseEvent *);

};

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

class DVAPI RowPanel : public GenericPanel

{

	Q_OBJECT

	const int m_xa; // frame cells start at m_xa

public:

	RowPanel(SpreadsheetViewer *viewer);

	virtual ~RowPanel() {}

	DragTool *createDragTool(QMouseEvent *);

protected:

	void paintEvent(QPaintEvent *);

	void drawRows(QPainter &p, int r0, int r1);

	void drawCurrentRowGadget(QPainter &p, int r0, int r1);

};

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

class DVAPI ColumnPanel : public GenericPanel

{

	Q_OBJECT

public:

	ColumnPanel(SpreadsheetViewer *viewer);

	virtual ~ColumnPanel() {}

};

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

class DVAPI CellPanel : public GenericPanel

{

	Q_OBJECT

public:

	CellPanel(SpreadsheetViewer *viewer);

	virtual ~CellPanel() {}

	DragTool *createDragTool(QMouseEvent *);

protected:

	void paintEvent(QPaintEvent *);

	virtual void drawCells(QPainter &p, int r0, int c0, int r1, int c1) {}

};

}

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

class DVAPI SpreadsheetViewer : public QFrame, public Spreadsheet::FrameScroller

{

	Q_OBJECT

	QColor m_lightLightBgColor; // RowPanel background (124,124,124)

	QColor m_bgColor;			// RowPanel background in scene range(164,164,164)

	QColor m_lightLineColor;	// horizontal line (146,144,146)

	Q_PROPERTY(QColor LightLightBGColor READ getLightLightBGColor WRITE setLightLightBGColor)

	Q_PROPERTY(QColor BGColor READ getBGColor WRITE setBGColor)

	Q_PROPERTY(QColor LightLineColor READ getLightLineColor WRITE setLightLineColor)

	QColor m_currentRowBgColor; //current frame, column

	QColor m_markerLineColor;   //marker interval (0, 255, 246)

	QColor m_textColor;			//text (black)

	QColor m_verticalLineColor; //vertical line (black)

	Q_PROPERTY(QColor CurrentRowBgColor READ getCurrentRowBgColor WRITE setCurrentRowBgColor)

	Q_PROPERTY(QColor MarkerLineColor READ getMarkerLineColor WRITE setMarkerLineColor)

	Q_PROPERTY(QColor TextColor READ getTextColor WRITE setTextColor)

	Q_PROPERTY(QColor VerticalLineColor READ getVerticalLineColor WRITE setVerticalLineColor)

	//key frame

	QColor m_keyFrameColor;			// (219,139,54)

	QColor m_keyFrameBorderColor;   // (82,51,20)

	QColor m_selectedKeyFrameColor; // (237,197,155)

	//key frame inbetween

	QColor m_inBetweenColor;		 // (194,194,176)

	QColor m_inBetweenBorderColor;   // (72,72,65)

	QColor m_selectedInBetweenColor; // (225,225,216)

	//empty cell

	QColor m_selectedEmptyColor; // (190,190,190)

	//empty cell in the scene range

	QColor m_selectedSceneRangeEmptyColor; // (210,210,210)

	Q_PROPERTY(QColor KeyFrameColor READ getKeyFrameColor WRITE setKeyFrameColor)

	Q_PROPERTY(QColor KeyFrameBorderColor READ getKeyFrameBorderColor WRITE setKeyFrameBorderColor)

	Q_PROPERTY(QColor SelectedKeyFrameColor READ getSelectedKeyFrameColor WRITE setSelectedKeyFrameColor)

	Q_PROPERTY(QColor InBetweenColor READ getInBetweenColor WRITE setInBetweenColor)

	Q_PROPERTY(QColor InBetweenBorderColor READ getInBetweenBorderColor WRITE setInBetweenBorderColor)

	Q_PROPERTY(QColor SelectedInBetweenColor READ getSelectedInBetweenColor WRITE setSelectedInBetweenColor)

	Q_PROPERTY(QColor SelectedEmptyColor READ getSelectedEmptyColor WRITE setSelectedEmptyColor)

	Q_PROPERTY(QColor SelectedSceneRangeEmptyColor READ getSelectedSceneRangeEmptyColor WRITE setSelectedSceneRangeEmptyColor)

	QColor m_columnHeaderBorderColor; //column header border lines (46,47,46)

	QColor m_selectedColumnTextColor; //selected column text (red)

	Q_PROPERTY(QColor ColumnHeaderBorderColor READ getColumnHeaderBorderColor WRITE setColumnHeaderBorderColor)

	Q_PROPERTY(QColor SelectedColumnTextColor READ getSelectedColumnTextColor WRITE setSelectedColumnTextColor)

	Spreadsheet::ScrollArea *m_columnScrollArea;

	Spreadsheet::ScrollArea *m_rowScrollArea;

	Spreadsheet::ScrollArea *m_cellScrollArea;

	TFrameHandle *m_frameHandle;

	int m_columnWidth;

	int m_rowHeight;

	// QPoint m_delta;

	int m_timerId;

	QPoint m_autoPanSpeed;

	QPoint m_lastAutoPanPos;

	int m_rowCount, m_columnCount;

	int m_currentRow;

	int m_markRowDistance, m_markRowOffset;

	// QRect m_selectedCells; // x=col, y=row

	bool m_isComputingSize;

public:

	SpreadsheetViewer(QWidget *parent);

	virtual ~SpreadsheetViewer();

	int getColumnWidth() const { return m_columnWidth; }

	void setColumnWidth(int width) { m_columnWidth = width; }

	int getRowHeight() const { return m_rowHeight; }

	void setRowHeight(int height) { m_rowHeight = height; }

	void setRowsPanel(Spreadsheet::RowPanel *rows);

	void setColumnsPanel(Spreadsheet::ColumnPanel *columns);

	void setCellsPanel(Spreadsheet::CellPanel *cells);

	int getRowCount() const { return m_rowCount; }

	// provvisorio

	QScrollArea *getFrameScrollArea() const { return m_cellScrollArea; }

	//QProperty

	void setLightLightBGColor(const QColor &color) { m_lightLightBgColor = color; }

	QColor getLightLightBGColor() const { return m_lightLightBgColor; }

	void setBGColor(const QColor &color) { m_bgColor = color; }

	QColor getBGColor() const { return m_bgColor; }

	void setLightLineColor(const QColor &color) { m_lightLineColor = color; }

	QColor getLightLineColor() const { return m_lightLineColor; }

	void setCurrentRowBgColor(const QColor &color) { m_currentRowBgColor = color; }

	QColor getCurrentRowBgColor() const { return m_currentRowBgColor; }

	void setMarkerLineColor(const QColor &color) { m_markerLineColor = color; }

	QColor getMarkerLineColor() const { return m_markerLineColor; }

	void setTextColor(const QColor &color) { m_textColor = color; }

	QColor getTextColor() const { return m_textColor; }

	void setVerticalLineColor(const QColor &color) { m_verticalLineColor = color; }

	QColor getVerticalLineColor() const { return m_verticalLineColor; }

	void setKeyFrameColor(const QColor &color) { m_keyFrameColor = color; }

	QColor getKeyFrameColor() const { return m_keyFrameColor; }

	void setKeyFrameBorderColor(const QColor &color) { m_keyFrameBorderColor = color; }

	QColor getKeyFrameBorderColor() const { return m_keyFrameBorderColor; }

	void setSelectedKeyFrameColor(const QColor &color) { m_selectedKeyFrameColor = color; }

	QColor getSelectedKeyFrameColor() const { return m_selectedKeyFrameColor; }

	void setInBetweenColor(const QColor &color) { m_inBetweenColor = color; }

	QColor getInBetweenColor() const { return m_inBetweenColor; }

	void setInBetweenBorderColor(const QColor &color) { m_inBetweenBorderColor = color; }

	QColor getInBetweenBorderColor() const { return m_inBetweenBorderColor; }

	void setSelectedInBetweenColor(const QColor &color) { m_selectedInBetweenColor = color; }

	QColor getSelectedInBetweenColor() const { return m_selectedInBetweenColor; }

	void setSelectedEmptyColor(const QColor &color) { m_selectedEmptyColor = color; }

	QColor getSelectedEmptyColor() const { return m_selectedEmptyColor; }

	void setSelectedSceneRangeEmptyColor(const QColor &color) { m_selectedSceneRangeEmptyColor = color; }

	QColor getSelectedSceneRangeEmptyColor() const { return m_selectedSceneRangeEmptyColor; }

	void setColumnHeaderBorderColor(const QColor &color) { m_columnHeaderBorderColor = color; }

	QColor getColumnHeaderBorderColor() const { return m_columnHeaderBorderColor; }

	void setSelectedColumnTextColor(const QColor &color) { m_selectedColumnTextColor = color; }

	QColor getSelectedColumnTextColor() const { return m_selectedColumnTextColor; }

	void scroll(QPoint delta);

	void onPrepareToScroll(int dy) { refreshContentSize(0, dy); }

	void setAutoPanSpeed(const QPoint &speed);

	void setAutoPanSpeed(const QRect &widgetBounds, const QPoint &mousePos);

	void stopAutoPan() { setAutoPanSpeed(QPoint()); }

	bool isAutoPanning() const { return m_autoPanSpeed.x() != 0 || m_autoPanSpeed.y() != 0; }

	int xToColumn(int x) const;

	int yToRow(int y) const;

	int columnToX(int col) const;

	int rowToY(int row) const;

	bool refreshContentSize(int scrollDx, int scrollDy);

	int getCurrentRow() const { return m_currentRow; }

	void setCurrentRow(int row) { m_currentRow = row; }

	virtual QRect getSelectedCells() const = 0;

	virtual void selectCells(const QRect &selectedCells) = 0;

	bool isSelectedCell(int row, int col) const

	{

		return getSelectedCells().contains(QPoint(col, row));

	}

	void setMarkRow(int distance, int offset)

	{

		m_markRowDistance = distance > 0 ? distance : 6;

		m_markRowOffset = offset;

	}

	void getMarkRow(int &distance, int &offset) const

	{

		distance = m_markRowDistance;

		offset = m_markRowOffset;

	}

	int isMarkRow(int row) const { return (row - m_markRowOffset) % m_markRowDistance == 0; }

	void setFrameHandle(TFrameHandle *frameHandle);

	TFrameHandle *getFrameHandle() const { return m_frameHandle; }

	void ensureVisibleCol(int col);

protected:

	void showEvent(QShowEvent *);

	void hideEvent(QHideEvent *);

	void resizeEvent(QResizeEvent *event);

	void keyPressEvent(QKeyEvent *event);

	void wheelEvent(QWheelEvent *event);

	void timerEvent(QTimerEvent *);

public slots:

	void setRowCount(int rowCount);

	void setColumnCount(int columnCount);

	void frameSwitched();

	void updateAreas();

	void onVSliderChanged(int);

	void onHSliderChanged(int);

	/*

  void updateAllAree();

  void updateCellColumnAree();

  void updateCellRowAree();

  */

};

#endif