+ * Copyright (c) 2014-2016 Isode Limited.

+ setAcceptDrops(true);

+ // detect the default tab bar height;

+ insertTab(0, "");

+ defaultTabHeight = QTabBar::sizeHint().height();

+ removeTab(0);

+ return dragIndex;

+ return dragText;

+ return dragWidget;

+ QSize hint = QTabBar::sizeHint();

+ if (hint.isEmpty()) {

+ hint = QSize(parentWidget()->width(), defaultTabHeight);

+ }

+ return hint;

+ QSize tabSize = QTabBar::tabSizeHint(index);

+ // With multiple tabs having the same label in a QTabBar, the size hint computed by

+ // Qt on OS X is too small and it is elided even though there is enough horizontal

+ // space available. We work around this issue by adding the width of a letter to the

+ // size hint.

+ tabSize += QSize(QFontMetrics(font()).width("I"), 0);

+ return tabSize;

+ QtDNDTabBar* sourceTabBar = dynamic_cast<QtDNDTabBar*>(dragEnterEvent->source());

+ if (sourceTabBar) {

+ dragEnterEvent->acceptProposedAction();

+ }

+ QtDNDTabBar* sourceTabBar = dynamic_cast<QtDNDTabBar*>(dropEvent->source());

+ if (sourceTabBar && dropEvent->mimeData() && dropEvent->mimeData()->data("action") == QByteArray("application/tab-detach")) {

+ QtDNDTabBar* source = dynamic_cast<QtDNDTabBar*>(dropEvent->source());

+

+ int targetTabIndex = tabAt(dropEvent->pos());

+ QRect rect = tabRect(targetTabIndex);

+ if (targetTabIndex >= 0 && (dropEvent->pos().x() - rect.left() - rect.width()/2 > 0)) {

+ targetTabIndex++;

+ }

+

+ QWidget* tab = source->getDragWidget();

+ assert(tab);

+ QTabWidget* targetTabWidget = dynamic_cast<QTabWidget*>(parentWidget());

+

+ QString tabText = source->getDragText();

+

+ /*

+ * When you add a widget to an empty QTabWidget, it's automatically made the current widget.

+ * Making the widget the current widget, widget->show() is called for the widget. Directly reacting

+ * to that event, and adding the widget again to the QTabWidget results in undefined behavior. For

+ * example the tab label is shown but the widget is neither has the old nor in the new QTabWidget as

+ * parent. Blocking signals on the QWidget to be added to a QTabWidget prevents this behavior.

+ */

+ targetTabWidget->setUpdatesEnabled(false);

+ tab->blockSignals(true);

+ targetTabWidget->insertTab(targetTabIndex, tab, tabText);

+ dropEvent->acceptProposedAction();

+ tab->blockSignals(false);

+ targetTabWidget->setUpdatesEnabled(true);

+ onDropSucceeded();

+ }

+ QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);

+ if (mouseEvent) {

+ QWidget* childAtPoint = window()->childAt(mapTo(window(), mouseEvent->pos()));

+ QtDNDTabBar* underMouse = dynamic_cast<QtDNDTabBar*>(childAtPoint);

+ if (!underMouse && childAtPoint) {

+ underMouse = dynamic_cast<QtDNDTabBar*>(childAtPoint->parent());

+ }

+ if (!underMouse && currentIndex() >= 0) {

+ // detach and drag

+

+ // stop move event

+ QMouseEvent* finishMoveEvent = new QMouseEvent (QEvent::MouseMove, mouseEvent->pos (), Qt::NoButton, Qt::NoButton, Qt::NoModifier);

+ QTabBar::event(finishMoveEvent);

+ delete finishMoveEvent;

+ finishMoveEvent = nullptr;

+

+ // start drag

+ QDrag* drag = new QDrag(this);

+ QMimeData* mimeData = new QMimeData;

+

+ // distinguish tab-reordering drops from other ones

+ mimeData->setData("action", "application/tab-detach") ;

+ drag->setMimeData(mimeData);

+

+ // set drag image

+ QRect rect = tabRect( currentIndex() );

+ QPixmap pixmap = grab(rect);

+ QPixmap pixmap = QPixmap::grabWidget(this, rect);

+ QPixmap targetPixmap (pixmap.size ());

+ QPainter painter (&targetPixmap);

+ painter.setOpacity(0.9);

+ painter.drawPixmap(0,0, pixmap);

+ painter.end ();

+ drag->setPixmap (targetPixmap);

+

+ drag->setHotSpot(QPoint(drag->pixmap().width()/2, drag->pixmap().height()));

+

+ dragIndex = currentIndex();

+ dragText = tabText(dragIndex);

+ dragWidget = dynamic_cast<QTabWidget*>(parent())->widget(dragIndex);

+ assert(dragWidget);

+ dynamic_cast<QTabWidget*>(parent())->removeTab(currentIndex());

+ Qt::DropAction dropAction = drag->exec();

+ if (dropAction == Qt::IgnoreAction) {

+ // aborted drag, put tab back in place

+ // disable event handling during the insert for the tab to prevent infinite recursion (stack overflow)

+ dragWidget->blockSignals(true);

+ dynamic_cast<QTabWidget*>(parent())->insertTab(dragIndex, dragWidget, dragText);

+ dragWidget->blockSignals(false);

+ }

+ return true;

+ }

+ }

+ return QTabBar::event(event);

+ * Copyright (c) 2014-2016 Isode Limited.

+#include <Swift/QtUI/QtTabWidget.h>

+

+ Q_OBJECT

+ public:

+ explicit QtDNDTabBar(QWidget* parent = nullptr);

+ virtual ~QtDNDTabBar();

+

+ int getDragIndex() const;

+ QString getDragText() const;

+ QWidget* getDragWidget() const;

+

+ virtual QSize sizeHint() const;

+

+ friend class QtTabWidget;

+ signals:

+ void onDropSucceeded();

+

+ protected:

+ virtual void dragEnterEvent(QDragEnterEvent* dragEnterEvent);

+ virtual void dropEvent(QDropEvent* dropEvent);

+ virtual bool event(QEvent* event);

+ virtual QSize tabSizeHint(int index) const;

+

+ private:

+ int defaultTabHeight;

+ int dragIndex = -1;

+ QString dragText;

+ QWidget* dragWidget = nullptr;

+ * Copyright (c) 2014-2016 Isode Limited.

+QtDynamicGridLayout::QtDynamicGridLayout(QWidget* parent, bool enableDND) : QWidget(parent), dndEnabled_(enableDND), movingTab_(nullptr) {

+ gridLayout_ = new QGridLayout(this);

+ setContentsMargins(0,0,0,0);

+ setDimensions(QSize(1,1));

+ connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(handleApplicationFocusChanged(QWidget*,QWidget*)));

+ assert(gridLayout_->rowCount() > 0 && gridLayout_->columnCount() > 0);

+

+ QPoint lastPos(0,0);

+ if (tabPositions_.contains(P2QSTRING(tab->getID()))) {

+ lastPos = tabPositions_[P2QSTRING(tab->getID())];

+ }

+

+ lastPos = QPoint(qMin(lastPos.x(), gridLayout_->columnCount() - 1), qMin(lastPos.y(), gridLayout_->rowCount() - 1));

+

+ QLayoutItem* item = gridLayout_->itemAtPosition(lastPos.y(), lastPos.x());

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(item ? item->widget() : nullptr);

+ if (tabWidget) {

+ tabWidget->addTab(tab, title);

+ }

+ tab->setEmphasiseFocus(getDimension().width() > 1 || getDimension().height() > 1);

+ return tabWidget ? indexOf(tab) : -1;

+ int count = 0;

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ if (tabWidget) {

+ count += tabWidget->count();

+ }

+ }

+ }

+ return count;

+ QWidget* widgetAtIndex = nullptr;

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem ? layoutItem->widget() : nullptr);

+ if (tabWidget) {

+ if (index < tabWidget->count()) {

+ widgetAtIndex = tabWidget->widget(index);

+ return widgetAtIndex;

+ }

+ else {

+ index -= tabWidget->count();

+ }

+ }

+ }

+ }

+ return widgetAtIndex;

+ int index = 0;

+ if (widget) {

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ if (tabWidget) {

+ for (int n = 0; n < tabWidget->count(); n++) {

+ QWidget* nthWidget = tabWidget->widget(n);

+ if (nthWidget == widget) {

+ return index;

+ }

+ index++;

+ }

+ }

+ }

+ }

+ }

+ return -1;

+ if (movingTab_ || resizing_) {

+ return;

+ }

+

+ if (newFocus) {

+ if (isAncestorOf(newFocus)) {

+ QtTabbable *newTab = dynamic_cast<QtTabbable*>(newFocus->parentWidget());

+ if (newTab) {

+ onCurrentIndexChanged(currentIndex());

+ }

+ }

+ }

+ return indexOf(currentWidget());

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+ if (tabIndex >= 0) {

+ tabWidget->setCurrentIndex(tabIndex);

+ if (!tabWidget->hasFocus()) {

+ tabWidget->widget(tabIndex)->setFocus(Qt::TabFocusReason);

+ }

+ } else {

+ assert(false);

+ }

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+ if (tabWidget) {

+ tabWidget->removeTab(tabIndex);

+ }

+ QtTabbable* tab = qobject_cast<QtTabbable*>(object);

+ if (!tab) {

+ return false;

+ }

+ if (tab && (tab != movingTab_)) {

+ if (event->type() == QEvent::Show) {

+ return true;

+ }

+ }

+ return false;

+ QWidget* current = nullptr;

+ current = focusWidget();

+ while (current && !dynamic_cast<QtTabbable*>(current)) {

+ if (current->parentWidget()) {

+ current = current->parentWidget();

+ } else {

+ current = nullptr;

+ break;

+ }

+ }

+ if (!current) {

+ current = widget(0);

+ }

+ return current;

+ if (widget) {

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ if (tabWidget) {

+ for (int n = 0; n < tabWidget->count(); n++) {

+ if (tabWidget->widget(n) == widget) {

+ tabWidget->setCurrentWidget(widget);

+ }

+ }

+ }

+ }

+ }

+ }

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ if (tabWidget) {

+ if (index < tabWidget->count()) {

+ tabIndex = index;

+ return tabWidget;

+ }

+ else {

+ index -= tabWidget->count();

+ if (index < 0) {

+ qWarning() << "Called QtDynamicGridLayout::setCurrentIndex with index out of bounds: index = " << index;

+ tabIndex = -1;

+ return nullptr;

+ }

+ }

+ }

+ }

+ }

+ tabIndex = -1;

+ return nullptr;

+ return dndEnabled_;

+ return tabPositions_;

+ tabPositions_ = positions;

+ return QSize(gridLayout_->columnCount(), gridLayout_->rowCount());

+ resizing_ = true;

+ assert(dim.width() > 0 && dim.height() > 0);

+ setUpdatesEnabled(false);

+

+ QWidget* restoredWidget = currentWidget();

+

+ QGridLayout* oldLayout = dynamic_cast<QGridLayout*>(layout());

+ QGridLayout* newLayout = new QGridLayout(this);

+ newLayout->setSpacing(4);

+ newLayout->setContentsMargins(0,0,0,0);

+

+ int oldWidth = oldLayout->columnCount();

+ int oldHeight = oldLayout->rowCount();

+ int maxCol = qMax(oldWidth, dim.width());

+ int minCol = qMin(oldWidth, dim.width());

+ int maxRow = qMax(oldHeight, dim.height());

