// SYSTEM INCLUDES

// USER INCLUDES

#include "univiewertextitem.h"

#include "univiewerpixmapwidget.h"

#include "univieweraudiowidget.h"

const QString IMAGE_MIMETYPE("image");

const QString AUDIO_MIMETYPE("audio");

const QString VIDEO_MIMETYPE("video");

const QString TEXT_MIMETYPE("text");

        mPixmapItem(0), mAudioItem(0)

    this->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

void UniViewerBodyWidget::setPixmap(UniMessageInfo *info)

    if (!mPixmapItem) {

        mPixmapItem = new UniViewerPixmapWidget(this);

        HbStyle::setItemName(mPixmapItem, "pixmap");

    mPixmapItem->hide();

    mPixmapItem->populate(info);

void UniViewerBodyWidget::setAudio(UniMessageInfo *info)

        mAudioItem = new UniViewerAudioWidget(this);

    mAudioItem->hide();

    mAudioItem->populate(info);

void UniViewerBodyWidget::setVideo(UniMessageInfo *info)

    setHasPixmap(true);

    //create image item instance

    if (!mPixmapItem) {

       mPixmapItem = new UniViewerPixmapWidget(this);

       HbStyle::setItemName(mPixmapItem, "pixmap");

    }

    mPixmapItem->hide();

    mPixmapItem->populate(info);

    this->repolish();

//UniViewerBodyWidget::setText

void UniViewerBodyWidget::setText(QString text)

    mTextItem->hide();

// UniViewerBodyWidget::setSlideCounter

    mSlideCounter->hide();

        QString mimeType = info->mimetype();

        if (mimeType.contains(TEXT_MIMETYPE)) {

            if (file.open(QIODevice::ReadOnly)) {

                QString textContent(file.readAll());

                setText(textContent);

            }

        else if (mimeType.contains(AUDIO_MIMETYPE)) {

            setAudio(info);

        else if (mimeType.contains(VIDEO_MIMETYPE)) {

            setVideo(info);

        else if (mimeType.contains(IMAGE_MIMETYPE)) {

            setPixmap(info);

    if (mPixmapItem) {

        mPixmapItem->setParent(NULL);

        delete mPixmapItem;

        mPixmapItem = NULL;

//UniViewerBodyWidget::sizeHint

QSizeF UniViewerBodyWidget::sizeHint(Qt::SizeHint which, const QSizeF & constraint) const

    QSizeF szHint = HbWidget::sizeHint(which, constraint);

    HbMainWindow *mainWindow = this->mainWindow();

    if (!mainWindow) {

        return szHint;

    qreal screenWidth = 0.0;

    qreal screenHeight = 0.0;

    qreal leftMargin = 0.0;

    qreal rightMargin = 0.0;

    qreal chromeHeight = 0.0;

    qreal toolbarHeight = 0.0;

    qreal iconSize = 0.0;

    qreal spacing = 0.0;

    qreal unitSize = HbDeviceProfile::profile(mPixmapItem).unitValue();

    style()->parameter("hb-param-screen-width", screenWidth);

    style()->parameter("hb-param-screen-height", screenHeight);

    style()->parameter("hb-param-margin-gene-left", leftMargin);

    style()->parameter("hb-param-margin-gene-right", rightMargin);

    style()->parameter("hb-param-widget-chrome-height", chromeHeight);

    style()->parameter("hb-param-widget-toolbar-height", toolbarHeight);

    style()->parameter("hb-param-graphic-size-primary-large", iconSize);

    style()->parameter("hb-param-margin-gene-middle-vertical", spacing);

    qreal maxWidth = 0.0;

    qreal maxHeight = 0.0;

    // Calculate max height & max width.

    if (mainWindow->orientation() == Qt::Horizontal) {

        qreal temp;

        temp = screenWidth;

        screenWidth = screenHeight;

        screenHeight = temp;

        if (mPixmapItem && mHasText) {

            maxWidth = (screenWidth / 2) - leftMargin - unitSize;

        }

        else {

            maxWidth = screenWidth - leftMargin - rightMargin;

        }

        maxHeight = screenHeight - chromeHeight - toolbarHeight;

        if (mAudioItem) {

            mAudioItem->setStretched(true);

    else if (mainWindow->orientation() == Qt::Vertical) {

        maxWidth = screenWidth - leftMargin - rightMargin;

        maxHeight = screenHeight - chromeHeight - toolbarHeight;

        if (mAudioItem) {

            mAudioItem->setStretched(false);

        }

    }

    // Slide Counter

    QSizeF slideCounterSize(0, 0);

    if (mSlideCounter) {

        slideCounterSize = mSlideCounter->effectiveSizeHint(which, constraint);

        mSlideCounter->show();

    }

    // Audio Item

    QSizeF audioSize(0, 0);

    if (mAudioItem) {

        audioSize = mAudioItem->effectiveSizeHint(which, constraint);

        mAudioItem->show();

    // Text Item

    QSizeF textSize(0, 0);

    if (mTextItem) {

        textSize = mTextItem->effectiveSizeHint(which, constraint);

        mTextItem->show();

    }

    // Pixmap Item

    QSizeF pixmapSize(0, 0);

    if (mPixmapItem) {

        qreal imageWidth = mPixmapItem->icon().defaultSize().width();

        qreal imageHeight = mPixmapItem->icon().defaultSize().height();

        qreal widthToSet = 0.0;

        qreal heightToSet = 0.0;

        if (imageWidth < iconSize) {

            widthToSet = iconSize;

            heightToSet = iconSize;

        }

        else if (imageWidth <= maxWidth) {

            // resize not needed

            widthToSet = imageWidth;

            heightToSet = qMin(imageHeight, maxHeight);

        }

        else {

            // resize needed, keep aspect-ratio and resize

            widthToSet = maxWidth;

            heightToSet = maxWidth * (imageHeight / imageWidth);

            heightToSet = qMin(heightToSet, maxHeight);

        }

        if (heightToSet == maxHeight) {

            widthToSet = heightToSet * (imageWidth / imageHeight);

        }

        pixmapSize.setHeight(heightToSet);

        pixmapSize.setWidth(widthToSet);

        mPixmapItem->setPreferredSize(pixmapSize);

        mPixmapItem->show();

    }

    // Calculate the size hint to be returned.

    szHint.setHeight(0);

    if (!slideCounterSize.isNull()) {

        szHint.rheight() += (slideCounterSize.height() + spacing);

    }

    if (!audioSize.isNull()) {

        szHint.rheight() += (audioSize.height() + spacing);

    }

    if (mainWindow->orientation() == Qt::Horizontal) {

        qreal remainingHeight = qMax(pixmapSize.height(), textSize.height());

        if (remainingHeight > 0.0) {

            szHint.rheight() += (remainingHeight + spacing);

        }

    }

    else if (mainWindow->orientation() == Qt::Vertical) {

        if (!pixmapSize.isNull()) {

            szHint.rheight() += (pixmapSize.height() + spacing);

        }

        if (!textSize.isNull()) {

            szHint.rheight() += (textSize.height() + spacing);

        }

    }

    szHint.rheight() = qMax(maxHeight, szHint.height());

    return szHint;