Windows can be docked to the dock bar

CamelotEditor/Include/CmEditorWindowManager.h

@@ -4,6 +4,7 @@
 #include "CmModule.h"
 #include <boost/function.hpp>
 #include <QtCore/QString>
+#include <QtCore/QPoint>
 
 namespace CamelotEditor
 {
@@ -27,6 +28,7 @@ namespace CamelotEditor
 		boost::function<void()> getOpenCallback(const QString& name);
 
 		QtEditorWindow* getOpenWindow(INT32 id) const;
+		QtEditorWindow* getWindowAtPosition(const QPoint& globalPos, vector<UINT32>::type windowsToIgnore = vector<UINT32>::type()) const;
 
 		void restoreWindowsFromPrefs();
 		void saveWindowsToPrefs();

CamelotEditor/Include/CmQtDockOverlayWidget.h

@@ -27,14 +27,25 @@ namespace CamelotEditor
 		void enableDropOverlay(std::vector<QPolygon> dragLocations, const QPoint& offset);
 		void disableDropOverlay();
 
+		void highlightTabDropLocation(INT32 dropLocation);
+
+		void enableTabDropOverlay(std::vector<QPolygon> dragLocations, const QPoint& offset);
+		void disableTabDropOverlay();
+
 	private:
 		WindowDragDropLocation mHighlightedDropLocation;
 		bool mDropOverlayEnabled;
 		vector<QPolygon>::type mDragLocations;
 		QPoint mOverlayOffset;
 
+		INT32 mHighlightedTabDropLocation;
+		bool mTabDropOverlayEnabled;
+		vector<QPolygon>::type mTabDropLocations;
+		QPoint mTabOverlayOffset;
+
 		void paintEvent(QPaintEvent* event);
 
 		void drawDragLocations(const std::vector<QPolygon>& dragLocations, WindowDragDropLocation highlightedLocation);
+		void drawTabDropLocations(const std::vector<QPolygon>& dropLocations, INT32 highlightedLocation);
 	};
 }

CamelotEditor/Include/CmQtDynamicTabBar.h

@@ -19,11 +19,21 @@ namespace CamelotEditor
 		void insertTab(UINT32 idx, const QString& name);
 		void removeTab(UINT32 idx);
 
+		vector<QPolygon>::type getDropLocations();
+
+		void enterEvent(QEvent *e);
+		void leaveEvent(QEvent *e);
+		void mousePressEvent(QMouseEvent* event);
+		void mouseReleaseEvent(QMouseEvent* event);
+		void mouseMoveEvent(QMouseEvent* event);
+		void paintEvent(QPaintEvent *event);
+
 		boost::signal<void(UINT32)> onTabSelected;
 
 	private:
 		QHBoxLayout* mHLayout;
 		vector<QPushButton*>::type mTabs;
+		bool dbg;
 
 		void setupUi();
 		void updateTabs();

CamelotEditor/Include/CmQtEditorWindow.h

@@ -45,6 +45,12 @@ namespace CamelotEditor
 
 		void setActiveWidget(UINT32 idx);
 		QWidget* getContentWidget() const;
+		QWidget* getTabWidget() const;
+
+		std::vector<QPolygon> getTabBarDropLocations() const;
+		INT32 getActiveTabBarDropLocation(const QPoint& mousePos) const;
+
+		void closeWindow();
 
 		boost::signal<void(QtEditorWindow*)> onClosed;
 	protected:
@@ -81,8 +87,6 @@ namespace CamelotEditor
 		ResizeMode getResizeMode(QPoint mousePos);
 		bool isOverResizeArea(QPoint mousePos);
 
