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