Russian Qt Forum

/* customtreeview.h */

class CustomTreeView : public QTreeView
{
    Q_OBJECT

    TreeSortFilterModel filter_model;
    SearchStringWidget search_widget;
public:
    // VARIABLES :
    bool highlight_enabled;

    explicit CustomTreeView(QWidget *parent = 0);
    void setModel(QAbstractItemModel *model);

    TreeSortFilterModel* filterModel();


protected:
        void mousePressEvent(QMouseEvent *event);
        void mouseMoveEvent(QMouseEvent *event);
        void keyPressEvent(QKeyEvent *);

private:


signals:
        void clickedWithModifiers(const QModelIndex &index, QMouseEvent* event);

public slots:

};

/* customtreeview.cpp */

#include "customtreeview.h"

#include <QMessageBox>

CustomTreeView::CustomTreeView(QWidget *parent) :
    QTreeView(parent)
{
    highlight_enabled = false;

    search_widget.setParent(this);
    search_widget.hide();
    connect(search_widget.edt_search_field, SIGNAL(textChanged(QString)), &filter_model, SLOT(updateFilterPattern(QString)));
    connect(&search_widget, SIGNAL(hidden()), &filter_model, SLOT(resetSearch()));

//    setModel(&filter_model);
}
///////////////////////////////////////////////////////////////////////
void CustomTreeView::mouseMoveEvent(QMouseEvent *event)
{
    if(highlight_enabled)
    { selectionModel()->setCurrentIndex(indexAt(event->pos()), QItemSelectionModel::SelectCurrent); }

    QTreeView::mouseMoveEvent(event);
}
///////////////////////////////////////////////////////////////////////
void CustomTreeView::mousePressEvent(QMouseEvent *event)
{
//    QModelIndex proxy_index = indexAt(event->pos());
//    QModelIndex real_index = filter_model.mapToSource(proxy_index);
    emit clickedWithModifiers(indexAt(event->pos()), event);
//    emit clicked(real_index);
//    setExpanded(proxy_index, !isExpanded(proxy_index));

    QTreeView::mousePressEvent(event);
}
///////////////////////////////////////////////////////////////////////
void CustomTreeView::keyPressEvent(QKeyEvent *evt)
{
    QString str = evt->text();
    if(str.isEmpty())
    { return; }
//    if(evt->key() == Key_Escape)
//    { search_widget.edt_search_field->clear(); search_widget.hide(); }

    QString search_text = search_widget.edt_search_field->text();
    search_widget.edt_search_field->setText(search_text + str);

    if(!search_widget.isVisible())
    {
        QPoint bottom_right = rect().bottomRight();
        search_widget.move(bottom_right.x()-search_widget.width(), bottom_right.y()-search_widget.height());
        search_widget.show();
        search_widget.edt_search_field->setFocus();
    }
}
///////////////////////////////////////////////////////////////////////
void CustomTreeView::setModel(QAbstractItemModel *model)
{
    filter_model.setSourceModel(model);
    QTreeView::setModel(&filter_model);
}
///////////////////////////////////////////////////////////////////////
TreeSortFilterModel* CustomTreeView::filterModel()
{
    return &filter_model;
}
///////////////////////////////////////////////////////////////////////

/* treemodel.h */

class TreeModel : public QAbstractItemModel
{
    Q_OBJECT

protected:
    TreeNode* root_item;

public:
    explicit TreeModel(QObject *parent = 0);
    ~TreeModel();
    QVariant headerData(int section, const Qt::Orientation & orientation, int role) const;
    QModelIndex index(int row, int column, const QModelIndex & parent) const;
    QModelIndex parent(const QModelIndex & child) const;
    Qt::ItemFlags flags(const QModelIndex & index) const;
    int rowCount(const QModelIndex & parent) const;
    int columnCount(const QModelIndex & parent) const;
    void addNode(TreeNode* item, TreeNode* parent = 0);
    void moveNode(TreeNode* item, int to);
    void removeNode(TreeNode* item, bool kill = true);
    void removeAll();

    virtual QStringList mimeTypes() const;
    virtual QMimeData* mimeData(const QModelIndexList &indexes) const;
    virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
    virtual Qt::DropActions supportedDropActions() const;

signals:

public slots:

};

/* treemodel.cpp */

#include "treemodel.h"

