class TestListBox(ui.QtGui.QListWidget):
      def __init__(self, type, parent=None):
            super(TestListBox, self).__init__(parent)
            self.setAcceptDrops(True)

      def dragEnterEvent(self, event):
            if event.mimeData().hasUrls:
                  event.accept()
            else:
                  event.ignore()

      def dragMoveEvent(self, event):
            if event.mimeData().hasUrls:
                  event.setDropAction(QtCore.Qt.CopyAction)
                  event.accept()
            else:
                  event.ignore()

      def dropEvent(self, event):
            
            if event.mimeData().hasUrls:
                  event.setDropAction(QtCore.Qt.CopyAction)
                  event.accept()
                  
                  links = []

                  for url in event.mimeData().urls():
                        links.append(str(url.toLocalFile()))
                  
                  self.emit(ui.QtCore.SIGNAL("dropped"), links)
            else:
                  event.ignore()

From there, in your window code you can initialize the list such as self.view = TestListbox(self) .  You must also make sure 

that the listView widget is set as the central widget for the window.  If you do not set it to be the central widget, the drag and

drop functionality does not appear to work.  The last couple of steps is to then connect the drop signal to a function where you

add the list items into the list.  The code above gets the data, but it does not actually add the data as items into the widget.  

To do this add code such as this:

self.connect(self.view, QtCore.SIGNAL("dropped"), self.testDropMethod )

In the function called testDropMethod just add the items to the list. The method should be defined in this way:

def testDropMethod(self, l): (l is the actual list of files that you can iterate through and add as items to the list)

I hope this is helpful for anyone who is also trying to do this. There is also a very good post on this here

.

The class had a list of properties such as:

properties = ['name', 'number', 'location']

Then, in the class, I created a fairly generic function called getPropertyValue(self, *args, **kwargs), which took an argument of the name of the property that we wanted to get the value for.  So it ended up being something like:

def getProperty(self, *args, **kwargs):
      if kwargs:
            # check to make sure we have a property argument passed in
            propertyName = kwargs.get('property', None)

            # check to make sure the property name is in the list of properties
            if propertyName in self.properties:
                  # get the value of the property and return it
                  return getattr(self, propertyName)

From there I can then create a function based off of that generic function called something like getName() dynamically.  To do this I used a for loop in the __init__ function for the class.  It ended up being:

for prop in self.properties:
      self.__dict__['get%s' % prop] = types.MethodType(pm.windows.Callback(self.getProperty,
                                                       {}, property = prop), self)

The tricky part was calling a function with an argument using MethodType. I started by trying to use a lambda function, but this does not work very well in for loops due to scope issues. Luckily I was doing this for a script in Maya, so I was able to use PyMEL which has a Callback object that solves this for me. That is what the pm.windows.Callback is, and it works well in this case since I am running this from Maya. It returns an instance of the method back to me with the proper argument set for it.

myClass.doSomething()

as opposed to

myClass().doSomething(), which will run the class initialization function.

To define a class method much like the one above you can use the syntax:

class myClass():
      def __init__(self):
            self.someVariable = "test"
      @classmethod
      def doSomething(cls):
            print "My first class method"

This is good because it allows you to skip code that you have put in your initialization function if you have overridden it. This is also good for utility functions where you just want to run the function without initializing the class. With Python's class methods you still also have access to the class variables.

This is also a good link on the subject: http://stackoverflow.com/questions/38238/what-are-class-methods-in-python-for