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.

    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

    24

    25

            XXX: abstract this

    26

        """

    27

    28

        yield self.subfile('degal.cfg')

    37

    38

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

    39

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

    45

        for file in self.iter_config_files() :

    46

            if file.exists() :

    47

                # yay! More configuration!

    48

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

    49

    50

                break

    51

    52

        # load some info for title?

    53

        if self.config and self.config.title :

    54

            # override our default title

    55

            self.title = self.config.title

    56

    57

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

    58

            # XXX: figure out a better way of doing this

    59

            self.config.title = None

    61

    @lazy_load

    62

    def title (self) :

    63

        """

    64

            Find the default title for this dir.

    65

        """

    66

    67

        # default

    68

        return self.name.title()

    69

    70

    @lazy_load

    71

    def description (self) :

    72

        """

    73

            Find the descriptive text for this dir

    74

        """

    75

    76

        # default

    77

        return None

    78

    79

    @lazy_load

    80

    def preview_dir (self) :

    81

        """

    82

            Load and return the Directory used for for preview Thumbnails

    83

        """

    84

    85

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

    86

    87

    @lazy_load

    88

    def thumb_dir (self) :

    89

        """

    90

            Load and return the Directory used for thumb Thumbnails

    91

        """

    92

    93

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

    94

    95

    @lazy_load_iter

    96

    def subnodes (self) :

    97

        """

    98

            Load and return an ordered list of child-Nodes

    99

        """

   100

   101

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

   102

   103

    @lazy_load_iter

   104

    def subfolders (self) :

   105

        """

   106

            Load and return an ordered list of sub-Folders

   107

        """

   108

   109

        # filter out valid subfolders

   110

        for node in self.subnodes :

   111

            # skip non-dirs

   112

            if not node.is_dir() :

   113

                continue

   114

   115

            # skip the previews/thumbs dirs

   116

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

   117

                continue

   118

   119

            # ok

   120

            yield Folder(node)

   121

   122

    @lazy_load_iter

   123

    def images (self) :

   124

        """

   125

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

   126

        """

   127

   128

        prev = None

   129

   130

        for node in self.subnodes :

   131

            # skip non-relevant ones

   132

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

   133

                continue

   134

   135

            # create new

   136

            img = image.Image(node)

   137

   138

            # link up

   139

            if prev :

   140

                img.prev = prev

   141

                prev.next = img

   142

   143

                # yield the linked-up prev

   144

                yield prev

   145

   146

            # continue

   147

            prev = img

   148

   149

        # and the last one

   150

        if prev :

   151

            yield prev

   152

   153

    @lazy_load

   154

    def empty (self) :

   155

        """

   156

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

   157

   158

            This is implemented recursively.

   159

        """

   160

   161

        # simple logic, my dear friend Watson

   162

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

   163

   164

    @property

   165

    def page_count (self) :

   166

        """

   167

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

   168

        """

   169

   170

        if self.images :

   171

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

   172

   173

        elif self.subfolders :

   174

            # paginate these?

   175

            return 1

   176

   177

        else :

   178

            # nothing to render, really

   179

            return 0

   180

   181

    def images_for_page (self, page) :

   182

        """

   183

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

   184

        """

   185

   186

        # offset to first image

   187

        offset = page * self.config.images_per_page

   188

   189

        # slice

   190

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

   191

   192

    @property

   193

    def html (self) :

   194

        """

   195

            Path to default page

   196

        """

   197

   198

        return self.html_page()

   199

   200

    def html_page (self, page=0) :

   201

        """

   202

            Returns the File representing the .html for the given page

   203

        """

   204

   205

        if page :

   206

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

   207

   208

        else :

   209

            return self.subfile("index.html")

   210

   211

    def index_images (self, for_update=True) :

   212

        """

   213

            Return a series of Images inside of this folder.

   214

   215

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

   216

        """

   217

   218

        for image in self.images :

   219

            if for_update and not image.stale() :

   220

                # skip 

   221

                continue

   222

   223

            yield image

   224