/*

* 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: Defines the Text Editor native side component

*

*/

// EXTERNAL INCLUDES

#include <MMIDCustomComponentContainer.h>

#include <lcdui.h>

#include <aknappui.h>

#include <aknnavi.h>

#include <j2me/jdebug.h>

// INTERNAL INCLUDES

#include "CMIDTextEditor.h"

#include "CMIDTextEditorEdwin.h"

#include "CMIDEditingStateIndicator.h"

#include "CMIDEdwinUtils.h"

#include "CMIDUtils.h"

#include "CMIDFont.h"

// Default background color.

const TInt KDefColorBgRed       = 0;

const TInt KDefColorBgGreen     = 0;

const TInt KDefColorBgBlue      = 0;

const TInt KDefColorBgAlpha     = 0;

// Default foreground color.

const TInt KDefColorFgRed       = 0;

const TInt KDefColorFgGreen     = 0;

const TInt KDefColorFgBlue      = 0;

const TInt KDefColorFgAlpha     = 255;

// Default highlight background color.

const TInt KDefColorHlBgRed     = 0;

const TInt KDefColorHlBgGreen   = 0;

const TInt KDefColorHlBgBlue    = 0;

const TInt KDefColorHlBgAlpha   = 255;

// Default highlight foreground color.

const TInt KDefColorHlFgRed     = 255;

const TInt KDefColorHlFgGreen   = 255;

const TInt KDefColorHlFgBlue    = 255;

const TInt KDefColorHlFgAlpha   = 255;

// Count of compound components in this custom component.

const TInt KComponentCount      = 2;

// For all touch input modes to be disabled

const TInt KAllTouchModesDisabled    = 63;

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

// CMIDTextEditor::NewL

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

//

CMIDTextEditor* CMIDTextEditor::NewL(const TCtorParams& aParams)

{

    CMIDTextEditor* self = new(ELeave) CMIDTextEditor();

    CleanupStack::PushL(self);

    self->ConstructL(aParams);

    CleanupStack::Pop(self);

    return self;

}

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

// CMIDTextEditor::~CMIDTextEditor

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

//

CMIDTextEditor::~CMIDTextEditor()

{

    DEBUG("CMIDTextEditor::~CMIDTextEditor +");

#ifdef RD_TACTILE_FEEDBACK

    if (iPenInputServerConnected)

    {

        // Close pen input server if the device is touch enabled and

        // connection was established

        iPenInputServerConnected = EFalse;

        iPenServer.Close();

    }

#endif // RD_TACTILE_FEEDBACK

    // Remove this component from the container if set.

    if (iComponentContainer)

    {

        iComponentContainer->UnregisterComponent(this);

    }

    // Remove association from the previous direct container.

    if (iDirectContainer)

    {

        iDirectContainer->MdcRemoveContent(this);

    }

    delete iTextEdwin;

    delete iEdwinUtils;

    delete iEditingStateIndicator;

    iUtils = NULL;

    DEBUG("CMIDTextEditor::~CMIDTextEditor -");

}

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

// CMIDTextEditor::CustomComponentControlCount

// (other items are commented in the header file)

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

//

TInt CMIDTextEditor::CustomComponentControlCount() const

{

    return KComponentCount;

}

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

// CMIDTextEditor::CustomComponentControl

// (other items are commented in the header file)

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

//

CCoeControl* CMIDTextEditor::CustomComponentControl(TInt aIndex)

{

    switch (aIndex)

    {

    case 0:

    {

        return iTextEdwin;

    }

    case 1:

    {

        return iEditingStateIndicator;

    }

    default:

    {

        __ASSERT_DEBUG(EFalse, User::Invariant());

    }

    }

    return NULL;

}

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

// CMIDTextEditor::CustomComponentContainerDisposing

// (other items are commented in the header file)

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

//

void CMIDTextEditor::CustomComponentContainerDisposing()

{

    DEBUG("CMIDTextEditor::CustomComponentContainerDisposing +");

    // Remove container association.

    iComponentContainer = NULL;

    // Uninitialize the text editor window.

    iTextEdwin->Uninitialize();

    DEBUG("CMIDTextEditor::CustomComponentContainerDisposing -");

}

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

// CMIDTextEditor::SetObserver

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetObserver(MMIDTextEditorObserver* aObserver)

{

    DEBUG("CMIDTextEditor::SetObserver +");

    iObserver = aObserver;

    iTextEdwin->SetObserver(aObserver);

    DEBUG("CMIDTextEditor::SetObserver -");

}

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

// CMIDTextEditor::isTouchEnabled

// (other items are commented in the header file)

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

//

TBool CMIDTextEditor::IsTouchEnabled()

