Bonjour,
les codes donnés ci-dessous permettent de créer une fenêtre graphique dans laquelle on peut tracer à la souris des segments ou des lignes brisées (ie un ensemble de segments qui se "suivent"), ainsi que des points isolés et des cercles.

Le problème est que ma méthode est statique (donc pratiquement inutile) : une fois les objets tracés, impossible de les déplacer. Je voudrais donc savoir comment créer des objets qui peuvent être déplacés. Je pense qu'il faut définir une classe item pour chaque objet graphique, et aussi faire en sorte que les points utilisés par ces items soient "dragables". Les déplacements seront ainsi gérés par PyQt.
Il faudrait aussi que je sache quand un élément est bougé pour savoir quel objet est bougé.

Si quelqu'un a une idée je suis preneur.

LES CODES

Comportement_GraphicsView.py
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
from PyQt4 import QtCore, QtGui
 
class GraphicsView_1(QtGui.QGraphicsView):
# Lors du premier appel d'un graphique, on peut lui donner diverses variables mais aussi des fonctions.
# Nous utilisons cela pour récupérer foncRetour, la fonction qui sera appelée à partir du GraphicsView personnalisé.
#
# Cette méthode a été trouvée à l'adresse suivante :
# http://www.mail-archive.com/pyqt@riverbankcomputing.com/msg13873.html
    def __init__(self, foncRetour, parent=None):
        super(GraphicsView_1, self).__init__(parent)
# Pour un usage tout au sein de la classe, nous utilisons l'astuce ci-dessous (sans faire cela, nous ne pourrions pas
# utiliser foncRetour dans n'importe quelle méthode).
        self.foncRetour = foncRetour
 
# Les différents évènements liés à la souris sont présentés dans le livre «*Rapid GUI Programming with Python and Qt*» de Mark SUMMERFIELD.
    def wheelEvent(self, event):
        print u"Au dessus du graphique 1 : Roulette de la souris activée"
 
    def mouseMoveEvent(self, mouseEvent):
        pt = mouseEvent.pos()
        self.foncRetour(1,pt.x(),pt.y())
 
    def mousePressEvent(self, mouseEvent):
        if mouseEvent.button() == QtCore.Qt.LeftButton :
            pt = mouseEvent.pos()
            print 'Sur le graphique 1 : Clic Gauche avec la souris \nPosition relative (x;y) = (' + str(pt.x()) + ';' + str(pt.y()) + ')'
        elif mouseEvent.button() == QtCore.Qt.RightButton :
            print 'Sur le graphique 1 : Clic Droit avec la souris \nPosition globale (x;y) = (' + str(mouseEvent.globalX()) + ';' + str(mouseEvent.globalY()) + ')'
 
 
class GraphicsView_2(QtGui.QGraphicsView):
    def __init__(self, foncRetour, parent=None):
        super(GraphicsView_2, self).__init__(parent)
        self.foncRetour = foncRetour
 
    def wheelEvent(self, event):
        print u"Au dessus du graphique 2 : Roulette de la souris activé"
 
    def mouseMoveEvent(self, mouseEvent):
        pt = mouseEvent.pos()
        self.foncRetour(2,pt.x(),pt.y())
 
    def mousePressEvent(self, mouseEvent):
        if mouseEvent.button() == QtCore.Qt.LeftButton :
            pt = mouseEvent.pos()
            print 'Sur le graphique 2 : Clic Gauche avec la souris \nPosition relative (x;y) = (' + str(pt.x()) + ';' + str(pt.y()) + ')'
        elif mouseEvent.button() == QtCore.Qt.RightButton :
            print 'Sur le graphique 2 : Clic Droit avec la souris \nPosition globale (x;y) = (' + str(mouseEvent.globalX()) + ';' + str(mouseEvent.globalY()) + ')'
window_TestSouris_Plus.py
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
# -*- coding: utf-8 -*-
 
# Form implementation generated from reading ui file 'C:\Documents and Settings\Christophe\Mes documents\2,pyBaNaMa\DebuterAvecPythonEtPyQT\CodesProjets\05-Proj5_DessinGraphSouris\01-TestSouris\window_TestSouris_Plus.ui     '
#
# Created: Thu Aug 14 13:49:25 2008
#      by: PyQt4 UI code generator 4.4.2
#
# WARNING! All changes made in this file will be lost!
 
from PyQt4 import QtCore, QtGui
 
# On commence par importer les GraphicsView modifiés pour notre usage.
# Nous pourrions très bien coller ici ces modifications mais que se passerait-il en cas de restrucration visuelle de l'interface ?
# Nous avons donc choisi de modifier au minimum le code Python de notre interface (toujours dans l'esprit de sépartaion du fond et de la forme).
from Comportement_GraphicsView import GraphicsView_1, GraphicsView_2
 
class Ui_window_TestSouris_Plus(object):
    def setupUi(self, window_TestSouris_Plus):
        window_TestSouris_Plus.setObjectName("window_TestSouris_Plus")
        window_TestSouris_Plus.resize(697,538)
        window_TestSouris_Plus.setMinimumSize(QtCore.QSize(697,538))
        window_TestSouris_Plus.setMaximumSize(QtCore.QSize(697,538))
        self.centralwidget = QtGui.QWidget(window_TestSouris_Plus)
        self.centralwidget.setGeometry(QtCore.QRect(0,21,697,498))
        self.centralwidget.setObjectName("centralwidget")
        self.horizontalLayout = QtGui.QHBoxLayout(self.centralwidget)
        self.horizontalLayout.setObjectName("horizontalLayout")
 
