Faire une seule colonne d'un QTreeWidgetItem modifiable

J'ai un QTreeWidgetItem avec deux colonnes de données, est-il possible de faire seulement la deuxième colonne modifiable? Quand je fais le suivant:

QTreeWidgetItem* item = new QTreeWidgetItem();
item->setFlags(item->flags() | Qt::ItemIsEditable);

toutes les colonnes deviennent modifiables.

InformationsquelleAutor Andreas Brinck | 2010-05-10

c++flags qt qtreewidgetitem

8

Dirait que vous aurez à renoncer à l'aide de QTreeWidget et QTreeWidgetItem et aller avec QTreeView et QAbstractItemModel. Le "Widget" classes sont des classes pratiques qui sont des implémentations concrètes de celle, plus abstraite, mais plus souple versions. QAbstractItemModel a un appel flags(QModelIndex index) où vous retourne la valeur appropriée pour votre colonne.
- Pas nécessairement (si je ne me trompe pas). Voir ma réponse ci-dessous.
- C'est beaucoup plus retravailler que les NoEditDelegate solution affiché ci-dessous, que je considère comme le meilleur.
- Merci @David. J'ai aussi upvoted la NoEditDelegate solution. Il semble plus lisible et plus complet et je le recommande pour plusieurs de modifier des déclencheurs.
InformationsquelleAutor Harald Scheirich
27

Vous pouvez faire seulement certaines colonnes dans un QTreeWidget modifiable à l'aide d'une solution de contournement:

1) Définir la editTriggers propriété de la QTreeWidget à NoEditTriggers

2) Sur l'insertion d'éléments, définir l'intervalle Qt:ItemIsEditable drapeau de la QTreeWidgetItem objet

3) le raccordement de l'emplacement à la "itemDoubleClicked" le signal de la QTreeWidget objet:
```
void MainWindow::onTreeWidgetItemDoubleClicked(QTreeWidgetItem * item, int column)
{
    if (isEditable(column)) {
        ui.treeWidget->editItem(item, column);
    }
}
```
où "isEditable" est une fonction que vous avez écrit qui retourne vrai pour les colonnes modifiables et false pour les non-modifiable colonnes.
- La meilleure solution dans mon cas. Merci!
- En Double-cliquant sur n'est pas la seule façon de commencer à éditer cependant, il ya beaucoup d'autres de modifier des déclencheurs (n'importe quelle touche, la touche de modification (F2 sur Windows/Linux), sur l'actuel point changé, etc. etc.) selon la configuration (setEditTriggers). Si cela semble un peu incomplète.
- Je suis d'accord, @DavidFaure. Ma solution est simple à comprendre et bien testé, mais aurait besoin d'un peu de travail à mettre en œuvre pour plusieurs de modifier des déclencheurs. Si plusieurs de modifier des déclencheurs sont souhaitées, je recommande la NoEditDelegate solution par user571167.
- une fois qu'elle devienne modifiable, est-il possible de définir la stratégie pour la saisie?(À l'aide de QRegExp et QRegExpValidator) comme seuls les nombres sont valides, sinon, ne pas accepter l'entrée? je ne peux pas comprendre cela.
- La solution élégante dans votre cas, serait une classe de l'élément délégué comme dans la solution par user571167, mais au lieu de mettre en œuvre une NoEditDelegate, connectez l'éditeur que vous créez dans createEditor à votre QRegExpValidator. Voir ici pour Qt de discussion et un exemple de comment la sous-classe d'un élément délégué.
- La solution alternative serait de connecter un slot pour QTreeWidget::itemChanged et de mettre en œuvre votre validation. Pour éviter accidentellement la validation d'autres éléments, vous pouvez ajouter un pointeur vers l'élément en cours de modification pour un QSet<QTreeWidgetItem *> ensemble juste avant l'appel de editItem dans ma réponse. Dans le slot connecté à QTreeWidget::itemChanged, vérifiez si l'élément qui a été modifié est dans cet ensemble. Si elle l'est, effectuer la validation et la retirer de l'ensemble. Si vous avez besoin de plus d'exemple de code complet, veuillez poser une nouvelle question et envoyer un lien à cette question ici.
InformationsquelleAutor d11
20

J'ai eu le même problème récemment et a découvert une solution qui fonctionne avec tous les EditTriggers, non seulement l'on double-clique sur l'une (et la connexion à la double cliqué signal)

Créer un Délégué, qui renvoie un Pointeur NULL pour l'éditeur:
```
class NoEditDelegate: public QStyledItemDelegate {
    public:
      NoEditDelegate(QObject* parent=0): QStyledItemDelegate(parent) {}
      virtual QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const {
        return 0;
      }
    };
```
Et à utiliser plus tard comme un délégué personnalisé pour votre colonne
```
ui->parameterView->setItemDelegateForColumn(0, new NoEditDelegate(this));
```
- Excellente option. Vous pouvez également affecter le délégué à l'ensemble de la vue et de vérifier si c'est un bloqué colonne en cochant contre index.column(). Vous pouvez également accéder à la QTreeWidgetItem lui-même par la refonte index.internalPointer() à un QTreeWidgetItem* pour encore plus de contrôle lors de l'édition est bloqué, telles que le blocage d'édition lorsque l'élément a des enfants (comme dans mon cas).
- super réponse, un petit affiner et vous pouvez utiliser ce délégué pour tous : virtual QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { if (index.colonne() >0) { return 0; } return QStyledItemDelegate::createEditor(parent, option, index); }}
InformationsquelleAutor user571167
8

Semblent comme la norme de QTreeWidget ne permet pas ceci. Je pense qu'il y a deux façons de le faire:
1. Utiliser un QTreeView avec votre propre classe dérivée de QAbstractItemModel et de remplacer les drapeaux de la fonction
2. Utiliser un QTreeView avec un QStandardItemModel. Puis, quand vous ajoutez l'élément viens de mettre la colonne appropriée pour permettre l'édition:
Voici un code pour la deuxième option:
```
QString x, y;
QList<QStandardItem*> newIt;
QStandardItem * item = new QStandardItem(x);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
newIt.append(item);
item = new QStandardItem(y);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsEditable);
newIt.append(item);
model->appendRow(newIt);
```
Je trouve la deuxième approche, plus simple mais que tout dépend de la flexibilité que vous voulez avec votre modèle.

InformationsquelleAutor Blaise
6

La façon la plus simple que j'ai trouvé était à l'utilisation de Qt::ItemFlags
```
void myClass::treeDoubleClickSlot(QTreeWidgetItem *item, int column)
{
    Qt::ItemFlags tmp = item->flags();
    if (isEditable(item, column)) {
        item->setFlags(tmp | Qt::ItemIsEditable);
    } else if (tmp & Qt::ItemIsEditable) {
        item->setFlags(tmp ^ Qt::ItemIsEditable);
    }
}
```
Le haut de la if ajoute la fonctionnalité de modification par le biais d'un OR, et, en bas, vérifie si elle est là, avec AND, puis l'enlève avec un XOR.

De cette façon, la fonction d'édition est ajouté quand vous le voulez, et supprimé lorsque vous n'en avez pas.

Puis connectez cette fonction à l'arbre du widget itemDoubleClicked() signal, et d'écrire votre " afin de modifier ou de ne pas modifier la décision à l'intérieur de isEditable()
- réponse parfaite bof moi
InformationsquelleAutor clark

class EditorDelegate : public QItemDelegate
{
    Q_OBJECT

public:
    EditorDelegate(QObject *parent):QItemDelegate(parent){};
    QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const;
};

QWidget* EditorDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    if(index.column() == 1)
    {
        return QItemDelegate::createEditor(parent, option, index);
    }
    return nullptr;
}

Dans le QTreeWidget:

myQTreeWidget::myQTreeWidget()
{
    EditorDelegate *d = new EditorDelegate(this);
    this->setItemDelegate(d);
}

Deux choses: retour nullptr de createEditor() si les colonnes ne doivent pas être modifiés, peut-être dans le cadre de la else. Et de définir l'élément de drapeaux à Qt::ItemIsEditable pour les éléments qui doivent être modifiés autrement le délégué ne sera pas appelé.

InformationsquelleAutor

Peut-être un peu en retard, mais il peut aider :

void MyClass::on_treeWidget_itemDoubleClicked(QTreeWidgetItem *item, int column) {
    Qt::ItemFlags flags = item->flags();
    if(column == 0)
    {
        item->setFlags(flags & (~Qt::ItemIsEditable));
    }
    else
    {
        item->setFlags(flags | Qt::ItemIsEditable);
    } 
}

Ici 0 est l'indice de la colonne que vous souhaitez faire readonly.

flags & (~Qt::ItemIsEditable)

Définit la ItemIsEditable position à 0 quel que soit le pavillon précédent de votre article.

flags | Qt::ItemIsEditable

Sets à 1 quel que soit le pavillon précédent.

InformationsquelleAutor chraz

1

Je suis nouveau sur PySide et Python en général, mais j'ai réussi à obtenir que cela fonctionne en vous inscrivant avec le QTreeWidget pour itemClicked rappels. Dans le rappel, cochez la colonne et appeler 'editItem" si c'est pour une colonne que vous souhaitez autoriser la modification.
```
class Foo(QtGui.QMainWindow):
...
def itemClicked(self, item, column):
   if column > 0:
      self.qtree.editItem(item, column)
```
Par n'est pas en invoquant editItem pour la colonne 0, l'événement est essentiellement jetés.
- Maintenant, essayez d'appuyer sur F2, et vous serez en mesure de modifier la soi-disant non-modifiable colonnes 😉
InformationsquelleAutor Kerry
1

J'ai découvert que le code ci-dessous fonctionne bien pour mes besoins et qui fait "un peu" arrêter la
utilisateur de modifier certaines parties de colonnes:

En gros, j'ai vérifier rôle et de la colonne. Je ne permettent le montage dans la colonne 0. Donc, si l'utilisateur de les modifier dans une autre colonne, puis-je arrêter la setData modifier et aucun changement n'est fait.
```
void treeItemSubclassed::setData(int column, int role, const QVariant &value) {
    if (role == Qt::ItemIsEditable && column != 0){
        return;
    }
    QTreeWidgetItem::setData(column, role, value);
}
```
InformationsquelleAutor Dariusz
0

La valeur de l'enfant de l'arbre-widget modifiable ou non(les itmes de l'arbre), en fonction de la ligne et de la colonne.
- Comment dois-je faire? QTreeWidgetItem::setFlags ne prend pas de colonne comme un argument. Suis-je censé faire dans le QTreeWidget, si oui, avec quelle méthode?
InformationsquelleAutor Naruto

Vous devez vous connecter pour publier un commentaire.