qtreewidget.cpp

Absolute File Name:/home/qt/qt5_coco/qt5/qtbase/src/widgets/itemviews/qtreewidget.cpp
Source codeSwitch to Preprocessed file
LineSourceCount
1/****************************************************************************-
2**-
3** Copyright (C) 2015 The Qt Company Ltd.-
4** Contact: http://www.qt.io/licensing/-
5**-
6** This file is part of the QtWidgets module of the Qt Toolkit.-
7**-
8** $QT_BEGIN_LICENSE:LGPL21$-
9** Commercial License Usage-
10** Licensees holding valid commercial Qt licenses may use this file in-
11** accordance with the commercial license agreement provided with the-
12** Software or, alternatively, in accordance with the terms contained in-
13** a written agreement between you and The Qt Company. For licensing terms-
14** and conditions see http://www.qt.io/terms-conditions. For further-
15** information use the contact form at http://www.qt.io/contact-us.-
16**-
17** GNU Lesser General Public License Usage-
18** Alternatively, this file may be used under the terms of the GNU Lesser-
19** General Public License version 2.1 or version 3 as published by the Free-
20** Software Foundation and appearing in the file LICENSE.LGPLv21 and-
21** LICENSE.LGPLv3 included in the packaging of this file. Please review the-
22** following information to ensure the GNU Lesser General Public License-
23** requirements will be met: https://www.gnu.org/licenses/lgpl.html and-
24** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.-
25**-
26** As a special exception, The Qt Company gives you certain additional-
27** rights. These rights are described in The Qt Company LGPL Exception-
28** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.-
29**-
30** $QT_END_LICENSE$-
31**-
32****************************************************************************/-
33-
34#include "qtreewidget.h"-
35-
36#ifndef QT_NO_TREEWIDGET-
37#include <qheaderview.h>-
38#include <qpainter.h>-
39#include <qitemdelegate.h>-
40#include <qstack.h>-
41#include <qdebug.h>-
42#include <private/qtreewidget_p.h>-
43#include <private/qwidgetitemdata_p.h>-
44#include <private/qtreewidgetitemiterator_p.h>-
45-
46#include <algorithm>-
47-
48QT_BEGIN_NAMESPACE-
49-
50// workaround for VC++ 6.0 linker bug (?)-
51typedef bool(*LessThan)(const QPair<QTreeWidgetItem*,int>&,const QPair<QTreeWidgetItem*,int>&);-
52-
53class QTreeModelLessThan-
54{-
55public:-
56 inline bool operator()(QTreeWidgetItem *i1, QTreeWidgetItem *i2) const-
57 { return *i1 < *i2; }
never executed: return *i1 < *i2;
0
58};-
59-
60class QTreeModelGreaterThan-
61{-
62public:-
63 inline bool operator()(QTreeWidgetItem *i1, QTreeWidgetItem *i2) const-
64 { return *i2 < *i1; }
never executed: return *i2 < *i1;
0
65};-
66-
67/*-
68 \class QTreeModel-
69 \brief The QTreeModel class manages the items stored in a tree view.-
70-
71 \ingroup model-view-
72 \inmodule QtWidgets-
73-
74*/-
75-
76/*!-
77 \enum QTreeWidgetItem::ChildIndicatorPolicy-
78 \since 4.3-
79-
80 \value ShowIndicator The controls for expanding and collapsing will be shown for this item even if there are no children.-
81 \value DontShowIndicator The controls for expanding and collapsing will never be shown even if there are children. If the node is forced open the user will not be able to expand or collapse the item.-
82 \value DontShowIndicatorWhenChildless The controls for expanding and collapsing will be shown if the item contains children.-
83*/-
84-
85/*!-
86 \fn void QTreeWidgetItem::setDisabled(bool disabled)-
87 \since 4.3-
88-
89 Disables the item if \a disabled is true; otherwise enables the item.-
90-
91 \sa setFlags()-
92*/-
93-
94/*!-
95 \fn bool QTreeWidgetItem::isDisabled() const-
96 \since 4.3-
97-
98 Returns \c true if the item is disabled; otherwise returns \c false.-
99-
100 \sa setFlags()-
101*/-
102-
103/*!-
104 \internal-
105-
106 Constructs a tree model with a \a parent object and the given-
107 number of \a columns.-
108*/-
109-
110QTreeModel::QTreeModel(int columns, QTreeWidget *parent)-
111 : QAbstractItemModel(parent), rootItem(new QTreeWidgetItem),-
112 headerItem(new QTreeWidgetItem), skipPendingSort(false)-
113{-
114 rootItem->view = parent;-
115 rootItem->itemFlags = Qt::ItemIsDropEnabled;-
116 headerItem->view = parent;-
117 setColumnCount(columns);-
118}
never executed: end of block
0
119-
120/*!-
121 \internal-
122-
123*/-
124-
125QTreeModel::QTreeModel(QTreeModelPrivate &dd, QTreeWidget *parent)-
126 : QAbstractItemModel(dd, parent), rootItem(new QTreeWidgetItem),-
127 headerItem(new QTreeWidgetItem), skipPendingSort(false)-
128{-
129 rootItem->view = parent;-
130 rootItem->itemFlags = Qt::ItemIsDropEnabled;-
131 headerItem->view = parent;-
132}
never executed: end of block
0
133-
134/*!-
135 \internal-
136-
137 Destroys this tree model.-
138*/-
139-
140QTreeModel::~QTreeModel()-
141{-
142 clear();-
143 headerItem->view = Q_NULLPTR;-
144 delete headerItem;-
145 rootItem->view = 0;-
146 delete rootItem;-
147}
never executed: end of block
0
148-
149/*!-
150 \internal-
151-
152 Removes all items in the model.-
153*/-
154-
155void QTreeModel::clear()-
156{-
157 SkipSorting skipSorting(this);-
158 beginResetModel();-
159 for (int i = 0; i < rootItem->childCount(); ++i) {
i < rootItem->childCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
160 QTreeWidgetItem *item = rootItem->children.at(i);-
161 item->par = 0;-
162 item->view = 0;-
163 delete item;-
164 }
never executed: end of block
0
165 rootItem->children.clear();-
166 sortPendingTimer.stop();-
167 endResetModel();-
168}
never executed: end of block
0
169-
170/*!-
171 \internal-
172-
173 Sets the number of \a columns in the tree model.-
174*/-
175-
176void QTreeModel::setColumnCount(int columns)-
177{-
178 SkipSorting skipSorting(this);-
179 if (columns < 0)
columns < 0Description
TRUEnever evaluated
FALSEnever evaluated
0
180 return;
never executed: return;
0
181 if (!headerItem) {
!headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
182 headerItem = new QTreeWidgetItem();-
183 headerItem->view = view();-
184 }
never executed: end of block
0
185 int count = columnCount();-
186 if (count == columns)
count == columnsDescription
TRUEnever evaluated
FALSEnever evaluated
0
187 return;
never executed: return;
0
188-
189 if (columns < count) {
columns < countDescription
TRUEnever evaluated
FALSEnever evaluated
0
190 beginRemoveColumns(QModelIndex(), columns, count - 1);-
191 headerItem->values.resize(columns);-
192 endRemoveColumns();-
193 } else {
never executed: end of block
0
194 beginInsertColumns(QModelIndex(), count, columns - 1);-
195 headerItem->values.resize(columns);-
196 for (int i = count; i < columns; ++i) {// insert data without emitting the dataChanged signal
i < columnsDescription
TRUEnever evaluated
FALSEnever evaluated
0
197 headerItem->values[i].append(QWidgetItemData(Qt::DisplayRole, QString::number(i + 1)));-
198 headerItem->d->display.append(QString::number(i + 1));-
199 }
never executed: end of block
0
200 endInsertColumns();-
201 }
never executed: end of block
0
202}-
203-
204/*!-
205 \internal-
206-
207 Returns the tree view item corresponding to the \a index given.-
208-
209 \sa QModelIndex-
210*/-
211-
212QTreeWidgetItem *QTreeModel::item(const QModelIndex &index) const-
213{-
214 if (!index.isValid())
!index.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
215 return 0;
never executed: return 0;
0
216 return static_cast<QTreeWidgetItem*>(index.internalPointer());
never executed: return static_cast<QTreeWidgetItem*>(index.internalPointer());
0
217}-
218-
219/*!-
220 \internal-
221-
222 Returns the model index that refers to the-
223 tree view \a item and \a column.-
224*/-
225-
226QModelIndex QTreeModel::index(const QTreeWidgetItem *item, int column) const-
227{-
228 executePendingSort();-
229-
230 if (!item || (item == rootItem))
!itemDescription
TRUEnever evaluated
FALSEnever evaluated
(item == rootItem)Description
TRUEnever evaluated
FALSEnever evaluated
0
231 return QModelIndex();
never executed: return QModelIndex();
0
232 const QTreeWidgetItem *par = item->parent();-
233 QTreeWidgetItem *itm = const_cast<QTreeWidgetItem*>(item);-
234 if (!par)
!parDescription
TRUEnever evaluated
FALSEnever evaluated
0
235 par = rootItem;
never executed: par = rootItem;
0
236 int row;-
237 int guess = item->d->rowGuess;-
238 if (guess >= 0
guess >= 0Description
TRUEnever evaluated
FALSEnever evaluated
0
239 && par->children.count() > guess
par->children.count() > guessDescription
TRUEnever evaluated
FALSEnever evaluated
0
240 && par->children.at(guess) == itm) {
par->children.at(guess) == itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
241 row = guess;-
242 } else {
never executed: end of block
0
243 row = par->children.lastIndexOf(itm);-
244 itm->d->rowGuess = row;-
245 }
never executed: end of block
0
246 return createIndex(row, column, itm);
never executed: return createIndex(row, column, itm);
0
247}-
248-
249/*!-
250 \internal-
251 \reimp-
252-
253 Returns the model index with the given \a row,-
254 \a column and \a parent.-
255*/-
256-
257QModelIndex QTreeModel::index(int row, int column, const QModelIndex &parent) const-
258{-
259 executePendingSort();-
260-
261 int c = columnCount(parent);-
262 if (row < 0 || column < 0 || column >= c)
row < 0Description
TRUEnever evaluated
FALSEnever evaluated
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
column >= cDescription
TRUEnever evaluated
FALSEnever evaluated
0
263 return QModelIndex();
never executed: return QModelIndex();
0
264-
265 QTreeWidgetItem *parentItem = parent.isValid() ? item(parent) : rootItem;
parent.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
266 if (parentItem && row < parentItem->childCount()) {
parentItemDescription
TRUEnever evaluated
FALSEnever evaluated
row < parentItem->childCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
267 QTreeWidgetItem *itm = parentItem->child(row);-
268 if (itm)
itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
269 return createIndex(row, column, itm);
never executed: return createIndex(row, column, itm);
0
270 return QModelIndex();
never executed: return QModelIndex();
0
271 }-
272-
273 return QModelIndex();
never executed: return QModelIndex();
0
274}-
275-
276/*!-
277 \internal-
278 \reimp-
279-
280 Returns the parent model index of the index given as-
281 the \a child.-
282*/-
283-
284QModelIndex QTreeModel::parent(const QModelIndex &child) const-
285{-
286 SkipSorting skipSorting(this); //The reason we don't sort here is that this might be called from a valid QPersistentModelIndex-
287 //We don't want it to become suddenly invalid-
288-
289 if (!child.isValid())
!child.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
290 return QModelIndex();
never executed: return QModelIndex();
0
291 QTreeWidgetItem *itm = static_cast<QTreeWidgetItem *>(child.internalPointer());-
292 if (!itm || itm == rootItem)
!itmDescription
TRUEnever evaluated
FALSEnever evaluated
itm == rootItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
293 return QModelIndex();
never executed: return QModelIndex();
0
294 QTreeWidgetItem *parent = itm->parent();-
295 return index(parent, 0);
never executed: return index(parent, 0);
0
296}-
297-
298/*!-
299 \internal-
300 \reimp-
301-
302 Returns the number of rows in the \a parent model index.-
303*/-
304-
305int QTreeModel::rowCount(const QModelIndex &parent) const-
306{-
307 if (!parent.isValid())
!parent.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
308 return rootItem->childCount();
never executed: return rootItem->childCount();
0
309-
310 QTreeWidgetItem *parentItem = item(parent);-
311 if (parentItem)
parentItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
312 return parentItem->childCount();
never executed: return parentItem->childCount();
0
313 return 0;
never executed: return 0;
0
314}-
315-
316/*!-
317 \internal-
318 \reimp-
319-
320 Returns the number of columns in the item referred to by-
321 the given \a index.-
322*/-
323-
324int QTreeModel::columnCount(const QModelIndex &index) const-
325{-
326 Q_UNUSED(index);-
327 if (!headerItem)
!headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
328 return 0;
never executed: return 0;
0
329 return headerItem->columnCount();
never executed: return headerItem->columnCount();
0
330}-
331-
332bool QTreeModel::hasChildren(const QModelIndex &parent) const-
333{-
334 if (!parent.isValid())
!parent.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
335 return (rootItem->childCount() > 0);
never executed: return (rootItem->childCount() > 0);
0
336-
337 QTreeWidgetItem *itm = item(parent);-
338 if (!itm)
!itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
339 return false;
never executed: return false;
0
340 switch (itm->d->policy) {-
341 case QTreeWidgetItem::ShowIndicator:
never executed: case QTreeWidgetItem::ShowIndicator:
0
342 return true;
never executed: return true;
0
343 case QTreeWidgetItem::DontShowIndicator:
never executed: case QTreeWidgetItem::DontShowIndicator:
0
344 return false;
never executed: return false;
0
345 case QTreeWidgetItem::DontShowIndicatorWhenChildless:
never executed: case QTreeWidgetItem::DontShowIndicatorWhenChildless:
0
346 return (itm->childCount() > 0);
never executed: return (itm->childCount() > 0);
0
347 }-
348 return false;
never executed: return false;
0
349}-
350-
351/*!-
352 \internal-
353 \reimp-
354-
355 Returns the data corresponding to the given model \a index-
356 and \a role.-
357*/-
358-
359QVariant QTreeModel::data(const QModelIndex &index, int role) const-
360{-
361 if (!index.isValid())
!index.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
362 return QVariant();
never executed: return QVariant();
0
363 QTreeWidgetItem *itm = item(index);-
364 if (itm)
itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
365 return itm->data(index.column(), role);
never executed: return itm->data(index.column(), role);
0
366 return QVariant();
never executed: return QVariant();
0
367}-
368-
369/*!-
370 \internal-
371 \reimp-
372-
373 Sets the data for the item specified by the \a index and \a role-
374 to that referred to by the \a value.-
375-
376 Returns \c true if successful; otherwise returns \c false.-
377*/-
378-
379bool QTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)-
380{-
381 if (!index.isValid())
!index.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
382 return false;
never executed: return false;
0
383 QTreeWidgetItem *itm = item(index);-
384 if (itm) {
itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
385 itm->setData(index.column(), role, value);-
386 return true;
never executed: return true;
0
387 }-
388 return false;
never executed: return false;
0
389}-
390-
391QMap<int, QVariant> QTreeModel::itemData(const QModelIndex &index) const-
392{-
393 QMap<int, QVariant> roles;-
394 QTreeWidgetItem *itm = item(index);-
395 if (itm) {
itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
396 int column = index.column();-
397 if (column < itm->values.count()) {
column < itm->values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
398 for (int i = 0; i < itm->values.at(column).count(); ++i) {
i < itm->value...olumn).count()Description
TRUEnever evaluated
FALSEnever evaluated
0
399 roles.insert(itm->values.at(column).at(i).role,-
400 itm->values.at(column).at(i).value);-
401 }
never executed: end of block
0
402 }
never executed: end of block
0
403-
404 // the two special cases-
405 QVariant displayValue = itm->data(column, Qt::DisplayRole);-
406 if (displayValue.isValid())
displayValue.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
407 roles.insert(Qt::DisplayRole, displayValue);
never executed: roles.insert(Qt::DisplayRole, displayValue);
0
408-
409 QVariant checkValue = itm->data(column, Qt::CheckStateRole);-
410 if (checkValue.isValid())
checkValue.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
411 roles.insert(Qt::CheckStateRole, checkValue);
never executed: roles.insert(Qt::CheckStateRole, checkValue);
0
412 }
never executed: end of block
0
413 return roles;
never executed: return roles;
0
414}-
415-
416/*!-
417 \internal-
418 \reimp-
419*/-
420bool QTreeModel::insertRows(int row, int count, const QModelIndex &parent)-
421{-
422 SkipSorting skipSorting(this);-
423 if (count < 1 || row < 0 || row > rowCount(parent) || parent.column() > 0)
count < 1Description
TRUEnever evaluated
FALSEnever evaluated
row < 0Description
TRUEnever evaluated
FALSEnever evaluated
row > rowCount(parent)Description
TRUEnever evaluated
FALSEnever evaluated
parent.column() > 0Description
TRUEnever evaluated
FALSEnever evaluated
0
424 return false;
never executed: return false;
0
425-
426 beginInsertRows(parent, row, row + count - 1);-
427 QTreeWidgetItem *par = item(parent);-
428 while (count > 0) {
count > 0Description
TRUEnever evaluated
FALSEnever evaluated
0
429 QTreeWidgetItem *item = new QTreeWidgetItem();-
430 item->view = view();-
431 item->par = par;-
432 if (par)
parDescription
TRUEnever evaluated
FALSEnever evaluated
0
433 par->children.insert(row++, item);
never executed: par->children.insert(row++, item);
0
434 else-
435 rootItem->children.insert(row++, item);
never executed: rootItem->children.insert(row++, item);
0
436 --count;-
437 }
never executed: end of block
0
438 endInsertRows();-
439 return true;
never executed: return true;
0
440}-
441-
442/*!-
443 \internal-
444 \reimp-
445*/-
446bool QTreeModel::insertColumns(int column, int count, const QModelIndex &parent)-
447{-
448 SkipSorting skipSorting(this);-
449 if (count < 1 || column < 0 || column > columnCount(parent) || parent.column() > 0 || !headerItem)
count < 1Description
TRUEnever evaluated
FALSEnever evaluated
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
column > columnCount(parent)Description
TRUEnever evaluated
FALSEnever evaluated
parent.column() > 0Description
TRUEnever evaluated
FALSEnever evaluated
!headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
450 return false;
never executed: return false;
0
451-
452 beginInsertColumns(parent, column, column + count - 1);-
453-
454 int oldCount = columnCount(parent);-
455 column = qBound(0, column, oldCount);-
456 headerItem->values.resize(oldCount + count);-
457 for (int i = oldCount; i < oldCount + count; ++i) {
i < oldCount + countDescription
TRUEnever evaluated
FALSEnever evaluated
0
458 headerItem->values[i].append(QWidgetItemData(Qt::DisplayRole, QString::number(i + 1)));-
459 headerItem->d->display.append(QString::number(i + 1));-
460 }
never executed: end of block
0
461-
462 QStack<QTreeWidgetItem*> itemstack;-
463 itemstack.push(0);-
464 while (!itemstack.isEmpty()) {
!itemstack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
465 QTreeWidgetItem *par = itemstack.pop();-
466 QList<QTreeWidgetItem*> children = par ? par->children : rootItem->children;
parDescription
TRUEnever evaluated
FALSEnever evaluated
0
467 for (int row = 0; row < children.count(); ++row) {
row < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
468 QTreeWidgetItem *child = children.at(row);-
469 if (child->children.count())
child->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
470 itemstack.push(child);
never executed: itemstack.push(child);
0
471 child->values.insert(column, count, QVector<QWidgetItemData>());-
472 }
never executed: end of block
0
473 }
never executed: end of block
0
474-
475 endInsertColumns();-
476 return true;
never executed: return true;
0
477}-
478-
479/*!-
480 \internal-
481 \reimp-
482*/-
483bool QTreeModel::removeRows(int row, int count, const QModelIndex &parent) {-
484 if (count < 1 || row < 0 || (row + count) > rowCount(parent))
count < 1Description
TRUEnever evaluated
FALSEnever evaluated
row < 0Description
TRUEnever evaluated
FALSEnever evaluated
(row + count) ...wCount(parent)Description
TRUEnever evaluated
FALSEnever evaluated
0
485 return false;
never executed: return false;
0
486-
487 beginRemoveRows(parent, row, row + count - 1);-
488-
489 QSignalBlocker blocker(this);-
490-
491 QTreeWidgetItem *itm = item(parent);-
492 for (int i = row + count - 1; i >= row; --i) {
i >= rowDescription
TRUEnever evaluated
FALSEnever evaluated
0
493 QTreeWidgetItem *child = itm ? itm->takeChild(i) : rootItem->children.takeAt(i);
itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
494 Q_ASSERT(child);-
495 child->view = 0;-
496 delete child;-
497 child = 0;-
498 }
never executed: end of block
0
499 blocker.unblock();-
500-
501 endRemoveRows();-
502 return true;
never executed: return true;
0
503}-
504-
505/*!-
506 \internal-
507 \reimp-
508-
509 Returns the header data corresponding to the given header \a section,-
510 \a orientation and data \a role.-
511*/-
512-
513QVariant QTreeModel::headerData(int section, Qt::Orientation orientation, int role) const-
514{-
515 if (orientation != Qt::Horizontal)
orientation != Qt::HorizontalDescription
TRUEnever evaluated
FALSEnever evaluated
0
516 return QVariant();
never executed: return QVariant();
0
517-
518 if (headerItem)
headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
519 return headerItem->data(section, role);
never executed: return headerItem->data(section, role);
0
520 if (role == Qt::DisplayRole)
role == Qt::DisplayRoleDescription
TRUEnever evaluated
FALSEnever evaluated
0
521 return QString::number(section + 1);
never executed: return QString::number(section + 1);
0
522 return QVariant();
never executed: return QVariant();
0
523}-
524-
525/*!-
526 \internal-
527 \reimp-
528-
529 Sets the header data for the item specified by the header \a section,-
530 \a orientation and data \a role to the given \a value.-
531-
532 Returns \c true if successful; otherwise returns \c false.-
533*/-
534-
535bool QTreeModel::setHeaderData(int section, Qt::Orientation orientation,-
536 const QVariant &value, int role)-
537{-
538 if (section < 0 || orientation != Qt::Horizontal || !headerItem || section >= columnCount())
section < 0Description
TRUEnever evaluated
FALSEnever evaluated
orientation != Qt::HorizontalDescription
TRUEnever evaluated
FALSEnever evaluated
!headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
section >= columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
539 return false;
never executed: return false;
0
540-
541 headerItem->setData(section, role, value);-
542 return true;
never executed: return true;
0
543}-
544-
545/*!-
546 \reimp-
547-
548 Returns the flags for the item referred to the given \a index.-
549-
550*/-
551-
552Qt::ItemFlags QTreeModel::flags(const QModelIndex &index) const-
553{-
554 if (!index.isValid())
!index.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
555 return rootItem->flags();
never executed: return rootItem->flags();
0
556 QTreeWidgetItem *itm = item(index);-
557 Q_ASSERT(itm);-
558 return itm->flags();
never executed: return itm->flags();
0
559}-
560-
561/*!-
562 \internal-
563-
564 Sorts the entire tree in the model in the given \a order,-
565 by the values in the given \a column.-
566*/-
567-
568void QTreeModel::sort(int column, Qt::SortOrder order)-
569{-
570 SkipSorting skipSorting(this);-
571 sortPendingTimer.stop();-
572-
573 if (column < 0 || column >= columnCount())
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
column >= columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
574 return;
never executed: return;
0
575-
576 //layoutAboutToBeChanged and layoutChanged will be called by sortChildren-
577 rootItem->sortChildren(column, order, true);-
578}
never executed: end of block
0
579-
580/*!-
581 \internal-
582*/-
583void QTreeModel::ensureSorted(int column, Qt::SortOrder order,-
584 int start, int end, const QModelIndex &parent)-
585{-
586 if (isChanging())
isChanging()Description
TRUEnever evaluated
FALSEnever evaluated
0
587 return;
never executed: return;
0
588-
589 sortPendingTimer.stop();-
590-
591 if (column < 0 || column >= columnCount())
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
column >= columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
592 return;
never executed: return;
0
593-
594 SkipSorting skipSorting(this);-
595-
596 QTreeWidgetItem *itm = item(parent);-
597 if (!itm)
!itmDescription
TRUEnever evaluated
FALSEnever evaluated
0
598 itm = rootItem;
never executed: itm = rootItem;
0
599 QList<QTreeWidgetItem*> lst = itm->children;-
600-
601 int count = end - start + 1;-
602 QVector < QPair<QTreeWidgetItem*,int> > sorting(count);-
603 for (int i = 0; i < count; ++i) {
i < countDescription
TRUEnever evaluated
FALSEnever evaluated
0
604 sorting[i].first = lst.at(start + i);-
605 sorting[i].second = start + i;-
606 }
never executed: end of block
0
607-
608 LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);
order == Qt::AscendingOrderDescription
TRUEnever evaluated
FALSEnever evaluated
0
609 std::stable_sort(sorting.begin(), sorting.end(), compare);-
610-
611 QModelIndexList oldPersistentIndexes;-
612 QModelIndexList newPersistentIndexes;-
613 QList<QTreeWidgetItem*>::iterator lit = lst.begin();-
614 bool changed = false;-
615-
616 for (int i = 0; i < count; ++i) {
i < countDescription
TRUEnever evaluated
FALSEnever evaluated
0
617 int oldRow = sorting.at(i).second;-
618-
619 int tmpitepos = lit - lst.begin();-
620 QTreeWidgetItem *item = lst.takeAt(oldRow);-
621 if (tmpitepos > lst.size())
tmpitepos > lst.size()Description
TRUEnever evaluated
FALSEnever evaluated
0
622 --tmpitepos;
never executed: --tmpitepos;
0
623 lit = lst.begin() + tmpitepos;-
624-
625 lit = sortedInsertionIterator(lit, lst.end(), order, item);-
626 int newRow = qMax(lit - lst.begin(), 0);-
627-
628 if ((newRow < oldRow) && !(*item < *lst.at(oldRow - 1)) && !(*lst.at(oldRow - 1) < *item ))
(newRow < oldRow)Description
TRUEnever evaluated
FALSEnever evaluated
!(*item < *lst.at(oldRow - 1))Description
TRUEnever evaluated
FALSEnever evaluated
!(*lst.at(oldR...- 1) < *item )Description
TRUEnever evaluated
FALSEnever evaluated
0
629 newRow = oldRow;
never executed: newRow = oldRow;
0
630-
631 lit = lst.insert(lit, item);-
632 if (newRow != oldRow) {
newRow != oldRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
633 // we are going to change the persistent indexes, so we need to prepare-
634 if (!changed) { // this will only happen once
!changedDescription
TRUEnever evaluated
FALSEnever evaluated
0
635 changed = true;-
636 emit layoutAboutToBeChanged(); // the selection model needs to know-
637 oldPersistentIndexes = persistentIndexList();-
638 newPersistentIndexes = oldPersistentIndexes;-
639 }
never executed: end of block
0
640 for (int j = i + 1; j < count; ++j) {
j < countDescription
TRUEnever evaluated
FALSEnever evaluated
0
641 int otherRow = sorting.at(j).second;-
642 if (oldRow < otherRow && newRow >= otherRow)
oldRow < otherRowDescription
TRUEnever evaluated
FALSEnever evaluated
newRow >= otherRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
643 --sorting[j].second;
never executed: --sorting[j].second;
0
644 else if (oldRow > otherRow && newRow <= otherRow)
oldRow > otherRowDescription
TRUEnever evaluated
FALSEnever evaluated
newRow <= otherRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
645 ++sorting[j].second;
never executed: ++sorting[j].second;
0
646 }
never executed: end of block
0
647 for (int k = 0; k < newPersistentIndexes.count(); ++k) {
k < newPersist...ndexes.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
648 QModelIndex pi = newPersistentIndexes.at(k);-
649 if (pi.parent() != parent)
pi.parent() != parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
650 continue;
never executed: continue;
0
651 int oldPersistentRow = pi.row();-
652 int newPersistentRow = oldPersistentRow;-
653 if (oldPersistentRow == oldRow)
oldPersistentRow == oldRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
654 newPersistentRow = newRow;
never executed: newPersistentRow = newRow;
0
655 else if (oldRow < oldPersistentRow && newRow >= oldPersistentRow)
oldRow < oldPersistentRowDescription
TRUEnever evaluated
FALSEnever evaluated
newRow >= oldPersistentRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
656 newPersistentRow = oldPersistentRow - 1;
never executed: newPersistentRow = oldPersistentRow - 1;
0
657 else if (oldRow > oldPersistentRow && newRow <= oldPersistentRow)
oldRow > oldPersistentRowDescription
TRUEnever evaluated
FALSEnever evaluated
newRow <= oldPersistentRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
658 newPersistentRow = oldPersistentRow + 1;
never executed: newPersistentRow = oldPersistentRow + 1;
0
659 if (newPersistentRow != oldPersistentRow)
newPersistentR...dPersistentRowDescription
TRUEnever evaluated
FALSEnever evaluated
0
660 newPersistentIndexes[k] = createIndex(newPersistentRow,
never executed: newPersistentIndexes[k] = createIndex(newPersistentRow, pi.column(), pi.internalPointer());
0
661 pi.column(), pi.internalPointer());
never executed: newPersistentIndexes[k] = createIndex(newPersistentRow, pi.column(), pi.internalPointer());
0
662 }
never executed: end of block
0
663 }
never executed: end of block
0
664 }
never executed: end of block
0
665-
666 if (changed) {
changedDescription
TRUEnever evaluated
FALSEnever evaluated
0
667 itm->children = lst;-
668 changePersistentIndexList(oldPersistentIndexes, newPersistentIndexes);-
669 emit layoutChanged();-
670 }
never executed: end of block
0
671}
never executed: end of block
0
672-
673/*!-
674 \internal-
675-
676 Returns \c true if the value of the \a left item is-
677 less than the value of the \a right item.-
678-
679 Used by the sorting functions.-
680*/-
681-
682bool QTreeModel::itemLessThan(const QPair<QTreeWidgetItem*,int> &left,-
683 const QPair<QTreeWidgetItem*,int> &right)-
684{-
685 return *(left.first) < *(right.first);
never executed: return *(left.first) < *(right.first);
0
686}-
687-
688/*!-
689 \internal-
690-
691 Returns \c true if the value of the \a left item is-
692 greater than the value of the \a right item.-
693-
694 Used by the sorting functions.-
695*/-
696-
697bool QTreeModel::itemGreaterThan(const QPair<QTreeWidgetItem*,int> &left,-
698 const QPair<QTreeWidgetItem*,int> &right)-
699{-
700 return *(right.first) < *(left.first);
never executed: return *(right.first) < *(left.first);
0
701}-
702-
703/*!-
704 \internal-
705*/-
706QList<QTreeWidgetItem*>::iterator QTreeModel::sortedInsertionIterator(-
707 const QList<QTreeWidgetItem*>::iterator &begin,-
708 const QList<QTreeWidgetItem*>::iterator &end,-
709 Qt::SortOrder order, QTreeWidgetItem *item)-
710{-
711 if (order == Qt::AscendingOrder)
order == Qt::AscendingOrderDescription
TRUEnever evaluated
FALSEnever evaluated
0
712 return std::lower_bound(begin, end, item, QTreeModelLessThan());
never executed: return std::lower_bound(begin, end, item, QTreeModelLessThan());
0
713 return std::lower_bound(begin, end, item, QTreeModelGreaterThan());
never executed: return std::lower_bound(begin, end, item, QTreeModelGreaterThan());
0
714}-
715-
716QStringList QTreeModel::mimeTypes() const-
717{-
718 return view()->mimeTypes();
never executed: return view()->mimeTypes();
0
719}-
720-
721QMimeData *QTreeModel::internalMimeData() const-
722{-
723 return QAbstractItemModel::mimeData(cachedIndexes);
never executed: return QAbstractItemModel::mimeData(cachedIndexes);
0
724}-
725-
726QMimeData *QTreeModel::mimeData(const QModelIndexList &indexes) const-
727{-
728 QList<QTreeWidgetItem*> items;-
729 for (int i = 0; i < indexes.count(); ++i) {
i < indexes.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
730 if (indexes.at(i).column() == 0) // only one item per row
indexes.at(i).column() == 0Description
TRUEnever evaluated
FALSEnever evaluated
0
731 items << item(indexes.at(i));
never executed: items << item(indexes.at(i));
0
732 }
never executed: end of block
0
733-
734 // cachedIndexes is a little hack to avoid copying from QModelIndexList to-
735 // QList<QTreeWidgetItem*> and back again in the view-
736 cachedIndexes = indexes;-
737 QMimeData *mimeData = view()->mimeData(items);-
738 cachedIndexes.clear();-
739 return mimeData;
never executed: return mimeData;
0
740}-
741-
742bool QTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action,-
743 int row, int column, const QModelIndex &parent)-
744{-
745 if (row == -1 && column == -1)
row == -1Description
TRUEnever evaluated
FALSEnever evaluated
column == -1Description
TRUEnever evaluated
FALSEnever evaluated
0
746 row = rowCount(parent); // append
never executed: row = rowCount(parent);
0
747 return view()->dropMimeData(item(parent), row, data, action);
never executed: return view()->dropMimeData(item(parent), row, data, action);
0
748}-
749-
750Qt::DropActions QTreeModel::supportedDropActions() const-
751{-
752 return view()->supportedDropActions();
never executed: return view()->supportedDropActions();
0
753}-
754-
755void QTreeModel::itemChanged(QTreeWidgetItem *item)-
756{-
757 SkipSorting skipSorting(this); //this is kind of wrong, but not doing this would kill performence-
758 QModelIndex left = index(item, 0);-
759 QModelIndex right = index(item, item->columnCount() - 1);-
760 emit dataChanged(left, right);-
761}
never executed: end of block
0
762-
763bool QTreeModel::isChanging() const-
764{-
765 Q_D(const QTreeModel);-
766 return !d->changes.isEmpty();
never executed: return !d->changes.isEmpty();
0
767}-
768-
769/*!-
770 \internal-
771 Emits the dataChanged() signal for the given \a item.-
772 if column is -1 then all columns have changed-
773*/-
774-
775void QTreeModel::emitDataChanged(QTreeWidgetItem *item, int column)-
776{-
777 if (signalsBlocked())
signalsBlocked()Description
TRUEnever evaluated
FALSEnever evaluated
0
778 return;
never executed: return;
0
779-
780 if (headerItem == item && column < item->columnCount()) {
headerItem == itemDescription
TRUEnever evaluated
FALSEnever evaluated
column < item->columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
781 if (column == -1)
column == -1Description
TRUEnever evaluated
FALSEnever evaluated
0
782 emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
never executed: headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
0
783 else-
784 emit headerDataChanged(Qt::Horizontal, column, column);
never executed: headerDataChanged(Qt::Horizontal, column, column);
0
785 return;
never executed: return;
0
786 }-
787-
788 SkipSorting skipSorting(this); //This is a little bit wrong, but not doing it would kill performence-
789-
790 QModelIndex bottomRight, topLeft;-
791 if (column == -1) {
column == -1Description
TRUEnever evaluated
FALSEnever evaluated
0
792 topLeft = index(item, 0);-
793 bottomRight = createIndex(topLeft.row(), columnCount() - 1, item);-
794 } else {
never executed: end of block
0
795 topLeft = index(item, column);-
796 bottomRight = topLeft;-
797 }
never executed: end of block
0
798 emit dataChanged(topLeft, bottomRight);-
799}
never executed: end of block
0
800-
801void QTreeModel::beginInsertItems(QTreeWidgetItem *parent, int row, int count)-
802{-
803 QModelIndex par = index(parent, 0);-
804 beginInsertRows(par, row, row + count - 1);-
805}
never executed: end of block
0
806-
807void QTreeModel::endInsertItems()-
808{-
809 endInsertRows();-
810}
never executed: end of block
0
811-
812void QTreeModel::beginRemoveItems(QTreeWidgetItem *parent, int row, int count)-
813{-
814 Q_ASSERT(row >= 0);-
815 Q_ASSERT(count > 0);-
816 beginRemoveRows(index(parent, 0), row, row + count - 1);-
817 if (!parent)
!parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
818 parent = rootItem;
never executed: parent = rootItem;
0
819 // now update the iterators-
820 for (int i = 0; i < iterators.count(); ++i) {
i < iterators.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
821 for (int j = 0; j < count; j++) {
j < countDescription
TRUEnever evaluated
FALSEnever evaluated
0
822 QTreeWidgetItem *c = parent->child(row + j);-
823 iterators[i]->d_func()->ensureValidIterator(c);-
824 }
never executed: end of block
0
825 }
never executed: end of block
0
826}
never executed: end of block
0
827-
828void QTreeModel::endRemoveItems()-
829{-
830 endRemoveRows();-
831}
never executed: end of block
0
832-
833void QTreeModel::sortItems(QList<QTreeWidgetItem*> *items, int column, Qt::SortOrder order)-
834{-
835 // see QTreeViewItem::operator<-
836 Q_UNUSED(column);-
837 if (isChanging())
isChanging()Description
TRUEnever evaluated
FALSEnever evaluated
0
838 return;
never executed: return;
0
839-
840 // store the original order of indexes-
841 QVector< QPair<QTreeWidgetItem*,int> > sorting(items->count());-
842 for (int i = 0; i < sorting.count(); ++i) {
i < sorting.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
843 sorting[i].first = items->at(i);-
844 sorting[i].second = i;-
845 }
never executed: end of block
0
846-
847 // do the sorting-
848 LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);
order == Qt::AscendingOrderDescription
TRUEnever evaluated
FALSEnever evaluated
0
849 std::stable_sort(sorting.begin(), sorting.end(), compare);-
850-
851 QModelIndexList fromList;-
852 QModelIndexList toList;-
853 int colCount = columnCount();-
854 for (int r = 0; r < sorting.count(); ++r) {
r < sorting.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
855 int oldRow = sorting.at(r).second;-
856 if (oldRow == r)
oldRow == rDescription
TRUEnever evaluated
FALSEnever evaluated
0
857 continue;
never executed: continue;
0
858 QTreeWidgetItem *item = sorting.at(r).first;-
859 items->replace(r, item);-
860 for (int c = 0; c < colCount; ++c) {
c < colCountDescription
TRUEnever evaluated
FALSEnever evaluated
0
861 QModelIndex from = createIndex(oldRow, c, item);-
862 if (static_cast<QAbstractItemModelPrivate *>(d_ptr.data())->persistent.indexes.contains(from)) {
static_cast<QA...contains(from)Description
TRUEnever evaluated
FALSEnever evaluated
0
863 QModelIndex to = createIndex(r, c, item);-
864 fromList << from;-
865 toList << to;-
866 }
never executed: end of block
0
867 }
never executed: end of block
0
868 }
never executed: end of block
0
869 changePersistentIndexList(fromList, toList);-
870}
never executed: end of block
0
871-
872void QTreeModel::timerEvent(QTimerEvent *ev)-
873{-
874 if (ev->timerId() == sortPendingTimer.timerId()) {
ev->timerId() ...imer.timerId()Description
TRUEnever evaluated
FALSEnever evaluated
0
875 executePendingSort();-
876 } else {
never executed: end of block
0
877 QAbstractItemModel::timerEvent(ev);-
878 }
never executed: end of block
0
879}-
880-
881/*!-
882 \class QTreeWidgetItem-
883-
884 \brief The QTreeWidgetItem class provides an item for use with the-
885 QTreeWidget convenience class.-
886-
887 \ingroup model-view-
888 \inmodule QtWidgets-
889-
890 Tree widget items are used to hold rows of information for tree widgets.-
891 Rows usually contain several columns of data, each of which can contain-
892 a text label and an icon.-
893-
894 The QTreeWidgetItem class is a convenience class that replaces the-
895 QListViewItem class in Qt 3. It provides an item for use with-
896 the QTreeWidget class.-
897-
898 Items are usually constructed with a parent that is either a QTreeWidget-
899 (for top-level items) or a QTreeWidgetItem (for items on lower levels of-
900 the tree). For example, the following code constructs a top-level item-
901 to represent cities of the world, and adds a entry for Oslo as a child-
902 item:-
903-
904 \snippet qtreewidget-using/mainwindow.cpp 3-
905-
906 Items can be added in a particular order by specifying the item they-
907 follow when they are constructed:-
908-
909 \snippet qtreewidget-using/mainwindow.cpp 5-
910-
911 Each column in an item can have its own background brush which is set with-
912 the setBackground() function. The current background brush can be-
913 found with background().-
914 The text label for each column can be rendered with its own font and brush.-
915 These are specified with the setFont() and setForeground() functions,-
916 and read with font() and foreground().-
917-
918 The main difference between top-level items and those in lower levels of-
919 the tree is that a top-level item has no parent(). This information-
920 can be used to tell the difference between items, and is useful to know-
921 when inserting and removing items from the tree.-
922 Children of an item can be removed with takeChild() and inserted at a-
923 given index in the list of children with the insertChild() function.-
924-
925 By default, items are enabled, selectable, checkable, and can be the source-
926 of a drag and drop operation.-
927 Each item's flags can be changed by calling setFlags() with the appropriate-
928 value (see \l{Qt::ItemFlags}). Checkable items can be checked and unchecked-
929 with the setCheckState() function. The corresponding checkState() function-
930 indicates whether the item is currently checked.-
931-
932 \section1 Subclassing-
933-
934 When subclassing QTreeWidgetItem to provide custom items, it is possible to-
935 define new types for them so that they can be distinguished from standard-
936 items. The constructors for subclasses that require this feature need to-
937 call the base class constructor with a new type value equal to or greater-
938 than \l UserType.-
939-
940 \sa QTreeWidget, QTreeWidgetItemIterator, {Model/View Programming},-
941 QListWidgetItem, QTableWidgetItem-
942*/-
943-
944/*!-
945 \enum QTreeWidgetItem::ItemType-
946-
947 This enum describes the types that are used to describe tree widget items.-
948-
949 \value Type The default type for tree widget items.-
950 \value UserType The minimum value for custom types. Values below UserType are-
951 reserved by Qt.-
952-
953 You can define new user types in QTreeWidgetItem subclasses to ensure that-
954 custom items are treated specially; for example, when items are sorted.-
955-
956 \sa type()-
957*/-
958-
959/*!-
960 \fn int QTreeWidgetItem::type() const-
961-
962 Returns the type passed to the QTreeWidgetItem constructor.-
963*/-
964-
965/*!-
966 \fn void QTreeWidgetItem::sortChildren(int column, Qt::SortOrder order)-
967 \since 4.2-
968-
969 Sorts the children of the item using the given \a order,-
970 by the values in the given \a column.-
971-
972 \note This function does nothing if the item is not associated with a-
973 QTreeWidget.-
974*/-
975-
976/*!-
977 \fn QTreeWidget *QTreeWidgetItem::treeWidget() const-
978-
979 Returns the tree widget that contains the item.-
980*/-
981-
982/*!-
983 \fn void QTreeWidgetItem::setSelected(bool select)-
984 \since 4.2-
985-
986 Sets the selected state of the item to \a select.-
987-
988 \sa isSelected()-
989-
990*/-
991-
992/*!-
993 \fn bool QTreeWidgetItem::isSelected() const-
994 \since 4.2-
995-
996 Returns \c true if the item is selected, otherwise returns \c false.-
997-
998 \sa setSelected()-
999*/-
1000-
1001/*!-
1002 \fn void QTreeWidgetItem::setHidden(bool hide)-
1003 \since 4.2-
1004-
1005 Hides the item if \a hide is true, otherwise shows the item.-
1006 \note A call to this function has no effect if the item is not currently in a view. In particular,-
1007 calling \c setHidden(true) on an item and only then adding it to a view will result in-
1008 a visible item.-
1009-
1010 \sa isHidden()-
1011*/-
1012-
1013/*!-
1014 \fn bool QTreeWidgetItem::isHidden() const-
1015 \since 4.2-
1016-
1017 Returns \c true if the item is hidden, otherwise returns \c false.-
1018-
1019 \sa setHidden()-
1020*/-
1021-
1022/*!-
1023 \fn void QTreeWidgetItem::setExpanded(bool expand)-
1024 \since 4.2-
1025-
1026 Expands the item if \a expand is true, otherwise collapses the item.-
1027 \warning The QTreeWidgetItem must be added to the QTreeWidget before calling this function.-
1028-
1029 \sa isExpanded()-
1030*/-
1031-
1032/*!-
1033 \fn bool QTreeWidgetItem::isExpanded() const-
1034 \since 4.2-
1035-
1036 Returns \c true if the item is expanded, otherwise returns \c false.-
1037-
1038 \sa setExpanded()-
1039*/-
1040-
1041/*!-
1042 \fn void QTreeWidgetItem::setFirstColumnSpanned(bool span)-
1043 \since 4.3-
1044-
1045 Sets the first section to span all columns if \a span is true;-
1046 otherwise all item sections are shown.-
1047-
1048 \sa isFirstColumnSpanned()-
1049*/-
1050-
1051/*!-
1052 \fn bool QTreeWidgetItem::isFirstColumnSpanned() const-
1053 \since 4.3-
1054-
1055 Returns \c true if the item is spanning all the columns in a row; otherwise returns \c false.-
1056-
1057 \sa setFirstColumnSpanned()-
1058*/-
1059-
1060/*!-
1061 \fn QString QTreeWidgetItem::text(int column) const-
1062-
1063 Returns the text in the specified \a column.-
1064-
1065 \sa setText()-
1066*/-
1067-
1068/*!-
1069 \fn void QTreeWidgetItem::setText(int column, const QString &text)-
1070-
1071 Sets the text to be displayed in the given \a column to the given \a text.-
1072-
1073 \sa text(), setFont(), setForeground()-
1074*/-
1075-
1076/*!-
1077 \fn QIcon QTreeWidgetItem::icon(int column) const-
1078-
1079 Returns the icon that is displayed in the specified \a column.-
1080-
1081 \sa setIcon(), {QAbstractItemView::iconSize}{iconSize}-
1082*/-
1083-
1084/*!-
1085 \fn void QTreeWidgetItem::setIcon(int column, const QIcon &icon)-
1086-
1087 Sets the icon to be displayed in the given \a column to \a icon.-
1088-
1089 \sa icon(), setText(), {QAbstractItemView::iconSize}{iconSize}-
1090*/-
1091-
1092/*!-
1093 \fn QString QTreeWidgetItem::statusTip(int column) const-
1094-
1095 Returns the status tip for the contents of the given \a column.-
1096-
1097 \sa setStatusTip()-
1098*/-
1099-
1100/*!-
1101 \fn void QTreeWidgetItem::setStatusTip(int column, const QString &statusTip)-
1102-
1103 Sets the status tip for the given \a column to the given \a statusTip.-
1104 QTreeWidget mouse tracking needs to be enabled for this feature to work.-
1105-
1106 \sa statusTip(), setToolTip(), setWhatsThis()-
1107*/-
1108-
1109/*!-
1110 \fn QString QTreeWidgetItem::toolTip(int column) const-
1111-
1112 Returns the tool tip for the given \a column.-
1113-
1114 \sa setToolTip()-
1115*/-
1116-
1117/*!-
1118 \fn void QTreeWidgetItem::setToolTip(int column, const QString &toolTip)-
1119-
1120 Sets the tooltip for the given \a column to \a toolTip.-
1121-
1122 \sa toolTip(), setStatusTip(), setWhatsThis()-
1123*/-
1124-
1125/*!-
1126 \fn QString QTreeWidgetItem::whatsThis(int column) const-
1127-
1128 Returns the "What's This?" help for the contents of the given \a column.-
1129-
1130 \sa setWhatsThis()-
1131*/-
1132-
1133/*!-
1134 \fn void QTreeWidgetItem::setWhatsThis(int column, const QString &whatsThis)-
1135-
1136 Sets the "What's This?" help for the given \a column to \a whatsThis.-
1137-
1138 \sa whatsThis(), setStatusTip(), setToolTip()-
1139*/-
1140-
1141/*!-
1142 \fn QFont QTreeWidgetItem::font(int column) const-
1143-
1144 Returns the font used to render the text in the specified \a column.-
1145-
1146 \sa setFont()-
1147*/-
1148-
1149/*!-
1150 \fn void QTreeWidgetItem::setFont(int column, const QFont &font)-
1151-
1152 Sets the font used to display the text in the given \a column to the given-
1153 \a font.-
1154-
1155 \sa font(), setText(), setForeground()-
1156*/-
1157-
1158/*!-
1159 \fn QColor QTreeWidgetItem::backgroundColor(int column) const-
1160 \obsolete-
1161-
1162 This function is deprecated. Use background() instead.-
1163*/-
1164-
1165/*!-
1166 \fn void QTreeWidgetItem::setBackgroundColor(int column, const QColor &color)-
1167 \obsolete-
1168-
1169 This function is deprecated. Use setBackground() instead.-
1170*/-
1171-
1172/*!-
1173 \fn QBrush QTreeWidgetItem::background(int column) const-
1174 \since 4.2-
1175-
1176 Returns the brush used to render the background of the specified \a column.-
1177-
1178 \sa foreground()-
1179*/-
1180-
1181/*!-
1182 \fn void QTreeWidgetItem::setBackground(int column, const QBrush &brush)-
1183 \since 4.2-
1184-
1185 Sets the background brush of the label in the given \a column to the-
1186 specified \a brush.-
1187-
1188 \sa setForeground()-
1189*/-
1190-
1191/*!-
1192 \fn QColor QTreeWidgetItem::textColor(int column) const-
1193 \obsolete-
1194-
1195 This function is deprecated. Use foreground() instead.-
1196*/-
1197-
1198/*!-
1199 \fn void QTreeWidgetItem::setTextColor(int column, const QColor &color)-
1200 \obsolete-
1201-
1202 This function is deprecated. Use setForeground() instead.-
1203*/-
1204-
1205/*!-
1206 \fn QBrush QTreeWidgetItem::foreground(int column) const-
1207 \since 4.2-
1208-
1209 Returns the brush used to render the foreground (e.g. text) of the-
1210 specified \a column.-
1211-
1212 \sa background()-
1213*/-
1214-
1215/*!-
1216 \fn void QTreeWidgetItem::setForeground(int column, const QBrush &brush)-
1217 \since 4.2-
1218-
1219 Sets the foreground brush of the label in the given \a column to the-
1220 specified \a brush.-
1221-
1222 \sa setBackground()-
1223*/-
1224-
1225/*!-
1226 \fn Qt::CheckState QTreeWidgetItem::checkState(int column) const-
1227-
1228 Returns the check state of the label in the given \a column.-
1229-
1230 \sa Qt::CheckState-
1231*/-
1232-
1233/*!-
1234 \fn void QTreeWidgetItem::setCheckState(int column, Qt::CheckState state)-
1235-
1236 Sets the item in the given \a column check state to be \a state.-
1237-
1238 \sa checkState()-
1239*/-
1240-
1241/*!-
1242 \fn QSize QTreeWidgetItem::sizeHint(int column) const-
1243 \since 4.1-
1244-
1245 Returns the size hint set for the tree item in the given-
1246 \a column (see \l{QSize}).-
1247*/-
1248-
1249/*!-
1250 \fn void QTreeWidgetItem::setSizeHint(int column, const QSize &size)-
1251 \since 4.1-
1252-
1253 Sets the size hint for the tree item in the given \a column to be \a size.-
1254 If no size hint is set, the item delegate will compute the size hint based-
1255 on the item data.-
1256*/-
1257-
1258/*!-
1259 \fn QTreeWidgetItem *QTreeWidgetItem::parent() const-
1260-
1261 Returns the item's parent.-
1262-
1263 \sa child()-
1264*/-
1265-
1266/*!-
1267 \fn QTreeWidgetItem *QTreeWidgetItem::child(int index) const-
1268-
1269 Returns the item at the given \a index in the list of the item's children.-
1270-
1271 \sa parent()-
1272*/-
1273-
1274/*!-
1275 \fn int QTreeWidgetItem::childCount() const-
1276-
1277 Returns the number of child items.-
1278*/-
1279-
1280/*!-
1281 \fn int QTreeWidgetItem::columnCount() const-
1282-
1283 Returns the number of columns in the item.-
1284*/-
1285-
1286/*!-
1287 \fn int QTreeWidgetItem::textAlignment(int column) const-
1288-
1289 Returns the text alignment for the label in the given \a column-
1290 (see \l{Qt::AlignmentFlag}).-
1291*/-
1292-
1293/*!-
1294 \fn void QTreeWidgetItem::setTextAlignment(int column, int alignment)-
1295-
1296 Sets the text alignment for the label in the given \a column to-
1297 the \a alignment specified (see \l{Qt::AlignmentFlag}).-
1298*/-
1299-
1300/*!-
1301 \fn int QTreeWidgetItem::indexOfChild(QTreeWidgetItem *child) const-
1302-
1303 Returns the index of the given \a child in the item's list of children.-
1304*/-
1305-
1306/*!-
1307 Constructs a tree widget item of the specified \a type. The item-
1308 must be inserted into a tree widget.-
1309-
1310 \sa type()-
1311*/-
1312QTreeWidgetItem::QTreeWidgetItem(int type)-
1313 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1314 itemFlags(Qt::ItemIsSelectable-
1315 |Qt::ItemIsUserCheckable-
1316 |Qt::ItemIsEnabled-
1317 |Qt::ItemIsDragEnabled-
1318 |Qt::ItemIsDropEnabled)-
1319{-
1320}
never executed: end of block
0
1321-
1322-
1323/*!-
1324 Constructs a tree widget item of the specified \a type. The item-
1325 must be inserted into a tree widget.-
1326 The given list of \a strings will be set as the item text for each-
1327 column in the item.-
1328-
1329 \sa type()-
1330*/-
1331QTreeWidgetItem::QTreeWidgetItem(const QStringList &strings, int type)-
1332 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1333 itemFlags(Qt::ItemIsSelectable-
1334 |Qt::ItemIsUserCheckable-
1335 |Qt::ItemIsEnabled-
1336 |Qt::ItemIsDragEnabled-
1337 |Qt::ItemIsDropEnabled)-
1338{-
1339 for (int i = 0; i < strings.count(); ++i)
i < strings.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1340 setText(i, strings.at(i));
never executed: setText(i, strings.at(i));
0
1341}
never executed: end of block
0
1342-
1343/*!-
1344 \fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, int type)-
1345-
1346 Constructs a tree widget item of the specified \a type and appends it-
1347 to the items in the given \a parent.-
1348-
1349 \sa type()-
1350*/-
1351-
1352QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, int type)-
1353 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1354 itemFlags(Qt::ItemIsSelectable-
1355 |Qt::ItemIsUserCheckable-
1356 |Qt::ItemIsEnabled-
1357 |Qt::ItemIsDragEnabled-
1358 |Qt::ItemIsDropEnabled)-
1359{-
1360 if (view && view->model()) {
viewDescription
TRUEnever evaluated
FALSEnever evaluated
view->model()Description
TRUEnever evaluated
FALSEnever evaluated
0
1361 QTreeModel *model = qobject_cast<QTreeModel*>(view->model());-
1362 model->rootItem->addChild(this);-
1363 values.reserve(model->headerItem->columnCount());-
1364 }
never executed: end of block
0
1365}
never executed: end of block
0
1366-
1367/*!-
1368 \fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, const QStringList &strings, int type)-
1369-
1370 Constructs a tree widget item of the specified \a type and appends it-
1371 to the items in the given \a parent. The given list of \a strings will be set as-
1372 the item text for each column in the item.-
1373-
1374 \sa type()-
1375*/-
1376-
1377QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, const QStringList &strings, int type)-
1378 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1379 itemFlags(Qt::ItemIsSelectable-
1380 |Qt::ItemIsUserCheckable-
1381 |Qt::ItemIsEnabled-
1382 |Qt::ItemIsDragEnabled-
1383 |Qt::ItemIsDropEnabled)-
1384{-
1385 for (int i = 0; i < strings.count(); ++i)
i < strings.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1386 setText(i, strings.at(i));
never executed: setText(i, strings.at(i));
0
1387 if (view && view->model()) {
viewDescription
TRUEnever evaluated
FALSEnever evaluated
view->model()Description
TRUEnever evaluated
FALSEnever evaluated
0
1388 QTreeModel *model = qobject_cast<QTreeModel*>(view->model());-
1389 model->rootItem->addChild(this);-
1390 values.reserve(model->headerItem->columnCount());-
1391 }
never executed: end of block
0
1392}
never executed: end of block
0
1393-
1394/*!-
1395 \fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, QTreeWidgetItem *preceding, int type)-
1396-
1397 Constructs a tree widget item of the specified \a type and inserts it into-
1398 the given \a parent after the \a preceding item.-
1399-
1400 \sa type()-
1401*/-
1402QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, QTreeWidgetItem *after, int type)-
1403 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1404 itemFlags(Qt::ItemIsSelectable-
1405 |Qt::ItemIsUserCheckable-
1406 |Qt::ItemIsEnabled-
1407 |Qt::ItemIsDragEnabled-
1408 |Qt::ItemIsDropEnabled)-
1409{-
1410 if (view) {
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1411 QTreeModel *model = qobject_cast<QTreeModel*>(view->model());-
1412 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1413 int i = model->rootItem->children.indexOf(after) + 1;-
1414 model->rootItem->insertChild(i, this);-
1415 values.reserve(model->headerItem->columnCount());-
1416 }
never executed: end of block
0
1417 }
never executed: end of block
0
1418}
never executed: end of block
0
1419-
1420/*!-
1421 Constructs a tree widget item and append it to the given \a parent.-
1422-
1423 \sa type()-
1424*/-
1425QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, int type)-
1426 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1427 itemFlags(Qt::ItemIsSelectable-
1428 |Qt::ItemIsUserCheckable-
1429 |Qt::ItemIsEnabled-
1430 |Qt::ItemIsDragEnabled-
1431 |Qt::ItemIsDropEnabled)-
1432{-
1433 if (parent)
parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
1434 parent->addChild(this);
never executed: parent->addChild(this);
0
1435}
never executed: end of block
0
1436-
1437/*!-
1438 Constructs a tree widget item and append it to the given \a parent.-
1439 The given list of \a strings will be set as the item text for each column in the item.-
1440-
1441 \sa type()-
1442*/-
1443QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, const QStringList &strings, int type)-
1444 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1445 itemFlags(Qt::ItemIsSelectable-
1446 |Qt::ItemIsUserCheckable-
1447 |Qt::ItemIsEnabled-
1448 |Qt::ItemIsDragEnabled-
1449 |Qt::ItemIsDropEnabled)-
1450{-
1451 for (int i = 0; i < strings.count(); ++i)
i < strings.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1452 setText(i, strings.at(i));
never executed: setText(i, strings.at(i));
0
1453 if (parent)
parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
1454 parent->addChild(this);
never executed: parent->addChild(this);
0
1455}
never executed: end of block
0
1456-
1457/*!-
1458 \fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *preceding, int type)-
1459-
1460 Constructs a tree widget item of the specified \a type that is inserted-
1461 into the \a parent after the \a preceding child item.-
1462-
1463 \sa type()-
1464*/-
1465QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *after, int type)-
1466 : rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),-
1467 itemFlags(Qt::ItemIsSelectable-
1468 |Qt::ItemIsUserCheckable-
1469 |Qt::ItemIsEnabled-
1470 |Qt::ItemIsDragEnabled-
1471 |Qt::ItemIsDropEnabled)-
1472{-
1473 if (parent) {
parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
1474 int i = parent->children.indexOf(after) + 1;-
1475 parent->insertChild(i, this);-
1476 }
never executed: end of block
0
1477}
never executed: end of block
0
1478-
1479/*!-
1480 Destroys this tree widget item.-
1481-
1482 The item will be removed from \l{QTreeWidget}s to which it has-
1483 been added. This makes it safe to delete an item at any time.-
1484-
1485*/-
1486-
1487QTreeWidgetItem::~QTreeWidgetItem()-
1488{-
1489 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1490 bool wasSkipSort = false;-
1491 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1492 wasSkipSort = model->skipPendingSort;-
1493 model->skipPendingSort = true;-
1494 }
never executed: end of block
0
1495 if (par) {
parDescription
TRUEnever evaluated
FALSEnever evaluated
0
1496 int i = par->children.indexOf(this);-
1497 if (i >= 0) {
i >= 0Description
TRUEnever evaluated
FALSEnever evaluated
0
1498 if (model) model->beginRemoveItems(par, i, 1);
never executed: model->beginRemoveItems(par, i, 1);
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1499 // users _could_ do changes when connected to rowsAboutToBeRemoved,-
1500 // so we check again to make sure 'i' is valid-
1501 if (!par->children.isEmpty() && par->children.at(i) == this)
!par->children.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
par->children.at(i) == thisDescription
TRUEnever evaluated
FALSEnever evaluated
0
1502 par->children.takeAt(i);
never executed: par->children.takeAt(i);
0
1503 if (model) model->endRemoveItems();
never executed: model->endRemoveItems();
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1504 }
never executed: end of block
0
1505 } else if (model) {
never executed: end of block
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1506 if (this == model->headerItem) {
this == model->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
1507 model->headerItem = 0;-
1508 } else {
never executed: end of block
0
1509 int i = model->rootItem->children.indexOf(this);-
1510 if (i >= 0) {
i >= 0Description
TRUEnever evaluated
FALSEnever evaluated
0
1511 model->beginRemoveItems(0, i, 1);-
1512 // users _could_ do changes when connected to rowsAboutToBeRemoved,-
1513 // so we check again to make sure 'i' is valid-
1514 if (!model->rootItem->children.isEmpty() && model->rootItem->children.at(i) == this)
!model->rootIt...dren.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
model->rootIte....at(i) == thisDescription
TRUEnever evaluated
FALSEnever evaluated
0
1515 model->rootItem->children.takeAt(i);
never executed: model->rootItem->children.takeAt(i);
0
1516 model->endRemoveItems();-
1517 }
never executed: end of block
0
1518 }
never executed: end of block
0
1519 }-
1520 // at this point the persistent indexes for the children should also be invalidated-
1521 // since we invalidated the parent-
1522 for (int i = 0; i < children.count(); ++i) {
i < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1523 QTreeWidgetItem *child = children.at(i);-
1524 // make sure the child does not try to remove itself from our children list-
1525 child->par = 0;-
1526 // make sure the child does not try to remove itself from the top level list-
1527 child->view = 0;-
1528 delete child;-
1529 }
never executed: end of block
0
1530-
1531 children.clear();-
1532 delete d;-
1533 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1534 model->skipPendingSort = wasSkipSort;-
1535 }
never executed: end of block
0
1536}
never executed: end of block
0
1537-
1538/*!-
1539 Creates a deep copy of the item and of its children.-
1540*/-
1541QTreeWidgetItem *QTreeWidgetItem::clone() const-
1542{-
1543 QTreeWidgetItem *copy = 0;-
1544-
1545 QStack<const QTreeWidgetItem*> stack;-
1546 QStack<QTreeWidgetItem*> parentStack;-
1547 stack.push(this);-
1548 parentStack.push(0);-
1549-
1550 QTreeWidgetItem *root = 0;-
1551 const QTreeWidgetItem *item = 0;-
1552 QTreeWidgetItem *parent = 0;-
1553 while (!stack.isEmpty()) {
!stack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
1554 // get current item, and copied parent-
1555 item = stack.pop();-
1556 parent = parentStack.pop();-
1557-
1558 // copy item-
1559 copy = new QTreeWidgetItem(*item);-
1560 if (!root)
!rootDescription
TRUEnever evaluated
FALSEnever evaluated
0
1561 root = copy;
never executed: root = copy;
0
1562-
1563 // set parent and add to parents children list-
1564 if (parent) {
parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
1565 copy->par = parent;-
1566 parent->children.insert(0, copy);-
1567 }
never executed: end of block
0
1568-
1569 for (int i = 0; i < item->childCount(); ++i) {
i < item->childCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
1570 stack.push(item->child(i));-
1571 parentStack.push(copy);-
1572 }
never executed: end of block
0
1573 }
never executed: end of block
0
1574 return root;
never executed: return root;
0
1575}-
1576-
1577/*!-
1578 Sets the item indicator \a policy. This policy decides when the-
1579 tree branch expand/collapse indicator is shown.-
1580 The default value is ShowForChildren.-
1581-
1582 \sa childIndicatorPolicy()-
1583*/-
1584void QTreeWidgetItem::setChildIndicatorPolicy(QTreeWidgetItem::ChildIndicatorPolicy policy)-
1585{-
1586 if (d->policy == policy)
d->policy == policyDescription
TRUEnever evaluated
FALSEnever evaluated
0
1587 return;
never executed: return;
0
1588 d->policy = policy;-
1589-
1590 if (!view)
!viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1591 return;
never executed: return;
0
1592-
1593 view->scheduleDelayedItemsLayout();-
1594}
never executed: end of block
0
1595-
1596/*!-
1597 Returns the item indicator policy. This policy decides when the-
1598 tree branch expand/collapse indicator is shown.-
1599-
1600 \sa setChildIndicatorPolicy()-
1601*/-
1602QTreeWidgetItem::ChildIndicatorPolicy QTreeWidgetItem::childIndicatorPolicy() const-
1603{-
1604 return d->policy;
never executed: return d->policy;
0
1605}-
1606-
1607/*!-
1608 \fn void QTreeWidgetItem::setFlags(Qt::ItemFlags flags)-
1609-
1610 Sets the flags for the item to the given \a flags. These determine whether-
1611 the item can be selected or modified. This is often used to disable an item.-
1612-
1613 \sa flags()-
1614*/-
1615void QTreeWidgetItem::setFlags(Qt::ItemFlags flags)-
1616{-
1617 const bool enable = (flags & Qt::ItemIsEnabled);-
1618 const bool changedState = bool(itemFlags & Qt::ItemIsEnabled) != enable;-
1619 const bool changedExplicit = d->disabled != !enable;-
1620-
1621 d->disabled = !enable;-
1622-
1623 if (enable && par && !(par->itemFlags & Qt::ItemIsEnabled)) // inherit from parent
enableDescription
TRUEnever evaluated
FALSEnever evaluated
parDescription
TRUEnever evaluated
FALSEnever evaluated
!(par->itemFla...ItemIsEnabled)Description
TRUEnever evaluated
FALSEnever evaluated
0
1624 itemFlags = flags & ~Qt::ItemIsEnabled;
never executed: itemFlags = flags & ~Qt::ItemIsEnabled;
0
1625 else // this item is explicitly disabled or has no parent-
1626 itemFlags = flags;
never executed: itemFlags = flags;
0
1627-
1628 if (changedState && changedExplicit) { // if the propagate the change to the children
changedStateDescription
TRUEnever evaluated
FALSEnever evaluated
changedExplicitDescription
TRUEnever evaluated
FALSEnever evaluated
0
1629 QStack<QTreeWidgetItem*> parents;-
1630 parents.push(this);-
1631 while (!parents.isEmpty()) {
!parents.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
1632 QTreeWidgetItem *parent = parents.pop();-
1633 for (int i = 0; i < parent->children.count(); ++i) {
i < parent->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1634 QTreeWidgetItem *child = parent->children.at(i);-
1635 if (!child->d->disabled) { // if not explicitly disabled
!child->d->disabledDescription
TRUEnever evaluated
FALSEnever evaluated
0
1636 parents.push(child);-
1637 if (enable)
enableDescription
TRUEnever evaluated
FALSEnever evaluated
0
1638 child->itemFlags = child->itemFlags | Qt::ItemIsEnabled;
never executed: child->itemFlags = child->itemFlags | Qt::ItemIsEnabled;
0
1639 else-
1640 child->itemFlags = child->itemFlags & ~Qt::ItemIsEnabled;
never executed: child->itemFlags = child->itemFlags & ~Qt::ItemIsEnabled;
0
1641 child->itemChanged(); // ### we may want to optimize this-
1642 }
never executed: end of block
0
1643 }
never executed: end of block
0
1644 }
never executed: end of block
0
1645 }
never executed: end of block
0
1646 itemChanged();-
1647}
never executed: end of block
0
1648-
1649void QTreeWidgetItemPrivate::propagateDisabled(QTreeWidgetItem *item)-
1650{-
1651 Q_ASSERT(item);-
1652 const bool enable = item->par ? (item->par->itemFlags.testFlag(Qt::ItemIsEnabled)) : true;
item->parDescription
TRUEnever evaluated
FALSEnever evaluated
0
1653-
1654 QStack<QTreeWidgetItem*> parents;-
1655 parents.push(item);-
1656 while (!parents.isEmpty()) {
!parents.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
1657 QTreeWidgetItem *parent = parents.pop();-
1658 if (!parent->d->disabled) { // if not explicitly disabled
!parent->d->disabledDescription
TRUEnever evaluated
FALSEnever evaluated
0
1659 Qt::ItemFlags oldFlags = parent->itemFlags;-
1660 if (enable)
enableDescription
TRUEnever evaluated
FALSEnever evaluated
0
1661 parent->itemFlags = parent->itemFlags | Qt::ItemIsEnabled;
never executed: parent->itemFlags = parent->itemFlags | Qt::ItemIsEnabled;
0
1662 else-
1663 parent->itemFlags = parent->itemFlags & ~Qt::ItemIsEnabled;
never executed: parent->itemFlags = parent->itemFlags & ~Qt::ItemIsEnabled;
0
1664 if (parent->itemFlags != oldFlags)
parent->itemFlags != oldFlagsDescription
TRUEnever evaluated
FALSEnever evaluated
0
1665 parent->itemChanged();
never executed: parent->itemChanged();
0
1666 }
never executed: end of block
0
1667-
1668 for (int i = 0; i < parent->children.count(); ++i) {
i < parent->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1669 QTreeWidgetItem *child = parent->children.at(i);-
1670 parents.push(child);-
1671 }
never executed: end of block
0
1672 }
never executed: end of block
0
1673}
never executed: end of block
0
1674/*!-
1675 \fn Qt::ItemFlags QTreeWidgetItem::flags() const-
1676-
1677 Returns the flags used to describe the item. These determine whether-
1678 the item can be checked, edited, and selected.-
1679-
1680 The default value for flags is-
1681 Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled |-
1682 Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled.-
1683-
1684 \sa setFlags()-
1685*/-
1686Qt::ItemFlags QTreeWidgetItem::flags() const-
1687{-
1688 return itemFlags;
never executed: return itemFlags;
0
1689}-
1690-
1691/*!-
1692 Sets the value for the item's \a column and \a role to the given-
1693 \a value.-
1694-
1695 The \a role describes the type of data specified by \a value, and is defined by-
1696 the Qt::ItemDataRole enum.-
1697*/-
1698void QTreeWidgetItem::setData(int column, int role, const QVariant &value)-
1699{-
1700 if (column < 0)
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
0
1701 return;
never executed: return;
0
1702-
1703 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1704 switch (role) {-
1705 case Qt::EditRole:
never executed: case Qt::EditRole:
0
1706 case Qt::DisplayRole: {
never executed: case Qt::DisplayRole:
0
1707 if (values.count() <= column) {
values.count() <= columnDescription
TRUEnever evaluated
FALSEnever evaluated
0
1708 if (model && this == model->headerItem)
modelDescription
TRUEnever evaluated
FALSEnever evaluated
this == model->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
1709 model->setColumnCount(column + 1);
never executed: model->setColumnCount(column + 1);
0
1710 else-
1711 values.resize(column + 1);
never executed: values.resize(column + 1);
0
1712 }-
1713 if (d->display.count() <= column) {
d->display.count() <= columnDescription
TRUEnever evaluated
FALSEnever evaluated
0
1714 for (int i = d->display.count() - 1; i < column - 1; ++i)
i < column - 1Description
TRUEnever evaluated
FALSEnever evaluated
0
1715 d->display.append(QVariant());
never executed: d->display.append(QVariant());
0
1716 d->display.append(value);-
1717 } else if (d->display[column] != value) {
never executed: end of block
d->display[column] != valueDescription
TRUEnever evaluated
FALSEnever evaluated
0
1718 d->display[column] = value;-
1719 } else {
never executed: end of block
0
1720 return; // value is unchanged
never executed: return;
0
1721 }-
1722 } break;
never executed: break;
0
1723 case Qt::CheckStateRole:
never executed: case Qt::CheckStateRole:
0
1724 if ((itemFlags & Qt::ItemIsAutoTristate) && value != Qt::PartiallyChecked) {
(itemFlags & Q...sAutoTristate)Description
TRUEnever evaluated
FALSEnever evaluated
value != Qt::PartiallyCheckedDescription
TRUEnever evaluated
FALSEnever evaluated
0
1725 for (int i = 0; i < children.count(); ++i) {
i < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1726 QTreeWidgetItem *child = children.at(i);-
1727 if (child->data(column, role).isValid()) {// has a CheckState
child->data(co...ole).isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
1728 Qt::ItemFlags f = itemFlags; // a little hack to avoid multiple dataChanged signals-
1729 itemFlags &= ~Qt::ItemIsAutoTristate;-
1730 child->setData(column, role, value);-
1731 itemFlags = f;-
1732 }
never executed: end of block
0
1733 }
never executed: end of block
0
1734 }
never executed: end of block
0
1735 // Don't break, but fall through-
1736 default:
code before this statement never executed: default:
never executed: default:
0
1737 if (column < values.count()) {
column < values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1738 bool found = false;-
1739 QVector<QWidgetItemData> column_values = values.at(column);-
1740 for (int i = 0; i < column_values.count(); ++i) {
i < column_values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1741 if (column_values.at(i).role == role) {
column_values....).role == roleDescription
TRUEnever evaluated
FALSEnever evaluated
0
1742 if (column_values.at(i).value == value)
column_values....value == valueDescription
TRUEnever evaluated
FALSEnever evaluated
0
1743 return; // value is unchanged
never executed: return;
0
1744 values[column][i].value = value;-
1745 found = true;-
1746 break;
never executed: break;
0
1747 }-
1748 }
never executed: end of block
0
1749 if (!found)
!foundDescription
TRUEnever evaluated
FALSEnever evaluated
0
1750 values[column].append(QWidgetItemData(role, value));
never executed: values[column].append(QWidgetItemData(role, value));
0
1751 } else {
never executed: end of block
0
1752 if (model && this == model->headerItem)
modelDescription
TRUEnever evaluated
FALSEnever evaluated
this == model->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
1753 model->setColumnCount(column + 1);
never executed: model->setColumnCount(column + 1);
0
1754 else-
1755 values.resize(column + 1);
never executed: values.resize(column + 1);
0
1756 values[column].append(QWidgetItemData(role, value));-
1757 }
never executed: end of block
0
1758 }-
1759-
1760 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1761 model->emitDataChanged(this, column);-
1762 if (role == Qt::CheckStateRole) {
role == Qt::CheckStateRoleDescription
TRUEnever evaluated
FALSEnever evaluated
0
1763 QTreeWidgetItem *p;-
1764 for (p = par; p && (p->itemFlags & Qt::ItemIsAutoTristate); p = p->par)
pDescription
TRUEnever evaluated
FALSEnever evaluated
(p->itemFlags ...sAutoTristate)Description
TRUEnever evaluated
FALSEnever evaluated
0
1765 model->emitDataChanged(p, column);
never executed: model->emitDataChanged(p, column);
0
1766 }
never executed: end of block
0
1767 }
never executed: end of block
0
1768}
never executed: end of block
0
1769-
1770/*!-
1771 Returns the value for the item's \a column and \a role.-
1772*/-
1773QVariant QTreeWidgetItem::data(int column, int role) const-
1774{-
1775 switch (role) {-
1776 case Qt::EditRole:
never executed: case Qt::EditRole:
0
1777 case Qt::DisplayRole:
never executed: case Qt::DisplayRole:
0
1778 if (column >= 0 && column < d->display.count())
column >= 0Description
TRUEnever evaluated
FALSEnever evaluated
column < d->display.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1779 return d->display.at(column);
never executed: return d->display.at(column);
0
1780 break;
never executed: break;
0
1781 case Qt::CheckStateRole:
never executed: case Qt::CheckStateRole:
0
1782 // special case for check state in tristate-
1783 if (children.count() && (itemFlags & Qt::ItemIsAutoTristate))
children.count()Description
TRUEnever evaluated
FALSEnever evaluated
(itemFlags & Q...sAutoTristate)Description
TRUEnever evaluated
FALSEnever evaluated
0
1784 return childrenCheckState(column);
never executed: return childrenCheckState(column);
0
1785 // fallthrough intended-
1786 default:
code before this statement never executed: default:
never executed: default:
0
1787 if (column >= 0 && column < values.size()) {
column >= 0Description
TRUEnever evaluated
FALSEnever evaluated
column < values.size()Description
TRUEnever evaluated
FALSEnever evaluated
0
1788 const QVector<QWidgetItemData> &column_values = values.at(column);-
1789 for (int i = 0; i < column_values.count(); ++i)
i < column_values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1790 if (column_values.at(i).role == role)
column_values....).role == roleDescription
TRUEnever evaluated
FALSEnever evaluated
0
1791 return column_values.at(i).value;
never executed: return column_values.at(i).value;
0
1792 }
never executed: end of block
0
1793 }
never executed: end of block
0
1794 return QVariant();
never executed: return QVariant();
0
1795}-
1796-
1797/*!-
1798 Returns \c true if the text in the item is less than the text in the-
1799 \a other item, otherwise returns \c false.-
1800*/-
1801-
1802bool QTreeWidgetItem::operator<(const QTreeWidgetItem &other) const-
1803{-
1804 int column = view ? view->sortColumn() : 0;
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1805 const QVariant v1 = data(column, Qt::DisplayRole);-
1806 const QVariant v2 = other.data(column, Qt::DisplayRole);-
1807 return QAbstractItemModelPrivate::variantLessThan(v1, v2);
never executed: return QAbstractItemModelPrivate::variantLessThan(v1, v2);
0
1808}-
1809-
1810#ifndef QT_NO_DATASTREAM-
1811-
1812/*!-
1813 Reads the item from stream \a in. This only reads data into a single item.-
1814-
1815 \sa write()-
1816*/-
1817void QTreeWidgetItem::read(QDataStream &in)-
1818{-
1819 // convert from streams written before we introduced display (4.2.0)-
1820 if (in.version() < QDataStream::Qt_4_2) {
in.version() <...Stream::Qt_4_2Description
TRUEnever evaluated
FALSEnever evaluated
0
1821 d->display.clear();-
1822 in >> values;-
1823 // move the display value over to the display string list-
1824 for (int column = 0; column < values.count(); ++column) {
column < values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1825 d->display << QVariant();-
1826 for (int i = 0; i < values.at(column).count(); ++i) {
i < values.at(column).count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1827 if (values.at(column).at(i).role == Qt::DisplayRole) {
values.at(colu...t::DisplayRoleDescription
TRUEnever evaluated
FALSEnever evaluated
0
1828 d->display[column] = values.at(column).at(i).value;-
1829 values[column].remove(i--);-
1830 }
never executed: end of block
0
1831 }
never executed: end of block
0
1832 }
never executed: end of block
0
1833 } else {
never executed: end of block
0
1834 in >> values >> d->display;-
1835 }
never executed: end of block
0
1836}-
1837-
1838/*!-
1839 Writes the item to stream \a out. This only writes data from one single item.-
1840-
1841 \sa read()-
1842*/-
1843void QTreeWidgetItem::write(QDataStream &out) const-
1844{-
1845 out << values << d->display;-
1846}
never executed: end of block
0
1847#endif // QT_NO_DATASTREAM-
1848-
1849/*!-
1850 \since 4.1-
1851-
1852 Constructs a copy of \a other. Note that type() and treeWidget()-
1853 are not copied.-
1854-
1855 This function is useful when reimplementing clone().-
1856-
1857 \sa data(), flags()-
1858*/-
1859QTreeWidgetItem::QTreeWidgetItem(const QTreeWidgetItem &other)-
1860 : rtti(Type), values(other.values), view(0),-
1861 d(new QTreeWidgetItemPrivate(this)), par(0),-
1862 itemFlags(other.itemFlags)-
1863{-
1864 d->display = other.d->display;-
1865}
never executed: end of block
0
1866-
1867/*!-
1868 Assigns \a other's data and flags to this item. Note that type()-
1869 and treeWidget() are not copied.-
1870-
1871 This function is useful when reimplementing clone().-
1872-
1873 \sa data(), flags()-
1874*/-
1875QTreeWidgetItem &QTreeWidgetItem::operator=(const QTreeWidgetItem &other)-
1876{-
1877 values = other.values;-
1878 d->display = other.d->display;-
1879 d->policy = other.d->policy;-
1880 itemFlags = other.itemFlags;-
1881 return *this;
never executed: return *this;
0
1882}-
1883-
1884/*!-
1885 Appends the \a child item to the list of children.-
1886-
1887 \sa insertChild(), takeChild()-
1888*/-
1889void QTreeWidgetItem::addChild(QTreeWidgetItem *child)-
1890{-
1891 if (child) {
childDescription
TRUEnever evaluated
FALSEnever evaluated
0
1892 insertChild(children.count(), child);-
1893 child->d->rowGuess = children.count() - 1;-
1894 }
never executed: end of block
0
1895}
never executed: end of block
0
1896-
1897/*!-
1898 Inserts the \a child item at \a index in the list of children.-
1899-
1900 If the child has already been inserted somewhere else it won't be inserted again.-
1901*/-
1902void QTreeWidgetItem::insertChild(int index, QTreeWidgetItem *child)-
1903{-
1904 if (index < 0 || index > children.count() || child == 0 || child->view != 0 || child->par != 0)
index < 0Description
TRUEnever evaluated
FALSEnever evaluated
index > children.count()Description
TRUEnever evaluated
FALSEnever evaluated
child == 0Description
TRUEnever evaluated
FALSEnever evaluated
child->view != 0Description
TRUEnever evaluated
FALSEnever evaluated
child->par != 0Description
TRUEnever evaluated
FALSEnever evaluated
0
1905 return;
never executed: return;
0
1906-
1907 if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0)) {
QTreeModel *mo...>model()) : 0)Description
TRUEnever evaluated
FALSEnever evaluated
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1908 const bool wasSkipSort = model->skipPendingSort;-
1909 model->skipPendingSort = true;-
1910 if (model->rootItem == this)
model->rootItem == thisDescription
TRUEnever evaluated
FALSEnever evaluated
0
1911 child->par = 0;
never executed: child->par = 0;
0
1912 else-
1913 child->par = this;
never executed: child->par = this;
0
1914 if (view->isSortingEnabled()) {
view->isSortingEnabled()Description
TRUEnever evaluated
FALSEnever evaluated
0
1915 // do a delayed sort instead-
1916 if (!model->sortPendingTimer.isActive())
!model->sortPe...mer.isActive()Description
TRUEnever evaluated
FALSEnever evaluated
0
1917 model->sortPendingTimer.start(0, model);
never executed: model->sortPendingTimer.start(0, model);
0
1918 }
never executed: end of block
0
1919 model->beginInsertItems(this, index, 1);-
1920 int cols = model->columnCount();-
1921 QStack<QTreeWidgetItem*> stack;-
1922 stack.push(child);-
1923 while (!stack.isEmpty()) {
!stack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
1924 QTreeWidgetItem *i = stack.pop();-
1925 i->view = view;-
1926 i->values.reserve(cols);-
1927 for (int c = 0; c < i->children.count(); ++c)
c < i->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1928 stack.push(i->children.at(c));
never executed: stack.push(i->children.at(c));
0
1929 }
never executed: end of block
0
1930 children.insert(index, child);-
1931 model->endInsertItems();-
1932 model->skipPendingSort = wasSkipSort;-
1933 } else {
never executed: end of block
0
1934 child->par = this;-
1935 children.insert(index, child);-
1936 }
never executed: end of block
0
1937 if (child->par)
child->parDescription
TRUEnever evaluated
FALSEnever evaluated
0
1938 d->propagateDisabled(child);
never executed: d->propagateDisabled(child);
0
1939}
never executed: end of block
0
1940-
1941/*!-
1942 Removes the given item indicated by \a child.-
1943 The removed item will not be deleted.-
1944*/-
1945void QTreeWidgetItem::removeChild(QTreeWidgetItem *child)-
1946{-
1947 (void)takeChild(children.indexOf(child));-
1948}
never executed: end of block
0
1949-
1950/*!-
1951 Removes the item at \a index and returns it, otherwise return 0.-
1952*/-
1953QTreeWidgetItem *QTreeWidgetItem::takeChild(int index)-
1954{-
1955 // we move this outside the check of the index to allow executing-
1956 // pending sorts from inline functions, using this function (hack)-
1957 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
1958 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1959 // This will trigger a layoutChanged signal, thus we might want to optimize-
1960 // this function by not emitting the rowsRemoved signal etc to the view.-
1961 // On the other hand we also need to make sure that the selectionmodel-
1962 // is updated in case we take an item that is selected.-
1963 model->skipPendingSort = false;-
1964 model->executePendingSort();-
1965 }
never executed: end of block
0
1966 if (index >= 0 && index < children.count()) {
index >= 0Description
TRUEnever evaluated
FALSEnever evaluated
index < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1967 if (model) model->beginRemoveItems(this, index, 1);
never executed: model->beginRemoveItems(this, index, 1);
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1968 QTreeWidgetItem *item = children.takeAt(index);-
1969 item->par = 0;-
1970 QStack<QTreeWidgetItem*> stack;-
1971 stack.push(item);-
1972 while (!stack.isEmpty()) {
!stack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
1973 QTreeWidgetItem *i = stack.pop();-
1974 i->view = 0;-
1975 for (int c = 0; c < i->children.count(); ++c)
c < i->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
1976 stack.push(i->children.at(c));
never executed: stack.push(i->children.at(c));
0
1977 }
never executed: end of block
0
1978 d->propagateDisabled(item);-
1979 if (model) model->endRemoveRows();
never executed: model->endRemoveRows();
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
1980 return item;
never executed: return item;
0
1981 }-
1982 return 0;
never executed: return 0;
0
1983}-
1984-
1985/*!-
1986 \since 4.1-
1987-
1988 Appends the given list of \a children to the item.-
1989-
1990 \sa insertChildren(), takeChildren()-
1991*/-
1992void QTreeWidgetItem::addChildren(const QList<QTreeWidgetItem*> &children)-
1993{-
1994 insertChildren(this->children.count(), children);-
1995}
never executed: end of block
0
1996-
1997/*!-
1998 \since 4.1-
1999-
2000 Inserts the given list of \a children into the list of the item children at \a index .-
2001-
2002 Children that have already been inserted somewhere else won't be inserted.-
2003*/-
2004void QTreeWidgetItem::insertChildren(int index, const QList<QTreeWidgetItem*> &children)-
2005{-
2006 if (view && view->isSortingEnabled()) {
viewDescription
TRUEnever evaluated
FALSEnever evaluated
view->isSortingEnabled()Description
TRUEnever evaluated
FALSEnever evaluated
0
2007 for (int n = 0; n < children.count(); ++n)
n < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2008 insertChild(index, children.at(n));
never executed: insertChild(index, children.at(n));
0
2009 return;
never executed: return;
0
2010 }-
2011 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2012 QStack<QTreeWidgetItem*> stack;-
2013 QList<QTreeWidgetItem*> itemsToInsert;-
2014 for (int n = 0; n < children.count(); ++n) {
n < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2015 QTreeWidgetItem *child = children.at(n);-
2016 if (child->view || child->par)
child->viewDescription
TRUEnever evaluated
FALSEnever evaluated
child->parDescription
TRUEnever evaluated
FALSEnever evaluated
0
2017 continue;
never executed: continue;
0
2018 itemsToInsert.append(child);-
2019 if (view && model) {
viewDescription
TRUEnever evaluated
FALSEnever evaluated
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2020 if (child->childCount() == 0)
child->childCount() == 0Description
TRUEnever evaluated
FALSEnever evaluated
0
2021 child->view = view;
never executed: child->view = view;
0
2022 else-
2023 stack.push(child);
never executed: stack.push(child);
0
2024 }-
2025 if (model && (model->rootItem == this))
modelDescription
TRUEnever evaluated
FALSEnever evaluated
(model->rootItem == this)Description
TRUEnever evaluated
FALSEnever evaluated
0
2026 child->par = 0;
never executed: child->par = 0;
0
2027 else-
2028 child->par = this;
never executed: child->par = this;
0
2029 }-
2030 if (!itemsToInsert.isEmpty()) {
!itemsToInsert.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
2031 while (!stack.isEmpty()) {
!stack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
2032 QTreeWidgetItem *i = stack.pop();-
2033 i->view = view;-
2034 for (int c = 0; c < i->children.count(); ++c)
c < i->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2035 stack.push(i->children.at(c));
never executed: stack.push(i->children.at(c));
0
2036 }
never executed: end of block
0
2037 if (model) model->beginInsertItems(this, index, itemsToInsert.count());
never executed: model->beginInsertItems(this, index, itemsToInsert.count());
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2038 for (int n = 0; n < itemsToInsert.count(); ++n) {
n < itemsToInsert.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2039 QTreeWidgetItem *child = itemsToInsert.at(n);-
2040 this->children.insert(index + n, child);-
2041 if (child->par)
child->parDescription
TRUEnever evaluated
FALSEnever evaluated
0
2042 d->propagateDisabled(child);
never executed: d->propagateDisabled(child);
0
2043 }
never executed: end of block
0
2044 if (model) model->endInsertItems();
never executed: model->endInsertItems();
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2045 }
never executed: end of block
0
2046}
never executed: end of block
0
2047-
2048/*!-
2049 \since 4.1-
2050-
2051 Removes the list of children and returns it, otherwise returns an empty list.-
2052*/-
2053QList<QTreeWidgetItem*> QTreeWidgetItem::takeChildren()-
2054{-
2055 QList<QTreeWidgetItem*> removed;-
2056 if (children.count() > 0) {
children.count() > 0Description
TRUEnever evaluated
FALSEnever evaluated
0
2057 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2058 if (model) {
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2059 // This will trigger a layoutChanged signal, thus we might want to optimize-
2060 // this function by not emitting the rowsRemoved signal etc to the view.-
2061 // On the other hand we also need to make sure that the selectionmodel-
2062 // is updated in case we take an item that is selected.-
2063 model->executePendingSort();-
2064 }
never executed: end of block
0
2065 if (model) model->beginRemoveItems(this, 0, children.count());
never executed: model->beginRemoveItems(this, 0, children.count());
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2066 for (int n = 0; n < children.count(); ++n) {
n < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2067 QTreeWidgetItem *item = children.at(n);-
2068 item->par = 0;-
2069 QStack<QTreeWidgetItem*> stack;-
2070 stack.push(item);-
2071 while (!stack.isEmpty()) {
!stack.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
2072 QTreeWidgetItem *i = stack.pop();-
2073 i->view = 0;-
2074 for (int c = 0; c < i->children.count(); ++c)
c < i->children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2075 stack.push(i->children.at(c));
never executed: stack.push(i->children.at(c));
0
2076 }
never executed: end of block
0
2077 d->propagateDisabled(item);-
2078 }
never executed: end of block
0
2079 removed = children;-
2080 children.clear(); // detach-
2081 if (model) model->endRemoveItems();
never executed: model->endRemoveItems();
modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2082 }
never executed: end of block
0
2083 return removed;
never executed: return removed;
0
2084}-
2085-
2086-
2087void QTreeWidgetItemPrivate::sortChildren(int column, Qt::SortOrder order, bool climb)-
2088{-
2089 QTreeModel *model = (q->view ? qobject_cast<QTreeModel*>(q->view->model()) : 0);
q->viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2090 if (!model)
!modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2091 return;
never executed: return;
0
2092 model->sortItems(&q->children, column, order);-
2093 if (climb) {
climbDescription
TRUEnever evaluated
FALSEnever evaluated
0
2094 QList<QTreeWidgetItem*>::iterator it = q->children.begin();-
2095 for (; it != q->children.end(); ++it) {
it != q->children.end()Description
TRUEnever evaluated
FALSEnever evaluated
0
2096 //here we call the private object's method to avoid emitting-
2097 //the layoutAboutToBeChanged and layoutChanged signals-
2098 (*it)->d->sortChildren(column, order, climb);-
2099 }
never executed: end of block
0
2100 }
never executed: end of block
0
2101}
never executed: end of block
0
2102-
2103/*!-
2104 \internal-
2105-
2106 Sorts the children by the value in the given \a column, in the \a order-
2107 specified. If \a climb is true, the items below each of the children will-
2108 also be sorted.-
2109*/-
2110void QTreeWidgetItem::sortChildren(int column, Qt::SortOrder order, bool climb)-
2111{-
2112 QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2113 if (!model)
!modelDescription
TRUEnever evaluated
FALSEnever evaluated
0
2114 return;
never executed: return;
0
2115 if (model->isChanging())
model->isChanging()Description
TRUEnever evaluated
FALSEnever evaluated
0
2116 return;
never executed: return;
0
2117 QTreeModel::SkipSorting skipSorting(model);-
2118 int oldSortColumn = view->d_func()->explicitSortColumn;-
2119 view->d_func()->explicitSortColumn = column;-
2120 emit model->layoutAboutToBeChanged();-
2121 d->sortChildren(column, order, climb);-
2122 emit model->layoutChanged();-
2123 view->d_func()->explicitSortColumn = oldSortColumn;-
2124}
never executed: end of block
0
2125-
2126/*!-
2127 \internal-
2128-
2129 Calculates the checked state of the item based on the checked state-
2130 of its children. E.g. if all children checked => this item is also-
2131 checked; if some children checked => this item is partially checked;-
2132 if no children checked => this item is unchecked.-
2133*/-
2134QVariant QTreeWidgetItem::childrenCheckState(int column) const-
2135{-
2136 if (column < 0)
column < 0Description
TRUEnever evaluated
FALSEnever evaluated
0
2137 return QVariant();
never executed: return QVariant();
0
2138 bool checkedChildren = false;-
2139 bool uncheckedChildren = false;-
2140 for (int i = 0; i < children.count(); ++i) {
i < children.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2141 QVariant value = children.at(i)->data(column, Qt::CheckStateRole);-
2142 if (!value.isValid())
!value.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
2143 return QVariant();
never executed: return QVariant();
0
2144-
2145 switch (static_cast<Qt::CheckState>(value.toInt()))-
2146 {-
2147 case Qt::Unchecked:
never executed: case Qt::Unchecked:
0
2148 uncheckedChildren = true;-
2149 break;
never executed: break;
0
2150 case Qt::Checked:
never executed: case Qt::Checked:
0
2151 checkedChildren = true;-
2152 break;
never executed: break;
0
2153 case Qt::PartiallyChecked:
never executed: case Qt::PartiallyChecked:
0
2154 default:
never executed: default:
0
2155 return Qt::PartiallyChecked;
never executed: return Qt::PartiallyChecked;
0
2156 }-
2157-
2158 if (uncheckedChildren && checkedChildren)
uncheckedChildrenDescription
TRUEnever evaluated
FALSEnever evaluated
checkedChildrenDescription
TRUEnever evaluated
FALSEnever evaluated
0
2159 return Qt::PartiallyChecked;
never executed: return Qt::PartiallyChecked;
0
2160 }
never executed: end of block
0
2161-
2162 if (uncheckedChildren)
uncheckedChildrenDescription
TRUEnever evaluated
FALSEnever evaluated
0
2163 return Qt::Unchecked;
never executed: return Qt::Unchecked;
0
2164 else if (checkedChildren)
checkedChildrenDescription
TRUEnever evaluated
FALSEnever evaluated
0
2165 return Qt::Checked;
never executed: return Qt::Checked;
0
2166 else-
2167 return QVariant(); // value was not defined
never executed: return QVariant();
0
2168}-
2169-
2170/*!-
2171 \since 4.5-
2172-
2173 Causes the model associated with this item to emit a-
2174 \l{QAbstractItemModel::dataChanged()}{dataChanged}() signal for this-
2175 item.-
2176-
2177 You normally only need to call this function if you have subclassed-
2178 QTreeWidgetItem and reimplemented data() and/or setData().-
2179-
2180 \sa setData()-
2181*/-
2182void QTreeWidgetItem::emitDataChanged()-
2183{-
2184 itemChanged();-
2185}
never executed: end of block
0
2186-
2187/*!-
2188 \internal-
2189*/-
2190void QTreeWidgetItem::itemChanged()-
2191{-
2192 if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0))
QTreeModel *mo...>model()) : 0)Description
TRUEnever evaluated
FALSEnever evaluated
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2193 model->itemChanged(this);
never executed: model->itemChanged(this);
0
2194}
never executed: end of block
0
2195-
2196/*!-
2197 \internal-
2198*/-
2199void QTreeWidgetItem::executePendingSort() const-
2200{-
2201 if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0))
QTreeModel *mo...>model()) : 0)Description
TRUEnever evaluated
FALSEnever evaluated
viewDescription
TRUEnever evaluated
FALSEnever evaluated
0
2202 model->executePendingSort();
never executed: model->executePendingSort();
0
2203}
never executed: end of block
0
2204-
2205-
2206#ifndef QT_NO_DATASTREAM-
2207/*!-
2208 \relates QTreeWidgetItem-
2209-
2210 Writes the tree widget item \a item to stream \a out.-
2211-
2212 This operator uses QTreeWidgetItem::write().-
2213-
2214 \sa {Serializing Qt Data Types}-
2215*/-
2216QDataStream &operator<<(QDataStream &out, const QTreeWidgetItem &item)-
2217{-
2218 item.write(out);-
2219 return out;
never executed: return out;
0
2220}-
2221-
2222/*!-
2223 \relates QTreeWidgetItem-
2224-
2225 Reads a tree widget item from stream \a in into \a item.-
2226-
2227 This operator uses QTreeWidgetItem::read().-
2228-
2229 \sa {Serializing Qt Data Types}-
2230*/-
2231QDataStream &operator>>(QDataStream &in, QTreeWidgetItem &item)-
2232{-
2233 item.read(in);-
2234 return in;
never executed: return in;
0
2235}-
2236#endif // QT_NO_DATASTREAM-
2237-
2238-
2239void QTreeWidgetPrivate::_q_emitItemPressed(const QModelIndex &index)-
2240{-
2241 Q_Q(QTreeWidget);-
2242 emit q->itemPressed(item(index), index.column());-
2243}
never executed: end of block
0
2244-
2245void QTreeWidgetPrivate::_q_emitItemClicked(const QModelIndex &index)-
2246{-
2247 Q_Q(QTreeWidget);-
2248 emit q->itemClicked(item(index), index.column());-
2249}
never executed: end of block
0
2250-
2251void QTreeWidgetPrivate::_q_emitItemDoubleClicked(const QModelIndex &index)-
2252{-
2253 Q_Q(QTreeWidget);-
2254 emit q->itemDoubleClicked(item(index), index.column());-
2255}
never executed: end of block
0
2256-
2257void QTreeWidgetPrivate::_q_emitItemActivated(const QModelIndex &index)-
2258{-
2259 Q_Q(QTreeWidget);-
2260 emit q->itemActivated(item(index), index.column());-
2261}
never executed: end of block
0
2262-
2263void QTreeWidgetPrivate::_q_emitItemEntered(const QModelIndex &index)-
2264{-
2265 Q_Q(QTreeWidget);-
2266 emit q->itemEntered(item(index), index.column());-
2267}
never executed: end of block
0
2268-
2269void QTreeWidgetPrivate::_q_emitItemChanged(const QModelIndex &index)-
2270{-
2271 Q_Q(QTreeWidget);-
2272 QTreeWidgetItem *indexItem = item(index);-
2273 if (indexItem)
indexItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
2274 emit q->itemChanged(indexItem, index.column());
never executed: q->itemChanged(indexItem, index.column());
0
2275}
never executed: end of block
0
2276-
2277void QTreeWidgetPrivate::_q_emitItemExpanded(const QModelIndex &index)-
2278{-
2279 Q_Q(QTreeWidget);-
2280 emit q->itemExpanded(item(index));-
2281}
never executed: end of block
0
2282-
2283void QTreeWidgetPrivate::_q_emitItemCollapsed(const QModelIndex &index)-
2284{-
2285 Q_Q(QTreeWidget);-
2286 emit q->itemCollapsed(item(index));-
2287}
never executed: end of block
0
2288-
2289void QTreeWidgetPrivate::_q_emitCurrentItemChanged(const QModelIndex &current,-
2290 const QModelIndex &previous)-
2291{-
2292 Q_Q(QTreeWidget);-
2293 QTreeWidgetItem *currentItem = item(current);-
2294 QTreeWidgetItem *previousItem = item(previous);-
2295 emit q->currentItemChanged(currentItem, previousItem);-
2296}
never executed: end of block
0
2297-
2298void QTreeWidgetPrivate::_q_sort()-
2299{-
2300 if (sortingEnabled) {
sortingEnabledDescription
TRUEnever evaluated
FALSEnever evaluated
0
2301 int column = header->sortIndicatorSection();-
2302 Qt::SortOrder order = header->sortIndicatorOrder();-
2303 treeModel()->sort(column, order);-
2304 }
never executed: end of block
0
2305}
never executed: end of block
0
2306-
2307void QTreeWidgetPrivate::_q_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)-
2308{-
2309 Q_Q(QTreeWidget);-
2310 QModelIndexList indices = selected.indexes();-
2311 int i;-
2312 QTreeModel *m = treeModel();-
2313 for (i = 0; i < indices.count(); ++i) {
i < indices.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2314 QTreeWidgetItem *item = m->item(indices.at(i));-
2315 item->d->selected = true;-
2316 }
never executed: end of block
0
2317-
2318 indices = deselected.indexes();-
2319 for (i = 0; i < indices.count(); ++i) {
i < indices.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2320 QTreeWidgetItem *item = m->item(indices.at(i));-
2321 item->d->selected = false;-
2322 }
never executed: end of block
0
2323-
2324 emit q->itemSelectionChanged();-
2325}
never executed: end of block
0
2326-
2327void QTreeWidgetPrivate::_q_dataChanged(const QModelIndex &topLeft,-
2328 const QModelIndex &bottomRight)-
2329{-
2330 if (sortingEnabled && topLeft.isValid() && bottomRight.isValid()
sortingEnabledDescription
TRUEnever evaluated
FALSEnever evaluated
topLeft.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
bottomRight.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
2331 && !treeModel()->sortPendingTimer.isActive()) {
!treeModel()->...mer.isActive()Description
TRUEnever evaluated
FALSEnever evaluated
0
2332 int column = header->sortIndicatorSection();-
2333 if (column >= topLeft.column() && column <= bottomRight.column()) {
column >= topLeft.column()Description
TRUEnever evaluated
FALSEnever evaluated
column <= bottomRight.column()Description
TRUEnever evaluated
FALSEnever evaluated
0
2334 Qt::SortOrder order = header->sortIndicatorOrder();-
2335 treeModel()->ensureSorted(column, order, topLeft.row(),-
2336 bottomRight.row(), topLeft.parent());-
2337 }
never executed: end of block
0
2338 }
never executed: end of block
0
2339}
never executed: end of block
0
2340-
2341/*!-
2342 \class QTreeWidget-
2343-
2344 \brief The QTreeWidget class provides a tree view that uses a predefined-
2345 tree model.-
2346-
2347 \ingroup model-view-
2348 \inmodule QtWidgets-
2349-
2350 The QTreeWidget class is a convenience class that provides a standard-
2351 tree widget with a classic item-based interface similar to that used by-
2352 the QListView class in Qt 3.-
2353 This class is based on Qt's Model/View architecture and uses a default-
2354 model to hold items, each of which is a QTreeWidgetItem.-
2355-
2356 Developers who do not need the flexibility of the Model/View framework-
2357 can use this class to create simple hierarchical lists very easily. A more-
2358 flexible approach involves combining a QTreeView with a standard item model.-
2359 This allows the storage of data to be separated from its representation.-
2360-
2361 In its simplest form, a tree widget can be constructed in the following way:-
2362-
2363 \snippet code/src_gui_itemviews_qtreewidget.cpp 0-
2364-
2365 Before items can be added to the tree widget, the number of columns must-
2366 be set with setColumnCount(). This allows each item to have one or more-
2367 labels or other decorations. The number of columns in use can be found-
2368 with the columnCount() function.-
2369-
2370 The tree can have a header that contains a section for each column in-
2371 the widget. It is easiest to set up the labels for each section by-
2372 supplying a list of strings with setHeaderLabels(), but a custom header-
2373 can be constructed with a QTreeWidgetItem and inserted into the tree-
2374 with the setHeaderItem() function.-
2375-
2376 The items in the tree can be sorted by column according to a predefined-
2377 sort order. If sorting is enabled, the user can sort the items by clicking-
2378 on a column header. Sorting can be enabled or disabled by calling-
2379 \l{QTreeView::setSortingEnabled()}{setSortingEnabled()}. The-
2380 \l{QTreeView::isSortingEnabled()}{isSortingEnabled()} function indicates-
2381 whether sorting is enabled.-
2382-
2383 \table 100%-
2384 \row \li \inlineimage windowsvista-treeview.png Screenshot of a Windows Vista style tree widget-
2385 \li \inlineimage macintosh-treeview.png Screenshot of a Macintosh style tree widget-
2386 \li \inlineimage fusion-treeview.png Screenshot of a Fusion style tree widget-
2387 \row \li A \l{Windows Vista Style Widget Gallery}{Windows Vista style} tree widget.-
2388 \li A \l{Macintosh Style Widget Gallery}{Macintosh style} tree widget.-
2389 \li A \l{Fusion Style Widget Gallery}{Fusion style} tree widget.-
2390 \endtable-
2391-
2392 \sa QTreeWidgetItem, QTreeWidgetItemIterator, QTreeView,-
2393 {Model/View Programming}, {Settings Editor Example}-
2394*/-
2395-
2396/*!-
2397 \property QTreeWidget::columnCount-
2398 \brief the number of columns displayed in the tree widget-
2399-
2400 By default, this property has a value of 1.-
2401*/-
2402-
2403/*!-
2404 \fn void QTreeWidget::itemActivated(QTreeWidgetItem *item, int column)-
2405-
2406 This signal is emitted when the user activates an item by single--
2407 or double-clicking (depending on the platform, i.e. on the-
2408 QStyle::SH_ItemView_ActivateItemOnSingleClick style hint) or-
2409 pressing a special key (e.g., \uicontrol Enter).-
2410-
2411 The specified \a item is the item that was clicked, or 0 if no-
2412 item was clicked. The \a column is the item's column that was-
2413 clicked, or -1 if no item was clicked.-
2414*/-
2415-
2416/*!-
2417 \fn void QTreeWidget::itemPressed(QTreeWidgetItem *item, int column)-
2418-
2419 This signal is emitted when the user presses a mouse button inside-
2420 the widget.-
2421-
2422 The specified \a item is the item that was clicked, or 0 if no-
2423 item was clicked. The \a column is the item's column that was-
2424 clicked, or -1 if no item was clicked.-
2425*/-
2426-
2427/*!-
2428 \fn void QTreeWidget::itemClicked(QTreeWidgetItem *item, int column)-
2429-
2430 This signal is emitted when the user clicks inside the widget.-
2431-
2432 The specified \a item is the item that was clicked. The \a column is the-
2433 item's column that was clicked. If no item was clicked, no signal will be-
2434 emitted.-
2435*/-
2436-
2437/*!-
2438 \fn void QTreeWidget::itemDoubleClicked(QTreeWidgetItem *item, int column)-
2439-
2440 This signal is emitted when the user double clicks inside the-
2441 widget.-
2442-
2443 The specified \a item is the item that was clicked, or 0 if no-
2444 item was clicked. The \a column is the item's column that was-
2445 clicked. If no item was double clicked, no signal will be emitted.-
2446*/-
2447-
2448/*!-
2449 \fn void QTreeWidget::itemExpanded(QTreeWidgetItem *item)-
2450-
2451 This signal is emitted when the specified \a item is expanded so that-
2452 all of its children are displayed.-
2453-
2454 \note This signal will not be emitted if an item changes its state when-
2455 expandAll() is invoked.-
2456-
2457 \sa QTreeWidgetItem::isExpanded(), itemCollapsed(), expandItem()-
2458*/-
2459-
2460/*!-
2461 \fn void QTreeWidget::itemCollapsed(QTreeWidgetItem *item)-
2462-
2463 This signal is emitted when the specified \a item is collapsed so that-
2464 none of its children are displayed.-
2465-
2466 \note This signal will not be emitted if an item changes its state when-
2467 collapseAll() is invoked.-
2468-
2469 \sa QTreeWidgetItem::isExpanded(), itemExpanded(), collapseItem()-
2470*/-
2471-
2472/*!-
2473 \fn void QTreeWidget::currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)-
2474-
2475 This signal is emitted when the current item changes. The current-
2476 item is specified by \a current, and this replaces the \a previous-
2477 current item.-
2478-
2479 \sa setCurrentItem()-
2480*/-
2481-
2482/*!-
2483 \fn void QTreeWidget::itemSelectionChanged()-
2484-
2485 This signal is emitted when the selection changes in the tree widget.-
2486 The current selection can be found with selectedItems().-
2487*/-
2488-
2489/*!-
2490 \fn void QTreeWidget::itemEntered(QTreeWidgetItem *item, int column)-
2491-
2492 This signal is emitted when the mouse cursor enters an \a item over the-
2493 specified \a column.-
2494 QTreeWidget mouse tracking needs to be enabled for this feature to work.-
2495*/-
2496-
2497/*!-
2498 \fn void QTreeWidget::itemChanged(QTreeWidgetItem *item, int column)-
2499-
2500 This signal is emitted when the contents of the \a column in the specified-
2501 \a item changes.-
2502*/-
2503-
2504/*!-
2505 \since 4.3-
2506-
2507 \fn void QTreeWidget::removeItemWidget(QTreeWidgetItem *item, int column)-
2508-
2509 Removes the widget set in the given \a item in the given \a column.-
2510*/-
2511-
2512/*!-
2513 Constructs a tree widget with the given \a parent.-
2514*/-
2515QTreeWidget::QTreeWidget(QWidget *parent)-
2516 : QTreeView(*new QTreeWidgetPrivate(), parent)-
2517{-
2518 QTreeView::setModel(new QTreeModel(1, this));-
2519 connect(this, SIGNAL(pressed(QModelIndex)),-
2520 SLOT(_q_emitItemPressed(QModelIndex)));-
2521 connect(this, SIGNAL(clicked(QModelIndex)),-
2522 SLOT(_q_emitItemClicked(QModelIndex)));-
2523 connect(this, SIGNAL(doubleClicked(QModelIndex)),-
2524 SLOT(_q_emitItemDoubleClicked(QModelIndex)));-
2525 connect(this, SIGNAL(activated(QModelIndex)),-
2526 SLOT(_q_emitItemActivated(QModelIndex)));-
2527 connect(this, SIGNAL(entered(QModelIndex)),-
2528 SLOT(_q_emitItemEntered(QModelIndex)));-
2529 connect(this, SIGNAL(expanded(QModelIndex)),-
2530 SLOT(_q_emitItemExpanded(QModelIndex)));-
2531 connect(this, SIGNAL(collapsed(QModelIndex)),-
2532 SLOT(_q_emitItemCollapsed(QModelIndex)));-
2533 connect(selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),-
2534 this, SLOT(_q_emitCurrentItemChanged(QModelIndex,QModelIndex)));-
2535 connect(model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),-
2536 this, SLOT(_q_emitItemChanged(QModelIndex)));-
2537 connect(model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),-
2538 this, SLOT(_q_dataChanged(QModelIndex,QModelIndex)));-
2539 connect(model(), SIGNAL(columnsRemoved(QModelIndex,int,int)),-
2540 this, SLOT(_q_sort()));-
2541 connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),-
2542 this, SLOT(_q_selectionChanged(QItemSelection,QItemSelection)));-
2543 header()->setSectionsClickable(false);-
2544}
never executed: end of block
0
2545-
2546/*!-
2547 Destroys the tree widget and all its items.-
2548*/-
2549-
2550QTreeWidget::~QTreeWidget()-
2551{-
2552}-
2553-
2554/*-
2555 Retuns the number of header columns in the view.-
2556-
2557 \sa sortColumn(), currentColumn(), topLevelItemCount()-
2558*/-
2559-
2560int QTreeWidget::columnCount() const-
2561{-
2562 Q_D(const QTreeWidget);-
2563 return d->model->columnCount();
never executed: return d->model->columnCount();
0
2564}-
2565-
2566/*-
2567 Sets the number of header \a columns in the tree widget.-
2568*/-
2569-
2570void QTreeWidget::setColumnCount(int columns)-
2571{-
2572 Q_D(QTreeWidget);-
2573 if (columns < 0)
columns < 0Description
TRUEnever evaluated
FALSEnever evaluated
0
2574 return;
never executed: return;
0
2575 d->treeModel()->setColumnCount(columns);-
2576}
never executed: end of block
0
2577-
2578/*!-
2579 \since 4.2-
2580-
2581 Returns the tree widget's invisible root item.-
2582-
2583 The invisible root item provides access to the tree widget's top-level items-
2584 through the QTreeWidgetItem API, making it possible to write functions that-
2585 can treat top-level items and their children in a uniform way; for example,-
2586 recursive functions.-
2587*/-
2588-
2589QTreeWidgetItem *QTreeWidget::invisibleRootItem() const-
2590{-
2591 Q_D(const QTreeWidget);-
2592 return d->treeModel()->rootItem;
never executed: return d->treeModel()->rootItem;
0
2593}-
2594-
2595/*!-
2596 Returns the top level item at the given \a index, or 0 if the item does-
2597 not exist.-
2598-
2599 \sa topLevelItemCount(), insertTopLevelItem()-
2600*/-
2601-
2602QTreeWidgetItem *QTreeWidget::topLevelItem(int index) const-
2603{-
2604 Q_D(const QTreeWidget);-
2605 return d->treeModel()->rootItem->child(index);
never executed: return d->treeModel()->rootItem->child(index);
0
2606}-
2607-
2608/*!-
2609 \property QTreeWidget::topLevelItemCount-
2610 \brief the number of top-level items-
2611-
2612 By default, this property has a value of 0.-
2613-
2614 \sa columnCount(), currentItem()-
2615*/-
2616-
2617int QTreeWidget::topLevelItemCount() const-
2618{-
2619 Q_D(const QTreeWidget);-
2620 return d->treeModel()->rootItem->childCount();
never executed: return d->treeModel()->rootItem->childCount();
0
2621}-
2622-
2623/*!-
2624 Inserts the \a item at \a index in the top level in the view.-
2625-
2626 If the item has already been inserted somewhere else it won't be inserted.-
2627-
2628 \sa addTopLevelItem(), columnCount()-
2629*/-
2630-
2631void QTreeWidget::insertTopLevelItem(int index, QTreeWidgetItem *item)-
2632{-
2633 Q_D(QTreeWidget);-
2634 d->treeModel()->rootItem->insertChild(index, item);-
2635}
never executed: end of block
0
2636-
2637/*!-
2638 \since 4.1-
2639-
2640 Appends the \a item as a top-level item in the widget.-
2641-
2642 \sa insertTopLevelItem()-
2643*/-
2644void QTreeWidget::addTopLevelItem(QTreeWidgetItem *item)-
2645{-
2646 insertTopLevelItem(topLevelItemCount(), item);-
2647}
never executed: end of block
0
2648-
2649/*!-
2650 Removes the top-level item at the given \a index in the tree and-
2651 returns it, otherwise returns 0;-
2652-
2653 \sa insertTopLevelItem(), topLevelItem(), topLevelItemCount()-
2654*/-
2655-
2656QTreeWidgetItem *QTreeWidget::takeTopLevelItem(int index)-
2657{-
2658 Q_D(QTreeWidget);-
2659 return d->treeModel()->rootItem->takeChild(index);
never executed: return d->treeModel()->rootItem->takeChild(index);
0
2660}-
2661-
2662/*!-
2663 Returns the index of the given top-level \a item, or -1 if the item-
2664 cannot be found.-
2665-
2666 \sa sortItems(), topLevelItemCount()-
2667 */-
2668int QTreeWidget::indexOfTopLevelItem(QTreeWidgetItem *item) const-
2669{-
2670 Q_D(const QTreeWidget);-
2671 d->treeModel()->executePendingSort();-
2672 return d->treeModel()->rootItem->children.indexOf(item);
never executed: return d->treeModel()->rootItem->children.indexOf(item);
0
2673}-
2674-
2675/*!-
2676 \since 4.1-
2677-
2678 Inserts the list of \a items at \a index in the top level in the view.-
2679-
2680 Items that have already been inserted somewhere else won't be inserted.-
2681-
2682 \sa addTopLevelItems()-
2683*/-
2684void QTreeWidget::insertTopLevelItems(int index, const QList<QTreeWidgetItem*> &items)-
2685{-
2686 Q_D(QTreeWidget);-
2687 d->treeModel()->rootItem->insertChildren(index, items);-
2688}
never executed: end of block
0
2689-
2690/*!-
2691 Appends the list of \a items as a top-level items in the widget.-
2692-
2693 \sa insertTopLevelItems()-
2694*/-
2695void QTreeWidget::addTopLevelItems(const QList<QTreeWidgetItem*> &items)-
2696{-
2697 insertTopLevelItems(topLevelItemCount(), items);-
2698}
never executed: end of block
0
2699-
2700/*!-
2701 Returns the item used for the tree widget's header.-
2702-
2703 \sa setHeaderItem()-
2704*/-
2705-
2706QTreeWidgetItem *QTreeWidget::headerItem() const-
2707{-
2708 Q_D(const QTreeWidget);-
2709 return d->treeModel()->headerItem;
never executed: return d->treeModel()->headerItem;
0
2710}-
2711-
2712/*!-
2713 Sets the header \a item for the tree widget. The label for each column in-
2714 the header is supplied by the corresponding label in the item.-
2715-
2716 The tree widget takes ownership of the item.-
2717-
2718 \sa headerItem(), setHeaderLabels()-
2719*/-
2720-
2721void QTreeWidget::setHeaderItem(QTreeWidgetItem *item)-
2722{-
2723 Q_D(QTreeWidget);-
2724 if (!item)
!itemDescription
TRUEnever evaluated
FALSEnever evaluated
0
2725 return;
never executed: return;
0
2726 item->view = this;-
2727-
2728 int oldCount = columnCount();-
2729 if (oldCount < item->columnCount())
oldCount < item->columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
2730 d->treeModel()->beginInsertColumns(QModelIndex(), oldCount, item->columnCount());
never executed: d->treeModel()->beginInsertColumns(QModelIndex(), oldCount, item->columnCount());
0
2731 else-
2732 d->treeModel()->beginRemoveColumns(QModelIndex(), item->columnCount(), oldCount);
never executed: d->treeModel()->beginRemoveColumns(QModelIndex(), item->columnCount(), oldCount);
0
2733 delete d->treeModel()->headerItem;-
2734 d->treeModel()->headerItem = item;-
2735 if (oldCount < item->columnCount())
oldCount < item->columnCount()Description
TRUEnever evaluated
FALSEnever evaluated
0
2736 d->treeModel()->endInsertColumns();
never executed: d->treeModel()->endInsertColumns();
0
2737 else-
2738 d->treeModel()->endRemoveColumns();
never executed: d->treeModel()->endRemoveColumns();
0
2739 d->treeModel()->headerDataChanged(Qt::Horizontal, 0, oldCount);-
2740}
never executed: end of block
0
2741-
2742-
2743/*!-
2744 Adds a column in the header for each item in the \a labels list, and sets-
2745 the label for each column.-
2746-
2747 Note that setHeaderLabels() won't remove existing columns.-
2748-
2749 \sa setHeaderItem(), setHeaderLabel()-
2750*/-
2751void QTreeWidget::setHeaderLabels(const QStringList &labels)-
2752{-
2753 Q_D(QTreeWidget);-
2754 if (columnCount() < labels.count())
columnCount() < labels.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2755 setColumnCount(labels.count());
never executed: setColumnCount(labels.count());
0
2756 QTreeWidgetItem *item = d->treeModel()->headerItem;-
2757 for (int i = 0; i < labels.count(); ++i)
i < labels.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
2758 item->setText(i, labels.at(i));
never executed: item->setText(i, labels.at(i));
0
2759}
never executed: end of block
0
2760-
2761/*!-
2762 \fn void QTreeWidget::setHeaderLabel(const QString &label)-
2763 \since 4.2-
2764-
2765 Same as setHeaderLabels(QStringList(\a label)).-
2766*/-
2767-
2768/*!-
2769 Returns the current item in the tree widget.-
2770-
2771 \sa setCurrentItem(), currentItemChanged()-
2772*/-
2773QTreeWidgetItem *QTreeWidget::currentItem() const-
2774{-
2775 Q_D(const QTreeWidget);-
2776 return d->item(currentIndex());
never executed: return d->item(currentIndex());
0
2777}-
2778-
2779/*!-
2780 \since 4.1-
2781 Returns the current column in the tree widget.-
2782-
2783 \sa setCurrentItem(), columnCount()-
2784*/-
2785int QTreeWidget::currentColumn() const-
2786{-
2787 return currentIndex().column();
never executed: return currentIndex().column();
0
2788}-
2789-
2790/*!-
2791 Sets the current \a item in the tree widget.-
2792-
2793 Unless the selection mode is \l{QAbstractItemView::}{NoSelection},-
2794 the item is also selected.-
2795-
2796 \sa currentItem(), currentItemChanged()-
2797*/-
2798void QTreeWidget::setCurrentItem(QTreeWidgetItem *item)-
2799{-
2800 setCurrentItem(item, 0);-
2801}
never executed: end of block
0
2802-
2803/*!-
2804 \since 4.1-
2805 Sets the current \a item in the tree widget and the current column to \a column.-
2806-
2807 \sa currentItem()-
2808*/-
2809void QTreeWidget::setCurrentItem(QTreeWidgetItem *item, int column)-
2810{-
2811 Q_D(QTreeWidget);-
2812 setCurrentIndex(d->index(item, column));-
2813}
never executed: end of block
0
2814-
2815/*!-
2816 \since 4.4-
2817 Sets the current \a item in the tree widget and the current column to \a column,-
2818 using the given \a command.-
2819-
2820 \sa currentItem()-
2821*/-
2822void QTreeWidget::setCurrentItem(QTreeWidgetItem *item, int column,-
2823 QItemSelectionModel::SelectionFlags command)-
2824{-
2825 Q_D(QTreeWidget);-
2826 d->selectionModel->setCurrentIndex(d->index(item, column), command);-
2827}
never executed: end of block
0
2828-
2829-
2830/*!-
2831 Returns a pointer to the item at the coordinates \a p. The coordinates-
2832 are relative to the tree widget's \l{QAbstractScrollArea::}{viewport()}.-
2833-
2834 \sa visualItemRect()-
2835*/-
2836QTreeWidgetItem *QTreeWidget::itemAt(const QPoint &p) const-
2837{-
2838 Q_D(const QTreeWidget);-
2839 return d->item(indexAt(p));
never executed: return d->item(indexAt(p));
0
2840}-
2841-
2842/*!-
2843 \fn QTreeWidgetItem *QTreeWidget::itemAt(int x, int y) const-
2844 \overload-
2845-
2846 Returns a pointer to the item at the coordinates (\a x, \a y). The coordinates-
2847 are relative to the tree widget's \l{QAbstractScrollArea::}{viewport()}.-
2848*/-
2849-
2850/*!-
2851 Returns the rectangle on the viewport occupied by the item at \a item.-
2852-
2853 \sa itemAt()-
2854*/-
2855QRect QTreeWidget::visualItemRect(const QTreeWidgetItem *item) const-
2856{-
2857 Q_D(const QTreeWidget);-
2858 //the visual rect for an item is across all columns. So we need to determine-
2859 //what is the first and last column and get their visual index rects-
2860 QModelIndex base = d->index(item);-
2861 const int firstVisiblesection = header()->logicalIndexAt(- header()->offset());-
2862 const int lastVisibleSection = header()->logicalIndexAt(header()->length() - header()->offset() - 1);-
2863 QModelIndex first = base.sibling(base.row(), header()->logicalIndex(firstVisiblesection));-
2864 QModelIndex last = base.sibling(base.row(), header()->logicalIndex(lastVisibleSection));-
2865 return visualRect(first) | visualRect(last);
never executed: return visualRect(first) | visualRect(last);
0
2866}-
2867-
2868/*!-
2869 \since 4.1-
2870-
2871 Returns the column used to sort the contents of the widget.-
2872-
2873 \sa sortItems()-
2874*/-
2875int QTreeWidget::sortColumn() const-
2876{-
2877 Q_D(const QTreeWidget);-
2878 return (d->explicitSortColumn != -1
never executed: return (d->explicitSortColumn != -1 ? d->explicitSortColumn : header()->sortIndicatorSection());
d->explicitSortColumn != -1Description
TRUEnever evaluated
FALSEnever evaluated
0
2879 ? d->explicitSortColumn
never executed: return (d->explicitSortColumn != -1 ? d->explicitSortColumn : header()->sortIndicatorSection());
0
2880 : header()->sortIndicatorSection());
never executed: return (d->explicitSortColumn != -1 ? d->explicitSortColumn : header()->sortIndicatorSection());
0
2881}-
2882-
2883/*!-
2884 Sorts the items in the widget in the specified \a order by the values in-
2885 the given \a column.-
2886-
2887 \sa sortColumn()-
2888*/-
2889-
2890void QTreeWidget::sortItems(int column, Qt::SortOrder order)-
2891{-
2892 Q_D(QTreeWidget);-
2893 header()->setSortIndicator(column, order);-
2894 d->model->sort(column, order);-
2895}
never executed: end of block
0
2896-
2897/*!-
2898 Starts editing the \a item in the given \a column if it is editable.-
2899*/-
2900-
2901void QTreeWidget::editItem(QTreeWidgetItem *item, int column)-
2902{-
2903 Q_D(QTreeWidget);-
2904 edit(d->index(item, column));-
2905}
never executed: end of block
0
2906-
2907/*!-
2908 Opens a persistent editor for the \a item in the given \a column.-
2909-
2910 \sa closePersistentEditor()-
2911*/-
2912-
2913void QTreeWidget::openPersistentEditor(QTreeWidgetItem *item, int column)-
2914{-
2915 Q_D(QTreeWidget);-
2916 QAbstractItemView::openPersistentEditor(d->index(item, column));-
2917}
never executed: end of block
0
2918-
2919/*!-
2920 Closes the persistent editor for the \a item in the given \a column.-
2921-
2922 This function has no effect if no persistent editor is open for this-
2923 combination of item and column.-
2924-
2925 \sa openPersistentEditor()-
2926*/-
2927-
2928void QTreeWidget::closePersistentEditor(QTreeWidgetItem *item, int column)-
2929{-
2930 Q_D(QTreeWidget);-
2931 QAbstractItemView::closePersistentEditor(d->index(item, column));-
2932}
never executed: end of block
0
2933-
2934/*!-
2935 \since 4.1-
2936-
2937 Returns the widget displayed in the cell specified by \a item and the given \a column.-
2938-
2939*/-
2940QWidget *QTreeWidget::itemWidget(QTreeWidgetItem *item, int column) const-
2941{-
2942 Q_D(const QTreeWidget);-
2943 return QAbstractItemView::indexWidget(d->index(item, column));
never executed: return QAbstractItemView::indexWidget(d->index(item, column));
0
2944}-
2945-
2946/*!-
2947 \since 4.1-
2948-
2949 Sets the given \a widget to be displayed in the cell specified by the given-
2950 \a item and \a column.-
2951-
2952 The given \a widget's \l {QWidget::}{autoFillBackground} property must be-
2953 set to true, otherwise the widget's background will be transparent, showing-
2954 both the model data and the tree widget item.-
2955-
2956 This function should only be used to display static content in the place of-
2957 a tree widget item. If you want to display custom dynamic content or-
2958 implement a custom editor widget, use QTreeView and subclass QItemDelegate-
2959 instead.-
2960-
2961 This function cannot be called before the item hierarchy has been set up,-
2962 i.e., the QTreeWidgetItem that will hold \a widget must have been added to-
2963 the view before \a widget is set.-
2964-
2965 \note The tree takes ownership of the widget.-
2966-
2967 \sa {Delegate Classes}-
2968*/-
2969void QTreeWidget::setItemWidget(QTreeWidgetItem *item, int column, QWidget *widget)-
2970{-
2971 Q_D(QTreeWidget);-
2972 QAbstractItemView::setIndexWidget(d->index(item, column), widget);-
2973}
never executed: end of block
0
2974-
2975/*!-
2976 Returns \c true if the \a item is selected; otherwise returns \c false.-
2977-
2978 \sa itemSelectionChanged()-
2979-
2980 \obsolete-
2981-
2982 This function is deprecated. Use \l{QTreeWidgetItem::isSelected()} instead.-
2983*/-
2984bool QTreeWidget::isItemSelected(const QTreeWidgetItem *item) const-
2985{-
2986 if (!item)
!itemDescription
TRUEnever evaluated
FALSEnever evaluated
0
2987 return false;
never executed: return false;
0
2988 return item->d->selected;
never executed: return item->d->selected;
0
2989}-
2990-
2991/*!-
2992 If \a select is true, the given \a item is selected; otherwise it is-
2993 deselected.-
2994-
2995 \sa itemSelectionChanged()-
2996-
2997 \obsolete-
2998-
2999 This function is deprecated. Use \l{QTreeWidgetItem::setSelected()} instead.-
3000*/-
3001void QTreeWidget::setItemSelected(const QTreeWidgetItem *item, bool select)-
3002{-
3003 Q_D(QTreeWidget);-
3004-
3005 if (!item)
!itemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3006 return;
never executed: return;
0
3007-
3008 selectionModel()->select(d->index(item), (select ? QItemSelectionModel::Select-
3009 : QItemSelectionModel::Deselect)-
3010 |QItemSelectionModel::Rows);-
3011 item->d->selected = select;-
3012}
never executed: end of block
0
3013-
3014/*!-
3015 Returns a list of all selected non-hidden items.-
3016-
3017 \sa itemSelectionChanged()-
3018*/-
3019QList<QTreeWidgetItem*> QTreeWidget::selectedItems() const-
3020{-
3021 Q_D(const QTreeWidget);-
3022 QModelIndexList indexes = selectionModel()->selectedIndexes();-
3023 QList<QTreeWidgetItem*> items;-
3024 items.reserve(indexes.count());-
3025 QSet<QTreeWidgetItem *> seen;-
3026 seen.reserve(indexes.count());-
3027 for (int i = 0; i < indexes.count(); ++i) {
i < indexes.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
3028 QTreeWidgetItem *item = d->item(indexes.at(i));-
3029 if (isItemHidden(item) || seen.contains(item))
isItemHidden(item)Description
TRUEnever evaluated
FALSEnever evaluated
seen.contains(item)Description
TRUEnever evaluated
FALSEnever evaluated
0
3030 continue;
never executed: continue;
0
3031 seen.insert(item);-
3032 items.append(item);-
3033 }
never executed: end of block
0
3034 return items;
never executed: return items;
0
3035}-
3036-
3037/*!-
3038 Returns a list of items that match the given \a text, using the given \a flags, in the given \a column.-
3039*/-
3040QList<QTreeWidgetItem*> QTreeWidget::findItems(const QString &text, Qt::MatchFlags flags, int column) const-
3041{-
3042 Q_D(const QTreeWidget);-
3043 QModelIndexList indexes = d->model->match(model()->index(0, column, QModelIndex()),-
3044 Qt::DisplayRole, text, -1, flags);-
3045 QList<QTreeWidgetItem*> items;-
3046 const int indexesSize = indexes.size();-
3047 items.reserve(indexesSize);-
3048 for (int i = 0; i < indexesSize; ++i)
i < indexesSizeDescription
TRUEnever evaluated
FALSEnever evaluated
0
3049 items.append(d->item(indexes.at(i)));
never executed: items.append(d->item(indexes.at(i)));
0
3050 return items;
never executed: return items;
0
3051}-
3052-
3053/*!-
3054 Returns \c true if the \a item is explicitly hidden, otherwise returns \c false.-
3055-
3056 \obsolete-
3057-
3058 This function is deprecated. Use \l{QTreeWidgetItem::isHidden()} instead.-
3059*/-
3060bool QTreeWidget::isItemHidden(const QTreeWidgetItem *item) const-
3061{-
3062 Q_D(const QTreeWidget);-
3063 if (item == d->treeModel()->headerItem)
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3064 return header()->isHidden();
never executed: return header()->isHidden();
0
3065 if (d->hiddenIndexes.isEmpty())
d->hiddenIndexes.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
3066 return false;
never executed: return false;
0
3067 QTreeModel::SkipSorting skipSorting(d->treeModel());-
3068 return d->isRowHidden(d->index(item));
never executed: return d->isRowHidden(d->index(item));
0
3069}-
3070-
3071/*!-
3072 Hides the given \a item if \a hide is true; otherwise shows the item.-
3073-
3074 \sa itemChanged()-
3075-
3076 \obsolete-
3077-
3078 This function is deprecated. Use \l{QTreeWidgetItem::setHidden()} instead.-
3079*/-
3080void QTreeWidget::setItemHidden(const QTreeWidgetItem *item, bool hide)-
3081{-
3082 Q_D(QTreeWidget);-
3083 if (item == d->treeModel()->headerItem) {
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3084 header()->setHidden(hide);-
3085 } else {
never executed: end of block
0
3086 const QModelIndex index = d->index(item);-
3087 setRowHidden(index.row(), index.parent(), hide);-
3088 }
never executed: end of block
0
3089}-
3090-
3091/*!-
3092 Returns \c true if the given \a item is open; otherwise returns \c false.-
3093-
3094 \sa itemExpanded()-
3095-
3096 \obsolete-
3097-
3098 This function is deprecated. Use \l{QTreeWidgetItem::isExpanded()} instead.-
3099*/-
3100bool QTreeWidget::isItemExpanded(const QTreeWidgetItem *item) const-
3101{-
3102 Q_D(const QTreeWidget);-
3103 QTreeModel::SkipSorting skipSorting(d->treeModel());-
3104 return isExpanded(d->index(item));
never executed: return isExpanded(d->index(item));
0
3105}-
3106-
3107/*!-
3108 Sets the item referred to by \a item to either closed or opened,-
3109 depending on the value of \a expand.-
3110-
3111 \sa expandItem(), collapseItem(), itemExpanded()-
3112-
3113 \obsolete-
3114-
3115 This function is deprecated. Use \l{QTreeWidgetItem::setExpanded()} instead.-
3116*/-
3117void QTreeWidget::setItemExpanded(const QTreeWidgetItem *item, bool expand)-
3118{-
3119 Q_D(QTreeWidget);-
3120 QTreeModel::SkipSorting skipSorting(d->treeModel());-
3121 setExpanded(d->index(item), expand);-
3122}
never executed: end of block
0
3123-
3124/*!-
3125 \since 4.3-
3126-
3127 Returns \c true if the given \a item is set to show only one section over all columns;-
3128 otherwise returns \c false.-
3129-
3130 \sa setFirstItemColumnSpanned()-
3131*/-
3132bool QTreeWidget::isFirstItemColumnSpanned(const QTreeWidgetItem *item) const-
3133{-
3134 Q_D(const QTreeWidget);-
3135 if (item == d->treeModel()->headerItem)
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3136 return false; // We can't set the header items to spanning
never executed: return false;
0
3137 const QModelIndex index = d->index(item);-
3138 return isFirstColumnSpanned(index.row(), index.parent());
never executed: return isFirstColumnSpanned(index.row(), index.parent());
0
3139}-
3140-
3141/*!-
3142 \since 4.3-
3143-
3144 Sets the given \a item to only show one section for all columns if \a span is true;-
3145 otherwise the item will show one section per column.-
3146-
3147 \sa isFirstItemColumnSpanned()-
3148*/-
3149void QTreeWidget::setFirstItemColumnSpanned(const QTreeWidgetItem *item, bool span)-
3150{-
3151 Q_D(QTreeWidget);-
3152 if (item == d->treeModel()->headerItem)
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3153 return; // We can't set header items to spanning
never executed: return;
0
3154 const QModelIndex index = d->index(item);-
3155 setFirstColumnSpanned(index.row(), index.parent(), span);-
3156}
never executed: end of block
0
3157-
3158/*!-
3159 \since 4.3-
3160-
3161 Returns the item above the given \a item.-
3162*/-
3163QTreeWidgetItem *QTreeWidget::itemAbove(const QTreeWidgetItem *item) const-
3164{-
3165 Q_D(const QTreeWidget);-
3166 if (item == d->treeModel()->headerItem)
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3167 return 0;
never executed: return 0;
0
3168 const QModelIndex index = d->index(item);-
3169 const QModelIndex above = indexAbove(index);-
3170 return d->item(above);
never executed: return d->item(above);
0
3171}-
3172-
3173/*!-
3174 \since 4.3-
3175-
3176 Returns the item visually below the given \a item.-
3177*/-
3178QTreeWidgetItem *QTreeWidget::itemBelow(const QTreeWidgetItem *item) const-
3179{-
3180 Q_D(const QTreeWidget);-
3181 if (item == d->treeModel()->headerItem)
item == d->tre...()->headerItemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3182 return 0;
never executed: return 0;
0
3183 const QModelIndex index = d->index(item);-
3184 const QModelIndex below = indexBelow(index);-
3185 return d->item(below);
never executed: return d->item(below);
0
3186}-
3187-
3188/*!-
3189 \reimp-
3190 */-
3191void QTreeWidget::setSelectionModel(QItemSelectionModel *selectionModel)-
3192{-
3193 Q_D(QTreeWidget);-
3194 QTreeView::setSelectionModel(selectionModel);-
3195 QItemSelection newSelection = selectionModel->selection();-
3196 if (!newSelection.isEmpty())
!newSelection.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
3197 d->_q_selectionChanged(newSelection, QItemSelection());
never executed: d->_q_selectionChanged(newSelection, QItemSelection());
0
3198}
never executed: end of block
0
3199-
3200/*!-
3201 Ensures that the \a item is visible, scrolling the view if necessary using-
3202 the specified \a hint.-
3203-
3204 \sa currentItem(), itemAt(), topLevelItem()-
3205*/-
3206void QTreeWidget::scrollToItem(const QTreeWidgetItem *item, QAbstractItemView::ScrollHint hint)-
3207{-
3208 Q_D(QTreeWidget);-
3209 QTreeView::scrollTo(d->index(item), hint);-
3210}
never executed: end of block
0
3211-
3212/*!-
3213 Expands the \a item. This causes the tree containing the item's children-
3214 to be expanded.-
3215-
3216 \sa collapseItem(), currentItem(), itemAt(), topLevelItem(), itemExpanded()-
3217*/-
3218void QTreeWidget::expandItem(const QTreeWidgetItem *item)-
3219{-
3220 Q_D(QTreeWidget);-
3221 QTreeModel::SkipSorting skipSorting(d->treeModel());-
3222 expand(d->index(item));-
3223}
never executed: end of block
0
3224-
3225/*!-
3226 Closes the \a item. This causes the tree containing the item's children-
3227 to be collapsed.-
3228-
3229 \sa expandItem(), currentItem(), itemAt(), topLevelItem()-
3230*/-
3231void QTreeWidget::collapseItem(const QTreeWidgetItem *item)-
3232{-
3233 Q_D(QTreeWidget);-
3234 QTreeModel::SkipSorting skipSorting(d->treeModel());-
3235 collapse(d->index(item));-
3236}
never executed: end of block
0
3237-
3238/*!-
3239 Clears the tree widget by removing all of its items and selections.-
3240-
3241 \b{Note:} Since each item is removed from the tree widget before being-
3242 deleted, the return value of QTreeWidgetItem::treeWidget() will be invalid-
3243 when called from an item's destructor.-
3244-
3245 \sa takeTopLevelItem(), topLevelItemCount(), columnCount()-
3246*/-
3247void QTreeWidget::clear()-
3248{-
3249 Q_D(QTreeWidget);-
3250 selectionModel()->clear();-
3251 d->treeModel()->clear();-
3252}
never executed: end of block
0
3253-
3254/*!-
3255 Returns a list of MIME types that can be used to describe a list of-
3256 treewidget items.-
3257-
3258 \sa mimeData()-
3259*/-
3260QStringList QTreeWidget::mimeTypes() const-
3261{-
3262 return model()->QAbstractItemModel::mimeTypes();
never executed: return model()->QAbstractItemModel::mimeTypes();
0
3263}-
3264-
3265/*!-
3266 Returns an object that contains a serialized description of the specified-
3267 \a items. The format used to describe the items is obtained from the-
3268 mimeTypes() function.-
3269-
3270 If the list of items is empty, 0 is returned rather than a serialized-
3271 empty list.-
3272*/-
3273#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)-
3274QMimeData *QTreeWidget::mimeData(const QList<QTreeWidgetItem *> &items) const-
3275#else-
3276QMimeData *QTreeWidget::mimeData(const QList<QTreeWidgetItem*> items) const-
3277#endif-
3278{-
3279 Q_D(const QTreeWidget);-
3280 if (d->treeModel()->cachedIndexes.isEmpty()) {
d->treeModel()...exes.isEmpty()Description
TRUEnever evaluated
FALSEnever evaluated
0
3281 QList<QModelIndex> indexes;-
3282 for (int i = 0; i < items.count(); ++i) {
i < items.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
3283 QTreeWidgetItem *item = items.at(i);-
3284 if (!item) {
!itemDescription
TRUEnever evaluated
FALSEnever evaluated
0
3285 qWarning("QTreeWidget::mimeData: Null-item passed");-
3286 return 0;
never executed: return 0;
0
3287 }-
3288-
3289 for (int c = 0; c < item->values.count(); ++c) {
c < item->values.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
3290 const QModelIndex index = indexFromItem(item, c);-
3291 if (!index.isValid()) {
!index.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
3292 qWarning() << "QTreeWidget::mimeData: No index associated with item :" << item;-
3293 return 0;
never executed: return 0;
0
3294 }-
3295 indexes << index;-
3296 }
never executed: end of block
0
3297 }
never executed: end of block
0
3298 return d->model->QAbstractItemModel::mimeData(indexes);
never executed: return d->model->QAbstractItemModel::mimeData(indexes);
0
3299 }-
3300 return d->treeModel()->internalMimeData();
never executed: return d->treeModel()->internalMimeData();
0
3301}-
3302-
3303/*!-
3304 Handles the \a data supplied by a drag and drop operation that ended with-
3305 the given \a action in the \a index in the given \a parent item.-
3306-
3307 The default implementation returns \c true if the drop was-
3308 successfully handled by decoding the mime data and inserting it-
3309 into the model; otherwise it returns \c false.-
3310-
3311 \sa supportedDropActions()-
3312*/-
3313bool QTreeWidget::dropMimeData(QTreeWidgetItem *parent, int index,-
3314 const QMimeData *data, Qt::DropAction action)-
3315{-
3316 QModelIndex idx;-
3317 if (parent) idx = indexFromItem(parent);
never executed: idx = indexFromItem(parent);
parentDescription
TRUEnever evaluated
FALSEnever evaluated
0
3318 return model()->QAbstractItemModel::dropMimeData(data, action , index, 0, idx);
never executed: return model()->QAbstractItemModel::dropMimeData(data, action , index, 0, idx);
0
3319}-
3320-
3321/*!-
3322 Returns the drop actions supported by this view.-
3323-
3324 \sa Qt::DropActions-
3325*/-
3326Qt::DropActions QTreeWidget::supportedDropActions() const-
3327{-
3328 return model()->QAbstractItemModel::supportedDropActions() | Qt::MoveAction;
never executed: return model()->QAbstractItemModel::supportedDropActions() | Qt::MoveAction;
0
3329}-
3330-
3331/*!-
3332 \obsolete-
3333 Returns an empty list-
3334-
3335 \sa mimeData()-
3336*/-
3337QList<QTreeWidgetItem*> QTreeWidget::items(const QMimeData *data) const-
3338{-
3339 Q_UNUSED(data);-
3340 return QList<QTreeWidgetItem*>();
never executed: return QList<QTreeWidgetItem*>();
0
3341}-
3342-
3343/*!-
3344 Returns the QModelIndex assocated with the given \a item in the given \a column.-
3345-
3346 \sa itemFromIndex(), topLevelItem()-
3347*/-
3348QModelIndex QTreeWidget::indexFromItem(QTreeWidgetItem *item, int column) const-
3349{-
3350 Q_D(const QTreeWidget);-
3351 return d->index(item, column);
never executed: return d->index(item, column);
0
3352}-
3353-
3354/*!-
3355 Returns a pointer to the QTreeWidgetItem assocated with the given \a index.-
3356-
3357 \sa indexFromItem()-
3358*/-
3359QTreeWidgetItem *QTreeWidget::itemFromIndex(const QModelIndex &index) const-
3360{-
3361 Q_D(const QTreeWidget);-
3362 return d->item(index);
never executed: return d->item(index);
0
3363}-
3364-
3365#ifndef QT_NO_DRAGANDDROP-
3366/*! \reimp */-
3367void QTreeWidget::dropEvent(QDropEvent *event) {-
3368 Q_D(QTreeWidget);-
3369 if (event->source() == this && (event->dropAction() == Qt::MoveAction ||
event->source() == thisDescription
TRUEnever evaluated
FALSEnever evaluated
event->dropAct...Qt::MoveActionDescription
TRUEnever evaluated
FALSEnever evaluated
0
3370 dragDropMode() == QAbstractItemView::InternalMove)) {
dragDropMode()...::InternalMoveDescription
TRUEnever evaluated
FALSEnever evaluated
0
3371 QModelIndex topIndex;-
3372 int col = -1;-
3373 int row = -1;-
3374 if (d->dropOn(event, &row, &col, &topIndex)) {
d->dropOn(even...ol, &topIndex)Description
TRUEnever evaluated
FALSEnever evaluated
0
3375 QList<QModelIndex> idxs = selectedIndexes();-
3376 QList<QPersistentModelIndex> indexes;-
3377 const int indexesCount = idxs.count();-
3378 indexes.reserve(indexesCount);-
3379 for (int i = 0; i < indexesCount; i++)
i < indexesCountDescription
TRUEnever evaluated
FALSEnever evaluated
0
3380 indexes.append(idxs.at(i));
never executed: indexes.append(idxs.at(i));
0
3381-
3382 if (indexes.contains(topIndex))
indexes.contains(topIndex)Description
TRUEnever evaluated
FALSEnever evaluated
0
3383 return;
never executed: return;
0
3384-
3385 // When removing items the drop location could shift-
3386 QPersistentModelIndex dropRow = model()->index(row, col, topIndex);-
3387-
3388 // Remove the items-
3389 QList<QTreeWidgetItem *> taken;-
3390 for (int i = 0; i < indexes.count(); ++i) {
i < indexes.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
3391 QTreeWidgetItem *parent = itemFromIndex(indexes.at(i));-
3392 if (!parent || !parent->parent()) {
!parentDescription
TRUEnever evaluated
FALSEnever evaluated
!parent->parent()Description
TRUEnever evaluated
FALSEnever evaluated
0
3393 taken.append(takeTopLevelItem(indexes.at(i).row()));-
3394 } else {
never executed: end of block
0
3395 taken.append(parent->parent()->takeChild(indexes.at(i).row()));-
3396 }
never executed: end of block
0
3397 }-
3398-
3399 // insert them back in at their new positions-
3400 for (int i = 0; i < indexes.count(); ++i) {
i < indexes.count()Description
TRUEnever evaluated
FALSEnever evaluated
0
3401 // Either at a specific point or appended-
3402 if (row == -1) {
row == -1Description
TRUEnever evaluated
FALSEnever evaluated
0
3403 if (topIndex.isValid()) {
topIndex.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
3404 QTreeWidgetItem *parent = itemFromIndex(topIndex);-
3405 parent->insertChild(parent->childCount(), taken.takeFirst());-
3406 } else {
never executed: end of block
0
3407 insertTopLevelItem(topLevelItemCount(), taken.takeFirst());-
3408 }
never executed: end of block
0
3409 } else {-
3410 int r = dropRow.row() >= 0 ? dropRow.row() : row;
dropRow.row() >= 0Description
TRUEnever evaluated
FALSEnever evaluated
0
3411 if (topIndex.isValid()) {
topIndex.isValid()Description
TRUEnever evaluated
FALSEnever evaluated
0
3412 QTreeWidgetItem *parent = itemFromIndex(topIndex);-
3413 parent->insertChild(qMin(r, parent->childCount()), taken.takeFirst());-
3414 } else {
never executed: end of block
0
3415 insertTopLevelItem(qMin(r, topLevelItemCount()), taken.takeFirst());-
3416 }
never executed: end of block
0
3417 }-
3418 }-
3419-
3420 event->accept();-
3421 // Don't want QAbstractItemView to delete it because it was "moved" we already did it-
3422 event->setDropAction(Qt::CopyAction);-
3423 }
never executed: end of block
0
3424 }
never executed: end of block
0
3425-
3426 QTreeView::dropEvent(event);-
3427}
never executed: end of block
0
3428#endif-
3429-
3430/*!-
3431 \reimp-
3432*/-
3433-
3434void QTreeWidget::setModel(QAbstractItemModel * /*model*/)-
3435{-
3436 Q_ASSERT(!"QTreeWidget::setModel() - Changing the model of the QTreeWidget is not allowed.");-
3437}
never executed: end of block
0
3438-
3439/*!-
3440 \reimp-
3441*/-
3442bool QTreeWidget::event(QEvent *e)-
3443{-
3444 Q_D(QTreeWidget);-
3445 if (e->type() == QEvent::Polish)
e->type() == QEvent::PolishDescription
TRUEnever evaluated
FALSEnever evaluated
0
3446 d->treeModel()->executePendingSort();
never executed: d->treeModel()->executePendingSort();
0
3447 return QTreeView::event(e);
never executed: return QTreeView::event(e);
0
3448}-
3449-
3450QT_END_NAMESPACE-
3451-
3452#include "moc_qtreewidget.cpp"-
3453#include "moc_qtreewidget_p.cpp"-
3454-
3455#endif // QT_NO_TREEWIDGET-
Source codeSwitch to Preprocessed file
Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9