#include <qpaintevent></qpaintevent>

#include <qdesktopwidget></qdesktopwidget>

#include <qapplication></qapplication>

#include <qmetaobject></qmetaobject>

#include <qcursor></qcursor>

#include <qpainter></qpainter>

#include "toonzqt/screenboard.h"

using namespace DVGui;

#include <qpalette></qpalette>

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

//    Local namespace

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

namespace

{

class MouseTrackerDrawing : public ScreenBoard::Drawing

{

public:

	bool acceptScreenEvents(const QRect &rect) const

	{

		return rect.contains(QCursor::pos());

	}

	void paintEvent(QWidget *widget, QPaintEvent *pe)

	{

//Seems that mouse masking is on by default on the drawn regions, when using

//WA_TranslucentBackground (which is weird). I think it's the Qt 2 autoMask feature

//that disappeared from Qt 3 on - now it must be managed internally.

//So, we have to fill the entire screen region with the most invisible color possible...

#ifdef MACOSX

#define MIN_ALPHA 13 // Again, very weird. 13 is the minimal alpha that gets converted to 'mask-opaque' on MAC...

#else

#define MIN_ALPHA 1 // ... whereas 1 is sufficient on Windows. Argh!

#endif

		QPainter painter(widget);

		painter.fillRect(0, 0, widget->width(), widget->height(), QColor(0, 0, 0, MIN_ALPHA));

	}

} tracker;

} //namespace

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

//    ScreenWidget implementation

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

class ScreenBoard::ScreenWidget : public QWidget

{

	QList<screenboard::drawing *=""> m_drawings; //!< Drawings intersecting the screen</screenboard::drawing>

	bool m_mouseOnScreen;					  //!< Whether the mouse is inside this screen

public:

	ScreenWidget(QWidget *parent = 0, bool grabbing = false)

		: QWidget(parent, Qt::Tool |					//Tool does not force focus changes upon shows

							  Qt::FramelessWindowHint | //No decorations

							  Qt::WindowStaysOnTopHint) //Must be above all other windows

	{

		setAttribute(Qt::WA_TransparentForMouseEvents, !grabbing); //Receives mouse events?

		setAttribute(Qt::WA_TranslucentBackground);				   //Transparent widget

		setFocusPolicy(Qt::NoFocus);

		setMouseTracking(true); //When receiving mouse events

	}

	const QList<drawing *=""> &drawings() const { return m_drawings; }</drawing>

	QList<drawing *=""> &drawings() { return m_drawings; }</drawing>

	bool mouseOnScreen() const { return m_mouseOnScreen; }

protected:

	bool event(QEvent *e)

	{

		int i, size = m_drawings.size();

		if (e->type() == QEvent::Paint) {

			//Invoke paint events in reversed sorting order

			for (i = size - 1; i >= 0; --i)

				m_drawings[i]->paintEvent(this, static_cast<qpaintevent *="">(e));</qpaintevent>

		}

		//Invoke other events in straight sorting order

		for (i = 0; i < size; ++i)

			m_drawings[i]->event(this, e);

		return QWidget::event(e);

	}

	void leaveEvent(QEvent *e)

	{

		m_mouseOnScreen = false;

		ScreenBoard *screenBoard = ScreenBoard::instance();

		if (screenBoard->m_grabbing)

			screenBoard->ensureMouseOnAScreen();

	}

	void enterEvent(QEvent *e)

	{

		m_mouseOnScreen = true;

		ScreenBoard::instance()->m_mouseOnAScreen = true;

	}

};

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

//    ScreenBoard implementation

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

ScreenBoard::ScreenBoard()

	: m_grabbing(false)

{

}

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

ScreenBoard *ScreenBoard::instance()

{

	static ScreenBoard theInstance;

	return &theInstance;

}

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

/*!

  Makes the ScreenBoard catch all mouse events (effectively preventing other windows or applications

  to get them), and delivers them to drawings. An appropriate cursor should be specified to inform the

  user that tout-court mouse grabbing takes place.

*/

void ScreenBoard::grabMouse(const QCursor &cursor)

{

	m_grabbing = true;

	m_cursor = cursor;

	//Place a mouse-tracking dummy drawing among drawings

	m_drawings.push_back(&::tracker);

	//Make all screen widgets react to mouse events, and show them

	int i, size = m_screenWidgets.size();

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

		QWidget *screenWidget = m_screenWidgets[i];

		if (screenWidget) {

			screenWidget->setAttribute(Qt::WA_TransparentForMouseEvents, false);

			screenWidget->setCursor(m_cursor);

		}

	}

}

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

