svx/source/sidebar/area/AreaPropertyPanelBase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <osl/diagnose.h>
  21 #include <svx/sidebar/AreaPropertyPanelBase.hxx>
  22 #include <svx/drawitem.hxx>
  23 #include <svx/itemwin.hxx>
  24 #include <svx/svxids.hrc>
  25 #include <sfx2/objsh.hxx>
  26 #include <svx/xfltrit.hxx>
  27 #include <svx/xflftrit.hxx>
  28 #include <svx/xfilluseslidebackgrounditem.hxx>
  29 #include <svx/xtable.hxx>
  30 #include <sfx2/sidebar/Panel.hxx>
  31 #include <sfx2/opengrf.hxx>
  32 #include <sfx2/weldutils.hxx>
  33 #include <tools/urlobj.hxx>
  34 #include <bitmaps.hlst>
  35 #include <comphelper/lok.hxx>
  36
  37 using namespace css;
  38 using namespace css::uno;
  39
  40 constexpr OUStringLiteral SIDEBARGRADIENT = u"sidebargradient";
  41
  42 namespace svx::sidebar {
  43
  44 namespace {
  45
  46 enum eFillStyle
  47 {
  48     NONE,
  49     SOLID,
  50     GRADIENT,
  51     HATCH,
  52     BITMAP,
  53     PATTERN,
  54     USE_BACKGROUND
  55 };
  56
  57 }
  58
  59 const sal_Int32 AreaPropertyPanelBase::DEFAULT_CENTERX = 50;
  60 const sal_Int32 AreaPropertyPanelBase::DEFAULT_CENTERY = 50;
  61 const sal_Int32 AreaPropertyPanelBase::DEFAULT_ANGLE = 0;
  62 const sal_Int32 AreaPropertyPanelBase::DEFAULT_STARTVALUE = 0;
  63 const sal_Int32 AreaPropertyPanelBase::DEFAULT_ENDVALUE = 16777215;
  64 const sal_Int32 AreaPropertyPanelBase::DEFAULT_BORDER = 0;
  65
  66 AreaPropertyPanelBase::AreaPropertyPanelBase(
  67     weld::Widget* pParent,
  68     const css::uno::Reference<css::frame::XFrame>& rxFrame)
  69     : PanelLayout(pParent, "AreaPropertyPanel", "svx/ui/sidebararea.ui"),
  70       mxFrame(rxFrame),
  71       meLastXFS(static_cast<sal_uInt16>(-1)),
  72       mnLastPosHatch(0),
  73       mnLastPosBitmap(0),
  74       mnLastPosPattern(0),
  75       mnLastTransSolid(50),
  76       mxColorTextFT(m_xBuilder->weld_label("filllabel")),
  77       mxLbFillType(m_xBuilder->weld_combo_box("fillstylearea")),
  78       mxLbFillAttr(m_xBuilder->weld_combo_box("fillattrhb")),
  79       mxLbFillGradFrom(new ColorListBox(m_xBuilder->weld_menu_button("fillgrad1"), [this]{ return GetFrameWeld(); })),
  80       mxLbFillGradTo(new ColorListBox(m_xBuilder->weld_menu_button("fillgrad2"), [this]{ return GetFrameWeld(); })),
  81       mxToolBoxColor(m_xBuilder->weld_toolbar("selectcolor")),
  82       mxColorDispatch(new ToolbarUnoDispatcher(*mxToolBoxColor, *m_xBuilder, rxFrame)),
  83       mxTrspTextFT(m_xBuilder->weld_label("transparencylabel")),
  84       mxLBTransType(m_xBuilder->weld_combo_box("transtype")),
  85       mxMTRTransparent(m_xBuilder->weld_metric_spin_button("settransparency", FieldUnit::PERCENT)),
  86       mxSldTransparent(m_xBuilder->weld_scale("transparencyslider")),
  87       mxBTNGradient(m_xBuilder->weld_toolbar("selectgradient")),
  88       mxMTRAngle(m_xBuilder->weld_metric_spin_button("gradangle", FieldUnit::DEGREE)),
  89       mxGradientStyle(m_xBuilder->weld_combo_box("gradientstyle")),
  90       mxBmpImport(m_xBuilder->weld_button("bmpimport")),
  91       maImgAxial(BMP_AXIAL),
  92       maImgElli(BMP_ELLI),
  93       maImgQuad(BMP_QUAD),
  94       maImgRadial(BMP_RADIAL),
  95       maImgSquare(BMP_SQUARE),
  96       maImgLinear(BMP_LINEAR)
  97 {
  98     Initialize();
  99 }
 100
 101 AreaPropertyPanelBase::~AreaPropertyPanelBase()
 102 {
 103     mxTrGrPopup.reset();
 104     mxColorTextFT.reset();
 105     mxLbFillType.reset();
 106     mxLbFillAttr.reset();
 107     mxColorDispatch.reset();
 108     mxToolBoxColor.reset();
 109     mxTrspTextFT.reset();
 110     mxLBTransType.reset();
 111     mxMTRTransparent.reset();
 112     mxSldTransparent.reset();
 113     mxBTNGradient.reset();
 114     mxMTRAngle.reset();
 115     mxLbFillGradFrom.reset();
 116     mxLbFillGradTo.reset();
 117     mxGradientStyle.reset();
 118     mxBmpImport.reset();
 119 }
 120
 121 void AreaPropertyPanelBase::Initialize()
 122 {
 123     SvxFillTypeBox::Fill(*mxLbFillType);
 124
 125     mxLbFillAttr->set_size_request(42, -1);
 126
 127     maGradientLinear.SetXOffset(DEFAULT_CENTERX);
 128     maGradientLinear.SetYOffset(DEFAULT_CENTERY);
 129     maGradientLinear.SetAngle(Degree10(DEFAULT_ANGLE));
 130     maGradientLinear.SetColorStops(
 131         basegfx::BColorStops(
 132             Color(DEFAULT_STARTVALUE).getBColor(),
 133             Color(DEFAULT_ENDVALUE).getBColor()));
 134     maGradientLinear.SetBorder(DEFAULT_BORDER);
 135     maGradientLinear.SetGradientStyle(css::awt::GradientStyle_LINEAR);
 136
 137     maGradientAxial = maGradientLinear;
 138     maGradientAxial.SetGradientStyle(css::awt::GradientStyle_AXIAL);
 139
 140     maGradientRadial = maGradientLinear;
 141     maGradientRadial.SetGradientStyle(css::awt::GradientStyle_RADIAL);
 142
 143     maGradientElliptical = maGradientLinear;
 144     maGradientElliptical.SetGradientStyle(css::awt::GradientStyle_ELLIPTICAL);
 145
 146     maGradientSquare = maGradientLinear;
 147     maGradientSquare.SetGradientStyle(css::awt::GradientStyle_SQUARE);
 148
 149     maGradientRect = maGradientLinear;
 150     maGradientRect.SetGradientStyle(css::awt::GradientStyle_RECT);
 151
 152
 153     mxLbFillType->connect_changed( LINK( this, AreaPropertyPanelBase, SelectFillTypeHdl ) );
 154
 155     Link<weld::ComboBox&,void> aLink = LINK( this, AreaPropertyPanelBase, SelectFillAttrHdl );
 156     mxLbFillAttr->connect_changed( aLink );
 157     mxGradientStyle->connect_changed( aLink );
 158     Link<ColorListBox&,void> aLink3 = LINK( this, AreaPropertyPanelBase, SelectFillColorHdl );
 159     mxLbFillGradFrom->SetSelectHdl( aLink3 );
 160     mxLbFillGradTo->SetSelectHdl( aLink3 );
 161     mxMTRAngle->connect_value_changed(LINK(this,AreaPropertyPanelBase, ChangeGradientAngle));
 162
 163     // set a small width to force widgets to take their final width from other widgets in the grid
 164     mxLbFillGradFrom->get_widget().set_size_request(42, -1);
 165     mxLbFillGradTo->get_widget().set_size_request(42, -1);
 166
 167     mxLBTransType->connect_changed(LINK(this, AreaPropertyPanelBase, ChangeTrgrTypeHdl_Impl));
 168
 169     SetTransparency( 50 );
 170     mxMTRTransparent->connect_value_changed(LINK(this, AreaPropertyPanelBase, ModifyTransparentHdl_Impl));
 171     mxSldTransparent->connect_value_changed(LINK(this, AreaPropertyPanelBase, ModifyTransSliderHdl));
 172
 173     mxTrGrPopup = std::make_unique<AreaTransparencyGradientPopup>(mxFrame, *this, mxBTNGradient.get());
 174
 175     mxBTNGradient->set_item_popover(SIDEBARGRADIENT, mxTrGrPopup->getTopLevel());
 176     mxBTNGradient->connect_clicked(LINK(this, AreaPropertyPanelBase, ToolbarHdl_Impl));
 177
 178     mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgLinear);
 179     mxBTNGradient->hide();
 180     mxBmpImport->connect_clicked( LINK(this, AreaPropertyPanelBase, ClickImportBitmapHdl));
 181 }
 182
 183 IMPL_LINK_NOARG(AreaPropertyPanelBase, ToolbarHdl_Impl, const OUString&, void)
 184 {
 185     mxBTNGradient->set_menu_item_active(SIDEBARGRADIENT, !mxBTNGradient->get_menu_item_active(SIDEBARGRADIENT));
 186 }
 187
 188 void AreaPropertyPanelBase::SetTransparency(sal_uInt16 nVal)
 189 {
 190     mxSldTransparent->set_value(nVal);
 191     mxMTRTransparent->set_value(nVal, FieldUnit::PERCENT);
 192 }
 193
 194 IMPL_LINK_NOARG(AreaPropertyPanelBase, ClickImportBitmapHdl, weld::Button&, void)
 195 {
 196     SvxOpenGraphicDialog aDlg("Import", GetFrameWeld());
 197     aDlg.EnableLink(false);
 198     if( aDlg.Execute() != ERRCODE_NONE )
 199         return;
 200
 201     Graphic aGraphic;
 202     auto xWait = std::make_unique<weld::WaitObject>(m_xContainer.get());
 203     ErrCode nError = aDlg.GetGraphic( aGraphic );
 204     xWait.reset();
 205     if( nError != ERRCODE_NONE )
 206         return;
 207
 208     mxLbFillAttr->clear();
 209
 210     if (SfxObjectShell* pSh = SfxObjectShell::Current())
 211     {
 212         INetURLObject aURL(aDlg.GetPath());
 213         OUString aFileName = aURL.GetLastName().getToken(0, '.');
 214         OUString aName = aFileName;
 215
 216         XBitmapListRef pList = pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList();
 217
 218         tools::Long j = 1;
 219         bool bValidBitmapName = false;
 220         while( !bValidBitmapName )
 221         {
 222             bValidBitmapName = true;
 223             for( tools::Long i = 0; i < pList->Count() && bValidBitmapName; i++ )
 224             {
 225                 if( aName == pList->GetBitmap(i)->GetName() )
 226                 {
 227                     bValidBitmapName = false;
 228                     aName = aFileName + OUString::number(j++);
 229                 }
 230             }
 231         }
 232
 233         pList->Insert(std::make_unique<XBitmapEntry>(aGraphic, aName));
 234         pList->Save();
 235
 236         SvxFillAttrBox::Fill(*mxLbFillAttr, pList);
 237
 238         mxLbFillAttr->set_active_text(aName);
 239         SelectFillAttrHdl(*mxLbFillAttr);
 240     }
 241 }
 242
 243 IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillTypeHdl, weld::ComboBox&, void)
 244 {
 245     FillStyleChanged(true);
 246 }
 247
 248 IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillColorHdl, ColorListBox&, void)
 249 {
 250     SelectFillAttrHdl_Impl();
 251 }
 252
 253 IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillAttrHdl, weld::ComboBox&, void)
 254 {
 255     SelectFillAttrHdl_Impl();
 256 }
 257
 258 IMPL_LINK_NOARG(AreaPropertyPanelBase, ChangeGradientAngle, weld::MetricSpinButton&, void)
 259 {
 260     SelectFillAttrHdl_Impl();
 261 }
 262
 263 void AreaPropertyPanelBase::SelectFillAttrHdl_Impl()
 264 {
 265     sal_Int32 nPosFillStyle = static_cast<eFillStyle>(mxLbFillType->get_active());
 266     SfxObjectShell* pSh = SfxObjectShell::Current();
 267
 268     // #i122676# dependent from bFillStyleChange, do execute a single or two
 269     // changes in one Execute call
 270     const bool bFillStyleChange(static_cast<eFillStyle>(meLastXFS) != static_cast<eFillStyle>(nPosFillStyle));
 271
 272     switch(nPosFillStyle)
 273     {
 274         case eFillStyle::NONE:
 275         {
 276             if(bFillStyleChange)
 277             {
 278                 const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE);
 279                 // Need to disable the XFillUseSlideBackgroundItem
 280                 const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(false);
 281                 setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem);
 282             }
 283             break;
 284         }
 285         case eFillStyle::SOLID:
 286         {
 287             if(bFillStyleChange)
 288             {
 289                 // #i122676# Single FillStyle change call needed here
 290                 XFillStyleItem aXFillStyleItem(drawing::FillStyle_SOLID);
 291                 setFillStyle(aXFillStyleItem);
 292             }
 293             break;
 294         }
 295         case eFillStyle::GRADIENT:
 296         {
 297
 298             if (pSh && pSh->GetItem(SID_COLOR_TABLE))
 299             {
 300                 basegfx::BGradient aGradient(createColorStops());
 301                 aGradient.SetAngle(Degree10(mxMTRAngle->get_value(FieldUnit::DEGREE) * 10));
 302                 aGradient.SetGradientStyle(static_cast<css::awt::GradientStyle>(mxGradientStyle->get_active()));
 303
 304                 const XFillGradientItem aXFillGradientItem(mxLbFillAttr->get_active_text(), aGradient);
 305
 306                     // #i122676# Change FillStyle and Gradient in one call
 307                 XFillStyleItem aXFillStyleItem(drawing::FillStyle_GRADIENT);
 308                 setFillStyleAndGradient(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillGradientItem);
 309             }
 310             break;
 311         }
 312         case eFillStyle::HATCH:
 313         {
 314             sal_Int32 nPos = mxLbFillAttr->get_active();
 315
 316             if (nPos == -1)
 317             {
 318                 nPos = mnLastPosHatch;
 319             }
 320
 321             if (nPos != -1 && pSh && pSh->GetItem(SID_HATCH_LIST))
 322             {
 323                 const SvxHatchListItem * pItem = pSh->GetItem(SID_HATCH_LIST);
 324
 325                 if(nPos < pItem->GetHatchList()->Count())
 326                 {
 327                     const XHatch aHatch = pItem->GetHatchList()->GetHatch(nPos)->GetHatch();
 328                     const XFillHatchItem aXFillHatchItem( mxLbFillAttr->get_active_text(), aHatch);
 329
 330                     // #i122676# Change FillStyle and Hatch in one call
 331                     XFillStyleItem aXFillStyleItem(drawing::FillStyle_HATCH);
 332                     setFillStyleAndHatch(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillHatchItem);
 333                 }
 334             }
 335
 336             if (nPos != -1)
 337             {
 338                 mnLastPosHatch = nPos;
 339             }
 340             break;
 341         }
 342         case eFillStyle::BITMAP:
 343         {
 344             sal_Int32 nPos = mxLbFillAttr->get_active();
 345
 346             if (nPos == -1)
 347             {
 348                 nPos = mnLastPosBitmap;
 349             }
 350
 351             if (nPos != -1 && pSh && pSh->GetItem(SID_BITMAP_LIST))
 352             {
 353                 const SvxBitmapListItem * pItem = pSh->GetItem(SID_BITMAP_LIST);
 354
 355                 if(nPos < pItem->GetBitmapList()->Count())
 356                 {
 357                     const XBitmapEntry* pXBitmapEntry = pItem->GetBitmapList()->GetBitmap(nPos);
 358                     const XFillBitmapItem aXFillBitmapItem(mxLbFillAttr->get_active_text(), pXBitmapEntry->GetGraphicObject());
 359
 360                     // #i122676# Change FillStyle and Bitmap in one call
 361                     XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP);
 362                     setFillStyleAndBitmap(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillBitmapItem);
 363                 }
 364             }
 365
 366             if (nPos != -1)
 367             {
 368                 mnLastPosBitmap = nPos;
 369             }
 370             break;
 371         }
 372         case eFillStyle::PATTERN:
 373         {
 374             sal_Int32 nPos = mxLbFillAttr->get_active();
 375
 376             if (nPos == -1)
 377             {
 378                 nPos = mnLastPosPattern;
 379             }
 380
 381             if (nPos != -1 && pSh && pSh->GetItem(SID_PATTERN_LIST))
 382             {
 383                 const SvxPatternListItem * pItem = pSh->GetItem(SID_PATTERN_LIST);
 384
 385                 if(nPos < pItem->GetPatternList()->Count())
 386                 {
 387                     const XBitmapEntry* pXPatternEntry = pItem->GetPatternList()->GetBitmap(nPos);
 388                     const XFillBitmapItem aXFillBitmapItem(mxLbFillAttr->get_active_text(), pXPatternEntry->GetGraphicObject());
 389
 390                     // #i122676# Change FillStyle and Bitmap in one call
 391                     XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP);
 392                     setFillStyleAndBitmap(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillBitmapItem);
 393                 }
 394             }
 395
 396             if (nPos != -1)
 397             {
 398                 mnLastPosPattern = nPos;
 399             }
 400             break;
 401         }
 402     }
 403     if (m_pPanel && !comphelper::LibreOfficeKit::isActive())
 404         m_pPanel->TriggerDeckLayouting();
 405 }
 406
 407 void AreaPropertyPanelBase::FillStyleChanged(bool bUpdateModel)
 408 {
 409     sal_Int32 nPos = static_cast<eFillStyle>(mxLbFillType->get_active());
 410     mxLbFillAttr->clear();
 411     SfxObjectShell* pSh = SfxObjectShell::Current();
 412     if (!pSh)
 413         return;
 414
 415     bool bShowLbFillAttr = false;
 416     bool bShowLbFillGradFrom = false;
 417     bool bShowLbFillGradTo = false;
 418     bool bShowGradientStyle = false;
 419     bool bShowMTRAngle = false;
 420     bool bShowToolBoxColor = false;
 421     bool bShowBmpImport = false;
 422
 423     // #i122676# Do no longer trigger two Execute calls, one for SID_ATTR_FILL_STYLE
 424     // and one for setting the fill attribute itself, but add two SfxPoolItems to the
 425     // call to get just one action at the SdrObject and to create only one Undo action, too.
 426     // Checked that this works in all apps.
 427     switch (nPos)
 428     {
 429         default:
 430         case NONE:
 431         {
 432             if (bUpdateModel)
 433             {
 434                 const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE);
 435                 // Need to disable the XFillUseSlideBackgroundItem
 436                 const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(false);
 437                 setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem);
 438             }
 439
 440             break;
 441         }
 442         case SOLID:
 443         {
 444             bShowToolBoxColor = true;
 445
 446             if (bUpdateModel)
 447             {
 448                 const Color aColor = mpColorItem ? mpColorItem->GetColorValue() : COL_AUTO;
 449                 const XFillColorItem aXFillColorItem("", aColor);
 450
 451                 // #i122676# change FillStyle and Color in one call
 452                 XFillStyleItem aXFillStyleItem(drawing::FillStyle_SOLID);
 453                 setFillStyleAndColor(&aXFillStyleItem, aXFillColorItem);
 454             }
 455             break;
 456         }
 457         case GRADIENT:
 458         {
 459             bShowLbFillGradFrom = true;
 460             bShowLbFillGradTo = true;
 461             bShowGradientStyle = true;
 462             bShowMTRAngle = true;
 463
 464             mxLbFillAttr->set_sensitive(true);
 465             mxLbFillGradTo->set_sensitive(true);
 466             mxLbFillGradFrom->set_sensitive(true);
 467             mxGradientStyle->set_sensitive(true);
 468             mxMTRAngle->set_sensitive(true);
 469             mxLbFillAttr->clear();
 470
 471             if (bUpdateModel)
 472             {
 473                 mxLbFillAttr->hide();
 474                 mxToolBoxColor->hide();
 475                 mxBmpImport->hide();
 476
 477                 const SvxGradientListItem* pItem = pSh->GetItem(SID_GRADIENT_LIST);
 478                 if (pItem->GetGradientList()->Count() > 0)
 479                 {
 480                     const basegfx::BGradient aGradient
 481                         = pItem->GetGradientList()->GetGradient(0)->GetGradient();
 482                     const OUString aName = pItem->GetGradientList()->GetGradient(0)->GetName();
 483                     const XFillGradientItem aXFillGradientItem(aName, aGradient);
 484
 485                     // #i122676# change FillStyle and Gradient in one call
 486                     XFillStyleItem aXFillStyleItem(drawing::FillStyle_GRADIENT);
 487                     setFillStyleAndGradient(&aXFillStyleItem, aXFillGradientItem);
 488                     mxLbFillGradFrom->SelectEntry(Color(aGradient.GetColorStops().front().getStopColor()));
 489                     mxLbFillGradTo->SelectEntry(Color(aGradient.GetColorStops().back().getStopColor()));
 490
 491                     // MCGR: preserve ColorStops if given
 492                     // tdf#155901 We need offset of first and last stop, so include them.
 493                     if (aGradient.GetColorStops().size() >= 2)
 494                         maColorStops = aGradient.GetColorStops();
 495                     else
 496                         maColorStops.clear();
 497
 498                     mxMTRAngle->set_value(toDegrees(aGradient.GetAngle()), FieldUnit::DEGREE);
 499                     css::awt::GradientStyle eXGS = aGradient.GetGradientStyle();
 500                     mxGradientStyle->set_active(sal::static_int_cast<sal_Int32>(eXGS));
 501                 }
 502             }
 503             else
 504             {
 505                 if (pSh->GetItem(SID_GRADIENT_LIST))
 506                 {
 507                     SvxFillAttrBox::Fill(*mxLbFillAttr,
 508                                          pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList());
 509                     mxLbFillGradTo->SetNoSelection();
 510                     mxLbFillGradFrom->SetNoSelection();
 511                     if (mpFillGradientItem)
 512                     {
 513                         const OUString aString(mpFillGradientItem->GetName());
 514                         mxLbFillAttr->set_active_text(aString);
 515                         const basegfx::BGradient aGradient = mpFillGradientItem->GetGradientValue();
 516                         mxLbFillGradFrom->SelectEntry(Color(aGradient.GetColorStops().front().getStopColor()));
 517                         mxLbFillGradTo->SelectEntry(Color(aGradient.GetColorStops().back().getStopColor()));
 518
 519                         // MCGR: preserve ColorStops if given
 520                         // tdf#155901 We need offset of first and last stop, so include them.
 521                         if (aGradient.GetColorStops().size() >= 2)
 522                             maColorStops = basegfx::BColorStops(aGradient.GetColorStops().begin(),
 523                                                                 aGradient.GetColorStops().end());
 524                         else
 525                             maColorStops.clear();
 526
 527                         mxGradientStyle->set_active(
 528                             sal::static_int_cast<sal_Int32>(aGradient.GetGradientStyle()));
 529                         if (mxGradientStyle->get_active() == sal_Int32(css::awt::GradientStyle_RADIAL))
 530                             mxMTRAngle->set_sensitive(false);
 531                         else
 532                             mxMTRAngle->set_value(toDegrees(aGradient.GetAngle()),
 533                                                   FieldUnit::DEGREE);
 534                     }
 535                     else
 536                     {
 537                         mxLbFillAttr->set_active(-1);
 538                     }
 539                 }
 540                 else
 541                 {
 542                     mxLbFillAttr->set_active(-1);
 543                 }
 544             }
 545             break;
 546         }
 547         case HATCH:
 548         {
 549             bShowLbFillAttr = true;
 550
 551             const SvxHatchListItem* pItem(pSh->GetItem(SID_HATCH_LIST));
 552             if (pItem)
 553             {
 554                 const XHatchListRef& pXHatchList(pItem->GetHatchList());
 555                 mxLbFillAttr->set_sensitive(true);
 556                 mxLbFillAttr->clear();
 557                 SvxFillAttrBox::Fill(*mxLbFillAttr, pXHatchList);
 558
 559                 if (mnLastPosHatch != -1)
 560                 {
 561                     if (mnLastPosHatch < pXHatchList->Count())
 562                     {
 563                         const XHatch aHatch = pXHatchList->GetHatch(mnLastPosHatch)->GetHatch();
 564                         const OUString aName = pXHatchList->GetHatch(mnLastPosHatch)->GetName();
 565                         const XFillHatchItem aXFillHatchItem(aName, aHatch);
 566
 567                         // #i122676# change FillStyle and Hatch in one call
 568                         if (bUpdateModel)
 569                         {
 570                             XFillStyleItem aXFillStyleItem(drawing::FillStyle_HATCH);
 571                             setFillStyleAndHatch(&aXFillStyleItem, aXFillHatchItem);
 572                         }
 573                         mxLbFillAttr->set_active(mnLastPosHatch);
 574                     }
 575                 }
 576             }
 577             else
 578             {
 579                 mxLbFillAttr->set_sensitive(false);
 580             }
 581             break;
 582         }
 583         case BITMAP:
 584         case PATTERN:
 585         {
 586             bShowLbFillAttr = true;
 587             mxLbFillAttr->set_sensitive(true);
 588             mxLbFillAttr->clear();
 589
 590             OUString aName;
 591             GraphicObject aBitmap;
 592             if (nPos == static_cast<sal_Int32>(BITMAP))
 593             {
 594                 if (!comphelper::LibreOfficeKit::isActive())
 595                     bShowBmpImport = true;
 596                 const SvxBitmapListItem* pItem = pSh->GetItem(SID_BITMAP_LIST);
 597                 if (pItem)
 598                 {
 599                     const XBitmapListRef& pXBitmapList(pItem->GetBitmapList());
 600                     SvxFillAttrBox::Fill(*mxLbFillAttr, pXBitmapList);
 601
 602                     if (mnLastPosBitmap != -1)
 603                     {
 604                         if (mnLastPosBitmap < pXBitmapList->Count())
 605                         {
 606                             const XBitmapEntry* pXBitmapEntry
 607                                 = pXBitmapList->GetBitmap(mnLastPosBitmap);
 608                             aBitmap = pXBitmapEntry->GetGraphicObject();
 609                             aName = pXBitmapEntry->GetName();
 610                             mxLbFillAttr->set_active(mnLastPosBitmap);
 611                         }
 612                     }
 613                 }
 614                 else
 615                 {
 616                     bShowBmpImport = false;
 617                 }
 618             }
 619             else if (nPos == static_cast<sal_Int32>(PATTERN))
 620             {
 621                 const SvxPatternListItem* pItem = pSh->GetItem(SID_PATTERN_LIST);
 622                 if (pItem)
 623                 {
 624                     const XPatternListRef& pXPatternList(pItem->GetPatternList());
 625                     SvxFillAttrBox::Fill(*mxLbFillAttr, pXPatternList);
 626
 627                     if (mnLastPosPattern != -1)
 628                     {
 629                         if (mnLastPosPattern < pXPatternList->Count())
 630                         {
 631                             const XBitmapEntry* pXPatternEntry
 632                                 = pXPatternList->GetBitmap(mnLastPosPattern);
 633                             aBitmap = pXPatternEntry->GetGraphicObject();
 634                             aName = pXPatternEntry->GetName();
 635                             mxLbFillAttr->set_active(mnLastPosPattern);
 636                         }
 637                     }
 638                 }
 639                 else
 640                 {
 641                     bShowLbFillAttr = false;
 642                 }
 643             }
 644             if (bUpdateModel)
 645             {
 646                 const XFillBitmapItem aXFillBitmapItem(aName, aBitmap);
 647                 const XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP);
 648                 setFillStyleAndBitmap(&aXFillStyleItem, aXFillBitmapItem);
 649             }
 650             break;
 651         }
 652         case USE_BACKGROUND:
 653         {
 654             // No transparencies here
 655             mxLBTransType->hide();
 656             mxTrspTextFT->hide();
 657             mxMTRTransparent->hide();
 658             mxSldTransparent->hide();
 659             mxBTNGradient->hide();
 660             if (bUpdateModel)
 661             {
 662                 const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE);
 663                 const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(true);
 664                 setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem);
 665                 break;
 666             }
 667         }
 668     }
 669
 670     mxLbFillAttr->set_visible(bShowLbFillAttr);
 671     mxLbFillGradFrom->set_visible(bShowLbFillGradFrom);
 672     mxLbFillGradTo->set_visible(bShowLbFillGradTo);
 673     mxGradientStyle->set_visible(bShowGradientStyle);
 674     mxMTRAngle->set_visible(bShowMTRAngle);
 675     mxToolBoxColor->set_visible(bShowToolBoxColor);
 676     mxBmpImport->set_visible(bShowBmpImport);
 677
 678     meLastXFS = static_cast<sal_uInt16>(nPos);
 679
 680     if (m_pPanel && !comphelper::LibreOfficeKit::isActive())
 681         m_pPanel->TriggerDeckLayouting();
 682 }
 683
 684 void AreaPropertyPanelBase::ImpUpdateTransparencies()
 685 {
 686     if(mpTransparenceItem || mpFloatTransparenceItem)
 687     {
 688         bool bZeroValue(false);
 689
 690         if (mpTransparenceItem)
 691         {
 692             const sal_uInt16 nValue(mpTransparenceItem->GetValue());
 693
 694             if(!nValue)
 695             {
 696                 bZeroValue = true;
 697             }
 698             else if(nValue <= 100)
 699             {
 700                 mxLBTransType->set_sensitive(true);
 701                 mxTrspTextFT->set_sensitive(true);
 702                 mxLBTransType->set_active(1);
 703                 mxBTNGradient->hide();
 704                 mxMTRTransparent->show();
 705                 mxSldTransparent->show();
 706                 mxMTRTransparent->set_sensitive(true);
 707                 mxSldTransparent->set_sensitive(true);
 708                 SetTransparency(nValue);
 709             }
 710
 711             if (!bZeroValue && mxTrGrPopup)
 712             {
 713                 mxBTNGradient->set_menu_item_active(SIDEBARGRADIENT, false);
 714             }
 715         }
 716
 717         if(bZeroValue && mpFloatTransparenceItem)
 718         {
 719             if(mpFloatTransparenceItem->IsEnabled())
 720             {
 721                 const basegfx::BGradient& rGradient = mpFloatTransparenceItem->GetGradientValue();
 722                 sal_Int32 nEntryPos(0);
 723                 OUString* pImage = nullptr;
 724
 725                 mxLBTransType->set_sensitive(true);
 726                 mxTrspTextFT->set_sensitive(true);
 727                 mxMTRTransparent->hide();
 728                 mxSldTransparent->hide();
 729                 mxBTNGradient->set_sensitive(true);
 730                 mxBTNGradient->show();
 731
 732                 switch(rGradient.GetGradientStyle())
 733                 {
 734                     default:
 735                     case css::awt::GradientStyle_LINEAR:
 736                     {
 737                         nEntryPos = 2;
 738                         pImage = &maImgLinear;
 739                         break;
 740                     }
 741                     case css::awt::GradientStyle_AXIAL:
 742                     {
 743                         nEntryPos = 3;
 744                         pImage = &maImgAxial;
 745                         break;
 746                     }
 747                     case css::awt::GradientStyle_RADIAL:
 748                     {
 749                         nEntryPos = 4;
 750                         pImage = &maImgRadial;
 751                         break;
 752                     }
 753                     case css::awt::GradientStyle_ELLIPTICAL:
 754                     {
 755                         nEntryPos = 5;
 756                         pImage = &maImgElli;
 757                         break;
 758                     }
 759                     case css::awt::GradientStyle_SQUARE:
 760                     {
 761                         nEntryPos = 6;
 762                         pImage = &maImgQuad;
 763                         break;
 764                     }
 765                     case css::awt::GradientStyle_RECT:
 766                     {
 767                         nEntryPos = 7;
 768                         pImage = &maImgSquare;
 769                         break;
 770                     }
 771                 }
 772                 mxLBTransType->set_active(nEntryPos);
 773                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, *pImage);
 774                 mxTrGrPopup->Rearrange(mpFloatTransparenceItem.get());
 775                 bZeroValue = false;
 776             }
 777             else
 778             {
 779                 bZeroValue = true;
 780             }
 781         }
 782
 783         if(bZeroValue)
 784         {
 785             mxLBTransType->set_sensitive(true);
 786             mxTrspTextFT->set_sensitive(true);
 787             mxLBTransType->set_active(0);
 788             mxBTNGradient->hide();
 789             mxMTRTransparent->set_sensitive(true);
 790             mxSldTransparent->set_sensitive(true);
 791             mxMTRTransparent->show();
 792             mxSldTransparent->show();
 793             SetTransparency(0);
 794         }
 795     }
 796     else
 797     {
 798         // no transparency at all
 799         mxLBTransType->set_active(-1);
 800         mxLBTransType->set_sensitive(false);
 801         mxTrspTextFT->set_sensitive(false);
 802         mxMTRTransparent->set_sensitive(false);
 803         mxSldTransparent->set_sensitive(false);
 804         mxMTRTransparent->show();
 805         mxSldTransparent->show();
 806         mxBTNGradient->set_sensitive(false);
 807         mxBTNGradient->hide();
 808     }
 809 }
 810
 811 void AreaPropertyPanelBase::updateFillTransparence(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
 812 {
 813     if (bDisabled)
 814     {
 815         mpTransparenceItem.reset();
 816         return;
 817     }
 818     else if (bDefaultOrSet)
 819     {
 820         if (pState)
 821         {
 822             const SfxUInt16Item* pItem = static_cast<const SfxUInt16Item*>(pState);
 823             mpTransparenceItem.reset(pItem->Clone());
 824         }
 825         else
 826         {
 827             mpTransparenceItem.reset();
 828         }
 829     }
 830     else
 831     {
 832         mpTransparenceItem.reset();
 833     }
 834
 835     // update transparency settings dependent of mpTransparenceItem and mpFloatTransparenceItem
 836     ImpUpdateTransparencies();
 837 }
 838
 839 void AreaPropertyPanelBase::updateFillFloatTransparence(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
 840 {
 841     if (bDisabled)
 842     {
 843         mpFloatTransparenceItem.reset();
 844         return;
 845     }
 846
 847     if (bDefaultOrSet)
 848     {
 849         if (pState)
 850         {
 851             const XFillFloatTransparenceItem* pItem = static_cast<const XFillFloatTransparenceItem*>(pState);
 852             mpFloatTransparenceItem.reset(pItem->Clone());
 853         }
 854         else
 855         {
 856             mpFloatTransparenceItem.reset();
 857         }
 858     }
 859     else
 860     {
 861         mpFloatTransparenceItem.reset();
 862     }
 863
 864     // update transparency settings dependent of mpTransparenceItem and mpFloatTransparenceItem
 865     ImpUpdateTransparencies();
 866 }
 867
 868 void AreaPropertyPanelBase::updateFillStyle(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
 869 {
 870     if(bDisabled)
 871     {
 872         mxLbFillType->set_sensitive(false);
 873         mxColorTextFT->set_sensitive(false);
 874         mxLbFillType->set_active(-1);
 875         mxLbFillAttr->show();
 876         mxLbFillAttr->set_sensitive(false);
 877         mxLbFillAttr->set_active(-1);
 878         mxToolBoxColor->hide();
 879         meLastXFS = static_cast<sal_uInt16>(-1);
 880         mpStyleItem.reset();
 881     }
 882     else if (bDefaultOrSet && pState)
 883     {
 884         const XFillStyleItem* pItem = static_cast<const XFillStyleItem*>(pState);
 885         mpStyleItem.reset(pItem->Clone());
 886         mxLbFillType->set_sensitive(true);
 887         mxColorTextFT->set_sensitive(true);
 888         drawing::FillStyle eXFS = mpStyleItem->GetValue();
 889         eFillStyle nPos = NONE;
 890         switch(eXFS)
 891         {
 892             default:
 893             case drawing::FillStyle_NONE:
 894             {
 895                 mxLbFillAttr->hide();
 896                 // "Use slide background" also uses FillStyle_NONE internally,
 897                 // don't switch listbox in that case (will be handled by updateFillUseBackground)
 898                 nPos = meLastXFS == USE_BACKGROUND ? USE_BACKGROUND : NONE;
 899                 break;
 900             }
 901             case drawing::FillStyle_SOLID:
 902                 nPos = SOLID;
 903                 break;
 904             case drawing::FillStyle_GRADIENT:
 905                 nPos = GRADIENT;
 906                 break;
 907             case drawing::FillStyle_HATCH:
 908                 nPos = HATCH;
 909                 break;
 910             case drawing::FillStyle_BITMAP:
 911             {
 912                 if(mpBitmapItem)
 913                 {
 914                     if(!mpBitmapItem->isPattern())
 915                         nPos = BITMAP;
 916                     else
 917                         nPos = PATTERN;
 918                 }
 919                 else
 920                     nPos = BITMAP;
 921                 break;
 922             }
 923         }
 924         meLastXFS = static_cast< sal_uInt16 >(mxLbFillType->get_active());
 925         mxLbFillType->set_active(static_cast< sal_Int32 >(nPos));
 926         FillStyleChanged(false);
 927         return;
 928     }
 929
 930     mxLbFillType->set_active(-1);
 931     mxLbFillAttr->show();
 932     mxLbFillAttr->set_sensitive(false);
 933     mxLbFillAttr->set_active(-1);
 934     mxToolBoxColor->hide();
 935     meLastXFS = static_cast<sal_uInt16>(-1);
 936     mpStyleItem.reset();
 937 }
 938
 939 void AreaPropertyPanelBase::updateFillGradient(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
 940 {
 941     if (bDefaultOrSet)
 942     {
 943         const XFillGradientItem* pItem = static_cast<const XFillGradientItem*>(pState);
 944         mpFillGradientItem.reset(pItem ? pItem->Clone() : nullptr);
 945     }
 946
 947     if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue())
 948     {
 949         mxLbFillAttr->hide();
 950         mxLbFillGradFrom->show();
 951         mxLbFillGradTo->show();
 952         mxMTRAngle->show();
 953         mxGradientStyle->show();
 954         mxToolBoxColor->hide();
 955
 956         if (bDefaultOrSet)
 957         {
 958             mxLbFillType->set_active(GRADIENT);
 959             FillStyleChanged(false);
 960         }
 961         else if(bDisabled)
 962         {
 963             mxLbFillGradFrom->SetNoSelection();
 964             mxLbFillGradTo->SetNoSelection();
 965             mxLbFillGradFrom->set_sensitive(false);
 966             mxLbFillGradTo->set_sensitive(false);
 967             mxMTRAngle->set_sensitive(false);
 968             mxGradientStyle->set_sensitive(false);
 969         }
 970         else
 971         {
 972             mxLbFillGradFrom->SetNoSelection();
 973             mxLbFillGradTo->SetNoSelection();
 974         }
 975     }
 976 }
 977
 978 void AreaPropertyPanelBase::updateFillHatch(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
 979 {
 980     if (bDefaultOrSet)
 981     {
 982         const XFillHatchItem* pItem = static_cast<const XFillHatchItem*>(pState);
 983         mpHatchItem.reset(pItem ? pItem->Clone() : nullptr);
 984     }
 985
 986     if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue())
 987     {
 988         mxLbFillAttr->show();
 989         mxToolBoxColor->hide();
 990
 991         if (bDefaultOrSet)
 992         {
 993             mxLbFillAttr->set_sensitive(true);
 994             mxLbFillType->set_active(HATCH);
 995             FillStyleChanged(false);
 996         }
 997         else if(bDisabled)
 998         {
 999             mxLbFillAttr->set_sensitive(false);
1000             mxLbFillAttr->set_active(-1);
1001         }
1002         else
1003         {
1004             mxLbFillAttr->set_active(-1);
1005         }
1006     }
1007     FillStyleChanged(false);
1008 }
1009
1010 void AreaPropertyPanelBase::updateFillColor(bool bDefaultOrSet, const SfxPoolItem* pState)
1011 {
1012     if (bDefaultOrSet)
1013     {
1014         const XFillColorItem* pItem = static_cast<const XFillColorItem*>(pState);
1015         mpColorItem.reset(pItem ? pItem->Clone() : nullptr);
1016     }
1017
1018     if(mpStyleItem && drawing::FillStyle_SOLID == mpStyleItem->GetValue())
1019     {
1020         mxLbFillAttr->hide();
1021         mxToolBoxColor->show();
1022         mxLbFillType->set_active(SOLID);
1023         FillStyleChanged(false);
1024     }
1025 }
1026
1027 void AreaPropertyPanelBase::updateFillBitmap(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
1028 {
1029     if (bDefaultOrSet)
1030     {
1031         const XFillBitmapItem* pItem = static_cast<const XFillBitmapItem*>(pState);
1032         mpBitmapItem.reset(pItem ? pItem->Clone() : nullptr);
1033     }
1034
1035     if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue())
1036     {
1037         mxLbFillAttr->show();
1038         mxToolBoxColor->hide();
1039
1040         if (bDefaultOrSet)
1041         {
1042             if(mpBitmapItem->isPattern())
1043                 mxLbFillType->set_active(PATTERN);
1044             else
1045                 mxLbFillType->set_active(BITMAP);
1046             FillStyleChanged(false);
1047         }
1048         else if(bDisabled)
1049         {
1050             mxLbFillAttr->hide();
1051             mxLbFillAttr->set_active(-1);
1052         }
1053         else
1054         {
1055             mxLbFillAttr->set_active(-1);
1056         }
1057     }
1058 }
1059
1060 void AreaPropertyPanelBase::updateFillUseBackground(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState)
1061 {
1062     if (bDisabled)
1063         return;
1064
1065     if (bDefaultOrSet)
1066     {
1067         if (pState)
1068         {
1069             const XFillUseSlideBackgroundItem* pItem = static_cast<const XFillUseSlideBackgroundItem*>(pState);
1070             // When XFillUseSlideBackgroundItem is set, select "Use Background Fill".
1071             // When false, select "None" (only if "Use background fill" was selected beforehand)
1072             int nPos = pItem->GetValue() ? USE_BACKGROUND : NONE;
1073             if ((nPos == NONE && mxLbFillType->get_active() == USE_BACKGROUND) || nPos == USE_BACKGROUND)
1074             {
1075                 mxLbFillType->set_active(nPos);
1076                 FillStyleChanged(false);
1077             }
1078         }
1079     }
1080 }
1081
1082 void AreaPropertyPanelBase::NotifyItemUpdate(
1083     sal_uInt16 nSID,
1084     SfxItemState eState,
1085     const SfxPoolItem* pState)
1086 {
1087     const bool bDisabled(SfxItemState::DISABLED == eState);
1088     const bool bDefaultOrSet(SfxItemState::DEFAULT <= eState);
1089     const bool bDefault(SfxItemState::DEFAULT == eState);
1090
1091     switch(nSID)
1092     {
1093         case SID_ATTR_FILL_TRANSPARENCE:
1094             updateFillTransparence(bDisabled, bDefaultOrSet, pState);
1095         break;
1096         case SID_ATTR_FILL_FLOATTRANSPARENCE:
1097             updateFillFloatTransparence(bDisabled, bDefaultOrSet, pState);
1098         break;
1099         case SID_ATTR_FILL_STYLE:
1100             updateFillStyle(bDisabled, bDefaultOrSet, pState);
1101         break;
1102         case SID_ATTR_FILL_COLOR:
1103             updateFillColor(bDefaultOrSet, pState);
1104         break;
1105         case SID_ATTR_FILL_GRADIENT:
1106             updateFillGradient(bDisabled, bDefaultOrSet, pState);
1107         break;
1108         case SID_ATTR_FILL_HATCH:
1109             updateFillHatch(bDisabled, bDefaultOrSet, pState);
1110         break;
1111         case SID_ATTR_FILL_BITMAP:
1112             updateFillBitmap(bDisabled, bDefaultOrSet, pState);
1113         break;
1114         case SID_ATTR_FILL_USE_SLIDE_BACKGROUND:
1115             updateFillUseBackground(bDisabled, bDefaultOrSet, pState);
1116         break;
1117         case SID_GRADIENT_LIST:
1118         {
1119             if(bDefault)
1120             {
1121                 if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue())
1122                 {
1123                     if(mpFillGradientItem)
1124                     {
1125                         const OUString aString( mpFillGradientItem->GetName() );
1126                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1127                         mxLbFillAttr->clear();
1128                         if (pSh)
1129                         {
1130                             mxLbFillAttr->set_sensitive(true);
1131                             SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList());
1132                         }
1133                         mxLbFillAttr->set_active_text(aString);
1134                     }
1135                     else
1136                     {
1137                         mxLbFillAttr->set_active(-1);
1138                     }
1139                 }
1140             }
1141             break;
1142         }
1143         case SID_HATCH_LIST:
1144         {
1145             if(bDefault)
1146             {
1147                 if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue())
1148                 {
1149                     if(mpHatchItem)
1150                     {
1151                         const OUString aString( mpHatchItem->GetName() );
1152                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1153                         mxLbFillAttr->clear();
1154                         if (pSh)
1155                         {
1156                             mxLbFillAttr->set_sensitive(true);
1157                             SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_HATCH_LIST)->GetHatchList());
1158                         }
1159                         mxLbFillAttr->set_active_text(aString);
1160                     }
1161                     else
1162                     {
1163                         mxLbFillAttr->set_active(-1);
1164                     }
1165                 }
1166             }
1167             break;
1168         }
1169         case SID_BITMAP_LIST:
1170         case SID_PATTERN_LIST:
1171         {
1172             if(bDefault)
1173             {
1174                 if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue())
1175                 {
1176                     if(mpBitmapItem)
1177                     {
1178                         const OUString aString( mpBitmapItem->GetName() );
1179                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1180                         mxLbFillAttr->clear();
1181                         mxLbFillAttr->show();
1182                         if (pSh)
1183                         {
1184                             if(nSID == SID_BITMAP_LIST)
1185                                 SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList());
1186                             else if(nSID == SID_PATTERN_LIST)
1187                                 SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_PATTERN_LIST)->GetPatternList());
1188                         }
1189                         mxLbFillAttr->set_active_text(aString);
1190                     }
1191                     else
1192                     {
1193                         mxLbFillAttr->set_active(-1);
1194                     }
1195                 }
1196             }
1197             break;
1198         }
1199     }
1200     FillStyleChanged(false);
1201 }
1202
1203 IMPL_LINK_NOARG(AreaPropertyPanelBase, ModifyTransSliderHdl, weld::Scale&, void)
1204 {
1205     const sal_uInt16 nVal = mxSldTransparent->get_value();
1206     SetTransparency(nVal);
1207     const XFillTransparenceItem aLinearItem(nVal);
1208     setFillTransparence(aLinearItem);
1209 }
1210
1211 IMPL_LINK_NOARG(AreaPropertyPanelBase, ChangeTrgrTypeHdl_Impl, weld::ComboBox&, void)
1212 {
1213     sal_Int32 nSelectType = mxLBTransType->get_active();
1214     bool bGradient = false;
1215     sal_uInt16 nTrans = 0;
1216
1217     if(!nSelectType)
1218     {
1219         mxBTNGradient->hide();
1220         mxMTRTransparent->show();
1221         mxSldTransparent->show();
1222         mxMTRTransparent->set_sensitive(true);
1223         mxSldTransparent->set_sensitive(true);
1224         SetTransparency(0);
1225     }
1226     else if(1 == nSelectType)
1227     {
1228         mxBTNGradient->hide();
1229         mxMTRTransparent->show();
1230         mxSldTransparent->show();
1231         nTrans = mnLastTransSolid;
1232         mxMTRTransparent->set_value(nTrans, FieldUnit::PERCENT);
1233         mxLBTransType->set_active(1);
1234         mxMTRTransparent->set_sensitive(true);
1235         mxSldTransparent->set_sensitive(true);
1236     }
1237     else
1238     {
1239         mxBTNGradient->show();
1240
1241         switch (nSelectType)
1242         {
1243             case 2:
1244                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgLinear);
1245                 break;
1246             case 3:
1247                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgAxial);
1248                 break;
1249             case 4:
1250                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgRadial);
1251                 break;
1252             case 5:
1253                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgElli);
1254                 break;
1255             case 6:
1256                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgQuad);
1257                 break;
1258             case 7:
1259                 mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgSquare);
1260                 break;
1261         }
1262
1263         mxMTRTransparent->hide();
1264         mxSldTransparent->hide();
1265         mxBTNGradient->set_sensitive(true);
1266         bGradient = true;
1267     }
1268
1269     const XFillTransparenceItem aLinearItem(nTrans);
1270     setFillTransparence(aLinearItem);
1271
1272     if(nSelectType > 1)
1273     {
1274         nSelectType -= 2;
1275     }
1276
1277     basegfx::BGradient aTmpGradient;
1278
1279     switch(static_cast<css::awt::GradientStyle>(nSelectType))
1280     {
1281         case css::awt::GradientStyle_LINEAR:
1282             aTmpGradient = maGradientLinear;
1283             break;
1284         case css::awt::GradientStyle_AXIAL:
1285             aTmpGradient = maGradientAxial;
1286             break;
1287         case css::awt::GradientStyle_RADIAL:
1288             aTmpGradient = maGradientRadial;
1289             break;
1290         case css::awt::GradientStyle_ELLIPTICAL:
1291             aTmpGradient = maGradientElliptical;
1292             break;
1293         case css::awt::GradientStyle_SQUARE:
1294             aTmpGradient = maGradientSquare;
1295             break;
1296         case css::awt::GradientStyle_RECT:
1297             aTmpGradient = maGradientRect;
1298             break;
1299         default:
1300             break;
1301     }
1302
1303     const XFillFloatTransparenceItem aGradientItem(aTmpGradient, bGradient);
1304     setFillFloatTransparence(aGradientItem);
1305 }
1306
1307 IMPL_LINK_NOARG(AreaPropertyPanelBase, ModifyTransparentHdl_Impl, weld::MetricSpinButton&, void)
1308 {
1309     const sal_uInt16 nTrans = static_cast<sal_uInt16>(mxMTRTransparent->get_value(FieldUnit::PERCENT));
1310     mnLastTransSolid = nTrans;
1311     SetTransparency(nTrans);
1312     const sal_Int32 nSelectType = mxLBTransType->get_active();
1313
1314     if(nTrans && !nSelectType)
1315     {
1316         mxLBTransType->set_active(1);
1317     }
1318
1319     const XFillTransparenceItem aLinearItem(nTrans);
1320     setFillTransparence(aLinearItem);
1321 }
1322
1323 const basegfx::BGradient& AreaPropertyPanelBase::GetGradient (const css::awt::GradientStyle eStyle) const
1324 {
1325     switch (eStyle)
1326     {
1327         default:
1328         case css::awt::GradientStyle_LINEAR:
1329             return maGradientLinear;
1330         case css::awt::GradientStyle_AXIAL:
1331             return maGradientAxial;
1332         case css::awt::GradientStyle_RADIAL:
1333             return maGradientRadial;
1334         case css::awt::GradientStyle_ELLIPTICAL:
1335             return maGradientElliptical;
1336         case css::awt::GradientStyle_SQUARE:
1337             return maGradientSquare;
1338         case css::awt::GradientStyle_RECT:
1339             return maGradientRect;
1340     }
1341 }
1342
1343 void AreaPropertyPanelBase::SetGradient (const basegfx::BGradient& rGradient)
1344 {
1345     switch (rGradient.GetGradientStyle())
1346     {
1347         case css::awt::GradientStyle_LINEAR:
1348             maGradientLinear = rGradient;
1349             break;
1350         case css::awt::GradientStyle_AXIAL:
1351             maGradientAxial = rGradient;
1352             break;
1353         case css::awt::GradientStyle_RADIAL:
1354             maGradientRadial = rGradient;
1355             break;
1356         case css::awt::GradientStyle_ELLIPTICAL:
1357             maGradientElliptical = rGradient;
1358             break;
1359         case css::awt::GradientStyle_SQUARE:
1360             maGradientSquare = rGradient;
1361             break;
1362         case css::awt::GradientStyle_RECT:
1363             maGradientRect = rGradient;
1364             break;
1365         default:
1366             break;
1367     }
1368 }
1369
1370 sal_Int32 AreaPropertyPanelBase::GetSelectedTransparencyTypeIndex() const
1371 {
1372     return mxLBTransType->get_active();
1373 }
1374
1375 basegfx::BColorStops AreaPropertyPanelBase::createColorStops()
1376 {
1377     basegfx::BColorStops aColorStops;
1378
1379     if (maColorStops.size() >= 2)
1380     {
1381         aColorStops = maColorStops;
1382         aColorStops.front() = basegfx::BColorStop(maColorStops.front().getStopOffset(),
1383                                                   mxLbFillGradFrom->GetSelectEntryColor().getBColor());
1384         aColorStops.back() = basegfx::BColorStop(maColorStops.back().getStopOffset(),
1385                                                  mxLbFillGradTo->GetSelectEntryColor().getBColor());
1386     }
1387     else
1388     {
1389         aColorStops.emplace_back(0.0, mxLbFillGradFrom->GetSelectEntryColor().getBColor());
1390         aColorStops.emplace_back(1.0, mxLbFillGradTo->GetSelectEntryColor().getBColor());
1391     }
1392
1393     return aColorStops;
1394 }
1395
1396 void AreaPropertyPanelBase::HandleContextChange(
1397     const vcl::EnumContext& rContext)
1398 {
1399     if (maContext.GetApplication() == rContext.GetApplication())
1400         return;
1401
1402     maContext = rContext;
1403
1404     switch (maContext.GetApplication())
1405     {
1406         case vcl::EnumContext::Application::Impress:
1407             if (!msUseBackgroundText.isEmpty())
1408             {
1409                 mxLbFillType->insert_text(USE_BACKGROUND, msUseBackgroundText);
1410                 msUseBackgroundText = OUString();
1411             }
1412         break;
1413         default:
1414             if (msUseBackgroundText.isEmpty())
1415             {
1416                 msUseBackgroundText = mxLbFillType->get_text(USE_BACKGROUND);
1417                 mxLbFillType->remove(USE_BACKGROUND);
1418             }
1419         break;
1420     }
1421 }
1422
1423 } // end of namespace svx::sidebar
1424
1425 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */