if (THEME_SERVER_NAME != HbMemoryUtils::getCleanAppName()) {

    queueCheckInvoker = CIdle::New(CActive::EPriorityLow); // important to set the proper prio here

        if (error == KErrNone) {

class QueueEntry : public CActive

{

public:

    QueueEntry(HbThemeClientPrivate *tc);

    ~QueueEntry();

    void DoCancel();

    void RunL();

    void init(const HbThemeClient::IconReqInfo &reqInfo,

              HbAsyncIconInfoCallback callback,

              void *callbackParam);

    void issueRequest();

    HbThemeClientPrivate *mTc;

    TPckg<HbSharedIconInfo> *mInfoPckg;

    TPckg<TIconParams> *mParamsPckg;

    void *mCallbackParam;

    HbAsyncIconInfoCallback mCallback;

    HbSharedIconInfo mInfo;

    TIconParams mParams;

    TFileName mIconPathBuf;

};

// Never call this directly, use scheduleQueueCheck() to have it

// invoked asynchronously when there is nothing better to do.

static TInt checkQueue(TAny *param)

{

    HbThemeClientPrivate *tc = static_cast<HbThemeClientPrivate *>(param);

    // Only one request can be sent a time. The themeserver is single-threaded

    // and has no special async support so it blocks anyway.

    if (tc->reqQueue.isEmpty()) {

        return 0;

    }

    foreach (QueueEntry *e, tc->reqQueue) {

        if (e->IsActive()) {

            return 0;

        }

    }

    tc->reqQueue.head()->issueRequest();

    return 0;

}

QueueEntry::QueueEntry(HbThemeClientPrivate *tc)

    : CActive(EPriorityStandard),

      mTc(tc), mInfoPckg(0), mParamsPckg(0), mCallbackParam(0)

{

    CActiveScheduler::Add(this);

}

QueueEntry::~QueueEntry()

{

    Cancel();

    delete mParamsPckg;

    delete mInfoPckg;

}

void QueueEntry::DoCancel()

{

    // No cancel support on server-side, so complete here. This also means that

    // Cancel() can only be called from the dtor. See cancelGetSharedIconInfo().

    TRequestStatus *rs = &iStatus;

    User::RequestComplete(rs, KErrCancel);

}

void QueueEntry::RunL()

{

    if (iStatus != KErrCancel) {

        mTc->reqQueue.removeOne(this);

        if (iStatus != KErrNone) {

            mInfo.type = INVALID_FORMAT;

        }

        if (!mCallback || !mCallback(mInfo, mCallbackParam)) {

            // Requestor is not interested, may not even exist anymore, so unload.

            HbThemeClient::IconReqInfo reqInfo;

            reqInfo.iconPath = QString::fromUtf16(mParams.fileName.Ptr(), mParams.fileName.Length());

            reqInfo.size = QSizeF(mParams.width, mParams.height);

            reqInfo.aspectRatioMode = (Qt::AspectRatioMode) mParams.aspectRatioMode;

            reqInfo.mode = (QIcon::Mode) mParams.mode;

            reqInfo.mirrored = (bool) mParams.mirrored;

            reqInfo.color = mParams.colorflag ? QColor(mParams.rgba) : QColor();

            reqInfo.renderMode = (HbRenderingMode) mParams.renderMode;

            mTc->unloadIcon(reqInfo);

        }

        mTc->scheduleQueueCheck();

        delete this;

    }

}

void QueueEntry::init(const HbThemeClient::IconReqInfo &reqInfo,

                      HbAsyncIconInfoCallback callback,

                      void *callbackParam)

{

    mCallback = callback;

    mCallbackParam = callbackParam;

    mInfo.type = INVALID_FORMAT;

    mIconPathBuf = TFileName(reqInfo.iconPath.utf16());

    mParams.fileName = mIconPathBuf;

    mParams.width = reqInfo.size.width();

    mParams.height = reqInfo.size.height();

    mParams.aspectRatioMode = (TUint8) reqInfo.aspectRatioMode;

    mParams.mode = (TUint8) reqInfo.mode;

    mParams.options = (TUint8) reqInfo.options;

    mParams.mirrored = (TBool) reqInfo.mirrored;

    mParams.rgba = (TUint32) reqInfo.color.rgba();

    mParams.colorflag = reqInfo.color.isValid();

    mParams.renderMode = reqInfo.renderMode;

    mInfoPckg = new TPckg<HbSharedIconInfo>(mInfo);

    mParamsPckg = new TPckg<TIconParams>(mParams);

}

void QueueEntry::issueRequest()

{

    TIpcArgs args(mParamsPckg, mInfoPckg);

    mTc->SendReceive(EIconLookup, args, iStatus);

    SetActive();

}

 * Returns the shared icon information, asynchronous version.

*/

void HbThemeClientPrivate::getSharedIconInfo(const HbThemeClient::IconReqInfo &reqInfo,

                                             HbAsyncIconInfoCallback callback,

                                             void *callbackParam)

{

    if (!clientConnected) {

        HbSharedIconInfo info;

        info.type = INVALID_FORMAT;

        callback(info, callbackParam);

        return;

    }

    QueueEntry *e = new QueueEntry(this);

    e->init(reqInfo, callback, callbackParam);

    reqQueue.enqueue(e);

    scheduleQueueCheck();

}

void HbThemeClientPrivate::scheduleQueueCheck()

{

    if (queueCheckInvoker && !queueCheckInvoker->IsActive()) {

        queueCheckInvoker->Start(TCallBack(checkQueue, this));

    }

}

/**

 * HbThemeClientPrivate::cancelGetSharedIconInfo

 *

 * Cancels a previous async getSharedIconInfo request.

 * If callbackParam is 0 then it is ignored and only \a callback is used in the matching.

 * Otherwise both \a callback and \a callbackParam must match.

void HbThemeClientPrivate::cancelGetSharedIconInfo(HbAsyncIconInfoCallback callback,

                                                   void *callbackParam)

{

    for (int i = 0; i < reqQueue.count(); ++i) {

        QueueEntry *e = reqQueue.at(i);

        if (e->mCallback == callback && (!callbackParam || callbackParam == e->mCallbackParam)) {

            if (e->IsActive()) {

                // There is no real cancelation support, the themeserver is busy

                // and is blocked at this point, so just let it go and ignore

                // the future results. Calling Cancel() would potentially result

                // in a stray signal.

                e->mCallback = 0;

            } else {

                delete e;

                reqQueue.removeAt(i--);

            }

        }

    }

}

inline TIconParams reqInfoToParams(const HbThemeClient::IconReqInfo &reqInfo)

{

    TIconParams params;

    params.fileName.Copy(TPtrC(static_cast<const TUint16 *>(reqInfo.iconPath.utf16()),

                               reqInfo.iconPath.length()));

    params.width = reqInfo.size.width();

    params.height = reqInfo.size.height();

    params.aspectRatioMode = (TUint8)  reqInfo.aspectRatioMode;

    params.mode = (TUint8) reqInfo.mode;

    params.options = (TUint8) reqInfo.options;

    params.mirrored = (TBool) reqInfo.mirrored;

    params.rgba = (TUint32) reqInfo.color.rgba();

    params.colorflag = reqInfo.color.isValid();

    params.renderMode = reqInfo.renderMode;

    return params;

}

/**

 * HbThemeClientPrivate::getSharedIconInfo()

 *

 * Returns the shared icon information, synchronous version.

*/

HbSharedIconInfo HbThemeClientPrivate::getSharedIconInfo(const HbThemeClient::IconReqInfo &reqInfo)

    if (!clientConnected) {

    TIconParams params = reqInfoToParams(reqInfo);

    TIpcArgs args(&paramPckg, &iconInfo);

        sharedIconInfo.type = INVALID_FORMAT;

    TFileName iconId(multiPartIconData.multiPartIconId.utf16());

        TFileName pieceIconId(multiPartIconList[i].utf16());

HbCss::StyleSheet *HbThemeClientPrivate::getSharedStyleSheet(const QString &fileName, 

            HbLayeredStyleLoader::LayerPriority priority, bool &fileExists)

    TFileName fileDes(fileName.utf16());

    THEME_GENERIC_DEBUG() << "Time elapsed in IPC:" << time.elapsed() << "ms";

#endif    

        fileExists = stylesheetInfo.fileExists;

 * HbThemeClientPrivate::getSharedMissedHbCss()

 *

 * Returns a pointer to the list in shared memory of CSS files for classes

 * starting with 'hb' which the theme server attempted to load and found

 * the file does not exist

 */

HbVector<uint> *HbThemeClientPrivate::getSharedMissedHbCss()

{

    if (!clientConnected) {

        return 0;

    }

    HbVector<uint> *list(0);

    HbSharedMissedHbCssInfo missedListInfo;

    TPckg<HbSharedMissedHbCssInfo> listInfo(missedListInfo);

    TIpcArgs args(&listInfo);

    TInt err = SendReceive(EMissedHbCssLookup, args);

    if (KErrNone == err) {

        if (missedListInfo.offset >= 0) {

            list = HbMemoryUtils::getAddress<HbVector<uint> >(

                HbMemoryManager::SharedMemory, missedListInfo.offset);

        }

    }

    return list;

}

/**

    THEME_GENERIC_DEBUG() << "HbThemeClientPrivate::getSharedEffect" << filePath;

    TFileName fileDes(filePath.utf16());

#ifdef THEME_SERVER_TRACES    

    THEME_GENERIC_DEBUG() << "Time elapsed in EEffectLookupFilePath IPC:" << time.elapsed() << "ms";

#endif    

        THEME_GENERIC_DEBUG() << "HbThemeClientPrivate::getSharedEffect effectInfo.offSet is:"

            THEME_GENERIC_DEBUG() << "effect offset invalid: " << effectInfo.offset;

        THEME_GENERIC_DEBUG() << "effect sendreceive error:" << err;