/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <QGraphicsTextItem>

#include "TextEditItem.h"

#include "ChromeSnippet.h"

#include "GreenChromeSnippet.h"

namespace GVA {

  EditorWidget::EditorWidget(QGraphicsItem * parent)

    : QGraphicsTextItem(parent)

  {

    setText("");

  }

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

  {

    //Hack to get rid of the ugly selection ants. This should be tunable in QGraphicsTextItem!

    QStyleOptionGraphicsItem newOption = *option;

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

    painter->save();

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

    painter->restore();

  }

  // The editor document signals cursor movements when the document modified (because characters

  // are being added or removed, but not when the cursor is simply being moved. Also, the

  // document's idea of cursor position is based on the character count, not the actual pixel

  // position. To implement scrolling, we need our own cursor change event that supplies the

  // pixel change in all cases.

  void EditorWidget::keyPressEvent(QKeyEvent *event)

  {   

    qreal oldX = cursorX();

    QGraphicsTextItem::keyPressEvent(event);

    emit cursorXChanged(cursorX(), oldX);

  }

  void EditorWidget::setText(const QString& text, bool html)

  {

    if(html)

      setHtml(text);

    else

      setPlainText(text);

    //All this just to get the first (and only) text line of the document!

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

  }

  // Use QTextLine to compute the text metrics for the current cursor position.

  qreal EditorWidget::cursorX() {

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

  }

  TextEditItem::TextEditItem(ChromeSnippet * snippet, QGraphicsItem* parent)

    : NativeChromeItem(snippet, parent),

      m_textWidth(0),

      m_scrollPos(0)

  {

    setFlags(QGraphicsItem::ItemIsMovable);

    //The viewport clips the editor when text overflows

    m_viewPort = new QGraphicsWidget(this);

    m_viewPort->setFlags(QGraphicsItem::ItemClipsChildrenToShape);

    //The actual text editor item

    m_editor = new EditorWidget(m_viewPort);

    m_cursor = m_editor->textCursor();

    connect(m_editor, SIGNAL(cursorXChanged(qreal, qreal)), this, SLOT(onCursorXChanged(qreal, qreal)));

    //Force the editor to be a single text line 

    m_textOption = m_editor->document()->defaultTextOption();

    m_textOption.setWrapMode(QTextOption::NoWrap);

    m_editor->document()->setDefaultTextOption(m_textOption);

    //Not exactly well-documented, but this flag is needed to make cursor keys work

    m_editor->setTextInteractionFlags(Qt::TextEditorInteraction);

    //Non-default key handling for scrolling, etc.

    m_editor->installEventFilter(this);

    //Set text and background colors from element css

    QString cssVal = m_snippet->element().styleProperty("color", QWebElement::ComputedStyle);

    CSSToQColor(cssVal, m_textColor);

    m_editor->setDefaultTextColor(m_textColor);

    cssVal = m_snippet->element().styleProperty("background-color", QWebElement::ComputedStyle);

    CSSToQColor(cssVal, m_backgroundColor);

    //For border-related properties, we constrain all values (top, left, etc.) to be the same.

    //These can be set using the css shorthand (e.g. padding:10px), but the computed css style will be for

    //the four primitive values (padding-top, padding-left) etc, which will all be equal.

    //Hence we just use one of the computed primitive values (top) to represent the common value.

    cssVal = m_snippet->element().styleProperty("border-top-color", QWebElement::ComputedStyle);

    CSSToQColor(cssVal, m_borderColor);

    cssVal = m_snippet->element().styleProperty("padding-top", QWebElement::ComputedStyle);

    m_padding = cssVal.remove("px").toInt();

    cssVal = m_snippet->element().styleProperty("border-top-width", QWebElement::ComputedStyle);

    m_border = cssVal.remove("px").toInt();

    //Cool effect, but shadow, if any, should be set by js

    //m_shadow = new QGraphicsDropShadowEffect();

    //m_shadow->setOffset(3.0,3.0);

    //m_shadow->setBlurRadius(2.0);

    //setGraphicsEffect(m_shadow);

  }

  TextEditItem::~TextEditItem()

  {

    delete m_editor;

  }

  void TextEditItem::resizeEvent(QGraphicsSceneResizeEvent * ev)

  {

    NativeChromeItem::resizeEvent(ev);

    m_viewPortWidth = boundingRect().width()-m_padding*2;

    m_viewPort->setGeometry(m_padding,(boundingRect().height()-m_editor->boundingRect().height())/2,m_viewPortWidth, m_editor->boundingRect().height() );

    m_editor->setTextWidth(m_viewPortWidth);

    //Make a rectangular background with a cut-out for the text. The width of the surrounding

    //background is set by padding 

    m_background.addRect(boundingRect());

    m_background.addRoundedRect(m_padding, m_padding, m_viewPortWidth, boundingRect().height()-m_padding*2,4,4);

 }

  //Filter key events to emit activate signal absorb up, down keys

  bool TextEditItem::eventFilter(QObject * obj, QEvent *ev)

  {

    if(obj == m_editor){

      if(ev->type() == QEvent::KeyPress){

	QKeyEvent *keyEvent = static_cast<QKeyEvent*>(ev);

	if(keyEvent->key() == Qt::Key_Select || keyEvent->key() == Qt::Key_Return || keyEvent->key() == Qt::Key_Enter) {

          //Signal that a carriage return-like key-press happened

	  emit activated();

	  return true;

	}

	if(keyEvent->key() == Qt::Key_Down || keyEvent->key() == Qt::Key_Up)

	  return true;

        //Otherwise, pass keypress to the text editor

	return false;

      }

    }

    return NativeChromeItem::eventFilter(obj, ev);

  }

  void TextEditItem::internalScroll(qreal deltaX)

  {

    if(deltaX > -m_scrollPos)

      m_editor->moveBy(-m_scrollPos,0);

    else

      m_editor->moveBy(deltaX,0);

    m_scrollPos = m_editor->pos().x();

  }

  //Handle text scrolling

  //NB: Still needs some tweaking, for example to keep the last character visibile when

  //inserting! Rewrite as state machine?

  void TextEditItem::onCursorXChanged(qreal newX, qreal oldX)

  {

    qreal oldTextWidth = m_textWidth;

    m_textWidth = m_editor->document()->size().width(); 

    if(oldTextWidth == 0)

	return;

    qreal textDelta = m_textWidth - oldTextWidth;

    qreal deltaX = oldX - newX;

    //Just moving the cursor, slide window as needed

    if(textDelta == 0){

      //NB: Currently slides by one character, in some browsers slides by multiple characters

      if((newX <= -m_scrollPos)||(newX >= (m_viewPortWidth - m_scrollPos))){

	internalScroll(deltaX);

      }

    }

    //Inserting characters

    else if (textDelta > 0){

      if(newX >= (m_viewPortWidth - m_scrollPos)){

        internalScroll(deltaX);

      }

    }

    //Deleting characters. 

    else {

      if(m_scrollPos < 0){

        //Delete may be a selected block, in which case the cursor movement may be

        //different from the text delta.

        internalScroll(-textDelta);

      }

    }

  }

  // Paint background and any border

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

    NativeChromeItem::paint(painter, option,widget);

    QPainterPath path;

    painter->save();

    painter->setRenderHint(QPainter::Antialiasing);

    painter->setBrush(m_backgroundColor);

    if(m_border > 0){

      QPen pen;

      pen.setWidth(m_border);

      pen.setBrush(m_borderColor);

      painter->setPen(pen);

    }

    painter->drawPath(m_background);

    painter->restore();

  }

  //NB: Move these slots to the containing snippet so they can be exported to JS

  QString TextEditItem::text(){

    return m_editor->toPlainText();

  }

  void TextEditItem::setText(const QString & text){

    m_editor->setText(text);

  }

}