/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#ifndef ESWTGRAPHICS_H

#define ESWTGRAPHICS_H

#include <e32base.h>

#include "eswt.h"

class MSwtGc;

class TRequestStatus;

/**

 * Utility base class for managing reference-counted objects

 */

class MSwtRefCounted

{

protected:

    inline MSwtRefCounted();

    virtual ~MSwtRefCounted() {};

public:

    inline void AddRef()    const;

    inline void RemoveRef() const;

    inline TInt RefCount()  const;

private:

    mutable TInt iRefCount;

};

/**

 * Initialises the reference count to 1.

 */

inline MSwtRefCounted::MSwtRefCounted()

        : iRefCount(1)

{

}

/**

 * Increases the object's reference count by 1.

 */

inline void MSwtRefCounted::AddRef() const

{

    ++iRefCount;

}

/**

 * Decreases the object's reference count by 1.

 * If the reference count reaches 0, the object is destroyed.

 */

inline void MSwtRefCounted::RemoveRef() const

{

    if (--iRefCount == 0)

        delete const_cast<MSwtRefCounted*>(this);

}

/**

 * Returns the object's current reference count.

 */

inline TInt MSwtRefCounted::RefCount() const

{

    return iRefCount;

}

/**

 * Object containing the data needed for the

 * org.eclipse.swt.graphics.PaletteData class.

 */

class MSwtPaletteData

{

// Data types

public:

    /**

     * Data structure for direct palettes

     *

     * To extract a component from a colour: first apply the mask and then

     * shift the result by the specified value.

     *

     * To combine components in order to build a colour, for each component:

     * first shift by the opposite of the specified value and then apply the

     * mask. Finally, combine all three components with a OR operator.

     *

     * In both cases, a positive value indicates a left shift whereas a

     * negative one indicates a right shift.

     */

    struct TDirectData

    {

        TInt iRedMask;    // The red mask for a direct palette.

        TInt iGreenMask;  // The green mask for a direct palette.

        TInt iBlueMask;   // The blue mask for a direct palette.

        TInt iRedShift;   // The red shift for a direct palette.

        TInt iGreenShift; // The green shift for a direct palette.

        TInt iBlueShift;  // The blue shift for a direct palette.

    };

// Methods

public:

    virtual ~MSwtPaletteData() {}

    /**

     * Test whether a palette is a direct or an indirect one

     */

    virtual TBool IsDirect() const =0;

    /**

     * Returns the data of a direct palette

     */

    virtual const TDirectData& DirectData() const =0;

    /**

     * Returns the data of an indirect palette

     */

    virtual const CPalette* IndirectData() const =0;

};

/**

 * Object containing the data needed for the

 * org.eclipse.swt.graphics.ImageData class.

 */

class MSwtImageData

{

// Data types

public:

    struct TInfo

    {

        TSize            iSize;             // The size of the image, in pixels.

        TInt             iDepth;            // The color depth of the image, in bits per pixel.

        TInt             iScanlinePad;      // The scanline padding.

        TInt             iBytesPerLine;     // The number of bytes per scanline.

        TInt             iTransparentPixel; // The transparent pixel.

        TInt             iMaskPad;          // An icon-specific field containing the scanline pad of the mask.

        TInt             iAlpha;            // The global alpha value to be used for every pixel.

        TSwtImageType    iType;             // The type of file from which the image was read.

        TPoint           iTopLeft;          // The coordinates of the top-left corner of the image within the logical screen.

        TSwtGifDisposal  iDisposalMethod;   // A description of how to dispose of the current image before displaying the next.

        TInt             iDelayTime;        // The time to delay before displaying the next image in an animation

    };

// Methods

public:

    virtual ~MSwtImageData() {}

    virtual const TInfo&           Info()        const =0;

    virtual const MSwtPaletteData& Palette()     const =0;

    virtual const HBufC8&          PixelBuffer() const =0;

    virtual const HBufC8*          MaskBuffer()  const =0;

    virtual const HBufC8*          AlphaBuffer() const =0;

};

/**

 * Interface class for the

 * org.eclipse.swt.graphics.Color class.

 */

class MSwtColor

{

protected:

    virtual ~MSwtColor() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Disposes of (i.e. destroys) the colour

     */

    virtual void Dispose() =0;

    /**

     * Retrieves the RGB value representing the colour such as it would

     * appear on the associated device.

     */

    virtual TRgb RgbValue() const =0;

};

/**

 * Interface class for the org.eclipse.swt.graphics.Drawable interface.

 * Devices and GCs have been restricted to bitmap ones rather than fully

 * generic ones as no printer support is available in eSWT.

 */

class MSwtDrawable

{

protected:

    virtual ~MSwtDrawable() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Creates a new graphics context to draw on.

     */

    virtual MSwtGc* NewGcL() =0;

    /**

     * The native device used by this drawable

     */

    virtual CBitmapDevice& GraphicsDevice() =0;

