pyQt v4 rowsMoved Signal

Im pretty new to Qt and have been trying to create a UI where the user will have rows of information and each row represents a stage in a pipeline. Iam trying to achieve that a user can drag and drop the different rows and that will change the order in which the steps occur.

I have achieved the drag and drop of the rows using : self.tableView.verticalHeader().setMovable(True)

Iam now trying to get the Signal"rowsMoved" to work but cant seem to get it to work in my custom model and delegate. If anyone knows of a way to get this working or of a way to not use this Signla and use another signal to track which row has moved and where it is now moved to. It will be a great help! :)

Thanks everyone

CODE BELOW

class pipelineModel( QAbstractTableModel ):

    def __init_( self ):
        super( pipelineModel, self ).__init__()
        self.stages = []

    # Sets up the population of information in the Model    
    def data( self, index, role=Qt.DisplayRole ):

        if (not index.isValid() or not (0 <= index.row() < len(self.stages) ) ):
            return QVariant()

        column = index.column()
        stage = self.stages[ index.row() ]          # Retrieves the object from the list using the row count.

        if role == Qt.DisplayRole:                      # If the role is a display role, setup the display information in each cell for the stage that has just been retrieved
            if column == NAME:
                return QVariant(stage.name)
            if column == ID:
                return QVariant(stage.id)
            if column == PREV:
                return QVariant(stage.prev)
            if column == NEXT:
                return QVariant(stage.next)
            if column == TYPE:
                return QVariant(stage.assetType)
            if column == DEPARTMENT:
                return QVariant(stage.depID)
            if column == EXPORT:
                return QVariant(stage.export)
            if column == PREFIX:
                return QVariant(stage.prefix)
            if column == DELETE:
                return QVariant(stage.delete)

        elif role == Qt.TextAlignmentRole:
            pass

        elif role == Qt.TextColorRole:
            pass

        elif role == Qt.BackgroundColorRole:
            pass

        return QVariant()

    # Sets up the header information for the table
    def headerData( self, section, orientation, role = Qt.DisplayRole ):

        if role == Qt.TextAlignmentRole:

            if orientation == Qt.Horizontal:
                return QVariant( int(Qt.AlignLeft|Qt.AlignVCenter))
            return QVariant( int(Qt.AlignRight|Qt.AlignVCenter))

        if role != Qt.DisplayRole:
            return QVariant()

        if orientation == Qt.Horizontal:        # If Orientation is horizontal then we populate the headings
            if section == ID:
                return QVariant("ID")
            elif section == PREV:
                return QVariant("Previouse")
            elif section == NEXT: 
                return QVariant("Next")
            elif section == NAME:
                return QVariant("Name")
            elif section == TYPE:
                return QVariant("Type")
            elif section == DEPARTMENT:
                return QVariant("Department")
            elif section == EXPORT:
                return QVariant("Export Model")
            elif section == PREFIX:
                return QVariant("Prefix")
            elif section == DELETE:
                return QVariant("Delete")
        return QVariant( int( section + 1 ) )           # Creates the Numbers Down the Vertical Side

    # Sets up the amount of Rows they are
    def rowCount( self, index = QModelIndex() ):
        count = 0
        try:
            count = len( self.stages )
        except:
            pass

        return count

    # Sets up the amount of columns they are
    def columnCount( self, index = QModelIndex() ):
        return 9

    def rowsMoved( self, row, oldIndex, newIndex ):
        print 'ASDASDSA'

# ---------MA开发者_Python百科IN AREA---------
class pipeline( QDialog ):


    def __init__(self, parent = None):
        super(pipeline, self).__init__(parent)
        self.stages = self.getDBinfo()                      # gets the stages from the DB and return them as a list of objects

        tableLabel      = QLabel("Testing Table - Custom Model + Custom Delegate")
        self.tableView  = QTableView()              # Creates a Table View (for now we are using the default one and not creating our own)

        self.tableDelegate  = pipelineDelegate()
        self.tableModel     = pipelineModel()

        tableLabel.setBuddy( self.tableView )
        self.tableView.setModel( self.tableModel )
#       self.tableView.setItemDelegate( self.tableDelegate )

        layout = QVBoxLayout()
        layout.addWidget(self.tableView)
        self.setLayout(layout)

        self.tableView.verticalHeader().setMovable(True) 

        self.connect(self.tableModel, SIGNAL("rowsMoved( )"), self.MovedRow) # trying to setup an on moved signal, need to check threw the available slots
#       self.connect(self.tableModel, SIGNAL("  rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex ,int)"), self.MovedRow) # trying to setup an on moved signal, need to check threw the available slots

---

Note: Components connected to this signal use it to adapt to changes in the model's dimensions. It can only be emitted by the QAbstractItemModel implementation, and cannot be explicitly emitted in subclass code.

---

What you want is to subclass the QTableView, and overload the rowMoved() SLOT

class MyTableView(QtGui.QTableView):
    def __init__(self, parent=None):
        super(MyTableView, self).__init__(parent)

        self.rowsMoved.connect(self.movedRowsSlot)  

    def rowMoved(self, row, oldIndex, newIndex):
        # do something with these or

        super(MyTableView, self).rowMoved(row, oldIndex, newIndex)

    def movedRowsSlot(self, *args):
        print "Moved rows!", args

Edited To show both overloading rowMoved slot, and using rowsMoved signal