Hmm désolé ne ne pas avoir précisé, oui c'est du pyQT

Je dessine dans des qwidget, je peux déplacer avec la souris ces qwidget dans la qframe. Sauf que lorsque 2 qwidgets se superposent celui qui reste visible est le dernier à avoir été instancié. J'aimerais pouvoir donner la visibilité à celui qui est en mouvement.

Alors pour illustrer un peu mes dires, voici une capture de mon appli
C'est un peu le même fonctionnement que simulink pour matlab

Lorsque je déplace un bloc, je souhaite qu'il soit au dessus de tous les autres.

Ca fait plaisir d'avoir des méssages comme le tiens, tu n'es pas modérateur pour rien je pense !! Et ça donne envie de s'abonner ^^...

Tous mes objets graphiques dessinés dérivent de cette classe :

class ObjectUI(QtGui.QWidget):
    """ Graphical Objects wich are displayed on the screen (virtual object) """
    def __init__(self, _QSSize, _QPPosition, parent=None):
        super (ObjectUI, self).__init__ (parent)
        self.QPPosition = _QPPosition
        self.QSSize = _QSSize
        
        # Properties of the font
        newFont = self.font()
        newFont.setPixelSize(12)
        self.setFont(newFont)
        self.setFixedSize(self.getSize())     
        fontMetrics = QtGui.QFontMetrics(newFont)
        
        self.QPaint = QtGui.QPainter()
      
#=================================
# Public accessors
#=================================
    def setPosition(self,P):
        """ set the position of the action object block """
        self.QPPosition = P
    
    def getPosition(self):
        """ return the position of the action object block """
        return self.QPPosition   

    def setSize(self,_QSSize):
        """ set the size of the current object user interface """
        self.QSSize = _QSSize
    
    def getSize(self):
        """ return the size of the current object user interface """
        return self.QSSize
    
    def getPainter(self):
        """ return the qpainter """
        return(self.QPaint)
    
#=================================
# Manage the mouse
#=================================
    def mousePressEvent(self, event): 
        """ action performed when the mouse is clicked """
        raise NotImplementedError("Method mousePressEvent not defined in class " + self.__class__.__name__)   

    def mouseMoveEvent(self, event): 
        """ action performed when the mouse is moved """
        raise NotImplementedError("Method mouseMoveEvent not defined in class " + self.__class__.__name__)   
    
    def mouseReleaseEvent(self, event): 
        """ action performed when the mouse is released """
        raise NotImplementedError("Method mouseReleaseEvent not defined in class " + self.__class__.__name__)   

Et voici le code d'un widget graphique qui dessine un carré:

#==================================
# Import modules
#==================================
from PyQt4 import QtGui, QtCore
from ObjectUI import ObjectUI
#==================================
# Constructor
#==================================
class PlaceObjectUI(ObjectUI, QtGui.QLabel):
    colorFix = QtCore.Qt.darkGray
    colorMoving = QtCore.Qt.gray
    colorFill = QtCore.Qt.gray
    """ Graphical Objects of places (represent variables """
    def __init__(self, _QPPosition, parent=None):
        ObjectUI.__init__(self, QtCore.QSize(10, 10), _QPPosition, parent)
        # Attributes
        self.m_place = 0
        self.m_ascendant = 0
        self.m_ascPosition = 0
        self.m_descendants = []
        
        # Color of the picture drawn
        self.color = self.colorFix
               
        # get the painter
        self.painter = self.getPainter()
        
        # Draw the shape
        self.setupShape()

        
#=================================
# Public painting
#=================================         
    def paintEvent(self, event):
        # Go to the position where to draw the object
        self.move(self.getPosition().x(), self.getPosition().y())
        
        self.painter = QtGui.QPainter()
        self.painter.begin(self)
        #painter.setRenderHint(QtGui.QPainter.Antialiasing)
        self.painter.fillRect(event.rect(), QtGui.QBrush(self.colorFix))
        self.drawShape(self.painter)
        self.painter.end()

    def drawShape(self, painter):
        self.painter.fillPath(self.shape, QtGui.QBrush(self.colorFix))

    def setupShape(self):
        QPpath = QtGui.QPainterPath()
        QPpath.setFillRule(QtCore.Qt.OddEvenFill)
        
        QPpath.addRect(0, 0, self.getSize().width(), self.getSize().height())    
        self.shape = QPpath
        
#=================================
# Public accessors
#=================================  
    def setPlace(self, _place):
        self.m_place = _place
    
    def getPlace(self):
        return self.m_place
    
    def setAscendant(self, _asc):
        self.m_ascendant = _asc
        
    def addDescendant(self, _desc):
        self.m_descendants.append(_desc)
    
    def getAscendant(self):
        return self.m_ascendant

#=================================
# Public functions
#=================================  
    def getNbDescendants(self):
        return len(self.m_descendants)
    
    def getDescendant(self, _position):
        return self.m_descendants[_position]
    
    def removeAscendant(self):
        self.m_ascendant = 0

