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