root/DRIM_GUI/lime-perf/trunk/src/libsrc/monitor_gui.cpp

/*
 * $Id: monitor_gui.cpp,v 2.2 2008/07/14 07:55:57 cvstaohe Exp $
 * 
 * lime monitor main GUI
 *
 * FIXME:
 *   o need more sensors, such as temperature, voltage, fan, network connection...
 *   o text mode display
 *   o .mon file parsing error handling
 */

#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/utsname.h>
#include "lime-perf.h"

#include <qapplication.h>
#include <qpainter.h>
#include <qframe.h>
#include <qregexp.h>
#include <qpopupmenu.h>
#include <qlistview.h>
#include <qlayout.h> 
#include <qlineedit.h>
#include <qvalidator.h> 
#include <qlabel.h>
#include <qlistbox.h>
#include <qpushbutton.h>
#include <qcolordialog.h>
#include <math.h>
#include <qslider.h>
#include <qgroupbox.h>
#include <qdatetime.h>
#include <qmessagebox.h>
#include <qtranslator.h>
#include <qtextcodec.h>
#include <qfiledialog.h>
#include <qkeysequence.h>
#include <qtabwidget.h>
#include <qmenubar.h>
#include <qtoolbar.h>
#include <qwindowsstyle.h>
#include <qcursor.h>
#include <qtextbrowser.h>
#include <qsplitter.h>

#include "icon/properties.xpm"
//#include "icon/fileopen.xpm"
//#include "icon/filesave.xpm"
#include "icon/add.xpm"
#include "icon/del.xpm"
#include "icon/pause.xpm"
#include "icon/reset.xpm"
#include "icon/curve.xpm"
#include "icon/bar.xpm"
#include "icon/clear.xpm"
#include "icon/step.xpm"

#include "monitor_gui.h"
#include "alarm_gui.h"
#include "addsensordlg.h"
#include "monprop_gui.h"
#include "corefile/SensorManager.h"
#include "activesensor.h"

#define WAIT_CURSOR()                   \
        QCursor old_c = cursor();       \
        QCursor wait_c(Qt::WaitCursor); \
        setCursor(wait_c); 

#define NORM_CURSOR() setCursor(old_c); 


Canvas::Canvas(QWidget* parent, const char *name, MonitorGUI *m)
        : QFrame(parent, name), monitor(m)
{
//      setPaletteBackgroundColor(Qt::black);
        setFrameShape( QFrame::StyledPanel );
        setFrameShadow( QFrame::Sunken );
}

void
Canvas::paintEvent( QPaintEvent *e )
{
        monitor->paintEvent(e);
}

void
Canvas::resizeEvent( QResizeEvent * )
{
        monitor->paintEvent(NULL);
}

void 
Canvas::mouseMoveEvent ( QMouseEvent * e )
{
        qDebug("(%d,%d)", e->x(), e->y());
}

Marker::Marker( MonitorGUI *m, const char *name )
        : QWidget( m->fra, name, WStaticContents ), monitor(m)
{}

void
Marker::paintEvent( QPaintEvent * )
{
        draw_marker();
}

void
Marker::resizeEvent( QResizeEvent * )
{
        draw_marker();
        update();
}

static int
grid_number(int h)
{
        int min_grid_h = 30;
        int n;
        int grid_h;

        /* compute marker number */
        if ((grid_h = h/10) > min_grid_h)
                n = 10;
        else if ((grid_h = h/5) > min_grid_h)
                n = 5;
        else
        {
                grid_h = h/2;
                n = 2;
        }
        return n;
}

void
Marker::draw_marker()
{
        int h = monitor->canvas->height();
        int n = grid_number(h);;

        QPainter p(this); 
        p.fillRect(0, 0, width(), height(),
                   QBrush(backgroundColor()));
        p.setPen( Qt::black );
        for (int i = 0; i <= n; i++)
        {
                int y = (i*h)/n;
                QString s = QString::number(i*100/n);
                p.drawText(0, h-y+20, s.rightJustify(3, ' '));
        }       
}

