← Back to branch summary

~ubuntu-branches/ubuntu/precise/gwenview/precise-proposed

« back to all changes in this revision

Viewing changes to lib/semanticinfo/tagmodel.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2011-12-15 14:17:54 UTC
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20111215141754-z043hyx69dulbggf
Tags: upstream-4.7.90
Import upstream version 4.7.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/semanticinfo/tagmodel.cpp
1
 
// vim: set tabstop=4 shiftwidth=4 noexpandtab:
 
1
// vim: set tabstop=4 shiftwidth=4 expandtab:
2
2
/*
3
3
Gwenview: an image viewer
4
4
Copyright 2008 Aurélien Gâteau <agateau@kde.org>
30
30
// Local
31
31
#include "abstractsemanticinfobackend.h"
32
32
 
33
 
namespace Gwenview {
34
 
 
 
33
namespace Gwenview
 
34
{
35
35
 
36
36
struct TagModelPrivate {
37
 
        AbstractSemanticInfoBackEnd* mBackEnd;
 
37
    AbstractSemanticInfoBackEnd* mBackEnd;
38
38
};
39
39
 
40
 
 
41
 
static QStandardItem* createItem(const SemanticInfoTag& tag, const QString& label, TagModel::AssignmentStatus status) {
42
 
        QStandardItem* item = new QStandardItem(label);
43
 
        item->setData(tag, TagModel::TagRole);
44
 
        item->setData(label.toLower(), TagModel::SortRole);
45
 
        item->setData(status, TagModel::AssignmentStatusRole);
46
 
        item->setData(KIcon("mail-tagged.png"), Qt::DecorationRole);
47
 
        return item;
 
40
static QStandardItem* createItem(const SemanticInfoTag& tag, const QString& label, TagModel::AssignmentStatus status)
 
41
{
 
42
    QStandardItem* item = new QStandardItem(label);
 
43
    item->setData(tag, TagModel::TagRole);
 
44
    item->setData(label.toLower(), TagModel::SortRole);
 
45
    item->setData(status, TagModel::AssignmentStatusRole);
 
46
    item->setData(KIcon("mail-tagged.png"), Qt::DecorationRole);
 
47
    return item;
48
48
}
49
49
 
50
 
 
51
50
TagModel::TagModel(QObject* parent)
52
51
: QStandardItemModel(parent)
53
 
, d(new TagModelPrivate) {
54
 
        d->mBackEnd = 0;
55
 
        setSortRole(SortRole);
56
 
}
57
 
 
58
 
 
59
 
TagModel::~TagModel() {
60
 
        delete d;
61
 
}
62
 
 
63
 
 
64
 
void TagModel::setSemanticInfoBackEnd(AbstractSemanticInfoBackEnd* backEnd) {
65
 
        d->mBackEnd = backEnd;
66
 
}
67
 
 
68
 
 
69
 
void TagModel::setTagSet(const TagSet& set) {
70
 
        clear();
71
 
        Q_FOREACH(const SemanticInfoTag& tag, set) {
72
 
                QString label = d->mBackEnd->labelForTag(tag);
73
 
                QStandardItem* item = createItem(tag, label, TagModel::FullyAssigned);
74
 
                appendRow(item);
75
 
        }
76
 
        sort(0);
77
 
}
78
 
 
79
 
 
80
 
void TagModel::addTag(const SemanticInfoTag& tag, const QString& _label, TagModel::AssignmentStatus status) {
81
 
        int row;
82
 
        QString label = _label.isEmpty() ? d->mBackEnd->labelForTag(tag) : _label;
83
 
 
84
 
        const QString sortLabel = label.toLower();
85
 
        // This is not optimal, implement dichotomic search if necessary
86
 
        for (row=0; row < rowCount(); ++row) {
87
 
                const QModelIndex idx = index(row, 0);
88
 
                if (idx.data(SortRole).toString().compare(sortLabel) > 0) {
89
 
                        break;
90
 
                }
91
 
        }
92
 
        if (row > 0) {
93
 
                QStandardItem* _item = item(row - 1);
94
 
                Q_ASSERT(_item);
95
 
                if (_item->data(TagRole).toString() == tag) {
96
 
                        // Update, do not add
97
 
                        _item->setData(label.toLower(), SortRole);
98
 
                        _item->setData(status, AssignmentStatusRole);
99
 
                        return;
100
 
                }
101
 
        }
102
 
        QStandardItem* _item = createItem(tag, label, status);
103
 
        insertRow(row, _item);
104
 
}
105
 
 
106
 
 
107
 
void TagModel::removeTag(const SemanticInfoTag& tag) {
108
 
        // This is not optimal, implement dichotomic search if necessary
109
 
        for (int row=0; row < rowCount(); ++row) {
110
 
                if (index(row, 0).data(TagRole).toString() == tag) {
111
 
                        removeRow(row);
112
 
                        return;
113
 
                }
114
 
        }
115
 
}
116
 
 
117
 
 
118
 
TagModel* TagModel::createAllTagsModel(QObject* parent, AbstractSemanticInfoBackEnd* backEnd) {
119
 
        TagModel* tagModel = new TagModel(parent);
120
 
        tagModel->setSemanticInfoBackEnd(backEnd);
121
 
        tagModel->setTagSet(backEnd->allTags());
122
 
        connect(backEnd, SIGNAL(tagAdded(const SemanticInfoTag&, const QString&)),
123
 
                tagModel, SLOT(addTag(const SemanticInfoTag&, const QString&)));
124
 
        return tagModel;
125
 
}
126
 
 
 
52
, d(new TagModelPrivate)
 
53
{
 
54
    d->mBackEnd = 0;
 
55
    setSortRole(SortRole);
 
56
}
 
57
 
 
58
TagModel::~TagModel()
 
59
{
 
60
    delete d;
 
61
}
 
62
 
 
63
void TagModel::setSemanticInfoBackEnd(AbstractSemanticInfoBackEnd* backEnd)
 
64
{
 
65
    d->mBackEnd = backEnd;
 
66
}
 
67
 
 
68
void TagModel::setTagSet(const TagSet& set)
 
69
{
 
70
    clear();
 
71
    Q_FOREACH(const SemanticInfoTag & tag, set) {
 
72
        QString label = d->mBackEnd->labelForTag(tag);
 
73
        QStandardItem* item = createItem(tag, label, TagModel::FullyAssigned);
 
74
        appendRow(item);
 
75
    }
 
76
    sort(0);
 
77
}
 
78
 
 
79
void TagModel::addTag(const SemanticInfoTag& tag, const QString& _label, TagModel::AssignmentStatus status)
 
80
{
 
81
    int row;
 
82
    QString label = _label.isEmpty() ? d->mBackEnd->labelForTag(tag) : _label;
 
83
 
 
84
    const QString sortLabel = label.toLower();
 
85
    // This is not optimal, implement dichotomic search if necessary
 
86
    for (row = 0; row < rowCount(); ++row) {
 
87
        const QModelIndex idx = index(row, 0);
 
88
        if (idx.data(SortRole).toString().compare(sortLabel) > 0) {
 
89
            break;
 
90
        }
 
91
    }
 
92
    if (row > 0) {
 
93
        QStandardItem* _item = item(row - 1);
 
94
        Q_ASSERT(_item);
 
95
        if (_item->data(TagRole).toString() == tag) {
 
96
            // Update, do not add
 
97
            _item->setData(label.toLower(), SortRole);
 
98
            _item->setData(status, AssignmentStatusRole);
 
99
            return;
 
100
        }
 
101
    }
 
102
    QStandardItem* _item = createItem(tag, label, status);
 
103
    insertRow(row, _item);
 
104
}
 
105
 
 
106
void TagModel::removeTag(const SemanticInfoTag& tag)
 
107
{
 
108
    // This is not optimal, implement dichotomic search if necessary
 
109
    for (int row = 0; row < rowCount(); ++row) {
 
110
        if (index(row, 0).data(TagRole).toString() == tag) {
 
111
            removeRow(row);
 
112
            return;
 
113
        }
 
114
    }
 
115
}
 
116
 
 
117
TagModel* TagModel::createAllTagsModel(QObject* parent, AbstractSemanticInfoBackEnd* backEnd)
 
118
{
 
119
    TagModel* tagModel = new TagModel(parent);
 
120
    tagModel->setSemanticInfoBackEnd(backEnd);
 
121
    tagModel->setTagSet(backEnd->allTags());
 
122
    connect(backEnd, SIGNAL(tagAdded(SemanticInfoTag, QString)),
 
123
            tagModel, SLOT(addTag(SemanticInfoTag, QString)));
 
124
    return tagModel;
 
125
}
127
126
 
128
127
} // namespace