diff options
Diffstat (limited to 'svx/source/unodraw/gluepts.cxx')
| -rw-r--r-- | svx/source/unodraw/gluepts.cxx | 513 |
1 files changed, 513 insertions, 0 deletions
diff --git a/svx/source/unodraw/gluepts.cxx b/svx/source/unodraw/gluepts.cxx new file mode 100644 index 000000000..584effb73 --- /dev/null +++ b/svx/source/unodraw/gluepts.cxx @@ -0,0 +1,513 @@ +/* -*- 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 ) noexcept; + + // 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 ) noexcept +{ + 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 ) noexcept +{ + 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 ) noexcept +: 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 gluepoint + 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 gluepoint + 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 gluepoint? + { + SdrGluePoint aTempPoint = mpObject->GetVertexGluePoint( static_cast<sal_uInt16>(Identifier) ); + aGluePoint.IsUserDefined = false; + convert( aTempPoint, aGluePoint ); + return uno::Any( 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::Any( 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 gluepoints + // and any number of user defined gluepoints + 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 gluepoint? + { + 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: */ |