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
|
/*
* Copyright (c) 2019-2020, Jesse Buhgaiar <jooster669@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/NonnullRefPtr.h>
#include <AK/Vector.h>
#include <LibGUI/Model.h>
namespace GUI {
template<typename T, typename Container = Vector<T>, typename ColumnNameListType = void>
class ItemListModel : public Model {
public:
static constexpr auto IsTwoDimensional = requires(Container data)
{
requires !IsVoid<ColumnNameListType>;
data.at(0).at(0);
data.at(0).size();
};
// Substitute 'void' for a dummy u8.
using ColumnNamesT = Conditional<IsVoid<ColumnNameListType>, u8, ColumnNameListType>;
static NonnullRefPtr<ItemListModel> create(const Container& data, const ColumnNamesT& column_names, const Optional<size_t>& row_count = {}) requires(IsTwoDimensional)
{
return adopt_ref(*new ItemListModel<T, Container, ColumnNameListType>(data, column_names, row_count));
}
static NonnullRefPtr<ItemListModel> create(const Container& data, const Optional<size_t>& row_count = {}) requires(!IsTwoDimensional)
{
return adopt_ref(*new ItemListModel<T, Container>(data, row_count));
}
virtual ~ItemListModel() override { }
virtual int row_count(const ModelIndex&) const override
{
return m_provided_row_count.has_value() ? *m_provided_row_count : m_data.size();
}
virtual int column_count(const ModelIndex& index) const override
{
// if it's 2D (e.g. Vector<Vector<T>>)
if constexpr (IsTwoDimensional) {
if (index.is_valid())
return m_data.at(index.row()).size();
if (m_data.size())
return m_data.at(0).size();
return 0;
}
// Otherwise, let's just assume it's 1D.
return 1;
}
virtual String column_name(int index) const override
{
if constexpr (IsTwoDimensional)
return m_column_names[index];
return "Data";
}
virtual Variant data(const ModelIndex& index, ModelRole role) const override
{
if (role == ModelRole::TextAlignment)
return Gfx::TextAlignment::CenterLeft;
if (role == ModelRole::Display) {
if constexpr (IsTwoDimensional)
return m_data.at(index.row()).at(index.column());
else
return m_data.at(index.row());
}
return {};
}
virtual void update() override
{
did_update();
}
protected:
explicit ItemListModel(const Container& data, Optional<size_t> row_count = {}) requires(!IsTwoDimensional)
: m_data(data)
, m_provided_row_count(move(row_count))
{
}
explicit ItemListModel(const Container& data, const ColumnNamesT& column_names, Optional<size_t> row_count = {}) requires(IsTwoDimensional)
: m_data(data)
, m_column_names(column_names)
, m_provided_row_count(move(row_count))
{
}
const Container& m_data;
ColumnNamesT m_column_names;
Optional<size_t> m_provided_row_count;
};
}
|
