~flimm/epidermis/icon-theme-bugfix

from shell import SubprocessShell

import ep_exceptions

import handy

import const

from const import PIGMENT_TYPES

import managepigments

 

TEMP_DIR = "TEMP"

 

QUERY_OVERWRITE = 1

QUERY_OVERWRITE_DATA = 2

 

STATE_EMPTY = 0

STATE_INFO = 2

STATE_INSTALLED = 3

STATE_TEMP = 4

STATE_INCOMPLETE = 1

 

class PigmentType():

    """The class for the type of pigment, has the following

    attributes: humanName, humanPluralName, codeName, abbreviation,

    directoryName

    humanName = {"en":""}

    humanPluralName = {"en":""}

    codeName = ""

    

    @staticmethod

    def get_Pigment():

    

    @classmethod

    def does_system_support_me(klass):

 

 

 

    def __init__(self):

        """Initilises Psigment object, including the humanName, codeName, copyright,

        author, authorContact, description, preview, listStore,

        # TODO: add version

        self.humanName = {"en":""}

        self.codeName = "" #: moohoo

    

    def set_human_name(self, humanName, language="en"):

        """Set a human name for this pigment in specified language,

        if len(language) == 0:

            language = "en"

        self.humanName[language] = humanName

    

    def set_description(self, description, language="en"):

        """Set a human readable description for this pigment in specified language,

        self.description[language] = description

    

    def get_description(self, language="en"):

        """Get the human readable description for this pigment in specified

        return self.description[language]

    

    def add_attachment(self, attachment):

        """Add a file or a directory that may be needed for the installation

        and activation of the pigment. When saved, the file or directory will

        be found under data in the pigment compressed archive.

        Please note that the order of attachments cannot be relied upon.

        Use this function instead of appending to self.attachments directly.

        If attachment is not an absolute path, the pigment will look for it

        if not os.path.exists(attachment):

            raise(ep_exceptions.AttachmentNotFoundException(attachment, pigment=self))

        self.attachments.append(attachment)

    

    

    def get_state(self):

        these constants:

        STATE_EMPTY: this is the state that the pigment initializes in

        STATE_INFO: the pigment only contains essential meta-data, for example, pigments

            viewed in the repo browser are in this state, no attachments

        STATE_TEMP: the pigment has been extracted to a temporary directory,

            including attachments

        STATE_INCOMPLETE: the pigment doesn't contain enough meta-data to qualify

        # check to see if pigment's essential meta-data is completed

        # only skins are excluded from the preview check

        if self.humanName != {"en":""} and \

    

    def set_preview_file(self, filename):

        """Set the preview file. If an absolute path is given, the

        if os.path.isabs(os.path.expanduser(filename)):

            if not os.path.exists(filename):

                raise(ep_exceptions.PreviewFileNotFoundException(filename))

            self.preview = None

    

    def _give_preview_file(self):

        If the preview filename hasn't been set, but a Pixbuf has, this

        subprocess.call(["mkdir", "-p", "/tmp/epidermis/preview"])

        if len(self.previewFilename) > 0 and len(self.previewPath) == 0:

            self.preview.save("/tmp/epidermis/preview" + self.previewFilename, self.previewFilename.split(".")[-1].lower())

            return self.previewPath

    

    def get_preview(self):

        if not self.preview is None:

            return self.preview

        elif len(self.previewPath) > 0:

            return None

    

    def generate_preview(self):

        Returning None means the method was not successful, otherwise, the method will return

    

    def _extract_in_temp(self, filePath, shell=None):

        Returns the directory where the pigment has been extracted to.

        if not os.path.exists(filePath):

            raise(ep_exceptions.FileNotFoundException(filePath))

        if shell is None:

        return mytmp

    

    def _rearrange_temp(self, dir, shell=None):

        If any attachments are in /tmp, they're moved and re-added to attachments using self.add_attachment

        Sets self.installationDirectory to /tmp/epidermis/pigments/

        if shell is None:

            shell = SubprocessShell()

            shell.prepare()

 

    

    def install(self, installationDirectory, progressCallback=None, shell=None):

        and copies the data to the appropriate place.

        

        # use subprocess shell if not specified

        if shell is None:

            

    

    def remove(self, progressCallback=None, shell=None):

        # use subprocess shell if not specified

        if shell is None:

            shell = SubprocessShell()

        progressCallback(1.0)

    

    def activate(self, progressCallback=None, shell=None):

    

    def save(self, filePath, shell=None):

        # TODO: save needs to be more easily 'sub-classed'

        # for example, the gtk_ pigment saves with it metacity

        doc = self.information_xml()

    

    def read(self, filePath):

        """Load the Pigment object from an xml file (.xml)

        This function will look for the preview file and for attachments, if required

        NOTE: this function will look for attachments in places other than filePath, 

        if not os.path.exists(filePath):

            raise(ep_exceptions.FileNotFoundException(filePath))

        doc = minidom.parse(filePath)

    

    def write(self, filePath, shell=None):

        """Write the XML file to filePath

        # TODO: fixme ? write doesn't save preview

        subprocess.call(["rm", "/tmp/epidermis/pigment.xml"])

        subprocess.call(["mkdir", "-p", "/tmp/epidermis"])

        shell.do(["mv", "/tmp/epidermis/pigment.xml", filePath])

    

    def information_xml(self):

        doc = minidom.Document()

        root = doc.createElement("pigment")

        doc.appendChild(root)

    def is_attachment_correct(self, attachmentIndex=None):

        """Return whether the attachment number attachmentIndex or all the attachments

        if None is passed are correct.

        For example, a Metacity pigment would verify that the attachment is a

        directory with a metacity-1 subdirectory

        if attachmentIndex is None:

            for att in self.attachments:

                if not os.path.exists(att):

##        return

    

    def summary(self):

        return "Pigment codename: " + self.codeName \

            + "\nhumanName: " + str(self.humanName) \

            + "\ncopyright: " + self.copyright \

##        return

    

    def does_activation_require_root(self):

        If it does, the Pigment object will need a Shell running as root

    

    def does_uninstallation_require_root(self):

        If it does, the Pigment object will need a Shell running as root

        # TODO: check permissions of files and attachments to determine

        # whether uninstallation requires root

        return True

    

    def match_filter(self, matchString, lang="en"):

        for ii in (self.get_human_name(lang), self.get_description(lang)):

            if matchString.lower() in ii.lower():

                return True

        return False