/*

* Copyright (c) 2009 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 "FBFileEditor.h"

#include "FBStd.h"

#include "FB.hrh"

#include <filebrowser.rsg>

#include <utf.h>

#include <eikedwin.h>

#include <eikrted.h>

#include <txtrich.h>

#include <eikspane.h>

#include <avkon.hrh> 

#include <akntitle.h>

#include <AknUtils.h> 

#include <AknBidiTextUtils.h>

#include <aknnotewrappers.h>

#include <eiksbfrm.h>

#include <AknDef.h>

#include <layoutmetadata.cdl.h>

const TUint KLeftMargin = 2;

const TUint KRightMargin = 2;

const TUint KHexSeparatorMargin = 4;

const TInt KEditorFontHeight = 117;

const TInt KViewerFontHeight = 117;

const TInt KEditorFontHeightQHD = 100;

const TInt KViewerFontHeightQHD = 100;

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

CFileBrowserFileEditorDlg* CFileBrowserFileEditorDlg::NewL(const TDesC& aFileName, TInt aMode)

    {

    CFileBrowserFileEditorDlg* self = new(ELeave) CFileBrowserFileEditorDlg(aFileName, aMode);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

CFileBrowserFileEditorDlg::~CFileBrowserFileEditorDlg()

    {

    if (iEditorPF)

        delete iEditorPF;

    }

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

CFileBrowserFileEditorDlg::CFileBrowserFileEditorDlg(const TDesC& aFileName, TInt aMode) :

    iFileName(aFileName), iActiveMode(aMode)

    {

    }

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

void CFileBrowserFileEditorDlg::ConstructL()

    {

    // construct a menu bar

    if (iActiveMode == EFileEditorEditAsText || iActiveMode == EFileEditorEditAsHex)

        CAknDialog::ConstructL(R_FILEBROWSER_FILEEDITOR_MENUBAR);

    else

        CAknDialog::ConstructL(R_FILEBROWSER_FILEVIEWER_MENUBAR);

    iTextFormat = EFileBrowserCmdFileEditorSaveFormatANSIASCII;

    }

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

void CFileBrowserFileEditorDlg::PreLayoutDynInitL()

    {

    CAknDialog::PreLayoutDynInitL();

    // set title text

    CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();

    CAknTitlePane* tp = static_cast<CAknTitlePane*>( sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    tp->SetTextL( _L("File editor") );

    // init edwin editor component

    if (iActiveMode == EFileEditorEditAsText || iActiveMode == EFileEditorEditAsHex)

        {

        CCoeControl* control = CreateLineByTypeL(KNullDesC, EFileEditorDialogId, EEikCtEdwin, NULL);

        iTextEditor = static_cast<CEikEdwin*>(control);

        iTextEditor->SetMopParent(this);

        iTextEditor->ConstructL(EEikEdwinOwnsWindow|EEikEdwinNoHorizScrolling|EEikEdwinInclusiveSizeFixed|EEikEdwinNoAutoSelection, 0, 0, 0 );

        iTextEditor->CreateTextViewL();

        iTextEditor->SetAknEditorFlags(EAknEditorFlagEnableScrollBars);

        iTextEditor->CreateScrollBarFrameL();

        iTextEditor->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        iTextEditor->ForceScrollBarUpdateL(); 

        iTextEditor->SetBackgroundColorL(KRgbWhite);

        iTextEditor->SetFocus(ETrue);

        }

    }

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

void CFileBrowserFileEditorDlg::PostLayoutDynInitL()

    {

    CAknDialog::PostLayoutDynInitL();

    // modify layout of the texteditor

    if (iActiveMode == EFileEditorEditAsText || iActiveMode == EFileEditorEditAsHex)

        {

        CGraphicsDevice* dev = iCoeEnv->ScreenDevice();

        const TSize screenSize = dev->SizeInPixels();

        // Set the font of the editor

        TFontSpec fontSpec = AknLayoutUtils::FontFromId(EAknLogicalFontSecondaryFont)->FontSpecInTwips();

        fontSpec.iHeight = IsQHD(screenSize) ? KEditorFontHeightQHD : KEditorFontHeight; // set height

        TCharFormat cf(fontSpec.iTypeface.iName, fontSpec.iHeight);

        cf.iFontPresentation.iTextColor = KRgbBlack; 

        TCharFormatMask cfm;

        cfm.SetAll();

        CCharFormatLayer *charFL = CCharFormatLayer::NewL(cf, cfm);

        iTextEditor->SetCharFormatLayer(charFL);

        if (iEditorPF)

            {

            delete iEditorPF;

            iEditorPF = NULL;

            }

        iEditorPF = CParaFormat::NewL();

        iEditorPF->iLineSpacingInTwips = IsQHD(screenSize) ? KEditorFontHeightQHD : KEditorFontHeight;

        iEditorPF->iFillColor = KRgbWhite;

        TParaFormatMask pfm;

        pfm.SetAll();

        CParaFormatLayer *paraFL = CParaFormatLayer::NewL(iEditorPF, pfm);

        iTextEditor->SetParaFormatLayer(paraFL);

        // set size of the editor

        TRect rect = Rect();

        iTextEditor->SetRect(rect);

        //iTextEditor->Size().iWidth - (CEikScrollBar::DefaultScrollBarBreadth());

        }

    // load the file to editor or viewer

    LoadFileL();

    }

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

void CFileBrowserFileEditorDlg::OpenFileLC(RFile& aFile, const TDesC& aFileName)

    {

    TInt err = aFile.Open(CEikonEnv::Static()->FsSession(), aFileName, EFileRead|EFileShareReadersOnly);

    if (err == KErrInUse)

        {

        CAknErrorNote* note = new(ELeave) CAknErrorNote;

        note->ExecuteLD(_L("The file is in use, cannot open"));

        User::Leave(KErrNone);

        }

    else if (err != KErrNone)

        {

        CAknErrorNote* note = new(ELeave) CAknErrorNote;

        note->ExecuteLD(_L("Cannot open the file"));

        User::Leave(KErrNone);

        }

    else

        {

        // opened succesfully, add to cleanup stack

        CleanupClosePushL(aFile);

        }     

    }

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

void CFileBrowserFileEditorDlg::GetTextFileMode(RFile& aFile, TInt& aFileSize)

    {

    iTextFormat = EFileBrowserCmdFileEditorSaveFormatANSIASCII;

    // if we are working with text files, check the type first   

    if (iActiveMode == EFileEditorEditAsText || iActiveMode == EFileEditorViewAsText)

        {

        TBuf8<4> BOM;

        // first check for UTF-16

        if (aFileSize >= 2 && aFile.Read(0, BOM, 2) == KErrNone)

            {

            if (BOM.Length()==2 && BOM[0]==0xFF && BOM[1]==0xFE)

                {

                iTextFormat = EFileBrowserCmdFileEditorSaveFormatUTF16LE;

                aFileSize -= 2;

                return;

                }

            else if (BOM.Length()==2 && BOM[0]==0xFE && BOM[1]==0xFF)

                {

                iTextFormat = EFileBrowserCmdFileEditorSaveFormatUTF16BE;

                aFileSize -= 2;

                return;

                }

            }       

        // then check for UTF-8

        if (aFileSize >= 3 && aFile.Read(0, BOM, 3) == KErrNone)

            {

            if (BOM.Length()==3 && BOM[0]==0xEF && BOM[1]==0xBB && BOM[2]==0xBF)

                {

                iTextFormat = EFileBrowserCmdFileEditorSaveFormatUTF8;

                aFileSize -= 3;

                return;

                }

            }

        // none of those, seek back to beginning

        TInt pos(0);

        aFile.Seek(ESeekStart, pos);

        }    

    }

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

HBufC16* CFileBrowserFileEditorDlg::ConvertBuf8ToBuf16L(HBufC8* aBuf8)

    {

    __ASSERT_ALWAYS(aBuf8 != NULL, User::Panic(_L("Emp.Buf."),942));

    HBufC16* buf16 = NULL;

    TPtr8 buf8Ptr(aBuf8->Des()); 

    if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatANSIASCII)

        {

        // simple conversion

        buf16 = HBufC16::NewMaxL(aBuf8->Length());

        buf16->Des().Copy(aBuf8->Des());

        }

    else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF8)

        {

        // use the conversion service

        buf16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(aBuf8->Des());

        }            

    else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16LE || iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16BE)

        {

        buf16 = HBufC16::NewL(aBuf8->Length());

        buf16->Des().Copy(KNullDesC);

        HBufC16* oneUniCodeChar = HBufC16::NewMaxLC(1);

        TUint16* oneUniCodeCharPtr = &oneUniCodeChar->Des()[0];

        for (TInt i=0; i<buf8Ptr.Length(); i+=2)

            {

            // get two 8-bit values and pack them to one 16-bit character depending of endianess

            if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16LE)

                {

                oneUniCodeCharPtr[0] = TUint16((buf8Ptr[i+1] << 8) + buf8Ptr[i]);

                }

            else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16BE)

                {

                oneUniCodeCharPtr[0] = TUint16((buf8Ptr[i] << 8) + buf8Ptr[i+1]);

                }

            // append to buffer

            buf16->Des().Append( oneUniCodeChar->Des() );

            }

        CleanupStack::PopAndDestroy(); // oneUniCodeChar

        } 

    return buf16; //ownership of buf16 will transferred to the caller           

    }

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

HBufC8* CFileBrowserFileEditorDlg::ConvertBuf16ToBuf8L(HBufC16* aBuf16)

    {

    __ASSERT_ALWAYS(aBuf16 != NULL, User::Panic(_L("Emp.Buf."),943));

    HBufC8* buf8 = NULL;

    TPtr16 buf16Ptr(aBuf16->Des()); 

    if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatANSIASCII)

        {

        // simple conversion

        buf8 = HBufC8::NewMaxL(aBuf16->Length());

        buf8->Des().Copy(aBuf16->Des());

        }

    else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF8)

        {

        // use the conversion service

        buf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aBuf16->Des());

        }            

    else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16LE || iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16BE)

        {

        buf8 = HBufC8::NewL(aBuf16->Length()*2);

        buf8->Des().Copy(KNullDesC);

        TUint16* charPtr = NULL;

        TBuf8<2> twoChars;

        twoChars.Copy(_L8("XX"));        

        for (TInt i=0; i<aBuf16->Length(); i++)

            {

            charPtr = &aBuf16->Des()[i];

            // get 16-bit character to two variables

            if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16LE)

                {

                twoChars[0] = TUint8(charPtr[0]);

                twoChars[1] = TUint8(charPtr[0] << 8);

                }

            else if (iTextFormat == EFileBrowserCmdFileEditorSaveFormatUTF16BE)

                {

                twoChars[0] = TUint8(charPtr[0] << 8);

                twoChars[1] = TUint8(charPtr[0]);

                }

            // append to the buffer

            buf8->Des().Append(twoChars);

            } // for

        } // else if

    return buf8; //ownership of buf8 will transferred to the caller           

    }                

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

void CFileBrowserFileEditorDlg::LoadFileL()

    {

    // open the file for reading

    RFile fileP;

    OpenFileLC(fileP, iFileName);

    // get file size

    TInt fileSize(0);

    User::LeaveIfError(fileP.Size(fileSize));

    // read BOM from file

    GetTextFileMode(fileP, fileSize);

    // editor related file loading

    if (iActiveMode == EFileEditorEditAsText || iActiveMode == EFileEditorEditAsHex)

        {

        // make sure that there is currently no text in the editor 

        iTextEditor->Text()->Reset();

        // set character handling related cases for the editor

        if (iActiveMode == EFileEditorEditAsText)

            {

            iTextEditor->SetOnlyASCIIChars(EFalse);

            iTextEditor->SetAknEditorCase(EAknEditorTextCase);

            }

        else if (iActiveMode == EFileEditorEditAsHex)

            {

            iTextEditor->SetOnlyASCIIChars(ETrue);

            iTextEditor->SetAknEditorCase(EAknEditorUpperCase);

            }  

        const TInt KBufSize(1024);

        TInt fileOffset(0);

        TInt printOffset(0);

        HBufC8* buf = HBufC8::NewLC(KBufSize);

        TPtr8 bufPtr(buf->Des());

        TChar ch;

        _LIT(KHex, "%02x");

        TBuf<3> hexBuf;

        // read to buffer and supply the editor

        while (fileOffset < fileSize)

            {

            // read to buffer

            User::LeaveIfError( fileP.Read(bufPtr, KBufSize) );

            // handle in text format

            if (iActiveMode == EFileEditorEditAsText)

                {

                HBufC16* buf16 = ConvertBuf8ToBuf16L(buf);

                CleanupStack::PushL(buf16);

                TPtr16 buf16Ptr(buf16->Des());

                // replace any line breaks and append to the editor

                for (TInt i=0; i<buf16Ptr.Length(); i++)

                    {

                    ch = buf16Ptr[i] != '\n' ? (TChar)buf16Ptr[i] : (TChar)CEditableText::ELineBreak;

                    iTextEditor->Text()->InsertL(printOffset, ch);

                    printOffset++;

                    }

                CleanupStack::PopAndDestroy(); // buf16

                }

            // or handle in hex format

            else if (iActiveMode == EFileEditorEditAsHex)

                {

                for (TInt i=0; i<bufPtr.Length(); i++)

                    {

                    hexBuf.Format(KHex, bufPtr[i]);

                    hexBuf.UpperCase();

                    hexBuf.Append(_L(" "));                    

                    iTextEditor->Text()->InsertL(printOffset, hexBuf);

                    printOffset += 3;

                    }

                }

            fileOffset += bufPtr.Length();

            }

        CleanupStack::PopAndDestroy(); // buf

        // make sure that the cursor position is in the beginning 

        iTextEditor->SetCursorPosL(0, EFalse);

        iTextEditor->NotifyNewDocumentL();

        iTextEditor->UpdateScrollBarsL();

        }

    // viewer related file loading

    else if (iActiveMode == EFileEditorViewAsText || iActiveMode == EFileEditorViewAsHex)

        {

        // load the entire file to buffer

        HBufC8* buf = HBufC8::NewLC(fileSize);

        TPtr8 bufPtr(buf->Des());

        User::LeaveIfError( fileP.Read(bufPtr, fileSize) );

        // send the buffer to viewer

        if (iActiveMode == EFileEditorViewAsText)

            {

            HBufC16* buf16 = ConvertBuf8ToBuf16L(buf);

            CleanupStack::PopAndDestroy(); // buf

            iViewer->FormatAsTextL(buf16);

            }

        else if (iActiveMode == EFileEditorViewAsHex)

            {

            iViewer->FormatAsHexL(buf);

            CleanupStack::Pop(); // buf

            }

        }

    CleanupStack::PopAndDestroy(); // fileP

    }

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

void CFileBrowserFileEditorDlg::SaveEditorDataL(TBool aQueryNewName)

    {

    TBool doSave(ETrue);

    CPlainText* docText = iTextEditor->Text();

    TInt docLength = docText->DocumentLength();

    TFileName fileName;

    fileName.Copy(iFileName);

    // check that format of the file is valid

    if (iActiveMode == EFileEditorEditAsHex)

        {

        // check every 3rd char is a space

        for (TInt i=2; i<docLength; i+=3)

            {

            TPtrC docPtr = docText->Read(i, 1);

            if (docPtr.Length() < 1 || docPtr[0] != ' ')

                {

                CAknErrorNote* note = new(ELeave) CAknErrorNote;

                note->ExecuteLD(_L("Separate hex blocks with space!"));

                return;                

                }

            }

        // check for valid chars

        for (TInt i=0; i<docLength; i+=3)

            {

            TPtrC docPtr = docText->Read(i, 2);

            if (docPtr.Length() < 2 || !IsHexChar(docPtr[0]) || !IsHexChar(docPtr[1]))

                {

                CAknErrorNote* note = new(ELeave) CAknErrorNote;

                note->ExecuteLD(_L("Use only hex characters!"));

                return;                

                }

            }

        }

    // query new file name

    if (aQueryNewName)

        {

        CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(fileName);

        textQuery->SetPromptL(_L("Full path:"));

        if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY))

            {

            doSave = ETrue;

            }

        else

            {

            doSave = EFalse;

            }

        }

    // continue with writing