mirrors/Qt-Advanced-Docking-System
1
0
Fork 0
mirror of https://github.com/githubuser0xFFFF/Qt-Advanced-Docking-System.git synced 2025-04-01 02:42:39 +08:00
Code

formatting only

Browse Source
This commit is contained in:
Syarif Fakhri 2023-02-19 13:03:21 +08:00
parent 62af0e3f11
commit 80f5025b73
4 changed files with 546 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

416
src/AutoHideSideBar.cpp
View File

@ -16,7 +16,6 @@
** License along with this library; If not, see <http://www.gnu.org/licenses/>. ** License along with this library; If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
//============================================================================ //============================================================================
/// \file AutoHideSideBar.cpp /// \file AutoHideSideBar.cpp
/// \author Syarif Fakhri /// \author Syarif Fakhri
@ -24,7 +23,6 @@
/// \brief Implementation of CAutoHideSideBar class /// \brief Implementation of CAutoHideSideBar class
//============================================================================ //============================================================================
//============================================================================ //============================================================================
// INCLUDES // INCLUDES
//============================================================================ //============================================================================
@ -52,181 +50,173 @@ class CTabsWidget;
*/ */
struct AutoHideSideBarPrivate struct AutoHideSideBarPrivate
{ {
/** /**
* Private data constructor * Private data constructor
*/ */
AutoHideSideBarPrivate(CAutoHideSideBar* _public); AutoHideSideBarPrivate(CAutoHideSideBar *_public);
CAutoHideSideBar* _this; CAutoHideSideBar *_this;
CDockContainerWidget* ContainerWidget; CDockContainerWidget *ContainerWidget;
CTabsWidget* TabsContainerWidget; CTabsWidget *TabsContainerWidget;
QBoxLayout* TabsLayout; QBoxLayout *TabsLayout;
Qt::Orientation Orientation; Qt::Orientation Orientation;
SideBarLocation SideTabArea = SideBarLocation::SideBarLeft; SideBarLocation SideTabArea = SideBarLocation::SideBarLeft;
CAutoHideTab* PlaceholderTab; CAutoHideTab *PlaceholderTab;
/** /**
* Convenience function to check if this is a horizontal side bar * Convenience function to check if this is a horizontal side bar
*/ */
bool isHorizontal() const bool isHorizontal() const
{ {
return Qt::Horizontal == Orientation; return Qt::Horizontal == Orientation;
} }
/** /**
* Called from viewport to forward event handling to this * Called from viewport to forward event handling to this
*/ */
void handleViewportEvent(QEvent* e); void handleViewportEvent(QEvent *e);
/** /**
* Convenience function to access first tab * Convenience function to access first tab
*/ */
CAutoHideTab* firstTab() const {return _this->tab(0);} CAutoHideTab *firstTab() const { return _this->tab(0); }
/** /**
* Convenience function to access last tab * Convenience function to access last tab
*/ */
CAutoHideTab* lastTab() const {return _this->tab(_this->tabCount() - 1);} CAutoHideTab *lastTab() const { return _this->tab(_this->tabCount() - 1); }
}; // struct AutoHideSideBarPrivate }; // struct AutoHideSideBarPrivate
/** /**
* This widget stores the tab buttons * This widget stores the tab buttons
*/ */
class CTabsWidget : public QWidget class CTabsWidget : public QWidget
{ {
public: public:
using QWidget::QWidget; using QWidget::QWidget;
using Super = QWidget; using Super = QWidget;
AutoHideSideBarPrivate* EventHandler; AutoHideSideBarPrivate *EventHandler;
/** /**
* Returns the size hint as minimum size hint * Returns the size hint as minimum size hint
*/ */
virtual QSize minimumSizeHint() const override virtual QSize minimumSizeHint() const override
{ {
return Super::sizeHint(); return Super::sizeHint();
} }
/** /**
* Forward event handling to EventHandler * Forward event handling to EventHandler
*/ */
virtual bool event(QEvent* e) override virtual bool event(QEvent *e) override
{ {
EventHandler->handleViewportEvent(e); EventHandler->handleViewportEvent(e);
return Super::event(e); return Super::event(e);
} }
}; };
//============================================================================ //============================================================================
AutoHideSideBarPrivate::AutoHideSideBarPrivate(CAutoHideSideBar* _public) : AutoHideSideBarPrivate::AutoHideSideBarPrivate(CAutoHideSideBar *_public) : _this(_public),
_this(_public), PlaceholderTab(new CAutoHideTab(_this))
PlaceholderTab(new CAutoHideTab(_this))
{ {
PlaceholderTab->hide(); PlaceholderTab->hide();
} }
//============================================================================
void AutoHideSideBarPrivate::handleViewportEvent(QEvent *e)
{
switch (e->type())
{
case QEvent::ChildRemoved:
if (TabsLayout->isEmpty())
{
_this->hide();
}
break;
case QEvent::Resize:
if (_this->tabCount())
{
auto ev = static_cast<QResizeEvent *>(e);
auto Tab = _this->tabAt(0);
int Size = isHorizontal() ? ev->size().height() : ev->size().width();
int TabSize = isHorizontal() ? Tab->size().height() : Tab->size().width();
// If the size of the side bar is less than the size of the first tab
// then there are no visible tabs in this side bar. This check will
// fail if someone will force a very big border via CSS!!
if (Size < TabSize)
{
_this->hide();
}
}
else
{
_this->hide();
}
break;
default:
break;
}
}
//============================================================================ //============================================================================
void AutoHideSideBarPrivate::handleViewportEvent(QEvent* e) CAutoHideSideBar::CAutoHideSideBar(CDockContainerWidget *parent, SideBarLocation area) : Super(parent),
d(new AutoHideSideBarPrivate(this))
{ {
switch (e->type()) d->SideTabArea = area;
{ d->ContainerWidget = parent;
case QEvent::ChildRemoved: d->Orientation = (area == SideBarLocation::SideBarBottom || area == SideBarLocation::SideBarTop)
if (TabsLayout->isEmpty()) ? Qt::Horizontal
{ : Qt::Vertical;
_this->hide();
}
break;
case QEvent::Resize: setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
if (_this->tabCount()) setFrameStyle(QFrame::NoFrame);
setWidgetResizable(true);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
d->TabsContainerWidget = new CTabsWidget();
d->TabsContainerWidget->EventHandler = d;
d->TabsContainerWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
d->TabsContainerWidget->setObjectName("sideTabsContainerWidget");
d->TabsLayout = new QBoxLayout(d->Orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
d->TabsLayout->setContentsMargins(0, 0, 0, 0);
d->TabsLayout->setSpacing(12);
d->TabsLayout->addStretch(1);
d->TabsContainerWidget->setLayout(d->TabsLayout);
setWidget(d->TabsContainerWidget);
setFocusPolicy(Qt::NoFocus);
if (d->isHorizontal())
{ {
auto ev = static_cast<QResizeEvent*>(e); setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
auto Tab = _this->tabAt(0);
int Size = isHorizontal() ? ev->size().height() : ev->size().width();
int TabSize = isHorizontal() ? Tab->size().height() : Tab->size().width();
// If the size of the side bar is less than the size of the first tab
// then there are no visible tabs in this side bar. This check will
// fail if someone will force a very big border via CSS!!
if (Size < TabSize)
{
_this->hide();
}
} }
else else
{ {
_this->hide(); setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
} }
break;
default: hide();
break;
}
} }
//============================================================================ //============================================================================
CAutoHideSideBar::CAutoHideSideBar(CDockContainerWidget* parent, SideBarLocation area) : CAutoHideSideBar::~CAutoHideSideBar()
Super(parent),
d(new AutoHideSideBarPrivate(this))
{ {
d->SideTabArea = area; ADS_PRINT("~CSideTabBar()");
d->ContainerWidget = parent; // The SideTabeBar is not the owner of the tabs and to prevent deletion
d->Orientation = (area == SideBarLocation::SideBarBottom || area == SideBarLocation::SideBarTop) // we set the parent here to nullptr to remove it from the children
? Qt::Horizontal : Qt::Vertical; auto Tabs = findChildren<CAutoHideTab *>(QString(), Qt::FindDirectChildrenOnly);
for (auto Tab : Tabs)
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); {
setFrameStyle(QFrame::NoFrame); Tab->setParent(nullptr);
setWidgetResizable(true); }
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); delete d;
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
d->TabsContainerWidget = new CTabsWidget();
d->TabsContainerWidget->EventHandler = d;
d->TabsContainerWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
d->TabsContainerWidget->setObjectName("sideTabsContainerWidget");
d->TabsLayout = new QBoxLayout(d->Orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
d->TabsLayout->setContentsMargins(0, 0, 0, 0);
d->TabsLayout->setSpacing(12);
d->TabsLayout->addStretch(1);
d->TabsContainerWidget->setLayout(d->TabsLayout);
setWidget(d->TabsContainerWidget);
setFocusPolicy(Qt::NoFocus);
if (d->isHorizontal())
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
}
else
{
setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
}
hide();
} }
//============================================================================ //============================================================================
CAutoHideSideBar::~CAutoHideSideBar() void CAutoHideSideBar::insertTab(int Index, CAutoHideTab *SideTab)
{
ADS_PRINT("~CSideTabBar()");
// The SideTabeBar is not the owner of the tabs and to prevent deletion
// we set the parent here to nullptr to remove it from the children
auto Tabs = findChildren<CAutoHideTab*>(QString(), Qt::FindDirectChildrenOnly);
for (auto Tab : Tabs)
{
Tab->setParent(nullptr);
}
delete d;
}
//============================================================================
void CAutoHideSideBar::insertTab(int Index, CAutoHideTab* SideTab)
{ {
SideTab->setSideBar(this); SideTab->setSideBar(this);
SideTab->installEventFilter(this); SideTab->installEventFilter(this);
@ -234,72 +224,68 @@ void CAutoHideSideBar::insertTab(int Index, CAutoHideTab* SideTab)
connect(SideTab, SIGNAL(moving(QPoint)), this, SLOT(onAutoHideTabMoving(QPoint))); connect(SideTab, SIGNAL(moving(QPoint)), this, SLOT(onAutoHideTabMoving(QPoint)));
if (Index < 0) if (Index < 0)
{ {
d->TabsLayout->insertWidget(d->TabsLayout->count() - 1, SideTab); d->TabsLayout->insertWidget(d->TabsLayout->count() - 1, SideTab);
} }
else else
{ {
d->TabsLayout->insertWidget(Index, SideTab); d->TabsLayout->insertWidget(Index, SideTab);
} }
show(); show();
} }
//============================================================================ //============================================================================
CAutoHideDockContainer* CAutoHideSideBar::insertDockWidget(int Index, CDockWidget* DockWidget) CAutoHideDockContainer *CAutoHideSideBar::insertDockWidget(int Index, CDockWidget *DockWidget)
{ {
auto AutoHideContainer = new CAutoHideDockContainer(DockWidget, d->SideTabArea, d->ContainerWidget); auto AutoHideContainer = new CAutoHideDockContainer(DockWidget, d->SideTabArea, d->ContainerWidget);
DockWidget->dockManager()->dockFocusController()->clearDockWidgetFocus(DockWidget); DockWidget->dockManager()->dockFocusController()->clearDockWidgetFocus(DockWidget);
auto Tab = AutoHideContainer->autoHideTab(); auto Tab = AutoHideContainer->autoHideTab();
DockWidget->setSideTabWidget(Tab); DockWidget->setSideTabWidget(Tab);
insertTab(Index, Tab); insertTab(Index, Tab);
return AutoHideContainer; return AutoHideContainer;
}
//============================================================================
void CAutoHideSideBar::removeAutoHideWidget(CAutoHideDockContainer* AutoHideWidget)
{
AutoHideWidget->autoHideTab()->removeFromSideBar();
auto DockContainer = AutoHideWidget->dockContainer();
if (DockContainer)
{
DockContainer->removeAutoHideWidget(AutoHideWidget);
}
AutoHideWidget->setParent(nullptr);
} }
//============================================================================ //============================================================================
void CAutoHideSideBar::addAutoHideWidget(CAutoHideDockContainer* AutoHideWidget) void CAutoHideSideBar::removeAutoHideWidget(CAutoHideDockContainer *AutoHideWidget)
{ {
auto SideBar = AutoHideWidget->autoHideTab()->sideBar(); AutoHideWidget->autoHideTab()->removeFromSideBar();
if (SideBar == this) auto DockContainer = AutoHideWidget->dockContainer();
{ if (DockContainer)
return; {
} DockContainer->removeAutoHideWidget(AutoHideWidget);
}
if (SideBar) AutoHideWidget->setParent(nullptr);
{
SideBar->removeAutoHideWidget(AutoHideWidget);
}
AutoHideWidget->setParent(d->ContainerWidget);
AutoHideWidget->setSideBarLocation(d->SideTabArea);
d->ContainerWidget->registerAutoHideWidget(AutoHideWidget);
insertTab(-1, AutoHideWidget->autoHideTab());
} }
//============================================================================
void CAutoHideSideBar::addAutoHideWidget(CAutoHideDockContainer *AutoHideWidget)
{
auto SideBar = AutoHideWidget->autoHideTab()->sideBar();
if (SideBar == this)
{
return;
}
if (SideBar)
{
SideBar->removeAutoHideWidget(AutoHideWidget);
}
AutoHideWidget->setParent(d->ContainerWidget);
AutoHideWidget->setSideBarLocation(d->SideTabArea);
d->ContainerWidget->registerAutoHideWidget(AutoHideWidget);
insertTab(-1, AutoHideWidget->autoHideTab());
}
//============================================================================ //============================================================================
void CAutoHideSideBar::removeTab(CAutoHideTab* SideTab) void CAutoHideSideBar::removeTab(CAutoHideTab *SideTab)
{ {
SideTab->removeEventFilter(this); SideTab->removeEventFilter(this);
d->TabsLayout->removeWidget(SideTab); d->TabsLayout->removeWidget(SideTab);
if (d->TabsLayout->isEmpty()) if (d->TabsLayout->isEmpty())
{ {
hide(); hide();
} }
} }
//============================================================================ //============================================================================
bool CAutoHideSideBar::eventFilter(QObject *watched, QEvent *event) bool CAutoHideSideBar::eventFilter(QObject *watched, QEvent *event)
{ {
@ -309,7 +295,7 @@ bool CAutoHideSideBar::eventFilter(QObject *watched, QEvent *event)
} }
// As soon as on tab is shown, we need to show the side tab bar // As soon as on tab is shown, we need to show the side tab bar
auto Tab = qobject_cast<CAutoHideTab*>(watched); auto Tab = qobject_cast<CAutoHideTab *>(watched);
if (Tab) if (Tab)
{ {
show(); show();
@ -323,95 +309,86 @@ Qt::Orientation CAutoHideSideBar::orientation() const
return d->Orientation; return d->Orientation;
} }
//============================================================================ //============================================================================
CAutoHideTab* CAutoHideSideBar::tabAt(int index) const CAutoHideTab *CAutoHideSideBar::tabAt(int index) const
{ {
return qobject_cast<CAutoHideTab*>(d->TabsLayout->itemAt(index)->widget()); return qobject_cast<CAutoHideTab *>(d->TabsLayout->itemAt(index)->widget());
} }
//============================================================================ //============================================================================
int CAutoHideSideBar::tabCount() const int CAutoHideSideBar::tabCount() const
{ {
return d->TabsLayout->count() - 1; return d->TabsLayout->count() - 1;
} }
//============================================================================ //============================================================================
SideBarLocation CAutoHideSideBar::sideBarLocation() const SideBarLocation CAutoHideSideBar::sideBarLocation() const
{ {
return d->SideTabArea; return d->SideTabArea;
} }
//============================================================================ //============================================================================
void CAutoHideSideBar::saveState(QXmlStreamWriter& s) const void CAutoHideSideBar::saveState(QXmlStreamWriter &s) const
{ {
if (!tabCount()) if (!tabCount())
{
return;
}
s.writeStartElement("SideBar");
s.writeAttribute("Area", QString::number(sideBarLocation()));
s.writeAttribute("Tabs", QString::number(tabCount()));
for (auto i = 0; i < tabCount(); ++i)
{
auto Tab = tabAt(i);
if (!Tab)
{ {
continue; return;
} }
Tab->dockWidget()->autoHideDockContainer()->saveState(s); s.writeStartElement("SideBar");
} s.writeAttribute("Area", QString::number(sideBarLocation()));
s.writeAttribute("Tabs", QString::number(tabCount()));
s.writeEndElement(); for (auto i = 0; i < tabCount(); ++i)
{
auto Tab = tabAt(i);
if (!Tab)
{
continue;
}
Tab->dockWidget()->autoHideDockContainer()->saveState(s);
}
s.writeEndElement();
} }
//=========================================================================== //===========================================================================
QSize CAutoHideSideBar::minimumSizeHint() const QSize CAutoHideSideBar::minimumSizeHint() const
{ {
QSize Size = sizeHint(); QSize Size = sizeHint();
Size.setWidth(10); Size.setWidth(10);
return Size; return Size;
} }
//=========================================================================== //===========================================================================
QSize CAutoHideSideBar::sizeHint() const QSize CAutoHideSideBar::sizeHint() const
{ {
return d->TabsContainerWidget->sizeHint(); return d->TabsContainerWidget->sizeHint();
} }
//=========================================================================== //===========================================================================
int CAutoHideSideBar::spacing() const int CAutoHideSideBar::spacing() const
{ {
return d->TabsLayout->spacing(); return d->TabsLayout->spacing();
} }
//=========================================================================== //===========================================================================
void CAutoHideSideBar::setSpacing(int Spacing) void CAutoHideSideBar::setSpacing(int Spacing)
{ {
d->TabsLayout->setSpacing(Spacing); d->TabsLayout->setSpacing(Spacing);
} }
//=========================================================================== //===========================================================================
CDockContainerWidget* CAutoHideSideBar::dockContainer() const CDockContainerWidget *CAutoHideSideBar::dockContainer() const
{ {
return d->ContainerWidget; return d->ContainerWidget;
} }
//=========================================================================== //===========================================================================
void CAutoHideSideBar::onAutoHideTabMoved(const QPoint& GlobalPos) void CAutoHideSideBar::onAutoHideTabMoved(const QPoint &GlobalPos)
{ {
auto MovingTab = qobject_cast<CAutoHideTab*>(sender()); auto MovingTab = qobject_cast<CAutoHideTab *>(sender());
if (!MovingTab) if (!MovingTab)
{ {
return; return;
@ -427,11 +404,10 @@ void CAutoHideSideBar::onAutoHideTabMoved(const QPoint& GlobalPos)
d->TabsLayout->insertWidget(index, MovingTab); d->TabsLayout->insertWidget(index, MovingTab);
} }
//=========================================================================== //===========================================================================
void CAutoHideSideBar::onAutoHideTabMoving(const QPoint& GlobalPos) void CAutoHideSideBar::onAutoHideTabMoving(const QPoint &GlobalPos)
{ {
auto MovingTab = qobject_cast<CAutoHideTab*>(sender()); auto MovingTab = qobject_cast<CAutoHideTab *>(sender());
if (!MovingTab) if (!MovingTab)
{ {
return; return;
@ -463,10 +439,8 @@ void CAutoHideSideBar::onAutoHideTabMoving(const QPoint& GlobalPos)
// Find tab under mouse // Find tab under mouse
for (int i = 0; i < tabCount(); ++i) for (int i = 0; i < tabCount(); ++i)
{ {
CAutoHideTab* DropTab = tab(i); CAutoHideTab *DropTab = tab(i);
if (DropTab == d->PlaceholderTab || !DropTab->isVisibleTo(this) if (DropTab == d->PlaceholderTab || !DropTab->isVisibleTo(this) || !DropTab->geometry().contains(MousePos))
|| !DropTab->geometry().contains(MousePos)
)
{ {
continue; continue;
} }
@ -491,15 +465,13 @@ void CAutoHideSideBar::onAutoHideTabMoving(const QPoint& GlobalPos)
} }
} }
//=========================================================================== //===========================================================================
CAutoHideTab* CAutoHideSideBar::tab(int Index) const CAutoHideTab *CAutoHideSideBar::tab(int Index) const
{ {
if (Index >= tabCount() || Index < 0) if (Index >= tabCount() || Index < 0)
{ {
return nullptr; return nullptr;
} }
return qobject_cast<CAutoHideTab*>(d->TabsLayout->itemAt(Index)->widget()); return qobject_cast<CAutoHideTab *>(d->TabsLayout->itemAt(Index)->widget());
} }
} // namespace ads } // namespace ads

181
src/AutoHideSideBar.h
View File

@ -18,7 +18,6 @@
** License along with this library; If not, see <http://www.gnu.org/licenses/>. ** License along with this library; If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
//============================================================================ //============================================================================
/// \file AutoHideSideBar.h /// \file AutoHideSideBar.h
/// \author Syarif Fakhri /// \author Syarif Fakhri
@ -62,121 +61,121 @@ class ADS_EXPORT CAutoHideSideBar : public QScrollArea
Q_PROPERTY(int spacing READ spacing WRITE setSpacing) Q_PROPERTY(int spacing READ spacing WRITE setSpacing)
private: private:
AutoHideSideBarPrivate* d; ///< private data (pimpl) AutoHideSideBarPrivate *d; ///< private data (pimpl)
friend struct AutoHideSideBarPrivate; friend struct AutoHideSideBarPrivate;
friend class DockWidgetSideTab; friend class DockWidgetSideTab;
friend DockContainerWidgetPrivate; friend DockContainerWidgetPrivate;
friend CDockContainerWidget; friend CDockContainerWidget;
private Q_SLOTS: private Q_SLOTS:
void onAutoHideTabMoved(const QPoint& GlobalPos); void onAutoHideTabMoved(const QPoint &GlobalPos);
void onAutoHideTabMoving(const QPoint& GlobalPos); void onAutoHideTabMoving(const QPoint &GlobalPos);
protected: protected:
virtual bool eventFilter(QObject *watched, QEvent *event) override; virtual bool eventFilter(QObject *watched, QEvent *event) override;
/** /**
* Saves the state into the given stream * Saves the state into the given stream
*/ */
void saveState(QXmlStreamWriter& Stream) const; void saveState(QXmlStreamWriter &Stream) const;
/** /**
* Inserts the given dock widget tab at the given position. * Inserts the given dock widget tab at the given position.
* An Index value of -1 appends the side tab at the end. * An Index value of -1 appends the side tab at the end.
*/ */
void insertTab(int Index, CAutoHideTab* SideTab); void insertTab(int Index, CAutoHideTab *SideTab);
public: public:
using Super = QScrollArea; using Super = QScrollArea;
/** /**
* Default Constructor * Default Constructor
*/ */
CAutoHideSideBar(CDockContainerWidget* parent, SideBarLocation area); CAutoHideSideBar(CDockContainerWidget *parent, SideBarLocation area);
/** /**
* Virtual Destructor * Virtual Destructor
*/ */
virtual ~CAutoHideSideBar(); virtual ~CAutoHideSideBar();
/** /**
* Removes the given DockWidgetSideTab from the tabbar * Removes the given DockWidgetSideTab from the tabbar
*/ */
void removeTab(CAutoHideTab* SideTab); void removeTab(CAutoHideTab *SideTab);
/** /**
* Insert dock widget into the side bar. * Insert dock widget into the side bar.
* The function creates the auto hide dock container, inserts the * The function creates the auto hide dock container, inserts the
* auto hide tab * auto hide tab
*/ */
CAutoHideDockContainer* insertDockWidget(int Index, CDockWidget* DockWidget); CAutoHideDockContainer *insertDockWidget(int Index, CDockWidget *DockWidget);
/** /**
* Removes the auto hide widget from this side bar * Removes the auto hide widget from this side bar
*/ */
void removeAutoHideWidget(CAutoHideDockContainer* AutoHideWidget); void removeAutoHideWidget(CAutoHideDockContainer *AutoHideWidget);
/** /**
* Adds the given AutoHideWidget to this sidebar. * Adds the given AutoHideWidget to this sidebar.
* If the AutoHideWidget is in another sidebar, then it will be removed * If the AutoHideWidget is in another sidebar, then it will be removed
* from this sidebar. * from this sidebar.
*/ */
void addAutoHideWidget(CAutoHideDockContainer* AutoHideWidget); void addAutoHideWidget(CAutoHideDockContainer *AutoHideWidget);
/** /**
* Returns orientation of side tab. * Returns orientation of side tab.
*/ */
Qt::Orientation orientation() const; Qt::Orientation orientation() const;
/* /*
* get the side tab widget at position, returns nullptr if it's out of bounds * get the side tab widget at position, returns nullptr if it's out of bounds
*/ */
CAutoHideTab* tabAt(int index) const; CAutoHideTab *tabAt(int index) const;
/* /*
* Gets the count of the tab widgets * Gets the count of the tab widgets
*/ */
int tabCount() const; int tabCount() const;
/** /**
* Getter for side tab bar area property * Getter for side tab bar area property
*/ */
SideBarLocation sideBarLocation() const; SideBarLocation sideBarLocation() const;
/** /**
* Overrides the minimumSizeHint() function of QScrollArea * Overrides the minimumSizeHint() function of QScrollArea
* The minimumSizeHint() is bigger than the sizeHint () for the scroll * The minimumSizeHint() is bigger than the sizeHint () for the scroll
* area because even if the scrollbars are invisible, the required speace * area because even if the scrollbars are invisible, the required speace
* is reserved in the minimumSizeHint(). This override simply returns * is reserved in the minimumSizeHint(). This override simply returns
* sizeHint(); * sizeHint();
*/ */
virtual QSize minimumSizeHint() const override; virtual QSize minimumSizeHint() const override;
/** /**
* The function provides a sizeHint that matches the height of the * The function provides a sizeHint that matches the height of the
* internal viewport. * internal viewport.
*/ */
virtual QSize sizeHint() const override; virtual QSize sizeHint() const override;
/** /**
* Getter for spacing property - returns the spacing of the tabs * Getter for spacing property - returns the spacing of the tabs
*/ */
int spacing() const; int spacing() const;
/** /**
* Setter for spacing property - sets the spacing * Setter for spacing property - sets the spacing
*/ */
void setSpacing(int Spacing); void setSpacing(int Spacing);
/** /**
* Returns the dock container that hosts this sideBar() * Returns the dock container that hosts this sideBar()
*/ */
CDockContainerWidget* dockContainer() const; CDockContainerWidget *dockContainer() const;
/** /**
* Returns the tab with the given index * Returns the tab with the given index
*/ */
CAutoHideTab* tab(int Index) const; CAutoHideTab *tab(int Index) const;
}; };
} // namespace ads } // namespace ads
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

