#include "docklayout.h"
#include <assert.h>
#include <math.h>
#include <algorithm>
#include <QTextStream>
#include <QApplication>
#include <QDesktopWidget>
//========================================================
//TO DO:
// * Usa la macro QWIDGETSIZE_MAX per max grandezza settabile per una widget
// => Dopodiche', basterebbe troncare tutte le somme che eccedono quel valore... Comunque...
// * Il ricalcolo delle extremal sizes e' inutile nei resize events... Cerca di tagliare cose di questo tipo - ottimizza!
// => Pero' e' sensato in generale che redistribute possa ricalcolarle - forse si potrebbe fare una redistribute
// con un bool di ingresso. Se l'operazione contenitrice non puo' cambiare le extremal sizes, allora metti false..
// * Implementa gli stretch factors
// * Nascondere le finestre dockate...? Molto rognoso...
// * Una dock widget potrebbe non avere i soli stati docked e floating... Che succede se e' una subwindow
// non dockata in un dockLayout??
// * Spezzare tdockwindows.h in tmainwindow.h e tdockwidget.h, come in Qt?
// * Muovere o fare operazioni su una dockWidget allo stato attuale non e' sicuro se quella non e' assegnata ad
// un DockLayout!! Comunque, si puo' assumere che il parente di una DockWidget non sia nemmeno una QWidget
// che implementa un DockLayout. Questa cosa puo' venire meno in un'implementazione specifica come TDockWidget?
// Esempio: vedi calculateDockPlaceholders ad un drag, viene lanciato comunque...
// * Ha senso mettere DockLayout e DockWidget nella DVAPI? Forse se definissi delle inline opportune in TDockWidget...
// * Quanto contenuto in DockSeparator::mousePress e mouseMove dovrebbe essere reso pubblico. Anche la geometria
// delle regioni potrebbe essere editabile dall'utente... ma prima si dovrebbero fare gli stretch factors!!
// > Ossia: se si vuole esplicitamente settare la geometria di una regione, si potrebbe fare che quella
// si prende stretch factor infinito (o quasi), e gli altri 1...
// * Dovrebbe esistere un modo per specificare la posizione dei separatori da codice?
// Rognoso. Comunque, ora basta specificare la geometria delle widget prima del dock;
// la redistribute cerca di adattarsi.
// * Capita spesso di considerare l'ipotetica nuova radice della struttura. Perche' non metterla direttamente??
// X Non e' possibile coprire tutte le possibilita' di docking con il sistema attuale, anche se e' comunque piu'
// esteso di quello di Qt.
// Esempio: |
// -----|
// | | => !!
// |-----
// |
//========================================================
//------------------------
// Geometry inlines
//------------------------
//QRectF::toRect seems to work in the commented way inside the following function.
//Of course that way the rect borders are *not* approximated to the nearest integer
//coordinates:
// e.g.: topLeft= (1/3, 1/3); width= 4/3, height= 4/3 => left= top= right= bottom= 0.
inline QRect toRect(const QRectF &rect)
{
//return QRect(qRound(rect.left()), qRound(rect.top()), qRound(rect.width()), qRound(rect.height()));
return QRect(rect.topLeft().toPoint(), rect.bottomRight().toPoint() -= QPoint(1, 1));
}
//========================================================
//-----------------
// Dock Layout
//-----------------
DockLayout::DockLayout()
: m_maximizedDock(0), m_decoAllocator(new DockDecoAllocator())
{
}
//-------------------------------------
DockLayout::~DockLayout()
{
//Deleting Regions (separators are Widgets with parent, so they are recursively deleted)
unsigned int i;
for (i = 0; i < m_regions.size(); ++i)
delete m_regions[i];
//Deleting dockWidgets
for (i = 0; i < m_items.size(); ++i) {
//delete m_items[i]->widget();
delete m_items[i];
}
//Delete deco allocator
delete m_decoAllocator;
}
//-------------------------------------
inline int DockLayout::count() const
{
return m_items.size();
}
//-------------------------------------
inline void DockLayout::addItem(QLayoutItem *item)
{
DockWidget *addedItem = dynamic_cast<DockWidget *>(item->widget());
//Ensure that added item is effectively a DockWidget type;
assert(addedItem);
//Check if item is already under layout's control. If so, quit.
if (find(addedItem))
return;
//Force reparentation. This is required in order to ensure that all items possess
//the same geometry() reference. Also store parentLayout for convenience.
addedItem->m_parentLayout = this;
addedItem->setParent(parentWidget());
//Remember that reparenting a widget produces a window flags reset if the new
//parent is not the current one (see Qt's manual). So, first reassign standard
//floating flags, then call for custom appearance (which may eventually reassign the flags).
addedItem->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint);
addedItem->setFloatingAppearance();
m_items.push_back(item);
}
//-------------------------------------
inline QLayoutItem *DockLayout::takeAt(int idx)
{
if (idx < 0 || idx >= (int)m_items.size())
return 0;
QLayoutItem *item = m_items[idx];
DockWidget *dw = static_cast<DockWidget *>(item->widget());
//If docked, undock item
if (!dw->isFloating())
undockItem(dw);
//Reset item's parentLayout
dw->m_parentLayout = 0;
m_items.erase(m_items.begin() + idx);
return item;
}
//-------------------------------------
inline QLayoutItem *DockLayout::itemAt(int idx) const
{
if (idx >= (int)m_items.size())
return 0;
return m_items[idx];
}
//-------------------------------------
QWidget *DockLayout::widgetAt(int idx) const
{
return itemAt(idx)->widget();
}
//-------------------------------------
inline QSize DockLayout::minimumSize() const
{
if (!m_regions.empty()) {
Region *r = m_regions.front();
r->calculateExtremalSizes();
return QSize(r->m_minimumSize[0], r->m_minimumSize[1]);
}
return QSize(0, 0);
}
//-------------------------------------
inline QSize DockLayout::maximumSize() const
{
if (!m_regions.empty()) {
Region *r = m_regions.front();
r->calculateExtremalSizes();
return QSize(r->m_maximumSize[0], r->m_maximumSize[1]);
}
return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
}
//-------------------------------------
inline QSize DockLayout::sizeHint() const
{
QSize s(0, 0);
int n = m_items.size();
if (n > 0)
s = QSize(100, 70); //start with a nice default size
int i = 0;
while (i < n) {
QLayoutItem *o = m_items[i];
s = s.expandedTo(o->sizeHint());
++i;
}
return s + n * QSize(spacing(), spacing());
//return QSize(0,0);
}
//-------------------------------------
//----------------------
// Custom methods
//----------------------
QWidget *DockLayout::containerOf(QPoint point) const
{
//Search among regions, from leaf regions to root.
int i;
unsigned int j;
for (i = m_regions.size() - 1; i >= 0; --i) {
Region *currRegion = m_regions[i];
DockWidget *item = currRegion->getItem();
//First check if item contains it
if (item && item->geometry().contains(point))
return currRegion->getItem();
//Then, search among separators
for (j = 0; j < currRegion->separators().size(); ++j)
if (currRegion->separator(j)->geometry().contains(point))
return currRegion->separator(j);
}
return 0;
}
//-------------------------------------
inline void DockLayout::setMaximized(DockWidget *item, bool state)
{
if (item && state != item->m_maximized) {
if (state) {
//Maximize
if (m_maximizedDock) {
//If maximized already exists, normalize it
Region *r = find(m_maximizedDock);
m_maximizedDock->setGeometry(toRect(r->getGeometry()));
m_maximizedDock->m_maximized = false;
}
//Now, attempt requested item maximization
QSize minimumSize = item->minimumSize();
QSize maximumSize = item->maximumSize();
if (contentsRect().width() > minimumSize.width() && contentsRect().height() > minimumSize.height() &&
contentsRect().width() < maximumSize.width() && contentsRect().height() < maximumSize.height()) {
//Maximization succeeds
item->setGeometry(contentsRect());
item->raise();
item->m_maximized = true;
m_maximizedDock = item;
//Hide all the other docked widgets (no need to update them. Moreover, doing so
//could eventually result in painting over the newly maximized widget)
DockWidget *currWidget;
for (int i = 0; i < count(); ++i) {
currWidget = (DockWidget *)itemAt(i)->widget();
if (currWidget != item && !currWidget->isFloating())
currWidget->hide();
}
}
} else {
//Normalize
Region *r = find(m_maximizedDock);
if (r)
m_maximizedDock->setGeometry(toRect(r->getGeometry()));
m_maximizedDock->m_maximized = false;
m_maximizedDock = 0;
//Show all other docked widgets
DockWidget *currWidget;
for (int i = 0; i < count(); ++i) {
currWidget = (DockWidget *)itemAt(i)->widget();
if (currWidget != item && !currWidget->isFloating())
currWidget->show();
}
}
}
}
//======================================================================
//======================================
// Layout Geometry Handler
//======================================
//!NOTE: This method is currently unused by DockLayout implementation...
void DockLayout::setGeometry(const QRect &rect)
{
//Just pass the info to the widget (it's somehow necessary...)
QLayout::setGeometry(rect);
}
//--------------------------------------------------------------------------
//!Defines cursors for separators of the layout: if it is not possible to
//!move a separator, its cursor must be an arrow.
inline void DockLayout::updateSeparatorCursors()
{
Region *r, *child;
unsigned int i, j;
int k, jInt;
for (i = 0; i < m_regions.size(); ++i) {
r = m_regions[i];
bool orientation = r->getOrientation();
//If region geometry is minimal or maximal, its separators are blocked
//NOTE: If this update follows only from a dock/undock, this should be disabled 'til 'Otherwise'
QSize size = toRect(r->getGeometry()).size();
bool isExtremeSize = (orientation == Region::horizontal) ? size.width() == r->getMinimumSize(Region::horizontal) || size.width() == r->getMaximumSize(Region::horizontal) : size.height() == r->getMinimumSize(Region::vertical) || size.height() == r->getMaximumSize(Region::vertical);
if (isExtremeSize) {
for (j = 0; j < r->separators().size(); ++j)
r->separator(j)->setCursor(Qt::ArrowCursor);
continue;
}
//Otherwise...
//Arrowize all separators as long as the preceding region has equal
//maximum and minimum sizes
for (j = 0; j < r->getChildList().size(); ++j) {
child = r->childRegion(j);
if (child->getMaximumSize(orientation) == child->getMinimumSize(orientation))
r->separator(j)->setCursor(Qt::ArrowCursor);
else
break;
}
jInt = j;
//The same as above in reverse order
for (k = r->getChildList().size() - 1; k > jInt; --k) {
child = r->childRegion(k);
if (child->getMaximumSize(orientation) == child->getMinimumSize(orientation))
r->separator(k - 1)->setCursor(Qt::ArrowCursor);
else
break;
}
//Middle separators have a split cursor
Qt::CursorShape shape = (orientation == Region::horizontal) ? Qt::SplitHCursor : Qt::SplitVCursor;
for (; jInt < k; ++jInt)
r->separator(jInt)->setCursor(shape);
}
}
//--------------------------------------------------------------------------
//!Applies Regions geometry to dock widgets and separators.
void DockLayout::applyGeometry()
{
//Update docked window's geometries
unsigned int i, j;
for (i = 0; i < m_regions.size(); ++i) {
Region *r = m_regions[i];
const std::deque<Region *> &childList = r->getChildList();
std::deque<DockSeparator *> &sepList = r->m_separators;
if (m_regions[i]->getItem()) {
m_regions[i]->getItem()->setGeometry(toRect(m_regions[i]->getGeometry()));
} else {
for (j = 0; j < sepList.size(); ++j) {
QRect leftAdjRect = toRect(childList[j]->getGeometry());
if (r->getOrientation() == Region::horizontal) {
leftAdjRect.adjust(0, 0, 1, 0); //Take adjacent-to topRight pixel
sepList[j]->setGeometry(QRect(leftAdjRect.topRight(), QSize(spacing(), leftAdjRect.height())));
sepList[j]->m_index = j;
} else {
leftAdjRect.adjust(0, 0, 0, 1);
sepList[j]->setGeometry(QRect(leftAdjRect.bottomLeft(), QSize(leftAdjRect.width(), spacing())));
sepList[j]->m_index = j;
}
}
}
}
//If there is a maximized widget, reset its geometry to that of the main region
if (m_maximizedDock) {
m_maximizedDock->setGeometry(toRect(m_regions[0]->getGeometry()));
m_maximizedDock->raise();
}
//Finally, update separator cursors.
updateSeparatorCursors();
}
//------------------------------------------------------
void DockLayout::applyTransform(const QTransform &transform)
{
unsigned int i;
for (i = 0; i < m_regions.size(); ++i)
m_regions[i]->setGeometry(transform.mapRect(m_regions[i]->getGeometry()));
}
//------------------------------------------------------
void DockLayout::redistribute()
{
if (!m_regions.empty()) {
//Recompute extremal region sizes
//NOTA: Sarebbe da fare solo se un certo flag lo richiede; altrimenti tipo per resize events e' inutile...
m_regions.front()->calculateExtremalSizes();
int parentWidth = contentsRect().width();
int parentHeight = contentsRect().height();
//Always check main window consistency before effective redistribution. DO NOT ERASE or crashes may occur...
if (m_regions.front()->getMinimumSize(Region::horizontal) > parentWidth ||
m_regions.front()->getMinimumSize(Region::vertical) > parentHeight ||
m_regions.front()->getMaximumSize(Region::horizontal) < parentWidth ||
m_regions.front()->getMaximumSize(Region::vertical) < parentHeight)
return;
//Recompute Layout geometry
m_regions.front()->setGeometry(contentsRect());
m_regions.front()->redistribute();
}
//Finally, apply Region geometries found
applyGeometry();
}
//======================================================================
//=============================
// Region implementation
//=============================
Region::~Region()
{
//Delete separators
unsigned int i;
for (i = 0; i < m_separators.size(); ++i)
delete m_separators[i];
}
//------------------------------------------------------
//!Inserts DockSeparator \b sep in \b this Region
inline void Region::insertSeparator(DockSeparator *sep)
{
m_separators.push_back(sep);
}
//------------------------------------------------------
//!Removes a DockSeparator from \b this Region
inline void Region::removeSeparator()
{
delete m_separators.back();
m_separators.pop_back();
}
//------------------------------------------------------
inline void Region::insertSubRegion(Region *subRegion, int idx)
{
m_childList.insert(m_childList.begin() + idx, subRegion);
subRegion->m_parent = this;
subRegion->m_orientation = !m_orientation;
}
//------------------------------------------------------
//!Inserts input \b item before position \b idx. Returns associated new region.
inline Region *Region::insertItem(DockWidget *item, int idx)
{
Region *newRegion = new Region(m_owner, item);
if (this)
insertSubRegion(newRegion, idx);
return newRegion;
}
//=============================================================
unsigned int Region::find(const Region *subRegion) const
{
unsigned int i;
for (i = 0; i < m_childList.size(); ++i)
if (m_childList[i] == subRegion)
return i;
return -1;
}
//------------------------------------------------------
Region *DockLayout::find(DockWidget *item) const
{
unsigned int i;
for (i = 0; i < m_regions.size(); ++i)
if (m_regions[i]->getItem() == item)
return m_regions[i];
return 0;
}
//------------------------------------------------------
//!Calculates possible docking solutions for \b this
//!dock widget. They are stored into the dock widget.
//!\b NOTE: Placeholders are here calculated by decreasing importance;
//!in other words, if two rects are part of the layout, and the first
//!contains the second, placeholders of the first are found before
//!those of the second. This fact may be exploited when selecting an
//!appropriate placeholder for docking.
void DockLayout::calculateDockPlaceholders(DockWidget *item)
{
assert(item);
//If the DockLayout's owner widget is hidden, avoid
if (!parentWidget()->isVisible())
return;
if (!m_regions.size()) {
if (isPossibleInsertion(item, 0, 0)) {
//Then insert a root placeholder only
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, 0, 0, DockPlaceholder::root));
return;
}
}
//For all regions (and for all insertion index), check if
//insertion may succeed.
//NOTE: Insertion chance is just the same for all indexes in a given
//parent region...
//First check parentRegion=0 (under a new Root - External cases)
if (isPossibleInsertion(item, 0, 0)) {
QRect contRect = contentsRect();
if (m_regions.front()->getOrientation() == Region::horizontal) {
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, 0, 0, DockPlaceholder::top));
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, 0, 1, DockPlaceholder::bottom));
} else {
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, 0, 0, DockPlaceholder::left));
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, 0, 1, DockPlaceholder::right));
}
}
unsigned int i;
for (i = 0; i < m_regions.size(); ++i) {
Region *r = m_regions[i];
r->m_placeholders.clear();
if (isPossibleInsertion(item, r, 0)) {
unsigned int j;
QRect cellRect;
//For all indices, insert a placeholder
if (r->getOrientation() == Region::horizontal) {
//Left side
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, 0, DockPlaceholder::left));
r->m_placeholders.push_back(item->m_placeholders.back());
//Separators
for (j = 1; j < r->getChildList().size(); ++j) {
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, j, DockPlaceholder::sepVert));
r->m_placeholders.push_back(item->m_placeholders.back());
}
//Right side
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, j, DockPlaceholder::right));
r->m_placeholders.push_back(item->m_placeholders.back());
} else {
//Top side
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, 0, DockPlaceholder::top));
r->m_placeholders.push_back(item->m_placeholders.back());
for (j = 1; j < r->getChildList().size(); ++j) {
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, j, DockPlaceholder::sepHor));
r->m_placeholders.push_back(item->m_placeholders.back());
}
//Bottom side
item->m_placeholders.push_back(item->m_decoAllocator->newPlaceBuilt(item, r, j, DockPlaceholder::bottom));
r->m_placeholders.push_back(item->m_placeholders.back());
}
}
}
//Disable all placeholders
//for(i=0; i<item->m_placeholders.size(); ++i)
// item->m_placeholders[i]->setDisabled(true);
}
//------------------------------------------------------
//!Docks input \b item before position \b idx of region \b r. Deals with overall region hierarchy.
//!\b NOTE: Docked items are forcedly shown.
void DockLayout::dockItem(DockWidget *item, DockPlaceholder *place)
{
place->hide();
item->hide();
dockItemPrivate(item, place->m_region, place->m_idx);
redistribute();
parentWidget()->repaint();
item->setWindowFlags(Qt::SubWindow);
item->show();
}
//------------------------------------------------------
//!Docks input \b item at side \b regionside of \b target dock widget.
//!RegionSide can be Region::left, right, top or bottom.
void DockLayout::dockItem(DockWidget *item, DockWidget *target, int regionSide)
{
Region *targetRegion = find(target);
short var = regionSide >> 2 * (int)targetRegion->getOrientation();
bool pos = regionSide & 0xa;
item->setWindowFlags(Qt::SubWindow);
item->show();
if (var & 0x3) {
//Side is coherent with orientation => Direct insertion at position 0 or 1
dockItemPrivate(item, targetRegion, pos);
} else {
//Side is not coherent - have to find target's index in parent region
Region *parentRegion = targetRegion->getParent();
unsigned int idx = parentRegion ? parentRegion->find(targetRegion) + pos : pos;
dockItemPrivate(item, parentRegion, idx);
}
}
//------------------------------------------------------
//!Docks input \b item into Region \b r, at position \b idx; returns region corresponding to
//!newly inserted item.
//!\b NOTE: Unlike dockItem(DockWidget*,DockPlaceholder*) and undockItem, this
//!method is supposedly called directly into application code; therefore, no \b redistribution
//!is done after a single dock - you are supposed to manually call redistribute() after
//!all widgets have been docked.
Region *DockLayout::dockItem(DockWidget *item, Region *r, int idx)
{
item->setWindowFlags(Qt::SubWindow);
item->show();
return dockItemPrivate(item, r, idx);
}
//------------------------------------------------------
//Internal docking function. Contains raw docking code, excluded reparenting (setWindowFlags)
//which may slow down a bit - should be done only after a redistribute() and a repaint() on
//real-time docking.
inline Region *DockLayout::dockItemPrivate(DockWidget *item, Region *r, int idx)
{
// hide minimize button in FlipboolPanel
item->onDock(true);
item->setDockedAppearance();
item->m_floating = false;
if (!r) {
//Insert new root region
Region *newRoot = new Region(this);
m_regions.push_front(newRoot);
newRoot->setSize(item->size());
if (m_regions.size() == 1) {
newRoot->setItem(item);
return newRoot;
}
newRoot->setOrientation(!m_regions[1]->getOrientation());
newRoot->insertSubRegion(m_regions[1], 0);
r = newRoot;
} else if (r->getItem()) {
//Then the Layout gets further subdived - r's item has to be moved
Region *regionForOldItem = r->insertItem(r->getItem(), 0);
regionForOldItem->setSize(r->getItem()->size());
//regionForOldItem->setSize(r->getItem()->frameSize());
r->setItem(0);
m_regions.push_back(regionForOldItem);
}
Region *newRegion = r->insertItem(item, idx);
m_regions.push_back(newRegion);
//Temporarily setting suggested size for newly inserted region
newRegion->setSize(item->size());
//Finally, insert a new DockSeparator in parent region r.
r->insertSeparator(m_decoAllocator->newSeparator(this, r->getOrientation(), r));
return newRegion;
}
//------------------------------------------------------
//!A region is empty, if contains no item and no children.
inline bool isEmptyRegion(Region *r)
{
if ((!r->getItem()) && (r->getChildList().size() == 0)) {
delete r; //Be', e' un po' improprio, ma funziona...
return true;
}
return false;
}
//------------------------------------------------------
//!Removes input item from region
inline void Region::removeItem(DockWidget *item)
{
if (item == 0)
return;
unsigned int i;
for (i = 0; i < m_childList.size(); ++i)
if (item == m_childList[i]->getItem()) {
m_childList.erase(m_childList.begin() + i);
removeSeparator();
//parent Region may collapse; then move item back to parent and update its parent
if (m_childList.size() == 1) {
Region *parent = getParent();
if (parent) {
Region *remainingSon = m_childList[0];
if (!remainingSon->m_childList.size()) {
//remainingSon is a leaf: better keep this and move son's item and childList
setItem(remainingSon->getItem());
remainingSon->setItem(0);
} else {
//remainingSon is a branch: append remainingSon childList to parent one and
//sign this and remainingSon nodes for destruction.
//First find this position in parent
unsigned int j = parent->find(this);
parent->m_childList.erase(parent->m_childList.begin() + j);
parent->m_childList.insert(parent->m_childList.begin() + j, remainingSon->m_childList.begin(),
remainingSon->m_childList.end());
parent->m_separators.insert(parent->m_separators.begin() + j, remainingSon->m_separators.begin(),
remainingSon->m_separators.end());
//Update remainingSon children's and DockSeparator's parent
for (j = 0; j < remainingSon->m_childList.size(); ++j)
remainingSon->m_childList[j]->m_parent = parent;
for (j = 0; j < remainingSon->m_separators.size(); ++j)
remainingSon->m_separators[j]->m_parentRegion = parent;
remainingSon->m_childList.clear();
remainingSon->m_separators.clear();
}
} else {
//Root case; better keep the remaining child
m_childList[0]->setParent(0);
}
m_childList.clear();
}
break;
}
}
//------------------------------------------------------
//!Undocks \b item and updates geometry.
//!\b NOTE: Window flags are resetted to floating appearance (thus hiding the widget). Since the geometry
//!reference changes a geometry() update may be needed - so item's show() is not forced here. You should
//!eventually remember to call it manually after this.
bool DockLayout::undockItem(DockWidget *item)
{
//Find item's region index in m_regions
Region *itemCarrier = find(item);
Region *parent = itemCarrier->getParent();
if (parent) {
int removalIdx = 0;
//Find removal index in parent's childList
unsigned int j;
for (j = 0; j < parent->getChildList().size(); ++j)
if (parent->getChildList()[j]->getItem() == item)
break;
if (isPossibleRemoval(item, parent, removalIdx))
parent->removeItem(item);
else
return false;
}
//Remove region in regions list
//m_regions.erase(i); //Don't - m_regions is cleaned before the end by remove_if
itemCarrier->setItem(0);
std::deque<Region *>::iterator j;
j = std::remove_if(m_regions.begin(), m_regions.end(), isEmptyRegion);
m_regions.resize(j - m_regions.begin());
//Update status
//qDebug("Undock");
item->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint);
//NOTA: Usando la flag Qt::Window il focus viene automaticamente riassegnato, con un po' di ritardo.
//Usando Tool questo non accade. In questo caso, i placeholder devono essere disattivati...
item->setFloatingAppearance();
item->m_floating = true;
//show minimize button in FlipbookPanel
item->onDock(false);
setMaximized(item, false);
redistribute();
return true;
}
//=============================================================
//!Search for the \b nearest n-ple from a \b target one, under conditions:
//!\b 1) nearest elements belong to \b fixed \b intervals; \b 2) their \b sum is \b fixed too.
inline void calculateNearest(std::vector<double> target, std::vector<double> &nearest,
std::vector<std::pair<int, int>> intervals, double sum)
{
//Solving a small Lagrange multipliers problem to find solution on constraint (2)
assert(target.size() == intervals.size());
unsigned int i;
double targetSum = 0;
for (i = 0; i < target.size(); ++i)
targetSum += target[i];
double multiplier = (sum - targetSum) / (double)target.size();
nearest.resize(target.size());
for (i = 0; i < target.size(); ++i)
nearest[i] = target[i] + multiplier;
//Now, constraint (1) is not met; however, satisfying also (2) yields a hyperRect
//on which we must find the nearest point to our above partial solution. In particular,
//it can be demonstrated that at least one coordinate of the current partial solution is related
//to the final one (...). This mean that we may have to solve sub-problems of this same kind,
//with less variable coordinates.
unsigned int max;
double distance, maxDistance = 0;
for (i = 0; i < target.size(); ++i) {
if (nearest[i] < intervals[i].first || nearest[i] > intervals[i].second) {
distance = nearest[i] < intervals[i].first ? intervals[i].first - nearest[i] : nearest[i] - intervals[i].second;
nearest[i] = nearest[i] < intervals[i].first ? intervals[i].first : intervals[i].second;
if (maxDistance < distance) {
maxDistance = distance;
max = i;
}
}
}
std::vector<double> newTarget = target;
std::vector<double> newNearest;
std::vector<std::pair<int, int>> newIntervals = intervals;
if (maxDistance) {
newTarget.erase(newTarget.begin() + max);
newIntervals.erase(newIntervals.begin() + max);
sum -= nearest[max];
calculateNearest(newTarget, newNearest, newIntervals, sum);
for (i = 0; i < max; ++i)
nearest[i] = newNearest[i];
for (i = max + 1; i < nearest.size(); ++i)
nearest[i] = newNearest[i - 1];
} else
return;
}
//------------------------------------------------------
//!Equally redistribute separators and children regions' internal geometry
//!according to current subregion sizes.
void Region::redistribute()
{
if (!m_childList.size())
return;
bool expansion =
m_minimumSize[Region::horizontal] > m_rect.width() ||
m_minimumSize[Region::vertical] > m_rect.height();
double regionSize[2];
//If there is no need to expand this region, maintain current geometry; otherwise, expand at minimum.
regionSize[Region::horizontal] = expansion ? m_minimumSize[Region::horizontal] : m_rect.width();
regionSize[Region::vertical] = expansion ? m_minimumSize[Region::vertical] : m_rect.height();
//However, expansion in the oriented direction has to take care of parent's consense.
if (m_parent != 0)
regionSize[m_orientation] = std::min((double)m_parent->m_maximumSize[m_orientation], regionSize[m_orientation]);
//Now find nearest-to-preferred window sizes, according to size constraints.
unsigned int i;
//First build target sizes vector
std::vector<double> targetSizes(m_childList.size());
for (i = 0; i < m_childList.size(); ++i) {
//Assuming preferred sizes are those already present before redistribution.
targetSizes[i] = (m_orientation == Region::horizontal) ? m_childList[i]->m_rect.width() : m_childList[i]->m_rect.height();
}
//Build minimum and maximum size constraints
std::vector<std::pair<int, int>> sizeIntervals(m_childList.size());
for (i = 0; i < m_childList.size(); ++i) {
sizeIntervals[i].first = m_childList[i]->m_minimumSize[m_orientation];
sizeIntervals[i].second = m_childList[i]->m_maximumSize[m_orientation];
}
//Build width sum
int separatorWidth = m_owner->spacing();
double sum = regionSize[m_orientation] - (m_childList.size() - 1) * separatorWidth;
std::vector<double> nearestSizes;
calculateNearest(targetSizes, nearestSizes, sizeIntervals, sum);
//NearestSizes stores optimal subregion sizes; calculate their geometries and assign them.
QPointF topLeftCorner = m_rect.topLeft();
if (m_orientation == horizontal) {
for (i = 0; i < m_childList.size(); ++i) {
QSizeF currSize = QSizeF(nearestSizes[i], regionSize[vertical]);
m_childList[i]->setGeometry(QRectF(topLeftCorner, currSize));
topLeftCorner = m_childList[i]->getGeometry().topRight() + QPointF(separatorWidth, 0);
}
} else {
for (i = 0; i < m_childList.size(); ++i) {
QSizeF currSize = QSizeF(regionSize[horizontal], nearestSizes[i]);
m_childList[i]->setGeometry(QRectF(topLeftCorner, currSize));
topLeftCorner = m_childList[i]->getGeometry().bottomLeft() + QPointF(0, separatorWidth);
}
}
//Finally, redistribute region's children
for (i = 0; i < m_childList.size(); ++i)
m_childList[i]->redistribute();
}
//------------------------------------------------------
//!Calculates maximum and minimum sizes for each sub-region.
void Region::calculateExtremalSizes()
{
calculateMinimumSize(horizontal, true);
calculateMinimumSize(vertical, true);
calculateMaximumSize(horizontal, true);
calculateMaximumSize(vertical, true);
}
//------------------------------------------------------
//!Calculates minimum occupiable space in \b this region on given \b direction. Also stores cache for it.
int Region::calculateMinimumSize(bool direction, bool recalcChildren)
{
int sumMinSizes = 0, maxMinSizes = 0;
if (m_item) {
sumMinSizes = maxMinSizes = (direction == horizontal) ? m_item->minimumSize().width() : m_item->minimumSize().height();
} else {
unsigned int i;
int currMinSize;
//If required, recalculate children sizes along our direction.
if (recalcChildren) {
for (i = 0; i < m_childList.size(); ++i)
m_childList[i]->calculateMinimumSize(direction, true);
}
for (i = 0; i < m_childList.size(); ++i) {
sumMinSizes += currMinSize = m_childList[i]->getMinimumSize(direction);
if (maxMinSizes < currMinSize)
maxMinSizes = currMinSize;
}
//Add separators width
sumMinSizes += m_separators.size() * m_owner->spacing();
}
//If m_orientation is coherent with input direction, minimum occupied space is the sum
//of childs' minimumSizes. Otherwise, the maximum is taken.
if (m_orientation == direction) {
return m_minimumSize[direction] = sumMinSizes;
} else {
return m_minimumSize[direction] = maxMinSizes;
}
}
//------------------------------------------------------
//!Calculates maximum occupiable space in \b this region on given \b direction. Also stores cache for it.
//NOTE: Effectively the dual of calculateMinimumSize(int).
int Region::calculateMaximumSize(bool direction, bool recalcChildren)
{
const int inf = 1000000;
int sumMaxSizes = 0, minMaxSizes = inf;
if (m_item) {
sumMaxSizes = minMaxSizes = (direction == horizontal) ? m_item->maximumSize().width() : m_item->maximumSize().height();
} else {
unsigned int i;
int currMaxSize;
//If required, recalculate children sizes along our direction.
if (recalcChildren) {
for (i = 0; i < m_childList.size(); ++i)
m_childList[i]->calculateMaximumSize(direction, true);
}
for (i = 0; i < m_childList.size(); ++i) {
sumMaxSizes += currMaxSize = m_childList[i]->getMaximumSize(direction);
if (minMaxSizes > currMaxSize)
minMaxSizes = currMaxSize;
}
//Add separators width
sumMaxSizes += m_separators.size() * m_owner->spacing();
}
//If m_orientation is coherent with input direction, maximum occupied space is the sum
//of childs' maximumSizes. Otherwise, the minimum is taken.
if (m_orientation == direction) {
return m_maximumSize[direction] = sumMaxSizes;
} else {
return m_maximumSize[direction] = minMaxSizes;
}
}
//------------------------------------------------------
inline bool Region::addItemSize(DockWidget *item)
{
int sepWidth = m_owner->spacing();
if (m_orientation == horizontal) {
//Add minimum and maximum horizontal sizes
m_minimumSize[horizontal] += item->getDockedMinimumSize().width() + sepWidth;
m_maximumSize[horizontal] += item->getDockedMaximumSize().width() + sepWidth;
//Make max and min with vertical extremal sizes
m_minimumSize[vertical] = std::max(m_minimumSize[vertical], item->getDockedMinimumSize().height());
m_maximumSize[vertical] = std::min(m_maximumSize[vertical], item->getDockedMaximumSize().height());
} else {
//Viceversa
m_minimumSize[vertical] += item->getDockedMinimumSize().height() + sepWidth;
m_maximumSize[vertical] += item->getDockedMaximumSize().height() + sepWidth;
m_minimumSize[horizontal] = std::max(m_minimumSize[horizontal], item->getDockedMinimumSize().width());
m_maximumSize[horizontal] = std::min(m_maximumSize[horizontal], item->getDockedMaximumSize().width());
}
if (m_minimumSize[horizontal] > m_maximumSize[horizontal] ||
m_minimumSize[vertical] > m_maximumSize[vertical])
return false;
//Now, climb parent hierarchy and update extremal sizes. If minSizes get > maxSizes, return failed insertion
Region *r = m_parent;
while (r) {
r->calculateMinimumSize(horizontal, false);
r->calculateMinimumSize(vertical, false);
r->calculateMaximumSize(horizontal, false);
r->calculateMaximumSize(vertical, false);
if (r->getMinimumSize(horizontal) > r->getMaximumSize(horizontal) ||
r->getMinimumSize(vertical) > r->getMaximumSize(vertical))
return false;
r = r->m_parent;
}
return true;
}
//------------------------------------------------------
inline bool Region::subItemSize(DockWidget *item)
{
int sepWidth = m_owner->spacing();
if (m_orientation == horizontal) {
//Subtract minimum and maximum horizontal sizes
m_minimumSize[horizontal] -= item->minimumSize().width() + sepWidth;
m_maximumSize[horizontal] -= item->maximumSize().width() + sepWidth;
//Recalculate opposite extremal sizes (without considering item)
unsigned int i;
for (i = 0; i < m_childList.size(); ++i)
if (m_childList[i]->getItem() != item) {
m_minimumSize[vertical] = std::max(m_minimumSize[vertical], m_childList[i]->getMinimumSize(vertical));
m_maximumSize[vertical] = std::min(m_maximumSize[vertical], m_childList[i]->getMaximumSize(vertical));
}
} else {
//Viceversa
m_minimumSize[vertical] -= item->minimumSize().height() + sepWidth;
m_maximumSize[vertical] -= item->maximumSize().height() + sepWidth;
//Recalculate opposite extremal sizes (without considering item)
unsigned int i;
for (i = 0; i < m_childList.size(); ++i)
if (m_childList[i]->getItem() != item) {
m_minimumSize[horizontal] = std::max(m_minimumSize[horizontal], m_childList[i]->getMinimumSize(horizontal));
m_maximumSize[horizontal] = std::min(m_maximumSize[horizontal], m_childList[i]->getMaximumSize(horizontal));
}
}
if (m_minimumSize[horizontal] > m_maximumSize[horizontal] ||
m_minimumSize[vertical] > m_maximumSize[vertical])
return false;
//Now, climb parent hierarchy and update extremal sizes. If minSizes get > maxSizes, return failed insertion
Region *r = m_parent;
while (r) {
r->calculateMinimumSize(horizontal, false);
r->calculateMinimumSize(vertical, false);
r->calculateMaximumSize(horizontal, false);
r->calculateMaximumSize(vertical, false);
if (r->getMinimumSize(horizontal) > r->getMaximumSize(horizontal) ||
r->getMinimumSize(vertical) > r->getMaximumSize(vertical))
return false;
r = r->m_parent;
}
return true;
}
//=============================================================
//!Checks insertion validity of \b item inside \b parentRegion at position \b insertionIdx.
inline bool DockLayout::isPossibleInsertion(DockWidget *item, Region *parentRegion, int insertionIdx)
{
const int inf = 1000000;
int mainWindowWidth = contentsRect().width();
int mainWindowHeight = contentsRect().height();
std::deque<Region *>::iterator i;
bool result = true;
if (m_regions.size()) {
//Calculate original extremal sizes
m_regions.front()->calculateExtremalSizes();
if (parentRegion) //Common case
{
//And update parent region extremal size after hypothetic insertion took place
result &= parentRegion->addItemSize(item);
} else //With root insertion
{
//Insertion under new root: simulated by adding with m_regions.front() on its opposite direction;
bool frontOrientation = m_regions.front()->getOrientation();
m_regions.front()->setOrientation(!frontOrientation);
result &= m_regions.front()->addItemSize(item);
m_regions.front()->setOrientation(frontOrientation);
}
}
QSize rootMinSize;
QSize rootMaxSize;
if (m_regions.size()) {
rootMinSize =
QSize(m_regions[0]->getMinimumSize(Region::horizontal), m_regions[0]->getMinimumSize(Region::vertical));
rootMaxSize =
QSize(m_regions[0]->getMaximumSize(Region::horizontal), m_regions[0]->getMaximumSize(Region::vertical));
} else {
//New Root
rootMinSize = item->minimumSize();
rootMaxSize = item->maximumSize();
}
//Finally, check updated root against main window sizes
if (rootMinSize.width() > mainWindowWidth ||
rootMinSize.height() > mainWindowHeight ||
rootMaxSize.width() < mainWindowWidth ||
rootMaxSize.height() < mainWindowHeight) {
result = false;
}
return result;
}
//------------------------------------------------------
//!Checks insertion validity of \b item inside \b parentRegion at position \b insertionIdx.
inline bool DockLayout::isPossibleRemoval(DockWidget *item, Region *parentRegion, int removalIdx)
{
//NOTE: parentRegion is necessarily !=0 or there's no need to check anything
if (!parentRegion)
return true;
const int inf = 1000000;
int mainWindowWidth = contentsRect().width();
int mainWindowHeight = contentsRect().height();
std::deque<Region *>::iterator i;
bool result = true;
//Calculate original extremal sizes
m_regions.front()->calculateExtremalSizes();
//And update parent region extremal size after hypothetic insertion took place
result &= parentRegion->subItemSize(item);
QSize rootMinSize;
QSize rootMaxSize;
rootMinSize =
QSize(m_regions[0]->getMinimumSize(Region::horizontal), m_regions[0]->getMinimumSize(Region::vertical));
rootMaxSize =
QSize(m_regions[0]->getMaximumSize(Region::horizontal), m_regions[0]->getMaximumSize(Region::vertical));
//Finally, check updated root against main window sizes
if (rootMinSize.width() > mainWindowWidth ||
rootMinSize.height() > mainWindowHeight ||
rootMaxSize.width() < mainWindowWidth ||
rootMaxSize.height() < mainWindowHeight) {
result = false;
}
return result;
}
//========================================================
//===================
// Save & Load
//===================
//!Returns the current \b State of the layout. A State is a typedef
//!for a pair containing the (normal) geometries of all layout items,
//!and a string indicating their hierarchycal structure.
DockLayout::State DockLayout::saveState()
{
QString hierarchy;
//Set save indices so we don't need to find anything
unsigned int i;
for (i = 0; i < m_regions.size(); ++i)
m_regions[i]->m_saveIndex = i;
DockWidget *item;
for (i = 0; i < m_items.size(); ++i) {
item = static_cast<DockWidget *>(m_items[i]->widget());
item->m_saveIndex = i;
}
//Write item geometries
std::vector<QRect> geometries;
for (i = 0; i < m_items.size(); ++i)
geometries.push_back(m_items[i]->geometry());
QTextStream stream(&hierarchy, QIODevice::WriteOnly);
//Save maximimized Dock index and geometry
stream << QString::number(m_maximizedDock ? m_maximizedDock->m_saveIndex : -1) << " ";
if (m_maximizedDock) {
Region *r = find(m_maximizedDock);
geometries[m_maximizedDock->m_saveIndex] = toRect(r->getGeometry());
}
//Save regions
Region *r = rootRegion();
if (r) {
stream << QString::number(r->getOrientation()) << " ";
writeRegion(r, hierarchy);
}
return std::pair<std::vector<QRect>, QString>(geometries, hierarchy);
}
//------------------------------------------------------
void DockLayout::writeRegion(Region *r, QString &hierarchy)
{
DockWidget *item = static_cast<DockWidget *>(r->getItem());
//If Region has item, write it.
if (item) {
hierarchy.append(QString::number(item->m_saveIndex) + " ");
} else {
hierarchy.append("[ ");
//Scan childList
unsigned int i, size = r->getChildList().size();
for (i = 0; i < size; ++i) {
writeRegion(r->childRegion(i), hierarchy);
}
hierarchy.append("] ");
}
}
//------------------------------------------------------
//!Restores the given internal structure of the layout.
//!This method is intended to restore the
//!geometry of a set of items that was handled by the layout
//!at the time the state was saved. Input are the geometries of
//!the items involved and the dock hierarchy in form of a string.
//!\b IMPORTANT \b NOTE: No check is performed on the item themselves,
//!except for the consistency of their geometrical constraints
//!inside the layout. Furthermore, this method does not ensure the
//!identity of the items involved, assuming that the set of dock
//!widget has ever been left unchanged or completely restored
//!as it were when saved. In particular, their ordering must be preserved.
bool DockLayout::restoreState(const State &state)
{
QStringList vars = state.second.split(" ", QString::SkipEmptyParts);
if (vars.size() < 1)
return 0;
//Check number of items
unsigned int count = state.first.size();
if (m_items.size() != count)
return false; //Items list is not coherent
//Initialize new Regions hierarchy
std::deque<Region *> newHierarchy;
//Load it
int maximizedItem = vars[0].toInt();
if (vars.size() > 1) {
//Scan hierarchy
Region *r = 0, *newRegion;
int orientation = !vars[1].toInt();
int i;
for (i = 2; i < vars.size(); ++i) {
if (vars[i] == "]") {
//End region and get parent
r = r->getParent();
} else {
//Allocate new Region
newRegion = new Region(this);
newHierarchy.push_back(newRegion);
newRegion->m_orientation = !orientation;
if (r)
r->insertSubRegion(newRegion, r->getChildList().size());
if (vars[i] == "[") {
//Current region has children
r = newRegion;
} else {
//newRegion has item
newRegion->m_item = static_cast<DockWidget *>(m_items[vars[i].toInt()]->widget());
}
}
}
//Check if size constraints are satisfied
newHierarchy[0]->calculateExtremalSizes();
}
unsigned int j;
for (j = 0; j < newHierarchy.size(); ++j) {
//Check if their extremal sizes are valid
Region *r = newHierarchy[j];
if (r->getMinimumSize(Region::horizontal) > r->getMaximumSize(Region::horizontal) ||
r->getMinimumSize(Region::vertical) > r->getMaximumSize(Region::vertical)) {
//If not, deallocate attempted hierarchy and quit
for (j = 0; j < newHierarchy.size(); ++j)
delete newHierarchy[j];
return false;
}
}
//Else, deallocate old regions and substitute with new ones
for (j = 0; j < m_regions.size(); ++j)
delete m_regions[j];
m_regions = newHierarchy;
//Now re-initialize dock widgets' infos.
const std::vector<QRect> &geoms = state.first;
DockWidget *item;
for (j = 0; j < m_items.size(); ++j) {
item = static_cast<DockWidget *>(m_items[j]->widget());
item->setGeometry(geoms[j]);
item->m_maximized = false;
item->m_saveIndex = j;
}
//Docked widgets are found in hierarchy
for (j = 0; j < m_regions.size(); ++j)
if (item = m_regions[j]->m_item) {
item->setWindowFlags(Qt::SubWindow);
item->setDockedAppearance();
item->m_floating = false;
item->m_saveIndex = -1;
item->show();
}
//Recover available geometry infos
//QRect availableRect= QApplication::desktop()->availableGeometry();
int recoverX = 0, recoverY = 0;
//Deal with floating panels
for (j = 0; j < m_items.size(); ++j) {
item = static_cast<DockWidget *>(m_items[j]->widget());
if (item->m_saveIndex > 0) {
//Ensure that floating panels are not placed in
//unavailable positions
if ((geoms[j] & QApplication::desktop()->availableGeometry(item)).isEmpty())
item->move(recoverX += 50, recoverY += 50);
//Set floating appearances
item->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint);
item->setFloatingAppearance();
item->m_floating = true;
}
}
//Allocate region separators
unsigned int k;
for (j = 0; j < m_regions.size(); ++j) {
Region *r = m_regions[j];
for (k = 1; k < r->m_childList.size(); ++k) {
r->insertSeparator(m_decoAllocator->newSeparator(this, r->getOrientation(), r));
}
}
//Calculate regions' geometry starting from leaves (items)
if (m_regions.size())
m_regions[0]->restoreGeometry();
//Then, ensure the result is correctly fitting the contents rect
//redistribute();
//NOTE: The previous might be tempting to ensure all is right - unfortunately, it may
//be that the main window's content rect is not yet defined before it is shown the first
//time (like on MAC), and that is needed to redistribute. Se we force the saved values
//(assuming they are right)...
applyGeometry();
//Finally, set maximized dock widget
if (maximizedItem != -1) {
item = static_cast<DockWidget *>(m_items[maximizedItem]->widget());
//Problema: Puo' essere, in fase di caricamento dati, che la contentsRect del layout
//venga sballata! (vv. lo ctor di TMainWindow) Allora, evitiamo il controllo fatto
//in setMazimized, e assumiamo sia per forza corretto...
//setMaximized(item, true);
m_maximizedDock = item;
item->m_maximized = true;
item->raise();
//Hide all other widgets
QWidget *currWidget;
for (int i = 0; i < this->count(); ++i)
if ((currWidget = itemAt(i)->widget()) != item)
currWidget->hide();
}
return true;
}
//------------------------------------------------------
//!Recalculates the geometry of \b this Region and of its branches,
//!assuming those of 'leaf items' are correct.
//!Regions always tend to keep their geometry by default. However,
//!it may be useful (for example, when restoring the state of a DockLayout)
//!the possibility of recalculating its current geometry directly from the
//!items that are contained in the branches.
void Region::restoreGeometry()
{
//Applying a head-recursive algorithm to update the geometry of a Region
//after those of its children have been updated
if (m_item) {
//Place item's geometry
setGeometry(m_item->geometry());
return;
}
//First do children
unsigned int i;
for (i = 0; i < m_childList.size(); ++i)
m_childList[i]->restoreGeometry();
//Then, update this one: just take the edges of its children.
unsigned int last = m_childList.size() - 1;
QPoint topLeft(m_childList[0]->getGeometry().left(), m_childList[0]->getGeometry().top());
QPoint bottomRight(m_childList[last]->getGeometry().right(), m_childList[last]->getGeometry().bottom());
setGeometry(QRect(topLeft, bottomRight));
return;
}
//========================================================================
//---------------------------
// Dock Deco Allocator
//---------------------------
//!Allocates a new DockSeparator with input parameters. This function can be re-implemented
//!to allocate derived DockSeparator classes.
inline DockSeparator *DockDecoAllocator::newSeparator(DockLayout *owner, bool orientation, Region *parentRegion)
{
return new DockSeparator(owner, orientation, parentRegion);
}
//------------------------------------------------------
//!When inheriting a DockLayout class, new custom placeholders gets allocated by this method.
inline DockPlaceholder *DockDecoAllocator::newPlaceholder(DockWidget *owner, Region *r, int idx, int attributes)
{
return new DockPlaceholder(owner, r, idx, attributes);
}
//------------------------------------------------------
//BuildGeometry() method should not be called inside the base contructor - because it's a virtual method.
//So we provide this little inline...
inline DockPlaceholder *DockDecoAllocator::newPlaceBuilt(DockWidget *owner, Region *r, int idx, int attributes)
{
DockPlaceholder *res = newPlaceholder(owner, r, idx, attributes);
res->buildGeometry();
return res;
}
//------------------------------------------------------
//!Sets current deco allocator to decoAllocator. A default deco allocator
//!is already provided at construction.
//!\b NOTE: DockLayout takes ownership of the allocator.
void DockLayout::setDecoAllocator(DockDecoAllocator *decoAllocator)
{
//Delete old one
if (m_decoAllocator)
delete m_decoAllocator;
//Place new one
m_decoAllocator = decoAllocator;
}
//------------------------------------------------------
//!Sets current deco allocator to decoAllocator. A default deco allocator
//!is already provided at construction.
//!\b NOTE: DockWidget takes ownership of the allocator.
void DockWidget::setDecoAllocator(DockDecoAllocator *decoAllocator)
{
//Delete old one
if (m_decoAllocator)
delete m_decoAllocator;
//Place a copy of new one
m_decoAllocator = decoAllocator;
}