TreeModel::TreeModel(QObject *parent) :
    QAbstractItemModel(parent)
{
    root_item = new TreeNode();
}
////////////////////////////////////////////////////////////////////////////////
TreeModel::~TreeModel()
{
    delete root_item;
}
////////////////////////////////////////////////////////////////////////////////
QVariant TreeModel::headerData(int section, const Qt::Orientation &orientation, int role) const
{
    Q_UNUSED(section);

    if(orientation == Qt::Horizontal && role == Qt::DisplayRole)
    { return "Object"; }

    return QVariant();
}
////////////////////////////////////////////////////////////////////////////////
QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if(!hasIndex(row, column, parent))
    { return QModelIndex(); }

    TreeNode* parent_node;
    if(!parent.isValid())
    { parent_node = root_item; }
    else { parent_node = static_cast<TreeNode*>(parent.internalPointer()); }

    TreeNode* child_node = static_cast<TreeNode*>(parent_node->children().at(row));
    if(child_node)
    { return createIndex(row, column, child_node); }
    else { return QModelIndex(); }
}
////////////////////////////////////////////////////////////////////////////////
QModelIndex TreeModel::parent(const QModelIndex &child) const
{
    if(!child.isValid())
    { return QModelIndex(); }

    TreeNode* child_node = static_cast<TreeNode*>(child.internalPointer());
    TreeNode* parent_node = static_cast<TreeNode*>(child_node->parent());

    if(parent_node == root_item)
    { return QModelIndex(); }

    return createIndex(parent_node->row(), 0, parent_node);
}
////////////////////////////////////////////////////////////////////////////////
Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const
{
    if(index.isValid())
    { return Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsSelectable; }

    return Qt::ItemIsDropEnabled;
}
////////////////////////////////////////////////////////////////////////////////
int TreeModel::rowCount(const QModelIndex &parent) const
{
    TreeNode* parent_node;

        if(!parent.isValid())
        { parent_node = root_item; }
        else { parent_node = static_cast<TreeNode*>(parent.internalPointer()); }

        return parent_node->children().count();
}
////////////////////////////////////////////////////////////////////////////////
int TreeModel::columnCount(const QModelIndex &parent) const
{
    return 1;
}
////////////////////////////////////////////////////////////////////////////////
void TreeModel::addNode(TreeNode* item, TreeNode* parent)
{
    QModelIndex parent_index;

    if(!parent || parent == root_item)
    {
        parent = root_item;
        parent_index = QModelIndex();
    }
    else { parent_index = createIndex(parent->row(), 0, parent); }

    int idx = parent->children().count();

    beginInsertRows(parent_index, idx, idx);
    item->setParent(parent);
    endInsertRows();
}
////////////////////////////////////////////////////////////////////////////////
void TreeModel::removeAll()
{
    foreach(QObject* child, root_item->children())
    { delete child; }

    reset();
}
////////////////////////////////////////////////////////////////////////////////
void TreeModel::removeNode(TreeNode* item, bool kill)
{
    TreeNode* parent_node;
    QModelIndex parent_index;
    if(item->parent() == root_item)
    { parent_index = QModelIndex(); }
    else {
        parent_node = static_cast<TreeNode*>(item->parent());

        parent_index = createIndex(parent_node->row(), 0, parent_node);
    }

    int idx = item->row();
    beginRemoveRows(parent_index, idx, idx);
    if(kill)
    { delete item; }
    else { item->setParent(NULL); }
    endRemoveRows();
}
////////////////////////////////////////////////////////////////////////////////
QStringList TreeModel::mimeTypes() const
{
    QStringList list;
    list << "text/plain";
    return list;
}
////////////////////////////////////////////////////////////////////////////////
Qt::DropActions TreeModel::supportedDropActions() const
{
    return Qt::CopyAction | Qt::MoveAction;
}
////////////////////////////////////////////////////////////////////////////////
QMimeData* TreeModel::mimeData(const QModelIndexList &indexes) const
{
    QMimeData* data = new QMimeData();

    QStringList all_index_paths;
    foreach(QModelIndex index, indexes)
    {
        TreeNode* node = static_cast<TreeNode*>(index.internalPointer());
        QObject *child = node;
        QStringList pos_list;

//        pos_list.prepend(QString("%1").arg(child->parent()->children().indexOf(node)));

        while(child != root_item)
        {
            pos_list.prepend(QString("%1").arg(child->parent()->children().indexOf(child)));
            child  = child->parent();
        }


        QString index_path = pos_list.join("<<");
        all_index_paths.append(index_path);
    }

    data->setText(all_index_paths.join("|"));
    return data;
}
////////////////////////////////////////////////////////////////////////////////
bool TreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
    qDebug("root_item = 0x%x", root_item);
//    qDebug("%s", data->text().toAscii().data());

    QStringList index_paths = data->text().split("|");
    foreach(QString index_path, index_paths)
    {
        QStringList pos_list = index_path.split("<<");
        TreeNode* needle = root_item;
        for(int i = 0; i < pos_list.count(); i++)
        { needle = static_cast<TreeNode*>(needle->children().at(pos_list.at(i).toInt())); }

        removeNode(needle, false);
        TreeNode* target = static_cast<TreeNode*>(parent.internalPointer());

        qDebug("target = 0x%x", target);

        if(!target) { target = root_item; }
        addNode(needle, target);
        qDebug("needle = 0x%x", needle);
        qDebug("needle new parent: 0x%x", needle->parent());
        moveNode(needle, row);
    }

    return true;
}
////////////////////////////////////////////////////////////////////////////////
void TreeModel::moveNode(TreeNode *item, int to)
{
    TreeNode* parent = static_cast<TreeNode*>(item->parent());
    if(parent == root_item) { return; }     // NOT POSSIBLE TO MOVE TOPLEVEL ITEMS YET :-(

    if(parent)
    {
        int parent_row;
        QModelIndex parent_index = QModelIndex();
        parent_row = parent->parent()->children().indexOf(parent),
        parent_index = createIndex(parent_row, 0, parent);
        int child_row = parent->children().indexOf(item);
        if(child_row != to)
        {
            beginMoveRows(parent_index, child_row, child_row, parent_index, to);
            parent->moveChild(item, to);
            endMoveRows();
        }
    }
}
////////////////////////////////////////////////////////////////////////////////

