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

**

** 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 <QPoint>

#include <hbglobal.h>

#include "hbparameterlengthlimiter.h"

#include "hbparameterlengthlimiter_p.h"

/*!

    @alpha

    @hbcore

    \class HbParameterLengthLimiter

    \brief HbParameterLengthLimiter is a class that offers support to insert different types of arguments into a QString.

    Supports upto 9 argument inserts per QString.

    Supports different kinds of indicators that are used for marking where arguments are inserted

        - %x for inserting QStrings, where x is number from 1 to 9 indicating the order in which argumentss are positioned.

        - %[y]x for inserting QStrings, x indicates argument inserting order and y is a number indicating the maximum length

                for the argument e.g. %[10]2 would mean that the inserted QStrings maximum length is 10 characters and that the

                limited argument is the second argument to be inserted.

        - %Lx   for inserting numbers, x is used to indicate argument inserting order.

    Example of how to use HbParameterLengthLimiter

    \snippet{unittest_HbParameterLengthLimiter/unittest_HbParameterLengthLimiter.cpp,1}

*/

/*!

    Constructs a HbParameterLengthLimiter with \a HbParameterLengthLimiter.

    \a HbLengthLimter& - HbParameterLengthLimiter that will have arguments inserted

*/

HbParameterLengthLimiter::HbParameterLengthLimiter( const HbParameterLengthLimiter& a )

{

    p = new HbParameterLengthLimiterPrivate();

    p->str = a.p->str;

}

/*!

    Constructs a HbParameterLengthLimiter with \a QString.

    \a QString - QString that will have arguments inserted

*/

HbParameterLengthLimiter::HbParameterLengthLimiter( QString a )

{

    p = new HbParameterLengthLimiterPrivate();

    p->str = a;

}

/*!

    Constructs a HbParameterLengthLimiter with \a char*.

    \a const char* - char string that will have arguments inserted

*/

HbParameterLengthLimiter::HbParameterLengthLimiter( const char* a )

{

    p = new HbParameterLengthLimiterPrivate();

    p->str = hbTrId(a);

}

/*!

    Constructs a HbParameterLengthLimiter with \a char*.

    \a const char* - char string that will have arguments inserted

    \n int - used to identify which plural form to use

*/

HbParameterLengthLimiter::HbParameterLengthLimiter( const char* a, int n )

{

    p = new HbParameterLengthLimiterPrivate();

    p->str = hbTrId(a, n);

}

/*!

    Conp->structs a HbParameterLengthLimiter without a predefined QString.

*/

HbParameterLengthLimiter::HbParameterLengthLimiter()

{

    p = new HbParameterLengthLimiterPrivate();

    p->str = "";

}

/*!

    Destructor

*/

HbParameterLengthLimiter::~HbParameterLengthLimiter()

{

    delete p;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a qlonglong - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg(qlonglong a,

                                      int fieldwidth,

                                      int base,

                                      const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldwidth,base,tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a qulonglong - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( qulonglong a,

                                       int fieldwidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldwidth,base,tmpChar);

    return *this;

 }

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a long - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( long a,

                                       int fieldwidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldwidth,base,tmpChar);

    return *this;

 }

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a ulong - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( ulong a,

                                       int fieldwidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldwidth,base,tmpChar);

    return *this;

 }

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a int - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( int a,

                                       int fieldWidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldWidth,base,tmpChar);

    return *this;

 }

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a uint - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( uint a,

                                       int fieldWidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldWidth,base,tmpChar);

    return *this;

 }

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a short - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( short a,

                                       int fieldWidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldWidth,base,tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a ushort - number that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \base int - defines the number base

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( ushort a,

                                       int fieldWidth,

                                       int base,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a,fieldWidth,base,tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a double - Argument a is formatted according to the specified format and precision.

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \fmt char - defines the format to be used

    \prec int - defines the precision to be used

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( double a,

                                       int fieldWidth,

                                       char fmt,

                                       int prec,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a, fieldWidth, fmt, prec, tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a char - character that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( char a,

                                       int fieldWidth,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a, fieldWidth, tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a QChar - character that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( QChar a,

                                       int fieldWidth,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    p->str = p->str.arg(a, fieldWidth, tmpChar);

    return *this;

}

/*!

    Inserts an \a argument to a HbParameterLengthLimiter QString.

    \a QString - QString that will be inserted to the QString

    \fieldwidth int - specifies the minimum amount of space that a is padded to and filled with the character fillChar

    \fillChar QChar - defines the fill character

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a,

                                       int fieldWidth,

                                       const QChar &fillChar)

{

    QChar tmpChar = fillChar;

    if ( a.length() == 0 ) {

        return *this;    

    }

    QString result = "";

    int i = 0;

    int signPosition;

    QPoint position(10,0);

    while ( i < p->str.length() ) {

        if ( p->str.at(i) == '%' ) {

            signPosition = i;

            i++;

            if ( i >= p->str.length() ) {

                break;

            }

            if ( p->str.at(i).isDigit() ) {

                //normal QString

                QString number = p->str.at( i );

                if( number.toInt() < position.x() ) {

                    position.setX( number.toInt() );

                    position.setY( signPosition );

                }

            } else if ( p->str.at(i) == '[' ) {

                //limited QString

                i++;

                if( i >= p->str.length() ) {

                    break;

                }

                while( p->str.at(i) != ']' ) {

                    i++;

                }

                i++;

                if( i >= p->str.length() ) {

                    break;

                }

                if( p->str.at(i).isDigit() ) {

                    QString number = p->str.at(i);

                    if( number.toInt() < position.x() ) {

                        position.setX( number.toInt() );

                        position.setY( signPosition );

                    }

                }

                else{

                    --i;

                }

            }

        }

        i++;

    }

    i = position.y();

    if ( p->str.at(i) == '%' ) {

        result.append( p->str.at(i) );

        i++;

        if ( p->str.at(i).isDigit() ) {

            //normal QString

            p->str = p->str.arg( a, fieldWidth, tmpChar );

        } else if ( p->str.at(i) == '[' ) {

            //limited QString

            i++;

            if( i >= p->str.length() ) {

                return *this;

            }

            QString limiter = "";

            bool limitedFound = false;

            while (p->str.at(i) != ']'){

                if ( p->str.at(i).isNumber() ) {

                    limitedFound = true;

                    limiter.append( p->str.at(i) );

                    i++; 

                    if ( i >= p->str.length() ) {

                        return *this;

                    }

                }

            }

            i++;

            if ( i >= p->str.length() ) {

                return *this;

            }

            if( limitedFound && p->str.at(i).isNumber() ) {

                i++;

                result = p->str.left( position.y() );

                int length = limiter.toInt();

                QString limitedA = a;

                int o = 0;

                int u = 0;

                if( length < a.length() ) {

                    while ( o <= a.length() ) {

                        // If character is Thai vowel or tone mark, skip it as it does not have length

                        // U+E34 = 3636, U+E3B = 3643, U+E47 = 3655, U+E4D = 3661

                        // or zero wide space 200B = 8203

                        if ( (a.at(o).unicode() < 3636 || a.at(o).unicode() > 3643)

                             && (a.at(o).unicode() < 3655 || a.at(o).unicode() > 3661)

                             && a.at(o).unicode() != 8203 ) {

                            u++;

                        }

                        if ( u == length+1 ) {

                            limitedA = a.left( o) ;

                            // Add ellipsis as a mark that QString is truncated

                            limitedA.append( QChar(0x2026) );

                            break;

                        }

                        o++;

                    }

                }

                result.append( "%1" );

                int cutter = p->str.length() - i ;

                QString tmp = p->str.right(cutter);

                result.append( tmp );

                p->str = result.arg( limitedA, fieldWidth, tmpChar );

            }

        }

    }

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2 )

{

    this->arg(a1).arg(a2);

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

    \a3 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2,

                                       const QString &a3)

{

    this->arg(a1, a2).arg(a3);

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

    \a3 QString - QString that will be inserted to the QString

    \a4 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2,

                                       const QString &a3,

                                       const QString &a4 )

{

    this->arg(a1, a2, a3).arg(a4);

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

    \a3 QString - QString that will be inserted to the QString

    \a4 QString - QString that will be inserted to the QString

    \a5 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2,

                                       const QString &a3,

                                       const QString &a4,

                                       const QString &a5 )

{

    this->arg(a1, a2, a3, a4 ).arg(a5);

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

    \a3 QString - QString that will be inserted to the QString

    \a4 QString - QString that will be inserted to the QString

    \a5 QString - QString that will be inserted to the QString

    \a6 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2,

                                       const QString &a3,

                                       const QString &a4,

                                       const QString &a5,

                                       const QString &a6 )

{

    this->arg(a1, a2, a3, a4, a5).arg(a6);

    return *this;

}

/*!

    Inserts an arguments \a1 and \a2 to a HbParameterLengthLimiter QString.

    \a1 QString - QString that will be inserted to the QString

    \a2 QString - QString that will be inserted to the QString

    \a3 QString - QString that will be inserted to the QString

    \a4 QString - QString that will be inserted to the QString

    \a5 QString - QString that will be inserted to the QString

    \a6 QString - QString that will be inserted to the QString

    \a7 QString - QString that will be inserted to the QString

*/

HbParameterLengthLimiter& HbParameterLengthLimiter::arg( const QString &a1,

                                       const QString &a2,