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