/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name tbcontrl.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx

/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <typeinfo>
21#include <utility>

23#include <comphelper/configurationlistener.hxx>
24#include <comphelper/propertysequence.hxx>
25#include <tools/color.hxx>
26#include <svl/poolitem.hxx>
27#include <svl/itemset.hxx>
28#include <vcl/commandinfoprovider.hxx>
29#include <vcl/event.hxx>
30#include <vcl/toolbox.hxx>
31#include <vcl/customweld.hxx>
32#include <vcl/vclptr.hxx>
33#include <vcl/weldutils.hxx>
34#include <svtools/valueset.hxx>
35#include <svtools/ctrlbox.hxx>
36#include <svl/style.hxx>
37#include <svtools/ctrltool.hxx>
38#include <svtools/borderhelper.hxx>
39#include <vcl/InterimItemWindow.hxx>
40#include <sfx2/tbxctrl.hxx>
41#include <sfx2/tplpitem.hxx>
42#include <sfx2/sfxstatuslistener.hxx>
43#include <toolkit/helper/vclunohelper.hxx>
44#include <sfx2/viewfrm.hxx>
45#include <vcl/svapp.hxx>
46#include <vcl/settings.hxx>
47#include <vcl/virdev.hxx>
48#include <com/sun/star/awt/FontDescriptor.hpp>
49#include <com/sun/star/table/BorderLine2.hpp>
50#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
51#include <com/sun/star/lang/XServiceInfo.hpp>
52#include <com/sun/star/beans/XPropertySet.hpp>
53#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
54#include <com/sun/star/frame/XDispatchProvider.hpp>
55#include <com/sun/star/frame/XFrame.hpp>
56#include <svx/strings.hrc>
57#include <svx/svxids.hrc>
58#include <helpids.h>
59#include <sfx2/sidebar/Sidebar.hxx>
60#include <sfx2/sidebar/SidebarToolBox.hxx>
61#include <svx/xtable.hxx>
62#include <editeng/editids.hrc>
63#include <editeng/fontitem.hxx>
64#include <editeng/fhgtitem.hxx>
65#include <editeng/boxitem.hxx>
66#include <editeng/charreliefitem.hxx>
67#include <editeng/contouritem.hxx>
68#include <editeng/colritem.hxx>
69#include <editeng/crossedoutitem.hxx>
70#include <editeng/emphasismarkitem.hxx>
71#include <editeng/flstitem.hxx>
72#include <editeng/lineitem.hxx>
73#include <editeng/postitem.hxx>
74#include <editeng/shdditem.hxx>
75#include <editeng/udlnitem.hxx>
76#include <editeng/wghtitem.hxx>
77#include <editeng/svxfont.hxx>
78#include <editeng/cmapitem.hxx>
79#include <svx/colorwindow.hxx>
80#include <svx/colorbox.hxx>
81#include <svx/tbcontrl.hxx>
82#include <svx/dialmgr.hxx>
83#include <svx/PaletteManager.hxx>
84#include <memory>

86#include <tbxcolorupdate.hxx>
87#include <editeng/eerdll.hxx>
88#include <editeng/editrids.hrc>
89#include <svx/xdef.hxx>
90#include <svx/xfillit0.hxx>
91#include <svx/xflclit.hxx>
92#include <svl/currencytable.hxx>
93#include <svtools/langtab.hxx>
94#include <cppu/unotype.hxx>
95#include <cppuhelper/supportsservice.hxx>
96#include <officecfg/Office/Common.hxx>
97#include <o3tl/safeint.hxx>
98#include <o3tl/typed_flags_set.hxx>
99#include <bitmaps.hlst>
100#include <sal/log.hxx>
101#include <unotools/collatorwrapper.hxx>

103#include <comphelper/lok.hxx>
104#include <tools/json_writer.hxx>

106#define MAX_MRU_FONTNAME_ENTRIES5    5

108#define COMBO_WIDTH_IN_CHARS18        18

110// namespaces
111using namespace ::editeng;
112using namespace ::com::sun::star;
113using namespace ::com::sun::star::uno;
114using namespace ::com::sun::star::frame;
115using namespace ::com::sun::star::beans;
116using namespace ::com::sun::star::lang;

118namespace
119{
120class SvxStyleBox_Base
121{
122public:
  SvxStyleBox_Base(std::unique_ptr<weld::ComboBox> xWidget, const OUString& rCommand, SfxStyleFamily eFamily,
                   const Reference<XDispatchProvider>& rDispatchProvider,
                   const Reference<XFrame>& _xFrame,const OUString& rClearFormatKey,
                   const OUString& rMoreKey, bool bInSpecialMode, SvxStyleToolBoxControl& rCtrl);

  virtual ~SvxStyleBox_Base()
  {
  }

  void            SetFamily( SfxStyleFamily eNewFamily );

  void            SetDefaultStyle( const OUString& rDefault ) { sDefaultStyle = rDefault; }

  int get_count() const { return m_xWidget->get_count(); }
  OUString get_text(int nIndex) const { return m_xWidget->get_text(nIndex); }
  OUString get_active_text() const { return m_xWidget->get_active_text(); }

  void append_text(const OUString& rStr)
  {
      OUString sId(OUString::number(m_xWidget->get_count()));
      m_xWidget->append(sId, rStr);
  }

  void insert_separator(int pos, const OUString& rId)
  {
      m_xWidget->insert_separator(pos, rId);
  }

  void set_active_or_entry_text(const OUString& rText)
  {
      const int nFound = m_xWidget->find_text(rText);
      if (nFound != -1)
          m_xWidget->set_active(nFound);
      else
          m_xWidget->set_entry_text(rText);
  }

  void set_active(int nActive)
  {
      m_xWidget->set_active(nActive);
  }

  void freeze()
  {
      m_xWidget->freeze();
  }

  void save_value()
  {
      m_xWidget->save_value();
  }

  void clear()
  {
      m_xWidget->clear();
      m_nMaxUserDrawFontWidth = 0;
  }

  void thaw()
  {
      m_xWidget->thaw();
  }

  virtual bool DoKeyInput(const KeyEvent& rKEvt);

188private:
  DECL_LINK(SelectHdl, weld::ComboBox&, void)static void LinkStubSelectHdl(void *, weld::ComboBox&); void
 SelectHdl(weld::ComboBox&);
  DECL_LINK(KeyInputHdl, const KeyEvent&, bool)static bool LinkStubKeyInputHdl(void *, const KeyEvent&);
 bool KeyInputHdl(const KeyEvent&);
  DECL_LINK(ActivateHdl, weld::ComboBox&, bool)static bool LinkStubActivateHdl(void *, weld::ComboBox&);
 bool ActivateHdl(weld::ComboBox&);
  DECL_LINK(FocusOutHdl, weld::Widget&, void)static void LinkStubFocusOutHdl(void *, weld::Widget&); void
 FocusOutHdl(weld::Widget&);
  DECL_LINK(DumpAsPropertyTreeHdl, tools::JsonWriter&, void)static void LinkStubDumpAsPropertyTreeHdl(void *, tools::JsonWriter
&); void DumpAsPropertyTreeHdl(tools::JsonWriter&);
  DECL_LINK(CustomRenderHdl, weld::ComboBox::render_args, void)static void LinkStubCustomRenderHdl(void *, weld::ComboBox::render_args
); void CustomRenderHdl(weld::ComboBox::render_args);
  DECL_LINK(CustomGetSizeHdl, OutputDevice&, Size)static Size LinkStubCustomGetSizeHdl(void *, OutputDevice&
); Size CustomGetSizeHdl(OutputDevice&);

  /// Calculate the optimal width of the dropdown.  Very expensive operation, triggers lots of font measurement.
  void CalcOptimalExtraUserWidth(vcl::RenderContext& rRenderContext);

  void Select(bool bNonTravelSelect);

202protected:
  SvxStyleToolBoxControl& m_rCtrl;

  std::unique_ptr<weld::Builder>  m_xMenuBuilder;
  std::unique_ptr<weld::Menu>     m_xMenu;
  std::unique_ptr<weld::ComboBox> m_xWidget;

  SfxStyleFamily                  eStyleFamily;
  int                             m_nMaxUserDrawFontWidth;
  bool                            bRelease;
  Reference< XDispatchProvider >  m_xDispatchProvider;
  Reference< XFrame >             m_xFrame;
  OUString                        m_aCommand;
  OUString                        aClearFormatKey;
  OUString                        aMoreKey;
  OUString                        sDefaultStyle;
  bool                            bInSpecialMode;

  void            ReleaseFocus();
  static Color    TestColorsVisible(const Color &FontCol, const Color &BackCol);
  static void     UserDrawEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const OUString &rStyleName);
  void            SetupEntry(vcl::RenderContext& rRenderContext, sal_Int32 nItem, const tools::Rectangle& rRect, const OUString& rStyleName, bool bIsNotSelected);
  static bool     AdjustFontForItemHeight(OutputDevice& rDevice, tools::Rectangle const & rTextRect, long nHeight);
  DECL_LINK(MenuSelectHdl, const OString&, void)static void LinkStubMenuSelectHdl(void *, const OString&)
; void MenuSelectHdl(const OString&);
  DECL_STATIC_LINK(SvxStyleBox_Base, ShowMoreHdl, void*, void)static void LinkStubShowMoreHdl(void *, void*); static void ShowMoreHdl
(SvxStyleBox_Base *, void*);
227};

229class SvxStyleBox_Impl final : public InterimItemWindow
                           , public SvxStyleBox_Base
231{
232public:
  SvxStyleBox_Impl(vcl::Window* pParent, const OUString& rCommand, SfxStyleFamily eFamily, const Reference< XDispatchProvider >& rDispatchProvider,
                   const Reference< XFrame >& _xFrame,const OUString& rClearFormatKey, const OUString& rMoreKey, bool bInSpecialMode, SvxStyleToolBoxControl& rCtrl);

  virtual ~SvxStyleBox_Impl() override
  {
      disposeOnce();
  }

  virtual void dispose() override
  {
      m_xWidget.reset();
      m_xMenu.reset();
      m_xMenuBuilder.reset();
      InterimItemWindow::dispose();
  }

  virtual bool DoKeyInput(const KeyEvent& rKEvt) override;

251private:

  virtual void DataChanged(const DataChangedEvent& rDCEvt) override;
  void  SetOptimalSize();
255};

257class SvxFontNameBox_Impl;
258class SvxFontNameBox_Base;

260class SvxFontNameToolBoxControl final : public cppu::ImplInheritanceHelper<svt::ToolboxController,
                                                                         css::lang::XServiceInfo>
262{
263public:
  SvxFontNameToolBoxControl();

  // XStatusListener
  virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;

  // XToolbarController
  virtual css::uno::Reference<css::awt::XWindow> SAL_CALL createItemWindow(const css::uno::Reference<css::awt::XWindow>& rParent) override;

  // XComponent
  virtual void SAL_CALL dispose() override;

  // XServiceInfo
  virtual OUString SAL_CALL getImplementationName() override;
  virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
  virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;

280private:
  VclPtr<SvxFontNameBox_Impl> m_xVclBox;
  std::unique_ptr<SvxFontNameBox_Base> m_xWeldBox;
  SvxFontNameBox_Base* m_pBox;
284};

286class FontOptionsListener final : public comphelper::ConfigurationListenerProperty<bool>
287{
288private:
  SvxFontNameBox_Base& m_rBox;

  virtual void setProperty(const css::uno::Any &rProperty) override;
292public:
  FontOptionsListener(const rtl::Reference<comphelper::ConfigurationListener>& rListener, const OUString& rProp, SvxFontNameBox_Base& rBox)
      : comphelper::ConfigurationListenerProperty<bool>(rListener, rProp)
      , m_rBox(rBox)
  {
  }
298};

300class SvxFontNameBox_Base
301{
302private:
  rtl::Reference<comphelper::ConfigurationListener> m_xListener;
  FontOptionsListener m_aWYSIWYG;
  FontOptionsListener m_aHistory;

307protected:
  SvxFontNameToolBoxControl& m_rCtrl;

  std::unique_ptr<FontNameBox>   m_xWidget;
  const FontList*                pFontList;
  ::std::unique_ptr<FontList>    m_aOwnFontList;
  vcl::Font                      aCurFont;
  sal_uInt16                     nFtCount;
  bool                           bRelease;
  Reference< XDispatchProvider > m_xDispatchProvider;
  Reference< XFrame >            m_xFrame;
  bool            mbCheckingUnknownFont;

  void            ReleaseFocus_Impl();

  void            Select(bool bNonTravelSelect);

  void            EndPreview()
  {
      Sequence< PropertyValue > aArgs;
      SfxToolBoxControl::Dispatch( m_xDispatchProvider,
                                       ".uno:CharEndPreviewFontName",
                                       aArgs );
  }
  void            CheckAndMarkUnknownFont();

333public:
  SvxFontNameBox_Base(std::unique_ptr<weld::ComboBox> xWidget, const Reference<XDispatchProvider>& rDispatchProvider,
                      const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl);
  virtual ~SvxFontNameBox_Base()
  {
      m_xListener->dispose();
  }

  void            FillList();
  void            Update( const css::awt::FontDescriptor* pFontDesc );
  sal_uInt16      GetListCount() const { return nFtCount; }
  void            Clear() { m_xWidget->clear(); nFtCount = 0; }
  void            Fill( const FontList* pList )
  {
      m_xWidget->Fill(pList);
      nFtCount = pList->GetFontNameCount();
  }

  void SetOwnFontList(::std::unique_ptr<FontList> && _aOwnFontList) { m_aOwnFontList = std::move(_aOwnFontList); }

  virtual void set_sensitive(bool bSensitive)
  {
      m_xWidget->set_sensitive(bSensitive);
  }

  void set_active_or_entry_text(const OUString& rText);

  void statusChanged_Impl(const css::frame::FeatureStateEvent& rEvent);

  virtual bool DoKeyInput(const KeyEvent& rKEvt);

  void EnableControls();

  DECL_LINK(SelectHdl, weld::ComboBox&, void)static void LinkStubSelectHdl(void *, weld::ComboBox&); void
 SelectHdl(weld::ComboBox&);
  DECL_LINK(KeyInputHdl, const KeyEvent&, bool)static bool LinkStubKeyInputHdl(void *, const KeyEvent&);
 bool KeyInputHdl(const KeyEvent&);
  DECL_LINK(ActivateHdl, weld::ComboBox&, bool)static bool LinkStubActivateHdl(void *, weld::ComboBox&);
 bool ActivateHdl(weld::ComboBox&);
  DECL_LINK(FocusInHdl, weld::Widget&, void)static void LinkStubFocusInHdl(void *, weld::Widget&); void
 FocusInHdl(weld::Widget&);
  DECL_LINK(FocusOutHdl, weld::Widget&, void)static void LinkStubFocusOutHdl(void *, weld::Widget&); void
 FocusOutHdl(weld::Widget&);
  DECL_LINK(DumpAsPropertyTreeHdl, tools::JsonWriter&, void)static void LinkStubDumpAsPropertyTreeHdl(void *, tools::JsonWriter
&); void DumpAsPropertyTreeHdl(tools::JsonWriter&);
372};

374void FontOptionsListener::setProperty(const css::uno::Any &rProperty)
375{
  comphelper::ConfigurationListenerProperty<bool>::setProperty(rProperty);
  m_rBox.EnableControls();
378}

380class SvxFontNameBox_Impl final : public InterimItemWindow
                              , public SvxFontNameBox_Base
382{
383private:
  virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
  virtual void GetFocus() override
  {
      if (m_xWidget)
          m_xWidget->grab_focus();
      InterimItemWindow::GetFocus();
  }

  void            SetOptimalSize();

  virtual bool DoKeyInput(const KeyEvent& rKEvt) override;

396public:
  SvxFontNameBox_Impl(vcl::Window* pParent, const Reference<XDispatchProvider>& rDispatchProvider,
                      const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl);

  virtual void dispose() override
  {
      m_xWidget.reset();
      InterimItemWindow::dispose();
  }

  virtual ~SvxFontNameBox_Impl() override
  {
      disposeOnce();
  }

  virtual Reference< css::accessibility::XAccessible > CreateAccessible() override;

  virtual void set_sensitive(bool bSensitive) override
  {
      m_xWidget->set_sensitive(bSensitive);
      if (bSensitive)
          InterimItemWindow::Enable();
      else
          InterimItemWindow::Disable();
  }
421};


424// SelectHdl needs the Modifiers, get them in MouseButtonUp
425class SvxFrmValueSet_Impl final : public ValueSet
426{
427private:
  sal_uInt16 nModifier;

  virtual bool MouseButtonUp(const MouseEvent& rMEvt) override
  {
      nModifier = rMEvt.GetModifier();
      return ValueSet::MouseButtonUp(rMEvt);
  }

436public:
  SvxFrmValueSet_Impl()
      : ValueSet(nullptr)
      , nModifier(0)
  {
  }
  sal_uInt16 GetModifier() const {return nModifier;}
443};

445}

447namespace {

449class SvxFrameToolBoxControl;

451class SvxFrameWindow_Impl final : public WeldToolbarPopup
452{
453private:
  rtl::Reference<SvxFrameToolBoxControl> mxControl;
  std::unique_ptr<SvxFrmValueSet_Impl> mxFrameSet;
  std::unique_ptr<weld::CustomWeld> mxFrameSetWin;
  std::vector<BitmapEx>       aImgVec;
  bool                        bParagraphMode;

  void InitImageList();
  void CalcSizeValueSet();
  DECL_LINK( SelectHdl, ValueSet*, void )static void LinkStubSelectHdl(void *, ValueSet*); void SelectHdl
(ValueSet*);

464public:
  SvxFrameWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent);
  virtual void GrabFocus() override
  {
      mxFrameSet->GrabFocus();
  }

  virtual void    statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
472};

474class SvxFrameToolBoxControl : public svt::PopupWindowController
475{
476public:
  explicit SvxFrameToolBoxControl( const css::uno::Reference< css::uno::XComponentContext >& rContext );

  // XInitialization
  virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& rArguments ) override;

  // XServiceInfo
  virtual OUString SAL_CALL getImplementationName() override;
  virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;

  virtual void SAL_CALL execute(sal_Int16 nKeyModifier) override;
487private:
  virtual std::unique_ptr<WeldToolbarPopup> weldPopupWindow() override;
  virtual VclPtr<vcl::Window> createVclPopupWindow( vcl::Window* pParent ) override;
