/*

* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

* which accompanies this distribution, and is available

* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Defines a public static class AknsDrawUtils and related 

*                constants.

*

*/

#ifndef AKNSDRAWUTILS_H

#define AKNSDRAWUTILS_H

// INCLUDES

#include <AknsUtils.h>

// CONSTANTS

/**

* Default value for drawing parameters.

*

* @since 2.0

*/

static const TInt KAknsDrawParamDefault                 = 0x0;

/**

* Drawing parameter that limits processing of layout levels to the first one.

* This can be used to temporarily disable secondary layout levels.

*

* @since 2.0

*/

static const TInt KAknsDrawParamLimitToFirstLevel       = 0x1;

/**

* Drawing parameter that suspends clearing under images. Only the first

* layout level is affected.

*

* @since 2.0

*/

static const TInt KAknsDrawParamNoClearUnderImage       = 0x2;

/**

* Drawing parameter that causes the layouts and bitmaps to be prepared,

* but no actual drawing takes place.

*

* @since 2.8

*/

static const TInt KAknsDrawParamPrepareOnly             = 0x04;

/**

* Drawing parameter that draws only the RGB channel of data.

*

* @since 3.0

*/

static const TInt KAknsDrawParamRGBOnly                 = 0x8;

/**

* Drawing parameter that draws only the alpha channel of data. If the data

* is unmasked, the result is undefined.

*

* @since 3.0

*/

static const TInt KAknsSDMAlphaOnly                     = 0x10;

/**

* Drawing parameter that allows empty SCALABLEITEMS to use

* the parent bitmap directly

*

* @since 3.0

*/

static const TInt KAknsDrawParamChained                     = 0x20;

/**

* Forces drawing the bottom level in chain to use RGBOnly. Bottom level is the

* first drawn level, visually the bottom most level.

*

* @since 3.0

*/

static const TInt KAknsDrawParamBottomLevelRGBOnly            = 0x40;

/**

* Ignores layer mask when drawing layers.

*

* @since 3.2

*/

static const TInt KAknsDrawParamIgnoreLayerMask               = 0x80;

/**

* Direction, from where notes and queries slide to the screen.

*

* @since 3.1

*/

enum TSlidingMode

    {

    /** Sliding is disabled either by skin or compile time */

    ESlidingDisabled = 0,

    /** Slide from the CBA side */

    ESlidingFromCBA,

    /** Slide from left */

    ESlidingFromLeft,

    /** Slide from topleft */

    ESlidingFromTopLeft, 

    /** Slide from top */

    ESlidingFromTop,

    /** Slide from topright */

    ESlidingFromTopRight, 

    /** Slide from right */

    ESlidingFromRight, 

    /** Slide from bottomright */

    ESlidingFromBottomRight, 

    /** Slide from bottom */

    ESlidingFromBottom, 

    /** Slide from bottomleft */

    ESlidingFromBottomLeft,

    /** Slide from random direction (any of the 8 directions) */

    ESlidingFromRandom

    };

// FORWARD DECLARATIONS

class MAknsSkinInstance;

class MAknsControlContext;

class CWindowGc;

class CFbsBitGc;

class CCoeControl;

// CLASS DECLARATION

/**

* Static utility class to support Avkon Skins drawing operations.

* AknsDrawUtils provides utility methods to perform skin-aware drawing

* operations, such as background drawing.

*

* This is a public static class with exported functions.

* The class is not intended for derivation outside the library.

*

* @lib AknSkins.lib

*

* @since 2.0

*/

