void StackTreeView::setModel(QAbstractItemModel *model)
{
    BaseTreeView::setModel(model);
    resizeColumnToContents(StackLevelColumn);
    resizeColumnToContents(StackLineNumberColumn);
    showAddressColumn(action(UseAddressInStackView)->isChecked());
}

void KFindTreeView::resizeToContents()
{
    resizeColumnToContents( 0 );
    resizeColumnToContents( 1 );
    resizeColumnToContents( 2 );
    resizeColumnToContents( 3 );
}

void ArchiveList::updateArchives(QList<Archive *> archivesOrig)
{
    QSet<QString> expandedLanguages;
    QSet<QString> knownLanguages;
    QSet<ArchiveID> expandedItems;

    for (int i = 0; i < topLevelItemCount(); i ++) {
        QTreeWidgetItem *langItem = topLevelItem(i);
        const QString &lang = langItem->text(0);
        if (langItem->isExpanded())
            expandedLanguages += lang;
        knownLanguages += lang;
        for (int j = 0; j < langItem->childCount(); j ++) {
            QTreeWidgetItem *dateItem = langItem->child(j);
            if (dateItem->isExpanded())
                expandedItems += ArchiveID(lang, dateItem->text(0));
        }
    }

    clear();

    QList<Archive *> archives(archivesOrig);
    qSort(archives.begin(), archives.end(), Archive::comparePointers);

    QTreeWidgetItem *topItem(0);
    QString lastLanguage;

    foreach (Archive *a, archives) {
        if (lastLanguage != a->getLanguage() || a->getLanguage().isEmpty()) {
            lastLanguage = a->getLanguage();
            topItem = new QTreeWidgetItem(this, QStringList() << lastLanguage);
            addTopLevelItem(topItem);
            if (expandedLanguages.contains(lastLanguage))
                topItem->setExpanded(true);
        }
        QTreeWidgetItem *item = new QTreeWidgetItem(topItem);
        item->setText(0, a->getDate());

        if (expandedItems.contains(a->getID()))
            item->setExpanded(true);

        if (qobject_cast<DownloadableArchive *>(a)) {
            fillDownloadableArchiveItem(static_cast<DownloadableArchive *>(a), item);
        } else if (qobject_cast<PartialArchive *>(a)) {
            if (!knownLanguages.contains(a->getLanguage()))
                topItem->setExpanded(true);
            fillPartialArchiveItem(static_cast<PartialArchive *>(a), item);
        } else if (qobject_cast<LocalArchive *>(a)) {
            if (!knownLanguages.contains(a->getLanguage()))
                topItem->setExpanded(true);
            fillLocalArchiveItem(static_cast<LocalArchive *>(a), item);
        }
    }
    resizeColumnToContents(0);
    resizeColumnToContents(1);
    resizeColumnToContents(2);
    resizeColumnToContents(3);
}

void ThreadsWindow::setModel(QAbstractItemModel *model)
{
    BaseWindow::setModel(model);
    resizeColumnToContents(ThreadData::IdColumn);
    resizeColumnToContents(ThreadData::LineColumn);
    resizeColumnToContents(ThreadData::NameColumn);
    resizeColumnToContents(ThreadData::StateColumn);
    resizeColumnToContents(ThreadData::TargetIdColumn);
}

void ScTreeWidget::handleMousePress(QTreeWidgetItem *item)
{
    if (item == 0)
        return;
    if (item->parent() == 0)
    {
        if (item->isDisabled())
        {
            setItemExpanded(item, false);
            return;
        }
        int wide = 0;
        int tops = topLevelItemCount();
        if (m_toolbox_mode)
        {
            for (int t = 0; t < tops; t++)
            {
                setItemExpanded(topLevelItem(t), false);
            }
            setCurrentItem(item);
            setItemExpanded(item, true);
            if (item->childCount() != 0)
            {
                QTreeWidgetItem *child = item->child(0);
                if (child != 0)
                    wide = itemWidget(child, 0)->minimumSizeHint().width()+5;
            }
            if (wide != 0)
                setColumnWidth(0, wide);
            else
                resizeColumnToContents(0);
        }
        else
        {
            setItemExpanded(item, !isItemExpanded(item));
            for (int t = 0; t < tops; t++)
            {
                QTreeWidgetItem *top = topLevelItem(t);
                if (isItemExpanded(top))
                {
                    if (top->childCount() != 0)
                    {
                        QTreeWidgetItem *child = top->child(0);
                        if (child != 0)
                            wide = qMax(wide, itemWidget(child, 0)->minimumSizeHint().width()+5);
                    }
                }
            }
        }
        if (wide != 0)
            setColumnWidth(0, wide);
        else
            resizeColumnToContents(0);
        emit currentChanged2(indexOfTopLevelItem(item));
    }
}

