catalog.cpp

/*

    poedit, a wxWindows i18n catalogs editor

    ---------------
      catalog.cpp
    
      Translations catalog
    
      (c) Vaclav Slavik, 1999

*/


#ifdef __GNUG__
#pragma implementation
#endif

#include <wx/wxprec.h>

#include <stdio.h>
#include <wx/utils.h>
#include <wx/tokenzr.h>
#include <wx/log.h>
#include <wx/intl.h>
#include <wx/datetime.h>
#include <wx/config.h>
#include <wx/textfile.h>
#include <wx/strconv.h>
#include <wx/msgdlg.h>

#include "catalog.h"
#include "digger.h"
#include "gexecute.h"
#include "progressinfo.h"
#include "summarydlg.h"



#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(CatalogDataArray)


// textfile processing utilities:

// Read one line from file, remove all \r and \n characters, ignore empty lines
static wxString ReadTextLine(wxTextFile* f)
{
    wxString s;
    
    while (s.IsEmpty())
    {
        if (f->Eof()) return wxEmptyString;
        s = f->GetNextLine();
    }
    return s;
}


// If input begins with pattern, fill output with end of input (without pattern; strips trailing spaces) 
// and return true.
// Return false otherwise and don't touch output
static bool ReadParam(const wxString& input, const wxString& pattern, wxString& output)
{
    if (input.Length() < pattern.Length()) return false;
    
    for (unsigned i = 0; i < pattern.Length(); i++)
        if (input[i] != pattern[i]) return false;
    output = input.Mid(pattern.Length()).Strip(wxString::trailing);
    return true;
}
        
        
// parsers:

void CatalogParser::Parse()
{
    if (m_textFile->GetLineCount() == 0) return;

    wxString line, dummy;
    wxString mflags, mstr, mtrans, mcomment;
    wxArrayString mrefs;
    unsigned mlinenum;
    
    line = m_textFile->GetFirstLine();
    if (line.IsEmpty()) line = ReadTextLine(m_textFile);

    while (!line.IsEmpty())
    {
        // flags:
        if (ReadParam(line, _T("#, "), dummy))
        {
            mflags = _T("#, ") + dummy;
            line = ReadTextLine(m_textFile);
        }
        
        // references:
        if (ReadParam(line, _T("#: "), dummy))
        {
            wxStringTokenizer tkn(dummy, _T("\t\r\n "));
            while (tkn.HasMoreTokens())
                mrefs.Add(tkn.GetNextToken());
            line = ReadTextLine(m_textFile);
        }
        
        // msgid:
        else if (ReadParam(line, _T("msgid \""), dummy))
        {
            mstr = dummy.RemoveLast();
            mlinenum = m_textFile->GetCurrentLine() + 1;
            while (!(line = ReadTextLine(m_textFile)).IsEmpty())
            {
                if (line[0u] == _T('"') && line.Last() == _T('"'))
                    mstr += line.Mid(1, line.Length() - 2);
                else break;
            }
        }
        
        // msgstr:
        else if (ReadParam(line, _T("msgstr \""), dummy))
        {
            mtrans = dummy.RemoveLast();
            while (!(line = ReadTextLine(m_textFile)).IsEmpty())
            {
                if (line[0u] == _T('"') && line.Last() == _T('"'))
                    mtrans += line.Mid(1, line.Length() - 2);
                else break;
            }

            if (!OnEntry(mstr, mtrans, mflags, mrefs, mcomment, mlinenum))
                return;

            mcomment = mstr = mtrans = mflags = wxEmptyString;
            mrefs.Clear();
        }
        
        // comment:
        else if (line[0u] == _T('#'))
        {
            while (!line.IsEmpty() && line[0u] == _T('#') &&
                   (line.Length() < 2 || (line[1u] != _T(',') && line[1u] != _T(':'))))
            {
                mcomment << line << _T('\n');
                line = ReadTextLine(m_textFile);
            }
        }
        
        else
            line = ReadTextLine(m_textFile);
    }
}



