*** empty log message ***

[booh] / booh

#!/usr/bin/ruby
#
#                         *  BOOH  *
#
# A.k.a `Best web-album Of the world, Or your money back, Humerus'.
#
# The acronyn sucks, however this is a tribute to Dragon Ball by
# Akira Toriyama, where the last enemy beaten by heroes of Dragon
# Ball is named "Boo". But there was already a free software project
# called Boo, so this one will be it "Booh". Or whatever.
#
#
# Copyright (c) 2004 Guillaume Cottenceau <gc3 at bluewin.ch>
#
# This software may be freely redistributed under the terms of the GNU
# public license version 2.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

require 'getoptlong'
require 'gettext'
include GetText
require 'rexml/document'
include REXML
require 'timeout'

require 'booh-lib'
require 'html_merges'

#- bind text domain as soon as possible because some _() functions are called early to build data structures
bindtextdomain("booh")

#- options
$options = [
    [ '--help',          '-h', GetoptLong::NO_ARGUMENT,       _("Get help message") ],

    [ '--no-check',      '-n', GetoptLong::NO_ARGUMENT,       _("Don't check for needed external programs at startup") ],

    [ '--source',        '-s', GetoptLong::REQUIRED_ARGUMENT, _("Directory which contains original images/videos as files or subdirs") ],
    [ '--destination',   '-d', GetoptLong::REQUIRED_ARGUMENT, _("Directory which will contain the web-album") ],
    [ '--clean',         '-c', GetoptLong::NO_ARGUMENT,       _("Clean destination directory") ],

    [ '--theme',         '-t', GetoptLong::REQUIRED_ARGUMENT, _("Select HTML theme to use") ],
    [ '--config',        '-C', GetoptLong::REQUIRED_ARGUMENT, _("File containing config listing images and videos within directories with captions") ],
    [ '--config-skel',   '-k', GetoptLong::REQUIRED_ARGUMENT, _("Filename where the script will output a config skeleton") ],
    [ '--merge-config',  '-M', GetoptLong::REQUIRED_ARGUMENT, _("File containing config listing, where to merge new images/videos from --source") ],

    [ '--mproc',         '-m', GetoptLong::REQUIRED_ARGUMENT, _("Specify the number of processors for multi-processors machines") ],

    [ '--verbose-level', '-v', GetoptLong::REQUIRED_ARGUMENT, _("Set max verbosity level (0: errors, 1: warnings, 2: important messages, 3: other messages)") ],
]

#- default values for some globals 
$convert = 'convert -interlace line +profile "*"'
$switches = []
$stdout.sync = true

def usage
    puts __("Usage: %s [OPTION]...", File.basename($0))
    $options.each { |ary|
        printf " %3s, %-15s %s\n", ary[1], ary[0], ary[3]
    }
end

def handle_options
    parser = GetoptLong.new
    parser.set_options(*$options.collect { |ary| ary[0..2] })
    begin
        parser.each_option do |name, arg|
            case name
            when '--help'
                usage
                exit(0)

            when '--no-check'
                $no_check = true

            when '--source'
                $source = arg.sub(%r|/$|, '')
                if !File.directory?($source)
                    die __("Argument to --source must be a directory")
                end
            when '--destination'
                $dest = arg.sub(%r|/$|, '')
                if File.exists?($dest) && !File.directory?($dest)
                    die __("If --destination exists, it must be a directory")
                end
                if $dest != make_dest_filename($dest)
                    die __("Sorry, destination directory can't contain non simple alphanumeric characters.")
                end
            when '--clean'
                system("rm -rf #{$dest}")

            when '--theme'
                select_theme(arg)
            when '--config'
                if File.readable?(arg)
                    $xmldoc = REXML::Document.new File.new(arg)
                    $mode = 'use_config'
                else
                    die __('Config file does not exist or is unreadable.')
                end
            when '--config-skel'
                if File.exists?(arg)
                    msg 1, __("Config skeleton file already exists, backuping to #{arg}.backup")
                    File.rename(arg, "#{arg}.backup")
                end
                $config_writeto = arg
                $mode = 'gen_config'
            when '--merge-config'
                if File.readable?(arg)
                    msg 2, __("Merge config notice: backuping current config file to #{arg}.backup")
                    $xmldoc = REXML::Document.new File.new(arg)
                    File.rename(arg, "#{arg}.backup")
                    $config_writeto = arg
                    $mode = 'merge_config'
                else
                    die __('Config file does not exist or is unreadable.')
                end

            when '--mproc'
                $mproc = arg.to_i
                $pids = []

            when '--verbose-level'
                $verbose_level = arg.to_i

            end
        end
    rescue
        puts $!
        usage
        exit(1)
    end

    if !$source && $xmldoc
        $source = $xmldoc.root.attributes['source']
        $dest = $xmldoc.root.attributes['destination']
    end

    if !$source
        die __("Missing --source parameter.")
    end
    if !$dest
        die __("Missing --destination parameter.")
    end
    if !$xmldoc
        $xmldoc = Document.new "<booh version='#{$VERSION}' source='#{utf8($source)}' destination='#{utf8($dest)}'/>"
        $xmldoc << XMLDecl.new( XMLDecl::DEFAULT_VERSION, $CURRENT_CHARSET )
        $mode = 'gen_config'
    end

    if !$theme
        select_theme('simple')
    end

end

def check_installation
    if $no_check
        return
    end
    %w(convert identify exif transcode mencoder).each { |prg|
        if !system("which #{prg} >/dev/null")
            die __("The `%s' program is typically needed. Re-run with --no-check if you're sure you're fine without it.", prg)
        end
    }
end

