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

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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 qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qwhatsthis.h"

#ifndef QT_NO_WHATSTHIS

#include "qpointer.h"

#include "qapplication.h"

#include "qdesktopwidget.h"

#include "qevent.h"

#include "qpixmap.h"

#include "qpainter.h"

#include "qtimer.h"

#include "qhash.h"

#include "qaction.h"

#include "qcursor.h"

#include "qbitmap.h"

#include "qtextdocument.h"

#include "../text/qtextdocumentlayout_p.h"

#include "qtoolbutton.h"

#include "qdebug.h"

#ifndef QT_NO_ACCESSIBILITY

#include "qaccessible.h"

#endif

#if defined(Q_WS_WIN)

#include "qt_windows.h"

#ifndef SPI_GETDROPSHADOW

#define SPI_GETDROPSHADOW                   0x1024

#endif

#endif

#if defined(Q_WS_X11)

#include "qx11info_x11.h"

#include <qwidget.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QWhatsThis

    \brief The QWhatsThis class provides a simple description of any

    widget, i.e. answering the question "What's This?".

    \ingroup helpsystem

    "What's This?" help is part of an application's online help

    system, and provides users with information about the

    functionality and usage of a particular widget. "What's This?"

    help texts are typically longer and more detailed than \link

    QToolTip tooltips\endlink, but generally provide less information

    than that supplied by separate help windows.

    QWhatsThis provides a single window with an explanatory text that

    pops up when the user asks "What's This?". The default way for

    users to ask the question is to move the focus to the relevant

    widget and press Shift+F1. The help text appears immediately; it

    goes away as soon as the user does something else.

    (Note that if there is a shortcut for Shift+F1, this mechanism

    will not work.) Some dialogs provide a "?" button that users can

    click to enter "What's This?" mode; they then click the relevant

    widget to pop up the "What's This?" window. It is also possible to

    provide a a menu option or toolbar button to switch into "What's

    This?" mode.

    To add "What's This?" text to a widget or an action, you simply

    call QWidget::setWhatsThis() or QAction::setWhatsThis().

    The text can be either rich text or plain text. If you specify a

    rich text formatted string, it will be rendered using the default

    stylesheet, making it possible to embed images in the displayed

    text. To be as fast as possible, the default stylesheet uses a

    simple method to determine whether the text can be rendered as

    plain text. See Qt::mightBeRichText() for details.

    \snippet doc/src/snippets/whatsthis/whatsthis.cpp 0

    An alternative way to enter "What's This?" mode is to call

    createAction(), and add the returned QAction to either a menu or

    a tool bar. By invoking this context help action (in the picture

    below, the button with the arrow and question mark icon) the user

    switches into "What's This?" mode. If they now click on a widget

    the appropriate help text is shown. The mode is left when help is

    given or when the user presses Esc.

    \img whatsthis.png

    You can enter "What's This?" mode programmatically with

    enterWhatsThisMode(), check the mode with inWhatsThisMode(), and

    return to normal mode with leaveWhatsThisMode().

    If you want to control the "What's This?" behavior of a widget

    manually see Qt::WA_CustomWhatsThis.

    It is also possible to show different help texts for different

    regions of a widget, by using a QHelpEvent of type

    QEvent::WhatsThis. Intercept the help event in your widget's

    QWidget::event() function and call QWhatsThis::showText() with the

    text you want to display for the position specified in

    QHelpEvent::pos(). If the text is rich text and the user clicks

    on a link, the widget also receives a QWhatsThisClickedEvent with

    the link's reference as QWhatsThisClickedEvent::href(). If a

    QWhatsThisClickedEvent is handled (i.e. QWidget::event() returns

    true), the help window remains visible. Call

    QWhatsThis::hideText() to hide it explicitly.

    \sa QToolTip

*/

extern void qDeleteInEventHandler(QObject *o);

class QWhatsThat : public QWidget

{

    Q_OBJECT

public:

    QWhatsThat(const QString& txt, QWidget* parent, QWidget *showTextFor);

    ~QWhatsThat() ;

    static QWhatsThat *instance;

protected:

    void showEvent(QShowEvent *e);

    void mousePressEvent(QMouseEvent*);

    void mouseReleaseEvent(QMouseEvent*);

    void mouseMoveEvent(QMouseEvent*);

    void keyPressEvent(QKeyEvent*);

    void paintEvent(QPaintEvent*);

private:

    QPointer<QWidget>widget;

    bool pressed;

    QString text;

    QTextDocument* doc;

    QString anchor;

    QPixmap background;

};

QWhatsThat *QWhatsThat::instance = 0;

// shadowWidth not const, for XP drop-shadow-fu turns it to 0

static int shadowWidth = 6;   // also used as '5' and '6' and even '8' below

static const int vMargin = 8;

static const int hMargin = 12;

QWhatsThat::QWhatsThat(const QString& txt, QWidget* parent, QWidget *showTextFor)

    : QWidget(parent, Qt::Popup),

      widget(showTextFor), pressed(false), text(txt)

{

    delete instance;

    instance = this;

    setAttribute(Qt::WA_DeleteOnClose, true);

    setAttribute(Qt::WA_NoSystemBackground, true);

    if (parent)

        setPalette(parent->palette());

    setMouseTracking(true);

    setFocusPolicy(Qt::StrongFocus);

#ifndef QT_NO_CURSOR

    setCursor(Qt::ArrowCursor);

#endif

    QRect r;

    doc = 0;

    ensurePolished(); // Ensures style sheet font before size calc

    if (Qt::mightBeRichText(text)) {

        doc = new QTextDocument();

        doc->setUndoRedoEnabled(false);

        doc->setDefaultFont(QApplication::font(this));

#ifdef QT_NO_TEXTHTMLPARSER

        doc->setPlainText(text);

#else

        doc->setHtml(text);

#endif

        doc->setUndoRedoEnabled(false);

        doc->adjustSize();

        r.setTop(0);

        r.setLeft(0);

        r.setSize(doc->size().toSize());

    }

    else

    {

        int sw = QApplication::desktop()->width() / 3;

        if (sw < 200)

            sw = 200;

        else if (sw > 300)

            sw = 300;

        r = fontMetrics().boundingRect(0, 0, sw, 1000,

                                        Qt::AlignLeft + Qt::AlignTop

                                        + Qt::TextWordWrap + Qt::TextExpandTabs,

                                        text);

    }

#if defined(Q_WS_WIN)

    if ((QSysInfo::WindowsVersion >= QSysInfo::WV_XP

        && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based))

    {

        BOOL shadow;

        SystemParametersInfo(SPI_GETDROPSHADOW, 0, &shadow, 0);

        shadowWidth = shadow ? 0 : 6;

    }

#endif

    resize(r.width() + 2*hMargin + shadowWidth, r.height() + 2*vMargin + shadowWidth);

}

QWhatsThat::~QWhatsThat()

{

    instance = 0;

    if (doc)

        delete doc;

}

void QWhatsThat::showEvent(QShowEvent *)

{

    background = QPixmap::grabWindow(QApplication::desktop()->internalWinId(),

                                     x(), y(), width(), height());

}

void QWhatsThat::mousePressEvent(QMouseEvent* e)

{

    pressed = true;

    if (e->button() == Qt::LeftButton && rect().contains(e->pos())) {

        if (doc)

            anchor = doc->documentLayout()->anchorAt(e->pos() -  QPoint(hMargin, vMargin));

        return;

    }

    close();

}

void QWhatsThat::mouseReleaseEvent(QMouseEvent* e)

{

    if (!pressed)

        return;

    if (widget && e->button() == Qt::LeftButton && doc && rect().contains(e->pos())) {

        QString a = doc->documentLayout()->anchorAt(e->pos() -  QPoint(hMargin, vMargin));

        QString href;

        if (anchor == a)

            href = a;

        anchor.clear();

        if (!href.isEmpty()) {

            QWhatsThisClickedEvent e(href);

            if (QApplication::sendEvent(widget, &e))

                return;

        }

    }

    close();

}

void QWhatsThat::mouseMoveEvent(QMouseEvent* e)

{

#ifdef QT_NO_CURSOR

    Q_UNUSED(e);

#else

    if (!doc)

        return;

    QString a = doc->documentLayout()->anchorAt(e->pos() -  QPoint(hMargin, vMargin));

    if (!a.isEmpty())

        setCursor(Qt::PointingHandCursor);

    else

        setCursor(Qt::ArrowCursor);

#endif

}

void QWhatsThat::keyPressEvent(QKeyEvent*)

{

    close();

}

void QWhatsThat::paintEvent(QPaintEvent*)

{

    bool drawShadow = true;

#if defined(Q_WS_WIN)

    if ((QSysInfo::WindowsVersion >= QSysInfo::WV_XP

        && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based))

    {

        BOOL shadow;

        SystemParametersInfo(SPI_GETDROPSHADOW, 0, &shadow, 0);

        drawShadow = !shadow;

    }

#elif defined(Q_WS_MAC) || defined(Q_WS_QWS)

    drawShadow = false; // never draw it on OS X or QWS, as we get it for free

#endif

    QRect r = rect();

    r.adjust(0, 0, -1, -1);

    if (drawShadow)

        r.adjust(0, 0, -shadowWidth, -shadowWidth);

    QPainter p(this);

    p.drawPixmap(0, 0, background);

    p.setPen(QPen(palette().toolTipText(), 0));

    p.setBrush(palette().toolTipBase());

    p.drawRect(r);

    int w = r.width();

    int h = r.height();

    p.setPen(palette().brush(QPalette::Dark).color());

    p.drawRect(1, 1, w-2, h-2);

    if (drawShadow) {

        p.setPen(palette().shadow().color());

        p.drawPoint(w + 5, 6);

        p.drawLine(w + 3, 6, w + 5, 8);

        p.drawLine(w + 1, 6, w + 5, 10);

        int i;

        for(i=7; i < h; i += 2)

            p.drawLine(w, i, w + 5, i + 5);

        for(i = w - i + h; i > 6; i -= 2)

            p.drawLine(i, h, i + 5, h + 5);

        for(; i > 0 ; i -= 2)

            p.drawLine(6, h + 6 - i, i + 5, h + 5);

    }

    r.adjust(0, 0, 1, 1);

    p.setPen(palette().toolTipText().color());

    r.adjust(hMargin, vMargin, -hMargin, -vMargin);

    if (doc) {

        p.translate(r.x(), r.y());

        QRect rect = r;

        rect.translate(-r.x(), -r.y());

        p.setClipRect(rect);

        QAbstractTextDocumentLayout::PaintContext context;

        context.palette.setBrush(QPalette::Text, context.palette.toolTipText());

        doc->documentLayout()->draw(&p, context);

    }

    else

    {

        p.drawText(r, Qt::AlignLeft + Qt::AlignTop + Qt::TextWordWrap + Qt::TextExpandTabs, text);

    }

}

static const char * const button_image[] = {

"16 16 3 1",

"         c None",

"o        c #000000",

"a        c #000080",

"o        aaaaa  ",

"oo      aaa aaa ",

"ooo    aaa   aaa",

"oooo   aa     aa",

"ooooo  aa     aa",

"oooooo  a    aaa",

"ooooooo     aaa ",

"oooooooo   aaa  ",

"ooooooooo aaa   ",

"ooooo     aaa   ",

"oo ooo          ",

"o  ooo    aaa   ",

"    ooo   aaa   ",

"    ooo         ",

"     ooo        ",

"     ooo        "};

class QWhatsThisPrivate : public QObject

{

 public:

    QWhatsThisPrivate();

    ~QWhatsThisPrivate();

    static QWhatsThisPrivate *instance;

    bool eventFilter(QObject *, QEvent *);

    QPointer<QAction> action;

#ifdef QT3_SUPPORT

    QPointer<QToolButton> button;

#endif

    static void say(QWidget *, const QString &, int x = 0, int y = 0);

    static void notifyToplevels(QEvent *e);

    bool leaveOnMouseRelease;

};

void QWhatsThisPrivate::notifyToplevels(QEvent *e)

{

    QWidgetList toplevels = QApplication::topLevelWidgets();

    for (int i = 0; i < toplevels.count(); ++i) {

        register QWidget *w = toplevels.at(i);

        QApplication::sendEvent(w, e);

    }

}

QWhatsThisPrivate *QWhatsThisPrivate::instance = 0;

QWhatsThisPrivate::QWhatsThisPrivate()

    : leaveOnMouseRelease(false)

