?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sw / source / ui / misc / glossary.cxx
blob89a37a86e798570b16604bb5d0df428f59837b48
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: glossary.cxx,v $
10 * $Revision: 1.49 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33 #ifdef SW_DLLIMPLEMENTATION
34 #undef SW_DLLIMPLEMENTATION
35 #endif
36
37
38
39 #define _SVSTDARR_STRINGSDTOR
40 #define _SVSTDARR_STRINGS
41 #include <hintids.hxx>
42
43 #ifndef _MENU_HXX //autogen
44 #include <vcl/menu.hxx>
45 #endif
46 #ifndef _MSGBOX_HXX //autogen
47 #include <vcl/msgbox.hxx>
48 #endif
49 #ifndef _HELP_HXX //autogen
50 #include <vcl/help.hxx>
51 #endif
52 #ifndef _SVSTDARR_HXX
53 #include <svtools/svstdarr.hxx>
54 #endif
55 #include <svtools/stritem.hxx>
56 #include <svtools/pathoptions.hxx>
57 #include <svtools/lingucfg.hxx>
58 #include <sfx2/request.hxx>
59 #include <sfx2/fcontnr.hxx>
60
61 #include <svx/svxdlg.hxx>
62 #include <svx/dialogs.hrc>
63 #include <svx/acorrcfg.hxx>
64 #include <sfx2/viewfrm.hxx>
65 #include <unocrsr.hxx>
66 #include <unotools.hxx>
67 #include <unoobj.hxx>
68 #include <comphelper/processfactory.hxx>
69 #include <ucbhelper/content.hxx>
70 #include <com/sun/star/ui/dialogs/XFilePicker.hpp>
71 #include <com/sun/star/ui/dialogs/XFilterManager.hpp>
72 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
73 #include <svtools/urihelper.hxx>
74 #include <unotools/charclass.hxx>
75 #include <swwait.hxx>
76 #include <swtypes.hxx>
77 #include <wrtsh.hxx>
78 #ifndef _VIEW_HXX
79 #include <view.hxx>
80 #endif
81 #ifndef _BASESH_HXX
82 #include <basesh.hxx>
83 #endif
84 #include <glossary.hxx>
85 #include <gloshdl.hxx>
86 #include <glosbib.hxx>
87 #include <initui.hxx> // fuer ::GetGlossaries()
88 #include <glosdoc.hxx>
89 #include <macassgn.hxx>
90 #include <swevent.hxx>
91 #ifndef _DOCSH_HXX
92 #include <docsh.hxx>
93 #endif
94 #include <shellio.hxx>
95
96 #ifndef _CMDID_H
97 #include <cmdid.h>
98 #endif
99 #ifndef _HELPID_H
100 #include <helpid.h>
101 #endif
102 #ifndef _SWERROR_H
103 #include <swerror.h>
104 #endif
105 #ifndef _GLOBALS_HRC
106 #include <globals.hrc>
107 #endif
108 #ifndef _MISC_HRC
109 #include <misc.hrc>
110 #endif
111 #ifndef _GLOSSARY_HRC
112 #include <glossary.hrc>
113 #endif
114 #include <swmodule.hxx>
115 #include <sfx2/filedlghelper.hxx>
116
117 #define LONG_LENGTH 60
118 #define SHORT_LENGTH 30
119
120
121 using namespace ::com::sun::star;
122 using namespace ::com::sun::star::lang;
123 using namespace ::com::sun::star::uno;
124 using namespace ::com::sun::star::text;
125 using namespace ::com::sun::star::ucb;
126 using namespace ::com::sun::star::ui::dialogs;
127 using namespace ::comphelper;
128 using namespace ::ucbhelper;
129 using ::rtl::OUString;
130 using namespace ::sfx2;
131
132 String lcl_GetValidShortCut( const String& rName )
133 {
134 const sal_uInt16 nSz = rName.Len();
135
136 if ( 0 == nSz )
137 return rName;
138
139 sal_uInt16 nStart = 1;
140 while( rName.GetChar( nStart-1 ) == ' ' && nStart < nSz )
141 nStart++;
142
143 String aBuf( rName.GetChar( nStart-1 ));
144
145 for( ; nStart < nSz; ++nStart )
146 {
147 if( rName.GetChar( nStart-1 ) == ' ' && rName.GetChar( nStart ) != ' ')
148 aBuf += rName.GetChar( nStart );
149 }
150 return aBuf;
151 }
152
153 /* -----------------------------08.02.00 10:28--------------------------------
154
155 ---------------------------------------------------------------------------*/
156 struct GroupUserData
157 {
158 String sGroupName;
159 sal_uInt16 nPathIdx;
160 BOOL bReadonly;
161
162 GroupUserData()
163 : nPathIdx(0),
164 bReadonly(FALSE) {}
165 };
166
167 /*------------------------------------------------------------------------
168 Beschreibung: Dialog fuer neuen Bausteinnamen
169 ------------------------------------------------------------------------*/
170 class SwNewGlosNameDlg : public ModalDialog
171 {
172 FixedText aNNFT;
173 Edit aNewName;
174 FixedText aNSFT;
175 NoSpaceEdit aNewShort;
176 OKButton aOk;
177 CancelButton aCancel;
178 FixedLine aFL;
179 FixedText aONFT;
180 Edit aOldName;
181 FixedText aOSFT;
182 Edit aOldShort;
183
184 protected:
185 DECL_LINK( Modify, Edit * );
186 DECL_LINK( Rename, Button * );
187
188 public:
189 SwNewGlosNameDlg( Window* pParent,
190 const String& rOldName,
191 const String& rOldShort );
192
193 String GetNewName() const { return aNewName.GetText(); }
194 String GetNewShort() const { return aNewShort.GetText(); }
195 };
196
197 SwNewGlosNameDlg::SwNewGlosNameDlg(Window* pParent,
198 const String& rOldName,
199 const String& rOldShort ) :
200 ModalDialog( pParent, SW_RES( DLG_RENAME_GLOS ) ),
201 aNNFT (this, SW_RES( FT_NN )),
202 aNewName(this, SW_RES( ED_NN )),
203 aNSFT (this, SW_RES( FT_NS )),
204 aNewShort(this,SW_RES( ED_NS )),
205 aOk (this, SW_RES( BT_OKNEW)),
206 aCancel (this, SW_RES( BT_CANCEL)),
207 aFL (this, SW_RES( FL_NN )),
208 aONFT (this, SW_RES( FT_ON )),
209 aOldName(this, SW_RES( ED_ON )),
210 aOSFT (this, SW_RES( FT_OS )),
211 aOldShort(this,SW_RES( ED_OS ))
212 {
213 FreeResource();
214 aOldName.SetText( rOldName );
215 aOldShort.SetText( rOldShort );
216 aNewShort.SetMaxTextLen(SHORT_LENGTH);
217 aNewName.SetMaxTextLen(LONG_LENGTH);
218 aNewName.SetModifyHdl(LINK(this, SwNewGlosNameDlg, Modify ));
219 aNewShort.SetModifyHdl(LINK(this, SwNewGlosNameDlg, Modify ));
220 aOk.SetClickHdl(LINK(this, SwNewGlosNameDlg, Rename ));
221 aNewName.GrabFocus();
222 }
223
224 /*------------------------------------------------------------------------
225 Beschreibung: aktuell eingestellte Gruppe erfragen / setzen
226 ------------------------------------------------------------------------*/
227
228 String SwGlossaryDlg::GetCurrGroup()
229 {
230 if( ::GetCurrGlosGroup() && ::GetCurrGlosGroup()->Len() )
231 return *(::GetCurrGlosGroup());
232 return SwGlossaries::GetDefName();
233 }
234
235
236
237 void SwGlossaryDlg::SetActGroup(const String &rGrp)
238 {
239 if( !::GetCurrGlosGroup() )
240 ::SetCurrGlosGroup( new String );
241 *(::GetCurrGlosGroup()) = rGrp;
242 }
243
244
245
246 SwGlossaryDlg::SwGlossaryDlg(SfxViewFrame* pViewFrame,
247 SwGlossaryHdl * pGlosHdl, SwWrtShell *pWrtShell) :
248
249 SvxStandardDialog(&pViewFrame->GetWindow(), SW_RES(DLG_GLOSSARY)),
250
251 aInsertTipCB (this, SW_RES(CB_INSERT_TIP)),
252 aNameLbl (this, SW_RES(FT_NAME)),
253 aNameED (this, SW_RES(ED_NAME)),
254 aShortNameLbl (this, SW_RES(FT_SHORTNAME)),
255 aShortNameEdit(this, SW_RES(ED_SHORTNAME)),
256 aCategoryBox (this, SW_RES(LB_BIB)),
257 aRelativeFL (this, SW_RES(FL_RELATIVE)),
258 aFileRelCB (this, SW_RES(CB_FILE_REL)),
259 aNetRelCB (this, SW_RES(CB_NET_REL)),
260 aExampleWIN (this, SW_RES(WIN_EXAMPLE )),
261 aExampleDummyWIN(this, SW_RES(WIN_EXAMPLE_DUMMY )),
262 aShowExampleCB(this, SW_RES(CB_SHOW_EXAMPLE )),
263 aInsertBtn (this, SW_RES(PB_INSERT)),
264 aCloseBtn (this, SW_RES(PB_CLOSE)),
265 aHelpBtn (this, SW_RES(PB_HELP)),
266 aEditBtn (this, SW_RES(PB_EDIT)),
267 aBibBtn (this, SW_RES(PB_BIB)),
268 aPathBtn (this, SW_RES(PB_PATH)),
269
270 sReadonlyPath (SW_RES(ST_READONLY_PATH)),
271 pExampleFrame(0),
272
273 pMenu (new PopupMenu(SW_RES(MNU_EDIT))),
274 pGlossaryHdl (pGlosHdl),
275
276 bResume(sal_False),
277
278 bSelection( pWrtShell->IsSelection() ),
279 bReadOnly( sal_False ),
280 bIsOld( sal_False ),
281 bIsDocReadOnly(sal_False),
282
283 pSh (pWrtShell)
284 {
285 SvtLinguConfig aLocalLinguConfig;
286
287 // Static-Pointer initialisieren
288 if( !::GetCurrGlosGroup() )
289 ::SetCurrGlosGroup(new String);//(SwGlossaries::GetDefName());
290
291 pMenu->SetActivateHdl(LINK(this,SwGlossaryDlg,EnableHdl));
292 pMenu->SetSelectHdl(LINK(this,SwGlossaryDlg,MenuHdl));
293 aEditBtn.SetPopupMenu(pMenu);
294 aEditBtn.SetSelectHdl(LINK(this,SwGlossaryDlg,EditHdl));
295 aPathBtn.SetClickHdl(LINK(this, SwGlossaryDlg, PathHdl));
296
297 aNameED.SetModifyHdl(LINK(this,SwGlossaryDlg,NameModify));
298 aShortNameEdit.SetModifyHdl(LINK(this,SwGlossaryDlg,NameModify));
299
300 aCategoryBox.SetDoubleClickHdl(LINK(this,SwGlossaryDlg, NameDoubleClick));
301 aCategoryBox.SetSelectHdl(LINK(this,SwGlossaryDlg,GrpSelect));
302 aBibBtn.SetClickHdl(LINK(this,SwGlossaryDlg,BibHdl));
303 aShowExampleCB.SetClickHdl(LINK(this, SwGlossaryDlg, ShowPreviewHdl));
304
305 aShortNameEdit.SetMaxTextLen(SHORT_LENGTH);
306 aNameED.SetMaxTextLen(LONG_LENGTH);
307 FreeResource();
308
309 const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
310
311 aShowExampleCB.Check( pCfg->IsAutoTextPreview());
312 ShowPreviewHdl(&aShowExampleCB);
313
314 bIsDocReadOnly = pSh->GetView().GetDocShell()->IsReadOnly() ||
315 pSh->HasReadonlySel();
316 if( bIsDocReadOnly )
317 aInsertBtn.Enable(sal_False);
318 aNameED.GrabFocus();
319 aCategoryBox.SetHelpId(HID_MD_GLOS_CATEGORY);
320 aCategoryBox.SetWindowBits(WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL|WB_VSCROLL|WB_CLIPCHILDREN|WB_SORT);
321 aCategoryBox.GetModel()->SetSortMode(SortAscending);
322 aCategoryBox.SetHighlightRange(); // ueber volle Breite selektieren
323 aCategoryBox.SetNodeDefaultImages( );
324
325 Init();
326 }
327 /*--------------------------------------------------------------------
328 Beschreibung:
329 --------------------------------------------------------------------*/
330
331
332 SwGlossaryDlg::~SwGlossaryDlg()
333 {
334 SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
335 pCfg->SetAutoTextPreview(aShowExampleCB.IsChecked()) ;
336
337 aCategoryBox.Clear();
338 aEditBtn.SetPopupMenu(0);
339 delete pMenu;
340 delete pExampleFrame;
341 }
342 /*------------------------------------------------------------------------
343 Beschreibung: Auswahl neue Gruppe
344 ------------------------------------------------------------------------*/
345
346
347 IMPL_LINK( SwGlossaryDlg, GrpSelect, SvTreeListBox *, pBox )
348 {
349 SvLBoxEntry* pEntry = pBox->FirstSelected();
350 if(!pEntry)
351 return 0;
352 SvLBoxEntry* pParent = pBox->GetParent(pEntry) ? pBox->GetParent(pEntry) : pEntry;
353 GroupUserData* pGroupData = (GroupUserData*)pParent->GetUserData();
354 String *pGlosGroup = ::GetCurrGlosGroup();
355 (*pGlosGroup) = pGroupData->sGroupName;
356 (*pGlosGroup) += GLOS_DELIM;
357 (*pGlosGroup) += String::CreateFromInt32(pGroupData->nPathIdx);
358 pGlossaryHdl->SetCurGroup(*pGlosGroup);
359 // Aktuellen Textbaustein setzen
360 bReadOnly = pGlossaryHdl->IsReadOnly();
361 EnableShortName( !bReadOnly );
362 aEditBtn.Enable(!bReadOnly);
363 bIsOld = pGlossaryHdl->IsOld();
364 if( pParent != pEntry)
365 {
366 String aName(pBox->GetEntryText(pEntry));
367 aNameED.SetText(aName);
368 aShortNameEdit.SetText(*(String*)pEntry->GetUserData());
369 pEntry = pBox->GetParent(pEntry);
370 aInsertBtn.Enable( !bIsDocReadOnly);
371 ShowAutoText(*::GetCurrGlosGroup(), aShortNameEdit.GetText());
372 }
373 else
374 ShowAutoText(aEmptyStr, aEmptyStr);
375 //Controls aktualisieren
376 NameModify(&aShortNameEdit);
377 if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
378 {
379 SfxRequest aReq( pSh->GetView().GetViewFrame(), FN_SET_ACT_GLOSSARY );
380 String sTemp(*::GetCurrGlosGroup());
381 // der nullte Pfad wird nicht aufgezeichnet!
382 if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
383 sTemp = sTemp.GetToken(0, GLOS_DELIM);
384 aReq.AppendItem(SfxStringItem(FN_SET_ACT_GLOSSARY, sTemp));
385 aReq.Done();
386 }
387 return 0;
388 }
389 /*--------------------------------------------------------------------
390 Beschreibung:
391 --------------------------------------------------------------------*/
392
393
394 void SwGlossaryDlg::Apply()
395 {
396 const String aGlosName(aShortNameEdit.GetText());
397 if(aGlosName.Len()) pGlossaryHdl->InsertGlossary(aGlosName);
398 if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
399 {
400 SfxRequest aReq( pSh->GetView().GetViewFrame(), FN_INSERT_GLOSSARY );
401 String sTemp(*::GetCurrGlosGroup());
402 // der nullte Pfad wird nicht aufgezeichnet!
403 if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
404 sTemp = sTemp.GetToken(0, GLOS_DELIM);
405 aReq.AppendItem(SfxStringItem(FN_INSERT_GLOSSARY, sTemp));
406 aReq.AppendItem(SfxStringItem(FN_PARAM_1, aGlosName));
407 aReq.Done();
408 }
409 }
410 /*--------------------------------------------------------------------
411 Beschreibung:
412 --------------------------------------------------------------------*/
413 /* inline */ void SwGlossaryDlg::EnableShortName(sal_Bool bOn)
414 {
415 aShortNameLbl.Enable(bOn);
416 aShortNameEdit.Enable(bOn);
417 }
418
419 /* -----------------26.11.98 16:15-------------------
420 * existiert der Titel in der ausgewaehlten Gruppe?
421 * --------------------------------------------------*/
422 SvLBoxEntry* SwGlossaryDlg::DoesBlockExist(const String& rBlock,
423 const String& rShort)
424 {
425 //evtl. vorhandenen Eintrag in der TreeListBox suchen
426 SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
427 if(pEntry)
428 {
429 if(aCategoryBox.GetParent(pEntry))
430 pEntry = aCategoryBox.GetParent(pEntry);
431 sal_uInt32 nChildCount = aCategoryBox.GetChildCount( pEntry );
432 for(sal_uInt32 i = 0; i < nChildCount; i++)
433 {
434 SvLBoxEntry* pChild = aCategoryBox.GetEntry( pEntry, i );
435 if(rBlock == aCategoryBox.GetEntryText(pChild) &&
436 (!rShort.Len() || rShort == *(String*)pChild->GetUserData()))
437 {
438 return pChild;
439 }
440 }
441 }
442 return 0;
443 }
444
445 /*--------------------------------------------------------------------
446 Beschreibung:
447 --------------------------------------------------------------------*/
448
449
450 IMPL_LINK( SwGlossaryDlg, NameModify, Edit *, pEdit )
451 {
452 String aName(aNameED.GetText());
453 sal_Bool bNameED = pEdit == &aNameED;
454 if( !aName.Len() )
455 {
456 if(bNameED)
457 aShortNameEdit.SetText(aName);
458 aInsertBtn.Enable(sal_False);
459 return 0;
460 }
461 String sShortSearch;
462 if(!bNameED)
463 sShortSearch = pEdit->GetText();
464 sal_Bool bNotFound = !DoesBlockExist(aName, sShortSearch);
465 if(bNameED)
466 {
467 // ist der Text durch einen Klick in die Listbox in das
468 // Edit gekommem?
469 if(bNotFound)
470 {
471 aShortNameEdit.SetText( lcl_GetValidShortCut( aName ) );
472 EnableShortName();
473 }
474 else
475 {
476 aShortNameEdit.SetText(pGlossaryHdl->GetGlossaryShortName(aName));
477 EnableShortName(!bReadOnly);
478 }
479 aInsertBtn.Enable(!bNotFound && !bIsDocReadOnly);
480 }
481 else
482 {
483 //ShortNameEdit
484 if(!bNotFound)
485 {
486 sal_Bool bEnable = !bNotFound;
487 bEnable &= !bIsDocReadOnly;
488 aInsertBtn.Enable(bEnable);
489 }
490 }
491 return 0;
492 }
493 /*--------------------------------------------------------------------
494 Beschreibung:
495 --------------------------------------------------------------------*/
496
497
498 IMPL_LINK_INLINE_START( SwGlossaryDlg, NameDoubleClick, SvTreeListBox*, pBox )
499 {
500 SvLBoxEntry* pEntry = pBox->FirstSelected();
501 if(pBox->GetParent(pEntry) && !bIsDocReadOnly)
502 EndDialog( RET_OK );
503 return 0;
504 }
505 IMPL_LINK_INLINE_END( SwGlossaryDlg, NameDoubleClick, SvTreeListBox*, EMPTYARG )
506 /*--------------------------------------------------------------------
507 Beschreibung:
508 --------------------------------------------------------------------*/
509
510
511 IMPL_LINK( SwGlossaryDlg, EnableHdl, Menu *, pMn )
512 {
513 const String aEditText(aNameED.GetText());
514 const sal_Bool bHasEntry = aEditText.Len() && aShortNameEdit.GetText().Len();
515 const sal_Bool bExists = 0 != DoesBlockExist(aEditText, aShortNameEdit.GetText());
516 pMn->EnableItem(FN_GL_DEFINE, bSelection && bHasEntry && !bExists);
517 pMn->EnableItem(FN_GL_DEFINE_TEXT, bSelection && bHasEntry && !bExists);
518 pMn->EnableItem(FN_GL_COPY_TO_CLIPBOARD, bExists);
519 pMn->EnableItem(FN_GL_REPLACE, bSelection && bExists && !bIsOld );
520 pMn->EnableItem(FN_GL_REPLACE_TEXT, bSelection && bExists && !bIsOld );
521 pMn->EnableItem(FN_GL_EDIT, bExists );
522 pMn->EnableItem(FN_GL_RENAME, bExists );
523 pMn->EnableItem(FN_GL_DELETE, bExists );
524 pMn->EnableItem(FN_GL_MACRO, bExists && !bIsOld &&
525 !pGlossaryHdl->IsReadOnly() );
526
527 SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
528 sal_Bool bEnable = sal_False;
529 if ( pEntry )
530 bEnable = !aCategoryBox.GetParent( pEntry ) && !bIsOld && !pGlossaryHdl->IsReadOnly();
531 pMn->EnableItem( FN_GL_IMPORT, bEnable );
532 return 1;
533 }
534 /*--------------------------------------------------------------------
535 Beschreibung:
536 --------------------------------------------------------------------*/
537
538
539 IMPL_LINK( SwGlossaryDlg, MenuHdl, Menu *, pMn )
540 {
541 sal_Bool bNoAttr = sal_False;
542
543 switch(pMn->GetCurItemId())
544 {
545 case FN_GL_REPLACE:
546 case FN_GL_REPLACE_TEXT:
547 pGlossaryHdl->NewGlossary( aNameED.GetText(),
548 aShortNameEdit.GetText(),
549 sal_False,
550 pMn->GetCurItemId() == FN_GL_REPLACE_TEXT);
551 break;
552 case FN_GL_DEFINE_TEXT:
553 bNoAttr = sal_True;
554 // Kein break!!!
555 case FN_GL_DEFINE:
556 {
557 const String aStr(aNameED.GetText());
558 const String aShortName(aShortNameEdit.GetText());
559 if(pGlossaryHdl->HasShortName(aShortName))
560 {
561 InfoBox(this, SW_RES(MSG_DOUBLE_SHORTNAME)).Execute();
562 aShortNameEdit.SetSelection(Selection(0, SELECTION_MAX));
563 aShortNameEdit.GrabFocus();
564 break;
565 }
566 if(pGlossaryHdl->NewGlossary(aStr, aShortName, sal_False, bNoAttr ))
567 {
568 SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
569 if(aCategoryBox.GetParent(pEntry))
570 pEntry = aCategoryBox.GetParent(pEntry);
571
572 SvLBoxEntry* pChild = aCategoryBox.InsertEntry(aStr, pEntry);
573 pChild->SetUserData(new String(aShortName));
574 aNameED.SetText(aStr);
575 aShortNameEdit.SetText(aShortName);
576 NameModify(&aNameED); // fuer Schalten der Buttons
577
578 if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
579 {
580 SfxRequest aReq(pSh->GetView().GetViewFrame(), FN_NEW_GLOSSARY);
581 String sTemp(*::GetCurrGlosGroup());
582 // der nullte Pfad wird nicht aufgezeichnet!
583 if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
584 sTemp = sTemp.GetToken(0, GLOS_DELIM);
585 aReq.AppendItem(SfxStringItem(FN_NEW_GLOSSARY, sTemp));
586 aReq.AppendItem(SfxStringItem(FN_PARAM_1, aShortName));
587 aReq.AppendItem(SfxStringItem(FN_PARAM_2, aStr));
588 aReq.Done();
589 }
590 }
591 }
592 break;
593 case FN_GL_COPY_TO_CLIPBOARD :
594 {
595 pGlossaryHdl->CopyToClipboard(*pSh, aShortNameEdit.GetText());
596 }
597 break;
598 case FN_GL_EDIT:
599 break;
600 case FN_GL_RENAME:
601 {
602 aShortNameEdit.SetText(pGlossaryHdl->GetGlossaryShortName(aNameED.GetText()));
603 SwNewGlosNameDlg* pNewNameDlg = new SwNewGlosNameDlg(this, aNameED.GetText(),
604 aShortNameEdit.GetText() );
605 if( RET_OK == pNewNameDlg->Execute() &&
606 pGlossaryHdl->Rename( aShortNameEdit.GetText(),
607 pNewNameDlg->GetNewShort(),
608 pNewNameDlg->GetNewName()))
609 {
610 SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
611 SvLBoxEntry* pNewEntry = aCategoryBox.InsertEntry(
612 pNewNameDlg->GetNewName(), aCategoryBox.GetParent(pEntry));
613 pNewEntry->SetUserData(new String(pNewNameDlg->GetNewShort()));
614 delete (String*)pEntry->GetUserData();
615 aCategoryBox.GetModel()->Remove(pEntry);
616 aCategoryBox.Select(pNewEntry);
617 aCategoryBox.MakeVisible(pNewEntry);
618 }
619 GrpSelect( &aCategoryBox );
620 delete pNewNameDlg;
621 }
622 break;
623 case FN_GL_DELETE:
624 {
625 QueryBox aQuery(this, SW_RES(MSG_QUERY_DELETE));
626 if(RET_YES == aQuery.Execute())
627 {
628 const String aShortName(aShortNameEdit.GetText());
629 const String aTitle(aNameED.GetText());
630 if(aTitle.Len() && pGlossaryHdl->DelGlossary(aShortName))
631 {
632 SvLBoxEntry* pChild = DoesBlockExist(aTitle, aShortName);
633 DBG_ASSERT(pChild, "Eintrag nicht gefunden!");
634 SvLBoxEntry* pParent = aCategoryBox.GetParent(pChild);
635 aCategoryBox.Select(pParent);
636
637 aCategoryBox.GetModel()->Remove(pChild);
638 aNameED.SetText( aEmptyStr );
639 NameModify(&aNameED);
640 }
641 }
642 }
643 break;
644 case FN_GL_MACRO:
645 {
646 SfxItemSet aSet( pSh->GetAttrPool(), RES_FRMMACRO, RES_FRMMACRO, SID_EVENTCONFIG, SID_EVENTCONFIG, 0 );
647
648 SvxMacro aStart(aEmptyStr, aEmptyStr, STARBASIC);
649 SvxMacro aEnd(aEmptyStr, aEmptyStr, STARBASIC);
650 pGlossaryHdl->GetMacros(aShortNameEdit.GetText(), aStart, aEnd );
651
652 SvxMacroItem aItem(RES_FRMMACRO);
653 if( aStart.GetMacName().Len() )
654 aItem.SetMacro( SW_EVENT_START_INS_GLOSSARY, aStart );
655 if( aEnd.GetMacName().Len() )
656 aItem.SetMacro( SW_EVENT_END_INS_GLOSSARY, aEnd );
657
658 aSet.Put( aItem );
659 aSet.Put( SwMacroAssignDlg::AddEvents( MACASSGN_TEXTBAUST ) );
660
661 const SfxPoolItem* pItem;
662 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
663 SfxAbstractDialog* pMacroDlg = pFact->CreateSfxDialog( this, aSet,
664 pSh->GetView().GetViewFrame()->GetFrame()->GetFrameInterface(), SID_EVENTCONFIG );
665 if ( pMacroDlg && pMacroDlg->Execute() == RET_OK &&
666 SFX_ITEM_SET == pMacroDlg->GetOutputItemSet()->GetItemState( RES_FRMMACRO, sal_False, &pItem ) )
667 {
668 const SvxMacroTableDtor& rTbl = ((SvxMacroItem*)pItem)->GetMacroTable();
669 pGlossaryHdl->SetMacros( aShortNameEdit.GetText(),
670 rTbl.Get( SW_EVENT_START_INS_GLOSSARY ),
671 rTbl.Get( SW_EVENT_END_INS_GLOSSARY ) );
672 }
673
674 delete pMacroDlg;
675 }
676 break;
677
678 case FN_GL_IMPORT:
679 {
680 // call the FileOpenDialog do find WinWord - Files with templates
681 FileDialogHelper aDlgHelper( TemplateDescription::FILEOPEN_SIMPLE, 0 );
682 uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker();
683
684 SvtPathOptions aPathOpt;
685 xFP->setDisplayDirectory(aPathOpt.GetWorkPath() );
686 String sWW8( C2S( FILTER_WW8 ) );
687
688 uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY);
689 SfxFilterMatcher aMatcher( String::CreateFromAscii(SwDocShell::Factory().GetShortName()) );
690 SfxFilterMatcherIter aIter( &aMatcher );
691 const SfxFilter* pFilter = aIter.First();
692 while ( pFilter )
693 {
694 if( pFilter->GetUserData() == sWW8 )
695 {
696 xFltMgr->appendFilter( pFilter->GetUIName(),
697 ((WildCard&)pFilter->GetWildcard()).GetWildCard() );
698 xFltMgr->setCurrentFilter( pFilter->GetUIName() ) ;
699 }
700
701 pFilter = aIter.Next();
702 }
703
704 if( aDlgHelper.Execute() == ERRCODE_NONE )
705 {
706 if( pGlossaryHdl->ImportGlossaries( xFP->getFiles().getConstArray()[0] ))
707 Init();
708 else
709 {
710 InfoBox(this, SW_RES( MSG_NO_GLOSSARIES )).Execute();
711 }
712 }
713 }
714 break;
715
716 default:
717 return 0;
718 }
719 return 1;
720 }
721 /*--------------------------------------------------------------------
722 Beschreibung: Dialog Verwaltung Bereiche
723 --------------------------------------------------------------------*/
724
725
726 IMPL_LINK( SwGlossaryDlg, BibHdl, Button *, EMPTYARG )
727 {
728 SwGlossaries* pGloss = ::GetGlossaries();
729 if( pGloss->IsGlosPathErr() )
730 pGloss->ShowError();
731 else
732 {
733 //check if at least one glossary path is write enabled
734 SvtPathOptions aPathOpt;
735 String sGlosPath( aPathOpt.GetAutoTextPath() );
736 USHORT nPaths = sGlosPath.GetTokenCount(';');
737 BOOL bIsWritable = FALSE;
738 for(USHORT nPath = 0; nPath < nPaths; nPath++)
739 {
740 String sPath = URIHelper::SmartRel2Abs(
741 INetURLObject(), sGlosPath.GetToken(nPath, ';'),
742 URIHelper::GetMaybeFileHdl());
743 try
744 {
745 Content aTestContent( sPath,
746 uno::Reference< XCommandEnvironment >());
747 Any aAny = aTestContent.getPropertyValue( C2U("IsReadOnly") );
748 if(aAny.hasValue())
749 {
750 bIsWritable = !*(sal_Bool*)aAny.getValue();
751 }
752 }
753 catch(Exception&)
754 {}
755 if(bIsWritable)
756 break;
757 }
758 if(bIsWritable)
759 {
760
761 SwGlossaryGroupDlg *pDlg = new SwGlossaryGroupDlg( this, pGloss->GetPathArray(), pGlossaryHdl );
762 if ( RET_OK == pDlg->Execute() )
763 {
764 Init();
765 //if new groups were created - select one of them
766 String sNewGroup = pDlg->GetCreatedGroupName();
767 SvLBoxEntry* pEntry = aCategoryBox.First();
768 while(sNewGroup.Len() && pEntry)
769 {
770 if(!aCategoryBox.GetParent(pEntry))
771 {
772 GroupUserData* pGroupData = (GroupUserData*)pEntry->GetUserData();
773 String sGroup = pGroupData->sGroupName;
774 sGroup += GLOS_DELIM;
775 sGroup += String::CreateFromInt32(pGroupData->nPathIdx);
776 if(sGroup == sNewGroup)
777 {
778 aCategoryBox.Select(pEntry);
779 aCategoryBox.MakeVisible(pEntry);
780 GrpSelect(&aCategoryBox);
781 break;
782 }
783 }
784 pEntry = aCategoryBox.Next(pEntry);
785 }
786
787 }
788 delete pDlg;
789 }
790 else
791 {
792 QueryBox aBox(this, WB_YES_NO, sReadonlyPath);
793 if(RET_YES == aBox.Execute())
794 PathHdl(&aPathBtn);
795 }
796 }
797 return 0;
798 }
799
800 /*------------------------------------------------------------------------
801 Beschreibung: Initialisierung; aus Ctor und nach Bearbeiten Bereiche
802 ------------------------------------------------------------------------*/
803
804
805 void SwGlossaryDlg::Init()
806 {
807 aCategoryBox.SetUpdateMode( sal_False );
808 aCategoryBox.Clear();
809 // Textbausteinbereiche anzeigen
810 const sal_uInt16 nCnt = pGlossaryHdl->GetGroupCnt();
811 SvLBoxEntry* pSelEntry = 0;
812 const String sSelStr(::GetCurrGlosGroup()->GetToken(0, GLOS_DELIM));
813 const sal_uInt16 nSelPath = static_cast< sal_uInt16 >(::GetCurrGlosGroup()->GetToken(1, GLOS_DELIM).ToInt32());
814 for(sal_uInt16 nId = 0; nId < nCnt; ++nId )
815 {
816 String sTitle;
817 String sGroupName(pGlossaryHdl->GetGroupName(nId, &sTitle));
818 if(!sGroupName.Len())
819 continue;
820 if(!sTitle.Len())
821 sTitle = sGroupName.GetToken( 0, GLOS_DELIM );
822 SvLBoxEntry* pEntry = aCategoryBox.InsertEntry( sTitle );
823 sal_uInt16 nPath = static_cast< sal_uInt16 >(sGroupName.GetToken( 1, GLOS_DELIM ).ToInt32());
824
825 GroupUserData* pData = new GroupUserData;
826 pData->sGroupName = sGroupName.GetToken(0, GLOS_DELIM);
827 pData->nPathIdx = nPath;
828 pData->bReadonly = pGlossaryHdl->IsReadOnly(&sGroupName);
829
830 pEntry->SetUserData(pData);
831 if(sSelStr == pData->sGroupName && nSelPath == nPath)
832 pSelEntry = pEntry;
833
834 //Eintraege fuer die Gruppen auffuellen
835 {
836 pGlossaryHdl->SetCurGroup(sGroupName, sal_False, sal_True);
837 const sal_uInt16 nCount = pGlossaryHdl->GetGlossaryCnt();
838 for(sal_uInt16 i = 0; i < nCount; ++i)
839 {
840 String sGroupTitle(pGlossaryHdl->GetGlossaryName(i));
841 SvLBoxEntry* pChild = aCategoryBox.InsertEntry(
842 sGroupTitle, pEntry);
843 pChild->SetUserData(new String(pGlossaryHdl->GetGlossaryShortName(i)));
844 }
845 }
846 }
847 // Aktuelle Gruppe setzen und Textbausteine anzeigen
848 if(!pSelEntry)
849 {
850 //find a non-readonly group
851 SvLBoxEntry* pSearch = aCategoryBox.First();
852 while(pSearch)
853 {
854 if(!aCategoryBox.GetParent(pSearch))
855 {
856 GroupUserData* pData = (GroupUserData*)pSearch->GetUserData();
857 if(!pData->bReadonly)
858 {
859 pSelEntry = pSearch;
860 break;
861 }
862 }
863 pSearch = aCategoryBox.Next(pSearch);
864 }
865 if(!pSelEntry)
866 pSelEntry = aCategoryBox.GetEntry(0);
867 }
868 if(pSelEntry)
869 {
870 aCategoryBox.Expand(pSelEntry);
871 aCategoryBox.Select(pSelEntry);
872 aCategoryBox.MakeVisible(pSelEntry);
873 GrpSelect(&aCategoryBox);
874 }
875 //JP 16.11.99: the SvxTreeListBox has a Bug. The Box dont recalc the
876 // outputsize, when all entries are insertet. The result is, that
877 // the Focus/Highlight rectangle is to large and paintet over the
878 // HScrollbar. -> Fix: call the resize
879 aCategoryBox.Resize();
880
881 aCategoryBox.GetModel()->Resort();
882 aCategoryBox.SetUpdateMode( sal_True );
883 aCategoryBox.Update();
884
885 const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
886 aFileRelCB.Check( pCfg->IsSaveRelFile() );
887 aFileRelCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
888 aNetRelCB.Check( pCfg->IsSaveRelNet() );
889 aNetRelCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
890 aInsertTipCB.Check( pCfg->IsAutoTextTip() );
891 aInsertTipCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
892 }
893 /*------------------------------------------------------------------------
894 Beschreibung:
895 ------------------------------------------------------------------------*/
896
897
898 IMPL_LINK_INLINE_START( SwGlossaryDlg, EditHdl, Button *, EMPTYARG )
899 {
900 //EndDialog darf nicht im MenuHdl aufgerufen werden
901 if(aEditBtn.GetCurItemId() == FN_GL_EDIT )
902 {
903 SwTextBlocks *pGroup = ::GetGlossaries()->GetGroupDoc ( GetCurrGrpName () );
904 BOOL bRet = pGlossaryHdl->ConvertToNew ( *pGroup );
905 delete pGroup;
906 if ( bRet )
907 EndDialog(RET_EDIT);
908 }
909 return 0;
910 }
911 IMPL_LINK_INLINE_END( SwGlossaryDlg, EditHdl, Button *, EMPTYARG )
912
913 /*------------------------------------------------------------------------
914 Beschreibung: KeyInput fuer ShortName - Edits ohne Spaces
915 ------------------------------------------------------------------------*/
916
917 IMPL_LINK( SwNewGlosNameDlg, Modify, Edit *, pBox )
918 {
919 String aName(aNewName.GetText());
920 SwGlossaryDlg* pDlg = (SwGlossaryDlg*)GetParent();
921
922 if( pBox == &aNewName )
923 aNewShort.SetText( lcl_GetValidShortCut( aName ) );
924
925 sal_Bool bEnable = aName.Len() && aNewShort.GetText().Len() &&
926 (!pDlg->DoesBlockExist(aName, aNewShort.GetText())
927 || aName == aOldName.GetText());
928 aOk.Enable(bEnable);
929 return 0;
930 }
931 /*------------------------------------------------------------------------
932 Beschreibung:
933 ------------------------------------------------------------------------*/
934
935 IMPL_LINK( SwNewGlosNameDlg, Rename, Button *, EMPTYARG )
936 {
937 SwGlossaryDlg* pDlg = (SwGlossaryDlg*)GetParent();
938 String sNew = aNewShort.GetText();
939 GetAppCharClass().toUpper(sNew);
940 if( pDlg->pGlossaryHdl->HasShortName(aNewShort.GetText())
941 && sNew != aOldShort.GetText() )
942 {
943 InfoBox(this, SW_RES(MSG_DOUBLE_SHORTNAME)).Execute();
944 aNewShort.GrabFocus();
945 }
946 else
947 EndDialog(sal_True);
948 return 0;
949 }
950
951 /*------------------------------------------------------------------------
952 Beschreibung:
953 ------------------------------------------------------------------------*/
954
955 IMPL_LINK( SwGlossaryDlg, CheckBoxHdl, CheckBox *, pBox )
956 {
957 SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
958 sal_Bool bCheck = pBox->IsChecked();
959 if( pBox == &aInsertTipCB )
960 pCfg->SetAutoTextTip(bCheck);
961 else if(pBox == &aFileRelCB)
962 pCfg->SetSaveRelFile(bCheck);
963 else
964 pCfg->SetSaveRelNet(bCheck);
965 return 0;
966 }
967
968 /* -----------------26.11.98 15:18-------------------
969 * TreeListBox fuer Gruppen und Bausteine
970 * --------------------------------------------------*/
971 SwGlTreeListBox::SwGlTreeListBox(Window* pParent, const ResId& rResId) :
972 SvTreeListBox(pParent, rResId),
973 sReadonly (SW_RES(ST_READONLY)),
974 pDragEntry(0)
975 {
976 FreeResource();
977 SetDragDropMode( SV_DRAGDROP_CTRL_MOVE|SV_DRAGDROP_CTRL_COPY );
978 }
979 /* -----------------30.11.98 10:49-------------------
980 *
981 * --------------------------------------------------*/
982 void SwGlTreeListBox::Clear()
983 {
984 SvLBoxEntry* pEntry = First();
985 while(pEntry)
986 {
987 if(GetParent(pEntry))
988 delete (String*)pEntry->GetUserData();
989 else
990 delete (GroupUserData*)pEntry->GetUserData();
991 pEntry = Next(pEntry);
992 }
993 SvTreeListBox::Clear();
994 }
995
996 /*-----------------10.06.97 14.52-------------------
997
998 --------------------------------------------------*/
999 void SwGlTreeListBox::RequestHelp( const HelpEvent& rHEvt )
1000 {
1001 Point aPos( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ));
1002 SvLBoxEntry* pEntry = GetEntry( aPos );
1003 // Hilfe gibt es nur fuer die Gruppennamen
1004 if(pEntry)
1005 {
1006 SvLBoxTab* pTab;
1007 SvLBoxItem* pItem = GetItem( pEntry, aPos.X(), &pTab );
1008 if(pItem)
1009 {
1010 aPos = GetEntryPosition( pEntry );
1011 Size aSize(pItem->GetSize( this, pEntry ));
1012 aPos.X() = GetTabPos( pEntry, pTab );
1013
1014 if((aPos.X() + aSize.Width()) > GetSizePixel().Width())
1015 aSize.Width() = GetSizePixel().Width() - aPos.X();
1016 aPos = OutputToScreenPixel(aPos);
1017 Rectangle aItemRect( aPos, aSize );
1018 String sMsg;
1019 if(!GetParent(pEntry))
1020 {
1021 GroupUserData* pData = (GroupUserData*)pEntry->GetUserData();
1022 const SvStrings* pPathArr = ::GetGlossaries()->GetPathArray();
1023 if(pPathArr->Count())
1024 {
1025 sMsg = (*(*pPathArr)[pData->nPathIdx]);
1026 sMsg += INET_PATH_TOKEN;
1027 sMsg += pData->sGroupName;
1028 sMsg += SwGlossaries::GetExtension();
1029 INetURLObject aTmp(sMsg);
1030 sMsg = aTmp.GetPath();
1031
1032 if(pData->bReadonly)
1033 {
1034 sMsg += ' ';
1035 sMsg += '(';
1036 sMsg += sReadonly;
1037 sMsg += ')';
1038 }
1039
1040
1041 }
1042 }
1043 else
1044 sMsg = *(String*)pEntry->GetUserData();
1045 Help::ShowQuickHelp( this, aItemRect, sMsg,
1046 QUICKHELP_LEFT|QUICKHELP_VCENTER );
1047 }
1048 }
1049 }
1050 /* -----------------26.11.98 14:42-------------------
1051 *
1052 * --------------------------------------------------*/
1053 DragDropMode SwGlTreeListBox::NotifyStartDrag(
1054 TransferDataContainer& /*rContainer*/,
1055 SvLBoxEntry* pEntry )
1056 {
1057 DragDropMode eRet;
1058 pDragEntry = pEntry;
1059 if(!GetParent(pEntry))
1060 eRet = SV_DRAGDROP_NONE;
1061 else
1062 {
1063 SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
1064 SvLBoxEntry* pParent = GetParent(pEntry);
1065
1066 GroupUserData* pGroupData = (GroupUserData*)pParent->GetUserData();
1067 String sEntry(pGroupData->sGroupName);
1068 sEntry += GLOS_DELIM;
1069 sEntry += String::CreateFromInt32(pGroupData->nPathIdx);
1070 sal_Int8 nDragOption = DND_ACTION_COPY;
1071 eRet = SV_DRAGDROP_CTRL_COPY;
1072 if(!pDlg->pGlossaryHdl->IsReadOnly(&sEntry))
1073 {
1074 eRet |= SV_DRAGDROP_CTRL_MOVE;
1075 nDragOption |= DND_ACTION_MOVE;
1076 }
1077 SetDragOptions( nDragOption );
1078 }
1079 return eRet;
1080 }
1081 /* -----------------27.11.98 09:35-------------------
1082 *
1083 * --------------------------------------------------*/
1084 sal_Bool SwGlTreeListBox::NotifyAcceptDrop( SvLBoxEntry* pEntry)
1085 {
1086 // TODO: Readonly - Ueberpruefung fehlt noch!
1087 SvLBoxEntry* pSrcParent = GetParent(pEntry) ? GetParent(pEntry) : pEntry;
1088 SvLBoxEntry* pDestParent =
1089 GetParent(pDragEntry ) ? GetParent(pDragEntry ) : pDragEntry ;
1090 return pDestParent != pSrcParent;
1091
1092 }
1093 /* -----------------26.11.98 14:42-------------------
1094 *
1095 * --------------------------------------------------*/
1096 sal_Bool SwGlTreeListBox::NotifyMoving( SvLBoxEntry* pTarget,
1097 SvLBoxEntry* pEntry,
1098 SvLBoxEntry*& /*rpNewParent*/,
1099 ULONG& /*rNewChildPos*/
1100 )
1101 {
1102 pDragEntry = 0;
1103 if(!pTarget) //An den Anfang verschieben
1104 {
1105 pTarget = GetEntry(0);
1106 }
1107 // 1. wird in verschiedene Gruppen verschoben?
1108 // 2. darf in beiden Gruppen geschrieben werden?
1109 SvLBoxEntry* pSrcParent = GetParent(pEntry);
1110 SvLBoxEntry* pDestParent =
1111 GetParent(pTarget) ? GetParent(pTarget) : pTarget;
1112 sal_Bool bRet = sal_False;
1113 if(pDestParent != pSrcParent)
1114 {
1115 SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
1116 SwWait aWait( *pDlg->pSh->GetView().GetDocShell(), sal_True );
1117
1118 GroupUserData* pGroupData = (GroupUserData*)pSrcParent->GetUserData();
1119 String sSourceGroup(pGroupData->sGroupName);
1120 sSourceGroup += GLOS_DELIM;
1121 sSourceGroup += String::CreateFromInt32(pGroupData->nPathIdx);
1122 pDlg->pGlossaryHdl->SetCurGroup(sSourceGroup);
1123 String sTitle(GetEntryText(pEntry));
1124 String sShortName(*(String*)pEntry->GetUserData());
1125
1126 GroupUserData* pDestData = (GroupUserData*)pDestParent->GetUserData();
1127 String sDestName = pDestData->sGroupName;
1128 sDestName += GLOS_DELIM;
1129 sDestName += String::CreateFromInt32(pDestData->nPathIdx);
1130 bRet = pDlg->pGlossaryHdl->CopyOrMove( sSourceGroup, sShortName,
1131 sDestName, sTitle, sal_True );
1132 if(bRet)
1133 {
1134 SvLBoxEntry* pChild = InsertEntry(sTitle, pDestParent);
1135 pChild->SetUserData(new String(sShortName));
1136 GetModel()->Remove(pEntry);
1137 }
1138 }
1139 return sal_False; //sonst wird der Eintrag automatisch vorgenommen
1140 }
1141 /* -----------------26.11.98 14:42-------------------
1142 *
1143 * --------------------------------------------------*/
1144 sal_Bool SwGlTreeListBox::NotifyCopying( SvLBoxEntry* pTarget,
1145 SvLBoxEntry* pEntry,
1146 SvLBoxEntry*& /*rpNewParent*/,
1147 ULONG& /*rNewChildPos*/
1148 )
1149 {
1150 pDragEntry = 0;
1151 // 1. wird in verschiedene Gruppen verschoben?
1152 // 2. darf in beiden Gruppen geschrieben werden?
1153 if(!pTarget) //An den Anfang verschieben
1154 {
1155 pTarget = GetEntry(0);
1156 }
1157 SvLBoxEntry* pSrcParent = GetParent(pEntry);
1158 SvLBoxEntry* pDestParent =
1159 GetParent(pTarget) ? GetParent(pTarget) : pTarget;
1160 sal_Bool bRet = sal_False;
1161 if(pDestParent != pSrcParent)
1162 {
1163 SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
1164 SwWait aWait( *pDlg->pSh->GetView().GetDocShell(), sal_True );
1165
1166 GroupUserData* pGroupData = (GroupUserData*)pSrcParent->GetUserData();
1167 String sSourceGroup(pGroupData->sGroupName);
1168 sSourceGroup += GLOS_DELIM;
1169 sSourceGroup += String::CreateFromInt32(pGroupData->nPathIdx);
1170
1171 pDlg->pGlossaryHdl->SetCurGroup(sSourceGroup);
1172 String sTitle(GetEntryText(pEntry));
1173 String sShortName(*(String*)pEntry->GetUserData());
1174
1175 GroupUserData* pDestData = (GroupUserData*)pDestParent->GetUserData();
1176 String sDestName = pDestData->sGroupName;
1177 sDestName += GLOS_DELIM;
1178 sDestName += String::CreateFromInt32(pDestData->nPathIdx);
1179
1180 bRet = pDlg->pGlossaryHdl->CopyOrMove( sSourceGroup, sShortName,
1181 sDestName, sTitle, sal_False );
1182 if(bRet)
1183 {
1184 SvLBoxEntry* pChild = InsertEntry(sTitle, pDestParent);
1185 pChild->SetUserData(new String(sShortName));
1186 }
1187 }
1188 return sal_False; //sonst wird der Eintrag automatisch vorgenommen
1189 }
1190
1191
1192 /*-----------------10.06.97 15.18-------------------
1193
1194 --------------------------------------------------*/
1195 String SwGlossaryDlg::GetCurrGrpName() const
1196 {
1197 SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
1198 String sRet;
1199 if(pEntry)
1200 {
1201 pEntry =
1202 aCategoryBox.GetParent(pEntry) ? aCategoryBox.GetParent(pEntry) : pEntry;
1203 GroupUserData* pGroupData = (GroupUserData*)pEntry->GetUserData();
1204 sRet = pGroupData->sGroupName;
1205 sRet += GLOS_DELIM;
1206 sRet += String::CreateFromInt32(pGroupData->nPathIdx);
1207 }
1208 return sRet;
1209 }
1210
1211 /*-----------------11.06.97 08.17-------------------
1212
1213 --------------------------------------------------*/
1214 IMPL_LINK( SwGlossaryDlg, PathHdl, Button *, pBtn )
1215 {
1216 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1217 if(pFact)
1218 {
1219 AbstractSvxMultiPathDialog* pDlg = pFact->CreateSvxMultiPathDialog( pBtn, RID_SVXDLG_MULTIPATH);
1220 DBG_ASSERT(pDlg, "Dialogdiet fail!");
1221 SvtPathOptions aPathOpt;
1222 String sGlosPath( aPathOpt.GetAutoTextPath() );
1223 pDlg->SetPath(sGlosPath);
1224 if(RET_OK == pDlg->Execute())
1225 {
1226 String sTmp(pDlg->GetPath());
1227 if(sTmp != sGlosPath)
1228 {
1229 aPathOpt.SetAutoTextPath( sTmp );
1230 ::GetGlossaries()->UpdateGlosPath( sal_True );
1231 Init();
1232 }
1233 }
1234 delete pDlg;
1235 }
1236 return 0;
1237 }
1238 /* -----------------28.07.99 13:48-------------------
1239
1240 --------------------------------------------------*/
1241 IMPL_LINK( SwGlossaryDlg, ShowPreviewHdl, CheckBox *, pBox )
1242 {
1243 sal_Bool bCreated = sal_False;
1244 if(pBox->IsChecked())
1245 {
1246 //create example
1247 if(!pExampleFrame)
1248 {
1249 Link aLink(LINK(this, SwGlossaryDlg, PreviewLoadedHdl));
1250 pExampleFrame = new SwOneExampleFrame( aExampleWIN,
1251 EX_SHOW_ONLINE_LAYOUT, &aLink );
1252 bCreated = sal_True;
1253 }
1254 }
1255
1256 BOOL bShow = pBox->IsChecked() && !bCreated;
1257 aExampleWIN.Show( bShow );
1258 aExampleDummyWIN.Show(!bShow);
1259 if( ::GetCurrGlosGroup() )
1260 ShowAutoText(*::GetCurrGlosGroup(), aShortNameEdit.GetText());
1261
1262 return 0;
1263 };
1264 /* -----------------18.11.99 17:09-------------------
1265
1266 --------------------------------------------------*/
1267 IMPL_LINK( SwGlossaryDlg, PreviewLoadedHdl, void *, EMPTYARG )
1268 {
1269 BOOL bShow = aShowExampleCB.IsChecked();
1270 aExampleWIN.Show( bShow );
1271 aExampleDummyWIN.Show(!bShow);
1272 ResumeShowAutoText();
1273 return 0;
1274 }
1275
1276 /* -----------------28.07.99 16:28-------------------
1277
1278 --------------------------------------------------*/
1279 void SwGlossaryDlg::ShowAutoText(const String& rGroup, const String& rShortName)
1280 {
1281 if(aExampleWIN.IsVisible())
1282 {
1283 SetResumeData(rGroup, rShortName);
1284 //try to make an Undo()
1285 pExampleFrame->ClearDocument( TRUE );
1286 }
1287 }
1288 /* -----------------------------21.12.00 11:33--------------------------------
1289
1290 ---------------------------------------------------------------------------*/
1291 void SwGlossaryDlg::ResumeShowAutoText()
1292 {
1293 String sGroup, sShortName;
1294 if(GetResumeData(sGroup, sShortName) && aExampleWIN.IsVisible())
1295 {
1296 if(!_xAutoText.is())
1297 {
1298 uno::Reference< lang::XMultiServiceFactory >
1299 xMgr = getProcessServiceFactory();
1300 //now the AutoText ListBoxes have to be filled
1301
1302 uno::Reference< uno::XInterface > xAText = xMgr->createInstance( C2U("com.sun.star.text.AutoTextContainer") );
1303 _xAutoText = uno::Reference< container::XNameAccess >(xAText, uno::UNO_QUERY);
1304 }
1305
1306 uno::Reference< XTextCursor > & xCrsr = pExampleFrame->GetTextCursor();
1307 if(xCrsr.is())
1308 {
1309 if(sShortName.Len())
1310 {
1311 uno::Any aGroup = _xAutoText->getByName(sGroup);
1312 uno::Reference< XAutoTextGroup > xGroup;
1313 OUString uShortName(sShortName);
1314 if((aGroup >>= xGroup) && xGroup->hasByName(uShortName))
1315 {
1316 uno::Any aEntry(xGroup->getByName(uShortName));
1317 uno::Reference< XAutoTextEntry > xEntry;
1318 aEntry >>= xEntry;
1319 uno::Reference< XTextRange > xRange(xCrsr, uno::UNO_QUERY);
1320 xEntry->applyTo(xRange);
1321 }
1322 }
1323 }
1324 }
1325 ResetResumeData();
1326 }
1327
1328
vba interoperability for OOo