MonitorWindow Class Reference

#include <MonitorWindow.h>

Inherits RioExplorer.

Public Slots

void setUpdateInterval (int)

Signals

void showQueue ()
void hideQueue ()

Public Member Functions

 MonitorWindow (QWidget *, RioQt *, int)
ClientTable * getClientTable ()
StorageTable * getStorageTable ()
bool connectRioServer (char *, char *, char *)
void processSearchLogsEvent (SearchLogsEvent *event)
 Funcao para processar o evento enviado pela callback.

Private Slots

bool refresh ()
void buttonSelected (int id)
void generateStats ()
void saveGraph ()

Private Member Functions

bool showMessage (int, string, string="")
void updateCopyProgress (void)
void setMD5Calculation (char *, bool)
void setSyncCheck (char *, bool)
void closeEvent (QCloseEvent *closeEvent)
bool ExecuteSearch (unsigned int SearchType, time_t StartTime, time_t EndTime)
 Funcao para executar uma busca nos logs dos servidores.

Static Private Member Functions

static void ExecuteSearchCallback (void *callbackparm, int result)
 Funcao de callback chamada quando a busca terminar (com ou sem sucesso tanto para o pedido de busca, como para a propria busca a ser executada).

Private Attributes

RioQt * rioQt
ClientTable * client_table
StorageTable * storage_table
LogPlot * data_plot
QTimer * timer
QString userName
QButtonGroup * data_bg
QButtonGroup * options_bg
QDateTimeEdit * history_start_date_time
QDateTimeEdit * history_end_date_time
QSpinBox * refresh_period_sb
QLabel * generate_msg
QString data_file
QPushButton * save_button
QPushButton * gen_button
QComboBox * storages_address
QWidgetStack * results_widgets
struct sockaddr_in * m_ServerAddress
unsigned int m_ServerAddressSize
bool m_UsedHistoricData
int m_LastSearchType
unsigned int blockSize
char home [MAXLEN_FILE+1]
char * host

Static Private Attributes

static const int MAXLEN_FILE = 1024
static const int MAXLEN_MESSAGE = 1024*5

Detailed Description

Definition at line 281 of file MonitorWindow.h.

Constructor & Destructor Documentation

MonitorWindow::MonitorWindow ( QWidget *  parent,
RioQt *  rioQt,
int  UpdateInterval 
)

Definition at line 746 of file MonitorWindow.cpp.

