--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbcore/i18n/hbparameterlengthlimiter.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,618 @@
+/****************************************************************************
+**
+** 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,
+ const QString &a3,
+ const QString &a4,
+ const QString &a5,
+ const QString &a6,
+ const QString &a7 )
+{
+ this->arg(a1, a2, a3, a4, a5, a6).arg(a7);
+ 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
+ \a8 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,
+ const QString &a7,
+ const QString &a8 )
+{
+ this->arg(a1, a2, a3, a4, a5, a6, a7).arg(a8);
+ 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
+ \a8 QString - QString that will be inserted to the QString
+ \a9 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,
+ const QString &a7,
+ const QString &a8,
+ const QString &a9 )
+{
+ this->arg(a1, a2, a3, a4, a5, a6, a7, a8).arg(a9);
+ return *this;
+}
+
+/*!
+ Changes the QString that is to be used for inserting arguments to \a.
+ \a QString - QString that will be used for inserting arguments
+*/
+HbParameterLengthLimiter& HbParameterLengthLimiter::operator=( const QString &a )
+{
+ p->str = a;
+ return *this;
+}
+
+/*!
+ Changes the QString that is to be used for inserting arguments to \a.
+ \a HbParameterLengthLimiter - HbParameterLengthLimiter holding the QString that will be used for inserting arguments
+*/
+HbParameterLengthLimiter& HbParameterLengthLimiter::operator=( const HbParameterLengthLimiter &a )
+{
+ p->str = a.p->str;
+ return *this;
+}
+
+/*!
+ returns the current QString.
+*/
+HbParameterLengthLimiter::operator QString() const
+{
+ return p->str;
+}
+
+
+