7ced53424a
Change-Id: I88fdaa74c4944f9ffc81db6df08a29283362375a Reviewed-on: https://gerrit.libreoffice.org/c/core/+/103647 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
513 lines
16 KiB
C++
513 lines
16 KiB
C++
/* -*- 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/container/NoSuchElementException.hpp>
|
|
#include <com/sun/star/container/XIdentifierContainer.hpp>
|
|
#include <com/sun/star/container/XIndexContainer.hpp>
|
|
#include <com/sun/star/drawing/GluePoint2.hpp>
|
|
#include <com/sun/star/lang/IllegalArgumentException.hpp>
|
|
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
|
|
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <tools/weakbase.hxx>
|
|
|
|
#include <svx/svdobj.hxx>
|
|
#include <svx/svdglue.hxx>
|
|
|
|
#include "gluepts.hxx"
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace ::cppu;
|
|
|
|
const sal_uInt16 NON_USER_DEFINED_GLUE_POINTS = 4;
|
|
|
|
namespace {
|
|
|
|
class SvxUnoGluePointAccess : public WeakImplHelper< container::XIndexContainer, container::XIdentifierContainer >
|
|
{
|
|
private:
|
|
tools::WeakReference<SdrObject> mpObject;
|
|
|
|
public:
|
|
explicit SvxUnoGluePointAccess( SdrObject* pObject ) throw();
|
|
|
|
// XIdentifierContainer
|
|
virtual sal_Int32 SAL_CALL insert( const uno::Any& aElement ) override;
|
|
virtual void SAL_CALL removeByIdentifier( sal_Int32 Identifier ) override;
|
|
|
|
// XIdentifierReplace
|
|
virtual void SAL_CALL replaceByIdentifer( sal_Int32 Identifier, const uno::Any& aElement ) override;
|
|
|
|
// XIdentifierReplace
|
|
virtual uno::Any SAL_CALL getByIdentifier( sal_Int32 Identifier ) override;
|
|
virtual uno::Sequence< sal_Int32 > SAL_CALL getIdentifiers( ) override;
|
|
|
|
/* deprecated */
|
|
// XIndexContainer
|
|
virtual void SAL_CALL insertByIndex( sal_Int32 Index, const uno::Any& Element ) override;
|
|
virtual void SAL_CALL removeByIndex( sal_Int32 Index ) override;
|
|
|
|
/* deprecated */
|
|
// XIndexReplace
|
|
virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const uno::Any& Element ) override;
|
|
|
|
/* deprecated */
|
|
// XIndexAccess
|
|
virtual sal_Int32 SAL_CALL getCount( ) override;
|
|
virtual uno::Any SAL_CALL getByIndex( sal_Int32 Index ) override;
|
|
|
|
// XElementAccess
|
|
virtual uno::Type SAL_CALL getElementType( ) override;
|
|
virtual sal_Bool SAL_CALL hasElements( ) override;
|
|
};
|
|
|
|
}
|
|
|
|
static void convert( const SdrGluePoint& rSdrGlue, drawing::GluePoint2& rUnoGlue ) throw()
|
|
{
|
|
rUnoGlue.Position.X = rSdrGlue.GetPos().X();
|
|
rUnoGlue.Position.Y = rSdrGlue.GetPos().Y();
|
|
rUnoGlue.IsRelative = rSdrGlue.IsPercent();
|
|
|
|
SdrAlign eAlign = rSdrGlue.GetAlign();
|
|
if (eAlign == (SdrAlign::VERT_TOP|SdrAlign::HORZ_LEFT))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_TOP_LEFT;
|
|
else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_TOP;
|
|
else if (eAlign == (SdrAlign::VERT_TOP|SdrAlign::HORZ_RIGHT))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_TOP_RIGHT;
|
|
else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_CENTER;
|
|
else if (eAlign == (SdrAlign::HORZ_RIGHT|SdrAlign::VERT_CENTER))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_RIGHT;
|
|
else if (eAlign == (SdrAlign::HORZ_LEFT|SdrAlign::VERT_BOTTOM))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM_LEFT;
|
|
else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM;
|
|
else if (eAlign == (SdrAlign::HORZ_RIGHT|SdrAlign::VERT_BOTTOM))
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM_RIGHT;
|
|
else {
|
|
rUnoGlue.PositionAlignment = drawing::Alignment_LEFT;
|
|
}
|
|
|
|
switch( rSdrGlue.GetEscDir() )
|
|
{
|
|
case SdrEscapeDirection::LEFT:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_LEFT;
|
|
break;
|
|
case SdrEscapeDirection::RIGHT:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_RIGHT;
|
|
break;
|
|
case SdrEscapeDirection::TOP:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_UP;
|
|
break;
|
|
case SdrEscapeDirection::BOTTOM:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_DOWN;
|
|
break;
|
|
case SdrEscapeDirection::HORZ:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_HORIZONTAL;
|
|
break;
|
|
case SdrEscapeDirection::VERT:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_VERTICAL;
|
|
break;
|
|
// case SdrEscapeDirection::SMART:
|
|
default:
|
|
rUnoGlue.Escape = drawing::EscapeDirection_SMART;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void convert( const drawing::GluePoint2& rUnoGlue, SdrGluePoint& rSdrGlue ) throw()
|
|
{
|
|
rSdrGlue.SetPos( Point( rUnoGlue.Position.X, rUnoGlue.Position.Y ) );
|
|
rSdrGlue.SetPercent( rUnoGlue.IsRelative );
|
|
|
|
switch( rUnoGlue.PositionAlignment )
|
|
{
|
|
case drawing::Alignment_TOP_LEFT:
|
|
rSdrGlue.SetAlign( SdrAlign::VERT_TOP|SdrAlign::HORZ_LEFT );
|
|
break;
|
|
case drawing::Alignment_TOP:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP );
|
|
break;
|
|
case drawing::Alignment_TOP_RIGHT:
|
|
rSdrGlue.SetAlign( SdrAlign::VERT_TOP|SdrAlign::HORZ_RIGHT );
|
|
break;
|
|
case drawing::Alignment_CENTER:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER );
|
|
break;
|
|
case drawing::Alignment_RIGHT:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_RIGHT|SdrAlign::VERT_CENTER );
|
|
break;
|
|
case drawing::Alignment_BOTTOM_LEFT:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_LEFT|SdrAlign::VERT_BOTTOM );
|
|
break;
|
|
case drawing::Alignment_BOTTOM:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM );
|
|
break;
|
|
case drawing::Alignment_BOTTOM_RIGHT:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_RIGHT|SdrAlign::VERT_BOTTOM );
|
|
break;
|
|
// case SdrAlign::HORZ_LEFT:
|
|
default:
|
|
rSdrGlue.SetAlign( SdrAlign::HORZ_LEFT );
|
|
break;
|
|
}
|
|
switch( rUnoGlue.Escape )
|
|
{
|
|
case drawing::EscapeDirection_LEFT:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::LEFT);
|
|
break;
|
|
case drawing::EscapeDirection_RIGHT:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::RIGHT);
|
|
break;
|
|
case drawing::EscapeDirection_UP:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::TOP);
|
|
break;
|
|
case drawing::EscapeDirection_DOWN:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::BOTTOM);
|
|
break;
|
|
case drawing::EscapeDirection_HORIZONTAL:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::HORZ);
|
|
break;
|
|
case drawing::EscapeDirection_VERTICAL:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::VERT);
|
|
break;
|
|
// case drawing::EscapeDirection_SMART:
|
|
default:
|
|
rSdrGlue.SetEscDir(SdrEscapeDirection::SMART);
|
|
break;
|
|
}
|
|
}
|
|
|
|
SvxUnoGluePointAccess::SvxUnoGluePointAccess( SdrObject* pObject ) throw()
|
|
: mpObject( pObject )
|
|
{
|
|
}
|
|
|
|
// XIdentifierContainer
|
|
sal_Int32 SAL_CALL SvxUnoGluePointAccess::insert( const uno::Any& aElement )
|
|
{
|
|
if( mpObject.is() )
|
|
{
|
|
SdrGluePointList* pList = mpObject->ForceGluePointList();
|
|
if( pList )
|
|
{
|
|
// second, insert the new glue point
|
|
drawing::GluePoint2 aUnoGlue;
|
|
|
|
if( aElement >>= aUnoGlue )
|
|
{
|
|
SdrGluePoint aSdrGlue;
|
|
convert( aUnoGlue, aSdrGlue );
|
|
sal_uInt16 nId = pList->Insert( aSdrGlue );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
|
|
return static_cast<sal_Int32>((*pList)[nId].GetId() + NON_USER_DEFINED_GLUE_POINTS) - 1;
|
|
}
|
|
|
|
throw lang::IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void SAL_CALL SvxUnoGluePointAccess::removeByIdentifier( sal_Int32 Identifier )
|
|
{
|
|
if( mpObject.is() && ( Identifier >= NON_USER_DEFINED_GLUE_POINTS ))
|
|
{
|
|
const sal_uInt16 nId = static_cast<sal_uInt16>(Identifier - NON_USER_DEFINED_GLUE_POINTS) + 1;
|
|
|
|
SdrGluePointList* pList = const_cast<SdrGluePointList*>(mpObject->GetGluePointList());
|
|
const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
|
|
sal_uInt16 i;
|
|
|
|
for( i = 0; i < nCount; i++ )
|
|
{
|
|
if( (*pList)[i].GetId() == nId )
|
|
{
|
|
pList->Delete( i );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw container::NoSuchElementException();
|
|
}
|
|
|
|
// XIdentifierReplace
|
|
void SAL_CALL SvxUnoGluePointAccess::replaceByIdentifer( sal_Int32 Identifier, const uno::Any& aElement )
|
|
{
|
|
if( !mpObject.is() )
|
|
return;
|
|
|
|
struct drawing::GluePoint2 aGluePoint;
|
|
if( (Identifier < NON_USER_DEFINED_GLUE_POINTS) || !(aElement >>= aGluePoint))
|
|
throw lang::IllegalArgumentException();
|
|
|
|
const sal_uInt16 nId = static_cast<sal_uInt16>( Identifier - NON_USER_DEFINED_GLUE_POINTS ) + 1;
|
|
|
|
SdrGluePointList* pList = const_cast< SdrGluePointList* >( mpObject->GetGluePointList() );
|
|
const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
|
|
sal_uInt16 i;
|
|
for( i = 0; i < nCount; i++ )
|
|
{
|
|
if( (*pList)[i].GetId() == nId )
|
|
{
|
|
// change the glue point
|
|
SdrGluePoint& rTempPoint = (*pList)[i];
|
|
convert( aGluePoint, rTempPoint );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw container::NoSuchElementException();
|
|
}
|
|
|
|
// XIdentifierAccess
|
|
uno::Any SAL_CALL SvxUnoGluePointAccess::getByIdentifier( sal_Int32 Identifier )
|
|
{
|
|
if( mpObject.is() )
|
|
{
|
|
struct drawing::GluePoint2 aGluePoint;
|
|
|
|
if( Identifier < NON_USER_DEFINED_GLUE_POINTS ) // default glue point?
|
|
{
|
|
SdrGluePoint aTempPoint = mpObject->GetVertexGluePoint( static_cast<sal_uInt16>(Identifier) );
|
|
aGluePoint.IsUserDefined = false;
|
|
convert( aTempPoint, aGluePoint );
|
|
return uno::makeAny( aGluePoint );
|
|
}
|
|
else
|
|
{
|
|
const sal_uInt16 nId = static_cast<sal_uInt16>( Identifier - NON_USER_DEFINED_GLUE_POINTS ) + 1;
|
|
|
|
const SdrGluePointList* pList = mpObject->GetGluePointList();
|
|
const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
|
|
for( sal_uInt16 i = 0; i < nCount; i++ )
|
|
{
|
|
const SdrGluePoint& rTempPoint = (*pList)[i];
|
|
if( rTempPoint.GetId() == nId )
|
|
{
|
|
// #i38892#
|
|
if(rTempPoint.IsUserDefined())
|
|
{
|
|
aGluePoint.IsUserDefined = true;
|
|
}
|
|
|
|
convert( rTempPoint, aGluePoint );
|
|
return uno::makeAny( aGluePoint );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
throw container::NoSuchElementException();
|
|
}
|
|
|
|
uno::Sequence< sal_Int32 > SAL_CALL SvxUnoGluePointAccess::getIdentifiers()
|
|
{
|
|
if( mpObject.is() )
|
|
{
|
|
const SdrGluePointList* pList = mpObject->GetGluePointList();
|
|
const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
|
|
|
|
sal_uInt16 i;
|
|
|
|
uno::Sequence< sal_Int32 > aIdSequence( nCount + NON_USER_DEFINED_GLUE_POINTS );
|
|
sal_Int32 *pIdentifier = aIdSequence.getArray();
|
|
|
|
for( i = 0; i < NON_USER_DEFINED_GLUE_POINTS; i++ )
|
|
*pIdentifier++ = static_cast<sal_Int32>(i);
|
|
|
|
for( i = 0; i < nCount; i++ )
|
|
*pIdentifier++ = static_cast<sal_Int32>( (*pList)[i].GetId() + NON_USER_DEFINED_GLUE_POINTS ) - 1;
|
|
|
|
return aIdSequence;
|
|
}
|
|
else
|
|
{
|
|
uno::Sequence< sal_Int32 > aEmpty;
|
|
return aEmpty;
|
|
}
|
|
}
|
|
|
|
/* deprecated */
|
|
|
|
// XIndexContainer
|
|
void SAL_CALL SvxUnoGluePointAccess::insertByIndex( sal_Int32, const uno::Any& Element )
|
|
{
|
|
if( mpObject.is() )
|
|
{
|
|
SdrGluePointList* pList = mpObject->ForceGluePointList();
|
|
if( pList )
|
|
{
|
|
drawing::GluePoint2 aUnoGlue;
|
|
|
|
if( Element >>= aUnoGlue )
|
|
{
|
|
SdrGluePoint aSdrGlue;
|
|
convert( aUnoGlue, aSdrGlue );
|
|
pList->Insert( aSdrGlue );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
|
|
return;
|
|
}
|
|
|
|
throw lang::IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
throw lang::IndexOutOfBoundsException();
|
|
}
|
|
|
|
void SAL_CALL SvxUnoGluePointAccess::removeByIndex( sal_Int32 Index )
|
|
{
|
|
if( mpObject.is() )
|
|
{
|
|
SdrGluePointList* pList = mpObject->ForceGluePointList();
|
|
if( pList )
|
|
{
|
|
Index -= 4;
|
|
if( Index >= 0 && Index < pList->GetCount() )
|
|
{
|
|
pList->Delete( static_cast<sal_uInt16>(Index) );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw lang::IndexOutOfBoundsException();
|
|
}
|
|
|
|
// XIndexReplace
|
|
void SAL_CALL SvxUnoGluePointAccess::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
|
|
{
|
|
drawing::GluePoint2 aUnoGlue;
|
|
if(!(Element >>= aUnoGlue))
|
|
throw lang::IllegalArgumentException();
|
|
|
|
Index -= 4;
|
|
if( mpObject.is() && Index >= 0 )
|
|
{
|
|
SdrGluePointList* pList = const_cast< SdrGluePointList* >( mpObject->GetGluePointList() );
|
|
if( pList && Index < pList->GetCount() )
|
|
{
|
|
SdrGluePoint& rGlue = (*pList)[static_cast<sal_uInt16>(Index)];
|
|
convert( aUnoGlue, rGlue );
|
|
|
|
// only repaint, no objectchange
|
|
mpObject->ActionChanged();
|
|
// mpObject->BroadcastObjectChange();
|
|
}
|
|
}
|
|
|
|
throw lang::IndexOutOfBoundsException();
|
|
}
|
|
|
|
// XIndexAccess
|
|
sal_Int32 SAL_CALL SvxUnoGluePointAccess::getCount()
|
|
{
|
|
sal_Int32 nCount = 0;
|
|
if( mpObject.is() )
|
|
{
|
|
// each node has a default of 4 glue points
|
|
// and any number of user defined glue points
|
|
nCount += 4;
|
|
|
|
const SdrGluePointList* pList = mpObject->GetGluePointList();
|
|
if( pList )
|
|
nCount += pList->GetCount();
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
uno::Any SAL_CALL SvxUnoGluePointAccess::getByIndex( sal_Int32 Index )
|
|
{
|
|
if( Index >= 0 && mpObject.is() )
|
|
{
|
|
struct drawing::GluePoint2 aGluePoint;
|
|
|
|
if( Index < 4 ) // default glue point?
|
|
{
|
|
SdrGluePoint aTempPoint = mpObject->GetVertexGluePoint( static_cast<sal_uInt16>(Index) );
|
|
aGluePoint.IsUserDefined = false;
|
|
convert( aTempPoint, aGluePoint );
|
|
return uno::Any(aGluePoint);
|
|
}
|
|
else
|
|
{
|
|
Index -= 4;
|
|
const SdrGluePointList* pList = mpObject->GetGluePointList();
|
|
if( pList && Index < pList->GetCount() )
|
|
{
|
|
const SdrGluePoint& rTempPoint = (*pList)[static_cast<sal_uInt16>(Index)];
|
|
aGluePoint.IsUserDefined = true;
|
|
convert( rTempPoint, aGluePoint );
|
|
return uno::Any(aGluePoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
throw lang::IndexOutOfBoundsException();
|
|
}
|
|
|
|
// XElementAccess
|
|
uno::Type SAL_CALL SvxUnoGluePointAccess::getElementType()
|
|
{
|
|
return cppu::UnoType<drawing::GluePoint2>::get();
|
|
}
|
|
|
|
sal_Bool SAL_CALL SvxUnoGluePointAccess::hasElements()
|
|
{
|
|
return mpObject.is();
|
|
}
|
|
|
|
/**
|
|
* Create a SvxUnoGluePointAccess
|
|
*/
|
|
uno::Reference< uno::XInterface > SvxUnoGluePointAccess_createInstance( SdrObject* pObject )
|
|
{
|
|
return *new SvxUnoGluePointAccess(pObject);
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|