490};

  class LineListBox final : public ValueSet
  {
  public:
      typedef Color (*ColorFunc)(Color);
      typedef Color (*ColorDistFunc)(Color, Color);

      LineListBox();

      /** Set the width in Twips */
      Size SetWidth( long nWidth )
      {
          long nOldWidth = m_nWidth;
          m_nWidth = nWidth;
          return UpdateEntries( nOldWidth );
      }

      void SetNone( const OUString& sNone )
      {
          m_sNone = sNone;
      }

      /** Insert a listbox entry with all widths in Twips. */
      void            InsertEntry(const BorderWidthImpl& rWidthImpl,
                          SvxBorderLineStyle nStyle, long nMinWidth = 0,
                          ColorFunc pColor1Fn = &sameColor,
                          ColorFunc pColor2Fn = &sameColor,
                          ColorDistFunc pColorDistFn = &sameDistColor);

      SvxBorderLineStyle GetEntryStyle( sal_Int32 nPos ) const;

      SvxBorderLineStyle GetSelectEntryStyle() const;

      void            SetSourceUnit( FieldUnit eNewUnit ) { eSourceUnit = eNewUnit; }

      const Color&    GetColor() const { return aColor; }

      virtual void    SetDrawingArea(weld::DrawingArea* pDrawingArea) override;
  private:

      void         ImpGetLine(long nLine1, long nLine2, long nDistance,
                              Color nColor1, Color nColor2, Color nColorDist,
                              SvxBorderLineStyle nStyle, BitmapEx& rBmp);

      void            UpdatePaintLineColor();       // returns sal_True if maPaintCol has changed

      Size            UpdateEntries( long nOldWidth );
      sal_Int32       GetStylePos( sal_Int32  nListPos, long nWidth );

      const Color& GetPaintColor() const
      {
          return maPaintCol;
      }

      Color   GetColorLine1( sal_Int32  nPos );
      Color   GetColorLine2( sal_Int32  nPos );
      Color   GetColorDist( sal_Int32  nPos );

                      LineListBox( const LineListBox& ) = delete;
      LineListBox&    operator =( const LineListBox& ) = delete;

      std::vector<std::unique_ptr<ImpLineListData>> m_vLineList;
      long            m_nWidth;
      OUString        m_sNone;
      ScopedVclPtr<VirtualDevice>   aVirDev;
      Size            aTxtSize;
      Color const     aColor;
      Color           maPaintCol;
      FieldUnit       eSourceUnit;
  };

  SvxBorderLineStyle LineListBox::GetSelectEntryStyle() const
  {
      SvxBorderLineStyle nStyle = SvxBorderLineStyle::SOLID;
      size_t nPos = GetSelectItemPos();
      if (nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)))
      {
          if (!m_sNone.isEmpty())
              --nPos;
          nStyle = GetEntryStyle( nPos );
      }

      return nStyle;
  }

  void LineListBox::ImpGetLine( long nLine1, long nLine2, long nDistance,
                              Color aColor1, Color aColor2, Color aColorDist,
                              SvxBorderLineStyle nStyle, BitmapEx& rBmp )
  {
      auto nMinWidth = GetDrawingArea()->get_ref_device().approximate_digit_width() * COMBO_WIDTH_IN_CHARS18;
      Size aSize(nMinWidth, aTxtSize.Height());
      aSize.AdjustWidth( -(aTxtSize.Width()) );
      aSize.AdjustWidth( -6 );

      // SourceUnit to Twips
      if ( eSourceUnit == FieldUnit::POINT )
      {
          nLine1      /= 5;
          nLine2      /= 5;
          nDistance   /= 5;
      }

      // Paint the lines
      aSize = aVirDev->PixelToLogic( aSize );
      long nPix = aVirDev->PixelToLogic( Size( 0, 1 ) ).Height();
      sal_uInt32 n1 = nLine1;
      sal_uInt32 n2 = nLine2;
      long nDist  = nDistance;
      n1 += nPix-1;
      n1 -= n1%nPix;
      if ( n2 )
      {
          nDist += nPix-1;
          nDist -= nDist%nPix;
          n2    += nPix-1;
          n2    -= n2%nPix;
      }
      long nVirHeight = n1+nDist+n2;
      if ( nVirHeight > aSize.Height() )
          aSize.setHeight( nVirHeight );
      // negative width should not be drawn
      if ( aSize.Width() <= 0 )
          return;

      Size aVirSize = aVirDev->LogicToPixel( aSize );
      if ( aVirDev->GetOutputSizePixel() != aVirSize )
          aVirDev->SetOutputSizePixel( aVirSize );
      aVirDev->SetFillColor( aColorDist );
      aVirDev->DrawRect( tools::Rectangle( Point(), aSize ) );

      aVirDev->SetFillColor( aColor1 );

      double y1 = double( n1 ) / 2;
      svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y1 ), basegfx::B2DPoint( aSize.Width( ), y1 ), n1, nStyle );

      if ( n2 )
      {
          double y2 =  n1 + nDist + double( n2 ) / 2;
          aVirDev->SetFillColor( aColor2 );
          svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y2 ), basegfx::B2DPoint( aSize.Width(), y2 ), n2, SvxBorderLineStyle::SOLID );
      }
      rBmp = aVirDev->GetBitmapEx( Point(), Size( aSize.Width(), n1+nDist+n2 ) );
  }

  LineListBox::LineListBox()
      : ValueSet(nullptr)
      , m_nWidth( 5 )
      , m_sNone()
      , aVirDev(VclPtr<VirtualDevice>::Create())
      , aColor(COL_BLACK)
      , maPaintCol(COL_BLACK)
      , eSourceUnit(FieldUnit::POINT)
  {
      aVirDev->SetLineColor();
      aVirDev->SetMapMode( MapMode( MapUnit::MapTwip ) );
  }

  void LineListBox::SetDrawingArea(weld::DrawingArea* pDrawingArea)
  {
      ValueSet::SetDrawingArea(pDrawingArea);

      OutputDevice& rDevice = pDrawingArea->get_ref_device();

      aTxtSize.setWidth( rDevice.approximate_digit_width() );
      aTxtSize.setHeight( rDevice.GetTextHeight() );

      UpdatePaintLineColor();
  }

  sal_Int32 LineListBox::GetStylePos( sal_Int32 nListPos, long nWidth )
  {
      sal_Int32 nPos = -1;
      if (!m_sNone.isEmpty())
          nListPos--;

      sal_Int32 n = 0;
      size_t i = 0;
      size_t nCount = m_vLineList.size();
      while ( nPos == -1 && i < nCount )
      {
          auto& pData = m_vLineList[ i ];
          if ( pData->GetMinWidth() <= nWidth )
          {
              if ( nListPos == n )
                  nPos = static_cast<sal_Int32>(i);
              n++;
          }
          i++;
      }

      return nPos;
  }

  void LineListBox::InsertEntry(
      const BorderWidthImpl& rWidthImpl, SvxBorderLineStyle nStyle, long nMinWidth,
      ColorFunc pColor1Fn, ColorFunc pColor2Fn, ColorDistFunc pColorDistFn )
  {
      m_vLineList.emplace_back(new ImpLineListData(
          rWidthImpl, nStyle, nMinWidth, pColor1Fn, pColor2Fn, pColorDistFn));
  }

  SvxBorderLineStyle LineListBox::GetEntryStyle( sal_Int32 nPos ) const
  {
      ImpLineListData* pData = (0 <= nPos && o3tl::make_unsigned(nPos) < m_vLineList.size()) ? m_vLineList[ nPos ].get() : nullptr;
      return pData ? pData->GetStyle() : SvxBorderLineStyle::NONE;
  }

  void LineListBox::UpdatePaintLineColor()
  {
      const StyleSettings&    rSettings = Application::GetSettings().GetStyleSettings();
      Color                   aNewCol( rSettings.GetWindowColor().IsDark()? rSettings.GetLabelTextColor() : aColor );

      bool bRet = aNewCol != maPaintCol;

      if( bRet )
          maPaintCol = aNewCol;
  }

  Size LineListBox::UpdateEntries( long nOldWidth )
  {
      Size aSize;

      UpdatePaintLineColor( );

      sal_Int32      nSelEntry = GetSelectItemPos();
      sal_Int32       nTypePos = GetStylePos( nSelEntry, nOldWidth );

      // Remove the old entries
      Clear();

      sal_uInt16 nId(1);

      // Add the new entries based on the defined width
      if (!m_sNone.isEmpty())
          InsertItem(nId++, Image(), m_sNone);

      sal_uInt16 n = 0;
      sal_uInt16 nCount = m_vLineList.size( );
      while ( n < nCount )
      {
          auto& pData = m_vLineList[ n ];
          if ( pData->GetMinWidth() <= m_nWidth )
          {
              BitmapEx aBmp;
              ImpGetLine( pData->GetLine1ForWidth( m_nWidth ),
                      pData->GetLine2ForWidth( m_nWidth ),
                      pData->GetDistForWidth( m_nWidth ),
                      GetColorLine1( GetItemCount( ) ),
                      GetColorLine2( GetItemCount( ) ),
                      GetColorDist( GetItemCount( ) ),
                      pData->GetStyle(), aBmp );
              InsertItem(nId, Image(aBmp));
              Size aBmpSize = aBmp.GetSizePixel();
              if (aBmpSize.Width() > aSize.Width())
                  aSize.setWidth(aBmpSize.getWidth());
              if (aBmpSize.Height() > aSize.Height())
                  aSize.setHeight(aBmpSize.getHeight());
              if ( n == nTypePos )
                  SelectItem(nId);
          }
          else if ( n == nTypePos )
              SetNoSelection();
          n++;
          ++nId;
      }

      Invalidate();

      return aSize;
  }

  Color LineListBox::GetColorLine1( sal_Int32 nPos )
  {
      sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
      if (nStyle == -1)
          return GetPaintColor( );
      auto& pData = m_vLineList[ nStyle ];
      return pData->GetColorLine1( GetColor( ) );
  }

  Color LineListBox::GetColorLine2( sal_Int32 nPos )
  {
      sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
      if (nStyle == -1)
          return GetPaintColor( );
      auto& pData = m_vLineList[ nStyle ];
      return pData->GetColorLine2( GetColor( ) );
  }

  Color LineListBox::GetColorDist( sal_Int32 nPos )
  {
      Color rResult = Application::GetSettings().GetStyleSettings().GetFieldColor();

      sal_Int32 nStyle = GetStylePos( nPos, m_nWidth );
      if (nStyle == -1)
          return rResult;
      auto& pData = m_vLineList[ nStyle ];
      return pData->GetColorDist( GetColor( ), rResult );
  }
790}

792namespace {

794class SvxLineWindow_Impl final : public WeldToolbarPopup
795{
796private:
  rtl::Reference<SvxFrameToolBoxControl> m_xControl;
  std::unique_ptr<LineListBox> m_xLineStyleLb;
  std::unique_ptr<weld::CustomWeld> m_xLineStyleLbWin;
  bool                m_bIsWriter;

  DECL_LINK( SelectHdl, ValueSet*, void )static void LinkStubSelectHdl(void *, ValueSet*); void SelectHdl
(ValueSet*);

804public:
  SvxLineWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent);
  virtual void GrabFocus() override
  {
      m_xLineStyleLb->GrabFocus();
  }
810};

812}

814class SvxStyleToolBoxControl;

816class SfxStyleControllerItem_Impl : public SfxStatusListener
817{
  public:
      SfxStyleControllerItem_Impl( const Reference< XDispatchProvider >& rDispatchProvider,
                                   sal_uInt16 nSlotId,
                                   const OUString& rCommand,
                                   SvxStyleToolBoxControl& rTbxCtl );

  protected:
      virtual void StateChanged( SfxItemState eState, const SfxPoolItem* pState ) override;

  private:
      SvxStyleToolBoxControl& rControl;
829};

831#define BUTTON_PADDING10 10
832#define ITEM_HEIGHT30 30

834SvxStyleBox_Base::SvxStyleBox_Base(std::unique_ptr<weld::ComboBox> xWidget,
                                 const OUString& rCommand,
                                 SfxStyleFamily eFamily,
                                 const Reference< XDispatchProvider >& rDispatchProvider,
                                 const Reference< XFrame >& _xFrame,
                                 const OUString& rClearFormatKey,
                                 const OUString& rMoreKey,
                                 bool bInSpec, SvxStyleToolBoxControl& rCtrl)
  : m_rCtrl(rCtrl)
  , m_xMenuBuilder(Application::CreateBuilder(nullptr, "svx/ui/stylemenu.ui"))
  , m_xMenu(m_xMenuBuilder->weld_menu("menu"))
  , m_xWidget(std::move(xWidget))
  , eStyleFamily( eFamily )
  , m_nMaxUserDrawFontWidth(0)
  , bRelease( true )
  , m_xDispatchProvider( rDispatchProvider )
  , m_xFrame(_xFrame)
  , m_aCommand( rCommand )
  , aClearFormatKey( rClearFormatKey )
  , aMoreKey( rMoreKey )
  , bInSpecialMode( bInSpec )
855{
  m_xWidget->connect_changed(LINK(this, SvxStyleBox_Base, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubSelectHdl));
  m_xWidget->connect_key_press(LINK(this, SvxStyleBox_Base, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubKeyInputHdl));
  m_xWidget->connect_entry_activate(LINK(this, SvxStyleBox_Base, ActivateHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubActivateHdl));
  m_xWidget->connect_focus_out(LINK(this, SvxStyleBox_Base, FocusOutHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubFocusOutHdl));
  m_xWidget->connect_get_property_tree(LINK(this, SvxStyleBox_Base, DumpAsPropertyTreeHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubDumpAsPropertyTreeHdl
));
  m_xWidget->set_help_id(HID_STYLE_LISTBOX"SVX_HID_STYLE_LISTBOX");
  m_xWidget->set_entry_completion(true);
  m_xMenu->connect_activate(LINK(this, SvxStyleBox_Base, MenuSelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubMenuSelectHdl));

  m_xWidget->connect_custom_get_size(LINK(this, SvxStyleBox_Base, CustomGetSizeHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubCustomGetSizeHdl
));
  m_xWidget->connect_custom_render(LINK(this, SvxStyleBox_Base, CustomRenderHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(this), &SvxStyleBox_Base::LinkStubCustomRenderHdl));
  m_xWidget->set_custom_renderer(true);

  m_xWidget->set_entry_width_chars(COMBO_WIDTH_IN_CHARS18);
870}

872IMPL_LINK(SvxStyleBox_Base, CustomGetSizeHdl, OutputDevice&, rArg, Size)Size SvxStyleBox_Base::LinkStubCustomGetSizeHdl(void * instance
, OutputDevice& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->CustomGetSizeHdl(data); } Size SvxStyleBox_Base
::CustomGetSizeHdl(OutputDevice& rArg)
873{
  CalcOptimalExtraUserWidth(rArg);
  return Size(m_nMaxUserDrawFontWidth, ITEM_HEIGHT30);
876}

878SvxStyleBox_Impl::SvxStyleBox_Impl(vcl::Window* pParent,
                                 const OUString& rCommand,
                                 SfxStyleFamily eFamily,
                                 const Reference< XDispatchProvider >& rDispatchProvider,
                                 const Reference< XFrame >& _xFrame,
                                 const OUString& rClearFormatKey,
                                 const OUString& rMoreKey,
                                 bool bInSpec, SvxStyleToolBoxControl& rCtrl)
  : InterimItemWindow(pParent, "svx/ui/applystylebox.ui", "ApplyStyleBox")
  , SvxStyleBox_Base(m_xBuilder->weld_combo_box("applystyle"), rCommand, eFamily,
                     rDispatchProvider, _xFrame, rClearFormatKey, rMoreKey, bInSpec, rCtrl)
889{
  InitControlBase(m_xWidget.get());

  set_id("applystyle");
  SetOptimalSize();
894}

896void SvxStyleBox_Base::ReleaseFocus()
897{
  if ( !bRelease )
  {
      bRelease = true;
      return;
  }
  if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
      m_xFrame->getContainerWindow()->setFocus();
905}

907IMPL_LINK(SvxStyleBox_Base, MenuSelectHdl, const OString&, rMenuIdent, void)void SvxStyleBox_Base::LinkStubMenuSelectHdl(void * instance,
 const OString& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->MenuSelectHdl(data); } void SvxStyleBox_Base
::MenuSelectHdl(const OString& rMenuIdent)
908{
  OUString sEntry = m_xWidget->get_active_text();

  ReleaseFocus(); // It must be after getting entry pos!
  Sequence<PropertyValue> aArgs(2);
  aArgs[0].Name   = "Param";
  aArgs[0].Value  <<= sEntry;
  aArgs[1].Name   = "Family";
  aArgs[1].Value  <<= sal_Int16( eStyleFamily );

  if (rMenuIdent == "update")
  {
      SfxToolBoxControl::Dispatch( m_xDispatchProvider,
          ".uno:StyleUpdateByExample", aArgs );
  }
  else if (rMenuIdent == "edit")
  {
      SfxToolBoxControl::Dispatch( m_xDispatchProvider,
          ".uno:EditStyle", aArgs );
  }
928}

930IMPL_STATIC_LINK_NOARG(SvxStyleBox_Base, ShowMoreHdl, void*, void)void SvxStyleBox_Base::LinkStubShowMoreHdl(void * instance, void
* data) { return ShowMoreHdl(static_cast<SvxStyleBox_Base *
>(instance), data); } void SvxStyleBox_Base::ShowMoreHdl( __attribute__
 ((unused)) SvxStyleBox_Base *, __attribute__ ((unused)) void
*)
931{
  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
  DBG_ASSERT( pViewFrm, "SvxStyleBox_Base::Select(): no viewframe" )do { if (true && (!(pViewFrm))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "933" ": "), "%s", "SvxStyleBox_Base::Select(): no viewframe"
); } } while (false);
  if (!pViewFrm)
      return;
  pViewFrm->ShowChildWindow(SID_SIDEBAR(10000 + 336));
  ::sfx2::sidebar::Sidebar::ShowPanel("StyleListPanel", pViewFrm->GetFrame().GetFrameInterface(), true);
938}

940IMPL_LINK(SvxStyleBox_Base, SelectHdl, weld::ComboBox&, rCombo, void)void SvxStyleBox_Base::LinkStubSelectHdl(void * instance, weld
::ComboBox& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->SelectHdl(data); } void SvxStyleBox_Base
::SelectHdl(weld::ComboBox& rCombo)
941{
  Select(rCombo.changed_by_direct_pick()); // only when picked from the list
943}

945IMPL_LINK_NOARG(SvxStyleBox_Base, ActivateHdl, weld::ComboBox&, bool)bool SvxStyleBox_Base::LinkStubActivateHdl(void * instance, weld
::ComboBox& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->ActivateHdl(data); } bool SvxStyleBox_Base
::ActivateHdl(__attribute__ ((unused)) weld::ComboBox&)
946{
  Select(true);
  return true;
949}

951void SvxStyleBox_Base::Select(bool bNonTravelSelect)
952{
  if (!bNonTravelSelect)
      return;

  OUString aSearchEntry(m_xWidget->get_active_text());
  bool bDoIt = true, bClear = false;
  if( bInSpecialMode )
  {
      if( aSearchEntry == aClearFormatKey && m_xWidget->get_active() == 0 )
      {
          aSearchEntry = sDefaultStyle;
          bClear = true;
          //not only apply default style but also call 'ClearFormatting'
          Sequence< PropertyValue > aEmptyVals;
          SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:ResetAttributes",
              aEmptyVals);
      }
      else if (aSearchEntry == aMoreKey && m_xWidget->get_active() == (m_xWidget->get_count() - 1))
      {
          Application::PostUserEvent(LINK(nullptr, SvxStyleBox_Base, ShowMoreHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxStyleBox_Base
 *>(nullptr), &SvxStyleBox_Base::LinkStubShowMoreHdl));
          //tdf#113214 change text back to previous entry
          set_active_or_entry_text(m_xWidget->get_saved_value());
          bDoIt = false;
      }
  }

  //Do we need to create a new style?
  SfxObjectShell *pShell = SfxObjectShell::Current();
  SfxStyleSheetBasePool* pPool = pShell->GetStyleSheetPool();
  SfxStyleSheetBase* pStyle = nullptr;

  bool bCreateNew = false;

  if ( pPool )
  {
      pStyle = pPool->First(eStyleFamily);
      while ( pStyle && pStyle->GetName() != aSearchEntry )
          pStyle = pPool->Next();
  }

  if ( !pStyle )
  {
      // cannot find the style for whatever reason
      // therefore create a new style
      bCreateNew = true;
  }

  /*  #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
      This instance may be deleted in the meantime (i.e. when a dialog is opened
      while in Dispatch()), accessing members will crash in this case. */
  ReleaseFocus();

  if( !bDoIt )
      return;

  if ( bClear )
      set_active_or_entry_text(aSearchEntry);
  m_xWidget->save_value();

  Sequence< PropertyValue > aArgs( 2 );
  aArgs[0].Value  <<= aSearchEntry;
  aArgs[1].Name   = "Family";
  aArgs[1].Value  <<= sal_Int16( eStyleFamily );
  if( bCreateNew )
  {
      aArgs[0].Name   = "Param";
      SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:StyleNewByExample", aArgs);
  }
  else
  {
      aArgs[0].Name   = "Template";
      SfxToolBoxControl::Dispatch( m_xDispatchProvider, m_aCommand, aArgs );
  }
1025}

1027void SvxStyleBox_Base::SetFamily( SfxStyleFamily eNewFamily )
1028{
  eStyleFamily = eNewFamily;
1030}

1032IMPL_LINK_NOARG(SvxStyleBox_Base, FocusOutHdl, weld::Widget&, void)void SvxStyleBox_Base::LinkStubFocusOutHdl(void * instance, weld
::Widget& data) { return static_cast<SvxStyleBox_Base *
>(instance)->FocusOutHdl(data); } void SvxStyleBox_Base
::FocusOutHdl(__attribute__ ((unused)) weld::Widget&)
1033{
  if (!m_xWidget->has_focus()) // a combobox can be comprised of different subwidget so double-check if none of those has focus
      set_active_or_entry_text(m_xWidget->get_saved_value());
1036}

1038IMPL_LINK(SvxStyleBox_Base, KeyInputHdl, const KeyEvent&, rKEvt, bool)bool SvxStyleBox_Base::LinkStubKeyInputHdl(void * instance, const
 KeyEvent& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->KeyInputHdl(data); } bool SvxStyleBox_Base
