

#include "docklayout.h"

#include <assert.h>
#include <math.h>
#include <algorithm>

#include <QTextStream>
#include <QApplication>
#include <QDesktopWidget>

//========================================================
// TO DO:
//  * Use the macro QWIDGETSIZE_MAX for the maximum settable size for a widget
//      => After that, it would be enough to truncate all sums that exceed that
//      value... Anyway...
//  * Recalculating extremal sizes is useless in resize events... Try to cut
//  such things - optimize!
//      => However, it generally makes sense for redistribute to recalculate
//      them - maybe we could make a redistribute with a bool input.
//      If the containing operation cannot change the
//      extremal sizes, then set false..
//  * Implement stretch factors
//  * Hiding docked windows...? Very tricky...
//  * A dock widget might not only have docked and floating states... What
//  happens if it is a subwindow not docked in a dockLayout??
//  * Split tdockwindows.h into tmainwindow.h and tdockwidget.h, as in Qt?
//  * Moving or performing operations on a dockWidget in its current state is
//  not safe if it is not assigned to a DockLayout!! However, it can be
//  assumed that the parent of a DockWidget is not even a QWidget
//  that implements a DockLayout. This assumption may break in a specific
//  implementation like TDockWidget?
//      Example: see calculateDockPlaceholders on drag, it gets called anyway...
//  * Does it make sense to put DockLayout and DockWidget in DVAPI? Perhaps if I
//  defined appropriate inlines in TDockWidget...
//  * What is contained in DockSeparator::mousePress and mouseMove should be
//  made public. Also the geometry of the regions could be
//  user-editable... but first stretch factors should be done!!
//      > I.e., if you explicitly want to set the geometry of a region, you
//      could do that by setting
//        that region's stretch factor to infinity (or almost), and the others
//        to 1...
//  * There should be a way to specify the position of separators from code?
//    Tricky. However, now it's enough to specify the geometry of widgets before
//    docking; redistribute tries to adapt.
//  * It often happens to consider the hypothetical new root of the structure.
//  Why not put it directly??
//  X It is not possible to cover all docking possibilities with the current
//  system, even if it is more extensive than Qt's.
//      Example:           |
//                    -----|
//                      |  |        => !!
//                      |-----
//                      |
//========================================================

//------------------------
//    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;
}

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

int DockLayout::count() const { return m_items.size(); }

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

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 reparenting to unify the coordinate system for all items.
  // 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);
}

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

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;
}

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

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(); }

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

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);
}

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

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);
}

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

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;
}

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

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.
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()));
}

//------------------------------------------------------
// check if the region will be with fixed width
bool Region::checkWidgetsToBeFixedWidth(std::vector<QWidget *> &widgets,
                                        bool &fromDocking) {
  if (m_item) {
    if (m_item->wasFloating()) {
      fromDocking = true;
      m_item->clearWasFloating();
      return false;
    }
    /*
    if ((m_item->objectName() == "FilmStrip" && m_item->getCanFixWidth()) ||
        m_item->objectName() == "StyleEditor") {
      widgets.push_back(m_item);
      return true;
    } else if (m_item->objectName() == "ToolBar") {
      return true;
    } else
      return false;
    */
    switch (m_item->getFixWidthMode()) {
    case 2:
      widgets.push_back(m_item);
      // fallthrough
    case 1:
      return true;
    default:
      return false;
    }
  }
  if (m_childList.empty()) return false;
  // for horizontal orientation, return true if all items are to be fixed
  if (m_orientation == horizontal) {
    bool ret = true;
    for (Region *childRegion : m_childList) {
      if (!childRegion->checkWidgetsToBeFixedWidth(widgets, fromDocking))
        ret = false;
    }
    return ret;
  }
  // for vertical orientation, return true if at least one item is to be fixed
  else {
    bool ret = false;
    for (Region *childRegion : m_childList) {
      if (childRegion->checkWidgetsToBeFixedWidth(widgets, fromDocking))
        ret = true;
    }
    return ret;
  }
}

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

void DockLayout::redistribute() {
  if (!m_regions.empty()) {
    std::vector<QWidget *> widgets;
    std::vector<QSize> minSizes;
    std::vector<QSize> maxSizes;

    // Recompute extremal region sizes
    // NOTE: This should only be done if a certain flag requires it;
    // otherwise, for things like resize events, it is useless...

    // let's force the width of the film strip / style editor not to change
    // check recursively from the root region, if the widgets can be fixed.
    // it avoids all widgets in horizontal alignment to be fixed, or UI becomes
    // glitchy.
    bool fromDocking = false;
    bool widgetsCanBeFixedWidth =
        !m_regions.front()->checkWidgetsToBeFixedWidth(widgets, fromDocking);
    if (!fromDocking && widgetsCanBeFixedWidth) {
      for (QWidget *widget : widgets) {
        minSizes.push_back(widget->minimumSize());
        maxSizes.push_back(widget->maximumSize());
        widget->setFixedWidth(widget->width());
      }
    }

    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) {
      // Restore original sizes before returning
      if (!fromDocking && widgetsCanBeFixedWidth) {
        for (int i = 0; i < widgets.size(); ++i) {
          widgets[i]->setMinimumSize(minSizes[i]);
          widgets[i]->setMaximumSize(maxSizes[i]);
        }
      }
      return;
    }

    // Recompute Layout geometry
    m_regions.front()->setGeometry(contentsRect());
    m_regions.front()->redistribute();

    if (!fromDocking && widgetsCanBeFixedWidth) {
      /*
      for (QWidget *widget : widgets) {
        widget->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
        widget->setMinimumSize(0, 0);
      }
      */
      for (int i = 0; i < widgets.size(); ++i) {
        widgets[i]->setMinimumSize(minSizes[i]);
        widgets[i]->setMaximumSize(maxSizes[i]);
      }
    }
  }

  // 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
void Region::insertSeparator(DockSeparator *sep) {
  m_separators.push_back(sep);
}

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

//! Removes a DockSeparator from \b this Region
void Region::removeSeparator() {
  delete m_separators.back();
  m_separators.pop_back();
}

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

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.
Region *Region::insertItem(DockWidget *item, int idx) {
  Region *newRegion = new Region(m_owner, item);

  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.
Region *DockLayout::dockItemPrivate(DockWidget *item, Region *r, int idx) {
  // hide minimize button in FlipboolPanel
  item->onDock(true);

  item->setDockedAppearance();
  item->m_floating    = false;
  item->m_wasFloating = true;

  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.
static bool isEmptyRegion(Region *r) {
  if ((!r->getItem()) && (r->getChildList().size() == 0)) {
    delete r;  // Well, it's a bit improper, but it works...
    return true;
  }
  return false;
}

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

//! Removes input item from region
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 reset 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);
  // NOTE: Using the Qt::Window flag, focus is automatically reassigned, with a
  // slight delay. Using Tool this does not happen.
  // In this case, placeholders must be disabled...

  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.
static void calculateNearest(std::vector<double> target,
                             std::vector<double> &nearest,
                             std::vector<std::pair<int, int>> intervals,
                             double sum) {
  // Solve Lagrange for 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;
  }
}

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

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 {
    // Vice versa
    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;
}

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

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 {
    // Vice versa
    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.
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.
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(" ", Qt::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. So 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());

    // Problem: During data loading, the contentsRect of the layout
    // may be off! (see TMainWindow ctor) So, we skip the check performed
    // in setMaximized, and assume it is correct...
    // 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.
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.
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 constructor -
// because it's a virtual method.
// So we provide this little 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;
}
