1

# DeGAL - A pretty simple web image gallery

     2

# Copyright (C) 2007 Tero Marttila

     3

# http://marttila.de/~terom/degal/

     4

#

     5

# This program is free software; you can redistribute it and/or modify

     6

# it under the terms of the GNU General Public License as published by

     7

# the Free Software Foundation; either version 2 of the License, or

     8

# (at your option) any later version.

     9

#

    10

# This program is distributed in the hope that it will be useful,

    11

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    12

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13

# GNU General Public License for more details.

    14

#

    15

# You should have received a copy of the GNU General Public License

    16

# along with this program; if not, write to the

    17

# Free Software Foundation, Inc.,

    18

# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

#

    20

    21

import os, os.path

    22

    23

import settings, image, utils, helpers

    24

from log import index, render

    25

from template import gallery as gallery_tpl

    26

from helpers import url_for_page

    27

    28

def dirUp (count=1) :

    29

    """

    30

        Returns a relative path to the directly count levels above the current one

    31

    """

    32

    33

    if not count :

    34

        return '.'

    35

    36

    return os.path.join(*(['..']*count))

    37

    38

class Folder (object) :

    39

    def __init__ (self, name='.', parent=None) :

    40

        # the directory name, no trailing /

    41

        self.name = name.rstrip(os.sep)

    42

    43

        # our parent Folder, or None

    44

        self.parent = parent

    45

    46

        # the path to this dir, as a relative path to the root of the image gallery, always starts with .

    47

        if parent and name :

    48

            self.path = parent.pathFor(self.name)

    49

        else :

    50

            self.path = self.name

    51

    52

        # the url-path to the index.html file

    53

        self.html_path = self.path

    54

    55

        # dict of fname -> Folder

    56

        self.subdirs = {}

    57

    58

        # dict of fname -> Image

    59

        self.images = {}

    60

    61

        # our human-friendly title

    62

        self.title = None

    63

    64

        # our long-winded description

    65

        self.descr = ''

    66

    67

        # is this folder non-empty?

    68

        self.alive = None

    69

    70

        # self.images.values(), but sorted by filename

    71

        self.sorted_images = []

    72

    73

        # the ShortURL key to this dir

    74

        self.shorturl_code = None

    75

    76

        # were we filtered out?

    77

        self.filtered = False

    78

    79

    def pathFor (self, *fnames) :

    80

        """

    81

            Return a root-relative path to the given path inside this dir

    82

        """

    83

        return os.path.join(self.path, *fnames)

    84

    85

    def index (self, filters=None) :

    86

        """

    87

            Look for other dirs and images inside this dir. Filters must be either None,

    88

            whereupon all files will be included, or a dict of {filename -> next_filter}.

    89

            If given, only filenames that are present in the dict will be indexed, and in

    90

            the case of dirs, the next_filter will be passed on to that Folder's index

    91

            method.

    92

        """

    93

    94

        index.info("Indexing %s", self.path)

    95

    96

        if filters :

    97

            self.filtered = True

    98

    99

        # iterate through listdir

   100

        for fname in os.listdir(self.path) :

   101

            # the full filesystem path to it

   102

            fpath = self.pathFor(fname)

   103

   104

            # ignore dotfiles

   105

            if fname.startswith('.') :

   106

                index.debug("Skipping dotfile %s", fname)

   107

                continue

   108

   109

            # apply filters

   110

            if filters :

   111

                if fname in filters :

   112

                    next_filter = filters[fname]

   113

                else :

   114

                    index.debug("Skip `%s' as we have a filter", fname)

   115

                    continue

   116

            else :

   117

                next_filter = None

   118

   119

            # recurse into subdirs, but not thumbs/previews

   120

            if (os.path.isdir(fpath) 

   121

                and (fname not in (settings.THUMB_DIR, settings.PREVIEW_DIR))

   122

                and (self.parent or fname not in settings.ROOT_IGNORE)

   123

            ) :

   124

                index.debug("Found subdir %s", fpath)

   125

                f = self.subdirs[fname] = Folder(fname, self)

   126

                if f.index(next_filter) :   # recursion

   127

                    # if a subdir is alive, we are alive as well

   128

                    self.alive = True

   129

   130

            # handle images

   132

                index.debug("Found image %s", fname)

   133

                self.images[fname] = image.Image(self, fname)

   134

   135

            # ignore everything else

   136

            else :

   137

                index.debug("Ignoring file %s", fname)

   138

   139

        # sort and link the images

   140

        if self.images :

   141

            self.alive = True

   142

   143

            # sort the images

   144

            fnames = self.images.keys()

   145

            fnames.sort()

   146

   147

            prev = None

   148

   149

            # link

   150

            for fname in fnames :

   151

                img = self.images[fname]

   152

   153

                img.prev = prev

   154

   155

                if prev :

   156

                    prev.next = img

   157

   158

                prev = img

   159

   160

                # add to the sorted images list

   161

                self.sorted_images.append(img)

   162

   163

            # figure out our title/ descr. Must be done before our parent dir is rendered (self.title)

   164

            title_path = self.pathFor(settings.TITLE_FILE)

   165

   166

            self.title, self.descr = utils.readTitleDescr(title_path)

   167

   168

            # default title for the root dir

   169

            if self.title :

   170

                self.alive = True

   171

                pass # use what was in the title file

   172

   173

            elif not self.parent :

   174

                self.title = 'Index'

   175

   176

            else :

   177

                self.title = self.name

   178

   179

            if self.descr :

   180

                self.alive = True

   181

   182

        return self.alive

   183

   184

    def getObjInfo (self) :

   185

        """

   186

            Metadata for shorturls2.db

   187

        """

   188

        return 'dir', self.path, ''

   189

   190

    def breadcrumb (self, forImg=None) :

   191

        """

   192

            Returns a [(fname, title)] list of this dir's parent dirs

   193

        """

   194

   195

        f = self

   196

        b = []

   197

        d = 0

   198

   199

        while f :

   200

            # functionality of the slightly-hacked-in variety

   201

            if f is self and forImg is not None :

   202

                url = helpers.url_for_page(self.getPageNumber(forImg))

   203

            else :

   204

                url = dirUp(d)

   205

   206

            b.insert(0, (url, f.title))

   207

   208

            d += 1

   209

            f = f.parent

   210

   211

        return b

   212

   213

    def getPageNumber (self, img) :

   214

        """

   215

            Get the page number that the given image is on

   216

        """

   217

   218

        return self.sorted_images.index(img) // settings.IMAGE_COUNT

   219

   220

    def countParents (self, acc=0) :

   221

        if self.parent :

   222

            return self.parent.countParents(acc+1)

   223

        else :

   224

            return acc

   225

   226

    def inRoot (self, *fnames) :

   227

        """

   228

            Return a relative URL from this dir to the given path in the root dir

   229

        """

   230

   231

        c = self.countParents()

   232

   233

        return utils.url_join(*((['..']*c) + list(fnames)))

   234

   235

    def render (self) :

   236

        """

   237

            Render the index.html, Images, and recurse into subdirs

   238

        """

   239

   240

        # ded folders are skipped

   241

        if not self.alive :

   242

            render.info("Skipping dir %s (no images)", self.path)

   243

            return

   244

   245

        # if this dir's contents were filtered out, then we can't render the index.html, as we aren't aware of all the images in here

   246

        if self.filtered :

   247

            render.warning("Dir `%s' contents were filtered, so we won't render the gallery index again", self.path)

   248

   249

        else :  

   250

            # create the thumb/preview dirs if needed

   251

            for dir in (settings.THUMB_DIR, settings.PREVIEW_DIR) :

   252

                path = self.pathFor(dir)

   253

   254

                if not os.path.isdir(path) :

   255

                    render.info("Creating dir %s", path)

   256

                    os.mkdir(path)

   257

   258

            # sort the subdirs

   259

            subdirs = self.subdirs.values()

   260

            subdirs.sort(key=lambda d: d.name)

   261

   262

            render.info("Rendering %s", self.path)

   263

   264

            # paginate!

   265

            images = self.sorted_images

   266

            image_count = len(images)

   267

            pages = []

   268

   269

            while images :

   270

                pages.append(images[:settings.IMAGE_COUNT])

   271

                images = images[settings.IMAGE_COUNT:]

   272

   273

            pagination_required = len(pages) > 1

   274

   275

            if pagination_required :

   276

                render.info("Index split into %d pages of %d images each", len(pages), settings.IMAGE_COUNT)

   277

   278

            for cur_page, images in enumerate(pages) :

   279

                if pagination_required and cur_page > 0 :

   280

                    shorturl = "%s/%s" % (self.shorturl_code, cur_page+1)

   281

                else :

   282

                    shorturl = self.shorturl_code

   283

   284

                # render to index.html

   285

                gallery_tpl.render_to(self.pathFor(url_for_page(cur_page)), 

   286

                    stylesheet_url               = self.inRoot('style.css'),

   287

                    title                        = self.title,

   288

                    breadcrumb                   = self.breadcrumb(),

   289

   290

                    dirs                         = subdirs,

   291

                    images                       = images,

   292

   293

                    num_pages                    = len(pages),

   294

                    cur_page                     = cur_page,

   295

   296

                    description                  = self.descr,

   297

   298

                    shorturl                     = self.inRoot('s', shorturl),

   299

                    shorturl_code                = shorturl,

   300

                )

   301

   302

        # render images

   303

        for img in self.images.itervalues() :

   304

            img.render()

   305

   306

        # recurse into subdirs

   307

        for dir in self.subdirs.itervalues() :

   308

            dir.render()