+ int minRow = qMin(oldHeight, dim.height());

+

+ for (int row = 0; row < maxRow; row++) {

+ for (int col = 0; col < maxCol; col++) {

+ QLayoutItem* oldItem = oldLayout->itemAtPosition(row, col);

+ QLayoutItem* newItem = newLayout->itemAtPosition(row, col);

+ bool removeRow = !(row < dim.height());

+ bool removeCol = !(col < dim.width());

+

+ if (removeCol || removeRow) {

+ if (oldItem) {

+ int squeezeRow = removeRow ? (minRow - 1) : row;

+ int squeezeCol = removeCol ? (minCol - 1) : col;

+ newItem = newLayout->itemAtPosition(squeezeRow, squeezeCol);

+ if (!newItem) {

+ newLayout->addWidget(createDNDTabWidget(this), squeezeRow, squeezeCol);

+ newItem = newLayout->itemAtPosition(squeezeRow, squeezeCol);

+ }

+ QtTabWidget* oldTabWidget = dynamic_cast<QtTabWidget*>(oldItem->widget());

+ QtTabWidget* newTabWidget = dynamic_cast<QtTabWidget*>(newItem->widget());

+ assert(oldTabWidget && newTabWidget);

+

+ oldTabWidget->hide();

+ while(oldTabWidget->count()) {

+ QIcon icon = oldTabWidget->tabIcon(0);

+ QString text = oldTabWidget->tabText(0);

+ newTabWidget->addTab(oldTabWidget->widget(0), icon, text);

+ }

+ delete oldTabWidget;

+ }

+ } else {

+ if (oldItem) {

+ newLayout->addWidget(oldItem->widget(), row, col);

+ newItem = newLayout->itemAtPosition(row, col);

+ } else {

+ newLayout->addWidget(createDNDTabWidget(this), row, col);

+ }

+ }

+ }

+ }

+

+ for (int col = 0; col < dim.width(); col++) {

+ newLayout->setColumnStretch(col, 1);

+ }

+ for (int row = 0; row < dim.height(); row++) {

+ newLayout->setRowStretch(row, 1);

+ }

+

+ setUpdatesEnabled(true);

+ delete layout();

+ setLayout(newLayout);

+ gridLayout_ = newLayout;

+

+ resizing_ = false;

+ setCurrentWidget(restoredWidget);

+

+ updateEmphasiseFocusOnTabs();

+}

+

+void QtDynamicGridLayout::updateEmphasiseFocusOnTabs() {

+ const auto currentDimensions = getDimension();

+

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ assert(tabWidget);

+ for (int index = 0; index < tabWidget->count(); index++) {

+ QtTabbable* tab = dynamic_cast<QtTabbable*>(tabWidget->widget(index));

+ assert(tab);

+ tab->setEmphasiseFocus(currentDimensions.height() > 1 || currentDimensions.width() > 1);

+ }

+ }

+ }

+ int index = currentIndex();

+ if (index >= 0) {

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+ assert(tabWidget);

+ int newTabIndex = (tabIndex + 1) % tabWidget->count();

+ moveTab(tabWidget, tabIndex, newTabIndex);

+ }

+ int index = currentIndex();

+ if (index >= 0) {

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+ assert(tabWidget);

+ int newTabIndex = (tabWidget->count() + tabIndex - 1) % tabWidget->count();

+ moveTab(tabWidget, tabIndex, newTabIndex);

+ }

+ int index = currentIndex();

