/*

 * Copyright (c) 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:  Task list entry

 *

 */

#define __E32SVR_H__

#include <s32strm.h>

#include <fbs.h>

#include "tsentry.h"

#include "tsdataobserver.h"

// --------------------------------------------------------------------------

// CTsFswEntry::NewL

// --------------------------------------------------------------------------

//

CTsEntry* CTsEntry::NewL()

{

    CTsEntry* self = NewLC();

    CleanupStack::Pop(self);

    return self;

}

// --------------------------------------------------------------------------

// CTsFswEntry::NewLC

// --------------------------------------------------------------------------

//

CTsEntry* CTsEntry::NewLC()

{

    CTsEntry* self = new (ELeave) CTsEntry;

    CleanupStack::PushL(self);

    return self;

}

// --------------------------------------------------------------------------

// CTsFswEntry::NewL

// --------------------------------------------------------------------------

//

CTsEntry* CTsEntry::NewL(const TTsEntryKey& key, MHsDataObserver *observer)

{

    CTsEntry* self = NewLC(key, observer);

    CleanupStack::Pop(self);

    return self;

}

// --------------------------------------------------------------------------

// CTsFswEntry::NewLC

// --------------------------------------------------------------------------

//

CTsEntry* CTsEntry::NewLC(const TTsEntryKey& key, MHsDataObserver* observer)

{

    CTsEntry* self = new (ELeave) CTsEntry(key, observer);

    CleanupStack::PushL(self);

    return self;

}

// --------------------------------------------------------------------------

// CTsFswEntry::~CTsFswEntry

// --------------------------------------------------------------------------

//

CTsEntry::~CTsEntry()

{

    delete mAppName;

    delete mAppIconBitmap;

    delete mAppIconMask;

    delete mScreenshot;

    delete mImgTool;

}

// --------------------------------------------------------------------------

// CTsFswEntry::CTsFswEntry

// --------------------------------------------------------------------------

//

CTsEntry::CTsEntry() :

    mVisibility(Visible),

    mPriority(Low)

{

    mKey = TTsEntryKey();

}

// --------------------------------------------------------------------------

// CTsFswEntry::CTsFswEntry

// --------------------------------------------------------------------------

//

CTsEntry::CTsEntry(const TTsEntryKey& key, MHsDataObserver *observer) 

:

    mVisibility(Visible),

    mKey(key), 

    mPriority(Low), 

    mObserver(observer)

{

}

// --------------------------------------------------------------------------

// CTsFswEntry::SetAppUid

// --------------------------------------------------------------------------

//

void CTsEntry::SetAppUid(const TUid& uid)

{

    mAppUid = uid;

}

// --------------------------------------------------------------------------

// CTsFswEntry::SetAppNameL

// --------------------------------------------------------------------------

//

void CTsEntry::SetAppNameL(const TDesC& appName)

{

    delete mAppName;

    mAppName = 0;

    mAppName = appName.AllocL();

}

// --------------------------------------------------------------------------

// CTsFswEntry::SetSystemApp

// --------------------------------------------------------------------------

//

void CTsEntry::SetCloseableApp(TBool value)

{

    mCloseableApp = value;

}

// --------------------------------------------------------------------------

// CTsFswEntry::SetAppIconHandles

// --------------------------------------------------------------------------

//

void CTsEntry::SetAppIcon(CFbsBitmap* bitmap, CFbsBitmap* mask)

{

    mAppIconBitmap = bitmap;

    mAppIconMask = mask;

}

// --------------------------------------------------------------------------

/**

 * Application uid.

 */

TUid CTsEntry::AppUid() const

{

    return mAppUid;

}

// --------------------------------------------------------------------------

/**

 * Application name.

 */

const TDesC& CTsEntry::AppName() const

{

    return mAppName ? *mAppName : KNullDesC();

}

// --------------------------------------------------------------------------

/**

 * Retrieve entry visibilit status

 */

Visibility CTsEntry::GetVisibility() const

{

    return mVisibility;

}

// --------------------------------------------------------------------------

/**

 * Change entry visibility status

 * @param visibility - new visibility status

 */

void CTsEntry::SetVisibility(Visibility visibility)

{

    mVisibility = visibility;

}

// --------------------------------------------------------------------------

/**

 * ETrue if the application is closeable

 */

TBool CTsEntry::CloseableApp() const

{

    return mCloseableApp;

}

// --------------------------------------------------------------------------

/**

 * Application icon bitmap

 */

CFbsBitmap* CTsEntry::AppIconBitmap() const

{

    return mAppIconBitmap;

}

// --------------------------------------------------------------------------

/**

 * Application icon mask.

 */

CFbsBitmap* CTsEntry::AppIconMask() const

{

    return mAppIconMask;

}

// --------------------------------------------------------------------------

/**

 * Entry's key

 */

const TTsEntryKey& CTsEntry::Key() const

{

    return mKey;

}

// --------------------------------------------------------------------------

// CTsFswEntry::ExternalizeL

// --------------------------------------------------------------------------

//

void CTsEntry::ExternalizeL(RWriteStream& stream) const

{

    stream.WriteInt32L(mAppUid.iUid);

    stream << AppName();

    stream.WriteInt32L(mCloseableApp);

    if (mAppIconBitmap) {

        stream.WriteInt32L(mAppIconBitmap->Handle());

    }

    else {

        stream.WriteInt32L(KErrNotFound);

    }

    if (mAppIconMask) {

        stream.WriteInt32L(mAppIconMask->Handle());

    }

    else {

        stream.WriteInt32L(KErrNotFound);

    }

    if (mScreenshot) {

        stream.WriteInt32L(mScreenshot->Handle());

    }

    else {

        stream.WriteInt32L(KErrNotFound);

    }

    mKey.ExternalizeL(stream);

    TInt currentPriority = static_cast<TInt> (mPriority);

    stream.WriteInt32L(currentPriority);

}

// --------------------------------------------------------------------------

// CTsFswEntry::InternalizeL

// --------------------------------------------------------------------------

//

void CTsEntry::InternalizeL(RReadStream& stream)

{

    mAppUid = TUid::Uid(stream.ReadInt32L());

    delete mAppName;

    mAppName = NULL;

    mAppName = HBufC::NewL(stream, KMaxTInt);

    mCloseableApp = stream.ReadInt32L();

    TInt appIconBitmapHandle = stream.ReadInt32L();

    TInt appIconMaskHandle = stream.ReadInt32L();

    TInt screenshotHandle = stream.ReadInt32L();

    if (appIconBitmapHandle != KErrNotFound) {

        mAppIconBitmap = new (ELeave) CFbsBitmap;

        mAppIconBitmap->Duplicate(appIconBitmapHandle);

    }

    if (appIconMaskHandle != KErrNotFound) {

        mAppIconMask = new (ELeave) CFbsBitmap;

        mAppIconMask->Duplicate(appIconMaskHandle);

    }

    if (screenshotHandle != KErrNotFound) {

        mScreenshot = new (ELeave) CFbsBitmap;

        mScreenshot->Duplicate(screenshotHandle);

    }

    mKey.InternalizeL(stream);

    TInt currentPriority = stream.ReadInt32L();

    mPriority = static_cast<UpdatePriority> (currentPriority);

}

// --------------------------------------------------------------------------

// CTsFswEntry::ExternalizeArrayL

// --------------------------------------------------------------------------

//

void CTsEntry::ExternalizeArrayL(RWriteStream& stream, const RTsFswArray& array)

{

    TInt iter(0);

    RArray<TInt> visibleItems(array.Count() ? array.Count() : 1);

    CleanupClosePushL(visibleItems);

    for (iter = 0; iter < array.Count(); ++iter) {

        if (Visible == array[iter]->GetVisibility()) {

            visibleItems.AppendL(iter);

        }

    }

    stream.WriteInt32L(visibleItems.Count());

    for (iter = 0; iter < visibleItems.Count(); ++iter) {

        array[visibleItems[iter]]->ExternalizeL(stream);

    }

    CleanupStack::PopAndDestroy(&visibleItems);

}

// --------------------------------------------------------------------------

// CTsFswEntry::InternalizeArrayL

// --------------------------------------------------------------------------

//

void CTsEntry::InternalizeArrayL(RReadStream& stream, RTsFswArray& array)

{

    array.ResetAndDestroy();

    TInt count = stream.ReadInt32L();

    for (TInt i = 0; i < count; ++i) {

        CTsEntry* entry = CTsEntry::NewLC();

        entry->InternalizeL(stream);

        array.AppendL(entry);

        CleanupStack::Pop(entry);

    }

}

// --------------------------------------------------------------------------

/**

 * Application type.

 */

TAppType CTsEntry::Type() const

{

    return EApp;

}

// --------------------------------------------------------------------------

// CTsFswEntry::SetScreenshot

// --------------------------------------------------------------------------

//

void CTsEntry::SetScreenshotL(const CFbsBitmap& bitmapArg, UpdatePriority priority)

{

    TInt currentPriority = static_cast<TInt> (mPriority);

    TInt newPriority = static_cast<TInt> (priority);

    if(newPriority <currentPriority) {

        User::Leave(KErrAccessDenied);

    }

    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    User::LeaveIfError(bitmap->Duplicate(bitmapArg.Handle()));

    CleanupStack::Pop(bitmap);

    mPriority = priority;

    delete mScreenshot;

    mScreenshot = bitmap;

    delete mImgTool;

    mImgTool = 0;

    mImgTool = CTsGraphicFileScalingHandler::NewL(*this, *mScreenshot, TSize(128, 128),

    CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding);

}

// --------------------------------------------------------------------------

// CTsFswEntry::RemoveScreenshot

// --------------------------------------------------------------------------

//

void CTsEntry::RemoveScreenshotL()

{

    if (!mScreenshot) {

        User::Leave(KErrNotFound);

    }

    delete mScreenshot;

    mScreenshot = NULL;

    mPriority = Low;

    if (mObserver) {

        mObserver->DataChanged();

    }

}

// --------------------------------------------------------------------------

/**

 * Application screenshot.

 */

CFbsBitmap* CTsEntry::Screenshot() const

{

    return mScreenshot;

}

// --------------------------------------------------------------------------

/**

 * Priority.

 */

UpdatePriority CTsEntry::Priority() const

{

    return mPriority;

}

// --------------------------------------------------------------------------

// CTsFswEntry::Priority

// --------------------------------------------------------------------------

//

void CTsEntry::ImageReadyCallBack(TInt error, const CFbsBitmap *bitmap)

{

    if (KErrNone == error && 0 != bitmap) {

        mScreenshot->Reset();

        mScreenshot->Duplicate(bitmap->Handle());

        if (mObserver) {

            mObserver->DataChanged();

        }

    }

}

// end of file