Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <algorithm>
21 :
22 : #include <com/sun/star/container/XNamed.hpp>
23 :
24 : #include <unotools/transliterationwrapper.hxx>
25 :
26 : #ifndef __RSC //autogen
27 : #include <tools/errinf.hxx>
28 : #endif
29 : #include <osl/diagnose.h>
30 : #include <svl/urihelper.hxx>
31 : #include <svl/fstathelper.hxx>
32 : #include <unotools/pathoptions.hxx>
33 : #include <unotools/tempfile.hxx>
34 : #include <comphelper/string.hxx>
35 : #include <swtypes.hxx>
36 : #include <uitool.hxx>
37 : #include <glosdoc.hxx>
38 : #include <shellio.hxx>
39 : #include <swunohelper.hxx>
40 :
41 : #include <unoatxt.hxx>
42 : #include <swerror.h>
43 : #include <globals.hrc>
44 :
45 : #include <boost/scoped_ptr.hpp>
46 :
47 : using namespace ::com::sun::star;
48 : using namespace ::com::sun::star::uno;
49 :
50 : namespace
51 : {
52 :
53 132 : inline OUString lcl_FullPathName(const OUString& sPath, const OUString& sName)
54 : {
55 132 : return sPath + "/" + sName + SwGlossaries::GetExtension();
56 : }
57 :
58 8 : OUString lcl_CheckFileName( const OUString& rNewFilePath,
59 : const OUString& rNewGroupName )
60 : {
61 8 : const sal_Int32 nLen = rNewGroupName.getLength();
62 8 : OUStringBuffer aBuf(nLen);
63 : //group name should contain only A-Z and a-z and spaces
64 110 : for( sal_Int32 i=0; i < nLen; ++i )
65 : {
66 102 : const sal_Unicode cChar = rNewGroupName[i];
67 204 : if (comphelper::string::isalnumAscii(cChar) ||
68 102 : cChar == '_' || cChar == 0x20)
69 : {
70 102 : aBuf.append(cChar);
71 : }
72 : }
73 :
74 16 : const OUString sRet = aBuf.makeStringAndClear().trim();
75 8 : if ( !sRet.isEmpty() )
76 : {
77 8 : if (!FStatHelper::IsDocument( lcl_FullPathName(rNewFilePath, sRet) ))
78 8 : return sRet;
79 : }
80 :
81 0 : OUString rSG = SwGlossaries::GetExtension();
82 : //generate generic name
83 0 : utl::TempFile aTemp("group", true, &rSG, &rNewFilePath);
84 0 : aTemp.EnableKillingFile();
85 :
86 0 : INetURLObject aTempURL( aTemp.GetURL() );
87 8 : return aTempURL.GetBase();
88 : }
89 :
90 : }
91 :
92 : // supplies the default group's name
93 16 : OUString SwGlossaries::GetDefName()
94 : {
95 16 : return OUString("standard");
96 :
97 : }
98 :
99 : // supplies the number of text block groups
100 60 : size_t SwGlossaries::GetGroupCnt()
101 : {
102 60 : return GetNameList().size();
103 : }
104 :
105 : // supplies the group's name
106 0 : bool SwGlossaries::FindGroupName(OUString& rGroup)
107 : {
108 : // if the group name doesn't contain a path, a suitable group entry
109 : // can the searched for here;
110 0 : const size_t nCount = GetGroupCnt();
111 0 : for(size_t i = 0; i < nCount; ++i)
112 : {
113 0 : const OUString sTemp(GetGroupName(i));
114 0 : if (rGroup==sTemp.getToken(0, GLOS_DELIM))
115 : {
116 0 : rGroup = sTemp;
117 0 : return true;
118 : }
119 0 : }
120 : // you can search two times because for more directories the case sensitive
121 : // name could occur multiple times
122 0 : const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
123 0 : for(size_t i = 0; i < nCount; ++i)
124 : {
125 0 : const OUString sTemp( GetGroupName( i ));
126 0 : sal_uInt16 nPath = (sal_uInt16)sTemp.getToken(1, GLOS_DELIM).toInt32();
127 :
128 0 : if (!SWUnoHelper::UCB_IsCaseSensitiveFileName( m_PathArr[nPath] )
129 0 : && rSCmp.isEqual( rGroup, sTemp.getToken( 0, GLOS_DELIM) ) )
130 : {
131 0 : rGroup = sTemp;
132 0 : return true;
133 : }
134 0 : }
135 0 : return false;
136 : }
137 :
138 182 : OUString SwGlossaries::GetGroupName(size_t nGroupId)
139 : {
140 : OSL_ENSURE(nGroupId < m_GlosArr.size(),
141 : "SwGlossaries::GetGroupName: index out of bounds");
142 182 : return m_GlosArr[nGroupId];
143 : }
144 :
145 4 : OUString SwGlossaries::GetGroupTitle( const OUString& rGroupName )
146 : {
147 4 : OUString sRet;
148 8 : OUString sGroup(rGroupName);
149 4 : if (sGroup.indexOf(GLOS_DELIM)<0)
150 0 : FindGroupName(sGroup);
151 4 : SwTextBlocks* pGroup = GetGroupDoc(sGroup, false);
152 4 : if(pGroup)
153 : {
154 4 : sRet = pGroup->GetName();
155 4 : delete pGroup;
156 : }
157 8 : return sRet;
158 : }
159 :
160 : // supplies the group rName's text block document
161 110 : SwTextBlocks* SwGlossaries::GetGroupDoc(const OUString &rName,
162 : bool bCreate)
163 : {
164 : // insert to the list of text blocks if applicable
165 110 : if(bCreate && !m_GlosArr.empty())
166 : {
167 0 : std::vector<OUString>::const_iterator it(m_GlosArr.begin());
168 0 : for (; it != m_GlosArr.end(); ++it)
169 : {
170 0 : if (*it == rName)
171 0 : break;
172 : }
173 0 : if (it == m_GlosArr.end())
174 : { // block not in the list
175 0 : m_GlosArr.push_back(rName);
176 : }
177 : }
178 110 : return GetGlosDoc( rName, bCreate );
179 : }
180 :
181 : // Creates a new document with the group name. temporarly also created as file
182 : // so that groups remain there later (without access).
183 4 : bool SwGlossaries::NewGroupDoc(OUString& rGroupName, const OUString& rTitle)
184 : {
185 4 : const OUString sNewPath(rGroupName.getToken(1, GLOS_DELIM));
186 4 : sal_uInt16 nNewPath = (sal_uInt16)sNewPath.toInt32();
187 4 : if (static_cast<size_t>(nNewPath) >= m_PathArr.size())
188 0 : return false;
189 8 : const OUString sNewFilePath(m_PathArr[nNewPath]);
190 : const OUString sNewGroup = lcl_CheckFileName(sNewFilePath, rGroupName.getToken(0, GLOS_DELIM))
191 8 : + OUString(GLOS_DELIM) + sNewPath;
192 4 : SwTextBlocks *pBlock = GetGlosDoc( sNewGroup );
193 4 : if(pBlock)
194 : {
195 4 : GetNameList().push_back(sNewGroup);
196 4 : pBlock->SetName(rTitle);
197 4 : delete pBlock;
198 4 : rGroupName = sNewGroup;
199 4 : return true;
200 : }
201 4 : return false;
202 : }
203 :
204 4 : bool SwGlossaries::RenameGroupDoc(
205 : const OUString& rOldGroup, OUString& rNewGroup, const OUString& rNewTitle )
206 : {
207 4 : sal_uInt16 nOldPath = (sal_uInt16)rOldGroup.getToken(1, GLOS_DELIM).toInt32();
208 4 : if (static_cast<size_t>(nOldPath) >= m_PathArr.size())
209 0 : return false;
210 :
211 : const OUString sOldFileURL =
212 4 : lcl_FullPathName(m_PathArr[nOldPath], rOldGroup.getToken(0, GLOS_DELIM));
213 :
214 4 : if (!FStatHelper::IsDocument( sOldFileURL ))
215 : {
216 : OSL_FAIL("group doesn't exist!");
217 0 : return false;
218 : }
219 :
220 4 : sal_uInt16 nNewPath = (sal_uInt16)rNewGroup.getToken(1, GLOS_DELIM).toInt32();
221 4 : if (static_cast<size_t>(nNewPath) >= m_PathArr.size())
222 0 : return false;
223 :
224 4 : const OUString sNewFileName = lcl_CheckFileName(m_PathArr[nNewPath],
225 12 : rNewGroup.getToken(0, GLOS_DELIM));
226 8 : const OUString sNewFileURL = lcl_FullPathName(m_PathArr[nNewPath], sNewFileName);
227 :
228 4 : if (FStatHelper::IsDocument( sNewFileURL ))
229 : {
230 : OSL_FAIL("group already exists!");
231 0 : return false;
232 : }
233 :
234 4 : if (!SWUnoHelper::UCB_CopyFile(sOldFileURL, sNewFileURL, true ))
235 0 : return false;
236 :
237 4 : RemoveFileFromList( rOldGroup );
238 :
239 4 : rNewGroup = sNewFileName + OUString(GLOS_DELIM) + OUString::number(nNewPath);
240 4 : if (m_GlosArr.empty())
241 : {
242 0 : GetNameList();
243 : }
244 : else
245 : {
246 4 : m_GlosArr.push_back(rNewGroup);
247 : }
248 :
249 8 : boost::scoped_ptr<SwTextBlocks> pNewBlock(new SwTextBlocks( sNewFileURL ));
250 4 : pNewBlock->SetName(rNewTitle);
251 :
252 8 : return true;
253 : }
254 :
255 : // Deletes a text block group
256 2 : bool SwGlossaries::DelGroupDoc(const OUString &rName)
257 : {
258 2 : sal_uInt16 nPath = (sal_uInt16)rName.getToken(1, GLOS_DELIM).toInt32();
259 2 : if (static_cast<size_t>(nPath) >= m_PathArr.size())
260 0 : return false;
261 2 : const OUString sBaseName(rName.getToken(0, GLOS_DELIM));
262 4 : const OUString sFileURL = lcl_FullPathName(m_PathArr[nPath], sBaseName);
263 4 : const OUString aName = sBaseName + OUString(GLOS_DELIM) + OUString::number(nPath);
264 : // Even if the file doesn't exist it has to be deleted from
265 : // the list of text block regions
266 : // no && because of CFfront
267 2 : bool bRemoved = SWUnoHelper::UCB_DeleteFile( sFileURL );
268 : OSL_ENSURE(bRemoved, "file has not been removed");
269 2 : RemoveFileFromList( aName );
270 4 : return bRemoved;
271 : }
272 :
273 8 : SwGlossaries::~SwGlossaries()
274 : {
275 4 : InvalidateUNOOjects();
276 4 : }
277 :
278 : // read a block document
279 114 : SwTextBlocks* SwGlossaries::GetGlosDoc( const OUString &rName, bool bCreate ) const
280 : {
281 114 : sal_uInt16 nPath = (sal_uInt16)rName.getToken(1, GLOS_DELIM).toInt32();
282 114 : SwTextBlocks *pTmp = 0;
283 114 : if (static_cast<size_t>(nPath) < m_PathArr.size())
284 : {
285 : const OUString sFileURL =
286 114 : lcl_FullPathName(m_PathArr[nPath], rName.getToken(0, GLOS_DELIM));
287 :
288 114 : bool bExist = false;
289 114 : if(!bCreate)
290 110 : bExist = FStatHelper::IsDocument( sFileURL );
291 :
292 114 : if (bCreate || bExist)
293 : {
294 114 : pTmp = new SwTextBlocks( sFileURL );
295 114 : bool bOk = true;
296 114 : if( pTmp->GetError() )
297 : {
298 0 : ErrorHandler::HandleError( pTmp->GetError() );
299 0 : bOk = !IsError( pTmp->GetError() );
300 : }
301 :
302 114 : if( bOk && pTmp->GetName().isEmpty() )
303 0 : pTmp->SetName( rName );
304 114 : }
305 : }
306 :
307 114 : return pTmp;
308 : }
309 :
310 : // access to the list of names; read in if applicable
311 64 : std::vector<OUString> & SwGlossaries::GetNameList()
312 : {
313 64 : if (m_GlosArr.empty())
314 : {
315 2 : const OUString sExt( SwGlossaries::GetExtension() );
316 6 : for (size_t i = 0; i < m_PathArr.size(); ++i)
317 : {
318 4 : std::vector<OUString> aFiles;
319 :
320 4 : SWUnoHelper::UCB_GetFileListOfFolder(m_PathArr[i], aFiles, &sExt);
321 36 : for( std::vector<OUString>::const_iterator filesIt(aFiles.begin());
322 24 : filesIt != aFiles.end(); ++filesIt)
323 : {
324 8 : const OUString aTitle = *filesIt;
325 8 : const OUString sName( aTitle.copy( 0, aTitle.getLength() - sExt.getLength() )
326 24 : + OUString(GLOS_DELIM) + OUString::number( static_cast<sal_Int16>(i) ));
327 8 : m_GlosArr.push_back(sName);
328 8 : }
329 4 : }
330 2 : if (m_GlosArr.empty())
331 : {
332 : // the standard block is inside of the path's first part
333 0 : m_GlosArr.push_back( SwGlossaries::GetDefName() + OUString(GLOS_DELIM) + "0" );
334 2 : }
335 : }
336 64 : return m_GlosArr;
337 : }
338 :
339 4 : SwGlossaries::SwGlossaries()
340 : {
341 4 : UpdateGlosPath(true);
342 4 : }
343 :
344 : // set new path and recreate internal array
345 0 : rtl::OUString lcl_makePath(const std::vector<rtl::OUString>& rPaths)
346 : {
347 0 : std::vector<rtl::OUString>::const_iterator aIt(rPaths.begin());
348 0 : const std::vector<rtl::OUString>::const_iterator aEnd(rPaths.end());
349 0 : rtl::OUStringBuffer aPath(*aIt);
350 0 : for (++aIt; aIt != aEnd; ++aIt)
351 : {
352 0 : aPath.append(SVT_SEARCHPATH_DELIMITER);
353 0 : const INetURLObject aTemp(*aIt);
354 0 : aPath.append(aTemp.GetFull());
355 0 : }
356 0 : return aPath.getStr();
357 : }
358 :
359 4 : void SwGlossaries::UpdateGlosPath(bool bFull)
360 : {
361 4 : SvtPathOptions aPathOpt;
362 8 : OUString aNewPath( aPathOpt.GetAutoTextPath() );
363 4 : bool bPathChanged = m_aPath != aNewPath;
364 4 : if (bFull || bPathChanged)
365 : {
366 4 : m_aPath = aNewPath;
367 :
368 4 : m_PathArr.clear();
369 :
370 4 : std::vector<OUString> aDirArr;
371 8 : std::vector<rtl::OUString> aInvalidPaths;
372 4 : if (!m_aPath.isEmpty())
373 : {
374 4 : sal_Int32 nIndex = 0;
375 8 : do
376 : {
377 : const OUString sPth = URIHelper::SmartRel2Abs(
378 : INetURLObject(),
379 : m_aPath.getToken(0, SVT_SEARCHPATH_DELIMITER, nIndex),
380 8 : URIHelper::GetMaybeFileHdl());
381 32 : if (aDirArr.size() &&
382 24 : std::find(aDirArr.begin(), aDirArr.end(), sPth) != aDirArr.end())
383 : {
384 0 : continue;
385 : }
386 8 : aDirArr.push_back(sPth);
387 8 : if( !FStatHelper::IsFolder( sPth ) )
388 0 : aInvalidPaths.push_back(sPth);
389 : else
390 8 : m_PathArr.push_back(sPth);
391 : }
392 8 : while (nIndex>=0);
393 : }
394 :
395 4 : if (m_aPath.isEmpty() || !aInvalidPaths.empty())
396 : {
397 0 : std::sort(aInvalidPaths.begin(), aInvalidPaths.end());
398 0 : aInvalidPaths.erase(std::unique(aInvalidPaths.begin(), aInvalidPaths.end()), aInvalidPaths.end());
399 0 : if (bPathChanged || (m_aInvalidPaths != aInvalidPaths))
400 : {
401 0 : m_aInvalidPaths = aInvalidPaths;
402 : // wrong path, that means AutoText directory doesn't exist
403 :
404 : ErrorHandler::HandleError( *new StringErrorInfo(
405 : ERR_AUTOPATH_ERROR, lcl_makePath(m_aInvalidPaths),
406 0 : ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR ));
407 0 : m_bError = true;
408 : }
409 : else
410 0 : m_bError = false;
411 : }
412 : else
413 4 : m_bError = false;
414 :
415 4 : if (!m_GlosArr.empty())
416 : {
417 0 : m_GlosArr.clear();
418 0 : GetNameList();
419 4 : }
420 4 : }
421 4 : }
422 :
423 0 : void SwGlossaries::ShowError()
424 : {
425 : sal_uInt32 nPathError = *new StringErrorInfo(ERR_AUTOPATH_ERROR,
426 0 : lcl_makePath(m_aInvalidPaths), ERRCODE_BUTTON_OK );
427 0 : ErrorHandler::HandleError( nPathError );
428 0 : }
429 :
430 134 : OUString SwGlossaries::GetExtension()
431 : {
432 134 : return OUString(".bau");
433 : }
434 :
435 6 : void SwGlossaries::RemoveFileFromList( const OUString& rGroup )
436 : {
437 6 : if (!m_GlosArr.empty())
438 : {
439 90 : for (std::vector<OUString>::iterator it(m_GlosArr.begin());
440 60 : it != m_GlosArr.end(); ++it)
441 : {
442 30 : if (*it == rGroup)
443 : {
444 6 : OUString aUName = rGroup;
445 : {
446 : // tell the UNO AutoTextGroup object that it's not valid anymore
447 66 : for ( UnoAutoTextGroups::iterator aLoop = m_aGlossaryGroups.begin();
448 44 : aLoop != m_aGlossaryGroups.end();
449 : ++aLoop
450 : )
451 : {
452 20 : Reference< container::XNamed > xNamed( aLoop->get(), UNO_QUERY );
453 20 : if ( xNamed.is() && ( xNamed->getName() == aUName ) )
454 : {
455 4 : static_cast< SwXAutoTextGroup* >( xNamed.get() )->Invalidate();
456 : // note that this static_cast works because we know that the array only
457 : // contains SwXAutoTextGroup implementation
458 4 : m_aGlossaryGroups.erase( aLoop );
459 4 : break;
460 : }
461 16 : }
462 : }
463 :
464 : {
465 : // tell all our UNO AutoTextEntry objects that they're not valid anymore
466 42 : for ( UnoAutoTextEntries::iterator aLoop = m_aGlossaryEntries.begin();
467 36 : aLoop != m_aGlossaryEntries.end();
468 : )
469 : {
470 12 : Reference< lang::XUnoTunnel > xEntryTunnel( aLoop->get(), UNO_QUERY );
471 :
472 12 : SwXAutoTextEntry* pEntry = NULL;
473 12 : if ( xEntryTunnel.is() )
474 : pEntry = reinterpret_cast< SwXAutoTextEntry* >(
475 12 : xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
476 :
477 12 : if ( pEntry && ( pEntry->GetGroupName() == rGroup ) )
478 : {
479 0 : pEntry->Invalidate();
480 0 : aLoop = m_aGlossaryEntries.erase( aLoop );
481 : }
482 : else
483 12 : ++aLoop;
484 12 : }
485 : }
486 :
487 6 : m_GlosArr.erase(it);
488 6 : break;
489 : }
490 : }
491 : }
492 6 : }
493 :
494 46 : OUString SwGlossaries::GetCompleteGroupName( const OUString& rGroupName )
495 : {
496 46 : const size_t nCount = GetGroupCnt();
497 : // when the group name was created internally the path is here as well
498 46 : sal_Int32 nIndex = 0;
499 46 : const OUString sGroupName(rGroupName.getToken(0, GLOS_DELIM, nIndex));
500 46 : const bool bPathLen = !rGroupName.getToken(0, GLOS_DELIM, nIndex).isEmpty();
501 174 : for ( size_t i = 0; i < nCount; i++ )
502 : {
503 160 : const OUString sGrpName = GetGroupName(i);
504 160 : if (bPathLen)
505 : {
506 88 : if (rGroupName == sGrpName)
507 20 : return sGrpName;
508 : }
509 : else
510 : {
511 72 : if (sGroupName == sGrpName.getToken(0, GLOS_DELIM))
512 12 : return sGrpName;
513 : }
514 128 : }
515 14 : return OUString();
516 : }
517 :
518 4 : void SwGlossaries::InvalidateUNOOjects()
519 : {
520 : // invalidate all the AutoTextGroup-objects
521 27 : for ( UnoAutoTextGroups::iterator aGroupLoop = m_aGlossaryGroups.begin();
522 18 : aGroupLoop != m_aGlossaryGroups.end();
523 : ++aGroupLoop
524 : )
525 : {
526 5 : Reference< text::XAutoTextGroup > xGroup( aGroupLoop->get(), UNO_QUERY );
527 5 : if ( xGroup.is() )
528 5 : static_cast< SwXAutoTextGroup* >( xGroup.get() )->Invalidate();
529 5 : }
530 4 : UnoAutoTextGroups aTmpg = UnoAutoTextGroups();
531 4 : m_aGlossaryGroups.swap( aTmpg );
532 :
533 : // invalidate all the AutoTextEntry-objects
534 30 : for ( UnoAutoTextEntries::const_iterator aEntryLoop = m_aGlossaryEntries.begin();
535 20 : aEntryLoop != m_aGlossaryEntries.end();
536 : ++aEntryLoop
537 : )
538 : {
539 6 : Reference< lang::XUnoTunnel > xEntryTunnel( aEntryLoop->get(), UNO_QUERY );
540 6 : SwXAutoTextEntry* pEntry = NULL;
541 6 : if ( xEntryTunnel.is() )
542 : pEntry = reinterpret_cast< SwXAutoTextEntry* >(
543 3 : xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
544 :
545 6 : if ( pEntry )
546 3 : pEntry->Invalidate();
547 6 : }
548 8 : UnoAutoTextEntries aTmpe = UnoAutoTextEntries();
549 8 : m_aGlossaryEntries.swap( aTmpe );
550 4 : }
551 :
552 16 : Reference< text::XAutoTextGroup > SwGlossaries::GetAutoTextGroup( const OUString& _rGroupName, bool _bCreate )
553 : {
554 : // first, find the name with path-extension
555 16 : const OUString sCompleteGroupName = GetCompleteGroupName( _rGroupName );
556 :
557 16 : Reference< text::XAutoTextGroup > xGroup;
558 :
559 : // look up the group in the cache
560 16 : UnoAutoTextGroups::iterator aSearch = m_aGlossaryGroups.begin();
561 16 : for ( ; aSearch != m_aGlossaryGroups.end(); )
562 : {
563 35 : Reference< lang::XUnoTunnel > xGroupTunnel( aSearch->get(), UNO_QUERY );
564 :
565 35 : SwXAutoTextGroup* pSwGroup = 0;
566 35 : if ( xGroupTunnel.is() )
567 32 : pSwGroup = reinterpret_cast< SwXAutoTextGroup* >( xGroupTunnel->getSomething( SwXAutoTextGroup::getUnoTunnelId() ) );
568 :
569 35 : if ( !pSwGroup )
570 : {
571 : // the object is dead in the meantime -> remove from cache
572 3 : aSearch = m_aGlossaryGroups.erase( aSearch );
573 3 : continue;
574 : }
575 :
576 32 : if ( _rGroupName == pSwGroup->getName() )
577 : { // the group is already cached
578 4 : if ( !sCompleteGroupName.isEmpty() )
579 : { // the group still exists -> return it
580 4 : xGroup = pSwGroup;
581 4 : break;
582 : }
583 : else
584 : {
585 : // this group does not exist (anymore) -> release the cached UNO object for it
586 0 : aSearch = m_aGlossaryGroups.erase( aSearch );
587 : // so it won't be created below
588 0 : _bCreate = false;
589 0 : break;
590 : }
591 : }
592 :
593 28 : ++aSearch;
594 28 : }
595 :
596 16 : if ( !xGroup.is() && _bCreate )
597 : {
598 12 : xGroup = new SwXAutoTextGroup( sCompleteGroupName, this );
599 : // cache it
600 12 : m_aGlossaryGroups.push_back( AutoTextGroupRef( xGroup ) );
601 : }
602 :
603 16 : return xGroup;
604 : }
605 :
606 14 : Reference< text::XAutoTextEntry > SwGlossaries::GetAutoTextEntry(
607 : const OUString& rCompleteGroupName,
608 : const OUString& rGroupName,
609 : const OUString& rEntryName,
610 : bool _bCreate )
611 : {
612 : //standard must be created
613 14 : bool bCreate = ( rCompleteGroupName == GetDefName() );
614 14 : boost::scoped_ptr< SwTextBlocks > pGlosGroup( GetGroupDoc( rCompleteGroupName, bCreate ) );
615 :
616 14 : if ( pGlosGroup.get() && !pGlosGroup->GetError() )
617 : {
618 14 : sal_uInt16 nIdx = pGlosGroup->GetIndex( rEntryName );
619 14 : if ( USHRT_MAX == nIdx )
620 2 : throw container::NoSuchElementException();
621 : }
622 : else
623 0 : throw lang::WrappedTargetException();
624 :
625 12 : Reference< text::XAutoTextEntry > xReturn;
626 :
627 12 : UnoAutoTextEntries::iterator aSearch( m_aGlossaryEntries.begin() );
628 12 : for ( ; aSearch != m_aGlossaryEntries.end(); )
629 : {
630 16 : Reference< lang::XUnoTunnel > xEntryTunnel( aSearch->get(), UNO_QUERY );
631 :
632 16 : SwXAutoTextEntry* pEntry = NULL;
633 16 : if ( xEntryTunnel.is() )
634 16 : pEntry = reinterpret_cast< SwXAutoTextEntry* >( xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
635 : else
636 : {
637 : // the object is dead in the meantime -> remove from cache
638 0 : aSearch = m_aGlossaryEntries.erase( aSearch );
639 0 : continue;
640 : }
641 :
642 16 : if ( pEntry
643 16 : && pEntry->GetGroupName() == rGroupName
644 24 : && pEntry->GetEntryName() == rEntryName
645 : )
646 : {
647 6 : xReturn = pEntry;
648 6 : break;
649 : }
650 :
651 10 : ++aSearch;
652 10 : }
653 :
654 12 : if ( !xReturn.is() && _bCreate )
655 : {
656 6 : xReturn = new SwXAutoTextEntry( this, rGroupName, rEntryName );
657 : // cache it
658 6 : m_aGlossaryEntries.push_back( AutoTextEntryRef( xReturn ) );
659 : }
660 :
661 14 : return xReturn;
662 270 : }
663 :
664 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
