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