904 lines
38 KiB
C++
904 lines
38 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 <config_features.h>
|
|
|
|
#include <DrawViewShell.hxx>
|
|
#include <svx/svdpagv.hxx>
|
|
#include <svx/xfillit0.hxx>
|
|
#include <svx/xlineit0.hxx>
|
|
#include <svx/xlnwtit.hxx>
|
|
#include <svx/xlndsit.hxx>
|
|
#include <svx/xflhtit.hxx>
|
|
#include <svx/xflgrit.hxx>
|
|
#include <svx/xlnclit.hxx>
|
|
#include <svx/xflclit.hxx>
|
|
#include <sfx2/bindings.hxx>
|
|
|
|
#include <sfx2/dispatch.hxx>
|
|
#include <svl/intitem.hxx>
|
|
#include <sfx2/request.hxx>
|
|
#include <svl/stritem.hxx>
|
|
#include <svx/svxids.hrc>
|
|
#include <svx/xtable.hxx>
|
|
#include <vcl/graph.hxx>
|
|
#include <svx/svdograf.hxx>
|
|
#include <svl/whiter.hxx>
|
|
#include <basic/sbstar.hxx>
|
|
#include <basic/sberrors.hxx>
|
|
|
|
#include <sfx2/viewfrm.hxx>
|
|
|
|
#include <app.hrc>
|
|
#include <strings.hrc>
|
|
#include <Window.hxx>
|
|
#include <drawdoc.hxx>
|
|
#include <drawview.hxx>
|
|
#include <DrawDocShell.hxx>
|
|
#include <sdresid.hxx>
|
|
|
|
#include <svx/galleryitem.hxx>
|
|
#include <com/sun/star/gallery/GalleryItemType.hpp>
|
|
#include <com/sun/star/drawing/LineStyle.hpp>
|
|
#include <memory>
|
|
|
|
using namespace com::sun::star;
|
|
|
|
namespace sd {
|
|
|
|
void DrawViewShell::ExecGallery(SfxRequest const & rReq)
|
|
{
|
|
// nothing is executed during a slide show!
|
|
if(HasCurrentFunction(SID_PRESENTATION))
|
|
return;
|
|
|
|
const SfxItemSet* pArgs = rReq.GetArgs();
|
|
|
|
const SvxGalleryItem* pGalleryItem = SfxItemSet::GetItem<SvxGalleryItem>(pArgs, SID_GALLERY_FORMATS, false);
|
|
if ( !pGalleryItem )
|
|
return;
|
|
|
|
GetDocSh()->SetWaitCursor( true );
|
|
|
|
sal_Int8 nType( pGalleryItem->GetType() );
|
|
// insert graphic
|
|
if (nType == css::gallery::GalleryItemType::GRAPHIC)
|
|
{
|
|
Graphic aGraphic( pGalleryItem->GetGraphic() );
|
|
|
|
// reduce size if necessary
|
|
ScopedVclPtrInstance< Window > aWindow(GetActiveWindow());
|
|
aWindow->SetMapMode(aGraphic.GetPrefMapMode());
|
|
Size aSizePix = aWindow->LogicToPixel(aGraphic.GetPrefSize());
|
|
aWindow->SetMapMode( MapMode(MapUnit::Map100thMM) );
|
|
Size aSize = aWindow->PixelToLogic(aSizePix);
|
|
|
|
// constrain size to page size if necessary
|
|
SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage();
|
|
Size aPageSize = pPage->GetSize();
|
|
aPageSize.AdjustWidth( -(pPage->GetLeftBorder() + pPage->GetRightBorder()) );
|
|
aPageSize.AdjustHeight( -(pPage->GetUpperBorder() + pPage->GetLowerBorder()) );
|
|
|
|
// If the image is too large we make it fit into the page
|
|
if ( ( ( aSize.Height() > aPageSize.Height() ) || ( aSize.Width() > aPageSize.Width() ) ) &&
|
|
aSize.Height() && aPageSize.Height() )
|
|
{
|
|
float fGrfWH = static_cast<float>(aSize.Width()) /
|
|
static_cast<float>(aSize.Height());
|
|
float fWinWH = static_cast<float>(aPageSize.Width()) /
|
|
static_cast<float>(aPageSize.Height());
|
|
|
|
// constrain size to page size if necessary
|
|
if ((fGrfWH != 0.F) && (fGrfWH < fWinWH))
|
|
{
|
|
aSize.setWidth( static_cast<::tools::Long>(aPageSize.Height() * fGrfWH) );
|
|
aSize.setHeight( aPageSize.Height() );
|
|
}
|
|
else
|
|
{
|
|
aSize.setWidth( aPageSize.Width() );
|
|
aSize.setHeight( static_cast<::tools::Long>(aPageSize.Width() / fGrfWH) );
|
|
}
|
|
}
|
|
|
|
// set output rectangle for graphic
|
|
Point aPnt ((aPageSize.Width() - aSize.Width()) / 2,
|
|
(aPageSize.Height() - aSize.Height()) / 2);
|
|
aPnt += Point(pPage->GetLeftBorder(), pPage->GetUpperBorder());
|
|
::tools::Rectangle aRect (aPnt, aSize);
|
|
|
|
rtl::Reference<SdrGrafObj> pGrafObj;
|
|
|
|
bool bInsertNewObject = true;
|
|
|
|
const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
|
|
if ( rMarkList.GetMarkCount() != 0 )
|
|
{
|
|
// is there an empty graphic object?
|
|
if (rMarkList.GetMarkCount() == 1)
|
|
{
|
|
SdrMark* pMark = rMarkList.GetMark(0);
|
|
SdrObject* pObj = pMark->GetMarkedSdrObj();
|
|
|
|
if (pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == SdrObjKind::Graphic)
|
|
{
|
|
pGrafObj = static_cast<SdrGrafObj*>(pObj);
|
|
|
|
if( pGrafObj->IsEmptyPresObj() )
|
|
{
|
|
// the empty graphic object gets a new graphic
|
|
bInsertNewObject = false;
|
|
|
|
rtl::Reference<SdrGrafObj> pNewGrafObj(SdrObject::Clone(*pGrafObj, pGrafObj->getSdrModelFromSdrObject()));
|
|
pNewGrafObj->SetEmptyPresObj(false);
|
|
pNewGrafObj->SetOutlinerParaObject(std::nullopt);
|
|
pNewGrafObj->SetGraphic(aGraphic);
|
|
|
|
OUString aStr = rMarkList.GetMarkDescription() +
|
|
" " + SdResId(STR_UNDO_REPLACE);
|
|
mpDrawView->BegUndo(aStr);
|
|
SdrPageView* pPV = mpDrawView->GetSdrPageView();
|
|
mpDrawView->ReplaceObjectAtView(pGrafObj.get(), *pPV, pNewGrafObj.get());
|
|
mpDrawView->EndUndo();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bInsertNewObject )
|
|
{
|
|
pGrafObj = new SdrGrafObj(
|
|
GetView()->getSdrModelFromSdrView(),
|
|
aGraphic,
|
|
aRect);
|
|
SdrPageView* pPV = mpDrawView->GetSdrPageView();
|
|
mpDrawView->InsertObjectAtView(pGrafObj.get(), *pPV, SdrInsertFlags::SETDEFLAYER);
|
|
}
|
|
}
|
|
// insert sound
|
|
else if( nType == css::gallery::GalleryItemType::MEDIA )
|
|
{
|
|
const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGalleryItem->GetURL() );
|
|
GetViewFrame()->GetDispatcher()->ExecuteList(SID_INSERT_AVMEDIA,
|
|
SfxCallMode::SYNCHRON, { &aMediaURLItem });
|
|
}
|
|
|
|
GetDocSh()->SetWaitCursor( false );
|
|
}
|
|
|
|
/**
|
|
* Edit macros for attribute configuration
|
|
*/
|
|
|
|
/* the work flow to adjust the attributes is nearly everywhere the same
|
|
1. read existing attributes
|
|
2. read parameter from the basic-set
|
|
3. delete selected item from the attribute-set
|
|
4. create new attribute-item
|
|
5. insert item into set */
|
|
void DrawViewShell::AttrExec (SfxRequest &rReq)
|
|
{
|
|
// nothing is executed during a slide show!
|
|
if(HasCurrentFunction(SID_PRESENTATION))
|
|
return;
|
|
|
|
CheckLineTo (rReq);
|
|
|
|
SfxBindings& rBindings = GetViewFrame()->GetBindings();
|
|
SfxItemSet aAttr( GetDoc()->GetPool() );
|
|
|
|
GetView()->GetAttributes( aAttr );
|
|
const SfxItemSet* pArgs = rReq.GetArgs();
|
|
|
|
switch (rReq.GetSlot ())
|
|
{
|
|
// set new fill-style
|
|
case SID_SETFILLSTYLE :
|
|
if (pArgs && pArgs->Count () == 1)
|
|
{
|
|
const SfxUInt32Item* pFillStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
|
|
if (CHECK_RANGE (drawing::FillStyle_NONE, static_cast<drawing::FillStyle>(pFillStyle->GetValue ()), drawing::FillStyle_BITMAP))
|
|
{
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
XFillStyleItem aStyleItem(static_cast<drawing::FillStyle>(pFillStyle->GetValue ()));
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put (aStyleItem);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
|
|
#endif
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
// determine new line style
|
|
case SID_SETLINESTYLE :
|
|
if (pArgs && pArgs->Count () == 1)
|
|
{
|
|
const SfxUInt32Item* pLineStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
|
|
if (CHECK_RANGE (sal_Int32(drawing::LineStyle_NONE), static_cast<sal_Int32>(pLineStyle->GetValue()), sal_Int32(drawing::LineStyle_DASH)))
|
|
{
|
|
aAttr.ClearItem (XATTR_LINESTYLE);
|
|
XLineStyleItem aStyleItem(static_cast<drawing::LineStyle>(pLineStyle->GetValue()));
|
|
aStyleItem.SetWhich(XATTR_LINESTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
rBindings.Invalidate (SID_ATTR_LINE_STYLE);
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
|
|
#endif
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
// set line width
|
|
case SID_SETLINEWIDTH :
|
|
if (pArgs && pArgs->Count () == 1)
|
|
{
|
|
const SfxUInt32Item* pLineWidth = rReq.GetArg<SfxUInt32Item>(ID_VAL_WIDTH);
|
|
aAttr.ClearItem (XATTR_LINEWIDTH);
|
|
XLineWidthItem aWidthItem(pLineWidth->GetValue());
|
|
aWidthItem.SetWhich(XATTR_LINEWIDTH);
|
|
aAttr.Put(aWidthItem);
|
|
rBindings.Invalidate (SID_ATTR_LINE_WIDTH);
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SETFILLCOLOR :
|
|
if (pArgs && pArgs->Count () == 3)
|
|
{
|
|
const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
|
|
const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
|
|
const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
|
|
|
|
aAttr.ClearItem (XATTR_FILLCOLOR);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
XFillColorItem aColorItem(-1, Color (static_cast<sal_uInt8>(pRed->GetValue ()),
|
|
static_cast<sal_uInt8>(pGreen->GetValue ()),
|
|
static_cast<sal_uInt8>(pBlue->GetValue ())));
|
|
aColorItem.SetWhich(XATTR_FILLCOLOR);
|
|
aAttr.Put(aColorItem);
|
|
rBindings.Invalidate (SID_ATTR_FILL_COLOR);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_COLOR);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SETLINECOLOR :
|
|
if (pArgs && pArgs->Count () == 3)
|
|
{
|
|
const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
|
|
const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
|
|
const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
|
|
|
|
aAttr.ClearItem (XATTR_LINECOLOR);
|
|
XLineColorItem aColorItem(-1, Color(static_cast<sal_uInt8>(pRed->GetValue()),
|
|
static_cast<sal_uInt8>(pGreen->GetValue()),
|
|
static_cast<sal_uInt8>(pBlue->GetValue())));
|
|
aColorItem.SetWhich(XATTR_LINECOLOR);
|
|
aAttr.Put(aColorItem);
|
|
rBindings.Invalidate (SID_ATTR_LINE_COLOR);
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SETGRADSTARTCOLOR :
|
|
case SID_SETGRADENDCOLOR :
|
|
if (pArgs && pArgs->Count () == 4)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
|
|
const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
|
|
const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
|
|
assert(pName && pRed && pGreen && pBlue && "must be present");
|
|
|
|
XGradientListRef pGradientList = GetDoc()->GetGradientList ();
|
|
::tools::Long nCounts = pGradientList->Count ();
|
|
Color aColor (static_cast<sal_uInt8>(pRed->GetValue ()),
|
|
static_cast<sal_uInt8>(pGreen->GetValue ()),
|
|
static_cast<sal_uInt8>(pBlue->GetValue ()));
|
|
::tools::Long i;
|
|
|
|
aAttr.ClearItem (XATTR_FILLGRADIENT);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
|
|
for ( i = 0; i < nCounts; i ++)
|
|
{
|
|
const XGradientEntry* pEntry = pGradientList->GetGradient(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
basegfx::BGradient aGradient(pEntry->GetGradient());
|
|
basegfx::BColorStops aNewColorStops(aGradient.GetColorStops());
|
|
|
|
if (SID_SETGRADSTARTCOLOR == rReq.GetSlot ())
|
|
{
|
|
aNewColorStops.replaceStartColor(aColor.getBColor());
|
|
}
|
|
else
|
|
{
|
|
aNewColorStops.replaceEndColor(aColor.getBColor());
|
|
}
|
|
|
|
aGradient.SetColorStops(aNewColorStops);
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
|
|
aGradientItem.SetWhich(XATTR_FILLGRADIENT);
|
|
aAttr.Put(aGradientItem);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= nCounts)
|
|
{
|
|
Color aBlack (0, 0, 0);
|
|
basegfx::BGradient aGradient (
|
|
basegfx::BColorStops(
|
|
(rReq.GetSlot () == SID_SETGRADSTARTCOLOR)
|
|
? aColor.getBColor()
|
|
: aBlack.getBColor(),
|
|
(rReq.GetSlot () == SID_SETGRADENDCOLOR)
|
|
? aColor.getBColor()
|
|
: aBlack.getBColor()));
|
|
|
|
GetDoc()->GetGradientList()->Insert(std::make_unique<XGradientEntry>(aGradient, pName->GetValue()));
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillGradientItem aGradientItem(pName->GetValue(), aGradient);
|
|
aGradientItem.SetWhich(XATTR_FILLGRADIENT);
|
|
aAttr.Put(aGradientItem);
|
|
}
|
|
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SETHATCHCOLOR :
|
|
if (pArgs && pArgs->Count () == 4)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
|
|
const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
|
|
const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
|
|
assert(pName && pRed && pGreen && pBlue && "must be present");
|
|
|
|
XHatchListRef pHatchList = GetDoc()->GetHatchList ();
|
|
::tools::Long nCounts = pHatchList->Count ();
|
|
Color aColor (static_cast<sal_uInt8>(pRed->GetValue ()),
|
|
static_cast<sal_uInt8>(pGreen->GetValue ()),
|
|
static_cast<sal_uInt8>(pBlue->GetValue ()));
|
|
::tools::Long i;
|
|
|
|
aAttr.ClearItem (XATTR_FILLHATCH);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
|
|
for ( i = 0; i < nCounts; i ++)
|
|
{
|
|
const XHatchEntry* pEntry = pHatchList->GetHatch(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
XHatch aHatch(pEntry->GetHatch());
|
|
|
|
aHatch.SetColor (aColor);
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillHatchItem aHatchItem(pName->GetValue(), aHatch);
|
|
aHatchItem.SetWhich(XATTR_FILLHATCH);
|
|
aAttr.Put(aHatchItem);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= nCounts)
|
|
{
|
|
XHatch aHatch (aColor);
|
|
|
|
GetDoc()->GetHatchList()->Insert(std::make_unique<XHatchEntry>(aHatch, pName->GetValue()));
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
|
|
aHatchItem.SetWhich(XATTR_FILLHATCH);
|
|
aAttr.Put(aHatchItem);
|
|
}
|
|
|
|
rBindings.Invalidate (SID_ATTR_FILL_HATCH);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_HATCH);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
// configuration for line-dash
|
|
case SID_DASH :
|
|
if (pArgs && pArgs->Count () == 7)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
|
|
const SfxUInt32Item* pDots = rReq.GetArg<SfxUInt32Item>(ID_VAL_DOTS);
|
|
const SfxUInt32Item* pDotLen = rReq.GetArg<SfxUInt32Item>(ID_VAL_DOTLEN);
|
|
const SfxUInt32Item* pDashes = rReq.GetArg<SfxUInt32Item>(ID_VAL_DASHES);
|
|
const SfxUInt32Item* pDashLen = rReq.GetArg<SfxUInt32Item>(ID_VAL_DASHLEN);
|
|
const SfxUInt32Item* pDistance = rReq.GetArg<SfxUInt32Item>(ID_VAL_DISTANCE);
|
|
assert(pName && pStyle && pDots && pDotLen && pDashes && pDashLen && pDistance && "must be present");
|
|
|
|
if (CHECK_RANGE (sal_Int32(css::drawing::DashStyle_RECT), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::drawing::DashStyle_ROUNDRELATIVE)))
|
|
{
|
|
XDash aNewDash (static_cast<css::drawing::DashStyle>(pStyle->GetValue ()), static_cast<short>(pDots->GetValue ()), pDotLen->GetValue (),
|
|
static_cast<short>(pDashes->GetValue ()), pDashLen->GetValue (), pDistance->GetValue ());
|
|
|
|
aAttr.ClearItem (XATTR_LINEDASH);
|
|
aAttr.ClearItem (XATTR_LINESTYLE);
|
|
|
|
XDashListRef pDashList = GetDoc()->GetDashList();
|
|
::tools::Long nCounts = pDashList->Count ();
|
|
std::unique_ptr<XDashEntry> pEntry = std::make_unique<XDashEntry>(aNewDash, pName->GetValue());
|
|
::tools::Long i;
|
|
|
|
for ( i = 0; i < nCounts; i++ )
|
|
if (pDashList->GetDash (i)->GetName () == pName->GetValue ())
|
|
break;
|
|
|
|
if (i < nCounts)
|
|
pDashList->Replace(std::move(pEntry), i);
|
|
else
|
|
pDashList->Insert(std::move(pEntry));
|
|
|
|
XLineDashItem aDashItem(pName->GetValue(), aNewDash);
|
|
aDashItem.SetWhich(XATTR_LINEDASH);
|
|
aAttr.Put(aDashItem);
|
|
XLineStyleItem aStyleItem(drawing::LineStyle_DASH);
|
|
aStyleItem.SetWhich(XATTR_LINESTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
rBindings.Invalidate (SID_ATTR_LINE_DASH);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
|
|
#endif
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
// configuration for gradients
|
|
case SID_GRADIENT :
|
|
if (pArgs && pArgs->Count () == 8)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
|
|
const SfxUInt32Item* pAngle = rReq.GetArg<SfxUInt32Item>(ID_VAL_ANGLE);
|
|
const SfxUInt32Item* pBorder = rReq.GetArg<SfxUInt32Item>(ID_VAL_BORDER);
|
|
const SfxUInt32Item* pCenterX = rReq.GetArg<SfxUInt32Item>(ID_VAL_CENTER_X);
|
|
const SfxUInt32Item* pCenterY = rReq.GetArg<SfxUInt32Item>(ID_VAL_CENTER_Y);
|
|
const SfxUInt32Item* pStart = rReq.GetArg<SfxUInt32Item>(ID_VAL_STARTINTENS);
|
|
const SfxUInt32Item* pEnd = rReq.GetArg<SfxUInt32Item>(ID_VAL_ENDINTENS);
|
|
assert(pName && pStyle && pAngle && pBorder && pCenterX && pCenterY && pStart && pEnd && "must be present");
|
|
|
|
if (CHECK_RANGE (sal_Int32(css::awt::GradientStyle_LINEAR), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::awt::GradientStyle_RECT)) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pAngle->GetValue ()), 360) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pBorder->GetValue ()), 100) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pCenterX->GetValue ()), 100) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pCenterY->GetValue ()), 100) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pStart->GetValue ()), 100) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pEnd->GetValue ()), 100))
|
|
{
|
|
aAttr.ClearItem (XATTR_FILLGRADIENT);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
|
|
XGradientListRef pGradientList = GetDoc()->GetGradientList ();
|
|
::tools::Long nCounts = pGradientList->Count ();
|
|
::tools::Long i;
|
|
|
|
for ( i = 0; i < nCounts; i++ )
|
|
{
|
|
const XGradientEntry* pEntry = pGradientList->GetGradient(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
basegfx::BGradient aGradient(pEntry->GetGradient());
|
|
|
|
aGradient.SetGradientStyle (static_cast<css::awt::GradientStyle>(pStyle->GetValue ()));
|
|
aGradient.SetAngle (Degree10(pAngle->GetValue () * 10));
|
|
aGradient.SetBorder (static_cast<short>(pBorder->GetValue ()));
|
|
aGradient.SetXOffset (static_cast<short>(pCenterX->GetValue ()));
|
|
aGradient.SetYOffset (static_cast<short>(pCenterY->GetValue ()));
|
|
aGradient.SetStartIntens (static_cast<short>(pStart->GetValue ()));
|
|
aGradient.SetEndIntens (static_cast<short>(pEnd->GetValue ()));
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
|
|
aGradientItem.SetWhich(XATTR_FILLGRADIENT);
|
|
aAttr.Put(aGradientItem);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= nCounts)
|
|
{
|
|
Color aBlack (0, 0, 0);
|
|
basegfx::BGradient aGradient (
|
|
basegfx::BColorStops(aBlack.getBColor(), aBlack.getBColor()),
|
|
static_cast<css::awt::GradientStyle>(pStyle->GetValue ()),
|
|
Degree10(pAngle->GetValue () * 10), static_cast<short>(pCenterX->GetValue ()),
|
|
static_cast<short>(pCenterY->GetValue ()), static_cast<short>(pBorder->GetValue ()),
|
|
static_cast<short>(pStart->GetValue ()), static_cast<short>(pEnd->GetValue ()));
|
|
|
|
pGradientList->Insert(std::make_unique<XGradientEntry>(aGradient, pName->GetValue()));
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
|
|
aGradientItem.SetWhich(XATTR_FILLGRADIENT);
|
|
aAttr.Put(aGradientItem);
|
|
}
|
|
|
|
rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
|
|
#endif
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
// configuration for hatch
|
|
case SID_HATCH :
|
|
if (pArgs && pArgs->Count () == 4)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
|
|
const SfxUInt32Item* pDistance = rReq.GetArg<SfxUInt32Item>(ID_VAL_DISTANCE);
|
|
const SfxUInt32Item* pAngle = rReq.GetArg<SfxUInt32Item>(ID_VAL_ANGLE);
|
|
assert(pName && pStyle && pDistance && pAngle && "must be present");
|
|
|
|
if (CHECK_RANGE (sal_Int32(css::drawing::HatchStyle_SINGLE), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::drawing::HatchStyle_TRIPLE)) &&
|
|
CHECK_RANGE (0, static_cast<sal_Int32>(pAngle->GetValue ()), 360))
|
|
{
|
|
aAttr.ClearItem (XATTR_FILLHATCH);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
|
|
XHatchListRef pHatchList = GetDoc()->GetHatchList ();
|
|
::tools::Long nCounts = pHatchList->Count ();
|
|
::tools::Long i;
|
|
|
|
for ( i = 0; i < nCounts; i++ )
|
|
{
|
|
const XHatchEntry* pEntry = pHatchList->GetHatch(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
XHatch aHatch(pEntry->GetHatch());
|
|
|
|
aHatch.SetHatchStyle (static_cast<css::drawing::HatchStyle>(pStyle->GetValue ()));
|
|
aHatch.SetDistance (pDistance->GetValue ());
|
|
aHatch.SetAngle (Degree10(pAngle->GetValue () * 10));
|
|
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
|
|
aHatchItem.SetWhich(XATTR_FILLHATCH);
|
|
aAttr.Put(aHatchItem);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= nCounts)
|
|
{
|
|
XHatch aHatch (Color(0), static_cast<css::drawing::HatchStyle>(pStyle->GetValue ()), pDistance->GetValue (),
|
|
Degree10(pAngle->GetValue () * 10));
|
|
|
|
pHatchList->Insert(std::make_unique<XHatchEntry>(aHatch, pName->GetValue()));
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
|
|
aHatchItem.SetWhich(XATTR_FILLHATCH);
|
|
aAttr.Put(aHatchItem);
|
|
}
|
|
|
|
rBindings.Invalidate (SID_ATTR_FILL_HATCH);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
|
|
#endif
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SELECTGRADIENT :
|
|
if (pArgs && (pArgs->Count() == 1))
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
assert(pName && "must be present");
|
|
|
|
XGradientListRef pGradientList = GetDoc()->GetGradientList ();
|
|
::tools::Long nCounts = pGradientList->Count ();
|
|
|
|
for (::tools::Long i = 0; i < nCounts; i ++)
|
|
{
|
|
const XGradientEntry* pEntry = pGradientList->GetGradient(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
aAttr.ClearItem (XATTR_FILLGRADIENT);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillGradientItem aGradientItem(pName->GetValue (), pEntry->GetGradient ());
|
|
aGradientItem.SetWhich(XATTR_FILLGRADIENT);
|
|
aAttr.Put(aGradientItem);
|
|
rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_SELECTHATCH :
|
|
if (pArgs && pArgs->Count() == 1)
|
|
{
|
|
const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
|
|
assert(pName && "must be present");
|
|
|
|
XHatchListRef pHatchList = GetDoc()->GetHatchList ();
|
|
::tools::Long nCounts = pHatchList->Count ();
|
|
|
|
for (::tools::Long i = 0; i < nCounts; i ++)
|
|
{
|
|
const XHatchEntry* pEntry = pHatchList->GetHatch(i);
|
|
|
|
if (pEntry->GetName () == pName->GetValue ())
|
|
{
|
|
aAttr.ClearItem (XATTR_FILLHATCH);
|
|
aAttr.ClearItem (XATTR_FILLSTYLE);
|
|
XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
|
|
aStyleItem.SetWhich(XATTR_FILLSTYLE);
|
|
aAttr.Put(aStyleItem);
|
|
XFillHatchItem aHatchItem(pName->GetValue (), pEntry->GetHatch ());
|
|
aHatchItem.SetWhich(XATTR_FILLHATCH);
|
|
aAttr.Put(aHatchItem);
|
|
|
|
rBindings.Invalidate (SID_ATTR_FILL_HATCH);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_HATCH);
|
|
rBindings.Invalidate (SID_ATTR_FILL_STYLE);
|
|
rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
case SID_UNSELECT :
|
|
mpDrawView->UnmarkAll ();
|
|
break;
|
|
|
|
case SID_GETRED :
|
|
if (pArgs && pArgs->Count () == 1)
|
|
{
|
|
break;
|
|
}
|
|
#if HAVE_FEATURE_SCRIPTING
|
|
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
|
|
#endif
|
|
break;
|
|
|
|
/* case SID_SETFONTFAMILYNAME :
|
|
case SID_SETFONTSTYLENAME :
|
|
case SID_SETFONTFAMILY :
|
|
case SID_SETFONTPITCH :
|
|
case SID_SETFONTCHARSET :
|
|
case SID_SETFONTPOSTURE :
|
|
case SID_SETFONTWEIGHT :
|
|
case SID_SETFONTUNDERLINE :
|
|
case SID_SETFONTCROSSEDOUT :
|
|
case SID_SETFONTSHADOWED :
|
|
case SID_SETFONTCONTOUR :
|
|
case SID_SETFONTCOLOR :
|
|
case SID_SETFONTLANGUAGE :
|
|
case SID_SETFONTWORDLINE :
|
|
case SID_SETFONTCASEMAP :
|
|
case SID_SETFONTESCAPE :
|
|
case SID_SETFONTKERNING :
|
|
break;*/
|
|
|
|
default :
|
|
;
|
|
}
|
|
|
|
mpDrawView->SetAttributes (const_cast<const SfxItemSet &>(aAttr));
|
|
rReq.Ignore ();
|
|
}
|
|
|
|
/**
|
|
* Edit macros for attribute configuration
|
|
*/
|
|
void DrawViewShell::AttrState (SfxItemSet& rSet)
|
|
{
|
|
SfxWhichIter aIter (rSet);
|
|
sal_uInt16 nWhich = aIter.FirstWhich ();
|
|
SfxItemSet aAttr( GetDoc()->GetPool() );
|
|
mpDrawView->GetAttributes( aAttr );
|
|
|
|
while (nWhich)
|
|
{
|
|
switch (nWhich)
|
|
{
|
|
case SID_GETFILLSTYLE :
|
|
{
|
|
const XFillStyleItem &rFillStyleItem = aAttr.Get (XATTR_FILLSTYLE);
|
|
|
|
rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rFillStyleItem.GetValue ())));
|
|
break;
|
|
}
|
|
|
|
case SID_GETLINESTYLE :
|
|
{
|
|
const XLineStyleItem &rLineStyleItem = aAttr.Get (XATTR_LINESTYLE);
|
|
|
|
rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rLineStyleItem.GetValue ())));
|
|
break;
|
|
}
|
|
|
|
case SID_GETLINEWIDTH :
|
|
{
|
|
const XLineWidthItem &rLineWidthItem = aAttr.Get (XATTR_LINEWIDTH);
|
|
|
|
rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rLineWidthItem.GetValue ())));
|
|
break;
|
|
}
|
|
|
|
case SID_GETGREEN :
|
|
case SID_GETRED :
|
|
case SID_GETBLUE :
|
|
{
|
|
const SfxUInt32Item &rWhatKind = static_cast<const SfxUInt32Item &>( rSet.Get (ID_VAL_WHATKIND) );
|
|
Color aColor;
|
|
|
|
switch (rWhatKind.GetValue ())
|
|
{
|
|
case 1 :
|
|
{
|
|
const XLineColorItem &rLineColorItem = aAttr.Get (XATTR_LINECOLOR);
|
|
|
|
aColor = rLineColorItem.GetColorValue ();
|
|
break;
|
|
}
|
|
|
|
case 2 :
|
|
{
|
|
const XFillColorItem &rFillColorItem = aAttr.Get (XATTR_FILLCOLOR);
|
|
|
|
aColor = rFillColorItem.GetColorValue ();
|
|
break;
|
|
}
|
|
|
|
case 3 :
|
|
case 4 :
|
|
{
|
|
const XFillGradientItem &rFillGradientItem = aAttr.Get (XATTR_FILLGRADIENT);
|
|
const basegfx::BGradient &rGradient = rFillGradientItem.GetGradientValue ();
|
|
|
|
aColor = (rWhatKind.GetValue () == 3)
|
|
? Color(rGradient.GetColorStops().front().getStopColor())
|
|
: Color(rGradient.GetColorStops().back().getStopColor());
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
const XFillHatchItem &rFillHatchItem = aAttr.Get (XATTR_FILLHATCH);
|
|
const XHatch &rHatch = rFillHatchItem.GetHatchValue ();
|
|
|
|
aColor = rHatch.GetColor ();
|
|
break;
|
|
}
|
|
|
|
default :
|
|
;
|
|
}
|
|
|
|
rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>((nWhich == SID_GETRED)
|
|
? aColor.GetRed ()
|
|
: (nWhich == SID_GETGREEN)
|
|
? aColor.GetGreen ()
|
|
: aColor.GetBlue ())));
|
|
break;
|
|
}
|
|
|
|
default :
|
|
;
|
|
}
|
|
|
|
nWhich = aIter.NextWhich ();
|
|
}
|
|
}
|
|
|
|
} // end of namespace sd
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|