source: trunk/tools/designer/src/components/widgetbox/widgetboxtreewidget.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 32.8 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation (qt-info@nokia.com)
6**
7** This file is part of the Qt Designer of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "widgetboxtreewidget.h"
43#include "widgetboxcategorylistview.h"
44
45// shared
46#include <iconloader_p.h>
47#include <sheet_delegate_p.h>
48#include <QtDesigner/private/abstractsettings_p.h>
49#include <ui4_p.h>
50#include <qdesigner_utils_p.h>
51#include <pluginmanager_p.h>
52
53// sdk
54#include <QtDesigner/QDesignerFormEditorInterface>
55#include <QtDesigner/QDesignerDnDItemInterface>
56#include <QtDesigner/QDesignerCustomWidgetInterface>
57#include <QtDesigner/private/abstractsettings_p.h>
58
59#include <QtGui/QHeaderView>
60#include <QtGui/QApplication>
61#include <QtGui/QTreeWidgetItem>
62#include <QtGui/QContextMenuEvent>
63#include <QtGui/QAction>
64#include <QtGui/QActionGroup>
65#include <QtGui/QMenu>
66
67#include <QtCore/QFile>
68#include <QtCore/QTimer>
69#include <QtCore/QDebug>
70
71static const char *widgetBoxRootElementC = "widgetbox";
72static const char *widgetElementC = "widget";
73static const char *uiElementC = "ui";
74static const char *categoryElementC = "category";
75static const char *categoryEntryElementC = "categoryentry";
76static const char *nameAttributeC = "name";
77static const char *typeAttributeC = "type";
78static const char *iconAttributeC = "icon";
79static const char *defaultTypeValueC = "default";
80static const char *customValueC = "custom";
81static const char *iconPrefixC = "__qt_icon__";
82static const char *scratchPadValueC = "scratchpad";
83static const char *qtLogoC = "qtlogo.png";
84static const char *invisibleNameC = "[invisible]";
85
86enum TopLevelRole { NORMAL_ITEM, SCRATCHPAD_ITEM, CUSTOM_ITEM };
87
88QT_BEGIN_NAMESPACE
89
90static void setTopLevelRole(TopLevelRole tlr, QTreeWidgetItem *item)
91{
92 item->setData(0, Qt::UserRole, QVariant(tlr));
93}
94
95static TopLevelRole topLevelRole(const QTreeWidgetItem *item)
96{
97 return static_cast<TopLevelRole>(item->data(0, Qt::UserRole).toInt());
98}
99
100namespace qdesigner_internal {
101
102WidgetBoxTreeWidget::WidgetBoxTreeWidget(QDesignerFormEditorInterface *core, QWidget *parent) :
103 QTreeWidget(parent),
104 m_core(core),
105 m_iconMode(false),
106 m_scratchPadDeleteTimer(0)
107{
108 setFocusPolicy(Qt::NoFocus);
109 setIndentation(0);
110 setRootIsDecorated(false);
111 setColumnCount(1);
112 header()->hide();
113 header()->setResizeMode(QHeaderView::Stretch);
114 setTextElideMode(Qt::ElideMiddle);
115 setVerticalScrollMode(ScrollPerPixel);
116
117 setItemDelegate(new SheetDelegate(this, this));
118
119 connect(this, SIGNAL(itemPressed(QTreeWidgetItem*,int)),
120 this, SLOT(handleMousePress(QTreeWidgetItem*)));
121}
122
123QIcon WidgetBoxTreeWidget::iconForWidget(QString iconName) const
124{
125 if (iconName.isEmpty())
126 iconName = QLatin1String(qtLogoC);
127
128 if (iconName.startsWith(QLatin1String(iconPrefixC))) {
129 const IconCache::const_iterator it = m_pluginIcons.constFind(iconName);
130 if (it != m_pluginIcons.constEnd())
131 return it.value();
132 }
133 return createIconSet(iconName);
134}
135
136WidgetBoxCategoryListView *WidgetBoxTreeWidget::categoryViewAt(int idx) const
137{
138 WidgetBoxCategoryListView *rc = 0;
139 if (QTreeWidgetItem *cat_item = topLevelItem(idx))
140 if (QTreeWidgetItem *embedItem = cat_item->child(0))
141 rc = qobject_cast<WidgetBoxCategoryListView*>(itemWidget(embedItem, 0));
142 Q_ASSERT(rc);
143 return rc;
144}
145
146void WidgetBoxTreeWidget::saveExpandedState() const
147{
148 QStringList closedCategories;
149 if (const int numCategories = categoryCount()) {
150 for (int i = 0; i < numCategories; ++i) {
151 const QTreeWidgetItem *cat_item = topLevelItem(i);
152 if (!isItemExpanded(cat_item))
153 closedCategories.append(cat_item->text(0));
154 }
155 }
156 QDesignerSettingsInterface *settings = m_core->settingsManager();
157 settings->beginGroup(QLatin1String(widgetBoxRootElementC));
158 settings->setValue(QLatin1String("Closed categories"), closedCategories);
159 settings->setValue(QLatin1String("View mode"), m_iconMode);
160 settings->endGroup();
161}
162
163void WidgetBoxTreeWidget::restoreExpandedState()
164{
165 typedef QSet<QString> StringSet;
166 QDesignerSettingsInterface *settings = m_core->settingsManager();
167 m_iconMode = settings->value(QLatin1String("WidgetBox/View mode")).toBool();
168 updateViewMode();
169 const StringSet closedCategories = settings->value(QLatin1String("WidgetBox/Closed categories"), QStringList()).toStringList().toSet();
170 expandAll();
171 if (closedCategories.empty())
172 return;
173
174 if (const int numCategories = categoryCount()) {
175 for (int i = 0; i < numCategories; ++i) {
176 QTreeWidgetItem *item = topLevelItem(i);
177 if (closedCategories.contains(item->text(0)))
178 item->setExpanded(false);
179 }
180 }
181}
182
183WidgetBoxTreeWidget::~WidgetBoxTreeWidget()
184{
185 saveExpandedState();
186}
187
188void WidgetBoxTreeWidget::setFileName(const QString &file_name)
189{
190 m_file_name = file_name;
191}
192
193QString WidgetBoxTreeWidget::fileName() const
194{
195 return m_file_name;
196}
197
198bool WidgetBoxTreeWidget::save()
199{
200 if (fileName().isEmpty())
201 return false;
202
203 QFile file(fileName());
204 if (!file.open(QIODevice::WriteOnly))
205 return false;
206
207 CategoryList cat_list;
208 const int count = categoryCount();
209 for (int i = 0; i < count; ++i)
210 cat_list.append(category(i));
211
212 QXmlStreamWriter writer(&file);
213 writer.setAutoFormatting(true);
214 writer.setAutoFormattingIndent(1);
215 writer.writeStartDocument();
216 writeCategories(writer, cat_list);
217 writer.writeEndDocument();
218
219 return true;
220}
221
222void WidgetBoxTreeWidget::slotSave()
223{
224 save();
225}
226
227void WidgetBoxTreeWidget::handleMousePress(QTreeWidgetItem *item)
228{
229 if (item == 0)
230 return;
231
232 if (QApplication::mouseButtons() != Qt::LeftButton)
233 return;
234
235 if (item->parent() == 0) {
236 setItemExpanded(item, !isItemExpanded(item));
237 return;
238 }
239}
240
241int WidgetBoxTreeWidget::ensureScratchpad()
242{
243 const int existingIndex = indexOfScratchpad();
244 if (existingIndex != -1)
245 return existingIndex;
246
247 QTreeWidgetItem *scratch_item = new QTreeWidgetItem(this);
248 scratch_item->setText(0, tr("Scratchpad"));
249 setTopLevelRole(SCRATCHPAD_ITEM, scratch_item);
250 addCategoryView(scratch_item, false); // Scratchpad in list mode.
251 return categoryCount() - 1;
252}
253
254WidgetBoxCategoryListView *WidgetBoxTreeWidget::addCategoryView(QTreeWidgetItem *parent, bool iconMode)
255{
256 QTreeWidgetItem *embed_item = new QTreeWidgetItem(parent);
257 embed_item->setFlags(Qt::ItemIsEnabled);
258 WidgetBoxCategoryListView *categoryView = new WidgetBoxCategoryListView(m_core, this);
259 categoryView->setViewMode(iconMode ? QListView::IconMode : QListView::ListMode);
260 connect(categoryView, SIGNAL(scratchPadChanged()), this, SLOT(slotSave()));
261 connect(categoryView, SIGNAL(pressed(QString,QString,QPoint)), this, SIGNAL(pressed(QString,QString,QPoint)));
262 connect(categoryView, SIGNAL(itemRemoved()), this, SLOT(slotScratchPadItemDeleted()));
263 connect(categoryView, SIGNAL(lastItemRemoved()), this, SLOT(slotLastScratchPadItemDeleted()));
264 setItemWidget(embed_item, 0, categoryView);
265 return categoryView;
266}
267
268int WidgetBoxTreeWidget::indexOfScratchpad() const
269{
270 if (const int numTopLevels = topLevelItemCount()) {
271 for (int i = numTopLevels - 1; i >= 0; --i) {
272 if (topLevelRole(topLevelItem(i)) == SCRATCHPAD_ITEM)
273 return i;
274 }
275 }
276 return -1;
277}
278
279int WidgetBoxTreeWidget::indexOfCategory(const QString &name) const
280{
281 const int topLevelCount = topLevelItemCount();
282 for (int i = 0; i < topLevelCount; ++i) {
283 if (topLevelItem(i)->text(0) == name)
284 return i;
285 }
286 return -1;
287}
288
289bool WidgetBoxTreeWidget::load(QDesignerWidgetBox::LoadMode loadMode)
290{
291 switch (loadMode) {
292 case QDesignerWidgetBox::LoadReplace:
293 clear();
294 break;
295 case QDesignerWidgetBox::LoadCustomWidgetsOnly:
296 addCustomCategories(true);
297 updateGeometries();
298 return true;
299 default:
300 break;
301 }
302
303 const QString name = fileName();
304
305 QFile f(name);
306 if (!f.open(QIODevice::ReadOnly)) // Might not exist at first startup
307 return false;
308
309 const QString contents = QString::fromUtf8(f.readAll());
310 return loadContents(contents);
311}
312
313bool WidgetBoxTreeWidget::loadContents(const QString &contents)
314{
315 QString errorMessage;
316 CategoryList cat_list;
317 if (!readCategories(m_file_name, contents, &cat_list, &errorMessage)) {
318 qdesigner_internal::designerWarning(errorMessage);
319 return false;
320 }
321
322 foreach(const Category &cat, cat_list)
323 addCategory(cat);
324
325 addCustomCategories(false);
326 // Restore which items are expanded
327 restoreExpandedState();
328 return true;
329}
330
331void WidgetBoxTreeWidget::addCustomCategories(bool replace)
332{
333 if (replace) {
334 // clear out all existing custom widgets
335 if (const int numTopLevels = topLevelItemCount()) {
336 for (int t = 0; t < numTopLevels ; ++t)
337 categoryViewAt(t)->removeCustomWidgets();
338 }
339 }
340 // re-add
341 const CategoryList customList = loadCustomCategoryList();
342 const CategoryList::const_iterator cend = customList.constEnd();
343 for (CategoryList::const_iterator it = customList.constBegin(); it != cend; ++it)
344 addCategory(*it);
345}
346
347static inline QString msgXmlError(const QString &fileName, const QXmlStreamReader &r)
348{
349 return QDesignerWidgetBox::tr("An error has been encountered at line %1 of %2: %3")
350 .arg(r.lineNumber()).arg(fileName, r.errorString());
351}
352
353bool WidgetBoxTreeWidget::readCategories(const QString &fileName, const QString &contents,
354 CategoryList *cats, QString *errorMessage)
355{
356 // Read widget box XML:
357 //
358 //<widgetbox version="4.5">
359 // <category name="Layouts">
360 // <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default">
361 // <widget class="QListWidget" ...>
362 // ...
363
364 QXmlStreamReader reader(contents);
365
366
367 // Entries of category with name="invisible" should be ignored
368 bool ignoreEntries = false;
369
370 while (!reader.atEnd()) {
371 switch (reader.readNext()) {
372 case QXmlStreamReader::StartElement: {
373 const QStringRef tag = reader.name();
374 if (tag == QLatin1String(widgetBoxRootElementC)) {
375 //<widgetbox version="4.5">
376 continue;
377 }
378 if (tag == QLatin1String(categoryElementC)) {
379 // <category name="Layouts">
380 const QXmlStreamAttributes attributes = reader.attributes();
381 const QString categoryName = attributes.value(QLatin1String(nameAttributeC)).toString();
382 if (categoryName == QLatin1String(invisibleNameC)) {
383 ignoreEntries = true;
384 } else {
385 Category category(categoryName);
386 if (attributes.value(QLatin1String(typeAttributeC)) == QLatin1String(scratchPadValueC))
387 category.setType(Category::Scratchpad);
388 cats->push_back(category);
389 }
390 continue;
391 }
392 if (tag == QLatin1String(categoryEntryElementC)) {
393 // <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default">
394 if (!ignoreEntries) {
395 QXmlStreamAttributes attr = reader.attributes();
396 const QString widgetName = attr.value(QLatin1String(nameAttributeC)).toString();
397 const QString widgetIcon = attr.value(QLatin1String(iconAttributeC)).toString();
398 const WidgetBoxTreeWidget::Widget::Type widgetType =
399 attr.value(QLatin1String(typeAttributeC)).toString()
400 == QLatin1String(customValueC) ?
401 WidgetBoxTreeWidget::Widget::Custom :
402 WidgetBoxTreeWidget::Widget::Default;
403
404 Widget w;
405 w.setName(widgetName);
406 w.setIconName(widgetIcon);
407 w.setType(widgetType);
408 if (!readWidget(&w, contents, reader))
409 continue;
410
411 cats->back().addWidget(w);
412 } // ignoreEntries
413 continue;
414 }
415 break;
416 }
417 case QXmlStreamReader::EndElement: {
418 const QStringRef tag = reader.name();
419 if (tag == QLatin1String(widgetBoxRootElementC)) {
420 continue;
421 }
422 if (tag == QLatin1String(categoryElementC)) {
423 ignoreEntries = false;
424 continue;
425 }
426 if (tag == QLatin1String(categoryEntryElementC)) {
427 continue;
428 }
429 break;
430 }
431 default: break;
432 }
433 }
434
435 if (reader.hasError()) {
436 *errorMessage = msgXmlError(fileName, reader);
437 return false;
438 }
439
440 return true;
441}
442
443/*!
444 * Read out a widget within a category. This can either be
445 * enclosed in a <ui> element or a (legacy) <widget> element which may
446 * contain nested <widget> elements.
447 *
448 * Examples:
449 *
450 * <ui language="c++">
451 * <widget class="MultiPageWidget" name="multipagewidget"> ... </widget>
452 * <customwidgets>...</customwidgets>
453 * <ui>
454 *
455 * or
456 *
457 * <widget>
458 * <widget> ... </widget>
459 * ...
460 * <widget>
461 *
462 * Returns true on success, false if end was reached or an error has been encountered
463 * in which case the reader has its error flag set. If successful, the current item
464 * of the reader will be the closing element (</ui> or </widget>)
465 */
466bool WidgetBoxTreeWidget::readWidget(Widget *w, const QString &xml, QXmlStreamReader &r)
467{
468 qint64 startTagPosition =0, endTagPosition = 0;
469
470 int nesting = 0;
471 bool endEncountered = false;
472 bool parsedWidgetTag = false;
473 QString outmostElement;
474 while (!endEncountered) {
475 const qint64 currentPosition = r.characterOffset();
476 switch(r.readNext()) {
477 case QXmlStreamReader::StartElement:
478 if (nesting++ == 0) {
479 // First element must be <ui> or (legacy) <widget>
480 const QStringRef name = r.name();
481 if (name == QLatin1String(uiElementC)) {
482 startTagPosition = currentPosition;
483 } else {
484 if (name == QLatin1String(widgetElementC)) {
485 startTagPosition = currentPosition;
486 parsedWidgetTag = true;
487 } else {
488 r.raiseError(QDesignerWidgetBox::tr("Unexpected element <%1> encountered when parsing for <widget> or <ui>").arg(name.toString()));
489 return false;
490 }
491 }
492 } else {
493 // We are within <ui> looking for the first <widget> tag
494 if (!parsedWidgetTag && r.name() == QLatin1String(widgetElementC)) {
495 parsedWidgetTag = true;
496 }
497 }
498 break;
499 case QXmlStreamReader::EndElement:
500 // Reached end of widget?
501 if (--nesting == 0) {
502 endTagPosition = r.characterOffset();
503 endEncountered = true;
504 }
505 break;
506 case QXmlStreamReader::EndDocument:
507 r.raiseError(QDesignerWidgetBox::tr("Unexpected end of file encountered when parsing widgets."));
508 return false;
509 case QXmlStreamReader::Invalid:
510 return false;
511 default:
512 break;
513 }
514 }
515 if (!parsedWidgetTag) {
516 r.raiseError(QDesignerWidgetBox::tr("A widget element could not be found."));
517 return false;
518 }
519 // Oddity: Startposition is 1 off
520 QString widgetXml = xml.mid(startTagPosition, endTagPosition - startTagPosition);
521 const QChar lessThan = QLatin1Char('<');
522 if (!widgetXml.startsWith(lessThan))
523 widgetXml.prepend(lessThan);
524 w->setDomXml(widgetXml);
525 return true;
526}
527
528void WidgetBoxTreeWidget::writeCategories(QXmlStreamWriter &writer, const CategoryList &cat_list) const
529{
530 const QString widgetbox = QLatin1String(widgetBoxRootElementC);
531 const QString name = QLatin1String(nameAttributeC);
532 const QString type = QLatin1String(typeAttributeC);
533 const QString icon = QLatin1String(iconAttributeC);
534 const QString defaultType = QLatin1String(defaultTypeValueC);
535 const QString category = QLatin1String(categoryElementC);
536 const QString categoryEntry = QLatin1String(categoryEntryElementC);
537 const QString iconPrefix = QLatin1String(iconPrefixC);
538 const QString widgetTag = QLatin1String(widgetElementC);
539
540 //
541 // <widgetbox>
542 // <category name="Layouts">
543 // <categoryEntry name="Vertical Layout" type="default" icon="win/editvlayout.png">
544 // <ui>
545 // ...
546 // </ui>
547 // </categoryEntry>
548 // ...
549 // </category>
550 // ...
551 // </widgetbox>
552 //
553
554 writer.writeStartElement(widgetbox);
555
556 foreach (const Category &cat, cat_list) {
557 writer.writeStartElement(category);
558 writer.writeAttribute(name, cat.name());
559 if (cat.type() == Category::Scratchpad)
560 writer.writeAttribute(type, QLatin1String(scratchPadValueC));
561
562 const int widgetCount = cat.widgetCount();
563 for (int i = 0; i < widgetCount; ++i) {
564 const Widget wgt = cat.widget(i);
565 if (wgt.type() == Widget::Custom)
566 continue;
567
568 writer.writeStartElement(categoryEntry);
569 writer.writeAttribute(name, wgt.name());
570 if (!wgt.iconName().startsWith(iconPrefix))
571 writer.writeAttribute(icon, wgt.iconName());
572 writer.writeAttribute(type, defaultType);
573
574 const DomUI *domUI = QDesignerWidgetBox::xmlToUi(wgt.name(), WidgetBoxCategoryListView::widgetDomXml(wgt), false);
575 if (domUI) {
576 domUI->write(writer);
577 delete domUI;
578 }
579
580 writer.writeEndElement(); // categoryEntry
581 }
582 writer.writeEndElement(); // categoryEntry
583 }
584
585 writer.writeEndElement(); // widgetBox
586}
587
588static int findCategory(const QString &name, const WidgetBoxTreeWidget::CategoryList &list)
589{
590 int idx = 0;
591 foreach (const WidgetBoxTreeWidget::Category &cat, list) {
592 if (cat.name() == name)
593 return idx;
594 ++idx;
595 }
596 return -1;
597}
598
599static inline bool isValidIcon(const QIcon &icon)
600{
601 if (!icon.isNull()) {
602 const QList<QSize> availableSizes = icon.availableSizes();
603 if (!availableSizes.empty())
604 return !availableSizes.front().isEmpty();
605 }
606 return false;
607}
608
609WidgetBoxTreeWidget::CategoryList WidgetBoxTreeWidget::loadCustomCategoryList() const
610{
611 CategoryList result;
612
613 const QDesignerPluginManager *pm = m_core->pluginManager();
614 const QDesignerPluginManager::CustomWidgetList customWidgets = pm->registeredCustomWidgets();
615 if (customWidgets.empty())
616 return result;
617
618 static const QString customCatName = tr("Custom Widgets");
619
620 const QString invisible = QLatin1String(invisibleNameC);
621 const QString iconPrefix = QLatin1String(iconPrefixC);
622
623 foreach(QDesignerCustomWidgetInterface *c, customWidgets) {
624 const QString dom_xml = c->domXml();
625 if (dom_xml.isEmpty())
626 continue;
627
628 const QString pluginName = c->name();
629 const QDesignerCustomWidgetData data = pm->customWidgetData(c);
630 QString displayName = data.xmlDisplayName();
631 if (displayName.isEmpty())
632 displayName = pluginName;
633
634 QString cat_name = c->group();
635 if (cat_name.isEmpty())
636 cat_name = customCatName;
637 else if (cat_name == invisible)
638 continue;
639
640 int idx = findCategory(cat_name, result);
641 if (idx == -1) {
642 result.append(Category(cat_name));
643 idx = result.size() - 1;
644 }
645 Category &cat = result[idx];
646
647 const QIcon icon = c->icon();
648
649 QString icon_name;
650 if (isValidIcon(icon)) {
651 icon_name = iconPrefix;
652 icon_name += pluginName;
653 m_pluginIcons.insert(icon_name, icon);
654 } else {
655 icon_name = QLatin1String(qtLogoC);
656 }
657
658 cat.addWidget(Widget(displayName, dom_xml, icon_name, Widget::Custom));
659 }
660
661 return result;
662}
663
664void WidgetBoxTreeWidget::adjustSubListSize(QTreeWidgetItem *cat_item)
665{
666 QTreeWidgetItem *embedItem = cat_item->child(0);
667 if (embedItem == 0)
668 return;
669
670 WidgetBoxCategoryListView *list_widget = static_cast<WidgetBoxCategoryListView*>(itemWidget(embedItem, 0));
671 list_widget->setFixedWidth(header()->width());
672 list_widget->doItemsLayout();
673 const int height = qMax(list_widget->contentsSize().height() ,1);
674 list_widget->setFixedHeight(height);
675 embedItem->setSizeHint(0, QSize(-1, height - 1));
676}
677
678int WidgetBoxTreeWidget::categoryCount() const
679{
680 return topLevelItemCount();
681}
682
683WidgetBoxTreeWidget::Category WidgetBoxTreeWidget::category(int cat_idx) const
684{
685 if (cat_idx >= topLevelItemCount())
686 return Category();
687
688 QTreeWidgetItem *cat_item = topLevelItem(cat_idx);
689
690 QTreeWidgetItem *embedItem = cat_item->child(0);
691 WidgetBoxCategoryListView *categoryView = static_cast<WidgetBoxCategoryListView*>(itemWidget(embedItem, 0));
692
693 Category result = categoryView->category();
694 result.setName(cat_item->text(0));
695
696 switch (topLevelRole(cat_item)) {
697 case SCRATCHPAD_ITEM:
698 result.setType(Category::Scratchpad);
699 break;
700 default:
701 result.setType(Category::Default);
702 break;
703 }
704 return result;
705}
706
707void WidgetBoxTreeWidget::addCategory(const Category &cat)
708{
709 if (cat.widgetCount() == 0)
710 return;
711
712 const bool isScratchPad = cat.type() == Category::Scratchpad;
713 WidgetBoxCategoryListView *categoryView;
714 QTreeWidgetItem *cat_item;
715
716 if (isScratchPad) {
717 const int idx = ensureScratchpad();
718 categoryView = categoryViewAt(idx);
719 cat_item = topLevelItem(idx);
720 } else {
721 const int existingIndex = indexOfCategory(cat.name());
722 if (existingIndex == -1) {
723 cat_item = new QTreeWidgetItem();
724 cat_item->setText(0, cat.name());
725 setTopLevelRole(NORMAL_ITEM, cat_item);
726 // insert before scratchpad
727 const int scratchPadIndex = indexOfScratchpad();
728 if (scratchPadIndex == -1) {
729 addTopLevelItem(cat_item);
730 } else {
731 insertTopLevelItem(scratchPadIndex, cat_item);
732 }
733 setItemExpanded(cat_item, true);
734 categoryView = addCategoryView(cat_item, m_iconMode);
735 } else {
736 categoryView = categoryViewAt(existingIndex);
737 cat_item = topLevelItem(existingIndex);
738 }
739 }
740 // The same categories are read from the file $HOME, avoid duplicates
741 const int widgetCount = cat.widgetCount();
742 for (int i = 0; i < widgetCount; ++i) {
743 const Widget w = cat.widget(i);
744 if (!categoryView->containsWidget(w.name()))
745 categoryView->addWidget(w, iconForWidget(w.iconName()), isScratchPad);
746 }
747 adjustSubListSize(cat_item);
748}
749
750void WidgetBoxTreeWidget::removeCategory(int cat_idx)
751{
752 if (cat_idx >= topLevelItemCount())
753 return;
754 delete takeTopLevelItem(cat_idx);
755}
756
757int WidgetBoxTreeWidget::widgetCount(int cat_idx) const
758{
759 if (cat_idx >= topLevelItemCount())
760 return 0;
761 // SDK functions want unfiltered access
762 return categoryViewAt(cat_idx)->count(WidgetBoxCategoryListView::UnfilteredAccess);
763}
764
765WidgetBoxTreeWidget::Widget WidgetBoxTreeWidget::widget(int cat_idx, int wgt_idx) const
766{
767 if (cat_idx >= topLevelItemCount())
768 return Widget();
769 // SDK functions want unfiltered access
770 WidgetBoxCategoryListView *categoryView = categoryViewAt(cat_idx);
771 return categoryView->widgetAt(WidgetBoxCategoryListView::UnfilteredAccess, wgt_idx);
772}
773
774void WidgetBoxTreeWidget::addWidget(int cat_idx, const Widget &wgt)
775{
776 if (cat_idx >= topLevelItemCount())
777 return;
778
779 QTreeWidgetItem *cat_item = topLevelItem(cat_idx);
780 WidgetBoxCategoryListView *categoryView = categoryViewAt(cat_idx);
781
782 const bool scratch = topLevelRole(cat_item) == SCRATCHPAD_ITEM;
783 categoryView->addWidget(wgt, iconForWidget(wgt.iconName()), scratch);
784 adjustSubListSize(cat_item);
785}
786
787void WidgetBoxTreeWidget::removeWidget(int cat_idx, int wgt_idx)
788{
789 if (cat_idx >= topLevelItemCount())
790 return;
791
792 WidgetBoxCategoryListView *categoryView = categoryViewAt(cat_idx);
793
794 // SDK functions want unfiltered access
795 const WidgetBoxCategoryListView::AccessMode am = WidgetBoxCategoryListView::UnfilteredAccess;
796 if (wgt_idx >= categoryView->count(am))
797 return;
798
799 categoryView->removeRow(am, wgt_idx);
800}
801
802void WidgetBoxTreeWidget::slotScratchPadItemDeleted()
803{
804 const int scratch_idx = indexOfScratchpad();
805 QTreeWidgetItem *scratch_item = topLevelItem(scratch_idx);
806 adjustSubListSize(scratch_item);
807 save();
808}
809
810void WidgetBoxTreeWidget::slotLastScratchPadItemDeleted()
811{
812 // Remove the scratchpad in the next idle loop
813 if (!m_scratchPadDeleteTimer) {
814 m_scratchPadDeleteTimer = new QTimer(this);
815 m_scratchPadDeleteTimer->setSingleShot(true);
816 m_scratchPadDeleteTimer->setInterval(0);
817 connect(m_scratchPadDeleteTimer, SIGNAL(timeout()), this, SLOT(deleteScratchpad()));
818 }
819 if (!m_scratchPadDeleteTimer->isActive())
820 m_scratchPadDeleteTimer->start();
821}
822
823void WidgetBoxTreeWidget::deleteScratchpad()
824{
825 const int idx = indexOfScratchpad();
826 if (idx == -1)
827 return;
828 delete takeTopLevelItem(idx);
829 save();
830}
831
832
833void WidgetBoxTreeWidget::slotListMode()
834{
835 m_iconMode = false;
836 updateViewMode();
837}
838
839void WidgetBoxTreeWidget::slotIconMode()
840{
841 m_iconMode = true;
842 updateViewMode();
843}
844
845void WidgetBoxTreeWidget::updateViewMode()
846{
847 if (const int numTopLevels = topLevelItemCount()) {
848 for (int i = numTopLevels - 1; i >= 0; --i) {
849 QTreeWidgetItem *topLevel = topLevelItem(i);
850 // Scratch pad stays in list mode.
851 const QListView::ViewMode viewMode = m_iconMode && (topLevelRole(topLevel) != SCRATCHPAD_ITEM) ? QListView::IconMode : QListView::ListMode;
852 WidgetBoxCategoryListView *categoryView = categoryViewAt(i);
853 if (viewMode != categoryView->viewMode()) {
854 categoryView->setViewMode(viewMode);
855 adjustSubListSize(topLevelItem(i));
856 }
857 }
858 }
859
860 updateGeometries();
861}
862
863void WidgetBoxTreeWidget::resizeEvent(QResizeEvent *e)
864{
865 QTreeWidget::resizeEvent(e);
866 if (const int numTopLevels = topLevelItemCount()) {
867 for (int i = numTopLevels - 1; i >= 0; --i)
868 adjustSubListSize(topLevelItem(i));
869 }
870}
871
872void WidgetBoxTreeWidget::contextMenuEvent(QContextMenuEvent *e)
873{
874 QTreeWidgetItem *item = itemAt(e->pos());
875
876 const bool scratchpad_menu = item != 0
877 && item->parent() != 0
878 && topLevelRole(item->parent()) == SCRATCHPAD_ITEM;
879
880 QMenu menu;
881 menu.addAction(tr("Expand all"), this, SLOT(expandAll()));
882 menu.addAction(tr("Collapse all"), this, SLOT(collapseAll()));
883 menu.addSeparator();
884
885 QAction *listModeAction = menu.addAction(tr("List View"));
886 QAction *iconModeAction = menu.addAction(tr("Icon View"));
887 listModeAction->setCheckable(true);
888 iconModeAction->setCheckable(true);
889 QActionGroup *viewModeGroup = new QActionGroup(&menu);
890 viewModeGroup->addAction(listModeAction);
891 viewModeGroup->addAction(iconModeAction);
892 if (m_iconMode)
893 iconModeAction->setChecked(true);
894 else
895 listModeAction->setChecked(true);
896 connect(listModeAction, SIGNAL(triggered()), SLOT(slotListMode()));
897 connect(iconModeAction, SIGNAL(triggered()), SLOT(slotIconMode()));
898
899 if (scratchpad_menu) {
900 menu.addSeparator();
901 menu.addAction(tr("Remove"), itemWidget(item, 0), SLOT(removeCurrentItem()));
902 if (!m_iconMode)
903 menu.addAction(tr("Edit name"), itemWidget(item, 0), SLOT(editCurrentItem()));
904 }
905 e->accept();
906 menu.exec(mapToGlobal(e->pos()));
907}
908
909void WidgetBoxTreeWidget::dropWidgets(const QList<QDesignerDnDItemInterface*> &item_list)
910{
911 QTreeWidgetItem *scratch_item = 0;
912 WidgetBoxCategoryListView *categoryView = 0;
913 bool added = false;
914
915 foreach (QDesignerDnDItemInterface *item, item_list) {
916 QWidget *w = item->widget();
917 if (w == 0)
918 continue;
919
920 DomUI *dom_ui = item->domUi();
921 if (dom_ui == 0)
922 continue;
923
924 const int scratch_idx = ensureScratchpad();
925 scratch_item = topLevelItem(scratch_idx);
926 categoryView = categoryViewAt(scratch_idx);
927
928 // Temporarily remove the fake toplevel in-between
929 DomWidget *fakeTopLevel = dom_ui->takeElementWidget();
930 DomWidget *firstWidget = 0;
931 if (fakeTopLevel && !fakeTopLevel->elementWidget().isEmpty()) {
932 firstWidget = fakeTopLevel->elementWidget().first();
933 dom_ui->setElementWidget(firstWidget);
934 } else {
935 dom_ui->setElementWidget(fakeTopLevel);
936 continue;
937 }
938
939 // Serialize to XML
940 QString xml;
941 {
942 QXmlStreamWriter writer(&xml);
943 writer.setAutoFormatting(true);
944 writer.setAutoFormattingIndent(1);
945 writer.writeStartDocument();
946 dom_ui->write(writer);
947 writer.writeEndDocument();
948 }
949
950 // Insert fake toplevel again
951 dom_ui->takeElementWidget();
952 dom_ui->setElementWidget(fakeTopLevel);
953
954 const Widget wgt = Widget(w->objectName(), xml);
955 categoryView->addWidget(wgt, iconForWidget(wgt.iconName()), true);
956 setItemExpanded(scratch_item, true);
957 added = true;
958 }
959
960 if (added) {
961 save();
962 QApplication::setActiveWindow(this);
963 // Is the new item visible in filtered mode?
964 const WidgetBoxCategoryListView::AccessMode am = WidgetBoxCategoryListView::FilteredAccess;
965 if (const int count = categoryView->count(am))
966 categoryView->setCurrentItem(am, count - 1);
967 categoryView->adjustSize(); // XXX
968 adjustSubListSize(scratch_item);
969 }
970}
971
972void WidgetBoxTreeWidget::filter(const QString &f)
973{
974 const bool empty = f.isEmpty();
975 const QRegExp re = empty ? QRegExp() : QRegExp(f, Qt::CaseInsensitive, QRegExp::FixedString);
976 const int numTopLevels = topLevelItemCount();
977 bool changed = false;
978 for (int i = 0; i < numTopLevels; i++) {
979 QTreeWidgetItem *tl = topLevelItem(i);
980 WidgetBoxCategoryListView *categoryView = categoryViewAt(i);
981 // Anything changed? -> Enable the category
982 const int oldCount = categoryView->count(WidgetBoxCategoryListView::FilteredAccess);
983 categoryView->filter(re);
984 const int newCount = categoryView->count(WidgetBoxCategoryListView::FilteredAccess);
985 if (oldCount != newCount) {
986 changed = true;
987 const bool categoryEnabled = newCount > 0 || empty;
988 if (categoryEnabled) {
989 categoryView->adjustSize();
990 adjustSubListSize(tl);
991 }
992 setRowHidden (i, QModelIndex(), !categoryEnabled);
993 }
994 }
995 if (changed)
996 updateGeometries();
997}
998
999} // namespace qdesigner_internal
1000
1001QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.