/*
* Copyright (c) 2003-2008 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:  Implementation of CMIDFont for series 60
*
*/


#include <eikenv.h>
#include <coemain.h>
#include <barsread.h>
#include <lcdui.rsg>
#include <fontids.hrh>
#include <gulfont.h>
// API used when font is created
#include <AknUtils.h>
#include <aknenv.h>
// API from CAknLayoutFont related to fonts
#include <AknLayoutFont.h>
#include <j2me/jdebug.h>
#include <aknlayoutscalable_avkon.cdl.h> // for layout data

#include "CMIDFont.h"
// API used for checking graphic scaling related parameters
#include "CMIDMenuHandler.h"
#include "CMIDUIManager.h"

// Indexes for the font size table below
enum TColumnIndexes
{
    EIndexScreenWidth  = 0,
    EIndexScreenHeight = 1,
    EIndexSmallFont    = 2,
    EIndexMediumFont   = 3,
    EIndexLargeFont    = 4,
    EResolutionCount   = 6
};

// Table including the font sizes for known S60 resolutions
// The order of the numbers in one table row:
// 1. screen width
// 2. screen height
// 3. small font height
// 4. medium font height
// 5. large font heigth
// This table must be updated when new resolutions become available in S60.
const TInt KFontSizes[EResolutionCount][5] =
{
    { 176, 208, 13, 15, 17 }, // Low
    { 240, 320, 19, 21, 24 }, // QVGA
    { 320, 480, 25, 28, 32 }, // HVGA
    { 352, 416, 26, 30, 34 }, // Double
    { 360, 640, 24, 27, 30 }, // nHD
    { 480, 640, 32, 36, 41 }  // VGA
};

// Constant for calculating the font heights when in graphic scaling case
// the original MIDlet resolution is smaller than any known S60 resolution.
// These are the averages of screen width / font height ratios of
// Low, QVGA, Double and HVGA resolutions.
const TReal KSmallFontRatioToScreenWidth  = 13.13;
const TReal KMediumFontRatioToScreenWidth = 11.58;
const TReal KLargeFontRatioToScreenWidth  = 10.18;

// Minimum font height. This is used as font height if calculated font
// height would be smaller than this.
const TInt KMinFontHeight = 11;

// Default value of iScalingFactor.
const TReal KNonScaled = 1.0;

// Zero size (0, 0).
#define KZeroSize ::TSize()

MMIDFont* CMIDFont::NewL(TUint aStyle, TUint aSize, TInt aFace,
                         CMIDUIManager* aUIManager, TBool aIsFreeSizeFont)
{
    CMIDFont* font = new(ELeave) CMIDFont(aUIManager);
    CleanupStack::PushL(font);
    font->ConstructL(aStyle, aSize, aFace, aIsFreeSizeFont);
    CleanupStack::Pop(font);
    return font;
}

CMIDFont::CMIDFont(CMIDUIManager* aUIManager)
        : iUIManager(aUIManager), iScalingFactor(KNonScaled)
{
}

/**
 * @return the MIDP font height - including external leading.
 */
TInt CMIDFont::Height()
{
    const CAknLayoutFont* layFont =  CAknLayoutFont::AsCAknLayoutFontOrNull(Font());
    // We are using only CAknLayoutFonts, so panic is raised if the layFont is null.
    ASSERT(layFont);
    return layFont->TextPaneHeight();
}

/**
 * @return vertical distance from top of font to the baseline.
 */
TInt CMIDFont::Baseline()
{
    return Font()->FontMaxAscent();
}

TInt CMIDFont::Width(const TDesC& aString)
{
    return Font()->TextWidthInPixels(aString);
}

CMIDFont::~CMIDFont()
{
    const CAknLayoutFont* layFont =  CAknLayoutFont::AsCAknLayoutFontOrNull(iFont);
    if (layFont)
    {
        delete layFont;
        iFont = NULL;
    }
}

void CMIDFont::ConstructL(TUint aStyle, TUint aSize, TInt /*aFace*/,
                          TBool aIsFreeSizeFont)
{
    // Ensure that menu handler exists. It will be needed later.
    iUIManager->OpenMenuHandlerL();

    // saving of flag iUnderline
    iUnderlined = aStyle & EUnderlined;

    // We don't need underline flag in aStyle.
    aStyle &= ~EUnderlined;

    // saving of size of font
    iSize = aSize;

    // saving iIsFreeSizeFont flag
    iIsFreeSizeFont = aIsFreeSizeFont;

    // saving of iBold flag
    if (aStyle & EBold)
    {
        iBold = ETrue;
    }
    else
    {
        iBold = EFalse;
    }

    // saving of iItalic flag
    if (aStyle & EItalic)
    {
        iItalic = ETrue;
    }
    else
    {
        iItalic = EFalse;
    }

    // seting of orginal size and scaling factor.
    SetOrigFontHeight();

    // checking of this is really resizible font
    if (iIsFreeSizeFont)
    {
        // In case of font with custom height simply set the same value as in iSize
        iPaneHeight = aSize;
    }
    else
    {
        // If is not downscaling on and this is not freely resizible font, then we use predefined size of font.
        iPaneHeight = GetTextPaneHeight(ETrue);
    }

    iFont = NULL;

    // creating of new iFont
    CreateNewFont();
}

const CFont* CMIDFont::DefaultFont(const TDefaultId& aId)
{
    if (aId == EDefaultTextId)
    {
        return AknLayoutUtils::FontFromId(
                   AknLayoutScalable_Avkon::form2_mdip_string_pane_t1(1,0).Font(), NULL);
    }
    else if (aId == EDefaultLabelId)
    {
        return AknLayoutUtils::FontFromId(
                   AknLayoutScalable_Avkon::form2_midp_label_pane_t1(0).Font(), NULL);
    }
    else
    {
        ASSERT(0); // unsupported default font id
        return NULL;
    }
}

// deprecated, use DefaultFont(EDefaultLabelId)
const CFont* CMIDFont::DefaultLabelFont()
{
    return DefaultFont(EDefaultLabelId);
}

/**
 * Returns iFont that is a pointer to CFont object.
 * Parameter aHighLevelUIComponent indicates whether this method has been called
 * from a non-high level ui component (Graphics), or a high level UI component (List, StringItem, etc.).
 */
CFont* CMIDFont::Font(TBool aHighLevelComponent)
{
    TBool useScaling = !aHighLevelComponent;

    TInt paneHeight;
    if (iIsFreeSizeFont)
    {
        // free size font is independent on resolution, so it should not be
        // re-created if resolution is changed
        paneHeight = iPaneHeight;
    }
    else
    {
        // standard font depends on resolution, if resolution is changed
        // pane height is changed too
        paneHeight = GetTextPaneHeight(useScaling);
    }

    // Check if the font size has changed e.g. because of the dynamic
    // resolution change. If so re-create the font.
    if (iPaneHeight != paneHeight)
    {
        iPaneHeight = paneHeight;
        CreateNewFont();
    }

    if (iFont)
    {
        return iFont;
    }
    else
    {
        // returns the default font if font creation has failed
        return const_cast<CFont*>(CMIDFont::DefaultFont(EDefaultTextId));
    }

}

/**
 * CreteNewFont function creates a new iFont object.
 * Font specification attributes are retrieved from the class member variables.
 */
void CMIDFont::CreateNewFont()
{
    // delete existing iFont object
    const CAknLayoutFont* layFont =  CAknLayoutFont::AsCAknLayoutFontOrNull(iFont);
    if (layFont)
    {
        delete layFont;
        iFont = NULL;
    }

    // init spec
    TAknFontSpecification spec(EAknLogicalFontSecondaryFont);
    // size
    spec.SetTextPaneHeight(iPaneHeight);
    // italic
    if (iItalic)
        spec.SetPosture(EPostureItalic);
    // bold
    if (iBold)
        spec.SetWeight(EStrokeWeightBold);

    TInt err = 0;
    DEBUG("CMIDFont::CreateNewFont - calling CreateLayoutFontFromSpecificationL");
    TRAP(err, iFont = AknLayoutUtils::CreateLayoutFontFromSpecificationL(spec));   // Now owned by the client code
    if (err != KErrNone)
    {
        DEBUG_INT("CMIDFont::CreateNewFont - Exception from AknLayoutUtils::CreateLayoutFontFromSpecificationL. Error = %d", err);
    }
}

TBool CMIDFont::IsUnderlined() const
{
    return iUnderlined;
}

void CMIDFont::Dispose()
{
    delete this;
}


/**
 * This function returns the height of the text pane for the current font size.
 * The text pane height value is retrieved from the LAF.
 * If the aScaling is true and graphic scaling is effective in current device screen,
 * the font height in the original MIDlet resolution is returned.
 */
TInt CMIDFont::GetTextPaneHeight(TBool aScaling)
{
    // iOrigFontHeight > 0 only when orignial MIDlet resolution has been defined in .jad
    if (aScaling && iOrigFontHeight > 0 &&
            iUIManager->GetMenuHandler()->IsScalingEffectiveInCurrentScreen())
    {
        return iOrigFontHeight;
    }

    TInt paneHeight;
    if (iSize == MMIDFont::ESmall)
    {
        //Small size is retrieved from the form item label LAF
        paneHeight = AknLayoutScalable_Avkon::form2_midp_label_pane_t1(0).H();
    }
    else if (iSize == MMIDFont::ELarge)
    {
        paneHeight = AknLayoutScalable_Avkon::form2_mdip_string_pane_t1(2,0).H();
    }
    else // EMedium
    {
        paneHeight = AknLayoutScalable_Avkon::form2_mdip_string_pane_t1(1,0).H();
    }

    return paneHeight;
}


void CMIDFont::SetOrigFontHeight()
{
    iOrigFontHeight = 0;

    if (!iUIManager->GetMenuHandler()->IsScalingEnabled())
    {
        return;
    }

    ::TSize origResolution =
        iUIManager->GetMenuHandler()->GetScalingParameterOrgMIDletScrSize();

    // ensure that resolution is in portrait orientation
    ::TSize resolution(Min(origResolution.iWidth, origResolution.iHeight),
                       Max(origResolution.iWidth, origResolution.iHeight));

    TInt fontSizeIndex = 0;
    switch (iSize)
    {
    case MMIDFont::ESmall:
        fontSizeIndex = EIndexSmallFont;
        break;
    case MMIDFont::EMedium:
        fontSizeIndex = EIndexMediumFont;
        break;
    case MMIDFont::ELarge:
        fontSizeIndex = EIndexLargeFont;
        break;
    default:
        break;
    }

    // These indexes are for the case that original resolution is not a known
    // resolution and font height needs to be calculated based on the font heights
    // in KFontSizes table.
    TInt smallerResolutionIndex = KErrNotFound;
    TInt biggerResolutionIndex = KErrNotFound;

    for (TInt i = 0; i < EResolutionCount && biggerResolutionIndex == KErrNotFound; ++i)
    {
        if (KFontSizes[i][EIndexScreenWidth] == resolution.iWidth)
        {
            iOrigFontHeight = KFontSizes[i][fontSizeIndex];
            return;
        }

        if (KFontSizes[i][EIndexScreenWidth] < resolution.iWidth)
        {
            smallerResolutionIndex = i;
        }
        else if (KFontSizes[i][EIndexScreenWidth] > resolution.iWidth &&
                 biggerResolutionIndex == KErrNotFound)
        {
            biggerResolutionIndex = i;
        }
    }

    // Orig resolution is not a known S60 resolution, need to calculate an estimate for
    // original font height based on the screen width of the original resolution.
    if (iOrigFontHeight == 0)
    {
        // First check if the original MIDlet resolution is smaller than any known
        // S60 resolution. If so, the original font height estimate is calculated
        // by using the KXXXFontRatioToScreenWidth constants.
        if (smallerResolutionIndex == KErrNotFound)
        {
            TReal fontSizeRatio = KSmallFontRatioToScreenWidth;

            switch (iSize)
            {
            case MMIDFont::ESmall:
                fontSizeRatio = KSmallFontRatioToScreenWidth;
                break;
            case MMIDFont::EMedium:
                fontSizeRatio = KMediumFontRatioToScreenWidth;
                break;
            case MMIDFont::ELarge:
                fontSizeRatio = KLargeFontRatioToScreenWidth;
                break;
            default:
                break;
            }

            iOrigFontHeight = TReal(resolution.iWidth) / fontSizeRatio;
            iOrigFontHeight = Max(KMinFontHeight, iOrigFontHeight);
        }
        else if (biggerResolutionIndex == KErrNotFound)
        {
            // Original screen width is bigger than the highest resolution in the KFontSizes table.
            // Use the font size defined for the highest resolution in the table.
            iOrigFontHeight = KFontSizes[EResolutionCount - 1][fontSizeIndex];
        }
        else
        {
            // The screen width of the original MIDlet resolution is between 2 known S60 screen
            // widths. Calculate estimate for font height based on the heights of the 2 known resolutions.
            TReal fontHeightDelta = KFontSizes[biggerResolutionIndex][fontSizeIndex] -
                                    KFontSizes[smallerResolutionIndex][fontSizeIndex];

            TReal screenWidthDelta = KFontSizes[biggerResolutionIndex][EIndexScreenWidth] -
                                     KFontSizes[smallerResolutionIndex][EIndexScreenWidth];

            TReal origScreenWidthDelta = resolution.iWidth -
                                         KFontSizes[smallerResolutionIndex][EIndexScreenWidth];

            iOrigFontHeight = KFontSizes[smallerResolutionIndex][fontSizeIndex] +
                              ((origScreenWidthDelta / screenWidthDelta) *
                               fontHeightDelta);
        }
    }
}

/**
 * @return ETrue if font is bold, EFalse if not.
 */
TBool CMIDFont::IsBold()
{
    return iBold;
}

/**
 * @return ETrue if font is italic, EFalse if not.
 */
TBool CMIDFont::IsItalic()
{
    return iItalic;
}
// End of File