dockingmanager.cpp

Notepad++ is a generic source code editor (it tries to be anyway) and Notepad replacement written in

					   rcBottom.top   ,
					   rcBottom.right ,
					   rcBottom.bottom,
					   SWP_NOZORDER);
		_vSplitter[CONT_BOTTOM]->display();
	}

	if (_vContainer[CONT_TOP]->isVisible())
	{
		::SetWindowPos(_vContainer[CONT_TOP]->getHSelf(), NULL, 
					   _dockData.rcRegion[CONT_TOP].left  ,
					   _dockData.rcRegion[CONT_TOP].top   ,
					   _dockData.rcRegion[CONT_TOP].right ,
					   _dockData.rcRegion[CONT_TOP].bottom,
					   SWP_NOZORDER);
		_vSplitter[CONT_TOP]->display();
	}

	if (_vContainer[CONT_RIGHT]->isVisible())
	{
		::SetWindowPos(_vContainer[CONT_RIGHT]->getHSelf(), NULL, 
					   rcRight.left  ,
					   rcRight.top   ,
					   rcRight.right ,
					   rcRight.bottom,
					   SWP_NOZORDER);
		_vSplitter[CONT_RIGHT]->display();
	}

	if (_vContainer[CONT_LEFT]->isVisible())
	{
		::SetWindowPos(_vContainer[CONT_LEFT]->getHSelf(), NULL, 
					   _dockData.rcRegion[CONT_LEFT].left  ,
					   _dockData.rcRegion[CONT_LEFT].top   ,
					   _dockData.rcRegion[CONT_LEFT].right ,
					   _dockData.rcRegion[CONT_LEFT].bottom,
					   SWP_NOZORDER);
		_vSplitter[CONT_LEFT]->display();
	}

	(*_ppMainWindow)->reSizeTo(_rcWork);
}

void DockingManager::createDockableDlg(tTbData data, int iCont, bool isVisible)
{
	/* add icons */
	if (data.uMask & DWS_ICONTAB)
	{
		/* create image list if not exist */
		if (_hImageList == NULL)
		{
			_hImageList = ::ImageList_Create(14,14,ILC_COLOR8, 0, 0); 
		}

		/* add icon */
		::ImageList_AddIcon(_hImageList, data.hIconTab);

		/* do the reference here to find later the correct position */
		_vImageList.push_back(data.hClient);
	}

	/* create additional containers if necessary */
	RECT				rc			= {0,0,0,0};
	DockingCont*		pCont		= NULL;

	/* if floated rect not set */
	if (memcmp(&data.rcFloat, &rc, sizeof(RECT)) == 0)
	{
		/* set default rect state */
		::GetWindowRect(data.hClient, &data.rcFloat);

		/* test if dialog is first time created */
		if (iCont == -1)
		{
			/* set default visible state */
			isVisible = (::IsWindowVisible(data.hClient) == TRUE);

			if (data.uMask & DWS_DF_FLOATING)
			{
				/* create new container */
				pCont = new DockingCont;
				_vContainer.push_back(pCont);

				/* initialize */
				pCont->init(_hInst, _hSelf);
				pCont->doDialog(isVisible, true);

				/* get previous position and set container id */
				data.iPrevCont = (data.uMask & 0x30000000) >> 28;
				iCont	= _vContainer.size()-1;
			}
			else
			{
				/* set position */
				iCont = (data.uMask & 0x30000000) >> 28;

				/* previous container is not selected */
				data.iPrevCont = -1;
			}
		}
	}
	/* if one of the container was not created before */
	else if ((iCont >= DOCKCONT_MAX) || (data.iPrevCont >= DOCKCONT_MAX))
	{
        /* test if current container is in floating state */
		if (iCont >= DOCKCONT_MAX)
		{
			/* no mapping for available store mapping */
			if (_iContMap[iCont] == -1)
			{
				/* create new container */
				pCont = new DockingCont;
				_vContainer.push_back(pCont);

				/* initialize and map container id */
				pCont->init(_hInst, _hSelf);
				pCont->doDialog(isVisible, true);
				_iContMap[iCont] = _vContainer.size()-1;
			}

			/* get current container from map */
			iCont = _iContMap[iCont];
		}
		/* previous container is in floating state  */
		else
		{
			/* no mapping for available store mapping */
			if (_iContMap[data.iPrevCont] == -1)
			{
				/* create new container */
				pCont = new DockingCont;
				_vContainer.push_back(pCont);

				/* initialize and map container id */
				pCont->init(_hInst, _hSelf);
				pCont->doDialog(false, true);
				pCont->reSizeToWH(data.rcFloat);
				_iContMap[data.iPrevCont] = _vContainer.size()-1;
			}
			data.iPrevCont = _iContMap[data.iPrevCont];
		}
	}

	/* attach toolbar */
	_vContainer[iCont]->createToolbar(data, _ppMainWindow);

	/* notify client app */
	if (iCont < DOCKCONT_MAX)
		SendNotify(data.hClient, MAKELONG(DMN_DOCK, iCont));
	else
		SendNotify(data.hClient, MAKELONG(DMN_FLOAT, iCont));
}

