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

    """

    19

    """

    20

    21

    def iter_config_files (self) :

    22

        """

    23

            Iterate over the possible config files for this dir

    24

        """

    25

    26

        yield self.subfile('degal.cfg')

    27

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

    28

    29

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

    30

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

    31

    32

        # find config

    33

        for file in self.iter_config_files() :

    34

            if file.exists() :

    35

                # yay! More configuration!

    36

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

    37

    38

                break

    39

    41

        if self.config and self.config.title :

    43

            self.title = self.config.title

    44

    45

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

    46

            # XXX: figure out a better way of doing this

    47

            self.config.title = None

    48

    49

    @lazy_load

    50

    def title (self) :

    51

        """

    53

        """

    54

    55

        # default

    56

        return self.name.title()

    57

    58

    @lazy_load

    59

    def description (self) :

    60

        """

    61

            Find the descriptive text for this dir

    62

        """

    63

    64

        # default

    65

        return None

    66

    67

    @lazy_load

    68

    def preview_dir (self) :

    69

        """

    71

        """

    72

    73

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

    74

    75

    @lazy_load

    76

    def thumb_dir (self) :

    77

        """

    79

        """

    80

    81

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

    82

    83

    @lazy_load_iter

    84

    def subnodes (self) :

    85

        """

    86

            Load and return an ordered list of child-Nodes

    87

        """

    88

    89

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

    90

    91

    @lazy_load_iter

    92

    def subfolders (self) :

    93

        """

    94

            Load and return an ordered list of sub-Folders

    95

        """

    96

    97

        # filter out valid subfolders

    98

        for node in self.subnodes :

    99

            # skip non-dirs

   100

            if not node.is_dir() :

   101

                continue

   102

   103

            # skip the previews/thumbs dirs

   104

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

   105

                continue

   106

   107

            # ok

   108

            yield Folder(node)

   109

   110

    @lazy_load_iter

   111

    def images (self) :

   112

        """

   113

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

   114

        """

   115

   116

        prev = None

   117

   118

        for node in self.subnodes :

   119

            # skip non-relevant ones

   120

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

   121

                continue

   122

   123

            # create new

   124

            img = image.Image(node)

   125

   126

            # link up

   127

            if prev :

   128

                img.prev = prev

   129

                prev.next = img

   130

   131

                # yield the linked-up prev

   132

                yield prev

   133

   134

            # continue

   135

            prev = img

   136

   137

        # and the last one

   138

        if prev :

   139

            yield prev

   140

   141

    @lazy_load

   142

    def empty (self) :

   143

        """

   144

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

   145

   146

            This is implemented recursively.

   147

        """

   148

   149

        # simple logic, my dear friend Watson

   150

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

   151

   152

    @property

   153

    def page_count (self) :

   154

        """

   155

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

   156

        """

   157

   158

        if self.images :

   159

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

   160

   161

        elif self.subfolders :

   162

            # paginate these?

   163

            return 1

   164

   165

        else :

   166

            # nothing to render, really

   167

            return 0

   168

   169

    def images_for_page (self, page) :

   170

        """

   171

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

   172

        """

   173

   174

        # offset to first image

   175

        offset = page * self.config.images_per_page

   176

   177

        # slice

   178

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

   179

   180

    @property

   181

    def html (self) :

   182

        """

   183

            Path to default page

   184

        """

   185

   186

        return self.html_page()

   187

   188

    def html_page (self, page=0) :

   189

        """

   190

            Returns the File representing the .html for the given page

   191

        """

   192

   193

        if page :

   194

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

   195

   196

        else :

   197

            return self.subfile("index.html")

   198

   199

    def index_images (self, for_update=True) :

   200

        """

   201

            Return a series of Images inside of this folder.

   202

   203

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

   204

        """

   205

   206

        for image in self.images :

   207

            if for_update and not image.stale() :

   208

                # skip 

   209

                continue

   210

   211

            yield image

   212