::KeyInputHdl(const KeyEvent& rKEvt)
1039{
  return DoKeyInput(rKEvt);
1041}

1043bool SvxStyleBox_Base::DoKeyInput(const KeyEvent& rKEvt)
1044{
  bool bHandled = false;

  sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();

  switch (nCode)
  {
      case KEY_TAB:
          bRelease = false;
          Select(true);
          break;
      case KEY_ESCAPE:
          set_active_or_entry_text(m_xWidget->get_saved_value());
          if (!m_rCtrl.IsInSidebar())
          {
              ReleaseFocus();
              bHandled = true;
          }
          break;
  }

  return bHandled;
1066}

1068bool SvxStyleBox_Impl::DoKeyInput(const KeyEvent& rKEvt)
1069{
  return SvxStyleBox_Base::DoKeyInput(rKEvt) || ChildKeyInput(rKEvt);
1071}

1073void SvxStyleBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1074{
  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
       (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
  {
      SetOptimalSize();
  }

  InterimItemWindow::DataChanged( rDCEvt );
1082}

1084bool SvxStyleBox_Base::AdjustFontForItemHeight(OutputDevice& rDevice, tools::Rectangle const & rTextRect, long nHeight)
1085{
  if (rTextRect.Bottom() > nHeight)
  {
      // the text does not fit, adjust the font size
      double ratio = static_cast< double >( nHeight ) / rTextRect.Bottom();
      vcl::Font aFont(rDevice.GetFont());
      Size aPixelSize(aFont.GetFontSize());
      aPixelSize.setWidth( aPixelSize.Width() * ratio );
      aPixelSize.setHeight( aPixelSize.Height() * ratio );
      aFont.SetFontSize(aPixelSize);
      rDevice.SetFont(aFont);
      return true;
  }
  return false;
1099}

1101void SvxStyleBox_Impl::SetOptimalSize()
1102{
  // set width in chars low so the size request will not be overridden
  m_xWidget->set_entry_width_chars(1);
  // tdf#132338 purely using this calculation to keep things their traditional width
  Size aSize(LogicToPixel(Size(COMBO_WIDTH_IN_CHARS18 * 4, 0), MapMode(MapUnit::MapAppFont)));
  m_xWidget->set_size_request(aSize.Width(), -1);

  SetSizePixel(get_preferred_size());
1110}

1112void SvxStyleBox_Base::UserDrawEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const OUString &rStyleName)
1113{
  // IMG_TXT_DISTANCE in ilstbox.hxx is 6, then 1 is added as
  // nBorder, and we are adding 1 in order to look better when
  // italics is present
  const int nLeftDistance = 8;

  tools::Rectangle aTextRect;
  rRenderContext.GetTextBoundRect(aTextRect, rStyleName);

  Point aPos(rRect.TopLeft());
  aPos.AdjustX(nLeftDistance );

  if (!AdjustFontForItemHeight(rRenderContext, aTextRect, rRect.GetHeight()))
      aPos.AdjustY((rRect.GetHeight() - aTextRect.Bottom() ) / 2);

  rRenderContext.DrawText(aPos, rStyleName);
1129}

1131void SvxStyleBox_Base::SetupEntry(vcl::RenderContext& rRenderContext, sal_Int32 nItem, const tools::Rectangle& rRect, const OUString& rStyleName, bool bIsNotSelected)
1132{
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  if (!bIsNotSelected)
      rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
  else
      rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());

  // handle the push-button
  if (!bIsNotSelected)
  {
      if (nItem == 0 || nItem == m_xWidget->get_count() - 1)
          m_xWidget->set_item_menu(OString::number(nItem), nullptr);
      else
          m_xWidget->set_item_menu(OString::number(nItem), m_xMenu.get());
  }

  if (nItem <= 0 || nItem >= m_xWidget->get_count() - 1)
      return;

  SfxObjectShell *pShell = SfxObjectShell::Current();
  SfxStyleSheetBasePool* pPool = pShell->GetStyleSheetPool();
  SfxStyleSheetBase* pStyle = nullptr;

  if ( pPool )
  {
      pStyle = pPool->First(eStyleFamily);
      while (pStyle && pStyle->GetName() != rStyleName)
          pStyle = pPool->Next();
  }

  if (!pStyle )
      return;

  std::unique_ptr<const SfxItemSet> const pItemSet(pStyle->GetItemSetForPreview());
  if (!pItemSet) return;

  const SvxFontItem * const pFontItem =
      pItemSet->GetItem<SvxFontItem>(SID_ATTR_CHAR_FONT( 10000 + 7 ));
  const SvxFontHeightItem * const pFontHeightItem =
      pItemSet->GetItem<SvxFontHeightItem>(SID_ATTR_CHAR_FONTHEIGHT( 10000 + 15 ));

  if ( !(pFontItem && pFontHeightItem) )
      return;

  Size aFontSize( 0, pFontHeightItem->GetHeight() );
  Size aPixelSize(rRenderContext.LogicToPixel(aFontSize, MapMode(pShell->GetMapUnit())));

  // setup the font properties
  SvxFont aFont;
  aFont.SetFamilyName(pFontItem->GetFamilyName());
  aFont.SetStyleName(pFontItem->GetStyleName());
  aFont.SetFontSize(aPixelSize);

  const SfxPoolItem *pItem = pItemSet->GetItem( SID_ATTR_CHAR_WEIGHT( 10000 + 9 ) );
  if ( pItem )
      aFont.SetWeight( static_cast< const SvxWeightItem* >( pItem )->GetWeight() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_POSTURE( 10000 + 8 ) );
  if ( pItem )
      aFont.SetItalic( static_cast< const SvxPostureItem* >( pItem )->GetPosture() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_CONTOUR( 10000 + 12 ) );
  if ( pItem )
      aFont.SetOutline( static_cast< const SvxContourItem* >( pItem )->GetValue() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_SHADOWED( 10000 + 10 ) );
  if ( pItem )
      aFont.SetShadow( static_cast< const SvxShadowedItem* >( pItem )->GetValue() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_RELIEF( 10000 + 920 ) );
  if ( pItem )
      aFont.SetRelief( static_cast< const SvxCharReliefItem* >( pItem )->GetValue() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ) );
  if ( pItem )
      aFont.SetUnderline( static_cast< const SvxUnderlineItem* >( pItem )->GetLineStyle() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_OVERLINE( ((10000 + 1499) + 1) + 68 ) );
  if ( pItem )
      aFont.SetOverline( static_cast< const SvxOverlineItem* >( pItem )->GetValue() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_STRIKEOUT( 10000 + 13 ) );
  if ( pItem )
      aFont.SetStrikeout( static_cast< const SvxCrossedOutItem* >( pItem )->GetStrikeout() );

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_CASEMAP( 10000 + 19 ) );
  if ( pItem )
      aFont.SetCaseMap(static_cast<const SvxCaseMapItem*>(pItem)->GetCaseMap());

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_EMPHASISMARK( 10000 + 899 ) );
  if ( pItem )
      aFont.SetEmphasisMark( static_cast< const SvxEmphasisMarkItem* >( pItem )->GetEmphasisMark() );

  // setup the device & draw
  Color aFontCol = COL_AUTO, aBackCol = COL_AUTO;

  rRenderContext.SetFont(aFont);

  pItem = pItemSet->GetItem( SID_ATTR_CHAR_COLOR( 10000 + 17 ) );
  // text color, when nothing is selected
  if ( (nullptr != pItem) && bIsNotSelected)
      aFontCol = static_cast< const SvxColorItem* >( pItem )->GetValue();

  drawing::FillStyle style = drawing::FillStyle_NONE;
  // which kind of Fill style is selected
  pItem = pItemSet->GetItem( XATTR_FILLSTYLE );
  // only when ok and not selected
  if ( (nullptr != pItem) && bIsNotSelected)
      style = static_cast< const XFillStyleItem* >( pItem )->GetValue();

  switch(style)
  {
      case drawing::FillStyle_SOLID:
      {
          // set background color
          pItem = pItemSet->GetItem( XATTR_FILLCOLOR );
          if ( nullptr != pItem )
              aBackCol = static_cast< const XFillColorItem* >( pItem )->GetColorValue();

          if ( aBackCol != COL_AUTO )
          {
              rRenderContext.SetFillColor(aBackCol);
              rRenderContext.DrawRect(rRect);
          }
      }
      break;

      default: break;
      //TODO Draw the other background styles: gradient, hatching and bitmap
  }

  // when the font and background color are too similar, adjust the Font-Color
  if( (aFontCol != COL_AUTO) || (aBackCol != COL_AUTO) )
      aFontCol = TestColorsVisible(aFontCol, (aBackCol != COL_AUTO) ? aBackCol : rRenderContext.GetBackground().GetColor());

  // set text color
  if ( aFontCol != COL_AUTO )
      rRenderContext.SetTextColor(aFontCol);
1270}

1272IMPL_LINK(SvxStyleBox_Base, CustomRenderHdl, weld::ComboBox::render_args, aPayload, void)void SvxStyleBox_Base::LinkStubCustomRenderHdl(void * instance
, weld::ComboBox::render_args data) { return static_cast<SvxStyleBox_Base
 *>(instance)->CustomRenderHdl(data); } void SvxStyleBox_Base
::CustomRenderHdl(weld::ComboBox::render_args aPayload)
1273{
  vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
  const ::tools::Rectangle& rRect = std::get<1>(aPayload);
  bool bSelected = std::get<2>(aPayload);
  const OUString& rId = std::get<3>(aPayload);

  sal_uInt32 nIndex = rId.toUInt32();

  OUString aStyleName(m_xWidget->get_text(nIndex));

  rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::FONT | PushFlags::TEXTCOLOR);

  SetupEntry(rRenderContext, nIndex, rRect, aStyleName, !bSelected);

  UserDrawEntry(rRenderContext, rRect, aStyleName);

  rRenderContext.Pop();
1290}

1292void SvxStyleBox_Base::CalcOptimalExtraUserWidth(vcl::RenderContext& rRenderContext)
1293{
  if (m_nMaxUserDrawFontWidth)
      return;

  long nMaxNormalFontWidth = 0;
  sal_Int32 nEntryCount = m_xWidget->get_count();
  for (sal_Int32 i = 0; i < nEntryCount; ++i)
  {
      OUString sStyleName(get_text(i));
      tools::Rectangle aTextRectForDefaultFont;
      rRenderContext.GetTextBoundRect(aTextRectForDefaultFont, sStyleName);

      const long nWidth = aTextRectForDefaultFont.GetWidth();

      nMaxNormalFontWidth = std::max(nWidth, nMaxNormalFontWidth);
  }

  m_nMaxUserDrawFontWidth = nMaxNormalFontWidth;
  for (sal_Int32 i = 1; i < nEntryCount-1; ++i)
  {
      OUString sStyleName(get_text(i));

      rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::FONT | PushFlags::TEXTCOLOR);
      SetupEntry(rRenderContext, i, tools::Rectangle(0, 0, RECT_MAX9223372036854775807L, ITEM_HEIGHT30), sStyleName, true);
      tools::Rectangle aTextRectForActualFont;
      rRenderContext.GetTextBoundRect(aTextRectForActualFont, sStyleName);
      if (AdjustFontForItemHeight(rRenderContext, aTextRectForActualFont, ITEM_HEIGHT30))
      {
          //Font didn't fit, so it was changed, refetch with final font size
          rRenderContext.GetTextBoundRect(aTextRectForActualFont, sStyleName);
      }
      rRenderContext.Pop();

      const int nWidth = aTextRectForActualFont.GetWidth() + m_xWidget->get_menu_button_width() + BUTTON_PADDING10;

      m_nMaxUserDrawFontWidth = std::max(nWidth, m_nMaxUserDrawFontWidth);
  }
1330}

1332// test is the color between Font- and background-color to be identify
1333// return is always the Font-Color
1334//        when both light or dark, change the Contrast
1335//        in other case do not change the origin color
1336//        when the color is R=G=B=128 the DecreaseContrast make 128 the need an exception
1337Color SvxStyleBox_Base::TestColorsVisible(const Color &FontCol, const Color &BackCol)
1338{
  constexpr sal_uInt8  ChgVal = 60;       // increase/decrease the Contrast

  Color  retCol = FontCol;
  if ((FontCol.IsDark() == BackCol.IsDark()) && (FontCol.IsBright() == BackCol.IsBright()))
  {
      sal_uInt8 lumi = retCol.GetLuminance();

      if((lumi > 120) && (lumi < 140))
          retCol.DecreaseLuminance(ChgVal / 2);
      else
          retCol.DecreaseContrast(ChgVal);
  }

  return retCol;
1353}

1355IMPL_LINK(SvxStyleBox_Base, DumpAsPropertyTreeHdl, tools::JsonWriter&, rJsonWriter, void)void SvxStyleBox_Base::LinkStubDumpAsPropertyTreeHdl(void * instance
, tools::JsonWriter& data) { return static_cast<SvxStyleBox_Base
 *>(instance)->DumpAsPropertyTreeHdl(data); } void SvxStyleBox_Base
::DumpAsPropertyTreeHdl(tools::JsonWriter& rJsonWriter)
1356{
  {
      auto entriesNode = rJsonWriter.startNode("entries");
      for (int i = 0, nEntryCount = m_xWidget->get_count(); i < nEntryCount; ++i)
      {
          auto entryNode = rJsonWriter.startNode("");
          rJsonWriter.put("", m_xWidget->get_text(i));
      }
  }

  int nActive = m_xWidget->get_active();
  rJsonWriter.put("selectedCount", static_cast<sal_Int32>(nActive == -1 ? 0 : 1));

  {
      auto selectedNode = rJsonWriter.startNode("selectedEntries");
      if (nActive != -1)
      {
          auto node = rJsonWriter.startNode("");
          rJsonWriter.put("", static_cast<sal_Int32>(nActive));
      }
  }

  rJsonWriter.put("command", ".uno:StyleApply");
1379}

1381static bool lcl_GetDocFontList(const FontList** ppFontList, SvxFontNameBox_Base* pBox)
1382{
  bool bChanged = false;
  const SfxObjectShell* pDocSh = SfxObjectShell::Current();
  const SvxFontListItem* pFontListItem = nullptr;

  if ( pDocSh )
      pFontListItem =
          static_cast<const SvxFontListItem*>(pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST( 10000 + 22 ) ));
  else
  {
      ::std::unique_ptr<FontList> aFontList(new FontList(Application::GetDefaultDevice()));
      *ppFontList = aFontList.get();
      pBox->SetOwnFontList(std::move(aFontList));
      bChanged = true;
  }

  if ( pFontListItem )
  {
      const FontList* pNewFontList = pFontListItem->GetFontList();
      DBG_ASSERT( pNewFontList, "Doc-FontList not available!" )do { if (true && (!(pNewFontList))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "1401" ": "), "%s", "Doc-FontList not available!"); } } while
 (false);

      // No old list, but a new list
      if ( !*ppFontList && pNewFontList )
      {
          // => take over
          *ppFontList = pNewFontList;
          bChanged = true;
      }
      else
      {
          // Comparing the font lists is not perfect.
          // When you change the font list in the Doc, you can track
          // changes here only on the Listbox, because ppFontList
          // has already been updated.
          bChanged =
              ( ( *ppFontList != pNewFontList ) ||
                pBox->GetListCount() != pNewFontList->GetFontNameCount() );
          // HACK: Comparing is incomplete

          if ( bChanged )
              *ppFontList = pNewFontList;
      }

      if ( pBox )
          pBox->set_sensitive(true);
  }
  else if ( pBox && ( pDocSh || !ppFontList ))
  {
      // Disable box only when we have a SfxObjectShell and didn't get a font list OR
      // we don't have a SfxObjectShell and no current font list.
      // It's possible that we currently have no SfxObjectShell, but a current font list.
      // See #i58471: When a user set the focus into the font name combo box and opens
      // the help window with F1. After closing the help window, we disable the font name
      // combo box. The SfxObjectShell::Current() method returns in that case zero. But the
      // font list hasn't changed and therefore the combo box shouldn't be disabled!
      pBox->set_sensitive(false);
  }

  // Fill the FontBox, also the new list if necessary
  if ( pBox && bChanged )
  {
      if ( *ppFontList )
          pBox->Fill( *ppFontList );
      else
          pBox->Clear();
  }
  return bChanged;
1449}

1451SvxFontNameBox_Base::SvxFontNameBox_Base(std::unique_ptr<weld::ComboBox> xWidget,
                                       const Reference<XDispatchProvider>& rDispatchProvider,
                                       const Reference<XFrame>& rFrame,
                                       SvxFontNameToolBoxControl& rCtrl)
  : m_xListener(new comphelper::ConfigurationListener("/org.openoffice.Office.Common/Font/View"))
  , m_aWYSIWYG(m_xListener, "ShowFontBoxWYSIWYG", *this)
  , m_aHistory(m_xListener, "History", *this)
  , m_rCtrl(rCtrl)
  , m_xWidget(new FontNameBox(std::move(xWidget)))
  , pFontList(nullptr)
  , nFtCount(0)
  , bRelease(true)
  , m_xDispatchProvider(rDispatchProvider)
  , m_xFrame(rFrame)
  , mbCheckingUnknownFont(false)
1466{
  EnableControls();

  m_xWidget->connect_changed(LINK(this, SvxFontNameBox_Base, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubSelectHdl));
  m_xWidget->connect_key_press(LINK(this, SvxFontNameBox_Base, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubKeyInputHdl));
  m_xWidget->connect_entry_activate(LINK(this, SvxFontNameBox_Base, ActivateHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubActivateHdl));
  m_xWidget->connect_focus_in(LINK(this, SvxFontNameBox_Base, FocusInHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubFocusInHdl));
  m_xWidget->connect_focus_out(LINK(this, SvxFontNameBox_Base, FocusOutHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubFocusOutHdl));
  m_xWidget->connect_get_property_tree(LINK(this, SvxFontNameBox_Base, DumpAsPropertyTreeHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxFontNameBox_Base
 *>(this), &SvxFontNameBox_Base::LinkStubDumpAsPropertyTreeHdl
));

  m_xWidget->set_entry_width_chars(COMBO_WIDTH_IN_CHARS18);
1477}

1479SvxFontNameBox_Impl::SvxFontNameBox_Impl(vcl::Window* pParent, const Reference<XDispatchProvider>& rDispatchProvider,
                                       const Reference<XFrame>& rFrame, SvxFontNameToolBoxControl& rCtrl)
  : InterimItemWindow(pParent, "svx/ui/fontnamebox.ui", "FontNameBox")
  , SvxFontNameBox_Base(m_xBuilder->weld_combo_box("fontnamecombobox"), rDispatchProvider, rFrame, rCtrl)
1483{
  set_id("fontnamecombobox");
  SetOptimalSize();
1486}

1488void SvxFontNameBox_Base::FillList()
1489{
  if (!m_xWidget) // e.g. disposed
      return;
  // Save old Selection, set back in the end
  int nStartPos, nEndPos;
  m_xWidget->get_entry_selection_bounds(nStartPos, nEndPos);

  // Did Doc-Fontlist change?
  lcl_GetDocFontList(&pFontList, this);

  m_xWidget->select_entry_region(nStartPos, nEndPos);
1500}

1502void SvxFontNameBox_Base::CheckAndMarkUnknownFont()
1503{
  if (mbCheckingUnknownFont) //tdf#117537 block rentry
      return;
  mbCheckingUnknownFont = true;
  OUString fontname = m_xWidget->get_active_text();
  lcl_GetDocFontList( &pFontList, this );
  // If the font is unknown, show it in italic.
  vcl::Font font = m_xWidget->get_entry_font();
  if( pFontList != nullptr && pFontList->IsAvailable( fontname ))
  {
      if( font.GetItalic() != ITALIC_NONE )
      {
          font.SetItalic( ITALIC_NONE );
          m_xWidget->set_entry_font(font);
          m_xWidget->set_tooltip_text(SvxResId(RID_SVXSTR_CHARFONTNAMEreinterpret_cast<char const *>("RID_SVXSTR_CHARFONTNAME"
 "\004" u8"Font Name")));
      }
  }
  else
  {
      if( font.GetItalic() != ITALIC_NORMAL )
      {
          font.SetItalic( ITALIC_NORMAL );
          m_xWidget->set_entry_font(font);
          m_xWidget->set_tooltip_text(SvxResId(RID_SVXSTR_CHARFONTNAME_NOTAVAILABLEreinterpret_cast<char const *>("RID_SVXSTR_CHARFONTNAME_NOTAVAILABLE"
 "\004" u8"Font Name. The current font is not available and will be substituted."
)));
      }
  }
  mbCheckingUnknownFont = false;
1530}

