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

def isImage (fname) :

    39

    """

    40

        Is the given filename likely to be an image file?

    41

    """

    42

    43

    fname = fname.lower()

    44

    base, ext = os.path.splitext(fname)

    45

    ext = ext.lstrip('.')

    46

    47

    return ext in settings.IMAGE_EXTS

    48

    49

class Folder (object) :

    50

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

    51

        # the directory name, no trailing /

    52

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

    53

    54

        # our parent Folder, or None

    55

        self.parent = parent

    56

    57

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

    58

        if parent and name :

    59

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

    60

        else :

    61

            self.path = self.name

    62

    63

        # the url-path to the index.html file

    64

        self.html_path = self.path

    65

    66

        # dict of fname -> Folder

    67

        self.subdirs = {}

    68

    69

        # dict of fname -> Image

    70

        self.images = {}

    71

    72

        # our human-friendly title

    73

        self.title = None

    74

    75

        # our long-winded description

    76

        self.descr = ''

    77

    78

        # is this folder non-empty?

    79

        self.alive = None

    80

    81

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

    82

        self.sorted_images = []

    83

    84

        # the ShortURL key to this dir

    85

        self.shorturl_code = None

    86

    87

        # were we filtered out?

    88

        self.filtered = False

    89

    90

    def pathFor (self, *fnames) :

    91

        """

    92

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

    93

        """

    94

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

    95

    96

    def index (self, filters=None) :

    97

        """

    98

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

    99

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

   100

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

   101

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

   102

            method.

   103

        """

   104

   105

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

   106

   107

        if filters :

   108

            self.filtered = True

   109

   110

        # iterate through listdir

   111

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

   112

            # the full filesystem path to it

   113

            fpath = self.pathFor(fname)

   114

   115

            # ignore dotfiles

   116

            if fname.startswith('.') :

   117

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

   118

                continue

   119

   120

            # apply filters

   121

            if filters :

   122

                if fname in filters :

   123

                    next_filter = filters[fname]

   124

                else :

   125

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

   126

                    continue

   127

            else :

   128

                next_filter = None

   129

   130

            # recurse into subdirs, but not thumbs/previews

   131

            if (os.path.isdir(fpath) 

   132

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

   133

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

   134

            ) :

   135

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

   136

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

   137

                if f.index(next_filter) :   # recursion

   138

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

   139

                    self.alive = True

   140

   141

            # handle images

   142

            elif os.path.isfile(fpath) and isImage(fname) :

   143

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

   144

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

   145

   146

            # ignore everything else

   147

            else :

   148

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

   149

   150

        # sort and link the images

   151

        if self.images :

   152

            self.alive = True

   153

   154

            # sort the images

   155

            fnames = self.images.keys()

   156

            fnames.sort()

   157

   158

            prev = None

   159

   160

            # link

   161

            for fname in fnames :

   162

                img = self.images[fname]

   163

   164

                img.prev = prev

   165

   166

                if prev :

   167

                    prev.next = img

   168

   169

                prev = img

   170

   171

                # add to the sorted images list

   172

                self.sorted_images.append(img)

   173

   174

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

   175

            title_path = self.pathFor(settings.TITLE_FILE)

   176

   177

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

   178

   179

            # default title for the root dir

   180

            if self.title :

   181

                self.alive = True

   182

                pass # use what was in the title file

   183

   184

            elif not self.parent :

   185

                self.title = 'Index'

   186

   187

            else :

   188

                self.title = self.name

   189

   190

            if self.descr :

   191

                self.alive = True

   192

   193

        return self.alive

   194

   195

    def getObjInfo (self) :

   196

        """

   197

            Metadata for shorturls2.db

   198

        """

   199

        return 'dir', self.path, ''

   200

   201

    def breadcrumb (self, forImg=None) :

   202

        """

   203

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

   204

        """

   205

   206

        f = self

   207

        b = []

   208

        d = 0

   209

   210

        while f :

   211

            # functionality of the slightly-hacked-in variety

   212

            if f is self and forImg is not None :

   213

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

   214

            else :

   215

                url = dirUp(d)

   216

   217

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

   218

   219

            d += 1

   220

            f = f.parent

   221

   222

        return b

   223

   224

    def getPageNumber (self, img) :

   225

        """

   226

            Get the page number that the given image is on

   227

        """

   228

   229

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

   230

   231

    def countParents (self, acc=0) :

   232

        if self.parent :

   233

            return self.parent.countParents(acc+1)

   234

        else :

   235

            return acc

   236

   237

    def inRoot (self, *fnames) :

   238

        """

   239

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

   240

        """

   241

   242

        c = self.countParents()

   243

   244

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

   245

   246

    def render (self) :

   247

        """

   248

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

   249

        """

   250

   251

        # ded folders are skipped

   252

        if not self.alive :

   253

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

   254

            return

   255

   256

        # 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

   257

        if self.filtered :

   258

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

   259

   260

        else :  

   261

            # create the thumb/preview dirs if needed

   262

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

   263

                path = self.pathFor(dir)

   264

   265

                if not os.path.isdir(path) :

   266

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

   267

                    os.mkdir(path)

   268

   269

            # sort the subdirs

   270

            subdirs = self.subdirs.values()

   271

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

   272

   273

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

   274

   275

            # paginate!

   276

            images = self.sorted_images

   277

            image_count = len(images)

   278

            pages = []

   279

   280

            while images :

   281

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

   282

                images = images[settings.IMAGE_COUNT:]

   283

   284

            pagination_required = len(pages) > 1

   285

   286

            if pagination_required :

   287

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

   288

   289

            for cur_page, images in enumerate(pages) :

   290

                if pagination_required and cur_page > 0 :

   291

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

   292

                else :

   293

                    shorturl = self.shorturl_code

   294

   295

                # render to index.html

   296

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

   297

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

   298

                    title                        = self.title,

   299

                    breadcrumb                   = self.breadcrumb(),

   300

   301

                    dirs                         = subdirs,

   302

                    images                       = images,

   303

   304

                    num_pages                    = len(pages),

   305

                    cur_page                     = cur_page,

   306

   307

                    description                  = self.descr,

   308

   309

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

   310

                    shorturl_code                = shorturl,

   311

                )

   312

   313

        # render images

   314

        for img in self.images.itervalues() :

   315

            img.render()

   316

   317

        # recurse into subdirs

   318

        for dir in self.subdirs.itervalues() :

   319

            dir.render()

   320