applet/system_monitor.cpp

   1 /***********************************************************************************
   2 * System Monitor: Plasmoid and data engines to monitor CPU/Memory/Swap Usage.
   3 * Copyright (C) 2008  Matthew Dawson
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License
   7 * as published by the Free Software Foundation; either version 2
   8 * of the License, or (at your option) any later version.
   9 *
  10 * This program is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write to the Free Software
  17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 *
  19 ***********************************************************************************/
  20
  21 #include "system_monitor.h"
  22
  23 #include <Plasma/ToolTipManager>
  24 //#include <Plasma/ToolTipContent>
  25 #include "plasma/tooltipcontent.h"
  26
  27 #include <KConfigDialog>
  28
  29 #include <QPainter>
  30
  31 #include <cmath>
  32
  33 systemMonitor::systemMonitor(QObject *parent, const QVariantList &args)
  34                 : Plasma::Applet(parent, args),
  35                 m_ramfree(0),
  36                 m_ramused(0),
  37                 m_rambuffers(0),
  38                 m_ramcached(0),
  39                 m_ramtotal(1),
  40                 m_swapfree(0),
  41                 m_swapused(0),
  42                 m_swaptotal(1){
  43
  44         m_cpuInfo.resize(1);
  45         setHasConfigurationInterface(true);
  46         resize(100, 100);
  47
  48 }
  49 systemMonitor::~systemMonitor(){
  50
  51         if(hasFailedToLaunch()){
  52
  53         }else {
  54
  55         }
  56
  57 }
  58
  59 void systemMonitor::init(){
  60
  61         readConfig();
  62
  63         sys_mon = dataEngine("systemmonitor");
  64         connect(sys_mon, SIGNAL(sourceAdded(const QString &)), this, SLOT(sourcesAdded(const QString &)));
  65         reconnectSources();
  66
  67         Plasma::ToolTipManager::self()->registerWidget(this);
  68
  69 }
  70
  71 void systemMonitor::reconnectSources(){
  72
  73         reconnectCPUSources();
  74
  75         sys_mon->connectSource("mem/physical/used", this, 500);
  76         sys_mon->connectSource("mem/physical/free", this, 500);
  77         sys_mon->connectSource("mem/physical/buf", this, 500);
  78         sys_mon->connectSource("mem/physical/cached", this, 500);
  79
  80         sys_mon->connectSource("mem/swap/used", this, 500);
  81         sys_mon->connectSource("mem/swap/free", this, 500);
  82
  83 }
  84
  85 void systemMonitor::reconnectCPUSources(){
  86
  87         sys_mon->connectSource("cpu/system/user", this, 500);
  88         sys_mon->connectSource("cpu/system/sys", this, 500);
  89         sys_mon->connectSource("cpu/system/nice", this, 500);
  90         sys_mon->connectSource("cpu/system/wait", this, 500);
  91         sys_mon->connectSource("cpu/system/idle", this, 500);
  92
  93 }
  94
  95 void systemMonitor::disconnectSources(){
  96
  97         sys_mon->disconnectSource("mem/physical/used", this);
  98         sys_mon->disconnectSource("mem/physical/free", this);
  99         sys_mon->disconnectSource("mem/physical/buf", this);
 100         sys_mon->disconnectSource("mem/physical/cached", this);
 101
 102         sys_mon->disconnectSource("mem/swap/used", this);
 103         sys_mon->disconnectSource("mem/swap/free", this);
 104
 105 }
 106
 107 void systemMonitor::sourcesAdded(const QString &source){
 108
 109         if(source.startsWith("cpu/system/") && !m_showMultiCPU){
 110
 111                 if(source.endsWith("/user") || source.endsWith("/sys") || source.endsWith("/nice") || source.endsWith("/wait") || source.endsWith("/idle")){
 112
 113                         sys_mon->connectSource(source, this, 500);
 114
 115                 }
 116
 117         }else if(source.startsWith("mem/swap")){
 118
 119                 sys_mon->connectSource(source, this, 500);
 120
 121         }else if(source.startsWith("mem/physical/")){
 122
 123                 if(!source.endsWith("application")){
 124
 125                         sys_mon->connectSource(source, this, 500);
 126
 127                 }
 128
 129         }
 130
 131 }
 132
 133 void systemMonitor::constraintsEvent(Plasma::Constraints constraints){
 134
 135         if(constraints.testFlag(Plasma::FormFactorConstraint)){
 136
 137                 if(formFactor() == Plasma::Planar || formFactor() == Plasma::MediaCenter){
 138                         setAspectRatioMode(Plasma::IgnoreAspectRatio);
 139                 }else {
 140                         setAspectRatioMode(Plasma::ConstrainedSquare);
 141                 }
 142
 143                 //If only StandardBackground is set, it should be completely transparent. (it gets
 144                 //set in Plasma::Applet on certain conditions.
 145                 if(backgroundHints() == StandardBackground){
 146                         setBackgroundHints(NoBackground);
 147                 }
 148
 149         }
 150
 151 }
 152
 153 void systemMonitor::createConfigurationInterface(KConfigDialog *parent){
 154
 155         QWidget *widGeneral = new QWidget();
 156         uiGeneral.setupUi(widGeneral);
 157
 158         uiGeneral.chkIsVertical->setChecked(m_isVertical);
 159         uiGeneral.chkUseOxygen->setChecked(m_useOxygen);
 160         uiGeneral.kcmbBackground->setItemData(0, DefaultBackground);
 161         uiGeneral.kcmbBackground->setItemData(1, TranslucentBackground);
 162         uiGeneral.kcmbBackground->setItemData(2, NoBackground);
 163
 164         switch( (int)backgroundHints() ){
 165
 166                 case (int)DefaultBackground:
 167                         uiGeneral.kcmbBackground->setCurrentIndex(0);
 168                         break;
 169                 //StandardBackground may get set.  Doesn't effect drawing, so this just makes sure we catch it.
 170                 case (int)TranslucentBackground:
 171                 case (int)TranslucentBackground | StandardBackground:
 172                         uiGeneral.kcmbBackground->setCurrentIndex(1);
 173                         break;
 174                 case (int)NoBackground:
 175                         uiGeneral.kcmbBackground->setCurrentIndex(2);
 176                         break;
 177                 default:
 178                         Q_ASSERT("Unknown background hints!");
 179                         break;
 180
 181         }
 182
 183         QWidget *widColours = new QWidget();
 184         uiColours.setupUi(widColours);
 185
 186         uiColours.kcbCpuUser->setColor(this->m_cpuUserColour);
 187         uiColours.kcbCpuNice->setColor(this->m_cpuNiceColour);
 188         uiColours.kcbCpuDisk->setColor(this->m_cpuDiskColour);
 189         uiColours.kcbCpuSystem->setColor(this->m_cpuSysColour);
 190         uiColours.kcbRamBuffers->setColor(this->m_ramBuffersColour);
 191         uiColours.kcbRamCached->setColor(this->m_ramCachedColour);
 192         uiColours.kcbRamUser->setColor(this->m_ramUsedColour);
 193         uiColours.kcbSwap->setColor(this->m_swapUsedColour);
 194
 195         parent->setButtons (KDialog::Ok | KDialog::Cancel | KDialog::Apply );
 196         connect(parent, SIGNAL(applyClicked()), this, SLOT(configUpdated()));
 197         connect(parent, SIGNAL(okClicked()), this, SLOT(configUpdated()));
 198
 199         parent->addPage(widGeneral, "General", icon(), QString(), false);
 200         parent->addPage(widColours, "Colours", icon(), QString(), false);
 201
 202         parent->setFaceType(KConfigDialog::Tabbed);
 203
 204 }
 205
 206 void systemMonitor::configUpdated(){
 207
 208         KConfigGroup cg = config();
 209
 210         if(uiGeneral.kcmbBackground->itemData(uiGeneral.kcmbBackground->currentIndex()).toInt() != (int)this->backgroundHints()){
 211                 this->setBackgroundHints(QFlag(uiGeneral.kcmbBackground->itemData(uiGeneral.kcmbBackground->currentIndex()).toInt()));
 212                 cg.writeEntry("background", (int)this->backgroundHints());
 213         }
 214
 215         if(uiGeneral.chkIsVertical->isChecked() != this->m_isVertical){
 216                 this->m_isVertical = uiGeneral.chkIsVertical->isChecked();
 217                 cg.writeEntry("vertical", this->m_isVertical);
 218         }
 219         if(uiGeneral.chkUseOxygen->isChecked() != this->m_useOxygen){
 220                 this->m_useOxygen = uiGeneral.chkUseOxygen->isChecked();
 221                 cg.writeEntry("use_oxygen", this->m_useOxygen);
 222         }
 223         if(uiColours.kcbCpuUser->color() != this->m_cpuUserColour){
 224                 this->m_cpuUserColour = uiColours.kcbCpuUser->color();
 225                 cg.writeEntry("colour_cpu_user", this->m_cpuUserColour.name());
 226         }
 227         if(uiColours.kcbCpuNice->color() != this->m_cpuNiceColour){
 228                 this->m_cpuNiceColour = uiColours.kcbCpuNice->color();
 229                 cg.writeEntry("colour_cpu_nice", this->m_cpuNiceColour.name());
 230         }
 231         if(uiColours.kcbCpuDisk->color() != this->m_cpuDiskColour){
 232                 this->m_cpuDiskColour = uiColours.kcbCpuDisk->color();
 233                 cg.writeEntry("colour_cpu_disk", this->m_cpuDiskColour.name());
 234         }
 235         if(uiColours.kcbCpuSystem->color() != this->m_cpuSysColour){
 236                 this->m_cpuSysColour = uiColours.kcbCpuSystem->color();
 237                 cg.writeEntry("colour_cpu_sys", this->m_cpuSysColour.name());
 238         }
 239         if(uiColours.kcbRamCached->color() != this->m_ramCachedColour){
 240                 this->m_ramCachedColour = uiColours.kcbRamCached->color();
 241                 cg.writeEntry("colour_ram_cached", this->m_ramCachedColour.name());
 242         }
 243         if(uiColours.kcbRamBuffers->color() != this->m_ramBuffersColour){
 244                 this->m_ramBuffersColour = uiColours.kcbRamBuffers->color();
 245                 cg.writeEntry("colour_ram_buffers", this->m_ramBuffersColour.name());
 246         }
 247         if(uiColours.kcbRamUser->color() != this->m_ramUsedColour){
 248                 this->m_ramUsedColour = uiColours.kcbRamUser->color();
 249                 cg.writeEntry("colour_ram_used", this->m_ramUsedColour.name());
 250         }
 251         if(uiColours.kcbSwap->color() != this->m_swapUsedColour){
 252                 this->m_swapUsedColour = uiColours.kcbSwap->color();
 253                 cg.writeEntry("colour_swap_used", this->m_swapUsedColour.name());
 254         }
 255
 256         emit configNeedsSaving();
 257         update();
 258
 259 }
 260
 261 void systemMonitor::dataUpdated(const QString& source, const Plasma::DataEngine::Data &data){
 262
 263         if(source.startsWith("cpu/system/") && !m_showMultiCPU){
 264
 265                 if(source.endsWith("/user")){
 266
 267                         m_cpuInfo[0].user = (data["value"].toString().toDouble()) / 100;
 268
 269                 }else if(source.endsWith("/sys")){
 270
 271                         m_cpuInfo[0].sys = (data["value"].toString().toDouble()) / 100;
 272
 273                 }else if(source.endsWith("/nice")){
 274
 275                         m_cpuInfo[0].nice = (data["value"].toString().toDouble()) / 100;
 276
 277                 }else if(source.endsWith("/wait")){
 278
 279                         m_cpuInfo[0].disk = (data["value"].toString().toDouble()) / 100;
 280
 281                 }else if(source.endsWith("/idle")){
 282
 283                         m_cpuInfo[0].idle = (data["value"].toString().toDouble()) / 100;
 284
 285                 }
 286
 287         }else if(source.startsWith("mem/swap")){
 288
 289                 if(source.endsWith("/used")){
 290
 291                         m_swapused = data["value"].toDouble() / 100;
 292
 293                 }else if(source.endsWith("/free")){
 294
 295                         m_swapfree = data["value"].toDouble() / 100;
 296
 297                 }
 298
 299                 m_swaptotal = m_swapfree + m_swapused;
 300
 301                 if(m_swaptotal == 0){
 302
 303                         m_swaptotal = 1;
 304
 305                 }
 306
 307                 update();
 308
 309         }else if(source.startsWith("mem/physical/")){
 310
 311                 if(source.endsWith("/used")){
 312
 313                         m_ramused = data["value"].toDouble();
 314
 315                 }else if(source.endsWith("/cached")){
 316
 317                         m_ramcached = data["value"].toDouble();
 318
 319                 }else if(source.endsWith("/buf")){
 320
 321                         m_rambuffers = data["value"].toDouble();
 322
 323                 }else if(source.endsWith("/free")){
 324
 325                         m_ramfree = data["value"].toDouble();
 326
 327                 }
 328
 329                 m_ramtotal = m_ramused + m_ramcached + m_rambuffers + m_ramfree;
 330
 331                 if(m_ramtotal == 0){
 332
 333                         m_ramtotal = 1;
 334
 335                 }
 336
 337         }
 338
 339 }
 340
 341 void systemMonitor::paintCPUUsage(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect& contentsRect, const cpuInfo &cpu){
 342
 343         Q_UNUSED(option)
 344
 345         p->save();
 346
 347         p->translate(0, contentsRect.height() * cpu.idle);
 348
 349
 350         p->setBrush(this->m_cpuUserColour);
 351         p->setPen(this->m_cpuUserColour);
 352
 353         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * cpu.user));
 354         p->translate(0, contentsRect.height() * cpu.user);
 355
 356
 357         p->setBrush(this->m_cpuNiceColour);
 358         p->setPen(this->m_cpuNiceColour);
 359
 360         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * cpu.nice));
 361         p->translate(0, contentsRect.height() * cpu.nice);
 362
 363
 364         p->setBrush(this->m_cpuDiskColour);
 365         p->setPen(this->m_cpuDiskColour);
 366
 367         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * cpu.disk));
 368         p->translate(0, contentsRect.height() * cpu.disk);
 369
 370
 371         p->setBrush(this->m_cpuSysColour);
 372         p->setPen(this->m_cpuSysColour);
 373
 374         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * cpu.sys));
 375
 376         p->restore();
 377
 378 }
 379
 380 void systemMonitor::paintSwapUsage(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect& contentsRect){
 381
 382         Q_UNUSED(option)
 383
 384         p->save();
 385
 386         p->translate(0, contentsRect.height() * m_swapfree / m_swaptotal);
 387
 388
 389         p->setBrush(this->m_swapUsedColour);
 390         p->setPen(this->m_swapUsedColour);
 391
 392         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * m_swapused / m_swaptotal));
 393
 394         p->restore();
 395
 396 }
 397
 398 void systemMonitor::paintRAMUsage(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect& contentsRect){
 399
 400         Q_UNUSED(option)
 401
 402         p->save();
 403
 404         p->translate(0, contentsRect.height() * m_ramfree / m_ramtotal);
 405
 406
 407         p->setBrush(this->m_ramCachedColour);
 408         p->setPen(this->m_ramCachedColour);
 409
 410         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * m_ramcached / m_ramtotal));
 411         p->translate(0, contentsRect.height() * m_ramcached / m_ramtotal);
 412
 413
 414         p->setBrush(this->m_ramBuffersColour);
 415         p->setPen(this->m_ramBuffersColour);
 416
 417         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * m_rambuffers / m_ramtotal));
 418         p->translate(0, contentsRect.height() * m_rambuffers / m_ramtotal);
 419
 420
 421         p->setBrush(this->m_ramUsedColour);
 422         p->setPen(this->m_ramUsedColour);
 423
 424         p->drawRect(QRectF(contentsRect.left(), contentsRect.top(), contentsRect.width(), contentsRect.height() * m_ramused / m_ramtotal));
 425
 426         p->restore();
 427
 428 }
 429
 430 void systemMonitor::paintFrontGlass(QPainter* p, const QStyleOptionGraphicsItem *option, const QRect& contentsRect) {
 431
 432         Q_UNUSED(option);
 433
 434         QLinearGradient grad(0,contentsRect.top(),0,contentsRect.bottom());
 435         grad.setColorAt(0,QColor(255,255,255, 30));
 436         grad.setColorAt(1,QColor(  0,  0,  0,150));
 437         p->setBrush(grad);
 438         p->setPen(QColor(0,0,0,100));
 439         p->drawRect(contentsRect);
 440
 441 }
 442
 443 void systemMonitor::paintInterface(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect& contentsRect){
 444
 445         p->setRenderHint(QPainter::SmoothPixmapTransform);
 446         p->setRenderHint(QPainter::Antialiasing);
 447
 448         QRect rotatedContentsRect(contentsRect);
 449
 450
 451         if(!this->m_isVertical && (this->formFactor() == Plasma::Horizontal || this->formFactor() == Plasma::Vertical) ){
 452                 p->setWorldTransform(QTransform().rotate(90).translate(0, -(contentsRect.width() + contentsRect.x() * 2)));
 453                 rotatedContentsRect.setWidth(contentsRect.height());
 454                 rotatedContentsRect.setHeight(contentsRect.width());
 455         }
 456
 457         int origWidth = rotatedContentsRect.width();
 458
 459         if(m_useOxygen){
 460                 rotatedContentsRect.setWidth(rotatedContentsRect.width() * 0.325);
 461                 rotatedContentsRect.moveLeft(rotatedContentsRect.left() + origWidth * 0.009);
 462         }else{
 463                 rotatedContentsRect.setWidth(rotatedContentsRect.width() * 0.33);
 464         }
 465
 466         paintCPUUsage(p, option, rotatedContentsRect, m_cpuInfo[0]);
 467         if(m_useOxygen){
 468                 paintFrontGlass(p, option, rotatedContentsRect);
 469         }
 470         rotatedContentsRect.moveLeft(rotatedContentsRect.left() + 0.33*origWidth);
 471
 472         paintRAMUsage(p, option, rotatedContentsRect);
 473         if(m_useOxygen){
 474                 paintFrontGlass(p, option, rotatedContentsRect);
 475         }
 476         rotatedContentsRect.moveLeft(rotatedContentsRect.left() + 0.33*origWidth);
 477
 478         paintSwapUsage(p, option, rotatedContentsRect);
 479         if(m_useOxygen){
 480                 paintFrontGlass(p, option, rotatedContentsRect);
 481         }
 482
 483
 484 }
 485
 486 void systemMonitor::readConfig(){
 487
 488         KConfigGroup cg = config();
 489
 490         this->m_isVertical = cg.readEntry("vertical", true);
 491         this->m_useOxygen = cg.readEntry("use_oxygen", false);
 492         this->m_showMultiCPU = false;
 493
 494         this->m_cpuUserColour = QColor( cg.readEntry("colour_cpu_user", QString("#0000FF")) );
 495         this->m_cpuNiceColour = QColor( cg.readEntry("colour_cpu_nice", QString("#FFFF00")) );
 496         this->m_cpuDiskColour = QColor( cg.readEntry("colour_cpu_disk", QString("#006400")) );
 497         this->m_cpuSysColour = QColor( cg.readEntry("colour_cpu_sys", QString("#FF0000")) );
 498         this->m_ramCachedColour = QColor( cg.readEntry("colour_ram_cached", QString("#007800")) );
 499         this->m_ramBuffersColour = QColor( cg.readEntry("colour_ram_buffers", QString("#FFFF00")) );
 500         this->m_ramUsedColour = QColor( cg.readEntry("colour_ram_used", QString("#0000B1")) );
 501         this->m_swapUsedColour = QColor( cg.readEntry("colour_swap_used", QString("#00CDCD")) );
 502
 503         this->setBackgroundHints(QFlag(cg.readEntry("background", (int)(TranslucentBackground))));
 504
 505 }
 506
 507 void systemMonitor::toolTipAboutToShow(){
 508
 509         Plasma::ToolTipManager::self()->setContent(this, Plasma::ToolTipContent("System Status:", QString("CPU usage: %1%<br>Ram Usage: %2%<br>Swap Usage: %3%").arg( round((1 - m_cpuInfo[0].idle) * 100)).arg( round((1 - m_ramfree / m_ramtotal) * 100)).arg( round((1 - m_swapfree / m_swaptotal) * 100 ))));
 510
 511 }
 512
 513 #include "system_monitor.moc"