void ConformerList::load()
{
QTableWidget* table(m_conformerListConfigurator.energyTable);
QList<Layer::Conformer*>
conformers(m_conformerList->findLayers<Layer::Conformer>(Layer::Children));
table->setRowCount(conformers.size());
QTableWidgetItem* energy;
int row(0);
QList<Layer::Conformer*>::iterator iter;
for (iter = conformers.begin(); iter != conformers.end(); ++iter) {
energy = new QTableWidgetItem( (*iter)->text() );
energy->setTextAlignment(Qt::AlignCenter|Qt::AlignVCenter);
energy->setData(Qt::UserRole, QVariantPointer<Layer::Conformer>::toQVariant(*iter));
table->setItem(row, 0, energy);
++row;
}
if (conformers.size() < 2) {
m_conformerListConfigurator.playButton->setEnabled(false);
m_conformerListConfigurator.forwardButton->setEnabled(false);
m_conformerListConfigurator.backButton->setEnabled(false);
m_conformerListConfigurator.bounceButton->setEnabled(false);
m_conformerListConfigurator.updateBondsButton->setEnabled(false);
m_conformerListConfigurator.speedSlider->setEnabled(false);
m_conformerListConfigurator.speedLabel->setEnabled(false);
}
}
QTableWidgetItem* catalogueTableWidget::setItem( int Row, int Column, const QString& Title, const QVariant& Data )
{
QTableWidgetItem *Item = new QTableWidgetItem( Title );
Item->setText( Title );
Item->setData( Qt::UserRole, Data );
return setItem( Row, Column, Item );
}
void Window::createGUI()
{
QList<QPair<QString, QColor> > list;
list << QPair<QString, QColor>(tr("Alice"), QColor("aliceblue")) <<
QPair<QString, QColor>(tr("Neptun"), QColor("aquamarine")) <<
QPair<QString, QColor>(tr("Ferdinand"), QColor("springgreen"));
QTableWidget *table = new QTableWidget(3, 2);
table->setHorizontalHeaderLabels(QStringList() << tr("Name")
<< tr("Hair Color"));
table->verticalHeader()->setVisible(false);
table->resize(150, 50);
for (int i = 0; i < 3; ++i) {
QPair<QString, QColor> pair = list.at(i);
QTableWidgetItem *nameItem = new QTableWidgetItem(pair.first);
QTableWidgetItem *colorItem = new QTableWidgetItem;
colorItem->setData(Qt::DisplayRole, pair.second);
table->setItem(i, 0, nameItem);
table->setItem(i, 1, colorItem);
}
table->resizeColumnToContents(0);
table->horizontalHeader()->setStretchLastSection(true);
QGridLayout *layout = new QGridLayout;
layout->addWidget(table, 0, 0);
setLayout(layout);
setWindowTitle(tr("Color Editor Factory"));
}
void MusicLrcSearchTableWidget::creatSearchedItems(const QString &songname,
const QString &artistname, const QString &time)
{
int count;
setRowCount(count = m_downLoadManager->getSongIdIndex());
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(MUSIC_CHECK_ROLE, false);
setItem(count - 1, 0, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(songname, Qt::ElideRight, 170));
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(songname);
setItem(count - 1, 1, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(artistname, Qt::ElideRight, 144));
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(artistname);
setItem(count - 1, 2, item);
item = new QTableWidgetItem(time);
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
setItem(count - 1, 3, item);
item = new QTableWidgetItem;
item->setIcon(QIcon(QString::fromUtf8(":/radio/collect")));
setItem(count - 1, 4, item);
}
foreach (const QString &genre, genres) {
QTableWidgetItem *item = new QTableWidgetItem(genre);
item->setData(Qt::UserRole, genre);
int row = ui->genres->rowCount();
ui->genres->insertRow(row);
ui->genres->setItem(row, 0, item);
}
void
SeqLenAnalysis::redraw()
{
while (ui->seqLenTable->rowCount() > 0) {
ui->seqLenTable->removeRow(0);
}
for (auto& data: m_data[m_currentK]) {
ui->seqLenTable->insertRow(0);
auto add = [&](int x, QVariant value) {
QTableWidgetItem* w = new QTableWidgetItem;
w->setData(Qt::DisplayRole, value);
ui->seqLenTable->setItem(0, x, w);
m_widgetData[w] = &data;
};
add(0, data.bit);
add(1, data.n);
add(2, data.mean);
add(3, data.stddev);
add(4, data.min);
add(5, data.max);
}
}
void ccPointPairRegistrationDlg::addPointToTable(QTableWidget* tableWidget, int rowIndex, const CCVector3d& P, QString pointName)
{
assert(tableWidget);
if (!tableWidget)
return;
//add corresponding row in table
tableWidget->setRowCount(std::max<int>(rowIndex + 1, tableWidget->rowCount()));
tableWidget->setVerticalHeaderItem(rowIndex, new QTableWidgetItem(pointName));
//add point coordinates
for (int d = 0; d < 3; ++d)
{
QTableWidgetItem* item = new QTableWidgetItem();
item->setData(Qt::EditRole, QString::number(P.u[d], 'f', 6));
tableWidget->setItem(rowIndex, XYZ_COL_INDEX + d, item);
}
//add 'remove' button
{
if (rowIndex == 0)
tableWidget->setColumnWidth(DEL_BUTTON_COL_INDEX, 20);
//QTableWidgetItem* item = new QTableWidgetItem();
//tableWidget->setItem(rowIndex, DEL_BUTTON_COL_INDEX, item);
QToolButton* delButton = CreateDeleteButton();
connect(delButton, SIGNAL(clicked()), this, SLOT(onDelButtonPushed()));
tableWidget->setCellWidget(rowIndex, DEL_BUTTON_COL_INDEX, delButton);
}
}
void IndexDialog::tableChanged(const QString &tb)
{
tbname = tb;
tbColumnList->clearContents();
QSqlDatabase db = QSqlDatabase::database(conname);
QSqlRecord record = db.record(tbname);
int count = record.count();
tbColumnList->setRowCount(count);
for(int i=0;i<count;i++){
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(Qt::EditRole,false);
item->setFlags(Qt::ItemIsEnabled);
tbColumnList->setItem(i,0,item);
item = new QTableWidgetItem;
item->setText(record.fieldName(i));
tbColumnList->setItem(i,1,item);
item = new QTableWidgetItem;
item->setText(QString());
tbColumnList->setItem(i,2,item);
item = new QTableWidgetItem;
item->setText(QString());
tbColumnList->setItem(i,3,item);
}
}
// get speaker's themes by language
QTableWidget *PublicTalks::getSpeakerPublicTalks(int kieli_id, int personid, QString select) {
QTableWidget *table = new QTableWidget(0,3);
table->verticalHeader()->setVisible(false);
//sitten vectoriin kaikki aiheet
std::vector<sql_item> q;
// q = sql.selectSql("SELECT * FROM Esitelmat, P_esitelmat WHERE Esitelmat.kieli_id = '"+ kielet[0].getValue("id") +"'"
// " AND Esitelmat.aihe_id = P_esitelmat.aihe_id"
// " AND P_esitelmat.puhuja_id = '" + QString::number(personid) + "'");
q = sql.selectSql("SELECT Esitelmat.*, P_esitelmat.puhuja_id, yleisokokous.pvm FROM Esitelmat "
"LEFT JOIN yleisokokous ON Esitelmat.aihe_id = yleisokokous.aihe_id "
"LEFT JOIN P_esitelmat ON Esitelmat.aihe_id = P_esitelmat.aihe_id "
"WHERE P_esitelmat.puhuja_id = '" + QString::number(personid) + "' "
"AND Esitelmat.kieli_id = '"+ langId +"' "
"GROUP BY Esitelmat.aihe_id ORDER BY Esitelmat.aihe_id");
table->setRowCount(q.size()+1);
for(unsigned int i = 0; i < q.size(); i++) {
int value = QVariant(q[i].getValue("aihe_id")).toInt();
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(Qt::DisplayRole,value);
table->setItem(i+1,0,item);
//table->setItem(i+1,0,new QTableWidgetItem(q[i].getValue("aihe_id")));
table->setItem(i+1,1,new QTableWidgetItem(q[i].getValue("aihe")));
if(table->item(i+1,1)->text() == select) {
QFont boldfont(table->item(i+1,1)->font().family(),
table->item(i+1,1)->font().pointSize(),
QFont::Bold);
table->item(i+1,1)->setFont(boldfont);
}
table->setItem(i+1,2,new QTableWidgetItem(q[i].getValue("pvm")));
}
return table;
}
void MusicConnectTransferWidget::createAllItems(const MusicSongs &songs)
{
ui->playListTableWidget->clear();
if(ui->allSelectedcheckBox->isChecked())
{
ui->allSelectedcheckBox->click();
}
ui->playListTableWidget->setRowCount(songs.count());
for(int i=0; i<songs.count(); ++i)
{
MusicSong song = songs[i];
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(MUSIC_CHECK_ROLE, false);
ui->playListTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(song.getMusicName(), Qt::ElideRight, 280));
item->setToolTip(song.getMusicPath());
item->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
ui->playListTableWidget->setItem(i, 1, item);
item = new QTableWidgetItem;
item->setText(QFontMetrics(font()).elidedText(song.getMusicTime(), Qt::ElideRight, 40));
item->setToolTip(song.getMusicTime());
item->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
ui->playListTableWidget->setItem(i, 2, item);
}
}
void
TagColorEditor::cellDoubleClicked(int row, int col)
{
if (row == 0 && col > 0)
return;
QTableWidgetItem *item = table->item(row, col);
uchar *colors = Global::tagColors();
//int index = row*8 + col;
int index = 0;
if (row > 0) index = 1 + (row-1)*5 + col;
QColor clr = QColor(colors[4*index+0],
colors[4*index+1],
colors[4*index+2]);
clr = DColorDialog::getColor(clr);
if (!clr.isValid())
return;
colors[4*index+0] = clr.red();
colors[4*index+1] = clr.green();
colors[4*index+2] = clr.blue();
item->setData(Qt::DisplayRole, QString("%1").arg(index));
item->setBackground(clr);
emit tagColorChanged();
}
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 ViennaMiniForm::setupDevice(std::vector<int> const& segment_indices)
{
if(resize_device_parameters)
{
device_parameters.clear();
}
ui->tableWidget->clearContents();
ui->tableWidget->setRowCount(segment_indices.size());
for(int i = 0; i < segment_indices.size(); i++)
{
QTableWidgetItem *item = new QTableWidgetItem(QString::number(segment_indices[i]));
item->setFlags(item->flags() ^ Qt::ItemIsEditable); // make the table not editable
item->setData(Qt::UserRole, segment_indices[i]);
ui->tableWidget->setItem(i, 0, item);
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
//ui->tableWidget->verticalHeader()->setStretchLastSection(true);
// now, activate the device tab!
ui->tabWidget->setTabEnabled(1, true);
// select the first segment by default
ui->tableWidget->setCurrentCell(segment_indices[0], 0);
// this->toggleParameters(true);
// this->showSegmentParameters(0,0); //show default parameters for the initial selection
}
void ShortcutsImpl::initTable(MainImpl *main)
{
QList<QObject*> childrens = main->children();
QListIterator<QObject*> iterator(childrens);
int row = 0;
while( iterator.hasNext() )
{
QObject *object = iterator.next();
QAction *action = qobject_cast<QAction*>(object);
if (action)
{
QString text = action->text().remove("&");
if ( !text.isEmpty() && !(action->data().toString().contains("Recent|")) )
{
QString shortcut = action->shortcut();
QTableWidgetItem *newItem = new QTableWidgetItem(text);
newItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
newItem->setData(Qt::UserRole, addressToVariant(object));
newItem->setIcon(action->icon());
table->setRowCount(row+1);
table->setItem(row, 0, newItem);
table->setItem(row++, 1, new QTableWidgetItem(shortcut));
}
}
table->sortItems( 0 );
}
QHeaderView *header = table->horizontalHeader();
header->resizeSection( 0, 230 );
table->verticalHeader()->hide();
}
void MainWindow::on_addEventButton_clicked()
{
// QTreeWidgetItem* parentWidget = selectedTreeWidgetItem();
Task* parentTask = selectedTask();
if (parentTask == NULL) return;
Event* newEvent = addEvent(parentTask, "");
ui->tableEvents->blockSignals(true);
ui->tableEvents->insertRow(0);
QTableWidgetItem *widgetUid = new QTableWidgetItem();
widgetUid->setText(newEvent->mUID);
widgetUid->setData(Qt::UserRole, qVariantFromValue((void*) newEvent));
ui->tableEvents->setItem(0, 0, widgetUid);
QTableWidgetItem *widgetName = new QTableWidgetItem();
widgetName->setText(newEvent->mName);
ui->tableEvents->setItem(0, 1, widgetName);
DateItem *widgetStart = new DateItem();
widgetStart->setText(newEvent->mStartTime.toString());
widgetStart->mTime = newEvent->mStartTime;
ui->tableEvents->setItem(0, 2, widgetStart);
DateItem *widgetEnd = new DateItem();
widgetEnd->setText(newEvent->mEndTime.toString());
widgetEnd->mTime = newEvent->mEndTime;
ui->tableEvents->setItem(0, 3, widgetEnd);
ui->tableEvents->blockSignals(false);
}
void AddLink::displayComp(vector<Computer>& computer)
{
ui->table_linking->setSortingEnabled(false);
ui->table_linking->clearContents();
ui->table_linking->setColumnCount(5);
ui->table_linking->setRowCount(computer.size());
ui->table_linking->setHorizontalHeaderItem(0,new QTableWidgetItem(QString("id")));
ui->table_linking->setHorizontalHeaderItem(1,new QTableWidgetItem(QString("Name")));
ui->table_linking->setHorizontalHeaderItem(2,new QTableWidgetItem(QString("Year")));
ui->table_linking->setHorizontalHeaderItem(3,new QTableWidgetItem(QString("Type")));
ui->table_linking->setHorizontalHeaderItem(4,new QTableWidgetItem(QString("Built")));
for(size_t i = 0; i < computer.size(); i++)
{
Computer temp = computer[i];
QTableWidgetItem* id = new QTableWidgetItem;
id->setData(Qt::DisplayRole,temp.getID());
ui->table_linking->setItem(i,0, id);
ui->table_linking->setItem(i,1, new QTableWidgetItem(QString::fromStdString(temp.getName())));
ui->table_linking->setItem(i,2, new QTableWidgetItem(QString::number(temp.getYear())));
ui->table_linking->setItem(i,3, new QTableWidgetItem(QString::fromStdString(temp.getType())));
ui->table_linking->setItem(i,4, new QTableWidgetItem(QString::number(temp.getBuilt())));
}
ui->table_linking->setSortingEnabled(true);
}
/*! @brief Takes in an action and adds it to the queue.
This function parses the passed action and displays the appropriate information in the table.
It also stores the action as data in the QTableWidgetItem in the first column.
This is done using the function setData().
This function takes in an int and a QVariant.
The int represents a role - this is basically an index into an array or a key into a hashtable.
The role used here is predefined within Qt - Qt::UserRole.
This role is specifically set aside by Qt for the user to use - it should be empty unless the user puts something in it.
The QVariant is the data to be stored. QVariants can store any type of data - even structs!
In this case, an action struct is being stored using the function setValue().
After storing the action into the QVariant, the QVariant can be stored in the QTableWidgetItem using setData().
To extract the data from the QTableWidgetItem, simply call the function data().
This function takes in an int representing a role. To retrieve the data store here, pass it Qt::UserRole.
The function will return a QVariant. The QVariant can be cast into whatever data type is stored within it using the value() function.
In this case, of course, the data type is the struct Action. The form for the function should look like this:
Action act = qvariant.value<Action>();
"Action" here can be replaced with an arbitrary data type.
*/
void Queue::addActionToQueue(Action action) {
QVariant v;
v.setValue(action);
QTableWidgetItem* act = new QTableWidgetItem(0);
act->setData(Qt::UserRole, v);
act->setFlags(act->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem* span = new QTableWidgetItem(0);
span->setFlags(span->flags() ^ Qt::ItemIsEditable);
span->setTextAlignment(Qt::AlignHCenter);
int index = action.queueIndex;
if (action.typ != INITIALIZE || rowCount() == 0) {
insertRow(index);
setRowHeight(index, 20);
}
setItem(index, 0, act);
setItem(index, 1, span);
for (int i=0; i < 5; i++) {
QTableWidgetItem* item = new QTableWidgetItem(0);
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
setItem(index, i + 2, item);
}
updateQueue(index, rowCount());
}
void MusicLrcSearchTableWidget::creatSearchedItems(const QString &songname,
const QString &artistname, const QString &time)
{
int count;
setRowCount(count = m_downLoadManager->getSongIdIndex());
setStyleSheet(MusicUIObject::MTableWidgetStyle01 + \
MusicUIObject::MScrollBarStyle01);
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(Qt::DisplayRole, false);
setItem(count - 1, 0, item);
item = new QTableWidgetItem(songname);
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(songname);
setItem(count - 1, 1, item);
item = new QTableWidgetItem(artistname);
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
item->setToolTip(artistname);
setItem(count - 1, 2, item);
item = new QTableWidgetItem(time);
item->setTextColor(QColor(50, 50, 50));
item->setTextAlignment(Qt::AlignCenter);
setItem(count - 1, 3, item);
item = new QTableWidgetItem(QIcon(QString::fromUtf8(":/radio/collect")), "");
item->setTextAlignment(Qt::AlignCenter);
setItem(count - 1, 4, item);
}
QTableWidgetItem* NewClassDialog::createClass(QString name, QString gradeString, \
QString gradeData, QString section, QString notes)
{
QList<QVariant> *newData = new QList<QVariant>;
newData->append(QVariant(name));
newData->append(QVariant(gradeData));
newData->append(QVariant(section));
newData->append(QVariant(notes));
newData->append(QVariant(nRow));
newData->append(QVariant(nColumn));
newData->append((QVariant)QString("None"));
QVariant *dataToAdd = new QVariant(*newData);
QTableWidgetItem *newItem;
if(notes == "")
{
newItem = new QTableWidgetItem( \
QString("%1\n%2\n00%3").arg(name).arg(gradeString).arg(section) );
} else {
newItem = new QTableWidgetItem( \
QString("%1\n%2\n** 00%3 **").arg(name).arg(gradeString).arg(section) );
}
newItem->setTextAlignment(Qt::AlignCenter);
newItem->setData(Qt::UserRole, *dataToAdd);
return newItem;
}
void AghPhoneSearchDirDialog::putTerminalIntoTable(TerminalAddress *terminal, QString alias) {
if (terminal == NULL) {
return;
}
// check whether exists
QList<QTableWidgetItem *> tmpList = resultTAble->findItems(alias, Qt::MatchExactly);
if ( tmpList.count() > 0)
return;
QTableWidgetItem *tmpItem = new QTableWidgetItem(alias);
if (terminal->type == USERTERMINAL) {
tmpItem->setIcon(QIcon(":contactuser.png"));
} else if (terminal->type == MCUTERMINAL) {
tmpItem->setIcon(QIcon(":contactmcu.png"));
} else {
tmpItem->setIcon(QIcon(":tray.png"));
}
tmpItem->setFlags(Qt::ItemIsEnabled);
tmpItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
tmpItem->setData(Qt::UserRole, QVariant(QMetaType::VoidStar, &terminal) );
int rowCout = resultTAble->rowCount();
resultTAble->insertRow(rowCout);
resultTAble->setItem(rowCout, 0, tmpItem);
}
void CQArrayAnnotationsWidget::initSelectionTable()
{
#ifdef DEBUG_UI
qDebug() << "-- in initSelectionTable -- \n";
#endif
size_t i, imax = mpArray->dimensionality();
mpSelectionTable->setRowCount((int) imax);
mpSelectionTable->setColumnCount(2);
for (i = 0; i < imax; ++i)
{
QTableWidgetItem *pItem = new QTableWidgetItem(FROM_UTF8(mpArray->getDimensionDescription(i)));
mpSelectionTable->setItem((int) i, 0, pItem);
//combo box
QStringList ComboEntries;
vectorOfStrings2QStringList(mpArray->getAnnotationsString(i), ComboEntries);
pItem = new QTableWidgetItem(ComboEntries[mSelectionIndex[i]]);
pItem->setData(Qt::EditRole, ComboEntries);
mpSelectionTable->setItem((int) i, 1, pItem);
}
mpSelectionTable->resizeColumnsToContents();
mpSelectionTable->show();
mpSelectionTable->resizeColumnsToContents();
mpSelectionTable->resizeRowsToContents();
mpSelectionTable->setMaximumHeight(mpSelectionTable->verticalHeader()->sectionSize(0) * (mpArray->dimensionality() + 1));
}
void UTableNotes::clickActionHide()
{
QTableWidgetItem *curItem = item(currentRow(), indexColumnVisible);
curItem->setData(pointerOnDataColumnVisible, false);
curItem->setIcon(QIcon(IconHide));
emit clickActionHideItem();
}
/** 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 SessionWizard::match()
{
if (!lwSessionStudents->currentIndex().isValid())
return;
if (!lwClassStudents->currentIndex().isValid())
return;
twMatchedPairs->setRowCount(twMatchedPairs->rowCount() + 1);
QTableWidgetItem *item = new QTableWidgetItem(lwSessionStudents->currentItem()->text());
item->setData(Qt::UserRole, lwSessionStudents->currentItem()->data(Qt::UserRole));
twMatchedPairs->setItem(twMatchedPairs->rowCount() - 1, 0, item);
delete lwSessionStudents->takeItem(lwSessionStudents->currentRow());
item = new QTableWidgetItem(lwClassStudents->currentItem()->text());
item->setData(Qt::UserRole, lwClassStudents->currentItem()->data(Qt::UserRole));
twMatchedPairs->setItem(twMatchedPairs->rowCount() - 1, 1, item);
delete lwClassStudents->takeItem(lwClassStudents->currentRow());
}
void jTransaction::setRow(QTableWidget* table, int row)
{
QTableWidgetItem * dateTableItem;
QTableWidgetItem * descTableItem;
QTableWidgetItem * catTableItem;
QTableWidgetItem * amountTableItem;
dateTableItem = new QTableWidgetItem();
dateTableItem->setFlags(dateTableItem->flags() ^ Qt::ItemIsEditable);
dateTableItem->setData(Qt::EditRole, mDate);
descTableItem = new QTableWidgetItem(mDescription);
descTableItem->setFlags(descTableItem->flags() ^ Qt::ItemIsEditable);
catTableItem = new QTableWidgetItem(mCategory);
catTableItem->setFlags(catTableItem->flags() ^ Qt::ItemIsEditable);
amountTableItem = new QTableWidgetItem(QLocale().toCurrencyString(mAmount));
amountTableItem->setFlags(amountTableItem->flags() ^ Qt::ItemIsEditable);
table->setItem(row,0, dateTableItem);
table->setItem(row,1, catTableItem);
table->setItem(row,2, descTableItem);
table->setItem(row,3, amountTableItem);
}
bool TilesetTable::Load(const QString &def_filename, const QString& root_folder)
{
if (!Tileset::Load(def_filename, root_folder))
return false;
// Read in tiles and create table items.
QRect rectangle;
QImage entire_tileset;
entire_tileset.load(root_folder + _tileset_image_filename, "png");
for(uint32_t row = 0; row < num_rows; ++row) {
for(uint32_t col = 0; col < num_cols; ++col) {
rectangle.setRect(col * TILE_WIDTH, row * TILE_HEIGHT, TILE_WIDTH,
TILE_HEIGHT);
QVariant variant = entire_tileset.copy(rectangle);
if(!variant.isNull()) {
QTableWidgetItem *item = new QTableWidgetItem(QTableWidgetItem::UserType);
item->setData(Qt::DecorationRole, variant);
item->setFlags(item->flags() &~ Qt::ItemIsEditable);
table->setItem(row, col, item);
} else
qDebug("Image loading error!");
} // iterate through the columns of the tileset
} // iterate through the rows of the tileset
// Select the top left item
table->setCurrentCell(0, 0);
return true;
}
void ManageDefinitionsDialog::populateDefinitionsWidget(const QList<DefinitionMetaDataPtr> &definitionsMetaData)
{
const int size = definitionsMetaData.size();
ui.definitionsTable->setRowCount(size);
for (int i = 0; i < size; ++i) {
const HighlightDefinitionMetaData &downloadData = *definitionsMetaData.at(i);
// Look for this definition in the current path specified by the user, not the one
// stored in the settings. So the manager should not be queried for this information.
QString dirVersion;
QFileInfo fi(m_path + downloadData.fileName);
QFile definitionFile(fi.absoluteFilePath());
if (definitionFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
const DefinitionMetaDataPtr data = Manager::parseMetadata(fi);
if (!data.isNull())
dirVersion = data->version;
}
for (int j = 0; j < 3; ++j) {
QTableWidgetItem *item = new QTableWidgetItem;
if (j == 0) {
item->setText(downloadData.name);
item->setData(Qt::UserRole, downloadData.url);
} else if (j == 1) {
item->setText(dirVersion);
item->setTextAlignment(Qt::AlignCenter);
} else if (j == 2) {
item->setText(downloadData.version);
item->setTextAlignment(Qt::AlignCenter);
}
ui.definitionsTable->setItem(i, j, item);
}
}
}
QTableWidgetItem* TSController::getQTableWidgetItem(QVariant text){
// qDebug()<<"TSController::getQTableWidgetItem";
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(0,text);
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
return item;
}
void SheetView::refreshDisplay() {
ui->tableWidget->setRowCount(C->Count_Get());
ui->tableWidget->setColumnCount(Sheet::getSheet()->getNbColumns());
for(int i=0;i<Sheet::getSheet()->getNbColumns();++i) {
column c = Sheet::getSheet()->getColumn(i);
if(ui->tableWidget->horizontalHeaderItem(i))
ui->tableWidget->horizontalHeaderItem(i)->setText(c.name);
else
ui->tableWidget->setHorizontalHeaderItem(i,new QTableWidgetItem(c.name));
ui->tableWidget->setColumnWidth(i,c.width);
}
for (unsigned FilePos=0;FilePos<C->Count_Get();FilePos++) {
//ui->tableWidget->setItem(FilePos,0,new QTableWidgetItem(wstring2QString(C->Get(FilePos, Stream_General, 0, _T("CompleteName")))));
for(int i=0;i<Sheet::getSheet()->getNbColumns();++i) {
column c = Sheet::getSheet()->getColumn(i);
QString itemText = wstring2QString(C->Get(FilePos,c.stream,0,QString2wstring(c.key)));
if(c.key=="CompleteName")
itemText=MainWindow::shortName(C,itemText);
QTableWidgetItem* twi = new QTableWidgetItem(itemText);
twi->setData(Qt::UserRole,FilePos);
ui->tableWidget->setItem(FilePos,i,twi);
}
}
if(Sheet::getSheet()->getAdaptColumns())
ui->tableWidget->resizeColumnsToContents();
}
DataTableWidget::DataTableWidget(IDataForms *ADataForms, const IDataTable &ATable, QWidget *AParent) : QTableWidget(AParent)
{
FTable = ATable;
FDataForms = ADataForms;
setRowCount(ATable.rows.count());
setColumnCount(ATable.columns.count());
int row = 0;
foreach(const QStringList &values, ATable.rows)
{
for (int col=0; col<values.count(); col++)
{
QTableWidgetItem *item = new QTableWidgetItem(values.at(col));
item->setData(DTR_COL_INDEX,col);
item->setData(DTR_ROW_INDEX,row);
item->setFlags(Qt::ItemIsEnabled);
setItem(row,col,item);
}
row++;
}
QStringList headers;
foreach(const IDataField &field, ATable.columns)
headers.append(!field.label.isEmpty() ? field.label : field.var);
setHorizontalHeaderLabels(headers);
horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
verticalHeader()->resizeSections(QHeaderView::ResizeToContents);
setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
connect(this,SIGNAL(cellActivated(int,int)),SIGNAL(activated(int,int)));
connect(this,SIGNAL(currentCellChanged(int,int,int,int)),SIGNAL(changed(int,int,int,int)));
}
