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

As an example, I can use the System library from .Net to set the envrionment variables using this process from a Python script.  The System library has a easy to use function that works well for setting user environment variables as well as system envrionment variables on Windows.  The script below is an example of how this can work.   

There are some interesting possibilities that this opens up.  If you have an API or anything that has been built into a library, you can add that library as a reference using Python .net.  Since they can be used with Python, they can also then be used in Maya as well.

Python .Net is fairly easy to setup, and you can find directions and info at http://tech-artists.org/wiki/PythonNetInMaya .  You can also download Python .Net source code and libraries from http://sourceforge.net/projects/pythonnet/files/pythonnet-2.0-alpha2-clr2.0_py25/ .  

In Python you can import everything from a module using from mymodule import * .  This will import everything from the module into the default namespace.  This can be nice since you can just call the function as normal by putting in bestever(); however, this can create name clashes.

In the case of our example modules above:

module1.py

def bestever(v = True)

print "This is module1!"

module2.py

def bestever(v = True):

print "I am module 2!"

if we ran this code:

from module1 import *

from module2 import *

bestever()

we would get the output:

I am module 2!

Python takes the last known instance of the function bestever, which would be module 2 since we imported it last.  If we wanted to tell python which one to use we would have to import the module another way.

import module1 as m1 #"as m1" is what creates the namespace

import module2 as m2 #"as m2" is what creates the namespace

m1.bestever() # call the bestever from module 1

m2.bestever() # call the bestever from module 2

Running this code we can now call out to the version of bestever we want using the namespace.  For small programs where we are certain that there will be no name clashes we can use the first way of importing a module if we want, but to avoid any issues it is always a good idea to use namespaces.  You can keep the names of the namespaces minimal while avoiding issues with your program not working properly.   

http://www.cgbootcamp.com/tutorials/category/maya-pymel