diff -r 000000000000 -r 72b543305e3a messagingappbase/smartmessaging/msgeditorutils/src/MsgBioUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/smartmessaging/msgeditorutils/src/MsgBioUtils.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,365 @@ +/* +* Copyright (c) 2002-2006 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: Class offers helper methods for BIO controls +* +*/ + + + +// INCLUDE FILES + +#include // CAknTextQueryDialog +#include +#include // StringLoader + +#include "MsgBioUtils.h" // Own header +#include // TUriParser8 +#include // resouce identifiers +#include "MsgEditorUtils.pan" // for MsgEditorUtils panics + +// IP min length comes from 0.0.0.0 --> 7 +const TInt KIPMinLength = 7; +// IP max lenght comes from 255.255.255.255 --> 15 +const TInt KIPMaxLength = 15; +const TInt KMinDelimitedValue = 0; +const TInt KMaxDelimitedValue = 255; +const TInt KDigitMaxLength = 3; + +#ifdef _DEBUG +_LIT(KMsgBioUtils,"MsgBioUtils"); +#endif + +// ================= MEMBER FUNCTIONS ======================= + +// leaves if user cancels query +EXPORT_C void MsgBioUtils::TextQueryL(TInt aQueryResource, TDes& aText) + { + CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog(aText,CAknQueryDialog::ENoTone); + if (dlg->ExecuteLD(aQueryResource)) //R_DATA_QUERY + { + // query approved + return; + } + // query was cancelled + User::Leave(KLeaveWithoutAlert); + } + +EXPORT_C void MsgBioUtils::ErrorNoteL(const TDesC& aText) + { + CAknErrorNote* note = new(ELeave)CAknErrorNote( ETrue ); + note->ExecuteLD(aText); + } + +EXPORT_C void MsgBioUtils::ErrorNoteL(TInt aStringResource) + { + HBufC* buf = StringLoader::LoadLC(aStringResource); + ErrorNoteL(*buf); + CleanupStack::PopAndDestroy(buf); + } + +EXPORT_C void MsgBioUtils::ConfirmationNoteL(const TDesC& aText) + { + CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote; + note->ExecuteLD(aText); + } + +EXPORT_C void MsgBioUtils::ConfirmationNoteL(TInt aStringResource) + { + HBufC* buf = StringLoader::LoadLC(aStringResource); + ConfirmationNoteL(*buf); + CleanupStack::PopAndDestroy(buf); + } + +EXPORT_C void MsgBioUtils::InformationNoteL(const TDesC& aText) + { + CAknInformationNote* note = new (ELeave) CAknInformationNote; + note->ExecuteLD(aText); + } + +EXPORT_C void MsgBioUtils::InformationNoteL(TInt aStringResource) + { + HBufC* buf = StringLoader::LoadLC(aStringResource); + InformationNoteL(*buf); + CleanupStack::PopAndDestroy(buf); + } + + +EXPORT_C void MsgBioUtils::IncrementNameL(TDes& aName, TInt aMaxLength) + { + TInt length = aName.Length(); + + // If this fails it means that at least default name should have been assigned + // to item. + __ASSERT_ALWAYS(length > 0, Panic(EMEUNameEmpty)); + TInt newOrdinal = 0; + TInt index = length-1; + TInt charValue = aName[index]; + + // Check if name ends with ')' + if (charValue == ')') + { + TBool cutBetweenIndexes = EFalse; + index--; + TInt multi = 1; + while ( index >= 0) + { + charValue = aName[index]; + TChar ch(charValue); + + if (!ch.IsDigit()) + { + // There was non-digits inside the brackets. + if ( charValue == '(') + { + // We found the start + cutBetweenIndexes = ETrue; + index--; + break; + } + else + { + // There was a non-digit inside the '(' and ')' + // We just append after the original name. + break; + } + } // if + else + { + TInt newNum = ch.GetNumericValue(); + if (multi <= 100000000) + { + // If there's a pattern (007) then this makes it to be (007)(01) + if (newNum == 0 && newOrdinal != 0 && multi > 10) + { + break; + } + newOrdinal += newNum * multi; + multi*=10; + }//0010 + else + { + newOrdinal = 0; + break; + } + } + index--; + } // while + + // There was correct pattern of (0000) so now we delete it. + if (cutBetweenIndexes) + { + aName.Delete(index+1, length-index); + } + else + { + // This case is for example 12345) so we get 12345)(01) + newOrdinal = 0; + } + } // if + + // Add one to the ordinal read from the old name + newOrdinal++; + + // Check that there's enough space to add the ordinal + TInt maxLength = aMaxLength; + TInt ordinalSpace(4); // Ordinal space comes from (00) so it's 4 + length = aName.Length(); + if (length + ordinalSpace > maxLength) + { + aName.Delete(maxLength-ordinalSpace, ordinalSpace); + } + + // Append the ordinal at the end of the name + HBufC* old = aName.AllocLC(); + + _LIT(KFormatSpecLessTen, "%S(0%d)"); + _LIT(KFormatSpecOverTen, "%S(%d)"); + if (newOrdinal < 10) + { + aName.Format(KFormatSpecLessTen, old, newOrdinal); + } + else + { + aName.Format(KFormatSpecOverTen, old, newOrdinal); + } + CleanupStack::PopAndDestroy(old); // old + } + +EXPORT_C TBool MsgBioUtils::CheckIP( const TDesC& aIP ) + { + TInt length( aIP.Length() ); + + // Check that ip length is correct. + if ( !(length >= KIPMinLength && length <= KIPMaxLength) ) + { + return EFalse; + } + + TChar token('.'); + const TInt KNumberOfTokenizedValues = 4; + + TInt startIndex( -1 ); // startIndex is advanced in loop to point to next char. + for ( TInt i = 0; i < KNumberOfTokenizedValues; i++ ) + { + TInt value(0); + + // Advance the startIndex to point to the next character. + startIndex++; + if ( startIndex < length ) + { + TBool hasNumValue = GetTokenizedValue( aIP, token, startIndex, value ); + if ( !hasNumValue ) + { + return EFalse; + } + // Set the value to the correct variable + switch ( i ) + { + case 0: + { + + break; + } + case 1: + { + + break; + } + case 2: + { + + break; + } + case 3: + { + + break; + } + default: + { + // Check that your KNumberOfTokenizedValues is correct + // and add cases to this switch clause. + User::Invariant(); + break; + } + } + } + else + { + // too short IP string + return EFalse; + } + } + + // At this point we've extracted four Tokenized values from the + // ip string. + if ( startIndex < length ) + { + // too long IP string + return EFalse; + } + + /// do any consistency checks here. + return ETrue; + } + +EXPORT_C TBool MsgBioUtils::CheckURL( const TDesC& aUrl ) + { + TUriParser16 uriParser; + TInt err = uriParser.Parse( aUrl ); + if ( err == KErrNone ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +EXPORT_C TBool MsgBioUtils::ConfirmationQueryOkCancelL(const TDesC& aText) + { + //This temporary descriptor is needed because the query wants a non const + HBufC* text = aText.AllocL(); + CleanupStack::PushL(text); + CAknQueryDialog* qDlg = new (ELeave) CAknQueryDialog(*text); + TInt response = + qDlg->ExecuteLD(R_MSGEDITORUTILS_GENERAL_CONFIRMATION_QUERY_OK_CANCEL); + CleanupStack::PopAndDestroy( text ); + if (response) + { + return ETrue; + } + return EFalse; + } + +EXPORT_C TBool MsgBioUtils::ConfirmationQueryOkCancelL(TInt aStringResource) + { + HBufC* buf = StringLoader::LoadLC(aStringResource); + TBool result = ConfirmationQueryOkCancelL(*buf); + CleanupStack::PopAndDestroy(buf); + return result; + } + +TBool MsgBioUtils::GetTokenizedValue( const TDesC& aIP, + const TChar atoken, + TInt& aStartIndex, + TInt& aValue ) + { + TInt length(aIP.Length()); + __ASSERT_DEBUG( aStartIndex >= 0, User::Panic(KMsgBioUtils, KErrUnderflow ) ); + __ASSERT_DEBUG( aStartIndex < length, User::Panic(KMsgBioUtils, KErrOverflow ) ); + + aValue = 0; + TBool hasValue(EFalse); + TInt rounds(0); + while ( aStartIndex < length ) + { + rounds++; + if ( rounds > KDigitMaxLength + 1 ) // +1 comes from the dot (255. -> count is 4 ) + { + return EFalse; + } + TChar character = aIP[aStartIndex]; + if ( character.IsDigit() ) + { + hasValue = ETrue; + aValue*=10; + TInt lastDigit = character.GetNumericValue(); + aValue+=lastDigit; + + // Do the limit check for value. + if ( aValue < KMinDelimitedValue || aValue > KMaxDelimitedValue ) + { + return EFalse; + } + } + else + { + // Check if it's dot + if ( character == atoken ) + { + return hasValue; + } + else // not valid + { + return EFalse; + } + } + aStartIndex++; + } + return hasValue; // Check that we had something. + } + +// End of File