# Voici un autre changement à faire. La ligne originale de window_TestSouris est :
# self.graphicsView_1 = QtGui.QGraphicsView(self.centralwidget)
        self.graphicsView_1 = GraphicsView_1(self.modifGraph)
# Ce changement permet d'utiliser notre 1er Graphics View personnalisé en lui fournissant la fonction
# qu'il utilisera pour indiquer les quelques évènments liés à la souris.
# Toujours pour réduire au minimum la modification du code Python originel de notre interface,
# nous définirons plus tard et à part la fonction modifGraph (voir le code de TestSouris_v1).
# Fin du changement.
 
        self.graphicsView_1.setObjectName("graphicsView_1")
        self.horizontalLayout.addWidget(self.graphicsView_1)
        spacerItem = QtGui.QSpacerItem(40,20,QtGui.QSizePolicy.Preferred,QtGui.QSizePolicy.Minimum)
        self.horizontalLayout.addItem(spacerItem)
 
# Même changement que pérécédemment.
        self.graphicsView_2 = GraphicsView_2(self.modifGraph)
# Fin du changement.
 
        self.graphicsView_2.setObjectName("graphicsView_2")
        self.horizontalLayout.addWidget(self.graphicsView_2)
        window_TestSouris_Plus.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(window_TestSouris_Plus)
        self.menubar.setGeometry(QtCore.QRect(0,0,697,21))
        self.menubar.setObjectName("menubar")
        window_TestSouris_Plus.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(window_TestSouris_Plus)
        self.statusbar.setGeometry(QtCore.QRect(0,519,697,19))
        self.statusbar.setObjectName("statusbar")
        window_TestSouris_Plus.setStatusBar(self.statusbar)
 
        self.retranslateUi(window_TestSouris_Plus)
        QtCore.QMetaObject.connectSlotsByName(window_TestSouris_Plus)
 
    def retranslateUi(self, window_TestSouris_Plus):
        window_TestSouris_Plus.setWindowTitle(QtGui.QApplication.translate("window_TestSouris_Plus", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    window_TestSouris_Plus = QtGui.QMainWindow()
    ui = Ui_window_TestSouris_Plus()
    ui.setupUi(window_TestSouris_Plus)
    window_TestSouris_Plus.show()
    sys.exit(app.exec_())
TestSouris_v1.py
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
# -*- coding: utf-8 -*-
#!/usr/bin/env python
# Les lignes ci-dessus sont très importantes :
#	1°) La 1ère ligne indique le codage du fichier Python.
#	2°) La 2nde ligne est indispensable pour un bon fonctionnement sous Linux.
 
# PRESENTATION : ce script montre comment lier un  texte ayant un contenu que nous allons analyser
# à un arbre représentant la struture hiérarchique de ce texte.
# AUTEUR : BAL Christophe
# MAIL : projetmbc@club.fr
# SITE : http://christophe_bal.club.fr/index.php
# DATE DE CREATION : 14/08/2008
# 
# TEST(S) EFFECTUE(S) : programme testé sous Windows XP avec succès.
 
# On importe les bibliothèques que nous allons utiliser.
import sys
from PyQt4 import QtCore, QtGui
# On importe notre boîte de dialogue.
from window_TestSouris_Plus import Ui_window_TestSouris_Plus
 
 
# # # # # # # # # # # # # # # # # # # # # #
# Comportement de la boîte de dialogue.   DEBUT
 
class window_TestSouris_Plus(QtGui.QMainWindow, Ui_window_TestSouris_Plus):
	def __init__(self):
		QtGui.QMainWindow.__init__(self)
		Ui_window_TestSouris_Plus.__init__(self)
		self.setupUi(self)
 
	def modifGraph(self,num_Graph,x_souris,y_souris):
		self.statusbar.showMessage(u"Graphique n°" + str(num_Graph) + u" survolé : Souris aux coordonnées (" + str(x_souris) + ";" + str(y_souris) + ")", 500)
 
# Comportement de la boîte de dialogue.   FIN
# # # # # # # # # # # # # # # # # # # # # # # #
 
 
# # # # # # # # # # # # # # #
# Lancement de l'application.
if __name__ == "__main__":	
	app = QtGui.QApplication(sys.argv)
	TestSouris = window_TestSouris_Plus()
 
# Affichage d'une boîte de dialogue pour informer l'utilisateur de "l'utilité" de cette 1ère application test.
# Nous avons déjà rencontré les boîtes de dialogue de PyQt. La seule chose qu'il faille faire c'est d'indiquer
# que la boîte de dialogue est associé à l'interface TestSouris. Ceci se fait en remplaçant toutes les occurences
# de self en TestSouris. Ainsi, on doit avoir
#		QtGui.QMessageBox.information(TestSouris,... 
# au lieu de
#		QtGui.QMessageBox.information(self,... 
# De même, toutes les fonctions
#		self.tr(...)
# doivent devenir
#		TestSouris.tr(...)
	QtGui.QMessageBox.information(TestSouris, TestSouris.tr(u"Fonctionnement de ce 1er test".encode('ISO-8859-15')),TestSouris.tr(u" En vous baladant sur les deux cadres blancs (qui sont des Graphics View),\n ou en cliquant (droit ou gauche), ou bien en utilisant la roulette,\n vous verrez soit apparaître en bas de la fenêtre, soit dans la console Python  \n des informations relatives à l'action faite et à la position de votre souris.".encode('ISO-8859-15')),QtGui.QMessageBox.Ok)
 
	TestSouris.show()
	sys.exit(app.exec_())