#include "docklayout.h"

#include <assert.h></assert.h>

#include <math.h></math.h>

#include <algorithm></algorithm>

#include <qtextstream></qtextstream>

#include <qapplication></qapplication>

#include <qdesktopwidget></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;

}

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

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

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

void DockLayout::addItem(QLayoutItem *item) {

  DockWidget *addedItem = dynamic_cast<dockwidget *="">(item->widget());</dockwidget>

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

}

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

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());</dockwidget>

  // 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();</region>

    std::deque<dockseparator *=""> &sepList  = r->m_separators;</dockseparator>

    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,</qwidget>

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

    std::vector<qsize> minSizes;</qsize>

    std::vector<qsize> maxSizes;</qsize>

    // Recompute extremal region sizes

    // NOTA: Sarebbe da fare solo se un certo flag lo richiede; altrimenti tipo

    // per resize events e' inutile...

    // 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)

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

  //  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;  // Be', e' un po' improprio, ma funziona...

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