void  CommitTableWidget::refresh()
// ----------------------------------------------------------------------------
//    Reload the commit history from the model
// ----------------------------------------------------------------------------
{
    table->refresh();

    resizeColumnToContents(0);  // ID
    resizeColumnToContents(1);  // Date
    resizeColumnToContents(2);  // Author
}

    void PipelineTreeWidget::update(const std::vector<DataContainer*>& dataContainers, const std::vector<AbstractPipeline*>& pipelines) {
        // clear selection before setting the new data or we will encounter random crashes...
        selectionModel()->clear();

        _treeModel->setData(dataContainers, pipelines);
        expandAll();
        resizeColumnToContents(0);
        resizeColumnToContents(1);
        resizeColumnToContents(2);

        // The widget's size hint might have changed, notify the layout
        updateGeometry();
    }

 /* TODO This looses the current expanded tree's.
  * Needs to update the model rahter than replace it.
  */
void XmlTree::update ( const KMimeType::Ptr mime,  const QDomDocument& doc ) {
    setModel ( 0 );
    if ( m_treeModel )
        delete m_treeModel;
    if ( mime->is ( "application/xsd" ) )
        m_treeModel = new XsdDocumentModel();
    else
        m_treeModel = new XmlDocumentModel();
    m_treeModel->update ( doc );
    setModel ( m_treeModel );
    expandToDepth ( 0 );
    resizeColumnToContents ( 0 );
    resizeColumnToContents ( 1 );
}

void TransferListWidget::hidePriorityColumn(bool hide)
{
    qDebug("hidePriorityColumn(%d)", hide);
    setColumnHidden(TorrentModel::TR_PRIORITY, hide);
    if (!hide && !columnWidth(TorrentModel::TR_PRIORITY))
        resizeColumnToContents(TorrentModel::TR_PRIORITY);
}

InterfaceTree::InterfaceTree(QWidget *parent) :
    QTreeWidget(parent)
#ifdef HAVE_LIBPCAP
    ,stat_cache_(NULL)
    ,stat_timer_(NULL)
#endif // HAVE_LIBPCAP
{
    QTreeWidgetItem *ti;

    qRegisterMetaType< PointList >("PointList");

    header()->setVisible(false);
    setRootIsDecorated(false);
    setUniformRowHeights(true);
    /* Seems to have no effect, still the default value (2) is being used, as it
     * was set in the .ui file. But better safe, then sorry. */
    resetColumnCount();
    setSelectionMode(QAbstractItemView::ExtendedSelection);
    setAccessibleName(tr("Welcome screen list"));

    setItemDelegateForColumn(IFTREE_COL_STATS, new SparkLineDelegate(this));
    setDisabled(true);

    ti = new QTreeWidgetItem();
    ti->setText(IFTREE_COL_NAME, tr("Waiting for startup%1").arg(UTF8_HORIZONTAL_ELLIPSIS));
    addTopLevelItem(ti);
    resizeColumnToContents(IFTREE_COL_NAME);

    connect(wsApp, SIGNAL(appInitialized()), this, SLOT(getInterfaceList()));
    connect(wsApp, SIGNAL(localInterfaceListChanged()), this, SLOT(interfaceListChanged()));
    connect(this, SIGNAL(itemSelectionChanged()), this, SLOT(updateSelectedInterfaces()));
}

