示例#1
0
    def newProject(self, projectName, projectCode):
        """
        Create new project

        :param projectName: Project name
        :type projectName: str
        :param projectCode: Project code
        :type projectCode: str
        """
        self.log.info("#--- Create New Project ---#")
        self.log.info("Project Name: %s" % projectName)
        self.log.info("Project Code: %s" % projectCode)
        #--- Check New Project ---#
        if '%s--%s' % (projectName, projectCode) in self.projects:
            raise AttributeError("Project already exists: %s--%s" % (projectName, projectCode))
        if projectName in self.projectNames:
            raise AttributeError("Project name already used: %s" % projectName)
        if projectCode in self.projectCodes:
            raise AttributeError("Project code already used: %s" % projectCode)
        #--- Create Project Folder ---#
        newProjectPath = pFile.conformPath(os.path.join(self._fdn.__projectsPath__,
                                                        '%s--%s' % (projectName, projectCode)))
        pFile.createPath([newProjectPath], log=self.log)
        #--- Create Project File ---#
        projFile = pFile.conformPath(os.path.join(newProjectPath, '%s--%s.py' % (projectName, projectCode)))
        projDict = dict(project="%s--%s" % (projectName, projectCode), watchers=[self._fdn.__user__],
                        _assets=None, _shots=None)
        try:
            pFile.writeDictFile(projFile, projDict)
            self.log.debug("---> Project file successfully written: %s" % projFile)
        except:
            raise IOError("!!! Can not write project file: %s !!!" % projFile)
示例#2
0
 def __init__(self, mainUi):
     super(LoadProject, self).__init__(mainUi)
     self.mainUi = mainUi
     #--- Core ---#
     self.log = self.mainUi.log
     self._fdn = self.mainUi._fdn
     self._users = self._fdn._users
     self._groups = self._fdn._groups
     self._project = self._fdn._project
     #--- Icons ---#
     self.iconStore = QtGui.QIcon(
         pFile.conformPath(
             os.path.join(self.mainUi.__iconPath__, 'png', 'pinGreen.png')))
     self.iconRemove = QtGui.QIcon(
         pFile.conformPath(
             os.path.join(self.mainUi.__iconPath__, 'png', 'del.png')))
     self.iconRefresh = QtGui.QIcon(
         pFile.conformPath(
             os.path.join(self.mainUi.__iconPath__, 'png', 'refresh.png')))
     self.iconLoad = QtGui.QIcon(
         pFile.conformPath(
             os.path.join(self.mainUi.__iconPath__, 'png', 'apply.png')))
     self.iconCancel = QtGui.QIcon(
         pFile.conformPath(
             os.path.join(self.mainUi.__iconPath__, 'png', 'cancel.png')))
     #--- Setup ---#
     self._setupDial()
示例#3
0
class Fondation(object):
    """
    Fondation Class: Contains foundation datas, main core object

    :param logLvl : Log level ('critical', 'error', 'warning', 'info', 'debug', 'detail')
    :type logLvl: str
    """

    __user__ = os.environ['USERNAME']
    __rootPath__ = "E:/fondation"
    __projectsPath__ = pFile.conformPath(os.path.join(__rootPath__, "projects"))
    __settingsPath__ = pFile.conformPath(os.path.join(__rootPath__, "settings"))

    def __init__(self, logLvl='info'):
        self._setup(logLvl)
        self._groups = userGroups.Groups(self)
        self._users = users.Users(self)
        self._project = project.Project(self)

    def _setup(self, logLvl):
        """
        Setup Foundation core object
        """
        #--- Init Log ---#
        self.log = pFile.Logger(title=self.__class__.__name__, level=logLvl)
        self.log.info("########## %s ##########" % self.__class__.__name__, newLinesBefore=1)
        #--- Create Tool Paths ---#
        self.log.debug("#--- Check Paths ---#")
        paths = [self.__rootPath__, self.__projectsPath__, self.__settingsPath__]
        pFile.createPath(paths, log=self.log)

    @property
    def contextTypes(self):
        """
        Get context types

        :return: Context types
        :rtype: list
        """
        return ['asset', 'shot']

    @property
    def typoExclusion(self):
        """
        Typo results that must not be found

        :return: Typo exclusion
        :rtype: list
        """
        return ['', ' ', 'None', None]
示例#4
0
    def projects(self):
        """
        Get all projects

        :return: Project list
        :rtype: list
        """
        projectList = []
        for fld in os.listdir(self._fdn.__projectsPath__):
            if '--' in fld:
                fldPath = pFile.conformPath(os.path.join(self._fdn.__projectsPath__, fld))
                if os.path.isdir(fldPath):
                    if os.path.exists(pFile.conformPath(os.path.join(fldPath, '%s.py' % fld))):
                        projectList.append(fld)
        return projectList
示例#5
0
class ToolBox(QtGui.QMainWindow, toolBoxUI.Ui_mw_toolBox):
    """
    ToolBox class: Cloth toolBox mainUi. Contains cloth dept cmds and tools

    :param logLvl : Log level ('critical', 'error', 'warning', 'info', 'debug', 'detail')
    :type logLvl: str
    :param parent: Maya main window
    :type parent: QtCore.QObject
    """

    __iconPath__ = pFile.conformPath(env.iconsPath)

    def __init__(self, logLvl='info', parent=None):
        self.log = pFile.Logger(title=self.__class__.__name__, level=logLvl)
        self.log.info("########## Launching %s Ui ##########" % self.__class__.__name__, newLinesBefore=1)
        super(ToolBox, self).__init__(parent)
        self._setupUi()

    def _setupUi(self):
        """
        Setup main ui
        """
        self.log.debug("Setup %s ui ..." % self.__class__.__name__)
        self.setupUi(self)
        #-- Widgets --#
        self.wgModeBox = toolBoxWgts.ModeBox(self)
        self.vl_mode.addWidget(self.wgModeBox)
        self.wgRiggBox = toolBoxWgts.RiggBox(self)
        self.vl_setup.addWidget(self.wgRiggBox)
示例#6
0
    def loadProject(self, project):
        """
        Load given project

        :param project: Project (name--code)
        :type project: str
        """
        self.log.info("#--- Load Project: %r ---#" % project)
        #--- Check Project ---#
        projectFile = pFile.conformPath(
            os.path.join(self._fdn.__projectsPath__, project,
                         '%s.py' % project))
        if not os.path.exists(projectFile):
            raise ValueError("!!! Project %r not found !!!" % project)
        #--- Get Project ---#
        try:
            projectDict = pFile.readDictFile(projectFile)
        except:
            raise IOError("!!! Can not load project %r !!!" % project)
        #--- Load Project ---#
        if self._fdn.__user__ in projectDict['watchers']:
            self.update(**projectDict)
            self.log.info("---> Project %r successfully loaded" % project)
        else:
            raise ValueError("User %r is not set as projectUser in %s !" %
                             (self._fdn.__user__, project))
示例#7
0
def launchDisplayColorUi():
    """
    Launch DisplayColorUi
    """
    from mayaTools.util import displayColor as toolModul
    tmFile = pFile.conformPath(os.path.join(os.path.dirname(toolModul.__file__), '__tm__.py'))
    execfile(tmFile)
示例#8
0
def launchRiggerUi():
    """
    Launch RiggerUi
    """
    from mayaTools.cloth import rigger as toolModul
    tmFile = pFile.conformPath(os.path.join(os.path.dirname(toolModul.__file__), '__tm__.py'))
    execfile(tmFile)
示例#9
0
    def parseUsers(self, userPrefix, userName):
        """
        Parse disk users directory

        :param userPrefix: User prefix folder
        :type userPrefix: str
        :param userName: User name
        :type userName: str
        :return: Users list
        :rtype: list
        """
        self.log.detail("Parse disk ...")
        #--- Get Index List ---#
        if userPrefix is not None:
            prefixList = [userPrefix]
        else:
            if userName is not None:
                prefixList = [userName[0].lower()]
            else:
                prefixList = os.listdir(self.usersPath) or []
        #--- Collecte Index ---#
        userList = []
        for prefix in prefixList:
            prefixPath = pFile.conformPath(os.path.join(self.usersPath, prefix))
            if len(prefix) == 1 and os.path.isdir(prefixPath):
                #--- Get User List ---#
                if userName is not None:
                    userList = [userName]
                else:
                    userList.extend(os.listdir(prefixPath) or [])
        #--- Result ---#
        return userList
