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