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