Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sfx2 / source / dialog / templdlg.cxx
blob: 55bb0b98ab6e1dc741690ecf3bf3f22f54f27414 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sfx2.hxx"
#ifndef _MENU_HXX //autogen
#include <vcl/menu.hxx>
#endif
#include <svl/intitem.hxx>
#include <svl/stritem.hxx>
#include <svl/style.hxx>
#ifndef GCC
#endif
#define _SVSTDARR_STRINGSDTOR
#include <svl/svstdarr.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/sequenceashashmap.hxx>
#include <unotools/intlwrapper.hxx>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/frame/XModuleManager.hpp>
#include "sfx2/sfxhelp.hxx"
#include <sfx2/app.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/templdlg.hxx>
#include "templdgi.hxx"
#include "tplcitem.hxx"
#include "sfxtypes.hxx"
#include <sfx2/styfitem.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/newstyle.hxx>
#include "sfx2/tplpitem.hxx"
#include "sfx2/sfxresid.hxx"
#include "templdlg.hrc"
#include <sfx2/sfx.hrc>
#include "dialog.hrc"
#include "arrdecl.hxx"
#include "fltfnc.hxx"
#include <sfx2/docfilt.hxx>
#include <sfx2/docfac.hxx>
#include "docvor.hxx"
#include <sfx2/doctempl.hxx>
#include <sfx2/module.hxx>
#include "sfx2/imgmgr.hxx"
#include "helpid.hrc"
#include "appdata.hxx"
#include <sfx2/viewfrm.hxx>
#include <comphelper/configurationhelper.hxx>
using namespace ::com::sun::star;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::uno;
//=========================================================================
// Fenster wird ab jetzt dynamisch erstellt. Daher hier R"ander usw.
#define SFX_TEMPLDLG_HFRAME 3
#define SFX_TEMPLDLG_VTOPFRAME 3
#define SFX_TEMPLDLG_VBOTFRAME 3
#define SFX_TEMPLDLG_MIDHSPACE 3
#define SFX_TEMPLDLG_MIDVSPACE 3
#define SFX_TEMPLDLG_FILTERHEIGHT 100
static sal_uInt16 nLastItemId = USHRT_MAX;
// filter box has maximum 12 entries visible
#define MAX_FILTER_ENTRIES 12
#define SFX_TEMPLDLG_FILTER_MAX 0xFFFF
#define SFX_TEMPLDLG_FILTER_HIERARCHICAL 0xFFFE
//=========================================================================
TYPEINIT0(SfxCommonTemplateDialog_Impl);
TYPEINIT1(SfxTemplateDialog_Impl,SfxCommonTemplateDialog_Impl);
TYPEINIT1(SfxTemplateCatalog_Impl,SfxCommonTemplateDialog_Impl);
SFX_IMPL_DOCKINGWINDOW(SfxTemplateDialogWrapper, SID_STYLE_DESIGNER)
//-------------------------------------------------------------------------
// Redirektionsfunktionen
SfxTemplateDialog::SfxTemplateDialog
(
SfxBindings *pBind,
SfxChildWindow *pCW,
Window *pParent
)
/* [Beschreibung]
Gestalterklasse.
*/
: SfxDockingWindow( pBind, pCW, pParent, SfxResId(DLG_STYLE_DESIGNER) ),
pImpl( new SfxTemplateDialog_Impl( pBind, this ) )
{
pImpl->updateNonFamilyImages();
}
//-------------------------------------------------------------------------
SfxTemplateDialog::~SfxTemplateDialog()
{
delete pImpl;
}
ISfxTemplateCommon* SfxTemplateDialog::GetISfxTemplateCommon()
{
return pImpl->GetISfxTemplateCommon();
}
void SfxTemplateDialog::SetParagraphFamily()
{
// first select the paragraph family
pImpl->FamilySelect( SFX_STYLE_FAMILY_PARA );
// then select the automatic filter
pImpl->SetAutomaticFilter();
}
// ------------------------------------------------------------------------
void SfxTemplateDialog::DataChanged( const DataChangedEvent& _rDCEvt )
{
if ( ( DATACHANGED_SETTINGS == _rDCEvt.GetType() ) &&
( 0 != ( SETTINGS_STYLE & _rDCEvt.GetFlags() ) ) )
{
pImpl->updateFamilyImages();
pImpl->updateNonFamilyImages();
}
SfxDockingWindow::DataChanged( _rDCEvt );
}
//-------------------------------------------------------------------------
void SfxTemplateDialog::Update()
{
pImpl->Update();
}
//-------------------------------------------------------------------------
void SfxTemplateDialog::Resize()
{
if(pImpl)
pImpl->Resize();
SfxDockingWindow::Resize();
}
//-------------------------------------------------------------------------
SfxChildAlignment SfxTemplateDialog::CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)
{
switch (eAlign)
{
case SFX_ALIGN_TOP:
case SFX_ALIGN_HIGHESTTOP:
case SFX_ALIGN_LOWESTTOP:
case SFX_ALIGN_BOTTOM:
case SFX_ALIGN_LOWESTBOTTOM:
case SFX_ALIGN_HIGHESTBOTTOM:
return eActAlign;
case SFX_ALIGN_LEFT:
case SFX_ALIGN_RIGHT:
case SFX_ALIGN_FIRSTLEFT:
case SFX_ALIGN_LASTLEFT:
case SFX_ALIGN_FIRSTRIGHT:
case SFX_ALIGN_LASTRIGHT:
return eAlign;
default:
return eAlign;
}
}
//-------------------------------------------------------------------------
SfxTemplateCatalog::SfxTemplateCatalog(Window *pParent, SfxBindings *pBindings)
: SfxModalDialog(pParent,SfxResId(RID_STYLECATALOG))
{
pImpl = new SfxTemplateCatalog_Impl(pParent, pBindings, this);
}
//-------------------------------------------------------------------------
SfxTemplateCatalog::~SfxTemplateCatalog()
{
delete pImpl;
}
//-------------------------------------------------------------------------
void DropListBox_Impl::MouseButtonDown( const MouseEvent& rMEvt )
{
nModifier = rMEvt.GetModifier();
sal_Bool bHitEmptySpace = ( NULL == GetEntry( rMEvt.GetPosPixel(), sal_True ) );
if( bHitEmptySpace && ( rMEvt.GetClicks() == 2 ) && rMEvt.IsMod1() )
Control::MouseButtonDown( rMEvt );
else
SvTreeListBox::MouseButtonDown( rMEvt );
}
sal_Int8 DropListBox_Impl::AcceptDrop( const AcceptDropEvent& rEvt )
/* [Description: ]
Drop is enabled as long as it is allowed to create a new style by example, i.e. to
create a style out of the current selection.
*/
{
if ( IsDropFormatSupported( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) )
{
// special case: page styles are allowed to create new styles by example
// but not allowed to be created by drag and drop
if( pDialog->nActFamily == SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SFX_STYLE_FAMILY_PAGE ) ||
pDialog->bNewByExampleDisabled )
return DND_ACTION_NONE;
else
return DND_ACTION_COPY;
}
return SvTreeListBox::AcceptDrop( rEvt );
}
//-------------------------------------------------------------------------
sal_Int8 DropListBox_Impl::ExecuteDrop( const ExecuteDropEvent& rEvt )
{
// rEvt.maDropEvent.Context->acceptDrop( DND_ACTION_NONE );
// rEvt.maDropEvent.Context->dropComplete( sal_True );
sal_Int8 nRet = DND_ACTION_NONE;
SfxObjectShell* pDocShell = pDialog->GetObjectShell();
TransferableDataHelper aHelper( rEvt.maDropEvent.Transferable );
sal_uInt32 nFormatCount = aHelper.GetFormatCount();
if ( pDocShell )
{
sal_Bool bFormatFound = sal_False;
for ( sal_uInt32 i = 0; i < nFormatCount; ++i )
{
SotFormatStringId nId = aHelper.GetFormat(i);
TransferableObjectDescriptor aDesc;
if ( aHelper.GetTransferableObjectDescriptor( nId, aDesc ) )
{
if ( aDesc.maClassName == pDocShell->GetFactory().GetClassId() )
{
PostUserEvent( LINK( this, DropListBox_Impl, OnAsyncExecuteDrop ), 0 );
bFormatFound = sal_True;
nRet = rEvt.mnAction;
break;
}
}
}
if ( !bFormatFound )
return SvTreeListBox::ExecuteDrop( rEvt );
}
return nRet;
}
IMPL_LINK( DropListBox_Impl, OnAsyncExecuteDrop, SvLBoxEntry*, EMPTYARG )
{
pDialog->ActionSelect( SID_STYLE_NEW_BY_EXAMPLE );
return 0;
}
IMPL_LINK( DropListBox_Impl, OnAsyncExecuteError, void*, NOTINTERESTEDIN )
{
(void)NOTINTERESTEDIN; // unused
ErrorHandler::HandleError( ERRCODE_IO_WRONGFORMAT );
return 0;
}
long DropListBox_Impl::Notify( NotifyEvent& rNEvt )
{
long nRet = 0;
if( rNEvt.GetType() == EVENT_KEYINPUT )
{
const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
if(!rKeyCode.GetModifier())
{
if( pDialog->bCanDel && KEY_DELETE == rKeyCode.GetCode())
{
pDialog->DeleteHdl( NULL );
nRet = 1;
}
else if( KEY_RETURN == rKeyCode.GetCode())
{
GetDoubleClickHdl().Call(this);
nRet = 1;
}
}
}
if(!nRet)
nRet = SvTreeListBox::Notify( rNEvt );
return nRet;
}
//-------------------------------------------------------------------------
SfxActionListBox::SfxActionListBox
(
SfxCommonTemplateDialog_Impl* pParent,
WinBits nWinBits
)
/* [Beschreibung]
ListBox- Klasse, die im Command-Handler ein PopupMenu (Gestalter
spezifisch) startet.
*/
: DropListBox_Impl(pParent->GetWindow(), nWinBits, pParent)
{
EnableContextMenuHandling();
}
//-------------------------------------------------------------------------
SfxActionListBox::SfxActionListBox( SfxCommonTemplateDialog_Impl* pParent,
const ResId &rResId) :
DropListBox_Impl(pParent->GetWindow(), rResId, pParent)
{
EnableContextMenuHandling();
}
//-------------------------------------------------------------------------
PopupMenu* SfxActionListBox::CreateContextMenu( void )
{
//added by BerryJia for fixing Bug102739 2002-9-9 17:00(Beijing Time)
if( !( GetSelectionCount() > 0 ) )
{
pDialog->EnableEdit( sal_False );
pDialog->EnableDel( sal_False );
}
return pDialog->CreateContextMenu();
}
//-------------------------------------------------------------------------
SfxTemplateDialogWrapper::SfxTemplateDialogWrapper(Window *pParentWnd,
sal_uInt16 nId, SfxBindings *p, SfxChildWinInfo *pInfo) :
SfxChildWindow(pParentWnd, nId)
{
SfxTemplateDialog *pWin = new SfxTemplateDialog(p, this, pParentWnd);
pWindow = pWin;
eChildAlignment = SFX_ALIGN_NOALIGNMENT;
pWin->Initialize( pInfo );
pWin->SetMinOutputSizePixel(pWin->pImpl->GetMinOutputSizePixel());
}
void SfxTemplateDialogWrapper::SetParagraphFamily()
{
// forward to SfxTemplateDialog, because SfxTemplateDialog isn't exported
static_cast< SfxTemplateDialog* >( GetWindow() )->SetParagraphFamily();
}
//===== SfxTemplatePanelControl ===============================================
SfxTemplatePanelControl::SfxTemplatePanelControl (
SfxBindings* pBindings,
Window* pParentWindow)
: DockingWindow(pParentWindow, SfxResId(DLG_STYLE_DESIGNER) ),
pImpl(new SfxTemplateDialog_Impl(pBindings, this)),
mpBindings(pBindings)
{
OSL_ASSERT(mpBindings!=NULL);
pImpl->updateNonFamilyImages();
SetStyle(GetStyle() & ~WB_DOCKABLE);
}
SfxTemplatePanelControl::~SfxTemplatePanelControl (void)
{
delete pImpl;
}
ISfxTemplateCommon* SfxTemplatePanelControl::GetISfxTemplateCommon()
{
return pImpl->GetISfxTemplateCommon();
}
void SfxTemplatePanelControl::SetParagraphFamily()
{
// first select the paragraph family
pImpl->FamilySelect( SFX_STYLE_FAMILY_PARA );
// then select the automatic filter
pImpl->SetAutomaticFilter();
}
void SfxTemplatePanelControl::DataChanged( const DataChangedEvent& _rDCEvt )
{
if ( ( DATACHANGED_SETTINGS == _rDCEvt.GetType() ) &&
( 0 != ( SETTINGS_STYLE & _rDCEvt.GetFlags() ) ) )
{
pImpl->updateFamilyImages();
pImpl->updateNonFamilyImages();
}
DockingWindow::DataChanged( _rDCEvt );
}
void SfxTemplatePanelControl::Update()
{
pImpl->Update();
}
void SfxTemplatePanelControl::Resize()
{
if(pImpl)
pImpl->Resize();
DockingWindow::Resize();
}
void SfxTemplatePanelControl::FreeResource (void)
{
DockingWindow::FreeResource();
}
SfxChildAlignment SfxTemplatePanelControl::CheckAlignment(SfxChildAlignment eActAlign,SfxChildAlignment eAlign)
{
switch (eAlign)
{
case SFX_ALIGN_TOP:
case SFX_ALIGN_HIGHESTTOP:
case SFX_ALIGN_LOWESTTOP:
case SFX_ALIGN_BOTTOM:
case SFX_ALIGN_LOWESTBOTTOM:
case SFX_ALIGN_HIGHESTBOTTOM:
return eActAlign;
case SFX_ALIGN_LEFT:
case SFX_ALIGN_RIGHT:
case SFX_ALIGN_FIRSTLEFT:
case SFX_ALIGN_LASTLEFT:
case SFX_ALIGN_FIRSTRIGHT:
case SFX_ALIGN_LASTRIGHT:
return eAlign;
default:
return eAlign;
}
}
void SfxTemplatePanelControl::StateChanged( StateChangedType nStateChange )
{
if ( nStateChange == STATE_CHANGE_INITSHOW )
{
SfxViewFrame *pFrame = mpBindings->GetDispatcher_Impl()->GetFrame();
Window* pEditWin = pFrame->GetViewShell()->GetWindow();
Size aSize = pEditWin->GetSizePixel();
Point aPoint = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
aPoint = GetParent()->ScreenToOutputPixel( aPoint );
Size aWinSize = GetSizePixel();
aPoint.X() += aSize.Width() - aWinSize.Width() - 20;
aPoint.Y() += aSize.Height() / 2 - aWinSize.Height() / 2;
// SetFloatingPos( aPoint );
}
DockingWindow::StateChanged( nStateChange );
}
//=========================================================================
SV_DECL_PTRARR_DEL(ExpandedEntries, StringPtr,16,8)
SV_IMPL_PTRARR(ExpandedEntries, StringPtr)
/* [Beschreibung]
TreeListBox- Klasse f"ur die Anzeige der hierarchischen View
der Vorlagen
*/
class StyleTreeListBox_Impl : public DropListBox_Impl
{
private:
SvLBoxEntry* pCurEntry;
SfxCommonTemplateDialog_Impl* pCommon;
Link aDoubleClickLink;
Link aDropLink;
String aParent;
String aStyle;
protected:
virtual void Command( const CommandEvent& rMEvt );
virtual long Notify( NotifyEvent& rNEvt );
virtual sal_Bool DoubleClickHdl();
virtual long ExpandingHdl();
virtual void ExpandedHdl();
virtual sal_Bool NotifyMoving(SvLBoxEntry* pTarget,
SvLBoxEntry* pEntry,
SvLBoxEntry*& rpNewParent,
sal_uIntPtr& rNewChildPos);
public:
StyleTreeListBox_Impl( SfxCommonTemplateDialog_Impl* pParent, WinBits nWinStyle = 0);
void SetDoubleClickHdl(const Link &rLink) { aDoubleClickLink = rLink; }
void SetDropHdl(const Link &rLink) { aDropLink = rLink; }
using SvLBox::GetParent;
const String& GetParent() const { return aParent; }
const String& GetStyle() const { return aStyle; }
void MakeExpanded_Impl(ExpandedEntries& rEntries) const;
virtual PopupMenu* CreateContextMenu( void );
};
//-------------------------------------------------------------------------
void StyleTreeListBox_Impl::MakeExpanded_Impl(ExpandedEntries& rEntries) const
{
SvLBoxEntry *pEntry;
sal_uInt16 nCount=0;
for(pEntry=(SvLBoxEntry*)FirstVisible();pEntry;pEntry=(SvLBoxEntry*)NextVisible(pEntry))
{
if(IsExpanded(pEntry))
{
StringPtr pString=new String(GetEntryText(pEntry));
rEntries.Insert(pString,nCount++);
}
}
}
PopupMenu* StyleTreeListBox_Impl::CreateContextMenu()
{
return pDialog->CreateContextMenu();
}
sal_Bool StyleTreeListBox_Impl::DoubleClickHdl()
/* [Beschreibung]
DoubleClick-Handler; ruft entsprechenden Link.
Virtuelle Methode aus SV.
*/
{
aDoubleClickLink.Call(this);
return sal_False;
}
//-------------------------------------------------------------------------
void StyleTreeListBox_Impl::Command( const CommandEvent& rCEvt )
/* [Beschreibung]
Command Handler; dieser executed ein PopupMenu (Gestalter
spezifisch).
Virtuelle Methode aus SV.
*/
{
SvTreeListBox::Command(rCEvt);
}
//-------------------------------------------------------------------------
long StyleTreeListBox_Impl::Notify( NotifyEvent& rNEvt )
{
// handle <RETURN> as double click
long nRet = 0;
if ( rNEvt.GetType() == EVENT_KEYINPUT )
{
const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
if ( !rKeyCode.GetModifier() && KEY_RETURN == rKeyCode.GetCode() )
{
aDoubleClickLink.Call( this );
nRet = 1;
}
}
if ( !nRet )
nRet = DropListBox_Impl::Notify( rNEvt );
return nRet;
}
//-------------------------------------------------------------------------
sal_Bool StyleTreeListBox_Impl::NotifyMoving(SvLBoxEntry* pTarget,
SvLBoxEntry* pEntry,
SvLBoxEntry*& rpNewParent,
sal_uIntPtr& lPos)
/* [Beschreibung]
NotifyMoving Handler; dieser leitet per Link das Event an den Dialog
weiter.
Virtuelle Methode aus SV.
*/
{
if(!pTarget || !pEntry)
return sal_False;
aParent = GetEntryText(pTarget);
aStyle = GetEntryText(pEntry);
const sal_Bool bRet = (sal_Bool)aDropLink.Call(this);
rpNewParent = pTarget;
lPos=0;
IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() );
const CollatorWrapper* pCollator = aIntlWrapper.getCaseCollator();
for(SvLBoxEntry *pTmpEntry=FirstChild(pTarget);
pTmpEntry && COMPARE_LESS==pCollator->compareString(
GetEntryText(pTmpEntry),GetEntryText(pEntry));
pTmpEntry=NextSibling(pTmpEntry),lPos++) ;
return bRet? (sal_Bool)2: sal_False;
}
//-------------------------------------------------------------------------
long StyleTreeListBox_Impl::ExpandingHdl()
/* [Beschreibung]
ExpandingHdl Handler; der aktuelle Eintrag wird gemerkt.
Virtuelle Methode aus SV.
[Querverweise]
<StyleTreeListBox_Impl::ExpandedHdl()>
*/
{
pCurEntry = GetCurEntry();
return sal_True;
}
//-------------------------------------------------------------------------
void StyleTreeListBox_Impl::ExpandedHdl()
/* [Beschreibung]
ExpandedHdl Handler;
Virtuelle Methode aus SV.
[Querverweise]
<StyleTreeListBox_Impl::ExpandingHdl()>
*/
{
SvLBoxEntry *pEntry = GetHdlEntry();
if(!IsExpanded(pEntry) && pCurEntry != GetCurEntry())
SelectAll( sal_False );
pCurEntry = 0;
}
//-------------------------------------------------------------------------
StyleTreeListBox_Impl::StyleTreeListBox_Impl(
SfxCommonTemplateDialog_Impl* pParent, WinBits nWinStyle) :
DropListBox_Impl(pParent->GetWindow(), nWinStyle, pParent),
pCurEntry(0),
pCommon(pParent)
/* [Beschreibung]
Konstruktor StyleTreeListBox_Impl
*/
{
EnableContextMenuHandling();
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class StyleTreeArr_Impl;
/* [Beschreibung]
Interne Struktur f"ur den Aufbau der hierarchischen View
*/
struct StyleTree_Impl
{
String aName;
String aParent;
StyleTreeArr_Impl *pChilds;
sal_Bool bIsExpanded;
sal_Bool HasParent() const { return aParent.Len() != 0; }
StyleTree_Impl(const String &rName, const String &rParent):
aName(rName), aParent(rParent), pChilds(0), bIsExpanded(0) {}
~StyleTree_Impl();
void Put(StyleTree_Impl* pIns, sal_uIntPtr lPos=ULONG_MAX);
sal_uIntPtr Count();
};
typedef StyleTree_Impl* StyleTree_ImplPtr;
SV_DECL_PTRARR_DEL(StyleTreeArr_Impl, StyleTree_ImplPtr, 16, 8)
SV_IMPL_PTRARR(StyleTreeArr_Impl, StyleTree_ImplPtr)
sal_uIntPtr StyleTree_Impl::Count()
{
return pChilds ? pChilds->Count() : 0L;
}
//-------------------------------------------------------------------------
StyleTree_Impl::~StyleTree_Impl()
{
delete pChilds;
}
//-------------------------------------------------------------------------
void StyleTree_Impl::Put(StyleTree_Impl* pIns, sal_uIntPtr lPos)
{
if ( !pChilds )
pChilds = new StyleTreeArr_Impl;
if ( ULONG_MAX == lPos )
lPos = pChilds->Count();
pChilds->Insert( pIns, (sal_uInt16)lPos );
}
//-------------------------------------------------------------------------
StyleTreeArr_Impl &MakeTree_Impl(StyleTreeArr_Impl &rArr)
{
const sal_uInt16 nCount = rArr.Count();
// Alle unter ihren Parents einordnen
sal_uInt16 i;
for(i = 0; i < nCount; ++i)
{
StyleTree_ImplPtr pEntry = rArr[i];
if(pEntry->HasParent())
{
for(sal_uInt16 j = 0; j < nCount; ++j)
{
StyleTree_ImplPtr pCmp = rArr[j];
if(pCmp->aName == pEntry->aParent)
{
// initial sortiert einfuegen
sal_uInt16 ii;
IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() );
const CollatorWrapper* pCollator = aIntlWrapper.getCaseCollator();
for ( ii = 0;
ii < pCmp->Count() && COMPARE_LESS ==
pCollator->compareString( (*pCmp->pChilds)[ii]->aName,
pEntry->aName);++ii) ;
pCmp->Put(pEntry,ii);
break;
}
}
}
}
// alle, die schon unter ihrem Parent eingeordnet wurden
// entfernen
for(i = 0; i < rArr.Count(); )
{
if(rArr[i]->HasParent())
rArr.Remove(i);
else
++i;
}
return rArr;
}
//-------------------------------------------------------------------------
inline sal_Bool IsExpanded_Impl( const ExpandedEntries& rEntries,
const String &rStr)
{
sal_uInt16 nCount=rEntries.Count();
for(sal_uInt16 n=0;n<nCount;n++)
if(*rEntries[n]==rStr)
return sal_True;
return sal_False;
}
SvLBoxEntry* FillBox_Impl(SvTreeListBox *pBox,
StyleTree_ImplPtr pEntry,
const ExpandedEntries& rEntries,
SvLBoxEntry* pParent = 0)
{
SvLBoxEntry* pNewEntry = pBox->InsertEntry(pEntry->aName, pParent);
const sal_uInt16 nCount = pEntry->pChilds? pEntry->pChilds->Count(): 0;
for(sal_uInt16 i = 0; i < nCount; ++i)
FillBox_Impl(pBox, (*pEntry->pChilds)[i], rEntries, pNewEntry);
return pNewEntry;
}
//-------------------------------------------------------------------------
// Konstruktor
SfxCommonTemplateDialog_Impl::SfxCommonTemplateDialog_Impl( SfxBindings* pB, Window* pW, bool ) :
aISfxTemplateCommon ( this ),
pBindings ( pB ),
pWindow ( pW ),
pModule ( NULL ),
pTimer ( NULL ),
m_pStyleFamiliesId ( NULL ),
pStyleSheetPool ( NULL ),
pTreeBox ( NULL ),
pCurObjShell ( NULL ),
xModuleManager ( ::comphelper::getProcessServiceFactory()->createInstance(
DEFINE_CONST_UNICODE("com.sun.star.frame.ModuleManager") ), UNO_QUERY ),
pbDeleted ( NULL ),
aFmtLb ( this, WB_BORDER | WB_TABSTOP | WB_SORT | WB_QUICK_SEARCH ),
aFilterLb ( pW, WB_BORDER | WB_DROPDOWN | WB_TABSTOP ),
nActFamily ( SFX_TEMPLDLG_FILTER_MAX ),
nActFilter ( 0 ),
nAppFilter ( 0 ),
bDontUpdate ( sal_False ),
bIsWater ( sal_False ),
bEnabled ( sal_True ),
bUpdate ( sal_False ),
bUpdateFamily ( sal_False ),
bCanEdit ( sal_False ),
bCanDel ( sal_False ),
bCanNew ( sal_True ),
bWaterDisabled ( sal_False ),
bNewByExampleDisabled ( sal_False ),
bUpdateByExampleDisabled( sal_False ),
bTreeDrag ( sal_True ),
bHierarchical ( sal_False ),
bBindingUpdate ( sal_True )
{
aFmtLb.SetAccessibleName(SfxResId(STR_STYLE_ELEMTLIST));
aFmtLb.SetHelpId( HID_TEMPLATE_FMT );
aFilterLb.SetHelpId( HID_TEMPLATE_FILTER );
aFmtLb.SetStyle( aFmtLb.GetStyle() | WB_SORT | WB_HIDESELECTION );
Font aFont = aFmtLb.GetFont();
aFont.SetWeight( WEIGHT_NORMAL );
aFmtLb.SetFont( aFont );
}
//-------------------------------------------------------------------------
SfxCommonTemplateDialog_Impl::SfxCommonTemplateDialog_Impl( SfxBindings* pB, Window* pW ) :
aISfxTemplateCommon ( this ),
pBindings ( pB ),
pWindow ( pW ),
pModule ( NULL ),
pTimer ( NULL ),
pStyleSheetPool ( NULL ),
pTreeBox ( NULL ),
pCurObjShell ( NULL ),
pbDeleted ( NULL ),
aFmtLb ( this, SfxResId( BT_VLIST ) ),
aFilterLb ( pW, SfxResId( BT_FLIST ) ),
nActFamily ( SFX_TEMPLDLG_FILTER_MAX ),
nActFilter ( 0 ),
nAppFilter ( 0 ),
bDontUpdate ( sal_False ),
bIsWater ( sal_False ),
bEnabled ( sal_True ),
bUpdate ( sal_False ),
bUpdateFamily ( sal_False ),
bCanEdit ( sal_False ),
bCanDel ( sal_False ),
bCanNew ( sal_True ),
bWaterDisabled ( sal_False ),
bNewByExampleDisabled ( sal_False ),
bUpdateByExampleDisabled( sal_False ),
bTreeDrag ( sal_True ),
bHierarchical ( sal_False ),
bBindingUpdate ( sal_True )
{
aFmtLb.SetStyle( aFmtLb.GetStyle() | WB_SORT );
}
//-------------------------------------------------------------------------
sal_uInt16 SfxCommonTemplateDialog_Impl::StyleNrToInfoOffset(sal_uInt16 nId)
{
const SfxStyleFamilyItem *pItem=pStyleFamilies->GetObject(nId);
return SfxFamilyIdToNId(pItem->GetFamily())-1;
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::EnableEdit(sal_Bool bEnable)
{
SfxCommonTemplateDialog_Impl::EnableEdit( bEnable );
if( !bEnable || !bUpdateByExampleDisabled )
EnableItem( SID_STYLE_UPDATE_BY_EXAMPLE, bEnable);
}
//-------------------------------------------------------------------------
sal_uInt16 SfxCommonTemplateDialog_Impl::InfoOffsetToStyleNr(sal_uInt16 nId)
{
for ( sal_uInt16 i=0;i<pStyleFamilies->Count();i++ )
if ( SfxFamilyIdToNId(pStyleFamilies->GetObject(i)->GetFamily()) == nId+1 )
return i;
DBG_ERROR("Style Nummer nicht gefunden");
return 0;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::ReadResource()
{
// globale Benutzer-Resource auslesen
sal_uInt16 i;
for(i = 0; i < MAX_FAMILIES; ++i)
pFamilyState[i] = 0;
SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
pCurObjShell = pViewFrame->GetObjectShell();
ResMgr* pMgr = pCurObjShell ? pCurObjShell->GetResMgr() : NULL;
ResId aFamId( DLG_STYLE_DESIGNER, *pMgr );
aFamId.SetRT(RSC_SFX_STYLE_FAMILIES);
m_pStyleFamiliesId = new ResId( aFamId.GetId(), *pMgr );
m_pStyleFamiliesId->SetRT(RSC_SFX_STYLE_FAMILIES);
if( !pMgr || !pMgr->IsAvailable( aFamId ) )
pStyleFamilies = new SfxStyleFamilies;
else
pStyleFamilies = new SfxStyleFamilies( aFamId );
nActFilter = pCurObjShell ?
static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pCurObjShell ) ) :
SFX_TEMPLDLG_FILTER_MAX;
if ( pCurObjShell && SFX_TEMPLDLG_FILTER_MAX == nActFilter )
nActFilter = pCurObjShell->GetAutoStyleFilterIndex();
// Einfuegen in die Toolbox
// umgekehrte Reihenfolge, da immer vorne eingefuegt wird.
sal_uInt16 nCount = pStyleFamilies->Count();
pBindings->ENTERREGISTRATIONS();
for(i = 0; i < nCount; ++i)
{
sal_uInt16 nSlot = 0;
switch((sal_uInt16)pStyleFamilies->GetObject(i)->GetFamily())
{
case SFX_STYLE_FAMILY_CHAR: nSlot = SID_STYLE_FAMILY1; break;
case SFX_STYLE_FAMILY_PARA: nSlot = SID_STYLE_FAMILY2; break;
case SFX_STYLE_FAMILY_FRAME:nSlot = SID_STYLE_FAMILY3; break;
case SFX_STYLE_FAMILY_PAGE: nSlot = SID_STYLE_FAMILY4; break;
case SFX_STYLE_FAMILY_PSEUDO: nSlot = SID_STYLE_FAMILY5; break;
default: DBG_ERROR("unbekannte StyleFamily"); break;
}
pBoundItems[i] =
new SfxTemplateControllerItem(nSlot, *this, *pBindings);
}
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_WATERCAN, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_NEW_BY_EXAMPLE, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_UPDATE_BY_EXAMPLE, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_NEW, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_DRAGHIERARCHIE, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_EDIT, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_DELETE, *this, *pBindings);
pBoundItems[i++] = new SfxTemplateControllerItem(
SID_STYLE_FAMILY, *this, *pBindings);
pBindings->LEAVEREGISTRATIONS();
for(; i < COUNT_BOUND_FUNC; ++i)
pBoundItems[i] = 0;
StartListening(*pBindings);
//In umgekehrter Reihenfolge des Auftretens in den Stylefamilies einfuegen.
//Das ist fuer den Toolbar des Gestalters. Die Listbox des Kataloges achtet
//selbst auf korrekte Reihenfolge.
//Reihenfolgen: Reihenfolge in der Resource = Reihenfolge in Toolbar bzw.
//Listbox.
//Reihenfolge aufsteigender SIDs: Niedrige SIDs werden als erstes angezeigt,
//wenn Vorlagen mehrerer Familien aktiv sind.
// in the Writer the UpdateStyleByExample Toolbox button is removed and
// the NewStyle button gets a PopupMenu
if(nCount > 4)
ReplaceUpdateButtonByMenu();
for( ; nCount--; )
{
const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject( nCount );
sal_uInt16 nId = SfxFamilyIdToNId( pItem->GetFamily() );
InsertFamilyItem( nId, pItem );
}
LoadedFamilies();
sal_uInt16 nStart = SID_STYLE_FAMILY1;
sal_uInt16 nEnd = SID_STYLE_FAMILY4;
for ( i = nStart; i <= nEnd; i++ )
pBindings->Update(i);
pModule = pCurObjShell ? pCurObjShell->GetModule() : NULL;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::ClearResource()
{
ClearFamilyList();
DELETEX(pStyleFamilies);
sal_uInt16 i;
for ( i = 0; i < MAX_FAMILIES; ++i )
DELETEX(pFamilyState[i]);
for ( i = 0; i < COUNT_BOUND_FUNC; ++i )
delete pBoundItems[i];
pCurObjShell = NULL;
DELETEZ( m_pStyleFamiliesId );
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::Initialize()
{
// globale Benutzer-Resource auslesen
ReadResource();
pBindings->Invalidate( SID_STYLE_FAMILY );
pBindings->Update( SID_STYLE_FAMILY );
Update_Impl();
aFilterLb.SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, FilterSelectHdl ) );
aFmtLb.SetDoubleClickHdl( LINK( this, SfxCommonTemplateDialog_Impl, ApplyHdl ) );
aFmtLb.SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, FmtSelectHdl ) );
aFilterLb.Show();
aFmtLb.Show();
}
//-------------------------------------------------------------------------
SfxCommonTemplateDialog_Impl::~SfxCommonTemplateDialog_Impl()
{
String aEmpty;
if ( bIsWater )
Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
GetWindow()->Hide();
DELETEX(pStyleFamilies);
DELETEZ( m_pStyleFamiliesId );
sal_uInt16 i;
for ( i = 0; i < MAX_FAMILIES; ++i )
DELETEX(pFamilyState[i]);
for ( i = 0; i < COUNT_BOUND_FUNC; ++i )
delete pBoundItems[i];
if ( pStyleSheetPool )
EndListening(*pStyleSheetPool);
pStyleSheetPool = NULL;
delete pTreeBox;
delete pTimer;
if ( pbDeleted )
{
pbDeleted->bDead = true;
pbDeleted = NULL;
}
}
//-------------------------------------------------------------------------
sal_uInt16 SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SfxStyleFamily nFamily )
{
switch ( nFamily )
{
case SFX_STYLE_FAMILY_CHAR: return 1;
case SFX_STYLE_FAMILY_PARA: return 2;
case SFX_STYLE_FAMILY_FRAME: return 3;
case SFX_STYLE_FAMILY_PAGE: return 4;
case SFX_STYLE_FAMILY_PSEUDO: return 5;
default: return 0;
}
}
void SfxCommonTemplateDialog_Impl::SetAutomaticFilter()
{
sal_uInt16 nCount = aFilterLb.GetEntryCount();
for ( sal_uInt16 i = 0; i < nCount; ++i )
{
sal_uIntPtr nFlags = (sal_uIntPtr)aFilterLb.GetEntryData(i);
if ( SFXSTYLEBIT_AUTO == nFlags )
{
// automatic entry found -> select it
aFilterLb.SelectEntryPos(i);
// then call the handler to filter the styles
FilterSelect( i - 1 );
break;
}
}
}
//-------------------------------------------------------------------------
// Hilfsfunktion: Zugriff auf aktuelles Family-Item
const SfxStyleFamilyItem *SfxCommonTemplateDialog_Impl::GetFamilyItem_Impl() const
{
const sal_uInt16 nCount = pStyleFamilies->Count();
for(sal_uInt16 i = 0; i < nCount; ++i)
{
const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject(i);
// if(!pItem)continue;
sal_uInt16 nId = SfxFamilyIdToNId(pItem->GetFamily());
if(nId == nActFamily)
return pItem;
}
return 0;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::SelectStyle(const String &rStr)
{
const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
if ( !pItem )
return;
const SfxStyleFamily eFam = pItem->GetFamily();
SfxStyleSheetBase* pStyle = pStyleSheetPool->Find( rStr, eFam, SFXSTYLEBIT_ALL );
if( pStyle )
EnableEdit( !(pStyle->GetMask() & SFXSTYLEBIT_READONLY) );
else
EnableEdit(sal_False);
if ( pTreeBox )
{
if ( rStr.Len() )
{
SvLBoxEntry* pEntry = pTreeBox->First();
while ( pEntry )
{
if ( pTreeBox->GetEntryText( pEntry ) == rStr )
{
pTreeBox->MakeVisible( pEntry );
pTreeBox->Select( pEntry );
return;
}
pEntry = pTreeBox->Next( pEntry );
}
}
else
pTreeBox->SelectAll( sal_False );
}
else
{
sal_Bool bSelect = ( rStr.Len() > 0 );
if ( bSelect )
{
SvLBoxEntry* pEntry = (SvLBoxEntry*)aFmtLb.FirstVisible();
while ( pEntry && aFmtLb.GetEntryText( pEntry ) != rStr )
pEntry = (SvLBoxEntry*)aFmtLb.NextVisible( pEntry );
if ( !pEntry )
bSelect = sal_False;
else
{
aFmtLb.MakeVisible( pEntry );
aFmtLb.Select( pEntry );
bWaterDisabled = !HasSelectedStyle(); //added by BerryJia for fixing Bug76391 2003-1-22
FmtSelectHdl( NULL );
}
}
if ( !bSelect )
{
aFmtLb.SelectAll( sal_False );
EnableEdit(sal_False);
}
}
}
//-------------------------------------------------------------------------
String SfxCommonTemplateDialog_Impl::GetSelectedEntry() const
{
String aRet;
if ( pTreeBox )
{
SvLBoxEntry* pEntry = pTreeBox->FirstSelected();
if ( pEntry )
aRet = pTreeBox->GetEntryText( pEntry );
}
else
{
SvLBoxEntry* pEntry = aFmtLb.FirstSelected();
if ( pEntry )
aRet = aFmtLb.GetEntryText( pEntry );
}
return aRet;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::EnableTreeDrag( sal_Bool bEnable )
{
if ( pStyleSheetPool )
{
SfxStyleSheetBase* pStyle = pStyleSheetPool->First();
if ( pTreeBox )
{
if ( pStyle && pStyle->HasParentSupport() && bEnable )
pTreeBox->SetDragDropMode(SV_DRAGDROP_CTRL_MOVE);
else
pTreeBox->SetDragDropMode(SV_DRAGDROP_NONE);
}
}
bTreeDrag = bEnable;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::FillTreeBox()
{
DBG_ASSERT( pTreeBox, "FillTreeBox() without treebox");
if(pStyleSheetPool && nActFamily != SFX_TEMPLDLG_FILTER_MAX)
{
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
pStyleSheetPool->SetSearchMask(pItem->GetFamily(), SFXSTYLEBIT_ALL);
StyleTreeArr_Impl aArr;
SfxStyleSheetBase *pStyle = pStyleSheetPool->First();
if(pStyle && pStyle->HasParentSupport() && bTreeDrag )
pTreeBox->SetDragDropMode(SV_DRAGDROP_CTRL_MOVE);
else
pTreeBox->SetDragDropMode(SV_DRAGDROP_NONE);
while(pStyle)
{
StyleTree_ImplPtr pNew =
new StyleTree_Impl(pStyle->GetName(), pStyle->GetParent());
aArr.Insert(pNew, aArr.Count());
pStyle = pStyleSheetPool->Next();
}
MakeTree_Impl(aArr);
ExpandedEntries aEntries;
if(pTreeBox)
((const StyleTreeListBox_Impl *)pTreeBox)->
MakeExpanded_Impl( aEntries);
pTreeBox->SetUpdateMode( sal_False );
pTreeBox->Clear();
const sal_uInt16 nCount = aArr.Count();
for(sal_uInt16 i = 0; i < nCount; ++i)
FillBox_Impl(pTreeBox, aArr[i], aEntries);
// EnableEdit(sal_False);
EnableItem(SID_STYLE_WATERCAN,sal_False);
SfxTemplateItem* pState = pFamilyState[nActFamily-1];
if ( nCount )
pTreeBox->Expand( pTreeBox->First() );
for ( SvLBoxEntry* pEntry = pTreeBox->First(); pEntry; pEntry = pTreeBox->Next( pEntry ) )
{
if ( IsExpanded_Impl( aEntries, pTreeBox->GetEntryText( pEntry ) ) )
pTreeBox->Expand( pEntry );
}
pTreeBox->SetUpdateMode( sal_True );
String aStyle;
if(pState) //Aktuellen Eintrag selektieren
aStyle = pState->GetStyleName();
SelectStyle(aStyle);
EnableDelete();
}
}
//-------------------------------------------------------------------------
sal_Bool SfxCommonTemplateDialog_Impl::HasSelectedStyle() const
{
return pTreeBox? pTreeBox->FirstSelected() != 0:
aFmtLb.GetSelectionCount() != 0;
}
//-------------------------------------------------------------------------
// intern: Aktualisierung der Anzeige
void SfxCommonTemplateDialog_Impl::UpdateStyles_Impl(sal_uInt16 nFlags) // Flags, was aktualisiert werden soll (s.o.)
{
DBG_ASSERT(nFlags, "nichts zu tun");
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
if (!pItem)
{
// Ist beim Vorlagenkatalog der Fall
SfxTemplateItem **ppItem = pFamilyState;
const sal_uInt16 nFamilyCount = pStyleFamilies->Count();
sal_uInt16 n;
for(n=0;n<nFamilyCount;n++)
if(ppItem[StyleNrToInfoOffset(n)])break;
if ( n == nFamilyCount )
// passiert gelegentlich bei Beichten, Formularen etc.; weiss der Teufel warum
return;
ppItem+=StyleNrToInfoOffset(n);
nAppFilter = (*ppItem)->GetValue();
FamilySelect( StyleNrToInfoOffset(n)+1 );
pItem = GetFamilyItem_Impl();
}
const SfxStyleFamily eFam = pItem->GetFamily();
SfxFilterTupel *pT = pItem->GetFilterList().GetObject(nActFilter);
sal_uInt16 nFilter = pT ? pItem->GetFilterList().GetObject(nActFilter)->nFlags : 0;
if(!nFilter) // automatisch
nFilter = nAppFilter;
DBG_ASSERT(pStyleSheetPool, "kein StyleSheetPool");
if(pStyleSheetPool)
{
pStyleSheetPool->SetSearchMask(eFam, nFilter);
pItem = GetFamilyItem_Impl();
if((nFlags & UPDATE_FAMILY) == UPDATE_FAMILY)
{
CheckItem(nActFamily, sal_True); // Button in Toolbox checken
aFilterLb.SetUpdateMode(sal_False);
aFilterLb.Clear();
//insert hierarchical at the beginning
sal_uInt16 nPos = aFilterLb.InsertEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)), 0);
aFilterLb.SetEntryData( nPos, (void*)(sal_uIntPtr)SFXSTYLEBIT_ALL );
const SfxStyleFilter& rFilter = pItem->GetFilterList();
for(sal_uInt16 i = 0; i < rFilter.Count(); ++i)
{
sal_uIntPtr nFilterFlags = rFilter.GetObject(i)->nFlags;
nPos = aFilterLb.InsertEntry( rFilter.GetObject(i)->aName );
aFilterLb.SetEntryData( nPos, (void*)nFilterFlags );
}
if(nActFilter < aFilterLb.GetEntryCount() - 1)
aFilterLb.SelectEntryPos(nActFilter + 1);
else
{
nActFilter = 0;
aFilterLb.SelectEntryPos(1);
SfxFilterTupel *pActT = rFilter.GetObject(nActFilter);
sal_uInt16 nFilterFlags = pActT ? rFilter.GetObject(nActFilter)->nFlags : 0;
pStyleSheetPool->SetSearchMask(eFam, nFilterFlags);
}
//Falls in Treedarstellung wieder Family Hierarchie selektieren
if(pTreeBox)
aFilterLb.SelectEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)));
// show maximum 12 entries
aFilterLb.SetDropDownLineCount( MAX_FILTER_ENTRIES );
aFilterLb.SetUpdateMode(sal_True);
}
else
{
if( nActFilter < aFilterLb.GetEntryCount() - 1)
aFilterLb.SelectEntryPos(nActFilter + 1);
else
{
nActFilter = 0;
aFilterLb.SelectEntryPos(1);
}
}
if(nFlags & UPDATE_FAMILY_LIST)
{
// EnableEdit(sal_False);
EnableItem(SID_STYLE_WATERCAN,sal_False);
SfxStyleSheetBase *pStyle = pStyleSheetPool->First();
SvLBoxEntry* pEntry = aFmtLb.First();
SvStringsDtor aStrings;
while( pStyle )
{
//Bubblesort
for( sal_uInt16 nPos = aStrings.Count() + 1 ; nPos-- ;)
{
if( !nPos || *aStrings[nPos-1] < pStyle->GetName() )
{
// Die Namen stehen in den Styles, also nicht kopieren
// Reingefallen!: Writer hat insgesamt nur 1 Style
aStrings.Insert(
new String( pStyle->GetName() ), nPos );
break;
}
}
pStyle = pStyleSheetPool->Next();
}
sal_uInt16 nCount = aStrings.Count();
sal_uInt16 nPos = 0;
while( nPos < nCount && pEntry &&
*aStrings[ nPos ] == aFmtLb.GetEntryText( pEntry ) )
{
nPos++;
pEntry = aFmtLb.Next( pEntry );
}
if( nPos < nCount || pEntry )
{
// Box mit den Vorlagen fuellen
aFmtLb.SetUpdateMode(sal_False);
aFmtLb.Clear();
nPos = 0;
while( nPos < nCount )
aFmtLb.InsertEntry( *aStrings.GetObject( nPos++ ));
aFmtLb.SetUpdateMode(sal_True);
}
// aktuelle Vorlage anzeigen
SfxTemplateItem *pState = pFamilyState[nActFamily-1];
String aStyle;
if(pState) //Aktuellen Eintrag selektieren
aStyle = pState->GetStyleName();
SelectStyle(aStyle);
EnableDelete();
}
}
}
//-------------------------------------------------------------------------
// Aktualisierung Anzeige: Gie\skanne an/aus
void SfxCommonTemplateDialog_Impl::SetWaterCanState(const SfxBoolItem *pItem)
{
// EnableItem(SID_STYLE_WATERCAN, pItem != 0);
bWaterDisabled = pItem == 0;
//added by BerryJia for fixing Bug76391 2003-1-7
if(!bWaterDisabled)
bWaterDisabled = !HasSelectedStyle();
if(pItem && !bWaterDisabled)
{
CheckItem(SID_STYLE_WATERCAN, pItem->GetValue());
EnableItem( SID_STYLE_WATERCAN, sal_True );
}
else
if(!bWaterDisabled)
EnableItem(SID_STYLE_WATERCAN, sal_True);
else
EnableItem(SID_STYLE_WATERCAN, sal_False);
//Waehrend Giesskannenmodus Statusupdates ignorieren.
sal_uInt16 nCount=pStyleFamilies->Count();
pBindings->EnterRegistrations();
for(sal_uInt16 n=0; n<nCount; n++)
{
SfxControllerItem *pCItem=pBoundItems[n];
sal_Bool bChecked = pItem && pItem->GetValue();
if( pCItem->IsBound() == bChecked )
{
if( !bChecked )
pCItem->ReBind();
else
pCItem->UnBind();
}
}
pBindings->LeaveRegistrations();
}
//-------------------------------------------------------------------------
// Item mit dem Status einer Family wird kopiert und gemerkt
// (Aktualisierung erfolgt, wenn alle Stati aktualisiert worden sind.
// Siehe auch: <SfxBindings::AddDoneHdl(const Link &)>
void SfxCommonTemplateDialog_Impl::SetFamilyState( sal_uInt16 nSlotId, const SfxTemplateItem* pItem )
{
sal_uInt16 nIdx = nSlotId - SID_STYLE_FAMILY_START;
DELETEZ(pFamilyState[nIdx]);
if ( pItem )
pFamilyState[nIdx] = new SfxTemplateItem(*pItem);
bUpdate = sal_True;
// Wenn verwendete Vorlagen ( wie zum Teufel findet man das heraus ?? )
bUpdateFamily = sal_True;
}
//-------------------------------------------------------------------------
// Benachrichtigung durch SfxBindings, da"s die Aktualisierung
// beendet ist. St"o\st die Aktualisierung der Anzeige an.
void SfxCommonTemplateDialog_Impl::Update_Impl()
{
sal_Bool bDocChanged=sal_False;
SfxStyleSheetBasePool* pNewPool = NULL;
SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
SfxObjectShell* pDocShell = pViewFrame->GetObjectShell();
if( pDocShell )
pNewPool = pDocShell->GetStyleSheetPool();
if ( pNewPool != pStyleSheetPool && pDocShell )
{
SfxModule* pNewModule = pDocShell->GetModule();
if( pNewModule && pNewModule != pModule )
{
ClearResource();
ReadResource();
}
if ( pStyleSheetPool )
{
EndListening(*pStyleSheetPool);
pStyleSheetPool = 0;
}
if ( pNewPool )
{
StartListening(*pNewPool);
pStyleSheetPool = pNewPool;
bDocChanged=sal_True;
}
// InvalidateBindings();
}
if (bUpdateFamily)
UpdateFamily_Impl();
sal_uInt16 i;
for(i = 0; i < MAX_FAMILIES; ++i)
if(pFamilyState[i])
break;
if(i == MAX_FAMILIES || !pNewPool)
// nichts erlaubt
return;
SfxTemplateItem *pItem = 0;
// aktueller Bereich nicht innerhalb der erlaubten Bereiche
// oder Default
if(nActFamily == SFX_TEMPLDLG_FILTER_MAX || 0 == (pItem = pFamilyState[nActFamily-1] ) )
{
CheckItem(nActFamily, sal_False);
SfxTemplateItem **ppItem = pFamilyState;
const sal_uInt16 nFamilyCount = pStyleFamilies->Count();
sal_uInt16 n;
for(n=0;n<nFamilyCount;n++)
if(ppItem[StyleNrToInfoOffset(n)])break;
ppItem+=StyleNrToInfoOffset(n);
nAppFilter = (*ppItem)->GetValue();
FamilySelect( StyleNrToInfoOffset(n)+1 );
pItem = *ppItem;
}
else if( bDocChanged )
{
// andere DocShell -> alles neu
CheckItem( nActFamily, sal_True );
nActFilter = static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pDocShell ) );
if ( SFX_TEMPLDLG_FILTER_MAX == nActFilter )
nActFilter = pDocShell->GetAutoStyleFilterIndex();
nAppFilter = pItem->GetValue();
if(!pTreeBox)
{
UpdateStyles_Impl(UPDATE_FAMILY_LIST);
}
else
FillTreeBox();
}
else
{
// anderer Filter fuer automatisch
CheckItem( nActFamily, sal_True );
const SfxStyleFamilyItem *pStyleItem = GetFamilyItem_Impl();
if(0 == pStyleItem->GetFilterList().GetObject(nActFilter)->nFlags
&& nAppFilter != pItem->GetValue())
{
nAppFilter = pItem->GetValue();
if(!pTreeBox)
UpdateStyles_Impl(UPDATE_FAMILY_LIST);
else
FillTreeBox();
}
else
nAppFilter = pItem->GetValue();
}
const String aStyle(pItem->GetStyleName());
SelectStyle(aStyle);
EnableDelete();
EnableNew( bCanNew );
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxCommonTemplateDialog_Impl, TimeOut, Timer *, pTim )
{
(void)pTim; // unused
if(!bDontUpdate)
{
bDontUpdate=sal_True;
if(!pTreeBox)
UpdateStyles_Impl(UPDATE_FAMILY_LIST);
else
{
FillTreeBox();
SfxTemplateItem *pState = pFamilyState[nActFamily-1];
if(pState)
{
const String aStyle(pState->GetStyleName());
SelectStyle(aStyle);
EnableDelete();
}
}
bDontUpdate=sal_False;
DELETEZ(pTimer);
}
else
pTimer->Start();
return 0;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
{
// Aktualisierung anstossen
if(rHint.Type() == TYPE(SfxSimpleHint))
{
switch(((SfxSimpleHint&) rHint ).GetId())
{
case SFX_HINT_UPDATEDONE:
{
SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
if (
bUpdate &&
(
!IsCheckedItem(SID_STYLE_WATERCAN) ||
(pDocShell && pDocShell->GetStyleSheetPool() != pStyleSheetPool)
)
)
{
bUpdate = sal_False;
Update_Impl();
}
else if ( bUpdateFamily )
{
UpdateFamily_Impl();
}
if( pStyleSheetPool )
{
String aStr = GetSelectedEntry();
if( aStr.Len() && pStyleSheetPool )
{
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
if( !pItem ) break;
const SfxStyleFamily eFam = pItem->GetFamily();
SfxStyleSheetBase *pStyle =
pStyleSheetPool->Find(
aStr, eFam, SFXSTYLEBIT_ALL );
if( pStyle )
EnableEdit(
!(pStyle->GetMask() & SFXSTYLEBIT_READONLY) );
else
EnableEdit(sal_False);
}
}
break;
}
// noetig, wenn zwichen Dokumenten umgeschaltet wird,
// aber in beiden Dokumenten die gleiche Vorlage gilt.
// Nicht sofort Update_Impl rufen, fuer den Fall da\s eines
// der Dokumente ein internes InPlaceObjekt ist!
case SFX_HINT_DOCCHANGED:
bUpdate = sal_True;
break;
case SFX_HINT_DYING:
{
EndListening(*pStyleSheetPool);
pStyleSheetPool=0;
break;
}
}
}
// Timer nicht aufsetzen, wenn der StyleSheetPool in die Kiste geht, denn
// es kann sein, da\s sich ein neuer erst anmeldet, nachdem der Timer
// abgelaufen ist - macht sich schlecht in UpdateStyles_Impl() !
sal_uIntPtr nId = rHint.ISA(SfxSimpleHint) ? ( (SfxSimpleHint&)rHint ).GetId() : 0;
if(!bDontUpdate && nId != SFX_HINT_DYING &&
(rHint.Type() == TYPE(SfxStyleSheetPoolHint)||
rHint.Type() == TYPE(SfxStyleSheetHint) ||
rHint.Type() == TYPE( SfxStyleSheetHintExtended )))
{
if(!pTimer)
{
pTimer=new Timer;
pTimer->SetTimeout(500);
pTimer->SetTimeoutHdl(LINK(this,SfxCommonTemplateDialog_Impl,TimeOut));
}
pTimer->Start();
}
}
//-------------------------------------------------------------------------
// Anderer Filter; kann durch den Benutzer umgeschaltet werden
// oder als Folge von Neu oder Bearbeiten, wenn die aktuelle
// Vorlage einem anderen Filter zugewiesen wurde.
void SfxCommonTemplateDialog_Impl::FilterSelect(
sal_uInt16 nEntry, // Idx des neuen Filters
sal_Bool bForce ) // Aktualisierung erzwingen, auch wenn der neue Filter gleich dem aktuellen ist
{
if( nEntry != nActFilter || bForce )
{
nActFilter = nEntry;
SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
if (pDocShell)
{
pDocShell->SetAutoStyleFilterIndex(nActFilter);
SaveFactoryStyleFilter( pDocShell, nActFilter );
}
SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): 0;
if ( pOldStyleSheetPool != pStyleSheetPool )
{
if ( pOldStyleSheetPool )
EndListening(*pOldStyleSheetPool);
if ( pStyleSheetPool )
StartListening(*pOldStyleSheetPool);
}
UpdateStyles_Impl(UPDATE_FAMILY_LIST);
}
}
//-------------------------------------------------------------------------
// Intern: Ausf"uhren von Funktionen "uber den Dispatcher
sal_Bool SfxCommonTemplateDialog_Impl::Execute_Impl(
sal_uInt16 nId, const String &rStr, const String& rRefStr, sal_uInt16 nFamily,
sal_uInt16 nMask, sal_uInt16 *pIdx, const sal_uInt16* pModifier)
{
SfxDispatcher &rDispatcher = *SFX_APP()->GetDispatcher_Impl();
SfxStringItem aItem(nId, rStr);
SfxUInt16Item aFamily(SID_STYLE_FAMILY, nFamily);
SfxUInt16Item aMask( SID_STYLE_MASK, nMask );
SfxStringItem aUpdName(SID_STYLE_UPD_BY_EX_NAME, rStr);
SfxStringItem aRefName( SID_STYLE_REFERENCE, rRefStr );
const SfxPoolItem* pItems[ 6 ];
sal_uInt16 nCount = 0;
if( rStr.Len() )
pItems[ nCount++ ] = &aItem;
pItems[ nCount++ ] = &aFamily;
if( nMask )
pItems[ nCount++ ] = &aMask;
if(SID_STYLE_UPDATE_BY_EXAMPLE == nId)
{
//Sonderloesung fuer Numerierungsupdate im Writer
const String aTemplName(GetSelectedEntry());
aUpdName.SetValue(aTemplName);
pItems[ nCount++ ] = &aUpdName;
}
if ( rRefStr.Len() )
pItems[ nCount++ ] = &aRefName;
pItems[ nCount++ ] = 0;
// This unbelievably crude technique is used to detect and handle
// destruction of this during the synchronous slot call: store a
// pointer to a local bool, initialize it to false and set that it
// to true in the destructor.
Deleted aDeleted;
pbDeleted = &aDeleted;
sal_uInt16 nModi = pModifier ? *pModifier : 0;
const SfxPoolItem* pItem = rDispatcher.Execute(
nId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD | SFX_CALLMODE_MODAL,
pItems, nModi );
// FIXME: Dialog can be destroyed while in Execute() check stack variable for dtor flag!
if (aDeleted())
{
// this has been deleted in the previous synchronous slot
// call. Exit without touching anything.
return sal_False;
}
else
{
// this has not been deleted. Reset pbDeleted to prevent the
// destructor to access the local bool at a later and rather
// inconvenient time. See bugs 124392 and 100110 for more information.
pbDeleted = NULL;
}
if (pItem == NULL)
{
return sal_False;
}
if ( nId == SID_STYLE_NEW || SID_STYLE_EDIT == nId )
{
SfxUInt16Item *pFilterItem = PTR_CAST(SfxUInt16Item, pItem);
DBG_ASSERT(pFilterItem, "SfxUINT16Item erwartet");
sal_uInt16 nFilterFlags = pFilterItem->GetValue() & ~SFXSTYLEBIT_USERDEF;
if(!nFilterFlags) // Benutzervorlage?
nFilterFlags = pFilterItem->GetValue();
const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
const sal_uInt16 nFilterCount = (sal_uInt16) pFamilyItem->GetFilterList().Count();
for ( sal_uInt16 i = 0; i < nFilterCount; ++i )
{
const SfxFilterTupel *pTupel =
pFamilyItem->GetFilterList().GetObject(i);
if ( ( pTupel->nFlags & nFilterFlags ) == nFilterFlags && pIdx )
*pIdx = i;
}
}
return sal_True;
}
//-------------------------------------------------------------------------
// Handler der Listbox der Filter
IMPL_LINK( SfxCommonTemplateDialog_Impl, FilterSelectHdl, ListBox *, pBox )
{
if ( pBox->GetSelectEntry() == String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)) )
{
if ( !bHierarchical )
{
// TreeView einschalten
bHierarchical=sal_True;
const String aSelectEntry( GetSelectedEntry());
aFmtLb.Hide();
// aFilterLb.Disable();
pTreeBox = new StyleTreeListBox_Impl(
this, WB_HASBUTTONS | WB_HASLINES |
WB_BORDER | WB_TABSTOP | WB_HASLINESATROOT |
WB_HASBUTTONSATROOT | WB_HIDESELECTION | WB_QUICK_SEARCH );
pTreeBox->SetFont( aFmtLb.GetFont() );
pTreeBox->SetPosSizePixel(aFmtLb.GetPosPixel(), aFmtLb.GetSizePixel());
pTreeBox->SetNodeDefaultImages();
pTreeBox->SetSelectHdl(
LINK(this, SfxCommonTemplateDialog_Impl, FmtSelectHdl));
((StyleTreeListBox_Impl*)pTreeBox)->
SetDoubleClickHdl(
LINK(this, SfxCommonTemplateDialog_Impl, ApplyHdl));
((StyleTreeListBox_Impl*)pTreeBox)->
SetDropHdl(LINK(this, SfxCommonTemplateDialog_Impl, DropHdl));
pTreeBox->SetIndent(10);
FillTreeBox();
SelectStyle(aSelectEntry);
pTreeBox->SetAccessibleName(SfxResId(STR_STYLE_ELEMTLIST));
pTreeBox->Show();
// Save the filter state
SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
if (pDocShell)
{
// only in the configuration
// SetAutoStyleFilterIndex would update nActFilter
// which should only contain a valid listbox entry
SaveFactoryStyleFilter( pDocShell, SFX_TEMPLDLG_FILTER_HIERARCHICAL );
}
}
}
else
{
DELETEZ(pTreeBox);
aFmtLb.Show();
// aFilterLb.Enable();
// Falls bHierarchical, kann sich die Familie geaendert haben
// minus one since hierarchical is inserted at the start
FilterSelect(pBox->GetSelectEntryPos() - 1, bHierarchical );
bHierarchical=sal_False;
// UpdateStyles_Impl(UPDATE_FAMILY_LIST); // Anzeige aktualisieren
}
return 0;
}
//-------------------------------------------------------------------------
// Select-Handler der Toolbox
void SfxCommonTemplateDialog_Impl::FamilySelect(sal_uInt16 nEntry)
{
if( nEntry != nActFamily )
{
CheckItem( nActFamily, sal_False );
nActFamily = nEntry;
SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
SfxUInt16Item aItem( SID_STYLE_FAMILY, nEntry );
pDispat->Execute( SID_STYLE_FAMILY, SFX_CALLMODE_SYNCHRON, &aItem, 0L );
pBindings->Invalidate( SID_STYLE_FAMILY );
pBindings->Update( SID_STYLE_FAMILY );
UpdateFamily_Impl();
}
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::ActionSelect(sal_uInt16 nEntry)
{
String aEmpty;
switch(nEntry)
{
case SID_STYLE_WATERCAN:
{
const sal_Bool bState = IsCheckedItem(nEntry);
sal_Bool bCheck;
SfxBoolItem aBool;
// wenn eine Vorlage ausgewaehlt ist.
if(!bState && aFmtLb.GetSelectionCount())
{
const String aTemplName(
GetSelectedEntry());
Execute_Impl(
SID_STYLE_WATERCAN, aTemplName, aEmpty,
(sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
bCheck = sal_True;
}
else
{
Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
bCheck = sal_False;
}
CheckItem(nEntry, bCheck);
aBool.SetValue(bCheck);
SetWaterCanState(&aBool);
break;
}
case SID_STYLE_NEW_BY_EXAMPLE:
{
if(pStyleSheetPool && nActFamily != SFX_TEMPLDLG_FILTER_MAX)
{
const SfxStyleFamily eFam=GetFamilyItem_Impl()->GetFamily();
//pStyleSheetPool->GetSearchFamily();
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
sal_uInt16 nFilter;
if(pItem&&nActFilter!=SFX_TEMPLDLG_FILTER_MAX)
{
nFilter = pItem->GetFilterList().GetObject(
nActFilter)->nFlags;
if(!nFilter) // automatisch
nFilter = nAppFilter;
}
else
nFilter=pStyleSheetPool->GetSearchMask();
pStyleSheetPool->SetSearchMask( eFam, SFXSTYLEBIT_USERDEF );
SfxNewStyleDlg *pDlg =
// why? : FloatingWindow must not be parent of a modal dialog
new SfxNewStyleDlg(pWindow, *pStyleSheetPool);
if(RET_OK == pDlg->Execute())
{
pStyleSheetPool->SetSearchMask(eFam, nFilter);
const String aTemplName(pDlg->GetName());
Execute_Impl(SID_STYLE_NEW_BY_EXAMPLE,
aTemplName, aEmpty,
(sal_uInt16)GetFamilyItem_Impl()->GetFamily(),
nFilter);
}
pStyleSheetPool->SetSearchMask( eFam, nFilter );
delete pDlg;
}
break;
}
case SID_STYLE_UPDATE_BY_EXAMPLE:
{
Execute_Impl(SID_STYLE_UPDATE_BY_EXAMPLE,
aEmpty, aEmpty,
(sal_uInt16)GetFamilyItem_Impl()->GetFamily());
break;
}
case SID_TEMPLATE_LOAD:
SFX_APP()->GetDispatcher_Impl()->Execute(nEntry);
break;
default: DBG_ERROR("not implemented"); break;
}
}
//-------------------------------------------------------------------------
static rtl::OUString getModuleIdentifier( const Reference< XModuleManager >& i_xModMgr, SfxObjectShell* i_pObjSh )
{
DBG_ASSERT( i_xModMgr.is(), "getModuleIdentifier(): no XModuleManager" );
DBG_ASSERT( i_pObjSh, "getModuleIdentifier(): no ObjectShell" );
::rtl::OUString sIdentifier;
try
{
sIdentifier = i_xModMgr->identify( i_pObjSh->GetModel() );
}
catch ( ::com::sun::star::frame::UnknownModuleException& )
{
DBG_WARNING( "getModuleIdentifier(): unknown module" );
}
catch ( Exception& )
{
DBG_ERRORFILE( "getModuleIdentifier(): exception of XModuleManager::identify()" );
}
return sIdentifier;
}
//-------------------------------------------------------------------------
sal_Int32 SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter( SfxObjectShell* i_pObjSh )
{
DBG_ASSERT( i_pObjSh, "SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter(): no ObjectShell" );
sal_Int32 nFilter = -1;
Sequence< PropertyValue > lProps;
Reference< ::com::sun::star::container::XNameAccess > xContainer( xModuleManager, UNO_QUERY );
if ( xContainer.is() )
{
::comphelper::SequenceAsHashMap aFactoryProps(
xContainer->getByName( getModuleIdentifier( xModuleManager, i_pObjSh ) ) );
sal_Int32 nDefault = -1;
nFilter = aFactoryProps.getUnpackedValueOrDefault( DEFINE_CONST_UNICODE("ooSetupFactoryStyleFilter"), nDefault );
}
return nFilter;
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::SaveFactoryStyleFilter( SfxObjectShell* i_pObjSh, sal_Int32 i_nFilter )
{
DBG_ASSERT( i_pObjSh, "SfxCommonTemplateDialog_Impl::SaveFactoryStyleFilter(): no ObjectShell" );
Reference< ::com::sun::star::container::XNameReplace > xContainer( xModuleManager, UNO_QUERY );
if ( xContainer.is() )
{
Sequence< PropertyValue > lProps(1);
lProps[0].Name = DEFINE_CONST_UNICODE("ooSetupFactoryStyleFilter");
lProps[0].Value = makeAny( i_nFilter );;
xContainer->replaceByName( getModuleIdentifier( xModuleManager, i_pObjSh ), makeAny( lProps ) );
}
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxCommonTemplateDialog_Impl, DropHdl, StyleTreeListBox_Impl *, pBox )
{
bDontUpdate=sal_True;
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
const SfxStyleFamily eFam = pItem->GetFamily();
long ret= pStyleSheetPool->SetParent(eFam,pBox->GetStyle(), pBox->GetParent())? 1L: 0L;
bDontUpdate=sal_False;
return ret;
}
//-------------------------------------------------------------------------
// Handler des Neu-Buttons
void SfxCommonTemplateDialog_Impl::NewHdl(void *)
{
String aEmpty;
if ( nActFamily != SFX_TEMPLDLG_FILTER_MAX )
{
Window* pTmp;
pTmp = Application::GetDefDialogParent();
if ( ISA(SfxTemplateDialog_Impl) )
Application::SetDefDialogParent( pWindow->GetParent() );
else
Application::SetDefDialogParent( pWindow );
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
const SfxStyleFamily eFam=pItem->GetFamily();
sal_uInt16 nMask;
if(pItem&&nActFilter!=SFX_TEMPLDLG_FILTER_MAX)
{
nMask = pItem->GetFilterList().GetObject(
nActFilter)->nFlags;
if(!nMask) // automatisch
nMask = nAppFilter;
}
else
nMask=pStyleSheetPool->GetSearchMask();
pStyleSheetPool->SetSearchMask(eFam,nMask);
Execute_Impl(SID_STYLE_NEW,
aEmpty, GetSelectedEntry(),
( sal_uInt16 )GetFamilyItem_Impl()->GetFamily(),
nMask);
Application::SetDefDialogParent( pTmp );
/* {
DBG_ASSERT(nFilter < aFilterLb.GetEntryCount(),
"Filter ueberindiziert");
if(!pTreeBox)
{
// aFilterLb.SelectEntryPos(nFilter);
FilterSelect(nActFilter, sal_True);
}
else
{
FillTreeBox();
SfxTemplateItem *pState = pFamilyState[nActFamily-1];
if(pState)
{
const String aStyle(pState->GetStyleName());
SelectStyle(aStyle);
}
EnableDelete();
}*/
// }
}
}
//-------------------------------------------------------------------------
// Handler des Bearbeiten-Buttons
void SfxCommonTemplateDialog_Impl::EditHdl(void *)
{
if(IsInitialized() && HasSelectedStyle())
{
sal_uInt16 nFilter = nActFilter;
String aTemplName(GetSelectedEntry());
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
const SfxStyleFamily eFam = pItem->GetFamily();
pStyleSheetPool->Find(aTemplName,eFam,SFXSTYLEBIT_ALL); // -Wall required??
Window* pTmp;
//DefModalDialogParent setzen fuer
//Modalitaet der nachfolgenden Dialoge
pTmp = Application::GetDefDialogParent();
if ( ISA(SfxTemplateDialog_Impl) )
Application::SetDefDialogParent( pWindow->GetParent() );
else
Application::SetDefDialogParent( pWindow );
if ( Execute_Impl( SID_STYLE_EDIT, aTemplName, String(),
(sal_uInt16)GetFamilyItem_Impl()->GetFamily(), 0, &nFilter ) )
{
// DBG_ASSERT(nFilter < aFilterLb.GetEntryCount(), "Filter ueberindiziert");
// aTemplName = pStyle->GetName();
// kann durch Bearbeiten umbenannt worden sein
/* if(!pTreeBox)
{
// aFilterLb.SelectEntryPos(nFilter);
// FilterSelect(nFilter, sal_True);
}
else
FillTreeBox();*/
}
Application::SetDefDialogParent( pTmp );
}
}
//-------------------------------------------------------------------------
// Handler des L"oschen-Buttons
void SfxCommonTemplateDialog_Impl::DeleteHdl(void *)
{
if ( IsInitialized() && HasSelectedStyle() )
{
const String aTemplName( GetSelectedEntry() );
const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
SfxStyleSheetBase* pStyle =
pStyleSheetPool->Find( aTemplName, pItem->GetFamily(), SFXSTYLEBIT_ALL );
if ( pStyle )
{
String aMsg;
if ( pStyle->IsUsed() )
aMsg = String( SfxResId( STR_DELETE_STYLE_USED ) );
aMsg += String ( SfxResId( STR_DELETE_STYLE ) );
aMsg.SearchAndReplaceAscii( "$1", aTemplName );
#if defined UNX
QueryBox aBox( SFX_APP()->GetTopWindow(), WB_YES_NO | WB_DEF_NO, aMsg );
#else
QueryBox aBox( GetWindow(), WB_YES_NO | WB_DEF_NO , aMsg );
#endif
if ( RET_YES == aBox.Execute() )
{
PrepareDeleteAction();
if ( pTreeBox ) // Damit die Treelistbox beim L"oschen nicht zuklappt
{
bDontUpdate = sal_True;
}
Execute_Impl( SID_STYLE_DELETE, aTemplName,
String(), (sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
if ( pTreeBox )
{
pTreeBox->RemoveParentKeepChilds( pTreeBox->FirstSelected() );
bDontUpdate = sal_False;
}
}
}
}
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::EnableDelete()
{
if(IsInitialized() && HasSelectedStyle())
{
DBG_ASSERT(pStyleSheetPool, "Kein StyleSheetPool");
const String aTemplName(GetSelectedEntry());
const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
const SfxStyleFamily eFam = pItem->GetFamily();
sal_uInt16 nFilter = 0;
if(pItem->GetFilterList().Count() > nActFilter)
nFilter = pItem->GetFilterList().GetObject(nActFilter)->nFlags;
if(!nFilter) // automatisch
nFilter = nAppFilter;
const SfxStyleSheetBase *pStyle =
pStyleSheetPool->Find(aTemplName,eFam,
pTreeBox? SFXSTYLEBIT_ALL: nFilter);
DBG_ASSERT(pStyle, "Style nicht gefunden");
if(pStyle && pStyle->IsUserDefined())
{
EnableDel(sal_True);
}
else
{
EnableDel(sal_False);
}
}
else
{
EnableDel(sal_False);
}
// rBindings.Invalidate( SID_STYLE_DELETE );
// rBindings.Update( SID_STYLE_DELETE );
}
//-------------------------------------------------------------------------
// nach Selektion eines Eintrags den Focus gfs. wieder auf das App-Fenster
// setzen
void SfxCommonTemplateDialog_Impl::ResetFocus()
{
if(ISA(SfxTemplateDialog_Impl))
{
SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
SfxViewShell *pVu = pViewFrame->GetViewShell();
Window *pAppWin = pVu ? pVu->GetWindow(): 0;
if(pAppWin)
pAppWin->GrabFocus();
}
}
//-------------------------------------------------------------------------
// Doppelclick auf ein StyleSheet in der ListBox, wird angewendet.
IMPL_LINK( SfxCommonTemplateDialog_Impl, ApplyHdl, Control *, pControl )
{
(void)pControl; //unused
// nur, wenn dieser Bereich erlaubt ist
if ( IsInitialized() && 0 != pFamilyState[nActFamily-1] &&
GetSelectedEntry().Len() )
{
sal_uInt16 nModifier = aFmtLb.GetModifier();
Execute_Impl(SID_STYLE_APPLY,
GetSelectedEntry(), String(),
( sal_uInt16 )GetFamilyItem_Impl()->GetFamily(),
0, 0, &nModifier );
if(ISA(SfxTemplateCatalog_Impl))
((SfxTemplateCatalog_Impl*) this)->pReal->EndDialog(RET_OK);
}
ResetFocus();
return 0;
}
//-------------------------------------------------------------------------
// Selektion einer Vorlage w"ahrend des Watercan-Status
IMPL_LINK( SfxCommonTemplateDialog_Impl, FmtSelectHdl, SvTreeListBox *, pListBox )
{
// HilfePI antriggern, wenn von Call als Handler und Bereich erlaubt ist
if( !pListBox || pListBox->IsSelected( pListBox->GetHdlEntry() ) )
{
// nur, wenn Giesskanne an ist
if ( IsInitialized() &&
IsCheckedItem(SID_STYLE_WATERCAN) &&
// nur, wenn dieser Bereich erlaubt ist
0 != pFamilyState[nActFamily-1] )
{
String aEmpty;
Execute_Impl(SID_STYLE_WATERCAN,
aEmpty, aEmpty, 0);
Execute_Impl(SID_STYLE_WATERCAN,
GetSelectedEntry(), aEmpty,
( sal_uInt16 )GetFamilyItem_Impl()->GetFamily());
}
// EnableEdit(sal_True);
EnableItem(SID_STYLE_WATERCAN, !bWaterDisabled);
EnableDelete();
}
if( pListBox )
SelectStyle( pListBox->GetEntryText( pListBox->GetHdlEntry() ));
return 0;
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxCommonTemplateDialog_Impl, MenuSelectHdl, Menu *, pMenu )
{
if( pMenu )
{
nLastItemId = pMenu->GetCurItemId();
Application::PostUserEvent(
LINK( this, SfxCommonTemplateDialog_Impl, MenuSelectHdl ), 0 );
return sal_True;
}
switch(nLastItemId) {
case ID_NEW: NewHdl(0); break;
case ID_EDIT: EditHdl(0); break;
case ID_DELETE: DeleteHdl(0); break;
default: return sal_False;
}
return sal_True;
}
// -----------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::ExecuteContextMenu_Impl( const Point& rPos, Window* pWin )
{
// Bug# 94152: This part should never be called, because before this happens, the TreeListBox should captured this!
DBG_ASSERT( sal_False, "+SfxCommonTemplateDialog_Impl::ExecuteContextMenu_Impl(): How could this happen? Please infirm developer ASAP!" );
PopupMenu* pMenu = CreateContextMenu();
pMenu->Execute( pWin, rPos );
delete pMenu;
}
// -----------------------------------------------------------------------
SfxStyleFamily SfxCommonTemplateDialog_Impl::GetActualFamily() const
{
const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
if( !pFamilyItem || nActFamily == SFX_TEMPLDLG_FILTER_MAX )
return SFX_STYLE_FAMILY_PARA;
else
return pFamilyItem->GetFamily();
}
// -----------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::EnableExample_Impl(sal_uInt16 nId, sal_Bool bEnable)
{
if( nId == SID_STYLE_NEW_BY_EXAMPLE )
bNewByExampleDisabled = !bEnable;
else if( nId == SID_STYLE_UPDATE_BY_EXAMPLE )
bUpdateByExampleDisabled = !bEnable;
EnableItem(nId, bEnable);
}
void SfxCommonTemplateDialog_Impl::PrepareDeleteAction()
{
}
// -----------------------------------------------------------------------
PopupMenu* SfxCommonTemplateDialog_Impl::CreateContextMenu( void )
{
if ( bBindingUpdate )
{
pBindings->Invalidate( SID_STYLE_NEW, sal_True, sal_False );
pBindings->Update( SID_STYLE_NEW );
bBindingUpdate = sal_False;
}
PopupMenu* pMenu = new PopupMenu( SfxResId( MN_CONTEXT_TEMPLDLG ) );
pMenu->SetSelectHdl( LINK( this, SfxCommonTemplateDialog_Impl, MenuSelectHdl ) );
pMenu->EnableItem( ID_EDIT, bCanEdit );
pMenu->EnableItem( ID_DELETE, bCanDel );
pMenu->EnableItem( ID_NEW, bCanNew );
return pMenu;
}
// ------------------------------------------------------------------------
SfxTemplateDialog_Impl::SfxTemplateDialog_Impl(
SfxBindings* pB, SfxTemplateDialog* pDlgWindow ) :
SfxCommonTemplateDialog_Impl( pB, pDlgWindow, true ),
m_pFloat ( pDlgWindow ),
m_bZoomIn ( sal_False ),
m_aActionTbL ( pDlgWindow, this ),
m_aActionTbR ( pDlgWindow, SfxResId( TB_ACTION ) )
{
pDlgWindow->FreeResource();
Initialize();
}
SfxTemplateDialog_Impl::SfxTemplateDialog_Impl(
SfxBindings* pB, SfxTemplatePanelControl* pDlgWindow )
: SfxCommonTemplateDialog_Impl( pB, pDlgWindow, true ),
m_pFloat ( pDlgWindow ),
m_bZoomIn ( sal_False ),
m_aActionTbL ( pDlgWindow, this ),
m_aActionTbR ( pDlgWindow, SfxResId( TB_ACTION ) )
{
pDlgWindow->FreeResource();
Initialize();
}
void SfxTemplateDialog_Impl::Initialize (void)
{
// Read the filter stored in the configuration
// This is already done in ReadResource(), invoked by Initialize()
// and stored in nActFilter, but we can't rely on nActFilter's value
// because it is changed in UpdateStyles_Impl
SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
pCurObjShell = pViewFrame->GetObjectShell();
const sal_uInt16 nConfigFilter = pCurObjShell ?
static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pCurObjShell ) ) : 0;
SfxCommonTemplateDialog_Impl::Initialize();
m_aActionTbL.SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxLSelect));
m_aActionTbR.SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxRSelect));
m_aActionTbR.SetDropdownClickHdl(LINK(this, SfxTemplateDialog_Impl, ToolBoxRClick));
m_aActionTbL.Show();
m_aActionTbR.Show();
Font aFont=aFilterLb.GetFont();
aFont.SetWeight( WEIGHT_NORMAL );
aFilterLb.SetFont( aFont );
m_aActionTbL.SetHelpId( HID_TEMPLDLG_TOOLBOX_LEFT );
if ( nConfigFilter == SFX_TEMPLDLG_FILTER_HIERARCHICAL )
{
bHierarchical = sal_False;
aFilterLb.SelectEntry(String(SfxResId(STR_STYLE_FILTER_HIERARCHICAL)));
FilterSelectHdl(&aFilterLb);
}
}
// ------------------------------------------------------------------------
void SfxTemplateDialog_Impl::EnableFamilyItem( sal_uInt16 nId, sal_Bool bEnable )
{
m_aActionTbL.EnableItem( nId, bEnable );
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::InsertFamilyItem(sal_uInt16 nId,const SfxStyleFamilyItem *pItem)
{
rtl::OString sHelpId;
switch( (sal_uInt16) pItem->GetFamily() )
{
case SFX_STYLE_FAMILY_CHAR: sHelpId = ".uno:CharStyle"; break;
case SFX_STYLE_FAMILY_PARA: sHelpId = ".uno:ParaStyle"; break;
case SFX_STYLE_FAMILY_FRAME: sHelpId = ".uno:FrameStyle"; break;
case SFX_STYLE_FAMILY_PAGE: sHelpId = ".uno:PageStyle"; break;
case SFX_STYLE_FAMILY_PSEUDO: sHelpId = ".uno:ListStyle"; break;
default: DBG_ERROR("unknown StyleFamily"); break;
}
m_aActionTbL.InsertItem( nId, pItem->GetImage(), pItem->GetText(), 0, 0);
m_aActionTbL.SetHelpId( nId, sHelpId );
}
// ------------------------------------------------------------------------
void SfxTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
{
m_aActionTbR.HideItem(SID_STYLE_UPDATE_BY_EXAMPLE);
m_aActionTbR.SetItemBits( SID_STYLE_NEW_BY_EXAMPLE,
TIB_DROPDOWNONLY|m_aActionTbR.GetItemBits( SID_STYLE_NEW_BY_EXAMPLE ));
}
// ------------------------------------------------------------------------
void SfxTemplateDialog_Impl::updateFamilyImages()
{
if ( !m_pStyleFamiliesId )
// we do not have a resource id to load the new images from
return;
// let the families collection update the images
sal_Bool bIsHighContrast;
if (m_pFloat != NULL)
bIsHighContrast = m_pFloat->GetSettings().GetStyleSettings().GetHighContrastMode();
else
bIsHighContrast = false;
pStyleFamilies->updateImages( *m_pStyleFamiliesId, bIsHighContrast ? BMP_COLOR_HIGHCONTRAST : BMP_COLOR_NORMAL );
// and set the new images on our toolbox
sal_uInt16 nLoop = pStyleFamilies->Count();
for( ; nLoop--; )
{
const SfxStyleFamilyItem *pItem = pStyleFamilies->GetObject( nLoop );
sal_uInt16 nId = SfxFamilyIdToNId( pItem->GetFamily() );
m_aActionTbL.SetItemImage( nId, pItem->GetImage() );
}
}
// ------------------------------------------------------------------------
void SfxTemplateDialog_Impl::updateNonFamilyImages()
{
if (m_pFloat != NULL)
m_aActionTbR.SetImageList( ImageList( SfxResId(
m_pFloat->GetSettings().GetStyleSettings().GetHighContrastMode() ? IMG_LST_STYLE_DESIGNER_HC
: DLG_STYLE_DESIGNER ) ) );
}
// ------------------------------------------------------------------------
void SfxTemplateDialog_Impl::ClearFamilyList()
{
m_aActionTbL.Clear();
}
//-------------------------------------------------------------------------
void SfxCommonTemplateDialog_Impl::InvalidateBindings()
{
pBindings->Invalidate(SID_STYLE_NEW_BY_EXAMPLE, sal_True, sal_False);
pBindings->Update( SID_STYLE_NEW_BY_EXAMPLE );
pBindings->Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE, sal_True, sal_False);
pBindings->Update( SID_STYLE_UPDATE_BY_EXAMPLE );
pBindings->Invalidate( SID_STYLE_WATERCAN, sal_True, sal_False);
pBindings->Update( SID_STYLE_WATERCAN );
pBindings->Invalidate( SID_STYLE_NEW, sal_True, sal_False );
pBindings->Update( SID_STYLE_NEW );
pBindings->Invalidate( SID_STYLE_DRAGHIERARCHIE, sal_True, sal_False );
pBindings->Update( SID_STYLE_DRAGHIERARCHIE );
}
//-------------------------------------------------------------------------
SfxTemplateDialog_Impl::~SfxTemplateDialog_Impl()
{
/*
SfxImageManager* pImgMgr = pBindings->GetImageManager();
if ( pImgMgr )
{
pImgMgr->ReleaseToolBox( &m_aActionTbL );
pImgMgr->ReleaseToolBox( &m_aActionTbR );
}
*/
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::LoadedFamilies()
{
updateFamilyImages();
Resize();
}
//-------------------------------------------------------------------------
// "Uberladener Resize-Handler ( StarView )
// Die Groesse der Listboxen wird angepasst
void SfxTemplateDialog_Impl::Resize()
{
SfxDockingWindow* pDockingWindow = dynamic_cast<SfxDockingWindow*>(m_pFloat);
FloatingWindow *pF = pDockingWindow!=NULL ? pDockingWindow->GetFloatingWindow() : NULL;
if ( pF )
{
// if(pF->IsZoomedIn() && m_bZoomIn==sal_False)
// pF->SetText(String(SfxResId( DLG_STYLE_DESIGNER )));
// if(!pF->IsZoomedIn() && m_bZoomIn==sal_True && GetFamilyItem_Impl())
// UpdateStyles_Impl(UPDATE_FAMILY); //Bereich wieder in Titel schreiben
m_bZoomIn = pF->IsRollUp();
if ( m_bZoomIn )
return;
}
if (m_pFloat == NULL)
return;
Size aDlgSize=m_pFloat->PixelToLogic(m_pFloat->GetOutputSizePixel());
Size aSizeATL=m_pFloat->PixelToLogic(m_aActionTbL.CalcWindowSizePixel());
Size aSizeATR=m_pFloat->PixelToLogic(m_aActionTbR.CalcWindowSizePixel());
Size aMinSize = GetMinOutputSizePixel();
long nListHeight = m_pFloat->PixelToLogic( aFilterLb.GetSizePixel() ).Height();
long nWidth = aDlgSize.Width()- 2 * SFX_TEMPLDLG_HFRAME;
m_aActionTbL.SetPosSizePixel(m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME,SFX_TEMPLDLG_VTOPFRAME)),
m_pFloat->LogicToPixel(aSizeATL));
// Die Position der rechten Toolbox nur ver"andern, wenn das Fenster
// breit genug ist
Point aPosATR(aDlgSize.Width()-SFX_TEMPLDLG_HFRAME-aSizeATR.Width(),SFX_TEMPLDLG_VTOPFRAME);
if(aDlgSize.Width() >= aMinSize.Width())
m_aActionTbR.SetPosPixel(m_pFloat->LogicToPixel(aPosATR));
else
m_aActionTbR.SetPosPixel( m_pFloat->LogicToPixel(
Point( SFX_TEMPLDLG_HFRAME + aSizeATL.Width() + SFX_TEMPLDLG_MIDHSPACE,
SFX_TEMPLDLG_VTOPFRAME ) ) );
m_aActionTbR.SetSizePixel(m_pFloat->LogicToPixel(aSizeATR));
Point aFilterPos(
m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME,
aDlgSize.Height()-SFX_TEMPLDLG_VBOTFRAME-nListHeight)) );
Size aFilterSize(
m_pFloat->LogicToPixel(Size(nWidth,SFX_TEMPLDLG_FILTERHEIGHT)) );
Point aFmtPos(
m_pFloat->LogicToPixel(Point(SFX_TEMPLDLG_HFRAME, SFX_TEMPLDLG_VTOPFRAME +
SFX_TEMPLDLG_MIDVSPACE+aSizeATL.Height())) );
Size aFmtSize(
m_pFloat->LogicToPixel(Size(nWidth,
aDlgSize.Height() - SFX_TEMPLDLG_VBOTFRAME -
SFX_TEMPLDLG_VTOPFRAME - 2*SFX_TEMPLDLG_MIDVSPACE-
nListHeight-aSizeATL.Height())) );
// Die Position der Listboxen nur ver"andern, wenn das Fenster
// hoch genug ist
if(aDlgSize.Height() >= aMinSize.Height())
{
aFilterLb.SetPosPixel(aFilterPos);
aFmtLb.SetPosPixel( aFmtPos );
if(pTreeBox)
pTreeBox->SetPosPixel(aFmtPos);
}
else
aFmtSize.Height() += aFilterSize.Height();
aFilterLb.SetSizePixel(aFilterSize);
aFmtLb.SetSizePixel( aFmtSize );
if(pTreeBox)
pTreeBox->SetSizePixel(aFmtSize);
}
// -----------------------------------------------------------------------
Size SfxTemplateDialog_Impl::GetMinOutputSizePixel()
{
if (m_pFloat != NULL)
{
Size aSizeATL=m_pFloat->PixelToLogic(m_aActionTbL.CalcWindowSizePixel());
Size aSizeATR=m_pFloat->PixelToLogic(m_aActionTbR.CalcWindowSizePixel());
Size aMinSize=Size(
aSizeATL.Width()+aSizeATR.Width()+
2*SFX_TEMPLDLG_HFRAME + SFX_TEMPLDLG_MIDHSPACE,
4*aSizeATL.Height()+2*SFX_TEMPLDLG_MIDVSPACE);
return aMinSize;
}
else
return Size(0,0);
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::Command( const CommandEvent& rCEvt )
{
if (m_pFloat != NULL)
if(COMMAND_CONTEXTMENU == rCEvt.GetCommand())
ExecuteContextMenu_Impl( rCEvt.GetMousePosPixel(), m_pFloat );
else
m_pFloat->Command(rCEvt);
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::EnableItem(sal_uInt16 nMesId, sal_Bool bCheck)
{
String aEmpty;
switch(nMesId)
{
case SID_STYLE_WATERCAN :
if(!bCheck && IsCheckedItem(SID_STYLE_WATERCAN))
Execute_Impl(SID_STYLE_WATERCAN, aEmpty, aEmpty, 0);
case SID_STYLE_NEW_BY_EXAMPLE:
case SID_STYLE_UPDATE_BY_EXAMPLE:
m_aActionTbR.EnableItem(nMesId,bCheck);
break;
}
}
//-------------------------------------------------------------------------
void SfxTemplateDialog_Impl::CheckItem(sal_uInt16 nMesId, sal_Bool bCheck)
{
switch(nMesId)
{
case SID_STYLE_WATERCAN :
bIsWater=bCheck;
m_aActionTbR.CheckItem(SID_STYLE_WATERCAN,bCheck);
break;
default:
m_aActionTbL.CheckItem(nMesId,bCheck); break;
}
}
//-------------------------------------------------------------------------
sal_Bool SfxTemplateDialog_Impl::IsCheckedItem(sal_uInt16 nMesId)
{
switch(nMesId)
{
case SID_STYLE_WATERCAN :
return m_aActionTbR.GetItemState(SID_STYLE_WATERCAN)==STATE_CHECK;
default:
return m_aActionTbL.GetItemState(nMesId)==STATE_CHECK;
}
}
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateDialog_Impl, ToolBoxLSelect, ToolBox *, pBox )
{
const sal_uInt16 nEntry = pBox->GetCurItemId();
FamilySelect(nEntry);
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateDialog_Impl, ToolBoxLSelect, ToolBox *, pBox )
//-------------------------------------------------------------------------
::rtl::OUString lcl_GetLabel(uno::Any& rAny)
{
::rtl::OUString sRet;
uno::Sequence< beans::PropertyValue >aPropSeq;
if ( rAny >>= aPropSeq )
{
for( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
{
if ( aPropSeq[i].Name.equalsAscii( "Label" ))
{
aPropSeq[i].Value >>= sRet;
break;
}
}
}
return sRet;
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxTemplateDialog_Impl, ToolBoxRSelect, ToolBox *, pBox )
{
const sal_uInt16 nEntry = pBox->GetCurItemId();
if(nEntry != SID_STYLE_NEW_BY_EXAMPLE ||
TIB_DROPDOWN != (pBox->GetItemBits(nEntry)&TIB_DROPDOWN))
ActionSelect(nEntry);
return 0;
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxTemplateDialog_Impl, ToolBoxRClick, ToolBox *, pBox )
{
const sal_uInt16 nEntry = pBox->GetCurItemId();
if(nEntry == SID_STYLE_NEW_BY_EXAMPLE &&
TIB_DROPDOWN == (pBox->GetItemBits(nEntry)&TIB_DROPDOWN))
{
//create a popup menu in Writer
PopupMenu *pMenu = new PopupMenu;
uno::Reference< container::XNameAccess > xNameAccess(
::comphelper::getProcessServiceFactory()->
createInstance( ::rtl::OUString::createFromAscii(
"com.sun.star.frame.UICommandDescription") ), uno::UNO_QUERY );
uno::Reference< container::XNameAccess > xUICommands;
if ( xNameAccess.is() )
{
rtl::OUString sTextDoc = ::rtl::OUString::createFromAscii("com.sun.star.text.TextDocument");
if(xNameAccess->hasByName(sTextDoc))
{
uno::Any a = xNameAccess->getByName( sTextDoc );
a >>= xUICommands;
}
}
if(!xUICommands.is())
return 0;
try
{
uno::Sequence< beans::PropertyValue > aPropSeq;
uno::Any aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:StyleNewByExample"));
::rtl::OUString sLabel = lcl_GetLabel( aCommand );
pMenu->InsertItem( SID_STYLE_NEW_BY_EXAMPLE, sLabel );
pMenu->SetHelpId(SID_STYLE_NEW_BY_EXAMPLE, HID_TEMPLDLG_NEWBYEXAMPLE);
aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:StyleUpdateByExample"));
sLabel = lcl_GetLabel( aCommand );
pMenu->InsertItem( SID_STYLE_UPDATE_BY_EXAMPLE, sLabel );
pMenu->SetHelpId(SID_STYLE_UPDATE_BY_EXAMPLE, HID_TEMPLDLG_UPDATEBYEXAMPLE);
aCommand = xUICommands->getByName(::rtl::OUString::createFromAscii(".uno:LoadStyles"));
sLabel = lcl_GetLabel( aCommand );
pMenu->InsertItem( SID_TEMPLATE_LOAD, sLabel );
pMenu->SetHelpId(SID_TEMPLATE_LOAD, ".uno:LoadStyles");
pMenu->SetSelectHdl(LINK(this, SfxTemplateDialog_Impl, MenuSelectHdl));
pMenu->Execute( pBox,
pBox->GetItemRect(nEntry),
POPUPMENU_EXECUTE_DOWN );
pBox->EndSelection();
}
catch(uno::Exception&)
{
}
delete pMenu;
pBox->Invalidate();
}
return 0;
}
//-------------------------------------------------------------------------
IMPL_LINK( SfxTemplateDialog_Impl, MenuSelectHdl, Menu*, pMenu)
{
sal_uInt16 nMenuId = pMenu->GetCurItemId();
ActionSelect(nMenuId);
return 0;
}
//-------------------------------------------------------------------------
SfxTemplateCatalog_Impl::SfxTemplateCatalog_Impl( Window* /*pParent*/, SfxBindings* pB,
SfxTemplateCatalog* pTmpWindow ) :
SfxCommonTemplateDialog_Impl( pB, pTmpWindow ),
aFamList ( pTmpWindow, SfxResId( BT_TOOL ) ),
aOkBtn ( pTmpWindow, SfxResId( BT_OK ) ),
aCancelBtn ( pTmpWindow, SfxResId( BT_CANCEL ) ),
aNewBtn ( pTmpWindow, SfxResId( BT_NEW ) ),
aChangeBtn ( pTmpWindow, SfxResId( BT_EDIT ) ),
aDelBtn ( pTmpWindow, SfxResId( BT_DEL ) ),
aOrgBtn ( pTmpWindow, SfxResId( BT_ORG ) ),
aHelpBtn ( pTmpWindow, SfxResId( BT_HELP ) ),
pReal ( pTmpWindow ),
aHelper ( pTmpWindow )
{
aNewBtn.Disable();
aDelBtn.Disable();
aChangeBtn.Disable();
SFX_APP()->Get_Impl()->pTemplateCommon = GetISfxTemplateCommon();
pTmpWindow->FreeResource();
Initialize();
aFamList.SetSelectHdl( LINK( this, SfxTemplateCatalog_Impl, FamListSelect ) );
aOkBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, OkHdl ) );
aCancelBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, CancelHdl ) );
aNewBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, NewHdl ) );
aDelBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, DelHdl ) );
aChangeBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, ChangeHdl ) );
aOrgBtn.SetClickHdl( LINK( this, SfxTemplateCatalog_Impl, OrgHdl ) );
}
//-------------------------------------------------------------------------
SfxTemplateCatalog_Impl::~SfxTemplateCatalog_Impl()
{
SFX_APP()->Get_Impl()->pTemplateCommon = 0;
}
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, OkHdl, Button *, pButton )
{
(void)pButton; //unused
ApplyHdl( NULL );
pReal->EndDialog( RET_OK );
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, OkHdl, Button *, pButton )
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, CancelHdl, Button *, pButton )
{
(void)pButton; //unused
pReal->EndDialog( RET_CANCEL );
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, CancelHdl, Button *, pButton )
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, NewHdl, Button *, pButton )
{
(void)pButton; //unused
aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
SfxCommonTemplateDialog_Impl::NewHdl( NULL );
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, NewHdl, Button *, pButton )
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, ChangeHdl, Button *, pButton )
{
(void)pButton; //unused
aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
SfxCommonTemplateDialog_Impl::EditHdl( NULL );
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, ChangeHdl, Button *, pButton )
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, DelHdl, Button *, pButton )
{
(void)pButton; //unused
SfxCommonTemplateDialog_Impl::DeleteHdl( NULL );
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, DelHdl, Button *, pButton )
//-------------------------------------------------------------------------
IMPL_LINK( SfxTemplateCatalog_Impl, OrgHdl, Button *, pButton )
{
(void)pButton; //unused
aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
SfxDocumentTemplates aTemplates;
aTemplates.Construct();
SfxTemplateOrganizeDlg* pDlg = new SfxTemplateOrganizeDlg( pReal, &aTemplates );
const short nRet = pDlg->Execute();
delete pDlg;
if ( RET_OK == nRet )
Update_Impl();
else if ( RET_EDIT_STYLE == nRet )
pReal->EndDialog( RET_CANCEL );
return 0;
}
//-------------------------------------------------------------------------
void SfxTemplateCatalog_Impl::EnableEdit( sal_Bool bEnable )
{
SfxCommonTemplateDialog_Impl::EnableEdit( bEnable );
aChangeBtn.Enable( bEnable );
}
//-------------------------------------------------------------------------
void SfxTemplateCatalog_Impl::EnableDel( sal_Bool bEnable )
{
SfxCommonTemplateDialog_Impl::EnableDel( bEnable );
aDelBtn.Enable( bEnable );
}
void SfxTemplateCatalog_Impl::EnableNew(sal_Bool bEnable)
{
SfxCommonTemplateDialog_Impl::EnableNew( bEnable );
aNewBtn.Enable( bEnable );
}
//-------------------------------------------------------------------------
IMPL_LINK_INLINE_START( SfxTemplateCatalog_Impl, FamListSelect, ListBox *, pList )
{
const sal_uInt16 nEntry = aFamIds[pList->GetSelectEntryPos()];
FamilySelect(nEntry);
return 0;
}
IMPL_LINK_INLINE_END( SfxTemplateCatalog_Impl, FamListSelect, ListBox *, pList )
//-------------------------------------------------------------------------
void SfxTemplateCatalog_Impl::EnableItem( sal_uInt16 nMesId, sal_Bool bCheck )
{
if ( nMesId == SID_STYLE_WATERCAN )
aOkBtn.Enable( bCheck );
if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
return;
/* for(sal_uInt16 i=0;i<aFamIds.Count&&aFamIds[i]!=nMesId;i++);
if(i!=aFamIds.Count())
aFamList.SelectEntry(aFamIds[i]);
else
DBG_ERROR("Entry nicht gefunden");*/
}
//-------------------------------------------------------------------------
void SfxTemplateCatalog_Impl::CheckItem(sal_uInt16 nMesId, sal_Bool /*bCheck*/)
{
if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
return;
sal_uInt16 i;
for ( i = 0; i < aFamIds.Count() && aFamIds[i] != nMesId; i++ ) ;
aFamList.SelectEntryPos(i);
}
//-------------------------------------------------------------------------
sal_Bool SfxTemplateCatalog_Impl::IsCheckedItem(sal_uInt16 nMesId)
{
if ( nMesId > SFX_STYLE_FAMILY_PSEUDO || nMesId < SFX_STYLE_FAMILY_CHAR )
return sal_False;
sal_uInt16 i;
for ( i = 0; i < aFamIds.Count() && aFamIds[i] != nMesId; i++ )
;
return aFamList.IsEntrySelected( String::CreateFromInt32(i) );
}
//-------------------------------------------------------------------------
// Der Katalog muss nur das Disablen beherrschen, da waehrend seiner
// Lebenszeit keine Selektionsaenderungen vorgenommen werden koennen
void SfxTemplateCatalog_Impl::EnableFamilyItem( sal_uInt16 nId, sal_Bool bEnable )
{
if ( !bEnable )
for ( sal_uInt16 nPos = aFamIds.Count(); nPos--; )
if ( aFamIds[ nPos ] == nId )
{
aFamIds.Remove( nPos );
aFamList.RemoveEntry( nPos );
}
}
void SfxTemplateCatalog_Impl::InsertFamilyItem( sal_uInt16 nId, const SfxStyleFamilyItem* pItem )
{
if ( nId > SFX_STYLE_FAMILY_PSEUDO || nId < SFX_STYLE_FAMILY_CHAR )
return;
aFamList.InsertEntry( pItem->GetText(), 0 );
aFamIds.Insert( nId, 0 );
}
void SfxTemplateCatalog_Impl::ClearFamilyList()
{
aFamList.Clear();
aFamIds.Remove( 0, aFamIds.Count() );
}
void SfxTemplateCatalog_Impl::PrepareDeleteAction()
{
aDelBtn.Disable();
aCancelBtn.SetText( String( SfxResId( STR_CLOSE ) ) );
}
void SfxCommonTemplateDialog_Impl::SetFamily( sal_uInt16 nId )
{
if ( nId != nActFamily )
{
if ( nActFamily != SFX_TEMPLDLG_FILTER_MAX )
CheckItem( nActFamily, sal_False );
nActFamily = nId;
if ( nId != SFX_TEMPLDLG_FILTER_MAX )
bUpdateFamily = sal_True;
}
}
void SfxCommonTemplateDialog_Impl::UpdateFamily_Impl()
{
bUpdateFamily = sal_False;
SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
SfxViewFrame *pViewFrame = pDispat->GetFrame();
SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): 0;
if ( pOldStyleSheetPool != pStyleSheetPool )
{
if ( pOldStyleSheetPool )
EndListening(*pOldStyleSheetPool);
if ( pStyleSheetPool )
StartListening(*pOldStyleSheetPool);
}
bWaterDisabled = sal_False;
bCanNew = sal_True;
bTreeDrag = sal_True;
bUpdateByExampleDisabled = sal_False;
if ( pStyleSheetPool )
{
if(!pTreeBox)
UpdateStyles_Impl(UPDATE_FAMILY | UPDATE_FAMILY_LIST);
else
{
UpdateStyles_Impl(UPDATE_FAMILY);
FillTreeBox();
}
}
InvalidateBindings();
if ( IsCheckedItem( SID_STYLE_WATERCAN ) &&
// nur, wenn dieser Bereich erlaubt ist
0 != pFamilyState[ nActFamily - 1 ] )
Execute_Impl( SID_STYLE_APPLY, GetSelectedEntry(),
String(), (sal_uInt16)GetFamilyItem_Impl()->GetFamily() );
}
void SfxCommonTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
{
//does nothing
}
void SfxTemplateDialog::StateChanged( StateChangedType nStateChange )
{
if ( nStateChange == STATE_CHANGE_INITSHOW )
{
SfxViewFrame *pFrame = GetBindings().GetDispatcher_Impl()->GetFrame();
Window* pEditWin = pFrame->GetViewShell()->GetWindow();
Size aSize = pEditWin->GetSizePixel();
Point aPoint = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
aPoint = GetParent()->ScreenToOutputPixel( aPoint );
Size aWinSize = GetSizePixel();
aPoint.X() += aSize.Width() - aWinSize.Width() - 20;
aPoint.Y() += aSize.Height() / 2 - aWinSize.Height() / 2;
SetFloatingPos( aPoint );
}
SfxDockingWindow::StateChanged( nStateChange );
}
/*-- 10.12.2003 11:44:35---------------------------------------------------
-----------------------------------------------------------------------*/
DropToolBox_Impl::DropToolBox_Impl(Window* pParent, SfxTemplateDialog_Impl* pTemplateDialog) :
ToolBox(pParent),
DropTargetHelper(this),
rParent(*pTemplateDialog)
{
}
/*-- 10.12.2003 11:44:35---------------------------------------------------
-----------------------------------------------------------------------*/
DropToolBox_Impl::~DropToolBox_Impl()
{
}
/*-- 10.12.2003 11:44:35---------------------------------------------------
-----------------------------------------------------------------------*/
sal_Int8 DropToolBox_Impl::AcceptDrop( const AcceptDropEvent& rEvt )
{
sal_Int8 nReturn = DND_ACTION_NONE;
sal_uInt16 nItemId = GetItemId( rEvt.maPosPixel );
if(USHRT_MAX != nItemId && !IsItemChecked( nItemId ))
{
SetCurItemId(nItemId);
GetSelectHdl().Call(this);
}
// special case: page styles are allowed to create new styles by example
// but not allowed to be created by drag and drop
if ( nItemId != SfxCommonTemplateDialog_Impl::SfxFamilyIdToNId( SFX_STYLE_FAMILY_PAGE )&&
IsDropFormatSupported( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) &&
!rParent.bNewByExampleDisabled )
{
nReturn = DND_ACTION_COPY;
}
return nReturn;
}
/*-- 10.12.2003 11:44:35---------------------------------------------------
-----------------------------------------------------------------------*/
sal_Int8 DropToolBox_Impl::ExecuteDrop( const ExecuteDropEvent& rEvt )
{
return rParent.aFmtLb.ExecuteDrop(rEvt);
}