1532void SvxFontNameBox_Base::Update( const css::awt::FontDescriptor* pFontDesc )
1533{
  if ( pFontDesc )
  {
      aCurFont.SetFamilyName  ( pFontDesc->Name );
      aCurFont.SetFamily      ( FontFamily( pFontDesc->Family ) );
      aCurFont.SetStyleName   ( pFontDesc->StyleName );
      aCurFont.SetPitch       ( FontPitch( pFontDesc->Pitch ) );
      aCurFont.SetCharSet     ( rtl_TextEncoding( pFontDesc->CharSet ) );
  }
  OUString aCurName = aCurFont.GetFamilyName();
  OUString aText = m_xWidget->get_active_text();
  if (aText != aCurName)
      set_active_or_entry_text(aCurName);
1546}

1548void SvxFontNameBox_Base::set_active_or_entry_text(const OUString& rText)
1549{
  m_xWidget->set_active_or_entry_text(rText);
  CheckAndMarkUnknownFont();
1552}

1554IMPL_LINK_NOARG(SvxFontNameBox_Base, FocusInHdl, weld::Widget&, void)void SvxFontNameBox_Base::LinkStubFocusInHdl(void * instance,
 weld::Widget& data) { return static_cast<SvxFontNameBox_Base
 *>(instance)->FocusInHdl(data); } void SvxFontNameBox_Base
::FocusInHdl(__attribute__ ((unused)) weld::Widget&)
1555{
  FillList();
1557}

1559IMPL_LINK(SvxFontNameBox_Base, KeyInputHdl, const KeyEvent&, rKEvt, bool)bool SvxFontNameBox_Base::LinkStubKeyInputHdl(void * instance
, const KeyEvent& data) { return static_cast<SvxFontNameBox_Base
 *>(instance)->KeyInputHdl(data); } bool SvxFontNameBox_Base
::KeyInputHdl(const KeyEvent& rKEvt)
1560{
  return DoKeyInput(rKEvt);
1562}

1564bool SvxFontNameBox_Base::DoKeyInput(const KeyEvent& rKEvt)
1565{
  bool bHandled = false;

  sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();

  switch (nCode)
  {
      case KEY_TAB:
          bRelease = false;
          Select(true);
          break;

      case KEY_ESCAPE:
          set_active_or_entry_text(m_xWidget->get_saved_value());
          if (!m_rCtrl.IsInSidebar())
          {
              ReleaseFocus_Impl();
              bHandled = true;
          }
          EndPreview();
          break;
  }

  return bHandled;
1589}

1591bool SvxFontNameBox_Impl::DoKeyInput(const KeyEvent& rKEvt)
1592{
  return SvxFontNameBox_Base::DoKeyInput(rKEvt) || ChildKeyInput(rKEvt);
1594}

1596IMPL_LINK_NOARG(SvxFontNameBox_Base, FocusOutHdl, weld::Widget&, void)void SvxFontNameBox_Base::LinkStubFocusOutHdl(void * instance
, weld::Widget& data) { return static_cast<SvxFontNameBox_Base
 *>(instance)->FocusOutHdl(data); } void SvxFontNameBox_Base
::FocusOutHdl(__attribute__ ((unused)) weld::Widget&)
1597{
  if (!m_xWidget->has_focus()) // a combobox can be comprised of different subwidget so double-check if none of those has focus
  {
      set_active_or_entry_text(m_xWidget->get_saved_value());
      // send EndPreview
      EndPreview();
  }
1604}

1606void SvxFontNameBox_Impl::SetOptimalSize()
1607{
  // set width in chars low so the size request will not be overridden
  m_xWidget->set_entry_width_chars(1);
  // tdf#132338 purely using this calculation to keep things their traditional width
  Size aSize(LogicToPixel(Size(COMBO_WIDTH_IN_CHARS18 * 4, 0), MapMode(MapUnit::MapAppFont)));
  m_xWidget->set_size_request(aSize.Width(), -1);

  SetSizePixel(get_preferred_size());
1615}

1617void SvxFontNameBox_Impl::DataChanged( const DataChangedEvent& rDCEvt )
1618{
  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
       (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
  {
      SetOptimalSize();
  }
  else if ( ( rDCEvt.GetType() == DataChangedEventType::FONTS ) ||
            ( rDCEvt.GetType() == DataChangedEventType::DISPLAY ) )
  {
      // The old font list in shell has likely been destroyed at this point, so we need to get
      // the new one before doing anything further.
      lcl_GetDocFontList( &pFontList, this );
  }
1631}

1633void SvxFontNameBox_Base::ReleaseFocus_Impl()
1634{
  if ( !bRelease )
  {
      bRelease = true;
      return;
  }
  if ( m_xFrame.is() && m_xFrame->getContainerWindow().is() )
      m_xFrame->getContainerWindow()->setFocus();
1642}

1644void SvxFontNameBox_Base::EnableControls()
1645{
  bool bEnableMRU = m_aHistory.get();
  sal_uInt16 nEntries = bEnableMRU ? MAX_MRU_FONTNAME_ENTRIES5 : 0;

  bool bNewWYSIWYG = m_aWYSIWYG.get();
  bool bOldWYSIWYG = m_xWidget->IsWYSIWYGEnabled();

  if (m_xWidget->get_max_mru_count() != nEntries || bNewWYSIWYG != bOldWYSIWYG)
  {
      // refill in the next GetFocus-Handler
      pFontList = nullptr;
      Clear();
      m_xWidget->set_max_mru_count(nEntries);
  }

  if (bNewWYSIWYG != bOldWYSIWYG)
      m_xWidget->EnableWYSIWYG(bNewWYSIWYG);
1662}

1664IMPL_LINK(SvxFontNameBox_Base, SelectHdl, weld::ComboBox&, rCombo, void)void SvxFontNameBox_Base::LinkStubSelectHdl(void * instance, weld
::ComboBox& data) { return static_cast<SvxFontNameBox_Base
 *>(instance)->SelectHdl(data); } void SvxFontNameBox_Base
::SelectHdl(weld::ComboBox& rCombo)
1665{
  Select(rCombo.changed_by_direct_pick()); // only when picked from the list
1667}

1669IMPL_LINK_NOARG(SvxFontNameBox_Base, ActivateHdl, weld::ComboBox&, bool)bool SvxFontNameBox_Base::LinkStubActivateHdl(void * instance
, weld::ComboBox& data) { return static_cast<SvxFontNameBox_Base
 *>(instance)->ActivateHdl(data); } bool SvxFontNameBox_Base
::ActivateHdl(__attribute__ ((unused)) weld::ComboBox&)
1670{
  Select(true);
  return true;
1673}

1675void SvxFontNameBox_Base::Select(bool bNonTravelSelect)
1676{
  Sequence< PropertyValue > aArgs( 1 );
  std::unique_ptr<SvxFontItem> pFontItem;
  if ( pFontList )
  {
      FontMetric aFontMetric( pFontList->Get(m_xWidget->get_active_text(),
          aCurFont.GetWeight(),
          aCurFont.GetItalic() ) );
      aCurFont = aFontMetric;

      pFontItem.reset( new SvxFontItem( aFontMetric.GetFamilyType(),
          aFontMetric.GetFamilyName(),
          aFontMetric.GetStyleName(),
          aFontMetric.GetPitch(),
          aFontMetric.GetCharSet(),
          SID_ATTR_CHAR_FONT( 10000 + 7 ) ) );

      Any a;
      pFontItem->QueryValue( a );
      aArgs[0].Value  = a;
  }

  if (bNonTravelSelect)
  {
      CheckAndMarkUnknownFont();
      //  #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
      //  This instance may be deleted in the meantime (i.e. when a dialog is opened
      //  while in Dispatch()), accessing members will crash in this case.
      ReleaseFocus_Impl();
      EndPreview();
      if (pFontItem)
      {
          aArgs[0].Name   = "CharFontName";
          SfxToolBoxControl::Dispatch( m_xDispatchProvider,
                                       ".uno:CharFontName",
                                       aArgs );
      }
  }
  else
  {
      if (pFontItem)
      {
          aArgs[0].Name   = "CharPreviewFontName";
          SfxToolBoxControl::Dispatch( m_xDispatchProvider,
                                       ".uno:CharPreviewFontName",
                                       aArgs );
      }
  }
1724}

1726IMPL_LINK(SvxFontNameBox_Base, DumpAsPropertyTreeHdl, tools::JsonWriter&, rJsonWriter, void)void SvxFontNameBox_Base::LinkStubDumpAsPropertyTreeHdl(void *
 instance, tools::JsonWriter& data) { return static_cast<
SvxFontNameBox_Base *>(instance)->DumpAsPropertyTreeHdl
(data); } void SvxFontNameBox_Base::DumpAsPropertyTreeHdl(tools
::JsonWriter& rJsonWriter)
1727{
  {
      auto entriesNode = rJsonWriter.startNode("entries");
      for (int i = 0, nEntryCount = m_xWidget->get_count(); i < nEntryCount; ++i)
      {
          auto entryNode = rJsonWriter.startNode("");
          rJsonWriter.put("", m_xWidget->get_text(i));
      }
  }

  int nSelectedEntry = m_xWidget->get_active();
  rJsonWriter.put("selectedCount", static_cast<sal_Int32>(nSelectedEntry == -1 ? 0 : 1));

  {
      auto selectedNode = rJsonWriter.startNode("selectedEntries");
      if (nSelectedEntry != -1)
      {
          auto entryNode = rJsonWriter.startNode("");
          rJsonWriter.put("", m_xWidget->get_text(nSelectedEntry));
      }
  }

  rJsonWriter.put("command", ".uno:CharFontName");
1750}

1752ColorWindow::ColorWindow(const OUString& rCommand,
                       std::shared_ptr<PaletteManager> const & rPaletteManager,
                       ColorStatus&               rColorStatus,
                       sal_uInt16                 nSlotId,
                       const Reference< XFrame >& rFrame,
                       weld::Window*              pParentWindow,
                       const MenuOrToolMenuButton& rMenuButton,
                       ColorSelectFunction const & aFunction)
  : WeldToolbarPopup(rFrame, rMenuButton.get_widget(), "svx/ui/colorwindow.ui", "palette_popup_window")
  , theSlotId(nSlotId)
  , maCommand(rCommand)
  , mpParentWindow(pParentWindow)
  , maMenuButton(rMenuButton)
  , mxPaletteManager(rPaletteManager)
  , mrColorStatus(rColorStatus)
  , maColorSelectFunction(aFunction)
  , mxColorSet(new SvxColorValueSet(m_xBuilder->weld_scrolled_window("colorsetwin", true)))
  , mxRecentColorSet(new SvxColorValueSet(nullptr))
  , mxPaletteListBox(m_xBuilder->weld_combo_box("palette_listbox"))
  , mxButtonAutoColor(m_xBuilder->weld_button("auto_color_button"))
  , mxButtonNoneColor(m_xBuilder->weld_button("none_color_button"))
  , mxButtonPicker(m_xBuilder->weld_button("color_picker_button"))
  , mxAutomaticSeparator(m_xBuilder->weld_widget("separator4"))
  , mxColorSetWin(new weld::CustomWeld(*m_xBuilder, "colorset", *mxColorSet))
  , mxRecentColorSetWin(new weld::CustomWeld(*m_xBuilder, "recent_colorset", *mxRecentColorSet))
  , mpDefaultButton(nullptr)
1778{
  mxColorSet->SetStyle( WinBits(WB_FLATVALUESET(WinBits(0x02000000)) | WB_ITEMBORDER(WinBits(0x00010000)) | WB_3DLOOK | WB_NO_DIRECTSELECT(WinBits(0x04000000)) | WB_TABSTOP) );
  mxRecentColorSet->SetStyle( WinBits(WB_FLATVALUESET(WinBits(0x02000000)) | WB_ITEMBORDER(WinBits(0x00010000)) | WB_3DLOOK | WB_NO_DIRECTSELECT(WinBits(0x04000000)) | WB_TABSTOP) );

  switch ( theSlotId )
  {
      case SID_ATTR_CHAR_COLOR_BACKGROUND(10000 + 489):
      case SID_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 186 ):
      case SID_ATTR_CHAR_BACK_COLOR( 10000 + 1153 ):
      case SID_TABLE_CELL_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 1189 ):
      {
          mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_NOFILLreinterpret_cast<char const *>("RID_SVXSTR_NOFILL" "\004"
 u8"No Fill") ) );
          break;
      }
      case SID_AUTHOR_COLOR( 10000 + 1168 ):
      {
          mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_BY_AUTHORreinterpret_cast<char const *>("RID_SVXSTR_BY_AUTHOR" "\004"
 u8"By author") ) );
          break;
      }
      case SID_BMPMASK_COLOR( 10000 + 1169 ):
      {
          mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_TRANSPARENTreinterpret_cast<char const *>("RID_SVXSTR_TRANSPARENT"
 "\004" u8"Transparent") ) );
          break;
      }
      case SID_ATTR_CHAR_COLOR( 10000 + 17 ):
      case SID_ATTR_CHAR_COLOR2(10000 + 537):
      case SID_EXTRUSION_3D_COLOR( 10000 + 969 ):
      {
          mxButtonAutoColor->set_label(EditResId(RID_SVXSTR_AUTOMATICreinterpret_cast<char const *>("RID_SVXSTR_AUTOMATIC" "\004"
 u8"Automatic")));
          break;
      }
      case SID_FM_CTL_PROPERTIES( 10000 + 613 ):
      {
          mxButtonAutoColor->set_label( SvxResId( RID_SVXSTR_DEFAULTreinterpret_cast<char const *>("RID_SVXSTR_DEFAULT" "\004"
 u8"Default") ) );
          break;
      }
      default:
      {
          mxButtonAutoColor->hide();
          mxAutomaticSeparator->hide();
          break;
      }
  }

  mxPaletteListBox->connect_changed(LINK(this, ColorWindow, SelectPaletteHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubSelectPaletteHdl));
  std::vector<OUString> aPaletteList = mxPaletteManager->GetPaletteList();
  mxPaletteListBox->freeze();
  for (const auto& rPalette : aPaletteList)
      mxPaletteListBox->append_text(rPalette);
  mxPaletteListBox->thaw();
  OUString aPaletteName( officecfg::Office::Common::UserColors::PaletteName::get() );
  mxPaletteListBox->set_active_text(aPaletteName);
  const int nSelectedEntry(mxPaletteListBox->get_active());
  if (nSelectedEntry != -1)
      mxPaletteManager->SetPalette(nSelectedEntry);

  mxButtonAutoColor->connect_clicked(LINK(this, ColorWindow, AutoColorClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubAutoColorClickHdl));
  mxButtonNoneColor->connect_clicked(LINK(this, ColorWindow, AutoColorClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubAutoColorClickHdl));
  mxButtonPicker->connect_clicked(LINK(this, ColorWindow, OpenPickerClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubOpenPickerClickHdl));

  mxColorSet->SetSelectHdl(LINK( this, ColorWindow, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubSelectHdl));
  mxRecentColorSet->SetSelectHdl(LINK( this, ColorWindow, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorWindow
 *>(this), &ColorWindow::LinkStubSelectHdl));
  m_xTopLevel->set_help_id(HID_POPUP_COLOR"SVX_HID_POPUP_COLOR");
  mxColorSet->SetHelpId(HID_POPUP_COLOR_CTRL"SVX_HID_POPUP_COLOR_CTRL");

  mxPaletteManager->ReloadColorSet(*mxColorSet);
  const sal_uInt32 nMaxItems(SvxColorValueSet::getMaxRowCount() * SvxColorValueSet::getColumnCount());
  Size aSize = mxColorSet->layoutAllVisible(nMaxItems);
  mxColorSet->set_size_request(aSize.Width(), aSize.Height());

  mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
  aSize = mxRecentColorSet->layoutAllVisible(mxPaletteManager->GetRecentColorCount());
  mxRecentColorSet->set_size_request(aSize.Width(), aSize.Height());

  AddStatusListener( ".uno:ColorTableState" );
  AddStatusListener( maCommand );
  if ( maCommand == ".uno:FrameLineColor" )
  {
      AddStatusListener( ".uno:BorderTLBR" );
      AddStatusListener( ".uno:BorderBLTR" );
  }
1859}

1861void ColorWindow::GrabFocus()
1862{
  if (mxColorSet->IsNoSelection() && mpDefaultButton)
      mpDefaultButton->grab_focus();
  else
      mxColorSet->GrabFocus();
1867}

1869void ColorWindow::ShowNoneButton()
1870{
  mxButtonNoneColor->show();
1872}

1874ColorWindow::~ColorWindow()
1875{
1876}

1878NamedColor ColorWindow::GetSelectEntryColor(ValueSet const * pColorSet)
1879{
  Color aColor = pColorSet->GetItemColor(pColorSet->GetSelectedItemId());
  OUString sColorName = pColorSet->GetItemText(pColorSet->GetSelectedItemId());
  return std::make_pair(aColor, sColorName);
1883}

1885namespace
1886{
  NamedColor GetAutoColor(sal_uInt16 nSlotId)
  {
      Color aColor;
      OUString sColorName;
      switch (nSlotId)
      {
          case SID_ATTR_CHAR_COLOR_BACKGROUND(10000 + 489):
          case SID_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 186 ):
          case SID_ATTR_CHAR_BACK_COLOR( 10000 + 1153 ):
          case SID_TABLE_CELL_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 1189 ):
              aColor = COL_TRANSPARENT;
              sColorName = SvxResId(RID_SVXSTR_NOFILLreinterpret_cast<char const *>("RID_SVXSTR_NOFILL" "\004"
 u8"No Fill"));
              break;
          case SID_AUTHOR_COLOR( 10000 + 1168 ):
              aColor = COL_TRANSPARENT;
              sColorName = SvxResId(RID_SVXSTR_BY_AUTHORreinterpret_cast<char const *>("RID_SVXSTR_BY_AUTHOR" "\004"
 u8"By author"));
              break;
          case SID_BMPMASK_COLOR( 10000 + 1169 ):
              aColor = COL_TRANSPARENT;
              sColorName = SvxResId(RID_SVXSTR_TRANSPARENTreinterpret_cast<char const *>("RID_SVXSTR_TRANSPARENT"
 "\004" u8"Transparent"));
              break;
          case SID_FM_CTL_PROPERTIES( 10000 + 613 ):
              aColor = COL_TRANSPARENT;
              sColorName = SvxResId(RID_SVXSTR_DEFAULTreinterpret_cast<char const *>("RID_SVXSTR_DEFAULT" "\004"
 u8"Default"));
              break;
          case SID_ATTR_CHAR_COLOR( 10000 + 17 ):
          case SID_ATTR_CHAR_COLOR2(10000 + 537):
          case SID_EXTRUSION_3D_COLOR( 10000 + 969 ):
          default:
              aColor = COL_AUTO;
              sColorName = EditResId(RID_SVXSTR_AUTOMATICreinterpret_cast<char const *>("RID_SVXSTR_AUTOMATIC" "\004"
 u8"Automatic"));
              break;
      }

      return std::make_pair(aColor, sColorName);
  }

  NamedColor GetNoneColor()
  {
      return std::make_pair(COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF), comphelper::LibreOfficeKit::isActive() ? SvxResId(RID_SVXSTR_INVISIBLEreinterpret_cast<char const *>("RID_SVXSTR_INVISIBLE" "\004"
 u8"None"))
          : SvxResId(RID_SVXSTR_NONEreinterpret_cast<char const *>("RID_SVXSTR_NONE" "\004"
 u8"- none -")));
  }
1929}

1931NamedColor ColorWindow::GetSelectEntryColor() const
1932{
  if (!mxColorSet->IsNoSelection())
      return GetSelectEntryColor(mxColorSet.get());
  if (!mxRecentColorSet->IsNoSelection())
      return GetSelectEntryColor(mxRecentColorSet.get());
  if (mxButtonNoneColor.get() == mpDefaultButton)
      return GetNoneColor();
  return GetAutoColor();
1940}

1942IMPL_LINK(ColorWindow, SelectHdl, ValueSet*, pColorSet, void)void ColorWindow::LinkStubSelectHdl(void * instance, ValueSet
* data) { return static_cast<ColorWindow *>(instance)->
SelectHdl(data); } void ColorWindow::SelectHdl(ValueSet* pColorSet
)
1943{
  NamedColor aNamedColor = GetSelectEntryColor(pColorSet);

  if (pColorSet != mxRecentColorSet.get())
  {
       mxPaletteManager->AddRecentColor(aNamedColor.first, aNamedColor.second);
       if (!maMenuButton.get_active())
          mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
  }

  maSelectedLink.Call(aNamedColor);

  // deliberate take a copy here in case maMenuButton.set_inactive
  // triggers a callback that destroys ourself
  ColorSelectFunction aColorSelectFunction(maColorSelectFunction);
  OUString sCommand(maCommand);

  maMenuButton.set_inactive();

  aColorSelectFunction(sCommand, aNamedColor);
1963}

1965IMPL_LINK_NOARG(ColorWindow, SelectPaletteHdl, weld::ComboBox&, void)void ColorWindow::LinkStubSelectPaletteHdl(void * instance, weld
::ComboBox& data) { return static_cast<ColorWindow *>
(instance)->SelectPaletteHdl(data); } void ColorWindow::SelectPaletteHdl
(__attribute__ ((unused)) weld::ComboBox&)
1966{
  int nPos = mxPaletteListBox->get_active();
  mxPaletteManager->SetPalette( nPos );
  mxPaletteManager->ReloadColorSet(*mxColorSet);
  mxColorSet->layoutToGivenHeight(mxColorSet->GetOutputSizePixel().Height(), mxPaletteManager->GetColorCount());
1971}

1973NamedColor ColorWindow::GetAutoColor() const
1974{
  return ::GetAutoColor(theSlotId);
1976}

1978IMPL_LINK(ColorWindow, AutoColorClickHdl, weld::Button&, rButton, void)void ColorWindow::LinkStubAutoColorClickHdl(void * instance, weld
::Button& data) { return static_cast<ColorWindow *>
(instance)->AutoColorClickHdl(data); } void ColorWindow::AutoColorClickHdl
(weld::Button& rButton)
1979{
  NamedColor aNamedColor = &rButton == mxButtonAutoColor.get() ? GetAutoColor() : GetNoneColor();

  mxColorSet->SetNoSelection();
  mxRecentColorSet->SetNoSelection();
  mpDefaultButton = &rButton;

  maSelectedLink.Call(aNamedColor);

  // deliberate take a copy here in case maMenuButton.set_inactive
  // triggers a callback that destroys ourself
  ColorSelectFunction aColorSelectFunction(maColorSelectFunction);
  OUString sCommand(maCommand);

  maMenuButton.set_inactive();

  aColorSelectFunction(sCommand, aNamedColor);
1996}

1998IMPL_LINK_NOARG(ColorWindow, OpenPickerClickHdl, weld::Button&, void)void ColorWindow::LinkStubOpenPickerClickHdl(void * instance,
 weld::Button& data) { return static_cast<ColorWindow *
>(instance)->OpenPickerClickHdl(data); } void ColorWindow
::OpenPickerClickHdl(__attribute__ ((unused)) weld::Button&
)
1999{
  // copy before set_inactive
  auto nColor = GetSelectEntryColor().first;
  auto pParentWindow = mpParentWindow;
  OUString sCommand = maCommand;
  std::shared_ptr<PaletteManager> xPaletteManager(mxPaletteManager);

  maMenuButton.set_inactive();

  xPaletteManager->PopupColorPicker(pParentWindow, sCommand, nColor);
2009}

2011void ColorWindow::SetNoSelection()
2012{
  mxColorSet->SetNoSelection();
  mxRecentColorSet->SetNoSelection();
  mpDefaultButton = nullptr;
2016}

2018bool ColorWindow::IsNoSelection() const
2019{
  if (!mxColorSet->IsNoSelection())
      return false;
  if (!mxRecentColorSet->IsNoSelection())
      return false;
  return !mxButtonAutoColor->get_visible() && !mxButtonNoneColor->get_visible();
2025}

2027void ColorWindow::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2028{
  if (rEvent.FeatureURL.Complete == ".uno:ColorTableState")
  {
      if (rEvent.IsEnabled && mxPaletteManager->GetPalette() == 0)
      {
          mxPaletteManager->ReloadColorSet(*mxColorSet);
          mxColorSet->layoutToGivenHeight(mxColorSet->GetOutputSizePixel().Height(), mxPaletteManager->GetColorCount());
      }
  }
  else
  {
      mrColorStatus.statusChanged(rEvent);
      SelectEntry(mrColorStatus.GetColor());
  }
2042}

2044bool ColorWindow::SelectValueSetEntry(SvxColorValueSet* pColorSet, const Color& rColor)
2045{
  for (size_t i = 1; i <= pColorSet->GetItemCount(); ++i)
  {
      if (rColor == pColorSet->GetItemColor(i))
      {
          pColorSet->SelectItem(i);
          return true;
      }
  }
  return false;
2055}

2057void ColorWindow::SelectEntry(const NamedColor& rNamedColor)
2058{
  SetNoSelection();

  const Color &rColor = rNamedColor.first;

  if (mxButtonAutoColor->get_visible() && (rColor == COL_TRANSPARENT || rColor == COL_AUTO))
  {
      mpDefaultButton = mxButtonAutoColor.get();
      return;
  }

  if (mxButtonNoneColor->get_visible() && rColor == COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
  {
      mpDefaultButton = mxButtonNoneColor.get();
      return;
  }

  // try current palette
  bool bFoundColor = SelectValueSetEntry(mxColorSet.get(), rColor);
  // try recently used
  if (!bFoundColor)
      bFoundColor = SelectValueSetEntry(mxRecentColorSet.get(), rColor);
  // if it's not there, add it there now to the end of the recently used
  // so its available somewhere handy, but not without trashing the
  // whole recently used
  if (!bFoundColor)
  {
      const OUString& rColorName = rNamedColor.second;
      mxPaletteManager->AddRecentColor(rColor, rColorName, false);
      mxPaletteManager->ReloadRecentColorSet(*mxRecentColorSet);
      SelectValueSetEntry(mxRecentColorSet.get(), rColor);
  }
2090}

2092void ColorWindow::SelectEntry(const Color& rColor)
2093{
  OUString sColorName = "#" + rColor.AsRGBHexString().toAsciiUpperCase();
  ColorWindow::SelectEntry(std::make_pair(rColor, sColorName));
2096}

2098ColorStatus::ColorStatus() :
  maColor( COL_TRANSPARENT ),
  maTLBRColor( COL_TRANSPARENT ),
  maBLTRColor( COL_TRANSPARENT )
2102{
2103}

2105ColorStatus::~ColorStatus()
2106{
2107}

2109void ColorStatus::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2110{
  Color aColor( COL_TRANSPARENT );
  css::table::BorderLine2 aTable;

  if ( rEvent.State >>= aTable )
  {
      SvxBorderLine aLine;
      SvxBoxItem::LineToSvxLine( aTable, aLine, false );
      if ( !aLine.isEmpty() )
          aColor = aLine.GetColor();
  }
  else
      rEvent.State >>= aColor;

  if ( rEvent.FeatureURL.Path == "BorderTLBR" )
      maTLBRColor = aColor;
  else if ( rEvent.FeatureURL.Path == "BorderBLTR" )
      maBLTRColor = aColor;
  else
      maColor = aColor;
2130}

2132Color ColorStatus::GetColor()
2133{
  Color aColor( maColor );

  if ( maTLBRColor != COL_TRANSPARENT )
  {
      if ( aColor != maTLBRColor && aColor != COL_TRANSPARENT )
          return COL_TRANSPARENT;
      aColor = maTLBRColor;
  }

  if ( maBLTRColor != COL_TRANSPARENT )
  {
      if ( aColor != maBLTRColor && aColor != COL_TRANSPARENT )
          return COL_TRANSPARENT;
      return maBLTRColor;
  }

  return aColor;
2151}


2154SvxFrameWindow_Impl::SvxFrameWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent)
  : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/floatingframeborder.ui", "FloatingFrameBorder")
  , mxControl(pControl)
  , mxFrameSet(new SvxFrmValueSet_Impl)
  , mxFrameSetWin(new weld::CustomWeld(*m_xBuilder, "valueset", *mxFrameSet))
  , bParagraphMode(false)
2160{
  mxFrameSet->SetStyle(WB_ITEMBORDER(WinBits(0x00010000)) | WB_DOUBLEBORDER(WinBits(0x00020000)) | WB_3DLOOK | WB_NO_DIRECTSELECT(WinBits(0x04000000)));
  AddStatusListener(".uno:BorderReducedMode");
  InitImageList();

  /*
   *  1       2        3         4
   *  -------------------------------------
   *  NONE    LEFT     RIGHT     LEFTRIGHT
   *  TOP     BOTTOM   TOPBOTTOM OUTER
   *  -------------------------------------
   *  HOR     HORINNER VERINNER   ALL         <- can be switched of via bParagraphMode
   */

  sal_uInt16 i = 0;

  for ( i=1; i<9; i++ )
      mxFrameSet->InsertItem(i, Image(aImgVec[i-1]));

  //bParagraphMode should have been set in StateChanged
  if ( !bParagraphMode )
      for ( i = 9; i < 13; i++ )
          mxFrameSet->InsertItem(i, Image(aImgVec[i-1]));

  mxFrameSet->SetColCount( 4 );
  mxFrameSet->SetSelectHdl( LINK( this, SvxFrameWindow_Impl, SelectHdl )::tools::detail::makeLink( ::tools::detail::castTo<SvxFrameWindow_Impl
 *>(this), &SvxFrameWindow_Impl::LinkStubSelectHdl) );
  CalcSizeValueSet();

  mxFrameSet->SetHelpId( HID_POPUP_FRAME"SVX_HID_POPUP_FRAME" );
  mxFrameSet->SetAccessibleName( SvxResId(RID_SVXSTR_FRAMEreinterpret_cast<char const *>("RID_SVXSTR_FRAME" "\004"
 u8"Borders")) );
2190}

2192namespace {

2194enum class FrmValidFlags {
  NONE      = 0x00,
  Left      = 0x01,
  Right     = 0x02,
  Top       = 0x04,
  Bottom    = 0x08,
  HInner    = 0x10,
  VInner    = 0x20,
  AllMask   = 0x3f,
2203};

2205}

2207namespace o3tl {
  template<> struct typed_flags<FrmValidFlags> : is_typed_flags<FrmValidFlags, 0x3f> {};
2209}

2211// By default unset lines remain unchanged.
2212// Via Shift unset lines are reset

2214IMPL_LINK_NOARG(SvxFrameWindow_Impl, SelectHdl, ValueSet*, void)void SvxFrameWindow_Impl::LinkStubSelectHdl(void * instance, ValueSet
* data) { return static_cast<SvxFrameWindow_Impl *>(instance
)->SelectHdl(data); } void SvxFrameWindow_Impl::SelectHdl(
__attribute__ ((unused)) ValueSet*)
2215{
  SvxBoxItem          aBorderOuter( SID_ATTR_BORDER_OUTER( 10000 + 24 ) );
  SvxBoxInfoItem      aBorderInner( SID_ATTR_BORDER_INNERTypedWhichId<SvxBoxInfoItem>( 10000 + 23 ) );
  SvxBorderLine       theDefLine;
  SvxBorderLine       *pLeft = nullptr,
                      *pRight = nullptr,
                      *pTop = nullptr,
                      *pBottom = nullptr;
  sal_uInt16           nSel = mxFrameSet->GetSelectedItemId();
  sal_uInt16           nModifier = mxFrameSet->GetModifier();
  FrmValidFlags        nValidFlags = FrmValidFlags::NONE;

  theDefLine.GuessLinesWidths(theDefLine.GetBorderLineStyle(),
          DEF_LINE_WIDTH_01);
  switch ( nSel )
  {
      case 1: nValidFlags |= FrmValidFlags::AllMask;
      break;  // NONE
      case 2: pLeft = &theDefLine;
              nValidFlags |= FrmValidFlags::Left;
      break;  // LEFT
      case 3: pRight = &theDefLine;
              nValidFlags |= FrmValidFlags::Right;
      break;  // RIGHT
      case 4: pLeft = pRight = &theDefLine;
              nValidFlags |=  FrmValidFlags::Right|FrmValidFlags::Left;
      break;  // LEFTRIGHT
      case 5: pTop = &theDefLine;
              nValidFlags |= FrmValidFlags::Top;
      break;  // TOP
      case 6: pBottom = &theDefLine;
              nValidFlags |= FrmValidFlags::Bottom;
      break;  // BOTTOM
      case 7: pTop =  pBottom = &theDefLine;
              nValidFlags |= FrmValidFlags::Bottom|FrmValidFlags::Top;
      break;  // TOPBOTTOM
      case 8: pLeft = pRight = pTop = pBottom = &theDefLine;
              nValidFlags |= FrmValidFlags::Left | FrmValidFlags::Right | FrmValidFlags::Top | FrmValidFlags::Bottom;
      break;  // OUTER

      // Inner Table:
      case 9: // HOR
          pTop = pBottom = &theDefLine;
          aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
          aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::VERT );
          nValidFlags |= FrmValidFlags::HInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
          break;

      case 10: // HORINNER
          pLeft = pRight = pTop = pBottom = &theDefLine;
          aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
          aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::VERT );
          nValidFlags |= FrmValidFlags::Right|FrmValidFlags::Left|FrmValidFlags::HInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
          break;

      case 11: // VERINNER
          pLeft = pRight = pTop = pBottom = &theDefLine;
          aBorderInner.SetLine( nullptr, SvxBoxInfoItemLine::HORI );
          aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::VERT );
          nValidFlags |= FrmValidFlags::Right|FrmValidFlags::Left|FrmValidFlags::VInner|FrmValidFlags::Top|FrmValidFlags::Bottom;
      break;

      case 12: // ALL
          pLeft = pRight = pTop = pBottom = &theDefLine;
          aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::HORI );
          aBorderInner.SetLine( &theDefLine, SvxBoxInfoItemLine::VERT );
          nValidFlags |= FrmValidFlags::AllMask;
          break;

      default:
      break;
  }
  aBorderOuter.SetLine( pLeft, SvxBoxItemLine::LEFT );
  aBorderOuter.SetLine( pRight, SvxBoxItemLine::RIGHT );
  aBorderOuter.SetLine( pTop, SvxBoxItemLine::TOP );
  aBorderOuter.SetLine( pBottom, SvxBoxItemLine::BOTTOM );

  if(nModifier == KEY_SHIFT)
      nValidFlags |= FrmValidFlags::AllMask;
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::TOP,       bool(nValidFlags&FrmValidFlags::Top ));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::BOTTOM,    bool(nValidFlags&FrmValidFlags::Bottom ));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::LEFT,      bool(nValidFlags&FrmValidFlags::Left));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::RIGHT,     bool(nValidFlags&FrmValidFlags::Right ));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::HORI,      bool(nValidFlags&FrmValidFlags::HInner ));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::VERT,      bool(nValidFlags&FrmValidFlags::VInner));
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::DISTANCE );
  aBorderInner.SetValid( SvxBoxInfoItemValidFlags::DISABLE,   false );

  Any a;
  Sequence< PropertyValue > aArgs( 2 );
  aArgs[0].Name = "OuterBorder";
  aBorderOuter.QueryValue( a );
  aArgs[0].Value = a;
  aArgs[1].Name = "InnerBorder";
  aBorderInner.QueryValue( a );
  aArgs[1].Value = a;

  if (mxFrameSet)
  {
      /* #i33380# Moved the following line above the Dispatch() call.
         This instance may be deleted in the meantime (i.e. when a dialog is opened
         while in Dispatch()), accessing members will crash in this case. */
      mxFrameSet->SetNoSelection();
  }

  mxControl->dispatchCommand( ".uno:SetBorderStyle", aArgs );

  mxControl->EndPopupMode();
2323}

2325void SvxFrameWindow_Impl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2326{
  if ( rEvent.FeatureURL.Complete != ".uno:BorderReducedMode" )
      return;

  bool bValue;
  if ( !(rEvent.State >>= bValue) )
      return;

  bParagraphMode = bValue;
  //initial calls mustn't insert or remove elements
  if(!mxFrameSet->GetItemCount())
      return;

  bool bTableMode = ( mxFrameSet->GetItemCount() == 12 );
  bool bResize    = false;

  if ( bTableMode && bParagraphMode )
  {
      for ( sal_uInt16 i = 9; i < 13; i++ )
          mxFrameSet->RemoveItem(i);
      bResize = true;
  }
  else if ( !bTableMode && !bParagraphMode )
  {
      for ( sal_uInt16 i = 9; i < 13; i++ )
          mxFrameSet->InsertItem(i, Image(aImgVec[i-1]));
      bResize = true;
  }

  if ( bResize )
  {
      CalcSizeValueSet();
  }
2359}

2361void SvxFrameWindow_Impl::CalcSizeValueSet()
2362{
  weld::DrawingArea* pDrawingArea = mxFrameSet->GetDrawingArea();
  const OutputDevice& rDevice = pDrawingArea->get_ref_device();
  Size aItemSize( 20 * rDevice.GetDPIScaleFactor(), 20 * rDevice.GetDPIScaleFactor() );
  Size aSize = mxFrameSet->CalcWindowSizePixel( aItemSize );
  pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
  mxFrameSet->SetOutputSizePixel(aSize);
2369}

2371void SvxFrameWindow_Impl::InitImageList()
2372{
  aImgVec.clear();
  aImgVec.emplace_back(RID_SVXBMP_FRAME1"svx/res/fr01.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME2"svx/res/fr02.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME3"svx/res/fr03.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME4"svx/res/fr04.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME5"svx/res/fr05.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME6"svx/res/fr06.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME7"svx/res/fr07.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME8"svx/res/fr08.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME9"svx/res/fr09.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME10"svx/res/fr010.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME11"svx/res/fr011.png");
  aImgVec.emplace_back(RID_SVXBMP_FRAME12"svx/res/fr012.png");
2386}

2388static Color lcl_mediumColor( Color aMain, Color /*aDefault*/ )
2389{
  return SvxBorderLine::threeDMediumColor( aMain );
2391}

2393SvxLineWindow_Impl::SvxLineWindow_Impl(SvxFrameToolBoxControl* pControl, weld::Widget* pParent)
  : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/floatingframeborder.ui", "FloatingFrameBorder")
  , m_xControl(pControl)
  , m_xLineStyleLb(new LineListBox)
  , m_xLineStyleLbWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xLineStyleLb))
  , m_bIsWriter(false)
2399{
  try
  {
      Reference< lang::XServiceInfo > xServices(m_xFrame->getController()->getModel(), UNO_QUERY_THROW);
      m_bIsWriter = xServices->supportsService("com.sun.star.text.TextDocument");
  }
  catch(const uno::Exception& )
  {
  }

  m_xLineStyleLb->SetStyle( WinBits(WB_FLATVALUESET(WinBits(0x02000000)) | WB_ITEMBORDER(WinBits(0x00010000)) | WB_3DLOOK | WB_NO_DIRECTSELECT(WinBits(0x04000000)) | WB_TABSTOP) );

  m_xLineStyleLb->SetSourceUnit( FieldUnit::TWIP );
  m_xLineStyleLb->SetNone( comphelper::LibreOfficeKit::isActive() ? SvxResId(RID_SVXSTR_INVISIBLEreinterpret_cast<char const *>("RID_SVXSTR_INVISIBLE" "\004"
 u8"None"))
      :SvxResId(RID_SVXSTR_NONEreinterpret_cast<char const *>("RID_SVXSTR_NONE" "\004"
 u8"- none -")) );

  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::SOLID ), SvxBorderLineStyle::SOLID );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DOTTED ), SvxBorderLineStyle::DOTTED );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DASHED ), SvxBorderLineStyle::DASHED );

  // Double lines
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::DOUBLE ), SvxBorderLineStyle::DOUBLE );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_SMALLGAP ), SvxBorderLineStyle::THINTHICK_SMALLGAP, 20 );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_MEDIUMGAP ), SvxBorderLineStyle::THINTHICK_MEDIUMGAP );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THINTHICK_LARGEGAP ), SvxBorderLineStyle::THINTHICK_LARGEGAP );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_SMALLGAP ), SvxBorderLineStyle::THICKTHIN_SMALLGAP, 20 );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_MEDIUMGAP ), SvxBorderLineStyle::THICKTHIN_MEDIUMGAP );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::THICKTHIN_LARGEGAP ), SvxBorderLineStyle::THICKTHIN_LARGEGAP );

  // Engraved / Embossed
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::EMBOSSED ), SvxBorderLineStyle::EMBOSSED, 15,
          &SvxBorderLine::threeDLightColor, &SvxBorderLine::threeDDarkColor,
          &lcl_mediumColor );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::ENGRAVED ), SvxBorderLineStyle::ENGRAVED, 15,
          &SvxBorderLine::threeDDarkColor, &SvxBorderLine::threeDLightColor,
          &lcl_mediumColor );

  // Inset / Outset
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::OUTSET ), SvxBorderLineStyle::OUTSET, 10,
         &SvxBorderLine::lightColor, &SvxBorderLine::darkColor );
  m_xLineStyleLb->InsertEntry( SvxBorderLine::getWidthImpl( SvxBorderLineStyle::INSET ), SvxBorderLineStyle::INSET, 10,
         &SvxBorderLine::darkColor, &SvxBorderLine::lightColor );
  Size aSize = m_xLineStyleLb->SetWidth( 20 ); // 1pt by default

  m_xLineStyleLb->SetSelectHdl( LINK( this, SvxLineWindow_Impl, SelectHdl )::tools::detail::makeLink( ::tools::detail::castTo<SvxLineWindow_Impl
 *>(this), &SvxLineWindow_Impl::LinkStubSelectHdl) );

  m_xContainer->set_help_id(HID_POPUP_LINE"SVX_HID_POPUP_LINE");

  aSize.AdjustWidth(6);
  aSize.AdjustHeight(6);
  aSize = m_xLineStyleLb->CalcWindowSizePixel(aSize);
  m_xLineStyleLb->GetDrawingArea()->set_size_request(aSize.Width(), aSize.Height());
  m_xLineStyleLb->SetOutputSizePixel(aSize);
