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 <com/sun/star/beans/PropertyAttribute.hpp>
21 : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
22 : #include <osl/mutex.hxx>
23 : #include <osl/diagnose.h>
24 : #include <vcl/svapp.hxx>
25 : #include <svtools/unoevent.hxx>
26 : #include <svl/urihelper.hxx>
27 : #include <sfx2/event.hxx>
28 : #include <swtypes.hxx>
29 : #include <glosdoc.hxx>
30 : #include <shellio.hxx>
31 : #include <initui.hxx>
32 : #include <gloslst.hxx>
33 : #include <unoatxt.hxx>
34 : #include <unomap.hxx>
35 : #include <unomid.h>
36 : #include <unotextbodyhf.hxx>
37 : #include <unotextrange.hxx>
38 : #include <TextCursorHelper.hxx>
39 : #include <swevent.hxx>
40 : #include <doc.hxx>
41 : #include <unocrsr.hxx>
42 : #include <IMark.hxx>
43 : #include <IDocumentContentOperations.hxx>
44 : #include <IDocumentRedlineAccess.hxx>
45 : #include <IDocumentFieldsAccess.hxx>
46 : #include <IDocumentState.hxx>
47 : #include <unoprnms.hxx>
48 : #include <docsh.hxx>
49 : #include <swmodule.hxx>
50 : #include <swdll.hxx>
51 : #include <svl/smplhint.hxx>
52 : #include <svl/macitem.hxx>
53 : #include <editeng/acorrcfg.hxx>
54 : #include <comphelper/servicehelper.hxx>
55 : #include <comphelper/string.hxx>
56 : #include <cppuhelper/supportsservice.hxx>
57 :
58 : #include <boost/scoped_ptr.hpp>
59 :
60 : using namespace ::com::sun::star;
61 :
62 8 : uno::Reference< uno::XInterface > SAL_CALL SwXAutoTextContainer_createInstance(
63 : const uno::Reference< lang::XMultiServiceFactory > & ) throw( uno::Exception )
64 : {
65 : //the module may not be loaded
66 8 : SolarMutexGuard aGuard;
67 8 : SwGlobals::ensure();
68 8 : static uno::Reference< uno::XInterface > xAText = (cppu::OWeakObject*)new SwXAutoTextContainer();
69 8 : return xAText;
70 : }
71 :
72 4 : uno::Sequence< OUString > SAL_CALL SwXAutoTextContainer_getSupportedServiceNames() throw()
73 : {
74 4 : OUString sService("com.sun.star.text.AutoTextContainer");
75 4 : const uno::Sequence< OUString > aSeq( &sService, 1 );
76 4 : return aSeq;
77 : }
78 :
79 104 : OUString SAL_CALL SwXAutoTextContainer_getImplementationName() throw()
80 : {
81 104 : return OUString("SwXAutoTextContainer" );
82 : }
83 :
84 4 : SwXAutoTextContainer::SwXAutoTextContainer()
85 : {
86 4 : pGlossaries = ::GetGlossaries();
87 :
88 4 : }
89 :
90 8 : SwXAutoTextContainer::~SwXAutoTextContainer()
91 : {
92 :
93 8 : }
94 :
95 2 : sal_Int32 SwXAutoTextContainer::getCount(void) throw( uno::RuntimeException, std::exception )
96 : {
97 : OSL_ENSURE(pGlossaries->GetGroupCnt() < static_cast<size_t>(SAL_MAX_INT32),
98 : "SwXAutoTextContainer::getCount: too many items");
99 2 : return static_cast<sal_Int32>(pGlossaries->GetGroupCnt());
100 : }
101 :
102 8 : uno::Any SwXAutoTextContainer::getByIndex(sal_Int32 nIndex)
103 : throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
104 : {
105 8 : SolarMutexGuard aGuard;
106 8 : const size_t nCount = pGlossaries->GetGroupCnt();
107 8 : if ( nIndex < 0 || static_cast<size_t>(nIndex) >= nCount )
108 2 : throw lang::IndexOutOfBoundsException();
109 6 : return getByName(pGlossaries->GetGroupName( static_cast<size_t>(nIndex) ));
110 : }
111 :
112 2 : uno::Type SwXAutoTextContainer::getElementType(void) throw( uno::RuntimeException, std::exception )
113 : {
114 2 : return cppu::UnoType<text::XAutoTextGroup>::get();
115 :
116 : }
117 :
118 2 : sal_Bool SwXAutoTextContainer::hasElements(void) throw( uno::RuntimeException, std::exception )
119 : {
120 : // At least standard should always exists!
121 2 : return sal_True;
122 : }
123 :
124 14 : uno::Any SwXAutoTextContainer::getByName(const OUString& GroupName)
125 : throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
126 : {
127 14 : SolarMutexGuard aGuard;
128 :
129 28 : uno::Reference< text::XAutoTextGroup > xGroup;
130 14 : if ( pGlossaries && hasByName( GroupName ) ) // group name already known?
131 : // sal_True = create group if not already available
132 12 : xGroup = pGlossaries->GetAutoTextGroup( GroupName, true );
133 :
134 14 : if ( !xGroup.is() )
135 2 : throw container::NoSuchElementException();
136 :
137 26 : return makeAny( xGroup );
138 : }
139 :
140 4 : uno::Sequence< OUString > SwXAutoTextContainer::getElementNames(void) throw( uno::RuntimeException, std::exception )
141 : {
142 4 : SolarMutexGuard aGuard;
143 4 : const size_t nCount = pGlossaries->GetGroupCnt();
144 : OSL_ENSURE(nCount < static_cast<size_t>(SAL_MAX_INT32),
145 : "SwXAutoTextContainer::getElementNames: too many groups");
146 :
147 4 : uno::Sequence< OUString > aGroupNames(static_cast<sal_Int32>(nCount));
148 4 : OUString *pArr = aGroupNames.getArray();
149 :
150 20 : for ( size_t i = 0; i < nCount; ++i )
151 : {
152 : // The names will be passed without a path extension.
153 16 : OUString sGroupName(pGlossaries->GetGroupName(i));
154 16 : pArr[i] = sGroupName.getToken(0, GLOS_DELIM);
155 16 : }
156 4 : return aGroupNames;
157 : }
158 : // Finds group names with or without path index.
159 22 : sal_Bool SwXAutoTextContainer::hasByName(const OUString& Name)
160 : throw( uno::RuntimeException, std::exception )
161 : {
162 22 : SolarMutexGuard aGuard;
163 44 : OUString sGroupName( pGlossaries->GetCompleteGroupName( Name ) );
164 22 : if(!sGroupName.isEmpty())
165 14 : return sal_True;
166 30 : return sal_False;
167 : }
168 :
169 4 : uno::Reference< text::XAutoTextGroup > SwXAutoTextContainer::insertNewByName(
170 : const OUString& aGroupName)
171 : throw( lang::IllegalArgumentException, container::ElementExistException, uno::RuntimeException, std::exception )
172 : {
173 4 : SolarMutexGuard aGuard;
174 4 : if(hasByName(aGroupName))
175 0 : throw container::ElementExistException();
176 : //check for non-ASCII characters
177 4 : if(aGroupName.isEmpty())
178 : {
179 0 : lang::IllegalArgumentException aIllegal;
180 0 : aIllegal.Message = "group name must not be empty";
181 0 : throw aIllegal;
182 : }
183 76 : for(sal_Int32 nPos = 0; nPos < aGroupName.getLength(); nPos++)
184 : {
185 72 : sal_Unicode cChar = aGroupName[nPos];
186 146 : if (comphelper::string::isalnumAscii(cChar) ||
187 2 : (cChar == '_') ||
188 74 : (cChar == 0x20) ||
189 : (cChar == GLOS_DELIM) )
190 : {
191 72 : continue;
192 : }
193 0 : lang::IllegalArgumentException aIllegal;
194 0 : aIllegal.Message = "group name must contain a-z, A-z, '_', ' ' only";
195 0 : throw aIllegal;
196 0 : }
197 8 : OUString sGroup(aGroupName);
198 4 : if (sGroup.indexOf(GLOS_DELIM)<0)
199 : {
200 2 : sGroup += OUString(GLOS_DELIM) + "0";
201 : }
202 4 : pGlossaries->NewGroupDoc(sGroup, sGroup.getToken(0, GLOS_DELIM));
203 :
204 4 : uno::Reference< text::XAutoTextGroup > xGroup = pGlossaries->GetAutoTextGroup( sGroup, true );
205 : OSL_ENSURE( xGroup.is(), "SwXAutoTextContainer::insertNewByName: no UNO object created? How this?" );
206 : // We just inserted the group into the glossaries, so why doesn't it exist?
207 :
208 8 : return xGroup;
209 : }
210 :
211 8 : void SwXAutoTextContainer::removeByName(const OUString& aGroupName)
212 : throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
213 : {
214 8 : SolarMutexGuard aGuard;
215 : // At first find the name with path extension
216 16 : OUString sGroupName = pGlossaries->GetCompleteGroupName( aGroupName );
217 8 : if(sGroupName.isEmpty())
218 6 : throw container::NoSuchElementException();
219 10 : pGlossaries->DelGroupDoc(sGroupName);
220 2 : }
221 :
222 0 : OUString SwXAutoTextContainer::getImplementationName(void) throw( uno::RuntimeException, std::exception )
223 : {
224 0 : return SwXAutoTextContainer_getImplementationName();
225 : }
226 :
227 0 : sal_Bool SwXAutoTextContainer::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
228 : {
229 0 : return cppu::supportsService(this, rServiceName);
230 : }
231 :
232 0 : uno::Sequence< OUString > SwXAutoTextContainer::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
233 : {
234 0 : return SwXAutoTextContainer_getSupportedServiceNames();
235 : }
236 :
237 : namespace
238 : {
239 : class theSwXAutoTextGroupUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXAutoTextGroupUnoTunnelId > {};
240 : }
241 :
242 64 : const uno::Sequence< sal_Int8 > & SwXAutoTextGroup::getUnoTunnelId()
243 : {
244 64 : return theSwXAutoTextGroupUnoTunnelId::get().getSeq();
245 : }
246 :
247 32 : sal_Int64 SAL_CALL SwXAutoTextGroup::getSomething( const uno::Sequence< sal_Int8 >& rId )
248 : throw(uno::RuntimeException, std::exception)
249 : {
250 64 : if( rId.getLength() == 16
251 96 : && 0 == memcmp( getUnoTunnelId().getConstArray(),
252 64 : rId.getConstArray(), 16 ) )
253 : {
254 32 : return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ));
255 : }
256 0 : return 0;
257 : }
258 :
259 12 : SwXAutoTextGroup::SwXAutoTextGroup(const OUString& rName,
260 : SwGlossaries* pGlos) :
261 12 : pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_AUTO_TEXT_GROUP)),
262 : pGlossaries(pGlos),
263 : sName(rName),
264 24 : m_sGroupName(rName)
265 : {
266 : OSL_ENSURE( -1 != rName.indexOf( GLOS_DELIM ),
267 : "SwXAutoTextGroup::SwXAutoTextGroup: to be constructed with a complete name only!" );
268 12 : }
269 :
270 24 : SwXAutoTextGroup::~SwXAutoTextGroup()
271 : {
272 24 : }
273 :
274 14 : uno::Sequence< OUString > SwXAutoTextGroup::getTitles(void) throw( uno::RuntimeException, std::exception )
275 : {
276 14 : SolarMutexGuard aGuard;
277 28 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
278 14 : if (!pGlosGroup || pGlosGroup->GetError())
279 0 : throw uno::RuntimeException();
280 14 : const sal_uInt16 nCount = pGlosGroup->GetCount();
281 :
282 14 : uno::Sequence< OUString > aEntryTitles(nCount);
283 14 : OUString *pArr = aEntryTitles.getArray();
284 :
285 22 : for ( sal_uInt16 i = 0; i < nCount; i++ )
286 8 : pArr[i] = pGlosGroup->GetLongName(i);
287 28 : return aEntryTitles;
288 : }
289 :
290 6 : void SwXAutoTextGroup::renameByName(const OUString& aElementName,
291 : const OUString& aNewElementName, const OUString& aNewElementTitle)
292 : throw( lang::IllegalArgumentException, container::ElementExistException, io::IOException,
293 : uno::RuntimeException, std::exception)
294 : {
295 6 : SolarMutexGuard aGuard;
296 : // throw exception only if the programmatic name is to be changed into an existing name
297 6 : if(aNewElementName != aElementName && hasByName(aNewElementName))
298 2 : throw container::ElementExistException();
299 8 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
300 4 : if(pGlosGroup && !pGlosGroup->GetError())
301 : {
302 4 : sal_uInt16 nIdx = pGlosGroup->GetIndex( aElementName);
303 4 : if(USHRT_MAX == nIdx)
304 2 : throw lang::IllegalArgumentException();
305 2 : OUString aNewShort(aNewElementName);
306 4 : OUString aNewName(aNewElementTitle);
307 2 : sal_uInt16 nOldLongIdx = pGlosGroup->GetLongIndex( aNewShort );
308 2 : sal_uInt16 nOldIdx = pGlosGroup->GetIndex( aNewName );
309 :
310 2 : if( nIdx != USHRT_MAX &&
311 0 : (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&&
312 0 : (nOldIdx == USHRT_MAX || nOldIdx == nIdx ))
313 : {
314 2 : pGlosGroup->Rename( nIdx, &aNewShort, &aNewName );
315 2 : if(pGlosGroup->GetError() != 0)
316 0 : throw io::IOException();
317 2 : }
318 : }
319 : else
320 6 : throw uno::RuntimeException();
321 2 : }
322 :
323 0 : static bool lcl_CopySelToDoc( SwDoc* pInsDoc, OTextCursorHelper* pxCursor, SwXTextRange* pxRange)
324 : {
325 : OSL_ENSURE( pInsDoc, "no InsDoc");
326 :
327 0 : SwNodes& rNds = pInsDoc->GetNodes();
328 :
329 0 : SwNodeIndex aIdx( rNds.GetEndOfContent(), -1 );
330 0 : SwCntntNode * pNd = aIdx.GetNode().GetCntntNode();
331 0 : SwPosition aPos(aIdx, SwIndex(pNd, (pNd) ? pNd->Len() : 0));
332 :
333 0 : bool bRet = false;
334 0 : pInsDoc->getIDocumentFieldsAccess().LockExpFlds();
335 : {
336 0 : SwDoc *const pDoc((pxCursor) ? pxCursor->GetDoc() : pxRange->GetDoc());
337 0 : SwPaM aPam(pDoc->GetNodes());
338 0 : SwPaM * pPam(0);
339 0 : if(pxCursor)
340 : {
341 0 : pPam = pxCursor->GetPaM();
342 : }
343 : else
344 : {
345 0 : if (pxRange->GetPositions(aPam))
346 : {
347 0 : pPam = & aPam;
348 : }
349 : }
350 0 : if (!pPam) { return false; }
351 0 : bRet = pDoc->getIDocumentContentOperations().CopyRange( *pPam, aPos, false ) || bRet;
352 : }
353 :
354 0 : pInsDoc->getIDocumentFieldsAccess().UnlockExpFlds();
355 0 : if( !pInsDoc->getIDocumentFieldsAccess().IsExpFldsLocked() )
356 0 : pInsDoc->getIDocumentFieldsAccess().UpdateExpFlds(NULL, true);
357 :
358 0 : return bRet;
359 : }
360 :
361 12 : uno::Reference< text::XAutoTextEntry > SwXAutoTextGroup::insertNewByName(const OUString& aName,
362 : const OUString& aTitle, const uno::Reference< text::XTextRange > & xTextRange)
363 : throw( container::ElementExistException, uno::RuntimeException, std::exception )
364 : {
365 12 : SolarMutexGuard aGuard;
366 12 : if(hasByName(aName))
367 2 : throw container::ElementExistException();
368 10 : if(!xTextRange.is())
369 0 : throw uno::RuntimeException();
370 :
371 10 : SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0;
372 20 : OUString sShortName(aName);
373 20 : OUString sLongName(aTitle);
374 10 : if (pGlosGroup && !pGlosGroup->GetError())
375 : {
376 10 : uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
377 10 : SwXTextRange* pxRange = 0;
378 10 : OTextCursorHelper* pxCursor = 0;
379 10 : if(xRangeTunnel.is())
380 : {
381 10 : pxRange = reinterpret_cast<SwXTextRange*>(xRangeTunnel->getSomething(
382 10 : SwXTextRange::getUnoTunnelId()));
383 10 : pxCursor = reinterpret_cast<OTextCursorHelper*>(xRangeTunnel->getSomething(
384 10 : OTextCursorHelper::getUnoTunnelId()));
385 : }
386 :
387 20 : OUString sOnlyTxt;
388 10 : OUString* pOnlyTxt = 0;
389 10 : bool bNoAttr = !pxCursor && !pxRange;
390 10 : if(bNoAttr)
391 : {
392 10 : sOnlyTxt = OUString(xTextRange->getString());
393 10 : pOnlyTxt = &sOnlyTxt;
394 : }
395 :
396 10 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
397 :
398 10 : SwDoc* pGDoc = pGlosGroup->GetDoc();
399 :
400 : // Until there is an option for that, delete base util::URL
401 10 : if(rCfg.IsSaveRelFile())
402 : {
403 0 : INetURLObject aTemp(pGlosGroup->GetFileName());
404 0 : pGlosGroup->SetBaseURL( aTemp.GetMainURL(INetURLObject::NO_DECODE));
405 : }
406 : else
407 10 : pGlosGroup->SetBaseURL( OUString() );
408 :
409 10 : sal_uInt16 nRet = USHRT_MAX;
410 10 : if( pOnlyTxt )
411 10 : nRet = pGlosGroup->PutText( sShortName, sLongName, *pOnlyTxt );
412 : else
413 : {
414 0 : pGlosGroup->ClearDoc();
415 0 : if( pGlosGroup->BeginPutDoc( sShortName, sLongName ) )
416 : {
417 0 : pGDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( nsRedlineMode_t::REDLINE_DELETE_REDLINES );
418 0 : lcl_CopySelToDoc( pGDoc, pxCursor, pxRange );
419 0 : pGDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)( 0 ));
420 0 : nRet = pGlosGroup->PutDoc();
421 : }
422 : }
423 :
424 10 : if (nRet == USHRT_MAX)
425 : {
426 0 : throw uno::RuntimeException();
427 10 : }
428 : }
429 10 : delete pGlosGroup;
430 :
431 10 : uno::Reference< text::XAutoTextEntry > xEntry;
432 :
433 : try
434 : {
435 20 : xEntry = pGlossaries ?
436 : pGlossaries->GetAutoTextEntry( m_sGroupName, sName, sShortName, true ) :
437 10 : uno::Reference< text::XAutoTextEntry >();
438 : OSL_ENSURE( xEntry.is(), "SwXAutoTextGroup::insertNewByName: no UNO object created? How this?" );
439 : // we just inserted the entry into the group, so why doesn't it exist?
440 : }
441 0 : catch (const container::ElementExistException&)
442 : {
443 0 : throw;
444 : }
445 0 : catch (const uno::RuntimeException&)
446 : {
447 0 : throw;
448 : }
449 0 : catch (const uno::Exception& e)
450 : {
451 : throw css::lang::WrappedTargetRuntimeException(
452 : "Error Getting AutoText!",
453 : static_cast < OWeakObject * > ( this ),
454 0 : makeAny( e ) );
455 : }
456 :
457 22 : return xEntry;
458 : }
459 :
460 14 : void SwXAutoTextGroup::removeByName(const OUString& aEntryName) throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
461 : {
462 14 : SolarMutexGuard aGuard;
463 28 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
464 14 : if(pGlosGroup && !pGlosGroup->GetError())
465 : {
466 14 : sal_uInt16 nIdx = pGlosGroup->GetIndex(aEntryName);
467 14 : if ( nIdx != USHRT_MAX )
468 10 : pGlosGroup->Delete(nIdx);
469 : }
470 : else
471 14 : throw container::NoSuchElementException();
472 14 : }
473 :
474 58 : OUString SwXAutoTextGroup::getName(void) throw( uno::RuntimeException, std::exception )
475 : {
476 58 : SolarMutexGuard aGuard;
477 58 : return sName;
478 : }
479 :
480 4 : void SwXAutoTextGroup::setName(const OUString& rName) throw( uno::RuntimeException, std::exception )
481 : {
482 4 : SolarMutexGuard aGuard;
483 4 : if( !pGlossaries )
484 0 : throw uno::RuntimeException();
485 :
486 4 : sal_Int32 nNewDelimPos = rName.lastIndexOf( GLOS_DELIM );
487 4 : sal_Int32 nOldDelimPos = sName.lastIndexOf( GLOS_DELIM );
488 :
489 8 : OUString aNewSuffix;
490 4 : if (nNewDelimPos > -1)
491 4 : aNewSuffix = rName.copy( nNewDelimPos + 1 );
492 8 : OUString aOldSuffix;
493 4 : if (nOldDelimPos > -1)
494 4 : aOldSuffix = sName.copy( nOldDelimPos + 1 );
495 :
496 4 : sal_Int32 nNewNumeric = aNewSuffix.toInt32();
497 4 : sal_Int32 nOldNumeric = aOldSuffix.toInt32();
498 :
499 8 : OUString aNewPrefix( (nNewDelimPos > 1) ? rName.copy( 0, nNewDelimPos ) : rName );
500 8 : OUString aOldPrefix( (nOldDelimPos > 1) ? sName.copy( 0, nOldDelimPos ) : sName );
501 :
502 4 : if ( sName == rName ||
503 4 : ( nNewNumeric == nOldNumeric && aNewPrefix == aOldPrefix ) )
504 4 : return;
505 8 : OUString sNewGroup(rName);
506 4 : if (sNewGroup.indexOf(GLOS_DELIM)<0)
507 : {
508 0 : sNewGroup += OUString(GLOS_DELIM) + "0";
509 : }
510 :
511 : //the name must be saved, the group may be invalidated while in RenameGroupDoc()
512 4 : SwGlossaries* pTempGlossaries = pGlossaries;
513 :
514 8 : OUString sPreserveTitle( pGlossaries->GetGroupTitle( sName ) );
515 4 : if ( !pGlossaries->RenameGroupDoc( sName, sNewGroup, sPreserveTitle ) )
516 0 : throw uno::RuntimeException();
517 4 : sName = rName;
518 4 : m_sGroupName = sNewGroup;
519 8 : pGlossaries = pTempGlossaries;
520 : }
521 :
522 2 : sal_Int32 SwXAutoTextGroup::getCount(void) throw( uno::RuntimeException, std::exception )
523 : {
524 2 : SolarMutexGuard aGuard;
525 4 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
526 2 : if (!pGlosGroup || pGlosGroup->GetError())
527 0 : throw uno::RuntimeException();
528 4 : return static_cast<sal_Int32>(pGlosGroup->GetCount());
529 : }
530 :
531 0 : uno::Any SwXAutoTextGroup::getByIndex(sal_Int32 nIndex)
532 : throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
533 : {
534 0 : SolarMutexGuard aGuard;
535 0 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
536 0 : if (!pGlosGroup || pGlosGroup->GetError())
537 0 : throw uno::RuntimeException();
538 0 : const sal_uInt16 nCount = pGlosGroup->GetCount();
539 0 : if (nIndex < 0 || nIndex >= static_cast<sal_Int32>(nCount))
540 0 : throw lang::IndexOutOfBoundsException();
541 0 : return getByName(pGlosGroup->GetShortName(static_cast<sal_uInt16>(nIndex)));
542 : }
543 :
544 0 : uno::Type SwXAutoTextGroup::getElementType(void) throw( uno::RuntimeException, std::exception )
545 : {
546 0 : return cppu::UnoType<text::XAutoTextEntry>::get();
547 :
548 : }
549 :
550 0 : sal_Bool SwXAutoTextGroup::hasElements(void) throw( uno::RuntimeException, std::exception )
551 : {
552 0 : SolarMutexGuard aGuard;
553 0 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
554 0 : if (!pGlosGroup || pGlosGroup->GetError())
555 0 : throw uno::RuntimeException();
556 0 : return pGlosGroup->GetCount() > 0;
557 :
558 : }
559 :
560 4 : uno::Any SwXAutoTextGroup::getByName(const OUString& _rName)
561 : throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
562 : {
563 4 : SolarMutexGuard aGuard;
564 6 : uno::Reference< text::XAutoTextEntry > xEntry = pGlossaries->GetAutoTextEntry( m_sGroupName, sName, _rName, true );
565 : OSL_ENSURE( xEntry.is(), "SwXAutoTextGroup::getByName: GetAutoTextEntry is fractious!" );
566 : // we told it to create the object, so why didn't it?
567 6 : return makeAny( xEntry );
568 : }
569 :
570 10 : uno::Sequence< OUString > SwXAutoTextGroup::getElementNames(void)
571 : throw( uno::RuntimeException, std::exception )
572 : {
573 10 : SolarMutexGuard aGuard;
574 20 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
575 10 : if (!pGlosGroup || pGlosGroup->GetError())
576 0 : throw uno::RuntimeException();
577 :
578 10 : const sal_uInt16 nCount = pGlosGroup->GetCount();
579 10 : uno::Sequence< OUString > aEntryNames(nCount);
580 10 : OUString *pArr = aEntryNames.getArray();
581 :
582 14 : for ( sal_uInt16 i = 0; i < nCount; i++ )
583 4 : pArr[i] = pGlosGroup->GetShortName(i);
584 20 : return aEntryNames;
585 : }
586 :
587 26 : sal_Bool SwXAutoTextGroup::hasByName(const OUString& rName)
588 : throw( uno::RuntimeException, std::exception )
589 : {
590 26 : SolarMutexGuard aGuard;
591 26 : bool bRet = false;
592 52 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
593 26 : if (!pGlosGroup || pGlosGroup->GetError())
594 0 : throw uno::RuntimeException();
595 :
596 26 : const sal_uInt16 nCount = pGlosGroup->GetCount();
597 32 : for( sal_uInt16 i = 0; i < nCount; ++i )
598 : {
599 14 : OUString sCompare(pGlosGroup->GetShortName(i));
600 14 : if(sCompare.equalsIgnoreAsciiCase(rName))
601 : {
602 8 : bRet = true;
603 8 : break;
604 : }
605 6 : }
606 52 : return bRet;
607 : }
608 :
609 0 : uno::Reference< beans::XPropertySetInfo > SwXAutoTextGroup::getPropertySetInfo(void)
610 : throw( uno::RuntimeException, std::exception )
611 : {
612 0 : static uno::Reference< beans::XPropertySetInfo > xRet = pPropSet->getPropertySetInfo();
613 0 : return xRet;
614 : }
615 :
616 0 : void SwXAutoTextGroup::setPropertyValue(
617 : const OUString& rPropertyName, const uno::Any& aValue)
618 : throw( beans::UnknownPropertyException, beans::PropertyVetoException,
619 : lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
620 : {
621 0 : SolarMutexGuard aGuard;
622 0 : const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap().getByName( rPropertyName );
623 :
624 0 : if(!pEntry)
625 0 : throw beans::UnknownPropertyException();
626 :
627 0 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
628 0 : if(!pGlosGroup || pGlosGroup->GetError())
629 0 : throw uno::RuntimeException();
630 0 : switch(pEntry->nWID)
631 : {
632 : case WID_GROUP_TITLE:
633 : {
634 0 : OUString sNewTitle;
635 0 : aValue >>= sNewTitle;
636 0 : if(sNewTitle.isEmpty())
637 0 : throw lang::IllegalArgumentException();
638 0 : bool bChanged = !sNewTitle.equals(pGlosGroup->GetName());
639 0 : pGlosGroup->SetName(sNewTitle);
640 0 : if(bChanged && HasGlossaryList())
641 0 : GetGlossaryList()->ClearGroups();
642 : }
643 0 : break;
644 0 : }
645 0 : }
646 :
647 0 : uno::Any SwXAutoTextGroup::getPropertyValue(const OUString& rPropertyName)
648 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
649 : {
650 0 : SolarMutexGuard aGuard;
651 0 : const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap().getByName( rPropertyName);
652 :
653 0 : if(!pEntry)
654 0 : throw beans::UnknownPropertyException();
655 0 : boost::scoped_ptr<SwTextBlocks> pGlosGroup(pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, false) : 0);
656 0 : if(!pGlosGroup || pGlosGroup->GetError())
657 0 : throw uno::RuntimeException();
658 :
659 0 : uno::Any aAny;
660 0 : switch(pEntry->nWID)
661 : {
662 : case WID_GROUP_PATH:
663 0 : aAny <<= OUString(pGlosGroup->GetFileName());
664 0 : break;
665 : case WID_GROUP_TITLE:
666 0 : aAny <<= OUString(pGlosGroup->GetName());
667 0 : break;
668 : }
669 0 : return aAny;
670 : }
671 :
672 0 : void SwXAutoTextGroup::addPropertyChangeListener(
673 : const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
674 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
675 : {
676 0 : }
677 :
678 0 : void SwXAutoTextGroup::removePropertyChangeListener(
679 : const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
680 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
681 : {
682 0 : }
683 :
684 0 : void SwXAutoTextGroup::addVetoableChangeListener(
685 : const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
686 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
687 : {
688 0 : }
689 :
690 0 : void SwXAutoTextGroup::removeVetoableChangeListener(
691 : const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
692 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
693 : {
694 0 : }
695 :
696 9 : void SwXAutoTextGroup::Invalidate()
697 : {
698 9 : pGlossaries = 0;
699 9 : sName = OUString();
700 9 : m_sGroupName = OUString();
701 9 : }
702 :
703 2 : OUString SwXAutoTextGroup::getImplementationName(void) throw( uno::RuntimeException, std::exception )
704 : {
705 2 : return OUString("SwXAutoTextGroup");
706 : }
707 :
708 0 : sal_Bool SwXAutoTextGroup::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
709 : {
710 0 : return cppu::supportsService(this, rServiceName);
711 : }
712 :
713 0 : uno::Sequence< OUString > SwXAutoTextGroup::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
714 : {
715 0 : uno::Sequence< OUString > aRet(1);
716 0 : OUString* pArray = aRet.getArray();
717 0 : pArray[0] = "com.sun.star.text.AutoTextGroup";
718 0 : return aRet;
719 : }
720 :
721 : namespace
722 : {
723 : class theSwXAutoTextEntryUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXAutoTextEntryUnoTunnelId > {};
724 : }
725 :
726 62 : const uno::Sequence< sal_Int8 > & SwXAutoTextEntry::getUnoTunnelId()
727 : {
728 62 : return theSwXAutoTextEntryUnoTunnelId::get().getSeq();
729 : }
730 :
731 31 : sal_Int64 SAL_CALL SwXAutoTextEntry::getSomething( const uno::Sequence< sal_Int8 >& rId )
732 : throw(uno::RuntimeException, std::exception)
733 : {
734 62 : if( rId.getLength() == 16
735 93 : && 0 == memcmp( getUnoTunnelId().getConstArray(),
736 62 : rId.getConstArray(), 16 ) )
737 : {
738 31 : return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ));
739 : }
740 0 : return 0;
741 : }
742 :
743 6 : SwXAutoTextEntry::SwXAutoTextEntry(SwGlossaries* pGlss, const OUString& rGroupName,
744 : const OUString& rEntryName) :
745 : pGlossaries(pGlss),
746 : sGroupName(rGroupName),
747 : sEntryName(rEntryName),
748 6 : pBodyText ( NULL )
749 : {
750 6 : }
751 :
752 18 : SwXAutoTextEntry::~SwXAutoTextEntry()
753 : {
754 : {
755 6 : SolarMutexGuard aGuard;
756 :
757 : // ensure that any pending modifications are written
758 6 : implFlushDocument( true );
759 :
760 : //! Bug #96559
761 : // DocShell must be cleared before mutex is lost.
762 : // Needs to be done explicitly since xDocSh is a class member.
763 : // Thus, an own block here, guarded by the SolarMutex
764 : }
765 12 : }
766 :
767 13 : void SwXAutoTextEntry::implFlushDocument( bool _bCloseDoc )
768 : {
769 13 : if ( xDocSh.Is() )
770 : {
771 4 : if ( xDocSh->GetDoc()->getIDocumentState().IsModified () )
772 4 : xDocSh->Save();
773 :
774 4 : if ( _bCloseDoc )
775 : {
776 : // stop listening at the document
777 1 : EndListening( *&xDocSh );
778 :
779 1 : xDocSh->DoClose();
780 1 : xDocSh.Clear();
781 : }
782 : }
783 13 : }
784 :
785 57 : void SwXAutoTextEntry::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint )
786 : {
787 57 : if ( &_rBC == &xDocSh )
788 : { // it's our document
789 57 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>( &_rHint );
790 57 : if ( pSimpleHint )
791 : {
792 48 : if ( SFX_HINT_DEINITIALIZING == pSimpleHint->GetId() )
793 : {
794 : // our document is dying (possibly because we're shuting down, and the document was notified
795 : // earlier than we are?)
796 : // stop listening at the docu
797 0 : EndListening( *&xDocSh );
798 : // and release our reference
799 0 : xDocSh.Clear();
800 : }
801 : }
802 9 : else if(dynamic_cast<const SfxEventHint*>(&_rHint))
803 : {
804 9 : if(SFX_EVENT_PREPARECLOSEDOC == static_cast< const SfxEventHint& >( _rHint ).GetEventId())
805 : {
806 1 : implFlushDocument( false );
807 1 : xBodyText = 0;
808 1 : EndListening( *&xDocSh );
809 1 : xDocSh.Clear();
810 : }
811 : }
812 : }
813 57 : }
814 :
815 2 : void SwXAutoTextEntry::GetBodyText ()
816 : {
817 2 : SolarMutexGuard aGuard;
818 :
819 2 : xDocSh = pGlossaries->EditGroupDoc ( sGroupName, sEntryName, false );
820 : OSL_ENSURE( xDocSh.Is(), "SwXAutoTextEntry::GetBodyText: unexpected: no doc returned by EditGroupDoc!" );
821 :
822 : // start listening at the document
823 2 : StartListening( *&xDocSh );
824 :
825 2 : pBodyText = new SwXBodyText ( xDocSh->GetDoc() );
826 2 : xBodyText = uno::Reference < lang::XServiceInfo > ( *pBodyText, uno::UNO_QUERY);
827 2 : }
828 :
829 6 : uno::Reference< text::XTextCursor > SwXAutoTextEntry::createTextCursor(void) throw( uno::RuntimeException, std::exception )
830 : {
831 6 : SolarMutexGuard aGuard;
832 6 : EnsureBodyText();
833 6 : return pBodyText->createTextCursor();
834 : }
835 :
836 2 : uno::Reference< text::XTextCursor > SwXAutoTextEntry::createTextCursorByRange(
837 : const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException, std::exception )
838 : {
839 2 : SolarMutexGuard aGuard;
840 2 : EnsureBodyText();
841 2 : return pBodyText->createTextCursorByRange ( aTextPosition );
842 : }
843 :
844 4 : void SwXAutoTextEntry::insertString(const uno::Reference< text::XTextRange > & xRange, const OUString& aString, sal_Bool bAbsorb) throw( uno::RuntimeException, std::exception )
845 : {
846 4 : SolarMutexGuard aGuard;
847 4 : EnsureBodyText();
848 4 : pBodyText->insertString ( xRange, aString, bAbsorb );
849 4 : }
850 :
851 4 : void SwXAutoTextEntry::insertControlCharacter(const uno::Reference< text::XTextRange > & xRange,
852 : sal_Int16 nControlCharacter, sal_Bool bAbsorb)
853 : throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
854 : {
855 4 : SolarMutexGuard aGuard;
856 4 : EnsureBodyText();
857 4 : pBodyText->insertControlCharacter ( xRange, nControlCharacter, bAbsorb );
858 4 : }
859 :
860 4 : void SwXAutoTextEntry::insertTextContent(
861 : const uno::Reference< text::XTextRange > & xRange,
862 : const uno::Reference< text::XTextContent > & xContent, sal_Bool bAbsorb)
863 : throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
864 : {
865 4 : SolarMutexGuard aGuard;
866 4 : EnsureBodyText();
867 6 : pBodyText->insertTextContent ( xRange, xContent, bAbsorb );
868 2 : }
869 :
870 2 : void SwXAutoTextEntry::removeTextContent(
871 : const uno::Reference< text::XTextContent > & xContent)
872 : throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
873 : {
874 2 : SolarMutexGuard aGuard;
875 2 : EnsureBodyText();
876 2 : pBodyText->removeTextContent ( xContent );
877 2 : }
878 :
879 8 : uno::Reference< text::XText > SwXAutoTextEntry::getText(void) throw( uno::RuntimeException, std::exception )
880 : {
881 8 : SolarMutexGuard aGuard;
882 8 : uno::Reference< text::XText > xRet = (text::XText*)this;
883 8 : return xRet;
884 : }
885 :
886 2 : uno::Reference< text::XTextRange > SwXAutoTextEntry::getStart(void) throw( uno::RuntimeException, std::exception )
887 : {
888 2 : SolarMutexGuard aGuard;
889 2 : EnsureBodyText();
890 2 : return pBodyText->getStart();
891 : }
892 :
893 2 : uno::Reference< text::XTextRange > SwXAutoTextEntry::getEnd(void) throw( uno::RuntimeException, std::exception )
894 : {
895 2 : SolarMutexGuard aGuard;
896 2 : EnsureBodyText();
897 2 : return pBodyText->getEnd();
898 : }
899 :
900 14 : OUString SwXAutoTextEntry::getString(void) throw( uno::RuntimeException, std::exception )
901 : {
902 14 : SolarMutexGuard aGuard;
903 14 : EnsureBodyText();
904 14 : return pBodyText->getString();
905 : }
906 :
907 8 : void SwXAutoTextEntry::setString(const OUString& aString) throw( uno::RuntimeException, std::exception )
908 : {
909 8 : SolarMutexGuard aGuard;
910 8 : EnsureBodyText();
911 8 : pBodyText->setString( aString );
912 8 : }
913 :
914 6 : void SwXAutoTextEntry::applyTo(const uno::Reference< text::XTextRange > & xTextRange)throw( uno::RuntimeException, std::exception )
915 : {
916 6 : SolarMutexGuard aGuard;
917 :
918 : // ensure that any pending modifications are written
919 : // reason is that we're holding the _copy_ of the auto text, while the real auto text
920 : // is stored somewhere. And below, we're not working with our copy, but only tell the target
921 : // TextRange to work with the stored version.
922 : // #96380# - 2003-03-03 - fs@openoffice.org
923 6 : implFlushDocument( false );
924 : // TODO: think about if we should pass "true" here
925 : // The difference would be that when the next modification is made to this instance here, then
926 : // we would be forced to open the document again, instead of working on our current copy.
927 : // This means that we would reflect any changes which were done to the AutoText by foreign instances
928 : // in the meantime
929 :
930 12 : uno::Reference<lang::XUnoTunnel> xTunnel( xTextRange, uno::UNO_QUERY);
931 6 : SwXTextRange* pRange = 0;
932 6 : OTextCursorHelper* pCursor = 0;
933 6 : SwXText *pText = 0;
934 :
935 6 : if(xTunnel.is())
936 : {
937 : pRange = reinterpret_cast < SwXTextRange* >
938 6 : ( xTunnel->getSomething( SwXTextRange::getUnoTunnelId() ) );
939 : pCursor = reinterpret_cast < OTextCursorHelper*>
940 6 : ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) );
941 : pText = reinterpret_cast < SwXText* >
942 6 : ( xTunnel->getSomething( SwXText::getUnoTunnelId() ) );
943 : }
944 :
945 6 : SwDoc* pDoc = 0;
946 6 : if (pRange)
947 0 : pDoc = pRange->GetDoc();
948 6 : else if ( pCursor )
949 4 : pDoc = pCursor->GetDoc();
950 2 : else if ( pText && pText->GetDoc() )
951 : {
952 2 : xTunnel = uno::Reference < lang::XUnoTunnel > (pText->getStart(), uno::UNO_QUERY);
953 2 : if (xTunnel.is())
954 : {
955 : pCursor = reinterpret_cast < OTextCursorHelper* >
956 2 : ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) );
957 2 : if (pCursor)
958 2 : pDoc = pText->GetDoc();
959 : }
960 : }
961 :
962 6 : if(!pDoc)
963 0 : throw uno::RuntimeException();
964 :
965 12 : SwPaM InsertPaM(pDoc->GetNodes());
966 6 : if (pRange)
967 : {
968 0 : if (!pRange->GetPositions(InsertPaM))
969 : {
970 0 : throw uno::RuntimeException();
971 : }
972 : }
973 : else
974 : {
975 6 : InsertPaM = *pCursor->GetPaM();
976 : }
977 :
978 12 : boost::scoped_ptr<SwTextBlocks> pBlock(pGlossaries->GetGroupDoc(sGroupName));
979 12 : const bool bResult = pBlock.get() && !pBlock->GetError()
980 12 : && pDoc->InsertGlossary( *pBlock, sEntryName, InsertPaM);
981 :
982 6 : if(!bResult)
983 6 : throw uno::RuntimeException();
984 6 : }
985 :
986 0 : OUString SwXAutoTextEntry::getImplementationName(void) throw( uno::RuntimeException, std::exception )
987 : {
988 0 : return OUString("SwXAutoTextEntry");
989 : }
990 :
991 0 : sal_Bool SwXAutoTextEntry::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
992 : {
993 0 : return cppu::supportsService(this, rServiceName);
994 : }
995 :
996 0 : uno::Sequence< OUString > SwXAutoTextEntry::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
997 : {
998 0 : uno::Sequence< OUString > aRet(1);
999 0 : OUString* pArray = aRet.getArray();
1000 0 : pArray[0] = "com.sun.star.text.AutoTextEntry";
1001 0 : return aRet;
1002 : }
1003 :
1004 0 : uno::Reference< container::XNameReplace > SwXAutoTextEntry::getEvents()
1005 : throw( uno::RuntimeException, std::exception )
1006 : {
1007 0 : return new SwAutoTextEventDescriptor( *this );
1008 : }
1009 :
1010 : const struct SvEventDescription aAutotextEvents[] =
1011 : {
1012 : { SW_EVENT_START_INS_GLOSSARY, "OnInsertStart" },
1013 : { SW_EVENT_END_INS_GLOSSARY, "OnInsertDone" },
1014 : { 0, NULL }
1015 : };
1016 :
1017 0 : SwAutoTextEventDescriptor::SwAutoTextEventDescriptor(
1018 : SwXAutoTextEntry& rAutoText ) :
1019 : SvBaseEventDescriptor(aAutotextEvents),
1020 : sSwAutoTextEventDescriptor(
1021 : "SwAutoTextEventDescriptor"),
1022 0 : rAutoTextEntry(rAutoText)
1023 : {
1024 0 : }
1025 :
1026 0 : SwAutoTextEventDescriptor::~SwAutoTextEventDescriptor()
1027 : {
1028 0 : }
1029 :
1030 0 : OUString SwAutoTextEventDescriptor::getImplementationName()
1031 : throw( uno::RuntimeException, std::exception )
1032 : {
1033 0 : return sSwAutoTextEventDescriptor;
1034 : }
1035 :
1036 0 : void SwAutoTextEventDescriptor::replaceByName(
1037 : const sal_uInt16 nEvent,
1038 : const SvxMacro& rMacro)
1039 : throw(
1040 : lang::IllegalArgumentException,
1041 : container::NoSuchElementException,
1042 : lang::WrappedTargetException,
1043 : uno::RuntimeException)
1044 : {
1045 : OSL_ENSURE( NULL != rAutoTextEntry.GetGlossaries(),
1046 : "Strangely enough, the AutoText vanished!" );
1047 : OSL_ENSURE( (nEvent == SW_EVENT_END_INS_GLOSSARY) ||
1048 : (nEvent == SW_EVENT_START_INS_GLOSSARY) ,
1049 : "Unknown event ID" );
1050 :
1051 : SwGlossaries *const pGlossaries =
1052 0 : const_cast<SwGlossaries*>(rAutoTextEntry.GetGlossaries());
1053 : boost::scoped_ptr<SwTextBlocks> pBlocks(
1054 0 : pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() ));
1055 : OSL_ENSURE( pBlocks,
1056 : "can't get autotext group; SwAutoTextEntry has illegal name?");
1057 :
1058 0 : if( pBlocks && !pBlocks->GetError())
1059 : {
1060 0 : sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() );
1061 0 : if( nIndex != USHRT_MAX )
1062 : {
1063 0 : SvxMacroTableDtor aMacroTable;
1064 0 : if( pBlocks->GetMacroTable( nIndex, aMacroTable ) )
1065 : {
1066 0 : aMacroTable.Insert( nEvent, rMacro );
1067 0 : pBlocks->SetMacroTable( nIndex, aMacroTable );
1068 0 : }
1069 : }
1070 0 : }
1071 : // else: ignore
1072 0 : }
1073 :
1074 0 : void SwAutoTextEventDescriptor::getByName(
1075 : SvxMacro& rMacro,
1076 : const sal_uInt16 nEvent )
1077 : throw(
1078 : container::NoSuchElementException,
1079 : lang::WrappedTargetException,
1080 : uno::RuntimeException)
1081 : {
1082 : OSL_ENSURE( NULL != rAutoTextEntry.GetGlossaries(), "no AutoText" );
1083 : OSL_ENSURE( (nEvent == SW_EVENT_END_INS_GLOSSARY) ||
1084 : (nEvent == SW_EVENT_START_INS_GLOSSARY) ,
1085 : "Unknown event ID" );
1086 :
1087 : SwGlossaries *const pGlossaries =
1088 0 : const_cast<SwGlossaries*>(rAutoTextEntry.GetGlossaries());
1089 : boost::scoped_ptr<SwTextBlocks> pBlocks(
1090 0 : pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() ));
1091 : OSL_ENSURE( pBlocks,
1092 : "can't get autotext group; SwAutoTextEntry has illegal name?");
1093 :
1094 : // return empty macro, unless macro is found
1095 0 : OUString sEmptyStr;
1096 0 : SvxMacro aEmptyMacro(sEmptyStr, sEmptyStr);
1097 0 : rMacro = aEmptyMacro;
1098 :
1099 0 : if ( pBlocks && !pBlocks->GetError())
1100 : {
1101 0 : sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() );
1102 0 : if( nIndex != USHRT_MAX )
1103 : {
1104 0 : SvxMacroTableDtor aMacroTable;
1105 0 : if( pBlocks->GetMacroTable( nIndex, aMacroTable ) )
1106 : {
1107 0 : SvxMacro *pMacro = aMacroTable.Get( nEvent );
1108 0 : if( pMacro )
1109 0 : rMacro = *pMacro;
1110 0 : }
1111 : }
1112 0 : }
1113 270 : }
1114 :
1115 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
