void DigraphLineEdit::keyPressEvent( QKeyEvent* event ) {
    if( digraphEnabled ) {
        // We consider only printable keys.  Control keys are processed normally.
        // I'm not sure if this test covers all the cases though.
        if( event->count() > 0 ) {
            if( event->key() == Qt::Key_Backspace ) {
                if( cursorPosition() > 0 ) {
                    if( buffer.isNull() ) {
                        QString charToDelete( text().mid( cursorPosition() - 1, 1 ) );
                        buffer = charToDelete;
                    }
                    else 
                        buffer = QString::null;
                }
            }
            else {
                // Shift key is required to input some digraphs so it's a special case.
                if( !buffer.isNull() && event->key() != Qt::Key_Shift ) {
                    buffer += event->text();
                    const QString newChar( Util::getDigraph( buffer ) );
                    if( newChar == QString::null )
                        buffer = QString::null;
                    else {
                        QKeyEvent* digraphEvent = new QKeyEvent( QEvent::KeyPress, 0, Qt::NoModifier, newChar, event->isAutoRepeat(), 0 );
                        QLineEdit::keyPressEvent( digraphEvent );
                        buffer = QString::null;
                        return;
                    }
                }
            }
        }
    }
    QLineEdit::keyPressEvent( event );
}

void lcl_OnyxLineEdit::keyPressEvent(QKeyEvent * ke)
{
    if (ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Return)
    {
        NumberDialog dialog(0, name);
        if (dialog.popup(text().toInt(), maxval) == QDialog::Accepted) {
            int val = dialog.value();
            QString s_val;
            s_val = QString("%1").arg(val);
            setText(s_val);
    
            onyx::screen::instance().updateWidget(0, onyx::screen::ScreenProxy::GU);
            emit valueChanged(this);
        }
    }

    if ((ke->key() == Qt::Key_Left && cursorPosition() <= 0) ||
        (ke->key() == Qt::Key_Right && cursorPosition() >= text().size()))
    {
        out_of_range_ = true;
    }
    QLineEdit::keyPressEvent(ke);
    ke->accept();
    update();
    onyx::screen::watcher().enqueue(this, onyx::screen::ScreenProxy::DW, onyx::screen::ScreenCommand::WAIT_NONE);
}

/** TagButton instances are converted with whitespaces in the LineEdit in order to move them. */
void TagLineEdit::insertSpaces()
{
	TagButton *t = qobject_cast<TagButton*>(sender());
	int cx = cursorRect().x();
	t->setPosition(cursorPosition());
	int numberOfSpace = 2;

	this->setText(this->text().insert(cursorPosition(), "  "));

	cursorForward(false, 2);
	while (t->frameGeometry().contains(cursorRect().center())) {
		this->setText(this->text().insert(cursorPosition(), " "));
		cursorForward(false);
		numberOfSpace++;
	}
	t->setMinimumWidth(numberOfSpace * fontMetrics().width(" ") - 5);
	t->setSpaceCount(numberOfSpace);
	t->disconnect();

	for (TagButton *tag : _tags) {
		//qDebug() << Q_FUNC_INFO << "trying to move tag";
		if (t != tag && tag->frameGeometry().x() > cx) {
			//qDebug() << Q_FUNC_INFO << "moving tag" << tag->text();
			tag->move(tag->x() + fontMetrics().width(" ") * numberOfSpace, 0);
		}
	}
}

void GuidLineEdit::keyPressEvent(QKeyEvent * event)
{
    if (event == QKeySequence::Delete || event->key() == Qt::Key_Backspace)
    {
        int pos = cursorPosition();
        if (event->key() == Qt::Key_Backspace && pos > 0) {
            cursorBackward(false);
            pos = cursorPosition();
        }
        
        QString txt = text();
        QString selected = selectedText();

        if (!selected.isEmpty()) {
            pos = QLineEdit::selectionStart();
            for (int i = pos; i < pos + selected.count(); i++)
                if (txt[i] != QChar('-'))
                    txt[i] = QChar('.');
        }
        else 
            txt[pos] = QChar('.');

        setCursorPosition(0);
        insert(txt);
        setCursorPosition(pos);

        return;
    }

    // Call original event handler
    QLineEdit::keyPressEvent(event);
}