class CharsetInfoFinder : public CatalogParser
{
    public:
        CharsetInfoFinder(wxTextFile *f) 
                : CatalogParser(f), m_charset(_T("iso-8859-1")) {}
        wxString GetCharset() const { return m_charset; }

    protected:
        wxString m_charset;
    
        virtual bool OnEntry(const wxString& msgid,
                             const wxString& msgstr,
                             const wxString& flags,
                             const wxArrayString& references,
                             const wxString& comment,
                             unsigned lineNumber);
};

bool CharsetInfoFinder::OnEntry(const wxString& msgid,
                                const wxString& msgstr,
                                const wxString& flags,
                                const wxArrayString& references,
                                const wxString& comment,
                                unsigned lineNumber)
{
    if (msgid.IsEmpty())
    {
        // gettext header:
        wxString mtrans = msgstr;
        mtrans.Replace(_T("\\n"), _T("\n"));
        wxStringTokenizer tkn(mtrans, _T("\n"));
        wxString ln2;

        while (tkn.HasMoreTokens())
        {
            ln2 = tkn.GetNextToken();
            if (ReadParam(ln2, _T("Content-Type: text/plain; charset="), 
                          m_charset))
            {
                if (m_charset == _T("CHARSET"))
                    m_charset = _T("iso-8859-1");
                return false; // stop parsing
            }
        }
    }
    return true;
}



class LoadParser : public CatalogParser
{
    public:
        LoadParser(Catalog *c, wxTextFile *f)
              : CatalogParser(f), m_catalog(c) {}

    protected:
        Catalog *m_catalog;
    
        virtual bool OnEntry(const wxString& msgid,
                             const wxString& msgstr,
                             const wxString& flags,
                             const wxArrayString& references,
                             const wxString& comment,
                             unsigned lineNumber);
};


bool LoadParser::OnEntry(const wxString& msgid,
                         const wxString& msgstr,
                         const wxString& flags,
                         const wxArrayString& references,
                         const wxString& comment,
                         unsigned lineNumber)
{
    if (msgid.IsEmpty())
    {
        // gettext header:
        wxString mtrans = msgstr;
        mtrans.Replace(_T("\\n"), _T("\n"));
        wxStringTokenizer tkn(mtrans, _T("\n"));
        wxString dummy2, ln2;

        while (tkn.HasMoreTokens())
        {
            ln2 = tkn.GetNextToken();
            ReadParam(ln2, _T("Project-Id-Version: "), m_catalog->m_header.Project);
            ReadParam(ln2, _T("POT-Creation-Date: "), m_catalog->m_header.CreationDate);
            ReadParam(ln2, _T("PO-Revision-Date: "), m_catalog->m_header.RevisionDate);
            if (ReadParam(ln2, _T("Last-Translator: "), dummy2))
            {
                wxStringTokenizer tkn2(dummy2, _T("<>"));
                if (tkn2.CountTokens() != 2) 
                    wxLogWarning(_("Corrupted translator record, please correct in Catalog/Settings"));
                m_catalog->m_header.Translator = tkn2.GetNextToken().Strip(wxString::trailing);
                m_catalog->m_header.TranslatorEmail = tkn2.GetNextToken();
            }
            if (ReadParam(ln2, _T("Language-Team: "), dummy2))
            {
                wxStringTokenizer tkn2(dummy2, _T("<>"));
                if (tkn2.CountTokens() != 2) 
                    wxLogWarning(_("Corrupted team record, please correct in Catalog/Settings"));
                m_catalog->m_header.Team = tkn2.GetNextToken().Strip(wxString::trailing);
                m_catalog->m_header.TeamEmail = tkn2.GetNextToken();
            }
        }
        m_catalog->m_header.Comment = comment;
    }
    else
    {
        CatalogData *d = new CatalogData(wxEmptyString, wxEmptyString);
        if (!flags.IsEmpty()) d->SetFlags(flags);
        d->SetString(msgid);
        d->SetTranslation(msgstr);
        d->SetComment(comment);
        d->SetLineNumber(lineNumber);
        for (size_t i = 0; i < references.GetCount(); i++)
            d->AddReference(references[i]);

        m_catalog->m_data->Put(msgid, d);
        m_catalog->m_dataArray.Add(d);
        m_catalog->m_count++;
    }
    return true;
}




// catalog class:

Catalog::Catalog()
{
    m_data = new wxHashTable(wxKEY_STRING);
    m_count = 0;
    m_isOk = true;
    m_header.BasePath = wxEmptyString;
}


Catalog::~Catalog() 
{
    Clear();
    delete m_data;
}


Catalog::Catalog(const wxString& po_file)
{
    m_data = NULL;
    m_count = 0;
    m_isOk = false;
    Load(po_file);
}


void Catalog::CreateNewHeader()
{
    HeaderData &dt = Header();
    
    wxDateTime timenow = wxDateTime::Now();
    int offs = wxDateTime::TimeZone(wxDateTime::Local).GetOffset();
    dt.CreationDate.Printf(_T("%s%s%02i%02i"),
                                 timenow.Format(_T("%Y-%m-%d %H:%M")).c_str(),
                                 (offs > 0) ? _T("+") : _T("-"),
                                 offs / 3600, (abs(offs) / 60) % 60);
    dt.RevisionDate = dt.CreationDate;

    dt.Language = wxEmptyString;
    dt.Project = wxEmptyString;
    dt.Team = wxEmptyString;
    dt.TeamEmail = wxEmptyString;
    dt.Charset = _T("utf-8");
    dt.Translator = wxConfig::Get()->Read(_T("translator_name"), wxEmptyString);
    dt.TranslatorEmail = wxConfig::Get()->Read(_T("translator_email"), wxEmptyString);
    dt.Keywords.Add(_T("_"));
    dt.Keywords.Add(_T("gettext"));
    dt.Keywords.Add(_T("gettext_noop"));
    dt.BasePath = _T(".");
}


bool Catalog::Load(const wxString& po_file)
{
    wxTextFile f;

    Clear();
    delete m_data; m_data = NULL;    
    m_count = 0;
    m_isOk = false;
    m_fileName = po_file;
    m_header.BasePath = wxEmptyString;

    /* Load extended information from .po.poedit file, if present: */
    
    if (wxFileExists(po_file + _T(".poedit")) && f.Open(po_file + _T(".poedit")))
    {
        wxString dummy;
        // poedit header (optional, we should be able to read any catalog):
        f.GetFirstLine();
        if (ReadParam(ReadTextLine(&f), _T("#. Number of items: "), dummy))
        {
            long sz;
            dummy.ToLong(&sz);
            if (sz == 0) sz = 500;
            m_data = new wxHashTable(wxKEY_STRING, 2 * sz /*optimal hash table size*/);
        }
        else
            m_data = new wxHashTable(wxKEY_STRING);
        ReadParam(ReadTextLine(&f), _T("#. Language: "), m_header.Language);
        ReadParam(ReadTextLine(&f), _T("#. Basepath: "), m_header.BasePath);

        if (ReadParam(ReadTextLine(&f), _T("#. Paths: "), dummy))
        {
            long sz;
            dummy.ToLong(&sz);
            for (; sz > 0; sz--)
            if (ReadParam(ReadTextLine(&f), _T("#.     "), dummy))
                m_header.SearchPaths.Add(dummy);
        }

        if (ReadParam(ReadTextLine(&f), _T("#. Keywords: "), dummy))
        {
            long sz;
            dummy.ToLong(&sz);
            for (; sz > 0; sz--)
            if (ReadParam(ReadTextLine(&f), _T("#.     "), dummy))
                m_header.Keywords.Add(dummy);
        }

        f.Close();
    }
    else
        m_data = new wxHashTable(wxKEY_STRING);


    /* Load the .po file: */

    if (!f.Open(po_file)) return false;
    
    CharsetInfoFinder charsetFinder(&f);
    charsetFinder.Parse();
    m_header.Charset = charsetFinder.GetCharset();

    f.Close();
    wxCSConv encConv(m_header.Charset);
    if (!f.Open(po_file, encConv)) return false;

    LoadParser parser(this, &f);
    parser.Parse();

    m_isOk = true;
    
    f.Close();
    
#if !wxUSE_UNICODE
    /* Convert loaded data from file's encoding to UTF-8 which is our
       internal representation (in Unicode mode, LoadParser
       converts the file to wide char representation): */
    if (wxStricmp(Header().Charset, _T("utf-8")) != 0)
    {
        for (size_t i = 0; i < m_dataArray.GetCount(); i++)
            m_dataArray[i].SetTranslation(wxString(
                m_dataArray[i].GetTranslation().wc_str(encConv),
                wxConvUTF8));
    }
#endif
    
    return true;
}


void Catalog::Clear()
{
    delete m_data; 
    m_dataArray.Empty();
    m_isOk = true;
    m_count = 0;
    m_data = new wxHashTable(wxKEY_STRING);
}


static bool CanEncodeToCharset(Catalog& catalog, const wxString& charset)
{
    if (charset == _T("utf-8") || charset == _T("UTF-8"))
        return true;

    wxCSConv conv(charset);
    size_t cnt = catalog.GetCount();
    for (size_t i = 0; i < cnt; i++)
    {
        const wxString& orig = catalog[i].GetTranslation();
        if (orig.IsEmpty())
            continue;
#if !wxUSE_UNICODE
        wxString trans = 
            wxString(orig.wc_str(wxConvUTF8), conv);
        if (!trans)
            return false;
#else
        if (!orig.mb_str(conv))
            return false;
#endif
        
    }
    return true;
}


static void GetCRLFBehaviour(wxTextFileType& type, bool& preserve)
{
    wxString format = wxConfigBase::Get()->Read(_T("crlf_format"), _T("unix"));

    if (format == _T("win")) type = wxTextFileType_Dos;
    else if (format == _T("mac")) type = wxTextFileType_Mac;
    else if (format == _T("native")) type = wxTextFile::typeDefault;
    else /* _T("unix") */ type = wxTextFileType_Unix;

    preserve = (bool)(wxConfigBase::Get()->Read(_T("keep_crlf"), true));
}

static void SaveMultiLines(wxTextFile &f, const wxString& text)
{
    wxStringTokenizer tkn(text, _T('\n'));
    while (tkn.HasMoreTokens())
        f.AddLine(tkn.GetNextToken());
}

/** Adds \n characters as neccesary for good-looking output
 */
static wxString FormatStringForFile(const wxString& text)
{
    wxString s;
    unsigned n_cnt = 0;
    int len = text.length();
    
    s.Alloc(len + 16);
    // Scan the string up to len-2 because we don't want to account for the
    // very last \n on the line:
    //       "some\n string \n"
    //                      ^
    //                      |
    //                      \--- = len-2
    int i;
    for (i = 0; i < len-2; i++)
    {
        if (text[i] == _T('\\') && text[i+1] == _T('n'))
        {
            n_cnt++;
            s << _T("\\n\"\n\"");
            i++;
        }
        else
            s << text[i];
    }
    // ...and add not yet processed characters to the string...
    for (; i < len; i++)
        s << text[i];
    
    if (n_cnt > 1)
        return _T("\"\n\"") + s;
    else
        return s;
}

bool Catalog::Save(const wxString& po_file, bool save_mo)
{
    CatalogData *data;
    wxString dummy;
    size_t i;
    int j;
    wxTextFileType crlfOrig, crlf;
    bool crlfPreserve;
    wxTextFile f;
    
    GetCRLFBehaviour(crlfOrig, crlfPreserve);

    /* Update information about last modification time: */
  
    wxDateTime timenow = wxDateTime::Now();
    int offs = wxDateTime::TimeZone(wxDateTime::Local).GetOffset();
    m_header.RevisionDate.Printf(_T("%s%s%02i%02i"),
                                 timenow.Format(_T("%Y-%m-%d %H:%M")).c_str(),
                                 (offs > 0) ? _T("+") : _T("-"),
                                 offs / 3600, (abs(offs) / 60) % 60);

    /* Detect CRLF format: */

    if (crlfPreserve && wxFileExists(po_file) && f.Open(po_file))
    {
        {
        wxLogNull null;
        crlf = f.GuessType();
        }
        if (crlf == wxTextFileType_None || crlf == wxTextFile::typeDefault)
            crlf = crlfOrig;
        f.Close();
    }
    else
        crlf = crlfOrig;
        

    /* If neccessary, save extended info into .po.poedit file: */

    if (!m_header.Language.IsEmpty() || 
        !m_header.BasePath.IsEmpty() || 
        m_header.SearchPaths.GetCount() > 0 ||
        m_header.Keywords.GetCount() > 0)
    {
        if (!wxFileExists(po_file + _T(".poedit")) || !f.Open(po_file + _T(".poedit")))
            if (!f.Create(po_file + _T(".poedit")))
                return false;
        for (j = f.GetLineCount() - 1; j >= 0; j--)
            f.RemoveLine(j);

        f.AddLine(_T("#. This catalog was generated by poedit"));
        dummy.Printf(_T("#. Number of items: %i"), GetCount());
        f.AddLine(dummy);
        f.AddLine(_T("#. Language: ") + m_header.Language);
        f.AddLine(_T("#. Basepath: ") + m_header.BasePath);

        dummy.Printf(_T("#. Paths: %i"), m_header.SearchPaths.GetCount());
        f.AddLine(dummy);
        for (i = 0; i < m_header.SearchPaths.GetCount(); i++)
            f.AddLine(_T("#.     ") + m_header.SearchPaths[i]);

        dummy.Printf(_T("#. Keywords: %i"), m_header.Keywords.GetCount());
        f.AddLine(dummy);
        for (i = 0; i < m_header.Keywords.GetCount(); i++)
            f.AddLine(_T("#.     ") + m_header.Keywords[i]);
        f.Write(crlf);
        f.Close();
    }


    /* Save .po file: */

    wxString charset(m_header.Charset);
    if (!charset)
        charset = _T("utf-8");
        
    if (!CanEncodeToCharset(*this, charset))
    {
        wxString msg;
        msg.Printf(_("The catalog couldn't be saved in '%s' charset as\nspecified in catalog settings. It was saved in UTF-8 instead\nand the setting was modified accordingly."), charset.c_str());
        wxMessageBox(msg, _("Error saving catalog"),
                     wxOK | wxICON_EXCLAMATION);
        charset = _T("utf-8");
        m_header.Charset = charset;
    }
   
    if (!wxFileExists(po_file) || !f.Open(po_file))
        if (!f.Create(po_file))
            return false;
    for (j = f.GetLineCount() - 1; j >= 0; j--)
        f.RemoveLine(j);

    SaveMultiLines(f, m_header.Comment);
    f.AddLine(_T("msgid \"\""));
    f.AddLine(_T("msgstr \"\""));
    f.AddLine(_T("\"Project-Id-Version: ") + m_header.Project + _T("\\n\""));
    f.AddLine(_T("\"POT-Creation-Date: ") + m_header.CreationDate + _T("\\n\""));
    f.AddLine(_T("\"PO-Revision-Date: ") + m_header.RevisionDate + _T("\\n\""));
    f.AddLine(_T("\"Last-Translator: ") + m_header.Translator + 
              _T(" <") + m_header.TranslatorEmail + _T(">\\n\""));
    f.AddLine(_T("\"Language-Team: ") + m_header.Team +
              _T(" <") + m_header.TeamEmail + _T(">\\n\""));
    f.AddLine(_T("\"MIME-Version: 1.0\\n\""));
    f.AddLine(_T("\"Content-Type: text/plain; charset=") + charset + _T("\\n\""));
    f.AddLine(_T("\"Content-Transfer-Encoding: 8bit\\n\""));
    f.AddLine(wxEmptyString);
    
    wxCSConv *encConv;
#if wxUSE_UNICODE
    encConv = new wxCSConv(charset);
#else
    if (wxStricmp(charset, _T("utf-8")) != 0)
        encConv = new wxCSConv(charset);
    else
        encConv = NULL;
#endif

    for (i = 0; i < m_dataArray.GetCount(); i++)
    {
        data = &(m_dataArray[i]);
        SaveMultiLines(f, data->GetComment());
        for (unsigned i = 0; i < data->GetReferences().GetCount(); i++)
            f.AddLine(_T("#: ") + data->GetReferences()[i]);
        dummy = data->GetFlags();
        if (!dummy.IsEmpty())
            f.AddLine(dummy);
        dummy = FormatStringForFile(data->GetString());
        data->SetLineNumber(f.GetLineCount()+1);
        SaveMultiLines(f, _T("msgid \"") + dummy + _T("\""));
        dummy = FormatStringForFile(data->GetTranslation());
#if !wxUSE_UNICODE
        if (encConv)
            dummy = wxString(dummy.wc_str(wxConvUTF8), *encConv);
#endif
        SaveMultiLines(f, _T("msgstr \"") + dummy + _T("\""));
        f.AddLine(wxEmptyString);
    }
    
#if wxUSE_UNICODE
    f.Write(crlf, *encConv);
#else
    f.Write(crlf);
#endif
    f.Close();
    delete encConv;    

    /* If user wants it, compile .mo file right now: */
    
    if (save_mo && wxConfig::Get()->Read(_T("compile_mo"), true))
        ExecuteGettext(_T("msgfmt -o \"") + 
                       po_file.BeforeLast(_T('.')) + _T(".mo\" \"") + po_file + _T("\""));

    m_fileName = po_file;
    
    return true;
}


