favoriteMaterial.py

import os
import math
import random
from functools import partial

import maya.cmds as cmds
import maya.OpenMayaUI as omui
import pymel.core as pm

from PySide import QtCore as qc
from PySide import QtGui as qg
import System.QTutils as qu
reload(qu)

uiFile = "C:/kTools/__favoriteMaterial/ui/main.ui"
uiSettings = "C:/kTools/__favoriteMaterial/ui/settings.ui"
favList = []
# favList = ['blinn1', 'lambert1', 'anisotropic2', 'anisotropic1']
# favList = ['blinn1', 'lambert1', 'anisotropic2', 'anisotropic1']
form_class, base_class = qu.loadUiType(uiFile)

def maya_main_window():
    main_window_ptr = omui.MQtUtil.mainWindow()
    return qu.wrapinstance(long(main_window_ptr), qg.QMainWindow)

class favoriteMaterial_UI(form_class, base_class):
	def __init__(self, parent=maya_main_window()):
		super(favoriteMaterial_UI, self).__init__(parent)
		self.setupUi(self)

		#assign functions to ui
		self.addSlotButton.clicked.connect(self.addSlot)
		self.refreshSlotButton.clicked.connect(self.refreshSlot)
		self.importLibraryAction.triggered.connect(self.importLibrary)
		self.exportLibraryAction.triggered.connect(self.exportLibrary)
		# self.settingsAction.triggered.connect(self.openSettings)
		self.randomShaderButton.clicked.connect(self.newMaterial)

		self.displayLibrary()

	def displayLibrary(self):
		# Create the port using cmds first. I couldn't get the displayPort to work unless I created a window first
		tempwin = cmds.window()
		cmds.columnLayout()
		buttons = {}
		shadersRange = len(favList)
		cols = math.ceil(float(shadersRange)/4)
		perRow = 4
		index = 0
		labels = {}
		vLayouts = {}
		ports = {}
		qPorts = {}

		for i in range(int(cols)):
			if shadersRange < perRow:
				rowRange = shadersRange
			else:
				rowRange = 4
			shadersRange = shadersRange - perRow
			for j in range(int(rowRange)):
				labelName = str(favList[index])
				labels[(i, j)] = qg.QLabel(labelName)
				labels[(i, j)].setAlignment(qc.Qt.AlignCenter)

				ports[(i,j)] = cmds.swatchDisplayPort(labelName, rs=50, wh=(50, 50), sn=labelName, pc=partial(self.assignSlot, index))
				qPorts[(i,j)] = qu.toQtObject(ports[(i,j)])
				qPorts[(i,j)].setContextMenuPolicy(qc.Qt.ActionsContextMenu)
				# cmds.deleteUI(ports[(i,j)])

				edit = qg.QAction(self)
				edit.setText("edit")
				edit.triggered.connect(partial(self.editSlot, index))

				delete = qg.QAction(self)
				delete.setText("remove from library")
				delete.triggered.connect(partial(self.deleteSlot, index))

				deleteNet = qg.QAction(self)
				deleteNet.setText("delete network")
				deleteNet.triggered.connect(partial(self.deleteNetwork, index))

				duplicateNet = qg.QAction(self)
				duplicateNet.setText("duplicate network")
				duplicateNet.triggered.connect(partial(self.duplicateNetwork, index))

				qPorts[(i,j)].addAction(edit)
				qPorts[(i,j)].addAction(delete)
				qPorts[(i,j)].addAction(deleteNet)
				qPorts[(i,j)].addAction(duplicateNet)

				vLayouts[(i,j)] = qg.QVBoxLayout()
				vLayouts[(i,j)].addWidget(qPorts[(i,j)])
				vLayouts[(i,j)].addWidget(labels[(i,j)])

				self.shadersGrid.layout().addLayout(vLayouts[(i,j)], i, j)
				index = index + 1
		for port in ports:
			# cmds.deleteUI(port)
			print "port"
		cmds.deleteUI(tempwin)
		print tempwin

	def addSlot(self, shaderName=None):
		if shaderName:
			if cmds.objExists(shaderName):
				material = shaderName
			else:
				print "Material doesn't exist."
				material = None
		elif cmds.ls(selection=True):
			selection = cmds.ls(selection=True, materials=True)
			if selection:
				material = selection[0]
			else: material = None
		else:
			print "Something went wrong. Maybe your material doesn't exists?"
			material = None

		if material:
			if material not in favList:
				favList.append(material)
			else:
				print "Shader {0} already on the list. Skipping.".format(material)
			self.refreshSlot()

	def refreshSlot(self):
		print favList
		for index, slot in enumerate(favList):
			#check if shader exist
			if not cmds.objExists(slot):
				favList.pop(index)
				print "Shader {0} doesn't exist. Deleting from list.".format(slot)
		self.displayLibrary()

	def editSlot(self, material):
		print material
		pass
	def deleteSlot(self, material):
		name = favList[material]
		favList.pop(material)
		print "Shader {0} deleted from list.".format(name)
	def deleteNetwork(self, material):
		pass
	def duplicateNetwork(self, material):
		pass
	def assignSlot(self, material):
		pass
	def checkShadingNode(self):
		pass
	def newMaterial(self):
		pass
	def importLibrary(self):
		pass
	def exportLibrary(self):
		pass