def replace_line(surround, keyword, line)
    begin
        contents = eval "$#{keyword}"
        line.sub!(/#{surround}#{keyword}#{surround}/, contents)
    rescue NameError
        die __("No `%s' found for substitution", keyword)
    end
end

def build_html_skeletons
    $html_images     = File.open("#{$FPATH}/themes/#{$theme}/skeleton_image.html").readlines
    $html_thumbnails = File.open("#{$FPATH}/themes/#{$theme}/skeleton_thumbnails.html").readlines
    $html_index      = File.open("#{$FPATH}/themes/#{$theme}/skeleton_index.html").readlines
    for line in $html_images + $html_thumbnails + $html_index
        while line =~ /~~~(\w+)~~~/
            replace_line('~~~', $1, line)
        end
    end
end

def sys(cmd)
    msg 2, cmd
    system(cmd)
end

#- parallelizable sys
def psys(cmd)
    if $mproc
        if pid = fork
            $pids << pid
        else
            msg 2, cmd + ' &'
            system(cmd)
            exit 0
        end
        if $pids.length == $mproc
            finished = Process.wait2
            $pids.delete(finished[0])
            $pids = $pids.find_all { |pid| Process.waitpid(pid, Process::WNOHANG) == nil }
        end
    else
        sys(cmd)
    end
end

def find_caption_value(xmldir, filename)
    xmldir.elements["[@filename='#{utf8(filename)}']"].attributes['caption']
end

def find_captions(xmldir, images)
    return images.collect { |img| find_caption_value(xmldir, img) }
end

def entry2type(entry)
    if entry =~ /\.(jpg|jpeg|jpe|gif|bmp|png)$/i
        return 'image'
    elsif entry =~ /\.(mov|avi|mpg|mpeg|mpe|wmv|asx)$/i
        #- might consider using file magic later..
        return 'video'
    else
        return nil
    end
end

#- grab the results of a command but don't sleep forever on a runaway process
def subproc_runaway_aware(command)
    begin
        timeout(5) {
            return `#{command}`
        }
    rescue Timeout::Error    
        msg 1, _("forgetting runaway process (transcode sucks again?)")
        #- todo should slay transcode but dunno how to do that
        return nil
    end
end

def gen_thumbnails(orig, xmldir, dests)
    if !dests.detect { |dest| !File.exists?(dest['filename']) } 
        return true
    end

    felem = xmldir.elements["[@filename='#{utf8(File.basename(orig))}']"]

    if entry2type(orig) == 'image'
        convert_options = ''
        if felem
            rotate = felem.attributes['rotate']
            if !rotate
                orientation = `exif '#{orig}'`.detect { |line| line =~ /^Orientation/ }
                if orientation =~ /right - top/
                    rotate = '90'
                end
                if orientation =~ /left - bottom/
                    rotate = '-90'
                end
                rotate ||= '0'
                felem.add_attribute('rotate', rotate)
            end
            convert_options += "-rotate #{rotate} "
        end
        for dest in dests
            if !File.exists?(dest['filename'])
                psys("#{$convert} #{convert_options}-geometry #{dest['size']} '#{orig}' '#{dest['filename']}'")
            end
        end
        return true

    elsif entry2type(orig) == 'video'
        dest_dir = make_dest_filename(File.dirname(dests[0]['filename']))
        #- frame-offset is an attribute that allows to specify which frame to use for the thumbnail;
        #- first try in dir to allow for: <dir .. subdirs-captionfile='/tmp/src2/people/pict0008.mov' pict0008.mov-frame-offset='100' ..>
        frame_offset = xmldir.attributes["#{utf8(File.basename(orig))}-frame-offset"]
        if !frame_offset
            #- then try in elements to allow for: <video filename='bourrique.mov' frame-offset='200'/>
            felem and frame_offset = felem.attributes['frame-offset']
        end
        frame_offset = (frame_offset || 5).to_i
        for dest in dests
            if !File.exists?("#{dest_dir}/screenshot.jpg000004.jpg")
                cmd = "transcode -a 0 -c #{frame_offset-5}-#{frame_offset} -i '#{orig}' -y jpg -o '#{dest_dir}/screenshot.jpg' 2>&1"
                msg 2, cmd
                if subproc_runaway_aware(cmd) =~ /V: import format.*unknown/ || !File.exists?("#{dest_dir}/screenshot.jpg000004.jpg")
                    msg 2, __("* could not extract first image of video %s with transcode, will try first converting with mencoder", orig)
                    cmd = "mencoder '#{orig}' -nosound -ovc lavc -lavcopts vcodec=mjpeg -o '#{dest_dir}/foo.avi' -frames #{frame_offset} -fps 25 >/dev/null 2>/dev/null"
                    msg 2, cmd
                    system cmd
                    if File.exists?("#{dest_dir}/foo.avi")
                        cmd = "transcode -a 0 -c #{frame_offset-5}-#{frame_offset} -i '#{dest_dir}/foo.avi' -y jpg -o '#{dest_dir}/screenshot.jpg' 2>&1"
                        msg 2, cmd
                        results = subproc_runaway_aware(cmd)
                        system("rm -f '#{dest_dir}/foo.avi'")
                        if results =~ /V: import format.*unknown/ || !File.exists?("#{dest_dir}/screenshot.jpg000004.jpg")
                            msg 0, __("could not extract first image of video %s encoded by mencoder", "#{dest_dir}/foo.avi")
                            return false
                        end
                    else
                        msg 0, __("could not make mencoder to encode %s to mpeg4", "#{orig}")
                        return false
                    end
                end

            end
            sys("#{$convert} -geometry #{dest['size']} #{dest_dir}/screenshot.jpg000004.jpg '#{dest['filename']}'")
        end
        return true
    end
end

#- stolen from CVSspam
def urlencode(text)
  text.sub(/[^a-zA-Z0-9\-,.*_\/]/) do
    "%#{sprintf('%2X', $&[0])}"
  end
end

def html_refresh(target)
    return "<html><head><META http-equiv='refresh' content='0;URL=#{target}'></head><body></body><html>"
end

def discover_iterations(iterations, line)
    if line =~ /~~iterate(\d)_open(_max(\d+))?~~/
        for iter in iterations.values
            if iter['open']
                iter['open'] = false
                iter['close_wait'] = $1.to_i
            end
        end
        iterations[$1.to_i] = { 'open' => true, 'max' => $3, 'opening' => '', 'closing' => '' }
        if $1.to_i == 1
            line.sub!(/.*/, '~~thumbnails~~')
        else
            line.sub!(/.*/, '')
        end
    elsif line =~ /~~iterate(\d)_close~~/
        iterations[$1.to_i]['open']  = false;
        iterations[$1.to_i]['close'] = true;
        line.sub!(/.*/, '')
    else
        for iter in iterations.values
            if iter['open']
                iter['opening'] += line
                line.sub!(/.*/, '')
            end
            if !iter['close'] && iter['close_wait'] && iterations[iter['close_wait']]['close']
                iter['closing'] += line
                line.sub!(/.*/, '')
            end
        end
    end
end

def reset_iterations(iterations)
    for iter in iterations.values
        iter['value'] = 1
    end
end

def run_iterations(iterations)
    html = ''
    for level in iterations.keys.sort
        if iterations[level]['value'] == 1 || level == iterations.keys.max
            html += iterations[level]['opening']
        end
        iterations[level]['value'] += 1
        if iterations[level]['max'] && iterations[level]['value'] > iterations[level]['max'].to_i
            iterations[level]['value'] = 1
            iterations[level-1]['value'] = 1
            html += iterations[level-1]['closing']
        end
    end
    return html
end

def close_iterations(iterations)
    html = ''
    for level in iterations.keys.sort.reverse
        html += iterations[level]['closing']
    end
    return html
end

def img_element(fullpath)
    sizespec = `identify '#{fullpath}'` =~ / JPEG (\d+)x(\d+) / ? 'width="' + $1 + '" height="' + $2 + '"' : ''
    return '<img src="' + File.basename(fullpath) + '" ' + sizespec + ' border="0"/>'
end

def walk_source_dir

    `find #{$source} -type d`.sort.each { |dir|
        dir.chomp!

        #- place xml document on proper node if exists, else create
        xmldir = $xmldoc.elements["//dir[@path='#{utf8(dir)}']"]
        if $mode == 'use_config'
            if !xmldir
                next
            end
        else
            if $mode == 'gen_config' || ($mode == 'merge_config' && !xmldir)
                #- add the <dir..> element if necessary
                parent = File.dirname(dir)
                xmldir = $xmldoc.elements["//dir[@path='#{utf8(parent)}']"]
                if !xmldir
                    xmldir = $xmldoc.root
                end
                xmldir = xmldir.add_element 'dir', { 'path' => utf8(dir), 'new' => 1 }
            end
        end

        #- read images/videos entries from config or from directories depending on mode
        entries = []
        if $mode == 'use_config'
            msg 2, __("Handling %s from config list...", dir)
            xmldir.elements.each { |element|
                if %w(image video).include?(element.name)
                    entries << from_utf8(element.attributes['filename'])
                end
            }
        else
            msg 2, __("Examining %s...", dir)
            entries = Dir.entries(dir).sort
            #- populate config in case of gen_config, add new files in case of merge_config
            for file in entries
                type = entry2type(file)
                if type && !xmldir.elements["#{type}[@filename='#{utf8(file)}']"]
                    xmldir.add_element type, { "filename" => utf8(file), "caption" => utf8(file.sub(/\.[^\.]+$/, '')[0..17]) }
                end
            end
            if $mode == 'merge_config'
                #- cleanup removed files from config and reread entries from config to get proper ordering
                entries = []
                xmldir.elements.each { |element|
                    fullpath = "#{dir}/#{from_utf8(element.attributes['filename'])}"
                    if %w(image video).include?(element.name)
                        if !File.readable?(fullpath)
                            msg 1, __("Config merge: removing #{fullpath} from config; use the backup file to retrieve caption info if this was a mistake")
                            xmldir.delete(element)
                        else
                            entries << from_utf8(element.attributes['filename'])
                        end
                    end
                }
            end
        end
        images = entries.find_all { |e| entry2type(e) == 'image' }
        msg 3, __("\t%s images", images.length)
        videos = entries.find_all { |e| entry2type(e) == 'video' }
        msg 3, __("\t%s videos", videos.length)

        dest_dir = make_dest_filename(dir.sub(/^#{Regexp.quote($source)}/, $dest))
        system("mkdir -p '#{dest_dir}'")

        #- copy any resource file that goes with the theme (css, images..)
        for entry in Dir.entries("#{$FPATH}/themes/#{$theme}")
            if !%w(. .. skeleton_image.html skeleton_thumbnails.html skeleton_index.html parameters.rb CVS).include?(entry)
                if !File.exists?("#{dest_dir}/#{entry}")
                    psys("cp '#{$FPATH}/themes/#{$theme}/#{entry}' '#{dest_dir}'")
                end
            end
        end

        #- pass through if there are no images and videos
        if images.size == 0 && videos.size == 0
            next
        end

        msg 2, __("Outputting in %s...", dest_dir)

        #- populate data structure with sizes from theme
        for sizeobj in $images_size
            fullscreen_images ||= {}
            fullscreen_images[sizeobj['name']] = []
            thumbnail_images ||= {}
            thumbnail_images[sizeobj['name']] = []
            thumbnail_videos ||= {}
            thumbnail_videos[sizeobj['name']] = []
        end

        images.size >= 1 and msg 3, __("\tcreating images thumbnails...")

        #- create thumbnails for images
        images.each { |img|
            base_dest_img = dest_dir + '/' + make_dest_filename(img.sub(/\.[^\.]+$/, ''))
            for sizeobj in $images_size
                size_fullscreen = sizeobj['fullscreen']
                size_thumbnails = sizeobj['thumbnails']
                fullscreen_dest_img = base_dest_img + "-#{size_fullscreen}.jpg"
                thumbnail_dest_img  = base_dest_img + "-#{size_thumbnails}.jpg"
                fullscreen_images[sizeobj['name']] << File.basename(fullscreen_dest_img)
                thumbnail_images[sizeobj['name']]  << File.basename(thumbnail_dest_img)
                gen_thumbnails("#{dir}/#{img}", xmldir, [ { 'filename' => fullscreen_dest_img, 'size' => size_fullscreen },
                                                          { 'filename' => thumbnail_dest_img, 'size' => size_thumbnails } ])
            end
        }

        videos.size >= 1 and msg 3, __("\tcreating videos thumbnails...")

        #- create thumbnails for videos
        videos.each { |video|
            thumbnail_ok = true
            for sizeobj in $images_size
                size_thumbnails = sizeobj['thumbnails']
                thumbnail_dest_img = dest_dir + '/' + make_dest_filename(video.sub(/\.[^\.]+$/, '')) + "-#{size_thumbnails}.jpg"
                thumbnail_videos[sizeobj['name']] << File.basename(thumbnail_dest_img)
                thumbnail_ok &&= gen_thumbnails("#{dir}/#{video}", xmldir, [ { 'filename' => thumbnail_dest_img, 'size' => size_thumbnails } ])
            end
            destvideo = "#{dest_dir}/#{video}"
            if !File.exists?(destvideo)
                psys("cp '#{dir}/#{video}' '#{destvideo}'")
            end
            #- cleanup temp
            system("rm -f #{dest_dir}/screenshot.jpg00000*")
        }

        #- fake for gettext to find these; if themes need more sizes, english name for them should be added here
        sizenames = { 'small' => utf8(_("small")), 'medium' => utf8(_("medium")), 'large' => utf8(_("large")) }

        msg 3, __("\tgenerating HTML pages...")
        
        #- generate thumbnails.html (page with thumbnails)
        for sizeobj in $images_size
            html = $html_thumbnails.collect { |l| l.clone }
            iterations = {}
            for i in html
                i.sub!(/~~run_slideshow~~/, images.size <= 1 ? '' : '<a href="image-' + sizeobj['name'] + '.html?run_slideshow">' + utf8(_('Run slideshow!')) + '</a>')
                i.sub!(/~~title~~/, xmldir.attributes['thumbnails-caption'] || utf8(File.basename(dir)))
                for sizeobj2 in $images_size
                    if sizeobj != sizeobj2
                        i.sub!(/~~size_#{sizeobj2['name']}~~/, '<a href="thumbnails-' + sizeobj2['name'] + '.html">' + sizenames[sizeobj2['name']] + '</a>')
                    else
                        i.sub!(/~~size_#{sizeobj2['name']}~~/, sizenames[sizeobj2['name']])
                    end
                end
                discover_iterations(iterations, i)
            end
            html_thumbnails = ''
            reset_iterations(iterations)
            for file in entries
                type = images.include?(file) ? 'image' : videos.include?(file) ? 'video' : nil
                if type
                    html_thumbnails += run_iterations(iterations)
                    if type == 'image'
                        index = images.index(file)
                        html_thumbnails.gsub!(/~~image_iteration~~/,
                                              '<a href="image-' + sizeobj['name'] + '.html?current=' + fullscreen_images[sizeobj['name']][index] + '">' +
                                                  img_element("#{dest_dir}/#{thumbnail_images[sizeobj['name']][index]}") + '</a>')
                        html_thumbnails.gsub!(/~~caption_iteration~~/,
                                              find_caption_value(xmldir, images[index]) || utf8(images[index]))
                        html_thumbnails.gsub!(/~~ifimage\?~~(.+?)~~fi~~/) { $1 }
                        html_thumbnails.gsub!(/~~ifvideo\?~~(.+?)~~fi~~/, '')
                    elsif type == 'video'
                        index = videos.index(file)
                        if File.exists?("#{dest_dir}/#{thumbnail_videos[sizeobj['name']][index]}")
                            html_thumbnails.gsub!(/~~image_iteration~~/,
                                                  '<a href="' + videos[index] + '">' + img_element("#{dest_dir}/#{thumbnail_videos[sizeobj['name']][index]}") + '</a>')
                        else
                            html_thumbnails.gsub!(/~~image_iteration~~/,
                                                  '<a href="' + videos[index] + '">' + utf8(_("(no preview)")) + '</a>')
                        end
                        html_thumbnails.gsub!(/~~caption_iteration~~/,
                                              find_caption_value(xmldir, videos[index]) || utf8(videos[index]))
                        html_thumbnails.gsub!(/~~ifimage\?~~(.+?)~~fi~~/, '')
                        html_thumbnails.gsub!(/~~ifvideo\?~~(.+?)~~fi~~/) { $1 }
                    end
                end
            end
            html_thumbnails += close_iterations(iterations)
            for i in html
                i.sub!(/~~thumbnails~~/, html_thumbnails)
            end
            ios = File.open("#{dest_dir}/thumbnails-#{sizeobj['name']}.html", "w")
            ios.write(html)
            ios.close
        end

        #- generate image.html (page with fullscreen images)
        if images.size > 0
            #- don't ask me why I need so many backslashes... the aim is to print \\\" for each " in the javascript source
            captions4js = find_captions(xmldir, images).collect { |e| e ? '"' + e.gsub('"', '\\\\\\\\\\\\\\\\\"' ) + '"' : '""' }.join(', ')
            for sizeobj in $images_size
                html = $html_images.collect { |l| l.clone }
                images4js = fullscreen_images[sizeobj['name']].collect { |e| "\"#{e}\"" }.join(', ')
                otherimages4js = ''
                othersizes = []
                for sizeobj2 in $images_size
                    if sizeobj != sizeobj2
                        otherimages4js += "var images_#{sizeobj2['name']} = new Array(" + fullscreen_images[sizeobj2['name']].collect { |e| "\"#{e}\"" }.join(', ') + ")\n"
                        othersizes << "\"#{sizeobj2['name']}\""
                    end
                end
                for i in html
                    i.sub!(/~~images~~/, images4js)
                    i.sub!(/~~other_images~~/, otherimages4js)
                    i.sub!(/~~other_sizes~~/, othersizes.join(', '))
                    i.sub!(/~~captions~~/, captions4js)
                    i.sub!(/~~title~~/, xmldir.attributes['thumbnails-caption'] || utf8(File.basename(dir)))
                    i.sub!(/~~thumbnails~~/, '<a href="thumbnails-' + sizeobj['name'] + '.html">' + utf8(_('Return to thumbnails')) + '</a>')
                    for sizeobj2 in $images_size
                        if sizeobj != sizeobj2
                            i.sub!(/~~size_#{sizeobj2['name']}~~/,
                                   '<a href="image-' + sizeobj2['name'] + '.html" id="link' + sizeobj2['name'] + '">' + sizenames[sizeobj2['name']] + '</a>')
                        else
                            i.sub!(/~~size_#{sizeobj2['name']}~~/,
                                   sizenames[sizeobj2['name']])
                        end
                    end
                end
                ios = File.open("#{dest_dir}/image-#{sizeobj['name']}.html", "w")
                ios.write(html)
                ios.close
            end
        end
    }

    msg 3, ''

    #- add attributes to <dir..> elements needing so
    if $mode != 'use_config'
        msg 3, __("\tfixating configuration file...")
        $xmldoc.elements.each('//dir[@new]') { |element|
            path = captionpath = element.attributes['path']
            child = element
            captionfile = nil
            while true
                child = child.elements[1]
                if !child
                    element.remove  #- means we have a directory with nothing interesting in it
                    break
                elsif child.name == 'dir'
                    captionpath = child.attributes['path']
                else
                    captionfile = "#{captionpath}/#{child.attributes['filename']}"
                    break
                end
            end
            basename = File.basename(path)
            if element.elements['dir']
                element.add_attribute('subdirs-caption', basename)
                element.add_attribute('subdirs-captionfile', captionfile)
            end
            if element.elements['image'] || element.elements['video']
                element.add_attribute('thumbnails-caption', basename)
                element.add_attribute('thumbnails-captionfile', captionfile)
            end
            element.delete_attribute('new')
        }
    end

    #- write down to disk config if necessary
    if $config_writeto
        ios = File.open($config_writeto, "w")
        $xmldoc.write(ios, 0)
        ios.close
    end

    #- second pass to create index.html files
    default_thumbnails = $images_size.detect { |sizeobj| sizeobj['default'] }
    if !default_thumbnails
        die __("Theme `%s' has no default size.", $theme)
    else
        default_thumbnails = default_thumbnails['name']
    end

    msg 3, __("\trescanning directories to generate all `index.html' files...")

    `find #{$source} -type d`.each { |dir|
        dir.chomp!
        xmldir = $xmldoc.elements["//dir[@path='#{utf8(dir)}']"]
        if !xmldir
            next
        end
        dest_dir = make_dest_filename(dir.sub(/^#{Regexp.quote($source)}/, $dest))

        html = $html_index.collect { |l| l.clone }
        iterations = {}
        for i in html
            caption = xmldir.attributes['subdirs-caption'] || xmldir.attributes['thumbnails-caption'] || utf8(File.basename(dir))
            i.gsub!(/~~title~~/, caption)
            if xmldir.parent.name == 'dir'
                nav = ''
                path = '..'
                parent = xmldir.parent
                while parent.name == 'dir'
                    parentcaption = parent.attributes['subdirs-caption'] || parent.attributes['thumbnails-caption'] || File.basename(parent.attributes['path'])
                    nav = "<a href='#{path}/index.html'>#{parentcaption}</a> #{utf8(_(" > "))} #{nav}"
                    path += '/..'
                    parent = parent.parent
                end
                i.gsub!(/~~ifnavigation\?~~(.+?)~~fi~~/) { $1 }
                i.gsub!(/~~navigation~~/, nav + caption)
            else
                i.gsub!(/~~ifnavigation\?~~(.+?)~~fi~~/, '')
            end
            discover_iterations(iterations, i)
        end

        html_index = ''
        reset_iterations(iterations)

        if xmldir.elements['dir']
            #- deal with "current" album (directs to "thumbnails" page)
            if xmldir.attributes['thumbnails-caption']
                thumbnail = "#{dest_dir}/thumbnails-thumbnail.jpg"
                gen_thumbnails(from_utf8(xmldir.attributes['thumbnails-captionfile']), xmldir, [ { 'filename' => thumbnail, 'size' => $albums_thumbnail_size } ])
                html_index += run_iterations(iterations)
                html_index.gsub!(/~~image_iteration~~/, "<a href='thumbnails-#{default_thumbnails}.html'>" + img_element(thumbnail) + '</a>')
                html_index.gsub!(/~~caption_iteration~~/, xmldir.attributes['thumbnails-caption'])
            end
            #- cleanup temp for videos
            system("rm -f #{dest_dir}/screenshot.jpg00000*")

            #- deal with sub-albums (direct to subdirs/index.html pages)
            xmldir.elements.each('dir') { |child|
                subdir = make_dest_filename(from_utf8(File.basename(child.attributes['path'])))
                thumbnail = "#{dest_dir}/thumbnails-#{subdir}.jpg"
                html_index += run_iterations(iterations)
                #- first look for subdirs info; if not, means there is no subdir
                caption = child.attributes['subdirs-caption']
                if caption
                    gen_thumbnails(from_utf8(child.attributes['subdirs-captionfile']), child, [ { 'filename' => thumbnail, 'size' => $albums_thumbnail_size } ])
                    html_index.gsub!(/~~caption_iteration~~/, caption)
                else
                    gen_thumbnails(from_utf8(child.attributes['thumbnails-captionfile']), child, [ { 'filename' => thumbnail, 'size' => $albums_thumbnail_size } ])
                    html_index.gsub!(/~~caption_iteration~~/, child.attributes['thumbnails-caption'])
                end
                html_index.gsub!(/~~image_iteration~~/, "<a href='#{make_dest_filename(subdir)}/index.html'>" + img_element(thumbnail) + '</a>')
                #- cleanup temp for videos
                system("rm -f #{dest_dir}/screenshot.jpg00000*")
            }

        else
            html = html_refresh("thumbnails-#{default_thumbnails}.html")
        end

        html_index += close_iterations(iterations)
        for i in html
            i.gsub!(/~~thumbnails~~/, html_index)
        end

        ios = File.open("#{dest_dir}/index.html", "w")
        ios.write(html)
        ios.close

        #- substitute "return to albums" correctly
        `find '#{dest_dir}' -maxdepth 1 -name "thumbnails*.html"`.each { |thumbnails|
            thumbnails.chomp!
            contents = File.open(thumbnails.chomp).readlines
            for i in contents
                if xmldir.elements['dir']
                    i.sub!(/~~return_to_albums~~/, '<a href="index.html">' + utf8(_('Return to albums')) + '</a>')
                else
                    if xmldir.parent.name == 'dir'
                        i.sub!(/~~return_to_albums~~/, '<a href="../index.html">' + utf8(_('Return to albums')) + '</a>')
                    else
                        i.sub!(/~~return_to_albums~~/, '')
                    end
                end
            end
            ios = File.open(thumbnails, "w")
            ios.write(contents)
            ios.close
        }
    }

    msg 3, _(" all done.")
end

handle_options
check_installation

build_html_skeletons

walk_source_dir