# GNU Solfege - ear training for GNOME
# Copyright (C) 2000, 2001, 2002, 2003, 2004  Tom Cato Amundsen
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

try:
    app_running == True
except:
    import sys
    sys.path.append("src")
    sys.path.append(".")
    import i18n
    i18n.setup_srcdir()

class NoQuestionException(Exception):
    pass
class LessonfileException(Exception):
    pass

import re, string, types, os, sys
import const
import random
import mpd
import cfg
import utils
from soundcard.rat import Rat
import soundcard
import dataparser
import app

# The keys in the dict say how many steps up or down in the
# circle of fifths we go if we transpose.
_keys_to_interval = {
              -10: '-M6', #c -> eses
               -9: '-a2', #c -> beses
               -8: '-a5', #c -> fes
               -7: '-au', #c -> ces
               -6: '-a4', #c -> ges
               -5: 'm2', # c -> des
               -4: '-M3',# c -> as
               -3: 'm3', # c -> es
               -2: '-M2', # c -> bes
               -1: '4', # c -> f
                0: 'u',
                1: '-4', # c -> g,
                2: 'M2', # c -> d
                3: '-m3',# c -> a
                4: 'M3', # c -> e
                5: '-m2', # c -> b
                6: 'a4', # c -> fis
                7: 'au', #c -> cis
                8: 'a5', # c -> gis
                9: 'a2', # c -> dis
                10: 'M6', # c -> ais
            }

predef = {'dictation': 'dictation',
          'progression': 'progression',
          # define the harmony keyword for backward compatibility
          'harmony': 'harmonic-progression-dictation',
          'harmonic-progression-dictation': 'harmonic-progression-dictation',
          'sing-chord': 'sing-chord',
          'singanswer': 'singanswer',
          'chord-voicing': 'chord-voicing',
          'chord': 'chord',
          'id-by-name': 'id-by-name',
          'satb': 'satb',
          'cmdline': 'cmdline',
          'horiz': 'horiz',
          'vertic': 'vertic',
          'yes': True,
          'no': False,
          'accidentals': 'accidentals',
          'key': 'key',
          'semitones': 'semitones',
          'tempo': (60, 4)}

class WavPlayerFunctionClass(object):
    def __init__(self, args):
        self.m_args = args
    def __str__(self):
        return cfg.get_string("sound/wav_player") + " " + self.m_args

lessonfile_functions = {
        '_': dataparser.dataparser_i18n_func,
        '_i': _i, #FIXME
        'play_wav': lambda f: WavPlayerFunctionClass(f),
}

class _Header:
    def __init__(self, headerdict):
        self.m_headerdict = headerdict
        for key, value in (
                           ('version', ''),
                           ('title', ''),
                           ('description', ''),
                           #('content', ''), This MUST be set in the lessonfile
                           ('musicformat', 'normal'),
                           ('random_transpose', False),
                           ('labelformat', 'normal'),
                           ('fillnum', 1),
                           ('filldir', 'horiz'),
                           ('questions_selectable', False),
                           ('have_repeat_slowly_button', False),
                           ('have_music_displayer', False),
                           ):
            if not self.m_headerdict.has_key(key):
                self.m_headerdict[key] = value
    def __getattr__(self, name):
        if self.m_headerdict.has_key(name):
            return dataparser.get_translated_string(self.m_headerdict, name)
        raise NameError(name)