429
src/AutoHideTab.cpp
View File

@ -16,7 +16,6 @@
** License along with this library; If not, see <http://www.gnu.org/licenses/>. ** License along with this library; If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
//============================================================================ //============================================================================
/// \file AutoHideTab.cpp /// \file AutoHideTab.cpp
/// \author Syarif Fakhri /// \author Syarif Fakhri
@ -46,9 +45,9 @@ namespace ads
*/ */
struct AutoHideTabPrivate struct AutoHideTabPrivate
{ {
CAutoHideTab* _this; CAutoHideTab *_this;
CDockWidget* DockWidget = nullptr; CDockWidget *DockWidget = nullptr;
CAutoHideSideBar* SideBar = nullptr; CAutoHideSideBar *SideBar = nullptr;
Qt::Orientation Orientation{Qt::Vertical}; Qt::Orientation Orientation{Qt::Vertical};
QElapsedTimer TimeSinceHoverMousePress; QElapsedTimer TimeSinceHoverMousePress;
QPoint GlobalDragStartMousePosition; QPoint GlobalDragStartMousePosition;
@ -56,276 +55,258 @@ struct AutoHideTabPrivate
QPoint TabDragStartPosition; QPoint TabDragStartPosition;
eDragState DragState = DraggingInactive; eDragState DragState = DraggingInactive;
/** /**
* Private data constructor * Private data constructor
*/ */
AutoHideTabPrivate(CAutoHideTab* _public); AutoHideTabPrivate(CAutoHideTab *_public);
/** /**
* Update the orientation, visibility and spacing based on the area of * Update the orientation, visibility and spacing based on the area of
* the side bar * the side bar
*/ */
void updateOrientation(); void updateOrientation();
/** /**
* Convenience function to ease dock container access * Convenience function to ease dock container access
*/ */
CDockContainerWidget* dockContainer() const CDockContainerWidget *dockContainer() const
{ {
return DockWidget ? DockWidget->dockContainer() : nullptr; return DockWidget ? DockWidget->dockContainer() : nullptr;
} }
/** /**
* Forward this event to the dock container * Forward this event to the dock container
*/ */
void forwardEventToDockContainer(QEvent* event) void forwardEventToDockContainer(QEvent *event)
{ {
auto DockContainer = dockContainer(); auto DockContainer = dockContainer();
if (DockContainer) if (DockContainer)
{ {
DockContainer->handleAutoHideWidgetEvent(event, _this); DockContainer->handleAutoHideWidgetEvent(event, _this);
} }
} }
/** /**
* Saves the drag start position in global and local coordinates * Saves the drag start position in global and local coordinates
*/ */
void saveDragStartMousePosition(const QPoint& GlobalPos) void saveDragStartMousePosition(const QPoint &GlobalPos)
{ {
GlobalDragStartMousePosition = GlobalPos; GlobalDragStartMousePosition = GlobalPos;
DragStartMousePosition = _this->mapFromGlobal(GlobalPos); DragStartMousePosition = _this->mapFromGlobal(GlobalPos);
} }
/** /**
* Test function for current drag state * Test function for current drag state
*/ */
bool isDraggingState(eDragState dragState) const bool isDraggingState(eDragState dragState) const
{ {
return this->DragState == dragState; return this->DragState == dragState;
} }
/** /**
* Moves the tab depending on the position in the given mouse event * Moves the tab depending on the position in the given mouse event
*/ */
void moveTab(QMouseEvent* ev); void moveTab(QMouseEvent *ev);
}; // struct DockWidgetTabPrivate }; // struct DockWidgetTabPrivate
//============================================================================ //============================================================================
AutoHideTabPrivate::AutoHideTabPrivate(CAutoHideTab* _public) : AutoHideTabPrivate::AutoHideTabPrivate(CAutoHideTab *_public) : _this(_public)
_this(_public)
{ {
} }
//============================================================================ //============================================================================
void AutoHideTabPrivate::updateOrientation() void AutoHideTabPrivate::updateOrientation()
{ {
bool IconOnly = CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideSideBarsIconOnly); bool IconOnly = CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideSideBarsIconOnly);
if (IconOnly && !_this->icon().isNull()) if (IconOnly && !_this->icon().isNull())
{ {
_this->setText(""); _this->setText("");
_this->setOrientation(Qt::Horizontal); _this->setOrientation(Qt::Horizontal);
} }
else else
{ {
auto area = SideBar->sideBarLocation(); auto area = SideBar->sideBarLocation();
_this->setOrientation((area == SideBarBottom || area == SideBarTop) ? Qt::Horizontal : Qt::Vertical); _this->setOrientation((area == SideBarBottom || area == SideBarTop) ? Qt::Horizontal : Qt::Vertical);
} }
} }
//============================================================================ //============================================================================
void AutoHideTabPrivate::moveTab(QMouseEvent* ev) void AutoHideTabPrivate::moveTab(QMouseEvent *ev)
{ {
ev->accept(); ev->accept();
QPoint Distance = internal::globalPositionOf(ev) - GlobalDragStartMousePosition; QPoint Distance = internal::globalPositionOf(ev) - GlobalDragStartMousePosition;
Orientation == Qt::Horizontal ? Distance.setY(0) : Distance.setX(0); Orientation == Qt::Horizontal ? Distance.setY(0) : Distance.setX(0);
auto TargetPos = Distance + TabDragStartPosition; auto TargetPos = Distance + TabDragStartPosition;
if (Orientation == Qt::Horizontal) if (Orientation == Qt::Horizontal)
{ {
TargetPos.rx() = qMax(TargetPos.x(), 0); TargetPos.rx() = qMax(TargetPos.x(), 0);
TargetPos.rx() = qMin(_this->parentWidget()->rect().right() - _this->width() + 1, TargetPos.rx()); TargetPos.rx() = qMin(_this->parentWidget()->rect().right() - _this->width() + 1, TargetPos.rx());
} }
else else
{ {
TargetPos.ry() = qMax(0, TargetPos.y()); TargetPos.ry() = qMax(0, TargetPos.y());
TargetPos.ry() = qMin(_this->parentWidget()->rect().bottom() - _this->height() + 1, TargetPos.ry()); TargetPos.ry() = qMin(_this->parentWidget()->rect().bottom() - _this->height() + 1, TargetPos.ry());
} }
_this->move(TargetPos); _this->move(TargetPos);
_this->raise(); _this->raise();
} }
//============================================================================ //============================================================================
void CAutoHideTab::setSideBar(CAutoHideSideBar* SideTabBar) void CAutoHideTab::setSideBar(CAutoHideSideBar *SideTabBar)
{ {
d->SideBar = SideTabBar; d->SideBar = SideTabBar;
if (d->SideBar) if (d->SideBar)
{ {
d->updateOrientation(); d->updateOrientation();
} }
} }
//============================================================================ //============================================================================
CAutoHideSideBar* CAutoHideTab::sideBar() const CAutoHideSideBar *CAutoHideTab::sideBar() const
{ {
return d->SideBar; return d->SideBar;
} }
//============================================================================ //============================================================================
void CAutoHideTab::removeFromSideBar() void CAutoHideTab::removeFromSideBar()
{ {
if (d->SideBar == nullptr) if (d->SideBar == nullptr)
{ {
return; return;
} }
disconnect(d->SideBar); disconnect(d->SideBar);
d->SideBar->removeTab(this); d->SideBar->removeTab(this);
setSideBar(nullptr); setSideBar(nullptr);
} }
//============================================================================ //============================================================================
CAutoHideTab::CAutoHideTab(QWidget* parent) : CAutoHideTab::CAutoHideTab(QWidget *parent) : CPushButton(parent),
CPushButton(parent), d(new AutoHideTabPrivate(this))
d(new AutoHideTabPrivate(this))
{ {
setAttribute(Qt::WA_NoMousePropagation); setAttribute(Qt::WA_NoMousePropagation);
setFocusPolicy(Qt::NoFocus); setFocusPolicy(Qt::NoFocus);
} }
//============================================================================ //============================================================================
CAutoHideTab::~CAutoHideTab() CAutoHideTab::~CAutoHideTab()
{ {
ADS_PRINT("~CDockWidgetSideTab()"); ADS_PRINT("~CDockWidgetSideTab()");
delete d; delete d;
} }
//============================================================================ //============================================================================
void CAutoHideTab::updateStyle() void CAutoHideTab::updateStyle()
{ {
internal::repolishStyle(this, internal::RepolishDirectChildren); internal::repolishStyle(this, internal::RepolishDirectChildren);
update(); update();
} }
//============================================================================ //============================================================================
SideBarLocation CAutoHideTab::sideBarLocation() const SideBarLocation CAutoHideTab::sideBarLocation() const
{ {
if (d->SideBar) if (d->SideBar)
{ {
return d->SideBar->sideBarLocation(); return d->SideBar->sideBarLocation();
} }
return SideBarLeft; return SideBarLeft;
} }
//============================================================================ //============================================================================
void CAutoHideTab::setOrientation(Qt::Orientation Orientation) void CAutoHideTab::setOrientation(Qt::Orientation Orientation)
{ {
d->Orientation = Orientation; d->Orientation = Orientation;
if (orientation() == Qt::Horizontal) if (orientation() == Qt::Horizontal)
{ {
setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
} }
else else
{ {
setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum); setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
} }
CPushButton::setButtonOrientation((Qt::Horizontal == Orientation) CPushButton::setButtonOrientation((Qt::Horizontal == Orientation)
? CPushButton::Horizontal : CPushButton::VerticalTopToBottom); ? CPushButton::Horizontal
updateStyle(); : CPushButton::VerticalTopToBottom);
updateStyle();
} }
//============================================================================ //============================================================================
Qt::Orientation CAutoHideTab::orientation() const Qt::Orientation CAutoHideTab::orientation() const
{ {
return d->Orientation; return d->Orientation;
} }
//============================================================================ //============================================================================
bool CAutoHideTab::isActiveTab() const bool CAutoHideTab::isActiveTab() const
{ {
if (d->DockWidget && d->DockWidget->autoHideDockContainer()) if (d->DockWidget && d->DockWidget->autoHideDockContainer())
{ {
return d->DockWidget->autoHideDockContainer()->isVisible(); return d->DockWidget->autoHideDockContainer()->isVisible();
} }
return false; return false;
} }
//============================================================================ //============================================================================
CDockWidget* CAutoHideTab::dockWidget() const CDockWidget *CAutoHideTab::dockWidget() const
{ {
return d->DockWidget; return d->DockWidget;
} }
//============================================================================ //============================================================================
void CAutoHideTab::setDockWidget(CDockWidget* DockWidget) void CAutoHideTab::setDockWidget(CDockWidget *DockWidget)
{ {
if (!DockWidget) if (!DockWidget)
{ {
return; return;
} }
d->DockWidget = DockWidget; d->DockWidget = DockWidget;
setText(DockWidget->windowTitle()); setText(DockWidget->windowTitle());
setIcon(d->DockWidget->icon()); setIcon(d->DockWidget->icon());
setToolTip(DockWidget->windowTitle()); setToolTip(DockWidget->windowTitle());
} }
//============================================================================ //============================================================================
bool CAutoHideTab::event(QEvent* event) bool CAutoHideTab::event(QEvent *event)
{ {
if (!CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideShowOnMouseOver)) if (!CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideShowOnMouseOver))
{ {
return Super::event(event); return Super::event(event);
} }
switch (event->type()) switch (event->type())
{ {
case QEvent::Enter: case QEvent::Enter:
case QEvent::Leave: case QEvent::Leave:
d->forwardEventToDockContainer(event); d->forwardEventToDockContainer(event);
break; break;
case QEvent::MouseButtonRelease: case QEvent::MouseButtonRelease:
// If AutoHideShowOnMouseOver is active, then the showing is triggered // If AutoHideShowOnMouseOver is active, then the showing is triggered
// by a MousePresRelease sent to this tab. To prevent accidental hiding // by a MousePresRelease sent to this tab. To prevent accidental hiding
// of the tab by a mouse click, we wait at least 500 ms before we accept // of the tab by a mouse click, we wait at least 500 ms before we accept
// the mouse click // the mouse click
if (!event->spontaneous()) if (!event->spontaneous())
{ {
d->TimeSinceHoverMousePress.restart(); d->TimeSinceHoverMousePress.restart();
d->forwardEventToDockContainer(event); d->forwardEventToDockContainer(event);
} }
else if (d->TimeSinceHoverMousePress.hasExpired(500)) else if (d->TimeSinceHoverMousePress.hasExpired(500))
{ {
d->forwardEventToDockContainer(event); d->forwardEventToDockContainer(event);
} }
break; break;
default: default:
break; break;
} }
return Super::event(event); return Super::event(event);
} }
//============================================================================ //============================================================================
void CAutoHideTab::mousePressEvent(QMouseEvent* ev) void CAutoHideTab::mousePressEvent(QMouseEvent *ev)
{ {
if (ev->button() == Qt::LeftButton) if (ev->button() == Qt::LeftButton)
{ {
@ -338,75 +319,73 @@ void CAutoHideTab::mousePressEvent(QMouseEvent* ev)
Super::mousePressEvent(ev); Super::mousePressEvent(ev);
} }
//============================================================================ //============================================================================
void CAutoHideTab::mouseMoveEvent(QMouseEvent* ev) void CAutoHideTab::mouseMoveEvent(QMouseEvent *ev)
{ {
if (!(ev->buttons() & Qt::LeftButton) || d->isDraggingState(DraggingInactive)) if (!(ev->buttons() & Qt::LeftButton) || d->isDraggingState(DraggingInactive))
{ {
d->DragState = DraggingInactive; d->DragState = DraggingInactive;
Super::mouseMoveEvent(ev); Super::mouseMoveEvent(ev);
return; return;
} }
// move tab // move tab
if (d->isDraggingState(DraggingTab)) if (d->isDraggingState(DraggingTab))
{ {
// Moving the tab is always allowed because it does not mean moving the // Moving the tab is always allowed because it does not mean moving the
// dock widget around // dock widget around
d->moveTab(ev); d->moveTab(ev);
Q_EMIT moving(internal::globalPositionOf(ev)); Q_EMIT moving(internal::globalPositionOf(ev));
} }
else if ( else if (
(internal::globalPositionOf(ev) - d->GlobalDragStartMousePosition).manhattanLength() >= QApplication::startDragDistance()) // Wait a few pixels before start moving (internal::globalPositionOf(ev) - d->GlobalDragStartMousePosition).manhattanLength() >= QApplication::startDragDistance()) // Wait a few pixels before start moving
{ {
// If we start dragging the tab, we save its inital position to // If we start dragging the tab, we save its inital position to
// restore it later // restore it later
if (DraggingTab != d->DragState) if (DraggingTab != d->DragState)
{ {
d->TabDragStartPosition = this->pos(); d->TabDragStartPosition = this->pos();
} }
d->DragState = DraggingTab; d->DragState = DraggingTab;
return; return;
} }
Super::mouseMoveEvent(ev); Super::mouseMoveEvent(ev);
} }
//============================================================================ //============================================================================
void CAutoHideTab::mouseReleaseEvent(QMouseEvent* ev) void CAutoHideTab::mouseReleaseEvent(QMouseEvent *ev)
{ {
if (ev->button() == Qt::LeftButton) if (ev->button() == Qt::LeftButton)
{ {
auto CurrentDragState = d->DragState; auto CurrentDragState = d->DragState;
d->GlobalDragStartMousePosition = QPoint(); d->GlobalDragStartMousePosition = QPoint();
d->DragStartMousePosition = QPoint(); d->DragStartMousePosition = QPoint();
d->DragState = DraggingInactive; d->DragState = DraggingInactive;
switch (CurrentDragState) switch (CurrentDragState)
{ {
case DraggingInactive: case DraggingInactive:
case DraggingMousePressed: case DraggingMousePressed:
Q_EMIT released(); Q_EMIT released();
break; break;
case DraggingTab: case DraggingTab:
// End of tab moving, emit signal // End of tab moving, emit signal
ev->accept(); ev->accept();
Q_EMIT moved(internal::globalPositionOf(ev)); Q_EMIT moved(internal::globalPositionOf(ev));
break; break;
default:; // do nothing default:; // do nothing
} }
} }
Super::mouseReleaseEvent(ev); Super::mouseReleaseEvent(ev);
} }
//============================================================================ //============================================================================
bool CAutoHideTab::iconOnly() const bool CAutoHideTab::iconOnly() const
{ {
return CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideSideBarsIconOnly) && !icon().isNull(); return CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideSideBarsIconOnly) && !icon().isNull();
} }
} }

