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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2012-07-13
 * Description : Qt categorized item view for showfoto items
 *
 * SPDX-FileCopyrightText: 2013 by Mohamed_Anwer <m_dot_anwer at gmx dot com>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * ============================================================ */

#pragma once

// Local includes

#include "itemviewcategorized.h"
#include "showfotoiteminfo.h"

namespace Digikam
{
class ItemDelegateOverlay;
class ThumbnailSize;
};

namespace ShowFoto
{

class ShowfotoItemModel;
class ShowfotoDelegate;
class ShowfotoSortFilterModel;
class ShowfotoThumbnailModel;
class ShowfotoFilterModel;

class ShowfotoCategorizedView : public ItemViewCategorized
{
public:

    Q_OBJECT

public:

    explicit ShowfotoCategorizedView(QWidget* const parent = nullptr);
    ~ShowfotoCategorizedView() override;

    void setModels(ShowfotoItemModel* model, ShowfotoSortFilterModel* filterModel);

    ShowfotoItemModel*          showfotoItemModel()                     const;
    ShowfotoSortFilterModel*    showfotoSortFilterModel()               const;

    QItemSelectionModel*        getSelectionModel()                     const;

    /**
     * Returns any ShowfotoFilterModel in chain. May not be sourceModel()
     */
    ShowfotoFilterModel*        showfotoFilterModel()                   const;

    /**
     * Returns 0 if the ShowfotoItemModel is not an ShowfotoThumbnailModel
     */
    ShowfotoThumbnailModel*     showfotoThumbnailModel()                const;

    ShowfotoDelegate*           showfotoDelegate()                      const;

    ShowfotoItemInfo            currentInfo()                           const;
    QUrl                        currentUrl()                            const;

    QList<ShowfotoItemInfo>     selectedShowfotoItemInfos()             const;
    QList<ShowfotoItemInfo>     selectedShowfotoItemInfosCurrentFirst() const;
    QList<QUrl>                 selectedUrls()                          const;

    QList<ShowfotoItemInfo>     showfotoItemInfos()                     const;
    QList<QUrl>                 urls()                                  const;

    /**
     * Selects the index as current and scrolls to it
     */
    void toIndex(const QUrl& url);

    /**
     * Returns the n-th info after the given one.
     * Specifically, return the previous info for nth = -1
     * and the next info for n = 1.
     * Returns a null info if either startingPoint or the nth info are
     * not contained in the model
     */
    ShowfotoItemInfo nextInOrder(const ShowfotoItemInfo& startingPoint, int nth);

    ShowfotoItemInfo previousInfo(const ShowfotoItemInfo& info);
    ShowfotoItemInfo nextInfo(const ShowfotoItemInfo& info);

    /**
     * Add and remove an overlay. It will as well be removed automatically when destroyed.
     * Unless you pass a different delegate, the current delegate will be used.
     */
    void addOverlay(ItemDelegateOverlay* overlay, ShowfotoDelegate* delegate = nullptr);
    void removeOverlay(ItemDelegateOverlay* overlay);

    // TODO: Implement This
/*
    void addSelectionOverlay(ShowfotoDelegate* delegate = 0);
*/
    ThumbnailSize thumbnailSize()                                       const;

    virtual void setThumbnailSize(const ThumbnailSize& size);

public Q_SLOTS:

    void setThumbnailSize(int size);

    /**
     * Scroll the view to the given item when it becomes available
     */
    void setCurrentWhenAvailable(qlonglong ShowfotoItemId);

    /**
     * Set as current item the item identified by its file url
     */
    void setCurrentUrl(const QUrl& url);

    /**
     * Set as current item the item identified by the ShowfotoItemInfo
     */
    void setCurrentInfo(const ShowfotoItemInfo& info);

    /**
     * Set selected items identified by their file urls
     */
    void setSelectedUrls(const QList<QUrl>& urlList);

    /**
     * Set selected items
     */
    void setSelectedShowfotoItemInfos(const QList<ShowfotoItemInfo>& infos);

    /**
     * Does something to gain attention for info, but not changing current selection
     */
    void hintAt(const ShowfotoItemInfo& info);

Q_SIGNALS:

    void currentInfoChanged(const ShowfotoItemInfo& info);

    /**
     * Emitted when new items are selected. The parameter includes only the newly selected infos,
     * there may be other already selected infos.
     */
    void selected(const QList<ShowfotoItemInfo>& newSelectedInfos);

    /**
     * Emitted when items are deselected. There may be other selected infos left.
     * This signal is not emitted when the model is reset; then only selectionCleared is emitted.
     */
    void deselected(const QList<ShowfotoItemInfo>& nowDeselectedInfos);

    /**
     * Emitted when the given ShowfotoItemInfo is activated. Info is never null.
     */
    void showfotoItemInfoActivated(const ShowfotoItemInfo& info);

    /**
     * Emitted when a new model is set.
     */
    void modelChanged();

protected:

    /// reimplemented from parent class
    QSortFilterProxyModel*       filterModel()                                                                       const override;
    AbstractItemDragDropHandler* dragDropHandler()                                                                   const override;
    QModelIndex                  nextIndexHint(const QModelIndex& indexToAnchor, const QItemSelectionRange& removed) const override;

    void setItemDelegate(ShowfotoDelegate* delegate);
    void indexActivated(const QModelIndex& index, Qt::KeyboardModifiers modifiers)                                         override;
    void currentChanged(const QModelIndex& index, const QModelIndex& previous)                                             override;
    void paintEvent(QPaintEvent* e)                                                                                        override;<--- Function in derived class
    void selectionChanged(const QItemSelection&, const QItemSelection&)                                                    override;
    void updateGeometries()                                                                                                override;

    /// Reimplement these in a subclass
    virtual void activated(const ShowfotoItemInfo& info, Qt::KeyboardModifiers modifiers);
    virtual void showContextMenuOnInfo(QContextMenuEvent* event, const ShowfotoItemInfo& info);
    void showContextMenuOnIndex(QContextMenuEvent* event, const QModelIndex& index) override;

private Q_SLOTS:

    void slotFileChanged(const QString& filePath);
    void slotDelayedEnter();

private:

    void scrollToStoredItem();

private:

    // Disable
    ShowfotoCategorizedView(const ShowfotoCategorizedView&)            = delete;
    ShowfotoCategorizedView& operator=(const ShowfotoCategorizedView&) = delete;

private:

    class Private;
    Private* const d = nullptr;
};

} // namespace Showfoto