#include "SubWindowManager.h"

#include "Common/Types.h"
#include "Geometry/geometryData.h"
#include "GeometryCommand/GeoCommandPy.h"
#include "MainWidgets/ControlPanel.h"
#include "MainWidgets/preWindow.h"
#include "MainWindow.h"
#include "MeshData/meshSingleton.h"
#include "ModuleBase/graphWindowBase.h"
#include "PostInterface/PostProcessPy.h"
#include "PostWidgets/PostWindowBase.h"
#include "PostWidgets/RealTimeWindowBase.h"
#include "PythonModule/PyAgent.h"
#include "SARibbonBar/SARibbonBar.h"
#include "SARibbonMWUi.h"
#include "SignalHandler.h"
#include "XGenerateReport/ReportWindow.h"

#include <assert.h>
#include <QDebug>
#include <QList>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QToolBar>

namespace GUI {
	SubWindowManager::SubWindowManager(MainWindow* mainwindow, QMdiArea* mdiArea,
									   SignalHandler* hander, MainWidget::ControlPanel* cp)
		: _mainWindow(mainwindow)
		, _mdiArea(mdiArea)
		, _signalHander(hander)
		, _controlPanel(cp)
	{
		connect(mainwindow, SIGNAL(closePreWindowSig()), this, SLOT(closePreWindow()));
		connect(mainwindow, SIGNAL(openPostWindowSig(Post::PostWindowBase*)), this,
				SLOT(openPostWindow(Post::PostWindowBase*)));
		connect(mainwindow, SIGNAL(openRealTimeWindowSig(Post::RealTimeWindowBase*, int)), this,
				SLOT(openRealTimeWindow(Post::RealTimeWindowBase*)));
		connect(mainwindow, SIGNAL(showPostWindowInfoSig(int, int)), this,
				SLOT(showPostWindowInfo(int, int)));
		connect(mainwindow, SIGNAL(closePostWindowSig(Post::PostWindowBase*)), this,
				SLOT(closePostWindow(Post::PostWindowBase*)));
		connect(_mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this,
				SLOT(subWindowActived(QMdiSubWindow*)));
		connect(mainwindow, SIGNAL(closeRealTimeWindowSig(Post::RealTimeWindowBase*)), this,
				SLOT(closeRealTimeWindow(Post::RealTimeWindowBase*)));
		connect(mainwindow, SIGNAL(openReportWindowSig(XReport::ReportWindow*)), this,
				SLOT(openReportWindow(XReport::ReportWindow*)));
		connect(mainwindow, SIGNAL(closeReportWindowSig(XReport::ReportWindow*)), this,
				SLOT(closeReportWindow(XReport::ReportWindow*)));
		connect(mainwindow, SIGNAL(saveImageSig(QString, int, Post::PostWindowBase*, int, int)),
				this, SLOT(saveImage(QString, int, Post::PostWindowBase*, int, int)));
		connect(mainwindow, SIGNAL(saveImage(int, int, QString)), this,
				SLOT(saveImage(int, int, QString)));

		connect(this, SIGNAL(setViewSig(int, QString, QString)), this,
				SLOT(setView(int, QString, QString)));
		connect(this,
				SIGNAL(setViewValueSig(int, QString, int, int, int, int, int, int, int, int, int)),
				this,
				SLOT(setViewValue(int, QString, int, int, int, int, int, int, int, int, int)));
		connect(this, SIGNAL(saveImageSig(int, int, int, QString, QString)), this,
				SLOT(saveImage(int, int, int, QString, QString)));
		connect(this, SIGNAL(openPreWindowSig()), this, SLOT(openPreWindow()));
	}
	SubWindowManager::~SubWindowManager() {}
	void SubWindowManager::openPreWindow()
	{
		if(isPreWindowOpened()) {
			Py::PythonAgent::getInstance()->unLock();
			return;
		}
		if(_preWindow.first == nullptr || _preWindow.second == nullptr) {
			_preWindow.second = new MainWidget::PreWindow(_mainWindow);
			_preWindow.first  = _mdiArea->addSubWindow(_preWindow.second);
			_signalHander->updateActionsStates();
			Command::GeometryCommandPy::init(_mainWindow, _preWindow.second);
		}
		//		else
		updatePreActors();
		_preWindow.first->showMaximized();
		_preWindow.first->setFocus();
		_mdiArea->setActiveSubWindow(_preWindow.first);
		_mainWindow->getUi()->actionPre_Window->setEnabled(false);
		emit _mainWindow->preWindowOpenedSig(_preWindow.second);
		Py::PythonAgent::getInstance()->unLock();
	}

