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:

    14

            * has a title/description (XXX: Page)

    15

            * contains any number of other sub-Folders and Images.

    16

            * can load custom configuration for itself and sub-nodes to override the base config

    17

            * holds sub-dirs for previews/thumbs

    18

            * has a HTML view

    19

    """

    20

    21

    def iter_config_files (self) :

    22

        """

    23

            Iterate over the possible config files for this dir

    26

        """

    27

    28

        yield self.subfile('degal.cfg')

    29

    30

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

    31

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

    32

    33

        # find config

    34

        for file in self.iter_config_files() :

    35

            if file.exists() :

    36

                # yay! More configuration!

    37

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

    38

    39

                break

    40

    41

        # load some info for title?

    42

        if self.config and self.config.title :

    43

            # override our default title

    44

            self.title = self.config.title

    45

    46

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

    47

            # XXX: figure out a better way of doing this

    48

            self.config.title = None

    49

    50

    @lazy_load

    51

    def title (self) :

    52

        """

    53

            Find the default title for this dir.

    54

        """

    55

    56

        # default

    57

        return self.name.title()

    58

    59

    @lazy_load

    60

    def description (self) :

    61

        """

    62

            Find the descriptive text for this dir

    63

        """

    64

    65

        # default

    66

        return None

    67

    68

    @lazy_load

    69

    def preview_dir (self) :

    70

        """

    71

            Load and return the Directory used for for preview Thumbnails

    72

        """

    73

    74

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

    75

    76

    @lazy_load

    77

    def thumb_dir (self) :

    78

        """

    79

            Load and return the Directory used for thumb Thumbnails

    80

        """

    81

    82

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

    83

    84

    @lazy_load_iter

    85

    def subnodes (self) :

    86

        """

    87

            Load and return an ordered list of child-Nodes

    88

        """

    89

    90

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

    91

    92

    @lazy_load_iter

    93

    def subfolders (self) :

    94

        """

    95

            Load and return an ordered list of sub-Folders

    96

        """

    97

    98

        # filter out valid subfolders

    99

        for node in self.subnodes :

   100

            # skip non-dirs

   101

            if not node.is_dir() :

   102

                continue

   103

   104

            # skip the previews/thumbs dirs

   105

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

   106

                continue

   107

   108

            # ok

   109

            yield Folder(node)

   110

   111

    @lazy_load_iter

   112

    def images (self) :

   113

        """

   114

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

   115

        """

   116

   117

        prev = None

   118

   119

        for node in self.subnodes :

   120

            # skip non-relevant ones

   121

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

   122

                continue

   123

   124

            # create new

   125

            img = image.Image(node)

   126

   127

            # link up

   128

            if prev :

   129

                img.prev = prev

   130

                prev.next = img

   131

   132

                # yield the linked-up prev

   133

                yield prev

   134

   135

            # continue

   136

            prev = img

   137

   138

        # and the last one

   139

        if prev :

   140

            yield prev

   141

   142

    @lazy_load

   143

    def empty (self) :

   144

        """

   145

            A Folder is empty if it does not contain any Images, and all of its sub-Folders (if any) are also empty.

   146

   147

            This is implemented recursively.

   148

        """

   149

   150

        # simple logic, my dear friend Watson

   151

        return not self.images and all(subfolder.empty for subfolder in self.subfolders)

   152

   153

    @property

   154

    def page_count (self) :

   155

        """

   156

            Returns the number of pages needed to show this folder's images or subfolders. May be zero, one or more.

   157

        """

   158

   159

        if self.images :

   160

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

   161

   162

        elif self.subfolders :

   163

            # paginate these?

   164

            return 1

   165

   166

        else :

   167

            # nothing to render, really

   168

            return 0

   169

   170

    def images_for_page (self, page) :

   171

        """

   172

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

   173

        """

   174

   175

        # offset to first image

   176

        offset = page * self.config.images_per_page

   177

   178

        # slice

   179

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

   180

   181

    @property

   182

    def html (self) :

   183

        """

   184

            Path to default page

   185

        """

   186

   187

        return self.html_page()

   188

   189

    def html_page (self, page=0) :

   190

        """

   191

            Returns the File representing the .html for the given page

   192

        """

   193

   194

        if page :

   195

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

   196

   197

        else :

   198

            return self.subfile("index.html")

   199

   200

    def index_images (self, for_update=True) :

   201

        """

   202

            Return a series of Images inside of this folder.

   203

   204

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

   205

        """

   206

   207

        for image in self.images :

   208

            if for_update and not image.stale() :

   209

                # skip 

   210

                continue

   211

   212

            yield image

   213