core/Separator.cpp

Go to the documentation of this file.

/*
  This file is part of KDDockWidgets.
 
  SPDX-FileCopyrightText: 2020 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
  Author: Sérgio Martins <sergio.martins@kdab.com>
 
  SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only
 
  Contact KDAB at <info@kdab.com> for commercial licensing options.
*/
 
#include "Separator.h"
#include "layouting/Item_p.h"
#include "layouting/LayoutingSeparator_p.h"
#include "View.h"
#include "Logging_p.h"
#include "Layout.h"
#include "Config.h"
#include "Platform.h"
#include "Controller.h"
#include "core/ViewFactory.h"
 
 
#ifdef Q_OS_WIN
#include <Windows.h>
#endif
 
using namespace KDDockWidgets;
using namespace KDDockWidgets::Core;
 
static int s_numSeparators = 0;
 
namespace {
 
bool rubberBandIsTopLevel()
{
    return KDDockWidgets::Config::self().internalFlags()
        & KDDockWidgets::Config::InternalFlag_TopLevelIndicatorRubberBand;
}
 
}
 
struct Separator::Private : public LayoutingSeparator
{
    // Only set when anchor is moved through mouse. Side1 if going towards left or top, Side2
    // otherwise.
 
    explicit Private(Core::Separator *qq, LayoutingHost *host, Qt::Orientation orientation, Core::ItemBoxContainer *parentContainer)
        : LayoutingSeparator(host, orientation, parentContainer)
        , q(qq)
    {
        s_numSeparators++;
    }
 
    ~Private() override;
 
    Rect geometry() const override
    {
        return m_geometry;
    }
 
    void setGeometry(Rect r) override
    {
        q->setGeometry(r);
    }
 
    void free() override
    {
        delete q;
    }
 
    Core::Separator *const q;
    Rect m_geometry;
    int lazyPosition = 0;
    View *lazyResizeRubberBand = nullptr;
    const bool usesLazyResize = Config::self().flags() & Config::Flag_LazyResize;
};
 
namespace {
Core::View *viewForLayoutingHost(LayoutingHost *host)
{
    // For KDDW, a LayoutingHost is always a Core::Layout
    if (auto layout = Layout::fromLayoutingHost(host))
        return layout->view();
 
    return nullptr;
}
}
 
Separator::Separator(LayoutingHost *host, Qt::Orientation orientation, Core::ItemBoxContainer *parentContainer)
    : Controller(ViewType::Separator, Config::self().viewFactory()->createSeparator(this, viewForLayoutingHost(host)))
    , d(new Private(this, host, orientation, parentContainer))
{
    view()->show();
    view()->init();
    d->lazyResizeRubberBand = d->usesLazyResize ? Config::self().viewFactory()->createRubberBand(
                                  rubberBandIsTopLevel() ? nullptr : view())
                                                : nullptr;
    setVisible(true);
}
 
Separator::~Separator()
{
    delete d;
}
 
bool Separator::isVertical() const
{
    return d->isVertical();
}
 
int Separator::position() const
{
    return d->position();
}
 
void Separator::move(int p)
{
    if (p == position())
        return;
 
    Rect geo = d->m_geometry;
    if (isVertical()) {
        geo.moveTop(p);
    } else {
        geo.moveLeft(p);
    }
    setGeometry(geo);
 
    if (View *v = view()) {
        if (isVertical()) {
            v->move(v->x(), p);
        } else {
            v->move(p, v->y());
        }
    }
}
 
void Separator::setGeometry(Rect r)
{
    if (r == d->m_geometry)
        return;
 
    d->m_geometry = r;
 
    if (View *v = view()) {
        v->setGeometry(r);
    }
 
    setVisible(true);
}
 
// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
void Separator::setGeometry(int pos, int pos2, int length)
{
    d->LayoutingSeparator::setGeometry(pos, pos2, length);
}
 
Qt::Orientation Separator::orientation() const
{
    return d->m_orientation;
}
 
void Separator::setLazyPosition(int pos)
{
    if (pos == d->lazyPosition)
        return;
 
    View *v = view();
 
    d->lazyPosition = pos;
 
    Rect geo = v->geometry();
    if (isVertical()) {
        geo.moveTop(pos);
    } else {
        geo.moveLeft(pos);
    }
 
    if (rubberBandIsTopLevel() && Platform::instance()->isQtWidgets())
        geo.translate(view()->mapToGlobal(Point(0, 0)));
    d->lazyResizeRubberBand->setGeometry(geo);
}
 
bool Separator::usesLazyResize() const
{
    return d->usesLazyResize;
}
 
void Separator::onMousePress()
{
    d->onMousePress();
 
    KDDW_DEBUG("Drag started");
 
    if (d->lazyResizeRubberBand) {
        setLazyPosition(position());
        d->lazyResizeRubberBand->show();
        if (rubberBandIsTopLevel() && Platform::instance()->isQtWidgets())
            d->lazyResizeRubberBand->raise();
    }
}
 
void Separator::onMouseReleased()
{
    if (d->lazyResizeRubberBand) {
        d->lazyResizeRubberBand->hide();
        d->m_parentContainer->requestSeparatorMove(d, d->lazyPosition - position());
    }
 
    d->onMouseRelease();
}
 
void Separator::onMouseDoubleClick()
{
    // a double click means we'll resize the left and right neighbour so that they occupy
    // the same size (or top/bottom, depending on orientation).
    d->m_parentContainer->requestEqualSize(d);
}
 
void Separator::onMouseMove(Point pos)
{
    if (!d->isBeingDragged())
        return;
 
    if (Platform::instance()->isQt()) {
        // Workaround a bug in Qt where we're getting mouse moves without without the button being
        // pressed
        if (!Platform::instance()->isLeftMouseButtonPressed()) {
            KDDW_DEBUG(
                "Separator::onMouseMove: Ignoring spurious mouse event. Someone ate our ReleaseEvent");
            onMouseReleased();
            return;
        }
 
#ifdef KDDW_FRONTEND_QT_WINDOWS
        // Try harder, Qt can be wrong, if mixed with MFC
        const bool mouseButtonIsReallyDown =
            (GetKeyState(VK_LBUTTON) & 0x8000) || (GetKeyState(VK_RBUTTON) & 0x8000);
        if (!mouseButtonIsReallyDown) {
            KDDW_DEBUG(
                "Separator::onMouseMove: Ignoring spurious mouse event. Someone ate our ReleaseEvent");
            onMouseReleased();
            return;
        }
#endif
    }
 
    if (d->lazyResizeRubberBand) {
        const int positionToGoTo = d->onMouseMove(pos, /*moveSeparator=*/false);
        if (positionToGoTo != -1)
            setLazyPosition(positionToGoTo);
    } else {
        d->onMouseMove(pos, /*moveSeparator=*/true);
    }
}
 
Core::ItemBoxContainer *Separator::parentContainer() const
{
    return d->m_parentContainer;
}
 
LayoutingSeparator *Separator::asLayoutingSeparator() const
{
    return d;
}
 
bool Separator::isResizing()
{
    return LayoutingSeparator::s_separatorBeingDragged != nullptr;
}
 
int Separator::numSeparators()
{
    return s_numSeparators;
}
 
Separator::Private::~Private()
{
    s_numSeparators--;
}