/*!

  Restores the ScreenBoard to ignore mouse events (the default behaviour) after a

  call to grabMouse().

*/

void ScreenBoard::releaseMouse()

{

	//Restore screen widgets to ignore mouse events

	int i, size = m_screenWidgets.size();

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

		QWidget *screenWidget = m_screenWidgets[i];

		if (screenWidget) {

			screenWidget->setAttribute(Qt::WA_TransparentForMouseEvents, true);

			screenWidget->unsetCursor();

		}

	}

	//Remove the mouse-tracking drawing

	m_drawings.removeAt(m_drawings.indexOf(&::tracker));

	m_cursor = QCursor();

	m_grabbing = false;

}

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

// Refresh the screen widgets pool, depending on stored drawings

void ScreenBoard::reallocScreenWidgets()

{

	QDesktopWidget *desktop = QApplication::desktop();

	int i, screensCount = desktop->numScreens();

	//Delete exceeding screens and resize to screensCount

	for (i = screensCount; i < m_screenWidgets.size(); ++i) {

		m_screenWidgets[i]->hide();

		m_screenWidgets[i]->deleteLater(); //Ensures no event about it is pending.

										   //Note that updates may be invoked in event handlers.

	}

	m_screenWidgets.resize(desktop->numScreens());

	//Re-initialize the screen widgets list

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

		ScreenWidget *screenWidget = m_screenWidgets[i];

		if (screenWidget)

			screenWidget->drawings().clear();

	}

	//Turn on a ScreenWidget for each screen crossed by any drawing

	int j, drawingsCount = m_drawings.size();

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

		ScreenWidget *screenWidget = m_screenWidgets[i];

		const QRect &screenGeom = desktop->screenGeometry(i);

		for (j = 0; j < drawingsCount; ++j) {

			Drawing *drawing = m_drawings[j];

			if (drawing->acceptScreenEvents(screenGeom)) {

				//Allocate the associated screen widget if necessary

				if (!screenWidget) {

					m_screenWidgets[i] = screenWidget = new ScreenWidget(0, m_grabbing);

					if (m_grabbing)

						screenWidget->setCursor(m_cursor);

					screenWidget->setGeometry(screenGeom);

					screenWidget->show();

				}

				//Add the drawing to the widget

				screenWidget->drawings().push_back(drawing);

			}

		}

	}

	//Remove screens without drawings

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

		ScreenWidget *screenWidget = m_screenWidgets[i];

		if (screenWidget && screenWidget->drawings().empty()) {

			screenWidget->hide();

			screenWidget->deleteLater();

			m_screenWidgets[i] = 0;

		}

	}

}

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

/*!

  This function must be called whenever a drawing needs to be refreshed.

  It has 2 consequences:

    \li The pool of invisible screen widgets that are used to catch Qt events

        is refreshed to satisfy the drawings requirements. Screen widgets whose

        events are not needed are released from the pool.

    \li All screen widgets are updated, propagating paintEvents to their drawings.

  Observe that this function awaits return to the main event loop before being processed.

  This ensures that update calls are processed outside event handlers, and multiple

  calls from different drawings gets coalesced into one.

*/

void ScreenBoard::update()

{

	m_updated = false;

	QMetaObject::invokeMethod(this, "doUpdate", Qt::QueuedConnection);

}

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

void ScreenBoard::doUpdate()

{

	if (m_updated) //Weak updates coalescence. It helps.

		return;

	m_updated = true;

	reallocScreenWidgets();

	//Update all screenWidgets

	int i, size = m_screenWidgets.size();

	for (i = 0; i < size; ++i)

		if (m_screenWidgets[i])

			m_screenWidgets[i]->update();

}

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

void ScreenBoard::ensureMouseOnAScreen()

{

	//Find out if the mouse is on a screen

	m_mouseOnAScreen = false;

	int i, size = m_screenWidgets.size();

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

		ScreenWidget *screenWidget = m_screenWidgets[i];

		if (screenWidget)

			m_mouseOnAScreen |= screenWidget->mouseOnScreen();

	}

	if (!m_mouseOnAScreen)

		//Ensure that there is a screen under the mouse cursor.

		//We need a slot invocation, since this method could be called in an event handler.

		QMetaObject::invokeMethod(this, "trackCursor", Qt::QueuedConnection);

}

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

void ScreenBoard::trackCursor()

{

	while (!m_mouseOnAScreen) {

		update();														//Refresh screens pool

		QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents); //Process events (-> enterEv.)

	}

}