{

    instance = this;

    qApp->installEventFilter(this);

    QPoint pos = QCursor::pos();

    if (QWidget *w = QApplication::widgetAt(pos)) {

        QHelpEvent e(QEvent::QueryWhatsThis, w->mapFromGlobal(pos), pos);

        bool sentEvent = QApplication::sendEvent(w, &e);

#ifdef QT_NO_CURSOR

        Q_UNUSED(sentEvent);

#else

        QApplication::setOverrideCursor((!sentEvent || !e.isAccepted())?

                                        Qt::ForbiddenCursor:Qt::WhatsThisCursor);

    } else {

        QApplication::setOverrideCursor(Qt::WhatsThisCursor);

#endif

    }

#ifndef QT_NO_ACCESSIBILITY

    QAccessible::updateAccessibility(this, 0, QAccessible::ContextHelpStart);

#endif

}

QWhatsThisPrivate::~QWhatsThisPrivate()

{

    if (action)

        action->setChecked(false);

#ifdef QT3_SUPPORT

    if (button)

        button->setChecked(false);

#endif

#ifndef QT_NO_CURSOR

    QApplication::restoreOverrideCursor();

#endif

#ifndef QT_NO_ACCESSIBILITY

    QAccessible::updateAccessibility(this, 0, QAccessible::ContextHelpEnd);

#endif

    instance = 0;

}

bool QWhatsThisPrivate::eventFilter(QObject *o, QEvent *e)

{

    if (!o->isWidgetType())

        return false;

    QWidget * w = static_cast<QWidget *>(o);

    bool customWhatsThis = w->testAttribute(Qt::WA_CustomWhatsThis);

    switch (e->type()) {

    case QEvent::MouseButtonPress:

    {

        QMouseEvent *me = static_cast<QMouseEvent*>(e);

        if (me->button() == Qt::RightButton || customWhatsThis)

            return false;

        QHelpEvent e(QEvent::WhatsThis, me->pos(), me->globalPos());

        if (!QApplication::sendEvent(w, &e) || !e.isAccepted())

            leaveOnMouseRelease = true;

    } break;

    case QEvent::MouseMove:

    {

        QMouseEvent *me = static_cast<QMouseEvent*>(e);

        QHelpEvent e(QEvent::QueryWhatsThis, me->pos(), me->globalPos());

        bool sentEvent = QApplication::sendEvent(w, &e);

#ifdef QT_NO_CURSOR

        Q_UNUSED(sentEvent);

#else

        QApplication::changeOverrideCursor((!sentEvent || !e.isAccepted())?

                                           Qt::ForbiddenCursor:Qt::WhatsThisCursor);

#endif

    }

    // fall through

    case QEvent::MouseButtonRelease:

    case QEvent::MouseButtonDblClick:

        if (leaveOnMouseRelease && e->type() == QEvent::MouseButtonRelease)

            QWhatsThis::leaveWhatsThisMode();

        if (static_cast<QMouseEvent*>(e)->button() == Qt::RightButton || customWhatsThis)

            return false; // ignore RMB release

        break;

    case QEvent::KeyPress:

    {

        QKeyEvent* kev = (QKeyEvent*)e;

        if (kev->key() == Qt::Key_Escape) {

            QWhatsThis::leaveWhatsThisMode();

            return true;

        } else if (customWhatsThis) {

            return false;

        } else if (kev->key() == Qt::Key_Menu ||

                    (kev->key() == Qt::Key_F10 &&

                      kev->modifiers() == Qt::ShiftModifier)) {

            // we don't react to these keys, they are used for context menus

            return false;

        } else if (kev->key() != Qt::Key_Shift && kev->key() != Qt::Key_Alt // not a modifier key

                   && kev->key() != Qt::Key_Control && kev->key() != Qt::Key_Meta) {

            QWhatsThis::leaveWhatsThisMode();

        }

    } break;

    default:

        return false;

    }

    return true;

}

class QWhatsThisAction: public QAction

{

    Q_OBJECT

public:

    explicit QWhatsThisAction(QObject* parent = 0);

private slots:

    void actionTriggered();

};

QWhatsThisAction::QWhatsThisAction(QObject *parent) : QAction(tr("What's This?"), parent)

{