/*

* Copyright (c) 2003 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:  ?Description

*

*/

#include <eikenv.h>

#include <eiklabel.h>

#include <eikon.hrh>

#include <AknLayoutFont.h>

// LAF API in several places

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknUtils.h>

#include "CMIDDateFieldItem.h"

// API used for retrieving commands count (in IsSelectable function)

#include "CMIDCommandList.h"

// API needed for iLabelControl (inherited from CMIDControlItem)

#include "CMIDItemLabel.h"

#include "CMIDDisplayable.h"

#include "CMIDUtils.h"

#include "CMIDTicker.h"

#include "CMIDUIManager.h"

#include <j2me/jdebug.h>

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDDateFieldItem.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

// Must be used in TIME case due to strange definition of KAknMinimumDate

#define KCMIDDateFieldMinTime (TTime(TDateTime(0, EJanuary, 0, 0, 0, 0, 0)))

#define KCMIDDateFieldEpochDate (TTime(TDateTime(1970, EJanuary, 1-1, 0, 0, 0, 0)))

_LIT(KTimeAndDateFieldSeparator," ");

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

//

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

//

CMIDDateFieldItem* CMIDDateFieldItem::NewL(

    const TDesC& aLabel, MMIDDateField::TInputMode aInputMode, CMIDUIManager* aUIManager)

{

    CMIDDateFieldItem* item = new(ELeave)CMIDDateFieldItem(aUIManager);

    CleanupStack::PushL(item);

    item->ConstructL(aLabel,aInputMode);

    CleanupStack::Pop(item);

    return item;

}

CMIDDateFieldItem::~CMIDDateFieldItem()

{

    if (iAmPmToggleCommand)

    {

        iAmPmToggleCommand->SetObserver(NULL);

        iAmPmToggleCommand->Dispose();

        iAmPmToggleCommand = NULL;

    }

    if (iEditor)

    {

        iEditor->SetFocus(ETrue);   // needed to notify observers about editor destruction

        delete iEditor;

        iEditor = NULL;

    }

}

void CMIDDateFieldItem::SetDate(const TTime& aTime)

{

    TTime time = aTime;

    if (iInputMode == MMIDDateField::ETime)

    {

        TDateTime dateTime = aTime.DateTime();

        time = TTime(TDateTime(0, EJanuary, 0,

                               dateTime.Hour(),

                               dateTime.Minute(),

                               dateTime.Second(),

                               dateTime.MicroSecond()));

    }

    else

    {

        TDateTime dateTime = aTime.DateTime();

        if (dateTime.Year() == 0)

        { // Date is not set or DateField type is switched

            // from ETime input mode. Date part set to "zero epoch"

            TDateTime epochDate = KCMIDDateFieldEpochDate.DateTime();

            time = TTime(TDateTime(epochDate.Year(), // set to "zero epoch"

                                   epochDate.Month(),

                                   epochDate.Day(),

                                   dateTime.Hour(),

                                   dateTime.Minute(),

                                   dateTime.Second(),

                                   dateTime.MicroSecond()));

        }

    }

    iEditor->SetTTime(time);

    SetInitialized(EFalse);

}

TTime CMIDDateFieldItem::Date() const

{

    TInt err = KErrNone;

    TTime ret = KCMIDDateFieldEpochDate;

    TBool nonEmpty = IsDateTimeNonEmpty();

    if (nonEmpty)

    {

        // GetTTime leaves if there is zero in the day, month or year fields.

        TRAP(err, ret = iEditor->GetTTime());

    }

    if ((err != KErrNone) || !nonEmpty)

    {

        TRAP(err, iEditor->PrepareForFocusLossL())

        // GetTTime should not leave after calling PrepareForFocusLossL

        ret = iEditor->GetTTime();

    }

    return ret;

}

void CMIDDateFieldItem::SetUninitialized()

{

    iInitialised = EFalse;

    iEditor->SetTTime(KCMIDDateFieldEpochDate);

    if (iInputMode == MMIDDateField::ETime)

    {

        iEditor->SetTTime(KCMIDDateFieldMinTime);

        reinterpret_cast<CEikTimeEditor*>(iEditor)->SetUninitialised(ETrue);

    }

    else if (iInputMode == MMIDDateField::EDate)

    {

        reinterpret_cast<CEikDateEditor*>(iEditor)->SetUninitialised(ETrue);

    }

    else if (iInputMode == MMIDDateField::EDateTime)

    {

        reinterpret_cast<CEikTimeAndDateEditor*>(iEditor)->SetUninitialised(ETrue);

    }

    DoSafeDraw();

}

void CMIDDateFieldItem::SetInputModeL(MMIDDateField::TInputMode aInputMode)

{

    CEikTTimeEditor* editor = NULL;

    TBool validOldTime = IsDateTimeNonEmpty();

    TTime oldTime;

    if (validOldTime)

    {

        // GetTTime leaves if there is 0 in day, month or year fields

        TRAPD(err, oldTime = iEditor->GetTTime());

        if (err != KErrNone)

        {

            validOldTime = EFalse;

        }

    }

    switch (aInputMode)

    {

    case MMIDDateField::EDate:

    {

        CEikDateEditor* dateEditor = new(ELeave) CEikDateEditor();

        CleanupStack::PushL(dateEditor);

        dateEditor->ConstructL(KAknMinimumDate,KAknMaximumDate,KCMIDDateFieldEpochDate,ETrue);

        CleanupStack::Pop(dateEditor);

        dateEditor->SetUninitialised(ETrue);

        editor = dateEditor;

        break;

    }

    case MMIDDateField::ETime:

    {

        CEikTimeEditor* timeEditor = new(ELeave) CEikTimeEditor();

        CleanupStack::PushL(timeEditor);

        timeEditor->ConstructL(KCMIDDateFieldMinTime,

                               KAknMaximumDate,

                               KCMIDDateFieldMinTime,

                               EEikTimeWithoutSecondsField);

        CleanupStack::Pop(timeEditor);

        timeEditor->SetUninitialised(ETrue);

        editor = timeEditor;

        break;

    }

    case MMIDDateField::EDateTime:

    {

        CEikTimeAndDateEditor* timeDateEditor = new(ELeave) CEikTimeAndDateEditor();

        CleanupStack::PushL(timeDateEditor);

        TUint32 flags = EEikTimeWithoutSecondsField + EEikDateWithoutPopoutCalendar;

        TPtrC separatorPtr(KTimeAndDateFieldSeparator);

        HBufC* separator = separatorPtr.AllocLC();

        timeDateEditor->ConstructL(KAknMinimumDate,

                                   KAknMaximumDate,

                                   KCMIDDateFieldEpochDate,flags,separator);

        CleanupStack::Pop(separator); // Do not destroy separator as

        // CEikTimeAndDateEditor takes control of it

        CleanupStack::Pop(timeDateEditor);

        timeDateEditor->SetUninitialised(ETrue);

        editor = timeDateEditor;

        break;

    }

    default:

        ASSERT(EFalse);

    }

    delete iEditor;

    iEditor = editor;

    iInputMode = aInputMode;

    // Set font from LAF to the editor, so that MinimumSize() will return correct values.

    // AknLayoutUtils::LayoutMfne() will also set the font from LAF to the editor

    iEditor->SetFont(AknLayoutUtils::FontFromId(

                         AknLayoutScalable_Avkon::form2_midp_time_pane_t1().Font()));

    iEditor->SetBorder(TGulBorder::ENone);

    if (iForm)

    {

        iEditor->SetContainerWindowL(*this);

        iEditor->ActivateL();

    }

    if (validOldTime)

    {

        SetDate(oldTime);

        DoSafeDraw();

    }

    else

    {

        iInitialised = EFalse;

    }

    // Text colour from skin

    iEditor->SetSkinTextColorL(EAknsCIQsnTextColorsCG6);

}

void CMIDDateFieldItem::SetInitialized(TInt aSetCurrentTime /* = ETrue */)

{

    iInitialised = ETrue;

    if (iInputMode == MMIDDateField::ETime)

    {

        reinterpret_cast<CEikTimeEditor*>(iEditor)->SetUninitialised(EFalse);

    }

    else if (iInputMode == MMIDDateField::EDate)

    {

        reinterpret_cast<CEikDateEditor*>(iEditor)->SetUninitialised(EFalse);

    }

    else if (iInputMode == MMIDDateField::EDateTime)

    {

        reinterpret_cast<CEikTimeAndDateEditor*>(iEditor)->SetUninitialised(EFalse);

    }

    if (aSetCurrentTime)

    {

        TTime time;

        time.HomeTime();

        iEditor->SetTTime(time);

    }

    iEditor->DrawDeferred();

}

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

//

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

//

CMIDDateFieldItem::CMIDDateFieldItem(CMIDUIManager* aUIManager)

        :CMIDControlItem(EDefault, aUIManager),

        iInitialised(EFalse),

        iAmPmToggleCommand(0)

{

    iMMidItem = this;

}

void CMIDDateFieldItem::ConstructL(const TDesC& aLabel,MMIDDateField::TInputMode aInputMode)

{

    CMIDControlItem::ConstructL();

    SetLabelL(aLabel);

    SetFocusing(ETrue);

    UpdateMemberVariables();

    SetInputModeL(aInputMode);

    // Create built-in command to toggle am/pm value

    HBufC* label = iEikonEnv->AllocReadResourceL(R_QTN_MSK_CHANGE);

    CleanupStack::PushL(label);

    iAmPmToggleCommand = CMIDCommand::NewBuiltInCommandL(label->Des(),

                         MMIDCommand::EItem,

                         CMIDCommand::EAmPmToggleCommandId);

    CleanupStack::PopAndDestroy(label); // command creates a copy of the label

    iAmPmToggleCommand->SetObserver(this);

}

void CMIDDateFieldItem::SetLabelL(const TDesC& aLabel)

{

    CMIDControlItem::SetLabelL(aLabel);

}

/** Recalculate the preferred size.*/

TSize CMIDDateFieldItem::ResetPreferredSize() const

{

    CMIDDateFieldItem* self = const_cast<CMIDDateFieldItem*>(this);

    TRAP_IGNORE(self->SetPreferredSizeL(iRequestedPreferredSize));

    return iPreferredSize;

}

void CMIDDateFieldItem::SetPreferredSizeL(const TSize& aSize)

{

    iRequestedPreferredSize = CheckRequestedSize(aSize);

    iPreferredSize = iRequestedPreferredSize;

    if (iPreferredSize.iWidth < 0)

    { // height is specified but width isn't

        iPreferredSize.iWidth = Max(iLabelControl->PreferredWidth(),

                                    iEditor->Size().iWidth + iMargins.iLeft + iMargins.iRight);

    }

    // make sure the width doesn't get bigger than the form width

    iPreferredSize.iWidth = Min(iPreferredSize.iWidth, FormClientAreaWidth());

    if (iPreferredSize.iHeight < 0)

    {  // width is specified but height isn't, do text wrapping (call SetWidthL)

        // so that we can then calculate the height

        if (HasLabel())

        {

            iLabelControl->SetWidthL(iPreferredSize.iWidth);

        }

        iPreferredSize.iHeight = LabelHeight() + ItemPreferredHeightWithoutLabel();

    }

    TSize minimumSize = MinimumSize();

    if ((minimumSize.iWidth == 0) && (minimumSize.iHeight == 0))

    { //it means there is no control and no label, so set our size to null

        iPreferredSize.iWidth = 0;

        iPreferredSize.iHeight = 0;

    }

    else

    { //make sure the preferred size is not smaller than the minimum size

        iPreferredSize.iWidth = Max(iPreferredSize.iWidth, minimumSize.iWidth);

        iPreferredSize.iHeight = Max(iPreferredSize.iHeight, minimumSize.iHeight);

    }

}

TBool CMIDDateFieldItem::IsSelectable() const

{

    return (!IsNonFocusing() || CommandList()->Count() > 0);

}

TSize CMIDDateFieldItem::MinimumSize()

{

    TBool hasLabel = HasLabel();

    TInt height = ItemPreferredHeightWithoutLabel();

    if (hasLabel)

    {

        height += OneLineLabelHeight();

    }

    TInt formWidth = FormClientAreaWidth();

    TInt width     = formWidth;

    if (Layout() & ELayout2)

    {

        TInt labelMinWidth = hasLabel ? iLabelControl->MinimumSize().iWidth : 0;

        width = Max(iEditor->MinimumSize().iWidth + iMargins.iLeft + iMargins.iRight,

                    labelMinWidth);

        width = Min(width, formWidth);

    }

    return TSize(width, height);

}

TInt CMIDDateFieldItem::CountComponentControls() const

{

    return 2;

}

CCoeControl* CMIDDateFieldItem::ComponentControl(TInt aIndex) const

{

    switch (aIndex)

    {

    case 0:

        return iLabelControl;

    case 1:

        return iEditor;

    }

    ASSERT(NULL);

    return NULL;

}

void CMIDDateFieldItem::Draw(const TRect& aRect) const

{

    if (!iForm)

    {

        return; // if we don't have a form we shouldn't try to draw

    }

    CMIDControlItem::Draw(aRect);

}

void CMIDDateFieldItem::SizeChanged()

{

    TRect rect = Rect();

    TPoint topLeft = Position();

    TInt labelHeight = LabelHeight();

    iLabelControl->SetExtent(topLeft, TSize(rect.Width(), labelHeight));

    rect.iTl.iY += labelHeight;

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(rect, AknLayoutScalable_Avkon::form2_midp_time_pane().LayoutLine());

    AknLayoutUtils::LayoutMfne(iEditor, layoutRect.Rect(),

                               AknLayoutScalable_Avkon::form2_midp_time_pane_t1().LayoutLine());

    CMIDControlItem::SizeChanged();

}

TKeyResponse CMIDDateFieldItem::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    TInt oldCurrentField = iEditor->CurrentField();

    TInt code = aKeyEvent.iCode;

    TBool initialised = EFalse;

    //

    // Enter Key

    //

    if (aType == EEventKey)

    {

        usedKeyEvent=&aKeyEvent;

        prevInitialised=iInitialised;

    }

#ifdef RD_JAVA_S60_RELEASE_9_2

    if (iInitialised && ((aType == EEventKey && (aKeyEvent.iScanCode == EStdKeyEnter || aKeyEvent.iScanCode == EStdKeyDevice3)) ||

                         (aType == EEventKey && (aKeyEvent.iCode == EKeyEnter || aKeyEvent.iCode == EKeyDevice3) && (usedKeyEvent != &aKeyEvent) ||

                          (aType == EEventKeyUp && (aKeyEvent.iScanCode == EStdKeyEnter || aKeyEvent.iScanCode == EStdKeyDevice3) &&  prevInitialised == iInitialised && (usedKeyEvent != &aKeyEvent)))))

#else

    if (iInitialised && ((aType == EEventKey &&  aKeyEvent.iScanCode == EStdKeyEnter) ||

                         (aType == EEventKey && aKeyEvent.iCode == EKeyEnter && (usedKeyEvent != &aKeyEvent) ||

                          (aType == EEventKeyUp && aKeyEvent.iScanCode == EStdKeyEnter &&  prevInitialised == iInitialised && (usedKeyEvent != &aKeyEvent)))))

#endif // RD_JAVA_S60_RELEASE_9_2        

    {

        // Toggle AmPm

        if (IsCurrentFieldAmPmField())

        {

            ToggleAmPmFieldValue();

            return EKeyWasConsumed;

        }

        else

        {

            CMIDDisplayable& displayable = iForm->CurrentDisplayable();

            TInt cntOpt = displayable.NumCommandsForOkOptionsMenu();

            // set first command from command list,

            // if command list <= 0 then command sets NULL

            const CMIDCommand* command = (CommandList()->Count() > 0 ?

                                          CommandList()->At(0).iCommand :

                                          NULL);

            // Activate Default command

            // For default command will run ProcessCommandL( KItemCommandIdBase + 1 )

            if (DefaultCommand())

            {

                displayable.ProcessCommandL(CommandList()->CommandOffset() +

                                            CommandList()->FindCommandIndex(DefaultCommand()));

                return EKeyWasConsumed;

            }

            // Show Menu or activate one command

            else

            {

                // Active Command Show Menu

                // if ( cntOpt > 1 ) will run menu, else execute ProcessCommandL( CommandOffset )

                if (cntOpt > 1)

                {

                    displayable.MenuHandler()->ShowMenuL(CMIDMenuHandler::EOkMenu);

                    return EKeyWasConsumed;

                }

                else if (command && command->CommandType() != MMIDCommand::EBack &&

                         command->CommandType() != MMIDCommand::ECancel)

                {

                    displayable.ProcessCommandL(CommandList()->CommandOffset());

                    return EKeyWasConsumed;

                }

                else

                {

                    displayable.ProcessCommandL(displayable.MainCommandList()->CommandOffset());

                    return EKeyWasConsumed;

                }

            }

        }

    }

    //

    // End Enter Key

    //

    if (code == EKeyDownArrow || code == EKeyUpArrow || code == EKeyApplication0)

        return EKeyWasNotConsumed;

    if (!iInitialised && aType == EEventKey && !CMIDUtils::IgnoreKeyEvent(aKeyEvent.iCode))

    {

        if (code == EKeyBackspace)

        {

            return EKeyWasNotConsumed;