/*

* Copyright (c) 2006 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 "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:  Handles the viewing of a single frame. If the page is not frame

*               enabled, this class is used as the single view.  If frame

*               enabled, there is one instance of this class for each frame.

*

*/

#include "../../bidi.h"

#include <fbs.h>

#include <coemain.h>

#include "WebSprite.h"

/*

 * CWebSprite class serves as a replacement for Symbian RWsSprite 

 * in the cases when transparent window is possible (platform supports it).

 * It's a window owning CCoeControl which window gets highest priority and

 * smallest ordinal number. That allows to CWebSprite be on top of all windows

 * in the same window group. The movement is restricted by boundaries of the

 * parent CCoeControl window or Root Window if parent is NULL.

 * Only one bitmap is supported, so animation is not possible.

 * If platform doesn't support window transparency CWebSprite acts as wrapper

 * around RWsSprite.

 */

// ======================================================================

// CWebSprite::NewL

// ======================================================================

CWebSprite* CWebSprite::NewL(TPoint& aPos, CFbsBitmap* aBitmap, 

                             CFbsBitmap* aMask, TBool aInvertMask)

    {

    CWebSprite* self = new(ELeave)CWebSprite(NULL, aBitmap, aMask, aInvertMask);

    CleanupStack::PushL(self);

    self->ConstructL(aPos);

    CleanupStack::Pop();

    return self;

    }

// ======================================================================

// CWebSprite::NewL

// ======================================================================

CWebSprite* CWebSprite::NewL(CCoeControl* aParent, TPoint& aPos, 

                             CFbsBitmap* aBitmap, CFbsBitmap* aMask, 

			     TBool aInvertMask)

    {

    CWebSprite* self = new(ELeave)CWebSprite(aParent, aBitmap, aMask, aInvertMask);

    CleanupStack::PushL(self);

    self->ConstructL(aParent, aPos);

    CleanupStack::Pop();

    return self;

    }

// ======================================================================

// CWebSprite::BaseConstructL

// ======================================================================

void CWebSprite::BaseConstructL(TPoint& aPos, CFbsBitmap* aBitmap, 

                                CFbsBitmap* aMask, TBool aInvertMask)

    {

    iBitmap = aBitmap;

    iMask = aMask;

    iInvertMask = aInvertMask;

    iParent = NULL;

    ConstructL(aPos);

    }

// ======================================================================

// CWebSprite::BaseConstructL

// ======================================================================

void CWebSprite::BaseConstructL(CCoeControl* aParent, TPoint& aPos, 

                                CFbsBitmap* aBitmap, CFbsBitmap* aMask, 

				TBool aInvertMask)

    {

    iBitmap = aBitmap;

    iMask = aMask;

    iInvertMask = aInvertMask;

    iParent = aParent;

    ConstructL(aParent, aPos);

    }

// ======================================================================

// CWebSprite::CWebSprite()

// ======================================================================

CWebSprite::CWebSprite()

    {

    }

// ======================================================================

// CWebSprite::CWebSprite()

// ======================================================================

CWebSprite::CWebSprite(CCoeControl* aParent, CFbsBitmap* aBitmap, 

                       CFbsBitmap* aMask, TBool aInvertMask) : 

                       iParent(aParent), iBitmap(aBitmap), iMask(aMask), 

		       iInvertMask(aInvertMask), iWin(NULL)

    {    

    }

// ======================================================================

// CWebSprite::ConstructL

// ======================================================================

void CWebSprite::ConstructL(TPoint& aPos)

    {

    ConstructL(NULL, aPos);

    }

// ======================================================================

// CWebSprite::ConstructL

// ======================================================================

void CWebSprite::ConstructL(CCoeControl* aParent, TPoint& aPos)

    {

    TInt err = KErrNone;

    if (aParent)

        {

        CreateWindowL(aParent);

        }

    else

        {

        CreateWindowL();

        }

    iWin = &(Window());

    iWin->SetRequiredDisplayMode(EColor16MA);

    err = iWin->SetTransparencyAlphaChannel();

    if (err != KErrNone)

        {

        // Transparency is not possible - close window and use sprites

        CloseWindow();

        iWin = NULL;

        }

    if (iWin)

        {

        iWin->SetOrdinalPosition(0, KPasswordWindowGroupPriority - 1);   

        iWin->SetBackgroundColor(TRgb(0,0));    

        if (iBitmap) 

            {

            init(aPos, iBitmap->SizeInPixels());

            ActivateL();

            }

        else

            {

            SetPosition(aPos);

            Hide();

            }

        }

    else

        {

        MakeVisible(EFalse);

        CreateSprite(aPos);

        }

    }

// ======================================================================

// CWebSprite::CreateSprite

// ======================================================================

void CWebSprite::CreateSprite(TPoint& aPos)

    {

    /*

     * We should come here only if iWin is NULL since it will mean that 

     * transparent windowis not possible and we are using sprite

     */

    RWindowTreeNode* window = iParent ? static_cast<RWindowTreeNode*>(iParent->DrawableWindow()) :

                                        static_cast<RWindowTreeNode*>(&(ControlEnv()->RootWin()));

    iSprite = RWsSprite(ControlEnv()->WsSession());

    iSprite.Construct(*window, aPos, ESpriteNoChildClip);

    TSpriteMember spriteMem;

    spriteMem.iBitmap = iBitmap;

    spriteMem.iMaskBitmap = iMask;

    spriteMem.iInvertMask = iInvertMask;

    iSprite.AppendMember(spriteMem);

    iSprite.Activate();

    }