void DockingManager::setActiveTab(int iCont, int iItem)
{
	if ((iCont == -1) || (_iContMap[iCont] == -1))
		return;

	_vContainer[_iContMap[iCont]]->setActiveTb(iItem);
}

DockingCont* DockingManager::toggleActiveTb(DockingCont* pContSrc, UINT message, BOOL bNew, LPRECT prcFloat)
{
	tTbData			TbData		= *pContSrc->getDataOfActiveTb();
	int				iContSrc	= GetContainer(pContSrc);
	int				iContPrev	= TbData.iPrevCont;
	BOOL			isCont		= ContExists(iContPrev);
	DockingCont*	pContTgt	= NULL;

	/* if new float position is given */
	if (prcFloat != NULL)
	{
		TbData.rcFloat = *prcFloat;
	}

	/* remove toolbar from anywhere */
	TbData = _vContainer[iContSrc]->destroyToolbar(TbData);

	if ((isCont == FALSE) || (bNew == TRUE))
	{
		/* find an empty container */
		int	iContNew = FindEmptyContainer();

		if (iContNew == -1)
		{
			/* if no free container is available create a new one */
			pContTgt = new DockingCont;
			pContTgt->init(_hInst, _hSelf);
			pContTgt->doDialog(true, true);

			/* change only on toggling */
			if ((bNew == FALSE) || (!pContSrc->isFloating()))
				TbData.iPrevCont = iContSrc;

			pContTgt->createToolbar(TbData, _ppMainWindow);
			_vContainer.push_back(pContTgt);
		}
		else
		{
			/* set new target */
			pContTgt = _vContainer[iContNew];

			/* change only on toggling */
			if ((pContSrc->isFloating()) != (pContTgt->isFloating()))
                TbData.iPrevCont = iContSrc;

			pContTgt->createToolbar(TbData, _ppMainWindow);
		}
	}
	else
	{
		/* set new target */
		pContTgt = _vContainer[iContPrev];
        
		/* change data normaly */
		TbData.iPrevCont = iContSrc;
		pContTgt->createToolbar(TbData, _ppMainWindow);
	}

	/* notify client app */
	SendNotify(TbData.hClient, MAKELONG(message==DMM_DOCK?DMN_DOCK:DMN_FLOAT, GetContainer(pContTgt)));

	return pContTgt;
}

DockingCont* DockingManager::toggleVisTb(DockingCont* pContSrc, UINT message, LPRECT prcFloat)
{
	vector<tTbData*>	vTbData		= pContSrc->getDataOfVisTb();
	tTbData*			pTbData		= pContSrc->getDataOfActiveTb();

	int					iContSrc	= GetContainer(pContSrc);
	int					iContPrev	= pTbData->iPrevCont;
	BOOL				isCont		= ContExists(iContPrev);
	DockingCont*		pContTgt	= NULL;

	/* at first hide container and resize */
	pContSrc->doDialog(false);
	onSize();

	for (size_t iTb = 0; iTb < vTbData.size(); iTb++)
	{
		/* get data one by another */
		tTbData		TbData = *vTbData[iTb];

		/* if new float position is given */
		if (prcFloat != NULL)
		{
			TbData.rcFloat = *prcFloat;
		}

		/* remove toolbar from anywhere */
		TbData = _vContainer[iContSrc]->destroyToolbar(TbData);

		if (isCont == FALSE)
		{
            /* create new container */
			pContTgt = new DockingCont;
			pContTgt->init(_hInst, _hSelf);
			pContTgt->doDialog(true, true);

			TbData.iPrevCont = iContSrc;
			pContTgt->createToolbar(TbData, _ppMainWindow);
			_vContainer.push_back(pContTgt);

			/* now container exists */
			isCont	= TRUE;
			iContPrev = GetContainer(pContTgt);
		}
		else
		{
			/* set new target */
			pContTgt = _vContainer[iContPrev];

			TbData.iPrevCont = iContSrc;
			pContTgt->createToolbar(TbData, _ppMainWindow);
		}

		SendNotify(TbData.hClient, MAKELONG(message==DMM_DOCK?DMN_DOCK:DMN_FLOAT, GetContainer(pContTgt)));
	}

	_vContainer[iContPrev]->setActiveTb(pTbData);
	return pContTgt;
}

