+ config()->requestRemoveBuffer(bufferId);
+ }
+}
+
+void BufferView::rowsInserted(const QModelIndex& parent, int start, int end)
+{
+ TreeViewTouch::rowsInserted(parent, start, end);
+
+ // ensure that newly inserted network nodes are expanded per default
+ if (parent.data(NetworkModel::ItemTypeRole) != NetworkModel::NetworkItemType)
+ return;
+
+ setExpandedState(parent);
+}
+
+void BufferView::on_layoutChanged()
+{
+ int numNets = model()->rowCount(QModelIndex());
+ for (int row = 0; row < numNets; row++) {
+ QModelIndex networkIdx = model()->index(row, 0, QModelIndex());
+ setExpandedState(networkIdx);
+ }
+}
+
+void BufferView::on_configChanged()
+{
+ Q_ASSERT(model());
+
+ // Expand/collapse as needed
+ setExpandedState();
+
+ if (config()) {
+ // update selection to current one
+ Client::bufferModel()->synchronizeView(this);
+ }
+}
+
+void BufferView::setExpandedState()
+{
+ // Expand all active networks, collapse inactive ones... unless manually changed
+ QModelIndex networkIdx;
+ NetworkId networkId;
+ for (int row = 0; row < model()->rowCount(); row++) {
+ networkIdx = model()->index(row, 0);
+ if (model()->rowCount(networkIdx) == 0)
+ continue;
+
+ networkId = model()->data(networkIdx, NetworkModel::NetworkIdRole).value<NetworkId>();
+ if (!networkId.isValid())
+ continue;
+
+ setExpandedState(networkIdx);
+ }
+}
+
+void BufferView::storeExpandedState(const QModelIndex& networkIdx)
+{
+ NetworkId networkId = model()->data(networkIdx, NetworkModel::NetworkIdRole).value<NetworkId>();
+
+ int oldState = 0;
+ if (isExpanded(networkIdx))
+ oldState |= WasExpanded;
+ if (model()->data(networkIdx, NetworkModel::ItemActiveRole).toBool())
+ oldState |= WasActive;
+
+ _expandedState[networkId] = oldState;
+}
+
+void BufferView::setExpandedState(const QModelIndex& networkIdx)
+{
+ if (model()->data(networkIdx, NetworkModel::ItemTypeRole) != NetworkModel::NetworkItemType)
+ return;
+
+ if (model()->rowCount(networkIdx) == 0)
+ return;
+
+ NetworkId networkId = model()->data(networkIdx, NetworkModel::NetworkIdRole).value<NetworkId>();
+
+ bool networkActive = model()->data(networkIdx, NetworkModel::ItemActiveRole).toBool();
+ bool expandNetwork = networkActive;
+ if (_expandedState.contains(networkId)) {
+ int oldState = _expandedState[networkId];
+ if ((bool)(oldState & WasActive) == networkActive)
+ expandNetwork = (bool)(oldState & WasExpanded);
+ }
+
+ if (expandNetwork != isExpanded(networkIdx)) {
+ update(networkIdx);
+ setExpanded(networkIdx, expandNetwork);
+ }
+ storeExpandedState(networkIdx); // this call is needed to keep track of the isActive state
+}
+
+void BufferView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
+{
+ TreeViewTouch::dataChanged(topLeft, bottomRight, roles);
+
+ // determine how many items have been changed and if any of them is a networkitem
+ // which just swichted from active to inactive or vice versa
+ if (topLeft.data(NetworkModel::ItemTypeRole) != NetworkModel::NetworkItemType)
+ return;
+
+ for (int i = topLeft.row(); i <= bottomRight.row(); i++) {
+ QModelIndex networkIdx = topLeft.sibling(i, 0);
+ setExpandedState(networkIdx);
+ }
+}
+
+void BufferView::toggleHeader(bool checked)
+{
+ auto* action = qobject_cast<QAction*>(sender());
+ header()->setSectionHidden((action->property("column")).toInt(), !checked);
+}
+
+void BufferView::contextMenuEvent(QContextMenuEvent* event)
+{
+ QModelIndex index = indexAt(event->pos());
+ if (!index.isValid())
+ index = rootIndex();
+
+ QMenu contextMenu(this);
+
+ if (index.isValid()) {
+ addActionsToMenu(&contextMenu, index);
+ }
+
+ addFilterActions(&contextMenu, index);
+
+ if (!contextMenu.actions().isEmpty())
+ contextMenu.exec(QCursor::pos());
+}
+
+void BufferView::addActionsToMenu(QMenu* contextMenu, const QModelIndex& index)
+{
+ QModelIndexList indexList = selectedIndexes();
+ // make sure the item we clicked on is first
+ indexList.removeAll(index);
+ indexList.prepend(index);
+
+ GraphicalUi::contextMenuActionProvider()->addActions(contextMenu, indexList, this, &BufferView::menuActionTriggered, (bool)config());
+}
+
+void BufferView::addFilterActions(QMenu* contextMenu, const QModelIndex& index)
+{
+ auto* filter = qobject_cast<BufferViewFilter*>(model());
+ if (filter) {
+ QList<QAction*> filterActions = filter->actions(index);
+ if (!filterActions.isEmpty()) {
+ contextMenu->addSeparator();
+ foreach (QAction* action, filterActions) {
+ contextMenu->addAction(action);
+ }
+ }
+ }
+}
+
+void BufferView::menuActionTriggered(QAction* result)
+{
+ ContextMenuActionProvider::ActionType type = (ContextMenuActionProvider::ActionType)result->data().toInt();
+ switch (type) {
+ case ContextMenuActionProvider::HideBufferTemporarily:
+ removeSelectedBuffers();
+ break;
+ case ContextMenuActionProvider::HideBufferPermanently:
+ removeSelectedBuffers(true);
+ break;
+ default:
+ return;
+ }
+}
+
+void BufferView::nextBuffer()
+{
+ changeBuffer(Forward);
+}
+
+void BufferView::previousBuffer()
+{
+ changeBuffer(Backward);
+}
+
+void BufferView::changeBuffer(Direction direction)
+{
+ QModelIndex currentIndex = selectionModel()->currentIndex();
+ QModelIndex resultingIndex;
+
+ QModelIndex lastNetIndex = model()->index(model()->rowCount() - 1, 0, QModelIndex());
+
+ if (currentIndex.parent().isValid()) {
+ // If we are a child node just switch among siblings unless it's the first/last child
+ resultingIndex = currentIndex.sibling(currentIndex.row() + direction, 0);
+
+ if (!resultingIndex.isValid()) {
+ QModelIndex parent = currentIndex.parent();
+ if (direction == Backward)
+ resultingIndex = parent;
+ else
+ resultingIndex = parent.sibling(parent.row() + direction, 0);
+ }
+ }
+ else {
+ // If we have a toplevel node, try and get an adjacent child
+ if (direction == Backward) {
+ QModelIndex newParent = currentIndex.sibling(currentIndex.row() - 1, 0);
+ if (currentIndex.row() == 0)
+ newParent = lastNetIndex;
+ if (model()->hasChildren(newParent))
+ resultingIndex = newParent.model()->index(model()->rowCount(newParent) - 1, 0, newParent);
+ else
+ resultingIndex = newParent;
+ }
+ else {
+ if (model()->hasChildren(currentIndex))
+ resultingIndex = currentIndex.model()->index(0, 0, currentIndex);
+ else
+ resultingIndex = currentIndex.sibling(currentIndex.row() + 1, 0);
+ }
+ }
+
+ if (!resultingIndex.isValid()) {
+ if (direction == Forward)
+ resultingIndex = model()->index(0, 0, QModelIndex());
+ else
+ resultingIndex = lastNetIndex.model()->index(model()->rowCount(lastNetIndex) - 1, 0, lastNetIndex);
+ }
+
+ selectionModel()->setCurrentIndex(resultingIndex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+ selectionModel()->select(resultingIndex, QItemSelectionModel::ClearAndSelect);
+}
+
+void BufferView::selectFirstBuffer()
+{
+ int networksCount = model()->rowCount(QModelIndex());
+ if (networksCount == 0) {
+ return;
+ }
+
+ QModelIndex bufferIndex;
+ for (int row = 0; row < networksCount; row++) {
+ QModelIndex networkIndex = model()->index(row, 0, QModelIndex());
+ int childCount = model()->rowCount(networkIndex);
+ if (childCount > 0) {
+ bufferIndex = model()->index(0, 0, networkIndex);
+ break;
+ }
+ }
+
+ if (!bufferIndex.isValid()) {
+ return;
+ }
+
+ selectionModel()->setCurrentIndex(bufferIndex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+ selectionModel()->select(bufferIndex, QItemSelectionModel::ClearAndSelect);
+}
+
+void BufferView::wheelEvent(QWheelEvent* event)
+{
+ if (ItemViewSettings().mouseWheelChangesBuffer() == (bool)(event->modifiers() & Qt::AltModifier))
+ return TreeViewTouch::wheelEvent(event);
+
+ int rowDelta = (event->delta() > 0) ? -1 : 1;
+ changeBuffer((Direction)rowDelta);
+}
+
+void BufferView::hideCurrentBuffer()
+{
+ QModelIndex index = selectionModel()->currentIndex();
+ if (index.data(NetworkModel::ItemTypeRole) != NetworkModel::BufferItemType)
+ return;
+
+ BufferId bufferId = index.data(NetworkModel::BufferIdRole).value<BufferId>();
+
+ // The check above means we won't be looking at a network, which should always be the first row, so we can just go backwards.
+ changeBuffer(Backward);
+
+ config()->requestRemoveBuffer(bufferId);
+}
+
+void BufferView::filterTextChanged(const QString& filterString)
+{
+ auto* filter = qobject_cast<BufferViewFilter*>(model());
+ if (!filter) {
+ return;
+ }
+ filter->setFilterString(filterString);
+ on_configChanged(); // make sure collapsation is correct
+}
+
+void BufferView::changeHighlight(BufferView::Direction direction)
+{
+ // If for some weird reason we get a new delegate
+ auto delegate = qobject_cast<BufferViewDelegate*>(itemDelegate(_currentHighlight));
+ if (delegate) {
+ delegate->currentHighlight = QModelIndex();
+ }
+
+ QModelIndex newIndex = _currentHighlight;
+ if (!newIndex.isValid()) {
+ newIndex = model()->index(0, 0);
+ }
+
+ if (direction == Backward) {
+ newIndex = indexBelow(newIndex);
+ }
+ else {
+ newIndex = indexAbove(newIndex);
+ }
+
+ if (!newIndex.isValid()) {
+ return;
+ }
+
+ _currentHighlight = newIndex;
+
+ delegate = qobject_cast<BufferViewDelegate*>(itemDelegate(_currentHighlight));
+ if (delegate) {
+ delegate->currentHighlight = _currentHighlight;
+ }
+ viewport()->update();
+}
+
+void BufferView::selectHighlighted()
+{
+ if (_currentHighlight.isValid()) {
+ selectionModel()->setCurrentIndex(_currentHighlight, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+ selectionModel()->select(_currentHighlight, QItemSelectionModel::ClearAndSelect);
+ }
+ else {
+ selectFirstBuffer();
+ }
+
+ clearHighlight();
+}
+
+void BufferView::clearHighlight()
+{
+ // If for some weird reason we get a new delegate
+ auto delegate = qobject_cast<BufferViewDelegate*>(itemDelegate(_currentHighlight));
+ if (delegate) {
+ delegate->currentHighlight = QModelIndex();
+ }
+ _currentHighlight = QModelIndex();
+ viewport()->update();
+}
+
+// ****************************************
+// BufferViewDelegate
+// ****************************************
+class ColorsChangedEvent : public QEvent
+{
+public:
+ ColorsChangedEvent()
+ : QEvent(QEvent::User){};
+};
+
+BufferViewDelegate::BufferViewDelegate(QObject* parent)
+ : QStyledItemDelegate(parent)
+{}
+
+void BufferViewDelegate::customEvent(QEvent* event)
+{
+ if (event->type() != QEvent::User)
+ return;
+
+ event->accept();
+}
+
+bool BufferViewDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index)
+{
+ if (event->type() != QEvent::MouseButtonRelease)
+ return QStyledItemDelegate::editorEvent(event, model, option, index);
+
+ if (!(model->flags(index) & Qt::ItemIsUserCheckable))
+ return QStyledItemDelegate::editorEvent(event, model, option, index);
+
+ QVariant value = index.data(Qt::CheckStateRole);
+ if (!value.isValid())
+ return QStyledItemDelegate::editorEvent(event, model, option, index);
+
+ QStyleOptionViewItem viewOpt(option);
+ initStyleOption(&viewOpt, index);
+
+ QRect checkRect = viewOpt.widget->style()->subElementRect(QStyle::SE_ItemViewItemCheckIndicator, &viewOpt, viewOpt.widget);
+ auto* me = static_cast<QMouseEvent*>(event);
+
+ if (me->button() != Qt::LeftButton || !checkRect.contains(me->pos()))
+ return QStyledItemDelegate::editorEvent(event, model, option, index);
+
+ auto state = static_cast<Qt::CheckState>(value.toInt());
+ if (state == Qt::Unchecked)
+ state = Qt::PartiallyChecked;
+ else if (state == Qt::PartiallyChecked)
+ state = Qt::Checked;
+ else
+ state = Qt::Unchecked;
+ model->setData(index, state, Qt::CheckStateRole);
+ return true;
+}
+
+// ==============================
+// BufferView Dock
+// ==============================
+BufferViewDock::BufferViewDock(BufferViewConfig* config, QWidget* parent)
+ : QDockWidget(parent)
+ , _childWidget(nullptr)
+ , _widget(new QWidget(parent))
+ , _filterEdit(new QLineEdit(parent))
+ , _active(false)
+ , _title(config->bufferViewName())
+{
+ setObjectName("BufferViewDock-" + QString::number(config->bufferViewId()));
+ toggleViewAction()->setData(config->bufferViewId());
+ setAllowedAreas(Qt::RightDockWidgetArea | Qt::LeftDockWidgetArea);
+ connect(config, &BufferViewConfig::bufferViewNameSet, this, &BufferViewDock::bufferViewRenamed);
+ connect(config, &BufferViewConfig::configChanged, this, &BufferViewDock::configChanged);
+ updateTitle();
+
+ _widget->setLayout(new QVBoxLayout);
+ _widget->layout()->setSpacing(0);
+ _widget->layout()->setContentsMargins(0, 0, 0, 0);
+
+ // We need to potentially hide it early, so it doesn't flicker
+ _filterEdit->setVisible(config->showSearch());
+ _filterEdit->setFocusPolicy(Qt::ClickFocus);
+ _filterEdit->installEventFilter(this);
+ _filterEdit->setPlaceholderText(tr("Search..."));
+ connect(_filterEdit, &QLineEdit::returnPressed, this, &BufferViewDock::onFilterReturnPressed);
+
+ _widget->layout()->addWidget(_filterEdit);
+ QDockWidget::setWidget(_widget);
+}
+
+void BufferViewDock::setLocked(bool locked)
+{
+ if (locked) {
+ setFeatures(nullptr);
+ }
+ else {
+ setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
+ }
+}
+
+void BufferViewDock::updateTitle()
+{
+ QString title = _title;
+ if (isActive())
+ title.prepend(QString::fromUtf8("• "));
+ setWindowTitle(title);
+}
+
+void BufferViewDock::configChanged()
+{
+ if (_filterEdit->isVisible() != config()->showSearch()) {
+ _filterEdit->setVisible(config()->showSearch());
+ _filterEdit->clear();
+ }
+}
+
+void BufferViewDock::onFilterReturnPressed()
+{
+ if (_oldFocusItem) {
+ _oldFocusItem->setFocus();
+ _oldFocusItem = nullptr;
+ }
+
+ if (!config()->showSearch()) {
+ _filterEdit->setVisible(false);
+ }
+
+ BufferView* view = bufferView();
+ if (!view) {
+ return;
+ }
+
+ if (!_filterEdit->text().isEmpty()) {
+ view->selectHighlighted();
+ _filterEdit->clear();
+ }
+ else {
+ view->clearHighlight();
+ }
+}
+
+void BufferViewDock::setActive(bool active)
+{
+ if (active != isActive()) {
+ _active = active;
+ updateTitle();
+ if (active) {
+ raise(); // for tabbed docks
+ }
+ }
+}
+
+bool BufferViewDock::eventFilter(QObject* object, QEvent* event)
+{
+ if (object != _filterEdit) {
+ return false;
+ }
+
+ if (event->type() == QEvent::FocusOut) {
+ if (!config()->showSearch() && _filterEdit->text().isEmpty()) {
+ _filterEdit->setVisible(false);
+ return true;
+ }
+ }
+ else if (event->type() == QEvent::KeyRelease) {
+ auto keyEvent = static_cast<QKeyEvent*>(event);
+
+ BufferView* view = bufferView();
+ if (!view) {
+ return false;
+ }
+
+ switch (keyEvent->key()) {
+ case Qt::Key_Escape: {
+ _filterEdit->clear();
+
+ if (!_oldFocusItem) {
+ return false;
+ }
+
+ _oldFocusItem->setFocus();
+ _oldFocusItem = nullptr;
+ return true;
+ }
+ case Qt::Key_Down:
+ view->changeHighlight(BufferView::Backward);
+ return true;
+ case Qt::Key_Up:
+ view->changeHighlight(BufferView::Forward);
+ return true;
+ default:
+ break;
+ }
+
+ return false;
+ }
+
+ return false;
+}
+
+void BufferViewDock::bufferViewRenamed(const QString& newName)
+{
+ _title = newName;
+ updateTitle();
+ toggleViewAction()->setText(newName);
+}
+
+int BufferViewDock::bufferViewId() const
+{
+ BufferView* view = bufferView();
+ if (!view)
+ return 0;
+
+ if (view->config())
+ return view->config()->bufferViewId();
+ else
+ return 0;
+}
+
+BufferViewConfig* BufferViewDock::config() const
+{
+ BufferView* view = bufferView();
+ if (!view)
+ return nullptr;
+ else
+ return view->config();
+}
+
+void BufferViewDock::setWidget(QWidget* newWidget)
+{
+ _widget->layout()->addWidget(newWidget);
+ _childWidget = newWidget;
+
+ connect(_filterEdit, &QLineEdit::textChanged, bufferView(), &BufferView::filterTextChanged);
+}
+
+void BufferViewDock::activateFilter()
+{
+ if (!_filterEdit->isVisible()) {
+ _filterEdit->setVisible(true);
+ }
+
+ _oldFocusItem = qApp->focusWidget();
+
+ _filterEdit->setFocus();
+}
+
+
+void BufferViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+ QStyleOptionViewItem newOption = option;
+ if (index == currentHighlight) {
+ newOption.state |= QStyle::State_HasFocus;
+ }
+ QStyledItemDelegate::paint(painter, newOption, index);