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