bool Catalog::Update()
{
    if (!m_isOk) return false;

    ProgressInfo pinfo;
    pinfo.SetTitle(_("Updating catalog..."));

    wxString cwd = wxGetCwd();
    if (m_fileName != wxEmptyString) 
    {
        wxString path;
        
        if (wxIsAbsolutePath(m_header.BasePath))
            path = m_header.BasePath;
        else
            path = wxPathOnly(m_fileName) + _T("/") + m_header.BasePath;
        
        if (wxIsAbsolutePath(path))
            wxSetWorkingDirectory(path);
        else
            wxSetWorkingDirectory(cwd + _T("/") + path);
    }
    
    SourceDigger dig(&pinfo);
    Catalog *newcat = dig.Dig(m_header.SearchPaths, m_header.Keywords);

    if (newcat != NULL) 
    {
        pinfo.UpdateMessage(_("Merging differences..."));

        if (wxConfig::Get()->Read(_T("show_summary"), true))
        {
            wxArrayString snew, sobsolete;
            GetMergeSummary(newcat, snew, sobsolete);
            MergeSummaryDialog sdlg;
            sdlg.TransferTo(snew, sobsolete);
            if (sdlg.ShowModal() == wxID_OK)
                Merge(newcat);
            else
            {
                delete newcat; newcat = NULL;
            }
        }
        else
            Merge(newcat);
    }
    
    wxSetWorkingDirectory(cwd);
    
    if (newcat == NULL) return false;
  
    delete newcat;
    return true;
}


