/*

* Copyright (c) 2008 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:  Username and password multiline data query

*

*/

// INCLUDE FILES

#include <IMPSConnectionUiNG.rsg>

#include  "ccnouiusernameandpwdquery.h"

#include  "CnUiIMPSIdValidator.h"

#include  "MCnUiUiFacade.h"

#include <barsread.h>

#include <eikcapc.h>

#include <LayoutMetaData.cdl.h>

#include <stringloader.h>

#include <browserlauncher.h>

#include <aknmessagequerydialog.h>

#include 	"VariantKeys.h"

#include <CentralRepository.h>

#include 	"CnUiResourceFileName.h"

#include "orangeim.hrh"

#include "impswapreguiddefs.h"

#include "CIMPSSharedDataFactory.h"

#include "MIMPSSharedData.h"

#include "IMPSPresenceConnectionUiConstsNG.h"

//Max length of WAP registration URL

#define KMaxRegUrlLength 20

// ================= MEMBER FUNCTIONS =======================

CCnOUiUsernameAndPwdQuery* CCnOUiUsernameAndPwdQuery::NewL( TDes&  aUserName,

                                                            TDes&  aPwd,

                                                            TCnUiLoginDataQueryMode aMode,

                                                            TBool aDomainSelectionQueryVariation,

                                                            MCnUiUiFacade& aUiFacade )

    {

    TInitialFocus focus;

    TBool cursorToBeginning = EFalse;

    switch ( aMode )

        {

        case ECnUiReEdit:

            {

            //in re-edit focus always the user name field

            focus = EFirstLine;

            break;

            }

        case ECnUiNormal:

            {

            // detect which line to focus

            focus = DetectLineToFocus( aUserName, aPwd );

            break;

            }

        case ECnUiEditPrefilledUser:

            {

            // detect which line to focus

            focus = EFirstLine;

            cursorToBeginning = ETrue;

            break;

            }

        default:

            {

            focus = EFirstLine;

            break;

            }

        }

    CCnOUiUsernameAndPwdQuery* self =

        new ( ELeave ) CCnOUiUsernameAndPwdQuery( focus,

                                                  aUiFacade,

                                                  aDomainSelectionQueryVariation,

                                                  cursorToBeginning );

    CleanupStack::PushL( self );

    self->SetDataL( aUserName, aPwd );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

CCnOUiUsernameAndPwdQuery::CCnOUiUsernameAndPwdQuery( TInitialFocus aInitialFocus,

                                                      MCnUiUiFacade& aUiFacade,

                                                      TBool aDomainSelectionQueryVariation,

                                                      TBool aCursorToBeginning /* = EFalse */ )

        : CAknMultiLineDataQueryDialog( ENoTone ),

        iInitialFocus( aInitialFocus ),

        iCursorToBeginning( aCursorToBeginning ),

        iUiFacade( aUiFacade ),

        iDomainSelectionQueryVariation( aDomainSelectionQueryVariation ),

        iForcedExit( EFalse )

    {

    }

//ConstructL

void CCnOUiUsernameAndPwdQuery::ConstructL()

    {

    iSharedData = CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL( NULL, KBrandingUid );

    }

// Destructor

CCnOUiUsernameAndPwdQuery::~CCnOUiUsernameAndPwdQuery()

    {

    iRFs.Close();

    delete iBrLauncher;

    delete iSharedData;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::SetInitialCurrentLine()

//

// From CEikDialog

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::SetInitialCurrentLine()

    {

    //if initial line can't be set,

    //the error can be only ignored

    TInt ignore;

    TRAP( ignore, DoSetInitialCurrentLineL() );

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::UpdateLeftSoftKeyL()

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::UpdateLeftSoftKeyL()

    {

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::ProcessCommandL()

// From CAknDialog

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::ProcessCommandL( TInt aCommandId )

    {

    switch ( aCommandId )

        {

        case ERegister:

            {

            HideMenu();

            if ( ShowTAndCDlgL() == EAknSoftkeyOk )

                {

                // Get pointer to WAP registration settings

                CRepository* cenRep = CRepository::NewLC( KCRUidIMPSConnUI );

                HBufC16 *url = HBufC::NewLC( KMaxRegUrlLength );

                TPtr ptr( url->Des() );

                TInt urlLength;

                if ( cenRep->Get( KWAPRegistrationURL, ptr, urlLength ) == KErrOverflow )

                    {

                    //because there could be an overflow

                    CleanupStack::PopAndDestroy( url );

                    url = HBufC::NewLC( urlLength );

                    ptr.Set( url->Des() );

                    User::LeaveIfError( cenRep->Get( KWAPRegistrationURL, ptr, urlLength ) );

                    }

                OpenWebBrowserL( *url );

                CleanupStack::PopAndDestroy( url );

                CleanupStack::PopAndDestroy( cenRep );

                }

            break;

            }

        case EAknSoftkeyOk:

            {

            TryExitL( aCommandId );

            break;

            }

        default:

            {

            CAknMultiLineDataQueryDialog::ProcessCommandL( aCommandId );

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::ShowTAndCDlgL()

// Shows Terms and conditions

// -----------------------------------------------------------------------------

//

TInt CCnOUiUsernameAndPwdQuery::ShowTAndCDlgL()

    {

    CAknMessageQueryDialog* msgQueryDlg = new( ELeave )CAknMessageQueryDialog( CAknMessageQueryDialog::ENoTone );

    CleanupStack::PushL( msgQueryDlg );

    msgQueryDlg->PrepareLC( R_MESSAGE_QUERY );

    HBufC* resourceText = NULL;

    resourceText = StringLoader::LoadLC( R_QTN_IM_AGREE_LSK_REGISTER );

    msgQueryDlg->ButtonGroupContainer().SetCommandL( 0, EAknSoftkeyOk, *resourceText );

    CleanupStack::PopAndDestroy( resourceText );

    resourceText = StringLoader::LoadLC( R_QTN_IM_REFUSE_RSK_REGISTER );

    msgQueryDlg->ButtonGroupContainer().SetCommandL( 2, EAknSoftkeyCancel, *resourceText );

    CleanupStack::PopAndDestroy( resourceText );

    resourceText = StringLoader::LoadL( R_QTN_NOTE_TERMS_WAP_ORANGE );

    msgQueryDlg->SetMessageText( *resourceText );

    resourceText = StringLoader::LoadL( R_QTN_NOTE_TITLE_TERMS_WAP_ORANGE );

    msgQueryDlg->SetHeaderText( *resourceText );

    CleanupStack::Pop( msgQueryDlg );

    TInt command = msgQueryDlg->RunLD();

    return command;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::OpenWebBrowserL()

// Opens native browser for specified URL

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::OpenWebBrowserL( const TDesC& aUrl )

    {

    if ( !iBrLauncher )

        {

        iBrLauncher = CBrowserLauncher::NewL();

        }

    //Asynchronous operation to launch the browser with aUrl

    iBrLauncher->LaunchBrowserEmbeddedL( aUrl );

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::DynInitMenuPaneL()

// From CAknDialog

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    CAknMultiLineDataQueryDialog::DynInitMenuPaneL( aResourceId, aMenuPane );

    switch ( aResourceId )

        {

        case R_AVKON_MENUPANE_LANGUAGE_DEFAULT:

            {

            if ( CanSignOnL() )

                {

                CEikMenuPaneItem::SData signOn;

                signOn.iCommandId = EAknSoftkeyOk;

                signOn.iCascadeId = 0;

                HBufC* lsk = NULL;

                lsk = StringLoader::LoadLC( R_QTN_IM_REGISTER_SIGN_OPTION );

                signOn.iText.Copy( *lsk );

                aMenuPane->AddMenuItemL( signOn );

                CleanupStack::PopAndDestroy( lsk );

                lsk = NULL;

                }

            CEikMenuPaneItem::SData registeration;

            registeration.iCommandId = ERegister;

            registeration.iCascadeId = 0;

            HBufC* rsk = NULL;

            rsk = StringLoader::LoadLC( R_QTN_IM_REGISTER_LOGIN_OPTION );

            registeration.iText.Copy( *rsk );

            CleanupStack::PopAndDestroy( rsk );

            rsk = NULL;

            aMenuPane->AddMenuItemL( registeration );

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::CanSignOnL()

// From CAknDialog

// -----------------------------------------------------------------------------

//

TBool CCnOUiUsernameAndPwdQuery::CanSignOnL()

    {

    CAknMultilineQueryControl* first =

        CAknMultiLineDataQueryDialog::FirstControl();

    CAknMultilineQueryControl* second =

        CAknMultiLineDataQueryDialog::SecondControl();

    HBufC* firstText = HBufC::NewLC( first->GetTextLength() );

    HBufC* secondText = HBufC::NewL( second->GetTextEntryLength() );

    TPtr firstPtr( firstText->Des() );

    TPtr secondPtr( secondText->Des() );

    first->GetText( firstPtr );

    firstPtr.TrimAll();

    second->GetText( secondPtr );

    secondPtr.TrimAll();

    TBool returnVal( EFalse );

    if ( ( firstPtr.Length() > 0 ) && ( secondPtr.Length() > 0 ) )

        {

        returnVal = ETrue;

        }

    delete secondText;

    CleanupStack::PopAndDestroy( firstText );

    return returnVal;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::OkToExitL()

//

// From CEikDialog

// -----------------------------------------------------------------------------

//

TBool CCnOUiUsernameAndPwdQuery::OkToExitL( TInt aButtonId )

    {

    if ( iForcedExit )

        {

        // If dialog needs to be exited because user

        // emptied user id field, allow exit and don't do any checks

        return ETrue;

        }

    if ( aButtonId == EAknSoftkeyOptions || aButtonId == EAknSoftkeyOk )

        {

        if ( !MenuShowing() )

            {

            DisplayMenuL();

            return EFalse;

            }

        }

    HBufC* userId = HBufC::NewLC( FirstControl()->GetTextLength() );

    TPtr IdPtr( userId->Des() );

    FirstControl()->GetText( IdPtr );

    // Check userID before changing to next page

    if ( CnUiIMPSIdValidator::ValidLoginIdL( IdPtr ) )

        {

        CleanupStack::PopAndDestroy( userId );

        TBool okValue = CAknMultiLineDataQueryDialog::OkToExitL( aButtonId );

        UpdateLeftSoftKeyL();

        return okValue;

        }

    else

        {

        //WV id faulty, show note

        iUiFacade.ShowNoteL( ECnUiImproperPresenceId, IdPtr );

        CleanupStack::PopAndDestroy( userId );

        //try to focus whole editor line

        CEikEdwin* presIdEdwin = ( CEikEdwin* )

                                 FirstControl()->ControlByLayoutOrNull( EMultiDataFirstEdwin );

        if ( presIdEdwin )

            {

            TryChangeFocusToL( EMultilineFirstLine );

            presIdEdwin->SelectAllL();

            }

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::TryChangeFocusToL()

// From CEikDialog

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::TryChangeFocusToL( TInt aControlId )

    {

    // This special focusing is only used to revert the focus

    // back from second line to first line ( landscape mode ).

    if ( Layout_Meta_Data::IsLandscapeOrientation() &&

         aControlId == EMultilineFirstLine )

        {

        // CAknMultiLineDataQueryDialog does not support changing the query

        // backwards, so we have to do it "manually".

        // This is copied from CAknMultiLineDataQueryDialog

        TBool firstLineEnabled = ETrue;

        TBool secondLineEnabled = EFalse;

        CAknMultilineQueryControl* firstControl = FirstControl();

        CAknMultilineQueryControl* secondControl = SecondControl();

        TInt line1 = FindLineIndex( *firstControl );

        TInt line2 = FindLineIndex( *secondControl );

        CEikCaptionedControl *ctrl1 = GetLineByLineAndPageIndex( line1, 0 );

        CEikCaptionedControl *ctrl2 = GetLineByLineAndPageIndex( line2, 0 );

        ctrl1->SetLatent( !firstLineEnabled );

        ctrl2->SetLatent( !secondLineEnabled );

        ctrl1->SetLatentGroupLineFollows( !firstLineEnabled );

        ctrl2->SetLatentGroupLineFollows( !secondLineEnabled );

        ctrl1->SetFocusing( firstLineEnabled );

        ctrl2->SetFocusing( secondLineEnabled );

        }

    CAknMultiLineDataQueryDialog::TryChangeFocusToL( aControlId );

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::HandleResourceChange()

// From CEikDialog

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::HandleResourceChange( TInt aType )

    {

    CAknMultiLineDataQueryDialog::HandleResourceChange( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        TRAP_IGNORE( UpdateLeftSoftKeyL( ) );

        }

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::NeedToDismissQueryL

// From CAknMultiLineDataQueryDialog

// -----------------------------------------------------------------------------

//

TBool CCnOUiUsernameAndPwdQuery::NeedToDismissQueryL( const TKeyEvent& aKeyEvent )

    {

    // Check if user has emptied user id field

    // and exit if domain selection query is variated on

    if ( iDomainSelectionQueryVariation &&

         ( aKeyEvent.iCode == EKeyBackspace || aKeyEvent.iCode == EKeyDelete ) )

        {

        CAknMultilineQueryControl* ctrl = FirstControl(); // user id field

        CCoeControl* coeCtrl = ctrl->ControlByLayoutOrNull( EMultiDataFirstEdwin );

        if ( coeCtrl )

            {

            CEikEdwin* firstEdwin = static_cast<CEikEdwin*>( coeCtrl );

            TInt textLen = firstEdwin->TextLength();

            TInt cursorPos = firstEdwin->CursorPos();

            if ( ( firstEdwin->Selection().Length() == textLen )

                 || ( textLen == 1 && cursorPos == 1 && aKeyEvent.iCode == EKeyBackspace )

                 || ( textLen == 1 && cursorPos == 0 && aKeyEvent.iCode == EKeyDelete ) )

                {

                // NeedToDismissQueryL is called first thing in OfferKeyEventL

                // so if editor length is 1 or whole text is selected at this point

                // it would be 0 after OfferKeyEventL, clear editor and dismiss dialog

                firstEdwin->SelectAllL();

                firstEdwin->ClearSelectionL();

                iForcedExit = ETrue;

                TryExitL( EAknSoftkeyExit );

                return ETrue;

                }

            else

                {

                // Text in editor, don't dismiss

                return EFalse;

                }

            }

        }

    // Else just return EFalse and don't dismiss dialog

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::DetectLineToFocus()

// Private helper.

// -----------------------------------------------------------------------------

//

CCnOUiUsernameAndPwdQuery::TInitialFocus

CCnOUiUsernameAndPwdQuery::DetectLineToFocus(

    const TDesC& aFirstLine,

    const TDesC& aSecondLine )

    {

    //focus the second line just if the first one has something in it

    //and the second one is empty

    if ( ( aFirstLine.Length() > 0 ) && ( aSecondLine.Length() == 0 ) )

        {

        return ESecondLine;

        }

    //else

    return EFirstLine;

    }

// -----------------------------------------------------------------------------

// CCnOUiUsernameAndPwdQuery::DoSetInitialCurrentLineL()

// Private helper.

// -----------------------------------------------------------------------------

//

void CCnOUiUsernameAndPwdQuery::DoSetInitialCurrentLineL()

    {

    ActivateFirstPageL();

    // change input mode according to resource variation

    TBool textualInput = IntResourceValueL( RSC_CHAT_VARIATION_IMPSCU_USERID_TEXTUAL_INPUTMODE );

    if ( ! textualInput )

        {

        // default is textual mode, but now we must switch to numeric mode

        CAknMultilineQueryControl* ctrl = FirstControl(); // user id field

        CCoeControl* coeCtrl = ctrl->ControlByLayoutOrNull( EMultiDataFirstEdwin );

        if ( coeCtrl )

            {

            CEikEdwin* edwin = static_cast<CEikEdwin*>( coeCtrl );

            edwin->SetAknEditorInputMode( EAknEditorNumericInputMode );

            }

        }