385 lines
10 KiB
C++
385 lines
10 KiB
C++
#include "listViewFocusController.h"
|
|
|
|
#include <QQuickItem>
|
|
#include <QQueue>
|
|
#include <QPointF>
|
|
#include <QRectF>
|
|
#include <QQuickWindow>
|
|
|
|
|
|
bool isVisible(QObject* item)
|
|
{
|
|
const auto res = item->property("visible").toBool();
|
|
// qDebug() << "==>> " << (res ? "VISIBLE" : "NOT visible") << item;
|
|
return res;
|
|
}
|
|
|
|
bool isFocusable(QObject* item)
|
|
{
|
|
const auto res = item->property("isFocusable").toBool();
|
|
return res;
|
|
}
|
|
|
|
QPointF getItemCenterPointOnScene(QQuickItem* item)
|
|
{
|
|
const auto x0 = item->x() + (item->width() / 2);
|
|
const auto y0 = item->y() + (item->height() / 2);
|
|
return item->parentItem()->mapToScene(QPointF{x0, y0});
|
|
}
|
|
|
|
bool isLess(QObject* item1, QObject* item2)
|
|
{
|
|
const auto p1 = getItemCenterPointOnScene(qobject_cast<QQuickItem*>(item1));
|
|
const auto p2 = getItemCenterPointOnScene(qobject_cast<QQuickItem*>(item2));
|
|
return (p1.y() == p2.y()) ? (p1.x() < p2.x()) : (p1.y() < p2.y());
|
|
}
|
|
|
|
bool isMore(QObject* item1, QObject* item2)
|
|
{
|
|
return !isLess(item1, item2);
|
|
}
|
|
|
|
bool isListView(QObject* item)
|
|
{
|
|
return item->inherits("QQuickListView");
|
|
}
|
|
|
|
bool isOnTheScene(QObject* object)
|
|
{
|
|
QQuickItem* item = qobject_cast<QQuickItem*>(object);
|
|
if (!item) {
|
|
qWarning() << "Couldn't recognize object as item";
|
|
return false;
|
|
}
|
|
|
|
if (!item->isVisible()) {
|
|
// qDebug() << "===>> The item is not visible: " << item;
|
|
return false;
|
|
}
|
|
|
|
QRectF itemRect = item->mapRectToScene(item->childrenRect());
|
|
|
|
QQuickWindow* window = item->window();
|
|
if (!window) {
|
|
qWarning() << "Couldn't get the window on the Scene check";
|
|
return false;
|
|
}
|
|
|
|
const auto contentItem = window->contentItem();
|
|
if (!contentItem) {
|
|
qWarning() << "Couldn't get the content item on the Scene check";
|
|
return false;
|
|
}
|
|
QRectF windowRect = contentItem->childrenRect();
|
|
const auto res = (windowRect.contains(itemRect) || isListView(item));
|
|
// qDebug() << (res ? "===>> item is inside the Scene" : "===>> ITEM IS OUTSIDE THE SCENE") << " itemRect: " << itemRect << "; windowRect: " << windowRect;
|
|
return res;
|
|
}
|
|
|
|
bool isEnabled(QObject* obj)
|
|
{
|
|
const auto item = qobject_cast<QQuickItem*>(obj);
|
|
return item && item->isEnabled();
|
|
}
|
|
|
|
QList<QObject*> getSubChain(QObject* object)
|
|
{
|
|
QList<QObject*> res;
|
|
if (!object) {
|
|
qDebug() << "The object is NULL";
|
|
return res;
|
|
}
|
|
|
|
const auto children = object->children();
|
|
|
|
for(const auto child : children) {
|
|
if (child
|
|
&& isFocusable(child)
|
|
&& isOnTheScene(child)
|
|
&& isEnabled(child)
|
|
) {
|
|
res.append(child);
|
|
} else {
|
|
res.append(getSubChain(child));
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void printItems(const QList<QObject*>& items, QObject* current_item)
|
|
{
|
|
for(const auto& item : items) {
|
|
QQuickItem* i = qobject_cast<QQuickItem*>(item);
|
|
QPointF coords {getItemCenterPointOnScene(i)};
|
|
QString prefix = current_item == i ? "==>" : " ";
|
|
qDebug() << prefix << " Item: " << i << " with coords: " << coords;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ListViewFocusController::ListViewFocusController(QQuickItem* listView, QObject* parent)
|
|
: QObject{parent}
|
|
, m_listView{listView}
|
|
, m_focusChain{}
|
|
, m_currentSection{Section::Default}
|
|
, m_header{nullptr}
|
|
, m_footer{nullptr}
|
|
, m_focusedItem{nullptr}
|
|
, m_focusedItemIndex{-1}
|
|
, m_delegateIndex{0}
|
|
, m_isReturnNeeded{false}
|
|
, m_currentSectionString {"Default", "Header", "Delegate", "Footer"}
|
|
{
|
|
QVariant headerItemProperty = m_listView->property("headerItem");
|
|
m_header = headerItemProperty.canConvert<QQuickItem*>() ? headerItemProperty.value<QQuickItem*>() : nullptr;
|
|
|
|
QVariant footerItemProperty = m_listView->property("footerItem");
|
|
m_footer = footerItemProperty.canConvert<QQuickItem*>() ? footerItemProperty.value<QQuickItem*>() : nullptr;
|
|
}
|
|
|
|
ListViewFocusController::~ListViewFocusController()
|
|
{
|
|
|
|
}
|
|
|
|
void ListViewFocusController::viewAtCurrentIndex()
|
|
{
|
|
switch(m_currentSection) {
|
|
case Section::Default:
|
|
case Section::Header: {
|
|
QMetaObject::invokeMethod(m_listView, "positionViewAtBeginning");
|
|
break;
|
|
}
|
|
case Section::Delegate: {
|
|
QMetaObject::invokeMethod(m_listView, "positionViewAtIndex",
|
|
Q_ARG(int, m_delegateIndex), // Index
|
|
Q_ARG(int, 2)); // PositionMode (0 = Visible)
|
|
break;
|
|
}
|
|
case Section::Footer: {
|
|
QMetaObject::invokeMethod(m_listView, "positionViewAtEnd");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
int ListViewFocusController::size() const
|
|
{
|
|
return m_listView->property("count").toInt();
|
|
}
|
|
|
|
int ListViewFocusController::currentIndex() const
|
|
{
|
|
return m_delegateIndex;
|
|
}
|
|
|
|
void ListViewFocusController::nextElement()
|
|
{
|
|
qDebug() << "===>> Current section: " << m_currentSectionString.at(static_cast<qsizetype>(m_currentSection));
|
|
switch(m_currentSection) {
|
|
case Section::Default: {
|
|
if(m_header) {
|
|
m_currentSection = Section::Header;
|
|
break;
|
|
}
|
|
}
|
|
case Section::Header: {
|
|
if (size() > 0) {
|
|
m_currentSection = Section::Delegate;
|
|
break;
|
|
}
|
|
}
|
|
case Section::Delegate:
|
|
if (m_delegateIndex < (size() - 1)) {
|
|
m_delegateIndex++;
|
|
break;
|
|
} else if (m_footer) {
|
|
m_currentSection = Section::Footer;
|
|
break;
|
|
}
|
|
case Section::Footer: {
|
|
m_isReturnNeeded = true;
|
|
m_currentSection = Section::Default;
|
|
break;
|
|
}
|
|
default: {
|
|
qCritical() << "Current section is invalid!";
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void ListViewFocusController::previousElement()
|
|
{
|
|
switch(m_currentSection) {
|
|
case Section::Default: {
|
|
if(m_footer) {
|
|
m_currentSection = Section::Footer;
|
|
break;
|
|
}
|
|
}
|
|
case Section::Footer: {
|
|
if (size() > 0) {
|
|
m_currentSection = Section::Delegate;
|
|
m_focusedItemIndex = size() - 1; // workarount to default value == -1
|
|
break;
|
|
}
|
|
}
|
|
case Section::Delegate: {
|
|
if (m_delegateIndex > 0) {
|
|
m_delegateIndex--;
|
|
break;
|
|
} else if (m_header) {
|
|
m_currentSection = Section::Header;
|
|
break;
|
|
}
|
|
}
|
|
case Section::Header: {
|
|
m_isReturnNeeded = true;
|
|
m_currentSection = Section::Default;
|
|
break;
|
|
}
|
|
default: {
|
|
qCritical() << "Current section is invalid!";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ListViewFocusController::decrementIndex()
|
|
{
|
|
m_delegateIndex--;
|
|
}
|
|
|
|
QQuickItem* ListViewFocusController::itemAtIndex(const int index)
|
|
{
|
|
QQuickItem* item{nullptr};
|
|
|
|
QMetaObject::invokeMethod(m_listView, "itemAtIndex",
|
|
Q_RETURN_ARG(QQuickItem*, item),
|
|
Q_ARG(int, index));
|
|
|
|
return item;
|
|
}
|
|
|
|
QQuickItem* ListViewFocusController::currentDelegate()
|
|
{
|
|
QQuickItem* result{nullptr};
|
|
|
|
switch(m_currentSection) {
|
|
case Section::Default: {
|
|
qWarning() << "No elements...";
|
|
break;
|
|
}
|
|
case Section::Header: {
|
|
result = m_header;
|
|
break;
|
|
}
|
|
case Section::Delegate: {
|
|
result = itemAtIndex(m_delegateIndex);
|
|
break;
|
|
}
|
|
case Section::Footer: {
|
|
result = m_footer;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
QQuickItem* ListViewFocusController::focusedItem()
|
|
{
|
|
return m_focusedItem;
|
|
}
|
|
|
|
void ListViewFocusController::focusNextItem()
|
|
{
|
|
if (m_isReturnNeeded) {
|
|
return;
|
|
}
|
|
|
|
if (m_focusChain.empty()) {
|
|
qDebug() << "Empty focusChain with current delegate: " << currentDelegate() << "Scanning for elements...";
|
|
m_focusChain = getSubChain(currentDelegate());
|
|
}
|
|
if (m_focusChain.empty()) {
|
|
qWarning() << "No elements found. Returning from ListView...";
|
|
nextElement();
|
|
focusNextItem();
|
|
return;
|
|
}
|
|
m_focusedItemIndex++;
|
|
m_focusedItem = qobject_cast<QQuickItem*>(m_focusChain.at(m_focusedItemIndex));
|
|
qDebug() << "==>> Focused Item: " << m_focusedItem << " with Index: " << m_focusedItemIndex;
|
|
m_focusedItem->forceActiveFocus();
|
|
}
|
|
|
|
void ListViewFocusController::focusPreviousItem()
|
|
{
|
|
if (m_isReturnNeeded) {
|
|
return;
|
|
}
|
|
|
|
if (m_focusChain.empty()) {
|
|
qDebug() << "Empty focusChain with current delegate: " << currentDelegate() << "Scanning for elements...";
|
|
m_focusChain = getSubChain(currentDelegate());
|
|
}
|
|
if (m_focusChain.empty()) {
|
|
qWarning() << "No elements found. Returning from ListView...";
|
|
previousElement();
|
|
focusPreviousItem();
|
|
return;
|
|
}
|
|
m_focusedItemIndex--;
|
|
m_focusedItem = qobject_cast<QQuickItem*>(m_focusChain.at(m_focusedItemIndex));
|
|
qDebug() << "==>> Focused Item: " << m_focusedItem << " with Index: " << m_focusedItemIndex;
|
|
m_focusedItem->forceActiveFocus();
|
|
}
|
|
|
|
void ListViewFocusController::resetFocusChain()
|
|
{
|
|
m_focusChain.clear();
|
|
m_focusedItem = nullptr;
|
|
m_focusedItemIndex = -1;
|
|
}
|
|
|
|
bool ListViewFocusController::isFirstFocusItemInDelegate()
|
|
{
|
|
return m_focusedItem && (m_focusedItem == m_focusChain.first());
|
|
}
|
|
|
|
bool ListViewFocusController::isLastFocusItemInDelegate()
|
|
{
|
|
return m_focusedItem && (m_focusedItem == m_focusChain.last());
|
|
}
|
|
|
|
bool ListViewFocusController::isFirstFocusItemInListView()
|
|
{
|
|
return (m_delegateIndex == 0) && isFirstFocusItemInDelegate();
|
|
}
|
|
|
|
bool ListViewFocusController::isLastFocusItemInListView()
|
|
{
|
|
bool isLastSection = (m_footer && m_currentSection == Section::Footer)
|
|
|| (!m_footer && (m_currentSection == Section::Delegate) && (m_delegateIndex == size() - 1))
|
|
|| (m_header && (m_currentSection == Section::Header) && (size() <= 0) && !m_footer);
|
|
return isLastSection && isLastFocusItemInDelegate();
|
|
}
|
|
|
|
bool ListViewFocusController::isReturnNeeded()
|
|
{
|
|
return m_isReturnNeeded;
|
|
}
|
|
|
|
void ListViewFocusController::viewToBegin()
|
|
{
|
|
QMetaObject::invokeMethod(m_listView, "positionViewAtBeginning", Qt::AutoConnection);
|
|
}
|
|
|
|
void ListViewFocusController::viewToEnd()
|
|
{
|
|
QMetaObject::invokeMethod(m_listView, "positionViewAtEnd", Qt::AutoConnection);
|
|
}
|