QRangeModel Class

std::array<int, 5> numbers = {1, 2, 3, 4, 5};
QRangeModel model(numbers);
listView.setModel(&model);

QRangeModel model(numbers);

QRangeModel model(&numbers);

QRangeModel model(std::ref(numbers));

auto shared_numbers = std::make_shared<std::vector<int>>(numbers);
QRangeModel model(shared_numbers);

const std::array<int, 5> numbers = {1, 2, 3, 4, 5};

std::array<const int, 5> numbers = {1, 2, 3, 4, 5};

QRangeModel model(std::cref(numbers));

QList<int> numbers = {1, 2, 3, 4, 5};
QRangeModel model(numbers); // columnCount() == 1
QListView listView;
listView.setModel(&model);

std::vector<std::vector<int>> gridOfNumbers = {
    {1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
};
QRangeModel model(&gridOfNumbers); // columnCount() == 5
QTableView tableView;
tableView.setModel(&model);

using TableRow = std::tuple<int, QString>;
QList<TableRow> numberNames = {
    {1, "one"},
    {2, "two"},
    {3, "three"}
};
QRangeModel model(&numberNames); // columnCount() == 2
QTableView tableView;
tableView.setModel(&model);

class Book
{
    Q_GADGET
    Q_PROPERTY(QString title READ title)
    Q_PROPERTY(QString author READ author)
    Q_PROPERTY(QString summary MEMBER m_summary)
    Q_PROPERTY(int rating READ rating WRITE setRating)
public:
    Book(const QString &title, const QString &author);

    // C++ rule of 0: destructor, as well as copy/move operations
    // provided by the compiler.

    // read-only properties
    QString title() const { return m_title; }
    QString author() const { return m_author; }

    // read/writable property with input validation
    int rating() const { return m_rating; }
    void setRating(int rating)
    {
        m_rating = qBound(0, rating, 5);
    }

private:
    QString m_title;
    QString m_author;
    QString m_summary;
    int m_rating = 0;
};

using ColorEntry = QMap<Qt::ItemDataRole, QVariant>;

const QStringList colorNames = QColor::colorNames();
QList<ColorEntry> colors;
colors.reserve(colorNames.size());
for (const QString &name : colorNames) {
    const QColor color = QColor::fromString(name);
    colors << ColorEntry{{Qt::DisplayRole, name},
                        {Qt::DecorationRole, color},
                        {Qt::ToolTipRole, color.name()}};
}
QRangeModel colorModel(colors);
QListView list;
list.setModel(&colorModel);

class ColorEntry
{
    Q_GADGET
    Q_PROPERTY(QString display MEMBER m_colorName)
    Q_PROPERTY(QColor decoration READ decoration)
    Q_PROPERTY(QString toolTip READ toolTip)
public:
    ColorEntry(const QString &color = {})
        : m_colorName(color)
    {}

    QColor decoration() const
    {
        return QColor::fromString(m_colorName);
    }
    QString toolTip() const
    {
        return QColor::fromString(m_colorName).name();
    }

private:
    QString m_colorName;
};

QList<QList<ColorEntry>> colorTable;

// ...

QRangeModel colorModel(colorTable);
QTableView table;
table.setModel(&colorModel);

class ColorEntry
{
    Q_GADGET
    Q_PROPERTY(QString display MEMBER m_colorName)
    Q_PROPERTY(QColor decoration READ decoration)
    Q_PROPERTY(QString toolTip READ toolTip)
public:
    ...
};
template <>
struct QRangeModel::RowOptions<ColorEntry>
{
    static constexpr auto rowCategory = QRangeModel::RowCategory::MultiRoleItem;
};

const QStringList colorNames = QColor::colorNames();
QList<std::tuple<ColorEntry>> colors;

// ...

QRangeModel colorModel(colors);
QListView list;
list.setModel(&colorModel);

ColorEntry firstEntry = std::get<0>(colors.at(0));

auto [firstEntry] = colors.at(0);

class Entry : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString display READ display WRITE setDisplay NOTIFY displayChanged)
    Q_PROPERTY(QIcon decoration READ decoration WRITE setDecoration NOTIFY decorationChanged)
    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY toolTipChanged)

