1

"""

     2

    Per-directory gallery state

     3

"""

     4

     5

import filesystem, image, html

     6

     7

from utils import lazy_load, lazy_load_iter

     8

     9

import math

    10

    11

class Folder (filesystem.Directory) :

    12

    """

    13

        A Folder is a filesystem Directory that contains any number of other Folders and Images.

    14

    """

    15

    16

    def __init__ (self, *args, **kwargs) :

    17

        super(Folder, self).__init__(*args, **kwargs)

    18

    19

        # info

    20

        self.title = None

    21

        self.description = None

    22

    23

    @lazy_load

    24

    def preview_dir (self) :

    25

        """

    26

            Load and return the Directory for previews

    27

        """

    28

    29

        return self.subdir(self.config.preview_dir, create=True)

    30

    31

    @lazy_load

    32

    def thumb_dir (self) :

    33

        """

    34

            Load and return the Directory for thumbs

    35

        """

    36

    37

        return self.subdir(self.config.thumb_dir, create=True)

    38

    39

    @lazy_load_iter

    40

    def subnodes (self) :

    41

        """

    42

            Load and return an ordered list of child-Nodes

    43

        """

    44

    45

        return super(Folder, self).subnodes(skip_dotfiles=True, sort=True)

    46

    47

    @lazy_load_iter

    48

    def subfolders (self) :

    49

        """

    50

            Load and return an ordered list of sub-Folders

    51

        """

    52

    53

        return (Folder(node) for node in self.subnodes if isinstance(node, filesystem.Directory))

    54

    55

    @lazy_load_iter

    56

    def images (self) :

    57

        """

    58

            Load and return an ordered/linked list of sub-Images

    59

        """

    60

    61

        prev = None

    62

    63

        for node in self.subnodes :

    64

            # skip non-relevant ones

    65

            # XXX: node should need to be a File

    66

            if not node.is_file() or not self.config.is_image(filesystem.File(node)) :

    67

                continue

    68

    69

            # create new

    70

            img = image.Image(node)

    71

    72

            # link up

    73

            if prev :

    74

                img.prev = prev

    75

                prev.next = img

    76

    77

                # yield the linked-up prev

    78

                yield prev

    79

    80

            # continue

    81

            prev = img

    82

    83

        # and the last one

    84

        if prev :

    85

            yield prev

    86

    87

    @property

    88

    def page_count (self) :

    89

        """

    90

            Returns the number of pages needed to show this folder's images

    91

        """

    92

    93

        return int(math.ceil(len(self.images) / float(self.config.images_per_page)))

    94

    95

    def images_for_page (self, page) :

    96

        """

    97

            Returns the list of Images to be displayed for the given page, if any

    98

        """

    99

   100

        # offset to first image

   101

        offset = page * self.config.images_per_page

   102

   103

        # slice

   104

        return self.images[offset : offset + self.config.images_per_page]

   105

   106

    def html_file (self, page=0) :

   107

        """

   108

            Returns the File representing the .html for the given page

   109

        """

   110

   111

        if page :

   112

            return self.subfile("index_%d.html" % page)

   113

   114

        else :

   115

            return self.subfile("index.html")

   116

   117

    def index_images (self, for_update=True) :

   118

        """

   119

            Return a series of Images inside of this folder.

   120

   121

            If `for_update` is given, only images that are stale will be returned.

   122

        """

   123

   124

        for image in self.images :

   125

            if for_update and not image.stale() :

   126

                # skip 

   127

                continue

   128

   129

            yield image

   130