00748               : QMainWindow( parent, "MonitorWindow", 0 )
00749 {
00750 /* PREPARAR WIDGET PARA EXIBIR DIFERENTES TIPOS DE INFORMAÇÃO:
00751    - Estado atual
00752      - Filas nos servidores / storages
00753      - Clientes conectados
00754    - Histórico
00755      - Taxa de envio nos storages
00756      - Quantidade de clientes conectados */
00757 
00758     this->rioQt = rioQt;
00759     timer = new QTimer( this );
00760 
00761     QSplitter *splitter = new QSplitter( Qt::Horizontal, this );
00762     splitter->setChildrenCollapsible( false );
00763     setCentralWidget( splitter );
00764     
00765     QScrollView *scroll = new QScrollView( splitter );
00766     scroll->setResizePolicy( QScrollView::AutoOneFit );
00767 
00768     splitter->setResizeMode( scroll, QSplitter::KeepSize );
00769     splitter->setMargin( 0 );
00770 
00771 
00772     data_bg = new QButtonGroup( 12, Qt::Vertical, "Data", scroll->viewport() );
00773     scroll->addChild( data_bg );
00774 
00775     QGroupBox *rt_box = new QGroupBox( 0, Qt::Vertical,
00776                                        "Real time data", data_bg );
00777     rt_box->setFlat( true );
00778     rt_box->setInsideMargin(0);
00779     rt_box->setAlignment( Qt::AlignHCenter );
00780 
00781     new QRadioButton( "Client List", data_bg );
00782     new QRadioButton( "Storage Queues", data_bg );
00783 
00784     QHBox *update_box = new QHBox( data_bg );
00785     new QLabel( "Refresh period (ms): ", update_box );
00786     refresh_period_sb = new QSpinBox( 500, 60000, 1, update_box );
00787     refresh_period_sb->setValue( UpdateInterval );
00788     refresh_period_sb->setEnabled( false );
00789     
00790     connect( refresh_period_sb, SIGNAL(valueChanged(int)),
00791          this, SLOT(setUpdateInterval(int)));
00792 
00793     new QLabel( "", data_bg );
00794     
00795     QGroupBox *hst_box = new QGroupBox( 0, Qt::Vertical,
00796                                        "Historical data", data_bg );
00797     hst_box->setFlat( true );
00798     hst_box->setInsideMargin(0);
00799     hst_box->setAlignment( Qt::AlignHCenter );
00800     new QRadioButton( "Connected Clients", data_bg );
00801     new QRadioButton( "Storage Send Rate", data_bg );
00802 
00803     // Nova combobox para armazenar os IPs dos servidores de armazenamento.
00804     storages_address = new QComboBox( data_bg );
00805     storages_address->setEnabled( false );
00806 
00807     QHBox *start_box = new QHBox( data_bg );
00808     new QLabel( "Start time: ", start_box );
00809     history_start_date_time = new QDateTimeEdit( QDateTime::currentDateTime(),
00810                                                  start_box );
00811     history_start_date_time->setEnabled( false );
00812 
00813     QHBox *end_box = new QHBox( data_bg );
00814     new QLabel( "End time: ", end_box );
00815     history_end_date_time = new QDateTimeEdit( QDateTime::currentDateTime(),
00816                                                end_box );
00817     history_end_date_time->setEnabled( false );
00818 
00819     QHBox *gen_box = new QHBox( data_bg );
00820     gen_box->layout()->addItem( new QSpacerItem( 0, 0, QSizePolicy::Maximum, 
00821                                                  QSizePolicy::Maximum ) );
00822     gen_button = new QPushButton( "Generate", gen_box );
00823     gen_button->setFixedSize( gen_button->sizeHint() );
00824     gen_button->setEnabled( false );
00825     
00826     save_button = new QPushButton( "Save", gen_box );
00827     save_button->setFixedSize( save_button->sizeHint() );
00828     gen_box->layout()->addItem( new QSpacerItem( 0, 0, QSizePolicy::Maximum, 
00829                                                  QSizePolicy::Maximum ) );
00830     save_button->setEnabled( false );      
00831     
00832     connect( gen_button, SIGNAL(clicked()), this, SLOT(generateStats()));
00833     connect( save_button, SIGNAL(clicked()), this, SLOT(saveGraph()));
00834     
00835     connect( data_bg, SIGNAL(clicked(int)),
00836              this, SLOT(buttonSelected(int)));
00837              
00838     // Cria uma pilha para colocar os widgets dos graficos e o do rotulo.
00839     results_widgets = new QWidgetStack( splitter );  
00840     splitter->setResizeMode( results_widgets, QSplitter::FollowSizeHint );
00841 
00842     generate_msg = new QLabel(
00843         "For real time data, choose your option.\n\
00844 For historical data, choose your option and a date range and click\
00845  \"Generate\".",
00846          results_widgets );
00847     generate_msg->setAlignment( Qt::AlignCenter );
00848     results_widgets->addWidget( generate_msg );
00849     
00850     client_table = new ClientTable( results_widgets );
00851     results_widgets->addWidget( client_table );
00852     storage_table = new StorageTable( results_widgets );
00853     results_widgets->addWidget( storage_table );
00854     data_plot = new LogPlot( results_widgets );
00855     results_widgets->addWidget( data_plot );
00856      
00857     results_widgets->raiseWidget( generate_msg ); 
00858 
00859     // Inicialmente, ainda nao geramos graficos com um historico.
00860     m_UsedHistoricData = false;
00861 }

Member Function Documentation

void MonitorWindow::buttonSelected ( int  id  )  [private, slot]