void DockingManager::toggleActiveTb(DockingCont* pContSrc, DockingCont* pContTgt)
{
	tTbData		TbData		= *pContSrc->getDataOfActiveTb();

	toggleTb(pContSrc, pContTgt, TbData);			
}

void DockingManager::toggleVisTb(DockingCont* pContSrc, DockingCont* pContTgt)
{
	vector<tTbData*>	vTbData		= pContSrc->getDataOfVisTb();
	tTbData*			pTbData		= pContSrc->getDataOfActiveTb();

	/* at first hide container and resize */
	pContSrc->doDialog(false);
	onSize();

	for (size_t iTb = 0; iTb < vTbData.size(); iTb++)
	{
		/* get data one by another */
		tTbData		TbData = *vTbData[iTb];
		toggleTb(pContSrc, pContTgt, TbData);		
	}
	pContTgt->setActiveTb(pTbData);
}

void DockingManager::toggleTb(DockingCont* pContSrc, DockingCont* pContTgt, tTbData TbData)
{
	int					iContSrc	= GetContainer(pContSrc);
	int					iContTgt	= GetContainer(pContTgt);

	/* remove toolbar from anywhere */
	TbData = _vContainer[iContSrc]->destroyToolbar(TbData);

	/* test if container state changes from docking to floating or vice versa */
	if (((iContSrc <  DOCKCONT_MAX) && (iContTgt >= DOCKCONT_MAX)) ||
		((iContSrc >= DOCKCONT_MAX) && (iContTgt <  DOCKCONT_MAX)))
	{
		/* change states */
		TbData.iPrevCont = iContSrc;
	}

	/* notify client app */
	if (iContTgt < DOCKCONT_MAX)
		SendNotify(TbData.hClient, MAKELONG(DMN_DOCK, iContTgt));
	else
		SendNotify(TbData.hClient, MAKELONG(DMN_FLOAT, iContTgt));

	pContTgt->createToolbar(TbData, _ppMainWindow);	
}

BOOL DockingManager::ContExists(size_t iCont)
{
	BOOL	bRet = FALSE;

	if (iCont < _vContainer.size())
	{
		bRet = TRUE;
	}

	return bRet;
}

int DockingManager::GetContainer(DockingCont* pCont)
{
	int		iRet = -1;

	for (size_t iCont = 0; iCont < _vContainer.size(); iCont++)
	{
		if (_vContainer[iCont] == pCont)
		{
			iRet = iCont;
			break;
		}
	}

	return iRet;
}

int DockingManager::FindEmptyContainer(void)
{
    int      iRetCont       = -1;
    BOOL*    pPrevDockList  = (BOOL*) new BOOL[_vContainer.size()+1];
    BOOL*    pArrayPos      = &pPrevDockList[1];

    /* delete all entries */
    for (size_t iCont = 0; iCont < _vContainer.size()+1; iCont++)
    {
        pPrevDockList[iCont] = FALSE;
    }

    /* search for used floated containers */
    for (size_t iCont = 0; iCont < DOCKCONT_MAX; iCont++)
    {
        vector<tTbData*>    vTbData = _vContainer[iCont]->getDataOfAllTb();

        for (size_t iTb = 0; iTb < vTbData.size(); iTb++)
        {
            pArrayPos[vTbData[iTb]->iPrevCont] = TRUE;
        }
    }

    /* find free container */
    for (size_t iCont = DOCKCONT_MAX; iCont < _vContainer.size(); iCont++)
    {
        if (pArrayPos[iCont] == FALSE)
        {
            /* and test if container is hidden */
            if (!_vContainer[iCont]->isVisible())
            {
                iRetCont = iCont;
                break;
            }
        }
    }

    delete [] pPrevDockList;

    /* search for empty arrays */
    return iRetCont; 
}