PluginProjectKivy.py

# -*- coding: utf-8 -*-

# Copyright (c) 2013 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the Kivy project plug-in.
"""

import fnmatch

from PyQt4.QtCore import QObject

from E5Gui.E5Application import e5App

import Preferences

from pygments.lexers._mapping import LEXERS

# Start-of-Header
name = "Kivy Project Plugin"
author = "Detlev Offenbach <detlev@die-offenbachs.de>"
autoactivate = True
deactivateable = True
version = "1.0.0"
className = "ProjectKivyPlugin"
packageName = "ProjectKivy"
shortDescription = "Project support for Kivy projects."
longDescription = """This plugin implements project support for Kivy projects."""
needsRestart = False
pyqtApi = 2
# End-of-Header


class ProjectKivyPlugin(QObject):
    """
    Class implementing the Kivy project plugin.
    """
    lexerAssociations = {
        "*.kv": "Pygments|Kivy",
        "*.kivy": "Pygments|Kivy",
    }
    
    KivyLexerKey = 'KivyLexer'
    KivyLexerEntry = (
        'ProjectKivy.KivyLexer',
        'Kivy',
        ('kivy', 'kv'),
        ('*.kv', '*.kivy'),
        ('application/x-kivy',)
    )
    
    def __init__(self, ui):
        """
        Constructor
        
        @param ui reference to the user interface object (UI.UserInterface)
        """
        QObject.__init__(self, ui)
        self.__ui = ui
        self.__initialize()
    
    def __initialize(self):
        """
        Private slot to (re)initialize the plugin.
        """
        self.__e5project = e5App().getObject("Project")
    
    def activate(self):
        """
        Public method to activate this plugin.
        
        @return tuple of None and activation status (boolean)
        """
        self.__e5project.registerProjectType("Kivy", self.trUtf8("Kivy"),
            self.fileTypesCallback,
            lexerAssociationCallback=self.lexerAssociationCallback)
        
        from Project.ProjectBrowser import SourcesBrowserFlag, FormsBrowserFlag, \
            TranslationsBrowserFlag, OthersBrowserFlag
        Preferences.setProjectBrowserFlagsDefault("Kivy",
            SourcesBrowserFlag | \
            FormsBrowserFlag | \
            TranslationsBrowserFlag | \
            OthersBrowserFlag,
        )
        
        LEXERS[self.KivyLexerKey] = self.KivyLexerEntry
        import QScintilla.Lexers
        QScintilla.Lexers.registerLexer(
            "Kivy", 
            self.trUtf8("Kivy"), 
            "dummy.kv", 
            self.getLexer, 
            [self.trUtf8('Kivy Files (*.kv)')],
            [self.trUtf8('Kivy Files (*.kv)')], 
            ['*.kv', '*.kivy']
        )
        
        return None, True
    
    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        self.__e5project.unregisterProjectType("Kivy")
        
        import QScintilla.Lexers
        QScintilla.Lexers.unregisterLexer("Kivy")
        if self.KivyLexerKey in LEXERS:
            del LEXERS[self.KivyLexerKey]
        
        self.__initialize()
    
    def fileTypesCallback(self):
        """
        Public method get the filetype associations of the Kivy project type.
        
        @return dictionary with file type associations
        """
        if self.__e5project.getProjectType() == "Kivy":
            fileTypes = {
                "*.kv": "SOURCES",
                "*.kivy": "SOURCES",
                "*.py": "SOURCES",
            }
        else:
            fileTypes = {}
        return fileTypes
    
    def lexerAssociationCallback(self, filename):
        """
        Public method to get the lexer association of the Kivy project type for
        a file.
        
        @param filename name of the file (string)
        @return name of the lexer (string) (Pygments lexers are prefixed with 'Pygments|')
        """
        for pattern, language in self.lexerAssociations.items():
            if fnmatch.fnmatch(filename, pattern):
                return language
        
        return ""
    
    def getLexer(self, parent=None):
        """
        Public method to instantiate a Pygments Kivy lexer object.
        
        @param parent reference to the parent object (QObject)
        @return reference to the instanciated lexer object (QsciLexer)
        """
        from QScintilla.Lexers.LexerPygments import LexerPygments
        lexer = LexerPygments(parent, name="Kivy")
        if lexer.canStyle():
            return lexer
        else:
            return None