	void SubWindowManager::openGeometryWindow()
	{
		// if (_geometryWindow.first == nullptr || _geometryWindow.second == nullptr)
		//{
		//	_geometryWindow.second = new GenerateGeometry::GenerateGeometryWidget(_mainWindow);
		//	_geometryWindow.first = _mdiArea->addSubWindow(_geometryWindow.second);
		// }
		//_preWindow.first->showMaximized();
		//_preWindow.first->setFocus();
	}

	QMdiArea* SubWindowManager::getMdiArea() const
	{
		return _mdiArea;
	}

	void SubWindowManager::add3dRenderPage(const QList<QToolBar*>& toolbars)
	{
		if(_threeD_render_page || toolbars.size() != 4)
			return;
		QList<QAction*> actions;
		QAction*		action{};
		SARibbonBar*	ribbon	 = _mainWindow->ribbonBar();
		_threeD_render_page		 = ribbon->addCategoryPage(QObject::tr("3D Render"));

		SARibbonPannel* pannel0	 = _threeD_render_page->addPannel(QString());
		QToolBar*		toolbar0 = toolbars.at(0);
		actions					 = toolbar0->actions();
		for(int j = 0; j < actions.size(); j++) {
			action = actions.at(j);
			pannel0->addLargeAction(action);
		}

		SARibbonPannel* pannel2	 = _threeD_render_page->addPannel(QString());
		QToolBar*		toolbar2 = toolbars.at(2);
		actions					 = toolbar2->actions();
		for(int j = 0; j < actions.size(); j++) {
			action = actions.at(j);
			pannel2->addLargeAction(action);
		}

		SARibbonPannel* pannel3	 = _threeD_render_page->addPannel(QString());
		QToolBar*		toolbar3 = toolbars.at(3);
		actions					 = toolbar3->actions();
		for(int j = 0; j < actions.size(); j++) {
			action = actions.at(j);
			pannel3->addLargeAction(action);
		}

		SARibbonPannel* pannel1	 = _threeD_render_page->addPannel(QString());
		QToolBar*		toolbar1 = toolbars.at(1);
		actions					 = toolbar1->actions();
		QList<QAction*> realActions;
		QList<QWidget*> comboxs;
		QWidget*		widget{};
		for(int j = 0; j < actions.size(); j++) {
			action = actions.at(j);
			if(action->objectName() == "QComboBox") {
				widget = toolbar1->widgetForAction(action);
				widget->setVisible(true);
				comboxs.append(widget);
			} else if(action->objectName() == "QAction")
				realActions.append(action);
		}
		if(realActions.size() != 4 && comboxs.size() != 3)
			return;
		pannel1->addLargeAction(realActions.at(0));
		pannel1->addLargeAction(realActions.at(1));
		pannel1->addLargeAction(realActions.at(2));
		pannel1->addLargeAction(realActions.at(3));
		pannel1->addSmallWidget(comboxs.at(0));
		pannel1->addSmallWidget(comboxs.at(1));
		pannel1->addLargeWidget(comboxs.at(2));

		// modify
		/*
		int index = ribbon->tabIndex(_threeD_render_page);
		ribbon->setCurrentIndex(index);
		ribbon->onCurrentRibbonTabChanged(index);
		*/

		ribbon->raiseCategory(_threeD_render_page);
	}

	void SubWindowManager::remove3dRenderPage()
	{
		if(_threeD_render_page == nullptr)
			return;
		auto pannels = _threeD_render_page->pannelList();
		for(SARibbonPannel* pannel : pannels) {
			_threeD_render_page->removePannel(pannel);
			pannel = nullptr;
		}

		SARibbonBar* ribbon = _mainWindow->ribbonBar();
		ribbon->removeCategory(_threeD_render_page);
		_threeD_render_page = nullptr;

		ribbon->setCurrentIndex(4);
		// ribbon->onCurrentRibbonTabChanged(4);
	}

	void SubWindowManager::updatePreActors()
	{
		updatePreGeometryActor();
		updatePreMeshActor();
	}
	void SubWindowManager::updatePreMeshActor()
	{
		if(_preWindow.second != nullptr) {
			emit _preWindow.second->updateMeshActorSig();
		}
	}
	void SubWindowManager::updatePreGeometryActor()
	{
		if(_preWindow.second != nullptr) {
			_preWindow.second->updateGeometryActor();
		}
	}
	void SubWindowManager::closePreWindow()
	{
		_preWindow.first  = nullptr;
		_preWindow.second = nullptr;
		_mainWindow->getUi()->actionPre_Window->setEnabled(true);

		emit _mainWindow->updateGeometryTreeSig();
		emit _mainWindow->updateMeshTreeSig();
		emit _mainWindow->updateSetTreeSig();
		emit _mainWindow->updatePhysicsTreeSignal();
		emit _mainWindow->updateProperty(nullptr);
		emit _mainWindow->updateActionStatesSig();

		//		_signalHander->clearData();
	}
	void SubWindowManager::openPostWindow(Post::PostWindowBase* pw)
	{
		if(pw == nullptr) {
			assert(0);
			return;
		}
		QMdiSubWindow*				 sw	 = nullptr;
		QList<Post::PostWindowBase*> pwl = _postWindow.values();
		if(pwl.contains(pw)) {
			sw = _postWindow.key(pw);
		} else {
			sw = _mdiArea->addSubWindow(pw);
			_mdiArea->cascadeSubWindows();
			_postWindow[sw] = pw;
		}
		if(sw != nullptr) {
			sw->activateWindow();
			sw->showMaximized();
			sw->setFocus();
		}
		Post::PostProcessPy::init(_mainWindow, _mainWindow->getControlPanel()->getPostTreeWidget());
		Py::PythonAgent::getInstance()->unLock();
		emit _mainWindow->updateActionStatesSig();
	}

