summaryrefslogtreecommitdiffstats
path: root/kbabel/common/catalog.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitbd9e6617827818fd043452c08c606f07b78014a0 (patch)
tree425bb4c3168f9c02f10150f235d2cb998dcc6108 /kbabel/common/catalog.cpp
downloadtdesdk-bd9e6617827818fd043452c08c606f07b78014a0.tar.gz
tdesdk-bd9e6617827818fd043452c08c606f07b78014a0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdesdk@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kbabel/common/catalog.cpp')
-rw-r--r--kbabel/common/catalog.cpp3509
1 files changed, 3509 insertions, 0 deletions
diff --git a/kbabel/common/catalog.cpp b/kbabel/common/catalog.cpp
new file mode 100644
index 00000000..ffd939b7
--- /dev/null
+++ b/kbabel/common/catalog.cpp
@@ -0,0 +1,3509 @@
+/* ****************************************************************************
+ This file is part of KBabel
+
+ Copyright (C) 1999-2000 by Matthias Kiefer <matthias.kiefer@gmx.de>
+ 2001-2005 by Stanislav Visnovsky <visnovsky@kde.org>
+ Copyright (C) 2006 by Nicolas GOUTTE <goutte@kde.org>
+
+ 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ In addition, as a special exception, the copyright holders give
+ permission to link the code of this program with any edition of
+ the Qt library by Trolltech AS, Norway (or with modified versions
+ of Qt that use the same license as Qt), and distribute linked
+ combinations including the two. You must obey the GNU General
+ Public License in all respects for all of the code used other than
+ Qt. If you modify this file, you may extend this exception to
+ your version of the file, but you are not obligated to do so. If
+ you do not wish to do so, delete this exception statement from
+ your version.
+
+**************************************************************************** */
+#include <qtextstream.h>
+#include <qfile.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+#include <qstring.h>
+#include <qtextcodec.h>
+#include <qdatetime.h>
+
+#include <kconfig.h>
+#include <kdatatool.h>
+#include <kglobal.h>
+#include <klibloader.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kmimetype.h>
+#include <kapplication.h>
+#include <kio/netaccess.h>
+#include <krfcdate.h>
+#include <ktrader.h>
+#include <kurl.h>
+
+#include "kbprojectmanager.h"
+#include "catalog.h"
+#include "catalog_private.h"
+#include "catalogitem.h"
+#include "diff.h"
+#include "findoptions.h"
+#include "catalogview.h"
+#include "editcmd.h"
+#include "kbprojectsettings.h"
+
+#include "resources.h"
+#include "version.h"
+#include "stringdistance.h"
+
+#include <kmessagebox.h>
+using namespace KBabel;
+
+Catalog::Catalog(QObject* parent, const char* name, QString projectFile)
+ : QObject(parent,name)
+{
+ if ( projectFile.isEmpty() )
+ projectFile = KBabel::ProjectManager::defaultProjectName();
+ d = new CatalogPrivate(ProjectManager::open(projectFile));
+ readPreferences();
+}
+
+Catalog::Catalog(const Catalog& c): QObject(c.parent(),c.name()
+)
+{
+ kdFatal() << "Copy constructor of Catalog, please report how to reproduce to the authors" << endl;
+}
+
+Catalog::~Catalog()
+{
+ delete d;
+}
+
+QString Catalog::msgctxt(uint index) const
+{
+ if ( d->_entries.isEmpty() )
+ return QString::null;
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+ return d->_entries[index].msgctxt();
+}
+
+QStringList Catalog::msgid(uint index, const bool noNewlines) const
+{
+ if ( d->_entries.isEmpty() )
+ return QString::null;
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ return d->_entries[index].msgid(noNewlines);
+}
+
+QStringList Catalog::msgstr(uint index, const bool noNewlines) const
+{
+ if ( d->_entries.isEmpty() )
+ return QString::null;
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ return d->_entries[index].msgstr(noNewlines);
+}
+
+QString Catalog::comment(uint index) const
+{
+ if ( d->_entries.isEmpty() )
+ return QString::null;
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+ return d->_entries[index].comment();
+}
+
+QString Catalog::context(uint index) const
+{
+ QString c = comment(index);
+
+ QStringList lines = QStringList::split("\n",c);
+
+ QString result;
+ for( QStringList::Iterator it=lines.begin(); it!=lines.end(); ++it)
+ {
+ if( (*it).startsWith( "#:") )
+ {
+ result+=(*it)+"\n";
+ }
+ }
+ return result.stripWhiteSpace();
+}
+
+CatalogItem Catalog::header() const
+{
+ return d->_header;
+}
+
+QString Catalog::lastTranslator() const
+{
+ return headerInfo( d->_header ).lastTranslator;
+}
+
+int Catalog::indexForMsgid(const QString& id) const
+{
+ int i=0;
+ QValueVector<CatalogItem>::ConstIterator it = d->_entries.begin();
+
+ while(it != d->_entries.end() && !((*it).msgid(true).contains(id)))
+ {
+ ++it;
+ i++;
+ }
+
+ if(it == d->_entries.end())
+ i=-1;
+
+ return i;
+}
+
+QStringList Catalog::tagList(uint index)
+{
+ if ( d->_entries.isEmpty() )
+ return QStringList();
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ return d->_entries[index].tagList(*(d->_tagExtractor));
+}
+
+
+QStringList Catalog::argList(uint index)
+{
+ if ( d->_entries.isEmpty() )
+ return QStringList();
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ return d->_entries[index].argList(*(d->_argExtractor));
+}
+
+
+/*
+bool Catalog::setMsgstr(uint index,QString msgstr)
+{
+ kdWarning() << "Catalog::setMsgstr()" << endl;
+
+ bool untranslatedChanged=false;
+
+ if(_entries[index].isUntranslated() && !msgstr.isEmpty())
+ {
+ _untransIndex.remove(index);
+ untranslatedChanged=true;
+ }
+ else if(msgstr.isEmpty())
+ {
+ QValueList<uint>::Iterator it;
+
+ // insert index in the right place in the list
+ it = _untransIndex.begin();
+ while(it != _untransIndex.end() && index > (*it))
+ {
+ ++it;
+ }
+ _untransIndex.insert(it,index);
+
+ untranslatedChanged=true;
+ }
+
+ _entries[index].setMsgstr(msgstr);
+
+ setModified(true);
+
+ if(untranslatedChanged)
+ emit signalNumberOfUntranslatedChanged(numberOfUntranslated());
+
+ return untranslatedChanged;
+}
+*/
+
+/*
+bool Catalog::setComment(uint index,QString comment)
+{
+ kdWarning() << "Catalog::setComment()" << endl;
+ bool fuzziesChanged=false;
+
+
+ bool wasFuzzy=_entries[index].isFuzzy();
+
+ _entries[index].setComment(comment);
+
+ bool isFuzzy=_entries[index].isFuzzy();
+
+ if(wasFuzzy && !isFuzzy)
+ {
+ _fuzzyIndex.remove(index);
+ fuzziesChanged=true;
+ }
+ else if(isFuzzy)
+ {
+ QValueList<uint>::Iterator it;
+
+ // insert index in the right place in the list
+ it = _fuzzyIndex.begin();
+ while(it != _fuzzyIndex.end() && index > (*it))
+ {
+ ++it;
+ }
+ _fuzzyIndex.insert(it,index);
+
+ fuzziesChanged=true;
+ }
+
+ setModified(true);
+
+ if(fuzziesChanged)
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+
+
+ return fuzziesChanged;
+}
+*/
+
+bool Catalog::setHeader(CatalogItem newHeader)
+{
+ if(newHeader.isValid())
+ {
+ // normalize the values - ensure every key:value pair is only on a single line
+ QString values = newHeader.msgstr().first();
+ values.replace ("\n", "");
+ values.replace ("\\n", "\\n\n");
+
+ kdDebug () << "Normalized header: " << values << endl;
+
+ d->_header=newHeader;
+ d->_header.setMsgstr (values);
+
+ setModified(true);
+
+ emit signalHeaderChanged();
+
+ return true;
+ }
+
+ return false;
+}
+
+KURL Catalog::currentURL() const
+{
+ return d->_url;
+}
+
+void Catalog::setCurrentURL(const KURL& url)
+{
+ d->_url=url;
+}
+
+
+CatalogItem Catalog::updatedHeader(CatalogItem oldHeader, bool usePrefs) const
+{
+ QStringList headerList=oldHeader.msgstrAsList();
+ QStringList commentList=QStringList::split('\n',oldHeader.comment());
+
+ QStringList::Iterator it,ait;
+ QString temp;
+ bool found;
+
+ const IdentitySettings identityOptions = identitySettings();
+ const SaveSettings saveOptions = saveSettings();
+
+ if(!usePrefs || saveOptions.updateLastTranslator)
+ {
+ found=false;
+
+ temp="Last-Translator: "+identityOptions.authorName;
+ if(!identityOptions.authorEmail.isEmpty())
+ {
+ temp+=(" <"+identityOptions.authorEmail+">");
+ }
+ temp+="\\n";
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *Last-Translator:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+ if(!usePrefs || saveOptions.updateRevisionDate)
+ {
+ found=false;
+
+ temp="PO-Revision-Date: "+dateTime()+"\\n";
+
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *PO-Revision-Date:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+ if(!usePrefs || saveOptions.updateProject)
+ {
+ found=false;
+
+ temp="Project-Id-Version: "+saveOptions.projectString+"\\n";
+ temp.replace( "@PACKAGE@", packageName());
+
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *Project-Id-Version:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+ if(!usePrefs || saveOptions.updateLanguageTeam)
+ {
+ found=false;
+
+ temp="Language-Team: "+identityOptions.languageName;
+ if(!identityOptions.mailingList.isEmpty())
+ {
+ temp+=(" <"+identityOptions.mailingList+">");
+ }
+ temp+="\\n";
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *Language-Team:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+ if(!usePrefs || saveOptions.updateCharset)
+ {
+
+ found=false;
+
+ QString encodingStr;
+ if(saveOptions.useOldEncoding && d->fileCodec)
+ {
+ encodingStr = charsetString(d->fileCodec);
+ }
+ else
+ {
+ encodingStr=charsetString(saveOptions.encoding);
+ }
+
+ temp = "Content-Type: text/plain; charset=" + encodingStr + "\\n";
+
+ it = headerList.begin();
+ while( it != headerList.end() )
+ {
+ if( (*it).find( QRegExp( "^ *Content-Type:.*" ) ) != -1 )
+ {
+ if ( found )
+ {
+ // We had already a Content-Type, so we do not need a duplicate
+ it = headerList.remove( it );
+ }
+ else
+ {
+ found=true;
+ QRegExp regexp( "^ *Content-Type:(.*/.*);?\\s*charset=.*$" );
+ QString mimeType;
+ if ( regexp.search( *it ) )
+ {
+ mimeType = regexp.cap( 1 ).stripWhiteSpace();
+ }
+ if ( mimeType.isEmpty() )
+ {
+ mimeType = "text/plain";
+ }
+ temp = "Content-Type: ";
+ temp += mimeType;
+ temp += "; charset=";
+ temp += encodingStr;
+ temp += "\\n";
+ (*it) = temp;
+ }
+ }
+ ++it;
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+ if(!usePrefs || saveOptions.updateEncoding)
+ {
+ found=false;
+
+ temp="Content-Transfer-Encoding: 8bit\\n";
+
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *Content-Transfer-Encoding:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+ }
+
+ temp="X-Generator: KBabel %1\\n";
+ temp=temp.arg(VERSION);
+ found=false;
+
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *X-Generator:.*")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if(!found)
+ {
+ headerList.append(temp);
+ }
+
+ // ensure MIME-Version header
+ temp="MIME-Version: 1.0\\n";
+ found=false;
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *MIME-Version:")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if( !found )
+ {
+ headerList.append(temp);
+ }
+
+
+ temp="Plural-Forms: %1\\n";
+ temp=temp.arg(identityOptions.gnuPluralFormHeader);
+ found=false;
+
+ // update plural form header
+ if( !identityOptions.gnuPluralFormHeader.isEmpty() )
+ {
+ for( it = headerList.begin(); it != headerList.end(); ++it )
+ {
+ if((*it).contains(QRegExp("^ *Plural-Forms:")))
+ {
+ (*it) = temp;
+ found=true;
+ break;
+ }
+ }
+ if( !found )
+ {
+ headerList.append(temp);
+ }
+ }
+
+ oldHeader.setMsgstr( headerList.join( "\n" ) );
+
+ //comment = description, copyrights
+ if(!usePrefs || (saveOptions.FSFCopyright != ProjectSettingsBase::NoChange))
+ {
+ found=false;
+
+ for( it = commentList.begin(); it != commentList.end(); ++it )
+ {
+ // U+00A9 is the Copyright sign
+ if ( (*it).find( QRegExp("^# *Copyright (\\(C\\)|\\x00a9).*Free Software Foundation, Inc") ) != -1 )
+ {
+ found=true;
+ break;
+ }
+ }
+ if(found)
+ {
+ if ( (*it).find( QRegExp("^# *Copyright (\\(C\\)|\\x00a9) YEAR Free Software Foundation, Inc\\.") ) != -1 )
+ {
+ //template string
+ if( saveOptions.FSFCopyright == ProjectSettingsBase::Remove)
+ (*it).remove(" YEAR Free Software Foundation, Inc");
+ else
+ (*it).replace("YEAR", QDate::currentDate().toString("yyyy"));
+ } else
+ if( saveOptions.FSFCopyright == ProjectSettingsBase::Update )
+ {
+ //update years
+ QString cy = QDate::currentDate().toString("yyyy");
+ if( !(*it).contains( QRegExp(cy)) ) // is the year already included?
+ {
+ int index = (*it).findRev( QRegExp("[\\d]+[\\d\\-, ]*") );
+ if( index == -1 )
+ {
+ KMessageBox::information(0,i18n("Free Software Foundation Copyright does not contain any year. "
+ "It will not be updated."));
+ } else {
+ (*it).insert(index+1, QString(", ")+cy);
+ }
+ }
+ }
+ }
+ }
+
+ if ( ( !usePrefs || saveOptions.updateDescription )
+ && ( !saveOptions.descriptionString.isEmpty() ) )
+ {
+ temp = "# "+saveOptions.descriptionString;
+ temp.replace( "@PACKAGE@", packageName());
+ temp.replace( "@LANGUAGE@", identityOptions.languageName);
+ temp = temp.stripWhiteSpace();
+
+ // The description strings has often buggy variants already in the file, these must be removed
+ QString regexpstr = "^#\\s+" + QRegExp::escape( saveOptions.descriptionString.stripWhiteSpace() ) + "\\s*$";
+ regexpstr.replace( "@PACKAGE@", ".*" );
+ regexpstr.replace( "@LANGUAGE@", ".*" );
+ //kdDebug() << "REGEXPSTR: " << regexpstr << endl;
+ QRegExp regexp ( regexpstr );
+
+ // The buggy variants exist in English too (of a time before KBabel got a translation for the corresponding language)
+ QRegExp regexpUntranslated ( "^#\\s+Translation of .* into .*\\s*$" );
+
+ kdDebug () << "Temp is '" << temp << "'" << endl;
+
+ found=false;
+//not used anyway bool foundTemplate=false;
+
+ it = commentList.begin();
+ while ( it != commentList.end() )
+ {
+ kdDebug () << "testing '" << (*it) << "'" << endl;
+ bool deleteItem = false;
+
+ if ( (*it) == temp )
+ {
+ kdDebug () << "Match " << endl;
+ if ( found )
+ deleteItem = true;
+ else
+ found=true;
+ }
+ else if ( regexp.search( *it ) >= 0 )
+ {
+ // We have a similar (translated) string (from another project or another language (perhaps typos)). Remove it.
+ deleteItem = true;
+ }
+ else if ( regexpUntranslated.search( *it ) >= 0 )
+ {
+ // We have a similar (untranslated) string (from another project or another language (perhaps typos)). Remove it.
+ deleteItem = true;
+ }
+ else if ( (*it) == "# SOME DESCRIPTIVE TITLE." )
+ {
+ // We have the standard title placeholder, remove it
+ deleteItem = true;
+ }
+
+ if ( deleteItem )
+ it = commentList.remove( it );
+ else
+ ++it;
+ }
+ if(!found) commentList.prepend(temp);
+ }
+
+ // kdDebug() << "HEADER COMMENT: " << commentList << endl;
+
+ if ( (!usePrefs || saveOptions.updateTranslatorCopyright)
+ && ( ! identityOptions.authorName.isEmpty() )
+ && ( ! identityOptions.authorEmail.isEmpty() ) ) // An email address can be used as ersatz of a name
+ {
+ QStringList foundAuthors;
+
+ temp = "# ";
+ temp += identityOptions.authorName;
+ if(!identityOptions.authorEmail.isEmpty())
+ {
+ temp+=(" <"+identityOptions.authorEmail+">");
+ }
+ temp+=", "+QDate::currentDate().toString("yyyy")+".";
+
+ // ### TODO: it would be nice if the entry could start with "COPYRIGHT" and have the "(C)" symbol (both not mandatory)
+ QRegExp regexpAuthorYear( "^#.*(<.+@.+>)?,\\s*([\\d]+[\\d\\-, ]*|YEAR)" );
+ QRegExp regexpYearAlone( "^# , \\d{4}.?\\s*$" );
+ it = commentList.begin();
+ while ( it != commentList.end() )
+ {
+ bool deleteItem = false;
+ if ( (*it).find ( "copyright", 0, false ) != -1 )
+ {
+ // We have a line with a copyright. It should not be moved.
+ }
+ else if ( (*it).find ( regexpYearAlone ) != -1 )
+ {
+ // We have found a year number that is preceeded by a comma.
+ // That is typical of KBabel 1.10 (and earlier?) when there is neither an author name nor an email
+ // Remove the entry
+ deleteItem = true;
+ }
+ else if ( (*it) == "# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR." )
+ {
+ // Typical placeholder, remove it.
+ deleteItem = true;
+ }
+ else if ( (*it).find ( regexpAuthorYear ) != -1 ) // email address followed by year
+ {
+ if ( foundAuthors.find( (*it) ) == foundAuthors.end() )
+ {
+ // The author line is new (and not a duplicate), so add it to the author line list
+ foundAuthors.append( (*it) );
+ }
+ // Delete also non-duplicated entry, as now all what is needed will be processed in foundAuthors
+ deleteItem = true;
+ }
+
+ if ( deleteItem )
+ it = commentList.remove( it );
+ else
+ ++it;
+ }
+
+ if( !foundAuthors.isEmpty() )
+ {
+ found = false;
+ bool foundAuthor = false;
+
+ const QString cy = QDate::currentDate().toString("yyyy");
+
+ ait = foundAuthors.end();
+ for( it = foundAuthors.begin() ; it!=foundAuthors.end(); ++it )
+ {
+ if ( (*it).find( QRegExp(
+ QRegExp::escape( identityOptions.authorName )+".*"
+ + QRegExp::escape( identityOptions.authorEmail ) ) ) != -1 )
+ {
+ foundAuthor = true;
+ if( (*it).find( cy ) != -1 )
+ found = true;
+ else
+ ait = it;
+ }
+ }
+ if( !found )
+ {
+ if ( !foundAuthor )
+ foundAuthors.append(temp);
+ else if ( ait != foundAuthors.end() )
+ {
+ //update years
+ const int index = (*ait).findRev( QRegExp("[\\d]+[\\d\\-, ]*") );
+ if ( index == -1 )
+ (*ait)+=", "+cy;
+ else
+ (*ait).insert(index+1, QString(", ")+cy);
+ }
+ else
+ kdDebug() << "INTERNAL ERROR: author found but iterator dangling!" << endl;
+ }
+
+ }
+ else
+ foundAuthors.append(temp);
+ it=commentList.end();
+ do
+ --it;
+ while( ( it != commentList.begin() ) && ( (*it).find( QRegExp( "^#(\\s*$|[:,\\.])" ) ) == -1 ) );
+ ++it;
+ for( ait = foundAuthors.begin() ; ait != foundAuthors.end() ; ++ait )
+ {
+ QString s = (*ait);
+
+ // ensure dot at the end of copyright
+ if( !s.endsWith(".") ) s += ".";
+ commentList.insert(it, s);
+ }
+ }
+
+ oldHeader.setComment( commentList.join( "\n" ) );
+
+ return oldHeader;
+}
+
+void Catalog::setFuzzy(uint index, bool on)
+{
+ if ( d->_entries.isEmpty() )
+ return;
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ return;
+
+ if(d->_entries[index].isFuzzy() != on)
+ {
+ applyBeginCommand( index, Comment, 0 );
+
+ QPtrList<EditCommand> editList;
+ if(on)
+ {
+ editList=d->_entries[index].addFuzzy(false);
+ }
+ else
+ {
+ editList=d->_entries[index].removeFuzzy(false);
+ d->_fuzzyIndex.remove(index);
+ }
+
+ for ( EditCommand* cmd=editList.first(); cmd != 0; cmd=editList.next() )
+ {
+ cmd->setIndex(index);
+ applyEditCommand(cmd,0);
+ }
+
+ setModified(true);
+
+ applyEndCommand( index, Comment, 0 );
+
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+ }
+
+}
+
+void Catalog::removeFuzzyStatus(uint index)
+{
+ setFuzzy(index,false);
+}
+
+
+void Catalog::setModified(bool flag)
+{
+ bool old=d->_modified;
+ d->_modified=flag;
+
+ if(old!=d->_modified)
+ emit signalModified(flag);
+}
+
+
+QString Catalog::packageName() const
+{
+ if( !d->_packageName.isNull() ) return d->_packageName;
+
+ QString package=d->_url.fileName();
+
+ int index=package.find(QRegExp("(\\."+identitySettings().languageCode+")?\\.pot?$"));
+
+ if(index>0)
+ package=package.left(index);
+
+ return package;
+}
+
+void Catalog::setPackage(const QString& package )
+{
+ const int pos = package.findRev( '/' );
+ if( pos < 0 )
+ {
+ d->_packageDir = QString();
+ d->_packageName = package;
+ }
+ else
+ {
+ d->_packageDir = package.left( pos + 1 ); // We want the / included
+ d->_packageName = package.mid( pos + 1 ); // We do not want /
+ }
+ kdDebug() << k_funcinfo << " " << package << " => " << d->_packageDir << " + " << d->_packageName << endl;
+}
+
+QString Catalog::packageDir() const
+{
+ QString result;
+ if( !d->_packageDir.isNull() ) result=d->_packageDir;
+ else result=d->_url.directory(false);
+
+ return result;
+}
+
+QString Catalog::encoding() const
+{
+ SaveSettings options = saveSettings();
+
+ QString encodingStr;
+ if(options.useOldEncoding && d->fileCodec)
+ {
+ encodingStr = charsetString(d->fileCodec);
+ }
+ else
+ {
+ encodingStr= charsetString(options.encoding);
+ }
+
+ return encodingStr;
+}
+
+ConversionStatus Catalog::openURL(const KURL& url, const QString& package)
+{
+ QString target;
+ ConversionStatus error = OK;
+
+ if(KIO::NetAccess::download(url, target, NULL))
+ {
+ CatalogImportPlugin* filter=0;
+
+ // gimme plugin for this MIME type
+ KMimeType::Ptr mime = KMimeType::findByURL( url, 0, true );
+ kdDebug() << "Found mimetype: " << mime->name() << endl;
+ KTrader::OfferList offers = KTrader::self()->query("KBabelFilter", "('"+mime->name()+"' in [X-KDE-Import])");
+ KService::Ptr ptr = offers.first();
+
+ // we have no offer for this MIME type
+ if( !ptr )
+ {
+ kdDebug(KBABEL) << "No plugin for this type, will try PO" << endl;
+ offers = KTrader::self()->query("KBabelFilter", "('application/x-gettext' in [X-KDE-Import])");
+ ptr = offers.first();
+ if( !ptr )
+ {
+ kdDebug(KBABEL) << "No plugin for PO files, giving up" << endl;
+ KIO::NetAccess::removeTempFile(target);
+ return NO_PLUGIN;
+ }
+ }
+
+ // try to load the library, if unsuccesfull, we have an installation problem
+ KLibFactory *factory = KLibLoader::self()->factory( ptr->library().local8Bit() );
+ if (!factory)
+ {
+ kdDebug(KBABEL) << "No factory" << endl;
+ KIO::NetAccess::removeTempFile(target);
+ return OS_ERROR;
+ }
+
+ // create the filter
+ filter = static_cast<CatalogImportPlugin*>(factory->create(0, 0));
+
+ // provide progress bar indication
+ connect( filter, SIGNAL( signalResetProgressBar(QString,int) ),
+ this, SIGNAL( signalResetProgressBar(QString,int) ));
+ connect( filter, SIGNAL( signalProgress(int) ),
+ this, SIGNAL( signalProgress(int) ));
+ connect( filter, SIGNAL( signalClearProgressBar() ),
+ this, SIGNAL( signalClearProgressBar() ));
+
+ connect( this, SIGNAL( signalStopActivity() ),
+ filter, SLOT( stop() ));
+
+ // load in the file (target is always local)
+ d->_active = true;
+ kdDebug(KBABEL) << "openURL active" << endl;
+ error = filter->open(target,mime->name(),this);
+ // we should be not freed yet
+ d->_active = false;
+ kdDebug(KBABEL) << "openURL not active" << endl;
+ if( error == STOPPED )
+ {
+ delete filter;
+ return STOPPED;
+ }
+
+ if( error == OK || error == RECOVERED_PARSE_ERROR || error == RECOVERED_HEADER_ERROR )
+ {
+ const uint entries = numberOfEntries();
+
+ if ( !entries )
+ {
+ // KBabel cannot work correctly with not any entry
+ kdWarning() << k_funcinfo << " No entries! Assuming parse error!" << endl;
+ delete filter;
+ return NO_ENTRY_ERROR;
+ }
+
+ //kdDebug( KBABEL ) << k_funcinfo << " Success (full or partial) " << entries << endl;
+ setModified(false);
+ d->_url=url;
+
+ if( package.isEmpty() )
+ {
+ d->_packageName=QString::null;
+ d->_packageDir=QString::null;
+ }
+ else setPackage(package);
+
+ emit signalFileOpened(d->_readOnly);
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+ emit signalNumberOfUntranslatedChanged(numberOfUntranslated());
+ emit signalTotalNumberChanged( entries );
+ }
+
+ delete filter;
+
+ return error;
+ }
+ else
+ {
+ return OS_ERROR;
+ }
+}
+
+ConversionStatus Catalog::openURL(const KURL& openUrl, const KURL& saveURL, const QString& package)
+{
+ QString target;
+ ConversionStatus error = OK;
+
+ if(KIO::NetAccess::download(openUrl, target, NULL))
+ {
+ CatalogImportPlugin* filter=0;
+
+ // gimme plugin for this MIME type
+ KMimeType::Ptr mime = KMimeType::findByURL( openUrl, 0, true );
+ KTrader::OfferList offers = KTrader::self()->query("KBabelFilter", "('"+mime->name()+"' in [X-KDE-Import])");
+ KService::Ptr ptr = offers.first();
+
+ // we have no offer for this MIME type
+ if( !ptr )
+ {
+ kdDebug(KBABEL) << "No plugin for this type" << endl;
+ KIO::NetAccess::removeTempFile(target);
+ return NO_PLUGIN;
+ }
+
+ // try to load the library, if unsuccesfull, we have an installation problem
+ KLibFactory *factory = KLibLoader::self()->factory( ptr->library().local8Bit() );
+ if (!factory)
+ {
+ kdDebug(KBABEL) << "No factory" << endl;
+ KIO::NetAccess::removeTempFile(target);
+ return OS_ERROR;
+ }
+
+ // create the filter
+ filter = static_cast<CatalogImportPlugin*>(factory->create(0, 0));
+
+ // provide progress bar indication
+ connect( filter, SIGNAL( signalResetProgressBar(QString,int) ),
+ this, SIGNAL( signalResetProgressBar(QString,int) ));
+ connect( filter, SIGNAL( signalProgress(int) ),
+ this, SIGNAL( signalProgress(int) ));
+ connect( filter, SIGNAL( signalClearProgressBar() ),
+ this, SIGNAL( signalClearProgressBar() ));
+
+ connect( this, SIGNAL( signalStopActivity() ),
+ filter, SLOT( stop() ));
+
+ // load in the file (target is always local)
+ d->_active = true;
+ kdDebug(KBABEL) << "openURL - template active" << endl;
+ error = filter->open(target,mime->name(),this);
+ // we should be not freed yet
+ kdDebug(KBABEL) << "openURL - template not active" << endl;
+ d->_active = false;
+ if( error == STOPPED )
+ {
+ delete filter;
+ KIO::NetAccess::removeTempFile(target);
+ return STOPPED;
+ }
+
+ // Templates should not have recoverable errors (or they are bad templates)
+ if( error == OK )
+ {
+ const uint entries = numberOfEntries();
+
+ if ( !entries )
+ {
+ // KBabel cannot work correctly with not any entry
+ kdWarning() << k_funcinfo << " No entries! Assuming parse error!" << endl;
+ delete filter;
+ KIO::NetAccess::removeTempFile(target);
+ return NO_ENTRY_ERROR;
+ }
+
+ setModified(false);
+ d->_url = saveURL;
+ if( package.isEmpty() )
+ {
+ d->_packageName=QString::null;
+ d->_packageDir=QString::null;
+ }
+ else setPackage(package);
+
+ emit signalFileOpened(d->_readOnly);
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+ emit signalNumberOfUntranslatedChanged(numberOfUntranslated());
+ emit signalTotalNumberChanged( entries );
+ }
+
+ delete filter;
+
+ // and remove the temp file
+ KIO::NetAccess::removeTempFile(target);
+
+ return error;
+ }
+ else
+ {
+ return OS_ERROR;
+ }
+}
+
+Msgfmt::Status Catalog::checkSyntax(QString& output, bool clearErrors)
+{
+ if( !d->_mimeTypes.contains( "application/x-gettext" ) )
+ return Msgfmt::Unsupported;
+
+ QString filename;
+ bool tempFileUsed=false;
+
+ if(d->_url.isLocalFile() && !isModified())
+ {
+ filename=d->_url.path(0);
+ }
+ else
+ {
+ tempFileUsed=true;
+ filename=saveTempFile();
+ }
+
+ Msgfmt msgfmt;
+ Msgfmt::Status result = msgfmt.checkSyntax( filename , output, pluralFormType() != KDESpecific );
+
+ if( clearErrors) clearErrorList();
+
+ if( result==Msgfmt::SyntaxError )
+ {
+ int currentIndex=-1;
+ int currentLine=0;
+
+ if( !d->_header.msgstr().isEmpty() )
+ currentLine=d->_header.totalLines()+1;
+
+ // ### KDE4: return "lines" not "output"
+ const QStringList lines = QStringList::split("\n",output);
+ for ( QStringList::const_iterator it = lines.constBegin(); it != lines.constEnd(); ++it )
+ {
+ if( (*it).find(QRegExp("^.+:\\d+:")) >= 0 )
+ {
+ const int begin=(*it).find(":",0)+1;
+ const int end=(*it).find(":",begin);
+
+ const QString line=(*it).mid(begin,end-begin);
+
+ while( line.toInt() > currentLine )
+ {
+ currentIndex++;
+ currentLine += ( d->_entries[currentIndex].totalLines() + 1 );
+ }
+
+ if( currentIndex == -1 )
+ {
+ // header error
+ result = Msgfmt::HeaderError;
+ continue;
+ }
+
+ if( !d->_errorIndex.contains(currentIndex) )
+ {
+ d->_errorIndex.append(currentIndex);
+ d->_entries[currentIndex].setSyntaxError(true);
+ }
+ }
+ }
+ }
+
+ if(tempFileUsed)
+ QFile::remove(filename);
+
+ return result;
+}
+
+void Catalog::clearErrorList()
+{
+ QValueList<uint>::Iterator it;
+ for(it = d->_errorIndex.begin(); it != d->_errorIndex.end(); ++it)
+ {
+ d->_entries[(*it)].setSyntaxError(false);
+ d->_entries[(*it)].clearErrors();
+ }
+
+ d->_errorIndex.clear();
+}
+
+void Catalog::removeFromErrorList(uint index)
+{
+ if(d->_errorIndex.contains(index))
+ {
+ d->_errorIndex.remove(index);
+ d->_entries[index].setSyntaxError(false);
+ d->_entries[index].clearErrors();
+ }
+}
+
+QStringList Catalog::itemStatus(uint index, bool recheck, QPtrList<KDataTool> whatToCheck)
+{
+ if ( d->_entries.isEmpty() )
+ return QStringList();
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ CatalogItem& item = d->_entries[index];
+
+ if(recheck)
+ {
+ for( KDataTool* t = whatToCheck.first(); t ; t=whatToCheck.next() )
+ {
+ t->run("validate", (void*)(&item), "CatalogItem", "application/x-kbabel-catalogitem" );
+ }
+ }
+
+ return item.errors();
+}
+
+QStringList Catalog::itemStatus(uint index)
+{
+ if ( d->_entries.isEmpty() )
+ return QStringList();
+
+ uint max=d->_entries.count()-1;
+ if(index > max)
+ index=max;
+
+ CatalogItem& item = d->_entries[index];
+
+ return item.errors();
+}
+
+bool Catalog::checkUsingTool(KDataTool* tool, bool clearErrors)
+{
+ if(clearErrors)
+ clearErrorList();
+
+ kdDebug(KBABEL) << "checkUsingTool active" << endl;
+ d->_active=true;
+ d->_stop=false;
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ int index = 0;
+ bool hasErrors=false;
+
+ emit signalResetProgressBar(i18n("validating file"),100);
+
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin();
+ it != d->_entries.end(); ++it, index++ )
+ {
+ if( !tool->run( "validate", (void*)(&(*it)), "CatalogItem", "application/x-kbabel-catalogitem" ))
+ {
+ if( !d->_errorIndex.contains(index) )
+ {
+ d->_errorIndex.append(index);
+ hasErrors=true;
+ }
+ }
+ if( d->_stop ) break;
+ emit signalProgress((index*100)/d->_entries.count());
+ }
+
+ if( hasErrors && !clearErrors ) qHeapSort(d->_errorIndex);
+
+ kdDebug(KBABEL) << "checkUsingTool not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ emit signalClearProgressBar();
+
+ return !hasErrors;
+}
+
+void Catalog::modifyUsingTool(KDataTool* tool, const QString& command)
+{
+ kdDebug(KBABEL) << "modifyUsingTool active" << endl;
+ d->_active=true;
+ d->_stop=false;
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ int index = 0;
+ bool modified = false;
+
+ emit signalResetProgressBar(i18n("applying tool"),100);
+
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin();
+ it != d->_entries.end(); ++it, index++ )
+ {
+ CatalogItem dummyItem( *it );
+
+ tool->run( command, (void*)(&dummyItem), "CatalogItem", "application/x-kbabel-catalogitem" );
+
+ if( (*it).msgstr() != dummyItem.msgstr() || (*it).comment() != dummyItem.comment() )
+ {
+ if( !modified )
+ {
+ applyBeginCommand(0,Msgstr,0);
+ modified = true;
+ }
+
+ if( (*it).msgstr() != dummyItem.msgstr() )
+ {
+ uint in = 0; // number of current lural form
+ // go over all plural forms and test, which changed
+ for ( QStringList::Iterator itorig = (*it).msgstr().begin()
+ , itchanged = dummyItem.msgstr().begin()
+ ; itorig != (*it).msgstr().end()
+ ; ++itorig, ++itchanged) {
+ if( (*itorig) != (*itchanged) )
+ {
+ EditCommand* cmd = new DelTextCmd(0,(*itorig),index);
+ cmd->setPart(Msgstr);
+ applyEditCommand(cmd,0);
+ cmd = new InsTextCmd(0,(*itchanged),index);
+ cmd->setPart(Msgstr);
+ applyEditCommand(cmd,0);
+ }
+ in++;
+ }
+ }
+
+ if( (*it).comment() != dummyItem.comment() )
+ {
+ EditCommand* cmd = new DelTextCmd(0,(*it).comment(),0);
+ cmd->setPart(Comment);
+ cmd->setIndex(index);
+ applyEditCommand(cmd,0);
+ cmd = new InsTextCmd(0,dummyItem.comment(),0);
+ cmd->setPart(Comment);
+ cmd->setIndex(index);
+ applyEditCommand(cmd,0);
+ kdDebug(KBABEL) << "DummyItem comment is " << dummyItem.comment() << endl;
+ }
+ }
+
+ if( d->_stop ) break;
+ emit signalProgress((index*100)/d->_entries.count());
+ }
+
+ if( modified ) applyEndCommand(0, Msgstr, 0);
+
+ kdDebug(KBABEL) << "modifyUsingTool not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ emit signalClearProgressBar();
+}
+
+void Catalog::clear()
+{
+ d->_errorIndex.clear();
+ d->_entries.clear();
+ d->_url=KURL();
+ d->_obsoleteEntries.clear();
+
+ if(d->_undoList.count() > 0)
+ emit signalUndoAvailable(false);
+ if(d->_redoList.count() > 0)
+ emit signalRedoAvailable(false);
+
+ d->_undoList.clear();
+ d->_redoList.clear();
+
+ d->msgidDiffList.clear();
+ d->msgstr2MsgidDiffList.clear();
+ d->diffCache.clear();
+}
+
+
+uint Catalog::numberOfEntries() const
+{
+ return d->_entries.count();
+}
+
+uint Catalog::numberOfFuzzies() const
+{
+ return d->_fuzzyIndex.count();
+}
+
+uint Catalog::numberOfUntranslated() const
+{
+ return d->_untransIndex.count();
+}
+
+
+bool Catalog::hasFuzzyInFront(uint index) const
+{
+ if(findPrevInList(d->_fuzzyIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::hasFuzzyAfterwards(uint index) const
+{
+ if(findNextInList(d->_fuzzyIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::hasUntranslatedInFront(uint index) const
+{
+ if(findPrevInList(d->_untransIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::hasUntranslatedAfterwards(uint index) const
+{
+ if(findNextInList(d->_untransIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::hasErrorInFront(uint index) const
+{
+ if(findPrevInList(d->_errorIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::hasErrorAfterwards(uint index) const
+{
+ if(findNextInList(d->_errorIndex,index)>=0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool Catalog::isFuzzy(uint index) const
+{
+ if ( d->_entries.isEmpty() )
+ return false;
+
+ if(index > numberOfEntries())
+ return false;
+
+ return d->_entries[index].isFuzzy();
+}
+
+
+bool Catalog::isUntranslated(uint index) const
+{
+ if ( d->_entries.isEmpty() )
+ return false;
+
+ if(index > numberOfEntries())
+ return false;
+
+ return d->_entries[index].isUntranslated();
+}
+
+bool Catalog::hasError(uint index, DocPosition& pos) const
+{
+ if( d->_errorIndex.contains(index) )
+ {
+ pos.item=index;
+ pos.form=0;
+ return true;
+ }
+ return false;
+}
+
+PluralFormType Catalog::pluralForm(uint index) const
+{
+ if ( d->_entries.isEmpty() )
+ return NoPluralForm;
+
+ if(index > numberOfEntries())
+ return NoPluralForm;
+
+ return static_cast<PluralFormType>(d->_entries[index].pluralForm());
+}
+
+PluralFormType Catalog::pluralFormType() const
+{
+ if ( d->_entries.isEmpty() )
+ return NoPluralForm;
+
+ for( uint i = 0 ; i < numberOfEntries(); i++)
+ {
+ if( d->_entries[i].pluralForm() != NoPluralForm )
+ return d->_entries[i].pluralForm();
+ }
+
+ return NoPluralForm;
+}
+
+int Catalog::nextFuzzy(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findNextInList(d->_fuzzyIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+int Catalog::prevFuzzy(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findPrevInList(d->_fuzzyIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+int Catalog::nextUntranslated(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findNextInList(d->_untransIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+int Catalog::prevUntranslated(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findPrevInList(d->_untransIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+
+int Catalog::nextError(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findNextInList(d->_errorIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+int Catalog::prevError(uint startIndex, DocPosition& pos) const
+{
+ pos.item=findPrevInList(d->_errorIndex,startIndex);
+ pos.form=0;
+ return pos.item;
+}
+
+
+void Catalog::registerView(CatalogView* view)
+{
+ if(d->_views.containsRef(view)==0)
+ {
+ d->_views.append(view);
+ }
+}
+
+
+void Catalog::removeView(CatalogView* view)
+{
+ d->_views.removeRef(view);
+}
+
+
+void Catalog::updateViews(EditCommand* cmd,CatalogView* view2exclude)
+{
+ CatalogView* view;
+ for ( view=d->_views.first(); view != 0; view=d->_views.next())
+ {
+ if(view!=view2exclude)
+ {
+ view->update(cmd);
+ }
+ }
+}
+
+
+
+bool Catalog::hasView() const
+{
+ if(d->_views.count()==0)
+ return false;
+
+ return true;
+}
+
+bool Catalog::isLastView() const
+{
+ if(d->_views.count()<=1)
+ return true;
+
+ return false;
+}
+
+
+void Catalog::useProject(Project::Ptr project)
+{
+ d->_project->config()->sync();
+ d->_project = project;
+ readPreferences();
+ emit signalSettingsChanged(saveSettings());
+ emit signalSettingsChanged(identitySettings());
+ emit signalSettingsChanged(miscSettings());
+ emit signalSettingsChanged(tagSettings());
+}
+
+Project::Ptr Catalog::project() const
+{
+ return d->_project;
+}
+
+void Catalog::readPreferences()
+{
+ getNumberOfPluralForms();
+
+ d->_project->config()->setGroup("Tags");
+ d->_tagSettings.tagExpressions=d->_project->config()->readListEntry("TagExpressions");
+ if( d->_tagSettings.tagExpressions.empty() ) d->_tagSettings.tagExpressions = Defaults::Tag::tagExpressions();
+ d->_tagExtractor->setRegExpList(d->_tagSettings.tagExpressions) ;
+
+ d->_tagSettings.argExpressions=d->_project->config()->readListEntry("ArgExpressions");
+ if( d->_tagSettings.argExpressions.empty() ) d->_tagSettings.argExpressions = Defaults::Tag::argExpressions();
+ d->_argExtractor->setRegExpList(d->_tagSettings.argExpressions) ;
+}
+
+void Catalog::savePreferences()
+{
+ d->_project->config()->setGroup("Tags");
+
+ d->_project->config()->writeEntry( "TagExpressions", d->_tagSettings.tagExpressions );
+ d->_project->config()->writeEntry( "ArgExpressions", d->_tagSettings.argExpressions );
+
+ d->_project->config()->sync();
+}
+
+IdentitySettings Catalog::identitySettings() const
+{
+ return d->_project->identitySettings();
+}
+
+SaveSettings Catalog::saveSettings() const
+{
+ return d->_project->saveSettings();
+
+}
+
+MiscSettings Catalog::miscSettings() const
+{
+ return d->_project->miscSettings();
+
+}
+
+TagSettings Catalog::tagSettings() const
+{
+ return d->_tagSettings;
+
+}
+
+bool Catalog::isGeneratedFromDocbook() const
+{
+ return d->_generatedFromDocbook;
+}
+
+QString Catalog::package() const
+{
+ return packageDir()+packageName();
+}
+
+bool Catalog::isReadOnly() const
+{
+ return d->_readOnly;
+}
+
+void Catalog::setSettings(SaveSettings settings)
+{
+ d->_project->setSettings(settings);
+}
+
+void Catalog::setSettings(IdentitySettings settings)
+{
+ IdentitySettings oldsettings = d->_project->identitySettings();
+
+ QString oldLanguageCode = oldsettings.languageCode;
+ int oldForms = oldsettings.numberOfPluralForms;
+
+
+ d->_project->setSettings(settings);
+
+ if(oldLanguageCode != settings.languageCode)
+ {
+ getNumberOfPluralForms();
+ }
+
+ if(oldForms != settings.numberOfPluralForms)
+ {
+ getNumberOfPluralForms();
+ }
+
+ emit signalSettingsChanged(settings);
+}
+
+void Catalog::setSettings(MiscSettings settings)
+{
+ d->_project->setSettings(settings);
+ emit signalSettingsChanged(settings);
+}
+
+void Catalog::setSettings(TagSettings settings)
+{
+ d->_tagSettings=settings;
+
+ emit signalSettingsChanged(settings);
+}
+
+void Catalog::generateIndexLists()
+{
+ d->_fuzzyIndex.clear();
+ d->_untransIndex.clear();
+ clearErrorList();
+
+ uint counter=0;
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin(); it != d->_entries.end(); ++it )
+ {
+ if((*it).isUntranslated())
+ {
+ d->_untransIndex.append(counter);
+ }
+ else if((*it).isFuzzy())
+ {
+ d->_fuzzyIndex.append(counter);
+ }
+
+ counter++;
+ }
+
+}
+
+int Catalog::findNextInList(const QValueList<uint>& list,uint index) const
+{
+ QValueList<uint>::ConstIterator it;
+
+ int nextIndex=-1;
+
+ // find index in List
+ it=list.find(index);
+
+ // if the given index is found in the list and not the last entry
+ // in the list, return the next listentry
+ if(it!=list.end() && it!=list.fromLast())
+ {
+ ++it;
+ return (*it);
+ }
+
+ // if the index is not in the list, search the index in the list, that
+ // is the nearest to the given index
+ for( it = list.begin(); it != list.end(); ++it )
+ {
+ if((*it) > index)
+ {
+ nextIndex=(*it);
+ break;
+ }
+ }
+
+
+ return nextIndex;
+}
+
+int Catalog::findPrevInList(const QValueList<uint>& list,uint index) const
+{
+ QValueList<uint>::ConstIterator it;
+
+ int prevIndex=-1;
+
+ it=list.find(index);
+
+ // if the given index is found in the list and not the last entry
+ // in the list, return the next listentry
+ if(it!=list.end() && it!=list.begin())
+ {
+ --it;
+ return (*it);
+ }
+
+
+ // if the index is not in the list, search the index in the list, that
+ // is the nearest to the given index
+ for( it = list.fromLast(); it != list.end(); --it )
+ {
+ if((*it) < index)
+ {
+ prevIndex=(*it);
+ break;
+ }
+
+ if ( it == list.constBegin() )
+ {
+ // Decremeniting the iterator at the begin is undefined, so break the loop
+ break;
+ }
+ }
+
+
+ return prevIndex;
+}
+
+
+QString Catalog::dateTime() const
+{
+ const QDateTime dt = QDateTime::currentDateTime();
+ QString dateTimeString;
+
+ const SaveSettings options = d->_project->saveSettings();
+
+ switch(options.dateFormat)
+ {
+ case Qt::LocalDate:
+ {
+ dateTimeString = KGlobal::locale()->formatDateTime( dt );
+ break;
+ }
+ case Qt::ISODate:
+ {
+ dateTimeString = dt.toString("yyyy-MM-dd hh:mm");
+ QTime t;
+ const int offset = KRFCDate::localUTCOffset();
+ const int correction = offset < 0 ? -60 : 60 ;
+ t = t.addSecs( offset * correction );
+ dateTimeString += ( offset < 0 ? "-" : "+" );
+ dateTimeString += t.toString("hhmm");
+ break;
+ }
+ case Qt::TextDate:
+ {
+ dateTimeString = options.customDateFormat;
+
+ const QDate date = dt.date();
+ const QTime time = dt.time();
+
+ // the year
+ dateTimeString.replace( "%Y", QString::number( date.year() ) );
+ dateTimeString.replace( "%y", QString::number( date.year() ).right(2) );
+
+ // the month
+ if(date.month()<10)
+ {
+ dateTimeString.replace( "%m", "0"+QString::number( date.month() ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%m", QString::number( date.month() ) );
+ }
+
+ dateTimeString.replace( "%f", QString::number( date.month() ) );
+
+ dateTimeString.replace( "%b", date.longMonthName(date.month()) );
+ dateTimeString.replace( "%h", date.longMonthName(date.month()) );
+
+ // the day
+ dateTimeString.replace( "%j", QString::number( date.dayOfYear() ) );
+ dateTimeString.replace( "%e", QString::number( date.day() ) );
+ if(date.day() < 10)
+ {
+ dateTimeString.replace( "%d", "0"+QString::number( date.day() ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%d", QString::number( date.day() ) );
+ }
+
+ dateTimeString.replace( "%a", date.longDayName( date.dayOfWeek() ) );
+
+
+ // hour
+ dateTimeString.replace( "%k", QString::number( time.hour() ) );
+
+ if(time.hour() < 10)
+ {
+ dateTimeString.replace( "%H", "0"+QString::number( time.hour() ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%H", QString::number( time.hour() ) );
+ }
+
+ QString zone; // AM or PM
+ int hour = time.hour();
+ if( hour > 12 )
+ {
+ zone="PM";
+ hour -= 12;
+ }
+ else
+ {
+ zone="AM";
+ }
+
+ dateTimeString.replace( "%I", QString::number( hour ) );
+
+ if(hour < 10)
+ {
+ dateTimeString.replace( "%i", "0"+QString::number( hour ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%i", QString::number( hour ) );
+ }
+
+ dateTimeString.replace( "%p", zone );
+
+ // minutes
+ if(time.minute() < 10)
+ {
+ dateTimeString.replace( "%M", "0"+QString::number( time.minute() ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%M", QString::number( time.minute() ) );
+ }
+
+ // seconds
+ if(time.second() < 10)
+ {
+ dateTimeString.replace( "%S", "0"+QString::number( time.second() ) );
+ }
+ else
+ {
+ dateTimeString.replace( "%S", QString::number( time.second() ) );
+ }
+
+ // timezone
+ dateTimeString.replace( "%Z", d->_project->identitySettings().timeZone );
+ QTime t;
+ const int offset = KRFCDate::localUTCOffset();
+ const int correction = offset < 0 ? -60 : 60;
+ t = t.addSecs( offset * correction );
+ dateTimeString.replace( "%z", ( offset < 0 ? "-" : "+" ) + t.toString("hhmm") );
+ break;
+ }
+ }
+ kdDebug(KBABEL) << "New date: " << dateTimeString << endl;
+ return dateTimeString;
+}
+
+
+ConversionStatus Catalog::saveFile()
+{
+ if(d->_url.isEmpty())
+ {
+ kdFatal(KBABEL) << "fatal error: empty filename" << endl;
+ return NO_FILE;
+ }
+
+ return saveFileAs(d->_url,true);
+}
+
+ConversionStatus Catalog::saveFileAs(const KURL &url, bool overwrite)
+{
+ if( d->_active ) return BUSY;
+
+ ConversionStatus status=OK;
+
+ bool newName=false;
+ KURL targetURL=d->_url;
+
+ if(url != d->_url)
+ {
+ newName = true;
+ targetURL=url;
+ }
+
+
+ if(d->_project->saveSettings().autoUpdate)
+ {
+ d->_header=updatedHeader(d->_header);
+ emit signalHeaderChanged();
+ }
+
+
+ if(targetURL.isLocalFile())
+ {
+ // test if the directory exists. If not, create it.
+ QDir dir( targetURL.directory());
+
+ QStringList dirList;
+ while(!dir.exists() && !dir.dirName().isEmpty())
+ {
+ dirList.prepend(dir.dirName());
+ dir.setPath(dir.path()+"/..");
+ }
+ for ( QStringList::Iterator it = dirList.begin(); it != dirList.end(); ++it )
+ {
+ if(!dir.mkdir(*it))
+ {
+ status=OS_ERROR;
+ break;
+ }
+ dir.cd(*it);
+ }
+
+ if(status==OK)
+ {
+ status=writeFile(targetURL.path(0),overwrite);
+ }
+ }
+ else
+ {
+ QString tempFile=kapp->tempSaveName(targetURL.path(0));
+
+ status = writeFile(tempFile,overwrite);
+
+ if(status == OK)
+ {
+ if( !KIO::NetAccess::upload( tempFile, targetURL, NULL ) )
+ {
+ status = OS_ERROR;
+ }
+ }
+
+ QFile::remove(tempFile);
+ }
+
+ if(status == OK)
+ {
+ setModified(false);
+
+ if(newName)
+ {
+ // if we saved a file, the catalog can not be any longer readOnly;
+ d->_readOnly=false;
+
+ d->_url=targetURL;
+
+ emit signalFileOpened(d->_readOnly);
+ }
+ }
+
+ return status;
+}
+
+QString Catalog::saveTempFile()
+{
+ QString filename = kapp->tempSaveName("/temp/kbabel_temp.po");
+ if( writeFile(filename) != OK )
+ {
+ filename = QString::null;
+ }
+
+ return filename;
+}
+
+
+ConversionStatus Catalog::writeFile(QString localFile , bool overwrite)
+{
+ QFileInfo info(localFile);
+
+ if(info.isDir())
+ return NO_FILE;
+
+ if(info.exists())
+ {
+ if(!overwrite || !info.isWritable())
+ {
+ return NO_PERMISSIONS;
+ }
+ }
+ else // check if the directory is writable
+ {
+ QFileInfo dir(info.dirPath());
+ if(!dir.isWritable())
+ {
+ return NO_PERMISSIONS;
+ }
+ }
+
+ ConversionStatus error = OK;
+ CatalogExportPlugin* filter=0;
+
+ // gimme plugin for this MIME type
+ KMimeType::Ptr mime = KMimeType::findByURL( KURL::fromPathOrURL( localFile ) );
+ KTrader::OfferList offers = KTrader::self()->query("KBabelFilter", "('"+mime->name()+"' in [X-KDE-Export])");
+ KService::Ptr ptr = offers.first();
+
+ // we have no offer for this MIME type
+ if( !ptr )
+ {
+ kdDebug(KBABEL) << "No plugin for this type" << endl;
+ return NO_PLUGIN;
+ }
+
+ // try to load the library, if unsuccesfull, we have an installation problem
+ KLibFactory *factory = KLibLoader::self()->factory( ptr->library().local8Bit() );
+ if (!factory)
+ {
+ kdDebug(KBABEL) << "No factory" << endl;
+ return OS_ERROR;
+ }
+
+ // create the filter
+ filter = static_cast<CatalogExportPlugin*>(factory->create(0, 0));
+
+ // provide progress bar indication
+ connect( filter, SIGNAL( signalResetProgressBar(QString,int) ),
+ this, SIGNAL( signalResetProgressBar(QString,int) ));
+ connect( filter, SIGNAL( signalProgress(int) ),
+ this, SIGNAL( signalProgress(int) ));
+ connect( filter, SIGNAL( signalClearProgressBar() ),
+ this, SIGNAL( signalClearProgressBar() ));
+
+ connect( this, SIGNAL( signalStopActivity() ),
+ filter, SLOT( stop() ));
+
+ // load in the file (target is always local)
+ kdDebug(KBABEL) << "writeFile active" << endl;
+ d->_active = true;
+ error = filter->save(localFile,mime->name(),this);
+ // we should be not freed yet
+ kdDebug(KBABEL) << "writeFile not active" << endl;
+ d->_active = false;
+ if( error == STOPPED ) return STOPPED;
+
+ delete filter;
+
+ return error;
+}
+
+QTextCodec* Catalog::codecForFile(QString gettextHeader)
+{
+ QString charset;
+
+ QString head = gettextHeader;
+
+ QRegExp r("Content-Type:\\s*\\w+/[-\\w]+;?\\s*charset\\s*=\\s*[^\\\"\\n]+");
+ int begin=r.search(head);
+ int len=r.matchedLength();
+ if(begin<0) {
+ kdDebug(KBABEL) << "no charset entry found" << endl;
+ return 0;
+ }
+
+ head = head.mid(begin,len);
+
+ QRegExp regexp("charset *= *([^\\\\\\\"]+)");
+ if( regexp.search( head ) > -1 )
+ {
+ charset = regexp.cap(1);
+ }
+
+ QTextCodec* codec=0;
+
+ if(!charset.isEmpty())
+ {
+ // "CHARSET" is the default charset entry in a template (pot).
+ // characters in a template should be either pure ascii or
+ // at least utf8, so utf8-codec can be used for both.
+ if( charset == "CHARSET")
+ {
+ codec=QTextCodec::codecForName("utf8");
+ kdDebug(KBABEL)
+ << QString("file seems to be a template: using utf8 encoding.")
+ << endl;
+ }
+ else
+ {
+ codec=QTextCodec::codecForName(charset.latin1());
+ }
+
+ if(!codec)
+ {
+ kdWarning() << "charset found, but no codec available, using UTF8 instead" << endl;
+ codec=QTextCodec::codecForName("utf8");
+ }
+ }
+
+ return codec;
+}
+
+PoInfo Catalog::headerInfo(const CatalogItem headerItem)
+{
+ QStringList header=headerItem.msgstrAsList();
+
+ QStringList::Iterator it;
+
+ PoInfo info;
+
+ // extract information from the header
+ for(it=header.begin();it!=header.end();++it)
+ {
+ if((*it).contains(QRegExp("^\\s*Project-Id-Version\\s*:\\s*.+\\s*$")))
+ {
+ info.project=(*it).replace(QRegExp("^\\s*Project-Id-Version\\s*:\\s*"),"");
+
+ if(info.project.right(2)=="\\n")
+ info.project.remove(info.project.length()-2,2);
+
+ info.project=info.project.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*POT-Creation-Date\\s*:\\s*.+\\s*$")))
+ {
+ info.creation=(*it).replace(QRegExp("^\\s*POT-Creation-Date\\s*:\\s*"),"");
+
+ if(info.creation.right(2)=="\\n")
+ info.creation.remove(info.creation.length()-2,2);
+
+ info.creation=info.creation.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*PO-Revision-Date\\s*:\\s*.+\\s*$")))
+ {
+ info.revision=(*it).replace(QRegExp("^\\s*PO-Revision-Date\\s*:\\s*"),"");
+
+ if(info.revision.right(2)=="\\n")
+ info.revision.remove(info.revision.length()-2,2);
+
+ info.revision=info.revision.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*Last-Translator\\s*:\\s*.+\\s*$")))
+ {
+ info.lastTranslator=(*it).replace(QRegExp("^\\s*Last-Translator\\s*:\\s*"),"");
+
+ if(info.lastTranslator.right(2)=="\\n")
+ info.lastTranslator.remove(info.lastTranslator.length()-2,2);
+
+ info.lastTranslator=info.lastTranslator.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*Language-Team\\s*:\\s*.+\\s*")))
+ {
+ info.languageTeam=(*it).replace(QRegExp("^\\s*Language-Team\\s*:\\s*"),"");
+
+ if(info.languageTeam.right(2)=="\\n")
+ info.languageTeam.remove(info.languageTeam.length()-2,2);
+
+ info.languageTeam=info.languageTeam.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*MIME-Version\\s*:\\s*.+\\s*")))
+ {
+ info.mimeVersion=(*it).replace(QRegExp("^\\s*MIME-Version\\s*:\\s*"),"");
+
+ if(info.mimeVersion.right(2)=="\\n")
+ info.mimeVersion.remove(info.mimeVersion.length()-2,2);
+
+ info.mimeVersion=info.mimeVersion.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*Content-Type\\s*:\\s*.+\\s*")))
+ {
+ info.contentType=(*it).replace(QRegExp("^\\s*Content-Type\\s*:\\s*"),"");
+
+ if(info.contentType.right(2)=="\\n")
+ info.contentType.remove(info.contentType.length()-2,2);
+
+ info.contentType=info.contentType.simplifyWhiteSpace();
+ }
+ else if((*it).contains(QRegExp("^\\s*Content-Transfer-Encoding\\s*:\\s*.+\\s*")))
+ {
+ info.encoding=(*it).replace(QRegExp("^\\s*Content-Transfer-Encoding\\s*:\\s*"),"");
+
+ if(info.encoding.right(2)=="\\n")
+ info.encoding.remove(info.encoding.length()-2,2);
+
+ info.encoding=info.encoding.simplifyWhiteSpace();
+ }
+ else
+ {
+ QString line=(*it);
+
+ if(line.right(2)=="\\n")
+ line.remove(line.length()-2,2);
+
+ line=line.simplifyWhiteSpace();
+ if(!info.others.isEmpty())
+ info.others+='\n';
+
+ info.others+=line;
+ }
+
+
+ }
+
+ info.headerComment=headerItem.comment();
+
+ return info;
+}
+
+bool Catalog::isUndoAvailable()
+{
+ return !d->_undoList.isEmpty();
+}
+
+bool Catalog::isRedoAvailable()
+{
+ return !d->_redoList.isEmpty();
+}
+
+int Catalog::undo()
+{
+ if(!isUndoAvailable())
+ return -1;
+
+ int macroLevel = 0;
+
+ EditCommand *command=0;
+ do
+ {
+ command = d->_undoList.take();
+ if ( !command )
+ {
+ kdError() << "undo command is NULL?" << endl;
+ return -1;
+ }
+
+ processCommand( command, 0, true );
+
+ macroLevel += command->terminator();
+
+ if ( d->_undoList.isEmpty() )
+ {
+ emit signalUndoAvailable( false );
+ }
+ if(d->_redoList.isEmpty())
+ {
+ emit signalRedoAvailable(true);
+ }
+ d->_redoList.append(command);
+
+ }
+ while(macroLevel != 0);
+
+ return command->index();
+}
+
+int Catalog::redo()
+{
+ if(!isRedoAvailable())
+ return -1;
+
+ int macroLevel = 0;
+ EditCommand *command=0;
+
+ do
+ {
+ command = d->_redoList.take();
+ if ( !command )
+ {
+ kdError() << "undo command is NULL?" << endl;
+ return -1;
+ }
+
+ processCommand( command, 0,false );
+
+ macroLevel += command->terminator();
+ if ( d->_redoList.isEmpty() )
+ {
+ emit signalRedoAvailable( false );
+ }
+ if ( d->_undoList.isEmpty() )
+ {
+ emit signalUndoAvailable( true );
+ }
+
+ d->_undoList.append( command );
+ }
+ while (macroLevel != 0);
+
+ return command->index();
+}
+
+void Catalog::applyEditCommand(EditCommand* cmd, CatalogView* view)
+{
+
+ processCommand(cmd,view);
+ setModified(true);
+
+ if ( d->_undoList.isEmpty() )
+ {
+ emit signalUndoAvailable(true);
+ }
+ else if ( cmd->merge( d->_undoList.last() ) )
+ {
+ delete cmd;
+ return;
+ }
+
+
+ d->_undoList.append(cmd);
+
+
+ if ( !d->_redoList.isEmpty() )
+ {
+ d->_redoList.clear();
+ emit signalRedoAvailable( false );
+ }
+
+}
+
+void Catalog::applyBeginCommand(uint index, Part part, CatalogView* view)
+{
+ applyEditCommand( new BeginCommand(index,part), view );
+}
+
+void Catalog::applyEndCommand(uint index, Part part, CatalogView* view)
+{
+ applyEditCommand( new EndCommand(index,part), view );
+}
+
+void Catalog::processCommand(EditCommand* cmd,CatalogView* view, bool undo)
+{
+ kdDebug(KBABEL) << "Catalog::processCommand()" << endl;
+ if(cmd->terminator()==0)
+ {
+ bool checkUntranslated=false;
+ bool checkFuzzy=false;
+ bool wasFuzzy=false;
+
+ CatalogItem &item=d->_entries[cmd->index()];
+
+ if(cmd->part() == Msgstr)
+ {
+ if( item.isUntranslated() )
+ {
+ d->_untransIndex.remove(cmd->index());
+
+ emit signalNumberOfUntranslatedChanged(numberOfUntranslated());
+ }
+ else
+ {
+ checkUntranslated=true;
+ }
+ }
+ else if(cmd->part() == Comment)
+ {
+ checkFuzzy=true;
+ wasFuzzy=item.isFuzzy();
+ }
+
+
+
+ item.processCommand(cmd,undo);
+
+ if(undo)
+ {
+ EditCommand* tmpCmd=0;
+ DelTextCmd* delcmd = (DelTextCmd*) cmd;
+ if (delcmd->type() == EditCommand::Delete )
+ {
+ tmpCmd = new InsTextCmd(delcmd->offset,delcmd->str,delcmd->pluralNumber);
+ }
+ else
+ {
+ tmpCmd = new DelTextCmd(delcmd->offset,delcmd->str,delcmd->pluralNumber);
+ }
+
+ tmpCmd->setIndex(cmd->index());
+ tmpCmd->setPart(cmd->part());
+
+ updateViews(tmpCmd,view);
+
+ delete tmpCmd;
+ }
+ else
+ {
+ updateViews(cmd,view);
+ }
+
+ if(checkUntranslated && item.isUntranslated())
+ {
+ QValueList<uint>::Iterator it;
+
+ // insert index in the right place in the list
+ it = d->_untransIndex.begin();
+ while(it != d->_untransIndex.end() && cmd->index() > (int)(*it))
+ {
+ ++it;
+ }
+ d->_untransIndex.insert( it,(uint)(cmd->index()) );
+
+ emit signalNumberOfUntranslatedChanged(numberOfUntranslated());
+ }
+ else if(checkFuzzy)
+ {
+ if(wasFuzzy != item.isFuzzy())
+ {
+ if(wasFuzzy)
+ {
+ d->_fuzzyIndex.remove(cmd->index());
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+ }
+ else
+ {
+ QValueList<uint>::Iterator it;
+
+ // insert index in the right place in the list
+ it = d->_fuzzyIndex.begin();
+ while(it != d->_fuzzyIndex.end() && cmd->index() > (int)(*it))
+ {
+ ++it;
+ }
+ d->_fuzzyIndex.insert( it,(uint)(cmd->index()) );
+
+ emit signalNumberOfFuzziesChanged(numberOfFuzzies());
+ }
+ }
+ }
+
+ }
+}
+
+bool Catalog::findNext(const FindOptions* findOpts, DocPosition& docPos, int& len)
+{
+ bool success = false; // true, when string found
+ bool endReached=false;
+
+ kdDebug(KBABEL) << "findNext active" << endl;
+ d->_active=true;
+ d->_stop=false;
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ MiscSettings miscOptions = miscSettings();
+
+ len=0;
+ int pos=0;
+
+ QString searchStr = findOpts->findStr;
+ QRegExp regexp(searchStr);
+
+ if( findOpts->isRegExp ) {
+ regexp.setCaseSensitive(findOpts->caseSensitive);
+ }
+
+ if( docPos.item == numberOfEntries()-1) {
+ switch(docPos.part) {
+ case Msgid:
+ // FIXME: we should search in plurals as well
+ if(!findOpts->inMsgstr && !findOpts->inComment
+ && docPos.offset >= msgid(docPos.item).first().length() ) {
+ endReached=true;
+ }
+ break;
+ case Msgstr:
+ if(!findOpts->inComment && (int)(docPos.form+1) >= numberOfPluralForms(docPos.item)
+ && docPos.offset >= msgstr(docPos.item).last().length() ) {
+ endReached=true;
+ }
+ break;
+ case Comment:
+ if(docPos.offset >= comment(docPos.item).length() ) {
+ endReached=true;
+ }
+ break;
+ case UndefPart:
+ break;
+ }
+ }
+
+ while(!success) {
+ int accelMarkerPos = -1;
+ int contextInfoLength = 0;
+ int contextInfoPos = -1;
+ QString targetStr;
+
+ kapp->processEvents(10);
+
+ if( d->_stop || endReached)
+ {
+ kdDebug(KBABEL) << "FindNext: endReached or stopped" << endl;
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "findNext not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ return false;
+ }
+
+ switch(docPos.part) {
+ case Msgid:
+ // FIXME: should care about plural forms in msgid
+ targetStr = msgid(docPos.item).first();
+ break;
+ case Msgstr:
+ targetStr = *(msgstr(docPos.item).at(docPos.form));
+ break;
+ case Comment:
+ targetStr = comment(docPos.item);
+ break;
+ case UndefPart:
+ break;
+ }
+
+ if(findOpts->ignoreContextInfo)
+ {
+ contextInfoPos = miscOptions.contextInfo.search(targetStr);
+ contextInfoLength = miscOptions.contextInfo.matchedLength();
+ if(contextInfoPos >= 0)
+ {
+ targetStr.remove(contextInfoPos,contextInfoLength);
+
+ if(docPos.offset > (uint)contextInfoPos)
+ docPos.offset -= contextInfoLength;
+ }
+ }
+
+ if(findOpts->ignoreAccelMarker
+ && targetStr.contains(miscOptions.accelMarker))
+ {
+ accelMarkerPos = targetStr.find(miscOptions.accelMarker);
+ targetStr.remove(accelMarkerPos,1);
+
+ if(docPos.offset > (uint)accelMarkerPos)
+ docPos.offset--;
+ }
+
+ if( findOpts->isRegExp ) {
+ if ((pos=regexp.search(targetStr,docPos.offset)) >= 0 ) {
+ len = regexp.matchedLength();
+ if(findOpts->wholeWords) {
+ QString pre=targetStr.mid(pos-1,1);
+ QString post=targetStr.mid(pos+len,1);
+ if(!pre.contains(QRegExp("[a-zA-Z0-9]")) && !post.contains(QRegExp("[a-zA-Z0-9]")) ){
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ else {
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ }
+ else {
+ if( (pos=targetStr.find(searchStr,docPos.offset,findOpts->caseSensitive)) >= 0 ) {
+ len=searchStr.length();
+
+ if(findOpts->wholeWords) {
+ QString pre=targetStr.mid(pos-1,1);
+ QString post=targetStr.mid(pos+len,1);
+ if(!pre.contains(QRegExp("[a-zA-Z0-9]")) && !post.contains(QRegExp("[a-zA-Z0-9]")) ){
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ else {
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ }
+
+
+ if(!success) {
+ docPos.offset=0;
+ switch(docPos.part) {
+ case Msgid:
+ {
+ if(findOpts->inMsgstr) {
+ docPos.part = Msgstr;
+ docPos.form = 0;
+ }
+ else if(findOpts->inComment) {
+ docPos.part = Comment;
+ }
+ else
+ {
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.item++;
+ docPos.form = 0;
+ }
+ }
+ break;
+ }
+ case Msgstr:
+ if( (int)docPos.form < numberOfPluralForms(docPos.item)-1 && pluralForm(docPos.item)==Gettext) {
+ docPos.form++;
+ }
+ else
+ if(findOpts->inComment) {
+ docPos.part = Comment;
+ }
+ else if(findOpts->inMsgid) {
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.part = Msgid;
+ docPos.item++;
+ }
+ }
+ else {
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.item++;
+ docPos.form = 0;
+ }
+ }
+ break;
+ case Comment:
+ if(findOpts->inMsgid) {
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.part = Msgid;
+ docPos.item++;
+ docPos.form = 0;
+ }
+ }
+ else if(findOpts->inMsgstr){
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.part = Msgstr;
+ docPos.form = 0;
+ docPos.item++;
+ }
+ }
+ else {
+ if(docPos.item >= numberOfEntries()-1)
+ {
+ endReached=true;
+ }
+ else
+ {
+ docPos.item++;
+ docPos.form = 0;
+ }
+ }
+ break;
+ case UndefPart:
+ break;
+ }
+ }
+ else
+ {
+ if(accelMarkerPos >= 0)
+ {
+ if(docPos.offset >= (uint)accelMarkerPos)
+ {
+ docPos.offset++;
+ }
+ else if(docPos.offset+len > (uint)accelMarkerPos)
+ {
+ len++;
+ }
+ }
+
+ if(contextInfoPos >= 0)
+ {
+ if(docPos.offset >= (uint)contextInfoPos)
+ {
+ docPos.offset+=contextInfoLength;
+ }
+ else if(docPos.offset+len > (uint)contextInfoPos)
+ {
+ len+=contextInfoLength;
+ }
+
+ }
+ }
+ }
+
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "findNext not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+
+ return true;
+}
+
+bool Catalog::findPrev(const FindOptions* findOpts, DocPosition& docPos, int& len)
+{
+ bool success = false; // true, when found
+ bool beginReached = false;
+
+ kdDebug(KBABEL) << "findPrev active" << endl;
+ d->_active=true;
+ d->_stop=false;
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+
+ MiscSettings miscOptions = miscSettings();
+
+ len=0;
+ int pos=0;
+
+ QString searchStr = findOpts->findStr;
+ QRegExp regexp(searchStr);
+
+ if( findOpts->isRegExp ) {
+ regexp.setCaseSensitive(findOpts->caseSensitive);
+ }
+ while(!success) {
+ int accelMarkerPos = -1;
+ int contextInfoLength = 0;
+ int contextInfoPos = -1;
+ QString targetStr;
+
+ kapp->processEvents(10);
+
+ if( d->_stop || beginReached)
+ {
+ kdDebug(KBABEL) << "FindNext: endReached or stopped" << endl;
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "findPrev active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ return false;
+ }
+
+ switch(docPos.part) {
+ case Msgid:
+ // FIXME: should care about plural forms in msgid
+ targetStr = msgid(docPos.item).first();
+ break;
+ case Msgstr:
+ targetStr = *(msgstr(docPos.item).at(docPos.form));
+ break;
+ case Comment:
+ targetStr = comment(docPos.item);
+ break;
+ case UndefPart:
+ break;
+ }
+
+ if(findOpts->ignoreContextInfo)
+ {
+ contextInfoPos = miscOptions.contextInfo.search(targetStr);
+ contextInfoLength = miscOptions.contextInfo.matchedLength();
+ if(contextInfoPos >= 0)
+ {
+ targetStr.remove(contextInfoPos,contextInfoLength);
+
+ if(docPos.offset > (uint)contextInfoPos)
+ docPos.offset -= contextInfoLength;
+ }
+ }
+
+ if(findOpts->ignoreAccelMarker
+ && targetStr.contains(miscOptions.accelMarker))
+ {
+ accelMarkerPos = targetStr.find(miscOptions.accelMarker);
+ targetStr.remove(accelMarkerPos,1);
+
+ if(docPos.offset > (uint)accelMarkerPos)
+ docPos.offset--;
+ }
+
+ if(docPos.offset <= 0) {
+ success=false;
+ }
+ else if( findOpts->isRegExp ) {
+ /*
+ don't work!?
+ if((pos=targetStr.findRev(regexp,docPos.offset)) >= 0 ) {
+ regexp.match(targetStr,pos,&len); // to get the length of the string
+ */
+ bool found=false;
+ int tmpPos=docPos.offset;
+ while(!found && tmpPos>=0)
+ {
+ if( (pos=regexp.search(targetStr,tmpPos)) >= 0 && (uint)pos < docPos.offset)
+ found=true;
+ else
+ tmpPos--;
+ len = regexp.matchedLength();
+ }
+ if(found) {
+ if(findOpts->wholeWords) {
+ QString pre=targetStr.mid(pos-1,1);
+ QString post=targetStr.mid(pos+len,1);
+ if(!pre.contains(QRegExp("[a-zA-Z0-9]")) && !post.contains(QRegExp("[a-zA-Z0-9]")) ){
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ else {
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ }
+ else if( (pos=targetStr.findRev(searchStr,docPos.offset-1,findOpts->caseSensitive)) >= 0
+ && (uint)pos < docPos.offset) {
+ len=searchStr.length();
+ if(findOpts->wholeWords) {
+ QString pre=targetStr.mid(pos-1,1);
+ QString post=targetStr.mid(pos+len,1);
+ if(!pre.contains(QRegExp("[a-zA-Z0-9]")) && !post.contains(QRegExp("[a-zA-Z0-9]")) ){
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+ else {
+ success=true;
+ docPos.offset=pos;
+ }
+ }
+
+ if(!success) {
+ switch(docPos.part) {
+ case Comment:
+ {
+ if(findOpts->inMsgstr) {
+ docPos.part = Msgstr;
+ docPos.form = msgstr(docPos.item).count()-1;
+ docPos.offset = msgstr(docPos.item).last().length();
+ }
+ else if(findOpts->inMsgid) {
+ docPos.part = Msgid;
+ // FIXME: should care about plural forms in msgid
+ docPos.offset = msgid(docPos.item).first().length();
+ }
+ else
+ {
+ if(docPos.item <= 0)
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.item--;
+ docPos.offset = comment(docPos.item).length();
+ }
+ }
+ break;
+ }
+ case Msgstr:
+ if(docPos.form != 0 ) {
+ docPos.form--;
+ docPos.offset = (*msgstr(docPos.item).at(docPos.form)).length();
+ }
+ else if(findOpts->inMsgid) {
+ docPos.part = Msgid;
+ // FIXME: should care about plural forms in msgid
+ docPos.offset = msgid(docPos.item).first().length();
+ }
+ else if(findOpts->inComment) {
+ if(docPos.item <= 0)
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.part = Comment;
+ docPos.item--;
+ docPos.offset = comment(docPos.item).length();
+ }
+ }
+ else {
+ if(docPos.item <= 0)
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.item--;
+ docPos.offset = msgstr(docPos.item).last().length();
+ docPos.form = msgstr(docPos.item).count()-1;
+ }
+ }
+ break;
+ case Msgid:
+ if(findOpts->inComment) {
+ if(docPos.item <= 0 )
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.part = Comment;
+ docPos.item--;
+ docPos.offset = comment(docPos.item).length();
+ }
+ }
+ else if(findOpts->inMsgstr){
+ if(docPos.item <= 0)
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.part = Msgstr;
+ docPos.item--;
+ docPos.offset = msgstr(docPos.item).last().length();
+ docPos.form = msgstr(docPos.item).count()-1;
+ }
+ }
+ else {
+ if(docPos.item <= 0)
+ {
+ beginReached=true;
+ }
+ else
+ {
+ docPos.item--;
+ // FIXME: should care about plural forms in msgid
+ docPos.offset = msgid(docPos.item).first().length();
+ }
+ }
+ break;
+ case UndefPart:
+ break;
+ }
+ }
+ else
+ {
+ if(accelMarkerPos >= 0)
+ {
+ if(docPos.offset >= (uint)accelMarkerPos)
+ {
+ docPos.offset++;
+ }
+ else if(docPos.offset+len > (uint)accelMarkerPos)
+ {
+ len++;
+ }
+ }
+
+ if(contextInfoPos >= 0)
+ {
+ if(docPos.offset >= (uint)contextInfoPos)
+ {
+ docPos.offset+=contextInfoLength;
+ }
+ else if(docPos.offset+len > (uint)contextInfoPos)
+ {
+ len+=contextInfoLength;
+ }
+
+ }
+ }
+ }
+
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "findPrev active" << endl;
+ d->_active=false;
+ d->_stop=false;
+
+ return true;
+}
+
+
+Catalog::DiffResult Catalog::diff(uint entry, QString *result)
+{
+ if(!result)
+ {
+ kdWarning() << "0 pointer for result" << endl;
+ return DiffNotFound;
+ }
+
+ if( d->msgidDiffList.isEmpty() )
+ {
+ return DiffNeedList;
+ }
+
+ // first look if the diff for this entry is in the cache
+ QString *s = d->diffCache[entry];
+ if(s)
+ {
+ if(s->isEmpty())
+ return DiffNotFound;
+
+
+ *result = *s;
+ return DiffOk;
+ }
+
+ // then look if the same msgid is contained in the diff file
+ // FIXME: should care about plural forms in msgid
+ QString id = msgid(entry).first();
+ id.replace( "\n","");
+ if(d->msgidDiffList.contains(id))
+ {
+ // FIXME:: should care about plural forms in msgid
+ *result = msgid(entry).first();
+
+ return DiffOk;
+ }
+
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "diffv active" << endl;
+ d->_active=true;
+ d->_stop=false;
+
+ QString idForDiff;
+
+
+ // then look if there are entries with the same translation
+ kdWarning() << "Diff feature (2) does not work with plural forms" << endl;
+ QString str = msgstr(entry).first();
+ str.replace("\n","");
+ if(d->msgstr2MsgidDiffList.contains(str))
+ {
+ QStringList list = d->msgstr2MsgidDiffList[str];
+
+ if(list.count() == 1)
+ {
+ idForDiff = list.first();
+ }
+ else
+ {
+ // find the best matching id
+ double bestWeight = 0.6;
+ QString bestId;
+
+ QStringList::ConstIterator it;
+ for(it = list.begin(); it != list.end(); ++it)
+ {
+ double weight = LevenshteinDistance()(id, (*it));
+ if(weight > bestWeight)
+ {
+ bestWeight = weight;
+ bestId = (*it);
+ }
+ }
+
+ if( !bestId.isEmpty() )
+ {
+ idForDiff = bestId;
+ }
+ }
+ }
+ else
+ {
+ emit signalResetProgressBar(i18n("searching matching message")
+ ,100);
+
+ // find the best matching id
+ double bestWeight = 0.6;
+ QString bestId;
+
+ int counter=0;
+ int oldPercent=0;
+ int max = QMAX( d->msgidDiffList.count()-1, 1);
+
+ QStringList::ConstIterator it;
+ for(it = d->msgidDiffList.begin();
+ it != d->msgidDiffList.end(); ++it)
+ {
+ counter++;
+ int percent = 100*counter/max;
+ if(percent > oldPercent)
+ {
+ oldPercent = percent;
+ emit signalProgress(percent);
+ }
+
+ double weight = LevenshteinDistance()( id, (*it) );
+ if(weight > bestWeight)
+ {
+ bestWeight = weight;
+ bestId = (*it);
+ }
+
+ kapp->processEvents(10);
+
+ if( d->_stop )
+ {
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug
+
+ (KBABEL) << "diffv not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ return DiffNotFound;
+ }
+ }
+
+ if( !bestId.isEmpty() )
+ {
+ idForDiff = bestId;
+ }
+
+ emit signalClearProgressBar();
+
+ }
+
+ if( idForDiff.isEmpty() )
+ {
+ s = new QString(*result);
+ if( !d->diffCache.insert(entry,s) )
+ delete s;
+
+ kdDebug (KBABEL) << "diffv not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+ return DiffNotFound;
+ }
+
+ QString r = wordDiff(idForDiff,id);
+
+ //esp for plural forms
+ *result = r.replace("\\n<KBABELADD>" + QString(QChar(0x00B6)) + "</KBABELADD>", "\\n\n");
+
+ s = new QString(*result);
+ if( !d->diffCache.insert(entry,s) )
+ delete s;
+
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "diffv not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+
+ return DiffOk;
+}
+
+void Catalog::setDiffList( const QValueList<DiffEntry>& list)
+{
+ connect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "setDiffList active" << endl;
+ d->_active=true;
+ d->_stop=false;
+
+ emit signalResetProgressBar(i18n("preparing messages for diff"),100);
+
+ d->msgidDiffList.clear();
+ d->msgstr2MsgidDiffList.clear();
+ d->diffCache.clear();
+
+ uint max = QMAX(list.count()-1,1);
+ int oldPercent=0;
+ uint counter=0;
+ QValueList<DiffEntry>::ConstIterator it;
+ for(it = list.begin(); it != list.end(); ++it)
+ {
+ int percent = (100*counter)/max;
+ counter++;
+ if(percent > oldPercent)
+ {
+ oldPercent = percent;
+ emit signalProgress(percent);
+ kapp->processEvents(10);
+ }
+
+ QString id = (*it).msgid;
+ id.replace("\n","");
+ QString str = (*it).msgstr;
+ str.replace("\n","");
+ d->msgidDiffList.append(id);
+
+ if(!str.isEmpty())
+ {
+ if(d->msgstr2MsgidDiffList.contains(str))
+ {
+ QStringList sl = d->msgstr2MsgidDiffList[str];
+ sl.append(id);
+ }
+ else
+ {
+ QStringList sl;
+ sl.append(id);
+ d->msgstr2MsgidDiffList.insert(str,sl);
+ }
+ }
+ }
+
+ emit signalClearProgressBar();
+
+ disconnect( this, SIGNAL( signalStopActivity() ), this, SLOT( stopInternal() ));
+ kdDebug(KBABEL) << "setDiffList not active" << endl;
+ d->_active=false;
+ d->_stop=false;
+}
+
+QValueList<DiffEntry> Catalog::asDiffList()
+{
+ QValueList<DiffEntry> list;
+
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin();
+ it != d->_entries.end(); ++it)
+ {
+ DiffEntry e;
+ e.msgid = (*it).msgid().first();
+ kdWarning() << "Diff feature does not support plural forms" << endl;
+ e.msgstr = (*it).msgstr().first();
+
+ list.append(e);
+ }
+
+ return list;
+
+}
+
+int Catalog::defaultNumberOfPluralForms() const
+{
+ return d->numberOfPluralForms;
+}
+
+void Catalog::getNumberOfPluralForms()
+{
+ IdentitySettings options = identitySettings();
+
+ if(options.numberOfPluralForms > 0)
+ {
+ d->numberOfPluralForms = options.numberOfPluralForms;
+ return;
+ }
+
+ QString lang=options.languageCode;
+ if(lang.isEmpty())
+ {
+ d->numberOfPluralForms=-1;
+ return;
+ }
+
+ d->numberOfPluralForms = getNumberOfPluralForms(lang);
+}
+
+int Catalog::getNumberOfPluralForms(const QString& lang)
+{
+ int nr=-1;
+
+ KLocale locale("kdelibs");
+ locale.setLanguage(lang);
+
+ const char* formsString =
+ "_: Dear translator, please do not translate this string in any form, but "
+ "pick the _right_ value out of NoPlural/TwoForms/French... If not sure what "
+ "to do mail thd@kde.org and coolo@kde.org, they will tell you. Better leave "
+ "that out if unsure, the programs will crash!!\n"
+ "Definition of PluralForm - to be set by the translator of kdelibs.po";
+
+ QString formsTranslation = locale.translate(formsString);
+
+ // no translation found
+ if(formsTranslation == formsString || formsTranslation.isEmpty())
+ {
+ kdDebug(KBABEL) << "no translation of PluralForms found" << endl;
+ return -1;
+ }
+ if ( formsTranslation == "NoPlural" )
+ nr = 1;
+ else if ( formsTranslation == "TwoForms" )
+ nr = 2;
+ else if ( formsTranslation == "French" )
+ nr = 2;
+ else if ( formsTranslation == "Gaeilge" || formsTranslation == "OneTwoRest" )
+ nr = 3;
+ else if ( formsTranslation == "Russian" )
+ nr = 3;
+ else if ( formsTranslation == "Polish" )
+ nr = 3;
+ else if ( formsTranslation == "Slovenian" )
+ nr = 4;
+ else if ( formsTranslation == "Lithuanian" )
+ nr = 3;
+ else if ( formsTranslation == "Czech" )
+ nr = 3;
+ else if ( formsTranslation == "Slovak" )
+ nr = 3;
+ else if ( formsTranslation == "Maltese" )
+ nr = 4;
+ else if ( formsTranslation == "Arabic" )
+ nr = 4;
+ else if ( formsTranslation == "Balcan" )
+ nr = 3;
+ else
+ {
+ kdDebug(KBABEL) << "unknown translation of PluralForms: "
+ << formsTranslation << endl;
+ nr=-1;
+ }
+
+ return nr;
+}
+
+int Catalog::numberOfPluralForms( uint index ) const
+{
+ if( index > numberOfEntries() ) return -1;
+
+ if ( d->_entries.isEmpty() )
+ return -1;
+ if( d->_entries[index].pluralForm() == NoPluralForm ) return 1;
+
+ if( d->numberOfPluralForms > 0 ) return d->numberOfPluralForms;
+
+ return 2; //default
+}
+
+bool Catalog::isModified() const
+{
+ return d->_modified;
+}
+
+void Catalog::setEntries(QValueVector<CatalogItem> entries)
+{
+ d->_entries=entries;
+
+ // update the project for entries
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin();
+ it != d->_entries.end(); ++it)
+ {
+ it->setProject( d->_project );
+ }
+}
+
+void Catalog::setObsoleteEntries(QValueList<CatalogItem> entries)
+{
+ d->_obsoleteEntries=entries;
+}
+
+QValueList<CatalogItem> Catalog::obsoleteEntries() const
+{
+ return d->_obsoleteEntries;
+}
+
+void Catalog::setCatalogExtraData(const QStringList& data)
+{
+ d->_catalogExtra = data;
+}
+
+QStringList Catalog::catalogExtraData() const
+{
+ return d->_catalogExtra;
+}
+
+QString Catalog::importPluginID() const
+{
+ return d->_importID;
+}
+
+QTextCodec* Catalog::fileCodec() const
+{
+ return d->fileCodec;
+}
+
+void Catalog::setGeneratedFromDocbook(const bool generated)
+{
+ d->_generatedFromDocbook = generated;
+}
+
+void Catalog::setFileCodec( QTextCodec* codec )
+{
+ d->fileCodec = codec;
+}
+
+void Catalog::setErrorIndex( const QValueList<uint>& list )
+{
+ d->_errorIndex = list;
+}
+
+void Catalog::setImportPluginID( const QString& id )
+{
+ d->_importID = id;
+}
+
+void Catalog::stop()
+{
+ if( d->_active )
+ emit signalStopActivity();
+}
+
+void Catalog::stopInternal()
+{
+ d->_stop = true;
+}
+
+bool Catalog::isActive()
+{
+ return d->_active;
+}
+
+void Catalog::setMimeTypes( const QString& mimeTypes )
+{
+ d->_mimeTypes = mimeTypes;
+}
+
+QString Catalog::mimeTypes() const
+{
+ return d->_mimeTypes;
+}
+
+void Catalog::wordCount (uint &total, uint &fuzzy, uint &untranslated) const
+{
+ total = 0;
+ fuzzy = 0;
+ untranslated = 0;
+
+ QRegExp separator( "[ \n\t]+" );
+
+ for ( QValueVector<CatalogItem>::Iterator it = d->_entries.begin();
+ it != d->_entries.end(); ++it)
+ {
+ // find out the number of words for this message
+
+ // join all forms together
+ QString message = (*it).msgid ().join (" ");
+
+ // remove tags first
+ d->_tagExtractor->setString( message );
+ message = d->_tagExtractor->plainString(false);
+
+ QStringList words = QStringList::split ( separator, message );
+
+ total += words.count();
+
+ if ( (*it).isFuzzy() )
+ fuzzy += words.count();
+ else if ( (*it).isUntranslated() )
+ untranslated += words.count();
+ }
+}
+
+#include "catalog.moc"
+
+// kate: space-indent on; indent-width 4; replace-tabs on;