strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/svx/source/unodraw/unopool.cxx
Mike Kaganski 95ebd24a62 editengine-columns: ODF support [API CHANGE] 
This uses existing ODF markup, as used by Writer's text frame:
style::columns child element of style:graphic-properties, its
fo:column-count and fo:column-gap attributes. No ODF extension
is required.

Since currently only columns with same width and spacing are
implemented, without additional settings, style:column child
elements are exported, but ignored on import.

This adds new property to css::drawing::TextProperties service:
TextColumns (of type css::text::XTextColumns).

Change-Id: I7e63293e5814b281ceec8a9632e696322d3629e8
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/116035
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>
2021-06-08 14:50:55 +02:00

375 lines
12 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 <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/beans/PropertyState.hpp>
#include <comphelper/propertysetinfo.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <vcl/svapp.hxx>
#include <svx/unopool.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdpool.hxx>
#include <svx/unoprov.hxx>
#include <svx/unoshprp.hxx>
#include <svx/xflbstit.hxx>
#include <svx/xflbmtit.hxx>
#include <svx/svdetc.hxx>
#include <editeng/editeng.hxx>
#include <tools/debug.hxx>
#include <memory>
using namespace ::com::sun::star;
using namespace ::cppu;
SvxUnoDrawPool::SvxUnoDrawPool(SdrModel* pModel, sal_Int32 nServiceId)
: PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( nServiceId ) ), mpModel( pModel )
{
init();
}
/* deprecated */
SvxUnoDrawPool::SvxUnoDrawPool(SdrModel* pModel)
: PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS ) ), mpModel( pModel )
{
init();
}
SvxUnoDrawPool::~SvxUnoDrawPool() noexcept
{
}
void SvxUnoDrawPool::init()
{
mpDefaultsPool = new SdrItemPool();
rtl::Reference<SfxItemPool> pOutlPool = EditEngine::CreatePool();
mpDefaultsPool->SetSecondaryPool(pOutlPool.get());
SdrModel::SetTextDefaults( mpDefaultsPool.get(), SdrEngineDefaults::GetFontHeight() );
mpDefaultsPool->SetDefaultMetric(SdrEngineDefaults::GetMapUnit());
mpDefaultsPool->FreezeIdRanges();
}
SfxItemPool* SvxUnoDrawPool::getModelPool( bool bReadOnly ) noexcept
{
if( mpModel )
{
return &mpModel->GetItemPool();
}
else
{
if( bReadOnly )
return mpDefaultsPool.get();
else
return nullptr;
}
}
void SvxUnoDrawPool::getAny( SfxItemPool const * pPool, const comphelper::PropertyMapEntry* pEntry, uno::Any& rValue )
{
switch( pEntry->mnHandle )
{
case OWN_ATTR_FILLBMP_MODE:
{
if (pPool->GetDefaultItem(XATTR_FILLBMP_TILE).GetValue())
{
rValue <<= drawing::BitmapMode_REPEAT;
}
else if (pPool->GetDefaultItem(XATTR_FILLBMP_STRETCH).GetValue())
{
rValue <<= drawing::BitmapMode_STRETCH;
}
else
{
rValue <<= drawing::BitmapMode_NO_REPEAT;
}
break;
}
default:
{
const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
sal_uInt8 nMemberId = pEntry->mnMemberId;
if( eMapUnit == MapUnit::Map100thMM )
nMemberId &= (~CONVERT_TWIPS);
// Assure, that ID is a Which-ID (it could be a Slot-ID.)
// Thus, convert handle to Which-ID.
pPool->GetDefaultItem( pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) ) ).QueryValue( rValue, nMemberId );
}
}
// check for needed metric translation
const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
if(pEntry->mnMoreFlags & PropertyMoreFlags::METRIC_ITEM && eMapUnit != MapUnit::Map100thMM)
{
SvxUnoConvertToMM( eMapUnit, rValue );
}
// convert int32 to correct enum type if needed
else if ( pEntry->maType.getTypeClass() == uno::TypeClass_ENUM && rValue.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
{
sal_Int32 nEnum;
rValue >>= nEnum;
rValue.setValue( &nEnum, pEntry->maType );
}
}
void SvxUnoDrawPool::putAny( SfxItemPool* pPool, const comphelper::PropertyMapEntry* pEntry, const uno::Any& rValue )
{
uno::Any aValue( rValue );
const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
if(pEntry->mnMoreFlags & PropertyMoreFlags::METRIC_ITEM && eMapUnit != MapUnit::Map100thMM)
{
SvxUnoConvertFromMM( eMapUnit, aValue );
}
// Assure, that ID is a Which-ID (it could be a Slot-ID.)
// Thus, convert handle to Which-ID.
const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
switch( nWhich )
{
case OWN_ATTR_FILLBMP_MODE:
do
{
drawing::BitmapMode eMode;
if(!(aValue >>= eMode) )
{
sal_Int32 nMode = 0;
if(!(aValue >>= nMode))
throw lang::IllegalArgumentException();
eMode = static_cast<drawing::BitmapMode>(nMode);
}
pPool->SetPoolDefaultItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
pPool->SetPoolDefaultItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
return;
}
while(false);
default:
{
std::unique_ptr<SfxPoolItem> pNewItem( pPool->GetDefaultItem( nWhich ).Clone() );
sal_uInt8 nMemberId = pEntry->mnMemberId;
if( pPool->GetMetric(nWhich) == MapUnit::Map100thMM )
nMemberId &= (~CONVERT_TWIPS);
if( !pNewItem->PutValue( aValue, nMemberId ) )
throw lang::IllegalArgumentException();
pPool->SetPoolDefaultItem( *pNewItem );
}
}
}
void SvxUnoDrawPool::_setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const uno::Any* pValues )
{
SolarMutexGuard aGuard;
SfxItemPool* pPool = getModelPool( false );
DBG_ASSERT( pPool, "I need a SfxItemPool!" );
if( nullptr == pPool )
throw beans::UnknownPropertyException( "no pool, no properties..", static_cast<cppu::OWeakObject*>(this));
while( *ppEntries )
putAny( pPool, *ppEntries++, *pValues++ );
}
void SvxUnoDrawPool::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValue )
{
SolarMutexGuard aGuard;
SfxItemPool* pPool = getModelPool( true );
DBG_ASSERT( pPool, "I need a SfxItemPool!" );
if( nullptr == pPool )
throw beans::UnknownPropertyException( "no pool, no properties..", static_cast<cppu::OWeakObject*>(this));
while( *ppEntries )
getAny( pPool, *ppEntries++, *pValue++ );
}
void SvxUnoDrawPool::_getPropertyStates( const comphelper::PropertyMapEntry** ppEntries, beans::PropertyState* pStates )
{
SolarMutexGuard aGuard;
SfxItemPool* pPool = getModelPool( true );
if( pPool && pPool != mpDefaultsPool.get() )
{
while( *ppEntries )
{
//Assure, that ID is a Which-ID (it could be a Slot-ID.)
// Thus, convert handle to Which-ID.
const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>((*ppEntries)->mnHandle) );
switch( nWhich )
{
case OWN_ATTR_FILLBMP_MODE:
{
// use method <IsStaticDefaultItem(..)> instead of using
// probably incompatible item pool <mpDefaultPool>.
if ( IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_STRETCH )) ) ||
IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_TILE )) ) )
{
*pStates = beans::PropertyState_DEFAULT_VALUE;
}
else
{
*pStates = beans::PropertyState_DIRECT_VALUE;
}
}
break;
case OWN_ATTR_TEXTCOLUMNS:
if (IsStaticDefaultItem(&pPool->GetDefaultItem(sal_uInt16(SDRATTR_TEXTCOLUMNS_NUMBER)))
&& IsStaticDefaultItem(&pPool->GetDefaultItem(sal_uInt16(SDRATTR_TEXTCOLUMNS_SPACING))))
*pStates = beans::PropertyState_DEFAULT_VALUE;
else
*pStates = beans::PropertyState_DIRECT_VALUE;
break;
default:
//#i18732# - correction:
// use method <IsStaticDefaultItem(..)> instead of using probably
// incompatible item pool <mpDefaultPool>.
const SfxPoolItem& r1 = pPool->GetDefaultItem( nWhich );
//const SfxPoolItem& r2 = mpDefaultPool->GetDefaultItem( nWhich );
if ( IsStaticDefaultItem( &r1 ) )
{
*pStates = beans::PropertyState_DEFAULT_VALUE;
}
else
{
*pStates = beans::PropertyState_DIRECT_VALUE;
}
}
pStates++;
ppEntries++;
}
}
else
{
// as long as we have no model, all properties are default
while( *ppEntries++ )
*pStates++ = beans::PropertyState_DEFAULT_VALUE;
return;
}
}
void SvxUnoDrawPool::_setPropertyToDefault( const comphelper::PropertyMapEntry* pEntry )
{
SolarMutexGuard aGuard;
SfxItemPool* pPool = getModelPool( true );
// Assure, that ID is a Which-ID (it could be a Slot-ID.)
// Thus, convert handle to Which-ID.
const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
if ( pPool && pPool != mpDefaultsPool.get() )
{
// use method <ResetPoolDefaultItem(..)> instead of using probably incompatible item pool <mpDefaultsPool>.
pPool->ResetPoolDefaultItem( nWhich );
}
}
uno::Any SvxUnoDrawPool::_getPropertyDefault( const comphelper::PropertyMapEntry* pEntry )
{
SolarMutexGuard aGuard;
//#i18732# - use method <GetPoolDefaultItem(..)> instead of
// using probably incompatible item pool <mpDefaultsPool>
uno::Any aAny;
SfxItemPool* pPool = getModelPool( true );
const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
const SfxPoolItem *pItem = pPool->GetPoolDefaultItem ( nWhich );
if (pItem)
{
pItem->QueryValue( aAny, pEntry->mnMemberId );
}
return aAny;
}
// XInterface
uno::Any SAL_CALL SvxUnoDrawPool::queryInterface( const uno::Type & rType )
{
return OWeakAggObject::queryInterface( rType );
}
uno::Any SAL_CALL SvxUnoDrawPool::queryAggregation( const uno::Type & rType )
{
uno::Any aAny;
if( rType == cppu::UnoType<lang::XServiceInfo>::get())
aAny <<= uno::Reference< lang::XServiceInfo >(this);
else if( rType == cppu::UnoType<lang::XTypeProvider>::get())
aAny <<= uno::Reference< lang::XTypeProvider >(this);
else if( rType == cppu::UnoType<beans::XPropertySet>::get())
aAny <<= uno::Reference< beans::XPropertySet >(this);
else if( rType == cppu::UnoType<beans::XPropertyState>::get())
aAny <<= uno::Reference< beans::XPropertyState >(this);
else if( rType == cppu::UnoType<beans::XMultiPropertySet>::get())
aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
else
aAny = OWeakAggObject::queryAggregation( rType );
return aAny;
}
uno::Sequence< uno::Type > SAL_CALL SvxUnoDrawPool::getTypes()
{
static const uno::Sequence aTypes {
cppu::UnoType<uno::XAggregation>::get(),
cppu::UnoType<lang::XServiceInfo>::get(),
cppu::UnoType<lang::XTypeProvider>::get(),
cppu::UnoType<beans::XPropertySet>::get(),
cppu::UnoType<beans::XPropertyState>::get(),
cppu::UnoType<beans::XMultiPropertySet>::get() };
return aTypes;
}
uno::Sequence< sal_Int8 > SAL_CALL SvxUnoDrawPool::getImplementationId()
{
return css::uno::Sequence<sal_Int8>();
}
// XServiceInfo
sal_Bool SAL_CALL SvxUnoDrawPool::supportsService( const OUString& ServiceName )
{
return cppu::supportsService(this, ServiceName);
}
OUString SAL_CALL SvxUnoDrawPool::getImplementationName()
{
return "SvxUnoDrawPool";
}
uno::Sequence< OUString > SAL_CALL SvxUnoDrawPool::getSupportedServiceNames( )
{
uno::Sequence<OUString> aSNS { "com.sun.star.drawing.Defaults" };
return aSNS;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink