410 lines
16 KiB
C++
410 lines
16 KiB
C++
|
|
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC/LIP6 2008-2010, All Rights Reserved
|
|
//
|
|
// ===================================================================
|
|
//
|
|
// $Id$
|
|
//
|
|
// x-----------------------------------------------------------------x
|
|
// | |
|
|
// | C O R I O L I S |
|
|
// | K i t e - D e t a i l e d R o u t e r |
|
|
// | |
|
|
// | Author : Jean-Paul Chaput |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./ConfigurationWidget.cpp" |
|
|
// | *************************************************************** |
|
|
// | U p d a t e s |
|
|
// | |
|
|
// x-----------------------------------------------------------------x
|
|
|
|
|
|
#include <QLabel>
|
|
#include <QPushButton>
|
|
#include <QFrame>
|
|
#include <QHBoxLayout>
|
|
#include <QVBoxLayout>
|
|
#include <QGridLayout>
|
|
#include <QSpinBox>
|
|
#include <QLineEdit>
|
|
#include <QIntValidator>
|
|
#include <QDoubleValidator>
|
|
|
|
#include "hurricane/viewer/Graphics.h"
|
|
#include "kite/Configuration.h"
|
|
#include "kite/ConfigurationWidget.h"
|
|
|
|
|
|
namespace Kite {
|
|
|
|
using Hurricane::Graphics;
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "Kite::ConfigurationWidget".
|
|
|
|
|
|
ConfigurationWidget::ConfigurationWidget ( QWidget* parent )
|
|
: QWidget(parent)
|
|
, _configuration (NULL)
|
|
, _saturateRatioEdit (new QLineEdit())
|
|
, _globalThresholdEdit (new QLineEdit())
|
|
, _edgeCapacityEdit (new QLineEdit())
|
|
, _expandStepEdit (new QLineEdit())
|
|
, _eventsLimitEdit (new QLineEdit())
|
|
, _ripupCostSb (new QSpinBox())
|
|
, _borderRipupLimitSb (new QSpinBox())
|
|
, _strapRipupLimitSb (new QSpinBox())
|
|
, _localRipupLimitSb (new QSpinBox())
|
|
, _globalRipupLimitSb (new QSpinBox())
|
|
, _longGlobalRipupLimitSb(new QSpinBox())
|
|
{
|
|
setAttribute ( Qt::WA_QuitOnClose, false );
|
|
|
|
QVBoxLayout* vLayout = new QVBoxLayout ();
|
|
QGridLayout* gLayout = new QGridLayout ();
|
|
|
|
QLabel* label = new QLabel();
|
|
label->setFont ( Graphics::getNormalFont(true) );
|
|
label->setText ( "Katabatic - Routing Database" );
|
|
gLayout->addWidget ( label, 0, 0, 1, 4, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Saturate Ratio (%)" );
|
|
_saturateRatioEdit->setValidator ( new QDoubleValidator(this) );
|
|
_saturateRatioEdit->setEnabled ( false );
|
|
gLayout->addWidget ( label , 1, 0, Qt::AlignRight );
|
|
gLayout->addWidget ( _saturateRatioEdit, 1, 1, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
_globalThresholdEdit->setValidator ( new QIntValidator(this) );
|
|
_globalThresholdEdit->setEnabled ( false );
|
|
label->setText ( "Global Length Threshold" );
|
|
gLayout->addWidget ( label , 2, 0, Qt::AlignRight );
|
|
gLayout->addWidget ( _globalThresholdEdit, 2, 1, Qt::AlignLeft );
|
|
|
|
const int kiteRow = 3;
|
|
|
|
label = new QLabel();
|
|
label->setFont ( Graphics::getNormalFont(true) );
|
|
label->setText ( "Kite - Detailed Router" );
|
|
|
|
QFrame* separator = new QFrame ();
|
|
separator->setFrameShape ( QFrame::HLine );
|
|
separator->setFrameShadow ( QFrame::Sunken );
|
|
|
|
gLayout->addWidget ( separator, kiteRow+0, 0, 1, 4 );
|
|
gLayout->addWidget ( label , kiteRow+1, 0, 1, 4, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Edge Capacity (%)" );
|
|
_edgeCapacityEdit->setValidator ( new QDoubleValidator(this) );
|
|
_edgeCapacityEdit->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+2, 0, Qt::AlignRight );
|
|
gLayout->addWidget ( _edgeCapacityEdit, kiteRow+2, 1, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Expand Step (%)" );
|
|
_expandStepEdit->setValidator ( new QDoubleValidator(this) );
|
|
_expandStepEdit->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+3, 0, Qt::AlignRight );
|
|
gLayout->addWidget ( _expandStepEdit, kiteRow+3, 1, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
_eventsLimitEdit->setValidator ( new QIntValidator(this) );
|
|
_eventsLimitEdit->setEnabled ( false );
|
|
label->setText ( "Events Limit" );
|
|
gLayout->addWidget ( label , kiteRow+4, 0, Qt::AlignRight );
|
|
gLayout->addWidget ( _eventsLimitEdit, kiteRow+4, 1, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Ripup Cost" );
|
|
_ripupCostSb->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+2, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _ripupCostSb, kiteRow+2, 3, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setFont ( Graphics::getNormalFont(true) );
|
|
label->setText ( "Ripup Limit" );
|
|
gLayout->addWidget ( label, kiteRow+3, 2, Qt::AlignLeft );
|
|
|
|
QSizePolicy spinBoxPolicy (QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Borders" );
|
|
_borderRipupLimitSb->setEnabled ( false );
|
|
//_borderRipupLimitSb->setSizePolicy ( spinBoxPolicy );
|
|
gLayout->addWidget ( label , kiteRow+4, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _borderRipupLimitSb, kiteRow+4, 3, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Straps" );
|
|
_strapRipupLimitSb->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+5, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _strapRipupLimitSb, kiteRow+5, 3, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Locals" );
|
|
_localRipupLimitSb->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+6, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _localRipupLimitSb, kiteRow+6, 3, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Globals" );
|
|
_globalRipupLimitSb->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+7, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _globalRipupLimitSb, kiteRow+7, 3, Qt::AlignLeft );
|
|
|
|
label = new QLabel();
|
|
label->setText ( "Long Globals" );
|
|
_longGlobalRipupLimitSb->setEnabled ( false );
|
|
gLayout->addWidget ( label , kiteRow+8, 2, Qt::AlignRight );
|
|
gLayout->addWidget ( _longGlobalRipupLimitSb, kiteRow+8, 3, Qt::AlignLeft );
|
|
|
|
separator = new QFrame ();
|
|
separator->setFrameShape ( QFrame::HLine );
|
|
separator->setFrameShadow ( QFrame::Sunken );
|
|
gLayout->addWidget ( separator, kiteRow+9, 0, 1, 4 );
|
|
|
|
vLayout->addLayout ( gLayout );
|
|
|
|
QHBoxLayout* hLayout = new QHBoxLayout ();
|
|
hLayout->addStretch ();
|
|
|
|
QPushButton* apply = new QPushButton ();
|
|
apply->setText ( tr("Apply") );
|
|
hLayout->addWidget ( apply );
|
|
hLayout->addStretch ();
|
|
|
|
vLayout->addLayout ( hLayout );
|
|
vLayout->addStretch ();
|
|
|
|
setLayout ( vLayout );
|
|
|
|
connect ( apply, SIGNAL(clicked()), this, SLOT(_applySettings()) );
|
|
// connect ( _saturateRatioEdit , SIGNAL(returnPressed()) , this, SLOT(_updateSaturateRatio()) );
|
|
// connect ( _globalThresholdEdit , SIGNAL(returnPressed()) , this, SLOT(_updateGlobalThreshold()) );
|
|
// connect ( _edgeCapacityEdit , SIGNAL(returnPressed()) , this, SLOT(_updateEdgeCapacity()) );
|
|
// connect ( _expandStepEdit , SIGNAL(returnPressed()) , this, SLOT(_updateExpandStep()) );
|
|
// connect ( _eventsLimitEdit , SIGNAL(returnPressed()) , this, SLOT(_updateEventsLimit()) );
|
|
// connect ( _ripupCostSb , SIGNAL(valueChanged(int)), this, SLOT(_updateRipupCost(int)) );
|
|
// connect ( _borderRipupLimitSb , SIGNAL(valueChanged(int)), this, SLOT(_updateBorderRipupLimit(int)) );
|
|
// connect ( _strapRipupLimitSb , SIGNAL(valueChanged(int)), this, SLOT(_updateStrapRipupLimit(int)) );
|
|
// connect ( _localRipupLimitSb , SIGNAL(valueChanged(int)), this, SLOT(_updateLocalRipupLimit(int)) );
|
|
// connect ( _globalRipupLimitSb , SIGNAL(valueChanged(int)), this, SLOT(_updateGlobalRipupLimit(int)) );
|
|
// connect ( _longGlobalRipupLimitSb, SIGNAL(valueChanged(int)), this, SLOT(_updateLongGlobalRipupLimit(int)) );
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::setConfiguration ( Configuration* config )
|
|
{
|
|
if ( config != NULL ) {
|
|
_saturateRatioEdit ->setText ( QString("%1").arg(config->getSaturateRatio()) );
|
|
_globalThresholdEdit->setText ( QString("%1").arg((long)DbU::getLambda(config->getGlobalThreshold())) );
|
|
|
|
_edgeCapacityEdit->setText ( QString("%1").arg(config->getEdgeCapacityPercent()) );
|
|
_expandStepEdit ->setText ( QString("%1").arg(config->getExpandStep()) );
|
|
_eventsLimitEdit ->setText ( QString("%1").arg(config->getEventsLimit()) );
|
|
|
|
_ripupCostSb ->setValue ( config->getRipupCost() );
|
|
_borderRipupLimitSb ->setValue ( config->getRipupLimit(Configuration::BorderRipupLimit) );
|
|
_strapRipupLimitSb ->setValue ( config->getRipupLimit(Configuration::StrapRipupLimit) );
|
|
_localRipupLimitSb ->setValue ( config->getRipupLimit(Configuration::LocalRipupLimit) );
|
|
_globalRipupLimitSb ->setValue ( config->getRipupLimit(Configuration::GlobalRipupLimit) );
|
|
_longGlobalRipupLimitSb->setValue ( config->getRipupLimit(Configuration::LongGlobalRipupLimit) );
|
|
|
|
_saturateRatioEdit ->setEnabled ( true );
|
|
_globalThresholdEdit ->setEnabled ( true );
|
|
_edgeCapacityEdit ->setEnabled ( true );
|
|
_expandStepEdit ->setEnabled ( true );
|
|
_eventsLimitEdit ->setEnabled ( true );
|
|
_ripupCostSb ->setEnabled ( true );
|
|
_borderRipupLimitSb ->setEnabled ( true );
|
|
_strapRipupLimitSb ->setEnabled ( true );
|
|
_localRipupLimitSb ->setEnabled ( true );
|
|
_globalRipupLimitSb ->setEnabled ( true );
|
|
_longGlobalRipupLimitSb->setEnabled ( true );
|
|
} else {
|
|
_saturateRatioEdit ->setEnabled ( false );
|
|
_globalThresholdEdit ->setEnabled ( false );
|
|
_edgeCapacityEdit ->setEnabled ( false );
|
|
_expandStepEdit ->setEnabled ( false );
|
|
_eventsLimitEdit ->setEnabled ( false );
|
|
_ripupCostSb ->setEnabled ( false );
|
|
_borderRipupLimitSb ->setEnabled ( false );
|
|
_strapRipupLimitSb ->setEnabled ( false );
|
|
_localRipupLimitSb ->setEnabled ( false );
|
|
_globalRipupLimitSb ->setEnabled ( false );
|
|
_longGlobalRipupLimitSb->setEnabled ( false );
|
|
}
|
|
_configuration = config;
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_applySettings ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
_updateSaturateRatio ();
|
|
_updateGlobalThreshold ();
|
|
_updateEdgeCapacity ();
|
|
_updateExpandStep ();
|
|
_updateEventsLimit ();
|
|
_updateRipupCost (_ripupCostSb ->value());
|
|
_updateBorderRipupLimit (_borderRipupLimitSb ->value());
|
|
_updateStrapRipupLimit (_strapRipupLimitSb ->value());
|
|
_updateLocalRipupLimit (_localRipupLimitSb ->value());
|
|
_updateGlobalRipupLimit (_globalRipupLimitSb ->value());
|
|
_updateLongGlobalRipupLimit(_longGlobalRipupLimitSb->value());
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateSaturateRatio ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
bool success = false;
|
|
float ratio = _saturateRatioEdit->displayText().toFloat ( &success );
|
|
if ( not success or (ratio >= 1.0) or (ratio < 0.0) ) {
|
|
_saturateRatioEdit->setText ( QString("%1").arg(_configuration->getSaturateRatio()) );
|
|
} else {
|
|
_configuration->setSaturateRatio ( ratio );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateGlobalThreshold ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
bool success = false;
|
|
DbU::Unit length = DbU::lambda ( _globalThresholdEdit->displayText().toDouble(&success) );
|
|
if ( not success or (length < 0) ) {
|
|
_globalThresholdEdit->setText ( QString("%1").arg((long)DbU::getLambda(_configuration->getGlobalThreshold())) );
|
|
} else {
|
|
_configuration->setGlobalThreshold ( length );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateEdgeCapacity ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
bool success = false;
|
|
float ratio = _edgeCapacityEdit->displayText().toFloat ( &success );
|
|
if ( not success or (ratio >= 1.0) or (ratio < 0.0) ) {
|
|
_edgeCapacityEdit->setText ( QString("%1").arg(_configuration->getEdgeCapacityPercent()) );
|
|
} else {
|
|
_configuration->setEdgeCapacityPercent ( ratio );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateExpandStep ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
bool success = false;
|
|
float ratio = _expandStepEdit->displayText().toFloat ( &success );
|
|
if ( not success or (ratio >= 1.0) or (ratio < 0.0) ) {
|
|
_expandStepEdit->setText ( QString("%1").arg(_configuration->getExpandStep()) );
|
|
} else {
|
|
_configuration->setExpandStep ( ratio );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateEventsLimit ()
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
bool success = false;
|
|
long limit = _eventsLimitEdit->displayText().toLong ( &success );
|
|
if ( not success or (limit < 0) ) {
|
|
_eventsLimitEdit->setText ( QString("%1").arg(_configuration->getEventsLimit()) );
|
|
} else {
|
|
_configuration->setEventsLimit ( (unsigned long)limit );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateRipupCost ( int cost )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
//std::cerr << "_vptr:" << (void*)(*((int*)_configuration)) << std::endl;
|
|
if ( cost < 0 ) {
|
|
_ripupCostSb->setValue ( (int)_configuration->getRipupCost() );
|
|
} else {
|
|
_configuration->setRipupCost ( (unsigned int)cost );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateBorderRipupLimit ( int limit )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
if ( limit < 0 ) {
|
|
_borderRipupLimitSb->setValue ( (int)_configuration->getRipupLimit(Configuration::BorderRipupLimit) );
|
|
} else {
|
|
_configuration->setRipupLimit ( Configuration::BorderRipupLimit, (unsigned int)limit );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateStrapRipupLimit ( int limit )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
if ( limit < 0 ) {
|
|
_strapRipupLimitSb->setValue ( (int)_configuration->getRipupLimit(Configuration::StrapRipupLimit) );
|
|
} else {
|
|
_configuration->setRipupLimit ( Configuration::StrapRipupLimit, (unsigned int)limit );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateLocalRipupLimit ( int limit )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
if ( limit < 0 ) {
|
|
_localRipupLimitSb->setValue ( (int)_configuration->getRipupLimit(Configuration::LocalRipupLimit) );
|
|
} else {
|
|
_configuration->setRipupLimit ( Configuration::LocalRipupLimit, (unsigned int)limit );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateGlobalRipupLimit ( int limit )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
if ( limit < 0 ) {
|
|
_globalRipupLimitSb->setValue ( (int)_configuration->getRipupLimit(Configuration::GlobalRipupLimit) );
|
|
} else {
|
|
_configuration->setRipupLimit ( Configuration::GlobalRipupLimit, (unsigned int)limit );
|
|
}
|
|
}
|
|
|
|
|
|
void ConfigurationWidget::_updateLongGlobalRipupLimit ( int limit )
|
|
{
|
|
if ( _configuration == NULL ) return;
|
|
|
|
if ( limit < 0 ) {
|
|
_longGlobalRipupLimitSb->setValue ( (int)_configuration->getRipupLimit(Configuration::LongGlobalRipupLimit) );
|
|
} else {
|
|
_configuration->setRipupLimit ( Configuration::LongGlobalRipupLimit, (unsigned int)limit );
|
|
}
|
|
}
|
|
|
|
|
|
} // End of Kite namespace.
|