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_sfx2.hxx"
26
27 #ifndef _MENU_HXX //autogen
28 #include <vcl/menu.hxx>
29 #endif
30 #include <svl/intitem.hxx>
31 #include <svl/stritem.hxx>
32 #include <svl/style.hxx>
33 #ifndef GCC
34 #endif
35
36 #define _SVSTDARR_STRINGSDTOR
37 #include <svl/svstdarr.hxx>
38 #include <comphelper/processfactory.hxx>
39 #include <comphelper/sequenceashashmap.hxx>
40 #include <unotools/intlwrapper.hxx>
41 #include <comphelper/processfactory.hxx>
42 #include <com/sun/star/container/XNameAccess.hpp>
43 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
44 #include <com/sun/star/beans/PropertyValue.hpp>
45 #include <com/sun/star/frame/XModuleManager.hpp>
46
47 #include "sfx2/sfxhelp.hxx"
48 #include <sfx2/app.hxx>
49 #include <sfx2/dispatch.hxx>
50 #include <sfx2/bindings.hxx>
51 #include <sfx2/templdlg.hxx>
52 #include "templdgi.hxx"
53 #include "tplcitem.hxx"
54 #include "sfxtypes.hxx"
55 #include <sfx2/styfitem.hxx>
56 #include <sfx2/objsh.hxx>
57 #include <sfx2/viewsh.hxx>
58 #include <sfx2/newstyle.hxx>
59 #include "sfx2/tplpitem.hxx"
60 #include "sfx2/sfxresid.hxx"
61
62 #include "templdlg.hrc"
63 #include <sfx2/sfx.hrc>
64 #include "dialog.hrc"
65 #include "arrdecl.hxx"
66 #include "fltfnc.hxx"
67 #include <sfx2/docfilt.hxx>
68 #include <sfx2/docfac.hxx>
69 #include "docvor.hxx"
70 #include <sfx2/doctempl.hxx>
71 #include <sfx2/module.hxx>
72 #include "sfx2/imgmgr.hxx"
73 #include "helpid.hrc"
74 #include "appdata.hxx"
75 #include <sfx2/viewfrm.hxx>
76
77 #include <comphelper/configurationhelper.hxx>
78
79 using namespace ::com::sun::star;
80 using namespace ::com::sun::star::beans;
81 using namespace ::com::sun::star::frame;
82 using namespace ::com::sun::star::uno;
83
84 //=========================================================================
85
86 // Fenster wird ab jetzt dynamisch erstellt. Daher hier R"ander usw.
87
88 #define SFX_TEMPLDLG_HFRAME 3
89 #define SFX_TEMPLDLG_VTOPFRAME 3
90
91 #define SFX_TEMPLDLG_VBOTFRAME 3
92 #define SFX_TEMPLDLG_MIDHSPACE 3
93 #define SFX_TEMPLDLG_MIDVSPACE 3
94 #define SFX_TEMPLDLG_FILTERHEIGHT 100
95
96 static sal_uInt16 nLastItemId = USHRT_MAX;
97
98 // filter box has maximum 12 entries visible
99 #define MAX_FILTER_ENTRIES 12
100
101 #define SFX_TEMPLDLG_FILTER_MAX 0xFFFF
102 #define SFX_TEMPLDLG_FILTER_HIERARCHICAL 0xFFFE
103
104 //=========================================================================
105
106 TYPEINIT0(SfxCommonTemplateDialog_Impl);
107 TYPEINIT1(SfxTemplateDialog_Impl,SfxCommonTemplateDialog_Impl);
108 TYPEINIT1(SfxTemplateCatalog_Impl,SfxCommonTemplateDialog_Impl);
109
SFX_IMPL_DOCKINGWINDOW(SfxTemplateDialogWrapper,SID_STYLE_DESIGNER)110 SFX_IMPL_DOCKINGWINDOW(SfxTemplateDialogWrapper, SID_STYLE_DESIGNER)
111
112 //-------------------------------------------------------------------------
113
114 // Redirektionsfunktionen
115
116 SfxTemplateDialog::SfxTemplateDialog
117 (
118 SfxBindings *pBind,
119 SfxChildWindow *pCW,
120 Window *pParent
121 )
122
123 /* [Beschreibung]
124 Gestalterklasse.
125 */
126 : SfxDockingWindow( pBind, pCW, pParent, SfxResId(DLG_STYLE_DESIGNER) ),
127
128 pImpl( new SfxTemplateDialog_Impl( pBind, this ) )
129
130 {
131 pImpl->updateNonFamilyImages();
132 }
133
134 //-------------------------------------------------------------------------
135
~SfxTemplateDialog()136 SfxTemplateDialog::~SfxTemplateDialog()
137 {
138 delete pImpl;
139 }
140
GetISfxTemplateCommon()141 ISfxTemplateCommon* SfxTemplateDialog::GetISfxTemplateCommon()
142 {
143 return pImpl->GetISfxTemplateCommon();
144 }
145
SetParagraphFamily()146 void SfxTemplateDialog::SetParagraphFamily()
147 {
148 // first select the paragraph family
149 pImpl->FamilySelect( SFX_STYLE_FAMILY_PARA );
150 // then select the automatic filter
151 pImpl->SetAutomaticFilter();
152 }
153
154 // ------------------------------------------------------------------------
155
DataChanged(const DataChangedEvent & _rDCEvt)156 void SfxTemplateDialog::DataChanged( const DataChangedEvent& _rDCEvt )
157 {
158 if ( ( DATACHANGED_SETTINGS == _rDCEvt.GetType() ) &&
159 ( 0 != ( SETTINGS_STYLE & _rDCEvt.GetFlags() ) ) )
160 {
161 pImpl->updateFamilyImages();
162 pImpl->updateNonFamilyImages();
163 }
164
165 SfxDockingWindow::DataChanged( _rDCEvt );
166 }
167
168 //-------------------------------------------------------------------------
169
Update()170 void SfxTemplateDialog::Update()
171 {
172 pImpl->Update();
173 }
174
175 //-------------------------------------------------------------------------
176
Resize()177 void SfxTemplateDialog::Resize()
178 {
179 if(pImpl)
180 pImpl->Resize();
181 SfxDockingWindow::Resize();
182 }
183
184
185 //-------------------------------------------------------------------------
186
CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)187 SfxChildAlignment SfxTemplateDialog::CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)
188 {
189 switch (eAlign)
190 {
191 case SFX_ALIGN_TOP:
192 case SFX_ALIGN_HIGHESTTOP:
193 case SFX_ALIGN_LOWESTTOP:
194 case SFX_ALIGN_BOTTOM:
195 case SFX_ALIGN_LOWESTBOTTOM:
196 case SFX_ALIGN_HIGHESTBOTTOM:
197 return eActAlign;
198
199 case SFX_ALIGN_LEFT:
200 case SFX_ALIGN_RIGHT:
201 case SFX_ALIGN_FIRSTLEFT:
202 case SFX_ALIGN_LASTLEFT:
203 case SFX_ALIGN_FIRSTRIGHT:
204 case SFX_ALIGN_LASTRIGHT:
205 return eAlign;
206
207 default:
208 return eAlign;
209 }
210 }
211
212 //-------------------------------------------------------------------------
213
SfxTemplateCatalog(Window * pParent,SfxBindings * pBindings)214 SfxTemplateCatalog::SfxTemplateCatalog(Window *pParent, SfxBindings *pBindings)
215 : SfxModalDialog(pParent,SfxResId(RID_STYLECATALOG))
216 {
217 pImpl = new SfxTemplateCatalog_Impl(pParent, pBindings, this);
218 }
219
220 //-------------------------------------------------------------------------
221
~SfxTemplateCatalog()222 SfxTemplateCatalog::~SfxTemplateCatalog()
223 {
224 delete pImpl;
225 }
226
227 //-------------------------------------------------------------------------
228
MouseButtonDown(const MouseEvent & rMEvt)229 void DropListBox_Impl::MouseButtonDown( const MouseEvent& rMEvt )
230 {
231 nModifier = rMEvt.GetModifier();
232
233 sal_Bool bHitEmptySpace = ( NULL == GetEntry( rMEvt.GetPosPixel(), sal_True ) );
234 if( bHitEmptySpace && ( rMEvt.GetClicks() == 2 ) && rMEvt.IsMod1() )
235 Control::MouseButtonDown( rMEvt );
236 else
237 SvTreeListBox::MouseButtonDown( rMEvt );
238 }
239
AcceptDrop(const AcceptDropEvent & rEvt)240 sal_Int8 DropListBox_Impl::AcceptDrop( const AcceptDropEvent& rEvt )
241
242 /* [Description: ]
243 Drop is enabled as long as it is allowed to create a new style by example, i.e. to
244 create a style out of the current selection.
245 */
246
247 {
248 if ( IsDropFormatSupported( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) )
249 {
250 // special case: page styles are allowed to create new styles by example
251 // but not allowed to be created by drag and drop
252 if( pDialog->nActFamily == SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SFX_STYLE_FAMILY_PAGE ) ||
253 pDialog->bNewByExampleDisabled )
254 return DND_ACTION_NONE;
255 else
256 return DND_ACTION_COPY;
257 }
258 return SvTreeListBox::AcceptDrop( rEvt );
259 }
260
261 //-------------------------------------------------------------------------
262
ExecuteDrop(const ExecuteDropEvent & rEvt)263 sal_Int8 DropListBox_Impl::ExecuteDrop( const ExecuteDropEvent& rEvt )
264 {
265 // rEvt.maDropEvent.Context->acceptDrop( DND_ACTION_NONE );
266 // rEvt.maDropEvent.Context->dropComplete( sal_True );
267
268 sal_Int8 nRet = DND_ACTION_NONE;
269 SfxObjectShell* pDocShell = pDialog->GetObjectShell();
270 TransferableDataHelper aHelper( rEvt.maDropEvent.Transferable );
271 sal_uInt32 nFormatCount = aHelper.GetFormatCount();
272 if ( pDocShell )
273 {
274 sal_Bool bFormatFound = sal_False;
275
276 for ( sal_uInt32 i = 0; i < nFormatCount; ++i )
277 {
278 SotFormatStringId nId = aHelper.GetFormat(i);
279 TransferableObjectDescriptor aDesc;
280
281 if ( aHelper.GetTransferableObjectDescriptor( nId, aDesc ) )
282 {
283 if ( aDesc.maClassName == pDocShell->GetFactory().GetClassId() )
284 {
285 PostUserEvent( LINK( this, DropListBox_Impl, OnAsyncExecuteDrop ), 0 );
286
287 bFormatFound = sal_True;
288 nRet = rEvt.mnAction;
289 break;
290 }
291 }
292 }
293
294 if ( !bFormatFound )
295 return SvTreeListBox::ExecuteDrop( rEvt );
296 }
297
298 return nRet;
299 }
300
301
IMPL_LINK(DropListBox_Impl,OnAsyncExecuteDrop,SvLBoxEntry *,EMPTYARG)302 IMPL_LINK( DropListBox_Impl, OnAsyncExecuteDrop, SvLBoxEntry*, EMPTYARG )
303 {
304 pDialog->ActionSelect( SID_STYLE_NEW_BY_EXAMPLE );
305 return 0;
306 }
307
308
IMPL_LINK(DropListBox_Impl,OnAsyncExecuteError,void *,NOTINTERESTEDIN)309 IMPL_LINK( DropListBox_Impl, OnAsyncExecuteError, void*, NOTINTERESTEDIN )
310 {
311 (void)NOTINTERESTEDIN; // unused
312 ErrorHandler::HandleError( ERRCODE_IO_WRONGFORMAT );
313
314 return 0;
315 }
316
317
Notify(NotifyEvent & rNEvt)318 long DropListBox_Impl::Notify( NotifyEvent& rNEvt )
319 {
320 long nRet = 0;
321 if( rNEvt.GetType() == EVENT_KEYINPUT )
322 {
323 const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
324 if(!rKeyCode.GetModifier())
325 {
326 if( pDialog->bCanDel && KEY_DELETE == rKeyCode.GetCode())
327 {
328 pDialog->DeleteHdl( NULL );
329 nRet = 1;
330 }
331 else if( KEY_RETURN == rKeyCode.GetCode())
332 {
333 GetDoubleClickHdl().Call(this);
334 nRet = 1;
335 }
336 }
337 }
338 if(!nRet)
339 nRet = SvTreeListBox::Notify( rNEvt );
340 return nRet;
341 }
342
343
344 //-------------------------------------------------------------------------
345
346
SfxActionListBox(SfxCommonTemplateDialog_Impl * pParent,WinBits nWinBits)347 SfxActionListBox::SfxActionListBox
348 (
349 SfxCommonTemplateDialog_Impl* pParent,
350 WinBits nWinBits
351 )
352
353 /* [Beschreibung]
354
355 ListBox- Klasse, die im Command-Handler ein PopupMenu (Gestalter
356 spezifisch) startet.
357
358 */
359
360 : DropListBox_Impl(pParent->GetWindow(), nWinBits, pParent)
361
362 {
363 EnableContextMenuHandling();
364 }
365
366 //-------------------------------------------------------------------------
367
SfxActionListBox(SfxCommonTemplateDialog_Impl * pParent,const ResId & rResId)368 SfxActionListBox::SfxActionListBox( SfxCommonTemplateDialog_Impl* pParent,
369 const ResId &rResId) :
370 DropListBox_Impl(pParent->GetWindow(), rResId, pParent)
371 {
372 EnableContextMenuHandling();
373 }
374
375 //-------------------------------------------------------------------------
376
CreateContextMenu(void)377 PopupMenu* SfxActionListBox::CreateContextMenu( void )
378 {
379 //added by BerryJia for fixing Bug102739 2002-9-9 17:00(Beijing Time)
380 if( !( GetSelectionCount() > 0 ) )
381 {
382 pDialog->EnableEdit( sal_False );
383 pDialog->EnableDel( sal_False );
384 }
385 return pDialog->CreateContextMenu();
386 }
387
388 //-------------------------------------------------------------------------
389
SfxTemplateDialogWrapper(Window * pParentWnd,sal_uInt16 nId,SfxBindings * p,SfxChildWinInfo * pInfo)390 SfxTemplateDialogWrapper::SfxTemplateDialogWrapper(Window *pParentWnd,
391 sal_uInt16 nId, SfxBindings *p, SfxChildWinInfo *pInfo) :
392 SfxChildWindow(pParentWnd, nId)
393 {
394 SfxTemplateDialog *pWin = new SfxTemplateDialog(p, this, pParentWnd);
395 pWindow = pWin;
396 eChildAlignment = SFX_ALIGN_NOALIGNMENT;
397
398 pWin->Initialize( pInfo );
399 pWin->SetMinOutputSizePixel(pWin->pImpl->GetMinOutputSizePixel());
400 }
401
SetParagraphFamily()402 void SfxTemplateDialogWrapper::SetParagraphFamily()
403 {
404 // forward to SfxTemplateDialog, because SfxTemplateDialog isn't exported
405 static_cast< SfxTemplateDialog* >( GetWindow() )->SetParagraphFamily();
406 }
407
408
409
410 //===== SfxTemplatePanelControl ===============================================
411
SfxTemplatePanelControl(SfxBindings * pBindings,Window * pParentWindow)412 SfxTemplatePanelControl::SfxTemplatePanelControl (
413 SfxBindings* pBindings,
414 Window* pParentWindow)
415 : DockingWindow(pParentWindow, SfxResId(DLG_STYLE_DESIGNER) ),
416 pImpl(new SfxTemplateDialog_Impl(pBindings, this)),
417 mpBindings(pBindings)
418 {
419 OSL_ASSERT(mpBindings!=NULL);
420
421 pImpl->updateNonFamilyImages();
422
423 SetStyle(GetStyle() & ~WB_DOCKABLE);
424 }
425
426
427
428
~SfxTemplatePanelControl(void)429 SfxTemplatePanelControl::~SfxTemplatePanelControl (void)
430 {
431 delete pImpl;
432 }
433
434
435
436
GetISfxTemplateCommon()437 ISfxTemplateCommon* SfxTemplatePanelControl::GetISfxTemplateCommon()
438 {
439 return pImpl->GetISfxTemplateCommon();
440 }
441
442
443
444
SetParagraphFamily()445 void SfxTemplatePanelControl::SetParagraphFamily()
446 {
447 // first select the paragraph family
448 pImpl->FamilySelect( SFX_STYLE_FAMILY_PARA );
449 // then select the automatic filter
450 pImpl->SetAutomaticFilter();
451 }
452
453
454
455
DataChanged(const DataChangedEvent & _rDCEvt)456 void SfxTemplatePanelControl::DataChanged( const DataChangedEvent& _rDCEvt )
457 {
458 if ( ( DATACHANGED_SETTINGS == _rDCEvt.GetType() ) &&
459 ( 0 != ( SETTINGS_STYLE & _rDCEvt.GetFlags() ) ) )
460 {
461 pImpl->updateFamilyImages();
462 pImpl->updateNonFamilyImages();
463 }
464
465 DockingWindow::DataChanged( _rDCEvt );
466 }
467
468
469
470
Update()471 void SfxTemplatePanelControl::Update()
472 {
473 pImpl->Update();
474 }
475
476
477
478
Resize()479 void SfxTemplatePanelControl::Resize()
480 {
481 if(pImpl)
482 pImpl->Resize();
483 DockingWindow::Resize();
484 }
485
486
FreeResource(void)487 void SfxTemplatePanelControl::FreeResource (void)
488 {
489 DockingWindow::FreeResource();
490 }
491
492
CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)493 SfxChildAlignment SfxTemplatePanelControl::CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)
494 {
495 switch (eAlign)
496 {
497 case SFX_ALIGN_TOP:
498 case SFX_ALIGN_HIGHESTTOP:
499 case SFX_ALIGN_LOWESTTOP:
500 case SFX_ALIGN_BOTTOM:
501 case SFX_ALIGN_LOWESTBOTTOM:
502 case SFX_ALIGN_HIGHESTBOTTOM:
503 return eActAlign;
504
505 case SFX_ALIGN_LEFT:
506 case SFX_ALIGN_RIGHT:
507 case SFX_ALIGN_FIRSTLEFT:
508 case SFX_ALIGN_LASTLEFT:
509 case SFX_ALIGN_FIRSTRIGHT:
510 case SFX_ALIGN_LASTRIGHT:
511 return eAlign;
512
513 default:
514 return eAlign;
515 }
516 }
517
518
StateChanged(StateChangedType nStateChange)519 void SfxTemplatePanelControl::StateChanged( StateChangedType nStateChange )
520 {
521 if ( nStateChange == STATE_CHANGE_INITSHOW )
522 {
523 SfxViewFrame *pFrame = mpBindings->GetDispatcher_Impl()->GetFrame();
524 Window* pEditWin = pFrame->GetViewShell()->GetWindow();
525
526 Size aSize = pEditWin->GetSizePixel();
527 Point aPoint = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
528 aPoint = GetParent()->ScreenToOutputPixel( aPoint );
529 Size aWinSize = GetSizePixel();
530 aPoint.X() += aSize.Width() - aWinSize.Width() - 20;
531 aPoint.Y() += aSize.Height() / 2 - aWinSize.Height() / 2;
532 // SetFloatingPos( aPoint );
533 }
534
535 DockingWindow::StateChanged( nStateChange );
536 }
537
538
539 //=========================================================================
540 SV_DECL_PTRARR_DEL(ExpandedEntries, StringPtr,16,8)
541 SV_IMPL_PTRARR(ExpandedEntries, StringPtr)
542
543 /* [Beschreibung]
544
545 TreeListBox- Klasse f"ur die Anzeige der hierarchischen View
546 der Vorlagen
547
548 */
549
550 class StyleTreeListBox_Impl : public DropListBox_Impl
551 {
552 private:
553 SvLBoxEntry* pCurEntry;
554 SfxCommonTemplateDialog_Impl* pCommon;
555 Link aDoubleClickLink;
556 Link aDropLink;
557 String aParent;
558 String aStyle;
559
560 protected:
561 virtual void Command( const CommandEvent& rMEvt );
562 virtual long Notify( NotifyEvent& rNEvt );
563 virtual sal_Bool DoubleClickHdl();
564 virtual long ExpandingHdl();
565 virtual void ExpandedHdl();
566 virtual sal_Bool NotifyMoving(SvLBoxEntry* pTarget,
567 SvLBoxEntry* pEntry,
568 SvLBoxEntry*& rpNewParent,
569 sal_uIntPtr& rNewChildPos);
570 public:
571 StyleTreeListBox_Impl( SfxCommonTemplateDialog_Impl* pParent, WinBits nWinStyle = 0);
572
SetDoubleClickHdl(const Link & rLink)573 void SetDoubleClickHdl(const Link &rLink) { aDoubleClickLink = rLink; }
SetDropHdl(const Link & rLink)574 void SetDropHdl(const Link &rLink) { aDropLink = rLink; }
575 using SvLBox::GetParent;
GetParent() const576 const String& GetParent() const { return aParent; }
GetStyle() const577 const String& GetStyle() const { return aStyle; }
578 void MakeExpanded_Impl(ExpandedEntries& rEntries) const;
579
580 virtual PopupMenu* CreateContextMenu( void );
581 };
582
583 //-------------------------------------------------------------------------
584
585
MakeExpanded_Impl(ExpandedEntries & rEntries) const586 void StyleTreeListBox_Impl::MakeExpanded_Impl(ExpandedEntries& rEntries) const
587 {
588 SvLBoxEntry *pEntry;
589 sal_uInt16 nCount=0;
590 for(pEntry=(SvLBoxEntry*)FirstVisible();pEntry;pEntry=(SvLBoxEntry*)NextVisible(pEntry))
591 {
592 if(IsExpanded(pEntry))
593 {
594 StringPtr pString=new String(GetEntryText(pEntry));
595 rEntries.Insert(pString,nCount++);
596 }
597 }
598 }
599
CreateContextMenu()600 PopupMenu* StyleTreeListBox_Impl::CreateContextMenu()
601 {
602 return pDialog->CreateContextMenu();
603 }
604
DoubleClickHdl()605 sal_Bool StyleTreeListBox_Impl::DoubleClickHdl()
606
607 /* [Beschreibung]
608
609
610 DoubleClick-Handler; ruft entsprechenden Link.
611 Virtuelle Methode aus SV.
612
613 */
614 {
615 aDoubleClickLink.Call(this);
616 return sal_False;
617 }
618
619 //-------------------------------------------------------------------------
620
Command(const CommandEvent & rCEvt)621 void StyleTreeListBox_Impl::Command( const CommandEvent& rCEvt )
622
623 /* [Beschreibung]
624
625 Command Handler; dieser executed ein PopupMenu (Gestalter
626 spezifisch).
627 Virtuelle Methode aus SV.
628
629 */
630 {
631 SvTreeListBox::Command(rCEvt);
632 }
633
634 //-------------------------------------------------------------------------
635
Notify(NotifyEvent & rNEvt)636 long StyleTreeListBox_Impl::Notify( NotifyEvent& rNEvt )
637 {
638 // handle <RETURN> as double click
639
640 long nRet = 0;
641 if ( rNEvt.GetType() == EVENT_KEYINPUT )
642 {
643 const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
644 if ( !rKeyCode.GetModifier() && KEY_RETURN == rKeyCode.GetCode() )
645 {
646 aDoubleClickLink.Call( this );
647 nRet = 1;
648 }
649 }
650
651 if ( !nRet )
652 nRet = DropListBox_Impl::Notify( rNEvt );
653
654 return nRet;
655 }
656
657 //-------------------------------------------------------------------------
658
NotifyMoving(SvLBoxEntry * pTarget,SvLBoxEntry * pEntry,SvLBoxEntry * & rpNewParent,sal_uIntPtr & lPos)659 sal_Bool StyleTreeListBox_Impl::NotifyMoving(SvLBoxEntry* pTarget,
660 SvLBoxEntry* pEntry,
661 SvLBoxEntry*& rpNewParent,
662 sal_uIntPtr& lPos)
663 /* [Beschreibung]
664
665 NotifyMoving Handler; dieser leitet per Link das Event an den Dialog
666 weiter.
667 Virtuelle Methode aus SV.
668
669 */
670 {
671 if(!pTarget || !pEntry)
672 return sal_False;
673 aParent = GetEntryText(pTarget);
674 aStyle = GetEntryText(pEntry);
675 const sal_Bool bRet = (sal_Bool)aDropLink.Call(this);
676 rpNewParent = pTarget;
677 lPos=0;
678 IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() );
679 const CollatorWrapper* pCollator = aIntlWrapper.getCaseCollator();
680 for(SvLBoxEntry *pTmpEntry=FirstChild(pTarget);
681 pTmpEntry && COMPARE_LESS==pCollator->compareString(
682 GetEntryText(pTmpEntry),GetEntryText(pEntry));
683 pTmpEntry=NextSibling(pTmpEntry),lPos++) ;
684
685 return bRet? (sal_Bool)2: sal_False;
686 }
687
688 //-------------------------------------------------------------------------
689
ExpandingHdl()690 long StyleTreeListBox_Impl::ExpandingHdl()
691
692 /* [Beschreibung]
693
694 ExpandingHdl Handler; der aktuelle Eintrag wird gemerkt.
695 Virtuelle Methode aus SV.
696
697 [Querverweise]
698 <StyleTreeListBox_Impl::ExpandedHdl()>
699
700 */
701 {
702 pCurEntry = GetCurEntry();
703 return sal_True;
704 }
705
706 //-------------------------------------------------------------------------
707
ExpandedHdl()708 void StyleTreeListBox_Impl::ExpandedHdl()
709
710 /* [Beschreibung]
711
712 ExpandedHdl Handler;
713 Virtuelle Methode aus SV.
714
715 [Querverweise]
716 <StyleTreeListBox_Impl::ExpandingHdl()>
717
718 */
719
720 {
721 SvLBoxEntry *pEntry = GetHdlEntry();
722 if(!IsExpanded(pEntry) && pCurEntry != GetCurEntry())
723 SelectAll( sal_False );
724 pCurEntry = 0;
725 }
726
727 //-------------------------------------------------------------------------
728
StyleTreeListBox_Impl(SfxCommonTemplateDialog_Impl * pParent,WinBits nWinStyle)729 StyleTreeListBox_Impl::StyleTreeListBox_Impl(
730 SfxCommonTemplateDialog_Impl* pParent, WinBits nWinStyle) :
731 DropListBox_Impl(pParent->GetWindow(), nWinStyle, pParent),
732 pCurEntry(0),
733 pCommon(pParent)
734
735 /* [Beschreibung]
736
737 Konstruktor StyleTreeListBox_Impl
738
739 */
740 {
741 EnableContextMenuHandling();
742 }
743
744 //-------------------------------------------------------------------------
745 //-------------------------------------------------------------------------
746
747 class StyleTreeArr_Impl;
748
749
750 /* [Beschreibung]
751
752 Interne Struktur f"ur den Aufbau der hierarchischen View
753
754 */
755
756 struct StyleTree_Impl
757 {
758 String aName;
759 String aParent;
760 StyleTreeArr_Impl *pChilds;
761 sal_Bool bIsExpanded;
HasParentStyleTree_Impl762 sal_Bool HasParent() const { return aParent.Len() != 0; }
763
StyleTree_ImplStyleTree_Impl764 StyleTree_Impl(const String &rName, const String &rParent):
765 aName(rName), aParent(rParent), pChilds(0), bIsExpanded(0) {}
766 ~StyleTree_Impl();
767 void Put(StyleTree_Impl* pIns, sal_uIntPtr lPos=ULONG_MAX);
768 sal_uIntPtr Count();
769 };
770
771 typedef StyleTree_Impl* StyleTree_ImplPtr;
772 SV_DECL_PTRARR_DEL(StyleTreeArr_Impl, StyleTree_ImplPtr, 16, 8)
SV_IMPL_PTRARR(StyleTreeArr_Impl,StyleTree_ImplPtr)773 SV_IMPL_PTRARR(StyleTreeArr_Impl, StyleTree_ImplPtr)
774
775
776 sal_uIntPtr StyleTree_Impl::Count()
777 {
778 return pChilds ? pChilds->Count() : 0L;
779 }
780
781 //-------------------------------------------------------------------------
782
~StyleTree_Impl()783 StyleTree_Impl::~StyleTree_Impl()
784 {
785 delete pChilds;
786 }
787
788 //-------------------------------------------------------------------------
789
Put(StyleTree_Impl * pIns,sal_uIntPtr lPos)790 void StyleTree_Impl::Put(StyleTree_Impl* pIns, sal_uIntPtr lPos)
791 {
792 if ( !pChilds )
793 pChilds = new StyleTreeArr_Impl;
794
795 if ( ULONG_MAX == lPos )
796 lPos = pChilds->Count();
797 pChilds->Insert( pIns, (sal_uInt16)lPos );
798 }
799
800 //-------------------------------------------------------------------------
801
MakeTree_Impl(StyleTreeArr_Impl & rArr)802 StyleTreeArr_Impl &MakeTree_Impl(StyleTreeArr_Impl &rArr)
803 {
804 const sal_uInt16 nCount = rArr.Count();
805 // Alle unter ihren Parents einordnen
806 sal_uInt16 i;
807 for(i = 0; i < nCount; ++i)
808 {
809 StyleTree_ImplPtr pEntry = rArr[i];
810 if(pEntry->HasParent())
811 {
812 for(sal_uInt16 j = 0; j < nCount; ++j)
813 {
814 StyleTree_ImplPtr pCmp = rArr[j];
815 if(pCmp->aName == pEntry->aParent)
816 {
817 // initial sortiert einfuegen
818 sal_uInt16 ii;
819 IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() );
820 const CollatorWrapper* pCollator = aIntlWrapper.getCaseCollator();
821 for ( ii = 0;
822 ii < pCmp->Count() && COMPARE_LESS ==
823 pCollator->compareString( (*pCmp->pChilds)[ii]->aName,
824 pEntry->aName);++ii) ;
825 pCmp->Put(pEntry,ii);
826 break;
827 }
828 }
829 }
830 }
831 // alle, die schon unter ihrem Parent eingeordnet wurden
832 // entfernen
833 for(i = 0; i < rArr.Count(); )
834 {
835 if(rArr[i]->HasParent())
836 rArr.Remove(i);
837 else
838 ++i;
839 }
840 return rArr;
841 }
842
843 //-------------------------------------------------------------------------
844
845
IsExpanded_Impl(const ExpandedEntries & rEntries,const String & rStr)846 inline sal_Bool IsExpanded_Impl( const ExpandedEntries& rEntries,
847 const String &rStr)
848 {
849 sal_uInt16 nCount=rEntries.Count();
850 for(sal_uInt16 n=0;n<nCount;n++)
851 if(*rEntries[n]==rStr)
852 return sal_True;
853 return sal_False;
854 }
855
856
857
FillBox_Impl(SvTreeListBox * pBox,StyleTree_ImplPtr pEntry,const ExpandedEntries & rEntries,SvLBoxEntry * pParent=0)858 SvLBoxEntry* FillBox_Impl(SvTreeListBox *pBox,
859 StyleTree_ImplPtr pEntry,
860 const ExpandedEntries& rEntries,
861 SvLBoxEntry* pParent = 0)
862 {
863 SvLBoxEntry* pNewEntry = pBox->InsertEntry(pEntry->aName, pParent);
864 const sal_uInt16 nCount = pEntry->pChilds? pEntry->pChilds->Count(): 0;
865 for(sal_uInt16 i = 0; i < nCount; ++i)
866 FillBox_Impl(pBox, (*pEntry->pChilds)[i], rEntries, pNewEntry);
867 return pNewEntry;
868 }
869
870 //-------------------------------------------------------------------------
871
872 // Konstruktor
873
SfxCommonTemplateDialog_Impl(SfxBindings * pB,Window * pW,bool)874 SfxCommonTemplateDialog_Impl::SfxCommonTemplateDialog_Impl( SfxBindings* pB, Window* pW, bool ) :
875
876 aISfxTemplateCommon ( this ),
877 pBindings ( pB ),
878 pWindow ( pW ),
879 pModule ( NULL ),
880 pTimer ( NULL ),
881 m_pStyleFamiliesId ( NULL ),
882 pStyleSheetPool ( NULL ),
883 pTreeBox ( NULL ),
884 pCurObjShell ( NULL ),
885 xModuleManager ( ::comphelper::getProcessServiceFactory()->createInstance(
886 DEFINE_CONST_UNICODE("com.sun.star.frame.ModuleManager") ), UNO_QUERY ),
887 pbDeleted ( NULL ),
888
889 aFmtLb ( this, WB_BORDER | WB_TABSTOP | WB_SORT | WB_QUICK_SEARCH ),
890 aFilterLb ( pW, WB_BORDER | WB_DROPDOWN | WB_TABSTOP ),
891
892 nActFamily ( SFX_TEMPLDLG_FILTER_MAX ),
893 nActFilter ( 0 ),
894 nAppFilter ( 0 ),
895
896 bDontUpdate ( sal_False ),
897 bIsWater ( sal_False ),
898 bEnabled ( sal_True ),
899 bUpdate ( sal_False ),
900 bUpdateFamily ( sal_False ),
901 bCanEdit ( sal_False ),
902 bCanDel ( sal_False ),
903 bCanNew ( sal_True ),
904 bWaterDisabled ( sal_False ),
905 bNewByExampleDisabled ( sal_False ),
906 bUpdateByExampleDisabled( sal_False ),
907 bTreeDrag ( sal_True ),
908 bHierarchical ( sal_False ),
909 bBindingUpdate ( sal_True )
910 {
911 aFmtLb.SetAccessibleName(SfxResId(STR_STYLE_ELEMTLIST));
912 aFmtLb.SetHelpId( HID_TEMPLATE_FMT );
913 aFilterLb.SetHelpId( HID_TEMPLATE_FILTER );
914 aFmtLb.SetStyle( aFmtLb.GetStyle() | WB_SORT | WB_HIDESELECTION );
915 Font aFont = aFmtLb.GetFont();
916 aFont.SetWeight( WEIGHT_NORMAL );
917 aFmtLb.SetFont( aFont );
918 }
919
920 //-------------------------------------------------------------------------
921
SfxCommonTemplateDialog_Impl(SfxBindings * pB,Window * pW)922 SfxCommonTemplateDialog_Impl::SfxCommonTemplateDialog_Impl( SfxBindings* pB, Window* pW ) :
923
924 aISfxTemplateCommon ( this ),
925 pBindings ( pB ),
926 pWindow ( pW ),
927 pModule ( NULL ),
928 pTimer ( NULL ),
929 pStyleSheetPool ( NULL ),
930 pTreeBox ( NULL ),
931 pCurObjShell ( NULL ),
932 pbDeleted ( NULL ),
933
934 aFmtLb ( this, SfxResId( BT_VLIST ) ),
935 aFilterLb ( pW, SfxResId( BT_FLIST ) ),
936
937 nActFamily ( SFX_TEMPLDLG_FILTER_MAX ),
938 nActFilter ( 0 ),
939 nAppFilter ( 0 ),
940
941 bDontUpdate ( sal_False ),
942 bIsWater ( sal_False ),
943 bEnabled ( sal_True ),
944 bUpdate ( sal_False ),
945 bUpdateFamily ( sal_False ),
946 bCanEdit ( sal_False ),
947 bCanDel ( sal_False ),
948 bCanNew ( sal_True ),
949 bWaterDisabled ( sal_False ),
950 bNewByExampleDisabled ( sal_False ),
951 bUpdateByExampleDisabled( sal_False ),
952 bTreeDrag ( sal_True ),
953 bHierarchical ( sal_False ),
954 bBindingUpdate ( sal_True )
955
956 {
957 aFmtLb.SetStyle( aFmtLb.GetStyle() | WB_SORT );
958 }
959
960 //-------------------------------------------------------------------------
961
StyleNrToInfoOffset(sal_uInt16 nId)962 sal_uInt16 SfxCommonTemplateDialog_Impl::StyleNrToInfoOffset(sal_uInt16 nId)
963 {
964 const SfxStyleFamilyItem *pItem=pStyleFamilies->GetObject(nId);
965 return SfxFamilyIdToNId(pItem->GetFamily())-1;
966 }
967
968 //-------------------------------------------------------------------------
969
EnableEdit(sal_Bool bEnable)970 void SfxTemplateDialog_Impl::EnableEdit(sal_Bool bEnable)
971 {
972 SfxCommonTemplateDialog_Impl::EnableEdit( bEnable );
973 if( !bEnable || !bUpdateByExampleDisabled )
974 EnableItem( SID_STYLE_UPDATE_BY_EXAMPLE, bEnable);
975 }
976
977 //-------------------------------------------------------------------------
978
979
InfoOffsetToStyleNr(sal_uInt16 nId)980 sal_uInt16 SfxCommonTemplateDialog_Impl::InfoOffsetToStyleNr(sal_uInt16 nId)
981 {
982 for ( sal_uInt16 i=0;i<pStyleFamilies->Count();i++ )
983 if ( SfxFamilyIdToNId(pStyleFamilies->GetObject(i)->GetFamily()) == nId+1 )
984 return i;
985 DBG_ERROR("Style Nummer nicht gefunden");
986 return 0;
987 }
988
989
990 //-------------------------------------------------------------------------
991
ReadResource()992 void SfxCommonTemplateDialog_Impl::ReadResource()
993 {
994 // globale Benutzer-Resource auslesen
995 sal_uInt16 i;
996 for(i = 0; i < MAX_FAMILIES; ++i)
997 pFamilyState[i] = 0;
998
999 SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1000 pCurObjShell = pViewFrame->GetObjectShell();
1001 ResMgr* pMgr = pCurObjShell ? pCurObjShell->GetResMgr() : NULL;
1002 ResId aFamId( DLG_STYLE_DESIGNER, *pMgr );
1003 aFamId.SetRT(RSC_SFX_STYLE_FAMILIES);
1004 m_pStyleFamiliesId = new ResId( aFamId.GetId(), *pMgr );
1005 m_pStyleFamiliesId->SetRT(RSC_SFX_STYLE_FAMILIES);
1006 if( !pMgr || !pMgr->IsAvailable( aFamId ) )
1007 pStyleFamilies = new SfxStyleFamilies;
1008 else
1009 pStyleFamilies = new SfxStyleFamilies( aFamId );
1010
1011 nActFilter = pCurObjShell ?
1012 static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pCurObjShell ) ) :
1013 SFX_TEMPLDLG_FILTER_MAX;
1014 if ( pCurObjShell && SFX_TEMPLDLG_FILTER_MAX == nActFilter )
1015 nActFilter = pCurObjShell->GetAutoStyleFilterIndex();
1016
1017 // Einfuegen in die Toolbox
1018 // umgekehrte Reihenfolge, da immer vorne eingefuegt wird.
1019 sal_uInt16 nCount = pStyleFamilies->Count();
1020
1021 pBindings->ENTERREGISTRATIONS();
1022
1023 for(i = 0; i < nCount; ++i)
1024 {
1025 sal_uInt16 nSlot = 0;
1026 switch((sal_uInt16)pStyleFamilies->GetObject(i)->GetFamily())
1027 {
1028 case SFX_STYLE_FAMILY_CHAR: nSlot = SID_STYLE_FAMILY1; break;
1029 case SFX_STYLE_FAMILY_PARA: nSlot = SID_STYLE_FAMILY2; break;
1030 case SFX_STYLE_FAMILY_FRAME:nSlot = SID_STYLE_FAMILY3; break;
1031 case SFX_STYLE_FAMILY_PAGE: nSlot = SID_STYLE_FAMILY4; break;
1032 case SFX_STYLE_FAMILY_PSEUDO: nSlot = SID_STYLE_FAMILY5; break;
1033 default: DBG_ERROR("unbekannte StyleFamily"); break;
1034 }
1035 pBoundItems[i] =
1036 new SfxTemplateControllerItem(nSlot, *this, *pBindings);
1037 }
1038 pBoundItems[i++] = new SfxTemplateControllerItem(
1039 SID_STYLE_WATERCAN, *this, *pBindings);
1040 pBoundItems[i++] = new SfxTemplateControllerItem(
1041 SID_STYLE_NEW_BY_EXAMPLE, *this, *pBindings);
1042 pBoundItems[i++] = new SfxTemplateControllerItem(
1043 SID_STYLE_UPDATE_BY_EXAMPLE, *this, *pBindings);
1044 pBoundItems[i++] = new SfxTemplateControllerItem(
1045 SID_STYLE_NEW, *this, *pBindings);
1046 pBoundItems[i++] = new SfxTemplateControllerItem(
1047 SID_STYLE_DRAGHIERARCHIE, *this, *pBindings);
1048 pBoundItems[i++] = new SfxTemplateControllerItem(
1049 SID_STYLE_EDIT, *this, *pBindings);
1050 pBoundItems[i++] = new SfxTemplateControllerItem(
1051 SID_STYLE_DELETE, *this, *pBindings);
1052 pBoundItems[i++] = new SfxTemplateControllerItem(
1053 SID_STYLE_FAMILY, *this, *pBindings);
1054 pBindings->LEAVEREGISTRATIONS();
1055
1056 for(; i < COUNT_BOUND_FUNC; ++i)
1057 pBoundItems[i] = 0;
1058
1059 StartListening(*pBindings);
1060
1061 //In umgekehrter Reihenfolge des Auftretens in den Stylefamilies einfuegen.
1062 //Das ist fuer den Toolbar des Gestalters. Die Listbox des Kataloges achtet
1063 //selbst auf korrekte Reihenfolge.
1064
1065 //Reihenfolgen: Reihenfolge in der Resource = Reihenfolge in Toolbar bzw.
1066 //Listbox.
1067 //Reihenfolge aufsteigender SIDs: Niedrige SIDs werden als erstes angezeigt,
1068 //wenn Vorlagen mehrerer Familien aktiv sind.
1069
1070 // in the Writer the UpdateStyleByExample Toolbox button is removed and
1071 // the NewStyle button gets a PopupMenu
1072 if(nCount > 4)
1073 ReplaceUpdateButtonByMenu();
1074
1075 for( ; nCount--; )
1076 {
1077 const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject( nCount );
1078 sal_uInt16 nId = SfxFamilyIdToNId( pItem->GetFamily() );
1079 InsertFamilyItem( nId, pItem );
1080 }
1081
1082 LoadedFamilies();
1083
1084 sal_uInt16 nStart = SID_STYLE_FAMILY1;
1085 sal_uInt16 nEnd = SID_STYLE_FAMILY4;
1086
1087 for ( i = nStart; i <= nEnd; i++ )
1088 pBindings->Update(i);
1089
1090 pModule = pCurObjShell ? pCurObjShell->GetModule() : NULL;
1091 }
1092
1093 //-------------------------------------------------------------------------
1094
ClearResource()1095 void SfxCommonTemplateDialog_Impl::ClearResource()
1096 {
1097 ClearFamilyList();
1098 DELETEX(pStyleFamilies);
1099 sal_uInt16 i;
1100 for ( i = 0; i < MAX_FAMILIES; ++i )
1101 DELETEX(pFamilyState[i]);
1102 for ( i = 0; i < COUNT_BOUND_FUNC; ++i )
1103 delete pBoundItems[i];
1104 pCurObjShell = NULL;
1105
1106 DELETEZ( m_pStyleFamiliesId );
1107 }
1108
1109 //-------------------------------------------------------------------------
1110
Initialize()1111 void SfxCommonTemplateDialog_Impl::Initialize()
1112 {
1113 // globale Benutzer-Resource auslesen
1114 ReadResource();
1115 pBindings->Invalidate( SID_STYLE_FAMILY );
1116 pBindings->Update( SID_STYLE_FAMILY );
1117 Update_Impl();
1118
1119 aFilterLb.SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, FilterSelectHdl ) );
1120 aFmtLb.SetDoubleClickHdl( LINK( this, SfxCommonTemplateDialog_Impl, ApplyHdl ) );
1121 aFmtLb.SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, FmtSelectHdl ) );
1122
1123 aFilterLb.Show();
1124 aFmtLb.Show();
1125 }
1126
1127 //-------------------------------------------------------------------------
1128
~SfxCommonTemplateDialog_Impl()1129 SfxCommonTemplateDialog_Impl::~SfxCommonTemplateDialog_Impl()
1130 {
1131 String aEmpty;
1132 if ( bIsWater )
1133 Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
1134 GetWindow()->Hide();
1135 DELETEX(pStyleFamilies);
1136 DELETEZ( m_pStyleFamiliesId );
1137 sal_uInt16 i;
1138 for ( i = 0; i < MAX_FAMILIES; ++i )
1139 DELETEX(pFamilyState[i]);
1140 for ( i = 0; i < COUNT_BOUND_FUNC; ++i )
1141 delete pBoundItems[i];
1142 if ( pStyleSheetPool )
1143 EndListening(*pStyleSheetPool);
1144 pStyleSheetPool = NULL;
1145 delete pTreeBox;
1146 delete pTimer;
1147 if ( pbDeleted )
1148 {
1149 pbDeleted->bDead = true;
1150 pbDeleted = NULL;
1151 }
1152 }
1153
1154 //-------------------------------------------------------------------------
1155
SfxFamilyIdToNId(SfxStyleFamily nFamily)1156 sal_uInt16 SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SfxStyleFamily nFamily )
1157 {
1158 switch ( nFamily )
1159 {
1160 case SFX_STYLE_FAMILY_CHAR: return 1;
1161 case SFX_STYLE_FAMILY_PARA: return 2;
1162 case SFX_STYLE_FAMILY_FRAME: return 3;
1163 case SFX_STYLE_FAMILY_PAGE: return 4;
1164 case SFX_STYLE_FAMILY_PSEUDO: return 5;
1165 default: return 0;
1166 }
1167 }
1168
SetAutomaticFilter()1169 void SfxCommonTemplateDialog_Impl::SetAutomaticFilter()
1170 {
1171 sal_uInt16 nCount = aFilterLb.GetEntryCount();
1172 for ( sal_uInt16 i = 0; i < nCount; ++i )
1173 {
1174 sal_uIntPtr nFlags = (sal_uIntPtr)aFilterLb.GetEntryData(i);
1175 if ( SFXSTYLEBIT_AUTO == nFlags )
1176 {
1177 // automatic entry found -> select it
1178 aFilterLb.SelectEntryPos(i);
1179 // then call the handler to filter the styles
1180 FilterSelect( i - 1 );
1181 break;
1182 }
1183 }
1184 }
1185
1186 //-------------------------------------------------------------------------
1187
1188 // Hilfsfunktion: Zugriff auf aktuelles Family-Item
GetFamilyItem_Impl() const1189 const SfxStyleFamilyItem *SfxCommonTemplateDialog_Impl::GetFamilyItem_Impl() const
1190 {
1191 const sal_uInt16 nCount = pStyleFamilies->Count();
1192 for(sal_uInt16 i = 0; i < nCount; ++i)
1193 {
1194 const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject(i);
1195 // if(!pItem)continue;
1196 sal_uInt16 nId = SfxFamilyIdToNId(pItem->GetFamily());
1197 if(nId == nActFamily)
1198 return pItem;
1199 }
1200 return 0;
1201 }
1202
1203 //-------------------------------------------------------------------------
1204
SelectStyle(const String & rStr)1205 void SfxCommonTemplateDialog_Impl::SelectStyle(const String &rStr)
1206 {
1207 const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
1208 if ( !pItem )
1209 return;
1210 const SfxStyleFamily eFam = pItem->GetFamily();
1211 SfxStyleSheetBase* pStyle = pStyleSheetPool->Find( rStr, eFam, SFXSTYLEBIT_ALL );
1212 if( pStyle )
1213 EnableEdit( !(pStyle->GetMask() & SFXSTYLEBIT_READONLY) );
1214 else
1215 EnableEdit(sal_False);
1216
1217 if ( pTreeBox )
1218 {
1219 if ( rStr.Len() )
1220 {
1221 SvLBoxEntry* pEntry = pTreeBox->First();
1222 while ( pEntry )
1223 {
1224 if ( pTreeBox->GetEntryText( pEntry ) == rStr )
1225 {
1226 pTreeBox->MakeVisible( pEntry );
1227 pTreeBox->Select( pEntry );
1228 return;
1229 }
1230 pEntry = pTreeBox->Next( pEntry );
1231 }
1232 }
1233 else
1234 pTreeBox->SelectAll( sal_False );
1235 }
1236 else
1237 {
1238 sal_Bool bSelect = ( rStr.Len() > 0 );
1239 if ( bSelect )
1240 {
1241 SvLBoxEntry* pEntry = (SvLBoxEntry*)aFmtLb.FirstVisible();
1242 while ( pEntry && aFmtLb.GetEntryText( pEntry ) != rStr )
1243 pEntry = (SvLBoxEntry*)aFmtLb.NextVisible( pEntry );
1244 if ( !pEntry )
1245 bSelect = sal_False;
1246 else
1247 {
1248 aFmtLb.MakeVisible( pEntry );
1249 aFmtLb.Select( pEntry );
1250 bWaterDisabled = !HasSelectedStyle(); //added by BerryJia for fixing Bug76391 2003-1-22
1251 FmtSelectHdl( NULL );
1252 }
1253 }
1254
1255 if ( !bSelect )
1256 {
1257 aFmtLb.SelectAll( sal_False );
1258 EnableEdit(sal_False);
1259 }
1260 }
1261 }
1262
1263 //-------------------------------------------------------------------------
1264
GetSelectedEntry() const1265 String SfxCommonTemplateDialog_Impl::GetSelectedEntry() const
1266 {
1267 String aRet;
1268 if ( pTreeBox )
1269 {
1270 SvLBoxEntry* pEntry = pTreeBox->FirstSelected();
1271 if ( pEntry )
1272 aRet = pTreeBox->GetEntryText( pEntry );
1273 }
1274 else
1275 {
1276 SvLBoxEntry* pEntry = aFmtLb.FirstSelected();
1277 if ( pEntry )
1278 aRet = aFmtLb.GetEntryText( pEntry );
1279 }
1280 return aRet;
1281 }
1282
1283 //-------------------------------------------------------------------------
1284
EnableTreeDrag(sal_Bool bEnable)1285 void SfxCommonTemplateDialog_Impl::EnableTreeDrag( sal_Bool bEnable )
1286 {
1287 if ( pStyleSheetPool )
1288 {
1289 SfxStyleSheetBase* pStyle = pStyleSheetPool->First();
1290 if ( pTreeBox )
1291 {
1292 if ( pStyle && pStyle->HasParentSupport() && bEnable )
1293 pTreeBox->SetDragDropMode(SV_DRAGDROP_CTRL_MOVE);
1294 else
1295 pTreeBox->SetDragDropMode(SV_DRAGDROP_NONE);
1296 }
1297 }
1298 bTreeDrag = bEnable;
1299 }
1300
1301 //-------------------------------------------------------------------------
1302
FillTreeBox()1303 void SfxCommonTemplateDialog_Impl::FillTreeBox()
1304 {
1305 DBG_ASSERT( pTreeBox, "FillTreeBox() without treebox");
1306 if(pStyleSheetPool && nActFamily != SFX_TEMPLDLG_FILTER_MAX)
1307 {
1308 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
1309 pStyleSheetPool->SetSearchMask(pItem->GetFamily(), SFXSTYLEBIT_ALL);
1310 StyleTreeArr_Impl aArr;
1311 SfxStyleSheetBase *pStyle = pStyleSheetPool->First();
1312 if(pStyle && pStyle->HasParentSupport() && bTreeDrag )
1313 pTreeBox->SetDragDropMode(SV_DRAGDROP_CTRL_MOVE);
1314 else
1315 pTreeBox->SetDragDropMode(SV_DRAGDROP_NONE);
1316 while(pStyle)
1317 {
1318 StyleTree_ImplPtr pNew =
1319 new StyleTree_Impl(pStyle->GetName(), pStyle->GetParent());
1320 aArr.Insert(pNew, aArr.Count());
1321 pStyle = pStyleSheetPool->Next();
1322 }
1323 MakeTree_Impl(aArr);
1324 ExpandedEntries aEntries;
1325 if(pTreeBox)
1326 ((const StyleTreeListBox_Impl *)pTreeBox)->
1327 MakeExpanded_Impl( aEntries);
1328 pTreeBox->SetUpdateMode( sal_False );
1329 pTreeBox->Clear();
1330 const sal_uInt16 nCount = aArr.Count();
1331 for(sal_uInt16 i = 0; i < nCount; ++i)
1332 FillBox_Impl(pTreeBox, aArr[i], aEntries);
1333
1334 // EnableEdit(sal_False);
1335 EnableItem(SID_STYLE_WATERCAN,sal_False);
1336
1337 SfxTemplateItem* pState = pFamilyState[nActFamily-1];
1338
1339 if ( nCount )
1340 pTreeBox->Expand( pTreeBox->First() );
1341
1342 for ( SvLBoxEntry* pEntry = pTreeBox->First(); pEntry; pEntry = pTreeBox->Next( pEntry ) )
1343 {
1344 if ( IsExpanded_Impl( aEntries, pTreeBox->GetEntryText( pEntry ) ) )
1345 pTreeBox->Expand( pEntry );
1346 }
1347
1348 pTreeBox->SetUpdateMode( sal_True );
1349
1350 String aStyle;
1351 if(pState) //Aktuellen Eintrag selektieren
1352 aStyle = pState->GetStyleName();
1353 SelectStyle(aStyle);
1354 EnableDelete();
1355 }
1356 }
1357
1358 //-------------------------------------------------------------------------
HasSelectedStyle() const1359 sal_Bool SfxCommonTemplateDialog_Impl::HasSelectedStyle() const
1360 {
1361 return pTreeBox? pTreeBox->FirstSelected() != 0:
1362 aFmtLb.GetSelectionCount() != 0;
1363 }
1364
1365
1366 //-------------------------------------------------------------------------
1367
1368 // intern: Aktualisierung der Anzeige
UpdateStyles_Impl(sal_uInt16 nFlags)1369 void SfxCommonTemplateDialog_Impl::UpdateStyles_Impl(sal_uInt16 nFlags) // Flags, was aktualisiert werden soll (s.o.)
1370 {
1371 DBG_ASSERT(nFlags, "nichts zu tun");
1372 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
1373 if (!pItem)
1374 {
1375 // Ist beim Vorlagenkatalog der Fall
1376 SfxTemplateItem **ppItem = pFamilyState;
1377 const sal_uInt16 nFamilyCount = pStyleFamilies->Count();
1378 sal_uInt16 n;
1379 for(n=0;n<nFamilyCount;n++)
1380 if(ppItem[StyleNrToInfoOffset(n)])break;
1381 if ( n == nFamilyCount )
1382 // passiert gelegentlich bei Beichten, Formularen etc.; weiss der Teufel warum
1383 return;
1384 ppItem+=StyleNrToInfoOffset(n);
1385 nAppFilter = (*ppItem)->GetValue();
1386 FamilySelect( StyleNrToInfoOffset(n)+1 );
1387 pItem = GetFamilyItem_Impl();
1388 }
1389
1390 const SfxStyleFamily eFam = pItem->GetFamily();
1391
1392 SfxFilterTupel *pT = pItem->GetFilterList().GetObject(nActFilter);
1393 sal_uInt16 nFilter = pT ? pItem->GetFilterList().GetObject(nActFilter)->nFlags : 0;
1394 if(!nFilter) // automatisch
1395 nFilter = nAppFilter;
1396
1397 DBG_ASSERT(pStyleSheetPool, "kein StyleSheetPool");
1398 if(pStyleSheetPool)
1399 {
1400 pStyleSheetPool->SetSearchMask(eFam, nFilter);
1401 pItem = GetFamilyItem_Impl();
1402 if((nFlags & UPDATE_FAMILY) == UPDATE_FAMILY)
1403 {
1404 CheckItem(nActFamily, sal_True); // Button in Toolbox checken
1405 aFilterLb.SetUpdateMode(sal_False);
1406 aFilterLb.Clear();
1407 //insert hierarchical at the beginning
1408 sal_uInt16 nPos = aFilterLb.InsertEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)), 0);
1409 aFilterLb.SetEntryData( nPos, (void*)(sal_uIntPtr)SFXSTYLEBIT_ALL );
1410 const SfxStyleFilter& rFilter = pItem->GetFilterList();
1411 for(sal_uInt16 i = 0; i < rFilter.Count(); ++i)
1412 {
1413 sal_uIntPtr nFilterFlags = rFilter.GetObject(i)->nFlags;
1414 nPos = aFilterLb.InsertEntry( rFilter.GetObject(i)->aName );
1415 aFilterLb.SetEntryData( nPos, (void*)nFilterFlags );
1416 }
1417 if(nActFilter < aFilterLb.GetEntryCount() - 1)
1418 aFilterLb.SelectEntryPos(nActFilter + 1);
1419 else
1420 {
1421 nActFilter = 0;
1422 aFilterLb.SelectEntryPos(1);
1423 SfxFilterTupel *pActT = rFilter.GetObject(nActFilter);
1424 sal_uInt16 nFilterFlags = pActT ? rFilter.GetObject(nActFilter)->nFlags : 0;
1425 pStyleSheetPool->SetSearchMask(eFam, nFilterFlags);
1426 }
1427
1428 //Falls in Treedarstellung wieder Family Hierarchie selektieren
1429 if(pTreeBox)
1430 aFilterLb.SelectEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)));
1431
1432 // show maximum 12 entries
1433 aFilterLb.SetDropDownLineCount( MAX_FILTER_ENTRIES );
1434 aFilterLb.SetUpdateMode(sal_True);
1435 }
1436 else
1437 {
1438 if( nActFilter < aFilterLb.GetEntryCount() - 1)
1439 aFilterLb.SelectEntryPos(nActFilter + 1);
1440 else
1441 {
1442 nActFilter = 0;
1443 aFilterLb.SelectEntryPos(1);
1444 }
1445 }
1446
1447 if(nFlags & UPDATE_FAMILY_LIST)
1448 {
1449 // EnableEdit(sal_False);
1450 EnableItem(SID_STYLE_WATERCAN,sal_False);
1451
1452 SfxStyleSheetBase *pStyle = pStyleSheetPool->First();
1453 SvLBoxEntry* pEntry = aFmtLb.First();
1454 SvStringsDtor aStrings;
1455
1456 while( pStyle )
1457 {
1458 //Bubblesort
1459 for( sal_uInt16 nPos = aStrings.Count() + 1 ; nPos-- ;)
1460 {
1461 if( !nPos || *aStrings[nPos-1] < pStyle->GetName() )
1462 {
1463 // Die Namen stehen in den Styles, also nicht kopieren
1464 // Reingefallen!: Writer hat insgesamt nur 1 Style
1465 aStrings.Insert(
1466 new String( pStyle->GetName() ), nPos );
1467 break;
1468 }
1469 }
1470 pStyle = pStyleSheetPool->Next();
1471 }
1472
1473
1474 sal_uInt16 nCount = aStrings.Count();
1475 sal_uInt16 nPos = 0;
1476 while( nPos < nCount && pEntry &&
1477 *aStrings[ nPos ] == aFmtLb.GetEntryText( pEntry ) )
1478 {
1479 nPos++;
1480 pEntry = aFmtLb.Next( pEntry );
1481 }
1482
1483 if( nPos < nCount || pEntry )
1484 {
1485 // Box mit den Vorlagen fuellen
1486 aFmtLb.SetUpdateMode(sal_False);
1487 aFmtLb.Clear();
1488
1489 nPos = 0;
1490 while( nPos < nCount )
1491 aFmtLb.InsertEntry( *aStrings.GetObject( nPos++ ));
1492 aFmtLb.SetUpdateMode(sal_True);
1493 }
1494 // aktuelle Vorlage anzeigen
1495 SfxTemplateItem *pState = pFamilyState[nActFamily-1];
1496 String aStyle;
1497 if(pState) //Aktuellen Eintrag selektieren
1498 aStyle = pState->GetStyleName();
1499 SelectStyle(aStyle);
1500 EnableDelete();
1501 }
1502 }
1503 }
1504
1505 //-------------------------------------------------------------------------
1506
1507 // Aktualisierung Anzeige: Gie\skanne an/aus
SetWaterCanState(const SfxBoolItem * pItem)1508 void SfxCommonTemplateDialog_Impl::SetWaterCanState(const SfxBoolItem *pItem)
1509 {
1510 // EnableItem(SID_STYLE_WATERCAN, pItem != 0);
1511 bWaterDisabled = pItem == 0;
1512 //added by BerryJia for fixing Bug76391 2003-1-7
1513 if(!bWaterDisabled)
1514 bWaterDisabled = !HasSelectedStyle();
1515
1516 if(pItem && !bWaterDisabled)
1517 {
1518 CheckItem(SID_STYLE_WATERCAN, pItem->GetValue());
1519 EnableItem( SID_STYLE_WATERCAN, sal_True );
1520 }
1521 else
1522 if(!bWaterDisabled)
1523 EnableItem(SID_STYLE_WATERCAN, sal_True);
1524 else
1525 EnableItem(SID_STYLE_WATERCAN, sal_False);
1526
1527 //Waehrend Giesskannenmodus Statusupdates ignorieren.
1528
1529 sal_uInt16 nCount=pStyleFamilies->Count();
1530 pBindings->EnterRegistrations();
1531 for(sal_uInt16 n=0; n<nCount; n++)
1532 {
1533 SfxControllerItem *pCItem=pBoundItems[n];
1534 sal_Bool bChecked = pItem && pItem->GetValue();
1535 if( pCItem->IsBound() == bChecked )
1536 {
1537 if( !bChecked )
1538 pCItem->ReBind();
1539 else
1540 pCItem->UnBind();
1541 }
1542 }
1543 pBindings->LeaveRegistrations();
1544 }
1545
1546 //-------------------------------------------------------------------------
1547
1548 // Item mit dem Status einer Family wird kopiert und gemerkt
1549 // (Aktualisierung erfolgt, wenn alle Stati aktualisiert worden sind.
1550 // Siehe auch: <SfxBindings::AddDoneHdl(const Link &)>
1551
SetFamilyState(sal_uInt16 nSlotId,const SfxTemplateItem * pItem)1552 void SfxCommonTemplateDialog_Impl::SetFamilyState( sal_uInt16 nSlotId, const SfxTemplateItem* pItem )
1553 {
1554 sal_uInt16 nIdx = nSlotId - SID_STYLE_FAMILY_START;
1555 DELETEZ(pFamilyState[nIdx]);
1556 if ( pItem )
1557 pFamilyState[nIdx] = new SfxTemplateItem(*pItem);
1558 bUpdate = sal_True;
1559
1560 // Wenn verwendete Vorlagen ( wie zum Teufel findet man das heraus ?? )
1561 bUpdateFamily = sal_True;
1562 }
1563
1564 //-------------------------------------------------------------------------
1565
1566 // Benachrichtigung durch SfxBindings, da"s die Aktualisierung
1567 // beendet ist. St"o\st die Aktualisierung der Anzeige an.
1568
Update_Impl()1569 void SfxCommonTemplateDialog_Impl::Update_Impl()
1570 {
1571 sal_Bool bDocChanged=sal_False;
1572 SfxStyleSheetBasePool* pNewPool = NULL;
1573 SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1574 SfxObjectShell* pDocShell = pViewFrame->GetObjectShell();
1575 if( pDocShell )
1576 pNewPool = pDocShell->GetStyleSheetPool();
1577
1578 if ( pNewPool != pStyleSheetPool && pDocShell )
1579 {
1580 SfxModule* pNewModule = pDocShell->GetModule();
1581 if( pNewModule && pNewModule != pModule )
1582 {
1583 ClearResource();
1584 ReadResource();
1585 }
1586 if ( pStyleSheetPool )
1587 {
1588 EndListening(*pStyleSheetPool);
1589 pStyleSheetPool = 0;
1590 }
1591
1592 if ( pNewPool )
1593 {
1594 StartListening(*pNewPool);
1595 pStyleSheetPool = pNewPool;
1596 bDocChanged=sal_True;
1597 }
1598 // InvalidateBindings();
1599 }
1600
1601 if (bUpdateFamily)
1602 UpdateFamily_Impl();
1603
1604 sal_uInt16 i;
1605 for(i = 0; i < MAX_FAMILIES; ++i)
1606 if(pFamilyState[i])
1607 break;
1608 if(i == MAX_FAMILIES || !pNewPool)
1609 // nichts erlaubt
1610 return;
1611
1612 SfxTemplateItem *pItem = 0;
1613 // aktueller Bereich nicht innerhalb der erlaubten Bereiche
1614 // oder Default
1615 if(nActFamily == SFX_TEMPLDLG_FILTER_MAX || 0 == (pItem = pFamilyState[nActFamily-1] ) )
1616 {
1617 CheckItem(nActFamily, sal_False);
1618 SfxTemplateItem **ppItem = pFamilyState;
1619 const sal_uInt16 nFamilyCount = pStyleFamilies->Count();
1620 sal_uInt16 n;
1621 for(n=0;n<nFamilyCount;n++)
1622 if(ppItem[StyleNrToInfoOffset(n)])break;
1623 ppItem+=StyleNrToInfoOffset(n);
1624
1625 nAppFilter = (*ppItem)->GetValue();
1626 FamilySelect( StyleNrToInfoOffset(n)+1 );
1627
1628 pItem = *ppItem;
1629 }
1630 else if( bDocChanged )
1631 {
1632 // andere DocShell -> alles neu
1633 CheckItem( nActFamily, sal_True );
1634 nActFilter = static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pDocShell ) );
1635 if ( SFX_TEMPLDLG_FILTER_MAX == nActFilter )
1636 nActFilter = pDocShell->GetAutoStyleFilterIndex();
1637
1638 nAppFilter = pItem->GetValue();
1639 if(!pTreeBox)
1640 {
1641 UpdateStyles_Impl(UPDATE_FAMILY_LIST);
1642 }
1643 else
1644 FillTreeBox();
1645 }
1646 else
1647 {
1648 // anderer Filter fuer automatisch
1649 CheckItem( nActFamily, sal_True );
1650 const SfxStyleFamilyItem *pStyleItem = GetFamilyItem_Impl();
1651 if(0 == pStyleItem->GetFilterList().GetObject(nActFilter)->nFlags
1652 && nAppFilter != pItem->GetValue())
1653 {
1654 nAppFilter = pItem->GetValue();
1655 if(!pTreeBox)
1656 UpdateStyles_Impl(UPDATE_FAMILY_LIST);
1657 else
1658 FillTreeBox();
1659 }
1660 else
1661 nAppFilter = pItem->GetValue();
1662 }
1663 const String aStyle(pItem->GetStyleName());
1664 SelectStyle(aStyle);
1665 EnableDelete();
1666 EnableNew( bCanNew );
1667 }
1668
1669 //-------------------------------------------------------------------------
1670
IMPL_LINK(SfxCommonTemplateDialog_Impl,TimeOut,Timer *,pTim)1671 IMPL_LINK( SfxCommonTemplateDialog_Impl, TimeOut, Timer *, pTim )
1672 {
1673 (void)pTim; // unused
1674 if(!bDontUpdate)
1675 {
1676 bDontUpdate=sal_True;
1677 if(!pTreeBox)
1678 UpdateStyles_Impl(UPDATE_FAMILY_LIST);
1679 else
1680 {
1681 FillTreeBox();
1682 SfxTemplateItem *pState = pFamilyState[nActFamily-1];
1683 if(pState)
1684 {
1685 const String aStyle(pState->GetStyleName());
1686 SelectStyle(aStyle);
1687 EnableDelete();
1688 }
1689 }
1690 bDontUpdate=sal_False;
1691 DELETEZ(pTimer);
1692 }
1693 else
1694 pTimer->Start();
1695 return 0;
1696 }
1697
1698
1699 //-------------------------------------------------------------------------
Notify(SfxBroadcaster &,const SfxHint & rHint)1700 void SfxCommonTemplateDialog_Impl::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
1701 {
1702 // Aktualisierung anstossen
1703 if(rHint.Type() == TYPE(SfxSimpleHint))
1704 {
1705 switch(((SfxSimpleHint&) rHint ).GetId())
1706 {
1707 case SFX_HINT_UPDATEDONE:
1708 {
1709 SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1710 SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
1711 if (
1712 bUpdate &&
1713 (
1714 !IsCheckedItem(SID_STYLE_WATERCAN) ||
1715 (pDocShell && pDocShell->GetStyleSheetPool() != pStyleSheetPool)
1716 )
1717 )
1718 {
1719 bUpdate = sal_False;
1720 Update_Impl();
1721 }
1722 else if ( bUpdateFamily )
1723 {
1724 UpdateFamily_Impl();
1725 }
1726
1727 if( pStyleSheetPool )
1728 {
1729 String aStr = GetSelectedEntry();
1730 if( aStr.Len() && pStyleSheetPool )
1731 {
1732 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
1733 if( !pItem ) break;
1734 const SfxStyleFamily eFam = pItem->GetFamily();
1735 SfxStyleSheetBase *pStyle =
1736 pStyleSheetPool->Find(
1737 aStr, eFam, SFXSTYLEBIT_ALL );
1738 if( pStyle )
1739 EnableEdit(
1740 !(pStyle->GetMask() & SFXSTYLEBIT_READONLY) );
1741 else
1742 EnableEdit(sal_False);
1743 }
1744 }
1745 break;
1746 }
1747 // noetig, wenn zwichen Dokumenten umgeschaltet wird,
1748 // aber in beiden Dokumenten die gleiche Vorlage gilt.
1749 // Nicht sofort Update_Impl rufen, fuer den Fall da\s eines
1750 // der Dokumente ein internes InPlaceObjekt ist!
1751 case SFX_HINT_DOCCHANGED:
1752 bUpdate = sal_True;
1753 break;
1754 case SFX_HINT_DYING:
1755 {
1756 EndListening(*pStyleSheetPool);
1757 pStyleSheetPool=0;
1758 break;
1759 }
1760 }
1761 }
1762
1763 // Timer nicht aufsetzen, wenn der StyleSheetPool in die Kiste geht, denn
1764 // es kann sein, da\s sich ein neuer erst anmeldet, nachdem der Timer
1765 // abgelaufen ist - macht sich schlecht in UpdateStyles_Impl() !
1766
1767 sal_uIntPtr nId = rHint.ISA(SfxSimpleHint) ? ( (SfxSimpleHint&)rHint ).GetId() : 0;
1768
1769 if(!bDontUpdate && nId != SFX_HINT_DYING &&
1770 (rHint.Type() == TYPE(SfxStyleSheetPoolHint)||
1771 rHint.Type() == TYPE(SfxStyleSheetHint) ||
1772 rHint.Type() == TYPE( SfxStyleSheetHintExtended )))
1773 {
1774 if(!pTimer)
1775 {
1776 pTimer=new Timer;
1777 pTimer->SetTimeout(500);
1778 pTimer->SetTimeoutHdl(LINK(this,SfxCommonTemplateDialog_Impl,TimeOut));
1779 }
1780 pTimer->Start();
1781
1782 }
1783 }
1784
1785
1786 //-------------------------------------------------------------------------
1787
1788 // Anderer Filter; kann durch den Benutzer umgeschaltet werden
1789 // oder als Folge von Neu oder Bearbeiten, wenn die aktuelle
1790 // Vorlage einem anderen Filter zugewiesen wurde.
FilterSelect(sal_uInt16 nEntry,sal_Bool bForce)1791 void SfxCommonTemplateDialog_Impl::FilterSelect(
1792 sal_uInt16 nEntry, // Idx des neuen Filters
1793 sal_Bool bForce ) // Aktualisierung erzwingen, auch wenn der neue Filter gleich dem aktuellen ist
1794 {
1795 if( nEntry != nActFilter || bForce )
1796 {
1797 nActFilter = nEntry;
1798 SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1799 SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
1800 if (pDocShell)
1801 {
1802 pDocShell->SetAutoStyleFilterIndex(nActFilter);
1803 SaveFactoryStyleFilter( pDocShell, nActFilter );
1804 }
1805
1806 SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
1807 pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): 0;
1808 if ( pOldStyleSheetPool != pStyleSheetPool )
1809 {
1810 if ( pOldStyleSheetPool )
1811 EndListening(*pOldStyleSheetPool);
1812 if ( pStyleSheetPool )
1813 StartListening(*pOldStyleSheetPool);
1814 }
1815
1816 UpdateStyles_Impl(UPDATE_FAMILY_LIST);
1817 }
1818 }
1819
1820 //-------------------------------------------------------------------------
1821
1822 // Intern: Ausf"uhren von Funktionen "uber den Dispatcher
Execute_Impl(sal_uInt16 nId,const String & rStr,const String & rRefStr,sal_uInt16 nFamily,sal_uInt16 nMask,sal_uInt16 * pIdx,const sal_uInt16 * pModifier)1823 sal_Bool SfxCommonTemplateDialog_Impl::Execute_Impl(
1824 sal_uInt16 nId, const String &rStr, const String& rRefStr, sal_uInt16 nFamily,
1825 sal_uInt16 nMask, sal_uInt16 *pIdx, const sal_uInt16* pModifier)
1826 {
1827 SfxDispatcher &rDispatcher = *SFX_APP()->GetDispatcher_Impl();
1828 SfxStringItem aItem(nId, rStr);
1829 SfxUInt16Item aFamily(SID_STYLE_FAMILY, nFamily);
1830 SfxUInt16Item aMask( SID_STYLE_MASK, nMask );
1831 SfxStringItem aUpdName(SID_STYLE_UPD_BY_EX_NAME, rStr);
1832 SfxStringItem aRefName( SID_STYLE_REFERENCE, rRefStr );
1833 const SfxPoolItem* pItems[ 6 ];
1834 sal_uInt16 nCount = 0;
1835 if( rStr.Len() )
1836 pItems[ nCount++ ] = &aItem;
1837 pItems[ nCount++ ] = &aFamily;
1838 if( nMask )
1839 pItems[ nCount++ ] = &aMask;
1840 if(SID_STYLE_UPDATE_BY_EXAMPLE == nId)
1841 {
1842 //Sonderloesung fuer Numerierungsupdate im Writer
1843 const String aTemplName(GetSelectedEntry());
1844 aUpdName.SetValue(aTemplName);
1845 pItems[ nCount++ ] = &aUpdName;
1846 }
1847 if ( rRefStr.Len() )
1848 pItems[ nCount++ ] = &aRefName;
1849
1850 pItems[ nCount++ ] = 0;
1851
1852 // This unbelievably crude technique is used to detect and handle
1853 // destruction of this during the synchronous slot call: store a
1854 // pointer to a local bool, initialize it to false and set that it
1855 // to true in the destructor.
1856 Deleted aDeleted;
1857 pbDeleted = &aDeleted;
1858
1859 sal_uInt16 nModi = pModifier ? *pModifier : 0;
1860 const SfxPoolItem* pItem = rDispatcher.Execute(
1861 nId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD | SFX_CALLMODE_MODAL,
1862 pItems, nModi );
1863
1864 // FIXME: Dialog can be destroyed while in Execute() check stack variable for dtor flag!
1865 if (aDeleted())
1866 {
1867 // this has been deleted in the previous synchronous slot
1868 // call. Exit without touching anything.
1869 return sal_False;
1870 }
1871 else
1872 {
1873 // this has not been deleted. Reset pbDeleted to prevent the
1874 // destructor to access the local bool at a later and rather
1875 // inconvenient time. See bugs 124392 and 100110 for more information.
1876 pbDeleted = NULL;
1877 }
1878 if (pItem == NULL)
1879 {
1880 return sal_False;
1881 }
1882
1883 if ( nId == SID_STYLE_NEW || SID_STYLE_EDIT == nId )
1884 {
1885 SfxUInt16Item *pFilterItem = PTR_CAST(SfxUInt16Item, pItem);
1886 DBG_ASSERT(pFilterItem, "SfxUINT16Item erwartet");
1887 sal_uInt16 nFilterFlags = pFilterItem->GetValue() & ~SFXSTYLEBIT_USERDEF;
1888 if(!nFilterFlags) // Benutzervorlage?
1889 nFilterFlags = pFilterItem->GetValue();
1890 const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
1891 const sal_uInt16 nFilterCount = (sal_uInt16) pFamilyItem->GetFilterList().Count();
1892
1893 for ( sal_uInt16 i = 0; i < nFilterCount; ++i )
1894 {
1895 const SfxFilterTupel *pTupel =
1896 pFamilyItem->GetFilterList().GetObject(i);
1897
1898 if ( ( pTupel->nFlags & nFilterFlags ) == nFilterFlags && pIdx )
1899 *pIdx = i;
1900 }
1901 }
1902
1903 return sal_True;
1904 }
1905
1906 //-------------------------------------------------------------------------
1907
1908 // Handler der Listbox der Filter
IMPL_LINK(SfxCommonTemplateDialog_Impl,FilterSelectHdl,ListBox *,pBox)1909 IMPL_LINK( SfxCommonTemplateDialog_Impl, FilterSelectHdl, ListBox *, pBox )
1910 {
1911 if ( pBox->GetSelectEntry() == String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)) )
1912 {
1913 if ( !bHierarchical )
1914 {
1915 // TreeView einschalten
1916 bHierarchical=sal_True;
1917 const String aSelectEntry( GetSelectedEntry());
1918 aFmtLb.Hide();
1919 // aFilterLb.Disable();
1920
1921 pTreeBox = new StyleTreeListBox_Impl(
1922 this, WB_HASBUTTONS | WB_HASLINES |
1923 WB_BORDER | WB_TABSTOP | WB_HASLINESATROOT |
1924 WB_HASBUTTONSATROOT | WB_HIDESELECTION | WB_QUICK_SEARCH );
1925 pTreeBox->SetFont( aFmtLb.GetFont() );
1926
1927 pTreeBox->SetPosSizePixel(aFmtLb.GetPosPixel(), aFmtLb.GetSizePixel());
1928 pTreeBox->SetNodeDefaultImages();
1929 pTreeBox->SetSelectHdl(
1930 LINK(this, SfxCommonTemplateDialog_Impl, FmtSelectHdl));
1931 ((StyleTreeListBox_Impl*)pTreeBox)->
1932 SetDoubleClickHdl(
1933 LINK(this, SfxCommonTemplateDialog_Impl, ApplyHdl));
1934 ((StyleTreeListBox_Impl*)pTreeBox)->
1935 SetDropHdl(LINK(this, SfxCommonTemplateDialog_Impl, DropHdl));
1936 pTreeBox->SetIndent(10);
1937
1938 FillTreeBox();
1939 SelectStyle(aSelectEntry);
1940 pTreeBox->SetAccessibleName(SfxResId(STR_STYLE_ELEMTLIST));
1941 pTreeBox->Show();
1942
1943 // Save the filter state
1944 SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1945 SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
1946 if (pDocShell)
1947 {
1948 // only in the configuration
1949 // SetAutoStyleFilterIndex would update nActFilter
1950 // which should only contain a valid listbox entry
1951 SaveFactoryStyleFilter( pDocShell, SFX_TEMPLDLG_FILTER_HIERARCHICAL );
1952 }
1953 }
1954 }
1955
1956 else
1957 {
1958 DELETEZ(pTreeBox);
1959 aFmtLb.Show();
1960 // aFilterLb.Enable();
1961 // Falls bHierarchical, kann sich die Familie geaendert haben
1962 // minus one since hierarchical is inserted at the start
1963 FilterSelect(pBox->GetSelectEntryPos() - 1, bHierarchical );
1964 bHierarchical=sal_False;
1965 // UpdateStyles_Impl(UPDATE_FAMILY_LIST); // Anzeige aktualisieren
1966 }
1967
1968 return 0;
1969 }
1970
1971 //-------------------------------------------------------------------------
1972
1973 // Select-Handler der Toolbox
FamilySelect(sal_uInt16 nEntry)1974 void SfxCommonTemplateDialog_Impl::FamilySelect(sal_uInt16 nEntry)
1975 {
1976 if( nEntry != nActFamily )
1977 {
1978 CheckItem( nActFamily, sal_False );
1979 nActFamily = nEntry;
1980 SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
1981 SfxUInt16Item aItem( SID_STYLE_FAMILY, nEntry );
1982 pDispat->Execute( SID_STYLE_FAMILY, SFX_CALLMODE_SYNCHRON, &aItem, 0L );
1983 pBindings->Invalidate( SID_STYLE_FAMILY );
1984 pBindings->Update( SID_STYLE_FAMILY );
1985 UpdateFamily_Impl();
1986 }
1987 }
1988
1989 //-------------------------------------------------------------------------
1990
ActionSelect(sal_uInt16 nEntry)1991 void SfxCommonTemplateDialog_Impl::ActionSelect(sal_uInt16 nEntry)
1992 {
1993 String aEmpty;
1994 switch(nEntry)
1995 {
1996 case SID_STYLE_WATERCAN:
1997 {
1998 const sal_Bool bState = IsCheckedItem(nEntry);
1999 sal_Bool bCheck;
2000 SfxBoolItem aBool;
2001 // wenn eine Vorlage ausgewaehlt ist.
2002 if(!bState && aFmtLb.GetSelectionCount())
2003 {
2004 const String aTemplName(
2005 GetSelectedEntry());
2006 Execute_Impl(
2007 SID_STYLE_WATERCAN, aTemplName, aEmpty,
2008 (sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
2009 bCheck = sal_True;
2010 }
2011 else
2012 {
2013 Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
2014 bCheck = sal_False;
2015 }
2016 CheckItem(nEntry, bCheck);
2017 aBool.SetValue(bCheck);
2018 SetWaterCanState(&aBool);
2019 break;
2020 }
2021 case SID_STYLE_NEW_BY_EXAMPLE:
2022 {
2023 if(pStyleSheetPool && nActFamily != SFX_TEMPLDLG_FILTER_MAX)
2024 {
2025 const SfxStyleFamily eFam=GetFamilyItem_Impl()->GetFamily();
2026 //pStyleSheetPool->GetSearchFamily();
2027 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
2028 sal_uInt16 nFilter;
2029 if(pItem&&nActFilter!=SFX_TEMPLDLG_FILTER_MAX)
2030 {
2031 nFilter = pItem->GetFilterList().GetObject(
2032 nActFilter)->nFlags;
2033 if(!nFilter) // automatisch
2034 nFilter = nAppFilter;
2035 }
2036 else
2037 nFilter=pStyleSheetPool->GetSearchMask();
2038 pStyleSheetPool->SetSearchMask( eFam, SFXSTYLEBIT_USERDEF );
2039
2040 SfxNewStyleDlg *pDlg =
2041 // why? : FloatingWindow must not be parent of a modal dialog
2042 new SfxNewStyleDlg(pWindow, *pStyleSheetPool);
2043 if(RET_OK == pDlg->Execute())
2044 {
2045 pStyleSheetPool->SetSearchMask(eFam, nFilter);
2046 const String aTemplName(pDlg->GetName());
2047 Execute_Impl(SID_STYLE_NEW_BY_EXAMPLE,
2048 aTemplName, aEmpty,
2049 (sal_uInt16)GetFamilyItem_Impl()->GetFamily(),
2050 nFilter);
2051 }
2052 pStyleSheetPool->SetSearchMask( eFam, nFilter );
2053 delete pDlg;
2054 }
2055 break;
2056 }
2057 case SID_STYLE_UPDATE_BY_EXAMPLE:
2058 {
2059 Execute_Impl(SID_STYLE_UPDATE_BY_EXAMPLE,
2060 aEmpty, aEmpty,
2061 (sal_uInt16)GetFamilyItem_Impl()->GetFamily());
2062 break;
2063 }
2064 case SID_TEMPLATE_LOAD:
2065 SFX_APP()->GetDispatcher_Impl()->Execute(nEntry);
2066 break;
2067 default: DBG_ERROR("not implemented"); break;
2068 }
2069 }
2070
2071 //-------------------------------------------------------------------------
2072
getModuleIdentifier(const Reference<XModuleManager> & i_xModMgr,SfxObjectShell * i_pObjSh)2073 static rtl::OUString getModuleIdentifier( const Reference< XModuleManager >& i_xModMgr, SfxObjectShell* i_pObjSh )
2074 {
2075 DBG_ASSERT( i_xModMgr.is(), "getModuleIdentifier(): no XModuleManager" );
2076 DBG_ASSERT( i_pObjSh, "getModuleIdentifier(): no ObjectShell" );
2077
2078 ::rtl::OUString sIdentifier;
2079
2080 try
2081 {
2082 sIdentifier = i_xModMgr->identify( i_pObjSh->GetModel() );
2083 }
2084 catch ( ::com::sun::star::frame::UnknownModuleException& )
2085 {
2086 DBG_WARNING( "getModuleIdentifier(): unknown module" );
2087 }
2088 catch ( Exception& )
2089 {
2090 DBG_ERRORFILE( "getModuleIdentifier(): exception of XModuleManager::identify()" );
2091 }
2092
2093 return sIdentifier;
2094 }
2095
2096 //-------------------------------------------------------------------------
2097
LoadFactoryStyleFilter(SfxObjectShell * i_pObjSh)2098 sal_Int32 SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter( SfxObjectShell* i_pObjSh )
2099 {
2100 DBG_ASSERT( i_pObjSh, "SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter(): no ObjectShell" );
2101 sal_Int32 nFilter = -1;
2102
2103 Sequence< PropertyValue > lProps;
2104 Reference< ::com::sun::star::container::XNameAccess > xContainer( xModuleManager, UNO_QUERY );
2105 if ( xContainer.is() )
2106 {
2107 ::comphelper::SequenceAsHashMap aFactoryProps(
2108 xContainer->getByName( getModuleIdentifier( xModuleManager, i_pObjSh ) ) );
2109 sal_Int32 nDefault = -1;
2110 nFilter = aFactoryProps.getUnpackedValueOrDefault( DEFINE_CONST_UNICODE("ooSetupFactoryStyleFilter"), nDefault );
2111 }
2112
2113 return nFilter;
2114 }
2115
2116 //-------------------------------------------------------------------------
2117
SaveFactoryStyleFilter(SfxObjectShell * i_pObjSh,sal_Int32 i_nFilter)2118 void SfxCommonTemplateDialog_Impl::SaveFactoryStyleFilter( SfxObjectShell* i_pObjSh, sal_Int32 i_nFilter )
2119 {
2120 DBG_ASSERT( i_pObjSh, "SfxCommonTemplateDialog_Impl::SaveFactoryStyleFilter(): no ObjectShell" );
2121 Reference< ::com::sun::star::container::XNameReplace > xContainer( xModuleManager, UNO_QUERY );
2122 if ( xContainer.is() )
2123 {
2124 Sequence< PropertyValue > lProps(1);
2125 lProps[0].Name = DEFINE_CONST_UNICODE("ooSetupFactoryStyleFilter");
2126 lProps[0].Value = makeAny( i_nFilter );;
2127 xContainer->replaceByName( getModuleIdentifier( xModuleManager, i_pObjSh ), makeAny( lProps ) );
2128 }
2129 }
2130
2131 //-------------------------------------------------------------------------
2132
IMPL_LINK(SfxCommonTemplateDialog_Impl,DropHdl,StyleTreeListBox_Impl *,pBox)2133 IMPL_LINK( SfxCommonTemplateDialog_Impl, DropHdl, StyleTreeListBox_Impl *, pBox )
2134 {
2135 bDontUpdate=sal_True;
2136 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
2137 const SfxStyleFamily eFam = pItem->GetFamily();
2138 long ret= pStyleSheetPool->SetParent(eFam,pBox->GetStyle(), pBox->GetParent())? 1L: 0L;
2139 bDontUpdate=sal_False;
2140 return ret;
2141 }
2142
2143 //-------------------------------------------------------------------------
2144
2145 // Handler des Neu-Buttons
NewHdl(void *)2146 void SfxCommonTemplateDialog_Impl::NewHdl(void *)
2147 {
2148 String aEmpty;
2149 if ( nActFamily != SFX_TEMPLDLG_FILTER_MAX )
2150 {
2151 Window* pTmp;
2152 pTmp = Application::GetDefDialogParent();
2153 if ( ISA(SfxTemplateDialog_Impl) )
2154 Application::SetDefDialogParent( pWindow->GetParent() );
2155 else
2156 Application::SetDefDialogParent( pWindow );
2157
2158 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
2159 const SfxStyleFamily eFam=pItem->GetFamily();
2160 sal_uInt16 nMask;
2161 if(pItem&&nActFilter!=SFX_TEMPLDLG_FILTER_MAX)
2162 {
2163 nMask = pItem->GetFilterList().GetObject(
2164 nActFilter)->nFlags;
2165 if(!nMask) // automatisch
2166 nMask = nAppFilter;
2167 }
2168 else
2169 nMask=pStyleSheetPool->GetSearchMask();
2170
2171 pStyleSheetPool->SetSearchMask(eFam,nMask);
2172
2173 Execute_Impl(SID_STYLE_NEW,
2174 aEmpty, GetSelectedEntry(),
2175 ( sal_uInt16 )GetFamilyItem_Impl()->GetFamily(),
2176 nMask);
2177
2178 Application::SetDefDialogParent( pTmp );
2179
2180 /* {
2181 DBG_ASSERT(nFilter < aFilterLb.GetEntryCount(),
2182 "Filter ueberindiziert");
2183
2184 if(!pTreeBox)
2185 {
2186 // aFilterLb.SelectEntryPos(nFilter);
2187 FilterSelect(nActFilter, sal_True);
2188 }
2189 else
2190 {
2191 FillTreeBox();
2192 SfxTemplateItem *pState = pFamilyState[nActFamily-1];
2193 if(pState)
2194 {
2195 const String aStyle(pState->GetStyleName());
2196 SelectStyle(aStyle);
2197 }
2198 EnableDelete();
2199 }*/
2200 // }
2201 }
2202 }
2203
2204 //-------------------------------------------------------------------------
2205
2206 // Handler des Bearbeiten-Buttons
EditHdl(void *)2207 void SfxCommonTemplateDialog_Impl::EditHdl(void *)
2208 {
2209 if(IsInitialized() && HasSelectedStyle())
2210 {
2211 sal_uInt16 nFilter = nActFilter;
2212 String aTemplName(GetSelectedEntry());
2213 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
2214 const SfxStyleFamily eFam = pItem->GetFamily();
2215 pStyleSheetPool->Find(aTemplName,eFam,SFXSTYLEBIT_ALL); // -Wall required??
2216 Window* pTmp;
2217 //DefModalDialogParent setzen fuer
2218 //Modalitaet der nachfolgenden Dialoge
2219 pTmp = Application::GetDefDialogParent();
2220 if ( ISA(SfxTemplateDialog_Impl) )
2221 Application::SetDefDialogParent( pWindow->GetParent() );
2222 else
2223 Application::SetDefDialogParent( pWindow );
2224 if ( Execute_Impl( SID_STYLE_EDIT, aTemplName, String(),
2225 (sal_uInt16)GetFamilyItem_Impl()->GetFamily(), 0, &nFilter ) )
2226 {
2227 // DBG_ASSERT(nFilter < aFilterLb.GetEntryCount(), "Filter ueberindiziert");
2228 // aTemplName = pStyle->GetName();
2229 // kann durch Bearbeiten umbenannt worden sein
2230 /* if(!pTreeBox)
2231 {
2232 // aFilterLb.SelectEntryPos(nFilter);
2233 // FilterSelect(nFilter, sal_True);
2234 }
2235 else
2236 FillTreeBox();*/
2237 }
2238 Application::SetDefDialogParent( pTmp );
2239 }
2240 }
2241
2242 //-------------------------------------------------------------------------
2243
2244 // Handler des L"oschen-Buttons
DeleteHdl(void *)2245 void SfxCommonTemplateDialog_Impl::DeleteHdl(void *)
2246 {
2247 if ( IsInitialized() && HasSelectedStyle() )
2248 {
2249 const String aTemplName( GetSelectedEntry() );
2250 const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
2251 SfxStyleSheetBase* pStyle =
2252 pStyleSheetPool->Find( aTemplName, pItem->GetFamily(), SFXSTYLEBIT_ALL );
2253 if ( pStyle )
2254 {
2255 String aMsg;
2256 if ( pStyle->IsUsed() )
2257 aMsg = String( SfxResId( STR_DELETE_STYLE_USED ) );
2258 aMsg += String ( SfxResId( STR_DELETE_STYLE ) );
2259 aMsg.SearchAndReplaceAscii( "$1", aTemplName );
2260 #if defined UNX
2261 QueryBox aBox( SFX_APP()->GetTopWindow(), WB_YES_NO | WB_DEF_NO, aMsg );
2262 #else
2263 QueryBox aBox( GetWindow(), WB_YES_NO | WB_DEF_NO , aMsg );
2264 #endif
2265 if ( RET_YES == aBox.Execute() )
2266 {
2267 PrepareDeleteAction();
2268
2269 if ( pTreeBox ) // Damit die Treelistbox beim L"oschen nicht zuklappt
2270 {
2271 bDontUpdate = sal_True;
2272 }
2273 Execute_Impl( SID_STYLE_DELETE, aTemplName,
2274 String(), (sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
2275
2276 if ( pTreeBox )
2277 {
2278 pTreeBox->RemoveParentKeepChilds( pTreeBox->FirstSelected() );
2279 bDontUpdate = sal_False;
2280 }
2281 }
2282 }
2283 }
2284 }
2285
2286 //-------------------------------------------------------------------------
2287
EnableDelete()2288 void SfxCommonTemplateDialog_Impl::EnableDelete()
2289 {
2290 if(IsInitialized() && HasSelectedStyle())
2291 {
2292 DBG_ASSERT(pStyleSheetPool, "Kein StyleSheetPool");
2293 const String aTemplName(GetSelectedEntry());
2294 const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
2295 const SfxStyleFamily eFam = pItem->GetFamily();
2296 sal_uInt16 nFilter = 0;
2297 if(pItem->GetFilterList().Count() > nActFilter)
2298 nFilter = pItem->GetFilterList().GetObject(nActFilter)->nFlags;
2299 if(!nFilter) // automatisch
2300 nFilter = nAppFilter;
2301 const SfxStyleSheetBase *pStyle =
2302 pStyleSheetPool->Find(aTemplName,eFam,
2303 pTreeBox? SFXSTYLEBIT_ALL: nFilter);
2304 DBG_ASSERT(pStyle, "Style nicht gefunden");
2305 if(pStyle && pStyle->IsUserDefined())
2306 {
2307 EnableDel(sal_True);
2308 }
2309 else
2310 {
2311 EnableDel(sal_False);
2312 }
2313 }
2314 else
2315 {
2316 EnableDel(sal_False);
2317 }
2318 // rBindings.Invalidate( SID_STYLE_DELETE );
2319 // rBindings.Update( SID_STYLE_DELETE );
2320 }
2321
2322 //-------------------------------------------------------------------------
2323
2324 // nach Selektion eines Eintrags den Focus gfs. wieder auf das App-Fenster
2325 // setzen
ResetFocus()2326 void SfxCommonTemplateDialog_Impl::ResetFocus()
2327 {
2328 if(ISA(SfxTemplateDialog_Impl))
2329 {
2330 SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
2331 SfxViewShell *pVu = pViewFrame->GetViewShell();
2332 Window *pAppWin = pVu ? pVu->GetWindow(): 0;
2333 if(pAppWin)
2334 pAppWin->GrabFocus();
2335 }
2336 }
2337
2338 //-------------------------------------------------------------------------
2339
2340 // Doppelclick auf ein StyleSheet in der ListBox, wird angewendet.
IMPL_LINK(SfxCommonTemplateDialog_Impl,ApplyHdl,Control *,pControl)2341 IMPL_LINK( SfxCommonTemplateDialog_Impl, ApplyHdl, Control *, pControl )
2342 {
2343 (void)pControl; //unused
2344 // nur, wenn dieser Bereich erlaubt ist
2345 if ( IsInitialized() && 0 != pFamilyState[nActFamily-1] &&
2346 GetSelectedEntry().Len() )
2347 {
2348 sal_uInt16 nModifier = aFmtLb.GetModifier();
2349 Execute_Impl(SID_STYLE_APPLY,
2350 GetSelectedEntry(), String(),
2351 ( sal_uInt16 )GetFamilyItem_Impl()->GetFamily(),
2352 0, 0, &nModifier );
2353 if(ISA(SfxTemplateCatalog_Impl))
2354 ((SfxTemplateCatalog_Impl*) this)->pReal->EndDialog(RET_OK);
2355 }
2356 ResetFocus();
2357 return 0;
2358 }
2359
2360 //-------------------------------------------------------------------------
2361
2362 // Selektion einer Vorlage w"ahrend des Watercan-Status
IMPL_LINK(SfxCommonTemplateDialog_Impl,FmtSelectHdl,SvTreeListBox *,pListBox)2363 IMPL_LINK( SfxCommonTemplateDialog_Impl, FmtSelectHdl, SvTreeListBox *, pListBox )
2364 {
2365 // HilfePI antriggern, wenn von Call als Handler und Bereich erlaubt ist
2366 if( !pListBox || pListBox->IsSelected( pListBox->GetHdlEntry() ) )
2367 {
2368 // nur, wenn Giesskanne an ist
2369 if ( IsInitialized() &&
2370 IsCheckedItem(SID_STYLE_WATERCAN) &&
2371 // nur, wenn dieser Bereich erlaubt ist
2372 0 != pFamilyState[nActFamily-1] )
2373 {
2374 String aEmpty;
2375 Execute_Impl(SID_STYLE_WATERCAN,
2376 aEmpty, aEmpty, 0);
2377 Execute_Impl(SID_STYLE_WATERCAN,
2378 GetSelectedEntry(), aEmpty,
2379 ( sal_uInt16 )GetFamilyItem_Impl()->GetFamily());
2380 }
2381 // EnableEdit(sal_True);
2382 EnableItem(SID_STYLE_WATERCAN, !bWaterDisabled);
2383 EnableDelete();
2384 }
2385 if( pListBox )
2386 SelectStyle( pListBox->GetEntryText( pListBox->GetHdlEntry() ));
2387
2388 return 0;
2389 }
2390
2391 //-------------------------------------------------------------------------
2392
IMPL_LINK(SfxCommonTemplateDialog_Impl,MenuSelectHdl,Menu *,pMenu)2393 IMPL_LINK( SfxCommonTemplateDialog_Impl, MenuSelectHdl, Menu *, pMenu )
2394 {
2395 if( pMenu )
2396 {
2397 nLastItemId = pMenu->GetCurItemId();
2398 Application::PostUserEvent(
2399 LINK( this, SfxCommonTemplateDialog_Impl, MenuSelectHdl ), 0 );
2400 return sal_True;
2401 }
2402
2403 switch(nLastItemId) {
2404 case ID_NEW: NewHdl(0); break;
2405 case ID_EDIT: EditHdl(0); break;
2406 case ID_DELETE: DeleteHdl(0); break;
2407 default: return sal_False;
2408 }
2409 return sal_True;
2410 }
2411
2412 // -----------------------------------------------------------------------
2413
ExecuteContextMenu_Impl(const Point & rPos,Window * pWin)2414 void SfxCommonTemplateDialog_Impl::ExecuteContextMenu_Impl( const Point& rPos, Window* pWin )
2415 {
2416 // Bug# 94152: This part should never be called, because before this happens, the TreeListBox should captured this!
2417 DBG_ASSERT( sal_False, "+SfxCommonTemplateDialog_Impl::ExecuteContextMenu_Impl(): How could this happen? Please infirm developer ASAP!" );
2418
2419 PopupMenu* pMenu = CreateContextMenu();
2420 pMenu->Execute( pWin, rPos );
2421 delete pMenu;
2422 }
2423
2424 // -----------------------------------------------------------------------
2425
GetActualFamily() const2426 SfxStyleFamily SfxCommonTemplateDialog_Impl::GetActualFamily() const
2427 {
2428 const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
2429 if( !pFamilyItem || nActFamily == SFX_TEMPLDLG_FILTER_MAX )
2430 return SFX_STYLE_FAMILY_PARA;
2431 else
2432 return pFamilyItem->GetFamily();
2433 }
2434
2435 // -----------------------------------------------------------------------
2436
EnableExample_Impl(sal_uInt16 nId,sal_Bool bEnable)2437 void SfxCommonTemplateDialog_Impl::EnableExample_Impl(sal_uInt16 nId, sal_Bool bEnable)
2438 {
2439 if( nId == SID_STYLE_NEW_BY_EXAMPLE )
2440 bNewByExampleDisabled = !bEnable;
2441 else if( nId == SID_STYLE_UPDATE_BY_EXAMPLE )
2442 bUpdateByExampleDisabled = !bEnable;
2443 EnableItem(nId, bEnable);
2444 }
2445
PrepareDeleteAction()2446 void SfxCommonTemplateDialog_Impl::PrepareDeleteAction()
2447 {
2448 }
2449
2450 // -----------------------------------------------------------------------
2451
CreateContextMenu(void)2452 PopupMenu* SfxCommonTemplateDialog_Impl::CreateContextMenu( void )
2453 {
2454 if ( bBindingUpdate )
2455 {
2456 pBindings->Invalidate( SID_STYLE_NEW, sal_True, sal_False );
2457 pBindings->Update( SID_STYLE_NEW );
2458 bBindingUpdate = sal_False;
2459 }
2460 PopupMenu* pMenu = new PopupMenu( SfxResId( MN_CONTEXT_TEMPLDLG ) );
2461 pMenu->SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, MenuSelectHdl ) );
2462 pMenu->EnableItem( ID_EDIT, bCanEdit );
2463 pMenu->EnableItem( ID_DELETE, bCanDel );
2464 pMenu->EnableItem( ID_NEW, bCanNew );
2465
2466 return pMenu;
2467 }
2468
2469 // ------------------------------------------------------------------------
2470
2471
SfxTemplateDialog_Impl(SfxBindings * pB,SfxTemplateDialog * pDlgWindow)2472 SfxTemplateDialog_Impl::SfxTemplateDialog_Impl(
2473 SfxBindings* pB, SfxTemplateDialog* pDlgWindow ) :
2474
2475 SfxCommonTemplateDialog_Impl( pB, pDlgWindow, true ),
2476
2477 m_pFloat ( pDlgWindow ),
2478 m_bZoomIn ( sal_False ),
2479 m_aActionTbL ( pDlgWindow, this ),
2480 m_aActionTbR ( pDlgWindow, SfxResId( TB_ACTION ) )
2481
2482 {
2483 pDlgWindow->FreeResource();
2484 Initialize();
2485 }
2486
SfxTemplateDialog_Impl(SfxBindings * pB,SfxTemplatePanelControl * pDlgWindow)2487 SfxTemplateDialog_Impl::SfxTemplateDialog_Impl(
2488 SfxBindings* pB, SfxTemplatePanelControl* pDlgWindow )
2489 : SfxCommonTemplateDialog_Impl( pB, pDlgWindow, true ),
2490 m_pFloat ( pDlgWindow ),
2491 m_bZoomIn ( sal_False ),
2492 m_aActionTbL ( pDlgWindow, this ),
2493 m_aActionTbR ( pDlgWindow, SfxResId( TB_ACTION ) )
2494 {
2495 pDlgWindow->FreeResource();
2496 Initialize();
2497 }
2498
Initialize(void)2499 void SfxTemplateDialog_Impl::Initialize (void)
2500 {
2501 // Read the filter stored in the configuration
2502 // This is already done in ReadResource(), invoked by Initialize()
2503 // and stored in nActFilter, but we can't rely on nActFilter's value
2504 // because it is changed in UpdateStyles_Impl
2505 SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
2506 pCurObjShell = pViewFrame->GetObjectShell();
2507 const sal_uInt16 nConfigFilter = pCurObjShell ?
2508 static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pCurObjShell ) ) : 0;
2509
2510 SfxCommonTemplateDialog_Impl::Initialize();
2511
2512 m_aActionTbL.SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxLSelect));
2513 m_aActionTbR.SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxRSelect));
2514 m_aActionTbR.SetDropdownClickHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxRClick));
2515 m_aActionTbL.Show();
2516 m_aActionTbR.Show();
2517 Font aFont=aFilterLb.GetFont();
2518 aFont.SetWeight( WEIGHT_NORMAL );
2519 aFilterLb.SetFont( aFont );
2520 m_aActionTbL.SetHelpId( HID_TEMPLDLG_TOOLBOX_LEFT );
2521
2522 if ( nConfigFilter == SFX_TEMPLDLG_FILTER_HIERARCHICAL )
2523 {
2524 bHierarchical = sal_False;
2525 aFilterLb.SelectEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)));
2526 FilterSelectHdl(&aFilterLb);
2527 }
2528 }
2529
2530 // ------------------------------------------------------------------------
2531
EnableFamilyItem(sal_uInt16 nId,sal_Bool bEnable)2532 void SfxTemplateDialog_Impl::EnableFamilyItem( sal_uInt16 nId, sal_Bool bEnable )
2533 {
2534 m_aActionTbL.EnableItem( nId, bEnable );
2535 }
2536
2537 //-------------------------------------------------------------------------
2538
InsertFamilyItem(sal_uInt16 nId,const SfxStyleFamilyItem * pItem)2539 void SfxTemplateDialog_Impl::InsertFamilyItem(sal_uInt16 nId,const SfxStyleFamilyItem *pItem)
2540 {
2541 rtl::OString sHelpId;
2542 switch( (sal_uInt16) pItem->GetFamily() )
2543 {
2544 case SFX_STYLE_FAMILY_CHAR: sHelpId = ".uno:CharStyle"; break;
2545 case SFX_STYLE_FAMILY_PARA: sHelpId = ".uno:ParaStyle"; break;
2546 case SFX_STYLE_FAMILY_FRAME: sHelpId = ".uno:FrameStyle"; break;
2547 case SFX_STYLE_FAMILY_PAGE: sHelpId = ".uno:PageStyle"; break;
2548 case SFX_STYLE_FAMILY_PSEUDO: sHelpId = ".uno:ListStyle"; break;
2549 default: DBG_ERROR("unknown StyleFamily"); break;
2550 }
2551 m_aActionTbL.InsertItem( nId, pItem->GetImage(), pItem->GetText(), 0, 0);
2552 m_aActionTbL.SetHelpId( nId, sHelpId );
2553 }
2554
2555 // ------------------------------------------------------------------------
2556
ReplaceUpdateButtonByMenu()2557 void SfxTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
2558 {
2559 m_aActionTbR.HideItem(SID_STYLE_UPDATE_BY_EXAMPLE);
2560 m_aActionTbR.SetItemBits( SID_STYLE_NEW_BY_EXAMPLE,
2561 TIB_DROPDOWNONLY|m_aActionTbR.GetItemBits( SID_STYLE_NEW_BY_EXAMPLE ));
2562 }
2563
2564 // ------------------------------------------------------------------------
updateFamilyImages()2565 void SfxTemplateDialog_Impl::updateFamilyImages()
2566 {
2567 if ( !m_pStyleFamiliesId )
2568 // we do not have a resource id to load the new images from
2569 return;
2570
2571 // let the families collection update the images
2572 sal_Bool bIsHighContrast;
2573 if (m_pFloat != NULL)
2574 bIsHighContrast = m_pFloat->GetSettings().GetStyleSettings().GetHighContrastMode();
2575 else
2576 bIsHighContrast = false;
2577 pStyleFamilies->updateImages( *m_pStyleFamiliesId, bIsHighContrast ? BMP_COLOR_HIGHCONTRAST : BMP_COLOR_NORMAL );
2578
2579 // and set the new images on our toolbox
2580 sal_uInt16 nLoop = pStyleFamilies->Count();
2581 for( ; nLoop--; )
2582 {
2583 const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject( nLoop );
2584 sal_uInt16 nId = SfxFamilyIdToNId( pItem->GetFamily() );
2585 m_aActionTbL.SetItemImage( nId, pItem->GetImage() );
2586 }
2587 }
2588
2589 // ------------------------------------------------------------------------
updateNonFamilyImages()2590 void SfxTemplateDialog_Impl::updateNonFamilyImages()
2591 {
2592 if (m_pFloat != NULL)
2593 m_aActionTbR.SetImageList( ImageList( SfxResId(
2594 m_pFloat->GetSettings().GetStyleSettings().GetHighContrastMode() ? IMG_LST_STYLE_DESIGNER_HC
2595 : DLG_STYLE_DESIGNER ) ) );
2596 }
2597
2598 // ------------------------------------------------------------------------
2599
ClearFamilyList()2600 void SfxTemplateDialog_Impl::ClearFamilyList()
2601 {
2602 m_aActionTbL.Clear();
2603 }
2604
2605 //-------------------------------------------------------------------------
2606
InvalidateBindings()2607 void SfxCommonTemplateDialog_Impl::InvalidateBindings()
2608 {
2609 pBindings->Invalidate(SID_STYLE_NEW_BY_EXAMPLE, sal_True, sal_False);
2610 pBindings->Update( SID_STYLE_NEW_BY_EXAMPLE );
2611 pBindings->Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE, sal_True, sal_False);
2612 pBindings->Update( SID_STYLE_UPDATE_BY_EXAMPLE );
2613 pBindings->Invalidate( SID_STYLE_WATERCAN, sal_True, sal_False);
2614 pBindings->Update( SID_STYLE_WATERCAN );
2615 pBindings->Invalidate( SID_STYLE_NEW, sal_True, sal_False );
2616 pBindings->Update( SID_STYLE_NEW );
2617 pBindings->Invalidate( SID_STYLE_DRAGHIERARCHIE, sal_True, sal_False );
2618 pBindings->Update( SID_STYLE_DRAGHIERARCHIE );
2619 }
2620
2621 //-------------------------------------------------------------------------
2622
~SfxTemplateDialog_Impl()2623 SfxTemplateDialog_Impl::~SfxTemplateDialog_Impl()
2624 {
2625 /*
2626 SfxImageManager* pImgMgr = pBindings->GetImageManager();
2627 if ( pImgMgr )
2628 {
2629 pImgMgr->ReleaseToolBox( &m_aActionTbL );
2630 pImgMgr->ReleaseToolBox( &m_aActionTbR );
2631 }
2632 */
2633 }
2634
2635 //-------------------------------------------------------------------------
2636
LoadedFamilies()2637 void SfxTemplateDialog_Impl::LoadedFamilies()
2638 {
2639 updateFamilyImages();
2640 Resize();
2641 }
2642
2643 //-------------------------------------------------------------------------
2644
2645 // "Uberladener Resize-Handler ( StarView )
2646 // Die Groesse der Listboxen wird angepasst
Resize()2647 void SfxTemplateDialog_Impl::Resize()
2648 {
2649 SfxDockingWindow* pDockingWindow = dynamic_cast<SfxDockingWindow*>(m_pFloat);
2650 FloatingWindow *pF = pDockingWindow!=NULL ? pDockingWindow->GetFloatingWindow() : NULL;
2651 if ( pF )
2652 {
2653 // if(pF->IsZoomedIn() && m_bZoomIn==sal_False)
2654 // pF->SetText(String(SfxResId( DLG_STYLE_DESIGNER )));
2655 // if(!pF->IsZoomedIn() && m_bZoomIn==sal_True && GetFamilyItem_Impl())
2656 // UpdateStyles_Impl(UPDATE_FAMILY); //Bereich wieder in Titel schreiben
2657 m_bZoomIn = pF->IsRollUp();
2658 if ( m_bZoomIn )
2659 return;
2660 }
2661
2662 if (m_pFloat == NULL)
2663 return;
2664 Size aDlgSize=m_pFloat->PixelToLogic(m_pFloat->GetOutputSizePixel());
2665 Size aSizeATL=m_pFloat->PixelToLogic(m_aActionTbL.CalcWindowSizePixel());
2666 Size aSizeATR=m_pFloat->PixelToLogic(m_aActionTbR.CalcWindowSizePixel());
2667 Size aMinSize = GetMinOutputSizePixel();
2668
2669 long nListHeight = m_pFloat->PixelToLogic( aFilterLb.GetSizePixel() ).Height();
2670 long nWidth = aDlgSize.Width()- 2 * SFX_TEMPLDLG_HFRAME;
2671
2672 m_aActionTbL.SetPosSizePixel(m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME,SFX_TEMPLDLG_VTOPFRAME)),
2673 m_pFloat->LogicToPixel(aSizeATL));
2674
2675 // Die Position der rechten Toolbox nur ver"andern, wenn das Fenster
2676 // breit genug ist
2677 Point aPosATR(aDlgSize.Width()-SFX_TEMPLDLG_HFRAME-aSizeATR.Width(),SFX_TEMPLDLG_VTOPFRAME);
2678 if(aDlgSize.Width() >= aMinSize.Width())
2679 m_aActionTbR.SetPosPixel(m_pFloat->LogicToPixel(aPosATR));
2680 else
2681 m_aActionTbR.SetPosPixel( m_pFloat->LogicToPixel(
2682 Point( SFX_TEMPLDLG_HFRAME + aSizeATL.Width() + SFX_TEMPLDLG_MIDHSPACE,
2683 SFX_TEMPLDLG_VTOPFRAME ) ) );
2684
2685 m_aActionTbR.SetSizePixel(m_pFloat->LogicToPixel(aSizeATR));
2686
2687 Point aFilterPos(
2688 m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME,
2689 aDlgSize.Height()-SFX_TEMPLDLG_VBOTFRAME-nListHeight)) );
2690
2691 Size aFilterSize(
2692 m_pFloat->LogicToPixel(Size(nWidth,SFX_TEMPLDLG_FILTERHEIGHT)) );
2693
2694 Point aFmtPos(
2695 m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME, SFX_TEMPLDLG_VTOPFRAME +
2696 SFX_TEMPLDLG_MIDVSPACE+aSizeATL.Height())) );
2697 Size aFmtSize(
2698 m_pFloat->LogicToPixel(Size(nWidth,
2699 aDlgSize.Height() - SFX_TEMPLDLG_VBOTFRAME -
2700 SFX_TEMPLDLG_VTOPFRAME - 2*SFX_TEMPLDLG_MIDVSPACE-
2701 nListHeight-aSizeATL.Height())) );
2702
2703 // Die Position der Listboxen nur ver"andern, wenn das Fenster
2704 // hoch genug ist
2705 if(aDlgSize.Height() >= aMinSize.Height())
2706 {
2707 aFilterLb.SetPosPixel(aFilterPos);
2708 aFmtLb.SetPosPixel( aFmtPos );
2709 if(pTreeBox)
2710 pTreeBox->SetPosPixel(aFmtPos);
2711 }
2712 else
2713 aFmtSize.Height() += aFilterSize.Height();
2714
2715 aFilterLb.SetSizePixel(aFilterSize);
2716 aFmtLb.SetSizePixel( aFmtSize );
2717 if(pTreeBox)
2718 pTreeBox->SetSizePixel(aFmtSize);
2719 }
2720
2721 // -----------------------------------------------------------------------
2722
2723
GetMinOutputSizePixel()2724 Size SfxTemplateDialog_Impl::GetMinOutputSizePixel()
2725 {
2726 if (m_pFloat != NULL)
2727 {
2728 Size aSizeATL=m_pFloat->PixelToLogic(m_aActionTbL.CalcWindowSizePixel());
2729 Size aSizeATR=m_pFloat->PixelToLogic(m_aActionTbR.CalcWindowSizePixel());
2730 Size aMinSize=Size(
2731 aSizeATL.Width()+aSizeATR.Width()+
2732 2*SFX_TEMPLDLG_HFRAME + SFX_TEMPLDLG_MIDHSPACE,
2733 4*aSizeATL.Height()+2*SFX_TEMPLDLG_MIDVSPACE);
2734 return aMinSize;
2735 }
2736 else
2737 return Size(0,0);
2738 }
2739
2740 //-------------------------------------------------------------------------
2741
Command(const CommandEvent & rCEvt)2742 void SfxTemplateDialog_Impl::Command( const CommandEvent& rCEvt )
2743 {
2744 if (m_pFloat != NULL)
2745 if(COMMAND_CONTEXTMENU == rCEvt.GetCommand())
2746 ExecuteContextMenu_Impl( rCEvt.GetMousePosPixel(), m_pFloat );
2747 else
2748 m_pFloat->Command(rCEvt);
2749 }
2750
2751 //-------------------------------------------------------------------------
2752
EnableItem(sal_uInt16 nMesId,sal_Bool bCheck)2753 void SfxTemplateDialog_Impl::EnableItem(sal_uInt16 nMesId, sal_Bool bCheck)
2754 {
2755 String aEmpty;
2756 switch(nMesId)
2757 {
2758 case SID_STYLE_WATERCAN :
2759 if(!bCheck && IsCheckedItem(SID_STYLE_WATERCAN))
2760 Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
2761 case SID_STYLE_NEW_BY_EXAMPLE:
2762 case SID_STYLE_UPDATE_BY_EXAMPLE:
2763 m_aActionTbR.EnableItem(nMesId,bCheck);
2764 break;
2765 }
2766 }
2767
2768 //-------------------------------------------------------------------------
2769
CheckItem(sal_uInt16 nMesId,sal_Bool bCheck)2770 void SfxTemplateDialog_Impl::CheckItem(sal_uInt16 nMesId, sal_Bool bCheck)
2771 {
2772 switch(nMesId)
2773 {
2774 case SID_STYLE_WATERCAN :
2775 bIsWater=bCheck;
2776 m_aActionTbR.CheckItem(SID_STYLE_WATERCAN,bCheck);
2777 break;
2778 default:
2779 m_aActionTbL.CheckItem(nMesId,bCheck); break;
2780 }
2781 }
2782
2783 //-------------------------------------------------------------------------
2784
IsCheckedItem(sal_uInt16 nMesId)2785 sal_Bool SfxTemplateDialog_Impl::IsCheckedItem(sal_uInt16 nMesId)
2786 {
2787 switch(nMesId)
2788 {
2789 case SID_STYLE_WATERCAN :
2790 return m_aActionTbR.GetItemState(SID_STYLE_WATERCAN)==STATE_CHECK;
2791 default:
2792 return m_aActionTbL.GetItemState(nMesId)==STATE_CHECK;
2793 }
2794 }
2795
2796 //-------------------------------------------------------------------------
2797
IMPL_LINK_INLINE_START(SfxTemplateDialog_Impl,ToolBoxLSelect,ToolBox *,pBox)2798 IMPL_LINK_INLINE_START( SfxTemplateDialog_Impl, ToolBoxLSelect, ToolBox *, pBox )
2799 {
2800 const sal_uInt16 nEntry = pBox->GetCurItemId();
2801 FamilySelect(nEntry);
2802 return 0;
2803 }
IMPL_LINK_INLINE_END(SfxTemplateDialog_Impl,ToolBoxLSelect,ToolBox *,pBox)2804 IMPL_LINK_INLINE_END( SfxTemplateDialog_Impl, ToolBoxLSelect, ToolBox *, pBox )
2805
2806 //-------------------------------------------------------------------------
2807 ::rtl::OUString lcl_GetLabel(uno::Any& rAny)
2808 {
2809 ::rtl::OUString sRet;
2810 uno::Sequence< beans::PropertyValue >aPropSeq;
2811 if ( rAny >>= aPropSeq )
2812 {
2813 for( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
2814 {
2815 if ( aPropSeq[i].Name.equalsAscii( "Label" ))
2816 {
2817 aPropSeq[i].Value >>= sRet;
2818 break;
2819 }
2820 }
2821 }
2822 return sRet;
2823 }
2824 //-------------------------------------------------------------------------
2825
IMPL_LINK(SfxTemplateDialog_Impl,ToolBoxRSelect,ToolBox *,pBox)2826 IMPL_LINK( SfxTemplateDialog_Impl, ToolBoxRSelect, ToolBox *, pBox )
2827 {
2828 const sal_uInt16 nEntry = pBox->GetCurItemId();
2829 if(nEntry != SID_STYLE_NEW_BY_EXAMPLE ||
2830 TIB_DROPDOWN != (pBox->GetItemBits(nEntry)&TIB_DROPDOWN))
2831 ActionSelect(nEntry);
2832 return 0;
2833 }
2834 //-------------------------------------------------------------------------
IMPL_LINK(SfxTemplateDialog_Impl,ToolBoxRClick,ToolBox *,pBox)2835 IMPL_LINK( SfxTemplateDialog_Impl, ToolBoxRClick, ToolBox *, pBox )
2836 {
2837 const sal_uInt16 nEntry = pBox->GetCurItemId();
2838 if(nEntry == SID_STYLE_NEW_BY_EXAMPLE &&
2839 TIB_DROPDOWN == (pBox->GetItemBits(nEntry)&TIB_DROPDOWN))
2840 {
2841 //create a popup menu in Writer
2842 PopupMenu *pMenu = new PopupMenu;
2843 uno::Reference< container::XNameAccess > xNameAccess(
2844 ::comphelper::getProcessServiceFactory()->
2845 createInstance( ::rtl::OUString::createFromAscii(
2846 "com.sun.star.frame.UICommandDescription") ), uno::UNO_QUERY );
2847 uno::Reference< container::XNameAccess > xUICommands;
2848 if ( xNameAccess.is() )
2849 {
2850 rtl::OUString sTextDoc = ::rtl::OUString::createFromAscii("com.sun.star.text.TextDocument");
2851 if(xNameAccess->hasByName(sTextDoc))
2852 {
2853 uno::Any a = xNameAccess->getByName( sTextDoc );
2854 a >>= xUICommands;
2855 }
2856 }
2857 if(!xUICommands.is())
2858 return 0;
2859 try
2860 {
2861 uno::Sequence< beans::PropertyValue > aPropSeq;
2862 uno::Any aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:StyleNewByExample"));
2863 ::rtl::OUString sLabel = lcl_GetLabel( aCommand );
2864 pMenu->InsertItem( SID_STYLE_NEW_BY_EXAMPLE, sLabel );
2865 pMenu->SetHelpId(SID_STYLE_NEW_BY_EXAMPLE, HID_TEMPLDLG_NEWBYEXAMPLE);
2866
2867 aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:StyleUpdateByExample"));
2868 sLabel = lcl_GetLabel( aCommand );
2869
2870 pMenu->InsertItem( SID_STYLE_UPDATE_BY_EXAMPLE, sLabel );
2871 pMenu->SetHelpId(SID_STYLE_UPDATE_BY_EXAMPLE, HID_TEMPLDLG_UPDATEBYEXAMPLE);
2872
2873 aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:LoadStyles"));
2874 sLabel = lcl_GetLabel( aCommand );
2875 pMenu->InsertItem( SID_TEMPLATE_LOAD, sLabel );
2876 pMenu->SetHelpId(SID_TEMPLATE_LOAD, ".uno:LoadStyles");
2877
2878 pMenu->SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, MenuSelectHdl));
2879 pMenu->Execute( pBox,
2880 pBox->GetItemRect(nEntry),
2881 POPUPMENU_EXECUTE_DOWN );
2882 pBox->EndSelection();
2883 }
2884 catch(uno::Exception&)
2885 {
2886 }
2887 delete pMenu;
2888 pBox->Invalidate();
2889 }
2890 return 0;
2891 }
2892 //-------------------------------------------------------------------------
IMPL_LINK(SfxTemplateDialog_Impl,MenuSelectHdl,Menu *,pMenu)2893 IMPL_LINK( SfxTemplateDialog_Impl, MenuSelectHdl, Menu*, pMenu)
2894 {
2895 sal_uInt16 nMenuId = pMenu->GetCurItemId();
2896 ActionSelect(nMenuId);
2897 return 0;
2898 }
2899 //-------------------------------------------------------------------------
2900
SfxTemplateCatalog_Impl(Window *,SfxBindings * pB,SfxTemplateCatalog * pTmpWindow)2901 SfxTemplateCatalog_Impl::SfxTemplateCatalog_Impl( Window* /*pParent*/, SfxBindings* pB,
2902 SfxTemplateCatalog* pTmpWindow ) :
2903
2904 SfxCommonTemplateDialog_Impl( pB, pTmpWindow ),
2905
2906 aFamList ( pTmpWindow, SfxResId( BT_TOOL ) ),
2907 aOkBtn ( pTmpWindow, SfxResId( BT_OK ) ),
2908 aCancelBtn ( pTmpWindow, SfxResId( BT_CANCEL ) ),
2909 aNewBtn ( pTmpWindow, SfxResId( BT_NEW ) ),
2910 aChangeBtn ( pTmpWindow, SfxResId( BT_EDIT ) ),
2911 aDelBtn ( pTmpWindow, SfxResId( BT_DEL ) ),
2912 aOrgBtn ( pTmpWindow, SfxResId( BT_ORG ) ),
2913 aHelpBtn ( pTmpWindow, SfxResId( BT_HELP ) ),
2914 pReal ( pTmpWindow ),
2915 aHelper ( pTmpWindow )
2916
2917 {
2918 aNewBtn.Disable();
2919 aDelBtn.Disable();
2920 aChangeBtn.Disable();
2921
2922 SFX_APP()->Get_Impl()->pTemplateCommon = GetISfxTemplateCommon();
2923 pTmpWindow->FreeResource();
2924
2925 Initialize();
2926
2927 aFamList.SetSelectHdl( LINK( this, SfxTemplateCatalog_Impl, FamListSelect ) );
2928 aOkBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, OkHdl ) );
2929 aCancelBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, CancelHdl ) );
2930 aNewBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, NewHdl ) );
2931 aDelBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, DelHdl ) );
2932 aChangeBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, ChangeHdl ) );
2933 aOrgBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, OrgHdl ) );
2934 }
2935
2936 //-------------------------------------------------------------------------
2937
~SfxTemplateCatalog_Impl()2938 SfxTemplateCatalog_Impl::~SfxTemplateCatalog_Impl()
2939 {
2940 SFX_APP()->Get_Impl()->pTemplateCommon = 0;
2941 }
2942
2943 //-------------------------------------------------------------------------
2944
IMPL_LINK_INLINE_START(SfxTemplateCatalog_Impl,OkHdl,Button *,pButton)2945 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, OkHdl, Button *, pButton )
2946 {
2947 (void)pButton; //unused
2948 ApplyHdl( NULL );
2949 pReal->EndDialog( RET_OK );
2950 return 0;
2951 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,OkHdl,Button *,pButton)2952 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, OkHdl, Button *, pButton )
2953
2954 //-------------------------------------------------------------------------
2955
2956 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, CancelHdl, Button *, pButton )
2957 {
2958 (void)pButton; //unused
2959 pReal->EndDialog( RET_CANCEL );
2960 return 0;
2961 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,CancelHdl,Button *,pButton)2962 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, CancelHdl, Button *, pButton )
2963
2964 //-------------------------------------------------------------------------
2965
2966 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, NewHdl, Button *, pButton )
2967 {
2968 (void)pButton; //unused
2969 aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
2970 SfxCommonTemplateDialog_Impl::NewHdl( NULL );
2971 return 0;
2972 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,NewHdl,Button *,pButton)2973 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, NewHdl, Button *, pButton )
2974
2975 //-------------------------------------------------------------------------
2976
2977 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, ChangeHdl, Button *, pButton )
2978 {
2979 (void)pButton; //unused
2980 aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
2981 SfxCommonTemplateDialog_Impl::EditHdl( NULL );
2982 return 0;
2983 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,ChangeHdl,Button *,pButton)2984 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, ChangeHdl, Button *, pButton )
2985
2986 //-------------------------------------------------------------------------
2987
2988 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, DelHdl, Button *, pButton )
2989 {
2990 (void)pButton; //unused
2991 SfxCommonTemplateDialog_Impl::DeleteHdl( NULL );
2992 return 0;
2993 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,DelHdl,Button *,pButton)2994 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, DelHdl, Button *, pButton )
2995
2996 //-------------------------------------------------------------------------
2997
2998 IMPL_LINK( SfxTemplateCatalog_Impl, OrgHdl, Button *, pButton )
2999 {
3000 (void)pButton; //unused
3001 aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
3002 SfxDocumentTemplates aTemplates;
3003 aTemplates.Construct();
3004 SfxTemplateOrganizeDlg* pDlg = new SfxTemplateOrganizeDlg( pReal, &aTemplates );
3005 const short nRet = pDlg->Execute();
3006 delete pDlg;
3007 if ( RET_OK == nRet )
3008 Update_Impl();
3009 else if ( RET_EDIT_STYLE == nRet )
3010 pReal->EndDialog( RET_CANCEL );
3011 return 0;
3012 }
3013
3014 //-------------------------------------------------------------------------
3015
EnableEdit(sal_Bool bEnable)3016 void SfxTemplateCatalog_Impl::EnableEdit( sal_Bool bEnable )
3017 {
3018 SfxCommonTemplateDialog_Impl::EnableEdit( bEnable );
3019 aChangeBtn.Enable( bEnable );
3020 }
3021
3022 //-------------------------------------------------------------------------
3023
EnableDel(sal_Bool bEnable)3024 void SfxTemplateCatalog_Impl::EnableDel( sal_Bool bEnable )
3025 {
3026 SfxCommonTemplateDialog_Impl::EnableDel( bEnable );
3027 aDelBtn.Enable( bEnable );
3028 }
3029
EnableNew(sal_Bool bEnable)3030 void SfxTemplateCatalog_Impl::EnableNew(sal_Bool bEnable)
3031 {
3032 SfxCommonTemplateDialog_Impl::EnableNew( bEnable );
3033 aNewBtn.Enable( bEnable );
3034 }
3035
3036 //-------------------------------------------------------------------------
3037
IMPL_LINK_INLINE_START(SfxTemplateCatalog_Impl,FamListSelect,ListBox *,pList)3038 IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, FamListSelect, ListBox *, pList )
3039 {
3040 const sal_uInt16 nEntry = aFamIds[pList->GetSelectEntryPos()];
3041 FamilySelect(nEntry);
3042 return 0;
3043 }
IMPL_LINK_INLINE_END(SfxTemplateCatalog_Impl,FamListSelect,ListBox *,pList)3044 IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, FamListSelect, ListBox *, pList )
3045
3046 //-------------------------------------------------------------------------
3047
3048 void SfxTemplateCatalog_Impl::EnableItem( sal_uInt16 nMesId, sal_Bool bCheck )
3049 {
3050 if ( nMesId == SID_STYLE_WATERCAN )
3051 aOkBtn.Enable( bCheck );
3052 if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
3053 return;
3054
3055 /* for(sal_uInt16 i=0;i<aFamIds.Count&&aFamIds[i]!=nMesId;i++);
3056 if(i!=aFamIds.Count())
3057 aFamList.SelectEntry(aFamIds[i]);
3058 else
3059 DBG_ERROR("Entry nicht gefunden");*/
3060
3061 }
3062
3063 //-------------------------------------------------------------------------
3064
CheckItem(sal_uInt16 nMesId,sal_Bool)3065 void SfxTemplateCatalog_Impl::CheckItem(sal_uInt16 nMesId, sal_Bool /*bCheck*/)
3066 {
3067 if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
3068 return;
3069 sal_uInt16 i;
3070 for ( i = 0; i < aFamIds.Count() && aFamIds[i] != nMesId; i++ ) ;
3071 aFamList.SelectEntryPos(i);
3072 }
3073
3074 //-------------------------------------------------------------------------
3075
IsCheckedItem(sal_uInt16 nMesId)3076 sal_Bool SfxTemplateCatalog_Impl::IsCheckedItem(sal_uInt16 nMesId)
3077 {
3078 if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
3079 return sal_False;
3080 sal_uInt16 i;
3081 for ( i = 0; i < aFamIds.Count() && aFamIds[i] != nMesId; i++ )
3082 ;
3083 return aFamList.IsEntrySelected( String::CreateFromInt32(i) );
3084 }
3085
3086 //-------------------------------------------------------------------------
3087
3088 // Der Katalog muss nur das Disablen beherrschen, da waehrend seiner
3089 // Lebenszeit keine Selektionsaenderungen vorgenommen werden koennen
EnableFamilyItem(sal_uInt16 nId,sal_Bool bEnable)3090 void SfxTemplateCatalog_Impl::EnableFamilyItem( sal_uInt16 nId, sal_Bool bEnable )
3091 {
3092 if ( !bEnable )
3093 for ( sal_uInt16 nPos = aFamIds.Count(); nPos--; )
3094 if ( aFamIds[ nPos ] == nId )
3095 {
3096 aFamIds.Remove( nPos );
3097 aFamList.RemoveEntry( nPos );
3098 }
3099 }
3100
InsertFamilyItem(sal_uInt16 nId,const SfxStyleFamilyItem * pItem)3101 void SfxTemplateCatalog_Impl::InsertFamilyItem( sal_uInt16 nId, const SfxStyleFamilyItem* pItem )
3102 {
3103 if ( nId > SFX_STYLE_FAMILY_PSEUDO || nId < SFX_STYLE_FAMILY_CHAR )
3104 return;
3105 aFamList.InsertEntry( pItem->GetText(), 0 );
3106 aFamIds.Insert( nId, 0 );
3107 }
3108
ClearFamilyList()3109 void SfxTemplateCatalog_Impl::ClearFamilyList()
3110 {
3111 aFamList.Clear();
3112 aFamIds.Remove( 0, aFamIds.Count() );
3113 }
3114
PrepareDeleteAction()3115 void SfxTemplateCatalog_Impl::PrepareDeleteAction()
3116 {
3117 aDelBtn.Disable();
3118 aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
3119 }
3120
3121
SetFamily(sal_uInt16 nId)3122 void SfxCommonTemplateDialog_Impl::SetFamily( sal_uInt16 nId )
3123 {
3124 if ( nId != nActFamily )
3125 {
3126 if ( nActFamily != SFX_TEMPLDLG_FILTER_MAX )
3127 CheckItem( nActFamily, sal_False );
3128 nActFamily = nId;
3129 if ( nId != SFX_TEMPLDLG_FILTER_MAX )
3130 bUpdateFamily = sal_True;
3131 }
3132 }
3133
UpdateFamily_Impl()3134 void SfxCommonTemplateDialog_Impl::UpdateFamily_Impl()
3135 {
3136 bUpdateFamily = sal_False;
3137
3138 SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
3139 SfxViewFrame *pViewFrame = pDispat->GetFrame();
3140 SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
3141
3142 SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
3143 pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): 0;
3144 if ( pOldStyleSheetPool != pStyleSheetPool )
3145 {
3146 if ( pOldStyleSheetPool )
3147 EndListening(*pOldStyleSheetPool);
3148 if ( pStyleSheetPool )
3149 StartListening(*pOldStyleSheetPool);
3150 }
3151
3152 bWaterDisabled = sal_False;
3153 bCanNew = sal_True;
3154 bTreeDrag = sal_True;
3155 bUpdateByExampleDisabled = sal_False;
3156
3157 if ( pStyleSheetPool )
3158 {
3159 if(!pTreeBox)
3160 UpdateStyles_Impl(UPDATE_FAMILY | UPDATE_FAMILY_LIST);
3161 else
3162 {
3163 UpdateStyles_Impl(UPDATE_FAMILY);
3164 FillTreeBox();
3165 }
3166 }
3167
3168 InvalidateBindings();
3169
3170 if ( IsCheckedItem( SID_STYLE_WATERCAN ) &&
3171 // nur, wenn dieser Bereich erlaubt ist
3172 0 != pFamilyState[ nActFamily - 1 ] )
3173 Execute_Impl( SID_STYLE_APPLY, GetSelectedEntry(),
3174 String(), (sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
3175 }
ReplaceUpdateButtonByMenu()3176 void SfxCommonTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
3177 {
3178 //does nothing
3179 }
3180
StateChanged(StateChangedType nStateChange)3181 void SfxTemplateDialog::StateChanged( StateChangedType nStateChange )
3182 {
3183 if ( nStateChange == STATE_CHANGE_INITSHOW )
3184 {
3185 SfxViewFrame *pFrame = GetBindings().GetDispatcher_Impl()->GetFrame();
3186 Window* pEditWin = pFrame->GetViewShell()->GetWindow();
3187
3188 Size aSize = pEditWin->GetSizePixel();
3189 Point aPoint = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
3190 aPoint = GetParent()->ScreenToOutputPixel( aPoint );
3191 Size aWinSize = GetSizePixel();
3192 aPoint.X() += aSize.Width() - aWinSize.Width() - 20;
3193 aPoint.Y() += aSize.Height() / 2 - aWinSize.Height() / 2;
3194 SetFloatingPos( aPoint );
3195 }
3196
3197 SfxDockingWindow::StateChanged( nStateChange );
3198 }
3199
3200 /*-- 10.12.2003 11:44:35---------------------------------------------------
3201
3202 -----------------------------------------------------------------------*/
DropToolBox_Impl(Window * pParent,SfxTemplateDialog_Impl * pTemplateDialog)3203 DropToolBox_Impl::DropToolBox_Impl(Window* pParent, SfxTemplateDialog_Impl* pTemplateDialog) :
3204 ToolBox(pParent),
3205 DropTargetHelper(this),
3206 rParent(*pTemplateDialog)
3207 {
3208 }
3209 /*-- 10.12.2003 11:44:35---------------------------------------------------
3210
3211 -----------------------------------------------------------------------*/
~DropToolBox_Impl()3212 DropToolBox_Impl::~DropToolBox_Impl()
3213 {
3214 }
3215 /*-- 10.12.2003 11:44:35---------------------------------------------------
3216
3217 -----------------------------------------------------------------------*/
AcceptDrop(const AcceptDropEvent & rEvt)3218 sal_Int8 DropToolBox_Impl::AcceptDrop( const AcceptDropEvent& rEvt )
3219 {
3220 sal_Int8 nReturn = DND_ACTION_NONE;
3221 sal_uInt16 nItemId = GetItemId( rEvt.maPosPixel );
3222 if(USHRT_MAX != nItemId && !IsItemChecked( nItemId ))
3223 {
3224 SetCurItemId(nItemId);
3225 GetSelectHdl().Call(this);
3226 }
3227 // special case: page styles are allowed to create new styles by example
3228 // but not allowed to be created by drag and drop
3229 if ( nItemId != SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SFX_STYLE_FAMILY_PAGE )&&
3230 IsDropFormatSupported( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) &&
3231 !rParent.bNewByExampleDisabled )
3232 {
3233 nReturn = DND_ACTION_COPY;
3234 }
3235 return nReturn;
3236 }
3237 /*-- 10.12.2003 11:44:35---------------------------------------------------
3238
3239 -----------------------------------------------------------------------*/
ExecuteDrop(const ExecuteDropEvent & rEvt)3240 sal_Int8 DropToolBox_Impl::ExecuteDrop( const ExecuteDropEvent& rEvt )
3241 {
3242 return rParent.aFmtLb.ExecuteDrop(rEvt);
3243 }
3244
3245