Hi all, 
          a problem I'm having right now with my script is that when my gui 
takes in a series of selections decided by the user, I want to be able to 
select a row/rows from the GUI and remove it. Currently I'm just trying to 
get it to print out the information from the selection but it crashes 
everytime I do so. After some attempts to debug it, I noticed that 
everytime I send the information into the itemFromIndex method in my model 
I'm getting some huge number like 65536 which is the reason it has been 
crashing

           Could anyone tell me the likely reason that this may be so? Or 
possible mistakes I've made? Attached are the files. 

Thank you
Gann Boon Bay

-- 
You received this message because you are subscribed to the Google Groups 
"Python Programming for Autodesk Maya" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/python_inside_maya/934ce0cf-3e97-45fa-be70-1990757b8172%40googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
from PyQt4 import QtCore, QtGui
import sip

import maya.cmds as cmds
import maya.OpenMaya as api
import maya.OpenMayaUI as apiUI
import icons_rc
import sys

def mayaMainWindow():

    ptr = apiUI.MQtUtil.mainWindow()

    mainWin= sip.wrapinstance(long(ptr),QtCore.QObject)

    return mainWin


class Node(object):

    def __init__(self, name, parent=None):

        self._name=name
        self._children=[]
        self._parent=parent

        if parent is not None:
            parent.addChild(self)

    def typeInfo(self):

        return 'NODE'

    def addChild(self, child):
        self._children.append(child)

    def insertChild(self, position, child):

        if position < 0 or position > len(self._children):
            return False

        self._children.insert(position, child)
        child._parent = self
        return True

    def removeChild(self, position):

        if position < 0 or position > len(self._children):
            return False

        child = self._children.pop(position)
        child._parent = None

        return True

    def name(self):
        return self._name

    def setName(self,name):
        self._name=name

    def child(self, row):
        if row >len(self._children):
            print row
        else:
            return self._children[row]

    def childCount(self):
            return len(self._children)

    def parent(self):
        return self._parent

    def row(self):
        if self._parent is not None:
            return self._parent._children.index(self)



class SceneGraphModel(QtCore.QAbstractItemModel):

        def __init__(self, parent=None):
            super(SceneGraphModel, self).__init__(parent)
            self._rootNode=Node(None)

        def itemFromIndex( self, index ):

            '''Returns the TreeItem instance from a QModelIndex.'''
            return index.internalPointer() if index.isValid() else self._rootNode

        def rowCount(self, parent):
            if not parent.isValid():
                parentNode=self._rootNode
            else:
                parentNode = parent.internalPointer()

            return parentNode.childCount()

        def columnCount(self, parent):
            return 2

        def data(self, index, role):
            if not index.isValid():
                return None
            node = index.internalPointer()

            if role == QtCore.Qt.DisplayRole or role==QtCore.Qt.EditRole:
                if index.column()==0:

                    return node.name()

                else:
                    return node.typeInfo()

        def setData(self, index, value, role=QtCore.Qt.EditRole):

            if index.isValid():

                if role == QtCore.Qt.EditRole:

                    node = index.internalPointer()
                    node.setName(value)

                    return True
            return False


        def headerData(self, section, orientation, role):
            if role == QtCore.Qt.DisplayRole:
                if section==0:
                    return 'Scenegraph'
                else:
                    return 'Typeinfo'

        def flags(self,index):
            return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable

        def parent(self, index):

            node=index.internalPointer()
            parentNode = node.parent()

            if parentNode == self._rootNode:
                return QtCore.QModelIndex()


            return self.createIndex(parentNode.row(), 0,parentNode)

        def index(self, row, column, parent):

            parentNode = self.getNode(parent)

            childItem = parentNode.child(row)


            if childItem:
                return self.createIndex(row, column, childItem)
            else:
                return QtCore.QModelIndex()

        def getNode(self, index):
            if index is not None:
                node = index.internalPointer()
                if node:
                    return node

            return self._rootNode


        def insertRows(self, position, rows, name, parent=QtCore.QModelIndex()):

            parentNode = self.getNode(parent)

            self.beginInsertRows(parent, position, position + rows - 1)

            for row in range(rows):

                childCount = parentNode.childCount()
                childNode = Node(name)
                success = parentNode.insertChild(position, childNode)

            self.endInsertRows()

            return success

        def removeRows(self, position, rows, parent=QtCore.QModelIndex()):

            parentNode = self.getNode(parent)
            self.beginRemoveRows(parent, position, position + rows - 1)

            for row in range(rows):
                success = parentNode.removeChild(position)

            self.endRemoveRows()

            return success
