parouby
/
Pamhyr2
mirror of https://gitlab.com/pamhyr/pamhyr2
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

geometry: Cleanup some piece of code.

mesh
Pierre-Antoine Rouby 2023-04-12 10:41:00 +02:00
parent 0d08ca3889
commit 8782056b1c
7 changed files with 101 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Model/Geometry/Profile.py
View File

@ -88,6 +88,6 @@ class Profile(object):
"""
return self._profile_type
@type.setter
@profile_type.setter
def profile_type(self, value: str):
self._profile_type = value

26
src/Model/Geometry/Reach.py
View File

@ -13,17 +13,13 @@ from Model.Geometry.ProfileXYZ import ProfileXYZ
from Model.Except import FileFormatError, exception_message_box
class Reach:
def __init__(self, edge):
self._edge = edge
def __init__(self, parent):
self._parent = parent
self._profiles: List[Profile] = []
# Copy/Paste
self.__list_copied_profiles = []
def __repr__(self):
return f"\n===== Début liste des profils ======> {np.array(self._profiles)}" \
f"\n<====== Fin liste des profils ====="
def profile(self, i):
"""Returns profile at index i
@ -38,6 +34,10 @@ class Reach:
return None
@property
def name(self):
return self._parent.name
@property
def profiles(self):
return self._profiles.copy()
@ -79,8 +79,9 @@ class Reach:
nb_profile = self.number_profiles
profile = ProfileXYZ()
profile.num = nb_profile + 1
self._profiles.insert(profile, index + 1)
# self._update_profile_numbers()
self._update_profile_numbers()
def _update_profile_numbers(self):
"""Update profiles index
@ -101,6 +102,7 @@ class Reach:
Nothing.
"""
profile = ProfileXYZ()
self._profiles.insert(index, profile)
self._update_profile_numbers()
@ -117,7 +119,6 @@ class Reach:
if list_index:
indices = sorted(list(set(list_index)), reverse=True)
for idx in indices:
# if idx < len(self._profiles) :
try:
self._profiles.pop(idx)
self._update_profile_numbers()
@ -217,7 +218,7 @@ class Reach:
print(e)
e.alert()
def read_file_st(self):
def read_file_st(self, filename):
"""Read the ST file
Returns:
@ -230,7 +231,7 @@ class Reach:
list_header = []
stop_code = "999.999"
with open(self.file_st, encoding="utf-8") as file_st:
with open(filename, encoding="utf-8") as file_st:
for line in file_st:
if not (line.startswith("#") or line.startswith("*")):
line = line.split()
@ -267,12 +268,11 @@ class Reach:
pass
if list_profile and list_header:
raise FileFormatError(self.file_st, f"{list_profile}, {list_header}")
raise FileFormatError(filename, f"{list_profile}, {list_header}")
print("****** Fichier {} lu et traité en {} secondes *******".format(self.file_st, time() - t0))
print("****** Fichier {} lu et traité en {} secondes *******".format(filename, time() - t0))
return list_profile, list_header
# TODO: Move this function to model reach
def export_reach(self, filename):
with open(f"{filename}", "w") as file_st:

10
src/Model/Network/Edge.py
View File

@ -9,7 +9,7 @@ class Edge(object):
super(Edge, self).__init__()
self.id = id
self.name = name if name != "" else f"{node1.name} -> {node2.name}"
self._name = name if name != "" else f"{node1.name} -> {node2.name}"
self.node1 = node1
self.node2 = node2
@ -20,7 +20,7 @@ class Edge(object):
ret = None
if name == "name":
ret = self.name
ret = self._name
elif name == "id":
ret = self.id
elif name == "node1":
@ -34,7 +34,7 @@ class Edge(object):
def __setitem__(self, name, value):
if name == "name":
self.name = value
self._name = value
elif name == "id":
self.id = value
elif name == "node1":
@ -44,6 +44,10 @@ class Edge(object):
elif name == "enable":
self.enable = value
@property
def name(self):
return self._name
def enable(self):
self.enable = True

6
src/Model/River.py
View File

@ -35,16 +35,12 @@ class RiverReach(Edge):
node1, node2
)
self._reach = None
self._reach = Reach(self)
@property
def reach(self):
return self._reach
@reach.setter
def reach(self, reach:Reach):
self._reach = reach
class River(Graph):
def __init__(self):

191
src/View/Geometry/GeometryWindow.py
View File

@ -28,22 +28,27 @@ class GeometryWindow(QMainWindow, WindowToolKit):
super(GeometryWindow, self).__init__(parent=parent)
self._model = model
self._reach = model.river.current_reach()
self._reach = model.river.current_reach().reach
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.tableView = self.ui.tableView
self.tableView_header = self.ui.tableView_header
self.model = None
self.filename = None
self.model = None
self.setup_window()
self.setup_model()
self.setup_connections()
def setup_window(self):
self.setWindowTitle(f"{self.ui.mainwindow_title} - {self._reach.name}")
def setup_model(self):
self.model = qtableview_reach.PandasModelEditableCreateReach(
self.model = qtableview_reach.PandasModelEditable(
headers = self.ui.tableView_header,
rows = self._reach
reach = self._reach
)
self.tableView.setModel(self.model)
self.tableView.setItemDelegate(qtableview_reach.Delegate())
@ -70,32 +75,30 @@ class GeometryWindow(QMainWindow, WindowToolKit):
settings = QSettings(QSettings.IniFormat, QSettings.UserScope, 'MyOrg', )
current_dir = settings.value('current_directory', DEFAULT_DIRECTORY, type=str)
options |= QFileDialog.DontUseNativeDialog
self.filename, _ = QtWidgets.QFileDialog.getOpenFileName(
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
self,
_translate("MainWindow_reach", "Ouvrir un fichier"),
current_dir,
_translate("MainWindow_reach",
"Fichiers .ST (*.ST)") + ";;" +
_translate("MainWindow_reach",
"Fichiers textes (*.txt)") + ";; " +
_translate("MainWindow_reach",
"Tous les fichiers (*)"),
_translate("MainWindow_reach", "Fichiers .ST (*.ST)") +
";; " +
_translate("MainWindow_reach", "Fichiers textes (*.txt)") +
";; " +
_translate("MainWindow_reach", "Tous les fichiers (*)"),
options=options
)
current_dir = os.path.split(self.filename)[0] or DEFAULT_DIRECTORY
settings.setValue('current_directory', current_dir)
if self.filename != "":
size = os.stat(self.filename).st_size
self.bief_name = pathlib.Path(self.filename).stem
self.setWindowTitle(f"{self.ui.mainwindow_title} {self.bief_name}")
self.model = qtableview_reach.PandasModelEditable(
self.filename,
self.tableView_header
)
self.tableView.setModel(self.model)
self.update_text_label()
current_dir = os.path.split(filename)[0] or DEFAULT_DIRECTORY
#settings.setValue('current_directory', current_dir)
if filename != "":
size = os.stat(filename).st_size
self._reach.import_geometry(filename)
# self.model = qtableview_reach.PandasModelEditable(
# ,
# self.tableView_header
# )
# self.tableView.setModel(self.model)
self.model.layoutChanged.emit()
self.update_profile_windows()
self.graphic_1()
@ -119,25 +122,6 @@ class GeometryWindow(QMainWindow, WindowToolKit):
.connect(self.update_graphic_2)
def update_text_label(self):
"""
Returns: Cette méthode met à jour le texte (en haut à gauche) indiquant le nombre de profils et
l'ordre des sections.
"""
if self.filename:
if self.model.rowCount() > 1:
self.ui.label_section_order.setText(
f"{self.model.rowCount()}" + " " +
_translate("MainWindow_reach", "profils") +
f"{self.ui.text_section_order}"
)
else:
self.ui.label_section_order.setText(
f"{self.model.rowCount()}" + " " +
_translate("MainWindow_reach", "profil") +
f"{self.ui.text_section_order}"
)
def messagebox_profile_editing(self):
msg_box = QtWidgets.QMessageBox()
msg_box.setIcon(QtWidgets.QMessageBox.Information)
@ -164,14 +148,14 @@ class GeometryWindow(QMainWindow, WindowToolKit):
for selected_row in list_selected_row[:5]:
selected_row = int(selected_row)
profile_identifier = self.model.get_profile_selected_identifier(selected_row)
Pk = self.model.get_pk_i(selected_row)
profile_name = self.model.get_profile_name(selected_row)
profile_identifier = self._reach.get_profile_selected_identifier(selected_row)
Pk = self._reach.get_pk_i(selected_row)
profile_name = self._reach.get_profile_name(selected_row)
if len(self.list_second_window) == 0:
self.second_window = window_profileXYZ.View(
selected_row + 1,
self.model.get_profile_via_identifier(profile_identifier),
self._reach.get_profile_via_identifier(profile_identifier),
pk=Pk, profile_name="", parent=self
)
self.second_window.window_title(
@ -202,7 +186,7 @@ class GeometryWindow(QMainWindow, WindowToolKit):
else:
second_window1 = window_profileXYZ.View(
selected_row + 1,
self.model.get_profile_via_identifier(profile_identifier),
self._reach.get_profile_via_identifier(profile_identifier),
pk=Pk, profile_name="", parent=self
)
second_window1.window_title(
@ -253,38 +237,38 @@ class GeometryWindow(QMainWindow, WindowToolKit):
_translate("MainWindow_reach", "Y (m)"), color='green', fontsize=12
)
self.get_x = self.model.get_x()
self.get_y = self.model.get_y()
self.get_x = self._reach.get_x()
self.get_y = self._reach.get_y()
self.line_xy = [
self.ui.canvas_1.axes.plot(x, y, color='r', lw=1., markersize=3, marker='+')
for x, y in zip(self.get_x, self.get_y)
]
self.get_x_complete_list_ld = self.model.get_x_complete_list_ld()
self.get_y_complete_list_ld = self.model.get_y_complete_list_ld()
self.get_x_complete_list_ld = self._reach.get_x_complete_list_ld()
self.get_y_complete_list_ld = self._reach.get_y_complete_list_ld()
self.line_ld_1 = self.ui.canvas_1.axes.plot(
self.get_x_complete_list_ld,
self.get_y_complete_list_ld
)
self.plot_selected_1, = self.ui.canvas_1.axes.plot(
self.model.get_x_profile_i(0),
self.model.get_y_profile_i(0), lw=1., markersize=3,
self._reach.get_x_profile_i(0),
self._reach.get_y_profile_i(0), lw=1., markersize=3,
marker='+', color="b"
)
self.plot_selected_1.set_visible(False)
self.before_plot_selected_1, = self.ui.canvas_1.axes.plot(
self.model.get_x_profile_i(0),
self.model.get_y_profile_i(0), lw=1., markersize=3,
self._reach.get_x_profile_i(0),
self._reach.get_y_profile_i(0), lw=1., markersize=3,
marker='+', color="k", linestyle="--"
)
self.before_plot_selected_1.set_visible(False)
self.after_plot_selected_1, = self.ui.canvas_1.axes.plot(
self.model.get_x_profile_i(0),
self.model.get_y_profile_i(0), lw=1., markersize=3,
self._reach.get_x_profile_i(0),
self._reach.get_y_profile_i(0), lw=1., markersize=3,
marker='+', color="m", linestyle='--'
)
@ -306,9 +290,9 @@ class GeometryWindow(QMainWindow, WindowToolKit):
_translate("MainWindow_reach", "Cote (m)"), color='green', fontsize=12
)
self.get_pk = self.model.get_pk()
self.get_z_min = self.model.get_z_min()
self.get_z_max = self.model.get_z_max()
self.get_pk = self._reach.get_pk()
self.get_z_min = self._reach.get_z_min()
self.get_z_max = self._reach.get_z_max()
self.line_pk_zmin_zmax = self.ui.canvas_2.axes.vlines(
x=self.get_pk,
@ -340,7 +324,7 @@ class GeometryWindow(QMainWindow, WindowToolKit):
try:
self.line_pk_zld = [
self.ui.canvas_2.axes.plot(
self.model.get_pk(), i, lw=1.
self._reach.get_pk(), i, lw=1.
) for i in self.model.z_complete_guideline()
]
except:
@ -363,8 +347,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
for ind in range(self.model.rowCount()):
self.line_xy[ind][0].set_data(
self.model.get_x_profile_i(ind),
self.model.get_y_profile_i(ind)
self._reach.get_x_profile_i(ind),
self._reach.get_y_profile_i(ind)
)
for i in range(len(self.line_ld_1)):
@ -379,9 +363,9 @@ class GeometryWindow(QMainWindow, WindowToolKit):
def update_graphic_2(self):
self.tableView.model().blockSignals(True)
get_pk = self.model.get_pk()
get_z_min = self.model.get_z_min()
get_z_max = self.model.get_z_max()
get_pk = self._reach.get_pk()
get_z_min = self._reach.get_z_min()
get_z_max = self._reach.get_z_max()
self.line_pk_zmin.set_data(get_pk, get_z_min)
@ -408,11 +392,11 @@ class GeometryWindow(QMainWindow, WindowToolKit):
self.tableView.model().blockSignals(True)
selected_profile = 0
station = self.model.get_station(selected_profile) # L'abscisse en travers
station_plus_1 = self.model.get_station(selected_profile + 1)
elevation = self.model.get_z_profile_i(selected_profile)
elevation_i_plus_1 = self.model.get_z_profile_i(selected_profile + 1)
ld = self.model.get_ld_profile_i(selected_profile)
station = self._reach.get_station(selected_profile) # L'abscisse en travers
station_plus_1 = self._reach.get_station(selected_profile + 1)
elevation = self._reach.get_z_profile_i(selected_profile)
elevation_i_plus_1 = self._reach.get_z_profile_i(selected_profile + 1)
ld = self._reach.get_ld_profile_i(selected_profile)
self.ui.canvas_3.axes.cla()
self.ui.canvas_3.axes.grid(color='grey', linestyle='--', linewidth=0.5)
@ -448,8 +432,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
color=color_profile_i_plus_1, lw=1.6, linestyle='--'
)
self.annotation_3 = []
self.complete_list_ld = self.model.get_complete_list_ld()
self.incomplete_list_ld = self.model.get_incomplete_list_ld()
self.complete_list_ld = self._reach.get_complete_list_ld()
self.incomplete_list_ld = self._reach.get_incomplete_list_ld()
line_2d = [[line_2D] for line_2D in self.line_ld_1]
self.color_complete_ld = self.get_line_ld_colors(line_2d)
@ -516,9 +500,9 @@ class GeometryWindow(QMainWindow, WindowToolKit):
x = self.get_station(ind)
y = self.get_elevation(ind)
ld = self.model.get_ld_profile_i(ind)
get_complete_list_ld = self.model.get_complete_list_ld()
get_incomplete_list_ld = self.model.get_incomplete_list_ld()
ld = self._reach.get_ld_profile_i(ind)
get_complete_list_ld = self._reach.get_complete_list_ld()
get_incomplete_list_ld = self._reach.get_incomplete_list_ld()
try:
x_ld_complete = []
@ -571,10 +555,10 @@ class GeometryWindow(QMainWindow, WindowToolKit):
return colors
def get_station(self, ind: int):
return self.model.get_station(ind)
return self._reach.get_station(ind)
def get_elevation(self, ind: int):
return self.model.get_z_profile_i(ind)
return self._reach.get_z_profile_i(ind)
def update_graphic_3(self, ind: int):
self.tableView.model().blockSignals(True)
@ -628,8 +612,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
self.tableView.model().blockSignals(True)
if 0 <= ind < self.model.rowCount():
self.plot_selected_1.set_data(self.model.get_x_profile_i(ind),
self.model.get_y_profile_i(ind))
self.plot_selected_1.set_data(self._reach.get_x_profile_i(ind),
self._reach.get_y_profile_i(ind))
self.plot_selected_1.set_visible(True)
self.tableView.model().blockSignals(False)
@ -648,8 +632,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
t0 = time.time()
self.before_plot_selected_1.set_data(
self.model.get_x_profile_i(ind),
self.model.get_y_profile_i(ind)
self._reach.get_x_profile_i(ind),
self._reach.get_y_profile_i(ind)
)
self.before_plot_selected_1.set_visible(True)
@ -658,8 +642,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
def select_after_plot_selected_1(self, ind: int):
if 0 <= ind < self.model.rowCount():
self.after_plot_selected_1.set_data(
self.model.get_x_profile_i(ind),
self.model.get_y_profile_i(ind)
self._reach.get_x_profile_i(ind),
self._reach.get_y_profile_i(ind)
)
self.after_plot_selected_1.set_visible(True)
self.ui.canvas_1.figure.canvas.draw_idle()
@ -746,7 +730,7 @@ class GeometryWindow(QMainWindow, WindowToolKit):
self.ui.verticalSlider.setMaximum(self.model.rowCount() - 1)
slider_value = self.ui.verticalSlider.value()
pk = self.model.get_pk_profile_i(slider_value)
pk = self._reach.get_pk_profile_i(slider_value)
self.ui.vertical_slider_label.setText(
_translate("MainWindow_reach", "Pk : ") +
@ -913,39 +897,6 @@ class GeometryWindow(QMainWindow, WindowToolKit):
]
return liste_lignes_directrices
def get_x(self):
return self.model.get_x()
def get_y(self):
return self.model.get_y()
def get_z(self):
return self.model.get_z()
def get_z_min(self):
return self.model.get_z_min()
def get_z_min_i(self, index):
return self.model.get_z_min_i(index)
def get_z_max_i(self, index):
return self.model.get_z_max_i(index)
def get_z_max(self):
return self.model.get_z_max()
def get_pk(self):
return self.model.get_pk()
def get_pk_i(self, index):
return self.model.get_pk_i(index)
def get_pk_z_ld(self):
return self.model.get_pk_z_ld()
def get_pk_z_ld_bis(self):
return self.model.get_pk_z_ld_bis()
@property
def model_data(self):
return self.model.model_data()

3
src/View/Geometry/mainwindow_ui_reach.py
View File

@ -397,7 +397,8 @@ class Ui_MainWindow(object):
self.btn_move_down.setToolTip(_translate("MainWindow_reach", " Changer l'ordre des profils (en décalant le "
"profil sélectionné vers le bas)"))
self.btn_end_editing.setToolTip(_translate("MainWindow_reach", " Terminer l'édition"))
self.tableView_header = [_translate("MainWindow_reach", "Nom"), _translate("MainWindow_reach", "Pk (m)"),
self.tableView_header = [_translate("MainWindow_reach", "Name"),
_translate("MainWindow_reach", "Kp (m)"),
_translate("MainWindow_reach", "Type")]
self.toolbar_1._actions["isometric_view"].setShortcut(_translate("MainWindow_reach", "Alt+Z"))

189
src/View/Geometry/qtableview_reach.py
View File

@ -23,26 +23,20 @@ from Model.Geometry import Reach
_translate = QCoreApplication.translate
class PandasModelEditable(QAbstractTableModel):
def __init__(self, reach, header=None, profiles_type=None):
def __init__(self, reach, headers=None):
QAbstractTableModel.__init__(self)
data_list = []
self._data = reach
if header is None:
if headers is None:
self.headers = [
_translate("Geometry", "Name"),
_translate("Geometry", "KP"),
_translate("Geometry", "Kp (m)"),
_translate("Geometry", "Type")
]
else:
self.headers = header
if profiles_type is None:
self.profiles_type = [
"XYZ", "AC",
# "LC", "R", "T", "RT"
]
self.headers = headers
def rowCount(self, parent=QModelIndex()):
return self._data.number_profiles
@ -70,11 +64,10 @@ class PandasModelEditable(QAbstractTableModel):
name = self._data.profile(index.row()).name\
.strip()\
.lower()
if (name == "upstream" or
if (name == "upstream" or name == "up" or
name == _translate("Geometry", "upstream")):
return QtGui.QColor("Green")
elif (name == "downstream" or
elif (name == "downstream" or name == "down" or
name == _translate("Geometry", "downstream")):
return QtGui.QColor("Red")
@ -88,9 +81,6 @@ class PandasModelEditable(QAbstractTableModel):
else:
return str(section + 1)
if orientation == Qt.Vertical and role == Qt.DisplayRole:
return self.headers[section]
return QVariant()
def setData(self, index, value, role=Qt.EditRole):
@ -205,173 +195,6 @@ class Delegate(QtWidgets.QStyledItemDelegate):
"""permet de redimensionner l'éditeur à la bonne taille lorsque la taille de la vue change"""
editor.setGeometry(option.rect)
class PandasModelEditableCreateReach(QAbstractTableModel):
# TODO : Cette calsse permet juste d'éviter que l'application plante lorsque 'on essaye d'éditer le tablueau. Le
# problème se trouve au niveau du délégué QtWidgets.QStyledItemDelegate. Il faudra prendre en compte le cas où
# on part de zero pour creer un bief. Pour l'instant, le prototype ne gère que l'importation d'une géométrie.
#
def __init__(self, data, headers):
QAbstractTableModel.__init__(self)
data_list = []
self._data = data
self.headers = headers
def rowCount(self, parent=QModelIndex()): # parent=None):
return len(self._data)
def columnCount(self, parent=QModelIndex()): # parent=None):
return len(self.headers)
def data(self, index, role=Qt.DisplayRole):
if index.isValid():
if role == Qt.DisplayRole and index.column() == 0:
value = self._data[index.row()][0][5]
return self._data[index.row()][0][5]
if role == Qt.DisplayRole and index.column() == 1:
return "%.4f" % float(self._data[index.row()][0][4])
column_count = self.columnCount()
for column in range(0, column_count):
if index.column() == column and role == Qt.TextAlignmentRole:
return Qt.AlignHCenter | Qt.AlignVCenter
# if role == Qt.BackgroundRole and index.column() == 1:
# return QtGui.QColor(Qt.lightGray)
return QVariant() # None
def headerData(self, section, orientation, role=Qt.DisplayRole):
if role == Qt.DisplayRole:
if orientation == Qt.Horizontal:
if section < len(self.headers):
return self.headers[section]
else:
return "not implemented"
else:
return "%d" % (section + 1)
if orientation == Qt.Vertical and role == Qt.DisplayRole:
return self._data[section]
return None
def setData(self, index, value, role=Qt.EditRole):
row = index.row()
column = index.column()
if role == Qt.EditRole and index.column() != 2:
try:
if role == Qt.EditRole and index.column() == 0:
self._data[index.row()][0][5] = value
if role == Qt.EditRole and index.column() == 1:
self._data[index.row()][0][4] = float(value)
self.dataChanged.emit(index, index)
except:
print('TODO')
return True
self.layoutChanged.emit()
return False
def index(self, row, column, parent=QModelIndex()):
if not self.hasIndex(row, column, parent):
return QModelIndex()
return self.createIndex(row, column, QModelIndex())
def flags(self, index):
if index.column() == 2:
return Qt.ItemIsEnabled
else:
return Qt.ItemIsEditable | Qt.ItemIsSelectable | Qt.ItemIsEnabled
# @QtCore.pyqtSlot()
def insertRows(self, row, count, parent=QModelIndex()):
self.beginInsertRows(parent, row, row + count - 1)
indexes = [str(self.rowCount() + i) for i in range(count)]
self._data.insert(row, [[self.rowCount() + 1, 0, 0, 0, np.nan, ''],
pd.DataFrame({'x': [0], 'y': [0], 'z': [0], 'ld': ['']})])
self.endInsertRows()
self.layoutChanged.emit()
# @QtCore.pyqtSlot()
def removeRows1(self, row, count, parent=QModelIndex()):
self.beginRemoveRows(parent, row, row)
self._data.pop(row)
self.endRemoveRows()
self.layoutChanged.emit()
def removeRows(self, position, rows, parent=QModelIndex()):
self.beginRemoveRows(QModelIndex(), position, position + rows - 1)
for i in range(rows):
del (self._data[position])
self.endRemoveRows()
self.layoutChanged.emit()
return True
# # @QtCore.pyqtSlot()
def sort_data(self, _reverse):
self.layoutAboutToBeChanged.emit()
if not _reverse:
self._data = sorted(self._data, key=lambda x: float(x[0][4]), reverse=False)
else:
self._data = sorted(self._data, key=lambda x: float(x[0][4]), reverse=True)
self.layoutAboutToBeChanged.emit()
self.layoutChanged.emit()
def moveRowDown(self, row_to_move, parent=QModelIndex()):
target = row_to_move + 2
self.beginMoveRows(parent, row_to_move, row_to_move, parent, target)
self._data[row_to_move], self._data[row_to_move + 1] = self._data[row_to_move + 1], self._data[row_to_move]
self.endMoveRows()
self.layoutChanged.emit()
def moveRowUp(self, row_to_move, parent=QModelIndex()):
target = row_to_move + 1
self.beginMoveRows(parent, row_to_move - 1, row_to_move - 1, parent, target)
self._data[row_to_move], self._data[row_to_move - 1] = self._data[row_to_move - 1], self._data[row_to_move]
self.endMoveRows()
self.layoutChanged.emit()
class Delegate(QtWidgets.QStyledItemDelegate):
# Lorsque l'on souhaite uniquement personnaliser l'édition des éléments dans une vue et non le rendu,
# on doit redéfinir quatre méthodes
def __init__(self, parent=None, setModelDataEvent=None):
super(Delegate, self).__init__(parent)
self.setModelDataEvent = setModelDataEvent
def createEditor(self, parent, option, index):
"""retourne le widget (éditeur) pour éditer l'item se trouvant à l'index index."""
index.model().data(index, Qt.DisplayRole)
return QtWidgets.QLineEdit(parent)
def setEditorData(self, editor, index):
"""permet de transmettre à l'éditeur editor les données à afficher à partir du modèle se trouvant à l'index
index. """
value = index.model().data(index, Qt.DisplayRole) # DisplayRole
editor.setText(str(value)) # récupère la valeur de la cellule applique la méthode définie dans setData
print('Donnée éditée dans la case [{},{}] :'.format(index.row(), index.column()), value)
def setModelData(self, editor, model, index):
"""permet de récupérer les données de l'éditeur et de les stocker à l'intérieur du modèle, à l'index identifié
par le paramètre index """
model.setData(index, editor.text())
if not self.setModelDataEvent is None:
self.setModelDataEvent()
def updateEditorGeometry(self, editor, option, index):
"""permet de redimensionner l'éditeur à la bonne taille lorsque la taille de la vue change"""
editor.setGeometry(option.rect)
class Delegate1(QtWidgets.QStyledItemDelegate):
def __init__(self, owner, choices):
super().__init__(owner)