MonitorGUI::MonitorGUI( SensorManager * sm,HostItem *hostItem, QWidget* parent, const char* name)
        : MonitorBase(parent, name),
          sensor_dlg(0), prop_dlg(0)
{
        /* init sensor manager */
        SetInit(sm,hostItem);
        active_sensors.setAutoDelete(TRUE);
        
        /* set init sample rate: 1 sec */
        sample_rate = 1;
        startTimer(sample_rate*1000);
        showmode = 0; /* curve mode */
        
        /* init sensor listview */
        /* FIXME: need to spread the listview column nicely */

        /* init frame */
        step = 5; /* pixels */
        cur_x = -step;

        /* init splitter size */
        {
                QValueList<int> vl;
                vl.append(400); /* init size of view window */
                splitter->setSizes(vl);
        }
        
        /* init canvas */
        QFrame* canvas_main_frame = new QFrame(fra);
        canvas_main_frame->setFrameShape( QFrame::NoFrame );
        QFrame* canvas_frame = new QFrame(canvas_main_frame);
        canvas_frame->setFrameShape( QFrame::StyledPanel );
        canvas_frame->setFrameShadow( QFrame::Sunken );
        canvas = new Canvas( canvas_frame, "", this );
        QVBoxLayout* canvas_layout = new QVBoxLayout(canvas_frame, 1, 0, "CanvasLayout");
        canvas_layout->addWidget( canvas );
        QVBoxLayout* canvas_main_layout = new QVBoxLayout(canvas_main_frame, 10, 0, "CanvasMainLayout");
        canvas_main_layout->addWidget( canvas_frame );

        /* init marker */
        marker = new Marker( this );
        marker->setMaximumSize( QSize( 25, 32767 ) );

        /* glue canvas and marker together */
        QHBoxLayout* layout = new QHBoxLayout(fra, 0, 0, "MarkerAndCanvasLayout");
        layout->addWidget( marker );    
        layout->addWidget( canvas_main_frame );
        
        /* init last, avg, max, min labels */
        last_lbl->setMinimumSize( QSize( 20, 0 ) );
        avg_lbl->setMinimumSize( QSize( 20, 0 ) );
        min_lbl->setMinimumSize( QSize( 20, 0 ) );
        max_lbl->setMinimumSize( QSize( 20, 0 ) );

        sensors_lv->setSorting(2); /* sort by sensor name */
        sensors_lv->setShowSortIndicator(TRUE);

        /* init connections */ 
        connect( sensors_lv, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ), this, 
                 SLOT( do_active_sensors_mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ) );

        connect( ratio_sld, SIGNAL( valueChanged(int) ), 
                 this, SLOT( do_ratio_changed(int) ) );
        connect( color_btn, SIGNAL( clicked() ), 
                 this, SLOT( do_color() ) );
        connect( sensors_lv, SIGNAL( selectionChanged(QListViewItem*) ), 
                 this, SLOT( do_active_sensors_select(QListViewItem*) ) );
        
        /* init actions and menu items */

        /* init sensor popup menu */
//      sensor_popup = new QPopupMenu(this);
//      addAction->addTo( sensor_popup );
//      delAction->addTo( sensor_popup );
//      sensor_popup->insertSeparator();
//      propertiesAction->addTo( sensor_popup );

       layout11 = new QHBoxLayout( 0, 0, 6, "layout11");
       layout22 = new QHBoxLayout( 0, 0, 6, "layout22");
       layout44 = new QVBoxLayout( 0, 11, 6, "layout44");
        /* init sensors */
        show_active_sensors();

}


void MonitorGUI::SetInit(SensorManager * sm,HostItem * hostItem)
{
        //init_actions();
        this->sm=sm;
        this->hostItem=hostItem;
        do_reset();
}

