void StochasticProcessWidget::updateSelectAllColumn(
int index) {
bool allChecked = true;
bool allUnchecked = true;
for (int i = 0; i <= 2; i++) {
QTableWidgetItem *item = distGraphTable->item(
i, index);
if (item) {
bool isChecked = item->checkState()
== Qt::Checked;
bool isPartiallyChecked =
item->checkState()
== Qt::PartiallyChecked;
allChecked = allChecked && isChecked
&& !isPartiallyChecked;
allUnchecked = allUnchecked && !isChecked
&& !isPartiallyChecked;
}
}
QTableWidgetItem *selectAllItem =
distGraphTable->item(5, index);
if (selectAllItem) {
if (allChecked) {
selectAllItem->setCheckState(Qt::Checked);
} else if (allUnchecked) {
selectAllItem->setCheckState(Qt::Unchecked);
} else {
selectAllItem->setCheckState(Qt::PartiallyChecked);
}
}
}
StochasticProcessWidget::StochasticProcessWidget(QWidget* parent) :
QWidget(parent), correlationCurve(0) {
setupUi(this);
// Add check boxes
for (int i = 0; i <= 5; i++) {
if (i == 4) { // Except for Range row
continue;
}
QTableWidgetItem *item = distGraphTable->item(i, 0);
if (item) {
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
if (i != 3) {
item->setCheckState(Qt::Checked);
} else {
item->setCheckState(Qt::Unchecked);
}
}
}
distGraphTable->horizontalHeader()->hide();
quantileTable->verticalHeader()->hide();
quantileEdit->setValidator(new QDoubleValidator(0.0, 1.0, 15, quantileEdit));
distGraphTable->resizeRowsToContents();
quantileTable->resizeRowsToContents();
}
void RenderWindow::updateParam(const QString & name, const QVariant & value, bool active)
{
QTableWidgetItem * ctItem = 0;
_params[name] = value;
int r;
for(r = 0; r < _table->rowCount(); r++) {
if(_table->item(r, 1)->text() == name)
{
ctItem = _table->item(r, 0);
ctItem->setCheckState((active ? Qt::Checked : Qt::Unchecked));
_table->item(r, 2)->setText(value.typeName());
_table->item(r, 3)->setText(value.toString());
return;
}
}
// If we didn't find an existing parameter by the name specified add one
r = _table->rowCount();
_table->setRowCount(r+1);
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(value.typeName()));
_table->setItem(r, 3, new QTableWidgetItem(value.toString()));
}
void
TagColorEditor::setColors()
{
QFont fnt("Helvetica", 12);
uchar *colors = Global::tagColors();
for (int i=0; i < 256; i++)
{
int row = i/2;
int col = i%2;
int r,g,b;
float a;
r = colors[4*i+0];
g = colors[4*i+1];
b = colors[4*i+2];
QTableWidgetItem *colorItem = table->item(row, col);
if (!colorItem)
{
colorItem = new QTableWidgetItem;
table->setItem(row, col, colorItem);
}
colorItem->setFont(fnt);
colorItem->setData(Qt::DisplayRole, QString("%1").arg(i));
if (colors[4*i+3] > 250)
colorItem->setCheckState(Qt::Checked);
else
colorItem->setCheckState(Qt::Unchecked);
colorItem->setBackground(QColor(r,g,b));
}
}
/** Insert a row with a checkbox with folder's name and the number of files in this folder. */
void QuickStart::insertRow(const QFileInfo &fileInfo, const int & musicFileNumber)
{
// A subfolder is displayed with its number of files on the right
QTableWidgetItem *checkBox = new QTableWidgetItem;
checkBox->setFlags(checkBox->flags() | Qt::ItemIsUserCheckable);
checkBox->setCheckState(Qt::Checked);
QTableWidgetItem *musicSubFolderName = new QTableWidgetItem(QFileIconProvider().icon(fileInfo), fileInfo.baseName());
musicSubFolderName->setData(Qt::UserRole, fileInfo.absoluteFilePath());
QTableWidgetItem *musicSubFolderCount;
if (musicFileNumber == 0) {
musicSubFolderCount = new QTableWidgetItem(tr("empty folder"));
checkBox->setCheckState(Qt::Unchecked);
} else {
musicSubFolderCount = new QTableWidgetItem(tr("%n elements", "", musicFileNumber));
}
musicSubFolderCount->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
int rowCount = quickStartTableWidget->rowCount();
quickStartTableWidget->insertRow(rowCount);
quickStartTableWidget->setItem(rowCount, 0, checkBox);
quickStartTableWidget->setItem(rowCount, 1, musicSubFolderName);
quickStartTableWidget->setItem(rowCount, 2, musicSubFolderCount);
_totalMusicFiles += musicFileNumber;
}
void ChangesDialog::AddItem(const AppCore::Entry& Data)
{
const int Rows = ui->Items->rowCount();
const bool Sorting = ui->Items->isSortingEnabled();
const bool Block = ui->Items->blockSignals(true);
ui->Items->setSortingEnabled(false);
ui->Items->insertRow(Rows);
QTableWidgetItem* IndexBox = new QTableWidgetItem();
QTableWidgetItem* CheckBox = new QTableWidgetItem();
IndexBox->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
IndexBox->setData(Qt::UserRole, Data.ID);
IndexBox->setData(Qt::EditRole, Data.ID);
IndexBox->setCheckState(Data.isEnabled ? Qt::Checked : Qt::Unchecked);
CheckBox->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
CheckBox->setCheckState(Data.isRegExp ? Qt::Checked : Qt::Unchecked);
CheckBox->setText(Data.isRegExp ? tr("Yes") : tr("No"));
ui->Items->setItem(Rows, 0, IndexBox);
ui->Items->setItem(Rows, 1, new QTableWidgetItem(Data.Source));
ui->Items->setItem(Rows, 2, new QTableWidgetItem(Data.Replace));
ui->Items->setItem(Rows, 3, CheckBox);
ui->Items->blockSignals(Block);
ui->Items->setSortingEnabled(Sorting);
if (Data.ID == -1) ui->Items->scrollToItem(IndexBox);
}
void DataTableConfigDialog::readConfig (QMap<QString,bool> &visMap, QVector<QString> &names) {
ui->DataTableConfigTable->clear();
ui->DataTableConfigTable->setColumnCount(2);
ui->DataTableConfigTable->setRowCount(names.count() );
QList<QString> tl;
tl << "name" << "show";
// tl << "Name" << "show" << "color" << "warn color 1" << "warn color 2" << "val" << "warn val 1" << "warn val 2";
ui->DataTableConfigTable->setHorizontalHeaderLabels( tl );
for (quint8 c = 0 ; c < names.size() ; c++ ) {
QTableWidgetItem *wi = new QTableWidgetItem(names.at(c));
//md name
Qt::ItemFlags f = Qt::NoItemFlags;
wi->setFlags(f);
ui->DataTableConfigTable->setItem (c,0,wi);
wi = new QTableWidgetItem();
f=Qt::ItemIsUserCheckable | Qt::ItemIsEnabled;
//visible
if ( visMap[names[c]] == true )
wi->setCheckState(Qt::Checked);
else
wi->setCheckState(Qt::Unchecked);
wi->setFlags(f);
ui->DataTableConfigTable->setItem (c,1,wi);
//color
// wi = new QTableWidgetItem( pc->pen().color().name() );
// wi->setBackground ( pc->pen().brush() );
// ui->VisConfigTable->setItem (i,2,wi);
}
}
void editComputers::displayPeople(vector<peopleWithComputers> people)
{
ui->tableComputerCreators->setSortingEnabled(false);
ui->tableComputerCreators->hideColumn(0);
ui->tableComputerCreators->setColumnWidth(2,330);
ui->tableComputerCreators->setColumnWidth(1,70);
ui->tableComputerCreators->clearContents();
ui->tableComputerCreators->setRowCount(people.size());
for(unsigned int row = 0; row < people.size(); row++)
{
peopleWithComputers currPerson = people[row];
QTableWidgetItem *checkbox = new QTableWidgetItem();
for(int i = 0; i < selectedComputer.creators.size(); i++)
{
if(currPerson.p.getId() == selectedComputer.creators[i].getId()&& selectedComputer.creators[i].getName() != "default")
{
checkbox->setCheckState(Qt::Checked);
break;
}
else
{
checkbox->setCheckState(Qt::Unchecked);
}
}
ui->tableComputerCreators->setItem(row,0,new QTableWidgetItem(QString::number(currPerson.p.getId())));
ui->tableComputerCreators->setItem(row,1,checkbox);
ui->tableComputerCreators->setItem(row,2,new QTableWidgetItem(QString::fromStdString(currPerson.p.getName())));
ui->tableComputerCreators->setItem(row,3,new QTableWidgetItem(QString::number(currPerson.p.getBirth())));
}
ui->tableComputerCreators->setSortingEnabled(true);
}
void SetupPluginsDialog::updatePlugins()
{
FItemElement.clear();
ui.twtPlugins->clearContents();
ui.twtPlugins->setRowCount(0);
QDomElement pluginElem = FPluginsSetup.documentElement().firstChildElement();
while (!pluginElem.isNull())
{
QString name = pluginElem.firstChildElement("name").text().isEmpty() ? pluginElem.tagName() : pluginElem.firstChildElement("name").text();
QTableWidgetItem *nameItem = new QTableWidgetItem(name);
if (pluginElem.attribute("enabled","true")=="true")
{
if (FPluginManager->pluginInstance(pluginElem.attribute("uuid"))==NULL)
nameItem->setForeground(Qt::red);
nameItem->setCheckState(Qt::Checked);
}
else
{
nameItem->setForeground(Qt::gray);
nameItem->setCheckState(Qt::Unchecked);
}
nameItem->setCheckState(pluginElem.attribute("enabled","true")=="true" ? Qt::Checked : Qt::Unchecked);
QTableWidgetItem *fileItem = new QTableWidgetItem(pluginElem.tagName());
ui.twtPlugins->setRowCount(ui.twtPlugins->rowCount()+1);
ui.twtPlugins->setItem(ui.twtPlugins->rowCount()-1, COL_NAME, nameItem);
ui.twtPlugins->setItem(nameItem->row(), COL_FILE, fileItem);
FItemElement.insert(nameItem,pluginElem);
pluginElem = pluginElem.nextSiblingElement();
}
ui.twtPlugins->sortItems(COL_NAME,Qt::AscendingOrder);
}
void PropertiesWidget::updateDisplayedProperties()
{
tableWidget->clear();
_propNames.clear();
tableWidget->setColumnCount(2);
QStringList horizontalHeaders;
horizontalHeaders.append("Name");
horizontalHeaders.append("Value");
tableWidget->setHorizontalHeaderLabels(horizontalHeaders);
tableWidget->verticalHeader()->hide();
PropertyMap* properties = _properties;
if (! properties)
return;
tableWidget->setRowCount(properties->size());
int r = 0;
for (PropertyMap::PropertyMapIterator it = properties->begin(); it != properties->end(); ++it, ++r) {
QTableWidgetItem* textItem = new QTableWidgetItem;
textItem->setText(QString::fromLocal8Bit(humanReadablePropName(it->first).c_str()));
textItem->setFlags(textItem->flags() & ~Qt::ItemIsEditable);
tableWidget->setItem(r, 0, textItem);
_propNames.push_back(it->first);
if (dynamic_cast<Property<bool>*>(it->second)) {
Property<bool>* prop = static_cast<Property<bool>*>(it->second);
QTableWidgetItem* checkItem = new QTableWidgetItem;
checkItem->setText("enabled");
checkItem->setFlags(checkItem->flags() | Qt::ItemIsUserCheckable);
if (prop->value())
checkItem->setCheckState(Qt::Checked);
else
checkItem->setCheckState(Qt::Unchecked);
tableWidget->setItem(r, 1, checkItem);
} else {
QLineEdit* editor = new QLineEdit(tableWidget);
editor->setText(QString::fromLocal8Bit(it->second->toString().c_str()));
if (dynamic_cast<Property<int>*>(it->second)) {
editor->setValidator(new QIntValidator(editor));
}
else if (dynamic_cast<Property<float>*>(it->second)) {
editor->setValidator(new QDoubleValidator(editor));
}
else if (dynamic_cast<Property<double>*>(it->second)) {
editor->setValidator(new QDoubleValidator(editor));
}
tableWidget->setCellWidget(r, 1, editor);
}
}
tableWidget->resizeColumnToContents(0);
}
void MainWindow::updateTable() {
ui->tableWidget->clearContents();
ui->tableWidget->setRowCount(0);
if(network != NULL) {
qDebug() << "UpdateTable() - Start";
QMap<QString, NetNode*> nodes = network->getNodeMap();
QMap<QString, NetNode*>::iterator nodeIter = nodes.begin();
//ui->tableWidget->setRowCount(nodes.size());
int row = 0;
while(nodeIter != nodes.end()) {
QTableWidgetItem* name = new QTableWidgetItem(nodeIter.key());
name->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
QString addrStr = nodeIter.value()->getAddress().toString().c_str();
QTableWidgetItem* address = new QTableWidgetItem(addrStr);
QTableWidgetItem* autoAssign = new QTableWidgetItem();
if(nodeIter.value()->isAutoAddress()) {
autoAssign->setCheckState(Qt::Checked);
}
else {
autoAssign->setCheckState(Qt::Unchecked);
}
QTableWidgetItem* mmtEnable = new QTableWidgetItem();
if(nodeIter.value()->isMmtEnabled()) {
mmtEnable->setCheckState(Qt::Checked);
}
else {
mmtEnable->setCheckState(Qt::Unchecked);
}
QString mmtUidStr;
QTextStream strm(&mmtUidStr);
strm << nodeIter.value()->getMmtUid();
QTableWidgetItem* mmtUid = new QTableWidgetItem(mmtUidStr);
ui->tableWidget->insertRow(row);
qDebug() << "Insert at row "<<row;
ui->tableWidget->setItem(row, 0, name);
ui->tableWidget->setItem(row, 1, address);
ui->tableWidget->setItem(row, 2, autoAssign);
ui->tableWidget->setItem(row, 3, mmtEnable);
ui->tableWidget->setItem(row, 4, mmtUid);
row++;
nodeIter++;
}
qDebug() << "UpdateTable() - End";
}
}
void SpectraIdentificationViewWidget::addCheckboxItemToBottomRow_(bool selected, Size column_index, const QColor& c)
{
QTableWidgetItem * item = table_widget_->itemPrototype()->clone();
if (selected)
{
item->setCheckState(Qt::Checked);
}
else
{
item->setCheckState(Qt::Unchecked);
}
item->setBackgroundColor(c);
table_widget_->setItem(table_widget_->rowCount() - 1, column_index, item);
}
void ParameterEdit::newItem()
{
ParameterProperties pedit(this);
if (pedit.exec() == QDialog::Accepted)
{
QString name = pedit.name();
if(_params.contains(name))
QMessageBox::warning(this, tr("Name already exists"),
tr("<p>The name for the parameter you specified "
"already exists in the list."));
_params[name] = pedit.value();
int r = _table->rowCount();
_table->setRowCount(r+1);
QTableWidgetItem * ctItem = 0;
ctItem = new QTableWidgetItem();
ctItem->setFlags(Qt::ItemIsUserCheckable);
ctItem->setCheckState((pedit.active() ? Qt::Checked : Qt::Unchecked));
_table->setItem(r, 0, ctItem);
_table->setItem(r, 1, new QTableWidgetItem(name));
_table->setItem(r, 2, new QTableWidgetItem(pedit.value().typeName()));
_table->setItem(r, 3, new QTableWidgetItem(pedit.value().toString()));
}
}
void CDlgSmsPhone::FillData( )
{
QString strSql = "select a.cardno, b.carcp, c.username, c.userphone from \
monthcard as a, carinfo as b, userinfo as c \
where a.cardno = b.cardindex and a.cardno = c.cardindex and \
c.userphone <> 'δ֪' and '1' = LEFT( c.userphone, 1 ) \
and 11 = CHAR_LENGTH( c.userphone )";
QStringList lstRows;
CLogicInterface::GetInterface( )->ExecuteSql( strSql, lstRows );
QTableWidgetItem* pItem = NULL;
for ( int nIndex = 0; nIndex < lstRows.size( ); nIndex += 4 ) {
ui->tableWidget->insertRow( 0 );
for ( int nCol = 0; nCol < 5; nCol++ ) {
if ( 4 != nCol ) {
pItem = new QTableWidgetItem( lstRows[ nIndex + nCol ] );
} else {
pItem = new QTableWidgetItem( );
pItem->setCheckState( Qt::Unchecked );
}
ui->tableWidget->setItem( 0, nCol, pItem );
pItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
}
}
}
void QgsGlobePluginDialog::readElevationDatasources()
{
//showMessageBox("reading");
// clear the widget
elevationDatasourcesWidget->clearContents();
elevationDatasourcesWidget->setRowCount( 0 );
int keysCount = QgsProject::instance()->subkeyList( "Globe-Plugin", "/elevationDatasources/" ).count();
for ( int i = 0; i < keysCount; ++i )
{
QString iNum;
iNum.setNum( i );
QTableWidgetItem *type = new QTableWidgetItem(
QgsProject::instance()->readEntry( "Globe-Plugin", "/elevationDatasources/L" + iNum + "/type" ) );
QTableWidgetItem *uri = new QTableWidgetItem(
QgsProject::instance()->readEntry( "Globe-Plugin", "/elevationDatasources/L" + iNum + "/uri" ) );
bool cache = QgsProject::instance()->readBoolEntry( "Globe-Plugin", "/elevationDatasources/L" + iNum + "/cache" );
elevationDatasourcesWidget->setRowCount( 1 + i );
elevationDatasourcesWidget->setItem( i, 0, type );
QTableWidgetItem* chkBoxItem = new QTableWidgetItem();
chkBoxItem->setCheckState( cache ? Qt::Checked : Qt::Unchecked );
elevationDatasourcesWidget->setItem( i, 1, chkBoxItem );
elevationDatasourcesWidget->setItem( i, 2, uri );
}
}
void VidStorAdd::SlotNewStor()
{
VidStor pStor;
UUIDGenerator uuidCreator;
astring strId = uuidCreator.createRandom().toString();
pStor.set_strid(strId);
pStor.set_strname("New Stor");
pStor.set_strip("192.168.0.1");
pStor.set_strport("9080");
pStor.set_struser("admin");
pStor.set_strpasswd("admin");
int insertRow = ui.tableWidget->rowCount();
ui.tableWidget->insertRow(insertRow);
QTableWidgetItem *firstCheck = new VidStorTableItem(pStor, false);
firstCheck->setCheckState(Qt::Checked);
ui.tableWidget->setItem(insertRow, 0, firstCheck);
ui.tableWidget->setItem(insertRow, 1, new QTableWidgetItem(pStor.strname().c_str()));
ui.tableWidget->setItem(insertRow, 2, new QTableWidgetItem(pStor.strip().c_str()));
ui.tableWidget->setItem(insertRow, 3, new QTableWidgetItem(pStor.struser().c_str()));
ui.tableWidget->selectRow(insertRow);
emit(SignalSectionClicked(insertRow, 0));
}
void SubjectsDialog::subjectsReady()
{
const int s = gdata->subjects().size();
this->m_tableWidget->clear();
this->m_tableWidget->setColumnCount(4);
this->m_tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem(QString::fromUtf8("Azonosító")));
this->m_tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem(QString::fromUtf8("Név")));
this->m_tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem(QString::fromUtf8("Rövidítés")));
this->m_tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem(QString::fromUtf8("Kijelölés")));
this->m_tableWidget->setRowCount(s);
this->m_tableWidget->setColumnWidth(1, 200);
for (int i = 0; i < s; ++i) {
const SubjectData sd = gdata->subjects().at(i);
QTableWidgetItem *item = new QTableWidgetItem(QString::number(sd.id));
item->setFlags(Qt::NoItemFlags);
this->m_tableWidget->setItem(i, 0, item);
this->m_tableWidget->setItem(i, 1, new QTableWidgetItem(sd.name));
this->m_tableWidget->setItem(i, 2, new QTableWidgetItem(sd.shortName));
item = new QTableWidgetItem();
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Unchecked);
this->m_tableWidget->setItem(i, 3, item);
}
}
void TOptions::on_m_new_ext_clicked()
{
// As this is a slot that can be called by Qt code (in response to pushing the "New"
// button in the options window, for example), we don't allow exceptions to go out
// from here. So we use a "try" block.
try
{
QDEBUG_METHOD_NAME
m_exts_apps->insertRow(m_exts_apps->rowCount());
m_exts_apps->setCurrentCell(m_exts_apps->rowCount() - 1, 0);
// By default, set the value "false", so for the extension there's no restriction
// of being opened only inside a container file
QTableWidgetItem *checkboxOnlyInsideContainer = new QTableWidgetItem();
checkboxOnlyInsideContainer->setCheckState(Qt::Unchecked);
// To avoid that the user can, for example, write text at the right to the checkbox
checkboxOnlyInsideContainer->setFlags(Qt::ItemFlags(checkboxOnlyInsideContainer->flags() - Qt::ItemIsEditable));
// Finally, we "put" the checkbox inside
m_exts_apps->setItem(m_exts_apps->rowCount() - 1, 1, checkboxOnlyInsideContainer);
}
catch(std::exception &excep)
{
syst.exitBecauseException(excep);
}
catch(...)
{
syst.exitBecauseException();
}
}
void CDlgBulkRegister::AddCheckBoxItem( int nRow, int nCol, QTableWidget* pTable, bool bChecked )
{
QTableWidgetItem* pItem = new QTableWidgetItem( );
pItem->setFlags( Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable );
pItem->setCheckState( bChecked ? Qt::Checked : Qt::Unchecked );
pTable->setItem( nRow, nCol, pItem );
}
void RoomsDialog::roomsReady()
{
const int s = gdata->rooms().size();
this->m_tableWidget->clear();
this->m_tableWidget->setColumnCount(5);
this->m_tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem(QString::fromUtf8("Azonosító")));
this->m_tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem(QString::fromUtf8("Név")));
this->m_tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem(QString::fromUtf8("Rövidítés")));
this->m_tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem(QString::fromUtf8("Helyek")));
this->m_tableWidget->setHorizontalHeaderItem(4, new QTableWidgetItem(QString::fromUtf8("Kijelölés")));
this->m_tableWidget->setRowCount(s);
for (int i = 0; i < s; ++i) {
const RoomData rd = gdata->rooms().at(i);
QTableWidgetItem *item = new QTableWidgetItem(QString::number(rd.id));
item->setFlags(Qt::NoItemFlags);
this->m_tableWidget->setItem(i, 0, item);
this->m_tableWidget->setItem(i, 1, new QTableWidgetItem(rd.name));
this->m_tableWidget->setItem(i, 2, new QTableWidgetItem(rd.shortName));
this->m_tableWidget->setItem(i, 3, new QTableWidgetItem(QString::number(rd.chairs)));
item = new QTableWidgetItem();
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Unchecked);
this->m_tableWidget->setItem(i, 4, item);
}
}
void VidStorAdd::TreeWidgetUpdate()
{
VidStorList storList;
m_pFactory.GetConfDB().GetStorListConf(storList);
int storSize = storList.cvidstor_size();
int nRowCnt = ui.tableWidget->rowCount();
for (s32 j = nRowCnt - 1; j >= 0; j --)
{
ui.tableWidget->removeRow(j);
}
ui.tableWidget->clear();
ui.tableWidget->clearSpans();
for (s32 i = 0; i < storList.cvidstor_size(); i ++)
{
VidStor pStor = storList.cvidstor(i);
//int insertRow = ui.tableWidget->rowCount();
int insertRow = i;
ui.tableWidget->insertRow(insertRow);
QTableWidgetItem *firstCheck = new VidStorTableItem(pStor, false);
firstCheck->setCheckState(Qt::Checked);
ui.tableWidget->setItem(insertRow, 0, firstCheck);
ui.tableWidget->setItem(insertRow, 1, new QTableWidgetItem(pStor.strname().c_str()));
ui.tableWidget->setItem(insertRow, 2, new QTableWidgetItem(pStor.strip().c_str()));
ui.tableWidget->setItem(insertRow, 3, new QTableWidgetItem(pStor.struser().c_str()));
}
}
void MapPreview::setupMapPreview(int mapID)
{
QTableWidgetItem *item;
int numLayers;
ignoreEvents = true;
gvMapPreview->changeMap(mapID);
gvMapPreview->changeLayer(0);
gvMapPreview->changeEditingMode(MapView::EDITMODE_PREVIEW);
gvMapPreview->setupView();
mapRef = new ProjectData::DataReference<Map>(mapID, __FILE__, __LINE__);
numLayers = (*mapRef)->numLayers();
twLayers->setRowCount(numLayers);
for (int i = 0; i < numLayers; ++i)
{
Map::LayerData *layerData = (*mapRef)->getLayerData(i);
item = new QTableWidgetItem();
item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsUserCheckable);
item->setCheckState((layerData->visible) ? Qt::Checked:Qt::Unchecked);
twLayers->setItem(i, 0, item);
item = new QTableWidgetItem(layerData->name);
item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsEditable);
twLayers->setItem(i, 1, item);
twLayers->setRowHeight(i, 16);
}
ignoreEvents = false;
}
void VidCamAdd::SlotNewCam()
{
VidCamera pCam;
UUIDGenerator uuidCreator;
astring strId = uuidCreator.createRandom().toString();
pCam.set_strid(strId);
pCam.set_strname("New Camera");
pCam.set_strip("192.168.0.1");
pCam.set_strport("80");
pCam.set_struser("admin");
pCam.set_strpasswd("admin");
pCam.set_ntype(VID_ONVIF_S);
pCam.set_stronvifaddress("/onvif/device_service");
pCam.set_bmotionjpeg(false);
pCam.set_strrtspurl("rtsp://192.168.0.1:554/Streaming");
astring filePath = "camera.mp4";
pCam.set_strfile(filePath.c_str());
astring *pSched = pCam.add_crecsched();
*pSched = REC_SCHED_ALL_DAY;
int insertRow = ui.tableWidget->rowCount();
ui.tableWidget->insertRow(insertRow);
QTableWidgetItem *firstCheck = new VidCamTableItem(pCam, false);
firstCheck->setCheckState(Qt::Checked);
ui.tableWidget->setItem(insertRow, 0, firstCheck);
ui.tableWidget->setItem(insertRow, 1, new QTableWidgetItem(pCam.strname().c_str()));
ui.tableWidget->setItem(insertRow, 2, new QTableWidgetItem(pCam.strip().c_str()));
ui.tableWidget->setItem(insertRow, 3, new QTableWidgetItem(pCam.struser().c_str()));
ui.tableWidget->selectRow(insertRow);
emit(SignalSectionClicked(insertRow, 0));
}
void QgsGlobePluginDialog::on_elevationAdd_clicked()
{
QString errorText;
bool validationResult = validateResource( elevationCombo->currentText(), elevationPath->text(), errorText );
QMessageBox msgBox;
msgBox.setText( errorText );
msgBox.setInformativeText( tr( "Do you want to add the datasource anyway?" ) );
msgBox.setIcon( QMessageBox::Warning );
msgBox.setStandardButtons( QMessageBox::Ok | QMessageBox::Cancel );
msgBox.setDefaultButton( QMessageBox::Cancel );
if ( validationResult || msgBox.exec() == QMessageBox::Ok )
{
int i = elevationDatasourcesWidget->rowCount();
QTableWidgetItem *type = new QTableWidgetItem( elevationCombo->currentText() );
QTableWidgetItem *uri = new QTableWidgetItem( elevationPath->text() );
QTableWidgetItem* cache = new QTableWidgetItem();
cache->setCheckState(( elevationCombo->currentText() == "Worldwind" ) ? Qt::Checked : Qt::Unchecked ); //worldwind_cache will be active
elevationDatasourcesWidget->setRowCount( 1 + i );
elevationDatasourcesWidget->setItem( i, 0, type );
elevationDatasourcesWidget->setItem( i, 1, cache );
elevationDatasourcesWidget->setItem( i, 2, uri );
elevationDatasourcesWidget->setCurrentItem( type, QItemSelectionModel::Clear );
}
}
void CreateIndexDialog::tableChanged(const QString& new_table)
{
// And fill the table again
QStringList fields = pdb->getObjectByName(new_table).table.fieldNames();
ui->tableIndexColumns->setRowCount(fields.size());
for(int i=0; i < fields.size(); ++i)
{
// Put the name of the field in the first column
QTableWidgetItem* name = new QTableWidgetItem(fields.at(i));
name->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->tableIndexColumns->setItem(i, 0, name);
// Put a checkbox to enable usage in the index of this field in the second column
QTableWidgetItem* enabled = new QTableWidgetItem("");
enabled->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
enabled->setCheckState(Qt::Unchecked);
ui->tableIndexColumns->setItem(i, 1, enabled);
// And put a combobox to select the order in which to index the field in the last column
QComboBox* order = new QComboBox(this);
order->addItem("");
order->addItem("ASC");
order->addItem("DESC");
ui->tableIndexColumns->setCellWidget(i, 2, order);
}
}
void MeasureProperties::setMeasure(Measure* _m)
{
m = _m;
setWindowTitle(tr("MuseScore: Measure Properties for Measure %1").arg(m->no()+1));
m->score()->select(0, SelectType::SINGLE, 0);
m->score()->select(m, SelectType::ADD, 0);
actualZ->setValue(m->len().numerator());
int index = actualN->findText(QString::number(m->len().denominator()));
if (index == -1)
index = 2;
actualN->setCurrentIndex(index);
nominalZ->setNum(m->timesig().numerator());
nominalN->setNum(m->timesig().denominator());
irregular->setChecked(m->irregular());
breakMultiMeasureRest->setChecked(m->breakMultiMeasureRest());
int n = m->repeatCount();
count->setValue(n);
count->setEnabled(m->repeatEnd());
layoutStretch->setValue(m->userStretch());
measureNumberMode->setCurrentIndex(int(m->measureNumberMode()));
measureNumberOffset->setValue(m->noOffset());
Score* score = m->score();
int rows = score->nstaves();
staves->setRowCount(rows);
staves->setColumnCount(3);
for (int staffIdx = 0; staffIdx < rows; ++staffIdx) {
QTableWidgetItem* item = new QTableWidgetItem(QString("%1").arg(staffIdx+1));
staves->setItem(staffIdx, 0, item);
MStaff* ms = m->mstaff(staffIdx);
item = new QTableWidgetItem(tr("visible"));
item->setFlags(item->flags() | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(ms->_visible ? Qt::Checked : Qt::Unchecked);
if (rows == 1) // cannot be invisible if only one row
item->setFlags(item->flags() & ~Qt::ItemIsEnabled);
staves->setItem(staffIdx, 1, item);
item = new QTableWidgetItem(tr("stemless"));
item->setFlags(item->flags() | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(ms->_slashStyle ? Qt::Checked : Qt::Unchecked);
staves->setItem(staffIdx, 2, item);
}
}
/*!
*/
void TOptions::updateOptionsRows()
{
// As this is a slot that can be called by Qt code (in response to pushing the "Restore
// defaults" button in the options window, for example), we don't allow exceptions to go
// out from here. So we use a "try" block
try
{
QDEBUG_METHOD_NAME
m_seconds->setValue(m_settings->value("seconds").toInt());
QStringList exts = m_settings->value("exts").toStringList();
QStringList apps = m_settings->value("apps").toStringList();
QVariantList onlyInsideContainer = m_settings->value("onlyInsideContainer").toList();
// Delete rows if they are found
if (m_exts_apps->rowCount() > 0)
{
bool success = m_exts_apps->model()->removeRows(0, m_exts_apps->rowCount());
if (not success)
{
QString message = tr("Error 2108091: A problem was found and a row could not be deleted.");
throw runtime_error(message.toStdString());
}
}
// Insert rows
int quant_elements = exts.count();
for(int i = 0; i < quant_elements; i++)
{
m_exts_apps->insertRow(m_exts_apps->rowCount());
m_exts_apps->setItem(i, 0, new QTableWidgetItem(exts.value(i)));
qDebug() << TDebugStartEnd::indentation << exts.value(i);
qDebug() << TDebugStartEnd::indentation << onlyInsideContainer.value(i).toBool();
QTableWidgetItem *checkboxOnlyInsideContainer = new QTableWidgetItem();
checkboxOnlyInsideContainer->setCheckState(onlyInsideContainer.value(i).toBool()?Qt::Checked:Qt::Unchecked);
// To avoid that the user can, for example, write text at the right to the checkbox
checkboxOnlyInsideContainer->setFlags(Qt::ItemFlags(checkboxOnlyInsideContainer->flags() - Qt::ItemIsEditable));
// Finally, we "put" the checkbox inside
m_exts_apps->setItem(i, 1, checkboxOnlyInsideContainer);
qDebug() << TDebugStartEnd::indentation << apps.value(i);
m_exts_apps->setItem(i, 2, new QTableWidgetItem(apps.value(i)));
}
m_folder->setText(m_settings->value("folder").toString());
m_shared->setText(m_settings->value("resource").toString());
}
catch(std::exception &excep)
{
syst.exitBecauseException(excep);
}
catch(...)
{
syst.exitBecauseException();
}
}
void ParamCompareDialog::checkAll()
{
QLOG_DEBUG() << " check uncheck all parameters";
QTableWidget* table = ui->compareTableWidget;
if(ui->checkAllBox->isChecked()){
for(int rowCount = 0; rowCount < table->rowCount(); ++rowCount){
QTableWidgetItem* item = table->item(rowCount, PCD_COLUMN_CHECKBOX);
if (item) item->setCheckState(Qt::Checked);
}
} else {
for(int rowCount = 0; rowCount < table->rowCount(); ++rowCount){
QTableWidgetItem* item = table->item(rowCount, PCD_COLUMN_CHECKBOX);
if (item) item->setCheckState(Qt::Unchecked);
}
}
}
void UAreaResultsTable::unselectTableNotesPage()
{
for (int i = 0; i < tableNotes->rowCount(); i++)
{
QTableWidgetItem *item = tableNotes->item(i, indexMainColumn);
item->setCheckState(Qt::Unchecked);
}
}
void UAreaResultsTable::selectAllTableRecycleBinPage()
{
for (int i = 0; i < tableRecycleBin->rowCount(); i++)
{
QTableWidgetItem *item = tableRecycleBin->item(i, indexMainColumn);
item->setCheckState(Qt::Checked);
}
}