	void SubWindowManager::openRealTimeWindow(Post::RealTimeWindowBase* pw)
	{
		QMdiSubWindow*					 sw	 = nullptr;
		QList<Post::RealTimeWindowBase*> pwl = _realTimeWindow.values();
		if(pwl.contains(pw)) {
			sw = _realTimeWindow.key(pw);
		} else {
			sw					= _mdiArea->addSubWindow(pw);
			_realTimeWindow[sw] = pw;
		}
		if(sw != nullptr) {
			sw->showMaximized();
			sw->setFocus();
		}
		emit _mainWindow->updateActionStatesSig();
	}
	ModuleBase::GraphWindowBase* SubWindowManager::getCurrentWindow()
	{
		QMdiSubWindow* activeWindow = nullptr;

		auto		   subWins		= _mdiArea->subWindowList();
		if(subWins.size() == 1) {
			activeWindow = subWins.at(0);
		} else {
			activeWindow = _mdiArea->activeSubWindow();
		}
		if(activeWindow == nullptr)
			return nullptr;
		else if(activeWindow == _preWindow.first)
			return _preWindow.second;
		else if(_postWindow.contains(activeWindow))
			return _postWindow[activeWindow];
		else
			return nullptr;
	}
	Post::PostWindowBase* SubWindowManager::getPostWindowByIDType(int id, int type)
	{
		QList<Post::PostWindowBase*> pwl = _postWindow.values();
		for(int i = 0; i < pwl.size(); ++i) {
			Post::PostWindowBase* w = pwl.at(i);
			if(w == nullptr)
				continue;
			int wid	  = w->getID();
			int wtype = (int)w->getPostWindowType();
			if(wid == id && wtype == type)
				return w;
		}
		return nullptr;
	}
	void SubWindowManager::removeToolBars()
	{
		const int n = _currentToolBars.size();
		for(int i = 0; i < n; ++i) {
			QToolBar* t = _currentToolBars.at(i);
			_mainWindow->removeToolBar(t);
		}
		_currentToolBars.clear();
	}
	void SubWindowManager::showPostWindowInfo(int id, int type)
	{
		Post::PostWindowBase* pwb = getPostWindowByIDType(id, type);
		if(pwb == nullptr)
			return;
		// 		QWidget* ptree = pwb->getTreeWidget();
		// 		QWidget* pprop = pwb->getPropWidget();
		QMdiSubWindow* subWin = _postWindow.key(pwb);
		if(subWin != nullptr) {
			subWin->showMaximized();
			subWin->setFocus();
		}
		//_controlPanel->updatePostWidget(ptree, pprop);
		if(type == 2)
			_controlPanel->updatePostWidget();

		QList<QToolBar*> toolBars = pwb->getToolBarList();
		if(_mainWindow->isUseRibbon()) {
			if(_threeD_render_page)
				return;
			add3dRenderPage(toolBars);
		} else {
			this->removeToolBars();
			_mainWindow->addToolBarBreak();
			for(int i = 0; i < toolBars.size(); ++i) {
				_mainWindow->addToolBar(toolBars.at(i));
				(toolBars.at(i))->show();
				_currentToolBars.append(toolBars.at(i));
			}
		}
	}
	void SubWindowManager::closePostWindow(Post::PostWindowBase* w)
	{
		QMdiSubWindow* subw = _postWindow.key(w);
		if(subw == nullptr)
			return;
		Post::PostWindowType type = w->getPostWindowType();
		removeToolBars();
		if(type == Post::PostWindowType::D3
		   && _mainWindow->isUseRibbon()) // 使用ribbon，并且关闭的是3维窗口
			remove3dRenderPage();

		if(_controlPanel != nullptr)
			_controlPanel->updatePostWidget(nullptr, nullptr);
		emit _mainWindow->updateProperty(nullptr);

		_postWindow.remove(subw);
		QList<Post::PostWindowBase*> postsubwlist = _postWindow.values();
		if(_preWindow.first != nullptr)
			showPreWindow();
		else if(postsubwlist.size() > 0) {
			Post::PostWindowBase* w	   = postsubwlist.at(0);
			int					  id   = w->getID();
			Post::PostWindowType  type = w->getPostWindowType();
			showPostWindowInfo(id, type);
		}
		emit _mainWindow->updateActionStatesSig();
	}
	void SubWindowManager::showPreWindow()
	{
		removeToolBars();
		if(_controlPanel == nullptr)
			return;
		_controlPanel->updatePostWidget(nullptr, nullptr);
		if(_preWindow.first != nullptr) {
			_preWindow.first->showMaximized();
			_preWindow.first->setFocus();
		}
	}
	void SubWindowManager::showRealTimeWindow(QMdiSubWindow* w)
	{
		removeToolBars();
		_controlPanel->updatePostWidget(nullptr, nullptr);
		if(_realTimeWindow.contains(w)) {
			w->showMaximized();
			w->setFocus();
		}
	}
	void SubWindowManager::subWindowActived(QMdiSubWindow* sw)
	{
		if(sw == nullptr)
			return;
		if(sw == _preWindow.first)
			showPreWindow();
		else if(_realTimeWindow.contains(sw))
			showRealTimeWindow(sw);
		else if(_postWindow.contains(sw)) {
			Post::PostWindowBase* pwb  = _postWindow.value(sw);
			int					  id   = pwb->getID();
			Post::PostWindowType  type = pwb->getPostWindowType();
			showPostWindowInfo(id, type);
		}
		emit _mainWindow->updateActionStatesSig();
	}
	void SubWindowManager::closeRealTimeWindow(Post::RealTimeWindowBase* w)
	{
		QMdiSubWindow* subw = _realTimeWindow.key(w);
		if(subw == nullptr)
			return;
		_realTimeWindow.remove(subw);
		if(_preWindow.first != nullptr)
			showPreWindow();
		emit _mainWindow->updateActionStatesSig();
	}
	void SubWindowManager::setView(QString view)
	{
		/*qDebug() << view;
		ModuleBase::GraphWindowBase* gwb = getCurrentWindow();
		if (gwb == nullptr) return;
		gwb->setView(view);*/
		ModuleBase::GraphWindowBase* gwb = getCurrentWindow();
		if(gwb == nullptr)
			return;
		const int id  = gwb->getID();
		QString	  win = gwb->getStringGraphWindowType();
		qDebug() << win;
		QString pycode = QString("MainWindow.setView(%1,\"%2\",\"%3\")").arg(id).arg(win).arg(view);
		qDebug() << pycode;
		Py::PythonAgent::getInstance()->submit(pycode);
		// gwb->setView(view);
	}