+ if (index >= 0) {

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+

+ int row = -1;

+ int col = -1;

+ int tmp;

+ gridLayout_->getItemPosition(gridLayout_->indexOf(tabWidget), &row, &col, &tmp, &tmp);

+

+ // calculate next cell

+ col++;

+ if (!(col < gridLayout_->columnCount())) {

+ col = 0;

+ row++;

+ if (!(row < gridLayout_->rowCount())) {

+ row = 0;

+ }

+ }

+

+ QtTabWidget* targetTabWidget = dynamic_cast<QtTabWidget*>(gridLayout_->itemAtPosition(row, col)->widget());

+ assert(tabWidget);

+ assert(targetTabWidget);

+

+ // fetch tab information

+ QWidget* tab = tabWidget->widget(tabIndex);

+ QString tabText = tabWidget->tabText(tabIndex);

+

+ // move tab

+ tab->blockSignals(true);

+ targetTabWidget->addTab(tab, tabText);

+ tab->blockSignals(false);

+ tab->setFocus(Qt::TabFocusReason);

+

+ updateTabPositions();

+ }

+ int index = currentIndex();

+ if (index >= 0) {

+ int tabIndex = -1;

+ QtTabWidget* tabWidget = indexToTabWidget(index, tabIndex);

+

+ int row = -1;

+ int col = -1;

+ int tmp;

+ gridLayout_->getItemPosition(gridLayout_->indexOf(tabWidget), &row, &col, &tmp, &tmp);

+

+ // calculate next cell

+ col--;

+ if (col < 0) {

+ col = gridLayout_->columnCount() - 1;

+ row--;

+ if (row < 0) {

+ row = gridLayout_->rowCount() - 1;

+ }

+ }

+

+ QtTabWidget* targetTabWidget = dynamic_cast<QtTabWidget*>(gridLayout_->itemAtPosition(row, col)->widget());

+ assert(tabWidget);

+ assert(targetTabWidget);

+

+ // fetch tab information

+ QWidget* tab = tabWidget->widget(tabIndex);

+ QString tabText = tabWidget->tabText(tabIndex);

+

+ // move tab

+ tab->blockSignals(true);

+ targetTabWidget->addTab(tab, tabText);

+ tab->blockSignals(false);

+ tab->setFocus(Qt::TabFocusReason);

+

+ updateTabPositions();

+ }

+ updateTabPositions();

+ QtTabWidget* tabWidgetSender = dynamic_cast<QtTabWidget*>(sender());

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ if (tabWidget == tabWidgetSender) {

+ tabCloseRequested(index);

+ }

+ else {

+ index += tabWidget->count();

+ }

+ }

+ }

+ if (movingTab_) {

+ return;

+ }

+

+ if (index >= 0) {

+ QTabWidget* sendingTabWidget = dynamic_cast<QTabWidget*>(sender());

+ assert(sendingTabWidget);

+ sendingTabWidget->widget(index)->setFocus();

+ }

+ for (int y = 0; y < gridLayout_->rowCount(); y++) {

+ for (int x = 0; x < gridLayout_->columnCount(); x++) {

+ QLayoutItem* layoutItem = gridLayout_->itemAtPosition(y, x);

+ QtTabWidget* tabWidget = dynamic_cast<QtTabWidget*>(layoutItem->widget());

+ assert(tabWidget);

+ for (int index = 0; index < tabWidget->count(); index++) {

+ QtTabbable* tab = dynamic_cast<QtTabbable*>(tabWidget->widget(index));

+ assert(tab);

+ tabPositions_.insert(P2QSTRING(tab->getID()), QPoint(x, y));

+ }

+ }

+ }

+ SWIFT_LOG_ASSERT(movingTab_ == nullptr, error) << std::endl;

+ movingTab_ = qobject_cast<QtTabbable*>(tabWidget->widget(oldIndex));

+ SWIFT_LOG_ASSERT(movingTab_ != nullptr, error) << std::endl;

+

+ if (movingTab_) {

+ // Install event filter that filters out events issued during the internal movement of the

+ // tab but not targeted at the moving tab.

+ qApp->installEventFilter(this);

+

+ tabWidget->tabBar()->moveTab(oldIndex, newIndex);

+

+ qApp->removeEventFilter(this);

+ SWIFT_LOG_ASSERT(movingTab_ == tabWidget->widget(newIndex), error) << std::endl;

+ }

+ movingTab_ = nullptr;