2452}

2454IMPL_LINK_NOARG(SvxLineWindow_Impl, SelectHdl, ValueSet*, void)void SvxLineWindow_Impl::LinkStubSelectHdl(void * instance, ValueSet
* data) { return static_cast<SvxLineWindow_Impl *>(instance
)->SelectHdl(data); } void SvxLineWindow_Impl::SelectHdl(__attribute__
 ((unused)) ValueSet*)
2455{
  SvxLineItem     aLineItem( SID_FRAME_LINESTYLETypedWhichId<SvxLineItem>( 10000 + 201 ) );
  SvxBorderLineStyle  nStyle = m_xLineStyleLb->GetSelectEntryStyle();

  if ( m_xLineStyleLb->GetSelectItemPos( ) > 0 )
  {
      SvxBorderLine aTmp;
      aTmp.SetBorderLineStyle( nStyle );
      aTmp.SetWidth( 20 ); // TODO Make it depend on a width field
      aLineItem.SetLine( &aTmp );
  }
  else
      aLineItem.SetLine( nullptr );

  Any a;
  Sequence< PropertyValue > aArgs( 1 );
  aArgs[0].Name = "LineStyle";
  aLineItem.QueryValue( a, m_bIsWriter ? CONVERT_TWIPS0x80 : 0 );
  aArgs[0].Value = a;

  m_xControl->dispatchCommand( ".uno:LineStyle", aArgs );

  m_xControl->EndPopupMode();
2478}

2480SfxStyleControllerItem_Impl::SfxStyleControllerItem_Impl(
  const Reference< XDispatchProvider >& rDispatchProvider,
  sal_uInt16                                nSlotId,      // Family-ID
  const OUString&                  rCommand,     // .uno: command bound to this item
  SvxStyleToolBoxControl&               rTbxCtl )     // controller instance, which the item is assigned to.
  :   SfxStatusListener( rDispatchProvider, nSlotId, rCommand ),
      rControl( rTbxCtl )
2487{
2488}

2490void SfxStyleControllerItem_Impl::StateChanged(
  SfxItemState eState, const SfxPoolItem* pState )
2492{
  switch ( GetId() )
  {
      case SID_STYLE_FAMILY1((5000 + 541)):
      case SID_STYLE_FAMILY2((5000 + 541) + 1):
      case SID_STYLE_FAMILY3((5000 + 541) + 2):
      case SID_STYLE_FAMILY4((5000 + 541) + 3):
      case SID_STYLE_FAMILY5((5000 + 541) + 4):
      {
          const sal_uInt16 nIdx = GetId() - SID_STYLE_FAMILY_START(5000 + 541);

          if ( SfxItemState::DEFAULT == eState )
          {
              const SfxTemplateItem* pStateItem =
                  dynamic_cast<const SfxTemplateItem*>( pState  );
              DBG_ASSERT( pStateItem != nullptr, "SfxTemplateItem expected" )do { if (true && (!(pStateItem != nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2507" ": "), "%s", "SfxTemplateItem expected"); } } while
 (false);
              rControl.SetFamilyState( nIdx, pStateItem );
          }
          else
              rControl.SetFamilyState( nIdx, nullptr );
          break;
      }
  }
2515}

2517struct SvxStyleToolBoxControl::Impl
2518{
  OUString                     aClearForm;
  OUString                     aMore;
  ::std::vector< OUString >    aDefaultStyles;
  bool                     bSpecModeWriter;
  bool                     bSpecModeCalc;

  VclPtr<SvxStyleBox_Impl> m_xVclBox;
  std::unique_ptr<SvxStyleBox_Base> m_xWeldBox;
  SvxStyleBox_Base* m_pBox;

  Impl()
      :aClearForm         ( SvxResId( RID_SVXSTR_CLEARFORMreinterpret_cast<char const *>("RID_SVXSTR_CLEARFORM" "\004"
 u8"Clear formatting") ) )
      ,aMore              ( SvxResId( RID_SVXSTR_MORE_STYLESreinterpret_cast<char const *>("RID_SVXSTR_MORE_STYLES"
 "\004" u8"More Styles...") ) )
      ,bSpecModeWriter    ( false )
      ,bSpecModeCalc      ( false )
      ,m_pBox             ( nullptr )
  {


  }
  void InitializeStyles(const Reference < frame::XModel >& xModel)
  {
      aDefaultStyles.clear();

      //now convert the default style names to the localized names
      try
      {
          Reference< style::XStyleFamiliesSupplier > xStylesSupplier( xModel, UNO_QUERY_THROW );
          Reference< lang::XServiceInfo > xServices( xModel, UNO_QUERY_THROW );
          bSpecModeWriter = xServices->supportsService("com.sun.star.text.TextDocument");
          if(bSpecModeWriter)
          {
              Reference<container::XNameAccess> xParaStyles;
              xStylesSupplier->getStyleFamilies()->getByName("ParagraphStyles") >>=
                  xParaStyles;
              static const std::vector<OUString> aWriterStyles =
              {
                  "Standard",
                  "Text body",
                  "Title",
                  "Subtitle",
                  "Heading 1",
                  "Heading 2",
                  "Heading 3",
                  "Quotations"
              };
              for( const OUString& aStyle: aWriterStyles )
              {
                  try
                  {
                      Reference< beans::XPropertySet > xStyle;
                      xParaStyles->getByName( aStyle ) >>= xStyle;
                      OUString sName;
                      xStyle->getPropertyValue("DisplayName") >>= sName;
                      if( !sName.isEmpty() )
                          aDefaultStyles.push_back(sName);
                  }
                  catch( const uno::Exception& )
                  {}
              }

          }
          else if( (
              bSpecModeCalc = xServices->supportsService(
                  "com.sun.star.sheet.SpreadsheetDocument")))
          {
              static const char* aCalcStyles[] =
              {
                  "Default",
                  "Heading1",
                  "Result",
                  "Result2"
              };
              Reference<container::XNameAccess> xCellStyles;
              xStylesSupplier->getStyleFamilies()->getByName("CellStyles") >>= xCellStyles;
              for(const char* pCalcStyle : aCalcStyles)
              {
                  try
                  {
                      const OUString sStyleName( OUString::createFromAscii( pCalcStyle ) );
                      if( xCellStyles->hasByName( sStyleName ) )
                      {
                          Reference< beans::XPropertySet > xStyle( xCellStyles->getByName( sStyleName), UNO_QUERY_THROW );
                          OUString sName;
                          xStyle->getPropertyValue("DisplayName") >>= sName;
                          if( !sName.isEmpty() )
                              aDefaultStyles.push_back(sName);
                      }
                  }
                  catch( const uno::Exception& )
                  {}
              }
          }
      }
      catch(const uno::Exception& )
      {
          OSL_FAIL("error while initializing style names")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2615" ": "), "%s", "error while initializing style names"
); } } while (false);
      }
  }
2618};

2620// mapping table from bound items. BE CAREFUL this table must be in the
2621// same order as the uno commands bound to the slots SID_STYLE_FAMILY1..n
2622// MAX_FAMILIES must also be correctly set!
2623static const char* StyleSlotToStyleCommand[MAX_FAMILIES5] =
2624{
  ".uno:CharStyle",
  ".uno:ParaStyle",
  ".uno:FrameStyle",
  ".uno:PageStyle",
  ".uno:TemplateFamily5"
2630};

2632SvxStyleToolBoxControl::SvxStyleToolBoxControl()
  : pImpl(new Impl)
  , pStyleSheetPool(nullptr)
  , nActFamily(0xffff)
2636{
  for (sal_uInt16 i = 0; i < MAX_FAMILIES5; ++i)
  {
      pBoundItems[i] = nullptr;
      m_xBoundItems[i].clear();
      pFamilyState[i]  = nullptr;
  }
2643}

2645SvxStyleToolBoxControl::~SvxStyleToolBoxControl()
2646{
2647}

2649void SAL_CALL SvxStyleToolBoxControl::initialize(const Sequence<Any>& rArguments)
2650{
  svt::ToolboxController::initialize(rArguments);

  // After initialize we should have a valid frame member where we can retrieve our
  // dispatch provider.
  if ( !m_xFrame.is() )
      return;

  pImpl->InitializeStyles(m_xFrame->getController()->getModel());
  Reference< XDispatchProvider > xDispatchProvider( m_xFrame->getController(), UNO_QUERY );
  for ( sal_uInt16 i=0; i<MAX_FAMILIES5; i++ )
  {
      pBoundItems[i]   = new SfxStyleControllerItem_Impl( xDispatchProvider,
                                                          SID_STYLE_FAMILY_START(5000 + 541) + i,
                                                          OUString::createFromAscii( StyleSlotToStyleCommand[i] ),
                                                          *this );
      m_xBoundItems[i].set( static_cast< OWeakObject* >( pBoundItems[i] ), UNO_QUERY );
      pFamilyState[i]  = nullptr;
  }
2669}

2671// XComponent
2672void SAL_CALL SvxStyleToolBoxControl::dispose()
2673{
  svt::ToolboxController::dispose();

  SolarMutexGuard aSolarMutexGuard;
  pImpl->m_xVclBox.disposeAndClear();
  pImpl->m_xWeldBox.reset();
  pImpl->m_pBox = nullptr;

  for (SfxStyleControllerItem_Impl* pBoundItem : pBoundItems)
  {
      if (!pBoundItem)
          continue;
      pBoundItem->UnBind();
  }
  unbindListener();

  for( sal_uInt16 i=0; i<MAX_FAMILIES5; i++ )
  {
      if ( m_xBoundItems[i].is() )
      {
          try
          {
              m_xBoundItems[i]->dispose();
          }
          catch ( Exception& )
          {
          }

          m_xBoundItems[i].clear();
          pBoundItems[i] = nullptr;
      }
      pFamilyState[i].reset();
  }
  pStyleSheetPool = nullptr;
  pImpl.reset();
2708}

2710OUString SvxStyleToolBoxControl::getImplementationName()
2711{
  return "com.sun.star.comp.svx.StyleToolBoxControl";
2713}

2715sal_Bool SvxStyleToolBoxControl::supportsService( const OUString& rServiceName )
2716{
  return cppu::supportsService( this, rServiceName );
2718}

2720css::uno::Sequence< OUString > SvxStyleToolBoxControl::getSupportedServiceNames()
2721{
  return { "com.sun.star.frame.ToolbarController" };
2723}

2725extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
2726com_sun_star_comp_svx_StyleToolBoxControl_get_implementation(
  css::uno::XComponentContext*,
  css::uno::Sequence<css::uno::Any> const & )
2729{
  return cppu::acquire( new SvxStyleToolBoxControl() );
2731}

2733void SAL_CALL SvxStyleToolBoxControl::update()
2734{
  for (SfxStyleControllerItem_Impl* pBoundItem : pBoundItems)
      pBoundItem->ReBind();
  bindListener();
2738}

2740SfxStyleFamily SvxStyleToolBoxControl::GetActFamily() const
2741{
  switch ( nActFamily-1 + SID_STYLE_FAMILY_START(5000 + 541) )
  {
      case SID_STYLE_FAMILY1((5000 + 541)): return SfxStyleFamily::Char;
      case SID_STYLE_FAMILY2((5000 + 541) + 1): return SfxStyleFamily::Para;
      case SID_STYLE_FAMILY3((5000 + 541) + 2): return SfxStyleFamily::Frame;
      case SID_STYLE_FAMILY4((5000 + 541) + 3): return SfxStyleFamily::Page;
      case SID_STYLE_FAMILY5((5000 + 541) + 4): return SfxStyleFamily::Pseudo;
      default:
          OSL_FAIL( "unknown style family" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2750" ": "), "%s", "unknown style family"); } } while (
false);
          break;
  }
  return SfxStyleFamily::Para;
2754}

2756void SvxStyleToolBoxControl::FillStyleBox()
2757{
  SvxStyleBox_Base* pBox = pImpl->m_pBox;

  DBG_ASSERT( pStyleSheetPool, "StyleSheetPool not found!" )do { if (true && (!(pStyleSheetPool))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2760" ": "), "%s", "StyleSheetPool not found!"); } } while
 (false);
  DBG_ASSERT( pBox,            "Control not found!" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2761" ": "), "%s", "Control not found!"); } } while (false
);

  if ( !(pStyleSheetPool && pBox && nActFamily!=0xffff) )
      return;

  const SfxStyleFamily    eFamily     = GetActFamily();
  SfxStyleSheetBase*      pStyle      = nullptr;
  bool                    bDoFill     = false;

  auto xIter = pStyleSheetPool->CreateIterator(eFamily, SfxStyleSearchBits::Used);
  sal_uInt16 nCount = xIter->Count();

  // Check whether fill is necessary
  pStyle = xIter->First();
  //!!! TODO: This condition isn't right any longer, because we always show some default entries
  //!!! so the list doesn't show the count
  if ( nCount != pBox->get_count() )
  {
      bDoFill = true;
  }
  else
  {
      sal_uInt16 i= 0;
      while ( pStyle && !bDoFill )
      {
          bDoFill = ( pBox->get_text(i) != pStyle->GetName() );
          pStyle = xIter->Next();
          i++;
      }
  }

  if ( !bDoFill )
      return;

  OUString aStrSel(pBox->get_active_text());
  pBox->freeze();
  pBox->clear();

  std::vector<OUString> aStyles;

  {
      pStyle = xIter->Next();

      if( pImpl->bSpecModeWriter || pImpl->bSpecModeCalc )
      {
          while ( pStyle )
          {
              // sort out default styles
              bool bInsert = true;
              OUString aName( pStyle->GetName() );
              for( auto const & _i: pImpl->aDefaultStyles )
              {
                  if( _i == aName )
                  {
                      bInsert = false;
                      break;
                  }
              }

              if( bInsert )
                  aStyles.push_back(aName);
              pStyle = xIter->Next();
          }
      }
      else
      {
          while ( pStyle )
          {
              aStyles.push_back(pStyle->GetName());
              pStyle = xIter->Next();
          }
      }
  }

  if (pImpl->bSpecModeWriter || pImpl->bSpecModeCalc)
  {
      pBox->append_text(pImpl->aClearForm);
      pBox->insert_separator(1, "separator");

      // insert default styles
      for (const auto &rStyle : pImpl->aDefaultStyles)
          pBox->append_text(rStyle);
  }

  std::sort(aStyles.begin(), aStyles.end());

  for (const auto& rStyle : aStyles)
      pBox->append_text(rStyle);

  if ((pImpl->bSpecModeWriter || pImpl->bSpecModeCalc) && !comphelper::LibreOfficeKit::isActive())
      pBox->append_text(pImpl->aMore);

  pBox->thaw();
  pBox->set_active_or_entry_text(aStrSel);
  pBox->SetFamily( eFamily );
2856}

2858void SvxStyleToolBoxControl::SelectStyle( const OUString& rStyleName )
2859{
  SvxStyleBox_Base* pBox = pImpl->m_pBox;
  DBG_ASSERT( pBox, "Control not found!" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "2861" ": "), "%s", "Control not found!"); } } while (false
);

  if ( !pBox )
      return;

  OUString aStrSel(pBox->get_active_text());

  if ( !rStyleName.isEmpty() )
  {
      if ( rStyleName != aStrSel )
          pBox->set_active_or_entry_text( rStyleName );
  }
  else
      pBox->set_active(-1);
  pBox->save_value();
2876}

2878void SvxStyleToolBoxControl::Update()
2879{
  SfxStyleSheetBasePool*  pPool     = nullptr;
  SfxObjectShell*         pDocShell = SfxObjectShell::Current();

  if ( pDocShell )
      pPool = pDocShell->GetStyleSheetPool();

  sal_uInt16 i;
  for ( i=0; i<MAX_FAMILIES5; i++ )
      if( pFamilyState[i] )
          break;

  if ( i==MAX_FAMILIES5 || !pPool )
  {
      pStyleSheetPool = pPool;
      return;
  }


  const SfxTemplateItem* pItem = nullptr;

  if ( nActFamily == 0xffff || nullptr == (pItem = pFamilyState[nActFamily-1].get()) )
  // Current range not within allowed ranges or default
  {
      pStyleSheetPool = pPool;
      nActFamily      = 2;

      pItem = pFamilyState[nActFamily-1].get();
      if ( !pItem )
      {
          nActFamily++;
          pItem = pFamilyState[nActFamily-1].get();
      }
  }
  else if ( pPool != pStyleSheetPool )
      pStyleSheetPool = pPool;

  FillStyleBox(); // Decides by itself whether Fill is needed

  if ( pItem )
      SelectStyle( pItem->GetStyleName() );
2920}

2922void SvxStyleToolBoxControl::SetFamilyState( sal_uInt16 nIdx,
                                           const SfxTemplateItem* pItem )
2924{
  pFamilyState[nIdx].reset( pItem == nullptr ? nullptr : new SfxTemplateItem( *pItem ) );
  Update();
2927}

2929void SvxStyleToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
2930{
  SolarMutexGuard aGuard;

  if (m_pToolbar)
      m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
  else
  {
      ToolBox* pToolBox = nullptr;
      sal_uInt16 nId = 0;
      if (!getToolboxId( nId, &pToolBox ) )
          return;
      pToolBox->EnableItem( nId, rEvent.IsEnabled );
  }

  if (rEvent.IsEnabled)
      Update();
2946}

2948css::uno::Reference<css::awt::XWindow> SvxStyleToolBoxControl::createItemWindow(const css::uno::Reference< css::awt::XWindow>& rParent)
2949{
  uno::Reference< awt::XWindow > xItemWindow;

  if (m_pBuilder)
  {
      SolarMutexGuard aSolarMutexGuard;

      std::unique_ptr<weld::ComboBox> xWidget(m_pBuilder->weld_combo_box("applystyle"));

      xItemWindow = css::uno::Reference<css::awt::XWindow>(new weld::TransportAsXWindow(xWidget.get()));

      pImpl->m_xWeldBox.reset(new SvxStyleBox_Base(std::move(xWidget),
                                                   ".uno:StyleApply",
                                                   SfxStyleFamily::Para,
                                                   Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
                                                   m_xFrame,
                                                   pImpl->aClearForm,
                                                   pImpl->aMore,
                                                   pImpl->bSpecModeWriter || pImpl->bSpecModeCalc, *this));
      pImpl->m_pBox = pImpl->m_xWeldBox.get();
  }
  else
  {
      VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(rParent);
      if ( pParent )
      {
          SolarMutexGuard aSolarMutexGuard;

          pImpl->m_xVclBox = VclPtr<SvxStyleBox_Impl>::Create(pParent,
                                                              ".uno:StyleApply",
                                                              SfxStyleFamily::Para,
                                                              Reference< XDispatchProvider >( m_xFrame->getController(), UNO_QUERY ),
                                                              m_xFrame,
                                                              pImpl->aClearForm,
                                                              pImpl->aMore,
                                                              pImpl->bSpecModeWriter || pImpl->bSpecModeCalc, *this);
          pImpl->m_pBox = pImpl->m_xVclBox.get();
          xItemWindow = VCLUnoHelper::GetInterface(pImpl->m_xVclBox);
      }
  }

  if (pImpl->m_pBox && !pImpl->aDefaultStyles.empty())
      pImpl->m_pBox->SetDefaultStyle(pImpl->aDefaultStyles[0]);

  return xItemWindow;
2994}

