class SupportManager(PrymatexComponent, SupportBaseManager, QtCore.QObject): #Signals for bundle bundleAdded = QtCore.Signal(object) bundleRemoved = QtCore.Signal(object) bundleChanged = QtCore.Signal(object) bundlePopulated = QtCore.Signal(object) #Signals for bundle items bundleItemAdded = QtCore.Signal(object) bundleItemRemoved = QtCore.Signal(object) bundleItemChanged = QtCore.Signal(object) bundleItemTriggered = QtCore.Signal(object) #Signals for themes themeAdded = QtCore.Signal(object) themeRemoved = QtCore.Signal(object) themeChanged = QtCore.Signal(object) #Settings shellVariables = ConfigurableItem(default = [], tm_name = 'OakShelVariables') @ConfigurableItem(default = [], tm_name = 'OakBundleManagerDeletedBundles') def deleted(self, deleted): self.deletedObjects = [uuidmodule.UUID(uuid) for uuid in deleted] @ConfigurableItem(default = [], tm_name = 'OakBundleManagerDeletedBundles') def disabled(self, disabled): self.disabledObjects = [uuidmodule.UUID(uuid) for uuid in disabled] #http://manual.macromates.com/en/expert_preferences.html #When you create a new item in the bundle editor without having selected a bundle first, then the bundle with the UUID held by this defaults key is used as the target defaultBundleForNewBundleItems = ConfigurableItem(default = 'B7BC3FFD-6E4B-11D9-91AF-000D93589AF6', tm_name = 'OakDefaultBundleForNewBundleItems') SETTINGS_GROUP = 'SupportManager' def __init__(self, **kwargs): super(SupportManager, self).__init__(**kwargs) self.bundleTreeModel = BundleItemTreeModel(self) self.themeStylesTableModel = ThemeStylesTableModel(self) self.processTableModel = ExternalProcessTableModel(self) #STYLE PROXY self.themeStyleProxyModel = ThemeStyleProxyTableModel(self) self.themeStyleProxyModel.setSourceModel(self.themeStylesTableModel) #TREE PROXY self.bundleProxyTreeModel = BundleItemProxyTreeModel(self) self.bundleProxyTreeModel.setSourceModel(self.bundleTreeModel) #BUNDLES self.bundleProxyModel = BundleListModel(self) self.bundleProxyModel.setSourceModel(self.bundleTreeModel) #TEMPLATES self.templateProxyModel = TemplateListModel(self) self.templateProxyModel.setSourceModel(self.bundleTreeModel) #PROJECTS self.projectProxyModel = ProjectListModel(self) self.projectProxyModel.setSourceModel(self.bundleTreeModel) #SYNTAX self.syntaxProxyModel = SyntaxListModel(self) self.syntaxProxyModel.setSourceModel(self.bundleTreeModel) #INTERACTIVEITEMS self.actionItemsProxyModel = BundleItemTypeProxyModel(["command", "snippet", "macro"], self) self.actionItemsProxyModel.setSourceModel(self.bundleTreeModel) #PREFERENCES self.preferenceProxyModel = BundleItemTypeProxyModel("preference", self) self.preferenceProxyModel.setSourceModel(self.bundleTreeModel) #DRAGCOMMANDS self.dragcommandProxyModel = BundleItemTypeProxyModel("dragcommand", self) self.dragcommandProxyModel.setSourceModel(self.bundleTreeModel) #THEMES self.themeProxyModel = BundleItemTypeProxyModel("theme", self) self.themeProxyModel.setSourceModel(self.bundleTreeModel) #BUNDLEMENUGROUP self.bundleMenuGroup = BundleItemMenuGroup(self) @classmethod def contributeToSettings(cls): from prymatex.gui.settings.environment import VariablesSettingsWidget return [ VariablesSettingsWidget ] def setEditorAvailable(self, available): self.editorAvailable = available def appendMenuToBundleMenuGroup(self, menu, offset = None): self.bundleMenuGroup.appendMenu(menu, offset) def menuForBundle(self, bundle): return self.bundleMenuGroup.menuForBundle(bundle) # Override buildPlistFileStorage for custom storage def buildPlistFileStorage(self): return self.application.storageManager.singleFileStorage("support-plist") def buildBundleItemStorage(self): return SupportBaseManager.buildBundleItemStorage(self) #--------------------------------------------------- # Environment #--------------------------------------------------- def environmentVariables(self): environment = SupportBaseManager.environmentVariables(self) #Extend wiht the user shell variables for var in self.shellVariables: if var['enabled']: environment[var['variable']] = var['value'] return environment # Override loadSupport for emit signals def loadSupport(self, *largs, **kwargs): self.bundleProxyTreeModel.setDynamicSortFilter(True) SupportBaseManager.loadSupport(self, *largs, **kwargs) #self.bundleProxyTreeModel.sort(0, QtCore.Qt.AscendingOrder) def runSystemCommand(self, **attrs): if attrs.get("asynchronous", False): return self.runQtProcessCommand(**attrs) else: return SupportBaseManager.runSystemCommand(self, **attrs) #Interface def runQtProcessCommand(self, **attrs): context = RunningContext(**attrs) context.process = QtCore.QProcess(self) if context.workingDirectory is not None: context.process.setWorkingDirectory(context.workingDirectory) self.processTableModel.appendProcess(context.process, description = context.description()) environment = QtCore.QProcessEnvironment() for key, value in context.scriptFileEnvironment.items(): environment.insert(key, value) context.process.setProcessEnvironment(environment) def onQProcessFinished(context): def _finished(exitCode, exitStatus): self.processTableModel.removeProcess(context.process) errorValue = qbytearray_to_text( context.process.readAllStandardError()) context.errorValue = encoding.from_fs(errorValue) outputValue = qbytearray_to_text( context.process.readAllStandardOutput()) context.outputValue = encoding.from_fs(outputValue) context.outputType = exitCode context.callback(context) return _finished context.process.finished[int, QtCore.QProcess.ExitStatus].connect( onQProcessFinished(context) ) def onQProcessStarted(context): def _started(): if context.inputValue is not None: context.process.write(encoding.to_fs(context.inputValue)) context.process.closeWriteChannel() return _started context.process.started.connect(onQProcessStarted(context)) context.process.start(context.scriptFilePath) return context def buildAdHocCommand(self, *largs, **kwargs): return BundleItemTreeNode(SupportBaseManager.buildAdHocCommand(self, *largs, **kwargs)) def buildAdHocSnippet(self, *largs, **kwargs): return BundleItemTreeNode(SupportBaseManager.buildAdHocSnippet(self, *largs, **kwargs)) #--------------------------------------------------- # MANAGED OBJECTS OVERRIDE INTERFACE #--------------------------------------------------- def setDeleted(self, uuid): """ Marcar un managed object como eliminado """ self.deletedObjects.append(uuid) deleted = [str(uuid).upper() for uuid in self.deletedObjects] self.settings.setValue('deleted', deleted) def isDeleted(self, uuid): return uuid in self.deletedObjects def isEnabled(self, uuid): return uuid not in self.disabledObjects def setDisabled(self, uuid): self.disabledObjects.append(uuid) disabled = [str(uuid).upper() for uuid in self.disabledObjects] self.settings.setValue('disabled', disabled) def setEnabled(self, uuid): self.disabledObjects.remove(uuid) disabled = [str(uuid).upper() for uuid in self.disabledObjects] self.settings.setValue('disabled', disabled) #--------------------------------------------------- # BUNDLE OVERRIDE INTERFACE #--------------------------------------------------- def addBundle(self, bundle): bundleNode = BundleItemTreeNode(bundle) self.bundleTreeModel.appendBundle(bundleNode) self.bundleAdded.emit(bundleNode) return bundleNode def modifyBundle(self, bundle): self.bundleChanged.emit(bundle) def removeBundle(self, bundle): self.bundleTreeModel.removeBundle(bundle) self.bundleRemoved.emit(bundle) def getAllBundles(self): return self.bundleProxyModel.nodes() def getDefaultBundle(self): return self.getBundle(self.defaultBundleForNewBundleItems) def populatedBundle(self, bundle): self.bundlePopulated.emit(bundle) #--------------------------------------------------- # BUNDLEITEM OVERRIDE INTERFACE #--------------------------------------------------- def addBundleItem(self, bundleItem): bundleItemNode = BundleItemTreeNode(bundleItem) self.bundleTreeModel.appendBundleItem(bundleItemNode) self.bundleItemAdded.emit(bundleItemNode) return bundleItemNode def modifyBundleItem(self, bundleItem): self.bundleItemChanged.emit(bundleItem) def removeBundleItem(self, bundleItem): self.bundleTreeModel.removeBundleItem(bundleItem) self.bundleItemRemoved.emit(bundleItem) def getAllBundleItems(self): nodes = [] for bundle in self.getAllBundles(): for node in bundle.childNodes(): nodes.append(node) return nodes #--------------------------------------------------- # STATICFILE OVERRIDE INTERFACE #--------------------------------------------------- def addStaticFile(self, staticFile): bundleStaticFileNode = BundleItemTreeNode(staticFile) self.bundleTreeModel.appendStaticFile(bundleStaticFileNode) return bundleStaticFileNode def removeStaticFile(self, file): pass #--------------------------------------------------- # THEME STYLE OVERRIDE INTERFACE #--------------------------------------------------- def addThemeStyle(self, style): themeStyle = ThemeStyleTableRow(style) self.themeStylesTableModel.appendStyle(themeStyle) return themeStyle def removeThemeStyle(self, style): self.themeStylesTableModel.removeStyle(style) #--------------------------------------------------- # PREFERENCES OVERRIDE INTERFACE #--------------------------------------------------- def getAllPreferences(self): memoizedKey = ("getAllPreferences", None, None, None) if memoizedKey in self.bundleItemCache: return self.bundleItemCache.get(memoizedKey) return self.bundleItemCache.setdefault(memoizedKey, list(self.preferenceProxyModel.nodes())) #--------------------------------------------------- # TABTRIGGERS OVERRIDE INTERFACE #--------------------------------------------------- def getAllTabTriggerItems(self): memoizedKey = ("getAllTabTriggerItems", None, None, None) if memoizedKey in self.bundleItemCache: return self.bundleItemCache.get(memoizedKey) tabTriggers = [] for item in self.actionItemsProxyModel.nodes(): if item.tabTrigger is not None: tabTriggers.append(item) return self.bundleItemCache.setdefault(memoizedKey, tabTriggers) def getAllBundleItemsByTabTrigger(self, tabTrigger): memoizedKey = ("getAllBundleItemsByTabTrigger", tabTrigger, None, None) if memoizedKey in self.bundleItemCache: return self.bundleItemCache.get(memoizedKey) items = [] for item in self.actionItemsProxyModel.nodes(): if item.tabTrigger == tabTrigger: items.append(item) return self.bundleItemCache.setdefault(memoizedKey, items) #--------------------------------------------------- # KEYEQUIVALENT OVERRIDE INTERFACE #--------------------------------------------------- def getAllKeyEquivalentItems(self): memoizedKey = ("getAllBundleItemsByTabTrigger", None, None, None) if memoizedKey in self.bundleItemCache: return self.bundleItemCache[memoizedKey] keyCode = [] for item in self.actionItemsProxyModel.nodes(): if item.keyCode() is not None: keyCode.append(item) for item in self.syntaxProxyModel.nodes(): if item.keyCode() is not None: keyCode.append(item) return self.bundleItemCache.setdefault(memoizedKey, keyCode) def getAllBundleItemsByKeyEquivalent(self, keyCode): memoizedKey = ("getAllBundleItemsByKeyEquivalent", keyCode, None, None) if memoizedKey in self.bundleItemCache: return self.bundleItemCache.get(memoizedKey) items = [] for item in self.actionItemsProxyModel.nodes(): if item.keyCode() == keyCode: items.append(item) for syntax in self.syntaxProxyModel.nodes(): if syntax.keyCode() == keyCode: items.append(syntax) return self.bundleItemCache.setdefault(memoizedKey, items) #--------------------------------------------------- # FILE EXTENSION OVERRIDE INTERFACE #--------------------------------------------------- def getAllBundleItemsByFileExtension(self, path): items = [] for item in self.dragcommandProxyModel.nodes(): if any([fnmatch.fnmatch(path, "*.%s" % extension) for extension in item.draggedFileExtensions]): items.append(item) return items #--------------------------------------------------- # ACTION ITEMS OVERRIDE INTERFACE #--------------------------------------------------- def getAllActionItems(self): return self.actionItemsProxyModel.nodes() #--------------------------------------------------- # SYNTAXES OVERRIDE INTERFACE #--------------------------------------------------- def getAllSyntaxes(self): return self.syntaxProxyModel.nodes()