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 iter_config_files (self) :

    17

        """

    18

            Iterate over the possible config files for this dir

    19

        """

    20

    21

        yield self.subfile('degal.cfg')

    22

        yield self.subdir('.degal').subfile('cfg')

    23

    24

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

    25

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

    26

    27

        # find config

    28

        for file in self.iter_config_files() :

    29

            if file.exists() :

    30

                # yay! More configuration!

    31

                self.config = self.config.load(file.path)

    32

    33

                break

    34

    35

        # load some info from title?

    36

        if self.config and self.config.title :

    37

            self.title = self.config.title

    38

    39

            # disable it so it won't be used by children

    40

            # XXX: figure out a better way of doing this

    41

            self.config.title = None

    42

    43

    @lazy_load

    44

    def title (self) :

    45

        """

    46

            Find the title for this dir

    47

        """

    48

    49

        # default

    50

        return self.name.title()

    51

    52

    @lazy_load

    53

    def description (self) :

    54

        """

    55

            Find the descriptive text for this dir

    56

        """

    57

    58

        # default

    59

        return None

    60

    61

    @lazy_load

    62

    def preview_dir (self) :

    63

        """

    64

            Load and return the Directory for previews

    65

        """

    66

    67

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

    68

    69

    @lazy_load

    70

    def thumb_dir (self) :

    71

        """

    72

            Load and return the Directory for thumbs

    73

        """

    74

    75

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

    76

    77

    @lazy_load_iter

    78

    def subnodes (self) :

    79

        """

    80

            Load and return an ordered list of child-Nodes

    81

        """

    82

    83

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

    84

    85

    @lazy_load_iter

    86

    def subfolders (self) :

    87

        """

    88

            Load and return an ordered list of sub-Folders

    89

        """

    90

    91

        # filter out valid subfolders

    92

        for node in self.subnodes :

    93

            # skip non-dirs

    94

            if not node.is_dir() :

    95

                continue

    96

    97

            # skip the previews/thumbs dirs

    98

            if node.name in (self.config.preview_dir, self.config.thumb_dir) :

    99

                continue

   100

   101

            # ok

   102

            yield Folder(node)

   103

   104

    @lazy_load_iter

   105

    def images (self) :

   106

        """

   107

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

   108

        """

   109

   110

        prev = None

   111

   112

        for node in self.subnodes :

   113

            # skip non-relevant ones

   114

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

   115

                continue

   116

   117

            # create new

   118

            img = image.Image(node)

   119

   120

            # link up

   121

            if prev :

   122

                img.prev = prev

   123

                prev.next = img

   124

   125

                # yield the linked-up prev

   126

                yield prev

   127

   128

            # continue

   129

            prev = img

   130

   131

        # and the last one

   132

        if prev :

   133

            yield prev

   134

   135

    @property

   136

    def page_count (self) :

   137

        """

   139

        """

   147

   151

   152

    def images_for_page (self, page) :

   153

        """

   154

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

   155

        """

   156

   157

        # offset to first image

   158

        offset = page * self.config.images_per_page

   159

   160

        # slice

   161

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

   162

   163

    @property

   164

    def html (self) :

   165

        """

   166

            Path to default page

   167

        """

   168

   169

        return self.html_page()

   170

   171

    def html_page (self, page=0) :

   172

        """

   173

            Returns the File representing the .html for the given page

   174

        """

   175

   176

        if page :

   177

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

   178

   179

        else :

   180

            return self.subfile("index.html")

   181

   182

    def index_images (self, for_update=True) :

   183

        """

   184

            Return a series of Images inside of this folder.

   185

   186

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

   187

        """

   188

   189

        for image in self.images :

   190

            if for_update and not image.stale() :

   191

                # skip 

   192

                continue

   193

   194

            yield image

   195