src/gui/properties/speedplotview.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2021 Prince Gupta <guptaprince8832@gmail.com>
   4  * Copyright (C) 2015 Anton Lashkov <lenton_91@mail.ru>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "speedplotview.h"
  31
  32 #include <cmath>
  33
  34 #include <QLocale>
  35 #include <QPainter>
  36 #include <QPen>
  37
  38 #include "base/bittorrent/session.h"
  39 #include "base/global.h"
  40 #include "base/unicodestrings.h"
  41 #include "base/utils/misc.h"
  42
  43 namespace
  44 {
  45     // table of supposed nice steps for grid marks to get nice looking quarters of scale
  46     const qreal roundingTable[] = {1.2, 1.6, 2, 2.4, 2.8, 3.2, 4, 6, 8};
  47
  48     struct SplitValue
  49     {
  50         qreal arg = 0;
  51         Utils::Misc::SizeUnit unit {};
  52         qlonglong sizeInBytes() const
  53         {
  54             return Utils::Misc::sizeInBytes(arg, unit);
  55         }
  56     };
  57
  58     SplitValue getRoundedYScale(qreal value)
  59     {
  60         using Utils::Misc::SizeUnit;
  61
  62         if (value == 0.0) return {0, SizeUnit::Byte};
  63         if (value <= 12.0) return {12, SizeUnit::Byte};
  64
  65         SizeUnit calculatedUnit = SizeUnit::Byte;
  66         while (value > 1024)
  67         {
  68             value /= 1024;
  69             calculatedUnit = static_cast<SizeUnit>(static_cast<int>(calculatedUnit) + 1);
  70         }
  71
  72         if (value > 100)
  73         {
  74             const qreal roundedValue {std::ceil(value / 40) * 40};
  75             return {roundedValue, calculatedUnit};
  76         }
  77
  78         if (value > 10)
  79         {
  80             const qreal roundedValue {std::ceil(value / 4) * 4};
  81             return {roundedValue, calculatedUnit};
  82         }
  83
  84         for (const auto &roundedValue : roundingTable)
  85         {
  86             if (value <= roundedValue)
  87                 return {roundedValue, calculatedUnit};
  88         }
  89         return {10.0, calculatedUnit};
  90     }
  91
  92     QString formatLabel(const qreal argValue, const Utils::Misc::SizeUnit unit)
  93     {
  94         // check is there need for digits after decimal separator
  95         const int precision = (argValue < 10) ? friendlyUnitPrecision(unit) : 0;
  96         return QLocale::system().toString(argValue, 'f', precision)
  97                + QChar::Nbsp + unitString(unit, true);
  98     }
  99 }
 100
 101 SpeedPlotView::Averager::Averager(const milliseconds duration, const milliseconds resolution)
 102     : m_resolution {resolution}
 103     , m_maxDuration {duration}
 104     , m_sink {static_cast<DataCircularBuffer::size_type>(duration / resolution)}
 105 {
 106     m_lastSampleTime.start();
 107 }
 108
 109 bool SpeedPlotView::Averager::push(const SampleData &sampleData)
 110 {
 111     // Accumulator overflow will be hit in worst case on longest used averaging span,
 112     // defined by resolution. Maximum resolution is 144 seconds
 113     // Using int32 for accumulator we get overflow when transfer speed reaches 2^31/144 ~~ 14.2 MBytes/s.
 114     // With quint64 this speed limit is 2^64/144 ~~ 114 PBytes/s.
 115     // This speed is inaccessible to an ordinary user.
 116     ++m_counter;
 117     for (int id = UP; id < NB_GRAPHS; ++id)
 118         m_accumulator[id] += sampleData[id];
 119
 120     // system may go to sleep, that can cause very big elapsed interval
 121     const milliseconds updateInterval {static_cast<int64_t>(BitTorrent::Session::instance()->refreshInterval() * 1.25)};
 122     const milliseconds maxElapsed {std::max(updateInterval, m_resolution)};
 123     const milliseconds elapsed {std::min(milliseconds {m_lastSampleTime.elapsed()}, maxElapsed)};
 124     if (elapsed < m_resolution)
 125         return false; // still accumulating
 126
 127     // it is time final averaging calculations
 128     for (int id = UP; id < NB_GRAPHS; ++id)
 129         m_accumulator[id] /= m_counter;
 130
 131     m_currentDuration += elapsed;
 132
 133     // remove extra data from front if we reached max duration
 134     if (m_currentDuration > m_maxDuration)
 135     {
 136         // once we go above the max duration never go below that
 137         // otherwise it will cause empty space in graphs
 138         while (!m_sink.empty()
 139                && ((m_currentDuration - m_sink.front().duration) >= m_maxDuration))
 140         {
 141             m_currentDuration -= m_sink.front().duration;
 142             m_sink.pop_front();
 143         }
 144     }
 145
 146     // now flush out averaged data
 147     Q_ASSERT(m_sink.size() < m_sink.capacity());
 148     m_sink.push_back({elapsed, m_accumulator});
 149
 150     // reset
 151     m_accumulator = {};
 152     m_counter = 0;
 153     m_lastSampleTime.restart();
 154     return true;
 155 }
 156
 157 const SpeedPlotView::DataCircularBuffer &SpeedPlotView::Averager::data() const
 158 {
 159     return m_sink;
 160 }
 161
 162 SpeedPlotView::SpeedPlotView(QWidget *parent)
 163     : QGraphicsView {parent}
 164 {
 165     QPen greenPen;
 166     greenPen.setWidthF(1.5);
 167     greenPen.setColor(QColor(134, 196, 63));
 168     QPen bluePen;
 169     bluePen.setWidthF(1.5);
 170     bluePen.setColor(QColor(50, 153, 255));
 171
 172     m_properties[UP] = GraphProperties(tr("Total Upload"), bluePen);
 173     m_properties[DOWN] = GraphProperties(tr("Total Download"), greenPen);
 174
 175     bluePen.setStyle(Qt::DashLine);
 176     greenPen.setStyle(Qt::DashLine);
 177     m_properties[PAYLOAD_UP] = GraphProperties(tr("Payload Upload"), bluePen);
 178     m_properties[PAYLOAD_DOWN] = GraphProperties(tr("Payload Download"), greenPen);
 179
 180     bluePen.setStyle(Qt::DashDotLine);
 181     greenPen.setStyle(Qt::DashDotLine);
 182     m_properties[OVERHEAD_UP] = GraphProperties(tr("Overhead Upload"), bluePen);
 183     m_properties[OVERHEAD_DOWN] = GraphProperties(tr("Overhead Download"), greenPen);
 184
 185     bluePen.setStyle(Qt::DashDotDotLine);
 186     greenPen.setStyle(Qt::DashDotDotLine);
 187     m_properties[DHT_UP] = GraphProperties(tr("DHT Upload"), bluePen);
 188     m_properties[DHT_DOWN] = GraphProperties(tr("DHT Download"), greenPen);
 189
 190     bluePen.setStyle(Qt::DotLine);
 191     greenPen.setStyle(Qt::DotLine);
 192     m_properties[TRACKER_UP] = GraphProperties(tr("Tracker Upload"), bluePen);
 193     m_properties[TRACKER_DOWN] = GraphProperties(tr("Tracker Download"), greenPen);
 194 }
 195
 196 void SpeedPlotView::setGraphEnable(GraphID id, bool enable)
 197 {
 198     m_properties[id].enable = enable;
 199     viewport()->update();
 200 }
 201
 202 void SpeedPlotView::pushPoint(const SpeedPlotView::SampleData &point)
 203 {
 204     for (Averager *averager : {&m_averager5Min, &m_averager30Min
 205                                 , &m_averager6Hour, &m_averager12Hour
 206                                 , &m_averager24Hour})
 207     {
 208         if (averager->push(point))
 209         {
 210             if (m_currentAverager == averager)
 211                 viewport()->update();
 212         }
 213     }
 214 }
 215
 216 void SpeedPlotView::setPeriod(const TimePeriod period)
 217 {
 218     switch (period)
 219     {
 220     case SpeedPlotView::MIN1:
 221         m_currentMaxDuration = 1min;
 222         m_currentAverager = &m_averager5Min;
 223         break;
 224     case SpeedPlotView::MIN5:
 225         m_currentMaxDuration = 5min;
 226         m_currentAverager = &m_averager5Min;
 227         break;
 228     case SpeedPlotView::MIN30:
 229         m_currentMaxDuration = 30min;
 230         m_currentAverager = &m_averager30Min;
 231         break;
 232     case SpeedPlotView::HOUR3:
 233         m_currentMaxDuration = 3h;
 234         m_currentAverager = &m_averager6Hour;
 235         break;
 236     case SpeedPlotView::HOUR6:
 237         m_currentMaxDuration = 6h;
 238         m_currentAverager = &m_averager6Hour;
 239         break;
 240     case SpeedPlotView::HOUR12:
 241         m_currentMaxDuration = 12h;
 242         m_currentAverager = &m_averager12Hour;
 243         break;
 244     case SpeedPlotView::HOUR24:
 245         m_currentMaxDuration = 24h;
 246         m_currentAverager = &m_averager24Hour;
 247         break;
 248     }
 249
 250     viewport()->update();
 251 }
 252
 253 const SpeedPlotView::DataCircularBuffer &SpeedPlotView::currentData() const
 254 {
 255     return m_currentAverager->data();
 256 }
 257
 258 quint64 SpeedPlotView::maxYValue() const
 259 {
 260     const DataCircularBuffer &queue = currentData();
 261
 262     quint64 maxYValue = 0;
 263     for (int id = UP; id < NB_GRAPHS; ++id)
 264     {
 265
 266         if (!m_properties[static_cast<GraphID>(id)].enable)
 267             continue;
 268
 269         milliseconds duration {0};
 270         for (int i = static_cast<int>(queue.size()) - 1; i >= 0; --i)
 271         {
 272             maxYValue = std::max(maxYValue, queue[i].data[id]);
 273             duration += queue[i].duration;
 274             if (duration >= m_currentMaxDuration)
 275                 break;
 276         }
 277     }
 278
 279     return maxYValue;
 280 }
 281
 282 void SpeedPlotView::paintEvent(QPaintEvent *)
 283 {
 284     QPainter painter(viewport());
 285
 286     QRect fullRect = viewport()->rect();
 287     QRect rect = viewport()->rect();
 288     QFontMetrics fontMetrics = painter.fontMetrics();
 289
 290     rect.adjust(4, 4, 0, -4); // Add padding
 291     const SplitValue niceScale = getRoundedYScale(maxYValue());
 292     rect.adjust(0, fontMetrics.height(), 0, 0); // Add top padding for top speed text
 293
 294     // draw Y axis speed labels
 295     const QList<QString> speedLabels =
 296     {
 297         formatLabel(niceScale.arg, niceScale.unit),
 298         formatLabel((0.75 * niceScale.arg), niceScale.unit),
 299         formatLabel((0.50 * niceScale.arg), niceScale.unit),
 300         formatLabel((0.25 * niceScale.arg), niceScale.unit),
 301         formatLabel(0.0, niceScale.unit),
 302     };
 303
 304     int yAxisWidth = 0;
 305     for (const QString &label : speedLabels)
 306     {
 307         if (fontMetrics.horizontalAdvance(label) > yAxisWidth)
 308             yAxisWidth = fontMetrics.horizontalAdvance(label);
 309     }
 310
 311     int i = 0;
 312     for (const QString &label : speedLabels)
 313     {
 314         QRectF labelRect(rect.topLeft() + QPointF(-yAxisWidth, (i++) * 0.25 * rect.height() - fontMetrics.height()),
 315                          QSizeF(2 * yAxisWidth, fontMetrics.height()));
 316         painter.drawText(labelRect, label, Qt::AlignRight | Qt::AlignTop);
 317     }
 318
 319     // draw grid lines
 320     rect.adjust(yAxisWidth + 4, 0, 0, 0);
 321
 322     QPen gridPen;
 323     gridPen.setStyle(Qt::DashLine);
 324     gridPen.setWidthF(1);
 325     gridPen.setColor(QColor(128, 128, 128, 128));
 326     painter.setPen(gridPen);
 327
 328     painter.drawLine(fullRect.left(), rect.top(), rect.right(), rect.top());
 329     painter.drawLine(fullRect.left(), rect.top() + 0.25 * rect.height(), rect.right(), rect.top() + 0.25 * rect.height());
 330     painter.drawLine(fullRect.left(), rect.top() + 0.50 * rect.height(), rect.right(), rect.top() + 0.50 * rect.height());
 331     painter.drawLine(fullRect.left(), rect.top() + 0.75 * rect.height(), rect.right(), rect.top() + 0.75 * rect.height());
 332     painter.drawLine(fullRect.left(), rect.bottom(), rect.right(), rect.bottom());
 333
 334     const int TIME_AXIS_DIVISIONS = 6;
 335     for (int i = 0; i < TIME_AXIS_DIVISIONS; ++i)
 336     {
 337         const int x = rect.left() + (i * rect.width()) / TIME_AXIS_DIVISIONS;
 338         painter.drawLine(x, fullRect.top(), x, fullRect.bottom());
 339     }
 340
 341     // Set antialiasing for graphs
 342     painter.setRenderHints(QPainter::Antialiasing);
 343
 344     // draw graphs
 345     // averager is duration based, it may go little above the maxDuration
 346     painter.setClipping(true);
 347     painter.setClipRect(rect);
 348
 349     const DataCircularBuffer &queue = currentData();
 350
 351     // last point will be drawn at x=0, so we don't need it in the calculation of xTickSize
 352     const milliseconds lastDuration {queue.empty() ? 0ms : queue.back().duration};
 353     const qreal xTickSize = static_cast<qreal>(rect.width()) / (m_currentMaxDuration - lastDuration).count();
 354     const qreal yMultiplier = (niceScale.arg == 0) ? 0 : (static_cast<qreal>(rect.height()) / niceScale.sizeInBytes());
 355
 356     for (int id = UP; id < NB_GRAPHS; ++id)
 357     {
 358         if (!m_properties[static_cast<GraphID>(id)].enable)
 359             continue;
 360
 361         QList<QPoint> points;
 362         milliseconds duration {0};
 363
 364         for (int i = static_cast<int>(queue.size()) - 1; i >= 0; --i)
 365         {
 366             const int newX = rect.right() - (duration.count() * xTickSize);
 367             const int newY = rect.bottom() - (queue[i].data[id] * yMultiplier);
 368             points.push_back(QPoint(newX, newY));
 369
 370             duration += queue[i].duration;
 371             if (duration >= m_currentMaxDuration)
 372                 break;
 373         }
 374
 375         painter.setPen(m_properties[static_cast<GraphID>(id)].pen);
 376         painter.drawPolyline(points.data(), points.size());
 377     }
 378     painter.setClipping(false);
 379
 380     // draw legend
 381     QPoint legendTopLeft(rect.left() + 4, fullRect.top() + 4);
 382
 383     qreal legendHeight = 0;
 384     int legendWidth = 0;
 385     for (const auto &property : asConst(m_properties))
 386     {
 387         if (!property.enable)
 388             continue;
 389
 390         if (fontMetrics.horizontalAdvance(property.name) > legendWidth)
 391             legendWidth = fontMetrics.horizontalAdvance(property.name);
 392         legendHeight += 1.5 * fontMetrics.height();
 393     }
 394
 395     QRectF legendBackgroundRect(QPoint(legendTopLeft.x() - 4, legendTopLeft.y() - 4), QSizeF(legendWidth + 8, legendHeight + 8));
 396     QColor legendBackgroundColor = QWidget::palette().color(QWidget::backgroundRole());
 397     legendBackgroundColor.setAlpha(128);  // 50% transparent
 398     painter.fillRect(legendBackgroundRect, legendBackgroundColor);
 399
 400     i = 0;
 401     for (const auto &property : asConst(m_properties))
 402     {
 403         if (!property.enable)
 404             continue;
 405
 406         const int nameSize = fontMetrics.horizontalAdvance(property.name);
 407         const qreal indent = 1.5 * (i++) * fontMetrics.height();
 408
 409         painter.setPen(property.pen);
 410         painter.drawLine(legendTopLeft + QPointF(0, indent + fontMetrics.height()),
 411                          legendTopLeft + QPointF(nameSize, indent + fontMetrics.height()));
 412         painter.drawText(QRectF(legendTopLeft + QPointF(0, indent), QSizeF(2 * nameSize, fontMetrics.height())),
 413                          property.name, QTextOption(Qt::AlignVCenter));
 414     }
 415 }
 416
 417 SpeedPlotView::GraphProperties::GraphProperties()
 418     : enable(false)
 419 {
 420 }
 421
 422 SpeedPlotView::GraphProperties::GraphProperties(const QString &name, const QPen &pen, bool enable)
 423     : name(name)
 424     , pen(pen)
 425     , enable(enable)
 426 {
 427 }