Qt QTableWidget und grundlegende Operationen (detaillierte Version)
<Qt QTreeWidget- und QDockWidgetQt-Modell- / Ansichtsstruktur>
C Language Chinese Network hat Nachhilfeklassen gestartet, darunter "Nachhilfeklassen in C-Sprache, C ++ - Nachhilfeklassen, Nachhilfeklassen für Algorithmen / Datenstrukturen", die alle Einzelunterricht sind: Einzelunterricht + Einzelunterricht + Fragen und Antworten + Aufgaben + Projekte Übung + permanentes Lernen. QQ ist online und bereit zu antworten!
QTableWidget ist eine Tabellenkomponentenklasse in Qt. Nachdem Sie eine QTableWidget-Komponente in das Formular eingefügt haben, können Sie ihre Eigenschaften im Eigenschafteneditor festlegen. Doppelklicken Sie auf diese Komponente, um einen Editor zum Bearbeiten von Spalte, Zeile und Element zu öffnen.
Die Grundstruktur der Schnittstelle einer QTableWidget-Komponente ist in Abbildung 1 dargestellt. Die Tabelle besteht aus 6 Zeilen und 5 Spalten.
Abbildung 1 Die Grundstruktur einer QTableWidget-Tabelle sowie die Zeilen- und Spaltenindexnummern des Arbeitsbereichs
Die erste Zeile der Tabelle wird als Zeilenkopf bezeichnet, mit dem der Titel jeder Spalte festgelegt wird, und die erste Spalte wird als Listenkopf bezeichnet. Sie können den Titel festlegen, verwenden jedoch im Allgemeinen den Standardtitel, bei dem es sich um die Zeilennummer handelt. Zeilenüberschriften und Listenüberschriften können im Allgemeinen nicht bearbeitet werden.
Der Tabellenbereich mit Ausnahme des Zeilenkopfs und des Listenkopfs ist der Inhaltsbereich. Der Inhaltsbereich ist ein reguläres Raster wie ein zweidimensionales Array. Jede Rasterzelle wird als Zelle bezeichnet. Jede Zelle hat eine Zeilennummer und eine Spaltennummer. Abbildung 1 zeigt das sich ändernde Gesetz von Zeilennummer und Spaltennummer.
In der QTableWidget-Tabelle ist jede Zelle ein QTable Widgetltem-Objekt. Sie können den Textinhalt, die Schriftart, die Vordergrundfarbe, die Hintergrundfarbe, das Symbol sowie die Bearbeitungs- und Anzeigeflags festlegen. Jede Zelle kann auch QVariant-Daten zum Festlegen benutzerdefinierter Daten speichern.
Abbildung 2 Laufzeitschnittstelle der Instanz Samp4_9
Das Beispiel samp4_9 verwendet QTableWidget als Hauptkomponente, um die Realisierung einiger Hauptoperationen von QTableWidget zu demonstrieren. Die Schnittstelle, wenn das Beispiel ausgeführt wird, ist in Abbildung 2 dargestellt. Das Beispiel zeigt die Implementierung der folgenden Funktionen:
Festlegen der Anzahl der Spalten und Zeilen der Tabelle, Festlegen des Texts und des Formats der Kopfzeile.
Initialisieren Sie die Tabellendaten und legen Sie einen Stapel von Instanzdaten fest, um die Tabelle auszufüllen.
Zeile einfügen, Zeile hinzufügen, aktuelle Zeilenoperation löschen.
Durchlaufen Sie alle Zellen der Tabelle und lesen Sie den Inhalt der Tabelle in ein QPlainTextEdit, eine Datenzeile in der Tabelle als Textzeile.
Wenn sich die in der Tabelle ausgewählte aktuelle Zelle ändert, werden die in der Zelle gespeicherten Informationen in der Statusleiste angezeigt.
Schnittstellendesign und Initialisierung
Das Hauptfenster von Samp4_9 wird von QMainWindow geerbt. In dem in Abbildung 2 gezeigten Fenster bilden eine QTableWidget-Komponente und eine QPlainTextEdit-Komponente einen Splitter-Layout-Splitter. Die Schaltflächen auf der linken Seite werden mithilfe des Rasterlayouts in einer QGroupBox-Komponente platziert. Anschließend werden die groupBox und der Splitter in linke und rechte Layouts unterteilt. Dies ist ein typisches Drei-Zonen-Layout.
In der Hauptfensterklasse MainWindow werden einige Variablen und Funktionen für die folgende Codeimplementierung angepasst. Die folgenden Variablen und Funktionen werden im privaten Teil von MainWindow angepasst:
private:
// Passen Sie den Typ des Zelltyps bei der Zellenerstellung an Verwenden Sie
enum CellType {ctName = 1000, ctSex, ctBirth, ctNation, ctPartyM, ctScore};
// die Spaltennummer jedes Felds in der Tabelle
enum FieldColNum {colName = 0, colSex, colBirth, colNation, colScore, colPartyM} ;
QLabel * labCellIndex; // Die Zeilennummer und Spaltennummer,
die zum Anzeigen der Zelle in der Statusleiste verwendet werden.
QLabel * labCellType; // Der Typ QLabel, der zum Anzeigen der Zelle in der Statusleiste verwendet wird. * LabStudID; // Die Statusleiste wird zum Anzeigen des Lernens verwendet Nr
Leere createItemsARow (int Rowno, QString Namen , QString Sex, QDate Geburt, QString Nation, bool ISPM, int score); // erstellen Elemente für eine Reihe
Der Aufzählungstyp CellType gibt den Zelltyp an und wird beim Erstellen einer Zelle verwendet. Der Aufzählungstyp FieldColNum verwendet eine Aufzählungskonstante, um die Spaltennummer jedes Felds in der Tabelle darzustellen.
Die Schnittstelle wird im Konstruktor von MainWindow initialisiert. Der Code lautet wie folgt:
MainWindow :: MainWindow (übergeordnetes QWidget *): QMainWindow (übergeordnetes Element), ui (neues Ui :: MainWindow)
{ ui-> setupUi (this); setCentralWidget (ui-) > splitterMain); // Erstellung der Statusleisteninitialisierung labCellIndex = neues QLabel ("aktuelle Zellkoordinaten:", this); labCellIndex-> setMinimumWidth (250); labCellType = neues QLabel ("aktueller Zelltyp:", this); labCellType-> setMinimumWidth (200); labStudID = neues QLabel ("Student ID:", this); labStudID-> setMinimumWidth (200); ui-> statusBar-> addWidget (labCellIndex); // Zur Statusleiste hinzufügen ui-> statusBar-> addWidget (labCellType); ui-> statusBar-> addWidget (labStudID); } Grundlegende Operationen von QTableWidget Legen Sie den Header fest
Die Schaltfläche "Set Header" auf der Schnittstelle implementiert die Einstellung des Headers. Der Slot-Funktionscode des geklickten () Signals lautet wie folgt:
void MainWindow :: on_btnSetHeader_clicked ()
{// Setze den Header
QTableWidgetItem * headerItem;
QStringList headerText;
headerText << "Name" << "Geschlecht" << "Geburtsdatum" << "Nationalität" << "Punktzahl" << "Parteimitglied"; // Die Kopfzeile der Tabelle wird durch QStringList
// ui-> tableInfo-> setHorizontalHeaderLabels ( headerText);
ui-> tableInfo-> setColumnCount (headerText.count ()); // Die Anzahl der Spalten entspricht der Anzahl der Zeilen von headerText
für (int i = 0; itableInfo-> columnCount (); i ++) // Spaltennummer Ausgehend von 0
{ // cellItem = ui-> tableInfo-> horizontalHeaderItem (i); headerItem = new QTableWidgetItem (headerText.at (i)); // Erstelle ein neues QTableWidgetItem, headerText.at (i) erhält die i-Zeilenzeichen von headerText String QFont font = headerItem-> font (); // Die ursprüngliche Schriftarteinstellung abrufen font.setBold (true);// Fettdruck setzen
font.setPointSize (12); // font size
headerItem-> setTextColor (Qt :: red); // font color
headerItem-> setFont (font); // set font
ui-> tableInfo-> setHorizontalHeaderItem (i, headerItem) ; // Setze das Element der Header-Zelle
}
ui-> tableInfo-> setItemDelegateForColumn (colScore, & spinDelegate); // Setze die benutzerdefinierte Proxy-Komponente
}
Der Texttitel jeder Spalte des Zeilenkopfs wird initialisiert und gespeichert, wenn nur von einem QStringList-Objekt headerText Verwenden Sie die folgende Anweisungszeile, um die Überschriften jeder Spalte im
Zeilentabellenkopf festzulegen : ui-> tableInfo-> setHorizontalHeaderLabels (headerText);
Wenn Sie spezifischere Formateinstellungen vornehmen müssen, müssen Sie für jede Zelle des Zeilentabellenkopfs eine Variable vom Typ QTableWidgetItem erstellen und entsprechend festlegen.
In einer Tabelle ist jede Zelle ein QTableWidgetItem-Objekt, unabhängig davon, ob es sich um den Header oder den Arbeitsbereich handelt. Das QTableWidgetItem-Objekt speichert den gesamten Inhalt der Zelle, einschließlich des Worttitels, der Formatierung und der zugehörigen Daten. Die for-Schleife im obigen Programm durchläuft jede Zeile von headerText, erstellt mit jeder Textzeile ein QTableWidgetItem-Objekt-Headerltem, setzt dann die Schriftgröße von headerItem auf 12, fett und rot und weist dann Headerltem einer bestimmten Spalte des Headers zu:
ui- > tableInfo-> setHorizontalHeaderItern (i, headerItem);
Tabellendaten initialisieren
Die Schaltfläche "Tabellendaten initialisieren" auf der Schnittstelle generiert Daten, um die Tabelle entsprechend der Anzahl der Zeilen in der Tabelle zu füllen, generiert ein QTableWidgetItem-Objekt für jede Zelle und legt die entsprechenden Eigenschaften fest. Das Folgende ist der Slot-Funktionscode des
clicked () -Signals von btnlniData : void MainWindow :: on_btnIniData_clicked ()
{// Initialisiere den Tabelleninhalt
QString strName, strSex;
bool isParty = false;
QDate Birth;
Birth.setDate (1980,4,7); // Initialisiere ein Datum
ui-> tableInfo-> clearContents (); // Lösche nur den Arbeitsbereich, nicht den Header
int Rows = ui-> tableInfo-> rowCount (); // Anzahl der Zeilen im Datenbereich
für (int i = 0; i <Zeilen; i ++) // Die Anzahl der Zeilen 1 im Datenbereich ist 0, der Bereich ist also 0 ~ rowCount () - 1
{ strName = QString :: asprintf ("student% d", i); // Schülername if ((i% 2) == 0) // Setze das Geschlecht in ungeraden und geraden Zeilen und dessen Symbol strSex = "Männlich"; sonst strSex = "Weiblich"; createItemsARow (i, strName, strSex, Geburt, " Han-Nationalität ", isParty, 70); // Elemente für eine Zeile erstellen
geburt = geburt.addTage (20); // Datum plus 20 Tage
isParty =! isParty;
}
} Die Funktion
QTableWidget :: clearContents () löscht den gesamten Inhalt des Tabellendatenbereichs, löscht jedoch nicht den Header.
Die Funktion QTableWidget :: rowCount () gibt die Anzahl der Zeilen im Tabellendatenbereich zurück.
Generieren Sie die Daten, die für jede Zeile in der for-Schleife angezeigt werden müssen, und rufen Sie dann die benutzerdefinierte Funktion createItemsARow () auf, um QTableWidgetItem-Objekte für jede Zelle in einer Zeile der Tabelle zu generieren.
createItemsARow () ist eine benutzerdefinierte Funktion in der Formularklasse. Der Implementierungscode lautet wie folgt:
void MainWindow :: createItemsARow (int rowNo, QString-Name, QString-Geschlecht, QDate-Geburt, QString-Nation, bool isPM, int score)
{// is Erstellen einer Zellenreihe Elemente
QTableWidgetItem * item;
QString str;
uint StudID = 201605000; // Kardinalität der Schüler-ID
// Name
// Erstellen Sie ein neues
Element , setzen Sie den Zelltyp auf benutzerdefiniertes MainWindow :: ctName item = new QTableWidgetItem (Name , MainWindow :: ctName);
item-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Textausrichtungsformat
StudID + = rowNo; // Studenten-ID = Basis + Zeilennummer
item-> setData (Qt :: UserRole, QVariant (StudID)); // Setze studID auf data
ui-> tableInfo-> setItem (rowNo, MainWindow :: colName, item); // Setze Item für die Zelle
// Gender
QIcon icon;
if (Sex == "männlich")
icon.addFile (": / images / icons / boy.ico");
else
icon.addFile (": / images / icons / girl.ico");
item = new QTableWidgetItem (Sex, MainWindow :: ctSex); // Erstellen Sie ein neues Element und setzen Sie den Zelltyp auf benutzerdefiniertes MainWindow :: ctSex-
Element-> setIcon (Symbol);
item-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); //
Legen Sie das Element ui-> für die Zelle fest tableInfo-> setItem (rowNo, MainWindow :: colSex, item); // Set Item für die Zelle
// Geburtsdatum
str =irth.toString ("yyyy-MM-dd"); // Datum wird in string
item = konvertiert new QTableWidgetItem (str, MainWindow :: ctBirth); // Ein neues Element erstellen, den Zelltyp auf das benutzerdefinierte Element MainWindow :: ctBirth
setzen-> setTextAlignment (Qt :: AlignLeft | Qt :: AlignVCenter); // Textausrichtungsformat
ui-> tableInfo-> setItem (rowNo, MainWindow :: colBirth, item); // Set Item für die Zelle
// ethnisch
item = new QTableWidgetItem (Nation, MainWindow :: ctNation); // Neues Element erstellen, Zelltyp auf ein benutzerdefiniertes MainWindow :: ctNation-
Element setzen-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Text Ausrichtungsformat
ui-> tableInfo-> setItem (rowNo, MainWindow :: colNation, item); // Set Item für die Zelle
// Ist es ein Parteimitglied
item = new QTableWidgetItem ("Parteimitglied", MainWindow :: ctPartyM); // Erstelle ein neues Element, setzen Sie den Zelltyp auf benutzerdefiniertes MainWindow :: ctPartyM-
Element-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Textausrichtungsformat
if (isPM)
item-> setCheckState (Qt :: Checked);
sonst
item-> setCheckState (Qt :: Unchecked);
item-> setBackgroundColor (Qt :: gelb); // Qt :: green lightGray gelb
ui-> tableInfo-> setItem (rowNo, MainWindow :: colPartyM, item); / / Set Item für die Zelle
// Score
str.setNum (score);
item = new QTableWidgetItem (str, MainWindow :: ctScore); // Erstelle ein neues Item und setze den Zelltyp auf ein benutzerdefiniertes MainWindow :: ctPartyM
item-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Text Ausrichtungsformat
ui-> tableInfo-> setItem (rowNo, MainWindow :: colScore, item); // Set Item für die Zelle
}
Jede Zeile der Tabelle enthält 5 Spalten, und für jede Zelle wird ein variables Element vom Typ QTableWidgetItem erstellt , Und nehmen Sie die entsprechenden Einstellungen vor.
Der Prototyp des Konstruktors, der zum Erstellen von QTableWidgetItem verwendet wird, lautet:
QTableWidgetItem :: QTableWidgetItem (const QString & text, int type = Type)
Unter diesen ist der erste Parameter der Anzeigetext der Zelle und der zweite Parameter ist der Typ des Knotens.
Die Anweisung beim Erstellen eines
Zellenobjekts "name" lautet beispielsweise: cellItem = new QtableWidgetItem (Name, MainWindow :: ctName);
Unter diesen ist MainWindow :: ctName ein konstanter Wert des definierten Aufzählungstyps CellType.
Die Zelle "Name" ruft auch die Funktion setData () auf, um benutzerdefinierte Daten festzulegen, in denen die Studenten-ID gespeichert ist.
cellItem-> setData (Qt :: UserRole, QVariant (StudID));
Diese benutzerdefinierten Daten werden nicht auf der Benutzeroberfläche angezeigt, sondern sind der Zelle zugeordnet.
QTableWidgetItem verfügt über einige Funktionen zum Festlegen der Eigenschaften von Zellen:
setTextAlignment (int align): Festlegen der Textausrichtung.
setBackground (const QBrush & Pinsel): Legen Sie die Hintergrundfarbe der Zelle fest.
setForeground (const QBrush & Pinsel): Legt die Vordergrundfarbe der Zelle fest.
setIcon (const QIcon & icon): Legen Sie ein Anzeigesymbol für die Zelle fest.
setFont (const QFont & font): Legen Sie die Schriftart für den Zellenanzeigetext fest.
setCheckState (Qt :: CheckState-Status): Legen Sie den Zellenprüfstatus fest, und eine QCheckBox-Komponente wird in der Zelle angezeigt.
setFlags (Qt :: ItemFlags-Flags): Setzt einige Attributflags der Zelle.
Verwenden Sie nach dem Festlegen der verschiedenen Eigenschaften des Elements die setItem-Funktion von QTableWidget, um das Element als Element der Zelle
festzulegen , z. B.: Ui-> tableInfo-> setItem (rowNo, MainWindow :: colName, item);
Unter diesen ist MainWindow :: colName ein konstanter Wert des definierten Aufzählungstyps FieldColNum.
Nachdem Sie die Einstellungen auf diese Weise initialisiert haben, können Sie den Tabelleninhalt zur Laufzeit abrufen (siehe Abbildung 2). Die Studenten-ID wird nicht in der Tabelle angezeigt. Die Studenten-ID sind die zugehörigen Daten der Zelle "Name".
Aktuelle Zellendaten abrufen
Wenn die Maus auf eine Zelle in der Tabelle klickt, ist die ausgewählte Zelle die aktuelle Zelle. Über currentColumn () und currentRow () von QTableWidget können die Spaltennummer und die Zeilennummer der aktuellen Zelle abgerufen werden.
Wenn die aktuelle Zelle umgeschaltet wird, werden das Signal currentCellChanged () und das Signal currentItemChanged () ausgegeben. Beide Signale können verwendet werden, die übergebenen Parameter sind jedoch unterschiedlich.
Schreiben Sie eine Slot-Funktion für das currentCellChanged () -Signal, um die Daten der aktuellen Zelle und die Schüler-ID-Informationen der aktuellen Zeile
abzurufen . Der Code lautet wie folgt: void MainWindow :: on_tableInfo_currentCellChanged (int currentRow, int currentColumn, int previousRow, int previousColumn)
{ // Die Antwort, wenn sich die aktuell ausgewählte Zelle ändert
Q_UNUSED (previousRow);
Q_UNUSED (previousColumn);
QTableWidgetItem * item = ui-> tableInfo-> item (currentRow, currentColumn); // Liefert das
Element der Zelle if (item == NULL)
return;
labCellIndex-> setText (QString :: asprintf ("Aktuelle Zellkoordinaten:% d Zeile,% d Spalte", currentRow, currentColumn));
int cellType = item-> type (); // Hole die Zelle Typ
labCellType-> setText (QString :: asprintf ( "current Zelltyp:% d", Zelltyp));
item = UI-> tableInfo-> item (currentRow, Mainwindow :: colName); // die aktuelle Zeile nimmt zuerst Item
int ID der Zelle in Spalte 1 = item-> data (Qt :: UserRole) .toInt (); // Benutzerdefinierte Daten lesen
labStudID-> setText (QString :: asprintf ("Schüler-ID:% d", ID)); // Schüler-ID
}
Im Signal currentCellChanged () repräsentieren die übergebenen Parameter currentRow und currentColumn die Zeilennummer und Spaltennummer der aktuellen Zelle Durch diese beiden Zahlen kann das QTableWidgetltem-Objektelement der Zelle erhalten werden.
Nachdem das Element abgerufen wurde, wird der Typparameter der Zelle über die Funktion type () abgerufen. Dieser Typ ist der Typparameter, der beim Erstellen des QTableWidgetItem-Objekts für die Zelle übergeben wird.
Rufen Sie dann das Element der Zelle "Name" in derselben Zeile ab und extrahieren Sie mit der Funktion data () die benutzerdefinierten Daten. Dies ist die Schüler-ID, die beim Erstellen der Zelle gespeichert wird.
Einfügen, Hinzufügen und Löschen von Zeilen
QTableWidget verarbeitet Zeilenoperationen wie folgt:
insertRow (int row) : Fügen Sie eine Zeile vor der Zeile ein, deren Zeilennummer Zeile ist. Wenn die Zeile gleich oder größer als die Gesamtzahl der Zeilen ist, fügen Sie am Ende der Tabelle eine Zeile hinzu. Die Funktion insertRow () fügt nur eine leere Zeile ein und erstellt kein QTableWidgetItem-Objekt für die Zelle. Sie muss manuell für die Zelle erstellt werden.
removeRow (int row): Löscht die Zeile, deren Zeilennummer row ist.
Das Folgende ist der Antwortcode der Schaltflächen "Zeile einfügen", "Zeile hinzufügen" und "Aktuelle Zeile löschen" auf der Benutzeroberfläche. Nach dem Einfügen einer Zeile wird die Funktion createItemsARow () aufgerufen, um ein QTableWidgetItem-Objekt für jede Zelle der neu erstellten leeren Zeile zu
erstellen : void MainWindow :: on_btnInsertRow_clicked ()
{// Zeile
einfügen // int curRow;
int curRow = ui-> tableInfo -> currentRow (); // Aktuelle Zeilennummer
ui-> tableInfo-> insertRow (curRow); // Eine Zeile einfügen, erstellt jedoch nicht automatisch Elemente für die Zelle
createItemsARow (curRow, "New Student", "Male",
QDate :: fromString ("1990-1-1", "yyyy-Md"), "Miao", true, 60); // Elemente für eine Zeile erstellen
}
void MainWindow :: on_btnAppendRow_clicked ()
{// Zeile hinzufügen
// int curRow;
int curRow = ui-> tableInfo-> rowCount (); // Aktuelle Zeilennummer
ui-> tableInfo-> insertRow (curRow); // Fügen Sie am Ende der Tabelle eine Zeile hinzu
createItemsARow (curRow, "newborn", "female" ,
QDate :: fromString ("2000-1-1", "yyyy-Md"), "Manchu", false, 50); // Elemente für eine Zeile erstellen
}
void MainWindow :: on_btnDelCurRow_clicked ()
{// Lösche die aktuelle Zeile und ihre Elemente
// int curRow;
int curRow = ui-> tableInfo-> currentRow (); // Aktuelle Zeilennummer
ui-> tableInfo-> removeRow (curRow) ; // Aktuelle Zeile und ihre Elemente löschen
} Zeilenhöhe
und Spaltenbreite
automatisch anpassen QTableWidget verfügt über mehrere Funktionen zum automatischen Anpassen der Zeilenhöhe und Spaltenbreite der Tabelle:
resizeColumnsToContents (): Passt die Breite aller Spalten automatisch an den Inhalt an .
resizeColumnToContents (int column): Passt automatisch die Breite der Spalte an, deren Spaltennummer co / www lautet.
resizeRowsToContents (): Passt die Höhe aller Zeilen automatisch an ihren Inhalt an.
resizeRowToContents (int row): Passt automatisch die Höhe der Zeile an, deren Zeilennummer roh ist.
Diese Funktionen sind tatsächlich Funktionen von QTableView, der übergeordneten Klasse von QTableWidget.
Sonstige Eigenschaftssteuerung
Legen Sie fest, ob der Inhalt der Tabelle bearbeitet werden kann: Die EditTriggers-Eigenschaft von QTableWidget gibt an, ob sie bearbeitet werden kann und wie der Bearbeitungsstatus aufgerufen werden kann. Der Slot-Funktionscode des Kontrollkästchens "Tabelle editierbar" auf der Schnittstelle lautet:
void MainWindow :: on_chkBoxTabEditable_clicked (bool markiert)
{// Den Bearbeitungsmodus festlegen ,
wenn (aktiviert)
// Doppelklicken oder klicken, nachdem der Fokus abgerufen wurde, um den Bearbeitungsstatus
ui aufzurufen -> tableInfo-> setEditTriggers (QAbstractItemView :: DoubleClicked | QAbstractItemView :: SelectedClicked);
sonst
UI-> tableInfo-> setEditTriggers (QAbstractItemView :: NoEditTriggers); // Bearbeiten ist nicht erlaubt
}
Set Zeilenkopf und Listenkopf , ob angezeigt werden soll : horizontalHeader () Ruft den Zeilenkopf ab, verticalHeader () ruft den Kopf ab und legt dann seine Sichtbarkeit fest.
void MainWindow :: on_chkBoxHeaderH_clicked (bool geprüft)
{ // Gibt an, ob der horizontale Header angezeigt werden soll. ui-> tableInfo-> horizontalHeader () -> setVisible (geprüft); } void MainWindow ::
{ // Ob die vertikale Kopfzeile angezeigt UI-> tableInfo-> verticalHeader () -> setVisible (geprüft); } Intervall Zeile Hintergrundfarbe: setAltematingRowColors () Funktion kann eingestellt werden, ob die Zeilen der Tabelle mit alternativen Hintergrundfarben angezeigt werden, wenn es alternativer Hintergrund ist Farbe, die Intervalllinie verwendet Grau als Hintergrundfarbe. Für die Einstellung der spezifischen Hintergrundfarbe muss styleSheet verwendet werden, das in den folgenden Kapiteln vorgestellt wird. Leere Mainwindow :: on_chkBoxRowColor_clicked (bool geprüft) { UI-> tableInfo-> setAlternatingRowColors (markiert); } Auswahlmodus: setSelectionBehavior () gibt die Auswahlmethode Zellenauswahl oder Zeilenauswahl einstellen: Leere Hauptfenster :: on_rBtnSelectItem_clicked () { // Auswahlverhalten: Zellenauswahl ui-> tableInfo-> setSelectionBehavior (QAbstractltemView :: Selectltems); } void MainWindow :: on_rBtnSelectRow_clicked () {// Auswahlverhalten: Zeilenauswahl ui-> tableInfo-> setSelectionBehavior (QAbstractltemView :: SelectRes ); } Durchlaufen Sie die Tabelle, um Daten zu lesen
Die Schaltfläche "Tabelleninhalt in Text lesen" demonstriert die Methode zum Lesen des gesamten Inhalts des Tabellendatenbereichs. Sie liest den Text jeder Zelle und der Text der Zellen in derselben Zeile wird durch Leerzeichen als Text getrennt Eine Zeile, und verwenden Sie diese Textzeile dann als eine Zeile des Texteditors. Der Code lautet wie folgt:
void MainWindow :: on_btnReadToEdit_clicked ()
{// Extrahieren Sie die Zeichenfolge aus allen Zeilen von QTableWidget und zeigen Sie sie in QPlainTextEdit
QString str;
QTableWidgetItem * cellItem an.
ui-> textEdit-> clear (); // Lösche den Texteditor
für (int i = 0; itableInfo-> rowCount (); i ++) // Zeile für Zeile verarbeiten
{ str = QString :: asprintf ("Zeile% d : ", I + 1); for (int j = 0; jtableInfo-> columnCount () - 1; j ++) // Spalte für Spalte verarbeitet, die letzte Spalte ist jedoch ein Prüftyp , der separat verarbeitet wird { cellItem = ui-> tableInfo-> item (i, j); // Hole das Element der Zelle str = str + cellItem-> text () + ""; // string connection } cellItem = ui-> tableInfo-> item (i, colPartyM); / / Die letzte Spalte, Gruppenmitglieder if (cellItem-> checkState () == Qt :: Checked) // Text entsprechend dem Prüfstatus anzeigen
str = str + "Parteimitglied";
sonst
str = str + "Masse";
ui-> textEdit-> appendPlainText (str); // Als Zeile zum Bearbeitungsfeld hinzufügen
}
}
<Qt QTreeWidget und QDockWidget