From 48540940b6c28bb4378abfeb500ec45a625b37b6 Mon Sep 17 00:00:00 2001 From: Vadim Dashevskiy Date: Tue, 15 May 2012 10:38:20 +0000 Subject: initial commit git-svn-id: http://svn.miranda-ng.org/main/trunk@2 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- .../UserInfoEx/ex_import/classExImContactBase.cpp | 581 ++++++ .../UserInfoEx/ex_import/classExImContactBase.h | 103 + .../UserInfoEx/ex_import/classExImContactXML.cpp | 1141 +++++++++++ plugins/UserInfoEx/ex_import/classExImContactXML.h | 103 + plugins/UserInfoEx/ex_import/dlg_ExImModules.cpp | 464 +++++ plugins/UserInfoEx/ex_import/dlg_ExImModules.h | 39 + .../UserInfoEx/ex_import/dlg_ExImOpenSaveFile.cpp | 373 ++++ .../UserInfoEx/ex_import/dlg_ExImOpenSaveFile.h | 39 + plugins/UserInfoEx/ex_import/dlg_ExImProgress.cpp | 244 +++ plugins/UserInfoEx/ex_import/dlg_ExImProgress.h | 56 + plugins/UserInfoEx/ex_import/mir_rfcCodecs.h | 371 ++++ plugins/UserInfoEx/ex_import/svc_ExImINI.cpp | 547 ++++++ plugins/UserInfoEx/ex_import/svc_ExImINI.h | 39 + plugins/UserInfoEx/ex_import/svc_ExImVCF.cpp | 1364 ++++++++++++++ plugins/UserInfoEx/ex_import/svc_ExImVCF.h | 103 + plugins/UserInfoEx/ex_import/svc_ExImXML.cpp | 453 +++++ plugins/UserInfoEx/ex_import/svc_ExImXML.h | 75 + plugins/UserInfoEx/ex_import/svc_ExImport.cpp | 382 ++++ plugins/UserInfoEx/ex_import/svc_ExImport.h | 62 + plugins/UserInfoEx/ex_import/tinystr.cpp | 143 ++ plugins/UserInfoEx/ex_import/tinystr.h | 335 ++++ plugins/UserInfoEx/ex_import/tinyxml.cpp | 1978 ++++++++++++++++++++ plugins/UserInfoEx/ex_import/tinyxml.h | 1597 ++++++++++++++++ plugins/UserInfoEx/ex_import/tinyxmlerror.cpp | 76 + plugins/UserInfoEx/ex_import/tinyxmlparser.cpp | 1613 ++++++++++++++++ 25 files changed, 12281 insertions(+) create mode 100644 plugins/UserInfoEx/ex_import/classExImContactBase.cpp create mode 100644 plugins/UserInfoEx/ex_import/classExImContactBase.h create mode 100644 plugins/UserInfoEx/ex_import/classExImContactXML.cpp create mode 100644 plugins/UserInfoEx/ex_import/classExImContactXML.h create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImModules.cpp create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImModules.h create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.cpp create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.h create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImProgress.cpp create mode 100644 plugins/UserInfoEx/ex_import/dlg_ExImProgress.h create mode 100644 plugins/UserInfoEx/ex_import/mir_rfcCodecs.h create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImINI.cpp create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImINI.h create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImVCF.cpp create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImVCF.h create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImXML.cpp create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImXML.h create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImport.cpp create mode 100644 plugins/UserInfoEx/ex_import/svc_ExImport.h create mode 100644 plugins/UserInfoEx/ex_import/tinystr.cpp create mode 100644 plugins/UserInfoEx/ex_import/tinystr.h create mode 100644 plugins/UserInfoEx/ex_import/tinyxml.cpp create mode 100644 plugins/UserInfoEx/ex_import/tinyxml.h create mode 100644 plugins/UserInfoEx/ex_import/tinyxmlerror.cpp create mode 100644 plugins/UserInfoEx/ex_import/tinyxmlparser.cpp (limited to 'plugins/UserInfoEx/ex_import') diff --git a/plugins/UserInfoEx/ex_import/classExImContactBase.cpp b/plugins/UserInfoEx/ex_import/classExImContactBase.cpp new file mode 100644 index 0000000000..c0e0bc05ee --- /dev/null +++ b/plugins/UserInfoEx/ex_import/classExImContactBase.cpp @@ -0,0 +1,581 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/classExImContactBase.cpp $ +Revision : $Revision: 210 $ +Last change on : $Date: 2010-10-02 22:27:36 +0400 (ะกะฑ, 02 ะพะบั‚ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ +#include "commonheaders.h" +#include "..\svc_contactinfo.h" +#include "classExImContactBase.h" +#include "mir_rfcCodecs.h" + +HANDLE CListFindGroup(LPCSTR pszGroup) +{ + CHAR buf[4]; + BYTE i; + DBVARIANT dbv; + + for (i = 0; i < 255; i++) { + _itoa(i, buf, 10); + if (DB::Setting::GetUString(NULL, "CListGroups", buf, &dbv)) + break; + if (dbv.pszVal && pszGroup && !_stricmp(dbv.pszVal + 1, pszGroup)) { + DB::Variant::Free(&dbv); + return (HANDLE)(INT_PTR)(i+1); + } + DB::Variant::Free(&dbv); + } + return INVALID_HANDLE_VALUE; +} + +/** + * name: CExImContactBase + * class: CExImContactBase + * desc: default constructor + * param: none + * return: nothing + **/ +CExImContactBase::CExImContactBase() +{ + _pszNick = NULL; + _pszDisp = NULL; + _pszGroup = NULL; + _pszProto = NULL; + _pszProtoOld = NULL; + _pszAMPro = NULL; + _pszUIDKey = NULL; + _dbvUIDHash = NULL; + ZeroMemory(&_dbvUID, sizeof(DBVARIANT)); + _hContact = INVALID_HANDLE_VALUE; + _isNewContact = FALSE; +} + +/** + * name: ~CExImContactBase + * class: CExImContactBase + * desc: default denstructor + * param: none + * return: nothing + **/ +CExImContactBase::~CExImContactBase() +{ + MIR_FREE(_pszNick); + MIR_FREE(_pszDisp); + MIR_FREE(_pszGroup); + MIR_FREE(_pszProtoOld); + MIR_FREE(_pszProto); + MIR_FREE(_pszAMPro); + MIR_FREE(_pszUIDKey); + DB::Variant::Free(&_dbvUID); +} + +/** + * name: fromDB + * class: CExImContactBase + * desc: get contact information from database + * param: hContact - handle to contact whose information to read + * return: TRUE if successful or FALSE otherwise + **/ +BOOLEAN CExImContactBase::fromDB(HANDLE hContact) +{ + BOOLEAN ret = FALSE; + BOOLEAN isChatRoom = FALSE; + LPSTR pszProto; + LPCSTR uidSetting; + DBVARIANT dbv; + + _hContact = hContact; + _dbvUIDHash = 0; + MIR_FREE(_pszProtoOld); + MIR_FREE(_pszProto); + MIR_FREE(_pszAMPro); + MIR_FREE(_pszNick); + MIR_FREE(_pszDisp); + MIR_FREE(_pszGroup); + MIR_FREE(_pszUIDKey); + DB::Variant::Free(&_dbvUID); + ZeroMemory(&_dbvUID, sizeof(DBVARIANT)); + + // OWNER + if (!_hContact) return TRUE; + + // Proto + if (!(pszProto = DB::Contact::Proto(_hContact))) return FALSE; + _pszProto = mir_strdup(pszProto); + + // AM_BaseProto + if (!DB::Setting::GetUString(NULL, pszProto, "AM_BaseProto", &dbv )) { + _pszAMPro = mir_strdup(dbv.pszVal); + DB::Variant::Free(&dbv); + } + + // unique id (for ChatRoom) + if (isChatRoom = DB::Setting::GetByte(_hContact, pszProto, "ChatRoom", 0)) { + uidSetting = "ChatRoomID"; + _pszUIDKey = mir_strdup(uidSetting); + if (!DB::Setting::GetAsIs(_hContact, pszProto, uidSetting, &_dbvUID)) { + ret = TRUE; + } + } + // unique id (normal) + else { + uidSetting = (LPCSTR)CallProtoService(pszProto, PS_GETCAPS, PFLAG_UNIQUEIDSETTING, 0); + // valid + if (uidSetting != NULL && (INT_PTR)uidSetting != CALLSERVICE_NOTFOUND) { + _pszUIDKey = mir_strdup(uidSetting); + if (!DB::Setting::GetAsIs(_hContact, pszProto, uidSetting, &_dbvUID)) { + ret = TRUE; + } + } + // fails because the protocol is no longer installed + else { + // assert(ret == TRUE); + ret = TRUE; + } + } + + // nickname + if (!DB::Setting::GetUString(_hContact, pszProto, SET_CONTACT_NICK, &dbv)) { + _pszNick = mir_strdup(dbv.pszVal); + DB::Variant::Free(&dbv); + } + + if (_hContact && ret) { + // Clist Group + if (!DB::Setting::GetUString(_hContact, MOD_CLIST, "Group", &dbv)) { + _pszGroup = mir_strdup(dbv.pszVal); + DB::Variant::Free(&dbv); + } + // Clist DisplayName + if (!DB::Setting::GetUString(_hContact, MOD_CLIST, SET_CONTACT_MYHANDLE, &dbv)) { + _pszDisp = mir_strdup(dbv.pszVal); + DB::Variant::Free(&dbv); + } + } + return ret; +} + +/** + * name: fromIni + * class: CExImContactBase + * desc: get contact information from a row of a ini file + * param: row - the rows data + * return: TRUE if successful or FALSE otherwise + **/ +BOOLEAN CExImContactBase::fromIni(LPSTR& row) +{ + LPSTR p1, p2 = NULL; + LPSTR pszUIDValue, pszUIDSetting, pszProto = NULL; + LPSTR pszBuf = &row[0]; + size_t cchBuf = strlen(row); + + MIR_FREE(_pszProtoOld); + MIR_FREE(_pszProto); + MIR_FREE(_pszAMPro); + MIR_FREE(_pszNick); + MIR_FREE(_pszDisp); + MIR_FREE(_pszGroup); + MIR_FREE(_pszUIDKey); + DB::Variant::Free(&_dbvUID); + ZeroMemory(&_dbvUID, sizeof(DBVARIANT)); + _dbvUIDHash = 0; + + // read uid value + if (cchBuf > 10 && (p1 = mir_strrchr(pszBuf, '*{')) && (p2 = mir_strchr(p1, '}*')) && p1 + 2 < p2) { + pszUIDValue = p1 + 1; + *p1 = *(p2 - 1) = 0; + + // insulate the uid setting from buffer pointer + if (cchBuf > 0 && (p1 = mir_strrchr(pszBuf, '*<')) && (p2 = mir_strchr(p1, '>*')) && p1 + 2 < p2) { + pszUIDSetting = p1 + 1; + *p1 = *(p2 - 1) = 0; + + // insulate the protocol name from buffer pointer + if (cchBuf > 0 && (p1 = mir_strrchr(pszBuf, '*(')) && (p2 = mir_strchr(p1, ')*')) && p1 + 2 < p2) { + pszProto = p1 + 1; + *(--p1) = *(p2 - 1) = 0; + + // DBVT_DWORD + if (strspn(pszUIDValue, "0123456789") == mir_strlen(pszUIDValue)) { + _dbvUID.dVal = _atoi64(pszUIDValue); + _dbvUID.type = DBVT_DWORD; + } + else { + // DBVT_UTF8 + _dbvUID.pszVal = mir_strdup(pszUIDValue); + _dbvUID.type = DBVT_UTF8; + } + _pszUIDKey = mir_strdup(pszUIDSetting); + _pszProto = mir_strdup(pszProto); + } //end insulate the protocol name from buffer pointer + } //end insulate the uid setting from buffer pointer + } //end read uid value + + // create valid nickname + _pszNick = mir_strdup(pszBuf); + size_t i = strlen(_pszNick)-1; + while (i > 0 && (_pszNick[i] == ' ' || _pszNick[i] == '\t')) { + _pszNick[i] = 0; + i--; + } + // finally try to find contact in contact list + findHandle(); + return FALSE; +} + +/** + * name: toDB + * class: CExImContactBase + * desc: searches the database for a contact representing the one + * identified by this class or creates a new one if it was not found + * param: hMetaContact - a meta contact to add this contact to + * return: handle of the contact if successful + **/ +HANDLE CExImContactBase::toDB() +{ + DBCONTACTWRITESETTING cws; + + // create new contact if none exists + if (_hContact == INVALID_HANDLE_VALUE && _pszProto && _pszUIDKey && _dbvUID.type != DBVT_DELETED) { + PROTOACCOUNT* pszAccount = 0; + if(NULL == (pszAccount = ProtoGetAccount( _pszProto ))) { + //account does not exist + _hContact = INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; + } + if(!IsAccountEnabled(pszAccount)) { + ; + } + // create new contact + _hContact = DB::Contact::Add(); + if (!_hContact) { + _hContact = INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; + } + // Add the protocol to the new contact + if (CallService(MS_PROTO_ADDTOCONTACT, (WPARAM)_hContact, (LPARAM)_pszProto)) { + DB::Contact::Delete(_hContact); + _hContact = INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; + } + // write uid to protocol module + cws.szModule = _pszProto; + cws.szSetting = _pszUIDKey; + cws.value = _dbvUID; + if (CallService(MS_DB_CONTACT_WRITESETTING, (WPARAM)_hContact, (LPARAM)&cws)) { + DB::Contact::Delete(_hContact); + _hContact = INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; + } + // write nick and display name + if (_pszNick) DB::Setting::WriteUString(_hContact, _pszProto, SET_CONTACT_NICK, _pszNick); + if (_pszDisp) DB::Setting::WriteUString(_hContact, MOD_CLIST, SET_CONTACT_MYHANDLE, _pszDisp); + + // add group + if (_pszGroup) { + DB::Setting::WriteUString(_hContact, MOD_CLIST, "Group", _pszGroup); + if (CListFindGroup(_pszGroup) == INVALID_HANDLE_VALUE) { + WPARAM hGroup = (WPARAM)CallService(MS_CLIST_GROUPCREATE, 0, 0); + if (hGroup) { + // renaming twice is stupid but the only way to avoid error dialog telling shit like + // a group with that name does exist + CallService(MS_CLIST_GROUPRENAME, (WPARAM)hGroup, (LPARAM)_pszGroup); + } + } + } + } + return _hContact; +} + +/** + * name: toIni + * class: CExImContactBase + * desc: writes the line to an opened ini file which identifies the contact + * whose information are stored in this class + * param: file - pointer to the opened file + * return: nothing + **/ +VOID CExImContactBase::toIni(FILE* file, int modCount) +{ + // getting dbeditor++ NickFromHContact(hContact) + static char name[512] = ""; + char* ret = 0; + + if (_hContact){ + int loaded = _pszUIDKey ? 1 : 0; + if (_pszProto == NULL || !loaded) { + if (_pszProto){ + if (_pszNick) + mir_snprintf(name, sizeof(name),"%s (%s)", _pszNick, _pszProto); + else + mir_snprintf(name, sizeof(name),"(UNKNOWN) (%s)", _pszProto); + } + else + mir_snprintf(name, sizeof(name),"(UNKNOWN)"); + } + else { + // Proto loadet - GetContactName(hContact,pszProto,0) + LPSTR pszCI = NULL; + CONTACTINFO ci; + ZeroMemory(&ci, sizeof(ci)); + + ci.cbSize = sizeof(ci); + ci.hContact = _hContact; + ci.szProto = _pszProto; + ci.dwFlag = CNF_DISPLAY; + + if (!GetContactInfo(NULL, (LPARAM) &ci)){ + // CNF_DISPLAY always returns a string type + pszCI = (LPSTR)ci.pszVal; + } + LPSTR pszUID = uid2String(FALSE); + if (_pszUIDKey && pszUID) + mir_snprintf(name, sizeof(name), "%s *(%s)*<%s>*{%s}*", pszCI, _pszProto, _pszUIDKey, pszUID); + else + mir_snprintf(name, sizeof(name), "%s (%s)", pszCI, _pszProto); + + mir_free(pszCI); + mir_free(pszUID); + } // end else (Proto loadet) + + // it is not the best solution (but still works if only basic modules export) - need rework + if (modCount > 3) + fprintf(file, "CONTACT: %s\n", name); + else + fprintf(file, "FROM CONTACT: %s\n", name); + + } // end *if (_hContact) + else { + fprintf(file, "SETTINGS:\n"); + } +} + +BOOLEAN CExImContactBase::compareUID(DBVARIANT *dbv) +{ + DWORD hash = 0; + switch (dbv->type) { + case DBVT_BYTE: + if (dbv->bVal == _dbvUID.bVal) { + _dbvUID.type = dbv->type; + return TRUE; + } + break; + case DBVT_WORD: + if (dbv->wVal == _dbvUID.wVal) { + _dbvUID.type = dbv->type; + return TRUE; + } + break; + case DBVT_DWORD: + if (dbv->dVal == _dbvUID.dVal) { + _dbvUID.type = dbv->type; + return TRUE; + } + break; + case DBVT_ASCIIZ: + hash = hashSetting_M2(dbv->pszVal); + case DBVT_WCHAR: + if(!hash) hash = hashSettingW_M2((const char *)dbv->pwszVal); + case DBVT_UTF8: + if(!hash) { + LPWSTR tmp = mir_utf8decodeW(dbv->pszVal); + hash = hashSettingW_M2((const char *)tmp); + mir_free(tmp); + } + if(hash == _dbvUIDHash) return TRUE; + break; + case DBVT_BLOB: //'n' cpbVal and pbVal are valid + if (_dbvUID.type == dbv->type && + _dbvUID.cpbVal == dbv->cpbVal && + memcmp(_dbvUID.pbVal, dbv->pbVal, dbv->cpbVal) == 0) { + return TRUE; + } + break; + default: + return FALSE; + } + return FALSE; +} + +LPSTR CExImContactBase::uid2String(BOOLEAN bPrependType) +{ + CHAR szUID[MAX_PATH]; + LPSTR ptr = szUID; + + switch (_dbvUID.type) { + case DBVT_BYTE: //'b' bVal and cVal are valid + if (bPrependType) *ptr++ = 'b'; + _itoa(_dbvUID.bVal, ptr, 10); + break; + case DBVT_WORD: //'w' wVal and sVal are valid + if (bPrependType) *ptr++ = 'w'; + _itoa(_dbvUID.wVal, ptr, 10); + break; + case DBVT_DWORD: //'d' dVal and lVal are valid + if (bPrependType) *ptr++ = 'd'; + _itoa(_dbvUID.dVal, ptr, 10); + break; + case DBVT_WCHAR: //'u' pwszVal is valid + { + LPSTR r = mir_utf8encodeW(_dbvUID.pwszVal); + if (bPrependType) { + LPSTR t = (LPSTR)mir_alloc(strlen(r)+2); + t[0] = 'u'; + strcpy(t+1, r); + mir_free(r); + r = t; + } + return r; + } + case DBVT_UTF8: //'u' pszVal is valid + { + if (bPrependType) *ptr++ = 'u'; + mir_strncpy(ptr, _dbvUID.pszVal, SIZEOF(szUID)-1); + } + break; + case DBVT_ASCIIZ: { + LPSTR r = mir_utf8encode(_dbvUID.pszVal); + if (bPrependType) { + LPSTR t = (LPSTR)mir_alloc(strlen(r)+2); + t[0] = 's'; + strcpy(t+1, r); + mir_free(r); + r = t; + } + return r; + } + case DBVT_BLOB: //'n' cpbVal and pbVal are valid + { + if (bPrependType) { //True = XML + INT_PTR baselen = Base64EncodeGetRequiredLength(_dbvUID.cpbVal, BASE64_FLAG_NOCRLF); + LPSTR t = (LPSTR)mir_alloc(baselen + 5 + bPrependType); + assert(t != NULL); + if (Base64Encode(_dbvUID.pbVal, _dbvUID.cpbVal, t + bPrependType, &baselen, BASE64_FLAG_NOCRLF)){ + if (baselen){ + t[baselen + bPrependType] = 0; + if (bPrependType) t[0] = 'n'; + return t; + } + } + mir_free(t); + return NULL; + } + else { //FALSE = INI + WORD j; + INT_PTR baselen = (_dbvUID.cpbVal * 3); + LPSTR t = (LPSTR)mir_alloc(3 + baselen); + ZeroMemory(t, (3 + baselen)); + for (j = 0; j < _dbvUID.cpbVal; j++) { + mir_snprintf((t + bPrependType + (j * 3)), 4,"%02X ", (BYTE)_dbvUID.pbVal[j]); + } + if (t){ + if (bPrependType) t[0] = 'n'; + return t; + } + else { + mir_free(t); + return NULL; + } + } + break; + } + default: + return NULL; + } + return mir_strdup(szUID); +} + +BOOLEAN CExImContactBase::isMeta() const +{ + return DB::Module::IsMeta(_pszProto); +} + +BOOLEAN CExImContactBase::isHandle(HANDLE hContact) +{ + LPCSTR pszProto; + DBVARIANT dbv; + BOOLEAN isEqual = FALSE; + + // owner contact ? + if (!_pszProto) return hContact == NULL; + + // compare protocols + pszProto = DB::Contact::Proto(hContact); + if (pszProto == NULL || (INT_PTR)pszProto == CALLSERVICE_NOTFOUND || mir_stricmp(pszProto, _pszProto)) + return FALSE; + + // compare uids + if (_pszUIDKey) { + // get uid + if (DB::Setting::GetAsIs(hContact, pszProto,_pszUIDKey, &dbv)) + return FALSE; + + isEqual = compareUID (&dbv); + DB::Variant::Free(&dbv); + } + // compare nicknames if no UID + else if (!DB::Setting::GetUString(hContact, _pszProto, SET_CONTACT_NICK, &dbv)) { + if (dbv.type == DBVT_UTF8 && dbv.pszVal && !mir_stricmp(dbv.pszVal,_pszNick)) { + LPTSTR ptszNick = mir_utf8decodeT(_pszNick); + LPTSTR ptszProto = mir_a2t(_pszProto); + INT ans = MsgBox(NULL, MB_ICONQUESTION|MB_YESNO, LPGENT("Question"), LPGENT("contact identificaion"), + LPGENT("The contact %s(%s) has no unique id in the vCard,\nbut there is a contact in your clist with the same nick and protocol.\nDo you wish to use this contact?"), + ptszNick, ptszProto); + MIR_FREE(ptszNick); + MIR_FREE(ptszProto); + isEqual = ans == IDYES; + } + DB::Variant::Free(&dbv); + } + return isEqual; +} + +/** + * name: handle + * class: CExImContactBase + * desc: return the handle of the contact + * whose information are stored in this class + * param: none + * return: handle if successful, INVALID_HANDLE_VALUE otherwise + **/ +HANDLE CExImContactBase::findHandle() +{ + HANDLE hContact; + + for (hContact = DB::Contact::FindFirst(); + hContact != NULL; + hContact = DB::Contact::FindNext(hContact)) + { + if (isHandle(hContact)) { + _hContact = hContact; + _isNewContact = FALSE; + return hContact; + } + } + _isNewContact = TRUE; + _hContact = INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; +} diff --git a/plugins/UserInfoEx/ex_import/classExImContactBase.h b/plugins/UserInfoEx/ex_import/classExImContactBase.h new file mode 100644 index 0000000000..55e5d94f67 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/classExImContactBase.h @@ -0,0 +1,103 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/classExImContactBase.h $ +Revision : $Revision: 196 $ +Last change on : $Date: 2010-09-21 03:24:30 +0400 (ะ’ั‚, 21 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ +#pragma once + +#include "tinyxml.h" +#include "..\svc_gender.h" + +HANDLE CListFindGroup(LPCSTR pszGroup); + +class CExImContactBase { + BOOLEAN compareUID(DBVARIANT *dbv); + +protected: + LPSTR _pszNick; // utf8 encoded + LPSTR _pszDisp; // utf8 encoded + LPSTR _pszGroup; // utf8 encoded + LPSTR _pszAMPro; + LPSTR _pszProto; + LPSTR _pszProtoOld; + LPSTR _pszUIDKey; + DWORD _dbvUIDHash; + DBVARIANT _dbvUID; + HANDLE _hContact; + BOOLEAN _isNewContact; // is this contact a new one? + + HANDLE findHandle(); + +public: + CExImContactBase(); + ~CExImContactBase(); + +// __inline LPCSTR disp() const { return mir_strcmp(_pszDisp,"")? _pszDisp : NULL; } +// __inline LPCSTR group() const { return mir_strcmp(_pszGroup,"")? _pszGroup : NULL; } +// __inline LPCSTR nick() const { return mir_strcmp(_pszNick,"")? _pszNick : NULL; } +// __inline LPCSTR proto() const { return mir_strcmp(_pszProto,"")? _pszProto : NULL; } +// __inline LPCSTR ampro() const { return mir_strcmp(_pszAMPro,"")? _pszAMPro : NULL; } +// __inline LPCSTR uidk() const { return mir_strcmp(_pszUIDKey,"")? _pszUIDKey : NULL; } + __inline DBVARIANT& uid() { return _dbvUID; } + __inline HANDLE handle() const { return _hContact; } + + __inline VOID disp(LPCSTR val) { _pszDisp = val ? mir_strdup(val): NULL; } + __inline VOID group(LPCSTR val) { _pszGroup = val ? mir_strdup(val): NULL; } + __inline VOID nick(LPCSTR val) { _pszNick = val ? mir_strdup(val): NULL; } + __inline VOID proto(LPCSTR val) { _pszProto = val ? mir_strdup(val): NULL; } + __inline VOID ampro(LPCSTR val) { _pszAMPro = val ? mir_strdup(val): NULL; } + __inline VOID uidk(LPCSTR val) { _pszUIDKey = val ? mir_strdup(val): NULL; } + __inline VOID uid(BYTE val) { _dbvUID.type = DBVT_BYTE; _dbvUID.bVal = val; } + __inline VOID uid(WORD val) { _dbvUID.type = DBVT_WORD; _dbvUID.wVal = val; } + __inline VOID uid(DWORD val) { _dbvUID.type = DBVT_DWORD; _dbvUID.dVal = val; } + __inline VOID uidn(PBYTE val, DWORD len) { _dbvUID.type = DBVT_BLOB; _dbvUID.pbVal= val; _dbvUID.cpbVal = (WORD)len; } + __inline VOID uida(LPCSTR val) + { + _dbvUID.type = (_dbvUID.pszVal = mir_utf8decodeA(val))? DBVT_ASCIIZ : DBVT_DELETED; + _dbvUIDHash = hashSetting_M2(_dbvUID.pszVal); + } + __inline VOID uidu(LPCSTR val) + { + _dbvUID.type = (_dbvUID.pszVal = mir_strdup(val))? DBVT_UTF8 : DBVT_DELETED; + LPWSTR temp = mir_utf8decodeW(val); + _dbvUIDHash = hashSettingW_M2((const char *)temp); + mir_free(temp); + } + + BOOLEAN isHandle(HANDLE hContact); + BOOLEAN isMeta() const; + + LPSTR uid2String(BOOLEAN bPrependType); + + BOOLEAN fromDB(HANDLE hContact); + BOOLEAN fromIni(LPSTR& row); + + HANDLE toDB(); + VOID toIni(FILE* file, int modCount); + + BOOLEAN operator = (HANDLE hContact) { return fromDB(hContact); } +}; diff --git a/plugins/UserInfoEx/ex_import/classExImContactXML.cpp b/plugins/UserInfoEx/ex_import/classExImContactXML.cpp new file mode 100644 index 0000000000..ecd7bd73c9 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/classExImContactXML.cpp @@ -0,0 +1,1141 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/classExImContactXML.cpp $ +Revision : $Revision: 210 $ +Last change on : $Date: 2010-10-02 22:27:36 +0400 (ะกะฑ, 02 ะพะบั‚ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ +#include "commonheaders.h" +#include "classExImContactXML.h" +#include "svc_ExImXML.h" +#include "mir_rfcCodecs.h" + +/*********************************************************************************************************** + * common stuff + ***********************************************************************************************************/ + +/** + * name: SortProc + * desc: used for bsearch in CExImContactXML::IsContactInfo + * param: item1 - item to compare + * item2 - item to compare + * return: the difference + **/ +static INT SortProc(const LPDWORD item1, const LPDWORD item2) +{ + return *item1 - *item2; +} + +/** + * name: CExImContactXML + * class: CExImContactXML + * desc: the constructor for the contact class + * param: pXmlFile - the owning xml file + * return: nothing + **/ +CExImContactXML::CExImContactXML(CFileXml * pXmlFile) + : CExImContactBase() +{ + _xmlNode = NULL; + _pXmlFile = pXmlFile; + _hEvent = NULL; +} + +/** + * name: IsContactInfo + * class: CExImContactXML + * desc: this function compares the given setting key to the list of known contact + * information keys + * param: pszKey - the settings key to check + * return: TRUE if pszKey is a valid contact information + **/ +BOOLEAN CExImContactXML::IsContactInfo(LPCSTR pszKey) +{ + // This is a sorted list of all hashvalues of the contact information. + // This is the same as the szCiKey[] array below but sorted + const DWORD dwCiHash[] = { + 0x6576F145,0x65780A70,0x6719120C,0x6776F145,0x67780A70,0x6EDB33D7,0x6F0466B5, + 0x739B6915,0x73B11E48,0x760D8AD5,0x786A70D0,0x8813C350,0x88641AF8,0x8ED5652D, + 0x96D64541,0x97768A14,0x9B786F9C,0x9B7889F9,0x9C26E6ED,0xA6675748,0xA813C350, + 0xA8641AF8,0xAC408FCC,0xAC40AFCC,0xAC40CFCC,0xAEC6EA4C,0xB813C350,0xB8641AF8, + 0xC5227954,0xCC68DE0E,0xCCD62E70,0xCCFBAAF4,0xCD715E13,0xD36182CF,0xD361C2CF, + 0xD361E2CF,0xD42638DE,0xD4263956,0xD426395E,0xD453466E,0xD778D233,0xDB59D87A, + 0xE406F60E,0xE406FA0E,0xE406FA4E,0xECF7E910,0xEF660441,0x00331041,0x0039AB3A, + 0x003D88A6,0x07ABA803,0x113D8227,0x113DC227,0x113DE227,0x2288784F,0x238643D6, + 0x2671C03E,0x275F720B,0x2EBDC0D6,0x3075C8C5,0x32674C9F,0x33EEAE73,0x40239C1C, + 0x44DB75D0,0x44FA69D0,0x4C76989B,0x4FF38979,0x544B2F44,0x55AFAF8C,0x567A6BC5, + 0x5A96C47F,0x6376F145,0x63780A70 + }; + if (pszKey && *pszKey) { + char buf[MAXSETTING]; + // convert to hash and make bsearch as it is much faster then working with strings + const DWORD dwHash = hashSetting(_strlwr(mir_strncpy(buf, pszKey, SIZEOF(buf)))); + return bsearch(&dwHash, dwCiHash, SIZEOF(dwCiHash), sizeof(dwCiHash[0]), (INT (*)(const VOID*, const VOID*))SortProc) != NULL; + } + return FALSE; +/* + WORD i; + const LPCSTR szCiKey[] = { + // naming + SET_CONTACT_TITLE,SET_CONTACT_FIRSTNAME,SET_CONTACT_SECONDNAME,SET_CONTACT_LASTNAME,SET_CONTACT_PREFIX, + // private address + SET_CONTACT_STREET,SET_CONTACT_ZIP,SET_CONTACT_CITY,SET_CONTACT_STATE,SET_CONTACT_COUNTRY, + SET_CONTACT_PHONE,SET_CONTACT_FAX,SET_CONTACT_CELLULAR, + SET_CONTACT_EMAIL,SET_CONTACT_EMAIL0,SET_CONTACT_EMAIL1,SET_CONTACT_HOMEPAGE, + // origin + SET_CONTACT_ORIGIN_STREET,SET_CONTACT_ORIGIN_ZIP,SET_CONTACT_ORIGIN_CITY,SET_CONTACT_ORIGIN_STATE,SET_CONTACT_ORIGIN_COUNTRY, + // company + SET_CONTACT_COMPANY_POSITION,SET_CONTACT_COMPANY_OCCUPATION,SET_CONTACT_COMPANY_SUPERIOR,SET_CONTACT_COMPANY_ASSISTENT + SET_CONTACT_COMPANY,SET_CONTACT_COMPANY_DEPARTMENT,SET_CONTACT_COMPANY_OFFICE, + SET_CONTACT_COMPANY_STREET,SET_CONTACT_COMPANY_ZIP,SET_CONTACT_COMPANY_CITY,SET_CONTACT_COMPANY_STATE,SET_CONTACT_COMPANY_COUNTRY, + SET_CONTACT_COMPANY_PHONE,SET_CONTACT_COMPANY_FAX,SET_CONTACT_COMPANY_CELLULAR, + SET_CONTACT_COMPANY_EMAIL,SET_CONTACT_COMPANY_EMAIL0,SET_CONTACT_COMPANY_EMAIL1,SET_CONTACT_COMPANY_HOMEPAGE, + // personal information + SET_CONTACT_ABOUT,SET_CONTACT_MYNOTES,SET_CONTACT_MARITAL,SET_CONTACT_PARTNER, + SET_CONTACT_LANG1,SET_CONTACT_LANG2,SET_CONTACT_LANG3,SET_CONTACT_TIMEZONE,SET_CONTACT_TIMEZONENAME,SET_CONTACT_TIMEZONEINDEX, + SET_CONTACT_AGE,SET_CONTACT_GENDER,SET_CONTACT_BIRTHDAY,SET_CONTACT_BIRTHMONTH,SET_CONTACT_BIRTHYEAR, + "Past0", "Past0Text","Past1", "Past1Text","Past2", "Past2Text", + "Affiliation0", "Affiliation0Text","Affiliation1", "Affiliation1Text","Affiliation2", "Affiliation2Text", + "Interest0Cat", "Interest0Text","Interest1Cat", "Interest1Text","Interest2Cat", "Interest2Text" + }; + DWORD *hash = new DWORD[SIZEOF(szCiKey)]; + char buf[MAX_PATH]; + + for (i = 0; i < SIZEOF(szCiKey); i++) { + strcpy(buf, szCiKey[i]); + hash[i] = hashSetting(_strlwr((char*)buf)); + } + qsort(hash, SIZEOF(szCiKey), sizeof(hash[0]), + (INT (*)(const VOID*, const VOID*))SortProc); + + FILE* fil = fopen("D:\\temp\\id.txt", "wt"); + for (i = 0; i < SIZEOF(szCiKey); i++) { + fprintf(fil, "0x%08X,", hash[i]); + } + fclose(fil); + return FALSE; + */ +} + +/*********************************************************************************************************** + * exporting stuff + ***********************************************************************************************************/ + +/** + * name: CreateXmlNode + * class: CExImContactXML + * desc: creates a new TiXmlElement representing the contact + * whose information are stored in this class + * param: none + * return: pointer to the newly created TiXmlElement + **/ +TiXmlElement* CExImContactXML::CreateXmlElement() +{ + if (_hContact) { + if (_pszProto) { + _xmlNode = new TiXmlElement(XKEY_CONTACT); + + if (_xmlNode) { + LPSTR pszUID = uid2String(TRUE); + _xmlNode->SetAttribute("ampro", _pszAMPro); + _xmlNode->SetAttribute("proto", _pszProto); + + if (_pszDisp) _xmlNode->SetAttribute("disp", _pszDisp); + if (_pszNick) _xmlNode->SetAttribute("nick", _pszNick); + if (_pszGroup) _xmlNode->SetAttribute("group",_pszGroup); + + if (pszUID) { + + if (_pszUIDKey) { + _xmlNode->SetAttribute("uidk", _pszUIDKey); + _xmlNode->SetAttribute("uidv", pszUID); + } + else { + _xmlNode->SetAttribute("uidk", "#NV"); + _xmlNode->SetAttribute("uidv", "UNLOADED"); + } + mir_free(pszUID); + } + } + } + else + _xmlNode = NULL; + } + else { + _xmlNode = new TiXmlElement(XKEY_OWNER); + } + return _xmlNode; +} + +/** + * name: ExportContact + * class: CExImContactXML + * desc: exports a contact + * param: none + * return: ERROR_OK on success or any other on failure + **/ +INT CExImContactXML::ExportContact(DB::CEnumList* pModules) +{ + if (_pXmlFile->_wExport & EXPORT_DATA) + { + if (pModules) + { + INT i; + LPSTR p; + + for (i = 0; i < pModules->getCount(); i++) + { + p = (*pModules)[i]; + + /*Filter/ + if (mir_stricmp(p, "Protocol") && !DB::Module::IsMeta(p))*/ + { + ExportModule(p); + } + } + } + else + { + ExportModule(USERINFO); + ExportModule(MOD_MBIRTHDAY); + } + } + + // export contact's events + if (_pXmlFile->_wExport & EXPORT_HISTORY) + { + ExportEvents(); + } + + return ERROR_OK; +} + +/** + * name: ExportSubContact + * class: CExImContactXML + * desc: exports a meta sub contact + * param: none + * return: ERROR_OK on success or any other on failure + **/ +INT CExImContactXML::ExportSubContact(CExImContactXML *vMetaContact, DB::CEnumList* pModules) +{ + // create xmlNode + if (!CreateXmlElement()) + { + return ERROR_INVALID_CONTACT; + } + if (ExportContact(pModules) == ERROR_OK) + { + if (!_xmlNode->NoChildren() && vMetaContact->_xmlNode->LinkEndChild(_xmlNode)) + { + return ERROR_OK; + } + } + if (_xmlNode) delete _xmlNode; + return ERROR_NOT_ADDED; +} + +/** + * name: Export + * class: CExImContactXML + * desc: exports a contact + * param: xmlfile - handle to the open file to write the contact to + * pModules - list of modules to export for each contact + * return: ERROR_OK on success or any other on failure + **/ +INT CExImContactXML::Export(FILE *xmlfile, DB::CEnumList* pModules) +{ + if (!xmlfile) + { + return ERROR_INVALID_PARAMS; + } + + if (_hContact == INVALID_HANDLE_VALUE) + { + return ERROR_INVALID_CONTACT; + } + + if (!CreateXmlElement()) + { + return ERROR_INVALID_CONTACT; + } + + // export meta + if (isMeta()) + { + CExImContactXML vContact(_pXmlFile); + + const INT cnt = DB::MetaContact::SubCount(_hContact); + const INT def = DB::MetaContact::SubDefNum(_hContact); + HANDLE hSubContact = DB::MetaContact::Sub(_hContact, def); + INT i; + + // export default subcontact + if (hSubContact && vContact.fromDB(hSubContact)) + { + vContact.ExportSubContact(this, pModules); + } + + for (i = 0; i < cnt; i++) + { + if (i != def) + { + hSubContact = DB::MetaContact::Sub(_hContact, i); + if (hSubContact && vContact.fromDB(hSubContact)) + { + vContact.ExportSubContact(this, pModules); + } + } + } + } + ExportContact(pModules); + + // add xContact to document + if (_xmlNode->NoChildren()) + { + delete _xmlNode; + _xmlNode = NULL; + return ERROR_NOT_ADDED; + } + _xmlNode->Print(xmlfile, 1); + fputc('\n', xmlfile); + + delete _xmlNode; + _xmlNode = NULL; + + return ERROR_OK; +} + +/** + * name: ExportModule + * class: CExImContactXML + * desc: enumerates all settings of a database module and adds them to the xml tree + * params: pszModule - the module which is to export + * return: ERROR_OK on success or any other on failure + **/ +INT CExImContactXML::ExportModule(LPCSTR pszModule) +{ + DB::CEnumList Settings; + if (!pszModule || !*pszModule) { + return ERROR_INVALID_PARAMS; + } + if (!Settings.EnumSettings(_hContact, pszModule)) { + INT i; + TiXmlElement *xmod; + xmod = new TiXmlElement(XKEY_MOD); + if (!xmod) { + return ERROR_MEMORY_ALLOC; + } + xmod->SetAttribute("key", pszModule); + for (i = 0; i < Settings.getCount(); i++) { + ExportSetting(xmod, pszModule, Settings[i]); + } + + if (!xmod->NoChildren() && _xmlNode->LinkEndChild(xmod)) { + return ERROR_OK; + } + delete xmod; + } + return ERROR_EMPTY_MODULE; +} + +/** + * name: ExportSetting + * desc: read a setting from database and add an xmlelement to contact node + * params: xmlModule - xml node to add the setting to + * hContact - handle of the contact whose event chain is to export + * pszModule - the module which is to export + * pszSetting - the setting which is to export + * return: pointer to the added element + **/ +INT CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LPCSTR pszSetting) +{ + DBVARIANT dbv; + TiXmlElement *xmlEntry = NULL; + TiXmlText *xmlValue = NULL; + CHAR buf[32]; + LPSTR str = NULL; + + if (DB::Setting::GetAsIs(_hContact, pszModule, pszSetting, &dbv)) + return ERROR_INVALID_VALUE; + switch (dbv.type) { + case DBVT_BYTE: //'b' bVal and cVal are valid + buf[0] = 'b'; + _ultoa(dbv.bVal, buf + 1, 10); + xmlValue = new TiXmlText(buf); + break; + case DBVT_WORD: //'w' wVal and sVal are valid + buf[0] = 'w'; + _ultoa(dbv.wVal, buf + 1, 10); + xmlValue = new TiXmlText(buf); + break; + case DBVT_DWORD: //'d' dVal and lVal are valid + buf[0] = 'd'; + _ultoa(dbv.dVal, buf + 1, 10); + xmlValue = new TiXmlText(buf); + break; + case DBVT_ASCIIZ: //'s' pszVal is valid + { + if(mir_IsEmptyA(dbv.pszVal)) break; + DB::Variant::ConvertString(&dbv, DBVT_UTF8); + if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { + str[0] = 's'; + mir_strcpy(&str[1], dbv.pszVal); + xmlValue = new TiXmlText(str); + mir_free(str); + } + break; + } + case DBVT_UTF8: //'u' pszVal is valid + { + if(mir_IsEmptyA(dbv.pszVal)) break; + if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { + str[0] = 'u'; + mir_strcpy(&str[1], dbv.pszVal); + xmlValue = new TiXmlText(str); + mir_free(str); + } + break; + } + case DBVT_WCHAR: //'u' pwszVal is valid + { + if(mir_IsEmptyW(dbv.pwszVal)) break; + DB::Variant::ConvertString(&dbv, DBVT_UTF8); + if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { + str[0] = 'u'; + mir_strcpy(&str[1], dbv.pszVal); + xmlValue = new TiXmlText(str); + mir_free(str); + } + break; + } + case DBVT_BLOB: //'n' cpbVal and pbVal are valid + { + // new buffer for base64 encoded data + INT_PTR baselen = Base64EncodeGetRequiredLength(dbv.cpbVal, BASE64_FLAG_NOCRLF); + str = (LPSTR)mir_alloc(baselen + 6); + assert(str != NULL); + // encode data + if (Base64Encode(dbv.pbVal, dbv.cpbVal, str+1, &baselen, BASE64_FLAG_NOCRLF)){ + if (baselen){ + str[baselen+1] = 0; + str[0] = 'n'; + xmlValue = new TiXmlText(str); + } + } + mir_free(str); + break; + } + case DBVT_DELETED: //this setting just got deleted, no other values are valid + #if defined(_DEBUG) + OutputDebugStringA("DBVT_DELETED\n"); + #endif + break; + default: + #if defined(_DEBUG) + OutputDebugStringA("DBVT_TYPE unknown\n"); + #endif + ; // nothing + } + DB::Variant::Free(&dbv); + if (xmlValue) { + xmlEntry = new TiXmlElement(XKEY_SET); + if (xmlEntry) { + xmlEntry->SetAttribute("key", pszSetting); + if (xmlEntry->LinkEndChild(xmlValue) && xmlModule->LinkEndChild(xmlEntry)) + return ERROR_OK; + delete xmlEntry; + } + delete xmlValue; + } + return ERROR_MEMORY_ALLOC; +} + +/** + * name: ExportEvents + * desc: adds the event chain for a given contact to the xml tree + * params: xContact - the xml node to add the events as childs to + * hContact - handle of the contact whose event chain is to export + * return: TRUE on success, FALSE otherwise + **/ +BOOLEAN CExImContactXML::ExportEvents() +{ + DBEVENTINFO dbei; + HANDLE hDbEvent; + PBYTE pbEventBuf = NULL; + DWORD cbEventBuf = 0, + dwNumEvents = 0, + dwNumEventsAdded = 0; + LPSTR pBase64Data = NULL; + INT_PTR cbBase64Data = 0, + cbNewBase64Data = 0; + + TiXmlNode *xmlModule = NULL; + TiXmlElement *xmlEvent = NULL; + TiXmlText *xmlText = NULL; + + dwNumEvents = CallService(MS_DB_EVENT_GETCOUNT, (WPARAM)_hContact, NULL); + if(dwNumEvents == 0) return FALSE; + + try { + ZeroMemory(&dbei, sizeof(DBEVENTINFO)); + dbei.cbSize = sizeof(DBEVENTINFO); + + // read out all events for the current contact + for (hDbEvent = DB::Event::FindFirst(_hContact); hDbEvent != NULL; hDbEvent = DB::Event::FindNext(hDbEvent)) { + if (!DB::Event::GetInfoWithData(hDbEvent, &dbei)) { + // new buffer for base64 encoded data + cbNewBase64Data = Base64EncodeGetRequiredLength(dbei.cbBlob, BASE64_FLAG_NOCRLF); + if (cbNewBase64Data > cbBase64Data) { + pBase64Data = (LPSTR)mir_realloc(pBase64Data, cbNewBase64Data + 5); + if (pBase64Data == NULL) { + MessageBoxA(NULL, "mir_realloc(cbNewBase64Data + 5) == NULL", "Error", 0); + break; + } + cbBase64Data = cbNewBase64Data; + } + + // encode data + if (Base64Encode(dbei.pBlob, dbei.cbBlob, pBase64Data, &cbNewBase64Data, BASE64_FLAG_NOCRLF)) { + pBase64Data[cbNewBase64Data] = 0; + xmlEvent = new TiXmlElement("evt"); + if (xmlEvent) { + xmlEvent->SetAttribute("type", dbei.eventType); + xmlEvent->SetAttribute("time", dbei.timestamp); + xmlEvent->SetAttribute("flag", dbei.flags); + + xmlText = new TiXmlText(pBase64Data); + xmlEvent->LinkEndChild(xmlText); + + // find module + for (xmlModule = _xmlNode->FirstChild(); xmlModule != NULL; xmlModule = xmlModule->NextSibling()) { + if (!mir_stricmp(((TiXmlElement*)xmlModule)->Attribute("key"), dbei.szModule)) break; + } + // create new module + if (!xmlModule) { + xmlModule = _xmlNode->InsertEndChild(TiXmlElement(XKEY_MOD)); + if (!xmlModule) break; + ((TiXmlElement*)xmlModule)->SetAttribute("key", dbei.szModule); + } + + xmlModule->LinkEndChild(xmlEvent); + dwNumEventsAdded++; + xmlEvent = NULL; // avoid final deleting + } + } + MIR_FREE(dbei.pBlob); + } + } + } + catch(...) { + // fuck, do nothing + MIR_FREE(dbei.pBlob); + dwNumEventsAdded = 0; + } + + mir_free(pbEventBuf); + mir_free(pBase64Data); + if (xmlEvent) delete xmlEvent; + + return dwNumEventsAdded == dwNumEvents; +} + +/*********************************************************************************************************** + * importing stuff + ***********************************************************************************************************/ + +/** + * name: CountKeys + * desc: Counts the number of events and settings stored for a contact + * params: xmlContact - the contact, who is the owner of the keys to count + * return: nothing + **/ +VOID CExImContactXML::CountKeys(DWORD &numSettings, DWORD &numEvents) +{ + TiXmlNode *xmod, *xkey; + + numSettings = numEvents = 0; + for (xmod = _xmlNode->FirstChild(); + xmod != NULL; + xmod = xmod->NextSibling(XKEY_MOD) ) { + for (xkey = xmod->FirstChild(); + xkey != NULL; + xkey = xkey->NextSibling() ) { + if (!mir_stricmp(xkey->Value(), XKEY_SET)) numSettings++; + else numEvents++; + } + } +} + +/** + * name: LoadXmlElemnt + * class: CExImContactXML + * desc: get contact information from XML-file + * param: xContact - TiXmlElement representing a contact + * return: ERROR_OK if successful or any other error number otherwise + **/ +INT CExImContactXML::LoadXmlElemnt(TiXmlElement *xContact) +{ + if (xContact == NULL) return ERROR_INVALID_PARAMS; + + LPSTR pszMetaProto = myGlobals.szMetaProto ? myGlobals.szMetaProto : "MetaContacts"; + + // delete last contact + DB::Variant::Free(&_dbvUID); + _hContact = INVALID_HANDLE_VALUE; + + _xmlNode = xContact; + MIR_FREE(_pszAMPro); ampro(xContact->Attribute("ampro")); + MIR_FREE(_pszNick); nick (xContact->Attribute("nick")); + MIR_FREE(_pszDisp); disp (xContact->Attribute("disp")); + MIR_FREE(_pszGroup); group(xContact->Attribute("group")); + MIR_FREE(_pszProto); + MIR_FREE(_pszProtoOld); + MIR_FREE(_pszUIDKey); + + // is contact a metacontact + if (_pszAMPro && !strcmp(_pszAMPro, pszMetaProto) /*_xmlNode->FirstChildElement(XKEY_CONTACT)*/) { + TiXmlElement *xSub; + proto(pszMetaProto); + + // meta contact must be uniquelly identified by its subcontacts + // the metaID may change during an export or import call + for(xSub = xContact->FirstChildElement(XKEY_CONTACT); + xSub != NULL; + xSub = xSub->NextSiblingElement(XKEY_CONTACT)) { + CExImContactXML vSub(_pXmlFile); + if (vSub = xSub) { + // identify metacontact by the first valid subcontact in xmlfile + if (_hContact == INVALID_HANDLE_VALUE && vSub.handle() != INVALID_HANDLE_VALUE) { + HANDLE hMeta = (HANDLE)CallService(MS_MC_GETMETACONTACT, (WPARAM)vSub.handle(), NULL); + if (hMeta != NULL) { + _hContact = hMeta; + break; + } + } + } + } + // if no handle was found, this is a new meta contact + _isNewContact = _hContact == INVALID_HANDLE_VALUE; + } + // entry is a default contact + else { + proto(xContact->Attribute("proto")); + uidk (xContact->Attribute("uidk")); + if (!_pszProto) { + // check if this is the owner contact + if (mir_stricmp(xContact->Value(), XKEY_OWNER)) + return ERROR_INVALID_PARAMS; + _hContact = NULL; + _xmlNode = xContact; + return ERROR_OK; + } + + if (_pszUIDKey && mir_strcmp("#NV", _pszUIDKey) !=0) { + LPCSTR pUID = xContact->Attribute("uidv"); + + if (pUID != NULL) { + size_t len = 0; + INT_PTR baselen = NULL; + PBYTE pbVal = NULL; + + switch (*(pUID++)) { + case 'b': + uid((BYTE)atoi(pUID)); + break; + case 'w': + uid((WORD)atoi(pUID)); + break; + case 'd': + uid((DWORD)_atoi64(pUID)); + break; + case 's': + // utf8 -> asci + uida(pUID); + break; + case 'u': + uidu(pUID); + break; + case 'n': + len = strlen(pUID); + baselen = Base64DecodeGetRequiredLength(len); + pbVal = (PBYTE)mir_alloc(baselen /*+1*/); + if (pbVal != NULL){ + if (Base64Decode(pUID, len, pbVal, &baselen)){ + uidn(pbVal, baselen); + } + else { + assert(pUID != NULL); + } + } + break; + default: + uidu((LPCSTR)NULL); + break; + } + } + } + // finally try to find contact in contact list + findHandle(); + } + return ERROR_OK; +} + +/** + * name: ImportContact + * class: CExImContactXML + * desc: create the contact if neccessary and copy + * all information from the xmlNode to database + * param: none + * return: ERROR_OK on success or any other error number otherwise + **/ +INT CExImContactXML::ImportContact() +{ + TiXmlNode *xmod; + + // create the contact if not yet exists + if (toDB() != INVALID_HANDLE_VALUE) { + DWORD numSettings, numEvents; + + _hEvent = NULL; + + // count settings and events and init progress dialog + CountKeys(numSettings, numEvents); + _pXmlFile->_progress.SetSettingsCount(numSettings + numEvents); + _pXmlFile->_numSettingsTodo += numSettings; + _pXmlFile->_numEventsTodo += numEvents; + + // import all modules + for(xmod = _xmlNode->FirstChild(); + xmod != NULL; + xmod = xmod->NextSibling(XKEY_MOD)) { + + // import module + if (ImportModule(xmod) == ERROR_ABORTED) { + // ask to delete new incomplete contact + if (_isNewContact && _hContact != NULL) { + INT result = MsgBox(NULL, MB_YESNO|MB_ICONWARNING, + LPGENT("Question"), + LPGENT("Importing a new contact was aborted!"), + LPGENT("You aborted import of a new contact.\nSome information may be missing for this contact.\n\nDo you want to delete the incomplete contact?")); + if (result == IDYES) { + DB::Contact::Delete(_hContact); + _hContact = INVALID_HANDLE_VALUE; + } + } + return ERROR_ABORTED; + } + } + return ERROR_OK; + } + return ERROR_NOT_ADDED; +} + +/** + * name: ImportNormalContact + * class: CExImContactXML + * desc: create the contact if neccessary and copy + * all information from the xmlNode to database. + * Remove contact from a metacontact if it is a subcontact + * param: none + * return: ERROR_OK on success or any other error number otherwise + **/ +INT CExImContactXML::ImportNormalContact() +{ + INT err = ImportContact(); + + // remove contact from a metacontact + if (err == ERROR_OK && CallService(MS_MC_GETMETACONTACT, (WPARAM)_hContact, NULL)) { + CallService(MS_MC_REMOVEFROMMETA, NULL, (LPARAM)_hContact); + } + return err; +} + +/** + * name: Import + * class: CExImContactXML + * desc: create the contact if neccessary and copy + * all information from the xmlNode to database. + * Remove contact from a metacontact if it is a subcontact + * param: TRUE = keepMetaSubContact + * return: ERROR_OK on success or any other error number otherwise + **/ +INT CExImContactXML::Import(BOOLEAN keepMetaSubContact) +{ + INT result; + TiXmlElement *xContact = _xmlNode->FirstChildElement("CONTACT"); + + // xml contact contains subcontacts? + if (xContact) { + + // contact is a metacontact and metacontacts plugin is installed? + if (isMeta()) { + // create object for first sub contact + CExImContactXML vContact(_pXmlFile); + LPTSTR pszNick; + + // the contact does not yet exist + if (_isNewContact) { + // import default contact as normal contact and convert to meta contact + if (!(vContact = xContact)) { + return ERROR_CONVERT_METACONTACT; + } + // import as normal contact + result = vContact.ImportContact(); + if (result != ERROR_OK) return result; + // convert default subcontact to metacontact + _hContact = (HANDLE)CallService(MS_MC_CONVERTTOMETA, (WPARAM)vContact.handle(), NULL); + if (_hContact == NULL) { + _hContact = INVALID_HANDLE_VALUE; + return ERROR_CONVERT_METACONTACT; + } + + _pXmlFile->_numContactsDone++; + // do not load first meta contact twice + xContact = xContact->NextSiblingElement("CONTACT"); + } + // xml contact contains more than one subcontacts? + if (xContact) { + // load all subcontacts + do { + // update progressbar and abort if user clicked cancel + pszNick = mir_utf8decodeT(xContact->Attribute("nick")); + result = _pXmlFile->_progress.UpdateContact(_T("Sub Contact: %s (") _T(TCHAR_STR_PARAM) _T(")"), pszNick, xContact->Attribute("proto")); + if (pszNick) mir_free(pszNick); + // user clicked abort button + if (!result) break; + if (vContact = xContact) { + if (vContact.ImportMetaSubContact(this) == ERROR_ABORTED) + return ERROR_ABORTED; + _pXmlFile->_numContactsDone++; + } + } + while (xContact = xContact->NextSiblingElement("CONTACT")); + } + // load metacontact information (after subcontact for faster import) + ImportContact(); + return ERROR_OK; + } + // import sub contacts as normal contacts + return _pXmlFile->ImportContacts(_xmlNode); + } + + // load contact information + result = ImportContact(); + if (result == ERROR_OK && !keepMetaSubContact) + { + CallService(MS_MC_REMOVEFROMMETA, NULL, (LPARAM)_hContact); + } + + return result; +} + +/** + * name: ImportMetaSubContact + * class: CExImContactXML + * desc: create the contact if neccessary and copy + * all information from the xmlNode to database. + * Add this contact to an meta contact + * param: pMetaContact - the meta contact to add this one to + * return: + **/ +INT CExImContactXML::ImportMetaSubContact(CExImContactXML * pMetaContact) +{ + INT err = ImportContact(); + + // abort here if contact was not imported correctly + if (err != ERROR_OK) return err; + + // check if contact is subcontact of the desired meta contact + if ((HANDLE)CallService(MS_MC_GETMETACONTACT, (WPARAM)_hContact, NULL) != pMetaContact->handle()) { + // add contact to the metacontact (this service returns TRUE if successful) + err = CallService(MS_MC_ADDTOMETA, (WPARAM)_hContact, (LPARAM)pMetaContact->handle()); + if (err == FALSE) { + // ask to delete new contact + if (_isNewContact && _hContact != NULL) { + LPTSTR ptszNick = mir_utf8decodeT(_pszNick); + LPTSTR ptszMetaNick = mir_utf8decodeT(pMetaContact->_pszNick); + INT result = MsgBox(NULL, MB_YESNO|MB_ICONWARNING, + LPGENT("Question"), + LPGENT("Importing a new meta subcontact failed!"), + LPGENT("The newly created MetaSubContact '%s'\ncould not be added to MetaContact '%s'!\n\nDo you want to delete this contact?"), + ptszNick, ptszMetaNick); + MIR_FREE(ptszNick); + MIR_FREE(ptszMetaNick); + if (result == IDYES) { + DB::Contact::Delete(_hContact); + _hContact = INVALID_HANDLE_VALUE; + } + } + return ERROR_ADDTO_METACONTACT; + } + } + return ERROR_OK; +} + +/** + * name: ImportModule + * class: CExImContactXML + * desc: interprete an xmlnode as module and add the children to database. + * params: hContact - handle to the contact, who is the owner of the setting to import + * xmlModule - xmlnode representing the module + * stat - structure used to collect some statistics + * return: ERROR_OK on success or one other element of ImportError to tell the type of failure + **/ +INT CExImContactXML::ImportModule(TiXmlNode* xmlModule) +{ + TiXmlElement *xMod; + TiXmlElement *xKey; + LPCSTR pszModule; + BOOLEAN isProtoModule; + BOOLEAN isMetaModule; + + // check if parent is really a module + if (!xmlModule || mir_stricmp(xmlModule->Value(), XKEY_MOD)) + return ERROR_INVALID_SIGNATURE; + // convert to element + if (!(xMod = xmlModule->ToElement())) + return ERROR_INVALID_PARAMS; + // get module name + pszModule = xMod->Attribute("key"); + if (!pszModule || !*pszModule) + return ERROR_INVALID_PARAMS; + // ignore Modul 'Protocol' as it would cause trouble + if (!mir_stricmp(pszModule, "Protocol")) + return ERROR_OK; + + for (xKey = xmlModule->FirstChildElement(); xKey != NULL; xKey = xKey->NextSiblingElement()) { + // import setting + if (!mir_stricmp(xKey->Value(), XKEY_SET)) { + // check if the module to import is the contact's protocol module + isProtoModule = !mir_stricmp(pszModule, _pszProto)/* || DB::Module::IsMeta(pszModule)*/; + isMetaModule = DB::Module::IsMeta(pszModule); + + // just ignore MetaModule on normal contact to avoid errors (only keys) + if(!isProtoModule && isMetaModule) { + continue; + } + // just ignore MetaModule on Meta to avoid errors (only import spetial keys) + else if(isProtoModule && isMetaModule) { + if (!mir_stricmp(xKey->Attribute("key"),"Nick") || + !mir_stricmp(xKey->Attribute("key"),"TzName") || + !mir_stricmp(xKey->Attribute("key"),"Timezone") ){ + if (ImportSetting(pszModule, xKey->ToElement()) == ERROR_OK) { + _pXmlFile->_numSettingsDone++; + } + } + } + // just ignore some settings of protocol module to avoid errors (only keys) + else if (isProtoModule && !isMetaModule) { + if (!IsContactInfo(xKey->Attribute("key"))) { + if (ImportSetting(pszModule, xKey->ToElement()) == ERROR_OK) { + _pXmlFile->_numSettingsDone++; + } + } + } + // other module + else if (ImportSetting(pszModule, xKey->ToElement()) == ERROR_OK) { + _pXmlFile->_numSettingsDone++; + } + if (!_pXmlFile->_progress.UpdateSetting(LPGENT("Settings: %S"), pszModule)) + return ERROR_ABORTED; + } + // import event + else if (!mir_stricmp(xKey->Value(), XKEY_EVT)) { + INT error = ImportEvent(pszModule, xKey->ToElement()); + switch (error) { + case ERROR_OK: + _pXmlFile->_numEventsDone++; + break; + case ERROR_DUPLICATED: + _pXmlFile->_numEventsDuplicated++; + break; + } + if (!_pXmlFile->_progress.UpdateSetting(LPGENT("Events: %S"), pszModule)) + return ERROR_ABORTED; + } + } //*end for + return ERROR_OK; +} + +/** + * name: ImportSetting + * class: CExImContactXML + * desc: interprete an setting representing xmlnode and write the corresponding setting to database. + * params: xmlModule - xmlnode representing the module to write the setting to in the database + * xmlEntry - xmlnode representing the setting to import + * return: ERROR_OK on success or one other element of ImportError to tell the type of failure + **/ +INT CExImContactXML::ImportSetting(LPCSTR pszModule, TiXmlElement *xmlEntry) +{ + DBCONTACTWRITESETTING cws = {0}; + TiXmlText* xval; + LPCSTR value; + + // validate parameter + if (!xmlEntry || !pszModule || !*pszModule) + return ERROR_INVALID_PARAMS; + + // validate value + xval = (TiXmlText*)xmlEntry->FirstChild(); + if (!xval || xval->Type() != TiXmlText::TEXT) + return ERROR_INVALID_VALUE; + value = xval->Value(); + + // init write structure + cws.szModule = (LPSTR)pszModule; + cws.szSetting = xmlEntry->Attribute("key"); + + // convert data + size_t len = 0; + INT_PTR baselen = NULL; + + switch (value[0]) { + case 'b': //'b' bVal and cVal are valid + cws.value.type = DBVT_BYTE; + cws.value.bVal = (BYTE)atoi(value + 1); + break; + case 'w': //'w' wVal and sVal are valid + cws.value.type = DBVT_WORD; + cws.value.wVal = (WORD)atoi(value + 1); + break; + case 'd': //'d' dVal and lVal are valid + cws.value.type = DBVT_DWORD; + cws.value.dVal = (DWORD)_atoi64(value + 1); +// cws.value.dVal = (DWORD)atoi(value + 1); + break; + case 's': //'s' pszVal is valid + cws.value.type = DBVT_ASCIIZ; + cws.value.pszVal = (LPSTR)mir_utf8decodeA((LPSTR)(value + 1)); + break; + case 'u': + cws.value.type = DBVT_UTF8; + cws.value.pszVal = (LPSTR)mir_strdup((LPSTR)(value + 1)); + break; + case 'n': + len = strlen(value + 1); + baselen = Base64DecodeGetRequiredLength(len); + cws.value.type = DBVT_BLOB; + cws.value.pbVal = (PBYTE)mir_alloc(baselen +1); + if (cws.value.pbVal != NULL){ + if (Base64Decode((value + 1), len, cws.value.pbVal, &baselen)){ + cws.value.cpbVal = baselen; + } + else { + mir_free(cws.value.pbVal); + return ERROR_NOT_ADDED; + } + } + break; + default: + return ERROR_INVALID_TYPE; + } + // write value to db + if (CallService(MS_DB_CONTACT_WRITESETTING, (WPARAM)_hContact, (LPARAM)&cws)) { + //if (cws.value.pbVal>0) + mir_free(cws.value.pbVal); + if(cws.value.type == DBVT_ASCIIZ || cws.value.type == DBVT_UTF8) mir_free(cws.value.pszVal); + return ERROR_NOT_ADDED; + } + //if (cws.value.pbVal>0) + mir_free(cws.value.pbVal); + if(cws.value.type == DBVT_ASCIIZ || cws.value.type == DBVT_UTF8) mir_free(cws.value.pszVal); + return ERROR_OK; +} + +/** + * name: ImportEvent + * class: CExImContactXML + * desc: interprete an xmlnode and add the corresponding event to database. + * params: hContact - handle to the contact, who is the owner of the setting to import + * xmlModule - xmlnode representing the module to write the setting to in the database + * xmlEvent - xmlnode representing the event to import + * return: ERROR_OK on success or one other element of ImportError to tell the type of failure + **/ +INT CExImContactXML::ImportEvent(LPCSTR pszModule, TiXmlElement *xmlEvent) +{ + DBEVENTINFO dbei; + TiXmlText *xmlValue; + LPCSTR tmp; + size_t cbSrc; + INT_PTR baselen; + + // dont import events from metacontact + if (isMeta()) { + return ERROR_DUPLICATED; + } + + if (!xmlEvent || !pszModule || !*pszModule) + return ERROR_INVALID_PARAMS; + + if (stricmp(xmlEvent->Value(), "evt")) + return ERROR_NOT_ADDED; + + // timestamp must be valid + xmlEvent->Attribute("time", (LPINT)&dbei.timestamp); + if (dbei.timestamp == 0) return ERROR_INVALID_TIMESTAMP; + + xmlValue = (TiXmlText*)xmlEvent->FirstChild(); + if (!xmlValue || xmlValue->Type() != TiXmlText::TEXT) + return ERROR_INVALID_VALUE; + tmp = xmlValue->Value(); + if (!tmp || tmp[0] == 0) + return ERROR_INVALID_VALUE; + + cbSrc = strlen(tmp); + baselen = Base64DecodeGetRequiredLength(cbSrc); + dbei.cbBlob = NULL; + dbei.pBlob = NULL; + dbei.pBlob = (PBYTE)mir_alloc(baselen + 1); + if (dbei.pBlob != NULL) { + if (Base64Decode(tmp, cbSrc, dbei.pBlob, &baselen)) { + INT_PTR hEvent; + + // event owning module + dbei.cbSize = sizeof(dbei); + dbei.szModule = (LPSTR)pszModule; + dbei.cbBlob = baselen; + + xmlEvent->Attribute("type", (LPINT)&dbei.eventType); + xmlEvent->Attribute("flag", (LPINT)&dbei.flags); + if (dbei.flags == 0) dbei.flags = DBEF_READ; + + // search in new and existing contact for existing event to avoid duplicates + if (/*!_isNewContact && */DB::Event::Exists(_hContact, _hEvent, &dbei)) { + mir_free(dbei.pBlob); + return ERROR_DUPLICATED; + } + + hEvent = CallService(MS_DB_EVENT_ADD, (WPARAM)_hContact, (LPARAM)&dbei); + mir_free(dbei.pBlob); + if (hEvent) { + _hEvent = (HANDLE)hEvent; + return ERROR_OK; + } + } + mir_free(dbei.pBlob); + } + return ERROR_NOT_ADDED; +} diff --git a/plugins/UserInfoEx/ex_import/classExImContactXML.h b/plugins/UserInfoEx/ex_import/classExImContactXML.h new file mode 100644 index 0000000000..52ad2ef087 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/classExImContactXML.h @@ -0,0 +1,103 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/classExImContactXML.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _CLASS_EXIM_CONTACT_XML_INCLUDED_ +#define _CLASS_EXIM_CONTACT_XML_INCLUDED_ 1 + +#include "svc_ExImport.h" +#include "classExImContactBase.h" +#include "svc_ExImXML.h" +#include "dlg_ExImProgress.h" + +#define XKEY_MOD "MOD" +#define XKEY_SET "SET" +#define XKEY_EVT "evt" +#define XKEY_CONTACT "CONTACT" +#define XKEY_OWNER "OWNER" + +enum EError { + ERROR_OK = 0, + ERROR_NOT_ADDED = 1, + ERROR_INVALID_PARAMS = 2, + ERROR_INVALID_VALUE = 3, + ERROR_INVALID_TIMESTAMP = 4, + ERROR_INVALID_TYPE = 5, + ERROR_DUPLICATED = 6, + ERROR_MEMORY_ALLOC = 7, + ERROR_INVALID_CONTACT = 8, + ERROR_INVALID_SIGNATURE = 9, + ERROR_ABORTED = 10, + ERROR_CONVERT_METACONTACT = 11, + ERROR_ADDTO_METACONTACT = 12, + ERROR_EMPTY_MODULE = 13 +}; + +class CExImContactXML : public CExImContactBase { + + CFileXml* _pXmlFile; // the xmlfile + TiXmlElement* _xmlNode; // xmlnode with contact information + HANDLE _hEvent; + + BOOLEAN IsContactInfo(LPCSTR pszKey); + + // private importing methods + INT ImportModule(TiXmlNode* xmlModule); + INT ImportSetting(LPCSTR pszModule, TiXmlElement *xmlEntry); + INT ImportEvent(LPCSTR pszModule, TiXmlElement *xmlEvent); + INT ImportContact(); + INT ImportNormalContact(); + INT ImportMetaSubContact(CExImContactXML * pMetaContact); + VOID CountKeys(DWORD &numSettings, DWORD &numEvents); + + // private exporting methods + INT ExportModule(LPCSTR pszModule); + INT ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LPCSTR pszSetting); + BOOLEAN ExportEvents(); + + INT ExportContact(DB::CEnumList* pModules); + INT ExportSubContact(CExImContactXML *vMetaContact, DB::CEnumList* pModules); + +public: + CExImContactXML(CFileXml * pXmlFile); + + // exporting stuff + TiXmlElement* CreateXmlElement(); + INT Export(FILE *xmlfile, DB::CEnumList* pModules); + + // importing stuff + INT LoadXmlElemnt(TiXmlElement *xContact); + INT Import(BOOLEAN keepMetaSubContact = FALSE); + + BOOLEAN operator = (TiXmlElement* xmlContact) { + return LoadXmlElemnt(xmlContact) == ERROR_OK; + } +}; + +#endif /* _CLASS_EXIM_CONTACT_XML_INCLUDED_ */ diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImModules.cpp b/plugins/UserInfoEx/ex_import/dlg_ExImModules.cpp new file mode 100644 index 0000000000..ba026e2c52 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImModules.cpp @@ -0,0 +1,464 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImModules.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include "commonheaders.h" +//#include "svc_ExImport.h" +#include "dlg_ExImModules.h" + +/*********************************************************************************************************** + * typedefs + ***********************************************************************************************************/ + +typedef struct { + lpExImParam ExImContact; + DB::CEnumList* pModules; +} EXPORTDATA, *LPEXPORTDATA; + +/*********************************************************************************************************** + * modules stuff + ***********************************************************************************************************/ + +/** + * name: ExportTree_AppendModuleList + * desc: according to the checked list items create the module list for exporting + * param: hTree - handle to the window of the treeview + * hParent - parent tree item for the item to add + * pModules - module list to fill + * return: nothing + **/ +void ExportTree_AppendModuleList(HWND hTree, HTREEITEM hParent, DB::CEnumList* pModules) +{ + TVITEMA tvi; + + // add all checked modules + if (tvi.hItem = TreeView_GetChild(hTree, hParent)) { + CHAR szModule[MAXSETTING]; + + // add optional items + tvi.mask = TVIF_STATE|TVIF_TEXT; + tvi.stateMask = TVIS_STATEIMAGEMASK; + tvi.pszText = szModule; + tvi.cchTextMax = MAXSETTING; + + do { + if ( + SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&tvi) && + ( + tvi.state == INDEXTOSTATEIMAGEMASK(0) || + tvi.state == INDEXTOSTATEIMAGEMASK(2) + ) + ) + { + pModules->Insert(tvi.pszText); + } + } + while (tvi.hItem = TreeView_GetNextSibling(hTree, tvi.hItem)); + } +} + +/** + * name: ExportTree_FindItem + * desc: find a item by its label + * param: hTree - handle to the window of the treeview + * hParent - parent tree item for the item to add + * pszText - text to match the label against + * return: a handle to the found treeitem or NULL + **/ +HTREEITEM ExportTree_FindItem(HWND hTree, HTREEITEM hParent, LPSTR pszText) +{ + TVITEMA tvi; + CHAR szBuf[128]; + + if (!pszText || !*pszText) return NULL; + + tvi.mask = TVIF_TEXT; + tvi.pszText = szBuf; + tvi.cchTextMax = SIZEOF(szBuf); + + for (tvi.hItem = TreeView_GetChild(hTree, hParent); + tvi.hItem != NULL; + tvi.hItem = TreeView_GetNextSibling(hTree, tvi.hItem)) + { + if (SendMessageA(hTree, TVM_GETITEMA, NULL, (LPARAM)&tvi) && !mir_stricmp(tvi.pszText, pszText)) + return tvi.hItem; + } + return NULL; +} + +/** + * name: ExportTree_AddItem + * desc: add an item to the tree view with given options + * param: hTree - handle to the window of the treeview + * hParent - parent tree item for the item to add + * pszDesc - item label + * bUseImages - icons are loaded + * bState - 0-hide checkbox/1-unchecked/2-checked + * return: return handle to added treeitem + **/ +HTREEITEM ExportTree_AddItem(HWND hTree, HTREEITEM hParent, LPSTR pszDesc, BOOLEAN bUseImages, BYTE bState) +{ + TVINSERTSTRUCTA tvii; + HTREEITEM hItem = NULL; + + tvii.hParent = hParent; + tvii.hInsertAfter = TVI_SORT; + tvii.itemex.mask = TVIF_TEXT; + if (bUseImages) { + tvii.itemex.mask |= TVIF_IMAGE|TVIF_SELECTEDIMAGE; + tvii.itemex.iImage = tvii.itemex.iSelectedImage = 1; + } + tvii.itemex.pszText = pszDesc; + if (hItem = (HTREEITEM)SendMessageA(hTree, TVM_INSERTITEMA, NULL, (LPARAM)&tvii)) + TreeView_SetItemState(hTree, hItem, INDEXTOSTATEIMAGEMASK(bState), TVIS_STATEIMAGEMASK); + return hItem; +} + +/** + * name: SelectModulesToExport_DlgProc + * desc: dialog procedure for a dialogbox, which lists modules for a specific contact + * param: hDlg - handle to the window of the dialogbox + * uMsg - message to handle + * wParam - message specific parameter + * lParam - message specific parameter + * return: message specific + **/ +INT_PTR CALLBACK SelectModulesToExport_DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + LPEXPORTDATA pDat = (LPEXPORTDATA)GetUserData(hDlg); + + switch (uMsg) { + + case WM_INITDIALOG: + { + HWND hTree; + BOOLEAN bImagesLoaded = 0; + + // get tree handle and set treeview style + if (!(hTree = GetDlgItem(hDlg, IDC_TREE))) break; + SetWindowLongPtr(hTree, GWL_STYLE, GetWindowLongPtr(hTree, GWL_STYLE) | TVS_NOHSCROLL | TVS_CHECKBOXES); + + // init the datastructure + if (!(pDat = (LPEXPORTDATA)mir_alloc(sizeof(EXPORTDATA)))) + return FALSE; + pDat->ExImContact = ((LPEXPORTDATA)lParam)->ExImContact; + pDat->pModules = ((LPEXPORTDATA)lParam)->pModules; + SetUserData(hDlg, pDat); + + // set icons + { + HICON hIcon; + HIMAGELIST hImages; + OSVERSIONINFO osvi; + const ICONCTRL idIcon[] = { + { ICO_DLG_EXPORT, WM_SETICON, NULL }, + { ICO_DLG_EXPORT, STM_SETIMAGE, ICO_DLGLOGO }, + { ICO_BTN_EXPORT, BM_SETIMAGE, IDOK }, + { ICO_BTN_CANCEL, BM_SETIMAGE, IDCANCEL } + }; + const INT numIconsToSet = DB::Setting::GetByte(SET_ICONS_BUTTONS, 1) ? SIZEOF(idIcon) : 2; + IcoLib_SetCtrlIcons(hDlg, idIcon, numIconsToSet); + + // create imagelist for treeview + osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&osvi); + if ((hImages = ImageList_Create( + GetSystemMetrics(SM_CXSMICON), + GetSystemMetrics(SM_CYSMICON), + ((osvi.dwPlatformId == VER_PLATFORM_WIN32_NT && osvi.dwMajorVersion >= 5 && osvi.dwMinorVersion >= 1) ? ILC_COLOR32 : ILC_COLOR16)|ILC_MASK, + 0, 1) + ) != NULL) + { + SendMessage(hTree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)hImages); + + bImagesLoaded + = ((((hIcon = IcoLib_GetIcon(ICO_LST_MODULES)) != NULL) && 0 == ImageList_AddIcon(hImages, hIcon)) + && (((hIcon = IcoLib_GetIcon(ICO_LST_FOLDER)) != NULL) && 1 == ImageList_AddIcon(hImages, hIcon))); + } + } + // do the translation stuff + { + SendDlgItemMessage(hDlg, BTN_CHECK, BUTTONTRANSLATE, NULL, NULL); + SendDlgItemMessage(hDlg, BTN_UNCHECK, BUTTONTRANSLATE, NULL, NULL); + SendDlgItemMessage(hDlg, IDOK, BUTTONTRANSLATE, NULL, NULL); + SendDlgItemMessage(hDlg, IDCANCEL, BUTTONTRANSLATE, NULL, NULL); + } + // Set the Window Title and description + { + LPCTSTR name = NULL; + TCHAR oldTitle[MAXDATASIZE], + newTitle[MAXDATASIZE]; + switch (pDat->ExImContact->Typ) { + case EXIM_ALL: + case EXIM_GROUP: + name = TranslateT("All Contacts"); + break; + case EXIM_CONTACT: + if (pDat->ExImContact->hContact == NULL) { + name = TranslateT("Owner"); + } + else { + name = DB::Contact::DisplayName(pDat->ExImContact->hContact); + } + break; + case EXIM_SUBGROUP: + name = (LPCTSTR) pDat->ExImContact->ptszName; + break; + case EXIM_ACCOUNT: + PROTOACCOUNT* acc = ProtoGetAccount(pDat->ExImContact->pszName); + name = (LPCTSTR) acc->tszAccountName; + break; + } + TranslateDialogDefault(hDlg); //to translate oldTitle + GetWindowText(hDlg, oldTitle, MAXSETTING); + mir_sntprintf(newTitle, MAXDATASIZE - 1, _T("%s - %s"), name, oldTitle); + SetWindowText(hDlg, newTitle); + } + + { + LPSTR pszProto; + TVINSERTSTRUCT tviiT; + DB::CEnumList Modules; + HTREEITEM hItemEssential, hItemOptional; + + TreeView_SetIndent(hTree, 6); + TreeView_SetItemHeight(hTree, 18); + + pszProto = (pDat->ExImContact->Typ == EXIM_CONTACT && pDat->ExImContact->hContact != NULL) + ? (LPSTR)DB::Contact::Proto(pDat->ExImContact->hContact) + : NULL; + + // add items that are always exported + tviiT.hParent = TVI_ROOT; + tviiT.hInsertAfter = TVI_FIRST; + tviiT.itemex.mask = TVIF_TEXT|TVIF_STATE; + tviiT.itemex.pszText = TranslateT("Required modules"); + tviiT.itemex.state = tviiT.itemex.stateMask = TVIS_EXPANDED; + if (bImagesLoaded) { + tviiT.itemex.mask |= TVIF_IMAGE|TVIF_SELECTEDIMAGE; + tviiT.itemex.iImage = tviiT.itemex.iSelectedImage = 0; + } + if (hItemEssential = TreeView_InsertItem(hTree, &tviiT)) { + // disable state images + TreeView_SetItemState(hTree, hItemEssential, INDEXTOSTATEIMAGEMASK(0), TVIS_STATEIMAGEMASK); + + // insert essential items (modul from UIEX) + ExportTree_AddItem(hTree, hItemEssential, USERINFO, bImagesLoaded, 0); + ExportTree_AddItem(hTree, hItemEssential, MOD_MBIRTHDAY, bImagesLoaded, 0); + + /*Filter/ protocol module is ignored for owner contact + if (pDat->hContact != NULL) { + ExportTree_AddItem(hTree, hItemEssential, "Protocol", bImagesLoaded, 0); + }*/ + + // base protocol is only valid for single exported contact at this position + if (pszProto) { + ExportTree_AddItem(hTree, hItemEssential, pszProto, bImagesLoaded, 0); + } + } + + // add items that are optional (and more essential) + tviiT.hInsertAfter = TVI_LAST; + tviiT.itemex.pszText = TranslateT("Optional modules"); + if (hItemOptional = TreeView_InsertItem(hTree, &tviiT)) { + TreeView_SetItemState(hTree, hItemOptional, INDEXTOSTATEIMAGEMASK(0), TVIS_STATEIMAGEMASK); + + if (!Modules.EnumModules()) // init Modul list + { + INT i; + LPSTR p; + + for (i = 0; i < Modules.getCount(); i++) + { + p = Modules[i]; + /*Filter/ + if (!DB::Module::IsMeta(p))/end Filter*/ + { + // module must exist in at least one contact + if (pDat->ExImContact->Typ != EXIM_CONTACT) // TRUE = All Contacts + { + HANDLE hContact; + + for (hContact = DB::Contact::FindFirst(); + hContact != NULL; + hContact = DB::Contact::FindNext(hContact)) + { + // ignore empty modules + if (!DB::Module::IsEmpty(hContact, p)) { + pszProto = DB::Contact::Proto(hContact); + // Filter by mode + switch (pDat->ExImContact->Typ) + { + case EXIM_ALL: + case EXIM_GROUP: + break; + case EXIM_SUBGROUP: + if (mir_tcsncmp(pDat->ExImContact->ptszName, DB::Setting::GetTString(hContact, "CList", "Group"), mir_tcslen(pDat->ExImContact->ptszName))) { + continue; + } + break; + case EXIM_ACCOUNT: + if (mir_strcmp(pDat->ExImContact->pszName, pszProto)) { + continue; + } + break; + } + + // contact's base protocol is to be added to the treeview uniquely + if (!mir_stricmp(p, pszProto)) + { + if (!ExportTree_FindItem(hTree, hItemEssential, p)) + { + ExportTree_AddItem(hTree, hItemEssential, p, bImagesLoaded, 0); + } + break; + } + + // add optional module, which is valid for at least one contact + /*/Filter/*/ + if ( mir_stricmp(p, USERINFO) && + mir_stricmp(p, MOD_MBIRTHDAY) && + // Meta is only valid as base Proto at this point + mir_stricmp(p, myGlobals.szMetaProto) /*&& + mir_stricmp(p, "Protocol")*/ + ) + { + ExportTree_AddItem(hTree, hItemOptional, p, bImagesLoaded, 1); + break; + } + } + } // end for + } // end TRUE = All Contacts + + // module must exist in the selected contact + else if ( + /*Filter/*/ + !DB::Module::IsEmpty(pDat->ExImContact->hContact, p) && + (!pDat->ExImContact->hContact || mir_stricmp(p, pszProto)) && + //mir_stricmp(p, "Protocol") && + mir_stricmp(p, USERINFO) && + mir_stricmp(p, MOD_MBIRTHDAY) ) + { + ExportTree_AddItem(hTree, hItemOptional, (LPSTR)p, bImagesLoaded, 1); + } + } // end + } + } + } + } + TranslateDialogDefault(hDlg); + return TRUE; + } + case WM_CTLCOLORSTATIC: + if (GetDlgItem(hDlg, STATIC_WHITERECT) == (HWND)lParam || GetDlgItem(hDlg, ICO_DLGLOGO) == (HWND)lParam) { + SetBkColor((HDC)wParam, RGB(255, 255, 255)); + return (INT_PTR)GetStockObject(WHITE_BRUSH); + } + SetBkMode((HDC)wParam, TRANSPARENT); + return (INT_PTR)GetStockObject(NULL_BRUSH); + + case WM_COMMAND: + switch (LOWORD(wParam)) { + case IDOK: + { + HWND hTree = GetDlgItem(hDlg, IDC_TREE); + HTREEITEM hParent; + + // search the tree item of optional items + for (hParent = TreeView_GetRoot(hTree); + hParent != NULL; + hParent = TreeView_GetNextSibling(hTree, hParent)) + { + ExportTree_AppendModuleList(hTree, hParent, pDat->pModules); + } + return EndDialog(hDlg, IDOK); + } + case IDCANCEL: + return EndDialog(hDlg, IDCANCEL); + + case BTN_CHECK: + case BTN_UNCHECK: + { + HWND hTree = GetDlgItem(hDlg, IDC_TREE); + LPCSTR pszRoot = Translate("Optional modules"); + TVITEMA tvi; + CHAR szText[128]; + + tvi.mask = TVIF_TEXT; + tvi.pszText = szText; + tvi.cchTextMax = sizeof(szText); + + // search the tree item of optional items + for (tvi.hItem = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_ROOT, NULL); + tvi.hItem != NULL && SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&tvi); + tvi.hItem = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)tvi.hItem)) + { + if (!mir_stricmp(tvi.pszText, pszRoot)) { + tvi.mask = TVIF_STATE; + tvi.state = INDEXTOSTATEIMAGEMASK(LOWORD(wParam) == BTN_UNCHECK ? 1 : 2); + tvi.stateMask = TVIS_STATEIMAGEMASK; + + for (tvi.hItem = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)tvi.hItem); + tvi.hItem != NULL; + tvi.hItem = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)tvi.hItem)) + { + SendMessageA(hTree, TVM_SETITEMA, NULL, (LPARAM)&tvi); + } + break; + } + } + break; + } + } + break; + + case WM_DESTROY: + mir_free(pDat); + break; + } + return 0; +} + +/** + * name: DlgExImModules_SelectModulesToExport + * desc: calls a dialog box that lists all modules for a specific contact + * param: ExImContact - lpExImParam + * pModules - pointer to an ENUMLIST structure that retrieves the resulting list of modules + * hParent - handle to a window which should act as the parent of the created dialog + * return: 0 if user pressed ok, 1 on cancel + **/ +INT DlgExImModules_SelectModulesToExport(lpExImParam ExImContact, DB::CEnumList* pModules, HWND hParent) +{ + EXPORTDATA dat; + + dat.ExImContact = ExImContact; + dat.pModules = pModules; + return (IDOK != DialogBoxParam(ghInst, MAKEINTRESOURCE(IDD_EXPORT), hParent, SelectModulesToExport_DlgProc, (LPARAM)&dat)); +} + diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImModules.h b/plugins/UserInfoEx/ex_import/dlg_ExImModules.h new file mode 100644 index 0000000000..69ca65ddd3 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImModules.h @@ -0,0 +1,39 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImModules.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _DLG_EXIMMODULES_H_ +#define _DLG_EXIMMODULES_H_ + +#pragma once +#include "svc_ExImport.h" + +INT DlgExImModules_SelectModulesToExport(lpExImParam ExImContact, DB::CEnumList* pModules, HWND hParent); + +#endif /* _DLG_EXIMMODULES_H_ */ diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.cpp b/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.cpp new file mode 100644 index 0000000000..ae11ed0a5f --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.cpp @@ -0,0 +1,373 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImOpenSaveFile.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include "commonheaders.h" + +#ifdef _UNICODE + #include +#endif + +#include "m_db3xSA.h" +#include "dlg_ExImOpenSaveFile.h" + +#ifdef _UNICODE + +#define HKEY_MIRANDA_PLACESBAR _T("Software\\Miranda IM\\PlacesBar") +#define HKEY_WINPOL_PLACESBAR _T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\ComDlg32\\PlacesBar") + +static WNDPROC DefPlacesBarProc; + +/** + * This function maps the current users registry to a dummy key and + * changes the policy hive which is responsible for the places to be displayed, + * so the desired places are visible. + * + * @param nothing + * @return nothing + **/ +static VOID InitAlteredPlacesBar() +{ + // do not try it on a win9x Box + if (IsWinVer2000Plus()) + { + HKEY hkMiranda; + LONG result; + + // create or open temporary hive for miranda specific places + result = RegCreateKey(HKEY_CURRENT_USER, HKEY_MIRANDA_PLACESBAR, &hkMiranda); + if (SUCCEEDED(result)) + { + HKEY hkPlacesBar; + + // map the current users registry + RegOverridePredefKey(HKEY_CURRENT_USER, hkMiranda); + // open the policy key + result = RegCreateKey(HKEY_CURRENT_USER, HKEY_WINPOL_PLACESBAR, &hkPlacesBar); + // install the places bar + if (SUCCEEDED(result)) + { + DWORD dwFolderID; + LPSTR p; + CHAR szMirandaPath[MAX_PATH]; + CHAR szProfilePath[MAX_PATH]; + + // default places: Desktop, My Documents, My Computer + dwFolderID = 0; RegSetValueEx(hkPlacesBar, _T("Place0"), 0, REG_DWORD, (PBYTE)&dwFolderID, sizeof(DWORD)); + dwFolderID = 5; RegSetValueEx(hkPlacesBar, _T("Place1"), 0, REG_DWORD, (PBYTE)&dwFolderID, sizeof(DWORD)); + dwFolderID = 17; RegSetValueEx(hkPlacesBar, _T("Place2"), 0, REG_DWORD, (PBYTE)&dwFolderID, sizeof(DWORD)); + + // Miranda's installation path + GetModuleFileNameA(GetModuleHandle(NULL), szMirandaPath, SIZEOF(szMirandaPath)); + p = mir_strrchr(szMirandaPath, '\\'); + if (p) + { + RegSetValueExA(hkPlacesBar, "Place3", 0, REG_SZ, (PBYTE)szMirandaPath, (p - szMirandaPath) + 1); + } + + // Miranda's profile path + if (!CallService(MS_DB_GETPROFILEPATH, SIZEOF(szProfilePath), (LPARAM)szProfilePath)) + { + // only add if different from profile path + RegSetValueExA(hkPlacesBar, "Place4", 0, REG_SZ, (PBYTE)szProfilePath, (DWORD)strlen(szProfilePath) + 1); + } + + RegCloseKey(hkPlacesBar); + } + RegCloseKey(hkMiranda); + } + } +} + +/** + * name: ResetAlteredPlaceBars + * desc: Remove the mapping of current users registry + * and delete the temporary registry hive + * params: nothing + * return: nothing + **/ +static VOID ResetAlteredPlaceBars() +{ + // make sure not to call the following on a Win9x Box + if (IsWinVer2000Plus()) + { + RegOverridePredefKey(HKEY_CURRENT_USER, NULL); + SHDeleteKey(HKEY_CURRENT_USER, HKEY_MIRANDA_PLACESBAR); + } +} + +/** + * name: PlacesBarSubclassProc + * params: hWnd - handle, to control's window + * uMsg - the message to handle + * wParam - message dependend parameter + * lParam - message dependend parameter + * return: depends on message + **/ +static LRESULT PlacesBarSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case TB_ADDBUTTONS: + { + TBBUTTON *tbb = (TBBUTTON *)lParam; + TCHAR szBtnText[MAX_PATH]; + INT iString; + HWND hWndToolTip; + + if (tbb) + { + switch (tbb->idCommand) + { + // miranda button + case 41063: + ZeroMemory(szBtnText, sizeof(szBtnText)); + + mir_tcsncpy(szBtnText, TranslateT("Miranda IM"), SIZEOF(szBtnText)); + iString = SendMessage(hWnd, TB_ADDSTRING, NULL, (LPARAM)szBtnText); + if (iString != -1) tbb->iString = iString; + // set tooltip + hWndToolTip = (HWND)SendMessage(hWnd, TB_GETTOOLTIPS, NULL, NULL); + if (hWndToolTip) { + TOOLINFO ti; + + ZeroMemory(&ti, sizeof(ti)); + ti.cbSize = sizeof(ti); + ti.hwnd = hWnd; + ti.lpszText = TranslateT("Shows Miranda's installation directory."); + ti.uId = tbb->idCommand; + SendMessage(hWndToolTip, TTM_ADDTOOL, NULL, (LPARAM)&ti); + } + break; + // profile button + case 41064: + // set button text + iString = SendMessage(hWnd, TB_ADDSTRING, NULL, (LPARAM) TranslateT("Profile") ); + if (iString != -1) tbb->iString = iString; + + // set tooltip + hWndToolTip = (HWND)SendMessage(hWnd, TB_GETTOOLTIPS, NULL, NULL); + if (hWndToolTip) { + TOOLINFO ti; + + ZeroMemory(&ti, sizeof(ti)); + ti.cbSize = sizeof(ti); + ti.hwnd = hWnd; + ti.lpszText = TranslateT("Shows the directory with all your Miranda's profiles."); + ti.uId = tbb->idCommand; + SendMessage(hWndToolTip, TTM_ADDTOOL, NULL, (LPARAM)&ti); + } + // unmap registry and delete keys + ResetAlteredPlaceBars(); + break; + } + } + break; + } + } + return CallWindowProc(DefPlacesBarProc, hWnd, uMsg, wParam,lParam); +} + +/** + * name: OpenSaveFileDialogHook + * desc: it subclasses the places bar to provide the own interface for adding places + * params: hDlg - handle, to control's window + * uMsg - the message to handle + * wParam - message dependend parameter + * lParam - message dependend parameter + * return: depends on message + **/ +static UINT_PTR CALLBACK OpenSaveFileDialogHook(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) { + case WM_NOTIFY: + if (((LPNMHDR)lParam)->code == CDN_INITDONE) { + HWND hPlacesBar = GetDlgItem(GetParent(hDlg), ctl1); + + // we have a places bar? + if (hPlacesBar != NULL) { + InitAlteredPlacesBar(); + // finally subclass the places bar + DefPlacesBarProc = SubclassWindow(hPlacesBar, PlacesBarSubclassProc); + } + } + break; + case WM_DESTROY: + // unmap registry and delete keys + // (is to make it sure, if somehow the last places button was not added which also calls this function) + ResetAlteredPlaceBars(); + break; + } + return FALSE; +} + +#endif + +/** + * name: GetInitialDir + * desc: read the last vCard directory from database + * pszInitialDir - buffer to store the initial dir to (size must be MAX_PATH) + * return: nothing + **/ +static VOID GetInitialDir(LPSTR pszInitialDir) +{ + CHAR szRelative[MAX_PATH]; + + ZeroMemory(szRelative, SIZEOF(szRelative)); + + // is some standard path defined + if (!DB::Setting::GetStatic(0, MODNAME, "vCardPath", szRelative, SIZEOF(szRelative))) { + if (!CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)szRelative, (WPARAM)pszInitialDir)) + strcpy(pszInitialDir, szRelative); + } + else if (//try to use environment variables supported by pathpatch of db3xSA + !ServiceExists(MS_DB_GETPROFILEPATH_BASIC) || + !CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)PROFILEPATH "\\" PROFILENAME, (WPARAM)pszInitialDir) + ) { + // use standard path to absolute + if (!CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)"", (WPARAM)pszInitialDir)) + *pszInitialDir = 0; + } + else + *pszInitialDir = 0; +} + +/** + * name: SaveInitialDir + * desc: save the last vCard directory from database + * pszInitialDir - buffer to store the initial dir to (size must be MAX_PATH) + * return: nothing + **/ +static VOID SaveInitialDir(LPSTR pszInitialDir) +{ + CHAR szRelative[MAX_PATH]; + LPSTR p; + + if (p = mir_strrchr(pszInitialDir, '\\')) { + *p = 0; + if (CallService(MS_UTILS_PATHTORELATIVE, (WPARAM)pszInitialDir, (LPARAM)szRelative)) + DB::Setting::WriteAString(0, MODNAME, "vCardPath", szRelative); + else + DB::Setting::WriteAString(0, MODNAME, "vCardPath", pszInitialDir); + *p = '\\'; + } +} + +/** + * name: InitOpenFileNameStruct + * desc: initialize the openfilename structure + * params: pofn - OPENFILENAME structure to initialize + * hWndParent - parent window + * pszTitle - title for the dialog + * pszFilter - the filters to offer + * pszInitialDir - buffer to store the initial dir to (size must be MAX_PATH) + * pszFile - this is the buffer to store the file to (size must be MAX_PATH) + * return: nothing + **/ +static VOID InitOpenFileNameStruct(OPENFILENAMEA *pofn, HWND hWndParent, LPCSTR pszTitle, LPCSTR pszFilter, LPSTR pszInitialDir, LPSTR pszFile) +{ + ZeroMemory(pofn, sizeof(OPENFILENAME)); + + pofn->Flags = OFN_NONETWORKBUTTON|OFN_ENABLESIZING; + pofn->hwndOwner = hWndParent; + pofn->lpstrTitle = pszTitle; + pofn->lpstrFilter = pszFilter; + pofn->lpstrFile = pszFile; + pofn->nMaxFile = MAX_PATH; + pofn->lpstrDefExt = "xml"; + + GetInitialDir(pszInitialDir); + pofn->lpstrInitialDir = pszInitialDir; + +#ifdef _UNICODE + if (IsWinVer2000Plus()) { + pofn->lStructSize = sizeof (OPENFILENAME); + pofn->Flags |= OFN_ENABLEHOOK|OFN_EXPLORER; + pofn->lpfnHook = (LPOFNHOOKPROC)OpenSaveFileDialogHook; + } + else { + pofn->lStructSize = OPENFILENAME_SIZE_VERSION_400; + } +#else + pofn->lStructSize = sizeof (OPENFILENAME); +#endif +} + + +/** + * name: DlgExIm_OpenFileName + * desc: displayes a slightly modified OpenFileName DialogBox + * params: hWndParent - parent window + * pszTitle - title for the dialog + * pszFilter - the filters to offer + * pszFile - this is the buffer to store the file to (size must be MAX_PATH) + * return: -1 on error/abort or filter index otherwise + **/ +INT DlgExIm_OpenFileName(HWND hWndParent, LPCSTR pszTitle, LPCSTR pszFilter, LPSTR pszFile) +{ + OPENFILENAMEA ofn; + CHAR szInitialDir[MAX_PATH]; + + InitOpenFileNameStruct(&ofn, hWndParent, pszTitle, pszFilter, szInitialDir, pszFile); + ofn.Flags |= OFN_PATHMUSTEXIST; + if (!GetOpenFileNameA(&ofn)) { + DWORD dwError = CommDlgExtendedError(); + if (dwError) MsgErr(ofn.hwndOwner, LPGENT("The OpenFileDialog returned an error: %d!"), dwError); + return -1; + } + SaveInitialDir(pszFile); + return ofn.nFilterIndex; +} + +/** + * name: DlgExIm_SaveFileName + * desc: displayes a slightly modified SaveFileName DialogBox + * params: hWndParent - parent window + * pszTitle - title for the dialog + * pszFilter - the filters to offer + * pszFile - this is the buffer to store the file to (size must be MAX_PATH) + * return: -1 on error/abort or filter index otherwise + **/ +INT DlgExIm_SaveFileName(HWND hWndParent, LPCSTR pszTitle, LPCSTR pszFilter, LPSTR pszFile) +{ + OPENFILENAMEA ofn; + CHAR szInitialDir[MAX_PATH]; + + InitOpenFileNameStruct(&ofn, hWndParent, pszTitle, pszFilter, szInitialDir, pszFile); + ofn.Flags |= OFN_OVERWRITEPROMPT; + + if (!GetSaveFileNameA(&ofn)) { + DWORD dwError = CommDlgExtendedError(); + + if (dwError) MsgErr(ofn.hwndOwner, LPGENT("The SaveFileDialog returned an error: %d!"), dwError); + return -1; + } + SaveInitialDir(pszFile); + return ofn.nFilterIndex; +} diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.h b/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.h new file mode 100644 index 0000000000..eb47e9ab30 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImOpenSaveFile.h @@ -0,0 +1,39 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImOpenSaveFile.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _DLG_EXIMOPENSAVEFFILE_H_ +#define _DLG_EXIMOPENSAVEFFILE_H_ + +#pragma once + +INT DlgExIm_OpenFileName(HWND hWndParent, LPCSTR pszTitle, LPCSTR pszFilter, LPSTR pszFile); +INT DlgExIm_SaveFileName(HWND hWndParent, LPCSTR pszTitle, LPCSTR pszFilter, LPSTR pszFile); + +#endif /* _DLG_EXIMOPENSAVEFFILE_H_ */ diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImProgress.cpp b/plugins/UserInfoEx/ex_import/dlg_ExImProgress.cpp new file mode 100644 index 0000000000..9da4ee4373 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImProgress.cpp @@ -0,0 +1,244 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImProgress.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include "commonheaders.h" +#include "dlg_ExImProgress.h" + +/*********************************************************************************************************** + * windows procedure + ***********************************************************************************************************/ + +/** + * name: DlgProcProgress + * desc: dialog procedure for the progress dialog + * params: none + * return: nothing + **/ +LRESULT CALLBACK DlgProcProgress(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_INITDIALOG: + { + const ICONCTRL idIcon[] = { + { ICO_DLG_IMPORT, WM_SETICON, NULL }, + { ICO_DLG_IMPORT, STM_SETIMAGE, ICO_DLGLOGO }, + { ICO_BTN_CANCEL, BM_SETIMAGE, IDCANCEL } + }; + const INT numIconsToSet = DB::Setting::GetByte(SET_ICONS_BUTTONS, 1) ? SIZEOF(idIcon) : 2; + IcoLib_SetCtrlIcons(hDlg, idIcon, numIconsToSet); + + TranslateDialogDefault(hDlg); + SendDlgItemMessage(hDlg, IDCANCEL, BUTTONTRANSLATE, NULL, NULL); + SendDlgItemMessage(hDlg, IDC_PROGRESS, PBM_SETPOS, 0, 0); + SendDlgItemMessage(hDlg, IDC_PROGRESS2, PBM_SETPOS, 0, 0); + SetWindowLongPtr(hDlg, GWLP_USERDATA, 0); + UpdateWindow(hDlg); + break; + } + case WM_CTLCOLORSTATIC: + switch (GetWindowLongPtr((HWND)lParam, GWLP_ID)) { + //case IDC_HEADERBAR + case STATIC_WHITERECT: + case TXT_SETTING: + case IDC_PROGRESS: + case TXT_CONTACT: + case IDC_PROGRESS2: + //case ICO_DLGLOGO: + //case IDC_INFO: + SetBkColor((HDC)wParam, RGB(255, 255, 255)); + return (INT_PTR)GetStockObject(WHITE_BRUSH); + } + return FALSE; + case WM_COMMAND: + if (HIWORD(wParam) == BN_CLICKED) { + switch (LOWORD(wParam)) { + case IDCANCEL: + // in the progress dialog, use the user data to indicate that the user has pressed cancel + ShowWindow(hDlg, SW_HIDE); + SetWindowLongPtr(hDlg, GWLP_USERDATA, 1); + return TRUE; + } + } + break; + } + return FALSE; +} + +/** + * name: CProgress + * class: CProgress + * desc: create the progress dialog and return a handle as pointer to the datastructure + * params: none + * return: nothing + **/ +CProgress::CProgress() +{ + _dwStartTime = GetTickCount(); + _hDlg = CreateDialog(ghInst, MAKEINTRESOURCE(IDD_COPYPROGRESS), 0, (DLGPROC)DlgProcProgress); +} + +/** + * name: ~CProgress + * class: CProgress + * desc: destroy the progress dialog and its data structure + * params: none + * return: nothing + **/ +CProgress::~CProgress() +{ + if(IsWindow(_hDlg)) DestroyWindow(_hDlg); +} + +/** + * name: SetContactCount + * class: CProgress + * desc: number of contacts to show 100% for + * params: numContacts - the number of contacts + * return: nothing + **/ +VOID CProgress::SetContactCount(DWORD numContacts) +{ + if (_hDlg) { + HWND hProgress = GetDlgItem(_hDlg, IDC_PROGRESS2); + SendMessage(hProgress, PBM_SETRANGE32, 0, numContacts); + SendMessage(hProgress, PBM_SETPOS, 0, 0); + } +} + +/** + * name: SetSettingsCount + * class: CProgress + * desc: number of settings & events to show 100% for + * params: numSettings - the number of settings & events + * return: nothing + **/ +VOID CProgress::SetSettingsCount(DWORD numSettings) +{ + if (_hDlg) { + HWND hProgress = GetDlgItem(_hDlg, IDC_PROGRESS); + SendMessage(hProgress, PBM_SETRANGE32, 0, numSettings); + SendMessage(hProgress, PBM_SETPOS, 0, 0); + } +} + +/** + * name: Hide + * class: CProgress + * desc: hides the dialog + * params: none + * return: nothing + **/ +VOID CProgress::Hide() +{ + ShowWindow(_hDlg, SW_HIDE); +} + +/** + * name: Update + * class: CProgress + * desc: update the progress dialog + * params: nothing + * return: FALSE if user pressed cancel, TRUE otherwise + **/ +BOOLEAN CProgress::Update() +{ + MSG msg; + + // show dialog after one second + if (GetTickCount() > _dwStartTime + 1000) { + ShowWindow(_hDlg, SW_SHOW); + } + + UpdateWindow(_hDlg); + + while (PeekMessage(&msg, _hDlg, 0, 0, PM_REMOVE) != 0) { + if (!IsDialogMessage(_hDlg, &msg)) { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + } + return GetWindowLongPtr(_hDlg, GWLP_USERDATA) == 0; +} + +/** + * name: UpdateContact + * class: CProgress + * desc: increase contact's progressbar by one and set new text + * params: pszFormat - the text to display for the contact + * return: FALSE if user pressed cancel, TRUE otherwise + **/ +BOOLEAN CProgress::UpdateContact(LPCTSTR pszFormat, ...) +{ + if (_hDlg != NULL) { + HWND hProg = GetDlgItem(_hDlg, IDC_PROGRESS2); + if (pszFormat) { + TCHAR buf[MAX_PATH]; + va_list vl; + + va_start(vl, pszFormat); + mir_vsntprintf(buf, SIZEOF(buf), TranslateTS(pszFormat), vl); + va_end(vl); + SetDlgItemText(_hDlg, TXT_CONTACT, buf); + } + SendMessage(hProg, PBM_SETPOS, (INT)SendMessage(hProg, PBM_GETPOS, 0, 0) + 1, 0); + return Update(); + } + return TRUE; +} + +/** + * name: UpdateContact + * class: CProgress + * desc: increase setting's progressbar by one and set new text + * params: pszFormat - the text to display for the setting + * return: FALSE if user pressed cancel, TRUE otherwise + **/ +BOOLEAN CProgress::UpdateSetting(LPCTSTR pszFormat, ...) +{ + if (_hDlg != NULL) { + HWND hProg = GetDlgItem(_hDlg, IDC_PROGRESS); + if (pszFormat) { + TCHAR buf[MAX_PATH]; + TCHAR tmp[MAX_PATH]; + va_list vl; + + va_start(vl, pszFormat); + mir_vsntprintf(buf, SIZEOF(buf), TranslateTS(pszFormat), vl); + va_end(vl); + GetDlgItemText(_hDlg, TXT_SETTING, tmp, SIZEOF(tmp)); + if(mir_tcsicmp(tmp,buf)) + SetDlgItemText(_hDlg, TXT_SETTING, buf); + } + SendMessage(hProg, PBM_SETPOS, (INT)SendMessage(hProg, PBM_GETPOS, 0, 0) + 1, 0); + return Update(); + } + return TRUE; +} diff --git a/plugins/UserInfoEx/ex_import/dlg_ExImProgress.h b/plugins/UserInfoEx/ex_import/dlg_ExImProgress.h new file mode 100644 index 0000000000..55ab614cfe --- /dev/null +++ b/plugins/UserInfoEx/ex_import/dlg_ExImProgress.h @@ -0,0 +1,56 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/dlg_ExImProgress.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _DLG_EXIMPROGRESS_H_ +#define _DLG_EXIMPROGRESS_H_ + +#pragma once + +class CProgress +{ + HWND _hDlg; + DWORD _dwStartTime; + + BOOLEAN Update(); + +public: + CProgress(); + ~CProgress(); + + VOID Hide(); + + VOID SetContactCount(DWORD numContacts); + VOID SetSettingsCount(DWORD numSettings); + + BOOLEAN UpdateContact(LPCTSTR pszFormat, ...); + BOOLEAN UpdateSetting(LPCTSTR pszFormat, ...); +}; + +#endif /* _DLG_EXIMPROGRESS_H_ */ diff --git a/plugins/UserInfoEx/ex_import/mir_rfcCodecs.h b/plugins/UserInfoEx/ex_import/mir_rfcCodecs.h new file mode 100644 index 0000000000..0fe287ec93 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/mir_rfcCodecs.h @@ -0,0 +1,371 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/mir_rfcCodecs.h $ +Revision : $Revision: 190 $ +Last change on : $Date: 2010-09-14 14:32:57 +0400 (ะ’ั‚, 14 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include + +//Not including CRLFs +//NOTE: For BASE64 and UUENCODE, this actually +//represents the amount of unencoded characters +//per line +#define TSSMTPMAX_QP_LINE_LENGTH 76 +#define TSSMTPMAX_BASE64_LINE_LENGTH 57 +#define TSSMTPMAX_UUENCODE_LINE_LENGTH 45 + +//======================================================================= +// Base64Encode/Base64Decode +// compliant with RFC 2045 +//======================================================================= +// +#define BASE64_FLAG_NONE 0 +#define BASE64_FLAG_NOPAD 1 +#define BASE64_FLAG_NOCRLF 2 + +inline INT_PTR Base64EncodeGetRequiredLength(INT_PTR nSrcLen, DWORD dwFlags = BASE64_FLAG_NONE) +{ + INT_PTR nRet = nSrcLen*4/3; + + if ((dwFlags & BASE64_FLAG_NOPAD) == 0) + nRet += nSrcLen % 3; + + INT_PTR nCRLFs = nRet / 76 + 3; + INT_PTR nOnLastLine = nRet % 76; + + if (nOnLastLine) { + if (nOnLastLine % 4) + nRet += 4 - (nOnLastLine % 4); + } + + nCRLFs *= 2; + + if ((dwFlags & BASE64_FLAG_NOCRLF) == 0) + nRet += nCRLFs; + + return nRet; +} + +inline INT_PTR Base64DecodeGetRequiredLength(INT_PTR nSrcLen) +{ + return nSrcLen; +} + +inline BOOL Base64Encode( + const BYTE *pbSrcData, + INT_PTR nSrcLen, + LPSTR szDest, + INT_PTR *pnDestLen, + DWORD dwFlags = BASE64_FLAG_NONE) +{ + static const char s_chBase64EncodingTable[64] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', + 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', + 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' }; + + if (!pbSrcData || !szDest || !pnDestLen) + return FALSE; + + INT_PTR nWritten(0); + INT_PTR nLen1((nSrcLen / 3) * 4); + INT_PTR nLen2(nLen1 / 76); + INT_PTR nLen3(19); + INT_PTR i, j, k, n; + + for (i = 0; i <= nLen2; i++) { + if (i == nLen2) + nLen3 = (nLen1 % 76) / 4; + + for (j = 0; j < nLen3; j++) { + DWORD dwCurr(0); + for (INT_PTR n = 0; n < 3; n++) { + dwCurr |= *pbSrcData++; + dwCurr <<= 8; + } + for (k = 0; k < 4; k++) { + BYTE b = (BYTE)(dwCurr >> 26); + *szDest++ = s_chBase64EncodingTable[b]; + dwCurr <<= 6; + } + } + nWritten += nLen3 * 4; + + if ((dwFlags & BASE64_FLAG_NOCRLF) == 0) { + *szDest++ = '\r'; + *szDest++ = '\n'; + *szDest++ = '\t'; // as vcards have tabs in second line of binary data + nWritten += 3; + } + } + + if (nWritten && (dwFlags & BASE64_FLAG_NOCRLF) == 0) { + szDest -= 2; + nWritten -= 2; + } + + nLen2 = nSrcLen % 3 ? nSrcLen % 3 + 1 : 0; + if (nLen2) { + DWORD dwCurr(0); + for (n = 0; n < 3; n++) + { + if (n < (nSrcLen % 3)) + dwCurr |= *pbSrcData++; + dwCurr <<= 8; + } + for (k = 0; k < nLen2; k++) { + BYTE b = (BYTE)(dwCurr >> 26); + *szDest++ = s_chBase64EncodingTable[b]; + dwCurr <<= 6; + } + nWritten+= nLen2; + if ((dwFlags & BASE64_FLAG_NOPAD) == 0) { + nLen3 = nLen2 ? 4 - nLen2 : 0; + for (j = 0; j < nLen3; j++) { + *szDest++ = '='; + } + nWritten+= nLen3; + } + } + + *pnDestLen = nWritten; + return TRUE; +} + +inline INT_PTR DecodeBase64Char(UINT ch) throw() +{ + // returns -1 if the character is invalid + // or should be skipped + // otherwise, returns the 6-bit code for the character + // from the encoding table + if (ch >= 'A' && ch <= 'Z') + return ch - 'A' + 0; // 0 range starts at 'A' + if (ch >= 'a' && ch <= 'z') + return ch - 'a' + 26; // 26 range starts at 'a' + if (ch >= '0' && ch <= '9') + return ch - '0' + 52; // 52 range starts at '0' + if (ch == '+') + return 62; + if (ch == '/') + return 63; + return -1; +} + +inline BOOL Base64Decode(LPCSTR szSrc, INT_PTR nSrcLen, BYTE *pbDest, INT_PTR *pnDestLen) throw() +{ + // walk the source buffer + // each four character sequence is converted to 3 bytes + // CRLFs and =, and any characters not in the encoding table + // are skiped + + if (szSrc == NULL || pnDestLen == NULL) { + return FALSE; + } + + LPCSTR szSrcEnd = szSrc + nSrcLen; + INT_PTR nWritten = 0; + + BOOL bOverflow = (pbDest == NULL) ? TRUE : FALSE; + + while (szSrc < szSrcEnd) { + DWORD dwCurr = 0; + INT_PTR i; + INT_PTR nBits = 0; + for (i=0; i<4; i++) { + if (szSrc >= szSrcEnd) + break; + INT_PTR nCh = DecodeBase64Char(*szSrc); + szSrc++; + if (nCh == -1) { + // skip this char + i--; + continue; + } + dwCurr <<= 6; + dwCurr |= nCh; + nBits += 6; + } + + if (!bOverflow && nWritten + (nBits/8) > (*pnDestLen)) + bOverflow = TRUE; + + // dwCurr has the 3 bytes to write to the output buffer + // left to right + dwCurr <<= 24-nBits; + for (i=0; i> 16); + pbDest++; + } + dwCurr <<= 8; + nWritten++; + } + } + *pnDestLen = nWritten; + return bOverflow ? FALSE:TRUE; +} + +//======================================================================= +// Quoted Printable encode/decode +// compliant with RFC 2045 +//======================================================================= +// +#define TSSMTPQPENCODE_DOT 1 +#define TSSMTPQPENCODE_TRAILING_SOFT 2 + +inline INT_PTR QPEncodeGetRequiredLength(INT_PTR nSrcLen) +{ + INT_PTR nRet = 3*((3*nSrcLen)/(TSSMTPMAX_QP_LINE_LENGTH-8)); + nRet += 3*nSrcLen; + nRet += 3; + return nRet; +} + +inline INT_PTR QPDecodeGetRequiredLength(INT_PTR nSrcLen) +{ + return nSrcLen; +} + +inline BOOL QPEncode(BYTE* pbSrcData, INT_PTR nSrcLen, LPSTR szDest, INT_PTR* pnDestLen, BOOLEAN *bEncoded, DWORD dwFlags = 0) +{ + //The hexadecimal character set + static const CHAR s_chHexChars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + 'A', 'B', 'C', 'D', 'E', 'F'}; + INT_PTR nRead = 0, nWritten = 0, nLineLen = 0; + CHAR ch; + BOOLEAN bChanged = FALSE; + + + if (!pbSrcData || !szDest || !pnDestLen) { + return FALSE; + } + + while (nRead < nSrcLen) { + ch = *pbSrcData++; + nRead++; + if (nLineLen == 0 && ch == '.' && (dwFlags & TSSMTPQPENCODE_DOT)) { + *szDest++ = '.'; + nWritten++; + nLineLen++; + bChanged = TRUE; + } + if ((ch > 32 && ch < 61) || (ch > 61 && ch < 127)) { + *szDest++ = ch; + nWritten++; + nLineLen++; + } + else + if ((ch == ' ' || ch == '\t') && (nLineLen < (TSSMTPMAX_QP_LINE_LENGTH - 12))) { + *szDest++ = ch; + nWritten++; + nLineLen++; + } + else { + *szDest++ = '='; + *szDest++ = s_chHexChars[(ch >> 4) & 0x0F]; + *szDest++ = s_chHexChars[ch & 0x0F]; + nWritten += 3; + nLineLen += 3; + bChanged = TRUE; + } + if (nLineLen >= (TSSMTPMAX_QP_LINE_LENGTH - 11)) { + *szDest++ = '='; + *szDest++ = '\r'; + *szDest++ = '\n'; + nLineLen = 0; + nWritten += 3; + bChanged = TRUE; + } + } + if (dwFlags & TSSMTPQPENCODE_TRAILING_SOFT) { + *szDest++ = '='; + *szDest++ = '\r'; + *szDest++ = '\n'; + nWritten += 3; + bChanged = TRUE; + } + *pnDestLen = nWritten; + if (bEncoded) *bEncoded = bChanged; + return TRUE; +} + + +inline BOOL QPDecode(BYTE* pbSrcData, INT_PTR nSrcLen, LPSTR szDest, INT_PTR* pnDestLen, DWORD dwFlags = 0) +{ + if (!pbSrcData || !szDest || !pnDestLen) + { + return FALSE; + } + + INT_PTR nRead = 0, nWritten = 0, nLineLen = -1; + char ch; + while (nRead <= nSrcLen) + { + ch = *pbSrcData++; + nRead++; + nLineLen++; + if (ch == '=') + { + //if the next character is a digit or a character, convert + if (nRead < nSrcLen && (isdigit(*pbSrcData) || isalpha(*pbSrcData))) + { + char szBuf[5]; + szBuf[0] = *pbSrcData++; + szBuf[1] = *pbSrcData++; + szBuf[2] = '\0'; + char* tmp = '\0'; + *szDest++ = (BYTE)strtoul(szBuf, &tmp, 16); + nWritten++; + nRead += 2; + continue; + } + //if the next character is a carriage return or line break, eat it + if (nRead < nSrcLen && *pbSrcData == '\r' && (nRead+1 < nSrcLen) && *(pbSrcData+1)=='\n') + { + pbSrcData++; + nRead++; + nLineLen = -1; + continue; + } + return FALSE; + } + if (ch == '\r' || ch == '\n') + { + nLineLen = -1; + continue; + } + if ((dwFlags & TSSMTPQPENCODE_DOT) && ch == '.' && nLineLen == 0) + { + continue; + } + *szDest++ = ch; + nWritten++; + } + + *pnDestLen = nWritten-1; + return TRUE; +} diff --git a/plugins/UserInfoEx/ex_import/svc_ExImINI.cpp b/plugins/UserInfoEx/ex_import/svc_ExImINI.cpp new file mode 100644 index 0000000000..f3c4ce6362 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImINI.cpp @@ -0,0 +1,547 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImINI.cpp $ +Revision : $Revision: 196 $ +Last change on : $Date: 2010-09-21 03:24:30 +0400 (ะ’ั‚, 21 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +/** + * system & local includes: + **/ +#include "commonheaders.h" +#include "classExImContactBase.h" +#include "dlg_ExImModules.h" +#include "svc_ExImport.h" +#include "svc_ExImINI.h" + +/** + * Miranda includes + **/ +#include +#include + +/*********************************************************************************************************** + * exporting stuff + ***********************************************************************************************************/ + +/** + * name: ExportModule + * desc: write all settings from a database module to file + * param: hContact - handle of contact the module is owned from + * pszModule - name of the module to save + * file - file to write the settings to + * return nothing + **/ +static VOID ExportModule(HANDLE hContact, LPCSTR pszModule, FILE* file) +{ + DB::CEnumList Settings; + + if (!Settings.EnumSettings(hContact, pszModule)) + { + DBVARIANT dbv; + LPSTR here; + WORD j; + INT i; + LPSTR pszSetting; + //char tmp[32]; + + // print the module header.. + fprintf(file, "\n[%s]\n", pszModule); + + for (i = 0; i < Settings.getCount(); i++) + { + pszSetting = Settings[i]; + + if (!DB::Setting::GetAsIs(hContact, pszModule, pszSetting, &dbv)) + { + switch (dbv.type) + { + case DBVT_BYTE: + { + fprintf(file, "%s=b%u\n", pszSetting, dbv.bVal); + } + break; + + case DBVT_WORD: + { + fprintf(file, "%s=w%u\n", pszSetting, dbv.wVal); + } + break; + + case DBVT_DWORD: + { + fprintf(file, "%s=d%u\n", pszSetting, dbv.dVal); + } + break; + + case DBVT_ASCIIZ: + case DBVT_UTF8: + { + for (here = dbv.pszVal; here && *here; here++) + { + switch (*here) { + // convert \r to STX + case '\r': + *here = 2; + break; + + // convert \n to ETX + case '\n': + *here = 3; + } + } + if (dbv.type == DBVT_UTF8) + fprintf(file, "%s=u%s\n", pszSetting, dbv.pszVal); + else + fprintf(file, "%s=s%s\n", pszSetting, dbv.pszVal); + } + break; + + case DBVT_BLOB: + { + fprintf(file, "%s=n", pszSetting); + for (j = 0; j < dbv.cpbVal; j++) + { + fprintf(file, "%02X ", (BYTE)dbv.pbVal[j]); + } + fputc('\n', file); + } + break; + } + DB::Variant::Free(&dbv); + } + } + } +} + +/** + * name: ExportContact + * desc: Exports a certain contact to an ini file. + * param: hContact - contact to export or -1 to export all contacts + * pModules - module to export, NULL to export all modules of a contact + * file - ini file to write the contact to + **/ +static BOOLEAN ExportContact(HANDLE hContact, DB::CEnumList* pModules, FILE* file) +{ + CExImContactBase vcc; + + if (pModules) + { + if ((vcc = hContact) >= NULL) + { + INT i; + LPSTR p; + + vcc.toIni(file, pModules->getCount()-1); + + for (i = 0; i < pModules->getCount(); i++) + { + p = (*pModules)[i]; + + /*Filter/ + if (mir_stricmp(p, "Protocol"))*/ + { + ExportModule(hContact, p, file); + } + } + return TRUE; + } + } + return FALSE; +} + +/** + * name: SvcExImINI_Export + * desc: Exports a certain contact or all contacts to an ini file. + * param: hContact - contact to export or -1 to export all contacts + * pszFileName - ini-filename to write the contact to + **/ +INT SvcExImINI_Export(lpExImParam ExImContact, LPCSTR pszFileName) +{ + FILE* file; + errno_t err; + DB::CEnumList Modules; + SYSTEMTIME now; + HANDLE hContact; + + if (!DlgExImModules_SelectModulesToExport(ExImContact, &Modules, NULL)) + { + if ((err = fopen_s(&file, pszFileName, "wt")) != NULL) + { + MsgErr(NULL, + LPGENT("The ini-file \"%s\"\nfor saving contact information could not be opened."), + pszFileName); + return 1; + } + + SetCursor(LoadCursor(NULL, IDC_WAIT)); + + // write header + GetLocalTime(&now); + fprintf(file, + ";DATE = %04d-%02d-%02d %02d:%02d:%02d\n\n", + now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond + ); + + if (Modules.getCount() == 0) + { + Modules.EnumModules(); + } + + // hContact == -1 export entire db. + if (ExImContact->Typ != EXIM_CONTACT) + { + // Owner + ExportContact(NULL, &Modules, file); + fprintf(file, "\n\n"); + // Contacts + for (hContact = DB::Contact::FindFirst(); + hContact != NULL; + hContact = DB::Contact::FindNext(hContact)) + { + ExportContact(hContact, &Modules, file); + fprintf(file, "\n\n"); + } + } + // export only one contact + else + { + ExportContact(ExImContact->hContact, &Modules, file); + } + + if (file) + fclose(file); + SetCursor(LoadCursor(NULL, IDC_ARROW)); + } + return 0; +} + +/*********************************************************************************************************** + * importing stuff + ***********************************************************************************************************/ + +LPSTR strnrchr(LPSTR string, INT ch, DWORD len) +{ + LPSTR start = (LPSTR)string; + + string += len; /* find end of string */ + /* search towards front */ + while (--string != start && *string != (CHAR)ch); + if (*string == (CHAR)ch) /* char found ? */ + return ((LPSTR)string); + return(NULL); +} + +/** + * name: ImportreadLine + * desc: read exactly one line into a buffer and return its pointer. Size of buffer is managed. + * param: file - pointer to a file + * string - the string to write the read line to + * return: pointer to the buffer on success or NULL on error + **/ +static DWORD ImportreadLine(FILE* file, LPSTR &str) +{ + CHAR c; + DWORD l = 0; + BOOLEAN bComment = 0; + + str[0] = 0; + while (!feof(file)) { + switch (c = fgetc(file)) { + case EOF: + // reading error + if (ferror(file)) { + MIR_FREE(str); + return 0; + } + // end of line & file + return l; + + case '\r': + case '\n': + // ignore empty lines + if (l == 0) { + bComment = 0; + continue; + } + return l; + + case ';': + // found a comment line + bComment |= l == 0; + case '\t': + case ' ': + // ignore space and tab at the beginning of the line + if (l == 0) break; + + default: + if (!bComment) { + str = mir_strncat_c(str, c); + l++; + } + break; + } + } + return 0; +} + +/** + * name: ImportFindContact + * desc: This function decodes the given line, which is already identified to be a contact line. + * The resulting information is matcht to the given hContact if it isn't NULL. + * Otherwise all existing contacts are matched. + * param: hContact - handle to contact to match or NULL to match all existing + * pszBuf - pointer to the buffer holding the string of the current line in the ini.-file + * cchBuf - character count of the buffer + * return: handle to the contact that matches the information or NULL if no match + **/ +static HANDLE ImportFindContact(HANDLE hContact, LPSTR &strBuf, BOOLEAN bCanCreate) +{ + CExImContactBase vcc; + + vcc.fromIni(strBuf); + if (vcc.handle() != INVALID_HANDLE_VALUE) { + //if (vcc.isHandle(hContact)) + // return hContact; + return vcc.handle(); + } + else if (bCanCreate) + return vcc.toDB(); + + return vcc.handle(); +} + +/** + * name: ImportSetting + * desc: This function writes a line identified as a setting to the database + * param: hContact - handle to contact to match or NULL to match all existing + * pszModule - module to write the setting to + * strLine - string with the setting and its value to write to db + * return: 0 if writing was ok, 1 otherwise + **/ +INT ImportSetting(HANDLE hContact, LPCSTR pszModule, LPSTR &strLine) +{ + DBCONTACTWRITESETTING cws; + LPSTR end, value; + size_t numLines = 0; + size_t brk; + LPSTR pszLine = strLine; + + // check Module and filter "Protocol" + if (!pszModule || !*pszModule || mir_strncmp(pszModule,"Protocol",8) == 0) + return 1; + if ((end = value = mir_strchr(pszLine, '=')) == NULL) + return 1; + + // truncate setting string if it has spaces at the end + do { + if (end == pszLine) + return 1; + *(end--) = 0; + } while (*end == '\t' || *end == ' ' || *end < 27); + + cws.szModule = pszModule; + cws.szSetting = pszLine; + + // skip spaces from the beginning of the value + do { + value++; + // if the value is empty, delete it from db + if (*value == '\0') + return DB::Setting::Delete(hContact, pszModule, pszLine); + } while (*value == '\t' || *value == ' '); + + // decode database type and value + switch (*(value++)) { + case 'b': + case 'B': + if (brk = strspn(value, "0123456789-")) + *(value + brk) = 0; + cws.value.type = DBVT_BYTE; + cws.value.bVal = (BYTE)atoi(value); + break; + case 'w': + case 'W': + if (brk = strspn(value, "0123456789-")) + *(value + brk) = 0; + cws.value.type = DBVT_WORD; + cws.value.wVal = (WORD)atoi(value); + break; + case 'd': + case 'D': + if (brk = strspn(value, "0123456789-")) + *(value + brk) = 0; + cws.value.type = DBVT_DWORD; + cws.value.dVal = (DWORD)_atoi64(value); + break; + case 's': + case 'S': + case 'u': + case 'U': + for (end = value; end && *end; end++) { + switch (*end) { + // convert STX back to \r + case 2: + *end = '\r'; + break; + // convert ETX back to \n + case 3: + *end = '\n'; + break; + } + } + switch (*(value - 1)) { + case 's': + case 'S': + cws.value.type = DBVT_ASCIIZ; + cws.value.pszVal = value; + break; + case 'u': + case 'U': + cws.value.type = DBVT_UTF8; + cws.value.pszVal = value; + break; + } + break; + case 'n': + case 'N': + { + PBYTE dest; + cws.value.type = DBVT_BLOB; + cws.value.cpbVal = (WORD)mir_strlen(value) / 3; + cws.value.pbVal = (PBYTE)value; + for ( dest = cws.value.pbVal, value = strtok(value, " "); + value && *value; + value = strtok(NULL, " ")) + *(dest++) = (BYTE)strtol(value, NULL, 16); + *dest = 0; + break; + } + default: + cws.value.type = DBVT_DELETED; + //return 1; + } + return CallService(MS_DB_CONTACT_WRITESETTING, (WPARAM)hContact, (LPARAM)&cws); +} + +/** + * name: Import + * desc: This function imports an ini file + * param: hContact - handle to contact to match or NULL to match all existing + * file - module to write the setting to + * strLine - string with the setting and its value to write to db + * return: 0 if writing was ok, 1 otherwise + **/ +INT SvcExImINI_Import(HANDLE hContact, LPCSTR pszFileName) +{ + FILE *file; + HANDLE hNewContact = INVALID_HANDLE_VALUE; + DWORD end, + numLines = 0; + CHAR szModule[MAXSETTING] = {0}; + WORD numContactsInFile = 0, // number of contacts in the inifile + numContactsAdded = 0; // number of contacts, that were added to the database + CHAR *strBuf = (CHAR *) mir_alloc(1); + *strBuf = 0; + + if (file = fopen(pszFileName, "rt")) { + SetCursor(LoadCursor(NULL, IDC_WAIT)); + + while (ImportreadLine(file, strBuf)) { + numLines++; + + // contact was found and imported + if (hContact != INVALID_HANDLE_VALUE && hNewContact != INVALID_HANDLE_VALUE) + break; + + // importing settings is only valid vor the main menu item + if (hContact == INVALID_HANDLE_VALUE) { + if (!strncmp(strBuf, "SETTINGS:", 9)) { + *szModule = 0; + hNewContact = NULL; + continue; + } + } + + // there are some modules of a contact (import only if contact exist) + if (!strncmp(strBuf, "FROM CONTACT:", 13)) { + strBuf = mir_strnerase(strBuf, 0, 13); + while (strBuf[0] == ' ' || strBuf[0] == '\t') + strBuf = mir_strnerase(strBuf, 0, 1); + + numContactsInFile++; + if ((hNewContact = ImportFindContact(hContact, strBuf, FALSE)) != INVALID_HANDLE_VALUE) + numContactsAdded++; + continue; + } + + // there is a contact to import / add + if (!strncmp(strBuf, "CONTACT:", 8)) { + strBuf = mir_strnerase(strBuf, 0, 8); + while (strBuf[0] == ' ' || strBuf[0] == '\t') + strBuf = mir_strnerase(strBuf, 0, 1); + + *szModule = 0; + numContactsInFile++; + if ((hNewContact = ImportFindContact(hContact, strBuf, TRUE)) != INVALID_HANDLE_VALUE) + numContactsAdded++; + continue; + } + + // read modules and settings only for valid contacts + if (hNewContact != INVALID_HANDLE_VALUE) { + // found a module line + if (strBuf[0] == '[' && (end = (strchr(strBuf, ']') - strBuf)) > 0) { + mir_strncpy(szModule, &strBuf[1], end); + continue; + } + // try to import a setting + ImportSetting(hNewContact, szModule, strBuf); + } + } //end while + fclose(file); + mir_free(strBuf); + SetCursor(LoadCursor(NULL, IDC_ARROW)); + + // the contact was not found in the file + if (numContactsInFile > 0 && !numContactsAdded) { + MsgErr(NULL, + LPGENT("None of the %d contacts, stored in the ini-file, match the selected contact!\nNothing will be imported"), + numContactsInFile); + } + // Import complete + else{ + MsgBox(NULL, MB_ICON_INFO, LPGENT("Import complete"), LPGENT("Some basic statistics"), + LPGENT("Added %d of %d contacts stored in the ini-file."), + numContactsAdded, numContactsInFile); + } + return 0; + } + MsgErr(NULL, + LPGENT("The ini-file \"%s\"\nfor reading contact information could not be opened."), + pszFileName); + return 1; +} diff --git a/plugins/UserInfoEx/ex_import/svc_ExImINI.h b/plugins/UserInfoEx/ex_import/svc_ExImINI.h new file mode 100644 index 0000000000..63ecce7cbd --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImINI.h @@ -0,0 +1,39 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImINI.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _SVC_EXIMINI_H_ +#define _SVC_EXIMINI_H_ + +#pragma once + + INT SvcExImINI_Export(lpExImParam ExImContact, LPCSTR pszFileName); + INT SvcExImINI_Import(HANDLE hContact, LPCSTR pszFileName); + +#endif /* _SVC_EXIMINI_H_ */ diff --git a/plugins/UserInfoEx/ex_import/svc_ExImVCF.cpp b/plugins/UserInfoEx/ex_import/svc_ExImVCF.cpp new file mode 100644 index 0000000000..53faf60c02 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImVCF.cpp @@ -0,0 +1,1364 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImVCF.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +/** + * system & local includes: + **/ +#include "commonheaders.h" +#include "../svc_reminder.h" +#include "svc_ExImport.h" +#include "svc_ExImVCF.h" + +#include + +#define BLOCKSIZE 260 + +#define DELIM ";" + +/** + * name: IsUSASCII + * desc: determine whether the pBuffer string is ascii or not + * param: pBuffer - string to check + * + * return TRUE or FALSE + **/ +BOOLEAN IsUSASCII(LPCSTR pBuffer, LPDWORD pcbBuffer) +{ + BYTE c; + PBYTE s = (PBYTE)pBuffer; + BOOLEAN bIsUTF = 0; + + if (s == NULL) return 1; + while ((c = *s++) != 0) { + if (c < 0x80) continue; + if (!pcbBuffer) return 0; + bIsUTF = 1; + } + if (pcbBuffer) *pcbBuffer = s - (PBYTE)pBuffer; + return !bIsUTF; +} + +/* +========================================================================================================================= + class CLineBuffer +========================================================================================================================= +*/ + + +/** + * name: CLineBuffer::CLineBuffer + * desc: initializes all members on construction of the class + * param: none + * + * return: nothing + **/ +CLineBuffer::CLineBuffer() +{ + _pVal = NULL; + _pTok = NULL; + _cbVal = 0; + _cbUsed = 0; +} + +/** + * name: CLineBuffer::~CLineBuffer + * desc: frees up all memory on class destruction + * param: none + * + * return: nothing + **/ +CLineBuffer::~CLineBuffer() +{ + if (_pVal) mir_free(_pVal); +} + +/** + * name: CLineBuffer::_resizeBuf + * desc: ensure, the right size for the buffer + * param: cbReq - number of bytes required for the next operation + * + * return: TRUE if reallocation successful or memoryblock is large enough, FALSE otherwise + **/ +BOOLEAN CLineBuffer::_resizeBuf(const size_t cbReq) +{ + if (cbReq > _cbVal - _cbUsed) { + if (!(_pVal = (PBYTE)mir_realloc(_pVal, BLOCKSIZE + _cbVal + 1))) { + _cbVal = 0; + _cbUsed = 0; + return FALSE; + } + _cbVal += BLOCKSIZE; + } + return TRUE; +} + +/** + * name: CLineBuffer::operator = + * desc: applys the specified string to the class's _pVal member + * param: szVal - string to apply + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator = (const CHAR *szVal) +{ + if (szVal) { + size_t cbLength = mir_strlen(szVal); + + _cbUsed = 0; + if (_resizeBuf(cbLength)) { + memcpy(_pVal, szVal, cbLength); + _cbUsed += cbLength; + return cbLength; + } + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified string to the class's _pVal member + * param: szVal - string to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const CHAR *szVal) +{ + if (szVal) { + size_t cbLength = mir_strlen(szVal); + + if (_resizeBuf(cbLength)) { + memcpy(_pVal + _cbUsed, szVal, cbLength); + _cbUsed += cbLength; + return cbLength; + } + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified unicode string to the class's _pVal member + * param: wszVal - string to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const WCHAR *wszVal) +{ + if (wszVal) { + size_t cbLength = mir_wcslen(wszVal); + CHAR* szVal = mir_u2a(wszVal); + + if (szVal) { + size_t cbLength = mir_strlen(szVal); + + if (_resizeBuf(cbLength)) { + memcpy(_pVal + _cbUsed, szVal, cbLength); + _cbUsed += cbLength; + return cbLength; + } + } + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified character's value (-127 ... 128) as a string to the class's _pVal member + * param: cVal - character whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const CHAR cVal) +{ + if (_resizeBuf(1)) { + *(_pVal + _cbUsed++) = cVal; + return 1; + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified bytes's value (0 ... 255) as a string to the class's _pVal member + * param: bVal - character whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const BYTE bVal) +{ + size_t cbLength = 3; + + if (_resizeBuf(cbLength)) { + cbLength = mir_strlen(_itoa(bVal, (LPSTR)(_pVal + _cbUsed), 10)); + _cbUsed += cbLength; + return cbLength; + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified short integer as a string to the class's _pVal member + * param: sVal - short integer whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const SHORT sVal) +{ + size_t cbLength = 6; + + if (_resizeBuf(cbLength)) { + cbLength = mir_strlen(_itoa(sVal, (LPSTR)(_pVal + _cbUsed), 10)); + _cbUsed += cbLength; + return cbLength; + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified word as a string to the class's _pVal member + * param: wVal - word whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const WORD wVal) +{ + size_t cbLength = 5; + + if (_resizeBuf(cbLength)) { + cbLength = mir_strlen(_itoa(wVal, (LPSTR)(_pVal + _cbUsed), 10)); + _cbUsed += cbLength; + return cbLength; + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified long integer as a string to the class's _pVal member + * param: lVal - long integer whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const LONG lVal) +{ + size_t cbLength = 11; + + if (_resizeBuf(cbLength)) { + cbLength = mir_strlen(_ltoa(lVal, (LPSTR)(_pVal + _cbUsed), 10)); + _cbUsed += cbLength; + return cbLength; + } + return 0; +} + +/** + * name: CLineBuffer::operator + + * desc: appends the specified double word integer as a string to the class's _pVal member + * param: dVal - double word integer whose value to add + * + * return: length of the string, added + **/ +size_t CLineBuffer::operator + (const DWORD dVal) +{ + size_t cbLength = 10; + + if (_resizeBuf(cbLength)) { + cbLength = mir_strlen(_ltoa(dVal, (LPSTR)(_pVal + _cbUsed), 10)); + _cbUsed += cbLength; + return cbLength; + } + return 0; +} + +/** + * name: CLineBuffer::GetLength + * desc: returns the length of the _pVal string + * param: nothing + * + * return: length of the string + **/ +size_t CLineBuffer::GetLength() +{ + return _cbUsed; +} + +/** + * name: CLineBuffer::GetBuffer + * desc: returns the pointer of the _pVal string + * !!Use carefully + * param: nothing + * + * return: pointer to _pVal + **/ +LPCSTR CLineBuffer::GetBuffer() +{ + return (LPCSTR)_pVal; +} + +/** + * name: CLineBuffer::TruncToLength + * desc: resulting string has cbLength characters + * param: cbLength - desired length of the string member + * + * return: nothing + **/ +VOID CLineBuffer::TruncToLength(size_t cbLength) +{ + if (cbLength < _cbUsed) { + _cbUsed = cbLength; + _pVal[cbLength] = 0; + } +} + +/** + * name: CLineBuffer::TruncToLength + * desc: resulting string is Truncated by the specified number of bytes + * param: count - desired count of bytes to Truncate + * + * return: nothing + **/ +VOID CLineBuffer::Truncate(size_t count) +{ + if (_cbUsed <= count) { + _cbUsed = 0; + *_pVal = 0; + } + else { + _cbUsed -= count; + _pVal[_cbUsed] = 0; + } +} + +/** + * name: CLineBuffer::TruncateSMS + * desc: resulting string is Truncated by the " SMS" if found + * param: nothing + * + * return: nothing + **/ +VOID CLineBuffer::TruncateSMS() +{ + if (!strncmp((LPSTR)(_pVal + _cbUsed - 4), " SMS", 4)) { + _cbUsed -= 4; + _pVal[_cbUsed] = 0; + } +} + +/** + * name: CLineBuffer::fput + * desc: string member is written to the specified stream and Truncated to zero afterwards + * param: outfile - the stream to write to + * + * return: nothing + **/ +VOID CLineBuffer::fput(FILE *outfile) +{ + if (_pVal) { + _pVal[_cbUsed] = 0; + fputs((LPCSTR)_pVal, outfile); + _cbUsed = 0; + *_pVal = 0; + } +} + +/** + * name: CLineBuffer::fputEncoded + * desc: string member is encoded and written to the specified stream and Truncated to zero afterwards + * param: outfile - the stream to write to + * + * return: nothing + **/ +VOID CLineBuffer::fputEncoded(FILE *outFile) +{ + PBYTE pVal = _pVal; + + if (pVal && _cbUsed > 0) { + _pVal[_cbUsed] = 0; + while (_cbUsed > 0 && *pVal) { + switch (*pVal) { + // translate special characters + case ':': + case ';': + case '\r': + case '\n': + case '\t': + fprintf(outFile, "=%02X", *pVal); + break; + // Some database texts may contain encoded escapes, that have to be translated too. + case '\\': + if (*(pVal+1) == 'r') { + fprintf(outFile, "=%02X", '\r'); + pVal++; + break; + } + if (*(pVal+1) == 't') { + fprintf(outFile, "=%02X", '\t'); + pVal++; + break; + } + if (*(pVal+1) == 'n') { + fprintf(outFile, "=%02X", '\n'); + pVal++; + break; + } + // translate all characters which are not contained in the USASCII code + default: + if (*pVal > 127) fprintf(outFile, "=%02X", *pVal); + else fputc(*pVal, outFile); + break; + } + pVal++; + (_cbUsed)--; + } + *_pVal = 0; + } +} + +/** + * name: CLineBuffer::fgetEncoded + * desc: string member is read from the specified stream decoded + * param: outfile - the stream to write to + * + * return: nothing + **/ +INT CLineBuffer::fgetEncoded(FILE *inFile) +{ + CHAR c; + CHAR hex[3]; + WORD wAdd = 0; + + hex[2] = 0; + + _cbUsed = 0; + + while (EOF != (c = fgetc(inFile))) { + switch (c) { + case '\n': + if (_cbUsed > 0 && _pVal[_cbUsed - 1] == '\r') { + _pVal[--_cbUsed] = 0; + wAdd--; + } + else + _pVal[_cbUsed] = 0; + return wAdd; + case '=': + if (_resizeBuf(1)) { + fread(hex, 2, 1, inFile); + *(_pVal + _cbUsed++) = (BYTE)strtol(hex, NULL, 16); + wAdd++; + } + break; + default: + if (_resizeBuf(1)) { + *(_pVal + _cbUsed++) = c; + wAdd++; + } + break; + } + } + _pVal[_cbUsed] = 0; + return _cbUsed > 0 ? wAdd : EOF; +} + +/** + * name: CLineBuffer::GetTokenFirst + * desc: scans for the first in the _pVal member and returns all characters + * that come before the first in a new CLineBuffer class + * param: delim - the deliminer which delimins the string + * pBuf - pointer to a new CLineBuffer class holding the result + * + * return: length of the found string value + **/ +size_t CLineBuffer::GetTokenFirst(const CHAR delim, CLineBuffer * pBuf) +{ + PBYTE here; + size_t wLength; + + _pTok = _pVal; + + if (!_pTok || !*_pTok) + return 0; + + for (here = _pTok;; here++) { + if (*here == 0 || *here == '\n' || *here == delim) { + wLength = here - _pTok; + if (pBuf) { + CHAR c = *here; + *here = 0; + *pBuf = (LPCSTR)_pTok; + *here = c; + } + _pTok = (*here == 0 || *here == '\n') ? NULL : ++here; + break; + } + } + return wLength; +} + +/** + * name: CLineBuffer::GetTokenNext + * desc: scans for the next in the _pVal member and returns all characters + * that come before the first in a new CLineBuffer class + * param: delim - the deliminer which delimins the string + * pBuf - pointer to a new CLineBuffer class holding the result + * + * return: length of the found string value + **/ +size_t CLineBuffer::GetTokenNext(const CHAR delim, CLineBuffer * pBuf) +{ + PBYTE here; + size_t wLength; + + if (!_pTok || !*_pTok) + return 0; + + for (here = _pTok;; here++) { + if (*here == 0 || *here == '\n' || *here == delim) { + wLength = here - _pTok; + + if (pBuf) { + CHAR c = *here; + + *here = 0; + *pBuf = (LPCSTR)_pTok; + *here = c; + } + _pTok = (*here == 0 || *here == '\n') ? NULL : ++here; + break; + } + } + return wLength; +} + +/** + * name: CLineBuffer::DBWriteTokenFirst + * desc: scans for the first in the _pVal member and writes all characters + * that come before the first to database + * param: hContact - handle to the contact to write the setting to + * pszModule - destination module + * pszSetting - destination setting for the value + * delim - the deliminer which delimins the string + * + * return: 0 if successful, 1 otherwise + **/ +INT CLineBuffer::DBWriteTokenFirst(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting, const CHAR delim) +{ + PBYTE here; + INT iRet = 1; + _pTok = _pVal; + + if (_pTok && *_pTok) { + for (here = _pTok;; here++) { + if (*here == 0 || *here == '\n' || *here == delim) { + + if (here - _pTok > 0) { + CHAR c = *here; + + *here = 0; + iRet = DB::Setting::WriteAString(hContact, pszModule, pszSetting, (LPSTR)_pTok); + *here = c; + } + _pTok = (*here == 0 || *here == '\n') ? NULL : ++here; + break; + } + } + } + if (iRet) iRet = DB::Setting::Delete(hContact, pszModule, pszSetting); + return iRet; +} + +/** + * name: CLineBuffer::GetTokenNext + * desc: scans for the next in the _pVal member and writes all characters + * that come before the first to database + * param: hContact - handle to the contact to write the setting to + * pszModule - destination module + * pszSetting - destination setting for the value + * delim - the deliminer which delimins the string + * + * return: 0 if successful, 1 otherwise + **/ +INT CLineBuffer::DBWriteTokenNext(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting, const CHAR delim) +{ + PBYTE here; + INT iRet = 1; + + if (_pTok && *_pTok) { + for (here = _pTok;; here++) { + if (*here == 0 || *here == '\n' || *here == delim) { + + if (here - _pTok > 0) { + CHAR c = *here; + + *here = 0; + iRet = DB::Setting::WriteAString(hContact, pszModule, pszSetting, (LPSTR)_pTok); + *here = c; + } + _pTok = (*here == 0 || *here == '\n') ? NULL : ++here; + break; + } + } + } + if (iRet) iRet = DB::Setting::Delete(hContact, pszModule, pszSetting); + return iRet; +} + +/** + * name: CLineBuffer::GetTokenNext + * desc: writes _pVal member to database + * param: hContact - handle to the contact to write the setting to + * pszModule - destination module + * pszSetting - destination setting for the value + * + * return: 0 if successful, 1 otherwise + **/ +INT CLineBuffer::DBWriteSettingString(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting) +{ + if (_pVal && _cbUsed > 0) + return DB::Setting::WriteAString(hContact, pszModule, pszSetting, (LPSTR)_pVal); + return 1; +} + +/* +========================================================================================================================= + class CVCardFileVCF +========================================================================================================================= +*/ + +/** + * name: CVCardFileVCF + * desc: default constructor + * param: none + * return none + **/ +CVCardFileVCF::CVCardFileVCF() +{ + _pFile = NULL; + _hContact = INVALID_HANDLE_VALUE; + _pszBaseProto = NULL; + _hasUtf8 = 0; + _useUtf8 = FALSE; +} + +/** + * name: CVCardFileVCF::CVCardFileVCF + * desc: searches a static stringlist for the occureance of iID and adds + * the translated string value to the line buffer + * param: pList - pointer to the list to search in + * nList - number of items in the list + * iID - the id to search for + * cbRew - number of characters to truncate the _clVal by before writing to file + * + * return number of the added bytes + **/ +size_t CVCardFileVCF::packList(LPIDSTRLIST pList, UINT nList, INT iID, size_t *cbRew) +{ + UINT i; + WORD wAdd = 0; + + for (i = 0; i < nList; i++) { + if (pList[i].nID == iID) { + return (_clVal + pList[i].ptszTranslated); + } + } + if (cbRew) (*cbRew)++; + return 0; +} + +/** + * name: CVCardFileVCF::GetSetting + * desc: trys to read a value from the pszModule and than from the basic protocol module of the contact + * where strings are converted to ansi + * param: pszModule - module to read the value from + * pszSetting - setting to read the value from + * dbv - pointer to the structure holding the result + * + * return value type + **/ +BOOLEAN CVCardFileVCF::GetSetting(const CHAR *pszModule, const CHAR *pszSetting, DBVARIANT *dbv) +{ + DBCONTACTGETSETTING cgs; + + cgs.szModule = pszModule; + cgs.szSetting = pszSetting; + cgs.pValue = dbv; + dbv->type = _useUtf8 ? DBVT_UTF8 : DBVT_ASCIIZ; + dbv->pszVal = NULL; + if (!pszModule || CallService(MS_DB_CONTACT_GETSETTING_STR, (WPARAM)_hContact, (LPARAM)&cgs) || (dbv->type == DBVT_ASCIIZ && !dbv->pszVal && !*dbv->pszVal)) { + cgs.szModule = _pszBaseProto; + cgs.szSetting = pszSetting; + cgs.pValue = dbv; + dbv->type = DBVT_ASCIIZ; + if (!_pszBaseProto || CallService(MS_DB_CONTACT_GETSETTING_STR, (WPARAM)_hContact, (LPARAM)&cgs) || (dbv->type == DBVT_ASCIIZ && !dbv->pszVal && !*dbv->pszVal)) { + return DBVT_DELETED; + } + } + _hasUtf8 += _useUtf8 && !IsUSASCII(dbv->pszVal, NULL); + return dbv->type; +} + +/** + * name: CVCardFileVCF::packDB + * desc: read a value from the database and add it to the line buffer + * param: pszModule - module to read the value from + * pszSetting - setting to read the value from + * cbRew - number of characters to truncate the _clVal by before writing to file + * + * return number of bytes, added to the linebuffer + **/ +size_t CVCardFileVCF::packDB(const CHAR *pszModule, const CHAR *pszSetting, size_t *cbRew) +{ + DBVARIANT dbv; + + switch (GetSetting(pszModule, pszSetting, &dbv)) { + case DBVT_DELETED: + if (cbRew) (*cbRew)++; + break; + case DBVT_BYTE: + return _clVal + dbv.bVal; + case DBVT_WORD: + return _clVal + dbv.wVal; + case DBVT_DWORD: + return _clVal + dbv.dVal; + case DBVT_UTF8: + case DBVT_ASCIIZ: + { + size_t wAdd = _clVal + dbv.pszVal; + DB::Variant::Free(&dbv); + return wAdd; + } + default: + if (cbRew) (*cbRew)++; + DB::Variant::Free(&dbv); + break; + } + return 0; +} + +/** + * name: CVCardFileVCF::packDBList + * desc: read a value from the database and add a found list item to the line buffer + * param: pszModule - module to read the value from + * pszSetting - setting to read the value from + * GetList - pointer to a function retrieving the list pointer + * bSigned - is the read database value signed? + * cbRew - number of characters to truncate the _clVal by before writing to file + * + * return number of bytes, added to the linebuffer + **/ +size_t CVCardFileVCF::packDBList(const CHAR *pszModule, const CHAR *pszSetting, MIRANDASERVICE GetList, BOOLEAN bSigned, size_t *cbRew) +{ + DBVARIANT dbv; + UINT nList; + LPIDSTRLIST pList; + size_t wAdd = 0; + + GetList((WPARAM)&nList, (LPARAM)&pList); + switch (GetSetting(pszModule, pszSetting, &dbv)) { + case DBVT_BYTE: + wAdd = packList(pList, nList, (INT)(bSigned ? dbv.cVal : dbv.bVal), cbRew); + break; + case DBVT_WORD: + wAdd = packList(pList, nList, (INT)(bSigned ? dbv.sVal : dbv.wVal), cbRew); + break; + case DBVT_DWORD: + wAdd = packList(pList, nList, (INT)(bSigned ? dbv.lVal : dbv.dVal), cbRew); + break; + case DBVT_UTF8: + case DBVT_ASCIIZ: + wAdd = _clVal + Translate(dbv.pszVal); + DB::Variant::Free(&dbv); + break; + case DBVT_DELETED: + wAdd = 0; + break; + default: + wAdd = 0; + DB::Variant::Free(&dbv); + break; + } + if (cbRew) *cbRew = wAdd ? 0 : *cbRew + 1; + return wAdd; +} + +/** + * name: CVCardFileVCF::writeLine + * desc: write a line as clear text to the vcard file + * param: szSet - the string, which identifies the line + * cbRew - number of characters to truncate the _clVal by before writing to file + * + * return number of bytes, added to the linebuffer + **/ +VOID CVCardFileVCF::writeLine(const CHAR *szSet, size_t *cbRew) +{ + if (cbRew) { + _clVal.Truncate(*cbRew); + *cbRew = 0; + } + if (_clVal.GetLength() > 0) { + fputs(szSet, _pFile); + if (_hasUtf8) { + fputs(";CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:", _pFile); + _clVal.fputEncoded(_pFile); + _hasUtf8 = FALSE; + } + else { + fputc(':', _pFile); + _clVal.fput(_pFile); + } + fputc('\n', _pFile); + } +} + +/** + * name: CVCardFileVCF::writeLineEncoded + * desc: write a line as encoded text to the vcard file + * param: szSet - the string, which identifies the line + * cbRew - number of characters to truncate the _clVal by before writing to file + * + * return number of bytes, added to the linebuffer + **/ +VOID CVCardFileVCF::writeLineEncoded(const CHAR *szSet, size_t *cbRew) +{ + if (cbRew) { + _clVal.Truncate(*cbRew); + *cbRew = 0; + } + if (_clVal.GetLength() > 0) { + fputs(szSet, _pFile); + if (_hasUtf8) { + fputs(";CHARSET=UTF-8", _pFile); + _hasUtf8 = FALSE; + } + fputs(";ENCODING=QUOTED-PRINTABLE:", _pFile); + _clVal.fputEncoded(_pFile); + fputc('\n', _pFile); + } +} + +/** + * name: Open + * desc: open a specified filename and link to the contact + * param: hContact - handle to the contact to link with the vCard file + * pszFileName - path to the file to open + * pszMode - the mode the file should be opened with + * return TRUE or FALSE + **/ +BOOLEAN CVCardFileVCF::Open(HANDLE hContact, LPCSTR pszFileName, LPCSTR pszMode) +{ + if (!(_pFile = fopen(pszFileName, pszMode))) + return FALSE; + if ((_hContact = hContact) == INVALID_HANDLE_VALUE) + return FALSE; + if (!(_pszBaseProto = DB::Contact::Proto(_hContact))) + return FALSE; + return TRUE; +} + +/** + * name: Close + * desc: close up the file + * param: hContact - handle to the contact to link with the vCard file + * pszFileName - path to the file to open + * pszMode - the mode the file should be opened with + * return TRUE or FALSE + **/ +VOID CVCardFileVCF::Close(VOID) +{ + if (_pFile) + fclose(_pFile); + _pFile = NULL; + _hContact = INVALID_HANDLE_VALUE; + _pszBaseProto = NULL; +} + +/** + * name: Export + * desc: export the contacts information + * param: none + * return TRUE or FALSE + **/ +BOOLEAN CVCardFileVCF::Export(BOOLEAN bExportUtf) +{ + size_t cbRew = 0; + + _useUtf8 = bExportUtf; + + fputs("BEGIN:VCARD\nVERSION:2.1\n", _pFile); + + // + // naming + // + packDB(USERINFO, SET_CONTACT_LASTNAME, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_FIRSTNAME, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_SECONDNAME, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_TITLE, &cbRew); + _clVal + DELIM; + packDBList(USERINFO, SET_CONTACT_PREFIX, (MIRANDASERVICE)GetNamePrefixList, FALSE, &cbRew); + writeLine("N", &cbRew); + + if (packDB(USERINFO, SET_CONTACT_TITLE)) + _clVal + " "; + + if (packDB(USERINFO, SET_CONTACT_FIRSTNAME)) + _clVal + " "; + else + cbRew = 1; + + if (packDB(USERINFO, SET_CONTACT_SECONDNAME)) + _clVal + " "; + else + cbRew = 1; + + if (packDB(USERINFO, SET_CONTACT_LASTNAME)) + _clVal + " "; + else + cbRew = 1; + + packDBList(USERINFO, SET_CONTACT_PREFIX, (MIRANDASERVICE)GetNamePrefixList, FALSE, &cbRew); + writeLine("FN"); + + packDB(USERINFO, SET_CONTACT_NICK); + writeLine("NICKNAME"); + + // + // organisation + // + packDB(USERINFO, SET_CONTACT_COMPANY, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_DEPARTMENT, &cbRew); + writeLine("ORG", &cbRew); + packDB(USERINFO, SET_CONTACT_COMPANY_POSITION); + writeLine("TITLE"); + packDBList(USERINFO, SET_CONTACT_COMPANY_OCCUPATION, (MIRANDASERVICE)GetOccupationList, FALSE); + writeLine("ROLE"); + + // + // phone numbers + // + if (packDB(USERINFO, SET_CONTACT_PHONE)) { + _clVal.TruncateSMS(); + writeLine("TEL;HOME;VOICE"); + } + if (packDB(USERINFO, SET_CONTACT_FAX)) { + _clVal.TruncateSMS(); + writeLine("TEL;HOME;FAX"); + } + if (packDB(USERINFO, SET_CONTACT_CELLULAR)) { + _clVal.TruncateSMS(); + writeLine("TEL;CELL;VOICE"); + } + if (packDB(USERINFO, SET_CONTACT_COMPANY_PHONE)) { + _clVal.TruncateSMS(); + writeLine("TEL;WORK;VOICE"); + } + if (packDB(USERINFO, SET_CONTACT_COMPANY_FAX)) { + _clVal.TruncateSMS(); + writeLine("TEL;WORK;FAX"); + } + if (packDB(USERINFO, SET_CONTACT_COMPANY_CELLULAR)) { + _clVal.TruncateSMS(); + writeLine("TEL;PAGER;VOICE"); + } + + // + // private address + // + _clVal + ";;"; + cbRew = 1; + packDB(USERINFO, SET_CONTACT_STREET, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_CITY, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_STATE, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_ZIP, &cbRew); + _clVal + DELIM; + packDBList(USERINFO, SET_CONTACT_COUNTRY, (MIRANDASERVICE)GetCountryList, FALSE, &cbRew); + writeLine("ADR;HOME", &cbRew); + + // + // company address + // + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_OFFICE, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_STREET, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_CITY, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_STATE, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_COMPANY_ZIP, &cbRew); + _clVal + DELIM; + packDBList(USERINFO, SET_CONTACT_COMPANY_COUNTRY, (MIRANDASERVICE)GetCountryList, FALSE, &cbRew); + writeLine("ADR;WORK", &cbRew); + + // + // origin address + // + _clVal + ";;"; + cbRew = 1; + packDB(USERINFO, SET_CONTACT_ORIGIN_STREET, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_ORIGIN_CITY, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_ORIGIN_STATE, &cbRew); + _clVal + DELIM; + packDB(USERINFO, SET_CONTACT_ORIGIN_ZIP, &cbRew); + _clVal + DELIM; + packDBList(USERINFO, SET_CONTACT_ORIGIN_COUNTRY, (MIRANDASERVICE)GetCountryList, FALSE, &cbRew); + writeLine("ADR;POSTAL", &cbRew); + + // + // homepages + // + if (packDB(USERINFO, SET_CONTACT_HOMEPAGE)) + writeLine("URL;HOME"); + if (packDB(USERINFO, SET_CONTACT_COMPANY_HOMEPAGE)) + writeLine("URL;WORK"); + + // + // e-mails + // + if (packDB(USERINFO, SET_CONTACT_EMAIL)) + writeLine("EMAIL;PREF;intERNET"); + if (packDB(USERINFO, SET_CONTACT_EMAIL0)) + writeLine("EMAIL;intERNET"); + if (packDB(USERINFO, SET_CONTACT_EMAIL1)) + writeLine("EMAIL;intERNET"); + + // + // gender + // + { + BYTE gender = DB::Setting::GetByte(_hContact, USERINFO, SET_CONTACT_GENDER, 0); + if (!gender) gender = DB::Setting::GetByte(_hContact, _pszBaseProto, SET_CONTACT_GENDER, 0); + switch (gender) { + case 'F': + fputs("X-WAB-GENDER:1\n", _pFile); + break; + case 'M': + fputs("X-WAB-GENDER:2\n", _pFile); + break; + } + } + + // + // birthday + // + { + MAnnivDate mdb; + + if (!mdb.DBGetBirthDate(_hContact, NULL)) + fprintf(_pFile, "BDAY:%d%02d%02d\n\0", mdb.Year(), mdb.Month(), mdb.Day()); + } + + // + // notes + // + if (packDB(USERINFO, SET_CONTACT_MYNOTES)) + writeLineEncoded("NOTE"); + + // + // about + // + if (packDB(USERINFO, SET_CONTACT_ABOUT)) + writeLineEncoded("ABOUT"); + + // + // contacts protocol, uin setting, uin value + // + { + CHAR szUID[MAXUID]; + LPCSTR uid; + + uid = (LPCSTR)CallProtoService(_pszBaseProto, PS_GETCAPS, PFLAG_UNIQUEIDSETTING, 0); + if ((INT_PTR)uid != CALLSERVICE_NOTFOUND && uid) { + if (!DB::Setting::GetStatic(_hContact, _pszBaseProto, uid, szUID, sizeof(szUID))) + fprintf(_pFile, "IM;%s;%s:%s\n", _pszBaseProto, uid, szUID); + } + } + + // + // time of creation + // + { + SYSTEMTIME st; + + GetLocalTime(&st); + fprintf(_pFile, "REV:%04d%02d%02dD%02d%02d%02dT\n", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); + } + + fputs("END:VCARD", _pFile); + return 0; +} + +/** + * name: CVCardFileVCF::readLine + * desc: read one line from the VCF file and return the setting string + * to the szVCFSetting and the value to _clVal + * param: szVCFSetting - string holding the setting information + * cchSetting - number of bytes the szVCFSetting can hold + * + * return: number of characters read from the file or EOF + **/ +INT CVCardFileVCF::readLine(LPSTR szVCFSetting, WORD cchSetting) +{ + LPSTR here; + + // read setting (size is never larger than MAX_SETTING, error otherwise!) + for (here = szVCFSetting; here - szVCFSetting < cchSetting && EOF != (*here = fgetc(_pFile)); here++) { + // end of the setting string + if (*here == ':') { + *here = 0; + break; + } + // end of line before value? + if (*here == '\n') + return 0; + } + // ignore line if setting was not read correctly + if (here - szVCFSetting == cchSetting) + return 0; + + // read the value to the linebuffer, because its length may be very large + return _clVal.fgetEncoded(_pFile); +} + +/** + * name: CVCardFileVCF::Import + * desc: imports all lines from the file and writes them to database + * param: nothing + * + * return: number of characters read from the file or EOF + **/ +BOOLEAN CVCardFileVCF::Import() +{ + CHAR szEnt[MAX_PATH]; + LPSTR pszParam; + INT cbLine; + BYTE numEmails = 0; + + while (EOF != (cbLine = readLine(szEnt, MAX_PATH))) { + + // ignore empty lines + if (!cbLine) continue; + + // isolate the param string + if (pszParam = mir_strchr(szEnt, ';')) { + *(pszParam++) = 0; + } + switch (*szEnt) { + case 'A': + if (!strcmp(szEnt, "ABOUT")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_ABOUT); + continue; + } + if (!strcmp(szEnt, "ADR")) { + if (!pszParam) continue; + if (!strcmp(pszParam, "HOME")) { + _clVal.GetTokenFirst(';', NULL); + _clVal.GetTokenNext(';', NULL); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_STREET, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_CITY, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_STATE, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ZIP, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COUNTRY, ';'); + continue; + } + if (!strcmp(pszParam, "WORK")) { + _clVal.GetTokenFirst(';', NULL); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_OFFICE, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_STREET, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_CITY, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_STATE, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_ZIP, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_COUNTRY, ';'); + continue; + } + if (!strcmp(pszParam, "POSTAL")) { + _clVal.GetTokenFirst(';', NULL); + _clVal.GetTokenNext(';', NULL); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ORIGIN_STREET, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ORIGIN_CITY, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ORIGIN_STATE, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ORIGIN_ZIP, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_ORIGIN_COUNTRY, ';'); + } + } + continue; + + case 'B': + if (!strcmp(szEnt, "BDAY")) { + if (_clVal.GetLength() == 8) { + CHAR buf[5]; + + memcpy(buf, _clVal.GetBuffer(), 4); + buf[4] = 0; + DB::Setting::WriteWord(_hContact, MOD_MBIRTHDAY, SET_CONTACT_BIRTHYEAR, (WORD)strtol(buf, NULL, 10)); + memcpy(buf, _clVal.GetBuffer() + 4, 2); + buf[2] = 0; + DB::Setting::WriteByte(_hContact, MOD_MBIRTHDAY, SET_CONTACT_BIRTHMONTH, (BYTE)strtol(buf, NULL, 10)); + memcpy(buf, _clVal.GetBuffer() + 6, 2); + buf[2] = 0; + DB::Setting::WriteByte(_hContact, MOD_MBIRTHDAY, SET_CONTACT_BIRTHDAY, (BYTE)strtol(buf, NULL, 10)); + } + } + continue; + + case 'E': + if (!strcmp(szEnt, "EMAIL")) { + if (!pszParam || !strstr(pszParam, "intERNET")) + continue; + if (strstr(pszParam, "PREF")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_EMAIL); + continue; + } + switch (numEmails++) { + case 0: + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_EMAIL0); + break; + case 1: + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_EMAIL1); + break; + } + } + continue; + /* + case 'I': + if (!strcmp(szEnt, "IM")) { + LPSTR pszModule, pszSetting; + + if (pszParam && (pszModule = strtok(pszParam, DELIM)) && (pszSetting = strtok(NULL, DELIM))) + _clVal.DBWriteSettingString(_hContact, pszModule, pszSetting); + } + continue; + */ + case 'N': + if (!strcmp(szEnt, "N")) { + _clVal.DBWriteTokenFirst(_hContact, USERINFO, SET_CONTACT_LASTNAME, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_FIRSTNAME, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_SECONDNAME, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_TITLE, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_PREFIX, ';'); + continue; + } + if (!strcmp(szEnt, "NICKNAME")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_NICK); + continue; + } + if (!strcmp(szEnt, "NOTE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_MYNOTES); + } + continue; + + case 'O': + if (!strcmp(szEnt, "ORG")) { + _clVal.DBWriteTokenFirst(_hContact, USERINFO, SET_CONTACT_COMPANY, ';'); + _clVal.DBWriteTokenNext(_hContact, USERINFO, SET_CONTACT_COMPANY_DEPARTMENT, ';'); + } + continue; + + case 'R': + if (!strcmp(szEnt, "ROLE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_OCCUPATION); + } + continue; + + case 'T': + if (!strcmp(szEnt, "TITLE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_POSITION); + continue; + } + if (!strcmp(szEnt, "TEL")) { + + if (!pszParam) continue; + + if (!strcmp(pszParam, "HOME;VOICE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_PHONE); + continue; + } + if (!strcmp(pszParam, "HOME;FAX")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_FAX); + continue; + } + if (!strcmp(pszParam, "CELL;VOICE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_CELLULAR); + continue; + } + if (!strcmp(pszParam, "WORK;VOICE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_PHONE); + continue; + } + if (!strcmp(pszParam, "WORK;FAX")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_FAX); + continue; + } + if (!strcmp(pszParam, "PAGER;VOICE")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_CELLULAR); + continue; + } + } + continue; + + case 'U': + if (!strcmp(szEnt, "URL")) { + + if (!pszParam) continue; + + if (!strcmp(pszParam, "HOME")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_HOMEPAGE); + continue; + } + if (!strcmp(pszParam, "WORK")) { + _clVal.DBWriteSettingString(_hContact, USERINFO, SET_CONTACT_COMPANY_HOMEPAGE); + } + } + continue; + + case 'X': + if (!strcmp(szEnt, "X-WAB-GENDER")) { + if (!strcmp(_clVal.GetBuffer(), "1")) + DB::Setting::WriteByte(_hContact, USERINFO, SET_CONTACT_GENDER, 'F'); + else + if (!strcmp(_clVal.GetBuffer(), "2")) + DB::Setting::WriteByte(_hContact, USERINFO, SET_CONTACT_GENDER, 'M'); + } + continue; + } + } + return TRUE; +} diff --git a/plugins/UserInfoEx/ex_import/svc_ExImVCF.h b/plugins/UserInfoEx/ex_import/svc_ExImVCF.h new file mode 100644 index 0000000000..4465614b80 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImVCF.h @@ -0,0 +1,103 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImVCF.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#pragma once + +class CLineBuffer +{ +private: + PBYTE _pVal; + PBYTE _pTok; + size_t _cbVal; + size_t _cbUsed; + + BOOLEAN _resizeBuf(const size_t cbReq); + +public: + CLineBuffer(); + ~CLineBuffer(); + + size_t operator = (const CHAR *szVal); + + size_t operator + (const CHAR *szVal); + size_t operator + (const WCHAR *wszVal); + size_t operator + (const CHAR cVal); + size_t operator + (const BYTE bVal); + size_t operator + (const SHORT sVal); + size_t operator + (const WORD wVal); + size_t operator + (const LONG lVal); + size_t operator + (const DWORD dVal); + + size_t GetLength(); + LPCSTR GetBuffer(); + + VOID TruncToLength(size_t cbLength); + VOID Truncate(size_t count); + VOID TruncateSMS(); + + VOID fput(FILE *outfile); + VOID fputEncoded(FILE *outFile); + INT fgetEncoded(FILE *inFile); + + size_t GetTokenFirst(const CHAR delim, CLineBuffer * pBuf); + size_t GetTokenNext(const CHAR delim, CLineBuffer * pBuf); + INT DBWriteTokenFirst(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting, const CHAR delim); + INT DBWriteTokenNext(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting, const CHAR delim); + INT DBWriteSettingString(HANDLE hContact, const CHAR* pszModule, const CHAR* pszSetting); +}; + +class CVCardFileVCF +{ +private: + CLineBuffer _clVal; + FILE *_pFile; + HANDLE _hContact; + const CHAR *_pszBaseProto; + WORD _cbRew; + BOOLEAN _useUtf8; + WORD _hasUtf8; + + size_t packList(LPIDSTRLIST pList, UINT nList, INT iID, size_t *cbRew = NULL); + BOOLEAN GetSetting(const CHAR *pszModule, const CHAR *pszSetting, DBVARIANT *dbv); + size_t packDB(const CHAR *pszModule, const CHAR *pszSetting, size_t *cbRew = NULL); + size_t packDBList(const CHAR *pszModule, const CHAR *pszSetting, MIRANDASERVICE GetList, BOOLEAN bSigned = FALSE, size_t *cbRew = NULL); + + VOID writeLine(const CHAR *szSet, size_t *cbRew = NULL); + VOID writeLineEncoded(const CHAR *szSet, size_t *cbRew = NULL); + INT readLine(LPSTR szVCFSetting, WORD cchSetting); + +public: + CVCardFileVCF(); + + BOOLEAN Open(HANDLE hContact, LPCSTR pszFileName, LPCSTR pszMode); + VOID Close(VOID); + BOOLEAN Export(BOOLEAN bExportUtf); + BOOLEAN Import(); +}; diff --git a/plugins/UserInfoEx/ex_import/svc_ExImXML.cpp b/plugins/UserInfoEx/ex_import/svc_ExImXML.cpp new file mode 100644 index 0000000000..dca52f1685 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImXML.cpp @@ -0,0 +1,453 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImXML.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ +#include "commonheaders.h" + +#define XMLCARD_VERSION "1.1" + +/** + * system & local includes: + **/ +#include "dlg_ExImModules.h" +#include "classExImContactXML.h" +#include "svc_ExImport.h" + +LRESULT CALLBACK DlgProc_DataHistory(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_INITDIALOG: + { + const ICONCTRL idIcon[] = { + { ICO_DLG_EXPORT, WM_SETICON, NULL }, + { ICO_DLG_EXPORT, STM_SETIMAGE, ICO_DLGLOGO }, + { ICO_BTN_EXPORT, BM_SETIMAGE, IDOK }, + { ICO_BTN_CANCEL, BM_SETIMAGE, IDCANCEL } + }; + const INT numIconsToSet = DB::Setting::GetByte(SET_ICONS_BUTTONS, 1) ? SIZEOF(idIcon) : 2; + IcoLib_SetCtrlIcons(hDlg, idIcon, numIconsToSet); + + TranslateDialogDefault(hDlg); + SendDlgItemMessage(hDlg, IDOK, BUTTONTRANSLATE, NULL, NULL); + SendDlgItemMessage(hDlg, IDCANCEL, BUTTONTRANSLATE, NULL, NULL); + break; + } + case WM_CTLCOLORSTATIC: + switch (GetWindowLongPtr((HWND)lParam, GWLP_ID)) { + case STATIC_WHITERECT: + case ICO_DLGLOGO: + case IDC_INFO: + SetBkColor((HDC)wParam, RGB(255, 255, 255)); + return (INT_PTR)GetStockObject(WHITE_BRUSH); + } + return FALSE; + case WM_COMMAND: + if (HIWORD(wParam) == BN_CLICKED) { + switch (LOWORD(wParam)) { + case IDCANCEL: + EndDialog(hDlg, 0); + break; + case IDOK: { + WORD hiWord = 0; + + if (IsDlgButtonChecked(hDlg, IDC_CHECK1)) + hiWord |= EXPORT_DATA; + if (IsDlgButtonChecked(hDlg, IDC_CHECK2)) + hiWord |= EXPORT_HISTORY; + EndDialog(hDlg, (INT_PTR)MAKELONG(IDOK, hiWord)); + break; + } + } + } + break; + } + return FALSE; +} + +/*********************************************************************************************************** + * exporting stuff + ***********************************************************************************************************/ + +/** + * name: Export + * desc: globally accessible function which does the whole export stuff. + * params: hContact - handle to the contact who is to export + * pszFileName - full qualified path to the xml file which is destination for the export process + * return: 0 on success, 1 otherwise + **/ +INT CFileXml::Export(lpExImParam ExImContact, LPCSTR pszFileName) +{ + FILE *xmlfile; + DB::CEnumList Modules; + LONG cbHeader; + SYSTEMTIME now; + DWORD result; + HANDLE hContact; + + result = (DWORD)DialogBox(ghInst, + MAKEINTRESOURCE(IDD_EXPORT_DATAHISTORY), + NULL, (DLGPROC)DlgProc_DataHistory); + if (LOWORD(result) != IDOK) + { + return 0; + } + _wExport = HIWORD(result); + + // show dialog to enable user to select modules for export + if (!(_wExport & EXPORT_DATA) || + !DlgExImModules_SelectModulesToExport(ExImContact, &Modules, NULL)) + { + + xmlfile = fopen(pszFileName, "wt"); + if (!xmlfile) + { + MsgErr(NULL, LPGENT("Can't create xml file!\n%S"), pszFileName); + return 1; + } + + GetLocalTime(&now); + + // write xml header raw as it is without using the tinyxml api + fprintf(xmlfile, + "%c%c%c\n" + "\n", + 0xefU, 0xbbU, 0xbfU, now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond + ); + // remember the header's size + cbHeader = ftell(xmlfile); + + CExImContactXML vContact(this); + + // write data + if ( ExImContact->Typ == EXIM_CONTACT) { + // export single contact + _hContactToWorkOn = ExImContact->hContact; + if (vContact.fromDB(ExImContact->hContact)) { + vContact.Export(xmlfile, &Modules); + } + } + else { + // other export mode + _hContactToWorkOn = INVALID_HANDLE_VALUE; +#ifdef _DEBUG + LARGE_INTEGER freq, t1, t2; + + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&t1); +#endif + // export owner contact + if (ExImContact->Typ == EXIM_ALL && vContact.fromDB(NULL)) { + vContact.Export(xmlfile, &Modules); + } + // loop for all other contact + for (hContact = DB::Contact::FindFirst(); + hContact != NULL; + hContact = DB::Contact::FindNext(hContact)) + { + switch (ExImContact->Typ) + { + case EXIM_ALL: + case EXIM_GROUP: + // dont export meta subcontacts by default + if (!DB::MetaContact::IsSub(hContact)) { + if (vContact.fromDB(hContact)) { + vContact.Export(xmlfile, &Modules); + } + } + break; + case EXIM_SUBGROUP: + // dont export meta subcontacts by default and + // export only contact with selectet group name + if (!DB::MetaContact::IsSub(hContact) && + mir_tcsncmp(ExImContact->ptszName, DB::Setting::GetTString(hContact, "CList", "Group"), mir_tcslen(ExImContact->ptszName))== 0) + { + if (vContact.fromDB(hContact)) { + vContact.Export(xmlfile, &Modules); + } + } + break; + case EXIM_ACCOUNT: + // export only contact with selectet account name + if (!mir_strncmp(ExImContact->pszName, DB::Contact::Proto(hContact), mir_strlen(ExImContact->pszName))) { + if (vContact.fromDB(hContact)) { + vContact.Export(xmlfile, &Modules); + } + } + break; + } + } // *end for +#ifdef _DEBUG + QueryPerformanceCounter(&t2); + MsgErr(NULL, LPGENT("Export took %f msec"), + (long double)(t2.QuadPart - t1.QuadPart) / freq.QuadPart * 1000.); +#endif + }// *end other export mode + + // nothing exported? + if (cbHeader == ftell(xmlfile)) { + fclose(xmlfile); + DeleteFileA(pszFileName); + return 1; + } + fputs("\n", xmlfile); + fclose(xmlfile); + } + return 0; +} + + +/*********************************************************************************************************** + * importing stuff + ***********************************************************************************************************/ + +CFileXml::CFileXml() +{ + _numContactsTodo = 0; + _numContactsDone = 0; + _numSettingsTodo = 0; + _numSettingsDone = 0; + _numEventsTodo = 0; + _numEventsDone = 0; + _numEventsDuplicated = 0; +} + +/** + * name: ImportOwner + * desc: Interpretes an xmlnode as owner contact, finds a corresponding contact in database + * or adds a new one including all xml childnodes. + * params: xContact - xmlnode representing the contact + * stat - structure used to collect some statistics + * return: ERROR_OK on success or one other element of ImportError to tell the type of failure + **/ +INT CFileXml::ImportOwner(TiXmlElement* xContact) +{ + CExImContactXML vContact(this); + + if (vContact = xContact) { + vContact.Import(); + return ERROR_OK; + } + return ERROR_NOT_ADDED; +} + +/** + * name: ImportContacts + * desc: Parse all child nodes of an given parent node and try to import all found contacts + * params: xmlParent - xmlnode representing the parent of the list of contacts + * hContact - handle to the contact, who is the owner of the setting to import + * stat - structure used to collect some statistics + * return: ERROR_OK if at least one contact was successfully imported + **/ +INT CFileXml::ImportContacts(TiXmlElement* xmlParent) +{ + TiXmlElement *xContact; + CExImContactXML vContact(this); + INT result; + LPTSTR pszNick; + + // import contacts + for (xContact = xmlParent->FirstChildElement(); xContact != NULL; xContact = xContact->NextSiblingElement()) { + if (!mir_stricmp(xContact->Value(), XKEY_CONTACT)) { + // update progressbar and abort if user clicked cancel + pszNick = mir_utf8decodeT(xContact->Attribute("nick")); + // user clicked abort button + if (_progress.UpdateContact(LPGENT("Contact: %s (%S)"), pszNick, xContact->Attribute("proto"))) { + result = vContact.LoadXmlElemnt(xContact); + switch (result) { + case ERROR_OK: + // init contact class and import if matches the user desires + if (_hContactToWorkOn == INVALID_HANDLE_VALUE || vContact.handle() == _hContactToWorkOn) { + result = vContact.Import(_hContactToWorkOn != INVALID_HANDLE_VALUE); + switch (result) { + case ERROR_OK: + _numContactsDone++; + break; + case ERROR_ABORTED: + if (pszNick) mir_free(pszNick); + return ERROR_ABORTED; +#ifdef _DEBUG + default: + MsgErr(NULL, LPGENT("Importing %s caused error %d"), pszNick, result); + break; +#endif + } + } + break; + case ERROR_ABORTED: + if (pszNick) mir_free(pszNick); + return ERROR_ABORTED; +#ifdef _DEBUG + default: + MsgErr(NULL, LPGENT("Loading contact %s from xml failed with error %d"), pszNick, result); + break; +#endif + } + } + if (pszNick) mir_free(pszNick); + } + // import owner contact + else if (_hContactToWorkOn == INVALID_HANDLE_VALUE && !mir_stricmp(xContact->Value(), XKEY_OWNER) && (vContact = xContact)) { + result = vContact.Import(); + switch (result) { + case ERROR_OK: + _numContactsDone++; + break; + case ERROR_ABORTED: + return ERROR_ABORTED; +#ifdef _DEBUG + default: + MsgErr(NULL, LPGENT("Importing Owner caused error %d"), result); +#endif + } + } + } + return ERROR_OK; +} + +/** + * name: CountContacts + * desc: Counts the number of contacts stored in the file + * params: xContact - the contact, who is the owner of the keys to count + * return: nothing + **/ +DWORD CFileXml::CountContacts(TiXmlElement* xmlParent) +{ + DWORD dwCount = 0; + TiXmlNode *xContact; + + try { + // count contacts in file for progress bar + for (xContact = xmlParent->FirstChild(); xContact != NULL; xContact = xContact->NextSibling()) { + if (!mir_stricmp(xContact->Value(), XKEY_CONTACT) || !mir_stricmp(xContact->Value(), XKEY_OWNER)) { + dwCount += CountContacts(xContact->ToElement()) + 1; + } + } + } + catch(...) { + return 0; + } + return dwCount; +} + +/** + * name: Import + * desc: Interpretes an xmlnode as owner contact, finds a corresponding contact in database + * or adds a new one including all xml childnodes. + * params: hContact - handle to the contact, who is the owner of the setting to import + * pszFileName - full qualified path to the xml file which is to import + * return: ERROR_OK on success or one other element of ImportError to tell the type of failure + **/ +INT CFileXml::Import(HANDLE hContact, LPCSTR pszFileName) +{ + TiXmlDocument doc; + TiXmlElement *xmlCard = NULL; + + try { + _hContactToWorkOn = hContact; + // load xml file + if (!doc.LoadFile(pszFileName)) { + MsgErr(NULL, LPGENT("Parser is unable to load XMLCard \"%s\"\nError: %d\nDescription: %s"), + pszFileName, doc.ErrorId(), doc.ErrorDesc()); + return 1; + } + // is xmlfile a XMLCard ? + if ((xmlCard = doc.FirstChildElement("XMLCard")) == NULL) { + MsgErr(NULL, LPGENT("The selected file is no valid XMLCard")); + return 1; + } + // check version + if (mir_strcmp(xmlCard->Attribute("ver"), XMLCARD_VERSION)) { + MsgErr(NULL, LPGENT("The version of the XMLCard is not supported by UserInfoEx")); + return 1; + } + + // is owner contact to import ? + if (_hContactToWorkOn == NULL) { + INT ret; + + // disable database safty mode to speed up the operation + CallService(MS_DB_SETSAFETYMODE, 0, 0); + // import owner contact + ret = ImportOwner(xmlCard->FirstChildElement(XKEY_OWNER)); + // as soon as possible enable safty mode again! + CallService(MS_DB_SETSAFETYMODE, 1, 0); + + if (!ret) { + MsgBox(NULL, MB_ICONINFORMATION, + LPGENT("Complete"), + LPGENT("Import complete"), + LPGENT("Owner contact successfully imported.")); + return 0; + } else { + MsgErr(NULL, LPGENT("Selected XMLCard does not contain an owner contact!")); + return 1; + } + } + else { +#ifdef _DEBUG + LARGE_INTEGER freq, t1, t2; + + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&t1); +#endif + // count contacts in file for progress bar + _numContactsTodo = CountContacts(xmlCard); + if (_numContactsTodo > 0) { + _progress.SetContactCount(_numContactsTodo); + // disable database safty mode to speed up the operation + CallService(MS_DB_SETSAFETYMODE, 0, 0); + // import the contacts + ImportContacts(xmlCard); + // as soon as possible enable safty mode again! + CallService(MS_DB_SETSAFETYMODE, 1, 0); + } + // finally hide the progress dialog + _progress.Hide(); + +#ifdef _DEBUG + QueryPerformanceCounter(&t2); + MsgErr(NULL, LPGENT("Import took %f msec"), + (long double)(t2.QuadPart - t1.QuadPart) / freq.QuadPart * 1000.); +#endif + // show results + MsgBox(NULL, MB_ICONINFORMATION, LPGENT("Import complete"), LPGENT("Some basic statistics"), + LPGENT("added contacts: %u / %u\nadded settings: %u / %u\nadded events %u / %u\nduplicated events: %u"), + _numContactsDone, _numContactsTodo, + _numSettingsDone, _numSettingsTodo, + _numEventsDone, _numEventsTodo, + _numEventsDuplicated); + + } + } + catch(...) { + MsgErr(NULL, LPGENT("FATAL: An exception was thrown while importing contacts from xmlCard!")); + return 1; + } + return 0; +} diff --git a/plugins/UserInfoEx/ex_import/svc_ExImXML.h b/plugins/UserInfoEx/ex_import/svc_ExImXML.h new file mode 100644 index 0000000000..a2524a7dd6 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImXML.h @@ -0,0 +1,75 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImXML.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ +#ifndef _SVC_FILEXML_INCLUDED_ +#define _SVC_FILEXML_INCLUDED_ 1 + +#include "svc_ExImport.h" +#include "classExImContactBase.h" +#include "dlg_ExImProgress.h" + +#define EXPORT_DATA 1 +#define EXPORT_HISTORY 2 +#define EXPORT_ALL (EXPORT_DATA|EXPORT_HISTORY) + +class CFileXml { + friend class CExImContactXML; + + DWORD _numContactsTodo; + DWORD _numContactsDone; + DWORD _numSettingsTodo; + DWORD _numSettingsDone; + DWORD _numEventsTodo; + DWORD _numEventsDone; + DWORD _numEventsDuplicated; + + HANDLE _hContactToWorkOn; // contact to ex/import (NULL=owner|INVALID_HANDLE_VALUE=all|HADNLE=one user) + + WORD _wExport; + + CProgress _progress; + + INT ImportOwner(TiXmlElement* xmlContact); + INT ImportContacts(TiXmlElement* xmlParent); + + DWORD CountContacts(TiXmlElement* xmlParent); + + /* + INT ExportOwner(FILE *xmlfile, BOOLEAN bExportEvents); + INT ExportContact(FILE *xmlfile, HANDLE hContact, BOOLEAN bExportEvents, LPENUMLIST pModules); + INT ExportSubContact(TiXmlElement *xContact, HANDLE hContact, BOOLEAN bExportEvents); + */ + +public: + CFileXml(); + INT Import(HANDLE hContact, LPCSTR pszFileName); + INT Export(lpExImParam ExImContact, LPCSTR pszFileName); +}; + +#endif /* _SVC_FILEXML_INCLUDED_ */ \ No newline at end of file diff --git a/plugins/UserInfoEx/ex_import/svc_ExImport.cpp b/plugins/UserInfoEx/ex_import/svc_ExImport.cpp new file mode 100644 index 0000000000..b44f455cb8 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImport.cpp @@ -0,0 +1,382 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImport.cpp $ +Revision : $Revision: 210 $ +Last change on : $Date: 2010-10-02 22:27:36 +0400 (ะกะฑ, 02 ะพะบั‚ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include "commonheaders.h" +#include "classExImContactBase.h" +#include "dlg_ExImModules.h" +#include "dlg_ExImOpenSaveFile.h" +#include "svc_ExImport.h" +#include "svc_ExImINI.h" +#include "svc_ExImVCF.h" +#include "svc_ExImXML.h" + +#include +#include + +/*********************************************************************************************************** + * internal functions + ***********************************************************************************************************/ + +/** + * name: DisplayNameToFileName + * desc: convert contact's display name to valid filename + * param: hContact - handle of contact to create the filename for + * pszFileName - buffer, retrieving the converted filename + * cchFileName - number of maximum characters the filename can be + * return: nothing + **/ +static VOID DisplayNameToFileName(lpExImParam ExImContact, LPSTR pszFileName, WORD cchFileName) +{ + LPCSTR disp = 0; + LPSTR temp = 0; + + cchFileName--; + + ZeroMemory(pszFileName, cchFileName); + + switch (ExImContact->Typ) { + case EXIM_ALL: + case EXIM_GROUP: + mir_strncpy(pszFileName, Translate("all Contacts"), cchFileName); + return; + case EXIM_CONTACT: + if (ExImContact->hContact == NULL) { + mir_strncpy(pszFileName, Translate("Owner"), cchFileName); + return; + } + else { + disp = (LPCSTR)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)ExImContact->hContact, NULL); + } + break; + case EXIM_SUBGROUP: + temp = mir_t2a(ExImContact->ptszName); + disp = temp; + break; + case EXIM_ACCOUNT: + PROTOACCOUNT* acc = ProtoGetAccount(ExImContact->pszName); + temp = mir_t2a(acc->tszAccountName); + disp = temp; + break; + } + + // replace unwanted characters + while (*disp != 0 && cchFileName > 1) { + switch (*disp) { + case '?': case '*': case ':': + case '\\': case '|': case '/': + case '<': case '>': case '"': + *(pszFileName++) = '_'; + break; + default: + *(pszFileName++) = *disp; + break; + } + disp++; + cchFileName--; + } + mir_free(temp); +} + +LPCSTR FilterString(lpExImParam ExImContact) +{ + LPCSTR pszFilter = 0; + switch (ExImContact->Typ) { + case EXIM_SUBGROUP: + case EXIM_ACCOUNT: + pszFilter = ("XMLCard 1.0 (*.xml)\0*.xml\0"); + break; + case EXIM_ALL: + case EXIM_GROUP: + pszFilter = ("XMLCard 1.0 (*.xml)\0*.xml\0DBEditor++ File (*.ini)\0*.ini\0"); + break; + case EXIM_CONTACT: + pszFilter = ("XMLCard 1.0 (*.xml)\0*.xml\0DBEditor++ File (*.ini)\0*.ini\0Standard vCard 2.1 (*.vcf)\0*.vcf\0"); + break; + } + return pszFilter; +} + +/** + * name: SvcExImport_Export + * desc: service function to export contact information + * param: wParam - handle to contact or NULL + * lParam - parent window + * return: 0 always + **/ +INT_PTR SvcExImport_Export(lpExImParam ExImContact, HWND hwndParent) +{ + CHAR szFileName[MAX_PATH] = { 0 }; + // create the filename to suggest the user for the to export contact + DisplayNameToFileName(ExImContact, szFileName, SIZEOF(szFileName)); + INT nIndex = DlgExIm_SaveFileName(hwndParent, + Translate("Select a destination file..."), + FilterString(ExImContact), + szFileName); + + switch (nIndex) { + case 1: // .xml + { + CFileXml xmlFile; + return xmlFile.Export(ExImContact, szFileName); + } + case 2: // .ini + { + return SvcExImINI_Export(ExImContact, szFileName); + } + case 3: // .vcf + { + CVCardFileVCF vcfFile; + SetCursor(LoadCursor(NULL, IDC_WAIT)); + if (vcfFile.Open(ExImContact->hContact, szFileName, "wt")) { + vcfFile.Export(FALSE); + vcfFile.Close(); + } + SetCursor(LoadCursor(NULL, IDC_ARROW)); + return 0; + } + } + return 1; +} + +/** + * name: SvcExImport_Import + * desc: service function to export contact information + * param: wParam - handle to contact or NULL + * lParam - parent window + * return: 0 always + **/ +INT_PTR SvcExImport_Import(lpExImParam ExImContact, HWND hwndParent) +{ + CHAR szFileName[MAX_PATH] = { 0 }; + + // create the filename to suggest the user for the to export contact + DisplayNameToFileName(ExImContact, szFileName, SIZEOF(szFileName)); + + INT nIndex = DlgExIm_OpenFileName(hwndParent, + Translate("Import User Details from VCard"), + FilterString(ExImContact), + szFileName); + +// Stop during develop +if (ExImContact->Typ == EXIM_ACCOUNT || + ExImContact->Typ == EXIM_GROUP) return 1; + + switch (nIndex) { + case 1: + { + CFileXml xmlFile; + CallService(MS_CLIST_SETHIDEOFFLINE, -1, 0); //workarround to refresh the clist.... + xmlFile.Import(ExImContact->hContact, szFileName); + CallService(MS_CLIST_SETHIDEOFFLINE, -1, 0); //...after import. + //pcli->pfnClcBroadcast(CLM_AUTOREBUILD, 0, 0); //does not work + return 0; + } + // .ini + case 2: + return SvcExImINI_Import(ExImContact->hContact, szFileName); + + // .vcf + case 3: + { + CVCardFileVCF vcfFile; + + if (vcfFile.Open(ExImContact->hContact, szFileName, "rt")) { + SetCursor(LoadCursor(NULL, IDC_WAIT)); + vcfFile.Import(); + vcfFile.Close(); + SetCursor(LoadCursor(NULL, IDC_ARROW)); + } + return 0; + } + } + return 1; +} + +/*********************************************************************************************************** + * service functions + ***********************************************************************************************************/ + +/********************************* + * Ex/import All (MainMenu) + *********************************/ +INT_PTR svcExIm_MainExport_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + ZeroMemory(&ExIm, sizeof(ExIm)); + ExIm.hContact = INVALID_HANDLE_VALUE; + ExIm.Typ = EXIM_ALL; + return SvcExImport_Export(&ExIm, (HWND)lParam); +} + +INT_PTR svcExIm_MainImport_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + ZeroMemory(&ExIm, sizeof(ExIm)); + ExIm.hContact = INVALID_HANDLE_VALUE; + ExIm.Typ = EXIM_ALL; + return SvcExImport_Import(&ExIm, (HWND)lParam); +} + + +/********************************* + * Ex/import Contact (ContactMenu) + *********************************/ +INT_PTR svcExIm_ContactExport_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + ZeroMemory(&ExIm, sizeof(ExIm)); + ExIm.hContact = (HANDLE)wParam; + ExIm.Typ = EXIM_CONTACT; + return SvcExImport_Export(&ExIm, (HWND)lParam); +} + +INT_PTR svcExIm_ContactImport_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + ZeroMemory(&ExIm, sizeof(ExIm)); + ExIm.hContact = (HANDLE)wParam; + ExIm.Typ = EXIM_CONTACT; + return SvcExImport_Import(&ExIm, (HWND)lParam); +} + + +/********************************* + *Ex/import (Sub)Group (GroupMenu) + *********************************/ + +/** + * This service is call by (Sub)Group MenuItem Export and MenuItem Import + * + * @param wParam - gmp.wParam = 0 ->Import + * @param wParam - gmp.wParam != 0 ->Export + * @param lParam - gmp.lParam not used + * + * @return always 0 + **/ +INT_PTR svcExIm_Group_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + INT_PTR hItem = 0, hRoot = 0, hParent = 0; + TCHAR tszGroup[120], tszItem[120]; + ZeroMemory(&tszGroup, sizeof(tszGroup)); + ZeroMemory(&tszItem, sizeof(tszItem)); + ZeroMemory(&ExIm, sizeof(ExIm)); + LPTSTR ptszGroup = tszGroup; + LPTSTR ptszItem = tszItem; + + HWND hClist = (HWND)CallService(MS_CLUI_GETHWNDTREE,0,0); + // get clist selection + hItem = SendMessage(hClist,CLM_GETSELECTION,0,0); + hRoot = SendMessage(hClist,CLM_GETNEXTITEM, (WPARAM)CLGN_ROOT, (LPARAM)hItem); + while (hItem) { + if (SendMessage(hClist,CLM_GETITEMTYPE, (WPARAM)hItem, 0) == CLCIT_GROUP) { + SendMessage(hClist,CLM_GETITEMTEXT, (WPARAM)hItem, (LPARAM)ptszItem); + LPTSTR temp = mir_tstrdup(ptszGroup); + mir_sntprintf(tszGroup, SIZEOF(tszGroup),_T("%s%s%s"), ptszItem, _tcslen(temp)? _T("\\"):_T(""), temp); + mir_free (temp); + } + hParent = SendMessage(hClist,CLM_GETNEXTITEM, (WPARAM)CLGN_PARENT, (LPARAM)hItem); + hItem = (hParent != hRoot) ? hParent : 0; + } + ExIm.ptszName = ptszGroup; + ExIm.Typ = EXIM_SUBGROUP; + + if (wParam) { + //Export "/ExportGroup" + SvcExImport_Export(&ExIm, hClist); + } + else { + //Import "/ImportGroup" + SvcExImport_Import(&ExIm, hClist); + } + + return 0; +}; + + +/********************************* + *Ex/Import Account (AccountMenu) + *********************************/ +typedef struct +// neeed for MO_MENUITEMGETOWNERDATA +// taken from core clistmenus.ccp +{ + char *proto; //This is unique protoname + int protoindex; + int status; + + BOOL custom; + char *svc; + HANDLE hMenuItem; +} StatusMenuExecParam,*lpStatusMenuExecParam; + +/** + * This service is call by Account MenuItem Export and MenuItem Import + * + * @param wParam - not used + * @param lParam - MenuItem from MS_CLIST_ADDSTATUSMENUITEM + * + * @return always 0 + **/ +INT_PTR svcExIm_Account_Service(WPARAM wParam, LPARAM lParam) +{ + ExImParam ExIm; + ZeroMemory(&ExIm, sizeof(ExIm)); + HWND hClist = (HWND)CallService(MS_CLUI_GETHWNDTREE,0,0); + lpStatusMenuExecParam smep = (lpStatusMenuExecParam) CallService(MO_MENUITEMGETOWNERDATA, (WPARAM) lParam, NULL); + ExIm.pszName = mir_strdup(smep->proto); + ExIm.Typ = EXIM_ACCOUNT; + + if (strstr( smep->svc, "/ExportAccount" )) { + //Export "/ExportAccount" + SvcExImport_Export(&ExIm, hClist); + } + else { + //Import "/ImportAccount" + SvcExImport_Import(&ExIm, hClist); + } + mir_free(ExIm.pszName); + return 0; +}; + +/** + * name: SvcExImport_LoadModule() + * desc: initializes the Ex/Import Services + * + * return: 0 or 1 + **/ +VOID SvcExImport_LoadModule() +{ + myCreateServiceFunction(MS_USERINFO_VCARD_EXPORTALL, svcExIm_MainExport_Service); + myCreateServiceFunction(MS_USERINFO_VCARD_IMPORTALL, svcExIm_MainImport_Service); + myCreateServiceFunction(MS_USERINFO_VCARD_EXPORT, svcExIm_ContactExport_Service); + myCreateServiceFunction(MS_USERINFO_VCARD_IMPORT, svcExIm_ContactImport_Service); + return; +} diff --git a/plugins/UserInfoEx/ex_import/svc_ExImport.h b/plugins/UserInfoEx/ex_import/svc_ExImport.h new file mode 100644 index 0000000000..3539ad72cd --- /dev/null +++ b/plugins/UserInfoEx/ex_import/svc_ExImport.h @@ -0,0 +1,62 @@ +/* +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +=============================================================================== + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/svc_ExImport.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifndef _SVC_EXIMPORT_INCLUDED_ +#define _SVC_EXIMPORT_INCLUDED_ 1 + +typedef struct +{ + BYTE Typ; + union { + HANDLE hContact; + LPSTR pszName; + LPTSTR ptszName; + }; +} + ExImParam,*lpExImParam; + +enum ExImType { + EXIM_ALL = 1, + EXIM_CONTACT = 2, + EXIM_GROUP = 4, + EXIM_SUBGROUP = 8, + EXIM_ACCOUNT = 16 +}; + +INT_PTR svcExIm_MainExport_Service(WPARAM wParam, LPARAM lParam); +INT_PTR svcExIm_MainImport_Service(WPARAM wParam, LPARAM lParam); +INT_PTR svcExIm_ContactExport_Service(WPARAM wParam, LPARAM lParam); +INT_PTR svcExIm_ContactImport_Service(WPARAM wParam, LPARAM lParam); +INT_PTR svcExIm_Group_Service(WPARAM wParam,LPARAM lParam); +INT_PTR svcExIm_Account_Service(WPARAM wParam,LPARAM lParam); + +VOID SvcExImport_LoadModule(); + +#endif /* _SVC_EXIMPORT_INCLUDED_ */ \ No newline at end of file diff --git a/plugins/UserInfoEx/ex_import/tinystr.cpp b/plugins/UserInfoEx/ex_import/tinystr.cpp new file mode 100644 index 0000000000..3ec0fe4676 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinystr.cpp @@ -0,0 +1,143 @@ +/* +www.sourceforge.net/projects/tinyxml +Original file by Yves Berquin. + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +/* + * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005. + * + * - completely rewritten. compact, clean, and fast implementation. + * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems) + * - fixed reserve() to work as per specification. + * - fixed buggy compares operator==(), operator<(), and operator>() + * - fixed operator+=() to take a const ref argument, following spec. + * - added "copy" constructor with length, and most compare operators. + * - added swap(), clear(), size(), capacity(), operator+(). + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinystr.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== + */ + +#ifndef TIXML_USE_STL + +#ifdef USE_MMGR +#include +#include + +#include "mmgr.h" +#endif + +#include "tinystr.h" + +// Error value for find primitive +const TiXmlString::size_type TiXmlString::npos = static_cast< size_type >(-1); + +// Null rep. +TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, '\0' }; + + +void TiXmlString::reserve (size_type cap) +{ + if (cap > capacity()) + { + TiXmlString tmp; + tmp.init(length(), cap); + memcpy(tmp.start(), data(), length()); + swap(tmp); + } +} + + +TiXmlString& TiXmlString::assign(const char* str, size_type len) +{ + size_type cap = capacity(); + if (len > cap || cap > 3*(len + 8)) + { + TiXmlString tmp; + tmp.init(len); + memcpy(tmp.start(), str, len); + swap(tmp); + } + else + { + memmove(start(), str, len); + set_size(len); + } + return *this; +} + + +TiXmlString& TiXmlString::append(const char* str, size_type len) +{ + size_type newsize = length() + len; + if (newsize > capacity()) + { + reserve (newsize + capacity()); + } + memmove(finish(), str, len); + set_size(newsize); + return *this; +} + + +TiXmlString operator + (const TiXmlString & a, const TiXmlString & b) +{ + TiXmlString tmp; + tmp.reserve(a.length() + b.length()); + tmp += a; + tmp += b; + return tmp; +} + +TiXmlString operator + (const TiXmlString & a, const char* b) +{ + TiXmlString tmp; + TiXmlString::size_type b_len = static_cast(strlen(b)); + tmp.reserve(a.length() + b_len); + tmp += a; + tmp.append(b, b_len); + return tmp; +} + +TiXmlString operator + (const char* a, const TiXmlString & b) +{ + TiXmlString tmp; + TiXmlString::size_type a_len = static_cast(strlen(a)); + tmp.reserve(a_len + b.length()); + tmp.append(a, a_len); + tmp += b; + return tmp; +} + + +#endif // TIXML_USE_STL diff --git a/plugins/UserInfoEx/ex_import/tinystr.h b/plugins/UserInfoEx/ex_import/tinystr.h new file mode 100644 index 0000000000..1061e795d8 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinystr.h @@ -0,0 +1,335 @@ +/* +www.sourceforge.net/projects/tinyxml +Original file by Yves Berquin. + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +/* + * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005. + * + * - completely rewritten. compact, clean, and fast implementation. + * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems) + * - fixed reserve() to work as per specification. + * - fixed buggy compares operator==(), operator<(), and operator>() + * - fixed operator+=() to take a const ref argument, following spec. + * - added "copy" constructor with length, and most compare operators. + * - added swap(), clear(), size(), capacity(), operator+(). + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinystr.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== + */ + +#ifndef TIXML_USE_STL + +#ifndef TIXML_STRING_INCLUDED +#define TIXML_STRING_INCLUDED + +#ifndef USE_MMGR +#include +#include +#endif + +/* The support for explicit isn't that universal, and it isn't really + required - it is used to check that the TiXmlString class isn't incorrectly + used. Be nice to old compilers and macro it here: +*/ +#if defined(_MSC_VER) && (_MSC_VER >= 1200) + // Microsoft visual studio, version 6 and higher. + #define TIXML_EXPLICIT explicit +#elif defined(__GNUC__) && (__GNUC__ >= 3) + // GCC version 3 and higher.s + #define TIXML_EXPLICIT explicit +#else + #define TIXML_EXPLICIT +#endif + + +/* + TiXmlString is an emulation of a subset of the std::string template. + Its purpose is to allow compiling TinyXML on compilers with no or poor STL support. + Only the member functions relevant to the TinyXML project have been implemented. + The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase + a string and there's no more room, we allocate a buffer twice as big as we need. +*/ +class TiXmlString +{ + public : + // The size type used + typedef size_t size_type; + + // Error value for find primitive + static const size_type npos; // = -1; + + + // TiXmlString empty constructor + TiXmlString () : rep_(&nullrep_) + { + } + + // TiXmlString copy constructor + TiXmlString (const TiXmlString & copy) + { + init(copy.length()); + memcpy(start(), copy.data(), length()); + } + + // TiXmlString constructor, based on a string + TIXML_EXPLICIT TiXmlString (const char * copy) + { + init(static_cast(strlen(copy))); + memcpy(start(), copy, length()); + } + + // TiXmlString constructor, based on a string + TIXML_EXPLICIT TiXmlString (const char * str, size_type len) + { + init(len); + memcpy(start(), str, len); + } + + // TiXmlString destructor + ~TiXmlString () + { + quit(); + } + + // = operator + TiXmlString& operator = (const char * copy) + { + return assign(copy, (size_type)strlen(copy)); + } + + // = operator + TiXmlString& operator = (const TiXmlString & copy) + { + return assign(copy.start(), copy.length()); + } + + + // += operator. Maps to append + TiXmlString& operator += (const char * suffix) + { + return append(suffix, static_cast(strlen(suffix))); + } + + // += operator. Maps to append + TiXmlString& operator += (char single) + { + return append(&single, 1); + } + + // += operator. Maps to append + TiXmlString& operator += (const TiXmlString & suffix) + { + return append(suffix.data(), suffix.length()); + } + + + // Convert a TiXmlString into a null-terminated char * + const char * c_str () const { return rep_->str; } + + // Convert a TiXmlString into a char * (need not be null terminated). + const char * data () const { return rep_->str; } + + // Return the length of a TiXmlString + size_type length () const { return rep_->size; } + + // Alias for length() + size_type size () const { return rep_->size; } + + // Checks if a TiXmlString is empty + bool empty () const { return rep_->size == 0; } + + // Return capacity of string + size_type capacity () const { return rep_->capacity; } + + + // single char extraction + const char& at (size_type index) const + { + assert(index < length()); + return rep_->str[ index ]; + } + + // [] operator + char& operator [] (size_type index) const + { + assert(index < length()); + return rep_->str[ index ]; + } + + // find a char in a string. Return TiXmlString::npos if not found + size_type find (char lookup) const + { + return find(lookup, 0); + } + + // find a char in a string from an offset. Return TiXmlString::npos if not found + size_type find (char tofind, size_type offset) const + { + if (offset >= length()) return npos; + + for (const char* p = c_str() + offset; *p != '\0'; ++p) + { + if (*p == tofind) return static_cast< size_type >(p - c_str()); + } + return npos; + } + + void clear () + { + //Lee: + //The original was just too strange, though correct: + // TiXmlString().swap(*this); + //Instead use the quit & re-init: + quit(); + init(0,0); + } + + /* Function to reserve a big amount of data when we know we'll need it. Be aware that this + function DOES NOT clear the content of the TiXmlString if any exists. + */ + void reserve (size_type cap); + + TiXmlString& assign (const char* str, size_type len); + + TiXmlString& append (const char* str, size_type len); + + void swap (TiXmlString& other) + { + Rep* r = rep_; + rep_ = other.rep_; + other.rep_ = r; + } + + private: + + void init(size_type sz) { init(sz, sz); } + void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; } + char* start() const { return rep_->str; } + char* finish() const { return rep_->str + rep_->size; } + + struct Rep + { + size_type size, capacity; + char str[1]; + }; + + void init(size_type sz, size_type cap) + { + if (cap) + { + // Lee: the original form: + // rep_ = static_cast(operator new(sizeof(Rep) + cap)); + // doesn't work in some cases of new being overloaded. Switching + // to the normal allocation, although use an 'int' for systems + // that are overly picky about structure alignment. + const size_type bytesNeeded = sizeof(Rep) + cap; + const size_type intsNeeded = (bytesNeeded + sizeof(int) - 1) / sizeof(int); + rep_ = reinterpret_cast(new int[ intsNeeded ]); + + rep_->str[ rep_->size = sz ] = '\0'; + rep_->capacity = cap; + } + else + { + rep_ = &nullrep_; + } + } + + void quit() + { + if (rep_ != &nullrep_) + { + // The rep_ is really an array of ints. (see the allocator, above). + // Cast it back before delete, so the compiler won't incorrectly call destructors. + delete [] (reinterpret_cast(rep_)); + } + } + + Rep * rep_; + static Rep nullrep_; + +} ; + + +inline bool operator == (const TiXmlString & a, const TiXmlString & b) +{ + return (a.length() == b.length()) // optimization on some platforms + && (strcmp(a.c_str(), b.c_str()) == 0); // actual compare +} +inline bool operator < (const TiXmlString & a, const TiXmlString & b) +{ + return strcmp(a.c_str(), b.c_str()) < 0; +} + +inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); } +inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; } +inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); } +inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); } + +inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; } +inline bool operator == (const char* a, const TiXmlString & b) { return b == a; } +inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); } +inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); } + +TiXmlString operator + (const TiXmlString & a, const TiXmlString & b); +TiXmlString operator + (const TiXmlString & a, const char* b); +TiXmlString operator + (const char* a, const TiXmlString & b); + + +/* + TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString. + Only the operators that we need for TinyXML have been developped. +*/ +class TiXmlOutStream : public TiXmlString +{ +public : + + // TiXmlOutStream << operator. + TiXmlOutStream & operator << (const TiXmlString & in) + { + *this += in; + return *this; + } + + // TiXmlOutStream << operator. + TiXmlOutStream & operator << (const char * in) + { + *this += in; + return *this; + } + +} ; + +#endif // TIXML_STRING_INCLUDED +#endif // TIXML_USE_STL diff --git a/plugins/UserInfoEx/ex_import/tinyxml.cpp b/plugins/UserInfoEx/ex_import/tinyxml.cpp new file mode 100644 index 0000000000..2eba13a7ea --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinyxml.cpp @@ -0,0 +1,1978 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinyxml.cpp $ +Revision : $Revision: 196 $ +Last change on : $Date: 2010-09-21 03:24:30 +0400 (ะ’ั‚, 21 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== + */ +#include "tinyxml.h" + +#include + +#ifdef TIXML_USE_STL +#include +#include +#endif + +#ifdef USE_MMGR +#include +#include +#include +#include +#include + +#include "mmgr.h" +#endif + + +bool TiXmlBase::condenseWhiteSpace = true; + +void TiXmlBase::StreamDepth(TIXML_OSTREAM* stream, int depth) const +{ + for (int i = 0; i < depth; ++i) + { + (*stream) << " "; + } +} + +void TiXmlBase::PutString(const TIXML_STRING& str, TIXML_OSTREAM* stream) +{ + TIXML_STRING buffer; + PutString(str, &buffer); + (*stream) << buffer; +} + +void TiXmlBase::PutString(const TIXML_STRING& str, TIXML_STRING* outString) +{ + int i=0; + + while (i<(int)str.length()) + { + unsigned char c = (unsigned char) str[i]; + + if ( c == '&' + && i < ((int)str.length() - 2) + && str[i+1] == '#' + && str[i+2] == 'x') + { + // Hexadecimal character reference. + // Pass through unchanged. + // © -- copyright symbol, for example. + // + // The -1 is a bug fix from Rob Laveaux. It keeps + // an overflow from happening if there is no ';'. + // There are actually 2 ways to exit this loop - + // while fails (error case) and break (semicolon found). + // However, there is no mechanism (currently) for + // this function to return an error. + while (i<(int)str.length()-1) + { + outString->append(str.c_str() + i, 1); + ++i; + if (str[i] == ';') + break; + } + } + else if (c == '&') + { + outString->append(entity[0].str, entity[0].strLength); + ++i; + } + else if (c == '<') + { + outString->append(entity[1].str, entity[1].strLength); + ++i; + } + else if (c == '>') + { + outString->append(entity[2].str, entity[2].strLength); + ++i; + } + else if (c == '\"') + { + outString->append(entity[3].str, entity[3].strLength); + ++i; + } + else if (c == '\'') + { + outString->append(entity[4].str, entity[4].strLength); + ++i; + } + else if (c < 32) + { + // Easy pass at non-alpha/numeric/symbol + // Below 32 is symbolic. + char buf[ 32 ]; + + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "&#x%02X;", (unsigned) (c & 0xff)); + #else + sprintf(buf, "&#x%02X;", (unsigned) (c & 0xff)); + #endif + + //*ME: warning C4267: convert 'size_t' to 'int' + //*ME: Int-Cast to make compiler happy ... + outString->append(buf, (int)strlen(buf)); + ++i; + } + else + { + //char realc = (char) c; + //outString->append(&realc, 1); + *outString += (char) c; // somewhat more efficient function call. + ++i; + } + } +} + + +// <-- Strange class for a bug fix. Search for STL_STRING_BUG +TiXmlBase::StringToBuffer::StringToBuffer(const TIXML_STRING& str) +{ + buffer = new char[ str.length()+1 ]; + if (buffer) + { + strcpy(buffer, str.c_str()); + } +} + + +TiXmlBase::StringToBuffer::~StringToBuffer() +{ + delete [] buffer; +} +// End strange bug fix. --> + + +TiXmlNode::TiXmlNode(NodeType _type) : TiXmlBase() +{ + parent = 0; + type = _type; + firstChild = 0; + lastChild = 0; + prev = 0; + next = 0; +} + + +TiXmlNode::~TiXmlNode() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while (node) + { + temp = node; + node = node->next; + + delete temp; + } +} + + +void TiXmlNode::CopyTo(TiXmlNode* target) const +{ + target->SetValue (value.c_str()); + target->userData = userData; +} + + +void TiXmlNode::Clear() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while (node) + { + temp = node; + node = node->next; + delete temp; + } + + firstChild = 0; + lastChild = 0; +} + + +TiXmlNode* TiXmlNode::LinkEndChild(TiXmlNode* node) +{ + assert(node->parent == 0 || node->parent == this); + assert(node->GetDocument() == 0 || node->GetDocument() == this->GetDocument()); + + if (node->Type() == TiXmlNode::DOCUMENT) + { + delete node; + if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + + node->parent = this; + + node->prev = lastChild; + node->next = 0; + + if (lastChild) + lastChild->next = node; + else + firstChild = node; // it was an empty list. + + lastChild = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertEndChild(const TiXmlNode& addThis) +{ + if (addThis.Type() == TiXmlNode::DOCUMENT) + { + if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + TiXmlNode* node = addThis.Clone(); + if (!node) + return 0; + + return LinkEndChild(node); +} + + +TiXmlNode* TiXmlNode::InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis) +{ + if (!beforeThis || beforeThis->parent != this) { + return 0; + } + if (addThis.Type() == TiXmlNode::DOCUMENT) + { + if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if (!node) + return 0; + node->parent = this; + + node->next = beforeThis; + node->prev = beforeThis->prev; + if (beforeThis->prev) + { + beforeThis->prev->next = node; + } + else + { + assert(firstChild == beforeThis); + firstChild = node; + } + beforeThis->prev = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertAfterChild(TiXmlNode* afterThis, const TiXmlNode& addThis) +{ + if (!afterThis || afterThis->parent != this) { + return 0; + } + if (addThis.Type() == TiXmlNode::DOCUMENT) + { + if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if (!node) + return 0; + node->parent = this; + + node->prev = afterThis; + node->next = afterThis->next; + if (afterThis->next) + { + afterThis->next->prev = node; + } + else + { + assert(lastChild == afterThis); + lastChild = node; + } + afterThis->next = node; + return node; +} + + +TiXmlNode* TiXmlNode::ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis) +{ + if (replaceThis->parent != this) + return 0; + + TiXmlNode* node = withThis.Clone(); + if (!node) + return 0; + + node->next = replaceThis->next; + node->prev = replaceThis->prev; + + if (replaceThis->next) + replaceThis->next->prev = node; + else + lastChild = node; + + if (replaceThis->prev) + replaceThis->prev->next = node; + else + firstChild = node; + + delete replaceThis; + node->parent = this; + return node; +} + + +bool TiXmlNode::RemoveChild(TiXmlNode* removeThis) +{ + if (removeThis->parent != this) + { + assert(0); + return false; + } + + if (removeThis->next) + removeThis->next->prev = removeThis->prev; + else + lastChild = removeThis->prev; + + if (removeThis->prev) + removeThis->prev->next = removeThis->next; + else + firstChild = removeThis->next; + + delete removeThis; + return true; +} + +const TiXmlNode* TiXmlNode::FirstChild(const char * _value) const +{ + const TiXmlNode* node; + for (node = firstChild; node; node = node->next) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + + +TiXmlNode* TiXmlNode::FirstChild(const char * _value) +{ + TiXmlNode* node; + for (node = firstChild; node; node = node->next) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::LastChild(const char * _value) const +{ + const TiXmlNode* node; + for (node = lastChild; node; node = node->prev) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +TiXmlNode* TiXmlNode::LastChild(const char * _value) +{ + TiXmlNode* node; + for (node = lastChild; node; node = node->prev) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +const TiXmlNode* TiXmlNode::IterateChildren(const TiXmlNode* previous) const +{ + if (!previous) + { + return FirstChild(); + } + else + { + assert(previous->parent == this); + return previous->NextSibling(); + } +} + +TiXmlNode* TiXmlNode::IterateChildren(TiXmlNode* previous) +{ + if (!previous) + { + return FirstChild(); + } + else + { + assert(previous->parent == this); + return previous->NextSibling(); + } +} + +const TiXmlNode* TiXmlNode::IterateChildren(const char * val, const TiXmlNode* previous) const +{ + if (!previous) + { + return FirstChild(val); + } + else + { + assert(previous->parent == this); + return previous->NextSibling(val); + } +} + +TiXmlNode* TiXmlNode::IterateChildren(const char * val, TiXmlNode* previous) +{ + if (!previous) + { + return FirstChild(val); + } + else + { + assert(previous->parent == this); + return previous->NextSibling(val); + } +} + +const TiXmlNode* TiXmlNode::NextSibling(const char * _value) const +{ + const TiXmlNode* node; + for (node = next; node; node = node->next) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +TiXmlNode* TiXmlNode::NextSibling(const char * _value) +{ + TiXmlNode* node; + for (node = next; node; node = node->next) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +const TiXmlNode* TiXmlNode::PreviousSibling(const char * _value) const +{ + const TiXmlNode* node; + for (node = prev; node; node = node->prev) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +TiXmlNode* TiXmlNode::PreviousSibling(const char * _value) +{ + TiXmlNode* node; + for (node = prev; node; node = node->prev) + { + if (strcmp(node->Value(), _value) == 0) + return node; + } + return 0; +} + +void TiXmlElement::RemoveAttribute(const char * name) +{ + TIXML_STRING str(name); + TiXmlAttribute* node = attributeSet.Find(str); + if (node) + { + attributeSet.Remove(node); + delete node; + } +} + +const TiXmlElement* TiXmlNode::FirstChildElement() const +{ + const TiXmlNode* node; + + for ( node = FirstChild(); + node; + node = node->NextSibling()) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +TiXmlElement* TiXmlNode::FirstChildElement() +{ + TiXmlNode* node; + + for ( node = FirstChild(); + node; + node = node->NextSibling()) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +const TiXmlElement* TiXmlNode::FirstChildElement(const char * _value) const +{ + const TiXmlNode* node; + + for ( node = FirstChild(_value); + node; + node = node->NextSibling(_value)) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +TiXmlElement* TiXmlNode::FirstChildElement(const char * _value) +{ + TiXmlNode* node; + + for ( node = FirstChild(_value); + node; + node = node->NextSibling(_value)) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +const TiXmlElement* TiXmlNode::NextSiblingElement() const +{ + const TiXmlNode* node; + + for ( node = NextSibling(); + node; + node = node->NextSibling()) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +TiXmlElement* TiXmlNode::NextSiblingElement() +{ + TiXmlNode* node; + + for ( node = NextSibling(); + node; + node = node->NextSibling()) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +const TiXmlElement* TiXmlNode::NextSiblingElement(const char * _value) const +{ + const TiXmlNode* node; + + for ( node = NextSibling(_value); + node; + node = node->NextSibling(_value)) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + +TiXmlElement* TiXmlNode::NextSiblingElement(const char * _value) +{ + TiXmlNode* node; + + for ( node = NextSibling(_value); + node; + node = node->NextSibling(_value)) + { + if (node->ToElement()) + return node->ToElement(); + } + return 0; +} + + +const TiXmlDocument* TiXmlNode::GetDocument() const +{ + const TiXmlNode* node; + + for (node = this; node; node = node->parent) + { + if (node->ToDocument()) + return node->ToDocument(); + } + return 0; +} + +TiXmlDocument* TiXmlNode::GetDocument() +{ + TiXmlNode* node; + + for (node = this; node; node = node->parent) + { + if (node->ToDocument()) + return node->ToDocument(); + } + return 0; +} + +TiXmlElement::TiXmlElement (const char * _value) + : TiXmlNode(TiXmlNode::ELEMENT) +{ + firstChild = lastChild = 0; + value = _value; +} + + +#ifdef TIXML_USE_STL +TiXmlElement::TiXmlElement(const std::string& _value) + : TiXmlNode(TiXmlNode::ELEMENT) +{ + firstChild = lastChild = 0; + value = _value; +} +#endif + + +TiXmlElement::TiXmlElement(const TiXmlElement& copy) + : TiXmlNode(TiXmlNode::ELEMENT) +{ + firstChild = lastChild = 0; + copy.CopyTo(this); +} + + +void TiXmlElement::operator=(const TiXmlElement& base) +{ + ClearThis(); + base.CopyTo(this); +} + + +TiXmlElement::~TiXmlElement() +{ + ClearThis(); +} + + +void TiXmlElement::ClearThis() +{ + Clear(); + while (attributeSet.First()) + { + TiXmlAttribute* node = attributeSet.First(); + attributeSet.Remove(node); + delete node; + } +} + + +const char * TiXmlElement::Attribute(const char * name) const +{ + TIXML_STRING str(name); + const TiXmlAttribute* node = attributeSet.Find(str); + + if (node) + return node->Value(); + + return 0; +} + + +const char * TiXmlElement::Attribute(const char * name, int* i) const +{ + const char * s = Attribute(name); + if (i) + { + if (s) + *i = (int)_atoi64(s); + else + *i = 0; + } + return s; +} + + +const char * TiXmlElement::Attribute(const char * name, double* d) const +{ + const char * s = Attribute(name); + if (d) + { + if (s) + *d = atof(s); + else + *d = 0; + } + return s; +} + + +int TiXmlElement::QueryIntAttribute(const char* name, int* ival) const +{ + TIXML_STRING str(name); + const TiXmlAttribute* node = attributeSet.Find(str); + if (!node) + return TIXML_NO_ATTRIBUTE; + + return node->QueryIntValue(ival); +} + + +int TiXmlElement::QueryDoubleAttribute(const char* name, double* dval) const +{ + TIXML_STRING str(name); + const TiXmlAttribute* node = attributeSet.Find(str); + if (!node) + return TIXML_NO_ATTRIBUTE; + + return node->QueryDoubleValue(dval); +} + + +void TiXmlElement::SetAttribute(const char * name, int val) +{ + char buf[64]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%d", val); + #else + sprintf(buf, "%d", val); + #endif + SetAttribute(name, buf); +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute(const std::string& name, int val) +{ + std::ostringstream oss; + oss << val; + SetAttribute(name, oss.str()); +} +#endif + + +void TiXmlElement::SetDoubleAttribute(const char * name, double val) +{ + char buf[256]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%f", val); + #else + sprintf(buf, "%f", val); + #endif + SetAttribute(name, buf); +} + + +void TiXmlElement::SetAttribute(const char * cname, const char * cvalue) +{ + TIXML_STRING _name(cname); + TIXML_STRING _value(cvalue); + + TiXmlAttribute* node = attributeSet.Find(_name); + if (node) + { + node->SetValue(cvalue); + return; + } + + TiXmlAttribute* attrib = new TiXmlAttribute(cname, cvalue); + if (attrib) + { + attributeSet.Add(attrib); + } + else + { + TiXmlDocument* document = GetDocument(); + if (document) document->SetError(TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute(const std::string& name, const std::string& _value) +{ + TiXmlAttribute* node = attributeSet.Find(name); + if (node) + { + node->SetValue(_value); + return; + } + + TiXmlAttribute* attrib = new TiXmlAttribute(name, _value); + if (attrib) + { + attributeSet.Add(attrib); + } + else + { + TiXmlDocument* document = GetDocument(); + if (document) document->SetError(TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN); + } +} +#endif + + +void TiXmlElement::Print(FILE* cfile, int depth) const +{ + int i; + for (i=0; iNext()) + { + fprintf(cfile, " "); + attrib->Print(cfile, depth); + } + + // There are 3 different formatting approaches: + // 1) An element without children is printed as a node + // 2) An element with only a text child is printed as text + // 3) An element with children is printed on multiple lines. + TiXmlNode* node; + if (!firstChild) + { + fprintf(cfile, " />"); + } + else if (firstChild == lastChild && firstChild->ToText()) + { + fprintf(cfile, ">"); + firstChild->Print(cfile, depth + 1); + fprintf(cfile, "", value.c_str()); + } + else + { + fprintf(cfile, ">"); + + for (node = firstChild; node; node=node->NextSibling()) + { + if (!node->ToText()) + { + fprintf(cfile, "\n"); + } + node->Print(cfile, depth+1); + } + fprintf(cfile, "\n"); + for (i=0; i", value.c_str()); + } +} + +void TiXmlElement::StreamOut(TIXML_OSTREAM * stream) const +{ + (*stream) << "<" << value; + + const TiXmlAttribute* attrib; + for (attrib = attributeSet.First(); attrib; attrib = attrib->Next()) + { + (*stream) << " "; + attrib->StreamOut(stream); + } + + // If this node has children, give it a closing tag. Else + // make it an empty tag. + TiXmlNode* node; + if (firstChild) + { + (*stream) << ">"; + + for (node = firstChild; node; node=node->NextSibling()) + { + node->StreamOut(stream); + } + (*stream) << ""; + } + else + { + (*stream) << " />"; + } +} + +void TiXmlElement::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const +{ + // Adding tabs to get the proper tree format + int oldDepth = depth; + StreamDepth(stream, depth); + + // Element name + (*stream) << "<" << value; + + // Attributes + const TiXmlAttribute* attrib; + for (attrib = attributeSet.First(); attrib; attrib = attrib->Next()) + { + (*stream) << " "; + attrib->StreamOut(stream); + } + + // There are 3 different formatting approaches: + // 1) An element without children is printed as a node + // 2) An element with only a text child is printed as text + // 3) An element with children is printed on multiple lines. + TiXmlNode* node; + if (!firstChild) + { + (*stream) << " />" << TIXML_ENDL; + } + else if (firstChild == lastChild && firstChild->ToText()) + { + (*stream) << ">"; + firstChild->FormattedStreamOut(stream, depth + 1); + (*stream) << "" << TIXML_ENDL; + } + else + { + (*stream) << ">" << TIXML_ENDL; + + // Children + depth++; + for (node = firstChild; node; node=node->NextSibling()) + { + node->FormattedStreamOut(stream, depth); + } + StreamDepth(stream, oldDepth); + (*stream) << "" << TIXML_ENDL; + } +} + +void TiXmlElement::CopyTo(TiXmlElement* target) const +{ + // superclass: + TiXmlNode::CopyTo(target); + + // Element class: + // Clone the attributes, then clone the children. + const TiXmlAttribute* attribute = 0; + for ( attribute = attributeSet.First(); + attribute; + attribute = attribute->Next()) + { + target->SetAttribute(attribute->Name(), attribute->Value()); + } + + TiXmlNode* node = 0; + for (node = firstChild; node; node = node->NextSibling()) + { + target->LinkEndChild(node->Clone()); + } +} + + +TiXmlNode* TiXmlElement::Clone() const +{ + TiXmlElement* clone = new TiXmlElement(Value()); + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +const char* TiXmlElement::GetText() const +{ + const TiXmlNode* child = this->FirstChild(); + if (child) { + const TiXmlText* childText = child->ToText(); + if (childText) { + return childText->Value(); + } + } + return 0; +} + + +TiXmlDocument::TiXmlDocument() : TiXmlNode(TiXmlNode::DOCUMENT) +{ + tabsize = 4; + useMicrosoftBOM = false; + ClearError(); +} + +TiXmlDocument::TiXmlDocument(const char * documentName) : TiXmlNode(TiXmlNode::DOCUMENT) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} + + +#ifdef TIXML_USE_STL +TiXmlDocument::TiXmlDocument(const std::string& documentName) : TiXmlNode(TiXmlNode::DOCUMENT) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} +#endif + + +TiXmlDocument::TiXmlDocument(const TiXmlDocument& copy) : TiXmlNode(TiXmlNode::DOCUMENT) +{ + copy.CopyTo(this); +} + + +void TiXmlDocument::operator=(const TiXmlDocument& copy) +{ + Clear(); + copy.CopyTo(this); +} + + +bool TiXmlDocument::LoadFile(TiXmlEncoding encoding) +{ + // See STL_STRING_BUG below. + StringToBuffer buf(value); + + if (buf.buffer && LoadFile(buf.buffer, encoding)) + return true; + + return false; +} + + +bool TiXmlDocument::SaveFile() const +{ + // See STL_STRING_BUG below. + StringToBuffer buf(value); + + if (buf.buffer && SaveFile(buf.buffer)) + return true; + + return false; +} + +#ifdef TIXML_USE_STL +std::string TiXmlDocument::GetAsString() +{ + std::stringstream out; + FormattedStreamOut(&out, 0); + return out.str(); +} +#endif + +bool TiXmlDocument::GetAsCharBuffer(char* buffer, size_t bufferSize) +{ + #ifdef TIXML_USE_STL + std::string data = GetAsString(); + #else + TIXML_OSTREAM data; + FormattedStreamOut(&data, 0); + #endif + + if (bufferSize < data.length()) + { + return false; + } + else + { + strcpy(buffer, data.c_str()); + return true; + } +} + +bool TiXmlDocument::LoadFile(const char* filename, TiXmlEncoding encoding) +{ + // There was a really terrifying little bug here. The code: + // value = filename + // in the STL case, cause the assignment method of the std::string to + // be called. What is strange, is that the std::string had the same + // address as it's c_str() method, and so bad things happen. Looks + // like a bug in the Microsoft STL implementation. + // See STL_STRING_BUG above. + // Fixed with the StringToBuffer class. + value = filename; + + // reading in binary mode so that tinyxml can normalize the EOL + FILE* file = fopen(value.c_str (), "rb"); + + if (file) + { + bool result = LoadFile(file, encoding); + fclose(file); + return result; + } + else + { + SetError(TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN); + return false; + } +} + +bool TiXmlDocument::LoadFile(FILE* file, TiXmlEncoding encoding) +{ + if (!file) + { + SetError(TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN); + return false; + } + + // Delete the existing data: + Clear(); + location.Clear(); + + // Get the file size, so we can pre-allocate the string. HUGE speed impact. + long length = 0; + fseek(file, 0, SEEK_END); + length = ftell(file); + fseek(file, 0, SEEK_SET); + + // Strange case, but good to handle up front. + if (length == 0) + { + SetError(TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN); + return false; + } + + // If we have a file, assume it is all one big XML file, and read it in. + // The document parser may decide the document ends sooner than the entire file, however. + TIXML_STRING data; + data.reserve(length); + + // Subtle bug here. TinyXml did use fgets. But from the XML spec: + // 2.11 End-of-Line Handling + // + // + // ...the XML processor MUST behave as if it normalized all line breaks in external + // parsed entities (including the document entity) on input, before parsing, by translating + // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to + // a single #xA character. + // + // + // It is not clear fgets does that, and certainly isn't clear it works cross platform. + // Generally, you expect fgets to translate from the convention of the OS to the c/unix + // convention, and not work generally. + + /* + while (fgets(buf, sizeof(buf), file)) + { + data += buf; + } + */ + + char* buf = new char[ length+1 ]; + buf[0] = 0; + + if (fread(buf, length, 1, file) != 1) { + delete [] buf; + SetError(TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN); + return false; + } + + const char* lastPos = buf; + const char* p = buf; + + buf[length] = 0; + while (*p) { + assert(p < (buf+length)); + if (*p == 0xa) { + // Newline character. No special rules for this. Append all the characters + // since the last string, and include the newline. + data.append(lastPos, (p-lastPos+1)); // append, include the newline + ++p; // move past the newline + lastPos = p; // and point to the new buffer (may be 0) + assert(p <= (buf+length)); + } + else if (*p == 0xd) { + // Carriage return. Append what we have so far, then + // handle moving forward in the buffer. + if ((p-lastPos) > 0) { + data.append(lastPos, p-lastPos); // do not add the CR + } + data += (char)0xa; // a proper newline + + if (*(p+1) == 0xa) { + // Carriage return - new line sequence + p += 2; + lastPos = p; + assert(p <= (buf+length)); + } + else { + // it was followed by something else...that is presumably characters again. + ++p; + lastPos = p; + assert(p <= (buf+length)); + } + } + else { + ++p; + } + } + // Handle any left over characters. + if (p-lastPos) { + data.append(lastPos, p-lastPos); + } + delete [] buf; + buf = 0; + + Parse(data.c_str(), 0, encoding); + + if ( Error()) + return false; + else + return true; +} + + +bool TiXmlDocument::SaveFile(const char * filename) const +{ + // The old c stuff lives on... + FILE* fp = fopen(filename, "w"); + if (fp) + { + bool result = SaveFile(fp); + fclose(fp); + return result; + } + return false; +} + + +bool TiXmlDocument::SaveFile(FILE* fp) const +{ + if (useMicrosoftBOM) + { + const unsigned char TIXML_UTF_LEAD_0 = 0xefU; + const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; + const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + + fputc(TIXML_UTF_LEAD_0, fp); + fputc(TIXML_UTF_LEAD_1, fp); + fputc(TIXML_UTF_LEAD_2, fp); + } + Print(fp, 0); + return true; +} + + +void TiXmlDocument::CopyTo(TiXmlDocument* target) const +{ + TiXmlNode::CopyTo(target); + + target->error = error; + target->errorDesc = errorDesc.c_str (); + + TiXmlNode* node = 0; + for (node = firstChild; node; node = node->NextSibling()) + { + target->LinkEndChild(node->Clone()); + } +} + + +TiXmlNode* TiXmlDocument::Clone() const +{ + TiXmlDocument* clone = new TiXmlDocument(); + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +void TiXmlDocument::Print(FILE* cfile, int depth) const +{ + const TiXmlNode* node; + for (node=FirstChild(); node; node=node->NextSibling()) + { + node->Print(cfile, depth); + fprintf(cfile, "\n"); + } +} + +void TiXmlDocument::StreamOut(TIXML_OSTREAM * out) const +{ + const TiXmlNode* node; + for (node=FirstChild(); node; node=node->NextSibling()) + { + node->StreamOut(out); + + // Special rule for streams: stop after the root element. + // The stream in code will only read one element, so don't + // write more than one. + if (node->ToElement()) + break; + } +} + +void TiXmlDocument::FormattedStreamOut(TIXML_OSTREAM * out, int depth) const +{ + const TiXmlNode* node; + for (node=FirstChild(); node; node=node->NextSibling()) + { + node->FormattedStreamOut(out, depth); + + // Special rule for streams: stop after the root element. + // The stream in code will only read one element, so don't + // write more than one. + if (node->ToElement()) + break; + } +} + +const TiXmlAttribute* TiXmlAttribute::Next() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if (next->value.empty() && next->name.empty()) + return 0; + return next; +} + +TiXmlAttribute* TiXmlAttribute::Next() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if (next->value.empty() && next->name.empty()) + return 0; + return next; +} + +const TiXmlAttribute* TiXmlAttribute::Previous() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if (prev->value.empty() && prev->name.empty()) + return 0; + return prev; +} + +TiXmlAttribute* TiXmlAttribute::Previous() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if (prev->value.empty() && prev->name.empty()) + return 0; + return prev; +} + +void TiXmlAttribute::Print(FILE* cfile, int /*depth*/) const +{ + TIXML_STRING n, v; + + PutString(name, &n); + PutString(value, &v); + + if (value.find ('\"') == TIXML_STRING::npos) + fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str()); + else + fprintf (cfile, "%s='%s'", n.c_str(), v.c_str()); +} + + +void TiXmlAttribute::StreamOut(TIXML_OSTREAM * stream) const +{ + if (value.find('\"') != TIXML_STRING::npos) + { + PutString(name, stream); + (*stream) << "=" << "'"; + PutString(value, stream); + (*stream) << "'"; + } + else + { + PutString(name, stream); + (*stream) << "=" << "\""; + PutString(value, stream); + (*stream) << "\""; + } +} + +int TiXmlAttribute::QueryIntValue(int* ival) const +{ + if (sscanf(value.c_str(), "%d", ival) == 1) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +int TiXmlAttribute::QueryDoubleValue(double* dval) const +{ + if (sscanf(value.c_str(), "%lf", dval) == 1) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +void TiXmlAttribute::SetIntValue(int _value) +{ + char buf [64]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value); + #else + sprintf (buf, "%d", _value); + #endif + SetValue (buf); +} + +void TiXmlAttribute::SetDoubleValue(double _value) +{ + char buf [256]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%lf", _value); + #else + sprintf (buf, "%lf", _value); + #endif + SetValue (buf); +} + +int TiXmlAttribute::IntValue() const +{ + return (int)_atoi64(value.c_str ()); +} + +double TiXmlAttribute::DoubleValue() const +{ + return atof (value.c_str ()); +} + + +TiXmlComment::TiXmlComment(const TiXmlComment& copy) : TiXmlNode(TiXmlNode::COMMENT) +{ + copy.CopyTo(this); +} + + +void TiXmlComment::operator=(const TiXmlComment& base) +{ + Clear(); + base.CopyTo(this); +} + + +void TiXmlComment::Print(FILE* cfile, int depth) const +{ + for (int i=0; i", value.c_str()); +} + +void TiXmlComment::StreamOut(TIXML_OSTREAM * stream) const +{ + (*stream) << ""; +} + +void TiXmlComment::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const +{ + StreamDepth(stream, depth); + + StreamOut(stream); + + (*stream) << TIXML_ENDL; +} + +void TiXmlComment::CopyTo(TiXmlComment* target) const +{ + TiXmlNode::CopyTo(target); +} + + +TiXmlNode* TiXmlComment::Clone() const +{ + TiXmlComment* clone = new TiXmlComment(); + + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +void TiXmlText::Print(FILE* cfile, int depth) const +{ + if (cdata) + { + int i; + fprintf(cfile, "\n"); + for (i=0; i\n"); + } + else + { + TIXML_STRING buffer; + PutString(value, &buffer); + fprintf(cfile, "%s", buffer.c_str()); + } +} + + +void TiXmlText::StreamOut(TIXML_OSTREAM * stream) const +{ + if (cdata) + { + (*stream) << ""; + } + else + { + PutString(value, stream); + } +} + +void TiXmlText::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const +{ + if (cdata) + { + (*stream) << TIXML_ENDL; + StreamDepth(stream, depth); + (*stream) << "" << TIXML_ENDL; + } + else + { + PutString(value, stream); + } +} + +void TiXmlText::CopyTo(TiXmlText* target) const +{ + TiXmlNode::CopyTo(target); + target->cdata = cdata; +} + + +TiXmlNode* TiXmlText::Clone() const +{ + TiXmlText* clone = 0; + clone = new TiXmlText(""); + + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +TiXmlDeclaration::TiXmlDeclaration(const char * _version, + const char * _encoding, + const char * _standalone) + : TiXmlNode(TiXmlNode::DECLARATION) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} + + +#ifdef TIXML_USE_STL +TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone) + : TiXmlNode(TiXmlNode::DECLARATION) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} +#endif + + +TiXmlDeclaration::TiXmlDeclaration(const TiXmlDeclaration& copy) + : TiXmlNode(TiXmlNode::DECLARATION) +{ + copy.CopyTo(this); +} + + +void TiXmlDeclaration::operator=(const TiXmlDeclaration& copy) +{ + Clear(); + copy.CopyTo(this); +} + + +void TiXmlDeclaration::Print(FILE* cfile, int /*depth*/) const +{ + fprintf (cfile, ""); +} + +void TiXmlDeclaration::StreamOut(TIXML_OSTREAM * stream) const +{ + (*stream) << ""; +} + +void TiXmlDeclaration::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const +{ + StreamDepth(stream, depth); + StreamOut(stream); + (*stream) << TIXML_ENDL; +} + +void TiXmlDeclaration::CopyTo(TiXmlDeclaration* target) const +{ + TiXmlNode::CopyTo(target); + + target->version = version; + target->encoding = encoding; + target->standalone = standalone; +} + + +TiXmlNode* TiXmlDeclaration::Clone() const +{ + TiXmlDeclaration* clone = new TiXmlDeclaration(); + + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +void TiXmlUnknown::Print(FILE* cfile, int depth) const +{ + for (int i=0; i", value.c_str()); +} + + +void TiXmlUnknown::StreamOut(TIXML_OSTREAM * stream) const +{ + (*stream) << "<" << value << ">"; // Don't use entities here! It is unknown. +} + +void TiXmlUnknown::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const +{ + StreamDepth(stream, depth); + (*stream) << "<" << value << ">" << TIXML_ENDL; // Don't use entities here! It is unknown. +} + +void TiXmlUnknown::CopyTo(TiXmlUnknown* target) const +{ + TiXmlNode::CopyTo(target); +} + + +TiXmlNode* TiXmlUnknown::Clone() const +{ + TiXmlUnknown* clone = new TiXmlUnknown(); + + if (!clone) + return 0; + + CopyTo(clone); + return clone; +} + + +TiXmlAttributeSet::TiXmlAttributeSet() +{ + sentinel.next = &sentinel; + sentinel.prev = &sentinel; +} + + +TiXmlAttributeSet::~TiXmlAttributeSet() +{ + assert(sentinel.next == &sentinel); + assert(sentinel.prev == &sentinel); +} + + +void TiXmlAttributeSet::Add(TiXmlAttribute* addMe) +{ + assert(!Find(TIXML_STRING(addMe->Name()))); // Shouldn't be multiply adding to the set. + + addMe->next = &sentinel; + addMe->prev = sentinel.prev; + + sentinel.prev->next = addMe; + sentinel.prev = addMe; +} + +void TiXmlAttributeSet::Remove(TiXmlAttribute* removeMe) +{ + TiXmlAttribute* node; + + for (node = sentinel.next; node != &sentinel; node = node->next) + { + if (node == removeMe) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; + return; + } + } + assert(0); // we tried to remove a non-linked attribute. +} + +const TiXmlAttribute* TiXmlAttributeSet::Find(const TIXML_STRING& name) const +{ + const TiXmlAttribute* node; + + for (node = sentinel.next; node != &sentinel; node = node->next) + { + if (node->name == name) + return node; + } + return 0; +} + +TiXmlAttribute* TiXmlAttributeSet::Find(const TIXML_STRING& name) +{ + TiXmlAttribute* node; + + for (node = sentinel.next; node != &sentinel; node = node->next) + { + if (node->name == name) + return node; + } + return 0; +} + +#ifdef TIXML_USE_STL +TIXML_ISTREAM & operator >> (TIXML_ISTREAM & in, TiXmlNode & base) +{ + TIXML_STRING tag; + tag.reserve(8 * 1000); + base.StreamIn(&in, &tag); + + base.Parse(tag.c_str(), 0, TIXML_DEFAULT_ENCODING); + return in; +} +#endif + + +TIXML_OSTREAM & operator<< (TIXML_OSTREAM & out, const TiXmlNode & base) +{ + base.StreamOut (& out); + return out; +} + + +#ifdef TIXML_USE_STL +std::string & operator<< (std::string& out, const TiXmlNode& base) +{ + std::ostringstream os_stream(std::ostringstream::out); + base.StreamOut(&os_stream); + + out.append(os_stream.str()); + return out; +} +#endif + + +TiXmlHandle TiXmlHandle::FirstChild() const +{ + if (node) + { + TiXmlNode* child = node->FirstChild(); + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::FirstChild(const char * value) const +{ + if (node) + { + TiXmlNode* child = node->FirstChild(value); + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement() const +{ + if (node) + { + TiXmlElement* child = node->FirstChildElement(); + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement(const char * value) const +{ + if (node) + { + TiXmlElement* child = node->FirstChildElement(value); + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::Child(int count) const +{ + if (node) + { + int i; + TiXmlNode* child = node->FirstChild(); + for ( i=0; + child && iNextSibling(), ++i) + { + // nothing + } + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::Child(const char* value, int count) const +{ + if (node) + { + int i; + TiXmlNode* child = node->FirstChild(value); + for ( i=0; + child && iNextSibling(value), ++i) + { + // nothing + } + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::ChildElement(int count) const +{ + if (node) + { + int i; + TiXmlElement* child = node->FirstChildElement(); + for ( i=0; + child && iNextSiblingElement(), ++i) + { + // nothing + } + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} + + +TiXmlHandle TiXmlHandle::ChildElement(const char* value, int count) const +{ + if (node) + { + int i; + TiXmlElement* child = node->FirstChildElement(value); + for ( i=0; + child && iNextSiblingElement(value), ++i) + { + // nothing + } + if (child) + return TiXmlHandle(child); + } + return TiXmlHandle(0); +} diff --git a/plugins/UserInfoEx/ex_import/tinyxml.h b/plugins/UserInfoEx/ex_import/tinyxml.h new file mode 100644 index 0000000000..b8246f4953 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinyxml.h @@ -0,0 +1,1597 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinyxml.h $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + + +#ifndef TINYXML_INCLUDED +#define TINYXML_INCLUDED + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4530) +#pragma warning(disable : 4786) +#endif + +#ifndef USE_MMGR +#include +#include +#include +#include +#include +#endif + +// Help out windows: +#if defined(_DEBUG) && !defined(DEBUG) +#define DEBUG +#endif + +#ifdef TIXML_USE_TICPP + #ifndef TIXML_USE_STL + #define TIXML_USE_STL + #endif +#endif + +#ifdef TIXML_USE_STL + #include + #include + #include + #define TIXML_STRING std::string + #define TIXML_ISTREAM std::istream + #define TIXML_OSTREAM std::ostream + #define TIXML_ENDL std::endl +#else + #include "tinystr.h" + #define TIXML_STRING TiXmlString + #define TIXML_OSTREAM TiXmlOutStream + #define TIXML_ENDL "\n" +#endif + +// Deprecated library function hell. Compilers want to use the +// new safe versions. This probably doesn't fully address the problem, +// but it gets closer. There are too many compilers for me to fully +// test. If you get compilation troubles, undefine TIXML_SAFE + +#define TIXML_SAFE // TinyXml isn't fully buffer overrun protected, safe code. This is work in progress. +#ifdef TIXML_SAFE + #if defined(_MSC_VER) && (_MSC_VER >= 1400) + // Microsoft visual studio, version 2005 and higher. + #define TIXML_SNPRINTF _snprintf_s + #define TIXML_SNSCANF _snscanf_s + #elif defined(_MSC_VER) && (_MSC_VER >= 1200) + // Microsoft visual studio, version 6 and higher. + //#pragma message("Using _sn* functions.") + #define TIXML_SNPRINTF _snprintf + #define TIXML_SNSCANF _snscanf + #elif defined(__GNUC__) && (__GNUC__ >= 3) + // GCC version 3 and higher.s + //#warning("Using sn* functions.") + #define TIXML_SNPRINTF snprintf + #define TIXML_SNSCANF snscanf + #endif +#endif + +class TiXmlDocument; +class TiXmlElement; +class TiXmlComment; +class TiXmlUnknown; +class TiXmlAttribute; +class TiXmlText; +class TiXmlDeclaration; +class TiXmlParsingData; + +const int TIXML_MAJOR_VERSION = 2; +const int TIXML_MINOR_VERSION = 4; +const int TIXML_PATCH_VERSION = 3; + +/* Internal structure for tracking location of items + in the XML file. +*/ +struct TiXmlCursor +{ + TiXmlCursor() { Clear(); } + void Clear() { row = col = -1; } + + int row; // 0 based. + int col; // 0 based. +}; + + +// Only used by Attribute::Query functions +enum +{ + TIXML_SUCCESS, + TIXML_NO_ATTRIBUTE, + TIXML_WRONG_TYPE +}; + + +// Used by the parsing routines. +enum TiXmlEncoding +{ + TIXML_ENCODING_UNKNOWN, + TIXML_ENCODING_UTF8, + TIXML_ENCODING_LEGACY +}; + +const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN; + +/** TiXmlBase is a base class for every class in TinyXml. + It does little except to establish that TinyXml classes + can be printed and provide some utility functions. + + In XML, the document and elements can contain + other elements and other types of nodes. + + @verbatim + A Document can contain: Element (container or leaf) + Comment (leaf) + Unknown (leaf) + Declaration(leaf) + + An Element can contain: Element (container or leaf) + Text (leaf) + Attributes (not on tree) + Comment (leaf) + Unknown (leaf) + + A Decleration contains: Attributes (not on tree) + @endverbatim +*/ +#ifdef TIXML_USE_TICPP +#include "ticpprc.h" +class TiXmlBase : public TiCppRC +#else +class TiXmlBase +#endif +{ + friend class TiXmlNode; + friend class TiXmlElement; + friend class TiXmlDocument; + +public: + TiXmlBase() : userData(0) {} + virtual ~TiXmlBase() {} + + /** All TinyXml classes can print themselves to a filestream. + This is a formatted print, and will insert tabs and newlines. + + (For an unformatted stream, use the << operator.) + */ + virtual void Print(FILE* cfile, int depth) const = 0; + + /** The world does not agree on whether white space should be kept or + not. In order to make everyone happy, these global, static functions + are provided to set whether or not TinyXml will condense all white space + into a single space or not. The default is to condense. Note changing this + values is not thread safe. + */ + static void SetCondenseWhiteSpace(bool condense) { condenseWhiteSpace = condense; } + + /// Return the current white space setting. + static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; } + + /** Return the position, in the original source file, of this node or attribute. + The row and column are 1-based. (That is the first row and first column is + 1,1). If the returns values are 0 or less, then the parser does not have + a row and column value. + + Generally, the row and column value will be set when the TiXmlDocument::Load(), + TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set + when the DOM was created from operator>>. + + The values reflect the initial load. Once the DOM is modified programmatically + (by adding or changing nodes and attributes) the new values will NOT update to + reflect changes in the document. + + There is a minor performance cost to computing the row and column. Computation + can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value. + + @sa TiXmlDocument::SetTabSize() + */ + int Row() const { return location.row + 1; } + int Column() const { return location.col + 1; } ///< See Row() + + void _SetUserData(void* user) { userData = user; } + void* _GetUserData() { return userData; } + + // Table that returs, for a given lead byte, the total number of bytes + // in the UTF-8 sequence. + static const int utf8ByteTable[256]; + + virtual const char* Parse( const char* p, + TiXmlParsingData* data, + TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */) = 0; + + enum + { + TIXML_NO_ERROR = 0, + TIXML_ERROR, + TIXML_ERROR_OPENING_FILE, + TIXML_ERROR_OUT_OF_MEMORY, + TIXML_ERROR_PARSING_ELEMENT, + TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, + TIXML_ERROR_READING_ELEMENT_VALUE, + TIXML_ERROR_READING_ATTRIBUTES, + TIXML_ERROR_PARSING_EMPTY, + TIXML_ERROR_READING_END_TAG, + TIXML_ERROR_PARSING_UNKNOWN, + TIXML_ERROR_PARSING_COMMENT, + TIXML_ERROR_PARSING_DECLARATION, + TIXML_ERROR_DOCUMENT_EMPTY, + TIXML_ERROR_EMBEDDED_NULL, + TIXML_ERROR_PARSING_CDATA, + TIXML_ERROR_DOCUMENT_TOP_ONLY, + + TIXML_ERROR_STRING_COUNT + }; + +protected: + + void StreamDepth(TIXML_OSTREAM* stream, int depth) const; + + // See STL_STRING_BUG + // Utility class to overcome a bug. + class StringToBuffer + { + public: + StringToBuffer(const TIXML_STRING& str); + ~StringToBuffer(); + char* buffer; + }; + + static const char* SkipWhiteSpace(const char*, TiXmlEncoding encoding); + inline static bool IsWhiteSpace(char c) + { + return (isspace((unsigned char) c) || c == '\n' || c == '\r'); + } + inline static bool IsWhiteSpace(int c) + { + if (c < 256) + return IsWhiteSpace((char) c); + return false; // Again, only truly correct for English/Latin...but usually works. + } + + virtual void StreamOut (TIXML_OSTREAM *) const = 0; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const = 0; + + #ifdef TIXML_USE_STL + static bool StreamWhiteSpace(TIXML_ISTREAM * in, TIXML_STRING * tag); + static bool StreamTo(TIXML_ISTREAM * in, int character, TIXML_STRING * tag); + #endif + + /* Reads an XML name into the string provided. Returns + a pointer just past the last character of the name, + or 0 if the function has an error. + */ + static const char* ReadName(const char* p, TIXML_STRING* name, TiXmlEncoding encoding); + + /* Reads text. Returns a pointer past the given end tag. + Wickedly complex options, but it keeps the (sensitive) code in one place. + */ + static const char* ReadText( const char* in, // where to start + TIXML_STRING* text, // the string read + bool ignoreWhiteSpace, // whether to keep the white space + const char* endTag, // what ends this text + bool ignoreCase, // whether to ignore case in the end tag + TiXmlEncoding encoding); // the current encoding + + // If an entity has been found, transform it into a character. + static const char* GetEntity(const char* in, char* value, int* length, TiXmlEncoding encoding); + + // Get a character, while interpreting entities. + // The length can be from 0 to 4 bytes. + inline static const char* GetChar(const char* p, char* _value, int* length, TiXmlEncoding encoding) + { + assert(p); + if (encoding == TIXML_ENCODING_UTF8) + { + *length = utf8ByteTable[ *((unsigned char*)p) ]; + assert(*length >= 0 && *length < 5); + } + else + { + *length = 1; + } + + if (*length == 1) + { + if (*p == '&') + return GetEntity(p, _value, length, encoding); + *_value = *p; + return p+1; + } + else if (*length) + { + //strncpy(_value, p, *length); // lots of compilers don't like this function (unsafe), + // and the null terminator isn't needed + for (int i=0; p[i] && i<*length; ++i) { + _value[i] = p[i]; + } + return p + (*length); + } + else + { + // Not valid text. + return 0; + } + } + + // Puts a string to a stream, expanding entities as it goes. + // Note this should not contian the '<', '>', etc, or they will be transformed into entities! + static void PutString(const TIXML_STRING& str, TIXML_OSTREAM* out); + + static void PutString(const TIXML_STRING& str, TIXML_STRING* out); + + // Return true if the next characters in the stream are any of the endTag sequences. + // Ignore case only works for english, and should only be relied on when comparing + // to English words: StringEqual(p, "version", true) is fine. + static bool StringEqual( const char* p, + const char* endTag, + bool ignoreCase, + TiXmlEncoding encoding); + + static const char* errorString[ TIXML_ERROR_STRING_COUNT ]; + + TiXmlCursor location; + + /// Field containing a generic user pointer + void* userData; + + // None of these methods are reliable for any language except English. + // Good for approximation, not great for accuracy. + static int IsAlpha(unsigned char anyByte, TiXmlEncoding encoding); + static int IsAlphaNum(unsigned char anyByte, TiXmlEncoding encoding); + inline static int ToLower(int v, TiXmlEncoding encoding) + { + if (encoding == TIXML_ENCODING_UTF8) + { + if (v < 128) return tolower(v); + return v; + } + else + { + return tolower(v); + } + } + static void ConvertUTF32ToUTF8(unsigned long input, char* output, int* length); + +private: + TiXmlBase(const TiXmlBase&); // not implemented. + void operator=(const TiXmlBase& base); // not allowed. + + struct Entity + { + const char* str; + unsigned int strLength; + char chr; + }; + enum + { + NUM_ENTITY = 5, + MAX_ENTITY_LENGTH = 6 + + }; + static Entity entity[ NUM_ENTITY ]; + static bool condenseWhiteSpace; +}; + + +/** The parent class for everything in the Document Object Model. + (Except for attributes). + Nodes have siblings, a parent, and children. A node can be + in a document, or stand on its own. The type of a TiXmlNode + can be queried, and it can be cast to its more defined type. +*/ +class TiXmlNode : public TiXmlBase +{ + friend class TiXmlDocument; + friend class TiXmlElement; + +public: + #ifdef TIXML_USE_STL + + /** An input stream operator, for every class. Tolerant of newlines and + formatting, but doesn't expect them. + */ + friend std::istream& operator >> (std::istream& in, TiXmlNode& base); + + /** An output stream operator, for every class. Note that this outputs + without any newlines or formatting, as opposed to Print(), which + includes tabs and new lines. + + The operator<< and operator>> are not completely symmetric. Writing + a node to a stream is very well defined. You'll get a nice stream + of output, without any extra whitespace or newlines. + + But reading is not as well defined. (As it always is.) If you create + a TiXmlElement (for example) and read that from an input stream, + the text needs to define an element or junk will result. This is + true of all input streams, but it's worth keeping in mind. + + A TiXmlDocument will read nodes until it reads a root element, and + all the children of that root element. + */ + friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base); + + /// Appends the XML node or attribute to a std::string. + friend std::string& operator<< (std::string& out, const TiXmlNode& base); + + #else + // Used internally, not part of the public API. + friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base); + #endif + + /** The types of XML nodes supported by TinyXml. (All the + unsupported types are picked up by UNKNOWN.) + */ + enum NodeType + { + DOCUMENT, + ELEMENT, + COMMENT, + UNKNOWN, + TEXT, + DECLARATION, + TYPECOUNT + }; + + virtual ~TiXmlNode(); + + /** The meaning of 'value' changes for the specific type of + TiXmlNode. + @verbatim + Document: filename of the xml file + Element: name of the element + Comment: the comment text + Unknown: the tag contents + Text: the text string + @endverbatim + + The subclasses will wrap this function. + */ + const char *Value() const { return value.c_str (); } + + #ifdef TIXML_USE_STL + /** Return Value() as a std::string. If you only use STL, + this is more efficient than calling Value(). + Only available in STL mode. + */ + const std::string& ValueStr() const { return value; } + #endif + + /** Changes the value of the node. Defined as: + @verbatim + Document: filename of the xml file + Element: name of the element + Comment: the comment text + Unknown: the tag contents + Text: the text string + @endverbatim + */ + void SetValue(const char * _value) { value = _value;} + + #ifdef TIXML_USE_STL + /// STL std::string form. + void SetValue(const std::string& _value) { value = _value; } + #endif + + /// Delete all the children of this node. Does not affect 'this'. + void Clear(); + + /// One step up the DOM. + TiXmlNode* Parent() { return parent; } + const TiXmlNode* Parent() const { return parent; } + + const TiXmlNode* FirstChild() const { return firstChild; } ///< The first child of this node. Will be null if there are no children. + TiXmlNode* FirstChild() { return firstChild; } + const TiXmlNode* FirstChild(const char * value) const; ///< The first child of this node with the matching 'value'. Will be null if none found. + TiXmlNode* FirstChild(const char * value); ///< The first child of this node with the matching 'value'. Will be null if none found. + + const TiXmlNode* LastChild() const { return lastChild; } /// The last child of this node. Will be null if there are no children. + TiXmlNode* LastChild() { return lastChild; } + const TiXmlNode* LastChild(const char * value) const; /// The last child of this node matching 'value'. Will be null if there are no children. + TiXmlNode* LastChild(const char * value); + + #ifdef TIXML_USE_STL + const TiXmlNode* FirstChild(const std::string& _value) const { return FirstChild (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* FirstChild(const std::string& _value) { return FirstChild (_value.c_str ()); } ///< STL std::string form. + const TiXmlNode* LastChild(const std::string& _value) const { return LastChild (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* LastChild(const std::string& _value) { return LastChild (_value.c_str ()); } ///< STL std::string form. + #endif + + /** An alternate way to walk the children of a node. + One way to iterate over nodes is: + @verbatim + for (child = parent->FirstChild(); child; child = child->NextSibling()) + @endverbatim + + IterateChildren does the same thing with the syntax: + @verbatim + child = 0; + while (child = parent->IterateChildren(child)) + @endverbatim + + IterateChildren takes the previous child as input and finds + the next one. If the previous child is null, it returns the + first. IterateChildren will return null when done. + */ + const TiXmlNode* IterateChildren(const TiXmlNode* previous) const; + TiXmlNode* IterateChildren(TiXmlNode* previous); + + /// This flavor of IterateChildren searches for children with a particular 'value' + const TiXmlNode* IterateChildren(const char * value, const TiXmlNode* previous) const; + TiXmlNode* IterateChildren(const char * value, TiXmlNode* previous); + + #ifdef TIXML_USE_STL + const TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous) const { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. + TiXmlNode* IterateChildren(const std::string& _value, TiXmlNode* previous) { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. + #endif + + /** Add a new node related to this. Adds a child past the LastChild. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertEndChild(const TiXmlNode& addThis); + + + /** Add a new node related to this. Adds a child past the LastChild. + + NOTE: the node to be added is passed by pointer, and will be + henceforth owned (and deleted) by tinyXml. This method is efficient + and avoids an extra copy, but should be used with care as it + uses a different memory model than the other insert functions. + + @sa InsertEndChild + */ + TiXmlNode* LinkEndChild(TiXmlNode* addThis); + + /** Add a new node related to this. Adds a child before the specified child. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis); + + /** Add a new node related to this. Adds a child after the specified child. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis); + + /** Replace a child of this node. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis); + + /// Delete a child of this node. + bool RemoveChild(TiXmlNode* removeThis); + + /// Navigate to a sibling node. + const TiXmlNode* PreviousSibling() const { return prev; } + TiXmlNode* PreviousSibling() { return prev; } + + /// Navigate to a sibling node. + const TiXmlNode* PreviousSibling(const char *) const; + TiXmlNode* PreviousSibling(const char *); + + #ifdef TIXML_USE_STL + const TiXmlNode* PreviousSibling(const std::string& _value) const { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* PreviousSibling(const std::string& _value) { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. + const TiXmlNode* NextSibling(const std::string& _value) const { return NextSibling (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* NextSibling(const std::string& _value) { return NextSibling (_value.c_str ()); } ///< STL std::string form. + #endif + + /// Navigate to a sibling node. + const TiXmlNode* NextSibling() const { return next; } + TiXmlNode* NextSibling() { return next; } + + /// Navigate to a sibling node with the given 'value'. + const TiXmlNode* NextSibling(const char *) const; + TiXmlNode* NextSibling(const char *); + + /** Convenience function to get through elements. + Calls NextSibling and ToElement. Will skip all non-Element + nodes. Returns 0 if there is not another element. + */ + const TiXmlElement* NextSiblingElement() const; + TiXmlElement* NextSiblingElement(); + + /** Convenience function to get through elements. + Calls NextSibling and ToElement. Will skip all non-Element + nodes. Returns 0 if there is not another element. + */ + const TiXmlElement* NextSiblingElement(const char *) const; + TiXmlElement* NextSiblingElement(const char *); + + #ifdef TIXML_USE_STL + const TiXmlElement* NextSiblingElement(const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. + TiXmlElement* NextSiblingElement(const std::string& _value) { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. + #endif + + /// Convenience function to get through elements. + const TiXmlElement* FirstChildElement() const; + TiXmlElement* FirstChildElement(); + + /// Convenience function to get through elements. + const TiXmlElement* FirstChildElement(const char * value) const; + TiXmlElement* FirstChildElement(const char * value); + + #ifdef TIXML_USE_STL + const TiXmlElement* FirstChildElement(const std::string& _value) const { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. + TiXmlElement* FirstChildElement(const std::string& _value) { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. + #endif + + /** Query the type (as an enumerated value, above) of this node. + The possible types are: DOCUMENT, ELEMENT, COMMENT, + UNKNOWN, TEXT, and DECLARATION. + */ + int Type() const { return type; } + + /** Return a pointer to the Document this node lives in. + Returns null if not in a document. + */ + const TiXmlDocument* GetDocument() const; + TiXmlDocument* GetDocument(); + + /// Returns true if this node has no children. + bool NoChildren() const { return !firstChild; } + + virtual const TiXmlDocument* ToDocument() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlElement* ToElement() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlComment* ToComment() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlUnknown* ToUnknown() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlText* ToText() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + + virtual TiXmlDocument* ToDocument() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlElement* ToElement() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlComment* ToComment() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlUnknown* ToUnknown() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlText* ToText() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlDeclaration* ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + + /** Create an exact duplicate of this node and return it. The memory must be deleted + by the caller. + */ + virtual TiXmlNode* Clone() const = 0; + +protected: + TiXmlNode(NodeType _type); + + // Copy to the allocated object. Shared functionality between Clone, Copy constructor, + // and the assignment operator. + void CopyTo(TiXmlNode* target) const; + + #ifdef TIXML_USE_STL + // The real work of the input operator. + virtual void StreamIn(TIXML_ISTREAM* in, TIXML_STRING* tag) = 0; + #endif + + // Figure out what is at *p, and parse it. Returns null if it is not an xml node. + TiXmlNode* Identify(const char* start, TiXmlEncoding encoding); + + TiXmlNode* parent; + NodeType type; + + TiXmlNode* firstChild; + TiXmlNode* lastChild; + + TIXML_STRING value; + + TiXmlNode* prev; + TiXmlNode* next; + +private: + TiXmlNode(const TiXmlNode&); // not implemented. + void operator=(const TiXmlNode& base); // not allowed. +}; + +/** An attribute is a name-value pair. Elements have an arbitrary + number of attributes, each with a unique name. + + @note The attributes are not TiXmlNodes, since they are not + part of the tinyXML document object model. There are other + suggested ways to look at this problem. +*/ +class TiXmlAttribute : public TiXmlBase +{ + friend class TiXmlAttributeSet; + +public: + /// Construct an empty attribute. + TiXmlAttribute() : TiXmlBase() + { + document = 0; + prev = next = 0; + } + + #ifdef TIXML_USE_STL + /// std::string constructor. + TiXmlAttribute(const std::string& _name, const std::string& _value) + { + name = _name; + value = _value; + document = 0; + prev = next = 0; + } + #endif + + /// Construct an attribute with a name and value. + TiXmlAttribute(const char * _name, const char * _value) + { + name = _name; + value = _value; + document = 0; + prev = next = 0; + } + + const char* Name() const { return name.c_str(); } ///< Return the name of this attribute. + const char* Value() const { return value.c_str(); } ///< Return the value of this attribute. + #ifdef TIXML_USE_STL + const std::string& ValueStr() const { return value; } ///< Return the value of this attribute. + #endif + int IntValue() const; ///< Return the value of this attribute, converted to an integer. + double DoubleValue() const; ///< Return the value of this attribute, converted to a double. + + // Get the tinyxml string representation + const TIXML_STRING& NameTStr() const { return name; } + + /** QueryIntValue examines the value string. It is an alternative to the + IntValue() method with richer error checking. + If the value is an integer, it is stored in 'value' and + the call returns TIXML_SUCCESS. If it is not + an integer, it returns TIXML_WRONG_TYPE. + + A specialized but useful call. Note that for success it returns 0, + which is the opposite of almost all other TinyXml calls. + */ + int QueryIntValue(int* _value) const; + /// QueryDoubleValue examines the value string. See QueryIntValue(). + int QueryDoubleValue(double* _value) const; + + void SetName(const char* _name) { name = _name; } ///< Set the name of this attribute. + void SetValue(const char* _value) { value = _value; } ///< Set the value. + + void SetIntValue(int _value); ///< Set the value from an integer. + void SetDoubleValue(double _value); ///< Set the value from a double. + + #ifdef TIXML_USE_STL + /// STL std::string form. + void SetName(const std::string& _name) { name = _name; } + /// STL std::string form. + void SetValue(const std::string& _value) { value = _value; } + #endif + + /// Get the next sibling attribute in the DOM. Returns null at end. + const TiXmlAttribute* Next() const; + TiXmlAttribute* Next(); + /// Get the previous sibling attribute in the DOM. Returns null at beginning. + const TiXmlAttribute* Previous() const; + TiXmlAttribute* Previous(); + + bool operator==(const TiXmlAttribute& rhs) const { return rhs.name == name; } + bool operator<(const TiXmlAttribute& rhs) const { return name < rhs.name; } + bool operator>(const TiXmlAttribute& rhs) const { return name > rhs.name; } + + /* Attribute parsing starts: first letter of the name + returns: the next char after the value end quote + */ + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + // Prints this Attribute to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + virtual void StreamOut(TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const {} + + // [internal use] + // Set the document pointer so the attribute can report errors. + void SetDocument(TiXmlDocument* doc) { document = doc; } + +private: + TiXmlAttribute(const TiXmlAttribute&); // not implemented. + void operator=(const TiXmlAttribute& base); // not allowed. + + TiXmlDocument* document; // A pointer back to a document, for error reporting. + TIXML_STRING name; + TIXML_STRING value; + TiXmlAttribute* prev; + TiXmlAttribute* next; +}; + + +/* A class used to manage a group of attributes. + It is only used internally, both by the ELEMENT and the DECLARATION. + + The set can be changed transparent to the Element and Declaration + classes that use it, but NOT transparent to the Attribute + which has to implement a next() and previous() method. Which makes + it a bit problematic and prevents the use of STL. + + This version is implemented with circular lists because: + - I like circular lists + - it demonstrates some independence from the (typical) doubly linked list. +*/ +class TiXmlAttributeSet +{ +public: + TiXmlAttributeSet(); + ~TiXmlAttributeSet(); + + void Add(TiXmlAttribute* attribute); + void Remove(TiXmlAttribute* attribute); + + const TiXmlAttribute* First() const { return (sentinel.next == &sentinel) ? 0 : sentinel.next; } + TiXmlAttribute* First() { return (sentinel.next == &sentinel) ? 0 : sentinel.next; } + const TiXmlAttribute* Last() const { return (sentinel.prev == &sentinel) ? 0 : sentinel.prev; } + TiXmlAttribute* Last() { return (sentinel.prev == &sentinel) ? 0 : sentinel.prev; } + + const TiXmlAttribute* Find(const TIXML_STRING& name) const; + TiXmlAttribute* Find(const TIXML_STRING& name); + +private: + //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element), + //*ME: this class must be also use a hidden/disabled copy-constructor !!! + TiXmlAttributeSet(const TiXmlAttributeSet&); // not allowed + void operator=(const TiXmlAttributeSet&); // not allowed (as TiXmlAttribute) + + TiXmlAttribute sentinel; +}; + + +/** The element is a container class. It has a value, the element name, + and can contain other elements, text, comments, and unknowns. + Elements also contain an arbitrary number of attributes. +*/ +class TiXmlElement : public TiXmlNode +{ +public: + /// Construct an element. + TiXmlElement (const char * in_value); + + #ifdef TIXML_USE_STL + /// std::string constructor. + TiXmlElement(const std::string& _value); + #endif + + TiXmlElement(const TiXmlElement&); + + void operator=(const TiXmlElement& base); + + virtual ~TiXmlElement(); + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + */ + const char* Attribute(const char* name) const; + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + If the attribute exists and can be converted to an integer, + the integer value will be put in the return 'i', if 'i' + is non-null. + */ + const char* Attribute(const char* name, int* i) const; + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + If the attribute exists and can be converted to an double, + the double value will be put in the return 'd', if 'd' + is non-null. + */ + const char* Attribute(const char* name, double* d) const; + + /** QueryIntAttribute examines the attribute - it is an alternative to the + Attribute() method with richer error checking. + If the attribute is an integer, it is stored in 'value' and + the call returns TIXML_SUCCESS. If it is not + an integer, it returns TIXML_WRONG_TYPE. If the attribute + does not exist, then TIXML_NO_ATTRIBUTE is returned. + */ + int QueryIntAttribute(const char* name, int* _value) const; + /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute(). + int QueryDoubleAttribute(const char* name, double* _value) const; + /// QueryFloatAttribute examines the attribute - see QueryIntAttribute(). + int QueryFloatAttribute(const char* name, float* _value) const { + double d; + int result = QueryDoubleAttribute(name, &d); + if (result == TIXML_SUCCESS) { + *_value = (float)d; + } + return result; + } + #ifdef TIXML_USE_STL + /** Template form of the attribute query which will try to read the + attribute into the specified type. Very easy, very powerful, but + be careful to make sure to call this with the correct type. + + @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE + */ + template< typename T > int QueryValueAttribute(const std::string& name, T* outValue) const + { + const TiXmlAttribute* node = attributeSet.Find(name); + if (!node) + return TIXML_NO_ATTRIBUTE; + + std::stringstream sstream(node->ValueStr()); + sstream >> *outValue; + if (!sstream.fail()) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; + } + #endif + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetAttribute(const char* name, const char * _value); + + #ifdef TIXML_USE_STL + const char* Attribute(const std::string& name) const { return Attribute(name.c_str()); } + const char* Attribute(const std::string& name, int* i) const { return Attribute(name.c_str(), i); } + const char* Attribute(const std::string& name, double* d) const { return Attribute(name.c_str(), d); } + int QueryIntAttribute(const std::string& name, int* _value) const { return QueryIntAttribute(name.c_str(), _value); } + int QueryDoubleAttribute(const std::string& name, double* _value) const { return QueryDoubleAttribute(name.c_str(), _value); } + + /// STL std::string form. + void SetAttribute(const std::string& name, const std::string& _value); + ///< STL std::string form. + void SetAttribute(const std::string& name, int _value); + #endif + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetAttribute(const char * name, int value); + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetDoubleAttribute(const char * name, double value); + + /** Deletes an attribute with the given name. + */ + void RemoveAttribute(const char * name); + #ifdef TIXML_USE_STL + void RemoveAttribute(const std::string& name) { RemoveAttribute (name.c_str ()); } ///< STL std::string form. + #endif + + const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); } ///< Access the first attribute in this element. + TiXmlAttribute* FirstAttribute() { return attributeSet.First(); } + const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); } ///< Access the last attribute in this element. + TiXmlAttribute* LastAttribute() { return attributeSet.Last(); } + + /** Convenience function for easy access to the text inside an element. Although easy + and concise, GetText() is limited compared to getting the TiXmlText child + and accessing it directly. + + If the first child of 'this' is a TiXmlText, the GetText() + returns the character string of the Text node, else null is returned. + + This is a convenient method for getting the text of simple contained text: + @verbatim + This is text + const char* str = fooElement->GetText(); + @endverbatim + + 'str' will be a pointer to "This is text". + + Note that this function can be misleading. If the element foo was created from + this XML: + @verbatim + This is text + @endverbatim + + then the value of str would be null. The first child node isn't a text node, it is + another element. From this XML: + @verbatim + This is text + @endverbatim + GetText() will return "This is ". + + WARNING: GetText() accesses a child node - don't become confused with the + similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are + safe type casts on the referenced node. + */ + const char* GetText() const; + + /// Creates a new Element and returns it - the returned element is a copy. + virtual TiXmlNode* Clone() const; + // Print the Element to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + /* Attribtue parsing starts: next char past '<' + returns: next char past '>' + */ + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + virtual const TiXmlElement* ToElement() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlElement* ToElement() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected: + + void CopyTo(TiXmlElement* target) const; + void ClearThis(); // like clear, but initializes 'this' object as well + + // Used to be public [internal use] + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + virtual void StreamOut(TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + + /* [internal use] + Reads the "value" of the element -- another element, or text. + This should terminate with the current end tag. + */ + const char* ReadValue(const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding); + +private: + + TiXmlAttributeSet attributeSet; +}; + + +/** An XML comment. +*/ +class TiXmlComment : public TiXmlNode +{ +public: + /// Constructs an empty comment. + TiXmlComment() : TiXmlNode(TiXmlNode::COMMENT) {} + TiXmlComment(const TiXmlComment&); + void operator=(const TiXmlComment& base); + + virtual ~TiXmlComment() {} + + /// Returns a copy of this Comment. + virtual TiXmlNode* Clone() const; + /// Write this Comment to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + /* Attribtue parsing starts: at the ! of the !-- + returns: next char past '>' + */ + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected: + void CopyTo(TiXmlComment* target) const; + + // used to be public + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + virtual void StreamOut(TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + +private: + +}; + + +/** XML text. A text node can have 2 ways to output the next. "normal" output + and CDATA. It will default to the mode it was parsed from the XML file and + you generally want to leave it alone, but you can change the output mode with + SetCDATA() and query it with CDATA(). +*/ +class TiXmlText : public TiXmlNode +{ + friend class TiXmlElement; +public: + /** Constructor for text element. By default, it is treated as + normal, encoded text. If you want it be output as a CDATA text + element, set the parameter _cdata to 'true' + */ + TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT) + { + SetValue(initValue); + cdata = false; + } + virtual ~TiXmlText() {} + + #ifdef TIXML_USE_STL + /// Constructor. + TiXmlText(const std::string& initValue) : TiXmlNode (TiXmlNode::TEXT) + { + SetValue(initValue); + cdata = false; + } + #endif + + TiXmlText(const TiXmlText& copy) : TiXmlNode(TiXmlNode::TEXT) { copy.CopyTo(this); } + void operator=(const TiXmlText& base) { base.CopyTo(this); } + + /// Write this text object to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + /// Queries whether this represents text using a CDATA section. + bool CDATA() { return cdata; } + /// Turns on or off a CDATA representation of text. + void SetCDATA(bool _cdata) { cdata = _cdata; } + + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlText* ToText() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected : + /// [internal use] Creates a new Element and returns it. + virtual TiXmlNode* Clone() const; + void CopyTo(TiXmlText* target) const; + + virtual void StreamOut (TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + + bool Blank() const; // returns true if all white space and new lines + // [internal use] + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + +private: + bool cdata; // true if this should be input and output as a CDATA style text element +}; + + +/** In correct XML the declaration is the first entry in the file. + @verbatim + + @endverbatim + + TinyXml will happily read or write files without a declaration, + however. There are 3 possible attributes to the declaration: + version, encoding, and standalone. + + Note: In this version of the code, the attributes are + handled as special cases, not generic attributes, simply + because there can only be at most 3 and they are always the same. +*/ +class TiXmlDeclaration : public TiXmlNode +{ +public: + /// Construct an empty declaration. + TiXmlDeclaration() : TiXmlNode(TiXmlNode::DECLARATION) {} + +#ifdef TIXML_USE_STL + /// Constructor. + TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone); +#endif + + /// Construct. + TiXmlDeclaration( const char* _version, + const char* _encoding, + const char* _standalone); + + TiXmlDeclaration(const TiXmlDeclaration& copy); + void operator=(const TiXmlDeclaration& copy); + + virtual ~TiXmlDeclaration() {} + + /// Version. Will return an empty string if none was found. + const char *Version() const { return version.c_str (); } + /// Encoding. Will return an empty string if none was found. + const char *Encoding() const { return encoding.c_str (); } + /// Is this a standalone document? + const char *Standalone() const { return standalone.c_str (); } + + /// Creates a copy of this Declaration and returns it. + virtual TiXmlNode* Clone() const; + /// Print this declaration to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlDeclaration* ToDeclaration() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected: + void CopyTo(TiXmlDeclaration* target) const; + // used to be public + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + virtual void StreamOut (TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + +private: + + TIXML_STRING version; + TIXML_STRING encoding; + TIXML_STRING standalone; +}; + + +/** Any tag that tinyXml doesn't recognize is saved as an + unknown. It is a tag of text, but should not be modified. + It will be written back to the XML, unchanged, when the file + is saved. + + DTD tags get thrown into TiXmlUnknowns. +*/ +class TiXmlUnknown : public TiXmlNode +{ +public: + TiXmlUnknown() : TiXmlNode(TiXmlNode::UNKNOWN) {} + virtual ~TiXmlUnknown() {} + + TiXmlUnknown(const TiXmlUnknown& copy) : TiXmlNode(TiXmlNode::UNKNOWN) { copy.CopyTo(this); } + void operator=(const TiXmlUnknown& copy) { copy.CopyTo(this); } + + /// Creates a copy of this Unknown and returns it. + virtual TiXmlNode* Clone() const; + /// Print this Unknown to a FILE stream. + virtual void Print(FILE* cfile, int depth) const; + + virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); + + virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected: + void CopyTo(TiXmlUnknown* target) const; + + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + virtual void StreamOut (TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + +private: + +}; + + +/** Always the top level node. A document binds together all the + XML pieces. It can be saved, loaded, and printed to the screen. + The 'value' of a document node is the xml file name. +*/ +class TiXmlDocument : public TiXmlNode +{ +public: + /// Create an empty document, that has no name. + TiXmlDocument(); + /// Create a document with a name. The name of the document is also the filename of the xml. + TiXmlDocument(const char * documentName); + + #ifdef TIXML_USE_STL + /// Constructor. + TiXmlDocument(const std::string& documentName); + #endif + + TiXmlDocument(const TiXmlDocument& copy); + void operator=(const TiXmlDocument& copy); + + virtual ~TiXmlDocument() {} + + /** Load a file using the current document value. + Returns true if successful. Will delete any existing + document data before loading. + */ + bool LoadFile(TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); + /// Save a file using the current document value. Returns true if successful. + bool SaveFile() const; + /// Load a file using the given filename. Returns true if successful. + bool LoadFile(const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); + /// Save a file using the given filename. Returns true if successful. + bool SaveFile(const char * filename) const; + /** Load a file using the given FILE*. Returns true if successful. Note that this method + doesn't stream - the entire object pointed at by the FILE* + will be interpreted as an XML file. TinyXML doesn't stream in XML from the current + file location. Streaming may be added in the future. + */ + bool LoadFile(FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); + /// Save a file using the given FILE*. Returns true if successful. + bool SaveFile(FILE*) const; + + #ifdef TIXML_USE_STL + bool LoadFile(const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING) ///< STL std::string version. + { + StringToBuffer f(filename); + return (f.buffer && LoadFile(f.buffer, encoding)); + } + bool SaveFile(const std::string& filename) const ///< STL std::string version. + { + StringToBuffer f(filename); + return (f.buffer && SaveFile(f.buffer)); + } + /** Write the document to a string using formatted printing ("pretty print"). + @return the document as a formatted standard string. + */ + std::string GetAsString(); + #endif + + /** Write the document to a string using formatted printing ("pretty print"). + @param buffer A character buffer that should be big enough to hold your document. + @param bufferSize The size of @p buffer. + + @return True if the document could be copied into @p buffer, else false. + */ + bool GetAsCharBuffer(char* buffer, size_t bufferSize); + + /** Parse the given null terminated block of xml data. Passing in an encoding to this + method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml + to use that encoding, regardless of what TinyXml might otherwise try to detect. + */ + virtual const char* Parse(const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); + + /** Get the root element -- the only top level element -- of the document. + In well formed XML, there should only be one. TinyXml is tolerant of + multiple elements at the document level. + */ + const TiXmlElement* RootElement() const { return FirstChildElement(); } + TiXmlElement* RootElement() { return FirstChildElement(); } + + /** If an error occurs, Error will be set to true. Also, + - The ErrorId() will contain the integer identifier of the error (not generally useful) + - The ErrorDesc() method will return the name of the error. (very useful) + - The ErrorRow() and ErrorCol() will return the location of the error (if known) + */ + bool Error() const { return error; } + + /// Contains a textual (english) description of the error if one occurs. + const char * ErrorDesc() const { return errorDesc.c_str (); } + + /** Generally, you probably want the error string (ErrorDesc()). But if you + prefer the ErrorId, this function will fetch it. + */ + int ErrorId() const { return errorId; } + + /** Returns the location (if known) of the error. The first column is column 1, + and the first row is row 1. A value of 0 means the row and column wasn't applicable + (memory errors, for example, have no row/column) or the parser lost the error. (An + error in the error reporting, in that case.) + + @sa SetTabSize, Row, Column + */ + int ErrorRow() { return errorLocation.row+1; } + int ErrorCol() { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow() + + /** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol()) + to report the correct values for row and column. It does not change the output + or input in any way. + + By calling this method, with a tab size + greater than 0, the row and column of each node and attribute is stored + when the file is loaded. Very useful for tracking the DOM back in to + the source file. + + The tab size is required for calculating the location of nodes. If not + set, the default of 4 is used. The tabsize is set per document. Setting + the tabsize to 0 disables row/column tracking. + + Note that row and column tracking is not supported when using operator>>. + + The tab size needs to be enabled before the parse or load. Correct usage: + @verbatim + TiXmlDocument doc; + doc.SetTabSize(8); + doc.Load("myfile.xml"); + @endverbatim + + @sa Row, Column + */ + void SetTabSize(int _tabsize) { tabsize = _tabsize; } + + int TabSize() const { return tabsize; } + + /** If you have handled the error, it can be reset with this call. The error + state is automatically cleared if you Parse a new XML block. + */ + void ClearError() { error = false; + errorId = 0; + errorDesc = ""; + errorLocation.row = errorLocation.col = 0; + //errorLocation.last = 0; + } + + /** Dump the document to standard out. */ + void Print() const { Print(stdout, 0); } + + /// Print this Document to a FILE stream. + virtual void Print(FILE* cfile, int depth = 0) const; + // [internal use] + void SetError(int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding); + + virtual const TiXmlDocument* ToDocument() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlDocument* ToDocument() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + +protected : + virtual void StreamOut (TIXML_OSTREAM * out) const; + virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; + // [internal use] + virtual TiXmlNode* Clone() const; + #ifdef TIXML_USE_STL + virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); + #endif + +private: + void CopyTo(TiXmlDocument* target) const; + + bool error; + int errorId; + TIXML_STRING errorDesc; + int tabsize; + TiXmlCursor errorLocation; + bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write. +}; + + +/** + A TiXmlHandle is a class that wraps a node pointer with null checks; this is + an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml + DOM structure. It is a separate utility class. + + Take an example: + @verbatim + + + + + + + @endverbatim + + Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very + easy to write a *lot* of code that looks like: + + @verbatim + TiXmlElement* root = document.FirstChildElement("Document"); + if (root) + { + TiXmlElement* element = root->FirstChildElement("Element"); + if (element) + { + TiXmlElement* child = element->FirstChildElement("Child"); + if (child) + { + TiXmlElement* child2 = child->NextSiblingElement("Child"); + if (child2) + { + // Finally do something useful. + @endverbatim + + And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity + of such code. A TiXmlHandle checks for null pointers so it is perfectly safe + and correct to use: + + @verbatim + TiXmlHandle docHandle(&document); + TiXmlElement* child2 = docHandle.FirstChild("Document").FirstChild("Element").Child("Child", 1).Element(); + if (child2) + { + // do something useful + @endverbatim + + Which is MUCH more concise and useful. + + It is also safe to copy handles - internally they are nothing more than node pointers. + @verbatim + TiXmlHandle handleCopy = handle; + @endverbatim + + What they should not be used for is iteration: + + @verbatim + int i=0; + while (true) + { + TiXmlElement* child = docHandle.FirstChild("Document").FirstChild("Element").Child("Child", i).Element(); + if (!child) + break; + // do something + ++i; + } + @endverbatim + + It seems reasonable, but it is in fact two embedded while loops. The Child method is + a linear walk to find the element, so this code would iterate much more than it needs + to. Instead, prefer: + + @verbatim + TiXmlElement* child = docHandle.FirstChild("Document").FirstChild("Element").FirstChild("Child").Element(); + + for (child; child; child=child->NextSiblingElement()) + { + // do something + } + @endverbatim +*/ +class TiXmlHandle +{ +public: + /// Create a handle from any node (at any depth of the tree.) This can be a null pointer. + TiXmlHandle(TiXmlNode* _node) { this->node = _node; } + /// Copy constructor + TiXmlHandle(const TiXmlHandle& ref) { this->node = ref.node; } + TiXmlHandle operator=(const TiXmlHandle& ref) { this->node = ref.node; return *this; } + + /// Return a handle to the first child node. + TiXmlHandle FirstChild() const; + /// Return a handle to the first child node with the given name. + TiXmlHandle FirstChild(const char * value) const; + /// Return a handle to the first child element. + TiXmlHandle FirstChildElement() const; + /// Return a handle to the first child element with the given name. + TiXmlHandle FirstChildElement(const char * value) const; + + /** Return a handle to the "index" child with the given name. + The first child is 0, the second 1, etc. + */ + TiXmlHandle Child(const char* value, int index) const; + /** Return a handle to the "index" child. + The first child is 0, the second 1, etc. + */ + TiXmlHandle Child(int index) const; + /** Return a handle to the "index" child element with the given name. + The first child element is 0, the second 1, etc. Note that only TiXmlElements + are indexed: other types are not counted. + */ + TiXmlHandle ChildElement(const char* value, int index) const; + /** Return a handle to the "index" child element. + The first child element is 0, the second 1, etc. Note that only TiXmlElements + are indexed: other types are not counted. + */ + TiXmlHandle ChildElement(int index) const; + + #ifdef TIXML_USE_STL + TiXmlHandle FirstChild(const std::string& _value) const { return FirstChild(_value.c_str()); } + TiXmlHandle FirstChildElement(const std::string& _value) const { return FirstChildElement(_value.c_str()); } + + TiXmlHandle Child(const std::string& _value, int index) const { return Child(_value.c_str(), index); } + TiXmlHandle ChildElement(const std::string& _value, int index) const { return ChildElement(_value.c_str(), index); } + #endif + + /// Return the handle as a TiXmlNode. This may return null. + TiXmlNode* Node() const { return node; } + /// Return the handle as a TiXmlElement. This may return null. + TiXmlElement* Element() const { return ((node && node->ToElement()) ? node->ToElement() : 0); } + /// Return the handle as a TiXmlText. This may return null. + TiXmlText* Text() const { return ((node && node->ToText()) ? node->ToText() : 0); } + /// Return the handle as a TiXmlUnknown. This may return null; + TiXmlUnknown* Unknown() const { return ((node && node->ToUnknown()) ? node->ToUnknown() : 0); } + +private: + TiXmlNode* node; +}; + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif + diff --git a/plugins/UserInfoEx/ex_import/tinyxmlerror.cpp b/plugins/UserInfoEx/ex_import/tinyxmlerror.cpp new file mode 100644 index 0000000000..3c42354d11 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinyxmlerror.cpp @@ -0,0 +1,76 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinyxmlerror.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#ifdef USE_MMGR +#include +#include +#include +#include +#include +#include "mmgr.h" +#endif + +#include "tinyxml.h" + +// The goal of the seperate error file is to make the first +// step towards localization. tinyxml (currently) only supports +// english error messages, but the could now be translated. +// +// It also cleans up the code a bit. +// + +const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] = +{ + "No error", + "Error", + "Failed to open file", + "Memory allocation failed.", + "Error parsing Element.", + "Failed to read Element name", + "Error reading Element value.", + "Error reading Attributes.", + "Error: empty tag.", + "Error reading end tag.", + "Error parsing Unknown.", + "Error parsing Comment.", + "Error parsing Declaration.", + "Error document empty.", + "Error null (0) or unexpected EOF found in input stream.", + "Error parsing CDATA.", + "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.", +}; diff --git a/plugins/UserInfoEx/ex_import/tinyxmlparser.cpp b/plugins/UserInfoEx/ex_import/tinyxmlparser.cpp new file mode 100644 index 0000000000..73f2c18679 --- /dev/null +++ b/plugins/UserInfoEx/ex_import/tinyxmlparser.cpp @@ -0,0 +1,1613 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. + +=============================================================================== + +UserinfoEx plugin for Miranda IM + +Copyright: +ฉ 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol + +File name : $HeadURL: https://userinfoex.googlecode.com/svn/trunk/ex_import/tinyxmlparser.cpp $ +Revision : $Revision: 187 $ +Last change on : $Date: 2010-09-08 16:05:54 +0400 (ะกั€, 08 ัะตะฝ 2010) $ +Last change by : $Author: ing.u.horn $ + +=============================================================================== +*/ + +#include +#include + +#ifdef USE_MMGR +#include +#include +#include +#include "mmgr.h" +#endif + +#include "tinyxml.h" + +//#define DEBUG_PARSER +#if defined(DEBUG_PARSER) +# if defined(DEBUG) && defined(_MSC_VER) +# include +# define TIXML_LOG OutputDebugString +# else +# define TIXML_LOG printf +# endif +#endif + +// Note tha "PutString" hardcodes the same list. This +// is less flexible than it appears. Changing the entries +// or order will break putstring. +TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = +{ + { "&", 5, '&' }, + { "<", 4, '<' }, + { ">", 4, '>' }, + { """, 6, '\"' }, + { "'", 6, '\'' } +}; + +// Bunch of unicode info at: +// http://www.unicode.org/faq/utf_bom.html +// Including the basic of this table, which determines the #bytes in the +// sequence from the lead byte. 1 placed for invalid sequences -- +// although the result will be junk, pass it through as much as possible. +// Beware of the non-characters in UTF-8: +// ef bb bf (Microsoft "lead bytes") +// ef bf be +// ef bf bf + +const unsigned char TIXML_UTF_LEAD_0 = 0xefU; +const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; +const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + +const int TiXmlBase::utf8ByteTable[256] = +{ + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte + 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid +}; + + +void TiXmlBase::ConvertUTF32ToUTF8(unsigned long input, char* output, int* length) +{ + const unsigned long BYTE_MASK = 0xBF; + const unsigned long BYTE_MARK = 0x80; + const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; + + if (input < 0x80) + *length = 1; + else if (input < 0x800) + *length = 2; + else if (input < 0x10000) + *length = 3; + else if (input < 0x200000) + *length = 4; + else + { *length = 0; return; } // This code won't covert this correctly anyway. + + output += *length; + + // Scary scary fall throughs. + switch (*length) + { + case 4: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 3: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 2: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 1: + --output; + *output = (char)(input | FIRST_BYTE_MARK[*length]); + } +} + + +/*static*/ int TiXmlBase::IsAlpha(unsigned char anyByte, TiXmlEncoding /*encoding*/) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if (encoding == TIXML_ENCODING_UTF8) +// { + if (anyByte < 127) + return isalpha(anyByte); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalpha(anyByte); +// } +} + + +/*static*/ int TiXmlBase::IsAlphaNum(unsigned char anyByte, TiXmlEncoding /*encoding*/) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if (encoding == TIXML_ENCODING_UTF8) +// { + if (anyByte < 127) + return isalnum(anyByte); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalnum(anyByte); +// } +} + + +class TiXmlParsingData +{ + friend class TiXmlDocument; + public: + void Stamp(const char* now, TiXmlEncoding encoding); + + const TiXmlCursor& Cursor() { return cursor; } + + private: + // Only used by the document! + TiXmlParsingData(const char* start, int _tabsize, int row, int col) + { + assert(start); + stamp = start; + tabsize = _tabsize; + cursor.row = row; + cursor.col = col; + } + + TiXmlCursor cursor; + const char* stamp; + int tabsize; +}; + + +void TiXmlParsingData::Stamp(const char* now, TiXmlEncoding encoding) +{ + assert(now); + + // Do nothing if the tabsize is 0. + if (tabsize < 1) + { + return; + } + + // Get the current row, column. + int row = cursor.row; + int col = cursor.col; + const char* p = stamp; + assert(p); + + while (p < now) + { + // Treat p as unsigned, so we have a happy compiler. + const unsigned char* pU = (const unsigned char*)p; + + // Code contributed by Fletcher Dunn: (modified by lee) + switch (*pU) { + case 0: + // We *should* never get here, but in case we do, don't + // advance past the terminating null character, ever + return; + + case '\r': + // bump down to the next line + ++row; + col = 0; + // Eat the character + ++p; + + // Check for \r\n sequence, and treat this as a single character + if (*p == '\n') { + ++p; + } + break; + + case '\n': + // bump down to the next line + ++row; + col = 0; + + // Eat the character + ++p; + + // Check for \n\r sequence, and treat this as a single + // character. (Yes, this bizarre thing does occur still + // on some arcane platforms...) + if (*p == '\r') { + ++p; + } + break; + + case '\t': + // Eat the character + ++p; + + // Skip to next tab stop + col = (col / tabsize + 1) * tabsize; + break; + + case TIXML_UTF_LEAD_0: + if (encoding == TIXML_ENCODING_UTF8) + { + if (*(p+1) && *(p+2)) + { + // In these cases, don't advance the column. These are + // 0-width spaces. + if (*(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2) + p += 3; + else if (*(pU+1)==0xbfU && *(pU+2)==0xbeU) + p += 3; + else if (*(pU+1)==0xbfU && *(pU+2)==0xbfU) + p += 3; + else + { p +=3; ++col; } // A normal character. + } + } + else + { + ++p; + ++col; + } + break; + + default: + if (encoding == TIXML_ENCODING_UTF8) + { + // Eat the 1 to 4 byte utf8 character. + int step = TiXmlBase::utf8ByteTable[*((unsigned char*)p)]; + if (step == 0) + step = 1; // Error case from bad encoding, but handle gracefully. + p += step; + + // Just advance one column, of course. + ++col; + } + else + { + ++p; + ++col; + } + break; + } + } + cursor.row = row; + cursor.col = col; + assert(cursor.row >= -1); + assert(cursor.col >= -1); + stamp = p; + assert(stamp); +} + + +const char* TiXmlBase::SkipWhiteSpace(const char* p, TiXmlEncoding encoding) +{ + if (!p || !*p) + { + return 0; + } + if (encoding == TIXML_ENCODING_UTF8) + { + while (*p) + { + const unsigned char* pU = (const unsigned char*)p; + + // Skip the stupid Microsoft UTF-8 Byte order marks + if ( *(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==TIXML_UTF_LEAD_1 + && *(pU+2)==TIXML_UTF_LEAD_2) + { + p += 3; + continue; + } + else if (*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbeU) + { + p += 3; + continue; + } + else if (*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbfU) + { + p += 3; + continue; + } + + if (IsWhiteSpace(*p) || *p == '\n' || *p =='\r') // Still using old rules for white space. + ++p; + else + break; + } + } + else + { + while (*p && IsWhiteSpace(*p) || *p == '\n' || *p =='\r') + ++p; + } + + return p; +} + +#ifdef TIXML_USE_STL +/*static*/ bool TiXmlBase::StreamWhiteSpace(TIXML_ISTREAM * in, TIXML_STRING * tag) +{ + for (;;) + { + if (!in->good()) return false; + + int c = in->peek(); + // At this scope, we can't get to a document. So fail silently. + if (!IsWhiteSpace(c) || c <= 0) + return true; + + *tag += (char) in->get(); + } +} + +/*static*/ bool TiXmlBase::StreamTo(TIXML_ISTREAM * in, int character, TIXML_STRING * tag) +{ + //assert(character > 0 && character < 128); // else it won't work in utf-8 + while (in->good()) + { + int c = in->peek(); + if (c == character) + return true; + if (c <= 0) // Silent failure: can't get document at this scope + return false; + + in->get(); + *tag += (char) c; + } + return false; +} +#endif + +const char* TiXmlBase::ReadName(const char* p, TIXML_STRING * name, TiXmlEncoding encoding) +{ + *name = ""; + assert(p); + + // Names start with letters or underscores. + // Of course, in unicode, tinyxml has no idea what a letter *is*. The + // algorithm is generous. + // + // After that, they can be letters, underscores, numbers, + // hyphens, or colons. (Colons are valid ony for namespaces, + // but tinyxml can't tell namespaces from names.) + if ( p && *p + && (IsAlpha((unsigned char) *p, encoding) || *p == '_')) + { + while ( p && *p + && ( IsAlphaNum((unsigned char) *p, encoding) + || *p == '_' + || *p == '-' + || *p == '.' + || *p == ':')) + { + (*name) += *p; + ++p; + } + return p; + } + return 0; +} + +const char* TiXmlBase::GetEntity(const char* p, char* value, int* length, TiXmlEncoding encoding) +{ + // Presume an entity, and pull it out. + TIXML_STRING ent; + int i; + *length = 0; + + if (*(p+1) && *(p+1) == '#' && *(p+2)) + { + unsigned long ucs = 0; + ptrdiff_t delta = 0; + unsigned mult = 1; + + if (*(p+2) == 'x') + { + // Hexadecimal. + if (!*(p+3)) return 0; + + const char* q = p+3; + q = strchr(q, ';'); + + if (!q || !*q) return 0; + + delta = q-p; + --q; + + while (*q != 'x') + { + if (*q >= '0' && *q <= '9') + ucs += mult * (*q - '0'); + else if (*q >= 'a' && *q <= 'f') + ucs += mult * (*q - 'a' + 10); + else if (*q >= 'A' && *q <= 'F') + ucs += mult * (*q - 'A' + 10); + else + return 0; + mult *= 16; + --q; + } + } + else + { + // Decimal. + if (!*(p+2)) return 0; + + const char* q = p+2; + q = strchr(q, ';'); + + if (!q || !*q) return 0; + + delta = q-p; + --q; + + while (*q != '#') + { + if (*q >= '0' && *q <= '9') + ucs += mult * (*q - '0'); + else + return 0; + mult *= 10; + --q; + } + } + if (encoding == TIXML_ENCODING_UTF8) + { + // convert the UCS to UTF-8 + ConvertUTF32ToUTF8(ucs, value, length); + } + else + { + *value = (char)ucs; + *length = 1; + } + return p + delta + 1; + } + + // Now try to match it. + for (i=0; iappend(cArr, len); + } + } + else + { + bool whitespace = false; + + // Remove leading white space: + p = SkipWhiteSpace(p, encoding); + while ( p && *p + && !StringEqual(p, endTag, caseInsensitive, encoding)) + { + if (*p == '\r' || *p == '\n') + { + whitespace = true; + ++p; + } + else if (IsWhiteSpace(*p)) + { + whitespace = true; + ++p; + } + else + { + // If we've found whitespace, add it before the + // new character. Any whitespace just becomes a space. + if (whitespace) + { + (*text) += ' '; + whitespace = false; + } + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar(p, cArr, &len, encoding); + if (len == 1) + (*text) += cArr[0]; // more efficient + else + text->append(cArr, len); + } + } + } + return p + strlen(endTag); +} + +#ifdef TIXML_USE_STL + +void TiXmlDocument::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) +{ + // The basic issue with a document is that we don't know what we're + // streaming. Read something presumed to be a tag (and hope), then + // identify it, and call the appropriate stream method on the tag. + // + // This "pre-streaming" will never read the closing ">" so the + // sub-tag can orient itself. + + if (!StreamTo(in, '<', tag)) + { + SetError(TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN); + return; + } + + while (in->good()) + { + int tagIndex = (int) tag->length(); + while (in->good() && in->peek() != '>') + { + int c = in->get(); + if (c <= 0) + { + SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); + break; + } + (*tag) += (char) c; + } + + if (in->good()) + { + // We now have something we presume to be a node of + // some sort. Identify it, and call the node to + // continue streaming. + TiXmlNode* node = Identify(tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING); + + if (node) + { + node->StreamIn(in, tag); + bool isElement = node->ToElement() != 0; + delete node; + node = 0; + + // If this is the root element, we're done. Parsing will be + // done by the >> operator. + if (isElement) + { + return; + } + } + else + { + SetError(TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN); + return; + } + } + } + // We should have returned sooner. + SetError(TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN); +} + +#endif + +const char* TiXmlDocument::Parse(const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding) +{ + ClearError(); + + // Parse away, at the document level. Since a document + // contains nothing but other tags, most of what happens + // here is skipping white space. + if (!p || !*p) + { + SetError(TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + + // Note that, for a document, this needs to come + // before the while space skip, so that parsing + // starts from the pointer we are given. + location.Clear(); + if (prevData) + { + location.row = prevData->cursor.row; + location.col = prevData->cursor.col; + } + else + { + location.row = 0; + location.col = 0; + } + TiXmlParsingData data(p, TabSize(), location.row, location.col); + location = data.Cursor(); + + if (encoding == TIXML_ENCODING_UNKNOWN) + { + // Check for the Microsoft UTF-8 lead bytes. + const unsigned char* pU = (const unsigned char*)p; + if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 + && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 + && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2) + { + encoding = TIXML_ENCODING_UTF8; + useMicrosoftBOM = true; + } + } + + p = SkipWhiteSpace(p, encoding); + if (!p) + { + SetError(TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN); + return 0; + } + + while (p && *p) + { + TiXmlNode* node = Identify(p, encoding); + if (node) + { + p = node->Parse(p, &data, encoding); + LinkEndChild(node); + } + else + { + break; + } + + // Did we get encoding info? + if ( encoding == TIXML_ENCODING_UNKNOWN + && node->ToDeclaration()) + { + TiXmlDeclaration* dec = node->ToDeclaration(); + const char* enc = dec->Encoding(); + assert(enc); + + if (*enc == 0) + encoding = TIXML_ENCODING_UTF8; + else if (StringEqual(enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN)) + encoding = TIXML_ENCODING_UTF8; + else if (StringEqual(enc, "UTF8", true, TIXML_ENCODING_UNKNOWN)) + encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice + else + encoding = TIXML_ENCODING_LEGACY; + } + + p = SkipWhiteSpace(p, encoding); + } + + // Was this empty? + if (!firstChild) { + SetError(TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding); + return 0; + } + + // All is well. + return p; +} + +void TiXmlDocument::SetError(int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding) +{ + // The first error in a chain is more accurate - don't set again! + if (error) + return; + + assert(err > 0 && err < TIXML_ERROR_STRING_COUNT); + error = true; + errorId = err; + errorDesc = errorString[ errorId ]; + + errorLocation.Clear(); + if (pError && data) + { + data->Stamp(pError, encoding); + errorLocation = data->Cursor(); + } +} + + +TiXmlNode* TiXmlNode::Identify(const char* p, TiXmlEncoding encoding) +{ + TiXmlNode* returnNode = 0; + + p = SkipWhiteSpace(p, encoding); + if (!p || !*p || *p != '<') + { + return 0; + } + + TiXmlDocument* doc = GetDocument(); + p = SkipWhiteSpace(p, encoding); + + if (!p || !*p) + { + return 0; + } + + // What is this thing? + // - Elements start with a letter or underscore, but xml is reserved. + // - Comments: "; + + if (!StringEqual(p, startTag, false, encoding)) + { + document->SetError(TIXML_ERROR_PARSING_COMMENT, p, data, encoding); + return 0; + } + p += strlen(startTag); + p = ReadText(p, &value, false, endTag, false, encoding); + return p; +} + + +const char* TiXmlAttribute::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding) +{ + p = SkipWhiteSpace(p, encoding); + if (!p || !*p) return 0; + +// int tabsize = 4; +// if (document) +// tabsize = document->TabSize(); + + if (data) + { + data->Stamp(p, encoding); + location = data->Cursor(); + } + // Read the name, the '=' and the value. + const char* pErr = p; + p = ReadName(p, &name, encoding); + if (!p || !*p) + { + if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding); + return 0; + } + p = SkipWhiteSpace(p, encoding); + if (!p || !*p || *p != '=') + { + if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); + return 0; + } + + ++p; // skip '=' + p = SkipWhiteSpace(p, encoding); + if (!p || !*p) + { + if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); + return 0; + } + + const char* end; + const char SINGLE_QUOTE = '\''; + const char DOUBLE_QUOTE = '\"'; + + if (*p == SINGLE_QUOTE) + { + ++p; + end = "\'"; // single quote in string + p = ReadText(p, &value, false, end, false, encoding); + } + else if (*p == DOUBLE_QUOTE) + { + ++p; + end = "\""; // double quote in string + p = ReadText(p, &value, false, end, false, encoding); + } + else + { + // All attribute values should be in single or double quotes. + // But this is such a common error that the parser will try + // its best, even without them. + value = ""; + while ( p && *p // existence + && !IsWhiteSpace(*p) && *p != '\n' && *p != '\r' // whitespace + && *p != '/' && *p != '>') // tag end + { + if (*p == SINGLE_QUOTE || *p == DOUBLE_QUOTE) { + // [ 1451649 ] Attribute values with trailing quotes not handled correctly + // We did not have an opening quote but seem to have a + // closing one. Give up and throw an error. + if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); + return 0; + } + value += *p; + ++p; + } + } + return p; +} + +#ifdef TIXML_USE_STL +void TiXmlText::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) +{ + if (cdata) + { + int c = in->get(); + if (c <= 0) + { + TiXmlDocument* document = GetDocument(); + if (document) + document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); + return; + } + + (*tag) += (char) c; + + if (c == '>' + && tag->at(tag->length() - 2) == ']' + && tag->at(tag->length() - 3) == ']') + { + // All is well. + return; + } + } + else + { + while (in->good()) + { + int c = in->peek(); + if (c == '<') + return; + if (c <= 0) + { + TiXmlDocument* document = GetDocument(); + if (document) + document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); + return; + } + + (*tag) += (char) c; + in->get(); + } + } +} +#endif + +const char* TiXmlText::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding) +{ + value = ""; + TiXmlDocument* document = GetDocument(); + + if (data) + { + data->Stamp(p, encoding); + location = data->Cursor(); + } + + const char* const startTag = ""; + + if (cdata || StringEqual(p, startTag, false, encoding)) + { + cdata = true; + + if (!StringEqual(p, startTag, false, encoding)) + { + document->SetError(TIXML_ERROR_PARSING_CDATA, p, data, encoding); + return 0; + } + p += strlen(startTag); + + // Keep all the white space, ignore the encoding, etc. + while ( p && *p + && !StringEqual(p, endTag, false, encoding) + ) + { + value += *p; + ++p; + } + + TIXML_STRING dummy; + p = ReadText(p, &dummy, false, endTag, false, encoding); + return p; + } + else + { + bool ignoreWhite = true; + + const char* end = "<"; + p = ReadText(p, &value, ignoreWhite, end, false, encoding); + if (p) + return p-1; // don't truncate the '<' + return 0; + } +} + +#ifdef TIXML_USE_STL +void TiXmlDeclaration::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) +{ + while (in->good()) + { + int c = in->get(); + if (c <= 0) + { + TiXmlDocument* document = GetDocument(); + if (document) + document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); + return; + } + (*tag) += (char) c; + + if (c == '>') + { + // All is well. + return; + } + } +} +#endif + +const char* TiXmlDeclaration::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding) +{ + p = SkipWhiteSpace(p, _encoding); + // Find the beginning, find the end, and look for + // the stuff in-between. + TiXmlDocument* document = GetDocument(); + if (!p || !*p || !StringEqual(p, "SetError(TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding); + return 0; + } + if (data) + { + data->Stamp(p, _encoding); + location = data->Cursor(); + } + p += 5; + + version = ""; + encoding = ""; + standalone = ""; + + while (p && *p) + { + if (*p == '>') + { + ++p; + return p; + } + + p = SkipWhiteSpace(p, _encoding); + if (StringEqual(p, "version", true, _encoding)) + { + TiXmlAttribute attrib; + p = attrib.Parse(p, data, _encoding); + version = attrib.Value(); + } + else if (StringEqual(p, "encoding", true, _encoding)) + { + TiXmlAttribute attrib; + p = attrib.Parse(p, data, _encoding); + encoding = attrib.Value(); + } + else if (StringEqual(p, "standalone", true, _encoding)) + { + TiXmlAttribute attrib; + p = attrib.Parse(p, data, _encoding); + standalone = attrib.Value(); + } + else + { + // Read over whatever it is. + while (p && *p && *p != '>' && !IsWhiteSpace(*p)) + ++p; + } + } + return 0; +} + +bool TiXmlText::Blank() const +{ + for (unsigned i=0; i