void StatusEdit::shortenUrl()
{ 
  if( hasSelectedText() ) {
    selectedUrl = selectedText();
    emit shortenUrl( selectedUrl );
  } else {
    QRegExp rx( "((ftp|http|https)://(\\w+:{0,1}\\w*@)?([^ ]+)(:[0-9]+)?(/|/([\\w#!:.?+=&%@!-/]))?)", Qt::CaseInsensitive );

    int position = rx.indexIn( text() );
    QString url = rx.capturedTexts().at( 1 );
    if( cursorPosition() >= position && cursorPosition() <= url.length() + position ) {
      selectedUrl = url;
      emit shortenUrl( selectedUrl );
    }
  }
}

void NumberEdit::texttChanged(const QString& text) {
    QString in=text;
    if (!suffix.isEmpty()) {
        if (text.endsWith(suffix)) {
            in=in.remove(text.size()-suffix.size(), suffix.size());
        }
    }
    double d=extractVal(text);
    setViewOK();
    if ((checkMax) && (d>max)) {
        d=max;
        setViewError();
    }//setValue(d);}
    if ((checkMin) && (d<min)) {
        d=min;
        setViewError();
    }//setValue(d); }

    //std::cout<<d<<std::endl;
    //QMessageBox::information(this, "", QString("value is %1").arg(d));
    else emit valueChanged(d);
    if ((!suffix.isEmpty()) && (!text.contains(suffix))) {
        int cp=cursorPosition();
        setText(text+suffix);
        setCursorPosition(cp);
    }
}

void ByteArrayColumnViewPrivate::placeCursor( const QPoint& point )
{
    Q_Q( ByteArrayColumnView );

    // switch active column if needed
    if( mCharColumn->isVisible() && point.x() >= mCharColumn->x() )
    {
        mActiveColumn = mCharColumn;
        mInactiveColumn = mValueColumn;
    }
    else
    {
        mActiveColumn = mValueColumn;
        mInactiveColumn = mCharColumn;
    }
    adaptController();

    // get coord of click and whether this click was closer to the end of the pos
    const int linePosition = mActiveColumn->magneticLinePositionOfX( point.x() );
    const int lineIndex = q->lineAt( point.y() );
    const Coord coord( linePosition, lineIndex );

    mTableCursor->gotoCCoord( coord );
    emit q->cursorPositionChanged( cursorPosition() );
}

void QLineEditEx::keyPressEvent(QKeyEvent *e)
{
    if(e->key() == Qt::Key_Up)	
	{
		loadHistory(true,m_History,m_Index);
		return;
	}
    else if (e->key() == Qt::Key_Down)
	{
		loadHistory(false,m_History,m_Index);
		return;
	}
	else if(e->key() == Qt::Key_Left)
	{
		if(m_TabIndex != -1)
		{
			suggest(false);
			return;
		}
	}
	else if(e->key() == Qt::Key_Right)
	{
		if(cursorPosition() == text().length() || m_TabIndex != -1)
		{
			suggest(true);
			return;
		}
	}
	else
	{
		m_TabBase.clear();
		m_TabIndex = -1;
	}
	QLineEdit::keyPressEvent(e);
}

void KonqCombo::saveState()
{
    m_cursorPos = cursorPosition();
    m_currentText = currentText();
    m_selectedText = lineEdit()->selectedText();
    m_currentIndex = currentIndex();
}

