KoToolBoxDocker Class Reference

#include <KoToolBoxDocker_p.h>

Inheritance diagram for KoToolBoxDocker:

Public Member Functions
	KoToolBoxDocker (KoToolBox *toolBox)
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
	reimplemented from KoCanvasObserverBase
void	setViewManager (KisViewManager *viewManager) override
	reimplemented from KisMainwindowObserver
void	unsetCanvas () override
Public Member Functions inherited from KisMainwindowObserver
	KisMainwindowObserver ()
	~KisMainwindowObserver () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Protected Slots
void	updateFloating (bool)
void	updateToolBoxOrientation (Qt::DockWidgetArea)

Protected Member Functions
void	contextMenuEvent (QContextMenuEvent *event) override
void	resizeEvent (QResizeEvent *event) override

Private Types
enum	Orientation { Horizontal = Qt::Horizontal , Vertical = Qt::Vertical , Auto = -1 }

Private Member Functions
void	changeCompact (bool)
void	changeLayoutDir (Qt::LayoutDirection)
void	changeOrientation (Orientation)
void	setToolBoxOrientation (Qt::Orientation)
void	updateLayoutDir ()

Private Attributes
QMenu *	m_contextMenu {nullptr}
Qt::DockWidgetArea	m_dockArea {Qt::NoDockWidgetArea}
Qt::LayoutDirection	m_layoutDir {Qt::LayoutDirectionAuto}
Orientation	m_orientation {Auto}
KoToolBoxScrollArea *	m_scrollArea
KoToolBox *	m_toolBox

Detailed Description

Definition at line 23 of file KoToolBoxDocker_p.h.

Member Enumeration Documentation

Orientation

enum KoToolBoxDocker::Orientation

private

Enumerator
Horizontal
Vertical
Auto

Definition at line 45 of file KoToolBoxDocker_p.h.

                     {
        Horizontal = Qt::Horizontal,
        Vertical = Qt::Vertical,
        Auto = -1,
    };

Constructor & Destructor Documentation

KoToolBoxDocker()

KoToolBoxDocker::KoToolBoxDocker ( KoToolBox * toolBox )

explicit

Definition at line 25 of file KoToolBoxDocker.cpp.

    : QDockWidget(i18n("Toolbox"))
    , m_toolBox(toolBox)
    , m_scrollArea(new KoToolBoxScrollArea(toolBox, this))
{
    setWidget(m_scrollArea);
 
    QLabel *w = new QLabel(" ", this);
    w->setFrameShape(QFrame::StyledPanel);
    w->setFrameShadow(QFrame::Raised);
    w->setFrameStyle(QFrame::Panel | QFrame::Raised);
    QFont font = qApp->font();
    // Font size may be in pixels (on Android) or points (everywhere else.)
    qreal ratio = 0.9;
    if (font.pixelSize() == -1) {
        font.setPointSizeF(font.pointSizeF() * ratio);
    } else {
        font.setPixelSize(qRound(font.pixelSize() * ratio));
    }
    int titleSize = QFontMetrics(font).height();
    w->setMinimumSize(titleSize, titleSize);
    setTitleBarWidget(w);
 
    KConfigGroup cfg =  KSharedConfig::openConfig()->group("KoToolBox");
    const int layoutDirUnchecked = cfg.readEntry<int>("layoutDir", Qt::LayoutDirectionAuto);
    switch (layoutDirUnchecked) {
    case Qt::LayoutDirectionAuto:
    case Qt::LeftToRight:
    case Qt::RightToLeft:
        m_layoutDir = static_cast<Qt::LayoutDirection>(layoutDirUnchecked);
        break;
    default:
        m_layoutDir = Qt::LayoutDirectionAuto;
        break;
    }
    updateLayoutDir();
 
    const int orientUnchecked = cfg.readEntry<int>("orientation", Auto);
    switch (orientUnchecked) {
    case Horizontal:
    case Vertical:
    case Auto:
        m_orientation = static_cast<Orientation>(orientUnchecked);
        break;
    default:
        m_orientation = Auto;
        break;
    }
    if (m_orientation != Auto) {
        setToolBoxOrientation(static_cast<Qt::Orientation>(m_orientation));
    }
 
    connect(this, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)),
            this, SLOT(updateToolBoxOrientation(Qt::DockWidgetArea)));
    connect(this, SIGNAL(topLevelChanged(bool)),
            this, SLOT(updateFloating(bool)));
}