#=================================
# Manage the mouse
#=================================
    def mouseMoveEvent(self, event):
        """ Redraw the current block when the mouse is being moved """
        # shape of the cursor
        self.setCursor(QtCore.Qt.SizeAllCursor)
        # Catch the position of the mouse
        position = event.pos()
        # newPosition is the new position of the QLabel
        newPosition = QtCore.QPointF(self.getPosition().x()+position.x(),self.getPosition().y()+position.y())
        # Move to the current position of the mouse
        self.move(newPosition.x(),newPosition.y())
        # update the position of the QLabel
        self.QPPosition = newPosition
        self.color = self.colorMoving
        self.update()
        
    def mousePressEvent(self, event):
        return 
    
    def mouseReleaseEvent(self, event):
        # shape of the cursor
        self.setCursor(QtCore.Qt.SizeAllCursor)
        self.color = self.colorFix
        self.update()             

Premier bien sur, il n'y a pas d'ironie dans ce que j'ai dit.

Tu as pris le temps de me répondre ainsi que d'éclaircir mon post ! J'ai peine à trouver des forums python avec des forumeurs actifs. D'autant plus que dans la boite dans laquelle je suis (stagiaire), personne ne fait directement du graphique pythonQT.

Ok je pense voir ce que tu m'as expliqué.
Je dois donc redessiner tout le graphe même si je ne déplace qu'un seul widget ?

J'ai un autre soucis, mon widget "lien" qui représente le trait sur l'image se redessine à chaque déplacement d'une boite, ça marche mais il y à des scintillements. Je me demande si ma conception est bien adaptée pour ce que je souhaite faire? Je n'ai trouvé sur le net aucun tutorial pour faire du dessin interactif un peu évolué avec pyQT, je trouve ceci fort domage car python à l'air d'être puissant mais pas encore utilisé dans les entreprises.

ps: pour mon problème de "Z", on m'a parlé de QStackedWidget, mais la doc dit que ca sert à n'afficher que le widget en tete de la liste. Peux-tu m'en dire un peu plus sur ses fonctionnalités.

ps: j'espere ne pas abuser avec mes questions de débutant, mais j'ai fait pas mal de recherches google et RTFM...

J'éssaye de m'attaquer au Double Buffer en premier pour une v0, je verrai ensuite de revoir la conception.

        image = QtGui.QImage(sizeX, sizeY, QtGui.QImage.Format_ARGB32_Premultiplied)
        self.painter.begin(self)
        # dessin
        self.painter.setPen(QtCore.Qt.black)
        self.painter.drawLine(QtCore.QPoint(0,0), QtCore.QPoint(sizeX, sizeY))
        self.setPixmap(QtGui.QPixmap.fromImage(image))
        self.painter.end()

Je ne suis pas sur d'appliquer la bonne méthode du double buffer. Sur certains sites ils parlent de la fonction bitblt qui existe uniquement avec qt3, or j'utilise qt4. Avec qt4 il paraitrait que la technique du double buffer ne sert à rien puisque qt le ferait tout seul comme un grand, je n'en suis pas convaincu.

Est-ce que je procède bien pour faire un double buffer avec mon code, pas sur...car ca scintille encore !

Ok je me lance dans le dessin sur une seule image double buffeurisée.

J'ai un soucis pour afficher un simple carré. Lorsque ce code marchera, j'aurais compris comment fonctionne exactement les qpainterpath et je pourrais alors me lancer dans la nouvelle conception.

from PyQt4 import QtGui, QtCore
import sys

class DrawWidget(QtGui.QLabel):
    def __init__(self, parent=None):
        super (DrawWidget, self).__init__ (parent)
        
        QPath = QtGui.QPainterPath()
        painter = QtGui.QPainter()
        
        QPath.setFillRule(QtCore.Qt.OddEvenFill)

       # Partie qui sera encapsulee dans les fonctions setupShape de mes objets graphiques
        QPath.lineTo(0.0,87)
        QPath.lineTo(0.0,60)
        QPath.lineTo(10.0,60)
        QPath.lineTo(35,35)
        QPath.lineTo(100.0,35)
        QPath.lineTo(100, 87)
        QPath.lineTo(0.0, 87)
                
        painter.begin(self)

# Utile ou pas? :
        painter.fillRect(0,0,800,600, QtCore.Qt.white)

        painter.fillPath(QPath, QtGui.QBrush(QtCore.Qt.BDiagPattern))
        painter.end()

class DrawGraph(QtGui.QFrame):
    def __init__(self, parent=None):
        QtGui.QFrame.__init__(self, parent)
        self.move(0, 0)
        self.setMinimumSize(800, 600)
        self.setFrameStyle(QtGui.QFrame.Sunken | QtGui.QFrame.StyledPanel)
        self.setWindowTitle(self.tr("Test AFPy Objets Graphique"))
        dw = DrawWidget(self)
        
                
      

        
        
               
if __name__ == "__main__":
    
    app = QtGui.QApplication(sys.argv)
    window = DrawGraph()
    window.show()
    sys.exit(app.exec_())

Avec tout ça rien ne s'affiche...
*
Merci encore

Juste, mais toujours pas ! Rah, je vais faire des tutos à la fin de mon stage en francais et complets.