    /**

     * Called after the Drawable's content has been modified.

     */

    virtual void HandleUpdate() =0;

};

/**

 * Interface class for the org.eclipse.swt.graphics.Drawable

 * interface as applied to the window server's GCs.

 */

class MSwtWindowDrawable : public MSwtDrawable

{

protected:

    virtual ~MSwtWindowDrawable() {} // Made protected to prevent destruction through the interface

};

/**

 * Interface class for the org.eclipse.swt.graphics.Drawable

 * interface as applied to the font & bitmap server's GCs.

 */

class MSwtBitmapDrawable : public MSwtDrawable

{

protected:

    virtual ~MSwtBitmapDrawable() {} // Made protected to prevent destruction through the interface

};

/**

 * Interface class for the org.eclipse.swt.graphics.Font class.

 * Fonts are not intended to be disposed of while they are referenced by some

 * control and/or GC. Nonetheless, a broken application may loosely follow the

 * SWT coding guidelines and fail to do so, thereby causing an access violation.

 * In order to prevent such behaviour, fonts are reference counted, see

 * MSwtRefCounted.

 */

class MSwtFont : public MSwtRefCounted

{

protected:

    /**

     * Destructor

     */

    virtual ~MSwtFont() {};

public:

    /**

     * Disposes of (i.e. destroys) the font.

     * The font is disposed of by calling its RemoveRef() method.

     * It is therefore an error to try and dispose of a font whose reference

     * count is higher than 1.

     */

    virtual void Dispose() =0;

    /**

     * Returns the native font object.

     */

    virtual const CFont& Font() const =0;

    /**

     * Returns the height of the native font, in points.

     * The design height of a font is the "aesthetic" height specified by the designer

     * and not the actual "physical" height. See Symbian's Improved_Font_Metrics_How_To.doc

     */

    virtual TInt DesignHeightInPoints() const =0;

    /**

     * Returns the typeface name of the native font.

     * The new descriptor should then be freed when no more needed.

     * If the font has been substituted, this function will return the original

     * name used to create the font, not the substituted name.

     */

    virtual HBufC* GetNameL() const =0;

    /**

     * Returns the style of the native font.

     */

    virtual TInt Style() const =0;

    /**

     * Returns the width in pixels of the specified descriptor when displayed in this font.

     */

    virtual TInt TextWidthInPixels(const TDesC& aText) const=0;

};

/**

 * Structure containing the data needed for the

 *        org.eclipse.swt.graphics.FontMetrics class.

 */

struct TSwtFontMetrics

{

    TInt iAscent;           // Ascent of the font, measured in pixels.

    TInt iAverageCharWidth; // Average character width, measured in pixels.

    TInt iDescent;          // Descent of the font, measured in pixels.

    TInt iHeight;           // Height of the font, measured in pixels.

    TInt iLeading;          // Leading area of the font, measured in pixels.

};

struct TSwtFontData

{

    TFontSpec iFontSpec;

};

/**

 * Interface class for the org.eclipse.swt.graphics.Device class.

 */

class MSwtDevice : public MSwtBitmapDrawable

{

protected:

    virtual ~MSwtDevice() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Creates a Color object for this device.

     */

    virtual MSwtColor* CreateColorL(const TRgb& aRgbValue) const =0;

    /**

     * Returns a rectangle describing device's size and location.

     */

    virtual TRect Bounds() const =0;

    /**

     * Returns a rectangle which describes the area of the device which

     * is capable of displaying data.

     */

    virtual TRect ClientArea() const =0;

    /**

     * Returns the bit depth of the screen.

     */

    virtual TInt Depth() const =0;

    /**

     * Returns the dots per inch resolution of the device.

     */

    virtual TSize Dpi() const =0;

    /**

     * Returns font data objects which describe the fonts that match

     * the given arguments. For each font, the available heights will be provided.

     * @param aFaceName The name of the font to look for. If empty, all fonts

     *        will be returned.

     * @param aScalable If true only scalable fonts are returned, otherwise

     *        only non-scalable fonts are returned.

     * @return An array containing the TSwtFontData objects

     *         describing each font.

     */

    virtual CArrayFixFlat<TSwtFontData>* GetFontListL(

        const TDesC& aFaceName, TBool aScalable) const=0;

    /**

     * Returns the matching standard color for the given constant.

     * @param aId SWT color constant

     * @return The Symbian OS' matching standard color. Any value other

     *         than one of the SWT color constants which is passed

     *         in will result in the color black.

     */

    virtual TRgb GetSystemColor(TSwtColorId aId) const =0;

    /**

     * Returns a reasonable font for applications to use.

     * @return The system font, cannot be NULL

     */

    virtual const MSwtFont* GetSystemFont() const =0;

    /**

     * Returns the default height of a font.

     * This height is used for the Java FontData constructor with no argument.

     */

    virtual TInt GetDefaultFontHeightL() =0;

};

/**

 * Interface class for the org.eclipse.swt.graphics.Image class.

 *

 * Images are not intended to be disposed of while they are referenced by some

 * control and/or GC. Nonetheless, a broken application may loosely follow the

 * SWT coding guidelines and fail to do so, thereby causing an access violation.

 *

 * In order to prevent such behaviour, images are reference counted, see

 * MSwtRefCounted.

 */

class MSwtImage

        : public MSwtBitmapDrawable

        , public MSwtRefCounted

{

protected:

    virtual ~MSwtImage() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Disposes of (i.e. destroys) the image.

     * The image is disposed of by calling its RemoveRef() method.

     * It is therefore an error to try and dispose of an image whose reference

     * count is higher than 1.

     */

    virtual void Dispose() =0;

    /**

     * Retrieves the underlying native bitmap representing the alpha channel

     * @param aInvertedIfMonochrome if true and the main mask is monochrome

     *        the result bitmap is inverted. if false or if main mask is not

     *        monochrome, the returned bitmap is not inverted.

     * The returned value may be NULL.

     * Call this only after calling SubBitmap!

     */

    virtual const CFbsBitmap* MaskBitmap(TBool aInvertedIfMonochrome = EFalse) const =0;

    /**

     * Retrieves a reference to a scaled copy of the main mask.

     * @param aInvertedIfMonochrome if true and the main mask is monochrome

     *        the result bitmap is inverted. if false or if main mask is not

     *        monochrome, the returned bitmap is not inverted.

     * The returned value may be NULL.

     * Call this only after calling SubBitmap!

     */

    virtual const CFbsBitmap* SubMaskBitmap(const TSize& aSize,

                                            TBool aInvertedIfMonochrome = EFalse) const =0;

    /**

     * Returns the bounds of the image.

     * The iTl member of the return value is always (0,0).

     */

    virtual TRect GetBounds() const =0;

    /**

     * Returns the image's data.

     */

    virtual MSwtImageData* GetImageDataL() const =0;

protected:

    virtual CFbsBitmap& GetBitmap() const =0;

    virtual CFbsBitmap& GetSubBitmap(const TSize& aSize) const =0;

public:

    /**

     * Retrieves a const reference to the underlying native bitmap.

     */

    inline const CFbsBitmap& Bitmap() const

    {

        return GetBitmap();

    }

    /**

     * Retrieves a reference to the underlying native bitmap.

     */

    inline CFbsBitmap& Bitmap()

    {

        return GetBitmap();

    }

    /**

     * Retrieves a const reference to a scaled copy of the native bitmap.

     * Allocates memory in the object even if the object is const (see mutable).

     * The allocated copy is owned by the image object.

     * If memory allocation or bitmap scaling fails, NULL is returned.

     * If aSize equals the size of the main bitmap, the main bitmap is returned.

     * Call this before calling SubMaskBitmap!

     */

    inline const CFbsBitmap& SubBitmap(const TSize& aSize) const

    {

        return GetSubBitmap(aSize);

    }

    /**

     * Retrieves a reference to a scaled copy of the native bitmap.

     * Allocates memory in the object even if the object is const (see mutable).

     * The allocated copy is owned by the image object.

     * If memory allocation or bitmap scaling fails, NULL is returned.

     * If aSize equals the size of the main bitmap, the main bitmap is returned.

     * Call this before calling SubMaskBitmap!

     */

    inline CFbsBitmap& SubBitmap(const TSize& aSize)

    {

        return GetSubBitmap(aSize);

    }

public:

    /**

     * Means for clients to register their use of a scaled bitmap copy.

     * If aSize equals the size of the main bitmap, the main bitmap is referenced.

     * @return KErrNotFound if a copy of that size not found.

     *         KErrNone if reference added ok.

     */

    virtual TInt AddSubRef(const TSize& aSize) const =0;

    /**

     * Means for clients to deregister their use of a scaled bitmap copy.

     * If aSize equals the size of the main bitmap, the main bitmap is dereferenced.

     * If no clients left for that copy, the bitmap copy is destroyed.

     * @return KErrNotFound if a copy of that size not found.

     *         KErrNone if reference removed ok.

     */

    virtual TInt RemoveSubRef(const TSize& aSize) const =0;

    /**

     * Return the number of clients using the a scaled bitmap copy.

     * If aSize equals the size of the main bitmap, the main reference count is returned.

     */

    virtual TInt SubRefCount(const TSize& aSize) const = 0;

    /**

     * Create a bitmap with alpha channel based on underlying native bitmap.

     */

    virtual CFbsBitmap* BitmapWithAlphaLC() = 0;

};

/**

 * Interface class for the org.eclipse.swt.graphics.GC class.

 */

class MSwtGc

{

protected:

    virtual ~MSwtGc() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Signature for a function destroying native GCs.

     * Must not leave.

     */

    typedef void (*TDestructor)(CBitmapContext* aGc);