sw/source/uibase/sidebar/PageHeaderPanel.cxx

   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 #include <sal/config.h>
  20 #include <svl/intitem.hxx>
  21 #include <svl/eitem.hxx>
  22 #include <svl/itemset.hxx>
  23 #include <svx/dlgutil.hxx>
  24 #include <svx/rulritem.hxx>
  25 #include <svx/svdtrans.hxx>
  26 #include <svx/spacinglistbox.hxx>
  27 #include <svx/samecontentlistbox.hxx>
  28 #include "PageHeaderPanel.hxx"
  29 #include <sfx2/dispatch.hxx>
  30 #include <sfx2/bindings.hxx>
  31 #include <cmdid.h>
  32
  33 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  34
  35 namespace sw::sidebar{
  36
  37 std::unique_ptr<PanelLayout> PageHeaderPanel::Create(
  38     weld::Widget* pParent,
  39     SfxBindings* pBindings)
  40 {
  41     if( pParent == nullptr )
  42         throw css::lang::IllegalArgumentException(u"no parent window given to PageHeaderPanel::Create"_ustr, nullptr, 0);
  43     if( pBindings == nullptr )
  44         throw css::lang::IllegalArgumentException(u"no SfxBindings given to PageHeaderPanel::Create"_ustr, nullptr, 0);
  45
  46     return std::make_unique<PageHeaderPanel>(pParent, pBindings);
  47 }
  48
  49 void PageHeaderPanel::SetMarginsAndSpacingFieldUnit()
  50 {
  51     SpacingListBox::Fill(IsInch(meFUnit) ? SpacingType::SPACING_INCH : SpacingType::SPACING_CM, *mxHeaderSpacingLB);
  52     SpacingListBox::Fill(IsInch(meFUnit) ? SpacingType::MARGINS_INCH : SpacingType::MARGINS_CM, *mxHeaderMarginPresetLB);
  53 }
  54
  55 PageHeaderPanel::PageHeaderPanel(
  56     weld::Widget* pParent,
  57     SfxBindings* pBindings
  58     ) :
  59     PanelLayout(pParent, u"PageHeaderPanel"_ustr, u"modules/swriter/ui/pageheaderpanel.ui"_ustr),
  60     mpBindings( pBindings ),
  61     maHFToggleController(SID_ATTR_PAGE_HEADER, *pBindings, *this),
  62     maMetricController(SID_ATTR_METRIC, *pBindings,*this),
  63     maHeaderLRMarginController(SID_ATTR_PAGE_HEADER_LRMARGIN, *pBindings, *this),
  64     maHeaderSpacingController(SID_ATTR_PAGE_HEADER_SPACING, *pBindings, *this),
  65     maHeaderLayoutController(SID_ATTR_PAGE_HEADER_LAYOUT, *pBindings, *this),
  66     meFUnit(GetModuleFieldUnit()),
  67     mpHeaderItem( new SfxBoolItem(SID_ATTR_PAGE_HEADER) ),
  68     mpHeaderLRMarginItem( new SvxLongLRSpaceItem(0, 0, SID_ATTR_PAGE_HEADER_LRMARGIN)),
  69     mpHeaderSpacingItem( new SvxLongULSpaceItem(0, 0, SID_ATTR_PAGE_HEADER_SPACING)),
  70     mpHeaderLayoutItem( new SfxInt16Item(SID_ATTR_PAGE_HEADER_LAYOUT)),
  71     mxHeaderToggle(m_xBuilder->weld_check_button(u"headertoggle"_ustr)),
  72     mxHeaderSpacingLB(m_xBuilder->weld_combo_box(u"spacingpreset"_ustr)),
  73     mxHeaderMarginPresetLB(m_xBuilder->weld_combo_box(u"headermarginpreset"_ustr)),
  74     mxHeaderLayoutLB(m_xBuilder->weld_combo_box(u"samecontentLB"_ustr)),
  75     mxCustomEntry(m_xBuilder->weld_label(u"customlabel"_ustr))
  76 {
  77     Initialize();
  78 }
  79
  80 PageHeaderPanel::~PageHeaderPanel()
  81 {
  82     mxHeaderToggle.reset();
  83     mxHeaderSpacingLB.reset();
  84     mxHeaderLayoutLB.reset();
  85     mxHeaderMarginPresetLB.reset();
  86     mxCustomEntry.reset();
  87 }
  88
  89 FieldUnit PageHeaderPanel::GetCurrentUnit(SfxItemState eState, const SfxPoolItem* pState)
  90 {
  91     FieldUnit eUnit;
  92
  93     if (pState && eState >= SfxItemState::DEFAULT)
  94         eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pState)->GetValue());
  95     else
  96         eUnit = GetModuleFieldUnit();
  97
  98     return eUnit;
  99 }
 100
 101 void PageHeaderPanel::Initialize()
 102 {
 103     SameContentListBox::Fill(*mxHeaderLayoutLB);
 104
 105     SetMarginsAndSpacingFieldUnit();
 106
 107     m_aCustomEntry = mxCustomEntry->get_label();
 108     mxHeaderToggle->connect_toggled( LINK(this, PageHeaderPanel, HeaderToggleHdl) );
 109     mxHeaderMarginPresetLB->connect_changed( LINK(this, PageHeaderPanel, HeaderLRMarginHdl));
 110     mxHeaderSpacingLB->connect_changed( LINK(this, PageHeaderPanel, HeaderSpacingHdl));
 111     mxHeaderLayoutLB->connect_changed( LINK(this, PageHeaderPanel, HeaderLayoutHdl));
 112
 113     mpBindings->Invalidate(SID_ATTR_METRIC);
 114     mpBindings->Invalidate(SID_ATTR_PAGE_HEADER);
 115     mpBindings->Invalidate(SID_ATTR_PAGE_HEADER_LRMARGIN);
 116     mpBindings->Invalidate(SID_ATTR_PAGE_HEADER_SPACING);
 117     mpBindings->Invalidate(SID_ATTR_PAGE_HEADER_LAYOUT);
 118 }
 119
 120 void PageHeaderPanel::UpdateHeaderCheck()
 121 {
 122     if (mxHeaderToggle->get_active())
 123     {
 124         mxHeaderSpacingLB->set_sensitive(true);
 125         mxHeaderLayoutLB->set_sensitive(true);
 126         mxHeaderMarginPresetLB->set_sensitive(true);
 127     }
 128     else
 129     {
 130         mxHeaderSpacingLB->set_sensitive(false);
 131         mxHeaderLayoutLB->set_sensitive(false);
 132         mxHeaderMarginPresetLB->set_sensitive(false);
 133     }
 134 }
 135
 136 void PageHeaderPanel::UpdateMarginControl()
 137 {
 138     sal_uInt16 nLeft = mpHeaderLRMarginItem->GetLeft();
 139     sal_uInt16 nRight = mpHeaderLRMarginItem->GetRight();
 140     sal_uInt16 nCount = mxHeaderMarginPresetLB->get_count();
 141     if(nLeft == nRight)
 142     {
 143         for (sal_uInt16 i = 0; i < nCount; ++i)
 144         {
 145             if (mxHeaderMarginPresetLB->get_id(i).toUInt32() == nLeft)
 146             {
 147                 mxHeaderMarginPresetLB->set_active(i);
 148                 int nCustomEntry = mxHeaderMarginPresetLB->find_text(m_aCustomEntry);
 149                 if (nCustomEntry != -1)
 150                     mxHeaderMarginPresetLB->remove(nCustomEntry);
 151                 return;
 152             }
 153         }
 154     }
 155     mxHeaderMarginPresetLB->append_text(m_aCustomEntry);
 156     mxHeaderMarginPresetLB->set_active_text(m_aCustomEntry);
 157 }
 158
 159 void PageHeaderPanel::UpdateSpacingControl()
 160 {
 161     sal_uInt16 nBottom = mpHeaderSpacingItem->GetLower();
 162     sal_uInt16 nCount = mxHeaderSpacingLB->get_count();
 163     for (sal_uInt16 i = 0; i < nCount; ++i)
 164     {
 165         if (mxHeaderSpacingLB->get_id(i).toUInt32() == nBottom)
 166         {
 167             mxHeaderSpacingLB->set_active(i);
 168             int nCustomEntry = mxHeaderSpacingLB->find_text(m_aCustomEntry);
 169             if (nCustomEntry != -1)
 170                 mxHeaderSpacingLB->remove(nCustomEntry);
 171             return;
 172         }
 173     }
 174     mxHeaderSpacingLB->append_text(m_aCustomEntry);
 175     mxHeaderSpacingLB->set_active_text(m_aCustomEntry);
 176 }
 177
 178 void PageHeaderPanel::UpdateLayoutControl()
 179 {
 180     sal_uInt16 nLayout = mpHeaderLayoutItem->GetValue();
 181     mxHeaderLayoutLB->set_active(nLayout);
 182 }
 183
 184 void PageHeaderPanel::NotifyItemUpdate(
 185     const sal_uInt16 nSid,
 186     const SfxItemState eState,
 187     const SfxPoolItem* pState)
 188 {
 189     if (!mxHeaderToggle) //disposed
 190         return;
 191
 192     switch(nSid)
 193     {
 194         case SID_ATTR_PAGE_HEADER:
 195         {
 196             if(eState >= SfxItemState::DEFAULT &&
 197                 dynamic_cast<const SfxBoolItem*>( pState) )
 198             {
 199                 mpHeaderItem.reset( static_cast<SfxBoolItem*>(pState->Clone()) );
 200                 mxHeaderToggle->set_active(mpHeaderItem->GetValue());
 201                 UpdateHeaderCheck();
 202             }
 203         }
 204         break;
 205         case SID_ATTR_PAGE_HEADER_LRMARGIN:
 206         {
 207             if(eState >= SfxItemState::DEFAULT &&
 208                 dynamic_cast<const SvxLongLRSpaceItem*>( pState) )
 209             {
 210                 mpHeaderLRMarginItem.reset( static_cast<SvxLongLRSpaceItem*>(pState->Clone()) );
 211                 UpdateMarginControl();
 212             }
 213         }
 214         break;
 215         case SID_ATTR_PAGE_HEADER_SPACING:
 216         {
 217             if(eState >= SfxItemState::DEFAULT &&
 218                 dynamic_cast<const SvxLongULSpaceItem*>( pState) )
 219             {
 220                 mpHeaderSpacingItem.reset(static_cast<SvxLongULSpaceItem*>(pState->Clone()) );
 221                 UpdateSpacingControl();
 222             }
 223         }
 224         break;
 225         case SID_ATTR_PAGE_HEADER_LAYOUT:
 226         {
 227             if(eState >= SfxItemState::DEFAULT &&
 228                 dynamic_cast<const SfxInt16Item*>( pState) )
 229             {
 230                 mpHeaderLayoutItem.reset(static_cast<SfxInt16Item*>(pState->Clone()) );
 231                 UpdateLayoutControl();
 232             }
 233         }
 234         break;
 235         case SID_ATTR_METRIC:
 236         {
 237             FieldUnit eFUnit = GetCurrentUnit(eState, pState);
 238             if (meFUnit != eFUnit)
 239             {
 240                 meFUnit = eFUnit;
 241                 SetMarginsAndSpacingFieldUnit();
 242                 UpdateSpacingControl();
 243                 UpdateMarginControl();
 244             }
 245         }
 246         break;
 247         default:
 248             break;
 249     }
 250 }
 251
 252 IMPL_LINK_NOARG( PageHeaderPanel, HeaderToggleHdl, weld::Toggleable&, void )
 253 {
 254     bool IsChecked = mxHeaderToggle->get_active();
 255     mpHeaderItem->SetValue(IsChecked);
 256     GetBindings()->GetDispatcher()->ExecuteList( SID_ATTR_PAGE_HEADER, SfxCallMode::RECORD, { mpHeaderItem.get() } );
 257     UpdateHeaderCheck();
 258 }
 259
 260 IMPL_LINK_NOARG( PageHeaderPanel, HeaderLRMarginHdl, weld::ComboBox&, void )
 261 {
 262     sal_uInt16 nVal = mxHeaderMarginPresetLB->get_active_id().toUInt32();
 263     mpHeaderLRMarginItem->SetLeft(nVal);
 264     mpHeaderLRMarginItem->SetRight(nVal);
 265     GetBindings()->GetDispatcher()->ExecuteList( SID_ATTR_PAGE_HEADER_LRMARGIN,
 266                                                  SfxCallMode::RECORD, { mpHeaderLRMarginItem.get() } );
 267 }
 268
 269 IMPL_LINK_NOARG( PageHeaderPanel, HeaderSpacingHdl, weld::ComboBox&, void )
 270 {
 271     sal_uInt16 nVal = mxHeaderSpacingLB->get_active_id().toUInt32();
 272     mpHeaderSpacingItem->SetLower(nVal);
 273     GetBindings()->GetDispatcher()->ExecuteList( SID_ATTR_PAGE_HEADER_SPACING,
 274                                                  SfxCallMode::RECORD, { mpHeaderSpacingItem.get() } );
 275 }
 276 IMPL_LINK_NOARG( PageHeaderPanel, HeaderLayoutHdl, weld::ComboBox&, void )
 277 {
 278     sal_uInt16 nVal = mxHeaderLayoutLB->get_active();
 279     mpHeaderLayoutItem->SetValue(nVal);
 280     GetBindings()->GetDispatcher()->ExecuteList( SID_ATTR_PAGE_HEADER_LAYOUT,
 281                                                  SfxCallMode::RECORD, { mpHeaderLayoutItem.get() } );
 282 }
 283
 284
 285 }
 286
 287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */