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