	MainWidget::PreWindow* SubWindowManager::getPreWindow()
	{
		return _preWindow.second;
	}
	void SubWindowManager::openReportWindow(XReport::ReportWindow* w)
	{
		QMdiSubWindow*				  sw  = nullptr;
		QList<XReport::ReportWindow*> rws = _reportWindow.values();
		if(rws.contains(w)) {
			sw = _reportWindow.key(w);
		} else {
			sw				  = _mdiArea->addSubWindow(w);
			_reportWindow[sw] = w;
		}
		if(sw != nullptr) {
			sw->showMaximized();
			sw->setFocus();
		}
		emit _mainWindow->updateActionStatesSig();
	}
	void SubWindowManager::closeReportWindow(XReport::ReportWindow* w)
	{
		QMdiSubWindow* s = _reportWindow.key(w);
		if(s != nullptr) {
			_reportWindow.remove(s);
		}
	}
	bool SubWindowManager::isPreWindowOpened()
	{
		if(_preWindow.first == nullptr || _preWindow.second == nullptr)
			return false;
		return true;
	}
	bool SubWindowManager::isPostWindowOpened()
	{
		if(_postWindow.size() > 0)
			return true;
		return false;
	}

	bool SubWindowManager::isPostWindowOpening()
	{
		QMdiSubWindow* activeWindow = _mdiArea->activeSubWindow();
		if(activeWindow == nullptr)
			return false;
		else if(_postWindow.contains(activeWindow))
			return true;
		else
			return false;
	}

	void SubWindowManager::saveImage(QString fileName, int winType, Post::PostWindowBase* winhandle,
									 int w, int h)
	{
		if(winType == 0) {
			MainWidget::PreWindow* preW = _preWindow.second;
			if(preW == nullptr)
				return;
			preW->saveImage(fileName, w, h, false);
		} else if(winType == 1) {
			if(_postWindow.key(winhandle) == nullptr)
				return;
			winhandle->saveImage(fileName, w, h, false);
		}
	}

	void SubWindowManager::saveImage(int w, int h, QString f)
	{
		ModuleBase::GraphWindowBase* gw = this->getCurrentWindow();
		if(gw == nullptr) {
			_mainWindow->printMessage(Common::Message::Error, tr("No GraphWindow opened!"));
			return;
		}
		QString	  type	 = gw->getStringGraphWindowType();
		const int id	 = gw->getID();
		QString	  pycode = QString("MainWindow.saveImage(%1,%2,%3,\"%4\",\"%5\")")
							 .arg(w)
							 .arg(h)
							 .arg(id)
							 .arg(type)
							 .arg(f);
		qDebug() << pycode;
		Py::PythonAgent::getInstance()->submit(pycode);
	}

	void SubWindowManager::saveImage(int w, int h, int id, QString winType, QString file)
	{
		ModuleBase::GraphWindowBase* win = this->getWindowByTypeID(winType, id);
		if(win == nullptr)
			return;
		win->saveImage(file, w, h, false);
		Py::PythonAgent::getInstance()->unLock();
	}
	void SubWindowManager::setView(int id, QString winType, QString view) // liu
	{
		ModuleBase::GraphWindowBase* gwb = getWindowByTypeID(winType, id);
		if(gwb == nullptr)
			return;
		gwb->setView(view);
		Py::PythonAgent::getInstance()->unLock();
	}
	void SubWindowManager::setViewValue(int id, QString win, int x1, int x2, int x3, int y1, int y2,
										int y3, int z1, int z2, int z3)
	{
		ModuleBase::GraphWindowBase* gwb = getWindowByTypeID(win, id);
		if(gwb == nullptr)
			return;
		gwb->setViewValue(x1, x2, x3, y1, y2, y3, z1, z2, z3);
		Py::PythonAgent::getInstance()->unLock();
	}
	/*void SubWindowManager::setViewPreValue(int id, QString win, int x1, int x2, int x3, int y1,
	int y2, int y3, int z1, int z2, int z3)
	{
	ModuleBase::GraphWindowBase* gwb = getCurrentWindow();
	if (gwb == nullptr) return;
	gwb->setViewPreValue(x1, x2, x3, y1, y2, y3, z1, z2, z3);
	}*/
	void SubWindowManager::reTranslate()
	{
		MainWidget::PreWindow* prew = _preWindow.second;
		if(prew != nullptr)
			prew->reTranslate();

		int							 n			 = 0;
		QList<Post::PostWindowBase*> postWinList = _postWindow.values();
		n										 = postWinList.size();
		for(int i = 0; i < n; ++i) {
			Post::PostWindowBase* pw = postWinList.at(i);
			if(pw != nullptr)
				pw->reTranslate();
		}
		QList<Post::RealTimeWindowBase*> rwList = _realTimeWindow.values();
		n										= rwList.size();
		for(int i = 0; i < n; ++i) {
			Post::RealTimeWindowBase* rw = rwList.at(i);
			if(rw != nullptr)
				rw->reTranslate();
		}
		QList<XReport::ReportWindow*> repWin = _reportWindow.values();
		n									 = repWin.size();
		for(int i = 0; i < n; ++i) {
			XReport::ReportWindow* w = repWin.at(i);
			w->reTranslate();
		}
		if(_threeD_render_page != nullptr)
			_threeD_render_page->setWindowTitle(tr("3D Render"));
	}

