void model_import_dlg::on_texture_dialog_done(bool add, QString path, QString type)
{
QTableWidget * table = mesh_tab->findChild<QTableWidget*>("texturesTable");
int row = 0;
if (add)
{
row = table->rowCount();
table->insertRow(row);
}
else
{
row = table->currentRow();
}
table->setItem(row, 0, new QTableWidgetItem(path));
table->setItem(row, 1, new QTableWidgetItem(type));
table->setColumnWidth(0, 350);
table->setColumnWidth(1, 150);
for (int i = 0; i < table->rowCount(); i++)
for (int j = 0; j < table->columnCount(); j++)
table->item(i, j)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
}
Mat UIUtil::getMatFromQtable(QTableWidget &table) {
Mat_<double> mat(table.rowCount(), table.columnCount());
for (int row = 0; row < table.rowCount(); row++) {
for (int col = 0; col < table.columnCount(); col++) {
if (table.item(row, col) != NULL)
mat(row, col) = table.item(row, col)->text().toDouble();
else
mat(row, col) = 0;
}
}
return mat;
}
void tablewidget::selectTableRow( QTableWidgetItem * current,QTableWidgetItem * previous )
{
QTableWidget * table ;
int col = 0 ;
int i = 0 ;
int j = 0 ;
if( current && previous ){
if( previous->row() == current->row() ){
table = current->tableWidget() ;
table->setCurrentCell( current->row(),table->columnCount() - 1 ) ;
table->setFocus() ;
return ;
}
}
if( current ){
table = current->tableWidget() ;
if( table->rowCount() > 0 ){
col = table->columnCount() ;
j = current->row() ;
for( i = 0 ; i < col ; i++ ){
table->item( j,i )->setSelected( true ) ;
}
}
table->setCurrentCell( j,table->columnCount() -1 ) ;
table->setFocus() ;
}
if( previous ){
table = previous->tableWidget() ;
if( table->rowCount() > 0 ){
col = table->columnCount() ;
j = previous->row() ;
for( i = 0 ; i < col ; i++ ){
table->item( j,i )->setSelected( false ) ;
}
}
table->setFocus() ;
}
}
void HideElementIf(QTableWidget& list, QLabel& cntLabel, Pred&& f)
{
auto filterCnt = 0;
for (auto i = 0; i < list.rowCount(); ++i)
{
auto item = list.item(i, 0);
auto filterRes = f(item);
filterCnt += !filterRes;
list.setRowHidden(i, filterRes);
}
cntLabel.setText(QString("Showing %1 signals of %2").arg(filterCnt).arg(list.rowCount()));
}
void ShortcutsWidget::loadShortcuts(QSettings &settings)
{
MenuItems items = menuItems();
::loadShortcuts(&items, settings);
m_actions.clear();
m_shortcuts.clear();
QTableWidget *table = ui->tableWidget;
while (table->rowCount() > 0)
table->removeRow(0);
foreach (const MenuItem &item, items) {
MenuAction action;
action.iconName = item.iconName;
action.iconId = item.iconId;
action.text = item.text;
action.settingsKey = item.settingsKey;
const int row = table->rowCount();
table->insertRow(row);
QTableWidgetItem *tableItem = new QTableWidgetItem();
table->setItem(row, Columns::Empty, tableItem);
tableItem->setFlags(Qt::NoItemFlags);
tableItem = new QTableWidgetItem();
action.tableItem = tableItem;
table->setItem(row, Columns::Icon, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem(uiText(action.text));
table->setItem(row, Columns::Text, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
action.shortcutButton = new ShortcutButton(table);
table->setCellWidget(row, Columns::Shortcut, action.shortcutButton);
action.shortcutButton->setDefaultShortcut(item.defaultShortcut);
foreach (const QKeySequence &shortcut, item.shortcuts)
action.shortcutButton->addShortcut(shortcut);
action.iconId = item.iconId;
m_actions.append(action);
m_shortcuts << item.shortcuts;
m_timerCheckAmbiguous.start();
connect( action.shortcutButton, SIGNAL(shortcutAdded(QKeySequence)),
this, SLOT(onShortcutAdded(QKeySequence)) );
connect( action.shortcutButton, SIGNAL(shortcutRemoved(QKeySequence)),
this, SLOT(onShortcutRemoved(QKeySequence)) );
}
static void plugins_add_description(const char *name, const char *version,
const char *types, const char *filename,
void *user_data )
{
QTableWidget *tbPlugins = (QTableWidget *)user_data;
tbPlugins->setRowCount(tbPlugins->rowCount() + 1);
tbPlugins->setItem(tbPlugins->rowCount()-1, 0, new QTableWidgetItem(name));
tbPlugins->setItem(tbPlugins->rowCount()-1, 1, new QTableWidgetItem(version));
tbPlugins->setItem(tbPlugins->rowCount()-1, 2, new QTableWidgetItem(types));
tbPlugins->setItem(tbPlugins->rowCount()-1, 3, new QTableWidgetItem(filename));
}
///
/// \brief Form_PlatformConfiguration::traversalControl
/// \param q
/// save
///
void Form_PlatformConfiguration::traversalControl(const QObjectList& q)
{
for(int i=0;i<q.length();i++)
{
if(!q.at(i)->children().empty())
{
traversalControl(q.at(i)->children());
}
QObject* o = q.at(i);
if (o->inherits("QLineEdit"))
{
QLineEdit* b = qobject_cast<QLineEdit*>(o);
QDomElement qe= doc_config.createElement(b->objectName());
qe.setAttribute("Value",b->text());
qe.setAttribute("Type","QLineEdit");
doc_config.firstChildElement("root").appendChild(qe);
}
else if (o->inherits("QGroupBox"))
{
QGroupBox* b = qobject_cast<QGroupBox*>(o);
QDomElement qe= doc_config.createElement(b->objectName());
qe.setAttribute("Value",b->isChecked());
qe.setAttribute("Type","QGroupBox");
doc_config.firstChildElement("root").appendChild(qe);
}
else if (o->inherits("QTableWidget"))
{
QTableWidget * b = qobject_cast<QTableWidget*>(o);
int col_rate = b->objectName() == "table_labels" ? 1:0;
QDomElement qe= doc_config.createElement(b->objectName());
qe.setAttribute("Value_R",b->rowCount());
qe.setAttribute("Value_C",b->columnCount());
qe.setAttribute("Type","QTableWidget");
for(int i =0 ; i<b->rowCount() ;i++)
{
QDomElement item= doc_config.createElement("R"+QString::number(i));
for(int j=0 ;j <b->columnCount() - col_rate; j++)
{
item.setAttribute("C"+QString::number(j), b->item(i,j)->text());
}
qe.appendChild(item);
}
doc_config.firstChildElement("root").appendChild(qe);
}
}
}
void PublicTalks::beforePublicTalkComboBoxShown(int rownumber)
{
// themes combobox
cPersonComboBox *c = static_cast<cPersonComboBox *>(maintable->cellWidget(rownumber,2));
cPersonComboBox *speakerCombo = static_cast<cPersonComboBox *>(maintable->cellWidget(rownumber,3));
QString currentThemeText = c->currentText();
QTableWidget *table;
cpersons cp;
person *speaker = cp.getPerson(speakerCombo->currentText());
if (speaker) {
// the speaker selected --> will be shown speaker's themes
table = this->getSpeakerPublicTalks(0,speaker->id, currentThemeText);
} else {
// no speaker selected --> all themes will be shown
table = this->getPublicTalksbyLang(currentThemeText);
}
// schoolComboBox *sc = static_cast<schoolComboBox *>(ui->tableSchoolEdit->cellWidget(row,col));
qDebug() << QString::number(table->rowCount());
table->setSortingEnabled(true);
table->sortByColumn(0,Qt::AscendingOrder);
table->verticalHeader()->hide();
table->setColumnWidth(0,40);
table->setColumnWidth(1,200);
table->setColumnWidth(2,80);
table->setMinimumWidth(340);
c->clear();
c->setModel(table->model());
c->setView(table);
c->setModelColumn(1);
c->setCurrentIndex(c->findText(currentThemeText,Qt::MatchExactly));
}
void TableView::addRow(types::Data &data, int fid)
{
QTableWidget* table = getTableWidget();
if(0!=table)
{
if(fid>=table->rowCount())
{
table->setRowCount(fid+50);
}
unsigned int size = data.size();
if(table->columnCount()<(int)size)
{
size = table->columnCount();
}
for(unsigned int i=0;i<size;i++)
{
table->setItem(fid,i,new QTableWidgetItem(QString("%1").arg(data[i])));
}
table->selectRow(fid);
if(_realcount<fid)
{
_realcount = fid;
}
}
}
void ShortcutsWidget::loadShortcuts(const QSettings &settings)
{
MenuItems items = menuItems();
::loadShortcuts(&items, settings);
m_actions.clear();
m_shortcuts.clear();
QTableWidget *table = ui->tableWidget;
while (table->rowCount() > 0)
table->removeRow(0);
for (const auto &item : items) {
MenuAction action;
action.iconName = item.iconName;
action.iconId = item.iconId;
action.text = item.text;
action.settingsKey = item.settingsKey;
addShortcutRow(action);
action.shortcutButton->setDefaultShortcut(item.defaultShortcut);
for (const auto &shortcut : item.shortcuts)
action.shortcutButton->addShortcut(shortcut);
}
addCommands( loadAllCommands() );
addCommands( predefinedCommands() );
}
QVector<QVariantList> DebugPanel::getBreakpoints()
{
QTableWidget *table = ui->breakpointTableWidget;
QVector<QVariantList> breakpoints;
for (int row = 0; row < table->rowCount(); row++) {
QVariantList bp;
QCheckBox *cb = static_cast<QCheckBox *>(table->cellWidget(row,0));
if (cb->isChecked()) {
QTableWidgetItem *item = table->item(row,1);
bp << item->data(Qt::DisplayRole).toString();
if (bp.back().toString() == "instr" ) {
item = table->item(row,2);
bp << item->data(Qt::DisplayRole).toDouble();
item = table->item(row,3);
bp << item->data(Qt::DisplayRole).toInt();
breakpoints.append(bp);
} else {
item = table->item(row,2);
QStringList parts = item->data(Qt::DisplayRole).toString().split(":");
Q_ASSERT(parts.size() == 2);
bp << parts[0].toInt();
bp << parts[1].toInt();
item = table->item(row,3);
bp << item->data(Qt::DisplayRole).toInt();
breakpoints.append(bp);
}
}
}
return breakpoints;
}
void ShortcutsWidget::addShortcutRow(MenuAction &action)
{
QTableWidget *table = ui->tableWidget;
const int row = table->rowCount();
table->insertRow(row);
auto tableItem = new QTableWidgetItem();
action.tableItem = tableItem;
table->setItem(row, Columns::Icon, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem(uiText(action.text));
table->setItem(row, Columns::Text, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem();
table->setItem(row, Columns::Type, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
if (action.command.type() & CommandType::GlobalShortcut) {
tableItem->setIcon( getIcon("", IconExternalLinkSquareAlt) );
tableItem->setToolTip( tr("Shortcut can be triggered from any application") );
}
action.shortcutButton = new ShortcutButton(table);
table->setCellWidget(row, Columns::Shortcut, action.shortcutButton);
m_actions.append(action);
connect( action.shortcutButton, &ShortcutButton::shortcutAdded,
this, &ShortcutsWidget::onShortcutAdded );
connect( action.shortcutButton, &ShortcutButton::shortcutRemoved,
this, &ShortcutsWidget::onShortcutRemoved );
}
void GraphPlotDialog::setGraphVisibility(int currentVisibility)
{
QTableWidget *currentList = NULL;
QTableWidget *endList = NULL;
if (currentVisibility == 1) {
currentList = mUi.visibleGraph;
endList = mUi.invisibleGraph;
}
else if (currentVisibility == 0) {
currentList = mUi.invisibleGraph;
endList = mUi.visibleGraph;
}
else {
return;
}
QTableWidgetItem *item = currentList->takeItem(currentList->currentRow(), 0);
QTableWidgetItem *valueItem = currentList->takeItem(currentList->currentRow(), 1);
if (!item || !valueItem) {
return;
}
currentList->removeRow(currentList->currentRow());
unsigned graphId = item->data(Qt::UserRole).toUInt();
mData[graphId].isSelected = false;
int rowCount = endList->rowCount();
endList->setRowCount(rowCount + 1);
endList->setItem(rowCount, 0, item);
endList->setItem(rowCount, 1, valueItem);
}
// Slot.
void
TransitionEditorWindow::createPoint(unsigned int pointType, float time, float value)
{
if (model_ == nullptr) return;
if (transition_ == nullptr) return;
if (pointType < 2 || pointType > 4) {
qCritical("Invalid point type: %u", pointType);
return;
}
TransitionPoint newPoint;
newPoint.type = static_cast<TRMControlModel::Transition::Point::Type>(pointType);
newPoint.value = value;
newPoint.freeTime = time;
QTableWidget* table = ui_->pointsTable;
if (table->rowCount() == 0) {
pointList_.push_back(std::move(newPoint));
} else {
// Insert point at the end of the group.
auto iter = pointList_.begin();
auto end = pointList_.end();
while (iter != end && static_cast<unsigned int>(iter->type) <= pointType) {
++iter;
}
pointList_.insert(iter, std::move(newPoint));
}
updateTransition();
ui_->pointsTable->setCurrentItem(nullptr);
ui_->equationsTree->setCurrentItem(nullptr);
}
void ItemTagsLoader::addTagToSettingsTable(const ItemTagsLoader::Tag &tag)
{
QTableWidget *t = ui->tableWidget;
const int row = t->rowCount();
t->insertRow(row);
t->setItem( row, tagsTableColumns::name, new TagTableWidgetItem(tag.name) );
t->setItem( row, tagsTableColumns::match, new QTableWidgetItem(tag.match) );
t->setItem( row, tagsTableColumns::styleSheet, new QTableWidgetItem(tag.styleSheet) );
t->setItem( row, tagsTableColumns::color, new QTableWidgetItem() );
t->setItem( row, tagsTableColumns::icon, new QTableWidgetItem() );
auto colorButton = new QPushButton(t);
const QColor color = tag.color.isEmpty()
? QColor::fromRgb(50, 50, 50)
: deserializeColor(tag.color);
setColorIcon(colorButton, color);
t->setCellWidget(row, tagsTableColumns::color, colorButton);
connect(colorButton, &QAbstractButton::clicked, this, &ItemTagsLoader::onColorButtonClicked);
auto iconButton = new IconSelectButton(t);
iconButton->setCurrentIcon(tag.icon);
t->setCellWidget(row, tagsTableColumns::icon, iconButton);
connect(iconButton, &IconSelectButton::currentIconChanged, this, &ItemTagsLoader::onAllTableWidgetItemsChanged);
onTableWidgetItemChanged(t->item(row, 0));
}
void ListingTracePane::setDebuggingState(bool b)
{
QTableWidget *tableWidget;
if (Sim::trapped) {
tableWidget = ui->listingPepOsTraceTableWidget;
ui->listingPepOsTraceTableWidget->show();
ui->listingTraceTableWidget->hide();
}
else {
tableWidget = ui->listingTraceTableWidget;
ui->listingPepOsTraceTableWidget->hide();
ui->listingTraceTableWidget->show();
}
for (int i = 0; i < tableWidget->rowCount(); i++) {
tableWidget->item(i, 1)->setBackgroundColor(Qt::white);
tableWidget->item(i, 1)->setTextColor(Qt::black);
}
highlightedItemList.clear();
if (b && Pep::memAddrssToAssemblerListing->contains(Sim::programCounter)) {
QTableWidgetItem *highlightedItem = tableWidget->item(Pep::memAddrssToAssemblerListing->value(Sim::programCounter), 1);
highlightedItem->setBackgroundColor(QColor(56, 117, 215));
highlightedItem->setTextColor(Qt::white);
highlightedItemList.append(highlightedItem);
tableWidget->scrollToItem(highlightedItem);
}
tableWidget->horizontalScrollBar()->setValue(tableWidget->horizontalScrollBar()->minimum());
// resizeDocWidth();
}
void SkillEditFrame::onCurrentItemChanged(DataContainerItem *current) {
if (current == 0)
return;
QTableWidget *skillTable = this->findChild<QTableWidget *>("skillTable");
DataContainerItem *item = current;
if (item->getStringData().size() > 0) {
StatsContainer *skill = GenStatsReader::getContainer(*skillStats, item->getStringData());
if (skill != 0) {
typedef std::map<std::string, std::string> StringMap;
StringMap dataMap = skill->getBaseDataMap();
for (int i=0; i<skillTable->rowCount(); ++i) {
for (int j=0; j<skillTable->columnCount(); ++j) {
delete skillTable->item(i, j);
}
}
skillTable->setRowCount(0);
int row = 0;
for (StringMap::iterator it = dataMap.begin(); it != dataMap.end(); ++it) {
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setText(it->first.c_str());
QTableWidgetItem *valueItem = new QTableWidgetItem();
valueItem->setText(it->second.c_str());
skillTable->insertRow(row);
skillTable->setItem(row, 0, nameItem);
skillTable->setItem(row, 1, valueItem);
++row;
}
skillTable->resizeRowsToContents();
skillTable->resizeColumnsToContents();
}
}
}
static QTableWidget* createFilesTable(const QStringList &fileNames)
{
QTableWidget *table = new QTableWidget(0, 2);
table->setSelectionMode(QAbstractItemView::NoSelection);
QStringList labels({
QCoreApplication::translate("AddImageToResources","Filename"),
QCoreApplication::translate("AddImageToResources","Size")
});
table->setHorizontalHeaderLabels(labels);
table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
table->verticalHeader()->hide();
table->setShowGrid(false);
for (const QString &filePath : fileNames) {
const QString toolTip = QDir::toNativeSeparators(filePath);
const QString fileName = QFileInfo(filePath).fileName();
const qint64 size = QFileInfo(filePath).size() / 1024;
QTableWidgetItem *fileNameItem = new QTableWidgetItem(fileName);
fileNameItem->setToolTip(toolTip);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem = new QTableWidgetItem(QString::number(size) + " KB");
sizeItem->setToolTip(toolTip);
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = table->rowCount();
table->insertRow(row);
table->setItem(row, 0, fileNameItem);
table->setItem(row, 1, sizeItem);
}
return table;
}
void ParameterWin::somethingChanged(QTableWidgetItem *twi)
{
QSettings settings("DoLong Inc", "Command");
QVector <command_attr_t *> cVector;
QString tabName = tabWidget->tabText(tabWidget->currentIndex());
for (int j = 0; j < Command::commandSize(); ++j) {
if (userCommand[j].tableName == tabName) {
cVector.append(&userCommand[j]);
}
}
QTableWidget * tableWidget = twi->tableWidget();
int whichitem = tableWidget->rowCount() * twi->column() + twi->row();
QString string = cVector.at(whichitem)->commandName;
cVector.at(whichitem)->paraValue = twi->text();
if (cVector.at(whichitem)->paraAttr & SAVE) { //存储数据
settings.setValue(string, twi->text());
}
float value = twi->text().toFloat();
int setValue = value * cVector.at(whichitem)->paraCoe;
//serialPortThread->addTransaction(requestToByteArray(string, QString::number(setValue)));
emit sendData(Command::requestToByteArray(string, QString::number(setValue)));
qDebug() << string << "= " << QString::number(setValue);
}
void ItemSyncLoader::onBrowseButtonClicked()
{
QTableWidget *t = ui->tableWidgetSyncTabs;
QObject *button = sender();
Q_ASSERT(button != nullptr);
int row = 0;
for ( ; row < t->rowCount() && t->cellWidget(row, syncTabsTableColumns::browse) != button; ++row ) {}
Q_ASSERT(row != t->rowCount());
QTableWidgetItem *item = t->item(row, syncTabsTableColumns::path);
const QString path =
QFileDialog::getExistingDirectory( t, tr("Open Directory for Synchronization"), item->text() );
if ( !path.isEmpty() )
item->setText(path);
}
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 GlobePlugin::elevationLayersChanged()
{
if ( mIsGlobeRunning )
{
QgsDebugMsg( "elevationLayersChanged: Globe Running, executing" );
osg::ref_ptr<Map> map = mMapNode->getMap();
if ( map->getNumElevationLayers() > 1 )
{
mOsgViewer->getDatabasePager()->clear();
}
// Remove elevation layers
ElevationLayerVector list;
map->getElevationLayers( list );
for ( ElevationLayerVector::iterator i = list.begin(); i != list.end(); ++i )
{
map->removeElevationLayer( *i );
}
// Add elevation layers
QSettings settings;
QString cacheDirectory = settings.value( "cache/directory", QgsApplication::qgisSettingsDirPath() + "cache" ).toString();
QTableWidget* table = mSettingsDialog->elevationDatasources();
for ( int i = 0; i < table->rowCount(); ++i )
{
QString type = table->item( i, 0 )->text();
//bool cache = table->item( i, 1 )->checkState();
QString uri = table->item( i, 2 )->text();
ElevationLayer* layer = 0;
if ( "Raster" == type )
{
GDALOptions options;
options.url() = uri.toStdString();
layer = new osgEarth::ElevationLayer( uri.toStdString(), options );
}
else if ( "TMS" == type )
{
TMSOptions options;
options.url() = uri.toStdString();
layer = new osgEarth::ElevationLayer( uri.toStdString(), options );
}
map->addElevationLayer( layer );
//if ( !cache || type == "Worldwind" ) layer->setCache( 0 ); //no tms cache for worldwind (use worldwind_cache)
}
#if OSGEARTH_VERSION_GREATER_OR_EQUAL( 2, 5, 0 )
double scale = QgsProject::instance()->readDoubleEntry( "Globe-Plugin", "/verticalScale", 1 );
setVerticalScale( scale );
#endif
}
else
{
QgsDebugMsg( "layersChanged: Globe NOT running, skipping" );
return;
}
}
QVariantMap ItemSyncLoader::applySettings()
{
// Apply settings from tab sync path table.
QTableWidget *t = ui->tableWidgetSyncTabs;
QStringList tabPaths;
m_tabPaths.clear();
for (int row = 0; row < t->rowCount(); ++row) {
const QString tabName = t->item(row, syncTabsTableColumns::tabName)->text();
if ( !tabName.isEmpty() ) {
const QString tabPath = t->item(row, syncTabsTableColumns::path)->text();
tabPaths << tabName << tabPath;
m_tabPaths.insert(tabName, tabPath);
}
}
m_settings.insert(configSyncTabs, tabPaths);
// Apply settings from file format table.
t = ui->tableWidgetFormatSettings;
QVariantList formatSettings;
m_formatSettings.clear();
for (int row = 0; row < t->rowCount(); ++row) {
FileFormat fileFormat;
fileFormat.extensions = t->item(row, formatSettingsTableColumns::formats)->text()
.split( QRegExp("[,;\\s]"), QString::SkipEmptyParts );
fileFormat.itemMime = t->item(row, formatSettingsTableColumns::itemMime)->text();
if ( fileFormat.extensions.isEmpty() && fileFormat.itemMime.isEmpty() )
continue;
fileFormat.icon = t->cellWidget(row, formatSettingsTableColumns::icon)
->property("currentIcon").toString();
QVariantMap format;
format["formats"] = fileFormat.extensions;
format["itemMime"] = fileFormat.itemMime;
format["icon"] = fileFormat.icon;
formatSettings.append(format);
fixUserExtensions(&fileFormat.extensions);
fixUserMimeType(&fileFormat.itemMime);
m_formatSettings.append(fileFormat);
}
m_settings.insert(configFormatSettings, formatSettings);
return m_settings;
}
void MainWindow::actualizarSeleccionado()
{
Persona *p = selectedPersona;
QTableWidget * t = ui->tableWidget;
for (int i = 0; i < t->rowCount(); i++) {
if (t->item(i, 0)->text().toLong() == p->id()) {
updateRow( i, p);
}
}
}
void QgsMessageLogViewer::logMessage( QString message, QString tag, QgsMessageLog::MessageLevel level )
{
#ifdef ANDROID
mCount++;
#else
mButton->setToolTip( tr( "%1 message(s) logged." ).arg( mCount++ ) );
#endif
if ( !isVisible() && level > QgsMessageLog::INFO )
{
mButton->show();
if ( mShowToolTips )
QToolTip::showText( mButton->mapToGlobal( QPoint( 0, 0 ) ), mButton->toolTip() );
}
if ( tag.isNull() )
tag = tr( "General" );
int i;
for ( i = 0; i < tabWidget->count() && tabWidget->tabText( i ) != tag; i++ )
;
QTableWidget *w;
if ( i < tabWidget->count() )
{
w = qobject_cast<QTableWidget *>( tabWidget->widget( i ) );
tabWidget->setCurrentIndex( i );
}
else
{
w = new QTableWidget( 0, 3, this );
w->verticalHeader()->setDefaultSectionSize( 16 );
w->verticalHeader()->setResizeMode( QHeaderView::ResizeToContents );
w->verticalHeader()->setVisible( false );
w->setGridStyle( Qt::DotLine );
w->setEditTriggers( QAbstractItemView::NoEditTriggers );
w->setHorizontalScrollMode( QAbstractItemView::ScrollPerPixel );
w->setVerticalScrollMode( QAbstractItemView::ScrollPerPixel );
w->setHorizontalHeaderLabels( QStringList() << tr( "Timestamp" ) << tr( "Message" ) << tr( "Level" ) );
tabWidget->addTab( w, tag );
tabWidget->setCurrentIndex( tabWidget->count() - 1 );
}
int n = w->rowCount();
w->setRowCount( n + 1 );
QTableWidgetItem *item = new QTableWidgetItem( QDateTime::currentDateTime().toString( Qt::ISODate ) );
w->setItem( n, 0, item );
w->setItem( n, 1, new QTableWidgetItem( message ) );
w->setItem( n, 2, new QTableWidgetItem( QString::number( level ) ) );
w->scrollToBottom();
w->horizontalHeader()->resizeSections( QHeaderView::ResizeToContents );
}
void NotifyItemDelegate::selectRow(const QString & text)
{
QComboBox *combo = qobject_cast<QComboBox *>(sender());
QTableWidget *table = new QTableWidget;
table = (QTableWidget *)(combo->parent());
qNotifyDebug() << table->columnCount();
qNotifyDebug() << table->rowCount();
qNotifyDebug() << table->currentRow();
}
void QgsMessageLogViewer::closeTab( int index )
{
QTableWidget *w = qobject_cast<QTableWidget *>( tabWidget->widget( index ) );
if ( w )
{
mCount -= w->rowCount();
if ( mButton )
mButton->setToolTip( tr( "%1 message(s) logged." ).arg( mCount++ ) );
}
tabWidget->removeTab( index );
}
int SearchGrid(QTableWidget& Widget, const CCylinderController& Controller, const IQTableFunctors& Functor)
{
auto Index(-1);
for (auto Row(0); Row < Widget.rowCount(); ++Row)
{
Index = Functor(Widget, Controller, Row);
if (Index != -1) { break; }
}
return Index;
}
QListViewItemExt::QListViewItemExt(QTableWidgetItem* item)
:QTableWidgetItem()
{
QTableWidget* parent = item->tableWidget();
mParent = parent;
mRow = parent->rowCount();
parent->insertRow(mRow);
parent->setItem(mRow, 0, this);
mIndex = -1;
mHiddenText = QString::null;
}
void DebugPanel::setVariableList(QVector<QVariantList> varList)
{
QTableWidget *table = ui->stackTableWidget;
table->setRowCount(0);
int row = 0, column = 0;
foreach(QVariantList var, varList) {
table->insertRow(table->rowCount());
column = 0;
foreach(QVariant part, var) {
QTableWidgetItem *item = new QTableWidgetItem(part.toString());
table->setItem(row, column, item);
column++;
}