class AknsDrawUtils

    {

    public: // New functions        

        /**

        * Returns pointer to the current control context.

        * If aMop parameter is specified retrieves the nearest control context

        * in control hierarchy. If none is found (or @c NULL parameter was

        * given) returns @c NULL.

        *

        * @since 2.0

        *

        * @param aMop Object provider to be used to find the control context

        *   or @c NULL.

        *

        * @return Pointer to the nearest control context or @c NULL if none 

        *   was found.

        */

        IMPORT_C static MAknsControlContext* ControlContext( 

            const MObjectProvider* aMop );

        /**

        * Returns pointer to the control context of the parent of the given

        * control. The context possibly supplied by the control itself is ignored.

        *

        * @since 2.6

        *

        * @param aControl Pointer to CCoeControl or @c NULL.

        *

        * @return Pointer to the nearest control context of the parent control

        *   or @c NULL if none was found.

        */

        IMPORT_C static MAknsControlContext* ControlContextOfParent( 

            const CCoeControl* aControl );

        /**

        * Draws background with assumed origin.

        * Draws bacground to the specified rectangle. Origin is assumed

        * to be (0,0). This overload can not be used with parent absolute 

        * layouts.

        *

        * See @c DrawBackground for details on chained layouts.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. If @c NULL and skin

        *   instance was given, default parameters are used.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aRect Rectangle to be drawn.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise.

        */

        IMPORT_C static TBool Background( MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, CWindowGc& aGc, const TRect& aRect );

        /**

        * Draws background with proper origin.

        * Draws bacground to the specified rectangle. The origin is queried

        * from the control position list (if given using 

        * AknsUtils::RegisterControlPosition). If not found, the origin is

        * queried from the given control, which may result in a window server

        * flush.

        *

        * See @c DrawBackground for details on chained layouts.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. Must be specified, if

        *   aInstance is not @c NULL.

        *

        * @param aControl Control that knows the current window.

        *   Must be specified if parent absolute layout can be used,

        *   otherwise @c NULL may be given.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aRect Rectangle to be drawn.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool Background( MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, const CCoeControl* aControl,

            CWindowGc& aGc, const TRect& aRect );

        /**

        * Draws background with proper origin and drawing parameters.

        * Draws bacground to the specified rectangle. The origin is queried

        * from the control position list (if given using 

        * AknsUtils::RegisterControlPosition). If not found, the origin is

        * queried from the given control, which may result in a window server

        * flush. Drawing parameters may be used to control drawing.

        *

        * See @c DrawBackground for details on chained layouts.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. Must be specified, if

        *   aInstance is not @c NULL.

        *

        * @param aControl Control that knows the current window.

        *   Must be specified if parent absolute layout can be used,

        *   otherwise @c NULL may be given.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aRect Rectangle to be drawn.

        *

        * @param aDrawParam Bitwise combination of drawing parameters. 

        *   @c KAknsDrawParamDefault should be used if no special handling 

        *   is required.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool Background( MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, const CCoeControl* aControl,

            CWindowGc& aGc, const TRect& aRect, const TInt aDrawParam );

        /**

        * Draws background to the given graphics context.

        * The origin is queried from the control position list (if given using

        * AknsUtils::RegisterControlPosition). If not found, the origin is

        * queried from the given control, which may result in a window server

        * flush.

        *

        * If background contains multiple layers, they are drawn in the

        * sequence specified by the context. If multiple contexts are chained

        * (using @c SetParentContext), they are drawn in reverse order, i.e.

        * the context given as parameter to this method call is drawn last.

        *

        * Drawing parameter KAknsDrawParamNoClearUnderImage is automatically

        * assumed for all the chained contexts, except the deepest one.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. Must be specified, if

        *   aInstance is not @c NULL.

        *

        * @param aControl Control that knows the current window.

        *   Must be specified if parent absolute layout can be used,

        *   otherwise @c NULL may be given.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aDstPos Destination position (top-left corner of the area

        *   to be drawn) in graphics context coordinate system.

        *

        * @param aControlRect Rectangle (in the control coordinate system) 

        *   to be drawn.

        *

        * @param aDrawParam Bitwise combination of drawing parameters. 

        *   @c KAknsDrawParamDefault should be used if no special handling 

        *   is required.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool DrawBackground( MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, const CCoeControl* aControl,

            CBitmapContext& aGc, const TPoint& aDstPos,

            const TRect& aControlRect, const TInt aDrawParam );

        /**

        * Draws background between rects.

        * Draws bacground between specified rectangles. Origin is assumed

        * to be (0,0).

        *

        * See @c DrawBackground for details on chained layouts.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. If @c NULL and skin

        *   instance was given, default parameters are used.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aOuterRect Outer rectangle.

        *

        * @param aInnerRect Inner rectangle.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool BackgroundBetweenRects( 

            MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, CWindowGc& aGc, 

            const TRect& aOuterRect,const TRect& aInnerRect );

        /**

        * Draws background between rects.

        * Draws bacground between specified rectangles. 

        *

        * See @c DrawBackground for details on chained layouts.

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. Must be specified if

        *   aInstance is not @c NULL.

        *

        * @param aControl Control that knows the current window.

        *   Must be specified if parent absolute layout can be used,

        *   otherwise @c NULL may be given.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aOuterRect Outer rectangle.

        *

        * @param aInnerRect Inner rectangle.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool BackgroundBetweenRects( 

            MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, const CCoeControl* aControl, 

            CWindowGc& aGc, 

            const TRect& aOuterRect,const TRect& aInnerRect );

        /**

        * Draws background between rects.

        * Draws bacground between specified rectangles with drawing parameters. 

        *

        * @since 2.0

        *

        * @param aInstance Pointer to skin instance as obtained from

        *   AknsUtils::SkinInstance(). If @c NULL rectangle is cleared

        *   without bitmap.

        *

        * @param aContext Control context to obtain context specific 

        *   information about background drawing. Must be specified if

        *   aInstance is not @c NULL.

        *

        * @param aControl Control that knows the current window.

        *   Must be specified if parent absolute layout can be used,

        *   otherwise @c NULL may be given.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aOuterRect Outer rectangle.

        *

        * @param aInnerRect Inner rectangle.

        *

        * @param aDrawParam Bitwise combination of drawing parameters. 

        *   @c KAknsDrawParamDefault should be used if no special handling 

        *   is required.

        *

        * @return ETrue if background was drawn with a bitmap, EFalse

        *   otherwise. Note that many scalable skins implicitly define

        *   background bitmaps for seemingly blank areas.

        */

        IMPORT_C static TBool BackgroundBetweenRects( 

            MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext, const CCoeControl* aControl, 

            CWindowGc& aGc, 

            const TRect& aOuterRect, const TRect& aInnerRect, 

            const TInt aDrawParam );

        /**

        * Determines whether background drawing would be done with

        * a bitmap (deprecated).

        *

        * @param aInstance Pointer to skin instance. If @c NULL,

        *   method returns EFalse.

        *

        * @param aContext Control context, or @c NULL if no context 

        *   is used. Note that absence of control context affects

        *   the result.

        *

        * @return @c ETrue if background would be drawn with a bitmap,

        *   @c EFalse otherwise. If a scalable skin is currently active,

        *   the return value is undefined, and does not necessarily

        *   reflect the return value of the actual drawing operation.

        *

        * @deprecated This method is deprecated as of release 2.8.

        *   Use the return values of background drawing functions to

        *   determine whether the background was drawn with skinned

        *   content. The return value is always ETrue starting from

        *   rel 3.1

        */

        IMPORT_C static TBool HasBitmapBackground(

            MAknsSkinInstance* aInstance,

            MAknsControlContext* aContext );

        /**

        * Draws a cached image (with its attributes specified in the skin)

        * to the given rectangle.

        *

        * @param aInstance Pointer to the skin instance. If @c NULL,

        *   the method returns immediately.

        *

        * @param aGc Graphics context to be used for drawing.

        *

        * @param aRect Rectangle specifying the pane used for drawing. The

        *   image is laid out within the rectangle.

        *

        * @param aID Item ID of the image to be drawn.

        */