Definition at line 863 of file MonitorWindow.cpp.

00864 {
00865     if( data_bg->selectedId() < 2 ) // real time data
00866     {
00867         refresh_period_sb->setEnabled( true );
00868         history_start_date_time->setEnabled( false );
00869         history_end_date_time->setEnabled( false );
00870         storages_address->setEnabled( false );
00871         save_button->setEnabled( false );
00872         gen_button->setEnabled( false );
00873         generateStats();
00874     }
00875     else // historical data
00876     {
00877         bool showLastGraph;
00878         refresh_period_sb->setEnabled( false );
00879         history_start_date_time->setEnabled( true );
00880         history_end_date_time->setEnabled( true );
00881         gen_button->setEnabled( true );
00882         if( data_bg->selectedId() == 3 ) // storage logs data
00883         {
00884             storages_address->setEnabled( true );
00885             showLastGraph = m_UsedHistoricData && 
00886                             ( m_LastSearchType == SEARCHINTRAFFICLOGS );
00887         }
00888         else
00889         {    
00890             storages_address->setEnabled( false );
00891             showLastGraph = m_UsedHistoricData && 
00892                             ( m_LastSearchType == SEARCHINCLIENTSLOGS );
00893         }
00894         if( showLastGraph )
00895         {
00896             save_button->setEnabled( true );
00897             results_widgets->raiseWidget( data_plot ); 
00898         }
00899         else
00900         {
00901             save_button->setEnabled( false );
00902             results_widgets->raiseWidget( generate_msg ); 
00903         }
00904         generate_msg->setText( QString( "For real time data, choose your \
00905 option.\nFor historical data, choose your option and a date range and click\
00906  \"Generate\"." ) );    
00907     }
00908 }

void MonitorWindow::closeEvent ( QCloseEvent *  closeEvent  )  [private]

Definition at line 910 of file MonitorWindow.cpp.

00911 {
00912     WindowClosedEvent *event = new WindowClosedEvent( this );
00913     QApplication::postEvent( rioQt, event );
00914     closeEvent->accept();
00915 }

bool MonitorWindow::connectRioServer ( char *  hostName,
char *  user,
char *  passwd 
)

Definition at line 1081 of file MonitorWindow.cpp.

01082 {
01083     bool   status = true;
01084     string message;
01085 
01086     userName = user;
01087     session = createSession( hostName, user, passwd );
01088 
01089     if( session != NULL )
01090     {
01091         if( !getBlockSize( &blockSize, session ) )
01092         {
01093             message  = "Erro ao tentar obter tamanho de bloco da sessão RIO ";
01094             message += hostName;
01095             message += ".\n";
01096             showMessage( ERROR_MSG, message );
01097             status = false;
01098         }
01099 
01100         // Obtem os IPs e portas dos servidores
01101         
01102         session->GetServerAddress( &m_ServerAddress, &m_ServerAddressSize );
01103         
01104         // Preenche a combobox com os IPs dos servidores de armazenamento. A
01105         // posicao 0 e desconsiderada porque possui o IP do servidor de
01106         // gerenciamento.
01107         for( unsigned int i = 1; i < m_ServerAddressSize; i++ ) 
01108             storages_address->insertItem( QString( inet_ntoa( 
01109                                           m_ServerAddress[ i ].sin_addr ) ) );
01110 
01111         host = session->GetServerName();
01112         setCaption( QString( user ) + "@" + host );
01113 
01114         connect( timer, SIGNAL(timeout()), this, SLOT(refresh()));
01115 
01116         if( refresh() )// force first refresh
01117             timer->start( refresh_period_sb->value() );
01118         else
01119             status = false;
01120     }
01121     else
01122         status = false;
01123 
01124     return status;
01125 }

bool MonitorWindow::ExecuteSearch ( unsigned int  SearchType,
time_t  StartTime,
time_t  EndTime 
) [private]

Funcao para executar uma busca nos logs dos servidores.

