PluginProjectKivy.py

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

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

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

import os
import glob
import fnmatch

from PyQt6.QtCore import QObject, QTranslator

from EricWidgets.EricApplication import ericApp

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 = "10.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

error = ""


def apiFiles(language):
    """
    Module function to return the API files made available by this plugin.

    @param language language to get API file for
    @type str
    @return list of API filenames
    @rtype list of str
    """
    if language in ["Python3"]:
        apisDir = os.path.join(os.path.dirname(__file__), "ProjectKivy", "APIs")
        return glob.glob(os.path.join(apisDir, "*.api"))
    else:
        return []


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
        @type UserInterface
        """
        QObject.__init__(self, ui)
        self.__ui = ui
        self.__initialize()

        self.__translator = None
        self.__loadTranslator()

    def __initialize(self):
        """
        Private slot to (re)initialize the plugin.
        """
        self.__ericProject = ericApp().getObject("Project")

    def activate(self):
        """
        Public method to activate this plugin.

        @return tuple of None and activation status
        @rtype bool
        """
        self.__ericProject.registerProjectType(
            "Kivy",
            self.tr("Kivy"),
            self.fileTypesCallback,
            lexerAssociationCallback=self.lexerAssociationCallback,
            progLanguages=["Python3"],
        )

        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(
            "Pygments|Kivy",
            self.tr("Kivy"),
            "dummy.kv",
            self.getLexer,
            [self.tr("Kivy Files (*.kv *.kivy)")],
            [self.tr("Kivy Files (*.kv)")],
            ["*.kv", "*.kivy"],
        )

        return None, True

    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        self.__ericProject.unregisterProjectType("Kivy")

        import QScintilla.Lexers

        QScintilla.Lexers.unregisterLexer("Kivy")
        if self.KivyLexerKey in LEXERS:
            del LEXERS[self.KivyLexerKey]

        self.__initialize()

    def __loadTranslator(self):
        """
        Private method to load the translation file.
        """
        if self.__ui is not None:
            loc = self.__ui.getLocale()
            if loc and loc != "C":
                locale_dir = os.path.join(
                    os.path.dirname(__file__), "ProjectKivy", "i18n"
                )
                translation = "kivy_{0}".format(loc)
                translator = QTranslator(None)
                loaded = translator.load(translation, locale_dir)
                if loaded:
                    self.__translator = translator
                    ericApp().installTranslator(self.__translator)
                else:
                    print(
                        "Warning: translation file '{0}' could not be"
                        " loaded.".format(translation)
                    )
                    print("Using default.")

    def fileTypesCallback(self):
        """
        Public method get the filetype associations of the Kivy project type.

        @return dictionary with file type associations
        @rtype dict
        """
        if self.__ericProject.getProjectType() == "Kivy":
            return {
                "*.kv": "SOURCES",
                "*.kivy": "SOURCES",
                "*.py": "SOURCES",
            }
        else:
            return {}

    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
        @type str
        @return name of the lexer (Pygments lexers are prefixed with
            'Pygments|')
        @rtype str
        """
        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
        @type QObject
        @return reference to the instanciated lexer object
        @rtype QsciLexer
        """
        from QScintilla.Lexers.LexerPygments import LexerPygments

        lexer = LexerPygments(parent, name="Kivy")
        if lexer.canStyle():
            return lexer
        else:
            return None


#
# eflag: noqa = M801, M811