Initial commit of BudgetPro

qmtreeview.cpp

@@ -0,0 +1,655 @@
+#include "qmtreeview.h"
+
+#include <QPen>
+#include <QPainter>
+#include <QStyleOptionFrame>
+#include <QHeaderView>
+#include <QPushButton>
+#include <QtEvents>
+#include <QMenu>
+#include <QMimeData>
+// Implementation
+
+#include <QDebug>
+
+#include "treemodel.h"
+
+
+QMTreeView::QMTreeView(QWidget *parent):
+    QTreeView(parent)
+{
+    header()->setFixedHeight(30);
+    QPushButton * cornerbutton = new QPushButton(this);
+    setCornerWidget(cornerbutton);
+    connect(cornerbutton, &QPushButton::released, this, &QMTreeView::onCornerButtonRelease);
+
+    setLineWidth(1);
+    setAlternatingRowColors(false);
+
+    setAcceptDrops(true);  // Habilita el drop
+    setDropIndicatorShown(true);
+    setTreePosition(0);
+
+    return;
+    setStyleSheet("QHeaderView::section:horizontal {"
+                        "background-color: qlineargradient(spread:reflect,"
+                        "x1:0, y1:0, x2:0, y2:1,"
+                        "stop:0 rgba(255, 255, 255, 255),"
+                        "stop:1 rgba(164, 164, 164, 255));"
+                        "border: 1px solid rgb(153, 153, 153);"
+                        "border-width: 0 1px 1px 0;"
+                        "}"
+                        "QTreeView::item {"
+                        "border-bottom: 0.5px solid lightgray;"
+                        "selection-color: black;"
+                        "}"
+                        "QTreeView::item:selected { /*被选中的index*/"
+                        "background: qlineargradient("
+                        "x1: 0, y1: 0, x2: 0, y2: 1,"
+                        "stop: 0 #FAFBFE,"
+                        "stop: 1 #DCDEF1);"
+                        "}"
+                        "QTreeView::branch {"
+                        "background: yellow;"
+                        "}"
+                        "QTreeView::branch:has-siblings:!adjoins-item {"
+                        "background: cyan;"
+                        "}"
+                        "QTreeView::branch:has-siblings:adjoins-item {"
+                        "background: red;"
+                        "}"
+                        "QTreeView::branch:!has-children:!has-siblings:adjoins-item {"
+                        "background: blue;"
+                        "}"
+                        "QTreeView::branch:closed:has-children:has-siblings {"
+                        "background: black;"
+                        "}"
+                        "QTreeView::branch:has-children:!has-siblings:closed {"
+                        "background: gray;"
+                        "}"
+                        "QTreeView::branch:open:has-children:has-siblings {"
+                        "background: magenta;"
+                        "}"
+                        "QTreeView::branch:open:has-children:!has-siblings {"
+                        "background: green;}");
+}
+
+void QMTreeView::resizeEvent(QResizeEvent *event)
+{
+    QTreeView::resizeEvent(event);
+}
+
+
+/*
+void QMTreeView::drawTree(QPainter *painter, const QRegion &region) const
+{
+    QTreeView::drawTree(painter, region);
+    return;
+
+    if (model() && model()->rowCount() > 0)
+    {
+        QTreeView::drawTree(painter, region);
+    }
+    else
+    {
+        // If no items draw a text in the center of the viewport.
+        QPainter painter(viewport());
+        QString text(tr("There are no elements in this view"));
+        QRect textRect = painter.fontMetrics().boundingRect(text);
+        textRect.moveCenter(viewport()->rect().center());
+        painter.drawText(textRect, Qt::AlignCenter, text);
+    }
+
+*/
+    /*
+    Q_D(const QTreeView);
+    const QVector<QTreeViewItem> viewItems = d->viewItems;
+
+    QStyleOptionViewItem option = d->viewOptionsV1();
+    const QStyle::State state = option.state;
+    d->current = 0;
+
+    if (viewItems.count() == 0 || d->header->count() == 0 || !d->itemDelegate) {
+        d->paintAlternatingRowColors(painter, &option, 0, region.boundingRect().bottom()+1);
+        return;
+    }
+
+    int firstVisibleItemOffset = 0;
+    const int firstVisibleItem = d->firstVisibleItem(&firstVisibleItemOffset);
+    if (firstVisibleItem < 0) {
+        d->paintAlternatingRowColors(painter, &option, 0, region.boundingRect().bottom()+1);
+        return;
+    }
+
+    const int viewportWidth = d->viewport->width();
+
+    QPoint hoverPos = d->viewport->mapFromGlobal(QCursor::pos());
+    d->hoverBranch = d->itemDecorationAt(hoverPos);
+
+    QVector<int> drawn;
+    bool multipleRects = (region.rectCount() > 1);
+    for (const QRect &a : region) {
+        const QRect area = (multipleRects
+                            ? QRect(0, a.y(), viewportWidth, a.height())
+                            : a);
+        d->leftAndRight = d->startAndEndColumns(area);
+
+        int i = firstVisibleItem; // the first item at the top of the viewport
+        int y = firstVisibleItemOffset; // we may only see part of the first item
+
+        // start at the top of the viewport  and iterate down to the update area
+        for (; i < viewItems.count(); ++i) {
+            const int itemHeight = d->itemHeight(i);
+            if (y + itemHeight > area.top())
+                break;
+            y += itemHeight;
+        }
+
+        // paint the visible rows
+        for (; i < viewItems.count() && y <= area.bottom(); ++i) {
+            const int itemHeight = d->itemHeight(i);
+            option.rect.setRect(0, y, viewportWidth, itemHeight);
+            option.state = state | (viewItems.at(i).expanded ? QStyle::State_Open : QStyle::State_None)
+                                 | (viewItems.at(i).hasChildren ? QStyle::State_Children : QStyle::State_None)
+                                 | (viewItems.at(i).hasMoreSiblings ? QStyle::State_Sibling : QStyle::State_None);
+            d->current = i;
+            d->spanning = viewItems.at(i).spanning;
+            if (!multipleRects || !drawn.contains(i)) {
+                drawRow(painter, option, viewItems.at(i).index);
+                if (multipleRects)   // even if the rect only intersects the item,
+                    drawn.append(i); // the entire item will be painted
+            }
+            y += itemHeight;
+        }
+
+        if (y <= area.bottom()) {
+            d->current = i;
+            d->paintAlternatingRowColors(painter, &option, y, area.bottom());
+        }
+    }
+    */
+//}
+
+void QMTreeView::drawRow(QPainter * painter, const QStyleOptionViewItem & options, const QModelIndex & index) const
+{
+    QTreeView::drawRow(painter, options, index);
+    //return;
+
+    int m_iWidth = 1;
+    QColor m_gridLineColor = QColor(200, 200, 200);
+
+    QPen pen;
+    pen.setWidth(m_iWidth);
+    pen.setColor(m_gridLineColor);
+
+    QBrush brush;
+    brush.setColor(QColor(0,0,0,0));
+
+    painter->save();
+    painter->setPen(pen);
+    painter->setBrush(brush);
+    painter->drawRect(options.rect);
+    painter->restore();
+}
+
+void QMTreeView::drawBranches(QPainter *painter, const QRect &rect, const QModelIndex &index) const
+{
+    if (!index.isValid()) {
+        QTreeView::drawBranches(painter, rect, index);
+        return;
+    }
+
+    // Calcula el ancho del branch basado en el nivel de profundidad
+    int depth = 0;
+    QModelIndex parentIndex = index.parent();
+    while (parentIndex.isValid()) {
+        ++depth;
+        parentIndex = parentIndex.parent();
+    }
+
+    // Calcula el ancho del branch
+    int branchWidth = depth * indentation();
+
+    // Dibuja el rectángulo del branch
+    QRect branchRect(rect.left(), rect.top(), branchWidth, rect.height());
+    painter->save();
+    painter->setBrush(Qt::yellow);  // Cambia el color según prefieras
+    painter->setPen(Qt::NoPen);    // Sin bordes
+    painter->drawRect(branchRect);
+    painter->restore();
+
+    // Llama al método base para que Qt dibuje el resto
+    QTreeView::drawBranches(painter, rect, index);
+    return;
+
+
+    QTreeView::drawBranches(painter, rect, index);
+    //return;
+
+    //int m_iWidth = 1;
+    QColor m_gridLineColor = QColor(200, 200, 200);
+
+    QPen pen;
+    //pen.setWidth(m_iWidth);
+    pen.setColor(m_gridLineColor);
+
+    QBrush brush;
+    brush.setColor(QColor(0,0,0,0));
+
+    //painter->save();
+    painter->setPen(pen);
+    painter->setBrush(brush);
+    painter->drawRect(rect);
+    //painter->restore();
+
+    //const QTreeViewItem &viewItem = d->viewItems.at(item);
+    //int level = viewItem.level;
+
+
+    //Q_Q(const QMTreeView);
+    /*
+    const bool reverse = isRightToLeft();
+    const int indent = d->indent;
+    const int outer = d->rootDecoration ? 0 : 1;
+    const int item = d->current;
+    const QTreeViewItem &viewItem = d->viewItems.at(item);
+    int level = viewItem.level;
+    QRect primitive(reverse ? rect.left() : rect.right() + 1, rect.top(), indent, rect.height());
+
+    QModelIndex parent = index.parent();
+    QModelIndex current = parent;
+    QModelIndex ancestor = current.parent();
+
+    QStyleOptionViewItem opt = viewOptions();
+    QStyle::State extraFlags = QStyle::State_None;
+    if (isEnabled())
+        extraFlags |= QStyle::State_Enabled;
+    if (hasFocus())
+        extraFlags |= QStyle::State_Active;
+    QPoint oldBO = painter->brushOrigin();
+    if (verticalScrollMode() == QAbstractItemView::ScrollPerPixel)
+        painter->setBrushOrigin(QPoint(0, verticalOffset()));
+
+    if (d->alternatingColors) {
+        opt.features.setFlag(QStyleOptionViewItem::Alternate, d->current & 1);
+    }
+
+    // When hovering over a row, pass State_Hover for painting the branch
+    // indicators if it has the decoration (aka branch) selected.
+    bool hoverRow = selectionBehavior() == QAbstractItemView::SelectRows
+                    && opt.showDecorationSelected
+                    && index.parent() == d->hover.parent()
+                    && index.row() == d->hover.row();
+
+    if (d->selectionModel->isSelected(index))
+        extraFlags |= QStyle::State_Selected;
+
+    if (level >= outer) {
+        // start with the innermost branch
+        primitive.moveLeft(reverse ? primitive.left() : primitive.left() - indent);
+        opt.rect = primitive;
+
+        const bool expanded = viewItem.expanded;
+        const bool children = viewItem.hasChildren;
+        bool moreSiblings = viewItem.hasMoreSiblings;
+
+        opt.state = QStyle::State_Item | extraFlags
+                    | (moreSiblings ? QStyle::State_Sibling : QStyle::State_None)
+                    | (children ? QStyle::State_Children : QStyle::State_None)
+                    | (expanded ? QStyle::State_Open : QStyle::State_None);
+        opt.state.setFlag(QStyle::State_MouseOver, hoverRow || item == d->hoverBranch);
+
+        style()->drawPrimitive(QStyle::PE_IndicatorBranch, &opt, painter, this);
+    }
+    // then go out level by level
+    for (--level; level >= outer; --level) { // we have already drawn the innermost branch
+        primitive.moveLeft(reverse ? primitive.left() + indent : primitive.left() - indent);
+        opt.rect = primitive;
+        opt.state = extraFlags;
+        bool moreSiblings = false;
+        if (d->hiddenIndexes.isEmpty()) {
+            moreSiblings = (d->model->rowCount(ancestor) - 1 > current.row());
+        } else {
+            int successor = item + viewItem.total + 1;
+            while (successor < d->viewItems.size()
+                   && d->viewItems.at(successor).level >= uint(level)) {
+                const QTreeViewItem &successorItem = d->viewItems.at(successor);
+                if (successorItem.level == uint(level)) {
+                    moreSiblings = true;
+                    break;
+                }
+                successor += successorItem.total + 1;
+            }
+        }
+        if (moreSiblings)
+            opt.state |= QStyle::State_Sibling;
+        opt.state.setFlag(QStyle::State_MouseOver, hoverRow || item == d->hoverBranch);
+
+        style()->drawPrimitive(QStyle::PE_IndicatorBranch, &opt, painter, this);
+        current = ancestor;
+        ancestor = current.parent();
+    }
+    painter->setBrushOrigin(oldBO);*/
+}
+
+/*
+int indexRowSizeHint(const QModelIndex &index)
+{
+
+}
+
+int rowHeight(const QModelIndex &index)
+{
+
+}
+*/
+
+void QMTreeView::keyPressEvent(QKeyEvent *e)
+{
+    bool bNextCellOnEnter = true;
+    bool bNextRowOnLastCol = true;
+/*
+        Key_Left = 0x01000012,
+        Key_Up = 0x01000013,
+        Key_Right = 0x01000014,
+        Key_Down = 0x01000015,
+*/
+    if(bNextCellOnEnter && (e->key() == Qt::Key_Return | e->key() == Qt::Key_Enter | e->key() == Qt::Key_Right))
+    {
+        qint32  cr = currentIndex().row(),
+                cc = currentIndex().column(),
+                c  = model()->columnCount();
+
+        QHeaderView *hdr = static_cast<QHeaderView*>(header());
+
+        if(hdr)
+           cc = hdr->visualIndex(cc);
+
+        if(cc + 1 < c)
+        {
+            moveTo(cr, cc + 1);
+
+            if(editTriggers() == QAbstractItemView::AllEditTriggers)
+                edit(currentIndex());
+        }
+        else if(bNextRowOnLastCol)
+        {
+            // TODO: comporbar si tiene hijos y si tiene mover el selector a este.
+
+            if(cr < model()->rowCount() - 1)
+                moveTo(cr + 1, 0);
+            if(editTriggers() == QAbstractItemView::AllEditTriggers)
+                edit(currentIndex());
+        }
+        else
+           QTreeView::keyPressEvent(e);
+    }
+    else if(e->key() == Qt::Key_Left /*&& currentIndex().row() == model()->rowCount() - 1*/)
+    {
+        qint32  cr = currentIndex().row(),
+                cc = currentIndex().column(),
+                c  = model()->columnCount();
+
+        QHeaderView *hdr = static_cast<QHeaderView*>(header());
+
+        if(hdr)
+           cc = hdr->visualIndex(cc);
+
+        if(cc - 1 > -1)
+        {
+            moveTo(cr, cc - 1);
+
+            if(editTriggers() == QAbstractItemView::AllEditTriggers)
+                edit(currentIndex());
+        }
+        /*
+        else if(bNextRowOnLastCol)
+        {
+            // TODO: comporbar si tiene hijos y si tiene mover el selector a este.
+
+            if(cr < model()->rowCount() - 1)
+                moveTo(cr + 1, 0);
+            if(editTriggers() == QAbstractItemView::AllEditTriggers)
+                edit(currentIndex());
+        }
+        */
+        else
+           QTreeView::keyPressEvent(e);
+    }
+    /*
+    else if(e->key() == Qt::Key_Up)
+    {
+        qint32  cr = currentIndex().row(),
+                cc = currentIndex().column(),
+                c  = model()->columnCount();
+
+        if(cr > 0)
+            moveTo(cr - 1, currentIndex().column());
+    }
+    */
+    else if(e->key() == Qt::Key_Down && currentIndex().row() == model()->rowCount() - 1)
+    {
+        addNewRecord(currentIndex());
+
+        //QTreeView::keyPressEvent(e); // quitar esto
+    }
+    /*
+    else if(e->key() == Qt::Key_Down)
+    {
+        qint32  cr = currentIndex().row(),
+                cc = currentIndex().column(),
+                c  = model()->columnCount();
+
+        if(cr < model()->rowCount() - 1)
+            moveTo(cr + 1, currentIndex().column());
+    }
+    */
+    else
+    {
+        QModelIndex c(currentIndex());
+
+        QTreeView::keyPressEvent(e);
+
+        if(c.row() != currentIndex().row() || c.column() != currentIndex().column())
+        {
+            selectionModel()->select(currentIndex(), QItemSelectionModel::Select);
+            selectionModel()->select(c, QItemSelectionModel::Deselect);
+        }
+    }
+}
+
+void QMTreeView::moveTo(int r, int c)
+{
+    QHeaderView *hdr = static_cast<QHeaderView*>(header());
+    if(!hdr)
+        return;
+
+    if(c > hdr->count() - 1)
+        c = hdr->count() - 1;
+
+    if(r > model()->rowCount() - 1)
+        r = model()->rowCount() - 1;
+
+    c = nextVisibleIndex(hdr->logicalIndex(c));
+
+    QModelIndex oi = currentIndex(),
+                ix = model()->index(r, c, oi.parent().isValid() ? oi.parent() : QModelIndex());
+
+    qDebug() << "Pos" << r << ":" << c << "MoveTo" << ix << "IsValid ?" << ix.isValid();
+    if(ix.isValid())
+    {
+        QItemSelection os(currentIndex(), currentIndex());
+
+        setCurrentIndex(ix);
+        selectionModel()->setCurrentIndex(ix, QItemSelectionModel::ClearAndSelect);
+
+        QItemSelection ns(currentIndex(), currentIndex());
+
+        QTreeView::selectionChanged(os, ns);
+
+        qDebug() << "MOveTo" << currentIndex();
+        //emit onPositionChanged(currentRow(), currentColumn());
+    }
+}
+
+int QMTreeView::nextVisibleIndex(int c)
+{
+    QHeaderView *hdr = static_cast<QHeaderView*>(header());
+    if(!hdr)
+        return c;
+
+    if(c > hdr->count() - 1)
+        return nextVisibleIndex(hdr->count() - 1);
+
+    for(int i = c; i < hdr->count() - 1; i++)
+    {
+        if(!hdr->isSectionHidden(i))
+                return i;
+    }
+    return c;
+}
+
+bool QMTreeView::addNewRecord(const QModelIndex &index)
+{
+    if(editTriggers() == QAbstractItemView::NoEditTriggers) // read Only
+        return false;
+
+    insertRow();
+    scrollToBottom();
+    moveTo(model()->rowCount(), nextVisibleIndex(0));
+
+    /*
+    if(!bCanAddRow)
+        return false;
+
+    if(model() && model()->inherits("PBSDataModel"))
+    {
+        PBSDataModel *pModel = static_cast<PBSDataModel*>(model());
+        if(pModel)
+        {
+            int r = currentIndex().row(),
+                c = currentIndex().column();
+
+            if(!pModel->haveEmptyRow())
+            {
+                pModel->insertEmptyRow();
+                emit newRecordAdd();
+
+                resizeRowToContents(pModel->rowCount());
+                scrollToBottom();
+
+                if(bGotoFirstCellOnNewRec)
+                    c = nextVisibleIndex(0);
+                moveTo(pModel->rowCount(), c);
+
+                emit newRecordAdd();
+            }
+        }
+    }
+    else
+    {
+        model()->insertRow(model()->rowCount(QModelIndex()));
+        model()->submit();
+    }
+    */
+    return true;
+}
+
+void QMTreeView::insertChild()
+{
+    QModelIndex selindex = selectionModel()->currentIndex();
+    QAbstractItemModel *treemodel = model();
+
+    if (treemodel->columnCount(selindex) == 0)
+    {
+        if (!treemodel->insertColumn(0, selindex))
+            return;
+    }
+
+    if (!treemodel->insertRow(0, treemodel->index(selindex.row(), 0, selindex.parent())))
+        return;
+
+    /*
+    for (int column = 0; column < treemodel->columnCount(selindex); ++column)
+    {
+        QModelIndex child = treemodel->index(0, column, selindex);
+        treemodel->setData(child, QVariant(""), Qt::EditRole);
+        if (!treemodel->headerData(column, Qt::Horizontal).isValid())
+            treemodel->setHeaderData(column, Qt::Horizontal, QVariant("[No header]"), Qt::EditRole);
+    }
+    */
+
+    selectionModel()->setCurrentIndex(treemodel->index(0, 0, selindex),
+                                            QItemSelectionModel::ClearAndSelect);
+}
+
+void QMTreeView::addRow()
+{
+    //QModelIndex selindex = selectionModel()->currentIndex();
+    QAbstractItemModel *treemodel = model();
+
+    if (!treemodel->insertRow(treemodel->rowCount()))
+        return;
+}
+
+void QMTreeView::insertRow()
+{
+    QModelIndex selindex = selectionModel()->currentIndex();
+    QAbstractItemModel *treemodel = model();
+
+    //int i = 1;
+    //setFirstColumnSpanned(i, model()->index(i, 0), true);
+
+    if (!treemodel->insertRow(selindex.row() + 1, selindex.parent()))
+        return;
+}
+
+void QMTreeView::removeRow()
+{
+    QModelIndex selindex = selectionModel()->currentIndex();
+    QAbstractItemModel *treemodel = model();
+    treemodel->removeRow(selindex.row(), selindex.parent());
+}
+
+void QMTreeView::onCornerButtonRelease()
+{
+    QMenu *menu = new QMenu();
+    menu->addAction(new QAction("javi"));
+    menu->exec();
+
+    //QPushButton *bt = static_cast<QPushButton *>(cornerWidget());
+    //bt->setMenu(menu);
+}
+
+
+void QMTreeView::dragEnterEvent(QDragEnterEvent *event) {
+    if (event->mimeData()->hasText()) {
+        event->acceptProposedAction();
+    }
+}
+
+void QMTreeView::dragMoveEvent(QDragMoveEvent *event) {
+    if (event->mimeData()->hasText()) {
+        event->acceptProposedAction();
+    }
+}
+
+void QMTreeView::dropEvent(QDropEvent *event) {
+    if (event->mimeData()->hasText()) {
+        QString data = event->mimeData()->text();
+        QStringList items = data.split("\n");
+
+        // Aquí puedes insertar los datos en el modelo del QTreeView
+        QAbstractItemModel *treeModel = model();
+        for (const QString &item : items) {
+            if (!item.isEmpty()) {
+                QModelIndex parentIndex = currentIndex();
+                treeModel->insertRow(treeModel->rowCount(parentIndex), parentIndex);
+                QModelIndex newItemIndex = treeModel->index(treeModel->rowCount(parentIndex) - 1, 0, parentIndex);
+                treeModel->setData(newItemIndex, item);
+            }
+        }
+
+        event->acceptProposedAction();
+    }
+}