Parameters:
SearchType tipo da busca (SEARCHINTRAFFICLOGS para buscas nos logs de um dos servidores de armazenamento e SEARCHINCLIENTSLOGS para buscas nos logs do servidor de gerenciamento).
StartTime tempo inicial da faixa de logs a ser obtida.
EndTime tempo final da faixa de logs a ser obtida.
Returns:
true se a busca foi inicializada com sucesso e false caso a inicializacao da busca tenha falhado.

Definition at line 1161 of file MonitorWindow.cpp.

01163 {
01164     // Estrutura usada na callback para sabermos quem executou a busca.
01165     MonitorLogsData *LogsData;
01166     // Guarda a posicao do servidor.
01167     unsigned int Server;
01168     // Usada para guardar o retorno da funcao SearchLogs.
01169     RioResult Result;
01170     
01171     // Cria um objeto da estrutura LogsData com as informacoes para a callback.
01172     LogsData = new MonitorLogsData;
01173     if( LogsData == NULL )
01174     {
01175         string message;
01176         message  = "Erro de alocacao de memoria ao executar a busca ";
01177         showMessage( ERROR_MSG, message );
01178         return false;
01179     }
01180     
01181     // Inicializa o objeto com as informacoes para a callback.
01182     LogsData->Monitor = this;
01183     LogsData->SearchType = SearchType;
01184     LogsData->ResultFileName = new char[ MaxPathSize ];
01185     if( LogsData->ResultFileName == NULL )
01186     {
01187         string message;
01188         message  = "Erro de alocacao de memoria ao executar a busca ";
01189         showMessage( ERROR_MSG, message );
01190         delete LogsData;
01191         return false;
01192     }
01193     // Cria um arquivo temporario para os logs
01194     if( SearchType == SEARCHINTRAFFICLOGS )
01195         strcpy( LogsData->ResultFileName, "StorageSendRate-XXXXXXXXXX" );
01196     else // SearchType = SEARCHINCLIENTSLOGS
01197         strcpy( LogsData->ResultFileName, "ConnectedClients-XXXXXXXXXX" );
01198     if( !RIOmktemp( LogsData->ResultFileName ) )
01199     {
01200         string message;
01201         message  = "Erro ao criar um arquivo temporario ao executar a busca";
01202         showMessage( ERROR_MSG, message );
01203         delete LogsData;
01204         delete[] LogsData->ResultFileName;
01205         return false;
01206     }     
01207     strcat( LogsData->ResultFileName, ".gz" );
01208 
01209     // Tenta executar a busca nos arquivos de log correspondentes.
01210     if( SearchType == SEARCHINCLIENTSLOGS )
01211         Server = 0;
01212     else
01213         Server = 1 + storages_address->currentItem();
01214     Result = session->SearchLogs( SearchType, StartTime, EndTime,
01215                                   m_ServerAddress[ Server ].sin_addr.s_addr,
01216                                   m_ServerAddress[ Server ].sin_port, 
01217                                   LogsData->ResultFileName, 
01218                                   &ExecuteSearchCallback, ( void * ) LogsData );
01219                                    
01220     if( FAILED( Result ) )
01221     {
01222         string message;
01223         message  = "Erro ao executar solicitacao de busca";
01224         showMessage( ERROR_MSG, message );
01225         delete LogsData;
01226         delete[] LogsData->ResultFileName;
01227         return false;
01228     }      
01229     
01230     return true;
01231 }

void MonitorWindow::ExecuteSearchCallback ( void *  callbackparm,
int  result 
) [static, private]

Funcao de callback chamada quando a busca terminar (com ou sem sucesso tanto para o pedido de busca, como para a propria busca a ser executada).

Parameters:
callbackparm parametro generico passado a callback. No caso dos objetos da classe MonitorWindow, ele sera um ponteiro para uma estrutura do tipo SearchLogsData com a informacao da busca a ser executada.
Returns:
retorno ao executar a busca. Os erros passados sao os seguintes:
  • SEARCHLOGSFAILED a solicitacao de busca foi executada com sucesso, mas logs nao existem dentro da faixa de tempo passada.
  • SEARCHLOGSSUCESS a solicitacao de busca foi executada com sucesso e logs foram achados dentro da faixa de tempo passada.
  • SEARCHLOGSERROR ocorreu um erro na solicitacao da busca nos logs.

Definition at line 1235 of file MonitorWindow.cpp.

01236 {
01237     // Estrutura passada aos eventos gerados pela callback que processa o 
01238     // resultado das buscas.
01239     MonitorLogsData *LogsData;    
01240     // Armazena o evento.
01241     SearchLogsEvent *event;
01242 
01243     LogsData = ( MonitorLogsData* ) callbackparm;
01244 
01245     // Envia o evento a interface principal, informando o resultado da busca.
01246     // Cria o novo evento     
01247     event = new SearchLogsEvent( LogsData->Monitor, LogsData->ResultFileName,
01248                                  LogsData->SearchType, result );
01249     // Envia o evento criado a interface grafica.
01250     QApplication::postEvent( LogsData->Monitor->rioQt, event );
01251     
01252     // Deleta o objeto LogsData (note que nao deletaremos 
01253     // LogsData->ResultFileName, pois isso sera feito quando o evento 
01254     // SearchLogsEvent criado acima for removido apos ser processado).
01255     delete LogsData;    
01256 }

void MonitorWindow::generateStats (  )  [private, slot]

Definition at line 917 of file MonitorWindow.cpp.

00918 {
00919     unsigned int SearchType;
00920     time_t StartTime, EndTime;
00921     
00922     switch( data_bg->selectedId() )
00923     {
00924         case 0: // Client list
00925             setUpdateInterval( refresh_period_sb->value() );
00926             results_widgets->raiseWidget( client_table ); 
00927             refresh();
00928             return;
00929         case 1: // Storage window - queues
00930             setUpdateInterval( refresh_period_sb->value() );
00931             results_widgets->raiseWidget( storage_table ); 
00932             refresh();
00933             return;
00934         case 2:
00935         case 3: 
00936             // Inicializa as variaveis com os tempos.
00937             StartTime = history_start_date_time->dateTime().toTime_t();
00938             EndTime = history_end_date_time->dateTime().toTime_t();
00939             // Invalida o grafico anterior.
00940             m_UsedHistoricData = false;
00941             // Verifica se o tempo inicial e maior do que o final
00942             if( StartTime <= EndTime )
00943             {
00944                 if( data_bg->selectedId() == 2 ) // Busca nos logs do servidor 
00945                                                  // de gerenciamento.
00946                     SearchType = SEARCHINCLIENTSLOGS;
00947                 else // Busca nos logs do servidor de aramzenamento.
00948                     SearchType = SEARCHINTRAFFICLOGS;    
00949                 generate_msg->setText( QString( "Getting Logs. Please wait! " 
00950                                               ) );
00951                 results_widgets->raiseWidget( generate_msg ); 
00952                 setEnabled( false );
00953                 // Muda o cursor para o de espera.
00954                 QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
00955                 if( ExecuteSearch( SearchType, StartTime, EndTime ) )
00956                     return;
00957                 else
00958                 {
00959                     generate_msg->setText( QString( "Error when starting the\
00960                                                      search in logs " ) );
00961                     setEnabled( true );
00962                     // Muda o cursor para o normal.
00963                     QApplication::restoreOverrideCursor();
00964                     return;
00965                 }
00966             }
00967             else
00968             {
00969                 QString message;
00970                 message = "O Tempo inicial " + 
00971                           history_start_date_time->dateTime().toString() + 
00972                           " (" + QString::number( StartTime ) + 
00973                           ") e maior do que o tempo final " + 
00974                           history_end_date_time->dateTime().toString() + " (" + 
00975                           QString::number( EndTime ) + ")";
00976                 showMessage( ERROR_MSG, message );
00977                 
00978             }
00979         default:
00980             break;
00981     }
00982     generate_msg->setText( QString( "For real time data, choose your option.\n\
00983 For historical data, choose your option and a date range and click\
00984  \"Generate\"." ) );    
00985     results_widgets->raiseWidget( generate_msg ); 
00986 }

ClientTable * MonitorWindow::getClientTable (  ) 

Definition at line 1032 of file MonitorWindow.cpp.

01033 {
01034     return client_table;
01035 }

StorageTable * MonitorWindow::getStorageTable (  ) 

Definition at line 1037 of file MonitorWindow.cpp.

01038 {
01039     return storage_table;
01040 }

void MonitorWindow::hideQueue (  )  [signal]

Definition at line 266 of file moc_MonitorWindow.cpp.

00267 {
00268     activate_signal( staticMetaObject()->signalOffset() + 1 );
00269 }

void MonitorWindow::processSearchLogsEvent ( SearchLogsEvent *  event  ) 

Funcao para processar o evento enviado pela callback.

ExecuteSearchCallback. O envio do evento e necessario porque nao podemos acessar componentes do QT em outra thread diferente da thread principal usada pelo QT.

Parameters:
event evento gerado pela callback ExecuteSearchCallback.

Definition at line 1259 of file MonitorWindow.cpp.

01260 {
01261     // Verifica o resultado da solicitacao de busca (note que isso nao e o 
01262     // resultado da busca, e sim da execucao correta do pedido de busca e, em
01263     // caso de um pedido com sucesso para uma busca com sucesso, a correta
01264     // execucao do envio do arquivo com os resultados).
01265     switch( event->getSearchResult() )
01266     {
01267          case SEARCHLOGSFAILED:
01268             // Mostra uma mensagem indicando que a busca nao teve sucesso.
01269             generate_msg->setText( QString( "No logs in selected time interval" 
01270                                           ) );
01271             break;
01272          case SEARCHLOGSSUCESS:
01273             // Cria duas variaveis com os dois campos da mensagem usados quando
01274             // a busca tem sucesso (isso e para evitar chamarmos as funcoes do
01275             // evento mais de uma vez) e as inicializa com os seus valores.
01276             unsigned int SearchType, Server;
01277             char *ResultFileName;
01278             SearchType = event->getSearchType();
01279             ResultFileName = event->getResultFileName(); 
01280             // Define os rotulos do grafico de acordo com o tipo da busca.
01281             // Define qual e o IP do servidor associado ao grafico da busca.
01282             if( SearchType == SEARCHINCLIENTSLOGS )
01283                 Server = 0;
01284             else    
01285                 Server = 1 + storages_address->currentItem();
01286             // Processa o arquivo com os logs e mostra o grafico deste arquivo.
01287             if( !data_plot->ProcessSearchLogs( ResultFileName, SearchType,
01288                                     QString( inet_ntoa( 
01289                                              m_ServerAddress[ Server ].sin_addr 
01290                                              ) ) ) )
01291             {
01292                 #ifdef RIO_DEBUG2
01293                 RioErr << "MonitorWindow::processSearchLogsEvent erro ao gerar "
01294                        << " o grafico do arquivo " << ResultFileName 
01295                        << " usando o tipo " << SearchType << endl;
01296                 #endif
01297                 string message;
01298                 message  = "Erro ao gerar o grafico";
01299                 showMessage( ERROR_MSG, message );
01300             } 
01301             else
01302             {
01303                 // Habilita o botao usado para salvar os dados e o grafico.
01304                 save_button->setEnabled( true );
01305                 // Define que o grafico foi gerado com sucesso 
01306                 m_UsedHistoricData = true;
01307                 // Define o tipo de busca usado
01308                 m_LastSearchType = SearchType;
01309                 // Mostra o grafico.
01310                 results_widgets->raiseWidget( data_plot ); 
01311             }
01312             // Remove o arquivo com a busca.
01313             remove( ResultFileName );
01314             break;
01315         case SEARCHLOGSERROR:
01316             // Mostra uma mensagem indicando que algum erro ocorreu ao
01317             // processarmos a busca.
01318             generate_msg->setText( QString( "Error search request failed" ) );
01319             break;
01320         default:
01321             // Mostra uma mensagem indicando que existe um erro de 
01322             // implementacao (bug), pois o codigo de erro retornado pela
01323             // callback (que gerou este evento) foi invalido.
01324             generate_msg->setText( QString( "Error invalid error code" ) );
01325             break;   
01326     }
01327     // Reabilita a janela de monitoramento.
01328     setEnabled( true );
01329     // Muda o cursor para o normal.
01330     QApplication::restoreOverrideCursor();
01331 }

bool MonitorWindow::refresh (  )  [private, slot]

Definition at line 1127 of file MonitorWindow.cpp.

01128 {
01129     if( ( results_widgets->visibleWidget() != client_table ) &&
01130         ( results_widgets->visibleWidget() != storage_table ) )
01131         return true;
01132     vector<ClientData> client_data;
01133     vector<StorageData> storage_data;
01134     char *user = strdup( userName.latin1() );
01135     if( !( getMonitorTable( session, user, &client_data, &storage_data ) ) )
01136     {
01137         string message;
01138         message  = "Erro ao tentar obter tabelas de monitoramento da ";
01139         message += "sessão RIO ";
01140         message += host;
01141         message += ".\n";
01142         if( timer->isActive() )
01143         {
01144             message += "A sessão será paralisada.\n";
01145             timer->stop();
01146         }
01147         showMessage( ERROR_MSG, message );
01148         free( user );
01149         return false;
01150     }
01151     else
01152     {
01153         client_table->setTable( client_data );
01154         storage_table->setTable( storage_data );
01155         free( user );
01156         return true;
01157     }
01158 }

void MonitorWindow::saveGraph (  )  [private, slot]

Definition at line 988 of file MonitorWindow.cpp.

00989 {
00990     switch( QMessageBox::question( this, "Save graph",
00991                            "In which format would you like to save the graph?",
00992                            "Text (.log)", "Image (.jpg)" ) )
00993     {
00994         case -1:
00995         {
00996             return;
00997         }
00998         case 0:
00999         {
01000             QString log_file = QFileDialog::getSaveFileName(
01001                                          "/home/" + QString( getenv( "USER" ) ),
01002                                          "Text log files (*.log)" );
01003             if( log_file == QString::null ) // no save file defined
01004                 return;
01005             if( !log_file.endsWith( ".log" ) )
01006                 log_file += ".log";
01007 
01008             data_plot->SaveLogsData( log_file.latin1() );
01009             return;
01010         }
01011         case 1:
01012         {
01013             QString file = QFileDialog::getSaveFileName(
01014                                          "/home/" + QString( getenv( "USER" ) ),
01015                                          "JPEG image files (*.jpg)" );
01016             if( file == QString::null ) // no save file defined
01017                 return;
01018             if( !file.endsWith( ".jpg" ) )
01019                 file += ".jpg";
01020 
01021             QPixmap *temp_pixmap = new QPixmap( data_plot->size() );
01022             temp_pixmap->fill( data_plot->backgroundColor() );
01023             data_plot->print( *temp_pixmap );
01024             temp_pixmap->save( file,
01025                                "JPEG" );
01026             delete temp_pixmap;
01027             return;
01028         }
01029     }
01030 }

void MonitorWindow::setMD5Calculation ( char *  object,
bool  finished 
) [private, virtual]

Implements RioExplorer.

Definition at line 1073 of file MonitorWindow.cpp.

01074 {
01075 }

void MonitorWindow::setSyncCheck ( char *  object,
bool  finished 
) [private, virtual]

Implements RioExplorer.

Definition at line 1077 of file MonitorWindow.cpp.

01078 {
01079 }

void MonitorWindow::setUpdateInterval ( int  UpdateInterval  )  [slot]

Definition at line 1042 of file MonitorWindow.cpp.

01043 { 
01044     timer->changeInterval( UpdateInterval );
01045     refresh();
01046 }

bool MonitorWindow::showMessage ( int  type,
string  message,
string  title = "" 
) [private, virtual]

Implements RioExplorer.

