diff -r 48060abbbeaf -r b3cee849fa46 perfmon/ui/hb/app/src/graphdatacontainer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/perfmon/ui/hb/app/src/graphdatacontainer.cpp	Tue Aug 31 15:15:20 2010 +0300
@@ -0,0 +1,188 @@
+/*
+* Copyright (c) 2010 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:
+*
+*/
+
+#include "graphdatacontainer.h"
+#include "enginewrapper.h"
+
+#include <QPainter>
+#include <QFontMetrics>
+
+const int amountOfMicroSecondsFitsScreen = 20 * 1000000;
+const int microToSecondMultiplier = 1000000;
+
+GraphDataContainer::GraphDataContainer(const EngineWrapper& engine, QGraphicsItem *parent) :
+    DataContainer(engine, parent)
+{
+    HbFontSpec spec(HbFontSpec::Secondary);
+    mFont = spec.font();
+    mFont.setPixelSize(12);
+}
+
+void GraphDataContainer::paint (QPainter *painter,
+    const QStyleOptionGraphicsItem *option,
+    QWidget *widget)
+{
+    Q_UNUSED(option);
+    Q_UNUSED(widget);
+
+    // set proper font and prepare font metrics for text width / height calculation
+    painter->setFont(mFont);
+    QFontMetricsF metrics(mFont);
+
+    // fill background with black color
+    painter->fillRect(rect(), Qt::black);
+
+    // calculate time factor
+    qreal scaleFactor = rect().width() / (qreal) amountOfMicroSecondsFitsScreen;
+
+    // calculate area height which is used to draw the grpahs
+    qreal drawAreaHeight = rect().height() - 2 * metrics.height();
+
+
+    const QList<SampleEntry> sampleEntries = engine().sampleEntries();
+
+    // check if sample array has been constructed
+    if (sampleEntries.length())
+    {
+        // draw vertical time lines first
+        int verticalBarPeriodInSecs = engine().settings().graphVerticalBarPeriod();
+
+        if (verticalBarPeriodInSecs >= 1 && sampleEntries.first().sampleCount() > 0)
+        {
+            // get time from the first sample
+            const SampleData& firstSample = sampleEntries.first().sample(0);
+            qint64 currentMicroSeconds = firstSample.mTimeFromStart;
+
+            // calculate amount of microseconds exceeding value by using the modulo operator
+            int remainderInMicroSeconds = currentMicroSeconds % (verticalBarPeriodInSecs * 1000000);
+
+            // calculate first x pos
+            qreal vbarXpos = rect().width() - (remainderInMicroSeconds * scaleFactor);
+
+            // calculate the amount in seconds
+            int barSeconds = (currentMicroSeconds - remainderInMicroSeconds) / microToSecondMultiplier;
+
+            // continue drawing periodically the vertical lines
+            while (vbarXpos >= 0 && barSeconds >= 0)
+            {
+                // draw vertical line
+                painter->setPen(Qt::darkRed);
+                painter->drawLine(QPointF(vbarXpos, metrics.height() + 1),
+                                  QPointF(vbarXpos, rect().height() - metrics.height()));
+
+                // draw seconds value
+                painter->setPen(Qt::darkGray);
+                QString secsText = QString("%1s").arg(barSeconds);
+                QPointF secsPos(vbarXpos - metrics.width(secsText) / 2,
+                                rect().height());
+                painter->drawText(secsPos, secsText);
+
+                // calculate new position
+                vbarXpos -= verticalBarPeriodInSecs * 1000000 * scaleFactor;
+                barSeconds -= verticalBarPeriodInSecs;
+            }
+        }
+
+        // draw the basic grid
+        painter->setPen(Qt::darkGray);
+
+        qreal axisY = metrics.height();
+        painter->drawLine(QPointF(0, axisY), QPointF(rect().width(), axisY)); // upper line
+        painter->drawText(QPointF(0, axisY), tr("100%"));
+
+        axisY = rect().height() / 2;
+        painter->drawLine(QPointF(0, axisY), QPointF(rect().width(), axisY)); // mid line
+        painter->drawText(QPointF(0, axisY), tr("50%"));
+
+        axisY = rect().height() - metrics.height();
+        painter->drawLine(QPointF(0, axisY), QPointF(rect().width(), axisY)); // bottom line
+        painter->drawText(QPointF(0, axisY), tr("0%"));
+
+        int c = 0;
+        // draw graphs for each sampled type
+        for (int i=0; i<sampleEntries.length(); i++)
+        {
+            // check if this setting has been enabled and it has some data
+            if (engine().settings().graphSources().isEnabled(i) &&
+                sampleEntries.at(i).sampleCount() > 0)
+            {
+                // set pen color for the graph
+                painter->setPen(sampleEntries.at(i).graphColor());
+
+                // remember the position where drawing started
+                qreal currentXPos(rect().width()); // start drawing from right
+                qreal currentYPos(0.);
+
+                // draw samples
+                for (int j=0; j<sampleEntries.at(i).sampleCount()-1; j++)
+                {
+                    const SampleData& currentSample = sampleEntries.at(i).sample(j);
+                    const SampleData& previousSample = sampleEntries.at(i).sample(j+1);
+
+                    // calculate X position for previous (j+1)
+                    qreal previousXPos = currentXPos -
+                        qAbs(previousSample.mTimeFromStart - currentSample.mTimeFromStart) * scaleFactor;
+
+
+                    // calculate initial Y position
+                    if (j==0)
+                    {
+                        currentYPos = currentSample.mSize > 0 ?
+                            drawAreaHeight * currentSample.mFree / currentSample.mSize + metrics.height() :
+                            rect().height() - metrics.height();
+                    }
+
+                    // calculate Y position for previous (j+1)
+                    qreal previousYPos = previousSample.mSize > 0 ?
+                        drawAreaHeight * previousSample.mFree / previousSample.mSize + metrics.height() :
+                        rect().height() - metrics.height();
+
+
+                    // draw a line between the previous and current
+                    painter->drawLine(QPointF(previousXPos, previousYPos),
+                                      QPointF(currentXPos, currentYPos));
+
+                    // draw current value in %
+                    if (j==0) // draw the value of first sample
+                    {
+                        qreal perc = currentSample.mSize > 0 ?
+                                     100. - 100. * currentSample.mFree / currentSample.mSize : 0;
+                        QString percText = QString ("%1 %2%").
+                                           arg(sampleEntries.at(i).description()).
+                                           arg(perc, 0, 'f', 0);
+
+                        painter->drawText(QPointF(0, metrics.height() * (c + 2)),
+                                          percText);
+                        c++;
+                    }
+
+
+                    // stop drawing if we have run out of space
+                    if (previousXPos < 0)
+                        break;
+
+                    // remeber previous values
+                    currentXPos = previousXPos;
+                    currentYPos = previousYPos;
+                }
+
+
+            }
+        }
+
+    }
+}