Update to upstream version 1.3.6

79 files changed, 4059 insertions, 197 deletions

diff --git a/src/borrower.h b/src/borrower.h
index 81a5dc2..261ab4d 100644
--- a/src/borrower.h
+++ b/src/borrower.h
@@ -78,7 +78,7 @@ public:
   const TQString& name() const { return m_name; }
   const LoanVec& loans() const { return m_loans; }
   bool isEmpty() const { return m_loans.isEmpty(); }
-  int count() const { return m_loans.count(); }
+  size_t count() const { return m_loans.count(); }
 
   Data::LoanPtr loan(Data::ConstEntryPtr entry);
   void addLoan(Data::LoanPtr loan);
diff --git a/src/borroweritem.cpp b/src/borroweritem.cpp
index f43e502..80a305f 100644
--- a/src/borroweritem.cpp
+++ b/src/borroweritem.cpp
@@ -25,7 +25,7 @@ BorrowerItem::BorrowerItem(GUI::ListView* parent_, Data::BorrowerPtr borrower_)
   setPixmap(0, SmallIcon(TQString::fromLatin1("kaddressbook")));
 }
 
-int BorrowerItem::count() const {
+size_t BorrowerItem::count() const {
   return m_borrower ? m_borrower->count() : GUI::CountedItem::count();
 }
 
diff --git a/src/borroweritem.h b/src/borroweritem.h
index ad0b7d6..9d15f3f 100644
--- a/src/borroweritem.h
+++ b/src/borroweritem.h
@@ -29,7 +29,7 @@ public:
   virtual bool isBorrowerItem() const { return true; }
   Data::BorrowerPtr borrower() { return m_borrower; }
 
-  virtual int count() const;
+  virtual size_t count() const;
   virtual Data::EntryVec entries() const;
 
 private:
diff --git a/src/collection.cpp b/src/collection.cpp
index 7d121e0..59cbef6 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -878,6 +878,9 @@ bool Collection::mergeEntry(EntryPtr e1, EntryPtr e2, bool overwrite_, bool askU
       if(ret) {
         e1->setField(field, vals1.join(TQString::fromLatin1("; ")));
       }
+// remove the merging due to use comments
+// maybe in the future have a more intelligent way
+#if 0
     } else if(field->flags() & Data::Field::AllowMultiple) {
       // if field F allows multiple values and not a Table (see above case),
       // e1's F values = (e1's F values) U (e2's F values) (union)
@@ -894,6 +897,7 @@ bool Collection::mergeEntry(EntryPtr e1, EntryPtr e2, bool overwrite_, bool askU
 //      items1.sort();
       e1->setField(field, items1.join(TQString::fromLatin1("; ")));
       ret = true;
+#endif
     } else if(askUser_ && e1->field(field) != e2->field(field)) {
       int ret = Kernel::self()->askAndMerge(e1, e2, field);
       if(ret == 0) {
diff --git a/src/collectionfieldsdialog.cpp b/src/collectionfieldsdialog.cpp
index ef3583f..7d1fc46 100644
--- a/src/collectionfieldsdialog.cpp
+++ b/src/collectionfieldsdialog.cpp
@@ -254,7 +254,6 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
 
   // need to stretch at bottom
   vbox->setStretchFactor(new TQWidget(vbox), 1);
-  TDEAcceleratorManager::manage(vbox);
 
   // keep a default collection
   m_defaultCollection = CollectionFactory::collection(m_coll->type(), true);
@@ -279,6 +278,9 @@ CollectionFieldsDialog::~CollectionFieldsDialog() {
 }
 
 void CollectionFieldsDialog::slotSelectInitial() {
+  // the accel management is here so that it doesn't cause conflicts with the
+  // ones explicitly set in the constructor
+  TDEAcceleratorManager::manage(mainWidget());
   m_fieldsBox->setSelected(0, true);
 }
 
@@ -405,7 +407,7 @@ void CollectionFieldsDialog::slotNew() {
   }
 
   TQString name = TQString::fromLatin1("custom") + TQString::number(m_newFields.count()+1);
-  int count = m_newFields.count() + 1;
+  size_t count = m_newFields.count() + 1;
   TQString title = i18n("New Field") + TQString::fromLatin1(" %1").arg(count);
   while(m_fieldsBox->findItem(title)) {
     ++count;
diff --git a/src/collections/filecatalog.cpp b/src/collections/filecatalog.cpp
index 92d088f..afba7fc 100644
--- a/src/collections/filecatalog.cpp
+++ b/src/collections/filecatalog.cpp
@@ -102,4 +102,21 @@ Tellico::Data::FieldVec FileCatalog::defaultFields() {
   return list;
 }
 
+int FileCatalog::sameEntry(Data::EntryPtr entry1_, Data::EntryPtr entry2_) const {
+  // equal urls are always equal, even if modification time or something is different
+  if(Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("url"), this) > 0) {
+    return 100; // good match
+  }
+  // if volume or created time is different, it can't be same entry
+  if(Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("volume"), this) == 0 ||
+     Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("created"), this) == 0 ||
+     Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("size"), this) == 0) {
+    return 0;
+  }
+  int res = Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("title"), this);
+  res += Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("description"), this);
+  res += Entry::compareValues(entry1_, entry2_, TQString::fromLatin1("mimetype"), this);
+  return res;
+}
+
 #include "filecatalog.moc"
diff --git a/src/collections/filecatalog.h b/src/collections/filecatalog.h
index f2ede29..6a08dc9 100644
--- a/src/collections/filecatalog.h
+++ b/src/collections/filecatalog.h
@@ -1,5 +1,5 @@
 /***************************************************************************
-    copyright            : (C) 2005-2006 by Robby Stephenson
+    copyright            : (C) 2005-2008 by Robby Stephenson
     email                : [email protected]
  ***************************************************************************/
 
@@ -30,6 +30,7 @@ public:
   FileCatalog(bool addFields, const TQString& title = TQString());
 
   virtual Type type() const { return File; }
+  virtual int sameEntry(Data::EntryPtr entry1, Data::EntryPtr entry2) const;
 
   static FieldVec defaultFields();
 };
diff --git a/src/controller.cpp b/src/controller.cpp
index f3afb2a..d4a1599 100644
--- a/src/controller.cpp
+++ b/src/controller.cpp
@@ -434,6 +434,7 @@ void Controller::slotDeleteSelectedEntries() {
     int ret = KMessageBox::warningContinueCancel(Kernel::self()->widget(), str, i18n("Delete Entry"),
                                                  KGuiItem(i18n("&Delete"), TQString::fromLatin1("editdelete")), dontAsk);
     if(ret != KMessageBox::Continue) {
+      m_working = false;
       return;
     }
   } else {
@@ -448,6 +449,7 @@ void Controller::slotDeleteSelectedEntries() {
                                                      i18n("Delete Multiple Entries"),
                                                      KGuiItem(i18n("&Delete"), TQString::fromLatin1("editdelete")), dontAsk);
     if(ret != KMessageBox::Continue) {
+      m_working = false;
       return;
     }
   }
diff --git a/src/core/Makefile.am b/src/core/Makefile.am
index 15fc0df..01bf5a8 100644
--- a/src/core/Makefile.am
+++ b/src/core/Makefile.am
@@ -17,6 +17,8 @@ drophandler.h drophandler.cpp \
 tellico-rename.upd tellico.upd \
 tellico-1-3-update.pl
 
+dcopinterface_DCOPIDLNG = ALL
+
 kde_kcfg_DATA = tellico_config.kcfg
 
 updatedir = $(kde_datadir)/tdeconf_update
diff --git a/src/core/dcopinterface_skel.cpp b/src/core/dcopinterface_skel.cpp
index 8de56bf..4e819ed 100644
--- a/src/core/dcopinterface_skel.cpp
+++ b/src/core/dcopinterface_skel.cpp
@@ -25,11 +25,11 @@ static const char* const ApplicationInterface_ftable[16][3] = {
     { "bool", "exportHTML(TQString)", "exportHTML(TQString file)" },
     { "bool", "exportCSV(TQString)", "exportCSV(TQString file)" },
     { "bool", "exportPilotDB(TQString)", "exportPilotDB(TQString file)" },
-    { "TQValueList<long int>", "selectedEntries()", "selectedEntries()" },
-    { "TQValueList<long int>", "filteredEntries()", "filteredEntries()" },
+    { "TQValueList<long>", "selectedEntries()", "selectedEntries()" },
+    { "TQValueList<long>", "filteredEntries()", "filteredEntries()" },
     { "void", "openFile(TQString)", "openFile(TQString file)" },
     { "void", "setFilter(TQString)", "setFilter(TQString text)" },
-    { "bool", "showEntry(long int)", "showEntry(long int id)" },
+    { "bool", "showEntry(long)", "showEntry(long id)" },
     { 0, 0, 0 }
 };
 static const int ApplicationInterface_ftable_hiddens[15] = {
@@ -162,12 +162,12 @@ bool ApplicationInterface::process(const TQCString &fun, const TQByteArray &data
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportPilotDB(arg0 );
     } break;
-    case 10: { // TQValueList<long int> selectedEntries()
+    case 10: { // TQValueList<long> selectedEntries()
 	replyType = ApplicationInterface_ftable[10][0]; 
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << selectedEntries( );
     } break;
-    case 11: { // TQValueList<long int> filteredEntries()
+    case 11: { // TQValueList<long> filteredEntries()
 	replyType = ApplicationInterface_ftable[11][0]; 
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << filteredEntries( );
@@ -188,8 +188,8 @@ bool ApplicationInterface::process(const TQCString &fun, const TQByteArray &data
 	replyType = ApplicationInterface_ftable[13][0]; 
 	setFilter(arg0 );
     } break;
-    case 14: { // bool showEntry(long int)
-	long int arg0;
+    case 14: { // bool showEntry(long)
+	long arg0;
 	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
@@ -233,14 +233,14 @@ namespace Tellico {
 
 static const int CollectionInterface_fhash = 11;
 static const char* const CollectionInterface_ftable[9][3] = {
-    { "long int", "addEntry()", "addEntry()" },
-    { "bool", "removeEntry(long int)", "removeEntry(long int entryID)" },
+    { "long", "addEntry()", "addEntry()" },
+    { "bool", "removeEntry(long)", "removeEntry(long entryID)" },
     { TQSTRINGLIST_OBJECT_NAME_STRING, "values(TQString)", "values(TQString fieldName)" },
-    { TQSTRINGLIST_OBJECT_NAME_STRING, "values(long int,TQString)", "values(long int entryID,TQString fieldName)" },
+    { TQSTRINGLIST_OBJECT_NAME_STRING, "values(long,TQString)", "values(long entryID,TQString fieldName)" },
     { TQSTRINGLIST_OBJECT_NAME_STRING, "bibtexKeys()", "bibtexKeys()" },
-    { TQSTRING_OBJECT_NAME_STRING, "bibtexKey(long int)", "bibtexKey(long int entryID)" },
-    { "bool", "setFieldValue(long int,TQString,TQString)", "setFieldValue(long int entryID,TQString fieldName,TQString value)" },
-    { "bool", "addFieldValue(long int,TQString,TQString)", "addFieldValue(long int entryID,TQString fieldName,TQString value)" },
+    { TQSTRING_OBJECT_NAME_STRING, "bibtexKey(long)", "bibtexKey(long entryID)" },
+    { "bool", "setFieldValue(long,TQString,TQString)", "setFieldValue(long entryID,TQString fieldName,TQString value)" },
+    { "bool", "addFieldValue(long,TQString,TQString)", "addFieldValue(long entryID,TQString fieldName,TQString value)" },
     { 0, 0, 0 }
 };
 static const int CollectionInterface_ftable_hiddens[8] = {
@@ -264,13 +264,13 @@ bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data,
     }
     int* fp = fdict->find( fun );
     switch ( fp?*fp:-1) {
-    case 0: { // long int addEntry()
+    case 0: { // long addEntry()
 	replyType = CollectionInterface_ftable[0][0]; 
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << addEntry( );
     } break;
-    case 1: { // bool removeEntry(long int)
-	long int arg0;
+    case 1: { // bool removeEntry(long)
+	long arg0;
 	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
@@ -287,8 +287,8 @@ bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data,
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << values(arg0 );
     } break;
-    case 3: { // TQStringList values(long int,TQString)
-	long int arg0;
+    case 3: { // TQStringList values(long,TQString)
+	long arg0;
 	TQString arg1;
 	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
@@ -304,8 +304,8 @@ bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data,
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << bibtexKeys( );
     } break;
-    case 5: { // TQString bibtexKey(long int)
-	long int arg0;
+    case 5: { // TQString bibtexKey(long)
+	long arg0;
 	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
@@ -313,8 +313,8 @@ bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data,
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << bibtexKey(arg0 );
     } break;
-    case 6: { // bool setFieldValue(long int,TQString,TQString)
-	long int arg0;
+    case 6: { // bool setFieldValue(long,TQString,TQString)
+	long arg0;
 	TQString arg1;
 	TQString arg2;
 	TQDataStream arg( data, IO_ReadOnly );
@@ -328,8 +328,8 @@ bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data,
 	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << setFieldValue(arg0, arg1, arg2 );
     } break;
-    case 7: { // bool addFieldValue(long int,TQString,TQString)
-	long int arg0;
+    case 7: { // bool addFieldValue(long,TQString,TQString)
+	long arg0;
 	TQString arg1;
 	TQString arg2;
 	TQDataStream arg( data, IO_ReadOnly );
diff --git a/src/core/drophandler.cpp b/src/core/drophandler.cpp
index e609e7b..8d4875d 100644
--- a/src/core/drophandler.cpp
+++ b/src/core/drophandler.cpp
@@ -15,9 +15,13 @@
 #include "../mainwindow.h"
 #include "../tellico_kernel.h"
 #include "../tellico_debug.h"
+#include "../translators/bibteximporter.h"
+#include "../translators/risimporter.h"
 
 #include <kurldrag.h>
 #include <kmimetype.h>
+#include <tdeio/netaccess.h>
+#include <tdeio/job.h>
 
 using Tellico::DropHandler;
 
@@ -62,18 +66,37 @@ bool DropHandler::handleURL(const KURL::List& urls_) {
   bool hasUnknown = false;
   KURL::List tc, pdf, bib, ris;
   for(KURL::List::ConstIterator it = urls_.begin(); it != urls_.end(); ++it) {
-    KMimeType::Ptr ptr = KMimeType::findByURL(*it);
+    const KURL& url = *it;
+    KMimeType::Ptr ptr;
+    // findByURL doesn't work for http, so actually query
+    // the url itself
+    if(url.protocol() != TQString::fromLatin1("http")) {
+      ptr = KMimeType::findByURL(url);
+    } else {
+      TDEIO::MimetypeJob* job = TDEIO::mimetype(url, false /*progress*/);
+      TDEIO::NetAccess::synchronousRun(job, Kernel::self()->widget());
+      ptr = KMimeType::mimeType(job->mimetype());
+    }
     if(ptr->is(TQString::fromLatin1("application/x-tellico"))) {
-      tc << *it;
+      tc << url;
     } else if(ptr->is(TQString::fromLatin1("application/pdf"))) {
-      pdf << *it;
+      pdf << url;
     } else if(ptr->is(TQString::fromLatin1("text/x-bibtex")) ||
-              ptr->is(TQString::fromLatin1("application/x-bibtex"))) {
-      bib << *it;
+              ptr->is(TQString::fromLatin1("application/x-bibtex")) ||
+              ptr->is(TQString::fromLatin1("application/bibtex"))) {
+      bib << url;
     } else if(ptr->is(TQString::fromLatin1("application/x-research-info-systems"))) {
-      ris << *it;
+      ris << url;
+    } else if(url.fileName().endsWith(TQString::fromLatin1(".bib"))) {
+      bib << url;
+    } else if(url.fileName().endsWith(TQString::fromLatin1(".ris"))) {
+      ris << url;
+    } else if(ptr->is(TQString::fromLatin1("text/plain")) && Import::BibtexImporter::maybeBibtex(url)) {
+      bib << url;
+    } else if(ptr->is(TQString::fromLatin1("text/plain")) && Import::RISImporter::maybeRIS(url)) {
+      ris << url;
     } else {
-      myDebug() << "DropHandler::handleURL() - unrecognized type: " << ptr->name() << " (" << *it << ")" << endl;
+      myDebug() << "DropHandler::handleURL() - unrecognized type: " << ptr->name() << " (" << url << ")" << endl;
       hasUnknown = true;
     }
   }
diff --git a/src/document.cpp b/src/document.cpp
index 40a38dd..97a5c5a 100644
--- a/src/document.cpp
+++ b/src/document.cpp
@@ -15,6 +15,7 @@
 #include "mainwindow.h" // needed for calling fileSave()
 #include "collectionfactory.h"
 #include "translators/tellicoimporter.h"
+#include "translators/tellicosaximporter.h"
 #include "translators/tellicozipexporter.h"
 #include "translators/tellicoxmlexporter.h"
 #include "collection.h"
@@ -109,7 +110,12 @@ bool Document::openDocument(const KURL& url_) {
   }
 
   delete m_importer;
+#ifdef SAX_SUPPORT
+  myLog() << "Document::openDocument() - using SAX loader" << endl;
+  m_importer = new Import::TellicoSaxImporter(url_, m_loadAllImages);
+#else
   m_importer = new Import::TellicoImporter(url_, m_loadAllImages);
+#endif
 
   CollPtr coll = m_importer->collection();
   // delayed image loading only works for zip files
@@ -146,6 +152,8 @@ bool Document::openDocument(const KURL& url_) {
     TQTimer::singleShot(500, this, TQT_SLOT(slotLoadAllImages()));
   } else {
     emit signalCollectionImagesLoaded(m_coll);
+    m_importer->deleteLater();
+    m_importer = 0;
   }
   return true;
 }
diff --git a/src/document.h b/src/document.h
index b270be6..6d3e99e 100644
--- a/src/document.h
+++ b/src/document.h
@@ -27,6 +27,7 @@
 namespace Tellico {
   namespace Import {
     class TellicoImporter;
+    class TellicoSaxImporter;
   }
   namespace Data {
 
@@ -227,7 +228,11 @@ private:
   bool m_loadAllImages : 1;
   KURL m_url;
   bool m_validFile : 1;
+#ifdef SAX_SUPPORT
+  TQGuardedPtr<Import::TellicoSaxImporter> m_importer;
+#else
   TQGuardedPtr<Import::TellicoImporter> m_importer;
+#endif
   bool m_cancelImageWriting : 1;
   int m_fileFormat;
   bool m_allImagesOnDisk : 1;
diff --git a/src/entry.cpp b/src/entry.cpp
index fc97354..a1274db 100644
--- a/src/entry.cpp
+++ b/src/entry.cpp
@@ -252,8 +252,13 @@ bool Entry::setField(const TQString& name_, const TQString& value_) {
   }
 
   // the string store is probable only useful for fields with auto-completion or choice/number/bool
+  bool shareType = f->type() == Field::Choice ||
+                   f->type() == Field::Bool ||
+                   f->type() == Field::Image ||
+                   f->type() == Field::Rating ||
+                   f->type() == Field::Number;
   if(!(f->flags() & Field::AllowMultiple) &&
-     ((f->type() == Field::Choice || f->type() == Field::Bool || f->type() == Field::Number) ||
+     (shareType ||
       (f->type() == Field::Line && (f->flags() & Field::AllowCompletion)))) {
     m_fields.insert(Tellico::shareString(name_), Tellico::shareString(value_));
   } else {
@@ -415,6 +420,16 @@ int Entry::compareValues(EntryPtr e1, EntryPtr e2, FieldPtr f) {
   if(f->name() == Latin1Literal("lccn") && LCCNValidator::formalize(s1) == LCCNValidator::formalize(s2)) {
     return 5;
   }
+  if(f->name() == Latin1Literal("arxiv")) {
+    // normalize and unVersion arxiv ID
+    s1.remove(TQRegExp(TQString::fromLatin1("^arxiv:"), false));
+    s1.remove(TQRegExp(TQString::fromLatin1("v\\d+$")));
+    s2.remove(TQRegExp(TQString::fromLatin1("^arxiv:"), false));
+    s2.remove(TQRegExp(TQString::fromLatin1("v\\d+$")));
+    if(s1 == s2) {
+      return 5;
+    }
+  }
   if(f->formatFlag() == Field::FormatName) {
     s1 = e1->field(f, true).lower();
     s2 = e2->field(f, true).lower();
diff --git a/src/entry.h b/src/entry.h
index 92bda7c..de1ba66 100644
--- a/src/entry.h
+++ b/src/entry.h
@@ -84,11 +84,6 @@ public:
    * The assignment operator is overloaded, since the id must be different.
    */
   Entry& operator=(const Entry& other);
-  /**
-   * two entries are equal if all their field values are equal, except for
-   * file catalogs which match on the url only
-   */
-  bool operator==(const Entry& other);
 
   ~Entry();
 
@@ -231,6 +226,12 @@ public:
   static TQString dependentValue(ConstEntryPtr e, const TQString& formatString, bool formatted);
 
 private:
+  /**
+   * two entries are equal if all their field values are equal, except for
+   * file catalogs which match on the url only
+   */
+  bool operator==(const Entry& other);
+
   CollPtr m_coll;
   long m_id;
   StringMap m_fields;
diff --git a/src/entrygroupitem.cpp b/src/entrygroupitem.cpp
index 3d08169..3ddf6c1 100644
--- a/src/entrygroupitem.cpp
+++ b/src/entrygroupitem.cpp
@@ -131,7 +131,7 @@ TQString EntryGroupItem::key(int col_, bool) const {
   return m_key;
 }
 
-int EntryGroupItem::count() const {
+size_t EntryGroupItem::count() const {
   return m_group ? m_group->count() : GUI::CountedItem::count();
 }
 
diff --git a/src/entrygroupitem.h b/src/entrygroupitem.h
index 68e9fd5..4531e95 100644
--- a/src/entrygroupitem.h
+++ b/src/entrygroupitem.h
@@ -51,7 +51,7 @@ public:
    */
   virtual TQString key(int col, bool) const;
 
-  virtual int count() const;
+  virtual size_t count() const;
   virtual Data::EntryVec entries() const;
 
 private:
diff --git a/src/entryview.cpp b/src/entryview.cpp
index ab61616..66ad116 100644
--- a/src/entryview.cpp
+++ b/src/entryview.cpp
@@ -26,6 +26,7 @@
 #include "document.h"
 #include "latin1literal.h"
 #include "../core/drophandler.h"
+#include "../tellico_debug.h"
 
 #include <kstandarddirs.h>
 #include <krun.h>
@@ -37,10 +38,22 @@
 #include <tdelocale.h>
 
 #include <tqfile.h>
+#include <tqclipboard.h>
 
 using Tellico::EntryView;
+using Tellico::EntryViewWidget;
 
-EntryView::EntryView(TQWidget* parent_, const char* name_) : TDEHTMLPart(parent_, name_),
+EntryViewWidget::EntryViewWidget(TDEHTMLPart* part, TQWidget* parent)
+    : TDEHTMLView(part, parent) {}
+
+// for the life of me, I could not figure out how to call the actual
+// TDEHTMLPartBrowserExtension::copy() slot, so this will have to do
+void EntryViewWidget::copy() {
+  TQString text = part()->selectedText();
+  TQApplication::clipboard()->setText(text, TQClipboard::Clipboard);
+}
+
+EntryView::EntryView(TQWidget* parent_, const char* name_) : TDEHTMLPart(new EntryViewWidget(this, parent_), parent_, name_),
     m_entry(0), m_handler(0), m_run(0), m_tempFile(0), m_useGradientImages(true), m_checkCommonFile(true) {
   setJScriptEnabled(false);
   setJavaEnabled(false);
diff --git a/src/entryview.h b/src/entryview.h
index 2ddc7e7..b5dc3a3 100644
--- a/src/entryview.h
+++ b/src/entryview.h
@@ -20,6 +20,7 @@ class KTempFile;
 #include "datavectors.h"
 
 #include <tdehtml_part.h>
+#include <tdehtmlview.h>
 
 #include <tqguardedptr.h>
 
@@ -103,5 +104,15 @@ private:
   bool m_checkCommonFile : 1;
 };
 
+// stupid naming on my part, I need to subclass the view to
+// add a slot. EntryView is really a part though
+class EntryViewWidget : public TDEHTMLView {
+Q_OBJECT
+public:
+  EntryViewWidget(TDEHTMLPart* part, TQWidget* parent);
+public slots:
+  void copy();
+};
+
 } //end namespace
 #endif
diff --git a/src/fetch/Makefile.am b/src/fetch/Makefile.am
index 017ef60..2f56fa5 100644
--- a/src/fetch/Makefile.am
+++ b/src/fetch/Makefile.am
@@ -10,7 +10,7 @@ libfetch_a_SOURCES = amazonfetcher.cpp animenfofetcher.cpp arxivfetcher.cpp \
 	discogsfetcher.cpp entrezfetcher.cpp execexternalfetcher.cpp fetcher.cpp fetchmanager.cpp \
 	gcstarpluginfetcher.cpp googlescholarfetcher.cpp ibsfetcher.cpp imdbfetcher.cpp \
 	isbndbfetcher.cpp messagehandler.cpp srufetcher.cpp yahoofetcher.cpp z3950connection.cpp \
-	z3950fetcher.cpp
+	z3950fetcher.cpp amazonrequest.cpp hmac_sha2.c sha2.c
 
 ####### tdevelop will overwrite this part!!! (end)############
 
@@ -40,6 +40,8 @@ citebasefetcher.h citebasefetcher.cpp \
 bibsonomyfetcher.h bibsonomyfetcher.cpp \
 googlescholarfetcher.h googlescholarfetcher.cpp \
 discogsfetcher.h discogsfetcher.cpp \
+amazonrequest.h amazonrequest.cpp \
+hmac_sha2.h hmac_sha2.c sha2.h sha2.c \
 z3950-servers.cfg
 
 appdir = $(kde_datadir)/tellico
diff --git a/src/fetch/amazonfetcher.cpp b/src/fetch/amazonfetcher.cpp
index 9088643..1cb6b0c 100644
--- a/src/fetch/amazonfetcher.cpp
+++ b/src/fetch/amazonfetcher.cpp
@@ -12,6 +12,7 @@
  ***************************************************************************/
 
 #include "amazonfetcher.h"
+#include "amazonrequest.h"
 #include "messagehandler.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
@@ -47,7 +48,6 @@
 namespace {
   static const int AMAZON_RETURNS_PER_REQUEST = 10;
   static const int AMAZON_MAX_RETURNS_TOTAL = 20;
-  static const char* AMAZON_ACCESS_KEY = "0834VQ4S71KYPVSYQD02";
   static const char* AMAZON_ASSOC_TOKEN = "tellico-20";
   // need to have these in the translation file
   static const char* linkText = I18N_NOOP("Amazon Link");
@@ -84,7 +84,6 @@ const AmazonFetcher::SiteData& AmazonFetcher::siteData(int site_) {
 
 AmazonFetcher::AmazonFetcher(Site site_, TQObject* parent_, const char* name_)
     : Fetcher(parent_, name_), m_xsltHandler(0), m_site(site_), m_imageSize(MediumImage),
-      m_access(TQString::fromLatin1(AMAZON_ACCESS_KEY)),
       m_assoc(TQString::fromLatin1(AMAZON_ASSOC_TOKEN)), m_addLinkField(true), m_limit(AMAZON_MAX_RETURNS_TOTAL),
       m_countOffset(0), m_page(1), m_total(-1), m_numResults(0), m_job(0), m_started(false) {
   m_name = siteData(site_).title;
@@ -109,7 +108,8 @@ bool AmazonFetcher::canFetch(int type) const {
          || type == Data::Collection::Bibtex
          || type == Data::Collection::Album
          || type == Data::Collection::Video
-         || type == Data::Collection::Game;
+         || type == Data::Collection::Game
+         || type == Data::Collection::BoardGame;
 }
 
 void AmazonFetcher::readConfigHook(const TDEConfigGroup& config_) {
@@ -117,6 +117,10 @@ void AmazonFetcher::readConfigHook(const TDEConfigGroup& config_) {
   if(!s.isEmpty()) {
     m_access = s;
   }
+  s = config_.readEntry("SecretKey");
+  if(!s.isEmpty()) {
+    m_amazonKey = s;
+  }
   s = config_.readEntry("AssocToken");
   if(!s.isEmpty()) {
     m_assoc = s;
@@ -152,35 +156,41 @@ void AmazonFetcher::doSearch() {
 //  myDebug() << "AmazonFetcher::doSearch() - getting page " << m_page << endl;
 
   const SiteData& data = siteData(m_site);
-  KURL u = data.url;
-  u.addQueryItem(TQString::fromLatin1("Service"),        TQString::fromLatin1("AWSECommerceService"));
-  u.addQueryItem(TQString::fromLatin1("AssociateTag"),   m_assoc);
-  u.addQueryItem(TQString::fromLatin1("AWSAccessKeyId"), m_access);
-  u.addQueryItem(TQString::fromLatin1("Operation"),      TQString::fromLatin1("ItemSearch"));
-  u.addQueryItem(TQString::fromLatin1("ResponseGroup"),  TQString::fromLatin1("Large"));
-  u.addQueryItem(TQString::fromLatin1("ItemPage"),       TQString::number(m_page));
-  u.addQueryItem(TQString::fromLatin1("Version"),        TQString::fromLatin1("2007-10-29"));
+
+  TQMap<TQString, TQString> params;
+  params.insert(TQString::fromLatin1("Service"),        TQString::fromLatin1("AWSECommerceService"));
+  params.insert(TQString::fromLatin1("AssociateTag"),   m_assoc);
+  params.insert(TQString::fromLatin1("AWSAccessKeyId"), m_access);
+  params.insert(TQString::fromLatin1("Operation"),      TQString::fromLatin1("ItemSearch"));
+  params.insert(TQString::fromLatin1("ResponseGroup"),  TQString::fromLatin1("Large"));
+  params.insert(TQString::fromLatin1("ItemPage"),       TQString::number(m_page));
+  params.insert(TQString::fromLatin1("Version"),        TQString::fromLatin1("2007-10-29"));
 
   const int type = Kernel::self()->collectionType();
   switch(type) {
     case Data::Collection::Book:
     case Data::Collection::ComicBook:
     case Data::Collection::Bibtex:
-      u.addQueryItem(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Books"));
-      u.addQueryItem(TQString::fromLatin1("SortIndex"), TQString::fromLatin1("relevancerank"));
+      params.insert(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Books"));
+      params.insert(TQString::fromLatin1("SortIndex"), TQString::fromLatin1("relevancerank"));
       break;
 
     case Data::Collection::Album:
-      u.addQueryItem(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Music"));
+      params.insert(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Music"));
       break;
 
     case Data::Collection::Video:
-      u.addQueryItem(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Video"));
-      u.addQueryItem(TQString::fromLatin1("SortIndex"), TQString::fromLatin1("relevancerank"));
+      params.insert(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Video"));
+      params.insert(TQString::fromLatin1("SortIndex"), TQString::fromLatin1("relevancerank"));
       break;
 
     case Data::Collection::Game:
-      u.addQueryItem(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("VideoGames"));
+      params.insert(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("VideoGames"));
+      break;
+
+    case Data::Collection::BoardGame:
+      params.insert(TQString::fromLatin1("SearchIndex"), TQString::fromLatin1("Toys"));
+      params.insert(TQString::fromLatin1("SortIndex"), TQString::fromLatin1("relevancerank"));
       break;
 
     case Data::Collection::Coin:
@@ -188,7 +198,6 @@ void AmazonFetcher::doSearch() {
     case Data::Collection::Wine:
     case Data::Collection::Base:
     case Data::Collection::Card:
-    default:
       message(i18n("%1 does not allow searching for this collection type.").arg(source()), MessageHandler::Warning);
       stop();
       return;
@@ -207,29 +216,28 @@ void AmazonFetcher::doSearch() {
 
   switch(m_key) {
     case Title:
-      u.addQueryItem(TQString::fromLatin1("Title"), value, mib);
+      params.insert(TQString::fromLatin1("Title"), value);
       break;
 
     case Person:
       if(type == Data::Collection::Video) {
-        u.addQueryItem(TQString::fromLatin1("Actor"),        value, mib);
-        u.addQueryItem(TQString::fromLatin1("Director"),     value, mib);
+        params.insert(TQString::fromLatin1("Actor"),        value);
+        params.insert(TQString::fromLatin1("Director"),     value);
       } else if(type == Data::Collection::Album) {
-        u.addQueryItem(TQString::fromLatin1("Artist"),       value, mib);
+        params.insert(TQString::fromLatin1("Artist"),       value);
       } else if(type == Data::Collection::Game) {
-        u.addQueryItem(TQString::fromLatin1("Manufacturer"), value, mib);
+        params.insert(TQString::fromLatin1("Manufacturer"), value);
       } else { // books and bibtex
         TQString s = TQString::fromLatin1("author:%1 or publisher:%2").arg(value, value);
-//        u.addQueryItem(TQString::fromLatin1("Author"),       value, mib);
-//        u.addQueryItem(TQString::fromLatin1("Publisher"),    value, mib);
-        u.addQueryItem(TQString::fromLatin1("Power"),    s, mib);
+//        params.insert(TQString::fromLatin1("Author"),       value, mib);
+//        params.insert(TQString::fromLatin1("Publisher"),    value, mib);
+        params.insert(TQString::fromLatin1("Power"),    s);
       }
       break;
 
     case ISBN:
       {
-        u.removeQueryItem(TQString::fromLatin1("Operation"));
-        u.addQueryItem(TQString::fromLatin1("Operation"), TQString::fromLatin1("ItemLookup"));
+        params.insert(TQString::fromLatin1("Operation"), TQString::fromLatin1("ItemLookup"));
 
         TQString s = m_value; // not encValue!!!
         s.remove('-');
@@ -260,47 +268,46 @@ void AmazonFetcher::doSearch() {
             }
           }
           // the default search is by ASIN, which prohibits SearchIndex
-          u.removeQueryItem(TQString::fromLatin1("SearchIndex"));
+          params.remove(TQString::fromLatin1("SearchIndex"));
         }
         // limit to first 10
         while(isbns.size() > 10) {
           isbns.pop_back();
         }
-        u.addQueryItem(TQString::fromLatin1("ItemId"), isbns.join(TQString::fromLatin1(",")));
+        params.insert(TQString::fromLatin1("ItemId"), isbns.join(TQString::fromLatin1(",")));
         if(isbn13) {
-          u.addQueryItem(TQString::fromLatin1("IdType"), TQString::fromLatin1("EAN"));
+          params.insert(TQString::fromLatin1("IdType"), TQString::fromLatin1("EAN"));
         }
       }
       break;
 
     case UPC:
       {
-        u.removeQueryItem(TQString::fromLatin1("Operation"));
-        u.addQueryItem(TQString::fromLatin1("Operation"), TQString::fromLatin1("ItemLookup"));
+        params.insert(TQString::fromLatin1("Operation"), TQString::fromLatin1("ItemLookup"));
         // US allows UPC, all others are EAN
         if(m_site == US) {
-          u.addQueryItem(TQString::fromLatin1("IdType"), TQString::fromLatin1("UPC"));
+          params.insert(TQString::fromLatin1("IdType"), TQString::fromLatin1("UPC"));
         } else {
-          u.addQueryItem(TQString::fromLatin1("IdType"), TQString::fromLatin1("EAN"));
+          params.insert(TQString::fromLatin1("IdType"), TQString::fromLatin1("EAN"));
         }
         TQString s = m_value; // not encValue!!!
         s.remove('-');
         // limit to first 10
         s.replace(TQString::fromLatin1("; "), TQString::fromLatin1(","));
         s = s.section(',', 0, 9);
-        u.addQueryItem(TQString::fromLatin1("ItemId"), s);
+        params.insert(TQString::fromLatin1("ItemId"), s);
       }
       break;
 
     case Keyword:
-      u.addQueryItem(TQString::fromLatin1("Keywords"), m_value, mib);
+      params.insert(TQString::fromLatin1("Keywords"), value);
       break;
 
     case Raw:
       {
         TQString key = value.section('=', 0, 0).stripWhiteSpace();
         TQString str = value.section('=', 1).stripWhiteSpace();
-        u.addQueryItem(key, str, mib);
+        params.insert(key, str);
       }
       break;
 
@@ -309,9 +316,11 @@ void AmazonFetcher::doSearch() {
       stop();
       return;
   }
-//  myDebug() << "AmazonFetcher::search() - url: " << u.url() << endl;
+  AmazonRequest request(siteData(m_site).url, m_amazonKey);
+  KURL newUrl = request.signedRequest(params);
+//  myDebug() << "AmazonFetcher::search() - url: " << newUrl.url() << endl;
 
-  m_job = TDEIO::get(u, false, false);
+  m_job = TDEIO::get(newUrl, false, false);
   connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
           TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
   connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)),
@@ -520,6 +529,12 @@ void AmazonFetcher::slotComplete(TDEIO::Job* job_) {
                + entry->field(TQString::fromLatin1("year"));
         break;
 
+      case Data::Collection::BoardGame:
+        desc = entry->field(TQString::fromLatin1("publisher"))
+               + TQChar('/')
+               + entry->field(TQString::fromLatin1("year"));
+        break;
+
       default:
         break;
     }
@@ -889,11 +904,25 @@ AmazonFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const AmazonFetcher
   TQWhatsThis::add(m_assocEdit, w);
   label->setBuddy(m_assocEdit);
 
+  label = new TQLabel(i18n("Access key: "), optionsWidget());
+  l->addWidget(label, ++row, 0);
+  m_accessEdit = new KLineEdit(optionsWidget());
+  connect(m_accessEdit, SIGNAL(textChanged(const TQString&)), SLOT(slotSetModified()));
+  l->addWidget(m_accessEdit, row, 1);
+
+  label = new TQLabel(i18n("Secret Key: "), optionsWidget());
+  l->addWidget(label, ++row, 0);
+  m_secretKeyEdit = new KLineEdit(optionsWidget());
+  connect(m_secretKeyEdit, SIGNAL(textChanged(const TQString&)), SLOT(slotSetModified()));
+  l->addWidget(m_secretKeyEdit, row, 1);
+
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_siteCombo->setCurrentData(fetcher_->m_site);
     m_assocEdit->setText(fetcher_->m_assoc);
+    m_accessEdit->setText(fetcher_->m_access);
+    m_secretKeyEdit->setText(fetcher_->m_amazonKey);
     m_imageCombo->setCurrentData(fetcher_->m_imageSize);
   } else { // defaults
     m_assocEdit->setText(TQString::fromLatin1(AMAZON_ASSOC_TOKEN));
@@ -912,6 +941,14 @@ void AmazonFetcher::ConfigWidget::saveConfig(TDEConfigGroup& config_) {
   if(!s.isEmpty()) {
     config_.writeEntry("AssocToken", s);
   }
+  s = m_accessEdit->text().stripWhiteSpace();
+  if(!s.isEmpty()) {
+    config_.writeEntry("AccessKey", s);
+  }
+  s = m_secretKeyEdit->text().stripWhiteSpace();
+  if(!s.isEmpty()) {
+    config_.writeEntry("SecretKey", s);
+  }
   n = m_imageCombo->currentData().toInt();
   config_.writeEntry("Image Size", n);
 
diff --git a/src/fetch/amazonfetcher.h b/src/fetch/amazonfetcher.h
index 03aed7d..8628b2c 100644
--- a/src/fetch/amazonfetcher.h
+++ b/src/fetch/amazonfetcher.h
@@ -118,6 +118,7 @@ private:
   ImageSize m_imageSize;
 
   TQString m_access;
+  TQString m_amazonKey;
   TQString m_assoc;
   bool m_addLinkField;
   int m_limit;
@@ -151,6 +152,8 @@ private slots:
 
 private:
   KLineEdit* m_assocEdit;
+  KLineEdit* m_accessEdit;
+  KLineEdit* m_secretKeyEdit;
   GUI::ComboBox* m_siteCombo;
   GUI::ComboBox* m_imageCombo;
 };
diff --git a/src/fetch/amazonrequest.cpp b/src/fetch/amazonrequest.cpp
new file mode 100644
index 0000000..bb8d729
--- /dev/null
+++ b/src/fetch/amazonrequest.cpp
@@ -0,0 +1,72 @@
+/***************************************************************************
+    Copyright (C) 2007-2009 Robby Stephenson <[email protected]>
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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) version 3 or any later version        *
+ *   accepted by the membership of KDE e.V. (or its successor approved     *
+ *   by the membership of KDE e.V.), which shall act as a proxy            *
+ *   defined in Section 14 of version 3 of the license.                    *
+ *                                                                         *
+ *   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, see <http://www.gnu.org/licenses/>. *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "amazonrequest.h"
+#include "hmac_sha2.h"
+#include "../tellico_debug.h"
+
+#include <kmdcodec.h>
+
+#include <tqdatetime.h>
+
+using Tellico::Fetch::AmazonRequest;
+
+AmazonRequest::AmazonRequest(const KURL& site_, const TQString& key_) : m_siteUrl(site_), m_key(key_) {
+}
+
+KURL AmazonRequest::signedRequest(const TQMap<TQString, TQString>& params_) const {
+  TQMap<TQString, TQString> allParams = params_;
+  allParams.insert(TQString::fromLatin1("Timestamp"),
+                   TQDateTime::currentDateTime(TQt::UTC).toString(TQt::ISODate));
+
+  TQString query;
+  // has to be a map so that the query elements are sorted
+  TQMap<TQString, TQString>::Iterator it;
+  for ( it = allParams.begin(); it != allParams.end(); ++it ) {
+    query += KURL::encode_string(it.key());
+    query += '=';
+    query += KURL::encode_string(it.data());
+    query += '&';
+  }
+  // remove last '&'
+  query.truncate(query.length()-1);
+
+  const TQCString toSign = "GET\n"
+                          + m_siteUrl.host().utf8() + '\n'
+                          + m_siteUrl.path().utf8() + '\n'
+                          + query.latin1();
+
+  TQByteArray hmac_buffer;
+  hmac_buffer.fill('\0', SHA256_DIGEST_SIZE);
+  // subtract one from string size for toSign, not exactly sure why
+  hmac_sha256(reinterpret_cast<unsigned char*>(const_cast<char*>(m_key.latin1())), m_key.length(),
+              reinterpret_cast<unsigned char*>(toSign.data()), toSign.size()-1,
+              reinterpret_cast<unsigned char*>(hmac_buffer.data()), hmac_buffer.size());
+  const TQString sig = KURL::encode_string(KCodecs::base64Encode(hmac_buffer));
+//  myDebug() << sig << endl;
+
+  KURL url = m_siteUrl;
+  url.setQuery(query + "&Signature=" + sig);
+  return url;
+}
diff --git a/src/fetch/amazonrequest.h b/src/fetch/amazonrequest.h
new file mode 100644
index 0000000..d1d9017
--- /dev/null
+++ b/src/fetch/amazonrequest.h
@@ -0,0 +1,52 @@
+/***************************************************************************
+    Copyright (C) 2007-2009 Robby Stephenson <[email protected]>
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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) version 3 or any later version        *
+ *   accepted by the membership of KDE e.V. (or its successor approved     *
+ *   by the membership of KDE e.V.), which shall act as a proxy            *
+ *   defined in Section 14 of version 3 of the license.                    *
+ *                                                                         *
+ *   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, see <http://www.gnu.org/licenses/>. *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef TELLICO_FETCH_AMAZONREQUEST_H
+#define TELLICO_FETCH_AMAZONREQUEST_H
+
+#include <kurl.h>
+
+#include <tqmap.h>
+
+namespace Tellico {
+  namespace Fetch {
+
+/**
+ * @author Robby Stephenson
+ */
+class AmazonRequest {
+public:
+  AmazonRequest(const KURL& site, const TQString& key);
+
+  KURL signedRequest(const TQMap<TQString, TQString>& params) const;
+
+private:
+  KURL m_siteUrl;
+  TQString m_key;
+};
+
+  } // end Fetch namespace
+} // end Tellico namespace
+
+#endif
diff --git a/src/fetch/arxivfetcher.cpp b/src/fetch/arxivfetcher.cpp
index f59d246..ec3f8fb 100644
--- a/src/fetch/arxivfetcher.cpp
+++ b/src/fetch/arxivfetcher.cpp
@@ -226,6 +226,13 @@ Tellico::Data::EntryPtr ArxivFetcher::fetchEntry(uint uid_) {
       }
     }
   }
+  TQRegExp versionRx(TQString::fromLatin1("v\\d+$"));
+  // if the original search was not for a versioned ID, remove it
+  if(m_key != ArxivID || !m_value.contains(versionRx)) {
+    TQString arxiv = entry->field(TQString::fromLatin1("arxiv"));
+    arxiv.remove(versionRx);
+    entry->setField(TQString::fromLatin1("arxiv"), arxiv);
+  }
   return entry;
 }
 
diff --git a/src/fetch/citebasefetcher.cpp b/src/fetch/citebasefetcher.cpp
index f5e8cd6..2b5a8db 100644
--- a/src/fetch/citebasefetcher.cpp
+++ b/src/fetch/citebasefetcher.cpp
@@ -163,7 +163,15 @@ void CitebaseFetcher::slotComplete(TDEIO::Job* job_) {
 }
 
 Tellico::Data::EntryPtr CitebaseFetcher::fetchEntry(uint uid_) {
-  return m_entries[uid_];
+  Data::EntryPtr entry = m_entries[uid_];
+  TQRegExp versionRx(TQString::fromLatin1("v\\d+$"));
+  // if the original search was not for a versioned ID, remove it
+  if(m_key != ArxivID || !m_value.contains(versionRx)) {
+    TQString arxiv = entry->field(TQString::fromLatin1("arxiv"));
+    arxiv.remove(versionRx);
+    entry->setField(TQString::fromLatin1("arxiv"), arxiv);
+  }
+  return entry;
 }
 
 KURL CitebaseFetcher::searchURL(FetchKey key_, const TQString& value_) const {
diff --git a/src/fetch/entrezfetcher.cpp b/src/fetch/entrezfetcher.cpp
index 07066b8..b1d2789 100644
--- a/src/fetch/entrezfetcher.cpp
+++ b/src/fetch/entrezfetcher.cpp
@@ -34,7 +34,7 @@
 //#define ENTREZ_TEST
 
 namespace {
-  static const int ENTREZ_MAX_RETURNS_TOTAL = 25;
+  static const size_t ENTREZ_MAX_RETURNS_TOTAL = 25;
   static const char* ENTREZ_BASE_URL = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/";
   static const char* ENTREZ_SEARCH_CGI = "esearch.fcgi";
   static const char* ENTREZ_SUMMARY_CGI = "esummary.fcgi";
diff --git a/src/fetch/entrezfetcher.h b/src/fetch/entrezfetcher.h
index 87e13ae..7a9a0a1 100644
--- a/src/fetch/entrezfetcher.h
+++ b/src/fetch/entrezfetcher.h
@@ -92,8 +92,8 @@ private:
   XSLTHandler* m_xsltHandler;
   TQString m_dbname;
 
-  int m_start;
-  int m_total;
+  size_t m_start;
+  size_t m_total;
 
   TQByteArray m_data;
   TQMap<int, Data::EntryPtr> m_entries; // map from search result id to entry
diff --git a/src/fetch/googlescholarfetcher.cpp b/src/fetch/googlescholarfetcher.cpp
index 19e69c6..8ac7d4d 100644
--- a/src/fetch/googlescholarfetcher.cpp
+++ b/src/fetch/googlescholarfetcher.cpp
@@ -28,7 +28,7 @@
 #include <tqlayout.h>
 
 namespace {
-  static const int GOOGLE_MAX_RETURNS_TOTAL = 20;
+  static const size_t GOOGLE_MAX_RETURNS_TOTAL = 20;
   static const char* SCHOLAR_BASE_URL = "http://scholar.google.com/scholar";
 }
 
@@ -157,7 +157,7 @@ void GoogleScholarFetcher::slotComplete(TDEIO::Job* job_) {
 
   TQString text = TQString::fromUtf8(m_data, m_data.size());
   TQString bibtex;
-  int count = 0;
+  size_t count = 0;
   for(int pos = text.find(m_bibtexRx); count < m_limit && pos > -1; pos = text.find(m_bibtexRx, pos+m_bibtexRx.matchedLength()), ++count) {
     KURL bibtexUrl(TQString::fromLatin1(SCHOLAR_BASE_URL), m_bibtexRx.cap(1));
 //    myDebug() << bibtexUrl << endl;
diff --git a/src/fetch/googlescholarfetcher.h b/src/fetch/googlescholarfetcher.h
index 8ef91da..5c0b8a1 100644
--- a/src/fetch/googlescholarfetcher.h
+++ b/src/fetch/googlescholarfetcher.h
@@ -83,9 +83,9 @@ private slots:
 private:
   void doSearch();
 
-  int m_limit;
-  int m_start;
-  int m_total;
+  size_t m_limit;
+  size_t m_start;
+  size_t m_total;
 
   TQByteArray m_data;
   TQMap<int, Data::EntryPtr> m_entries;
diff --git a/src/fetch/hmac_sha2.c b/src/fetch/hmac_sha2.c
new file mode 100644
index 0000000..dd7c24a
--- /dev/null
+++ b/src/fetch/hmac_sha2.c
@@ -0,0 +1,544 @@
+/*-
+ * HMAC-SHA-224/256/384/512 implementation
+ * Last update: 06/15/2005
+ * Issue date:  06/15/2005
+ *
+ * Copyright (C) 2005 Olivier Gay <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+#include "hmac_sha2.h"
+
+/* HMAC-SHA-224 functions */
+
+void hmac_sha224_init(hmac_sha224_ctx *ctx, unsigned char *key,
+                      unsigned int key_size)
+{
+    unsigned int fill;
+    unsigned int num;
+
+    unsigned char *key_used;
+    unsigned char key_temp[SHA224_DIGEST_SIZE];
+    int i;
+
+    if (key_size == SHA224_BLOCK_SIZE) {
+        key_used = key;
+        num = SHA224_BLOCK_SIZE;
+    } else {
+        if (key_size > SHA224_BLOCK_SIZE){
+            key_used = key_temp;
+            num = SHA224_DIGEST_SIZE;
+            sha224(key, key_size, key_used);
+        } else { /* key_size > SHA224_BLOCK_SIZE */
+            key_used = key;
+            num = key_size;
+        }
+        fill = SHA224_BLOCK_SIZE - num;
+
+        memset(ctx->block_ipad + num, 0x36, fill);
+        memset(ctx->block_opad + num, 0x5c, fill);
+    }
+
+    for (i = 0; i < num; i++) {
+        ctx->block_ipad[i] = key_used[i] ^ 0x36;
+        ctx->block_opad[i] = key_used[i] ^ 0x5c;
+    }
+
+    sha224_init(&ctx->ctx_inside);
+    sha224_update(&ctx->ctx_inside, ctx->block_ipad, SHA224_BLOCK_SIZE);
+
+    sha224_init(&ctx->ctx_outside);
+    sha224_update(&ctx->ctx_outside, ctx->block_opad,
+                  SHA224_BLOCK_SIZE);
+
+    /* for hmac_reinit */
+    memcpy(&ctx->ctx_inside_reinit, &ctx->ctx_inside,
+           sizeof(sha224_ctx));
+    memcpy(&ctx->ctx_outside_reinit, &ctx->ctx_outside,
+           sizeof(sha224_ctx));
+}
+
+void hmac_sha224_reinit(hmac_sha224_ctx *ctx)
+{
+    memcpy(&ctx->ctx_inside, &ctx->ctx_inside_reinit,
+           sizeof(sha224_ctx));
+    memcpy(&ctx->ctx_outside, &ctx->ctx_outside_reinit,
+           sizeof(sha224_ctx));
+}
+
+void hmac_sha224_update(hmac_sha224_ctx *ctx, unsigned char *message,
+                        unsigned int message_len)
+{
+    sha224_update(&ctx->ctx_inside, message, message_len);
+}
+
+void hmac_sha224_final(hmac_sha224_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size)
+{
+    unsigned char digest_inside[SHA224_DIGEST_SIZE];
+    unsigned char mac_temp[SHA224_DIGEST_SIZE];
+
+    sha224_final(&ctx->ctx_inside, digest_inside);
+    sha224_update(&ctx->ctx_outside, digest_inside, SHA224_DIGEST_SIZE);
+    sha224_final(&ctx->ctx_outside, mac_temp);
+    memcpy(mac, mac_temp, mac_size);
+}
+
+void hmac_sha224(unsigned char *key, unsigned int key_size,
+          unsigned char *message, unsigned int message_len,
+          unsigned char *mac, unsigned mac_size)
+{
+    hmac_sha224_ctx ctx;
+
+    hmac_sha224_init(&ctx, key, key_size);
+    hmac_sha224_update(&ctx, message, message_len);
+    hmac_sha224_final(&ctx, mac, mac_size);
+}
+
+/* HMAC-SHA-256 functions */
+
+void hmac_sha256_init(hmac_sha256_ctx *ctx, unsigned char *key,
+                      unsigned int key_size)
+{
+    unsigned int fill;
+    unsigned int num;
+
+    unsigned char *key_used;
+    unsigned char key_temp[SHA256_DIGEST_SIZE];
+    int i;
+
+    if (key_size == SHA256_BLOCK_SIZE) {
+        key_used = key;
+        num = SHA256_BLOCK_SIZE;
+    } else {
+        if (key_size > SHA256_BLOCK_SIZE){
+            key_used = key_temp;
+            num = SHA256_DIGEST_SIZE;
+            sha256(key, key_size, key_used);
+        } else { /* key_size > SHA256_BLOCK_SIZE */
+            key_used = key;
+            num = key_size;
+        }
+        fill = SHA256_BLOCK_SIZE - num;
+
+        memset(ctx->block_ipad + num, 0x36, fill);
+        memset(ctx->block_opad + num, 0x5c, fill);
+    }
+
+    for (i = 0; i < num; i++) {
+        ctx->block_ipad[i] = key_used[i] ^ 0x36;
+        ctx->block_opad[i] = key_used[i] ^ 0x5c;
+    }
+
+    sha256_init(&ctx->ctx_inside);
+    sha256_update(&ctx->ctx_inside, ctx->block_ipad, SHA256_BLOCK_SIZE);
+
+    sha256_init(&ctx->ctx_outside);
+    sha256_update(&ctx->ctx_outside, ctx->block_opad,
+                  SHA256_BLOCK_SIZE);
+
+    /* for hmac_reinit */
+    memcpy(&ctx->ctx_inside_reinit, &ctx->ctx_inside,
+           sizeof(sha256_ctx));
+    memcpy(&ctx->ctx_outside_reinit, &ctx->ctx_outside,
+           sizeof(sha256_ctx));
+}
+
+void hmac_sha256_reinit(hmac_sha256_ctx *ctx)
+{
+    memcpy(&ctx->ctx_inside, &ctx->ctx_inside_reinit,
+           sizeof(sha256_ctx));
+    memcpy(&ctx->ctx_outside, &ctx->ctx_outside_reinit,
+           sizeof(sha256_ctx));
+}
+
+void hmac_sha256_update(hmac_sha256_ctx *ctx, unsigned char *message,
+                        unsigned int message_len)
+{
+    sha256_update(&ctx->ctx_inside, message, message_len);
+}
+
+void hmac_sha256_final(hmac_sha256_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size)
+{
+    unsigned char digest_inside[SHA256_DIGEST_SIZE];
+    unsigned char mac_temp[SHA256_DIGEST_SIZE];
+
+    sha256_final(&ctx->ctx_inside, digest_inside);
+    sha256_update(&ctx->ctx_outside, digest_inside, SHA256_DIGEST_SIZE);
+    sha256_final(&ctx->ctx_outside, mac_temp);
+    memcpy(mac, mac_temp, mac_size);
+}
+
+void hmac_sha256(unsigned char *key, unsigned int key_size,
+          unsigned char *message, unsigned int message_len,
+          unsigned char *mac, unsigned mac_size)
+{
+    hmac_sha256_ctx ctx;
+
+    hmac_sha256_init(&ctx, key, key_size);
+    hmac_sha256_update(&ctx, message, message_len);
+    hmac_sha256_final(&ctx, mac, mac_size);
+}
+
+/* HMAC-SHA-384 functions */
+
+void hmac_sha384_init(hmac_sha384_ctx *ctx, unsigned char *key,
+                      unsigned int key_size)
+{
+    unsigned int fill;
+    unsigned int num;
+
+    unsigned char *key_used;
+    unsigned char key_temp[SHA384_DIGEST_SIZE];
+    int i;
+
+    if (key_size == SHA384_BLOCK_SIZE) {
+        key_used = key;
+        num = SHA384_BLOCK_SIZE;
+    } else {
+        if (key_size > SHA384_BLOCK_SIZE){
+            key_used = key_temp;
+            num = SHA384_DIGEST_SIZE;
+            sha384(key, key_size, key_used);
+        } else { /* key_size > SHA384_BLOCK_SIZE */
+            key_used = key;
+            num = key_size;
+        }
+        fill = SHA384_BLOCK_SIZE - num;
+
+        memset(ctx->block_ipad + num, 0x36, fill);
+        memset(ctx->block_opad + num, 0x5c, fill);
+    }
+
+    for (i = 0; i < num; i++) {
+        ctx->block_ipad[i] = key_used[i] ^ 0x36;
+        ctx->block_opad[i] = key_used[i] ^ 0x5c;
+    }
+
+    sha384_init(&ctx->ctx_inside);
+    sha384_update(&ctx->ctx_inside, ctx->block_ipad, SHA384_BLOCK_SIZE);
+
+    sha384_init(&ctx->ctx_outside);
+    sha384_update(&ctx->ctx_outside, ctx->block_opad,
+                  SHA384_BLOCK_SIZE);
+
+    /* for hmac_reinit */
+    memcpy(&ctx->ctx_inside_reinit, &ctx->ctx_inside,
+           sizeof(sha384_ctx));
+    memcpy(&ctx->ctx_outside_reinit, &ctx->ctx_outside,
+           sizeof(sha384_ctx));
+}
+
+void hmac_sha384_reinit(hmac_sha384_ctx *ctx)
+{
+    memcpy(&ctx->ctx_inside, &ctx->ctx_inside_reinit,
+           sizeof(sha384_ctx));
+    memcpy(&ctx->ctx_outside, &ctx->ctx_outside_reinit,
+           sizeof(sha384_ctx));
+}
+
+void hmac_sha384_update(hmac_sha384_ctx *ctx, unsigned char *message,
+                        unsigned int message_len)
+{
+    sha384_update(&ctx->ctx_inside, message, message_len);
+}
+
+void hmac_sha384_final(hmac_sha384_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size)
+{
+    unsigned char digest_inside[SHA384_DIGEST_SIZE];
+    unsigned char mac_temp[SHA384_DIGEST_SIZE];
+
+    sha384_final(&ctx->ctx_inside, digest_inside);
+    sha384_update(&ctx->ctx_outside, digest_inside, SHA384_DIGEST_SIZE);
+    sha384_final(&ctx->ctx_outside, mac_temp);
+    memcpy(mac, mac_temp, mac_size);
+}
+
+void hmac_sha384(unsigned char *key, unsigned int key_size,
+          unsigned char *message, unsigned int message_len,
+          unsigned char *mac, unsigned mac_size)
+{
+    hmac_sha384_ctx ctx;
+
+    hmac_sha384_init(&ctx, key, key_size);
+    hmac_sha384_update(&ctx, message, message_len);
+    hmac_sha384_final(&ctx, mac, mac_size);
+}
+
+/* HMAC-SHA-512 functions */
+
+void hmac_sha512_init(hmac_sha512_ctx *ctx, unsigned char *key,
+                      unsigned int key_size)
+{
+    unsigned int fill;
+    unsigned int num;
+
+    unsigned char *key_used;
+    unsigned char key_temp[SHA512_DIGEST_SIZE];
+    int i;
+
+    if (key_size == SHA512_BLOCK_SIZE) {
+        key_used = key;
+        num = SHA512_BLOCK_SIZE;
+    } else {
+        if (key_size > SHA512_BLOCK_SIZE){
+            key_used = key_temp;
+            num = SHA512_DIGEST_SIZE;
+            sha512(key, key_size, key_used);
+        } else { /* key_size > SHA512_BLOCK_SIZE */
+            key_used = key;
+            num = key_size;
+        }
+        fill = SHA512_BLOCK_SIZE - num;
+
+        memset(ctx->block_ipad + num, 0x36, fill);
+        memset(ctx->block_opad + num, 0x5c, fill);
+    }
+
+    for (i = 0; i < num; i++) {
+        ctx->block_ipad[i] = key_used[i] ^ 0x36;
+        ctx->block_opad[i] = key_used[i] ^ 0x5c;
+    }
+
+    sha512_init(&ctx->ctx_inside);
+    sha512_update(&ctx->ctx_inside, ctx->block_ipad, SHA512_BLOCK_SIZE);
+
+    sha512_init(&ctx->ctx_outside);
+    sha512_update(&ctx->ctx_outside, ctx->block_opad,
+                  SHA512_BLOCK_SIZE);
+
+    /* for hmac_reinit */
+    memcpy(&ctx->ctx_inside_reinit, &ctx->ctx_inside,
+           sizeof(sha512_ctx));
+    memcpy(&ctx->ctx_outside_reinit, &ctx->ctx_outside,
+           sizeof(sha512_ctx));
+}
+
+void hmac_sha512_reinit(hmac_sha512_ctx *ctx)
+{
+    memcpy(&ctx->ctx_inside, &ctx->ctx_inside_reinit,
+           sizeof(sha512_ctx));
+    memcpy(&ctx->ctx_outside, &ctx->ctx_outside_reinit,
+           sizeof(sha512_ctx));
+}
+
+void hmac_sha512_update(hmac_sha512_ctx *ctx, unsigned char *message,
+                        unsigned int message_len)
+{
+    sha512_update(&ctx->ctx_inside, message, message_len);
+}
+
+void hmac_sha512_final(hmac_sha512_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size)
+{
+    unsigned char digest_inside[SHA512_DIGEST_SIZE];
+    unsigned char mac_temp[SHA512_DIGEST_SIZE];
+
+    sha512_final(&ctx->ctx_inside, digest_inside);
+    sha512_update(&ctx->ctx_outside, digest_inside, SHA512_DIGEST_SIZE);
+    sha512_final(&ctx->ctx_outside, mac_temp);
+    memcpy(mac, mac_temp, mac_size);
+}
+
+void hmac_sha512(unsigned char *key, unsigned int key_size,
+          unsigned char *message, unsigned int message_len,
+          unsigned char *mac, unsigned mac_size)
+{
+    hmac_sha512_ctx ctx;
+
+    hmac_sha512_init(&ctx, key, key_size);
+    hmac_sha512_update(&ctx, message, message_len);
+    hmac_sha512_final(&ctx, mac, mac_size);
+}
+
+#ifdef TEST_VECTORS
+
+/* IETF Validation tests */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void test(unsigned char *vector, unsigned char *digest,
+          unsigned int digest_size)
+{
+    unsigned char output[2 * SHA512_DIGEST_SIZE + 1];
+    int i;
+
+    output[2 * digest_size] = '\0';
+
+    for (i = 0; i < digest_size ; i++) {
+       sprintf((char *) output + 2*i, "%02x", digest[i]);
+    }
+
+    printf("H: %s\n", output);
+    if (strcmp((char *) vector, (char *) output)) {
+        fprintf(stderr, "Test failed.\n");
+        exit(1);
+    }
+}
+
+int main()
+{
+    static unsigned char *vectors[] =
+    {
+        /* HMAC-SHA-224 */
+        "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
+        "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
+        "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
+        "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
+        "0e2aea68a90c8d37c988bcdb9fca6fa8",
+        "95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
+        "3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1",
+        /* HMAC-SHA-256 */
+        "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+        "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+        "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
+        "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
+        "a3b6167473100ee06e0c796c2955552b",
+        "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
+        "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
+        /* HMAC-SHA-384 */
+        "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59c"
+        "faea9ea9076ede7f4af152e8b2fa9cb6",
+        "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e"
+        "8e2240ca5e69e2c78b3239ecfab21649",
+        "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b"
+        "2a5ab39dc13814b94e3ab6e101a34f27",
+        "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e"
+        "6801dd23c4a7d679ccf8a386c674cffb",
+        "3abf34c3503b2a23a46efc619baef897",
+        "4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c6"
+        "0c2ef6ab4030fe8296248df163f44952",
+        "6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5"
+        "a678cc31e799176d3860e6110c46523e",
+        /* HMAC-SHA-512 */
+        "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde"
+        "daa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854",
+        "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554"
+        "9758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
+        "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39"
+        "bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb",
+        "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db"
+        "a91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd",
+        "415fad6271580a531d4179bc891d87a6",
+        "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352"
+        "6b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598",
+        "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944"
+        "b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"
+    };
+
+    static unsigned char *messages[] =
+    {
+        "Hi There",
+        "what do ya want for nothing?",
+        NULL,
+        NULL,
+        "Test With Truncation",
+        "Test Using Larger Than Block-Size Key - Hash Key First",
+        "This is a test using a larger than block-size key "
+        "and a larger than block-size data. The key needs"
+        " to be hashed before being used by the HMAC algorithm."
+    };
+
+    unsigned char mac[SHA512_DIGEST_SIZE];
+    unsigned char *keys[7];
+    unsigned int keys_len[7] = {20, 4, 20, 25, 20, 131, 131};
+    unsigned int messages2and3_len = 50;
+    unsigned int mac_224_size, mac_256_size, mac_384_size, mac_512_size;
+    int i;
+
+    for (i = 0; i < 7; i++) {
+        keys[i] = malloc(keys_len[i]);
+        if (keys[i] == NULL) {
+            fprintf(stderr, "Can't allocate memory\n");
+            return 1;
+        }
+    }
+
+    memset(keys[0], 0x0b, keys_len[0]);
+    strcpy(keys[1], "Jefe");
+    memset(keys[2], 0xaa, keys_len[2]);
+    for (i = 0; i < keys_len[3]; i++)
+        keys[3][i] = (unsigned char) i + 1;
+    memset(keys[4], 0x0c, keys_len[4]);
+    memset(keys[5], 0xaa, keys_len[5]);
+    memset(keys[6], 0xaa, keys_len[6]);
+
+    messages[2] = malloc(messages2and3_len + 1);
+    messages[3] = malloc(messages2and3_len + 1);
+
+    if (messages[2] == NULL || messages[3] == NULL) {
+        fprintf(stderr, "Can't allocate memory\n");
+        return 1;
+    }
+
+    messages[2][messages2and3_len] = '\0';
+    messages[3][messages2and3_len] = '\0';
+
+    memset(messages[2], 0xdd, messages2and3_len);
+    memset(messages[3], 0xcd, messages2and3_len);
+
+    printf("HMAC-SHA-2 IETF Validation tests\n\n");
+
+    for (i = 0; i < 7; i++) {
+        if (i != 4) {
+            mac_224_size = SHA224_DIGEST_SIZE;
+            mac_256_size = SHA256_DIGEST_SIZE;
+            mac_384_size = SHA384_DIGEST_SIZE;
+            mac_512_size = SHA512_DIGEST_SIZE;
+        } else {
+            mac_224_size = 128 / 8; mac_256_size = 128 / 8;
+            mac_384_size = 128 / 8; mac_512_size = 128 / 8;
+        }
+
+        printf("Test %d:\n", i + 1);
+
+        hmac_sha224(keys[i], keys_len[i], messages[i], strlen(messages[i]),
+                    mac, mac_224_size);
+        test(vectors[i], mac, mac_224_size );
+        hmac_sha256(keys[i], keys_len[i], messages[i], strlen(messages[i]),
+                    mac, mac_256_size);
+        test(vectors[7 + i], mac, mac_256_size);
+        hmac_sha384(keys[i], keys_len[i], messages[i], strlen(messages[i]),
+                    mac, mac_384_size);
+        test(vectors[14 + i], mac, mac_384_size);
+        hmac_sha512(keys[i], keys_len[i], messages[i], strlen(messages[i]),
+                    mac, mac_512_size);
+        test(vectors[21 + i], mac, mac_512_size);
+    }
+
+    printf("All tests passed.\n");
+
+    return 0;
+}
+
+#endif /* TEST_VECTORS */
+
diff --git a/src/fetch/hmac_sha2.h b/src/fetch/hmac_sha2.h
new file mode 100644
index 0000000..f10fb49
--- /dev/null
+++ b/src/fetch/hmac_sha2.h
@@ -0,0 +1,140 @@
+/*-
+ * HMAC-SHA-224/256/384/512 implementation
+ * Last update: 06/15/2005
+ * Issue date:  06/15/2005
+ *
+ * Copyright (C) 2005 Olivier Gay <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _HMAC_SHA2_H
+#define _HMAC_SHA2_H
+
+#include "sha2.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    sha224_ctx ctx_inside;
+    sha224_ctx ctx_outside;
+
+    /* for hmac_reinit */
+    sha224_ctx ctx_inside_reinit;
+    sha224_ctx ctx_outside_reinit;
+
+    unsigned char block_ipad[SHA224_BLOCK_SIZE];
+    unsigned char block_opad[SHA224_BLOCK_SIZE];
+} hmac_sha224_ctx;
+
+typedef struct {
+    sha256_ctx ctx_inside;
+    sha256_ctx ctx_outside;
+
+    /* for hmac_reinit */
+    sha256_ctx ctx_inside_reinit;
+    sha256_ctx ctx_outside_reinit;
+
+    unsigned char block_ipad[SHA256_BLOCK_SIZE];
+    unsigned char block_opad[SHA256_BLOCK_SIZE];
+} hmac_sha256_ctx;
+
+typedef struct {
+    sha384_ctx ctx_inside;
+    sha384_ctx ctx_outside;
+
+    /* for hmac_reinit */
+    sha384_ctx ctx_inside_reinit;
+    sha384_ctx ctx_outside_reinit;
+
+    unsigned char block_ipad[SHA384_BLOCK_SIZE];
+    unsigned char block_opad[SHA384_BLOCK_SIZE];
+} hmac_sha384_ctx;
+
+typedef struct {
+    sha512_ctx ctx_inside;
+    sha512_ctx ctx_outside;
+
+    /* for hmac_reinit */
+    sha512_ctx ctx_inside_reinit;
+    sha512_ctx ctx_outside_reinit;
+
+    unsigned char block_ipad[SHA512_BLOCK_SIZE];
+    unsigned char block_opad[SHA512_BLOCK_SIZE];
+} hmac_sha512_ctx;
+
+void hmac_sha224_init(hmac_sha224_ctx *ctx, unsigned char *key,
+                      unsigned int key_size);
+void hmac_sha224_reinit(hmac_sha224_ctx *ctx);
+void hmac_sha224_update(hmac_sha224_ctx *ctx, unsigned char *message,
+                        unsigned int message_len);
+void hmac_sha224_final(hmac_sha224_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size);
+void hmac_sha224(unsigned char *key, unsigned int key_size,
+                 unsigned char *message, unsigned int message_len,
+                 unsigned char *mac, unsigned mac_size);
+
+void hmac_sha256_init(hmac_sha256_ctx *ctx, unsigned char *key,
+                      unsigned int key_size);
+void hmac_sha256_reinit(hmac_sha256_ctx *ctx);
+void hmac_sha256_update(hmac_sha256_ctx *ctx, unsigned char *message,
+                        unsigned int message_len);
+void hmac_sha256_final(hmac_sha256_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size);
+void hmac_sha256(unsigned char *key, unsigned int key_size,
+                 unsigned char *message, unsigned int message_len,
+                 unsigned char *mac, unsigned mac_size);
+
+void hmac_sha384_init(hmac_sha384_ctx *ctx, unsigned char *key,
+                      unsigned int key_size);
+void hmac_sha384_reinit(hmac_sha384_ctx *ctx);
+void hmac_sha384_update(hmac_sha384_ctx *ctx, unsigned char *message,
+                        unsigned int message_len);
+void hmac_sha384_final(hmac_sha384_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size);
+void hmac_sha384(unsigned char *key, unsigned int key_size,
+                 unsigned char *message, unsigned int message_len,
+                 unsigned char *mac, unsigned mac_size);
+
+void hmac_sha512_init(hmac_sha512_ctx *ctx, unsigned char *key,
+                      unsigned int key_size);
+void hmac_sha512_reinit(hmac_sha512_ctx *ctx);
+void hmac_sha512_update(hmac_sha512_ctx *ctx, unsigned char *message,
+                        unsigned int message_len);
+void hmac_sha512_final(hmac_sha512_ctx *ctx, unsigned char *mac,
+                       unsigned int mac_size);
+void hmac_sha512(unsigned char *key, unsigned int key_size,
+                 unsigned char *message, unsigned int message_len,
+                 unsigned char *mac, unsigned mac_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ! _HMAC_SHA2_H */
+
diff --git a/src/fetch/ibsfetcher.cpp b/src/fetch/ibsfetcher.cpp
index e715e5b..404bc1c 100644
--- a/src/fetch/ibsfetcher.cpp
+++ b/src/fetch/ibsfetcher.cpp
@@ -156,7 +156,8 @@ void IBSFetcher::slotComplete(TDEIO::Job* job_) {
 
   TQString s = Tellico::decodeHTML(TQString(m_data));
   // really specific regexp
-  TQString pat = TQString::fromLatin1("http://www.internetbookshop.it/code/");
+  //TQString pat = TQString::fromLatin1("http://www.internetbookshop.it/code/");
+  TQString pat = TQString::fromLatin1("http://www.ibs.it/code/");
   TQRegExp anchorRx(TQString::fromLatin1("<a\\s+[^>]*href\\s*=\\s*[\"'](") +
                    TQRegExp::escape(pat) +
                    TQString::fromLatin1("[^\"]*)\"[^>]*><b>([^<]+)<"), false);
diff --git a/src/fetch/imdbfetcher.cpp b/src/fetch/imdbfetcher.cpp
index a9c0dd0..36b19a1 100644
--- a/src/fetch/imdbfetcher.cpp
+++ b/src/fetch/imdbfetcher.cpp
@@ -799,7 +799,7 @@ void IMDBFetcher::doPlot(const TQString& str_, Data::EntryPtr entry_, const KURL
 
   TQString thisPlot;
   // match until next opening tag
-  TQRegExp plotRx(TQString::fromLatin1("plot (?:outline|summary):(.*)<[^/].*</"), false);
+  TQRegExp plotRx(TQString::fromLatin1("plot\\s*(?:outline|summary)?:(.*)<[^/].*</"), false);
   plotRx.setMinimal(true);
   TQRegExp plotURLRx(TQString::fromLatin1("<a\\s+.*href\\s*=\\s*\".*/title/.*/plotsummary\""), false);
   plotURLRx.setMinimal(true);
@@ -828,6 +828,8 @@ void IMDBFetcher::doPlot(const TQString& str_, Data::EntryPtr entry_, const KURL
       if(plotRx.search(plotPage) > -1) {
         TQString userPlot = plotRx.cap(1);
         userPlot.remove(*s_tagRx); // remove HTML tags
+        // remove last little "written by", if there
+        userPlot.remove(TQRegExp(TQString::fromLatin1("\\s*written by.*$"), false));
         entry_->setField(TQString::fromLatin1("plot"), Tellico::decodeHTML(userPlot));
       }
     }
diff --git a/src/fetch/sha2.c b/src/fetch/sha2.c
new file mode 100644
index 0000000..a32427e
--- /dev/null
+++ b/src/fetch/sha2.c
@@ -0,0 +1,950 @@
+/*
+ * FIPS 180-2 SHA-224/256/384/512 implementation
+ * Last update: 02/02/2007
+ * Issue date:  04/30/2005
+ *
+ * Copyright (C) 2005, 2007 Olivier Gay <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if 0
+#define UNROLL_LOOPS /* Enable loops unrolling */
+#endif
+
+#include <string.h>
+
+#include "sha2.h"
+
+#define SHFR(x, n)    (x >> n)
+#define ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
+#define ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
+#define CH(x, y, z)  ((x & y) ^ (~x & z))
+#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
+
+#define SHA256_F1(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
+#define SHA256_F2(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
+#define SHA256_F3(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
+#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))
+
+#define SHA512_F1(x) (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39))
+#define SHA512_F2(x) (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41))
+#define SHA512_F3(x) (ROTR(x,  1) ^ ROTR(x,  8) ^ SHFR(x,  7))
+#define SHA512_F4(x) (ROTR(x, 19) ^ ROTR(x, 61) ^ SHFR(x,  6))
+
+#define UNPACK32(x, str)                      \
+{                                             \
+    *((str) + 3) = (uint8) ((x)      );       \
+    *((str) + 2) = (uint8) ((x) >>  8);       \
+    *((str) + 1) = (uint8) ((x) >> 16);       \
+    *((str) + 0) = (uint8) ((x) >> 24);       \
+}
+
+#define PACK32(str, x)                        \
+{                                             \
+    *(x) =   ((uint32) *((str) + 3)      )    \
+           | ((uint32) *((str) + 2) <<  8)    \
+           | ((uint32) *((str) + 1) << 16)    \
+           | ((uint32) *((str) + 0) << 24);   \
+}
+
+#define UNPACK64(x, str)                      \
+{                                             \
+    *((str) + 7) = (uint8) ((x)      );       \
+    *((str) + 6) = (uint8) ((x) >>  8);       \
+    *((str) + 5) = (uint8) ((x) >> 16);       \
+    *((str) + 4) = (uint8) ((x) >> 24);       \
+    *((str) + 3) = (uint8) ((x) >> 32);       \
+    *((str) + 2) = (uint8) ((x) >> 40);       \
+    *((str) + 1) = (uint8) ((x) >> 48);       \
+    *((str) + 0) = (uint8) ((x) >> 56);       \
+}
+
+#define PACK64(str, x)                        \
+{                                             \
+    *(x) =   ((uint64) *((str) + 7)      )    \
+           | ((uint64) *((str) + 6) <<  8)    \
+           | ((uint64) *((str) + 5) << 16)    \
+           | ((uint64) *((str) + 4) << 24)    \
+           | ((uint64) *((str) + 3) << 32)    \
+           | ((uint64) *((str) + 2) << 40)    \
+           | ((uint64) *((str) + 1) << 48)    \
+           | ((uint64) *((str) + 0) << 56);   \
+}
+
+/* Macros used for loops unrolling */
+
+#define SHA256_SCR(i)                         \
+{                                             \
+    w[i] =  SHA256_F4(w[i -  2]) + w[i -  7]  \
+          + SHA256_F3(w[i - 15]) + w[i - 16]; \
+}
+
+#define SHA512_SCR(i)                         \
+{                                             \
+    w[i] =  SHA512_F4(w[i -  2]) + w[i -  7]  \
+          + SHA512_F3(w[i - 15]) + w[i - 16]; \
+}
+
+#define SHA256_EXP(a, b, c, d, e, f, g, h, j)               \
+{                                                           \
+    t1 = wv[h] + SHA256_F2(wv[e]) + CH(wv[e], wv[f], wv[g]) \
+         + sha256_k[j] + w[j];                              \
+    t2 = SHA256_F1(wv[a]) + MAJ(wv[a], wv[b], wv[c]);       \
+    wv[d] += t1;                                            \
+    wv[h] = t1 + t2;                                        \
+}
+
+#define SHA512_EXP(a, b, c, d, e, f, g ,h, j)               \
+{                                                           \
+    t1 = wv[h] + SHA512_F2(wv[e]) + CH(wv[e], wv[f], wv[g]) \
+         + sha512_k[j] + w[j];                              \
+    t2 = SHA512_F1(wv[a]) + MAJ(wv[a], wv[b], wv[c]);       \
+    wv[d] += t1;                                            \
+    wv[h] = t1 + t2;                                        \
+}
+
+uint32 sha224_h0[8] =
+            {0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+             0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
+
+uint32 sha256_h0[8] =
+            {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+             0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
+
+uint64 sha384_h0[8] =
+            {0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL,
+             0x9159015a3070dd17ULL, 0x152fecd8f70e5939ULL,
+             0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL,
+             0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL};
+
+uint64 sha512_h0[8] =
+            {0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
+             0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
+             0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
+             0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL};
+
+uint32 sha256_k[64] =
+            {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+             0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+             0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+             0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+             0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+             0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+             0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+             0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+             0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+             0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+             0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+             0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+             0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+             0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+             0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+             0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
+
+uint64 sha512_k[80] =
+            {0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+             0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+             0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+             0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+             0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+             0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+             0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+             0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+             0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+             0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+             0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+             0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+             0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+             0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+             0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+             0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+             0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+             0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+             0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+             0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+             0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+             0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+             0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+             0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+             0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+             0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+             0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+             0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+             0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+             0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+             0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+             0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+             0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+             0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+             0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+             0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+             0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+             0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+             0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+             0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};
+
+/* SHA-256 functions */
+
+void sha256_transf(sha256_ctx *ctx, const unsigned char *message,
+                   unsigned int block_nb)
+{
+    uint32 w[64];
+    uint32 wv[8];
+    uint32 t1, t2;
+    const unsigned char *sub_block;
+    int i;
+
+#ifndef UNROLL_LOOPS
+    int j;
+#endif
+
+    for (i = 0; i < (int) block_nb; i++) {
+        sub_block = message + (i << 6);
+
+#ifndef UNROLL_LOOPS
+        for (j = 0; j < 16; j++) {
+            PACK32(&sub_block[j << 2], &w[j]);
+        }
+
+        for (j = 16; j < 64; j++) {
+            SHA256_SCR(j);
+        }
+
+        for (j = 0; j < 8; j++) {
+            wv[j] = ctx->h[j];
+        }
+
+        for (j = 0; j < 64; j++) {
+            t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6])
+                + sha256_k[j] + w[j];
+            t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
+            wv[7] = wv[6];
+            wv[6] = wv[5];
+            wv[5] = wv[4];
+            wv[4] = wv[3] + t1;
+            wv[3] = wv[2];
+            wv[2] = wv[1];
+            wv[1] = wv[0];
+            wv[0] = t1 + t2;
+        }
+
+        for (j = 0; j < 8; j++) {
+            ctx->h[j] += wv[j];
+        }
+#else
+        PACK32(&sub_block[ 0], &w[ 0]); PACK32(&sub_block[ 4], &w[ 1]);
+        PACK32(&sub_block[ 8], &w[ 2]); PACK32(&sub_block[12], &w[ 3]);
+        PACK32(&sub_block[16], &w[ 4]); PACK32(&sub_block[20], &w[ 5]);
+        PACK32(&sub_block[24], &w[ 6]); PACK32(&sub_block[28], &w[ 7]);
+        PACK32(&sub_block[32], &w[ 8]); PACK32(&sub_block[36], &w[ 9]);
+        PACK32(&sub_block[40], &w[10]); PACK32(&sub_block[44], &w[11]);
+        PACK32(&sub_block[48], &w[12]); PACK32(&sub_block[52], &w[13]);
+        PACK32(&sub_block[56], &w[14]); PACK32(&sub_block[60], &w[15]);
+
+        SHA256_SCR(16); SHA256_SCR(17); SHA256_SCR(18); SHA256_SCR(19);
+        SHA256_SCR(20); SHA256_SCR(21); SHA256_SCR(22); SHA256_SCR(23);
+        SHA256_SCR(24); SHA256_SCR(25); SHA256_SCR(26); SHA256_SCR(27);
+        SHA256_SCR(28); SHA256_SCR(29); SHA256_SCR(30); SHA256_SCR(31);
+        SHA256_SCR(32); SHA256_SCR(33); SHA256_SCR(34); SHA256_SCR(35);
+        SHA256_SCR(36); SHA256_SCR(37); SHA256_SCR(38); SHA256_SCR(39);
+        SHA256_SCR(40); SHA256_SCR(41); SHA256_SCR(42); SHA256_SCR(43);
+        SHA256_SCR(44); SHA256_SCR(45); SHA256_SCR(46); SHA256_SCR(47);
+        SHA256_SCR(48); SHA256_SCR(49); SHA256_SCR(50); SHA256_SCR(51);
+        SHA256_SCR(52); SHA256_SCR(53); SHA256_SCR(54); SHA256_SCR(55);
+        SHA256_SCR(56); SHA256_SCR(57); SHA256_SCR(58); SHA256_SCR(59);
+        SHA256_SCR(60); SHA256_SCR(61); SHA256_SCR(62); SHA256_SCR(63);
+
+        wv[0] = ctx->h[0]; wv[1] = ctx->h[1];
+        wv[2] = ctx->h[2]; wv[3] = ctx->h[3];
+        wv[4] = ctx->h[4]; wv[5] = ctx->h[5];
+        wv[6] = ctx->h[6]; wv[7] = ctx->h[7];
+
+        SHA256_EXP(0,1,2,3,4,5,6,7, 0); SHA256_EXP(7,0,1,2,3,4,5,6, 1);
+        SHA256_EXP(6,7,0,1,2,3,4,5, 2); SHA256_EXP(5,6,7,0,1,2,3,4, 3);
+        SHA256_EXP(4,5,6,7,0,1,2,3, 4); SHA256_EXP(3,4,5,6,7,0,1,2, 5);
+        SHA256_EXP(2,3,4,5,6,7,0,1, 6); SHA256_EXP(1,2,3,4,5,6,7,0, 7);
+        SHA256_EXP(0,1,2,3,4,5,6,7, 8); SHA256_EXP(7,0,1,2,3,4,5,6, 9);
+        SHA256_EXP(6,7,0,1,2,3,4,5,10); SHA256_EXP(5,6,7,0,1,2,3,4,11);
+        SHA256_EXP(4,5,6,7,0,1,2,3,12); SHA256_EXP(3,4,5,6,7,0,1,2,13);
+        SHA256_EXP(2,3,4,5,6,7,0,1,14); SHA256_EXP(1,2,3,4,5,6,7,0,15);
+        SHA256_EXP(0,1,2,3,4,5,6,7,16); SHA256_EXP(7,0,1,2,3,4,5,6,17);
+        SHA256_EXP(6,7,0,1,2,3,4,5,18); SHA256_EXP(5,6,7,0,1,2,3,4,19);
+        SHA256_EXP(4,5,6,7,0,1,2,3,20); SHA256_EXP(3,4,5,6,7,0,1,2,21);
+        SHA256_EXP(2,3,4,5,6,7,0,1,22); SHA256_EXP(1,2,3,4,5,6,7,0,23);
+        SHA256_EXP(0,1,2,3,4,5,6,7,24); SHA256_EXP(7,0,1,2,3,4,5,6,25);
+        SHA256_EXP(6,7,0,1,2,3,4,5,26); SHA256_EXP(5,6,7,0,1,2,3,4,27);
+        SHA256_EXP(4,5,6,7,0,1,2,3,28); SHA256_EXP(3,4,5,6,7,0,1,2,29);
+        SHA256_EXP(2,3,4,5,6,7,0,1,30); SHA256_EXP(1,2,3,4,5,6,7,0,31);
+        SHA256_EXP(0,1,2,3,4,5,6,7,32); SHA256_EXP(7,0,1,2,3,4,5,6,33);
+        SHA256_EXP(6,7,0,1,2,3,4,5,34); SHA256_EXP(5,6,7,0,1,2,3,4,35);
+        SHA256_EXP(4,5,6,7,0,1,2,3,36); SHA256_EXP(3,4,5,6,7,0,1,2,37);
+        SHA256_EXP(2,3,4,5,6,7,0,1,38); SHA256_EXP(1,2,3,4,5,6,7,0,39);
+        SHA256_EXP(0,1,2,3,4,5,6,7,40); SHA256_EXP(7,0,1,2,3,4,5,6,41);
+        SHA256_EXP(6,7,0,1,2,3,4,5,42); SHA256_EXP(5,6,7,0,1,2,3,4,43);
+        SHA256_EXP(4,5,6,7,0,1,2,3,44); SHA256_EXP(3,4,5,6,7,0,1,2,45);
+        SHA256_EXP(2,3,4,5,6,7,0,1,46); SHA256_EXP(1,2,3,4,5,6,7,0,47);
+        SHA256_EXP(0,1,2,3,4,5,6,7,48); SHA256_EXP(7,0,1,2,3,4,5,6,49);
+        SHA256_EXP(6,7,0,1,2,3,4,5,50); SHA256_EXP(5,6,7,0,1,2,3,4,51);
+        SHA256_EXP(4,5,6,7,0,1,2,3,52); SHA256_EXP(3,4,5,6,7,0,1,2,53);
+        SHA256_EXP(2,3,4,5,6,7,0,1,54); SHA256_EXP(1,2,3,4,5,6,7,0,55);
+        SHA256_EXP(0,1,2,3,4,5,6,7,56); SHA256_EXP(7,0,1,2,3,4,5,6,57);
+        SHA256_EXP(6,7,0,1,2,3,4,5,58); SHA256_EXP(5,6,7,0,1,2,3,4,59);
+        SHA256_EXP(4,5,6,7,0,1,2,3,60); SHA256_EXP(3,4,5,6,7,0,1,2,61);
+        SHA256_EXP(2,3,4,5,6,7,0,1,62); SHA256_EXP(1,2,3,4,5,6,7,0,63);
+
+        ctx->h[0] += wv[0]; ctx->h[1] += wv[1];
+        ctx->h[2] += wv[2]; ctx->h[3] += wv[3];
+        ctx->h[4] += wv[4]; ctx->h[5] += wv[5];
+        ctx->h[6] += wv[6]; ctx->h[7] += wv[7];
+#endif /* !UNROLL_LOOPS */
+    }
+}
+
+void sha256(const unsigned char *message, unsigned int len, unsigned char *digest)
+{
+    sha256_ctx ctx;
+
+    sha256_init(&ctx);
+    sha256_update(&ctx, message, len);
+    sha256_final(&ctx, digest);
+}
+
+void sha256_init(sha256_ctx *ctx)
+{
+#ifndef UNROLL_LOOPS
+    int i;
+    for (i = 0; i < 8; i++) {
+        ctx->h[i] = sha256_h0[i];
+    }
+#else
+    ctx->h[0] = sha256_h0[0]; ctx->h[1] = sha256_h0[1];
+    ctx->h[2] = sha256_h0[2]; ctx->h[3] = sha256_h0[3];
+    ctx->h[4] = sha256_h0[4]; ctx->h[5] = sha256_h0[5];
+    ctx->h[6] = sha256_h0[6]; ctx->h[7] = sha256_h0[7];
+#endif /* !UNROLL_LOOPS */
+
+    ctx->len = 0;
+    ctx->tot_len = 0;
+}
+
+void sha256_update(sha256_ctx *ctx, const unsigned char *message,
+                   unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+
+    tmp_len = SHA256_BLOCK_SIZE - ctx->len;
+    rem_len = len < tmp_len ? len : tmp_len;
+
+    memcpy(&ctx->block[ctx->len], message, rem_len);
+
+    if (ctx->len + len < SHA256_BLOCK_SIZE) {
+        ctx->len += len;
+        return;
+    }
+
+    new_len = len - rem_len;
+    block_nb = new_len / SHA256_BLOCK_SIZE;
+
+    shifted_message = message + rem_len;
+
+    sha256_transf(ctx, ctx->block, 1);
+    sha256_transf(ctx, shifted_message, block_nb);
+
+    rem_len = new_len % SHA256_BLOCK_SIZE;
+
+    memcpy(ctx->block, &shifted_message[block_nb << 6],
+           rem_len);
+
+    ctx->len = rem_len;
+    ctx->tot_len += (block_nb + 1) << 6;
+}
+
+void sha256_final(sha256_ctx *ctx, unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+
+#ifndef UNROLL_LOOPS
+    int i;
+#endif
+
+    block_nb = (1 + ((SHA256_BLOCK_SIZE - 9)
+                     < (ctx->len % SHA256_BLOCK_SIZE)));
+
+    len_b = (ctx->tot_len + ctx->len) << 3;
+    pm_len = block_nb << 6;
+
+    memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
+    ctx->block[ctx->len] = 0x80;
+    UNPACK32(len_b, ctx->block + pm_len - 4);
+
+    sha256_transf(ctx, ctx->block, block_nb);
+
+#ifndef UNROLL_LOOPS
+    for (i = 0 ; i < 8; i++) {
+        UNPACK32(ctx->h[i], &digest[i << 2]);
+    }
+#else
+   UNPACK32(ctx->h[0], &digest[ 0]);
+   UNPACK32(ctx->h[1], &digest[ 4]);
+   UNPACK32(ctx->h[2], &digest[ 8]);
+   UNPACK32(ctx->h[3], &digest[12]);
+   UNPACK32(ctx->h[4], &digest[16]);
+   UNPACK32(ctx->h[5], &digest[20]);
+   UNPACK32(ctx->h[6], &digest[24]);
+   UNPACK32(ctx->h[7], &digest[28]);
+#endif /* !UNROLL_LOOPS */
+}
+
+/* SHA-512 functions */
+
+void sha512_transf(sha512_ctx *ctx, const unsigned char *message,
+                   unsigned int block_nb)
+{
+    uint64 w[80];
+    uint64 wv[8];
+    uint64 t1, t2;
+    const unsigned char *sub_block;
+    int i, j;
+
+    for (i = 0; i < (int) block_nb; i++) {
+        sub_block = message + (i << 7);
+
+#ifndef UNROLL_LOOPS
+        for (j = 0; j < 16; j++) {
+            PACK64(&sub_block[j << 3], &w[j]);
+        }
+
+        for (j = 16; j < 80; j++) {
+            SHA512_SCR(j);
+        }
+
+        for (j = 0; j < 8; j++) {
+            wv[j] = ctx->h[j];
+        }
+
+        for (j = 0; j < 80; j++) {
+            t1 = wv[7] + SHA512_F2(wv[4]) + CH(wv[4], wv[5], wv[6])
+                + sha512_k[j] + w[j];
+            t2 = SHA512_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
+            wv[7] = wv[6];
+            wv[6] = wv[5];
+            wv[5] = wv[4];
+            wv[4] = wv[3] + t1;
+            wv[3] = wv[2];
+            wv[2] = wv[1];
+            wv[1] = wv[0];
+            wv[0] = t1 + t2;
+        }
+
+        for (j = 0; j < 8; j++) {
+            ctx->h[j] += wv[j];
+        }
+#else
+        PACK64(&sub_block[  0], &w[ 0]); PACK64(&sub_block[  8], &w[ 1]);
+        PACK64(&sub_block[ 16], &w[ 2]); PACK64(&sub_block[ 24], &w[ 3]);
+        PACK64(&sub_block[ 32], &w[ 4]); PACK64(&sub_block[ 40], &w[ 5]);
+        PACK64(&sub_block[ 48], &w[ 6]); PACK64(&sub_block[ 56], &w[ 7]);
+        PACK64(&sub_block[ 64], &w[ 8]); PACK64(&sub_block[ 72], &w[ 9]);
+        PACK64(&sub_block[ 80], &w[10]); PACK64(&sub_block[ 88], &w[11]);
+        PACK64(&sub_block[ 96], &w[12]); PACK64(&sub_block[104], &w[13]);
+        PACK64(&sub_block[112], &w[14]); PACK64(&sub_block[120], &w[15]);
+
+        SHA512_SCR(16); SHA512_SCR(17); SHA512_SCR(18); SHA512_SCR(19);
+        SHA512_SCR(20); SHA512_SCR(21); SHA512_SCR(22); SHA512_SCR(23);
+        SHA512_SCR(24); SHA512_SCR(25); SHA512_SCR(26); SHA512_SCR(27);
+        SHA512_SCR(28); SHA512_SCR(29); SHA512_SCR(30); SHA512_SCR(31);
+        SHA512_SCR(32); SHA512_SCR(33); SHA512_SCR(34); SHA512_SCR(35);
+        SHA512_SCR(36); SHA512_SCR(37); SHA512_SCR(38); SHA512_SCR(39);
+        SHA512_SCR(40); SHA512_SCR(41); SHA512_SCR(42); SHA512_SCR(43);
+        SHA512_SCR(44); SHA512_SCR(45); SHA512_SCR(46); SHA512_SCR(47);
+        SHA512_SCR(48); SHA512_SCR(49); SHA512_SCR(50); SHA512_SCR(51);
+        SHA512_SCR(52); SHA512_SCR(53); SHA512_SCR(54); SHA512_SCR(55);
+        SHA512_SCR(56); SHA512_SCR(57); SHA512_SCR(58); SHA512_SCR(59);
+        SHA512_SCR(60); SHA512_SCR(61); SHA512_SCR(62); SHA512_SCR(63);
+        SHA512_SCR(64); SHA512_SCR(65); SHA512_SCR(66); SHA512_SCR(67);
+        SHA512_SCR(68); SHA512_SCR(69); SHA512_SCR(70); SHA512_SCR(71);
+        SHA512_SCR(72); SHA512_SCR(73); SHA512_SCR(74); SHA512_SCR(75);
+        SHA512_SCR(76); SHA512_SCR(77); SHA512_SCR(78); SHA512_SCR(79);
+
+        wv[0] = ctx->h[0]; wv[1] = ctx->h[1];
+        wv[2] = ctx->h[2]; wv[3] = ctx->h[3];
+        wv[4] = ctx->h[4]; wv[5] = ctx->h[5];
+        wv[6] = ctx->h[6]; wv[7] = ctx->h[7];
+
+        j = 0;
+
+        do {
+            SHA512_EXP(0,1,2,3,4,5,6,7,j); j++;
+            SHA512_EXP(7,0,1,2,3,4,5,6,j); j++;
+            SHA512_EXP(6,7,0,1,2,3,4,5,j); j++;
+            SHA512_EXP(5,6,7,0,1,2,3,4,j); j++;
+            SHA512_EXP(4,5,6,7,0,1,2,3,j); j++;
+            SHA512_EXP(3,4,5,6,7,0,1,2,j); j++;
+            SHA512_EXP(2,3,4,5,6,7,0,1,j); j++;
+            SHA512_EXP(1,2,3,4,5,6,7,0,j); j++;
+        } while (j < 80);
+
+        ctx->h[0] += wv[0]; ctx->h[1] += wv[1];
+        ctx->h[2] += wv[2]; ctx->h[3] += wv[3];
+        ctx->h[4] += wv[4]; ctx->h[5] += wv[5];
+        ctx->h[6] += wv[6]; ctx->h[7] += wv[7];
+#endif /* !UNROLL_LOOPS */
+    }
+}
+
+void sha512(const unsigned char *message, unsigned int len,
+            unsigned char *digest)
+{
+    sha512_ctx ctx;
+
+    sha512_init(&ctx);
+    sha512_update(&ctx, message, len);
+    sha512_final(&ctx, digest);
+}
+
+void sha512_init(sha512_ctx *ctx)
+{
+#ifndef UNROLL_LOOPS
+    int i;
+    for (i = 0; i < 8; i++) {
+        ctx->h[i] = sha512_h0[i];
+    }
+#else
+    ctx->h[0] = sha512_h0[0]; ctx->h[1] = sha512_h0[1];
+    ctx->h[2] = sha512_h0[2]; ctx->h[3] = sha512_h0[3];
+    ctx->h[4] = sha512_h0[4]; ctx->h[5] = sha512_h0[5];
+    ctx->h[6] = sha512_h0[6]; ctx->h[7] = sha512_h0[7];
+#endif /* !UNROLL_LOOPS */
+
+    ctx->len = 0;
+    ctx->tot_len = 0;
+}
+
+void sha512_update(sha512_ctx *ctx, const unsigned char *message,
+                   unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+
+    tmp_len = SHA512_BLOCK_SIZE - ctx->len;
+    rem_len = len < tmp_len ? len : tmp_len;
+
+    memcpy(&ctx->block[ctx->len], message, rem_len);
+
+    if (ctx->len + len < SHA512_BLOCK_SIZE) {
+        ctx->len += len;
+        return;
+    }
+
+    new_len = len - rem_len;
+    block_nb = new_len / SHA512_BLOCK_SIZE;
+
+    shifted_message = message + rem_len;
+
+    sha512_transf(ctx, ctx->block, 1);
+    sha512_transf(ctx, shifted_message, block_nb);
+
+    rem_len = new_len % SHA512_BLOCK_SIZE;
+
+    memcpy(ctx->block, &shifted_message[block_nb << 7],
+           rem_len);
+
+    ctx->len = rem_len;
+    ctx->tot_len += (block_nb + 1) << 7;
+}
+
+void sha512_final(sha512_ctx *ctx, unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+
+#ifndef UNROLL_LOOPS
+    int i;
+#endif
+
+    block_nb = 1 + ((SHA512_BLOCK_SIZE - 17)
+                     < (ctx->len % SHA512_BLOCK_SIZE));
+
+    len_b = (ctx->tot_len + ctx->len) << 3;
+    pm_len = block_nb << 7;
+
+    memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
+    ctx->block[ctx->len] = 0x80;
+    UNPACK32(len_b, ctx->block + pm_len - 4);
+
+    sha512_transf(ctx, ctx->block, block_nb);
+
+#ifndef UNROLL_LOOPS
+    for (i = 0 ; i < 8; i++) {
+        UNPACK64(ctx->h[i], &digest[i << 3]);
+    }
+#else
+    UNPACK64(ctx->h[0], &digest[ 0]);
+    UNPACK64(ctx->h[1], &digest[ 8]);
+    UNPACK64(ctx->h[2], &digest[16]);
+    UNPACK64(ctx->h[3], &digest[24]);
+    UNPACK64(ctx->h[4], &digest[32]);
+    UNPACK64(ctx->h[5], &digest[40]);
+    UNPACK64(ctx->h[6], &digest[48]);
+    UNPACK64(ctx->h[7], &digest[56]);
+#endif /* !UNROLL_LOOPS */
+}
+
+/* SHA-384 functions */
+
+void sha384(const unsigned char *message, unsigned int len,
+            unsigned char *digest)
+{
+    sha384_ctx ctx;
+
+    sha384_init(&ctx);
+    sha384_update(&ctx, message, len);
+    sha384_final(&ctx, digest);
+}
+
+void sha384_init(sha384_ctx *ctx)
+{
+#ifndef UNROLL_LOOPS
+    int i;
+    for (i = 0; i < 8; i++) {
+        ctx->h[i] = sha384_h0[i];
+    }
+#else
+    ctx->h[0] = sha384_h0[0]; ctx->h[1] = sha384_h0[1];
+    ctx->h[2] = sha384_h0[2]; ctx->h[3] = sha384_h0[3];
+    ctx->h[4] = sha384_h0[4]; ctx->h[5] = sha384_h0[5];
+    ctx->h[6] = sha384_h0[6]; ctx->h[7] = sha384_h0[7];
+#endif /* !UNROLL_LOOPS */
+
+    ctx->len = 0;
+    ctx->tot_len = 0;
+}
+
+void sha384_update(sha384_ctx *ctx, const unsigned char *message,
+                   unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+
+    tmp_len = SHA384_BLOCK_SIZE - ctx->len;
+    rem_len = len < tmp_len ? len : tmp_len;
+
+    memcpy(&ctx->block[ctx->len], message, rem_len);
+
+    if (ctx->len + len < SHA384_BLOCK_SIZE) {
+        ctx->len += len;
+        return;
+    }
+
+    new_len = len - rem_len;
+    block_nb = new_len / SHA384_BLOCK_SIZE;
+
+    shifted_message = message + rem_len;
+
+    sha512_transf(ctx, ctx->block, 1);
+    sha512_transf(ctx, shifted_message, block_nb);
+
+    rem_len = new_len % SHA384_BLOCK_SIZE;
+
+    memcpy(ctx->block, &shifted_message[block_nb << 7],
+           rem_len);
+
+    ctx->len = rem_len;
+    ctx->tot_len += (block_nb + 1) << 7;
+}
+
+void sha384_final(sha384_ctx *ctx, unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+
+#ifndef UNROLL_LOOPS
+    int i;
+#endif
+
+    block_nb = (1 + ((SHA384_BLOCK_SIZE - 17)
+                     < (ctx->len % SHA384_BLOCK_SIZE)));
+
+    len_b = (ctx->tot_len + ctx->len) << 3;
+    pm_len = block_nb << 7;
+
+    memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
+    ctx->block[ctx->len] = 0x80;
+    UNPACK32(len_b, ctx->block + pm_len - 4);
+
+    sha512_transf(ctx, ctx->block, block_nb);
+
+#ifndef UNROLL_LOOPS
+    for (i = 0 ; i < 6; i++) {
+        UNPACK64(ctx->h[i], &digest[i << 3]);
+    }
+#else
+    UNPACK64(ctx->h[0], &digest[ 0]);
+    UNPACK64(ctx->h[1], &digest[ 8]);
+    UNPACK64(ctx->h[2], &digest[16]);
+    UNPACK64(ctx->h[3], &digest[24]);
+    UNPACK64(ctx->h[4], &digest[32]);
+    UNPACK64(ctx->h[5], &digest[40]);
+#endif /* !UNROLL_LOOPS */
+}
+
+/* SHA-224 functions */
+
+void sha224(const unsigned char *message, unsigned int len,
+            unsigned char *digest)
+{
+    sha224_ctx ctx;
+
+    sha224_init(&ctx);
+    sha224_update(&ctx, message, len);
+    sha224_final(&ctx, digest);
+}
+
+void sha224_init(sha224_ctx *ctx)
+{
+#ifndef UNROLL_LOOPS
+    int i;
+    for (i = 0; i < 8; i++) {
+        ctx->h[i] = sha224_h0[i];
+    }
+#else
+    ctx->h[0] = sha224_h0[0]; ctx->h[1] = sha224_h0[1];
+    ctx->h[2] = sha224_h0[2]; ctx->h[3] = sha224_h0[3];
+    ctx->h[4] = sha224_h0[4]; ctx->h[5] = sha224_h0[5];
+    ctx->h[6] = sha224_h0[6]; ctx->h[7] = sha224_h0[7];
+#endif /* !UNROLL_LOOPS */
+
+    ctx->len = 0;
+    ctx->tot_len = 0;
+}
+
+void sha224_update(sha224_ctx *ctx, const unsigned char *message,
+                   unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+
+    tmp_len = SHA224_BLOCK_SIZE - ctx->len;
+    rem_len = len < tmp_len ? len : tmp_len;
+
+    memcpy(&ctx->block[ctx->len], message, rem_len);
+
+    if (ctx->len + len < SHA224_BLOCK_SIZE) {
+        ctx->len += len;
+        return;
+    }
+
+    new_len = len - rem_len;
+    block_nb = new_len / SHA224_BLOCK_SIZE;
+
+    shifted_message = message + rem_len;
+
+    sha256_transf(ctx, ctx->block, 1);
+    sha256_transf(ctx, shifted_message, block_nb);
+
+    rem_len = new_len % SHA224_BLOCK_SIZE;
+
+    memcpy(ctx->block, &shifted_message[block_nb << 6],
+           rem_len);
+
+    ctx->len = rem_len;
+    ctx->tot_len += (block_nb + 1) << 6;
+}
+
+void sha224_final(sha224_ctx *ctx, unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+
+#ifndef UNROLL_LOOPS
+    int i;
+#endif
+
+    block_nb = (1 + ((SHA224_BLOCK_SIZE - 9)
+                     < (ctx->len % SHA224_BLOCK_SIZE)));
+
+    len_b = (ctx->tot_len + ctx->len) << 3;
+    pm_len = block_nb << 6;
+
+    memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
+    ctx->block[ctx->len] = 0x80;
+    UNPACK32(len_b, ctx->block + pm_len - 4);
+
+    sha256_transf(ctx, ctx->block, block_nb);
+
+#ifndef UNROLL_LOOPS
+    for (i = 0 ; i < 7; i++) {
+        UNPACK32(ctx->h[i], &digest[i << 2]);
+    }
+#else
+   UNPACK32(ctx->h[0], &digest[ 0]);
+   UNPACK32(ctx->h[1], &digest[ 4]);
+   UNPACK32(ctx->h[2], &digest[ 8]);
+   UNPACK32(ctx->h[3], &digest[12]);
+   UNPACK32(ctx->h[4], &digest[16]);
+   UNPACK32(ctx->h[5], &digest[20]);
+   UNPACK32(ctx->h[6], &digest[24]);
+#endif /* !UNROLL_LOOPS */
+}
+
+#ifdef TEST_VECTORS
+
+/* FIPS 180-2 Validation tests */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void test(const unsigned char *vector, unsigned char *digest,
+          unsigned int digest_size)
+{
+    unsigned char output[2 * SHA512_DIGEST_SIZE + 1];
+    int i;
+
+    output[2 * digest_size] = '\0';
+
+    for (i = 0; i < (int) digest_size ; i++) {
+       sprintf((char *) output + 2 * i, "%02x", digest[i]);
+    }
+
+    printf("H: %s\n", output);
+    if (strcmp((char *) vector, (char *) output)) {
+        fprintf(stderr, "Test failed.\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
+int main()
+{
+    static const unsigned char *vectors[4][3] =
+    {   /* SHA-224 */
+        {
+        "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7",
+        "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525",
+        "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67",
+        },
+        /* SHA-256 */
+        {
+        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+        "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+        "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+        },
+        /* SHA-384 */
+        {
+        "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed"
+        "8086072ba1e7cc2358baeca134c825a7",
+        "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712"
+        "fcc7c71a557e2db966c3e9fa91746039",
+        "9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b"
+        "07b8b3dc38ecc4ebae97ddd87f3d8985",
+        },
+        /* SHA-512 */
+        {
+        "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
+        "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
+        "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"
+        "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909",
+        "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb"
+        "de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"
+        }
+    };
+
+    static const unsigned char message1[] = "abc";
+    static const unsigned char message2a[] = "abcdbcdecdefdefgefghfghighijhi"
+                                             "jkijkljklmklmnlmnomnopnopq";
+    static const unsigned char message2b[] =
+                                      "abcdefghbcdefghicdefghijdefghijkefghij"
+                                      "klfghijklmghijklmnhijklmnoijklmnopjklm"
+                                      "nopqklmnopqrlmnopqrsmnopqrstnopqrstu";
+    unsigned char *message3;
+    unsigned int message3_len  = 1000000;
+    unsigned char digest[SHA512_DIGEST_SIZE];
+
+    message3 = malloc(message3_len);
+    if (message3 == NULL) {
+        fprintf(stderr, "Can't allocate memory\n");
+        return -1;
+    }
+    memset(message3, 'a', message3_len);
+
+    printf("SHA-2 FIPS 180-2 Validation tests\n\n");
+    printf("SHA-224 Test vectors\n");
+
+    sha224(message1, strlen((char *) message1), digest);
+    test(vectors[0][0], digest, SHA224_DIGEST_SIZE);
+    sha224(message2a, strlen((char *) message2a), digest);
+    test(vectors[0][1], digest, SHA224_DIGEST_SIZE);
+    sha224(message3, message3_len, digest);
+    test(vectors[0][2], digest, SHA224_DIGEST_SIZE);
+    printf("\n");
+
+    printf("SHA-256 Test vectors\n");
+
+    sha256(message1, strlen((char *) message1), digest);
+    test(vectors[1][0], digest, SHA256_DIGEST_SIZE);
+    sha256(message2a, strlen((char *) message2a), digest);
+    test(vectors[1][1], digest, SHA256_DIGEST_SIZE);
+    sha256(message3, message3_len, digest);
+    test(vectors[1][2], digest, SHA256_DIGEST_SIZE);
+    printf("\n");
+
+    printf("SHA-384 Test vectors\n");
+
+    sha384(message1, strlen((char *) message1), digest);
+    test(vectors[2][0], digest, SHA384_DIGEST_SIZE);
+    sha384(message2b, strlen((char *) message2b), digest);
+    test(vectors[2][1], digest, SHA384_DIGEST_SIZE);
+    sha384(message3, message3_len, digest);
+    test(vectors[2][2], digest, SHA384_DIGEST_SIZE);
+    printf("\n");
+
+    printf("SHA-512 Test vectors\n");
+
+    sha512(message1, strlen((char *) message1), digest);
+    test(vectors[3][0], digest, SHA512_DIGEST_SIZE);
+    sha512(message2b, strlen((char *) message2b), digest);
+    test(vectors[3][1], digest, SHA512_DIGEST_SIZE);
+    sha512(message3, message3_len, digest);
+    test(vectors[3][2], digest, SHA512_DIGEST_SIZE);
+    printf("\n");
+
+    printf("All tests passed.\n");
+
+    return 0;
+}
+
+#endif /* TEST_VECTORS */
+
diff --git a/src/fetch/sha2.h b/src/fetch/sha2.h
new file mode 100644
index 0000000..60f52e3
--- /dev/null
+++ b/src/fetch/sha2.h
@@ -0,0 +1,108 @@
+/*
+ * FIPS 180-2 SHA-224/256/384/512 implementation
+ * Last update: 02/02/2007
+ * Issue date:  04/30/2005
+ *
+ * Copyright (C) 2005, 2007 Olivier Gay <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef SHA2_H
+#define SHA2_H
+
+#define SHA224_DIGEST_SIZE ( 224 / 8)
+#define SHA256_DIGEST_SIZE ( 256 / 8)
+#define SHA384_DIGEST_SIZE ( 384 / 8)
+#define SHA512_DIGEST_SIZE ( 512 / 8)
+
+#define SHA256_BLOCK_SIZE  ( 512 / 8)
+#define SHA512_BLOCK_SIZE  (1024 / 8)
+#define SHA384_BLOCK_SIZE  SHA512_BLOCK_SIZE
+#define SHA224_BLOCK_SIZE  SHA256_BLOCK_SIZE
+
+#ifndef SHA2_TYPES
+#define SHA2_TYPES
+typedef unsigned char uint8;
+typedef unsigned int  uint32;
+typedef unsigned long long uint64;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    unsigned int tot_len;
+    unsigned int len;
+    unsigned char block[2 * SHA256_BLOCK_SIZE];
+    uint32 h[8];
+} sha256_ctx;
+
+typedef struct {
+    unsigned int tot_len;
+    unsigned int len;
+    unsigned char block[2 * SHA512_BLOCK_SIZE];
+    uint64 h[8];
+} sha512_ctx;
+
+typedef sha512_ctx sha384_ctx;
+typedef sha256_ctx sha224_ctx;
+
+void sha224_init(sha224_ctx *ctx);
+void sha224_update(sha224_ctx *ctx, const unsigned char *message,
+                   unsigned int len);
+void sha224_final(sha224_ctx *ctx, unsigned char *digest);
+void sha224(const unsigned char *message, unsigned int len,
+            unsigned char *digest);
+
+void sha256_init(sha256_ctx * ctx);
+void sha256_update(sha256_ctx *ctx, const unsigned char *message,
+                   unsigned int len);
+void sha256_final(sha256_ctx *ctx, unsigned char *digest);
+void sha256(const unsigned char *message, unsigned int len,
+            unsigned char *digest);
+
+void sha384_init(sha384_ctx *ctx);
+void sha384_update(sha384_ctx *ctx, const unsigned char *message,
+                   unsigned int len);
+void sha384_final(sha384_ctx *ctx, unsigned char *digest);
+void sha384(const unsigned char *message, unsigned int len,
+            unsigned char *digest);
+
+void sha512_init(sha512_ctx *ctx);
+void sha512_update(sha512_ctx *ctx, const unsigned char *message,
+                   unsigned int len);
+void sha512_final(sha512_ctx *ctx, unsigned char *digest);
+void sha512(const unsigned char *message, unsigned int len,
+            unsigned char *digest);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !SHA2_H */
+
diff --git a/src/fetch/z3950-servers.cfg b/src/fetch/z3950-servers.cfg
index f4f6157..b30b661 100644
--- a/src/fetch/z3950-servers.cfg
+++ b/src/fetch/z3950-servers.cfg
@@ -43,9 +43,9 @@ Locale=it
 Syntax=unimarc
 
 [porbase]
-Host=z3950.bn.pt
+Host=z3950.porbase.org
 Port=210
-Database=bnd
+Database=Default
 Name=Portuguese National Library
 Charset=iso-8859-1
 Locale=pt
diff --git a/src/fetch/z3950fetcher.cpp b/src/fetch/z3950fetcher.cpp
index 7e70aa4..bd517ae 100644
--- a/src/fetch/z3950fetcher.cpp
+++ b/src/fetch/z3950fetcher.cpp
@@ -175,13 +175,13 @@ void Z3950Fetcher::search(FetchKey key_, const TQString& value_) {
             isbnList.insert(it, isbn10);
           }
         }
-        const int count = isbnList.count();
+        const size_t count = isbnList.count();
         if(count > 1) {
           m_pqn = TQString::fromLatin1("@or ");
         }
-        for(int i = 0; i < count; ++i) {
+        for(size_t i = 0; i < count; ++i) {
           m_pqn += TQString::fromLatin1(" @attr 1=7 ") + isbnList[i];
-          if(i < count-2) {
+          if(count > 1 && i < count-2) {
             m_pqn += TQString::fromLatin1(" @or");
           }
         }
diff --git a/src/fetchdialog.cpp b/src/fetchdialog.cpp
index ab9d91b..9586b13 100644
--- a/src/fetchdialog.cpp
+++ b/src/fetchdialog.cpp
@@ -591,6 +591,10 @@ void FetchDialog::slotMultipleISBN(bool toggle_) {
     m_valueLineEdit->setText(val);
   }
   m_editISBN->setEnabled(toggle_);
+  if(toggle_) {
+    // if we're editing multiple values, it makes sense to popup the dialog now
+    slotEditMultipleISBN();
+  }
 }
 
 void FetchDialog::slotEditMultipleISBN() {
diff --git a/src/field.cpp b/src/field.cpp
index 4ad2fa7..793de90 100644
--- a/src/field.cpp
+++ b/src/field.cpp
@@ -32,6 +32,7 @@ namespace {
 using Tellico::Data::Field;
 
 //these get overwritten, but are here since they're static
+TQStringList Field::s_articles;
 TQStringList Field::s_articlesApos;
 TQRegExp Field::s_delimiter = TQRegExp(TQString::fromLatin1("\\s*;\\s*"));
 
@@ -171,7 +172,7 @@ const TQString& Field::defaultValue() const {
 }
 
 void Field::setDefaultValue(const TQString& value_) {
-  if(m_type != Choice || m_allowed.findIndex(value_) > -1) {
+  if(value_.isEmpty() || m_type != Choice || m_allowed.findIndex(value_) > -1) {
     setProperty(TQString::fromLatin1("default"), value_);
   }
 }
@@ -260,8 +261,7 @@ TQString Field::formatTitle(const TQString& title_) {
   if(Config::autoFormat()) {
     const TQString lower = newTitle.lower();
     // TODO if the title has ",the" at the end, put it at the front
-    const TQStringList& articles = Config::articleList();
-    for(TQStringList::ConstIterator it = articles.begin(); it != articles.end(); ++it) {
+    for(TQStringList::ConstIterator it = s_articles.constBegin(); it != s_articles.constEnd(); ++it) {
       // assume white space is already stripped
       // the articles are already in lower-case
       if(lower.startsWith(*it + TQChar(' '))) {
@@ -415,7 +415,7 @@ TQString Field::capitalize(TQString str_) {
 
   TQString word = str_.mid(0, pos);
   // now check to see if words starts with apostrophe list
-  for(TQStringList::ConstIterator it = s_articlesApos.begin(); it != s_articlesApos.end(); ++it) {
+  for(TQStringList::ConstIterator it = s_articlesApos.constBegin(); it != s_articlesApos.constEnd(); ++it) {
     if(word.lower().startsWith(*it)) {
       uint l = (*it).length();
       str_.replace(l, 1, str_.at(l).upper());
@@ -432,7 +432,7 @@ TQString Field::capitalize(TQString str_) {
     word = str_.mid(pos+1, nextPos-pos-1);
     bool aposMatch = false;
     // now check to see if words starts with apostrophe list
-    for(TQStringList::ConstIterator it = s_articlesApos.begin(); it != s_articlesApos.end(); ++it) {
+    for(TQStringList::ConstIterator it = s_articlesApos.constBegin(); it != s_articlesApos.constEnd(); ++it) {
       if(word.lower().startsWith(*it)) {
         uint l = (*it).length();
         str_.replace(pos+l+1, 1, str_.at(pos+l+1).upper());
@@ -455,8 +455,7 @@ TQString Field::capitalize(TQString str_) {
 
 TQString Field::sortKeyTitle(const TQString& title_) {
   const TQString lower = title_.lower();
-  const TQStringList& articles = Config::articleList();
-  for(TQStringList::ConstIterator it = articles.begin(); it != articles.end(); ++it) {
+  for(TQStringList::ConstIterator it = s_articles.constBegin(); it != s_articles.constEnd(); ++it) {
     // assume white space is already stripped
     // the articles are already in lower-case
     if(lower.startsWith(*it + TQChar(' '))) {
@@ -464,7 +463,7 @@ TQString Field::sortKeyTitle(const TQString& title_) {
     }
   }
   // check apostrophes, too
-  for(TQStringList::ConstIterator it = s_articlesApos.begin(); it != s_articlesApos.end(); ++it) {
+  for(TQStringList::ConstIterator it = s_articlesApos.constBegin(); it != s_articlesApos.constEnd(); ++it) {
     if(lower.startsWith(*it)) {
       return title_.mid((*it).length());
     }
@@ -474,9 +473,9 @@ TQString Field::sortKeyTitle(const TQString& title_) {
 
 // articles should all be in lower-case
 void Field::articlesUpdated() {
-  const TQStringList articles = Config::articleList();
+  s_articles = Config::articleList();
   s_articlesApos.clear();
-  for(TQStringList::ConstIterator it = articles.begin(); it != articles.end(); ++it) {
+  for(TQStringList::ConstIterator it = s_articles.constBegin(); it != s_articles.constEnd(); ++it) {
     if((*it).endsWith(TQChar('\''))) {
       s_articlesApos += (*it);
     }
@@ -581,11 +580,10 @@ long Field::getID() {
 }
 
 void Field::stripArticles(TQString& value) {
-  const TQStringList articles = Config::articleList();
-  if(articles.isEmpty()) {
+  if(s_articles.isEmpty()) {
     return;
   }
-  for(TQStringList::ConstIterator it = articles.begin(); it != articles.end(); ++it) {
+  for(TQStringList::ConstIterator it = s_articles.constBegin(); it != s_articles.constEnd(); ++it) {
     TQRegExp rx(TQString::fromLatin1("\\b") + *it + TQString::fromLatin1("\\b"));
     value.remove(rx);
   }
diff --git a/src/field.h b/src/field.h
index f0b591a..c271705 100644
--- a/src/field.h
+++ b/src/field.h
@@ -385,6 +385,7 @@ private:
   FormatFlag m_formatFlag;
   StringMap m_properties;
 
+  static TQStringList s_articles;
   // need to remember articles with apostrophes for capitalization
   static TQStringList s_articlesApos;
   static TQRegExp s_delimiter;
diff --git a/src/gui/counteditem.h b/src/gui/counteditem.h
index 3aff0b7..4275696 100644
--- a/src/gui/counteditem.h
+++ b/src/gui/counteditem.h
@@ -39,8 +39,8 @@ public:
                          int column, int width, int align);
   virtual int width(const TQFontMetrics& fm, const TQListView* lv, int c) const;
 
-  virtual int count() const { return childCount(); }
-  virtual int realChildCount() const { return count(); }
+  virtual size_t count() const { return childCount(); }
+  virtual size_t realChildCount() const { return count(); }
 };
 
   } // end namespace
diff --git a/src/gui/listview.h b/src/gui/listview.h
index ccb0867..5e1137b 100644
--- a/src/gui/listview.h
+++ b/src/gui/listview.h
@@ -139,7 +139,7 @@ public:
   ListViewItem(ListViewItem* parent, const TQString& text) : TDEListViewItem(parent, text), m_sortWeight(-1) {}
   virtual ~ListViewItem();
 
-  virtual int realChildCount() const { return childCount(); }
+  virtual size_t realChildCount() const { return childCount(); }
   virtual void clear();
 
   virtual bool isEntryGroupItem() const { return false; }
diff --git a/src/gui/tabcontrol.cpp b/src/gui/tabcontrol.cpp
index f3c2bf2..92afec6 100644
--- a/src/gui/tabcontrol.cpp
+++ b/src/gui/tabcontrol.cpp
@@ -29,6 +29,9 @@ TQTabBar* TabControl::tabBar() const {
 void TabControl::setFocusToFirstChild() {
   TQWidget* page = currentPage();
   Q_ASSERT(page);
+  if(!page) {
+    return;
+  }
   TQObjectList* list = page->queryList(TQWIDGET_OBJECT_NAME_STRING);
   for(TQObjectListIt it(*list); it.current(); ++it) {
     TQWidget* w = TQT_TQWIDGET(it.current());
diff --git a/src/image.cpp b/src/image.cpp
index 8cb6fa4..cc015ae 100644
--- a/src/image.cpp
+++ b/src/image.cpp
@@ -14,6 +14,7 @@
 #include "image.h"
 #include "imagefactory.h"
 #include "tellico_debug.h"
+#include "tellico_utils.h"
 
 #include <kmdcodec.h>
 #include <kpixmapio.h>
@@ -105,7 +106,7 @@ TQByteArray Image::byteArray(const TQImage& img_, const TQCString& outputFormat_
 TQString Image::idClean(const TQString& id_) {
   static const TQRegExp rx('[' + TQRegExp::escape(TQString::fromLatin1("/@<>#\"&%?={}|^~[]'`\\:+")) + ']');
   TQString clean = id_;
-  return clean.remove(rx);
+  return shareString(clean.remove(rx));
 }
 
 void Image::setID(const TQString& id_) {
diff --git a/src/imagefactory.cpp b/src/imagefactory.cpp
index 574b199..0cc6acb 100644
--- a/src/imagefactory.cpp
+++ b/src/imagefactory.cpp
@@ -316,7 +316,7 @@ bool ImageFactory::writeCachedImage(const TQString& id_, CacheDir dir_, bool for
 
 const Tellico::Data::Image& ImageFactory::imageById(const TQString& id_) {
   if(id_.isEmpty()) {
-    myDebug() << "ImageFactory::imageById() - empty id" << endl;
+//    myDebug() << "ImageFactory::imageById() - empty id" << endl;
     return s_null;
   }
 //  myLog() << "ImageFactory::imageById() - " << id_ << endl;
@@ -348,7 +348,7 @@ const Tellico::Data::Image& ImageFactory::imageById(const TQString& id_) {
   if((s_imageInfoMap.contains(id_) && s_imageInfoMap[id_].linkOnly) || !KURL::isRelativeURL(id_)) {
     KURL u = id_;
     if(u.isValid()) {
-      return addImageImpl(u, false, KURL(), true);
+      return addImageImpl(u, true, KURL(), true);
     }
   }
 
@@ -385,43 +385,53 @@ const Tellico::Data::Image& ImageFactory::imageById(const TQString& id_) {
     }
   }
 
-  // don't check Config::writeImagesInFile(), someday we might have problems
-  // and the image will exist in the data dir, but the app thinks everything should
-  // be in the zip file instead
-  bool exists = TQFile::exists(dataDir() + id_);
-  if(exists) {
-    // if we're loading from the application data dir, but images are being saved in the
-    // data file instead, then consider the document to be modified since it needs
-    // the image saved
-    if(Config::imageLocation() != Config::ImagesInAppDir) {
+  if(Config::imageLocation() == Config::ImagesInLocalDir) {
+    bool exists = TQFile::exists(localDir() + id_);
+    if(exists) {
+      const Data::Image& img2 = addCachedImageImpl(id_, LocalDir);
+      if(img2.isNull()) {
+        myDebug() << "ImageFactory::imageById() - tried to add from LocalDir, but failed: " << id_ << endl;
+      } else {
+//        myLog() << "...imageById() - found in local dir" << endl;
+        return img2;
+      }
+    }
+    // not an else statement, it might be null
+    if(TQFile::exists(dataDir() + id_)) {
+      // the img is in the other location
+      // consider the document to be modified since it needs the image saved
       Data::Document::self()->slotSetModified(true);
+      const Data::Image& img2 = addCachedImageImpl(id_, DataDir);
+      if(img2.isNull()) {
+        myDebug() << "ImageFactory::imageById() - tried to add from DataDir, but failed: " << id_ << endl;
+      } else {
+//        myLog() << "...imageById() - found in data dir" << endl;
+        return img2;
+      }
     }
-    const Data::Image& img2 = addCachedImageImpl(id_, DataDir);
-    if(img2.isNull()) {
-      myDebug() << "ImageFactory::imageById() - tried to add from DataDir, but failed: " << id_ << endl;
-    } else {
-//      myLog() << "...imageById() - found in data dir" << endl;
-      return img2;
+  } else if(Config::imageLocation() == Config::ImagesInAppDir) {
+    bool exists = TQFile::exists(dataDir() + id_);
+    if(exists) {
+      const Data::Image& img2 = addCachedImageImpl(id_, DataDir);
+      if(img2.isNull()) {
+        myDebug() << "ImageFactory::imageById() - tried to add from DataDir, but failed: " << id_ << endl;
+      } else {
+//        myLog() << "...imageById() - found in data dir" << endl;
+        return img2;
+      }
     }
-  }
-  // if localDir() == DataDir(), then there's nothing left to check
-  if(localDir() == dataDir()) {
-    return s_null;
-  }
-  exists = TQFile::exists(localDir() + id_);
-  if(exists) {
-    // if we're loading from the application data dir, but images are being saved in the
-    // data file instead, then consider the document to be modified since it needs
-    // the image saved
-    if(Config::imageLocation() != Config::ImagesInLocalDir) {
+    // not an else statement, it might be null
+    if(TQFile::exists(localDir() + id_)) {
+      // the img is in the other location
+      // consider the document to be modified since it needs the image saved
       Data::Document::self()->slotSetModified(true);
-    }
-    const Data::Image& img2 = addCachedImageImpl(id_, LocalDir);
-    if(img2.isNull()) {
-      myDebug() << "ImageFactory::imageById() - tried to add from LocalDir, but failed: " << id_ << endl;
-    } else {
-//      myLog() << "...imageById() - found in data dir" << endl;
-      return img2;
+      const Data::Image& img2 = addCachedImageImpl(id_, LocalDir);
+      if(img2.isNull()) {
+        myDebug() << "ImageFactory::imageById() - tried to add from LocalDir, but failed: " << id_ << endl;
+      } else {
+//        myLog() << "...imageById() - found in local dir" << endl;
+        return img2;
+      }
     }
   }
   myDebug() << "***ImageFactory::imageById() - not found: " << id_ << endl;
diff --git a/src/isbnvalidator.cpp b/src/isbnvalidator.cpp
index 4832cdd..d6ae49f 100644
--- a/src/isbnvalidator.cpp
+++ b/src/isbnvalidator.cpp
@@ -12,6 +12,7 @@
  ***************************************************************************/
 
 #include "isbnvalidator.h"
+#include "upcvalidator.h"
 #include "tellico_debug.h"
 
 using Tellico::ISBNValidator;
@@ -58,6 +59,13 @@ ISBNValidator::ISBNValidator(TQObject* parent_, const char* name_/*=0*/)
 }
 
 TQValidator::State ISBNValidator::validate(TQString& input_, int& pos_) const {
+  // check if it's a cuecat first
+  State catState = CueCat::decode(input_);
+  if(catState != Invalid) {
+    pos_ = input_.length();
+    return catState;
+  }
+
   if(input_.startsWith(TQString::fromLatin1("978")) ||
      input_.startsWith(TQString::fromLatin1("979"))) {
     return validate13(input_, pos_);
diff --git a/src/lccnvalidator.cpp b/src/lccnvalidator.cpp
index cf0e850..b177d55 100644
--- a/src/lccnvalidator.cpp
+++ b/src/lccnvalidator.cpp
@@ -65,7 +65,7 @@ TQString LCCNValidator::formalize(const TQString& value_) {
 
   // now check for non digits in the serial
   pos = 0;
-  for( ; pos < serial.length() && serial.at(pos).isNumber(); ++pos) { ; }
+  for( ; pos < static_cast<int>(serial.length()) && serial.at(pos).isNumber(); ++pos) { ; }
   TQString suffix = serial.mid(pos);
   serial = serial.left(pos);
   // serial must be left-padded with zeros to 6 characters
diff --git a/src/listviewcomparison.cpp b/src/listviewcomparison.cpp
index b78de94..c03d402 100644
--- a/src/listviewcomparison.cpp
+++ b/src/listviewcomparison.cpp
@@ -48,6 +48,8 @@ Tellico::ListViewComparison* Tellico::ListViewComparison::create(Data::ConstFiel
     return new DependentComparison(field_);
   } else if(field_->type() == Data::Field::Date || field_->formatFlag() == Data::Field::FormatDate) {
     return new ISODateComparison(field_);
+  } else if(field_->type() == Data::Field::Choice) {
+    return new ChoiceComparison(field_);
   } else if(field_->formatFlag() == Data::Field::FormatTitle) {
     // Dependent could be title, so put this test after
     return new TitleComparison(field_);
@@ -277,3 +279,11 @@ int Tellico::ISODateComparison::compare(const TQString& str1, const TQString& st
   }
   return 0;
 }
+
+Tellico::ChoiceComparison::ChoiceComparison(Data::ConstFieldPtr field) : ListViewComparison(field) {
+  m_values = field->allowed();
+}
+
+int Tellico::ChoiceComparison::compare(const TQString& str1, const TQString& str2) {
+  return m_values.findIndex(str1) - m_values.findIndex(str2);
+}
diff --git a/src/listviewcomparison.h b/src/listviewcomparison.h
index 28a3878..3615df4 100644
--- a/src/listviewcomparison.h
+++ b/src/listviewcomparison.h
@@ -112,5 +112,16 @@ protected:
   virtual int compare(const TQString& str1, const TQString& str2);
 };
 
+class ChoiceComparison : public ListViewComparison {
+public:
+  ChoiceComparison(Data::ConstFieldPtr field);
+
+protected:
+  virtual int compare(const TQString& str1, const TQString& str2);
+
+private:
+  TQStringList m_values;
+};
+
 }
 #endif
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 74451ac..54aac95 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -336,7 +336,7 @@ void MainWindow::initActions() {
   action = new TDEAction(actionCollection(), "file_import_csv");
   action->setText(i18n("Import CSV Data..."));
   action->setToolTip(i18n("Import a CSV file"));
-  action->setIcon(MIME_ICON("text/x-csv"));
+  action->setIcon(MIME_ICON("text/csv"));
   importMenu->insert(action);
   connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map()));
   importMapper->setMapping(action, Import::CSV);
@@ -506,7 +506,7 @@ void MainWindow::initActions() {
   action = new TDEAction(actionCollection(), "file_export_csv");
   action->setText(i18n("Export to CSV..."));
   action->setToolTip(i18n("Export to a comma-separated values file"));
-  action->setIcon(MIME_ICON("text/x-csv"));
+  action->setIcon(MIME_ICON("text/csv"));
   exportMenu->insert(action);
   connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map()));
   exportMapper->setMapping(action, Export::CSV);
@@ -750,6 +750,7 @@ void MainWindow::initActions() {
   // want to update every time the filter text changes
   connect(m_quickFilter, TQT_SIGNAL(textChanged(const TQString&)),
           TQT_TQOBJECT(this), TQT_SLOT(slotQueueFilter()));
+  m_quickFilter->installEventFilter(this); // intercept keyEvents
 
   KWidgetAction* wAction = new KWidgetAction(m_quickFilter, i18n("Filter"), 0, 0, 0,
                                              actionCollection(), "quick_filter");
@@ -907,12 +908,12 @@ void MainWindow::saveOptions() {
   Config::setGroupViewSortAscending(m_groupView->ascendingSort());
 
   if(m_loanView) {
-    Config::setLoanViewSortAscending(m_loanView->sortStyle()); // ok to use SortColumn key, save semantics
+    Config::setLoanViewSortColumn(m_loanView->sortStyle()); // ok to use SortColumn key, save semantics
     Config::setLoanViewSortAscending(m_loanView->ascendingSort());
   }
 
   if(m_filterView) {
-    Config::setFilterViewSortAscending(m_filterView->sortStyle()); // ok to use SortColumn key, save semantics
+    Config::setFilterViewSortColumn(m_filterView->sortStyle()); // ok to use SortColumn key, save semantics
     Config::setFilterViewSortAscending(m_filterView->ascendingSort());
   }
 
@@ -991,7 +992,7 @@ void MainWindow::saveCollectionOptions(Data::CollPtr coll_) {
         configIndex = i;
       }
     }
-    uint limit = TQMIN(urls.count(), Config::maxCustomURLSettings());
+    size_t limit = TQMIN(urls.count(), Config::maxCustomURLSettings());
     for(uint i = 0; i < limit; ++i) {
       config.writeEntry(TQString::fromLatin1("URL_%1").arg(i), urls[i].url());
       config.writeEntry(TQString::fromLatin1("Group By_%1").arg(i), groupBys[i]);
@@ -1531,11 +1532,11 @@ void MainWindow::slotEntryCount() {
     return;
   }
 
-  int count = coll->entryCount();
+  size_t count = coll->entryCount();
   TQString text = i18n("Total entries: %1").arg(count);
 
-  int selectCount = Controller::self()->selectedEntries().count();
-  int filterCount = m_detailedView->visibleItems();
+  size_t selectCount = Controller::self()->selectedEntries().count();
+  size_t filterCount = m_detailedView->visibleItems();
   // if more than one book is selected, add the number of selected books
   if(filterCount < count && selectCount > 1) {
     text += TQChar(' ');
@@ -1848,6 +1849,10 @@ void MainWindow::setFilter(const TQString& text_) {
       // if it isn't valid, hold off on applying the filter
       TQRegExp tx(text);
       if(!tx.isValid()) {
+        text = TQRegExp::escape(text);
+        tx.setPattern(text);
+      }
+      if(!tx.isValid()) {
         myDebug() << "MainWindow::slotUpdateFilter() - invalid regexp: " << text << endl;
         return;
       }
@@ -2389,4 +2394,15 @@ void MainWindow::slotURLAction(const KURL& url_) {
   }
 }
 
+bool MainWindow::eventFilter(TQObject* obj_, TQEvent* ev_) {
+  if(ev_->type() == TQEvent::KeyPress && obj_ == m_quickFilter) {
+    switch(static_cast<TQKeyEvent*>(ev_)->key()) {
+      case TQt::Key_Escape:
+        m_quickFilter->clear();
+        return true;
+    }
+  }
+  return false;
+}
+
 #include "mainwindow.moc"
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 6b790e1..535085c 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -123,6 +123,8 @@ public:
   virtual void setFilter(const TQString& text);
   virtual bool showEntry(long id);
 
+  bool eventFilter(TQObject* watched, TQEvent* event);
+
 public slots:
   /**
    * Initializes some stuff after the object is created.
diff --git a/src/reportdialog.cpp b/src/reportdialog.cpp
index c47766e..6f6533a 100644
--- a/src/reportdialog.cpp
+++ b/src/reportdialog.cpp
@@ -197,7 +197,7 @@ void ReportDialog::slotSaveAs() {
   if(!u.isEmpty() && u.isValid()) {
     TDEConfigGroup config(TDEGlobal::config(), "ExportOptions");
     bool encode = config.readBoolEntry("EncodeUTF8", true);
-    int oldOpt = m_exporter->options();
+    long oldOpt = m_exporter->options();
 
     // turn utf8 off
     long options = oldOpt & ~Export::ExportUTF8;
diff --git a/src/tellico_debug.h b/src/tellico_debug.h
index ea65518..08a4912 100644
--- a/src/tellico_debug.h
+++ b/src/tellico_debug.h
@@ -22,7 +22,7 @@
 // std::clock_t
 #include <ctime>
 
-// linux has __GNUC_PREREQ, NetBSD has __GNUC_PREQ__
+// linux has __GNUC_PREREQ, NetBSD has __GNUC_PREREQ__
 #if defined(__GNUC_PREREQ) && !defined(__GNUC_PREREQ__)
 #define __GNUC_PREREQ__ __GNUC_PREREQ
 #endif
diff --git a/src/tests/Makefile.am b/src/tests/Makefile.am
index a0cdd59..3dc9d98 100644
--- a/src/tests/Makefile.am
+++ b/src/tests/Makefile.am
@@ -16,7 +16,7 @@ METASOURCES = AUTO
 DISTCLEANFILES = *~ *.Po $(CLEANFILES)
 
 isbntest_SOURCES = isbntest.cpp
-isbntest_LDADD = ../isbnvalidator.o $(LIB_QT) $(LIB_TDECORE) $(LIB_TDEUI)
+isbntest_LDADD = ../isbnvalidator.o ../upcvalidator.o $(LIB_QT) $(LIB_TDECORE) $(LIB_TDEUI)
 
 latin1test_SOURCES = latin1test.cpp
 latin1test_LDADD = $(LIB_QT) $(LIB_TDECORE)
diff --git a/src/translators/Makefile.am b/src/translators/Makefile.am
index fbbb11b..f0e8520 100644
--- a/src/translators/Makefile.am
+++ b/src/translators/Makefile.am
@@ -12,9 +12,9 @@ libtranslators_a_SOURCES = alexandriaexporter.cpp alexandriaimporter.cpp \
 	filelistingimporter.cpp freedb_util.cpp freedbimporter.cpp gcfilmsexporter.cpp \
 	gcfilmsimporter.cpp griffithimporter.cpp grs1importer.cpp htmlexporter.cpp libcsv.c \
 	onixexporter.cpp pdfimporter.cpp pilotdbexporter.cpp referencerimporter.cpp \
-	risimporter.cpp tellico_xml.cpp tellicoimporter.cpp tellicoxmlexporter.cpp \
-	tellicozipexporter.cpp textimporter.cpp xmlimporter.cpp xsltexporter.cpp xslthandler.cpp \
-	xsltimporter.cpp
+	risimporter.cpp tellico_xml.cpp tellicoimporter.cpp tellicosaximporter.cpp \
+	tellicoxmlexporter.cpp tellicoxmlhandler.cpp tellicozipexporter.cpp textimporter.cpp \
+	xmlimporter.cpp xmlstatehandler.cpp xsltexporter.cpp xslthandler.cpp xsltimporter.cpp
 
 if !USE_LIBBTPARSE
   SUBDIR_LIBBTPARSE = btparse
@@ -51,7 +51,10 @@ dcimporter.h             dcimporter.cpp           griffithimporter.h \
 griffithimporter.cpp     griffith2tellico.py      pdfimporter.h \
 pdfimporter.cpp          referencerimporter.h     referencerimporter.cpp \
 libcsv.h                 libcsv.c \
-deliciousimporter.h      deliciousimporter.cpp
+deliciousimporter.h      deliciousimporter.cpp \
+tellicosaximporter.h     tellicosaximporter.cpp \
+tellicoxmlhandler.h      tellicoxmlhandler.cpp \
+xmlstatehandler.h        xmlstatehandler.cpp
 
 ####### tdevelop will overwrite this part!!! (end)############
 
@@ -68,3 +71,4 @@ KDE_OPTIONS = noautodist
 appdir = $(kde_datadir)/tellico
 app_DATA = bibtex-translation.xml
 app_SCRIPTS = griffith2tellico.py
+
diff --git a/src/translators/alexandriaexporter.cpp b/src/translators/alexandriaexporter.cpp
index de64fbb..633864f 100644
--- a/src/translators/alexandriaexporter.cpp
+++ b/src/translators/alexandriaexporter.cpp
@@ -77,7 +77,7 @@ bool AlexandriaExporter::exec() {
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, TQString(), false);
   item.setTotalSteps(entries().count());
   ProgressItem::Done done(this);
-  const uint stepSize = TQMIN(1, entries().count()/100);
+  const uint stepSize = TQMAX(1, entries().count()/100);
   const bool showProgress = options() & ExportProgress;
 
   GUI::CursorSaver cs;
diff --git a/src/translators/bibteximporter.cpp b/src/translators/bibteximporter.cpp
index fb52f95..d3668d4 100644
--- a/src/translators/bibteximporter.cpp
+++ b/src/translators/bibteximporter.cpp
@@ -308,5 +308,47 @@ TQWidget* BibtexImporter::widget(TQWidget* parent_, const char* name_/*=0*/) {
   return m_widget;
 }
 
+bool BibtexImporter::maybeBibtex(const KURL& url_) {
+  TQString text = FileHandler::readTextFile(url_, true /*quiet*/);
+  if(text.isEmpty()) {
+    return false;
+  }
+
+  bt_initialize();
+  TQRegExp rx(TQString::fromLatin1("[{}]"));
+
+  ushort bt_options = 0; // ushort is defined in btparse.h
+  boolean ok; // boolean is defined in btparse.h as an int
+  bool foundOne = false;
+  int brace = 0;
+  int startpos = 0;
+  int pos = text.find(rx, 0);
+  while(pos > 0) {
+    if(text[pos] == '{') {
+      ++brace;
+    } else if(text[pos] == '}' && brace > 0) {
+      --brace;
+    }
+    if(brace == 0) {
+      TQString entry = text.mid(startpos, pos-startpos+1).stripWhiteSpace();
+      // All the downstream text processing on the AST node will assume utf-8
+      AST* node = bt_parse_entry_s(const_cast<char*>(entry.utf8().data()),
+                                   const_cast<char*>(url_.fileName().local8Bit().data()),
+                                   0, bt_options, &ok);
+      if(ok && node) {
+        foundOne = true;
+        break;
+      }
+      startpos = pos+1;
+    }
+    pos = text.find(rx, pos+1);
+  }
+  if(foundOne) {
+    // clean up some structures
+    bt_parse_entry_s(0, 0, 1, 0, 0);
+  }
+  bt_cleanup();
+  return foundOne;
+}
 
 #include "bibteximporter.moc"
diff --git a/src/translators/bibteximporter.h b/src/translators/bibteximporter.h
index 6d1b878..09e1ec3 100644
--- a/src/translators/bibteximporter.h
+++ b/src/translators/bibteximporter.h
@@ -67,6 +67,8 @@ public:
   virtual TQWidget* widget(TQWidget* parent, const char* name=0);
   virtual bool canImport(int type) const;
 
+  static bool maybeBibtex(const KURL& url);
+
 public slots:
   void slotCancel();
 
diff --git a/src/translators/csvimporter.cpp b/src/translators/csvimporter.cpp
index 8a53ff9..d6198d0 100644
--- a/src/translators/csvimporter.cpp
+++ b/src/translators/csvimporter.cpp
@@ -50,15 +50,26 @@ extern "C" {
 
 using Tellico::Import::CSVImporter;
 
+typedef int(*SpaceFunc)(char);
+
 static void writeToken(char* buffer, size_t len, void* data);
 static void writeRow(char buffer, void* data);
+static int isSpace(char c);
+static int isSpaceOrTab(char c);
+static int isTab(char c);
 
 class CSVImporter::Parser {
 public:
   Parser(const TQString& str) : stream(new TQTextIStream(&str)) { csv_init(&parser, 0); }
   ~Parser() { csv_free(parser); delete stream; stream = 0; }
 
-  void setDelimiter(const TQString& s) { Q_ASSERT(s.length() == 1); csv_set_delim(parser, s[0].latin1()); }
+  void setDelimiter(const TQString& s) {
+    Q_ASSERT(s.length() == 1);
+    csv_set_delim(parser, s[0].latin1());
+    if(s[0] == '\t')     csv_set_space_func(parser, isSpace);
+    else if(s[0] == ' ') csv_set_space_func(parser, isTab);
+    else                 csv_set_space_func(parser, isSpaceOrTab);
+  }
   void reset(const TQString& str) { delete stream; stream = new TQTextIStream(&str); };
   bool hasNext() { return !stream->atEnd(); }
   void skipLine() { stream->readLine(); }
@@ -95,6 +106,21 @@ static void writeRow(char c, void* data) {
   p->setRowDone(true);
 }
 
+static int isSpace(char c) {
+  if (c == CSV_SPACE) return 1;
+  return 0;
+}
+
+static int isSpaceOrTab(char c) {
+  if (c == CSV_SPACE || c == CSV_TAB) return 1;
+  return 0;
+}
+
+static int isTab(char c) {
+  if (c == CSV_TAB) return 1;
+  return 0;
+}
+
 CSVImporter::CSVImporter(const KURL& url_) : Tellico::Import::TextImporter(url_),
     m_coll(0),
     m_existingCollection(0),
diff --git a/src/translators/deliciousimporter.cpp b/src/translators/deliciousimporter.cpp
index a82c006..be6fe3e 100644
--- a/src/translators/deliciousimporter.cpp
+++ b/src/translators/deliciousimporter.cpp
@@ -35,7 +35,9 @@ DeliciousImporter::DeliciousImporter(const KURL& url_) : XSLTImporter(url_) {
 }
 
 bool DeliciousImporter::canImport(int type) const {
-  return type == Data::Collection::Book;
+  return type == Data::Collection::Book ||
+         type == Data::Collection::Video ||
+         type == Data::Collection::Game;
 }
 
 Tellico::Data::CollPtr DeliciousImporter::collection() {
@@ -51,7 +53,18 @@ Tellico::Data::CollPtr DeliciousImporter::collection() {
                               << TQString::fromLatin1("Medium Covers/")
                               << TQString::fromLatin1("Small Covers/")
                               << TQString::fromLatin1("Plain Covers/");
-  const TQString commField = TQString::fromLatin1("comments");
+  TQString commField;
+  switch(coll->type()) {
+    case Data::Collection::Book:
+      commField = TQString::fromLatin1("comments"); break;
+    case Data::Collection::Video:
+      commField = TQString::fromLatin1("plot"); break;
+    case Data::Collection::Game:
+      commField = TQString::fromLatin1("description"); break;
+    default:
+      myWarning() << "bad collection type:" << coll->type() << endl;
+  }
+
   const TQString uuidField = TQString::fromLatin1("uuid");
   const TQString coverField = TQString::fromLatin1("cover");
   const bool isLocal = url().isLocalFile();
diff --git a/src/translators/freedb_util.cpp b/src/translators/freedb_util.cpp
index 07292af..2a2e5ed 100644
--- a/src/translators/freedb_util.cpp
+++ b/src/translators/freedb_util.cpp
@@ -365,7 +365,7 @@ FreeDBImporter::CDText FreeDBImporter::getCDText(const TQCString& drive_) {
     }
   }
   if(cdtext.trackTitles.size() != cdtext.trackArtists.size()) {
-    int size = TQMAX(cdtext.trackTitles.size(), cdtext.trackArtists.size());
+    size_t size = TQMAX(cdtext.trackTitles.size(), cdtext.trackArtists.size());
     cdtext.trackTitles.resize(size);
     cdtext.trackArtists.resize(size);
   }
diff --git a/src/translators/htmlexporter.cpp b/src/translators/htmlexporter.cpp
index e27d6e5..e8bb95d 100644
--- a/src/translators/htmlexporter.cpp
+++ b/src/translators/htmlexporter.cpp
@@ -31,6 +31,7 @@
 #include <tdeio/netaccess.h>
 #include <tdeapplication.h>
 #include <tdelocale.h>
+#include <kuser.h>
 
 #include <tqdom.h>
 #include <tqgroupbox.h>
@@ -192,6 +193,9 @@ bool HTMLExporter::loadXSLTFile() {
     m_handler = 0;
     return false;
   }
+  m_handler->addStringParam("date", TQDate::currentDate().toString(TQt::ISODate).latin1());
+  m_handler->addStringParam("time", TQTime::currentTime().toString(TQt::ISODate).latin1());
+  m_handler->addStringParam("user", KUser(KUser::UseRealUserID).loginName().latin1());
 
   if(m_exportEntryFiles) {
     // export entries to same place as all the other date files
diff --git a/src/translators/risimporter.cpp b/src/translators/risimporter.cpp
index 735368c..0158708 100644
--- a/src/translators/risimporter.cpp
+++ b/src/translators/risimporter.cpp
@@ -188,7 +188,7 @@ void RISImporter::readURL(const KURL& url_, int n, const TQDict<Data::Field>& ri
   // technically, the spec requires a space immediately after the hyphen
   // however, at least one website (Springer) outputs RIS with no space after the final "ER -"
   // so just strip the white space later
-  // also be gracious and allow only any amount of space before hyphen
+  // also be gracious and allow any amount of space before hyphen
   TQRegExp rx(TQString::fromLatin1("^(\\w\\w)\\s+-(.*)$"));
   TQString currLine, nextLine;
   for(currLine = t.readLine(); !m_cancelled && !currLine.isNull(); currLine = nextLine, j += currLine.length()) {
@@ -312,4 +312,25 @@ void RISImporter::slotCancel() {
   m_cancelled = true;
 }
 
+bool RISImporter::maybeRIS(const KURL& url_) {
+  TQString text = FileHandler::readTextFile(url_, true /*quiet*/);
+  if(text.isEmpty()) {
+    return false;
+  }
+
+  // bare bones check, strip white space at beginning
+  // and then first text line must be valid RIS
+  TQTextIStream t(&text);
+
+  TQRegExp rx(TQString::fromLatin1("^(\\w\\w)\\s+-(.*)$"));
+  TQString currLine;
+  for(currLine = t.readLine(); !currLine.isNull(); currLine = t.readLine()) {
+    if(currLine.stripWhiteSpace().isEmpty()) {
+      continue;
+    }
+    break;
+  }
+  return rx.exactMatch(currLine);
+}
+
 #include "risimporter.moc"
diff --git a/src/translators/risimporter.h b/src/translators/risimporter.h
index fa581ba..a572283 100644
--- a/src/translators/risimporter.h
+++ b/src/translators/risimporter.h
@@ -50,6 +50,8 @@ public:
   virtual TQWidget* widget(TQWidget*, const char*) { return 0; }
   virtual bool canImport(int type) const;
 
+  static bool maybeRIS(const KURL& url);
+
 public slots:
   void slotCancel();
 
diff --git a/src/translators/tellico_xml.cpp b/src/translators/tellico_xml.cpp
index bcfb412..3a927d6 100644
--- a/src/translators/tellico_xml.cpp
+++ b/src/translators/tellico_xml.cpp
@@ -63,6 +63,12 @@ TQString Tellico::XML::dtdTellico(int version) {
   return TQString::fromLatin1("http://periapsis.org/tellico/dtd/v%1/tellico.dtd").arg(version);
 }
 
+// returns true if the file has to be converted
+// version 9 to 10 requires no conversion since it only added board games
+bool Tellico::XML::versionConversion(uint from, uint to) {
+  return from < to && (from != 9 || to != 10);
+}
+
 bool Tellico::XML::validXMLElementName(const TQString& name_) {
   return xmlValidateNameValue((xmlChar *)name_.utf8().data());
 }
diff --git a/src/translators/tellico_xml.h b/src/translators/tellico_xml.h
index 6ff4c1b..6ffda10 100644
--- a/src/translators/tellico_xml.h
+++ b/src/translators/tellico_xml.h
@@ -28,6 +28,8 @@ namespace Tellico {
     TQString pubTellico(int version = syntaxVersion);
     TQString dtdTellico(int version = syntaxVersion);
 
+    bool versionConversion(uint from, uint to);
+
     extern const TQString nsBookcase;
     extern const TQString nsDublinCore;
     extern const TQString nsZing;
diff --git a/src/translators/tellicoimporter.cpp b/src/translators/tellicoimporter.cpp
index a8dfb62..d722c0c 100644
--- a/src/translators/tellicoimporter.cpp
+++ b/src/translators/tellicoimporter.cpp
@@ -39,11 +39,6 @@
 
 using Tellico::Import::TellicoImporter;
 
-bool TellicoImporter::versionConversion(uint from, uint to) {
-  // version 10 only added board games to version 9
-  return from < to && (from != 9 || to != 10);
-}
-
 TellicoImporter::TellicoImporter(const KURL& url_, bool loadAllImages_) : DataImporter(url_),
     m_coll(0), m_loadAllImages(loadAllImages_), m_format(Unknown), m_modified(false),
     m_cancelled(false), m_hasImages(false), m_buffer(0), m_zip(0), m_imgDir(0) {
@@ -157,7 +152,7 @@ void TellicoImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) {
     }
     m_format = Error;
     return;
-  } else if(versionConversion(syntaxVersion, XML::syntaxVersion)) {
+  } else if(XML::versionConversion(syntaxVersion, XML::syntaxVersion)) {
     // going form version 9 to 10, there's no conversion needed
     TQString str = i18n("Tellico is converting the file to a more recent document format. "
                        "Information loss may occur if an older version of Tellico is used "
@@ -374,7 +369,7 @@ void TellicoImporter::readField(uint syntaxVersion_, const TQDomElement& elem_)
 
   Data::FieldPtr field;
   if(type == Data::Field::Choice) {
-    TQStringList allowed = TQStringList::split(TQString::fromLatin1(";"),
+    TQStringList allowed = TQStringList::split(TQRegExp(TQString::fromLatin1("\\s*;\\s*")),
                                              elem_.attribute(TQString::fromLatin1("allowed")));
     if(isI18n) {
       for(TQStringList::Iterator it = allowed.begin(); it != allowed.end(); ++it) {
@@ -652,8 +647,9 @@ void TellicoImporter::readEntry(uint syntaxVersion_, const TQDomElement& entryEl
 void TellicoImporter::readImage(const TQDomElement& elem_, bool loadImage_) {
   TQString format = elem_.attribute(TQString::fromLatin1("format"));
   const bool link = elem_.attribute(TQString::fromLatin1("link")) == Latin1Literal("true");
-  TQString id = shareString(link ? elem_.attribute(TQString::fromLatin1("id"))
-                                : Data::Image::idClean(elem_.attribute(TQString::fromLatin1("id"))));
+  // idClean() already calls shareString()
+  TQString id = link ? shareString(elem_.attribute(TQString::fromLatin1("id")))
+                    : Data::Image::idClean(elem_.attribute(TQString::fromLatin1("id")));
 
   bool readInfo = true;
   if(loadImage_) {
diff --git a/src/translators/tellicoimporter.h b/src/translators/tellicoimporter.h
index 93cf7da..6ea0ac5 100644
--- a/src/translators/tellicoimporter.h
+++ b/src/translators/tellicoimporter.h
@@ -70,8 +70,6 @@ public slots:
   void slotCancel();
 
 private:
-  static bool versionConversion(uint from, uint to);
-
   void loadXMLData(const TQByteArray& data, bool loadImages);
   void loadZipData();
 
diff --git a/src/translators/tellicosaximporter.cpp b/src/translators/tellicosaximporter.cpp
new file mode 100644
index 0000000..de60c63
--- /dev/null
+++ b/src/translators/tellicosaximporter.cpp
@@ -0,0 +1,293 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+//  before tellicosaxmporter.h because of QT_NO_CAST_ASCII issues
+#include "tellicoxmlhandler.h"
+#include "tellicosaximporter.h"
+#include "tellico_xml.h"
+#include "../collectionfactory.h"
+#include "../collections/bibtexcollection.h"
+#include "../entry.h"
+#include "../field.h"
+#include "../imagefactory.h"
+#include "../image.h"
+#include "../isbnvalidator.h"
+#include "../latin1literal.h"
+#include "../tellico_strings.h"
+#include "../tellico_kernel.h"
+#include "../tellico_utils.h"
+#include "../tellico_debug.h"
+#include "../progressmanager.h"
+
+#include <tdelocale.h>
+#include <kmdcodec.h>
+#include <kzip.h>
+#include <tdeapplication.h>
+
+#include <tqbuffer.h>
+#include <tqfile.h>
+#include <tqtimer.h>
+
+using Tellico::Import::TellicoSaxImporter;
+
+TellicoSaxImporter::TellicoSaxImporter(const KURL& url_, bool loadAllImages_) : DataImporter(url_),
+    m_coll(0), m_loadAllImages(loadAllImages_), m_format(Unknown), m_modified(false),
+    m_cancelled(false), m_hasImages(false), m_buffer(0), m_zip(0), m_imgDir(0) {
+}
+
+TellicoSaxImporter::TellicoSaxImporter(const TQString& text_) : DataImporter(text_),
+    m_coll(0), m_loadAllImages(true), m_format(Unknown), m_modified(false),
+    m_cancelled(false), m_hasImages(false), m_buffer(0), m_zip(0), m_imgDir(0) {
+}
+
+TellicoSaxImporter::~TellicoSaxImporter() {
+  if(m_zip) {
+    m_zip->close();
+  }
+  delete m_zip;
+  m_zip = 0;
+  delete m_buffer;
+  m_buffer = 0;
+}
+
+Tellico::Data::CollPtr TellicoSaxImporter::collection() {
+  if(m_coll) {
+    return m_coll;
+  }
+
+  TQCString s; // read first 5 characters
+  if(source() == URL) {
+    if(!fileRef().open()) {
+      return 0;
+    }
+    TQIODevice* f = fileRef().file();
+    for(uint i = 0; i < 5; ++i) {
+      s += static_cast<char>(f->getch());
+    }
+    f->reset();
+  } else {
+    if(data().size() < 5) {
+      m_format = Error;
+      return 0;
+    }
+    s = TQCString(data(), 6);
+  }
+
+  // need to decide if the data is xml text, or a zip file
+  // if the first 5 characters are <?xml then treat it like text
+  if(s[0] == '<' && s[1] == '?' && s[2] == 'x' && s[3] == 'm' && s[4] == 'l') {
+    m_format = XML;
+    loadXMLData(source() == URL ? fileRef().file()->readAll() : data(), true);
+  } else {
+    m_format = Zip;
+    loadZipData();
+  }
+  return m_coll;
+}
+
+void TellicoSaxImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) {
+  ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
+  item.setTotalSteps(data_.size());
+  connect(&item, SIGNAL(signalCancelled(ProgressItem*)), SLOT(slotCancel()));
+  ProgressItem::Done done(this);
+
+  const bool showProgress = options() & ImportProgress;
+
+  TellicoXMLHandler handler;
+  handler.setLoadImages(loadImages_);
+
+  TQXmlSimpleReader reader;
+  reader.setContentHandler(&handler);
+
+  TQXmlInputSource source;
+  bool success = reader.parse(&source, true);
+
+  const uint blockSize = data_.size()/100 + 1;
+  uint pos = 0;
+  TQByteArray block;
+
+  while(success && !m_cancelled && pos < data_.size()) {
+    uint size = TQMIN(blockSize, data_.size() - pos);
+    block.setRawData(data_.data() + pos, size);
+    source.setData(block);
+    success = reader.parseContinue();
+    block.resetRawData(data_.data() + pos, size);
+    pos += blockSize;
+    if(showProgress) {
+      ProgressManager::self()->setProgress(this, pos);
+      kapp->processEvents();
+    }
+  }
+
+  if(!success) {
+    m_format = Error;
+    TQString error;
+    if(!url().isEmpty()) {
+      error = i18n(errorLoad).arg(url().fileName()) + TQChar('\n');
+    }
+    error += handler.errorString();
+    myDebug() << error << endl;
+    setStatusMessage(error);
+    return;
+  }
+
+  if(!m_cancelled) {
+    m_hasImages = handler.hasImages();
+    m_coll = handler.collection();
+  }
+}
+
+void TellicoSaxImporter::loadZipData() {
+  delete m_buffer;
+  delete m_zip;
+  if(source() == URL) {
+    m_buffer = 0;
+    m_zip = new KZip(fileRef().fileName());
+  } else {
+    m_buffer = new TQBuffer(data());
+    m_zip = new KZip(m_buffer);
+  }
+  if(!m_zip->open(IO_ReadOnly)) {
+    setStatusMessage(i18n(errorLoad).arg(url().fileName()));
+    m_format = Error;
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+
+  const KArchiveDirectory* dir = m_zip->directory();
+  if(!dir) {
+    TQString str = i18n(errorLoad).arg(url().fileName()) + TQChar('\n');
+    str += i18n("The file is empty.");
+    setStatusMessage(str);
+    m_format = Error;
+    m_zip->close();
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+
+  // main file was changed from bookcase.xml to tellico.xml as of version 0.13
+  const KArchiveEntry* entry = dir->entry(TQString::fromLatin1("tellico.xml"));
+  if(!entry) {
+    entry = dir->entry(TQString::fromLatin1("bookcase.xml"));
+  }
+  if(!entry || !entry->isFile()) {
+    TQString str = i18n(errorLoad).arg(url().fileName()) + TQChar('\n');
+    str += i18n("The file contains no collection data.");
+    setStatusMessage(str);
+    m_format = Error;
+    m_zip->close();
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+
+  const TQByteArray xmlData = static_cast<const KArchiveFile*>(entry)->data();
+  loadXMLData(xmlData, false);
+  if(!m_coll) {
+    m_format = Error;
+    m_zip->close();
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+
+  if(m_cancelled) {
+    m_zip->close();
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+
+  const KArchiveEntry* imgDirEntry = dir->entry(TQString::fromLatin1("images"));
+  if(!imgDirEntry || !imgDirEntry->isDirectory()) {
+    m_zip->close();
+    delete m_zip;
+    m_zip = 0;
+    delete m_buffer;
+    m_buffer = 0;
+    return;
+  }
+  m_imgDir = static_cast<const KArchiveDirectory*>(imgDirEntry);
+  m_images.clear();
+  m_images.add(m_imgDir->entries());
+  m_hasImages = !m_images.isEmpty();
+
+  // if all the images are not to be loaded, then we're done
+  if(!m_loadAllImages) {
+//    myLog() << "TellicoSaxImporter::loadZipData() - delayed loading for " << m_images.count() << " images" << endl;
+    return;
+  }
+
+  const TQStringList images = static_cast<const KArchiveDirectory*>(imgDirEntry)->entries();
+  const uint stepSize = TQMAX(s_stepSize, images.count()/100);
+
+  uint j = 0;
+  for(TQStringList::ConstIterator it = images.begin(); !m_cancelled && it != images.end(); ++it, ++j) {
+    const KArchiveEntry* file = m_imgDir->entry(*it);
+    if(file && file->isFile()) {
+      ImageFactory::addImage(static_cast<const KArchiveFile*>(file)->data(),
+                             (*it).section('.', -1).upper(), (*it));
+      m_images.remove(*it);
+    }
+    if(j%stepSize == 0) {
+      kapp->processEvents();
+    }
+  }
+
+  if(m_images.isEmpty()) {
+    // give it some time
+    TQTimer::singleShot(3000, this, SLOT(deleteLater()));
+  }
+}
+
+bool TellicoSaxImporter::hasImages() const {
+  return m_hasImages;
+}
+
+bool TellicoSaxImporter::loadImage(const TQString& id_) {
+//  myLog() << "TellicoSaxImporter::loadImage() - id =  " << id_ << endl;
+  if(m_format != Zip || !m_imgDir) {
+    return false;
+  }
+  const KArchiveEntry* file = m_imgDir->entry(id_);
+  if(!file || !file->isFile()) {
+    return false;
+  }
+  TQString newID = ImageFactory::addImage(static_cast<const KArchiveFile*>(file)->data(),
+                                         id_.section('.', -1).upper(), id_);
+  m_images.remove(id_);
+  if(m_images.isEmpty()) {
+    // give it some time
+    TQTimer::singleShot(3000, this, SLOT(deleteLater()));
+  }
+  return !newID.isEmpty();
+}
+
+void TellicoSaxImporter::slotCancel() {
+  m_cancelled = true;
+  m_format = Cancel;
+}
+
+#include "tellicosaximporter.moc"
diff --git a/src/translators/tellicosaximporter.h b/src/translators/tellicosaximporter.h
new file mode 100644
index 0000000..056f60f
--- /dev/null
+++ b/src/translators/tellicosaximporter.h
@@ -0,0 +1,87 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef TELLICO_IMPORT_TELLICOSAXIMPORTER_H
+#define TELLICO_IMPORT_TELLICOSAXIMPORTER_H
+
+#include "dataimporter.h"
+#include "../datavectors.h"
+#include "../stringset.h"
+
+class TQBuffer;
+class KZip;
+class KArchiveDirectory;
+
+namespace Tellico {
+  namespace Import {
+
+/**
+ * @author Robby Stephenson
+ */
+class TellicoSaxImporter : public DataImporter {
+Q_OBJECT
+
+public:
+  enum Format { Unknown, Error, XML, Zip, Cancel };
+
+  /**
+   * @param url The tellico data file.
+   */
+  TellicoSaxImporter(const KURL& url, bool loadAllImages=true);
+  /**
+   * Constructor used to convert arbitrary text to a @ref Collection
+   *
+   * @param text The text
+   */
+  TellicoSaxImporter(const TQString& text);
+  virtual ~TellicoSaxImporter();
+
+  /**
+   * sometimes, a new document format might add data
+   */
+  bool modifiedOriginal() const { return m_modified; }
+
+  /**
+   */
+  virtual Data::CollPtr collection();
+  Format format() const { return m_format; }
+
+  bool hasImages() const;
+  bool loadImage(const TQString& id_);
+
+  static bool loadAllImages(const KURL& url);
+
+public slots:
+  void slotCancel();
+
+private:
+  void loadXMLData(const TQByteArray& data, bool loadImages);
+  void loadZipData();
+
+  Data::CollPtr m_coll;
+  bool m_loadAllImages;
+  TQString m_namespace;
+  Format m_format;
+  bool m_modified : 1;
+  bool m_cancelled : 1;
+  bool m_hasImages : 1;
+  StringSet m_images;
+
+  TQBuffer* m_buffer;
+  KZip* m_zip;
+  const KArchiveDirectory* m_imgDir;
+};
+
+  } // end namespace
+} // end namespace
+#endif
diff --git a/src/translators/tellicoxmlhandler.cpp b/src/translators/tellicoxmlhandler.cpp
new file mode 100644
index 0000000..5b3f063
--- /dev/null
+++ b/src/translators/tellicoxmlhandler.cpp
@@ -0,0 +1,74 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "tellicoxmlhandler.h"
+#include "../collection.h"
+#include "../tellico_debug.h"
+
+using Tellico::Import::TellicoXMLHandler;
+
+TellicoXMLHandler::TellicoXMLHandler() : TQXmlDefaultHandler(), m_data(new SAX::StateData) {
+  m_handlers.setAutoDelete(true);
+  m_handlers.push(new SAX::RootHandler(m_data));
+}
+
+TellicoXMLHandler::~TellicoXMLHandler() {
+  delete m_data;
+  m_data = 0;
+}
+
+bool TellicoXMLHandler::startElement(const TQString& nsURI_, const TQString& localName_,
+                                     const TQString& qName_, const TQXmlAttributes& atts_) {
+  SAX::StateHandler* handler = m_handlers.top()->nextHandler(nsURI_, localName_, qName_);
+  Q_ASSERT(handler);
+  m_handlers.push(handler);
+  return handler->start(nsURI_, localName_, qName_, atts_);
+}
+
+bool TellicoXMLHandler::endElement(const TQString& nsURI_, const TQString& localName_,
+                                   const TQString& qName_) {
+  m_data->text = m_data->text.stripWhiteSpace();
+/*
+  if(!m_data->text.isEmpty()) {
+    myDebug() << " text: " << m_text << endl;
+  }
+*/
+
+  SAX::StateHandler* handler = m_handlers.pop();
+  bool res = handler->end(nsURI_, localName_, qName_);
+  // need to reset character data, too
+  m_data->text = TQString();
+  delete handler;
+  return res;
+}
+
+bool TellicoXMLHandler::characters(const TQString& ch_) {
+  m_data->text += ch_;
+  return true;
+}
+
+TQString TellicoXMLHandler::errorString() {
+  return m_data->error;
+}
+
+Tellico::Data::CollPtr TellicoXMLHandler::collection() const {
+  return m_data->coll;
+}
+
+bool TellicoXMLHandler::hasImages() const {
+  return m_data->hasImages;
+}
+
+void TellicoXMLHandler::setLoadImages(bool loadImages_) {
+  m_data->loadImages = loadImages_;
+}
diff --git a/src/translators/tellicoxmlhandler.h b/src/translators/tellicoxmlhandler.h
new file mode 100644
index 0000000..1edeacc
--- /dev/null
+++ b/src/translators/tellicoxmlhandler.h
@@ -0,0 +1,49 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef TELLICO_IMPORT_TELLICOXMLHANDLER_H
+#define TELLICO_IMPORT_TELLICOXMLHANDLER_H
+
+#include "xmlstatehandler.h"
+
+#include <tqptrstack.h>
+
+namespace Tellico {
+  namespace Import {
+
+class TellicoXMLHandler : public TQXmlDefaultHandler {
+public:
+  TellicoXMLHandler();
+  ~TellicoXMLHandler();
+
+  virtual bool startElement(const TQString& namespaceURI, const TQString& localName,
+                            const TQString& qName, const TQXmlAttributes& atts);
+  virtual bool endElement(const TQString& namespaceURI, const TQString& localName,
+                          const TQString& qName);
+  virtual bool characters(const TQString& ch);
+
+  virtual TQString errorString();
+
+  Data::CollPtr collection() const;
+  bool hasImages() const;
+
+  void setLoadImages(bool loadImages);
+
+private:
+  TQPtrStack<SAX::StateHandler> m_handlers;
+  SAX::StateData* m_data;
+};
+
+  }
+}
+#endif
diff --git a/src/translators/xmlstatehandler.cpp b/src/translators/xmlstatehandler.cpp
new file mode 100644
index 0000000..48d52d6
--- /dev/null
+++ b/src/translators/xmlstatehandler.cpp
@@ -0,0 +1,772 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "xmlstatehandler.h"
+#include "tellico_xml.h"
+#include "../latin1literal.h"
+#include "../collection.h"
+#include "../collectionfactory.h"
+#include "../collections/bibtexcollection.h"
+#include "../image.h"
+#include "../imagefactory.h"
+#include "../isbnvalidator.h"
+#include "../tellico_utils.h"
+#include "../tellico_debug.h"
+
+#include <tdelocale.h>
+#include <kmdcodec.h>
+
+namespace {
+
+inline
+TQString attValue(const TQXmlAttributes& atts, const char* name, const TQString& defaultValue=TQString()) {
+  int idx = atts.index(TQString::fromLatin1(name));
+  return idx < 0 ? defaultValue : atts.value(idx);
+}
+
+inline
+TQString attValue(const TQXmlAttributes& atts, const char* name, const char* defaultValue) {
+  Q_ASSERT(defaultValue);
+  return attValue(atts, name, TQString::fromLatin1(defaultValue));
+}
+
+}
+
+using Tellico::Import::SAX::StateHandler;
+using Tellico::Import::SAX::NullHandler;
+using Tellico::Import::SAX::RootHandler;
+using Tellico::Import::SAX::DocumentHandler;
+using Tellico::Import::SAX::CollectionHandler;
+using Tellico::Import::SAX::FieldsHandler;
+using Tellico::Import::SAX::FieldHandler;
+using Tellico::Import::SAX::FieldPropertyHandler;
+using Tellico::Import::SAX::BibtexPreambleHandler;
+using Tellico::Import::SAX::BibtexMacrosHandler;
+using Tellico::Import::SAX::BibtexMacroHandler;
+using Tellico::Import::SAX::EntryHandler;
+using Tellico::Import::SAX::FieldValueContainerHandler;
+using Tellico::Import::SAX::FieldValueHandler;
+using Tellico::Import::SAX::DateValueHandler;
+using Tellico::Import::SAX::TableColumnHandler;
+using Tellico::Import::SAX::ImagesHandler;
+using Tellico::Import::SAX::ImageHandler;
+using Tellico::Import::SAX::FiltersHandler;
+using Tellico::Import::SAX::FilterHandler;
+using Tellico::Import::SAX::FilterRuleHandler;
+using Tellico::Import::SAX::BorrowersHandler;
+using Tellico::Import::SAX::BorrowerHandler;
+using Tellico::Import::SAX::LoanHandler;
+
+StateHandler* StateHandler::nextHandler(const TQString& ns_, const TQString& localName_, const TQString& qName_) {
+  StateHandler* handler = nextHandlerImpl(ns_, localName_, qName_);
+  if(!handler) {
+    myWarning() << "StateHandler::nextHandler() - no handler for " << localName_ << endl;
+  }
+  return handler ? handler : new NullHandler(d);
+}
+
+StateHandler* RootHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("tellico") || localName_ == Latin1Literal("bookcase")) {
+    return new DocumentHandler(d);
+  }
+  return new RootHandler(d);
+}
+
+StateHandler* DocumentHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("collection")) {
+    return new CollectionHandler(d);
+  } else if(localName_ == Latin1Literal("filters")) {
+    return new FiltersHandler(d);
+  } else if(localName_ == Latin1Literal("borrowers")) {
+    return new BorrowersHandler(d);
+  }
+  return 0;
+}
+
+bool DocumentHandler::start(const TQString&, const TQString& localName_, const TQString&, const TQXmlAttributes& atts_) {
+  // the syntax version field name changed from "version" to "syntaxVersion" in version 3
+  int idx = atts_.index(TQString::fromLatin1("syntaxVersion"));
+  if(idx < 0) {
+    idx = atts_.index(TQString::fromLatin1("version"));
+  }
+  if(idx < 0) {
+    myWarning() << "RootHandler::start() - no syntax version" << endl;
+    return false;
+  }
+  d->syntaxVersion = atts_.value(idx).toUInt();
+  if(d->syntaxVersion > Tellico::XML::syntaxVersion) {
+    d->error = i18n("It is from a future version of Tellico.");
+    return false;
+  } else if(Tellico::XML::versionConversion(d->syntaxVersion, Tellico::XML::syntaxVersion)) {
+    // going from version 9 to 10, there's no conversion needed
+    TQString str = i18n("Tellico is converting the file to a more recent document format. "
+                       "Information loss may occur if an older version of Tellico is used "
+                       "to read this file in the future.");
+    myDebug() << str <<  endl;
+  }
+  if((d->syntaxVersion > 6 && localName_ != Latin1Literal("tellico")) ||
+     (d->syntaxVersion < 7 && localName_ != Latin1Literal("bookcase"))) {
+    // no error message
+    myWarning() << "RootHandler::start() - bad root element name" << endl;
+    return false;
+  }
+  d->ns = d->syntaxVersion > 6 ? Tellico::XML::nsTellico : Tellico::XML::nsBookcase;
+  return true;
+}
+
+bool DocumentHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* CollectionHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if((d->syntaxVersion > 3 && localName_ == Latin1Literal("fields")) ||
+     (d->syntaxVersion < 4 && localName_ == Latin1Literal("attributes"))) {
+    return new FieldsHandler(d);
+  } else if(localName_ == Latin1Literal("bibtex-preamble")) {
+    return new BibtexPreambleHandler(d);
+  } else if(localName_ == Latin1Literal("macros")) {
+    return new BibtexMacrosHandler(d);
+  } else if(localName_ == d->entryName) {
+    return new EntryHandler(d);
+  } else if(localName_ == Latin1Literal("images")) {
+    return new ImagesHandler(d);
+  }
+  return 0;
+}
+
+bool CollectionHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  d->collTitle = attValue(atts_, "title");
+  d->collType = attValue(atts_, "type").toInt();
+  d->entryName = attValue(atts_, "unit");
+
+  Q_ASSERT(d->collType);
+  return true;
+}
+
+bool CollectionHandler::end(const TQString&, const TQString&, const TQString&) {
+  d->coll->addEntries(d->entries);
+  // a little hidden capability was to just have a local path as an image file name
+  // and on reading the xml file, Tellico would load the image file, too
+  // here, we need to scan all the image values in all the entries and check
+  // maybe this is too costly, especially since the capability wasn't advertised?
+  Data::FieldVec fields = d->coll->imageFields();
+  for(Data::EntryVecIt entry = d->entries.begin(); entry != d->entries.end(); ++entry) {
+    for(Data::FieldVecIt field = fields.begin(); field != fields.end(); ++field) {
+      TQString value = entry->field(field, false);
+      // image info should have already been loaded
+      const Data::ImageInfo& info = ImageFactory::imageInfo(value);
+      // possible that value needs to be cleaned first in which case info is null
+      if(info.isNull() || !info.linkOnly) {
+        // for local files only, allow paths here
+        KURL u = KURL::fromPathOrURL(value);
+        if(u.isValid() && u.isLocalFile()) {
+          TQString result = ImageFactory::addImage(u, false /* quiet */);
+          if(!result.isEmpty()) {
+            value = result;
+          }
+        }
+        value = Data::Image::idClean(value);
+        entry->setField(field->name(), value);
+      }
+    }
+  }
+  return true;
+}
+
+StateHandler* FieldsHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if((d->syntaxVersion > 3 && localName_ == Latin1Literal("field")) ||
+     (d->syntaxVersion < 4 && localName_ == Latin1Literal("attribute"))) {
+    return new FieldHandler(d);
+  }
+  return 0;
+}
+
+bool FieldsHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  d->defaultFields = false;
+  return true;
+}
+
+bool FieldsHandler::end(const TQString&, const TQString&, const TQString&) {
+  // add default fields if there was a default field name, or no names at all
+  const bool addFields = d->defaultFields || d->fields.isEmpty();
+  // in syntax 4, the element name was changed to "entry", always, rather than depending on
+  // on the entryName of the collection.
+  if(d->syntaxVersion > 3) {
+    d->entryName = TQString::fromLatin1("entry");
+    Data::Collection::Type type = static_cast<Data::Collection::Type>(d->collType);
+    d->coll = CollectionFactory::collection(type, addFields);
+  } else {
+    d->coll = CollectionFactory::collection(d->entryName, addFields);
+  }
+
+  if(!d->collTitle.isEmpty()) {
+    d->coll->setTitle(d->collTitle);
+  }
+
+  d->coll->addFields(d->fields);
+
+//  as a special case, for old book collections with a bibtex-id field, convert to Bibtex
+  if(d->syntaxVersion < 4 && d->collType == Data::Collection::Book
+     && d->coll->hasField(TQString::fromLatin1("bibtex-id"))) {
+    d->coll = Data::BibtexCollection::convertBookCollection(d->coll);
+  }
+
+  return true;
+}
+
+StateHandler* FieldHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("prop")) {
+    return new FieldPropertyHandler(d);
+  }
+  return 0;
+}
+
+bool FieldHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  // special case: if the i18n attribute equals true, then translate the title, description, and category
+  const bool isI18n = attValue(atts_, "i18n") == Latin1Literal("true");
+
+  TQString name  = attValue(atts_, "name", "unknown");
+  if(name == Latin1Literal("_default")) {
+    d->defaultFields = true;
+    return true;
+  }
+
+  TQString title  = attValue(atts_, "title", i18n("Unknown"));
+  if(isI18n) {
+    title = i18n(title.utf8());
+  }
+
+  TQString typeStr = attValue(atts_, "type", TQString::number(Data::Field::Line));
+  Data::Field::Type type = static_cast<Data::Field::Type>(typeStr.toInt());
+
+  Data::FieldPtr field;
+  if(type == Data::Field::Choice) {
+    TQStringList allowed = TQStringList::split(TQRegExp(TQString::fromLatin1("\\s*;\\s*")),
+                                             attValue(atts_, "allowed"));
+    if(isI18n) {
+      for(TQStringList::Iterator word = allowed.begin(); word != allowed.end(); ++word) {
+        (*word) = i18n((*word).utf8());
+      }
+    }
+    field = new Data::Field(name, title, allowed);
+  } else {
+    field = new Data::Field(name, title, type);
+  }
+
+  int idx = atts_.index(TQString::fromLatin1("category"));
+  if(idx > -1) {
+    // at one point, the categories had keyboard accels
+    TQString cat = atts_.value(idx);
+    if(d->syntaxVersion < 9 && cat.find('&') > -1) {
+      cat.remove('&');
+    }
+    if(isI18n) {
+      cat = i18n(cat.utf8());
+    }
+    field->setCategory(cat);
+  }
+
+  idx = atts_.index(TQString::fromLatin1("flags"));
+  if(idx > -1) {
+    int flags = atts_.value(idx).toInt();
+    // I also changed the enum values for syntax 3, but the only custom field
+    // would have been bibtex-id
+    if(d->syntaxVersion < 3 && name == Latin1Literal("bibtex-id")) {
+      flags = 0;
+    }
+
+    // in syntax version 4, added a flag to disallow deleting attributes
+    // if it's a version before that and is the title, then add the flag
+    if(d->syntaxVersion < 4 && name == Latin1Literal("title")) {
+      flags |= Data::Field::NoDelete;
+    }
+    field->setFlags(flags);
+  }
+
+  TQString formatStr = attValue(atts_, "format", TQString::number(Data::Field::FormatNone));
+  Data::Field::FormatFlag format = static_cast<Data::Field::FormatFlag>(formatStr.toInt());
+  field->setFormatFlag(format);
+
+  idx = atts_.index(TQString::fromLatin1("description"));
+  if(idx > -1) {
+    TQString desc = atts_.value(idx);
+    if(isI18n) {
+      desc = i18n(desc.utf8());
+    }
+    field->setDescription(desc);
+  }
+
+  if(d->syntaxVersion < 5 && atts_.index(TQString::fromLatin1("bibtex-field")) > -1) {
+    field->setProperty(TQString::fromLatin1("bibtex"), attValue(atts_, "bibtex-field"));
+  }
+
+  // Table2 is deprecated
+  if(type == Data::Field::Table2) {
+    field->setType(Data::Field::Table);
+    field->setProperty(TQString::fromLatin1("columns"), TQChar('2'));
+  }
+
+  // for syntax 8, rating fields got their own type
+  if(d->syntaxVersion < 8) {
+    Data::Field::convertOldRating(field); // does all its own checking
+  }
+  d->fields.append(field);
+
+  return true;
+}
+
+bool FieldHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+bool FieldPropertyHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  // there should be at least one field already so we can add properties to it
+  Q_ASSERT(!d->fields.isEmpty());
+  Data::FieldPtr field = d->fields.back();
+
+  m_propertyName = attValue(atts_, "name");
+
+  // all track fields in music collections prior to version 9 get converted to three columns
+  if(d->syntaxVersion < 9) {
+    if(d->collType == Data::Collection::Album && field->name() == Latin1Literal("track")) {
+      field->setProperty(TQString::fromLatin1("columns"), TQChar('3'));
+      field->setProperty(TQString::fromLatin1("column1"), i18n("Title"));
+      field->setProperty(TQString::fromLatin1("column2"), i18n("Artist"));
+      field->setProperty(TQString::fromLatin1("column3"), i18n("Length"));
+    } else if(d->collType == Data::Collection::Video && field->name() == Latin1Literal("cast")) {
+      field->setProperty(TQString::fromLatin1("column1"), i18n("Actor/Actress"));
+      field->setProperty(TQString::fromLatin1("column2"), i18n("Role"));
+    }
+  }
+
+  return true;
+}
+
+bool FieldPropertyHandler::end(const TQString&, const TQString&, const TQString&) {
+  Q_ASSERT(!m_propertyName.isEmpty());
+  // add the previous property
+  Data::FieldPtr field = d->fields.back();
+  field->setProperty(m_propertyName, d->text);
+  return true;
+}
+
+bool BibtexPreambleHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool BibtexPreambleHandler::end(const TQString&, const TQString&, const TQString&) {
+  Q_ASSERT(d->coll);
+  if(d->coll && d->collType == Data::Collection::Bibtex && !d->text.isEmpty()) {
+    Data::BibtexCollection* c = static_cast<Data::BibtexCollection*>(d->coll.data());
+    c->setPreamble(d->text);
+  }
+  return true;
+}
+
+StateHandler* BibtexMacrosHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("macro")) {
+    return new BibtexMacroHandler(d);
+  }
+  return 0;
+}
+
+bool BibtexMacrosHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool BibtexMacrosHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+bool BibtexMacroHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  m_macroName = attValue(atts_, "name");
+  return true;
+}
+
+bool BibtexMacroHandler::end(const TQString&, const TQString&, const TQString&) {
+  if(d->coll && d->collType == Data::Collection::Bibtex && !m_macroName.isEmpty() && !d->text.isEmpty()) {
+    Data::BibtexCollection* c = static_cast<Data::BibtexCollection*>(d->coll.data());
+    c->addMacro(m_macroName, d->text);
+  }
+  return true;
+}
+
+StateHandler* EntryHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(d->coll->hasField(localName_)) {
+    return new FieldValueHandler(d);
+  }
+  return new FieldValueContainerHandler(d);
+}
+
+bool EntryHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  // the entries must come after the fields
+  if(!d->coll || d->coll->fields().isEmpty()) {
+    myWarning() << "EntryHandler::start() - entries must come after fields are defined" << endl;
+    // TODO: i18n
+    d->error = TQString::fromLatin1("File format error: entries must come after fields are defined");
+    return false;
+  }
+  int id = attValue(atts_, "id").toInt();
+  Data::EntryPtr entry;
+  if(id > 0) {
+    entry = new Data::Entry(d->coll, id);
+  } else {
+    entry = new Data::Entry(d->coll);
+  }
+  d->entries.append(entry);
+  return true;
+}
+
+bool EntryHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* FieldValueContainerHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(d->coll->hasField(localName_)) {
+    return new FieldValueHandler(d);
+  }
+  return new FieldValueContainerHandler(d);
+}
+
+bool FieldValueContainerHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool FieldValueContainerHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* FieldValueHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("year") ||
+     localName_ == Latin1Literal("month") ||
+     localName_ == Latin1Literal("day")) {
+    return new DateValueHandler(d);
+  } else if(localName_ == Latin1Literal("column")) {
+    return new TableColumnHandler(d);
+  }
+  return 0;
+}
+
+bool FieldValueHandler::start(const TQString&, const TQString&, const TQString& localName_, const TQXmlAttributes& atts_) {
+  d->currentField = d->coll->fieldByName(localName_);
+  m_i18n = attValue(atts_, "i18n") == Latin1Literal("true");
+  m_validateISBN = attValue(atts_, "validate") != Latin1Literal("no");
+  return true;
+}
+
+bool FieldValueHandler::end(const TQString&, const TQString& localName_, const TQString&) {
+  Data::FieldPtr f = d->coll->fieldByName(localName_);
+  if(!f) {
+    myWarning() << "FieldValueHandler::end() - no field named " << localName_ << endl;
+    return true;
+  }
+  // if it's a derived value, no field value is added
+  if(f->type() == Data::Field::Dependent) {
+    return true;
+  }
+
+  Data::EntryPtr entry = d->entries.back();
+  Q_ASSERT(entry);
+  TQString fieldName = localName_;
+  TQString fieldValue = d->text;
+
+  if(d->syntaxVersion < 2 && fieldName == Latin1Literal("keywords")) {
+    // in version 2, "keywords" changed to "keyword"
+    fieldName = TQString::fromLatin1("keyword");
+  } else if(d->syntaxVersion < 4 && f->type() == Data::Field::Bool) {
+    // in version 3 and prior, checkbox attributes had no text(), set it to "true"
+    fieldValue = TQString::fromLatin1("true");
+  } else if(d->syntaxVersion < 8 && f->type() == Data::Field::Rating) {
+    // in version 8, old rating fields get changed
+    bool ok;
+    uint i = Tellico::toUInt(fieldValue, &ok);
+    if(ok) {
+      fieldValue = TQString::number(i);
+    }
+  } else if(!d->textBuffer.isEmpty()) {
+    // for dates and tables, the value is built up from child elements
+#ifndef NDEBUG
+    if(!d->text.isEmpty()) {
+      myWarning() << "FieldValueHandler::end() - ignoring value for field " << localName_ << ": " << d->text << endl;
+    }
+#endif
+    fieldValue = d->textBuffer;
+    d->textBuffer = TQString();
+  }
+  // this is not an else branch, the data may be in the textBuffer
+  if(d->syntaxVersion < 9 && d->coll->type() == Data::Collection::Album && fieldName == Latin1Literal("track")) {
+    // yes, this assumes the artist has already been set
+    fieldValue += TQString::fromLatin1("::");
+    fieldValue += entry->field(TQString::fromLatin1("artist"));
+  }
+  // special case: if the i18n attribute equals true, then translate the title, description, and category
+  if(m_i18n) {
+    fieldValue = i18n(fieldValue.utf8());
+  }
+  // special case for isbn fields, go ahead and validate
+  if(m_validateISBN && fieldName == Latin1Literal("isbn")) {
+    ISBNValidator val(0);
+    val.fixup(fieldValue);
+  }
+  if(fieldValue.isEmpty()) {
+    return true;
+  }
+  // for fields with multiple values, we need to add on the new value
+  TQString oldValue = entry->field(fieldName);
+  if(!oldValue.isEmpty()) {
+    fieldValue = oldValue + TQString::fromLatin1("; ") + fieldValue;
+  }
+  entry->setField(fieldName, fieldValue);
+  return true;
+}
+
+bool DateValueHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool DateValueHandler::end(const TQString&, const TQString& localName_, const TQString&) {
+  // the data value is y-m-d even if there are no date values
+  if(d->textBuffer.isEmpty()) {
+    d->textBuffer = TQString::fromLatin1("--");
+  }
+  TQStringList tokens = TQStringList::split('-', d->textBuffer, true /* allow empty */);
+  Q_ASSERT(tokens.size() == 3);
+  if(localName_ == Latin1Literal("year")) {
+    tokens[0] = d->text;
+  } else if(localName_ == Latin1Literal("month")) {
+    tokens[1] = d->text;
+  } else if(localName_ == Latin1Literal("day")) {
+    tokens[2] = d->text;
+  }
+  d->textBuffer = tokens.join(TQChar('-'));
+  return true;
+}
+
+bool TableColumnHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool TableColumnHandler::end(const TQString&, const TQString&, const TQString&) {
+  // for old collections, if the second column holds the track length, bump it to next column
+  if(d->syntaxVersion < 9 &&
+     d->coll->type() == Data::Collection::Album &&
+     d->currentField->name() == Latin1Literal("track") &&
+     !d->textBuffer.isEmpty() &&
+     d->textBuffer.contains(TQString::fromLatin1("::")) == 0) {
+    TQRegExp rx(TQString::fromLatin1("\\d+:\\d\\d"));
+    if(rx.exactMatch(d->text)) {
+      d->text += TQString::fromLatin1("::");
+      d->text += d->entries.back()->field(TQString::fromLatin1("artist"));
+    }
+  }
+
+  if(!d->textBuffer.isEmpty()) {
+    d->textBuffer += TQString::fromLatin1("::");
+  }
+  d->textBuffer += d->text;
+  return true;
+}
+
+StateHandler* ImagesHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("image")) {
+    return new ImageHandler(d);
+  }
+  return 0;
+}
+
+bool ImagesHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  // reset variable that gets updated in the image handler
+  d->hasImages = false;
+  return true;
+}
+
+bool ImagesHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+bool ImageHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  m_format = attValue(atts_, "format");
+  m_link = attValue(atts_, "link") == Latin1Literal("true");
+  // idClean() already calls shareString()
+  m_imageId = m_link ? shareString(attValue(atts_, "id"))
+                     : Data::Image::idClean(attValue(atts_, "id"));
+  m_width = attValue(atts_, "width").toInt();
+  m_height = attValue(atts_, "height").toInt();
+  return true;
+}
+
+bool ImageHandler::end(const TQString&, const TQString&, const TQString&) {
+  bool readInfo = true;
+  if(d->loadImages) {
+    TQByteArray ba;
+    KCodecs::base64Decode(TQCString(d->text.latin1()), ba);
+    if(!ba.isEmpty()) {
+      TQString result = ImageFactory::addImage(ba, m_format, m_imageId);
+      if(result.isEmpty()) {
+        myDebug() << "TellicoImporter::readImage(XML) - null image for " << m_imageId << endl;
+      }
+      d->hasImages = true;
+      readInfo = false;
+    }
+  }
+  if(readInfo) {
+    // a width or height of 0 is ok here
+    Data::ImageInfo info(m_imageId, m_format.latin1(), m_width, m_height, m_link);
+    ImageFactory::cacheImageInfo(info);
+  }
+  return true;
+}
+
+StateHandler* FiltersHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("filter")) {
+    return new FilterHandler(d);
+  }
+  return 0;
+}
+
+bool FiltersHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool FiltersHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* FilterHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("rule")) {
+    return new FilterRuleHandler(d);
+  }
+  return 0;
+}
+
+bool FilterHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  d->filter = new Filter(Filter::MatchAny);
+  d->filter->setName(attValue(atts_, "name"));
+
+  if(attValue(atts_, "match") == Latin1Literal("all")) {
+    d->filter->setMatch(Filter::MatchAll);
+  }
+  return true;
+}
+
+bool FilterHandler::end(const TQString&, const TQString&, const TQString&) {
+  if(d->coll && !d->filter->isEmpty()) {
+    d->coll->addFilter(d->filter);
+  }
+  d->filter = FilterPtr();
+  return true;
+}
+
+bool FilterRuleHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  TQString field = attValue(atts_, "field");
+  // empty field means match any of them
+  TQString pattern = attValue(atts_, "pattern");
+  // empty pattern is bad
+  if(pattern.isEmpty()) {
+    myWarning() << "FilterRuleHandler::start() - empty rule!" << endl;
+    return true;
+  }
+  TQString function = attValue(atts_, "function").lower();
+  FilterRule::Function func;
+  if(function == Latin1Literal("contains")) {
+    func = FilterRule::FuncContains;
+  } else if(function == Latin1Literal("notcontains")) {
+    func = FilterRule::FuncNotContains;
+  } else if(function == Latin1Literal("equals")) {
+    func = FilterRule::FuncEquals;
+  } else if(function == Latin1Literal("notequals")) {
+    func = FilterRule::FuncNotEquals;
+  } else if(function == Latin1Literal("regexp")) {
+    func = FilterRule::FuncRegExp;
+  } else if(function == Latin1Literal("notregexp")) {
+    func = FilterRule::FuncNotRegExp;
+  } else {
+    myWarning() << "FilterRuleHandler::start() - invalid rule function: " << function << endl;
+    return true;
+  }
+  d->filter->append(new FilterRule(field, pattern, func));
+  return true;
+}
+
+bool FilterRuleHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* BorrowersHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("borrower")) {
+    return new BorrowerHandler(d);
+  }
+  return 0;
+}
+
+bool BorrowersHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) {
+  return true;
+}
+
+bool BorrowersHandler::end(const TQString&, const TQString&, const TQString&) {
+  return true;
+}
+
+StateHandler* BorrowerHandler::nextHandlerImpl(const TQString&, const TQString& localName_, const TQString&) {
+  if(localName_ == Latin1Literal("loan")) {
+    return new LoanHandler(d);
+  }
+  return 0;
+}
+
+bool BorrowerHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  TQString name = attValue(atts_, "name");
+  TQString uid = attValue(atts_, "uid");
+  d->borrower = new Data::Borrower(name, uid);
+
+  return true;
+}
+
+bool BorrowerHandler::end(const TQString&, const TQString&, const TQString&) {
+  if(d->coll && !d->borrower->isEmpty()) {
+    d->coll->addBorrower(d->borrower);
+  }
+  d->borrower = Data::BorrowerPtr();
+  return true;
+}
+
+bool LoanHandler::start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes& atts_) {
+  m_id = attValue(atts_, "entryRef").toInt();
+  m_uid = attValue(atts_, "uid");
+  m_loanDate = attValue(atts_, "loanDate");
+  m_dueDate = attValue(atts_, "dueDate");
+  m_inCalendar = attValue(atts_, "calendar") == Latin1Literal("true");
+  return true;
+}
+
+bool LoanHandler::end(const TQString&, const TQString&, const TQString&) {
+  Data::EntryPtr entry = d->coll->entryById(m_id);
+  if(!entry) {
+    myWarning() << "LoanHandler::end() - no entry with id = " << m_id << endl;
+    return true;
+  }
+  TQDate loanDate, dueDate;
+  if(!m_loanDate.isEmpty()) {
+    loanDate = TQDate::fromString(m_loanDate, TQt::ISODate);
+  }
+  if(!m_dueDate.isEmpty()) {
+    dueDate = TQDate::fromString(m_dueDate, TQt::ISODate);
+  }
+
+  Data::LoanPtr loan = new Data::Loan(entry, loanDate, dueDate, d->text);
+  loan->setUID(m_uid);
+  loan->setInCalendar(m_inCalendar);
+  d->borrower->addLoan(loan);
+  return true;
+}
+
diff --git a/src/translators/xmlstatehandler.h b/src/translators/xmlstatehandler.h
new file mode 100644
index 0000000..8b5c137
--- /dev/null
+++ b/src/translators/xmlstatehandler.h
@@ -0,0 +1,345 @@
+/***************************************************************************
+    copyright            : (C) 2008 by Robby Stephenson
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of version 2 of the GNU General Public License as  *
+ *   published by the Free Software Foundation;                            *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef TELLICO_IMPORT_XMLSTATEHANDLER_H
+#define TELLICO_IMPORT_XMLSTATEHANDLER_H
+
+#ifdef QT_NO_CAST_ASCII
+#define HAD_QT_NO_CAST_ASCII
+#undef QT_NO_CAST_ASCII
+#endif
+
+#include <tqxml.h>
+
+#ifdef HAD_QT_NO_CAST_ASCII
+#define QT_NO_CAST_ASCII
+#undef HAD_QT_NO_CAST_ASCII
+#endif
+
+#include "../datavectors.h"
+
+namespace Tellico {
+  namespace Import {
+    namespace SAX {
+
+class StateData {
+public:
+  TQString text;
+  TQString error;
+  TQString ns; // namespace
+  TQString textBuffer;
+  uint syntaxVersion;
+  TQString collTitle;
+  int collType;
+  TQString entryName;
+  Data::CollPtr coll;
+  Data::FieldVec fields;
+  Data::FieldPtr currentField;
+  Data::EntryVec entries;
+  FilterPtr filter;
+  Data::BorrowerPtr borrower;
+  bool defaultFields;
+  bool loadImages;
+  bool hasImages;
+};
+
+class StateHandler {
+public:
+  StateHandler(StateData* data) : d(data) {}
+  virtual ~StateHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) = 0;
+  virtual bool   end(const TQString&, const TQString&, const TQString&) = 0;
+
+  StateHandler* nextHandler(const TQString&, const TQString&, const TQString&);
+protected:
+  StateData* d;
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&)  { return 0; }
+};
+
+class NullHandler : public StateHandler {
+public:
+  NullHandler(StateData* data) : StateHandler(data) {}
+  virtual ~NullHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) { return true; }
+  virtual bool   end(const TQString&, const TQString&, const TQString&) { return true; }
+};
+
+class RootHandler : public StateHandler {
+public:
+  RootHandler(StateData* data) : StateHandler(data) {}
+  virtual ~RootHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&) { return true; }
+  virtual bool   end(const TQString&, const TQString&, const TQString&) { return true; }
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class DocumentHandler : public StateHandler {
+public:
+  DocumentHandler(StateData* data) : StateHandler(data) {}
+  virtual ~DocumentHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class CollectionHandler : public StateHandler {
+public:
+  CollectionHandler(StateData* data) : StateHandler(data) {}
+  virtual ~CollectionHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FieldsHandler : public StateHandler {
+public:
+  FieldsHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FieldsHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FieldHandler : public StateHandler {
+public:
+  FieldHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FieldHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FieldPropertyHandler : public StateHandler {
+public:
+  FieldPropertyHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FieldPropertyHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  TQString m_propertyName;
+};
+
+class BibtexPreambleHandler : public StateHandler {
+public:
+  BibtexPreambleHandler(StateData* data) : StateHandler(data) {}
+  virtual ~BibtexPreambleHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+};
+
+class BibtexMacrosHandler : public StateHandler {
+public:
+  BibtexMacrosHandler(StateData* data) : StateHandler(data) {}
+  virtual ~BibtexMacrosHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class BibtexMacroHandler : public StateHandler {
+public:
+  BibtexMacroHandler(StateData* data) : StateHandler(data) {}
+  virtual ~BibtexMacroHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  TQString m_macroName;
+};
+
+class EntryHandler : public StateHandler {
+public:
+  EntryHandler(StateData* data) : StateHandler(data) {}
+  virtual ~EntryHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FieldValueContainerHandler : public StateHandler {
+public:
+  FieldValueContainerHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FieldValueContainerHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FieldValueHandler : public StateHandler {
+public:
+  FieldValueHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FieldValueHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+  bool m_i18n;
+  bool m_validateISBN;
+};
+
+class DateValueHandler : public StateHandler {
+public:
+  DateValueHandler(StateData* data) : StateHandler(data) {}
+  virtual ~DateValueHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+};
+
+class TableColumnHandler : public StateHandler {
+public:
+  TableColumnHandler(StateData* data) : StateHandler(data) {}
+  virtual ~TableColumnHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+};
+
+class ImagesHandler : public StateHandler {
+public:
+  ImagesHandler(StateData* data) : StateHandler(data) {}
+  virtual ~ImagesHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class ImageHandler : public StateHandler {
+public:
+  ImageHandler(StateData* data) : StateHandler(data) {}
+  virtual ~ImageHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  TQString m_format;
+  bool m_link;
+  TQString m_imageId;
+  int m_width;
+  int m_height;
+};
+
+class FiltersHandler : public StateHandler {
+public:
+  FiltersHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FiltersHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FilterHandler : public StateHandler {
+public:
+  FilterHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FilterHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class FilterRuleHandler : public StateHandler {
+public:
+  FilterRuleHandler(StateData* data) : StateHandler(data) {}
+  virtual ~FilterRuleHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+};
+
+class BorrowersHandler : public StateHandler {
+public:
+  BorrowersHandler(StateData* data) : StateHandler(data) {}
+  virtual ~BorrowersHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class BorrowerHandler : public StateHandler {
+public:
+  BorrowerHandler(StateData* data) : StateHandler(data) {}
+  virtual ~BorrowerHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  virtual StateHandler* nextHandlerImpl(const TQString&, const TQString&, const TQString&);
+};
+
+class LoanHandler : public StateHandler {
+public:
+  LoanHandler(StateData* data) : StateHandler(data) {}
+  virtual ~LoanHandler() {}
+
+  virtual bool start(const TQString&, const TQString&, const TQString&, const TQXmlAttributes&);
+  virtual bool   end(const TQString&, const TQString&, const TQString&);
+
+private:
+  int m_id;
+  TQString m_uid;
+  TQString m_loanDate;
+  TQString m_dueDate;
+  bool m_inCalendar;
+};
+
+    }
+  }
+}
+#endif
diff --git a/src/translators/xsltexporter.cpp b/src/translators/xsltexporter.cpp
index c08ee0f..b0642b3 100644
--- a/src/translators/xsltexporter.cpp
+++ b/src/translators/xsltexporter.cpp
@@ -18,6 +18,8 @@
 
 #include <tdelocale.h>
 #include <kurlrequester.h>
+#include <kuser.h>
+#include <tdeconfig.h>
 
 #include <tqlabel.h>
 #include <tqgroupbox.h>
@@ -49,6 +51,9 @@ bool XSLTExporter::exec() {
   }
   //  XSLTHandler handler(FileHandler::readXMLFile(url));
   XSLTHandler handler(u);
+  handler.addStringParam("date", TQDate::currentDate().toString(TQt::ISODate).latin1());
+  handler.addStringParam("time", TQTime::currentTime().toString(TQt::ISODate).latin1());
+  handler.addStringParam("user", KUser(KUser::UseRealUserID).loginName().latin1());
 
   TellicoXMLExporter exporter;
   exporter.setEntries(entries());
@@ -75,6 +80,25 @@ TQWidget* XSLTExporter::widget(TQWidget* parent_, const char* name_/*=0*/) {
   m_URLRequester = new KURLRequester(box);
   TQWhatsThis::add(m_URLRequester, i18n("Choose the XSLT file used to transform the Tellico XML data."));
 
+  TQString filter = i18n("*.xsl|XSL Files (*.xsl)") + TQChar('\n');
+  filter += i18n("*|All Files");
+  m_URLRequester->setFilter(filter);
+  m_URLRequester->setMode(static_cast<KFile::Mode>(KFile::File | KFile::ExistingOnly));
+  if(!m_xsltFile.isEmpty()) {
+    m_URLRequester->setURL(m_xsltFile);
+  }
+
   l->addStretch(1);
   return m_widget;
 }
+
+void XSLTExporter::readOptions(TDEConfig* config_) {
+  TDEConfigGroup group(config_, TQString::fromLatin1("ExportOptions - %1").arg(formatString()));
+  m_xsltFile = group.readEntry("Last File", TQString());
+}
+
+void XSLTExporter::saveOptions(TDEConfig* config_) {
+  TDEConfigGroup group(config_, TQString::fromLatin1("ExportOptions - %1").arg(formatString()));
+  m_xsltFile = m_URLRequester->url();
+  group.writeEntry("Last File", m_xsltFile);
+}
diff --git a/src/translators/xsltexporter.h b/src/translators/xsltexporter.h
index b14afd3..8b808e5 100644
--- a/src/translators/xsltexporter.h
+++ b/src/translators/xsltexporter.h
@@ -34,9 +34,13 @@ public:
 
   virtual TQWidget* widget(TQWidget* parent, const char* name=0);
 
+  virtual void readOptions(TDEConfig* cfg);
+  virtual void saveOptions(TDEConfig* cfg);
+
 private:
   TQWidget* m_widget;
   KURLRequester* m_URLRequester;
+  TQString m_xsltFile;
 };
 
   } // end namespace
diff --git a/src/upcvalidator.cpp b/src/upcvalidator.cpp
index 73cc0d6..e3aca4e 100644
--- a/src/upcvalidator.cpp
+++ b/src/upcvalidator.cpp
@@ -13,6 +13,7 @@
 
 #include "upcvalidator.h"
 #include "isbnvalidator.h"
+#include "tellico_debug.h"
 
 #include <kmdcodec.h>
 
@@ -24,7 +25,7 @@ UPCValidator::UPCValidator(TQObject* parent_, const char* name_/*=0*/)
 
 TQValidator::State UPCValidator::validate(TQString& input_, int& pos_) const {
   // check if it's a cuecat first
-  State catState = decodeCat(input_);
+  State catState = CueCat::decode(input_);
   if(catState == Acceptable) {
     pos_ = input_.length();
     return catState;
@@ -91,18 +92,18 @@ void UPCValidator::fixup(TQString& input_) const {
   }
 }
 
-TQValidator::State UPCValidator::decodeCat(TQString& input_) const {
+TQValidator::State Tellico::CueCat::decode(TQString& input_) {
   if(input_.length() < 3) {
-    return Intermediate;
+    return TQValidator::Intermediate;
   }
  if(!input_.startsWith(TQString::fromLatin1(".C3"))) { // all cuecat codes start with .C3
-    return Invalid;
+    return TQValidator::Invalid;
   }
   const int periods = input_.contains('.');
   if(periods < 4) {
-    return Intermediate; // not enough yet
+    return TQValidator::Intermediate; // not enough yet
   } else if(periods > 4) {
-    return Invalid;
+    return TQValidator::Invalid;
   }
 
   // ok, let's have a go, take the third token
@@ -127,7 +128,7 @@ TQValidator::State UPCValidator::decodeCat(TQString& input_) const {
   }
 
   input_ = code;
-  return Acceptable;
+  return TQValidator::Acceptable;
 }
 
 #include "upcvalidator.moc"
diff --git a/src/upcvalidator.h b/src/upcvalidator.h
index 5931c79..854dc62 100644
--- a/src/upcvalidator.h
+++ b/src/upcvalidator.h
@@ -37,11 +37,14 @@ signals:
   void signalISBN();
 
 private:
-  State decodeCat(TQString& str) const;
-
   bool m_checkISBN : 1;
   mutable bool m_isbn : 1;
 };
 
+class CueCat {
+public:
+  static TQValidator::State decode(TQString& str);
+};
+
 } // end namespace
 #endif