示例#10
0
    def buildTree(self, treeName):
        """
        Refresh 'Projects' tree

        :param treeName: Tree widget name ('allProjects' or 'myProjects')
        :type treeName: str
        """
        #--- Get Projects ---#
        if treeName == 'allProjects':
            self.log.detail("Build 'All Projects' tree ...")
            projects = self._project.projects
            treeWidget = self.tw_allProjects
        else:
            self.log.detail("Build 'My Projects' tree ...")
            projects = self._users._user.userPinedProjects
            treeWidget = self.tw_myProjects
        #--- Populate Tree ---#
        treeWidget.clear()
        for project in projects:
            projectFile = pFile.conformPath(os.path.join(self._fdn.__projectsPath__, project, '%s.py' % project))
            data = pFile.readDictFile(projectFile)
            newItem = self.new_projectItem(project, data, treeWidget)
            treeWidget.addTopLevelItem(newItem)
        #--- Refresh ---#
        self.rf_treeColumns(treeWidget)
        treeWidget.sortItems(0, QtCore.Qt.AscendingOrder)
示例#11
0
 def buildEntities(self):
     """
     Build all entities from disk
     """
     self.entities = []
     if self.contextPath is not None:
         if os.path.exists(self.contextPath):
             contents = os.listdir(self.contextPath) or []
             for fld in contents:
                 if not fld.startswith('_') and not fld.startswith('.'):
                     path = pFile.conformPath(os.path.join(self.contextPath, fld))
                     entityFile = pFile.conformPath(os.path.join(path, '%s.py' % fld))
                     if os.path.exists(entityFile):
                         self.log.detail(">>> Build entity from file %s ..." % entityFile)
                         data = pFile.readDictFile(entityFile)
                         self.addEntity(self.newEntity(**data))
示例#12
0
    def loadProject(self, project):
        """
        Load given project

        :param project: Project (name--code)
        :type project: str
        """
        self.log.info("#--- Load Project: %r ---#" % project)
        #--- Check Project ---#
        projectFile = pFile.conformPath(os.path.join(self._fdn.__projectsPath__, project, '%s.py' % project))
        if not os.path.exists(projectFile):
            raise ValueError("!!! Project %r not found !!!" % project)
        #--- Get Project ---#
        try:
            projectDict = pFile.readDictFile(projectFile)
        except:
            raise IOError("!!! Can not load project %r !!!" % project)
        #--- Load Project ---#
        if self._fdn.__user__ in projectDict['watchers']:
            self.update(**projectDict)
            for ctxtObj in self.contexts:
                ctxtObj.buildEntities()
            self.log.info("---> Project %r successfully loaded" % project)
        else:
            raise ValueError("User %r is not set as projectUser in %s !" % (self._fdn.__user__, project))
示例#13
0
    def buildTree(self, treeName):
        """
        Refresh 'Projects' tree

        :param treeName: Tree widget name ('allProjects' or 'myProjects')
        :type treeName: str
        """
        #--- Get Projects ---#
        if treeName == 'allProjects':
            self.log.detail("Build 'All Projects' tree ...")
            projects = self._project.projects
            treeWidget = self.tw_allProjects
        else:
            self.log.detail("Build 'My Projects' tree ...")
            projects = self._users._user.userPinedProjects
            treeWidget = self.tw_myProjects
        #--- Populate Tree ---#
        treeWidget.clear()
        for project in projects:
            projectFile = pFile.conformPath(
                os.path.join(self._fdn.__projectsPath__, project,
                             '%s.py' % project))
            data = pFile.readDictFile(projectFile)
            newItem = self.new_projectItem(project, data, treeWidget)
            treeWidget.addTopLevelItem(newItem)
        #--- Refresh ---#
        self.rf_treeColumns(treeWidget)
        treeWidget.sortItems(0, QtCore.Qt.AscendingOrder)
示例#14
0
 def __init__(self, mainUi):
     super(LoadProject, self).__init__(mainUi)
     self.mainUi = mainUi
     #--- Core ---#
     self.log = self.mainUi.log
     self._fdn = self.mainUi._fdn
     self._users = self._fdn._users
     self._groups = self._fdn._groups
     self._project = self._fdn._project
     #--- Icons ---#
     self.iconStore = QtGui.QIcon(pFile.conformPath(os.path.join(self.mainUi.__iconPath__, 'png', 'pinGreen.png')))
     self.iconRemove = QtGui.QIcon(pFile.conformPath(os.path.join(self.mainUi.__iconPath__, 'png', 'del.png')))
     self.iconRefresh = QtGui.QIcon(pFile.conformPath(os.path.join(self.mainUi.__iconPath__, 'png', 'refresh.png')))
     self.iconLoad = QtGui.QIcon(pFile.conformPath(os.path.join(self.mainUi.__iconPath__, 'png', 'apply.png')))
     self.iconCancel = QtGui.QIcon(pFile.conformPath(os.path.join(self.mainUi.__iconPath__, 'png', 'cancel.png')))
     #--- Setup ---#
     self._setupDial()
示例#15
0
    def settingsFile(self):
        """
        Get settings file full path

        :return: Settings file full path
        :rtype: str
        """
        return pFile.conformPath(os.path.join(self._fdn.__settingsPath__, 'userGroups.py'))
示例#16
0
    def archivePath(self):
        """
        Get archive path

        :return: Archive path
        :rtype: str
        """
        return pFile.conformPath(os.path.join(self.usersPath, self.__archiveDir__))
示例#17
0
    def usersPath(self):
        """
        Get users path

        :return: Users path
        :rtype: str
        """
        return pFile.conformPath(os.path.join(self._fdn.__rootPath__, self.__usersDir__))
示例#18
0
    def projectFile(self):
        """
        Get project file full path

        :return: Project file path
        :rtype: str
        """
        if self.project is not None:
            return pFile.conformPath(os.path.join(self.projectPath, '%s.py' % self.project))
示例#19
0
    def entityFile(self):
        """
        Get entity file full path

        :return: Entity file
        :rtype: str
        """
        if self.entityPath is not None:
            return pFile.conformPath(os.path.join(self.entityPath, '%s.py' % self.entityName))
示例#20
0
    def entityPath(self):
        """
        Get entity path

        :return: Entity path
        :rtype: str
        """
        if self.contextPath is not None and self.entityName is not None:
            return pFile.conformPath(os.path.join(self.contextPath, self.entityName))
示例#21
0
    def projectPath(self):
        """
        Get project path

        :return: Project path
        :rtype: str
        """
        if self.project is not None:
            return pFile.conformPath(os.path.join(self._fdn.__projectsPath__, self.project))
示例#22
0
    def userFile(self):
        """
        Get user file full path

        :return: User file full path
        :rtype: str
        """
        if self.userName is not None:
            return pFile.conformPath(os.path.join(self.userPath, '%s.py' % self.userName))
示例#23
0
    def contextPath(self):
        """
        Get context path

        :return: Context path
        :rtype: str
        """
        if self.contextFolder is not None:
            return pFile.conformPath(os.path.join(self._project.projectPath, self.contextFolder))
示例#24
0
    def contextPath(self):
        """
        Get context entity path

        :return: Context entity path
        :rtype: str
        """
        if self._parent.contextPath is not None and self.ctxtFolder is not None:
            return pFile.conformPath(os.path.join(self._parent.contextPath, self.ctxtFolder))
示例#25
0
    def userPath(self):
        """
        Get user path

        :return: User path
        :rtype: str
        """
        if self.userName is not None:
            return pFile.conformPath(os.path.join(self._parent.usersPath, self.userPrefix, self.userName))
