← Back to branch summary

~ubuntu-branches/ubuntu/wily/tora/wily-proposed

« back to all changes in this revision

Viewing changes to src/totreewidget.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Meskes
  • Date: 2009-04-07 13:16:05 UTC
  • mfrom: (1.2.7 upstream) (3.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090407131605-u422yigfv7jgg0l0
Tags: 2.0.0-3
* Cleaned up packaging a little bit.
* Added homepage information to control file.
* Bumped Standards-Version to 3.8.1.
* Released to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/totreewidget.cpp
 
1
 
 
2
/* BEGIN_COMMON_COPYRIGHT_HEADER
 
3
 *
 
4
 * TOra - An Oracle Toolkit for DBA's and developers
 
5
 * 
 
6
 * Shared/mixed copyright is held throughout files in this product
 
7
 * 
 
8
 * Portions Copyright (C) 2000-2001 Underscore AB
 
9
 * Portions Copyright (C) 2003-2005 Quest Software, Inc.
 
10
 * Portions Copyright (C) 2004-2008 Numerous Other Contributors
 
11
 * 
 
12
 * This program is free software; you can redistribute it and/or
 
13
 * modify it under the terms of the GNU General Public License
 
14
 * as published by the Free Software Foundation;  only version 2 of
 
15
 * the License is valid for this program.
 
16
 * 
 
17
 * This program is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU General Public License for more details.
 
21
 * 
 
22
 * You should have received a copy of the GNU General Public License
 
23
 * along with this program; if not, write to the Free Software
 
24
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
25
 * 
 
26
 *      As a special exception, you have permission to link this program
 
27
 *      with the Oracle Client libraries and distribute executables, as long
 
28
 *      as you follow the requirements of the GNU GPL in regard to all of the
 
29
 *      software in the executable aside from Oracle client libraries.
 
30
 * 
 
31
 *      Specifically you are not permitted to link this program with the
 
32
 *      Qt/UNIX, Qt/Windows or Qt Non Commercial products of TrollTech.
 
33
 *      And you are not permitted to distribute binaries compiled against
 
34
 *      these libraries. 
 
35
 * 
 
36
 *      You may link this product with any GPL'd Qt library.
 
37
 * 
 
38
 * All trademarks belong to their respective owners.
 
39
 *
 
40
 * END_COMMON_COPYRIGHT_HEADER */
 
41
 
 
42
#include "config.h"
 
43
#include "totreewidget.h"
 
44
 
 
45
#include <QTreeWidget>
 
46
#include <QTreeWidgetItem>
 
47
 
 
48
 
 
49
toTreeWidget::toTreeWidget(QWidget *parent,
 
50
                           const char *name,
 
51
                           Qt::WFlags f)
 
52
        : QTreeWidget(parent)
 
53
{
 
54
    if (name)
 
55
        setObjectName(name);
 
56
 
 
57
    connect(this,
 
58
            SIGNAL(itemSelectionChanged()),
 
59
            this,
 
60
            SLOT(handleSelectionChange()));
 
61
 
 
62
    connect(this,
 
63
            SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
 
64
            this,
 
65
            SLOT(handleDoubleClick(QTreeWidgetItem *, int)));
 
66
 
 
67
    connect(this,
 
68
            SIGNAL(itemClicked(QTreeWidgetItem *, int)),
 
69
            this,
 
70
            SLOT(handleClick(QTreeWidgetItem *, int)));
 
71
 
 
72
    connect(this,
 
73
            SIGNAL(itemExpanded(QTreeWidgetItem *)),
 
74
            this,
 
75
            SLOT(handleExpanded(QTreeWidgetItem *)));
 
76
 
 
77
    connect(this,
 
78
            SIGNAL(itemCollapsed(QTreeWidgetItem *)),
 
79
            this,
 
80
            SLOT(handleCollapsed(QTreeWidgetItem *)));
 
81
 
 
82
    connect(this,
 
83
            SIGNAL(itemActivated(QTreeWidgetItem *, int)),
 
84
            this,
 
85
            SLOT(handleActivated(QTreeWidgetItem *, int)));
 
86
 
 
87
    columnResize = NoColumn;      // q3listview default
 
88
}
 
89
 
 
90
 
 
91
toTreeWidgetItem* toTreeWidget::firstChild(void) const
 
92
{
 
93
    QTreeWidgetItem *it = QTreeWidget::topLevelItem(0);
 
94
    if (it)
 
95
        return dynamic_cast<toTreeWidgetItem *>(it);
 
96
    return NULL;
 
97
}
 
98
 
 
99
 
 
100
toTreeWidgetItem* toTreeWidget::currentItem(void) const
 
101
{
 
102
    QTreeWidgetItem *it = QTreeWidget::currentItem();
 
103
    if (it)
 
104
        return dynamic_cast<toTreeWidgetItem *>(it);
 
105
    return NULL;
 
106
}
 
107
 
 
108
 
 
109
toTreeWidgetItem* toTreeWidget::selectedItem(void) const
 
110
{
 
111
    QList<QTreeWidgetItem *> items = QTreeWidget::selectedItems();
 
112
 
 
113
    // just return the first item. widgets requiring multiple
 
114
    // selection support should be modified to use selectedItems()
 
115
    if (items.size() > 0)
 
116
        return dynamic_cast<toTreeWidgetItem *>(items.at(0));
 
117
    return NULL;
 
118
}
 
119
 
 
120
 
 
121
toTreeWidgetItem* toTreeWidget::itemAt(const QPoint &viewPos) const
 
122
{
 
123
    QTreeWidgetItem *it = QTreeWidget::itemAt(viewPos);
 
124
    if (it)
 
125
        return dynamic_cast<toTreeWidgetItem *>(it);
 
126
    return NULL;
 
127
}
 
128
 
 
129
 
 
130
void toTreeWidget::setSorting(int column, bool ascending)
 
131
{
 
132
    if (column < 0)
 
133
    {
 
134
        QTreeWidget::setSortingEnabled(false);
 
135
        return;
 
136
    }
 
137
 
 
138
    QTreeWidget::setSortingEnabled(true);
 
139
    QTreeWidget::sortByColumn(column,
 
140
                              ascending ?
 
141
                              Qt::AscendingOrder :
 
142
                              Qt::DescendingOrder);
 
143
}
 
144
 
 
145
 
 
146
const int toTreeWidget::columns(void)
 
147
{
 
148
    return QTreeWidget::columnCount();
 
149
}
 
150
 
 
151
 
 
152
int toTreeWidget::addColumn(const QString &label, int width)
 
153
{
 
154
    QTreeWidgetItem *head = QTreeWidget::headerItem();
 
155
    if (!head)
 
156
        return -1;
 
157
 
 
158
    int index = head->columnCount();
 
159
 
 
160
    // dirty, dirty hack.
 
161
 
 
162
    // QTreeWidget appears to always have at least one column.  you're
 
163
    // meant to add columns by using setHeaderLabels() but this is a
 
164
    // lot of porting.
 
165
 
 
166
    // check if we have just 1 column and it's name is "1" and then
 
167
    // change the name.
 
168
    if (index == 1 && head->text(0) == "1")
 
169
        index = 0;              // don't add
 
170
 
 
171
    head->setText(index, label);
 
172
    return index;
 
173
}
 
174
 
 
175
 
 
176
void toTreeWidget::setSelectionMode(SelectionMode mode)
 
177
{
 
178
    switch (mode)
 
179
    {
 
180
    case Multi:
 
181
        QTreeWidget::setSelectionMode(QAbstractItemView::MultiSelection);
 
182
        break;
 
183
 
 
184
    case Extended:
 
185
        QTreeWidget::setSelectionMode(QAbstractItemView::ExtendedSelection);
 
186
        break;
 
187
 
 
188
    case NoSelection:
 
189
        QTreeWidget::setSelectionMode(QAbstractItemView::NoSelection);
 
190
        break;
 
191
 
 
192
    default:
 
193
        QTreeWidget::setSelectionMode(QAbstractItemView::SingleSelection);
 
194
    }
 
195
}
 
196
 
 
197
 
 
198
int toTreeWidget::selectionMode() const
 
199
{
 
200
    switch (QTreeWidget::selectionMode())
 
201
    {
 
202
    case QAbstractItemView::MultiSelection:
 
203
        return Multi;
 
204
 
 
205
    case QAbstractItemView::ExtendedSelection:
 
206
        return Extended;
 
207
 
 
208
    case QAbstractItemView::NoSelection:
 
209
        return NoSelection;
 
210
 
 
211
    case QAbstractItemView::SingleSelection:
 
212
        return Single;
 
213
 
 
214
    case QAbstractItemView::ContiguousSelection:
 
215
        return Extended;
 
216
 
 
217
    default:
 
218
        return Single;
 
219
    }
 
220
}
 
221
 
 
222
 
 
223
void toTreeWidget::takeItem(toTreeWidgetItem *it)
 
224
{
 
225
    int pos = QTreeWidget::indexOfTopLevelItem(it);
 
226
    if (pos < 0)
 
227
        return;                 // not found
 
228
 
 
229
    QTreeWidget::takeTopLevelItem(pos);
 
230
}
 
231
 
 
232
 
 
233
void toTreeWidget::setColumnAlignment(int column, int align)
 
234
{
 
235
    ;                           // stub
 
236
}
 
237
 
 
238
 
 
239
int toTreeWidget::itemMargin() const
 
240
{
 
241
    return 1;                   // stub
 
242
}
 
243
 
 
244
 
 
245
void toTreeWidget::setTreeStepSize(int i)
 
246
{
 
247
    ;                           // stub
 
248
}
 
249
 
 
250
 
 
251
int toTreeWidget::childCount(void) const
 
252
{
 
253
    return QTreeWidget::topLevelItemCount();
 
254
}
 
255
 
 
256
 
 
257
void toTreeWidget::resizeColumnsToContents(void)
 
258
{
 
259
    for (int col = 0; col < QTreeWidget::columnCount(); col++)
 
260
        QTreeWidget::resizeColumnToContents(col);
 
261
}
 
262
 
 
263
 
 
264
void toTreeWidget::setResizeMode(ResizeMode m)
 
265
{
 
266
    columnResize = m;
 
267
 
 
268
    if (columnResize == NoColumn)
 
269
        return;
 
270
 
 
271
    if (columnResize == AllColumns)
 
272
        resizeColumnsToContents();
 
273
 
 
274
    // qtreewidget will by default allow the last column the most
 
275
    // space.
 
276
    if (columnResize == LastColumn)
 
277
        resizeColumnsToContents();
 
278
}
 
279
 
 
280
 
 
281
toTreeWidget::ResizeMode toTreeWidget::resizeMode() const
 
282
{
 
283
    return columnResize;
 
284
}
 
285
 
 
286
 
 
287
void toTreeWidget::setColumnWidthMode(int column, toTreeWidget::WidthMode)
 
288
{
 
289
    ;                           // stub
 
290
}
 
291
 
 
292
 
 
293
void toTreeWidget::sort(void)
 
294
{
 
295
    return;                     // stub
 
296
}
 
297
 
 
298
 
 
299
int toTreeWidget::visibleHeight(void)
 
300
{
 
301
    return 300;                 // stub
 
302
}
 
303
 
 
304
 
 
305
void toTreeWidget::setSelected(toTreeWidgetItem* item, bool selected)
 
306
{
 
307
    item->setSelected(selected);
 
308
}
 
309
 
 
310
 
 
311
void toTreeWidget::ensureItemVisible(const toTreeWidgetItem *tree)
 
312
{
 
313
    QTreeWidget::scrollToItem(tree);
 
314
}
 
315
 
 
316
 
 
317
void toTreeWidget::setOpen(bool o)
 
318
{
 
319
    int count = toTreeWidget::topLevelItemCount();
 
320
    for (int i = 0; i < count; i++)
 
321
        QTreeWidget::topLevelItem(i)->setExpanded(o);
 
322
}
 
323
 
 
324
 
 
325
void toTreeWidget::setOpen(toTreeWidgetItem *item, bool o)
 
326
{
 
327
    item->setExpanded(o);
 
328
}
 
329
 
 
330
 
 
331
void toTreeWidget::repaintItem(const QTreeWidgetItem *it) const
 
332
{
 
333
    return;                     // stub
 
334
}
 
335
 
 
336
 
 
337
void toTreeWidget::setShowSortIndicator(bool show)
 
338
{
 
339
    return;                     // stub
 
340
}
 
341
 
 
342
 
 
343
QString toTreeWidget::columnText(int column) const
 
344
{
 
345
    return QTreeWidget::headerItem()->text(column);
 
346
}
 
347
 
 
348
 
 
349
QModelIndex toTreeWidget::indexFromItem(QTreeWidgetItem *item,
 
350
                                        int column) const
 
351
{
 
352
    return QTreeWidget::indexFromItem(item, column);
 
353
}
 
354
 
 
355
 
 
356
QTreeWidgetItem* toTreeWidget::itemFromIndex(const QModelIndex &index) const
 
357
{
 
358
    return QTreeWidget::itemFromIndex(index);
 
359
}
 
360
 
 
361
 
 
362
void toTreeWidget::selectAll(bool s)
 
363
{
 
364
    if (!s)
 
365
        QTreeWidget::clearSelection();
 
366
    else
 
367
        QTreeWidget::selectAll();
 
368
}
 
369
 
 
370
 
 
371
void toTreeWidget::updateContents()
 
372
{
 
373
    return;                     // stub
 
374
}
 
375
 
 
376
 
 
377
void toTreeWidget::handleSelectionChange()
 
378
{
 
379
    QList<QTreeWidgetItem *> s = QTreeWidget::selectedItems();
 
380
    if (s.size() > 0)
 
381
        emit selectionChanged(dynamic_cast<toTreeWidgetItem *>(s.at(0)));
 
382
 
 
383
    emit selectionChanged();
 
384
}
 
385
 
 
386
 
 
387
void toTreeWidget::handleDoubleClick(QTreeWidgetItem *item, int column)
 
388
{
 
389
    if (!item || column < 0)
 
390
        return;
 
391
    emit doubleClicked(dynamic_cast<toTreeWidgetItem *>(item));
 
392
}
 
393
 
 
394
 
 
395
void toTreeWidget::handleClick(QTreeWidgetItem *item, int column)
 
396
{
 
397
    if (!item || column < 0)
 
398
        return;
 
399
    emit clicked(dynamic_cast<toTreeWidgetItem *>(item));
 
400
}
 
401
 
 
402
 
 
403
void toTreeWidget::handleExpanded(QTreeWidgetItem *item)
 
404
{
 
405
    if (item)
 
406
        emit(expanded(dynamic_cast<toTreeWidgetItem *>(item)));
 
407
}
 
408
 
 
409
 
 
410
void toTreeWidget::handleCollapsed(QTreeWidgetItem *item)
 
411
{
 
412
    if (item)
 
413
        emit(collapsed(dynamic_cast<toTreeWidgetItem *>(item)));
 
414
}
 
415
 
 
416
 
 
417
void toTreeWidget::handleActivated(QTreeWidgetItem *item, int column)
 
418
{
 
419
    if (item)
 
420
        emit(returnPressed(dynamic_cast<toTreeWidgetItem *>(item)));
 
421
}
 
422
 
 
423
 
 
424
void toTreeWidget::clear(void)
 
425
{
 
426
    QTreeWidget::clear();
 
427
}
 
428
 
 
429
 
 
430
// -------------------------------------------------- item
 
431
 
 
432
toTreeWidgetItem::toTreeWidgetItem(QTreeWidget *parent)
 
433
        : QTreeWidgetItem(parent, QTreeWidgetItem::Type)
 
434
{
 
435
}
 
436
 
 
437
 
 
438
toTreeWidgetItem::toTreeWidgetItem(QTreeWidget *parent, toTreeWidgetItem *after)
 
439
        : QTreeWidgetItem(parent, after, QTreeWidgetItem::Type)
 
440
{
 
441
}
 
442
 
 
443
 
 
444
toTreeWidgetItem::toTreeWidgetItem(toTreeWidget *parent,
 
445
                                   const QString &label0,
 
446
                                   const QString &label1,
 
447
                                   const QString &label2,
 
448
                                   const QString &label3,
 
449
                                   const QString &label4,
 
450
                                   const QString &label5,
 
451
                                   const QString &label6,
 
452
                                   const QString &label7)
 
453
        : QTreeWidgetItem(parent, QTreeWidgetItem::Type)
 
454
{
 
455
    if (!label0.isNull())
 
456
        setText(0, label0);
 
457
    if (!label1.isNull())
 
458
        setText(1, label1);
 
459
    if (!label2.isNull())
 
460
        setText(2, label2);
 
461
    if (!label3.isNull())
 
462
        setText(3, label3);
 
463
    if (!label4.isNull())
 
464
        setText(4, label4);
 
465
    if (!label5.isNull())
 
466
        setText(5, label5);
 
467
    if (!label6.isNull())
 
468
        setText(6, label6);
 
469
    if (!label7.isNull())
 
470
        setText(7, label7);
 
471
}
 
472
 
 
473
 
 
474
toTreeWidgetItem::toTreeWidgetItem(toTreeWidget *parent,
 
475
                                   toTreeWidgetItem *after,
 
476
                                   const QString &label0,
 
477
                                   const QString &label1,
 
478
                                   const QString &label2,
 
479
                                   const QString &label3,
 
480
                                   const QString &label4,
 
481
                                   const QString &label5,
 
482
                                   const QString &label6,
 
483
                                   const QString &label7)
 
484
        : QTreeWidgetItem(parent, after, QTreeWidgetItem::Type)
 
485
{
 
486
    if (!label0.isNull())
 
487
        setText(0, label0);
 
488
    if (!label1.isNull())
 
489
        setText(1, label1);
 
490
    if (!label2.isNull())
 
491
        setText(2, label2);
 
492
    if (!label3.isNull())
 
493
        setText(3, label3);
 
494
    if (!label4.isNull())
 
495
        setText(4, label4);
 
496
    if (!label5.isNull())
 
497
        setText(5, label5);
 
498
    if (!label6.isNull())
 
499
        setText(6, label6);
 
500
    if (!label7.isNull())
 
501
        setText(7, label7);
 
502
}
 
503
 
 
504
 
 
505
toTreeWidgetItem::toTreeWidgetItem(toTreeWidgetItem *parent,
 
506
                                   toTreeWidgetItem *after,
 
507
                                   const QString &label0,
 
508
                                   const QString &label1,
 
509
                                   const QString &label2,
 
510
                                   const QString &label3,
 
511
                                   const QString &label4,
 
512
                                   const QString &label5,
 
513
                                   const QString &label6,
 
514
                                   const QString &label7)
 
515
        : QTreeWidgetItem(parent, after, QTreeWidgetItem::Type)
 
516
{
 
517
    if (!label0.isNull())
 
518
        setText(0, label0);
 
519
    if (!label1.isNull())
 
520
        setText(1, label1);
 
521
    if (!label2.isNull())
 
522
        setText(2, label2);
 
523
    if (!label3.isNull())
 
524
        setText(3, label3);
 
525
    if (!label4.isNull())
 
526
        setText(4, label4);
 
527
    if (!label5.isNull())
 
528
        setText(5, label5);
 
529
    if (!label6.isNull())
 
530
        setText(6, label6);
 
531
    if (!label7.isNull())
 
532
        setText(7, label7);
 
533
}
 
534
 
 
535
 
 
536
toTreeWidgetItem::toTreeWidgetItem(toTreeWidgetItem *parent,
 
537
                                   const QString &label0,
 
538
                                   const QString &label1,
 
539
                                   const QString &label2,
 
540
                                   const QString &label3,
 
541
                                   const QString &label4,
 
542
                                   const QString &label5,
 
543
                                   const QString &label6,
 
544
                                   const QString &label7)
 
545
        : QTreeWidgetItem(parent, QTreeWidgetItem::Type)
 
546
{
 
547
    if (!label0.isNull())
 
548
        setText(0, label0);
 
549
    if (!label1.isNull())
 
550
        setText(1, label1);
 
551
    if (!label2.isNull())
 
552
        setText(2, label2);
 
553
    if (!label3.isNull())
 
554
        setText(3, label3);
 
555
    if (!label4.isNull())
 
556
        setText(4, label4);
 
557
    if (!label5.isNull())
 
558
        setText(5, label5);
 
559
    if (!label6.isNull())
 
560
        setText(6, label6);
 
561
    if (!label7.isNull())
 
562
        setText(7, label7);
 
563
}
 
564
 
 
565
 
 
566
toTreeWidgetItem* toTreeWidgetItem::nextSibling() const
 
567
{
 
568
    toTreeWidget *tree = dynamic_cast<toTreeWidget *>(
 
569
                             QTreeWidgetItem::treeWidget());
 
570
    if (!tree)
 
571
        return 0;
 
572
 
 
573
    QModelIndex index = tree->indexFromItem(const_cast<toTreeWidgetItem *>(this));
 
574
    QModelIndex sibling = index.sibling(index.row() + 1, index.column());
 
575
 
 
576
    if (sibling.isValid())
 
577
        return dynamic_cast<toTreeWidgetItem *>(tree->itemFromIndex(sibling));
 
578
 
 
579
    return 0;
 
580
}
 
581
 
 
582
 
 
583
toTreeWidgetItem* toTreeWidgetItem::firstChild() const
 
584
{
 
585
    if (QTreeWidgetItem::childCount() > 0)
 
586
        return dynamic_cast<toTreeWidgetItem *>(QTreeWidgetItem::child(0));
 
587
    return 0;
 
588
}
 
589
 
 
590
 
 
591
toTreeWidgetItem* toTreeWidgetItem::parent() const
 
592
{
 
593
    QTreeWidgetItem *p = QTreeWidgetItem::parent();
 
594
    if (p)
 
595
        return dynamic_cast<toTreeWidgetItem *>(p);
 
596
    return 0;
 
597
}
 
598
 
 
599
 
 
600
toTreeWidget* toTreeWidgetItem::listView() const
 
601
{
 
602
    return dynamic_cast<toTreeWidget *>(QTreeWidgetItem::treeWidget());
 
603
}
 
604
 
 
605
 
 
606
toTreeWidgetItem* toTreeWidgetItem::itemAbove() const
 
607
{
 
608
    return parent();
 
609
}
 
610
 
 
611
 
 
612
toTreeWidgetItem* toTreeWidgetItem::itemBelow() const
 
613
{
 
614
    return firstChild();
 
615
}
 
616
 
 
617
 
 
618
int toTreeWidgetItem::width(const QFontMetrics &fm,
 
619
                            const toTreeWidget *lv,
 
620
                            int c) const
 
621
{
 
622
    return 10;                  // stub
 
623
}
 
624
 
 
625
 
 
626
int toTreeWidgetItem::height()
 
627
{
 
628
    return 10;                  // stub
 
629
}
 
630
 
 
631
 
 
632
bool toTreeWidgetItem::isOpen(void) const
 
633
{
 
634
    return QTreeWidgetItem::isExpanded();
 
635
}
 
636
 
 
637
 
 
638
void toTreeWidgetItem::setOpen(bool o)
 
639
{
 
640
    return QTreeWidgetItem::setExpanded(o);
 
641
}
 
642
 
 
643
 
 
644
void toTreeWidgetItem::setPixmap(int col, const QPixmap &pix)
 
645
{
 
646
    QTreeWidgetItem::setIcon(col, QIcon(pix));
 
647
}
 
648
 
 
649
 
 
650
void toTreeWidgetItem::setSelectable(bool enable)
 
651
{
 
652
    // xor out the selectable flag
 
653
    Qt::ItemFlags fl = QTreeWidgetItem::flags() ^ Qt::ItemIsSelectable;
 
654
    QTreeWidgetItem::setFlags(fl);
 
655
}
 
656
 
 
657
 
 
658
void toTreeWidgetItem::moveItem(toTreeWidgetItem *after)
 
659
{
 
660
    return;                     // todo
 
661
}
 
662
 
 
663
 
 
664
void toTreeWidgetItem::setEnabled(bool b)
 
665
{
 
666
    Qt::ItemFlags fl = QTreeWidgetItem::flags();
 
667
    if (!b)
 
668
    {
 
669
        // xor out the enabled flag
 
670
        fl = fl ^ Qt::ItemIsEnabled;
 
671
    }
 
672
    else
 
673
    {
 
674
        // add enabled
 
675
        fl = fl | Qt::ItemIsEnabled;
 
676
    }
 
677
 
 
678
    QTreeWidgetItem::setFlags(fl);
 
679
}
 
680
 
 
681
 
 
682
bool toTreeWidgetItem::isEnabled() const
 
683
{
 
684
    return QTreeWidgetItem::flags() & Qt::ItemIsEnabled;
 
685
}
 
686
 
 
687
 
 
688
void toTreeWidgetItem::setExpandable(bool o)
 
689
{
 
690
    if (!o)
 
691
    {
 
692
        toTreeWidgetItem::setChildIndicatorPolicy(
 
693
            QTreeWidgetItem::DontShowIndicator);
 
694
    }
 
695
    else
 
696
    {
 
697
        toTreeWidgetItem::setChildIndicatorPolicy(
 
698
            QTreeWidgetItem::ShowIndicator);
 
699
    }
 
700
}
 
701
 
 
702
 
 
703
int toTreeWidgetItem::depth() const
 
704
{
 
705
    QTreeWidgetItem *parent;
 
706
    int d = 0;
 
707
    while ((parent = QTreeWidgetItem::parent()) != NULL)
 
708
        d++;
 
709
 
 
710
    return d;
 
711
}
 
712
 
 
713
 
 
714
// -------------------------------------------------- check item
 
715
 
 
716
toTreeWidgetCheck::toTreeWidgetCheck(toTreeWidget *parent,
 
717
                                     const QString &text,
 
718
                                     Type)
 
719
        : toTreeWidgetItem(parent, text)
 
720
{
 
721
    setOn(false);
 
722
}
 
723
 
 
724
 
 
725
toTreeWidgetCheck::toTreeWidgetCheck(toTreeWidgetItem *parent,
 
726
                                     const QString &text,
 
727
                                     Type)
 
728
        : toTreeWidgetItem(parent, text)
 
729
{
 
730
    setOn(false);
 
731
}
 
732
 
 
733
 
 
734
toTreeWidgetCheck::toTreeWidgetCheck(toTreeWidget *parent,
 
735
                                     toTreeWidgetItem *after,
 
736
                                     const QString &text,
 
737
                                     Type)
 
738
        : toTreeWidgetItem(parent, after, text)
 
739
{
 
740
    setOn(false);
 
741
}
 
742
 
 
743
 
 
744
toTreeWidgetCheck::toTreeWidgetCheck(toTreeWidgetItem *parent,
 
745
                                     toTreeWidgetItem *after,
 
746
                                     const QString &text,
 
747
                                     Type)
 
748
        : toTreeWidgetItem(parent, after, text)
 
749
{
 
750
    setOn(false);
 
751
}
 
752
 
 
753
 
 
754
bool toTreeWidgetCheck::isOn() const
 
755
{
 
756
    return checkState(0) == Qt::Checked;
 
757
}
 
758
 
 
759
 
 
760
void toTreeWidgetCheck::setOn(bool b)
 
761
{
 
762
    setCheckState(0, b ? Qt::Checked : Qt::Unchecked);
 
763
}