1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_sw.hxx" 30 #include <mmconfigitem.hxx> 31 #include <swtypes.hxx> 32 #include <tools/debug.hxx> 33 #include <com/sun/star/uno/Any.hxx> 34 #include <com/sun/star/beans/PropertyValue.hpp> 35 #include <com/sun/star/sdb/XCompletedConnection.hpp> 36 #include <com/sun/star/sdbc/XDataSource.hpp> 37 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> 38 #include "com/sun/star/mail/MailServiceType.hpp" 39 #include "com/sun/star/mail/XMailService.hpp" 40 #include "com/sun/star/mail/MailServiceProvider.hpp" 41 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 42 #include <com/sun/star/beans/XPropertySet.hpp> 43 #include <com/sun/star/sdbc/XRowSet.hpp> 44 #include <comphelper/processfactory.hxx> 45 #include <comphelper/types.hxx> 46 #include <com/sun/star/sdb/CommandType.hpp> 47 #include <unotools/configitem.hxx> 48 #include <mailmergehelper.hxx> 49 #include <swunohelper.hxx> 50 #ifndef _DBMGR_HXX 51 #include <dbmgr.hxx> 52 #endif 53 #ifndef _VIEW_HXX 54 #include <view.hxx> 55 #endif 56 #include <wrtsh.hxx> 57 #include <dbui.hrc> 58 #include <vector> 59 60 #include <unomid.h> 61 62 #define _SVSTDARR_STRINGSDTOR 63 #include <svl/svstdarr.hxx> 64 65 using namespace utl; 66 using ::rtl::OUString; 67 using namespace ::com::sun::star; 68 using namespace ::com::sun::star::uno; 69 using namespace ::com::sun::star::lang; 70 using namespace ::com::sun::star::beans; 71 using namespace ::com::sun::star::sdb; 72 using namespace ::com::sun::star::sdbc; 73 using namespace ::com::sun::star::sdbcx; 74 75 const char* cAddressDataAssignments = "AddressDataAssignments"; 76 const char* cDBColumnAssignments = "DBColumnAssignments"; 77 const char* cDataSourceName = "DataSource/DataSourceName"; 78 const char* cDataTableName = "DataSource/DataTableName" ; 79 const char* cDataCommandType = "DataSource/DataCommandType"; 80 81 #define SECURE_PORT 465 82 #define DEFAULT_PORT 25 83 #define POP_PORT 110 84 85 /*-- 16.04.2004 09:41:36--------------------------------------------------- 86 87 -----------------------------------------------------------------------*/ 88 struct DBAddressDataAssignment 89 { 90 SwDBData aDBData; 91 Sequence< ::rtl::OUString> aDBColumnAssignments; 92 //if loaded the name of the node has to be saved 93 ::rtl::OUString sConfigNodeName; 94 //all created or changed assignments need to be stored 95 bool bColumnAssignmentsChanged; 96 97 DBAddressDataAssignment() : 98 bColumnAssignmentsChanged(false) 99 {} 100 }; 101 102 /*-- 16.04.2004 09:43:29--------------------------------------------------- 103 104 -----------------------------------------------------------------------*/ 105 class SwMailMergeConfigItem_Impl : public utl::ConfigItem 106 { 107 friend class SwMailMergeConfigItem; 108 Reference< XDataSource> xSource; 109 SharedConnection xConnection; 110 Reference< XColumnsSupplier> xColumnsSupplier; 111 Reference< XStatement> xStatement; 112 Reference< XResultSet> xResultSet; 113 SwDBData aDBData; 114 ::rtl::OUString sFilter; 115 sal_Int32 nResultSetCursorPos; 116 117 ::std::vector<DBAddressDataAssignment> aAddressDataAssignments; 118 ::std::vector< ::rtl::OUString> aAddressBlocks; 119 sal_Int32 nCurrentAddressBlock; 120 sal_Bool bIsAddressBlock; 121 sal_Bool bIsHideEmptyParagraphs; 122 123 sal_Bool bIsOutputToLetter; 124 sal_Bool bIncludeCountry; 125 ::rtl::OUString sExcludeCountry; 126 127 sal_Bool bIsGreetingLine; 128 sal_Bool bIsIndividualGreetingLine; 129 ::std::vector< ::rtl::OUString> aFemaleGreetingLines; 130 sal_Int32 nCurrentFemaleGreeting; 131 ::std::vector< ::rtl::OUString> aMaleGreetingLines; 132 sal_Int32 nCurrentMaleGreeting; 133 ::std::vector< ::rtl::OUString> aNeutralGreetingLines; 134 sal_Int32 nCurrentNeutralGreeting; 135 ::rtl::OUString sFemaleGenderValue; 136 uno::Sequence< ::rtl::OUString> aSavedDocuments; 137 138 sal_Bool bIsGreetingLineInMail; 139 sal_Bool bIsIndividualGreetingLineInMail; 140 141 //mail settings 142 ::rtl::OUString sMailDisplayName; 143 ::rtl::OUString sMailAddress; 144 ::rtl::OUString sMailReplyTo; 145 ::rtl::OUString sMailServer; 146 ::rtl::OUString sMailUserName; 147 ::rtl::OUString sMailPassword; 148 149 sal_Bool bIsSMPTAfterPOP; 150 ::rtl::OUString sInServerName; 151 sal_Int16 nInServerPort; 152 sal_Bool bInServerPOP; 153 ::rtl::OUString sInServerUserName; 154 ::rtl::OUString sInServerPassword; 155 156 sal_Int16 nMailPort; 157 sal_Bool bIsMailReplyTo; 158 sal_Bool bIsDefaultPort; 159 sal_Bool bIsSecureConnection; 160 sal_Bool bIsAuthentication; 161 162 sal_Bool bIsEMailSupported; 163 164 ResStringArray m_AddressHeaderSA; 165 166 //these addresses are not stored in the configuration 167 ::std::vector< SwDocMergeInfo > aMergeInfos; 168 169 //we do overwrite the usersettings in a special case 170 //than we do remind the usersettings here 171 sal_Bool bUserSettingWereOverwritten; 172 sal_Bool bIsAddressBlock_LastUserSetting; 173 sal_Bool bIsGreetingLineInMail_LastUserSetting; 174 sal_Bool bIsGreetingLine_LastUserSetting; 175 176 177 const Sequence< ::rtl::OUString>& GetPropertyNames(); 178 179 public: 180 SwMailMergeConfigItem_Impl(); 181 ~SwMailMergeConfigItem_Impl(); 182 183 virtual void Commit(); 184 virtual void Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ); 185 const Sequence< ::rtl::OUString> 186 GetAddressBlocks(sal_Bool bConvertToConfig = sal_False) const; 187 void SetAddressBlocks( 188 const Sequence< ::rtl::OUString>& rBlocks, 189 sal_Bool bConvertFromConfig = sal_False); 190 const uno::Sequence< ::rtl::OUString> 191 GetGreetings(SwMailMergeConfigItem::Gender eType, 192 sal_Bool bConvertToConfig = sal_False) const; 193 void SetGreetings(SwMailMergeConfigItem::Gender eType, 194 const uno::Sequence< ::rtl::OUString>& rBlocks, 195 sal_Bool bConvertFromConfig = sal_False); 196 197 void SetCurrentAddressBlockIndex( sal_Int32 nSet ); 198 sal_Int32 GetCurrentAddressBlockIndex() const 199 { return nCurrentAddressBlock; } 200 sal_Int32 GetCurrentGreeting(SwMailMergeConfigItem::Gender eType) const; 201 void SetCurrentGreeting(SwMailMergeConfigItem::Gender eType, sal_Int32 nIndex); 202 203 }; 204 205 /*-- 06.05.2004 12:51:54--------------------------------------------------- 206 207 -----------------------------------------------------------------------*/ 208 SwMailMergeConfigItem_Impl::SwMailMergeConfigItem_Impl() : 209 ConfigItem(C2U("Office.Writer/MailMergeWizard"), 0), 210 nResultSetCursorPos(-1), 211 nCurrentAddressBlock(0), 212 bIsAddressBlock(sal_True), 213 bIsHideEmptyParagraphs(sal_False), 214 bIsOutputToLetter(sal_True), 215 bIncludeCountry(sal_False), 216 bIsGreetingLine(sal_True), 217 nCurrentFemaleGreeting(0), 218 nCurrentMaleGreeting(0), 219 nCurrentNeutralGreeting(0), 220 221 bIsSMPTAfterPOP(sal_False), 222 nInServerPort( POP_PORT ), 223 bInServerPOP( sal_True ), 224 nMailPort(0), 225 bIsMailReplyTo(sal_False), 226 bIsDefaultPort(sal_False), 227 bIsSecureConnection(sal_False), 228 bIsAuthentication(sal_False), 229 230 bIsEMailSupported(sal_False), 231 m_AddressHeaderSA( SW_RES( SA_ADDRESS_HEADER )), 232 bUserSettingWereOverwritten(sal_False), 233 bIsAddressBlock_LastUserSetting(sal_False), 234 bIsGreetingLineInMail_LastUserSetting(sal_False), 235 bIsGreetingLine_LastUserSetting(sal_False) 236 { 237 const Sequence<OUString>& rNames = GetPropertyNames(); 238 Sequence<Any> aValues = GetProperties(rNames); 239 const Any* pValues = aValues.getConstArray(); 240 DBG_ASSERT(aValues.getLength() == rNames.getLength(), "GetProperties failed"); 241 if(aValues.getLength() == rNames.getLength()) 242 { 243 for(int nProp = 0; nProp < rNames.getLength(); nProp++) 244 { 245 switch(nProp) 246 { 247 case 0: pValues[nProp] >>= bIsOutputToLetter; break; 248 case 1: pValues[nProp] >>= bIncludeCountry; break; 249 case 2: pValues[nProp] >>= sExcludeCountry; break; 250 case 3: 251 { 252 Sequence< ::rtl::OUString> aBlocks; 253 pValues[nProp] >>= aBlocks; 254 SetAddressBlocks(aBlocks, sal_True); 255 } 256 break; 257 case 4: pValues[nProp] >>= bIsAddressBlock; break; 258 case 5: pValues[nProp] >>= bIsGreetingLine; break; 259 case 6: pValues[nProp] >>= bIsIndividualGreetingLine; break; 260 case 7 : 261 case 8 : 262 case 9 : 263 { 264 Sequence< ::rtl::OUString> aGreetings; 265 pValues[nProp] >>= aGreetings; 266 SetGreetings(SwMailMergeConfigItem::Gender( 267 SwMailMergeConfigItem::FEMALE + nProp - 7), aGreetings, sal_True); 268 } 269 break; 270 271 case 10: pValues[nProp] >>= nCurrentFemaleGreeting; break; 272 case 11: pValues[nProp] >>= nCurrentMaleGreeting; break; 273 case 12: pValues[nProp] >>= nCurrentNeutralGreeting; break; 274 case 13: pValues[nProp] >>= sFemaleGenderValue; break; 275 case 14: pValues[nProp] >>= sMailDisplayName; break; 276 case 15: pValues[nProp] >>= sMailAddress; break; 277 case 16: pValues[nProp] >>= bIsMailReplyTo; break; 278 case 17: pValues[nProp] >>= sMailReplyTo; break; 279 case 18: pValues[nProp] >>= sMailServer; break; 280 case 19: 281 bIsDefaultPort = 282 (pValues[nProp] >>= nMailPort) ? 283 sal_False : sal_True; 284 break; 285 case 20: pValues[nProp] >>= bIsSecureConnection; break; 286 case 21: pValues[nProp] >>= bIsAuthentication; break; 287 case 22: pValues[nProp] >>= sMailUserName; break; 288 case 23: pValues[nProp] >>= sMailPassword; break; 289 case 24 :pValues[nProp] >>= aDBData.sDataSource; break; 290 case 25 :pValues[nProp] >>= aDBData.sCommand; break; 291 case 26 : 292 { 293 short nTemp = 0; 294 if(pValues[nProp] >>= nTemp) 295 aDBData.nCommandType = nTemp; 296 } 297 break; 298 case 27: pValues[nProp] >>= sFilter; break; 299 case 28: pValues[nProp] >>= aSavedDocuments; break; 300 case 29: 301 pValues[nProp] >>= bIsEMailSupported; 302 break; 303 case 30: pValues[nProp] >>= bIsGreetingLineInMail; break; 304 case 31: pValues[nProp] >>= bIsIndividualGreetingLineInMail; break; 305 case 32: pValues[nProp] >>= bIsSMPTAfterPOP; break; 306 case 33: pValues[nProp] >>= sInServerName; break; 307 case 34: pValues[nProp] >>= nInServerPort; break; 308 case 35: pValues[nProp] >>= bInServerPOP; break; 309 case 36: pValues[nProp] >>= sInServerUserName; break; 310 case 37: pValues[nProp] >>= sInServerPassword; break; 311 case 38: pValues[nProp] >>= bIsHideEmptyParagraphs; break; 312 case 39: pValues[nProp] >>= nCurrentAddressBlock; break; 313 } 314 } 315 } 316 //read the list of data base assignments 317 Sequence<OUString> aAssignments = GetNodeNames(C2U(cAddressDataAssignments)); 318 if(aAssignments.getLength()) 319 { 320 //create a list of property names to load the URLs of all data bases 321 const OUString* pAssignments = aAssignments.getConstArray(); 322 Sequence< ::rtl::OUString > aAssignProperties(4 * aAssignments.getLength()); 323 ::rtl::OUString* pAssignProperties = aAssignProperties.getArray(); 324 sal_Int32 nAssign; 325 OUString sSlash = C2U("/"); 326 for(nAssign = 0; nAssign < aAssignProperties.getLength(); nAssign += 4) 327 { 328 String sAssignPath = C2U(cAddressDataAssignments); 329 sAssignPath += '/'; 330 sAssignPath += String(pAssignments[nAssign / 4]); 331 sAssignPath += '/'; 332 pAssignProperties[nAssign] = sAssignPath; 333 pAssignProperties[nAssign] += C2U(cDataSourceName); 334 pAssignProperties[nAssign + 1] = sAssignPath; 335 pAssignProperties[nAssign + 1] += C2U(cDataTableName); 336 pAssignProperties[nAssign + 2] = sAssignPath; 337 pAssignProperties[nAssign + 2] += C2U(cDataCommandType); 338 pAssignProperties[nAssign + 3] = sAssignPath; 339 pAssignProperties[nAssign + 3] += C2U(cDBColumnAssignments); 340 } 341 Sequence<Any> aAssignValues = GetProperties(aAssignProperties); 342 const Any* pAssignValues = aAssignValues.getConstArray(); 343 for(nAssign = 0; nAssign < aAssignValues.getLength(); nAssign += 4 ) 344 { 345 DBAddressDataAssignment aAssignment; 346 pAssignValues[nAssign] >>= aAssignment.aDBData.sDataSource; 347 pAssignValues[nAssign + 1] >>= aAssignment.aDBData.sCommand; 348 pAssignValues[nAssign + 2] >>= aAssignment.aDBData.nCommandType; 349 pAssignValues[nAssign + 3] >>= aAssignment.aDBColumnAssignments; 350 aAssignment.sConfigNodeName = pAssignments[nAssign / 4]; 351 aAddressDataAssignments.push_back(aAssignment); 352 } 353 } 354 //check if the saved documents still exist 355 if(aSavedDocuments.getLength()) 356 { 357 uno::Sequence< ::rtl::OUString > aTempDocuments(aSavedDocuments.getLength()); 358 ::rtl::OUString* pTempDocuments = aTempDocuments.getArray(); 359 sal_Int32 nIndex = 0; 360 for(sal_Int32 i = 0; i < aSavedDocuments.getLength(); ++i) 361 { 362 if(SWUnoHelper::UCB_IsFile( aSavedDocuments[i] )) 363 { 364 pTempDocuments[nIndex++] = aSavedDocuments[i]; 365 } 366 } 367 if(nIndex < aSavedDocuments.getLength()) 368 { 369 aSavedDocuments = aTempDocuments; 370 aSavedDocuments.realloc(nIndex); 371 } 372 } 373 374 } 375 /*-- 06.05.2004 12:51:54--------------------------------------------------- 376 377 -----------------------------------------------------------------------*/ 378 SwMailMergeConfigItem_Impl::~SwMailMergeConfigItem_Impl() 379 { 380 } 381 /*-- 13.03.2006 12:12:59--------------------------------------------------- 382 383 -----------------------------------------------------------------------*/ 384 void SwMailMergeConfigItem_Impl::SetCurrentAddressBlockIndex( sal_Int32 nSet ) 385 { 386 if(aAddressBlocks.size() >= sal::static_int_cast<sal_uInt32, sal_Int32>(nSet)) 387 { 388 nCurrentAddressBlock = nSet; 389 SetModified(); 390 } 391 } 392 /*-- 16.04.2004 13:06:07--------------------------------------------------- 393 394 -----------------------------------------------------------------------*/ 395 OUString lcl_CreateNodeName(Sequence<OUString>& rAssignments ) 396 { 397 const OUString* pNames = rAssignments.getConstArray(); 398 sal_Int32 nStart = rAssignments.getLength(); 399 OUString sNewName; 400 bool bFound; 401 do 402 { 403 bFound = false; 404 sNewName = C2U("_"); 405 sNewName += OUString::valueOf(nStart); 406 //search if the name exists 407 for(sal_Int32 nAssign = 0; nAssign < rAssignments.getLength(); ++nAssign) 408 { 409 if(pNames[nAssign] == sNewName) 410 { 411 bFound = true; 412 ++nStart; 413 break; 414 } 415 } 416 } 417 while(bFound); 418 // add the new name to the array of existing names 419 rAssignments.realloc(rAssignments.getLength() + 1); 420 rAssignments.getArray()[rAssignments.getLength() - 1] = sNewName; 421 return sNewName; 422 } 423 // -------------------------------------------------------------------------------- 424 void lcl_ConvertToNumbers(OUString& rBlock, const ResStringArray& rHeaders ) 425 { 426 //convert the strings used for UI to numbers used for the configuration 427 String sBlock(rBlock); 428 sBlock.SearchAndReplaceAllAscii("\n", String::CreateFromAscii("\\n")); 429 for(sal_uInt16 i = 0; i < rHeaders.Count(); ++i) 430 { 431 String sHeader = rHeaders.GetString( i ); 432 sHeader.Insert('<', 0); 433 sHeader += '>'; 434 String sReplace(C2U("<>")); 435 sReplace.Insert('0' + i, 1); 436 sBlock.SearchAndReplaceAll(sHeader, sReplace); 437 } 438 rBlock = sBlock; 439 } 440 // -------------------------------------------------------------------------------- 441 void lcl_ConvertFromNumbers(OUString& rBlock, const ResStringArray& rHeaders) 442 { 443 //convert the numbers used for the configuration to strings used for UI to numbers 444 //doesn't use ReplaceAll to prevent expansion of numbers inside of the headers 445 String sBlock(rBlock); 446 sBlock.SearchAndReplaceAllAscii("\\n", '\n'); 447 SwAddressIterator aGreetingIter(sBlock); 448 sBlock.Erase(); 449 while(aGreetingIter.HasMore()) 450 { 451 SwMergeAddressItem aNext = aGreetingIter.Next(); 452 if(aNext.bIsColumn) 453 { 454 //the text should be 1 characters long 455 sal_Unicode cChar = aNext.sText.GetChar(0); 456 if(cChar >= '0' && cChar <= 'c') 457 { 458 sBlock += '<'; 459 sal_uInt16 nHeader = cChar - '0'; 460 if(nHeader < rHeaders.Count()) 461 sBlock += rHeaders.GetString( nHeader ); 462 sBlock += '>'; 463 } 464 else 465 { 466 DBG_ERROR("parse error in address block or greeting line"); 467 } 468 } 469 else 470 sBlock += aNext.sText; 471 } 472 rBlock = sBlock; 473 } 474 475 /*-------------------------------------------------------------------- 476 477 --------------------------------------------------------------------*/ 478 const Sequence<OUString>& SwMailMergeConfigItem_Impl::GetPropertyNames() 479 { 480 static Sequence<OUString> aNames; 481 if(!aNames.getLength()) 482 { 483 static const char* aPropNames[] = 484 { 485 "OutputToLetter", // 0 486 "IncludeCountry", // 1 487 "ExcludeCountry", // 2 488 "AddressBlockSettings", // 3 489 "IsAddressBlock", // 4 490 "IsGreetingLine", // 5 491 "IsIndividualGreetingLine", // 6 492 "FemaleGreetingLines", // 7 493 "MaleGreetingLines", // 8 494 "NeutralGreetingLines", // 9 495 "CurrentFemaleGreeting", // 10 496 "CurrentMaleGreeting", // 11 497 "CurrentNeutralGreeting", // 12 498 "FemaleGenderValue", // 13 499 "MailDisplayName", // 14 500 "MailAddress", // 15 501 "IsMailReplyTo", // 16 502 "MailReplyTo", // 17 503 "MailServer", // 18 504 "MailPort", // 19 505 "IsSecureConnection", // 20 506 "IsAuthentication", // 21 507 "MailUserName", // 22 508 "MailPassword", // 23 509 "DataSource/DataSourceName",// 24 510 "DataSource/DataTableName", // 25 511 "DataSource/DataCommandType",// 26 512 "Filter", // 27 513 "SavedDocuments", // 28 514 "EMailSupported", // 29 515 "IsEMailGreetingLine", //30 516 "IsEMailIndividualGreetingLine", //31 517 "IsSMPTAfterPOP", //32 518 "InServerName", //33 519 "InServerPort", //34 520 "InServerIsPOP", //35 521 "InServerUserName", //36 522 "InServerPassword", //37 523 "IsHideEmptyParagraphs", //38 524 "CurrentAddressBlock" //39 525 526 }; 527 const int nCount = sizeof(aPropNames)/sizeof(const char*); 528 aNames.realloc(nCount); 529 OUString* pNames = aNames.getArray(); 530 for(int i = 0; i < nCount; i++) 531 pNames[i] = OUString::createFromAscii(aPropNames[i]); 532 } 533 return aNames; 534 } 535 /*-- 15.04.2004 08:48:39--------------------------------------------------- 536 537 -----------------------------------------------------------------------*/ 538 void SwMailMergeConfigItem_Impl::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& ) {} 539 540 void SwMailMergeConfigItem_Impl::Commit() 541 { 542 Sequence<OUString> aNames = GetPropertyNames(); 543 Sequence<Any> aValues(aNames.getLength()); 544 Any* pValues = aValues.getArray(); 545 546 for(int nProp = 0; nProp < aNames.getLength(); nProp++) 547 { 548 switch(nProp) 549 { 550 case 0: pValues[nProp] <<= bIsOutputToLetter; break;// 551 case 1: pValues[nProp] <<= bIncludeCountry; break; 552 case 2: pValues[nProp] <<= sExcludeCountry; break; 553 case 3: pValues[nProp] <<= GetAddressBlocks(sal_True); break; 554 case 4: 555 { 556 if( bUserSettingWereOverwritten == sal_True ) 557 pValues[nProp] <<= bIsAddressBlock_LastUserSetting; 558 else 559 pValues[nProp] <<= bIsAddressBlock; 560 break; 561 } 562 case 5: 563 { 564 if( bUserSettingWereOverwritten == sal_True ) 565 pValues[nProp] <<= bIsGreetingLine_LastUserSetting; 566 else 567 pValues[nProp] <<= bIsGreetingLine; 568 break; 569 } 570 case 6: pValues[nProp] <<= bIsIndividualGreetingLine; break; 571 case 7: 572 case 8: 573 case 9: 574 pValues[nProp] <<= GetGreetings( 575 SwMailMergeConfigItem::Gender( 576 SwMailMergeConfigItem::FEMALE + nProp - 7), sal_True); 577 break; 578 case 10: pValues[nProp] <<= nCurrentFemaleGreeting; break; 579 case 11: pValues[nProp] <<= nCurrentMaleGreeting; break; 580 case 12: pValues[nProp] <<= nCurrentNeutralGreeting; break; 581 case 13: pValues[nProp] <<= sFemaleGenderValue; break; 582 case 14: pValues[nProp] <<= sMailDisplayName; break; 583 case 15: pValues[nProp] <<= sMailAddress; break; 584 case 16: pValues[nProp] <<= bIsMailReplyTo; break; 585 case 17: pValues[nProp] <<= sMailReplyTo; break; 586 case 18: pValues[nProp] <<= sMailServer; break; 587 case 19: if(!bIsDefaultPort) 588 pValues[nProp] <<= nMailPort; 589 break; 590 case 20: pValues[nProp] <<= bIsSecureConnection; break; 591 case 21: pValues[nProp] <<= bIsAuthentication; break; 592 case 22: pValues[nProp] <<= sMailUserName; break; 593 case 23: pValues[nProp] <<= sMailPassword; break; 594 case 24 :pValues[nProp] <<= aDBData.sDataSource; break; 595 case 25 :pValues[nProp] <<= aDBData.sCommand; break; 596 case 26 :pValues[nProp] <<= (short)aDBData.nCommandType; break; 597 case 27 :pValues[nProp] <<= sFilter; break; 598 case 28 :pValues[nProp] <<= aSavedDocuments; break; 599 case 29: pValues[nProp] <<= bIsEMailSupported; break; 600 case 30: 601 { 602 if( bUserSettingWereOverwritten == sal_True ) 603 pValues[nProp] <<= bIsGreetingLineInMail_LastUserSetting; 604 else 605 pValues[nProp] <<= bIsGreetingLineInMail; 606 break; 607 } 608 case 31: pValues[nProp] <<= bIsIndividualGreetingLineInMail; break; 609 case 32: pValues[nProp] <<= bIsSMPTAfterPOP; break; 610 case 33: pValues[nProp] <<= sInServerName; break; 611 case 34: pValues[nProp] <<= nInServerPort; break; 612 case 35: pValues[nProp] <<= bInServerPOP; break; 613 case 36: pValues[nProp] <<= sInServerUserName; break; 614 case 37: pValues[nProp] <<= sInServerPassword; break; 615 case 38: pValues[nProp] <<= bIsHideEmptyParagraphs; break; 616 case 39: pValues[nProp] <<= nCurrentAddressBlock; break; 617 } 618 } 619 PutProperties(aNames, aValues); 620 //store the changed / new assignments 621 622 //load the existing node names to find new names 623 Sequence<OUString> aAssignments = GetNodeNames(C2U(cAddressDataAssignments)); 624 625 ::std::vector<DBAddressDataAssignment>::iterator aAssignIter; 626 for(aAssignIter = aAddressDataAssignments.begin(); 627 aAssignIter != aAddressDataAssignments.end(); aAssignIter++) 628 { 629 if(aAssignIter->bColumnAssignmentsChanged) 630 { 631 //create a new node name 632 OUString sNewNode = aAssignIter->sConfigNodeName.getLength() ? 633 aAssignIter->sConfigNodeName : 634 lcl_CreateNodeName(aAssignments); 635 OUString sSlash = C2U("/"); 636 OUString sNodePath = C2U(cAddressDataAssignments); 637 sNodePath += sSlash; 638 sNodePath += sNewNode; 639 sNodePath += sSlash; 640 //only one new entry is written 641 Sequence< PropertyValue > aNewValues(4); 642 PropertyValue* pNewValues = aNewValues.getArray(); 643 pNewValues[0].Name = sNodePath; 644 pNewValues[0].Name += C2U(cDataSourceName); 645 pNewValues[0].Value <<= aAssignIter->aDBData.sDataSource; 646 pNewValues[1].Name = sNodePath; 647 pNewValues[1].Name += C2U(cDataTableName); 648 pNewValues[1].Value <<= aAssignIter->aDBData.sCommand; 649 pNewValues[2].Name = sNodePath; 650 pNewValues[2].Name += C2U(cDataCommandType); 651 pNewValues[2].Value <<= aAssignIter->aDBData.nCommandType; 652 pNewValues[3].Name = sNodePath; 653 pNewValues[3].Name += C2U(cDBColumnAssignments); 654 pNewValues[3].Value <<= aAssignIter->aDBColumnAssignments; 655 656 SetSetProperties(C2U(cAddressDataAssignments), aNewValues); 657 } 658 } 659 660 bUserSettingWereOverwritten = sal_False; 661 } 662 /*-- 06.05.2004 13:04:36--------------------------------------------------- 663 664 -----------------------------------------------------------------------*/ 665 const Sequence< ::rtl::OUString> SwMailMergeConfigItem_Impl::GetAddressBlocks( 666 sal_Bool bConvertToConfig) const 667 { 668 Sequence< ::rtl::OUString> aRet(aAddressBlocks.size()); 669 ::rtl::OUString* pRet = aRet.getArray(); 670 for(sal_uInt32 nBlock = 0; nBlock < aAddressBlocks.size(); nBlock++) 671 { 672 pRet[nBlock] = aAddressBlocks[nBlock]; 673 if(bConvertToConfig) 674 lcl_ConvertToNumbers(pRet[nBlock], m_AddressHeaderSA); 675 } 676 return aRet; 677 } 678 /*-- 06.05.2004 13:04:36--------------------------------------------------- 679 680 -----------------------------------------------------------------------*/ 681 void SwMailMergeConfigItem_Impl::SetAddressBlocks( 682 const Sequence< ::rtl::OUString>& rBlocks, 683 sal_Bool bConvertFromConfig) 684 { 685 aAddressBlocks.clear(); 686 for(sal_Int32 nBlock = 0; nBlock < rBlocks.getLength(); nBlock++) 687 { 688 OUString sBlock = rBlocks[nBlock]; 689 if(bConvertFromConfig) 690 lcl_ConvertFromNumbers(sBlock, m_AddressHeaderSA); 691 aAddressBlocks.push_back(sBlock); 692 } 693 nCurrentAddressBlock = 0; 694 SetModified(); 695 } 696 /*-- 30.04.2004 11:04:52--------------------------------------------------- 697 698 -----------------------------------------------------------------------*/ 699 const Sequence< ::rtl::OUString> SwMailMergeConfigItem_Impl::GetGreetings( 700 SwMailMergeConfigItem::Gender eType, sal_Bool bConvertToConfig) const 701 { 702 const ::std::vector< ::rtl::OUString>& rGreetings = 703 eType == SwMailMergeConfigItem::FEMALE ? aFemaleGreetingLines : 704 eType == SwMailMergeConfigItem::MALE ? aMaleGreetingLines : 705 aNeutralGreetingLines; 706 Sequence< ::rtl::OUString> aRet(rGreetings.size()); 707 ::rtl::OUString* pRet = aRet.getArray(); 708 for(sal_uInt32 nGreeting = 0; nGreeting < rGreetings.size(); nGreeting++) 709 { 710 pRet[nGreeting] = rGreetings[nGreeting]; 711 if(bConvertToConfig) 712 lcl_ConvertToNumbers(pRet[nGreeting], m_AddressHeaderSA); 713 } 714 return aRet; 715 } 716 /*-- 30.04.2004 11:04:52--------------------------------------------------- 717 718 -----------------------------------------------------------------------*/ 719 void SwMailMergeConfigItem_Impl::SetGreetings( 720 SwMailMergeConfigItem::Gender eType, 721 const Sequence< ::rtl::OUString>& rSetGreetings, 722 sal_Bool bConvertFromConfig) 723 { 724 ::std::vector< ::rtl::OUString>& rGreetings = 725 eType == SwMailMergeConfigItem::FEMALE ? aFemaleGreetingLines : 726 eType == SwMailMergeConfigItem::MALE ? aMaleGreetingLines : 727 aNeutralGreetingLines; 728 729 rGreetings.clear(); 730 for(sal_Int32 nGreeting = 0; nGreeting < rSetGreetings.getLength(); nGreeting++) 731 { 732 OUString sGreeting = rSetGreetings[nGreeting]; 733 if(bConvertFromConfig) 734 lcl_ConvertFromNumbers(sGreeting, m_AddressHeaderSA); 735 rGreetings.push_back(sGreeting); 736 } 737 SetModified(); 738 } 739 /*-- 11.05.2004 13:13:54--------------------------------------------------- 740 741 -----------------------------------------------------------------------*/ 742 sal_Int32 SwMailMergeConfigItem_Impl::GetCurrentGreeting( 743 SwMailMergeConfigItem::Gender eType) const 744 { 745 sal_Int32 nRet; 746 switch(eType) 747 { 748 case SwMailMergeConfigItem::FEMALE: nRet = nCurrentFemaleGreeting ; break; 749 case SwMailMergeConfigItem::MALE: nRet = nCurrentMaleGreeting ; break; 750 default: nRet = nCurrentNeutralGreeting; break; 751 } 752 return nRet; 753 } 754 /*-- 11.05.2004 13:13:54--------------------------------------------------- 755 756 -----------------------------------------------------------------------*/ 757 void SwMailMergeConfigItem_Impl::SetCurrentGreeting( 758 SwMailMergeConfigItem::Gender eType, sal_Int32 nIndex) 759 { 760 bool bChanged = false; 761 switch(eType) 762 { 763 case SwMailMergeConfigItem::FEMALE: 764 bChanged = nCurrentFemaleGreeting != nIndex; 765 nCurrentFemaleGreeting = nIndex; 766 break; 767 case SwMailMergeConfigItem::MALE: 768 bChanged = nCurrentMaleGreeting != nIndex; 769 nCurrentMaleGreeting = nIndex; 770 break; 771 default: 772 bChanged = nCurrentNeutralGreeting != nIndex; 773 nCurrentNeutralGreeting = nIndex; 774 } 775 if(bChanged) 776 SetModified(); 777 } 778 779 static SwMailMergeConfigItem_Impl* pOptions = NULL; 780 static sal_Int32 nRefCount = 0; 781 static ::osl::Mutex aMutex; 782 /*-- 15.04.2004 08:42:43--------------------------------------------------- 783 784 -----------------------------------------------------------------------*/ 785 SwMailMergeConfigItem::SwMailMergeConfigItem() : 786 m_bAddressInserted(false), 787 m_bMergeDone(false), 788 m_bGreetingInserted(false), 789 m_nGreetingMoves(0), 790 m_nStartPrint(0), 791 m_nEndPrint(0), 792 m_pSourceView(0), 793 m_pTargetView(0) 794 { 795 // Global access, must be guarded (multithreading) 796 ::osl::MutexGuard aGuard( aMutex ); 797 if ( !pOptions ) 798 pOptions = new SwMailMergeConfigItem_Impl; 799 ++nRefCount; 800 m_pImpl = pOptions; 801 } 802 /*-- 15.04.2004 08:43:36--------------------------------------------------- 803 804 -----------------------------------------------------------------------*/ 805 SwMailMergeConfigItem::~SwMailMergeConfigItem() 806 { 807 // Global access, must be guarded (multithreading) 808 ::osl::MutexGuard aGuard( aMutex ); 809 if ( !--nRefCount ) 810 { 811 DELETEZ( pOptions ); 812 } 813 } 814 /*-- 06.05.2004 14:18:10--------------------------------------------------- 815 816 -----------------------------------------------------------------------*/ 817 void SwMailMergeConfigItem::Commit() 818 { 819 if(m_pImpl->IsModified()) 820 m_pImpl->Commit(); 821 } 822 /*-- 06.05.2004 12:59:50--------------------------------------------------- 823 824 -----------------------------------------------------------------------*/ 825 const ResStringArray& SwMailMergeConfigItem::GetDefaultAddressHeaders() const 826 { 827 return m_pImpl->m_AddressHeaderSA; 828 } 829 /*-- 27.04.2004 14:34:16--------------------------------------------------- 830 831 -----------------------------------------------------------------------*/ 832 void SwMailMergeConfigItem::SetAddressBlocks( 833 const Sequence< ::rtl::OUString>& rBlocks) 834 { 835 m_pImpl->SetAddressBlocks(rBlocks); 836 } 837 /*-- 27.04.2004 14:34:16--------------------------------------------------- 838 839 -----------------------------------------------------------------------*/ 840 const Sequence< ::rtl::OUString> SwMailMergeConfigItem::GetAddressBlocks() const 841 { 842 return m_pImpl->GetAddressBlocks(); 843 } 844 /*-- 11.05.2004 17:08:45--------------------------------------------------- 845 846 -----------------------------------------------------------------------*/ 847 sal_Bool SwMailMergeConfigItem::IsAddressBlock()const 848 { 849 return m_pImpl->bIsAddressBlock && IsOutputToLetter(); 850 } 851 /*-- 11.05.2004 17:08:46--------------------------------------------------- 852 853 -----------------------------------------------------------------------*/ 854 void SwMailMergeConfigItem::SetAddressBlock(sal_Bool bSet) 855 { 856 m_pImpl->bUserSettingWereOverwritten = sal_False; 857 if(m_pImpl->bIsAddressBlock != bSet) 858 { 859 m_pImpl->bIsAddressBlock = bSet; 860 m_pImpl->SetModified(); 861 } 862 } 863 864 /*-- 30.08.2005 15:09:46--------------------------------------------------- 865 866 -----------------------------------------------------------------------*/ 867 sal_Bool SwMailMergeConfigItem::IsHideEmptyParagraphs() const 868 { 869 return m_pImpl->bIsHideEmptyParagraphs; 870 } 871 /*-- 30.08.2005 15:09:47--------------------------------------------------- 872 873 -----------------------------------------------------------------------*/ 874 void SwMailMergeConfigItem::SetHideEmptyParagraphs(sal_Bool bSet) 875 { 876 if(m_pImpl->bIsHideEmptyParagraphs != bSet) 877 { 878 m_pImpl->bIsHideEmptyParagraphs = bSet; 879 m_pImpl->SetModified(); 880 } 881 } 882 /*-- 28.04.2004 13:00:02--------------------------------------------------- 883 884 -----------------------------------------------------------------------*/ 885 sal_Bool SwMailMergeConfigItem::IsIncludeCountry() const 886 { 887 return m_pImpl->bIncludeCountry; 888 } 889 /*-- 28.04.2004 13:00:02--------------------------------------------------- 890 891 -----------------------------------------------------------------------*/ 892 rtl::OUString& SwMailMergeConfigItem::GetExcludeCountry() const 893 { 894 return m_pImpl->sExcludeCountry; 895 } 896 /*-- 28.04.2004 13:00:02--------------------------------------------------- 897 898 -----------------------------------------------------------------------*/ 899 void SwMailMergeConfigItem::SetCountrySettings(sal_Bool bSet, const rtl::OUString& rCountry) 900 { 901 if(m_pImpl->sExcludeCountry != rCountry || 902 m_pImpl->bIncludeCountry != bSet) 903 { 904 m_pImpl->bIncludeCountry = bSet; 905 m_pImpl->sExcludeCountry = bSet ? rCountry : OUString(); 906 m_pImpl->SetModified(); 907 } 908 } 909 910 /*-- 28.04.2004 15:35:16--------------------------------------------------- 911 912 -----------------------------------------------------------------------*/ 913 void SwMailMergeConfigItem::SetCurrentConnection( 914 Reference< XDataSource> xSource, 915 SharedConnection xConnection, 916 Reference< XColumnsSupplier> xColumnsSupplier, 917 const SwDBData& rDBData) 918 { 919 m_pImpl->xSource = xSource ; 920 m_pImpl->xConnection = xConnection ; 921 m_pImpl->xColumnsSupplier = xColumnsSupplier; 922 m_pImpl->aDBData = rDBData; 923 m_pImpl->xResultSet = 0; 924 m_pImpl->nResultSetCursorPos = 0; 925 m_pImpl->SetModified(); 926 } 927 /*-- 28.04.2004 15:38:11--------------------------------------------------- 928 929 -----------------------------------------------------------------------*/ 930 Reference< XDataSource> SwMailMergeConfigItem::GetSource() 931 { 932 return m_pImpl->xSource; 933 } 934 /*-- 28.04.2004 15:38:11--------------------------------------------------- 935 936 -----------------------------------------------------------------------*/ 937 SharedConnection SwMailMergeConfigItem::GetConnection() 938 { 939 return m_pImpl->xConnection; 940 } 941 /*-- 28.04.2004 15:38:11--------------------------------------------------- 942 943 -----------------------------------------------------------------------*/ 944 Reference< XColumnsSupplier> SwMailMergeConfigItem::GetColumnsSupplier() 945 { 946 if(!m_pImpl->xColumnsSupplier.is() && m_pImpl->xConnection.is()) 947 { 948 m_pImpl->xColumnsSupplier = SwNewDBMgr::GetColumnSupplier(m_pImpl->xConnection, 949 m_pImpl->aDBData.sCommand, 950 m_pImpl->aDBData.nCommandType == CommandType::TABLE ? 951 SW_DB_SELECT_TABLE : SW_DB_SELECT_QUERY ); 952 } 953 return m_pImpl->xColumnsSupplier; 954 } 955 /*-- 30.04.2004 14:30:55--------------------------------------------------- 956 957 -----------------------------------------------------------------------*/ 958 const SwDBData& SwMailMergeConfigItem::GetCurrentDBData() const 959 { 960 return m_pImpl->aDBData; 961 } 962 963 /*-- 17.06.2004 13:18:47--------------------------------------------------- 964 965 -----------------------------------------------------------------------*/ 966 void SwMailMergeConfigItem::SetCurrentDBData( const SwDBData& rDBData) 967 { 968 if(m_pImpl->aDBData != rDBData) 969 { 970 m_pImpl->aDBData = rDBData; 971 m_pImpl->xConnection.clear(); 972 m_pImpl->xSource = 0; 973 m_pImpl->xColumnsSupplier = 0; 974 m_pImpl->SetModified(); 975 } 976 } 977 /*-- 29.04.2004 11:34:36--------------------------------------------------- 978 979 -----------------------------------------------------------------------*/ 980 Reference< XResultSet> SwMailMergeConfigItem::GetResultSet() const 981 { 982 if(!m_pImpl->xConnection.is() && m_pImpl->aDBData.sDataSource.getLength()) 983 { 984 m_pImpl->xConnection.reset( 985 SwNewDBMgr::GetConnection( m_pImpl->aDBData.sDataSource, m_pImpl->xSource ), 986 SharedConnection::TakeOwnership 987 ); 988 } 989 if(!m_pImpl->xResultSet.is() && m_pImpl->xConnection.is()) 990 { 991 try 992 { 993 Reference< XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() ); 994 if( xMgr.is() ) 995 { 996 Reference<XRowSet> xRowSet( 997 xMgr->createInstance(C2U("com.sun.star.sdb.RowSet")), UNO_QUERY); 998 Reference<XPropertySet> xRowProperties(xRowSet, UNO_QUERY); 999 xRowProperties->setPropertyValue(C2U("DataSourceName"), makeAny(m_pImpl->aDBData.sDataSource)); 1000 xRowProperties->setPropertyValue(C2U("Command"), makeAny(m_pImpl->aDBData.sCommand)); 1001 xRowProperties->setPropertyValue(C2U("CommandType"), makeAny(m_pImpl->aDBData.nCommandType)); 1002 xRowProperties->setPropertyValue(C2U("FetchSize"), makeAny((sal_Int32)10)); 1003 xRowProperties->setPropertyValue(C2U("ActiveConnection"), makeAny(m_pImpl->xConnection.getTyped())); 1004 try 1005 { 1006 xRowProperties->setPropertyValue(C2U("ApplyFilter"), makeAny(m_pImpl->sFilter.getLength()>0)); 1007 xRowProperties->setPropertyValue(C2U("Filter"), makeAny(m_pImpl->sFilter)); 1008 } 1009 catch(Exception&) 1010 { 1011 DBG_ERROR("exception caught in xResultSet->SetFilter()"); 1012 } 1013 xRowSet->execute(); 1014 m_pImpl->xResultSet = xRowSet.get(); 1015 m_pImpl->xResultSet->first(); 1016 m_pImpl->nResultSetCursorPos = 1; 1017 } 1018 } 1019 catch(Exception& ) 1020 { 1021 DBG_ERROR("exception caught in: SwMailMergeConfigItem::GetResultSet() "); 1022 } 1023 } 1024 return m_pImpl->xResultSet; 1025 } 1026 /*-- 13.08.2004 11:49:46--------------------------------------------------- 1027 1028 -----------------------------------------------------------------------*/ 1029 void SwMailMergeConfigItem::DisposeResultSet() 1030 { 1031 m_pImpl->xConnection.clear(); 1032 if(m_pImpl->xResultSet.is()) 1033 { 1034 ::comphelper::disposeComponent( m_pImpl->xResultSet ); 1035 } 1036 } 1037 /*-- 14.05.2004 15:07:55--------------------------------------------------- 1038 1039 -----------------------------------------------------------------------*/ 1040 ::rtl::OUString& SwMailMergeConfigItem::GetFilter() const 1041 { 1042 return m_pImpl->sFilter; 1043 } 1044 /*-- 14.05.2004 15:07:55--------------------------------------------------- 1045 1046 -----------------------------------------------------------------------*/ 1047 void SwMailMergeConfigItem::SetFilter(::rtl::OUString& rFilter) 1048 { 1049 if(m_pImpl->sFilter != rFilter) 1050 { 1051 m_pImpl->sFilter = rFilter; 1052 m_pImpl->SetModified(); 1053 Reference<XPropertySet> xRowProperties(m_pImpl->xResultSet, UNO_QUERY); 1054 if(xRowProperties.is()) 1055 { 1056 try 1057 { 1058 xRowProperties->setPropertyValue(C2U("ApplyFilter"), makeAny(m_pImpl->sFilter.getLength()>0)); 1059 xRowProperties->setPropertyValue(C2U("Filter"), makeAny(m_pImpl->sFilter)); 1060 uno::Reference<XRowSet> xRowSet( m_pImpl->xResultSet, UNO_QUERY_THROW ); 1061 xRowSet->execute(); 1062 } 1063 catch(Exception&) 1064 { 1065 DBG_ERROR("exception caught in SwMailMergeConfigItem::SetFilter()"); 1066 } 1067 } 1068 } 1069 } 1070 /*-- 29.04.2004 11:55:38--------------------------------------------------- 1071 1072 -----------------------------------------------------------------------*/ 1073 sal_Int32 SwMailMergeConfigItem::MoveResultSet(sal_Int32 nTarget) 1074 { 1075 if(!m_pImpl->xResultSet.is()) 1076 GetResultSet(); 1077 if(m_pImpl->xResultSet.is()) 1078 { 1079 try 1080 { 1081 //no action if the resultset is already at the right position 1082 if(m_pImpl->xResultSet->getRow() != nTarget) 1083 { 1084 if(nTarget > 0) 1085 { 1086 sal_Bool bMoved = m_pImpl->xResultSet->absolute(nTarget); 1087 if(!bMoved) 1088 { 1089 if(nTarget > 1) 1090 m_pImpl->xResultSet->last(); 1091 else if(nTarget == 1) 1092 m_pImpl->xResultSet->first(); 1093 } 1094 } 1095 else if(nTarget == -1) 1096 m_pImpl->xResultSet->last(); 1097 m_pImpl->nResultSetCursorPos = m_pImpl->xResultSet->getRow(); 1098 } 1099 } 1100 catch(Exception&) 1101 { 1102 } 1103 } 1104 return m_pImpl->nResultSetCursorPos; 1105 } 1106 1107 /*-- 27.05.2004 13:56:18--------------------------------------------------- 1108 1109 -----------------------------------------------------------------------*/ 1110 bool SwMailMergeConfigItem::IsResultSetFirstLast(bool& bIsFirst, bool& bIsLast) 1111 { 1112 bool bRet = false; 1113 if(!m_pImpl->xResultSet.is()) 1114 GetResultSet(); 1115 if(m_pImpl->xResultSet.is()) 1116 { 1117 try 1118 { 1119 bIsFirst = m_pImpl->xResultSet->isFirst(); 1120 bIsLast = m_pImpl->xResultSet->isLast(); 1121 bRet = true; 1122 } 1123 catch(Exception&) 1124 { 1125 } 1126 } 1127 return bRet; 1128 } 1129 /*-- 29.04.2004 11:55:38--------------------------------------------------- 1130 1131 -----------------------------------------------------------------------*/ 1132 sal_Int32 SwMailMergeConfigItem::GetResultSetPosition() const 1133 { 1134 return m_pImpl->nResultSetCursorPos; 1135 } 1136 /*-- 27.05.2004 14:49:53--------------------------------------------------- 1137 1138 -----------------------------------------------------------------------*/ 1139 bool SwMailMergeConfigItem::IsRecordExcluded(sal_Int32 nRecord) 1140 { 1141 bool bRet = false; 1142 if(nRecord > 0 && nRecord < m_aSelection.getLength()) 1143 { 1144 sal_Int32 nTemp = 0; 1145 m_aSelection[nRecord - 1] >>= nTemp; 1146 bRet = nTemp < 1; 1147 } 1148 return bRet; 1149 } 1150 /*-- 27.05.2004 14:49:53--------------------------------------------------- 1151 1152 -----------------------------------------------------------------------*/ 1153 void SwMailMergeConfigItem::ExcludeRecord(sal_Int32 nRecord, bool bExclude) 1154 { 1155 //nRecord is based on 1 1156 //the selection array contains Anys for all records 1157 //excluded records contain a '-1' 1158 if(!m_aSelection.getLength() || nRecord > m_aSelection.getLength()) 1159 { 1160 if(bExclude) 1161 { 1162 //if no selection array is available we need to create one containing the 1163 //entries for all available records 1164 if(!m_pImpl->xResultSet.is()) 1165 GetResultSet(); 1166 if(m_pImpl->xResultSet.is()) 1167 { 1168 m_pImpl->xResultSet->last(); 1169 sal_Int32 nEnd = m_pImpl->xResultSet->getRow(); 1170 sal_Int32 nStart = m_aSelection.getLength(); 1171 m_aSelection.realloc(nEnd); 1172 Any* pSelection = m_aSelection.getArray(); 1173 for(sal_Int32 nIndex = nStart; nIndex < nEnd; ++nIndex) 1174 { 1175 if((nRecord - 1) != nIndex) 1176 pSelection[nIndex] <<= nIndex + 1; 1177 else 1178 pSelection[nIndex] <<= (sal_Int32) -1; 1179 } 1180 } 1181 } 1182 } 1183 else 1184 { 1185 if(nRecord > 0 && m_aSelection.getLength() > nRecord) 1186 { 1187 m_aSelection[nRecord - 1] <<= bExclude ? -1 : nRecord; 1188 } 1189 } 1190 } 1191 /*-- 27.05.2004 15:08:35--------------------------------------------------- 1192 1193 -----------------------------------------------------------------------*/ 1194 Sequence< Any > SwMailMergeConfigItem::GetSelection() const 1195 { 1196 Sequence< Any > aRet(m_aSelection.getLength()); 1197 sal_Int32 nRetIndex = 0; 1198 sal_Int32 nRet; 1199 for(sal_Int32 nIndex = 0; nIndex < m_aSelection.getLength(); ++nIndex) 1200 { 1201 m_aSelection[nIndex] >>= nRet; 1202 if(nRet > 0) 1203 { 1204 aRet[nRetIndex] <<= nRet; 1205 ++nRetIndex; 1206 } 1207 } 1208 aRet.realloc(nRetIndex); 1209 return aRet; 1210 } 1211 /*-- 16.06.2004 15:15:56--------------------------------------------------- 1212 1213 -----------------------------------------------------------------------*/ 1214 const uno::Sequence< ::rtl::OUString>& 1215 SwMailMergeConfigItem::GetSavedDocuments() const 1216 { 1217 return m_pImpl->aSavedDocuments; 1218 } 1219 /*-- 16.06.2004 15:15:56--------------------------------------------------- 1220 1221 -----------------------------------------------------------------------*/ 1222 void SwMailMergeConfigItem::AddSavedDocument(::rtl::OUString rName) 1223 { 1224 const ::rtl::OUString* pDocs = m_pImpl->aSavedDocuments.getConstArray(); 1225 bool bFound = false; 1226 for(sal_Int32 nDoc = 0; nDoc < m_pImpl->aSavedDocuments.getLength(); ++nDoc) 1227 { 1228 if(pDocs[nDoc] == rName) 1229 { 1230 bFound = true; 1231 break; 1232 } 1233 } 1234 if(!bFound) 1235 { 1236 m_pImpl->aSavedDocuments.realloc(m_pImpl->aSavedDocuments.getLength() + 1); 1237 m_pImpl->aSavedDocuments[m_pImpl->aSavedDocuments.getLength() - 1] = rName; 1238 } 1239 } 1240 /*-- 28.04.2004 16:15:16--------------------------------------------------- 1241 1242 -----------------------------------------------------------------------*/ 1243 sal_Bool SwMailMergeConfigItem::IsOutputToLetter()const 1244 { 1245 return m_pImpl->bIsOutputToLetter || !IsMailAvailable(); 1246 } 1247 /*-- 28.04.2004 16:15:16--------------------------------------------------- 1248 1249 -----------------------------------------------------------------------*/ 1250 void SwMailMergeConfigItem::SetOutputToLetter(sal_Bool bSet) 1251 { 1252 if(m_pImpl->bIsOutputToLetter != bSet) 1253 { 1254 m_pImpl->bIsOutputToLetter = bSet; 1255 m_pImpl->SetModified(); 1256 } 1257 } 1258 /*-- 30.04.2004 10:51:10--------------------------------------------------- 1259 1260 -----------------------------------------------------------------------*/ 1261 sal_Bool SwMailMergeConfigItem::IsIndividualGreeting(sal_Bool bInEMail) const 1262 { 1263 return bInEMail ? 1264 m_pImpl->bIsIndividualGreetingLineInMail : 1265 m_pImpl->bIsIndividualGreetingLine; 1266 } 1267 /*-- 30.04.2004 10:51:10--------------------------------------------------- 1268 1269 -----------------------------------------------------------------------*/ 1270 void SwMailMergeConfigItem::SetIndividualGreeting( 1271 sal_Bool bSet, sal_Bool bInEMail) 1272 { 1273 if(bInEMail) 1274 { 1275 if(m_pImpl->bIsIndividualGreetingLineInMail != bSet) 1276 { 1277 m_pImpl->bIsIndividualGreetingLineInMail = bSet; 1278 m_pImpl->SetModified(); 1279 } 1280 } 1281 else 1282 { 1283 if(m_pImpl->bIsIndividualGreetingLine != bSet) 1284 { 1285 m_pImpl->bIsIndividualGreetingLine = bSet; 1286 m_pImpl->SetModified(); 1287 } 1288 } 1289 } 1290 /*-- 30.04.2004 10:51:10--------------------------------------------------- 1291 1292 -----------------------------------------------------------------------*/ 1293 sal_Bool SwMailMergeConfigItem::IsGreetingLine(sal_Bool bInEMail) const 1294 { 1295 return bInEMail ? m_pImpl->bIsGreetingLineInMail : m_pImpl->bIsGreetingLine; 1296 } 1297 /*-- 30.04.2004 10:51:10--------------------------------------------------- 1298 1299 -----------------------------------------------------------------------*/ 1300 void SwMailMergeConfigItem::SetGreetingLine(sal_Bool bSet, sal_Bool bInEMail) 1301 { 1302 m_pImpl->bUserSettingWereOverwritten = sal_False; 1303 if(bInEMail) 1304 { 1305 if(m_pImpl->bIsGreetingLineInMail != bSet) 1306 { 1307 m_pImpl->bIsGreetingLineInMail = bSet; 1308 m_pImpl->SetModified(); 1309 } 1310 } 1311 else 1312 { 1313 if(m_pImpl->bIsGreetingLine != bSet) 1314 { 1315 m_pImpl->bIsGreetingLine = bSet; 1316 m_pImpl->SetModified(); 1317 } 1318 } 1319 } 1320 /*-- 30.04.2004 11:04:52--------------------------------------------------- 1321 1322 -----------------------------------------------------------------------*/ 1323 const Sequence< ::rtl::OUString> SwMailMergeConfigItem::GetGreetings( 1324 Gender eType ) const 1325 { 1326 return m_pImpl->GetGreetings(eType); 1327 } 1328 /*-- 30.04.2004 11:04:52--------------------------------------------------- 1329 1330 -----------------------------------------------------------------------*/ 1331 void SwMailMergeConfigItem::SetGreetings( 1332 Gender eType, const Sequence< ::rtl::OUString>& rSetGreetings) 1333 { 1334 m_pImpl->SetGreetings( eType, rSetGreetings); 1335 } 1336 1337 /*-- 11.05.2004 13:10:54--------------------------------------------------- 1338 1339 -----------------------------------------------------------------------*/ 1340 sal_Int32 SwMailMergeConfigItem::GetCurrentGreeting( 1341 SwMailMergeConfigItem::Gender eType) const 1342 { 1343 return m_pImpl->GetCurrentGreeting(eType); 1344 } 1345 /*-- 11.05.2004 13:10:55--------------------------------------------------- 1346 1347 -----------------------------------------------------------------------*/ 1348 void SwMailMergeConfigItem::SetCurrentGreeting(Gender eType, sal_Int32 nIndex) 1349 { 1350 m_pImpl->SetCurrentGreeting(eType, nIndex); 1351 } 1352 /*-- 12.05.2004 12:29:59--------------------------------------------------- 1353 1354 -----------------------------------------------------------------------*/ 1355 const ::rtl::OUString& SwMailMergeConfigItem::GetFemaleGenderValue() const 1356 { 1357 return m_pImpl->sFemaleGenderValue; 1358 } 1359 /*-- 12.05.2004 12:29:59--------------------------------------------------- 1360 1361 -----------------------------------------------------------------------*/ 1362 void SwMailMergeConfigItem::SetFemaleGenderValue(const ::rtl::OUString rValue) 1363 { 1364 if( m_pImpl->sFemaleGenderValue != rValue ) 1365 { 1366 m_pImpl->sFemaleGenderValue = rValue; 1367 m_pImpl->SetModified(); 1368 } 1369 } 1370 1371 /*-- 30.04.2004 13:25:41--------------------------------------------------- 1372 1373 -----------------------------------------------------------------------*/ 1374 Sequence< ::rtl::OUString> SwMailMergeConfigItem::GetColumnAssignment( 1375 const SwDBData& rDBData ) const 1376 { 1377 Sequence< ::rtl::OUString> aRet; 1378 ::std::vector<DBAddressDataAssignment>::iterator aAssignIter; 1379 for(aAssignIter = m_pImpl->aAddressDataAssignments.begin(); 1380 aAssignIter != m_pImpl->aAddressDataAssignments.end(); aAssignIter++) 1381 { 1382 if(aAssignIter->aDBData == rDBData) 1383 { 1384 aRet = aAssignIter->aDBColumnAssignments; 1385 break; 1386 } 1387 } 1388 return aRet; 1389 } 1390 /*-- 21.05.2004 12:31:31--------------------------------------------------- 1391 returns the name that is assigned as e-mail column of the current data base 1392 -----------------------------------------------------------------------*/ 1393 ::rtl::OUString SwMailMergeConfigItem::GetAssignedColumn(sal_uInt32 nColumn) const 1394 { 1395 ::rtl::OUString sRet; 1396 Sequence< ::rtl::OUString> aAssignment = GetColumnAssignment( m_pImpl->aDBData ); 1397 if(aAssignment.getLength() > sal::static_int_cast< sal_Int32, sal_uInt32>(nColumn) && aAssignment[nColumn].getLength()) 1398 sRet = aAssignment[nColumn]; 1399 else if(nColumn < m_pImpl->m_AddressHeaderSA.Count()) 1400 sRet = m_pImpl->m_AddressHeaderSA.GetString(nColumn); 1401 return sRet; 1402 } 1403 /*-- 30.04.2004 13:25:41--------------------------------------------------- 1404 1405 -----------------------------------------------------------------------*/ 1406 void SwMailMergeConfigItem::SetColumnAssignment( const SwDBData& rDBData, 1407 const Sequence< ::rtl::OUString>& rList) 1408 { 1409 ::std::vector<DBAddressDataAssignment>::iterator aAssignIter; 1410 sal_Bool bFound = sal_False; 1411 for(aAssignIter = m_pImpl->aAddressDataAssignments.begin(); 1412 aAssignIter != m_pImpl->aAddressDataAssignments.end(); aAssignIter++) 1413 { 1414 if(aAssignIter->aDBData == rDBData) 1415 { 1416 if(aAssignIter->aDBColumnAssignments != rList) 1417 { 1418 aAssignIter->aDBColumnAssignments = rList; 1419 aAssignIter->bColumnAssignmentsChanged = true; 1420 } 1421 bFound = sal_True; 1422 break; 1423 } 1424 } 1425 if(!bFound) 1426 { 1427 DBAddressDataAssignment aAssignment; 1428 aAssignment.aDBData = rDBData; 1429 aAssignment.aDBColumnAssignments = rList; 1430 aAssignment.bColumnAssignmentsChanged = true; 1431 m_pImpl->aAddressDataAssignments.push_back(aAssignment); 1432 } 1433 m_pImpl->SetModified(); 1434 } 1435 1436 /*-- 07.09.2005 11:50:27--------------------------------------------------- 1437 1438 -----------------------------------------------------------------------*/ 1439 bool SwMailMergeConfigItem::IsAddressFieldsAssigned() const 1440 { 1441 bool bResult = true; 1442 Reference< XResultSet> xResultSet = GetResultSet(); 1443 uno::Reference< XColumnsSupplier > xColsSupp( xResultSet, UNO_QUERY ); 1444 if(!xColsSupp.is()) 1445 return false; 1446 uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns(); 1447 1448 const ResStringArray& rHeaders = GetDefaultAddressHeaders(); 1449 Sequence< ::rtl::OUString> aAssignment = 1450 GetColumnAssignment( GetCurrentDBData() ); 1451 const ::rtl::OUString* pAssignment = aAssignment.getConstArray(); 1452 const Sequence< ::rtl::OUString> aBlocks = GetAddressBlocks(); 1453 1454 if(aBlocks.getLength() <= m_pImpl->GetCurrentAddressBlockIndex()) 1455 return false; 1456 SwAddressIterator aIter(aBlocks[m_pImpl->GetCurrentAddressBlockIndex()]); 1457 while(aIter.HasMore()) 1458 { 1459 SwMergeAddressItem aItem = aIter.Next(); 1460 if(aItem.bIsColumn) 1461 { 1462 String sConvertedColumn = aItem.sText; 1463 for(sal_uInt16 nColumn = 0; 1464 nColumn < rHeaders.Count() && nColumn < aAssignment.getLength(); 1465 ++nColumn) 1466 { 1467 if(rHeaders.GetString(nColumn) == aItem.sText && 1468 pAssignment[nColumn].getLength()) 1469 { 1470 sConvertedColumn = pAssignment[nColumn]; 1471 break; 1472 } 1473 } 1474 //find out if the column exists in the data base 1475 if(!xCols->hasByName(sConvertedColumn)) 1476 { 1477 bResult = false; 1478 break; 1479 } 1480 } 1481 } 1482 return bResult; 1483 } 1484 /*-- 07.09.2005 11:50:27--------------------------------------------------- 1485 1486 -----------------------------------------------------------------------*/ 1487 bool SwMailMergeConfigItem::IsGreetingFieldsAssigned() const 1488 { 1489 bool bResult = true; 1490 1491 if(!IsIndividualGreeting(sal_False)) 1492 return true; 1493 1494 Reference< XResultSet> xResultSet = GetResultSet(); 1495 uno::Reference< XColumnsSupplier > xColsSupp( xResultSet, UNO_QUERY ); 1496 if(!xColsSupp.is()) 1497 return false; 1498 const ResStringArray& rHeaders = GetDefaultAddressHeaders(); 1499 uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns(); 1500 1501 Sequence< ::rtl::OUString> aAssignment = 1502 GetColumnAssignment( GetCurrentDBData() ); 1503 const ::rtl::OUString* pAssignment = aAssignment.getConstArray(); 1504 1505 const Sequence< ::rtl::OUString> rFemaleEntries = GetGreetings(SwMailMergeConfigItem::FEMALE); 1506 sal_Int32 nCurrentFemale = GetCurrentGreeting(SwMailMergeConfigItem::FEMALE); 1507 const Sequence< ::rtl::OUString> rMaleEntries = GetGreetings(SwMailMergeConfigItem::MALE); 1508 sal_Int32 nCurrentMale = GetCurrentGreeting(SwMailMergeConfigItem::MALE); 1509 ::rtl::OUString sMale, sFemale; 1510 if(rFemaleEntries.getLength() > nCurrentFemale) 1511 sFemale = rFemaleEntries[nCurrentFemale]; 1512 if(rMaleEntries.getLength() > nCurrentMale) 1513 sMale = rMaleEntries[nCurrentMale]; 1514 1515 ::rtl::OUString sAddress( sFemale ); 1516 sAddress += sMale; 1517 SwAddressIterator aIter(sAddress); 1518 while(aIter.HasMore()) 1519 { 1520 SwMergeAddressItem aItem = aIter.Next(); 1521 if(aItem.bIsColumn) 1522 { 1523 String sConvertedColumn = aItem.sText; 1524 for(sal_uInt16 nColumn = 0; 1525 nColumn < rHeaders.Count() && nColumn < aAssignment.getLength(); 1526 ++nColumn) 1527 { 1528 if(rHeaders.GetString(nColumn) == aItem.sText && 1529 pAssignment[nColumn].getLength()) 1530 { 1531 sConvertedColumn = pAssignment[nColumn]; 1532 break; 1533 } 1534 } 1535 //find out if the column exists in the data base 1536 if(!xCols->hasByName(sConvertedColumn)) 1537 { 1538 bResult = false; 1539 break; 1540 } 1541 } 1542 } 1543 return bResult; 1544 } 1545 /*-- 05.05.2004 16:10:07--------------------------------------------------- 1546 1547 -----------------------------------------------------------------------*/ 1548 ::rtl::OUString SwMailMergeConfigItem::GetMailDisplayName() const 1549 { 1550 return m_pImpl->sMailDisplayName; 1551 } 1552 /*-- 05.05.2004 16:10:08--------------------------------------------------- 1553 1554 -----------------------------------------------------------------------*/ 1555 void SwMailMergeConfigItem::SetMailDisplayName(const ::rtl::OUString& rName) 1556 { 1557 if(m_pImpl->sMailDisplayName != rName) 1558 { 1559 m_pImpl->sMailDisplayName = rName; 1560 m_pImpl->SetModified(); 1561 } 1562 } 1563 /*-- 05.05.2004 16:10:09--------------------------------------------------- 1564 1565 -----------------------------------------------------------------------*/ 1566 ::rtl::OUString SwMailMergeConfigItem::GetMailAddress() const 1567 { 1568 return m_pImpl->sMailAddress; 1569 } 1570 /*-- 05.05.2004 16:10:09--------------------------------------------------- 1571 1572 -----------------------------------------------------------------------*/ 1573 void SwMailMergeConfigItem::SetMailAddress(const ::rtl::OUString& rAddress) 1574 { 1575 if(m_pImpl->sMailAddress != rAddress ) 1576 { 1577 m_pImpl->sMailAddress = rAddress; 1578 m_pImpl->SetModified(); 1579 } 1580 } 1581 1582 /*-- 07.05.2004 12:40:59--------------------------------------------------- 1583 1584 -----------------------------------------------------------------------*/ 1585 sal_Bool SwMailMergeConfigItem::IsMailReplyTo() const 1586 { 1587 return m_pImpl->bIsMailReplyTo; 1588 } 1589 /*-- 07.05.2004 12:40:59--------------------------------------------------- 1590 1591 -----------------------------------------------------------------------*/ 1592 void SwMailMergeConfigItem::SetMailReplyTo(sal_Bool bSet) 1593 { 1594 if(m_pImpl->bIsMailReplyTo != bSet) 1595 { 1596 m_pImpl->bIsMailReplyTo = bSet; 1597 m_pImpl->SetModified(); 1598 } 1599 } 1600 /*-- 05.05.2004 16:10:09--------------------------------------------------- 1601 1602 -----------------------------------------------------------------------*/ 1603 ::rtl::OUString SwMailMergeConfigItem::GetMailReplyTo() const 1604 { 1605 return m_pImpl->sMailReplyTo; 1606 } 1607 /*-- 05.05.2004 16:10:09--------------------------------------------------- 1608 1609 -----------------------------------------------------------------------*/ 1610 void SwMailMergeConfigItem::SetMailReplyTo(const ::rtl::OUString& rReplyTo) 1611 { 1612 if(m_pImpl->sMailReplyTo != rReplyTo) 1613 { 1614 m_pImpl->sMailReplyTo = rReplyTo; 1615 m_pImpl->SetModified(); 1616 } 1617 } 1618 /*-- 05.05.2004 16:10:09--------------------------------------------------- 1619 1620 -----------------------------------------------------------------------*/ 1621 ::rtl::OUString SwMailMergeConfigItem::GetMailServer() const 1622 { 1623 return m_pImpl->sMailServer; 1624 } 1625 /*-- 05.05.2004 16:10:10--------------------------------------------------- 1626 1627 -----------------------------------------------------------------------*/ 1628 void SwMailMergeConfigItem::SetMailServer(const ::rtl::OUString& rAddress) 1629 { 1630 if(m_pImpl->sMailServer != rAddress) 1631 { 1632 m_pImpl->sMailServer = rAddress; 1633 m_pImpl->SetModified(); 1634 } 1635 } 1636 /*-- 05.05.2004 16:10:10--------------------------------------------------- 1637 1638 -----------------------------------------------------------------------*/ 1639 sal_Int16 SwMailMergeConfigItem::GetMailPort() const 1640 { 1641 return m_pImpl->bIsDefaultPort ? 1642 (m_pImpl->bIsSecureConnection ? SECURE_PORT : DEFAULT_PORT) : 1643 m_pImpl->nMailPort; 1644 } 1645 /*-- 05.05.2004 16:10:10--------------------------------------------------- 1646 1647 -----------------------------------------------------------------------*/ 1648 void SwMailMergeConfigItem::SetMailPort(sal_Int16 nSet) 1649 { 1650 if(m_pImpl->nMailPort != nSet || m_pImpl->bIsDefaultPort) 1651 { 1652 m_pImpl->nMailPort = nSet; 1653 m_pImpl->bIsDefaultPort = sal_False; 1654 m_pImpl->SetModified(); 1655 } 1656 } 1657 /*-- 05.05.2004 16:10:11--------------------------------------------------- 1658 1659 -----------------------------------------------------------------------*/ 1660 sal_Bool SwMailMergeConfigItem::IsSecureConnection() const 1661 { 1662 return m_pImpl->bIsSecureConnection; 1663 } 1664 /*-- 05.05.2004 16:10:12--------------------------------------------------- 1665 1666 -----------------------------------------------------------------------*/ 1667 void SwMailMergeConfigItem::SetSecureConnection(sal_Bool bSet) 1668 { 1669 if(m_pImpl->bIsSecureConnection != bSet) 1670 { 1671 m_pImpl->bIsSecureConnection = bSet; 1672 m_pImpl->SetModified(); 1673 } 1674 } 1675 /*-- 05.05.2004 16:10:12--------------------------------------------------- 1676 1677 -----------------------------------------------------------------------*/ 1678 sal_Bool SwMailMergeConfigItem::IsAuthentication() const 1679 { 1680 return m_pImpl->bIsAuthentication; 1681 } 1682 /*-- 05.05.2004 16:10:13--------------------------------------------------- 1683 1684 -----------------------------------------------------------------------*/ 1685 void SwMailMergeConfigItem::SetAuthentication(sal_Bool bSet) 1686 { 1687 if(m_pImpl->bIsAuthentication != bSet) 1688 { 1689 m_pImpl->bIsAuthentication = bSet; 1690 m_pImpl->SetModified(); 1691 } 1692 } 1693 /*-- 05.05.2004 16:10:13--------------------------------------------------- 1694 1695 -----------------------------------------------------------------------*/ 1696 ::rtl::OUString SwMailMergeConfigItem::GetMailUserName() const 1697 { 1698 return m_pImpl->sMailUserName; 1699 } 1700 /*-- 05.05.2004 16:10:13--------------------------------------------------- 1701 1702 -----------------------------------------------------------------------*/ 1703 void SwMailMergeConfigItem::SetMailUserName(const ::rtl::OUString& rName) 1704 { 1705 if(m_pImpl->sMailUserName != rName) 1706 { 1707 m_pImpl->sMailUserName = rName; 1708 m_pImpl->SetModified(); 1709 } 1710 } 1711 /*-- 05.05.2004 16:10:14--------------------------------------------------- 1712 1713 -----------------------------------------------------------------------*/ 1714 ::rtl::OUString SwMailMergeConfigItem::GetMailPassword() const 1715 { 1716 return m_pImpl->sMailPassword; 1717 } 1718 /*-- 05.05.2004 16:10:14--------------------------------------------------- 1719 1720 -----------------------------------------------------------------------*/ 1721 void SwMailMergeConfigItem::SetMailPassword(const ::rtl::OUString& rPassword) 1722 { 1723 if(m_pImpl->sMailPassword != rPassword) 1724 { 1725 m_pImpl->sMailPassword = rPassword; 1726 m_pImpl->SetModified(); 1727 } 1728 } 1729 /*-- 19.08.2004 14:44:57--------------------------------------------------- 1730 1731 -----------------------------------------------------------------------*/ 1732 sal_Bool SwMailMergeConfigItem::IsSMTPAfterPOP() const 1733 { 1734 return m_pImpl->bIsSMPTAfterPOP; 1735 } 1736 /*-- 19.08.2004 14:44:57--------------------------------------------------- 1737 1738 -----------------------------------------------------------------------*/ 1739 void SwMailMergeConfigItem::SetSMTPAfterPOP(sal_Bool bSet) 1740 { 1741 if( m_pImpl->bIsSMPTAfterPOP != bSet) 1742 { 1743 m_pImpl->bIsSMPTAfterPOP = bSet; 1744 m_pImpl->SetModified(); 1745 } 1746 } 1747 /*-- 19.08.2004 14:44:57--------------------------------------------------- 1748 1749 -----------------------------------------------------------------------*/ 1750 ::rtl::OUString SwMailMergeConfigItem::GetInServerName() const 1751 { 1752 return m_pImpl->sInServerName; 1753 } 1754 /*-- 19.08.2004 14:44:57--------------------------------------------------- 1755 1756 -----------------------------------------------------------------------*/ 1757 void SwMailMergeConfigItem::SetInServerName(const ::rtl::OUString& rServer) 1758 { 1759 if(m_pImpl->sInServerName != rServer) 1760 { 1761 m_pImpl->sInServerName = rServer; 1762 m_pImpl->SetModified(); 1763 } 1764 } 1765 /*-- 19.08.2004 14:44:58--------------------------------------------------- 1766 1767 -----------------------------------------------------------------------*/ 1768 sal_Int16 SwMailMergeConfigItem::GetInServerPort() const 1769 { 1770 return m_pImpl->nInServerPort; 1771 } 1772 /*-- 19.08.2004 14:44:58--------------------------------------------------- 1773 1774 -----------------------------------------------------------------------*/ 1775 void SwMailMergeConfigItem::SetInServerPort(sal_Int16 nSet) 1776 { 1777 if( m_pImpl->nInServerPort != nSet) 1778 { 1779 m_pImpl->nInServerPort = nSet; 1780 m_pImpl->SetModified(); 1781 } 1782 } 1783 /*-- 20.08.2004 08:52:48--------------------------------------------------- 1784 1785 -----------------------------------------------------------------------*/ 1786 sal_Bool SwMailMergeConfigItem::IsInServerPOP() const 1787 { 1788 return m_pImpl->bInServerPOP; 1789 } 1790 /*-- 20.08.2004 08:52:49--------------------------------------------------- 1791 1792 -----------------------------------------------------------------------*/ 1793 void SwMailMergeConfigItem::SetInServerPOP(sal_Bool bSet) 1794 { 1795 if( m_pImpl->bInServerPOP != bSet) 1796 { 1797 m_pImpl->bInServerPOP = bSet; 1798 m_pImpl->SetModified(); 1799 } 1800 } 1801 /*-- 19.08.2004 14:44:58--------------------------------------------------- 1802 1803 -----------------------------------------------------------------------*/ 1804 ::rtl::OUString SwMailMergeConfigItem::GetInServerUserName() const 1805 { 1806 return m_pImpl->sInServerUserName; 1807 } 1808 /*-- 19.08.2004 14:44:58--------------------------------------------------- 1809 1810 -----------------------------------------------------------------------*/ 1811 void SwMailMergeConfigItem::SetInServerUserName(const ::rtl::OUString& rName) 1812 { 1813 if( m_pImpl->sInServerUserName != rName) 1814 { 1815 m_pImpl->sInServerUserName = rName; 1816 m_pImpl->SetModified(); 1817 } 1818 } 1819 /*-- 19.08.2004 14:44:59--------------------------------------------------- 1820 1821 -----------------------------------------------------------------------*/ 1822 ::rtl::OUString SwMailMergeConfigItem::GetInServerPassword() const 1823 { 1824 return m_pImpl->sInServerPassword; 1825 } 1826 /*-- 19.08.2004 14:45:00--------------------------------------------------- 1827 1828 -----------------------------------------------------------------------*/ 1829 void SwMailMergeConfigItem::SetInServerPassword(const ::rtl::OUString& rPassword) 1830 { 1831 if(m_pImpl->sInServerPassword != rPassword) 1832 { 1833 m_pImpl->sInServerPassword = rPassword; 1834 m_pImpl->SetModified(); 1835 } 1836 } 1837 1838 /*-- 02.09.2004 14:43:27--------------------------------------------------- 1839 1840 -----------------------------------------------------------------------*/ 1841 void SwMailMergeConfigItem::DocumentReloaded() 1842 { 1843 m_bMergeDone = false; 1844 m_bGreetingInserted = false; 1845 m_bAddressInserted = false; 1846 m_rAddressBlockFrame = ::rtl::OUString(); 1847 } 1848 /*-- 16.06.2004 12:24:18--------------------------------------------------- 1849 1850 -----------------------------------------------------------------------*/ 1851 bool SwMailMergeConfigItem::IsMailAvailable() const 1852 { 1853 return m_pImpl->bIsEMailSupported; 1854 } 1855 /*-- 21.05.2004 12:20:05--------------------------------------------------- 1856 1857 -----------------------------------------------------------------------*/ 1858 void SwMailMergeConfigItem::AddMergedDocument(SwDocMergeInfo& rInfo) 1859 { 1860 m_pImpl->aMergeInfos.push_back(rInfo); 1861 } 1862 /*-- 21.05.2004 12:20:05--------------------------------------------------- 1863 1864 -----------------------------------------------------------------------*/ 1865 SwDocMergeInfo& SwMailMergeConfigItem::GetDocumentMergeInfo(sal_uInt32 nDocument) 1866 { 1867 DBG_ASSERT(m_pImpl->aMergeInfos.size() > nDocument,"invalid document index"); 1868 return m_pImpl->aMergeInfos[nDocument]; 1869 } 1870 /*-- 14.06.2004 11:46:26--------------------------------------------------- 1871 1872 -----------------------------------------------------------------------*/ 1873 sal_uInt32 SwMailMergeConfigItem::GetMergedDocumentCount() const 1874 { 1875 return m_pImpl->aMergeInfos.size(); 1876 } 1877 /*-- 11.06.2004 10:38:39--------------------------------------------------- 1878 1879 -----------------------------------------------------------------------*/ 1880 SwView* lcl_ExistsView(SwView* pView) 1881 { 1882 const TypeId aType(TYPE(SwView)); 1883 SfxViewShell* pViewShell = SfxViewShell::GetFirst( &aType, sal_False ); 1884 while(pViewShell) 1885 { 1886 if(pViewShell == pView) 1887 return pView; 1888 1889 pViewShell = SfxViewShell::GetNext( *pViewShell, &aType, sal_False ); 1890 } 1891 return 0; 1892 } 1893 /*-- 16.06.2004 15:02:35--------------------------------------------------- 1894 1895 -----------------------------------------------------------------------*/ 1896 SwView* SwMailMergeConfigItem::GetTargetView() 1897 { 1898 //make sure that the pointer is really valid - the document may have been closed manually 1899 if(m_pTargetView) 1900 { 1901 m_pTargetView = lcl_ExistsView(m_pTargetView); 1902 } 1903 return m_pTargetView; 1904 } 1905 /*-- 02.09.2004 17:04:11--------------------------------------------------- 1906 1907 -----------------------------------------------------------------------*/ 1908 void SwMailMergeConfigItem::SetTargetView(SwView* pView) 1909 { 1910 m_pTargetView = pView; 1911 //reset the document merge counter 1912 if(!m_pTargetView) 1913 { 1914 m_pImpl->aMergeInfos.clear(); 1915 } 1916 } 1917 /*-- 16.06.2004 15:02:35--------------------------------------------------- 1918 1919 -----------------------------------------------------------------------*/ 1920 SwView* SwMailMergeConfigItem::GetSourceView() 1921 { 1922 m_pSourceView = lcl_ExistsView(m_pSourceView); 1923 return m_pSourceView; 1924 } 1925 1926 /*-- 04.11.2004 19:53 --------------------------------------------------- 1927 -----------------------------------------------------------------------*/ 1928 void SwMailMergeConfigItem::SetSourceView(SwView* pView) 1929 { 1930 m_pSourceView = pView; 1931 1932 if(pView) 1933 { 1934 SvStringsDtor aDBNameList(5, 1); 1935 SvStringsDtor aAllDBNames(5, 5); 1936 pView->GetWrtShell().GetAllUsedDB( aDBNameList, &aAllDBNames ); 1937 if(aDBNameList.Count()) 1938 { 1939 // if fields are available there is usually no need of an addressblock and greeting 1940 if(!m_pImpl->bUserSettingWereOverwritten) 1941 { 1942 if( m_pImpl->bIsAddressBlock == sal_True 1943 || m_pImpl->bIsGreetingLineInMail == sal_True 1944 || m_pImpl->bIsGreetingLine == sal_True ) 1945 { 1946 //store user settings 1947 m_pImpl->bUserSettingWereOverwritten = sal_True; 1948 m_pImpl->bIsAddressBlock_LastUserSetting = m_pImpl->bIsAddressBlock; 1949 m_pImpl->bIsGreetingLineInMail_LastUserSetting = m_pImpl->bIsGreetingLineInMail; 1950 m_pImpl->bIsGreetingLine_LastUserSetting = m_pImpl->bIsGreetingLine; 1951 1952 //set all to false 1953 m_pImpl->bIsAddressBlock = sal_False; 1954 m_pImpl->bIsGreetingLineInMail = sal_False; 1955 m_pImpl->bIsGreetingLine = sal_False; 1956 1957 m_pImpl->SetModified(); 1958 } 1959 } 1960 } 1961 else if( m_pImpl->bUserSettingWereOverwritten ) 1962 { 1963 //restore last user settings: 1964 m_pImpl->bIsAddressBlock = m_pImpl->bIsAddressBlock_LastUserSetting; 1965 m_pImpl->bIsGreetingLineInMail = m_pImpl->bIsGreetingLineInMail_LastUserSetting; 1966 m_pImpl->bIsGreetingLine = m_pImpl->bIsGreetingLine_LastUserSetting; 1967 1968 m_pImpl->bUserSettingWereOverwritten = sal_False; 1969 } 1970 } 1971 } 1972 1973 /*-- 13.03.2006 12:15:06--------------------------------------------------- 1974 1975 -----------------------------------------------------------------------*/ 1976 void SwMailMergeConfigItem::SetCurrentAddressBlockIndex( sal_Int32 nSet ) 1977 { 1978 m_pImpl->SetCurrentAddressBlockIndex( nSet ); 1979 } 1980 /*-- 13.03.2006 12:15:07--------------------------------------------------- 1981 1982 -----------------------------------------------------------------------*/ 1983 sal_Int32 SwMailMergeConfigItem::GetCurrentAddressBlockIndex() const 1984 { 1985 return m_pImpl->GetCurrentAddressBlockIndex(); 1986 } 1987