public:
    Entry() = default;

    QString display() const
    {
        return m_display;
    }

    void setDisplay(const QString &display)
    {
        if (m_display == display)
            return;
        m_display = display;
        emit displayChanged(m_display);
    }

signals:
    void displayChanged(const QString &);
    ...
};
std::vector<std::shared_ptr<Entry>> entries = {
    ...
};
QRangeModel model(std::ref(entries));
QListView listView;
listView.setModel(&model);

template <>
struct QRangeModel::RowOptions<Entry>
{
    static constexpr auto rowCategory = QRangeModel::RowCategory::MultiRoleItem;
};
std::vector<std::shared_ptr<Entry>> entries = {
    std::make_shared<Entry>(),
    ...
};

QRangeModel model(std::ref(entries));

class NumbersModel : public QRangeModel
{
    std::vector<int> m_numbers;

public:
    NumbersModel(const std::vector<int> &numbers)
        : QRangeModel(std::ref(m_numbers))
        , m_numbers(numbers)
    {
    }

    void setNumber(int idx, int number)
    {
        setData(index(idx, 0), QVariant::fromValue(number));
    }

    int number(int idx) const
    {
        return m_numbers.at(idx);
    }
};

class TreeRow;

using Tree = std::vector<TreeRow>;

class TreeRow
{
    Q_GADGET
    // properties

    TreeRow *m_parent;
    std::optional<Tree> m_children;

public:
    TreeRow() = default;

    // rule of 0: copy, move, and destructor implicitly defaulted

    // tree traversal protocol implementation
    const TreeRow *parentRow() const { return m_parent; }
    const std::optional<Tree> &childRows() const { return m_children; }

    void setParentRow(TreeRow *parent) { m_parent = parent; }
    std::optional<Tree> &childRows() { return m_children; }

    ...
    // Helper to assembly a tree of rows, not used by QRangeModel
    template <typename ...Args>
    TreeRow &addChild(Args &&...args)
    {
        if (!m_children)
            m_children.emplace(Tree{});
        auto &child = m_children->emplace_back(std::forward<Args>(args)...);
        child.m_parent = this;
        return child;
    }
};

Tree tree = {
    {"..."},
    {"..."},
    {"..."},
};

// each toplevel row has three children
tree[0].addChild("...");
tree[0].addChild("...");
tree[0].addChild("...");

tree[1].addChild("...");
tree[1].addChild("...");
tree[1].addChild("...");

tree[2].addChild("...");
tree[2].addChild("...");
tree[2].addChild("...");

// instantiate the model with a pointer to the tree, not a copy!
QRangeModel model(&tree);
QTreeView view;
view.setModel(&model);

struct TreeTraversal
{
    TreeRow newRow() const { return TreeRow{}; }
    const TreeRow *parentRow(const TreeRow &row) const { return row.m_parent; }
    void setParentRow(TreeRow &row, TreeRow *parent) const { row.m_parent = parent; }
    const std::optional<Tree> &childRows(const TreeRow &row) const { return row.m_children; }
    std::optional<Tree> &childRows(TreeRow &row) const { return row.m_children; }
};

QRangeModel model(&tree, TreeTraversal{});

struct TreeRow;
using Tree = std::vector<TreeRow *>;

