omads/omadsappui/AspSyncUtil/src/AspDialogUtil.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Fri, 19 Feb 2010 22:40:37 +0200
branchRCL_3
changeset 8 ad0f53516d84
parent 0 dab8a81a92de
permissions -rw-r--r--
Revision: 201003 Kit: 201007

/*
* Copyright (c) 2005 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:  
*
*/


// INCLUDE FILES

#include "AspDialogUtil.h"
#include "AspUtil.h"
#include "AspSchedule.h"
#include <aspsyncutil.mbg>  // for bitmap enumerations

#include <aknnavilabel.h>
#include <akntitle.h>           // CAknTitlePane
#include <akncontext.h>         // CAknTitlePane
#include <aknnotewrappers.h>    // CAknInformationNote
#include <eikmenup.h>           // CEikMenuPane
#include <aknlists.h>           // CAknSingleHeadingPopupMenuStyleListBox

#include <aknmfnesettingpage.h>         // CAknDateSettingPage
#include <aknradiobuttonsettingpage.h>  // CAknRadioButtonSettingPage
#include <akntextsettingpage.h>         // CAknIntegerSettingPage
#include <aknmessagequerydialog.h>      // CAknMessageQueryDialog
#include <AknIndicatorContainer.h>

#include <AknIconArray.h>   // for GulArray
#include <gulicon.h>

#include "AspSettingDialog.h"
// ============================ MEMBER FUNCTIONS ===============================




/*******************************************************************************
 * class TDialogUtil
 *******************************************************************************/


//------------------------------------------------------------------------------
// TDialogUtil::ShowTextQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowTextQueryL(const TDesC& aTitle, TDes& aText, TInt aMaxLength)
	{
	CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aText);
	CleanupStack::PushL(query);
	query->SetPromptL(aTitle);
	if (aMaxLength > 0)
		{
		query->SetMaxLength(aMaxLength);
		}
    CleanupStack::Pop(query);		

	query->ExecuteLD(R_ASP_TEXT_QUERY);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowMessageQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowMessageQueryL(const TDesC& aTitle, const TDesC& aText)
	{
	TPtrC ptr = aText;
	CAknMessageQueryDialog* query = CAknMessageQueryDialog::NewL(ptr);
	query->PrepareLC(R_ASP_MESSAGE_QUERY);
	_LIT(KEmpty, " ");
	if (aTitle.Compare(KEmpty) != 0 )
		{
		CAknPopupHeadingPane* headingPane = query->Heading();
		headingPane->SetTextL(aTitle);
		}
	query->RunLD();
	}

//------------------------------------------------------------------------------
// TDialogUtil::ShowAutoSyncMessageQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowAutoSyncMessageQueryL(const TDesC& aText)
	{
	TPtrC ptr = aText;
	HBufC* hBuf = CAspResHandler::ReadLC(R_ASP_MAIN_AUTO_ERROR_LOG_LINK);
	CAknMessageQueryDialog* query = CAknMessageQueryDialog::NewL(ptr);
	CleanupStack::PushL(query);

	TCallBack LogView(TDialogUtil::ShowAutoSyncLogL);
	query->SetLink(LogView);
    query->SetLinkTextL(hBuf->Des());
	
	//CAknPopupHeadingPane* headingPane = query->Heading();
	//headingPane->SetTextL(aTitle);

	CleanupStack::Pop(query);
	query->ExecuteLD(R_ASP_MESSAGE_QUERY);

	CleanupStack::PopAndDestroy(hBuf);
	}

//------------------------------------------------------------------------------
// TDialogUtil::ShowMessageQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowMessageQueryL(const TDesC& aTitle, TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
	ShowMessageQueryL(aTitle, hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}

	
//------------------------------------------------------------------------------
// TDialogUtil::ShowConfirmationQueryL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowConfirmationQueryL(const TDesC& aText)
	{
	CAknQueryDialog* queryDialog = new (ELeave) CAknQueryDialog;
	TBool ret = queryDialog->ExecuteLD(R_ASP_CONFIRMATION_QUERY, aText);
	return ret;
	}

//------------------------------------------------------------------------------
// TDialogUtil::ShowRoamingConfirmationQueryL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowRoamingConfirmationQueryL(const TDesC& aText)
    {
    CAknQueryDialog* queryDialog = new (ELeave) CAknQueryDialog;
    TBool ret = queryDialog->ExecuteLD(R_ASP_ROAMING_CONFIRMATION_QUERY, aText);
    return ret;
    }

//------------------------------------------------------------------------------
// TDialogUtil::ShowRoamingConfirmationQueryL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowRoamingConfirmationQueryL(TInt aResource)
    {
    HBufC* hBuf = CAspResHandler::ReadLC(aResource);
    TBool ret = ShowRoamingConfirmationQueryL(hBuf->Des());
    CleanupStack::PopAndDestroy(hBuf);
    return ret;
    }


