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 <hintids.hxx>
21 : #include <editeng/wghtitem.hxx>
22 : #include <editeng/adjustitem.hxx>
23 : #ifndef __RSC //autogen
24 : #include <tools/errinf.hxx>
25 : #endif
26 : #include <vcl/msgbox.hxx>
27 : #include <svl/macitem.hxx>
28 : #include <sfx2/fcontnr.hxx>
29 : #include <sfx2/docfile.hxx>
30 : #include <svl/urihelper.hxx>
31 : #include <unotools/transliterationwrapper.hxx>
32 : #include <poolfmt.hxx>
33 : #include <fmtcol.hxx>
34 : #include <docary.hxx>
35 : #include <wrtsh.hxx>
36 : #include <uitool.hxx>
37 : #include <view.hxx>
38 : #include <swevent.hxx>
39 : #include <gloshdl.hxx>
40 : #include <glosdoc.hxx>
41 : #include <shellio.hxx>
42 : #include <swundo.hxx>
43 : #include <expfld.hxx>
44 : #include <initui.hxx>
45 : #include <gloslst.hxx>
46 : #include <swdtflvr.hxx>
47 : #include <docsh.hxx>
48 : #include <crsskip.hxx>
49 :
50 : #include <dochdl.hrc>
51 : #include <swerror.h>
52 : #include <frmmgr.hxx>
53 : #include <vcl/layout.hxx>
54 : #include <vcl/lstbox.hxx>
55 :
56 : #include <editeng/acorrcfg.hxx>
57 : #include "swabstdlg.hxx"
58 : #include <misc.hrc>
59 :
60 : #include <IDocumentFieldsAccess.hxx>
61 : #include <boost/scoped_ptr.hpp>
62 :
63 : using namespace ::com::sun::star;
64 :
65 : const short RET_EDIT = 100;
66 :
67 0 : struct TextBlockInfo_Impl
68 : {
69 : OUString sTitle;
70 : OUString sLongName;
71 : OUString sGroupName;
72 : };
73 : typedef boost::ptr_vector<TextBlockInfo_Impl> TextBlockInfoArr;
74 :
75 : // Dialog for edit templates
76 0 : void SwGlossaryHdl::GlossaryDlg()
77 : {
78 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
79 : assert(pFact && "Dialog creation failed!");
80 0 : boost::scoped_ptr<AbstractGlossaryDlg> pDlg(pFact->CreateGlossaryDlg(pViewFrame, this, pWrtShell));
81 : assert(pDlg && "Dialog creation failed!");
82 0 : OUString sName;
83 0 : OUString sShortName;
84 :
85 0 : if( RET_EDIT == pDlg->Execute() )
86 : {
87 0 : sName = pDlg->GetCurrGrpName();
88 0 : sShortName = pDlg->GetCurrShortName();
89 : }
90 :
91 0 : pDlg.reset();
92 0 : DELETEZ(pCurGrp);
93 0 : if(HasGlossaryList())
94 : {
95 0 : GetGlossaryList()->ClearGroups();
96 : }
97 :
98 0 : if( !sName.isEmpty() || !sShortName.isEmpty() )
99 0 : rStatGlossaries.EditGroupDoc( sName, sShortName );
100 0 : }
101 :
102 : // set the default group; if called from the dialog
103 : // the group is created temporarily for faster access
104 0 : void SwGlossaryHdl::SetCurGroup(const OUString &rGrp, bool bApi, bool bAlwaysCreateNew )
105 : {
106 0 : OUString sGroup(rGrp);
107 0 : if (sGroup.indexOf(GLOS_DELIM)<0 && !FindGroupName(sGroup))
108 : {
109 0 : sGroup += OUStringLiteral1<GLOS_DELIM>() + "0";
110 : }
111 0 : if(pCurGrp)
112 : {
113 0 : bool bPathEqual = false;
114 0 : if(!bAlwaysCreateNew)
115 : {
116 0 : INetURLObject aTemp( pCurGrp->GetFileName() );
117 0 : const OUString sCurBase = aTemp.getBase();
118 0 : aTemp.removeSegment();
119 0 : const OUString sCurEntryPath = aTemp.GetMainURL(INetURLObject::NO_DECODE);
120 0 : const std::vector<OUString> & rPathArr = rStatGlossaries.GetPathArray();
121 0 : sal_uInt16 nCurrentPath = USHRT_MAX;
122 0 : for (size_t nPath = 0; nPath < rPathArr.size(); ++nPath)
123 : {
124 0 : if (sCurEntryPath == rPathArr[nPath])
125 : {
126 0 : nCurrentPath = static_cast<sal_uInt16>(nPath);
127 0 : break;
128 : }
129 : }
130 0 : const OUString sPath = sGroup.getToken(1, GLOS_DELIM);
131 0 : sal_uInt16 nComparePath = (sal_uInt16)sPath.toInt32();
132 0 : if(nCurrentPath == nComparePath &&
133 0 : sGroup.getToken(0, GLOS_DELIM) == sCurBase)
134 0 : bPathEqual = true;
135 : }
136 :
137 : // When path changed, the name is not reliable
138 0 : if(!bAlwaysCreateNew && bPathEqual)
139 0 : return;
140 : }
141 0 : aCurGrp = sGroup;
142 0 : if(!bApi)
143 : {
144 0 : delete pCurGrp;
145 0 : pCurGrp = rStatGlossaries.GetGroupDoc(aCurGrp, true);
146 0 : }
147 : }
148 :
149 0 : size_t SwGlossaryHdl::GetGroupCnt() const
150 : {
151 0 : return rStatGlossaries.GetGroupCnt();
152 : }
153 :
154 0 : OUString SwGlossaryHdl::GetGroupName( size_t nId, OUString* pTitle )
155 : {
156 0 : OUString sRet = rStatGlossaries.GetGroupName(nId);
157 0 : if(pTitle)
158 : {
159 0 : SwTextBlocks* pGroup = rStatGlossaries.GetGroupDoc(sRet, false);
160 0 : if (pGroup && !pGroup->GetError())
161 : {
162 0 : *pTitle = pGroup->GetName();
163 0 : if (pTitle->isEmpty())
164 : {
165 0 : *pTitle = sRet.getToken(0, GLOS_DELIM);
166 0 : pGroup->SetName(*pTitle);
167 : }
168 0 : delete pGroup;
169 : }
170 : else
171 : {
172 0 : delete pGroup;
173 0 : sRet.clear();
174 : }
175 : }
176 0 : return sRet;
177 : }
178 :
179 0 : bool SwGlossaryHdl::NewGroup(OUString &rGrpName, const OUString& rTitle)
180 : {
181 0 : if (rGrpName.indexOf(GLOS_DELIM)<0)
182 0 : FindGroupName(rGrpName);
183 0 : return rStatGlossaries.NewGroupDoc(rGrpName, rTitle);
184 : }
185 :
186 0 : bool SwGlossaryHdl::RenameGroup(const OUString& rOld, OUString& rNew, const OUString& rNewTitle)
187 : {
188 0 : bool bRet = false;
189 0 : OUString sOldGroup(rOld);
190 0 : if (rOld.indexOf(GLOS_DELIM)<0)
191 0 : FindGroupName(sOldGroup);
192 0 : if(rOld == rNew)
193 : {
194 0 : SwTextBlocks* pGroup = rStatGlossaries.GetGroupDoc(sOldGroup, false);
195 0 : if(pGroup)
196 : {
197 0 : pGroup->SetName(rNewTitle);
198 0 : delete pGroup;
199 0 : bRet = true;
200 : }
201 : }
202 : else
203 : {
204 0 : OUString sNewGroup(rNew);
205 0 : if (sNewGroup.indexOf(GLOS_DELIM)<0)
206 : {
207 0 : sNewGroup += OUStringLiteral1<GLOS_DELIM>() + "0";
208 : }
209 0 : bRet = rStatGlossaries.RenameGroupDoc(sOldGroup, sNewGroup, rNewTitle);
210 0 : rNew = sNewGroup;
211 : }
212 0 : return bRet;
213 : }
214 :
215 0 : bool SwGlossaryHdl::CopyOrMove( const OUString& rSourceGroupName, OUString& rSourceShortName,
216 : const OUString& rDestGroupName, const OUString& rLongName, bool bMove )
217 : {
218 0 : SwTextBlocks* pSourceGroup = rStatGlossaries.GetGroupDoc(rSourceGroupName, false);
219 0 : SwTextBlocks* pDestGroup = rStatGlossaries.GetGroupDoc(rDestGroupName, false);
220 0 : if (pDestGroup->IsReadOnly() || (bMove && pSourceGroup->IsReadOnly()) )
221 : {
222 0 : delete pDestGroup;
223 0 : delete pSourceGroup;
224 0 : return false;
225 : }
226 :
227 : //The index must be determined here because rSourceShortName maybe changed in CopyBlock
228 0 : sal_uInt16 nDeleteIdx = pSourceGroup->GetIndex( rSourceShortName );
229 : OSL_ENSURE(USHRT_MAX != nDeleteIdx, "entry not found");
230 0 : sal_uLong nRet = pSourceGroup->CopyBlock( *pDestGroup, rSourceShortName, rLongName );
231 0 : if(!nRet && bMove)
232 : {
233 : // the index must be existing
234 0 : nRet = pSourceGroup->Delete( nDeleteIdx ) ? 0 : 1;
235 : }
236 0 : delete pSourceGroup;
237 0 : delete pDestGroup;
238 0 : return !nRet;
239 : }
240 :
241 : // delete a autotext-file-group
242 0 : bool SwGlossaryHdl::DelGroup(const OUString &rGrpName)
243 : {
244 0 : OUString sGroup(rGrpName);
245 0 : if (sGroup.indexOf(GLOS_DELIM)<0)
246 0 : FindGroupName(sGroup);
247 0 : if( rStatGlossaries.DelGroupDoc(sGroup) )
248 : {
249 0 : if(pCurGrp)
250 : {
251 0 : if (pCurGrp->GetName() == sGroup)
252 0 : DELETEZ(pCurGrp);
253 : }
254 0 : return true;
255 : }
256 0 : return false;
257 : }
258 :
259 : // ask for number of autotexts
260 0 : sal_uInt16 SwGlossaryHdl::GetGlossaryCnt()
261 : {
262 0 : return pCurGrp ? pCurGrp->GetCount() : 0;
263 : }
264 :
265 0 : OUString SwGlossaryHdl::GetGlossaryName( sal_uInt16 nId )
266 : {
267 : OSL_ENSURE(nId < GetGlossaryCnt(), "Textbausteinarray ueberindiziert.");
268 0 : return pCurGrp->GetLongName( nId );
269 : }
270 :
271 0 : OUString SwGlossaryHdl::GetGlossaryShortName(sal_uInt16 nId)
272 : {
273 : OSL_ENSURE(nId < GetGlossaryCnt(), "Textbausteinarray ueberindiziert.");
274 0 : return pCurGrp->GetShortName( nId );
275 : }
276 :
277 : // ask for short name
278 0 : OUString SwGlossaryHdl::GetGlossaryShortName(const OUString &rName)
279 : {
280 0 : OUString sReturn;
281 : SwTextBlocks *pTmp =
282 0 : pCurGrp ? pCurGrp: rStatGlossaries.GetGroupDoc( aCurGrp, false );
283 0 : if(pTmp)
284 : {
285 0 : sal_uInt16 nIdx = pTmp->GetLongIndex( rName );
286 0 : if( nIdx != (sal_uInt16) -1 )
287 0 : sReturn = pTmp->GetShortName( nIdx );
288 0 : if( !pCurGrp )
289 0 : delete pTmp;
290 : }
291 0 : return sReturn;
292 : }
293 :
294 : // short name for autotext already used?
295 0 : bool SwGlossaryHdl::HasShortName(const OUString& rShortName) const
296 : {
297 : SwTextBlocks *pBlock = pCurGrp ? pCurGrp
298 0 : : rStatGlossaries.GetGroupDoc( aCurGrp );
299 0 : bool bRet = pBlock->GetIndex( rShortName ) != (sal_uInt16) -1;
300 0 : if( !pCurGrp )
301 0 : delete pBlock;
302 0 : return bRet;
303 : }
304 :
305 : // Create autotext
306 0 : bool SwGlossaryHdl::NewGlossary(const OUString& rName, const OUString& rShortName,
307 : bool bCreateGroup, bool bNoAttr)
308 : {
309 : SwTextBlocks *pTmp =
310 0 : pCurGrp ? pCurGrp: rStatGlossaries.GetGroupDoc( aCurGrp, bCreateGroup );
311 : //pTmp == 0 if the AutoText path setting is wrong
312 0 : if(!pTmp)
313 0 : return false;
314 :
315 0 : OUString sOnlyText;
316 0 : OUString* pOnlyText = 0;
317 0 : if( bNoAttr )
318 : {
319 0 : if( !pWrtShell->GetSelectedText( sOnlyText, GETSELTXT_PARABRK_TO_ONLYCR ))
320 0 : return false;
321 0 : pOnlyText = &sOnlyText;
322 : }
323 :
324 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
325 :
326 : const sal_uInt16 nSuccess = pWrtShell->MakeGlossary( *pTmp, rName, rShortName,
327 0 : rCfg.IsSaveRelFile(), pOnlyText );
328 0 : if(nSuccess == (sal_uInt16) -1 )
329 : {
330 0 : ScopedVclPtrInstance<MessageDialog>::Create(pWrtShell->GetView().GetWindow(), SW_RES(STR_ERR_INSERT_GLOS), VCL_MESSAGE_INFO)->Execute();
331 : }
332 0 : if( !pCurGrp )
333 0 : delete pTmp;
334 0 : return nSuccess != (sal_uInt16) -1;
335 : }
336 :
337 : // Delete a autotext
338 0 : bool SwGlossaryHdl::DelGlossary(const OUString &rShortName)
339 : {
340 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
341 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
342 : //pTmp == 0 if the AutoText path setting is wrong
343 0 : if(!pGlossary)
344 0 : return false;
345 :
346 0 : sal_uInt16 nIdx = pGlossary->GetIndex( rShortName );
347 0 : if( nIdx != (sal_uInt16) -1 )
348 0 : pGlossary->Delete( nIdx );
349 0 : if( !pCurGrp )
350 0 : delete pGlossary;
351 0 : return true;
352 : }
353 :
354 : // expand short name
355 0 : bool SwGlossaryHdl::ExpandGlossary()
356 : {
357 : OSL_ENSURE(pWrtShell->CanInsert(), "illegal");
358 : SwTextBlocks *pGlossary;
359 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
360 : assert(pFact && "Dialog creation failed!");
361 0 : ::GlossaryGetCurrGroup fnGetCurrGroup = pFact->GetGlossaryCurrGroupFunc();
362 : assert(fnGetCurrGroup && "Dialog creation failed!");
363 0 : OUString sGroupName( (*fnGetCurrGroup)() );
364 0 : if (sGroupName.indexOf(GLOS_DELIM)<0)
365 0 : FindGroupName(sGroupName);
366 0 : pGlossary = rStatGlossaries.GetGroupDoc(sGroupName);
367 :
368 0 : OUString aShortName;
369 :
370 : // use this at text selection
371 0 : if(pWrtShell->SwCrsrShell::HasSelection() && !pWrtShell->IsBlockMode())
372 : {
373 0 : aShortName = pWrtShell->GetSelText();
374 : }
375 : else
376 : {
377 0 : if(pWrtShell->IsAddMode())
378 0 : pWrtShell->LeaveAddMode();
379 0 : else if(pWrtShell->IsBlockMode())
380 0 : pWrtShell->LeaveBlockMode();
381 0 : else if(pWrtShell->IsExtMode())
382 0 : pWrtShell->LeaveExtMode();
383 : // select word
384 0 : pWrtShell->SelNearestWrd();
385 : // ask for word
386 0 : if(pWrtShell->IsSelection())
387 0 : aShortName = pWrtShell->GetSelText();
388 : }
389 0 : return pGlossary && Expand( aShortName, &rStatGlossaries, pGlossary );
390 : }
391 :
392 0 : bool SwGlossaryHdl::Expand( const OUString& rShortName,
393 : SwGlossaries *pGlossaries,
394 : SwTextBlocks *pGlossary )
395 : {
396 0 : TextBlockInfoArr aFoundArr;
397 0 : OUString aShortName( rShortName );
398 0 : bool bCancel = false;
399 : // search for text block
400 : // - don't prefer current group depending on configuration setting
401 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
402 0 : sal_uInt16 nFound = !rCfg.IsSearchInAllCategories() ? pGlossary->GetIndex( aShortName ) : -1;
403 : // if not found then search in all groups
404 0 : if( nFound == (sal_uInt16) -1 )
405 : {
406 0 : const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
407 0 : SwGlossaryList* pGlossaryList = ::GetGlossaryList();
408 0 : const size_t nGroupCount = pGlossaryList->GetGroupCount();
409 0 : for(size_t i = 0; i < nGroupCount; ++i)
410 : {
411 : // get group name with path-extension
412 0 : const OUString sGroupName = pGlossaryList->GetGroupName(i, false);
413 0 : if(sGroupName == pGlossary->GetName())
414 0 : continue;
415 0 : const sal_uInt16 nBlockCount = pGlossaryList->GetBlockCount(i);
416 0 : if(nBlockCount)
417 : {
418 0 : const OUString sTitle = pGlossaryList->GetGroupTitle(i);
419 0 : for(sal_uInt16 j = 0; j < nBlockCount; j++)
420 : {
421 0 : const OUString sLongName(pGlossaryList->GetBlockLongName(i, j));
422 0 : const OUString sShortName(pGlossaryList->GetBlockShortName(i, j));
423 0 : if( rSCmp.isEqual( rShortName, sShortName ))
424 : {
425 0 : TextBlockInfo_Impl* pData = new TextBlockInfo_Impl;
426 0 : pData->sTitle = sTitle;
427 0 : pData->sLongName = sLongName;
428 0 : pData->sGroupName = sGroupName;
429 0 : aFoundArr.push_back(pData);
430 : }
431 0 : }
432 : }
433 0 : }
434 0 : if( !aFoundArr.empty() ) // one was found
435 : {
436 0 : delete pGlossary;
437 0 : if(1 == aFoundArr.size())
438 : {
439 0 : TextBlockInfo_Impl* pData = &aFoundArr.front();
440 0 : pGlossary = pGlossaries->GetGroupDoc(pData->sGroupName);
441 0 : nFound = pGlossary->GetIndex( aShortName );
442 : }
443 : else
444 : {
445 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
446 : assert(pFact && "SwAbstractDialogFactory fail!");
447 :
448 0 : boost::scoped_ptr<AbstractSwSelGlossaryDlg> pDlg(pFact->CreateSwSelGlossaryDlg(0, aShortName));
449 : assert(pDlg && "Dialog creation failed!");
450 0 : for(size_t i = 0; i < aFoundArr.size(); ++i)
451 : {
452 0 : TextBlockInfo_Impl* pData = &aFoundArr[i];
453 0 : pDlg->InsertGlos(pData->sTitle, pData->sLongName);
454 : }
455 0 : pDlg->SelectEntryPos(0);
456 0 : const sal_Int32 nRet = RET_OK == pDlg->Execute()?
457 0 : pDlg->GetSelectedIdx():
458 0 : LISTBOX_ENTRY_NOTFOUND;
459 0 : pDlg.reset();
460 0 : if(LISTBOX_ENTRY_NOTFOUND != nRet)
461 : {
462 0 : TextBlockInfo_Impl* pData = &aFoundArr[nRet];
463 0 : pGlossary = pGlossaries->GetGroupDoc(pData->sGroupName);
464 0 : nFound = pGlossary->GetIndex( aShortName );
465 : }
466 : else
467 : {
468 0 : nFound = (sal_uInt16) -1;
469 0 : bCancel = true;
470 0 : }
471 : }
472 : }
473 : }
474 :
475 : // not found
476 0 : if( nFound == (sal_uInt16) -1 )
477 : {
478 0 : if( !bCancel )
479 : {
480 0 : delete pGlossary;
481 :
482 0 : const sal_Int32 nMaxLen = 50;
483 0 : if(pWrtShell->IsSelection() && aShortName.getLength() > nMaxLen)
484 : {
485 0 : aShortName = aShortName.copy(0, nMaxLen) + " ...";
486 : }
487 0 : OUString aTmp( SW_RES(STR_NOGLOS));
488 0 : aTmp = aTmp.replaceFirst("%1", aShortName);
489 0 : ScopedVclPtr<InfoBox>::Create( pWrtShell->GetView().GetWindow(), aTmp )->Execute();
490 : }
491 :
492 0 : return false;
493 : }
494 : else
495 : {
496 0 : SvxMacro aStartMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
497 0 : SvxMacro aEndMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
498 0 : GetMacros( aShortName, aStartMacro, aEndMacro, pGlossary );
499 :
500 : // StartAction must not be before HasSelection and DelRight,
501 : // otherwise the possible Shell change gets delayed and
502 : // API-programs would hang.
503 : // Moreover the event macro must also not be called in an action
504 0 : pWrtShell->StartUndo(UNDO_INSGLOSSARY);
505 0 : if( aStartMacro.HasMacro() )
506 0 : pWrtShell->ExecMacro( aStartMacro );
507 0 : if(pWrtShell->HasSelection())
508 0 : pWrtShell->DelLeft();
509 0 : pWrtShell->StartAllAction();
510 :
511 : // cache all InputFields
512 0 : SwInputFieldList aFieldLst( pWrtShell, true );
513 :
514 0 : pWrtShell->InsertGlossary(*pGlossary, aShortName);
515 0 : pWrtShell->EndAllAction();
516 0 : if( aEndMacro.HasMacro() )
517 : {
518 0 : pWrtShell->ExecMacro( aEndMacro );
519 : }
520 0 : pWrtShell->EndUndo(UNDO_INSGLOSSARY);
521 :
522 : // demand input for all new InputFields
523 0 : if( aFieldLst.BuildSortLst() )
524 0 : pWrtShell->UpdateInputFields( &aFieldLst );
525 : }
526 0 : delete pGlossary;
527 0 : return true;
528 : }
529 :
530 : // add autotext
531 0 : bool SwGlossaryHdl::InsertGlossary(const OUString &rName)
532 : {
533 : OSL_ENSURE(pWrtShell->CanInsert(), "illegal");
534 :
535 : SwTextBlocks *pGlos =
536 0 : pCurGrp? pCurGrp: rStatGlossaries.GetGroupDoc(aCurGrp);
537 :
538 0 : if (!pGlos)
539 0 : return false;
540 :
541 0 : SvxMacro aStartMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
542 0 : SvxMacro aEndMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
543 0 : GetMacros( rName, aStartMacro, aEndMacro, pGlos );
544 :
545 : // StartAction must not be before HasSelection and DelRight,
546 : // otherwise the possible Shell change gets delayed and
547 : // API-programs would hang.
548 : // Moreover the event macro must also not be called in an action
549 0 : if( aStartMacro.HasMacro() )
550 0 : pWrtShell->ExecMacro( aStartMacro );
551 0 : if( pWrtShell->HasSelection() )
552 0 : pWrtShell->DelRight();
553 0 : pWrtShell->StartAllAction();
554 :
555 : // cache all InputFields
556 0 : SwInputFieldList aFieldLst( pWrtShell, true );
557 :
558 0 : pWrtShell->InsertGlossary(*pGlos, rName);
559 0 : pWrtShell->EndAllAction();
560 0 : if( aEndMacro.HasMacro() )
561 : {
562 0 : pWrtShell->ExecMacro( aEndMacro );
563 : }
564 :
565 : // demand input for all new InputFields
566 0 : if( aFieldLst.BuildSortLst() )
567 0 : pWrtShell->UpdateInputFields( &aFieldLst );
568 :
569 0 : if(!pCurGrp)
570 0 : delete pGlos;
571 0 : return true;
572 : }
573 :
574 : // set / ask for macro
575 0 : void SwGlossaryHdl::SetMacros(const OUString& rShortName,
576 : const SvxMacro* pStart,
577 : const SvxMacro* pEnd,
578 : SwTextBlocks *pGlossary )
579 : {
580 : SwTextBlocks *pGlos = pGlossary ? pGlossary :
581 : pCurGrp ? pCurGrp
582 0 : : rStatGlossaries.GetGroupDoc( aCurGrp );
583 0 : SvxMacroTableDtor aMacroTable;
584 0 : if( pStart )
585 0 : aMacroTable.Insert( SW_EVENT_START_INS_GLOSSARY, *pStart);
586 0 : if( pEnd )
587 0 : aMacroTable.Insert( SW_EVENT_END_INS_GLOSSARY, *pEnd);
588 0 : sal_uInt16 nIdx = pGlos->GetIndex( rShortName );
589 0 : if( !pGlos->SetMacroTable( nIdx, aMacroTable ) && pGlos->GetError() )
590 0 : ErrorHandler::HandleError( pGlos->GetError() );
591 :
592 0 : if(!pCurGrp && !pGlossary)
593 0 : delete pGlos;
594 0 : }
595 :
596 2 : void SwGlossaryHdl::GetMacros( const OUString &rShortName,
597 : SvxMacro& rStart,
598 : SvxMacro& rEnd,
599 : SwTextBlocks *pGlossary )
600 : {
601 : SwTextBlocks *pGlos = pGlossary ? pGlossary
602 : : pCurGrp ? pCurGrp
603 2 : : rStatGlossaries.GetGroupDoc(aCurGrp);
604 2 : sal_uInt16 nIndex = pGlos->GetIndex( rShortName );
605 2 : if( nIndex != USHRT_MAX )
606 : {
607 1 : SvxMacroTableDtor aMacroTable;
608 1 : if( pGlos->GetMacroTable( nIndex, aMacroTable ) )
609 : {
610 0 : SvxMacro *pMacro = aMacroTable.Get( SW_EVENT_START_INS_GLOSSARY );
611 0 : if( pMacro )
612 0 : rStart = *pMacro;
613 :
614 0 : pMacro = aMacroTable.Get( SW_EVENT_END_INS_GLOSSARY );
615 0 : if( pMacro )
616 0 : rEnd = *pMacro;
617 1 : }
618 : }
619 :
620 2 : if( !pCurGrp && !pGlossary )
621 0 : delete pGlos;
622 2 : }
623 :
624 : // ctor, dtor
625 1 : SwGlossaryHdl::SwGlossaryHdl(SfxViewFrame* pVwFrm, SwWrtShell *pSh)
626 1 : : rStatGlossaries( *::GetGlossaries() ),
627 : aCurGrp( SwGlossaries::GetDefName() ),
628 : pViewFrame( pVwFrm ),
629 : pWrtShell( pSh ),
630 1 : pCurGrp( 0 )
631 : {
632 1 : }
633 :
634 2 : SwGlossaryHdl::~SwGlossaryHdl()
635 : {
636 1 : delete pCurGrp;
637 1 : }
638 :
639 : // rename an autotext
640 0 : bool SwGlossaryHdl::Rename(const OUString& rOldShort, const OUString& rNewShortName,
641 : const OUString& rNewName )
642 : {
643 0 : bool bRet = false;
644 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
645 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
646 0 : if(pGlossary)
647 : {
648 0 : sal_uInt16 nIdx = pGlossary->GetIndex( rOldShort );
649 0 : sal_uInt16 nOldLongIdx = pGlossary->GetLongIndex( rNewName );
650 0 : sal_uInt16 nOldIdx = pGlossary->GetIndex( rNewShortName );
651 :
652 0 : if( nIdx != USHRT_MAX &&
653 0 : (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&&
654 0 : (nOldIdx == USHRT_MAX || nOldIdx == nIdx ))
655 : {
656 0 : pGlossary->Rename( nIdx, &rNewShortName, &rNewName );
657 0 : bRet = pGlossary->GetError() == 0;
658 : }
659 0 : if( !pCurGrp )
660 0 : delete pGlossary;
661 : }
662 0 : return bRet;
663 : }
664 :
665 0 : bool SwGlossaryHdl::IsReadOnly( const OUString* pGrpNm ) const
666 : {
667 0 : SwTextBlocks *pGlossary = 0;
668 :
669 0 : if (pGrpNm)
670 0 : pGlossary = rStatGlossaries.GetGroupDoc( *pGrpNm );
671 0 : else if (pCurGrp)
672 0 : pGlossary = pCurGrp;
673 : else
674 0 : pGlossary = rStatGlossaries.GetGroupDoc(aCurGrp);
675 :
676 0 : const bool bRet = !pGlossary || pGlossary->IsReadOnly();
677 0 : if( pGrpNm || !pCurGrp )
678 0 : delete pGlossary;
679 0 : return bRet;
680 : }
681 :
682 0 : bool SwGlossaryHdl::IsOld() const
683 : {
684 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
685 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
686 0 : bool bRet = pGlossary && pGlossary->IsOld();
687 0 : if( !pCurGrp )
688 0 : delete pGlossary;
689 0 : return bRet;
690 : }
691 :
692 : // find group without path index
693 0 : bool SwGlossaryHdl::FindGroupName(OUString& rGroup)
694 : {
695 0 : return rStatGlossaries.FindGroupName(rGroup);
696 : }
697 :
698 0 : bool SwGlossaryHdl::CopyToClipboard(SwWrtShell& rSh, const OUString& rShortName)
699 : {
700 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
701 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
702 :
703 0 : SwTransferable* pTransfer = new SwTransferable( rSh );
704 : /*??*/uno::Reference<
705 0 : datatransfer::XTransferable > xRef( pTransfer );
706 :
707 0 : int nRet = pTransfer->CopyGlossary( *pGlossary, rShortName );
708 0 : if( !pCurGrp )
709 0 : delete pGlossary;
710 0 : return 0 != nRet;
711 : }
712 :
713 0 : bool SwGlossaryHdl::ImportGlossaries( const OUString& rName )
714 : {
715 0 : bool bRet = false;
716 0 : if( !rName.isEmpty() )
717 : {
718 0 : const SfxFilter* pFilter = 0;
719 0 : boost::scoped_ptr<SfxMedium> pMed(new SfxMedium( rName, StreamMode::READ, 0, 0 ));
720 0 : SfxFilterMatcher aMatcher( OUString("swriter") );
721 0 : pMed->UseInteractionHandler( true );
722 0 : if (!aMatcher.GuessFilter(*pMed, &pFilter, SfxFilterFlags::NONE))
723 : {
724 0 : SwTextBlocks *pGlossary = NULL;
725 0 : pMed->SetFilter( pFilter );
726 0 : Reader* pR = SwReaderWriter::GetReader( pFilter->GetUserData() );
727 0 : if( pR && 0 != ( pGlossary = pCurGrp ? pCurGrp
728 0 : : rStatGlossaries.GetGroupDoc(aCurGrp)) )
729 : {
730 0 : SwReader aReader( *pMed, rName );
731 0 : if( aReader.HasGlossaries( *pR ) )
732 : {
733 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
734 : bRet = aReader.ReadGlossaries( *pR, *pGlossary,
735 0 : rCfg.IsSaveRelFile() );
736 0 : }
737 : }
738 0 : }
739 : }
740 0 : return bRet;
741 177 : }
742 :
743 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
