/*
* 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 <AknQueryDialog.h> // CAknTextQueryDialog
#include <aknnotewrappers.h>
#include <StringLoader.h> // StringLoader
#include "MsgBioUtils.h" // Own header
#include <uri16.h> // TUriParser8
#include <MsgEditorUtils.rsg> // 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