구조체 TreeRow { Q_GADGETpublic: TreeRow(const QString &value = {}) : m_value(value) {} ~TreeRow() { if (m_children)            qDeleteAll(*m_children);
    } // 이동 전용TreeRow(TreeRow &&) = default; TreeRow &operator=(TreeRow &&) = default; // 템플릿  채우기 헬퍼<typename ...Args>TreeRow *addChild(Args &&...args) { if (!m_children) m_children.emplace(Tree{}); auto *child =  m_children->emplace_back(new TreeRow(std::forward<Args>(args)...));  child->m_parent = this; return child; }private: friend 구조체 TreeTraversal;    QString m_value; std::optional<Tree> m_children; TreeRow *m_parent = nullptr; }; Tree tree = { new TreeRow("1"), new TreeRow("2"), new TreeRow("3"), new TreeRow("4"),}; tree[0]->addChild("1.1");
tree[1]->addChild("2.1");
tree[2]->addChild("3.1")->addChild("3.1.1");
tree[3]->addChild("4.1");

struct TreeTraversal
{
    TreeRow *newRow() const { return new TreeRow; }
    void deleteRow(TreeRow *row) { delete row; }

    const TreeRow *parentRow(const TreeRow &row) const { return row.m_parent; }
    void setParentRow(TreeRow &row, TreeRow *parent) { row.m_parent = parent; }
    const std::optional<Tree> &childRows(const TreeRow &row) const { return row.m_children; }
    std::optional<Tree> &childRows(TreeRow &row) { return row.m_children; }
};

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    Tree tree = make_tree_of_pointers();

    QRangeModel model(std::move(tree), TreeTraversal{});
    QTreeView treeView;
    treeView.setModel(&model);
    treeView.show();

    return app.exec();
}

struct Book
{
    QString title;
    QString author;
    QString summary;
    int rating = 0;

    template <size_t I, typename T>
        requires ((I <= 3) && std::is_same_v<std::remove_cvref_t<T>, Book>)
    friend inline decltype(auto) get(T &&book)
    {
        if constexpr (I == 0)
            return std::as_const(book.title);
        else if constexpr (I == 1)
            return std::as_const(book.author);
        else if constexpr (I == 2)
            return std::forward_like<T>(book.summary);
        else if constexpr (I == 3)
            return std::forward_like<T>(book.rating);
    }
};

namespace std {
    template <> struct tuple_size<Book> : std::integral_constant<size_t, 4> {};
    template <size_t I> struct tuple_element<I, Book>
    { using type = decltype(get<I>(std::declval<Book>())); };
}

멤버 함수 문서

range 의 데이터에서 작동하는 QRangeModel 인스턴스를 구축합니다. range 은 std::begin 과 std::end 을 사용할 수 있는 순차적 범위여야 합니다. protocol 이 제공되면 모델은 프로토콜 구현을 사용하여 범위를 트리로 표현합니다. 모델 인스턴스는 parent 의 자식이 됩니다.

range 은 포인터 또는 참조 래퍼일 수 있으며, 이 경우 모델 API(예: setData() 또는 insertRow())를 변경하면 참조된 범위 인스턴스의 데이터가 수정됩니다. range 가 값(또는 모델 내로 이동)인 경우 모델에서 방출되는 신호에 연결하여 데이터 변경에 응답합니다.

QRangeModel 는 작성되는 동안 range 에 액세스하지 않습니다. 따라서 아직 완전히 구성되지 않은 범위 객체에 대한 포인터나 참조를 이 생성자에 전달하는 것이 합법적입니다(예: subclassing QRangeModel).

range 이 모델에 이동된 경우 모델 소멸 시 범위와 그 안의 모든 데이터가 소멸됩니다.

[override virtual noexcept] QRangeModel::~QRangeModel()

QRangeModel 을 파괴합니다.

모델이 생성된 범위에는 액세스하지 않으며, 모델이 이동된 범위에서 생성된 경우에만 파괴합니다.

[override virtual] QModelIndex QRangeModel::buddy(const QModelIndex &index) const

재구현합니다: QAbstractItemModel::buddy(const QModelIndex &index) const.

[override virtual] bool QRangeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const

재 구현합니다: QAbstractItemModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const.

[override virtual] bool QRangeModel::canFetchMore(const QModelIndex &parent) const

재구현합니다: QAbstractItemModel::canFetchMore(const QModelIndex &parent) const.

[override virtual] bool QRangeModel::clearItemData(const QModelIndex &index)

재구현합니다: QAbstractItemModel::clearItemData(const QModelIndex &index).

index 범위에 저장된 값을 기본값으로 구성된 값으로 바꿉니다.

읽기 전용 범위 또는 the C++ tuple protocol 을 구현하는 행 유형의 읽기 전용 열에서 작동하는 모델의 경우 이 구현은 false 을 즉시 반환합니다.

[override virtual] int QRangeModel::columnCount(const QModelIndex &parent = {}) const

재구현합니다: QAbstractItemModel::columnCount(const QModelIndex &parent) const.

모델의 열 수를 반환합니다. 이 함수는 모든 parent 인덱스에 대해 동일한 값을 반환합니다.

정적 크기의 행 유형에서 작동하는 모델의 경우 이 반환 값은 모델의 수명 기간 동안 항상 동일합니다. 동적 크기의 행 유형에서 작동하는 모델의 경우 첫 번째 행에 있는 항목 수를 반환하거나 모델에 행이 없는 경우 0을 반환합니다.

rowCount 및 insertColumns()도 참조하세요 .

[override virtual] QVariant QRangeModel::data(const QModelIndex &index, int role = Qt::DisplayRole) const

재구현합니다: QAbstractItemModel::data(const QModelIndex &index, int role) const.

index 에서 참조하는 범위의 값에 대해 지정된 role 에 저장된 데이터를 반환합니다.

해당 인덱스의 항목 유형이 int, Qt::ItemDataRole, 또는 QString 에서 QVariant 로 매핑되는 연관 컨테이너인 경우 해당 컨테이너에서 역할 데이터를 조회하여 반환합니다.

항목이 가젯 또는 QObject 인 경우 구현은 roleNames() 매핑의 role 항목과 일치하는 항목의 속성 값을 반환합니다.

그렇지 않으면 구현은 Qt::DisplayRole 또는 Qt::EditRole 에 대해 QVariant::fromValue() 을 통해 항목에서 구성된 QVariant 을 반환합니다. 다른 역할의 경우 구현은 잘못된 (기본적으로 구성된) QVariant 을 반환합니다.

Qt::ItemDataRole, setData() 및 headerData()도 참조하세요 .

[override virtual] bool QRangeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)

재구현합니다: QAbstractItemModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent).

[override virtual protected] bool QRangeModel::event(QEvent *event)

다시 구현합니다: QObject::event(QEvent *e).

[override virtual protected] bool QRangeModel::eventFilter(QObject *object, QEvent *event)

다시 구현합니다: QObject::eventFilter(QObject *watched, QEvent *event).

[override virtual] void QRangeModel::fetchMore(const QModelIndex &parent)

재구현합니다: QAbstractItemModel::fetchMore(const QModelIndex &parent).

[override virtual] Qt::ItemFlags QRangeModel::flags(const QModelIndex &index) const

재구현합니다: QAbstractItemModel::flags(const QModelIndex &index) const.

주어진 index 에 대한 항목 플래그를 반환합니다.

이 구현은 항목(ItemIsEnabled)을 활성화하고 선택(ItemIsSelectable)을 허용하는 플래그 조합을 반환합니다. 변경 가능한 데이터가 있는 범위에서 작동하는 모델의 경우 항목을 편집할 수 있는 플래그도 설정합니다 (ItemIsEditable).

Qt::ItemFlags 를참조하세요 .

[override virtual] bool QRangeModel::hasChildren(const QModelIndex &parent = QModelIndex()) const

재구현합니다: QAbstractItemModel::hasChildren(const QModelIndex &parent) const.

[override virtual] QVariant QRangeModel::headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const

재구현합니다: QAbstractItemModel::headerData(int section, Qt::오리엔테이션 방향, int 역할) const.

지정된 role 와 section 에 대한 데이터를 지정된 orientation 헤더로 반환합니다.

가로 헤더의 경우 섹션 번호는 열 번호에 해당합니다. 마찬가지로 세로 헤더의 경우 섹션 번호는 행 번호에 해당합니다.

가로 머리글 및 Qt::DisplayRole role , 배열을 행 유형으로 사용하는 범위에서 작동하는 모델은 section 을 반환합니다. 행 유형이 튜플인 경우 구현은 section 에서 유형 이름을 반환합니다. 가젯 또는 QObject 유형인 행의 경우 이 함수는 section 의 인덱스에 있는 속성 이름을 반환합니다.

세로 헤더의 경우 이 함수는 항상 QAbstractItemModel 의 기본 구현 결과를 반환합니다.

Qt::ItemDataRole, setHeaderData() 및 QHeaderView 를참조하십시오 .

[override virtual] QModelIndex QRangeModel::index(int row, int column, const QModelIndex &parent = {}) const

재구현합니다: QAbstractItemModel::index(int row, int column, const QModelIndex &parent) const.

parent 에서 row 및 column 의 모델 항목의 인덱스를 반환합니다.

유효한 부모를 전달하면 목록 및 테이블 범위에서 작동하는 모델에 대해 유효하지 않은 인덱스가 생성됩니다.

parent()도 참조하세요 .

[override virtual] bool QRangeModel::insertColumns(int column, int count, const QModelIndex &parent = {})

재구현합니다: QAbstractItemModel::insertColumns(int column, int count, const QModelIndex &parent).

count column 의 항목 앞에 의 범위의 모든 행에 빈 열을 삽입합니다. 성공하면 을 반환하고, 그렇지 않으면 을 반환합니다. parent true false

읽기 전용 범위 또는 정적 크기의 행 유형(예: 튜플, 배열 또는 구조체)이 있는 범위에서 작동하는 모델의 경우 이 구현은 아무 작업도 수행하지 않고 즉시 false 을 반환합니다. 트리 모델의 경우 항상 그렇습니다.

[override virtual] bool QRangeModel::insertRows(int row, int count, const QModelIndex &parent = {})

재구현합니다: QAbstractItemModel::insertRows(int row, int count, const QModelIndex &parent).

주어진 row 앞에 count 빈 행을 parent 의 범위에 삽입합니다. 성공하면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

읽기 전용 또는 정적으로 크기가 지정된 범위(예: 배열)에서 작동하는 모델의 경우 이 구현은 아무 작업도 수행하지 않고 false 을 즉시 반환합니다.

[override virtual] QMap<int, QVariant> QRangeModel::itemData(const QModelIndex &index) const

재구현합니다: QAbstractItemModel::itemData(const QModelIndex &index) const.

주어진 index 에 있는 항목에 대해 모델에서 미리 정의된 모든 역할에 대한 값이 있는 맵을 반환합니다.

해당 index 의 항목 유형이 int, Qt::ItemDataRole, 또는 QString 에서 QVariant 로 매핑되는 연관 컨테이너인 경우 해당 컨테이너의 데이터가 반환됩니다.

항목 유형이 가젯 또는 QObject 하위 클래스인 경우 role name 과 일치하는 해당 속성 값이 반환됩니다.

항목이 연관 컨테이너, 가젯 또는 QObject 서브클래스가 아닌 경우 기본 클래스 구현을 호출합니다.

setItemData(), Qt::ItemDataRole, data()도 참조하세요 .

[override virtual] QModelIndexList QRangeModel::match(const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const

재 구현합니다: QAbstractItemModel::match(const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const.

[override virtual] QMimeData *QRangeModel::mimeData(const QModelIndexList &indexes) const

재구현합니다: QAbstractItemModel::mimeData(const QModelIndexList &indexes) const.

[override virtual] QStringList QRangeModel::mimeTypes() const

재구현합니다: QAbstractItemModel::mimeTypes() const.

[override virtual] bool QRangeModel::moveColumns(const QModelIndex &sourceParent, int sourceColumn, int count, const QModelIndex &destinationParent, int destinationColumn)

재구현합니다: QAbstractItemModel::moveColumns(const QModelIndex &sourceParent, int sourceColumn, int count, const QModelIndex &destinationParent, int destinationChild).

부모 sourceParent 아래의 지정된 sourceColumn 열로 시작하는 count 열을 부모 destinationParent 아래의 destinationColumn 열로 이동합니다.

열이 성공적으로 이동하면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

[override virtual] bool QRangeModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationRow)

재구현합니다: QAbstractItemModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild).

부모 sourceParent 아래의 지정된 sourceRow 행으로 시작하는 count 행을 부모 destinationParent 아래의 destinationRow 행으로 이동합니다.

행이 성공적으로 이동하면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

[override virtual] void QRangeModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const

재구현합니다: QAbstractItemModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const.

[override virtual] QModelIndex QRangeModel::parent(const QModelIndex &child) const

재구현합니다: QAbstractItemModel::parent(const QModelIndex &index) const.

child 인덱스에서 항목의 부모를 반환합니다.

이 함수는 목록 및 테이블 범위에서 작동하는 모델에 대해 항상 잘못된 인덱스를 생성합니다. 트리에서 작동하는 모델의 경우 이 함수는 트리 탐색 프로토콜의 parent() 구현에서 반환한 행 항목의 인덱스를 반환합니다.

index() 및 hasChildren()도 참조하세요 .

[override virtual] bool QRangeModel::removeColumns(int column, int count, const QModelIndex &parent = {})

재구현합니다: QAbstractItemModel::removeColumns(int column, int count, const QModelIndex &parent).

column 에 있는 항목에서 parent 에 있는 범위의 모든 행에서 count 열을 제거합니다. 성공하면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

읽기 전용 범위 또는 정적 크기의 행 유형(예: 튜플, 배열 또는 구조체)이 있는 범위에서 작동하는 모델의 경우 이 구현은 아무 작업도 수행하지 않고 false 을 즉시 반환합니다. 트리 모델의 경우 항상 그렇습니다.

[override virtual] bool QRangeModel::removeRows(int row, int count, const QModelIndex &parent = {})

재구현합니다: QAbstractItemModel::removeRows(int row, int count, const QModelIndex &parent).

주어진 row 부터 시작하여 parent 범위에서 count 행을 제거합니다. 성공하면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

읽기 전용 또는 정적으로 크기가 지정된 범위(예: 배열)에서 작동하는 모델의 경우 이 구현은 아무 작업도 수행하지 않고 false 을 즉시 반환합니다.

[override virtual protected slot] void QRangeModel::resetInternalData()

다시 구현합니다: QAbstractItemModel::resetInternalData().

[override virtual] QHash<int, QByteArray> QRangeModel::roleNames() const

재구현합니다: QAbstractItemModel::roleNames() const.

setRoleNames()도 참조하세요 .

[override virtual] int QRangeModel::rowCount(const QModelIndex &parent = {}) const

재구현합니다: QAbstractItemModel::rowCount(const QModelIndex &parent) const.

주어진 parent 아래의 행 수를 반환합니다. 이 값은 잘못된 parent 인덱스의 루트 범위에 있는 항목 수입니다.

parent 인덱스가 유효하면 이 함수는 목록 및 테이블 범위에서 작동하는 모델에 대해 항상 0을 반환합니다. 트리의 경우 트리 탐색 프로토콜의 childRows() 구현에서 반환하는 범위의 크기를 반환합니다.

columnCount(), insertRows() 및 hasChildren()도 참조하세요 .

[override virtual] bool QRangeModel::setData(const QModelIndex &index, const QVariant &data, int role = Qt::EditRole)

재구현합니다: QAbstractItemModel::setData(const Q모델인덱스 &index, const Q변수 &value, int 역할).

index 에 있는 항목의 role 데이터를 data 로 설정합니다.

해당 index 의 항목 유형이 int, Qt::ItemDataRole 또는 QString 에서 QVariant 로 매핑되는 연관 컨테이너인 경우 data 는 role 에서 지정한 키에 대해 해당 컨테이너에 저장됩니다.

항목이 가젯 또는 QObject 인 경우 data 은 roleNames() 매핑의 role 항목과 일치하는 항목의 속성에 기록됩니다. 속성이 발견되고 data 에 필요한 유형으로 변환할 수 있는 값이 저장되어 있으면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

그렇지 않으면 이 구현은 data 의 값을 Qt::DisplayRole 및 Qt::EditRole 범위의 index 에 있는 항목에 할당하고 true 를 반환합니다. 다른 역할의 경우 구현은 false 을 반환합니다.

읽기 전용 범위 또는 the C++ tuple protocol 을 구현하는 행 유형의 읽기 전용 열에서 작동하는 모델의 경우 이 구현은 false 을 즉시 반환합니다.

data()도 참조하세요 .

[override virtual] bool QRangeModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &data, int role = Qt::EditRole)

재구현합니다: QAbstractItemModel::setHeaderData(int section, Qt::오리엔테이션 오리엔테이션, const QVariant &value, int role).

headerData()도 참조하십시오 .

[override virtual] bool QRangeModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &data)

재구현합니다: QAbstractItemModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles).

index 의 항목 유형이 int 또는 Qt::ItemDataRole 에서 QVariant 로 매핑되는 연관 컨테이너인 경우 data 의 항목이 해당 컨테이너에 저장됩니다. 연관 컨테이너가 QString 에서 QVariant 으로 매핑되는 경우 data 에 있는 값 중 role names 테이블에 매핑이 있는 값만 저장됩니다.

항목 유형이 가젯 또는 QObject 하위 클래스인 경우 role name 과 일치하는 속성은 data 에 있는 해당 값으로 설정됩니다.

data 에 항목이 없는 역할은 수정되지 않습니다.

복사할 수 있는 항목 유형의 경우 이 구현은 트랜잭션이며 data 의 모든 항목을 저장할 수 있는 경우 true를 반환합니다. 어떤 항목도 업데이트할 수 없는 경우 원래 컨테이너는 전혀 수정되지 않으며 함수는 false를 반환합니다.

항목이 연관 컨테이너, 가젯 또는 QObject 서브클래스가 아닌 경우 data 의 각 항목에 대해 setData()를 호출하는 기본 클래스 구현을 호출합니다.

itemData(), setData() 및 Qt::ItemDataRole도 참조하세요 .

[override virtual] QModelIndex QRangeModel::sibling(int row, int column, const QModelIndex &index) const

재구현합니다: QAbstractItemModel::sibling(int row, int column, const QModelIndex &index) const.

index 에 있는 항목에 대해 row 및 column 의 형제 항목을 반환하거나 해당 위치에 형제 항목이 없으면 유효하지 않은 QModelIndex 을 반환합니다.

이 구현은 index 의 parent()를 거치는 것보다 훨씬 빠릅니다.

index(), QModelIndex::row() 및 QModelIndex::column()도 참조하세요 .

[override virtual] void QRangeModel::sort(int column, Qt::SortOrder order = Qt::AscendingOrder)

재구현합니다: QAbstractItemModel::sort(int column, Qt::SortOrder 순서).

[override virtual] QSize QRangeModel::span(const QModelIndex &index) const

재구현합니다: QAbstractItemModel::span(const QModelIndex &index) const.

[override virtual] Qt::DropActions QRangeModel::supportedDragActions() const

재구현합니다: QAbstractItemModel::supportedDragActions() const.

[override virtual] Qt::DropActions QRangeModel::supportedDropActions() const

재구현합니다: QAbstractItemModel::supportedDropActions() const.