class LessonfileCommon(object):
    def __init__(self, teacher):
        self.m_prev_question = None
        self.m_t = teacher
        self._idx = None
    def parse_file(self, filename):
        """Parse the file named filename. Set these variables:
        self.header     a Header instance
        self.questions  a list of all question
        """
        parser = dataparser.Dataparser(predef, lessonfile_functions, ('tempo',))
        self.m_filename = filename
        parser.parse_file(filename)
        self.m_transpose = mpd.MusicalPitch.new_from_notename("c'")
        self.header = _Header(parser.header)
        self.m_globals = parser.globals
        self.m_questions = parser.questions
        for question in self.m_questions:
            question['active'] = 1
            question['m_lessonfile'] = self
    def select_random_question(self):
        """
        Select a new question by random.
        """
        count = 0
        available_question_idx = []
        for i in range(len(self.m_questions)):
            if self.m_questions[i]['active']:
                available_question_idx.append(i)
        if not available_question_idx:
            raise NoQuestionException()
        while 1:
            count += 1
            self._idx = random.choice(available_question_idx)
            if self.header.random_transpose:
                if self.header.random_transpose == True:
                    self.handle_random_transpose_is_yes()
                # Backward compatability to handle old style
                # random_transpose = -4, 5 FIXME
                elif len(self.header.random_transpose) == 2:
                    self.header.random_transpose \
                        = ['semitones'] + self.header.random_transpose
                if self.m_questions[self._idx].has_key('key'):
                    key = self.m_questions[self._idx]['key']
                else:
                    key = "c \major"
                if self.header.random_transpose[0] == 'semitones':
                    self.m_transpose = self.semitone_find_random_transpose()
                else:
                    self.m_transpose = self.find_random_transpose(key)
            if count == 10:
                break
            if self.m_prev_question == self.get_music() \
                and (len(self.m_questions) > 1 or self.header.random_transpose):
                continue
            break
        self.m_prev_question = self.get_music()
    def semitone_find_random_transpose(self):
        """
        Called to find random transposition in "semitone" mode.
        Create and return a random MusicalPitch representing this transposition.
        """
        assert self.header.random_transpose[0] == 'semitones'
        if self.header.random_transpose == 1:
            return mpd.MusicalPitch().randomize("g", "fis'")
        elif type(self.header.random_transpose) in (type([]), type(())):
            return mpd.MusicalPitch().randomize(
              mpd.transpose_notename("c'", self.header.random_transpose[1]),
              mpd.transpose_notename("c'", self.header.random_transpose[2]))
    def find_random_transpose(self, key):
        """
        Called to create random transposition in "accidentals" or "key" mode.
        Create and return a random MusicalPitch representing this transposition.
        """
        assert self.header.random_transpose[0] in ('key', 'accidentals')
        low, high = self.header.random_transpose[1:3]
        tone, minmaj = string.split(key, " ")
        k = mpd.MusicalPitch.new_from_notename(tone).get_octave_notename()
        #FIXME this list say what key signatures are allowed in sing-chord
        # lesson files. Get the correct values and document them.
        kv = ['des', 'aes', 'ees', 'bes', 'f', 'c',
              'g', 'd', 'a', 'e', 'b', 'fis', 'cis', 'gis']
        # na tell the number of accidentals (# is positive, b is negative)
        # the question has from the lessonfile before anything is transpose.
        na = kv.index(k) - 5
        if minmaj == '\\minor':
            na -= 3
        if self.header.random_transpose[0] == 'accidentals':
            # the number of steps down the circle of fifths we can go
            n_down = low - na
            # the number of steps up the circle of fifths we can go
            n_up = high - na
        else:
            assert self.header.random_transpose[0] == 'key'
            n_down = low
            n_up = high
        interv = mpd.Interval()
        interv.set_from_string(_keys_to_interval[random.choice(range(n_down, n_up+1))])
        return mpd.MusicalPitch.new_from_notename("c'") + interv
    def handle_random_transpose_is_yes(self):
        self.header.random_transpose = ['semitones', -5, 6]
    def iterate_questions_with_unique_names(self):
        """Iterate the questions in the lessonfile, but only yield the
        first question if several questions have the same name. The
        untranslated name is used when deciding if a name is unique.
        """
        names = {}
        for question in self.m_questions:
            if not names.has_key(question.get_cname()):
                names[question.get_cname()] = 1
                yield question
    def get_unique_cnames(self):
        """Return a list of all cnames in the file, in the same order
        as they appear in the file. Only list each cname once, even if
        there are more questions with the same cname.
        """
        names = []
        for question in self.m_questions:
            if not question.get_cname() in names:
                names.append(question.get_cname())
        return names
    def get_question(self):
        """
        Return the currently selected question.
        """
        assert self._idx is not None
        return self.m_questions[self._idx]
    def get_tempo(self):
        assert self._idx is not None
        return self.m_questions[self._idx]['tempo']
    def get_name(self):
        """
        Return the translated name of the currently selected question.
        """
        assert self._idx is not None
        return self.m_questions[self._idx].get_name()
    def get_cname(self):
        """
        The 'cname' of a question is the C locale of the question name.
        Said easier: If the lesson file supplies translations, then 'cname'
        is the untranslated name.
        """
        assert self._idx is not None
        return self.m_questions[self._idx].get_cname()
    def get_music_of_question(self, question):
        """
        Return the music of question 'question'. This is complete
        music code that can be fed to mpd.play_music(...).
        """
        return self.prepare_music_from_string('music', question)
    def prepare_music_from_string(self, name, question):
        """
        """
        if self.header.musicformat == 'chord':
            return r"\staff\transpose %s{< %s > }" \
              % (self.m_transpose.get_octave_notename(), question[name])
        elif self.header.musicformat == 'normal':
            return self.prepare_music_string_normal_format(question[name])
        elif self.header.musicformat == 'satb':
            return self.prepare_music_string_satb_format(question[name], question)
        elif self.header.musicformat == 'cmdline':
            return str(question[name])
        else:
            raise LessonfileException("\nLesson file contain illegal assignment 'musicformat=%s'" % self.header.musicformat)
    def get_music(self):
        """
        Return the music for the currently selected question. This is complete
        music code that can be fed to mpd.play_music(...).
        """
        assert self._idx is not None
        return self.get_music_of_question(self.m_questions[self._idx])
    def prepare_music_string_satb_format(self, s, question):
        """
        It should not be necessary to call this method directly. Call
        .get_music() or .prepare_music_from_string() and let that
        function decide.
        """
        assert self.header.musicformat == 'satb'
        v = string.split(s, '|')
        if question.has_key('key'):
            k = question['key']
        else:
            k = "c \major"
        music = r"""
                \staff{ \key %s\stemUp <%s> }
                \addvoice{ \stemDown <%s> }
                \staff{ \key %s\clef bass \stemUp <%s>}
                \addvoice{ \stemDown <%s>}
                """ % (k, v[0], v[1], k, v[2], v[3])
        if self.header.random_transpose:
            music = string.replace(music, r"\staff",
                      r"\staff\transpose %s" % self.m_transpose.get_octave_notename())
            music = string.replace(music, r"\addvoice",
                      r"\addvoice\transpose %s" % self.m_transpose.get_octave_notename())
        return music
    def prepare_music_string_normal_format(self, s):
        """
        It should not be necessary to call this method directly. Call
        .get_music() or .prepare_music_from_string() and let that
        function decide.
        """
        assert self.header.musicformat == 'normal'
        if self.header.random_transpose:
            s = string.replace(s, r'\staff',
               r'\staff\transpose %s' % self.m_transpose.get_octave_notename())
            s = string.replace(s, r'\addvoice',
               r'\addvoice\transpose %s' % self.m_transpose.get_octave_notename())
        return s
    def get_music_as_notename_list(self):
        """
        Return a list of notenames representing the question currently
        selected question

        Assert musicformat in ('chord', 'satb')
        """
        assert self.header.musicformat in ('chord', 'satb')
        assert self._idx is not None
        if self.header.musicformat == 'chord':
            if not self.header.random_transpose:
                return string.split(self.m_questions[self._idx]['music'])
            v = []
            for n in string.split(self.m_questions[self._idx]['music']):
                v.append(mpd.MusicalPitch.new_from_notename(n).transpose_by_musicalpitch(
                     self.m_transpose).get_octave_notename())
            return v
        elif self.header.musicformat == 'satb':
            v = []
            for n in re.split("\s|\|", self.m_questions[self._idx]['music']):
                v.append(mpd.MusicalPitch.new_from_notename(n).transpose_by_musicalpitch(self.m_transpose).get_octave_notename())
            return v
        else:
            raise LessonfileException("get_music_as_notename_list cannot handle musicformat=%s" % self.header.musicformat)
    def get_music_as_notename_string(self):
        """
        Return a string with notenames representing the question currently
        selected question.

        Assert musicformat in ('chord', 'satb')
        """
        return " ".join(self.get_music_as_notename_list())
    def has_question(self):
        """
        Return True if a question is selected.
        """
        return self._idx != None
    def play_question(self, question=None):
        """Play the question. Play the current question if question is none.
        """
        if not question:
            question = self.get_question()
        if self.header.musicformat == 'cmdline':
            app.run_external_program(self.get_music(), cfg.get_string('lessoncollections/%s' % self.m_t.get_string('lessoncollection')), "")
            return
        elif self.header.musicformat in ('normal', 'satb'):
            self.play_question_musicformat_normal_satb(question)
            return
        elif self.header.musicformat == 'chord':
            self.play_question_musicformat_chord(question)
            return
        raise FIXME
    def play_question_musicformat_normal_satb(self, question):
        assert self.header.musicformat in ('normal', 'satb')
        instrument = self.prepare_instrument_list(question)
        mpd.play_music(question.get_music(), self.get_tempo(),
                       instrument[0], instrument[1])
    def play_question_slowly(self, question=None):
        if not question:
            question = self.get_question()
        assert self.header.musicformat == 'normal'
        self.play_question_musicformat_normal_slowly(question)
    def play_question_musicformat_normal_slowly(self, question):
        assert self.header.musicformat == 'normal'
        instrument = self.prepare_instrument_list(question)
        bpm = self.get_tempo()
        bpm = (bpm[0]/2, bpm[1])
        mpd.play_music(question.get_music(), bpm,
                       instrument[0], instrument[1])
    def play_question_musicformat_chord(self, question):
        assert self.header.musicformat == 'chord'
        instrument = self.prepare_instrument_list(question)
        if len(instrument) == 2:
            mpd.play_music(question.get_music(), self.get_tempo(),
                       instrument[0], instrument[1])
        elif len(instrument) == 6:
            track = soundcard.Track()
            track.set_bpm(cfg.get_int('config/default_bpm'))#FIXME skulle dette vart tatt fra lesson file?
            nlist = self.get_music_as_notename_list()
            # set patches
            track.set_patch(0, instrument[0])
            for x in range(1, len(nlist)-1):
                track.set_patch(x, instrument[2])
            track.set_patch(len(nlist)-1, instrument[4])
            # start notes
            track.start_note(0, mpd.notename_to_int(nlist[0]), instrument[1])
            for x, notename in enumerate(nlist[1:-1]):
                track.start_note(x+1, mpd.notename_to_int(notename),
                        instrument[3])
            track.start_note(len(nlist)-1, mpd.notename_to_int(nlist[-1]), instrument[5])
            # delay
            track.notelen_time(4)
            # stop notes
            track.stop_note(0, mpd.notename_to_int(nlist[0]), instrument[1])
            for x, notename in enumerate(nlist[1:-1]):
                track.stop_note(x+1, mpd.notename_to_int(notename),
                                   instrument[3])
            track.stop_note(len(nlist)-1, mpd.notename_to_int(nlist[-1]), instrument[5])
            soundcard.synth.play_track(track)
        else:
            raise "FIXME"
    def play_question_arpeggio(self):
        if self.header.musicformat == 'chord':
            self.play_question_musicformat_chord_arpeggio()
        elif self.header.musicformat == 'satb':
            self.play_question_musicformat_satb_arpeggio()
        else:
            raise FIXME
    def play_question_musicformat_chord_arpeggio(self):
        """FIXME -- for completeness, should this function should take a question argument?
        """
        assert self.header.musicformat == 'chord'
        instrument = self.prepare_instrument_list(self.get_question())
        if len(instrument) == 2:
            m = self.get_music_as_notename_string()
            mpd.play_music(r"\staff{%s}" % m, self.get_tempo(),
                       instrument[0], instrument[1])
        elif len(instrument) == 6:
            track = soundcard.Track()
            track.set_bpm(cfg.get_int('config/default_bpm'))#FIXME skulle dette vart tatt fra lesson file?
            nlist = self.get_music_as_notename_list()
            # set patches
            track.set_patch(0, instrument[0])
            for x in range(1, len(nlist)-1):
                track.set_patch(x, instrument[2])
            track.set_patch(len(nlist)-1, instrument[4])
            # start notes
            track.note(4, 0, mpd.notename_to_int(nlist[0]), instrument[1])
            for x, notename in enumerate(nlist[1:-1]):
                track.note(4, x+1, mpd.notename_to_int(notename),
                                    instrument[3])
            track.note(4, len(nlist)-1, mpd.notename_to_int(nlist[-1]), instrument[5])
            soundcard.synth.play_track(track)
        else:
            raise "FIXME"
    def play_question_musicformat_satb_arpeggio(self):
        """FIXME -- for completeness, should this function should take a question argument?
        """
        instrument = self.prepare_instrument_list(self.get_question())
        track = soundcard.Track()
        track.set_bpm(cfg.get_int('config/default_bpm'))
        track.set_patch(0, instrument[0])
        for x in [0, 1]:
            v = self.get_music_as_notename_list()[x]
            s = string.split(string.strip(v), " ")
            for n in s:
                if cfg.get_string('user/sex') == 'female':
                    track.note(4, 0, mpd.notename_to_int(n), instrument[1])
                else:
                    track.note(4, 0, mpd.notename_to_int(n)-12, instrument[1])
        for x in [2, 3]:
            v = self.get_music_as_notename_list()[x]
            s = string.split(string.strip(v), " ")
            for n in s:
                if cfg.get_string('user/sex') == 'male':
                    track.note(4, 0, mpd.notename_to_int(n), instrument[1])
                else:
                    track.note(4, 0, mpd.notename_to_int(n)+12, instrument[1])
        soundcard.synth.play_track(track)
    def play_question_as_choral(self, question):
        instrument = self.prepare_instrument_list(self.get_question())
        if len(instrument) == 2:
            instrument = instrument * 3
        # FIXME, only the velocity from instrument[1] is used since
        # music_to_tracklist is not complete.
        tracklist = mpd.music_to_tracklist(question.get_music(), instrument[1])
        tracklist[0].prepend_patch(0, instrument[4])
        track = tracklist[0]
        a, b = self.get_tempo()
        # FIXME the bpm api is wrong. We set the tempo to one track, and it works for all.
        track.prepend_bpm(a, b)
        for x in range(1, len(tracklist)-1):
            tracklist[x].prepend_patch(x, instrument[2])
            track.merge_with(tracklist[x])
        tracklist[-1].prepend_patch(len(tracklist)-1, instrument[0])
        track.merge_with(tracklist[-1])
        soundcard.synth.play_track(track)
    def prepare_instrument_list(self, question):
        """Return a list created from the instrument variable the question.
        Use app default values if the variable is missing.
        Convert instrument names to integer values.
        """
        if question.has_key('instrument'):
            instrument = question['instrument']
        elif self.m_globals.has_key('instrument'):
            instrument = self.m_globals['instrument']
        else:
            instrument = [cfg.get_int('config/preferred_instrument'),
                          cfg.get_int('config/preferred_instrument_velocity')]
        if type(instrument) in (types.UnicodeType, types.IntType):
            instrument = [instrument,
                          cfg.get_int('config/preferred_instrument_velocity')]
        if len(instrument) == 2:
            if type(instrument[0]) == types.UnicodeType:
                try:
                    instrument[0] = soundcard.find_midi_instrument_number(instrument[0])
                except KeyError, e:
                    print "Warning: Invalid instrument name in lesson file:", e
                    instrument[0] = cfg.get_int('config/preferred_instrument')
            if not (0 <= instrument[1] < 128):
                instrument[1] = cfg.get_int('config/preferred_instrument_velocity')
        elif len(instrument) == 6:
            for x in (0, 2, 4):
                if type(instrument[x]) == types.UnicodeType:
                    try:
                        instrument[x] = soundcard.find_midi_instrument_number(instrument[x])
                    except KeyError, e:
                        print "Warning: Invalid instrument name in lesson file:", e
                        instrument[0] = cfg.get_int('config/preferred_instrument')
                if not (0 <= instrument[x+1] < 128):
                    instrument[x+1] = cfg.get_int('config/preferred_instrument_velocity')
        else:
            raise "FIXME"
        return instrument


class DictationLessonfile(LessonfileCommon):
    def __init__(self, filename, teacher):
        LessonfileCommon.__init__(self, teacher)
        self.parse_file(filename)
    def get_breakpoints(self):
        assert self._idx is not None
        r = []
        if self.m_questions[self._idx].has_key('breakpoints'):
            r = self.m_questions[self._idx]['breakpoints']
            if not type(r) == type([]):
                r = [r]
        r = map(lambda e: Rat(e[0], e[1]), r)
        return r
    def get_clue_end(self):
        assert self._idx is not None
        if self.m_questions[self._idx].has_key('clue_end'):
            return apply(Rat, self.m_questions[self._idx]['clue_end'])
    def get_clue_music(self):
        assert self._idx is not None
        if self.m_questions[self._idx].has_key('clue_music'):
            return self.m_questions[self._idx]['clue_music']
    def select_previous(self):
        """
        Select the previous question. Do nothing if we are on the first
        question.
        """
        assert self._idx is not None
        if self._idx > 0:
            self._idx = self._idx - 1
    def select_next(self):
        """
        Select the next question. Do nothing if we are on the last question.
        """
        assert self._idx is not None
        if self._idx < len(self.m_questions) -1:
            self._idx = self._idx + 1
    def select_first(self):
        """
        Select the first question.
        """
        self._idx = 0