References Auto, Horizontal, m_layoutDir, m_orientation, m_scrollArea, setToolBoxOrientation(), updateFloating(), updateLayoutDir(), updateToolBoxOrientation(), and Vertical.

Member Function Documentation

changeCompact()

void KoToolBoxDocker::changeCompact ( bool state )

private

Definition at line 152 of file KoToolBoxDocker.cpp.

{
    KConfigGroup cfg = KSharedConfig::openConfig()->group("KoToolBox");
    cfg.writeEntry<bool>("compact", state);
    m_scrollArea->setCompact(state);
}

References m_scrollArea, and KoToolBoxScrollArea::setCompact().

changeLayoutDir()

void KoToolBoxDocker::changeLayoutDir ( Qt::LayoutDirection dir )

private

Definition at line 129 of file KoToolBoxDocker.cpp.

{
    KConfigGroup cfg = KSharedConfig::openConfig()->group("KoToolBox");
    cfg.writeEntry<int>("layoutDir", dir);
    m_layoutDir = dir;
    updateLayoutDir();
}

References m_layoutDir, and updateLayoutDir().

changeOrientation()

void KoToolBoxDocker::changeOrientation ( Orientation orientation )

private

Definition at line 137 of file KoToolBoxDocker.cpp.

{
    if (m_orientation == orientation) {
        return;
    }
    KConfigGroup cfg = KSharedConfig::openConfig()->group("KoToolBox");
    cfg.writeEntry<int>("orientation", orientation);
    m_orientation = orientation;
    if (m_orientation == Auto) {
        setToolBoxOrientation(width() > height() ? Qt::Horizontal : Qt::Vertical);
    } else {
        setToolBoxOrientation(static_cast<Qt::Orientation>(m_orientation));
    }
}

References Auto, m_orientation, and setToolBoxOrientation().

contextMenuEvent()

void KoToolBoxDocker::contextMenuEvent ( QContextMenuEvent * event )

overrideprotected

Definition at line 178 of file KoToolBoxDocker.cpp.

{
    if (!m_contextMenu) {
        m_contextMenu = new QMenu(this);
 
        QAction *compact = m_contextMenu->addAction(i18n("Compact"));
        compact->setCheckable(true);
        compact->setChecked(m_toolBox->isCompact());
        connect(compact, &QAction::triggered, this, &KoToolBoxDocker::changeCompact);
 
        m_contextMenu->addSection(i18n("Icon Size"));
        m_toolBox->setupIconSizeMenu(m_contextMenu);
 
        m_contextMenu->addSection(i18nc("Toolbox layout", "Layout"));
        QActionGroup *layoutActionGroup = new QActionGroup(m_contextMenu);
 
        QAction *layoutAuto = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox layout direction", "&Automatic"));
        layoutAuto->setActionGroup(layoutActionGroup);
        layoutAuto->setCheckable(true);
        connect(layoutAuto, &QAction::triggered, this, [this]() {
            changeLayoutDir(Qt::LayoutDirectionAuto);
        });
 
        QAction *layoutLtr = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox layout direction", "&Left-to-right"));
        layoutLtr->setActionGroup(layoutActionGroup);
        layoutLtr->setCheckable(true);
        connect(layoutLtr, &QAction::triggered, this, [this]() {
            changeLayoutDir(Qt::LeftToRight);
        });
 
        QAction *layoutRtl = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox layout direction", "&Right-to-left"));
        layoutRtl->setActionGroup(layoutActionGroup);
        layoutRtl->setCheckable(true);
        connect(layoutRtl, &QAction::triggered, this, [this]() {
            changeLayoutDir(Qt::RightToLeft);
        });
 
        switch (m_layoutDir) {
        case Qt::LayoutDirectionAuto:
            layoutAuto->setChecked(true);
            break;
        case Qt::LeftToRight:
            layoutLtr->setChecked(true);
            break;
        case Qt::RightToLeft:
            layoutRtl->setChecked(true);
            break;
        }
 
        m_contextMenu->addSection(i18nc("Toolbox orientation", "Orientation"));
        QActionGroup *orientActionGroup = new QActionGroup(m_contextMenu);
 
        QAction *orientAuto = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox orientation", "&Automatic"));
        orientAuto->setActionGroup(orientActionGroup);
        orientAuto->setCheckable(true);
        connect(orientAuto, &QAction::triggered, this, [this]() {
            changeOrientation(Auto);
        });
 
        QAction *orientHorizontal = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox orientation", "&Horizontal"));
        orientHorizontal->setActionGroup(orientActionGroup);
        orientHorizontal->setCheckable(true);
        connect(orientHorizontal, &QAction::triggered, this, [this]() {
            changeOrientation(Horizontal);
        });
 
        QAction *orientVertical = m_contextMenu->addAction(i18nc("@item:inmenu Toolbox orientation", "&Vertical"));
        orientVertical->setActionGroup(orientActionGroup);
        orientVertical->setCheckable(true);
        connect(orientVertical, &QAction::triggered, this, [this]() {
            changeOrientation(Vertical);
        });
 
        switch (m_orientation) {
        case Horizontal:
            orientHorizontal->setChecked(true);
            break;
        case Vertical:
            orientVertical->setChecked(true);
            break;
        case Auto:
            orientAuto->setChecked(true);
            break;
        }
    }
 
    m_contextMenu->exec(event->globalPos());
}

References Auto, changeCompact(), changeLayoutDir(), changeOrientation(), Horizontal, KoToolBox::isCompact(), m_contextMenu, m_layoutDir, m_orientation, m_toolBox, KoToolBox::setupIconSizeMenu(), and Vertical.

observerName()

QString KoToolBoxDocker::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 32 of file KoToolBoxDocker_p.h.

{ return "KoToolBoxDocker"; }

resizeEvent()

void KoToolBoxDocker::resizeEvent ( QResizeEvent * event )

overrideprotected

Definition at line 97 of file KoToolBoxDocker.cpp.

{
    QDockWidget::resizeEvent(event);
    if (m_orientation == Auto) {
        setToolBoxOrientation(width() > height() ? Qt::Horizontal : Qt::Vertical);
    }
}

References Auto, m_orientation, and setToolBoxOrientation().

setCanvas()

void KoToolBoxDocker::setCanvas ( KoCanvasBase * canvas )

overridevirtual

reimplemented from KoCanvasObserverBase

Implements KoCanvasObserverBase.

Definition at line 83 of file KoToolBoxDocker.cpp.

{
    Q_UNUSED(canvas);
}

setToolBoxOrientation()

void KoToolBoxDocker::setToolBoxOrientation ( Qt::Orientation orientation )

private

Definition at line 159 of file KoToolBoxDocker.cpp.

{
    if (m_scrollArea->orientation() == orientation) {
        return;
    }
    if (orientation == Qt::Horizontal) {
        setFeatures(features() | QDockWidget::DockWidgetVerticalTitleBar);
        m_scrollArea->setOrientation(Qt::Horizontal);
    } else {
        setFeatures(features() & ~QDockWidget::DockWidgetVerticalTitleBar);
        m_scrollArea->setOrientation(Qt::Vertical);
    }
}

References m_scrollArea, KoToolBoxScrollArea::orientation(), and KoToolBoxScrollArea::setOrientation().