void KTextBox::fitText()
{
  int startindex, endindex, countindex, testlength, line, column;
  
  // Map the text to the width of the widget
  cursorPosition( &line, &column );
  countindex =-1;
  QString testText = text().simplifyWhiteSpace() + " ";
  startindex = 0;
  testlength = testText.length();
  countindex = testText.find(" ", 0);
  while ((endindex = testText.find(" ", countindex+1)) > -1) {
    QString middle;
    int len;
    len = endindex - startindex;
    middle = testText.mid( startindex, len );

    if (textWidth( &middle ) > width()) {
      testText.replace( countindex, 1, "\n" );
      startindex = countindex;
    }
    countindex = endindex;
  }

  setText( testText.stripWhiteSpace() );

  setCursorPosition( line, column );
}

void MgCommandLine::keyPressEvent(QKeyEvent * e)
{
	if(e->key() == Qt::Key_Escape )
		clear();
	else if((e->key() == Qt::Key_Enter || e->key() == Qt::Key_Return ) && m_scriptEngine && m_completer->popup()->isVisible())
	{
		insertText(m_completer->popup()->currentIndex().data().toString());
		m_completer->popup()->hide();
	}
	else if((e->key() == Qt::Key_Enter || e->key() == Qt::Key_Return ) && m_scriptEngine)
	{
		m_scriptEngine->execCommand(text());
		clear();
	}
	else if(e->key() == Qt::Key_Space && e->modifiers().testFlag(Qt::ControlModifier))
	{
		if(!m_completer->popup()->isVisible())
		{
			MgCommandCompleter completer(m_scriptEngine);
			MgCommandCompleter::CompletionResult result = completer.completionOf(text(),cursorPosition());

			m_completer->setCompletionPrefix("");
			m_prefix = result.prefix;
			m_completionModel->setStringList(result.completion);
			m_completer->complete();
		}
		else
		{
			m_completer->popup()->hide();
		}

	}
	else
		QLineEdit::keyPressEvent(e);
}

void QcrLineEdit::doSetValue(QString val)
{
    //keep cursor pos, so the cursor doesn't always jump to the end:
    int oldCursorPos = cursorPosition();
    setText(val);
    this->setCursorPosition(oldCursorPos);
}

void LineEditHistory::complete()
{
	QString para = this->text();
	int wordStart = beginOfWord( false );
	while (wordStart > 0 && para[wordStart - 1].isLetterOrNumber())
		--wordStart;
	wordPrefix = para.mid(wordStart, cursorPosition() - wordStart);
//	if (wordPrefix.isEmpty())
//		return;

	QStringList list = searchSymbols;
	QMap<QString, QString> map;
	QStringList::Iterator it = list.begin();
	while (it != list.end()) {
		if ((*it).startsWith(wordPrefix) && (*it).length() > wordPrefix.length())
			map[(*it).toLower()] = *it;
		++it;
	}

	if (map.count() == 1) {
		insert((*map.begin()).mid(wordPrefix.length()));
	} else if (map.count() > 1) {
		if (!listBox)
			createListBox();
		listBox->clear();
		listBox->addItems( map.values() );

		QPoint point = textCursorPoint();
		listBox->move(point);
		listBox->show();
		listBox->raise();
		listBox->activateWindow();
	}
}

void BaseValidatingLineEdit::slotChanged(const QString &t)
{
    m_bd->m_errorMessage.clear();
    // Are we displaying the initial text?
    const bool isDisplayingInitialText = !m_bd->m_initialText.isEmpty() && t == m_bd->m_initialText;
    const State newState = isDisplayingInitialText ?
                               DisplayingInitialText :
                               (validate(t, &m_bd->m_errorMessage) ? Valid : Invalid);
    setToolTip(m_bd->m_errorMessage);
    if (debug)
        qDebug() << Q_FUNC_INFO << t << "State" <<  m_bd->m_state << "->" << newState << m_bd->m_errorMessage;
    // Changed..figure out if valid changed. DisplayingInitialText is not valid,
    // but should not show error color. Also trigger on the first change.
    if (newState != m_bd->m_state || m_bd->m_firstChange) {
        const bool validHasChanged = (m_bd->m_state == Valid) != (newState == Valid);
        m_bd->m_state = newState;
        m_bd->m_firstChange = false;
        setTextColor(this, newState == Invalid ? m_bd->m_errorTextColor : m_bd->m_okTextColor);
        if (validHasChanged) {
            emit validChanged(newState == Valid);
            emit validChanged();
        }
    }
    bool block = blockSignals(true);
    const QString fixedString = fixInputString(t);
    if (t != fixedString) {
        const int cursorPos = cursorPosition();
        setText(fixedString);
        setCursorPosition(qMin(cursorPos, fixedString.length()));
    }
    blockSignals(block);
}