2996SvxFontNameToolBoxControl::SvxFontNameToolBoxControl()
  : m_pBox(nullptr)
2998{
2999}

3001void SvxFontNameBox_Base::statusChanged_Impl( const css::frame::FeatureStateEvent& rEvent )
3002{
  if ( !rEvent.IsEnabled )
  {
      set_sensitive(false);
      Update( nullptr );
  }
  else
  {
      set_sensitive(true);

      css::awt::FontDescriptor aFontDesc;
      if ( rEvent.State >>= aFontDesc )
          Update(&aFontDesc);
      else
          set_active_or_entry_text("");
      m_xWidget->save_value();
  }
3019}

3021void SvxFontNameToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
3022{
  SolarMutexGuard aGuard;
  m_pBox->statusChanged_Impl(rEvent);

  if (m_pToolbar)
      m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
  else
  {
      ToolBox* pToolBox = nullptr;
      sal_uInt16 nId = 0;
      if (!getToolboxId( nId, &pToolBox ) )
          return;
      pToolBox->EnableItem( nId, rEvent.IsEnabled );
  }
3036}

3038css::uno::Reference<css::awt::XWindow> SvxFontNameToolBoxControl::createItemWindow(const css::uno::Reference<css::awt::XWindow>& rParent)
3039{
  uno::Reference< awt::XWindow > xItemWindow;

  if (m_pBuilder)
  {
      SolarMutexGuard aSolarMutexGuard;

      std::unique_ptr<weld::ComboBox> xWidget(m_pBuilder->weld_combo_box("fontnamecombobox"));

      xItemWindow = css::uno::Reference<css::awt::XWindow>(new weld::TransportAsXWindow(xWidget.get()));

      m_xWeldBox.reset(new SvxFontNameBox_Base(std::move(xWidget),
                                               Reference<XDispatchProvider>(m_xFrame->getController(), UNO_QUERY),
                                               m_xFrame, *this));
      m_pBox = m_xWeldBox.get();
  }
  else
  {
      VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(rParent);
      if ( pParent )
      {
          SolarMutexGuard aSolarMutexGuard;
          m_xVclBox = VclPtr<SvxFontNameBox_Impl>::Create(pParent,
                                                          Reference<XDispatchProvider>(m_xFrame->getController(), UNO_QUERY),
                                                          m_xFrame, *this);
          m_pBox = m_xVclBox.get();
          xItemWindow = VCLUnoHelper::GetInterface(m_xVclBox);
      }
  }

  return xItemWindow;
3070}

3072void SvxFontNameToolBoxControl::dispose()
3073{
  ToolboxController::dispose();

  SolarMutexGuard aSolarMutexGuard;
  m_xVclBox.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→
  m_xWeldBox.reset();
  m_pBox = nullptr;
3080}

3082OUString SvxFontNameToolBoxControl::getImplementationName()
3083{
  return "com.sun.star.comp.svx.FontNameToolBoxControl";
3085}

3087sal_Bool SvxFontNameToolBoxControl::supportsService( const OUString& rServiceName )
3088{
  return cppu::supportsService( this, rServiceName );
3090}

3092css::uno::Sequence< OUString > SvxFontNameToolBoxControl::getSupportedServiceNames()
3093{
  return { "com.sun.star.frame.ToolbarController" };
3095}

3097extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
3098com_sun_star_comp_svx_FontNameToolBoxControl_get_implementation(
  css::uno::XComponentContext*,
  css::uno::Sequence<css::uno::Any> const & )
3101{
  return cppu::acquire( new SvxFontNameToolBoxControl() );
3103}

3105SvxColorToolBoxControl::SvxColorToolBoxControl( const css::uno::Reference<css::uno::XComponentContext>& rContext ) :
  ImplInheritanceHelper( rContext, nullptr, OUString() ),
  m_bSplitButton(true),
  m_nSlotId(0),
  m_aColorSelectFunction(PaletteManager::DispatchColorCommand)
3110{
3111}

3113namespace {

3115sal_uInt16 MapCommandToSlotId(const OUString& rCommand)
3116{
  if (rCommand == ".uno:Color")
      return SID_ATTR_CHAR_COLOR( 10000 + 17 );
  else if (rCommand == ".uno:FontColor")
      return SID_ATTR_CHAR_COLOR2(10000 + 537);
  else if (rCommand == ".uno:BackColor")
      return SID_ATTR_CHAR_COLOR_BACKGROUND(10000 + 489);
  else if (rCommand == ".uno:CharBackColor")
      return SID_ATTR_CHAR_BACK_COLOR( 10000 + 1153 );
  else if (rCommand == ".uno:BackgroundColor")
      return SID_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 186 );
  else if (rCommand == ".uno:TableCellBackgroundColor")
      return SID_TABLE_CELL_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 1189 );
  else if (rCommand == ".uno:Extrusion3DColor")
      return SID_EXTRUSION_3D_COLOR( 10000 + 969 );
  else if (rCommand == ".uno:XLineColor")
      return SID_ATTR_LINE_COLOR( 10000 + 172 );
  else if (rCommand == ".uno:FillColor")
      return SID_ATTR_FILL_COLOR( 10000 + 165 );
  else if (rCommand == ".uno:FrameLineColor")
      return SID_FRAME_LINECOLORTypedWhichId<SvxColorItem>( 10000 + 202 );

  SAL_WARN("svx.tbxcrtls", "Unknown color command: " << rCommand)do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx.tbxcrtls")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Unknown color command: "
 << rCommand) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("svx.tbxcrtls"), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "3138" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Unknown color command: " << rCommand
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Unknown color command: " << rCommand; ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.tbxcrtls"),
 ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "3138" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Unknown color command: " << rCommand) == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.tbxcrtls"
), ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "3138" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Unknown color command: " << rCommand
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Unknown color command: " << rCommand; ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.tbxcrtls"),
 ("/home/maarten/src/libreoffice/core/svx/source/tbxctrls/tbcontrl.cxx"
 ":" "3138" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  return 0;
3140}

3142}

3144void SvxColorToolBoxControl::initialize( const css::uno::Sequence<css::uno::Any>& rArguments )
3145{
  PopupWindowController::initialize( rArguments );

  m_nSlotId = MapCommandToSlotId( m_aCommandURL );

  if ( m_nSlotId == SID_ATTR_LINE_COLOR( 10000 + 172 ) || m_nSlotId == SID_ATTR_FILL_COLOR( 10000 + 165 ) ||
       m_nSlotId == SID_FRAME_LINECOLORTypedWhichId<SvxColorItem>( 10000 + 202 ) || m_nSlotId == SID_BACKGROUND_COLORTypedWhichId<SvxColorItem>( 10000 + 186 ) )
  {
      // Sidebar uses wide buttons for those.
      m_bSplitButton = !m_bSidebar;
  }

  auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(getCommandURL(), getModuleName());
  OUString aCommandLabel = vcl::CommandInfoProvider::GetLabelForCommand(aProperties);

  OString aId(m_aCommandURL.toUtf8());

  if (m_pToolbar)
  {
      mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
      m_pToolbar->set_item_popover(aId, mxPopoverContainer->getTopLevel());
      m_xBtnUpdater.reset(new svx::ToolboxButtonColorUpdater(m_nSlotId, aId, m_pToolbar, !m_bSplitButton, aCommandLabel, m_xFrame));
      return;
  }

  ToolBox* pToolBox = nullptr;
  sal_uInt16 nId = 0;
  if (getToolboxId(nId, &pToolBox))
  {
      m_xBtnUpdater.reset( new svx::VclToolboxButtonColorUpdater( m_nSlotId, nId, pToolBox, !m_bSplitButton,  aCommandLabel, m_aCommandURL, m_xFrame ) );
      pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ( m_bSplitButton ? ToolBoxItemBits::DROPDOWN : ToolBoxItemBits::DROPDOWNONLY ) );
  }
3177}

3179void SvxColorToolBoxControl::update()
3180{
  PopupWindowController::update();

  switch( m_nSlotId )
  {
      case SID_ATTR_CHAR_COLOR2(10000 + 537):
          addStatusListener( ".uno:CharColorExt");
          break;

      case SID_ATTR_CHAR_COLOR_BACKGROUND(10000 + 489):
          addStatusListener( ".uno:CharBackgroundExt");
          break;

      case SID_FRAME_LINECOLORTypedWhichId<SvxColorItem>( 10000 + 202 ):
          addStatusListener( ".uno:BorderTLBR");
          addStatusListener( ".uno:BorderBLTR");
          break;
  }
3198}

3200void SvxColorToolBoxControl::EnsurePaletteManager()
3201{
  if (!m_xPaletteManager)
  {
      m_xPaletteManager = std::make_shared<PaletteManager>();
      m_xPaletteManager->SetBtnUpdater(m_xBtnUpdater.get());
  }
3207}

3209SvxColorToolBoxControl::~SvxColorToolBoxControl()
3210{
  if (m_xPaletteManager)
      m_xPaletteManager->SetBtnUpdater(nullptr);
3213}

3215void SvxColorToolBoxControl::setColorSelectFunction(const ColorSelectFunction& aColorSelectFunction)
3216{
  m_aColorSelectFunction = aColorSelectFunction;
  if (m_xPaletteManager)
      m_xPaletteManager->SetColorSelectFunction(aColorSelectFunction);
3220}

3222std::unique_ptr<WeldToolbarPopup> SvxColorToolBoxControl::weldPopupWindow()
3223{
  EnsurePaletteManager();

  const css::uno::Reference<css::awt::XWindow> xParent = m_xFrame->getContainerWindow();
  weld::Window* pParentFrame = Application::GetFrameWeld(xParent);

  const OString aId(m_aCommandURL.toUtf8());

  auto xPopover = std::make_unique<ColorWindow>(
                      m_aCommandURL,
                      m_xPaletteManager,
                      m_aColorStatus,
                      m_nSlotId,
                      m_xFrame,
                      pParentFrame,
                      MenuOrToolMenuButton(m_pToolbar, aId),
                      m_aColorSelectFunction);

  if ( m_bSplitButton )
      xPopover->SetSelectedHdl( LINK( this, SvxColorToolBoxControl, SelectedHdl )::tools::detail::makeLink( ::tools::detail::castTo<SvxColorToolBoxControl
 *>(this), &SvxColorToolBoxControl::LinkStubSelectedHdl
) );

  return xPopover;
3245}

3247VclPtr<vcl::Window> SvxColorToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3248{
  ToolBox* pToolBox = nullptr;
  sal_uInt16 nId = 0;
  if (!getToolboxId(nId, &pToolBox))
      return nullptr;

  const css::uno::Reference<css::awt::XWindow> xParent = m_xFrame->getContainerWindow();
  weld::Window* pParentFrame = Application::GetFrameWeld(xParent);

  EnsurePaletteManager();

  auto xPopover = std::make_unique<ColorWindow>(
                      m_aCommandURL,
                      m_xPaletteManager,
                      m_aColorStatus,
                      m_nSlotId,
                      m_xFrame,
                      pParentFrame,
                      MenuOrToolMenuButton(this, pToolBox, nId),
                      m_aColorSelectFunction);

  if ( m_bSplitButton )
      xPopover->SetSelectedHdl( LINK( this, SvxColorToolBoxControl, SelectedHdl )::tools::detail::makeLink( ::tools::detail::castTo<SvxColorToolBoxControl
 *>(this), &SvxColorToolBoxControl::LinkStubSelectedHdl
) );

  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
      std::move(xPopover), true);

  auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(m_aCommandURL, m_sModuleName);
  OUString aWindowTitle = vcl::CommandInfoProvider::GetLabelForCommand(aProperties);
  mxInterimPopover->SetText(aWindowTitle);

  mxInterimPopover->Show();

  return mxInterimPopover;
3282}

3284IMPL_LINK(SvxColorToolBoxControl, SelectedHdl, const NamedColor&, rColor, void)void SvxColorToolBoxControl::LinkStubSelectedHdl(void * instance
, const NamedColor& data) { return static_cast<SvxColorToolBoxControl
 *>(instance)->SelectedHdl(data); } void SvxColorToolBoxControl
::SelectedHdl(const NamedColor& rColor)
3285{
  m_xBtnUpdater->Update(rColor);
3287}

3289void SvxColorToolBoxControl::statusChanged( const css::frame::FeatureStateEvent& rEvent )
3290{
  ToolBox* pToolBox = nullptr;
  sal_uInt16 nId = 0;
  if (!getToolboxId(nId, &pToolBox) && !m_pToolbar)
      return;

  if ( rEvent.FeatureURL.Complete == m_aCommandURL )
  {
      if (m_pToolbar)
          m_pToolbar->set_item_sensitive(m_aCommandURL.toUtf8(), rEvent.IsEnabled);
      else
          pToolBox->EnableItem( nId, rEvent.IsEnabled );
  }

  bool bValue;
  if ( !m_bSplitButton )
  {
      m_aColorStatus.statusChanged( rEvent );
      m_xBtnUpdater->Update( m_aColorStatus.GetColor() );
  }
  else if ( rEvent.State >>= bValue )
  {
      if (m_pToolbar)
          m_pToolbar->set_item_active(m_aCommandURL.toUtf8(), bValue);
      else if (pToolBox)
          pToolBox->CheckItem( nId, bValue );
  }
3317}

3319void SvxColorToolBoxControl::execute(sal_Int16 /*nSelectModifier*/)
3320{
  if ( !m_bSplitButton )
  {
      if (m_pToolbar)
      {
          // Toggle the popup also when toolbutton is activated
          const OString aId(m_aCommandURL.toUtf8());
          m_pToolbar->set_menu_item_active(aId, !m_pToolbar->get_menu_item_active(aId));
      }
      else
      {
          // Open the popup also when Enter key is pressed.
          createPopupWindow();
      }
      return;
  }

  OUString aCommand = m_aCommandURL;
  Color aColor = m_xBtnUpdater->GetCurrentColor();

  switch( m_nSlotId )
  {
      case SID_ATTR_CHAR_COLOR2(10000 + 537) :
          aCommand    = ".uno:CharColorExt";
          break;

      case SID_ATTR_CHAR_COLOR_BACKGROUND(10000 + 489) :
          aCommand    = ".uno:CharBackgroundExt";
          break;
  }

  auto aArgs( comphelper::InitPropertySequence( {
      { m_aCommandURL.copy(5), css::uno::makeAny(aColor) }
  } ) );
  dispatchCommand( aCommand, aArgs );

  EnsurePaletteManager();
  OUString sColorName = m_xBtnUpdater->GetCurrentColorName();
  m_xPaletteManager->AddRecentColor(aColor, sColorName);
3359}

3361sal_Bool SvxColorToolBoxControl::opensSubToolbar()
3362{
  // We mark this controller as a sub-toolbar controller, so we get notified
  // (through updateImage method) on button image changes, and could redraw
  // the last used color on top of it.
  return true;
3367}

3369void SvxColorToolBoxControl::updateImage()
3370{
  m_xBtnUpdater->Update(m_xBtnUpdater->GetCurrentColor(), true);
3372}

3374OUString SvxColorToolBoxControl::getSubToolbarName()
3375{
  return OUString();
3377}

3379void SvxColorToolBoxControl::functionSelected( const OUString& /*rCommand*/ )
3380{
3381}

3383OUString SvxColorToolBoxControl::getImplementationName()
3384{
  return "com.sun.star.comp.svx.ColorToolBoxControl";
3386}

3388css::uno::Sequence<OUString> SvxColorToolBoxControl::getSupportedServiceNames()
3389{
  return { "com.sun.star.frame.ToolbarController" };
3391}

3393extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
3394com_sun_star_comp_svx_ColorToolBoxControl_get_implementation(
  css::uno::XComponentContext* rContext,
  css::uno::Sequence<css::uno::Any> const & )
3397{
  return cppu::acquire( new SvxColorToolBoxControl( rContext ) );
3399}

3401SvxFrameToolBoxControl::SvxFrameToolBoxControl( const css::uno::Reference< css::uno::XComponentContext >& rContext )
  : svt::PopupWindowController( rContext, nullptr, OUString() )
3403{
3404}

3406void SAL_CALL SvxFrameToolBoxControl::execute(sal_Int16 /*KeyModifier*/)
3407{
  if (m_pToolbar)
  {
      // Toggle the popup also when toolbutton is activated
      const OString aId(m_aCommandURL.toUtf8());
      m_pToolbar->set_menu_item_active(aId, !m_pToolbar->get_menu_item_active(aId));
  }
  else
  {
      // Open the popup also when Enter key is pressed.
      createPopupWindow();
  }
3419}

3421void SvxFrameToolBoxControl::initialize( const css::uno::Sequence< css::uno::Any >& rArguments )
3422{
  svt::PopupWindowController::initialize( rArguments );

  if (m_pToolbar)
  {
      mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
      m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel());
  }

  ToolBox* pToolBox = nullptr;
  sal_uInt16 nId = 0;
  if (getToolboxId(nId, &pToolBox))
      pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
3435}

3437std::unique_ptr<WeldToolbarPopup> SvxFrameToolBoxControl::weldPopupWindow()
3438{
  if ( m_aCommandURL == ".uno:LineStyle" )
      return std::make_unique<SvxLineWindow_Impl>(this, m_pToolbar);
  return std::make_unique<SvxFrameWindow_Impl>(this, m_pToolbar);
3442}

3444VclPtr<vcl::Window> SvxFrameToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3445{
  if ( m_aCommandURL == ".uno:LineStyle" )
  {
      mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
          std::make_unique<SvxLineWindow_Impl>(this, pParent->GetFrameWeld()));

      mxInterimPopover->Show();

      mxInterimPopover->SetText(SvxResId(RID_SVXSTR_FRAME_STYLEreinterpret_cast<char const *>("RID_SVXSTR_FRAME_STYLE"
 "\004" u8"Border Style")));

      return mxInterimPopover;
  }

  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
      std::make_unique<SvxFrameWindow_Impl>(this, pParent->GetFrameWeld()));

  mxInterimPopover->Show();

  mxInterimPopover->SetText(SvxResId(RID_SVXSTR_FRAMEreinterpret_cast<char const *>("RID_SVXSTR_FRAME" "\004"
 u8"Borders")));

  return mxInterimPopover;
3466}

3468OUString SvxFrameToolBoxControl::getImplementationName()
3469{
  return "com.sun.star.comp.svx.FrameToolBoxControl";
3471}

3473css::uno::Sequence< OUString > SvxFrameToolBoxControl::getSupportedServiceNames()
3474{
  return { "com.sun.star.frame.ToolbarController" };
3476}

3478extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
3479com_sun_star_comp_svx_FrameToolBoxControl_get_implementation(
  css::uno::XComponentContext* rContext,
  css::uno::Sequence<css::uno::Any> const & )
3482{
  return cppu::acquire( new SvxFrameToolBoxControl( rContext ) );
3484}

3486SvxCurrencyToolBoxControl::SvxCurrencyToolBoxControl( const css::uno::Reference<css::uno::XComponentContext>& rContext ) :
  PopupWindowController( rContext, nullptr, OUString() ),
  m_eLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() ),
  m_nFormatKey( NUMBERFORMAT_ENTRY_NOT_FOUND )
3490{
3491}

3493SvxCurrencyToolBoxControl::~SvxCurrencyToolBoxControl() {}

