strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/svx/source/form/fmexpl.cxx
Noel Grandin b7a32682f6 use less dynamic_cast when broadcasting SfxHint 
Change-Id: I24c947c20afeffffebe5ac794108c4ccecb680f1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/172828
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2024-09-03 21:41:08 +02:00

530 lines
13 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include <svx/strings.hrc>
#include <fmexpl.hxx>
#include <helpids.h>
#include <svx/svdobjkind.hxx>
#include <svx/fmtools.hxx>
#include <fmexch.hxx>
#include <svx/svxids.hrc>
#include <fmprop.hxx>
#include <bitmaps.hlst>
#include <svx/dialmgr.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <sfx2/objitem.hxx>
#include <svx/fmshell.hxx>
#include <comphelper/types.hxx>
#include <utility>
using namespace ::svxform;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::form;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::container;
FmNavInsertedHint::FmNavInsertedHint( FmEntryData* pInsertedEntryData, sal_uInt32 nRelPos )
:SfxHint(SfxHintId::FmNavInserted)
,pEntryData( pInsertedEntryData )
,nPos( nRelPos )
{
}
FmNavInsertedHint::~FmNavInsertedHint()
{
}
FmNavModelReplacedHint::FmNavModelReplacedHint( FmEntryData* pAffectedEntryData )
:SfxHint(SfxHintId::FmNavModelReplaced), pEntryData( pAffectedEntryData )
{
}
FmNavModelReplacedHint::~FmNavModelReplacedHint()
{
}
FmNavRemovedHint::FmNavRemovedHint( FmEntryData* pRemovedEntryData )
:SfxHint(SfxHintId::FmNavRemoved), pEntryData( pRemovedEntryData )
{
}
FmNavRemovedHint::~FmNavRemovedHint()
{
}
FmNavNameChangedHint::FmNavNameChangedHint( FmEntryData* pData, OUString _aNewName )
:SfxHint(SfxHintId::FmNavNameChanged), pEntryData( pData )
,aNewName(std::move( _aNewName ))
{
}
FmNavNameChangedHint::~FmNavNameChangedHint()
{
}
FmNavClearedHint::FmNavClearedHint() : SfxHint(SfxHintId::FmNavCleared)
{
}
FmNavClearedHint::~FmNavClearedHint()
{
}
FmEntryDataList::FmEntryDataList()
{
}
FmEntryDataList::~FmEntryDataList()
{
}
void FmEntryDataList::removeNoDelete( FmEntryData* pItem )
{
auto it = std::find_if(maEntryDataList.begin(), maEntryDataList.end(),
[&pItem](const std::unique_ptr<FmEntryData>& rEntryData) { return rEntryData.get() == pItem; });
if (it != maEntryDataList.end())
{
// coverity[leaked_storage] - deliberately not deleted, ownership transferred
it->release();
maEntryDataList.erase( it );
return;
}
assert(false);
}
void FmEntryDataList::insert( std::unique_ptr<FmEntryData> pItem, size_t Index )
{
if ( Index < maEntryDataList.size() )
{
maEntryDataList.insert( maEntryDataList.begin() + Index, std::move(pItem) );
}
else
maEntryDataList.push_back( std::move(pItem) );
}
void FmEntryDataList::clear()
{
maEntryDataList.clear();
}
FmEntryData::FmEntryData( FmEntryData* pParentData, const Reference< XInterface >& _rxIFace )
:pParent( pParentData )
{
pChildList.reset( new FmEntryDataList() );
newObject( _rxIFace );
}
FmEntryData::~FmEntryData()
{
pChildList->clear();
}
void FmEntryData::newObject( const css::uno::Reference< css::uno::XInterface >& _rxIFace )
{
// do not just copy, normalize it
m_xNormalizedIFace.set( _rxIFace, UNO_QUERY );
m_xProperties.set(m_xNormalizedIFace, css::uno::UNO_QUERY);
m_xChild.set(m_xNormalizedIFace, css::uno::UNO_QUERY);
}
FmEntryData::FmEntryData( const FmEntryData& rEntryData )
{
pChildList.reset( new FmEntryDataList() );
aText = rEntryData.GetText();
m_aNormalImage = rEntryData.GetNormalImage();
pParent = rEntryData.GetParent();
FmEntryData* pChildData;
size_t nEntryCount = rEntryData.GetChildList()->size();
for( size_t i = 0; i < nEntryCount; i++ )
{
pChildData = rEntryData.GetChildList()->at( i );
std::unique_ptr<FmEntryData> pNewChildData = pChildData->Clone();
pChildList->insert( std::move(pNewChildData), size_t(-1) );
}
m_xNormalizedIFace = rEntryData.m_xNormalizedIFace;
m_xProperties = rEntryData.m_xProperties;
m_xChild = rEntryData.m_xChild;
}
bool FmEntryData::IsEqualWithoutChildren( FmEntryData* pEntryData )
{
if(this == pEntryData)
return true;
if( !pEntryData )
return false;
if( aText != pEntryData->GetText() )
return false;
if( !pEntryData->GetParent() && pParent )
return false;
if( pEntryData->GetParent() && !pParent )
return false;
if( !pEntryData->GetParent() && !pParent )
return true;
if( !pParent->IsEqualWithoutChildren(pEntryData->GetParent()) )
return false;
return true;
}
FmFormData::FmFormData(const Reference< XForm >& _rxForm, FmFormData* _pParent)
: FmEntryData(_pParent, _rxForm)
, m_xForm(_rxForm)
{
// set images
m_aNormalImage = RID_SVXBMP_FORM;
// set title
if (m_xForm.is())
{
Reference< XPropertySet > xSet(m_xForm, UNO_QUERY);
if (xSet.is())
{
OUString aEntryName(::comphelper::getString(xSet->getPropertyValue( FM_PROP_NAME )));
SetText(aEntryName);
}
}
else
SetText( OUString() );
}
FmFormData::~FmFormData()
{
}
FmFormData::FmFormData( const FmFormData& rFormData )
:FmEntryData( rFormData )
{
m_xForm = rFormData.GetFormIface();
}
std::unique_ptr<FmEntryData> FmFormData::Clone()
{
return std::unique_ptr<FmEntryData>(new FmFormData( *this ));
}
bool FmFormData::IsEqualWithoutChildren( FmEntryData* pEntryData )
{
if(this == pEntryData)
return true;
FmFormData* pFormData = dynamic_cast<FmFormData*>(pEntryData);
if( !pFormData )
return false;
if( m_xForm.get() != pFormData->GetFormIface().get() )
return false;
return FmEntryData::IsEqualWithoutChildren( pFormData );
}
FmControlData::FmControlData(const Reference< XFormComponent >& _rxComponent, FmFormData* _pParent)
: FmEntryData( _pParent, _rxComponent ),
m_xFormComponent( _rxComponent )
{
// set images
m_aNormalImage = GetImage();
// set title
Reference< XPropertySet > xSet(m_xFormComponent, UNO_QUERY);
if( xSet.is() )
{
SetText( ::comphelper::getString(xSet->getPropertyValue( FM_PROP_NAME )));
}
}
FmControlData::~FmControlData()
{
}
FmControlData::FmControlData( const FmControlData& rControlData )
:FmEntryData( rControlData )
{
m_xFormComponent = rControlData.GetFormComponent();
}
std::unique_ptr<FmEntryData> FmControlData::Clone()
{
return std::unique_ptr<FmEntryData>(new FmControlData( *this ));
}
OUString FmControlData::GetImage() const
{
// Default-Image
OUString aImage(RID_SVXBMP_CONTROL);
Reference< XServiceInfo > xInfo( m_xFormComponent, UNO_QUERY );
if (!m_xFormComponent.is())
return aImage;
// Spezielle Control-Images
SdrObjKind nObjectType = getControlTypeByObject(xInfo);
switch (nObjectType)
{
case SdrObjKind::FormButton:
aImage = RID_SVXBMP_BUTTON;
break;
case SdrObjKind::FormFixedText:
aImage = RID_SVXBMP_FIXEDTEXT;
break;
case SdrObjKind::FormEdit:
aImage = RID_SVXBMP_EDITBOX;
break;
case SdrObjKind::FormRadioButton:
aImage = RID_SVXBMP_RADIOBUTTON;
break;
case SdrObjKind::FormCheckbox:
aImage = RID_SVXBMP_CHECKBOX;
break;
case SdrObjKind::FormListbox:
aImage = RID_SVXBMP_LISTBOX;
break;
case SdrObjKind::FormCombobox:
aImage = RID_SVXBMP_COMBOBOX;
break;
case SdrObjKind::FormNavigationBar:
aImage = RID_SVXBMP_NAVIGATIONBAR;
break;
case SdrObjKind::FormGroupBox:
aImage = RID_SVXBMP_GROUPBOX;
break;
case SdrObjKind::FormImageButton:
aImage = RID_SVXBMP_IMAGEBUTTON;
break;
case SdrObjKind::FormFileControl:
aImage = RID_SVXBMP_FILECONTROL;
break;
case SdrObjKind::FormHidden:
aImage = RID_SVXBMP_HIDDEN;
break;
case SdrObjKind::FormDateField:
aImage = RID_SVXBMP_DATEFIELD;
break;
case SdrObjKind::FormTimeField:
aImage = RID_SVXBMP_TIMEFIELD;
break;
case SdrObjKind::FormNumericField:
aImage = RID_SVXBMP_NUMERICFIELD;
break;
case SdrObjKind::FormCurrencyField:
aImage = RID_SVXBMP_CURRENCYFIELD;
break;
case SdrObjKind::FormPatternField:
aImage = RID_SVXBMP_PATTERNFIELD;
break;
case SdrObjKind::FormImageControl:
aImage = RID_SVXBMP_IMAGECONTROL;
break;
case SdrObjKind::FormFormattedField:
aImage = RID_SVXBMP_FORMATTEDFIELD;
break;
case SdrObjKind::FormGrid:
aImage = RID_SVXBMP_GRID;
break;
case SdrObjKind::FormScrollbar:
aImage = RID_SVXBMP_SCROLLBAR;
break;
case SdrObjKind::FormSpinButton:
aImage = RID_SVXBMP_SPINBUTTON;
break;
default:;
}
return aImage;
}
bool FmControlData::IsEqualWithoutChildren( FmEntryData* pEntryData )
{
if(this == pEntryData)
return true;
FmControlData* pControlData = dynamic_cast<FmControlData*>(pEntryData);
if( !pControlData )
return false;
if( m_xFormComponent.get() != pControlData->GetFormComponent().get() )
return false;
return FmEntryData::IsEqualWithoutChildren( pControlData );
}
void FmControlData::ModelReplaced(const Reference< XFormComponent >& _rxNew)
{
m_xFormComponent = _rxNew;
newObject( m_xFormComponent );
// set images anew
m_aNormalImage = GetImage();
}
namespace svxform
{
NavigatorFrame::NavigatorFrame( SfxBindings* _pBindings, SfxChildWindow* _pMgr,
vcl::Window* _pParent )
: SfxDockingWindow(_pBindings, _pMgr, _pParent, u"FormNavigator"_ustr, u"svx/ui/formnavigator.ui"_ustr)
, SfxControllerItem( SID_FM_FMEXPLORER_CONTROL, *_pBindings )
, m_xNavigatorTree(new NavigatorTree(m_xBuilder->weld_tree_view(u"treeview"_ustr)))
{
SetHelpId( HID_FORM_NAVIGATOR_WIN );
SetText( SvxResId(RID_STR_FMEXPLORER) );
SfxDockingWindow::SetFloatingSize( Size(200,200) );
}
NavigatorFrame::~NavigatorFrame()
{
disposeOnce();
}
void NavigatorFrame::dispose()
{
m_xNavigatorTree.reset();
::SfxControllerItem::dispose();
SfxDockingWindow::dispose();
}
void NavigatorFrame::UpdateContent( FmFormShell* pFormShell )
{
m_xNavigatorTree->UpdateContent(pFormShell);
}
void NavigatorFrame::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
{
if( !pState || SID_FM_FMEXPLORER_CONTROL != nSID )
return;
if( eState >= SfxItemState::DEFAULT )
{
FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() );
UpdateContent( pShell );
}
else
UpdateContent( nullptr );
}
void NavigatorFrame::GetFocus()
{
if (m_xNavigatorTree )
m_xNavigatorTree->GrabFocus();
else
SfxDockingWindow::GetFocus();
}
bool NavigatorFrame::Close()
{
UpdateContent( nullptr );
return SfxDockingWindow::Close();
}
void NavigatorFrame::FillInfo( SfxChildWinInfo& rInfo ) const
{
SfxDockingWindow::FillInfo( rInfo );
rInfo.bVisible = false;
}
Size NavigatorFrame::CalcDockingSize( SfxChildAlignment eAlign )
{
if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
return Size();
return SfxDockingWindow::CalcDockingSize( eAlign );
}
SfxChildAlignment NavigatorFrame::CheckAlignment( SfxChildAlignment _eActAlign, SfxChildAlignment _eAlign )
{
if ( ( _eAlign == SfxChildAlignment::LEFT ) || ( _eAlign == SfxChildAlignment::RIGHT ) || ( _eAlign == SfxChildAlignment::NOALIGNMENT ) )
return _eAlign;
return _eActAlign;
}
SFX_IMPL_DOCKINGWINDOW( NavigatorFrameManager, SID_FM_SHOW_FMEXPLORER )
NavigatorFrameManager::NavigatorFrameManager( vcl::Window* _pParent, sal_uInt16 _nId,
SfxBindings* _pBindings, SfxChildWinInfo* _pInfo )
:SfxChildWindow( _pParent, _nId )
{
SetWindow( VclPtr<NavigatorFrame>::Create( _pBindings, this, _pParent ) );
static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink