Geler des lignes ou colonnes dans un QTableView

Version imprimable

14/03/2013, 15h14
ricki963

Geler des lignes ou colonnes dans un QTableView

J'ai un tableau avec beaucoup d'information a faire afficher dans un QTableView ou QTableWidget, peut importe. Ce que je veux c'est de pouvoir geler quelque colonnes et lignes, les premières du tableau pour que lorsque je me déplace vers le bas ou la droite dans le tableau, je puisse toujours voir ces lignes et colonnes.

Il existe un exemple de ça, mais programmer en C++ et je n'arrive pas à le convertir ou comprendre suffisamment le code C++ pour le mettre dans mon Python. Ce que je veux c'est un code python. j'ai mis le lien vers le code c++ que j'ai trouvé qui fait ce que je veux

Si quelqu'un peut m'aider à me batir un code python qui fera la même chose ça serait grandement apprécié.

Merci et voici le lien discuté plus haut.

http://harmattan-dev.nokia.com/docs/...zencolumn.html

Salut,

C'est super intéressant ça, j'y ai un peu planché hier soir et ce matin.

Je propose une version Python du code que tu as donné en lien.

Je sous-classe ici un QTableView mais ce pourrait aussi être un QAbstractItemModel, à tester.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class FreezeTableView(QtGui.QtableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.model = model
        self.frozenTable = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenTable)
 
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenTable.verticalScrollBar().valueChanged.connect(self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(self.frozenTableView.verticalScrollBar().setValue)
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.setModel(mdl)
        self.frozenTable.setModel(mdl)
        for i in range(1, self.model.columnCount() - 1):
            self.frozenTable.setColumnHidden(i, true)
            self.frozenTable.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
    def scrollTo(self, index, hint=QtGui.QAbstractItemView.EnsureVisible):
        if index.column() > 0:
            QtGui.QtableView.scrollTo(index, hint)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenTable.setColumnWidth(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenTableView.setRowHeight(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(event)
 
class FrozenTableView(QtGui.QtableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setSelectionModel(QtGui.QItemSelectionModel())
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel)

Le principe de ce code, que tu auras sans doute compris, consiste à afficher par dessus le tableur principal un second tableur d'une seule colonne et auquel on applique le même modèle de données que le premier.

Pour obtenir la même chose avec la première ligne, il faudra donc créer un troisième tableur de la même manière.

Ceci fonctionne tant que les colonnes "figées" se trouvent à gauche du tableur et les lignes "figées" en haut.

Remarques:
Je n'ai rien testé, faudra commencer par les erreurs de syntaxe donc.

Je n'ai pas réimplémenté le mouveCursor(), parce que si j'en comprend l'utilité, la syntaxe m'est apparue quelque peu ésotérique. Je regarderai cela plus tard.

Quoiqu'il en soit, fait des test et tiens nous au courant, il y aura sûrement des choses à corriger mais ça vaut la peine.

Un exemple utilisable: (en tous cas testable)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(12, 20, None)
        for i in range(20):
            self.model.setHeaderData(1, QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(12):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenTable = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenTable)
 
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenTable.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenTable.verticalScrollBar().setValue)
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenTable.setModel(mdl)
        self.frozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        for i in range(1, self.model.columnCount() - 1):
            self.frozenTable.setColumnHidden(i, True)
            self.frozenTable.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
    def scrollTo(self, index, hint):
        if index.column() > 0:
            QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenTable.setColumnWidth(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenTableView.setRowHeight(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

15/03/2013, 12h32
ricki963

Merci, je vais regarder ça cet après midi et demain. Je vous en donne des nouvelle.

Merci, c'est très apprécié et je suis certain que ça va pouvoir servir à d'autre par la suite, donc une fois qu'on aura tout débuger, on pourra mettre le code sur ce post.

J'ai travaillé sur le code et j'ai ajouter le header pour deux ligne en haut du tableau.

Deux problème subsiste par la suite, le premier header que vous avez créer reste là mais les données disparaisse. De plus, au point de jointe des deux header (en ligne et colonne) quand je déplace le scrollBar ça ne fait pas ce qu'on voudrait, on ne vois pas les données correctement au point de jonction.

J'ai tenté plusieurs chose, mais je n'y ai pas arrivé.

De plus, je ne comprends pas la ligne "self.viewport().stackUnder(self.frozenTable)"

Je ne la comprends pas bien. Je croyais que ça permettait de mettre un tableau en dessous, mais je tente de faire apparaitre celui du côté mais je n'y arrive pas.

Merci de votre aide.

Richard

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(12, 20, None)
        for i in range(20):
            self.model.setHeaderData(1, QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(12):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenTable = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
#        self.viewport().stackUnder(self.frozenTable)
 
        self.ligneFrozenTable = FrozenTableView(self)
#        self.viewport().stackUnder(self.ligneFrozenTable)
 
        self.verticalHeader().hide()
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenTable.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenTable.verticalScrollBar().setValue)
 
        self.ligneFrozenTable.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.ligneFrozenTable.horizontalScrollBar().setValue)
 
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenTable.setModel(mdl)
        self.ligneFrozenTable.setModel(mdl)
        self.frozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.ligneFrozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        for i in range(1, self.model.columnCount() - 1):
            self.frozenTable.setColumnHidden(i, True)
            self.frozenTable.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
        for i in range(1, self.model.rowCount() - 1):
            self.frozenTable.setRowHidden(i, True)
            self.frozenTable.setRowHeight(0, self.rowHeight(0))
            self.updateFrozenTableGeometry()
 
    def scrollTo(self, index, hint):
        if index.column() > 0:
            QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenTable.setColumnWidth(0, new)
            self.ligneFrozenTable.setRowHeight(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenTable.setRowHeight(idx, new)
        self.ligneFrozenTable.setColumnWidth(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
        self.ligneFrozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.viewport().width() + self.verticalHeader().width(),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Salut,

Les données qui disparaissent, c'est normal, telle que je l'ai écrite la classe FrozenTableView ne convient que pour une colonne, la geométrie doit être adaptée pour une rangée.

J'ai modifié le code pour que la même classe puisse servir pour une colonne et pour une rangée il suffit d'indiquer l'orientation 0 == horizontal et 1 == vertical.

Le stackUnder() sert bien à garder la table principale en dessous de la table figée mais il ne faut le faire que pour une seule des deux tables figées.

Par contre la cellule commune aux deux tables figées contiendra toujours la donnée de la table qui recouvre les autres. Dans ce cas ci la rangée figée. Et là, je pense qu'on ne pourra rien y faire. En tout cas la question reste posée.

Donc j'ai modifié le code en ajoutant une rangée figée et en déplaçant dans la classe FrozenTableView les méthodes qui lui appartiennent.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(12, 20, None)
        for i in range(19, -1, -1):
            self.model.setHeaderData(i, QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(11, -1, -1):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenColumn = FrozenTableView(self)
        self.frozenColumn.set_orientation(1)
        self.frozenRow = FrozenTableView(self)
        self.frozenRow.set_orientation(0)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenColumn)
 
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenColumn.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.frozenRow.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenColumn.verticalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.frozenRow.horizontalScrollBar().setValue)
 
        if model is not None:
            self.set_model(model)
 
    def show_value(self, val):
        print val
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenColumn.setModel(mdl)
        self.frozenColumn.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenColumn.show_columns()
        self.frozenRow.setModel(mdl)
        self.frozenRow.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenRow.show_rows()
 
    def scrollTo(self, index, hint):
        if index.column() > 0:
            QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenColumn.setColumnWidth(0, new)
            self.frozenColumn.update_geometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenRow.setRowHeight(idx, new)
 
    def resizeEvent(self, event):
        self.frozenColumn.update_geometry()
        self.frozenRow.update_geometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.parent = parent
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.is_vertical = True
 
    def set_orientation(self, orient):
        if orient:
            self.is_vertical = True
            self.verticalHeader().hide()
            self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
 
        else:
            self.is_vertical = False
            self.horizontalHeader().hide()
            self.verticalHeader().hide()
            self.verticalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
 
    def show_columns(self):
        for i in range(1, self.model().columnCount()):
            self.setColumnHidden(i, True)
 
        self.setColumnWidth(0, self.parent.columnWidth(0))
        self.update_geometry()
 
    def show_rows(self):
        for i in range(1, self.model().rowCount()):
            self.setRowHidden(i, True)
 
        self.setRowHeight(0, self.parent.rowHeight(0))
        self.update_geometry()
 
    def update_geometry(self):
        geo = self.parent.viewport().geometry()
        if self.is_vertical:
            self.setGeometry(geo.x(), 0, self.parent.columnWidth(0),
                            geo.height() + 
                            self.parent.horizontalHeader().height())
 
        else:
            self.setGeometry(geo.x(), geo.y(),
                            self.parent.viewport().width() +
                            self.parent.verticalHeader().width(),
                            self.parent.rowHeight(0))
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Il faudra aussi synchroniser les cellules sélectionnées. Quand on sélectionne par exemple une cellule dans la colonne 1 et que l'on se déplace avec la flèche gauche la cellule de la colonne figée ne se sélectionne pas. La sélection existe mais elle est cachée par la table supérieure.
Pareil si on sélectionne une cellule dans la colonne figée et qu'on se déplace avec la flèche droite, la sélection ne se poursuit pas dans la grande table.

Je vais regarder votre code, j'ai aussi continuer à casser un peu la tête et j'ai trouvé une solution pour la jonction des deux header. Je met donc mon code ici et je vais regarder la façon donc vous avez codé. Je suis certain que je peux amiliorer mon code.

Il reste aussi, comme vous l'avez dit, lorsqu'on se déplace dans les cellules, oui on se ramasse en dessous des autres table. Je vais voir ce que je peux faire et mettre le code dans ce post. Bien a vous de regarder ce que j'ai fait et aussi de voir de votre côté une solution pour ce problème. J'ai aussi constater, mais par regarder pour le moment, que lorsque je clic sur une cellule, j'ai un message d'erreur, mais le programme ne crash pas.

Voici le code

Richard

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model,self.modelLigne,self.modelColonne,self.modelJonction)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(12, 20, None)
        self.modelLigne = QtGui.QStandardItemModel(2, 19, None)
        self.modelColonne = QtGui.QStandardItemModel(10, 1, None)
        self.modelJonction = QtGui.QStandardItemModel(2, 1, None)
        for i in range(20):
            self.model.setHeaderData(1, QtCore.Qt.Horizontal, "Col. %s" % i)
        for i in range(2,20):
            self.modelLigne.setHeaderData(1,QtCore.Qt.Horizontal, "Col. %s" % i)
        for i in range(1):
            self.modelJonction.setHeaderData(1,QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(12):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
        for i in range(10,12):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data_ligne(infos)
        for i in range(2, 12):
            infos = ["Row%sCol%s" %(i, j) for j in range(1)]
            self.add_data_colonne(infos)
        for i in range(10,12):
            infos = ["Row%sCol%s" %(i, j) for j in range(1)]
            self.add_data_jonction(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
    def add_data_ligne(self, data):
        self.modelLigne.insertRow(0)
        for idx, val in enumerate(data):
            self.modelLigne.setData(self.modelLigne.index(0, idx), val)
 
    def add_data_colonne(self, data):
        self.modelColonne.insertRow(0)
        for idx, val in enumerate(data):
            self.modelColonne.setData(self.modelColonne.index(0, idx), val)
 
    def add_data_jonction(self, data):
        self.modelJonction.insertRow(0)
        for idx, val in enumerate(data):
            self.modelJonction.setData(self.modelJonction.index(0, idx), val)
 
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenTable = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenTable)
 
        self.ligneFrozenTable = FrozenTableView(self)
        self.frozenTable.viewport().stackUnder(self.ligneFrozenTable)
 
        self.jonctionFrozenTable = FrozenTableView(self)
        self.verticalHeader().hide()
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenTable.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenTable.verticalScrollBar().setValue)
 
        self.ligneFrozenTable.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.ligneFrozenTable.horizontalScrollBar().setValue)
 
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl,mdlLigne,mdlColonne,mdlJonction):
        self.model = mdl
        self.modelLigne = mdlLigne
        self.modelColonne = mdlColonne
        self.modelJonction = mdlJonction
 
        self.setModel(mdl)
        self.frozenTable.setModel(mdl)
        self.ligneFrozenTable.setModel(mdl)
        self.jonctionFrozenTable.setModel(mdl)
 
        self.frozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.ligneFrozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.jonctionFrozenTable.setSelectionModel(QtGui.QItemSelectionModel(mdl))
 
        for i in range(1, self.model.columnCount() - 1):
            self.frozenTable.setColumnHidden(i, True)
            self.frozenTable.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
    def scrollTo(self, index, hint):
        if index.column() > 0:
            QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenTable.setColumnWidth(0, new)
            self.ligneFrozenTable.setRowHeight(0, new)
            self.jonctionFrozenTable.setRowHeight(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenTable.setRowHeight(idx, new)
        self.ligneFrozenTable.setColumnWidth(idx, new)
        self.jonctionFrozenTable.setColumnWidth(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
        self.ligneFrozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.viewport().width() + self.verticalHeader().width(),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
        self.jonctionFrozenTable.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.verticalHeader().width() + self.columnWidth(0),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

16/03/2013, 17h45
tyrtamos

Bonjour,

Bravo les gars, c'est très intéressant!

J'ai essayé le dernier code de VinsS, et j'ai encore quelques problèmes de largeur de colonnes avec la ligne fixe, mais ce n'est pas loin du bout!

Merci!
16/03/2013, 18h08
VinsS

riki963, il ne faut pas créer trois modèles mais appliquer le même modèle aux trois tables. Ce que l'on veut c'est que les trois tables soient synchro au niveau des données.

Voilà, je croix avoir réglé plusieurs chose. Il reste un problème que je n'ai pas encore réglé, soit, a chaque fois que je clic sur une cell du tableau principale j'ai une erreur que voici:

QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
TypeError: QTableView.scrollTo(QModelIndex, QAbstractItemView.ScrollHint hint=QAbstractItemView.EnsureVisible): argument 2 has unexpected type 'ScrollHint'

Pour ce qui est des trois modèle, c'était un test, mais j'avais oublier de l'enlever quand j'ai posté le code. Je vous remet un code clean qui fonctionne bien.

Finalement, vous remarquerez que dans mon code j'ai un autre frozenJoint que j'ai mis. Ce dernier est pour bien gérer la jonction entre les deux tableauHeader.

Autre chose qu'il reste à régler, c'est le déplacement dans les cellules pour que nous puissions passer dans le tableau en haut ou a gauche et même celui dans le coin suppérieur gauche pour que pour l'utilisateur, il n'y vois que du feu.

De plus, on pourrait s'assurer que lorsqu'on se déplace dans le tableau, les vrai Header du tableau "col 1, col 2, etc" se déplace automatiquement.

Une fois le tout régler, je vais intégrer ce code à une fenêtre et poster le code final de la fenêtre que je veux batir. Je croix que mon code final va en intéresser plus d'un. Ma fenêtre final permet d'avoir un tableau pour faire de la planification de temps, ou de réservation de plage de temps par item. Un peu comme un project manager.

Voici mon code:

Richard

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(0, 20, None)
        for i in range(19, -1, -1):
            self.model.setHeaderData(i, QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(11, -1, -1):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenColumn = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenColumn)
 
        self.frozenRow = FrozenTableView(self)
        self.frozenColumn.viewport().stackUnder(self.frozenRow)
 
        self.frozenJoint = FrozenTableView(self)
        self.verticalHeader().hide()
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenColumn.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenColumn.verticalScrollBar().setValue)
 
        self.frozenRow.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.frozenRow.horizontalScrollBar().setValue)
 
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenColumn.setModel(mdl)
        self.frozenRow.setModel(mdl)
        self.frozenJoint.setModel(mdl)
 
        self.frozenColumn.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenRow.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenJoint.setSelectionModel(QtGui.QItemSelectionModel(mdl))
 
        for i in range(1, self.model.columnCount()):
            self.frozenColumn.setColumnHidden(i, True)
            self.frozenColumn.setColumnWidth(0, self.columnWidth(0))
            self.frozenJoint.setColumnHidden(i, True)
            self.frozenJoint.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
        for i in range(2, self.model.rowCount()):
            self.frozenRow.setRowHidden(i, True)
            self.frozenRow.setRowHeight(0, self.rowHeight(0))
            self.frozenJoint.setRowHidden(i, True)
            self.frozenJoint.setRowHeight(0, self.rowHeight(0))
            self.updateFrozenTableGeometry()
 
 
    def scrollTo(self, index, hint):
        if index.column() > 0:
            QtGui.QTableView.scrollTo(self, QtGui.QAbstractItemView.EnsureVisible)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenColumn.setColumnWidth(0, new)
            self.frozenRow.setRowHeight(0, new)
            self.frozenJoint.setRowHeight(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenColumn.setRowHeight(idx, new)
        self.frozenRow.setColumnWidth(idx, new)
        self.frozenJoint.setColumnWidth(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenColumn.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
        self.frozenRow.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.viewport().width() + self.verticalHeader().width(),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
        self.frozenJoint.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.verticalHeader().width() + self.columnWidth(0),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Je propose autre chose pour ne pas créer de troisième table uniquement pour la cellule haut-gauche, remplaces ces lignes:
Code:

1 2 3 4 5 self.verticalScrollBar().valueChanged.connect( self.frozenColumn.verticalScrollBar().setValue) self.horizontalScrollBar().valueChanged.connect( self.frozenRow.horizontalScrollBar().setValue)
par ceci:
Code:

1 2 3 self.verticalScrollBar().valueChanged.connect(self.on_vertical_scrolling) self.horizontalScrollBar().valueChanged.connect(self.on_horizontal_scrolling)
et tu ajoutes les deux fonctions:
Code:

1 2 3 4 5 6 7 8 def on_vertical_scrolling(self, val): self.frozenColumn.stackUnder(self.frozenRow) self.frozenColumn.verticalScrollBar().setValue(val) def on_horizontal_scrolling(self, val): self.frozenRow.stackUnder(self.frozenColumn) self.frozenRow.horizontalScrollBar().setValue(val)
Pour l'erreur, il y a un non-sens:
TypeError: QTableView.scrollTo(QModelIndex, QAbstractItemView.ScrollHint hint=QAbstractItemView.EnsureVisible): argument 2 has unexpected type 'ScrollHint'

bof, remplaces comme ceci, ça fonctionne pareil:
Code:

1 2 3 4 def scrollTo(self, index, hint): if index.column() > 0 and index.row() > 0: QtGui.QTableView.scrollTo(index, hint)
En fait, ça consiste juste à réinjecter le signal dans le circuit si on est en dehors de la colonne ou de la ligne figée.

17/03/2013, 13h11
ricki963

Bonjour VinsS,

encore un gros merci pour votre aide, c'est grandement apprécié.

Pour ce qui est de la modification de l'utilisation de la 3ième table en haut à gauche, j'ai essayé votre code. C'est super et je suis certain que ça peut servir pour certaine situation, mais dans ma situation, le comportement de la fenêtre n'est pas le même.

Si vous tester mon code, vous allez voir que les lignes dans le coin suppérieur gauche ne change jamais, peut-importe que qu'on utiliser, en alternance, les scrollBar vertical et horizontal.

Avec votre modification, j'ai utiliser le scrollBar vertical et je l'ai laissé environ au centre, ensuite j'ai utiliser le scrollBar horizontal et je l'ai laissé aussi environ au centre. Là, si on continue de s'amuser avec les scrollBar on va voir que les donnés dans le coin ne sont pas figé avec les données du début. Ce qui est l'objectif. Généralement, dans ce coin, ce sont des cellule vide. Du moins dans le cas de mon utilisation.

Pour ce qui est du second point, j'ai modifier le ScrollTo et le message est maintenant différent. Le voici:

QtGui.QTableView.scrollTo(index, hint)
TypeError: QTableView.scrollTo(QModelIndex, QAbstractItemView.ScrollHint hint=QAbstractItemView.EnsureVisible): first argument of unbound method must have type 'QTableView'

J'ai demandé un print des données qui sont dans la variable "index et hint" et voici ce qui en est ressorti:

index est : <PyQt4.QtCore.QModelIndex object at 0x035C75A8>
hint est : 0

je ne sais pas si ça peut vous aider. De mon côté, je ne sais pas vraiment ce à quoi s'attend le scrollTo.

Merci encore.

Richard
17/03/2013, 13h18
ricki963
J'ai trouvé, il manquait juste le "self" dans le scrollTo

Voici la procédure corrigé
Code:

1 2 3 4 def scrollTo(self, index, hint): if index.column() > 0 and index.row() > 0: QtGui.QTableView.scrollTo(self,index, hint)
Je vais travailler mon code et vous poster le code complet de la fenêtre qui devrait en intéresser plus d'un. J'ai également une idée pour le déplacement sous les tableHeader. Je croix avoir une solution. Je vais travailler le tout et d'ici un ou deux jour, je vous post ça.

Merci

Richard

J'ai modifier le code de la procédure "scrollTo(self, index, hint):" pour permettre un déplacement du scrollBar avant de perdre sous le header la cellule sélectionné.

De plus, j'ai également ajouter un petit plus qui permet de bien suivre, surtout dans un grand tableau, où l'on se situe (ligne colonne), en sélectionnant la colonne et la ligne des header qu'on a créer.

Voici donc le code complet. Je ne l'ai pas encore intégrer dans mon code, je voulais régler ce petit problème et le partager avant. Donc demain, vous devriez avoir aussi un autre code qui peut servir dans un programme de gestion de projet ou gestion de tâche etc. Vous verrez.

Bref, pour le moment, voici un code qui me semble bien complet pour ce qui est d'avoir des lignes et ou colonne qui serve de Header.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setWindowTitle("FreezeTableView")
        MainWindow.resize(401, 291)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.tableView = FreezeTableView(None, self.centralwidget)
        self.gridLayout.addWidget(self.tableView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 401, 25))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        MainWindow.setStatusBar(self.statusbar)
 
        self.create_model()
        self.tableView.set_model(self.model)
 
    def create_model(self):
        self.model = QtGui.QStandardItemModel(0, 20, None)
        for i in range(19, -1, -1):
            self.model.setHeaderData(i, QtCore.Qt.Horizontal, "Col. %s" % i)
 
        for i in range(11, -1, -1):
            infos = ["Row%sCol%s" %(i, j) for j in range(20)]
            self.add_data(infos)
 
    def add_data(self, data):
        self.model.insertRow(0)
        for idx, val in enumerate(data):
            self.model.setData(self.model.index(0, idx), val)
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenColumn = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenColumn)
 
        self.frozenRow = FrozenTableView(self)
        self.frozenColumn.viewport().stackUnder(self.frozenRow)
 
        self.frozenJoint = FrozenTableView(self)
        self.verticalHeader().hide()
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenColumn.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenColumn.verticalScrollBar().setValue)
 
        self.frozenRow.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.frozenRow.horizontalScrollBar().setValue)
 
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenColumn.setModel(mdl)
        self.frozenRow.setModel(mdl)
        self.frozenJoint.setModel(mdl)
 
        self.frozenColumn.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenRow.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenJoint.setSelectionModel(QtGui.QItemSelectionModel(mdl))
 
        for i in range(1, self.model.columnCount()):
            self.frozenColumn.setColumnHidden(i, True)
            self.frozenColumn.setColumnWidth(0, self.columnWidth(0))
            self.frozenJoint.setColumnHidden(i, True)
            self.frozenJoint.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
        for i in range(2, self.model.rowCount()):
            self.frozenRow.setRowHidden(i, True)
            self.frozenRow.setRowHeight(0, self.rowHeight(0))
            self.frozenJoint.setRowHidden(i, True)
            self.frozenJoint.setRowHeight(0, self.rowHeight(0))
            self.updateFrozenTableGeometry()
 
 
    def scrollTo(self, index, hint):
        if index.column() > 0 or index.row() > 0:
            self.frozenRow.selectColumn(index.column())
            self.frozenColumn.selectRow(index.row())
            if index.column() == 0 or index.row() == 0:
                self.frozenJoint.selectColumn(index.column())
            else:
                self.frozenJoint.selectRow(index.row())
            QtGui.QTableView.scrollTo(self, index, QtGui.QAbstractItemView.EnsureVisible)
            if self.verticalScrollBar().value() > 0:
                nb_descente = int(self.verticalScrollBar().value() / self.rowHeight(0)) + 1
                if index.row() == (nb_descente + 1):
                    if nb_descente != 0:
                        positionV = self.verticalScrollBar().value() - self.rowHeight(0)
                        if positionV < 0:
                            positionV = 0
                        self.verticalScrollBar().setValue(positionV)
            if self.horizontalScrollBar().value() > 0:
                nb_horizontal = int(self.horizontalScrollBar().value() / self.columnWidth(0)) + 1
                if index.column() == (nb_horizontal):
                    if nb_horizontal != 0:
                        positionH = self.horizontalScrollBar().value() - self.columnWidth(0)
                        if positionH < 0:
                            positionH = 0
                        self.horizontalScrollBar().setValue(positionH)
 
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenColumn.setColumnWidth(0, new)
            self.frozenRow.setRowHeight(0, new)
            self.frozenJoint.setRowHeight(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenColumn.setRowHeight(idx, new)
        self.frozenRow.setColumnWidth(idx, new)
        self.frozenJoint.setColumnWidth(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenColumn.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
        self.frozenRow.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.viewport().width() + self.verticalHeader().width(),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
        self.frozenJoint.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.verticalHeader().width() + self.columnWidth(0),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
 
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Tien, ce matin j'avais posté le code qui manquait pour le slot moveCursor(), mais mon post semble avoir disparu ...

Bon, voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
    def moveCursor(self, action, mod):
        current = QtGui.QTableView.moveCursor(self, action, mod)
        cc = current.column()
        cr = current.row()
        xrect = self.visualRect(current).topLeft().x()
        yrect = self.visualRect(current).topLeft().y()
        if action == QtGui.QAbstractItemView.MoveLeft:
            if cc > 0 and xrect < self.frozenColumn.columnWidth(0):
                step = self.columnWidth(cc - 1)
                val = self.horizontalScrollBar().value() + xrect - step
                self.horizontalScrollBar().setValue(val)
 
        elif action == QtGui.QAbstractItemView.MoveUp:
            if cr > 0 and yrect < self.frozenRow.rowHeight(0):
                step = self.rowHeight(cr - 1)
                val = self.verticalScrollBar().value() + yrect - step
                self.verticalScrollBar().setValue(val)
 
        return current

C'est à ajouter à la classe FreezeTableView.

De mon côté, comme promis, voici le code (très basic et épuré) d'une fenêtre avec les lignes et colonne figées, comme dans mon code précédent, mais j'ai ajouter deux boutons, changé les donnés pour donné l'air d'une project manager ou un gestion de tache par exemple. Vous pouvez ajouter des sélections horizontal en sélectionnant des cellules horizontalement et ensuite appuyer sur le bouton Sélection. Pour annuler la sélection, vous la sélectionné et appuyez sur le bouton, annuler sélection.

Voilà. De là, vous pourrez vous amuser et le modifier à votre guise.

Je tiens à remercier Vincent pour son aide.

Voilà le code:

Richard

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
#!/Python32/Lib/site-packages
# -*- coding: utf-8 -*-
 
import sys, hashlib
import datetime
import re
from PyQt4 import QtCore, QtGui, QtSql
from pg8000 import DBAPI
from functools import partial
from CircuitProDbInfo import *
 
 
 
try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s
 
 
 
 
 
#=====================================================================
# Formatage des table de TableView
#=====================================================================
 
class paletteTableview(QtCore.QAbstractTableModel):
    def __init__(self, test_data, headerdata, colorData, parent=None):
        QtCore.QAbstractTableModel.__init__(self, parent)
        self.__test_data = test_data
        self.headerdata = headerdata
        self.colorData = colorData
 
    def rowCount(self, parent):
        return len(self.__test_data)
 
    def columnCount(self, parent):
        return len(self.__test_data[0])
 
    def data(self,index,role):
        if role == QtCore.Qt.DisplayRole:
 
            row = index.row()
            column = index.column()
            value = self.__test_data[row][column]
            return value
 
        if role == QtCore.Qt.BackgroundRole:
            for item in self.colorData:
                if index.row() == item[0] and index.column() == item[1]:
                    if item[4] == "yellow":
                        return QtGui.QBrush(QtCore.Qt.yellow)
                    if item[4] == "blue":
                        return QtGui.QBrush(QtCore.Qt.blue)
                    if item[4] == "red":
                        return QtGui.QBrush(QtCore.Qt.red)
                    if item[4] == "green":
                        return QtGui.QBrush(QtCore.Qt.green)
 
    def headerData(self, col, orientation, role):
        if orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:
            if self.headerdata != None:
                return self.headerdata[col]
 
 
#=====================================================================
# Fenêtre pour le tableau des réservations
#=====================================================================
 
 
 
class Ui_Tableau_reservation(QtGui.QWidget):
    def __init__(self):
        super(Ui_Tableau_reservation,self).__init__()
        self.setupUi()
 
    def setupUi(self):
        self.setObjectName(_fromUtf8("Client_existe"))
        self.resize(800, 460)
        font = QtGui.QFont()
        font.setPointSize(12)
        self.setFont(font)
        self.tableView = FreezeTableView(None, self)
        self.tableView.setGeometry(QtCore.QRect(10, 10, 781, 191))
        self.tableView.setObjectName(_fromUtf8("tableView"))
        self.data = (("","dim, 10 fév","","lun, 11 fév","","mar 12 fév","","","","","",""),("","AM","PM","AM","PM","AM","PM","","","","",""),("item 1","","","red","","red","","","","","",""),("item 2","","","","red","","","","","","",""),("item 3","","","","","","","","","","",""),("item 4","","","","","","","","","","",""),("item 5","","","","","","","","","","",""),("item 6","","","","","","","","","","",""),("item 7","","","","","","","","","","",""),)
        self.header_data = ((""),(""),(""),(""),(""),(""),(""),(""),(""),(""),(""),(""))
        self.colorData = [(2,3,1,2,"red"),(2,5,1,3,"red"),(3,4,1,3,"red"),(0,1,1,2,"white"),(0,3,1,2,"white"),(0,5,1,2,"white")]
        self.modelSql = paletteTableview(self.data,self.header_data,self.colorData)
        self.tableView.set_model( self.modelSql )
        for item in self.colorData:
            self.tableView.setSpan(item[0],item[1],item[2],item[3])
 
        self.Reserver = QtGui.QPushButton(self)
        self.Reserver.setGeometry(QtCore.QRect(130, 230, 121, 31))
        self.Reserver.setObjectName(_fromUtf8("Reserver"))
        self.Annuler = QtGui.QPushButton(self)
        self.Annuler.setGeometry(QtCore.QRect(330, 230, 121, 31))
        self.Annuler.setObjectName(_fromUtf8("Annuler"))
 
        self.show()        
 
 
        self.retranslateUi()
        QtCore.QObject.connect(self.Reserver, QtCore.SIGNAL(_fromUtf8("clicked()")), self.accepter_Ui)
        QtCore.QObject.connect(self.Annuler, QtCore.SIGNAL(_fromUtf8("clicked()")), self.annuler_Ui)
        self.tableView.selectionModel().selectionChanged.connect(self.tblItemChanged)
        QtCore.QMetaObject.connectSlotsByName(self)
 
    def retranslateUi(self):
        self.setWindowTitle(QtGui.QApplication.translate("Client_existe", "Confirmation d\'ajout de client", None, QtGui.QApplication.UnicodeUTF8))
        self.Reserver.setText(QtGui.QApplication.translate("CC_Validation", "Sélection", None, QtGui.QApplication.UnicodeUTF8))
        self.Annuler.setText(QtGui.QApplication.translate("CC_Validation", "Ann. Sélec.", None, QtGui.QApplication.UnicodeUTF8))
 
 
    def tblItemChanged(self, current):
        self.listeCell = self.tableView.selectedIndexes()
        self.coordonneDebut = [self.listeCell[0].row(),self.listeCell[0].column()]
        for item in self.listeCell:
            self.coordonneFin = [item.row(),item.column()]
        self.coordonneSpan = [1,self.coordonneFin[1] - self.coordonneDebut[1]+1]
 
    def accepter_Ui(self):
        self.tableView.setSpan(self.coordonneDebut[0],self.coordonneDebut[1],self.coordonneSpan[0],self.coordonneSpan[1])
        self.colorData.append((self.coordonneDebut[0],self.coordonneDebut[1],self.coordonneSpan[0],self.coordonneSpan[1],"red"))
        self.modelSql = paletteTableview(self.data,self.header_data,self.colorData)
        self.tableView.set_model( self.modelSql )
        self.tableView.selectionModel().selectionChanged.connect(self.tblItemChanged)
 
    def annuler_Ui(self):
 
        self.tableView.setSpan(self.coordonneDebut[0],self.coordonneDebut[1],1,1)
        self.listeCell = self.tableView.selectedIndexes()
        self.coordonneDebut = [self.listeCell[0].row(),self.listeCell[0].column()]
        for item in self.listeCell:
            self.coordonneFin = [item.row(),item.column()]
        self.coordonneSpan = [1,self.coordonneFin[1] - self.coordonneDebut[1]+1]
        index = self.tableView.selectedIndexes()
        indexFin = index[0]
        self.colorData.remove((self.coordonneDebut[0],self.coordonneDebut[1],self.coordonneSpan[0],self.coordonneSpan[1],"red"))
        self.modelSql = paletteTableview(self.data,self.header_data,self.colorData)
        self.tableView.set_model( self.modelSql )
        self.tableView.selectionModel().selectionChanged.connect(self.tblItemChanged)
 
 
 
#=========================================================================
 
class FreezeTableView(QtGui.QTableView):
    def __init__(self, model=None, parent=None):
        super(FreezeTableView, self).__init__(parent)
        self.frozenColumn = FrozenTableView(self)
        self.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
        self.viewport().stackUnder(self.frozenColumn)
 
        self.frozenRow = FrozenTableView(self)
        self.frozenColumn.viewport().stackUnder(self.frozenRow)
 
        self.frozenJoint = FrozenTableView(self)
        self.verticalHeader().hide()
        self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
        self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
        self.frozenColumn.verticalScrollBar().valueChanged.connect(
                                            self.verticalScrollBar().setValue)
        self.verticalScrollBar().valueChanged.connect(
                            self.frozenColumn.verticalScrollBar().setValue)
 
        self.frozenRow.horizontalScrollBar().valueChanged.connect(
                                            self.horizontalScrollBar().setValue)
        self.horizontalScrollBar().valueChanged.connect(
                            self.frozenRow.horizontalScrollBar().setValue)
 
        if model is not None:
            self.set_model(model)
 
    def set_model(self, mdl):
        self.model = mdl
        self.setModel(mdl)
        self.frozenColumn.setModel(mdl)
        self.frozenRow.setModel(mdl)
        self.frozenJoint.setModel(mdl)
 
        self.frozenColumn.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenRow.setSelectionModel(QtGui.QItemSelectionModel(mdl))
        self.frozenJoint.setSelectionModel(QtGui.QItemSelectionModel(mdl))
 
        for i in range(1, self.model.columnCount(0)):
            self.frozenColumn.setColumnHidden(i, True)
            self.frozenColumn.setColumnWidth(0, self.columnWidth(0))
            self.frozenJoint.setColumnHidden(i, True)
            self.frozenJoint.setColumnWidth(0, self.columnWidth(0))
            self.updateFrozenTableGeometry()
 
        for i in range(2, self.model.rowCount(0)):
            self.frozenRow.setRowHidden(i, True)
            self.frozenRow.setRowHeight(0, self.rowHeight(0))
            self.frozenJoint.setRowHidden(i, True)
            self.frozenJoint.setRowHeight(0, self.rowHeight(0))
            self.updateFrozenTableGeometry()
 
    def scrollTo(self, index, hint):
        if index.column() > 0 or index.row() > 0:
            self.frozenRow.selectColumn(index.column())
            self.frozenColumn.selectRow(index.row())
            if index.column() == 0 or index.row() == 0:
                self.frozenJoint.selectColumn(index.column())
            else:
                self.frozenJoint.selectRow(index.row())
            QtGui.QTableView.scrollTo(self, index, QtGui.QAbstractItemView.EnsureVisible)
            if self.verticalScrollBar().value() > 0:
                nb_descente = int(self.verticalScrollBar().value() / self.rowHeight(0)) + 1
                if index.row() == (nb_descente + 1):
                    if nb_descente != 0:
                        positionV = self.verticalScrollBar().value() - self.rowHeight(0)
                        if positionV < 0:
                            positionV = 0
                        self.verticalScrollBar().setValue(positionV)
            if self.horizontalScrollBar().value() > 0:
                nb_horizontal = int(self.horizontalScrollBar().value() / self.columnWidth(0)) + 1
                if index.column() == (nb_horizontal):
                    if nb_horizontal != 0:
                        positionH = self.horizontalScrollBar().value() - self.columnWidth(0)
                        if positionH < 0:
                            positionH = 0
                        self.horizontalScrollBar().setValue(positionH)
 
    def updateSectionWidth(self, idx, old, new):
        if idx == 0:
            self.frozenColumn.setColumnWidth(0, new)
            self.frozenRow.setRowWidth(0, new)
            self.frozenJoint.setRowHeight(0, new)
            self.updateFrozenTableGeometry()
 
    def updateSectionHeight(self, idx, old, new):
        self.frozenColumnView.setRowHeight(idx, new)
        self.frozenRowView.setColumnHeight(idx, new)
        self.frozenJoint.setColumnWidth(idx, new)
 
    def updateFrozenTableGeometry(self):
        self.frozenColumn.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.columnWidth(0),
                                     self.viewport().height() + 
                                     self.horizontalHeader().height())
        self.frozenRow.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.viewport().width() + self.verticalHeader().width(),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
        self.frozenJoint.setGeometry(self.verticalHeader().width() +
                                     self.frameWidth(), self.frameWidth(), 
                                     self.verticalHeader().width() + self.columnWidth(0),
                                     self.horizontalHeader().height() + self.rowHeight(0) + self.rowHeight(1))
 
    def resizeEvent(self, event):
        self.updateFrozenTableGeometry()
        QtGui.QTableView.resizeEvent(self, event)
 
class FrozenTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(FrozenTableView, self).__init__(parent)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.verticalHeader().hide()
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
        self.setHorizontalScrollMode((QtGui.QAbstractItemView.ScrollPerPixel))
 
 
#=========================================================================
 
if __name__ == '__main__':
    app=QtGui.QApplication(sys.argv)
    ui = Ui_Tableau_reservation()
    sys.exit(app.exec_())

19/03/2013, 11h58
ricki963

La nuit, je trouve souvent des idées et ou solution à mes problèmes. Voilà, j'ai eu une idée qui pourrait peut-être éviter d'avoir 2 ou 3 tableview par dessus le tableview de base pour faire des header de ligne. Il suffirait de pouvoir configurer le scrolling vertical et ou horizontal limité à des lignes spécifique. Je m'explique, si on pouvait dire au scrolling de débuter à la ligne 2 plutôt qu'à la ligne 0 et terminé à la fin du tableau comme normal, nous aurions un header de ligne de deux lignes qui ne bougerait pas durant un déplacment. On pourrait faire la même chose avec les colonnes.

Quelqu'un croix que c'est possible ?

J'ai trouvé que dans le QTableView il y a quelque chose qui s'appel QAbstractScrollArea. Je ne suis pas assez avancé pour savoir comment jouer avec ça, je j'ai l'impression qu'on a une piste et ça serait probablement plus simple de gestion.

Je sais qu'on a trouvé une solution, mais il y a toujours place à amélioration en programmation ;o)

Merci à tous ceux qui ont contribué à ce post.

Richard