?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sw / source / ui / index / swuiidxmrk.cxx
blobc3fc58bbff5c4f9f6e1e3deee8aef24752b96d57
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 "swuiidxmrk.hxx"
21 #include <hintids.hxx>
22 #include <helpid.h>
23 #include <comphelper/processfactory.hxx>
24 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
25 #include <com/sun/star/beans/PropertyValue.hpp>
26 #include <com/sun/star/beans/XPropertySet.hpp>
27 #include <com/sun/star/frame/Bibliography.hpp>
28 #include <com/sun/star/i18n/TransliterationModules.hpp>
29 #include <com/sun/star/i18n/IndexEntrySupplier.hpp>
30 #include <com/sun/star/util/SearchOptions.hpp>
31 #include <com/sun/star/util/SearchFlags.hpp>
32 #include <svl/stritem.hxx>
33 #include <vcl/layout.hxx>
34 #include <vcl/msgbox.hxx>
35 #include <sfx2/dispatch.hxx>
36 #include <svl/eitem.hxx>
37 #include <unotools/textsearch.hxx>
38 #include <editeng/scripttypeitem.hxx>
39 #include <svl/itemset.hxx>
40 #include <editeng/langitem.hxx>
41 #include "editeng/unolingu.hxx"
42 #include <swtypes.hxx>
43 #include <idxmrk.hxx>
44 #include <txttxmrk.hxx>
45 #include <wrtsh.hxx>
46 #include <view.hxx>
47 #include <multmrk.hxx>
48 #include <swundo.hxx> // for Undo-Ids
49 #include <cmdid.h>
50 #include <app.hrc>
51 #include <index.hrc>
52 #include <idxmrk.hrc>
53 #include <swmodule.hxx>
54 #include <fldmgr.hxx>
55 #include <fldbas.hxx>
56 #include <utlui.hrc>
57 #include <swcont.hxx>
58 #include <svl/cjkoptions.hxx>
59 #include <ndtxt.hxx>
60 #include <breakit.hxx>
61 #include <SwRewriter.hxx>
62
63 #include <unomid.h>
64
65
66 #define POS_CONTENT 0
67 #define POS_INDEX 1
68
69 static sal_uInt16 nTypePos = 1; // TOX_INDEX as standard
70 static sal_uInt16 nKey1Pos = USHRT_MAX;
71
72 static sal_uInt16 nKey2Pos = USHRT_MAX;
73
74 using namespace com::sun::star;
75 using namespace com::sun::star::i18n;
76 using namespace com::sun::star::lang;
77 using namespace com::sun::star::util;
78 using namespace ::comphelper;
79 using namespace ::com::sun::star;
80
81 /*--------------------------------------------------------------------
82 Description: dialog to insert a directory selection
83 --------------------------------------------------------------------*/
84 SwIndexMarkPane::SwIndexMarkPane(Dialog &rDialog, sal_Bool bNewDlg,
85 SwWrtShell& rWrtShell)
86 : m_rDialog(rDialog)
87 , bDel(false)
88 , bNewMark(bNewDlg)
89 , bSelected(sal_False)
90 , bPhoneticED0_ChangedByUser(sal_False)
91 , bPhoneticED1_ChangedByUser(sal_False)
92 , bPhoneticED2_ChangedByUser(sal_False)
93 , nLangForPhoneticReading(LANGUAGE_CHINESE_SIMPLIFIED)
94 , bIsPhoneticReadingEnabled(sal_False)
95 , xExtendedIndexEntrySupplier(NULL)
96 , pTOXMgr(0)
97 , pSh(&rWrtShell)
98 {
99 rDialog.get(m_pFrame, "frame");
100 rDialog.get(m_pTypeFT, "typeft");
101 rDialog.get(m_pTypeDCB, "typecb");
102 rDialog.get(m_pNewBT, "new");
103 m_pNewBT->SetAccessibleRelationMemberOf(m_pFrame->get_label_widget());
104 rDialog.get(m_pEntryED, "entryed");
105 rDialog.get(m_pPhoneticFT0, "phonetic0ft");
106 rDialog.get(m_pPhoneticED0, "phonetic0ed");
107 rDialog.get(m_pKey1FT, "key1ft");
108 rDialog.get(m_pKey1DCB, "key1cb");
109 rDialog.get(m_pPhoneticFT1, "phonetic1ft");
110 rDialog.get(m_pPhoneticED1, "phonetic1ed");
111 rDialog.get(m_pKey2FT, "key2ft");
112 rDialog.get(m_pKey2DCB, "key2cb");
113 rDialog.get(m_pPhoneticFT2, "phonetic2ft");
114 rDialog.get(m_pPhoneticED2, "phonetic2ed");
115 rDialog.get(m_pLevelFT, "levelft");
116 rDialog.get(m_pLevelNF, "levelnf");
117 rDialog.get(m_pMainEntryCB, "mainentrycb");
118 rDialog.get(m_pApplyToAllCB, "applytoallcb");
119 rDialog.get(m_pSearchCaseSensitiveCB, "searchcasesensitivecb");
120 rDialog.get(m_pSearchCaseWordOnlyCB, "searchcasewordonlycb");
121 rDialog.get(m_pCloseBT, "close");
122 rDialog.get(m_pDelBT, "delete");
123 rDialog.get(m_pPrevSameBT, "first");
124 rDialog.get(m_pNextSameBT, "last");
125 rDialog.get(m_pPrevBT, "previous");
126 rDialog.get(m_pNextBT, "next");
127
128 if (SvtCJKOptions().IsCJKFontEnabled())
129 {
130 uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
131
132 xExtendedIndexEntrySupplier = i18n::IndexEntrySupplier::create(xContext);
133
134 m_pPhoneticFT0->Show();
135 m_pPhoneticED0->Show();
136 m_pPhoneticFT1->Show();
137 m_pPhoneticED1->Show();
138 m_pPhoneticFT2->Show();
139 m_pPhoneticED2->Show();
140 }
141
142 rDialog.SetText( SW_RESSTR( bNewMark ? STR_IDXMRK_INSERT : STR_IDXMRK_EDIT));
143
144 m_pDelBT->SetClickHdl(LINK(this,SwIndexMarkPane, DelHdl));
145 m_pPrevBT->SetClickHdl(LINK(this,SwIndexMarkPane, PrevHdl));
146 m_pPrevSameBT->SetClickHdl(LINK(this,SwIndexMarkPane, PrevSameHdl));
147 m_pNextBT->SetClickHdl(LINK(this,SwIndexMarkPane, NextHdl));
148 m_pNextSameBT->SetClickHdl(LINK(this,SwIndexMarkPane, NextSameHdl));
149 m_pTypeDCB->SetSelectHdl(LINK(this,SwIndexMarkPane, ModifyHdl));
150 m_pKey1DCB->SetModifyHdl(LINK(this,SwIndexMarkPane, KeyDCBModifyHdl));
151 m_pKey2DCB->SetModifyHdl(LINK(this,SwIndexMarkPane, KeyDCBModifyHdl));
152 m_pCloseBT->SetClickHdl(LINK(this,SwIndexMarkPane, CloseHdl));
153 m_pEntryED->SetModifyHdl(LINK(this,SwIndexMarkPane, ModifyHdl));
154 m_pNewBT->SetClickHdl(LINK(this, SwIndexMarkPane, NewUserIdxHdl));
155 m_pApplyToAllCB->SetClickHdl(LINK(this, SwIndexMarkPane, SearchTypeHdl));
156 m_pPhoneticED0->SetModifyHdl(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
157 m_pPhoneticED1->SetModifyHdl(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
158 m_pPhoneticED2->SetModifyHdl(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
159
160 if(bNewMark)
161 {
162 m_pDelBT->Hide();
163 rDialog.get(m_pOKBT, "insert");
164 }
165 else
166 {
167 m_pNewBT->Hide();
168 rDialog.get(m_pOKBT, "ok");
169 }
170 m_pOKBT->Show();
171 m_pOKBT->SetClickHdl(LINK(this, SwIndexMarkPane, InsertHdl));
172
173 m_pEntryED->GrabFocus();
174 }
175
176 /*--------------------------------------------------------------------
177 Description: Newly initialise controls with the new selection
178 --------------------------------------------------------------------*/
179 void SwIndexMarkPane::InitControls()
180 {
181 OSL_ENSURE(pSh && pTOXMgr, "no shell?");
182 // contents index
183 const SwTOXType* pType = pTOXMgr->GetTOXType(TOX_CONTENT, 0);
184 OSL_ENSURE(pType, "Kein Verzeichnistyp !!");
185 String sTmpTypeSelection;
186 if(m_pTypeDCB->GetSelectEntryCount())
187 sTmpTypeSelection = m_pTypeDCB->GetSelectEntry();
188 m_pTypeDCB->Clear();
189 m_pTypeDCB->InsertEntry(pType->GetTypeName());
190
191 // keyword index
192 pType = pTOXMgr->GetTOXType(TOX_INDEX, 0);
193 OSL_ENSURE(pType, "Kein Verzeichnistyp !!");
194 m_pTypeDCB->InsertEntry(pType->GetTypeName());
195
196 // user index
197 sal_uInt16 nCount = pSh->GetTOXTypeCount(TOX_USER);
198 sal_uInt16 i;
199 for( i = 0; i < nCount; ++i )
200 m_pTypeDCB->InsertEntry( pSh->GetTOXType(TOX_USER, i)->GetTypeName() );
201
202 // read keywords primary
203 std::vector<String> aArr;
204 nCount = pSh->GetTOIKeys( TOI_PRIMARY, aArr );
205 std::sort(aArr.begin(), aArr.end());
206 for (std::vector<String>::iterator it = aArr.begin(); it != aArr.end(); ++it)
207 m_pKey1DCB->InsertEntry( *it );
208
209 // read keywords secondary
210 nCount = pSh->GetTOIKeys( TOI_SECONDARY, aArr );
211 std::sort(aArr.begin(), aArr.end());
212 for (std::vector<String>::iterator it = aArr.begin(); it != aArr.end(); ++it)
213 m_pKey2DCB->InsertEntry( *it );
214
215 UpdateLanguageDependenciesForPhoneticReading();
216
217 // current entry
218 const SwTOXMark* pMark = pTOXMgr->GetCurTOXMark();
219 if( pMark && !bNewMark)
220 {
221 // Controls-Handling
222
223 // only if there are more than one
224 // if equal it lands at the same entry
225 pSh->SttCrsrMove();
226
227 const SwTOXMark* pMoveMark;
228 bool bShow = false;
229
230 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_PRV );
231 if( pMoveMark != pMark )
232 pSh->GotoTOXMark( *pMoveMark, TOX_NXT ), bShow = true;
233 m_pPrevBT->Enable( pMoveMark != pMark );
234 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_NXT );
235 if( pMoveMark != pMark )
236 pSh->GotoTOXMark( *pMoveMark, TOX_PRV ), bShow = true;
237 m_pNextBT->Enable( pMoveMark != pMark );
238 if( bShow )
239 {
240 m_pPrevBT->Show();
241 m_pNextBT->Show();
242 bShow = false;
243 }
244
245 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_SAME_PRV );
246 if( pMoveMark != pMark )
247 pSh->GotoTOXMark( *pMoveMark, TOX_SAME_NXT ), bShow = true;
248 m_pPrevSameBT->Enable( pMoveMark != pMark );
249 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_SAME_NXT );
250 if( pMoveMark != pMark )
251 pSh->GotoTOXMark( *pMoveMark, TOX_SAME_PRV ), bShow = true;
252 m_pNextSameBT->Enable( pMoveMark != pMark );
253 if( bShow )
254 {
255 m_pNextSameBT->Show();
256 m_pPrevSameBT->Show();
257 }
258 pSh->EndCrsrMove();
259
260 m_pTypeFT->Show();
261
262 m_pTypeDCB->Enable(sal_False);
263 m_pTypeFT->Enable(sal_False);
264
265 UpdateDialog();
266 }
267 else
268 { // display current selection (first element) ????
269 sal_uInt16 nCnt = pSh->GetCrsrCnt();
270 if (nCnt < 2)
271 {
272 bSelected = !pSh->HasSelection();
273 aOrgStr = pSh->GetView().GetSelectionTextParam(sal_True, sal_False);
274 m_pEntryED->SetText(aOrgStr);
275
276 //to include all equal entries may only be allowed in the body and even there
277 //only when a simple selection exists
278 const sal_uInt16 nFrmType = pSh->GetFrmType(0,sal_True);
279 m_pApplyToAllCB->Show();
280 m_pSearchCaseSensitiveCB->Show();
281 m_pSearchCaseWordOnlyCB->Show();
282 m_pApplyToAllCB->Enable(0 != aOrgStr.Len() &&
283 0 == (nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER | FRMTYPE_FLY_ANY )));
284 SearchTypeHdl(m_pApplyToAllCB);
285 }
286
287 // index type is default
288 if( sTmpTypeSelection.Len() &&
289 LISTBOX_ENTRY_NOTFOUND != m_pTypeDCB->GetEntryPos( sTmpTypeSelection ) )
290 m_pTypeDCB->SelectEntry(sTmpTypeSelection);
291 else
292 m_pTypeDCB->SelectEntry(m_pTypeDCB->GetEntry(nTypePos));
293 ModifyHdl(m_pTypeDCB);
294 }
295 }
296
297 void SwIndexMarkPane::UpdateLanguageDependenciesForPhoneticReading()
298 {
299 //no phonetic reading if no global cjk support
300 if( !xExtendedIndexEntrySupplier.is() )
301 {
302 bIsPhoneticReadingEnabled = sal_False;
303 return;
304 }
305 bIsPhoneticReadingEnabled = sal_True;
306
307 //get the current language
308 if(!bNewMark) //if dialog is opened to iterate existing marks
309 {
310 OSL_ENSURE(pTOXMgr, "need TOXMgr");
311 if(!pTOXMgr)
312 return;
313 SwTOXMark* pMark = pTOXMgr->GetCurTOXMark();
314 OSL_ENSURE(pMark, "need current SwTOXMark");
315 if(!pMark)
316 return;
317 SwTxtTOXMark* pTxtTOXMark = pMark->GetTxtTOXMark();
318 OSL_ENSURE(pTxtTOXMark, "need current SwTxtTOXMark");
319 if(!pTxtTOXMark)
320 return;
321 const SwTxtNode* pTxtNode = pTxtTOXMark->GetpTxtNd();
322 OSL_ENSURE(pTxtNode, "need current SwTxtNode");
323 if(!pTxtNode)
324 return;
325 xub_StrLen nTextIndex = *pTxtTOXMark->GetStart();
326 nLangForPhoneticReading = pTxtNode->GetLang( nTextIndex );
327 }
328 else //if dialog is opened to create a new mark
329 {
330 sal_uInt16 nScriptType = pSh->GetScriptType();
331 sal_uInt16 nWhich;
332 switch(nScriptType)
333 {
334 case SCRIPTTYPE_ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break;
335 case SCRIPTTYPE_COMPLEX:nWhich = RES_CHRATR_CTL_LANGUAGE; break;
336 default:nWhich = RES_CHRATR_LANGUAGE; break;
337 }
338 SfxItemSet aLangSet(pSh->GetAttrPool(), nWhich, nWhich);
339 pSh->GetCurAttr(aLangSet);
340 nLangForPhoneticReading = ((const SvxLanguageItem&)aLangSet.Get(nWhich)).GetLanguage();
341 }
342
343 }
344
345 String SwIndexMarkPane::GetDefaultPhoneticReading( const String& rText )
346 {
347 if( !bIsPhoneticReadingEnabled )
348 return aEmptyStr;
349
350 return xExtendedIndexEntrySupplier->getPhoneticCandidate(rText, LanguageTag( nLangForPhoneticReading ).getLocale());
351 }
352
353 /* --------------------------------------------------
354 Change the content of m_pEntryED if text is selected
355 --------------------------------------------------*/
356 void SwIndexMarkPane::Activate()
357 {
358 // display current selection (first element) ????
359 if(bNewMark)
360 {
361 sal_uInt16 nCnt = pSh->GetCrsrCnt();
362 if (nCnt < 2)
363 {
364 bSelected = !pSh->HasSelection();
365 aOrgStr = pSh->GetView().GetSelectionTextParam(sal_True, sal_False);
366 m_pEntryED->SetText(aOrgStr);
367
368 //to include all equal entries may only be allowed in the body and even there
369 //only when a simple selection exists
370 const sal_uInt16 nFrmType = pSh->GetFrmType(0,sal_True);
371 m_pApplyToAllCB->Show();
372 m_pSearchCaseSensitiveCB->Show();
373 m_pSearchCaseWordOnlyCB->Show();
374 m_pApplyToAllCB->Enable(0 != aOrgStr.Len() &&
375 0 == (nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER | FRMTYPE_FLY_ANY )));
376 SearchTypeHdl(m_pApplyToAllCB);
377 }
378 ModifyHdl(m_pTypeDCB);
379 }
380 }
381
382 /*--------------------------------------------------------------------
383 Description: evaluate Ok-Button
384 --------------------------------------------------------------------*/
385 void SwIndexMarkPane::Apply()
386 {
387 InsertUpdate();
388 if(bSelected)
389 pSh->ResetSelect(0, sal_False);
390 }
391
392 /*--------------------------------------------------------------------
393 Description: apply changes
394 --------------------------------------------------------------------*/
395 void SwIndexMarkPane::InsertUpdate()
396 {
397 pSh->StartUndo(bDel ? UNDO_INDEX_ENTRY_DELETE : UNDO_INDEX_ENTRY_INSERT);
398 pSh->StartAllAction();
399
400 SwRewriter aRewriter;
401
402 if( bNewMark )
403 {
404 InsertMark();
405
406 if ( pTOXMgr->GetCurTOXMark())
407 aRewriter.AddRule(UndoArg1, pTOXMgr->GetCurTOXMark()->GetText());
408 }
409 else if( !pSh->HasReadonlySel() )
410 {
411 if ( pTOXMgr->GetCurTOXMark())
412 aRewriter.AddRule(UndoArg1,
413 pTOXMgr->GetCurTOXMark()->GetText());
414
415 if( bDel )
416 pTOXMgr->DeleteTOXMark();
417 else if( pTOXMgr->GetCurTOXMark() )
418 UpdateMark();
419 }
420
421 pSh->EndAllAction();
422 pSh->EndUndo(bDel ? UNDO_INDEX_ENTRY_DELETE : UNDO_INDEX_ENTRY_INSERT);
423
424 if((nTypePos = m_pTypeDCB->GetEntryPos(m_pTypeDCB->GetSelectEntry())) == LISTBOX_ENTRY_NOTFOUND)
425 nTypePos = 0;
426
427 nKey1Pos = m_pKey1DCB->GetEntryPos(m_pKey1DCB->GetText());
428 nKey2Pos = m_pKey2DCB->GetEntryPos(m_pKey2DCB->GetText());
429 }
430
431 /*--------------------------------------------------------------------
432 Description: insert mark
433 --------------------------------------------------------------------*/
434 static void lcl_SelectSameStrings(SwWrtShell& rSh, sal_Bool bWordOnly, sal_Bool bCaseSensitive)
435 {
436 rSh.Push();
437
438 SearchOptions aSearchOpt(
439 SearchAlgorithms_ABSOLUTE,
440 ( bWordOnly ? SearchFlags::NORM_WORD_ONLY : 0 ),
441 rSh.GetSelTxt(), OUString(),
442 GetAppLanguageTag().getLocale(),
443 0, 0, 0,
444 (bCaseSensitive
445 ? 0
446 : TransliterationModules_IGNORE_CASE) );
447
448 rSh.ClearMark();
449 sal_Bool bCancel;
450
451 //todo/mba: assuming that notes should not be searched
452 sal_Bool bSearchInNotes = sal_False;
453 rSh.Find( aSearchOpt, bSearchInNotes, DOCPOS_START, DOCPOS_END, bCancel,
454 (FindRanges)(FND_IN_SELALL|FND_IN_BODYONLY), sal_False );
455 }
456
457
458 void SwIndexMarkPane::InsertMark()
459 {
460 sal_uInt16 nPos = m_pTypeDCB->GetEntryPos(m_pTypeDCB->GetSelectEntry());
461 TOXTypes eType = nPos == POS_CONTENT ? TOX_CONTENT :
462 nPos == POS_INDEX ? TOX_INDEX : TOX_USER;
463
464 SwTOXMarkDescription aDesc(eType);
465
466 sal_uInt16 nLevel = (sal_uInt16)m_pLevelNF->Denormalize(m_pLevelNF->GetValue());
467 switch(nPos)
468 {
469 case POS_CONTENT : break;
470 case POS_INDEX: // keyword index mark
471 {
472 UpdateKeyBoxes();
473 String aPrim(m_pKey1DCB->GetText());
474 String aSec(m_pKey2DCB->GetText());
475 aDesc.SetPrimKey(aPrim);
476 aDesc.SetSecKey(aSec);
477 aDesc.SetMainEntry(m_pMainEntryCB->IsChecked());
478 aDesc.SetPhoneticReadingOfAltStr(m_pPhoneticED0->GetText());
479 aDesc.SetPhoneticReadingOfPrimKey(m_pPhoneticED1->GetText());
480 aDesc.SetPhoneticReadingOfSecKey(m_pPhoneticED2->GetText());
481 }
482 break;
483 default: // Userdefined index mark
484 {
485 String aName(m_pTypeDCB->GetSelectEntry());
486 aDesc.SetTOUName(aName);
487 }
488 }
489 if (OUString(aOrgStr) != m_pEntryED->GetText())
490 aDesc.SetAltStr(m_pEntryED->GetText());
491 sal_Bool bApplyAll = m_pApplyToAllCB->IsChecked();
492 sal_Bool bWordOnly = m_pSearchCaseWordOnlyCB->IsChecked();
493 sal_Bool bCaseSensitive = m_pSearchCaseSensitiveCB->IsChecked();
494
495 pSh->StartAllAction();
496 // all equal strings have to be selected here so that the
497 // entry is apllied to all equal strings
498 if(bApplyAll)
499 {
500 lcl_SelectSameStrings(*pSh, bWordOnly, bCaseSensitive);
501 }
502 aDesc.SetLevel(nLevel);
503 SwTOXMgr aMgr(pSh);
504 aMgr.InsertTOXMark(aDesc);
505 if(bApplyAll)
506 pSh->Pop(sal_False);
507
508 pSh->EndAllAction();
509 }
510
511 /*--------------------------------------------------------------------
512 Description: update mark
513 --------------------------------------------------------------------*/
514 void SwIndexMarkPane::UpdateMark()
515 {
516 String aAltText(m_pEntryED->GetText());
517 String* pAltText = OUString(aOrgStr) != m_pEntryED->GetText() ? &aAltText : 0;
518 //empty alternative texts are not allowed
519 if(pAltText && !pAltText->Len())
520 return;
521
522 UpdateKeyBoxes();
523
524 sal_uInt16 nPos = m_pTypeDCB->GetEntryPos(m_pTypeDCB->GetSelectEntry());
525 TOXTypes eType = TOX_USER;
526 if(POS_CONTENT == nPos)
527 eType = TOX_CONTENT;
528 else if(POS_INDEX == nPos)
529 eType = TOX_INDEX;
530
531 SwTOXMarkDescription aDesc(eType);
532 aDesc.SetLevel( static_cast< int >(m_pLevelNF->GetValue()) );
533 if(pAltText)
534 aDesc.SetAltStr(*pAltText);
535
536 String aPrim(m_pKey1DCB->GetText());
537 if(aPrim.Len())
538 aDesc.SetPrimKey(aPrim);
539 String aSec(m_pKey2DCB->GetText());
540 if(aSec.Len())
541 aDesc.SetSecKey(aSec);
542
543 if(eType == TOX_INDEX)
544 {
545 aDesc.SetPhoneticReadingOfAltStr(m_pPhoneticED0->GetText());
546 aDesc.SetPhoneticReadingOfPrimKey(m_pPhoneticED1->GetText());
547 aDesc.SetPhoneticReadingOfSecKey(m_pPhoneticED2->GetText());
548 }
549 aDesc.SetMainEntry(m_pMainEntryCB->IsVisible() && m_pMainEntryCB->IsChecked());
550 pTOXMgr->UpdateTOXMark(aDesc);
551 }
552
553 /*--------------------------------------------------------------------
554 Description: insert new keys
555 --------------------------------------------------------------------*/
556 void SwIndexMarkPane::UpdateKeyBoxes()
557 {
558 String aKey(m_pKey1DCB->GetText());
559 sal_uInt16 nPos = m_pKey1DCB->GetEntryPos(aKey);
560
561 if(nPos == LISTBOX_ENTRY_NOTFOUND && aKey.Len() > 0)
562 { // create new key
563 m_pKey1DCB->InsertEntry(aKey);
564 }
565
566 aKey = m_pKey2DCB->GetText();
567 nPos = m_pKey2DCB->GetEntryPos(aKey);
568
569 if(nPos == LISTBOX_ENTRY_NOTFOUND && aKey.Len() > 0)
570 { // create new key
571 m_pKey2DCB->InsertEntry(aKey);
572 }
573 }
574
575 class SwNewUserIdxDlg : public ModalDialog
576 {
577 OKButton* m_pOKPB;
578 Edit* m_pNameED;
579
580 SwIndexMarkPane* m_pDlg;
581
582 DECL_LINK( ModifyHdl, Edit*);
583
584 public:
585 SwNewUserIdxDlg(SwIndexMarkPane* pPane)
586 : ModalDialog(&(pPane->GetDialog()), "NewUserIndexDialog",
587 "modules/swriter/ui/newuserindexdialog.ui")
588 , m_pDlg(pPane)
589 {
590 get(m_pOKPB, "ok");
591 get(m_pNameED, "entry");
592 m_pNameED->SetModifyHdl(LINK(this, SwNewUserIdxDlg, ModifyHdl));
593 m_pOKPB->Enable(sal_False);
594 m_pNameED->GrabFocus();
595 }
596
597 virtual void Apply();
598 String GetName(){return m_pNameED->GetText();}
599 };
600 void SwNewUserIdxDlg::Apply()
601 {
602 }
603
604 IMPL_LINK( SwNewUserIdxDlg, ModifyHdl, Edit*, pEdit)
605 {
606 m_pOKPB->Enable(!pEdit->GetText().isEmpty() && !m_pDlg->IsTOXType(pEdit->GetText()));
607 return 0;
608 }
609
610 IMPL_LINK_NOARG(SwIndexMarkPane, NewUserIdxHdl)
611 {
612 SwNewUserIdxDlg* pDlg = new SwNewUserIdxDlg(this);
613 if(RET_OK == pDlg->Execute())
614 {
615 String sNewName(pDlg->GetName());
616 m_pTypeDCB->InsertEntry(sNewName);
617 m_pTypeDCB->SelectEntry(sNewName);
618 }
619 delete pDlg;
620 return 0;
621 }
622
623 IMPL_LINK( SwIndexMarkPane, SearchTypeHdl, CheckBox*, pBox)
624 {
625 sal_Bool bEnable = pBox->IsChecked() && pBox->IsEnabled();
626 m_pSearchCaseWordOnlyCB->Enable(bEnable);
627 m_pSearchCaseSensitiveCB->Enable(bEnable);
628 return 0;
629 }
630
631 IMPL_LINK( SwIndexMarkPane, InsertHdl, Button *, pButton )
632 {
633 Apply();
634 //close the dialog if only one entry is available
635 if(!bNewMark && !m_pPrevBT->IsVisible() && !m_pNextBT->IsVisible())
636 CloseHdl(pButton);
637 return 0;
638 }
639
640 IMPL_LINK_NOARG(SwIndexMarkPane, CloseHdl)
641 {
642 if(bNewMark)
643 {
644 sal_uInt16 nSlot = FN_INSERT_IDX_ENTRY_DLG;
645 SfxViewFrame::Current()->GetDispatcher()->Execute(nSlot,
646 SFX_CALLMODE_ASYNCHRON|SFX_CALLMODE_RECORD);
647 }
648 else
649 {
650 m_rDialog.EndDialog(RET_CANCEL);
651 }
652 return 0;
653 }
654
655 /*--------------------------------------------------------------------
656 Description: select index type only when inserting
657 --------------------------------------------------------------------*/
658 IMPL_LINK( SwIndexMarkPane, ModifyHdl, ListBox *, pBox )
659 {
660 if (m_pTypeDCB == pBox)
661 {
662 // set index type
663 sal_uInt16 nPos = m_pTypeDCB->GetEntryPos(m_pTypeDCB->GetSelectEntry());
664 sal_Bool bLevelEnable = sal_False,
665 bKeyEnable = sal_False,
666 bSetKey2 = sal_False,
667 bKey2Enable = sal_False,
668 bEntryHasText = sal_False,
669 bKey1HasText = sal_False,
670 bKey2HasText = sal_False;
671 if(nPos == POS_INDEX)
672 {
673 if(!m_pEntryED->GetText().isEmpty())
674 bEntryHasText = sal_True;
675 m_pPhoneticED0->SetText(GetDefaultPhoneticReading(m_pEntryED->GetText()));
676
677 bKeyEnable = sal_True;
678 m_pKey1DCB->SetText(m_pKey1DCB->GetEntry(nKey1Pos));
679 m_pPhoneticED1->SetText(GetDefaultPhoneticReading(m_pKey1DCB->GetText()));
680 if(!m_pKey1DCB->GetText().isEmpty())
681 {
682 bKey1HasText = bSetKey2 = bKey2Enable = sal_True;
683 m_pKey2DCB->SetText(m_pKey2DCB->GetEntry(nKey2Pos));
684 m_pPhoneticED2->SetText(GetDefaultPhoneticReading(m_pKey2DCB->GetText()));
685 if(!m_pKey2DCB->GetText().isEmpty())
686 bKey2HasText = sal_True;
687 }
688 }
689 else
690 {
691 bLevelEnable = sal_True;
692 m_pLevelNF->SetMax(MAXLEVEL);
693 m_pLevelNF->SetValue(m_pLevelNF->Normalize(0));
694 bSetKey2 = sal_True;
695 }
696 m_pLevelFT->Show(bLevelEnable);
697 m_pLevelNF->Show(bLevelEnable);
698 m_pMainEntryCB->Show(nPos == POS_INDEX);
699
700 m_pKey1FT->Enable(bKeyEnable);
701 m_pKey1DCB->Enable(bKeyEnable);
702 if ( bSetKey2 )
703 {
704 m_pKey2DCB->Enable(bKey2Enable);
705 m_pKey2FT->Enable(bKey2Enable);
706 }
707 m_pPhoneticFT0->Enable(bKeyEnable&&bEntryHasText&&bIsPhoneticReadingEnabled);
708 m_pPhoneticED0->Enable(bKeyEnable&&bEntryHasText&&bIsPhoneticReadingEnabled);
709 m_pPhoneticFT1->Enable(bKeyEnable&&bKey1HasText&&bIsPhoneticReadingEnabled);
710 m_pPhoneticED1->Enable(bKeyEnable&&bKey1HasText&&bIsPhoneticReadingEnabled);
711 m_pPhoneticFT2->Enable(bKeyEnable&&bKey2HasText&&bIsPhoneticReadingEnabled);
712 m_pPhoneticED2->Enable(bKeyEnable&&bKey2HasText&&bIsPhoneticReadingEnabled);
713 }
714 else //m_pEntryED !!m_pEntryED is not a ListBox but a Edit
715 {
716 bool bHasText = (!m_pEntryED->GetText().isEmpty());
717 if(!bHasText)
718 {
719 m_pPhoneticED0->SetText(aEmptyStr);
720 bPhoneticED0_ChangedByUser = sal_False;
721 }
722 else if(!bPhoneticED0_ChangedByUser)
723 m_pPhoneticED0->SetText(GetDefaultPhoneticReading(m_pEntryED->GetText()));
724
725 m_pPhoneticFT0->Enable(bHasText&&bIsPhoneticReadingEnabled);
726 m_pPhoneticED0->Enable(bHasText&&bIsPhoneticReadingEnabled);
727 }
728 m_pOKBT->Enable(!pSh->HasReadonlySel() &&
729 (!m_pEntryED->GetText().isEmpty() || pSh->GetCrsrCnt(sal_False)));
730 return 0;
731 }
732
733 IMPL_LINK_NOARG_INLINE_START(SwIndexMarkPane, NextHdl)
734 {
735 InsertUpdate();
736 pTOXMgr->NextTOXMark();
737 UpdateDialog();
738 return 0;
739 }
740 IMPL_LINK_NOARG_INLINE_END(SwIndexMarkPane, NextHdl)
741
742 IMPL_LINK_NOARG_INLINE_START(SwIndexMarkPane, NextSameHdl)
743 {
744 InsertUpdate();
745 pTOXMgr->NextTOXMark(sal_True);
746 UpdateDialog();
747 return 0;
748 }
749 IMPL_LINK_NOARG_INLINE_END(SwIndexMarkPane, NextSameHdl)
750
751 IMPL_LINK_NOARG_INLINE_START(SwIndexMarkPane, PrevHdl)
752 {
753 InsertUpdate();
754 pTOXMgr->PrevTOXMark();
755 UpdateDialog();
756 return 0;
757 }
758 IMPL_LINK_NOARG_INLINE_END(SwIndexMarkPane, PrevHdl)
759
760 IMPL_LINK_NOARG_INLINE_START(SwIndexMarkPane, PrevSameHdl)
761 {
762 InsertUpdate();
763 pTOXMgr->PrevTOXMark(sal_True);
764 UpdateDialog();
765
766 return 0;
767 }
768 IMPL_LINK_NOARG_INLINE_END(SwIndexMarkPane, PrevSameHdl)
769
770 IMPL_LINK_NOARG(SwIndexMarkPane, DelHdl)
771 {
772 bDel = sal_True;
773 InsertUpdate();
774 bDel = sal_False;
775
776 if(pTOXMgr->GetCurTOXMark())
777 UpdateDialog();
778 else
779 {
780 CloseHdl(m_pCloseBT);
781 SfxViewFrame::Current()->GetBindings().Invalidate(FN_EDIT_IDX_ENTRY_DLG);
782 }
783 return 0;
784 }
785
786 /*--------------------------------------------------------------------
787 Description: renew dialog view
788 --------------------------------------------------------------------*/
789 void SwIndexMarkPane::UpdateDialog()
790 {
791 OSL_ENSURE(pSh && pTOXMgr, "no shell?");
792 SwTOXMark* pMark = pTOXMgr->GetCurTOXMark();
793 OSL_ENSURE(pMark, "no current marker");
794 if(!pMark)
795 return;
796
797 ViewShell::SetCareWin(&m_rDialog);
798
799 aOrgStr = pMark->GetText();
800 m_pEntryED->SetText(aOrgStr);
801
802 // set index type
803 sal_Bool bLevelEnable = sal_True,
804 bKeyEnable = sal_False,
805 bKey2Enable = sal_False,
806 bEntryHasText = sal_False,
807 bKey1HasText = sal_False,
808 bKey2HasText = sal_False;
809
810 TOXTypes eCurType = pMark->GetTOXType()->GetType();
811 if(TOX_INDEX == eCurType)
812 {
813 bLevelEnable = sal_False;
814 bKeyEnable = sal_True;
815 bKey1HasText = bKey2Enable = 0 != pMark->GetPrimaryKey().Len();
816 bKey2HasText = 0 != pMark->GetSecondaryKey().Len();
817 bEntryHasText = 0 != pMark->GetText().Len();
818 m_pKey1DCB->SetText( pMark->GetPrimaryKey() );
819 m_pKey2DCB->SetText( pMark->GetSecondaryKey() );
820 m_pPhoneticED0->SetText( pMark->GetTextReading() );
821 m_pPhoneticED1->SetText( pMark->GetPrimaryKeyReading() );
822 m_pPhoneticED2->SetText( pMark->GetSecondaryKeyReading() );
823 m_pMainEntryCB->Check(pMark->IsMainEntry());
824 }
825 else if(TOX_CONTENT == eCurType || TOX_USER == eCurType)
826 {
827 m_pLevelNF->SetValue(m_pLevelNF->Normalize(pMark->GetLevel()));
828 }
829 m_pKey1FT->Enable(bKeyEnable);
830 m_pKey1DCB->Enable(bKeyEnable);
831 m_pLevelNF->SetMax(MAXLEVEL);
832 m_pLevelFT->Show(bLevelEnable);
833 m_pLevelNF->Show(bLevelEnable);
834 m_pMainEntryCB->Show(!bLevelEnable);
835 m_pKey2FT->Enable(bKey2Enable);
836 m_pKey2DCB->Enable(bKey2Enable);
837
838 UpdateLanguageDependenciesForPhoneticReading();
839 m_pPhoneticFT0->Enable(bKeyEnable&&bEntryHasText&&bIsPhoneticReadingEnabled);
840 m_pPhoneticED0->Enable(bKeyEnable&&bEntryHasText&&bIsPhoneticReadingEnabled);
841 m_pPhoneticFT1->Enable(bKeyEnable&&bKey1HasText&&bIsPhoneticReadingEnabled);
842 m_pPhoneticED1->Enable(bKeyEnable&&bKey1HasText&&bIsPhoneticReadingEnabled);
843 m_pPhoneticFT2->Enable(bKeyEnable&&bKey2HasText&&bIsPhoneticReadingEnabled);
844 m_pPhoneticED2->Enable(bKeyEnable&&bKey2HasText&&bIsPhoneticReadingEnabled);
845
846 // set index type
847 m_pTypeDCB->SelectEntry(pMark->GetTOXType()->GetTypeName());
848
849 // set Next - Prev - Buttons
850 pSh->SttCrsrMove();
851 if( m_pPrevBT->IsVisible() )
852 {
853 const SwTOXMark* pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_PRV );
854 if( pMoveMark != pMark )
855 pSh->GotoTOXMark( *pMoveMark, TOX_NXT );
856 m_pPrevBT->Enable( pMoveMark != pMark );
857 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_NXT );
858 if( pMoveMark != pMark )
859 pSh->GotoTOXMark( *pMoveMark, TOX_PRV );
860 m_pNextBT->Enable( pMoveMark != pMark );
861 }
862
863 if( m_pPrevSameBT->IsVisible() )
864 {
865 const SwTOXMark* pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_SAME_PRV );
866 if( pMoveMark != pMark )
867 pSh->GotoTOXMark( *pMoveMark, TOX_SAME_NXT );
868 m_pPrevSameBT->Enable( pMoveMark != pMark );
869 pMoveMark = &pSh->GotoTOXMark( *pMark, TOX_SAME_NXT );
870 if( pMoveMark != pMark )
871 pSh->GotoTOXMark( *pMoveMark, TOX_SAME_PRV );
872 m_pNextSameBT->Enable( pMoveMark != pMark );
873 }
874
875 sal_Bool bEnable = !pSh->HasReadonlySel();
876 m_pOKBT->Enable( bEnable );
877 m_pDelBT->Enable( bEnable );
878 m_pEntryED->SetReadOnly( !bEnable );
879 m_pLevelNF->SetReadOnly( !bEnable );
880 m_pKey1DCB->SetReadOnly( !bEnable );
881 m_pKey2DCB->SetReadOnly( !bEnable );
882
883 pSh->SelectTxtAttr( RES_TXTATR_TOXMARK, pMark->GetTxtTOXMark() );
884 // we need the point at the start of the attribut
885 pSh->SwapPam();
886
887 pSh->EndCrsrMove();
888 }
889
890 /*--------------------------------------------------------------------
891 Remind whether the edit boxes for Phonetic reading are changed manually
892 --------------------------------------------------------------------*/
893 IMPL_LINK( SwIndexMarkPane, PhoneticEDModifyHdl, Edit *, pEdit )
894 {
895 if (m_pPhoneticED0 == pEdit)
896 {
897 bPhoneticED0_ChangedByUser = !pEdit->GetText().isEmpty();
898 }
899 else if (m_pPhoneticED1 == pEdit)
900 {
901 bPhoneticED1_ChangedByUser = !pEdit->GetText().isEmpty();
902 }
903 else if (m_pPhoneticED2 == pEdit)
904 {
905 bPhoneticED2_ChangedByUser = !pEdit->GetText().isEmpty();
906 }
907 return 0;
908 }
909
910 /*--------------------------------------------------------------------
911 Description: Enable Disable of the 2nd key
912 --------------------------------------------------------------------*/
913 IMPL_LINK( SwIndexMarkPane, KeyDCBModifyHdl, ComboBox *, pBox )
914 {
915 if (m_pKey1DCB == pBox)
916 {
917 sal_Bool bEnable = !pBox->GetText().isEmpty();
918 if(!bEnable)
919 {
920 m_pKey2DCB->SetText(aEmptyStr);
921 m_pPhoneticED1->SetText(aEmptyStr);
922 m_pPhoneticED2->SetText(aEmptyStr);
923 bPhoneticED1_ChangedByUser = sal_False;
924 bPhoneticED2_ChangedByUser = sal_False;
925 }
926 else
927 {
928 if(pBox->IsInDropDown())
929 {
930 //reset bPhoneticED1_ChangedByUser if a completely new string is selected
931 bPhoneticED1_ChangedByUser = sal_False;
932 }
933 if(!bPhoneticED1_ChangedByUser)
934 m_pPhoneticED1->SetText(GetDefaultPhoneticReading(pBox->GetText()));
935 }
936 m_pKey2DCB->Enable(bEnable);
937 m_pKey2FT->Enable(bEnable);
938 }
939 else if (m_pKey2DCB == pBox)
940 {
941 if(pBox->GetText().isEmpty())
942 {
943 m_pPhoneticED2->SetText(aEmptyStr);
944 bPhoneticED2_ChangedByUser = sal_False;
945 }
946 else
947 {
948 if(pBox->IsInDropDown())
949 {
950 //reset bPhoneticED1_ChangedByUser if a completely new string is selected
951 bPhoneticED2_ChangedByUser = sal_False;
952 }
953 if(!bPhoneticED2_ChangedByUser)
954 m_pPhoneticED2->SetText(GetDefaultPhoneticReading(pBox->GetText()));
955 }
956 }
957 bool bKey1HasText = (!m_pKey1DCB->GetText().isEmpty());
958 bool bKey2HasText = (!m_pKey2DCB->GetText().isEmpty());
959
960 m_pPhoneticFT1->Enable(bKey1HasText && bIsPhoneticReadingEnabled);
961 m_pPhoneticED1->Enable(bKey1HasText && bIsPhoneticReadingEnabled);
962 m_pPhoneticFT2->Enable(bKey2HasText && bIsPhoneticReadingEnabled);
963 m_pPhoneticED2->Enable(bKey2HasText && bIsPhoneticReadingEnabled);
964
965 return 0;
966 }
967
968 /*--------------------------------------------------
969 overload dtor
970 --------------------------------------------------*/
971 SwIndexMarkPane::~SwIndexMarkPane()
972 {
973 delete pTOXMgr;
974 ViewShell::SetCareWin( 0 );
975 }
976
977 void SwIndexMarkPane::ReInitDlg(SwWrtShell& rWrtShell, SwTOXMark* pCurTOXMark)
978 {
979 pSh = &rWrtShell;
980 delete pTOXMgr;
981 pTOXMgr = new SwTOXMgr(pSh);
982 if(pCurTOXMark)
983 {
984 for(sal_uInt16 i = 0; i < pTOXMgr->GetTOXMarkCount(); i++)
985 if(pTOXMgr->GetTOXMark(i) == pCurTOXMark)
986 {
987 pTOXMgr->SetCurTOXMark(i);
988 break;
989 }
990 }
991 InitControls();
992 }
993
994 SwIndexMarkFloatDlg::SwIndexMarkFloatDlg(SfxBindings* _pBindings,
995 SfxChildWindow* pChild, Window *pParent,
996 SfxChildWinInfo* pInfo, sal_Bool bNew)
997 : SfxModelessDialog(_pBindings, pChild, pParent, "IndexEntryDialog", "modules/swriter/ui/indexentry.ui")
998 , m_aContent(*this, bNew, *::GetActiveWrtShell())
999 {
1000 m_aContent.ReInitDlg(*::GetActiveWrtShell());
1001 Initialize(pInfo);
1002 }
1003
1004 void SwIndexMarkFloatDlg::Activate()
1005 {
1006 SfxModelessDialog::Activate();
1007 m_aContent.Activate();
1008 }
1009
1010 void SwIndexMarkFloatDlg::ReInitDlg(SwWrtShell& rWrtShell)
1011 {
1012 m_aContent.ReInitDlg( rWrtShell );
1013 }
1014
1015 SwIndexMarkModalDlg::SwIndexMarkModalDlg(Window *pParent, SwWrtShell& rSh, SwTOXMark* pCurTOXMark)
1016 : SvxStandardDialog(pParent, "IndexEntryDialog", "modules/swriter/ui/indexentry.ui")
1017 , m_aContent(*this, sal_False, rSh)
1018 {
1019 m_aContent.ReInitDlg(rSh, pCurTOXMark);
1020 }
1021
1022 void SwIndexMarkModalDlg::Apply()
1023 {
1024 m_aContent.Apply();
1025 }
1026
1027 class SwCreateAuthEntryDlg_Impl : public ModalDialog
1028 {
1029 FixedText* pFixedTexts[AUTH_FIELD_END];
1030 ListBox* pTypeListBox;
1031 ComboBox* pIdentifierBox;
1032 Edit* pEdits[AUTH_FIELD_END];
1033
1034 OKButton* m_pOKBT;
1035
1036 Link aShortNameCheckLink;
1037
1038 SwWrtShell& rWrtSh;
1039
1040 sal_Bool m_bNewEntryMode;
1041 sal_Bool m_bNameAllowed;
1042
1043 DECL_LINK(IdentifierHdl, ComboBox*);
1044 DECL_LINK(ShortNameHdl, Edit*);
1045 DECL_LINK(EnableHdl, ListBox* pBox);
1046
1047 public:
1048 SwCreateAuthEntryDlg_Impl(Window* pParent,
1049 const String pFields[],
1050 SwWrtShell& rSh,
1051 sal_Bool bNewEntry,
1052 bool bCreate);
1053 ~SwCreateAuthEntryDlg_Impl();
1054
1055 String GetEntryText(ToxAuthorityField eField) const;
1056
1057 void SetCheckNameHdl(const Link& rLink) {aShortNameCheckLink = rLink;}
1058
1059 };
1060
1061 struct TextInfo
1062 {
1063 ToxAuthorityField nToxField;
1064 const char* pHelpId;
1065 };
1066
1067 static const TextInfo aTextInfoArr[] =
1068 {
1069 {AUTH_FIELD_IDENTIFIER, HID_AUTH_FIELD_IDENTIFIER },
1070 {AUTH_FIELD_AUTHORITY_TYPE, HID_AUTH_FIELD_AUTHORITY_TYPE },
1071 {AUTH_FIELD_AUTHOR, HID_AUTH_FIELD_AUTHOR },
1072 {AUTH_FIELD_TITLE, HID_AUTH_FIELD_TITLE },
1073 {AUTH_FIELD_YEAR, HID_AUTH_FIELD_YEAR },
1074 {AUTH_FIELD_PUBLISHER, HID_AUTH_FIELD_PUBLISHER },
1075 {AUTH_FIELD_ADDRESS, HID_AUTH_FIELD_ADDRESS },
1076 {AUTH_FIELD_ISBN, HID_AUTH_FIELD_ISBN },
1077 {AUTH_FIELD_CHAPTER, HID_AUTH_FIELD_CHAPTER },
1078 {AUTH_FIELD_PAGES, HID_AUTH_FIELD_PAGES },
1079 {AUTH_FIELD_EDITOR, HID_AUTH_FIELD_EDITOR },
1080 {AUTH_FIELD_EDITION, HID_AUTH_FIELD_EDITION },
1081 {AUTH_FIELD_BOOKTITLE, HID_AUTH_FIELD_BOOKTITLE },
1082 {AUTH_FIELD_VOLUME, HID_AUTH_FIELD_VOLUME },
1083 {AUTH_FIELD_HOWPUBLISHED, HID_AUTH_FIELD_HOWPUBLISHED },
1084 {AUTH_FIELD_ORGANIZATIONS, HID_AUTH_FIELD_ORGANIZATIONS },
1085 {AUTH_FIELD_INSTITUTION, HID_AUTH_FIELD_INSTITUTION },
1086 {AUTH_FIELD_SCHOOL, HID_AUTH_FIELD_SCHOOL },
1087 {AUTH_FIELD_REPORT_TYPE, HID_AUTH_FIELD_REPORT_TYPE },
1088 {AUTH_FIELD_MONTH, HID_AUTH_FIELD_MONTH },
1089 {AUTH_FIELD_JOURNAL, HID_AUTH_FIELD_JOURNAL },
1090 {AUTH_FIELD_NUMBER, HID_AUTH_FIELD_NUMBER },
1091 {AUTH_FIELD_SERIES, HID_AUTH_FIELD_SERIES },
1092 {AUTH_FIELD_ANNOTE, HID_AUTH_FIELD_ANNOTE },
1093 {AUTH_FIELD_NOTE, HID_AUTH_FIELD_NOTE },
1094 {AUTH_FIELD_URL, HID_AUTH_FIELD_URL },
1095 {AUTH_FIELD_CUSTOM1, HID_AUTH_FIELD_CUSTOM1 },
1096 {AUTH_FIELD_CUSTOM2, HID_AUTH_FIELD_CUSTOM2 },
1097 {AUTH_FIELD_CUSTOM3, HID_AUTH_FIELD_CUSTOM3 },
1098 {AUTH_FIELD_CUSTOM4, HID_AUTH_FIELD_CUSTOM4 },
1099 {AUTH_FIELD_CUSTOM5, HID_AUTH_FIELD_CUSTOM5 }
1100 };
1101
1102 sal_Bool SwAuthorMarkPane::bIsFromComponent = sal_True;
1103
1104 SwAuthorMarkPane::SwAuthorMarkPane(Dialog &rDialog, sal_Bool bNewDlg)
1105 : m_rDialog(rDialog)
1106 , bNewEntry(bNewDlg)
1107 , bBibAccessInitialized(sal_False)
1108 , pSh(0)
1109 {
1110 m_rDialog.get(m_pFromComponentRB, "frombibliography");
1111 m_rDialog.get(m_pFromDocContentRB, "fromdocument");
1112 m_rDialog.get(m_pAuthorFI, "author");
1113 m_rDialog.get(m_pTitleFI, "title");
1114 m_rDialog.get(m_pEntryED, "entryed");
1115 m_rDialog.get(m_pEntryLB, "entrylb");
1116 m_rDialog.get(m_pActionBT,
1117 bNewEntry ? OString("insert") : OString("modify"));
1118 m_pActionBT->Show(true);
1119 m_rDialog.get(m_pCloseBT, "close");
1120 m_rDialog.get(m_pCreateEntryPB, "new");
1121 m_rDialog.get(m_pEditEntryPB, "edit");
1122
1123 m_pFromComponentRB->Show(bNewEntry);
1124 m_pFromDocContentRB->Show(bNewEntry);
1125 m_pFromComponentRB->Check(bIsFromComponent);
1126 m_pFromDocContentRB->Check(!bIsFromComponent);
1127
1128 m_pActionBT->SetClickHdl(LINK(this,SwAuthorMarkPane, InsertHdl));
1129 m_pCloseBT->SetClickHdl(LINK(this,SwAuthorMarkPane, CloseHdl));
1130 m_pCreateEntryPB->SetClickHdl(LINK(this,SwAuthorMarkPane, CreateEntryHdl));
1131 m_pEditEntryPB->SetClickHdl(LINK(this,SwAuthorMarkPane, CreateEntryHdl));
1132 m_pFromComponentRB->SetClickHdl(LINK(this,SwAuthorMarkPane, ChangeSourceHdl));
1133 m_pFromDocContentRB->SetClickHdl(LINK(this,SwAuthorMarkPane, ChangeSourceHdl));
1134 m_pEntryED->SetModifyHdl(LINK(this,SwAuthorMarkPane, EditModifyHdl));
1135
1136 m_rDialog.SetText(SW_RESSTR(
1137 bNewEntry ? STR_AUTHMRK_INSERT : STR_AUTHMRK_EDIT));
1138
1139 m_pEntryED->Show(!bNewEntry);
1140 m_pEntryLB->Show(bNewEntry);
1141 if(bNewEntry)
1142 {
1143 m_pEntryLB->SetSelectHdl(LINK(this, SwAuthorMarkPane, CompEntryHdl));
1144 }
1145 }
1146
1147 void SwAuthorMarkPane::ReInitDlg(SwWrtShell& rWrtShell)
1148 {
1149 pSh = &rWrtShell;
1150 InitControls();
1151 }
1152
1153 IMPL_LINK_NOARG(SwAuthorMarkPane, CloseHdl)
1154 {
1155 if(bNewEntry)
1156 {
1157 sal_uInt16 nSlot = FN_INSERT_AUTH_ENTRY_DLG;
1158 SfxViewFrame::Current()->GetDispatcher()->Execute(nSlot,
1159 SFX_CALLMODE_ASYNCHRON|SFX_CALLMODE_RECORD);
1160 }
1161 else
1162 {
1163 m_rDialog.EndDialog(RET_CANCEL);
1164 }
1165 return 0;
1166 }
1167
1168 static String lcl_FindColumnEntry(const beans::PropertyValue* pFields, sal_Int32 nLen, const String& rColumnTitle)
1169 {
1170 String sRet;
1171 OUString uColumnTitle = rColumnTitle;
1172 for(sal_uInt16 i = 0; i < nLen; i++)
1173 {
1174 OUString uTmp;
1175 if(pFields[i].Name == uColumnTitle &&
1176 (pFields[i].Value >>= uTmp))
1177 {
1178 sRet = String(uTmp);
1179 break;
1180 }
1181 }
1182 return sRet;
1183 }
1184
1185 IMPL_LINK( SwAuthorMarkPane, CompEntryHdl, ListBox*, pBox)
1186 {
1187 String sEntry(pBox->GetSelectEntry());
1188 if(bIsFromComponent)
1189 {
1190 if(xBibAccess.is() && sEntry.Len())
1191 {
1192 OUString uEntry(sEntry);
1193 if(xBibAccess->hasByName(uEntry))
1194 {
1195 uno::Any aEntry(xBibAccess->getByName(uEntry));
1196 uno::Sequence<beans::PropertyValue> aFieldProps;
1197 if(aEntry >>= aFieldProps)
1198 {
1199 const beans::PropertyValue* pProps = aFieldProps.getConstArray();
1200 for(sal_uInt16 i = 0; i < AUTH_FIELD_END && i < aFieldProps.getLength(); i++)
1201 {
1202 m_sFields[i] = lcl_FindColumnEntry(
1203 pProps, aFieldProps.getLength(), m_sColumnTitles[i]);
1204 }
1205 }
1206 }
1207 }
1208 }
1209 else
1210 {
1211 if(sEntry.Len())
1212 {
1213 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1214 pSh->GetFldType(RES_AUTHORITY, aEmptyStr);
1215 const SwAuthEntry* pEntry = pFType ? pFType->GetEntryByIdentifier(sEntry) : 0;
1216 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1217 m_sFields[i] = pEntry ?
1218 pEntry->GetAuthorField((ToxAuthorityField)i) : aEmptyStr;
1219 }
1220 }
1221 if(!pBox->GetSelectEntry().Len())
1222 {
1223 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1224 m_sFields[i] = aEmptyStr;
1225 }
1226 m_pAuthorFI->SetText(m_sFields[AUTH_FIELD_AUTHOR]);
1227 m_pTitleFI->SetText(m_sFields[AUTH_FIELD_TITLE]);
1228 return 0;
1229 }
1230
1231 IMPL_LINK_NOARG(SwAuthorMarkPane, InsertHdl)
1232 {
1233 //insert or update the SwAuthorityField...
1234 if(pSh)
1235 {
1236 sal_Bool bDifferent = sal_False;
1237 OSL_ENSURE(m_sFields[AUTH_FIELD_IDENTIFIER].Len() , "No Id is set!");
1238 OSL_ENSURE(m_sFields[AUTH_FIELD_AUTHORITY_TYPE].Len() , "No authority type is set!");
1239 //check if the entry already exists with different content
1240 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1241 pSh->GetFldType(RES_AUTHORITY, aEmptyStr);
1242 const SwAuthEntry* pEntry = pFType ?
1243 pFType->GetEntryByIdentifier( m_sFields[AUTH_FIELD_IDENTIFIER])
1244 : 0;
1245 if(pEntry)
1246 {
1247 for(sal_uInt16 i = 0; i < AUTH_FIELD_END && !bDifferent; i++)
1248 bDifferent |= m_sFields[i] != pEntry->GetAuthorField((ToxAuthorityField)i);
1249 if(bDifferent)
1250 {
1251 QueryBox aQuery(&m_rDialog, SW_RES(DLG_CHANGE_AUTH_ENTRY));
1252 if(RET_YES != aQuery.Execute())
1253 return 0;
1254 }
1255 }
1256
1257 SwFldMgr aMgr(pSh);
1258 String sFields;
1259 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1260 {
1261 sFields += m_sFields[i];
1262 sFields += TOX_STYLE_DELIMITER;
1263 }
1264 if(bNewEntry)
1265 {
1266 if(bDifferent)
1267 {
1268 SwAuthEntry aNewData;
1269 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1270 aNewData.SetAuthorField((ToxAuthorityField)i, m_sFields[i]);
1271 pSh->ChangeAuthorityData(&aNewData);
1272 }
1273 SwInsertFld_Data aData(TYP_AUTHORITY, 0, sFields, aEmptyStr, 0 );
1274 aMgr.InsertFld( aData );
1275 }
1276 else if(aMgr.GetCurFld())
1277 {
1278 aMgr.UpdateCurFld(0, sFields, aEmptyStr);
1279 }
1280 }
1281 if(!bNewEntry)
1282 CloseHdl(0);
1283 return 0;
1284 }
1285
1286 IMPL_LINK(SwAuthorMarkPane, CreateEntryHdl, PushButton*, pButton)
1287 {
1288 bool bCreate = pButton == m_pCreateEntryPB;
1289 String sOldId = m_sCreatedEntry[0];
1290 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1291 m_sCreatedEntry[i] = bCreate ? aEmptyStr : m_sFields[i];
1292 SwCreateAuthEntryDlg_Impl aDlg(pButton,
1293 bCreate ? m_sCreatedEntry : m_sFields,
1294 *pSh, bNewEntry, bCreate);
1295 if(bNewEntry)
1296 {
1297 aDlg.SetCheckNameHdl(LINK(this, SwAuthorMarkPane, IsEntryAllowedHdl));
1298 }
1299 if(RET_OK == aDlg.Execute())
1300 {
1301 if(bCreate && sOldId.Len())
1302 {
1303 m_pEntryLB->RemoveEntry(sOldId);
1304 }
1305 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1306 {
1307 m_sFields[i] = aDlg.GetEntryText((ToxAuthorityField)i);
1308 m_sCreatedEntry[i] = m_sFields[i];
1309 }
1310 if(bNewEntry && !m_pFromDocContentRB->IsChecked())
1311 {
1312 m_pFromDocContentRB->Check(sal_True);
1313 ChangeSourceHdl(m_pFromDocContentRB);
1314 }
1315 if(bCreate)
1316 {
1317 OSL_ENSURE(LISTBOX_ENTRY_NOTFOUND ==
1318 m_pEntryLB->GetEntryPos(m_sFields[AUTH_FIELD_IDENTIFIER]),
1319 "entry exists!");
1320 m_pEntryLB->InsertEntry(m_sFields[AUTH_FIELD_IDENTIFIER]);
1321 m_pEntryLB->SelectEntry(m_sFields[AUTH_FIELD_IDENTIFIER]);
1322 }
1323 m_pEntryED->SetText(m_sFields[AUTH_FIELD_IDENTIFIER]);
1324 m_pAuthorFI->SetText(m_sFields[AUTH_FIELD_AUTHOR]);
1325 m_pTitleFI->SetText(m_sFields[AUTH_FIELD_TITLE]);
1326 m_pActionBT->Enable();
1327 }
1328 return 0;
1329 }
1330
1331 IMPL_LINK(SwAuthorMarkPane, ChangeSourceHdl, RadioButton*, pButton)
1332 {
1333 sal_Bool bFromComp = (pButton == m_pFromComponentRB);
1334 bIsFromComponent = bFromComp;
1335 m_pCreateEntryPB->Enable(!bIsFromComponent);
1336 m_pEntryLB->Clear();
1337 if(bIsFromComponent)
1338 {
1339 if(!bBibAccessInitialized)
1340 {
1341 uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
1342 xBibAccess = frame::Bibliography::create( xContext );
1343 uno::Reference< beans::XPropertySet > xPropSet(xBibAccess, uno::UNO_QUERY);
1344 OUString uPropName("BibliographyDataFieldNames");
1345 if(xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName(uPropName))
1346 {
1347 uno::Any aNames = xPropSet->getPropertyValue(uPropName);
1348 uno::Sequence<beans::PropertyValue> aSeq;
1349 if( aNames >>= aSeq)
1350 {
1351 const beans::PropertyValue* pArr = aSeq.getConstArray();
1352 for(sal_uInt16 i = 0; i < aSeq.getLength(); i++)
1353 {
1354 String sTitle = pArr[i].Name;
1355 sal_Int16 nField = 0;
1356 pArr[i].Value >>= nField;
1357 if(nField >= 0 && nField < AUTH_FIELD_END)
1358 m_sColumnTitles[nField] = sTitle;
1359 }
1360 }
1361 }
1362 bBibAccessInitialized = sal_True;
1363 }
1364 if(xBibAccess.is())
1365 {
1366 uno::Sequence<OUString> aIdentifiers = xBibAccess->getElementNames();
1367 const OUString* pNames = aIdentifiers.getConstArray();
1368 for(sal_uInt16 i = 0; i < aIdentifiers.getLength(); i++)
1369 {
1370 m_pEntryLB->InsertEntry(pNames[i]);
1371 }
1372 }
1373 }
1374 else
1375 {
1376 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1377 pSh->GetFldType(RES_AUTHORITY, aEmptyStr);
1378 if(pFType)
1379 {
1380 std::vector<String> aIds;
1381 pFType->GetAllEntryIdentifiers( aIds );
1382 for(size_t n = 0; n < aIds.size(); ++n)
1383 m_pEntryLB->InsertEntry(aIds[n]);
1384 }
1385 if(m_sCreatedEntry[AUTH_FIELD_IDENTIFIER].Len())
1386 m_pEntryLB->InsertEntry(m_sCreatedEntry[AUTH_FIELD_IDENTIFIER]);
1387 }
1388 m_pEntryLB->SelectEntryPos(0);
1389 CompEntryHdl(m_pEntryLB);
1390 return 0;
1391 }
1392
1393 IMPL_LINK(SwAuthorMarkPane, EditModifyHdl, Edit*, pEdit)
1394 {
1395 Link aAllowed = LINK(this, SwAuthorMarkPane, IsEntryAllowedHdl);
1396 long nResult = aAllowed.Call(pEdit);
1397 m_pActionBT->Enable(nResult > 0);
1398 if(nResult)
1399 {
1400 String sEntry(pEdit->GetText());
1401 m_sFields[AUTH_FIELD_IDENTIFIER] = sEntry;
1402 m_sCreatedEntry[AUTH_FIELD_IDENTIFIER] = sEntry;
1403 }
1404 return 0;
1405 };
1406
1407 IMPL_LINK(SwAuthorMarkPane, IsEntryAllowedHdl, Edit*, pEdit)
1408 {
1409 String sEntry = pEdit->GetText();
1410 sal_Bool bAllowed = sal_False;
1411 if(sEntry.Len())
1412 {
1413 if(m_pEntryLB->GetEntryPos(sEntry) != LISTBOX_ENTRY_NOTFOUND)
1414 return 0;
1415 else if(bIsFromComponent)
1416 {
1417 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1418 pSh->GetFldType(RES_AUTHORITY, aEmptyStr);
1419 bAllowed = !pFType || !pFType->GetEntryByIdentifier(sEntry);
1420 }
1421 else
1422 {
1423 bAllowed = !xBibAccess.is() || !xBibAccess->hasByName(sEntry);
1424 }
1425 }
1426 return bAllowed;
1427 }
1428
1429 void SwAuthorMarkPane::InitControls()
1430 {
1431 OSL_ENSURE(pSh, "no shell?");
1432 SwField* pField = pSh->GetCurFld();
1433 OSL_ENSURE(bNewEntry || pField, "no current marker");
1434 if(bNewEntry)
1435 {
1436 ChangeSourceHdl(m_pFromComponentRB->IsChecked() ? m_pFromComponentRB : m_pFromDocContentRB);
1437 m_pCreateEntryPB->Enable(!m_pFromComponentRB->IsChecked());
1438 if(!m_pFromComponentRB->IsChecked() && m_sCreatedEntry[0].Len())
1439 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1440 m_sFields[i] = m_sCreatedEntry[i];
1441 }
1442 if(bNewEntry || !pField || pField->GetTyp()->Which() != RES_AUTHORITY)
1443 return;
1444
1445 const SwAuthEntry* pEntry = ((SwAuthorityFieldType*)pField->GetTyp())->
1446 GetEntryByHandle(((SwAuthorityField*)pField)->GetHandle());
1447
1448 OSL_ENSURE(pEntry, "No authority entry found");
1449 if(!pEntry)
1450 return;
1451 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1452 m_sFields[i] = pEntry->GetAuthorField((ToxAuthorityField)i);
1453
1454 m_pEntryED->SetText(pEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER));
1455 m_pAuthorFI->SetText(pEntry->GetAuthorField(AUTH_FIELD_AUTHOR));
1456 m_pTitleFI->SetText(pEntry->GetAuthorField(AUTH_FIELD_TITLE));
1457 }
1458
1459 void SwAuthorMarkPane::Activate()
1460 {
1461 m_pActionBT->Enable(!pSh->HasReadonlySel());
1462 }
1463
1464 SwCreateAuthEntryDlg_Impl::SwCreateAuthEntryDlg_Impl(Window* pParent,
1465 const String pFields[],
1466 SwWrtShell& rSh,
1467 sal_Bool bNewEntry,
1468 bool bCreate)
1469 : ModalDialog(pParent, "CreateAuthorEntryDialog", "modules/swriter/ui/createauthorentry.ui")
1470
1471 ,
1472
1473 pTypeListBox(0),
1474 pIdentifierBox(0),
1475 rWrtSh(rSh),
1476 m_bNewEntryMode(bNewEntry),
1477 m_bNameAllowed(sal_True)
1478 {
1479 get(m_pOKBT, "ok");
1480
1481 VclGrid *pLeft = get<VclGrid>("leftgrid");
1482 VclGrid *pRight = get<VclGrid>("rightgrid");
1483
1484 bool bLeft = true;
1485 sal_Int32 nLeftRow(0), nRightRow(0);
1486 for(sal_uInt16 nIndex = 0; nIndex < AUTH_FIELD_END; nIndex++)
1487 {
1488 const TextInfo aCurInfo = aTextInfoArr[nIndex];
1489
1490 pFixedTexts[nIndex] = new FixedText(bLeft ? pLeft : pRight, WB_VCENTER);
1491
1492 pFixedTexts[nIndex]->set_grid_left_attach(0);
1493 pFixedTexts[nIndex]->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1494 pFixedTexts[nIndex]->SetText(SW_RES(STR_AUTH_FIELD_START + aCurInfo.nToxField));
1495 pFixedTexts[nIndex]->Show();
1496 pEdits[nIndex] = 0;
1497 if( AUTH_FIELD_AUTHORITY_TYPE == aCurInfo.nToxField )
1498 {
1499 pTypeListBox = new ListBox(bLeft ? pLeft : pRight, WB_DROPDOWN|WB_BORDER|WB_VCENTER);
1500 for(sal_uInt16 j = 0; j < AUTH_TYPE_END; j++)
1501 pTypeListBox->InsertEntry(SW_RESSTR(STR_AUTH_TYPE_START + j));
1502 if(pFields[aCurInfo.nToxField].Len())
1503 {
1504 sal_uInt16 nIndexPos = static_cast< sal_uInt16 >(pFields[aCurInfo.nToxField].ToInt32());
1505 pTypeListBox->SelectEntryPos(nIndexPos);
1506 }
1507 pTypeListBox->set_grid_left_attach(1);
1508 pTypeListBox->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1509 pTypeListBox->set_hexpand(true);
1510 pTypeListBox->Show();
1511 pTypeListBox->SetSelectHdl(LINK(this, SwCreateAuthEntryDlg_Impl, EnableHdl));
1512 pTypeListBox->SetHelpId(aCurInfo.pHelpId);
1513 pFixedTexts[nIndex]->set_mnemonic_widget(pTypeListBox);
1514 }
1515 else if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField && !m_bNewEntryMode)
1516 {
1517 pIdentifierBox = new ComboBox(bLeft ? pLeft : pRight, WB_BORDER|WB_DROPDOWN|WB_VCENTER);
1518
1519 pIdentifierBox->SetSelectHdl(LINK(this,
1520 SwCreateAuthEntryDlg_Impl, IdentifierHdl));
1521
1522
1523 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1524 rSh.GetFldType(RES_AUTHORITY, aEmptyStr);
1525 if(pFType)
1526 {
1527 std::vector<String> aIds;
1528 pFType->GetAllEntryIdentifiers( aIds );
1529 for(size_t n = 0; n < aIds.size(); ++n)
1530 pIdentifierBox->InsertEntry(aIds[n]);
1531 }
1532 pIdentifierBox->SetText(pFields[aCurInfo.nToxField]);
1533 pIdentifierBox->set_grid_left_attach(1);
1534 pIdentifierBox->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1535 pIdentifierBox->set_hexpand(true);
1536 pIdentifierBox->Show();
1537 pIdentifierBox->SetHelpId(aCurInfo.pHelpId);
1538 pFixedTexts[nIndex]->set_mnemonic_widget(pIdentifierBox);
1539 }
1540 else
1541 {
1542 pEdits[nIndex] = new Edit(bLeft ? pLeft : pRight, WB_BORDER|WB_VCENTER);
1543 pEdits[nIndex]->SetWidthInChars(14);
1544 pEdits[nIndex]->set_grid_left_attach(1);
1545 pEdits[nIndex]->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1546 pEdits[nIndex]->set_hexpand(true);
1547 pEdits[nIndex]->SetText(pFields[aCurInfo.nToxField]);
1548 pEdits[nIndex]->Show();
1549 pEdits[nIndex]->SetHelpId(aCurInfo.pHelpId);
1550 if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField)
1551 {
1552 pEdits[nIndex]->SetModifyHdl(LINK(this, SwCreateAuthEntryDlg_Impl, ShortNameHdl));
1553 m_bNameAllowed = pFields[nIndex].Len() > 0;
1554 if(!bCreate)
1555 {
1556 pFixedTexts[nIndex]->Enable(sal_False);
1557 pEdits[nIndex]->Enable(sal_False);
1558 }
1559 }
1560 pFixedTexts[nIndex]->set_mnemonic_widget(pEdits[nIndex]);
1561 }
1562 if(bLeft)
1563 ++nLeftRow;
1564 else
1565 ++nRightRow;
1566 bLeft = !bLeft;
1567 }
1568 EnableHdl(pTypeListBox);
1569 }
1570
1571 SwCreateAuthEntryDlg_Impl::~SwCreateAuthEntryDlg_Impl()
1572 {
1573 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1574 {
1575 delete pFixedTexts[i];
1576 delete pEdits[i];
1577 }
1578 delete pTypeListBox;
1579 delete pIdentifierBox;
1580 }
1581
1582 String SwCreateAuthEntryDlg_Impl::GetEntryText(ToxAuthorityField eField) const
1583 {
1584 String sRet;
1585 if( AUTH_FIELD_AUTHORITY_TYPE == eField )
1586 {
1587 OSL_ENSURE(pTypeListBox, "No ListBox");
1588 sRet = OUString::number(pTypeListBox->GetSelectEntryPos());
1589 }
1590 else if( AUTH_FIELD_IDENTIFIER == eField && !m_bNewEntryMode)
1591 {
1592 OSL_ENSURE(pIdentifierBox, "No ComboBox");
1593 sRet = pIdentifierBox->GetText();
1594 }
1595 else
1596 {
1597 for(sal_uInt16 nIndex = 0; nIndex < AUTH_FIELD_END; nIndex++)
1598 {
1599 const TextInfo aCurInfo = aTextInfoArr[nIndex];
1600 if(aCurInfo.nToxField == eField)
1601 {
1602 sRet = pEdits[nIndex]->GetText();
1603 break;
1604 }
1605 }
1606 }
1607 return sRet;
1608 }
1609
1610 IMPL_LINK(SwCreateAuthEntryDlg_Impl, IdentifierHdl, ComboBox*, pBox)
1611 {
1612 const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
1613 rWrtSh.GetFldType(RES_AUTHORITY, aEmptyStr);
1614 if(pFType)
1615 {
1616 const SwAuthEntry* pEntry = pFType->GetEntryByIdentifier(
1617 pBox->GetText());
1618 if(pEntry)
1619 {
1620 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++)
1621 {
1622 const TextInfo aCurInfo = aTextInfoArr[i];
1623 if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField)
1624 continue;
1625 if(AUTH_FIELD_AUTHORITY_TYPE == aCurInfo.nToxField)
1626 pTypeListBox->SelectEntry(
1627 pEntry->GetAuthorField(aCurInfo.nToxField));
1628 else
1629 pEdits[i]->SetText(
1630 pEntry->GetAuthorField(aCurInfo.nToxField));
1631 }
1632 }
1633 }
1634 return 0;
1635 }
1636
1637 IMPL_LINK(SwCreateAuthEntryDlg_Impl, ShortNameHdl, Edit*, pEdit)
1638 {
1639 if(aShortNameCheckLink.IsSet())
1640 {
1641 sal_Bool bEnable = 0 != aShortNameCheckLink.Call(pEdit);
1642 m_bNameAllowed |= bEnable;
1643 m_pOKBT->Enable(pTypeListBox->GetSelectEntryCount() && bEnable);
1644 }
1645 return 0;
1646 }
1647
1648 IMPL_LINK(SwCreateAuthEntryDlg_Impl, EnableHdl, ListBox*, pBox)
1649 {
1650 m_pOKBT->Enable(m_bNameAllowed && pBox->GetSelectEntryCount());
1651 return 0;
1652 };
1653
1654 SwAuthMarkFloatDlg::SwAuthMarkFloatDlg(SfxBindings* _pBindings,
1655 SfxChildWindow* pChild,
1656 Window *pParent,
1657 SfxChildWinInfo* pInfo,
1658 sal_Bool bNew)
1659 : SfxModelessDialog(_pBindings, pChild, pParent,
1660 "BibliographyEntryDialog", "modules/swriter/ui/bibliographyentry.ui")
1661 , m_aContent(*this, bNew)
1662 {
1663 Initialize(pInfo);
1664 SwWrtShell* pWrtShell = ::GetActiveWrtShell();
1665 OSL_ENSURE(pWrtShell, "No shell?");
1666 m_aContent.ReInitDlg(*pWrtShell);
1667 }
1668
1669 void SwAuthMarkFloatDlg::Activate()
1670 {
1671 SfxModelessDialog::Activate();
1672 m_aContent.Activate();
1673 }
1674
1675 void SwAuthMarkFloatDlg::ReInitDlg(SwWrtShell& rWrtShell)
1676 {
1677 m_aContent.ReInitDlg( rWrtShell );
1678 }
1679
1680 SwAuthMarkModalDlg::SwAuthMarkModalDlg(Window *pParent, SwWrtShell& rSh)
1681 : SvxStandardDialog(pParent, "BibliographyEntryDialog",
1682 "modules/swriter/ui/bibliographyentry.ui")
1683 , m_aContent(*this, sal_False)
1684 {
1685 m_aContent.ReInitDlg(rSh);
1686 }
1687
1688 void SwAuthMarkModalDlg::Apply()
1689 {
1690 m_aContent.InsertHdl(0);
1691 }
1692
1693 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE