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

    24

from template import gallery as gallery_tpl

    25

from helpers import url_for_page

    26

    27

def dirUp (count=1) :

    28

    """

    29

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

    30

    """

    31

    32

    if not count :

    33

        return '.'

    34

    35

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

    36

    37

class Folder (object) :

    38

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

    39

        # the directory name, no trailing /

    40

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

    41

    42

        # our parent Folder, or None

    43

        self.parent = parent

    44

    45

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

    46

        if parent and name :

    47

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

    48

        else :

    49

            self.path = self.name

    50

    51

        # the url-path to the index.html file

    52

        self.html_path = self.path

    53

    54

        # dict of fname -> Folder

    55

        self.subdirs = {}

    56

    57

        # dict of fname -> Image

    58

        self.images = {}

    59

    60

        # our human-friendly title

    61

        self.title = None

    62

    63

        # our long-winded description

    64

        self.descr = ''

    65

    66

        # is this folder non-empty?

    67

        self.alive = None

    68

    69

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

    70

        self.sorted_images = []

    71

    72

        # the ShortURL key to this dir

    73

        self.shorturl_code = None

    74

    75

        # were we filtered out?

    76

        self.filtered = False

    77

    78

    def pathFor (self, *fnames) :

    79

        """

    80

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

    81

        """

    82

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

    83

    84

    def index (self, filters=None) :

    85

        """

    86

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

    87

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

    88

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

    89

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

    90

            method.

    91

        """

    92

    93

        if filters :

    94

            self.filtered = True

    95

    96

        # iterate through listdir

    97

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

    98

            # the full filesystem path to it

    99

            fpath = self.pathFor(fname)

   100

   101

            # ignore dotfiles

   102

            if fname.startswith('.') :

   104

                continue

   105

   106

            # apply filters

   107

            if filters :

   108

                if fname in filters :

   109

                    next_filter = filters[fname]

   110

                else :

   112

                    continue

   113

            else :

   114

                next_filter = None

   115

   116

            # recurse into subdirs, but not thumbs/previews

   117

            if (os.path.isdir(fpath) 

   118

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

   119

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

   120

            ) :

   123

                f = Folder(fname, self)

   125

                if f.index(next_filter) :   # recursion

   126

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

   127

                    self.subdirs[fname] = f

   128

                    self.alive = True

   129

   132

            # handle images

   133

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

   135

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

   136

   137

            # ignore everything else

   138

            else :

   140

   141

        # sort and link the images

   142

        if self.images :

   143

            self.alive = True

   144

   145

            # sort the images

   146

            fnames = self.images.keys()

   147

            fnames.sort()

   148

   149

            prev = None

   150

   151

            # link

   152

            for fname in fnames :

   153

                img = self.images[fname]

   154

   155

                img.prev = prev

   156

   157

                if prev :

   158

                    prev.next = img

   159

   160

                prev = img

   161

   162

                # add to the sorted images list

   163

                self.sorted_images.append(img)

   164

   165

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

   166

        title_path = self.pathFor(settings.TITLE_FILE)

   167

   168

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

   169

   170

        # default title for the root dir

   171

        if self.title or self.descr :

   172

            self.alive = True

   173

            pass # use what was in the title file

   174

   175

        elif not self.parent :

   176

            self.title = 'Index'

   177

   178

        else :

   179

            self.title = self.name

   180

   181

        if not self.alive :

   183

   184

        return self.alive

   185

   186

    def getObjInfo (self) :

   187

        """

   188

            Metadata for shorturls2.db

   189

        """

   190

        return 'dir', self.path, ''

   191

   192

    def breadcrumb (self, forImg=None) :

   193

        """

   194

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

   195

        """

   196

   197

        f = self

   198

        b = []

   199

        d = 0

   200

   201

        while f :

   202

            # functionality of the slightly-hacked-in variety

   203

            if f is self and forImg is not None :

   204

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

   205

            else :

   206

                url = dirUp(d)

   207

   208

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

   209

   210

            d += 1

   211

            f = f.parent

   212

   213

        return b

   214

   215

    def getPageNumber (self, img) :

   216

        """

   217

            Get the page number that the given image is on

   218

        """

   219

   220

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

   221

   222

    def countParents (self, acc=0) :

   223

        if self.parent :

   224

            return self.parent.countParents(acc+1)

   225

        else :

   226

            return acc

   227

   228

    def inRoot (self, *fnames) :

   229

        """

   230

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

   231

        """

   232

   233

        c = self.countParents()

   234

   235

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

   236

   237

    def render (self) :

   238

        """

   239

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

   240

        """

   241

   242

        # ded folders are skipped

   243

        if not self.alive :

   245

            return

   246

   250

        # 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

   251

        if self.filtered :

   257

   258

        else :  

   259

            # create the thumb/preview dirs if needed

   260

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

   261

                path = self.pathFor(dir)

   262

   263

                if not os.path.isdir(path) :

   265

                    os.mkdir(path)

   266

   267

            # sort the subdirs

   268

            subdirs = self.subdirs.values()

   269

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

   270

   271

            # paginate!

   272

            images = self.sorted_images

   273

            image_count = len(images)

   274

            pages = []

   275

   276

            while images :

   277

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

   278

                images = images[settings.IMAGE_COUNT:]

   279

   280

            pagination_required = len(pages) > 1

   281

   282

            if pagination_required :

   284

            elif not pages :

   286

                pages = [[]]

   287

   288

            for cur_page, images in enumerate(pages) :

   289

                if pagination_required and cur_page > 0 :

   290

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

   291

                else :

   292

                    shorturl = self.shorturl_code

   293

   294

                # render to index.html

   295

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

   296

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

   297

                    title                        = self.title,

   298

                    breadcrumb                   = self.breadcrumb(),

   299

   300

                    dirs                         = subdirs,

   301

                    images                       = images,

   302

   303

                    num_pages                    = len(pages),

   304

                    cur_page                     = cur_page,

   305

   306

                    description                  = self.descr,

   307

   308

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

   309

                    shorturl_code                = shorturl,

   310

                )

   312

        # render images

   317

            img.render()

   318

   319

        # recurse into subdirs

   320

        for dir in self.subdirs.itervalues() :

   323

            dir.render()