+ tabWidget->widget(newIndex)->setFocus();

+ QtTabWidget* tab = new QtTabWidget(parent);

+ if (dndEnabled_) {

+ QtDNDTabBar* tabBar = new QtDNDTabBar(tab);

+ connect(tabBar, SIGNAL(onDropSucceeded()), this, SLOT(updateTabPositions()));

+ tab->setTabBar(tabBar);

+ }

+ tab->setUsesScrollButtons(true);

+ tab->setElideMode(Qt::ElideRight);

+ /*For Macs, change the tab rendering.*/

+ tab->setDocumentMode(true);

+ /*Closable tabs are only in Qt4.5 and later*/

+ tab->setTabsClosable(true);

+ tab->setMovable(true);

+ connect(tab, SIGNAL(tabCloseRequested(int)), this, SLOT(handleTabCloseRequested(int)));

+ connect(tab, SIGNAL(currentChanged(int)), this, SLOT(handleTabCurrentChanged(int)));

+ return tab;

+ * Copyright (c) 2014-2016 Isode Limited.

+ class QtTabbable;

+ class QtTabWidget;

+ class QtDynamicGridLayout : public QWidget {

+ Q_OBJECT

+ public:

+ explicit QtDynamicGridLayout(QWidget* parent = nullptr, bool enableDND = false);

+ virtual ~QtDynamicGridLayout();

+ QSize getDimension() const;

+ // emulate QtTabWidget API

+ int addTab(QtTabbable* tab, const QString& title);

+ void removeTab(int index);

+ int count() const;

+ QWidget* widget(int index) const;

+ QWidget* currentWidget() const;

+ void setCurrentWidget(QWidget* widget);

+ QtTabWidget* indexToTabWidget(int index, int& tabIndex);

+ int indexOf(const QWidget* widget) const;

+ int currentIndex() const;

+ void setCurrentIndex(int index);

+ bool isDNDEnabled() const;

+ QHash<QString, QPoint> getTabPositions() const;

+ void setTabPositions(const QHash<QString, QPoint> positions);

+ bool eventFilter(QObject* object, QEvent* event);

+ signals:

+ void tabCloseRequested(int index);

+ void onCurrentIndexChanged(int newIndex);

+ public slots:

+ void setDimensions(const QSize& dim);

+ // Tab Management

+ void moveCurrentTabRight();

+ void moveCurrentTabLeft();

+ void moveCurrentTabToNextGroup();

+ void moveCurrentTabToPreviousGroup();

+ void updateTabPositions();

+ private slots:

+ void handleTabCloseRequested(int index);

+ void handleTabCurrentChanged(int index);

+ void handleApplicationFocusChanged(QWidget* oldFocus, QWidget* newFocus);

+ private:

+ void moveTab(QtTabWidget* tabWidget, int oldIndex, int newIndex);

+ QtTabWidget* createDNDTabWidget(QWidget* parent);

+ void updateEmphasiseFocusOnTabs();

+ private:

+ QGridLayout *gridLayout_;

+ bool dndEnabled_;

+ QHash<QString, QPoint> tabPositions_;

+ QtTabbable* movingTab_;

+ bool resizing_ = false;

+ };

+ * Copyright (c) 2014-2016 Isode Limited.

+#include <QApplication>

+#include <QCursor>

+#include <QStyleOption>