class DrawWidget(QtGui.QLabel):
    def __init__(self, parent=None):
        super (DrawWidget, self).__init__ (parent)
        
        QPath = QtGui.QPainterPath()
        painter = QtGui.QPainter()
        
        QPath.setFillRule(QtCore.Qt.OddEvenFill)
        QPath.lineTo(0.0,87)
        QPath.lineTo(0.0,60)
        QPath.lineTo(10.0,60)
        QPath.lineTo(35,35)
        QPath.lineTo(100.0,35)
        QPath.lineTo(100, 87)
        QPath.lineTo(0.0, 87)
        QPath.addRect(0,0,100,100)
                
        painter.begin(self)
        painter.fillRect(0,0,800,600, QtCore.Qt.white)
        painter.fillPath(QPath, QtGui.QBrush(QtCore.Qt.BDiagPattern))
        painter.drawPath(QPath)
        painter.end()

class DrawGraph(QtGui.QFrame):
    def __init__(self, parent=None):
        QtGui.QFrame.__init__(self, parent)
        self.move(0, 0)
        self.setMinimumSize(800, 600)
        self.setFrameStyle(QtGui.QFrame.Sunken | QtGui.QFrame.StyledPanel)
        self.setWindowTitle(self.tr("Test AFPy Objets Graphique"))
        dw = DrawWidget(self)

Je suis entierement d'accord avec toi pour le nom self.QPixMap, j'ai corrigé dans mon code.

D'apres ta remarque, je pense que je ne dois pas faire de drawpixmap ou bien creer un autre qpixmap temporaire puis le copier dans celui du qpainter?
Non, désolé, mais je ne vois pas la logique. Je donne ma langue au chat

Hmm, je commence à comprendre la logique !
Je sens que j'y suis presque, MAIS... ça n'affiche toujours rien et je commence à culpabiliser de monopoliser ton temps pour ces broutilles.

class DrawGraph(QtGui.QFrame):
    def __init__(self, parent=None):
        QtGui.QFrame.__init__(self, parent)
        self.move(0, 0)
        self.setMinimumSize(800, 600)
        self.setFrameStyle(QtGui.QFrame.Sunken | QtGui.QFrame.StyledPanel)
        self.setWindowTitle(self.tr("Test AFPy Objets Graphique"))       
         
        self.QPath = QtGui.QPainterPath()
        self.qpm = QtGui.QPixmap(800,600)
        
        self.QPainter = QtGui.QPainter(self.qpm)     
        self.QPath.addRect(10,10,10,10)
        self.QPainter.fillPath(self.QPath, QtGui.QBrush(QtCore.Qt.black))    
        self.QPainter.drawPath(self.QPath)  
        self.QPainter.end()
        
        newQP = QtGui.QPainter(self)
        newQP.drawPixmap(QtCore.QPointF(0,0), self.qpm) 
        
        
if __name__ == "__main__":
    
    app = QtGui.QApplication(sys.argv)
    window = DrawGraph()
    window.show()
    sys.exit(app.exec_())

okok, je vois mieux, mais je dois avoir une mauvaise vision car je le trouve pas ce :evil: :evil: :evil: :evil: :evil: de carré.

#==================================
# Constructor
#==================================
class DrawGraph(QtGui.QFrame):
    def __init__(self, parent=None):
        QtGui.QFrame.__init__(self, parent)
        self.move(0, 0)
        self.setMinimumSize(800, 600)
        self.setFrameStyle(QtGui.QFrame.Sunken | QtGui.QFrame.StyledPanel)
        self.setWindowTitle(self.tr("Test AFPy Objets Graphique"))       
    
    def dessine_moi_le_carre_stp(self):
        self.QPath = QtGui.QPainterPath()
        self.qpm = QtGui.QPixmap(800,600)
        
        self.QPainter = QtGui.QPainter(self.qpm)     
        self.QPath.addRect(10,10,10,10)
        self.QPainter.fillPath(self.QPath, QtGui.QBrush(QtCore.Qt.black))    
        self.QPainter.drawPath(self.QPath)  
        self.QPainter.end()
        
        self.newQP = QtGui.QPainter(self)
        self.newQP.drawPixmap(QtCore.QPointF(0,0), self.qpm)
        self.newQP.end()
        
        
if __name__ == "__main__":
    
    app = QtGui.QApplication(sys.argv)
    window = DrawGraph()
    window.show()
    window.dessine_moi_le_carre_stp()
    
    sys.exit(app.exec_())
             
        
            

Oh grand magnat pythonesque...

Si je n'appelle pas la fonction end sur mes deux qpainter, lorsque je ferme la fenêtre un warning apparait :

Même avec un gros gros rectangle, il n'affiche rien :
self.QPath.addRect(50,50,400,400)

Le truc c'est que je comprends lentement au début, mais après lorsque j'ai compri je roxxe ^^ :evil:

Traduction : je comprends vite mais il faut m'expliquer longtemps. Le soucis c'est que je n'ai certains reflexes ou mécanismes pour comprendre ou utiliser la doc à 100 %.