'''
model = SceneGraphModel()

treeView=QtGui.QTreeView()
treeView.show()

treeView.setModel(model)
model.insertRows(0,5)
'''
from PyQt4 import QtCore, QtGui
import cPickle

import maya.OpenMayaUI
import maya.OpenMaya as api
import maya.cmds as cmds
import listbuild


import sip

def mayaMainWindow():
    '''Returns the Maya window as a QMainWindow instance.'''
    ptr = maya.OpenMayaUI.MQtUtil.mainWindow()
    if ptr is not None:
        return sip.wrapinstance( long(ptr), QtCore.QObject )


class Selector( QtGui.QMainWindow ):


    def __init__( self, parent=mayaMainWindow() ):

        super( Selector, self ).__init__( parent )

        self.setWindowTitle("SelectionUI")
        self.resize(250,600)


        self.create_layout()


        self._proxyModel=QtGui.QSortFilterProxyModel()
        self._proxyModel.setDynamicSortFilter(True)
        self._proxyModel.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)

        self._model=listbuild.SceneGraphModel()

        self._proxyModel.setSourceModel(self._model)

        self.tree.setModel(self._proxyModel)

        self.tree.setSortingEnabled

        self.create_connections()
        self.show()

    def create_layout(self):


        self.main_widget = QtGui.QWidget()
        self.setCentralWidget(self.main_widget)
        self.main_layout = QtGui.QVBoxLayout(self.main_widget)

        self.main_layout.setContentsMargins(10,10,10,10)

        self.uifilter = QtGui.QLineEdit()

        self.tree=QtGui.QTreeView()
        self.tree.setAlternatingRowColors(True)
        self.tree.setSizePolicy(QtGui.QSizePolicy.Preferred,
                                QtGui.QSizePolicy.Expanding)

        self.main_layout.addWidget(self.uifilter)
        self.main_layout.addWidget(self.tree)

        label=QtGui.QLabel("SelectionButton")
        self.main_layout.addWidget(label)

        button_layout = QtGui.QHBoxLayout()

        self.main_layout.addLayout(button_layout)

        self.add_button = QtGui.QPushButton("Add")
        self.remove_button = QtGui.QPushButton("Remove")
        self.quit_button = QtGui.QPushButton("Quit")

        button_layout.addWidget(self.add_button)
        button_layout.addWidget(self.remove_button)
        button_layout.addWidget(self.quit_button)



    def create_connections(self):

        # Connect the buttons
        self.connect(self.add_button, QtCore.SIGNAL("clicked()"), self.add_Object)
        self.connect(self.remove_button, QtCore.SIGNAL("clicked()"), self.remove_Object)
        self.connect(self.quit_button, QtCore.SIGNAL("clicked()"), self.close_Dialog)

        QtCore.QObject.connect(self.uifilter, QtCore.SIGNAL('textChanged(QString'),self._proxyModel.setFilterRegExp)

    def getSelection(self):

        selection = api.MSelectionList()

        api.MGlobal.getActiveSelectionList(selection)

        selection_list = api.MItSelectionList(selection)

        return selection_list

    def add_Object(self):

        selection_iter=self.getSelection()

        if selection_iter is not None:

            obj = api.MObject()

            while not selection_iter.isDone():

                selection_iter.getDependNode(obj)
                dagPath = api.MDagPath.getAPathTo(obj)
                self._model.insertRows(0,1, dagPath.partialPathName())
                selection_iter.next()

        else:

            api.MGlobal.displayWarning("Nothing Selected")
            pass



    def remove_Object(self):
        indices=self.tree.selectedIndexes()
        folders = []
        shapes = []

        for index in indices:
            item = self._model.itemFromIndex(index)
            shape = str(item.data(QtCore.Qt.UserRole).toString())
            #print shape


    def close_Dialog(self):
        self.close()

Reply via email to