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); }