1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svl.hxx" 26 27 #include <svl/srchcfg.hxx> 28 #include <svl/svarray.hxx> 29 #include <com/sun/star/uno/Any.hxx> 30 #include <com/sun/star/uno/Sequence.hxx> 31 #include <com/sun/star/beans/PropertyValue.hpp> 32 #include <tools/debug.hxx> 33 #include <unotools/configpathes.hxx> 34 35 //----------------------------------------------------------------------------- 36 using namespace utl; 37 using namespace rtl; 38 using namespace com::sun::star; 39 using namespace com::sun::star::uno; 40 using namespace com::sun::star::beans; 41 42 #define C2U(cChar) OUString::createFromAscii(cChar) 43 44 //----------------------------------------------------------------------------- 45 typedef SvxSearchEngineData* SvxSearchEngineDataPtr; 46 SV_DECL_PTRARR_DEL(SvxSearchEngineArr, SvxSearchEngineDataPtr, 2, 2) 47 SV_IMPL_PTRARR(SvxSearchEngineArr, SvxSearchEngineDataPtr); 48 //----------------------------------------------------------------------------- 49 struct SvxSearchConfig_Impl 50 { 51 SvxSearchEngineArr aEngineArr; 52 }; 53 /* -----------------------------19.03.01 14:00-------------------------------- 54 55 ---------------------------------------------------------------------------*/ 56 sal_Bool SvxSearchEngineData::operator==(const SvxSearchEngineData& rData) 57 { 58 return sEngineName == rData.sEngineName && 59 sAndPrefix == rData.sAndPrefix && 60 sAndSuffix == rData.sAndSuffix && 61 sAndSeparator == rData.sAndSeparator && 62 nAndCaseMatch == rData.nAndCaseMatch && 63 sOrPrefix == rData.sOrPrefix && 64 sOrSuffix == rData.sOrSuffix && 65 sOrSeparator == rData.sOrSeparator && 66 nOrCaseMatch == rData.nOrCaseMatch && 67 sExactPrefix == rData.sExactPrefix && 68 sExactSuffix == rData.sExactSuffix && 69 sExactSeparator == rData.sExactSeparator && 70 nExactCaseMatch == rData.nExactCaseMatch; 71 } 72 /* -----------------------------16.01.01 15:36-------------------------------- 73 74 ---------------------------------------------------------------------------*/ 75 const Sequence<OUString>& lcl_GetSearchPropertyNames_Impl() 76 { 77 static Sequence<OUString> aNames; 78 if(!aNames.getLength()) 79 { 80 aNames.realloc(12); 81 OUString* pNames = aNames.getArray(); 82 pNames[0] = C2U("And/ooInetPrefix"); 83 pNames[1] = C2U("And/ooInetSuffix"); 84 pNames[2] = C2U("And/ooInetSeparator"); 85 pNames[3] = C2U("And/ooInetCaseMatch"); 86 pNames[4] = C2U("Or/ooInetPrefix"); 87 pNames[5] = C2U("Or/ooInetSuffix"); 88 pNames[6] = C2U("Or/ooInetSeparator"); 89 pNames[7] = C2U("Or/ooInetCaseMatch"); 90 pNames[8] = C2U("Exact/ooInetPrefix"); 91 pNames[9] = C2U("Exact/ooInetSuffix"); 92 pNames[10] = C2U("Exact/ooInetSeparator"); 93 pNames[11] = C2U("Exact/ooInetCaseMatch"); 94 } 95 return aNames; 96 } 97 // --------------------------------------------------------------------------- 98 SvxSearchConfig::SvxSearchConfig(sal_Bool bEnableNotify) : 99 utl::ConfigItem(C2U("Inet/SearchEngines"), CONFIG_MODE_DELAYED_UPDATE), 100 pImpl(new SvxSearchConfig_Impl) 101 { 102 if(bEnableNotify) 103 { 104 //request notifications from the node 105 Sequence<OUString> aEnable(1); 106 EnableNotification(aEnable); 107 } 108 Load(); 109 } 110 /* -----------------------------16.01.01 15:36-------------------------------- 111 112 ---------------------------------------------------------------------------*/ 113 SvxSearchConfig::~SvxSearchConfig() 114 { 115 delete pImpl; 116 } 117 /* -----------------------------17.01.01 09:57-------------------------------- 118 119 ---------------------------------------------------------------------------*/ 120 void SvxSearchConfig::Load() 121 { 122 pImpl->aEngineArr.DeleteAndDestroy(0, pImpl->aEngineArr.Count()); 123 Sequence<OUString> aNodeNames = GetNodeNames(OUString()); 124 const OUString* pNodeNames = aNodeNames.getConstArray(); 125 for(sal_Int32 nNode = 0; nNode < aNodeNames.getLength(); nNode++) 126 { 127 SvxSearchEngineDataPtr pNew = new SvxSearchEngineData; 128 pNew->sEngineName = pNodeNames[nNode]; 129 const Sequence<OUString>& rPropNames = lcl_GetSearchPropertyNames_Impl(); 130 const OUString* pPropNames = rPropNames.getConstArray(); 131 Sequence<OUString> aPropertyNames(rPropNames.getLength()); 132 OUString* pPropertyNames = aPropertyNames.getArray(); 133 const OUString sSlash(C2U("/")); 134 sal_Int32 nProp; 135 for(nProp = 0; nProp < rPropNames.getLength(); nProp++) 136 { 137 pPropertyNames[nProp] = wrapConfigurationElementName(pNodeNames[nNode]); 138 pPropertyNames[nProp] += sSlash; 139 pPropertyNames[nProp] += pPropNames[nProp]; 140 } 141 Sequence<Any> aValues = GetProperties(aPropertyNames); 142 const Any* pValues = aValues.getConstArray(); 143 for(nProp = 0; nProp < rPropNames.getLength(); nProp++) 144 { 145 switch(nProp) 146 { 147 case 0 : pValues[nProp] >>= pNew->sAndPrefix; break; 148 case 1 : pValues[nProp] >>= pNew->sAndSuffix; break; 149 case 2 : pValues[nProp] >>= pNew->sAndSeparator; break; 150 case 3 : pValues[nProp] >>= pNew->nAndCaseMatch; break; 151 152 case 4 : pValues[nProp] >>= pNew->sOrPrefix; break; 153 case 5 : pValues[nProp] >>= pNew->sOrSuffix; break; 154 case 6 : pValues[nProp] >>= pNew->sOrSeparator; break; 155 case 7 : pValues[nProp] >>= pNew->nOrCaseMatch; break; 156 157 case 8 : pValues[nProp] >>= pNew->sExactPrefix; break; 158 case 9 : pValues[nProp] >>= pNew->sExactSuffix; break; 159 case 10: pValues[nProp] >>= pNew->sExactSeparator; break; 160 case 11: pValues[nProp] >>= pNew->nExactCaseMatch; break; 161 } 162 } 163 pImpl->aEngineArr.Insert(pNew, pImpl->aEngineArr.Count()); 164 } 165 } 166 /* -----------------------------17.01.01 09:57-------------------------------- 167 168 ---------------------------------------------------------------------------*/ 169 void SvxSearchConfig::Notify( const Sequence<OUString>& ) 170 { 171 Load(); 172 } 173 /* -----------------------------16.01.01 15:36-------------------------------- 174 175 ---------------------------------------------------------------------------*/ 176 void SvxSearchConfig::Commit() 177 { 178 OUString sNode; 179 if(!pImpl->aEngineArr.Count()) 180 ClearNodeSet(sNode); 181 else 182 { 183 Sequence<PropertyValue> aSetValues(12 * pImpl->aEngineArr.Count()); 184 PropertyValue* pSetValues = aSetValues.getArray(); 185 186 const Sequence<OUString>& rPropNames = lcl_GetSearchPropertyNames_Impl(); 187 const OUString* pPropNames = rPropNames.getConstArray(); 188 const OUString sSlash(C2U("/")); 189 for(sal_uInt16 i = 0; i < pImpl->aEngineArr.Count(); i++) 190 { 191 SvxSearchEngineDataPtr pSave = pImpl->aEngineArr[i]; 192 for(sal_Int16 nProp = 0; nProp < rPropNames.getLength(); nProp++) 193 { 194 OUString sTmpName = sSlash; 195 sTmpName += wrapConfigurationElementName(pSave->sEngineName); 196 sTmpName += sSlash; 197 sTmpName += pPropNames[nProp]; 198 pSetValues[nProp].Name = sTmpName; 199 switch(nProp) 200 { 201 case 0 : pSetValues[nProp].Value <<= pSave->sAndPrefix; break; 202 case 1 : pSetValues[nProp].Value <<= pSave->sAndSuffix; break; 203 case 2 : pSetValues[nProp].Value <<= pSave->sAndSeparator; break; 204 case 3 : pSetValues[nProp].Value <<= pSave->nAndCaseMatch; break; 205 206 case 4 : pSetValues[nProp].Value <<= pSave->sOrPrefix; break; 207 case 5 : pSetValues[nProp].Value <<= pSave->sOrSuffix; break; 208 case 6 : pSetValues[nProp].Value <<= pSave->sOrSeparator; break; 209 case 7 : pSetValues[nProp].Value <<= pSave->nOrCaseMatch; break; 210 211 case 8 : pSetValues[nProp].Value <<= pSave->sExactPrefix; break; 212 case 9 : pSetValues[nProp].Value <<= pSave->sExactSuffix; break; 213 case 10: pSetValues[nProp].Value <<= pSave->sExactSeparator; break; 214 case 11: pSetValues[nProp].Value <<= pSave->nExactCaseMatch; break; 215 } 216 } 217 pSetValues+= 12; 218 } 219 ReplaceSetProperties(sNode, aSetValues); 220 } 221 } 222 /* -----------------------------19.03.01 10:02-------------------------------- 223 224 ---------------------------------------------------------------------------*/ 225 sal_uInt16 SvxSearchConfig::Count() 226 { 227 return pImpl->aEngineArr.Count(); 228 } 229 /* -----------------------------19.03.01 10:02-------------------------------- 230 231 ---------------------------------------------------------------------------*/ 232 const SvxSearchEngineData& SvxSearchConfig::GetData(sal_uInt16 nPos) 233 { 234 DBG_ASSERT(nPos < pImpl->aEngineArr.Count(), "wrong array index"); 235 return *pImpl->aEngineArr[nPos]; 236 } 237 /* -----------------------------19.03.01 10:38-------------------------------- 238 239 ---------------------------------------------------------------------------*/ 240 const SvxSearchEngineData* SvxSearchConfig::GetData(const rtl::OUString& rEngineName) 241 { 242 for(sal_uInt16 nPos = 0; nPos < pImpl->aEngineArr.Count(); nPos++) 243 { 244 if(pImpl->aEngineArr[nPos]->sEngineName == rEngineName) 245 return pImpl->aEngineArr[nPos]; 246 } 247 return 0; 248 } 249 /* -----------------------------19.03.01 10:02-------------------------------- 250 251 ---------------------------------------------------------------------------*/ 252 void SvxSearchConfig::SetData(const SvxSearchEngineData& rData) 253 { 254 for(sal_uInt16 nPos = 0; nPos < pImpl->aEngineArr.Count(); nPos++) 255 { 256 if(pImpl->aEngineArr[nPos]->sEngineName == rData.sEngineName) 257 { 258 if((*pImpl->aEngineArr[nPos]) == rData) 259 return; 260 pImpl->aEngineArr.DeleteAndDestroy(nPos, 1); 261 break; 262 } 263 } 264 SvxSearchEngineDataPtr pInsert = new SvxSearchEngineData(rData); 265 pImpl->aEngineArr.Insert(pInsert, pImpl->aEngineArr.Count()); 266 SetModified(); 267 } 268 /* -----------------------------19.03.01 10:38-------------------------------- 269 270 ---------------------------------------------------------------------------*/ 271 void SvxSearchConfig::RemoveData(const rtl::OUString& rEngineName) 272 { 273 for(sal_uInt16 nPos = 0; nPos < pImpl->aEngineArr.Count(); nPos++) 274 { 275 if(pImpl->aEngineArr[nPos]->sEngineName == rEngineName) 276 { 277 pImpl->aEngineArr.DeleteAndDestroy(nPos, 1); 278 SetModified(); 279 return ; 280 } 281 } 282 } 283 284