LibreOffice Module svx (master)  1
tbcontrl.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 <utility>
21 
22 #include <comphelper/configurationlistener.hxx>
23 #include <comphelper/propertysequence.hxx>
24 #include <tools/color.hxx>
25 #include <svl/poolitem.hxx>
26 #include <svl/itemset.hxx>
27 #include <vcl/commandinfoprovider.hxx>
28 #include <vcl/event.hxx>
29 #include <vcl/toolbox.hxx>
30 #include <vcl/customweld.hxx>
31 #include <vcl/vclptr.hxx>
32 #include <vcl/weldutils.hxx>
33 #include <svtools/valueset.hxx>
34 #include <svtools/ctrlbox.hxx>
35 #include <svl/style.hxx>
36 #include <svtools/ctrltool.hxx>
37 #include <svtools/borderhelper.hxx>
38 #include <vcl/InterimItemWindow.hxx>
39 #include <sfx2/tbxctrl.hxx>
40 #include <sfx2/tplpitem.hxx>
41 #include <sfx2/sfxstatuslistener.hxx>
42 #include <toolkit/helper/vclunohelper.hxx>
43 #include <sfx2/viewfrm.hxx>
44 #include <vcl/svapp.hxx>
45 #include <vcl/settings.hxx>
46 #include <vcl/virdev.hxx>
47 #include <com/sun/star/awt/FontDescriptor.hpp>
48 #include <com/sun/star/table/BorderLine2.hpp>
49 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
50 #include <com/sun/star/lang/XServiceInfo.hpp>
51 #include <com/sun/star/beans/XPropertySet.hpp>
52 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
53 #include <com/sun/star/frame/XDispatchProvider.hpp>
54 #include <com/sun/star/frame/XFrame.hpp>
55 #include <svx/strings.hrc>
56 #include <svx/svxids.hrc>
57 #include <helpids.h>
58 #include <sfx2/sidebar/Sidebar.hxx>
59 #include <svx/xtable.hxx>
60 #include <editeng/editids.hrc>
61 #include <editeng/fontitem.hxx>
62 #include <editeng/fhgtitem.hxx>
63 #include <editeng/boxitem.hxx>
64 #include <editeng/charreliefitem.hxx>
65 #include <editeng/contouritem.hxx>
66 #include <editeng/colritem.hxx>
67 #include <editeng/crossedoutitem.hxx>
68 #include <editeng/emphasismarkitem.hxx>
69 #include <editeng/flstitem.hxx>
70 #include <editeng/lineitem.hxx>
71 #include <editeng/postitem.hxx>
72 #include <editeng/shdditem.hxx>
73 #include <editeng/udlnitem.hxx>
74 #include <editeng/wghtitem.hxx>
75 #include <editeng/svxfont.hxx>
76 #include <editeng/cmapitem.hxx>
77 #include <svx/colorwindow.hxx>
78 #include <svx/colorbox.hxx>
79 #include <svx/tbcontrl.hxx>
80 #include <svx/dialmgr.hxx>
81 #include <svx/PaletteManager.hxx>
82 #include <memory>
83 
84 #include <tbxcolorupdate.hxx>
85 #include <editeng/eerdll.hxx>
86 #include <editeng/editrids.hrc>
87 #include <svx/xdef.hxx>
88 #include <svx/xfillit0.hxx>
89 #include <svx/xflclit.hxx>
90 #include <svl/currencytable.hxx>
91 #include <svtools/langtab.hxx>
92 #include <cppu/unotype.hxx>
93 #include <cppuhelper/supportsservice.hxx>
94 #include <officecfg/Office/Common.hxx>
95 #include <o3tl/safeint.hxx>
96 #include <o3tl/typed_flags_set.hxx>
97 #include <bitmaps.hlst>
98 #include <sal/log.hxx>
99 #include <unotools/collatorwrapper.hxx>
100 
101 #include <comphelper/lok.hxx>
102 #include <tools/json_writer.hxx>
103 
104 #define MAX_MRU_FONTNAME_ENTRIES 5
105 
106 #define COMBO_WIDTH_IN_CHARS 18
107 
108 // namespaces
109 using namespace ::editeng;
110 using namespace ::com::sun::star;
111 using namespace ::com::sun::star::uno;
112 using namespace ::com::sun::star::frame;
113 using namespace ::com::sun::star::beans;
114 using namespace ::com::sun::star::lang;
115 
116 namespace
117 {
118 class SvxStyleBox_Base
119 {
120 public:
121  SvxStyleBox_Base(std::unique_ptr<weld::ComboBox> xWidget, const OUString& rCommand, SfxStyleFamily eFamily,
122  const Reference<XDispatchProvider>& rDispatchProvider,
123  const Reference<XFrame>& _xFrame,const OUString& rClearFormatKey,
124  const OUString& rMoreKey, bool bInSpecialMode, SvxStyleToolBoxControl& rCtrl);
125 
126  virtual ~SvxStyleBox_Base()
127  {
128  }
129 
130  void SetFamily( SfxStyleFamily eNewFamily );
131 
132  void SetDefaultStyle( const OUString& rDefault ) { sDefaultStyle = rDefault; }
133 
134  int get_count() const { return m_xWidget->get_count(); }
135  OUString get_text(int nIndex) const { return m_xWidget->get_text(nIndex); }
136  OUString get_active_text() const { return m_xWidget->get_active_text(); }
137 
138  void append_text(const OUString& rStr)
139  {
140  OUString sId(OUString::number(m_xWidget->get_count()));
141  m_xWidget->append(sId, rStr);
142  }
143 
144  void insert_separator(int pos, const OUString& rId)
145  {
146  m_xWidget->insert_separator(pos, rId);
147  }
148 
149  void set_active_or_entry_text(const OUString& rText)
150  {
151  const int nFound = m_xWidget->find_text(rText);
152  if (nFound != -1)
153  m_xWidget->set_active(nFound);
154  else
155  m_xWidget->set_entry_text(rText);
156  }
157 
158  void set_active(int nActive)
159  {
160  m_xWidget->set_active(nActive);
161  }
162 
163  void freeze()
164  {
165  m_xWidget->freeze();
166  }
167 
168  void save_value()
169  {
170  m_xWidget->save_value();
171  }
172 
173  void clear()
174  {
175  m_xWidget->clear();
176  m_nMaxUserDrawFontWidth = 0;
177  }
178 
179  void thaw()
180  {
181  m_xWidget->thaw();
182  }
183 
184  virtual bool DoKeyInput(const KeyEvent& rKEvt);
185 
186 private:
187  DECL_LINK(SelectHdl, weld::ComboBox&, void);
188  DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
189  DECL_LINK(ActivateHdl, weld::ComboBox&, bool);
190  DECL_LINK(FocusOutHdl, weld::Widget&, void);
191  DECL_LINK(DumpAsPropertyTreeHdl, tools::JsonWriter&, void);
192  DECL_LINK(CustomRenderHdl, weld::ComboBox::render_args, void);
193  DECL_LINK(CustomGetSizeHdl, OutputDevice&, Size);
194 
196  void CalcOptimalExtraUserWidth(vcl::RenderContext& rRenderContext);
197 
198  void Select(bool bNonTravelSelect);
199 
200 protected:
201  SvxStyleToolBoxControl& m_rCtrl;
202 
203  std::unique_ptr<weld::Builder> m_xMenuBuilder;
204  std::unique_ptr<weld::Menu> m_xMenu;
205  std::unique_ptr<weld::ComboBox> m_xWidget;
206 
207  SfxStyleFamily eStyleFamily;
208  int m_nMaxUserDrawFontWidth;
209  int m_nLastItemWithMenu;
210  bool bRelease;
211  Reference< XDispatchProvider > m_xDispatchProvider;
212  Reference< XFrame > m_xFrame;
213  OUString m_aCommand;
214  OUString aClearFormatKey;
215  OUString aMoreKey;
216  OUString sDefaultStyle;
217  bool bInSpecialMode;
218 
219  void ReleaseFocus();
220  static Color TestColorsVisible(const Color &FontCol, const Color &BackCol);
221  static void UserDrawEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const OUString &rStyleName);
222  void SetupEntry(vcl::RenderContext& rRenderContext, sal_Int32 nItem, const tools::Rectangle& rRect, std::u16string_view rStyleName, bool bIsNotSelected);
223  static bool AdjustFontForItemHeight(OutputDevice& rDevice, tools::Rectangle const & rTextRect, tools::Long nHeight);
224  DECL_LINK(MenuSelectHdl, const OString&, void);
225  DECL_STATIC_LINK(SvxStyleBox_Base, ShowMoreHdl, void*, void);
226 };
227 
228 class SvxStyleBox_Impl final : public InterimItemWindow
229  , public SvxStyleBox_Base
230 {
231 public:
232  SvxStyleBox_Impl(vcl::Window* pParent, const OUString& rCommand, SfxStyleFamily eFamily, const Reference< XDispatchProvider >& rDispatchProvider,
233  const Reference< XFrame >& _xFrame,const OUString& rClearFormatKey, const OUString& rMoreKey, bool bInSpecialMode, SvxStyleToolBoxControl& rCtrl);
234 
235  virtual ~SvxStyleBox_Impl() override
236  {
237  disposeOnce();
238  }
239 
240  virtual void dispose() override
241  {
242  m_xWidget.reset();
243  m_xMenu.reset();
244  m_xMenuBuilder.reset();
245  InterimItemWindow::dispose();
246  }
247 
248  virtual bool DoKeyInput(const KeyEvent& rKEvt) override;
249 
250 private:
251 
252  virtual void DataChanged(const DataChangedEvent& rDCEvt) override;
253  void SetOptimalSize();
254 };
255 
256 class SvxFontNameBox_Impl;
257 class SvxFontNameBox_Base;
258 
259 class SvxFontNameToolBoxControl final : public cppu::ImplInheritanceHelper<svt::ToolboxController,
260  css::lang::XServiceInfo>
261 {
262 public:
263  SvxFontNameToolBoxControl();
264 
265  // XStatusListener
266  virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
267 
268  // XToolbarController
269  virtual css::uno::Reference<css::awt::XWindow> SAL_CALL createItemWindow(const css::uno::Reference<css::awt::XWindow>& rParent) override;
270 
271  // XComponent
272  virtual void SAL_CALL dispose() override;
273 
274  // XServiceInfo
275  virtual OUString SAL_CALL getImplementationName() override;
276  virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
277  virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
278 
279 private:
280  VclPtr<SvxFontNameBox_Impl> m_xVclBox;
281  std::unique_ptr<SvxFontNameBox_Base> m_xWeldBox;
282  SvxFontNameBox_Base* m_pBox;
283 };
284 
285 class FontOptionsListener final : public comphelper::ConfigurationListenerProperty<bool>
286 {
287 private:
288  SvxFontNameBox_Base& m_rBox;
289 
290  virtual void setProperty(const css::uno::Any &rProperty) override;
291 public:
292  FontOptionsListener(const rtl::Reference<comphelper::ConfigurationListener>& rListener, const OUString& rProp, SvxFontNameBox_Base& rBox)
293  : comphelper::ConfigurationListenerProperty<bool>(rListener, rProp)
294  , m_rBox(rBox)
295  {
296  }
297 };
298 
299 class SvxFontNameBox_Base
300 {
301 private:
302  rtl::Reference<comphelper::ConfigurationListener> m_xListener;
303  FontOptionsListener m_aWYSIWYG;
304  FontOptionsListener m_aHistory;
305 
306 protected:
307  SvxFontNameToolBoxControl& m_rCtrl;
308 
309  std::unique_ptr<FontNameBox> m_xWidget;
310  const FontList* pFontList;
311  ::std::unique_ptr<FontList> m_aOwnFontList;
312  vcl::Font aCurFont;
313  sal_uInt16 nFtCount;
314  bool bRelease;
315  Reference< XDispatchProvider > m_xDispatchProvider;
316  Reference< XFrame > m_xFrame;
317  bool mbCheckingUnknownFont;
318 
319  void ReleaseFocus_Impl();
320 
321  void Select(bool bNonTravelSelect);
322 
323  void EndPreview()
324  {
325  Sequence< PropertyValue > aArgs;
326  SfxToolBoxControl::Dispatch( m_xDispatchProvider,
327  ".uno:CharEndPreviewFontName",
328  aArgs );
329  }
330  void CheckAndMarkUnknownFont();
331 
332 public:
333  SvxFontNameBox_Base(std::unique_ptr<weld::ComboBox> xWidget, const Reference<XDispatchProvider>& rDispatchProvider,
334  const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl);
335  virtual ~SvxFontNameBox_Base()
336  {
337  m_xListener->dispose();
338  }
339 
340  void FillList();
341  void Update( const css::awt::FontDescriptor* pFontDesc );
342  sal_uInt16 GetListCount() const { return nFtCount; }
343  void Clear() { m_xWidget->clear(); nFtCount = 0; }
344  void Fill( const FontList* pList )
345  {
346  m_xWidget->Fill(pList);
347  nFtCount = pList->GetFontNameCount();
348  }
349 
350  void SetOwnFontList(::std::unique_ptr<FontList> && _aOwnFontList) { m_aOwnFontList = std::move(_aOwnFontList); }
351 
352  virtual void set_sensitive(bool bSensitive)
353  {
354  m_xWidget->set_sensitive(bSensitive);
355  }
356 
357  void set_active_or_entry_text(const OUString& rText);
358 
359  void statusChanged_Impl(const css::frame::FeatureStateEvent& rEvent);
360 
361  virtual bool DoKeyInput(const KeyEvent& rKEvt);
362 
363  void EnableControls();
364 
365  DECL_LINK(SelectHdl, weld::ComboBox&, void);
366  DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
367  DECL_LINK(ActivateHdl, weld::ComboBox&, bool);
368  DECL_LINK(FocusInHdl, weld::Widget&, void);
369  DECL_LINK(FocusOutHdl, weld::Widget&, void);
370  DECL_LINK(DumpAsPropertyTreeHdl, tools::JsonWriter&, void);
371 };
372 
373 void FontOptionsListener::setProperty(const css::uno::Any &rProperty)
374 {
375  comphelper::ConfigurationListenerProperty<bool>::setProperty(rProperty);
376  m_rBox.EnableControls();
377 }
378 
379 class SvxFontNameBox_Impl final : public InterimItemWindow
380  , public SvxFontNameBox_Base
381 {
382 private:
383  virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
384  virtual void GetFocus() override
385  {
386  if (m_xWidget)
387  m_xWidget->grab_focus();
388  InterimItemWindow::GetFocus();
389  }
390 
391  void SetOptimalSize();
392 
393  virtual bool DoKeyInput(const KeyEvent& rKEvt) override;
394 
395 public:
396  SvxFontNameBox_Impl(vcl::Window* pParent, const Reference<XDispatchProvider>& rDispatchProvider,
397  const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl);
398 
399  virtual void dispose() override
400  {
401  m_xWidget.reset();
402  InterimItemWindow::dispose();
403  }
404 
405  virtual ~SvxFontNameBox_Impl() override
406  {
407  disposeOnce();
408  }
409 
410  virtual Reference< css::accessibility::XAccessible > CreateAccessible() override;
411 
412  virtual void set_sensitive(bool bSensitive) override
413  {
414  m_xWidget->set_sensitive(bSensitive);
415  if (bSensitive)
416  InterimItemWindow::Enable();
417  else
418  InterimItemWindow::Disable();
419  }
420 };
421 
422 
423 // SelectHdl needs the Modifiers, get them in MouseButtonUp
424 class SvxFrmValueSet_Impl final : public ValueSet
425 {
426 private:
427  sal_uInt16 nModifier;
428 
429  virtual bool MouseButtonUp(const MouseEvent& rMEvt) override
430  {
431  nModifier = rMEvt.GetModifier();
432  return ValueSet::MouseButtonUp(rMEvt);
433  }
434 
435 public:
436  SvxFrmValueSet_Impl()
437  : ValueSet(nullptr)
438  , nModifier(0)
439  {
440  }
441  sal_uInt16 GetModifier() const {return nModifier;}
442 };
443 
444 }
445 
446 namespace {
447 
448 class SvxFrameToolBoxControl;
449 
450 class SvxFrameWindow_Impl final : public WeldToolbarPopup
451 {
452 private:
453  rtl::Reference<SvxFrameToolBoxControl> mxControl;
454  std::unique_ptr<SvxFrmValueSet_Impl> mxFrameSet;
455  std::unique_ptr<weld::CustomWeld> mxFrameSetWin;
456  std::vector<std::pair<BitmapEx, OUString>> aImgVec;
457  bool bParagraphMode;
458 
459  void InitImageList();
460  void CalcSizeValueSet();
461  DECL_LINK( SelectHdl, ValueSet*, void );
462 
463 public:
464  SvxFrameWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent);
465  virtual void GrabFocus() override
466  {
467  mxFrameSet->GrabFocus();
468  }
469 
470  virtual void statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
471 };
472 
473 class SvxFrameToolBoxControl : public svt::PopupWindowController
474 {
475 public:
476  explicit SvxFrameToolBoxControl( const css::uno::Reference< css::uno::XComponentContext >& rContext );
477 
478  // XInitialization
479  virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& rArguments ) override;
480 
481  // XServiceInfo
482  virtual OUString SAL_CALL getImplementationName() override;
483  virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
484 
485  virtual void SAL_CALL execute(sal_Int16 nKeyModifier) override;
486 private:
487  virtual std::unique_ptr<WeldToolbarPopup> weldPopupWindow() override;
488  virtual VclPtr<vcl::Window> createVclPopupWindow( vcl::Window* pParent ) override;
489 };
490 
491  class LineListBox final : public ValueSet
492  {
493  public:
494  typedef Color (*ColorFunc)(Color);
495  typedef Color (*ColorDistFunc)(Color, Color);
496 
497  LineListBox();
498 
500  Size SetWidth( tools::Long nWidth )
501  {
502  tools::Long nOldWidth = m_nWidth;
503  m_nWidth = nWidth;
504  return UpdateEntries( nOldWidth );
505  }
506 
507  void SetNone( const OUString& sNone )
508  {
509  m_sNone = sNone;
510  }
511 
513  void InsertEntry(const BorderWidthImpl& rWidthImpl,
514  SvxBorderLineStyle nStyle, tools::Long nMinWidth = 0,
515  ColorFunc pColor1Fn = &sameColor,
516  ColorFunc pColor2Fn = &sameColor,
517  ColorDistFunc pColorDistFn = &sameDistColor);
518 
519  SvxBorderLineStyle GetEntryStyle( sal_Int32 nPos ) const;
520 
521  SvxBorderLineStyle GetSelectEntryStyle() const;
522 
523  void SetSourceUnit( FieldUnit eNewUnit ) { eSourceUnit = eNewUnit; }
524 
525  const Color& GetColor() const { return aColor; }
526 
527  virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override;
528  private:
529 
530  void ImpGetLine(tools::Long nLine1, tools::Long nLine2, tools::Long nDistance,
531  Color nColor1, Color nColor2, Color nColorDist,
532  SvxBorderLineStyle nStyle, BitmapEx& rBmp);
533 
534  void UpdatePaintLineColor(); // returns sal_True if maPaintCol has changed
535 
536  Size UpdateEntries( tools::Long nOldWidth );
537  sal_Int32 GetStylePos( sal_Int32 nListPos, tools::Long nWidth );
538 
539  const Color& GetPaintColor() const
540  {
541  return maPaintCol;
542  }
543 
544  Color GetColorLine1( sal_Int32 nPos );
545  Color GetColorLine2( sal_Int32 nPos );
546  Color GetColorDist( sal_Int32 nPos );
547 
548  LineListBox( const LineListBox& ) = delete;
549  LineListBox& operator =( const LineListBox& ) = delete;
550 
551  std::vector<std::unique_ptr<ImpLineListData>> m_vLineList;
552  tools::Long m_nWidth;
553  OUString m_sNone;
554  ScopedVclPtr<VirtualDevice> aVirDev;
555  Size aTxtSize;
556  Color const aColor;
557  Color maPaintCol;
558  FieldUnit eSourceUnit;
559  };
560 
561  SvxBorderLineStyle LineListBox::GetSelectEntryStyle() const
562  {
563  SvxBorderLineStyle nStyle = SvxBorderLineStyle::SOLID;
564  size_t nPos = GetSelectItemPos();
565  if (nPos != VALUESET_ITEM_NOTFOUND)
566  {
567  if (!m_sNone.isEmpty())
568  --nPos;
569  nStyle = GetEntryStyle( nPos );
570  }
571 
572  return nStyle;
573  }
574 
575  void LineListBox::ImpGetLine( tools::Long nLine1, tools::Long nLine2, tools::Long nDistance,
576  Color aColor1, Color aColor2, Color aColorDist,
577  SvxBorderLineStyle nStyle, BitmapEx& rBmp )
578  {
579  auto nMinWidth = GetDrawingArea()->get_ref_device().approximate_digit_width() * COMBO_WIDTH_IN_CHARS;
580  Size aSize(nMinWidth, aTxtSize.Height());
581  aSize.AdjustWidth( -(aTxtSize.Width()) );
582  aSize.AdjustWidth( -6 );
583 
584  // SourceUnit to Twips
585  if ( eSourceUnit == FieldUnit::POINT )
586  {
587  nLine1 /= 5;
588  nLine2 /= 5;
589  nDistance /= 5;
590  }
591 
592  // Paint the lines
593  aSize = aVirDev->PixelToLogic( aSize );
594  tools::Long nPix = aVirDev->PixelToLogic( Size( 0, 1 ) ).Height();
595  sal_uInt32 n1 = nLine1;
596  sal_uInt32 n2 = nLine2;
597  tools::Long nDist = nDistance;
598  n1 += nPix-1;
599  n1 -= n1%nPix;
600  if ( n2 )
601  {
602  nDist += nPix-1;
603  nDist -= nDist%nPix;
604  n2 += nPix-1;
605  n2 -= n2%nPix;
606  }
607  tools::Long nVirHeight = n1+nDist+n2;
608  if ( nVirHeight > aSize.Height() )
609  aSize.setHeight( nVirHeight );
610  // negative width should not be drawn
611  if ( aSize.Width() <= 0 )
612  return;
613 
614  Size aVirSize = aVirDev->LogicToPixel( aSize );
615  if ( aVirDev->GetOutputSizePixel() != aVirSize )
616  aVirDev->SetOutputSizePixel( aVirSize );
617  aVirDev->SetFillColor( aColorDist );
618  aVirDev->DrawRect( tools::Rectangle( Point(), aSize ) );
619 
620  aVirDev->SetFillColor( aColor1 );
621 
622  double y1 = double( n1 ) / 2;
623  svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y1 ), basegfx::B2DPoint( aSize.Width( ), y1 ), n1, nStyle );
624 
625  if ( n2 )
626  {
627  double y2 = n1 + nDist + double( n2 ) / 2;
628  aVirDev->SetFillColor( aColor2 );
629  svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y2 ), basegfx::B2DPoint( aSize.Width(), y2 ), n2, SvxBorderLineStyle::SOLID );
630  }
631  rBmp = aVirDev->GetBitmapEx( Point(), Size( aSize.Width(), n1+nDist+n2 ) );
632  }
633 
634  LineListBox::LineListBox()
635  : ValueSet(nullptr)
636  , m_nWidth( 5 )
637  , m_sNone()
638  , aVirDev(VclPtr<VirtualDevice>::Create())
639  , aColor(COL_BLACK)
640  , maPaintCol(COL_BLACK)
641  , eSourceUnit(FieldUnit::POINT)
642  {
643  aVirDev->SetLineColor();
644  aVirDev->SetMapMode( MapMode( MapUnit::MapTwip ) );
645  }
646 
647  void LineListBox::SetDrawingArea(weld::DrawingArea* pDrawingArea)
648  {
649  ValueSet::SetDrawingArea(pDrawingArea);
650 
651  OutputDevice& rDevice = pDrawingArea->get_ref_device();
652 
653  aTxtSize.setWidth( rDevice.approximate_digit_width() );
654  aTxtSize.setHeight( rDevice.GetTextHeight() );
655 
656  UpdatePaintLineColor();
657  }
658 
659  sal_Int32 LineListBox::GetStylePos( sal_Int32 nListPos, tools::Long nWidth )
660  {
661  sal_Int32 nPos = -1;
662  if (!m_sNone.isEmpty())
663  nListPos--;
664 
665  sal_Int32 n = 0;
666  size_t i = 0;
667  size_t nCount = m_vLineList.size();
668  while ( nPos == -1 && i < nCount )
669  {
670  auto& pData = m_vLineList[ i ];
671  if ( pData->GetMinWidth() <= nWidth )
672  {
673  if ( nListPos == n )
674  nPos = static_cast<sal_Int32>(i);
675  n++;
676  }
677  i++;
678  }
679 
680  return nPos;
681  }
682 
683  void LineListBox::InsertEntry(
684  const BorderWidthImpl& rWidthImpl, SvxBorderLineStyle nStyle, tools::Long nMinWidth,
685  ColorFunc pColor1Fn, ColorFunc pColor2Fn, ColorDistFunc pColorDistFn )
686  {
687  m_vLineList.emplace_back(new ImpLineListData(
688  rWidthImpl, nStyle, nMinWidth, pColor1Fn, pColor2Fn, pColorDistFn));
689  }
690 
691  SvxBorderLineStyle LineListBox::GetEntryStyle( sal_Int32 nPos ) const
692  {
693  ImpLineListData* pData = (0 <= nPos && o3tl::make_unsigned(nPos) < m_vLineList.size()) ? m_vLineList[ nPos ].get() : nullptr;
694  return pData ? pData->GetStyle() : SvxBorderLineStyle::NONE;
695  }
696 
697  void LineListBox::UpdatePaintLineColor()
698  {
699  const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
700  Color aNewCol( rSettings.GetWindowColor().IsDark()? rSettings.GetLabelTextColor() : aColor );
701 
702  bool bRet = aNewCol != maPaintCol;
703 
704  if( bRet )
705  maPaintCol = aNewCol;
706  }
707 
708  Size LineListBox::UpdateEntries( tools::Long nOldWidth )
709  {
710  Size aSize;
711 
712  UpdatePaintLineColor( );
713 
714  sal_Int32 nSelEntry = GetSelectItemPos();
715  sal_Int32 nTypePos = GetStylePos( nSelEntry, nOldWidth );
716 
717  // Remove the old entries
718  Clear();
719 
720  sal_uInt16 nId(1);
721 
722  // Add the new entries based on the defined width
723  if (!m_sNone.isEmpty())
724  InsertItem(nId++, Image(), m_sNone);
725 
726  sal_uInt16 n = 0;
727  sal_uInt16 nCount = m_vLineList.size( );
728  while ( n < nCount )
729  {
730  auto& pData = m_vLineList[ n ];
731  if ( pData->GetMinWidth() <= m_nWidth )
732  {
733  BitmapEx aBmp;
734  ImpGetLine( pData->GetLine1ForWidth( m_nWidth ),
735  pData->GetLine2ForWidth( m_nWidth ),
736  pData->GetDistForWidth( m_nWidth ),
737  GetColorLine1( GetItemCount( ) ),
738  GetColorLine2( GetItemCount( ) ),
739  GetColorDist( GetItemCount( ) ),
740  pData->GetStyle(), aBmp );
741  InsertItem(nId, Image(aBmp), SvtLineListBox::GetLineStyleName(pData->GetStyle()));
742  Size aBmpSize = aBmp.GetSizePixel();
743  if (aBmpSize.Width() > aSize.Width())
744  aSize.setWidth(aBmpSize.getWidth());
745  if (aBmpSize.Height() > aSize.Height())
746  aSize.setHeight(aBmpSize.getHeight());
747  if ( n == nTypePos )
748  SelectItem(nId);
749  }
750  else if ( n == nTypePos )
751  SetNoSelection();
752  n++;
753  ++nId;
754  }
755 
756  Invalidate();
757 
758  return aSize;
759  }
760 
761  Color LineListBox::GetColorLine1( sal_Int32 nPos )
762  {
763  sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
764  if (nStyle == -1)
765  return GetPaintColor( );
766  auto& pData = m_vLineList[ nStyle ];
767  return pData->GetColorLine1( GetColor( ) );
768  }
769 
770  Color LineListBox::GetColorLine2( sal_Int32 nPos )
771  {
772  sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
773  if (nStyle == -1)
774  return GetPaintColor( );
775  auto& pData = m_vLineList[ nStyle ];
776  return pData->GetColorLine2( GetColor( ) );
777  }
778 
779  Color LineListBox::GetColorDist( sal_Int32 nPos )
780  {
781  Color rResult = Application::GetSettings().GetStyleSettings().GetFieldColor();
782 
783  sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
784  if (nStyle == -1)
785  return rResult;
786  auto& pData = m_vLineList[ nStyle ];
787  return pData->GetColorDist( GetColor( ), rResult );
788  }
789 }
790 
791 namespace {
792 
793 class SvxLineWindow_Impl final : public WeldToolbarPopup
794 {
795 private:
796  rtl::Reference<SvxFrameToolBoxControl> m_xControl;
797  std::unique_ptr<LineListBox> m_xLineStyleLb;
798  std::unique_ptr<weld::CustomWeld> m_xLineStyleLbWin;
799  bool m_bIsWriter;
800 
801  DECL_LINK( SelectHdl, ValueSet*, void );
802 
803 public:
804  SvxLineWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent);
805  virtual void GrabFocus() override
806  {
807  m_xLineStyleLb->GrabFocus();
808  }
809 };
810 
811 }
812 
813 class SvxStyleToolBoxControl;
814 
815 class SfxStyleControllerItem_Impl : public SfxStatusListener
816 {
817  public:
818  SfxStyleControllerItem_Impl( const Reference< XDispatchProvider >& rDispatchProvider,
819  sal_uInt16 nSlotId,
820  const OUString& rCommand,
821  SvxStyleToolBoxControl& rTbxCtl );
822 
823  protected:
824  virtual void StateChanged( SfxItemState eState, const SfxPoolItem* pState ) override;
825 
826  private:
827  SvxStyleToolBoxControl& rControl;
828 };
829 
830 #define BUTTON_PADDING 10
831 #define ITEM_HEIGHT 30
832 
833 SvxStyleBox_Base::SvxStyleBox_Base(std::unique_ptr<weld::ComboBox> xWidget,
834  const OUString& rCommand,
835  SfxStyleFamily eFamily,
836  const Reference< XDispatchProvider >& rDispatchProvider,
837  const Reference< XFrame >& _xFrame,
838  const OUString& rClearFormatKey,
839  const OUString& rMoreKey,
840  bool bInSpec, SvxStyleToolBoxControl& rCtrl)
841  : m_rCtrl(rCtrl)
842  , m_xMenuBuilder(Application::CreateBuilder(nullptr, "svx/ui/stylemenu.ui"))
843  , m_xMenu(m_xMenuBuilder->weld_menu("menu"))
844  , m_xWidget(std::move(xWidget))
845  , eStyleFamily( eFamily )
846  , m_nMaxUserDrawFontWidth(0)
847  , m_nLastItemWithMenu(-1)
848  , bRelease( true )
849  , m_xDispatchProvider( rDispatchProvider )
850  , m_xFrame(_xFrame)
851  , m_aCommand( rCommand )
852  , aClearFormatKey( rClearFormatKey )
853  , aMoreKey( rMoreKey )
854  , bInSpecialMode( bInSpec )
855 {
856  m_xWidget->connect_changed(LINK(this, SvxStyleBox_Base, SelectHdl));
857  m_xWidget->connect_key_press(LINK(this, SvxStyleBox_Base, KeyInputHdl));
858  m_xWidget->connect_entry_activate(LINK(this, SvxStyleBox_Base, ActivateHdl));
859  m_xWidget->connect_focus_out(LINK(this, SvxStyleBox_Base, FocusOutHdl));
860  m_xWidget->connect_get_property_tree(LINK(this, SvxStyleBox_Base, DumpAsPropertyTreeHdl));
861  m_xWidget->set_help_id(HID_STYLE_LISTBOX);
862  m_xWidget->set_entry_completion(true);
863  m_xMenu->connect_activate(LINK(this, SvxStyleBox_Base, MenuSelectHdl));
864 
865  m_xWidget->connect_custom_get_size(LINK(this, SvxStyleBox_Base, CustomGetSizeHdl));
866  m_xWidget->connect_custom_render(LINK(this, SvxStyleBox_Base, CustomRenderHdl));
867  m_xWidget->set_custom_renderer(true);
868 
869  m_xWidget->set_entry_width_chars(COMBO_WIDTH_IN_CHARS + 3);
870 }
871 
872 IMPL_LINK(SvxStyleBox_Base, CustomGetSizeHdl, OutputDevice&, rArg, Size)
873 {
874  CalcOptimalExtraUserWidth(rArg);
875  return Size(m_nMaxUserDrawFontWidth, ITEM_HEIGHT);
876 }
877 
878 SvxStyleBox_Impl::SvxStyleBox_Impl(vcl::Window* pParent,
879  const OUString& rCommand,
880  SfxStyleFamily eFamily,
881  const Reference< XDispatchProvider >& rDispatchProvider,
882  const Reference< XFrame >& _xFrame,
883  const OUString& rClearFormatKey,
884  const OUString& rMoreKey,
885  bool bInSpec, SvxStyleToolBoxControl& rCtrl)
886  : InterimItemWindow(pParent, "svx/ui/applystylebox.ui", "ApplyStyleBox")
887  , SvxStyleBox_Base(m_xBuilder->weld_combo_box("applystyle"), rCommand, eFamily,
888  rDispatchProvider, _xFrame, rClearFormatKey, rMoreKey, bInSpec, rCtrl)
889 {
890  InitControlBase(m_xWidget.get());
891 
892  set_id("applystyle");
893  SetOptimalSize();
894 }
895 
896 void SvxStyleBox_Base::ReleaseFocus()
897 {
898  if ( !bRelease )
899  {
900  bRelease = true;
901  return;
902  }
903  if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
904  m_xFrame->getContainerWindow()->setFocus();
905 }
906 
907 IMPL_LINK(SvxStyleBox_Base, MenuSelectHdl, const OString&, rMenuIdent, void)
908 {
909  if (m_nLastItemWithMenu < 0 || m_nLastItemWithMenu >= m_xWidget->get_count())
910  return;
911 
912  OUString sEntry = m_xWidget->get_text(m_nLastItemWithMenu);
913 
914  ReleaseFocus(); // It must be after getting entry pos!
915  Sequence<PropertyValue> aArgs(2);
916  aArgs[0].Name = "Param";
917  aArgs[0].Value <<= sEntry;
918  aArgs[1].Name = "Family";
919  aArgs[1].Value <<= sal_Int16( eStyleFamily );
920 
921  if (rMenuIdent == "update")
922  {
923  SfxToolBoxControl::Dispatch( m_xDispatchProvider,
924  ".uno:StyleUpdateByExample", aArgs );
925  }
926  else if (rMenuIdent == "edit")
927  {
928  SfxToolBoxControl::Dispatch( m_xDispatchProvider,
929  ".uno:EditStyle", aArgs );
930  }
931 }
932 
933 IMPL_STATIC_LINK_NOARG(SvxStyleBox_Base, ShowMoreHdl, void*, void)
934 {
935  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
936  DBG_ASSERT( pViewFrm, "SvxStyleBox_Base::Select(): no viewframe" );
937  if (!pViewFrm)
938  return;
939  pViewFrm->ShowChildWindow(SID_SIDEBAR);
940  ::sfx2::sidebar::Sidebar::ShowPanel(u"StyleListPanel", pViewFrm->GetFrame().GetFrameInterface(), true);
941 }
942 
943 IMPL_LINK(SvxStyleBox_Base, SelectHdl, weld::ComboBox&, rCombo, void)
944 {
945  Select(rCombo.changed_by_direct_pick()); // only when picked from the list
946 }
947 
948 IMPL_LINK_NOARG(SvxStyleBox_Base, ActivateHdl, weld::ComboBox&, bool)
949 {
950  Select(true);
951  return true;
952 }
953 
954 void SvxStyleBox_Base::Select(bool bNonTravelSelect)
955 {
956  if (!bNonTravelSelect)
957  return;
958 
959  OUString aSearchEntry(m_xWidget->get_active_text());
960  bool bDoIt = true, bClear = false;
961  if( bInSpecialMode )
962  {
963  if( aSearchEntry == aClearFormatKey && m_xWidget->get_active() == 0 )
964  {
965  aSearchEntry = sDefaultStyle;
966  bClear = true;
967  //not only apply default style but also call 'ClearFormatting'
968  Sequence< PropertyValue > aEmptyVals;
969  SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:ResetAttributes",
970  aEmptyVals);
971  }
972  else if (aSearchEntry == aMoreKey && m_xWidget->get_active() == (m_xWidget->get_count() - 1))
973  {
974  Application::PostUserEvent(LINK(nullptr, SvxStyleBox_Base, ShowMoreHdl));
975  //tdf#113214 change text back to previous entry
976  set_active_or_entry_text(m_xWidget->get_saved_value());
977  bDoIt = false;
978  }
979  }
980 
981  //Do we need to create a new style?
982  SfxObjectShell *pShell = SfxObjectShell::Current();
983  SfxStyleSheetBasePool* pPool = pShell->GetStyleSheetPool();
984  SfxStyleSheetBase* pStyle = nullptr;
985 
986  bool bCreateNew = false;
987 
988  if ( pPool )
989  {
990  pStyle = pPool->First(eStyleFamily);
991  while ( pStyle && pStyle->GetName() != aSearchEntry )
992  pStyle = pPool->Next();
993  }
994 
995  if ( !pStyle )
996  {
997  // cannot find the style for whatever reason
998  // therefore create a new style
999  bCreateNew = true;
1000  }
1001 
1002  /* #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
1003  This instance may be deleted in the meantime (i.e. when a dialog is opened
1004  while in Dispatch()), accessing members will crash in this case. */
1005  ReleaseFocus();
1006 
1007  if( !bDoIt )
1008  return;
1009 
1010  if ( bClear )
1011  set_active_or_entry_text(aSearchEntry);
1012  m_xWidget->save_value();
1013 
1014  Sequence< PropertyValue > aArgs( 2 );
1015  aArgs[0].Value <<= aSearchEntry;
1016  aArgs[1].Name = "Family";
1017  aArgs[1].Value <<= sal_Int16( eStyleFamily );
1018  if( bCreateNew )
1019  {
1020  aArgs[0].Name = "Param";
1021  SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:StyleNewByExample", aArgs);
1022  }
1023  else
1024  {
1025  aArgs[0].Name = "Template";
1026  SfxToolBoxControl::Dispatch( m_xDispatchProvider, m_aCommand, aArgs );
1027  }
1028 }
1029 
1030 void SvxStyleBox_Base::SetFamily( SfxStyleFamily eNewFamily )
1031 {
1032  eStyleFamily = eNewFamily;
1033 }
1034 
1035 IMPL_LINK_NOARG(SvxStyleBox_Base, FocusOutHdl, weld::Widget&, void)
1036 {
1037  if (!m_xWidget->has_focus()) // a combobox can be comprised of different subwidget so double-check if none of those has focus
1038  set_active_or_entry_text(m_xWidget->get_saved_value());
1039 }
1040 
1041 IMPL_LINK(SvxStyleBox_Base, KeyInputHdl, const KeyEvent&, rKEvt, bool)
1042 {
1043  return DoKeyInput(rKEvt);
1044 }
1045 
1046 bool SvxStyleBox_Base::DoKeyInput(const KeyEvent& rKEvt)
1047 {
1048  bool bHandled = false;
1049 
1050  sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
1051 
1052  switch (nCode)
1053  {
1054  case KEY_TAB:
1055  bRelease = false;
1056  Select(true);
1057  break;
1058  case KEY_ESCAPE:
1059  set_active_or_entry_text(m_xWidget->get_saved_value());
1060  if (!m_rCtrl.IsInSidebar())
1061  {
1062  ReleaseFocus();
1063  bHandled = true;
1064  }
1065  break;
1066  }
1067 
1068  return bHandled;
1069 }
1070 
1071 bool SvxStyleBox_Impl::DoKeyInput(const KeyEvent& rKEvt)
1072 {
1073  return SvxStyleBox_Base::DoKeyInput(rKEvt) || ChildKeyInput(rKEvt);
1074 }
1075 
1076 void SvxStyleBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1077 {
1078  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1079  (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
1080  {
1081  SetOptimalSize();
1082  }
1083 
1084  InterimItemWindow::DataChanged( rDCEvt );
1085 }
1086 
1087 bool SvxStyleBox_Base::AdjustFontForItemHeight(OutputDevice& rDevice, tools::Rectangle const & rTextRect, tools::Long nHeight)
1088 {
1089  if (rTextRect.Bottom() > nHeight)
1090  {
1091  // the text does not fit, adjust the font size
1092  double ratio = static_cast< double >( nHeight ) / rTextRect.Bottom();
1093  vcl::Font aFont(rDevice.GetFont());
1094  Size aPixelSize(aFont.GetFontSize());
1095  aPixelSize.setWidth( aPixelSize.Width() * ratio );
1096  aPixelSize.setHeight( aPixelSize.Height() * ratio );
1097  aFont.SetFontSize(aPixelSize);
1098  rDevice.SetFont(aFont);
1099  return true;
1100  }
1101  return false;
1102 }
1103 
1104 void SvxStyleBox_Impl::SetOptimalSize()
1105 {
1106  // set width in chars low so the size request will not be overridden
1107  m_xWidget->set_entry_width_chars(1);
1108  // tdf#132338 purely using this calculation to keep things their traditional width
1109  Size aSize(LogicToPixel(Size((COMBO_WIDTH_IN_CHARS + 3) * 4, 0), MapMode(MapUnit::MapAppFont)));
1110  m_xWidget->set_size_request(aSize.Width(), -1);
1111 
1112  SetSizePixel(get_preferred_size());
1113 }
1114 
1115 void SvxStyleBox_Base::UserDrawEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const OUString &rStyleName)
1116 {
1117  // IMG_TXT_DISTANCE in ilstbox.hxx is 6, then 1 is added as
1118  // nBorder, and we are adding 1 in order to look better when
1119  // italics is present
1120  const int nLeftDistance = 8;
1121 
1122  tools::Rectangle aTextRect;
1123  rRenderContext.GetTextBoundRect(aTextRect, rStyleName);
1124 
1125  Point aPos(rRect.TopLeft());
1126  aPos.AdjustX(nLeftDistance );
1127 
1128  if (!AdjustFontForItemHeight(rRenderContext, aTextRect, rRect.GetHeight()))
1129  aPos.AdjustY((rRect.GetHeight() - aTextRect.Bottom() ) / 2);
1130 
1131  rRenderContext.DrawText(aPos, rStyleName);
1132 }
1133 
1134 void SvxStyleBox_Base::SetupEntry(vcl::RenderContext& rRenderContext, sal_Int32 nItem, const tools::Rectangle& rRect, std::u16string_view rStyleName, bool bIsNotSelected)
1135 {
1136  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1137  if (!bIsNotSelected)
1138  rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
1139  else
1140  rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());
1141 
1142  // handle the push-button
1143  if (!bIsNotSelected)
1144  {
1145  if (nItem == 0 || nItem == m_xWidget->get_count() - 1)
1146  m_xWidget->set_item_menu(OString::number(nItem), nullptr);
1147  else
1148  {
1149  m_nLastItemWithMenu = nItem;
1150  m_xWidget->set_item_menu(OString::number(nItem), m_xMenu.get());
1151  }
1152  }
1153 
1154  if (nItem <= 0 || nItem >= m_xWidget->get_count() - 1)
1155  return;
1156 
1157  SfxObjectShell *pShell = SfxObjectShell::Current();
1158  SfxStyleSheetBasePool* pPool = pShell->GetStyleSheetPool();
1159  SfxStyleSheetBase* pStyle = nullptr;
1160 
1161  if ( pPool )
1162  {
1163  pStyle = pPool->First(eStyleFamily);
1164  while (pStyle && pStyle->GetName() != rStyleName)
1165  pStyle = pPool->Next();
1166  }
1167 
1168  if (!pStyle )
1169  return;
1170 
1171  std::unique_ptr<const SfxItemSet> const pItemSet(pStyle->GetItemSetForPreview());
1172  if (!pItemSet) return;
1173 
1174  const SvxFontItem * const pFontItem =
1175  pItemSet->GetItem<SvxFontItem>(SID_ATTR_CHAR_FONT);
1176  const SvxFontHeightItem * const pFontHeightItem =
1177  pItemSet->GetItem<SvxFontHeightItem>(SID_ATTR_CHAR_FONTHEIGHT);
1178 
1179  if ( !(pFontItem && pFontHeightItem) )
1180  return;
1181 
1182  Size aFontSize( 0, pFontHeightItem->GetHeight() );
1183  Size aPixelSize(rRenderContext.LogicToPixel(aFontSize, MapMode(pShell->GetMapUnit())));
1184 
1185  // setup the font properties
1186  SvxFont aFont;
1187  aFont.SetFamilyName(pFontItem->GetFamilyName());
1188  aFont.SetStyleName(pFontItem->GetStyleName());
1189  aFont.SetFontSize(aPixelSize);
1190 
1191  const SfxPoolItem *pItem = pItemSet->GetItem( SID_ATTR_CHAR_WEIGHT );
1192  if ( pItem )
1193  aFont.SetWeight( static_cast< const SvxWeightItem* >( pItem )->GetWeight() );
1194 
1195  pItem = pItemSet->GetItem( SID_ATTR_CHAR_POSTURE );
1196  if ( pItem )
1197  aFont.SetItalic( static_cast< const SvxPostureItem* >( pItem )->GetPosture() );
1198 
1199  pItem = pItemSet->GetItem( SID_ATTR_CHAR_CONTOUR );
1200  if ( pItem )
1201  aFont.SetOutline( static_cast< const SvxContourItem* >( pItem )->GetValue() );
1202 
1203  pItem = pItemSet->GetItem( SID_ATTR_CHAR_SHADOWED );
1204  if ( pItem )
1205  aFont.SetShadow( static_cast< const SvxShadowedItem* >( pItem )->GetValue() );
1206 
1207  pItem = pItemSet->GetItem( SID_ATTR_CHAR_RELIEF );
1208  if ( pItem )
1209  aFont.SetRelief( static_cast< const SvxCharReliefItem* >( pItem )->GetValue() );
1210 
1211  pItem = pItemSet->GetItem( SID_ATTR_CHAR_UNDERLINE );
1212  if ( pItem )
1213  aFont.SetUnderline( static_cast< const SvxUnderlineItem* >( pItem )->GetLineStyle() );
1214 
1215  pItem = pItemSet->GetItem( SID_ATTR_CHAR_OVERLINE );
1216  if ( pItem )
1217  aFont.SetOverline( static_cast< const SvxOverlineItem* >( pItem )->GetValue() );
1218 
1219  pItem = pItemSet->GetItem( SID_ATTR_CHAR_STRIKEOUT );
1220  if ( pItem )
1221  aFont.SetStrikeout( static_cast< const SvxCrossedOutItem* >( pItem )->GetStrikeout() );
1222 
1223  pItem = pItemSet->GetItem( SID_ATTR_CHAR_CASEMAP );
1224  if ( pItem )
1225  aFont.SetCaseMap(static_cast<const SvxCaseMapItem*>(pItem)->GetCaseMap());
1226 
1227  pItem = pItemSet->GetItem( SID_ATTR_CHAR_EMPHASISMARK );
1228  if ( pItem )
1229  aFont.SetEmphasisMark( static_cast< const SvxEmphasisMarkItem* >( pItem )->GetEmphasisMark() );
1230 
1231  // setup the device & draw
1232  Color aFontCol = COL_AUTO, aBackCol = COL_AUTO;
1233 
1234  rRenderContext.SetFont(aFont);
1235 
1236  pItem = pItemSet->GetItem( SID_ATTR_CHAR_COLOR );
1237  // text color, when nothing is selected
1238  if ( (nullptr != pItem) && bIsNotSelected)
1239  aFontCol = static_cast< const SvxColorItem* >( pItem )->GetValue();
1240 
1241  drawing::FillStyle style = drawing::FillStyle_NONE;
1242  // which kind of Fill style is selected
1243  pItem = pItemSet->GetItem( XATTR_FILLSTYLE );
1244  // only when ok and not selected
1245  if ( (nullptr != pItem) && bIsNotSelected)
1246  style = static_cast< const XFillStyleItem* >( pItem )->GetValue();
1247 
1248  switch(style)
1249  {
1250  case drawing::FillStyle_SOLID:
1251  {
1252  // set background color
1253  pItem = pItemSet->GetItem( XATTR_FILLCOLOR );
1254  if ( nullptr != pItem )
1255  aBackCol = static_cast< const XFillColorItem* >( pItem )->GetColorValue();
1256 
1257  if ( aBackCol != COL_AUTO )
1258  {
1259  rRenderContext.SetFillColor(aBackCol);
1260  rRenderContext.DrawRect(rRect);
1261  }
1262  }
1263  break;
1264 
1265  default: break;
1266  //TODO Draw the other background styles: gradient, hatching and bitmap
1267  }
1268 
1269  // when the font and background color are too similar, adjust the Font-Color
1270  if( (aFontCol != COL_AUTO) || (aBackCol != COL_AUTO) )
1271  aFontCol = TestColorsVisible(aFontCol, (aBackCol != COL_AUTO) ? aBackCol : rRenderContext.GetBackground().GetColor());
1272 
1273  // set text color
1274  if ( aFontCol != COL_AUTO )
1275  rRenderContext.SetTextColor(aFontCol);
1276 }
1277 
1278 IMPL_LINK(SvxStyleBox_Base, CustomRenderHdl, weld::ComboBox::render_args, aPayload, void)
1279 {
1280  vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
1281  const ::tools::Rectangle& rRect = std::get<1>(aPayload);
1282  bool bSelected = std::get<2>(aPayload);
1283  const OUString& rId = std::get<3>(aPayload);
1284 
1285  sal_uInt32 nIndex = rId.toUInt32();
1286 
1287  OUString aStyleName(m_xWidget->get_text(nIndex));
1288 
1289  rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::FONT | PushFlags::TEXTCOLOR);
1290 
1291  SetupEntry(rRenderContext, nIndex, rRect, aStyleName, !bSelected);
1292 
1293  UserDrawEntry(rRenderContext, rRect, aStyleName);
1294 
1295  rRenderContext.Pop();
1296 }
1297 
1298 void SvxStyleBox_Base::CalcOptimalExtraUserWidth(vcl::RenderContext& rRenderContext)
1299 {
1300  if (m_nMaxUserDrawFontWidth)
1301  return;
1302 
1303  tools::Long nMaxNormalFontWidth = 0;
1304  sal_Int32 nEntryCount = m_xWidget->get_count();
1305  for (sal_Int32 i = 0; i < nEntryCount; ++i)
1306  {
1307  OUString sStyleName(get_text(i));
1308  tools::Rectangle aTextRectForDefaultFont;
1309  rRenderContext.GetTextBoundRect(aTextRectForDefaultFont, sStyleName);
1310 
1311  const tools::Long nWidth = aTextRectForDefaultFont.GetWidth();
1312 
1313  nMaxNormalFontWidth = std::max(nWidth, nMaxNormalFontWidth);
1314  }
1315 
1316  m_nMaxUserDrawFontWidth = nMaxNormalFontWidth;
1317  for (sal_Int32 i = 1; i < nEntryCount-1; ++i)
1318  {
1319  OUString sStyleName(get_text(i));
1320 
1321  rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::FONT | PushFlags::TEXTCOLOR);
1322  SetupEntry(rRenderContext, i, tools::Rectangle(0, 0, RECT_MAX, ITEM_HEIGHT), sStyleName, true);
1323  tools::Rectangle aTextRectForActualFont;
1324  rRenderContext.GetTextBoundRect(aTextRectForActualFont, sStyleName);
1325  if (AdjustFontForItemHeight(rRenderContext, aTextRectForActualFont, ITEM_HEIGHT))
1326  {
1327  //Font didn't fit, so it was changed, refetch with final font size
1328  rRenderContext.GetTextBoundRect(aTextRectForActualFont, sStyleName);
1329  }
1330  rRenderContext.Pop();
1331 
1332  const int nWidth = aTextRectForActualFont.GetWidth() + m_xWidget->get_menu_button_width() + BUTTON_PADDING;
1333 
1334  m_nMaxUserDrawFontWidth = std::max(nWidth, m_nMaxUserDrawFontWidth);
1335  }
1336 }
1337 
1338 // test is the color between Font- and background-color to be identify
1339 // return is always the Font-Color
1340 // when both light or dark, change the Contrast
1341 // in other case do not change the origin color
1342 // when the color is R=G=B=128 the DecreaseContrast make 128 the need an exception
1343 Color SvxStyleBox_Base::TestColorsVisible(const Color &FontCol, const Color &BackCol)
1344 {
1345  constexpr sal_uInt8 ChgVal = 60; // increase/decrease the Contrast
1346 
1347  Color retCol = FontCol;
1348  if ((FontCol.IsDark() == BackCol.IsDark()) && (FontCol.IsBright() == BackCol.IsBright()))
1349  {
1350  sal_uInt8 lumi = retCol.GetLuminance();
1351 
1352  if((lumi > 120) && (lumi < 140))
1353  retCol.DecreaseLuminance(ChgVal / 2);
1354  else
1355  retCol.DecreaseContrast(ChgVal);
1356  }
1357 
1358  return retCol;
1359 }
1360 
1361 IMPL_LINK(SvxStyleBox_Base, DumpAsPropertyTreeHdl, tools::JsonWriter&, rJsonWriter, void)
1362 {
1363  {
1364  auto entriesNode = rJsonWriter.startNode("entries");
1365  for (int i = 0, nEntryCount = m_xWidget->get_count(); i < nEntryCount; ++i)
1366  {
1367  auto entryNode = rJsonWriter.startNode("");
1368  rJsonWriter.put("", m_xWidget->get_text(i));
1369  }
1370  }
1371 
1372  int nActive = m_xWidget->get_active();
1373  rJsonWriter.put("selectedCount", static_cast<sal_Int32>(nActive == -1 ? 0 : 1));
1374 
1375  {
1376  auto selectedNode = rJsonWriter.startNode("selectedEntries");
1377  if (nActive != -1)
1378  {
1379  auto node = rJsonWriter.startNode("");
1380  rJsonWriter.put("", static_cast<sal_Int32>(nActive));
1381  }
1382  }
1383 
1384  rJsonWriter.put("command", ".uno:StyleApply");
1385 }
1386 
1387 static bool lcl_GetDocFontList(const FontList** ppFontList, SvxFontNameBox_Base* pBox)
1388 {
1389  bool bChanged = false;
1390  const SfxObjectShell* pDocSh = SfxObjectShell::Current();
1391  const SvxFontListItem* pFontListItem = nullptr;
1392 
1393  if ( pDocSh )
1394  pFontListItem =
1395  static_cast<const SvxFontListItem*>(pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST ));
1396  else
1397  {
1398  ::std::unique_ptr<FontList> aFontList(new FontList(Application::GetDefaultDevice()));
1399  *ppFontList = aFontList.get();
1400  pBox->SetOwnFontList(std::move(aFontList));
1401  bChanged = true;
1402  }
1403 
1404  if ( pFontListItem )
1405  {
1406  const FontList* pNewFontList = pFontListItem->GetFontList();
1407  DBG_ASSERT( pNewFontList, "Doc-FontList not available!" );
1408 
1409  // No old list, but a new list
1410  if ( !*ppFontList && pNewFontList )
1411  {
1412  // => take over
1413  *ppFontList = pNewFontList;
1414  bChanged = true;
1415  }
1416  else
1417  {
1418  // Comparing the font lists is not perfect.
1419  // When you change the font list in the Doc, you can track
1420  // changes here only on the Listbox, because ppFontList
1421  // has already been updated.
1422  bChanged =
1423  ( ( *ppFontList != pNewFontList ) ||
1424  pBox->GetListCount() != pNewFontList->GetFontNameCount() );
1425  // HACK: Comparing is incomplete
1426 
1427  if ( bChanged )
1428  *ppFontList = pNewFontList;
1429  }
1430 
1431  if ( pBox )
1432  pBox->set_sensitive(true);
1433  }
1434  else if ( pBox && ( pDocSh || !ppFontList ))
1435  {
1436  // Disable box only when we have a SfxObjectShell and didn't get a font list OR
1437  // we don't have a SfxObjectShell and no current font list.
1438  // It's possible that we currently have no SfxObjectShell, but a current font list.
1439  // See #i58471: When a user set the focus into the font name combo box and opens
1440  // the help window with F1. After closing the help window, we disable the font name
1441  // combo box. The SfxObjectShell::Current() method returns in that case zero. But the
1442  // font list hasn't changed and therefore the combo box shouldn't be disabled!
1443  pBox->set_sensitive(false);
1444  }
1445 
1446  // Fill the FontBox, also the new list if necessary
1447  if ( pBox && bChanged )
1448  {
1449  if ( *ppFontList )
1450  pBox->Fill( *ppFontList );
1451  else
1452  pBox->Clear();
1453  }
1454  return bChanged;
1455 }
1456 
1457 SvxFontNameBox_Base::SvxFontNameBox_Base(std::unique_ptr<weld::ComboBox> xWidget,
1458  const Reference<XDispatchProvider>& rDispatchProvider,
1459  const Reference<XFrame>& rFrame,
1460  SvxFontNameToolBoxControl& rCtrl)
1461  : m_xListener(new comphelper::ConfigurationListener("/org.openoffice.Office.Common/Font/View"))
1462  , m_aWYSIWYG(m_xListener, "ShowFontBoxWYSIWYG", *this)
1463  , m_aHistory(m_xListener, "History", *this)
1464  , m_rCtrl(rCtrl)
1465  , m_xWidget(new FontNameBox(std::move(xWidget)))
1466  , pFontList(nullptr)
1467  , nFtCount(0)
1468  , bRelease(true)
1469  , m_xDispatchProvider(rDispatchProvider)
1470  , m_xFrame(rFrame)
1471  , mbCheckingUnknownFont(false)
1472 {
1473  EnableControls();
1474 
1475  m_xWidget->connect_changed(LINK(this, SvxFontNameBox_Base, SelectHdl));
1476  m_xWidget->connect_key_press(LINK(this, SvxFontNameBox_Base, KeyInputHdl));
1477  m_xWidget->connect_entry_activate(LINK(this, SvxFontNameBox_Base, ActivateHdl));
1478  m_xWidget->connect_focus_in(LINK(this, SvxFontNameBox_Base, FocusInHdl));
1479  m_xWidget->connect_focus_out(LINK(this, SvxFontNameBox_Base, FocusOutHdl));
1480  m_xWidget->connect_get_property_tree(LINK(this, SvxFontNameBox_Base, DumpAsPropertyTreeHdl));
1481 
1482  m_xWidget->set_entry_width_chars(COMBO_WIDTH_IN_CHARS + 5);
1483 }
1484 
1485 SvxFontNameBox_Impl::SvxFontNameBox_Impl(vcl::Window* pParent, const Reference<XDispatchProvider>& rDispatchProvider,
1486  const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl)
1487  : InterimItemWindow(pParent, "svx/ui/fontnamebox.ui", "FontNameBox")
1488  , SvxFontNameBox_Base(m_xBuilder->weld_combo_box("fontnamecombobox"), rDispatchProvider, rFrame, rCtrl)
1489 {
1490  set_id("fontnamecombobox");
1491  SetOptimalSize();
1492 }
1493 
1494 void SvxFontNameBox_Base::FillList()
1495 {
1496  if (!m_xWidget) // e.g. disposed
1497  return;
1498  // Save old Selection, set back in the end
1499  int nStartPos, nEndPos;
1500  m_xWidget->get_entry_selection_bounds(nStartPos, nEndPos);
1501 
1502  // Did Doc-Fontlist change?
1503  lcl_GetDocFontList(&pFontList, this);
1504 
1505  m_xWidget->select_entry_region(nStartPos, nEndPos);
1506 }
1507 
1508 void SvxFontNameBox_Base::CheckAndMarkUnknownFont()
1509 {
1510  if (mbCheckingUnknownFont) //tdf#117537 block rentry
1511  return;
1512  mbCheckingUnknownFont = true;
1513  OUString fontname = m_xWidget->get_active_text();
1514  lcl_GetDocFontList( &pFontList, this );
1515  // If the font is unknown, show it in italic.
1516  vcl::Font font = m_xWidget->get_entry_font();
1517  if( pFontList != nullptr && pFontList->IsAvailable( fontname ))
1518  {
1519  if( font.GetItalic() != ITALIC_NONE )
1520  {
1521  font.SetItalic( ITALIC_NONE );
1522  m_xWidget->set_entry_font(font);
1523  m_xWidget->set_tooltip_text(SvxResId(RID_SVXSTR_CHARFONTNAME));
1524  }
1525  }
1526  else
1527  {
1528  if( font.GetItalic() != ITALIC_NORMAL )
1529  {
1530  font.SetItalic( ITALIC_NORMAL );
1531  m_xWidget->set_entry_font(font);
1532  m_xWidget->set_tooltip_text(SvxResId(RID_SVXSTR_CHARFONTNAME_NOTAVAILABLE));
1533  }
1534  }
1535  mbCheckingUnknownFont = false;
1536 }
1537 
1538 void SvxFontNameBox_Base::Update( const css::awt::FontDescriptor* pFontDesc )
1539 {
1540  if ( pFontDesc )
1541  {
1542  aCurFont.SetFamilyName ( pFontDesc->Name );
1543  aCurFont.SetFamily ( FontFamily( pFontDesc->Family ) );
1544  aCurFont.SetStyleName ( pFontDesc->StyleName );
1545  aCurFont.SetPitch ( FontPitch( pFontDesc->Pitch ) );
1546  aCurFont.SetCharSet ( rtl_TextEncoding( pFontDesc->CharSet ) );
1547  }
1548  OUString aCurName = aCurFont.GetFamilyName();
1549  OUString aText = m_xWidget->get_active_text();
1550  if (aText != aCurName)
1551  set_active_or_entry_text(aCurName);
1552 }
1553 
1554 void SvxFontNameBox_Base::set_active_or_entry_text(const OUString& rText)
1555 {
1556  m_xWidget->set_active_or_entry_text(rText);
1557  CheckAndMarkUnknownFont();
1558 }
1559 
1560 IMPL_LINK_NOARG(SvxFontNameBox_Base, FocusInHdl, weld::Widget&, void)
1561 {
1562  FillList();
1563 }
1564 
1565 IMPL_LINK(SvxFontNameBox_Base, KeyInputHdl, const KeyEvent&, rKEvt, bool)
1566 {
1567  return DoKeyInput(rKEvt);
1568 }
1569 
1570 bool SvxFontNameBox_Base::DoKeyInput(const KeyEvent& rKEvt)
1571 {
1572  bool bHandled = false;
1573 
1574  sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
1575 
1576  switch (nCode)
1577  {
1578  case KEY_TAB:
1579  bRelease = false;
1580  Select(true);
1581  break;
1582 
1583  case KEY_ESCAPE:
1584  set_active_or_entry_text(m_xWidget->get_saved_value());
1585  if (!m_rCtrl.IsInSidebar())
1586  {
1587  ReleaseFocus_Impl();
1588  bHandled = true;
1589  }
1590  EndPreview();
1591  break;
1592  }
1593 
1594  return bHandled;
1595 }
1596 
1597 bool SvxFontNameBox_Impl::DoKeyInput(const KeyEvent& rKEvt)
1598 {
1599  return SvxFontNameBox_Base::DoKeyInput(rKEvt) || ChildKeyInput(rKEvt);
1600 }
1601 
1602 IMPL_LINK_NOARG(SvxFontNameBox_Base, FocusOutHdl, weld::Widget&, void)
1603 {
1604  if (!m_xWidget->has_focus()) // a combobox can be comprised of different subwidget so double-check if none of those has focus
1605  {
1606  set_active_or_entry_text(m_xWidget->get_saved_value());
1607  // send EndPreview
1608  EndPreview();
1609  }
1610 }
1611 
1612 void SvxFontNameBox_Impl::SetOptimalSize()
1613 {
1614  // set width in chars low so the size request will not be overridden
1615  m_xWidget->set_entry_width_chars(1);
1616  // tdf#132338 purely using this calculation to keep things their traditional width
1617  Size aSize(LogicToPixel(Size((COMBO_WIDTH_IN_CHARS +5) * 4, 0), MapMode(MapUnit::MapAppFont)));
1618  m_xWidget->set_size_request(aSize.Width(), -1);
1619 
1620  SetSizePixel(get_preferred_size());
1621 }
1622 
1623 void SvxFontNameBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1624 {
1625  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1626  (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
1627  {
1628  SetOptimalSize();
1629  }
1630  else if ( ( rDCEvt.GetType() == DataChangedEventType::FONTS ) ||
1631  ( rDCEvt.GetType() == DataChangedEventType::DISPLAY ) )
1632  {
1633  // The old font list in shell has likely been destroyed at this point, so we need to get
1634  // the new one before doing anything further.
1635  lcl_GetDocFontList( &pFontList, this );
1636  }
1637 }
1638 
1639 void SvxFontNameBox_Base::ReleaseFocus_Impl()
1640 {
1641  if ( !bRelease )
1642  {
1643  bRelease = true;
1644  return;
1645  }
1646  if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
1647  m_xFrame->getContainerWindow()->setFocus();
1648 }
1649 
1650 void SvxFontNameBox_Base::EnableControls()
1651 {
1652  bool bEnableMRU = m_aHistory.get();
1653  sal_uInt16 nEntries = bEnableMRU ? MAX_MRU_FONTNAME_ENTRIES : 0;
1654 
1655  bool bNewWYSIWYG = m_aWYSIWYG.get();
1656  bool bOldWYSIWYG = m_xWidget->IsWYSIWYGEnabled();
1657 
1658  if (m_xWidget->get_max_mru_count() != nEntries || bNewWYSIWYG != bOldWYSIWYG)
1659  {
1660  // refill in the next GetFocus-Handler
1661  pFontList = nullptr;
1662  Clear();
1663  m_xWidget->set_max_mru_count(nEntries);
1664  }
1665 
1666  if (bNewWYSIWYG != bOldWYSIWYG)
1667  m_xWidget->EnableWYSIWYG(bNewWYSIWYG);
1668 }
1669 
1670 IMPL_LINK(SvxFontNameBox_Base, SelectHdl, weld::ComboBox&, rCombo, void)
1671 {
1672  Select(rCombo.changed_by_direct_pick()); // only when picked from the list
1673 }
1674 
1675 IMPL_LINK_NOARG(SvxFontNameBox_Base, ActivateHdl, weld::ComboBox&, bool)
1676 {
1677  Select(true);
1678  return true;
1679 }
1680 
1681 void SvxFontNameBox_Base::Select(bool bNonTravelSelect)
1682 {
1683  Sequence< PropertyValue > aArgs( 1 );
1684  std::unique_ptr<SvxFontItem> pFontItem;
1685  if ( pFontList )
1686  {
1687  FontMetric aFontMetric( pFontList->Get(m_xWidget->get_active_text(),
1688  aCurFont.GetWeight(),
1689  aCurFont.GetItalic() ) );
1690  aCurFont = aFontMetric;
1691 
1692  pFontItem.reset( new SvxFontItem( aFontMetric.GetFamilyType(),
1693  aFontMetric.GetFamilyName(),
1694  aFontMetric.GetStyleName(),
1695  aFontMetric.GetPitch(),
1696  aFontMetric.GetCharSet(),
1697  SID_ATTR_CHAR_FONT ) );
1698 
1699  Any a;
1700  pFontItem->QueryValue( a );
1701  aArgs[0].Value = a;
1702  }
1703 
1704  if (bNonTravelSelect)
1705  {
1706  CheckAndMarkUnknownFont();
1707  // #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
1708  // This instance may be deleted in the meantime (i.e. when a dialog is opened
1709  // while in Dispatch()), accessing members will crash in this case.
1710  ReleaseFocus_Impl();
1711  EndPreview();
1712  if (pFontItem)
1713  {
1714  aArgs[0].Name = "CharFontName";
1715  SfxToolBoxControl::Dispatch( m_xDispatchProvider,
1716  ".uno:CharFontName",
1717  aArgs );
1718  }
1719  }
1720  else
1721  {
1722  if (pFontItem)
1723  {
1724  aArgs[0].Name = "CharPreviewFontName";
1725  SfxToolBoxControl::Dispatch( m_xDispatchProvider,
1726  ".uno:CharPreviewFontName",
1727  aArgs );
1728  }
1729  }
1730 }
1731 
1732 IMPL_LINK(SvxFontNameBox_Base, DumpAsPropertyTreeHdl, tools::JsonWriter&, rJsonWriter, void)
1733 {
1734  {
1735  auto entriesNode = rJsonWriter.startNode("entries");
1736  for (int i = 0, nEntryCount = m_xWidget->get_count(); i < nEntryCount; ++i)
1737  {
1738  auto entryNode = rJsonWriter.startNode("");
1739  rJsonWriter.put("", m_xWidget->get_text(i));
1740  }
1741  }
1742 
1743  int nSelectedEntry = m_xWidget->get_active();
1744  rJsonWriter.put("selectedCount", static_cast<sal_Int32>(nSelectedEntry == -1 ? 0 : 1));
1745 
1746  {
1747  auto selectedNode = rJsonWriter.startNode("selectedEntries");
1748  if (nSelectedEntry != -1)
1749  {
1750  auto entryNode = rJsonWriter.startNode("");
1751  rJsonWriter.put("", m_xWidget->get_text(nSelectedEntry));
1752  }
1753  }
1754 
1755  rJsonWriter.put("command", ".uno:CharFontName");
1756 }
1757 
1758 ColorWindow::ColorWindow(const OUString& rCommand,
1759  std::shared_ptr<PaletteManager> const & rPaletteManager,
1760  ColorStatus& rColorStatus,
1761  sal_uInt16 nSlotId,
1762  const Reference< XFrame >& rFrame,
1763  const MenuOrToolMenuButton& rMenuButton,
1764  TopLevelParentFunction const& rTopLevelParentFunction,
1765  ColorSelectFunction const & rColorSelectFunction)
1766  : WeldToolbarPopup(rFrame, rMenuButton.get_widget(), "svx/ui/colorwindow.ui", "palette_popup_window")
1767  , theSlotId(nSlotId)
1768  , maCommand(rCommand)
1769  , maMenuButton(rMenuButton)
1770  , mxPaletteManager(rPaletteManager)
1771  , mrColorStatus(rColorStatus)
1772  , maTopLevelParentFunction(rTopLevelParentFunction)
1773  , maColorSelectFunction(rColorSelectFunction)
1774  , mxColorSet(new SvxColorValueSet(m_xBuilder->weld_scrolled_window("colorsetwin", true)))
1775  , mxRecentColorSet(new SvxColorValueSet(nullptr))
1776  , mxPaletteListBox(m_xBuilder->weld_combo_box("palette_listbox"))
1777  , mxButtonAutoColor(m_xBuilder->weld_button("auto_color_button"))
1778  , mxButtonNoneColor(m_xBuilder->weld_button("none_color_button"))
1779  , mxButtonPicker(m_xBuilder->weld_button("color_picker_button"))
1780  , mxAutomaticSeparator(m_xBuilder->weld_widget("separator4"))
1781  , mxColorSetWin(new weld::CustomWeld(*m_xBuilder, "colorset", *mxColorSet))
1782  , mxRecentColorSetWin(new weld::CustomWeld(*m_xBuilder, "recent_colorset", *mxRecentColorSet))
1783  , mpDefaultButton(nullptr)
1784 {
1785  mxColorSet->SetStyle( WinBits(WB_FLATVALUESET | WB_ITEMBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT | WB_TABSTOP) );
1786  mxRecentColorSet->SetStyle( WinBits(WB_FLATVALUESET | WB_ITEMBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT | WB_TABSTOP) );
1787 
1788  switch ( theSlotId )
1789  {
1790  case SID_ATTR_CHAR_COLOR_BACKGROUND:
1791  case SID_BACKGROUND_COLOR:
1792  case SID_ATTR_CHAR_BACK_COLOR:
1793  case SID_TABLE_CELL_BACKGROUND_COLOR:
1794  {
1795  mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_NOFILL ) );
1796  break;
1797  }
1798  case SID_AUTHOR_COLOR:
1799  {
1800  mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_BY_AUTHOR ) );
1801  break;
1802  }
1803  case SID_BMPMASK_COLOR:
1804  {
1805  mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_TRANSPARENT ) );
1806  break;
1807  }
1808  case SID_ATTR_CHAR_COLOR:
1809  case SID_ATTR_CHAR_COLOR2:
1810  case SID_EXTRUSION_3D_COLOR:
1811  {
1812  mxButtonAutoColor->set_label(EditResId(RID_SVXSTR_AUTOMATIC));
1813  break;
1814  }
1815  case SID_FM_CTL_PROPERTIES:
1816  {
1817  mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_DEFAULT ) );
1818  break;
1819  }
1820  default:
1821  {
1822  mxButtonAutoColor->hide();
1823  mxAutomaticSeparator->hide();
1824  break;
1825  }
1826  }
1827 
1828  mxPaletteListBox->connect_changed(LINK(this, ColorWindow, SelectPaletteHdl));
1829  std::vector<OUString> aPaletteList = mxPaletteManager->GetPaletteList();
1830  mxPaletteListBox->freeze();
1831  for (const auto& rPalette : aPaletteList)
1832  mxPaletteListBox->append_text(rPalette);
1833  mxPaletteListBox->thaw();
1834  OUString aPaletteName( officecfg::Office::Common::UserColors::PaletteName::get() );
1835  mxPaletteListBox->set_active_text(aPaletteName);
1836  const int nSelectedEntry(mxPaletteListBox->get_active());
1837  if (nSelectedEntry != -1)
1838  mxPaletteManager->SetPalette(nSelectedEntry);
1839 
1840  mxButtonAutoColor->connect_clicked(LINK(this, ColorWindow, AutoColorClickHdl));
1841  mxButtonNoneColor->connect_clicked(LINK(this, ColorWindow, AutoColorClickHdl));
1842  mxButtonPicker->connect_clicked(LINK(this, ColorWindow, OpenPickerClickHdl));
1843 
1844  mxColorSet->SetSelectHdl(LINK( this, ColorWindow, SelectHdl));
1845  mxRecentColorSet->SetSelectHdl(LINK( this, ColorWindow, SelectHdl));
1846  m_xTopLevel->set_help_id(HID_POPUP_COLOR);
1847  mxColorSet->SetHelpId(HID_POPUP_COLOR_CTRL);
1848 
1849  mxPaletteManager->ReloadColorSet(*mxColorSet);
1850  const sal_uInt32 nMaxItems(SvxColorValueSet::getMaxRowCount() * SvxColorValueSet::getColumnCount());
1851  Size aSize = mxColorSet->layoutAllVisible(nMaxItems);
1852  mxColorSet->set_size_request(aSize.Width(), aSize.Height());
1853 
1854  mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
1855  aSize = mxRecentColorSet->layoutAllVisible(mxPaletteManager->GetRecentColorCount());
1856  mxRecentColorSet->set_size_request(aSize.Width(), aSize.Height());
1857 
1858  AddStatusListener( ".uno:ColorTableState" );
1859  AddStatusListener( maCommand );
1860  if ( maCommand == ".uno:FrameLineColor" )
1861  {
1862  AddStatusListener( ".uno:BorderTLBR" );
1863  AddStatusListener( ".uno:BorderBLTR" );
1864  }
1865 }
1866 
1867 void ColorWindow::GrabFocus()
1868 {
1869  if (mxColorSet->IsNoSelection() && mpDefaultButton)
1870  mpDefaultButton->grab_focus();
1871  else
1872  mxColorSet->GrabFocus();
1873 }
1874 
1875 void ColorWindow::ShowNoneButton()
1876 {
1877  mxButtonNoneColor->show();
1878 }
1879 
1880 ColorWindow::~ColorWindow()
1881 {
1882 }
1883 
1884 NamedColor ColorWindow::GetSelectEntryColor(ValueSet const * pColorSet)
1885 {
1886  Color aColor = pColorSet->GetItemColor(pColorSet->GetSelectedItemId());
1887  OUString sColorName = pColorSet->GetItemText(pColorSet->GetSelectedItemId());
1888  return std::make_pair(aColor, sColorName);
1889 }
1890 
1891 namespace
1892 {
1893  NamedColor GetAutoColor(sal_uInt16 nSlotId)
1894  {
1895  Color aColor;
1896  OUString sColorName;
1897  switch (nSlotId)
1898  {
1899  case SID_ATTR_CHAR_COLOR_BACKGROUND:
1900  case SID_BACKGROUND_COLOR:
1901  case SID_ATTR_CHAR_BACK_COLOR:
1902  case SID_TABLE_CELL_BACKGROUND_COLOR:
1903  aColor = COL_TRANSPARENT;
1904  sColorName = SvxResId(RID_SVXSTR_NOFILL);
1905  break;
1906  case SID_AUTHOR_COLOR:
1907  aColor = COL_TRANSPARENT;
1908  sColorName = SvxResId(RID_SVXSTR_BY_AUTHOR);
1909  break;
1910  case SID_BMPMASK_COLOR:
1911  aColor = COL_TRANSPARENT;
1912  sColorName = SvxResId(RID_SVXSTR_TRANSPARENT);
1913  break;
1914  case SID_FM_CTL_PROPERTIES:
1915  aColor = COL_TRANSPARENT;
1916  sColorName = SvxResId(RID_SVXSTR_DEFAULT);
1917  break;
1918  case SID_ATTR_CHAR_COLOR:
1919  case SID_ATTR_CHAR_COLOR2:
1920  case SID_EXTRUSION_3D_COLOR:
1921  default:
1922  aColor = COL_AUTO;
1923  sColorName = EditResId(RID_SVXSTR_AUTOMATIC);
1924  break;
1925  }
1926 
1927  return std::make_pair(aColor, sColorName);
1928  }
1929 
1930  NamedColor GetNoneColor()
1931  {
1932  return std::make_pair(COL_NONE_COLOR, comphelper::LibreOfficeKit::isActive() ? SvxResId(RID_SVXSTR_INVISIBLE)
1933  : SvxResId(RID_SVXSTR_NONE));
1934  }
1935 }
1936 
1937 NamedColor ColorWindow::GetSelectEntryColor() const
1938 {
1939  if (!mxColorSet->IsNoSelection())
1940  return GetSelectEntryColor(mxColorSet.get());
1941  if (!mxRecentColorSet->IsNoSelection())
1942  return GetSelectEntryColor(mxRecentColorSet.get());
1943  if (mxButtonNoneColor.get() == mpDefaultButton)
1944  return GetNoneColor();
1945  return GetAutoColor();
1946 }
1947 
1948 IMPL_LINK(ColorWindow, SelectHdl, ValueSet*, pColorSet, void)
1949 {
1950  NamedColor aNamedColor = GetSelectEntryColor(pColorSet);
1951 
1952  if (pColorSet != mxRecentColorSet.get())
1953  {
1954  mxPaletteManager->AddRecentColor(aNamedColor.first, aNamedColor.second);
1955  if (!maMenuButton.get_active())
1956  mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
1957  }
1958 
1959  maSelectedLink.Call(aNamedColor);
1960 
1961  // deliberate take a copy here in case maMenuButton.set_inactive
1962  // triggers a callback that destroys ourself
1963  ColorSelectFunction aColorSelectFunction(maColorSelectFunction);
1964  OUString sCommand(maCommand);
1965 
1966  maMenuButton.set_inactive();
1967 
1968  aColorSelectFunction(sCommand, aNamedColor);
1969 }
1970 
1971 IMPL_LINK_NOARG(ColorWindow, SelectPaletteHdl, weld::ComboBox&, void)
1972 {
1973  int nPos = mxPaletteListBox->get_active();
1974  mxPaletteManager->SetPalette( nPos );
1975  mxPaletteManager->ReloadColorSet(*mxColorSet);
1976  mxColorSet->layoutToGivenHeight(mxColorSet->GetOutputSizePixel().Height(), mxPaletteManager->GetColorCount());
1977 }
1978 
1979 NamedColor ColorWindow::GetAutoColor() const
1980 {
1981  return ::GetAutoColor(theSlotId);
1982 }
1983 
1984 IMPL_LINK(ColorWindow, AutoColorClickHdl, weld::Button&, rButton, void)
1985 {
1986  NamedColor aNamedColor = &rButton == mxButtonAutoColor.get() ? GetAutoColor() : GetNoneColor();
1987 
1988  mxColorSet->SetNoSelection();
1989  mxRecentColorSet->SetNoSelection();
1990  mpDefaultButton = &rButton;
1991 
1992  maSelectedLink.Call(aNamedColor);
1993 
1994  // deliberate take a copy here in case maMenuButton.set_inactive
1995  // triggers a callback that destroys ourself
1996  ColorSelectFunction aColorSelectFunction(maColorSelectFunction);
1997  OUString sCommand(maCommand);
1998 
1999  maMenuButton.set_inactive();
2000 
2001  aColorSelectFunction(sCommand, aNamedColor);
2002 }
2003 
2004 IMPL_LINK_NOARG(ColorWindow, OpenPickerClickHdl, weld::Button&, void)
2005 {
2006  // copy before set_inactive
2007  auto nColor = GetSelectEntryColor().first;
2008  auto pParentWindow = maTopLevelParentFunction();
2009  OUString sCommand = maCommand;
2010  std::shared_ptr<PaletteManager> xPaletteManager(mxPaletteManager);
2011 
2012  maMenuButton.set_inactive();
2013 
2014  xPaletteManager->PopupColorPicker(pParentWindow, sCommand, nColor);
2015 }
2016 
2017 void ColorWindow::SetNoSelection()
2018 {
2019  mxColorSet->SetNoSelection();
2020  mxRecentColorSet->SetNoSelection();
2021  mpDefaultButton = nullptr;
2022 }
2023 
2024 bool ColorWindow::IsNoSelection() const
2025 {
2026  if (!mxColorSet->IsNoSelection())
2027  return false;
2028  if (!mxRecentColorSet->IsNoSelection())
2029  return false;
2030  return !mxButtonAutoColor->get_visible() && !mxButtonNoneColor->get_visible();
2031 }
2032 
2033 void ColorWindow::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2034 {
2035  if (rEvent.FeatureURL.Complete == ".uno:ColorTableState")
2036  {
2037  if (rEvent.IsEnabled && mxPaletteManager->GetPalette() == 0)
2038  {
2039  mxPaletteManager->ReloadColorSet(*mxColorSet);
2040  mxColorSet->layoutToGivenHeight(mxColorSet->GetOutputSizePixel().Height(), mxPaletteManager->GetColorCount());
2041  }
2042  }
2043  else
2044  {
2045  mrColorStatus.statusChanged(rEvent);
2046  SelectEntry(mrColorStatus.GetColor());
2047  }
2048 }
2049 
2050 bool ColorWindow::SelectValueSetEntry(SvxColorValueSet* pColorSet, const Color& rColor)
2051 {
2052  for (size_t i = 1; i <= pColorSet->GetItemCount(); ++i)
2053  {
2054  if (rColor == pColorSet->GetItemColor(i))
2055  {
2056  pColorSet->SelectItem(i);
2057  return true;
2058  }
2059  }
2060  return false;
2061 }
2062 
2063 void ColorWindow::SelectEntry(const NamedColor& rNamedColor)
2064 {
2065  SetNoSelection();
2066 
2067  const Color &rColor = rNamedColor.first;
2068 
2069  if (mxButtonAutoColor->get_visible() && (rColor == COL_TRANSPARENT || rColor == COL_AUTO))
2070  {
2071  mpDefaultButton = mxButtonAutoColor.get();
2072  return;
2073  }
2074 
2075  if (mxButtonNoneColor->get_visible() && rColor == COL_NONE_COLOR)
2076  {
2077  mpDefaultButton = mxButtonNoneColor.get();
2078  return;
2079  }
2080 
2081  // try current palette
2082  bool bFoundColor = SelectValueSetEntry(mxColorSet.get(), rColor);
2083  // try recently used
2084  if (!bFoundColor)
2085  bFoundColor = SelectValueSetEntry(mxRecentColorSet.get(), rColor);
2086  // if it's not there, add it there now to the end of the recently used
2087  // so its available somewhere handy, but not without trashing the
2088  // whole recently used
2089  if (!bFoundColor)
2090  {
2091  const OUString& rColorName = rNamedColor.second;
2092  mxPaletteManager->AddRecentColor(rColor, rColorName, false);
2093  mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
2094  SelectValueSetEntry(mxRecentColorSet.get(), rColor);
2095  }
2096 }
2097 
2098 void ColorWindow::SelectEntry(const Color& rColor)
2099 {
2100  OUString sColorName = "#" + rColor.AsRGBHexString().toAsciiUpperCase();
2101  ColorWindow::SelectEntry(std::make_pair(rColor, sColorName));
2102 }
2103 
2104 ColorStatus::ColorStatus() :
2105  maColor( COL_TRANSPARENT ),
2106  maTLBRColor( COL_TRANSPARENT ),
2107  maBLTRColor( COL_TRANSPARENT )
2108 {
2109 }
2110 
2111 ColorStatus::~ColorStatus()
2112 {
2113 }
2114 
2115 void ColorStatus::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2116 {
2117  Color aColor( COL_TRANSPARENT );
2118  css::table::BorderLine2 aTable;
2119 
2120  if ( rEvent.State >>= aTable )
2121  {
2122  SvxBorderLine aLine;
2123  SvxBoxItem::LineToSvxLine( aTable, aLine, false );
2124  if ( !aLine.isEmpty() )
2125  aColor = aLine.GetColor();
2126  }
2127  else
2128  rEvent.State >>= aColor;
2129 
2130  if ( rEvent.FeatureURL.Path == "BorderTLBR" )
2131  maTLBRColor = aColor;
2132  else if ( rEvent.FeatureURL.Path == "BorderBLTR" )
2133  maBLTRColor = aColor;
2134  else
2135  maColor = aColor;
2136 }
2137 
2138 Color ColorStatus::GetColor()
2139 {
2140  Color aColor( maColor );
2141 
2142  if ( maTLBRColor != COL_TRANSPARENT )
2143  {
2144  if ( aColor != maTLBRColor && aColor != COL_TRANSPARENT )
2145  return COL_TRANSPARENT;
2146  aColor = maTLBRColor;
2147  }
2148 
2149  if ( maBLTRColor != COL_TRANSPARENT )
2150  {
2151  if ( aColor != maBLTRColor && aColor != COL_TRANSPARENT )
2152  return COL_TRANSPARENT;
2153  return maBLTRColor;
2154  }
2155 
2156  return aColor;
2157 }
2158 
2159 
2160 SvxFrameWindow_Impl::SvxFrameWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent)
2161  : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/floatingframeborder.ui", "FloatingFrameBorder")
2162  , mxControl(pControl)
2163  , mxFrameSet(new SvxFrmValueSet_Impl)
2164  , mxFrameSetWin(new weld::CustomWeld(*m_xBuilder, "valueset", *mxFrameSet))
2165  , bParagraphMode(false)
2166 {
2167  mxFrameSet->SetStyle(WB_ITEMBORDER | WB_DOUBLEBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT);
2168  AddStatusListener(".uno:BorderReducedMode");
2169  InitImageList();
2170 
2171  /*
2172  * 1 2 3 4
2173  * -------------------------------------
2174  * NONE LEFT RIGHT LEFTRIGHT
2175  * TOP BOTTOM TOPBOTTOM OUTER
2176  * -------------------------------------
2177  * HOR HORINNER VERINNER ALL <- can be switched of via bParagraphMode
2178  */
2179 
2180  sal_uInt16 i = 0;
2181 
2182  for ( i=1; i<9; i++ )
2183  mxFrameSet->InsertItem(i, Image(aImgVec[i-1].first), aImgVec[i-1].second);
2184 
2185  //bParagraphMode should have been set in StateChanged
2186  if ( !bParagraphMode )
2187  for ( i = 9; i < 13; i++ )
2188  mxFrameSet->InsertItem(i, Image(aImgVec[i-1].first), aImgVec[i-1].second);
2189 
2190  mxFrameSet->SetColCount( 4 );
2191  mxFrameSet->SetSelectHdl( LINK( this, SvxFrameWindow_Impl, SelectHdl ) );
2192  CalcSizeValueSet();
2193 
2194  mxFrameSet->SetHelpId( HID_POPUP_FRAME );
2195  mxFrameSet->SetAccessibleName( SvxResId(RID_SVXSTR_FRAME) );
2196 }
2197 
2198 namespace {
2199 
2200 enum class FrmValidFlags {
2201  NONE = 0x00,
2202  Left = 0x01,
2203  Right = 0x02,
2204  Top = 0x04,
2205  Bottom = 0x08,
2206  HInner = 0x10,
2207  VInner = 0x20,
2208  AllMask = 0x3f,
2209 };
2210 
2211 }
2212 
2213 namespace o3tl {
2214  template<> struct typed_flags<FrmValidFlags> : is_typed_flags<FrmValidFlags, 0x3f> {};
2215 }
2216 
2217 // By default unset lines remain unchanged.
2218 // Via Shift unset lines are reset
2219 
2220 IMPL_LINK_NOARG(SvxFrameWindow_Impl, SelectHdl, ValueSet*, void)
2221 {
2222  SvxBoxItem aBorderOuter( SID_ATTR_BORDER_OUTER );
2223  SvxBoxInfoItem aBorderInner( SID_ATTR_BORDER_INNER );
2224  SvxBorderLine theDefLine;
2225  SvxBorderLine *pLeft = nullptr,
2226  *pRight = nullptr,
2227  *pTop = nullptr,
2228  *pBottom = nullptr;
2229  sal_uInt16 nSel = mxFrameSet->GetSelectedItemId();
2230  sal_uInt16 nModifier = mxFrameSet->GetModifier();
2231  FrmValidFlags nValidFlags = FrmValidFlags::NONE;
2232 
2233  theDefLine.GuessLinesWidths(theDefLine.GetBorderLineStyle(),
2234  DEF_LINE_WIDTH_0);
2235  switch ( nSel )
2236  {
2237  case 1: nValidFlags |= FrmValidFlags::AllMask;
2238  break; // NONE
2239  case 2: pLeft = &theDefLine;
2240  nValidFlags |= FrmValidFlags::Left;
2241  break; // LEFT
2242  case 3: pRight = &theDefLine;
2243  nValidFlags |= FrmValidFlags::Right;
2244  break; // RIGHT
2245  case 4: pLeft = pRight = &theDefLine;
2246  nValidFlags |= FrmValidFlags::Right|FrmValidFlags::Left;
2247  break; // LEFTRIGHT
2248  case 5: pTop = &theDefLine;
2249  nValidFlags |= FrmValidFlags::Top;
2250  break; // TOP
2251  case 6: pBottom = &theDefLine;
2252  nValidFlags |= FrmValidFlags::Bottom;
2253  break; // BOTTOM
2254  case 7: pTop = pBottom = &theDefLine;
2255  nValidFlags |= FrmValidFlags::Bottom|FrmValidFlags::Top;
2256  break; // TOPBOTTOM
2257  case 8: pLeft = pRight = pTop = pBottom = &theDefLine;
2258  nValidFlags |= FrmValidFlags::Left | FrmValidFlags::Right | FrmValidFlags::Top | FrmValidFlags::Bottom;
2259  break; // OUTER
2260 
2261  // Inner Table:
2262  case 9: // HOR
2263  pTop = pBottom = &theDefLine;
2264  aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
2265  aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::VERT );
2266  nValidFlags |= FrmValidFlags::HInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
2267  break;
2268 
2269  case 10: // HORINNER
2270  pLeft = pRight = pTop = pBottom = &theDefLine;
2271  aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
2272  aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::VERT );
2273  nValidFlags |= FrmValidFlags::Right|FrmValidFlags::Left|FrmValidFlags::HInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
2274  break;
2275 
2276  case 11: // VERINNER
2277  pLeft = pRight = pTop = pBottom = &theDefLine;
2278  aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::HORI );
2279  aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::VERT );
2280  nValidFlags |= FrmValidFlags::Right|FrmValidFlags::Left|FrmValidFlags::VInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
2281  break;
2282 
2283  case 12: // ALL
2284  pLeft = pRight = pTop = pBottom = &theDefLine;
2285  aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
2286  aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::VERT );
2287  nValidFlags |= FrmValidFlags::AllMask;
2288  break;
2289 
2290  default:
2291  break;
2292  }
2293  aBorderOuter.SetLine( pLeft, SvxBoxItemLine::LEFT );
2294  aBorderOuter.SetLine( pRight, SvxBoxItemLine::RIGHT );
2295  aBorderOuter.SetLine( pTop, SvxBoxItemLine::TOP );
2296  aBorderOuter.SetLine( pBottom, SvxBoxItemLine::BOTTOM );
2297 
2298  if(nModifier == KEY_SHIFT)
2299  nValidFlags |= FrmValidFlags::AllMask;
2300  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::TOP, bool(nValidFlags&FrmValidFlags::Top ));
2301  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::BOTTOM, bool(nValidFlags&FrmValidFlags::Bottom ));
2302  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::LEFT, bool(nValidFlags&FrmValidFlags::Left));
2303  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::RIGHT, bool(nValidFlags&FrmValidFlags::Right ));
2304  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::HORI, bool(nValidFlags&FrmValidFlags::HInner ));
2305  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::VERT, bool(nValidFlags&FrmValidFlags::VInner));
2306  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::DISTANCE );
2307  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::DISABLE, false );
2308 
2309  Any a;
2310  Sequence< PropertyValue > aArgs( 2 );
2311  aArgs[0].Name = "OuterBorder";
2312  aBorderOuter.QueryValue( a );
2313  aArgs[0].Value = a;
2314  aArgs[1].Name = "InnerBorder";
2315  aBorderInner.QueryValue( a );
2316  aArgs[1].Value = a;
2317 
2318  if (mxFrameSet)
2319  {
2320  /* #i33380# Moved the following line above the Dispatch() call.
2321  This instance may be deleted in the meantime (i.e. when a dialog is opened
2322  while in Dispatch()), accessing members will crash in this case. */
2323  mxFrameSet->SetNoSelection();
2324  }
2325 
2326  mxControl->dispatchCommand( ".uno:SetBorderStyle", aArgs );
2327 
2328  mxControl->EndPopupMode();
2329 }
2330 
2331 void SvxFrameWindow_Impl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2332 {
2333  if ( rEvent.FeatureURL.Complete != ".uno:BorderReducedMode" )
2334  return;
2335 
2336  bool bValue;
2337  if ( !(rEvent.State >>= bValue) )
2338  return;
2339 
2340  bParagraphMode = bValue;
2341  //initial calls mustn't insert or remove elements
2342  if(!mxFrameSet->GetItemCount())
2343  return;
2344 
2345  bool bTableMode = ( mxFrameSet->GetItemCount() == 12 );
2346  bool bResize = false;
2347 
2348  if ( bTableMode && bParagraphMode )
2349  {
2350  for ( sal_uInt16 i = 9; i < 13; i++ )
2351  mxFrameSet->RemoveItem(i);
2352  bResize = true;
2353  }
2354  else if ( !bTableMode && !bParagraphMode )
2355  {
2356  for ( sal_uInt16 i = 9; i < 13; i++ )
2357  mxFrameSet->InsertItem(i, Image(aImgVec[i-1].first), aImgVec[i-1].second);
2358  bResize = true;
2359  }
2360 
2361  if ( bResize )
2362  {
2363  CalcSizeValueSet();
2364  }
2365 }
2366 
2367 void SvxFrameWindow_Impl::CalcSizeValueSet()
2368 {
2369  weld::DrawingArea* pDrawingArea = mxFrameSet->GetDrawingArea();
2370  const OutputDevice& rDevice = pDrawingArea->get_ref_device();
2371  Size aItemSize( 20 * rDevice.GetDPIScaleFactor(), 20 * rDevice.GetDPIScaleFactor() );
2372  Size aSize = mxFrameSet->CalcWindowSizePixel( aItemSize );
2373  pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
2374  mxFrameSet->SetOutputSizePixel(aSize);
2375 }
2376 
2377 void SvxFrameWindow_Impl::InitImageList()
2378 {
2379  aImgVec = {
2380  {BitmapEx(RID_SVXBMP_FRAME1), SvxResId(RID_SVXSTR_TABLE_PRESET_NONE)},
2381  {BitmapEx(RID_SVXBMP_FRAME2), SvxResId(RID_SVXSTR_PARA_PRESET_ONLYLEFT)},
2382  {BitmapEx(RID_SVXBMP_FRAME3), SvxResId(RID_SVXSTR_PARA_PRESET_ONLYRIGHT)},
2383  {BitmapEx(RID_SVXBMP_FRAME4), SvxResId(RID_SVXSTR_PARA_PRESET_LEFTRIGHT)},
2384  {BitmapEx(RID_SVXBMP_FRAME5), SvxResId(RID_SVXSTR_PARA_PRESET_ONLYTOP)},
2385  {BitmapEx(RID_SVXBMP_FRAME6), SvxResId(RID_SVXSTR_PARA_PRESET_ONLYTBOTTOM)},
2386  {BitmapEx(RID_SVXBMP_FRAME7), SvxResId(RID_SVXSTR_PARA_PRESET_TOPBOTTOM)},
2387  {BitmapEx(RID_SVXBMP_FRAME8), SvxResId(RID_SVXSTR_TABLE_PRESET_ONLYOUTER)},
2388  {BitmapEx(RID_SVXBMP_FRAME9), SvxResId(RID_SVXSTR_PARA_PRESET_TOPBOTTOMHORI)},
2389  {BitmapEx(RID_SVXBMP_FRAME10), SvxResId(RID_SVXSTR_TABLE_PRESET_OUTERHORI)},
2390  {BitmapEx(RID_SVXBMP_FRAME11), SvxResId(RID_SVXSTR_TABLE_PRESET_OUTERVERI)},
2391  {BitmapEx(RID_SVXBMP_FRAME12), SvxResId(RID_SVXSTR_TABLE_PRESET_OUTERALL)}
2392  };
2393 }
2394 
2395 static Color lcl_mediumColor( Color aMain, Color /*aDefault*/ )
2396 {
2397  return SvxBorderLine::threeDMediumColor( aMain );
2398 }
2399 
2400 SvxLineWindow_Impl::SvxLineWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent)
2401  : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/floatingframeborder.ui", "FloatingFrameBorder")
2402  , m_xControl(pControl)
2403  , m_xLineStyleLb(new LineListBox)
2404  , m_xLineStyleLbWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xLineStyleLb))
2405  , m_bIsWriter(false)
2406 {
2407  try
2408  {
2409  Reference< lang::XServiceInfo > xServices(m_xFrame->getController()->getModel(), UNO_QUERY_THROW);
2410  m_bIsWriter = xServices->supportsService("com.sun.star.text.TextDocument");
2411  }
2412  catch(const uno::Exception& )
2413  {
2414  }
2415 
2416  m_xLineStyleLb->SetStyle( WinBits(WB_FLATVALUESET | WB_ITEMBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT | WB_TABSTOP) );
2417 
2418  m_xLineStyleLb->SetSourceUnit( FieldUnit::TWIP );
2419  m_xLineStyleLb->SetNone( comphelper::LibreOfficeKit::isActive() ? SvxResId(RID_SVXSTR_INVISIBLE)
2420  :SvxResId(RID_SVXSTR_NONE) );
2421 
2422  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::SOLID ), SvxBorderLineStyle::SOLID );
2423  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DOTTED ), SvxBorderLineStyle::DOTTED );
2424  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DASHED ), SvxBorderLineStyle::DASHED );
2425 
2426  // Double lines
2427  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DOUBLE ), SvxBorderLineStyle::DOUBLE );
2428  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_SMALLGAP ), SvxBorderLineStyle::THINTHICK_SMALLGAP, 20 );
2429  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_MEDIUMGAP ), SvxBorderLineStyle::THINTHICK_MEDIUMGAP );
2430  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_LARGEGAP ), SvxBorderLineStyle::THINTHICK_LARGEGAP );
2431  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_SMALLGAP ), SvxBorderLineStyle::THICKTHIN_SMALLGAP, 20 );
2432  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_MEDIUMGAP ), SvxBorderLineStyle::THICKTHIN_MEDIUMGAP );
2433  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_LARGEGAP ), SvxBorderLineStyle::THICKTHIN_LARGEGAP );
2434 
2435  // Engraved / Embossed
2436  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::EMBOSSED ), SvxBorderLineStyle::EMBOSSED, 15,
2437  &SvxBorderLine::threeDLightColor, &SvxBorderLine::threeDDarkColor,
2438  &lcl_mediumColor );
2439  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::ENGRAVED ), SvxBorderLineStyle::ENGRAVED, 15,
2440  &SvxBorderLine::threeDDarkColor, &SvxBorderLine::threeDLightColor,
2441  &lcl_mediumColor );
2442 
2443  // Inset / Outset
2444  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::OUTSET ), SvxBorderLineStyle::OUTSET, 10,
2445  &SvxBorderLine::lightColor, &SvxBorderLine::darkColor );
2446  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::INSET ), SvxBorderLineStyle::INSET, 10,
2447  &SvxBorderLine::darkColor, &SvxBorderLine::lightColor );
2448  Size aSize = m_xLineStyleLb->SetWidth( 20 ); // 1pt by default
2449 
2450  m_xLineStyleLb->SetSelectHdl( LINK( this, SvxLineWindow_Impl, SelectHdl ) );
2451 
2452  m_xContainer->set_help_id(HID_POPUP_LINE);
2453 
2454  aSize.AdjustWidth(6);
2455  aSize.AdjustHeight(6);
2456  aSize = m_xLineStyleLb->CalcWindowSizePixel(aSize);
2457  m_xLineStyleLb->GetDrawingArea()->set_size_request(aSize.Width(), aSize.Height());
2458  m_xLineStyleLb->SetOutputSizePixel(aSize);
2459 }
2460 
2461 IMPL_LINK_NOARG(SvxLineWindow_Impl, SelectHdl, ValueSet*, void)
2462 {
2463  SvxLineItem aLineItem( SID_FRAME_LINESTYLE );
2464  SvxBorderLineStyle nStyle = m_xLineStyleLb->GetSelectEntryStyle();
2465 
2466  if ( m_xLineStyleLb->GetSelectItemPos( ) > 0 )
2467  {
2468  SvxBorderLine aTmp;
2469  aTmp.SetBorderLineStyle( nStyle );
2470  aTmp.SetWidth( 20 ); // TODO Make it depend on a width field
2471  aLineItem.SetLine( &aTmp );
2472  }
2473  else
2474  aLineItem.SetLine( nullptr );
2475 
2476  Any a;
2477  Sequence< PropertyValue > aArgs( 1 );
2478  aArgs[0].Name = "LineStyle";
2479  aLineItem.QueryValue( a, m_bIsWriter ? CONVERT_TWIPS : 0 );
2480  aArgs[0].Value = a;
2481 
2482  m_xControl->dispatchCommand( ".uno:LineStyle", aArgs );
2483 
2484  m_xControl->EndPopupMode();
2485 }
2486 
2487 SfxStyleControllerItem_Impl::SfxStyleControllerItem_Impl(
2488  const Reference< XDispatchProvider >& rDispatchProvider,
2489  sal_uInt16 nSlotId, // Family-ID
2490  const OUString& rCommand, // .uno: command bound to this item
2491  SvxStyleToolBoxControl& rTbxCtl ) // controller instance, which the item is assigned to.
2492  : SfxStatusListener( rDispatchProvider, nSlotId, rCommand ),
2493  rControl( rTbxCtl )
2494 {
2495 }
2496 
2497 void SfxStyleControllerItem_Impl::StateChanged(
2498  SfxItemState eState, const SfxPoolItem* pState )
2499 {
2500  switch ( GetId() )
2501  {
2502  case SID_STYLE_FAMILY1:
2503  case SID_STYLE_FAMILY2:
2504  case SID_STYLE_FAMILY3:
2505  case SID_STYLE_FAMILY4:
2506  case SID_STYLE_FAMILY5:
2507  {
2508  const sal_uInt16 nIdx = GetId() - SID_STYLE_FAMILY_START;
2509 
2510  if ( SfxItemState::DEFAULT == eState )
2511  {
2512  const SfxTemplateItem* pStateItem =
2513  dynamic_cast<const SfxTemplateItem*>( pState );
2514  DBG_ASSERT( pStateItem != nullptr, "SfxTemplateItem expected" );
2515  rControl.SetFamilyState( nIdx, pStateItem );
2516  }
2517  else
2518  rControl.SetFamilyState( nIdx, nullptr );
2519  break;
2520  }
2521  }
2522 }
2523 
2524 struct SvxStyleToolBoxControl::Impl
2525 {
2526  OUString aClearForm;
2527  OUString aMore;
2528  ::std::vector< std::pair< OUString, OUString > > aDefaultStyles;
2529  bool bSpecModeWriter;
2530  bool bSpecModeCalc;
2531 
2532  VclPtr<SvxStyleBox_Impl> m_xVclBox;
2533  std::unique_ptr<SvxStyleBox_Base> m_xWeldBox;
2534  SvxStyleBox_Base* m_pBox;
2535 
2536  Impl()
2537  :aClearForm ( SvxResId( RID_SVXSTR_CLEARFORM ) )
2538  ,aMore ( SvxResId( RID_SVXSTR_MORE_STYLES ) )
2539  ,bSpecModeWriter ( false )
2540  ,bSpecModeCalc ( false )
2541  ,m_pBox ( nullptr )
2542  {
2543 
2544 
2545  }
2546  void InitializeStyles(const Reference < frame::XModel >& xModel)
2547  {
2548  aDefaultStyles.clear();
2549 
2550  //now convert the default style names to the localized names
2551  try
2552  {
2553  Reference< style::XStyleFamiliesSupplier > xStylesSupplier( xModel, UNO_QUERY_THROW );
2554  Reference< lang::XServiceInfo > xServices( xModel, UNO_QUERY_THROW );
2555  bSpecModeWriter = xServices->supportsService("com.sun.star.text.TextDocument");
2556  if(bSpecModeWriter)
2557  {
2558  Reference<container::XNameAccess> xParaStyles;
2559  xStylesSupplier->getStyleFamilies()->getByName("ParagraphStyles") >>=
2560  xParaStyles;
2561  static const std::vector<OUString> aWriterStyles =
2562  {
2563  "Standard",
2564  "Text body",
2565  "Title",
2566  "Subtitle",
2567  "Heading 1",
2568  "Heading 2",
2569  "Heading 3",
2570  "Heading 4",
2571  "Quotations",
2572  "Preformatted Text"
2573  };
2574  for( const OUString& aStyle: aWriterStyles )
2575  {
2576  try
2577  {
2578  Reference< beans::XPropertySet > xStyle;
2579  xParaStyles->getByName( aStyle ) >>= xStyle;
2580  OUString sName;
2581  xStyle->getPropertyValue("DisplayName") >>= sName;
2582  if( !sName.isEmpty() )
2583  aDefaultStyles.push_back(
2584  std::pair<OUString, OUString>(aStyle, sName) );
2585  }
2586  catch( const uno::Exception& )
2587  {}
2588  }
2589 
2590  }
2591  else if( (
2592  bSpecModeCalc = xServices->supportsService(
2593  "com.sun.star.sheet.SpreadsheetDocument")))
2594  {
2595  static const char* aCalcStyles[] =
2596  {
2597  "Default",
2598  "Heading1",
2599  "Result",
2600  "Result2"
2601  };
2602  Reference<container::XNameAccess> xCellStyles;
2603  xStylesSupplier->getStyleFamilies()->getByName("CellStyles") >>= xCellStyles;
2604  for(const char* pCalcStyle : aCalcStyles)
2605  {
2606  try
2607  {
2608  const OUString sStyleName( OUString::createFromAscii( pCalcStyle ) );
2609  if( xCellStyles->hasByName( sStyleName ) )
2610  {
2611  Reference< beans::XPropertySet > xStyle( xCellStyles->getByName( sStyleName), UNO_QUERY_THROW );
2612  OUString sName;
2613  xStyle->getPropertyValue("DisplayName") >>= sName;
2614  if( !sName.isEmpty() )
2615  aDefaultStyles.push_back(
2616  std::pair<OUString, OUString>(sStyleName, sName) );
2617  }
2618  }
2619  catch( const uno::Exception& )
2620  {}
2621  }
2622  }
2623  }
2624  catch(const uno::Exception& )
2625  {
2626  OSL_FAIL("error while initializing style names");
2627  }
2628  }
2629 };
2630 
2631 // mapping table from bound items. BE CAREFUL this table must be in the
2632 // same order as the uno commands bound to the slots SID_STYLE_FAMILY1..n
2633 // MAX_FAMILIES must also be correctly set!
2634 static const char* StyleSlotToStyleCommand[MAX_FAMILIES] =
2635 {
2636  ".uno:CharStyle",
2637  ".uno:ParaStyle",
2638  ".uno:FrameStyle",
2639  ".uno:PageStyle",
2640  ".uno:TemplateFamily5"
2641 };
2642 
2643 SvxStyleToolBoxControl::SvxStyleToolBoxControl()
2644  : pImpl(new Impl)
2645  , pStyleSheetPool(nullptr)
2646  , nActFamily(0xffff)
2647 {
2648  for (sal_uInt16 i = 0; i < MAX_FAMILIES; ++i)
2649  {
2650  m_xBoundItems[i].clear();
2651  pFamilyState[i] = nullptr;
2652  }
2653 }
2654 
2655 SvxStyleToolBoxControl::~SvxStyleToolBoxControl()
2656 {
2657 }
2658 
2659 void SAL_CALL SvxStyleToolBoxControl::initialize(const Sequence<Any>& rArguments)
2660 {
2661  svt::ToolboxController::initialize(rArguments);
2662 
2663  // After initialize we should have a valid frame member where we can retrieve our
2664  // dispatch provider.
2665  if ( !m_xFrame.is() )
2666  return;
2667 
2668  pImpl->InitializeStyles(m_xFrame->getController()->getModel());
2669  Reference< XDispatchProvider > xDispatchProvider( m_xFrame->getController(), UNO_QUERY );
2670  for ( sal_uInt16 i=0; i<MAX_FAMILIES; i++ )
2671  {
2672  m_xBoundItems[i] = new SfxStyleControllerItem_Impl( xDispatchProvider,
2673  SID_STYLE_FAMILY_START + i,
2674  OUString::createFromAscii( StyleSlotToStyleCommand[i] ),
2675  *this );
2676  pFamilyState[i] = nullptr;
2677  }
2678 }
2679 
2680 // XComponent
2681 void SAL_CALL SvxStyleToolBoxControl::dispose()
2682 {
2683  svt::ToolboxController::dispose();
2684 
2685  SolarMutexGuard aSolarMutexGuard;
2686  pImpl->m_xVclBox.disposeAndClear();
2687  pImpl->m_xWeldBox.reset();
2688  pImpl->m_pBox = nullptr;
2689 
2690  for (rtl::Reference<SfxStyleControllerItem_Impl>& pBoundItem : m_xBoundItems)
2691  {
2692  if (!pBoundItem)
2693  continue;
2694  pBoundItem->UnBind();
2695  }
2696  unbindListener();
2697 
2698  for( sal_uInt16 i=0; i<MAX_FAMILIES; i++ )
2699  {
2700  if ( m_xBoundItems[i].is() )
2701  {
2702  try
2703  {
2704  m_xBoundItems[i]->dispose();
2705  }
2706  catch ( Exception& )
2707  {
2708  }
2709 
2710  m_xBoundItems[i].clear();
2711  }
2712  pFamilyState[i].reset();
2713  }
2714  pStyleSheetPool = nullptr;
2715  pImpl.reset();
2716 }
2717 
2718 OUString SvxStyleToolBoxControl::getImplementationName()
2719 {
2720  return "com.sun.star.comp.svx.StyleToolBoxControl";
2721 }
2722 
2723 sal_Bool SvxStyleToolBoxControl::supportsService( const OUString& rServiceName )
2724 {
2725  return cppu::supportsService( this, rServiceName );
2726 }
2727 
2728 css::uno::Sequence< OUString > SvxStyleToolBoxControl::getSupportedServiceNames()
2729 {
2730  return { "com.sun.star.frame.ToolbarController" };
2731 }
2732 
2733 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
2734 com_sun_star_comp_svx_StyleToolBoxControl_get_implementation(
2735  css::uno::XComponentContext*,
2736  css::uno::Sequence<css::uno::Any> const & )
2737 {
2738  return cppu::acquire( new SvxStyleToolBoxControl() );
2739 }
2740 
2741 void SAL_CALL SvxStyleToolBoxControl::update()
2742 {
2743  for (rtl::Reference<SfxStyleControllerItem_Impl>& pBoundItem : m_xBoundItems)
2744  pBoundItem->ReBind();
2745  bindListener();
2746 }
2747 
2748 SfxStyleFamily SvxStyleToolBoxControl::GetActFamily() const
2749 {
2750  switch ( nActFamily-1 + SID_STYLE_FAMILY_START )
2751  {
2752  case SID_STYLE_FAMILY1: return SfxStyleFamily::Char;
2753  case SID_STYLE_FAMILY2: return SfxStyleFamily::Para;
2754  case SID_STYLE_FAMILY3: return SfxStyleFamily::Frame;
2755  case SID_STYLE_FAMILY4: return SfxStyleFamily::Page;
2756  case SID_STYLE_FAMILY5: return SfxStyleFamily::Pseudo;
2757  default:
2758  OSL_FAIL( "unknown style family" );
2759  break;
2760  }
2761  return SfxStyleFamily::Para;
2762 }
2763 
2764 void SvxStyleToolBoxControl::FillStyleBox()
2765 {
2766  SvxStyleBox_Base* pBox = pImpl->m_pBox;
2767 
2768  DBG_ASSERT( pStyleSheetPool, "StyleSheetPool not found!" );
2769  DBG_ASSERT( pBox, "Control not found!" );
2770 
2771  if ( !(pStyleSheetPool && pBox && nActFamily!=0xffff) )
2772  return;
2773 
2774  const SfxStyleFamily eFamily = GetActFamily();
2775  SfxStyleSheetBase* pStyle = nullptr;
2776  bool bDoFill = false;
2777 
2778  auto xIter = pStyleSheetPool->CreateIterator(eFamily, SfxStyleSearchBits::Used);
2779  sal_uInt16 nCount = xIter->Count();
2780 
2781  // Check whether fill is necessary
2782  pStyle = xIter->First();
2785  if ( nCount != pBox->get_count() )
2786  {
2787  bDoFill = true;
2788  }
2789  else
2790  {
2791  sal_uInt16 i= 0;
2792  while ( pStyle && !bDoFill )
2793  {
2794  bDoFill = ( pBox->get_text(i) != pStyle->GetName() );
2795  pStyle = xIter->Next();
2796  i++;
2797  }
2798  }
2799 
2800  if ( !bDoFill )
2801  return;
2802 
2803  OUString aStrSel(pBox->get_active_text());
2804  pBox->freeze();
2805  pBox->clear();
2806 
2807  std::vector<OUString> aStyles;
2808 
2809  {
2810  pStyle = xIter->Next();
2811 
2812  if( pImpl->bSpecModeWriter || pImpl->bSpecModeCalc )
2813  {
2814  while ( pStyle )
2815  {
2816  // sort out default styles
2817  bool bInsert = true;
2818  OUString aName( pStyle->GetName() );
2819  for( auto const & _i: pImpl->aDefaultStyles )
2820  {
2821  if( _i.first == aName || _i.second == aName )
2822  {
2823  bInsert = false;
2824  break;
2825  }
2826  }
2827 
2828  if( bInsert )
2829  aStyles.push_back(aName);
2830  pStyle = xIter->Next();
2831  }
2832  }
2833  else
2834  {
2835  while ( pStyle )
2836  {
2837  aStyles.push_back(pStyle->GetName());
2838  pStyle = xIter->Next();
2839  }
2840  }
2841  }
2842 
2843  if (pImpl->bSpecModeWriter || pImpl->bSpecModeCalc)
2844  {
2845  pBox->append_text(pImpl->aClearForm);
2846  pBox->insert_separator(1, "separator");
2847 
2848  // insert default styles
2849  for (const auto &rStyle : pImpl->aDefaultStyles)
2850  pBox->append_text(rStyle.second);
2851  }
2852 
2853  std::sort(aStyles.begin(), aStyles.end());
2854 
2855  for (const auto& rStyle : aStyles)
2856  pBox->append_text(rStyle);
2857 
2858  if ((pImpl->bSpecModeWriter || pImpl->bSpecModeCalc) && !comphelper::LibreOfficeKit::isActive())
2859  pBox->append_text(pImpl->aMore);
2860 
2861  pBox->thaw();
2862  pBox->set_active_or_entry_text(aStrSel);
2863  pBox->SetFamily( eFamily );
2864 }
2865 
2866 void SvxStyleToolBoxControl::SelectStyle( const OUString& rStyleName )
2867 {
2868  SvxStyleBox_Base* pBox = pImpl->m_pBox;
2869  DBG_ASSERT( pBox, "Control not found!" );
2870 
2871  if ( !pBox )
2872  return;
2873 
2874  OUString aStrSel(pBox->get_active_text());
2875 
2876  if ( !rStyleName.isEmpty() )
2877  {
2878  OUString aNewStyle = rStyleName;
2879 
2880  auto aFound = std::find_if(pImpl->aDefaultStyles.begin(), pImpl->aDefaultStyles.end(),
2881  [rStyleName] (auto it) { return it.first == rStyleName || it.second == rStyleName; }
2882  );
2883 
2884  if (aFound != pImpl->aDefaultStyles.end())
2885  aNewStyle = aFound->second;
2886 
2887  if ( aNewStyle != aStrSel )
2888  pBox->set_active_or_entry_text( aNewStyle );
2889  }
2890  else
2891  pBox->set_active(-1);
2892  pBox->save_value();
2893 }
2894 
2895 void SvxStyleToolBoxControl::Update()
2896 {
2897  SfxStyleSheetBasePool* pPool = nullptr;
2898  SfxObjectShell* pDocShell = SfxObjectShell::Current();
2899 
2900  if ( pDocShell )
2901  pPool = pDocShell->GetStyleSheetPool();
2902 
2903  sal_uInt16 i;
2904  for ( i=0; i<MAX_FAMILIES; i++ )
2905  if( pFamilyState[i] )
2906  break;
2907 
2908  if ( i==MAX_FAMILIES || !pPool )
2909  {
2910  pStyleSheetPool = pPool;
2911  return;
2912  }
2913 
2914 
2915  const SfxTemplateItem* pItem = nullptr;
2916 
2917  if ( nActFamily == 0xffff || nullptr == (pItem = pFamilyState[nActFamily-1].get()) )
2918  // Current range not within allowed ranges or default
2919  {
2920  pStyleSheetPool = pPool;
2921  nActFamily = 2;
2922 
2923  pItem = pFamilyState[nActFamily-1].get();
2924  if ( !pItem )
2925  {
2926  nActFamily++;
2927  pItem = pFamilyState[nActFamily-1].get();
2928  }
2929  }
2930  else if ( pPool != pStyleSheetPool )
2931  pStyleSheetPool = pPool;
2932 
2933  FillStyleBox(); // Decides by itself whether Fill is needed
2934 
2935  if ( pItem )
2936  SelectStyle( pItem->GetStyleName() );
2937 }
2938 
2939 void SvxStyleToolBoxControl::SetFamilyState( sal_uInt16 nIdx,
2940  const SfxTemplateItem* pItem )
2941 {
2942  pFamilyState[nIdx].reset( pItem == nullptr ? nullptr : new SfxTemplateItem( *pItem ) );
2943  Update();
2944 }
2945 
2946 void SvxStyleToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2947 {
2948  SolarMutexGuard aGuard;
2949 
2950  if (m_pToolbar)
2951  m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
2952  else
2953  {
2954  ToolBox* pToolBox = nullptr;
2955  ToolBoxItemId nId;
2956  if (!getToolboxId( nId, &pToolBox ) )
2957  return;
2958  pToolBox->EnableItem( nId, rEvent.IsEnabled );
2959  }
2960 
2961  if (rEvent.IsEnabled)
2962  Update();
2963 }
2964 
2965 css::uno::Reference<css::awt::XWindow> SvxStyleToolBoxControl::createItemWindow(const css::uno::Reference< css::awt::XWindow>& rParent)
2966 {
2967  uno::Reference< awt::XWindow > xItemWindow;
2968 
2969  if (m_pBuilder)
2970  {
2971  SolarMutexGuard aSolarMutexGuard;
2972 
2973  std::unique_ptr<weld::ComboBox> xWidget(m_pBuilder->weld_combo_box("applystyle"));
2974 
2975  xItemWindow = css::uno::Reference<css::awt::XWindow>(new weld::TransportAsXWindow(xWidget.get()));
2976 
2977  pImpl->m_xWeldBox.reset(new SvxStyleBox_Base(std::move(xWidget),
2978  ".uno:StyleApply",
2979  SfxStyleFamily::Para,
2980  Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
2981  m_xFrame,
2982  pImpl->aClearForm,
2983  pImpl->aMore,
2984  pImpl->bSpecModeWriter || pImpl->bSpecModeCalc, *this));
2985  pImpl->m_pBox = pImpl->m_xWeldBox.get();
2986  }
2987  else
2988  {
2989  VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(rParent);
2990  if ( pParent )
2991  {
2992  SolarMutexGuard aSolarMutexGuard;
2993 
2994  pImpl->m_xVclBox = VclPtr<SvxStyleBox_Impl>::Create(pParent,
2995  ".uno:StyleApply",
2996  SfxStyleFamily::Para,
2997  Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
2998  m_xFrame,
2999  pImpl->aClearForm,
3000  pImpl->aMore,
3001  pImpl->bSpecModeWriter || pImpl->bSpecModeCalc, *this);
3002  pImpl->m_pBox = pImpl->m_xVclBox.get();
3003  xItemWindow = VCLUnoHelper::GetInterface(pImpl->m_xVclBox);
3004  }
3005  }
3006 
3007  if (pImpl->m_pBox && !pImpl->aDefaultStyles.empty())
3008  pImpl->m_pBox->SetDefaultStyle(pImpl->aDefaultStyles[0].second);
3009 
3010  return xItemWindow;
3011 }
3012 
3013 SvxFontNameToolBoxControl::SvxFontNameToolBoxControl()
3014  : m_pBox(nullptr)
3015 {
3016 }
3017 
3018 void SvxFontNameBox_Base::statusChanged_Impl( const css::frame::FeatureStateEvent& rEvent )
3019 {
3020  if ( !rEvent.IsEnabled )
3021  {
3022  set_sensitive(false);
3023  Update( nullptr );
3024  }
3025  else
3026  {
3027  set_sensitive(true);
3028 
3029  css::awt::FontDescriptor aFontDesc;
3030  if ( rEvent.State >>= aFontDesc )
3031  Update(&aFontDesc);
3032  else
3033  set_active_or_entry_text("");
3034  m_xWidget->save_value();
3035  }
3036 }
3037 
3038 void SvxFontNameToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
3039 {
3040  SolarMutexGuard aGuard;
3041  m_pBox->statusChanged_Impl(rEvent);
3042 
3043  if (m_pToolbar)
3044  m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
3045  else
3046  {
3047  ToolBox* pToolBox = nullptr;
3048  ToolBoxItemId nId;
3049  if (!getToolboxId( nId, &pToolBox ) )
3050  return;
3051  pToolBox->EnableItem( nId, rEvent.IsEnabled );
3052  }
3053 }
3054 
3055 css::uno::Reference<css::awt::XWindow> SvxFontNameToolBoxControl::createItemWindow(const css::uno::Reference<css::awt::XWindow>& rParent)
3056 {
3057  uno::Reference< awt::XWindow > xItemWindow;
3058 
3059  if (m_pBuilder)
3060  {
3061  SolarMutexGuard aSolarMutexGuard;
3062 
3063  std::unique_ptr<weld::ComboBox> xWidget(m_pBuilder->weld_combo_box("fontnamecombobox"));
3064 
3065  xItemWindow = css::uno::Reference<css::awt::XWindow>(new weld::TransportAsXWindow(xWidget.get()));
3066 
3067  m_xWeldBox.reset(new SvxFontNameBox_Base(std::move(xWidget),
3068  Reference<XDispatchProvider>(m_xFrame->getController(), UNO_QUERY),
3069  m_xFrame, *this));
3070  m_pBox = m_xWeldBox.get();
3071  }
3072  else
3073  {
3074  VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(rParent);
3075  if ( pParent )
3076  {
3077  SolarMutexGuard aSolarMutexGuard;
3078  m_xVclBox = VclPtr<SvxFontNameBox_Impl>::Create(pParent,
3079  Reference<XDispatchProvider>(m_xFrame->getController(), UNO_QUERY),
3080  m_xFrame, *this);
3081  m_pBox = m_xVclBox.get();
3082  xItemWindow = VCLUnoHelper::GetInterface(m_xVclBox);
3083  }
3084  }
3085 
3086  return xItemWindow;
3087 }
3088 
3089 void SvxFontNameToolBoxControl::dispose()
3090 {
3091  ToolboxController::dispose();
3092 
3093  SolarMutexGuard aSolarMutexGuard;
3094  m_xVclBox.disposeAndClear();
3095  m_xWeldBox.reset();
3096  m_pBox = nullptr;
3097 }
3098 
3099 OUString SvxFontNameToolBoxControl::getImplementationName()
3100 {
3101  return "com.sun.star.comp.svx.FontNameToolBoxControl";
3102 }
3103 
3104 sal_Bool SvxFontNameToolBoxControl::supportsService( const OUString& rServiceName )
3105 {
3106  return cppu::supportsService( this, rServiceName );
3107 }
3108 
3109 css::uno::Sequence< OUString > SvxFontNameToolBoxControl::getSupportedServiceNames()
3110 {
3111  return { "com.sun.star.frame.ToolbarController" };
3112 }
3113 
3114 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
3115 com_sun_star_comp_svx_FontNameToolBoxControl_get_implementation(
3116  css::uno::XComponentContext*,
3117  css::uno::Sequence<css::uno::Any> const & )
3118 {
3119  return cppu::acquire( new SvxFontNameToolBoxControl() );
3120 }
3121 
3122 SvxColorToolBoxControl::SvxColorToolBoxControl( const css::uno::Reference<css::uno::XComponentContext>& rContext ) :
3123  ImplInheritanceHelper( rContext, nullptr, OUString() ),
3124  m_bSplitButton(true),
3125  m_nSlotId(0),
3126  m_aColorSelectFunction(PaletteManager::DispatchColorCommand)
3127 {
3128 }
3129 
3130 namespace {
3131 
3132 sal_uInt16 MapCommandToSlotId(const OUString& rCommand)
3133 {
3134  if (rCommand == ".uno:Color")
3135  return SID_ATTR_CHAR_COLOR;
3136  else if (rCommand == ".uno:FontColor")
3137  return SID_ATTR_CHAR_COLOR2;
3138  else if (rCommand == ".uno:BackColor")
3139  return SID_ATTR_CHAR_COLOR_BACKGROUND;
3140  else if (rCommand == ".uno:CharBackColor")
3141  return SID_ATTR_CHAR_BACK_COLOR;
3142  else if (rCommand == ".uno:BackgroundColor")
3143  return SID_BACKGROUND_COLOR;
3144  else if (rCommand == ".uno:TableCellBackgroundColor")
3145  return SID_TABLE_CELL_BACKGROUND_COLOR;
3146  else if (rCommand == ".uno:Extrusion3DColor")
3147  return SID_EXTRUSION_3D_COLOR;
3148  else if (rCommand == ".uno:XLineColor")
3149  return SID_ATTR_LINE_COLOR;
3150  else if (rCommand == ".uno:FillColor")
3151  return SID_ATTR_FILL_COLOR;
3152  else if (rCommand == ".uno:FrameLineColor")
3153  return SID_FRAME_LINECOLOR;
3154 
3155  SAL_WARN("svx.tbxcrtls", "Unknown color command: " << rCommand);
3156  return 0;
3157 }
3158 
3159 }
3160 
3161 void SvxColorToolBoxControl::initialize( const css::uno::Sequence<css::uno::Any>& rArguments )
3162 {
3163  PopupWindowController::initialize( rArguments );
3164 
3165  m_nSlotId = MapCommandToSlotId( m_aCommandURL );
3166 
3167  if ( m_nSlotId == SID_ATTR_LINE_COLOR || m_nSlotId == SID_ATTR_FILL_COLOR ||
3168  m_nSlotId == SID_FRAME_LINECOLOR || m_nSlotId == SID_BACKGROUND_COLOR )
3169  {
3170  // Sidebar uses wide buttons for those.
3171  m_bSplitButton = !m_bSidebar;
3172  }
3173 
3174  auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(getCommandURL(), getModuleName());
3175  OUString aCommandLabel = vcl::CommandInfoProvider::GetLabelForCommand(aProperties);
3176 
3177  OString aId(m_aCommandURL.toUtf8());
3178 
3179  if (m_pToolbar)
3180  {
3181  mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
3182  m_pToolbar->set_item_popover(aId, mxPopoverContainer->getTopLevel());
3183  m_xBtnUpdater.reset(new svx::ToolboxButtonColorUpdater(m_nSlotId, aId, m_pToolbar, !m_bSplitButton, aCommandLabel, m_xFrame));
3184  return;
3185  }
3186 
3187  ToolBox* pToolBox = nullptr;
3188  ToolBoxItemId nId;
3189  if (getToolboxId(nId, &pToolBox))
3190  {
3191  m_xBtnUpdater.reset( new svx::VclToolboxButtonColorUpdater( m_nSlotId, nId, pToolBox, !m_bSplitButton, aCommandLabel, m_aCommandURL, m_xFrame ) );
3192  pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ( m_bSplitButton ? ToolBoxItemBits::DROPDOWN : ToolBoxItemBits::DROPDOWNONLY ) );
3193  }
3194 }
3195 
3196 void SvxColorToolBoxControl::update()
3197 {
3198  PopupWindowController::update();
3199 
3200  switch( m_nSlotId )
3201  {
3202  case SID_ATTR_CHAR_COLOR2:
3203  addStatusListener( ".uno:CharColorExt");
3204  break;
3205 
3206  case SID_ATTR_CHAR_COLOR_BACKGROUND:
3207  addStatusListener( ".uno:CharBackgroundExt");
3208  break;
3209 
3210  case SID_FRAME_LINECOLOR:
3211  addStatusListener( ".uno:BorderTLBR");
3212  addStatusListener( ".uno:BorderBLTR");
3213  break;
3214  }
3215 }
3216 
3217 void SvxColorToolBoxControl::EnsurePaletteManager()
3218 {
3219  if (!m_xPaletteManager)
3220  {
3221  m_xPaletteManager = std::make_shared<PaletteManager>();
3222  m_xPaletteManager->SetBtnUpdater(m_xBtnUpdater.get());
3223  }
3224 }
3225 
3226 SvxColorToolBoxControl::~SvxColorToolBoxControl()
3227 {
3228  if (m_xPaletteManager)
3229  m_xPaletteManager->SetBtnUpdater(nullptr);
3230 }
3231 
3232 void SvxColorToolBoxControl::setColorSelectFunction(const ColorSelectFunction& aColorSelectFunction)
3233 {
3234  m_aColorSelectFunction = aColorSelectFunction;
3235  if (m_xPaletteManager)
3236  m_xPaletteManager->SetColorSelectFunction(aColorSelectFunction);
3237 }
3238 
3239 weld::Window* SvxColorToolBoxControl::GetParentFrame() const
3240 {
3241  const css::uno::Reference<css::awt::XWindow> xParent = m_xFrame->getContainerWindow();
3242  return Application::GetFrameWeld(xParent);
3243 }
3244 
3245 std::unique_ptr<WeldToolbarPopup> SvxColorToolBoxControl::weldPopupWindow()
3246 {
3247  EnsurePaletteManager();
3248 
3249  const OString aId(m_aCommandURL.toUtf8());
3250 
3251  auto xPopover = std::make_unique<ColorWindow>(
3252  m_aCommandURL,
3253  m_xPaletteManager,
3254  m_aColorStatus,
3255  m_nSlotId,
3256  m_xFrame,
3257  MenuOrToolMenuButton(m_pToolbar, aId),
3258  [this] { return GetParentFrame(); },
3259  m_aColorSelectFunction);
3260 
3261  if ( m_bSplitButton )
3262  xPopover->SetSelectedHdl( LINK( this, SvxColorToolBoxControl, SelectedHdl ) );
3263 
3264  return xPopover;
3265 }
3266 
3267 VclPtr<vcl::Window> SvxColorToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3268 {
3269  ToolBox* pToolBox = nullptr;
3270  ToolBoxItemId nId;
3271  if (!getToolboxId(nId, &pToolBox))
3272  return nullptr;
3273 
3274  EnsurePaletteManager();
3275 
3276  auto xPopover = std::make_unique<ColorWindow>(
3277  m_aCommandURL,
3278  m_xPaletteManager,
3279  m_aColorStatus,
3280  m_nSlotId,
3281  m_xFrame,
3282  MenuOrToolMenuButton(this, pToolBox, nId),
3283  [this] { return GetParentFrame(); },
3284  m_aColorSelectFunction);
3285 
3286  if ( m_bSplitButton )
3287  xPopover->SetSelectedHdl( LINK( this, SvxColorToolBoxControl, SelectedHdl ) );
3288 
3289  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
3290  std::move(xPopover), true);
3291 
3292  auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(m_aCommandURL, m_sModuleName);
3293  OUString aWindowTitle = vcl::CommandInfoProvider::GetLabelForCommand(aProperties);
3294  mxInterimPopover->SetText(aWindowTitle);
3295 
3296  mxInterimPopover->Show();
3297 
3298  return mxInterimPopover;
3299 }
3300 
3301 IMPL_LINK(SvxColorToolBoxControl, SelectedHdl, const NamedColor&, rColor, void)
3302 {
3303  m_xBtnUpdater->Update(rColor);
3304 }
3305 
3306 void SvxColorToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
3307 {
3308  ToolBox* pToolBox = nullptr;
3309  ToolBoxItemId nId;
3310  if (!getToolboxId(nId, &pToolBox) && !m_pToolbar)
3311  return;
3312 
3313  if ( rEvent.FeatureURL.Complete == m_aCommandURL )
3314  {
3315  if (m_pToolbar)
3316  m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
3317  else
3318  pToolBox->EnableItem( nId, rEvent.IsEnabled );
3319  }
3320 
3321  bool bValue;
3322  if ( !m_bSplitButton )
3323  {
3324  m_aColorStatus.statusChanged( rEvent );
3325  m_xBtnUpdater->Update( m_aColorStatus.GetColor() );
3326  }
3327  else if ( rEvent.State >>= bValue )
3328  {
3329  if (m_pToolbar)
3330  m_pToolbar->set_item_active(m_aCommandURL.toUtf8(), bValue);
3331  else if (pToolBox)
3332  pToolBox->CheckItem( nId, bValue );
3333  }
3334 }
3335 
3336 void SvxColorToolBoxControl::execute(sal_Int16 /*nSelectModifier*/)
3337 {
3338  if ( !m_bSplitButton )
3339  {
3340  if (m_pToolbar)
3341  {
3342  // Toggle the popup also when toolbutton is activated
3343  const OString aId(m_aCommandURL.toUtf8());
3344  m_pToolbar->set_menu_item_active(aId, !m_pToolbar->get_menu_item_active(aId));
3345  }
3346  else
3347  {
3348  // Open the popup also when Enter key is pressed.
3349  createPopupWindow();
3350  }
3351  return;
3352  }
3353 
3354  OUString aCommand = m_aCommandURL;
3355  Color aColor = m_xBtnUpdater->GetCurrentColor();
3356 
3357  switch( m_nSlotId )
3358  {
3359  case SID_ATTR_CHAR_COLOR2 :
3360  aCommand = ".uno:CharColorExt";
3361  break;
3362 
3363  case SID_ATTR_CHAR_COLOR_BACKGROUND :
3364  aCommand = ".uno:CharBackgroundExt";
3365  break;
3366  }
3367 
3368  auto aArgs( comphelper::InitPropertySequence( {
3369  { m_aCommandURL.copy(5), css::uno::makeAny(aColor) }
3370  } ) );
3371  dispatchCommand( aCommand, aArgs );
3372 
3373  EnsurePaletteManager();
3374  OUString sColorName = m_xBtnUpdater->GetCurrentColorName();
3375  m_xPaletteManager->AddRecentColor(aColor, sColorName);
3376 }
3377 
3378 sal_Bool SvxColorToolBoxControl::opensSubToolbar()
3379 {
3380  // We mark this controller as a sub-toolbar controller, so we get notified
3381  // (through updateImage method) on button image changes, and could redraw
3382  // the last used color on top of it.
3383  return true;
3384 }
3385 
3386 void SvxColorToolBoxControl::updateImage()
3387 {
3388  m_xBtnUpdater->Update(m_xBtnUpdater->GetCurrentColor(), true);
3389 }
3390 
3391 OUString SvxColorToolBoxControl::getSubToolbarName()
3392 {
3393  return OUString();
3394 }
3395 
3396 void SvxColorToolBoxControl::functionSelected( const OUString& /*rCommand*/ )
3397 {
3398 }
3399 
3400 OUString SvxColorToolBoxControl::getImplementationName()
3401 {
3402  return "com.sun.star.comp.svx.ColorToolBoxControl";
3403 }
3404 
3405 css::uno::Sequence<OUString> SvxColorToolBoxControl::getSupportedServiceNames()
3406 {
3407  return { "com.sun.star.frame.ToolbarController" };
3408 }
3409 
3410 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
3411 com_sun_star_comp_svx_ColorToolBoxControl_get_implementation(
3412  css::uno::XComponentContext* rContext,
3413  css::uno::Sequence<css::uno::Any> const & )
3414 {
3415  return cppu::acquire( new SvxColorToolBoxControl( rContext ) );
3416 }
3417 
3418 SvxFrameToolBoxControl::SvxFrameToolBoxControl( const css::uno::Reference< css::uno::XComponentContext >& rContext )
3419  : svt::PopupWindowController( rContext, nullptr, OUString() )
3420 {
3421 }
3422 
3423 void SAL_CALL SvxFrameToolBoxControl::execute(sal_Int16 /*KeyModifier*/)
3424 {
3425  if (m_pToolbar)
3426  {
3427  // Toggle the popup also when toolbutton is activated
3428  const OString aId(m_aCommandURL.toUtf8());
3429  m_pToolbar->set_menu_item_active(aId, !m_pToolbar->get_menu_item_active(aId));
3430  }
3431  else
3432  {
3433  // Open the popup also when Enter key is pressed.
3434  createPopupWindow();
3435  }
3436 }
3437 
3438 void SvxFrameToolBoxControl::initialize( const css::uno::Sequence< css::uno::Any >& rArguments )
3439 {
3440  svt::PopupWindowController::initialize( rArguments );
3441 
3442  if (m_pToolbar)
3443  {
3444  mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
3445  m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel());
3446  }
3447 
3448  ToolBox* pToolBox = nullptr;
3449  ToolBoxItemId nId;
3450  if (getToolboxId(nId, &pToolBox))
3451  pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
3452 }
3453 
3454 std::unique_ptr<WeldToolbarPopup> SvxFrameToolBoxControl::weldPopupWindow()
3455 {
3456  if ( m_aCommandURL == ".uno:LineStyle" )
3457  return std::make_unique<SvxLineWindow_Impl>(this, m_pToolbar);
3458  return std::make_unique<SvxFrameWindow_Impl>(this, m_pToolbar);
3459 }
3460 
3461 VclPtr<vcl::Window> SvxFrameToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3462 {
3463  if ( m_aCommandURL == ".uno:LineStyle" )
3464  {
3465  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
3466  std::make_unique<SvxLineWindow_Impl>(this, pParent->GetFrameWeld()));
3467 
3468  mxInterimPopover->Show();
3469 
3470  mxInterimPopover->SetText(SvxResId(RID_SVXSTR_FRAME_STYLE));
3471 
3472  return mxInterimPopover;
3473  }
3474 
3475  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
3476  std::make_unique<SvxFrameWindow_Impl>(this, pParent->GetFrameWeld()));
3477 
3478  mxInterimPopover->Show();
3479 
3480  mxInterimPopover->SetText(SvxResId(RID_SVXSTR_FRAME));
3481 
3482  return mxInterimPopover;
3483 }
3484 
3485 OUString SvxFrameToolBoxControl::getImplementationName()
3486 {
3487  return "com.sun.star.comp.svx.FrameToolBoxControl";
3488 }
3489 
3490 css::uno::Sequence< OUString > SvxFrameToolBoxControl::getSupportedServiceNames()
3491 {
3492  return { "com.sun.star.frame.ToolbarController" };
3493 }
3494 
3495 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
3496 com_sun_star_comp_svx_FrameToolBoxControl_get_implementation(
3497  css::uno::XComponentContext* rContext,
3498  css::uno::Sequence<css::uno::Any> const & )
3499 {
3500  return cppu::acquire( new SvxFrameToolBoxControl( rContext ) );
3501 }
3502 
3503 SvxCurrencyToolBoxControl::SvxCurrencyToolBoxControl( const css::uno::Reference<css::uno::XComponentContext>& rContext ) :
3504  PopupWindowController( rContext, nullptr, OUString() ),
3505  m_eLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() ),
3506  m_nFormatKey( NUMBERFORMAT_ENTRY_NOT_FOUND )
3507 {
3508 }
3509 
3510 SvxCurrencyToolBoxControl::~SvxCurrencyToolBoxControl() {}
3511 
3512 namespace
3513 {
3514  class SvxCurrencyList_Impl : public WeldToolbarPopup
3515  {
3516  private:
3517  rtl::Reference<SvxCurrencyToolBoxControl> m_xControl;
3518  std::unique_ptr<weld::Label> m_xLabel;
3519  std::unique_ptr<weld::TreeView> m_xCurrencyLb;
3520  std::unique_ptr<weld::Button> m_xOkBtn;
3521  OUString& m_rSelectedFormat;
3522  LanguageType& m_eSelectedLanguage;
3523 
3524  std::vector<OUString> m_aFormatEntries;
3525  LanguageType m_eFormatLanguage;
3526  DECL_LINK(RowActivatedHdl, weld::TreeView&, bool);
3527  DECL_LINK(OKHdl, weld::Button&, void);
3528 
3529  virtual void GrabFocus() override;
3530 
3531  public:
3532  SvxCurrencyList_Impl(SvxCurrencyToolBoxControl* pControl, weld::Widget* pParent, OUString& rSelectedFormat, LanguageType& eSelectedLanguage)
3533  : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/currencywindow.ui", "CurrencyWindow")
3534  , m_xControl(pControl)
3535  , m_xLabel(m_xBuilder->weld_label("label"))
3536  , m_xCurrencyLb(m_xBuilder->weld_tree_view("currency"))
3537  , m_xOkBtn(m_xBuilder->weld_button("ok"))
3538  , m_rSelectedFormat(rSelectedFormat)
3539  , m_eSelectedLanguage(eSelectedLanguage)
3540  {
3541  std::vector< OUString > aList;
3542  std::vector< sal_uInt16 > aCurrencyList;
3543  const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable();
3544  sal_uInt16 nLen = rCurrencyTable.size();
3545 
3546  SvNumberFormatter aFormatter( m_xControl->getContext(), LANGUAGE_SYSTEM );
3547  m_eFormatLanguage = aFormatter.GetLanguage();
3548 
3549  SvxCurrencyToolBoxControl::GetCurrencySymbols( aList, true, aCurrencyList );
3550 
3551  sal_uInt16 nPos = 0, nCount = 0;
3552  sal_Int32 nSelectedPos = -1;
3553  bool bIsSymbol;
3554  NfWSStringsDtor aStringsDtor;
3555 
3556  OUString sLongestString;
3557 
3558  m_xCurrencyLb->freeze();
3559  for( const auto& rItem : aList )
3560  {
3561  sal_uInt16& rCurrencyIndex = aCurrencyList[ nCount ];
3562  if ( rCurrencyIndex < nLen )
3563  {
3564  m_xCurrencyLb->append_text(rItem);
3565 
3566  if (rItem.getLength() > sLongestString.getLength())
3567  sLongestString = rItem;
3568 
3569  const NfCurrencyEntry& aCurrencyEntry = rCurrencyTable[ rCurrencyIndex ];
3570 
3571  bIsSymbol = nPos >= nLen;
3572 
3573  sal_uInt16 nDefaultFormat = aFormatter.GetCurrencyFormatStrings( aStringsDtor, aCurrencyEntry, bIsSymbol );
3574  const OUString& rFormatStr = aStringsDtor[ nDefaultFormat ];
3575  m_aFormatEntries.push_back( rFormatStr );
3576  if( rFormatStr == m_rSelectedFormat )
3577  nSelectedPos = nPos;
3578  ++nPos;
3579  }
3580  ++nCount;
3581  }
3582  m_xCurrencyLb->thaw();
3583  // enable multiple selection enabled so we can start with nothing selected
3584  m_xCurrencyLb->set_selection_mode(SelectionMode::Multiple);
3585  m_xCurrencyLb->connect_row_activated( LINK( this, SvxCurrencyList_Impl, RowActivatedHdl ) );
3586  m_xLabel->set_label(SvxResId(RID_SVXSTR_TBLAFMT_CURRENCY));
3587  m_xCurrencyLb->select( nSelectedPos );
3588  m_xOkBtn->connect_clicked(LINK(this, SvxCurrencyList_Impl, OKHdl));
3589 
3590  // gtk will initially make a best guess depending on the first few entries, so copy the probable
3591  // longest entry to the start temporarily and force in the width at this point
3592  m_xCurrencyLb->insert_text(0, sLongestString);
3593  m_xCurrencyLb->set_size_request(m_xCurrencyLb->get_preferred_size().Width(), m_xCurrencyLb->get_height_rows(12));
3594  m_xCurrencyLb->remove(0);
3595  }
3596  };
3597 
3598  void SvxCurrencyList_Impl::GrabFocus()
3599  {
3600  m_xCurrencyLb->grab_focus();
3601  }
3602 
3603  IMPL_LINK_NOARG(SvxCurrencyList_Impl, OKHdl, weld::Button&, void)
3604  {
3605  RowActivatedHdl(*m_xCurrencyLb);
3606  }
3607 
3608  IMPL_LINK_NOARG(SvxCurrencyList_Impl, RowActivatedHdl, weld::TreeView&, bool)
3609  {
3610  if (!m_xControl.is())
3611  return true;
3612 
3613  // multiple selection enabled so we can start with nothing selected,
3614  // so force single selection after something is picked
3615  int nSelected = m_xCurrencyLb->get_selected_index();
3616  if (nSelected == -1)
3617  return true;
3618 
3619  m_xCurrencyLb->set_selection_mode(SelectionMode::Single);
3620 
3621  m_rSelectedFormat = m_aFormatEntries[nSelected];
3622  m_eSelectedLanguage = m_eFormatLanguage;
3623 
3624  m_xControl->execute(nSelected + 1);
3625 
3626  m_xControl->EndPopupMode();
3627 
3628  return true;
3629  }
3630 }
3631 
3632 void SvxCurrencyToolBoxControl::initialize( const css::uno::Sequence< css::uno::Any >& rArguments )
3633 {
3634  PopupWindowController::initialize(rArguments);
3635 
3636  if (m_pToolbar)
3637  {
3638  mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
3639  m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel());
3640  return;
3641  }
3642 
3643  ToolBox* pToolBox = nullptr;
3644  ToolBoxItemId nId;
3645  if (getToolboxId(nId, &pToolBox) && pToolBox->GetItemCommand(nId) == m_aCommandURL)
3646  pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWN | pToolBox->GetItemBits(nId));
3647 }
3648 
3649 std::unique_ptr<WeldToolbarPopup> SvxCurrencyToolBoxControl::weldPopupWindow()
3650 {
3651  return std::make_unique<SvxCurrencyList_Impl>(this, m_pToolbar, m_aFormatString, m_eLanguage);
3652 }
3653 
3654 VclPtr<vcl::Window> SvxCurrencyToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3655 {
3656  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
3657  std::make_unique<SvxCurrencyList_Impl>(this, pParent->GetFrameWeld(), m_aFormatString, m_eLanguage));
3658 
3659  mxInterimPopover->Show();
3660 
3661  return mxInterimPopover;
3662 }
3663 
3664 void SvxCurrencyToolBoxControl::execute( sal_Int16 nSelectModifier )
3665 {
3666  sal_uInt32 nFormatKey;
3667  if (m_aFormatString.isEmpty())
3668  nFormatKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
3669  else
3670  {
3671  if ( nSelectModifier > 0 )
3672  {
3673  try
3674  {
3675  uno::Reference< util::XNumberFormatsSupplier > xRef( m_xFrame->getController()->getModel(), uno::UNO_QUERY );
3676  uno::Reference< util::XNumberFormats > rxNumberFormats( xRef->getNumberFormats(), uno::UNO_SET_THROW );
3677  css::lang::Locale aLocale = LanguageTag::convertToLocale( m_eLanguage );
3678  nFormatKey = rxNumberFormats->queryKey( m_aFormatString, aLocale, false );
3679  if ( nFormatKey == NUMBERFORMAT_ENTRY_NOT_FOUND )
3680  nFormatKey = rxNumberFormats->addNew( m_aFormatString, aLocale );
3681  }
3682  catch( const uno::Exception& )
3683  {
3684  nFormatKey = m_nFormatKey;
3685  }
3686  }
3687  else
3688  nFormatKey = m_nFormatKey;
3689  }
3690 
3691  if( nFormatKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
3692  {
3693  Sequence< PropertyValue > aArgs( 1 );
3694  aArgs[0].Name = "NumberFormatCurrency";
3695  aArgs[0].Value <<= nFormatKey;
3696  dispatchCommand( m_aCommandURL, aArgs );
3697  m_nFormatKey = nFormatKey;
3698  }
3699  else
3700  PopupWindowController::execute( nSelectModifier );
3701 }
3702 
3703 OUString SvxCurrencyToolBoxControl::getImplementationName()
3704 {
3705  return "com.sun.star.comp.svx.CurrencyToolBoxControl";
3706 }
3707 
3708 css::uno::Sequence<OUString> SvxCurrencyToolBoxControl::getSupportedServiceNames()
3709 {
3710  return { "com.sun.star.frame.ToolbarController" };
3711 }
3712 
3713 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
3714 com_sun_star_comp_svx_CurrencyToolBoxControl_get_implementation(
3715  css::uno::XComponentContext* rContext,
3716  css::uno::Sequence<css::uno::Any> const & )
3717 {
3718  return cppu::acquire( new SvxCurrencyToolBoxControl( rContext ) );
3719 }
3720 
3721 Reference< css::accessibility::XAccessible > SvxFontNameBox_Impl::CreateAccessible()
3722 {
3723  FillList();
3724  return InterimItemWindow::CreateAccessible();
3725 }
3726 
3727 //static
3728 void SvxCurrencyToolBoxControl::GetCurrencySymbols( std::vector<OUString>& rList, bool bFlag,
3729  std::vector<sal_uInt16>& rCurrencyList )
3730 {
3731  rCurrencyList.clear();
3732 
3733  const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable();
3734  sal_uInt16 nCount = rCurrencyTable.size();
3735 
3736  sal_uInt16 nStart = 1;
3737 
3738  OUString aString( ApplyLreOrRleEmbedding( rCurrencyTable[0].GetSymbol() ) + " " );
3739  aString += ApplyLreOrRleEmbedding( SvtLanguageTable::GetLanguageString(
3740  rCurrencyTable[0].GetLanguage() ) );
3741 
3742  rList.push_back( aString );
3743  rCurrencyList.push_back( sal_uInt16(-1) ); // nAuto
3744 
3745  if( bFlag )
3746  {
3747  rList.push_back( aString );
3748  rCurrencyList.push_back( 0 );
3749  ++nStart;
3750  }
3751 
3752  CollatorWrapper aCollator( ::comphelper::getProcessComponentContext() );
3753  aCollator.loadDefaultCollator( Application::GetSettings().GetLanguageTag().getLocale(), 0 );
3754 
3755  static const OUStringLiteral aTwoSpace(u" ");
3756 
3757  for( sal_uInt16 i = 1; i < nCount; ++i )
3758  {
3759  OUString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i].GetBankSymbol() ) );
3760  aStr += aTwoSpace;
3761  aStr += ApplyLreOrRleEmbedding( rCurrencyTable[i].GetSymbol() );
3762  aStr += aTwoSpace;
3763  aStr += ApplyLreOrRleEmbedding( SvtLanguageTable::GetLanguageString(
3764  rCurrencyTable[i].GetLanguage() ) );
3765 
3766  std::vector<OUString>::size_type j = nStart;
3767  for( ; j < rList.size(); ++j )
3768  if ( aCollator.compareString( aStr, rList[j] ) < 0 )
3769  break; // insert before first greater than
3770 
3771  rList.insert( rList.begin() + j, aStr );
3772  rCurrencyList.insert( rCurrencyList.begin() + j, i );
3773  }
3774 
3775  // Append ISO codes to symbol list.
3776  // XXX If this is to be changed, various other places would had to be
3777  // adapted that assume this order!
3778  std::vector<OUString>::size_type nCont = rList.size();
3779 
3780  for ( sal_uInt16 i = 1; i < nCount; ++i )
3781  {
3782  bool bInsert = true;
3783  OUString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i].GetBankSymbol() ) );
3784 
3785  std::vector<OUString>::size_type j = nCont;
3786  for ( ; j < rList.size() && bInsert; ++j )
3787  {
3788  if( rList[j] == aStr )
3789  bInsert = false;
3790  else if ( aCollator.compareString( aStr, rList[j] ) < 0 )
3791  break; // insert before first greater than
3792  }
3793  if ( bInsert )
3794  {
3795  rList.insert( rList.begin() + j, aStr );
3796  rCurrencyList.insert( rCurrencyList.begin() + j, i );
3797  }
3798  }
3799 }
3800 
3801 ListBoxColorWrapper::ListBoxColorWrapper(ColorListBox* pControl)
3802  : mpControl(pControl)
3803 {
3804 }
3805 
3806 void ListBoxColorWrapper::operator()(
3807  [[maybe_unused]] const OUString& /*rCommand*/, const NamedColor& rColor)
3808 {
3809  mpControl->Selected(rColor);
3810 }
3811 
3812 void ColorListBox::EnsurePaletteManager()
3813 {
3814  if (!m_xPaletteManager)
3815  {
3816  m_xPaletteManager = std::make_shared<PaletteManager>();
3817  m_xPaletteManager->SetColorSelectFunction(std::ref(m_aColorWrapper));
3818  }
3819 }
3820 
3821 void ColorListBox::SetSlotId(sal_uInt16 nSlotId, bool bShowNoneButton)
3822 {
3823  m_nSlotId = nSlotId;
3824  m_bShowNoneButton = bShowNoneButton;
3825  m_xButton->set_popover(nullptr);
3826  m_xColorWindow.reset();
3827  m_aSelectedColor = bShowNoneButton ? GetNoneColor() : GetAutoColor(m_nSlotId);
3828  ShowPreview(m_aSelectedColor);
3829  createColorWindow();
3830 }
3831 
3832 ColorListBox::ColorListBox(std::unique_ptr<weld::MenuButton> pControl, TopLevelParentFunction const& rTopLevelParentFunction)
3833  : m_xButton(std::move(pControl))
3834  , m_aColorWrapper(this)
3835  , m_aAutoDisplayColor(Application::GetSettings().GetStyleSettings().GetDialogColor())
3836  , m_nSlotId(0)
3837  , m_bShowNoneButton(false)
3838  , m_aTopLevelParentFunction(rTopLevelParentFunction)
3839 {
3840  m_xButton->connect_toggled(LINK(this, ColorListBox, ToggleHdl));
3841  m_aSelectedColor = GetAutoColor(m_nSlotId);
3842  LockWidthRequest();
3843  ShowPreview(m_aSelectedColor);
3844 }
3845 
3846 IMPL_LINK(ColorListBox, ToggleHdl, weld::Toggleable&, rButton, void)
3847 {
3848  if (rButton.get_active())
3849  getColorWindow()->GrabFocus();
3850 }
3851 
3852 ColorListBox::~ColorListBox()
3853 {
3854 }
3855 
3856 ColorWindow* ColorListBox::getColorWindow() const
3857 {
3858  if (!m_xColorWindow)
3859  const_cast<ColorListBox*>(this)->createColorWindow();
3860  return m_xColorWindow.get();
3861 }
3862 
3863 void ColorListBox::createColorWindow()
3864 {
3865  const SfxViewFrame* pViewFrame = SfxViewFrame::Current();
3866  const SfxFrame* pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
3867  css::uno::Reference<css::frame::XFrame> xFrame(pFrame ? pFrame->GetFrameInterface() : uno::Reference<css::frame::XFrame>());
3868 
3869  EnsurePaletteManager();
3870 
3871  m_xColorWindow.reset(new ColorWindow(
3872  OUString() /*m_aCommandURL*/,
3873  m_xPaletteManager,
3874  m_aColorStatus,
3875  m_nSlotId,
3876  xFrame,
3877  m_xButton.get(),
3878  m_aTopLevelParentFunction,
3879  m_aColorWrapper));
3880 
3881  SetNoSelection();
3882  m_xButton->set_popover(m_xColorWindow->getTopLevel());
3883  if (m_bShowNoneButton)
3884  m_xColorWindow->ShowNoneButton();
3885  m_xColorWindow->SelectEntry(m_aSelectedColor);
3886 }
3887 
3888 void ColorListBox::SelectEntry(const NamedColor& rColor)
3889 {
3890  if (rColor.second.trim().isEmpty())
3891  {
3892  SelectEntry(rColor.first);
3893  return;
3894  }
3895  ColorWindow* pColorWindow = getColorWindow();
3896  pColorWindow->SelectEntry(rColor);
3897  m_aSelectedColor = pColorWindow->GetSelectEntryColor();
3898  ShowPreview(m_aSelectedColor);
3899 }
3900 
3901 void ColorListBox::SelectEntry(const Color& rColor)
3902 {
3903  ColorWindow* pColorWindow = getColorWindow();
3904  pColorWindow->SelectEntry(rColor);
3905  m_aSelectedColor = pColorWindow->GetSelectEntryColor();
3906  ShowPreview(m_aSelectedColor);
3907 }
3908 
3909 void ColorListBox::Selected(const NamedColor& rColor)
3910 {
3911  ShowPreview(rColor);
3912  m_aSelectedColor = rColor;
3913  if (m_aSelectedLink.IsSet())
3914  m_aSelectedLink.Call(*this);
3915 }
3916 
3917 //to avoid the box resizing every time the color is changed to
3918 //the optimal size of the individual color, get the longest
3919 //standard color and stick with that as the size for all
3920 void ColorListBox::LockWidthRequest()
3921 {
3922  NamedColor aLongestColor;
3923  tools::Long nMaxStandardColorTextWidth = 0;
3924  XColorListRef const xColorTable = XColorList::CreateStdColorList();
3925  for (tools::Long i = 0; i != xColorTable->Count(); ++i)
3926  {
3927  XColorEntry& rEntry = *xColorTable->GetColor(i);
3928  auto nColorTextWidth = m_xButton->get_pixel_size(rEntry.GetName()).Width();
3929  if (nColorTextWidth > nMaxStandardColorTextWidth)
3930  {
3931  nMaxStandardColorTextWidth = nColorTextWidth;
3932  aLongestColor.second = rEntry.GetName();
3933  }
3934  }
3935  ShowPreview(aLongestColor);
3936  m_xButton->set_size_request(m_xButton->get_preferred_size().Width(), -1);
3937 }
3938 
3939 void ColorListBox::ShowPreview(const NamedColor &rColor)
3940 {
3941  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
3942  Size aImageSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
3943 
3944  ScopedVclPtrInstance<VirtualDevice> xDevice;
3945  xDevice->SetOutputSize(aImageSize);
3946  const tools::Rectangle aRect(Point(0, 0), aImageSize);
3947  if (m_bShowNoneButton && rColor.first == COL_NONE_COLOR)
3948  {
3949  const Color aW(COL_WHITE);
3950  const Color aG(0xef, 0xef, 0xef);
3951  xDevice->DrawCheckered(aRect.TopLeft(), aRect.GetSize(), 8, aW, aG);
3952  xDevice->SetFillColor();
3953  }
3954  else
3955  {
3956  if (rColor.first == COL_AUTO)
3957  xDevice->SetFillColor(m_aAutoDisplayColor);
3958  else
3959  xDevice->SetFillColor(rColor.first);
3960  }
3961 
3962  xDevice->SetLineColor(rStyleSettings.GetDisableColor());
3963  xDevice->DrawRect(aRect);
3964 
3965  m_xButton->set_image(xDevice.get());
3966  m_xButton->set_label(rColor.second);
3967 }
3968 
3969 MenuOrToolMenuButton::MenuOrToolMenuButton(weld::MenuButton* pMenuButton)
3970  : m_pMenuButton(pMenuButton)
3971  , m_pToolbar(nullptr)
3972  , m_pControl(nullptr)
3973  , m_nId(0)
3974 {
3975 }
3976 
3977 MenuOrToolMenuButton::MenuOrToolMenuButton(weld::Toolbar* pToolbar, const OString& rIdent)
3978  : m_pMenuButton(nullptr)
3979  , m_pToolbar(pToolbar)
3980  , m_aIdent(rIdent)
3981  , m_pControl(nullptr)
3982  , m_nId(0)
3983 {
3984 }
3985 
3986 MenuOrToolMenuButton::MenuOrToolMenuButton(SvxColorToolBoxControl* pControl, ToolBox* pToolbar, ToolBoxItemId nId)
3987  : m_pMenuButton(nullptr)
3988  , m_pToolbar(nullptr)
3989  , m_pControl(pControl)
3990  , m_xToolBox(pToolbar)
3991  , m_nId(nId)
3992 {
3993 }
3994 
3995 MenuOrToolMenuButton::~MenuOrToolMenuButton()
3996 {
3997 }
3998 
3999 bool MenuOrToolMenuButton::get_active() const
4000 {
4001  if (m_pMenuButton)
4002  return m_pMenuButton->get_active();
4003  if (m_pToolbar)
4004  return m_pToolbar->get_menu_item_active(m_aIdent);
4005  return m_xToolBox->GetDownItemId() == m_nId;
4006 }
4007 
4008 void MenuOrToolMenuButton::set_inactive() const
4009 {
4010  if (m_pMenuButton)
4011  {
4012  if (m_pMenuButton->get_active())
4013  m_pMenuButton->set_active(false);
4014  return;
4015  }
4016  if (m_pToolbar)
4017  {
4018  if (m_pToolbar->get_menu_item_active(m_aIdent))
4019  m_pToolbar->set_menu_item_active(m_aIdent, false);
4020  return;
4021  }
4022  m_pControl->EndPopupMode();
4023 }
4024 
4025 weld::Widget* MenuOrToolMenuButton::get_widget() const
4026 {
4027  if (m_pMenuButton)
4028  return m_pMenuButton;
4029  if (m_pToolbar)
4030  return m_pToolbar;
4031  return m_xToolBox->GetFrameWeld();
4032 }
4033 
4034 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Color::AsRGBHexString
OUString AsRGBHexString() const
sfx2::sidebar::Sidebar::ShowPanel
static void ShowPanel(std::u16string_view rsPanelId, const css::uno::Reference< css::frame::XFrame > &rxFrame, bool bFocus=false)
SfxStyleSheetBasePool::CreateIterator
virtual std::unique_ptr< SfxStyleSheetIterator > CreateIterator(SfxStyleFamily, SfxStyleSearchBits nMask=SfxStyleSearchBits::All)
ColorWindow::GetSelectEntryColor
static NamedColor GetSelectEntryColor(ValueSet const *pColorSet)
Definition: tbcontrl.cxx:1884
SfxStyleSheetBasePool::First
SfxStyleSheetBase * First(SfxStyleFamily eFamily, SfxStyleSearchBits eMask=SfxStyleSearchBits::All)
NamedColor
std::pair< Color, OUString > NamedColor
Definition: Palette.hxx:29
ValueSet::SetDrawingArea
virtual void SetDrawingArea(weld::DrawingArea *pDrawingArea) override
OutputDevice::GetBackground
const Wallpaper & GetBackground() const
FieldUnit
FieldUnit
FrmValidFlags
FrmValidFlags
Definition: tbcontrl.cxx:2200
nIndex
sal_Int32 nIndex
weld::ComboBox::render_args
std::tuple< vcl::RenderContext &, const tools::Rectangle &, bool, const OUString & > render_args
MenuOrToolMenuButton::m_pControl
SvxColorToolBoxControl * m_pControl
Definition: colorwindow.hxx:62
weld::Toolbar::set_menu_item_active
virtual void set_menu_item_active(const OString &rIdent, bool bActive)=0
SvxStyleToolBoxControl::Impl::m_xWeldBox
std::unique_ptr< SvxStyleBox_Base > m_xWeldBox
Definition: tbcontrl.cxx:2533
svt::ToolboxController::dispose
virtual void SAL_CALL dispose() override
SvxColorToolBoxControl::initialize
virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any > &rArguments) override
Definition: tbcontrl.cxx:3161
MenuOrToolMenuButton::set_inactive
void set_inactive() const
Definition: tbcontrl.cxx:4008
COMBO_WIDTH_IN_CHARS
#define COMBO_WIDTH_IN_CHARS
Definition: tbcontrl.cxx:106
Size::setWidth
void setWidth(tools::Long nWidth)
ImpLineListData::GetDistForWidth
tools::Long GetDistForWidth(tools::Long nWidth)
ToolBox::GetItemBits
ToolBoxItemBits GetItemBits(ToolBoxItemId nItemId) const
WeldToolbarPopup::AddStatusListener
void AddStatusListener(const OUString &rCommandURL)
ListBoxColorWrapper::mpControl
ColorListBox * mpControl
Definition: colorbox.hxx:26
MenuOrToolMenuButton::m_pToolbar
weld::Toolbar * m_pToolbar
Definition: colorwindow.hxx:59
StyleSettings::GetHighlightTextColor
const Color & GetHighlightTextColor() const
pData
std::unique_ptr< ContentProperties > pData
GetValue
std::string GetValue
m_xControl
Reference< XControl > m_xControl
Definition: viewobjectcontactofunocontrol.cxx:137
ToolBox::GetItemCommand
OUString GetItemCommand(ToolBoxItemId nItemId) const
XColorList::CreateStdColorList
static XColorListRef CreateStdColorList()
Definition: xtabcolr.cxx:31
svt::PopupWindowController::getImplementationName
virtual OUString SAL_CALL getImplementationName() override=0
n1
int n1
ValueSet::MouseButtonUp
virtual bool MouseButtonUp(const MouseEvent &rMEvt) override
ColorWindow::maCommand
OUString maCommand
Definition: colorwindow.hxx:85
ValueSet::ValueSet
ValueSet(std::unique_ptr< weld::ScrolledWindow > pScrolledWindow)
tools::Long
long Long
COL_TRANSPARENT
constexpr::Color COL_TRANSPARENT(ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF)
xFrame
Reference< XFrame > xFrame
ColorListBox::SetSlotId
void SetSlotId(sal_uInt16 nSlotId, bool bShowNoneButton=false)
Definition: tbcontrl.cxx:3821
ColorListBox::LockWidthRequest
void LockWidthRequest()
Definition: tbcontrl.cxx:3920
weld::Builder::weld_combo_box
virtual std::unique_ptr< ComboBox > weld_combo_box(const OString &id)=0
AllSettings::GetStyleSettings
const StyleSettings & GetStyleSettings() const
Application::GetSettings
static const AllSettings & GetSettings()
XATTR_FILLSTYLE
constexpr TypedWhichId< XFillStyleItem > XATTR_FILLSTYLE(XATTR_FILL_FIRST)
Color::GetLuminance
sal_uInt8 GetLuminance() const
vcl::CommandInfoProvider::GetLabelForCommand
OUString GetLabelForCommand(const css::uno::Sequence< css::beans::PropertyValue > &rProperties)
COL_AUTO
constexpr::Color COL_AUTO(ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF)
ImpLineListData::GetColorLine1
Color GetColorLine1(const Color &rMain)
ImpLineListData::GetColorLine2
Color GetColorLine2(const Color &rMain)
n
sal_Int64 n
SvxStyleToolBoxControl::pFamilyState
std::unique_ptr< SfxTemplateItem > pFamilyState[MAX_FAMILIES]
Definition: tbcontrl.hxx:190
m_xFrame
css::uno::Reference< css::lang::XComponent > m_xFrame
MenuOrToolMenuButton::m_xToolBox
VclPtr< ToolBox > m_xToolBox
Definition: colorwindow.hxx:63
SvxStyleToolBoxControl::Impl::m_xVclBox
VclPtr< SvxStyleBox_Impl > m_xVclBox
Definition: tbcontrl.cxx:2532
m_pBuilder
weld::Builder * m_pBuilder
nId
sal_Int16 nId
ImpLineListData::GetColorDist
Color GetColorDist(const Color &rMain, const Color &rDefault)
getSupportedServiceNames
css::uno::Sequence< OUString > getSupportedServiceNames()
getImplementationName
OUString getImplementationName()
Application::PostUserEvent
static ImplSVEvent * PostUserEvent(const Link< void *, void > &rLink, void *pCaller=nullptr, bool bReferenceLink=false)
vcl::KeyCode::GetCode
sal_uInt16 GetCode() const
aId
OUString aId
SvtLineListBox::GetLineStyleName
static OUString GetLineStyleName(SvxBorderLineStyle eStyle)
SvxStyleToolBoxControl::SetFamilyState
void SetFamilyState(sal_uInt16 nIdx, const SfxTemplateItem *pItem)
Definition: tbcontrl.cxx:2939
DataChangedEvent::GetType
DataChangedEventType GetType() const
SvxStyleToolBoxControl::update
virtual void SAL_CALL update() override
Definition: tbcontrl.cxx:2741
maColor
basegfx::BColor maColor
StyleSettings::GetLabelTextColor
const Color & GetLabelTextColor() const
ValueSet::GetSelectedItemId
sal_uInt16 GetSelectedItemId() const
SfxObjectShell::Current
static SfxObjectShell * Current()
SvxStyleToolBoxControl::Impl::InitializeStyles
void InitializeStyles(const Reference< frame::XModel > &xModel)
Definition: tbcontrl.cxx:2546
SvxLineItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew)
SvxStyleToolBoxControl::pImpl
std::unique_ptr< Impl > pImpl
Definition: tbcontrl.hxx:158
SvxStyleToolBoxControl::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: tbcontrl.cxx:2718
SvNumberFormatter::GetTheCurrencyTable
static const NfCurrencyTable & GetTheCurrencyTable()
MAX_FAMILIES
#define MAX_FAMILIES
Definition: tbcontrl.hxx:186
StyleSettings::GetListBoxPreviewDefaultPixelSize
const Size & GetListBoxPreviewDefaultPixelSize() const
SvxColorToolBoxControl::SvxColorToolBoxControl
SvxColorToolBoxControl(const css::uno::Reference< css::uno::XComponentContext > &rContext)
Definition: tbcontrl.cxx:3122
SvxColorToolBoxControl::m_xPaletteManager
std::shared_ptr< PaletteManager > m_xPaletteManager
Definition: tbcontrl.hxx:209
SvxColorToolBoxControl::getSubToolbarName
virtual OUString SAL_CALL getSubToolbarName() override
Definition: tbcontrl.cxx:3391
m_xLabel
std::unique_ptr< weld::Label > m_xLabel
ColorWindow::GrabFocus
virtual void GrabFocus() override
Definition: tbcontrl.cxx:1867
MenuOrToolMenuButton::m_pMenuButton
weld::MenuButton * m_pMenuButton
Definition: colorwindow.hxx:57
SvxStyleToolBoxControl::dispose
virtual void SAL_CALL dispose() override
Definition: tbcontrl.cxx:2681
NONE
NONE
SfxObjectShell::GetStyleSheetPool
virtual SfxStyleSheetBasePool * GetStyleSheetPool()
Application::GetDefaultDevice
static OutputDevice * GetDefaultDevice()
Size::Width
constexpr tools::Long Width() const
SvxBorderLineStyle
SvxBorderLineStyle
SvxStyleToolBoxControl::SfxStyleControllerItem_Impl
friend class SfxStyleControllerItem_Impl
Definition: tbcontrl.hxx:197
ColorWindow::SelectValueSetEntry
static bool SelectValueSetEntry(SvxColorValueSet *pColorSet, const Color &rColor)
Definition: tbcontrl.cxx:2050
vcl::Window::GetFrameWeld
weld::Window * GetFrameWeld() const
SvxStyleToolBoxControl::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &rServiceName) override
Definition: tbcontrl.cxx:2723
SvxColorValueSet::getColumnCount
static sal_uInt32 getColumnCount()
Definition: SvxColorValueSet.cxx:46
SvxColorToolBoxControl::updateImage
virtual void SAL_CALL updateImage() override
Definition: tbcontrl.cxx:3386
WinBits
sal_Int64 WinBits
vcl::Window::CreateAccessible
virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible()
vcl::Font::GetItalic
FontItalic GetItalic()
m_xContainer
Reference< XNameAccess > m_xContainer
IMPL_LINK
IMPL_LINK(SvxStyleBox_Base, CustomGetSizeHdl, OutputDevice &, rArg, Size)
Definition: tbcontrl.cxx:872
SvxLineItem::QueryValue
virtual bool QueryValue(css::uno::Any &rVal, sal_uInt8 nMemberId=0) const override
ColorListBox::SetNoSelection
void SetNoSelection()
Definition: colorbox.hxx:69
n2
int n2
vcl::Window::Enable
void Enable(bool bEnable=true, bool bChild=true)
SfxStyleSheetBase::GetName
const OUString & GetName() const
aProperties
PropertiesInfo aProperties
SvxResId
OUString SvxResId(const char *pId)
Definition: dialmgr.cxx:25
Color::DecreaseContrast
void DecreaseContrast(sal_uInt8 cContDec)
pos
size_t pos
OutputDevice::GetFont
const vcl::Font & GetFont() const
WB_ITEMBORDER
#define WB_ITEMBORDER
ColorWindow::mrColorStatus
ColorStatus & mrColorStatus
Definition: colorwindow.hxx:88
ImpLineListData::GetLine2ForWidth
tools::Long GetLine2ForWidth(tools::Long nWidth)
dispatchCommand
bool dispatchCommand(const OUString &rCommand, const uno::Reference< css::frame::XFrame > &rFrame, const css::uno::Sequence< css::beans::PropertyValue > &rArguments, const uno::Reference< css::frame::XDispatchResultListener > &rListener)
SvxStyleToolBoxControl::createItemWindow
virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createItemWindow(const css::uno::Reference< css::awt::XWindow > &rParent) override
Definition: tbcontrl.cxx:2965
VCLUnoHelper::GetWindow
static vcl::Window * GetWindow(const css::uno::Reference< css::awt::XWindow > &rxWindow)
NUMBERFORMAT_ENTRY_NOT_FOUND
constexpr sal_uInt32 NUMBERFORMAT_ENTRY_NOT_FOUND
com_sun_star_comp_svx_CurrencyToolBoxControl_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_svx_CurrencyToolBoxControl_get_implementation(css::uno::XComponentContext *rContext, css::uno::Sequence< css::uno::Any > const &)
Definition: tbcontrl.cxx:3714
ToolBox::SetItemBits
void SetItemBits(ToolBoxItemId nItemId, ToolBoxItemBits nBits)
SfxViewFrame::GetFrame
SfxFrame & GetFrame() const
nCount
int nCount
ColorListBox::Selected
void Selected(const NamedColor &rNamedColor)
Definition: tbcontrl.cxx:3909
InterimItemWindow::GetFocus
virtual void GetFocus() override
DataChangedEvent::GetFlags
AllSettingsFlags GetFlags() const
tools::Rectangle::Bottom
tools::Long Bottom() const
supportsService
bool CPPUHELPER_DLLPUBLIC supportsService(css::lang::XServiceInfo *implementation, rtl::OUString const &name)
lcl_GetDocFontList
static bool lcl_GetDocFontList(const FontList **ppFontList, SvxFontNameBox_Base *pBox)
Definition: tbcontrl.cxx:1387
ImpLineListData::GetLine1ForWidth
tools::Long GetLine1ForWidth(tools::Long nWidth)
tools::Rectangle::GetWidth
constexpr tools::Long GetWidth() const
WeldToolbarPopup::statusChanged
virtual void statusChanged(const css::frame::FeatureStateEvent &Event)
HID_POPUP_LINE
#define HID_POPUP_LINE
Definition: helpids.h:36
svtools::DrawLine
void DrawLine(OutputDevice &rDev, const Point &rP1, const Point &rP2, sal_uInt32 nWidth, SvxBorderLineStyle nDashing)
SvxColorToolBoxControl::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: tbcontrl.cxx:3405
o3tl::strong_int< sal_uInt16, struct ToolBoxItemIdTag >
SfxStyleFamily
SfxStyleFamily
Size::getHeight
constexpr tools::Long getHeight() const
weld::DrawingArea::get_ref_device
virtual OutputDevice & get_ref_device()=0
IMPL_LINK_NOARG
IMPL_LINK_NOARG(SvxStyleBox_Base, ActivateHdl, weld::ComboBox &, bool)
Definition: tbcontrl.cxx:948
ListBoxColorWrapper::operator()
void operator()(const OUString &rCommand, const NamedColor &rColor)
Definition: tbcontrl.cxx:3806
ColorWindow::mxPaletteListBox
std::unique_ptr< weld::ComboBox > mxPaletteListBox
Definition: colorwindow.hxx:94
SfxStyleControllerItem_Impl::StateChanged
virtual void StateChanged(SfxItemState eState, const SfxPoolItem *pState) override
Definition: tbcontrl.cxx:2497
comphelper::InitPropertySequence
css::uno::Sequence< css::beans::PropertyValue > InitPropertySequence(::std::initializer_list< ::std::pair< OUString, css::uno::Any > > vInit)
nCode
sal_uInt16 nCode
SvxStyleToolBoxControl::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: tbcontrl.cxx:2728
ColorWindow::ColorWindow
ColorWindow(const OUString &rCommand, std::shared_ptr< PaletteManager > const &rPaletteManager, ColorStatus &rColorStatus, sal_uInt16 nSlotId, const css::uno::Reference< css::frame::XFrame > &rFrame, const MenuOrToolMenuButton &rMenuButton, TopLevelParentFunction const &rTopLevelParentFunction, ColorSelectFunction const &rColorSelectFunction)
Definition: tbcontrl.cxx:1758
ColorWindow::IsNoSelection
bool IsNoSelection() const
Definition: tbcontrl.cxx:2024
OutputDevice::DrawRect
void DrawRect(const tools::Rectangle &rRect)
typed_flags_set.hxx
SvxFontItem::GetStyleName
const OUString & GetStyleName() const
WeldToolbarPopup::m_xTopLevel
std::unique_ptr< weld::Container > m_xTopLevel
m_nFormatKey
::sal_Int32 m_nFormatKey
svt::ToolboxController::initialize
virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any > &aArguments) override
SvxBoxItem::QueryValue
virtual bool QueryValue(css::uno::Any &rVal, sal_uInt8 nMemberId=0) const override
SvxColorToolBoxControl::functionSelected
virtual void SAL_CALL functionSelected(const OUString &rCommand) override
Definition: tbcontrl.cxx:3396
XPropertyEntry::GetName
const OUString & GetName() const
Definition: XPropertyEntry.hxx:45
SfxShell::GetItem
const SfxPoolItem * GetItem(sal_uInt16 nSlotId) const
ColorListBox::SelectEntry
void SelectEntry(const NamedColor &rColor)
Definition: tbcontrl.cxx:3888
svt::PopupWindowController::weldPopupWindow
virtual std::unique_ptr< WeldToolbarPopup > weldPopupWindow()
StyleSettings::GetDisableColor
const Color & GetDisableColor() const
Right
Right
ColorWindow::mxButtonPicker
std::unique_ptr< weld::Button > mxButtonPicker
Definition: colorwindow.hxx:97
ColorListBox::m_aTopLevelParentFunction
TopLevelParentFunction m_aTopLevelParentFunction
Definition: colorbox.hxx:43
com_sun_star_comp_svx_StyleToolBoxControl_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_svx_StyleToolBoxControl_get_implementation(css::uno::XComponentContext *, css::uno::Sequence< css::uno::Any > const &)
Definition: tbcontrl.cxx:2734
COL_NONE_COLOR
#define COL_NONE_COLOR
Definition: colorwindow.hxx:49
DBG_ASSERT
#define DBG_ASSERT(sCon, aError)
Color::DecreaseLuminance
void DecreaseLuminance(sal_uInt8 cLumDec)
SvxStyleToolBoxControl::initialize
virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any > &aArguments) override
Definition: tbcontrl.cxx:2659
i
int i
a
uno_Any a
m_xListener
Reference< XTextListener > m_xListener
Definition: formcontroller.cxx:719
Color::IsDark
bool IsDark() const
SvxColorToolBoxControl::createVclPopupWindow
virtual VclPtr< vcl::Window > createVclPopupWindow(vcl::Window *pParent) override
Definition: tbcontrl.cxx:3267
ColorWindow::mxButtonNoneColor
std::unique_ptr< weld::Button > mxButtonNoneColor
Definition: colorwindow.hxx:96
ColorWindow::mxRecentColorSet
std::unique_ptr< SvxColorValueSet > mxRecentColorSet
Definition: colorwindow.hxx:93
sName
OUString sName
Definition: formcontroller.cxx:211
OutputDevice::approximate_digit_width
float approximate_digit_width() const
SfxStyleControllerItem_Impl
Definition: tbcontrl.cxx:815
LANGUAGE_SYSTEM
#define LANGUAGE_SYSTEM
GetLanguage
LanguageType GetLanguage(SwWrtShell &rSh, sal_uInt16 nLangWhichId)
HID_POPUP_COLOR_CTRL
#define HID_POPUP_COLOR_CTRL
Definition: helpids.h:34
SvxStyleToolBoxControl::m_xBoundItems
rtl::Reference< SfxStyleControllerItem_Impl > m_xBoundItems[MAX_FAMILIES]
Definition: tbcontrl.hxx:189
SvxColorToolBoxControl::m_aColorStatus
ColorStatus m_aColorStatus
Definition: tbcontrl.hxx:210
MenuOrToolMenuButton::m_nId
ToolBoxItemId m_nId
Definition: colorwindow.hxx:64
Color::IsBright
bool IsBright() const
ColorWindow::mpDefaultButton
weld::Button * mpDefaultButton
Definition: colorwindow.hxx:101
legacy::SvxOrientation::Create
void Create(SvxOrientationItem &rItem, SvStream &rStrm, sal_uInt16)
Definition: legacyitem.cxx:34
Application::GetFrameWeld
static weld::Window * GetFrameWeld(const css::uno::Reference< css::awt::XWindow > &rWindow)
Wallpaper::GetColor
const Color & GetColor() const
SvxColorToolBoxControl::weldPopupWindow
virtual std::unique_ptr< WeldToolbarPopup > weldPopupWindow() override
Definition: tbcontrl.cxx:3245
SvxBoxInfoItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxInfoItemLine nLine)
ColorWindow::mxAutomaticSeparator
std::unique_ptr< weld::Widget > mxAutomaticSeparator
Definition: colorwindow.hxx:98
weld::Toggleable::set_active
virtual void set_active(bool active)=0
OutputDevice::SetFillColor
void SetFillColor()
svt::PopupWindowController::createVclPopupWindow
virtual VclPtr< vcl::Window > createVclPopupWindow(vcl::Window *pParent)=0
o3tl::make_unsigned
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
StyleSettings::GetFieldColor
const Color & GetFieldColor() const
ApplyLreOrRleEmbedding
OUString ApplyLreOrRleEmbedding(const OUString &rText)
WeldToolbarPopup::DECL_LINK
DECL_LINK(FocusHdl, weld::Widget &, void)
SvxColorToolBoxControl::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: tbcontrl.cxx:3400
u
float u
sal_Bool
unsigned char sal_Bool
OutputDevice::SetTextColor
void SetTextColor(const Color &rColor)
ColorWindow::mxPaletteManager
std::shared_ptr< PaletteManager > mxPaletteManager
Definition: colorwindow.hxx:87
ValueSet::GetItemText
OUString GetItemText(sal_uInt16 nItemId) const
o3tl::is_typed_flags
SvxColorToolBoxControl::statusChanged
virtual void SAL_CALL statusChanged(const css::frame::FeatureStateEvent &rEvent) override
Definition: tbcontrl.cxx:3306
ColorWindow::ShowNoneButton
void ShowNoneButton()
Definition: tbcontrl.cxx:1875
SvxStyleToolBoxControl::Impl::aDefaultStyles
::std::vector< std::pair< OUString, OUString > > aDefaultStyles
Definition: tbcontrl.cxx:2528
ITALIC_NONE
ITALIC_NONE
MouseEvent::GetModifier
sal_uInt16 GetModifier() const
json_writer.hxx
SfxTemplateItem::GetStyleName
const OUString & GetStyleName() const
FontPitch
FontPitch
ColorWindow::mxButtonAutoColor
std::unique_ptr< weld::Button > mxButtonAutoColor
Definition: colorwindow.hxx:95
SvxStyleToolBoxControl::GetActFamily
SfxStyleFamily GetActFamily() const
Definition: tbcontrl.cxx:2748
ITEM_HEIGHT
#define ITEM_HEIGHT
Definition: tbcontrl.cxx:831
TopLevelParentFunction
std::function< weld::Window *()> TopLevelParentFunction
Definition: colorwindow.hxx:29
ImpLineListData::GetStyle
SvxBorderLineStyle GetStyle() const
style
exports com.sun.star. style
ColorListBox::m_aColorStatus
ColorStatus m_aColorStatus
Definition: colorbox.hxx:44
SfxFrame::GetFrameInterface
const css::uno::Reference< css::frame::XFrame > & GetFrameInterface() const
vcl::Window::Disable
void Disable(bool bChild=true)
StyleSlotToStyleCommand
static const char * StyleSlotToStyleCommand[MAX_FAMILIES]
Definition: tbcontrl.cxx:2634
ColorWindow::theSlotId
const sal_uInt16 theSlotId
Definition: colorwindow.hxx:84
OutputDevice::GetDPIScaleFactor
float GetDPIScaleFactor() const
ColorListBox::createColorWindow
void createColorWindow()
Definition: tbcontrl.cxx:3863
tools::Rectangle::TopLeft
constexpr Point TopLeft() const
ColorWindow::~ColorWindow
virtual ~ColorWindow() override
Definition: tbcontrl.cxx:1880
SvxColorToolBoxControl::m_aColorSelectFunction
ColorSelectFunction m_aColorSelectFunction
Definition: tbcontrl.hxx:213
SvxColorToolBoxControl::execute
virtual void SAL_CALL execute(sal_Int16 nSelectModifier) override
Definition: tbcontrl.cxx:3336
MenuOrToolMenuButton::MenuOrToolMenuButton
MenuOrToolMenuButton(weld::MenuButton *pMenuButton)
Definition: tbcontrl.cxx:3969
HID_POPUP_COLOR
#define HID_POPUP_COLOR
Definition: helpids.h:33
FontList::GetFontNameCount
size_t GetFontNameCount() const
ToolBox::EnableItem
void EnableItem(ToolBoxItemId nItemId, bool bEnable=true)
ColorListBox::m_aSelectedColor
NamedColor m_aSelectedColor
Definition: colorbox.hxx:39
ValueSet::SelectItem
void SelectItem(sal_uInt16 nItemId)
OutputDevice::LogicToPixel
Point LogicToPixel(const Point &rLogicPt) const
SfxStyleControllerItem_Impl::SfxStyleControllerItem_Impl
SfxStyleControllerItem_Impl(const Reference< XDispatchProvider > &rDispatchProvider, sal_uInt16 nSlotId, const OUString &rCommand, SvxStyleToolBoxControl &rTbxCtl)
Definition: tbcontrl.cxx:2487
SvxColorToolBoxControl::GetParentFrame
weld::Window * GetParentFrame() const
Definition: tbcontrl.cxx:3239
getLocale
const LanguageTag & getLocale()
ValueSet::operator=
ValueSet & operator=(const ValueSet &)=delete
WB_3DLOOK
WinBits const WB_3DLOOK
vcl::CommandInfoProvider::GetCommandProperties
Sequence< beans::PropertyValue > GetCommandProperties(const OUString &rsCommandName, const OUString &rsModuleName)
FontFamily
FontFamily
SvxColorToolBoxControl::m_xBtnUpdater
std::unique_ptr< svx::ToolboxButtonColorUpdaterBase > m_xBtnUpdater
Definition: tbcontrl.hxx:208
Fill
Fill
ColorListBox::ColorListBox
ColorListBox(std::unique_ptr< weld::MenuButton > pControl, TopLevelParentFunction const &rTopLevelParentFunction)
Definition: tbcontrl.cxx:3832
SvxFontItem::GetFamilyName
const OUString & GetFamilyName() const
XATTR_FILLCOLOR
constexpr TypedWhichId< XFillColorItem > XATTR_FILLCOLOR(XATTR_FILL_FIRST+1)
KeyEvent::GetKeyCode
const vcl::KeyCode & GetKeyCode() const
ImpLineListData::GetMinWidth
tools::Long GetMinWidth() const
SvxColorToolBoxControl::~SvxColorToolBoxControl
virtual ~SvxColorToolBoxControl() override
Definition: tbcontrl.cxx:3226
tools::Rectangle::GetSize
constexpr Size GetSize() const
lcl_mediumColor
static Color lcl_mediumColor(Color aMain, Color)
Definition: tbcontrl.cxx:2395
ColorListBox::EnsurePaletteManager
void EnsurePaletteManager()
Definition: tbcontrl.cxx:3812
SfxViewFrame::Current
static SfxViewFrame * Current()
SetNone
void SetNone(tools::Long &nPageLeftMargin, tools::Long &nPageRightMargin, tools::Long &nPageTopMargin, tools::Long &nPageBottomMargin, bool &bMirrored)
SfxItemState
SfxItemState
WB_NO_DIRECTSELECT
#define WB_NO_DIRECTSELECT
ListBoxColorWrapper::ListBoxColorWrapper
ListBoxColorWrapper(ColorListBox *pControl)
Definition: tbcontrl.cxx:3801
SvxStyleToolBoxControl::SelectStyle
void SelectStyle(const OUString &rStyleName)
Definition: tbcontrl.cxx:2866
SvxColorValueSet::getMaxRowCount
static constexpr sal_uInt32 getMaxRowCount()
Definition: SvxColorValueSet.hxx:37
MenuOrToolMenuButton::get_active
bool get_active() const
Definition: tbcontrl.cxx:3999
ValueSet::GetItemCount
size_t GetItemCount() const
svt::PopupWindowController::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override=0
Size::Height
constexpr tools::Long Height() const
ITALIC_NORMAL
ITALIC_NORMAL
sal_uInt8
unsigned char sal_uInt8
ColorListBox::m_xColorWindow
std::unique_ptr< ColorWindow > m_xColorWindow
Definition: colorbox.hxx:33
EditResId
OUString EditResId(const char *pId)
KEY_ESCAPE
constexpr sal_uInt16 KEY_ESCAPE
OutputDevice::SetFont
void SetFont(const vcl::Font &rNewFont)
weld::Widget::grab_focus
virtual void grab_focus()=0
SfxStyleSheetBasePool::Next
SfxStyleSheetBase * Next()
InterimItemWindow::dispose
virtual void dispose() override
COL_WHITE
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_WHITE
SfxObjectShell::GetMapUnit
MapUnit GetMapUnit() const
OutputDevice::GetTextHeight
tools::Long GetTextHeight() const
aName
OUString aName
ColorListBox::m_aAutoDisplayColor
Color m_aAutoDisplayColor
Definition: colorbox.hxx:37
if
if(aStr!=aBuf) UpdateName_Impl(m_xFollowLb.get()
ColorListBox::getColorWindow
ColorWindow * getColorWindow() const
Definition: tbcontrl.cxx:3856
SvxStyleToolBoxControl::~SvxStyleToolBoxControl
virtual ~SvxStyleToolBoxControl() override
Definition: tbcontrl.cxx:2655
SvxColorToolBoxControl::opensSubToolbar
virtual sal_Bool SAL_CALL opensSubToolbar() override
Definition: tbcontrl.cxx:3378
Size::AdjustWidth
tools::Long AdjustWidth(tools::Long n)
HID_STYLE_LISTBOX
#define HID_STYLE_LISTBOX
Definition: helpids.h:39
ColorStatus::GetColor
Color GetColor()
Definition: tbcontrl.cxx:2138
VclPtr::Create
static VclPtr< reference_type > Create(Arg &&...arg)
ColorListBox::m_xPaletteManager
std::shared_ptr< PaletteManager > m_xPaletteManager
Definition: colorbox.hxx:42
ColorWindow::SelectEntry
void SelectEntry(const NamedColor &rColor)
Definition: tbcontrl.cxx:2063
ColorListBox::m_aSelectedLink
Link< ColorListBox &, void > m_aSelectedLink
Definition: colorbox.hxx:35
SvxColorToolBoxControl::update
virtual void SAL_CALL update() override
Definition: tbcontrl.cxx:3196
SvxColorToolBoxControl::setColorSelectFunction
void setColorSelectFunction(const ColorSelectFunction &aColorSelectFunction)
Definition: tbcontrl.cxx:3232
comphelper::getProcessComponentContext
Reference< XComponentContext > getProcessComponentContext()
COL_BLACK
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_BLACK
comphelper::ConfigurationListenerProperty::setProperty
virtual void setProperty(const css::uno::Any &aProperty) override
SvxStyleToolBoxControl::pStyleSheetPool
SfxStyleSheetBasePool * pStyleSheetPool
Definition: tbcontrl.hxx:188
SvxBoxInfoItem::QueryValue
virtual bool QueryValue(css::uno::Any &rVal, sal_uInt8 nMemberId=0) const override
o3tl::typed_flags
ColorWindow::statusChanged
virtual void statusChanged(const css::frame::FeatureStateEvent &rEvent) override
Definition: tbcontrl.cxx:2033
StyleSettings::GetWindowColor
const Color & GetWindowColor() const
ColorListBox::m_bShowNoneButton
bool m_bShowNoneButton
Definition: colorbox.hxx:41
ColorListBox::m_nSlotId
sal_uInt16 m_nSlotId
Definition: colorbox.hxx:40
com_sun_star_comp_svx_FrameToolBoxControl_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_svx_FrameToolBoxControl_get_implementation(css::uno::XComponentContext *rContext, css::uno::Sequence< css::uno::Any > const &)
Definition: tbcontrl.cxx:3496
Size::AdjustHeight
tools::Long AdjustHeight(tools::Long n)
weld::Toolbar::get_menu_item_active
virtual bool get_menu_item_active(const OString &rIdent) const =0
SfxViewFrame::ShowChildWindow
void ShowChildWindow(sal_uInt16, bool bVisible=true)
WB_TABSTOP
WinBits const WB_TABSTOP
SvtLanguageTable::GetLanguageString
static OUString GetLanguageString(const LanguageType eType)
OutputDevice::GetTextBoundRect
bool GetTextBoundRect(tools::Rectangle &rRect, const OUString &rStr, sal_Int32 nBase=0, sal_Int32 nIndex=0, sal_Int32 nLen=-1, sal_uLong nLayoutWidth=0, const tools::Long *pDXArray=nullptr, const SalLayoutGlyphs *pGlyphs=nullptr) const
vcl::Font::SetItalic
void SetItalic(FontItalic)
Size::setHeight
void setHeight(tools::Long nHeight)
ColorSelectFunction
std::function< void(const OUString &, const NamedColor &)> ColorSelectFunction
Definition: Palette.hxx:33
sId
OUString sId
SvxBoxInfoItem::SetValid
void SetValid(SvxBoxInfoItemValidFlags nValid, bool bValid=true)
ColorListBox::m_aColorWrapper
ListBoxColorWrapper m_aColorWrapper
Definition: colorbox.hxx:36
SAL_WARN
#define SAL_WARN(area, stream)
NfWSStringsDtor
std::vector< OUString > NfWSStringsDtor
aCommand
OUString aCommand
Size::getWidth
constexpr tools::Long getWidth() const
ColorStatus::maTLBRColor
Color maTLBRColor
Definition: colorwindow.hxx:38
SfxStyleSheetBase::GetItemSetForPreview
virtual std::unique_ptr< SfxItemSet > GetItemSetForPreview()
IMPL_STATIC_LINK_NOARG
IMPL_STATIC_LINK_NOARG(SvxStyleBox_Base, ShowMoreHdl, void *, void)
Definition: tbcontrl.cxx:933
DEF_LINE_WIDTH_0
#define DEF_LINE_WIDTH_0
Left
Left
ColorWindow::mxColorSet
std::unique_ptr< SvxColorValueSet > mxColorSet
Definition: colorwindow.hxx:92
HID_POPUP_FRAME
#define HID_POPUP_FRAME
Definition: helpids.h:35
SvxFontListItem::GetFontList
const FontList * GetFontList() const
NfCurrencyTable::size
size_t size() const
m_xWidget
std::unique_ptr< weld::Image > m_xWidget
dispose
void dispose()
MAX_MRU_FONTNAME_ENTRIES
#define MAX_MRU_FONTNAME_ENTRIES
Definition: tbcontrl.cxx:104
WB_FLATVALUESET
#define WB_FLATVALUESET
SvxStyleToolBoxControl::Impl::m_pBox
SvxStyleBox_Base * m_pBox
Definition: tbcontrl.cxx:2534
KEY_SHIFT
constexpr sal_uInt16 KEY_SHIFT
VCLUnoHelper::GetInterface
static css::uno::Reference< css::awt::XWindow > GetInterface(vcl::Window *pWindow)
BitmapEx::GetSizePixel
const Size & GetSizePixel() const
StyleSettings::GetDialogTextColor
const Color & GetDialogTextColor() const
ToolBox::CheckItem
void CheckItem(ToolBoxItemId nItemId, bool bCheck=true)
weld::Widget::set_size_request
virtual void set_size_request(int nWidth, int nHeight)=0
com_sun_star_comp_svx_ColorToolBoxControl_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_svx_ColorToolBoxControl_get_implementation(css::uno::XComponentContext *rContext, css::uno::Sequence< css::uno::Any > const &)
Definition: tbcontrl.cxx:3411
OutputDevice::Push
void Push(PushFlags nFlags=PushFlags::ALL)
ColorWindow::GetSelectEntryColor
NamedColor GetSelectEntryColor() const
Definition: tbcontrl.cxx:1937
ColorStatus::statusChanged
void statusChanged(const css::frame::FeatureStateEvent &rEvent)
Definition: tbcontrl.cxx:2115
OutputDevice::DrawText
void DrawText(const Point &rStartPt, const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, std::vector< tools::Rectangle > *pVector=nullptr, OUString *pDisplayText=nullptr, const SalLayoutGlyphs *pLayoutCache=nullptr)
WeldToolbarPopup::GrabFocus
virtual void GrabFocus()=0
ColorStatus::maBLTRColor
Color maBLTRColor
Definition: colorwindow.hxx:39
ColorListBox::m_xButton
std::unique_ptr< weld::MenuButton > m_xButton
Definition: colorbox.hxx:34
ColorWindow::GetAutoColor
NamedColor GetAutoColor() const
Definition: tbcontrl.cxx:1979
weld::Toggleable::get_active
virtual bool get_active() const =0
aStr
aStr
SfxToolBoxControl::Dispatch
void Dispatch(const OUString &aCommand, css::uno::Sequence< css::beans::PropertyValue > const &aArgs)
BUTTON_PADDING
#define BUTTON_PADDING
Definition: tbcontrl.cxx:830
SvxStyleToolBoxControl::statusChanged
virtual void SAL_CALL statusChanged(const css::frame::FeatureStateEvent &rEvent) override
Definition: tbcontrl.cxx:2946
GetCaseMap
sal_Int16 GetCaseMap(sal_Int32 nToken)
ValueSet::GetItemColor
Color GetItemColor(sal_uInt16 nItemId) const
SvxBoxItem::LineToSvxLine
static bool LineToSvxLine(const css::table::BorderLine &rLine, editeng::SvxBorderLine &rSvxLine, bool bConvert)
nPos
sal_uInt16 nPos
com_sun_star_comp_svx_FontNameToolBoxControl_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_svx_FontNameToolBoxControl_get_implementation(css::uno::XComponentContext *, css::uno::Sequence< css::uno::Any > const &)
Definition: tbcontrl.cxx:3115
SfxStyleControllerItem_Impl::rControl
SvxStyleToolBoxControl & rControl
Definition: tbcontrl.cxx:827
ToolBox::GetDownItemId
ToolBoxItemId GetDownItemId() const
KEY_TAB
constexpr sal_uInt16 KEY_TAB
ColorListBox::ShowPreview
void ShowPreview(const NamedColor &rColor)
Definition: tbcontrl.cxx:3939
vcl::Window::DataChanged
virtual void DataChanged(const DataChangedEvent &rDCEvt)
ColorWindow::SetNoSelection
void SetNoSelection()
Definition: tbcontrl.cxx:2017
LanguageTag::convertToLocale
static css::lang::Locale convertToLocale(LanguageType nLangID, bool bResolveSystem=true)
CONVERT_TWIPS
#define CONVERT_TWIPS
tools::Rectangle::GetHeight
constexpr tools::Long GetHeight() const
MenuOrToolMenuButton::get_widget
weld::Widget * get_widget() const
Definition: tbcontrl.cxx:4025
SvxBoxItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxItemLine nLine)
Generated on Fri Jun 11 2021 11:05:45 for LibreOffice Module svx (master) by   doxygen 1.8.10