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 += OUString(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 = OUString();
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 += OUString(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 0 : bool SwGlossaryHdl::ConvertToNew(SwTextBlocks& /*rOld*/)
306 : {
307 0 : return true;
308 : }
309 :
310 : // Create autotext
311 0 : bool SwGlossaryHdl::NewGlossary(const OUString& rName, const OUString& rShortName,
312 : bool bCreateGroup, bool bNoAttr)
313 : {
314 : SwTextBlocks *pTmp =
315 0 : pCurGrp ? pCurGrp: rStatGlossaries.GetGroupDoc( aCurGrp, bCreateGroup );
316 : //pTmp == 0 if the AutoText path setting is wrong
317 0 : if(!pTmp)
318 0 : return false;
319 0 : if(!ConvertToNew(*pTmp))
320 0 : return false;
321 :
322 0 : OUString sOnlyTxt;
323 0 : OUString* pOnlyTxt = 0;
324 0 : if( bNoAttr )
325 : {
326 0 : if( !pWrtShell->GetSelectedText( sOnlyTxt, GETSELTXT_PARABRK_TO_ONLYCR ))
327 0 : return false;
328 0 : pOnlyTxt = &sOnlyTxt;
329 : }
330 :
331 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
332 :
333 : const sal_uInt16 nSuccess = pWrtShell->MakeGlossary( *pTmp, rName, rShortName,
334 0 : rCfg.IsSaveRelFile(), pOnlyTxt );
335 0 : if(nSuccess == (sal_uInt16) -1 )
336 : {
337 0 : MessageDialog(pWrtShell->GetView().GetWindow(), SW_RES(STR_ERR_INSERT_GLOS), VCL_MESSAGE_INFO).Execute();
338 : }
339 0 : if( !pCurGrp )
340 0 : delete pTmp;
341 0 : return nSuccess != (sal_uInt16) -1;
342 : }
343 :
344 : // Delete a autotext
345 0 : bool SwGlossaryHdl::DelGlossary(const OUString &rShortName)
346 : {
347 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
348 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
349 : //pTmp == 0 if the AutoText path setting is wrong
350 0 : if(!pGlossary || !ConvertToNew(*pGlossary))
351 0 : return false;
352 :
353 0 : sal_uInt16 nIdx = pGlossary->GetIndex( rShortName );
354 0 : if( nIdx != (sal_uInt16) -1 )
355 0 : pGlossary->Delete( nIdx );
356 0 : if( !pCurGrp )
357 0 : delete pGlossary;
358 0 : return true;
359 : }
360 :
361 : // expand short name
362 0 : bool SwGlossaryHdl::ExpandGlossary()
363 : {
364 : OSL_ENSURE(pWrtShell->CanInsert(), "illegal");
365 : SwTextBlocks *pGlossary;
366 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
367 : assert(pFact && "Dialog creation failed!");
368 0 : ::GlossaryGetCurrGroup fnGetCurrGroup = pFact->GetGlossaryCurrGroupFunc();
369 : assert(fnGetCurrGroup && "Dialog creation failed!");
370 0 : OUString sGroupName( (*fnGetCurrGroup)() );
371 0 : if (sGroupName.indexOf(GLOS_DELIM)<0)
372 0 : FindGroupName(sGroupName);
373 0 : pGlossary = rStatGlossaries.GetGroupDoc(sGroupName);
374 :
375 0 : OUString aShortName;
376 :
377 : // use this at text selection
378 0 : if(pWrtShell->SwCrsrShell::HasSelection() && !pWrtShell->IsBlockMode())
379 : {
380 0 : aShortName = pWrtShell->GetSelTxt();
381 : }
382 : else
383 : {
384 0 : if(pWrtShell->IsAddMode())
385 0 : pWrtShell->LeaveAddMode();
386 0 : else if(pWrtShell->IsBlockMode())
387 0 : pWrtShell->LeaveBlockMode();
388 0 : else if(pWrtShell->IsExtMode())
389 0 : pWrtShell->LeaveExtMode();
390 : // select word
391 0 : pWrtShell->SelNearestWrd();
392 : // ask for word
393 0 : if(pWrtShell->IsSelection())
394 0 : aShortName = pWrtShell->GetSelTxt();
395 : }
396 0 : return pGlossary ? Expand( aShortName, &rStatGlossaries, pGlossary ) : sal_False;
397 : }
398 :
399 0 : bool SwGlossaryHdl::Expand( const OUString& rShortName,
400 : SwGlossaries *pGlossaries,
401 : SwTextBlocks *pGlossary )
402 : {
403 0 : TextBlockInfoArr aFoundArr;
404 0 : OUString aShortName( rShortName );
405 0 : bool bCancel = false;
406 : // search for text block
407 : // - don't prefer current group depending on configuration setting
408 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
409 0 : sal_uInt16 nFound = !rCfg.IsSearchInAllCategories() ? pGlossary->GetIndex( aShortName ) : -1;
410 : // if not found then search in all groups
411 0 : if( nFound == (sal_uInt16) -1 )
412 : {
413 0 : const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
414 0 : SwGlossaryList* pGlossaryList = ::GetGlossaryList();
415 0 : const size_t nGroupCount = pGlossaryList->GetGroupCount();
416 0 : for(size_t i = 0; i < nGroupCount; ++i)
417 : {
418 : // get group name with path-extension
419 0 : const OUString sGroupName = pGlossaryList->GetGroupName(i, false);
420 0 : if(sGroupName == pGlossary->GetName())
421 0 : continue;
422 0 : const sal_uInt16 nBlockCount = pGlossaryList->GetBlockCount(i);
423 0 : if(nBlockCount)
424 : {
425 0 : const OUString sTitle = pGlossaryList->GetGroupTitle(i);
426 0 : for(sal_uInt16 j = 0; j < nBlockCount; j++)
427 : {
428 0 : const OUString sLongName(pGlossaryList->GetBlockLongName(i, j));
429 0 : const OUString sShortName(pGlossaryList->GetBlockShortName(i, j));
430 0 : if( rSCmp.isEqual( rShortName, sShortName ))
431 : {
432 0 : TextBlockInfo_Impl* pData = new TextBlockInfo_Impl;
433 0 : pData->sTitle = sTitle;
434 0 : pData->sLongName = sLongName;
435 0 : pData->sGroupName = sGroupName;
436 0 : aFoundArr.push_back(pData);
437 : }
438 0 : }
439 : }
440 0 : }
441 0 : if( !aFoundArr.empty() ) // one was found
442 : {
443 0 : delete pGlossary;
444 0 : if(1 == aFoundArr.size())
445 : {
446 0 : TextBlockInfo_Impl* pData = &aFoundArr.front();
447 0 : pGlossary = (SwTextBlocks *)pGlossaries->GetGroupDoc(pData->sGroupName);
448 0 : nFound = pGlossary->GetIndex( aShortName );
449 : }
450 : else
451 : {
452 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
453 : assert(pFact && "SwAbstractDialogFactory fail!");
454 :
455 0 : boost::scoped_ptr<AbstractSwSelGlossaryDlg> pDlg(pFact->CreateSwSelGlossaryDlg(0, aShortName));
456 : assert(pDlg && "Dialog creation failed!");
457 0 : for(sal_uInt16 i = 0; i < aFoundArr.size(); ++i)
458 : {
459 0 : TextBlockInfo_Impl* pData = &aFoundArr[i];
460 0 : pDlg->InsertGlos(pData->sTitle, pData->sLongName);
461 : }
462 0 : pDlg->SelectEntryPos(0);
463 0 : const sal_Int32 nRet = RET_OK == pDlg->Execute()?
464 0 : pDlg->GetSelectedIdx():
465 0 : LISTBOX_ENTRY_NOTFOUND;
466 0 : pDlg.reset();
467 0 : if(LISTBOX_ENTRY_NOTFOUND != nRet)
468 : {
469 0 : TextBlockInfo_Impl* pData = &aFoundArr[nRet];
470 0 : pGlossary = (SwTextBlocks *)pGlossaries->GetGroupDoc(pData->sGroupName);
471 0 : nFound = pGlossary->GetIndex( aShortName );
472 : }
473 : else
474 : {
475 0 : nFound = (sal_uInt16) -1;
476 0 : bCancel = true;
477 0 : }
478 : }
479 : }
480 : }
481 :
482 : // not found
483 0 : if( nFound == (sal_uInt16) -1 )
484 : {
485 0 : if( !bCancel )
486 : {
487 0 : delete pGlossary;
488 :
489 0 : const sal_Int32 nMaxLen = 50;
490 0 : if(pWrtShell->IsSelection() && aShortName.getLength() > nMaxLen)
491 : {
492 0 : aShortName = aShortName.copy(0, nMaxLen) + " ...";
493 : }
494 0 : OUString aTmp( SW_RES(STR_NOGLOS));
495 0 : aTmp = aTmp.replaceFirst("%1", aShortName);
496 0 : InfoBox( pWrtShell->GetView().GetWindow(), aTmp ).Execute();
497 : }
498 :
499 0 : return false;
500 : }
501 : else
502 : {
503 0 : SvxMacro aStartMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
504 0 : SvxMacro aEndMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
505 0 : GetMacros( aShortName, aStartMacro, aEndMacro, pGlossary );
506 :
507 : // StartAction must not be before HasSelection and DelRight,
508 : // otherwise the possible Shell change gets delayed and
509 : // API-programs would hang.
510 : // Moreover the event macro must also not be called in an action
511 0 : pWrtShell->StartUndo(UNDO_INSGLOSSARY);
512 0 : if( aStartMacro.HasMacro() )
513 0 : pWrtShell->ExecMacro( aStartMacro );
514 0 : if(pWrtShell->HasSelection())
515 0 : pWrtShell->DelLeft();
516 0 : pWrtShell->StartAllAction();
517 :
518 : // cache all InputFields
519 0 : SwInputFieldList aFldLst( pWrtShell, true );
520 :
521 0 : pWrtShell->InsertGlossary(*pGlossary, aShortName);
522 0 : pWrtShell->EndAllAction();
523 0 : if( aEndMacro.HasMacro() )
524 : {
525 0 : pWrtShell->ExecMacro( aEndMacro );
526 : }
527 0 : pWrtShell->EndUndo(UNDO_INSGLOSSARY);
528 :
529 : // demand input for all new InputFields
530 0 : if( aFldLst.BuildSortLst() )
531 0 : pWrtShell->UpdateInputFlds( &aFldLst );
532 : }
533 0 : delete pGlossary;
534 0 : return true;
535 : }
536 :
537 : // add autotext
538 0 : bool SwGlossaryHdl::InsertGlossary(const OUString &rName)
539 : {
540 : OSL_ENSURE(pWrtShell->CanInsert(), "illegal");
541 :
542 : SwTextBlocks *pGlos =
543 0 : pCurGrp? pCurGrp: rStatGlossaries.GetGroupDoc(aCurGrp);
544 :
545 0 : if (!pGlos)
546 0 : return false;
547 :
548 0 : SvxMacro aStartMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
549 0 : SvxMacro aEndMacro(aEmptyOUStr, aEmptyOUStr, STARBASIC);
550 0 : GetMacros( rName, aStartMacro, aEndMacro, pGlos );
551 :
552 : // StartAction must not be before HasSelection and DelRight,
553 : // otherwise the possible Shell change gets delayed and
554 : // API-programs would hang.
555 : // Moreover the event macro must also not be called in an action
556 0 : if( aStartMacro.HasMacro() )
557 0 : pWrtShell->ExecMacro( aStartMacro );
558 0 : if( pWrtShell->HasSelection() )
559 0 : pWrtShell->DelRight();
560 0 : pWrtShell->StartAllAction();
561 :
562 : // cache all InputFields
563 0 : SwInputFieldList aFldLst( pWrtShell, true );
564 :
565 0 : pWrtShell->InsertGlossary(*pGlos, rName);
566 0 : pWrtShell->EndAllAction();
567 0 : if( aEndMacro.HasMacro() )
568 : {
569 0 : pWrtShell->ExecMacro( aEndMacro );
570 : }
571 :
572 : // demand input for all new InputFields
573 0 : if( aFldLst.BuildSortLst() )
574 0 : pWrtShell->UpdateInputFlds( &aFldLst );
575 :
576 0 : if(!pCurGrp)
577 0 : delete pGlos;
578 0 : return true;
579 : }
580 :
581 : // set / ask for macro
582 0 : void SwGlossaryHdl::SetMacros(const OUString& rShortName,
583 : const SvxMacro* pStart,
584 : const SvxMacro* pEnd,
585 : SwTextBlocks *pGlossary )
586 : {
587 : SwTextBlocks *pGlos = pGlossary ? pGlossary :
588 : pCurGrp ? pCurGrp
589 0 : : rStatGlossaries.GetGroupDoc( aCurGrp );
590 0 : SvxMacroTableDtor aMacroTbl;
591 0 : if( pStart )
592 0 : aMacroTbl.Insert( SW_EVENT_START_INS_GLOSSARY, *pStart);
593 0 : if( pEnd )
594 0 : aMacroTbl.Insert( SW_EVENT_END_INS_GLOSSARY, *pEnd);
595 0 : sal_uInt16 nIdx = pGlos->GetIndex( rShortName );
596 0 : if( !pGlos->SetMacroTable( nIdx, aMacroTbl ) && pGlos->GetError() )
597 0 : ErrorHandler::HandleError( pGlos->GetError() );
598 :
599 0 : if(!pCurGrp && !pGlossary)
600 0 : delete pGlos;
601 0 : }
602 :
603 4 : void SwGlossaryHdl::GetMacros( const OUString &rShortName,
604 : SvxMacro& rStart,
605 : SvxMacro& rEnd,
606 : SwTextBlocks *pGlossary )
607 : {
608 : SwTextBlocks *pGlos = pGlossary ? pGlossary
609 : : pCurGrp ? pCurGrp
610 4 : : rStatGlossaries.GetGroupDoc(aCurGrp);
611 4 : sal_uInt16 nIndex = pGlos->GetIndex( rShortName );
612 4 : if( nIndex != USHRT_MAX )
613 : {
614 2 : SvxMacroTableDtor aMacroTbl;
615 2 : if( pGlos->GetMacroTable( nIndex, aMacroTbl ) )
616 : {
617 0 : SvxMacro *pMacro = aMacroTbl.Get( SW_EVENT_START_INS_GLOSSARY );
618 0 : if( pMacro )
619 0 : rStart = *pMacro;
620 :
621 0 : pMacro = aMacroTbl.Get( SW_EVENT_END_INS_GLOSSARY );
622 0 : if( pMacro )
623 0 : rEnd = *pMacro;
624 2 : }
625 : }
626 :
627 4 : if( !pCurGrp && !pGlossary )
628 0 : delete pGlos;
629 4 : }
630 :
631 : // ctor, dtor
632 2 : SwGlossaryHdl::SwGlossaryHdl(SfxViewFrame* pVwFrm, SwWrtShell *pSh)
633 2 : : rStatGlossaries( *::GetGlossaries() ),
634 : aCurGrp( SwGlossaries::GetDefName() ),
635 : pViewFrame( pVwFrm ),
636 : pWrtShell( pSh ),
637 2 : pCurGrp( 0 )
638 : {
639 2 : }
640 :
641 4 : SwGlossaryHdl::~SwGlossaryHdl()
642 : {
643 2 : delete pCurGrp;
644 2 : }
645 :
646 : // rename an autotext
647 0 : bool SwGlossaryHdl::Rename(const OUString& rOldShort, const OUString& rNewShortName,
648 : const OUString& rNewName )
649 : {
650 0 : bool bRet = false;
651 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
652 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
653 0 : if(pGlossary)
654 : {
655 0 : if(!ConvertToNew(*pGlossary))
656 0 : return false;
657 :
658 0 : sal_uInt16 nIdx = pGlossary->GetIndex( rOldShort );
659 0 : sal_uInt16 nOldLongIdx = pGlossary->GetLongIndex( rNewName );
660 0 : sal_uInt16 nOldIdx = pGlossary->GetIndex( rNewShortName );
661 :
662 0 : if( nIdx != USHRT_MAX &&
663 0 : (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&&
664 0 : (nOldIdx == USHRT_MAX || nOldIdx == nIdx ))
665 : {
666 0 : pGlossary->Rename( nIdx, &rNewShortName, &rNewName );
667 0 : bRet = pGlossary->GetError() == 0;
668 : }
669 0 : if( !pCurGrp )
670 0 : delete pGlossary;
671 : }
672 0 : return bRet;
673 : }
674 :
675 0 : bool SwGlossaryHdl::IsReadOnly( const OUString* pGrpNm ) const
676 : {
677 0 : SwTextBlocks *pGlossary = 0;
678 :
679 0 : if (pGrpNm)
680 0 : pGlossary = rStatGlossaries.GetGroupDoc( *pGrpNm );
681 0 : else if (pCurGrp)
682 0 : pGlossary = pCurGrp;
683 : else
684 0 : pGlossary = rStatGlossaries.GetGroupDoc(aCurGrp);
685 :
686 0 : bool bRet = pGlossary ? pGlossary->IsReadOnly() : sal_True;
687 0 : if( pGrpNm || !pCurGrp )
688 0 : delete pGlossary;
689 0 : return bRet;
690 : }
691 :
692 0 : bool SwGlossaryHdl::IsOld() const
693 : {
694 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
695 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
696 0 : bool bRet = pGlossary ? pGlossary->IsOld() : sal_False;
697 0 : if( !pCurGrp )
698 0 : delete pGlossary;
699 0 : return bRet;
700 : }
701 :
702 : // find group without path index
703 0 : bool SwGlossaryHdl::FindGroupName(OUString& rGroup)
704 : {
705 0 : return rStatGlossaries.FindGroupName(rGroup);
706 : }
707 :
708 0 : bool SwGlossaryHdl::CopyToClipboard(SwWrtShell& rSh, const OUString& rShortName)
709 : {
710 : SwTextBlocks *pGlossary = pCurGrp ? pCurGrp
711 0 : : rStatGlossaries.GetGroupDoc(aCurGrp);
712 :
713 0 : SwTransferable* pTransfer = new SwTransferable( rSh );
714 : /*??*/uno::Reference<
715 0 : datatransfer::XTransferable > xRef( pTransfer );
716 :
717 0 : int nRet = pTransfer->CopyGlossary( *pGlossary, rShortName );
718 0 : if( !pCurGrp )
719 0 : delete pGlossary;
720 0 : return 0 != nRet;
721 : }
722 :
723 0 : bool SwGlossaryHdl::ImportGlossaries( const OUString& rName )
724 : {
725 0 : bool bRet = false;
726 0 : if( !rName.isEmpty() )
727 : {
728 0 : const SfxFilter* pFilter = 0;
729 0 : boost::scoped_ptr<SfxMedium> pMed(new SfxMedium( rName, STREAM_READ, 0, 0 ));
730 0 : SfxFilterMatcher aMatcher( OUString("swriter") );
731 0 : pMed->UseInteractionHandler( true );
732 0 : if( !aMatcher.GuessFilter( *pMed, &pFilter, sal_False ) )
733 : {
734 0 : SwTextBlocks *pGlossary = NULL;
735 0 : pMed->SetFilter( pFilter );
736 0 : Reader* pR = SwReaderWriter::GetReader( pFilter->GetUserData() );
737 0 : if( pR && 0 != ( pGlossary = pCurGrp ? pCurGrp
738 0 : : rStatGlossaries.GetGroupDoc(aCurGrp)) )
739 : {
740 0 : SwReader aReader( *pMed, rName );
741 0 : if( aReader.HasGlossaries( *pR ) )
742 : {
743 0 : const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
744 : bRet = aReader.ReadGlossaries( *pR, *pGlossary,
745 0 : rCfg.IsSaveRelFile() );
746 0 : }
747 : }
748 0 : }
749 : }
750 0 : return bRet;
751 270 : }
752 :
753 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
