FCL/sf/mw/hb: comparison src/hbcore/gui/hbcssinspector

equal deleted inserted replaced

-:e6ad4ef83b23
+:b7da29130b0e
 #include <hbcolorscheme.h>
 #include <hbcssformatter_p.h>
 #include <hbevent.h>
 #include <hbframedrawer.h>
 #include <hbframeitem.h>
+#include <hbgraphicsscene_p.h>
 #include <hbiconitem.h>
 #include <hbinstance.h>
 #include <hblayeredstyleloader_p.h>
 #include <hbmainwindow_p.h>
 #include <hbmarqueeitem.h>
 #include <hbnamespace_p.h>
+#include <hbpopupmanager_p.h>
+#include <hbpopupmanager_p_p.h>
 #include <hbscreen_p.h>
 #include <hbtextitem.h>
 #include <hbwidgetloadersyntax_p.h>
 #include <hbxmlloaderabstractsyntax_p.h>
 #include <hbwidgetbase_p.h>
 const qreal SIZE_PREF_DRAW_SIZE = 7.0;
 const qreal SIZE_PREF_MINIMUM_THRESHOLD = 4.0 * SIZE_PREF_DRAW_SIZE;
 const qreal SIZE_PREF_LINE_WIDTH = 1.0;
 const qreal SIZE_PREF_ALLOWED_OVERLAP = 2.0;
 const qreal SIZE_PREF_BOX_SIZE = 0.4 * SIZE_PREF_DRAW_SIZE;
+const QString ROOT_TREE_ELEMENT("HbScreen");
 static QString itemClass(const QGraphicsItem *item)
 {
 if (item && item->isWidget()) {
 const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item);
 mLabel->setLayoutDirection(dir);
 mTextBox->setLayoutDirection(dir);
 }
 /******************************************************************************************/
-CssInspectorModelItem::CssInspectorModelItem(QGraphicsItem *item, int row, CssInspectorModelItem *parent)
+ModelItemWrapper::ModelItemWrapper(QGraphicsItem *item)
+: mGraphicsItem(item), mWindow(0), mPopupMgr(0)
+{
+}
+ModelItemWrapper::ModelItemWrapper(HbMainWindow *win)
+: mGraphicsItem(0), mWindow(win), mPopupMgr(0)
+{
+}
+ModelItemWrapper::ModelItemWrapper(HbPopupManager *mgr)
+: mGraphicsItem(0), mWindow(0), mPopupMgr(mgr)
+{
+}
+ModelItemWrapper::ModelItemWrapper()
+: mGraphicsItem(0), mWindow(0), mPopupMgr(0)
+{
+}
+QGraphicsItem* ModelItemWrapper::graphicsItem() const
+{
+return mGraphicsItem;
+}
+HbMainWindow* ModelItemWrapper::window() const
+{
+return mWindow;
+}
+HbPopupManager* ModelItemWrapper::popupManager() const
+{
+return mPopupMgr;
+}
+/******************************************************************************************/
+CssInspectorModelItem::CssInspectorModelItem(ModelItemWrapper *item, int row, CssInspectorModelItem *parent)
 : mItem(item), mParent(parent), mRow(row)
 {
 }
 CssInspectorModelItem::~CssInspectorModelItem()
 {
 QHash<int, CssInspectorModelItem*>::iterator it;
 for (it = mChildren.begin(); it!= mChildren.end(); ++it)
 delete it.value();
+delete mItem;
 }
 CssInspectorModelItem* CssInspectorModelItem::child(int i)
 {
 if (mChildren.contains(i))
 return mChildren[i];
-if (i>=0 && i < mItem->childItems().count()) {
+if (i < 0)
-QGraphicsItem *child = mItem->childItems().at(i);
+return 0;
-CssInspectorModelItem *childItem = new CssInspectorModelItem(child, i, this);
+ModelItemWrapper *wrapper = 0;
+if (mItem->graphicsItem() && i < mItem->graphicsItem()->childItems().count()) {
+QGraphicsItem *child = mItem->graphicsItem()->childItems().at(i);
+wrapper = new ModelItemWrapper(child);
+} else if (mItem->popupManager() && i < mItem->popupManager()->d->popupList.count()) {
+HbPopup *popup = mItem->popupManager()->d->popupList.at(i);
+wrapper = new ModelItemWrapper(popup);
+} else if (mItem->window()) {
+HbMainWindowPrivate *winPriv = HbMainWindowPrivate::d_ptr(mItem->window());
+QGraphicsItem *screen = winPriv->element(HbMainWindowPrivate::ViewportItem);
+if (i < screen->childItems().count()) {
+wrapper = new ModelItemWrapper(screen->childItems().at(i));
+} else if (i == screen->childItems().count()) {
+// Out of bounds due to zero index, return popup manager (this is a special case)
+HbGraphicsScenePrivate *scenePriv = HbGraphicsScenePrivate::d_ptr(winPriv->mScene);
+HbPopupManager *mgr = scenePriv->popupManager();
+wrapper = new ModelItemWrapper(mgr);
+}
+} else {
+// Root node, return from all main windows
+if (i < hbInstance->allMainWindows().count()) {
+HbMainWindow *win = hbInstance->allMainWindows().at(i);
+wrapper = new ModelItemWrapper(win);
+}
+}
+if (wrapper) {
+CssInspectorModelItem *childItem = new CssInspectorModelItem(wrapper, i, this);
 mChildren[i] = childItem;
 return childItem;
 }
 return 0;
 }
 CssInspectorModelItem* CssInspectorModelItem::parent()
 {
 return mParent;
 }
-QGraphicsItem* CssInspectorModelItem::data()
+ModelItemWrapper* CssInspectorModelItem::data()
 {
 return mItem;
 }
 int CssInspectorModelItem::row()
 {
 return mRow;
 }
 /******************************************************************************************/
-CssInspectorModel::CssInspectorModel(HbMainWindow *win, QObject *parent)
+CssInspectorModel::CssInspectorModel(QObject *parent)
-: QAbstractItemModel(parent), mWin(win), mRootItem(0)
+: QAbstractItemModel(parent), mRootItem(0)
 {
-QGraphicsItem *screen = HbMainWindowPrivate::d_ptr(win)->mClippingItem;
+mRootItem = new CssInspectorModelItem(new ModelItemWrapper, 0);
-mRootItem = new CssInspectorModelItem(screen, 0);
 }
 CssInspectorModel::~CssInspectorModel()
 {
 delete mRootItem;
 {
 if (!index.isValid() || role != Qt::DisplayRole)
 return QVariant();
 CssInspectorModelItem *item = static_cast<CssInspectorModelItem*>(index.internalPointer());
-QGraphicsItem *graphicsItem = item->data();
+QGraphicsItem *graphicsItem = item->data()->graphicsItem();
-switch (index.column()) {
+if (graphicsItem) {
-case 0: return itemClass(graphicsItem);
+switch (index.column()) {
-case 1: return objName(graphicsItem);
+case 0: return itemClass(graphicsItem);
-case 2: return HbStyle::itemName(graphicsItem);
+case 1: return objName(graphicsItem);
-case 3: return itemValue(graphicsItem);
+case 2: return HbStyle::itemName(graphicsItem);
-case 4: return itemInParentLayout(graphicsItem);
+case 3: return itemValue(graphicsItem);
+case 4: return itemInParentLayout(graphicsItem);
+default: return QVariant();
+}
+} else {
+if (index.column() == 0) {
+// Return correct item name
+if (item->data()->popupManager()) {
+return "HbPopupManager";
+} else if (item->data()->window()) {
+return "HbScreen";
+}
+}
 }
 return QVariant();
 }
 QVariant CssInspectorModel::headerData(int section, Qt::Orientation orientation, int role) const
 if (!parent.isValid())
 parentItem = mRootItem;
 else
 parentItem = static_cast<CssInspectorModelItem*>(parent.internalPointer());
-return parentItem->data()->childItems().count();
+ModelItemWrapper *wrapper = parentItem->data();
+if (wrapper->graphicsItem()) {
+return wrapper->graphicsItem()->childItems().count();
+} else if (wrapper->popupManager()) {
+return wrapper->popupManager()->d->popupList.count();
+} else if (wrapper->window()) {
+HbMainWindowPrivate *winPriv = HbMainWindowPrivate::d_ptr(wrapper->window());
+QGraphicsItem *screen = winPriv->element(HbMainWindowPrivate::ViewportItem);
+return screen->childItems().count() + 1; // Special case to add PopupManager
+} else {
+return hbInstance->allMainWindows().count();
+}
 }
 int CssInspectorModel::columnCount(const QModelIndex &parent) const
 {
 Q_UNUSED(parent)
 const QModelIndex &index) const
 {
 if (index.column() == ITEMNAME_COLUMN) {
 if (index.data().toString() == "") {
 CssInspectorModelItem *modelItem = static_cast<CssInspectorModelItem*>(index.internalPointer());
-QGraphicsItem *item = modelItem->data();
+QGraphicsItem *item = modelItem->data()->graphicsItem();
 if (parentHasAnchorLayout(item)) {
 painter->fillRect(option.rect, Qt::red);
 }
 }
 } else if (index.column() == INLAYOUT_COLUMN) {
 }
 QStyledItemDelegate::paint(painter, option, index);
 }
 /******************************************************************************************/
+static QPointer<HbCssInspectorWindow> cssWindow = 0;
 HbCssInspectorWindow *HbCssInspectorWindow::instance()
 {
-static QPointer<HbCssInspectorWindow> window = 0;
+if (!cssWindow) {
-if (!window) {
+cssWindow = new HbCssInspectorWindow;
-window = new HbCssInspectorWindow;
+}
-}
+return cssWindow;
-return window;
+}
-}
+bool HbCssInspectorWindow::exists()
+{
+return !cssWindow.isNull();
+}
 void HbCssInspectorWindow::refresh()
 {
 if (this->isVisible()) {
 removeFilters();
 }
 void HbCssInspectorWindow::updateFromTreeView(const QModelIndex &index)
 {
 CssInspectorModelItem *modelItem = static_cast<CssInspectorModelItem*>(index.internalPointer());
-QGraphicsItem *item = modelItem->data();
+QGraphicsItem *item = modelItem->data()->graphicsItem();
 updateFocusItem(item);
 foreach (HoveredWidgetFilter *filter, mInstalledFilters) {
 filter->mCssInfoDrawer->updateFocusItem(item);
 filter->mArrowDrawer->updateFocusItem(item);
 }
 mTreeView->header()->resizeSections(QHeaderView::ResizeToContents);
 }
 void HbCssInspectorWindow::addFilters()
 {
-foreach (HbMainWindow *window, hbInstance->allMainWindows()) {
+mTreeView->setModel(new CssInspectorModel);
-mTreeView->setModel(new CssInspectorModel(window));
+foreach (const HbMainWindow *window, hbInstance->allMainWindows()) {
 HoveredWidgetFilter *filter = new HoveredWidgetFilter(window->scene());
 window->scene()->installEventFilter(filter);
 mInstalledFilters.append(filter);
 connect(filter, SIGNAL(newItemHovered(const QGraphicsItem*)),
 SLOT(updateFocusItem(const QGraphicsItem*)));
 QVBoxLayout *treeLayout = new QVBoxLayout;
 treeLayout->setContentsMargins(0,0,0,0);
 treeContainer->setLayout(treeLayout);
 mTreeView = new QTreeView(this);
 mTreeView->setItemDelegate(new ItemColorDelegate);
+mTreeView->setAttribute(Qt::WA_InputMethodEnabled, false);
 QLabel *treeLabel = new QLabel(tr("Item tree"));
 treeLayout->addWidget(treeLabel);
 treeLayout->addWidget(mTreeView);
 connect(mTreeView, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(updateColumnSizes(const QModelIndex&)));
 const QGraphicsItem *ancestor = item;
 while (ancestor) {
 ancestorItems << ancestor;
 ancestor = ancestor->parentItem();
 }
-bool foundRoot = false;
-QModelIndex index;
+CssInspectorModel *model = static_cast<CssInspectorModel*>(mTreeView->model());
-for (int i=ancestorItems.count() -1; i>=0; i--) {
+// Find root element
-const QGraphicsItem *thisItem = ancestorItems.at(i);
+int rootItemIndex = 0; // This is used later (outside for loop)
-if (!foundRoot) {
+bool rootIsInScreen = false;
-const QGraphicsWidget *wid = static_cast<const QGraphicsWidget*>(thisItem);
-if (wid) {
+// Iterating forwards in a reverse containment-order list
-QString name = wid->metaObject()->className();
+for (; rootItemIndex < ancestorItems.count(); ++rootItemIndex) {
-if (name == "HbScreen") {
+const QGraphicsItem *thisItem = ancestorItems.at(rootItemIndex);
-foundRoot = true;
+const QGraphicsWidget *widget = static_cast<const QGraphicsWidget*>(thisItem);
+if (widget) {
+if (widget->metaObject()->className() == ROOT_TREE_ELEMENT) {
+rootIsInScreen = true;
+break;
+}
+}
+}
+// Get the correct window
+QModelIndex parentIndex;
+bool foundWindow = false;
+int winCount = model->rowCount(QModelIndex());
+const HbWidget *hbWidget = static_cast<const HbWidget*>(item);
+if (hbWidget) {
+for (int idx=0; idx<winCount; idx++) {
+parentIndex = model->index(idx, 0, QModelIndex());
+CssInspectorModelItem *modelItem = static_cast<CssInspectorModelItem*>(parentIndex.internalPointer());
+if (modelItem->data()->window() == hbWidget->mainWindow()) {
+foundWindow = true;
+break;
+}
+}
+}
+if (foundWindow) {
+if (!rootIsInScreen) {
+// Need to set parentIndex to popupmgr
+parentIndex = model->index(model->rowCount(parentIndex)-1, 0, parentIndex);
+rootItemIndex--;
+}
+// Now descend containment heirarchy getting index
+for (int itemIdx=rootItemIndex; itemIdx>=0; itemIdx--) {
+const QGraphicsItem *thisItem = ancestorItems.at(itemIdx);
+int rowCount = model->rowCount(parentIndex);
+for (int row=0; row<rowCount; row++) {
+QModelIndex thisIndex = model->index(row, 0, parentIndex);
+CssInspectorModelItem *modelItem = static_cast<CssInspectorModelItem*>(thisIndex.internalPointer());
+QGraphicsItem *gItem = modelItem->data()->graphicsItem();
+if (gItem == thisItem) {
+parentIndex = thisIndex;
+break;
 }
 }
-} else {
-// Find and open tree node for item
-CssInspectorModel *model = static_cast<CssInspectorModel*>(mTreeView->model());
-if (model) {
-int rowCount = model->rowCount(index);
-for (int row=0; row<rowCount; row++) {
-QModelIndex idx = model->index(row, 0, index);
-CssInspectorModelItem *modelItem = static_cast<CssInspectorModelItem*>(idx.internalPointer());
-QGraphicsItem *graphicsItem = modelItem->data();
-if (graphicsItem == thisItem) {
-index = idx;
-break;
-}
-}
-}
 }
 }
 mTreeView->collapseAll();
-mTreeView->scrollTo(index, QAbstractItemView::EnsureVisible);
+mTreeView->scrollTo(parentIndex, QAbstractItemView::EnsureVisible);
-mTreeView->expand(index);
+mTreeView->expand(parentIndex);
 } else {
 mWidgetMLBox->setText("");
 mLayoutCssBox->setText("");
 mColorsCssBox->setText("");
 mPathLabel->setText("");
 mSizeHintLabel->setText("");
 mSizePolicyHoriz->setText("");
 mSizePolicyVert->setText("");
+mTreeView->collapseAll();
 }
 }

changeset 28	b7da29130b0e
parent 23	e6ad4ef83b23