class SingChordLessonfile(LessonfileCommon):
    def __init__(self, filename, teacher):
        LessonfileCommon.__init__(self, teacher)
        self.parse_file(filename)

class IdByNameLessonfile(LessonfileCommon):
    def __init__(self, filename, teacher):
        """
        teacher -- the teacher class contructing this lesson file class
        """
        LessonfileCommon.__init__(self, teacher)
        self.parse_file(filename)
    def parse_file(self, filename):
        super(IdByNameLessonfile, self).parse_file(filename)
        for question in self.m_questions:
            if not question.has_key('name'):
                print >> sys.stderr, "IdByNameLessonfile.parse_file: discarding question in the lessonfile '%s'\nbecause of missing 'name' variable" % filename
                continue

class SingAnswerLessonfile(LessonfileCommon):
    def __init__(self, filename, teacher):
        """
        teacher -- the teacher class contructing this lesson file class
        """
        LessonfileCommon.__init__(self, teacher)
        self.parse_file(filename)
    def parse_file(self, filename):
        # FIXME this method is only necessary if we to something in it.
        super(SingAnswerLessonfile, self).parse_file(filename)


class ChordLessonfile(LessonfileCommon):
    def __init__(self, filename, teacher):
        LessonfileCommon.__init__(self, teacher)
        self.parse_file(filename)
    def parse_file(self, filename):
        """
        Call ChordLessonfile.parse_file and after that set these variables:
        self.m_chord_types
        self.m_inversions
        self.m_toptone
        """
        super(ChordLessonfile, self).parse_file(filename)
        self.m_chord_types = {}
        self.m_inversions = []
        self.m_toptones = []
        for question in self.m_questions:
            self.m_chord_types[question.get_cname()] = question.get_name()

            # inversion
            if question.has_key('inversion') \
                    and question['inversion'] not in self.m_inversions:
                self.m_inversions.append(question['inversion'])
            # toptone
            if question.has_key('toptone') \
                    and question['toptone'] not in self.m_toptones:
                self.m_toptones.append(question['toptone'])
    def get_inversion(self):
        """
        Return the inversion of the currently selected question.
        Return 1 for root position, 3 for first inversion etc.
        Return -1 if no inversion info is set in the question.
        """
        assert self._idx is not None
        if self.m_questions[self._idx].has_key('inversion'):
             return self.m_questions[self._idx]['inversion']
        return -1
    def get_toptone(self):
        """
        Return the toptone of the currently question.
        Return -1 if no toptone info is set in the question.
        """
        assert self._idx is not None
        if self.m_questions[self._idx].has_key('toptone'):
            return self.m_questions[self._idx]['toptone']
        return -1