/* treesortfiltermodel.h */

class TreeSortFilterModel : public QSortFilterProxyModel
{
    Q_OBJECT

    QRegExp* re_filter;

    bool isNodeMatchesFilter(TreeNode* node) const;

public:
    explicit TreeSortFilterModel(QObject *parent = 0);
    QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;

protected:
    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const;

signals:

public slots:
    void updateFilterPattern(QString);
    void resetSearch();

};

/* treesortfiltermodel.cpp */

#include "treesortfiltermodel.h"

TreeSortFilterModel::TreeSortFilterModel(QObject *parent) :
    QSortFilterProxyModel(parent)
{
    re_filter = new QRegExp(".*", Qt::CaseInsensitive);
}
///////////////////////////////////////////////////////////////////////////
void TreeSortFilterModel::updateFilterPattern(QString patt)
{
    if(patt.isEmpty())
    { resetSearch(); }
    else { re_filter->setPattern(patt); invalidateFilter(); }
}
///////////////////////////////////////////////////////////////////////////
void TreeSortFilterModel::resetSearch()
{
    re_filter->setPattern(".*");
    invalidateFilter();
}
///////////////////////////////////////////////////////////////////////////
bool TreeSortFilterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
    bool child_matches_filter = false;
/*
    if(!source_parent.isValid())
    { return true; }
*/
//    TreeNode* parent_node;
    QModelIndex asked_index = sourceModel()->index(source_row, 0, source_parent);
    TreeNode* asked_node = static_cast<TreeNode*>(asked_index.internalPointer());

    foreach(QObject* child, asked_node->children())
    {
        TreeNode* child_node = static_cast<TreeNode*>(child);
        if(child_matches_filter = isNodeMatchesFilter(child_node))
        { break; }
    }

    if(child_matches_filter)      // if item has at least one appropriate child, show it
    { return true; }
    else {      // or check if it matches filter
        return isNodeMatchesFilter(asked_node);
    }
}
///////////////////////////////////////////////////////////////////////////
bool TreeSortFilterModel::isNodeMatchesFilter(TreeNode *node) const
{
    bool result;
    SqlDatabase* db;
    SqlTable* table;
    SqlAttribute* attrib;
    WebPage* page;
    SqlForm* form;
    SqlFormField* ff;
    SqlFormFieldGroup* ffg;
    SqlDisplay* display;
    SqlQuery* query;
    SqlQueryField* qf;
    DataSource* data_source;

    switch(node->type())
    {
        case T_SQLDB:
            db = static_cast<SqlDatabase*>(node);
            result = re_filter->indexIn(db->alias()) != -1;
            break;
        case T_SQLTABLE:
            table = static_cast<SqlTable*>(node);
            result = re_filter->indexIn(table->alias()) != -1;
            break;
        case T_SQLATTRIB:
            attrib = static_cast<SqlAttribute*>(node);
            result = re_filter->indexIn(attrib->alias()) != -1;
            break;
        case T_WEBPAGE:
            page = static_cast<WebPage*>(node);
            result = re_filter->indexIn(page->name()) != -1;
            break;
        case T_SQLFORM:
            form = static_cast<SqlForm*>(node);
            result = re_filter->indexIn(form->name()) != -1;
            break;
        case T_SQLFORMFIELD:
            ff = static_cast<SqlFormField*>(node);
            result = re_filter->indexIn(ff->name()) != -1;
            break;
        case T_SQLFORMFIELDGROUP:
            ffg = static_cast<SqlFormFieldGroup*>(node);
            result = re_filter->indexIn(ffg->name()) != -1;
            break;
        case T_SQLDISPLAY:
            display = static_cast<SqlDisplay*>(node);
            result = re_filter->indexIn(display->name()) != -1;
            break;
        case T_SQLQUERY:
            query = static_cast<SqlQuery*>(node);
            result = re_filter->indexIn(query->name()) != -1;
            break;
        case T_SQLQUERYFIELD:
            qf = static_cast<SqlQueryField*>(node);
            result = re_filter->indexIn(qf->alias()) != -1;
            break;
        case T_DATASOURCE:
            data_source = static_cast<DataSource*>(node);
            result = re_filter->indexIn(data_source->name()) != -1;
            break;
    }

    return result;
}
///////////////////////////////////////////////////////////////////////////
QModelIndex TreeSortFilterModel::mapToSource(const QModelIndex &proxyIndex) const
{
    return QSortFilterProxyModel::mapToSource(proxyIndex);
}
///////////////////////////////////////////////////////////////////////////
QModelIndex TreeSortFilterModel::mapFromSource(const QModelIndex &sourceIndex) const
{
    return QSortFilterProxyModel::mapFromSource(sourceIndex);
}
///////////////////////////////////////////////////////////////////////////