libs/widgetutils/KisOptionCollectionWidget.cpp

0001 /*
0002  *  SPDX-FileCopyrightText: 2022 Deif Lou <ginoba@gmail.com>
0003  *
0004  *  SPDX-License-Identifier: GPL-2.0-or-later
0005  */
0006
0007 #include <QWidget>
0008 #include <QFrame>
0009 #include <QLabel>
0010 #include <QScrollArea>
0011 #include <QVariant>
0012 #include <QBoxLayout>
0013
0014 #include <kis_assert.h>
0015
0016 #include "KisOptionCollectionWidget.h"
0017
0018 class KisOptionCollectionWidgetWrapper : public QWidget
0019 {
0020     Q_OBJECT
0021
0022 public:
0023     KisOptionCollectionWidgetWrapper(QWidget *parent, QWidget *widget)
0024         : QWidget(parent)
0025         , m_widget(widget)
0026         , m_margin(0)
0027     {
0028         m_widget->setParent(this);
0029
0030         setSizePolicy(widget->sizePolicy());
0031
0032         QBoxLayout *layoutWidget = new QBoxLayout(QBoxLayout::TopToBottom);
0033         layoutWidget->setContentsMargins(m_margin, 0, m_margin, 0);
0034         layoutWidget->setSpacing(0);
0035         layoutWidget->addWidget(m_widget);
0036
0037         m_separator = new QFrame(this);
0038         m_separator->setFrameShape(QFrame::HLine);
0039         m_separator->setFrameShadow(QFrame::Sunken);
0040         m_separator->setFixedHeight(10);
0041
0042         QBoxLayout *layoutMain = new QBoxLayout(QBoxLayout::LeftToRight);
0043         layoutMain->setContentsMargins(0, 0, 0, 0);
0044         layoutMain->setSpacing(0);
0045         layoutMain->addLayout(layoutWidget);
0046         layoutMain->addWidget(m_separator);
0047
0048         setLayout(layoutMain);
0049     }
0050
0051     ~KisOptionCollectionWidgetWrapper() override {}
0052
0053     QWidget* widget() const
0054     {
0055         return m_widget;
0056     }
0057
0058     void setSeparatorVisible(bool visible)
0059     {
0060         QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0061         KIS_ASSERT(layoutMain);
0062
0063         const bool isVisible = layoutMain->count() > 1;
0064         if (isVisible == visible) {
0065             return;
0066         }
0067         if (isVisible) {
0068             layoutMain->takeAt(1);
0069             m_separator->setVisible(false);
0070         } else {
0071             layoutMain->insertWidget(1, m_separator);
0072             m_separator->setVisible(true);
0073         }
0074     }
0075
0076     void setOrientation(Qt::Orientation orientation)
0077     {
0078         QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0079         KIS_ASSERT(layoutMain);
0080         QBoxLayout *layoutWidget = dynamic_cast<QBoxLayout*>(layoutMain->itemAt(0)->layout());
0081         KIS_ASSERT(layoutWidget);
0082
0083         if (orientation == Qt::Vertical) {
0084             if (layoutMain->direction() == QBoxLayout::TopToBottom) {
0085                 return;
0086             }
0087             layoutWidget->setContentsMargins(m_margin, 0, m_margin, 0);
0088             m_separator->setFixedSize(QWIDGETSIZE_MAX, 10);
0089             m_separator->setFrameShape(QFrame::HLine);
0090             layoutMain->setDirection(QBoxLayout::TopToBottom);
0091         } else {
0092             if (layoutMain->direction() == QBoxLayout::LeftToRight) {
0093                 return;
0094             }
0095             layoutWidget->setContentsMargins(0, 0, 0, 0);
0096             m_separator->setFixedSize(20, QWIDGETSIZE_MAX);
0097             m_separator->setFrameShape(QFrame::VLine);
0098             layoutMain->setDirection(QBoxLayout::LeftToRight);
0099         }
0100     }
0101
0102     void setWidgetMargin(int margin)
0103     {
0104         if (m_margin == margin) {
0105             return;
0106         }
0107         m_margin = margin;
0108         QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0109         if (layoutMain->direction() == QBoxLayout::TopToBottom) {
0110             QBoxLayout *layoutWidget = dynamic_cast<QBoxLayout*>(layoutMain->itemAt(0)->layout());
0111             KIS_SAFE_ASSERT_RECOVER_RETURN(layoutWidget);
0112             layoutWidget->setContentsMargins(margin, 0, margin, 0);
0113         }
0114     }
0115
0116 private:
0117     QWidget *m_widget;
0118     QFrame *m_separator;
0119     int m_margin;
0120 };
0121
0122 struct KisOptionCollectionWidgetWithHeader::Private
0123 {
0124     KisOptionCollectionWidgetWithHeader *q{nullptr};
0125     QLabel *label{nullptr};
0126     QWidget *primaryWidget{nullptr};
0127     KisOptionCollectionWidget *widgetCollection{nullptr};
0128     QBoxLayout *layoutHeader{nullptr};
0129     QBoxLayout *layoutPrimaryWidget{nullptr};
0130     QBoxLayout *layoutWidgets{nullptr};
0131     Qt::Orientation orientation{Qt::Vertical};
0132
0133     Private(KisOptionCollectionWidgetWithHeader *q) : q(q) {}
0134
0135     void adjustPrimaryWidget()
0136     {
0137         if (!primaryWidget || !primaryWidget->isVisible()) {
0138             return;
0139         }
0140
0141         if (orientation == Qt::Horizontal) {
0142             if (layoutHeader->direction() == QBoxLayout::LeftToRight) {
0143                 return;
0144             }
0145             layoutHeader->setDirection(QBoxLayout::LeftToRight);
0146             layoutHeader->setSpacing(10);
0147             layoutPrimaryWidget->setContentsMargins(0, 0, 0, 0);
0148             return;
0149         }
0150         // label.width + primaryWidget.size + 10px spacing + 4px extra (just in case)
0151         const int minimumHeaderWidth = label->minimumSizeHint().width() +
0152                                        primaryWidget->minimumSizeHint().width() +
0153                                        10 + 4;
0154         if (q->width() < minimumHeaderWidth) {
0155             if (layoutHeader->direction() == QBoxLayout::TopToBottom) {
0156                 return;
0157             }
0158             layoutHeader->setDirection(QBoxLayout::TopToBottom);
0159             layoutHeader->setSpacing(5);
0160             layoutPrimaryWidget->setContentsMargins(5, 0, 0, 0);
0161         } else {
0162             if (layoutHeader->direction() == QBoxLayout::LeftToRight) {
0163                 return;
0164             }
0165             layoutHeader->setDirection(QBoxLayout::LeftToRight);
0166             layoutHeader->setSpacing(10);
0167             layoutPrimaryWidget->setContentsMargins(0, 0, 0, 0);
0168         }
0169     }
0170
0171     void adjustWidgetCollection()
0172     {
0173         QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(q->layout());
0174         KIS_ASSERT(layoutMain);
0175         if (layoutMain->indexOf(layoutWidgets) == -1) {
0176             if (widgetCollection->numberOfVisibleWidgets() == 0) {
0177                 return;
0178             }
0179             layoutMain->insertLayout(1, layoutWidgets, 1);
0180             widgetCollection->setVisible(true);
0181         } else {
0182             if (widgetCollection->numberOfVisibleWidgets() != 0) {
0183                 return;
0184             }
0185             layoutMain->takeAt(1);
0186             widgetCollection->setVisible(false);
0187         }
0188     }
0189
0190 };
0191
0192 struct KisOptionCollectionWidget::Private
0193 {
0194     KisOptionCollectionWidget *q{nullptr};
0195     QVector<KisOptionCollectionWidgetWrapper*> widgetWrappers;
0196     bool showSeparators{false};
0197     Qt::Orientation orientation{Qt::Vertical};
0198     int widgetsMargin{10};
0199
0200     Private(KisOptionCollectionWidget *q) : q(q) {}
0201
0202     void insertWidget(int index, const QString &id, QWidget *widget)
0203     {
0204         KisOptionCollectionWidgetWrapper *widgetWrapper =
0205             new KisOptionCollectionWidgetWrapper(q, widget);
0206         widgetWrapper->setProperty("id", id);
0207         widgetWrapper->setSeparatorVisible(showSeparators);
0208         widgetWrapper->setOrientation(orientation);
0209         widgetWrapper->setWidgetMargin(widgetsMargin);
0210         widgetWrappers.insert(index, widgetWrapper);
0211
0212         QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(q->layout());
0213         KIS_ASSERT(layoutMain);
0214
0215         int indexLayout;
0216         for (indexLayout = 0; indexLayout < layoutMain->count(); ++indexLayout) {
0217             const QWidget *prevWidget = layoutMain->itemAt(indexLayout)->widget();
0218             const int prevIndex = q->widgetIndexFromId(prevWidget->property("id").toString());
0219             if (prevIndex >= index) {
0220                 break;
0221             }
0222         }
0223         layoutMain->insertWidget(indexLayout, widgetWrapper);
0224         adjustSeparators();
0225     }
0226
0227     void adjustSeparators()
0228     {
0229         if (q->layout()->count() == 0) {
0230             return;
0231         }
0232         for (int i = 0; i < q->layout()->count() - 1; ++i) {
0233             KisOptionCollectionWidgetWrapper *widgetWrapper =
0234                 qobject_cast<KisOptionCollectionWidgetWrapper*>(q->layout()->itemAt(i)->widget());
0235             widgetWrapper->setSeparatorVisible(showSeparators);
0236         }
0237         KisOptionCollectionWidgetWrapper *lastWidgetWrapper =
0238             qobject_cast<KisOptionCollectionWidgetWrapper*>(q->layout()->itemAt(q->layout()->count() - 1)->widget());
0239         lastWidgetWrapper->setSeparatorVisible(false);
0240     }
0241
0242     int widgetIndexFromId(QStringRef id) const
0243     {
0244         for (int i = 0; i < widgetWrappers.size(); ++i) {
0245             if (widgetWrappers[i]->property("id").toString() == id) {
0246                 return i;
0247             }
0248         }
0249         return -1;
0250     }
0251
0252     bool containsWidget(QStringRef id) const
0253     {
0254         return widgetIndexFromId(id) != -1;
0255     }
0256
0257     QWidget* widget(int index) const
0258     {
0259         return widgetWrappers[index]->widget();
0260     }
0261
0262     QWidget* widget(QStringRef id) const
0263     {
0264         return widget(widgetIndexFromId(id));
0265     }
0266
0267     QWidget* findWidget(QStringRef path, QWidget *candidate = nullptr) const
0268     {
0269         while (path.startsWith('/')) {
0270             path = path.right(path.size() - 1);
0271         }
0272         if (path.isEmpty()) {
0273             return candidate;
0274         }
0275         const int slashPosition = path.indexOf('/');
0276         if (slashPosition == -1) {
0277             return widget(path);
0278         }
0279         QWidget *nextCandidate = widget(path.left(slashPosition));
0280         if (nextCandidate) {
0281             KisOptionCollectionWidget *optionCollectionWidget =
0282                 qobject_cast<KisOptionCollectionWidget*>(nextCandidate);
0283             if (optionCollectionWidget) {
0284                 return optionCollectionWidget->m_d->findWidget(path.right(path.size() - slashPosition), nextCandidate);
0285             }
0286             KisOptionCollectionWidgetWithHeader *optionCollectionWidgetWithHeader =
0287                 qobject_cast<KisOptionCollectionWidgetWithHeader*>(nextCandidate);
0288             if (optionCollectionWidgetWithHeader) {
0289                 return optionCollectionWidgetWithHeader->m_d->widgetCollection->m_d->findWidget(path.right(path.size() - slashPosition), nextCandidate);
0290             }
0291             QStringRef rest = path.right(path.size() - slashPosition);
0292             while (rest.startsWith('/')) {
0293                 rest = rest.right(rest.size() - 1);
0294             }
0295             if (rest.isEmpty()) {
0296                 return nextCandidate;
0297             }
0298         }
0299         return nullptr;
0300     }
0301 };
0302
0303 KisOptionCollectionWidget::KisOptionCollectionWidget(QWidget *parent)
0304     : QWidget(parent)
0305     , m_d(new Private(this))
0306 {
0307     QBoxLayout *layoutMain = new QBoxLayout(QBoxLayout::TopToBottom);
0308     layoutMain->setSpacing(5);
0309     layoutMain->setContentsMargins(0, 0, 0, 0);
0310     setLayout(layoutMain);
0311 }
0312
0313 KisOptionCollectionWidget::~KisOptionCollectionWidget()
0314 {}
0315
0316 int KisOptionCollectionWidget::widgetIndexFromId(const QString &id) const
0317 {
0318     return m_d->widgetIndexFromId(&id);
0319 }
0320
0321 bool KisOptionCollectionWidget::containsWidget(const QString &id) const
0322 {
0323     return m_d->containsWidget(&id);
0324 }
0325
0326 QWidget* KisOptionCollectionWidget::widget(int index) const
0327 {
0328     return m_d->widget(index);
0329 }
0330
0331 QWidget* KisOptionCollectionWidget::widget(const QString &id) const
0332 {
0333     return m_d->widget(&id);
0334 }
0335
0336 QWidget* KisOptionCollectionWidget::findWidget(const QString &path) const
0337 {
0338     return m_d->findWidget(&path);
0339 }
0340
0341 void KisOptionCollectionWidget::insertWidget(int index, const QString &id, QWidget *widget)
0342 {
0343     if (containsWidget(id)) {
0344         return;
0345     }
0346     m_d->insertWidget(index, id, widget);
0347 }
0348
0349 void KisOptionCollectionWidget::appendWidget(const QString &id, QWidget *widget)
0350 {
0351     insertWidget(m_d->widgetWrappers.size(), id, widget);
0352 }
0353
0354 void KisOptionCollectionWidget::removeWidget(int index)
0355 {
0356     delete takeWidget(index);
0357 }
0358
0359 void KisOptionCollectionWidget::removeWidget(const QString &id)
0360 {
0361     removeWidget(widgetIndexFromId(id));
0362 }
0363
0364 QWidget* KisOptionCollectionWidget::takeWidget(int index)
0365 {
0366     QWidget* widget = m_d->widgetWrappers[index]->widget();
0367     widget->setParent(nullptr);
0368     m_d->widgetWrappers.removeAt(index);
0369     m_d->adjustSeparators();
0370     return widget;
0371 }
0372
0373 QWidget* KisOptionCollectionWidget::takeWidget(const QString &id)
0374 {
0375     return takeWidget(widgetIndexFromId(id));
0376 }
0377
0378 void KisOptionCollectionWidget::setWidgetVisible(int index, bool visible)
0379 {
0380     KisOptionCollectionWidgetWrapper *widgetWrapper = m_d->widgetWrappers[index];
0381
0382     QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0383     KIS_SAFE_ASSERT_RECOVER_RETURN(layoutMain);
0384
0385     if (visible) {
0386         if (layoutMain->indexOf(widgetWrapper) != -1) {
0387             return;
0388         }
0389         int indexLayout;
0390         for (indexLayout = 0; indexLayout < layoutMain->count(); ++indexLayout) {
0391             const QWidget *prevWidget = layoutMain->itemAt(indexLayout)->widget();
0392             const int prevIndex = widgetIndexFromId(prevWidget->property("id").toString());
0393             if (prevIndex >= index) {
0394                 break;
0395             }
0396         }
0397         layoutMain->insertWidget(indexLayout, widgetWrapper);
0398         widgetWrapper->setVisible(true);
0399     } else {
0400         if (layoutMain->indexOf(widgetWrapper) == -1) {
0401             return;
0402         }
0403         layoutMain->takeAt(layoutMain->indexOf(widgetWrapper));
0404         widgetWrapper->setVisible(false);
0405     }
0406
0407     m_d->adjustSeparators();
0408 }
0409
0410 void KisOptionCollectionWidget::setWidgetVisible(const QString &id, bool visible)
0411 {
0412     setWidgetVisible(widgetIndexFromId(id), visible);
0413 }
0414
0415 void KisOptionCollectionWidget::setWidgetsMargin(int margin)
0416 {
0417     if (margin == m_d->widgetsMargin) {
0418         return;
0419     }
0420     m_d->widgetsMargin = margin;
0421     for (KisOptionCollectionWidgetWrapper *widgetWrapper : m_d->widgetWrappers) {
0422         widgetWrapper->setWidgetMargin(margin);
0423     }
0424 }
0425
0426 void KisOptionCollectionWidget::setSeparatorsVisible(bool visible)
0427 {
0428     if (visible == m_d->showSeparators) {
0429         return;
0430     }
0431     m_d->showSeparators = visible;
0432     QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0433     layoutMain->setSpacing(visible ? 0 : 5);
0434     m_d->adjustSeparators();
0435 }
0436
0437 void KisOptionCollectionWidget::setOrientation(Qt::Orientation orientation, bool recursive)
0438 {
0439     if (orientation == m_d->orientation) {
0440         return;
0441     }
0442     m_d->orientation = orientation;
0443     for (KisOptionCollectionWidgetWrapper *widgetWrapper : m_d->widgetWrappers) {
0444         widgetWrapper->setOrientation(orientation);
0445         if (recursive) {
0446             KisOptionCollectionWidget *optionCollectionWidget =
0447                 qobject_cast<KisOptionCollectionWidget*>(widgetWrapper->widget());
0448             if (optionCollectionWidget) {
0449                 optionCollectionWidget->setOrientation(orientation, true);
0450                 continue;
0451             }
0452             KisOptionCollectionWidgetWithHeader *optionCollectionWidgetWithHeader =
0453                 qobject_cast<KisOptionCollectionWidgetWithHeader*>(widgetWrapper->widget());
0454             if (optionCollectionWidgetWithHeader) {
0455                 optionCollectionWidgetWithHeader->setOrientation(orientation, true);
0456             }
0457         }
0458     }
0459     QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0460     layoutMain->setDirection(orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
0461 }
0462
0463 int KisOptionCollectionWidget::size() const
0464 {
0465     return m_d->widgetWrappers.size();
0466 }
0467
0468 int KisOptionCollectionWidget::numberOfVisibleWidgets() const
0469 {
0470     return layout()->count();
0471 }
0472
0473 KisOptionCollectionWidgetWithHeader::KisOptionCollectionWidgetWithHeader(const QString &title,
0474                                                                          QWidget *parent)
0475     : QWidget(parent)
0476     , m_d(new Private(this))
0477 {
0478     m_d->label = new QLabel(title, this);
0479
0480     m_d->layoutPrimaryWidget = new QBoxLayout(QBoxLayout::LeftToRight);
0481     m_d->layoutPrimaryWidget->setSpacing(0);
0482     m_d->layoutPrimaryWidget->setContentsMargins(0, 0, 0, 0);
0483
0484     m_d->layoutHeader = new QBoxLayout(QBoxLayout::LeftToRight);
0485     m_d->layoutHeader->setSpacing(10);
0486     m_d->layoutHeader->setContentsMargins(0, 0, 0, 0);
0487     m_d->layoutHeader->addWidget(m_d->label, 0);
0488
0489     m_d->widgetCollection = new KisOptionCollectionWidget(this);
0490     m_d->widgetCollection->setWidgetsMargin(0);
0491     m_d->widgetCollection->setVisible(false);
0492
0493     m_d->layoutWidgets = new QBoxLayout(QBoxLayout::TopToBottom);
0494     m_d->layoutWidgets->setSpacing(0);
0495     m_d->layoutWidgets->setContentsMargins(5, 0, 0, 0);
0496     m_d->layoutWidgets->addWidget(m_d->widgetCollection);
0497
0498     QBoxLayout *layoutMain = new QBoxLayout(QBoxLayout::TopToBottom);
0499     layoutMain->setSpacing(5);
0500     layoutMain->setContentsMargins(0, 0, 0, 0);
0501     layoutMain->addLayout(m_d->layoutHeader, 0);
0502
0503     setLayout(layoutMain);
0504 }
0505
0506 KisOptionCollectionWidgetWithHeader::~KisOptionCollectionWidgetWithHeader()
0507 {}
0508
0509 QSize KisOptionCollectionWidgetWithHeader::minimumSizeHint() const
0510 {
0511     if (m_d->orientation == Qt::Horizontal) {
0512         return QWidget::minimumSizeHint();
0513     }
0514
0515     const QSize widgetListMinimumSizeHint = m_d->layoutWidgets->minimumSize();
0516     // label.width + primaryWidget.size + 10px spacing + 4px extra (just in case)
0517     const int minimumHeaderWidth = m_d->label->minimumSizeHint().width() +
0518                                    (m_d->primaryWidget ? m_d->primaryWidget->minimumSizeHint().width() + 10 + 4 : 0);
0519     const QSize headerMinimumSizeHint =
0520         QSize(
0521             qMax(
0522                 m_d->label->minimumSizeHint().width(),
0523                 m_d->primaryWidget ? m_d->layoutPrimaryWidget->minimumSize().width() : 0
0524             ),
0525             width() < minimumHeaderWidth
0526             ? m_d->label->minimumSizeHint().height() +
0527               (m_d->primaryWidget && m_d->primaryWidget->isVisible()
0528                 ? m_d->layoutPrimaryWidget->minimumSize().height() + m_d->layoutHeader->spacing() : 0)
0529             : qMax(
0530                 m_d->label->minimumSizeHint().height(),
0531                 m_d->primaryWidget && m_d->primaryWidget->isVisible()
0532                     ? m_d->layoutPrimaryWidget->minimumSize().height() : 0
0533               )
0534         );
0535
0536     return
0537         QSize(
0538             qMax(widgetListMinimumSizeHint.width(), headerMinimumSizeHint.width()),
0539             headerMinimumSizeHint.height() +
0540                 (m_d->widgetCollection->numberOfVisibleWidgets() > 0 ? widgetListMinimumSizeHint.height() + layout()->spacing() : 0)
0541         );
0542 }
0543
0544 QWidget* KisOptionCollectionWidgetWithHeader::primaryWidget() const
0545 {
0546     return m_d->primaryWidget;
0547 }
0548
0549 void KisOptionCollectionWidgetWithHeader::setPrimaryWidget(QWidget *widget)
0550 {
0551     if (widget == m_d->primaryWidget) {
0552         return;
0553     }
0554     const bool wasPrimaryWidgetVisible =
0555         m_d->primaryWidget ? m_d->primaryWidget->isVisible() : true;
0556     removePrimaryWidget();
0557     if (!widget) {
0558         return;
0559     }
0560     m_d->primaryWidget = widget;
0561     widget->setParent(this);
0562     m_d->layoutPrimaryWidget->insertWidget(0, widget);
0563
0564     if (!wasPrimaryWidgetVisible) {
0565         widget->setVisible(false);
0566         return;
0567     }
0568
0569     m_d->layoutHeader->insertLayout(1, m_d->layoutPrimaryWidget, 1);
0570     widget->setVisible(true);
0571     m_d->adjustPrimaryWidget();
0572 }
0573
0574 void KisOptionCollectionWidgetWithHeader::removePrimaryWidget()
0575 {
0576     if (!m_d->primaryWidget) {
0577         return;
0578     }
0579     delete takePrimaryWidget();
0580 }
0581
0582 QWidget* KisOptionCollectionWidgetWithHeader::takePrimaryWidget()
0583 {
0584     QWidget *widget = m_d->primaryWidget;
0585     if (!widget) {
0586         return nullptr;
0587     }
0588     m_d->primaryWidget = nullptr;
0589     widget->setParent(nullptr);
0590     m_d->layoutHeader->takeAt(1);
0591     m_d->adjustPrimaryWidget();
0592     return widget;
0593
0594 }
0595
0596 void KisOptionCollectionWidgetWithHeader::setPrimaryWidgetVisible(bool visible)
0597 {
0598     KIS_ASSERT_RECOVER_RETURN(m_d->primaryWidget);
0599
0600     if (visible) {
0601         if (m_d->layoutHeader->count() == 2) {
0602             return;
0603         }
0604         m_d->layoutHeader->insertLayout(1, m_d->layoutPrimaryWidget, 1);
0605         m_d->primaryWidget->setVisible(true);
0606         m_d->adjustPrimaryWidget();
0607     } else {
0608         if (m_d->layoutHeader->count() == 1) {
0609             return;
0610         }
0611         m_d->layoutHeader->takeAt(1);
0612         m_d->primaryWidget->setVisible(false);
0613     }
0614 }
0615
0616 int KisOptionCollectionWidgetWithHeader::widgetIndexFromId(const QString &id) const
0617 {
0618     return m_d->widgetCollection->widgetIndexFromId(id);
0619 }
0620
0621 bool KisOptionCollectionWidgetWithHeader::containsWidget(const QString &id) const
0622 {
0623     return m_d->widgetCollection->containsWidget(id);
0624 }
0625
0626 QWidget* KisOptionCollectionWidgetWithHeader::widget(int index) const
0627 {
0628     return m_d->widgetCollection->widget(index);
0629 }
0630
0631 QWidget* KisOptionCollectionWidgetWithHeader::widget(const QString &id) const
0632 {
0633     return m_d->widgetCollection->widget(id);
0634 }
0635
0636 QWidget* KisOptionCollectionWidgetWithHeader::findWidget(const QString &path) const
0637 {
0638     return m_d->widgetCollection->findWidget(path);
0639 }
0640
0641 void KisOptionCollectionWidgetWithHeader::insertWidget(int index, const QString &id, QWidget *widget)
0642 {
0643     m_d->widgetCollection->insertWidget(index, id, widget);
0644     m_d->adjustWidgetCollection();
0645 }
0646
0647 void KisOptionCollectionWidgetWithHeader::appendWidget(const QString &id, QWidget *widget)
0648 {
0649     m_d->widgetCollection->appendWidget(id, widget);
0650     m_d->adjustWidgetCollection();
0651 }
0652
0653 void KisOptionCollectionWidgetWithHeader::removeWidget(int index)
0654 {
0655     m_d->widgetCollection->removeWidget(index);
0656     m_d->adjustWidgetCollection();
0657 }
0658
0659 void KisOptionCollectionWidgetWithHeader::removeWidget(const QString &id)
0660 {
0661     m_d->widgetCollection->removeWidget(id);
0662     m_d->adjustWidgetCollection();
0663 }
0664
0665 QWidget* KisOptionCollectionWidgetWithHeader::takeWidget(int index)
0666 {
0667     QWidget *w = m_d->widgetCollection->takeWidget(index);
0668     m_d->adjustWidgetCollection();
0669     return w;
0670 }
0671
0672 QWidget* KisOptionCollectionWidgetWithHeader::takeWidget(const QString &id)
0673 {
0674     QWidget *w =  m_d->widgetCollection->takeWidget(id);
0675     m_d->adjustWidgetCollection();
0676     return w;
0677 }
0678
0679 void KisOptionCollectionWidgetWithHeader::setWidgetVisible(int index, bool visible)
0680 {
0681     m_d->widgetCollection->setWidgetVisible(index, visible);
0682     m_d->adjustWidgetCollection();
0683 }
0684
0685 void KisOptionCollectionWidgetWithHeader::setWidgetVisible(const QString &id, bool visible)
0686 {
0687     m_d->widgetCollection->setWidgetVisible(id, visible);
0688     m_d->adjustWidgetCollection();
0689 }
0690
0691 void KisOptionCollectionWidgetWithHeader::setWidgetsMargin(int margin)
0692 {
0693     m_d->widgetCollection->setWidgetsMargin(margin);
0694 }
0695
0696 void KisOptionCollectionWidgetWithHeader::setSeparatorsVisible(bool visible)
0697 {
0698     m_d->widgetCollection->setSeparatorsVisible(visible);
0699 }
0700
0701 void KisOptionCollectionWidgetWithHeader::setOrientation(Qt::Orientation orientation, bool recursive)
0702 {
0703     if (orientation == m_d->orientation) {
0704         return;
0705     }
0706     m_d->orientation = orientation;
0707     m_d->adjustPrimaryWidget();
0708     m_d->widgetCollection->setOrientation(orientation, recursive);
0709     m_d->layoutWidgets->setDirection(orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
0710     QBoxLayout *layoutMain = dynamic_cast<QBoxLayout*>(layout());
0711     layoutMain->setDirection(orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
0712 }
0713
0714 int KisOptionCollectionWidgetWithHeader::size() const
0715 {
0716     return m_d->widgetCollection->size();
0717 }
0718
0719 int KisOptionCollectionWidgetWithHeader::numberOfVisibleWidgets() const
0720 {
0721     return m_d->widgetCollection->numberOfVisibleWidgets();
0722 }
0723
0724 void KisOptionCollectionWidgetWithHeader::resizeEvent(QResizeEvent*)
0725 {
0726     m_d->adjustPrimaryWidget();
0727 }
0728
0729 #include "KisOptionCollectionWidget.moc"