示例#26
0
    def delUser(self, userName=None, userObj=None, archive=False):
        """
        Delete given user

        :param userName: User name
        :type userName: str
        :param userObj: User object
        :type userObj: User
        :param archive: Archives datas (clean disk)
        :type archive: bool
        """
        # --- Check User Object ---#
        if userObj is None:
            userObj = self.getChilds(userName=userName)
        if userObj is None:
            raise AttributeError("!!! User not found: %s !!!" % userName)
        # --- Archive User ---#
        if archive:
            self.log.info("Archive user %r" % userObj.userName)
            dateTime = "%s--%s" % (pFile.getDate(), pFile.getTime())
            archivePath = pFile.conformPath(
                os.path.join(self.archivePath, userObj.userPrefix, userObj.userName, dateTime)
            )
            pFile.createPath(archivePath, recursive=True, root=self.usersPath, log=self.log)
            archiveFullPath = pFile.conformPath(os.path.join(archivePath, userObj.userName))
            # --- Create Archive ---#
            if os.path.exists(userObj.userPath):
                try:
                    shutil.copytree(userObj.userPath, archiveFullPath)
                    shutil.rmtree(userObj.userPath)
                    self.log.debug("---> User %r archived in %s" % (userObj.userName, archivePath))
                except:
                    raise IOError("!!! Can not copy tree: %s !!!" % userObj.userPath)
            else:
                raise IOError("!!! User path not found: %s !!!" % userObj.userPath)
        # --- Delete User Object ---#
        if userObj in self.childs:
            self.log.info("Deleting user object %r ..." % userObj.userName)
            self.childs.remove(userObj)
        else:
            self.log.debug("User object %r already deleted. Skipp !!!" % userObj.userName)
        # --- Result ---#
        self.log.info("---> %r deleted." % userObj.userName)
示例#27
0
    def delUser(self, userName=None, userObj=None, archive=False):
        """
        Delete given user

        :param userName: User name
        :type userName: str
        :param userObj: User object
        :type userObj: User
        :param archive: Archives datas (clean disk)
        :type archive: bool
        """
        #--- Check User Object ---#
        if userObj is None:
            userObj = self.getChilds(userName=userName)
        if userObj is None:
            raise AttributeError("!!! User not found: %s !!!" % userName)
        #--- Archive User ---#
        if archive:
            self.log.info("Archive user %r" % userObj.userName)
            dateTime = '%s--%s' % (pFile.getDate(), pFile.getTime())
            archivePath = pFile.conformPath(os.path.join(self.archivePath, userObj.userPrefix,
                                                         userObj.userName, dateTime))
            pFile.createPath(archivePath, recursive=True, root=self.usersPath, log=self.log)
            archiveFullPath = pFile.conformPath(os.path.join(archivePath, userObj.userName))
            #--- Create Archive ---#
            if os.path.exists(userObj.userPath):
                try:
                    shutil.copytree(userObj.userPath, archiveFullPath)
                    shutil.rmtree(userObj.userPath)
                    self.log.debug("---> User %r archived in %s" % (userObj.userName, archivePath))
                except:
                    raise IOError("!!! Can not copy tree: %s !!!" % userObj.userPath)
            else:
                raise IOError("!!! User path not found: %s !!!" % userObj.userPath)
        #--- Delete User Object ---#
        if userObj in self.childs:
            self.log.info("Deleting user object %r ..." % userObj.userName)
            self.childs.remove(userObj)
        else:
            self.log.debug("User object %r already deleted. Skipp !!!" % userObj.userName)
        #--- Result ---#
        self.log.info("---> %r deleted." % userObj.userName)
示例#28
0
    def toolIcon(self):
        """
        Get icon file full path

        :return: Icon file
        :rtype: str
        """
        if self.tmFile is not None:
            iconFile = pFile.conformPath(os.path.join(os.path.dirname(self.tmFile), '__ico__.png'))
            if os.path.exists(iconFile):
                return iconFile
示例#29
0
    def collecteUsers(self, userPrefix=None, userName=None, clear=False, checkStatus=False):
        """
        Collecte Users from disk

        :param userPrefix: User prefix folder
        :type userPrefix: str
        :param userName: User name
        :type userName: str
        :param clear: Clear childs contents
        :type clear: bool
        :param checkStatus: Consider userStatus when collecting
        :type checkStatus: bool
        :return: Collected user objects
        :rtype: list
        """
        self.log.debug("Collecting users ...")
        #--- Clear Users ---#
        if clear:
            self.log.detail("Clear users list")
            self.clearChilds()
        #--- Collecte Users ---#
        userObjects = []
        userList = self.parseUsers(userPrefix, userName)
        for user in userList:
            userPath = pFile.conformPath(os.path.join(self.usersPath, user[0].lower(), user))
            if not user.startswith('_') and os.path.isdir(userPath):
                #--- Remove Existing object ---#
                userCheck = self.getChilds(userName=user)
                if userCheck:
                    self.log.debug("Remove user object: %s" % user)
                    if len(userCheck) == 1:
                        self.childs.remove(userCheck[0])
                    else:
                        raise ValueError("!!! Several userObj with same userName value !!!")
                #--- Create User Object ---#
                userObj = self.newChild(userName=user)
                userObj.setDataFromUserFile()
                #--- Check Status ---#
                addUserObj = True
                if checkStatus:
                    addUserObj = userObj.userStatus
                if addUserObj:
                    #--- Store Current User ---#
                    if user == self._fdn.__user__:
                        self._user = userObj
                    #--- Add User Object ---#
                    self.addChild(userObj)
                    userObjects.append(userObj)
                    self.log.detail("---> User Object %r added" % user)
                else:
                    #--- Reject Current User ---#
                    self.log.detail("---> User Object skipped, %r status is False" % user)
        #--- Result ---#
        return userObjects