118
src/AutoHideTab.h
View File

@ -18,7 +18,6 @@
** License along with this library; If not, see <http://www.gnu.org/licenses/>. ** License along with this library; If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
//============================================================================ //============================================================================
/// \file AutoHideTab.h /// \file AutoHideTab.h
/// \author Syarif Fakhri /// \author Syarif Fakhri
@ -55,8 +54,8 @@ class ADS_EXPORT CAutoHideTab : public CPushButton
Q_PROPERTY(bool activeTab READ isActiveTab) Q_PROPERTY(bool activeTab READ isActiveTab)
Q_PROPERTY(bool iconOnly READ iconOnly) Q_PROPERTY(bool iconOnly READ iconOnly)
private: private:
AutoHideTabPrivate* d; ///< private data (pimpl) AutoHideTabPrivate *d; ///< private data (pimpl)
friend struct AutoHideTabPrivate; friend struct AutoHideTabPrivate;
friend class CDockWidget; friend class CDockWidget;
friend class CAutoHideDockContainer; friend class CAutoHideDockContainer;
@ -68,81 +67,80 @@ private:
protected: protected:
void setSideBar(CAutoHideSideBar *SideTabBar); void setSideBar(CAutoHideSideBar *SideTabBar);
void removeFromSideBar(); void removeFromSideBar();
bool event(QEvent* event) override; bool event(QEvent *event) override;
void mousePressEvent(QMouseEvent* ev) override; void mousePressEvent(QMouseEvent *ev) override;
void mouseReleaseEvent(QMouseEvent* ev) override; void mouseReleaseEvent(QMouseEvent *ev) override;
void mouseMoveEvent(QMouseEvent* ev) override; void mouseMoveEvent(QMouseEvent *ev) override;
public: public:
using Super = CPushButton; using Super = CPushButton;
/** /**
* Default Constructor * Default Constructor
* param[in] DockWidget The dock widget this title bar belongs to * param[in] DockWidget The dock widget this title bar belongs to
* param[in] parent The parent widget of this title bar * param[in] parent The parent widget of this title bar
*/ */
CAutoHideTab(QWidget* parent = nullptr); CAutoHideTab(QWidget *parent = nullptr);
/** /**
* Virtual Destructor * Virtual Destructor
*/ */
virtual ~CAutoHideTab(); virtual ~CAutoHideTab();
/** /**
* Update stylesheet style if a property changes * Update stylesheet style if a property changes
*/ */
void updateStyle(); void updateStyle();
/** /**
* Getter for side tab bar area property * Getter for side tab bar area property
*/ */
SideBarLocation sideBarLocation() const; SideBarLocation sideBarLocation() const;
/** /**
* Set orientation vertical or horizontal * Set orientation vertical or horizontal
*/ */
void setOrientation(Qt::Orientation Orientation); void setOrientation(Qt::Orientation Orientation);
/** /**
* Returns the current orientation * Returns the current orientation
*/ */
Qt::Orientation orientation() const; Qt::Orientation orientation() const;
/** /**
* Returns true, if this is the active tab. The tab is active if the auto * Returns true, if this is the active tab. The tab is active if the auto
* hide widget is visible * hide widget is visible
*/ */
bool isActiveTab() const; bool isActiveTab() const;
/** /**
* returns the dock widget this belongs to * returns the dock widget this belongs to
*/ */
CDockWidget* dockWidget() const; CDockWidget *dockWidget() const;
/** /**
* Sets the dock widget that is controlled by this tab * Sets the dock widget that is controlled by this tab
*/ */
void setDockWidget(CDockWidget* DockWidget); void setDockWidget(CDockWidget *DockWidget);
/** /**
* Returns true if the auto hide config flag AutoHideSideBarsIconOnly * Returns true if the auto hide config flag AutoHideSideBarsIconOnly
* is set and if the tab has an icon - that means the icon is not null * is set and if the tab has an icon - that means the icon is not null
*/ */
bool iconOnly() const; bool iconOnly() const;
/** /**
* Returns the side bar that contains this tab or a nullptr if the tab is * Returns the side bar that contains this tab or a nullptr if the tab is
* not in a side bar * not in a side bar
*/ */
CAutoHideSideBar* sideBar() const; CAutoHideSideBar *sideBar() const;
Q_SIGNALS: Q_SIGNALS:
void moved(const QPoint& GlobalPos); void moved(const QPoint &GlobalPos);
void moving(const QPoint& GlobalPos); void moving(const QPoint &GlobalPos);
}; // class AutoHideTab }; // class AutoHideTab
} }
// namespace ads // namespace ads
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#endif #endif