1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2006-05-04
 * Description : Watch image attributes
 *
 * SPDX-FileCopyrightText: 2006-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * ============================================================ */

#include "itemattributeswatch.h"

// Local includes

#include "coredbaccess.h"
#include "coredbwatch.h"

namespace Digikam
{

ItemAttributesWatch* ItemAttributesWatch::m_instance = nullptr;

ItemAttributesWatch::ItemAttributesWatch()
{
    CoreDbWatch* const dbwatch = CoreDbAccess::databaseWatch();<--- Variable 'dbwatch' can be declared as pointer to const

    connect(dbwatch, SIGNAL(imageChange(ImageChangeset)),
            this, SLOT(slotImageChange(ImageChangeset)));

    connect(dbwatch, SIGNAL(imageTagChange(ImageTagChangeset)),
            this, SLOT(slotImageTagChange(ImageTagChangeset)));
}

ItemAttributesWatch::~ItemAttributesWatch()
{
    m_instance = nullptr;
}

void ItemAttributesWatch::cleanUp()
{
    delete m_instance;
    m_instance = nullptr;
}

void ItemAttributesWatch::shutDown()
{
    if (m_instance)
    {
        m_instance->disconnect(nullptr, nullptr, nullptr);
    }
}

ItemAttributesWatch* ItemAttributesWatch::instance()
{
    if (!m_instance)
    {
        m_instance = new ItemAttributesWatch;
    }

    return m_instance;
}

void ItemAttributesWatch::slotImageChange(const ImageChangeset& changeset)
{
    DatabaseFields::Set set = changeset.changes();

    if (
        (set & DatabaseFields::ItemCommentsAll)  ||
        (set & DatabaseFields::CreationDate)     ||
        (set & DatabaseFields::ModificationDate) ||
        (set & DatabaseFields::Rating)
       )
    {
        const auto ids = changeset.ids();

        for (const qlonglong& imageId : ids)
        {
            if (set & DatabaseFields::ItemCommentsAll)
            {
                Q_EMIT signalImageCaptionChanged(imageId);
            }

            if (
                (set & DatabaseFields::CreationDate) ||
                (set & DatabaseFields::ModificationDate)
               )
            {
                Q_EMIT signalImageDateChanged(imageId);
            }

            if (set & DatabaseFields::Rating)
            {
                Q_EMIT signalImageRatingChanged(imageId);
            }
        }
    }
}

void ItemAttributesWatch::slotImageTagChange(const ImageTagChangeset& changeset)
{
    const auto ids = changeset.ids();

    for (const qlonglong& imageId : ids)
    {
        Q_EMIT signalImageTagsChanged(imageId);
    }
}

void ItemAttributesWatch::fileMetadataChanged(const QUrl& url)
{
    Q_EMIT signalFileMetadataChanged(url);
}

/*

void ItemAttributesWatch::slotImageFieldChanged(qlonglong imageId, int field)
{
    // Translate signals

    // TODO: compress?
    // TODO!!: we have databaseaccess lock here as well. Make connection queued in one place (above!)

    switch (field)
    {
        case DatabaseAttributesWatch::ImageComment:
            Q_EMIT signalImageCaptionChanged(imageId);
            break;
        case DatabaseAttributesWatch::ImageDate:
            Q_EMIT signalImageDateChanged(imageId);
            break;
        case DatabaseAttributesWatch::ImageRating:
            Q_EMIT signalImageRatingChanged(imageId);
            break;
        case DatabaseAttributesWatch::ImageTags:
            Q_EMIT signalImageTagsChanged(imageId);
            break;
    }
}

void ItemAttributesWatch::imageTagsChanged(qint64 imageId)
{
    Q_EMIT signalImageTagsChanged(imageId);
}

void ItemAttributesWatch::imagesChanged(int albumId)
{
    Q_EMIT signalImagesChanged(albumId);
}

void ItemAttributesWatch::imageRatingChanged(qint64 imageId)
{
    Q_EMIT signalImageRatingChanged(imageId);
}

void ItemAttributesWatch::imageDateChanged(qint64 imageId)
{
    Q_EMIT signalImageDateChanged(imageId);
}

void ItemAttributesWatch::imageCaptionChanged(qint64 imageId)
{
    Q_EMIT signalImageCaptionChanged(imageId);
}

*/

} // namespace Digikam

#include "moc_itemattributeswatch.cpp"