workspace/ksysguard/gui/SensorDisplayLib/DancingBars.cc

   1 /*
   2     KSysGuard, the KDE System Guard
   3
   4     Copyright (c) 1999, 2000, 2001 Chris Schlaeger <cs@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 version 2 or at your option version 3 as published by
   9     the Free Software Foundation.
  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 <QCheckBox>
  23 #include <QtXml/qdom.h>
  24 #include <QLineEdit>
  25 #include <QPushButton>
  26 #include <QSpinBox>
  27 #include <QHBoxLayout>
  28
  29 #include <kdebug.h>
  30 #include <klocale.h>
  31 #include <knumvalidator.h>
  32 #include <ksgrd/SensorManager.h>
  33 #include "StyleEngine.h"
  34
  35 #include "BarGraph.h"
  36 #include "DancingBarsSettings.h"
  37
  38 #include "DancingBars.h"
  39
  40 DancingBars::DancingBars( QWidget *parent, const QString &title, SharedSettings *workSheetSettings)
  41   : KSGRD::SensorDisplay( parent, title, workSheetSettings)
  42 {
  43   mBars = 0;
  44   mFlags = QBitArray( 100 );
  45   mFlags.fill( false );
  46
  47   QLayout *layout = new QHBoxLayout(this);
  48   mPlotter = new BarGraph( this );
  49   layout->addWidget(mPlotter);
  50
  51   setMinimumSize( sizeHint() );
  52
  53   /* All RMB clicks to the mPlotter widget will be handled by
  54    * SensorDisplay::eventFilter. */
  55   mPlotter->installEventFilter( this );
  56
  57   setPlotterWidget( mPlotter );
  58
  59 }
  60
  61 DancingBars::~DancingBars()
  62 {
  63 }
  64
  65 void DancingBars::configureSettings()
  66 {
  67   DancingBarsSettings dlg( this );
  68
  69   dlg.setTitle( title() );
  70   dlg.setMinValue( mPlotter->getMin() );
  71   dlg.setMaxValue( mPlotter->getMax() );
  72
  73   double l, u;
  74   bool la, ua;
  75   mPlotter->getLimits( l, la, u, ua );
  76
  77   dlg.setUseUpperLimit( ua );
  78   dlg.setUpperLimit( u );
  79
  80   dlg.setUseLowerLimit( la );
  81   dlg.setLowerLimit( l );
  82
  83   dlg.setForegroundColor( mPlotter->normalColor );
  84   dlg.setAlarmColor( mPlotter->alarmColor );
  85   dlg.setBackgroundColor( mPlotter->mBackgroundColor );
  86   dlg.setFontSize( mPlotter->fontSize );
  87
  88   SensorModelEntry::List list;
  89   for ( uint i = mBars - 1; i < mBars; i-- ) {
  90     SensorModelEntry entry;
  91     entry.setId( i );
  92     entry.setHostName( sensors().at( i )->hostName() );
  93     entry.setSensorName( KSGRD::SensorMgr->translateSensor( sensors().at( i )->name() ) );
  94     entry.setLabel( mPlotter->footers[ i ] );
  95     entry.setUnit( KSGRD::SensorMgr->translateUnit( sensors().at( i )->unit() ) );
  96     entry.setStatus( sensors().at( i )->isOk() ? i18n( "OK" ) : i18n( "Error" ) );
  97
  98     list.append( entry );
  99   }
 100   dlg.setSensors( list );
 101
 102   if ( !dlg.exec() )
 103     return;
 104
 105   setTitle( dlg.title() );
 106   mPlotter->changeRange( dlg.minValue(), dlg.maxValue() );
 107   mPlotter->setLimits( dlg.useLowerLimit() ?
 108                        dlg.lowerLimit() : 0,
 109                        dlg.useLowerLimit(),
 110                        dlg.useUpperLimit() ?
 111                        dlg.upperLimit() : 0,
 112                        dlg.useUpperLimit() );
 113
 114   mPlotter->normalColor = dlg.foregroundColor();
 115   mPlotter->alarmColor = dlg.alarmColor();
 116   mPlotter->mBackgroundColor = dlg.backgroundColor();
 117   mPlotter->fontSize = dlg.fontSize();
 118
 119   uint delCount = 0;
 120
 121   list = dlg.sensors();
 122
 123   for ( int i = 0; i < sensors().count(); ++i ) {
 124     bool found = false;
 125     for ( int j = 0; j < list.count(); ++j ) {
 126       if ( list[ j ].id() == (int)( i + delCount ) ) {
 127         mPlotter->footers[ i ] = list[ j ].label();
 128         found = true;
 129         if ( delCount > 0 )
 130           list[ j ].setId( i );
 131
 132         continue;
 133       }
 134     }
 135
 136     if ( !found ) {
 137       if ( removeSensor(i) ) {
 138         i--;
 139         delCount++;
 140       }
 141     }
 142   }
 143
 144   repaint();
 145 }
 146
 147 void DancingBars::applyStyle()
 148 {
 149   mPlotter->normalColor = KSGRD::Style->firstForegroundColor();
 150   mPlotter->alarmColor = KSGRD::Style->alarmColor();
 151   mPlotter->mBackgroundColor = KSGRD::Style->backgroundColor();
 152   mPlotter->fontSize = KSGRD::Style->fontSize();
 153
 154   repaint();
 155 }
 156
 157 bool DancingBars::addSensor( const QString &hostName, const QString &name,
 158                              const QString &type, const QString &title )
 159 {
 160   if ( type != "integer" && type != "float" )
 161     return false;
 162
 163   if ( mBars >= 32 )
 164     return false;
 165
 166   if ( !mPlotter->addBar( title ) )
 167     return false;
 168
 169   registerSensor( new KSGRD::SensorProperties( hostName, name, type, title ) );
 170
 171   /* To differentiate between answers from value requests and info
 172    * requests we add 100 to the beam index for info requests. */
 173   sendRequest( hostName, name + '?', mBars + 100 );
 174   ++mBars;
 175   mSampleBuffer.resize( mBars );
 176
 177   QString tooltip;
 178   for ( uint i = 0; i < mBars; ++i ) {
 179     tooltip += QString( "%1%2:%3" ).arg( i != 0 ? "\n" : "" )
 180                                    .arg( sensors().at( i )->hostName() )
 181                                    .arg( sensors().at( i )->name() );
 182   }
 183   mPlotter->setToolTip( tooltip );
 184
 185   return true;
 186 }
 187
 188 bool DancingBars::removeSensor( uint pos )
 189 {
 190   if ( pos >= mBars ) {
 191     kDebug(1215) << "DancingBars::removeSensor: idx out of range ("
 192                   << pos << ")" << endl;
 193     return false;
 194   }
 195
 196   mPlotter->removeBar( pos );
 197   mBars--;
 198   KSGRD::SensorDisplay::removeSensor( pos );
 199
 200   QString tooltip;
 201   for ( uint i = 0; i < mBars; ++i ) {
 202     tooltip += QString( "%1%2:%3" ).arg( i != 0 ? "\n" : "" )
 203                                    .arg( sensors().at( i )->hostName() )
 204                                    .arg( sensors().at( i )->name() );
 205   }
 206   mPlotter->setToolTip( tooltip );
 207
 208   return true;
 209 }
 210
 211 void DancingBars::updateSamples( const QVector<double> &samples )
 212 {
 213   mPlotter->updateSamples( samples );
 214 }
 215
 216 void DancingBars::answerReceived( int id, const QList<QByteArray> &answerlist )
 217 {
 218   /* We received something, so the sensor is probably ok. */
 219   sensorError( id, false );
 220   QByteArray answer;
 221   if(!answerlist.isEmpty()) answer = answerlist[0];
 222   if ( id < 100 ) {
 223     if(id >= mSampleBuffer.count()) {
 224       kDebug(1215) << "ERROR: DancingBars received invalid data";
 225       sensorError(id, true);
 226       return;
 227     }
 228     mSampleBuffer[ id ] = answer.toDouble();
 229     if ( mFlags.testBit( id ) == true ) {
 230       kDebug(1215) << "ERROR: DancingBars lost sample (" << mFlags
 231                     << ", " << mBars << ")" << endl;
 232       sensorError( id, true );
 233       return;
 234     }
 235     mFlags.setBit( id, true );
 236
 237     bool allBitsAvailable = true;
 238     for ( uint i = 0; i < mBars; ++i )
 239       allBitsAvailable &= mFlags.testBit( i );
 240
 241     if ( allBitsAvailable ) {
 242       mPlotter->updateSamples( mSampleBuffer );
 243       mFlags.fill( false );
 244     }
 245   } else if ( id >= 100 ) {
 246     KSGRD::SensorIntegerInfo info( answer );
 247     if ( id == 100 )
 248       if ( mPlotter->getMin() == 0.0 && mPlotter->getMax() == 0.0 ) {
 249         /* We only use this information from the sensor when the
 250          * display is still using the default values. If the
 251          * sensor has been restored we don't touch the already set
 252          * values. */
 253         mPlotter->changeRange( info.min(), info.max() );
 254       }
 255
 256     sensors().at( id - 100 )->setUnit( info.unit() );
 257   }
 258 }
 259
 260 bool DancingBars::restoreSettings( QDomElement &element )
 261 {
 262   SensorDisplay::restoreSettings( element );
 263
 264   mPlotter->changeRange( element.attribute( "min", "0" ).toDouble(),
 265                          element.attribute( "max", "0" ).toDouble() );
 266
 267   mPlotter->setLimits( element.attribute( "lowlimit", "0" ).toDouble(),
 268                        element.attribute( "lowlimitactive", "0" ).toInt(),
 269                        element.attribute( "uplimit", "0" ).toDouble(),
 270                        element.attribute( "uplimitactive", "0" ).toInt() );
 271
 272   mPlotter->normalColor = restoreColor( element, "normalColor",
 273                                         KSGRD::Style->firstForegroundColor() );
 274   mPlotter->alarmColor = restoreColor( element, "alarmColor",
 275                                        KSGRD::Style->alarmColor() );
 276   mPlotter->mBackgroundColor = restoreColor( element, "backgroundColor",
 277                                             KSGRD::Style->backgroundColor() );
 278   mPlotter->fontSize = element.attribute( "fontSize", QString( "%1" ).arg(
 279                                           KSGRD::Style->fontSize() ) ).toInt();
 280
 281   QDomNodeList dnList = element.elementsByTagName( "beam" );
 282   for ( int i = 0; i < dnList.count(); ++i ) {
 283     QDomElement el = dnList.item( i ).toElement();
 284     addSensor( el.attribute( "hostName" ), el.attribute( "sensorName" ),
 285                ( el.attribute( "sensorType" ).isEmpty() ? "integer" :
 286                el.attribute( "sensorType" ) ), el.attribute( "sensorDescr" ) );
 287   }
 288
 289
 290   return true;
 291 }
 292
 293 bool DancingBars::saveSettings( QDomDocument &doc, QDomElement &element)
 294 {
 295   element.setAttribute( "min", mPlotter->getMin() );
 296   element.setAttribute( "max", mPlotter->getMax() );
 297   double l, u;
 298   bool la, ua;
 299   mPlotter->getLimits( l, la, u, ua );
 300   element.setAttribute( "lowlimit", l );
 301   element.setAttribute( "lowlimitactive", la );
 302   element.setAttribute( "uplimit", u );
 303   element.setAttribute( "uplimitactive", ua );
 304
 305   saveColor( element, "normalColor", mPlotter->normalColor );
 306   saveColor( element, "alarmColor", mPlotter->alarmColor );
 307         saveColor( element, "backgroundColor", mPlotter->mBackgroundColor );
 308   element.setAttribute( "fontSize", mPlotter->fontSize );
 309
 310   for ( uint i = 0; i < mBars; ++i ) {
 311     QDomElement beam = doc.createElement( "beam" );
 312     element.appendChild( beam );
 313     beam.setAttribute( "hostName", sensors().at( i )->hostName() );
 314     beam.setAttribute( "sensorName", sensors().at( i )->name() );
 315     beam.setAttribute( "sensorType", sensors().at( i )->type() );
 316     beam.setAttribute( "sensorDescr", mPlotter->footers[ i ] );
 317   }
 318
 319   SensorDisplay::saveSettings( doc, element );
 320
 321   return true;
 322 }
 323
 324 bool DancingBars::hasSettingsDialog() const
 325 {
 326   return true;
 327 }
 328
 329 #include "DancingBars.moc"