{

    return iTouchEnabled;

}

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

// CMIDTextEditor::setTouchEnabled

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetTouchEnabled(TBool aEnabled)

{

    iTouchEnabled = aEnabled;

}

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

// CMIDTextEditor::SetEditorSize

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetEditorSize(TInt aWidth, TInt aHeight)

{

    DEBUG_INT2("CMIDTextEditor::SetEditorSize + aWidth=%d, aHeight=%d",

               aWidth, aHeight);

    // We need store non-scaled size of editor for possible resolution

    // and fullscreen mode changes.

    iNonScaledEditorSize = TSize(aWidth, aHeight);

    // If parent is in fullscreen mode then it tries scale input size.

    // Only setting otherwise.

    if (IsScalingOn())

    {

        iTextEdwin->SetSize(iUtils->DoScaling(aWidth, CMIDUtils::EHorizontal),

                            iUtils->DoScaling(aHeight, CMIDUtils::EVertical));

        // Update the size of the indicator. Height does not need to be

        // calculated.

        iEditingStateIndicator->SetSize(iUtils->DoScaling(

                                            aWidth, CMIDUtils::EHorizontal), -1);

    }

    else

    {

        iTextEdwin->SetSize(aWidth, aHeight);

        // Update the size of the indicator. Height does not need to be

        // calculated.

        iEditingStateIndicator->SetSize(aWidth, -1);

    }

    // Updating of position of indicator is needed for change of its size.

    UpdateIndicatorPosition();

    // Redraw the editor

    iTextEdwin->Redraw();

    // Change the flag so now the font size changes will not

    // resize the editor any more.

    iRowCountActive = EFalse;

    DEBUG("CMIDTextEditor::SetEditorSize -");

}

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

// CMIDTextEditor::EditorSize

// (other items are commented in the header file)

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

//

TSize CMIDTextEditor::EditorSize() const

{

    DEBUG("CMIDTextEditor::EditorSize");

    TSize editorSize = iTextEdwin->Size();

    // When scaling is on it has to descaled editor size.

    if (IsScalingOn())

    {

        editorSize = iUtils->DoDescaling(editorSize);

    }

    return editorSize;

}

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

// CMIDTextEditor::SetParentL

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetParentL(

    MMIDCustomComponentContainer* aComponentContainer)

{

    DEBUG("CMIDTextEditor::SetParentL +");

    // Remove association from the previous container.

    if (iComponentContainer)

    {

        DEBUG("CMIDTextEditor::SetParentL, unregistering old association");

        // Remove focus

        SetFocusStateL(EFalse);

        // Remove editor from container

        iComponentContainer->UnregisterComponent(this);

        // Set editor window uninitialized

        iTextEdwin->Uninitialize();

        iComponentContainer->Control().DrawDeferred();

        iComponentContainer = NULL;

    }

    // Associate this component to the new container.

    if (aComponentContainer)

    {

        DEBUG("CMIDTextEditor::SetParentL, registering new");

        CCoeControl& control = aComponentContainer->Control();

        // Register container window for the editor.

        iTextEdwin->SetContainerWindowL(control);

        iTextEdwin->SetTopParent(&control);

        // Initialize the editor window.

        // Set container window also for the indicator.

        iEditingStateIndicator->SetContainerWindowL(&control);

        // Register this custom component to the container.

        aComponentContainer->RegisterComponentL(this);

    }

    // Store container. NULL is ok.

    iComponentContainer = aComponentContainer;

    if (iComponentContainer)

    {

        if (!iRowCountActive)

        {

            // We need call SetEditorSize to prevent wrong

            // scaling of TextEditor.

            // (only for TextEditor not created with row counter)

            SetEditorSize(iTextEdwin->Size().iWidth, iTextEdwin->Size().iHeight);

        }

        else

        {

            iNonScaledEditorSize = iTextEdwin->Size();

        }

        SetFontL(iNonScaledFont);

    }

    if (iUtils)

    {

        // It sets edwin variables necessary for correct clipping.

        iTextEdwin->SetOnScreenCanvasRect(iUtils->GetOnScreenCanvasRect());

        iTextEdwin->SetScaling(IsScalingOn());

        // It sets indicator variables necessary for correct clipping.

        iEditingStateIndicator->SetScalingOn(IsScalingOn());

        iEditingStateIndicator->SetCanvasRect(iUtils->GetOnScreenCanvasRect());

    }

    DEBUG("CMIDTextEditor::SetParentL -");

}

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

// CMIDTextEditor::SetDirectContainerL

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetDirectContainerL(MDirectContainer* aDirectContainer)

{

    // Remove association from the previous direct container.

    if (iDirectContainer)

    {

        iDirectContainer->MdcRemoveContent(this);

    }

    // Associate this component to the new direct container. Note that this

    // needs to be done in order to disable the direct screen access of

    // the MID parent component. This way it does not draw on top of

    // the text editor when repaint etc. methods are called.

    if (aDirectContainer)

    {

        aDirectContainer->MdcAddContent(this);

    }

    // Store new container. Or NULL if passed.

    iDirectContainer = aDirectContainer;

}

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

// CMIDTextEditor::SetElevationL

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetElevationL(TInt aElevation)

{

    DEBUG_INT("CMIDTextEditor::SetElevationL +, aElevation=%d", aElevation);

    // Parent must have been set.

    __ASSERT_DEBUG(iComponentContainer, User::Invariant());

    // The elevation is corrected in custom component container.

    iComponentContainer->SetComponentIndexL(this, aElevation);

    DEBUG("CMIDTextEditor::SetElevationL -");

}

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

// CMIDTextEditor::Elevation

// (other items are commented in the header file)

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

//

TInt CMIDTextEditor::Elevation()

{

    DEBUG("CMIDTextEditor::Elevation +");

    // Parent must have been set.

    __ASSERT_DEBUG(iComponentContainer, User::Invariant());

    TInt index = iComponentContainer->ComponentIndex(this);

    DEBUG_INT("CMIDTextEditor::Elevation - index=%d", index);

    return index;

}

void CMIDTextEditor::TraverseL(const TKeyEvent& aEvent)

{

    if (iTextEdwin->Traverse(aEvent))

    {

        if (iObserver)

        {

            if ((aEvent.iCode == EKeyUpArrow) ||

                    (aEvent.iScanCode == EStdKeyUpArrow))

            {

                iObserver->NotifyInputAction(

                    MMIDTextEditorObserver::EActionTraversePrevious);

            }

            else if ((aEvent.iCode == EKeyDownArrow) ||

                     (aEvent.iScanCode == EStdKeyDownArrow))

            {

                iObserver->NotifyInputAction(

                    MMIDTextEditorObserver::EActionTraverseNext);

            }

        }

    }

    else

    {

        iTextEdwin->OfferKeyEventL(aEvent, EEventKeyDown);

    }

}

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

// CMIDTextEditor::Show

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetVisibleL(TBool aVisible)

{

    DEBUG_INT("CMIDTextEditor::SetVisibleL +, aVisible=%d", aVisible);

    // SetParentL must be called before Show.

    __ASSERT_DEBUG(iComponentContainer, User::Invariant());

    if (aVisible && !iTextEdwin->IsVisible())

    {

        DEBUG("CMIDTextEditor::SetVisibleL, setting editor visible");

        // Show the text editor when it is hidden.

        iTextEdwin->MakeVisible(aVisible);

        // If setting visible already focused editor

        if (iFocusState)

        {

            iFocusState = EFalse;

            SetFocusStateL(ETrue);

            // Cursor is not shown automatically if the editor has focus.

            // So, set cursor visible.

            iTextEdwin->SetCursorVisible(ETrue);

        }

        else

        {

            // MakeVisible automatically selects the editor's content

            // Remove the selection at this point. The selection can be

            // set again with the API.

            SetCursorPositionL(iTextEdwin->CursorPos());

        }

    }

    else if (!aVisible && iTextEdwin->IsVisible())

    {

        DEBUG("CMIDTextEditor::SetVisibleL, setting editor hidden");

        if (iFocusState)

        {

            // Remove the focus from the editor also.

            SetFocusStateL(EFalse);

            // Keep focus state for visibility changes

            iFocusState = ETrue;

        }

        // Hide the text editor when it is visible.

        iTextEdwin->MakeVisible(EFalse);

        // Always disable indicator if the editor is hidden.

        iEditingStateIndicator->MakeVisible(EFalse);

    }

    iTextEdwin->Redraw();

    DEBUG("CMIDTextEditor::SetVisibleL -");

}

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

// CMIDTextEditor::IsVisible

// (other items are commented in the header file)

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

//

TBool CMIDTextEditor::IsVisible() const

{

    return iTextEdwin->IsVisible();

}

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

// CMIDTextEditor::SetPosition

// (other items are commented in the header file)

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

//

void CMIDTextEditor::SetPosition(TInt aX, TInt aY)

{

    DEBUG_INT2("CMIDTextEditor::SetPosition +, aX=%d, aY=%d", aX, aY);

    // We need store non-scaled position for possible resolution

    // and fullscreen mode changes.

    iNonScaledPosition = TPoint(aX, aY);

    // If parent is in fullscreen mode then it tries scale input position.

    // Only setting otherwise.

    if (IsScalingOn())