Definition at line 1048 of file MonitorWindow.cpp.

01049 {
01050     bool status = true;
01051     ShowMessageEvent * event;
01052     if( title == "" )
01053         event = new ShowMessageEvent( type, message );
01054     else
01055         event = new ShowMessageEvent( type, message, title );
01056     if( type == RioExplorer::QUESTION_MSG )
01057     {
01058         QApplication::sendEvent( rioQt, event );
01059         if( event->getResult() == QMessageBox::No )
01060             status = false;
01061         delete event;
01062     }
01063     else
01064         QApplication::postEvent( rioQt, event );
01065 
01066     return status;
01067 }

void MonitorWindow::showQueue (  )  [signal]

Definition at line 260 of file moc_MonitorWindow.cpp.

00261 {
00262     activate_signal( staticMetaObject()->signalOffset() + 0 );
00263 }

void MonitorWindow::updateCopyProgress ( void   )  [private, virtual]

Implements RioExplorer.

Definition at line 1069 of file MonitorWindow.cpp.

01070 {
01071 }

Field Documentation

unsigned int MonitorWindow::blockSize [private]

Definition at line 324 of file MonitorWindow.h.

ClientTable* MonitorWindow::client_table [private]

Definition at line 286 of file MonitorWindow.h.

QButtonGroup* MonitorWindow::data_bg [private]

Definition at line 291 of file MonitorWindow.h.

QString MonitorWindow::data_file [private]

Definition at line 297 of file MonitorWindow.h.

LogPlot* MonitorWindow::data_plot [private]

Definition at line 288 of file MonitorWindow.h.

QPushButton* MonitorWindow::gen_button [private]

Definition at line 299 of file MonitorWindow.h.

QLabel* MonitorWindow::generate_msg [private]

Definition at line 296 of file MonitorWindow.h.

QDateTimeEdit* MonitorWindow::history_end_date_time [private]

Definition at line 294 of file MonitorWindow.h.

QDateTimeEdit* MonitorWindow::history_start_date_time [private]

Definition at line 293 of file MonitorWindow.h.

char MonitorWindow::home[MAXLEN_FILE+1] [private]

Definition at line 325 of file MonitorWindow.h.

char* MonitorWindow::host [private]

Definition at line 326 of file MonitorWindow.h.

int MonitorWindow::m_LastSearchType [private]

Definition at line 319 of file MonitorWindow.h.

struct sockaddr_in* MonitorWindow::m_ServerAddress [private]

Definition at line 310 of file MonitorWindow.h.

unsigned int MonitorWindow::m_ServerAddressSize [private]

Definition at line 312 of file MonitorWindow.h.

bool MonitorWindow::m_UsedHistoricData [private]

Definition at line 316 of file MonitorWindow.h.

const int MonitorWindow::MAXLEN_FILE = 1024 [static, private]

Definition at line 321 of file MonitorWindow.h.

const int MonitorWindow::MAXLEN_MESSAGE = 1024*5 [static, private]

Definition at line 322 of file MonitorWindow.h.

QButtonGroup* MonitorWindow::options_bg [private]

Definition at line 292 of file MonitorWindow.h.

QSpinBox* MonitorWindow::refresh_period_sb [private]

Definition at line 295 of file MonitorWindow.h.

QWidgetStack* MonitorWindow::results_widgets [private]

Definition at line 306 of file MonitorWindow.h.

RioQt* MonitorWindow::rioQt [private]

Definition at line 285 of file MonitorWindow.h.

QPushButton* MonitorWindow::save_button [private]

Definition at line 298 of file MonitorWindow.h.

StorageTable* MonitorWindow::storage_table [private]

Definition at line 287 of file MonitorWindow.h.

QComboBox* MonitorWindow::storages_address [private]

Definition at line 302 of file MonitorWindow.h.

QTimer* MonitorWindow::timer [private]

Definition at line 289 of file MonitorWindow.h.

QString MonitorWindow::userName [private]

Definition at line 290 of file MonitorWindow.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:35 2012 for RIO by  doxygen 1.6.3