/*
* Copyright (c) 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:  rename dialog for Common UI
*
*/


// INCLUDE FILES
#include <coeutils.h>
#include <eikapp.h>
#include <StringLoader.h>
#include <aknnotewrappers.h>
#include <mpxcollectionuihelper.h>
#include <mpxcollectionhelperfactory.h>
#include <mpxcommonui.rsg>
#include <mpxlog.h>

#include "mpxcommonuihelper.h"
#include "mpxfilenamequerydlg.h"

// CONSTANTS
const TInt KMPXMaxPlaylistPathLen ( 200 );

_LIT( KBackslash, "\\" );
_LIT( KDirectionalChars, "\x202A\x202B\x202C\x202D\x200E\x200F" );

const TUint16 KIllegalChars[] = {
    '<', '>', '"', '/', '\\', '|', ':', '*', '?',
    0xFF02, // Full width quote
    0xFF0A, // Full width asterisk
    0xFF0F, // Full width slash
    0xFF1A, // Full width colon
    0xFF1C, // Full width left arrow
    0xFF1E, // Full width right arrow
    0xFF1F, // Full width question mark
    0xFF3C, // Full width back slash
    0xFF5C, // Full width pipe
    0x201C, // Left quote
    0x201D, // Right quote
    0x201F, // Reversed quote
    0, // Array terminator
};


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


// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CMPXFileNameQueryDlg* CMPXFileNameQueryDlg::NewL(
        const TDesC& aOldName,
        TDes& aNewName,
        const TDesC& aPath,
        TMPXGeneralCategory aCategory,
        CMPXCommonUiHelper* aParent )
    {
    MPX_FUNC( "CMPXFileNameQueryDlg::NewL" );
    CMPXFileNameQueryDlg* self =
        new( ELeave ) CMPXFileNameQueryDlg( aNewName, aCategory, aParent );

    CleanupStack::PushL( self );
    self->ConstructL( aOldName, aPath );
    CleanupStack::Pop( self );

    return self;
    }

// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CMPXFileNameQueryDlg::CMPXFileNameQueryDlg(
    TDes& aNewName,
    TMPXGeneralCategory aCategory,
    CMPXCommonUiHelper* aParent ) :
    CAknTextQueryDialog( aNewName ),
    iParent( aParent ),
    iCategory( aCategory )
    {
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CMPXFileNameQueryDlg::ConstructL(
    const TDesC& aOldName, const TDesC& aPath )
    {
    MPX_FUNC( "CMPXFileNameQueryDlg::ConstructL" );
    TParsePtrC name( aOldName );
    iOldName = aOldName.AllocL();
    iPath = aPath.AllocL();
    // Strip any directionality markers to get pure name
    TPtr ptr( iOldName->Des() );
    AknTextUtils::StripCharacters( ptr, KDirectionalChars );
    TInt extLength( 0 );
    if ( iCategory == EMPXPlaylist )
        {
        Text().Copy( name.NameAndExt() );
        }
    else
        {
        Text().Copy( name.Name() );
        if ( name.ExtPresent() )
            {
            extLength = name.Ext().Length();
            }
        }
    TInt maxLength( KMPXMaxPlaylistPathLen - aPath.Length() - extLength );
    MPX_DEBUG2( "CMPXFileNameQueryDlg::ConstructL setting max length = %d", maxLength );
    SetMaxLength( maxLength );
    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CMPXFileNameQueryDlg::~CMPXFileNameQueryDlg()
    {
    if ( iCollectionUiHelper )
        {
        iCollectionUiHelper->Close();
        }
    delete iOldName;
    delete iPath;
    }

// ---------------------------------------------------------------------------
// CFileManagerFileNameQueryDlg::OkToExitL
// ---------------------------------------------------------------------------
//
TBool CMPXFileNameQueryDlg::OkToExitL( TInt aButtonId )
    {
    MPX_FUNC( "CMPXFileNameQueryDlg::OkToExitL" );
    TBool result( CAknTextQueryDialog::OkToExitL( aButtonId ) );

    HBufC* userText = Text().AllocLC();
    TPtr ptrUserText( userText->Des() );

    // Strip any directionality markers to get pure name
    AknTextUtils::StripCharacters( ptrUserText, KDirectionalChars );

    TParsePtrC currentPath( *iPath );
    // Check file name
    TBool isValidName = IsValidName( currentPath.DriveAndPath(), *userText, EFalse );
    if( !isValidName )
        {
        if( IllegalChars( *userText ) )
            {
            iParent->DisplayInfoNoteL(
                R_MPX_QTN_FLDR_ILLEGAL_CHARACTERS );
            }
        else
            {
            iParent->DisplayInfoNoteL(
                R_MPX_QTN_FLDR_BAD_FILE_NAME );
            }
        CAknQueryControl* queryControl = QueryControl();
        if ( queryControl )
            {
            CEikEdwin* edwin = static_cast< CEikEdwin* >(
                queryControl->ControlByLayoutOrNull( EDataLayout ) );
            if (edwin)
                {
                edwin->SetSelectionL( edwin->TextLength(), 0 );
                }
            }
        CleanupStack::PopAndDestroy( userText );
        return EFalse;
        }

    // if some other entry found with same name
    // not ok except if name same as original
    if ( iCategory != EMPXPlaylist )
        {
        if ( iCollectionUiHelper->TitleExistsL( iCategory, *userText ) )
            {
            TBool overWrite( EFalse );
            HBufC* text = StringLoader::LoadLC( R_MPX_QTN_FLDR_OVERWRITE_QUERY, Text() );
            CAknQueryDialog* dlg = CAknQueryDialog::NewL();
            overWrite = dlg->ExecuteLD( R_MPX_CONFIRM_QUERY_WITH_YES_NO, *text );
            CleanupStack::PopAndDestroy( text );
            if( !overWrite )
                {
                CAknQueryControl* queryControl = QueryControl();
                if (queryControl)
                    {
                    CEikEdwin* edwin = static_cast< CEikEdwin* >(
                        queryControl->ControlByLayoutOrNull( EDataLayout ) );

                    HBufC* newTitle = iParent->GenerateTitleL( iCategory, *userText );
                    CleanupStack::PushL(newTitle);

                    if ( edwin )
                        {
                        edwin->SetTextL( newTitle );
                        edwin->SetSelectionL( edwin->TextLength(), 0 );
                        }
                    CleanupStack::PopAndDestroy(newTitle);
                    }
                result = EFalse;
                }
            }
        }
    CleanupStack::PopAndDestroy( userText );
    if ( result && iCategory != EMPXPlaylist )
        {
        // playlist has no extension, don't need to do this
        TParsePtrC oldName( *iOldName );
        iDataText.Append( oldName.Ext() );
        }
    return result;
    }

// -----------------------------------------------------------------------------
// CMPXFileNameQueryDlg::OfferKeyEventL
// 
// -----------------------------------------------------------------------------
// 
TKeyResponse CMPXFileNameQueryDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType ) 
    { 
    TKeyResponse response = EKeyWasNotConsumed;
    // consume 'enter' so it won't acknowledge the dialog
    TBool vkbOpen = EFalse;
    CAknQueryControl* queryControl = QueryControl();
    if ( queryControl )
        {
        CEikEdwin* edwin = static_cast< CEikEdwin* >(
            queryControl->ControlByLayoutOrNull( EDataLayout ) );
        if ( edwin )
            {            
            if ( edwin->AknEdwinFlags() & EAknEditorFlagTouchInputModeOpened )
                {
                // virtual keyboard is active.                
                vkbOpen = ETrue;
                }
            }
        }    
    
    if ( vkbOpen && aType == EEventKey && aKeyEvent.iCode == EKeyEnter ) 
        { 
        response = EKeyWasConsumed;
        } 
    else
        {
        response = CAknTextQueryDialog::OfferKeyEventL(aKeyEvent, aType); 
        }
    return response;
    }

// -----------------------------------------------------------------------------
// CMPXFileNameQueryDlg::IsValidName
// -----------------------------------------------------------------------------
//
TBool CMPXFileNameQueryDlg::IsValidName(
        const TDesC& aDriveAndPath, const TDesC& aName, TBool aIsFolder ) const
    {
    MPX_FUNC( "CMPXFileNameQueryDlg::IsValidName" );
    // Check name for bad chars
    const TUint16 KMinAllowedChar = 0x0020;
    const TUint16 KParagraphSeparator = 0x2029;
    const TUint16 KDot = '.';
    TInt nameLen( aName.Length() );
    if ( !nameLen )
        {
        return EFalse;
        }
    for ( TInt i( 0 ); i < nameLen; i++ )
        {
        TUint16 ch( aName[ i ] );
        if ( ch < KMinAllowedChar || ch == KParagraphSeparator )
            {
            return EFalse;
            }
        }
    // File system ignores totally dot in the end of name, so
    // we set here as not valid name, so that user gets correctly informed
    if ( aName[ nameLen - 1 ] == KDot || IllegalChars( aName ) )
        {
        return EFalse;
        }
    // Get full path length
    TPtrC pathPtr( aDriveAndPath );
    TInt pathLen( pathPtr.Length() );
    if ( !pathLen )
        {
        return EFalse;
        }
    TInt fullPathLen( pathLen );
    if ( pathPtr[ pathLen - 1 ] != KBackslash()[ 0 ] )
        {
        ++fullPathLen; // Add backslash before name
        }
    fullPathLen += nameLen;
    if ( aIsFolder )
        {
        ++fullPathLen; // Add folder final backslash
        }

    TBool ret( EFalse );
    if ( fullPathLen <= KMaxFileName )
        {
        // Check full path
        HBufC* fullPath = HBufC::New( KMaxFileName );
        if ( fullPath )
            {
            TPtr ptr( fullPath->Des() );
            ptr.Copy( pathPtr );
            if ( pathPtr[ pathLen - 1 ] != KBackslash()[ 0 ] )
                {
                ptr.Append( KBackslash ); // Add backslash before name
                }
            ptr.Append( aName );
            RFs fs;
            TInt connectError = fs.Connect();
            if ( connectError == KErrNone )
            {
                ret = fs.IsValidName( ptr );
                fs.Close();
            }
            delete fullPath;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CMPXFileNameQueryDlg::IllegalChars
// -----------------------------------------------------------------------------
//
TBool CMPXFileNameQueryDlg::IllegalChars( const TDesC& aName ) const
    {
    MPX_FUNC( "CMPXFileNameQueryDlg::IllegalChars" );
    for ( TInt i( 0 ); KIllegalChars[ i ]; i++ )
        {
        if ( aName.Locate( KIllegalChars[ i ] ) != KErrNotFound )
            {
            return ETrue;
            }
        }
    return EFalse;
    }

//  End of File