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 <unotextmarkup.hxx>
21 :
22 : #include <osl/mutex.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <SwSmartTagMgr.hxx>
25 : #include <com/sun/star/text/TextMarkupType.hpp>
26 : #include <com/sun/star/text/TextMarkupDescriptor.hpp>
27 : #include <com/sun/star/container/XStringKeyMap.hpp>
28 : #include <ndtxt.hxx>
29 : #include <SwGrammarMarkUp.hxx>
30 :
31 : #include <IGrammarContact.hxx>
32 :
33 : #include <com/sun/star/lang/XUnoTunnel.hpp>
34 : #include <com/sun/star/text/XTextRange.hpp>
35 :
36 : #include <pam.hxx>
37 :
38 : #include <unotextrange.hxx>
39 : #include <unotextcursor.hxx>
40 :
41 : using namespace ::com::sun::star;
42 :
43 0 : struct SwXTextMarkup::Impl
44 : : public SwClient
45 : {
46 : SwTextNode* m_pTextNode;
47 : ModelToViewHelper const m_ConversionMap;
48 :
49 0 : Impl(SwTextNode *const pTextNode, const ModelToViewHelper& rMap)
50 : : SwClient(pTextNode)
51 : , m_pTextNode(pTextNode)
52 0 : , m_ConversionMap(rMap)
53 : {
54 0 : }
55 :
56 : // SwClient
57 : virtual void Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) SAL_OVERRIDE;
58 : };
59 :
60 0 : SwXTextMarkup::SwXTextMarkup(
61 : SwTextNode *const pTextNode, const ModelToViewHelper& rMap)
62 0 : : m_pImpl(new Impl(pTextNode, rMap))
63 : {
64 0 : }
65 :
66 0 : SwXTextMarkup::~SwXTextMarkup()
67 : {
68 0 : }
69 :
70 0 : SwTextNode* SwXTextMarkup::GetTextNode()
71 : {
72 0 : return m_pImpl->m_pTextNode;
73 : }
74 :
75 0 : void SwXTextMarkup::ClearTextNode()
76 : {
77 0 : m_pImpl->m_pTextNode = nullptr;
78 0 : }
79 :
80 0 : const ModelToViewHelper& SwXTextMarkup::GetConversionMap()
81 : {
82 0 : return m_pImpl->m_ConversionMap;
83 : }
84 :
85 0 : uno::Reference< container::XStringKeyMap > SAL_CALL SwXTextMarkup::getMarkupInfoContainer() throw (uno::RuntimeException, std::exception)
86 : {
87 0 : SolarMutexGuard aGuard;
88 :
89 0 : uno::Reference< container::XStringKeyMap > xProp = new SwXStringKeyMap;
90 0 : return xProp;
91 : }
92 :
93 0 : void SAL_CALL SwXTextMarkup::commitTextRangeMarkup(::sal_Int32 nType, const OUString & aIdentifier, const uno::Reference< text::XTextRange> & xRange,
94 : const uno::Reference< container::XStringKeyMap > & xMarkupInfoContainer) throw (uno::RuntimeException, std::exception)
95 : {
96 0 : SolarMutexGuard aGuard;
97 :
98 0 : uno::Reference<lang::XUnoTunnel> xRangeTunnel( xRange, uno::UNO_QUERY);
99 :
100 0 : if(!xRangeTunnel.is()) return;
101 :
102 0 : SwXTextRange* pRange = 0;
103 0 : OTextCursorHelper* pCursor = 0;
104 :
105 0 : if(xRangeTunnel.is())
106 : {
107 0 : pRange = reinterpret_cast<SwXTextRange*>( sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething(SwXTextRange::getUnoTunnelId())));
108 0 : pCursor = reinterpret_cast<OTextCursorHelper*>( sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething(OTextCursorHelper::getUnoTunnelId())));
109 : }
110 :
111 0 : if (pRange)
112 : {
113 0 : SwDoc* pDoc = reinterpret_cast<SwDoc*>(pRange->GetDoc());
114 :
115 0 : if (!pDoc) return;
116 :
117 0 : SwUnoInternalPaM aPam(*pDoc);
118 :
119 0 : ::sw::XTextRangeToSwPaM(aPam, xRange);
120 :
121 0 : SwPosition* startPos = aPam.Start();
122 0 : SwPosition* endPos = aPam.End();
123 :
124 0 : commitStringMarkup (nType, aIdentifier, startPos->nContent.GetIndex(), endPos->nContent.GetIndex() - startPos->nContent.GetIndex(), xMarkupInfoContainer);
125 : }
126 0 : else if (pCursor)
127 : {
128 0 : SwPaM & rPam(*pCursor->GetPaM());
129 :
130 0 : SwPosition* startPos = rPam.Start();
131 0 : SwPosition* endPos = rPam.End();
132 :
133 0 : commitStringMarkup (nType, aIdentifier, startPos->nContent.GetIndex(), endPos->nContent.GetIndex() - startPos->nContent.GetIndex(), xMarkupInfoContainer);
134 0 : }
135 : }
136 :
137 0 : void SAL_CALL SwXTextMarkup::commitStringMarkup(
138 : ::sal_Int32 nType,
139 : const OUString & rIdentifier,
140 : ::sal_Int32 nStart,
141 : ::sal_Int32 nLength,
142 : const uno::Reference< container::XStringKeyMap > & xMarkupInfoContainer)
143 : throw (uno::RuntimeException, std::exception)
144 : {
145 0 : SolarMutexGuard aGuard;
146 :
147 : // paragraph already dead or modified?
148 0 : if (!m_pImpl->m_pTextNode || nLength <= 0)
149 0 : return;
150 :
151 0 : if ( nType == text::TextMarkupType::SMARTTAG &&
152 0 : !SwSmartTagMgr::Get().IsSmartTagTypeEnabled( rIdentifier ) )
153 0 : return;
154 :
155 : // get appropriate list to use...
156 0 : SwWrongList* pWList = 0;
157 0 : bool bRepaint = false;
158 0 : if ( nType == text::TextMarkupType::SPELLCHECK )
159 : {
160 0 : pWList = m_pImpl->m_pTextNode->GetWrong();
161 0 : if ( !pWList )
162 : {
163 0 : pWList = new SwWrongList( WRONGLIST_SPELL );
164 0 : m_pImpl->m_pTextNode->SetWrong( pWList );
165 : }
166 : }
167 0 : else if ( nType == text::TextMarkupType::PROOFREADING || nType == text::TextMarkupType::SENTENCE )
168 : {
169 0 : IGrammarContact *pGrammarContact = getGrammarContact(*m_pImpl->m_pTextNode);
170 0 : if( pGrammarContact )
171 : {
172 0 : pWList = pGrammarContact->getGrammarCheck(*m_pImpl->m_pTextNode, true);
173 : OSL_ENSURE( pWList, "GrammarContact _has_ to deliver a wrong list" );
174 : }
175 : else
176 : {
177 0 : pWList = m_pImpl->m_pTextNode->GetGrammarCheck();
178 0 : if ( !pWList )
179 : {
180 0 : m_pImpl->m_pTextNode->SetGrammarCheck( new SwGrammarMarkUp() );
181 0 : pWList = m_pImpl->m_pTextNode->GetGrammarCheck();
182 : }
183 : }
184 0 : bRepaint = pWList == m_pImpl->m_pTextNode->GetGrammarCheck();
185 0 : if( pWList->GetBeginInv() < COMPLETE_STRING )
186 0 : static_cast<SwGrammarMarkUp*>(pWList)->ClearGrammarList();
187 : }
188 0 : else if ( nType == text::TextMarkupType::SMARTTAG )
189 : {
190 0 : pWList = m_pImpl->m_pTextNode->GetSmartTags();
191 0 : if ( !pWList )
192 : {
193 0 : pWList = new SwWrongList( WRONGLIST_SMARTTAG );
194 0 : m_pImpl->m_pTextNode->SetSmartTags( pWList );
195 : }
196 : }
197 : else
198 : {
199 : OSL_FAIL( "Unknown mark-up type" );
200 0 : return;
201 : }
202 :
203 : const ModelToViewHelper::ModelPosition aStartPos =
204 0 : m_pImpl->m_ConversionMap.ConvertToModelPosition( nStart );
205 : const ModelToViewHelper::ModelPosition aEndPos =
206 0 : m_pImpl->m_ConversionMap.ConvertToModelPosition( nStart + nLength - 1);
207 :
208 0 : const bool bStartInField = aStartPos.mbIsField;
209 0 : const bool bEndInField = aEndPos.mbIsField;
210 0 : bool bCommit = false;
211 :
212 0 : if ( bStartInField && bEndInField && aStartPos.mnPos == aEndPos.mnPos )
213 : {
214 0 : nStart = aStartPos.mnSubPos;
215 0 : const sal_Int32 nFieldPosModel = aStartPos.mnPos;
216 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
217 :
218 0 : SwWrongList* pSubList = pWList->SubList( nInsertPos );
219 0 : if ( !pSubList )
220 : {
221 0 : if( nType == text::TextMarkupType::PROOFREADING || nType == text::TextMarkupType::SENTENCE )
222 0 : pSubList = new SwGrammarMarkUp();
223 : else
224 0 : pSubList = new SwWrongList( pWList->GetWrongListType() );
225 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
226 : }
227 :
228 0 : pWList = pSubList;
229 0 : bCommit = true;
230 : }
231 0 : else if ( !bStartInField && !bEndInField )
232 : {
233 0 : nStart = aStartPos.mnPos;
234 0 : bCommit = true;
235 0 : nLength = aEndPos.mnPos + 1 - aStartPos.mnPos;
236 : }
237 0 : else if( nType == text::TextMarkupType::PROOFREADING || nType == text::TextMarkupType::SENTENCE )
238 : {
239 0 : bCommit = true;
240 0 : nStart = aStartPos.mnPos;
241 0 : sal_Int32 nEnd = aEndPos.mnPos;
242 0 : if( bStartInField && nType != text::TextMarkupType::SENTENCE )
243 : {
244 0 : const sal_Int32 nFieldPosModel = aStartPos.mnPos;
245 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
246 0 : SwWrongList* pSubList = pWList->SubList( nInsertPos );
247 0 : if ( !pSubList )
248 : {
249 0 : pSubList = new SwGrammarMarkUp();
250 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
251 : }
252 : const sal_Int32 nTmpStart =
253 0 : m_pImpl->m_ConversionMap.ConvertToViewPosition(aStartPos.mnPos);
254 : const sal_Int32 nTmpLen =
255 0 : m_pImpl->m_ConversionMap.ConvertToViewPosition(aStartPos.mnPos + 1)
256 0 : - nTmpStart - aStartPos.mnSubPos;
257 0 : if( nTmpLen > 0 )
258 : {
259 0 : pSubList->Insert( rIdentifier, xMarkupInfoContainer, aStartPos.mnSubPos, nTmpLen );
260 : }
261 0 : ++nStart;
262 : }
263 0 : if( bEndInField && nType != text::TextMarkupType::SENTENCE )
264 : {
265 0 : const sal_Int32 nFieldPosModel = aEndPos.mnPos;
266 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
267 0 : SwWrongList* pSubList = pWList->SubList( nInsertPos );
268 0 : if ( !pSubList )
269 : {
270 0 : pSubList = new SwGrammarMarkUp();
271 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
272 : }
273 0 : const sal_Int32 nTmpLen = aEndPos.mnSubPos + 1;
274 0 : pSubList->Insert( rIdentifier, xMarkupInfoContainer, 0, nTmpLen );
275 : }
276 : else
277 0 : ++nEnd;
278 0 : if( nEnd > nStart )
279 0 : nLength = nEnd - nStart;
280 : else
281 0 : bCommit = false;
282 : }
283 :
284 0 : if ( bCommit )
285 : {
286 0 : if( nType == text::TextMarkupType::SENTENCE )
287 0 : static_cast<SwGrammarMarkUp*>(pWList)->setSentence( nStart );
288 : else
289 0 : pWList->Insert( rIdentifier, xMarkupInfoContainer, nStart, nLength );
290 : }
291 :
292 0 : if( bRepaint )
293 0 : finishGrammarCheck(*m_pImpl->m_pTextNode);
294 : }
295 :
296 0 : static void lcl_commitGrammarMarkUp(
297 : const ModelToViewHelper& rConversionMap,
298 : SwGrammarMarkUp* pWList,
299 : ::sal_Int32 nType,
300 : const OUString & rIdentifier,
301 : ::sal_Int32 nStart,
302 : ::sal_Int32 nLength,
303 : const uno::Reference< container::XStringKeyMap > & xMarkupInfoContainer)
304 : {
305 : OSL_ENSURE( nType == text::TextMarkupType::PROOFREADING || nType == text::TextMarkupType::SENTENCE, "Wrong mark-up type" );
306 : const ModelToViewHelper::ModelPosition aStartPos =
307 0 : rConversionMap.ConvertToModelPosition( nStart );
308 : const ModelToViewHelper::ModelPosition aEndPos =
309 0 : rConversionMap.ConvertToModelPosition( nStart + nLength - 1);
310 :
311 0 : const bool bStartInField = aStartPos.mbIsField;
312 0 : const bool bEndInField = aEndPos.mbIsField;
313 0 : bool bCommit = false;
314 :
315 0 : if ( bStartInField && bEndInField && aStartPos.mnPos == aEndPos.mnPos )
316 : {
317 0 : nStart = aStartPos.mnSubPos;
318 0 : const sal_Int32 nFieldPosModel = aStartPos.mnPos;
319 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
320 :
321 0 : SwGrammarMarkUp* pSubList = static_cast<SwGrammarMarkUp*>(pWList->SubList( nInsertPos ));
322 0 : if ( !pSubList )
323 : {
324 0 : pSubList = new SwGrammarMarkUp();
325 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
326 : }
327 :
328 0 : pWList = pSubList;
329 0 : bCommit = true;
330 : }
331 0 : else if ( !bStartInField && !bEndInField )
332 : {
333 0 : nStart = aStartPos.mnPos;
334 0 : bCommit = true;
335 0 : nLength = aEndPos.mnPos + 1 - aStartPos.mnPos;
336 : }
337 : else
338 : {
339 0 : bCommit = true;
340 0 : nStart = aStartPos.mnPos;
341 0 : sal_Int32 nEnd = aEndPos.mnPos;
342 0 : if( bStartInField && nType != text::TextMarkupType::SENTENCE )
343 : {
344 0 : const sal_Int32 nFieldPosModel = aStartPos.mnPos;
345 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
346 0 : SwGrammarMarkUp* pSubList = static_cast<SwGrammarMarkUp*>(pWList->SubList( nInsertPos ));
347 0 : if ( !pSubList )
348 : {
349 0 : pSubList = new SwGrammarMarkUp();
350 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
351 : }
352 0 : const sal_Int32 nTmpStart = rConversionMap.ConvertToViewPosition( aStartPos.mnPos );
353 0 : const sal_Int32 nTmpLen = rConversionMap.ConvertToViewPosition( aStartPos.mnPos + 1 )
354 0 : - nTmpStart - aStartPos.mnSubPos;
355 0 : if( nTmpLen > 0 )
356 0 : pSubList->Insert( rIdentifier, xMarkupInfoContainer, aStartPos.mnSubPos, nTmpLen );
357 0 : ++nStart;
358 : }
359 0 : if( bEndInField && nType != text::TextMarkupType::SENTENCE )
360 : {
361 0 : const sal_Int32 nFieldPosModel = aEndPos.mnPos;
362 0 : const sal_uInt16 nInsertPos = pWList->GetWrongPos( nFieldPosModel );
363 0 : SwGrammarMarkUp* pSubList = static_cast<SwGrammarMarkUp*>(pWList->SubList( nInsertPos ));
364 0 : if ( !pSubList )
365 : {
366 0 : pSubList = new SwGrammarMarkUp();
367 0 : pWList->InsertSubList( nFieldPosModel, 1, nInsertPos, pSubList );
368 : }
369 0 : const sal_Int32 nTmpLen = aEndPos.mnSubPos + 1;
370 0 : pSubList->Insert( rIdentifier, xMarkupInfoContainer, 0, nTmpLen );
371 : }
372 : else
373 0 : ++nEnd;
374 0 : if( nEnd > nStart )
375 0 : nLength = nEnd - nStart;
376 : else
377 0 : bCommit = false;
378 : }
379 :
380 0 : if ( bCommit )
381 : {
382 0 : if( nType == text::TextMarkupType::SENTENCE )
383 0 : static_cast<SwGrammarMarkUp*>(pWList)->setSentence( nStart+nLength );
384 : else
385 0 : pWList->Insert( rIdentifier, xMarkupInfoContainer, nStart, nLength );
386 : }
387 0 : }
388 :
389 0 : void SAL_CALL SwXTextMarkup::commitMultiTextMarkup(
390 : const uno::Sequence< text::TextMarkupDescriptor > &rMarkups )
391 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
392 : {
393 0 : SolarMutexGuard aGuard;
394 :
395 : // paragraph already dead or modified?
396 0 : if (!m_pImpl->m_pTextNode)
397 0 : return;
398 :
399 : // check for equal length of all sequnces
400 0 : sal_Int32 nLen = rMarkups.getLength();
401 :
402 : // for grammar checking there should be exactly one sentence markup
403 : // and 0..n grammar markups.
404 : // Different markups are not expected but may be applied anyway since
405 : // that should be no problem...
406 : // but it has to be implemented, at the moment only this function is for
407 : // grammar markups and sentence markup only!
408 0 : sal_Int32 nSentenceMarkUpIndex = -1;
409 0 : const text::TextMarkupDescriptor *pMarkups = rMarkups.getConstArray();
410 : sal_Int32 i;
411 0 : for( i = 0; i < nLen; ++i )
412 : {
413 0 : if (pMarkups[i].nType == text::TextMarkupType::SENTENCE)
414 : {
415 0 : if (nSentenceMarkUpIndex == -1)
416 0 : nSentenceMarkUpIndex = i;
417 : else // there is already one sentence markup
418 0 : throw lang::IllegalArgumentException();
419 : }
420 0 : else if( pMarkups[i].nType != text::TextMarkupType::PROOFREADING )
421 0 : return;
422 : }
423 :
424 0 : if( nSentenceMarkUpIndex == -1 )
425 0 : return;
426 :
427 : // get appropriate list to use...
428 0 : SwGrammarMarkUp* pWList = 0;
429 0 : bool bRepaint = false;
430 0 : IGrammarContact *pGrammarContact = getGrammarContact(*m_pImpl->m_pTextNode);
431 0 : if( pGrammarContact )
432 : {
433 0 : pWList = pGrammarContact->getGrammarCheck(*m_pImpl->m_pTextNode, true);
434 : OSL_ENSURE( pWList, "GrammarContact _has_ to deliver a wrong list" );
435 : }
436 : else
437 : {
438 0 : pWList = m_pImpl->m_pTextNode->GetGrammarCheck();
439 0 : if ( !pWList )
440 : {
441 0 : m_pImpl->m_pTextNode->SetGrammarCheck( new SwGrammarMarkUp() );
442 0 : pWList = m_pImpl->m_pTextNode->GetGrammarCheck();
443 0 : pWList->SetInvalid( 0, COMPLETE_STRING );
444 : }
445 : }
446 0 : bRepaint = pWList == m_pImpl->m_pTextNode->GetGrammarCheck();
447 :
448 0 : bool bAcceptGrammarError = false;
449 0 : if( pWList->GetBeginInv() < COMPLETE_STRING )
450 : {
451 : const ModelToViewHelper::ModelPosition aSentenceEnd =
452 0 : m_pImpl->m_ConversionMap.ConvertToModelPosition(
453 0 : pMarkups[nSentenceMarkUpIndex].nOffset + pMarkups[nSentenceMarkUpIndex].nLength );
454 0 : bAcceptGrammarError = aSentenceEnd.mnPos > pWList->GetBeginInv();
455 0 : pWList->ClearGrammarList( aSentenceEnd.mnPos );
456 : }
457 :
458 0 : if( bAcceptGrammarError )
459 : {
460 0 : for( i = 0; i < nLen; ++i )
461 : {
462 0 : const text::TextMarkupDescriptor &rDesc = pMarkups[i];
463 0 : lcl_commitGrammarMarkUp(m_pImpl->m_ConversionMap, pWList, rDesc.nType,
464 0 : rDesc.aIdentifier, rDesc.nOffset, rDesc.nLength, rDesc.xMarkupInfoContainer );
465 : }
466 : }
467 : else
468 : {
469 0 : bRepaint = false;
470 0 : i = nSentenceMarkUpIndex;
471 0 : const text::TextMarkupDescriptor &rDesc = pMarkups[i];
472 0 : lcl_commitGrammarMarkUp(m_pImpl->m_ConversionMap, pWList, rDesc.nType,
473 0 : rDesc.aIdentifier, rDesc.nOffset, rDesc.nLength, rDesc.xMarkupInfoContainer );
474 : }
475 :
476 0 : if( bRepaint )
477 0 : finishGrammarCheck(*m_pImpl->m_pTextNode);
478 :
479 0 : return;
480 : }
481 :
482 0 : void SwXTextMarkup::Impl::Modify( const SfxPoolItem* /*pOld*/, const SfxPoolItem* /*pNew*/ )
483 : {
484 : DBG_TESTSOLARMUTEX();
485 :
486 0 : if ( GetRegisteredIn() )
487 0 : GetRegisteredInNonConst()->Remove( this );
488 :
489 0 : m_pTextNode = 0;
490 0 : }
491 :
492 0 : SwXStringKeyMap::SwXStringKeyMap()
493 : {
494 0 : }
495 :
496 0 : uno::Any SAL_CALL SwXStringKeyMap::getValue(const OUString & aKey) throw (uno::RuntimeException, container::NoSuchElementException, std::exception)
497 : {
498 0 : std::map< OUString, uno::Any >::const_iterator aIter = maMap.find( aKey );
499 0 : if ( aIter == maMap.end() )
500 0 : throw container::NoSuchElementException();
501 :
502 0 : return (*aIter).second;
503 : }
504 :
505 0 : sal_Bool SAL_CALL SwXStringKeyMap::hasValue(const OUString & aKey) throw (uno::RuntimeException, std::exception)
506 : {
507 0 : return maMap.find( aKey ) != maMap.end();
508 : }
509 :
510 0 : void SAL_CALL SwXStringKeyMap::insertValue(const OUString & aKey, const uno::Any & aValue) throw (uno::RuntimeException, lang::IllegalArgumentException, container::ElementExistException, std::exception)
511 : {
512 0 : std::map< OUString, uno::Any >::const_iterator aIter = maMap.find( aKey );
513 0 : if ( aIter != maMap.end() )
514 0 : throw container::ElementExistException();
515 :
516 0 : maMap[ aKey ] = aValue;
517 0 : }
518 :
519 0 : ::sal_Int32 SAL_CALL SwXStringKeyMap::getCount() throw (uno::RuntimeException, std::exception)
520 : {
521 0 : return maMap.size();
522 : }
523 :
524 0 : OUString SAL_CALL SwXStringKeyMap::getKeyByIndex(::sal_Int32 nIndex) throw (uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception)
525 : {
526 0 : if ( (sal_uInt32)nIndex >= maMap.size() )
527 0 : throw lang::IndexOutOfBoundsException();
528 :
529 0 : return OUString();
530 : }
531 :
532 0 : uno::Any SAL_CALL SwXStringKeyMap::getValueByIndex(::sal_Int32 nIndex) throw (uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception)
533 : {
534 0 : if ( (sal_uInt32)nIndex >= maMap.size() )
535 0 : throw lang::IndexOutOfBoundsException();
536 :
537 0 : return uno::Any();
538 177 : }
539 :
540 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