示例#30
0
    def toolIcon(self):
        """
        Get icon file full path

        :return: Icon file
        :rtype: str
        """
        if self.tmFile is not None:
            iconFile = pFile.conformPath(
                os.path.join(os.path.dirname(self.tmFile), '__ico__.png'))
            if os.path.exists(iconFile):
                return iconFile
示例#31
0
class ToolManager(QtGui.QMainWindow, toolManagerUI.Ui_mw_toolManager):
    """
    ToolManager class: Manage maya tools

    :param logLvl : Log level ('critical', 'error', 'warning', 'info', 'debug', 'detail')
    :type logLvl: str
    :param parent: Maya main window
    :type parent: QtCore.QObject
    """

    __rootDir__ = 'mayaTools'
    __rootPath__ = '/'.join(pFile.conformPath(__file__).split('/')[:-4])
    __iconPath__ = pFile.conformPath(os.path.join(env.iconsPath, 'png'))

    def __init__(self, logLvl='info', parent=None):
        self.log = pFile.Logger(title=self.__class__.__name__, level=logLvl)
        self.log.info("########## Launching %s Ui ##########" %
                      self.__class__.__name__,
                      newLinesBefore=1)
        super(ToolManager, self).__init__(parent)
        self.toolsDict = dict()
        self._setupUi()

    def _setupUi(self):
        """
        Setup ToolManager ui
        """
        self.log.debug("Setup %s ui ..." % self.__class__.__name__)
        self.setupUi(self)
        self.gridLayout.setSpacing(0)
        self.gridLayout.setMargin(0)
        self._setupMenu()
        #--- Refresh ---#
        self.buildTree()

    def _setupMenu(self):
        """
        Setup toolManager menu
        """
        #--- Log Level ---#
        for level in self.log.levels:
            menuItem = self.m_logLevel.addAction(level)
            menuItem.setCheckable(True)
            menuItem.triggered.connect(partial(self.on_miLogLevel, level))
        self.on_miLogLevel(self.log.level)

    def collecteTools(self):
        """
        Collecte tools from rootPath.

        Tool is detected if roolPackage contains '__tm__.py' file
        :return: Tools dict
        :rtype: dict
        """
        self.log.info("Collecting tools ...")
        self.toolsDict = toolMngrCmds.collecteTools(self.__rootPath__)

    def buildTree(self):
        """
        Build tools tree
        """
        self.log.debug("Init tree ...")
        self.tw_tools.clear()
        self.collecteTools()
        #--- Add Category ---#
        self.log.debug("Building tree ...")
        for category in sorted(self.toolsDict.keys()):
            catItem = self.new_treeItem('category', category)
            self.tw_tools.addTopLevelItem(catItem)
            self.tw_tools.setItemWidget(catItem, 0, catItem._widget)
            #--- Add Tool ---#
            for tool in sorted(self.toolsDict[category].keys()):
                toolItem = self.new_treeItem(
                    'tool', tool, tmFile=self.toolsDict[category][tool])
                catItem.addChild(toolItem)
                self.tw_tools.setItemWidget(toolItem, 0, toolItem._widget)
        #--- Refresh ---#
        self.tw_tools.collapseAll()

    def new_treeItem(self, itemType, itemName, tmFile=None):
        """
        Create 'Tool' tree item

        :param itemType: 'Category' or 'tool'
        :type itemType: str
        :param itemName: Tool name
        :type itemName: str
        :param tmFile: __tm__.py file fullPath
        :type tmFile: str
        :return: Tool item
        :rtype: QtGui.QTreeWidgetItem
        """
        newItem = QtGui.QTreeWidgetItem()
        newItem.itemType = itemType
        newItem.itemName = itemName
        newItem._widget = toolMngrWgts.TreeNode(self, newItem, tmFile=tmFile)
        return newItem

    def on_miLogLevel(self, logLevel):
        """
        Command launched when 'Log Level' QMenuItem is triggered

        Set ui and core log level
        :param logLevel : Log level ('critical', 'error', 'warning', 'info', 'debug', 'detail')
        :type logLevel: str
        """
        #--- Uncheck All ---#
        for menuItem in self.m_logLevel.children():
            menuItem.setChecked(False)
        #--- Check Given LogLvl ---#
        for menuItem in self.m_logLevel.children():
            if str(menuItem.text()) == logLevel:
                menuItem.setChecked(True)
                break
        #--- Set Log Level ---#
        self.log.level = logLevel
示例#32
0
class Rigger(QtGui.QMainWindow, riggerUI.Ui_mw_rigger):
    """
    Rigger class: Cloth rigger mainUi. Contains cloth setup cmds

    :param logLvl : Log level ('critical', 'error', 'warning', 'info', 'debug', 'detail')
    :type logLvl: str
    :param parent: Maya main window
    :type parent: QtCore.QObject
    """

    __iconPath__ = pFile.conformPath(env.iconsPath)

    def __init__(self, logLvl='info', parent=None):
        self.log = pFile.Logger(title=self.__class__.__name__, level=logLvl)
        self.log.info("########## Launching %s Ui ##########" %
                      self.__class__.__name__,
                      newLinesBefore=1)
        super(Rigger, self).__init__(parent)
        self.iconCloth = QtGui.QIcon(
            os.path.join(self.__iconPath__, 'maya', 'nCloth.png'))
        self.iconRigid = QtGui.QIcon(
            os.path.join(self.__iconPath__, 'maya', 'nRigid.png'))
        self.iconConst = QtGui.QIcon(
            os.path.join(self.__iconPath__, 'maya', 'nConstraint.png'))
        self._setupUi()

    def _setupUi(self):
        """
        Setup main ui
        """
        self.log.debug("Setup %s ui ..." % self.__class__.__name__)
        self.setupUi(self)
        #--- Wraps ---#
        self.gb_initWraps.clicked.connect(self.rf_initWraps)
        self.pb_hiToDecoupe.setToolTip(
            "Select driver Hi mesh, then slave cutted loS mesh.")
        self.pb_losToDecoupe.setToolTip(
            "Select slave loS mesh component, then slave cutted loS mesh.")
        #--- nCloth ---#
        self.le_clothMesh.wgResult = self.le_clothResult
        self.pb_createCloth.setIcon(self.iconCloth)
        #--- nRigid ---#
        self.le_rigidMesh.wgResult = self.le_rigidResult
        self.pb_createRigid.setIcon(self.iconRigid)
        #--- nConstraint ---#
        self.le_constraint.wgResult = self.le_constResult
        self.pb_storeConst.setIcon(self.iconConst)
        #--- Refresh ---#
        self.rf_initWraps()

    @property
    def clothSolver(self):
        """
        Get current cloth solver

        :return: Cloth solver
        :rtype: str
        """
        return str(self.cb_clothSolver.currentText())

    @property
    def rigidSolver(self):
        """
        Get current rigid solver

        :return: Rigid solver
        :rtype: str
        """
        return str(self.cb_rigidSolver.currentText())

    @property
    def passiveMode(self):
        """
        Get current passive mode

        :return: Passive mode ('collide', 'pushOut', 'passive')
        :rtype: str
        """
        if self.rb_collide.isChecked():
            return "collide"
        elif self.rb_pushOut.isChecked():
            return "pushOut"
        elif self.rb_passive.isChecked():
            return "passive"

    def rf_initWraps(self):
        """
        Refresh 'Init Wraps' QGroupBox visibility
        """
        if self.gb_initWraps.isChecked():
            self.gb_initWraps.setMaximumHeight(55)
        else:
            self.gb_initWraps.setMaximumHeight(15)