/*

* Copyright (c) 2002 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: List Box Model class for Calendar Day view  

 *

*/

#include <calencommands.hrh>            // Calendar commands

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <eikenv.h>

#include <PUAcodes.hrh>

#include <StringLoader.h>

#include <txtrich.h>

#include <calentry.h>

#include <calinstance.h>

#include <calrrule.h>

#include <calalarm.h>

#include <centralrepository.h>

#include <Calendar.rsg>

#include <calsession.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenviewutils.h>

#include <calenagendautils.h>

#include "CalendarVariant.hrh"

#ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

#include <calendateutils.h>

#endif // RD_CALEN_MIDNIGHT_VISUALIZATION

#include <calcalendarinfo.h>

#include <calenservices.h>

//debug

#include "calendarui_debug.h"

#include "calendaylistboxmodel.h"

#include "calencontroller.h"

#include "CalendarVariant.hrh"

#include "calendaylistbox.h"

#include "calentodoview.h" // for priorities

#include "calendar.hrh"

#include "CalendarPrivateCRKeys.h"

#include "calenglobaldata.h"

// LOCAL CONSTANTS AND MACROS

_LIT(KDesTimeSpace, " ");

_LIT(KDesSeparator, "\t");

_LIT(KIconSeperatorFormat, "%d\t"); // Day LB icon seperator format

#ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

_LIT(KUnicodeRightwardsArrow, "\x2192"); // ->

_LIT(KUnicodeLeftwardsArrow, "\x2190");  // <-

_LIT(K24hFmt12am, " 00"); // already starts at hr 00

_LIT(K24hFmt12pm, "24 ");

#endif // RD_CALEN_MIDNIGHT_VISUALIZATION

const TInt KTimedNoteMaxLines(4);

const TInt KHypenBufSize(4);

const TInt KNonTimedNoteMaxLines(1);

// KMaxColumnDataLength is Avkon defined minimal maximum length for column texts.

const TInt KMaxLengthOfDisplayedText(KTimedNoteMaxLines * KMaxColumnDataLength);

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

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

// CCalenDayListBoxModel::CCalenDayListBoxModel

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

// might leave.

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

//

CCalenDayListBoxModel::CCalenDayListBoxModel()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenDayListBoxModel::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCalenDayListBoxModel::ConstructL( const CCalenDayContainer* aDayContainer )

    {

    TRACE_ENTRY_POINT;

    iDayContainer = aDayContainer;

    iItemTextArray = new(ELeave) CDesCArrayFlat(5);

    // Read time formats

    iTimeFormat = StringLoader::LoadL( R_QTN_TIME_USUAL_WITH_ZERO );

    TRACE_EXIT_POINT;

    }

void CCalenDayListBoxModel::UpdateLayoutValues( TInt aLayoutVariant,

TBool aMidnightVisualization)

    {

    TRACE_ENTRY_POINT;

    CCalenDayListBox::ReadLayout(

        aLayoutVariant,

        iLocale,

        iLaf.iGfxA,

        iLaf.iTextA,

        iLaf.iTextB,

        iLaf.iTextC,

        iLaf.iIconA,

        iLaf.iIconB,

        aMidnightVisualization );

    TRACE_EXIT_POINT;

    }

// Destructor

CCalenDayListBoxModel::~CCalenDayListBoxModel()

    {

    TRACE_ENTRY_POINT;

    delete iTimeFormat;

    delete iItemTextArray;

    TRACE_EXIT_POINT;

    }

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

// CCalenDayListBoxModel::NewL

// Two-phased constructor.

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

//

CCalenDayListBoxModel* CCalenDayListBoxModel::NewL( const CCalenDayContainer* aDayContainer )

    {

    TRACE_ENTRY_POINT;

    CCalenDayListBoxModel* self =

        new( ELeave ) CCalenDayListBoxModel();

    CleanupStack::PushL( self );

    self->ConstructL( aDayContainer );

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenDayListBoxModel::?member_function

// ?implementation_description

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

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

//

CDesCArrayFlat* CCalenDayListBoxModel::ItemTextArray()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iItemTextArray;

    }

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

// CCalenDayListBoxModel::?member_function

// ?implementation_description

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

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

//

void CCalenDayListBoxModel::GetEntryTextDataL(CCalEntry& aEntry,

                                              TDes& aBuf) const

    {

    TRACE_ENTRY_POINT;

    const TInt maxLen( aBuf.MaxLength() - KTimedNoteMaxLines * KAknBidiExtraSpacePerLine );

    CalenViewUtils::GetSummaryLocationTextL( aEntry, aBuf, maxLen );

    TRACE_EXIT_POINT;

    }

#ifndef RD_CALEN_MIDNIGHT_VISUALIZATION

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

// CCalenDayListBoxModel::?member_function

// ?implementation_description

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

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

//

void CCalenDayListBoxModel::LimitStartAndEndTime(TTime& aCurrentDay,

                                                 TTime& aStart,

                                                 TTime& aEnd)

    {

    TRACE_ENTRY_POINT;

    TTimeIntervalDays days(aCurrentDay.DaysFrom(TTime(TInt64(0))));

    TTimeIntervalDays startDays(aStart.DaysFrom(TTime(TInt64(0))));

    TTimeIntervalDays endDays(aEnd.DaysFrom(TTime(TInt64(0))));

    // set start time to 00:00, if event starts before current day

    if (startDays != days)

        {

        aStart = TTime(TInt64(0)) + startDays;

        }

    // Set end time to 23:59, if event continues to next day

    if (endDays != days)

        {

        TDateTime endDate = aEnd.DateTime();

        endDate.SetHour(ECalenMaxHour);

        endDate.SetMinute(ECalenMaxMinute);

        aEnd = endDate;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenDayListBoxModel::?member_function

// ?implementation_description

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

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

//

void CCalenDayListBoxModel::InsertTimeL(TDes& aBuf,

                                        const TTime& aTime)

    {

    TRACE_ENTRY_POINT;

    TBuf<32> timeDes;

    aTime.FormatL( timeDes, *iTimeFormat );

    AknTextUtils::DisplayTextLanguageSpecificNumberConversion( timeDes );

    AknBidiTextUtils::ConvertToVisualAndClipL( timeDes,

                                               *iLaf.iTextA.Font(),

                                               iLaf.iTextA.TextRect().Width(),

                                               iLaf.iTextA.TextRect().Width() );

    aBuf.Append(timeDes);

    TRACE_EXIT_POINT;

    }

#else // Midnight is ON

void CCalenDayListBoxModel::InsertTimeL(TDes& aBuf, const TTime& aTime, const TTimeStringFormat aInsert)

    {

    TRACE_ENTRY_POINT;

    TBuf<32> timeDes;

    switch(aInsert)

        {

            case EInsertTimeGiven:

                aTime.FormatL( timeDes, *iTimeFormat );

                break;

            case EInsert00:

                timeDes = K24hFmt12am();

                break;

            case EInsert24:

                timeDes = K24hFmt12pm();

                break;

            default:

                ASSERT(KErrArgument);

        }

    AknTextUtils::DisplayTextLanguageSpecificNumberConversion( timeDes );

    AknBidiTextUtils::ConvertToVisualAndClipL( timeDes,

                                               *iLaf.iTextA.Font(),

                                               iLaf.iTextA.TextRect().Width(),

                                               iLaf.iTextA.TextRect().Width() );

    aBuf.Append(timeDes);

    TRACE_EXIT_POINT;

    }

#endif // RD_CALEN_MIDNIGHT_VISUALIZATION

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

// CCalenDayListBoxModel::?member_function

// ?implementation_description

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

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

//

#ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

void CCalenDayListBoxModel::InsertHyphenL(TDes& aBuf,

                                               const TTime& aStart,

                                               const TTime& aEnd)

#else // keep the old definition

void CCalenDayListBoxModel::InsertHyphen(TDes& aBuf,

                                               const TTime& aStart,

                                               const TTime& aEnd)

#endif //RD_CALEN_MIDNIGHT_VISUALIZATION

    {

    TRACE_ENTRY_POINT;

    if (aStart != aEnd)

        {

        TBuf<KHypenBufSize> hyphen;

        hyphen.Append(TChar(KPuaCodeNarrowDash));

#ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

        AknBidiTextUtils::ConvertToVisualAndClipL( hyphen,

                                              *iLaf.iTextB.Font(),

                                               iLaf.iTextB.TextRect().Width(),

                                               iLaf.iTextB.TextRect().Width() );

        aBuf.Append(hyphen);

#else

        aBuf.Append(hyphen);

#endif // RD_CALEN_MIDNIGHT_VISUALIZATION

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenDayListBoxModel::LastLineWidth

// Calculates a last line width

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

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

//

TInt CCalenDayListBoxModel::LastLineWidthL(TInt aWidth, CCalEntry& aEntry) const

    {

    TRACE_ENTRY_POINT;

    CCalAlarm* alarmObj = aEntry.AlarmL();

    TBool alarm( alarmObj ? ETrue : EFalse );

    delete alarmObj;

    TCalRRule ignore;

    TBool repeat(CalenAgendaUtils::IsRepeatingL(aEntry));

    TBool priority( EFalse );

    if( aEntry.EntryTypeL() == CCalEntry::ETodo &&

        aEntry.PriorityL() != ETodoPriorityNormal )

        {

        priority = ETrue;

        }

    // Check if this entry has any geovalues for the location field

    CCalGeoValue* geovalue = aEntry.GeoValueL();  

    TBool mapIcon( geovalue ? ETrue : EFalse);

    delete geovalue;

    TInt width( aWidth );

    // FIXME, actually these should be read from LAF!

    if( alarm && repeat || alarm && priority || repeat && priority || mapIcon && alarm || mapIcon && repeat || mapIcon && priority)

        {

        width = aWidth -( iLaf.iIconB.Rect().Width() + iLaf.iIconA.Rect().Width() );

        }

    else if( alarm || repeat || priority || mapIcon)

        {

            width = aWidth - iLaf.iIconA.Rect().Width();

        }

    width = width - KAknBidiExtraSpacePerLine;

    TRACE_EXIT_POINT;

    return width;

    }

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

// CCalenDayListBoxModel::WrapTextL

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

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

//

HBufC* CCalenDayListBoxModel::WrapTextL(

    CCalEntry& aEntry,

    CArrayFixFlat<TPtrC>& aLineArray) const

    {

    TRACE_ENTRY_POINT;

    // This is rather complicated algorithm to calculate how many

    // lines given text takes.

    //

    // (Note: in below description of problem and solution we for simplicity

    // consider only meeting entries with maximum of 4 lines of text, but

    // code handles Todos, Day Events and Anniversaries with max 1 line

    // of text. It should be easy to adapt it to have different maximum number

    // of lines.)

    //

    // As UI spec says, textual representation of entry

    // (subject + location) takes as many lines as it needs.

    // If it doesn't fit to maximum number of lines (4), it is

    // truncated.

    //

    // Problem is that last line of entry might contain less space for

    // text than previous lines, as it can contain icons for alarm, repeat

    // and priority. Because Avkon APIs for text wrapping and truncating

    // cannot handle situation, in which line count is not defined AND

    // last line length varies, we have to programmatically try

    // to wrap and fit text first to 1 line, then to 2 lines, then to

    // 3 lines and finally truncate it to 4 lines.

    TBool isTimed =

        aEntry.EntryTypeL() == CCalEntry::EAppt ||

        aEntry.EntryTypeL() == CCalEntry::EReminder;

    const TInt KMaxLines =

        isTimed ? KTimedNoteMaxLines : KNonTimedNoteMaxLines;

    const TInt KLineWidth = iLaf.iTextC.TextRect().Width();

    CArrayFixFlat<TInt>* lineWidths = new( ELeave )CArrayFixFlat<TInt>( 5 );

    CleanupStack::PushL( lineWidths );

    // last line width is always dependent on icons and is thus calculated.

    // We insert last line width to line widths buffer here, and try to fit

    // text to this single line. After that we always add line with normal

    // width BEFORE this last line.

    // I.e.

    //  1st try: { LastLineWidth }

    //  2nd try: { NormalLineWidth, LastLineWidth }

    //  3rd try: { NormalLineWidth, NormalLineWidth, LastLineWidth }

    //  ...

    lineWidths->AppendL( LastLineWidthL( KLineWidth, aEntry ) );

    // Get entry text

    HBufC* text = HBufC::NewLC( KMaxLengthOfDisplayedText );

    TPtr textPtr = text->Des();

    GetEntryTextDataL( aEntry, textPtr );

    // First we try to fit text to [1, max_lines - 1] (i.e. 1,2 or 3 lines)

    TBool doesFit = EFalse;

    HBufC* visualText = NULL;

    while ( ! doesFit && lineWidths->Count() < KMaxLines  )

        {

        // Convert*WholeTextL wraps all text, so that if it doesn't

        // fit to given lines, it uses last line width to wrap remaining

        // texts. This is useful, because we then know did it fit or not.

        //

        // Note that it constructs new text buffer (visualText) that

        // has to be destroyed, if it's not used. If it's used, this

        // text has to be returned to caller and caller takes care of

        // destroying. This memory management is unfortunately complicated,

        // so be careful if you modify.

        visualText  =

            AknBidiTextUtils::ConvertToVisualAndWrapToArrayWholeTextL(

            *text,

            *lineWidths,

            *iLaf.iTextC.Font(),

            aLineArray);

        CleanupStack::PushL( visualText );

        // If amount of splitted lines is same (or less than) currently

        // tried lines, we can fit text to this amount of lines.

        TInt triedLines = lineWidths->Count();

        if ( aLineArray.Count() <= triedLines )

            {

            doesFit = ETrue;

            // In case Avkon method wraps text to less lines than we tried

            // it means that text fits to less lines, but icons has to

            // be put to empty line after text!

            // We have to manually add that empty line.

            if ( aLineArray.Count() < triedLines )

                {

                aLineArray.AppendL( TPtrC(KNullDesC) );

                }

            break; // exit from loop, we could fit text.

            }

        else

            {

            // Release visualText buffer and reset line array, because

            // we couldn't fit text on this try.

            CleanupStack::PopAndDestroy( visualText );

            visualText = NULL;

            aLineArray.Reset();

            // Prepend normal line width, and try again with more lines.

            // (Note: last line width stays last, because we prepend)

            lineWidths->InsertL( 0, KLineWidth );

            }

        }

    HBufC* result = NULL;

    if ( doesFit )

        {

        // If we could fit, we return visualText and caller has

        // to memory manage it. TPtrs in aLineArray points to this text

        // buffer.

        result = visualText;

        CleanupStack::Pop( visualText );

        CleanupStack::PopAndDestroy( text );

        }

    else

        {

        // If we couldn't fit before, we wrap text to max lines and truncate

        // it with ellipsis.

        TInt triedLines = lineWidths->Count();

        // truncate and add ellipsis

        TPtr truncatedText = text->Des();

        const TBool KUseEllipsis = ETrue;

        AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

            truncatedText,

            *lineWidths,

            *iLaf.iTextC.Font(),

            aLineArray,

            KUseEllipsis );

        // In case Avkon method wrapped text to less lines than we tried

        // it means that text fits to less lines, but icons has to

        // be put to empty line after text!

        // We have to manually add that empty line.

        if ( aLineArray.Count() < triedLines )

            {

            aLineArray.AppendL( TPtrC(KNullDesC) );

            }

        // We return original text, because

        // AknBidiTextUtils::ConvertToVisualAndWrapToArrayL

        // modifies that and TPtrs in aLineArray points to that buffer

        result = text;

        CleanupStack::Pop( text );

        }

    CleanupStack::PopAndDestroy( lineWidths );

    TRACE_EXIT_POINT;