void NavigableTableView::resizeTableRows() {

  if (!model())
    return;

  int top = qMax(0, verticalHeader()->visualIndexAt(0));
  int bottom = verticalHeader()->visualIndexAt(viewport()->height());

  if (bottom == -1 || (bottom+10) >= model()->rowCount()) {
    bottom = model()->rowCount() - 1;
  }
  else {
    bottom += 10;
  }

  int left = qMax(0, horizontalHeader()->visualIndexAt(0));
  int right = horizontalHeader()->visualIndexAt(viewport()->width());

  if (right < 0) right = model()->columnCount();

  for (int i = top ; i <= bottom ; ++i)
    resizeRowToContents(i);

  for (int i = left ; i <= right ; ++i)
    resizeColumnToContents(i);

}

void UnspentTxOutView::update()
{
    QTreeView::update();
    for (int i = 0; i < model->columnCount(); i++) {
        resizeColumnToContents(i);
    }
}

void MovableTableWidget::resizeColumnsToContents()
{
  for (int i = 0; i < columnCount(); ++i)
  {
    resizeColumnToContents(i);
  }
}

QTreeWidget *ConnectionPropertiesPanel::makePortListWidget(QWidget *parent, const GraphConnectionEndpoint &ep, std::map<QTreeWidgetItem *, QString> &itemToKey)
{
    //create list widget
    auto listWidget = new QTreeWidget(parent);
    listWidget->setColumnCount(1);
    listWidget->setHeaderLabels(QStringList(QString("%1[%2]").arg(ep.getObj()->getId(), ep.getKey().id)));

    //query the signal/slot ports
    QStringList portKeys;
    auto block = dynamic_cast<GraphBlock *>(ep.getObj().data());
    if (block != nullptr) switch(ep.getConnectableAttrs().direction)
    {
    case GRAPH_CONN_SLOT: portKeys = block->getSlotPorts(); break;
    case GRAPH_CONN_SIGNAL: portKeys = block->getSignalPorts(); break;
    default: break;
    }

    //populate
    if (portKeys.empty())
    {
        auto item = new QTreeWidgetItem(listWidget, QStringList(_conn->getKeyName(ep.getKey().id, ep)));
        itemToKey[item] = ep.getKey().id;
        listWidget->addTopLevelItem(item);
    }
    else for (const auto &portKey : portKeys)
    {
        auto item = new QTreeWidgetItem(listWidget, QStringList(_conn->getKeyName(portKey, ep)));
        itemToKey[item] = portKey;
        listWidget->addTopLevelItem(item);
    }
    listWidget->resizeColumnToContents(0);

    //return new widget
    return listWidget;
}

BtTreeView::BtTreeView(QWidget *parent, BtTreeModel::TypeMasks type) :
   QTreeView(parent)
{
   // Set some global properties that all the kids will use.
   setAllColumnsShowFocus(true);
   setContextMenuPolicy(Qt::CustomContextMenu);
   setRootIsDecorated(false);

   setDragEnabled(true);
   setAcceptDrops(true);
   setDropIndicatorShown(true);
   setSelectionMode(QAbstractItemView::ExtendedSelection);

   _type = type;
   _model = new BtTreeModel(this, _type);
   filter = new BtTreeFilterProxyModel(this, _type);
   filter->setSourceModel(_model);
   setModel(filter);
   filter->setDynamicSortFilter(true);
   
   setExpanded(findElement(0), true);
   setSortingEnabled(true);
   sortByColumn(0,Qt::AscendingOrder);
   resizeColumnToContents(0);

   // and one wee connection
   connect( _model, SIGNAL(expandFolder(BtTreeModel::TypeMasks, QModelIndex)), this, SLOT(expandFolder(BtTreeModel::TypeMasks, QModelIndex)));
}

