cui/source/tabpages/tparea.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
  20 #include <svx/svxids.hrc>
  21 #include <svx/xfillit0.hxx>
  22 #include <svx/xflbckit.hxx>
  23 #include <svx/drawitem.hxx>
  24 #include <svx/xflclit.hxx>
  25 #include <svx/xflgrit.hxx>
  26 #include <svx/xflhtit.hxx>
  27 #include <svx/xbtmpit.hxx>
  28 #include <cuitabarea.hxx>
  29 #include <sfx2/tabdlg.hxx>
  30
  31 using namespace com::sun::star;
  32
  33 // static ----------------------------------------------------------------
  34
  35 enum FillType
  36 {
  37     TRANSPARENT,
  38     SOLID,
  39     GRADIENT,
  40     HATCH,
  41     BITMAP,
  42     PATTERN
  43 };
  44
  45 const sal_uInt16 SvxAreaTabPage::pAreaRanges[] =
  46 {
  47     XATTR_GRADIENTSTEPCOUNT,
  48     XATTR_GRADIENTSTEPCOUNT,
  49     SID_ATTR_FILL_STYLE,
  50     SID_ATTR_FILL_BITMAP,
  51     0
  52 };
  53
  54 namespace
  55 {
  56
  57 void lclExtendSize(Size& rSize, const Size& rInputSize)
  58 {
  59     if (rSize.Width() < rInputSize.Width())
  60         rSize.setWidth( rInputSize.Width() );
  61     if (rSize.Height() < rInputSize.Height())
  62         rSize.setHeight( rInputSize.Height() );
  63 }
  64
  65 } // end anonymous namespace
  66
  67 /*************************************************************************
  68 |*
  69 |*  Dialog to modify fill-attributes
  70 |*
  71 \************************************************************************/
  72
  73 SvxAreaTabPage::SvxAreaTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs)
  74     : SfxTabPage(pPage, pController, "cui/ui/areatabpage.ui", "AreaTabPage", &rInAttrs)
  75     // local fixed not o be changed values for local pointers
  76     , maFixed_ChangeType(ChangeType::NONE)
  77     // init with pointers to fixed ChangeType
  78     , m_pnColorListState(&maFixed_ChangeType)
  79     , m_pnBitmapListState(&maFixed_ChangeType)
  80     , m_pnPatternListState(&maFixed_ChangeType)
  81     , m_pnGradientListState(&maFixed_ChangeType)
  82     , m_pnHatchingListState(&maFixed_ChangeType)
  83     , m_aXFillAttr(rInAttrs.GetPool())
  84     , m_rXFSet(m_aXFillAttr.GetItemSet())
  85     , m_xFillTab(m_xBuilder->weld_container("fillstylebox"))
  86     , m_xBtnNone(m_xBuilder->weld_toggle_button("btnnone"))
  87     , m_xBtnColor(m_xBuilder->weld_toggle_button("btncolor"))
  88     , m_xBtnGradient(m_xBuilder->weld_toggle_button("btngradient"))
  89     , m_xBtnHatch(m_xBuilder->weld_toggle_button("btnhatch"))
  90     , m_xBtnBitmap(m_xBuilder->weld_toggle_button("btnbitmap"))
  91     , m_xBtnPattern(m_xBuilder->weld_toggle_button("btnpattern"))
  92 {
  93     maBox.AddButton(m_xBtnNone.get());
  94     maBox.AddButton(m_xBtnColor.get());
  95     maBox.AddButton(m_xBtnGradient.get());
  96     maBox.AddButton(m_xBtnHatch.get());
  97     maBox.AddButton(m_xBtnBitmap.get());
  98     maBox.AddButton(m_xBtnPattern.get());
  99     Link<weld::ToggleButton&, void> aLink = LINK(this, SvxAreaTabPage, SelectFillTypeHdl_Impl);
 100     m_xBtnNone->connect_toggled(aLink);
 101     m_xBtnColor->connect_toggled(aLink);
 102     m_xBtnGradient->connect_toggled(aLink);
 103     m_xBtnHatch->connect_toggled(aLink);
 104     m_xBtnBitmap->connect_toggled(aLink);
 105     m_xBtnPattern->connect_toggled(aLink);
 106
 107     SetExchangeSupport();
 108 }
 109
 110 void SvxAreaTabPage::SetOptimalSize(weld::DialogController* pController)
 111 {
 112     m_xFillTab->set_size_request(-1, -1);
 113
 114     // Calculate optimal size of all pages...
 115     m_xFillTabPage = SvxColorTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet);
 116     Size aSize(m_xFillTab->get_preferred_size());
 117
 118     if (m_xBtnGradient->get_visible())
 119     {
 120         m_xFillTabPage = SvxGradientTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet);
 121         Size aGradientSize = m_xFillTab->get_preferred_size();
 122         lclExtendSize(aSize, aGradientSize);
 123     }
 124     if (m_xBtnBitmap->get_visible())
 125     {
 126         m_xFillTabPage = SvxBitmapTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet);
 127         Size aBitmapSize = m_xFillTab->get_preferred_size();
 128         lclExtendSize(aSize, aBitmapSize);
 129     }
 130     if (m_xBtnHatch->get_visible())
 131     {
 132         m_xFillTabPage = SvxHatchTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet);
 133         Size aHatchSize = m_xFillTab->get_preferred_size();
 134         lclExtendSize(aSize, aHatchSize);
 135     }
 136     if (m_xBtnPattern->get_visible())
 137     {
 138         m_xFillTabPage = SvxPatternTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet);
 139         Size aPatternSize = m_xFillTab->get_preferred_size();
 140         lclExtendSize(aSize, aPatternSize);
 141     }
 142     m_xFillTabPage.reset();
 143
 144     aSize.extendBy(10, 10); // apply a bit of margin
 145
 146     m_xFillTab->set_size_request(aSize.Width(), aSize.Height());
 147 }
 148
 149 SvxAreaTabPage::~SvxAreaTabPage()
 150 {
 151     m_xFillTabPage.reset();
 152 }
 153
 154 void SvxAreaTabPage::ActivatePage( const SfxItemSet& rSet )
 155 {
 156     drawing::FillStyle eXFS = drawing::FillStyle_NONE;
 157     if( rSet.GetItemState( XATTR_FILLSTYLE ) != SfxItemState::DONTCARE )
 158     {
 159         XFillStyleItem aFillStyleItem( static_cast<const XFillStyleItem&>( rSet.Get( GetWhich( XATTR_FILLSTYLE ) ) ) );
 160         eXFS = aFillStyleItem.GetValue();
 161         m_rXFSet.Put( aFillStyleItem );
 162     }
 163
 164     switch(eXFS)
 165     {
 166         default:
 167         case drawing::FillStyle_NONE:
 168         {
 169             SelectFillType(*m_xBtnNone);
 170             break;
 171         }
 172         case drawing::FillStyle_SOLID:
 173         {
 174             m_rXFSet.Put( static_cast<const XFillColorItem&>( rSet.Get( GetWhich( XATTR_FILLCOLOR ) ) ) );
 175             SelectFillType(*m_xBtnColor);
 176             break;
 177         }
 178         case drawing::FillStyle_GRADIENT:
 179         {
 180             m_rXFSet.Put( static_cast<const XFillGradientItem&>( rSet.Get( GetWhich( XATTR_FILLGRADIENT ) ) ) );
 181             SelectFillType(*m_xBtnGradient);
 182             break;
 183         }
 184         case drawing::FillStyle_HATCH:
 185         {
 186             m_rXFSet.Put( rSet.Get(XATTR_FILLHATCH) );
 187             m_rXFSet.Put( rSet.Get(XATTR_FILLBACKGROUND) );
 188             m_rXFSet.Put( rSet.Get(XATTR_FILLCOLOR) );
 189             SelectFillType(*m_xBtnHatch);
 190             break;
 191         }
 192         case drawing::FillStyle_BITMAP:
 193         {
 194             const bool bPattern
 195                 = rSet.Get(TypedWhichId<XFillBitmapItem>(GetWhich(XATTR_FILLBITMAP))).isPattern();
 196             // pass full item set here, bitmap fill has many attributes (tiling, size, offset etc.)
 197             m_rXFSet.Put( rSet );
 198             if (!bPattern)
 199                 SelectFillType(*m_xBtnBitmap);
 200             else
 201                 SelectFillType(*m_xBtnPattern);
 202             break;
 203         }
 204     }
 205 }
 206
 207 template< typename TTabPage >
 208 DeactivateRC SvxAreaTabPage::DeactivatePage_Impl( SfxItemSet* _pSet )
 209 {
 210     return static_cast<TTabPage&>(*m_xFillTabPage).DeactivatePage(_pSet);
 211 }
 212
 213 DeactivateRC SvxAreaTabPage::DeactivatePage( SfxItemSet* _pSet )
 214 {
 215     FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos());
 216     switch( eFillType )
 217     {
 218         case TRANSPARENT:
 219         {
 220             // Fill: None doesn't have its own tabpage and thus
 221             // implementation of FillItemSet, so we supply it here
 222             if ( m_bBtnClicked )
 223             {
 224                 XFillStyleItem aStyleItem( drawing::FillStyle_NONE );
 225                 _pSet->Put( aStyleItem );
 226             }
 227             break;
 228         }
 229         case SOLID:
 230             return DeactivatePage_Impl<SvxColorTabPage>(_pSet);
 231         case GRADIENT:
 232             return DeactivatePage_Impl<SvxGradientTabPage>(_pSet);
 233         case HATCH:
 234             return DeactivatePage_Impl<SvxHatchTabPage>(_pSet);
 235         case BITMAP:
 236             return DeactivatePage_Impl<SvxBitmapTabPage&>(_pSet);
 237         case PATTERN:
 238             return DeactivatePage_Impl<SvxPatternTabPage>(_pSet);
 239         default:
 240             break;
 241     }
 242     return DeactivateRC::LeavePage;
 243 }
 244
 245 template< typename TTabPage >
 246 bool SvxAreaTabPage::FillItemSet_Impl( SfxItemSet* rAttrs)
 247 {
 248     return static_cast<TTabPage&>( *m_xFillTabPage ).FillItemSet( rAttrs );
 249 }
 250
 251 bool SvxAreaTabPage::FillItemSet( SfxItemSet* rAttrs )
 252 {
 253     FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos());
 254     switch( eFillType )
 255     {
 256         case TRANSPARENT:
 257         {
 258             rAttrs->Put( XFillStyleItem( drawing::FillStyle_NONE ) );
 259             return true;
 260         }
 261         case SOLID:
 262         {
 263             return FillItemSet_Impl<SvxColorTabPage>( rAttrs );
 264         }
 265         case GRADIENT:
 266         {
 267             return FillItemSet_Impl<SvxGradientTabPage>( rAttrs );
 268         }
 269         case HATCH:
 270         {
 271             return FillItemSet_Impl<SvxHatchTabPage>( rAttrs );
 272         }
 273         case BITMAP:
 274         {
 275             return FillItemSet_Impl<SvxBitmapTabPage>( rAttrs );
 276         }
 277         case PATTERN:
 278         {
 279             return FillItemSet_Impl<SvxPatternTabPage>( rAttrs );
 280         }
 281         default:
 282             return false;
 283     }
 284 }
 285
 286 template< typename TTabPage >
 287 void SvxAreaTabPage::Reset_Impl( const SfxItemSet* rAttrs )
 288 {
 289     static_cast<TTabPage&>( *m_xFillTabPage ).Reset( rAttrs );
 290 }
 291
 292 void SvxAreaTabPage::Reset( const SfxItemSet* rAttrs )
 293 {
 294     m_bBtnClicked = false;
 295     auto eFillType = maBox.GetCurrentButtonPos();
 296     switch(eFillType)
 297     {
 298         case SOLID:
 299         {
 300             Reset_Impl<SvxColorTabPage>( rAttrs );
 301             break;
 302         }
 303         case GRADIENT:
 304         {
 305             Reset_Impl<SvxGradientTabPage>( rAttrs );
 306             break;
 307         }
 308         case HATCH:
 309         {
 310             Reset_Impl<SvxHatchTabPage>( rAttrs );
 311             break;
 312         }
 313         case BITMAP:
 314         {
 315             Reset_Impl<SvxBitmapTabPage>( rAttrs );
 316             break;
 317         }
 318         case PATTERN:
 319         {
 320             Reset_Impl<SvxPatternTabPage>( rAttrs );
 321             break;
 322         }
 323         default:
 324             break;
 325     }
 326 }
 327
 328 std::unique_ptr<SfxTabPage> SvxAreaTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs)
 329 {
 330     auto xRet = std::make_unique<SvxAreaTabPage>(pPage, pController, *rAttrs);
 331     xRet->SetOptimalSize(pController);
 332     return xRet;
 333 }
 334
 335 namespace {
 336
 337 std::unique_ptr<SfxTabPage> lcl_CreateFillStyleTabPage(sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
 338 {
 339     CreateTabPage fnCreate = nullptr;
 340     switch(nId)
 341     {
 342         case TRANSPARENT: fnCreate = nullptr; break;
 343         case SOLID: fnCreate = &SvxColorTabPage::Create; break;
 344         case GRADIENT: fnCreate = &SvxGradientTabPage::Create; break;
 345         case HATCH: fnCreate = &SvxHatchTabPage::Create; break;
 346         case BITMAP: fnCreate = &SvxBitmapTabPage::Create; break;
 347         case PATTERN: fnCreate = &SvxPatternTabPage::Create; break;
 348     }
 349     return fnCreate ? (*fnCreate)( pPage, pController, &rSet ) : nullptr;
 350 }
 351
 352 }
 353
 354 IMPL_LINK(SvxAreaTabPage, SelectFillTypeHdl_Impl, weld::ToggleButton&, rButton, void)
 355 {
 356     //tdf#124549 - If the button is already active do not toggle it back.
 357     if(!rButton.get_active())
 358         rButton.set_active(true);
 359
 360     SelectFillType(rButton);
 361     m_bBtnClicked = true;
 362 }
 363
 364 void SvxAreaTabPage::SelectFillType(weld::ToggleButton& rButton, const SfxItemSet* _pSet)
 365 {
 366     if (_pSet)
 367         m_rXFSet.Set(*_pSet);
 368
 369     sal_Int32 nPos = maBox.GetButtonPos(&rButton);
 370     if (nPos != -1 && (_pSet || nPos != maBox.GetCurrentButtonPos()))
 371     {
 372         maBox.SelectButton(&rButton);
 373         FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos());
 374         m_xFillTabPage = lcl_CreateFillStyleTabPage(eFillType, m_xFillTab.get(), GetDialogController(), m_rXFSet);
 375         if (m_xFillTabPage)
 376             m_xFillTabPage->SetDialogController(GetDialogController());
 377         CreatePage(eFillType, m_xFillTabPage.get());
 378     }
 379 }
 380
 381 void SvxAreaTabPage::PageCreated(const SfxAllItemSet& aSet)
 382 {
 383     const SvxColorListItem* pColorListItem = aSet.GetItem<SvxColorListItem>(SID_COLOR_TABLE, false);
 384     const SvxGradientListItem* pGradientListItem = aSet.GetItem<SvxGradientListItem>(SID_GRADIENT_LIST, false);
 385     const SvxHatchListItem* pHatchingListItem = aSet.GetItem<SvxHatchListItem>(SID_HATCH_LIST, false);
 386     const SvxBitmapListItem* pBitmapListItem = aSet.GetItem<SvxBitmapListItem>(SID_BITMAP_LIST, false);
 387     const SvxPatternListItem* pPatternListItem = aSet.GetItem<SvxPatternListItem>(SID_PATTERN_LIST, false);
 388
 389     if (pColorListItem)
 390         SetColorList(pColorListItem->GetColorList());
 391     if (pGradientListItem)
 392         SetGradientList(pGradientListItem->GetGradientList());
 393     if (pHatchingListItem)
 394         SetHatchingList(pHatchingListItem->GetHatchList());
 395     if (pBitmapListItem)
 396         SetBitmapList(pBitmapListItem->GetBitmapList());
 397     if (pPatternListItem)
 398         SetPatternList(pPatternListItem->GetPatternList());
 399 }
 400
 401 void SvxAreaTabPage::CreatePage( sal_Int32 nId, SfxTabPage* pTab )
 402 {
 403     if(nId == SOLID )
 404     {
 405         auto* pColorTab = static_cast<SvxColorTabPage*>(pTab);
 406         pColorTab->SetColorList(m_pColorList);
 407         pColorTab->SetColorChgd(m_pnColorListState);
 408         pColorTab->Construct();
 409         pColorTab->ActivatePage(m_rXFSet);
 410         pColorTab->Reset(&m_rXFSet);
 411         pColorTab->set_visible(true);
 412     }
 413     else if(nId == GRADIENT)
 414     {
 415         auto* pGradientTab = static_cast<SvxGradientTabPage*>(pTab);
 416         pGradientTab->SetColorList(m_pColorList);
 417         pGradientTab->SetGradientList(m_pGradientList);
 418         pGradientTab->SetGrdChgd(m_pnGradientListState);
 419         pGradientTab->SetColorChgd(m_pnColorListState);
 420         pGradientTab->Construct();
 421         pGradientTab->ActivatePage(m_rXFSet);
 422         pGradientTab->Reset(&m_rXFSet);
 423         pGradientTab->set_visible(true);
 424     }
 425     else if(nId == HATCH)
 426     {
 427         auto* pHatchTab = static_cast<SvxHatchTabPage*>(pTab);
 428         pHatchTab->SetColorList(m_pColorList);
 429         pHatchTab->SetHatchingList(m_pHatchingList);
 430         pHatchTab->SetHtchChgd(m_pnHatchingListState);
 431         pHatchTab->SetColorChgd(m_pnColorListState);
 432         pHatchTab->Construct();
 433         pHatchTab->ActivatePage(m_rXFSet);
 434         pHatchTab->Reset(&m_rXFSet);
 435         pHatchTab->set_visible(true);
 436     }
 437     else if(nId == BITMAP)
 438     {
 439         auto* pBitmapTab = static_cast<SvxBitmapTabPage*>(pTab);
 440         pBitmapTab->SetBitmapList(m_pBitmapList);
 441         pBitmapTab->SetBmpChgd(m_pnBitmapListState);
 442         pBitmapTab->Construct();
 443         pBitmapTab->ActivatePage(m_rXFSet);
 444         pBitmapTab->Reset(&m_rXFSet);
 445         pBitmapTab->set_visible(true);
 446     }
 447     else if(nId == PATTERN)
 448     {
 449         auto* pPatternTab = static_cast<SvxPatternTabPage*>(pTab);
 450         pPatternTab->SetColorList(m_pColorList);
 451         pPatternTab->SetPatternList(m_pPatternList);
 452         pPatternTab->SetPtrnChgd(m_pnPatternListState);
 453         pPatternTab->SetColorChgd(m_pnColorListState);
 454         pPatternTab->Construct();
 455         pPatternTab->ActivatePage(m_rXFSet);
 456         pPatternTab->Reset(&m_rXFSet);
 457         pPatternTab->set_visible(true);
 458     }
 459 }
 460
 461 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */