/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbcssinspector_p.h"

#ifdef HB_CSS_INSPECTOR

#include <hbanchor.h>

#include <hbanchorarrowdrawer_p.h>

#include <hbcolorscheme.h>

#include <hbcssformatter_p.h>

#include <hbevent.h>

#include <hbframedrawer.h>

#include <hbframeitem.h>

#include <hbiconitem.h>

#include <hbinstance.h>

#include <hblayeredstyleloader_p.h>

#include <hbmainwindow_p.h>

#include <hbmarqueeitem.h>

#include <hbnamespace_p.h>

#include <hbscreen_p.h>

#include <hbtextitem.h>

#include <hbwidgetloadersyntax_p.h>

#include <hbxmlloaderabstractsyntax_p.h>

#include <hbwidgetbase_p.h>

#include <hbwidget_p.h>

#include <QBrush>

#include <QCheckBox>

#include <QGraphicsLayout>

#include <QGraphicsScene>

#include <QGraphicsSceneMouseEvent>

#include <QGroupBox>

#include <QHeaderView>

#include <QHBoxLayout>

#include <QLabel>

#include <QPen>

#include <QPainter>

#include <QPointer>

#include <QRadioButton>

#include <QSizePolicy>

#include <QSplitter>

#include <QTextEdit>

#include <QTreeView>

#include <QVBoxLayout>

#include <QXmlStreamWriter>

#include <qmath.h>

#include <QMetaEnum>

#define NODEPTR_N(x) HbCss::StyleSelector::NodePtr n = {n.ptr = (void *)x};

const QString CSS_HTML_HEADER("<style type=\"text/css\"> \

                                .overridden {color:#999; text-decoration:line-through;} \

                                .filename {background-color: #e0e0e0; margin:0;} \

                                .selectors {margin:0;} \

                                .selector {color:#000;} \

                                .pseudo {font-weight:bold;} \

                                .attr {font-style:italic;} \

                                .property {color:#00f; font-weight:bold;} \

                                .value {color:#f00;} \

                                .overridden .property, .overridden .value {color:#999;} \

                                </style>");

const QString WIDGETML_HTML_HEADER("<style type=\"text/css\"> \

                                     pre {color:#999; font-family:Arial;} \

                                     span {color:#000; font-weight:bold;} \

                                     </style><pre>");

const QString WIDGETML_HTML_FOOTER("</pre>");

const QStringList SKIPPED_CHILD_ITEMS(QStringList() << "HbTextItem" << "HbTouchArea"

        << "HbIconItem" << "HbFrameItem" << "HbWidgetBase" 

        << "HbMarqueeItem" << "QGraphicsWidget" << "QGraphicsItem");

const QStringList SKIPPED_GLOBAL_ITEMS(QStringList() << "HbPopupLayoutManager" << "HbAnchorArrowDrawer" << "HbCssInfoDrawer");

const qreal HOVER_BOX_PEN_WIDTH = 2.0;

const qreal GUIDE_LINE_WIDTH = 1.0;

const QChar BIG_NUMBER_CHAR = 0x221E;

const QString TEXT_COLOR("qtc_default_main_pane_normal");

const QString LINE_COLOR("qtc_view_visited_normal");

const int ABOVE_POPUP_ZVALUE = 5000;

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;

static QString itemClass(const QGraphicsItem *item)

{

    if (item && item->isWidget()) {

        const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item);

        return widget->metaObject()->className();

    }

    return "QGraphicsItem";

}

static QString objName(const QGraphicsItem *item)

{

    if (item && item->isWidget()) {

        const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item);

        return widget->objectName();

    }

    return QString();

}

static QString itemValue(const QGraphicsItem *item)

{

    QString itemClassName(itemClass(item));

    if (itemClassName == "HbIconItem") {

        const HbIconItem *icon = static_cast<const HbIconItem*>(item);

        return icon->iconName();

    } else if (itemClassName == "HbTextItem") {

        const HbTextItem *text = static_cast<const HbTextItem*>(item);

        return text->text();

    } else if (itemClassName == "HbFrameItem") {

        const HbFrameItem *frame = static_cast<const HbFrameItem*>(item);

        return frame->frameDrawer().frameGraphicsName();

    } else if (itemClassName == "HbMarqueeItem") {

        const HbMarqueeItem *marquee = static_cast<const HbMarqueeItem*>(item);

        return marquee->text();

    }

    return QString();

}

static bool parentHasAnchorLayout(const QGraphicsItem *item)

{

    if (item) {

        if (const QGraphicsItem *parent = item->parentItem()) {

            if (const QGraphicsWidget *widget = static_cast<const QGraphicsWidget*>(parent)) {

                if (const QGraphicsLayout *layout = widget->layout()) {

                    if (const HbAnchorLayout *anchor = dynamic_cast<const HbAnchorLayout*>(layout)) {

                        Q_UNUSED(anchor)

                        return true;

                    }

                }

            }

        }

    }

    return false;

}

static QString itemInParentLayout(const QGraphicsItem *item)

{

    static QMap<const QGraphicsLayout*, QSet<const QGraphicsItem*> > itemCache;

    if (item) {

        if (const QGraphicsWidget *widget = static_cast<const QGraphicsWidget*>(item->parentItem())) {

            QGraphicsLayout *layout = widget->layout();

            QSet<const QGraphicsItem*> itemsInLayout;

            if (itemCache.contains(layout)) {

                itemsInLayout = itemCache[layout];

            } else {

                HbAnchorLayout *anchorLayout = dynamic_cast<HbAnchorLayout*>(layout);

                if (!anchorLayout) {

                    return QString(); // Non-anchor layout

                } else {

                    foreach (HbAnchor *anchor, anchorLayout->effectiveAnchors()) {

                        itemsInLayout << anchor->startItem()->graphicsItem();

                        itemsInLayout << anchor->endItem()->graphicsItem();

                    }

                    itemCache[layout] = itemsInLayout;

                }

            }

            return itemsInLayout.contains(item) ? "Yes" : "No";

        }

    }

    return QString(); // Non-widget parent

}

static QString sizePolicyText(QSizePolicy::Policy policy)

{

    const QMetaObject *meta = &QSizePolicy::staticMetaObject;

    const int enumIndex = meta->indexOfEnumerator("Policy");

    Q_ASSERT( enumIndex != -1 );

    QString name(meta->enumerator(enumIndex).valueToKey((int)policy));

    if (name.isEmpty()) {

        name = "[Unrecognised]";

    }

    return name;

}

static QString cssItemText(const QGraphicsItem *item)

{

    QString txt(itemClass(item));

    if (item && item->isWidget()) {

        // Add objectname

        QString objectName(objName(item));

        if (objectName.length() > 0) {

            txt.append("#");

            txt.append(objectName);

        }

    }

    // Add itemname

    QString name(HbStyle::itemName(item));

    if (name.length() > 0) {

        txt.append("::");

        txt.append(name);

    }

    return txt;

}

static QString convertMeasurementToText(const QGraphicsItem *item, qreal hint)

{

    qreal unit = HbDeviceProfile::profile(item).unitValue();

    if (unit != 0) {

        hint = (hint / unit);

        }

    QString hintText(QString::number(hint, 'g', 2));

    if (hintText.contains('+')) {

        hintText = BIG_NUMBER_CHAR;

    } else {

        if (hint !=0 && unit != 0) {

            hintText += "un";

        }

    }

    return hintText;

}

static QString convertEffectiveSizeHintToText(const QGraphicsWidget *item, Qt::SizeHint which)

{

    QString hintText('(');

    if (item) {

        const QSizeF &size = item->effectiveSizeHint(which);

        hintText += convertMeasurementToText(item, size.width()) + ',';

        hintText += convertMeasurementToText(item, size.height());

    }

    hintText += ')';

    return hintText;

}

static QString cssItemHintText(const QGraphicsItem *item)

{

    QString sizeHint;

    if (item && item->isWidget()) {

        const QGraphicsWidget *widget = static_cast<const QGraphicsWidget*>(item);

        sizeHint += convertEffectiveSizeHintToText(widget, Qt::MinimumSize)+'|';

        sizeHint += convertEffectiveSizeHintToText(widget, Qt::PreferredSize)+'|';

        sizeHint += convertEffectiveSizeHintToText(widget, Qt::MaximumSize);

    }

    return sizeHint;

}

static QString cssSizePolicyText(const QGraphicsItem *item, Qt::Orientation dir)

{

    if (!item || !item->isWidget()) {

        return QString();

    }

    const HbWidget *widget = static_cast<const HbWidget*>(item);

    QSizePolicy::Policy pol = dir == Qt::Vertical

        ? widget->sizePolicy().verticalPolicy()

        : widget->sizePolicy().horizontalPolicy();

    return sizePolicyText( pol );

}

static QRectF cssItemHintRect(const QGraphicsItem *item, Qt::SizeHint which)

{

    QRectF hintRect;

    if (item && item->isWidget()) {

        const QGraphicsWidget *widget = static_cast<const QGraphicsWidget*>(item);

        const QSizeF &size = widget->effectiveSizeHint(which);

        hintRect.setWidth(size.width());

        hintRect.setHeight(size.height());

    }

    return hintRect;

}

static QString anchorEdgeName(Hb::Edge edge)

{

    QString name;

    switch (edge) {

        // these are hardwired inside the parser

        case Hb::TopEdge: name = QString("TOP"); break;

        case Hb::BottomEdge: name = QString("BOTTOM"); break;

        case Hb::LeftEdge: name = QString("LEFT"); break;

        case Hb::RightEdge: name = QString("RIGHT"); break;

        case Hb::CenterHEdge: name = QString("CENTERH"); break;

        case Hb::CenterVEdge: name = QString("CENTERV"); break;

        }

    return name;

}

static QString anchorDirText(HbAnchor::Direction dir)

{

    QString name;

    switch (dir) {

        // these are hardwired inside the parser

        case HbAnchor::Negative: name = QString("NEGATIVE"); break;

        case HbAnchor::Positive: name = QString("POSITIVE"); break;

        }

    return name;

}

QString HbCssInspectorWindow::anchorItemName(QGraphicsLayoutItem* item, QGraphicsLayout* layout, bool& isIdBased)

{

    isIdBased = true;

    QString name;

    if ( item != layout ) {

        QGraphicsItem *gItem = item->graphicsItem();

        if ( gItem ) {

            name = HbStyle::itemName( gItem );

            if (name.isEmpty()) {

                isIdBased = false;

                name = objName(gItem);

                if (name.isEmpty()) {

                    name = QString("<%1>").arg(itemClass(gItem));

                }

            }

        }

        if ( name.isEmpty() ) {

            name = QString("<unknown>");

        }

    }

    return name;

}

QString HbCssInspectorWindow::anchorsToHtmlInfo(const QGraphicsWidget *widget, const QString layoutName)

{

    HbAnchorLayout *anchorLayout = dynamic_cast<HbAnchorLayout *>(widget->layout());

    QString itemName = itemClass(widget);

    QString widgetML;

    QXmlStreamWriter xmlWriter(&widgetML);

    xmlWriter.setAutoFormatting(true);

    HbWidgetLoaderSyntax syntax(new HbWidgetLoaderActions());

    QString str = syntax.lexemValue(HbXmlLoaderAbstractSyntax::TYPE_HBWIDGET);

    xmlWriter.writeStartElement(syntax.lexemValue(HbXmlLoaderAbstractSyntax::TYPE_HBWIDGET));

    xmlWriter.writeAttribute(

        syntax.lexemValue(HbXmlLoaderAbstractSyntax::ATTR_VERSION), 

        HbWidgetLoaderSyntax::version());

    xmlWriter.writeAttribute(syntax.lexemValue(HbXmlLoaderAbstractSyntax::ATTR_TYPE), itemName);

    xmlWriter.writeStartElement(syntax.lexemValue(HbXmlLoaderAbstractSyntax::TYPE_LAYOUT));

    xmlWriter.writeAttribute(syntax.lexemValue(HbXmlLoaderAbstractSyntax::ATTR_NAME), layoutName);

    xmlWriter.writeAttribute(

        syntax.lexemValue(HbXmlLoaderAbstractSyntax::ATTR_TYPE),

        syntax.lexemValue(HbXmlLoaderAbstractSyntax::LAYOUT_ANCHOR));

    if (anchorLayout) {

        foreach (HbAnchor *anchor, anchorLayout->effectiveAnchors()) {

            bool startIdBased, endIdBased;

            QString startName(anchorItemName(anchor->startItem(), anchorLayout, startIdBased));

            QString endName(anchorItemName(anchor->endItem(), anchorLayout, endIdBased));

            xmlWriter.writeStartElement(syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_ANCHOR));

            xmlWriter.writeAttribute(

                syntax.lexemValue( startIdBased

                    ? HbXmlLoaderAbstractSyntax::AL_SRC_ID

                    : HbXmlLoaderAbstractSyntax::AL_SRC_NAME),

                        startName);

            xmlWriter.writeAttribute(

                syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_SRC_EDGE), 

                anchorEdgeName(anchor->startEdge()));

            xmlWriter.writeAttribute(

                syntax.lexemValue( endIdBased

                    ? HbXmlLoaderAbstractSyntax::AL_DST_ID

                    : HbXmlLoaderAbstractSyntax::AL_DST_NAME),

                        endName);

            xmlWriter.writeAttribute(

                syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_DST_EDGE), 

                anchorEdgeName(anchor->endEdge()));

            if ( !anchor->anchorId().isEmpty() ) {

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_ANCHOR_ID),

                    anchor->anchorId());

            }

            if ( anchor->sizePolicy() != QSizePolicy::Fixed ) {

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_MIN_LENGTH),

                    convertMeasurementToText(widget, anchor->minimumLength()));

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_PREF_LENGTH),

                    convertMeasurementToText(widget, anchor->preferredLength()));

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_MAX_LENGTH),

                    convertMeasurementToText(widget, anchor->maximumLength()));

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_DIRECTION),

                    anchorDirText(anchor->direction()));

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_SIZEPOLICY),

                    sizePolicyText(anchor->sizePolicy()));

            } else {

                qreal spacing = anchor->preferredLength();

                if ( anchor->direction() == HbAnchor::Negative ) {

                    spacing *= -1.0;

                }

                xmlWriter.writeAttribute(

                    syntax.lexemValue(HbXmlLoaderAbstractSyntax::AL_SPACING),

                    convertMeasurementToText(widget, spacing));

            }

            xmlWriter.writeEndElement(); // anchoritem

        }

    }

    xmlWriter.writeEndElement(); // layout

    xmlWriter.writeEndElement(); // widgetml

    QString html(widgetML.trimmed());

    html.replace('<', "&lt;");

    html.replace('>', ">");

    html.replace(QRegExp("\"([^\"]*)\""), "\"<span>\\1</span>\""); // Add span elements around things in quotes

    html.replace('\"', """);

    html.replace("\n\n", "\n");

    html.replace('\n', "<br/>");

    html.insert(0, WIDGETML_HTML_HEADER);

    html.append(WIDGETML_HTML_FOOTER);

    return html;

}

/******************************************************************************************/

HbCssInfoDrawer::HbCssInfoDrawer(QGraphicsItem *parent) :

    HbWidgetBase(parent),

    mItemRect(0,0,0,0),

    mMinHintRect(0,0,0,0),

    mPrefHintRect(0,0,0,0),

    mMaxHintRect(0,0,0,0)

{

    updateColors();

    setVisible(false);

}

HbCssInfoDrawer::~HbCssInfoDrawer()

{

}

void HbCssInfoDrawer::changeEvent(QEvent *event)

{

    if (event->type() == HbEvent::ThemeChanged)

        updateColors();

    HbWidgetBase::changeEvent(event);

}

void HbCssInfoDrawer::updateColors()

{

    mTextColor = HbColorScheme::color(TEXT_COLOR);

    mBoxColor = HbColorScheme::color(LINE_COLOR);

}

void HbCssInfoDrawer::updateFocusItem(const QGraphicsItem *item)

{

    // update text and geometry

    if (item) {

        this->setVisible(true);

        mItemRect = item->sceneBoundingRect();

        mItemText = cssItemText(item);

        mHintText = cssItemHintText(item);

        mMinHintRect = cssItemHintRect(item, Qt::MinimumSize);

        mPrefHintRect = cssItemHintRect(item, Qt::PreferredSize);

        mMaxHintRect = cssItemHintRect(item, Qt::MaximumSize);

        // Make sure this is in the same place in the scene as the window

        if (item->isWidget()) {

            const HbWidget *obj = static_cast<const HbWidget*>(item);

            this->setGeometry(obj->mainWindow()->rect());

            mItemPolicy = obj->sizePolicy();

        }