summaryrefslogtreecommitdiffstats
path: root/kab/addressbook.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kab/addressbook.cpp')
-rw-r--r--kab/addressbook.cpp2040
1 files changed, 2040 insertions, 0 deletions
diff --git a/kab/addressbook.cpp b/kab/addressbook.cpp
new file mode 100644
index 000000000..017621ac7
--- /dev/null
+++ b/kab/addressbook.cpp
@@ -0,0 +1,2040 @@
+/*
+ This file implements the basic personal information management class
+ used in the TDE addressbook.
+
+ the TDE addressbook
+
+ $ Author: Mirko Boehm $
+ $ Copyright: (C) 1996-2001, Mirko Boehm $
+ $ Contact: mirko@kde.org
+ http://www.kde.org $
+ $ License: GPL with the following explicit clarification:
+ This code may be linked against any version of the Qt toolkit
+ from Troll Tech, Norway. $
+
+ $Id$
+*/
+
+#include "addressbook.h"
+#include "qconfigDB.h"
+
+#include <tqfileinfo.h>
+#include <tqstringlist.h>
+
+#include <tdeapplication.h>
+#include <tdeglobal.h>
+#include <kstandarddirs.h>
+#include <tdelocale.h>
+#include <kdebug.h>
+#include <tdemessagebox.h>
+
+extern "C" {
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+}
+
+// ----- some defines:
+#ifdef KAB_KDEBUG_AREA
+#undef KAB_KDEBUG_AREA
+#endif
+
+#define KAB_KDEBUG_AREA 800
+
+#ifdef STD_USERFILENAME
+#undef STD_USERFILENAME
+#endif
+#define STD_USERFILENAME "kab/addressbook.kab"
+
+#ifdef STD_CONFIGFILENAME
+#undef STD_CONFIGFILENAME
+#endif
+#define STD_CONFIGFILENAME "kab/kab.config"
+
+#ifdef ENTRY_SECTION
+#undef ENTRY_SECTION
+#endif
+#define ENTRY_SECTION "entries"
+
+// the name of the file-local configuration section
+#ifdef LOCAL_CONFIG_SECTION
+#undef LOCAL_CONFIG_SECTION
+#endif
+#define LOCAL_CONFIG_SECTION "config"
+
+// the name of the subsection for each entry
+#ifdef ADDRESS_SUBSECTION
+#undef ADDRESS_SUBSECTION
+#endif
+#define ADDRESS_SUBSECTION "addresses"
+
+#ifdef KAB_TEMPLATEFILE
+#undef KAB_TEMPLATEFILE
+#endif
+#define KAB_TEMPLATEFILE "kab/template.kab"
+
+#ifdef KAB_CONFIGTEMPLATE
+#undef KAB_CONFIGTEMPLATE
+#endif
+#define KAB_CONFIGTEMPLATE "kab/template.config"
+
+#ifdef KAB_CATEGORY_KEY
+#undef KAB_CATEGORY_KEY
+#endif
+#define KAB_CATEGORY_KEY "categories"
+
+const char* AddressBook::Entry::Address::Fields[]= {
+ "headline", "position",
+ "org", "orgunit", "orgsubunit",
+ "deliverylabel", "address", "zip", "town", "country", "state" };
+const int AddressBook::Entry::Address::NoOfFields
+=sizeof(AddressBook::Entry::Address::Fields)
+/sizeof(AddressBook::Entry::Address::Fields[0]);
+
+const char* AddressBook::Entry::Fields[]= {
+ "title", "rank", "fn", "nameprefix", "firstname", "middlename", "lastname",
+ "birthday", "comment", "talk", "emails", "keywords", "telephone",
+ "urls", "user1", "user2", "user3", "user4", "custom", "categories" };
+const int AddressBook::Entry::NoOfFields
+=sizeof(AddressBook::Entry::Fields)/sizeof(AddressBook::Entry::Fields[0]);
+
+struct QStringLess
+ : public binary_function<const TQString&, const TQString&, bool>
+{
+ /** The function operator, inline. */
+ bool operator()(const TQString& x, const TQString& y) const
+ {
+ return x < y; // make one Qt operator fit exactly
+ }
+};
+
+// ----- the derived map class:
+class StringKabKeyMap : public map<TQString, KabKey, QStringLess>
+{ /* Same as map, but a class for compilation reasons. This way we do not need
+ * to include the QStringLess class into the addressbook header file. */
+};
+
+// ----- another derived map class:
+class KeyNameMap : public map<const char*, TQString, less<const char*> >
+{ // same thing
+};
+
+KeyNameMap* AddressBook::Entry::fields;
+KeyNameMap* AddressBook::Entry::Address::fields;
+
+bool
+KabKey::operator == (const KabKey& key) const
+{
+ // ###########################################################################
+ return key.getKey()==getKey();
+ // ###########################################################################
+}
+
+void
+KabKey::setKey(const TQCString& text)
+{
+ // ###########################################################################
+ key=text;
+ // ###########################################################################
+}
+
+TQCString
+KabKey::getKey() const
+{
+ // ###########################################################################
+ return key;
+ // ###########################################################################
+}
+
+
+
+AddressBook::Entry::Address::Address()
+{
+}
+
+bool AddressBook::Entry::Address::nameOfField(const char* key, TQString& value)
+{
+ KeyNameMap::iterator pos;
+ // -----
+ if(fields==0)
+ { // this is executed exactly one time per application instance,
+ // as fields is static
+ int counter=0;
+ fields=new KeyNameMap;
+ TQ_CHECK_PTR(fields);
+ if(!fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Headline"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Position"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Organization"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Department"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Sub-Department"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Delivery Label"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("street/postal","Address"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Zipcode"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("City"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Country"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("As in addresses", "State"))).second)
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::Address::nameOfField (while "
+ << " creating field-name map): TYPO, correct this."
+ << endl;
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::Address::nameOfField: "
+ << "inserted field names." << endl;
+ }
+#if ! defined NDEBUG
+ TQString name;
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::Address::nameOfField:" << endl
+ << "Created key-fieldname-map. Defined fields are:"
+ << endl;
+ for(counter=0; counter<AddressBook::Entry::Address::NoOfFields;
+ ++counter)
+ {
+ pos=fields->find(Fields[counter]);
+ if(pos==fields->end())
+ {
+ kdDebug(KAB_KDEBUG_AREA) << " UNDEFINED" << endl;
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << " " << Fields[counter] << " ("
+ << (*pos).second.utf8() << ")" << endl;
+ }
+ }
+#endif
+ }
+ // ----- now finally do the lookup:
+ pos=fields->find(key);
+ if(pos==fields->end())
+ {
+ return false;
+ } else {
+ value=(*pos).second;
+ return true;
+ }
+}
+
+bool AddressBook::Entry::nameOfField(const char* key, TQString& value)
+{
+ KeyNameMap::iterator pos;
+ // -----
+ if(fields==0)
+ { // this is executed exactly one time per application instance,
+ // as fields is static
+ int counter=0;
+ fields=new KeyNameMap;
+ TQ_CHECK_PTR(fields);
+ if(!fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("person","Title"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Rank"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Formatted Name"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Name Prefix"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("First Name"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Middle Name"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Last Name"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Birthday"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Comment"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Talk Addresses"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Email Addresses"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Keywords"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Telephone Number"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("URLs"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("User Field 1"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("User Field 2"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("User Field 3"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("User Field 4"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Custom"))).second
+ ||
+ !fields->insert
+ (map<const char*, TQString, less<const char*> >::value_type
+ (Fields[counter++], i18n("Categories"))).second)
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::Address::nameOfField (while "
+ << " creating field-name map): TYPO, correct this." << endl;
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::Address::nameOfField: "
+ << "inserted field names." << endl;
+ }
+#if ! defined NDEBUG
+ TQString name;
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::Entry::nameOfField:" << endl
+ << "Created key-fieldname-map. Defined fields are:" << endl;
+ for(counter=0; counter<AddressBook::Entry::Address::NoOfFields;
+ ++counter)
+ {
+ pos=fields->find(Fields[counter]);
+ if(pos==fields->end())
+ {
+ kdDebug(KAB_KDEBUG_AREA) << " UNDEFINED" << endl;
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << " " << Fields[counter] << " ("
+ << (*pos).second.utf8() << ")" << endl;
+ }
+ }
+#endif
+ }
+ // ----- now finally do the lookup:
+ pos=fields->find(key);
+ if(pos==fields->end())
+ {
+ return false;
+ } else {
+ value=(*pos).second;
+ return true;
+ }
+}
+
+AddressBook::ErrorCode
+AddressBook::Entry::getAddress(int index, Address& address) const
+{
+ // ###########################################################################
+ list<Address>::const_iterator pos;
+ // -----
+ if(index>=0 && (unsigned)index<addresses.size())
+ {
+ pos=addresses.begin();
+ advance(pos, index);
+ address=*pos;
+ return AddressBook::NoError;
+ } else {
+ return AddressBook::OutOfRange;
+ }
+ // ###########################################################################
+}
+
+int AddressBook::Entry::noOfAddresses() const
+{
+ return addresses.size();
+}
+
+AddressBook::AddressBook(TQWidget* parent, const char* name, bool loadit)
+ : TQFrame(parent, name),
+ config(new QConfigDB(this)),
+ data(new QConfigDB(this)),
+ entries(new StringKabKeyMap),
+ state(NoFile)
+{
+ bool GUARD; GUARD=true;
+ // ###########################################################################
+ TQString dir, filename;
+ bool createBackup=true;
+ KeyValueMap *keys;
+ // ----- do memory checks (do not rely on exception handling):
+ if(config==0 || data==0 || entries==0)
+ {
+ KMessageBox::error(this,
+ i18n("Cannot initialize local variables."),
+ i18n("Out of Memory"));
+ kapp->quit(); // It is critical, but will possibly never happen.
+ }
+ connect(data, TQT_SIGNAL(fileChanged()), TQT_SLOT(dataFileChanged()));
+ connect(data, TQT_SIGNAL(changed(QConfigDB*)),
+ TQT_SLOT(reloaded(QConfigDB*)));
+ connect(config, TQT_SIGNAL(fileChanged()), TQT_SLOT(configFileChanged()));
+ // ----- set style:
+
+ filename = locate( "data", STD_CONFIGFILENAME);
+ if (filename.isEmpty())
+ {
+ filename = locateLocal( "data", STD_CONFIGFILENAME );
+ // config does not exist yet
+ if(createConfigFile()!=NoError)
+ {
+ KMessageBox::sorry(this,
+ i18n("Your local kab configuration file "
+ "\"%1\" "
+ "could not be created. kab will probably not "
+ "work correctly without it.\n"
+ "Make sure you have not removed write permission "
+ "from your local TDE directory (usually ~/.trinity).").arg(filename));
+ state=PermDenied;
+ }
+ }
+ loadConfigFile();
+ // ----- now get some configuration settings:
+ if(config->get("config", keys))
+ {
+ keys->get("CreateBackupOnStartup", createBackup);
+ }
+ // ----- check and possibly create user standard file:
+ filename = locate( "data", STD_USERFILENAME );
+
+ if(filename.isEmpty()) // if it does not exist
+ {
+ filename = locateLocal( "data", STD_USERFILENAME);
+ if(createNew(filename)!=NoError) // ...and we cannot create it
+ {
+ KMessageBox::sorry(this,
+ i18n("Your standard kab database file "
+ "\"%1\" "
+ "could not be created. kab will probably not "
+ "work correctly without it.\n"
+ "Make sure you have not removed write permission "
+ "from your local TDE directory (usually ~/.trinity).").arg(filename));
+ state=PermDenied;
+ } else {
+ KMessageBox::information
+ (this,
+ i18n("kab has created your standard addressbook in\n\"%1\"")
+ .arg(filename));
+ }
+ }
+ // ----- load the user standard file:
+ if(loadit)
+ {
+ if(load(filename)!=NoError)
+ { // ----- the standard file could not be loaded
+ state=PermDenied;
+ } else {
+ if(createBackup)
+ {
+ // ----- create the backup file:
+ TQString temp=data->fileName();
+ if(data->setFileName(temp+".backup", false, false))
+ {
+ if(!data->save())
+ {
+ KMessageBox::information
+ (this,
+ i18n("Cannot create backup file (permission denied)."),
+ i18n("File Error"));
+ }
+ } else {
+ KMessageBox::error
+ (this,
+ i18n("Cannot open backup file for "
+ "writing (permission denied)."),
+ i18n("File Error"));
+ }
+ // ----- reset the filename:
+ if(!data->setFileName(temp, true, true))
+ {
+ KMessageBox::error
+ (this,
+ i18n("Critical error:\n"
+ "Permissions changed in local directory!"),
+ i18n("File Error"));
+ closeFile(false);
+ state=PermDenied;
+ } else {
+ state=NoError;
+ }
+ }
+ }
+ }
+ // -----
+ data->watch(true);
+ // ###########################################################################
+}
+
+AddressBook::~AddressBook()
+{
+ // ###########################################################################
+ delete data;
+ delete config;
+ delete entries;
+ // ###########################################################################
+}
+
+QConfigDB* AddressBook::getConfig()
+{
+ // ###########################################################################
+ return config;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode AddressBook::getState()
+{
+ // ###########################################################################
+ return state;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode AddressBook::load(const TQString& filename)
+{
+ // ----- Remark: Close the file if it could not be loaded!
+ // ###########################################################################
+ ErrorCode rc=NoError;
+ TQFileInfo newfile, oldfile;
+ // -----
+ TQString fname = (filename.isEmpty()) ? data->fileName() : filename ;
+ if(fname.isEmpty()) // there was never a filename set:
+ {
+ state=NoFile;
+ return NoFile;
+ }
+ // -----
+ newfile.setFile(fname);
+ oldfile.setFile(data->fileName());
+ if(isSameFile(fname, data->fileName()))
+ { // ----- possibly deleted file:
+ if(data->load())
+ {
+ emit(setStatus(i18n("File reloaded.")));
+ state=NoError;
+ } else {
+ switch
+ (KMessageBox::questionYesNo
+ (this,
+ i18n("The currently loaded file "
+ "\"%1\" "
+ "cannot be reloaded. kab may close or save it.\n"
+ "Save it if you accidentally deleted your data file.\n"
+ "Close it if you intended to do so.\n"
+ "Your file will be closed by default.")
+ .arg(oldfile.absFilePath()),
+ i18n("File Error"),
+ KStdGuiItem::close(), KStdGuiItem::save()))
+ {
+ case KMessageBox::No: // save
+ if(!data->save(i18n("(Safety copy on file error)").ascii(), true))
+ {
+ KMessageBox::information(this,
+ i18n("Cannot save the file; will close it now."),
+ i18n("File Error"));
+ closeFile(false);
+ state=NoFile;
+ rc=PermDenied;
+ } else {
+ state=NoError;
+ rc=NoError;
+ }
+ break; // no error if we could save the file
+ default: // close
+ closeFile(false);
+ state=NoFile;
+ rc=NoSuchFile;
+ break;
+ }
+ }
+ } else { // ----- set new filename
+ if(data->setFileName(fname, true, true))
+ {
+ if(data->load())
+ {
+ emit(changed());
+ emit(setStatus(i18n("File opened.")));
+ state=NoError;
+ } else {
+ KMessageBox::information(this,
+ i18n("Could not load the file."),
+ i18n("File Error"));
+ closeFile(false);
+ emit(setStatus(i18n("No such file.")));
+ rc=NoSuchFile;
+ }
+ } else {
+ if(KMessageBox::questionYesNo
+ (this,
+ i18n("The file \"%1\" cannot be found. "
+ "Create a new one?").arg(fname),
+ i18n("No Such File"),
+ i18n("Create"), KStdGuiItem::cancel())==KMessageBox::Yes)
+ {
+ if(createNew(fname)==NoError)
+ {
+ emit(setStatus(i18n("New file.")));
+ } else { // ----- do not close here, stick with the old file:
+ emit(setStatus(i18n("Canceled.")));
+ }
+ }
+ }
+ }
+ // -----
+ if(rc==NoError)
+ {
+ data->watch(true);
+ updateMirrorMap();
+ }
+ // -----
+ return rc;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getListOfNames(TQStringList* strings, bool reverse, bool initials)
+{
+ bool GUARD; GUARD=false;
+ // ###########################################################################
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getListOfNames: called.\n";
+ StringKabKeyMap::iterator pos;
+ TQString desc;
+ ErrorCode rc=NoError;
+ ErrorCode temp;
+ // ----- erase the list contents:
+ strings->clear();
+ // ----- ...and fill it:
+ for(pos=entries->begin(); pos!=entries->end(); ++pos)
+ {
+ temp=literalName((*pos).second, desc, reverse, initials);
+ if(temp!=AddressBook::NoError)
+ {
+ desc=i18n("(Internal error in kab)");
+ rc=InternError;
+ }
+ if(desc.isEmpty())
+ {
+ desc=i18n("(empty entry)");
+ }
+ kdDebug(GUARD, KAB_KDEBUG_AREA) <<
+ "AddressBook::getListOfNames: adding " << desc << endl;
+ strings->append(desc);
+ }
+ // ----- any problems?
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::getListOfNames: done, "
+ << strings->count()
+ << " entries.\n";
+ return rc;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::literalName(const KabKey& key, TQString& text, bool rev, bool init)
+{
+ // ###########################################################################
+ Entry entry;
+ ErrorCode rc;
+ // ----- get the entry:
+ rc=getEntry(key, entry);
+ if(rc!=NoError)
+ {
+ return rc;
+ }
+ // -----
+ return literalName(entry, text, rev, init);
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::literalName(const Entry& entry, TQString& text, bool rev, bool init)
+{
+ bool GUARD; GUARD=false;
+ // ###########################################################################
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::literalName: called.\n";
+ TQString firstname, middlename, lastname, nameprefix;
+ // ----- is the formatted name set?
+ if(!entry.fn.isEmpty())
+ {
+ text=entry.fn;
+ kdDebug(GUARD, KAB_KDEBUG_AREA) <<
+ "AddressBook::literalName: done (fn).\n";
+ return NoError;
+ }
+ // ----- prepare the strings:
+ firstname=entry.firstname.simplifyWhiteSpace();
+ middlename=entry.middlename.simplifyWhiteSpace();
+ lastname=entry.lastname.simplifyWhiteSpace();
+ nameprefix=entry.nameprefix.simplifyWhiteSpace();
+ // ----- create the initials:
+ if(init)
+ {
+ if(!firstname.isEmpty()) firstname=firstname.mid(0, 1)+'.';
+ if(!middlename.isEmpty()) middlename=middlename.mid(0, 1)+'.';
+ // if(!lastname.isEmpty()) lastname=lastname.mid(0, 1)+'.';
+ }
+ // ----- assemble the string:
+ text="";
+ if(rev)
+ { // name, firstname - add. name - name prefix
+ if(!lastname.isEmpty())
+ {
+ text=lastname;
+ }
+ if(!firstname.isEmpty() || !middlename.isEmpty() || !nameprefix.isEmpty())
+ {
+ text+=',';
+ }
+ if(!firstname.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=firstname;
+ }
+ if(!middlename.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=middlename;
+ }
+ if(!nameprefix.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=nameprefix;
+ }
+ } else {
+ // firstname - add. name - name prefix - name
+ text=firstname;
+ if(!middlename.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=middlename;
+ }
+ if(!nameprefix.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=nameprefix;
+ }
+ if(!lastname.isEmpty())
+ {
+ if(!text.isEmpty())
+ {
+ text+=' ';
+ }
+ text+=lastname;
+ }
+ }
+ // -----
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::literalName: done: "
+ << text << ".\n";
+ return NoError;
+ // ###########################################################################
+}
+
+unsigned int
+AddressBook::noOfEntries()
+{
+ // ###########################################################################
+ return entries->size();
+ // ###########################################################################
+}
+
+void
+AddressBook::dataFileChanged()
+{
+ // ###########################################################################
+ data->watch(false); // will be restarted after successful load
+ load();
+ // ###########################################################################
+}
+
+void
+AddressBook::configFileChanged()
+{
+ bool GUARD; GUARD=true;
+ // ###########################################################################
+ if(!config->load())
+ {
+ KMessageBox::error(this,
+ i18n("Cannot reload configuration file!"),
+ i18n("File Error"));
+ } else {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::configFileChanged: "
+ "config file reloaded.\n";
+ emit(setStatus(i18n("Configuration file reloaded.")));
+ }
+ // ###########################################################################
+}
+
+void
+AddressBook::reloaded(QConfigDB* db)
+{
+ bool GUARD; GUARD=false;
+ // ###########################################################################
+ if(db==data)
+ {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::reloaded: file has been "
+ "reloaded.\n";
+ updateMirrorMap(); // WORK_TO_DO: what's up with the return value?
+ changed();
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::save(const TQString& filename, bool force)
+{
+ // ###########################################################################
+ if(filename.isEmpty())
+ {
+ if(data->save(0, force))
+ {
+ emit(setStatus(i18n("File saved.")));
+ return NoError;
+ } else {
+ return PermDenied;
+ }
+ } else {
+ if(data->setFileName(filename, false, false))
+ {
+ if(data->save(0, true))
+ {
+ emit(newFile(filename));
+ return NoError;
+ } else {
+ return PermDenied;
+ }
+ } else {
+ return PermDenied;
+ }
+ }
+ // ###########################################################################
+}
+
+bool
+AddressBook::isSameFile(const TQString& a, const TQString& b)
+{
+ // ###########################################################################
+ TQFileInfo filea(a), fileb(b);
+ // -----
+ return filea.absFilePath()==fileb.absFilePath();
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::closeFile(bool saveit)
+{
+ // ###########################################################################
+ if(saveit)
+ {
+ if(save()!=NoError)
+ {
+ emit(setStatus(i18n("Permission denied.")));
+ return PermDenied;
+ }
+ }
+ data->clear();
+ // data->reset(); WORK_TO_DO: File name is not reset by now.
+ emit(setStatus(i18n("File closed.")));
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getEntry(const KabKey& key, Entry& entry)
+{
+ // ###########################################################################
+ Section *section;
+ // -----
+ if(getEntry(key, section)==NoError)
+ {
+ return makeEntryFromSection(section, entry);
+ } else {
+ return NoSuchEntry;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getEntry(const KabKey& key, Section*& section)
+{
+ bool GUARD; GUARD=false;
+ // ###########################################################################
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getEntry: searching entry "
+ "with key " << key.getKey().data() << endl;
+ StringKabKeyMap::iterator pos;
+ // -----
+ for(pos=entries->begin(); pos!=entries->end(); ++pos)
+ {
+ if((*pos).second==key)
+ {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) <<
+ "AddressBook::getEntry: key exists." << endl;
+ break;
+ }
+ }
+ if(pos==entries->end())
+ {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) <<
+ "AddressBook::getEntry: no such entry.\n";
+ return NoSuchEntry;
+ } else {
+ if(data->get((TQCString)ENTRY_SECTION+'/'+key.getKey(), section))
+ {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) <<
+ "AddressBook::getEntry: done." << endl;
+ return NoError;
+ } else {
+ return InternError;
+ }
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getEntries(list<Entry>& thelist)
+{
+ // ###########################################################################
+ StringKabKeyMap::iterator pos;
+ Entry entry;
+ ErrorCode rc;
+ // -----
+ kdDebug(!thelist.empty(), KAB_KDEBUG_AREA)
+ << "AddressBook::getEntries: warning - non-empty value list!" << endl;
+ thelist.erase(thelist.begin(), thelist.end());
+ for(pos=entries->begin(); pos!=entries->end(); ++pos)
+ {
+ rc=getEntry((*pos).second, entry);
+ if(rc==NoError)
+ {
+ thelist.push_back(entry);
+ } else {
+ return InternError;
+ }
+ }
+ // -----
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getKey(int index, KabKey& key)
+{
+ // ###########################################################################
+ StringKabKeyMap::iterator pos;
+ // -----
+ if((unsigned)index<entries->size())
+ {
+ pos=entries->begin();
+ advance(pos, index);
+ key=(*pos).second;
+ return NoError;
+ } else {
+ return NoSuchEntry;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::getIndex(const KabKey& key, int& index)
+{
+ bool GUARD; GUARD=true;
+ // ###########################################################################
+ StringKabKeyMap::iterator pos;
+ // -----
+ index=0;
+ for(pos=entries->begin(); pos!=entries->end(); ++pos)
+ {
+ // kdDebug(KAB_KDEBUG_AREA) << (*pos).second.getKey().data() << " <--> " <<
+ // key.getKey().data() << endl;
+ if((*pos).second==key) break;
+ ++index;
+ }
+ kdDebug(pos==entries->end(), KAB_KDEBUG_AREA) <<
+ "AddressBook::getIndex: no such key." << endl;
+ if(pos==entries->end())
+ {
+ return NoSuchEntry;
+ } else {
+ return NoError;
+ }
+ // ###########################################################################
+}
+
+Section*
+AddressBook::entrySection()
+{
+ // ###########################################################################
+ Section* section;
+ // -----
+ if(!data->get(ENTRY_SECTION, section))
+ {
+ return 0;
+ } else {
+ return section;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::add(const Entry& entry, KabKey& key, bool update)
+{
+ bool GUARD; GUARD=true;
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::add: called." << endl;
+ // ###########################################################################
+ Section* theEntries=entrySection();
+ Section* newEntry;
+ KabKey nextKey;
+ ErrorCode locked;
+ ErrorCode rc;
+ // -----
+ if(theEntries==0)
+ {
+ kdDebug(KAB_KDEBUG_AREA) << "AddressBook::add: no entries section."
+ << endl;
+ return NoFile;
+ }
+ newEntry=new Section;
+ if(newEntry==0)
+ {
+ KMessageBox::error(this,
+ i18n("Cannot initialize local variables."),
+ i18n("Out of Memory"));
+ kapp->quit(); // It is critical, but will possibly never happen.
+ return InternError; // shut the compiler up...
+ }
+ // ----- lock the file:
+ locked=lock();
+ switch(locked)
+ {
+ case PermDenied:
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::add: permission denied." << endl;
+ return PermDenied; // cannot get r/w mode
+ case Locked:
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::add: db is already in r/w mode." << endl;
+ break;
+ case NoError:
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::add: got writing permissions." << endl;
+ break;
+ default:
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::add: unknown response, exiting." << endl;
+ return InternError;
+ }
+ // -----
+ if(makeSectionFromEntry(entry, *newEntry)==NoError)
+ {
+ nextKey=nextAvailEntryKey();
+ if(!theEntries->add(nextKey.getKey(), newEntry))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::add: Cannot insert section.\n";
+ rc=InternError;
+ } else {
+ key=nextKey;
+ emit(changed());
+ rc=NoError;
+ }
+ if(update) updateMirrorMap();
+ } else {
+ rc=InternError;
+ }
+ if(locked!=Locked)
+ { // ----- unlock the file here:
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::add: dropped writing permissions." << endl;
+ locked=unlock();
+ }
+ // -----
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::add: done." << endl;
+ if(locked!=NoError)
+ {
+ return locked;
+ }
+ if(rc!=NoError)
+ {
+ return rc;
+ }
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::change(const KabKey& key, const Entry& entry)
+{
+ // ###########################################################################
+ Section* theEntries=entrySection();
+ Section* oldEntry;
+ ErrorCode locked;
+ ErrorCode rc;
+ // -----
+ if(theEntries==0)
+ {
+ return NoFile;
+ }
+ // ----- lock the file:
+ locked=lock();
+ if(locked==PermDenied)
+ {
+ return PermDenied; // cannot get r/w mode
+ }
+ // -----
+ if(!theEntries->find(key.getKey(), oldEntry))
+ {
+ rc=NoSuchEntry;
+ } else {
+ oldEntry->clear();
+ rc=makeSectionFromEntry(entry, *oldEntry);
+ emit(changed());
+ }
+ // -----
+ if(locked!=PermDenied)
+ { // ----- unlock the file here:
+ locked=unlock();
+ }
+ if(locked==NoError)
+ {
+ return rc;
+ } else {
+ return locked;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::remove(const KabKey& key)
+{
+ // ###########################################################################
+ Section *theEntries=entrySection();
+ ErrorCode locked;
+ ErrorCode rc;
+ // -----
+ if(theEntries==0)
+ {
+ return NoFile;
+ }
+ // ----- lock the file:
+ locked=lock();
+ if(locked==PermDenied)
+ {
+ return PermDenied; // cannot get r/w mode
+ }
+ // -----
+ if(theEntries->remove(key.getKey()))
+ {
+ rc=NoError;
+ emit(changed());
+ } else {
+ rc=NoSuchEntry;
+ }
+ // -----
+ if(locked!=PermDenied)
+ { // ----- unlock the file here:
+ locked=unlock();
+ }
+ if(locked==NoError)
+ {
+ return rc;
+ } else {
+ return locked;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::lock()
+{
+ // ###########################################################################
+ if(!data->isRO()) return Locked;
+ if(data->setFileName(data->fileName(), false, false))
+ {
+ return NoError;
+ } else {
+ KMessageBox::information(this,
+ i18n("The file you wanted to change could not be locked.\n"
+ "It is probably in use by another application or read-only."),
+ i18n("File Error"));
+ return PermDenied;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::unlock()
+{
+ // ###########################################################################
+ if(data->isRO()) return PermDenied;
+ if(data->setFileName(data->fileName(), true, true))
+ {
+ return NoError;
+ } else {
+ return InternError;
+ }
+ // ###########################################################################
+}
+
+KabKey
+AddressBook::nextAvailEntryKey()
+{
+ // ###########################################################################
+ int max=0;
+ int temp;
+ Section::StringSectionMap::iterator pos;
+ Section *section=entrySection();
+ KabKey key;
+ TQCString dummy;
+ bool good=true;
+ // -----
+ if(section!=0)
+ {
+ for(pos=section->sectionsBegin(); pos!=section->sectionsEnd(); ++pos)
+ {
+ temp=0;
+ temp=(*pos).first.toInt(&good);
+ if(!good)
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::nextAvailEntryKey: non-integer entry "
+ << endl;
+ }
+ if(temp>max)
+ {
+ max=temp;
+ }
+ }
+ }
+ // -----
+ dummy.setNum(++max);
+ key.setKey(dummy);
+ // CHECK(key.getKey().toInt(&good)==max);
+ return key;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::updateMirrorMap()
+{
+ bool GUARD; GUARD=false;
+ // ###########################################################################
+ kdDebug(GUARD, KAB_KDEBUG_AREA)
+ << "AddressBook::updateMirrorMap: updating mirror map.\n";
+ TQString key;
+ Entry entry;
+ ErrorCode ec;
+ KabKey kk;
+ Section *section=entrySection();
+ Section::StringSectionMap::iterator pos;
+ // -----
+ entries->erase(entries->begin(), entries->end());
+ if(section==0)
+ {
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::updateMirrorMap: done, "
+ "no file loaded." << endl;
+ return NoError;
+ }
+ for(pos=section->sectionsBegin(); pos!=section->sectionsEnd(); ++pos)
+ {
+ if(makeEntryFromSection((*pos).second, entry)!=NoError)
+ {
+ // return InternError; // it is saver to continue without a key
+ }
+ key="";
+ ec=literalName(entry, key, true, false);
+ if(key.isEmpty() || ec!=NoError)
+ {
+ key=i18n("(empty entry)");
+ }
+ key+=(*pos).first; // append the section name to make the key unique
+ kk.setKey((*pos).first);
+ entries->insert(StringKabKeyMap::value_type(key, kk));
+ }
+ // -----
+ kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::updateMirrorMap: done."
+ << endl;
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::makeEntryFromSection(Section* section, Entry& entry)
+{
+ // ###########################################################################
+ Section *addresses;
+ Section *addressSection;
+ Section::StringSectionMap::iterator pos;
+ KeyValueMap *keys;
+ Entry temp;
+ Entry::Address address;
+ Entry::Address addressDummy;
+ int count;
+ // ----- create the aggregats:
+ const TQCString StringKeys[]= {
+ "title",
+ "rank",
+ "fn",
+ "nameprefix",
+ "firstname",
+ "middlename",
+ "lastname",
+ "comment",
+ "user1",
+ "user2",
+ "user3",
+ "user4"
+ };
+ TQString* StringValues[]= {
+ &temp.title,
+ &temp.rank,
+ &temp.fn,
+ &temp.nameprefix,
+ &temp.firstname,
+ &temp.middlename,
+ &temp.lastname,
+ &temp.comment,
+ &temp.user1,
+ &temp.user2,
+ &temp.user3,
+ &temp.user4
+ };
+ const int StringKeySize=sizeof(StringKeys)/sizeof(StringKeys[0]);
+ const TQCString StringListKeys[]= {
+ "talk",
+ "emails",
+ "keywords",
+ "telephone",
+ "URLs",
+ "custom",
+ "categories"
+ };
+ TQStringList* StringListValues[]= {
+ &temp.talk,
+ &temp.emails,
+ &temp.keywords,
+ &temp.telephone,
+ &temp.URLs,
+ &temp.custom,
+ &temp.categories
+ };
+ const int StringListKeySize=sizeof(StringListKeys)/sizeof(StringListKeys[0]);
+ // ----- first parse "addresses" subsection:
+ if(!section->find(ADDRESS_SUBSECTION, addresses))
+ {
+ return InternError; // no subsection called "addresses"
+ }
+ for(pos=addresses->sectionsBegin(); pos!=addresses->sectionsEnd(); ++pos)
+ {
+ if(!addresses->find((*pos).first, addressSection))
+ {
+ return InternError; // no section we have an iterator for?
+ }
+ keys=addressSection->getKeys();
+ address=addressDummy; // clean it up
+ if(makeAddressFromMap(keys, address)==AddressBook::NoError)
+ {
+ // ----- add the address to the list of addresses:
+ temp.addresses.push_back(address);
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeEntryFromSection: cannot find all fields "
+ << "in an address subsection." << endl;
+ }
+ }
+ // ----- now parse all other fields directly:
+ keys=section->getKeys();
+ for(count=0; count<StringKeySize; ++count)
+ {
+ if(!keys->get(StringKeys[count], *StringValues[count]))
+ {
+ /* Spits out lots of warnings:
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeEntryFromSection: error: could not get "
+ << "value for key " << (const char*)StringKeys[count]
+ << "." << endl;
+ */
+ }
+ }
+ for(count=0; count<StringListKeySize; ++count)
+ {
+ if(!keys->get(StringListKeys[count], *StringListValues[count]))
+ {
+ /* Spits out lots of warnings:
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeEntryFromSection: error: could not get "
+ << "value for key " << (const char*)StringListKeys[count]
+ << "." << endl;
+ */
+ }
+ }
+ // ----- finally get the birthday:
+ keys->get("birthday", temp.birthday); // this may return false (no date)
+ // -----
+ entry=temp;
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::makeAddressFromMap(KeyValueMap* keys, Entry::Address& address)
+{
+ // ###########################################################################
+ const TQCString Keys[]= {
+ "headline",
+ "position",
+ "org",
+ "orgunit",
+ "orgsubunit",
+ // "role",
+ "deliverylabel",
+ "address",
+ "zip",
+ "town",
+ "country",
+ "state"
+ };
+ TQString* strings[]= {
+ &address.headline,
+ &address.position,
+ &address.org,
+ &address.orgUnit,
+ &address.orgSubUnit,
+ // &address.role,
+ &address.deliveryLabel,
+ &address.address,
+ &address.zip,
+ &address.town,
+ &address.country,
+ &address.state
+ };
+ const int Size=sizeof(Keys)/sizeof(Keys[0]);
+ int count;
+ // -----
+ for(count=0; count<Size; ++count)
+ {
+ keys->get(Keys[count], *strings[count]);
+ }
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::makeSectionFromEntry(const Entry& entry, Section& section)
+{
+ // ###########################################################################
+ list<Entry::Address>::const_iterator addPos;
+ Section *addresses=0;
+ Section *address=0;
+ TQCString key; // used for creating address subsection keys
+ int count=0; // counts the addresses
+ KeyValueMap *keys;
+ // ----- prepare the section object:
+ section.clear();
+ // ----- first create "addresses" subsection:
+ if(!section.add(ADDRESS_SUBSECTION))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeSectionFromEntry: cannot create " << "subsection."
+ << " " << endl;
+ return InternError;
+ }
+ if(!section.find(ADDRESS_SUBSECTION, addresses))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeSectionFromEntry: cannot get new section." << endl;
+ return InternError;
+ }
+ // ----- now insert addresses:
+ for(addPos=entry.addresses.begin(); addPos!=entry.addresses.end(); ++addPos)
+ {
+ ++count;
+ key.setNum(count);
+ if(!addresses->add(key))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeSectionFromEntry: cannot create address " << endl;
+ return InternError;
+ }
+ if(!addresses->find(key, address))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeSectionFromEntry: cannot get new " << endl;
+ return InternError;
+ }
+ keys=address->getKeys();
+ // ----- now insert keys into address:
+ if(!keys->insert("headline", (*addPos).headline) ||
+ !keys->insert("position", (*addPos).position) ||
+ !keys->insert("org", (*addPos).org) ||
+ !keys->insert("orgunit", (*addPos).orgUnit) ||
+ !keys->insert("orgsubunit", (*addPos).orgSubUnit) ||
+ // !keys->insert("role", (*addPos).role) ||
+ !keys->insert("deliverylabel", (*addPos).deliveryLabel) ||
+ !keys->insert("address", (*addPos).address) ||
+ !keys->insert("zip", (*addPos).zip) ||
+ !keys->insert("town", (*addPos).town) ||
+ !keys->insert("country", (*addPos).country) ||
+ !keys->insert("state", (*addPos).state))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeSectionFromEntry: cannot completely "
+ << "insert this address." << endl;
+ return InternError;
+ }
+ }
+ // ----- now add the other fields:
+ keys=section.getKeys();
+ if(!keys->insert("title", entry.title) ||
+ !keys->insert("rank", entry.rank) ||
+ !keys->insert("fn", entry.fn) ||
+ !keys->insert("nameprefix", entry.nameprefix) ||
+ !keys->insert("firstname", entry.firstname) ||
+ !keys->insert("middlename", entry.middlename) ||
+ !keys->insert("lastname", entry.lastname) ||
+ !keys->insert("birthday", entry.birthday) ||
+ !keys->insert("comment", entry.comment) ||
+ !keys->insert("talk", entry.talk) ||
+ !keys->insert("emails", entry.emails) ||
+ !keys->insert("keywords", entry.keywords) ||
+ !keys->insert("telephone", entry.telephone) ||
+ !keys->insert("URLs", entry.URLs) ||
+ !keys->insert("user1", entry.user1) ||
+ !keys->insert("user2", entry.user2) ||
+ !keys->insert("user3", entry.user3) ||
+ !keys->insert("user4", entry.user4) ||
+ !keys->insert("custom", entry.custom) ||
+ !keys->insert("categories", entry.categories))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::makeEntryFromSection: cannot insert "
+ << "all fields of the entry." << endl;
+ return InternError;
+ }
+ // -----
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::createNew(const TQString& filename)
+{
+ // ###########################################################################
+ const TQString KabTemplateFile=locate("data", "kab/template.kab");
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::createNew: template file is \""
+ << (const char*)KabTemplateFile.utf8() << "\"." << endl;
+ QConfigDB db;
+ // -----
+ if(KabTemplateFile.isEmpty()
+ || !db.setFileName(KabTemplateFile, true, true))
+ {
+ KMessageBox::error(this,
+ i18n("Cannot find kab's template file.\n"
+ "You cannot create new files."),
+ i18n("File Error"));
+ return InternError;
+ }
+ if(!db.load())
+ {
+ KMessageBox::error(this,
+ i18n("Cannot read kab's template file.\n"
+ "You cannot create new files."),
+ i18n("Format Error"));
+
+ return InternError;
+ }
+ if(!db.setFileName(filename, false, false))
+ {
+ KMessageBox::error(this,
+ i18n("Cannot create the file\n\"")
+ +filename+"\"\n"+
+ i18n("Could not create the new file."),
+ i18n("File Error"));
+ return PermDenied;
+ }
+ if(!db.save())
+ {
+ KMessageBox::error(this,
+ i18n("Cannot save the file\n\"")
+ +filename+"\"\n"+
+ i18n("Could not create the new file."),
+ i18n("File Error"));
+ return InternError;
+ }
+ // -----
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::createConfigFile()
+{
+ // ###########################################################################
+ const TQString ConfigTemplateFile=locate("data", "kab/template.config");
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::createConfigFile: config template file is \""
+ << (const char*)ConfigTemplateFile.utf8() << "\"." << endl;
+ const TQString filename= locateLocal( "data", STD_CONFIGFILENAME);
+ QConfigDB db;
+ // -----
+ if(ConfigTemplateFile.isEmpty()
+ || !db.setFileName(ConfigTemplateFile, true, true))
+ {
+ KMessageBox::error(this,
+ i18n("Cannot find kab's configuration template file.\n"
+ "kab cannot be configured."),
+ i18n("File Error"));
+
+ return InternError;
+ }
+ if(!db.load())
+ {
+ KMessageBox::error(this,
+ i18n("Cannot read kab's configuration template file.\n"
+ "kab cannot be configured."),
+ i18n("File Error"));
+ return InternError;
+ }
+ if(!db.setFileName(filename, false, false))
+ {
+ KMessageBox::error(this,
+ i18n("Cannot create the file\n\"")
+ +filename+"\"\n"+
+ i18n("Could not create the new configuration file."),
+ i18n("File Error"));
+ return PermDenied;
+ }
+ if(!db.save())
+ {
+ KMessageBox::error(this,
+ i18n("Cannot save the file\n\"")
+ +filename+"\"\n"+
+ i18n("Could not create the new configuration file."),
+ i18n("File Error"));
+ return InternError;
+ }
+ // -----
+ return NoError;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::loadConfigFile()
+{
+ // ###########################################################################
+ TQString file = locateLocal( "data", STD_CONFIGFILENAME);
+ if(config->setFileName(file, true, true))
+ {
+ if(config->load())
+ {
+ return NoError;
+ } else {
+ KMessageBox::information(this,
+ i18n("Cannot load kab's local configuration file.\n"
+ "There may be a formatting error.\n"
+ "kab cannot be configured."),
+ i18n("File Error"));
+ return InternError;
+ }
+ } else {
+ KMessageBox::information(this,
+ i18n("Cannot find kab's local configuration file.\n"
+ "kab cannot be configured."),
+ i18n("File Error"));
+ return NoSuchFile;
+ }
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::makeVCardFromEntry(const Entry&, const TQString&)
+{
+ // ###########################################################################
+ return NotImplemented;
+ // ###########################################################################
+}
+
+AddressBook::ErrorCode
+AddressBook::makeEntryFromVCard(const TQString&, Entry&)
+{
+ // ###########################################################################
+ return NotImplemented;
+ // ###########################################################################
+}
+
+TQString
+AddressBook::getStandardFileName()
+{
+ // ###########################################################################
+ return locateLocal( "data", STD_USERFILENAME);
+ // ###########################################################################
+}
+
+TQString AddressBook::phoneType(AddressBook::Telephone phone)
+{
+ switch(phone)
+ {
+ case Fixed: return i18n("fixed"); break;
+ case Mobile: return i18n("mobile"); break;
+ case Fax: return i18n("fax"); break;
+ case Modem: return i18n("modem"); break;
+ default: return i18n("general");
+ }
+}
+
+void AddressBook::externalChange()
+{
+ updateMirrorMap();
+}
+
+Section* AddressBook::configurationSection()
+{
+ Section *section;
+ if(data!=0)
+ {
+ if(data->get(LOCAL_CONFIG_SECTION, section))
+ {
+ return section;
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+}
+
+AddressBook::ErrorCode AddressBook::Entry::get(const char* fieldname, TQVariant& field)
+{
+ // "title", "rank", "fn", "nameprefix", "firstname", "middlename", "lastname",
+ // "birthday", "comment", "talk", "emails", "keywords", "telephone",
+ // "urls", "user1", "user2", "user3", "user4", "custom"
+ int dummy=0;
+ // -----
+ if(fieldname==Fields[dummy++])
+ { // the title
+ field=title;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the rank
+ field=rank;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the formatted name
+ field=fn;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the nameprefix
+ field=nameprefix;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the firstname
+ field=firstname;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the middle name
+ field=middlename;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the last name
+ field=lastname;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the birthday
+ field=TQString(birthday.toString());
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the comment
+ field=comment;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the talk addresses
+ field=talk;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the email addresses
+ field=emails;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the keywords
+ field=keywords;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the telephones
+ field=telephone;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the urls
+ field=URLs;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the user field 1
+ field=user1;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the user field 2
+ field=user2;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the user field 3
+ field=user3;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the user field 4
+ field=user4;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the custom fields (app specific)
+ field=custom;
+ return NoError;
+ }
+ // ----- we did not find that field:
+ return NoSuchField;
+}
+
+AddressBook::ErrorCode AddressBook::Entry::Address::get(const char* fieldname,
+ TQVariant& field)
+{
+ // "headline", "position",
+ // "org", "orgunit", "orgsubunit",
+ // "deliverylabel", "address", "zip", "town", "country", "state"
+ int dummy=0;
+ // -----
+ if(fieldname==Fields[dummy++])
+ { // the headline
+ field=headline;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the position
+ field=position;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the organization
+ field=org;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the organizational unit
+ field=orgUnit;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the organizational subunit
+ field=orgSubUnit;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the delivery label
+ field=deliveryLabel;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the address
+ field=address;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the zip code
+ field=zip;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the town
+ field=town;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the country
+ field=country;
+ return NoError;
+ }
+ if(fieldname==Fields[dummy++])
+ { // the state
+ field=state;
+ return NoError;
+ }
+ // ----- we did not find that field:
+ return NoSuchField;
+}
+
+Section* AddressBook::categoriesSection()
+{
+ const TQString Predefines[]= {
+ i18n("Business"),
+ i18n("Private"),
+ i18n("Dates") };
+ size_t Size=sizeof(Predefines)/sizeof(Predefines[0]);
+ Section* section;
+ Section* categories;
+ KeyValueMap *keys;
+ // -----
+ if(data->get(KAB_CATEGORY_KEY, section))
+ {
+ // it exists, go ahead
+ return section;
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::categoriesSection: creating categories structure." << endl;
+ // it does not exist - create it
+ if(!data->createSection(KAB_CATEGORY_KEY))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::categoriesSection: error creating categories section."
+ << endl;
+ return 0;
+ }
+ data->get(KAB_CATEGORY_KEY, section);
+ // add the predefined categories:
+ categories=new Section;
+ keys=categories->getKeys();
+ for(size_t count=0; count<Size; ++count)
+ {
+ TQStringList values;
+ values.append(Predefines[count]);
+ keys->insert(TQCString().setNum(count), values);
+ }
+ section->add(KAB_CATEGORY_KEY, categories);
+ keys=section->getKeys();
+ keys->insert("NextAvailableCatKey", (long)Size);
+ }
+ save();
+ if(data->get(KAB_CATEGORY_KEY, section))
+ return section;
+ return 0; // might not happen
+}
+
+AddressBook::ErrorCode AddressBook::categories(CategoriesMap& cat)
+{ // WORK_TO_DO: use a permanent cached map and update on changed()
+ kdDebug(KAB_KDEBUG_AREA, !cat.isEmpty())
+ << "AddressBook::categories: warning - categories map is supposed to be empty!"
+ << endl;
+ Section *section;
+ Section *categories;
+ KeyValueMap* keys;
+ int key;
+ bool rc;
+ TQStringList values;
+ StringStringMap::iterator pos;
+ // ----- query categories section:
+ section=categoriesSection();
+ TQ_CHECK_PTR(section);
+ // -----
+ if(!section->find(KAB_CATEGORY_KEY, categories))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::categories: error in database structure."
+ << endl;
+ return InternError;
+ }
+ // ----- everything is set up, create the categories map:
+ // use an iterator to walk over all elements of categories key-value-map:
+ keys=categories->getKeys();
+ for(pos=keys->begin(); pos!=keys->end(); ++pos)
+ {
+ if(!keys->get((*pos).first, values))
+ {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::categories: internal error querying categories."
+ << endl;
+ } else {
+ key=(*pos).first.toInt(&rc);
+ if(rc)
+ {
+ cat.insert(key, values[0]);
+ } else {
+ kdDebug(KAB_KDEBUG_AREA)
+ << "AddressBook::categories: error - non-integer category key - ignored."
+ << endl;
+ }
+ }
+ }
+ return NoError;
+}
+
+#include "addressbook.moc"
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-15 08:52:53 +0000