wangxin/loongoffice
1
0
Fork 0
forked from amazingfate/loongoffice
Code Pull Requests Activity
Files
76ea287c040dcfc2fe71b0588e1701cfe1ae6940
loongoffice/chart2/source/controller/main/ChartController_Tools.cxx
Tomaž Vajngerl 242bb3fdda move BGradient to awt::Gradient2 UNO conversion into docmodel 
This is needed because the module dependencies are an issues if
the conversion is done in basegfx. The bigger issue will come when
the ComplexColor conversion will be done as basegfx can't depend on
docmodel because of circular dependencies.

The BGradient is also more suitable for docmodel anyway as the
previously it was part of the model and is not a basic (gfx)
type - however this doesn't move the whole BGradient into docmodel
yet.

Change-Id: Id91ce52232f89f00e09b451c13da36e2854ae14b
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/155674
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>
2023-08-21 09:27:12 +02:00

1128 lines
39 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 <ChartController.hxx>
#include <ChartWindow.hxx>
#include <ChartModel.hxx>
#include <ChartModelHelper.hxx>
#include <ChartType.hxx>
#include <TitleHelper.hxx>
#include <ThreeDHelper.hxx>
#include <DataSeries.hxx>
#include <DataSeriesHelper.hxx>
#include "UndoGuard.hxx"
#include <ControllerLockGuard.hxx>
#include <ResId.hxx>
#include <strings.hrc>
#include <ObjectIdentifier.hxx>
#include <ReferenceSizeProvider.hxx>
#include <chartview/DrawModelWrapper.hxx>
#include "ChartTransferable.hxx"
#include <DrawViewWrapper.hxx>
#include <Legend.hxx>
#include <LegendHelper.hxx>
#include <Axis.hxx>
#include <AxisHelper.hxx>
#include <RegressionCurveModel.hxx>
#include <RegressionCurveHelper.hxx>
#include "ShapeController.hxx"
#include <DiagramHelper.hxx>
#include <Diagram.hxx>
#include <ObjectNameProvider.hxx>
#include <unonames.hxx>
#include <com/sun/star/awt/Gradient.hpp>
#include <com/sun/star/chart2/DataPointLabel.hpp>
#include <com/sun/star/beans/XPropertyState.hpp>
#include <com/sun/star/graphic/XGraphic.hpp>
#include <com/sun/star/drawing/TextVerticalAdjust.hpp>
#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
#include <com/sun/star/chart/ErrorBarStyle.hpp>
#include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
#include <docmodel/uno/UnoGradientTools.hxx>
#include <editeng/editview.hxx>
#include <editeng/outliner.hxx>
#include <svx/ActionDescriptionProvider.hxx>
#include <vcl/transfer.hxx>
#include <sot/storage.hxx>
#include <vcl/graph.hxx>
#include <vcl/TypeSerializer.hxx>
#include <svx/unomodel.hxx>
#include <svx/svdmodel.hxx>
#include <unotools/streamwrap.hxx>
#include <vcl/svapp.hxx>
#include <svx/dialmgr.hxx>
#include <svx/strings.hrc>
#include <svx/svditer.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdundo.hxx>
#include <svx/unoapi.hxx>
#include <svx/unopage.hxx>
#include <svx/unoshape.hxx>
#include <PropertyHelper.hxx>
#include <LibreOfficeKit/LibreOfficeKitEnums.h>
#include <tools/debug.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <tools/UnitConversion.hxx>
#include <memory>
using namespace ::com::sun::star;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
namespace chart
{
namespace
{
bool lcl_deleteDataSeries(
std::u16string_view rCID,
const rtl::Reference<::chart::ChartModel> & xModel,
const Reference< document::XUndoManager > & xUndoManager )
{
bool bResult = false;
rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( rCID, xModel );
if( xSeries.is() && xModel.is())
{
rtl::Reference< ::chart::ChartType > xChartType =
DataSeriesHelper::getChartTypeOfSeries( xSeries, xModel->getFirstChartDiagram());
if( xChartType.is())
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_DATASERIES )),
xUndoManager );
rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();
rtl::Reference< Axis > xAxis = xDiagram->getAttachedAxis( xSeries );
DataSeriesHelper::deleteSeries( xSeries, xChartType );
AxisHelper::hideAxisIfNoDataIsAttached( xAxis, xDiagram );
bResult = true;
aUndoGuard.commit();
}
}
return bResult;
}
bool lcl_deleteDataCurve(
std::u16string_view rCID,
const rtl::Reference<::chart::ChartModel> & xModel,
const Reference< document::XUndoManager > & xUndoManager )
{
bool bResult = false;
uno::Reference< beans::XPropertySet > xProperties(
ObjectIdentifier::getObjectPropertySet( rCID, xModel));
uno::Reference< chart2::XRegressionCurve > xRegressionCurve( xProperties, uno::UNO_QUERY );
if( xRegressionCurve.is())
{
uno::Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer(
ObjectIdentifier::getObjectPropertySet(
ObjectIdentifier::getFullParentParticle( rCID ), xModel), uno::UNO_QUERY );
if( xRegressionCurveContainer.is())
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_CURVE )),
xUndoManager );
xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );
bResult = true;
aUndoGuard.commit();
}
}
return bResult;
}
} // anonymous namespace
std::unique_ptr<ReferenceSizeProvider> ChartController::impl_createReferenceSizeProvider()
{
awt::Size aPageSize( ChartModelHelper::getPageSize( getChartModel() ) );
return std::make_unique<ReferenceSizeProvider>(aPageSize, getChartModel());
}
void ChartController::impl_adaptDataSeriesAutoResize()
{
std::unique_ptr<ReferenceSizeProvider> pRefSizeProvider(impl_createReferenceSizeProvider());
if (pRefSizeProvider)
pRefSizeProvider->setValuesAtAllDataSeries();
}
void ChartController::executeDispatch_NewArrangement()
{
// remove manual positions at titles, legend and the diagram, remove manual
// size at the diagram
try
{
rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();
if( xDiagram.is())
{
UndoGuard aUndoGuard(
SchResId( STR_ACTION_REARRANGE_CHART ),
m_xUndoManager );
ControllerLockGuardUNO aCtlLockGuard( xModel );
// diagram
xDiagram->setPropertyToDefault( "RelativeSize");
xDiagram->setPropertyToDefault( "RelativePosition");
xDiagram->setPropertyToDefault( "PosSizeExcludeAxes");
// 3d rotation
xDiagram->set3DSettingsToDefault();
// legend
rtl::Reference< Legend > xLegend = xDiagram->getLegend2();
if( xLegend.is())
{
xLegend->setPropertyToDefault( "RelativePosition");
xLegend->setPropertyToDefault( "RelativeSize");
xLegend->setPropertyToDefault( "AnchorPosition");
}
// titles
for( sal_Int32 eType = TitleHelper::TITLE_BEGIN;
eType < TitleHelper::NORMAL_TITLE_END;
++eType )
{
rtl::Reference< Title > xTitleState =
TitleHelper::getTitle(
static_cast< TitleHelper::eTitleType >( eType ), xModel );
if( xTitleState.is())
xTitleState->setPropertyToDefault( "RelativePosition");
}
// regression curve equations
std::vector< rtl::Reference< RegressionCurveModel > > aRegressionCurves =
xDiagram->getAllRegressionCurvesNotMeanValueLine();
// reset equation position
for( const auto& xCurve : aRegressionCurves )
RegressionCurveHelper::resetEquationPosition( xCurve );
aUndoGuard.commit();
}
}
catch( const uno::RuntimeException & )
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
void ChartController::executeDispatch_ScaleText()
{
SolarMutexGuard aSolarGuard;
UndoGuard aUndoGuard(
SchResId( STR_ACTION_SCALE_TEXT ),
m_xUndoManager );
ControllerLockGuardUNO aCtlLockGuard( getChartModel() );
std::unique_ptr<ReferenceSizeProvider> pRefSizeProv(impl_createReferenceSizeProvider());
OSL_ASSERT(pRefSizeProv);
if (pRefSizeProv)
pRefSizeProv->toggleAutoResizeState();
aUndoGuard.commit();
}
void ChartController::executeDispatch_Paste()
{
SolarMutexGuard aGuard;
auto pChartWindow(GetChartWindow());
if( !pChartWindow )
return;
Graphic aGraphic;
// paste location: center of window
Point aPos = pChartWindow->PixelToLogic( tools::Rectangle(Point{}, pChartWindow->GetSizePixel()).Center());
// handle different formats
TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pChartWindow ));
if( aDataHelper.GetTransferable().is())
{
if ( aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )
{
tools::SvRef<SotTempStream> xStm;
if ( aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING, xStm ) )
{
xStm->Seek( 0 );
Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );
std::unique_ptr< SdrModel > spModel(
new SdrModel());
if ( SvxDrawingLayerImport( spModel.get(), xInputStream ) )
{
impl_PasteShapes( spModel.get() );
}
}
}
else if ( aDataHelper.HasFormat( SotClipboardFormatId::SVXB ) )
{
// graphic exchange format (graphic manager bitmap format?)
tools::SvRef<SotTempStream> xStm;
if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVXB, xStm ))
{
TypeSerializer aSerializer(*xStm);
aSerializer.readGraphic(aGraphic);
}
}
else if( aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ))
{
// meta file
GDIMetaFile aMetafile;
if( aDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMetafile ))
aGraphic = Graphic( aMetafile );
}
else if( aDataHelper.HasFormat( SotClipboardFormatId::BITMAP ))
{
// bitmap (non-graphic-manager)
BitmapEx aBmpEx;
if( aDataHelper.GetBitmapEx( SotClipboardFormatId::BITMAP, aBmpEx ))
aGraphic = Graphic( aBmpEx );
}
else if( aDataHelper.HasFormat( SotClipboardFormatId::STRING ))
{
OUString aString;
if( aDataHelper.GetString( SotClipboardFormatId::STRING, aString ) && m_pDrawModelWrapper )
{
if( m_pDrawViewWrapper )
{
OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
if( pOutlinerView )//in case of edit mode insert into edited string
pOutlinerView->InsertText( aString );
else
{
impl_PasteStringAsTextShape( aString, awt::Point( 0, 0 ) );
}
}
}
}
}
if( aGraphic.GetType() != GraphicType::NONE )
{
Reference< graphic::XGraphic > xGraphic( aGraphic.GetXGraphic());
if( xGraphic.is())
impl_PasteGraphic( xGraphic, aPos );
}
}
// note: aPosition is ignored for now. The object is always pasted centered to
// the page
void ChartController::impl_PasteGraphic(
uno::Reference< graphic::XGraphic > const & xGraphic,
const ::Point & /* aPosition */ )
{
DBG_TESTSOLARMUTEX();
// note: the XPropertySet of the model is the old API. Also the property
// "AdditionalShapes" that is used there.
rtl::Reference< ChartModel > xModel = getChartModel();
DrawModelWrapper * pDrawModelWrapper( GetDrawModelWrapper());
if( ! (xGraphic.is() && xModel.is()))
return;
rtl::Reference<SvxGraphicObject> xGraphicShape = new SvxGraphicObject(nullptr);
xGraphicShape->setShapeKind(SdrObjKind::Graphic);
uno::Reference< drawing::XShapes > xPage = pDrawModelWrapper->getMainDrawPage();
if( xPage.is())
{
xPage->add( xGraphicShape );
//need to change the model state manually
xModel->setModified( true );
//select new shape
m_aSelection.setSelection( xGraphicShape );
m_aSelection.applySelection( m_pDrawViewWrapper.get() );
}
xGraphicShape->SvxShape::setPropertyValue( "Graphic", uno::Any( xGraphic ));
awt::Size aGraphicSize( 1000, 1000 );
bool bGotGraphicSize = false;
try
{
bGotGraphicSize = xGraphicShape->SvxShape::getPropertyValue( "Size100thMM") >>= aGraphicSize;
}
catch (css::beans::UnknownPropertyException& )
{}
auto pChartWindow(GetChartWindow());
// first try size in 100th mm, then pixel size
if( !bGotGraphicSize )
{
bool bGotSizePixel = false;
try
{
bGotSizePixel = xGraphicShape->SvxShape::getPropertyValue( "SizePixel") >>= aGraphicSize;
}
catch (css::beans::UnknownPropertyException& )
{}
if ( bGotSizePixel && pChartWindow )
{
::Size aVCLSize( pChartWindow->PixelToLogic( Size( aGraphicSize.Width, aGraphicSize.Height )));
aGraphicSize.Width = aVCLSize.getWidth();
aGraphicSize.Height = aVCLSize.getHeight();
}
}
xGraphicShape->setSize( aGraphicSize );
xGraphicShape->setPosition( awt::Point( 0, 0 ) );
}
void ChartController::impl_PasteShapes( SdrModel* pModel )
{
DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );
if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )
return;
Reference< drawing::XDrawPage > xDestPage( pDrawModelWrapper->getMainDrawPage() );
SdrPage* pDestPage = GetSdrPageFromXDrawPage( xDestPage );
if ( !pDestPage )
return;
Reference< drawing::XShape > xSelShape;
m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
sal_uInt16 nCount = pModel->GetPageCount();
for ( sal_uInt16 i = 0; i < nCount; ++i )
{
const SdrPage* pPage = pModel->GetPage( i );
SdrObjListIter aIter( pPage, SdrIterMode::DeepNoGroups );
while ( aIter.IsMore() )
{
SdrObject* pObj(aIter.Next());
// Clone to new SdrModel
rtl::Reference<SdrObject> pNewObj;
if (pObj)
pNewObj = pObj->CloneSdrObject(pDrawModelWrapper->getSdrModel());
if ( pNewObj )
{
// set position
Reference< drawing::XShape > xShape( pNewObj->getUnoShape(), uno::UNO_QUERY );
if ( xShape.is() )
{
xShape->setPosition( awt::Point( 0, 0 ) );
}
pDestPage->InsertObject( pNewObj.get() );
m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pNewObj ) );
xSelShape = xShape;
}
}
}
rtl::Reference< ChartModel > xModifiable = getChartModel();
if ( xModifiable.is() )
{
xModifiable->setModified( true );
}
// select last inserted shape
m_aSelection.setSelection( xSelShape );
m_aSelection.applySelection( m_pDrawViewWrapper.get() );
m_pDrawViewWrapper->EndUndo();
impl_switchDiagramPositioningToExcludingPositioning();
}
void ChartController::impl_PasteStringAsTextShape( const OUString& rString, const awt::Point& rPosition )
{
DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );
if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )
return;
const Reference< drawing::XDrawPage >& xDrawPage( pDrawModelWrapper->getMainDrawPage() );
OSL_ASSERT( xDrawPage.is() );
if ( !xDrawPage )
return;
try
{
rtl::Reference<SvxShapeText> xTextShape = new SvxShapeText(nullptr);
xTextShape->setShapeKind(SdrObjKind::Text);
xDrawPage->add( xTextShape );
xTextShape->setString( rString );
float fCharHeight = 10.0;
xTextShape->SvxShape::setPropertyValue( "TextAutoGrowHeight", uno::Any( true ) );
xTextShape->SvxShape::setPropertyValue( "TextAutoGrowWidth", uno::Any( true ) );
xTextShape->SvxShape::setPropertyValue( "CharHeight", uno::Any( fCharHeight ) );
xTextShape->SvxShape::setPropertyValue( "CharHeightAsian", uno::Any( fCharHeight ) );
xTextShape->SvxShape::setPropertyValue( "CharHeightComplex", uno::Any( fCharHeight ) );
xTextShape->SvxShape::setPropertyValue( "TextVerticalAdjust", uno::Any( drawing::TextVerticalAdjust_CENTER ) );
xTextShape->SvxShape::setPropertyValue( "TextHorizontalAdjust", uno::Any( drawing::TextHorizontalAdjust_CENTER ) );
xTextShape->SvxShape::setPropertyValue( "CharFontName", uno::Any( OUString("Albany") ) );
xTextShape->setPosition( rPosition );
m_aSelection.setSelection( xTextShape );
m_aSelection.applySelection( m_pDrawViewWrapper.get() );
SdrObject* pObj = DrawViewWrapper::getSdrObject( xTextShape );
if ( pObj )
{
m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pObj ) );
m_pDrawViewWrapper->EndUndo();
impl_switchDiagramPositioningToExcludingPositioning();
}
}
catch ( const uno::Exception& )
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
void ChartController::executeDispatch_Copy()
{
SolarMutexGuard aSolarGuard;
if (!m_pDrawViewWrapper)
return;
OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
if (pOutlinerView)
pOutlinerView->Copy();
else
{
SdrObject* pSelectedObj = nullptr;
ObjectIdentifier aSelOID(m_aSelection.getSelectedOID());
if (aSelOID.isAutoGeneratedObject())
pSelectedObj = m_pDrawModelWrapper->getNamedSdrObject( aSelOID.getObjectCID() );
else if (aSelOID.isAdditionalShape())
pSelectedObj = DrawViewWrapper::getSdrObject( aSelOID.getAdditionalShape() );
if (pSelectedObj)
{
Reference<datatransfer::clipboard::XClipboard> xClipboard(GetChartWindow()->GetClipboard());
if (xClipboard.is())
{
Reference< datatransfer::XTransferable > xTransferable(
new ChartTransferable(m_pDrawModelWrapper->getSdrModel(),
pSelectedObj, aSelOID.isAdditionalShape()));
xClipboard->setContents(xTransferable, Reference< datatransfer::clipboard::XClipboardOwner >());
}
}
}
}
void ChartController::executeDispatch_Cut()
{
executeDispatch_Copy();
executeDispatch_Delete();
}
bool ChartController::isObjectDeleteable( const uno::Any& rSelection )
{
ObjectIdentifier aSelOID( rSelection );
if ( aSelOID.isAutoGeneratedObject() )
{
const OUString& aSelObjCID( aSelOID.getObjectCID() );
ObjectType aObjectType(ObjectIdentifier::getObjectType( aSelObjCID ));
switch(aObjectType)
{
case OBJECTTYPE_TITLE:
case OBJECTTYPE_LEGEND:
case OBJECTTYPE_DATA_SERIES:
case OBJECTTYPE_LEGEND_ENTRY:
case OBJECTTYPE_DATA_CURVE_EQUATION:
case OBJECTTYPE_DATA_CURVE:
case OBJECTTYPE_DATA_AVERAGE_LINE:
case OBJECTTYPE_DATA_ERRORS_X:
case OBJECTTYPE_DATA_ERRORS_Y:
case OBJECTTYPE_DATA_ERRORS_Z:
case OBJECTTYPE_DATA_LABELS:
case OBJECTTYPE_DATA_LABEL:
case OBJECTTYPE_AXIS:
case OBJECTTYPE_GRID:
case OBJECTTYPE_SUBGRID:
return true;
default:
break;
}
}
else if ( aSelOID.isAdditionalShape() )
{
return true;
}
return false;
}
bool ChartController::isShapeContext() const
{
return m_aSelection.isAdditionalShapeSelected() ||
( m_pDrawViewWrapper && m_pDrawViewWrapper->AreObjectsMarked() &&
( m_pDrawViewWrapper->GetCurrentObjIdentifier() == SdrObjKind::Text ) );
}
void ChartController::impl_ClearSelection()
{
if( m_aSelection.hasSelection())
{
m_aSelection.clearSelection();
impl_notifySelectionChangeListeners();
}
}
bool ChartController::executeDispatch_Delete()
{
bool bReturn = false;
// remove the selected object
OUString aCID( m_aSelection.getSelectedCID() );
if( !aCID.isEmpty() )
{
if( !isObjectDeleteable( uno::Any( aCID ) ) )
return false;
//remove chart object
rtl::Reference< ChartModel > xChartDoc = getChartModel();
if( !xChartDoc.is() )
return false;
ObjectType aObjectType( ObjectIdentifier::getObjectType( aCID ));
switch( aObjectType )
{
case OBJECTTYPE_TITLE:
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_TITLE )),
m_xUndoManager );
TitleHelper::removeTitle(
ObjectIdentifier::getTitleTypeForCID( aCID ), getChartModel() );
bReturn = true;
aUndoGuard.commit();
break;
}
case OBJECTTYPE_LEGEND:
{
rtl::Reference< Diagram > xDiagram( xChartDoc->getFirstChartDiagram());
if( xDiagram.is())
{
rtl::Reference< Legend > xLegend( xDiagram->getLegend2() );
if( xLegend.is())
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_LEGEND )),
m_xUndoManager );
xLegend->setPropertyValue( "Show", uno::Any( false ));
bReturn = true;
aUndoGuard.commit();
}
}
break;
}
case OBJECTTYPE_DATA_SERIES:
bReturn = lcl_deleteDataSeries( aCID, getChartModel(), m_xUndoManager );
break;
case OBJECTTYPE_LEGEND_ENTRY:
{
ObjectType eParentObjectType = ObjectIdentifier::getObjectType(
ObjectIdentifier::getFullParentParticle( aCID ));
if( eParentObjectType == OBJECTTYPE_DATA_SERIES )
{
bReturn = lcl_deleteDataSeries( aCID, getChartModel(), m_xUndoManager );
}
else if( eParentObjectType == OBJECTTYPE_DATA_CURVE )
{
sal_Int32 nEndPos = aCID.lastIndexOf(':');
OUString aParentCID = aCID.copy(0, nEndPos);
bReturn = lcl_deleteDataCurve(aParentCID, getChartModel(), m_xUndoManager );
}
else if( eParentObjectType == OBJECTTYPE_DATA_AVERAGE_LINE )
{
executeDispatch_DeleteMeanValue();
bReturn = true;
}
break;
}
case OBJECTTYPE_DATA_AVERAGE_LINE:
{
uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
ObjectIdentifier::getObjectPropertySet(
ObjectIdentifier::getFullParentParticle( aCID ), getChartModel()), uno::UNO_QUERY );
if( xRegCurveCnt.is())
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_AVERAGE_LINE )),
m_xUndoManager );
RegressionCurveHelper::removeMeanValueLine( xRegCurveCnt );
bReturn = true;
aUndoGuard.commit();
}
}
break;
case OBJECTTYPE_DATA_CURVE:
{
bReturn = lcl_deleteDataCurve( aCID, getChartModel(), m_xUndoManager );
}
break;
case OBJECTTYPE_DATA_CURVE_EQUATION:
{
uno::Reference< beans::XPropertySet > xEqProp(
ObjectIdentifier::getObjectPropertySet( aCID, getChartModel()));
if( xEqProp.is())
{
rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_CURVE_EQUATION )),
m_xUndoManager );
{
ControllerLockGuardUNO aCtlLockGuard( xModel );
xEqProp->setPropertyValue( "ShowEquation", uno::Any( false ));
xEqProp->setPropertyValue( "XName", uno::Any( OUString("x") ));
xEqProp->setPropertyValue( "YName", uno::Any( OUString("f(x)") ));
xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::Any( false ));
}
bReturn = true;
aUndoGuard.commit();
}
}
break;
case OBJECTTYPE_DATA_ERRORS_X:
case OBJECTTYPE_DATA_ERRORS_Y:
case OBJECTTYPE_DATA_ERRORS_Z:
{
uno::Reference< beans::XPropertySet > xErrorBarProp(
ObjectIdentifier::getObjectPropertySet( aCID, getChartModel() ));
if( xErrorBarProp.is())
{
TranslateId pId;
if ( aObjectType == OBJECTTYPE_DATA_ERRORS_X )
pId = STR_OBJECT_ERROR_BARS_X;
else if ( aObjectType == OBJECTTYPE_DATA_ERRORS_Y )
pId = STR_OBJECT_ERROR_BARS_Y;
else
pId = STR_OBJECT_ERROR_BARS_Z;
rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete, SchResId(pId)),
m_xUndoManager);
{
ControllerLockGuardUNO aCtlLockGuard( xModel );
xErrorBarProp->setPropertyValue(
"ErrorBarStyle",
uno::Any( css::chart::ErrorBarStyle::NONE ));
}
bReturn = true;
aUndoGuard.commit();
}
break;
}
case OBJECTTYPE_DATA_LABELS:
case OBJECTTYPE_DATA_LABEL:
{
uno::Reference< beans::XPropertySet > xObjectProperties =
ObjectIdentifier::getObjectPropertySet( aCID, getChartModel() );
if( xObjectProperties.is() )
{
UndoGuard aUndoGuard(
ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::Delete,
SchResId( aObjectType == OBJECTTYPE_DATA_LABEL ? STR_OBJECT_LABEL : STR_OBJECT_DATALABELS )),
m_xUndoManager );
chart2::DataPointLabel aLabel;
xObjectProperties->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
aLabel.ShowNumber = false;
aLabel.ShowNumberInPercent = false;
aLabel.ShowCategoryName = false;
aLabel.ShowLegendSymbol = false;
aLabel.ShowCustomLabel = false;
aLabel.ShowSeriesName = false;
if( aObjectType == OBJECTTYPE_DATA_LABELS )
{
rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( aCID, getChartModel() );
DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, CHART_UNONAME_LABEL, uno::Any(aLabel) );
DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, CHART_UNONAME_CUSTOM_LABEL_FIELDS, uno::Any() );
}
else
{
xObjectProperties->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
xObjectProperties->setPropertyValue(CHART_UNONAME_CUSTOM_LABEL_FIELDS, uno::Any());
}
bReturn = true;
aUndoGuard.commit();
}
break;
}
case OBJECTTYPE_AXIS:
{
executeDispatch_DeleteAxis();
bReturn = true;
break;
}
case OBJECTTYPE_GRID:
{
executeDispatch_DeleteMajorGrid();
bReturn = true;
break;
}
case OBJECTTYPE_SUBGRID:
{
executeDispatch_DeleteMinorGrid();
bReturn = true;
break;
}
default:
{
break;
}
}
}
else
{
//remove additional shape
impl_ClearSelection();
{
SolarMutexGuard aSolarGuard;
if ( m_pDrawViewWrapper )
{
m_pDrawViewWrapper->DeleteMarked();
bReturn = true;
}
}
}
return bReturn;
}
void ChartController::executeDispatch_ToggleLegend()
{
rtl::Reference< ChartModel > xModel = getChartModel();
UndoGuard aUndoGuard(
SchResId( STR_ACTION_TOGGLE_LEGEND ), m_xUndoManager );
rtl::Reference< Legend > xLegendProp = LegendHelper::getLegend(*xModel);
bool bChanged = false;
if( xLegendProp.is())
{
try
{
bool bShow = false;
if( xLegendProp->getPropertyValue( "Show") >>= bShow )
{
xLegendProp->setPropertyValue( "Show", uno::Any( ! bShow ));
bChanged = true;
}
}
catch( const uno::Exception & )
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
else
{
xLegendProp = LegendHelper::getLegend(*xModel, m_xCC, true);
if( xLegendProp.is())
bChanged = true;
}
if( bChanged )
aUndoGuard.commit();
}
void ChartController::executeDispatch_ToggleGridHorizontal()
{
UndoGuard aUndoGuard(
SchResId( STR_ACTION_TOGGLE_GRID_HORZ ), m_xUndoManager );
rtl::Reference< Diagram > xDiagram( getFirstDiagram() );
if( !xDiagram.is())
return;
sal_Int32 nDimensionIndex = 1;
sal_Int32 nCooSysIndex = 0;
bool bHasMajorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true, xDiagram );
bool bHasMinorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
if( bHasMajorYGrid )
{
if ( bHasMinorYGrid )
{
AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
}
else
{
AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
}
}
else
{
AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
}
aUndoGuard.commit();
}
void ChartController::executeDispatch_ToggleGridVertical()
{
UndoGuard aUndoGuard(
SchResId( STR_ACTION_TOGGLE_GRID_VERTICAL ), m_xUndoManager );
rtl::Reference< Diagram > xDiagram( getFirstDiagram() );
if( !xDiagram.is())
return;
sal_Int32 nDimensionIndex = 0;
sal_Int32 nCooSysIndex = 0;
bool bHasMajorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true, xDiagram );
bool bHasMinorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
if( bHasMajorXGrid )
{
if (bHasMinorXGrid)
{
AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
}
else
{
AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
}
}
else
{
AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
}
aUndoGuard.commit();
}
void ChartController::executeDispatch_FillColor(sal_uInt32 nColor)
{
try
{
OUString aCID( m_aSelection.getSelectedCID() );
rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
if( xChartModel.is() )
{
Reference< beans::XPropertySet > xPointProperties(
ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
if( xPointProperties.is() )
xPointProperties->setPropertyValue( "FillColor", uno::Any( nColor ) );
}
}
catch( const uno::Exception& )
{
DBG_UNHANDLED_EXCEPTION( "chart2" );
}
}
void ChartController::executeDispatch_FillGradient(std::u16string_view sJSONGradient)
{
basegfx::BGradient aBGradient = basegfx::BGradient::fromJSON(sJSONGradient);
css::awt::Gradient aGradient = model::gradient::createUnoGradient2(aBGradient);
try
{
OUString aCID( m_aSelection.getSelectedCID() );
rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
if( xChartModel.is() )
{
Reference< beans::XPropertySet > xPropSet(
ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
if( xPropSet.is() )
{
OUString aPrefferedName =
OUString::number(static_cast<sal_Int32>(Color(aBGradient.GetColorStops().front().getStopColor())))
+ OUString::number(static_cast<sal_Int32>(Color(aBGradient.GetColorStops().back().getStopColor())))
+ OUString::number(static_cast<sal_Int32>(aBGradient.GetAngle().get()));
OUString aNewName = PropertyHelper::addGradientUniqueNameToTable(css::uno::Any(aGradient),
xChartModel,
aPrefferedName);
xPropSet->setPropertyValue("FillGradientName", css::uno::Any(aNewName));
}
}
}
catch( const uno::Exception & )
{
TOOLS_WARN_EXCEPTION("chart2", "" );
}
}
void ChartController::executeDispatch_LineColor(sal_uInt32 nColor)
{
try
{
OUString aCID( m_aSelection.getSelectedCID() );
rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
if( xChartModel.is() )
{
Reference< beans::XPropertySet > xPropSet(
ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
ObjectType eType = ObjectIdentifier::getObjectType(aCID);
if (eType == OBJECTTYPE_DIAGRAM)
{
css::uno::Reference<css::chart2::XDiagram> xDiagram(
xPropSet, css::uno::UNO_QUERY);
if (xDiagram.is())
xPropSet.set(xDiagram->getWall());
}
if( xPropSet.is() )
xPropSet->setPropertyValue( "LineColor", css::uno::Any( Color(ColorTransparency, nColor) ) );
}
}
catch( const uno::Exception& )
{
DBG_UNHANDLED_EXCEPTION( "chart2" );
}
}
void ChartController::executeDispatch_LineWidth(sal_uInt32 nWidth)
{
try
{
OUString aCID( m_aSelection.getSelectedCID() );
rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
if( xChartModel.is() )
{
Reference< beans::XPropertySet > xPropSet(
ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
ObjectType eType = ObjectIdentifier::getObjectType(aCID);
if (eType == OBJECTTYPE_DIAGRAM)
{
css::uno::Reference<css::chart2::XDiagram> xDiagram(
xPropSet, css::uno::UNO_QUERY);
if (xDiagram.is())
xPropSet.set(xDiagram->getWall());
}
if( xPropSet.is() )
xPropSet->setPropertyValue( "LineWidth", css::uno::Any( nWidth ) );
}
}
catch( const uno::Exception& )
{
DBG_UNHANDLED_EXCEPTION( "chart2" );
}
}
void ChartController::executeDispatch_LOKSetTextSelection(int nType, int nX, int nY)
{
if (!m_pDrawViewWrapper)
return;
if (!m_pDrawViewWrapper->IsTextEdit())
return;
OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
if (!pOutlinerView)
return;
EditView& rEditView = pOutlinerView->GetEditView();
Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
switch (nType)
{
case LOK_SETTEXTSELECTION_START:
rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/false, /*bClearMark=*/false);
break;
case LOK_SETTEXTSELECTION_END:
rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/false);
break;
case LOK_SETTEXTSELECTION_RESET:
rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/true);
break;
default:
assert(false);
break;
}
}
void ChartController::executeDispatch_LOKPieSegmentDragging( int nOffset )
{
try
{
OUString aCID( m_aSelection.getSelectedCID() );
rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
if( xChartModel.is() )
{
Reference< beans::XPropertySet > xPointProperties(
ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
if( xPointProperties.is() )
xPointProperties->setPropertyValue( "Offset", uno::Any( nOffset / 100.0 ) );
}
}
catch( const uno::Exception & )
{
TOOLS_WARN_EXCEPTION("chart2", "" );
}
}
void ChartController::impl_ShapeControllerDispatch( const util::URL& rURL, const Sequence< beans::PropertyValue >& rArgs )
{
Reference< frame::XDispatch > xDispatch( m_aDispatchContainer.getShapeController() );
if ( xDispatch.is() )
{
xDispatch->dispatch( rURL, rArgs );
}
}
void ChartController::impl_switchDiagramPositioningToExcludingPositioning()
{
UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription(
ActionDescriptionProvider::ActionType::PosSize,
ObjectNameProvider::getName( OBJECTTYPE_DIAGRAM)),
m_xUndoManager );
if (DiagramHelper::switchDiagramPositioningToExcludingPositioning(*getChartModel(), true, true))
aUndoGuard.commit();
}
} // namespace chart
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
View Git Blame Copy Permalink