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