CameraSetup::CameraSetup(ros::NodeHandle& nh, ros::NodeHandle& nh_private, QWidget *parent, Qt::WFlags flags) :
QMainWindow(parent, flags), nh_(nh), nh_private_(nh_private), quit_threads_(false), broadcaster_(0)
{
ui.setupUi(this);
nh_private_.param("camera_n", camera_n_, 2);
ROS_DEBUG("Total camera: %d", camera_n_);
broadcaster_.resize(camera_n_);
camera_parameter_.resize(camera_n_);
camera_tf_.resize(camera_n_);
ui.tableWidget->setRowCount(camera_n_*2);
ui.tableWidget->setColumnCount(10);
ui.tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem(QString("Camera")));
ui.tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem(QString("Tx")));
ui.tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem(QString("Ty")));
ui.tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem(QString("Tz")));
ui.tableWidget->setHorizontalHeaderItem(4, new QTableWidgetItem(QString("Rx")));
ui.tableWidget->setHorizontalHeaderItem(5, new QTableWidgetItem(QString("Ry")));
ui.tableWidget->setHorizontalHeaderItem(6, new QTableWidgetItem(QString("Rz")));
ui.tableWidget->setHorizontalHeaderItem(7, new QTableWidgetItem(QString("Rw")));
ui.tableWidget->setHorizontalHeaderItem(8, new QTableWidgetItem(QString("Source")));
ui.tableWidget->setHorizontalHeaderItem(9, new QTableWidgetItem(QString("Target")));
for (int i = 0; i < camera_n_; i++)
{
string camera_parameter_text;
nh_private_.param((QString("camera_%1").arg(i)).toStdString(), camera_parameter_text, string(""));
ROS_DEBUG("Camera %d parameter: %s", i, camera_parameter_text.c_str());
QStringList tokens = QString(camera_parameter_text.c_str()).split(' ');
ROS_DEBUG("Camera %d parameter count: %d", i, tokens.size());
if(tokens.size() != 10)
{
ROS_ERROR("camera %d paparmeter count is not correct", i);
continue;
}
int j = 0;
foreach(QString text, tokens)
{
QTableWidgetItem* item = new QTableWidgetItem(text);
Qt::ItemFlags f = item->flags() & ~Qt::ItemIsEditable;
item->setFlags(f);
ui.tableWidget->setItem(i*2, j, item);
j++;
}
CameraParameter parameter;
parameter.name = tokens[0].toStdString();
parameter.tf.setOrigin(tf::Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble()));
parameter.tf.setRotation(tf::Quaternion(tokens[4].toDouble(), tokens[5].toDouble(), tokens[6].toDouble(), tokens[7].toDouble()));
parameter.source = tokens[8].toStdString();
parameter.target = tokens[9].toStdString();
camera_tf_[i] = parameter.tf;
camera_parameter_[i] = parameter;
ui.tableWidget->setItem(i*2 + 1, 1, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 2, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 3, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 4, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 5, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 6, new QTableWidgetItem("0"));
ui.tableWidget->setItem(i*2 + 1, 7, new QTableWidgetItem());
ui.tableWidget->setItem(i*2 + 1, 8, new QTableWidgetItem());
ui.tableWidget->setItem(i*2 + 1, 9, new QTableWidgetItem());
Qt::ItemFlags f = ui.tableWidget->item(i*2 + 1, 7)->flags() & ~Qt::ItemIsEditable;
ui.tableWidget->item(i*2 + 1, 7)->setFlags(f);
ui.tableWidget->item(i*2 + 1, 8)->setFlags(f);
ui.tableWidget->item(i*2 + 1, 9)->setFlags(f);
ui.tableWidget->setItemDelegateForRow(i*2+1, new DoubleSpinBoxDelegate());
}
FQTermShortcutDialog::FQTermShortcutDialog(FQTermShortcutHelper* helper, QWidget *parent_, Qt::WindowFlags fl)
: QDialog(parent_, fl),
helper_(helper),
table_(NULL) {
setWindowTitle(tr("Shortcut Setting"));
//grabKeyboard();
if (helper_)
{
QSignalMapper* signalMapper = new QSignalMapper(this);
int row = FQTermShortcutHelper::FQTERM_APPLICATION_SHORTCUT_END - FQTermShortcutHelper::FQTERM_APPLICATION_SHORTCUT_START - 1;
int column = 3;
table_ = new QTableWidget(row, column, this);
table_->clear();
QStringList header;
header << tr("Description") << tr("Shortcut") << "";
table_->setHorizontalHeaderLabels(header);
for (int i = 0; i < row; ++i) {
for (int j = 0; j < column; ++j) {
if (j == 0) {
QTableWidgetItem* item = new QTableWidgetItem;
table_->setItem(i, j, item);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setText(helper_->getShortcutDescription(i + 1));
} else if (j == 1) {
FQTermShortcutTableWidget* stw = new FQTermShortcutTableWidget(table_);
stw->setReadOnly(true);
stw->setText(helper_->getShortcutText(i + 1));
table_->setCellWidget(i, j, stw);
}else {
QPushButton* btn = new QPushButton(tr("default"), table_);
table_->setCellWidget(i, j, btn);
FQ_VERIFY(connect(btn, SIGNAL(clicked()), signalMapper, SLOT(map())));
signalMapper->setMapping(btn, i);
}
}
}
table_->resizeColumnsToContents();
int tableWidth = table_->horizontalHeader()->length();
if (table_->horizontalScrollBar() && table_->horizontalScrollBar()->isVisible()) {
tableWidth += table_->horizontalScrollBar()->width();
}
QPushButton* okBtn = new QPushButton(tr("OK"), this);
FQ_VERIFY(connect(okBtn, SIGNAL(clicked()), this, SLOT(okBtnClicked())));
QPushButton* applyBtn = new QPushButton(tr("Apply"), this);
FQ_VERIFY(connect(applyBtn, SIGNAL(clicked()), this, SLOT(applyBtnClicked())));
QPushButton* cancelBtn = new QPushButton(tr("Cancel"), this);
FQ_VERIFY(connect(cancelBtn, SIGNAL(clicked()), this, SLOT(cancelBtnClicked())));
QPushButton* resetBtn = new QPushButton(tr("Reset All"), this);
FQ_VERIFY(connect(resetBtn, SIGNAL(clicked()), this, SLOT(resetBtnClicked())));
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
QGridLayout* layout = new QGridLayout(this);
QLabel* label = new QLabel(tr("Press key/combines on Shortcut column.\nNote Del is reserved for clear shortcut setting."));
layout->addWidget(label, 0, 0, 1, -1);
layout->addWidget(table_, 1, 0, 1, -1);
layout->addWidget(okBtn, 2, 0);
layout->addWidget(applyBtn, 2, 1);
layout->addWidget(cancelBtn, 2, 2);
layout->addWidget(resetBtn, 2, 3);
setLayout(layout);
int left = 0;
int right = 0;
layout->getContentsMargins(&left, NULL, &right, NULL);
table_->horizontalHeader()->setStretchLastSection(true);
tableWidth *= 1.1;
resize(tableWidth + left + right, height());
FQ_VERIFY(connect(signalMapper, SIGNAL(mapped(int)),this, SLOT(defaultClicked(int))));
}
}
void AppDockWidget::loadBackTraceAndVariableData()
{
reactvariable = 0;
QString registerFilePath = mainwindow->GetCurrentWorkDir();
QString registerFile = registerFilePath + "/test/info_backtrace.txt";
QFile inputFile(registerFile);
inputFile.open(QIODevice::ReadOnly);
if (inputFile.size() != 0)
{
QTextStream in(&inputFile);
int i = 0;
int j = 0;
QTableWidgetItem *item;
ui.backTraceTableWidget->clearContents();
ui.variableTableWidget->clearContents();
while (!in.atEnd())
{
QString lineFunction = in.readLine();
QString lineVariable = in.readLine();
if(lineFunction.isEmpty() || lineVariable.isEmpty())
{
QMessageBox::about(this, tr("notice"), tr("the file is null"));
return;
}
if (i == 0)
{
QStringList lineIncludePC = lineFunction.split("at:");
lineFunction = lineIncludePC[0];
}
QStringList lineFunctionList = lineFunction.split(':');
item = new QTableWidgetItem(lineFunctionList[0]);
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.backTraceTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem(lineFunctionList[1]);
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.backTraceTableWidget->setItem(i, 1, item);
i++;
QStringList lineVariableList = lineVariable.split(',');
int k = 0;
while (k < lineVariableList.count())
{
QStringList lineVariableList1 = lineVariableList[k].split('=');
item = new QTableWidgetItem(lineVariableList1[0]);
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.variableTableWidget->setItem(j, 0, item);
item = new QTableWidgetItem(lineVariableList1[1]);
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);//使变量值这一列可编辑
ui.variableTableWidget->setItem(j, 1, item);
k++;
j++;
}
}
}
inputFile.close();
reactvariable = 1;
}
QgsProjectProperties::QgsProjectProperties( QgsMapCanvas* mapCanvas, QWidget *parent, Qt::WFlags fl )
: QDialog( parent, fl )
, mMapCanvas( mapCanvas )
{
setupUi( this );
connect( buttonBox, SIGNAL( accepted() ), this, SLOT( accept() ) );
connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) );
connect( buttonBox->button( QDialogButtonBox::Apply ), SIGNAL( clicked() ), this, SLOT( apply() ) );
connect( this, SIGNAL( accepted() ), this, SLOT( apply() ) );
connect( projectionSelector, SIGNAL( sridSelected( QString ) ), this, SLOT( setMapUnitsToCurrentProjection() ) );
///////////////////////////////////////////////////////////
// Properties stored in map canvas's QgsMapRenderer
// these ones are propagated to QgsProject by a signal
QgsMapRenderer* myRenderer = mMapCanvas->mapRenderer();
QGis::UnitType myUnit = myRenderer->mapUnits();
setMapUnits( myUnit );
// we need to initialize it, since the on_cbxProjectionEnabled_stateChanged()
// callback triggered by setChecked() might use it.
mProjectSrsId = myRenderer->destinationCrs().srsid();
//see if the user wants on the fly projection enabled
bool myProjectionEnabled = myRenderer->hasCrsTransformEnabled();
cbxProjectionEnabled->setChecked( myProjectionEnabled );
QgsDebugMsg( "Read project CRSID: " + QString::number( mProjectSrsId ) );
projectionSelector->setSelectedCrsId( mProjectSrsId );
projectionSelector->setEnabled( myProjectionEnabled );
///////////////////////////////////////////////////////////
// Properties stored in QgsProject
title( QgsProject::instance()->title() );
// get the manner in which the number of decimal places in the mouse
// position display is set (manual or automatic)
bool automaticPrecision = QgsProject::instance()->readBoolEntry( "PositionPrecision", "/Automatic" );
if ( automaticPrecision )
{
radAutomatic->setChecked( true );
spinBoxDP->setDisabled( true );
labelDP->setDisabled( true );
}
else
{
radManual->setChecked( true );
}
cbxAbsolutePath->setCurrentIndex( QgsProject::instance()->readBoolEntry( "Paths", "/Absolute", true ) ? 0 : 1 );
int dp = QgsProject::instance()->readNumEntry( "PositionPrecision", "/DecimalPlaces" );
spinBoxDP->setValue( dp );
QString format = QgsProject::instance()->readEntry( "PositionPrecision", "/DegreeFormat", "D" );
if ( format == "DM" )
radDM->setChecked( true );
else if ( format == "DMS" )
radDMS->setChecked( true );
else
radD->setChecked( true );
//get the color selections and set the button color accordingly
int myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorRedPart", 255 );
int myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorGreenPart", 255 );
int myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorBluePart", 0 );
int myAlphaInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorAlphaPart", 255 );
QColor myColor = QColor( myRedInt, myGreenInt, myBlueInt, myAlphaInt );
pbnSelectionColor->setColor( myColor );
//get the color for map canvas background and set button color accordingly (default white)
myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorRedPart", 255 );
myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorGreenPart", 255 );
myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorBluePart", 255 );
myColor = QColor( myRedInt, myGreenInt, myBlueInt );
pbnCanvasColor->setColor( myColor );
//get project scales
QStringList myScales = QgsProject::instance()->readListEntry( "Scales", "/ScalesList" );
if ( !myScales.isEmpty() )
{
QStringList::const_iterator scaleIt = myScales.constBegin();
for ( ; scaleIt != myScales.constEnd(); ++scaleIt )
{
QListWidgetItem* newItem = new QListWidgetItem( lstScales );
newItem->setText( *scaleIt );
newItem->setFlags( Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
lstScales->addItem( newItem );
}
}
grpProjectScales->setChecked( QgsProject::instance()->readBoolEntry( "Scales", "/useProjectScales" ) );
QgsMapLayer* currentLayer = 0;
QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" );
const QMap<QString, QgsMapLayer*> &mapLayers = QgsMapLayerRegistry::instance()->mapLayers();
if ( mMapCanvas->currentLayer() )
{
mLayerSrsId = mMapCanvas->currentLayer()->crs().srsid();
}
else if ( mapLayers.size() > 0 )
{
mLayerSrsId = mapLayers.begin().value()->crs().srsid();
}
else
{
mLayerSrsId = mProjectSrsId;
}
twIdentifyLayers->setColumnCount( 3 );
twIdentifyLayers->horizontalHeader()->setVisible( true );
twIdentifyLayers->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Layer" ) ) );
twIdentifyLayers->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "Type" ) ) );
twIdentifyLayers->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "Identifiable" ) ) );
twIdentifyLayers->setRowCount( mapLayers.size() );
twIdentifyLayers->verticalHeader()->setResizeMode( QHeaderView::ResizeToContents );
int i = 0;
for ( QMap<QString, QgsMapLayer*>::const_iterator it = mapLayers.constBegin(); it != mapLayers.constEnd(); it++, i++ )
{
currentLayer = it.value();
QTableWidgetItem *twi = new QTableWidgetItem( QString::number( i ) );
twIdentifyLayers->setVerticalHeaderItem( i, twi );
twi = new QTableWidgetItem( currentLayer->name() );
twi->setData( Qt::UserRole, it.key() );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
twIdentifyLayers->setItem( i, 0, twi );
QString type;
if ( currentLayer->type() == QgsMapLayer::VectorLayer )
{
type = tr( "Vector" );
}
else if ( currentLayer->type() == QgsMapLayer::RasterLayer )
{
QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( currentLayer );
if ( rl && rl->providerType() == "wms" )
{
type = tr( "WMS" );
}
else
{
type = tr( "Raster" );
}
}
twi = new QTableWidgetItem( type );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
twIdentifyLayers->setItem( i, 1, twi );
QCheckBox *cb = new QCheckBox();
cb->setChecked( !noIdentifyLayerIdList.contains( currentLayer->id() ) );
twIdentifyLayers->setCellWidget( i, 2, cb );
}
grpOWSServiceCapabilities->setChecked( QgsProject::instance()->readBoolEntry( "WMSServiceCapabilities", "/", false ) );
mWMSTitle->setText( QgsProject::instance()->readEntry( "WMSServiceTitle", "/" ) );
mWMSContactOrganization->setText( QgsProject::instance()->readEntry( "WMSContactOrganization", "/", "" ) );
mWMSContactPerson->setText( QgsProject::instance()->readEntry( "WMSContactPerson", "/", "" ) );
mWMSContactMail->setText( QgsProject::instance()->readEntry( "WMSContactMail", "/", "" ) );
mWMSContactPhone->setText( QgsProject::instance()->readEntry( "WMSContactPhone", "/", "" ) );
mWMSAbstract->setPlainText( QgsProject::instance()->readEntry( "WMSServiceAbstract", "/", "" ) );
mWMSOnlineResourceLineEdit->setText( QgsProject::instance()->readEntry( "WMSOnlineResource", "/", "" ) );
mWMSUrlLineEdit->setText( QgsProject::instance()->readEntry( "WMSUrl", "/", "" ) );
bool ok;
QStringList values;
mWMSExtMinX->setValidator( new QDoubleValidator( mWMSExtMinX ) );
mWMSExtMinY->setValidator( new QDoubleValidator( mWMSExtMinY ) );
mWMSExtMaxX->setValidator( new QDoubleValidator( mWMSExtMaxX ) );
mWMSExtMaxY->setValidator( new QDoubleValidator( mWMSExtMaxY ) );
values = QgsProject::instance()->readListEntry( "WMSExtent", "/", &ok );
grpWMSExt->setChecked( ok && values.size() == 4 );
if ( grpWMSExt->isChecked() )
{
mWMSExtMinX->setText( values[0] );
mWMSExtMinY->setText( values[1] );
mWMSExtMaxX->setText( values[2] );
mWMSExtMaxY->setText( values[3] );
}
values = QgsProject::instance()->readListEntry( "WMSCrsList", "/", &ok );
grpWMSList->setChecked( ok && values.size() > 0 );
if ( grpWMSList->isChecked() )
{
mWMSList->addItems( values );
}
else
{
values = QgsProject::instance()->readListEntry( "WMSEpsgList", "/", &ok );
grpWMSList->setChecked( ok && values.size() > 0 );
if ( grpWMSList->isChecked() )
{
QStringList list;
foreach ( QString value, values )
{
list << QString( "EPSG:%1" ).arg( value );
}
mWMSList->addItems( list );
}
void MainSettingsDialog::fillAllAutoProfilesTable()
{
for (int i = ui->autoProfileTableWidget->rowCount()-1; i >= 0; i--)
{
ui->autoProfileTableWidget->removeRow(i);
}
//QStringList tableHeader;
//tableHeader << tr("Active") << tr("GUID") << tr("Profile") << tr("Application") << tr("Default?")
// << tr("Instance");
//ui->autoProfileTableWidget->setHorizontalHeaderLabels(tableHeader);
ui->autoProfileTableWidget->horizontalHeader()->setVisible(true);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
ui->autoProfileTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
#else
ui->autoProfileTableWidget->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
#endif
ui->autoProfileTableWidget->hideColumn(5);
int i = 0;
AutoProfileInfo *info = allDefaultProfile;
ui->autoProfileTableWidget->insertRow(i);
QTableWidgetItem *item = new QTableWidgetItem();
item->setCheckState(info->isActive() ? Qt::Checked : Qt::Unchecked);
ui->autoProfileTableWidget->setItem(i, 0, item);
QString deviceName = info->getDeviceName();
QString guidDisplay = info->getGUID();
if (!deviceName.isEmpty())
{
guidDisplay = QString("%1 ").arg(info->getDeviceName());
guidDisplay.append(QString("(%1)").arg(info->getGUID()));
}
item = new QTableWidgetItem(guidDisplay);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getGUID());
item->setToolTip(info->getGUID());
ui->autoProfileTableWidget->setItem(i, 1, item);
QFileInfo profilePath(info->getProfileLocation());
item = new QTableWidgetItem(profilePath.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getProfileLocation());
item->setToolTip(info->getProfileLocation());
ui->autoProfileTableWidget->setItem(i, 2, item);
QFileInfo exeInfo(info->getExe());
item = new QTableWidgetItem(exeInfo.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getExe());
item->setToolTip(info->getExe());
ui->autoProfileTableWidget->setItem(i, 3, item);
item = new QTableWidgetItem("Default");
item->setData(Qt::UserRole, "default");
ui->autoProfileTableWidget->setItem(i, 4, item);
item = new QTableWidgetItem("Instance");
item->setData(Qt::UserRole, QVariant::fromValue<AutoProfileInfo*>(info));
ui->autoProfileTableWidget->setItem(i, 5, item);
i++;
QListIterator<AutoProfileInfo*> iterDefaults(defaultList);
while (iterDefaults.hasNext())
{
AutoProfileInfo *info = iterDefaults.next();
ui->autoProfileTableWidget->insertRow(i);
QTableWidgetItem *item = new QTableWidgetItem();
item->setCheckState(info->isActive() ? Qt::Checked : Qt::Unchecked);
ui->autoProfileTableWidget->setItem(i, 0, item);
QString deviceName = info->getDeviceName();
QString guidDisplay = info->getGUID();
if (!deviceName.isEmpty())
{
guidDisplay = QString("%1 ").arg(info->getDeviceName());
guidDisplay.append(QString("(%1)").arg(info->getGUID()));
}
item = new QTableWidgetItem(guidDisplay);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getGUID());
item->setToolTip(info->getGUID());
ui->autoProfileTableWidget->setItem(i, 1, item);
QFileInfo profilePath(info->getProfileLocation());
item = new QTableWidgetItem(profilePath.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getProfileLocation());
item->setToolTip(info->getProfileLocation());
ui->autoProfileTableWidget->setItem(i, 2, item);
QFileInfo exeInfo(info->getExe());
item = new QTableWidgetItem(exeInfo.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getExe());
item->setToolTip(info->getExe());
ui->autoProfileTableWidget->setItem(i, 3, item);
item = new QTableWidgetItem("Default");
item->setData(Qt::UserRole, "default");
ui->autoProfileTableWidget->setItem(i, 4, item);
item = new QTableWidgetItem("Instance");
item->setData(Qt::UserRole, QVariant::fromValue<AutoProfileInfo*>(info));
ui->autoProfileTableWidget->setItem(i, 5, item);
i++;
}
QListIterator<AutoProfileInfo*> iter(profileList);
while (iter.hasNext())
{
AutoProfileInfo *info = iter.next();
ui->autoProfileTableWidget->insertRow(i);
QTableWidgetItem *item = new QTableWidgetItem();
item->setCheckState(info->isActive() ? Qt::Checked : Qt::Unchecked);
ui->autoProfileTableWidget->setItem(i, 0, item);
QString deviceName = info->getDeviceName();
QString guidDisplay = info->getGUID();
if (!deviceName.isEmpty())
{
guidDisplay = QString("%1 ").arg(info->getDeviceName());
guidDisplay.append(QString("(%1)").arg(info->getGUID()));
}
item = new QTableWidgetItem(guidDisplay);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getGUID());
item->setToolTip(info->getGUID());
ui->autoProfileTableWidget->setItem(i, 1, item);
QFileInfo profilePath(info->getProfileLocation());
item = new QTableWidgetItem(profilePath.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getProfileLocation());
item->setToolTip(info->getProfileLocation());
ui->autoProfileTableWidget->setItem(i, 2, item);
QFileInfo exeInfo(info->getExe());
item = new QTableWidgetItem(exeInfo.fileName());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, info->getExe());
item->setToolTip(info->getExe());
ui->autoProfileTableWidget->setItem(i, 3, item);
item = new QTableWidgetItem();
item->setData(Qt::UserRole, "");
ui->autoProfileTableWidget->setItem(i, 4, item);
item = new QTableWidgetItem("Instance");
item->setData(Qt::UserRole, QVariant::fromValue<AutoProfileInfo*>(info));
ui->autoProfileTableWidget->setItem(i, 5, item);
i++;
}
}
void ClassSpaceChecker::search(const QString & searchName, const QString & searchText,
bool useUncryptName,
bool ignoreInnerClass,
bool onlyAnonymousClass,
bool useAsPackageName)
{
if(classList_.size() <= 0)
return;
ui.tableWidgetResult->clearContents();
ui.tableWidgetResult->setRowCount(0);
ui.tableWidgetResult->horizontalHeader()->setSortIndicator(-1, Qt::AscendingOrder);
long totalSize = 0;
int rowCount = 0;
int methodCount = 0;
QList<ClassFileContext*>::iterator it = classList_.begin();
for(; it != classList_.end(); it++)
{
int col = 0;
const ClassFileContext* ctx = *it;
int markPos = ctx->originalName.indexOf("$");
if(ignoreInnerClass && markPos > 0)
continue;
if(onlyAnonymousClass)
{
QString right = ctx->originalName.mid(markPos + 1);
int anonymousId = right.toUInt();
if(anonymousId <= 0)
continue;
}
if(useAsPackageName)
{
int posTemp = ctx->originalName.indexOf(searchName);
if(posTemp < 0)
continue;
posTemp = ctx->originalName.indexOf(".", posTemp + searchName.length() + 1);
if(posTemp > 0)
continue;
}
else
{
if(searchName.isEmpty() == false)
{
if(useUncryptName)
{
if(ctx->originalName.contains(QRegExp(searchName, Qt::CaseInsensitive)) == false)
continue;
}
else
{
if(ctx->className.contains(QRegExp(searchName, Qt::CaseInsensitive)) == false)
continue;
}
}
}
if(searchText.isEmpty() == false)
{
if(ctx->javaFileFlag)
{
QString decompiledBufferStr = ctx->decompiledBuffer;
if(decompiledBufferStr.contains(QRegExp(searchText, Qt::CaseSensitive)) == false)
continue;
}
else
{
if(ctx->decompiledBuffer.contains(searchText.toStdString().c_str()) == false)
continue;
}
}
QString space = QString::number(ctx->fileSize);
ui.tableWidgetResult->insertRow(rowCount);
QTableWidgetItem *itemOriginal = new QTableWidgetItem(ctx->className);
itemOriginal->setFlags(itemOriginal->flags() & ~Qt::ItemIsEditable);
itemOriginal->setData(Qt::UserRole, qVariantFromValue((void *)ctx));
ui.tableWidgetResult->setItem(rowCount, col++, itemOriginal);
QTableWidgetItem *itemSize = new QTableWidgetItem();
itemSize->setData(Qt::DisplayRole, ctx->fileSize);
itemSize->setFlags(itemSize->flags() & ~Qt::ItemIsEditable);
ui.tableWidgetResult->setItem(rowCount, col++, itemSize);
QString uncryptName = ctx->originalName;
if(currentMapPath_.isEmpty())
uncryptName = "-";
QTableWidgetItem *itemUncrypt = new QTableWidgetItem(uncryptName);
itemUncrypt->setFlags(itemUncrypt->flags() & ~Qt::ItemIsEditable);
ui.tableWidgetResult->setItem(rowCount, col++, itemUncrypt);
QTableWidgetItem *itemMethodCount = new QTableWidgetItem();
itemMethodCount->setData(Qt::DisplayRole, ctx->methodCount);
itemMethodCount->setFlags(itemMethodCount->flags() & ~Qt::ItemIsEditable);
ui.tableWidgetResult->setItem(rowCount, col++, itemMethodCount);
QTableWidgetItem *itemRefCount = new QTableWidgetItem();
itemRefCount->setData(Qt::DisplayRole, ctx->referencedCount);
itemRefCount->setFlags(itemRefCount->flags() & ~Qt::ItemIsEditable);
ui.tableWidgetResult->setItem(rowCount, col++, itemRefCount);
rowCount++;
methodCount += ctx->methodCount;
totalSize += ctx->fileSize;
}
QString resultStr;
resultStr += "Total : ";
resultStr += QString::number(rowCount);
resultStr += " class found, ";
resultStr += numberDot(QString::number(totalSize));
resultStr += " bytes, ";
resultStr += QString::number(methodCount);
resultStr += " methods found";
ui.lineEdit_Result->setText(resultStr);
ui.tableWidgetResult->sortItems(0, Qt::AscendingOrder);
ui.tableWidgetResult->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
prevTotalResultStr_ = resultStr;
}
void game_list_frame::PopulateGameGrid(uint maxCols, const QSize& image_size)
{
uint r = 0;
uint c = 0;
std::string selected_item = CurrentSelectionIconPath();
delete m_xgrid;
bool showText = m_Icon_Size_Str != GUI::gl_icon_key_small && m_Icon_Size_Str != GUI::gl_icon_key_tiny;
if (m_Icon_Size_Str == GUI::gl_icon_key_medium)
{
m_xgrid = new game_list_grid(image_size, m_Margin_Factor, m_Text_Factor * 2, showText);
}
else
{
m_xgrid = new game_list_grid(image_size, m_Margin_Factor, m_Text_Factor, showText);
}
// Get number of things that'll be in grid and precompute grid size.
int entries = 0;
for (GUI_GameInfo game : m_game_data)
{
if (qstr(game.info.category) == category::disc_Game || qstr(game.info.category) == category::hdd_Game)
{
if (SearchMatchesApp(game.info.name, game.info.serial) == false)
{
continue;
}
++entries;
}
}
// Edge cases!
if (entries == 0)
{ // For whatever reason, 0%x is division by zero. Absolute nonsense by definition of modulus. But, I'll acquiesce.
return;
}
if (maxCols == 0)
{
maxCols = 1;
}
if (maxCols > entries)
{
maxCols = entries;
}
int needsExtraRow = (entries % maxCols) != 0;
int maxRows = needsExtraRow + entries / maxCols;
m_xgrid->setRowCount(maxRows);
m_xgrid->setColumnCount(maxCols);
for (uint i = 0; i < m_game_data.size(); i++)
{
if (SearchMatchesApp(m_game_data[i].info.name, m_game_data[i].info.serial) == false)
{
continue;
}
QString category = qstr(m_game_data[i].info.category);
if (category == category::hdd_Game || category == category::disc_Game)
{
m_xgrid->addItem(m_game_data[i].pxmap, qstr(m_game_data[i].info.name), i, r, c);
if (selected_item == m_game_data[i].info.icon_path) m_xgrid->setCurrentItem(m_xgrid->item(r, c));;
if (++c >= maxCols)
{
c = 0;
r++;
}
}
}
if (c != 0)
{ // if left over games exist -- if empty entries exist
for (int col = c; col < maxCols; ++col)
{
QTableWidgetItem* emptyItem = new QTableWidgetItem();
emptyItem->setFlags(Qt::NoItemFlags);
emptyItem->setData(Qt::UserRole, -1);
m_xgrid->setItem(r, col, emptyItem);
}
}
m_xgrid->resizeColumnsToContents();
m_xgrid->resizeRowsToContents();
}
ExtImageProps::ExtImageProps( QWidget* parent, ImageInfoRecord *info, PageItem *item, ScribusView *view )
: QDialog( parent )
{
setModal(true);
setWindowTitle( tr( "Extended Image Properties" ) );
setWindowIcon(QIcon(loadIcon ( "AppIcon.png" )));
ExtImagePropsLayout = new QVBoxLayout( this );
ExtImagePropsLayout->setMargin(6);
ExtImagePropsLayout->setSpacing(6);
viewWidget = view;
currentItem = item;
currentLayer = 0;
originalInfo = *info;
originalImageClip = item->imageClip.copy();
blendModes.clear();
blendModes.insert("norm", tr("Normal"));
blendModes.insert("dark", tr("Darken"));
blendModes.insert("lite", tr("Lighten"));
blendModes.insert("hue ", tr("Hue"));
blendModes.insert("sat ", tr("Saturation"));
blendModes.insert("colr", tr("Color"));
blendModes.insert("lum ", tr("Luminosity"));
blendModes.insert("mul ", tr("Multiply"));
blendModes.insert("scrn", tr("Screen"));
blendModes.insert("diss", tr("Dissolve"));
blendModes.insert("over", tr("Overlay"));
blendModes.insert("hLit", tr("Hard Light"));
blendModes.insert("sLit", tr("Soft Light"));
blendModes.insert("diff", tr("Difference"));
blendModes.insert("smud", tr("Exclusion"));
blendModes.insert("div ", tr("Color Dodge"));
blendModes.insert("idiv", tr("Color Burn"));
blendModesRev.clear();
blendModesRev.insert( tr("Normal"), "norm");
blendModesRev.insert( tr("Darken"), "dark");
blendModesRev.insert( tr("Lighten"), "lite");
blendModesRev.insert( tr("Hue"), "hue ");
blendModesRev.insert( tr("Saturation"), "sat ");
blendModesRev.insert( tr("Color"), "colr");
blendModesRev.insert( tr("Luminosity"), "lum ");
blendModesRev.insert( tr("Multiply"), "mul ");
blendModesRev.insert( tr("Screen"), "scrn");
blendModesRev.insert( tr("Dissolve"), "diss");
blendModesRev.insert( tr("Overlay"), "over");
blendModesRev.insert( tr("Hard Light"), "hLit");
blendModesRev.insert( tr("Soft Light"), "sLit");
blendModesRev.insert( tr("Difference"), "diff");
blendModesRev.insert( tr("Exclusion"), "smud");
blendModesRev.insert( tr("Color Dodge"), "div ");
blendModesRev.insert( tr("Color Burn"), "idiv");
propsTab = new QTabWidget( this );
QPalette palette;
palette.setColor(backgroundRole(), Qt::white);
if (info->layerInfo.count() != 0)
{
tab = new QWidget( propsTab );
tabLayout = new QVBoxLayout( tab );
tabLayout->setMargin(6);
tabLayout->setSpacing(6);
layout1 = new QHBoxLayout;
layout1->setMargin(0);
layout1->setSpacing(6);
textLabel1 = new QLabel( tab );
textLabel1->setText( tr( "Blend Mode:" ) );
layout1->addWidget( textLabel1 );
blendMode = new ScComboBox( tab );
blendMode->clear();
blendMode->addItem( tr("Normal"));
blendMode->addItem( tr("Darken"));
blendMode->addItem( tr("Lighten"));
blendMode->addItem( tr("Hue"));
blendMode->addItem( tr("Saturation"));
blendMode->addItem( tr("Color"));
blendMode->addItem( tr("Luminosity"));
blendMode->addItem( tr("Multiply"));
blendMode->addItem( tr("Screen"));
blendMode->addItem( tr("Dissolve"));
blendMode->addItem( tr("Overlay"));
blendMode->addItem( tr("Hard Light"));
blendMode->addItem( tr("Soft Light"));
blendMode->addItem( tr("Difference"));
blendMode->addItem( tr("Exclusion"));
blendMode->addItem( tr("Color Dodge"));
blendMode->addItem( tr("Color Burn"));
layout1->addWidget( blendMode );
textLabel2 = new QLabel( tab );
textLabel2->setText( tr( "Opacity:" ) );
layout1->addWidget( textLabel2 );
opacitySpinBox = new QSpinBox( tab );
opacitySpinBox->setMinimum(0);
opacitySpinBox->setMaximum(100);
opacitySpinBox->setSingleStep(10);
opacitySpinBox->setSuffix( tr(" %"));
layout1->addWidget( opacitySpinBox );
tabLayout->addLayout( layout1 );
layerTable = new QTableWidget(info->layerInfo.count(), 3, tab );
layerTable->setHorizontalHeaderItem(0, new QTableWidgetItem(QIcon(loadIcon("16/show-object.png")), ""));
layerTable->setHorizontalHeaderItem(1, new QTableWidgetItem(""));
layerTable->setHorizontalHeaderItem(2, new QTableWidgetItem( tr("Name")));
QHeaderView* headerH = layerTable->horizontalHeader();
headerH->setStretchLastSection(true);
headerH->setMovable(false);
headerH->setClickable(false);
if (info->layerInfo.count() == 1)
{
layerTable->setColumnWidth(1, 40);
layerTable->setColumnWidth(0, 24);
}
layerTable->setSortingEnabled(false);
layerTable->setSelectionBehavior( QAbstractItemView::SelectRows );
QHeaderView *Header = layerTable->verticalHeader();
Header->setMovable(false);
Header->setResizeMode(QHeaderView::Fixed);
Header->hide();
FlagsSicht.clear();
int col2Width = 0;
int col1Width = 0;
if (info->layerInfo.count() != 0)
{
if ((info->isRequest) && (info->RequestProps.contains(0)))
{
opacitySpinBox->setValue(qRound(info->RequestProps[0].opacity / 255.0 * 100));
setCurrentComboItem(blendMode, blendModes[info->RequestProps[0].blend]);
}
else
{
opacitySpinBox->setValue(qRound(info->layerInfo[0].opacity / 255.0 * 100));
setCurrentComboItem(blendMode, blendModes[info->layerInfo[0].blend]);
}
opacitySpinBox->setEnabled(true);
blendMode->setEnabled(true);
QString tmp;
QList<PSDLayer>::iterator it2;
uint counter = 0;
for (it2 = info->layerInfo.begin(); it2 != info->layerInfo.end(); ++it2)
{
QCheckBox *cp = new QCheckBox((*it2).layerName, this);
cp->setPalette(palette);
QPixmap pm;
pm=QPixmap::fromImage((*it2).thumb);
col1Width = qMax(col1Width, pm.width());
cp->setIcon(pm);
FlagsSicht.append(cp);
connect(cp, SIGNAL(clicked()), this, SLOT(changedLayer()));
layerTable->setCellWidget(info->layerInfo.count()-counter-1, 0, cp);
if ((info->isRequest) && (info->RequestProps.contains(counter)))
cp->setChecked(info->RequestProps[counter].visible);
else
cp->setChecked(!((*it2).flags & 2));
if (!(*it2).thumb_mask.isNull())
{
QCheckBox *cp2 = new QCheckBox((*it2).layerName, this);
cp2->setPalette(palette);
QPixmap pm2;
pm2=QPixmap::fromImage((*it2).thumb_mask);
col2Width = qMax(col2Width, pm2.width());
cp2->setIcon(pm2);
connect(cp2, SIGNAL(clicked()), this, SLOT(changedLayer()));
layerTable->setCellWidget(info->layerInfo.count()-counter-1, 1, cp2);
if ((info->isRequest) && (info->RequestProps.contains(counter)))
cp2->setChecked(info->RequestProps[counter].useMask);
else
cp2->setChecked(true);
FlagsMask.append(cp2);
}
else
FlagsMask.append(0);
QTableWidgetItem *tW = new QTableWidgetItem((*it2).layerName);
tW->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
layerTable->setItem(info->layerInfo.count()-counter-1, 2, tW);
layerTable->setRowHeight(info->layerInfo.count()-counter-1, 40);
counter++;
}
}
tabLayout->addWidget( layerTable );
layerTable->setColumnWidth(1, 24 + col2Width);
layerTable->setColumnWidth(0, 24 + col1Width);
blendMode->setCurrentIndex(0);
// headerH->setResizeMode(QHeaderView::Fixed);
propsTab->addTab( tab, tr( "Layers" ) );
}
tab_2 = new QWidget( propsTab );
tabLayout_2 = new QVBoxLayout( tab_2 );
tabLayout_2->setMargin(6);
tabLayout_2->setSpacing(6);
pathList = new QListWidget( tab_2 );
pathList->clear();
pathList->setIconSize(QSize(40, 40));
QMap<QString, FPointArray>::Iterator it;
if (info->PDSpathData.count() != 0)
{
for (it = info->PDSpathData.begin(); it != info->PDSpathData.end(); ++it)
{
QImage pixm(40, 40, QImage::Format_ARGB32);
ScPainter *p = new ScPainter(&pixm, 40, 40);
p->clear();
p->translate(3.0, 3.0);
if (it.key() == info->clipPath)
{
pixm.fill(Qt::green);
p->clear(Qt::green);
}
else
pixm.fill(Qt::white);
FPointArray Path;
Path.resize(0);
Path = info->PDSpathData[it.key()].copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
QMatrix mm;
mm.scale(34.0 / qMax(max.x(), max.y()), 34.0 / qMax(max.x(), max.y()));
Path.map(mm);
p->setupPolygon(&Path);
p->setPen(Qt::black);
p->setBrush(Qt::white);
p->setFillMode(0);
p->setLineWidth(1.0);
p->strokePath();
p->end();
delete p;
QPixmap pm;
pm=QPixmap::fromImage(pixm);
new QListWidgetItem(QIcon(pm), it.key(), pathList);
if (it.key() == info->usedPath)
{
pathList->setCurrentRow(pathList->count()-1);
pathList->currentItem()->setSelected(true);
}
}
}
tabLayout_2->addWidget( pathList );
resetPath = new QPushButton( tr("Don't use any Path"), tab_2);
tabLayout_2->addWidget( resetPath );
propsTab->addTab( tab_2, tr( "Paths" ) );
ExtImagePropsLayout->addWidget( propsTab );
layoutBottom = new QHBoxLayout;
layoutBottom->setMargin(0);
layoutBottom->setSpacing(6);
livePreview = new QCheckBox( this );
livePreview->setText( tr( "Live Preview" ) );
livePreview->setChecked(true);
doPreview = true;
layoutBottom->addWidget( livePreview );
QSpacerItem* spacer = new QSpacerItem( 2, 2, QSizePolicy::Expanding, QSizePolicy::Minimum );
layoutBottom->addItem( spacer );
okButton = new QPushButton( CommonStrings::tr_OK, this );
layoutBottom->addWidget( okButton );
cancelButton = new QPushButton( CommonStrings::tr_Cancel, this );
cancelButton->setDefault( true );
layoutBottom->addWidget( cancelButton );
ExtImagePropsLayout->addLayout( layoutBottom );
resize(330, 320);
connect(pathList, SIGNAL( itemClicked(QListWidgetItem*) ), this, SLOT( selPath(QListWidgetItem*) ) );
connect(resetPath, SIGNAL(clicked()), this, SLOT(noPath()));
connect(livePreview, SIGNAL(clicked()), this, SLOT(changePreview()));
connect(okButton, SIGNAL(clicked()), this, SLOT(leaveOK()));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(leaveCancel()));
if (info->layerInfo.count() != 0)
{
connect(layerTable, SIGNAL(cellClicked(int, int)), this, SLOT(selLayer(int)));
connect(opacitySpinBox, SIGNAL(valueChanged(int)), this, SLOT(changedLayer()));
connect(blendMode, SIGNAL(activated(int)), this, SLOT(changedLayer()));
}
void PMeshViewer::addMesh(const QStringList &fileNames)
{
int startIndex = meshList.size();
for (int i = 0; i < fileNames.size(); ++i)
{
QString suffix = QFileInfo(fileNames[i]).suffix();
vtkPolyDataAlgorithm *reader = NULL;
if (suffix == "obj")
{
vtkOBJReader *rd = vtkOBJReader::New();
rd->SetFileName(fileNames[i].toAscii().data());
reader = rd;
}
else if (suffix == "ply")
{
vtkPLYReader *rd = vtkPLYReader::New();
rd->SetFileName(fileNames[i].toAscii().data());
reader = rd;
}
else if (suffix == "stl")
{
vtkSTLReader *rd = vtkSTLReader::New();
rd->SetFileName(fileNames[i].toAscii().data());
reader = rd;
}
else // This should not happen, but just in case.
{
uninstallPipeline();
cout << "Error in loadMesh: file type " <<
suffix.toAscii().data() << " is unsupported.\n" << flush;
return;
}
// Append to mesh list
PMeshPart part;
part.name = QFileInfo(fileNames[i]).baseName();
part.source = fileNames[i];
part.data = reader->GetOutput();
reader->Update();
part.normals = vtkPolyDataNormals::New();
part.normals->SetInput(part.data);
part.mapper = vtkPolyDataMapper::New();
part.mapper->SetInput(part.normals->GetOutput());
part.mapper->Update();
part.actor = vtkActor::New();
part.actor->SetMapper(part.mapper);
meshList.append(part);
reader->Delete();
// Append to mesh table
int j = meshTable->rowCount();
meshTable->insertRow(j);
meshTable->setRowHeight(j, RowHeight);
QTableWidgetItem *item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Checked);
meshTable->setItem(j, 0, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled);
item->setBackground(QBrush(QColor(255, 255, 255)));
meshTable->setItem(j, 1, item);
item = new QTableWidgetItem(part.name);
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable |
Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
meshTable->setItem(j, 2, item);
item = new QTableWidgetItem(part.source);
item->setFlags(Qt::ItemIsEnabled);
item->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
meshTable->setItem(j, 4, item);
}
int width = meshTable->width();
int height = meshTable->height();
int bestHeight = qMin(MaxHeight,
(meshTable->rowCount() + 2) * RowHeight);
if (height < bestHeight)
meshTable->resize(width, bestHeight);
installPipeline(startIndex);
setWindowTitle(QString("%1 - %2").arg(appName).arg(projectName));
}
void
BestIntervalDialog::findClicked()
{
const RideFile *ride = context->ride ? context->ride->ride() : NULL;
if (!ride) {
QMessageBox::critical(this, tr("Select Activity"), tr("No activity selected!"));
return;
}
int maxIntervals = (int) countSpinBox->value();
double windowSizeSecs = (hrsSpinBox->value() * 3600.0
+ minsSpinBox->value() * 60.0
+ secsSpinBox->value());
if (windowSizeSecs == 0.0) {
QMessageBox::critical(this, tr("Bad Interval Length"),
tr("Interval length must be greater than zero!"));
return;
}
QList<BestInterval> results;
findBests(ride, Specification(), windowSizeSecs, maxIntervals, results);
// clear the table
clearResultsTable(resultsTable);
// populate the table
resultsTable->setRowCount(results.size());
int row = 0;
foreach (const BestInterval &interval, results) {
double secs = interval.start;
double mins = floor(secs / 60);
secs = secs - mins * 60.0;
double hrs = floor(mins / 60);
mins = mins - hrs * 60.0;
// check box
QCheckBox *c = new QCheckBox;
c->setCheckState(Qt::Checked);
resultsTable->setCellWidget(row, 0, c);
// start time
QString start = "%1:%2:%3";
start = start.arg(hrs, 0, 'f', 0);
start = start.arg(mins, 2, 'f', 0, QLatin1Char('0'));
start = start.arg(round(secs), 2, 'f', 0, QLatin1Char('0'));
QTableWidgetItem *t = new QTableWidgetItem;
t->setText(start);
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
resultsTable->setItem(row, 1, t);
// name
int x = windowSizeSecs; // int is more help here
QString name = "Best %2%3 #%1 (%4w)";
name = name.arg(row + 1);
// best n mins
if (x < 60) {
// whole seconds
name = name.arg(x);
name = name.arg("sec");
} else if (x >= 60 && !(x%60)) {
// whole minutes
name = name.arg(x/60);
name = name.arg("min");
} else {
double secs = x;
double mins = ((int) secs) / 60;
secs = secs - mins * 60.0;
double hrs = ((int) mins) / 60;
mins = mins - hrs * 60.0;
QString tm = "%1:%2:%3";
tm = tm.arg(hrs, 0, 'f', 0);
tm = tm.arg(mins, 2, 'f', 0, QLatin1Char('0'));
tm = tm.arg(secs, 2, 'f', 0, QLatin1Char('0'));
// mins and secs
name = name.arg(tm);
name = name.arg("");
}
name = name.arg(round(interval.avg));
QTableWidgetItem *n = new QTableWidgetItem;
n->setText(name);
n->setFlags(n->flags() | (Qt::ItemIsEditable));
resultsTable->setItem(row, 2, n);
// hidden columns - start, stop
QString strt = QString("%1").arg(interval.start); // can't use secs as it gets modified
QTableWidgetItem *st = new QTableWidgetItem;
st->setText(strt);
resultsTable->setItem(row, 3, st);
QString stp = QString("%1").arg(interval.start + x);
QTableWidgetItem *sp = new QTableWidgetItem;
sp->setText(stp);
resultsTable->setItem(row, 4, sp);
row++;
}
RegDisplayPanel::RegDisplayPanel(QWidget *parent, IoBackend *io_backend, const SocRegRef& reg_ref)
:QGroupBox(parent), m_io_backend(io_backend), m_reg(reg_ref), m_reg_font(font())
{
bool read_only = m_io_backend->IsReadOnly();
QVBoxLayout *right_layout = new QVBoxLayout;
const soc_dev_addr_t& dev_addr = m_reg.GetDevAddr();
const soc_reg_t& reg = m_reg.GetReg();
const soc_reg_addr_t& reg_addr = m_reg.GetRegAddr();
m_reg_font.setWeight(100);
m_reg_font.setKerning(false);
QString reg_name;
reg_name.sprintf("HW_%s_%s", dev_addr.name.c_str(), reg_addr.name.c_str());
QStringList names;
QVector< soc_addr_t > addresses;
names.append(reg_name);
addresses.append(reg_addr.addr);
if(reg.flags & REG_HAS_SCT)
{
names.append(reg_name + "_SET");
names.append(reg_name + "_CLR");
names.append(reg_name + "_TOG");
addresses.append(reg_addr.addr + 4);
addresses.append(reg_addr.addr + 8);
addresses.append(reg_addr.addr + 12);
}
QString str;
str += "<table align=left>";
for(int i = 0; i < names.size(); i++)
str += "<tr><td><b>" + names[i] + "</b></td></tr>";
str += "</table>";
QLabel *label_names = new QLabel;
label_names->setTextFormat(Qt::RichText);
label_names->setText(str);
QString str_addr;
str_addr += "<table align=left>";
for(int i = 0; i < names.size(); i++)
str_addr += "<tr><td><b>" + QString().sprintf("0x%03x", addresses[i]) + "</b></td></tr>";
str_addr += "</table>";
QLabel *label_addr = new QLabel;
label_addr->setTextFormat(Qt::RichText);
label_addr->setText(str_addr);
QHBoxLayout *top_layout = new QHBoxLayout;
top_layout->addStretch();
top_layout->addWidget(label_names);
top_layout->addWidget(label_addr);
top_layout->addStretch();
m_raw_val_name = new QLabel;
m_raw_val_name->setText("Raw value:");
m_raw_val_edit = new RegLineEdit;
m_raw_val_edit->SetReadOnly(read_only);
m_raw_val_edit->GetLineEdit()->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
m_raw_val_edit->GetLineEdit()->setValidator(new SocFieldValidator(m_raw_val_edit));
m_raw_val_edit->EnableSCT(!!(reg.flags & REG_HAS_SCT));
m_raw_val_edit->GetLineEdit()->setFont(m_reg_font);
QHBoxLayout *raw_val_layout = new QHBoxLayout;
raw_val_layout->addStretch();
raw_val_layout->addWidget(m_raw_val_name);
raw_val_layout->addWidget(m_raw_val_edit);
raw_val_layout->addStretch();
m_value_table = new GrowingTableWidget;
m_value_table->setRowCount(reg.field.size());
m_value_table->setColumnCount(5);
for(size_t row = 0; row < reg.field.size(); row++)
{
const soc_reg_field_t& field = reg.field[row];
QString bits_str;
if(field.first_bit == field.last_bit)
bits_str.sprintf("%d", field.first_bit);
else
bits_str.sprintf("%d:%d", field.last_bit, field.first_bit);
QTableWidgetItem *item = new QTableWidgetItem(bits_str);
item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_value_table->setItem(row, FieldBitsColumn, item);
item = new QTableWidgetItem(QString(field.name.c_str()));
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_value_table->setItem(row, FieldNameColumn, item);
item = new QTableWidgetItem();
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
item->setData(Qt::DisplayRole, QVariant::fromValue(SocFieldCachedValue()));
item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
m_value_table->setItem(row, FieldValueColumn, item);
item = new QTableWidgetItem("");
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
m_value_table->setItem(row, FieldMeaningColumn, item);
item = new QTableWidgetItem(QString(field.desc.c_str()));
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_value_table->setItem(row, FieldDescColumn, item);
}
m_value_table->setHorizontalHeaderItem(FieldBitsColumn, new QTableWidgetItem("Bits"));
m_value_table->setHorizontalHeaderItem(FieldNameColumn, new QTableWidgetItem("Name"));
m_value_table->setHorizontalHeaderItem(FieldValueColumn, new QTableWidgetItem("Value"));
m_value_table->setHorizontalHeaderItem(FieldMeaningColumn, new QTableWidgetItem("Meaning"));
m_value_table->setHorizontalHeaderItem(FieldDescColumn, new QTableWidgetItem("Description"));
m_value_table->verticalHeader()->setVisible(false);
m_value_table->resizeColumnsToContents();
m_value_table->horizontalHeader()->setStretchLastSection(true);
m_value_table->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
SocFieldCachedItemDelegate *m_table_delegate = new SocFieldCachedItemDelegate(this);
m_table_edit_factory = new QItemEditorFactory();
SocFieldCachedEditorCreator *m_table_edit_creator = new SocFieldCachedEditorCreator();
// FIXME see QTBUG-30392
m_table_edit_factory->registerEditor((QVariant::Type)qMetaTypeId< SocFieldCachedValue >(),
m_table_edit_creator);
m_table_delegate->setItemEditorFactory(m_table_edit_factory);
m_value_table->setItemDelegate(m_table_delegate);
m_sexy_display = new RegSexyDisplay(reg_ref, this);
m_sexy_display->setFont(m_reg_font);
m_desc = new QLabel(this);
m_desc->setTextFormat(Qt::RichText);
m_desc->setText(QString::fromStdString(m_reg.GetReg().desc));
right_layout->addWidget(m_desc);
right_layout->addLayout(top_layout);
if(raw_val_layout)
right_layout->addLayout(raw_val_layout);
right_layout->addWidget(m_sexy_display);
right_layout->addWidget(m_value_table);
setTitle("Register Description");
m_viewport = new QWidget;
m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_viewport->setLayout(right_layout);
m_scroll = new QScrollArea;
m_scroll->setWidget(m_viewport);
m_scroll->setWidgetResizable(true);
m_scroll->setFrameShape(QFrame::NoFrame);
QHBoxLayout *layout = new QHBoxLayout;
layout->addWidget(m_scroll, 1);
setLayout(layout);
AllowWrite(false);
m_ignore_cell_change = false;
// load data
Reload();
connect(m_raw_val_edit->GetLineEdit(), SIGNAL(returnPressed()), this, SLOT(OnRawRegValueReturnPressed()));
connect(m_value_table, SIGNAL(cellChanged(int, int)), this, SLOT(OnRegFieldValueChanged(int, int)));
}
//---------------------------------------------------------------------------
void GUI_Main_xxxx__Common::Fill ()
{
//Preparing
Updating=true;
//Showing
ZtringListList List;
List.Separator_Set(0, EOL);
List.Separator_Set(1, _T(","));
List.Write(Fill_Content());
//Elminating unuseful info from filenames
FileName_Before.clear();
if (List.size()==2 && !List[1].empty())
{
size_t ToDelete=List[1][0].rfind(PathSeparator);
if (ToDelete!=string::npos)
{
FileName_Before=List[1][0].substr(0, ToDelete+1);
List[1][0].erase(0, ToDelete+1);
}
}
else if (List.size()>1 && !List[1].empty())
{
size_t ToDelete;
size_t File_Pos;
for (ToDelete=0; ToDelete<List[1][0].size(); ToDelete++)
{
char Char_File1=List[1][0][ToDelete];
for (File_Pos=2; File_Pos<List.size(); File_Pos++)
if (ToDelete>=List[File_Pos][0].size() || List[File_Pos][0][ToDelete]!=Char_File1)
break;
if (File_Pos!=List.size())
break;
}
ToDelete=List[1][0].rfind(PathSeparator, ToDelete);
if (ToDelete!=string::npos)
{
FileName_Before=List[1][0].substr(0, ToDelete+1);
for (File_Pos=1; File_Pos<List.size(); File_Pos++)
List[File_Pos][0].erase(0, ToDelete+1);
}
}
if (List.empty() || List[0].empty())
{
setRowCount(0);
setColumnCount(0);
//Preparing
Updating=false;
return;
}
//Forcing reset, else this seems to be some Qt bug in the table display
setRowCount(0);
setColumnCount(0);
//Filling - HorizontalHeader
setRowCount((int)List.size()-1);
size_t ColumnMissing_Count=0;
for (size_t Option=0; Option<Main->Preferences->Group_Options_Count_Get(Fill_Group()); Option++)
if (!Main->Menu_Fields_CheckBoxes[Fill_Group()*options::MaxCount+Option]->isChecked())
ColumnMissing_Count++;
setColumnCount((int)(List[0].size()-ColumnMissing_Count));
ColumnMissing_Count=0;
for (size_t Data_Pos=0; Data_Pos<List[0].size(); Data_Pos++)
if (Data_Pos==0 || Main->Menu_Fields_CheckBoxes[Fill_Group()*options::MaxCount+Data_Pos-1]->isChecked())
{
QTableWidgetItem* Item=new QTableWidgetItem(QString().fromUtf8(List[0][Data_Pos].To_Local().c_str()));
Item->setToolTip(Columns_ToolTip(List[0][Data_Pos]));
setHorizontalHeaderItem((int)(Data_Pos-ColumnMissing_Count), Item);
}
else
ColumnMissing_Count++;
//Filling - VerticalHeader and content
for (size_t File_Pos=1; File_Pos<List.size(); File_Pos++)
{
if (List[File_Pos].empty())
List[File_Pos].resize(1); //Empty filename, we need to manualy add it.
ColumnMissing_Count=0;
for (size_t Data_Pos=0; Data_Pos<List[0].size(); Data_Pos++)
if (Data_Pos==0 || Main->Menu_Fields_CheckBoxes[Fill_Group()*options::MaxCount+Data_Pos-1]->isChecked())
{
QTableWidgetItem* Item;
if (Data_Pos<List[File_Pos].size())
{
ZenLib::Ztring Value=List[File_Pos][Data_Pos];
Value.FindAndReplace(EOL, "\n", 0, Ztring_Recursive);
Item=new QTableWidgetItem(QString().fromUtf8(Value.To_Local().c_str()));
Item->setToolTip(Columns_ToolTip(List[0][Data_Pos]));
}
else
Item=new QTableWidgetItem(QString());
if (!C->IsValid_Get(FileName_Before+List[File_Pos][0])
|| (Data_Pos<List[File_Pos].size() && !Fill_Enabled(FileName_Before+List[File_Pos][0], List[0][Data_Pos], List[File_Pos][Data_Pos])))
Item->setFlags(Item->flags()&((Qt::ItemFlags)-1-Qt::ItemIsEnabled));
setItem((int)File_Pos-1, (int)(Data_Pos-ColumnMissing_Count), Item);
}
else
ColumnMissing_Count++;
}
//Configuring
Colors_Update();
resizeColumnsToContents();
setSortingEnabled(true);
//Preparing
Updating=false;
}
void rulesDialog::readTest( int index, QgsMapLayerRegistry* layerRegistry )
{
QString testName;
QString layer1Id;
QString layer2Id;
QString tolerance;
QgsProject* project = QgsProject::instance();
QString postfix = QString( "%1" ).arg( index );
testName = project->readEntry( "Topol", "/testname_" + postfix, "" );
tolerance = project->readEntry( "Topol", "/tolerance_" + postfix, "" );
layer1Id = project->readEntry( "Topol", "/layer1_" + postfix, "" );
layer2Id = project->readEntry( "Topol", "/layer2_" + postfix, "" );
QgsVectorLayer* l1;
if ( !( QgsVectorLayer* )layerRegistry->mapLayers().contains( layer1Id ) )
return;
l1 = ( QgsVectorLayer* )layerRegistry->mapLayers()[layer1Id];
if ( !l1 )
return;
QString layer1Name = l1->name();
QString layer2Name;
QgsVectorLayer* l2;
if ( mTestConfMap[testName].useSecondLayer )
{
if ( !( QgsVectorLayer* )layerRegistry->mapLayers().contains( layer2Id ) )
return;
else
{
l2 = ( QgsVectorLayer* )layerRegistry->mapLayers()[layer2Id];
layer2Name = l2->name();
}
}
else
layer2Name = "No layer";
int row = index;
mRulesTable->insertRow( row );
QTableWidgetItem* newItem;
newItem = new QTableWidgetItem( testName );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 0, newItem );
newItem = new QTableWidgetItem( layer1Name );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 1, newItem );
newItem = new QTableWidgetItem( layer2Name );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 2, newItem );
if ( mTestConfMap[testName].useTolerance )
newItem = new QTableWidgetItem( tolerance );
else
newItem = new QTableWidgetItem( tr( "No tolerance" ) );
newItem->setFlags( newItem->flags() & ~Qt::ItemIsEditable );
mRulesTable->setItem( row, 3, newItem );
// add layer ids to hidden columns
newItem = new QTableWidgetItem( layer1Id );
mRulesTable->setItem( row, 4, newItem );
newItem = new QTableWidgetItem( layer2Id );
mRulesTable->setItem( row, 5, newItem );
}
void ParameterTable::updateTable(const CReactionInterface & ri, const CModel & model)
{
//first get the units strings
CFindDimensions units(ri.getFunction(), model.getQuantityUnitEnum() == CModel::dimensionlessQuantity,
model.getVolumeUnitEnum() == CModel::dimensionlessVolume,
model.getTimeUnitEnum() == CModel::dimensionlessTime,
model.getAreaUnitEnum() == CModel::dimensionlessArea,
model.getLengthUnitEnum() == CModel::dimensionlessLength
);
units.setUseHeuristics(true);
units.setMolecularitiesForMassAction(ri.getChemEqInterface().getMolecularity(CFunctionParameter::SUBSTRATE),
ri.getChemEqInterface().getMolecularity(CFunctionParameter::PRODUCT));
units.findDimensions(ri.isMulticompartment());
size_t i, imax = ri.size();
size_t j, jmax;
size_t rowCounter = 0;
QStringList qsl;
QColor subsColor(255, 210, 210);
QColor prodColor(210, 255, 210);
QColor modiColor(250, 250, 190);
QColor paraColor(210, 210, 255);
QColor volColor(210, 210, 255);
QColor timeColor(210, 210, 210);
CFunctionParameter::Role usage;
QString qUsage;
QColor color;
const std::vector<std::string> * metabNames;
mIndex2Line.resize(imax);
mLine2Index.clear();
this->setRowCount(0);
this->setRowCount((int)(imax * 2));
for (i = 0; i < imax; ++i)
{
rowCounter++;
mIndex2Line[i] = rowCounter;
// set the stuff that is different for the specific usages
usage = ri.getUsage(i);
qUsage = FROM_UTF8(CFunctionParameter::RoleNameDisplay[usage]);
switch (usage)
{
case CFunctionParameter::SUBSTRATE:
color = subsColor;
break;
case CFunctionParameter::PRODUCT:
color = prodColor;
break;
case CFunctionParameter::MODIFIER:
color = modiColor;
break;
case CFunctionParameter::PARAMETER:
color = paraColor;
break;
case CFunctionParameter::VOLUME:
color = volColor;
break;
case CFunctionParameter::TIME:
color = timeColor;
break;
case CFunctionParameter::VARIABLE:
color = QColor(255, 20, 20);
break;
default:
qUsage = "unknown";
color = QColor(255, 20, 20);
break;
}
// add first column
QTableWidgetItem * pItem = new ColorTableItem(color, qUsage);
if (usage == CFunctionParameter::SUBSTRATE) pItem->setIcon(CQIconResource::icon(CQIconResource::reactionSubstrate));
if (usage == CFunctionParameter::PRODUCT) pItem->setIcon(CQIconResource::icon(CQIconResource::reactionProduct));
if (usage == CFunctionParameter::MODIFIER) pItem->setIcon(CQIconResource::icon(CQIconResource::reactionModifier));
setItem((int) rowCounter, 0, pItem);
// add second column
pItem = new ColorTableItem(color, FROM_UTF8(ri.getParameterName(i)));
if ((usage != CFunctionParameter::PARAMETER)
&& (usage != CFunctionParameter::VOLUME)
&& (usage != CFunctionParameter::TIME))
{
if (ri.isLocked(i))
pItem->setIcon(CQIconResource::icon(CQIconResource::locked));
else
pItem->setIcon(CQIconResource::icon(CQIconResource::unlocked));
}
setItem((int) rowCounter, 1, pItem);
// add third column
pItem = new ColorTableItem(color, "");
if (usage == CFunctionParameter::PARAMETER)
{
pItem->setFlags(pItem->flags() | Qt::ItemIsUserCheckable);
pItem->setCheckState(ri.isLocalValue(i) ? Qt::Unchecked : Qt::Checked);
}
setItem((int) rowCounter, 2, pItem);
// add units column
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
assert(pDataModel != NULL);
pItem = new ColorTableItem(color, FROM_UTF8(" " + units.getDimensions()[i].getDisplayString(pDataModel)));
setItem((int) rowCounter, 4, pItem);
// add a line for a metabolite Parameter
if ((usage == CFunctionParameter::SUBSTRATE)
|| (usage == CFunctionParameter::PRODUCT)
|| (usage == CFunctionParameter::MODIFIER))
{
// get the list of possible metabs (for the combo box)
if (usage == CFunctionParameter::MODIFIER) //get all metabs; modifiers are never locked
vectorOfStrings2QStringList(getListOfAllMetabNames(model, ri), qsl);
else //only get the modifiers from the ChemEq
{
if (!ri.isLocked(i))
vectorOfStrings2QStringList(ri.getListOfMetabs(usage), qsl);
}
metabNames = &(ri.getMappings(i));
if (!ri.isVector(i))
{
if (ri.isLocked(i))
{
pItem = new ColorTableItem(color, FROM_UTF8((*metabNames)[0]));
setItem((int) rowCounter, 3, pItem);
}
else
{
QComboBox * pComboBox = new QComboBox();
pComboBox->addItems(qsl);
pComboBox->setBackgroundColor(color);
pComboBox->setCurrentText(FROM_UTF8(unQuote((*metabNames)[0])));
setCellWidget((int) rowCounter, 3, pComboBox);
}
}
else
{
if (ri.isLocked(i))
{
pItem = new ColorTableItem(color, "");
setItem((int) rowCounter, 3, pItem);
}
else // this should not happen
{
QComboBox * pComboBox = new QComboBox();
pComboBox->addItems(qsl);
pComboBox->setBackgroundColor(color);
pComboBox->setCurrentText("add species");
setCellWidget((int) rowCounter, 3, pComboBox);
}
// add lines for vector parameters
jmax = metabNames->size();
setRowCount(rowCount() + (int) jmax);
for (j = 0; j < jmax; ++j)
{
++rowCounter;
pItem = new ColorTableItem(color, FROM_UTF8((*metabNames)[j]));
setItem((int) rowCounter, 3, pItem);
}
}
}
// add a line for a kinetic parameter
else if (usage == CFunctionParameter::PARAMETER)
{
if (ri.isLocalValue(i))
{
pItem = new ColorTableItem(color, QString::number(ri.getLocalValue(i)));
setItem((int) rowCounter, 3, pItem);
}
else //global parameter
{
QComboBox * pComboBox = new QComboBox();
pComboBox->addItems(getListOfAllGlobalParameterNames(model));
pComboBox->setBackgroundColor(color);
pComboBox->setCurrentText(FROM_UTF8(ri.getMapping(i)));
setCellWidget((int) rowCounter, 3, pComboBox);
}
}
// add a line for a kinetic parameter
else if (usage == CFunctionParameter::VOLUME)
{
QComboBox * pComboBox = new QComboBox();
pComboBox->addItems(getListOfAllCompartmentNames(model));
pComboBox->setBackgroundColor(color);
pComboBox->setCurrentText(FROM_UTF8(ri.getMapping(i)));
setCellWidget((int) rowCounter, 3, pComboBox);
}
// add a line for time
else if (usage == CFunctionParameter::TIME)
{
pItem = new ColorTableItem(color, "");
setItem((int) rowCounter, 3, pItem);
}
// add a line for an unknown role
else
{
pItem = new ColorTableItem(color, QString::number(ri.getLocalValue(i)));
setItem((int) rowCounter, 3, pItem);
}
resizeRowToContents((int) rowCounter);
//mLine2Index
++rowCounter;
}
this->resizeColumnsToContents();
}
void RenderWindow::sAdd()
{
bool ok = false;
bool active = false;
QString name;
QString varType;
QVariant var;
NewVariant newVar(this);
while(!ok)
{
if(newVar.exec() != QDialog::Accepted)
return;
name = newVar._name->text();
varType = newVar._type->currentText();
ok = !_params.contains(name);
if(!ok)
QMessageBox::warning(this, tr("Name already exists"), tr("The name for the parameter you specified already exists in the list."));
}
BoolEdit * be = 0;
IntEdit * ie = 0;
DoubleEdit * de = 0;
StringEdit * se = 0;
ListEdit * le = 0;
if(varType == NewVariant::tr("String")) {
se = new StringEdit(this);
se->_name->setText(name);
ok = (se->exec() == QDialog::Accepted);
var = QVariant(se->_value->text());
active = se->_active->isChecked();
delete se;
se = 0;
} else if(varType == NewVariant::tr("Int")) {
ie = new IntEdit(this);
ie->_name->setText(name);
ok = (ie->exec() == QDialog::Accepted);
var = QVariant(ie->_value->text().toInt());
active = ie->_active->isChecked();
delete ie;
ie = 0;
} else if(varType == NewVariant::tr("Double")) {
de = new DoubleEdit(this);
de->_name->setText(name);
ok = (de->exec() == QDialog::Accepted);
var = QVariant(de->_value->text().toDouble());
active = de->_active->isChecked();
delete de;
de = 0;
} else if(varType == NewVariant::tr("Bool")) {
be = new BoolEdit(this);
be->_name->setText(name);
ok = (be->exec() == QDialog::Accepted);
var = QVariant((bool)be->value());
active = be->_active->isChecked();
delete be;
be = 0;
} else if(varType == NewVariant::tr("List")) {
le = new ListEdit(this);
le->_name->setText(name);
ok = (le->exec() == QDialog::Accepted);
var = QVariant(le->list());
active = le->_active->isChecked();
delete le;
le = 0;
} else {
QMessageBox::warning(this, tr("Unknown Type"), QString(tr("I do not understand the type %1.")).arg(varType));
return;
}
if(!ok)
return;
_params[name] = var;
int r = _table->rowCount();
_table->setRowCount(r+1);
QTableWidgetItem * ctItem = new QTableWidgetItem();
ctItem->setFlags(Qt::ItemIsUserCheckable);
ctItem->setCheckState((active ? Qt::Checked : Qt::Unchecked));
_table->setItem(r, 0, ctItem);
_table->setItem(r, 1, new QTableWidgetItem(name));
_table->setItem(r, 2, new QTableWidgetItem(var.typeName()));
_table->setItem(r, 3, new QTableWidgetItem(var.toString()));
sSelectionChanged();
}
void FahrtagWindow::loadData()
{
if (nehme) {
nehme = false;
// Allgemeine Daten von AActivity
ui->dateDate->setDate(fahrtag->getDatum());
ui->textAnlass->clear();
ui->textAnlass->insertPlainText(fahrtag->getAnlass());
ui->timeEnde->setTime(fahrtag->getZeitEnde());
ui->checkBoxBenoetigt->setChecked(fahrtag->getPersonalBenoetigt());
// Daten von Manager_Reservierungen
ui->comboWagenreihung->setCurrentText(fahrtag->getWagenreihung());
QSetIterator<Reservierung*> iter = fahrtag->getReservierungen();
while(iter.hasNext()) {
Reservierung *r = iter.next();
QListWidgetItem *item = new QListWidgetItem(r->getName());
resToItem->insert(r, item);
itemToRes->insert(item, r);
ui->listRes->insertItem(0, item);
}
ui->listRes->sortItems();
ui->checkBoxAll->setEnabled(false);
ui->buttonVerteile->setEnabled(Fahrtag::Nikolauszug == fahrtag->getArt());
ui->checkBoxAll->setChecked(fahrtag->getCheckAll());
ui->checkBoxAll->setEnabled(fahrtag->getArt() == Fahrtag::Nikolauszug);
ui->buttonVerteile->setEnabled(fahrtag->getArt() == Fahrtag::Nikolauszug);
// Daten von Fahrtag
ui->comboArt->setCurrentIndex((int)fahrtag->getArt());
ui->comboTimeTfH->setCurrentText(fahrtag->getZeitTf().toString("HH"));
ui->comboTimeTfM->setCurrentText(fahrtag->getZeitTf().toString("mm"));
ui->comboTimeZH->setCurrentText(fahrtag->getZeitAnfang().toString("HH"));
ui->comboTimeZM->setCurrentText(fahrtag->getZeitAnfang().toString("mm"));
ui->checkWichtig->setChecked(fahrtag->getWichtig());
ui->checkTf->setChecked(fahrtag->getBenoetigeTf());
ui->checkZf->setChecked(fahrtag->getBenoetigeZf());
ui->checkZub->setChecked(fahrtag->getBenoetigeZub());
ui->checkService->setChecked(fahrtag->getBenoetigeService());
/* LIstTf, ListZf, ListZub, ListService fehlt noch */
QMap<Person*, AActivity::Infos*> tf;
QMap<Person*, AActivity::Infos*> zf;
QMap<Person*, AActivity::Infos*> zub;
QMap<Person*, AActivity::Infos*> service;
QMap<Person*, AActivity::Infos*> sonstige;
listeMitNamen = new QMap<QListWidgetItem*, QString>();
listToTable = new QMap<QListWidgetItem*, QTableWidgetItem*>();
namen = new QSet<QString>();
// Aufsplitten der Personen auf die Einzelnen Listen
for(Person *p: fahrtag->getPersonen()->keys()) {
AActivity::Infos *info = fahrtag->getPersonen()->value(p);
QListWidgetItem *item;
if (info->bemerkung == "") {
item = new QListWidgetItem(p->getName());
} else {
item = new QListWidgetItem(p->getName()+"; "+info->bemerkung);
}
item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled);
listeMitNamen->insert(item, p->getName());
namen->insert(p->getName());
bool block = true;
switch (fahrtag->getPersonen()->value(p)->kategorie) {
case AActivity::Tf:
case AActivity::Tb:
tf.insert(p, info);
ui->listTf->insertItem(0, item);
ui->buttonTfDelete->setEnabled(true);
break;
case AActivity::Zf:
zf.insert(p, info);
ui->listZf->insertItem(0, item);
ui->buttonZfDelete->setEnabled(true);
break;
case AActivity::Zub:
case AActivity::Begleiter:
zub.insert(p, info);
ui->listZub->insertItem(0, item);
ui->buttonZubDelete->setEnabled(true);
break;
case AActivity::Service:
service.insert(p, info);
ui->listService->insertItem(0, item);
ui->buttonServiceDelete->setEnabled(true);
break;
default:
sonstige.insert(p, info);
block = false;
ui->buttonRemove->setEnabled(true);
break;
}
// Zeile für die Person in die Tabelle einfügen
QString bem = info->bemerkung.toUpper();
if ( ! (bem.contains("EXTERN") || ((bem.contains("AZUBI") || bem.contains("FS")) && (info->kategorie == AActivity::Tf || info->kategorie == AActivity::Tb)))) {
ui->tablePersonen->insertRow(0);
QTableWidgetItem *zelleName = new QTableWidgetItem(p->getName());
if (block) zelleName->setFlags(Qt::NoItemFlags);
ui->tablePersonen->setItem(0,0,zelleName);
if (info->beginn != QTime(0, 0)) {
QTableWidgetItem *zelleBeginn = new QTableWidgetItem(info->beginn.toString("hh:mm"));
ui->tablePersonen->setItem(0, 1, zelleBeginn);
}
if (info->ende != QTime(0,0)) {
QTableWidgetItem *zelleEnde = new QTableWidgetItem(info->ende.toString("hh:mm"));
ui->tablePersonen->setItem(0, 2, zelleEnde);
}
QTableWidgetItem *zelleAufgabe;
if (info->aufgabe == "") {
zelleAufgabe = new QTableWidgetItem(AActivity::getStringFromCategory(info->kategorie));
} else {
zelleAufgabe = new QTableWidgetItem(info->aufgabe);
}
if (block) zelleAufgabe->setFlags(Qt::NoItemFlags);
ui->tablePersonen->setItem(0, 3, zelleAufgabe);
listToTable->insert(item, zelleName);
}
}
nehme = true;
}
}
QgsProjectProperties::QgsProjectProperties( QgsMapCanvas* mapCanvas, QWidget *parent, Qt::WFlags fl )
: QDialog( parent, fl ), mMapCanvas( mapCanvas )
{
setupUi( this );
connect( buttonBox, SIGNAL( accepted() ), this, SLOT( accept() ) );
connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) );
connect( buttonBox->button( QDialogButtonBox::Apply ), SIGNAL( clicked() ), this, SLOT( apply() ) );
connect( this, SIGNAL( accepted() ), this, SLOT( apply() ) );
connect( projectionSelector, SIGNAL( sridSelected( QString ) ), this, SLOT( setMapUnitsToCurrentProjection() ) );
///////////////////////////////////////////////////////////
// Properties stored in map canvas's QgsMapRenderer
// these ones are propagated to QgsProject by a signal
QgsMapRenderer* myRender = mMapCanvas->mapRenderer();
QGis::UnitType myUnit = myRender->mapUnits();
setMapUnits( myUnit );
//see if the user wants on the fly projection enabled
bool myProjectionEnabled = myRender->hasCrsTransformEnabled();
cbxProjectionEnabled->setChecked( myProjectionEnabled );
btnGrpMapUnits->setEnabled( !myProjectionEnabled );
long myCRSID = myRender->destinationSrs().srsid();
QgsDebugMsg( "Read project CRSID: " + QString::number( myCRSID ) );
projectionSelector->setSelectedCrsId( myCRSID );
///////////////////////////////////////////////////////////
// Properties stored in QgsProject
title( QgsProject::instance()->title() );
// get the manner in which the number of decimal places in the mouse
// position display is set (manual or automatic)
bool automaticPrecision = QgsProject::instance()->readBoolEntry( "PositionPrecision", "/Automatic" );
if ( automaticPrecision )
{
radAutomatic->setChecked( true );
spinBoxDP->setDisabled( true );
labelDP->setDisabled( true );
}
else
{
radManual->setChecked( true );
}
cbxAbsolutePath->setCurrentIndex( QgsProject::instance()->readBoolEntry( "Paths", "/Absolute", true ) ? 0 : 1 );
int dp = QgsProject::instance()->readNumEntry( "PositionPrecision", "/DecimalPlaces" );
spinBoxDP->setValue( dp );
//get the color selections and set the button color accordingly
int myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorRedPart", 255 );
int myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorGreenPart", 255 );
int myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorBluePart", 0 );
int myAlphaInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorAlphaPart", 255 );
QColor myColor = QColor( myRedInt, myGreenInt, myBlueInt, myAlphaInt );
pbnSelectionColor->setColor( myColor );
//get the color for map canvas background and set button color accordingly (default white)
myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorRedPart", 255 );
myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorGreenPart", 255 );
myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorBluePart", 255 );
myColor = QColor( myRedInt, myGreenInt, myBlueInt );
pbnCanvasColor->setColor( myColor );
QgsMapLayer* currentLayer = 0;
QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" );
const QMap<QString, QgsMapLayer*> &mapLayers = QgsMapLayerRegistry::instance()->mapLayers();
twIdentifyLayers->setColumnCount( 3 );
twIdentifyLayers->horizontalHeader()->setVisible( true );
twIdentifyLayers->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Layer" ) ) );
twIdentifyLayers->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "Type" ) ) );
twIdentifyLayers->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "Identifiable" ) ) );
twIdentifyLayers->setRowCount( mapLayers.size() );
twIdentifyLayers->verticalHeader()->setResizeMode( QHeaderView::ResizeToContents );
int i = 0;
for ( QMap<QString, QgsMapLayer*>::const_iterator it = mapLayers.constBegin(); it != mapLayers.constEnd(); it++, i++ )
{
currentLayer = it.value();
QTableWidgetItem *twi = new QTableWidgetItem( QString::number( i ) );
twIdentifyLayers->setVerticalHeaderItem( i, twi );
twi = new QTableWidgetItem( currentLayer->name() );
twi->setData( Qt::UserRole, it.key() );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
twIdentifyLayers->setItem( i, 0, twi );
QString type;
if ( currentLayer->type() == QgsMapLayer::VectorLayer )
{
type = tr( "Vector" );
}
else if ( currentLayer->type() == QgsMapLayer::RasterLayer )
{
QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( currentLayer );
if ( rl && rl->providerKey() == "wms" )
{
type = tr( "WMS" );
}
else
{
type = tr( "Raster" );
}
}
twi = new QTableWidgetItem( type );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
twIdentifyLayers->setItem( i, 1, twi );
QCheckBox *cb = new QCheckBox();
cb->setChecked( !noIdentifyLayerIdList.contains( currentLayer->getLayerID() ) );
twIdentifyLayers->setCellWidget( i, 2, cb );
}
restoreState();
}
void FahrtagWindow::itemChanged(QListWidgetItem *item , AActivity::Category kat, bool isExtern)
{
/* item: Das Item das Verändert wurde */
/* kat: Die Kategorie, auf die gebucht wird */
/* is Extern: Gibt an ob die Person extern ist */
// Laden der Informationen zur geänderten Person
QString text = item->text();
QStringList liste = text.split(QRegExp("\\s*;\\s*"));
QString name = liste.at(0);
QString bem = "";
QTime start = QTime(0,0);
QTime ende = QTime(0,0);
QString aufgabe = AActivity::getStringFromCategory(kat);
if (liste.length() > 1) {
bem = liste.at(1);
}
if (bem.toUpper().contains("EXTERN")) isExtern = true;
Person *person;
if (isExtern) {
person = new Person(name);
person->setAusbildungTf(true);
person->setAusbildungZf(true);
person->setAusbildungRangierer(true);
person->addActivity(fahrtag, kat);
fahrtag->addPerson(person, bem, start, ende, aufgabe);
if (listeMitNamen->contains(item)) {
fahrtag->removePerson(listeMitNamen->value(item));
listeMitNamen->remove(item);
ui->tablePersonen->removeRow(ui->tablePersonen->row(listToTable->value(item)));
namen->remove(name);
}
return;
} else if (!fahrtag->getPersonal()->personExists(name)) {
QMessageBox::information(this, "Person nicht gefunden", "Die eingegebene Person konnte nicht gefunden werden!");
return;
}
person = fahrtag->getPersonal()->getPerson(name);
// Die Person ist in Ordnung und kann jetzt übernommen werden
name = person->getName();
if (listeMitNamen->contains(item)) {
if (listeMitNamen->value(item) == name) {
// Der Name hat sich nicht verändert, lediglich die Bemerkungen updaten
fahrtag->updatePersonBemerkung(person, bem);
return;
} else {
// Der Name wurde verändert -> alte Person löschen und dann verfahren, als ob person nicht vorhanden wäre
QString nameAlt = listeMitNamen->value(item);
AActivity::Infos *info = fahrtag->getIndividual(person);
start = info->beginn;
ende = info->ende;
aufgabe = info->aufgabe;
fahrtag->removePerson(nameAlt); // Alte Person von Fahrtag lösen
listeMitNamen->remove(item);
ui->tablePersonen->removeRow(ui->tablePersonen->row(listToTable->value(item)));
listToTable->remove(item);
}
}
if (fahrtag->addPerson(person, bem, start, ende, aufgabe) == ManagerPersonal::FalscheQualifikation) {
QMessageBox::warning(this, "Fehlene Qualifikation", "Die Aufgabe kann/darf nicht von der angegebenen Person übernommen werden, da dies eine Aufgabe ist, welche eine Ausbildung voraussetzt.");
return;
}
person->addActivity(fahrtag, kat);
listeMitNamen->insert(item, name);
// Zeile für die Person in die Tabelle einfügen
ui->tablePersonen->insertRow(0);
QTableWidgetItem *zelleName = new QTableWidgetItem(name);
zelleName->setFlags(Qt::NoItemFlags);
ui->tablePersonen->setItem(0,0,zelleName);
if (start != QTime(0, 0)) {
ui->tablePersonen->setItem(0, 1, new QTableWidgetItem(start.toString("hh:mm")));
}
if (ende != QTime(0,0)) {
ui->tablePersonen->setItem(0, 2, new QTableWidgetItem(ende.toString("hh:mm")));
}
QTableWidgetItem *zelleAufgabe = new QTableWidgetItem(AActivity::getStringFromCategory(kat));
zelleAufgabe->setFlags(Qt::NoItemFlags);
ui->tablePersonen->setItem(0,3,zelleAufgabe);
listToTable->insert(item, zelleName);
namen->insert(name);
}
PrintSociosBusqueda::PrintSociosBusqueda(QWidget *parent) :
QWidget(parent),
ui(new Ui::PrintSociosBusqueda)
{
ui->setupUi(this);
ui->labelFecha->setText("FECHA: " + QDate::currentDate().toString("dd/MM/yy"));
d_espera = new DialogEspera();
d_espera->setModal (true);
d_espera->setWindowTitle("Imprimiendo");
d_espera->setInsideText("Imprimiendo socios");
d_espera->updateValue(1);
d_espera->show ();
QApplication::processEvents();
int hojas=1;
while(model->canFetchMore()) {
model->fetchMore();
}
int rowCount= model->rowCount();
int maxRowsPerPage = 27;
int count=maxRowsPerPage;
while (count<rowCount){
count+=maxRowsPerPage;
hojas=hojas+1;
}
hoja=1;
hojamax=QString::number(hojas);
progressIncrement = static_cast<int>(((100/ hojas)+0.5f));
ui->labelHoja->setText("Hoja 1 de "+hojamax);
ui->tableImpresion->setColumnWidth(0,100);
ui->tableImpresion->setColumnWidth(1,200);
ui->tableImpresion->setColumnWidth(2,200);
ui->tableImpresion->setColumnWidth(3,75);
ui->tableImpresion->setColumnWidth(4,75);
ui->tableImpresion->setColumnWidth(5,120);
ui->tableImpresion->setColumnWidth(6,100);
ui->tableImpresion->setColumnWidth(7,65);
QString styleSheet = "QHeaderView::section {"
"spacing: 5px;"
"height: 23px;"
"background-color: darkcyan;"
"color: black;"
"border: 1px solid black;"
"margin: 0px;"
"text-align: right;"
"font-family: arialblack;"
"font: bold 12px;"
"font-size: 12px; }";
ui->tableImpresion->horizontalHeader()->setStyleSheet(styleSheet);
int j=0;
int i=0;
QTableWidgetItem *item;
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setOrientation(QPrinter::Landscape);
QString fileNameAndPath = QFileDialog::getSaveFileName(this, "Guardar en formato PDF", "listaDeSociosAl_" + QDate::currentDate().toString("dd_MM_yy"),"*.pdf");
if (!fileNameAndPath.isNull()) {
printer.setOutputFileName(fileNameAndPath);
} else {
d_espera->close();
delete ui;
close();
return;
}
QPainter painter(&printer);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::HighQualityAntialiasing);
QFont f = QFont();
f.setPixelSize(10);
QApplication::processEvents();
while (j<rowCount){
QSqlRecord row = model->record(j);
ui->tableImpresion->insertRow(i);
item = new QTableWidgetItem(row.value(0).toString());
item->setFont(f);
item->setTextAlignment(Qt::AlignCenter);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 0, item);
item = new QTableWidgetItem(row.value(2).toString() + ", " + row.value(1).toString());
item->setFont(f);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 1, item);
item = new QTableWidgetItem(row.value(3).toString());
item->setFont(f);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 2, item);
item = new QTableWidgetItem(row.value(4).toString());
item->setFont(f);
item->setTextAlignment(Qt::AlignCenter);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 3, item);
item = new QTableWidgetItem(row.value(5).toString());
item->setFlags(item->flags()&~Qt::ItemIsEditable);
item->setFont(f);
item->setTextAlignment(Qt::AlignCenter);
ui->tableImpresion->setItem(i, 4, item);
item = new QTableWidgetItem(row.value(6).toString());
item->setFlags(item->flags()&~Qt::ItemIsEditable);
item->setFont(f);
ui->tableImpresion->setItem(i, 5, item);
item = new QTableWidgetItem(row.value(9).toString());
item->setFont(f);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 6, item);
item = new QTableWidgetItem(row.value(10).toString());
item->setFont(f);
item->setTextAlignment(Qt::AlignCenter);
item->setFlags(item->flags()&~Qt::ItemIsEditable);
ui->tableImpresion->setItem(i, 7, item);
j++;
i++;
if (i==maxRowsPerPage){
i=0;
render(&painter, QPoint(), QRegion(), QWidget::DrawChildren);
printer.newPage();
hoja++;
ui->tableImpresion->clearContents();
d_espera->updateValue(progressIncrement);
QApplication::processEvents();
ui->labelHoja->setText("Hoja "+QString::number(hoja)+" de "+hojamax);
}
}
if (i>0) {
render(&painter, QPoint(), QRegion(), QWidget::DrawChildren);
QApplication::processEvents();
}
painter.end();
d_espera->close();
delete ui;
close();
}
//------------------------------------------------------------------------------
void MoleculeElDensSurfaceWidget::UpdateGUI( bool updateTable, bool updateBBox )
{
table_->setEnabled( false );
if( mol_ == 0 ) return;
densityMatrixCheckBox_->setEnabled( mol_->CanComputeElectronDensity() );
ResourceHandler< bool > rh( updatingGUI_, true, false );
if( updateTable && mol_->GetNumberOfOrbitals() )
{
// update orbitals
const int orbitals = mol_->GetNumberOfOrbitals();
table_->setRowCount( orbitals );
QStringList verticalHeaders;
for( int i = 0; i != orbitals; ++i )
{
QTableWidgetItem *eigenValueItem = new QTableWidgetItem;
eigenValueItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
eigenValueItem->setText( QString( "%1" ).arg( mol_->GetOrbitalEigenValue( i ) ) );
QTableWidgetItem *occupationItem = new QTableWidgetItem;
occupationItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
occupationItem->setText( QString( "%1" ).arg( mol_->GetOrbitalOccupation( i ) ) );
QTableWidgetItem *typeItem = new QTableWidgetItem;
typeItem->setText( QString( "%1" ).arg( mol_->GetOrbitalType( i ) ) );
QTableWidgetItem *generatedItem = new QTableWidgetItem;
generatedItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
// Removed check box, not sure it's a good idea, user
// will want to check the checkbox and then click on generate
// to have multiple orbital surfaces generated at once.
if( mol_->HasOrbitalSurface( i ) )
{
//generatedItem->setCheckState( Qt::Checked );
generatedItem->setText( tr( "Yes" ) );
}
else
{
//generatedItem->setCheckState( Qt::Unchecked );
generatedItem->setText( tr( "No" ) );
}
table_->setItem( i, 0, generatedItem );
table_->setItem( i, 1, eigenValueItem );
table_->setItem( i, 2, occupationItem );
table_->setItem( i, 3, typeItem );
//TEMPORARY DISABLED
//if( mol_->IsAlphaOrbital( i ) )
//{
// verticalHeaders << QString( "%1 (%2)" ).arg( i + 1 ).arg( tr( "alpha" ) );
//}
//else if( mol_->IsBetaOrbital( i ) )
//{
// verticalHeaders << QString( "%1 (%2)" ).arg( i + 1 ).arg( tr( "beta" ) );
//}
}
table_->setVerticalHeaderLabels( verticalHeaders );
table_->resizeColumnsToContents();
/// @todo do we need the following to make sure everything is unselected ?
/// table_->setRangeSelected( QTableWidgetSelectionRange( 0, 0, table_->rowCount() - 1, 3 ), false );
}
if( updateBBox )
{
double dx = 0.;
double dy = 0.;
double dz = 0.;
mol_->GetIsoBoundingBoxSize( dx, dy, dz );
#ifdef PERSISTENT_ISOBBOX
QSettings s;
if( s.contains( BBOX_DX_KEY ) ) dx = s.value( BBOX_DX_KEY ).toDouble();
if( s.contains( BBOX_DY_KEY ) ) dy = s.value( BBOX_DY_KEY ).toDouble();
if( s.contains( BBOX_DZ_KEY ) ) dz = s.value( BBOX_DZ_KEY ).toDouble();
#endif
dxSpinBox_->setValue( dx );
dySpinBox_->setValue( dy );
dzSpinBox_->setValue( dz );
ComputeSteps();
}
double cx = 0.;
double cy = 0.;
double cz = 0.;
double dx = 0.;
double dy = 0.;
double dz = 0.;
mol_->GetIsoBoundingBoxSize( dx, dy, dz );
mol_->GetIsoBoundingBoxCenter( cx, cy, cz );
xSpinBox_->setValue( cx );
ySpinBox_->setValue( cy );
zSpinBox_->setValue( cz );
xSpinBox_->setSingleStep( 0.05 * dx );
ySpinBox_->setSingleStep( 0.05 * dy );
zSpinBox_->setSingleStep( 0.05 * dz );
xSpinBox_->setMinimum( cx - dx );
xSpinBox_->setMaximum( cx + dx );
ySpinBox_->setMinimum( cy - dy );
ySpinBox_->setMaximum( cy + dy );
zSpinBox_->setMinimum( cz - dz );
zSpinBox_->setMaximum( cz + dz );
dxSpinBox_->setSingleStep( 0.05 * dx );
dySpinBox_->setSingleStep( 0.05 * dy );
dzSpinBox_->setSingleStep( 0.05 * dz );
table_->setEnabled( true );
}
QucsSettingsDialog::QucsSettingsDialog(QucsApp *parent, const char *name)
: QDialog(parent, name)
{
App = parent;
setWindowTitle(tr("Edit Qucs Properties"));
Expr.setPattern("[\\w_]+");
Validator = new QRegExpValidator(Expr, this);
all = new QVBoxLayout(this); // to provide the neccessary size
QTabWidget *t = new QTabWidget();
all->addWidget(t);
// ...........................................................
QWidget *Tab1 = new QWidget(t);
QGridLayout *gp = new QGridLayout(Tab1);
gp->addWidget(new QLabel(tr("Font (set after reload):"), Tab1), 0,0);
FontButton = new QPushButton(Tab1);
connect(FontButton, SIGNAL(clicked()), SLOT(slotFontDialog()));
gp->addWidget(FontButton,0,1);
gp->addWidget(new QLabel(tr("Document Background Color:"), Tab1) ,1,0);
BGColorButton = new QPushButton(" ", Tab1);
connect(BGColorButton, SIGNAL(clicked()), SLOT(slotBGColorDialog()));
gp->addWidget(BGColorButton,1,1);
gp->addWidget(new QLabel(tr("Language (set after reload):"), Tab1) ,2,0);
LanguageCombo = new QComboBox(Tab1);
LanguageCombo->insertItem(tr("system language"));
LanguageCombo->insertItem(tr("English")+" (en)");
LanguageCombo->insertItem(tr("German")+" (de)");
LanguageCombo->insertItem(tr("French")+" (fr)");
LanguageCombo->insertItem(tr("Spanish")+" (es)");
LanguageCombo->insertItem(tr("Italian")+" (it)");
LanguageCombo->insertItem(tr("Polish")+" (pl)");
LanguageCombo->insertItem(tr("Romanian")+" (ro)");
LanguageCombo->insertItem(tr("Japanese")+" (jp)");
LanguageCombo->insertItem(tr("Swedish")+" (sv)");
LanguageCombo->insertItem(tr("Hungarian")+" (hu)");
LanguageCombo->insertItem(tr("Hebrew")+" (he)");
LanguageCombo->insertItem(tr("Portuguese")+" (pt)");
LanguageCombo->insertItem(tr("Turkish")+" (tr)");
LanguageCombo->insertItem(tr("Ukrainian")+" (uk)");
LanguageCombo->insertItem(tr("Russian")+" (ru)");
LanguageCombo->insertItem(tr("Czech")+" (cs)");
LanguageCombo->insertItem(tr("Catalan")+" (ca)");
LanguageCombo->insertItem(tr("Arabic")+" (ar)");
LanguageCombo->insertItem(tr("Kazakh")+" (kk)");
gp->addWidget(LanguageCombo,2,1);
val200 = new QIntValidator(0, 200, this);
gp->addWidget(new QLabel(tr("maximum undo operations:"), Tab1) ,3,0);
undoNumEdit = new QLineEdit(Tab1);
undoNumEdit->setValidator(val200);
gp->addWidget(undoNumEdit,3,1);
gp->addWidget(new QLabel(tr("text editor:"), Tab1) ,4,0);
editorEdit = new QLineEdit(Tab1);
gp->addWidget(editorEdit,4,1);
gp->addWidget(new QLabel(tr("start wiring when clicking open node:"), Tab1) ,5,0);
checkWiring = new QCheckBox(Tab1);
gp->addWidget(checkWiring,5,1);
t->addTab(Tab1, tr("Settings"));
// ...........................................................
QWidget *Tab3 = new QWidget(t);
QGridLayout *gp3 = new QGridLayout(Tab3);
gp3->addMultiCellWidget(new QLabel(tr("Colors for Syntax Highlighting:"), Tab3), 0,0,0,1);
ColorComment = new QPushButton(tr("Comment"), Tab3);
ColorComment->setPaletteForegroundColor(QucsSettings.Comment);
ColorComment->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorComment, SIGNAL(clicked()), SLOT(slotColorComment()));
gp3->addWidget(ColorComment,1,0);
ColorString = new QPushButton(tr("String"), Tab3);
ColorString->setPaletteForegroundColor(QucsSettings.String);
ColorString->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorString, SIGNAL(clicked()), SLOT(slotColorString()));
gp3->addWidget(ColorString,1,1);
ColorInteger = new QPushButton(tr("Integer Number"), Tab3);
ColorInteger->setPaletteForegroundColor(QucsSettings.Integer);
ColorInteger->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorInteger, SIGNAL(clicked()), SLOT(slotColorInteger()));
gp3->addWidget(ColorInteger,1,2);
ColorReal = new QPushButton(tr("Real Number"), Tab3);
ColorReal->setPaletteForegroundColor(QucsSettings.Real);
ColorReal->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorReal, SIGNAL(clicked()), SLOT(slotColorReal()));
gp3->addWidget(ColorReal,2,0);
ColorCharacter = new QPushButton(tr("Character"), Tab3);
ColorCharacter->setPaletteForegroundColor(QucsSettings.Character);
ColorCharacter->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorCharacter, SIGNAL(clicked()), SLOT(slotColorCharacter()));
gp3->addWidget(ColorCharacter,2,1);
ColorDataType = new QPushButton(tr("Data Type"), Tab3);
ColorDataType->setPaletteForegroundColor(QucsSettings.Type);
ColorDataType->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorDataType, SIGNAL(clicked()), SLOT(slotColorDataType()));
gp3->addWidget(ColorDataType,2,2);
ColorAttribute = new QPushButton(tr("Attribute"), Tab3);
ColorAttribute->setPaletteForegroundColor(QucsSettings.Attribute);
ColorAttribute->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorAttribute, SIGNAL(clicked()), SLOT(slotColorAttribute()));
gp3->addWidget(ColorAttribute,3,0);
ColorDirective = new QPushButton(tr("Directive"), Tab3);
ColorDirective->setPaletteForegroundColor(QucsSettings.Directive);
ColorDirective->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorDirective, SIGNAL(clicked()), SLOT(slotColorDirective()));
gp3->addWidget(ColorDirective,3,1);
ColorTask = new QPushButton(tr("Task"), Tab3);
ColorTask->setPaletteForegroundColor(QucsSettings.Task);
ColorTask->setPaletteBackgroundColor(QucsSettings.BGColor);
connect(ColorTask, SIGNAL(clicked()), SLOT(slotColorTask()));
gp3->addWidget(ColorTask,3,2);
t->addTab(Tab3, tr("Source Code Editor"));
// ...........................................................
QWidget *Tab2 = new QWidget(t);
QGridLayout *gp2 = new QGridLayout(Tab2);
QLabel *note = new QLabel(
tr("Register filename extensions here in order to\nopen files with an appropriate program."));
gp2->addWidget(note,0,0,1,2);
tableWidget = new QTableWidget(Tab2);
tableWidget->setColumnCount(2);
QTableWidgetItem *item1 = new QTableWidgetItem();
QTableWidgetItem *item2 = new QTableWidgetItem();
tableWidget->setHorizontalHeaderItem(0, item1);
tableWidget->setHorizontalHeaderItem(1, item2);
item1->setText(tr("Suffix"));
item2->setText(tr("Program"));
tableWidget->horizontalHeader()->setStretchLastSection(true);
tableWidget->verticalHeader()->hide();
connect(tableWidget, SIGNAL(cellClicked(int,int)), SLOT(slotTableCliked(int,int)));
gp2->addWidget(tableWidget,1,0,3,1);
// fill listview with already registered file extensions
QStringList::Iterator it = QucsSettings.FileTypes.begin();
while(it != QucsSettings.FileTypes.end()) {
int row = tableWidget->rowCount();
tableWidget->setRowCount(row+1);
QTableWidgetItem *suffix = new QTableWidgetItem(QString((*it).section('/',0,0)));
QTableWidgetItem *program = new QTableWidgetItem(QString((*it).section('/',1,1)));
suffix->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
program->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
tableWidget->setItem(row, 0, suffix);
tableWidget->setItem(row, 1, program);
it++;
}
QLabel *l5 = new QLabel(tr("Suffix:"), Tab2);
gp2->addWidget(l5,1,1);
Input_Suffix = new QLineEdit(Tab2);
Input_Suffix->setValidator(Validator);
gp2->addWidget(Input_Suffix,1,2);
// connect(Input_Suffix, SIGNAL(returnPressed()), SLOT(slotGotoProgEdit())); //not implemented
QLabel *l6 = new QLabel(tr("Program:"), Tab2);
gp2->addWidget(l6,2,1);
Input_Program = new QLineEdit(Tab2);
gp2->addWidget(Input_Program,2,2);
QPushButton *AddButt = new QPushButton(tr("Set"));
gp2->addWidget(AddButt,3,1);
connect(AddButt, SIGNAL(clicked()), SLOT(slotAdd()));
QPushButton *RemoveButt = new QPushButton(tr("Remove"));
gp2->addWidget(RemoveButt,3,2);
connect(RemoveButt, SIGNAL(clicked()), SLOT(slotRemove()));
gp2->setRowStretch(3,4);
t->addTab(Tab2, tr("File Types"));
// ...........................................................
// buttons on the bottom of the dialog (independent of the TabWidget)
QHBoxLayout *Butts = new QHBoxLayout();
Butts->setSpacing(3);
Butts->setMargin(3);
all->addLayout(Butts);
QPushButton *OkButt = new QPushButton(tr("OK"));
Butts->addWidget(OkButt);
connect(OkButt, SIGNAL(clicked()), SLOT(slotOK()));
QPushButton *ApplyButt = new QPushButton(tr("Apply"));
Butts->addWidget(ApplyButt);
connect(ApplyButt, SIGNAL(clicked()), SLOT(slotApply()));
QPushButton *CancelButt = new QPushButton(tr("Cancel"));
Butts->addWidget(CancelButt);
connect(CancelButt, SIGNAL(clicked()), SLOT(reject()));
QPushButton *DefaultButt = new QPushButton(tr("Default Values"));
Butts->addWidget(DefaultButt);
connect(DefaultButt, SIGNAL(clicked()), SLOT(slotDefaultValues()));
OkButt->setDefault(true);
// ...........................................................
// fill the fields with the Qucs-Properties
Font = QucsSettings.font;
FontButton->setText(Font.toString());
BGColorButton->setPaletteBackgroundColor(QucsSettings.BGColor);
undoNumEdit->setText(QString::number(QucsSettings.maxUndo));
editorEdit->setText(QucsSettings.Editor);
checkWiring->setChecked(QucsSettings.NodeWiring);
for(int z=LanguageCombo->count()-1; z>=0; z--)
if(LanguageCombo->text(z).section('(',1,1).remove(')') == QucsSettings.Language)
LanguageCombo->setCurrentItem(z);
resize(300, 200);
}
EditStyle::EditStyle(Score* s, QWidget* parent)
: QDialog(parent)
{
setupUi(this);
setWindowFlags(this->windowFlags() & ~Qt::WindowContextHelpButtonHint);
cs = s;
buttonApplyToAllParts = buttonBox->addButton(tr("Apply to all Parts"), QDialogButtonBox::ApplyRole);
buttonApplyToAllParts->setEnabled(cs->parentScore() != nullptr);
lstyle = *s->style();
setModal(true);
chordDescriptionFileButton->setIcon(*icons[int(Icons::fileOpen_ICON)]);
pageList->setCurrentRow(0);
//articulationTable->verticalHeader()->setVisible(false); // can get disabled in ui file
articulationTable->setSelectionBehavior(QAbstractItemView::SelectRows);
QStringList headers;
headers << tr("Symbol") << tr("Anchor");
articulationTable->setHorizontalHeaderLabels(headers);
articulationTable->setColumnWidth(0, 200);
articulationTable->setColumnWidth(1, 180);
articulationTable->setRowCount(int(ArticulationType::ARTICULATIONS));
accidentalsGroup->setVisible(false); // disable, not yet implemented
musicalSymbolFont->clear();
int idx = 0;
for (auto i : ScoreFont::scoreFonts()) {
musicalSymbolFont->addItem(i.name(), idx);
++idx;
}
for (int i = 0; i < int(ArticulationType::ARTICULATIONS); ++i) {
ArticulationInfo* ai = &Articulation::articulationList[i];
QPixmap ct = cs->scoreFont()->sym2pixmap(ai->upSym, 3.0);
QIcon icon(ct);
QTableWidgetItem* item = new QTableWidgetItem(icon, qApp->translate("articulation", qPrintable(ai->description)));
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
articulationTable->setItem(i, 0, item);
QComboBox* cb = new QComboBox();
cb->addItem(tr("Above Staff"), int(ArticulationAnchor::TOP_STAFF));
cb->addItem(tr("Below Staff"), int(ArticulationAnchor::BOTTOM_STAFF));
cb->addItem(tr("Chord Automatic"), int(ArticulationAnchor::CHORD));
cb->addItem(tr("Above Chord"), int(ArticulationAnchor::TOP_CHORD));
cb->addItem(tr("Below Chord"), int(ArticulationAnchor::BOTTOM_CHORD));
articulationTable->setCellWidget(i, 1, cb);
}
QButtonGroup* bg = new QButtonGroup(this);
bg->addButton(editEvenHeaderL, 0);
bg->addButton(editEvenHeaderC, 1);
bg->addButton(editEvenHeaderR, 2);
bg->addButton(editOddHeaderL, 3);
bg->addButton(editOddHeaderC, 4);
bg->addButton(editOddHeaderR, 5);
bg->addButton(editEvenFooterL, 6);
bg->addButton(editEvenFooterC, 7);
bg->addButton(editEvenFooterR, 8);
bg->addButton(editOddFooterL, 9);
bg->addButton(editOddFooterC, 10);
bg->addButton(editOddFooterR, 11);
// figured bass init
QList<QString> fbFontNames = FiguredBass::fontNames();
foreach(const QString& family, fbFontNames)
comboFBFont->addItem(family);
comboFBFont->setCurrentIndex(0);
connect(comboFBFont, SIGNAL(currentIndexChanged(int)), SLOT(on_comboFBFont_currentIndexChanged(int)));
setValues();
// keep in sync with implementation in Page::replaceTextMacros (page.cpp)
// jumping thru hoops here to make the job of translators easier, yet have a nice display
QString toolTipHeaderFooter
= QString("<html><head></head><body><p><b>")
+ tr("Special symbols in header/footer")
+ QString("</b></p>")
+ QString("<table><tr><td>$p</td><td>-</td><td><i>")
+ tr("page number, except on first page")
+ QString("</i></td></tr><tr><td>$P</td><td>-</td><td><i>")
+ tr("page number, on all pages")
+ QString("</i></td></tr><tr><td>$n</td><td>-</td><td><i>")
+ tr("number of pages")
+ QString("</i></td></tr><tr><td>$f</td><td>-</td><td><i>")
+ tr("file name")
+ QString("</i></td></tr><tr><td>$F</td><td>-</td><td><i>")
+ tr("file path+name")
+ QString("</i></td></tr><tr><td>$d</td><td>-</td><td><i>")
+ tr("current date")
+ QString("</i></td></tr><tr><td>$D</td><td>-</td><td><i>")
+ tr("creation date")
+ QString("</i></td></tr><tr><td>$C</td><td>-</td><td><i>")
+ tr("copyright, on first page only")
+ QString("</i></td></tr><tr><td>$c</td><td>-</td><td><i>")
+ tr("copyright, on all pages")
+ QString("</i></td></tr><tr><td>$$</td><td>-</td><td><i>")
+ tr("the $ sign itself")
+ QString("</i></td></tr><tr><td>$:tag:</td><td>-</td><td><i>")
+ tr("meta data tag")
+ QString("</i></td></tr></table><p>")
+ tr("Available tags and their current values:")
+ QString("</p><table>");
// shown all tags for curent score, see also Score::init()
QMapIterator<QString, QString> i(cs->metaTags());
while (i.hasNext()) {
i.next();
toolTipHeaderFooter += QString("<tr><td>%1</td><td>-</td><td>%2</td></tr>").arg(i.key()).arg(i.value());
}
toolTipHeaderFooter += QString("</table></body></html>");
showHeader->setToolTip(toolTipHeaderFooter);
showFooter->setToolTip(toolTipHeaderFooter);
connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), SLOT(buttonClicked(QAbstractButton*)));
connect(headerOddEven, SIGNAL(toggled(bool)), SLOT(toggleHeaderOddEven(bool)));
connect(footerOddEven, SIGNAL(toggled(bool)), SLOT(toggleFooterOddEven(bool)));
connect(chordDescriptionFileButton, SIGNAL(clicked()), SLOT(selectChordDescriptionFile()));
connect(chordsStandard, SIGNAL(toggled(bool)), SLOT(setChordStyle(bool)));
connect(chordsJazz, SIGNAL(toggled(bool)), SLOT(setChordStyle(bool)));
connect(chordsCustom, SIGNAL(toggled(bool)), SLOT(setChordStyle(bool)));
connect(SwingOff, SIGNAL(toggled(bool)), SLOT(setSwingParams(bool)));
connect(swingEighth, SIGNAL(toggled(bool)), SLOT(setSwingParams(bool)));
connect(swingSixteenth, SIGNAL(toggled(bool)), SLOT(setSwingParams(bool)));
connect(hideEmptyStaves, SIGNAL(clicked(bool)), dontHideStavesInFirstSystem, SLOT(setEnabled(bool)));
connect(bg, SIGNAL(buttonClicked(int)), SLOT(editTextClicked(int)));
QSignalMapper* mapper = new QSignalMapper(this);
#define CR(W, ID) connect(W, SIGNAL(clicked()), mapper, SLOT(map())); mapper->setMapping(W, int(ID));
CR(resetVoltaY, StyleIdx::voltaY);
CR(resetVoltaHook, StyleIdx::voltaHook);
CR(resetVoltaLineWidth, StyleIdx::voltaLineWidth);
CR(resetVoltaLineStyle, StyleIdx::voltaLineStyle);
CR(resetOttavaY, StyleIdx::ottavaY);
CR(resetOttavaHook, StyleIdx::ottavaHook);
CR(resetOttavaLineWidth, StyleIdx::ottavaLineWidth);
CR(resetOttavaLineStyle, StyleIdx::ottavaLineStyle);
CR(resetOttavaNumbersOnly, StyleIdx::ottavaNumbersOnly);
CR(resetHairpinY, StyleIdx::hairpinY);
CR(resetHairpinLineWidth, StyleIdx::hairpinLineWidth);
CR(resetHairpinHeight, StyleIdx::hairpinHeight);
CR(resetHairpinContinueHeight, StyleIdx::hairpinContHeight);
#undef CR
connect(mapper, SIGNAL(mapped(int)), SLOT(resetStyleValue(int)));
}
void MainSettingsDialog::fillControllerMappingsTable()
{
/*QList<QVariant> tempvariant = bindingValues(bind);
QTableWidgetItem* item = new QTableWidgetItem();
ui->buttonMappingTableWidget->setItem(associatedRow, 0, item);
item->setText(temptext);
item->setData(Qt::UserRole, tempvariant);
*/
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
ui->controllerMappingsTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
#else
ui->controllerMappingsTableWidget->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
#endif
QHash<QString, QList<QVariant> > tempHash;
settings->beginGroup("Mappings");
QStringList mappings = settings->allKeys();
QStringListIterator iter(mappings);
while (iter.hasNext())
{
QString tempkey = iter.next();
QString tempGUID;
if (tempkey.contains("Disable"))
{
bool disableGameController = settings->value(tempkey, false).toBool();
tempGUID = tempkey.remove("Disable");
insertTempControllerMapping(tempHash, tempGUID);
if (tempHash.contains(tempGUID))
{
QList<QVariant> templist = tempHash.value(tempGUID);
templist.replace(2, QVariant(disableGameController));
tempHash.insert(tempGUID, templist); // Overwrite original list
}
}
else
{
QString mappingString = settings->value(tempkey, QString()).toString();
if (!mappingString.isEmpty())
{
tempGUID = tempkey;
insertTempControllerMapping(tempHash, tempGUID);
if (tempHash.contains(tempGUID))
{
QList<QVariant> templist = tempHash.value(tempGUID);
templist.replace(1, mappingString);
tempHash.insert(tempGUID, templist); // Overwrite original list
}
}
}
}
settings->endGroup();
QHashIterator<QString, QList<QVariant> > iter2(tempHash);
int i = 0;
while (iter2.hasNext())
{
ui->controllerMappingsTableWidget->insertRow(i);
QList<QVariant> templist = iter2.next().value();
QTableWidgetItem* item = new QTableWidgetItem(templist.at(0).toString());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, iter2.key());
item->setToolTip(templist.at(0).toString());
ui->controllerMappingsTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem(templist.at(1).toString());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setData(Qt::UserRole, iter2.key());
//item->setToolTip(templist.at(1).toString());
ui->controllerMappingsTableWidget->setItem(i, 1, item);
bool disableController = templist.at(2).toBool();
item = new QTableWidgetItem();
item->setCheckState(disableController ? Qt::Checked : Qt::Unchecked);
item->setData(Qt::UserRole, iter2.key());
ui->controllerMappingsTableWidget->setItem(i, 2, item);
i++;
}
}
/*!
\brief Reset the subcontrols to reflect the data of the format scheme being edited
The name can be a bit misleading at first, it has been chosen
because it directly maps to the effect a "cancel" button would
have on the widget
*/
void QFormatConfig::cancel()
{
ui->m_table->clearContents();
if ( m_currentScheme )
{
const int n = m_currentScheme->formatCount();
ui->m_table->setRowCount(n);
for ( int i = 0 ; i < n; ++i )
{
QString fid = m_currentScheme->id(i);
const QFormat& fmt = m_currentScheme->formatRef(i);
QTableWidgetItem *item;
item = new QTableWidgetItem(fid);
item->setFlags(Qt::ItemIsEnabled);
ui->m_table->setItem(i, 0, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.weight == QFont::Bold ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Bold"));
ui->m_table->setItem(i, 1, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.italic ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Italic"));
ui->m_table->setItem(i, 2, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.underline ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Underline"));
ui->m_table->setItem(i, 3, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.overline ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Overline"));
ui->m_table->setItem(i, 4, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.strikeout ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Strikeout"));
ui->m_table->setItem(i, 5, item);
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(fmt.waveUnderline ? Qt::Checked : Qt::Unchecked);
item->setToolTip(tr("Wave underline"));
ui->m_table->setItem(i, 6, item);
ui->m_table->setCellWidget(i, 7, new QSimpleColorPicker(fmt.foreground));
ui->m_table->cellWidget(i, 7)->setToolTip(tr("Text color (aka foreground)"));
//ui->m_table->cellWidget(i, 7)->setMaximumSize(22, 22);
ui->m_table->setCellWidget(i, 8, new QSimpleColorPicker(fmt.background));
ui->m_table->cellWidget(i, 8)->setToolTip(tr("Background color"));
//ui->m_table->cellWidget(i, 8)->setMaximumSize(22, 22);
ui->m_table->setCellWidget(i, 9, new QSimpleColorPicker(fmt.linescolor));
ui->m_table->cellWidget(i, 9)->setToolTip(tr("Lines color (used by all lines formatting : underline, overline, ...)"));
//ui->m_table->cellWidget(i, 9)->setMaximumSize(22, 22);
}
}
ui->m_table->resizeColumnsToContents();
}
OptionsWidget_textEncoding::OptionsWidget_textEncoding(QWidget * parent)
: KviOptionsWidget(parent)
{
setObjectName("textencoding_options_widget");
createLayout();
KviTalGroupBox * gbox = addGroupBox(0, 0, 0, 0, Qt::Horizontal, __tr2qs_ctx("Encoding", "options"));
QGridLayout * grid = new QGridLayout;
gbox->setLayout(grid);
//server encoding
grid->addWidget(addLabel(gbox, __tr2qs_ctx("Default server encoding:", "options")), 0, 0);
m_pSrvEncodingCombo = new QComboBox(gbox);
grid->addWidget(m_pSrvEncodingCombo, 0, 1);
m_pSrvEncodingCombo->addItem(__tr2qs_ctx("Use Language Encoding", "options"));
//text encoding
grid->addWidget(addLabel(gbox, __tr2qs_ctx("Default text encoding:", "options")), 1, 0);
m_pTextEncodingCombo = new QComboBox(gbox);
grid->addWidget(m_pTextEncodingCombo, 1, 1);
m_pTextEncodingCombo->addItem(__tr2qs_ctx("Use Language Encoding", "options"));
//common between text and server encoding
int i = 0;
int iTextMatch = 0, iSrvMatch = 0;
KviLocale::EncodingDescription * d = KviLocale::instance()->encodingDescription(i);
while(d->pcName)
{
if(KviQString::equalCI(d->pcName, KVI_OPTION_STRING(KviOption_stringDefaultTextEncoding)))
iTextMatch = i + 1;
if(KviQString::equalCI(d->pcName, KVI_OPTION_STRING(KviOption_stringDefaultSrvEncoding)))
iSrvMatch = i + 1;
m_pTextEncodingCombo->insertItem(m_pTextEncodingCombo->count(), d->pcName);
m_pSrvEncodingCombo->insertItem(m_pSrvEncodingCombo->count(), d->pcName);
i++;
d = KviLocale::instance()->encodingDescription(i);
}
m_pTextEncodingCombo->setCurrentIndex(iTextMatch);
m_pSrvEncodingCombo->setCurrentIndex(iSrvMatch);
gbox = addGroupBox(0, 1, 0, 1, Qt::Horizontal, __tr2qs_ctx("Language", "options"));
grid = new QGridLayout;
gbox->setLayout(grid);
grid->addWidget(addLabel(gbox, __tr2qs_ctx("Force language:", "options")), 0, 0);
m_pForcedLocaleCombo = new QComboBox(gbox);
grid->addWidget(m_pForcedLocaleCombo, 0, 1);
grid->addWidget(addLabel(gbox, __tr2qs_ctx("<b>Note:</b> You must restart KVIrc to apply any language changes", "options")), 1, 0, 1, 2);
m_pForcedLocaleCombo->addItem(__tr2qs_ctx("Automatic detection", "options"));
m_pForcedLocaleCombo->addItem(__tr2qs_ctx("en", "options"));
QString szLangFile;
g_pApp->getLocalKvircDirectory(szLangFile, KviApplication::None, KVI_FORCE_LOCALE_FILE_NAME);
bool bIsDefaultLocale = !KviFileUtils::fileExists(szLangFile);
//We Have set locale, but not restarted kvirc
if(!g_szPrevSetLocale.isEmpty())
m_szLanguage = g_szPrevSetLocale;
else
m_szLanguage = KviLocale::instance()->localeName();
QString szLocaleDir;
g_pApp->getGlobalKvircDirectory(szLocaleDir, KviApplication::Locale);
QStringList list = QDir(szLocaleDir).entryList(QStringList("kvirc_*.mo"), QDir::Files);
i = 0;
int iMatch = 0;
for(auto szTmp : list)
{
szTmp.replace("kvirc_", "");
szTmp.replace(".mo", "");
m_pForcedLocaleCombo->insertItem(m_pForcedLocaleCombo->count(), szTmp);
if(QString::compare(szTmp, m_szLanguage, Qt::CaseInsensitive) == 0)
iMatch = i + 2;
i++;
}
if(bIsDefaultLocale)
m_pForcedLocaleCombo->setCurrentIndex(0);
else if(KviQString::equalCI(m_szLanguage, "en"))
m_pForcedLocaleCombo->setCurrentIndex(1);
else
m_pForcedLocaleCombo->setCurrentIndex(iMatch);
#ifdef COMPILE_ENCHANT_SUPPORT
{
gbox = addGroupBox(0, 2, 0, 2, Qt::Horizontal, __tr2qs_ctx("Spell Checker Dictionaries", "options"));
KviKvsVariant availableDictionaries;
KviKvsScript::evaluate("$spellchecker.availableDictionaries", nullptr, nullptr, &availableDictionaries);
const KviPointerHashTable<QString, KviKvsVariant> * hashTable = availableDictionaries.hash()->dict();
KviPointerHashTableIterator<QString, KviKvsVariant> iter(*hashTable);
QMap<QString, QString> dictMap;
for(bool b = iter.moveFirst(); b; b = iter.moveNext())
{
QString szDescription;
iter.current()->asString(szDescription);
dictMap[iter.currentKey()] = szDescription;
}
m_pSpellCheckerDictionaries = new QTableWidget(gbox);
m_pSpellCheckerDictionaries->setRowCount(dictMap.size());
m_pSpellCheckerDictionaries->setColumnCount(2);
QStringList header;
header << __tr2qs_ctx("Language Code", "options");
header << __tr2qs_ctx("Provided by", "options");
m_pSpellCheckerDictionaries->setHorizontalHeaderLabels(header);
m_pSpellCheckerDictionaries->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
m_pSpellCheckerDictionaries->setSelectionBehavior(QAbstractItemView::SelectRows);
m_pSpellCheckerDictionaries->setSelectionMode(QAbstractItemView::SingleSelection);
m_pSpellCheckerDictionaries->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
int row = 0;
for(QMap<QString, QString>::iterator it = dictMap.begin(); it != dictMap.end(); ++it, ++row)
{
QTableWidgetItem * itemLang = new QTableWidgetItem(it.key());
itemLang->setCheckState(KVI_OPTION_STRINGLIST(KviOption_stringlistSpellCheckerDictionaries).contains(it.key()) ? Qt::Checked : Qt::Unchecked);
itemLang->setFlags(itemLang->flags() & ~Qt::ItemIsEditable);
m_pSpellCheckerDictionaries->setItem(row, 0, itemLang);
QTableWidgetItem * itemDesc = new QTableWidgetItem(it.value());
itemDesc->setFlags(itemDesc->flags() & ~Qt::ItemIsEditable);
m_pSpellCheckerDictionaries->setItem(row, 1, itemDesc);
}
m_pSpellCheckerDictionaries->resizeColumnsToContents();
m_pSpellCheckerDictionaries->resizeRowsToContents();
}
#else
addRowSpacer(0, 2, 0, 2);
#endif
}
void VolumeListingDialog::updateTableRows() {
tgtAssert(table_->columnCount() == metaDataKeys_.size() + 1 /*+1 for URL*/, "column count mismatch");
QString filterAttribute;
if (comboBoxFilterAttribute_->currentIndex() > 0)
filterAttribute = comboBoxFilterAttribute_->currentText();
std::vector<VolumeURL> filteredOriginsNew = getFilteredOrigins(filterTextBox_->text().trimmed(), filterAttribute);
if (filteredOrigins_ == filteredOriginsNew)
return;
else
filteredOrigins_ = filteredOriginsNew;
table_->clearContents();
table_->setRowCount(static_cast<int>(filteredOrigins_.size()));
// disable sorting during insertion
table_->setSortingEnabled(false);
// iterate over filter origins create a row for each
for (size_t i=0; i<filteredOrigins_.size(); i++) {
VolumeURL& origin = filteredOrigins_.at(i);
// fill row cells with meta data entries
for (int m=0; m<metaDataKeys_.size(); m++) {
std::string key = metaDataKeys_.at(m).toStdString();
std::string cellText;
const MetaDataBase* metaDate = origin.getMetaDataContainer().getMetaData(key);
if (metaDate)
cellText = metaDate->toString();
// set cell content type according to type of meta data item
QTableWidgetItem* cellItem = new QTableWidgetItem();
if (dynamic_cast<const IntMetaData*>(metaDate))
cellItem->setData(Qt::DisplayRole, static_cast<const IntMetaData*>(metaDate)->getValue());
else if (dynamic_cast<const SizeTMetaData*>(metaDate))
cellItem->setData(Qt::DisplayRole, static_cast<qulonglong>(static_cast<const SizeTMetaData*>(metaDate)->getValue()));
else if (dynamic_cast<const FloatMetaData*>(metaDate))
cellItem->setData(Qt::DisplayRole, static_cast<const FloatMetaData*>(metaDate)->getValue());
else if (dynamic_cast<const DoubleMetaData*>(metaDate))
cellItem->setData(Qt::DisplayRole, static_cast<const DoubleMetaData*>(metaDate)->getValue());
else
cellItem->setData(Qt::DisplayRole, QString::fromStdString(cellText));
cellItem->setToolTip(QString::fromStdString(key) + ": " + QString::fromStdString(cellText));
//cellItem->setTextAlignment(Qt::AlignLeft);
cellItem->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
table_->setItem(static_cast<int>(i), m, cellItem);
}
// put URL into last cell
QTableWidgetItem* urlItem = new QTableWidgetItem(QString::fromStdString(origin.getURL()));
urlItem->setToolTip("URL: " + QString::fromStdString(origin.getURL()));
//urlItem->setTextAlignment(Qt::AlignLeft);
urlItem->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
table_->setItem(static_cast<int>(i), table_->columnCount()-1, urlItem);
}
table_->setSortingEnabled(true);
updateGuiState();
}
void AppDockWidget::showBreakpoints1(struct BreakPointList* breakPointList, QString filename, int *number)
{
struct BreakPointList *p = breakPointList;
int i = *number;
QTextBlock block = mainwindow->codeEditor->firstVisibleBlock();
int height = (int)mainwindow->codeEditor->blockBoundingRect(block).height();
QTableWidgetItem *item;
ui.breakpointTableWidget->setColumnWidth(1, 120);//设置第一列的宽度为120
while (p) {
if (!p->flag) {
p = p->next;
continue;
}
int blocknumber = ceil(p->blockNumber / height) + 1;
item = new QTableWidgetItem(QString::number(i + 1, 10));
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem(
filename + " : " + QString::number(blocknumber, 10));
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 1, item);
if (p->flag) {
item = new QTableWidgetItem("Enable");
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 2, item);
} else {
item = new QTableWidgetItem("Disable");
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 2, item);
}
if (p->threadid == -1 || p->threadid == -2) {
item = new QTableWidgetItem("all");
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 3, item);
} else
{
item = new QTableWidgetItem(
QString::number(p->threadid, 10) + "(" + QString::number(
p->truetid, 10) + ")");
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui.breakpointTableWidget->setItem(i, 3, item);
}
p = p->next;
i++;
}
*number = i;
}
void CDlgBulkRegister::AddItem( const QString &strText, int nRow, int nCol, QTableWidget* pTable )
{
QTableWidgetItem* pItem = new QTableWidgetItem( strText );
pItem->setFlags( Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
pTable->setItem( nRow, nCol, pItem );
}
void FilterChoice::updateDisplay()
{
std::vector<Filter*> filters;
int num = _number->value();
switch(_blurChoices->currentIndex())
{
case 0:
filters = Filter::uniform(num);
_number->show();
_labelNumber->show();
_labelNumber->setText("Number of Pixels");
break;
case 1:
filters = Filter::gaussian(num);
_number->show();
_labelNumber->show();
_labelNumber->setText("Coefficient");
break;
case 2:
filters = Filter::prewitt(num);
_number->show();
_labelNumber->show();
_labelNumber->setText("Number of Pixels");
break;
default:
filters = _filters[_blurChoices->currentIndex()];
_number->hide();
_labelNumber->hide();
}
if(_blurChoices->currentIndex() > 5)
_deleteButton->setEnabled(true);
else
_deleteButton->setEnabled(false);
int height(0), width(0);
for(unsigned int i = 0; i < filters.size(); i++)
{
if(height > 0)
height++;
height += filters[i]->height();
if(filters[i]->width() > width)
width = filters[i]->width();
}
_filterView->setRowCount(height);
_filterView->setColumnCount(width);
for(int i = 0; i < height; i++)
{
for(int j = 0; j < width; j++)
{
QTableWidgetItem* item = new QTableWidgetItem("");
item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
_filterView->setItem(i, j, item);
}
}
height = 0;
for(unsigned int i = 0; i < filters.size(); i++)
{
for(int j = height; j < filters[i]->width() + height; j++)
{
for(int k = 0; k < filters[i]->height(); k++)
{
int value = (*filters[i])[j - height][k];
QTableWidgetItem* item = new QTableWidgetItem(QString::number(value));
item->setTextAlignment(Qt::AlignHCenter);
item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
_filterView->setItem(j, k, item);
_filterView->setColumnWidth(k, _filterView->rowHeight(0));
}
}
height += filters[i]->width();
for(int k = 0; k < filters[i]->height(); k++)
{
QTableWidgetItem* item = new QTableWidgetItem("");
item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
_filterView->setItem(height, k, item);
}
height++;
}
_filterView->resizeColumnsToContents();
_filterView->resizeRowsToContents();
}
void SyntroDB::initDisplayStats()
{
QTableWidgetItem *item;
QHBoxLayout *layout;
QWidget *widget;
int cellHeight = fontMetrics().lineSpacing() + CELL_HEIGHT_PAD;
m_rxStreamTable = new QTableWidget(this);
m_rxStreamTable->setColumnCount(SYNTRODB_COL_COUNT);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_CONFIG, 80);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_INUSE, 60);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_STREAM, 140);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_TOTALRECS, 80);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_TOTALBYTES, 100);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_FILERECS, 80);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_FILEBYTES, 100);
m_rxStreamTable->setColumnWidth(SYNTRODB_COL_FILE, 400);
m_rxStreamTable->verticalHeader()->setDefaultSectionSize(cellHeight);
m_rxStreamTable->setHorizontalHeaderLabels(QStringList() << tr("") << tr("In use") << tr("Stream")
<< tr("Total Recs") << tr("Total Bytes")
<< tr("File Recs") << tr("File Bytes") << tr("Current file path"));
m_rxStreamTable->setSelectionMode(QAbstractItemView::NoSelection);
for (int row = 0; row < SYNTRODB_MAX_STREAMS; row++) {
m_rxStreamTable->insertRow(row);
m_rxStreamTable->setRowHeight(row, cellHeight);
m_rxStreamTable->setContentsMargins(5, 5, 5, 5);
StoreButton *button = new StoreButton("Configure", this, row);
m_rxStreamTable->setCellWidget(row, SYNTRODB_COL_CONFIG, button);
connect(button, SIGNAL(buttonClicked(int)), this, SLOT(buttonClicked(int)));
m_useBox[row] = new StoreCheckBox(m_rxStreamTable, row);
// center the checkbox in cell
widget = new QWidget;
layout = new QHBoxLayout;
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_useBox[row]);
layout->setAlignment(Qt::AlignCenter);
widget->setLayout(layout);
m_rxStreamTable->setCellWidget(row, SYNTRODB_COL_INUSE, widget);
connect(m_useBox[row], SIGNAL(boxClicked(bool, int)), this, SLOT(boxClicked(bool, int)));
for (int col = 2; col < SYNTRODB_COL_COUNT; col++) {
item = new QTableWidgetItem();
item->setTextAlignment(Qt::AlignLeft | Qt::AlignBottom);
item->setFlags(Qt::ItemIsEnabled);
item->setText("");
m_rxStreamTable->setItem(row, col, item);
}
}
setCentralWidget(m_rxStreamTable);
}