3495namespace
3496{
  class SvxCurrencyList_Impl : public WeldToolbarPopup
  {
  private:
      rtl::Reference<SvxCurrencyToolBoxControl> m_xControl;
      std::unique_ptr<weld::Label> m_xLabel;
      std::unique_ptr<weld::TreeView> m_xCurrencyLb;
      std::unique_ptr<weld::Button> m_xOkBtn;
      OUString&       m_rSelectedFormat;
      LanguageType&   m_eSelectedLanguage;

      std::vector<OUString> m_aFormatEntries;
      LanguageType          m_eFormatLanguage;
      DECL_LINK(RowActivatedHdl, weld::TreeView&, bool)static bool LinkStubRowActivatedHdl(void *, weld::TreeView&
); bool RowActivatedHdl(weld::TreeView&);
      DECL_LINK(OKHdl, weld::Button&, void)static void LinkStubOKHdl(void *, weld::Button&); void OKHdl
(weld::Button&);

      virtual void GrabFocus() override;

  public:
      SvxCurrencyList_Impl(SvxCurrencyToolBoxControl* pControl, weld::Widget* pParent, OUString& rSelectedFormat, LanguageType& eSelectedLanguage)
          : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/currencywindow.ui", "CurrencyWindow")
          , m_xControl(pControl)
          , m_xLabel(m_xBuilder->weld_label("label"))
          , m_xCurrencyLb(m_xBuilder->weld_tree_view("currency"))
          , m_xOkBtn(m_xBuilder->weld_button("ok"))
          , m_rSelectedFormat(rSelectedFormat)
          , m_eSelectedLanguage(eSelectedLanguage)
      {
          std::vector< OUString > aList;
          std::vector< sal_uInt16 > aCurrencyList;
          const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable();
          sal_uInt16 nLen = rCurrencyTable.size();

          SvNumberFormatter aFormatter( m_xControl->getContext(), LANGUAGE_SYSTEMLanguageType(0x0000) );
          m_eFormatLanguage = aFormatter.GetLanguage();

          SvxCurrencyToolBoxControl::GetCurrencySymbols( aList, true, aCurrencyList );

          sal_uInt16 nPos = 0, nCount = 0;
          sal_Int32 nSelectedPos = -1;
          bool bIsSymbol;
          NfWSStringsDtor aStringsDtor;

          OUString sLongestString;

          m_xCurrencyLb->freeze();
          for( const auto& rItem : aList )
          {
              sal_uInt16& rCurrencyIndex = aCurrencyList[ nCount ];
              if ( rCurrencyIndex < nLen )
              {
                  m_xCurrencyLb->append_text(rItem);

                  if (rItem.getLength() > sLongestString.getLength())
                      sLongestString = rItem;

                  const NfCurrencyEntry& aCurrencyEntry = rCurrencyTable[ rCurrencyIndex ];

                  bIsSymbol = nPos >= nLen;

                  sal_uInt16 nDefaultFormat = aFormatter.GetCurrencyFormatStrings( aStringsDtor, aCurrencyEntry, bIsSymbol );
                  const OUString& rFormatStr = aStringsDtor[ nDefaultFormat ];
                  m_aFormatEntries.push_back( rFormatStr );
                  if( rFormatStr == m_rSelectedFormat )
                      nSelectedPos = nPos;
                  ++nPos;
              }
              ++nCount;
          }
          m_xCurrencyLb->thaw();
          // enable multiple selection enabled so we can start with nothing selected
          m_xCurrencyLb->set_selection_mode(SelectionMode::Multiple);
          m_xCurrencyLb->connect_row_activated( LINK( this, SvxCurrencyList_Impl, RowActivatedHdl )::tools::detail::makeLink( ::tools::detail::castTo<SvxCurrencyList_Impl
 *>(this), &SvxCurrencyList_Impl::LinkStubRowActivatedHdl
) );
          m_xLabel->set_label(SvxResId(RID_SVXSTR_TBLAFMT_CURRENCYreinterpret_cast<char const *>("RID_SVXSTR_TBLAFMT_CURRENCY"
 "\004" u8"Currency")));
          m_xCurrencyLb->select( nSelectedPos );
          m_xOkBtn->connect_clicked(LINK(this, SvxCurrencyList_Impl, OKHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvxCurrencyList_Impl
 *>(this), &SvxCurrencyList_Impl::LinkStubOKHdl));

          // gtk will initially make a best guess depending on the first few entries, so copy the probable
          // longest entry to the start temporarily and force in the width at this point
          m_xCurrencyLb->insert_text(0, sLongestString);
          m_xCurrencyLb->set_size_request(m_xCurrencyLb->get_preferred_size().Width(), m_xCurrencyLb->get_height_rows(12));
          m_xCurrencyLb->remove(0);
      }
  };

  void SvxCurrencyList_Impl::GrabFocus()
  {
      m_xCurrencyLb->grab_focus();
  }

  IMPL_LINK_NOARG(SvxCurrencyList_Impl, OKHdl, weld::Button&, void)void SvxCurrencyList_Impl::LinkStubOKHdl(void * instance, weld
::Button& data) { return static_cast<SvxCurrencyList_Impl
 *>(instance)->OKHdl(data); } void SvxCurrencyList_Impl
::OKHdl(__attribute__ ((unused)) weld::Button&)
  {
      RowActivatedHdl(*m_xCurrencyLb);
  }

  IMPL_LINK_NOARG(SvxCurrencyList_Impl, RowActivatedHdl, weld::TreeView&, bool)bool SvxCurrencyList_Impl::LinkStubRowActivatedHdl(void * instance
, weld::TreeView& data) { return static_cast<SvxCurrencyList_Impl
 *>(instance)->RowActivatedHdl(data); } bool SvxCurrencyList_Impl
::RowActivatedHdl(__attribute__ ((unused)) weld::TreeView&
)
  {
      if (!m_xControl.is())
          return true;

      // multiple selection enabled so we can start with nothing selected,
      // so force single selection after something is picked
      int nSelected = m_xCurrencyLb->get_selected_index();
      if (nSelected == -1)
          return true;

      m_xCurrencyLb->set_selection_mode(SelectionMode::Single);

      m_rSelectedFormat = m_aFormatEntries[nSelected];
      m_eSelectedLanguage = m_eFormatLanguage;

      m_xControl->execute(nSelected + 1);

      m_xControl->EndPopupMode();

      return true;
  }
3613}

3615void SvxCurrencyToolBoxControl::initialize( const css::uno::Sequence< css::uno::Any >& rArguments )
3616{
  PopupWindowController::initialize(rArguments);

  if (m_pToolbar)
  {
      mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
      m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel());
      return;
  }

  ToolBox* pToolBox = nullptr;
  sal_uInt16 nId = 0;
  if (getToolboxId(nId, &pToolBox) && pToolBox->GetItemCommand(nId) == m_aCommandURL)
      pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWN | pToolBox->GetItemBits(nId));
3630}

3632std::unique_ptr<WeldToolbarPopup> SvxCurrencyToolBoxControl::weldPopupWindow()
3633{
  return std::make_unique<SvxCurrencyList_Impl>(this, m_pToolbar, m_aFormatString, m_eLanguage);
3635}

3637VclPtr<vcl::Window> SvxCurrencyToolBoxControl::createVclPopupWindow( vcl::Window* pParent )
3638{
  mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
      std::make_unique<SvxCurrencyList_Impl>(this, pParent->GetFrameWeld(), m_aFormatString, m_eLanguage));

  mxInterimPopover->Show();

  return mxInterimPopover;
3645}

3647void SvxCurrencyToolBoxControl::execute( sal_Int16 nSelectModifier )
3648{
  sal_uInt32 nFormatKey;
  if (m_aFormatString.isEmpty())
      nFormatKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
  else
  {
      if ( nSelectModifier > 0 )
      {
          try
          {
              uno::Reference< util::XNumberFormatsSupplier > xRef( m_xFrame->getController()->getModel(), uno::UNO_QUERY );
              uno::Reference< util::XNumberFormats > rxNumberFormats( xRef->getNumberFormats(), uno::UNO_SET_THROW );
              css::lang::Locale aLocale = LanguageTag::convertToLocale( m_eLanguage );
              nFormatKey = rxNumberFormats->queryKey( m_aFormatString, aLocale, false );
              if ( nFormatKey == NUMBERFORMAT_ENTRY_NOT_FOUND )
                  nFormatKey = rxNumberFormats->addNew( m_aFormatString, aLocale );
              }
              catch( const uno::Exception& )
              {
                  nFormatKey = m_nFormatKey;
              }
      }
      else
          nFormatKey = m_nFormatKey;
  }

  if( nFormatKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
  {
      Sequence< PropertyValue > aArgs( 1 );
      aArgs[0].Name = "NumberFormatCurrency";
      aArgs[0].Value <<= nFormatKey;
      dispatchCommand( m_aCommandURL, aArgs );
      m_nFormatKey = nFormatKey;
  }
  else
      PopupWindowController::execute( nSelectModifier );
3684}

3686OUString SvxCurrencyToolBoxControl::getImplementationName()
3687{
  return "com.sun.star.comp.svx.CurrencyToolBoxControl";
3689}

3691css::uno::Sequence<OUString> SvxCurrencyToolBoxControl::getSupportedServiceNames()
3692{
  return { "com.sun.star.frame.ToolbarController" };
3694}

3696extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
3697com_sun_star_comp_svx_CurrencyToolBoxControl_get_implementation(
  css::uno::XComponentContext* rContext,
  css::uno::Sequence<css::uno::Any> const & )
3700{
  return cppu::acquire( new SvxCurrencyToolBoxControl( rContext ) );
3702}

3704Reference< css::accessibility::XAccessible > SvxFontNameBox_Impl::CreateAccessible()
3705{
  FillList();
  return InterimItemWindow::CreateAccessible();
3708}

3710//static
3711void SvxCurrencyToolBoxControl::GetCurrencySymbols( std::vector<OUString>& rList, bool bFlag,
                                                  std::vector<sal_uInt16>& rCurrencyList )
3713{
  rCurrencyList.clear();

  const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable();
  sal_uInt16 nCount = rCurrencyTable.size();

  sal_uInt16 nStart = 1;

  OUString aString( ApplyLreOrRleEmbedding( rCurrencyTable[0].GetSymbol() ) + " " );
  aString += ApplyLreOrRleEmbedding( SvtLanguageTable::GetLanguageString(
                                     rCurrencyTable[0].GetLanguage() ) );

  rList.push_back( aString );
  rCurrencyList.push_back( sal_uInt16(-1) ); // nAuto

  if( bFlag )
  {
      rList.push_back( aString );
      rCurrencyList.push_back( 0 );
      ++nStart;
  }

  CollatorWrapper aCollator( ::comphelper::getProcessComponentContext() );
  aCollator.loadDefaultCollator( Application::GetSettings().GetLanguageTag().getLocale(), 0 );

  const OUString aTwoSpace("  ");

  for( sal_uInt16 i = 1; i < nCount; ++i )
  {
      OUString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i].GetBankSymbol() ) );
      aStr += aTwoSpace;
      aStr += ApplyLreOrRleEmbedding( rCurrencyTable[i].GetSymbol() );
      aStr += aTwoSpace;
      aStr += ApplyLreOrRleEmbedding( SvtLanguageTable::GetLanguageString(
                                      rCurrencyTable[i].GetLanguage() ) );

      std::vector<OUString>::size_type j = nStart;
      for( ; j < rList.size(); ++j )
          if ( aCollator.compareString( aStr, rList[j] ) < 0 )
              break;  // insert before first greater than

      rList.insert( rList.begin() + j, aStr );
      rCurrencyList.insert( rCurrencyList.begin() + j, i );
  }

  // Append ISO codes to symbol list.
  // XXX If this is to be changed, various other places would had to be
  // adapted that assume this order!
  std::vector<OUString>::size_type nCont = rList.size();

  for ( sal_uInt16 i = 1; i < nCount; ++i )
  {
      bool bInsert = true;
      OUString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i].GetBankSymbol() ) );

      std::vector<OUString>::size_type j = nCont;
      for ( ; j < rList.size() && bInsert; ++j )
      {
          if( rList[j] == aStr )
              bInsert = false;
          else if ( aCollator.compareString( aStr, rList[j] ) < 0 )
              break;  // insert before first greater than
      }
      if ( bInsert )
      {
          rList.insert( rList.begin() + j, aStr );
          rCurrencyList.insert( rCurrencyList.begin() + j, i );
      }
  }
3782}

3784ListBoxColorWrapper::ListBoxColorWrapper(ColorListBox* pControl)
  : mpControl(pControl)
3786{
3787}

3789void ListBoxColorWrapper::operator()(const OUString& /*rCommand*/, const NamedColor& rColor)
3790{
  mpControl->Selected(rColor);
3792}

3794void ColorListBox::EnsurePaletteManager()
3795{
  if (!m_xPaletteManager)
  {
      m_xPaletteManager = std::make_shared<PaletteManager>();
      m_xPaletteManager->SetColorSelectFunction(std::ref(m_aColorWrapper));
  }
3801}

3803void ColorListBox::SetSlotId(sal_uInt16 nSlotId, bool bShowNoneButton)
3804{
  m_nSlotId = nSlotId;
  m_bShowNoneButton = bShowNoneButton;
  m_xButton->set_popover(nullptr);
  m_xColorWindow.reset();
  m_aSelectedColor = bShowNoneButton ? GetNoneColor() : GetAutoColor(m_nSlotId);
  ShowPreview(m_aSelectedColor);
  createColorWindow();
3812}

3814ColorListBox::ColorListBox(std::unique_ptr<weld::MenuButton> pControl, weld::Window* pTopLevel)
  : m_xButton(std::move(pControl))
  , m_pTopLevel(pTopLevel)
  , m_aColorWrapper(this)
  , m_aAutoDisplayColor(Application::GetSettings().GetStyleSettings().GetDialogColor())
  , m_nSlotId(0)
  , m_bShowNoneButton(false)
3821{
  m_xButton->connect_toggled(LINK(this, ColorListBox, ToggleHdl)::tools::detail::makeLink( ::tools::detail::castTo<ColorListBox
 *>(this), &ColorListBox::LinkStubToggleHdl));
  m_aSelectedColor = GetAutoColor(m_nSlotId);
  LockWidthRequest();
  ShowPreview(m_aSelectedColor);
3826}

3828IMPL_LINK(ColorListBox, ToggleHdl, weld::ToggleButton&, rButton, void)void ColorListBox::LinkStubToggleHdl(void * instance, weld::ToggleButton
& data) { return static_cast<ColorListBox *>(instance
)->ToggleHdl(data); } void ColorListBox::ToggleHdl(weld::ToggleButton
& rButton)
3829{
  if (rButton.get_active())
      getColorWindow()->GrabFocus();
3832}

3834ColorListBox::~ColorListBox()
3835{
3836}

3838ColorWindow* ColorListBox::getColorWindow() const
3839{
  if (!m_xColorWindow)
      const_cast<ColorListBox*>(this)->createColorWindow();
  return m_xColorWindow.get();
3843}

3845void ColorListBox::createColorWindow()
3846{
  const SfxViewFrame* pViewFrame = SfxViewFrame::Current();
  const SfxFrame* pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
  css::uno::Reference<css::frame::XFrame> xFrame(pFrame ? pFrame->GetFrameInterface() : uno::Reference<css::frame::XFrame>());

  EnsurePaletteManager();

  m_xColorWindow.reset(new ColorWindow(
                          OUString() /*m_aCommandURL*/,
                          m_xPaletteManager,
                          m_aColorStatus,
                          m_nSlotId,
                          xFrame,
                          m_pTopLevel,
                          m_xButton.get(),
                          m_aColorWrapper));

  SetNoSelection();
  m_xButton->set_popover(m_xColorWindow->getTopLevel());
  if (m_bShowNoneButton)
      m_xColorWindow->ShowNoneButton();
  m_xColorWindow->SelectEntry(m_aSelectedColor);
3868}

3870void ColorListBox::SelectEntry(const NamedColor& rColor)
3871{
  if (rColor.second.trim().isEmpty())
  {
      SelectEntry(rColor.first);
      return;
  }
  ColorWindow* pColorWindow = getColorWindow();
  pColorWindow->SelectEntry(rColor);
  m_aSelectedColor = pColorWindow->GetSelectEntryColor();
  ShowPreview(m_aSelectedColor);
3881}

3883void ColorListBox::SelectEntry(const Color& rColor)
3884{
  ColorWindow* pColorWindow = getColorWindow();
  pColorWindow->SelectEntry(rColor);
  m_aSelectedColor = pColorWindow->GetSelectEntryColor();
  ShowPreview(m_aSelectedColor);
3889}

3891void ColorListBox::Selected(const NamedColor& rColor)
3892{
  ShowPreview(rColor);
  m_aSelectedColor = rColor;
  if (m_aSelectedLink.IsSet())
      m_aSelectedLink.Call(*this);
3897}

3899//to avoid the box resizing every time the color is changed to
3900//the optimal size of the individual color, get the longest
3901//standard color and stick with that as the size for all
3902void ColorListBox::LockWidthRequest()
3903{
  NamedColor aLongestColor;
  long nMaxStandardColorTextWidth = 0;
  XColorListRef const xColorTable = XColorList::CreateStdColorList();
  for (long i = 0; i != xColorTable->Count(); ++i)
  {
      XColorEntry& rEntry = *xColorTable->GetColor(i);
      auto nColorTextWidth = m_xButton->get_pixel_size(rEntry.GetName()).Width();
      if (nColorTextWidth > nMaxStandardColorTextWidth)
      {
          nMaxStandardColorTextWidth = nColorTextWidth;
          aLongestColor.second = rEntry.GetName();
      }
  }
  ShowPreview(aLongestColor);
  m_xButton->set_size_request(m_xButton->get_preferred_size().Width(), -1);
3919}

3921void ColorListBox::ShowPreview(const NamedColor &rColor)
3922{
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  Size aImageSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());

  ScopedVclPtrInstance<VirtualDevice> xDevice;
  xDevice->SetOutputSize(aImageSize);
  const tools::Rectangle aRect(Point(0, 0), aImageSize);
  if (m_bShowNoneButton && rColor.first == COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
  {
      const Color aW(COL_WHITE);
      const Color aG(0xef, 0xef, 0xef);
      xDevice->DrawCheckered(aRect.TopLeft(), aRect.GetSize(), 8, aW, aG);
      xDevice->SetFillColor();
  }
  else
  {
      if (rColor.first == COL_AUTO)
          xDevice->SetFillColor(m_aAutoDisplayColor);
      else
          xDevice->SetFillColor(rColor.first);
  }

  xDevice->SetLineColor(rStyleSettings.GetDisableColor());
  xDevice->DrawRect(aRect);

  m_xButton->set_image(xDevice.get());
  m_xButton->set_label(rColor.second);
3949}

3951MenuOrToolMenuButton::MenuOrToolMenuButton(weld::MenuButton* pMenuButton)
  : m_pMenuButton(pMenuButton)
  , m_pToolbar(nullptr)
  , m_pControl(nullptr)
  , m_nId(0)
3956{
3957}

3959MenuOrToolMenuButton::MenuOrToolMenuButton(weld::Toolbar* pToolbar, const OString& rIdent)
  : m_pMenuButton(nullptr)
  , m_pToolbar(pToolbar)
  , m_aIdent(rIdent)
  , m_pControl(nullptr)
  , m_nId(0)
3965{
3966}

3968MenuOrToolMenuButton::MenuOrToolMenuButton(SvxColorToolBoxControl* pControl, ToolBox* pToolbar, sal_uInt16 nId)
  : m_pMenuButton(nullptr)
  , m_pToolbar(nullptr)
  , m_pControl(pControl)
  , m_xToolBox(pToolbar)
  , m_nId(nId)
3974{
3975}

3977MenuOrToolMenuButton::~MenuOrToolMenuButton()
3978{
3979}

3981bool MenuOrToolMenuButton::get_active() const
3982{
  if (m_pMenuButton)
      return m_pMenuButton->get_active();
  if (m_pToolbar)
      return m_pToolbar->get_menu_item_active(m_aIdent);
  return m_xToolBox->GetDownItemId() == m_nId;
3988}

3990void MenuOrToolMenuButton::set_inactive() const
3991{
  if (m_pMenuButton)
  {
      if (m_pMenuButton->get_active())
          m_pMenuButton->set_active(false);
      return;
  }
  if (m_pToolbar)
  {
      if (m_pToolbar->get_menu_item_active(m_aIdent))
          m_pToolbar->set_menu_item_active(m_aIdent, false);
      return;
  }
  m_pControl->EndPopupMode();
4005}

4007weld::Widget* MenuOrToolMenuButton::get_widget() const
4008{
  if (m_pMenuButton)
      return m_pMenuButton;
  if (m_pToolbar)
      return m_pToolbar;
  return m_xToolBox->GetFrameWeld();
4014}

4016/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
2
←
Calling copy constructor for 'Reference<(anonymous namespace)::SvxFontNameBox_Impl>'→
5
←
Returning from copy constructor for 'Reference<(anonymous namespace)::SvxFontNameBox_Impl>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
6
←
Calling 'Reference::clear'→
13
←
Returning; memory was released→
      if (aTmp.get()) {
14
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody6.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
7
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
8
←
Calling 'VclReferenceBase::release'→
12
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
15
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

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#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
9
←
Assuming the condition is true→
10
←
Taking true branch→
40            delete this;
11
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif