C++ QTableWidget类代码示例

void Table::setColumnCount(int count, bool suppressSignals)
{
    QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
    bool oldSignalsState = tablewidget->blockSignals(suppressSignals);
    tablewidget->setColumnCount(count);
    tablewidget->blockSignals(oldSignalsState);
}

void ListingTracePane::updateListingTrace()
{
    // tableWidget depends on whether we are in the OS or a program
    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 = highlightedItemList.size() - 1; i >= 0; i--) {
        highlightedItemList.at(i)->setBackgroundColor(Qt::white);
        highlightedItemList.at(i)->setTextColor(Qt::black);
        highlightedItemList.removeLast();
    }
    if (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());
}

unsigned StManagerStudyListComp::getSeriesIndex( const SerieInfoVector info )
{
  // no resize, just exit button - reject, result code is 0 -> returned value will be 0
  QDialog *seriesSelectorDialog = new QDialog( this, Qt::WindowTitleHint | Qt::WindowSystemMenuHint| Qt::MSWindowsFixedSizeDialogHint );
  seriesSelectorDialog->setWindowTitle( tr( "Series Selector" ) );

  QVBoxLayout *mainLayout = new QVBoxLayout;

  QLabel *seriesLabel = new QLabel( tr( "Series in selected study:\n(their descriptions)" ) );
  mainLayout->addWidget( seriesLabel );

  QSpacerItem *verticalSpacer = new QSpacerItem( 2, 10, QSizePolicy::Minimum, 
                                                 QSizePolicy::Minimum );
  mainLayout->addItem( verticalSpacer );

  QTableWidget *seriesTable = createSeriesSelectionTable();
  seriesTable->setRowCount( info.size() );
  for ( unsigned i = 0; i < info.size(); i++ ) {
    seriesTable->setItem( i, 0, new QTableWidgetItem( QString( info[i].description.c_str() ) ) );
  }
  connect( seriesTable, SIGNAL(cellClicked( int, int )), seriesSelectorDialog, SLOT(done( int )) );
  mainLayout->addWidget( seriesTable );

  seriesSelectorDialog->setLayout( mainLayout );

  return seriesSelectorDialog->exec();
}

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

HttpUserSetupDialog::HttpUserSetupDialog(QWidget *parent)
	: QDialog(parent)
	, ui(new Ui::HttpUserSetupDialog)
{
	ui->setupUi(this);
	
	QTableWidget * tableWidget = ui->httpUsers;
	QList<HttpUser*> users = HttpUserUtil::instance()->users();
	
	tableWidget->setRowCount(users.size());
	int row = 0;
	foreach(HttpUser *user, users)
	{
		tableWidget->setItem(row, 0, new QTableWidgetItem(user->user()));
		tableWidget->setItem(row, 1, new QTableWidgetItem(user->pass()));
		tableWidget->setItem(row, 2, new QTableWidgetItem(QString::number(user->level())));
		
		QComboBox *levelCombo = new QComboBox();
		
		levelCombo->addItems(QStringList() << "Guest" << "User" << "Admin");
		levelCombo->setCurrentIndex(user->level());
		
		tableWidget->setCellWidget(row, 2, levelCombo);
		 
		row ++;
	}

/**
* @brief ctor for main window
*
* @param parent
*/
MainWindow::MainWindow(QWidget *parent):
    QMainWindow(parent)
{	
	m_pCentral = new QFrame;
	setCentralWidget(m_pCentral);

	m_mainLayout = new QHBoxLayout;
	m_mainLayout->setContentsMargins(1,1,1,1);
	m_mainLayout->setSpacing(1);
	centralWidget()->setLayout(m_mainLayout);
	m_mainLayout->addWidget(&m_accordion);
	m_accordion.setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);

	QAccordionItem *item = new QAccordionItem("Item1");
	QTableWidget *table = new QTableWidget();
	QTableWidgetItem *table_item = new QTableWidgetItem("Test talbe item");
	table->setColumnCount(1);
	table->setRowCount(1);
	table->setItem(0,0,table_item);
	item->setWidget(table);

	m_accordion.addItem(item);		

	QAccordionItem *item2 = new QAccordionItem("Item2");
	QLineEdit *lineEdit = new QLineEdit();
	lineEdit->setText("Testing Text");
	item2->setWidget(lineEdit);
	m_accordion.addItem(item2);		
	createInnerAccordion();

}

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 MainWindow::elegantClose(bool quit) {
  qDebug() << "Exiting elegantly.";

  QSettings s;
  s.setValue("mainWindowGeometry", saveGeometry());
  s.setValue("mainWindowState", saveState());

  for (int i = 0; i < ui->listTabs->count(); i++) {
    QTableWidget *t = static_cast<QTableWidget *>(
        ui->listTabs->widget(i)->layout()->itemAt(0)->widget());

    QString key = ui->listTabs->tabText(i)
                      .replace(QRegExp("[ ]+"), "")
                      .replace(QRegExp("\\([0-9]+\\)"), "") +
                  "State";

    s.setValue(key, t->horizontalHeader()->saveState());
  }

  for (QFuture<void> f : this->async_registry) {
    if (f.isRunning()) {
      qApp->processEvents();
      f.waitForFinished();
    }
  }

  if (!quit) return;

  if (this->hasUser) {
    connect(User::sharedUser(), SIGNAL(quitFinished()), qApp, SLOT(quit()));
    User::sharedUser()->quit();
  } else {
    qApp->quit();
  }
}

void MainWindow::on_spinAccount_valueChanged(int arg1)
{
    if (!root_set) return;
    const char addr_version = 0x00, wif_version = 0x80;
    const size_t buflen = 128;
    char buf[buflen + 1];
    HDNode node;
    // external chain
    for (int chain = 0; chain < 2; chain++) {
        QTableWidget *list = chain == 0 ? ui->listAddress : ui->listChange;
        node = root;
        hdnode_private_ckd(&node, 44 | 0x80000000);
        hdnode_private_ckd(&node, 0 | 0x80000000); // bitcoin
        hdnode_private_ckd(&node, (arg1 - 1) | 0x80000000);
        hdnode_serialize_private(&node, buf, buflen); QString xprv = QString(buf); ui->lineXprv->setText(xprv);
        hdnode_serialize_public(&node, buf, buflen); QString xpub = QString(buf); ui->lineXpub->setText(xpub);
        hdnode_private_ckd(&node, chain); // external / internal
        for (int i = 0; i < 100; i++) {
            HDNode node2 = node;
            hdnode_private_ckd(&node2, i);
            ecdsa_get_address(node2.public_key, addr_version, buf, buflen); QString address = QString(buf);
            ecdsa_get_wif(node2.private_key, wif_version, buf, buflen); QString wif = QString(buf);
            list->setItem(i, 0, new QTableWidgetItem(address));
            list->setItem(i, 1, new QTableWidgetItem(wif));
            list->setItem(i, 2, new QTableWidgetItem("0.0"));
        }
    }
}

AppHistoryTab::AppHistoryTab()
{

    //

    QLabel *legendLabel = new QLabel("Historique des applications depuis la connexion au serveur.");
    legendLabel->setFixedHeight(40);


    // TabWidget

    QTableWidget *tableWidget = new QTableWidget();
    tableWidget->setColumnCount(6);

    // resize to contents
    tableWidget->setColumnWidth(0, 300);

    QStringList listHeaders;
    listHeaders << "Nom" << "PID" << "Statut" << "UID" << "Date de début" << "Date de fin";
    tableWidget->setHorizontalHeaderLabels(listHeaders);
    tableWidget->horizontalHeaderItem(0)->setTextAlignment(Qt::AlignLeft);


    // Layering

    QVBoxLayout *vl = new QVBoxLayout();
    setLayout(vl);
    vl->addWidget(legendLabel);
    vl->addWidget(tableWidget);
}

void MainWindow::on_showMoreButton_clicked()
{
        if(currSelectedID.toInt() > 0){
            QString imgPath = "images/";
            QTableWidget *current = new QTableWidget;
            if(whatList){
                ui->listOfSci->setHidden(1);
                imgPath += "scientists/";
                current = ui->listOfSci;
            }
            else{
                ui->listOfComps->setHidden(1);
                imgPath += "computers/";
                current = ui->listOfComps;
            }

            imgPath += currSelectedID + ".jpg";
            QPixmap thing(imgPath);
            ui->pictureLable->setScaledContents(true);
            ui->pictureLable->setPixmap(thing);

            displayConnections(currSelectedID);
            fillComboConn();

            int row = currSelectedRow;
            ui->more1->setText(current->item(row, 1)->text());
            ui->more2->setText(current->item(row, 2)->text());
            ui->more3->setText(current->item(row, 3)->text());
            ui->more4->setText(current->item(row, 4)->text());
            ui->more5->setText(current->item(row, 5)->text());
            ui->moreUI->setVisible(1);
    }

    return;
}

void MainWindow::clearObjectTable()
{
    QTableWidget *table = ui->objectsTableWidget;
    table->clear();
    table->setRowCount(0);
    table->setColumnCount(0);
}

// 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 Table::setSelection(int row, int column, bool suppressSignals)
{
    QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
    bool oldSignalsState = tablewidget->blockSignals(suppressSignals);
    tablewidget->setCurrentCell(row, column);
    tablewidget->blockSignals(oldSignalsState);
}

ServerTab::ServerTab()
{
    //
    QLabel *legendLabel = new QLabel("Liste des clients connectés au serveur.");
    legendLabel->setFixedHeight(40);

    // TabWidget

    QTableWidget *tableWidget = new QTableWidget();
    tableWidget->setColumnCount(6);

    // resize to contents
    tableWidget->setColumnWidth(0, 300);
    tableWidget->setColumnWidth(4, 120);

    QStringList listHeaders;
    listHeaders << "Nom du client" << "ID de connexion" << "Adresse IP" << "Statut" << "Début de connexion" << "Fin de connexion";
    tableWidget->setHorizontalHeaderLabels(listHeaders);
    tableWidget->horizontalHeaderItem(0)->setTextAlignment(Qt::AlignLeft);


    // Layering

    QVBoxLayout *vl = new QVBoxLayout();
    setLayout(vl);
    vl->addWidget(legendLabel);
    vl->addWidget(tableWidget);
}