//------------------------------------------------------------------------------
// TDialogUtil::ShowConfirmationQueryL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowConfirmationQueryL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
	TBool ret = ShowConfirmationQueryL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	return ret;
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowInformationQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowInformationQueryL(const TDesC& aText)
	{
	CAknQueryDialog* queryDialog = new (ELeave) CAknQueryDialog;
	queryDialog->ExecuteLD(R_ASP_INFORMATION_QUERY, aText);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowInformationQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowInformationQueryL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
	ShowInformationQueryL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowInformationNoteL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowInformationNoteL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
    ShowInformationNoteL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowInformationNoteL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowInformationNoteL(const TDesC& aText)
	{
	CAknInformationNote* queryDialog = new (ELeave) CAknInformationNote(ETrue);
	queryDialog->ExecuteLD(aText);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowErrorNoteL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowErrorNoteL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
	ShowErrorNoteL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowErrorNoteL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowErrorNoteL(const TDesC& aText)
	{
	CAknErrorNote* errorNote = new (ELeave) CAknErrorNote(ETrue);
	errorNote->ExecuteLD(aText);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowErrorQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowErrorQueryL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
	ShowErrorQueryL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowErrorQueryL
//
//------------------------------------------------------------------------------
//
void TDialogUtil::ShowErrorQueryL(const TDesC& aText)
	{
	CAknQueryDialog* queryDialog = new (ELeave) CAknQueryDialog;
	queryDialog->ExecuteLD(R_ASP_ERROR_QUERY, aText);
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ShowListQueryL
// 
// -----------------------------------------------------------------------------
TBool TDialogUtil::ShowListQueryL(const TDesC& aTitle, CDesCArray* aList, TInt* aSelectedIndex)
	{
	CAknListQueryDialog* query = new (ELeave) CAknListQueryDialog(aSelectedIndex);
	CleanupStack::PushL(query);

	query->PrepareLC(R_ASP_LIST_QUERY);
	query->SetItemTextArray(aList);
	query->SetOwnershipType(ELbmDoesNotOwnItemArray);
	CAknPopupHeadingPane* headingPane = query->QueryHeading();
	headingPane->SetTextL(aTitle);
	
	CleanupStack::Pop(query);

	return query->RunLD();
	}

//------------------------------------------------------------------------------
// TDialogUtil::ShowListQueryIconL
//
//------------------------------------------------------------------------------
TBool TDialogUtil::ShowListQueryIconL(const TDesC& aTitle, CDesCArray* aList, TInt* aSelectedIndex)
	{
	  
	 CAknListQueryDialog* query = new (ELeave) CAknListQueryDialog(aSelectedIndex);
	 CleanupStack::PushL(query);
	 query->PrepareLC(R_ASP_LIST_APP_QUERY);
	 
	 
	 query->SetItemTextArray(aList);
	 query->SetOwnershipType(ELbmOwnsItemArray);
	 
	 CArrayPtr<CGulIcon>* iconList = new (ELeave) CAknIconArray(1);
	 CleanupStack::PushL(iconList);
	 
 	 TFileName bitmapName;
 	 CAspResHandler::GetBitmapFileName(bitmapName);
 	 //renders Qgn_Prop_Sml_New icon
	 iconList->AppendL(CreateIconL(KAknsIIDQgnPropSmlNew, bitmapName, 
	                     EMbmAspsyncutilQgn_prop_sml_new,
	                     EMbmAspsyncutilQgn_prop_sml_new_mask) );
	 query->SetIconArrayL(iconList);
	 CAknPopupHeadingPane* headingPane = query->QueryHeading();
 	 headingPane->SetTextL(aTitle);
 	  
	 CleanupStack::Pop(iconList);
	 CleanupStack::Pop(query);
	 return query->RunLD();
	}

// -----------------------------------------------------------------------------
// TDialogUtil::ShowListQueryL
// 
// -----------------------------------------------------------------------------
TBool TDialogUtil::ShowListQueryL(TInt aTitle, CDesCArray* aList, TInt* aSelectedIndex)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aTitle);

    TBool ret = ShowListQueryL(hBuf->Des(), aList, aSelectedIndex);
   	CleanupStack::PopAndDestroy(hBuf);
   	
   	return ret;
	}

//------------------------------------------------------------------------------
//TDialogUtil::ShowListQueryIconL
//
//------------------------------------------------------------------------------
TBool TDialogUtil::ShowListQueryIconL(TInt aTitle, CDesCArray* aList, TInt* aSelectedIndex)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aTitle);

    TBool ret = ShowListQueryIconL(hBuf->Des(), aList, aSelectedIndex);
   	CleanupStack::PopAndDestroy(hBuf);
   	
   	return ret;
	}
// -----------------------------------------------------------------------------
// TDialogUtil::ShowProfileQueryL
// 
// -----------------------------------------------------------------------------
TBool TDialogUtil::ShowProfileQueryL(CAspProfileList* aList, TInt& aId, TInt aResource)
	{
	aId = KErrNotFound;
	
	CDesCArray* arr = new (ELeave) CDesCArrayFlat(KDefaultArraySize);
	CleanupStack::PushL(arr);

	TInt count = aList->Count();
	for (TInt i=0; i<count; i++)
		{
		TAspProfileItem& profile = aList->Item(i);
		arr->AppendL(profile.iProfileName);
		}

    TInt index=KErrNotFound;
	TBool ret = ShowListQueryL(aResource, arr, &index);
	
	if (ret)
		{
	    TAspProfileItem& profile = aList->Item(index);
	    aId = profile.iProfileId;
		}

	CleanupStack::PopAndDestroy(arr);
	return ret;
	}
//------------------------------------------------------------------------------
//TDialogUtil::ShowProfileQueryAppL
//
//-----------------------------------------------------------------------------

TBool TDialogUtil::ShowProfileQueryAppL(CAspProfileList* aList, TInt& aId, TInt aResource,TInt &index1)
{
	aId = KErrNotFound;
	
	CDesCArray* arr = new (ELeave) CDesCArrayFlat(KDefaultArraySize);
	CleanupStack::PushL(arr);
      
    
	HBufC* hBuf = CAspResHandler::ReadLC(R_ASP_SELECT_PROFILE_CREATE_NEW);
    TPtr ptr = hBuf->Des();
  
    //"%d\t%S" for formatting the icon and text data in the query dialog 
   	 _LIT(KListItemFormat,"%d\t%S");
	 TBuf<KBufSize> item;
     item.Format(KListItemFormat,0 , &ptr);
	 arr->AppendL(item);
   	 CleanupStack::PopAndDestroy(hBuf);
       
    
	 TInt count = aList->Count();
	 for (TInt i=0; i< count; i++)
		{
		TAspProfileItem& profile = aList->Item(i);
		//"\t%S" no need of keeping icon for profile list
		_LIT(KListItemFormat,"\t%S");
		HBufC* hBuf1=TUtil::StrConversion(profile.iProfileName);
		TPtr ptr1=hBuf1->Des();
		item.Format(KListItemFormat,&ptr1);
		CleanupStack::PopAndDestroy(hBuf1);
	    arr->AppendL(item);
		}
		
	
	TInt index=KErrNotFound;
	TBool ret = ShowListQueryIconL(aResource, arr, &index);

	if (ret)
		{
		
		  if(index==0) //to check if R_ASP_SELECT_PROFILE_CREATE_NEW is selected
				{
	   				 ret=EFalse;
	   				 index1=1;
	    			 CleanupStack::Pop(arr);
					 return ret;
				}
		
	    TAspProfileItem& profile = aList->Item(index-1);
	    aId = profile.iProfileId;
	    
		}

	CleanupStack::Pop(arr);
	return ret;
}


// -----------------------------------------------------------------------------
// TDialogUtil::DeleteMenuItem
//
// -----------------------------------------------------------------------------
//
void TDialogUtil::DeleteMenuItem(CEikMenuPane* aMenuPane, TInt aCommandId)
	{
	TInt pos=KErrNotFound;
    if (aMenuPane->MenuItemExists(aCommandId, pos))
		{
		aMenuPane->DeleteMenuItem(aCommandId);
		}
	}


// -----------------------------------------------------------------------------
// TDialogUtil::CreateIconL
//
// Constructs an independent CGulIcon object with fallback support.
// If no matching item (aId) is found in the currently active skin,
// attempts to construct the item using the given file (last 3 parameters).
// -----------------------------------------------------------------------------
//
CGulIcon* TDialogUtil::CreateIconL(TAknsItemID aId, const TDesC& aFileName, TInt aFileBitmapId, TInt aFileMaskId)
	{
    CGulIcon* icon = AknsUtils::CreateGulIconL(AknsUtils::SkinInstance(), aId, aFileName, aFileBitmapId, aFileMaskId);
	return icon;
	}


// -----------------------------------------------------------------------------
// TDialogUtil::CreateImageL
//
// -----------------------------------------------------------------------------
//
CEikImage* TDialogUtil::CreateImageLC(TAknsItemID aId, const TDesC& aFileName, TInt aFileBitmapId, TInt aFileMaskId)
	{
	CFbsBitmap* bitmap1 = NULL;
	CFbsBitmap* bitmap2 = NULL;
	
	CEikImage* image = new (ELeave) CEikImage;
	CleanupStack::PushL(image);

	AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), aId, bitmap1, bitmap2, aFileName, aFileBitmapId, aFileMaskId);
	image->SetPicture(bitmap1, bitmap2);
	CleanupStack::Pop(2); // bitmap1 bitmap2

	return image;
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ConstructListBoxItemL
//
// -----------------------------------------------------------------------------
//
HBufC* TDialogUtil::ConstructListBoxItemLC(const TDesC& aFirstLine, const TDesC& aSecondLine, TInt /*aIndex*/)
	{
    _LIT(KFormat, "%d\t%S\t%S");
	
	TInt len = aFirstLine.Length() + aSecondLine.Length() + KBufSize16;
	
	HBufC* hBuf = HBufC::NewLC(len);
	TPtr ptr = hBuf->Des();
	
	ptr.Format(KFormat, 1, &aFirstLine, &aSecondLine);
	
	
	return hBuf;
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ShowTimeEditorL
//
// -----------------------------------------------------------------------------
//
TBool TDialogUtil::ShowTimeEditorL(TTime& aTime, const TDesC& aTitle)
	{
    CAknTimeSettingPage* dlg = new (ELeave) CAknTimeSettingPage(R_ASP_SETTING_TIME, aTime);
    
   	CleanupStack::PushL(dlg);
	dlg->ConstructL();
	dlg->SetSettingTextL(aTitle);
	CleanupStack::Pop(dlg);

    
    if (dlg->ExecuteLD(CAknSettingPage::EUpdateWhenAccepted))
        {
        return ETrue;
        }
        
    return EFalse;
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ShowDateEditorL
//
// -----------------------------------------------------------------------------
//
TBool TDialogUtil::ShowDateEditorL(TTime& aTime, const TDesC& aTitle)
	{
    CAknDateSettingPage* dlg = new (ELeave) CAknDateSettingPage(R_ASP_SETTING_DATE, aTime);
    
   	CleanupStack::PushL(dlg);
	dlg->ConstructL();
	dlg->SetSettingTextL(aTitle);
	CleanupStack::Pop(dlg);

    if (dlg->ExecuteLD(CAknSettingPage::EUpdateWhenAccepted))
        {
        return ETrue;
        }
        
    return EFalse;
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowListEditorL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowListEditorL(CDesCArray* aList, const TDesC& aTitle, TInt& aCurrent)
	{

	CAknRadioButtonSettingPage* dlg = new (ELeave) CAknRadioButtonSettingPage(
	                                       R_ASP_SETTING_RADIO, aCurrent, aList);
	CleanupStack::PushL(dlg);
	dlg->SetSettingTextL(aTitle); 
	CleanupStack::Pop(dlg);

	return dlg->ExecuteLD();
	}

//------------------------------------------------------------------------------
// TDialogUtil::ShowListEditorL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowListEditorL(TInt aResourceId, CDesCArray* aList, const TDesC& aTitle, TInt& aCurrent)
	{
	CAspRadioButtonSettingPageEditor* dlg = new (ELeave) CAspRadioButtonSettingPageEditor(
	                                       aResourceId, aCurrent, aList);
	CleanupStack::PushL(dlg);
	dlg->SetSettingTextL(aTitle); 
	CleanupStack::Pop(dlg);

	return dlg->ExecuteLD();
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowTextEditorL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowTextEditorL(TInt aResourceId, TDes& aText, const TDesC& aTitle, TBool aMandatory, TBool aLatinInput, TInt aMaxLength)
	{
	TInt flags(CAknTextSettingPage::EZeroLengthAllowed);

	if (aMandatory)
		{
		flags = CAknTextSettingPage::EZeroLengthNotOffered;
		}

	CAspTextSettingPageEditor * dlg = new (ELeave) CAspTextSettingPageEditor(aResourceId, aText, flags);
	CleanupStack::PushL(dlg);

	dlg->SetSettingTextL(aTitle); 
	dlg->ConstructL();
	dlg->TextControl()->SetTextLimit(aMaxLength);

	if (aLatinInput)
		{		
		dlg->TextControl()->SetAvkonWrap(ETrue);
		dlg->TextControl()->SetAknEditorCase(EAknEditorLowerCase);
		dlg->TextControl()->SetAknEditorFlags(EAknEditorFlagNoT9 | EAknEditorFlagLatinInputModesOnly);
		}
	
	CleanupStack::Pop(dlg);

	// CAknTextSettingPage::ExecuteLD only return boolean. See CAknSettingPage::ProcessCommandL
	// what softkey values map to ETrue and EFalse.
	TInt ret = dlg->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
	if (ret)
		{
    	return ETrue;
		}

	return EFalse;
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowTextEditorL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowTextEditorL(TDes& aText, const TDesC& aTitle, TBool aMandatory, TBool aLatinInput, TInt aMaxLength)
	{
	return ShowTextEditorL(R_ASP_SETTING_TEXT, aText, aTitle, aMandatory, aLatinInput, aMaxLength);
	}


//------------------------------------------------------------------------------
// TDialogUtil::ShowIntegerEditorL
//
//------------------------------------------------------------------------------
//
TBool TDialogUtil::ShowIntegerEditorL(TInt& aNumber, const TDesC& aTitle, TInt aMin, TInt aMax, TBool aLatinInput)
	{
	CAspIntegerSettingPageEditor* dlg = new (ELeave) CAspIntegerSettingPageEditor(
	                              R_ASP_SETTING_NUMBER, aNumber,
	                              CAknIntegerSettingPage::EInvalidValueNotOffered);
	CleanupStack::PushL(dlg);
	dlg->ConstructL();
	dlg->SetSettingTextL(aTitle);
	CleanupStack::Pop(dlg);
	
	CAknIntegerEdwin* editor = dlg->IntegerEditorControl();
	if (aMin != KErrNotFound)
		{
		editor->SetMinimumIntegerValue(aMin);
		}
	if (aMax != KErrNotFound)
		{
		editor->SetMaximumIntegerValue(aMax);
		}

	editor->SetAknEditorNumericKeymap(EAknEditorPlainNumberModeKeymap);
	
	if (aLatinInput)
		{
		editor->SetAknEditorFlags(EAknEditorFlagLatinInputModesOnly);
		editor->SetValueL(aNumber);
		}

	if (dlg->ExecuteLD(CAknIntegerSettingPage::EUpdateWhenChanged))
		{
		return ETrue;
		}

	return EFalse;
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ShowPopupDialogL
// 
// -----------------------------------------------------------------------------
void TDialogUtil::ShowPopupDialogL(const TDesC& aText, CDesCArray* aArray)
	{
	CAknSingleHeadingPopupMenuStyleListBox* listBox = new (ELeave) CAknSingleHeadingPopupMenuStyleListBox;
	CleanupStack::PushL(listBox);


	CAknPopupList* popupList = CAknPopupList::NewL(listBox, R_AVKON_SOFTKEYS_OK_EMPTY, AknPopupLayouts::EMenuWindow);
	CleanupStack::PushL(popupList);

	listBox->ConstructL(popupList, EAknListBoxViewerFlags);
	
	CDesCArray* array = (CDesCArray*) listBox->Model()->ItemTextArray();
	listBox->CreateScrollBarFrameL(ETrue); 
	listBox->ScrollBarFrame()->	SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
    
	TInt count = aArray->Count();
	for (TInt i=0; i<count; i++)
		{
		TPtrC ptr = (*aArray)[i];
		array->AppendL(ptr);
		}
	
	popupList->SetTitleL(aText);

	popupList->ExecuteLD();

	CleanupStack::Pop(popupList);
	CleanupStack::PopAndDestroy(listBox);
	}


// -----------------------------------------------------------------------------
// TDialogUtil::ShowPopupDialog2L
// 
// -----------------------------------------------------------------------------
void TDialogUtil::ShowPopupDialog2L(const TDesC& aText, CDesCArray* aArray)
	{
    CAknDoublePopupMenuStyleListBox* listBox = new(ELeave) CAknDoublePopupMenuStyleListBox;
    
    CleanupStack::PushL(listBox);

    // Avkon popup list with heading
    CAknPopupList* popupList = CAknPopupList::NewL(listBox, R_AVKON_SOFTKEYS_OK_EMPTY, AknPopupLayouts::EMenuDoubleWindow);
    CleanupStack::PushL(popupList);
    
    // Set listbox properties and create item array
    listBox->ConstructL(popupList, EAknListBoxViewerFlags);
    listBox->CreateScrollBarFrameL(ETrue);
    listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
    
   	CDesCArray* array = (CDesCArray*) listBox->Model()->ItemTextArray();
	TInt count = aArray->Count();
	for (TInt i=0; i<count; i++)
		{
		TPtrC ptr = (*aArray)[i];
		array->AppendL(ptr);
		}
    popupList->SetTitleL(aText);
    	
    popupList->ExecuteLD();

    CleanupStack::Pop(popupList);
    CleanupStack::PopAndDestroy(listBox);
	}

// -----------------------------------------------------------------------------
// TDialogUtil::ShowAutoSyncLogL
// 
// -----------------------------------------------------------------------------
TInt TDialogUtil::ShowAutoSyncLogL(TAny* /*aAny*/)
	{

	CAspSchedule* schedule = CAspSchedule::NewLC();
	TRAPD (err,schedule->ShowAutoSyncLogL());
	CleanupStack::PopAndDestroy(schedule);

	if (err == KErrNone)
		{
		return ETrue;
		}
	return EFalse;
	}

//-----------------------------------------------------------------------------
//
//Does Descriptor contain string "PC Suite"
//Its NOT case sensitive
//
//-----------------------------------------------------------------------------
TBool TDialogUtil::IsPCSuiteDesC(const TDesC& des)
{
	_LIT(KPCSuite, "pc suite");
	TPtrC pcSuitePtr(KPCSuite);
	
	TBuf<KBufSize64> buf;
	TUtil::StrCopy(buf,des);
	buf.LowerCase();
	if (buf.Match(pcSuitePtr) == 0)
	{
		return ETrue;
	}
		
	return EFalse;
}
	    		

/*******************************************************************************
 * class CAspIndicatorHandler
 *******************************************************************************/


// -----------------------------------------------------------------------------
// Destructor
//
// -----------------------------------------------------------------------------
//
CAspIndicatorHandler::~CAspIndicatorHandler()
    {
    if (iIndicator && iIndicatorContainer && iIndicatorModified)
    	{
        if (iPreviousIndicatorType == EAknNaviPaneEditorIndicatorMessageLength)
        	{
        	TRAP_IGNORE( iIndicatorContainer->SetIndicatorValueL(
                      TUid::Uid(EAknNaviPaneEditorIndicatorMessageLength), KNullDesC) );
            }

        iIndicatorContainer->SetIndicatorState(TUid::Uid(iIndicatorType), EAknIndicatorStateOff);
        }
    }


// -----------------------------------------------------------------------------
// CAspIndicatorHandler::CAspIndicatorHandler
//
// -----------------------------------------------------------------------------
//
CAspIndicatorHandler::CAspIndicatorHandler(MAknEditingStateIndicator* aIndicator) : iIndicator(aIndicator)
	{
	iIndicatorContainer = iIndicator->IndicatorContainer();
    iIndicatorModified = EFalse;
    iPreviousIndicatorType = KErrNotFound;
	}


// ----------------------------------------------------------------------------
// CAspIndicatorHandler::SetIndicatorStateL
// 
// ----------------------------------------------------------------------------
//
void CAspIndicatorHandler::SetIndicatorStateL(TInt aIndicatorType, const TDesC& aText)
	{
    if (iIndicator && iIndicatorContainer)
    	{
   	
        if (iPreviousIndicatorType == EAknNaviPaneEditorIndicatorMessageLength)
        	{
        	iIndicatorContainer->SetIndicatorValueL(
                      TUid::Uid(EAknNaviPaneEditorIndicatorMessageLength), KNullDesC);
            }

    	iIndicatorContainer->SetIndicatorState(TUid::Uid(aIndicatorType),
                                               EAknIndicatorStateOn);
                                               
        iIndicatorModified = ETrue;
        iPreviousIndicatorType = aIndicatorType;
        
                                               
        if (aIndicatorType == EAknNaviPaneEditorIndicatorMessageLength)
        	{
        	iIndicatorContainer->SetIndicatorValueL(
                                 TUid::Uid(EAknNaviPaneEditorIndicatorMessageLength), aText);
            iPreviousIndicatorType = aIndicatorType;
            }
    	}
	
	}



/*******************************************************************************
 * class CAspNaviPaneHandler
 *******************************************************************************/


// -----------------------------------------------------------------------------
// Destructor
//
// -----------------------------------------------------------------------------
//
CAspNaviPaneHandler::~CAspNaviPaneHandler()
    {
   	if (iNaviDecorator)
		{
		if (iNaviPane && iNavidecoratorPushed)
			{
			iNaviPane->Pop(iNaviDecorator);
			}
	
		delete iNaviDecorator;
		}
		
	if (iNaviPane && iNavipanePushed)
		{
		iNaviPane->Pop(); // restore previous navi pane
		}
    }


// -----------------------------------------------------------------------------
// CAspNaviPaneHandler::CAspNaviPaneHandler
//
// -----------------------------------------------------------------------------
//
CAspNaviPaneHandler::CAspNaviPaneHandler(CEikStatusPane* aStatusPane) : iStatusPane(aStatusPane)
	{
	iNavidecoratorPushed = EFalse;
	iNavipanePushed = EFalse;
	
	if (iStatusPane)
		{
		TRAP_IGNORE( iNaviPane = (CAknNavigationControlContainer*)iStatusPane->ControlL(TUid::Uid(EEikStatusPaneUidNavi)) );
		}
	}


// ----------------------------------------------------------------------------
// CAspNaviPaneHandler::SetNaviPaneTitleL
// 
// ----------------------------------------------------------------------------
//
void CAspNaviPaneHandler::SetNaviPaneTitleL(const TDesC& aTitle)
	{
	if (!iStatusPane || !iNaviPane)
		{
		return;
		}

    if (iNaviDecorator)
        {
        CAknNaviLabel* naviLabel = static_cast<CAknNaviLabel*>(iNaviDecorator->DecoratedControl());
        if (naviLabel)
        	{
        	naviLabel->SetTextL(aTitle);
        	iNaviDecorator->DrawDeferred();
        	}
        }
     else
    	{
    	iNaviDecorator = iNaviPane->CreateNavigationLabelL(aTitle);
    	iNaviPane->PushL(*iNaviDecorator); // activate navi label in navi pane
    	iNavidecoratorPushed = ETrue;
    	}
    	
    //CFbsBitmap* bitmap = NULL;
    //CFbsBitmap* bitmapMask = NULL;
    //AknsUtils::CreateIconL(AknsUtils::SkinInstance(), KAknsIIDQgnPropSmlHttp,
    //                       bitmap, bitmapMask, bitmapName,
    //                       EMbmAspsyncutilQgn_prop_sml_http, EMbmAspsyncutilQgn_prop_sml_http_mask);
    //iNaviDecorator = naviPane->CreateNavigationImageL(bitmap, bitmapMask);
    //naviPane->PushL(*iNaviDecorator);
    	
	}


// ----------------------------------------------------------------------------
// CAspNaviPaneHandler::StoreNavipaneL
// 
// ----------------------------------------------------------------------------
//
void CAspNaviPaneHandler::StoreNavipaneL()
	{
	if (!iNaviPane || !iStatusPane || iNavipanePushed)
		{
		return;
		}

	if (iStatusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent())
		{
		iNaviPane->PushDefaultL();
		iNavipanePushed = ETrue;
		}
	}

#ifdef RD_DSUI_TIMEDSYNC

/*******************************************************************************
 * class CAspTabbedNaviPaneHandler
 *******************************************************************************/


// -----------------------------------------------------------------------------
// Destructor
//
// -----------------------------------------------------------------------------
//
CAspTabbedNaviPaneHandler::~CAspTabbedNaviPaneHandler()
    {
   	if (iNaviDecorator)
		{
		if (iNaviPane && iNavidecoratorPushed)
			{
			iNaviPane->Pop(iNaviDecorator);
			}
	
		delete iNaviDecorator;
		}
		
	if (iNaviPane && iNavipanePushed)
		{
		iNaviPane->Pop(); // restore previous navi pane
		}
    }


// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::CAspTabbedNaviPaneHandler
//
// -----------------------------------------------------------------------------
//
CAspTabbedNaviPaneHandler::CAspTabbedNaviPaneHandler(CEikStatusPane* aStatusPane ,CAspSettingDialog *aDialog) 
						  : iStatusPane(aStatusPane)
	{
	iNavidecoratorPushed = EFalse;
	iNavipanePushed = EFalse;
	
	iDialog = aDialog;
	
	if (iStatusPane)
		{
		TRAP_IGNORE( iNaviPane = (CAknNavigationControlContainer*)iStatusPane->ControlL(TUid::Uid(EEikStatusPaneUidNavi)) );
		}
		
    if (iNaviPane)
        {
        TRAP_IGNORE(iNaviDecorator = iNaviPane->CreateTabGroupL(this));    
        if (iNaviDecorator)
            {
            TRAP_IGNORE(iNaviPane->PushL(*iNaviDecorator));
            iNavidecoratorPushed = ETrue;
    
            iTabGroup = static_cast<CAknTabGroup*>( iNaviDecorator->DecoratedControl() );
            }
        }
    }

// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::SetTabWidthL
//
// -----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::SetTabWidthL()
{
	
	if (iTabGroup)
	    {
	     if (iTabGroup->TabCount() == 1)
	         {
	         iTabGroup->SetTabFixedWidthL(KTabWidthWithOneTab);     	
	         }
	     else if (iTabGroup->TabCount() == 2)
	         {
	         iTabGroup->SetTabFixedWidthL(KTabWidthWithTwoLongTabs);     	
	         }
	     else
	         {
	         iTabGroup->SetTabFixedWidthL(KTabWidthWithThreeLongTabs);     		
	         }
	      }
}
// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::SetTabTextL
//
// -----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::SetTabTextL(const TDesC& aText, TInt aTabId)
	{
	if (iTabGroup)
	    {
	    iTabGroup->ReplaceTabTextL(aTabId, aText);
	    }
	}


// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::AddTabL
//
// -----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::AddTabL(const TDesC& aText, TInt aTabId)
	{
	if (iTabGroup)
	    {
	    iTabGroup->AddTabL(aTabId, aText);
	    }
	}


// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::DeleteTabsL
//
// -----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::DeleteTabsL()
	{
	if (iTabGroup)
	    {
	    TInt count = iTabGroup->TabCount();
	    for (TInt i=0; i<count; i++)
	        {
	        TInt id = iTabGroup->TabIdFromIndex(0);
	        iTabGroup->DeleteTabL(id);
	        }
	    }
	}


// -----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::SetActiveTabL
//
// -----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::SetActiveTabL(TInt aTabId)
	{
	if (iTabGroup)
	    {
	    TInt index = iTabGroup->TabIndexFromId(aTabId);
	    if (index != KErrNotFound)
	        {
	        iTabGroup->SetActiveTabById(aTabId);    
	        }
	    }
	}


// ----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::StoreNavipaneL
// 
// ----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::StoreNavipaneL()
	{
	if (!iNaviPane || !iStatusPane || iNavipanePushed)
		{
		return;
		}

	if (iStatusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent())
		{
		iNaviPane->PushDefaultL();
		iNavipanePushed = ETrue;
		}
	}

// ----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::TabIndex
// 
// ----------------------------------------------------------------------------
//
TInt CAspTabbedNaviPaneHandler::TabIndex(TInt aTabId)
	{
	return iTabGroup->TabIndexFromId(aTabId);
	}

// ----------------------------------------------------------------------------
// CAspTabbedNaviPaneHandler::TabChangedL (from MAknTabObserver)
// 
// ----------------------------------------------------------------------------
//
void CAspTabbedNaviPaneHandler::TabChangedL(TInt aIndex)
	{
	TInt profileId = iTabGroup->TabIdFromIndex(aIndex );
	iDialog->SetCurrentProfile(profileId);
	iDialog->UpdateTabsL();
	iDialog->UpdateListBoxL();
	}

#endif




/*******************************************************************************
 * class CStatusPaneHandler
 *******************************************************************************/

// -----------------------------------------------------------------------------
// CStatusPaneHandler::NewL
//
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CStatusPaneHandler* CStatusPaneHandler::NewL(CAknAppUi* aAppUi)
    {
    CStatusPaneHandler* self = new (ELeave) CStatusPaneHandler(aAppUi);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
    }


// -----------------------------------------------------------------------------
// Destructor
//
// -----------------------------------------------------------------------------
//
CStatusPaneHandler::~CStatusPaneHandler()
    {
	TRAP_IGNORE(RestoreOriginalTitleL());
	TRAP_IGNORE(RestoreOriginalImageL());
	
	delete iNaviPaneHandler;
    }


// -----------------------------------------------------------------------------
// CStatusPaneHandler::ConstructL
//
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CStatusPaneHandler::ConstructL(void)
    {
    iNaviPaneHandler = new (ELeave) CAspNaviPaneHandler(iAppUi->StatusPane());
    }


// -----------------------------------------------------------------------------
// CStatusPaneHandler::CStatusPaneHandler
//
// -----------------------------------------------------------------------------
//
CStatusPaneHandler::CStatusPaneHandler(CAknAppUi* aAppUi) : iAppUi(aAppUi)
	{
	__ASSERT_ALWAYS(iAppUi, TUtil::Panic(KErrGeneral));

	iOriginalTitleStored = EFalse;
	iOriginalTitle = KNullDesC;
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::GetTitleL
// 
// ----------------------------------------------------------------------------
//
TBool CStatusPaneHandler::GetTitleL(CAknAppUi* aAppUi, TDes& aTitle)
	{
	aTitle = KNullDesC;

	CEikStatusPane* statusPane = aAppUi->StatusPane();
    if (statusPane && statusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent())
		{
        CAknTitlePane* titlePane = static_cast<CAknTitlePane*>
            (statusPane->ControlL(TUid::Uid(EEikStatusPaneUidTitle)));
        if (titlePane->Text()) 
			{
		    TUtil::StrCopy(aTitle, *titlePane->Text());
			return ETrue;
    		}
		}

	return EFalse;
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetTitleL
// 
// ----------------------------------------------------------------------------
//
TBool CStatusPaneHandler::SetTitleL(CAknAppUi* aAppUi, const TDesC& aTitle)
	{
	CEikStatusPane* statusPane = aAppUi->StatusPane();
    if (statusPane && statusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent())
		{
        CAknTitlePane* titlePane = static_cast<CAknTitlePane*>
            (statusPane->ControlL(TUid::Uid(EEikStatusPaneUidTitle)));
        if (titlePane->Text()) 
			{
	   		titlePane->SetTextL(aTitle);
			return ETrue;
			}
		}
	return EFalse;
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetNaviPaneTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetNaviPaneTitleL(const TDesC& aTitle)
	{
	iNaviPaneHandler->SetNaviPaneTitleL(aTitle);
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetNaviPaneTitle
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetNaviPaneTitle(const TDesC& aTitle)
	{
	TRAP_IGNORE(iNaviPaneHandler->SetNaviPaneTitleL(aTitle));
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetNaviPaneTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetNaviPaneTitleL(TInt aResource)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResource);
    SetNaviPaneTitleL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::StoreNavipaneL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::StoreNavipaneL()
	{
	iNaviPaneHandler->StoreNavipaneL();
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::StoreOriginalTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::StoreOriginalTitleL()
	{
	TBool ret = GetTitleL(iAppUi, iOriginalTitle);
	
	if (ret)
		{
		iOriginalTitleStored = ETrue;
		}
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::RestoreOriginalTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::RestoreOriginalTitleL()
	{
	if (iOriginalTitleStored)
		{
		SetTitleL(iAppUi, iOriginalTitle);
		}
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetTitleL(const TDesC& aText)
	{
	if (iOriginalTitleStored)
		{
		SetTitleL(iAppUi, aText);
		}
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetTitleL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetTitleL(TInt aResourceId)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResourceId);
	SetTitleL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetNewImageL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::SetNewImageL(const TDesC& aFilename,TInt aMainId,TInt aMaskId)
	{
	__ASSERT_DEBUG(!iOriginalImage, TUtil::Panic(KErrGeneral)); // can set image only once

	CEikImage* image = new (ELeave) CEikImage;
	CleanupStack::PushL(image);
	
	image->CreatePictureFromFileL(aFilename, aMainId, aMaskId);

	iOriginalImage = SetImageL(iAppUi, image);

	if (iOriginalImage)
		{
        CleanupStack::Pop(image); // ownership transferred to context pane
		return;
		}

	CleanupStack::PopAndDestroy(image);
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::RestoreOriginalImageL
// 
// ----------------------------------------------------------------------------
//
void CStatusPaneHandler::RestoreOriginalImageL()
	{
	if (!iOriginalImage)
		{
		return; // image has not been replaced
		}

	CEikImage* image = NULL;
	TRAPD(err, image = SetImageL(iAppUi, iOriginalImage));

	if (err == KErrNone && image)
		{
		delete image; // delete our own image
		}
	else
		{
		delete iOriginalImage; // delete original image (could not restore it)
		iOriginalImage = NULL;
		}
	}


// ----------------------------------------------------------------------------
// CStatusPaneHandler::SetImageL
// 
// ----------------------------------------------------------------------------
//
CEikImage* CStatusPaneHandler::SetImageL(CAknAppUi* aAppUi, CEikImage* aIcon)
	{
	CEikStatusPane* statusPane = aAppUi->StatusPane();
    if (statusPane && statusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidContext)).IsPresent())
		{
        CAknContextPane* contextPane = static_cast<CAknContextPane*>
            (statusPane->ControlL(TUid::Uid(EEikStatusPaneUidContext)));
        if (contextPane) 
			{
	   		return contextPane->SwapPicture(aIcon);
			}
		}

	return NULL;
	}




/*******************************************************************************
 * class CAspSelectionItemList
 *******************************************************************************/


// -----------------------------------------------------------------------------
// CAspSelectionItemList::Cleanup
//
// -----------------------------------------------------------------------------
//
void CAspSelectionItemList::Cleanup(TAny* aObj)
    {
    CAspSelectionItemList* list = static_cast<CAspSelectionItemList*>(aObj);
	list->ResetAndDestroy();
	delete list;
	list = NULL;
    }


// -----------------------------------------------------------------------------
// CAspSelectionItemList::CAspSelectionItemList
//
// -----------------------------------------------------------------------------
//
CAspSelectionItemList::CAspSelectionItemList(TInt aGranularity) 
: CSelectionItemList(aGranularity)
	{
	}



/*******************************************************************************
 * class CAspListItemData
 *******************************************************************************/



//------------------------------------------------------------------------------
// CAspListItemData::NewLC
// 
//------------------------------------------------------------------------------
//
CAspListItemData* CAspListItemData::NewLC()
	{
	CAspListItemData* self = new (ELeave) CAspListItemData;
	CleanupStack::PushL( self);
	self->ConstructL();
	return self;
	}


//------------------------------------------------------------------------------
// CAspListItemData::ConstructL
//
//------------------------------------------------------------------------------
//
void CAspListItemData::ConstructL()
	{
	Init();
	
    iHeader  = HBufC::NewL(0);
	iDisplayValue = HBufC::NewL(0);
	iValue = HBufC::NewL(0);
    }


// -----------------------------------------------------------------------------
// CAspListItemData::CAspListItemData
// -----------------------------------------------------------------------------
//
CAspListItemData::CAspListItemData()
	{
	}


//------------------------------------------------------------------------------
// Destructor
//
//------------------------------------------------------------------------------
//
CAspListItemData::~CAspListItemData()
	{
	delete iHeader;
	delete iDisplayValue;
	delete iValue;
	}


//------------------------------------------------------------------------------
// CAspListItemData::Header
//
//------------------------------------------------------------------------------
//
const TDesC& CAspListItemData::Header()
	{
	__ASSERT_ALWAYS(iHeader, TUtil::Panic(KErrGeneral));
	
	return *iHeader;
    }


//------------------------------------------------------------------------------
// CAspListItemData::SetHeaderL
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetHeaderL(const TDesC& aText)
	{
	delete iHeader;
	iHeader = NULL;
	iHeader = aText.AllocL();
	}


//------------------------------------------------------------------------------
// CAspListItemData::SetHeaderL
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetHeaderL(TInt aResourceId)
	{
	HBufC* hBuf = CAspResHandler::ReadLC(aResourceId);
    SetHeaderL(hBuf->Des());
	CleanupStack::PopAndDestroy(hBuf);
	}


//------------------------------------------------------------------------------
// CAspListItemData::Value
// 
//------------------------------------------------------------------------------
//
const TDesC& CAspListItemData::Value()
	{
	__ASSERT_ALWAYS(iValue, TUtil::Panic(KErrGeneral));
	
	return *iValue;
	}


//------------------------------------------------------------------------------
// CAspListItemData::SetValue
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetValueL(const TDesC& aText)
	{
    delete iValue;
    iValue = NULL;
	iValue = aText.AllocL();
	}


//------------------------------------------------------------------------------
// CAspListItemData::SetValueL
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetValueL(TInt aNumber)
	{
	TBuf<KBufSize32> buf;
	buf.Num(aNumber);
	SetValueL(buf);
	}


//------------------------------------------------------------------------------
// CAspListItemData::SetDisplayValue
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetDisplayValueL(const TDesC& aText)
	{
	delete iDisplayValue;
	iDisplayValue = NULL;
	iDisplayValue = aText.AllocL();
    }


//------------------------------------------------------------------------------
// CAspListItemData::SetDisplayValue
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::SetDisplayValueL(TInt aResource)
	{
	delete iDisplayValue;
	iDisplayValue = NULL;
	
	iDisplayValue = StringLoader::LoadL(aResource);
	}


//------------------------------------------------------------------------------
// CAspListItemData::IsEmpty
// 
//------------------------------------------------------------------------------
//
TBool CAspListItemData::IsEmpty()
	{
	if (!iValue)
		{
		return ETrue;
		}
		
	if (TUtil::IsEmpty(iValue->Des()))
		{
		return ETrue;
		}
		
	return EFalse;
	}


//------------------------------------------------------------------------------
// CAspListItemData::ListItemTextL
//
// Constructs header and value suitable for listbox.
// List item syntax:
// "\t<header>\t\t<value>\t<mandatorychar>\t\t<readonlyicon>"
//------------------------------------------------------------------------------
//
HBufC* CAspListItemData::ListItemTextL(TBool aConvert)
	{
	_LIT(KTab, "\t");
	_LIT(KMandatoryChar, "*");
	_LIT(KReadOnlyIconIndex, "0");
	
	HBufC* hBuf = HBufC::NewL(KBufSize255);
	TPtr ptr = hBuf->Des();
	
	ptr.Append(KTab);
	ptr.Append(iHeader->Des());
	ptr.Append(KTab);
	ptr.Append(KTab);
	                                              //"PC Suite" string in Host address field and server id should be displayed as chinese
	if (IsEmpty() || iItemType == ETypeSecret || (TDialogUtil::IsPCSuiteDesC(iValue->Des()) && (iItemId == EAspHostAddress || iItemId == EAspServerId)))
		{
		ptr.Append(iDisplayValue->Des());
		}
	else
		{
		ptr.Append(iValue->Des());
		}

	ptr.Append(KTab);
	
	if (iMandatory)
		{
		ptr.Append(KMandatoryChar);
		}
	
	ptr.Append(KTab);
	ptr.Append(KTab);
	
	if (iHidden == EVisibilityReadOnly)
		{
		ptr.Append(KReadOnlyIconIndex);
		}

	if (aConvert)
		{
		AknTextUtils::DisplayTextLanguageSpecificNumberConversion(ptr);
		}

	return hBuf;
	}


//------------------------------------------------------------------------------
// CAspListItemData::Init
// 
//------------------------------------------------------------------------------
//
void CAspListItemData::Init()
	{
	iNumberData = KErrNotFound;
	iDate = 0;
	iTime = 0;
	
	iItemType = KErrNotFound;
	iHidden = EVisibilityNormal;
	iMaxLength = KBufSize;
	iResource = KErrNotFound;
	iIndex = KErrNotFound;
	iItemId = KErrNotFound;
	
	iMandatory = EFalse;
	iLatinInput = EFalse;
	
	iMinValue = KErrNotFound;
	iMaxValue = KErrNotFound;
	
	//iFilter = 0;
	iSelectKeyPressed = EFalse;
	
	iValue = NULL;
	iDisplayValue = NULL;
	iHeader = NULL;
    }


		
/*******************************************************************************
 * class CAspRadioButtonSettingPageEditor
 *******************************************************************************/


//------------------------------------------------------------------------------
// CAspRadioButtonSettingPageEditor::CAspRadioButtonSettingPage
// 
//------------------------------------------------------------------------------
//
CAspRadioButtonSettingPageEditor::CAspRadioButtonSettingPageEditor(TInt aResourceID,
                            TInt& aCurrentSelectionIndex,
                            const MDesCArray* aItemArray
                            )
                            
 : CAknRadioButtonSettingPage(aResourceID, aCurrentSelectionIndex, aItemArray)
	{
	}
	
	
// ----------------------------------------------------------------------------
// CAspRadioButtonSettingPageEditor::OfferKeyEventL
//
// ----------------------------------------------------------------------------
//
TKeyResponse CAspRadioButtonSettingPageEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent, 
                                                 TEventCode aType)
    {
		    if(EKeyEnter == aKeyEvent.iCode)
		    {
		    	ProcessCommandL(EAknSoftkeyOk);
		    	return EKeyWasConsumed;
		    }
		    return CAknRadioButtonSettingPage::OfferKeyEventL(aKeyEvent, aType);
    }

//------------------------------------------------------------------------------
// Destructor
// 
//------------------------------------------------------------------------------
//
CAspRadioButtonSettingPageEditor::~CAspRadioButtonSettingPageEditor()
	{
	}

		
/*******************************************************************************
 * class CAspTextSettingPageEditor
 *******************************************************************************/


//------------------------------------------------------------------------------
// CAspTextSettingPageEditor::CAspTextSettingPageEditor
// 
//------------------------------------------------------------------------------
//
CAspTextSettingPageEditor::CAspTextSettingPageEditor(TInt aResourceID, 
                                                     TDes& aText, 
                                                     TInt aTextSettingPageFlags)                      
 : CAknTextSettingPage(aResourceID, aText, aTextSettingPageFlags)
	{
	}
	
	
// ----------------------------------------------------------------------------
// CAspTextSettingPageEditor::OfferKeyEventL
//
// ----------------------------------------------------------------------------
//
TKeyResponse CAspTextSettingPageEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent, 
                                                 TEventCode aType)
    {
		    if(EKeyEnter == aKeyEvent.iCode)
		    {
		    	ProcessCommandL(EAknSoftkeyOk);
		    	return EKeyWasConsumed;
		    }
		    return CAknTextSettingPage::OfferKeyEventL(aKeyEvent, aType);
    }

//------------------------------------------------------------------------------
// Destructor
// 
//------------------------------------------------------------------------------
//
CAspTextSettingPageEditor::~CAspTextSettingPageEditor()
	{
	}

		
/*******************************************************************************
 * class CAspAlphaPasswordSettingPageEditor
 *******************************************************************************/


//------------------------------------------------------------------------------
// CAspAlphaPasswordSettingPageEditor::CAspAlphaPasswordSettingPageEditor
// 
//------------------------------------------------------------------------------
//
CAspAlphaPasswordSettingPageEditor::CAspAlphaPasswordSettingPageEditor(TInt aResourceID, 
                                                     TDes& aNewPassword, 
                                                     const TDesC& aOldPassword)                      
 : CAknAlphaPasswordSettingPage(aResourceID,aNewPassword,aOldPassword)
	{
	}
	
	
// ----------------------------------------------------------------------------
// CAspAlphaPasswordSettingPageEditor::OfferKeyEventL
//
// ----------------------------------------------------------------------------
//
TKeyResponse CAspAlphaPasswordSettingPageEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent, 
                                                 TEventCode aType)
    {
		    if(EKeyEnter == aKeyEvent.iCode)
		    {
		    	ProcessCommandL(EAknSoftkeyOk);
		    	return EKeyWasConsumed;
		    }
		    return CAknAlphaPasswordSettingPage::OfferKeyEventL(aKeyEvent, aType);
    }

//------------------------------------------------------------------------------
// Destructor
// 
//------------------------------------------------------------------------------
//
CAspAlphaPasswordSettingPageEditor::~CAspAlphaPasswordSettingPageEditor()
	{
	}

/*******************************************************************************
 * class CAspIntegerSettingPageEditor
 *******************************************************************************/


//------------------------------------------------------------------------------
// CAspIntegerSettingPageEditor::CAspIntegerSettingPageEditor
// 
//------------------------------------------------------------------------------
//
CAspIntegerSettingPageEditor::CAspIntegerSettingPageEditor(TInt aResourceID, 
												TInt& aValue, 
												TInt aTextSettingPageFlags)
 : CAknIntegerSettingPage(aResourceID,aValue,aTextSettingPageFlags)
	{
	}
	
	
// ----------------------------------------------------------------------------
// CAspIntegerSettingPageEditor::OfferKeyEventL
//
// ----------------------------------------------------------------------------
//
TKeyResponse CAspIntegerSettingPageEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent, 
                                                 TEventCode aType)
    {
		    if(EKeyEnter == aKeyEvent.iCode)
		    {
		    	ProcessCommandL(EAknSoftkeyOk);
		    	return EKeyWasConsumed;
		    }
		    return CAknIntegerSettingPage::OfferKeyEventL(aKeyEvent, aType);
    }

//------------------------------------------------------------------------------
// Destructor
// 
//------------------------------------------------------------------------------
//
CAspIntegerSettingPageEditor::~CAspIntegerSettingPageEditor()
	{
	}


//  End of File