WaitEditorWidget::WaitEditorWidget(QWidget *parent) :
    ActionEditorWidget(parent)
{
    mWaitTypeWidget = new QComboBox(this);
    mWaitTypeWidget->addItem(tr("Timed"));
    mWaitTypeWidget->addItem(tr("Until mouse button is clicked"));
    mWaitTypeWidget->addItem(tr("Forever"));

    mSkipBox = new QCheckBox(this);
    mTimeSpin = new QDoubleSpinBox(this);
    mTimeSpin->setValue(1);
    mTimeSpin->setSingleStep(0.1);
    mTimeSpin->setMaximum(3600);

    beginGroup(tr("Wait"));
    appendRow(tr("Type"), mWaitTypeWidget);
    appendRow(tr("Time (sec)"), mTimeSpin);
    appendRow(tr("Allow skipping"), mSkipBox);
    endGroup();

    resizeColumnToContents(0);

    mCurrentAction = 0;

    connect(mWaitTypeWidget, SIGNAL(currentIndexChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
    connect(mTimeSpin, SIGNAL(valueChanged(double)), this, SLOT(onTimeChanged(double)));
    connect(mSkipBox, SIGNAL(clicked(bool)), this, SLOT(onSkipBoxClicked(bool)));
}

void KeyValuesTable::AdjustColumnCount(bool isReadOnly)
{
    int colCount = isReadOnly ? 2 : 3;
    int currentCount = columnCount();

    for(int current = currentCount - 1; current  > -1; current--)
        removeColumn(0);

    for(int current(0); current < colCount ; current++)
    {
        insertColumn(current);
        //horizontalHeader()-> setLabel(current, colNames[current]);
        QTableWidgetItem * item = horizontalHeaderItem(current);
        if(!item)
         {
            item = new QTableWidgetItem();
            setHorizontalHeaderItem(current, item);
        }
         horizontalHeaderItem(current)->setText(colNames[current]);
    }

    setColumnStretchable(1, true);

    if(!isReadOnly)
    {

        setColumnStretchable(2, false);
        resizeColumnToContents(2);
    }
    horizontalHeader()->setSectionResizeMode(0, QHeaderView::Interactive);
    horizontalHeader()->setSectionResizeMode(1, QHeaderView::Interactive);

}

bool TreeView::createNewEntry(const std::string& name,
                              const osg::ref_ptr<osg::Node> node,
                              const bool& enableNode,
                              const bool& showNode,
                              d3DisplayItem* myParent)
{
    // create the entry for the item model
    d3DisplayItem* entry( new d3DisplayItem(name, node) );
    entry->setEnabled(enableNode);

    // add this entry to the item model
    m_mutex.lock();
    myParent->appendRow(entry);

    // set to accomodate this width
    resizeColumnToContents(0);

    // add the node to the osg tree
    m_pOsgWidget->lock();
    myParent->getNode()->asGroup()->addChild(node);
    m_pOsgWidget->unlock();
    if ( not showNode )
    {
        entry->setCheckState(Qt::Unchecked);
        clicked(m_pModel->indexFromItem(entry));
    }
    m_mutex.unlock();

    return true;
};

void DisassembleWidget::showEvent(QShowEvent*)
{
    slotActivate(true);

    for (int i = 0; i < model()->columnCount(); ++i)
        resizeColumnToContents(i);
}

InterfaceTree::InterfaceTree(QWidget *parent) :
    QTreeWidget(parent)
#ifdef HAVE_LIBPCAP
    ,stat_cache_(NULL)
    ,stat_timer_(NULL)
#endif // HAVE_LIBPCAP
{
    QTreeWidgetItem *ti;

    header()->setVisible(false);
    setRootIsDecorated(false);
    setUniformRowHeights(true);
    setColumnCount(2);
    setSelectionMode(QAbstractItemView::ExtendedSelection);
    setAccessibleName(tr("Welcome screen list"));

    setItemDelegateForColumn(1, new SparkLineDelegate());
    setDisabled(true);

    ti = new QTreeWidgetItem();
    ti->setText(0, tr("Waiting for startup" UTF8_HORIZONTAL_ELLIPSIS));
    addTopLevelItem(ti);
    resizeColumnToContents(0);

    connect(wsApp, SIGNAL(appInitialized()), this, SLOT(getInterfaceList()));
    connect(this, SIGNAL(itemSelectionChanged()), this, SLOT(updateSelectedInterfaces()));
}