void
MonitorGUI::do_color()
{
        ActiveSensor* as = get_current_as();
        if (!as)
                return;
        QColor c = QColorDialog::getColor(as->color);
        if (c.isValid())
                as->color = c;
        show_active_sensors(true);
}

int
MonitorGUI::init_actions()
{
        return 0;
}


void
MonitorGUI::do_properties()
{
        if (!prop_dlg)
                prop_dlg = new MonPropGUI(this, this, "", TRUE);
        prop_dlg->do_show();
}


int MonitorGUI::get_sample_rate()
{
        return sample_rate;
}

int 
MonitorGUI::set_sample_rate(int sr)
{
        sample_rate = sr;
        if (pause) {
                killTimers();
                if (sr > 0)
                        startTimer(sample_rate*1000);
        }
        return 0;
}

void
MonitorGUI::do_add_sensor()
{
        if (sensor_dlg)
                delete sensor_dlg;
        sensor_dlg = new AddSensorDlg(this, sm, this);
        sensor_dlg->exec();
}

void
MonitorGUI::do_del_sensor()
{
        delete_current_sensor();
}

void
MonitorGUI::do_reset()
{
        active_sensors.clear();
        for(map<int,LastSensorPair*>::iterator it=last_sensors.begin();it!=last_sensors.end();it++)
        {
                if((*it).second) delete (*it).second;
        }
        last_sensors.clear();
        sensors_lv->clear();
        cur_x = -step;
        show_active_sensors(true); /* refresh the sensor list */
}

void MonitorGUI::refresh()
{
        active_sensors.clear();
        sensors_lv->clear();
        if(ng) 
        {
                if(ng->currentHostItem)
                {
                        //ng->currentHostItem->connectHost();
                        ng->client=ng->currentHostItem->client;
                        if(ng->sm) ng->sm->SetHostItem(ng->currentHostItem);
                        else ng->sm= new SensorManager(ng->currentHostItem);
                        int ret=0;
                        try{
                                ng->sm->GetAllInstance();
                        }CATCH_EXCEPTION(NULL,_("Initialize Failure"),_("Fetch the statisics Instances Failure!\n"),ret)
                        while(ret==2)
                        {
                                ret=0;
                                if(! ng->getConsole()->getHostListBar()->sltEditHost())
                                {
                                        ng->alarm->SetInit(sm,NULL);
                                        break;
                                }
                                ng->currentHostItem=ng->getConsole()->getHostListBar()->currentHostItem();
                                ng->client=ng->currentHostItem->client;
                                ng->sm->SetHostItem(ng->currentHostItem);
                                try{
                                        ng->sm->GetAllInstance();
                                }CATCH_EXCEPTION(this,_("Initialize Failure"),_("Fetch the statisics Instances Failure!\n"),ret)
                        }
                        hostItem=ng->currentHostItem;
                        ng->alarm->SetInit(ng->sm,ng->currentHostItem);

                }
        }
        cur_x = -step;
        //add sensors
        for(map<int,LastSensorPair*>::iterator it=last_sensors.begin();it!=last_sensors.end();it++)
        {
                if((*it).second)
                {
                        add_sensor((*it).second->instance,(*it).second->property);
                }
        }
}


void
MonitorGUI::do_step()
{
        timerEvent(NULL);
}

void
MonitorGUI::do_clear()
{
        cur_x = -step;
        for (ActiveSensor* as = active_sensors.first(); as; as = active_sensors.next() ) 
                as->clear_value();
//      sm->ClearSensorList();
        update();
}

void MonitorGUI::do_pause(bool pause)
{       
        this->pause=pause;
        if (pause)
        {
                /*
                qDebug("pause");
                stepAction->setEnabled(TRUE);
                pauseAction->setText( _( "Continue" ) );
                pauseAction->setMenuText( _( "&Continue" ) );
                pauseAction->setToolTip( _( "Continue" ) );
                pauseAction->setStatusTip( _( "Continue display" ) );
//              pauseAction->setAccel(QKeySequence(_("Ctrl+C")));
*/
                killTimers();
        }
        else 
        {
/*
                qDebug("continue");
                stepAction->setEnabled(FALSE);
                pauseAction->setText( _( "Pause" ) );
                pauseAction->setMenuText( _( "&Pause" ) );
                pauseAction->setToolTip( _( "Pause" ) );
                pauseAction->setStatusTip( _( "Pause display" ) );
//              pauseAction->setAccel(QKeySequence(_("Ctrl+P")));
*/
                if (sample_rate > 0)
                        startTimer(sample_rate*1000);
                else
                        killTimers();
        }
}

void 
MonitorGUI::do_ratio_changed(int n)
{
        ActiveSensorItem* item;
        item = (ActiveSensorItem*)sensors_lv->currentItem();
        if (!item)
                return;
        ActiveSensor* as = item->as;
        if (!as)
                return;
        double ratio = pow(10.0, (double)n);
        as->ratio = ratio;
        QString ratio_str = QString::number(as->ratio, 'f', 10);
        ratio_str = ratio_str.replace( QRegExp("0+$"), "" ); 
        ratio_str = ratio_str.replace( QRegExp("\\.$"), ".0" ); 
        ratio_lbl->setText(ratio_str);
        show_active_sensors(true);
        update();
}

void 
MonitorGUI::do_active_sensors_select(QListViewItem* item) 
{
        if (!item)
                return;
        show_active_sensors(true);
}

void 
MonitorGUI::do_active_sensors_mouseButtonPressed (int button, QListViewItem*,const QPoint & pos, int)
{
        switch (button)
        {
        case 1: /* left button */
                show_current_sensor_value();
                update();
                break;
        case 2: /* right button */
//              sensor_popup->popup(pos);
                update();
                break;
        default:
                break;
        }
}

void
MonitorGUI::sample(ActiveSensor* as, bool do_real_sample)
{               
        int w = canvas->width();
        unsigned int max_length = w/step + 2;

        /* sample it */
        as->sample(do_real_sample);

        unsigned int size = as->samples.size();
        if (size > max_length)
                for (unsigned int i = max_length; i < size; i++)
                {
                        QValueList<double>::iterator it = as->samples.end();
                        it--;
                        as->samples.remove(it); /* remove the last one */
                }

#if 0
        QValueList<int>::iterator it;   
        for ( it = samples.begin(); it != samples.end(); ++it )
                cout << (*it) << ", ";
        cout << endl;
#endif
}

void 
MonitorGUI::timerEvent( QTimerEvent*)
{
        // qDebug("TimerEvent"); 
        int w = canvas->width();

        if (active_sensors.count() == 0) /* no sensor */
                return;
///////////////////////////////////////////
//      refresh the sensor instance
        
        sm->Sample();
//then refresh the sensor property
        
        QDict<bool> class_sampled;
        class_sampled.setAutoDelete(TRUE);
        for (ActiveSensor* as = active_sensors.first(); as; as = active_sensors.next() )
        {
                bool* b = new bool;
                *b = false;
                class_sampled.insert(as->instance, b);
        }
        for (ActiveSensor* as = active_sensors.first(); as; as = active_sensors.next() )
        {
                sample(as, !(*class_sampled[as->instance]));
                *class_sampled[as->instance] = true;
        }

        cur_x += step;
        if (cur_x > w)
                cur_x = 0;
        paintEvent(NULL);
}

void
MonitorGUI::draw_curve(ActiveSensor* as, QPainter& p)
{       
        int x;  
        int w = canvas->width();
        int h = canvas->height();
        double ratio = h/100.0*as->ratio;

        /* sanity check */
        if (!as)
                return; 

        QValueList<double>::iterator it = as->samples.begin();
        QPen pen(as->color);
        if (as->highlight)
                pen.setWidth(2);
        p.setPen(pen);    

        /* for the sample point, nothing needs to be done */
        if (cur_x == 0 && as->samples.count() == 1) 
                return;

        /* left part */
        for (x = cur_x; x > 0; x-=step)
        {
                double y1 = *it;
                it++;
                if (it == as->samples.end())
                        return;
                double y2 = *it;
                p.drawLine(x, (int)(y1*ratio), x-step, (int)(y2*ratio));
        }

        /* right part */
        it++;
        x = w - (w%step);
        while(it != as->samples.end())
        {
                double y1 = *it;
                it++;
                if (it == as->samples.end())
                        return;
                double y2 = *it;
                p.drawLine(x, (int)(y1*ratio), x-step, (int)(y2*ratio));
                x-=step;
        }
}

void MonitorGUI::set_viewport(QPainter& p)
{
        int h = canvas->height();
        p.translate(0, h);
        p.scale(1.0, -1.0);
}

void MonitorGUI::draw_grid(QPainter& p)
{
        int h = canvas->height();
        int w = canvas->width();
        int i;  
        int n = grid_number(h);

        p.fillRect(0, 0, w, h, QBrush(canvas->backgroundColor()));

        /* horizontal grid */
        p.setPen( Qt::black );
        for (i = 0; i < n; i++) {
                int y = (i*h)/n;
                p.drawLine(0, y, w, y);
        }
        p.drawLine(0, 1, w, 1);
        p.drawLine(0, h, w, h);


#if 0
        /* vertical grid */
        int s = (int)(10.0/(sample_rate/1.0)*step); /* 10 sec per mark */
        for (i = s; i < w; i += s)
                p.drawLine(i, 0, i, h);
#endif
}


int
MonitorGUI::delete_current_sensor()
{
        for(ActiveSensorItem* item=(ActiveSensorItem*)sensors_lv->firstChild(); item != NULL; )
        {
                if(!item->isSelected()) 
                {
                        item=(ActiveSensorItem*)item->itemBelow();
                        continue;
                }
                ActiveSensor* as = item->as;
                for(map<int,LastSensorPair*>::iterator it=last_sensors.begin();it!=last_sensors.end();it++)
                {
                        if((*it).second && (*it).second->instance==as->instance && (*it).second->property==as->property)  
                        {
                                delete (*it).second;
                                last_sensors.erase(it);
                        }
                }
                active_sensors.remove(as);
                if (active_sensors.count() == 0)
                        cur_x = -step;
                ActiveSensorItem* tmp=item;
                item=(ActiveSensorItem*)item->itemBelow();
                sensors_lv->takeItem(tmp);
        }
        
        sm->ClearSensorList();
        for(ActiveSensor* as = active_sensors.first(); as; as = active_sensors.next())
        {
                sm->AddSensorInstance(as->instance.latin1());
        }
        
        show_active_sensors(true); /* refresh the sensor list */
        return 0;
}

/*
 * show last, agv, max, min of the selected sensor 
 */
void
MonitorGUI::show_current_sensor_value()
{
        ActiveSensor* as;
        for ( as = active_sensors.first(); as; as = active_sensors.next() )
                as->highlight = false;
        ActiveSensorItem* item;
        
        item = (ActiveSensorItem*)sensors_lv->currentItem();
        if (!item)
        {
                last_lbl->setText("");
                avg_lbl->setText("");
                max_lbl->setText("");
                min_lbl->setText("");
        }
        else
        {
                sensors_lv->setSelected(item, TRUE);
                as = item->as;
                as->highlight = true;
                last_lbl->setText(QString::number(as->last));
                avg_lbl->setText(QString::number(as->avg));
                if (as->max == INT_MIN)
                        max_lbl->setText("-");
                else
                        max_lbl->setText(QString::number(as->max));
                if (as->min == INT_MAX)
                        min_lbl->setText("-");
                else
                        min_lbl->setText(QString::number(as->min));

                //reset the posistion of components
                static int flag=-1;
                if(flag==-1)
                {

                }
                if(width()<500&&flag!=0)
                {
                        Layout14->removeItem(Layout7_2);
                        Layout14->removeItem(Layout13_2);
                        Layout14->removeItem(Layout7_3_2);
                        Layout14->removeItem(Layout7_4_2);

                        Layout7_2->remove(TextLabel1_5);
                        Layout7_2->remove(last_lbl);
                        Layout7_2= new QHBoxLayout( 0, 0, 6, "layout7_2");
                        Layout7_2->addWidget(TextLabel1_5);
                        Layout7_2->addWidget(last_lbl);
                        layout11->addLayout(Layout7_2);

                        Layout13_2->remove(TextLabel1_2_2);
                        Layout13_2->remove(avg_lbl);
                        Layout13_2= new QHBoxLayout( 0, 0, 6, "layout13_2");
                        Layout13_2->addWidget(TextLabel1_2_2);
                        Layout13_2->addWidget(avg_lbl);
                        layout11->addLayout(Layout13_2);

                        Layout7_3_2->remove(TextLabel1_3_2);
                        Layout7_3_2->remove(min_lbl);
                        Layout7_3_2= new QHBoxLayout( 0, 0, 6, "layout7_3_2");
                        Layout7_3_2->addWidget(TextLabel1_3_2);
                        Layout7_3_2->addWidget(min_lbl);
                        layout22->addLayout(Layout7_3_2);

                        Layout7_4_2->remove(TextLabel1_4_2);
                        Layout7_4_2->remove(max_lbl);
                        Layout7_4_2= new QHBoxLayout( 0, 0, 6, "layout7_4_2");
                        Layout7_4_2->addWidget(TextLabel1_4_2);
                        Layout7_4_2->addWidget(max_lbl);
                        layout22->addLayout(Layout7_4_2);

                        layout44->addLayout(layout11);
                        layout44->addLayout(layout22);
                        Layout14->addLayout(layout44);
                        flag=0;
                }
                else if(width()>=500&& flag==0)
                {
                        layout11->removeItem(Layout7_2);
                        layout11->removeItem(Layout13_2);
                        layout44->removeItem(layout11);
                        layout11= new QHBoxLayout(0, 0, 6, "layout11");
                        layout22->removeItem(Layout7_3_2);
                        layout22->removeItem(Layout7_4_2);
                        layout44->removeItem(layout22);
                        layout22= new QHBoxLayout(0, 0, 6, "layout22");

                        Layout14->removeItem(layout44);
                        layout44= new QVBoxLayout(0, 0, 6, "layout44");

                        Layout7_2->remove(TextLabel1_5);
                        Layout7_2->remove(last_lbl);
                        Layout7_2= new QHBoxLayout( 0, 0, 6, "layout7_2");
                        Layout7_2->addWidget(TextLabel1_5);
                        Layout7_2->addWidget(last_lbl);
                        Layout14->addLayout(Layout7_2);

                        Layout13_2->remove(TextLabel1_2_2);
                        Layout13_2->remove(avg_lbl);
                        Layout13_2= new QHBoxLayout( 0, 0, 6, "layout13_2");
                        Layout13_2->addWidget(TextLabel1_2_2);
                        Layout13_2->addWidget(avg_lbl);
                        Layout14->addLayout(Layout13_2);

                        Layout7_3_2->remove(TextLabel1_3_2);
                        Layout7_3_2->remove(min_lbl);
                        Layout7_3_2= new QHBoxLayout( 0, 0, 6, "layout7_3_2");
                        Layout7_3_2->addWidget(TextLabel1_3_2);
                        Layout7_3_2->addWidget(min_lbl);
                        Layout14->addLayout(Layout7_3_2);

                        Layout7_4_2->remove(TextLabel1_4_2);
                        Layout7_4_2->remove(max_lbl);
                        Layout7_4_2= new QHBoxLayout( 0, 0, 6, "layout7_4_2");
                        Layout7_4_2->addWidget(TextLabel1_4_2);
                        Layout7_4_2->addWidget(max_lbl);
                        Layout14->addLayout(Layout7_4_2);
                        flag=1;
                }               

        }       
        update_display_prop(as);
}

void 
MonitorGUI::do_showmode(bool showflag)
{
        if(showflag) showmode = 0;
        else  showmode = 1;
        paintEvent(NULL);
}

void
MonitorGUI::draw_curve()
{       
        int w = canvas->width();
        int h = canvas->height();
        
        QPixmap pm( w, h );
        QPainter p(&pm);
        set_viewport(p);
        draw_grid(p);
        ActiveSensor* as;
        ActiveSensor* highlighted_as = NULL;
        for ( as = active_sensors.first(); as; as = active_sensors.next() )
        {
                if (!as->highlight)
                        draw_curve(as, p);
                else
                        highlighted_as = as;    
        }
        /* draw the highlighted curve in the end */
        if (highlighted_as)
                draw_curve(highlighted_as, p);

        /* draw vertical mark */
        p.setPen(QPen(Qt::red, 2));
        p.drawLine(cur_x, 0, cur_x, h);

        /* ok now show pixmap back */
        bitBlt(canvas, 0, 0, &pm);
}

void
MonitorGUI::draw_bar()
{
        int h = canvas->height();
        int w = canvas->width();
        int i;
        int ww;
        QPixmap pm( w, h );
        QPainter p(&pm);
        set_viewport(p);
        
        draw_grid(p);
        if (active_sensors.count() == 0)
                goto End;
        ww = w/active_sensors.count();
        ActiveSensor* as;
        for ( i = 0, as = active_sensors.first(); 
              as; as = active_sensors.next(),i+=ww )
        {
                double ratio = h/100.0*as->ratio;
                /* FIXME: samples may not have value yet */
                QValueList<double>::iterator it = as->samples.begin();
                int y = (int)*it;
                p.fillRect(i, 0, ww, (int)(y*ratio),
                           QBrush(as->color));
        }

 End:
        /* ok now show pixmap back */
        bitBlt(canvas, 0, 0, &pm);
}

void MonitorGUI::paintEvent (QPaintEvent*)
{
        switch (showmode) 
        {
        case 0: /* curve */
                draw_curve();
                break;
        case 1: /* bar mode */
                draw_bar();
                break;
        default:
                qWarning("unknown show mode: %d\n", showmode);
        }
        /* show value */
        show_current_sensor_value();
}

MonitorGUI::~MonitorGUI()
{
        /* FIXME: need delete something here, right? */
}

void
MonitorGUI::show_active_sensors(bool update_only)
{
        if (!update_only)
        {
                sensors_lv->clear(); 
                
                ActiveSensor* as;
                for ( as = active_sensors.first(); as; as = active_sensors.next() )
                {
                        ActiveSensorItem *item;
                        QString ratio_str = QString::number(as->ratio, 'f', 10);
                        ratio_str = ratio_str.replace( QRegExp("0+$"), "" ); 
                        ratio_str = ratio_str.replace( QRegExp("\\.$"), ".0" );
                //      QString pin_str = as->pin;
                //      pin_str.replace(QRegExp("%%"), "%");
                        item = new ActiveSensorItem(
                                sensors_lv,
                                as,
                                "",                /* color */
                                ratio_str+"  ",    /* ratio */
                        //      pin_str+"  ",      /* counter */
                                as->property+"  ", /* property */
                                as->instance+"  " /* sensor Object */
                                );         /* host */
                        QPixmap pm(16,16);
                        pm.fill(as->color);
                        item->setPixmap(0, pm);
                        sensors_lv->insertItem(item);
                        if (as->highlight)
                                sensors_lv->setSelected(item, TRUE);
                }
        }
        else /* update only */
        {
                QListViewItem* i;
                for (i = sensors_lv->firstChild();i;i=i->nextSibling())
                {
                        ActiveSensorItem *item = (ActiveSensorItem *)i;
                        ActiveSensor* as = item->as;
                        QPixmap pm(16,16);
                        pm.fill(as->color);
                        item->setPixmap(0, pm);
                        QString ratio_str = QString::number(as->ratio, 'f', 10);
                        ratio_str = ratio_str.replace( QRegExp("0+$"), "" ); 
                        ratio_str = ratio_str.replace( QRegExp("\\.$"), ".0" ); 
                        item->setText(1, ratio_str);
                }
        }
        /* update display property group box */
        update_display_prop(get_current_as());
        update(); /* redraw */
}

/*
 * for the purpose of sorting color, color is sorted by its name (#RRGGBB).
 */


ActiveSensor*
MonitorGUI::get_current_as()
{
        ActiveSensor* as = NULL;
        ActiveSensorItem* item;
        item = (ActiveSensorItem*)sensors_lv->currentItem();
        if (item)
                as = item->as;  
        return as;
}

int
MonitorGUI::update_display_prop(ActiveSensor* as)
{
        if(!as)
        {
                color_btn->setEnabled(FALSE);
                color_btn->setPaletteBackgroundColor(QColor("white"));
                display_prop_gb->setEnabled(FALSE);
        //      delAction->setEnabled(FALSE);
                return 0;
        }
        display_prop_gb->setEnabled(TRUE);
//      delAction->setEnabled(TRUE);
        QString ratio_str = QString::number(as->ratio, 'f', 10);
        ratio_str = ratio_str.replace( QRegExp("0+$"), "" ); 
        ratio_str = ratio_str.replace( QRegExp("\\.$"), ".0" ); 
        ratio_lbl->setText(ratio_str);
        ratio_sld->setValue((int)log10(as->ratio));
        color_btn->setEnabled(TRUE);
        color_btn->setPaletteBackgroundColor(as->color);
        color_btn->setPaletteForegroundColor(QColor(255 - as->color.red(),
                                                    255 - as->color.green(),
                                                    255 - as->color.blue()));
        
        return 0;
}


ActiveSensor* MonitorGUI::add_sensor(const QString& instance,const QString& property)
{
        ActiveSensor* as;
        
        /* check if the pin is already active */        
        for ( as = active_sensors.first(); as; as = active_sensors.next() ) {
                if (as->property == property && as->instance == instance)
                        return 0;
        }
        
        sm->AddSensorInstance(instance.latin1());
        /* make new active sensor object */
        as = new ActiveSensor(sm, instance, property, alloc_color());
        active_sensors.append(as);
        /* refresh active sensor list */
        show_active_sensors();
        return as;
}

/* FIXME: DEFAULT_COLOR_NUM is not necessary */
QColor MonitorGUI::alloc_color()
{
        static const int DEFAULT_COLOR_NUM = 8;
        static QColor default_colors[] = {"red", "purple", "blue", "magenta",
                                          "green", "brown", "pink", "orange"};  
        int hit[DEFAULT_COLOR_NUM];
        int i;

        /* usage counting */
        for (i = 0; i < DEFAULT_COLOR_NUM; i++)
                hit[i] = 0;
        ActiveSensor* as;
        for (i = 0; i < DEFAULT_COLOR_NUM; i++)
                for ( as = active_sensors.first(); as; as = active_sensors.next() )
                        if (default_colors[i] == as->color)
                                hit[i]++;
        
        /* if find one unused color, use it */
        for (i = 0; i < DEFAULT_COLOR_NUM; i++)
                if (!hit[i])
                        return default_colors[i];
        
        /* if all colors are used, choose the less frequently used one */
        int minhit = hit[0];
        int chosen = 0;
        for (i = 1; i < DEFAULT_COLOR_NUM; i++)
                if (minhit > hit[i])
                {
                        minhit = hit[i];
                        chosen = i;
                }
        return default_colors[chosen];
        // return default_colors[(int)(DEFAULT_COLOR_NUM*1.0*rand()/(RAND_MAX+1.0))];
}