degal/folder.py
changeset 64 4ebd563214d2
parent 44 533b7e8b5d3b
child 70 67dd32adf159
equal deleted inserted replaced
63:0db16d6b3617 64:4ebd563214d2
     1 import os, os.path
     1 """
     2 
     2     Per-directory gallery state
     3 import settings, image, utils, helpers, log
     3 """
     4 from template import gallery as gallery_tpl
     4 
     5 from helpers import url_for_page
     5 import filesystem, image, html
     6 
     6 
     7 def dirUp (count=1) :
     7 from utils import lazy_load
       
     8 
       
     9 class Folder (filesyste.Directory) :
     8     """
    10     """
     9         Returns a relative path to the directly count levels above the current one
    11         A Folder is a filesystem Directory that contains any number of other Folders and Images.
    10     """
    12     """
    11 
    13 
    12     if not count :
    14     def __init__ (self, node) :
    13         return '.'
    15         super(Folder, self).__init__(node)
    14 
    16 
    15     return os.path.join(*(['..']*count))
    17         # info
       
    18         self.title = None
       
    19         self.description = None
       
    20 
       
    21     @lazy_load
       
    22     def preview_dir (self) :
       
    23         """
       
    24             Load and return the Directory for previews
       
    25         """
       
    26         
       
    27         return self.subdir(self.config.preview_dir, create=True)
    16     
    28     
       
    29     @lazy_load
       
    30     def thumb_dir (self) :
       
    31         """
       
    32             Load and return the Directory for thumbs
       
    33         """
       
    34         
       
    35         return self.subdir(self.config.thumb_dir, create=True)
       
    36    
       
    37     @lazy_load_iter
       
    38     def subnodes (self) :
       
    39         """
       
    40             Load and return an ordered list of child-Nodes
       
    41         """
       
    42 
       
    43         return super(Folder, self).subnodes(skip_dotfiles=True, sorted=True)
       
    44     
       
    45     @lazy_load_iter
       
    46     def subfolders (self) :
       
    47         """
       
    48             Load and return an ordered list of sub-Folders
       
    49         """
       
    50 
       
    51         return (Folder(node) for node in self.subnodes if isinstance(node, filesystem.Directory))
       
    52 
       
    53     @lazy_load_iter
       
    54     def images (self) :
       
    55         """
       
    56             Load and return an ordered/linked list of sub-Images
       
    57         """
       
    58 
       
    59         prev = None
       
    60 
       
    61         for node in self.subnodes :
       
    62             # skip non-relevant ones
       
    63             # XXX: node should need to be a File
       
    64             if not isinstance(node, filesystem.File) or not self.config.is_image(node) :
       
    65                 continue
       
    66             
       
    67             # create new
       
    68             img = image.Image(node, prev)
       
    69 
       
    70             # link up
       
    71             if prev :
       
    72                 prev.next = img
       
    73 
       
    74                 # yield the linked-up prev
       
    75                 yield prev
       
    76             
       
    77             # continue
       
    78             prev = img
       
    79         
       
    80         # and the last one
       
    81         if prev :
       
    82             yield prev
       
    83 
       
    84     @property
       
    85     def page_count (self) :
       
    86         """
       
    87             Returns the number of pages needed to show this folder's images
       
    88         """
       
    89 
       
    90         return math.ceil(len(self.images) / float(self.config.images_per_page))
       
    91 
       
    92     def images_for_page (self, page) :
       
    93         """
       
    94             Returns the list of Images to be displayed for the given page, if any
       
    95         """
       
    96         
       
    97         # offset to first image
       
    98         offset = page * self.config.images_per_page
       
    99         
       
   100         # slice
       
   101         return self.images[offset : offset + self.config.images_per_page]
       
   102 
       
   103     def html_file (self, page=0) :
       
   104         """
       
   105             Returns the File representing the .html for the given page
       
   106         """
       
   107         
       
   108         if page :
       
   109             return self.subfile("index_%d.html" % page)
       
   110         
       
   111         else :
       
   112             return self.subfile("index.html")
       
   113     
       
   114     def index (self) :
       
   115         """
       
   116             Recursively index this Folder, yielding a series of all Folder objects inside.
       
   117         """
       
   118         
       
   119         # and subfolders
       
   120         for subfolder in self.subfolders :
       
   121             yield subfolder
       
   122 
       
   123             for item in subfolder.index_subfolders() :
       
   124                 yield item
       
   125    
    17 class Folder (object) :
   126 class Folder (object) :
    18     def __init__ (self, name='.', parent=None) :
   127     def __init__ (self, name='.', parent=None) :
    19         # the directory name, no trailing /
   128         # the directory name, no trailing /
    20         self.name = unicode(name.rstrip(os.sep))
   129         self.name = unicode(name.rstrip(os.sep))
    21 
   130