+QtGridSelectionDialog::QtGridSelectionDialog(QWidget* parent) : QWidget(parent), descriptionText(tr("Select the number of rows and columns for your layout. You can change the size by moving the mouse or cursor keys.")) {

+ frameSize = QSize(28,28) * 2;

+ maxGridSize = QSize(7,7);

+ minGridSize = QSize(1,1);

+ currentGridSize = QSize(1,1);

+ padding = 4;

+ setWindowFlags(Qt::FramelessWindowHint);

+ setCursor(Qt::SizeAllCursor);

+ horizontalMargin = style()->pixelMetric(QStyle::PM_LayoutLeftMargin);

+ verticalMargin = style()->pixelMetric(QStyle::PM_LayoutBottomMargin);

+ // PM_MenuVMargin | frameSize | ( padding | frameSize ) * | PM_MenuVMargin

+ int width = horizontalMargin + frameSize.width() + (padding + frameSize.width()) * (currentGridSize.width() - 1) + horizontalMargin;

+ int height = verticalMargin + frameSize.height() + (padding + frameSize.height()) * (currentGridSize.height() - 1) + verticalMargin;

+

+ // Add space for descriptive centered text below.

+ auto fontMetrics = QFontMetrics(QApplication::font());

+ auto descriptionBB = fontMetrics.boundingRect(QRect(0,0,width - 2*horizontalMargin,1000), Qt::TextWordWrap, descriptionText, 0, 0);

+

+ height += descriptionBB.height() + descriptionBB.y();

+

+ return QSize(width, height);

+ currentGridSize = size;

+ emit currentGridSizeChanged(size);

+ return currentGridSize;

+ minGridSize = size;

+ emit minGridSizeChanged(size);

+ return minGridSize;

+ maxGridSize = size;

+ emit maxGridSizeChanged(size);

+ return maxGridSize;

+ if (event) {

+ QSize newGridSize = currentGridSize;

+ if (event->key() == Qt::Key_Up) {

+ newGridSize += QSize(0, -1);

+ }

+ else if (event->key() == Qt::Key_Down) {

+ newGridSize += QSize(0, 1);

+ }

+ else if (event->key() == Qt::Key_Left) {

+ newGridSize += QSize(-1, 0);

+ }

+ else if (event->key() == Qt::Key_Right) {

+ newGridSize += QSize(1, 0);

+ }

+ else if (event->key() == Qt::Key_Return) {

+ hide();

+ setCurrentGridSize(currentGridSize);

+ }

+ if (minGridSize.expandedTo(newGridSize).boundedTo(maxGridSize) != currentGridSize) {

+ currentGridSize = minGridSize.expandedTo(newGridSize).boundedTo(maxGridSize);

+

+ QSize newSizeHint = sizeHint();

+ resize(newSizeHint);

+ QCursor::setPos(mapToGlobal(QPoint(newSizeHint.width(), newSizeHint.height()) - QPoint(frameSize.width() / 2, frameSize.height() / 2)));

+ }

+ }

+ hide();

+ setCurrentGridSize(currentGridSize);

+ QPainter painter(this);

+ // draw grid

+ QRect gridCell = QRect(QPoint(0,0), frameSize);

+ painter.setBrush(palette().highlight());

+ painter.setPen(Qt::NoPen);

+ for (int x = 0; x < currentGridSize.width(); x++) {

+ for (int y = 0; y < currentGridSize.height(); y++) {

+ int xPos = horizontalMargin + (x * (frameSize.width() + padding));

+ int yPos = verticalMargin + (y * (frameSize.height() + padding));

+ gridCell.moveTo(QPoint(xPos, yPos));

+ painter.drawRect(gridCell);

+ }

+ }

+

+ // draw description text

+ auto fontMetrics = QFontMetrics(QApplication::font());

+ auto descriptionBB = fontMetrics.boundingRect(QRect(0,0, width() - 2 * horizontalMargin,0), Qt::AlignHCenter | Qt::AlignTop | Qt::TextWordWrap, descriptionText, 0, 0);

+

+ QStyleOption opt;

+ opt.initFrom(this);

+ int textY = verticalMargin + (currentGridSize.height() * (frameSize.height() + padding));

+ int textX = (size().width() - descriptionBB.width()) / 2;

+ style()->drawItemText(&painter, QRect(textX, textY, descriptionBB.width(), descriptionBB.height()), Qt::AlignHCenter | Qt::AlignTop | Qt::TextWordWrap, opt.palette, true, descriptionText, foregroundRole());

+ int xPos = horizontalMargin + frameSize.width() + (padding + frameSize.width()) * (currentGridSize.width() - 1) - frameSize.width()/2;

+ int yPos = verticalMargin + frameSize.height() + (padding + frameSize.height()) * (currentGridSize.height() - 1) - frameSize.height()/2;

+ QCursor::setPos(mapToGlobal(QPoint(xPos, yPos)));

+ setMouseTracking(true);

+ setMouseTracking(false);

+ QPoint diff = (frameGeometry().bottomRight() - QCursor::pos());

+ QSize newDimensions = currentGridSize;

+ if (diff.x() > frameSize.width() * 1.5) {

+ newDimensions -= QSize(diff.x() / (frameSize.width() * 1.5), 0);

+ }

+ if (diff.y() > frameSize.height() * 1.5) {

+ newDimensions -= QSize(0, diff.y() / (frameSize.height() * 1.5));

+ }

+ if (minGridSize.expandedTo(newDimensions).boundedTo(maxGridSize) != currentGridSize) {

+ currentGridSize = minGridSize.expandedTo(newDimensions).boundedTo(maxGridSize);

+ resize(sizeHint());

+ }

+ QPoint diff = (frameGeometry().bottomRight() - QCursor::pos());

+ QSize newGridSize = currentGridSize;

+ if (diff.x() < 0) {

+ newGridSize += QSize(1,0);

+ }

+ if (diff.y() < 0) {

+ newGridSize += QSize(0,1);

+ }

+ if (minGridSize.expandedTo(newGridSize).boundedTo(maxGridSize) != currentGridSize) {

+ currentGridSize = minGridSize.expandedTo(newGridSize).boundedTo(maxGridSize);

+ resize(sizeHint());

+ }

+}

