workspace/ksysguard/gui/SensorDisplayLib/SensorLogger.cc

   1 /*
   2     KSysGuard, the KDE System Guard
   3
   4     Copyright (c) 2001 Tobias Koenig <tokoe@kde.org>
   5
   6     This program is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU General Public
   8     License as published by the Free Software Foundation; either
   9     version 2 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 */
  21
  22 #include <QtCore/QAbstractTableModel>
  23 #include <QtCore/QDate>
  24 #include <QtCore/QFile>
  25 #include <QtCore/QTextStream>
  26 #include <QtGui/QContextMenuEvent>
  27 #include <QtGui/QHeaderView>
  28 #include <QtGui/QMenu>
  29 #include <QtGui/QTreeView>
  30 #include <QtGui/QHBoxLayout>
  31 #include <QtXml/QDomNodeList>
  32 #include <QtXml/QDomDocument>
  33 #include <QtXml/QDomElement>
  34
  35 #include <kapplication.h>
  36 #include <kiconloader.h>
  37 #include <klocale.h>
  38 #include <knotification.h>
  39 #include <ksgrd/SensorManager.h>
  40 #include <kdebug.h>
  41 #include "StyleEngine.h"
  42
  43 #include "SensorLoggerDlg.h"
  44 #include "SensorLoggerSettings.h"
  45 #include "SensorLogger.h"
  46
  47 #define NONE -1
  48
  49 LogSensorView::LogSensorView( QWidget *parent )
  50  : QTreeView( parent )
  51 {
  52 }
  53
  54 void LogSensorView::contextMenuEvent( QContextMenuEvent *event )
  55 {
  56   const QModelIndex index = indexAt( event->pos() );
  57
  58   emit contextMenuRequest( index, viewport()->mapToGlobal( event->pos() ) );
  59 }
  60
  61 class LogSensorModel : public QAbstractTableModel
  62 {
  63   public:
  64     LogSensorModel( QObject *parent = 0 )
  65       : QAbstractTableModel( parent )
  66     {
  67     }
  68
  69     virtual int columnCount( const QModelIndex &parent = QModelIndex() ) const
  70     {
  71       Q_UNUSED( parent );
  72
  73       return 5;
  74     }
  75
  76     virtual int rowCount( const QModelIndex &parent = QModelIndex() ) const
  77     {
  78       Q_UNUSED( parent );
  79
  80       return mSensors.count();
  81     }
  82
  83     virtual QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const
  84     {
  85       if ( !index.isValid() )
  86         return QVariant();
  87
  88       if ( index.row() >= mSensors.count() || index.row() < 0 )
  89         return QVariant();
  90
  91       LogSensor *sensor = mSensors[ index.row() ];
  92
  93       if ( role == Qt::DisplayRole ) {
  94         switch ( index.column() ) {
  95           case 1:
  96             return sensor->timerInterval();
  97             break;
  98           case 2:
  99             return sensor->sensorName();
 100             break;
 101           case 3:
 102             return sensor->hostName();
 103             break;
 104           case 4:
 105             return sensor->fileName();
 106             break;
 107         }
 108       } else if ( role == Qt::DecorationRole ) {
 109         static QPixmap runningPixmap = KIconLoader::global()->loadIcon( "running", KIconLoader::Small, KIconLoader::SizeSmall );
 110         static QPixmap waitingPixmap = KIconLoader::global()->loadIcon( "waiting", KIconLoader::Small, KIconLoader::SizeSmall );
 111
 112         if ( index.column() == 0 ) {
 113           if ( sensor->isLogging() )
 114             return runningPixmap;
 115           else
 116             return waitingPixmap;
 117         }
 118       } else if ( role == Qt::ForegroundRole ) {
 119         if ( sensor->limitReached() )
 120           return mAlarmColor;
 121         else
 122           return mForegroundColor;
 123       } else if ( role == Qt::BackgroundRole ) {
 124           return mBackgroundColor;
 125       }
 126
 127       return QVariant();
 128     }
 129
 130     virtual QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const
 131     {
 132       if ( orientation == Qt::Vertical )
 133         return QVariant();
 134
 135       if ( role == Qt::DisplayRole ) {
 136         switch ( section ) {
 137           case 0:
 138             return i18n("Logging");
 139             break;
 140           case 1:
 141             return i18n("Timer Interval");
 142             break;
 143           case 2:
 144             return i18n("Sensor Name");
 145             break;
 146           case 3:
 147             return i18n("Host Name");
 148             break;
 149           case 4:
 150             return i18n("Log File");
 151             break;
 152           default:
 153             return QVariant();
 154         }
 155       }
 156
 157       return QVariant();
 158     }
 159
 160     void addSensor( LogSensor *sensor )
 161     {
 162       mSensors.append( sensor );
 163
 164       connect( sensor, SIGNAL( changed() ), this, SIGNAL( layoutChanged() ) );
 165
 166       emit layoutChanged();
 167     }
 168
 169     void removeSensor( LogSensor *sensor )
 170     {
 171       delete mSensors.takeAt( mSensors.indexOf( sensor ) );
 172
 173       emit layoutChanged();
 174     }
 175
 176     LogSensor* sensor( const QModelIndex &index ) const
 177     {
 178       if ( !index.isValid() || index.row() >= mSensors.count() || index.row() < 0 )
 179         return 0;
 180
 181       return mSensors[ index.row() ];
 182     }
 183
 184     void clear()
 185     {
 186       qDeleteAll( mSensors );
 187       mSensors.clear();
 188     }
 189
 190     const QList<LogSensor*> sensors() const
 191     {
 192       return mSensors;
 193     }
 194
 195     void setForegroundColor( const QColor &color ) { mForegroundColor = color; }
 196     QColor foregroundColor() const { return mForegroundColor; }
 197
 198     void setBackgroundColor( const QColor &color ) { mBackgroundColor = color; }
 199     QColor backgroundColor() const { return mBackgroundColor; }
 200
 201     void setAlarmColor( const QColor &color ) { mAlarmColor = color; }
 202     QColor alarmColor() const { return mAlarmColor; }
 203
 204   private:
 205
 206     QColor mForegroundColor;
 207     QColor mBackgroundColor;
 208     QColor mAlarmColor;
 209
 210     QList<LogSensor*> mSensors;
 211 };
 212
 213 LogSensor::LogSensor( QObject *parent )
 214   : QObject( parent ),
 215     mTimerID( NONE ),
 216     mLowerLimitActive( false ),
 217     mUpperLimitActive( 0 ),
 218     mLowerLimit( 0 ),
 219     mUpperLimit( 0 ),
 220     mLimitReached( false )
 221 {
 222 }
 223
 224 LogSensor::~LogSensor()
 225 {
 226 }
 227
 228 void LogSensor::setHostName( const QString& name )
 229 {
 230   mHostName = name;
 231 }
 232
 233 QString LogSensor::hostName() const
 234 {
 235   return mHostName;
 236 }
 237
 238 void LogSensor::setSensorName( const QString& name )
 239 {
 240   mSensorName = name;
 241 }
 242
 243 QString LogSensor::sensorName() const
 244 {
 245   return mSensorName;
 246 }
 247
 248 void LogSensor::setFileName( const QString& name )
 249 {
 250   mFileName = name;
 251 }
 252
 253 QString LogSensor::fileName() const
 254 {
 255   return mFileName;
 256 }
 257
 258 void LogSensor::setUpperLimitActive( bool value )
 259 {
 260   mUpperLimitActive = value;
 261 }
 262
 263 bool LogSensor::upperLimitActive() const
 264 {
 265   return mUpperLimitActive;
 266 }
 267
 268 void LogSensor::setLowerLimitActive( bool value )
 269 {
 270   mLowerLimitActive = value;
 271 }
 272
 273 bool LogSensor::lowerLimitActive() const
 274 {
 275   return mLowerLimitActive;
 276 }
 277
 278 void LogSensor::setUpperLimit( double value )
 279 {
 280   mUpperLimit = value;
 281 }
 282
 283 double LogSensor::upperLimit() const
 284 {
 285   return mUpperLimit;
 286 }
 287
 288 void LogSensor::setLowerLimit( double value )
 289 {
 290   mLowerLimit = value;
 291 }
 292
 293 double LogSensor::lowerLimit() const
 294 {
 295   return mLowerLimit;
 296 }
 297
 298 void LogSensor::setTimerInterval( int interval )
 299 {
 300   mTimerInterval = interval;
 301
 302   if ( mTimerID != NONE ) {
 303     timerOff();
 304     timerOn();
 305   }
 306 }
 307
 308 int LogSensor::timerInterval() const
 309 {
 310   return mTimerInterval;
 311 }
 312
 313 bool LogSensor::isLogging() const
 314 {
 315   return mTimerID != NONE;
 316 }
 317
 318 bool LogSensor::limitReached() const
 319 {
 320   return mLimitReached;
 321 }
 322
 323 void LogSensor::timerOff()
 324 {
 325   if ( mTimerID > 0 )
 326     killTimer( mTimerID );
 327   mTimerID = NONE;
 328 }
 329
 330 void LogSensor::timerOn()
 331 {
 332   mTimerID = startTimer( mTimerInterval * 1000 );
 333 }
 334
 335 void LogSensor::startLogging()
 336 {
 337   timerOn();
 338 }
 339
 340 void LogSensor::stopLogging()
 341 {
 342   timerOff();
 343 }
 344
 345 void LogSensor::timerTick( )
 346 {
 347   KSGRD::SensorMgr->sendRequest( mHostName, mSensorName, (KSGRD::SensorClient*) this, 42 );
 348 }
 349
 350 void LogSensor::answerReceived( int id, const QList<QByteArray>& answer ) //virtual
 351 {
 352   QFile mLogFile( mFileName );
 353
 354   if ( !mLogFile.open( QIODevice::ReadWrite | QIODevice::Append ) ) {
 355     stopLogging();
 356     return;
 357   }
 358
 359   switch ( id ) {
 360     case 42: {
 361       QTextStream stream( &mLogFile );
 362       double value = 0;
 363       if ( !answer.isEmpty() )
 364         value = answer[ 0 ].toDouble();
 365
 366       if ( mLowerLimitActive && value < mLowerLimit ) {
 367         timerOff();
 368         mLimitReached = true;
 369
 370         // send notification
 371         KNotification::event( "sensor_alarm", QString( "sensor '%1' at '%2' reached lower limit" )
 372                             .arg( mSensorName ).arg( mHostName), QPixmap(), 0 );
 373
 374         timerOn();
 375       } else if ( mUpperLimitActive && value > mUpperLimit ) {
 376         timerOff();
 377         mLimitReached = true;
 378
 379         // send notification
 380         KNotification::event( "sensor_alarm", QString( "sensor '%1' at '%2' reached upper limit" )
 381                             .arg( mSensorName).arg( mHostName), QPixmap(), 0 );
 382
 383         timerOn();
 384       } else {
 385         mLimitReached = false;
 386       }
 387
 388       const QDate date = QDateTime::currentDateTime().date();
 389       const QTime time = QDateTime::currentDateTime().time();
 390
 391       stream << QString( "%1 %2 %3 %4 %5: %6\n" ).arg( date.shortMonthName( date.month() ) )
 392                                                  .arg( date.day() ).arg( time.toString() )
 393                                                  .arg( mHostName).arg( mSensorName ).arg( value );
 394     }
 395   }
 396
 397   emit changed();
 398
 399   mLogFile.close();
 400 }
 401
 402 SensorLogger::SensorLogger( QWidget *parent, const QString& title, SharedSettings *workSheetSettings )
 403   : KSGRD::SensorDisplay( parent, title, workSheetSettings )
 404 {
 405   mModel = new LogSensorModel( this );
 406   mModel->setForegroundColor( KSGRD::Style->firstForegroundColor() );
 407   mModel->setBackgroundColor( KSGRD::Style->backgroundColor() );
 408   mModel->setAlarmColor( KSGRD::Style->alarmColor() );
 409
 410   QLayout *layout = new QHBoxLayout(this);
 411   mView = new LogSensorView( this );
 412   layout->addWidget(mView);
 413   setLayout(layout);
 414
 415   mView->setContextMenuPolicy( Qt::CustomContextMenu );
 416   connect(mView, SIGNAL(customContextMenuRequested(const QPoint&)), SLOT(showContextMenu(const QPoint &)));
 417
 418   mView->header()->setStretchLastSection( true );
 419   mView->setRootIsDecorated( false );
 420   mView->setItemsExpandable( false );
 421   mView->setModel( mModel );
 422   setPlotterWidget( mView );
 423
 424   connect( mView, SIGNAL( contextMenuRequest( const QModelIndex&, const QPoint& ) ),
 425            this, SLOT( contextMenuRequest( const QModelIndex&, const QPoint& ) ) );
 426
 427   QPalette palette = mView->palette();
 428   palette.setColor( QPalette::Base, KSGRD::Style->backgroundColor() );
 429   mView->setPalette( palette );
 430
 431   setTitle( i18n( "Sensor Logger" ) );
 432   setMinimumSize( 50, 25 );
 433 }
 434
 435 SensorLogger::~SensorLogger(void)
 436 {
 437 }
 438
 439 bool SensorLogger::addSensor( const QString& hostName, const QString& sensorName, const QString& sensorType, const QString& )
 440 {
 441   if ( sensorType != "integer" && sensorType != "float" )
 442     return false;
 443
 444   SensorLoggerDlg dlg( this );
 445
 446   if ( dlg.exec() ) {
 447     if ( !dlg.fileName().isEmpty() ) {
 448       LogSensor *sensor = new LogSensor( mModel );
 449
 450       sensor->setHostName( hostName );
 451       sensor->setSensorName( sensorName );
 452       sensor->setFileName( dlg.fileName() );
 453       sensor->setTimerInterval( dlg.timerInterval() );
 454       sensor->setLowerLimitActive( dlg.lowerLimitActive() );
 455       sensor->setUpperLimitActive( dlg.upperLimitActive() );
 456       sensor->setLowerLimit( dlg.lowerLimit() );
 457       sensor->setUpperLimit( dlg.upperLimit() );
 458
 459       mModel->addSensor( sensor );
 460     }
 461   }
 462
 463   return true;
 464 }
 465
 466 bool SensorLogger::editSensor( LogSensor* sensor )
 467 {
 468   SensorLoggerDlg dlg( this );
 469
 470   dlg.setFileName( sensor->fileName() );
 471   dlg.setTimerInterval( sensor->timerInterval() );
 472   dlg.setLowerLimitActive( sensor->lowerLimitActive() );
 473   dlg.setLowerLimit( sensor->lowerLimit() );
 474   dlg.setUpperLimitActive( sensor->upperLimitActive() );
 475   dlg.setUpperLimit( sensor->upperLimit() );
 476
 477   if ( dlg.exec() ) {
 478     if ( !dlg.fileName().isEmpty() ) {
 479       sensor->setFileName( dlg.fileName() );
 480       sensor->setTimerInterval( dlg.timerInterval() );
 481       sensor->setLowerLimitActive( dlg.lowerLimitActive() );
 482       sensor->setUpperLimitActive( dlg.upperLimitActive() );
 483       sensor->setLowerLimit( dlg.lowerLimit() );
 484       sensor->setUpperLimit( dlg.upperLimit() );
 485     }
 486   }
 487
 488   return true;
 489 }
 490
 491 void SensorLogger::configureSettings()
 492 {
 493   SensorLoggerSettings dlg( this );
 494
 495   dlg.setTitle( title() );
 496   dlg.setForegroundColor( mModel->foregroundColor() );
 497   dlg.setBackgroundColor( mModel->backgroundColor() );
 498   dlg.setAlarmColor( mModel->alarmColor() );
 499
 500   if ( dlg.exec() ) {
 501     setTitle( dlg.title() );
 502
 503     mModel->setForegroundColor( dlg.foregroundColor() );
 504     mModel->setBackgroundColor( dlg.backgroundColor() );
 505     mModel->setAlarmColor( dlg.alarmColor() );
 506
 507     QPalette palette = mView->palette();
 508     palette.setColor( QPalette::Base, dlg.backgroundColor() );
 509     mView->setPalette( palette );
 510   }
 511 }
 512
 513 void SensorLogger::applyStyle()
 514 {
 515   mModel->setForegroundColor( KSGRD::Style->firstForegroundColor() );
 516   mModel->setBackgroundColor( KSGRD::Style->backgroundColor() );
 517   mModel->setAlarmColor( KSGRD::Style->alarmColor() );
 518
 519   QPalette palette = mView->palette();
 520   palette.setColor( QPalette::Base, KSGRD::Style->backgroundColor() );
 521   mView->setPalette( palette );
 522 }
 523
 524 bool SensorLogger::restoreSettings( QDomElement& element )
 525 {
 526   mModel->setForegroundColor( restoreColor( element, "textColor", Qt::green) );
 527   mModel->setBackgroundColor( restoreColor( element, "backgroundColor", Qt::black ) );
 528   mModel->setAlarmColor( restoreColor( element, "alarmColor", Qt::red ) );
 529
 530   mModel->clear();
 531
 532   QDomNodeList dnList = element.elementsByTagName( "logsensors" );
 533   for ( int i = 0; i < dnList.count(); i++ ) {
 534     QDomElement element = dnList.item( i ).toElement();
 535     LogSensor* sensor = new LogSensor( mModel );
 536
 537     sensor->setHostName( element.attribute("hostName") );
 538     sensor->setSensorName( element.attribute("sensorName") );
 539     sensor->setFileName( element.attribute("fileName") );
 540     sensor->setTimerInterval( element.attribute("timerInterval").toInt() );
 541     sensor->setLowerLimitActive( element.attribute("lowerLimitActive").toInt() );
 542     sensor->setLowerLimit( element.attribute("lowerLimit").toDouble() );
 543     sensor->setUpperLimitActive( element.attribute("upperLimitActive").toInt() );
 544     sensor->setUpperLimit( element.attribute("upperLimit").toDouble() );
 545
 546     mModel->addSensor( sensor );
 547   }
 548
 549   SensorDisplay::restoreSettings( element );
 550
 551   QPalette palette = mView->palette();
 552   palette.setColor( QPalette::Base, mModel->backgroundColor() );
 553   mView->setPalette( palette );
 554
 555   return true;
 556 }
 557
 558 bool SensorLogger::saveSettings( QDomDocument& doc, QDomElement& element )
 559 {
 560   saveColor( element, "textColor", mModel->foregroundColor() );
 561   saveColor( element, "backgroundColor", mModel->backgroundColor() );
 562   saveColor( element, "alarmColor", mModel->alarmColor() );
 563
 564   const QList<LogSensor*> sensors = mModel->sensors();
 565   for ( int i = 0; i < sensors.count(); ++i ) {
 566     LogSensor *sensor = sensors[ i ];
 567     QDomElement log = doc.createElement( "logsensors" );
 568     log.setAttribute("sensorName", sensor->sensorName());
 569     log.setAttribute("hostName", sensor->hostName());
 570     log.setAttribute("fileName", sensor->fileName());
 571     log.setAttribute("timerInterval", sensor->timerInterval());
 572     log.setAttribute("lowerLimitActive", QString("%1").arg(sensor->lowerLimitActive()));
 573     log.setAttribute("lowerLimit", QString("%1").arg(sensor->lowerLimit()));
 574     log.setAttribute("upperLimitActive", QString("%1").arg(sensor->upperLimitActive()));
 575     log.setAttribute("upperLimit", QString("%1").arg(sensor->upperLimit()));
 576
 577     element.appendChild( log );
 578   }
 579
 580   SensorDisplay::saveSettings( doc, element );
 581
 582   return true;
 583 }
 584
 585 void SensorLogger::answerReceived( int, const QList<QByteArray>& ) //virtual
 586 {
 587  // we do not use this, since all answers are received by the LogSensors
 588 }
 589
 590 void SensorLogger::contextMenuRequest( const QModelIndex &index, const QPoint &point )
 591 {
 592   LogSensor *sensor = mModel->sensor( index );
 593
 594   QMenu pm;
 595
 596   QAction *action = 0;
 597   if (hasSettingsDialog()) {
 598     action = pm.addAction(i18n("&Properties"));
 599     action->setData( 1 );
 600   }
 601   if(!mSharedSettings->locked) {
 602
 603     action = pm.addAction(i18n("&Remove Display"));
 604     action->setData( 2 );
 605
 606     pm.addSeparator();
 607
 608     action = pm.addAction(i18n("&Remove Sensor"));
 609     action->setData( 3 );
 610     if ( !sensor )
 611       action->setEnabled( false );
 612
 613     action = pm.addAction(i18n("&Edit Sensor..."));
 614     action->setData( 4 );
 615     if ( !sensor )
 616       action->setEnabled( false );
 617   }
 618
 619   if ( sensor ) {
 620     if ( sensor->isLogging() ) {
 621       action = pm.addAction(i18n("St&op Logging"));
 622       action->setData( 6 );
 623     } else {
 624       action = pm.addAction(i18n("S&tart Logging"));
 625       action->setData( 5 );
 626     }
 627   }
 628
 629   action = pm.exec( point );
 630   if ( !action )
 631     return;
 632
 633   switch (action->data().toInt())
 634   {
 635     case 1:
 636       configureSettings();
 637       break;
 638     case 2: {
 639       KSGRD::SensorDisplay::DeleteEvent *ev = new KSGRD::SensorDisplay::DeleteEvent( this );
 640       kapp->postEvent(parent(), ev);
 641       break;
 642       }
 643     case 3:
 644       if ( sensor )
 645         mModel->removeSensor( sensor );
 646       break;
 647     case 4:
 648       if ( sensor )
 649         editSensor( sensor );
 650       break;
 651     case 5:
 652       if ( sensor )
 653         sensor->startLogging();
 654       break;
 655     case 6:
 656       if ( sensor )
 657         sensor->stopLogging();
 658       break;
 659   }
 660 }
 661
 662 #include "SensorLogger.moc"