svx/source/tbxctrls/fillctrl.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 <sfx2/dispatch.hxx>
  21 #include <sfx2/objsh.hxx>
  22 #include <sfx2/viewfrm.hxx>
  23 #include <sfx2/viewsh.hxx>
  24 #include <rtl/ustring.hxx>
  25 #include <vcl/event.hxx>
  26 #include <vcl/settings.hxx>
  27 #include <vcl/toolbox.hxx>
  28 #include <vcl/virdev.hxx>
  29 #include <svx/svxids.hrc>
  30 #include <tools/json_writer.hxx>
  31
  32 #define TMP_STR_BEGIN   "["
  33 #define TMP_STR_END     "]"
  34
  35 #include <svx/drawitem.hxx>
  36 #include <svx/xfillit0.hxx>
  37 #include <svx/xtable.hxx>
  38 #include <svx/fillctrl.hxx>
  39 #include <svx/itemwin.hxx>
  40 #include <svx/xflclit.hxx>
  41 #include <svx/xflgrit.hxx>
  42 #include <svx/xflhtit.hxx>
  43 #include <svx/xbtmpit.hxx>
  44 #include <boost/property_tree/ptree.hpp>
  45 #include <memory>
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::uno;
  49 using namespace ::com::sun::star::util;
  50 using namespace ::com::sun::star::beans;
  51 using namespace ::com::sun::star::lang;
  52
  53 SFX_IMPL_TOOLBOX_CONTROL( SvxFillToolBoxControl, XFillStyleItem );
  54
  55 SvxFillToolBoxControl::SvxFillToolBoxControl(
  56     sal_uInt16 nSlotId,
  57     sal_uInt16 nId,
  58     ToolBox& rTbx )
  59     : SfxToolBoxControl( nSlotId, nId, rTbx )
  60     , mpStyleItem()
  61     , mpColorItem()
  62     , mpFillGradientItem()
  63     , mpHatchItem()
  64     , mpBitmapItem()
  65     , mxFillControl(nullptr)
  66     , mpLbFillType(nullptr)
  67     , mpToolBoxColor(nullptr)
  68     , mpLbFillAttr(nullptr)
  69     , meLastXFS(static_cast<drawing::FillStyle>(-1))
  70     , mnLastPosGradient(0)
  71     , mnLastPosHatch(0)
  72     , mnLastPosBitmap(0)
  73 {
  74     addStatusListener( ".uno:FillColor");
  75     addStatusListener( ".uno:FillGradient");
  76     addStatusListener( ".uno:FillHatch");
  77     addStatusListener( ".uno:FillBitmap");
  78     addStatusListener( ".uno:ColorTableState");
  79     addStatusListener( ".uno:GradientListState");
  80     addStatusListener( ".uno:HatchListState");
  81     addStatusListener( ".uno:BitmapListState");
  82 }
  83
  84 SvxFillToolBoxControl::~SvxFillToolBoxControl()
  85 {
  86 }
  87
  88 void SvxFillToolBoxControl::StateChanged(
  89     sal_uInt16 nSID,
  90     SfxItemState eState,
  91     const SfxPoolItem* pState)
  92 {
  93     const bool bDisabled(SfxItemState::DISABLED == eState);
  94
  95     switch(nSID)
  96     {
  97         case SID_ATTR_FILL_STYLE:
  98         {
  99             if(bDisabled)
 100             {
 101                 mpLbFillType->set_sensitive(false);
 102                 mpLbFillType->set_active(-1);
 103                 mpLbFillAttr->show();
 104                 mpLbFillAttr->set_sensitive(false);
 105                 mpLbFillAttr->set_active(-1);
 106                 mpToolBoxColor->hide();
 107                 meLastXFS = static_cast<drawing::FillStyle>(-1);
 108                 mpStyleItem.reset();
 109             }
 110
 111             if(eState >= SfxItemState::DEFAULT)
 112             {
 113                 const XFillStyleItem* pItem = dynamic_cast< const XFillStyleItem* >(pState);
 114
 115                 if(pItem)
 116                 {
 117                     mpStyleItem.reset(pItem->Clone());
 118                     mpLbFillType->set_sensitive(true);
 119                     drawing::FillStyle eXFS = mpStyleItem->GetValue();
 120                     meLastXFS = eXFS;
 121                     mpLbFillType->set_active(sal::static_int_cast< sal_Int32 >(eXFS));
 122
 123                     if(drawing::FillStyle_NONE == eXFS)
 124                     {
 125                         mpLbFillAttr->set_active(-1);
 126                         mpLbFillAttr->set_sensitive(false);
 127                     }
 128
 129                     Update();
 130                     break;
 131                 }
 132             }
 133
 134             mpLbFillType->set_active(-1);
 135             mpLbFillAttr->show();
 136             mpLbFillAttr->set_sensitive(false);
 137             mpLbFillAttr->set_active(-1);
 138             mpToolBoxColor->hide();
 139             meLastXFS = static_cast<drawing::FillStyle>(-1);
 140             mpStyleItem.reset();
 141             mxFillControl->Resize();
 142             break;
 143         }
 144         case SID_ATTR_FILL_COLOR:
 145         {
 146             if(SfxItemState::DEFAULT == eState)
 147             {
 148                 mpColorItem.reset(pState ? static_cast<XFillColorItem*>(pState->Clone()) : nullptr);
 149             }
 150
 151             if(mpStyleItem && drawing::FillStyle_SOLID == mpStyleItem->GetValue())
 152             {
 153                 mpLbFillAttr->hide();
 154                 mpToolBoxColor->show();
 155                 mxFillControl->Resize();
 156
 157                 Update();
 158             }
 159             break;
 160         }
 161         case SID_ATTR_FILL_GRADIENT:
 162         {
 163             if(SfxItemState::DEFAULT == eState)
 164             {
 165                 mpFillGradientItem.reset(pState ? static_cast<XFillGradientItem*>(pState->Clone()) : nullptr);
 166             }
 167
 168             if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue())
 169             {
 170                 mpLbFillAttr->show();
 171                 mpToolBoxColor->hide();
 172                 mxFillControl->Resize();
 173
 174                 if(SfxItemState::DEFAULT == eState)
 175                 {
 176                     mpLbFillAttr->set_sensitive(true);
 177                     Update();
 178                 }
 179                 else if(SfxItemState::DISABLED == eState )
 180                 {
 181                     mpLbFillAttr->set_sensitive(false);
 182                     mpLbFillAttr->set_active(-1);
 183                 }
 184                 else
 185                 {
 186                     mpLbFillAttr->set_active(-1);
 187                 }
 188             }
 189             break;
 190         }
 191         case SID_ATTR_FILL_HATCH:
 192         {
 193             if(SfxItemState::DEFAULT == eState)
 194             {
 195                 mpHatchItem.reset(pState ? static_cast<XFillHatchItem*>(pState->Clone()) : nullptr);
 196             }
 197
 198             if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue())
 199             {
 200                 mpLbFillAttr->show();
 201                 mpToolBoxColor->hide();
 202                 mxFillControl->Resize();
 203
 204                 if(SfxItemState::DEFAULT == eState)
 205                 {
 206                     mpLbFillAttr->set_sensitive(true);
 207                     Update();
 208                 }
 209                 else if(SfxItemState::DISABLED == eState )
 210                 {
 211                     mpLbFillAttr->set_sensitive(false);
 212                     mpLbFillAttr->set_active(-1);
 213                 }
 214                 else
 215                 {
 216                     mpLbFillAttr->set_active(-1);
 217                 }
 218             }
 219             break;
 220         }
 221         case SID_ATTR_FILL_BITMAP:
 222         {
 223             if(SfxItemState::DEFAULT == eState)
 224             {
 225                 mpBitmapItem.reset(pState ? static_cast<XFillBitmapItem*>(pState->Clone()) : nullptr);
 226             }
 227
 228             if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue())
 229             {
 230                 mpLbFillAttr->show();
 231                 mpToolBoxColor->hide();
 232                 mxFillControl->Resize();
 233
 234                 if(SfxItemState::DEFAULT == eState)
 235                 {
 236                     mpLbFillAttr->set_sensitive(true);
 237                     Update();
 238                 }
 239                 else if(SfxItemState::DISABLED == eState )
 240                 {
 241                     mpLbFillAttr->set_sensitive(false);
 242                     mpLbFillAttr->set_active(-1);
 243                 }
 244                 else
 245                 {
 246                     mpLbFillAttr->set_active(-1);
 247                 }
 248             }
 249             break;
 250         }
 251         case SID_GRADIENT_LIST:
 252         {
 253             if(SfxItemState::DEFAULT == eState)
 254             {
 255                 if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue())
 256                 {
 257                     if(mpFillGradientItem)
 258                     {
 259                         const OUString aString( mpFillGradientItem->GetName() );
 260                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 261
 262                         mpLbFillAttr->clear();
 263                         mpLbFillAttr->set_sensitive(true);
 264                         SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList());
 265                         mpLbFillAttr->set_active_text(aString);
 266                     }
 267                     else
 268                     {
 269                         mpLbFillAttr->set_active(-1);
 270                     }
 271                 }
 272             }
 273             break;
 274         }
 275         case SID_HATCH_LIST:
 276         {
 277             if(SfxItemState::DEFAULT == eState)
 278             {
 279                 if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue())
 280                 {
 281                     if(mpHatchItem)
 282                     {
 283                         const OUString aString( mpHatchItem->GetName() );
 284                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 285
 286                         mpLbFillAttr->clear();
 287                         mpLbFillAttr->set_sensitive(true);
 288                         SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_HATCH_LIST)->GetHatchList());
 289                         mpLbFillAttr->set_active_text(aString);
 290                     }
 291                     else
 292                     {
 293                         mpLbFillAttr->set_active(-1);
 294                     }
 295                 }
 296             }
 297             break;
 298         }
 299         case SID_BITMAP_LIST:
 300         {
 301             if(SfxItemState::DEFAULT == eState)
 302             {
 303                 if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue())
 304                 {
 305                     if(mpBitmapItem)
 306                     {
 307                         const OUString aString( mpBitmapItem->GetName() );
 308                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 309
 310                         mpLbFillAttr->clear();
 311                         mpLbFillAttr->set_sensitive(true);
 312                         SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList());
 313                         mpLbFillAttr->set_active_text(aString);
 314                     }
 315                     else
 316                     {
 317                         mpLbFillAttr->set_active(-1);
 318                     }
 319                 }
 320             }
 321             break;
 322         }
 323     }
 324 }
 325
 326 void SvxFillToolBoxControl::Update()
 327 {
 328     if(!mpStyleItem)
 329         return;
 330
 331     const drawing::FillStyle eXFS = mpStyleItem->GetValue();
 332     SfxObjectShell* pSh = SfxObjectShell::Current();
 333
 334     switch( eXFS )
 335     {
 336         case drawing::FillStyle_NONE:
 337         {
 338             mpLbFillAttr->show();
 339             mpToolBoxColor->hide();
 340             mxFillControl->Resize();
 341             break;
 342         }
 343         case drawing::FillStyle_SOLID:
 344         {
 345             if(mpColorItem)
 346             {
 347                 mpLbFillAttr->hide();
 348                 mpToolBoxColor->show();
 349                 mxFillControl->Resize();
 350             }
 351             break;
 352         }
 353         case drawing::FillStyle_GRADIENT:
 354         {
 355             mpLbFillAttr->show();
 356             mpToolBoxColor->hide();
 357             mxFillControl->Resize();
 358
 359             if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
 360             {
 361                 mpLbFillAttr->set_sensitive(true);
 362                 mpLbFillAttr->clear();
 363                 SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList());
 364
 365                 if(mpFillGradientItem)
 366                 {
 367                     const OUString aString(mpFillGradientItem->GetName());
 368
 369                     mpLbFillAttr->set_active_text(aString);
 370
 371                     // Check if the entry is not in the list
 372                     if (mpLbFillAttr->get_active_text() != aString)
 373                     {
 374                         sal_Int32 nCount = mpLbFillAttr->get_count();
 375                         OUString aTmpStr;
 376                         if( nCount > 0 )
 377                         {
 378                             // Last entry gets tested against temporary entry
 379                             aTmpStr = mpLbFillAttr->get_text( nCount - 1 );
 380                             if( aTmpStr.startsWith(TMP_STR_BEGIN) &&
 381                                 aTmpStr.endsWith(TMP_STR_END) )
 382                             {
 383                                 mpLbFillAttr->remove(nCount - 1);
 384                             }
 385                         }
 386                         aTmpStr = TMP_STR_BEGIN + aString + TMP_STR_END;
 387
 388                         XGradientList aGradientList( "", ""/*TODO?*/ );
 389                         aGradientList.Insert(std::make_unique<XGradientEntry>(mpFillGradientItem->GetGradientValue(), aTmpStr));
 390                         aGradientList.SetDirty( false );
 391                         const BitmapEx aBmp = aGradientList.GetUiBitmap( 0 );
 392
 393                         if (!aBmp.IsEmpty())
 394                         {
 395                             ScopedVclPtrInstance< VirtualDevice > pVD;
 396                             const Size aBmpSize(aBmp.GetSizePixel());
 397                             pVD->SetOutputSizePixel(aBmpSize, false);
 398                             pVD->DrawBitmapEx(Point(), aBmp);
 399                             mpLbFillAttr->append("", aGradientList.Get(0)->GetName(), *pVD);
 400                             mpLbFillAttr->set_active(mpLbFillAttr->get_count() - 1);
 401                         }
 402                     }
 403
 404                 }
 405                 else
 406                 {
 407                     mpLbFillAttr->set_active(-1);
 408                 }
 409             }
 410             else
 411             {
 412                 mpLbFillAttr->set_active(-1);
 413             }
 414             break;
 415         }
 416         case drawing::FillStyle_HATCH:
 417         {
 418             mpLbFillAttr->show();
 419             mpToolBoxColor->hide();
 420             mxFillControl->Resize();
 421
 422             if(pSh && pSh->GetItem(SID_HATCH_LIST))
 423             {
 424                 mpLbFillAttr->set_sensitive(true);
 425                 mpLbFillAttr->clear();
 426                 SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_HATCH_LIST)->GetHatchList());
 427
 428                 if(mpHatchItem)
 429                 {
 430                     const OUString aString(mpHatchItem->GetName());
 431
 432                     mpLbFillAttr->set_active_text( aString );
 433
 434                     // Check if the entry is not in the list
 435                     if( mpLbFillAttr->get_active_text() != aString )
 436                     {
 437                         const sal_Int32 nCount = mpLbFillAttr->get_count();
 438                         OUString aTmpStr;
 439                         if( nCount > 0 )
 440                         {
 441                             // Last entry gets tested against temporary entry
 442                             aTmpStr = mpLbFillAttr->get_text( nCount - 1 );
 443                             if(  aTmpStr.startsWith(TMP_STR_BEGIN) &&
 444                                  aTmpStr.endsWith(TMP_STR_END) )
 445                             {
 446                                 mpLbFillAttr->remove( nCount - 1 );
 447                             }
 448                         }
 449                         aTmpStr = TMP_STR_BEGIN + aString + TMP_STR_END;
 450
 451                         XHatchList aHatchList( "", ""/*TODO?*/ );
 452                         aHatchList.Insert(std::make_unique<XHatchEntry>(mpHatchItem->GetHatchValue(), aTmpStr));
 453                         aHatchList.SetDirty( false );
 454                         const BitmapEx & aBmp = aHatchList.GetUiBitmap( 0 );
 455
 456                         if( !aBmp.IsEmpty() )
 457                         {
 458                             ScopedVclPtrInstance< VirtualDevice > pVD;
 459                             const Size aBmpSize(aBmp.GetSizePixel());
 460                             pVD->SetOutputSizePixel(aBmpSize, false);
 461                             pVD->DrawBitmapEx(Point(), aBmp);
 462                             mpLbFillAttr->append("", aHatchList.GetHatch(0)->GetName(), *pVD);
 463                             mpLbFillAttr->set_active(mpLbFillAttr->get_count() - 1);
 464                         }
 465                     }
 466                 }
 467                 else
 468                 {
 469                     mpLbFillAttr->set_active(-1);
 470                 }
 471             }
 472             else
 473             {
 474                 mpLbFillAttr->set_active(-1);
 475             }
 476             break;
 477         }
 478         case drawing::FillStyle_BITMAP:
 479         {
 480             mpLbFillAttr->show();
 481             mpToolBoxColor->hide();
 482             mxFillControl->Resize();
 483
 484             if(pSh && pSh->GetItem(SID_BITMAP_LIST))
 485             {
 486                 mpLbFillAttr->set_sensitive(true);
 487                 mpLbFillAttr->clear();
 488                 SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList());
 489
 490                 if(mpBitmapItem)
 491                 {
 492                     const OUString aString(mpBitmapItem->GetName());
 493
 494                     mpLbFillAttr->set_active_text(aString);
 495
 496                     // Check if the entry is not in the list
 497                     if (mpLbFillAttr->get_active_text() != aString)
 498                     {
 499                         sal_Int32 nCount = mpLbFillAttr->get_count();
 500                         OUString aTmpStr;
 501                         if( nCount > 0 )
 502                         {
 503                             // Last entry gets tested against temporary entry
 504                             aTmpStr = mpLbFillAttr->get_text(nCount - 1);
 505                             if( aTmpStr.startsWith(TMP_STR_BEGIN) &&
 506                                 aTmpStr.endsWith(TMP_STR_END) )
 507                             {
 508                                 mpLbFillAttr->remove(nCount - 1);
 509                             }
 510                         }
 511                         aTmpStr = TMP_STR_BEGIN + aString + TMP_STR_END;
 512
 513                         XBitmapListRef xBitmapList =
 514                             XPropertyList::AsBitmapList(
 515                                 XPropertyList::CreatePropertyList(
 516                                     XPropertyListType::Bitmap, "TmpList", ""/*TODO?*/));
 517                         xBitmapList->Insert(std::make_unique<XBitmapEntry>(mpBitmapItem->GetGraphicObject(), aTmpStr));
 518                         xBitmapList->SetDirty( false );
 519                         SvxFillAttrBox::Fill(*mpLbFillAttr, xBitmapList);
 520                         mpLbFillAttr->set_active(mpLbFillAttr->get_count() - 1);
 521                     }
 522
 523                 }
 524                 else
 525                 {
 526                     mpLbFillAttr->set_active(-1);
 527                 }
 528             }
 529             else
 530             {
 531                 mpLbFillAttr->set_active(-1);
 532             }
 533             break;
 534         }
 535         default:
 536             OSL_ENSURE(false, "Non supported FillType (!)");
 537         break;
 538     }
 539
 540 }
 541
 542 VclPtr<InterimItemWindow> SvxFillToolBoxControl::CreateItemWindow(vcl::Window *pParent)
 543 {
 544     if(GetSlotId() == SID_ATTR_FILL_STYLE)
 545     {
 546         mxFillControl.reset(VclPtr<FillControl>::Create(pParent, m_xFrame));
 547
 548         mpLbFillType = mxFillControl->mxLbFillType.get();
 549         mpLbFillAttr = mxFillControl->mxLbFillAttr.get();
 550         mpToolBoxColor = mxFillControl->mxToolBoxColor.get();
 551
 552         mpLbFillType->connect_changed(LINK(this,SvxFillToolBoxControl,SelectFillTypeHdl));
 553         mpLbFillAttr->connect_changed(LINK(this,SvxFillToolBoxControl,SelectFillAttrHdl));
 554
 555
 556         return mxFillControl;
 557     }
 558     return VclPtr<InterimItemWindow>();
 559 }
 560
 561 FillControl::FillControl(vcl::Window* pParent, const css::uno::Reference<css::frame::XFrame>& rFrame)
 562     : InterimItemWindow(pParent, "svx/ui/fillctrlbox.ui", "FillCtrlBox")
 563     , mxLbFillType(m_xBuilder->weld_combo_box("type"))
 564     , mxToolBoxColor(m_xBuilder->weld_toolbar("color"))
 565     , mxColorDispatch(new ToolbarUnoDispatcher(*mxToolBoxColor, *m_xBuilder, rFrame))
 566     , mxLbFillAttr(m_xBuilder->weld_combo_box("attr"))
 567     , mnTypeCurPos(0)
 568     , mnAttrCurPos(0)
 569 {
 570     InitControlBase(mxLbFillType.get());
 571
 572     mxLbFillAttr->connect_key_press(LINK(this, FillControl, AttrKeyInputHdl));
 573     mxLbFillType->connect_key_press(LINK(this, FillControl, TypeKeyInputHdl));
 574     mxToolBoxColor->connect_key_press(LINK(this, FillControl, ColorKeyInputHdl));
 575
 576     mxLbFillType->connect_get_property_tree(LINK(this, FillControl, DumpAsPropertyTreeHdl));
 577
 578     mxLbFillType->connect_focus_in(LINK(this, FillControl, TypeFocusHdl));
 579     mxLbFillAttr->connect_focus_in(LINK(this, FillControl, AttrFocusHdl));
 580
 581     SvxFillTypeBox::Fill(*mxLbFillType);
 582
 583     SetOptimalSize();
 584 }
 585
 586 IMPL_STATIC_LINK(FillControl, DumpAsPropertyTreeHdl, tools::JsonWriter&, rJsonWriter, void)
 587 {
 588     rJsonWriter.put("command", ".uno:FillStyle");
 589 }
 590
 591 void FillControl::ReleaseFocus_Impl()
 592 {
 593     SfxViewShell* pCurSh = SfxViewShell::Current();
 594     if (pCurSh)
 595     {
 596         vcl::Window* pShellWnd = pCurSh->GetWindow();
 597         if (pShellWnd)
 598             pShellWnd->GrabFocus();
 599     }
 600 }
 601
 602 IMPL_LINK(FillControl, TypeKeyInputHdl, const KeyEvent&, rKEvt, bool)
 603 {
 604     const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
 605     sal_uInt16 nCode = rKeyCode.GetCode();
 606
 607     if (nCode == KEY_ESCAPE)
 608     {
 609         mxLbFillType->set_active(mnTypeCurPos);
 610         ReleaseFocus_Impl();
 611         return true;
 612     }
 613
 614     if (nCode != KEY_TAB)
 615         return false;
 616     if (rKeyCode.IsShift())
 617         return ChildKeyInput(rKEvt);
 618     if (mxLbFillAttr->get_visible() && !mxLbFillAttr->get_sensitive())
 619         return ChildKeyInput(rKEvt);
 620     return false;
 621 }
 622
 623 IMPL_LINK_NOARG(FillControl, TypeFocusHdl, weld::Widget&, void)
 624 {
 625     mnTypeCurPos = mxLbFillType->get_active();
 626 }
 627
 628 IMPL_LINK_NOARG(FillControl, AttrFocusHdl, weld::Widget&, void)
 629 {
 630     mnAttrCurPos = mxLbFillAttr->get_active();
 631 }
 632
 633 IMPL_LINK(FillControl, AttrKeyInputHdl, const KeyEvent&, rKEvt, bool)
 634 {
 635     const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
 636     sal_uInt16 nCode = rKeyCode.GetCode();
 637
 638     if (nCode == KEY_ESCAPE)
 639     {
 640         mxLbFillAttr->set_active(mnAttrCurPos);
 641         ReleaseFocus_Impl();
 642         return true;
 643     }
 644
 645     return ChildKeyInput(rKEvt);
 646 }
 647
 648 IMPL_LINK(FillControl, ColorKeyInputHdl, const KeyEvent&, rKEvt, bool)
 649 {
 650     return ChildKeyInput(rKEvt);
 651 }
 652
 653 FillControl::~FillControl()
 654 {
 655     disposeOnce();
 656 }
 657
 658 void FillControl::dispose()
 659 {
 660     mxLbFillAttr.reset();
 661     mxColorDispatch.reset();
 662     mxToolBoxColor.reset();
 663     mxLbFillType.reset();
 664     InterimItemWindow::dispose();
 665 }
 666
 667 IMPL_LINK_NOARG(SvxFillToolBoxControl, SelectFillTypeHdl, weld::ComboBox&, void)
 668 {
 669     const drawing::FillStyle eXFS = static_cast<drawing::FillStyle>(mpLbFillType->get_active());
 670
 671     if(meLastXFS == eXFS)
 672         return;
 673
 674     mpLbFillAttr->clear();
 675     SfxObjectShell* pSh = SfxObjectShell::Current();
 676     const XFillStyleItem aXFillStyleItem(eXFS);
 677
 678     // #i122676# Do no longer trigger two Execute calls, one for SID_ATTR_FILL_STYLE
 679     // and one for setting the fill attribute itself, but add two SfxPoolItems to the
 680     // call to get just one action at the SdrObject and to create only one Undo action, too.
 681     // Checked that this works in all apps.
 682     switch( eXFS )
 683     {
 684         default:
 685         case drawing::FillStyle_NONE:
 686         {
 687             mpLbFillAttr->show();
 688             mpToolBoxColor->hide();
 689             mpLbFillAttr->set_sensitive(false);
 690             if (pSh)
 691             {
 692                 // #i122676# need to call a single SID_ATTR_FILL_STYLE change
 693                 pSh->GetDispatcher()->ExecuteList(
 694                     SID_ATTR_FILL_STYLE, SfxCallMode::RECORD,
 695                     { &aXFillStyleItem });
 696             }
 697             break;
 698         }
 699         case drawing::FillStyle_SOLID:
 700         {
 701             mpLbFillAttr->hide();
 702             mpToolBoxColor->show();
 703             if (pSh)
 704             {
 705                 const ::Color aColor = mpColorItem ? mpColorItem->GetColorValue() : COL_AUTO;
 706                 const XFillColorItem aXFillColorItem( "", aColor );
 707
 708                 // #i122676# change FillStyle and Color in one call
 709                 pSh->GetDispatcher()->ExecuteList(
 710                     SID_ATTR_FILL_COLOR, SfxCallMode::RECORD,
 711                     { &aXFillColorItem, &aXFillStyleItem });
 712             }
 713             break;
 714         }
 715         case drawing::FillStyle_GRADIENT:
 716         {
 717             mpLbFillAttr->show();
 718             mpToolBoxColor->hide();
 719
 720             if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
 721             {
 722                 if(!mpLbFillAttr->get_count())
 723                 {
 724                     mpLbFillAttr->set_sensitive(true);
 725                     mpLbFillAttr->clear();
 726                     SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList());
 727                 }
 728
 729                 if (mnLastPosGradient != -1)
 730                 {
 731                     const SvxGradientListItem * pItem = pSh->GetItem(SID_GRADIENT_LIST);
 732
 733                     if(mnLastPosGradient < pItem->GetGradientList()->Count())
 734                     {
 735                         const XGradient aGradient = pItem->GetGradientList()->GetGradient(mnLastPosGradient)->GetGradient();
 736                         const XFillGradientItem aXFillGradientItem(mpLbFillAttr->get_text(mnLastPosGradient), aGradient);
 737
 738                         // #i122676# change FillStyle and Gradient in one call
 739                         pSh->GetDispatcher()->ExecuteList(
 740                             SID_ATTR_FILL_GRADIENT, SfxCallMode::RECORD,
 741                             { &aXFillGradientItem, &aXFillStyleItem });
 742                         mpLbFillAttr->set_active(mnLastPosGradient);
 743                     }
 744                 }
 745             }
 746             else
 747             {
 748                 mpLbFillAttr->set_sensitive(false);
 749             }
 750             break;
 751         }
 752         case drawing::FillStyle_HATCH:
 753         {
 754             mpLbFillAttr->show();
 755             mpToolBoxColor->hide();
 756
 757             if(pSh && pSh->GetItem(SID_HATCH_LIST))
 758             {
 759                 if(!mpLbFillAttr->get_count())
 760                 {
 761                     mpLbFillAttr->set_sensitive(true);
 762                     mpLbFillAttr->clear();
 763                     SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_HATCH_LIST)->GetHatchList());
 764                 }
 765
 766                 if (mnLastPosHatch != -1)
 767                 {
 768                     const SvxHatchListItem * pItem = pSh->GetItem(SID_HATCH_LIST);
 769
 770                     if(mnLastPosHatch < pItem->GetHatchList()->Count())
 771                     {
 772                         const XHatch aHatch = pItem->GetHatchList()->GetHatch(mnLastPosHatch)->GetHatch();
 773                         const XFillHatchItem aXFillHatchItem(mpLbFillAttr->get_active_text(), aHatch);
 774
 775                         // #i122676# change FillStyle and Hatch in one call
 776                         pSh->GetDispatcher()->ExecuteList(
 777                             SID_ATTR_FILL_HATCH, SfxCallMode::RECORD,
 778                             { &aXFillHatchItem, &aXFillStyleItem });
 779                         mpLbFillAttr->set_active(mnLastPosHatch);
 780                     }
 781                 }
 782             }
 783             else
 784             {
 785                 mpLbFillAttr->set_sensitive(false);
 786             }
 787             break;
 788         }
 789         case drawing::FillStyle_BITMAP:
 790         {
 791             mpLbFillAttr->show();
 792             mpToolBoxColor->hide();
 793
 794             if(pSh && pSh->GetItem(SID_BITMAP_LIST))
 795             {
 796                 if(!mpLbFillAttr->get_count())
 797                 {
 798                     mpLbFillAttr->set_sensitive(true);
 799                     mpLbFillAttr->clear();
 800                     SvxFillAttrBox::Fill(*mpLbFillAttr, pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList());
 801                 }
 802
 803                 if (mnLastPosBitmap != -1)
 804                 {
 805                     const SvxBitmapListItem * pItem = pSh->GetItem(SID_BITMAP_LIST);
 806
 807                     if(mnLastPosBitmap < pItem->GetBitmapList()->Count())
 808                     {
 809                         const XBitmapEntry* pXBitmapEntry = pItem->GetBitmapList()->GetBitmap(mnLastPosBitmap);
 810                         const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->get_active_text(), pXBitmapEntry->GetGraphicObject());
 811
 812                         // #i122676# change FillStyle and Bitmap in one call
 813                         pSh->GetDispatcher()->ExecuteList(
 814                             SID_ATTR_FILL_BITMAP, SfxCallMode::RECORD,
 815                             { &aXFillBitmapItem, &aXFillStyleItem });
 816                         mpLbFillAttr->set_active(mnLastPosBitmap);
 817                     }
 818                 }
 819             }
 820             else
 821             {
 822                 mpLbFillAttr->set_sensitive(false);
 823             }
 824             break;
 825         }
 826     }
 827
 828     meLastXFS = eXFS;
 829
 830     mxFillControl->Resize();
 831 }
 832
 833 IMPL_LINK_NOARG(SvxFillToolBoxControl, SelectFillAttrHdl, weld::ComboBox&, void)
 834 {
 835     const drawing::FillStyle eXFS = static_cast<drawing::FillStyle>(mpLbFillType->get_active());
 836     const XFillStyleItem aXFillStyleItem(eXFS);
 837     SfxObjectShell* pSh = SfxObjectShell::Current();
 838
 839     // #i122676# dependent from bFillStyleChange, do execute a single or two
 840     // changes in one Execute call
 841     const bool bFillStyleChange(meLastXFS != eXFS);
 842
 843     switch(eXFS)
 844     {
 845         case drawing::FillStyle_SOLID:
 846         {
 847             if (bFillStyleChange && pSh)
 848             {
 849                 // #i122676# Single FillStyle change call needed here
 850                 pSh->GetDispatcher()->ExecuteList(
 851                     SID_ATTR_FILL_STYLE, SfxCallMode::RECORD,
 852                     { &aXFillStyleItem });
 853             }
 854             break;
 855         }
 856         case drawing::FillStyle_GRADIENT:
 857         {
 858             sal_Int32 nPos = mpLbFillAttr->get_active();
 859
 860             if (nPos == -1)
 861             {
 862                 nPos = mnLastPosGradient;
 863             }
 864
 865             if (nPos != -1 && pSh && pSh->GetItem(SID_GRADIENT_LIST))
 866             {
 867                 const SvxGradientListItem * pItem = pSh->GetItem(SID_GRADIENT_LIST);
 868
 869                 if(nPos < pItem->GetGradientList()->Count())
 870                 {
 871                     const XGradient aGradient = pItem->GetGradientList()->GetGradient(nPos)->GetGradient();
 872                     const XFillGradientItem aXFillGradientItem(mpLbFillAttr->get_active_text(), aGradient);
 873
 874                     // #i122676# Change FillStyle and Gradient in one call
 875                     pSh->GetDispatcher()->ExecuteList(
 876                         SID_ATTR_FILL_GRADIENT, SfxCallMode::RECORD,
 877                         bFillStyleChange
 878                             ? std::initializer_list<SfxPoolItem const*>{ &aXFillGradientItem, &aXFillStyleItem }
 879                             : std::initializer_list<SfxPoolItem const*>{ &aXFillGradientItem });
 880                 }
 881             }
 882
 883             if (nPos != -1)
 884             {
 885                 mnLastPosGradient = nPos;
 886             }
 887             break;
 888         }
 889         case drawing::FillStyle_HATCH:
 890         {
 891             sal_Int32 nPos = mpLbFillAttr->get_active();
 892
 893             if (nPos == -1)
 894             {
 895                 nPos = mnLastPosHatch;
 896             }
 897
 898             if (nPos != -1 && pSh && pSh->GetItem(SID_HATCH_LIST))
 899             {
 900                 const SvxHatchListItem * pItem = pSh->GetItem(SID_HATCH_LIST);
 901
 902                 if(nPos < pItem->GetHatchList()->Count())
 903                 {
 904                     const XHatch aHatch = pItem->GetHatchList()->GetHatch(nPos)->GetHatch();
 905                     const XFillHatchItem aXFillHatchItem( mpLbFillAttr->get_active_text(), aHatch);
 906
 907                     // #i122676# Change FillStyle and Hatch in one call
 908                     pSh->GetDispatcher()->ExecuteList(
 909                         SID_ATTR_FILL_HATCH, SfxCallMode::RECORD,
 910                         bFillStyleChange
 911                             ? std::initializer_list<SfxPoolItem const*>{ &aXFillHatchItem, &aXFillStyleItem }
 912                             : std::initializer_list<SfxPoolItem const*>{ &aXFillHatchItem });
 913                 }
 914             }
 915
 916             if (nPos != -1)
 917             {
 918                 mnLastPosHatch = nPos;
 919             }
 920             break;
 921         }
 922         case drawing::FillStyle_BITMAP:
 923         {
 924             sal_Int32 nPos = mpLbFillAttr->get_active();
 925
 926             if (nPos == -1)
 927             {
 928                 nPos = mnLastPosBitmap;
 929             }
 930
 931             if (nPos != -1 && pSh && pSh->GetItem(SID_BITMAP_LIST))
 932             {
 933                 const SvxBitmapListItem * pItem = pSh->GetItem(SID_BITMAP_LIST);
 934
 935                 if(nPos < pItem->GetBitmapList()->Count())
 936                 {
 937                     const XBitmapEntry* pXBitmapEntry = pItem->GetBitmapList()->GetBitmap(nPos);
 938                     const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->get_active_text(), pXBitmapEntry->GetGraphicObject());
 939
 940                     // #i122676# Change FillStyle and Bitmap in one call
 941                     pSh->GetDispatcher()->ExecuteList(
 942                         SID_ATTR_FILL_BITMAP, SfxCallMode::RECORD,
 943                         bFillStyleChange
 944                             ? std::initializer_list<SfxPoolItem const*>{ &aXFillBitmapItem, &aXFillStyleItem }
 945                             : std::initializer_list<SfxPoolItem const*>{ &aXFillBitmapItem });
 946                 }
 947             }
 948
 949             if (nPos != -1)
 950             {
 951                 mnLastPosBitmap = nPos;
 952             }
 953             break;
 954         }
 955         default: break;
 956     }
 957 }
 958
 959 void FillControl::SetOptimalSize()
 960 {
 961     Size aSize(mxLbFillType->get_preferred_size());
 962     Size aFirstSize(mxToolBoxColor->get_preferred_size());
 963     auto nWidth = std::max(aFirstSize.Width(), LogicToPixel(Size(55, 0), MapMode(MapUnit::MapAppFont)).Width());
 964     auto nHeight = std::max(aSize.Height(), aFirstSize.Height());
 965     mxToolBoxColor->set_size_request(nWidth, -1);
 966     mxLbFillAttr->set_size_request(42, -1); //something narrow so the toolbar sets the overall size of this column
 967     SetSizePixel(Size(m_xContainer->get_preferred_size().Width(), nHeight));
 968 }
 969
 970 void FillControl::DataChanged(const DataChangedEvent& rDCEvt)
 971 {
 972     if((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 973         (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
 974     {
 975         SetOptimalSize();
 976     }
 977     InterimItemWindow::DataChanged(rDCEvt);
 978 }
 979
 980 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */