/*
* Copyright (c) 2002-2004 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:
*
*/
#ifndef AKNLAYOUT2SCALABLEDEF_H
#define AKNLAYOUT2SCALABLEDEF_H
#include <e32std.h>
#include <avkon.hrh>
#include "AknLayout2Def.h"
class TAknLayoutRect;
/*
* this is in global namespace, as it needs to be used by multiple different classes
*/
enum TAknLayoutScalableComponentType
{
EAknLayoutScalableComponentTypeUnknown,
EAknLayoutScalableComponentTypeScreen,
EAknLayoutScalableComponentTypeContainer,
EAknLayoutScalableComponentTypePane,
EAknLayoutScalableComponentTypeGraphic,
EAknLayoutScalableComponentTypeText
};
/**
* Defines the valid range of a table lookup index.
* A table index is valid if it satisfies iFirstIndex <= index <= iLastIndex
*/
class TAknLayoutScalableTableLimits
{
public:
IMPORT_C TAknLayoutScalableTableLimits();
IMPORT_C TAknLayoutScalableTableLimits(TInt aFirstIndex, TInt aLastIndex);
IMPORT_C TAknLayoutTableLimits LayoutLimits() const;
IMPORT_C TInt FirstIndex() const;
IMPORT_C TInt LastIndex() const;
IMPORT_C void SetFirstIndex(TInt aIndex);
IMPORT_C void SetLastIndex(TInt aIndex);
private:
TInt iFirstIndex;
TInt iLastIndex;
};
/**
* Defines the valid maximum value of the parameters that can be passed into a scalable layout API
* An index is valid if it satisfies index < iMaxVarietys etc
*/
class TAknLayoutScalableParameterLimits
{
public:
IMPORT_C TAknLayoutScalableParameterLimits();
IMPORT_C TAknLayoutScalableParameterLimits(
TInt aFirstVariety, TInt aLastVariety,
TInt aFirstColumn, TInt aLastColumn,
TInt aFirstRow, TInt aLastRow);
IMPORT_C TInt FirstVariety() const;
IMPORT_C TInt LastVariety() const;
IMPORT_C TInt FirstColumn() const;
IMPORT_C TInt LastColumn() const;
IMPORT_C TInt FirstRow() const;
IMPORT_C TInt LastRow() const;
IMPORT_C void SetFirstVariety(TInt FirstVariety);
IMPORT_C void SetLastVariety(TInt LastVariety);
IMPORT_C void SetFirstColumn(TInt aFirstColumn);
IMPORT_C void SetLastColumn(TInt aLastColumn);
IMPORT_C void SetFirstRow(TInt aFirstRow);
IMPORT_C void SetLastRow(TInt aLastRow);
private:
TInt iFirstVariety;
TInt iLastVariety;
TInt iFirstColumn;
TInt iLastColumn;
TInt iFirstRow;
TInt iLastRow;
};
class TAknTextComponentLayout;
struct TAknTextComponentLayoutAttrs;
class TAknTextLineLayout;
/**
* A window component structure from scalable layout.
*
* The data members of this class have the following invariants which must be preserved in any methods
* of this class.
*
* il + iW + ir = parentRect.Width()
* it + iH + ib = parentRect.Height()
*
* The data format of the data members are as follows: (AknLayoutUtils knows this)
* any of il,iW,ir, it,iH,ib may be one of the following
* 1) coordinate value
* 2) ELayoutEmpty
* 3) ELayoutP - value
*/
class TAknWindowComponentLayout
{
public:
/**
* contructor
*
*/
IMPORT_C TAknWindowComponentLayout();
/*
* create a layout line using the old layout API structure
*
* @return layout line
*/
IMPORT_C TAknWindowLineLayout LayoutLine() const;
/*
* create a layout line using the old layout API structure
* such that the values are all non-empty
*
* @return layout line
*/
IMPORT_C TAknWindowLineLayout LayoutLineNoEmptys() const;
/*
* Return the type of the component, as specified in the layout
* Note that a TAknWindowComponentLayout is data layout
* compatible with TAknTextComponentLayout, and the actual
* type can be accessed using this method before casting.
* However, casting to the wrong type may cause unexpected results.
*
* @return the type of the component
*
*/
IMPORT_C TAknLayoutScalableComponentType LayoutComponentType() const;
private:
// note that the following get and set methods do not follow coding conventions
// this is to increase source compatibility with existing implementation
// that directly accesses the public members of the corresponding non-scalable
// data structures. also note that the parameter names don't follow coding conventions,
// this is to maintain consistency with the layout specifications.
// also note that they are not inline so that they can be modified
// for dynamic layout calculation without breaking BC.
IMPORT_C TInt16 C() const;
IMPORT_C TInt16 l() const;
IMPORT_C TInt16 t() const;
IMPORT_C TInt16 r() const;
IMPORT_C TInt16 b() const;
IMPORT_C TInt16 W() const;
IMPORT_C TInt16 H() const;
IMPORT_C void SetC(TInt16 aC);
IMPORT_C void Setl(TInt16 al);
IMPORT_C void Sett(TInt16 at);
IMPORT_C void Setr(TInt16 ar);
IMPORT_C void Setb(TInt16 ab);
IMPORT_C void SetW(TInt16 aW);
IMPORT_C void SetH(TInt16 aH);
public:
/*
* Compose two window lines together
* note that this is not commutative, line2 should lie inside line1
*
* Compose puts two layout lines together in the following way:
* TRect --aLine1--> TRect --aLine2--> TRect
*
* becomes
* TRect --------result--------------> TRect
*
* The arrow direction points towards smaller rectangles.
*
* The rectangle in the middle gets hidden and is shared by aLine1 and aLine2 in such way that
* aLine1's child rectangle becomes parent rectangle of aLine2.
*
* Compose() works pretty well with AknLayoutUtils. Here's two equivalent code pieces:
* 1) Chain of 2 AknLayoutUtils calls
* TAknLayoutRect rect;
* rect.LayoutRect(parent1, AknLayoutScalable::xxxx1().LayoutLine());
* TAknLayoutRect rect2;
* rect2.LayoutRect(rect.Rect(), AknLayoutScalable::xxxx2().LayoutLine());
* ... use rect2.Rect()....
* 2) Compose + one AknLayoutUtils call
* TAknWindowLineLayout combined = Compose(AknLayoutScalable::xxxx1(), AknLayoutScalable::xxxx2()).LayoutLine();
* TAknLayoutRect rect2;
* rect2.LayoutRect(parent1, combined);
* ... use rect2.Rect()...
*
* The only differences between the two pieces of code is that the version (2)
* cannot use rect.Rect() for positioning any CCoeControl's or drawable elements.
* Compose() hides that rectangle completely and it is no longer accessible.
*
* Compose() works without the parent rectangle! In the version (1), the
* parent rectangle must be provided at beginning. In version (2), the parent
* rectangle is provided after combining two layout lines; This property of Compose() allows
* us to use it in adaptation layer where parent rectangle is not always known.
*
* Compose() is associative. Compose(x,Compose(y,z)) == Compose(Compose(x,y),z).
*
* Mathematically, Compose() corresponds to function composition for TRect f(TRect) -type functions.
*
* Compose() implementation generates values for TAknWindowComponentLayout which are not coordinates:
* 1) any of l,t,r,b,W,H may become ELayoutEmpty
* 2) any of l,t,r,b,W,H may become ELayoutP - XX, where XX is some number.
* This is why the data members of TAknWindowComponentLayout (or TAknWindowLineLayout) should not be accessed.
* AknLayoutUtils and all related classes which access these values must handle these cases.
*
* Compose() implementation preserves some invariants of TAknWindowComponentLayout
* l+W+r = p.W
* t+H+b = p.H
*
* @param aLine1 window line
* @param aLine2 window line
*/
IMPORT_C static TAknWindowComponentLayout Compose(TAknWindowComponentLayout aLine1, TAknWindowComponentLayout aLine2);
/*
* compose a window line with a text line
* note that this is not commutative, line2 should lie inside line1
*
* ComposeText puts two layout lines together in the following way:
* TRect --aLine1--> TRect --aLine2--> Text
*
* becomes
* TRect --------result--------------> Text
*
* ComposeText() is associative. ComposeText(x,ComposeText(y,z)) = ComposeText(Compose(x,y),z).
*
* @param aLine1 window line
* @param aLine2 text line
*/
IMPORT_C static TAknTextComponentLayout ComposeText(TAknWindowComponentLayout aLine1, TAknTextComponentLayout aLine2);
/*
* intersect two layout lines that share the same parent rectangle
*
* Intersect combines two layout lines in such way that
* a) their parent rectangles will become the same rectangle
* b) the child rectangle is intersection of the child rectangles of aLine and aLine2
*
* Intersect can fail if the rectangles have no overlap. This can be detected by negative
* values in resulting TAknWindowComponentLayout.
*
* @param aLine
* @param aLine2
*/
IMPORT_C static TAknWindowComponentLayout Intersect(TAknWindowComponentLayout aLine, TAknWindowComponentLayout aLine2);
/**
* subtract two layout lines relative to the same parent rectangle
*
* Minus combines two layout lines in such way that
* a) the result is aLine with it's parent rectangle changed
* b) aLine and aParentDiff's parent rectangles becomes the same; and result's parent rectangle is calculated to be aParentDiff's child rectangle.
*
* @param aLine the inner rect
* @param aParentDiff the difference between the parent and the inner rect
*/
IMPORT_C static TAknWindowComponentLayout Minus(TAknWindowComponentLayout aLine, TAknWindowComponentLayout aParentDiff);
/**
* Treat two layout lines as if one is a child of the other.
* The two layouts must have the same parent.
* They must also have the same pattern of absolute, ElayoutEmptys and Parent relative
* measurements, both vertically and horizontally.
*
* @param aSiblingTreatedAsParent
* @param aSiblingTreatedAsChild
*
* @return a layout representing aSiblingTreated as child, relative to aSiblingTreatedAsParent
*/
IMPORT_C static TAknWindowComponentLayout SiblingAsChild(TAknWindowComponentLayout aSiblingTreatedAsParent, TAknWindowComponentLayout aSiblingTreatedAsChild);
/**
* Makes the window zero-sized, positioned in the top left corner.
*/
IMPORT_C void SetZeroSized();
/**
* This method splits parent rectangle to one of the 9 pieces based on aLine.
*
* aValue is one of the numbers:
* 0 1 2
* 3 4 5
* 6 7 8
* This is highly related to "frames" in skins. This allows us to generate a skin frame definition
* from a single TAknWindowComponentLayout.
*/
IMPORT_C static TAknWindowComponentLayout Split(TAknWindowComponentLayout aLine, TInt aValue);
/**
* This method calculates a grid item position in based on first cell.
*
*/
IMPORT_C static TAknWindowComponentLayout MultiLineGrid(TAknWindowComponentLayout aFirst, TInt aColumnIndex, TInt aRowIndex, TInt aGapBetweenColumns, TInt aGapBetweenRows);
/**
* This method calculates a grid item position in X-dimension based on first cell.
*
*/
IMPORT_C static TAknWindowComponentLayout MultiLineX(TAknWindowComponentLayout aFirst, TInt aColumnIndex, TInt aGapBetweenColumns);
/**
* This method calculates a list item position based on first item.
* This can be used to calculate either list item positions or grid cell Y-positions.
*/
IMPORT_C static TAknWindowComponentLayout MultiLineY(TAknWindowComponentLayout aFirst, TInt aItemIndex, TInt aGapBetweenItems);
public:
struct TRangeTriplet;
IMPORT_C static TAknWindowComponentLayout Anim(TAknWindowComponentLayout aLine,
TAknWindowComponentLayout aLine2,
const TRangeTriplet &aTriplet);
IMPORT_C TAknWindowComponentLayout( TAknWindowLineLayout aLine );
IMPORT_C TAknWindowComponentLayout operator=( TAknWindowLineLayout aLine );
public:
static void FormFieldHack(TAknWindowComponentLayout &aLayout) { aLayout.SetH(ELayoutEmpty); }
static void ListGenPaneHack(TAknWindowComponentLayout &aLayout) { aLayout.Setl(0); aLayout.Sett(0); }
static TAknWindowComponentLayout ListPaneHack(const TAknWindowComponentLayout &aLayout, const TAknWindowComponentLayout aListGenPane)
{
TAknWindowComponentLayout layout = aLayout;
TAknWindowComponentLayout l3 = aListGenPane; // 0 = find pane on
TAknWindowComponentLayout &aLine1 = layout;
if (aLine1.r() == ELayoutEmpty)
{
aLine1.Setr( TInt16(ELayoutP - aLine1.W() - aLine1.l()));
}
if (aLine1.b() == ELayoutEmpty)
{
aLine1.Setb(TInt16(ELayoutP - aLine1.H() - aLine1.t()));
}
if (aLine1.l() == ELayoutEmpty)
{
aLine1.Setl(TInt16(ELayoutP - aLine1.W() - aLine1.r()));
}
if (aLine1.t() == ELayoutEmpty)
{
aLine1.Sett(TInt16(ELayoutP - aLine1.H() - aLine1.b()));
}
if (aLine1.W() == ELayoutEmpty)
{
aLine1.SetW(TInt16(ELayoutP - aLine1.l() - aLine1.r()));
}
if (aLine1.H() == ELayoutEmpty)
{
aLine1.SetH(TInt16(ELayoutP - aLine1.t() - aLine1.b()));
}
layout.il = TInt16(layout.il + l3.il);
layout.it = TInt16(layout.it + l3.it);
layout.ib = ELayoutEmpty;
layout.ir = ELayoutEmpty;
return layout;
}
// this is a method to get the arrowhead scroll indicators working.
// aDirection is the nudge button direction, 1 = up, 2 = down.
static void ScrollIndicatorHack( const TAknWindowComponentLayout& aWidthHeightLayout,
TAknWindowComponentLayout& aParent,
TAknWindowComponentLayout& aLayout,
TInt aDirection)
{
aParent.SetW( aWidthHeightLayout.W() );
aLayout.Setl( aParent.W() / 2 - aParent.W() / 39 );
if (aDirection == 0)
{
aLayout.Sett( 0 );
aLayout.SetH( ( aWidthHeightLayout.H() - aParent.t() ) / 2);
}
else
{
aLayout.Sett( ( aWidthHeightLayout.H() - aParent.t() ) / 2 );
aLayout.SetH( ( aWidthHeightLayout.H() - aParent.t() ) / 2 );
}
aLayout.SetW( aParent.W() - 2 * aLayout.l() );
}
private:
// structural information
TInt16 iFirstChildID;
TInt16 iNextSiblingID;
TInt16 iParentID;
TInt16 iParentVariety;
TInt16 iAttributeSetID;
TInt16 iType;
// the following entries are the layout data
TInt16 iC;
TInt16 il;
TInt16 it;
TInt16 ir;
TInt16 ib;
TInt16 iW;
TInt16 iH;
// the following entries are to force this structure to be castable to TAknTextComponentLayout
TInt16 iReserved1;
TInt16 iReserved2;
TInt16 iReserved3;
private:
static TAknWindowComponentLayout RemoveLayoutEmptys(TAknWindowComponentLayout aLine1);
static TAknWindowComponentLayout ExtractWindow(TAknTextComponentLayout aText);
static TAknTextComponentLayout CombineAttrs(TAknWindowComponentLayout aLine1, const TAknTextComponentLayoutAttrs &aAttrs);
friend class TAknTextComponentLayout;
public:
struct TRangeTriplet
{
TInt16 iX; // 0.0 .. 1.0, scaled by 12 bits.
TInt16 iY; // 0.0 .. 1.0
TInt16 iP;
};
private:
class TScaledInt
{
public:
TScaledInt(TInt32 aValue) : iValue(aValue) { }
friend inline TScaledInt operator*(TScaledInt aValue, TScaledInt aValue2)
{
return TInt16( (aValue.Value() * aValue2.Value()) >> 12 );
}
friend TScaledInt MultiplyByScaled(TInt16 aValue, TScaledInt aValue2)
{
return TInt32( TInt32(aValue) * TInt32(aValue2.Value()) );
}
TInt16 NonScaled() { return TInt16(iValue >> 12); }
TInt32 Value() { return iValue; }
private:
TInt32 iValue;
};
static TInt16 MultiplyValue(TInt16 aValue, TScaledInt aMultiplier, TScaledInt aPMultiplier);
struct TTriplet
{
TTriplet(const TTriplet &aValue);
TTriplet(TInt16 aX, TInt16 aY, TInt16 aP);
TScaledInt iX;
TScaledInt iY;
TScaledInt iP;
};
static TAknWindowComponentLayout Multiply(TAknWindowComponentLayout aLine1, const TTriplet &aTriplet);
static TTriplet FromRangeToTriplet(const TRangeTriplet &aRange);
};
/**
* A text component structure from layout.
*/
class TAknTextComponentLayout
{
public:
/**
* contructor
*
*/
IMPORT_C TAknTextComponentLayout();
/*
* create a layout line using the old layout API structure
* note that the B value will contain the b value and may be parent relative
* note also that the fontId will be encoded
* see AknFontSpecification and AknLayoutUtils for helper methods
*
* @return layout line
*/
IMPORT_C TAknTextLineLayout LayoutLine() const;
IMPORT_C static TAknMultiLineTextLayout Multiline(const RArray<TAknTextComponentLayout> &aLayouts);
/*
* create a layout line using the old layout API structure
* such that the values are all non-empty
*
* @return layout line
*/
IMPORT_C TAknTextLineLayout LayoutLineNoEmptys() const;
/*
* Return the type of the component, as specified in the layout
* Note that a TAknWindowComponentLayout is data layout
* compatible with TAknTextComponentLayout, and the actual
* type can be accessed using this method before casting.
* However, casting to the wrong type may cause unexpected results.
*
* @return the type of the component
*
*/
IMPORT_C TAknLayoutScalableComponentType LayoutComponentType() const;
public:
// note that the following get and set methods do not follow coding conventions
// this is to increase source compatibility with existing implementation
// that directly accesses the public members of the corresponding non-scalable
// data structures. also note that the parameter names don't follow coding conventions,
// this is to maintain consistency with the layout specifications.
// also note that they are not inline so that they can be modified
// for dynamic layout calculation without breaking BC.
IMPORT_C TInt16 C() const;
IMPORT_C TInt16 l() const;
IMPORT_C TInt16 t() const;
IMPORT_C TInt16 r() const;
IMPORT_C TInt16 b() const;
IMPORT_C TInt16 W() const;
IMPORT_C TInt16 H() const;
IMPORT_C TInt16 J() const;
IMPORT_C TInt32 Font() const;
IMPORT_C void SetC(TInt16 aC);
IMPORT_C void Setl(TInt16 al);
IMPORT_C void Sett(TInt16 at);
IMPORT_C void Setr(TInt16 ar);
IMPORT_C void Setb(TInt16 ab);
IMPORT_C void SetW(TInt16 aW);
IMPORT_C void SetH(TInt16 aH);
IMPORT_C void SetJ(TInt16 aJ);
IMPORT_C void SetFont(TInt32 aFont);
public:
IMPORT_C static TAknTextComponentLayout Anim(TAknTextComponentLayout aLine,
TAknTextComponentLayout aLine2,
const TAknWindowComponentLayout::TRangeTriplet &aTriplet);
/**
* This method calculates a list item position based on first item.
* This can be used to calculate list item positions.
*/
IMPORT_C static TAknTextComponentLayout MultiLineY(TAknTextComponentLayout aFirst, TInt aItemIndex, TInt aGapBetweenItems);
IMPORT_C TAknTextComponentLayout( TAknTextLineLayout aLine );
IMPORT_C TAknTextComponentLayout operator=(TAknTextLineLayout aLine);
public:
static TInt FormDataHack(TAknTextComponentLayout aLayout)
{
aLayout = RemoveLayoutEmptys(aLayout);
return ELayoutP - aLayout.it - aLayout.iH;
}
static void FormDataHack2(TAknTextComponentLayout &aLayout)
{
aLayout.ib = ELayoutEmpty;
}
private:
IMPORT_C static TAknTextComponentLayout RemoveLayoutEmptys(TAknTextComponentLayout aLayout);
private:
// structural information
TInt16 iFirstChildID;
TInt16 iNextSiblingID;
TInt16 iParentID;
TInt16 iParentVariety;
TInt16 iAttributeSetID;
TInt16 iType;
// the following entries are the layout data
TInt16 iC;
TInt16 il;
TInt16 it;
TInt16 ir;
TInt16 ib; // note that this is bottom, not baseline
TInt16 iW;
TInt16 iH;
// the following entries are specific to text components
TInt16 iJ;
mutable TInt32 iFont;
};
#endif
// End of File