/* -*- 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/XIdentifierContainer.hpp>
#include <com/sun/star/container/XIndexContainer.hpp>
#include <com/sun/star/drawing/GluePoint2.hpp>
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
#include <cppuhelper/implbase.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdobj.hxx>
#include <svx/svdglue.hxx>
#include <svx/svdpage.hxx>
#include "gluepts.hxx"
using namespace ::com::sun::star;
using namespace ::cppu;
const sal_uInt16 NON_USER_DEFINED_GLUE_POINTS = 4;
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() && mpObject->IsNode() )
{
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() && mpObject->IsNode() )
{
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 )
{
SdrGluePoint aSdrGlue;
drawing::GluePoint2 aUnoGlue;
if( Element >>= aUnoGlue )
{
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
if( mpObject->IsNode() )
{
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() && mpObject->IsNode() )
{
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() && mpObject->IsNode();
}
/**
* Create a SvxUnoGluePointAccess
*/
uno::Reference< uno::XInterface > SvxUnoGluePointAccess_createInstance( SdrObject* pObject )
{
return *new SvxUnoGluePointAccess(pObject);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V1019 Compound assignment expression 'aElement >>= aGluePoint' is used inside condition.