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