-		void closeWindow();
-
 		/**
 		 * @brief	Query if 'mousePos' is over the area that can be used for dragging the window around.
 		 *

CamelotEditor/Include/CmWindowDockManager.h

@@ -36,7 +36,6 @@ namespace CamelotEditor
 
 		map<QtEditorWindow*, DockedWindowInfo>::type mDockedWindows;
 
-		QtEditorWindow* getDockedWindowAtPosition(const QPoint& globalPos);
 		bool isPositionInDockArea(const QPoint& globalPos);
 
 		WindowDragDropLocation getDropLocationAtPosition(const QWidget* widget, const QPoint& globalPos);

CamelotEditor/Source/CmEditorWindowManager.cpp

@@ -80,6 +80,26 @@ namespace CamelotEditor
 		return iterFind->second;
 	}
 
+	QtEditorWindow* EditorWindowManager::getWindowAtPosition(const QPoint& globalPos, vector<UINT32>::type windowsToIgnore) const
+	{
+		for(auto iter = mOpenWindows.begin(); iter != mOpenWindows.end(); ++iter)
+		{
+			QtEditorWindow* curWindow = iter->second;
+
+			auto iterFind = std::find(windowsToIgnore.begin(), windowsToIgnore.end(), curWindow->getId());
+			if(iterFind != windowsToIgnore.end())
+				continue;
+
+			QPoint globalWidgetPos = curWindow->mapToGlobal(QPoint(0, 0));
+			QRect widgetRect(globalWidgetPos, curWindow->geometry().size());
+
+			if(widgetRect.contains(globalPos))
+				return curWindow;
+		}
+
+		return nullptr;
+	}
+
 	void EditorWindowManager::restoreWindowsFromPrefs()
 	{
 		vector<WindowLayoutDesc>::type windowLayouts = gEditorPrefs().getWindowLayouts();

CamelotEditor/Source/CmQtDockOverlayWidget.cpp

@@ -9,7 +9,7 @@
 namespace CamelotEditor
 {
 	QtDockOverlayWidget::QtDockOverlayWidget(QWidget* parent)
-		:QWidget(parent), mHighlightedDropLocation(CM_WINDROP_NONE), mDropOverlayEnabled(false) 
+		:QWidget(parent), mHighlightedDropLocation(CM_WINDROP_NONE), mDropOverlayEnabled(false), mHighlightedTabDropLocation(-1), mTabDropOverlayEnabled(false)
 	{ 
 		setPalette(Qt::transparent);
 		setAttribute(Qt::WA_TransparentForMouseEvents);
@@ -47,12 +47,48 @@ namespace CamelotEditor
 		}
 	}
 
+	void QtDockOverlayWidget::highlightTabDropLocation(INT32 dropLocation)
+	{
+		mHighlightedTabDropLocation = dropLocation;
+		repaint();
+	}
+
+	void QtDockOverlayWidget::enableTabDropOverlay(std::vector<QPolygon> dragLocations, const QPoint& offset)
+	{
+		mTabDropLocations = dragLocations;
+		mTabOverlayOffset = offset;
+
+		if(!mTabDropOverlayEnabled)
+		{
+			show();
+
+			mTabDropOverlayEnabled = true; 
+			repaint();
+		}
+	}
+
+	void QtDockOverlayWidget::disableTabDropOverlay()
+	{
+		if(mTabDropOverlayEnabled)
+		{
+			hide();
+
+			mTabDropOverlayEnabled = false; 
+			repaint();
+		}
+	}
+
 	void QtDockOverlayWidget::paintEvent(QPaintEvent *event)
 	{
 		if(mDropOverlayEnabled)
 		{
 			drawDragLocations(mDragLocations, mHighlightedDropLocation);
 		}
+
+		if(mTabDropOverlayEnabled)
+		{
+			drawTabDropLocations(mTabDropLocations, mHighlightedTabDropLocation);
+		}
 	}
 
 	void QtDockOverlayWidget::drawDragLocations(const std::vector<QPolygon>& dragLocations, WindowDragDropLocation highlightedLocation)
@@ -86,4 +122,36 @@ namespace CamelotEditor
 			++idx;
 		}
 	}
+
+	void QtDockOverlayWidget::drawTabDropLocations(const std::vector<QPolygon>& dropLocations, INT32 highlightedLocation)
+	{
+		QPainter painter(this);
+		painter.translate(mTabOverlayOffset);
+		painter.setRenderHint(QPainter::Antialiasing);
+		painter.setPen(QColor(208, 208, 208));
+		painter.setClipping(false);
+
+		int idx = 0;
+		for(auto iter = dropLocations.begin(); iter != dropLocations.end(); ++iter)
+		{
+			painter.drawPolygon(*iter);
+
+			if(idx == (int)highlightedLocation)
+			{
+				QPainterPath highlightedPoly;
+				highlightedPoly.addPolygon(*iter);
+
+				painter.fillPath(highlightedPoly, QColor(190, 190, 190, 128));
+			}
+			else
+			{
+				QPainterPath highlightedPoly;
+				highlightedPoly.addPolygon(*iter);
+
+				painter.fillPath(highlightedPoly, QColor(210, 210, 210, 128));
+			}
+
+			++idx;
+		}
+	}
 }

CamelotEditor/Source/CmQtDynamicTabBar.cpp

@@ -2,11 +2,12 @@
 #include "CmException.h"
 #include <QtWidgets/QPushButton>
 #include <QtWidgets/QHBoxLayout>
+#include <QtGui/QPainter>
 
 namespace CamelotEditor
 {
 	QtDynamicTabBar::QtDynamicTabBar(QWidget* parent)
-		:QWidget(parent), mHLayout(nullptr)
+		:QWidget(parent), mHLayout(nullptr), dbg(false)
 	{
 		setupUi();
 	}
@@ -24,7 +25,7 @@ namespace CamelotEditor
 
 	void QtDynamicTabBar::insertTab(UINT32 idx, const QString& name)
 	{
-		if(idx >= (UINT32)mTabs.size())
+		if(idx > (UINT32)mTabs.size())
 			CM_EXCEPT(InvalidParametersException, "Index out of range: " + toString(idx) +". Valid range: 0 .. " + toString((UINT32)mTabs.size()));
 
 		QPushButton* newBtn = new QPushButton(this);
@@ -46,8 +47,92 @@ namespace CamelotEditor
 		updateTabs();
 	}
 
+	vector<QPolygon>::type QtDynamicTabBar::getDropLocations()
+	{
+		QPoint topLeft = mapToGlobal(QPoint(0, 0));
+		int curX = topLeft.x();
+		int endX = topLeft.x() + width();
+		int top = topLeft.y();
+		int bottom = topLeft.y() + height();
+
+		QRect rect(topLeft.x(), topLeft.y(), width(), height());
+
+		vector<QPolygon>::type polygons;
+		QPolygon polygon(4);
+
+		polygon[0] = QPoint(curX, top);
+		polygon[1] = QPoint(curX, bottom);
+
+		for(auto iter = mTabs.begin(); iter != mTabs.end(); ++iter)
+		{
+			QPoint tabTopLeft = (*iter)->mapToGlobal(QPoint(0, 0));
+			curX = tabTopLeft.x();
+
+			polygon[2] = QPoint(curX, bottom);
+			polygon[3] = QPoint(curX, top);
+			polygons.push_back(polygon);
+
+			polygon = QPolygon(4);
+			curX = tabTopLeft.x() + (*iter)->width();
+			polygon[0] = QPoint(curX, top);
+			polygon[1] = QPoint(curX, bottom);
+		}
+
+		polygon[2] = QPoint(endX, bottom);
+		polygon[3] = QPoint(endX, top);
+		polygons.push_back(polygon);
+
+		return polygons;
+	}
+
+	void QtDynamicTabBar::enterEvent(QEvent *e)
+	{
+
+	}
+
+	void QtDynamicTabBar::leaveEvent(QEvent *e)
+	{
+
+	}
+
+	void QtDynamicTabBar::mousePressEvent(QMouseEvent* event)
+	{
+		QWidget::mousePressEvent(event);
+	}
+
+	void QtDynamicTabBar::mouseReleaseEvent(QMouseEvent* event)
+	{
+		dbg = true;
+		repaint();
+
+		QWidget::mouseReleaseEvent(event);
+	}
+
+	void QtDynamicTabBar::mouseMoveEvent(QMouseEvent* event)
+	{
+		dbg = false;
+		repaint();
+
+		QWidget::mouseMoveEvent(event);
+	}
+
+	void QtDynamicTabBar::paintEvent(QPaintEvent *event)
+	{
+		if(dbg)
+		{
+			QPainter painter(this);
+			painter.setRenderHint(QPainter::Antialiasing);
+			painter.setPen(QColor(208, 208, 208));
+			painter.setClipping(false);
+
+			painter.fillRect(0, 0, 100, 100, QColor(190, 190, 190, 128));
+		}
+	}
+
 	void QtDynamicTabBar::setupUi()
 	{
+		setMouseTracking(true);
+
 		mHLayout = new QHBoxLayout(this);
 		mHLayout->setMargin(0);
 
@@ -60,6 +145,8 @@ namespace CamelotEditor
 		while((item = mHLayout->takeAt(0)) != nullptr)
 			mHLayout->removeItem(item);
 
+		mHLayout->addSpacing(10);
+
 		UINT32 idx = 0;
 		for(auto iter = mTabs.begin(); iter != mTabs.end(); ++iter)
 		{

CamelotEditor/Source/CmQtEditorWindow.cpp

@@ -272,6 +272,32 @@ namespace CamelotEditor
 		return mStackedWidget; 
 	}
 
+	QWidget* QtEditorWindow::getTabWidget() const
+	{ 
+		return mTabBar; 
+	}
+
+	std::vector<QPolygon> QtEditorWindow::getTabBarDropLocations() const
+	{
+		return mTabBar->getDropLocations();
+	}
+
+	INT32 QtEditorWindow::getActiveTabBarDropLocation(const QPoint& mousePos) const
+	{
+		std::vector<QPolygon> dropLocations = getTabBarDropLocations();
+
+		INT32 idx = 0;
+		for(auto iter = dropLocations.begin(); iter != dropLocations.end(); ++iter)
+		{
+			if(iter->containsPoint(mousePos, Qt::OddEvenFill))
+				return idx;
+
+			idx++;
+		}
+
+		return -1;
+	}
+
 	void QtEditorWindow::enterEvent(QEvent *e)
 	{
 		mTimer->start(100);

CamelotEditor/Source/CmWindowDockManager.cpp

@@ -1,4 +1,5 @@
 #include "CmWindowDockManager.h"
+#include "CmEditorWindowManager.h"
 #include "CmQtEditorWindow.h"
 #include "CmDebug.h"
 
@@ -33,32 +34,81 @@ namespace CamelotEditor
 
 		if(!window->isDocked())
 		{
-			QtEditorWindow* windowUnderMouse = getDockedWindowAtPosition(mousePos);
+			vector<UINT32>::type windowsToIgnore;
+			windowsToIgnore.push_back(window->getId()); // Ignore myself
+
+			QtEditorWindow* windowUnderMouse = gEditorWindowManager().getWindowAtPosition(mousePos, windowsToIgnore);
 			QWidget* dragOverWidget = nullptr;
+
+			bool contentUnderMouse = false;
+			bool tabBarUnderMouse = false;
+
 			if(windowUnderMouse != nullptr)
+			{
 				dragOverWidget = windowUnderMouse->getContentWidget();
 
-			if(dragOverWidget == nullptr && isPositionInDockArea(mousePos))
+				QPoint localMousePos = dragOverWidget->mapFromGlobal(mousePos);
+				if(dragOverWidget->geometry().contains(localMousePos))
+					contentUnderMouse = true;
+				
+				QWidget* tabBarWidget = windowUnderMouse->getTabWidget();
+				localMousePos = tabBarWidget->mapFromGlobal(mousePos);
+				if(tabBarWidget->geometry().contains(localMousePos))
+					tabBarUnderMouse = true;
+			}
+
+			if(!tabBarUnderMouse && dragOverWidget == nullptr && isPositionInDockArea(mousePos))
+			{
 				dragOverWidget = mCentralWidget;
+				contentUnderMouse = true;
+			}
 
-			if(dragOverWidget != nullptr)
+			if(contentUnderMouse)
 			{
-				WindowDragDropLocation dragLocation = getDropLocationAtPosition(dragOverWidget, mousePos);
-				std::vector<QPolygon> dropLocations = getDropLocations(dragOverWidget);
+				mDockOverlayWidget->highlightTabDropLocation(-1);
+				mDockOverlayWidget->disableTabDropOverlay();
+
+				// Draw dock overlay
+				if(dragOverWidget != nullptr)
+				{
+					WindowDragDropLocation dragLocation = getDropLocationAtPosition(dragOverWidget, mousePos);
+					std::vector<QPolygon> dropLocations = getDropLocations(dragOverWidget);
 
-				QPoint drawOffset = mCentralWidget->mapToGlobal(QPoint(0, 0)) - mDockOverlayWidget->mapToGlobal(QPoint(0, 0));
+					QPoint drawOffset = mCentralWidget->mapToGlobal(QPoint(0, 0)) - mDockOverlayWidget->mapToGlobal(QPoint(0, 0));
 
-				mDockOverlayWidget->enableDropOverlay(dropLocations, drawOffset);
+					mDockOverlayWidget->enableDropOverlay(dropLocations, drawOffset);
 
-				if(dragLocation != CM_WINDROP_CENTER)
-					mDockOverlayWidget->highlightDropLocation(dragLocation);
+					if(dragLocation != CM_WINDROP_CENTER)
+						mDockOverlayWidget->highlightDropLocation(dragLocation);
+					else
+						mDockOverlayWidget->highlightDropLocation(CM_WINDROP_NONE);
+				}
 				else
+				{
 					mDockOverlayWidget->highlightDropLocation(CM_WINDROP_NONE);
+					mDockOverlayWidget->disableDropOverlay();
+				}
 			}
-			else
+
+			if(tabBarUnderMouse)
 			{
 				mDockOverlayWidget->highlightDropLocation(CM_WINDROP_NONE);
 				mDockOverlayWidget->disableDropOverlay();
+
+				// Draw tab bar overlay
+				if(windowUnderMouse != nullptr)
+				{
+					std::vector<QPolygon> tabDropLocations = windowUnderMouse->getTabBarDropLocations();
+					INT32 activeTabDropLocation = windowUnderMouse->getActiveTabBarDropLocation(mousePos);
+
+					if(activeTabDropLocation != -1)
+					{
+						QPoint drawOffset = -mDockOverlayWidget->mapToGlobal(QPoint(0, 0));
+						mDockOverlayWidget->enableTabDropOverlay(tabDropLocations, drawOffset);
+				
+						mDockOverlayWidget->highlightTabDropLocation(activeTabDropLocation);
+					}
+				}
 			}
 		}
 		else
@@ -77,6 +127,9 @@ namespace CamelotEditor
 		mDockOverlayWidget->highlightDropLocation(CM_WINDROP_NONE);
 		mDockOverlayWidget->disableDropOverlay();
 
+		mDockOverlayWidget->highlightTabDropLocation(-1);
+		mDockOverlayWidget->disableTabDropOverlay();
+
 		if(mLastDraggedWindow != window)
 		{
 			mLastDragPosition = mousePos;
@@ -88,11 +141,46 @@ namespace CamelotEditor
 
 		if(wasDragged && !window->isDocked())
 		{
-			QtEditorWindow* windowUnderCursor = getDockedWindowAtPosition(mousePos);
+			vector<UINT32>::type windowsToIgnore;
+			windowsToIgnore.push_back(window->getId()); // Ignore myself
+			QtEditorWindow* windowUnderCursor = gEditorWindowManager().getWindowAtPosition(mousePos, windowsToIgnore);
+
 			if(windowUnderCursor != nullptr)
 			{
-				WindowDragDropLocation dropLocation = getDropLocationAtPosition(windowUnderCursor->getContentWidget(), mousePos);
-				dockWindow(window, windowUnderCursor, dropLocation);
+				bool contentUnderMouse = false;
+				bool tabBarUnderMouse = false;
+
+				QWidget* contentWidget = windowUnderCursor->getContentWidget();
+				QPoint localMousePos = contentWidget->mapFromGlobal(mousePos);
+				if(contentWidget->geometry().contains(localMousePos))
+					contentUnderMouse = true;
+
+				QWidget* tabBarWidget = windowUnderCursor->getTabWidget();
+				localMousePos = tabBarWidget->mapFromGlobal(mousePos);
+				if(tabBarWidget->geometry().contains(localMousePos))
+					tabBarUnderMouse = true;
+
+				if(contentUnderMouse)
+				{
+					WindowDragDropLocation dropLocation = getDropLocationAtPosition(windowUnderCursor->getContentWidget(), mousePos);
+					dockWindow(window, windowUnderCursor, dropLocation);
+				}
+				else if(tabBarUnderMouse)
+				{
+					INT32 dropLocation = windowUnderCursor->getActiveTabBarDropLocation(mousePos);
+					if(dropLocation != -1)
+					{
+						while(window->getNumWidgets() > 0)
+						{
+							QtEditorWidget* widget = window->getWidget(0);
+
+							window->removeWidget(0);
+							windowUnderCursor->insertWidget(dropLocation, widget);
+						}
+
+						window->closeWindow();
+					}
+				}
 			}
 			else
 			{
@@ -133,26 +221,6 @@ namespace CamelotEditor
 		return findIter->second.parentId;
 	}
 
-	QtEditorWindow* WindowDockManager::getDockedWindowAtPosition(const QPoint& globalPos)
-	{
-		QtEditorWindow* foundWindow = nullptr;
-		for(auto iter = mDockedWindows.begin(); iter != mDockedWindows.end(); ++iter)
-		{
-			QtEditorWindow* curWindow = iter->first;
-			QPoint globalWidgetPos = curWindow->mapToGlobal(QPoint(0, 0));
-
-			QRect widgetRect(globalWidgetPos, curWindow->geometry().size());
-
-			if(widgetRect.contains(globalPos))
-			{
-				foundWindow = curWindow;
-				break;
-			}
-		}
-
-		return foundWindow;
-	}
-
 	bool WindowDockManager::isPositionInDockArea(const QPoint& globalPos)
 	{
 		QPoint globalWidgetPos = mCentralWidget->mapToGlobal(QPoint(0, 0));

TODOEditor.txt

@@ -36,4 +36,12 @@ When restoring windows what happens why I try to restore an unloaded plugin?
  - A NullWindow?
 
  After I undock a window it needs to return itself to the default size
-  - Allow widgets to specify default size
+  - Allow widgets to specify default size
+
+
+  WindowDockManager
+ Checks if we're mousing over any dock widgets
+ If not it checks if we're mousing over DynamicTabBar (in any open window)
+   If we are it gets the polygons from DynamicTabBar and renders them
+   Also gets the current polygon and highlights it
+   Upon mouse release it find exactly at what index the mouse was released and adds the widget to the tab bar