// ======================================================================

// CWebSprite::UpdateSprite

// ======================================================================

void CWebSprite::UpdateSprite()

    {

    /*

     * We should come here only if iWin is NULL since it will mean that 

     * transparent windowis not possible and we are using sprite

     */

    TSpriteMember spriteMem;

    spriteMem.iBitmap = iBitmap;

    spriteMem.iMaskBitmap = iMask;

    spriteMem.iInvertMask = iInvertMask;

    iSprite.UpdateMember(0, spriteMem);

    }

// ======================================================================

// CWebSprite::init

// ======================================================================

void CWebSprite::init(TPoint& aPos, TSize aSize)

    {

    if (iWin)

        { // we have a window - let's set position and size

        SetPosition(aPos);

        SetSizeWithoutNotification(aSize);

        }

    }

// ======================================================================

// CWebSprite::Draw

// ======================================================================

void CWebSprite::Draw(const TRect& aRect) const

    {

    if (IsActivated() && iBitmap)

        {

        CWindowGc& gc = SystemGc();       

        gc.Clear(aRect);   

        Window().SetOrdinalPosition(0, KPasswordWindowGroupPriority - 1); 

        TPoint pt = TPoint(0,0);

        TRect rect = TRect(pt, iBitmap->SizeInPixels());

        gc.BitBltMasked(pt, iBitmap, rect, iMask, iInvertMask);

        }

    }

// ======================================================================

// CWebSprite::SetBitmap

// ======================================================================

void CWebSprite::SetBitmap(CFbsBitmap* aBitmap, CFbsBitmap* aMask, TBool aInvertMask)

    {

    iBitmap = aBitmap;

    iMask = aMask;   

    iInvertMask = aInvertMask;

    if(iWin && aBitmap)

        {

        TPoint pos = Position();

        init(pos, aBitmap->SizeInPixels());

        }

    }

// ======================================================================

// CWebSprite::Update

// ======================================================================

void CWebSprite::Update(const TPoint& aPos, CFbsBitmap* aBitmap, 

                        CFbsBitmap* aMask)

    {

    SetPos(aPos);

    Update(aBitmap, aMask);

    }

// ======================================================================

// CWebSprite::Update

// ======================================================================

void CWebSprite::Update(CFbsBitmap* aBitmap, CFbsBitmap* aMask)

    {

    TInt err = KErrNone;

    if(iWin && aBitmap) // if we have a window and bitmap check if we need 

        {               // to finish initialization

        if (!IsActivated() || !iBitmap)         // if control wasn't activated 

            {                                   // or bitmap was reset last time to NULL,

            TPoint pos = Position();            // because somebody wanted to reuse this control, 

            init(pos, aBitmap->SizeInPixels()); // we will try to initialize the control.

            TRAP(err, ActivateL());

            }

        }

    if (err == KErrNone)

        {

        iBitmap = aBitmap;

        iMask = aMask;   

        }

    else

        {

        iBitmap = NULL;

        iMask = NULL;    

        }

    if (!iWin)

        {

        UpdateSprite();

        }

    else if (iBitmap)

        {

        Show();

        DrawNow();

        }

    }

// ======================================================================

// CWebSprite::Update

// ======================================================================

void CWebSprite::Update(CFbsBitmap* aBitmap, CFbsBitmap* aMask, 

                        TBool aInvertMask)

    {

    iInvertMask = aInvertMask;

    Update(aBitmap, aMask);

    }

// ======================================================================

// CWebSprite::Show

// ======================================================================

void CWebSprite::Show()

    {

    if (iWin)

        {

        MakeVisible(ETrue);

        }

    else

        {

        UpdateSprite();

        }

    }

// ======================================================================

// CWebSprite::Hide

// ======================================================================

void CWebSprite::Hide()

    {

    if (iWin)

        {

        MakeVisible(EFalse);

        }

    else

        {

        Update(NULL, NULL);

        }

    }

// ======================================================================

// CWebSprite::~CWebSprite

// ======================================================================

CWebSprite::~CWebSprite()

    {

    if (!iWin)

        {

        iSprite.Close();

        }

    }

// ======================================================================

// CWebSprite::SetPos

// ======================================================================

void CWebSprite::SetPos(const TPoint& aPos)

    {

    if (!iWin)

        {

        iSprite.SetPosition(aPos);

        }

    else

        {

        TPoint pos = Position();

        if (pos != aPos) 

            {

            CCoeControl::SetPosition(aPos);

            }

        }

    }

// ======================================================================

// CWebSprite::IsShown

// ======================================================================

TBool CWebSprite::IsShown()

    {

    // if it's a window owning CoeControl just return IsVisible()

    // otherwise check if bitmap != NULL and if it's not then

    // sprite is shown.

    return (iWin && IsVisible()) || iBitmap != NULL;

    }