	void SubWindowManager::closeGeometryWindow()
	{
		_geometryWindow.first  = nullptr;
		_geometryWindow.second = nullptr;

		_signalHander->clearData(false);
		emit _mainWindow->updateGeometryTreeSig();
		emit _mainWindow->updateMeshTreeSig();
		emit _mainWindow->updatePhysicsTreeSignal();
		emit _mainWindow->updateProperty(nullptr);
	}

	GenerateGeometry::GenerateGeometryWidget* SubWindowManager::getGeometryWindow()
	{
		if(!_geometryWindow.second) {
			openGeometryWindow();
		}
		return _geometryWindow.second;
	}

	void SubWindowManager::closeAllSubWindow()
	{
		//		_mdiArea->setViewMode(QMdiArea::SubWindowView);
		//		_mdiArea->setTabPosition(QTabWidget::North);

		MainWidget::PreWindow* pre = _preWindow.second;
		if(pre != nullptr) {
			_preWindow.first->close();
			_mdiArea->removeSubWindow(pre);
			pre->close();
			delete pre;
		}

		QList<Post::PostWindowBase*> postlist = _postWindow.values();
		for(int i = 0; i < postlist.size(); ++i) {
			Post::PostWindowBase* p = postlist.at(i);
			_postWindow.key(p)->close();
			_mdiArea->removeSubWindow(p);
			p->close();
			delete p;
		}

		QList<Post::RealTimeWindowBase*> realtimelist = _realTimeWindow.values();
		for(int i = 0; i < realtimelist.size(); ++i) {
			Post::RealTimeWindowBase* r = realtimelist.at(i);
			_realTimeWindow.key(r)->close();
			_mdiArea->removeSubWindow(r);
			r->close();
			delete r;
		}

		QList<XReport::ReportWindow*> reportlist = _reportWindow.values();
		for(int i = 0; i < reportlist.size(); ++i) {
			XReport::ReportWindow* r = reportlist.at(i);
			_reportWindow.key(r)->close();
			_mdiArea->removeSubWindow(r);
			r->close();
			delete r;
		}
	}

	ModuleBase::GraphWindowBase* SubWindowManager::getWindowByTypeID(QString type, int id)
	{
		ModuleBase::GraphWindowBase* g = nullptr;
		type						   = type.toLower();
		if(type == "prewindow") {
			g = _preWindow.second;
		} else if(type == "realtime") {
			QList<Post::RealTimeWindowBase*> wlist = _realTimeWindow.values();
			for(int i = 0; i < wlist.size(); ++i) {
				ModuleBase::GraphWindowBase* t = wlist.at(i);
				const int					 d = t->getID();
				if(id == d) {
					g = t;
					break;
				}
			}
		} else if(type == "post2d") {
			QList<Post::PostWindowBase*> wlist = _postWindow.values();
			for(int i = 0; i < wlist.size(); ++i) {
				ModuleBase::GraphWindowBase* t = wlist.at(i);
				const int					 d = t->getID();
				if(id == d && t->getGraphWindowType() == ModuleBase::Post2D) {
					g = t;
					break;
				}
			}
		} else if(type == "post3d") {
			QList<Post::PostWindowBase*> wlist = _postWindow.values();
			for(int i = 0; i < wlist.size(); ++i) {
				ModuleBase::GraphWindowBase* t = wlist.at(i);
				const int					 d = t->getID();
				if(id == d && t->getGraphWindowType() == ModuleBase::Post3D) {
					g = t;
					break;
				}
			}
		}
		return g;
	}

	void SubWindowManager::setIcon(QString icon)
	{
		if(_preWindow.first != nullptr)
			_preWindow.first->setWindowIcon(QIcon(icon));
		QList<QMdiSubWindow*> subw =
			_postWindow.keys() + _realTimeWindow.keys() + _reportWindow.keys();
		for(auto w : subw) {
			w->setWindowIcon(QIcon(icon));
		}
	}

} // namespace GUI
