Mercurial Repositories > Time Tracker / file revision

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

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

"""
Module implementing the Time Tracker plugin.
"""

import os

from PyQt6.QtCore import QObject, QTranslator, QCoreApplication

from EricWidgets.EricApplication import ericApp

import Preferences

from TimeTracker.TimeTracker import TimeTracker

# Start-Of-Header
name = "Time Tracker Plugin"
author = "Detlev Offenbach <detlev@die-offenbachs.de>"
autoactivate = True
deactivateable = True
version = "1.0.1"
className = "TimeTrackerPlugin"
packageName = "TimeTracker"
shortDescription = "Time Tracker to keep track of the project time."
longDescription = (
    """This plug-in implements a time tracker to keep track"""
    """ of the time used for a project. The time can be subdivided"""
    """ into tasks."""
)
needsRestart = False
pyqtApi = 2
# End-Of-Header

error = ""

timeTrackerPluginObject = None
    

def createTimeTrackerPage(configDlg):
    """
    Module function to create the Time Tracker configuration page.
    
    @param configDlg reference to the configuration dialog
    @type ConfigurationWidget
    @return reference to the configuration page
    @rtype TimeTrackerPage
    """
    global timeTrackerPluginObject
    from TimeTracker.ConfigurationPage.TimeTrackerPage import TimeTrackerPage
    return TimeTrackerPage(timeTrackerPluginObject)


def getConfigData():
    """
    Module function returning data as required by the configuration dialog.
    
    @return dictionary containing the relevant data
    @rtype dict
    """
    usesDarkPalette = ericApp().usesDarkPalette()
    iconSuffix = "dark" if usesDarkPalette else "light"
    
    return {
        "timeTrackerPage": [
            QCoreApplication.translate("TimeTrackerPlugin",
                                       "Time Tracker"),
            os.path.join("TimeTracker", "icons",
                         "clock-{0}".format(iconSuffix)),
            createTimeTrackerPage, None, None],
    }


def prepareUninstall():
    """
    Module function to prepare for an uninstallation.
    """
    Preferences.Prefs.settings.remove(TimeTrackerPlugin.PreferencesKey)


class TimeTrackerPlugin(QObject):
    """
    Class implementing the Eric assistant plugin.
    """
    PreferencesKey = "TimeTracker"
    
    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.__defaults = {
            "MinimumDuration": 2,
            "AutoSave": False,
            "AllowDuplicates": False,
        }
        
        self.__translator = None
        self.__loadTranslator()
    
    def __initialize(self):
        """
        Private slot to (re)initialize the plugin.
        """
        self.__object = None
        
        self.__ericProject = ericApp().getObject("Project")
    
    def activate(self):
        """
        Public method to activate this plugin.
        
        @return tuple of None and activation status
        @rtype bool
        """
        global error
        error = ""     # clear previous error
        
        global timeTrackerPluginObject
        timeTrackerPluginObject = self
        
        usesDarkPalette = ericApp().usesDarkPalette()
        iconSuffix = "dark" if usesDarkPalette else "light"
        
        self.__object = TimeTracker(self, iconSuffix, self.__ui)
        self.__object.activate()
        ericApp().registerPluginObject("TimeTracker", self.__object)
        
        if self.__ericProject.isOpen():
            self.__object.projectOpened()
        
        self.__ericProject.newProject.connect(
            self.__object.projectOpened)
        self.__ericProject.projectOpened.connect(
            self.__object.projectOpened)
        self.__ericProject.projectClosed.connect(
            self.__object.projectClosed)
        
        return None, True
    
    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        ericApp().unregisterPluginObject("TimeTracker")
        self.__object.deactivate()
        
        self.__ericProject.newProject.disconnect(
            self.__object.projectOpened)
        self.__ericProject.projectOpened.disconnect(
            self.__object.projectOpened)
        self.__ericProject.projectClosed.disconnect(
            self.__object.projectClosed)
        
        self.__object.projectClosed()
        
        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__), "TimeTracker", "i18n")
                translation = "timetracker_{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 getPreferences(self, key):
        """
        Public method to retrieve the various settings.
        
        @param key key of the value to get
        @type str
        @return value of the requested setting
        @rtype Any
        """
        if key in ["MinimumDuration"]:
            return int(Preferences.Prefs.settings.value(
                self.PreferencesKey + "/" + key, self.__defaults[key]))
        elif key in ["AutoSave", "AllowDuplicates"]:
            return Preferences.toBool(
                Preferences.Prefs.settings.value(
                    self.PreferencesKey + "/" + key, self.__defaults[key]))
        else:
            return Preferences.Prefs.settings.value(
                self.PreferencesKey + "/" + key, self.__defaults[key])
    
    def setPreferences(self, key, value):
        """
        Public method to store the various settings.
        
        @param key key of the setting to be set
        @type str
        @param value value to be set
        @type Any
        """
        Preferences.Prefs.settings.setValue(
            self.PreferencesKey + "/" + key, value)

#
# eflag: noqa = M801