void BookTextView::replaceCurrentPositionInStack() {
	const ZLTextWordCursor &cursor = textArea().startCursor();
	if (!cursor.isNull()) {
		myPositionStack[myCurrentPointInStack] = cursorPosition(cursor);
		myStackChanged = true;
	}
}

void
line_edit_autocomplete::show_completions()
{
  if (!m_completer_enabled)
    return;

  QString prefix; // substring on which the completion is to be based

  int pos = cursorPosition();
  int start = get_prefix_pos(text(), pos);
  if (start>=0) {
    prefix=text().mid(start, pos-start);
  }

  if (prefix.isEmpty()) {
    // nothing to complete
    if (popup->isVisible()) {
      popup->clear();
      popup->hide();
    }
  }
  else {
    QList<QString> completions = get_completions(prefix);
    redisplay_popup(completions);
  }
}

 void PropertyLineEdit::insertText(const QString &text) {
     // position cursor after new text and grab focus
     const int oldCursorPosition = cursorPosition ();
     insert(text);
     setCursorPosition (oldCursorPosition + text.length());
     setFocus(Qt::OtherFocusReason);
 }

QPair<int, int> TagWidget::getCursorTagPosition()
{
	int i = 0, start = 0, end = 0;
	/* Parse string near cursor */
	i = cursorPosition();
	while (--i > 0) {
		if (text().at(i) == ',') {
			if (i > 0 && text().at(i - 1) != '\\') {
				i++;
				break;
			}
		}
	}
	start = i;
	while (++i < text().length()) {
		if (text().at(i) == ',') {
			if (i > 0 && text().at(i - 1) != '\\')
				break;
		}
	}
	end = i;
	if (start < 0 || end < 0) {
		start = 0;
		end = 0;
	}
	return qMakePair(start, end);
}

void
SpinBox::setValue_internal(double d,
                           bool reformat)
{
    if ( ( d == text().toDouble() ) && !reformat && _imp->valueInitialized ) {
        // the value is already OK
        return;
    }

    int pos = cursorPosition();
    QString str;
    switch (_imp->type) {
    case eSpinBoxTypeDouble: {
        str.setNum(d, 'f', _imp->decimals);
        double toDouble = str.toDouble();
        if (d != toDouble) {
            str.setNum(d, 'g', 8);
        }
        break;
    }
    case eSpinBoxTypeInt:
        str.setNum( (int)d );
        break;
    }
    assert( !str.isEmpty() );

    ///Remove trailing 0s by hand...
    int decimalPtPos = str.indexOf( QLatin1Char('.') );
    if (decimalPtPos != -1) {
        int i = str.size() - 1;
        while ( i > decimalPtPos && str.at(i) == QLatin1Char('0') ) {
            --i;
        }
        ///let 1 trailing 0
        if (i < str.size() - 1) {
            ++i;
        }
        str = str.left(i + 1);
    }

    // The following removes leading zeroes, but this is not necessary
    /*
       int i = 0;
       bool skipFirst = false;
       if (str.at(0) == '-') {
       skipFirst = true;
       ++i;
       }
       while (i < str.size() && i == '0') {
       ++i;
       }
       if (i > int(skipFirst)) {
       str = str.remove(int(skipFirst), i - int(skipFirst));
       }
     */
    _imp->valueWhenEnteringFocus = str;
    setText(str, pos);
    _imp->valueInitialized = true;
}

QChar WizTitleEdit::charBeforeCursor()
{
    int i = cursorPosition() - 1;
    if (i >= 0)
        return text().at(i);

    return QChar();
}