Qt QTableWidget e operações básicas (versão detalhada)
<Qt QTreeWidget e QDockWidgetQt Model / View structure>
C Language Chinese Network lançou aulas de tutoria, incluindo "aulas de tutoria de linguagem C, aulas de tutoria C ++, aulas de algoritmo / estrutura de dados", todas elas são aulas individuais: aulas individuais + perguntas e respostas individuais + tarefas + projetos Prática + aprendizagem permanente. QQ está online, pronto para responder!
QTableWidget é uma classe de componente de tabela em Qt. Após colocar um componente QTableWidget no formulário, você pode definir suas propriedades no Editor de Propriedades Clique duas vezes neste componente para abrir um editor e editar sua Coluna, Linha e Item.
A estrutura básica da interface de um componente QTableWidget é mostrada na Figura 1. A tabela é definida para 6 linhas e 5 colunas.
Figura 1 A estrutura básica de uma tabela QTableWidget e os números de índice de linha e coluna da área de trabalho
A primeira linha da tabela é chamada de cabeçalho da linha, que é usada para definir o título de cada coluna, e a primeira coluna é chamada de cabeçalho da lista. Você pode definir o título, mas geralmente usa o título padrão, que é o número da linha. Os cabeçalhos de linha e de lista geralmente não são editáveis.
A área da tabela, exceto o cabeçalho da linha e o cabeçalho da lista, é a área de conteúdo. A área de conteúdo é uma grade regular como uma matriz bidimensional. Cada célula da grade é chamada de célula. Cada célula tem um número de linha e um número de coluna. A Figura 1 mostra a lei de mudança do número da linha e do número da coluna.
Na tabela QTableWidget, cada célula é um objeto QTable Widgetltem, você pode definir o conteúdo do texto, fonte, cor do primeiro plano, cor do plano de fundo, ícone e sinalizadores de edição e exibição. Cada célula também pode armazenar dados QVariant para configurar dados definidos pelo usuário.
Figura 2 Interface de tempo de execução da instância Samp4_9
O exemplo samp4_9 usa QTableWidget como o componente principal para demonstrar a realização de algumas operações principais de QTableWidget. A interface quando o exemplo está rodando é mostrado na Figura 2. Este exemplo irá demonstrar a realização das seguintes funções:
configuração do número de colunas e linhas da tabela, configuração do texto e formato do cabeçalho.
Inicialize os dados da tabela, defina um lote de dados de instância para preencher a tabela.
Inserir linha, adicionar linha, excluir operação de linha atual.
Percorra todas as células da tabela, leia o conteúdo da tabela em um QPlainTextEdit, uma linha de dados na tabela como uma linha de texto.
Quando a célula atual selecionada na tabela muda, as informações armazenadas na célula são exibidas na barra de status.
Design de interface e inicialização
A janela principal de Samp4_9 é herdada de QMainWindow. Na janela mostrada na Figura 2, um componente QTableWidget e um componente QPlainTextEdit formam um divisor de layout divisor. Os botões à esquerda são colocados em um componente QGroupBox, usando o layout Grid e, em seguida, o groupBox e o divisor são divididos em layouts esquerdo e direito. Este é um layout típico de três zonas.
Na classe da janela principal MainWindow, algumas variáveis e funções são personalizadas para a seguinte implementação de código. A seguir estão as variáveis e funções personalizadas na parte privada de MainWindow:
private:
// Personalize o tipo de célula Tipo, na criação de célula Use
enum CellType {ctName = 1000, ctSex, ctBirth, ctNation, ctPartyM, ctScore};
// o número da coluna de cada campo na tabela
enum FieldColNum {colName = 0, colSex, colBirth, colNation, colScore, colPartyM} ;
QLabel * labCellIndex; // O número da linha e o número da coluna
usados para exibir a célula na barra de status
QLabel * labCellType; // O tipo QLabel usado para exibir a célula na barra de status * labStudID; // A barra de status é usada para exibir o aprendizado Não.
Void createItemsARow (int rowNo, QString Name , QString Sex, QDate birth, QString Nation, bool isPM, int score); // criar itens para uma linha
O tipo de enumeração CellType é usado para indicar o tipo de célula e é usado ao criar uma célula. O tipo de enumeração FieldColNum usa uma constante de enumeração para representar o número da coluna de cada campo na tabela.
A interface é inicializada no construtor de MainWindow, o código é o seguinte:
MainWindow :: MainWindow (QWidget * parent): QMainWindow (parent), ui (new Ui :: MainWindow)
{ ui-> setupUi (this); setCentralWidget (ui- > splitterMain); // Criação de inicialização da barra de status labCellIndex = new QLabel ("coordenadas da célula atual:", isto); labCellIndex-> setMinimumWidth (250); labCellType = new QLabel ("tipo de célula atual:", isto); labCellType-> setMinimumWidth (200); labStudID = new QLabel ("Student ID:", this); labStudID-> setMinimumWidth (200); ui-> statusBar-> addWidget (labCellIndex); // Adicionar à barra de status ui-> statusBar-> addWidget (labCellType); ui-> statusBar-> addWidget (labStudID); } Operação básica de QTableWidget Defina o cabeçalho
O botão "Definir cabeçalho" na interface implementa a configuração do cabeçalho e o código da função de slot do sinal clicked () é o seguinte:
void MainWindow :: on_btnSetHeader_clicked ()
{// Definir o cabeçalho
QTableWidgetItem * headerItem;
QStringList headerText;
headerText << "Nome" << "Sexo" << "Data de Nascimento" << "Nacionalidade" << "Pontuação" << "Membro do Partido"; // O cabeçalho da tabela é representado por QStringList
// ui-> tableInfo-> setHorizontalHeaderLabels ( headerText);
ui-> tableInfo-> setColumnCount (headerText.count ()); // O número de colunas é definido igual ao número de linhas de headerText
para (int i = 0; itableInfo-> columnCount (); i ++) // Número da coluna A partir de 0
{ // cellItem = ui-> tableInfo-> horizontalHeaderItem (i); headerItem = new QTableWidgetItem (headerText.at (i)); // Crie um novo QTableWidgetItem, headerText.at (i) obtém os caracteres de linha de headerText String QFont font = headerItem-> font (); // Obter a configuração de fonte original font.setBold (true);// Definir como negrito
font.setPointSize (12); // tamanho da fonte
headerItem-> setTextColor (Qt :: red); // cor da fonte
headerItem-> setFont (font); // definir fonte
ui-> tableInfo-> setHorizontalHeaderItem (i, headerItem) ; // Definir o item da célula do cabeçalho
}
ui-> tableInfo-> setItemDelegateForColumn (colScore, & spinDelegate); // Definir o componente proxy personalizado
}
O título do texto de cada coluna do cabeçalho da linha é inicializado e armazenado por um objeto QStringList headerText, se apenas Para definir os cabeçalhos de cada coluna no cabeçalho da tabela de linhas, use a seguinte linha de instruções:
ui-> tableInfo-> setHorizontalHeaderLabels (headerText);
Se você precisa fazer configurações de formato mais específicas, você precisa criar uma variável do tipo QTableWidgetItem para cada célula do cabeçalho da tabela de linhas e configurá-la de acordo.
Em uma tabela, seja o cabeçalho ou a área de trabalho, cada célula é um objeto QTableWidgetItem. O objeto QTableWidgetItem armazena todo o conteúdo da célula, incluindo o título da palavra, formatação e dados associados. O loop for no programa acima atravessa cada linha de headerText, cria um objeto QTableWidgetItem headerltem com cada linha de texto, então define o tamanho da fonte de headerItem para 12, negrito e vermelho, e então atribui headerltem para uma certa coluna do cabeçalho:
ui- > tableInfo-> setHorizontalHeaderItern (i, headerItem);
Inicializar dados da tabela
O botão "inicializar dados da tabela" na interface gera dados para preencher a tabela de acordo com o número de linhas na tabela e gera um objeto QTableWidgetItem para cada célula e define as propriedades correspondentes. A seguir está o código da função de slot do sinal clicked () de
btnlniData : void MainWindow :: on_btnIniData_clicked ()
{// Inicializar o conteúdo da tabela
QString strName, strSex;
bool isParty = false;
QDate birth;
birth.setDate (1980,4,7); // Inicializa uma data
ui-> tableInfo-> clearContents (); // Limpa apenas a área de trabalho, não o cabeçalho
int Rows = ui-> tableInfo-> rowCount (); // Número de linhas na área de dados,
para (int i = 0; i <Rows; i ++) // O número da linha 1 na área de dados é 0, então o intervalo é 0 ~ rowCount () - 1
{ strName = QString :: asprintf ("student% d", i); // Nome do aluno if ((i% 2) == 0) // Definir o gênero em linhas pares e ímpares e seu ícone strSex = "Masculino"; else strSex = "Feminino"; createItemsARow (i, strNome, strSex, nascimento, " Nacionalidade Han ", isParty, 70); // Criar itens para uma linha
birth = birth.addDays (20); // Data mais 20 dias
isParty =! isParty;
}
} A função
QTableWidget :: clearContents () limpa todo o conteúdo da área de dados da tabela, mas não limpa o cabeçalho.
A função QTableWidget :: rowCount () retorna o número de linhas na área de dados da tabela.
Gere os dados que precisam ser exibidos para cada linha no loop for e, em seguida, chame a função customizada createItemsARow () para gerar objetos QTableWidgetItem para cada célula em uma linha da tabela.
createItemsARow () é uma função personalizada na classe de formulário, seu código de implementação é o seguinte:
void MainWindow :: createItemsARow (int rowNo, QString Name, QString Sex, QDate birth, QString Nation, bool isPM, int score)
{// é Criar uma linha de células Itens
QTableWidgetItem * item;
QString str;
uint StudID = 201605000; // Cardinalidade da ID do aluno
// Nome
// Criar um novo item, definir o tipo de célula para customizado MainWindow :: ctName
item = new QTableWidgetItem (Name , MainWindow :: ctName);
item-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Formato de alinhamento do texto
StudID + = rowNo; // ID do aluno = base + número da linha
item-> setData (Qt :: UserRole, QVariant (StudID)); // Definir studID para dados
ui-> tableInfo-> setItem (rowNo, MainWindow :: colName, item); // Definir item para a célula
// Gender
QIcon ícone;
if (Sex == "masculino")
icon.addFile (": / images / icons / boy.ico");
else
icon.addFile (": / images / icons / girl.ico");
item = new QTableWidgetItem (Sex, MainWindow :: ctSex); // Crie um novo item, defina o tipo de célula para MainWindow :: ctSex item-
> setIcon (ícone);
item-> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Definir item
ui-> para a célula tableInfo-> setItem (rowNo, MainWindow :: colSex, item); // Definir Item para a célula
// data de nascimento
str = birth.toString ("aaaa-MM-dd"); // data é convertida em string
item = new QTableWidgetItem (str, MainWindow :: ctBirth); // Criar um novo Item, definir o tipo de célula para um
item MainWindow :: ctBirth personalizado- > setTextAlignment (Qt :: AlignLeft | Qt :: AlignVCenter); // Formato de alinhamento de texto
ui-> tableInfo-> setItem (rowNo, MainWindow :: colBirth, item); // Definir item para a célula
// étnica
item = new QTableWidgetItem (Nation, MainWindow :: ctNation); // Crie um novo Item, defina o tipo de célula para MainWindow :: ctNation item-
> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Texto Formato de alinhamento
ui-> tableInfo-> setItem (rowNo, MainWindow :: colNation, item); // Definir item para a célula
// É um
item de membro do partido = new QTableWidgetItem ("Party member", MainWindow :: ctPartyM); // Crie um novo Item, defina o tipo de célula para MainWindow :: ctPartyM item-
> setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Formato de alinhamento de texto
if (isPM) item-
> setCheckState (Qt :: Checked);
else
item-> setCheckState (Qt :: Unchecked);
item-> setBackgroundColor (Qt :: amarelo); // Qt :: luz verdeGray amarelo
ui-> tableInfo-> setItem (rowNo, MainWindow :: colPartyM, item); / / Definir item para a célula
// Pontuação
str.setNum (pontuação);
item = new QTableWidgetItem (str, MainWindow :: ctScore); // Crie um novo Item e defina o tipo de célula para um
item MainWindow :: ctPartyM personalizado- > setTextAlignment (Qt :: AlignHCenter | Qt :: AlignVCenter); // Texto Formato de alinhamento
ui-> tableInfo-> setItem (rowNo, MainWindow :: colScore, item); // Definir item para a célula
}
Cada linha da tabela tem 5 colunas, e um item variável do tipo QTableWidgetItem é criado para cada célula , E faça as configurações correspondentes.
O protótipo do construtor usado para criar QTableWidgetItem é:
QTableWidgetItem :: QTableWidgetItem (const QString & text, int type = Type)
Entre eles, o primeiro parâmetro é o texto de exibição da célula, e o segundo parâmetro é o tipo do nó.
Por exemplo, a instrução ao criar um objeto de célula "name" é:
cellItem = new QtableWidgetItem (Name, MainWindow :: ctName);
Entre eles, MainWindow :: ctName é um valor constante do tipo de enumeração definido CellType.
A célula "Nome" também chama a função setData () para definir dados personalizados, que armazenam a ID do aluno.
cellItem-> setData (Qt :: UserRole, QVariant (StudID));
Esses dados personalizados não são exibidos na interface, mas estão associados à célula.
QTableWidgetItem possui algumas funções para definir as propriedades das células, como segue:
setTextAlignment (int direction): Define o alinhamento do texto.
setBackground (const QBrush & brush): Defina a cor de fundo da célula.
setForeground (const QBrush & brush): Defina a cor de primeiro plano da célula.
setIcon (const QIcon & icon): Defina um ícone de exibição para a célula.
setFont (const QFont & font): Define a fonte para o texto de exibição da célula.
setCheckState (Qt :: CheckState state): define o estado de verificação da célula e um componente QCheckBox aparece na célula.
setFlags (Qt :: ItemFlags flags): Define alguns flags de atributo da célula.
Depois de definir as várias propriedades do item, use a função setItem de QTableWidget para definir o item como o item da célula, por exemplo:
ui-> tableInfo-> setItem (rowNo, MainWindow :: colName, item);
Entre eles, MainWindow :: colName é um valor constante do tipo de enumeração definido FieldColNum.
Depois de inicializar as configurações dessa maneira, você pode obter o conteúdo da tabela no tempo de execução, conforme mostrado na Figura 2. A ID do aluno não é exibida na tabela. A ID do aluno é o dado associado da célula "Nome".
Obter os dados da célula atual
Quando o mouse clica em uma célula da tabela, a célula selecionada é a célula atual. Por meio de currentColumn () e currentRow () de QTableWidget, o número da coluna e o número da linha da célula atual podem ser obtidos.
Quando a célula atual é trocada, o sinal currentCellChanged () e o sinal currentItemChanged () serão emitidos. Ambos os sinais podem ser usados, mas os parâmetros passados são diferentes.
Escreva uma função de slot para o sinal currentCellChanged () para obter os dados da célula atual e as informações de ID do aluno da linha atual. O código é o seguinte:
void MainWindow :: on_tableInfo_currentCellChanged (int currentRow, int currentColumn, int previousRow, int previousColumn)
{ // A resposta quando a célula selecionada atualmente muda
Q_UNUSED (previousRow);
Q_UNUSED (previousColumn);
QTableWidgetItem * item = ui-> tableInfo-> item (currentRow, currentColumn); // Obter o
item da célula if (item == NULL)
return;
labCellIndex-> setText (QString :: asprintf ("Coordenadas da célula atual:% d linha,% d coluna", currentRow, currentColumn));
int cellType = item-> type (); // Obter a célula Digite
labCellType-> setText (QString :: asprintf ("tipo de célula atual:% d", cellType));
item = ui-> tableInfo-> item (currentRow, MainWindow :: colName); // pegue a linha atual primeiro O item
int ID da célula na coluna 1 = item-> dados (Qt :: UserRole) .toInt (); // Lê dados definidos pelo usuário
labStudID-> setText (QString :: asprintf ("ID do aluno:% d", ID)); // ID do aluno
}
No sinal currentCellChanged (), os parâmetros passados currentRow e currentColumn representam o número da linha e o número da coluna da célula atual , Por meio desses dois números, o item de objeto QTableWidgetltem da célula pode ser obtido.
Após a obtenção do item, o parâmetro de tipo da célula é obtido através da função type () .Este tipo é o parâmetro de tipo passado na criação do objeto QTableWidgetItem para a célula.
Em seguida, obtenha o item da célula "nome" na mesma linha e use a função data () para extrair os dados personalizados, que é a ID do aluno armazenada quando a célula é criada.
Inserir, adicionar e excluir linhas
QTableWidget processa operações de linha da seguinte maneira:
insertRow (int row): insira uma linha antes da linha cujo número de linha é linha, se linha for igual ou maior que o número total de linhas, adicione uma linha no final da tabela. A função insertRow () apenas insere uma linha em branco e não cria um objeto QTableWidgetItem para a célula. Ele precisa ser criado manualmente para a célula.
removeRow (int row): exclui a linha cujo número de linha é linha.
A seguir está o código de resposta dos botões "Inserir linha", "Adicionar linha" e "Excluir linha atual" na interface. Depois de inserir uma linha, a função createItemsARow () é chamada para construir um objeto QTableWidgetItem para cada célula da linha vazia recém-criada:
void MainWindow :: on_btnInsertRow_clicked ()
{// Inserir uma linha
// int curRow;
int curRow = ui-> tableInfo -> currentRow (); // Número da linha atual
ui-> tableInfo-> insertRow (curRow); // Insere uma linha, mas não criará itens automaticamente para a célula
createItemsARow (curRow, "New Student", "Male",
QDate :: fromString ("1990-1-1", "yyyy-Md"), "Miao", true, 60); // Criar itens para uma linha
}
void MainWindow :: on_btnAppendRow_clicked ()
{// Adicionar uma linha
// int curRow;
int curRow = ui-> tableInfo-> rowCount (); // Número da linha atual
ui-> tableInfo-> insertRow (curRow); // Adicionar uma linha no final da tabela
createItemsARow (curRow, "newborn", "female" ,
QDate :: fromString ("2000-1-1", "yyyy-Md"), "Manchu", false, 50); // Criar itens para uma linha
}
void MainWindow :: on_btnDelCurRow_clicked ()
{// Excluir a linha atual e seus itens
// int curRow;
int curRow = ui-> tableInfo-> currentRow (); // Número da linha atual
ui-> tableInfo-> removeRow (curRow) ; // Excluir a linha atual e seus itens
}
Ajustar automaticamente a altura da linha e largura da coluna
QTableWidget tem várias funções para ajustar automaticamente a altura da linha e largura da coluna da tabela, respectivamente como segue:
resizeColumnsToContents (): ajusta automaticamente a largura de todas as colunas para caber seu conteúdo .
resizeColumnToContents (int column): ajusta automaticamente a largura da coluna cujo número da coluna é co / www.
resizeRowsToContents (): ajusta automaticamente a altura de todas as linhas para caber em seu conteúdo.
resizeRowToContents (int row): ajusta automaticamente a altura da linha cujo número da linha é bruto.
Essas funções são na verdade funções de QTableView, a classe pai de QTableWidget.
Outro controle de propriedade
Defina se o conteúdo da tabela é editável: A propriedade EditTriggers de QTableWidget indica se é editável e a maneira de entrar no estado de edição. O código da função de slot da caixa de seleção "table editable" na interface é:
void MainWindow :: on_chkBoxTabEditable_clicked (bool marcado)
{// Definir o modo de edição
se (marcado)
// Clique duas vezes ou clique após obter o foco para entrar no estado de edição
ui -> tableInfo-> setEditTriggers (QAbstractItemView :: DoubleClicked | QAbstractItemView :: SelectedClicked);
else
ui-> tableInfo-> setEditTriggers (QAbstractItemView :: NoEditTriggers); // Editar não é permitido
}
Definir cabeçalho de linha e cabeçalho de lista para exibir: horizontalHeader () Obtenha o cabeçalho da linha, verticalHeader () obtenha o cabeçalho e, em seguida, defina sua visibilidade.
void MainWindow :: on_chkBoxHeaderH_clicked (bool verificado)
{ // Se deve exibir o cabeçalho horizontal ui-> tableInfo-> horizontalHeader () -> setVisible (verificado); } void MainWindow ::
{ // Se exibir o cabeçalho vertical ui-> tableInfo-> verticalHeader () -> setVisible (verificado); } Cor de fundo da linha do intervalo: a função setAltematingRowColors () pode definir se as linhas da tabela são exibidas com cores de fundo alternativas, se for um fundo alternativo Cor, a linha do intervalo usará cinza como cor de fundo. A configuração da cor de fundo específica requer styleSheet, que será apresentado nos capítulos subsequentes. vazio MainWindow :: on_chkBoxRowColor_clicked (bool marcada) { UI-> tableInfo-> setAlternatingRowColors (marcada); } modo Selecção: setSelectionBehavior () função pode definir o método de seleção para seleção de célula ou seleção de linha: vazio MainWindow :: on_rBtnSelectItem_clicked () { // Comportamento de seleção: seleção de célula ui-> tableInfo-> setSelectionBehavior (QAbstractltemView :: Selectltems); } void MainWindow :: on_rBtnSelectRow_clicked () {// Comportamento de seleção: seleção de linha ui-> tableInfo-> setSelectionBehavior (QAbstractltemView :: SelectRows ); } Percorra a tabela para ler os dados
O botão "Ler o conteúdo da tabela em texto" demonstra o método de leitura de todo o conteúdo da área de dados da tabela. Ele lê o texto de cada célula, e o texto das células na mesma linha é separado por espaços como o texto Uma linha e, em seguida, use esta linha de texto como uma linha do editor de texto. O código é o seguinte:
void MainWindow :: on_btnReadToEdit_clicked ()
{// Extraia a string de todas as linhas de QTableWidget e exiba-a em QPlainTextEdit
QString str;
QTableWidgetItem * cellItem;
ui-> textEdit-> clear (); // Limpa o editor de texto
para (int i = 0; itableInfo-> rowCount (); i ++) // Processo linha por linha
{ str = QString :: asprintf ("% d linha : ", I + 1); for (int j = 0; jtableInfo-> columnCount () - 1; j ++) // Processado coluna por coluna, mas a última coluna é o tipo de verificação, processado separadamente { cellItem = ui-> tableInfo-> item (i, j); // Obtenha o item da célula str = str + cellItem-> text () + ""; // string de conexão } cellItem = ui-> tableInfo-> item (i, colPartyM); / / A última coluna, membros do grupo if (cellItem-> checkState () == Qt :: Checked) // Exibir texto de acordo com o estado de verificação
str = str + "Party Member";
else
str = str + "Mass";
ui-> textEdit-> appendPlainText (str); // Adicionar à caixa de edição como uma linha
}
}
<Qt QTreeWidget e QDockWidget