/*

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

 * All rights reserved.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, version 2.1 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not,

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

 *

 * Description:

 *

 */

#include <QIcon>

#ifdef ORBIT_UI

#include <hbaction.h>

#include <hbicon.h>

#include <hbinputmethod.h>

#include <hbinputeditorinterface.h>

#include <hbinputsettingproxy.h>

#endif

#include "EditorWidget.h"

#include "Utilities.h"

#include "ChromeEffect.h"

// FIXME ;;; Must address the following issues:

//

// * Clean ORBIT_UI flag by creating new class for orbit ui

// * Replace QGraphicsTextItem with HbTextItem for orbit ui

//

namespace GVA {

  // Methods for class EditorItem

  //GTextLineItem extends QGraphicsTextItem as a single-line editor.

  //Signals horizontal cursor movement, which can be used to implement horizontal scrolling.

  GTextLineItem::GTextLineItem(QGraphicsItem * parent)

  : QGraphicsTextItem(parent)

  , m_maxTextLength(0)

  , m_hints(Qt::ImhNoPredictiveText) // disable the predictive text

  , m_setSpecificBtn(false)

  {

    // Disable wrapping, force text to be stored and displayed

    // as a single line.

    QTextOption textOption = document()->defaultTextOption();

    textOption.setWrapMode(QTextOption::NoWrap);

    document()->setDefaultTextOption(textOption);

    // Enable cursor keys.

    setTextInteractionFlags(Qt::TextEditorInteraction);

    // This is needed to initialize m_textLine.

    setText("");

    setAcceptDrops(false);

    m_defaultStartDragDistance = QApplication::startDragDistance();

  }

  GTextLineItem::~GTextLineItem()

  {

    if (m_maxTextLength > 0)

      disconnect(document(), SIGNAL(contentsChange(int, int, int)), this, SLOT(contentsChange(int, int, int)));

    QApplication::setStartDragDistance(m_defaultStartDragDistance);

  }

  void GTextLineItem::setText(const QString & text)

  {

    QString newText = text;

    if(m_maxTextLength > 0 && text.length() > m_maxTextLength ) {

        newText = newText.left(m_maxTextLength);

    }

    setPlainText(newText);

    m_textLine = document()->begin().layout()->lineForTextPosition(0);

  }

  void GTextLineItem::setMaxTextLength(int length)

  {

    if (m_maxTextLength <= 0 && length > 0) {

        QString text = toPlainText();

        if( text.length() > length ) {

          setPlainText(text.left(length));

        }

        connect(document(), SIGNAL(contentsChange(int, int, int)), this, SLOT(contentsChange(int, int, int)));

    } else if (m_maxTextLength > 0 && length <= 0) {

        disconnect(document(), SIGNAL(contentsChange(int, int, int)), this, SLOT(contentsChange(int, int, int)));

    }

    m_maxTextLength = length;

  }

  void GTextLineItem::setSpecificButton(QString& commitString, QString& buttonIconPath) {

    m_spBtnCommitString = commitString;

    m_spBtnIconPath = buttonIconPath;

    m_setSpecificBtn = true;

  }

  void GTextLineItem::contentsChange(int position, int charsRemoved, int charsAdded)

  {

    Q_UNUSED(position);

    Q_UNUSED(charsRemoved);

    Q_UNUSED(charsAdded);

    if( m_maxTextLength > 0 && toPlainText().length() > m_maxTextLength ) {

      QTextCursor cursor = textCursor();

      cursor.deletePreviousChar();

      setTextCursor(cursor);

    }

  }

  void GTextLineItem::specificBtnTriggered(bool checked)

  {

#ifdef ORBIT_UI

    QInputContext *ic = qApp->inputContext();

    QInputMethodEvent *imEvent = new QInputMethodEvent();

    imEvent->setCommitString(QString(m_spBtnCommitString));

    if (ic)

      ic->sendEvent(*imEvent);

    delete imEvent;

#endif

  }

  // Get the pixel offset of the cursor. Needed to implement scrolling.

  qreal GTextLineItem::cursorX()

  {

    return m_textLine.cursorToX(textCursor().position());

  }

  qreal GTextLineItem::anchorX()

  {

    return m_textLine.cursorToX(textCursor().anchor());

  }

  QRectF GTextLineItem::selectionRectF()

  {

    qreal x1 = cursorX();

    qreal x2 = anchorX();

    if (x1 == x2)

      return QRectF();

    return QRectF(x1, 0, x2-x1 + 16, boundingRect().height());

  }

  void GTextLineItem::selectAll()

  {

    QTextCursor tc = textCursor();

    tc.select(QTextCursor::Document);

    setTextCursor(tc);

    emit cursorXChanged(cursorX());

  }

  void GTextLineItem::unselect()

  {

    QTextCursor tc = textCursor();

    tc.setPosition(tc.position());

    setTextCursor(tc);

  }

  void GTextLineItem::setCursorPosition(int pos)

  {

    QTextCursor tc = textCursor();

    tc.setPosition(pos);

    setTextCursor(tc);

  }

  qreal GTextLineItem::textWidth()

  {

    return m_textLine.naturalTextWidth();

  }

  void GTextLineItem::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)

  {

    // Paint without ugly selection ants (the dashed line that surrounds

    // the selected text). TODO: It is clearly a bug in QGraphicsTextItem

    // that you cannot explicitly set the style of the selection indicator.  File this.

    QStyleOptionGraphicsItem newOption = *option;

    newOption.state &= (!QStyle::State_Selected | !QStyle::State_HasFocus);

    painter->save();

    painter->setRenderHint(QPainter::Antialiasing);

    QGraphicsTextItem::paint(painter, &newOption, widget);

    painter->restore();

    if(!isEnabled()) {

        ChromeEffect::paintDisabledRect(painter, option->exposedRect);

    }

  }

  void GTextLineItem::mouseMoveEvent(QGraphicsSceneMouseEvent * event)

  {

    QGraphicsTextItem::mouseMoveEvent(event);

    emit cursorXChanged(cursorX());

  }

  void GTextLineItem::mousePressEvent(QGraphicsSceneMouseEvent * event)

  {

    QGraphicsTextItem::mousePressEvent(event);

  }

  void GTextLineItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)

  {

    QGraphicsTextItem::mouseReleaseEvent(event);

    QPointF pos = event->pos();

    emit tapped(pos);

  }

  void GTextLineItem::keyPressEvent(QKeyEvent * event)

  {

    // Signal horizontal cursor movement so that an editor widget can

    // implement horizontal scrolling.

    qreal oldX = cursorX();

    QGraphicsTextItem::keyPressEvent(event);

    qreal newX = cursorX();

    if (newX != oldX) {

      emit cursorXChanged(newX);

    }

  }

  void GTextLineItem::keyReleaseEvent(QKeyEvent * event)

  {

    QGraphicsTextItem::keyReleaseEvent(event);

    emit textMayChanged();

  }

  void GTextLineItem::focusInEvent(QFocusEvent * event)

  {

    Q_UNUSED(event);

    // disable the drag & drop to fix the auto-delete-all issue

    QApplication::setStartDragDistance(1000);

    QGraphicsTextItem::focusInEvent(event);

#ifndef ORBIT_UI

    QWidget* fw = QApplication::focusWidget();

    Qt::InputMethodHints hints = fw->inputMethodHints();

    if (hints != m_hints)

      fw->setInputMethodHints(m_hints);

#endif

    if (event->reason() != Qt::PopupFocusReason) // to fix the special char issue on VKB

      emit focusChanged(true);

  }

  void GTextLineItem::focusOutEvent(QFocusEvent * event)

  {

    Q_UNUSED(event);

    // restore the drag & drop for other components

    QApplication::setStartDragDistance(m_defaultStartDragDistance);

    QGraphicsTextItem::focusOutEvent(event);

    if (event->reason() != Qt::PopupFocusReason && event->reason() != Qt::ActiveWindowFocusReason) // to fix the special char issue on VKB

      emit focusChanged(false);

  }

  void GTextLineItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

  {

    // ignore context menu event

    event->ignore();

  }

  void GTextLineItem::setInputMethodHints(Qt::InputMethodHints hints)

  { 

    m_hints = hints;

    m_hints |= Qt::ImhNoPredictiveText;  // disable the predictive text

  }

  // Methods for class GLineEditor

  // GLineEditor is a QGraphicsWidget that wraps a GTextLineItem to implement scrolling, 

  // draw a background and set padding 

  GLineEditor::GLineEditor(ChromeSnippet * snippet, ChromeWidget * chrome, QGraphicsItem * parent)

  : QGraphicsWidget(parent)

  , m_chrome(chrome)

  , m_viewPortWidth(0.0)

  , m_padding(0.0)

  , m_rightTextMargin(0.0)

  {

    Q_UNUSED(snippet);

    // The viewport clips the editor when text overflows

    // viewport size will be set in resize()

    m_viewPort = new QGraphicsWidget(this);

    m_viewPort->setFlags(QGraphicsItem::ItemClipsChildrenToShape);

    // The actual text editor item

    m_editor = new GTextLineItem(m_viewPort);

    m_editor->setDefaultTextColor(m_textColor);

    m_editor->installEventFilter(this);

    // Monitor editor cursor position changes for horizontal scrolling.

    safe_connect(m_editor, SIGNAL(cursorXChanged(qreal)),

                 this, SLOT(makeVisible(qreal)));

    safe_connect(m_editor, SIGNAL(textMayChanged()),

                 this, SIGNAL(textMayChanged()));

    safe_connect(m_editor, SIGNAL(focusChanged(bool)),

                 this, SIGNAL(focusChanged(bool)));

    safe_connect(m_editor, SIGNAL(tapped(QPointF&)),

                 this, SIGNAL(tapped(QPointF&)));

    setAcceptDrops(false);

  }

  GLineEditor::~GLineEditor()

  {

  }

  // TODO: Be a good QGraphicsWidget: update this to use palette color?

  void GLineEditor::setTextColor(QColor & color)

  {

    m_textColor = color;

    m_editor->setDefaultTextColor(m_textColor);

  }

  void GLineEditor::setPadding(qreal padding)

  {

    m_padding = padding;

    //Trigger a resize to adjust component sizes to new padding

    resize(size());

  }

  void GLineEditor::setRightTextMargin(qreal margin)

  {

    m_rightTextMargin = margin;

    resize(size());

  }

  QString GLineEditor::text() const

  {

    return m_editor->toPlainText();

  }

  void GLineEditor::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)

  {

    Q_UNUSED(option);

    Q_UNUSED(widget);

    painter->save();

    painter->setRenderHint(QPainter::Antialiasing);

    // First, fill rectangle with background color.

    painter->fillRect(boundingRect(), m_backgroundColor);

    painter->restore();

    if(!isEnabled()) {

        ChromeEffect::paintDisabledRect(painter, option->exposedRect);

    }

    // Make sure any required horizontal scrolling happens

    // before rendering editor widget, which will be drawn on top

    // of the background rectangle.

    makeVisible(m_editor->cursorX());

  }

  void GLineEditor::resizeEvent(QGraphicsSceneResizeEvent * event)

  {

    QSizeF size = event->newSize();

    m_viewPort->setGeometry(

                            m_padding,

                            (size.height() - m_editor->boundingRect().height()) / 2,

    m_editor->setTextWidth(m_viewPortWidth);

    // move back the m_editor'x to 0

    qreal editorShift = -1 * m_editor->pos().x();

    m_editor->moveBy(editorShift, 0);

    updateEditor();

  }

  void GLineEditor::setText(const QString & text)

  {

    m_editor->setText(text);

    m_editor->setPos(0, m_editor->pos().y());

    updateEditor();

  }