class LessonFileManager:
    def __init__(self):
        self.parse()
    def parse(self):
        self.m_db = {}
        self.m_invalid_files = []
        vim_tmpfile_re = re.compile("\..*\.swp")
        for collection in string.split(cfg.get_string("config/lessoncollections")):
            self.m_db[collection] = {}
            if not os.path.isdir(os.path.expanduser(cfg.get_string("lessoncollections/%s" % collection))):
                continue
            # filter out backup files
            v = filter(lambda x, r=vim_tmpfile_re: x[-1:] != '~' and not r.match(x), os.listdir(os.path.expanduser(cfg.get_string("lessoncollections/%s" % collection))))
            for filename in v:
                # since I usually run solfege from the source dir:
                if filename in ('CVS', 'Makefile', 'Makefile.in') \
                  or not os.path.isfile(self.get_complete_filename(collection, filename)):
                    continue
                try:
                    p = dataparser.Dataparser(predef, lessonfile_functions)
                    p.parse_file(self.get_complete_filename(collection, filename))
                except dataparser.DataparserException, e:
                    self.m_invalid_files.append((collection, filename))
                    print >> sys.stderr, "Discarding lessonfile '%s/%s' because the file contain errors:" % (collection, filename)
                    print >> sys.stderr, str(e)
                    continue
                c = p.header['content']
                if type(c) in types.StringTypes:
                    c = [c]
                for u in c:
                    if not self.m_db[collection].has_key(u):
                        self.m_db[collection][u] = []
                    if p.header.has_key('title'):
                        title = p.header['title']
                    else:
                        title = ""
                    self.m_db[collection][u].append({'filename': filename,
                                                     'title': title}
                                                )
        for collection in self.m_db.keys():
            for content in self.m_db[collection].keys():
                self.m_db[collection][content].sort()
        self.m_htmldoc = """<html><body><p>This list is updated each time
                you start Solfege. As you can see, Solfege need more
                lessonfiles. <a href="lessonfiles.html">Write one!</a>"""
        if self.m_invalid_files:
            self.m_htmldoc += "<h1>Files we failed to parse</h1><ul>"
            for collection, filename in self.m_invalid_files:
                self.m_htmldoc += "<li>%(filename)s in collection %(collection)s</li>" % {'collection': collection, 'filename': filename}
            self.m_htmldoc += "</ul>"
        for collection in self.m_db.keys():
            self.m_htmldoc = self.m_htmldoc + "<h1>collection: %s</h1>" % collection
            for use in self.m_db[collection].keys():
                self.m_htmldoc = self.m_htmldoc + "<h2>%s</h2><p>" % use
                for d in self.m_db[collection][use]:
                    fn = d['filename']
                    self.m_htmldoc = self.m_htmldoc + \
                      "<a href=\"solfege:practise/%s/%s/%s\">%s</a>\n" % (use, collection, fn, fn)
                self.m_htmldoc += "</p>"
        self.m_htmldoc = self.m_htmldoc + "</body></html>"
    def get_collections(self):
        """
        Return a list of available collections. 
        """
        return self.m_db.keys()
    def get_complete_filename(self, catalog, fn):
        """
        Return the absolute path to a file in a given collection
        """
        if not catalog:
            catalog = 'solfege'
        return os.path.expanduser(os.path.join(
         cfg.get_string('lessoncollections/%s' % catalog), fn))
    def get_filenames(self, collection, usetype):
        if self.m_db[collection].has_key(usetype):
            v = []
            for d in self.m_db[collection][usetype]:
                v.append(d['filename'])
            return v
        else:
            return []
    def get_info(self, collection, usetype):
        if self.m_db[collection].has_key(usetype):
            return self.m_db[collection][usetype]
        else:
            return []

if __name__ == '__main__':
    import time
    cfg.initialise(None, "default.config",
        "~/.solfegerc1.9")
    t1=time.clock()
    for n in range(10):
        #p = LessonfileCommon()
        #p.parse_file(sys.argv[1])
        p = LessonFileManager()
    t2 = time.clock()
    print t2-t1
    print _