void Catalog::Merge(Catalog *refcat)
{
    wxString oldname = m_fileName;
    wxString tmp1 = wxGetTempFileName(_T("poedit"));
    wxString tmp2 = wxGetTempFileName(_T("poedit"));
    wxString tmp3 = wxGetTempFileName(_T("poedit"));

    refcat->Save(tmp1, false);
    Save(tmp2, false);
    
    ExecuteGettext(_T("msgmerge --force-po -o \"") + tmp3 + _T("\" \"") + 
                   tmp2 + _T("\" \"") + tmp1 + _T("\""));

    Catalog *c = new Catalog(tmp3);
    Clear();
    Append(*c);
    delete c;

    wxRemoveFile(tmp1);
    wxRemoveFile(tmp2);
    wxRemoveFile(tmp3);
    wxRemoveFile(tmp1 + _T(".poedit"));
    wxRemoveFile(tmp2 + _T(".poedit"));
    
    m_fileName = oldname;
}


void Catalog::GetMergeSummary(Catalog *refcat, 
                          wxArrayString& snew, wxArrayString& sobsolete)
{
    snew.Empty();
    sobsolete.Empty();
    unsigned i;
    
    for (i = 0; i < GetCount(); i++)
        if (refcat->FindItem((*this)[i].GetString()) == NULL)
        sobsolete.Add((*this)[i].GetString());

    for (i = 0; i < refcat->GetCount(); i++)
        if (FindItem((*refcat)[i].GetString()) == NULL)
        snew.Add((*refcat)[i].GetString());
}


CatalogData* Catalog::FindItem(const wxString& key) const
{
    return (CatalogData*) m_data->Get(key);
}


bool Catalog::Translate(const wxString& key, const wxString& translation)
{
    CatalogData *d = FindItem(key);
    
    if (d == NULL) 
        return false;
    else
    {
        d->SetTranslation(translation);
        return true;
    }
}


void Catalog::Append(Catalog& cat)
{
    CatalogData *dt, *mydt;
    
    for (unsigned i = 0; i < cat.GetCount(); i++)
    {
        dt = &(cat[i]);
        mydt = FindItem(dt->GetString());
        if (mydt == NULL)
        {
            mydt = new CatalogData(*dt);
            m_data->Put(dt->GetString(), mydt);
            m_dataArray.Add(mydt);
            m_count++;
        }
        else
        {
            for (unsigned j = 0; j < dt->GetReferences().GetCount(); j++)
                mydt->AddReference(dt->GetReferences()[j]);
            if (!dt->GetTranslation().IsEmpty())
                mydt->SetTranslation(dt->GetTranslation());
            if (dt->IsFuzzy()) mydt->SetFuzzy(true);
        }
    }
}


void Catalog::GetStatistics(int *all, int *fuzzy, int *untranslated)
{
    if (all) *all = 0;
    if (fuzzy) *fuzzy = 0;
    if (untranslated) *untranslated = 0;
    for (size_t i = 0; i < GetCount(); i++)
    {
        if (all) (*all)++;
        if ((*this)[i].IsFuzzy()) (*fuzzy)++;
        if (!(*this)[i].IsTranslated()) (*untranslated)++;
    }
}


void CatalogData::SetFlags(const wxString& flags)
{
    m_isFuzzy = false;
    m_moreFlags.Empty();
    
    if (flags.IsEmpty()) return;
    wxStringTokenizer tkn(flags.Mid(1), _T(" ,"), wxTOKEN_STRTOK);
    wxString s;
    while (tkn.HasMoreTokens())
    {
        s = tkn.GetNextToken();
        if (s == _T("fuzzy")) m_isFuzzy = true;
        else m_moreFlags << _T(", ") << s;
    }
}


wxString CatalogData::GetFlags() const
{
    wxString f;
    if (m_isFuzzy) f << _T(", fuzzy");
    f << m_moreFlags;
    if (!f.IsEmpty()) 
        return _T("#") + f;
    else 
        return wxEmptyString;
}