+

+bool QtGridSelectionDialog::event(QEvent* event) {

+ // Hide the window when it becomes a non-top-level window.

+ if (event->type() == QEvent::WindowDeactivate) {

+ hide();

+ return true;

+ }

+ return QWidget::event(event);

+ * Copyright (c) 2014-2016 Isode Limited.

+ class QtGridSelectionDialog : public QWidget {

+ Q_OBJECT

+

+ Q_PROPERTY(QSize currentGridSize READ getCurrentGridSize WRITE setCurrentGridSize NOTIFY currentGridSizeChanged)

+ Q_PROPERTY(QSize minGridSize READ getMinGridSize WRITE setMinGridSize NOTIFY minGridSizeChanged)

+ Q_PROPERTY(QSize maxGridSize READ getMaxGridSize WRITE setMaxGridSize NOTIFY maxGridSizeChanged)

+ public:

+ explicit QtGridSelectionDialog(QWidget* parent = nullptr);

+

+ virtual QSize sizeHint() const;

+

+ void setCurrentGridSize(const QSize& size);

+ QSize getCurrentGridSize() const;

+ void setMinGridSize(const QSize& size);

+ QSize getMinGridSize() const;

+ void setMaxGridSize(const QSize& size);

+ QSize getMaxGridSize() const;

+

+ signals:

+ void currentGridSizeChanged(QSize);

+ void minGridSizeChanged(QSize);

+ void maxGridSizeChanged(QSize);

+

+ protected:

+ void keyReleaseEvent(QKeyEvent* event);

+ void mousePressEvent(QMouseEvent* event);

+ void mouseMoveEvent(QMouseEvent* event);

+ void paintEvent(QPaintEvent* event);

+ void showEvent(QShowEvent* event);

+ void hideEvent(QHideEvent* event);

+ void leaveEvent(QEvent *event);

+ bool event(QEvent* event);

+

+ private:

+ int padding;

+ int horizontalMargin;

+ int verticalMargin;

+

+ QSize frameSize;

+

+ QSize currentGridSize;

+ QSize minGridSize;

+ QSize maxGridSize;

+

+ const QString descriptionText;

+ };