setViewManager()

void KoToolBoxDocker::setViewManager ( KisViewManager * viewManager )

overridevirtual

reimplemented from KisMainwindowObserver

Implements KisMainwindowObserver.

Definition at line 92 of file KoToolBoxDocker.cpp.

{
    m_toolBox->setViewManager(viewManager);
}

References m_toolBox, and KoToolBox::setViewManager().

unsetCanvas()

void KoToolBoxDocker::unsetCanvas ( )

overridevirtual

Re-implement to notify the observer that its canvas is no longer among the living. The daisies, it is pushing up. This means you don't have to disconnect, it's dead.

The old canvas should be deleted already, so if you stored a pointer to it, don't touch!

Note that currently there is a bug where in certain specific circumstances unsetCanvas can be called when it shouldn't, see for example KWStatisticsDocker for a workaround for this problem.

Implements KoCanvasObserverBase.

Definition at line 88 of file KoToolBoxDocker.cpp.

{
}

updateFloating

void KoToolBoxDocker::updateFloating ( bool v )

protectedslot

Definition at line 173 of file KoToolBoxDocker.cpp.

{
    m_toolBox->setFloating(v);
}

References m_toolBox, KoToolBox::setFloating(), and v.

updateLayoutDir()

void KoToolBoxDocker::updateLayoutDir ( )

private

Definition at line 114 of file KoToolBoxDocker.cpp.

{
    if (m_layoutDir == Qt::LayoutDirectionAuto) {
        if (m_dockArea == Qt::RightDockWidgetArea) {
            m_scrollArea->setLayoutDirection(Qt::RightToLeft);
        } else if (m_dockArea == Qt::LeftDockWidgetArea) {
            m_scrollArea->setLayoutDirection(Qt::LeftToRight);
        } else {
            m_scrollArea->unsetLayoutDirection();
        }
    } else {
        m_scrollArea->setLayoutDirection(m_layoutDir);
    }
}

References m_dockArea, m_layoutDir, and m_scrollArea.

updateToolBoxOrientation

void KoToolBoxDocker::updateToolBoxOrientation ( Qt::DockWidgetArea area )

protectedslot

Definition at line 105 of file KoToolBoxDocker.cpp.

{
    m_dockArea = area;
    updateLayoutDir();
    if (m_orientation == Auto) {
        setToolBoxOrientation(width() > height() ? Qt::Horizontal : Qt::Vertical);
    }
}

References Auto, m_dockArea, m_orientation, setToolBoxOrientation(), and updateLayoutDir().

Member Data Documentation

m_contextMenu

QMenu* KoToolBoxDocker::m_contextMenu {nullptr}

private

Definition at line 60 of file KoToolBoxDocker_p.h.

{nullptr};

m_dockArea

Qt::DockWidgetArea KoToolBoxDocker::m_dockArea {Qt::NoDockWidgetArea}

private

Definition at line 61 of file KoToolBoxDocker_p.h.

{Qt::NoDockWidgetArea};

m_layoutDir

Qt::LayoutDirection KoToolBoxDocker::m_layoutDir {Qt::LayoutDirectionAuto}

private

Definition at line 62 of file KoToolBoxDocker_p.h.

{Qt::LayoutDirectionAuto};

m_orientation

Orientation KoToolBoxDocker::m_orientation {Auto}

private

Definition at line 63 of file KoToolBoxDocker_p.h.

{Auto};

m_scrollArea

KoToolBoxScrollArea* KoToolBoxDocker::m_scrollArea

private

Definition at line 59 of file KoToolBoxDocker_p.h.

m_toolBox

KoToolBox* KoToolBoxDocker::m_toolBox

private

Definition at line 58 of file KoToolBoxDocker_p.h.

---

The documentation for this class was generated from the following files:

• libs/ui/toolbox/KoToolBoxDocker_p.h
• libs/ui/toolbox/KoToolBoxDocker.cpp