svx/source/sidebar/area/AreaPropertyPanel.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 #include "svx/sidebar/PopupContainer.hxx"
  20 #include "AreaTransparencyGradientControl.hxx"
  21
  22 #include <sfx2/sidebar/ResourceDefinitions.hrc>
  23 #include <sfx2/sidebar/Theme.hxx>
  24 #include <sfx2/sidebar/ControlFactory.hxx>
  25 #include <AreaPropertyPanel.hxx>
  26 #include <AreaPropertyPanel.hrc>
  27 #include <svx/dialogs.hrc>
  28 #include <svx/dialmgr.hxx>
  29 #include <sfx2/objsh.hxx>
  30 #include <svx/xfltrit.hxx>
  31 #include <svx/xflftrit.hxx>
  32 #include <svx/xtable.hxx>
  33 #include <sfx2/dispatch.hxx>
  34 #include <sfx2/bindings.hxx>
  35 #include <helpid.hrc>
  36 #include <svtools/valueset.hxx>
  37 #include <unotools/pathoptions.hxx>
  38 #include <svx/svxitems.hrc>
  39 #include <vcl/toolbox.hxx>
  40 #include <svtools/toolbarmenu.hxx>
  41
  42 #include <boost/bind.hpp>
  43
  44 using namespace css;
  45 using namespace css::uno;
  46 using ::sfx2::sidebar::Theme;
  47
  48 const char UNO_SIDEBARGRADIENT[] = ".uno:sidebargradient";
  49
  50 namespace svx { namespace sidebar {
  51
  52 const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERX = 50;
  53 const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERY = 50;
  54 const sal_Int32 AreaPropertyPanel::DEFAULT_ANGLE = 0;
  55 const sal_Int32 AreaPropertyPanel::DEFAULT_STARTVALUE = 0;
  56 const sal_Int32 AreaPropertyPanel::DEFAULT_ENDVALUE = 16777215;
  57 const sal_Int32 AreaPropertyPanel::DEFAULT_BORDER = 0;
  58
  59
  60 AreaPropertyPanel::AreaPropertyPanel(
  61     vcl::Window* pParent,
  62     const css::uno::Reference<css::frame::XFrame>& rxFrame,
  63     SfxBindings* pBindings)
  64     : PanelLayout(pParent, "AreaPropertyPanel", "svx/ui/sidebararea.ui", rxFrame),
  65       meLastXFS(static_cast<sal_uInt16>(-1)),
  66       mnLastPosGradient(0),
  67       mnLastPosHatch(0),
  68       mnLastPosBitmap(0),
  69       mnLastTransSolid(50),
  70       maGradientLinear(),
  71       maGradientAxial(),
  72       maGradientRadial(),
  73       maGradientElliptical(),
  74       maGradientSquare(),
  75       maGradientRect(),
  76       mpStyleItem(),
  77       mpColorItem(),
  78       mpFillGradientItem(),
  79       mpHatchItem(),
  80       mpBitmapItem(),
  81       maStyleControl(SID_ATTR_FILL_STYLE, *pBindings, *this),
  82       maColorControl(SID_ATTR_FILL_COLOR, *pBindings, *this),
  83       maGradientControl(SID_ATTR_FILL_GRADIENT, *pBindings, *this),
  84       maHatchControl(SID_ATTR_FILL_HATCH, *pBindings, *this),
  85       maBitmapControl(SID_ATTR_FILL_BITMAP, *pBindings, *this),
  86       maGradientListControl(SID_GRADIENT_LIST, *pBindings, *this),
  87       maHatchListControl(SID_HATCH_LIST, *pBindings, *this),
  88       maBitmapListControl(SID_BITMAP_LIST, *pBindings, *this),
  89       maFillTransparenceController(SID_ATTR_FILL_TRANSPARENCE, *pBindings, *this),
  90       maFillFloatTransparenceController(SID_ATTR_FILL_FLOATTRANSPARENCE, *pBindings, *this),
  91       maImgAxial(SVX_RES(IMG_AXIAL)),
  92       maImgElli(SVX_RES(IMG_ELLI)),
  93       maImgQuad(SVX_RES(IMG_QUAD)),
  94       maImgRadial(SVX_RES(IMG_RADIAL)),
  95       maImgSquare(SVX_RES(IMG_SQUARE)),
  96       maImgLinear(SVX_RES(IMG_LINEAR)),
  97       maTrGrPopup(this, ::boost::bind(&AreaPropertyPanel::CreateTransparencyGradientControl, this, _1)),
  98       mpFloatTransparenceItem(),
  99       mpTransparanceItem(),
 100       mxFrame(rxFrame),
 101       mpBindings(pBindings)
 102 {
 103     get(mpColorTextFT,    "filllabel");
 104     get(mpLbFillType,     "fillstyle");
 105     get(mpLbFillAttr,     "fillattr");
 106     get(mpTrspTextFT,     "transparencylabel");
 107     get(mpToolBoxColor,   "selectcolor");
 108     get(mpLBTransType,    "transtype");
 109     get(mpMTRTransparent, "settransparency");
 110     get(mpBTNGradient,    "selectgradient");
 111
 112     Initialize();
 113 }
 114
 115
 116 AreaPropertyPanel::~AreaPropertyPanel()
 117 {
 118     disposeOnce();
 119 }
 120
 121 void AreaPropertyPanel::dispose()
 122 {
 123     mpColorTextFT.clear();
 124     mpLbFillType.clear();
 125     mpLbFillAttr.clear();
 126     mpToolBoxColor.clear();
 127     mpTrspTextFT.clear();
 128     mpLBTransType.clear();
 129     mpMTRTransparent.clear();
 130     mpBTNGradient.clear();
 131
 132     maStyleControl.dispose();
 133     maColorControl.dispose();
 134     maGradientControl.dispose();
 135     maHatchControl.dispose();
 136     maBitmapControl.dispose();
 137     maGradientListControl.dispose();
 138     maHatchListControl.dispose();
 139     maBitmapListControl.dispose();
 140     maFillTransparenceController.dispose();
 141     maFillFloatTransparenceController.dispose();
 142
 143     PanelLayout::dispose();
 144 }
 145
 146 void AreaPropertyPanel::Initialize()
 147 {
 148     maGradientLinear.SetXOffset(DEFAULT_CENTERX);
 149     maGradientLinear.SetYOffset(DEFAULT_CENTERY);
 150     maGradientLinear.SetAngle(DEFAULT_ANGLE);
 151     maGradientLinear.SetStartColor(Color(DEFAULT_STARTVALUE));
 152     maGradientLinear.SetEndColor(Color(DEFAULT_ENDVALUE));
 153     maGradientLinear.SetBorder(DEFAULT_BORDER);
 154     maGradientLinear.SetGradientStyle(css::awt::GradientStyle_LINEAR);
 155
 156     maGradientAxial = maGradientLinear;
 157     maGradientAxial.SetGradientStyle(css::awt::GradientStyle_AXIAL);
 158
 159     maGradientRadial = maGradientLinear;
 160     maGradientRadial.SetGradientStyle(css::awt::GradientStyle_RADIAL);
 161
 162     maGradientElliptical = maGradientLinear;
 163     maGradientElliptical.SetGradientStyle(css::awt::GradientStyle_ELLIPTICAL);
 164
 165     maGradientSquare = maGradientLinear;
 166     maGradientSquare.SetGradientStyle(css::awt::GradientStyle_SQUARE);
 167
 168     maGradientRect = maGradientLinear;
 169     maGradientRect.SetGradientStyle(css::awt::GradientStyle_RECT);
 170
 171     mpLbFillType->SetAccessibleName(OUString( "Fill"));    //wj acc
 172     mpLbFillAttr->SetAccessibleName(OUString( "Fill"));    //wj acc
 173
 174     Link<> aLink = LINK( this, AreaPropertyPanel, SelectFillTypeHdl );
 175     mpLbFillType->SetSelectHdl( aLink );
 176
 177     aLink = LINK( this, AreaPropertyPanel, SelectFillAttrHdl );
 178     mpLbFillAttr->SetSelectHdl( aLink );
 179
 180     mpLBTransType->SetSelectHdl(LINK(this, AreaPropertyPanel, ChangeTrgrTypeHdl_Impl));
 181     mpLBTransType->SetAccessibleName(OUString( "Transparency"));    //wj acc
 182
 183     mpMTRTransparent->SetValue( 50 );
 184     mpMTRTransparent->SetModifyHdl(LINK(this, AreaPropertyPanel, ModifyTransparentHdl_Impl));
 185     mpMTRTransparent->SetAccessibleName(OUString( "Transparency"));    //wj acc
 186
 187     const sal_uInt16 nIdGradient = mpBTNGradient->GetItemId(UNO_SIDEBARGRADIENT);
 188     mpBTNGradient->SetItemBits( nIdGradient, mpBTNGradient->GetItemBits( nIdGradient ) | ToolBoxItemBits::DROPDOWNONLY );
 189     Link<ToolBox *, void> aLink2 = LINK( this, AreaPropertyPanel, ClickTrGrHdl_Impl );
 190     mpBTNGradient->SetDropdownClickHdl( aLink2 );
 191     mpBTNGradient->SetSelectHdl( aLink2 );
 192     mpBTNGradient->SetItemImage(nIdGradient,maImgLinear);
 193     mpBTNGradient->Hide();
 194
 195     mpLbFillType->SetAccessibleRelationLabeledBy(mpColorTextFT);
 196     mpLbFillAttr->SetAccessibleRelationLabeledBy(mpLbFillAttr);
 197     mpToolBoxColor->SetAccessibleRelationLabeledBy(mpToolBoxColor);
 198     mpLBTransType->SetAccessibleRelationLabeledBy(mpTrspTextFT);
 199     mpMTRTransparent->SetAccessibleRelationLabeledBy(mpMTRTransparent);
 200     mpBTNGradient->SetAccessibleRelationLabeledBy(mpBTNGradient);
 201
 202     SetupIcons();
 203 }
 204
 205 IMPL_LINK(AreaPropertyPanel, SelectFillTypeHdl, ListBox *, pToolBox)
 206 {
 207     const drawing::FillStyle eXFS = (drawing::FillStyle)mpLbFillType->GetSelectEntryPos();
 208
 209     if((drawing::FillStyle)meLastXFS != eXFS)
 210     {
 211         mpLbFillAttr->Clear();
 212         SfxObjectShell* pSh = SfxObjectShell::Current();
 213         const XFillStyleItem aXFillStyleItem(eXFS);
 214
 215         // #i122676# Do no longer trigger two Execute calls, one for SID_ATTR_FILL_STYLE
 216         // and one for setting the fill attribute itself, but add two SfxPoolItems to the
 217         // call to get just one action at the SdrObject and to create only one Undo action, too.
 218         // Checked that this works in all apps.
 219         switch( eXFS )
 220         {
 221             default:
 222             case drawing::FillStyle_NONE:
 223             {
 224                 mpLbFillAttr->Show();
 225                 mpToolBoxColor->Hide();
 226                 mpLbFillType->Selected();
 227                 mpLbFillAttr->Disable();
 228
 229                 // #i122676# need to call a single SID_ATTR_FILL_STYLE change
 230                 GetBindings()->GetDispatcher()->Execute(
 231                     SID_ATTR_FILL_STYLE, SfxCallMode::RECORD, &aXFillStyleItem, 0L);
 232                 break;
 233             }
 234             case drawing::FillStyle_SOLID:
 235             {
 236                 mpLbFillAttr->Hide();
 237                 mpToolBoxColor->Show();
 238                 const OUString aTmpStr;
 239                 const Color aColor = mpColorItem->GetColorValue();
 240                 const XFillColorItem aXFillColorItem( aTmpStr, aColor );
 241
 242                 // #i122676# change FillStyle and Color in one call
 243                 GetBindings()->GetDispatcher()->Execute(
 244                     SID_ATTR_FILL_COLOR, SfxCallMode::RECORD, &aXFillColorItem, &aXFillStyleItem, 0L);
 245                 break;
 246             }
 247             case drawing::FillStyle_GRADIENT:
 248             {
 249                 mpLbFillAttr->Show();
 250                 mpToolBoxColor->Hide();
 251
 252                 if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
 253                 {
 254                     if(!mpLbFillAttr->GetEntryCount())
 255                     {
 256                         const SvxGradientListItem aItem(*static_cast<const SvxGradientListItem*>(pSh->GetItem(SID_GRADIENT_LIST)));
 257                         mpLbFillAttr->Enable();
 258                         mpLbFillAttr->Clear();
 259                         mpLbFillAttr->Fill(aItem.GetGradientList());
 260                     }
 261
 262                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 263
 264                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosGradient)
 265                     {
 266                         const SvxGradientListItem aItem(*static_cast<const SvxGradientListItem*>(pSh->GetItem(SID_GRADIENT_LIST)));
 267
 268                         if(mnLastPosGradient < aItem.GetGradientList()->Count())
 269                         {
 270                             const XGradient aGradient = aItem.GetGradientList()->GetGradient(mnLastPosGradient)->GetGradient();
 271                             const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetEntry(mnLastPosGradient), aGradient);
 272
 273                             // #i122676# change FillStyle and Gradient in one call
 274                             GetBindings()->GetDispatcher()->Execute(
 275                                 SID_ATTR_FILL_GRADIENT, SfxCallMode::RECORD, &aXFillGradientItem, &aXFillStyleItem, 0L);
 276                             mpLbFillAttr->SelectEntryPos(mnLastPosGradient);
 277                         }
 278                     }
 279                 }
 280                 else
 281                 {
 282                     mpLbFillAttr->Disable();
 283                 }
 284                 break;
 285             }
 286             case drawing::FillStyle_HATCH:
 287             {
 288                 mpLbFillAttr->Show();
 289                 mpToolBoxColor->Hide();
 290
 291                 if(pSh && pSh->GetItem(SID_HATCH_LIST))
 292                 {
 293                     if(!mpLbFillAttr->GetEntryCount())
 294                     {
 295                         const SvxHatchListItem aItem( *static_cast<const SvxHatchListItem*>(pSh->GetItem(SID_HATCH_LIST)));
 296                         mpLbFillAttr->Enable();
 297                         mpLbFillAttr->Clear();
 298                         mpLbFillAttr->Fill(aItem.GetHatchList());
 299                     }
 300
 301                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 302
 303                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosHatch)
 304                     {
 305                         const SvxHatchListItem aItem(*static_cast<const SvxHatchListItem*>(pSh->GetItem(SID_HATCH_LIST)));
 306
 307                         if(mnLastPosHatch < aItem.GetHatchList()->Count())
 308                         {
 309                             const XHatch aHatch = aItem.GetHatchList()->GetHatch(mnLastPosHatch)->GetHatch();
 310                             const XFillHatchItem aXFillHatchItem(mpLbFillAttr->GetSelectEntry(), aHatch);
 311
 312                             // #i122676# change FillStyle and Hatch in one call
 313                             GetBindings()->GetDispatcher()->Execute(
 314                                 SID_ATTR_FILL_HATCH, SfxCallMode::RECORD, &aXFillHatchItem, &aXFillStyleItem, 0L);
 315                             mpLbFillAttr->SelectEntryPos(mnLastPosHatch);
 316                         }
 317                     }
 318                 }
 319                 else
 320                 {
 321                     mpLbFillAttr->Disable();
 322                 }
 323                 break;
 324             }
 325             case drawing::FillStyle_BITMAP:
 326             {
 327                 mpLbFillAttr->Show();
 328                 mpToolBoxColor->Hide();
 329
 330                 if(pSh && pSh->GetItem(SID_BITMAP_LIST))
 331                 {
 332                     if(!mpLbFillAttr->GetEntryCount())
 333                     {
 334                         const SvxBitmapListItem aItem( *static_cast<const SvxBitmapListItem*>(pSh->GetItem(SID_BITMAP_LIST)));
 335                         mpLbFillAttr->Enable();
 336                         mpLbFillAttr->Clear();
 337                         mpLbFillAttr->Fill(aItem.GetBitmapList());
 338                     }
 339
 340                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 341
 342                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosBitmap)
 343                     {
 344                         const SvxBitmapListItem aItem(*static_cast<const SvxBitmapListItem*>(pSh->GetItem(SID_BITMAP_LIST)));
 345
 346                         if(mnLastPosBitmap < aItem.GetBitmapList()->Count())
 347                         {
 348                             const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(mnLastPosBitmap);
 349                             const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject());
 350
 351                             // #i122676# change FillStyle and Bitmap in one call
 352                             GetBindings()->GetDispatcher()->Execute(
 353                                 SID_ATTR_FILL_BITMAP, SfxCallMode::RECORD, &aXFillBitmapItem, &aXFillStyleItem, 0L);
 354                             mpLbFillAttr->SelectEntryPos(mnLastPosBitmap);
 355                         }
 356                     }
 357                 }
 358                 else
 359                 {
 360                     mpLbFillAttr->Disable();
 361                 }
 362                 break;
 363             }
 364         }
 365
 366         meLastXFS = (sal_uInt16)eXFS;
 367
 368         if(drawing::FillStyle_NONE != eXFS)
 369         {
 370             if(pToolBox)
 371             {
 372                 mpLbFillType->Selected();
 373             }
 374         }
 375     }
 376
 377     return 0;
 378 }
 379
 380 IMPL_LINK(AreaPropertyPanel, SelectFillAttrHdl, ListBox*, pToolBox)
 381 {
 382     const drawing::FillStyle eXFS = (drawing::FillStyle)mpLbFillType->GetSelectEntryPos();
 383     const XFillStyleItem aXFillStyleItem(eXFS);
 384     SfxObjectShell* pSh = SfxObjectShell::Current();
 385
 386     if(pToolBox)
 387     {
 388         // #i122676# dependent from bFillStyleChange, do execute a single or two
 389         // changes in one Execute call
 390         const bool bFillStyleChange((drawing::FillStyle) meLastXFS != eXFS);
 391
 392         switch(eXFS)
 393         {
 394             case drawing::FillStyle_SOLID:
 395             {
 396                 if(bFillStyleChange)
 397                 {
 398                     // #i122676# Single FillStyle change call needed here
 399                     GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_STYLE, SfxCallMode::RECORD, &aXFillStyleItem, 0L);
 400                 }
 401                 break;
 402             }
 403             case drawing::FillStyle_GRADIENT:
 404             {
 405                 sal_Int32 nPos = mpLbFillAttr->GetSelectEntryPos();
 406
 407                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 408                 {
 409                     nPos = mnLastPosGradient;
 410                 }
 411
 412                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_GRADIENT_LIST))
 413                 {
 414                     const SvxGradientListItem aItem(*static_cast<const SvxGradientListItem*>(pSh->GetItem(SID_GRADIENT_LIST)));
 415
 416                     if(nPos < aItem.GetGradientList()->Count())
 417                     {
 418                         const XGradient aGradient = aItem.GetGradientList()->GetGradient(nPos)->GetGradient();
 419                         const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetSelectEntry(), aGradient);
 420
 421                         // #i122676# Change FillStale and Gradinet in one call
 422                         GetBindings()->GetDispatcher()->Execute(
 423                             SID_ATTR_FILL_GRADIENT, SfxCallMode::RECORD, &aXFillGradientItem,
 424                             bFillStyleChange ? &aXFillStyleItem : 0L, 0L);
 425                     }
 426                 }
 427
 428                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 429                 {
 430                     mnLastPosGradient = nPos;
 431                 }
 432                 break;
 433             }
 434             case drawing::FillStyle_HATCH:
 435             {
 436                 sal_Int32 nPos = mpLbFillAttr->GetSelectEntryPos();
 437
 438                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 439                 {
 440                     nPos = mnLastPosHatch;
 441                 }
 442
 443                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_HATCH_LIST))
 444                 {
 445                     const SvxHatchListItem aItem(*static_cast<const SvxHatchListItem*>(pSh->GetItem(SID_HATCH_LIST)));
 446
 447                     if(nPos < aItem.GetHatchList()->Count())
 448                     {
 449                         const XHatch aHatch = aItem.GetHatchList()->GetHatch(nPos)->GetHatch();
 450                         const XFillHatchItem aXFillHatchItem( mpLbFillAttr->GetSelectEntry(), aHatch);
 451
 452                         // #i122676# Change FillStale and Hatch in one call
 453                         GetBindings()->GetDispatcher()->Execute(
 454                             SID_ATTR_FILL_HATCH, SfxCallMode::RECORD, &aXFillHatchItem,
 455                             bFillStyleChange ? &aXFillStyleItem : 0L, 0L);
 456                     }
 457                 }
 458
 459                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 460                 {
 461                     mnLastPosHatch = nPos;
 462                 }
 463                 break;
 464             }
 465             case drawing::FillStyle_BITMAP:
 466             {
 467                 sal_Int32 nPos = mpLbFillAttr->GetSelectEntryPos();
 468
 469                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 470                 {
 471                     nPos = mnLastPosBitmap;
 472                 }
 473
 474                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_BITMAP_LIST))
 475                 {
 476                     const SvxBitmapListItem aItem(*static_cast<const SvxBitmapListItem*>(pSh->GetItem(SID_BITMAP_LIST)));
 477
 478                     if(nPos < aItem.GetBitmapList()->Count())
 479                     {
 480                         const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(nPos);
 481                         const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject());
 482
 483                         // #i122676# Change FillStale and Bitmap in one call
 484                         GetBindings()->GetDispatcher()->Execute(
 485                             SID_ATTR_FILL_BITMAP, SfxCallMode::RECORD, &aXFillBitmapItem,
 486                             bFillStyleChange ? &aXFillStyleItem : 0L, 0L);
 487                     }
 488                 }
 489
 490                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 491                 {
 492                     mnLastPosBitmap = nPos;
 493                 }
 494                 break;
 495             }
 496             default: break;
 497         }
 498     }
 499
 500     return 0;
 501 }
 502
 503
 504 VclPtr<PopupControl> AreaPropertyPanel::CreateTransparencyGradientControl (PopupContainer* pParent)
 505 {
 506     return VclPtrInstance<AreaTransparencyGradientControl>(pParent, *this);
 507 }
 508
 509
 510
 511
 512 void AreaPropertyPanel::SetupIcons()
 513 {
 514     if(Theme::GetBoolean(Theme::Bool_UseSymphonyIcons))
 515     {
 516         // todo
 517     }
 518     else
 519     {
 520         // todo
 521     }
 522 }
 523
 524
 525
 526 VclPtr<vcl::Window> AreaPropertyPanel::Create (
 527     vcl::Window* pParent,
 528     const css::uno::Reference<css::frame::XFrame>& rxFrame,
 529     SfxBindings* pBindings)
 530 {
 531     if (pParent == NULL)
 532         throw lang::IllegalArgumentException("no parent Window given to AreaPropertyPanel::Create", NULL, 0);
 533     if ( ! rxFrame.is())
 534         throw lang::IllegalArgumentException("no XFrame given to AreaPropertyPanel::Create", NULL, 1);
 535     if (pBindings == NULL)
 536         throw lang::IllegalArgumentException("no SfxBindings given to AreaPropertyPanel::Create", NULL, 2);
 537
 538     return VclPtr<AreaPropertyPanel>::Create(
 539                 pParent,
 540                 rxFrame,
 541                 pBindings);
 542 }
 543
 544
 545
 546 void AreaPropertyPanel::DataChanged(
 547     const DataChangedEvent& rEvent)
 548 {
 549     (void)rEvent;
 550
 551     SetupIcons();
 552 }
 553
 554
 555
 556 void AreaPropertyPanel::ImpUpdateTransparencies()
 557 {
 558     if(mpTransparanceItem.get() && mpFloatTransparenceItem.get())
 559     {
 560         bool bZeroValue(false);
 561
 562         if(mpTransparanceItem.get())
 563         {
 564             const sal_uInt16 nValue(mpTransparanceItem->GetValue());
 565
 566             if(!nValue)
 567             {
 568                 bZeroValue = true;
 569             }
 570             else if(nValue <= 100)
 571             {
 572                 mpLBTransType->Enable();
 573                 mpTrspTextFT->Enable();
 574                 mpLBTransType->SelectEntryPos(1);
 575                 mpBTNGradient->Hide();
 576                 mpMTRTransparent->Show();
 577                 mpMTRTransparent->Enable();
 578                 mpMTRTransparent->SetValue(nValue);
 579             }
 580
 581             if(!bZeroValue)
 582             {
 583                 maTrGrPopup.Hide();
 584             }
 585         }
 586
 587         if(bZeroValue && mpFloatTransparenceItem.get())
 588         {
 589             if(mpFloatTransparenceItem->IsEnabled())
 590             {
 591                 const XGradient& rGradient = mpFloatTransparenceItem->GetGradientValue();
 592                 sal_Int32 nEntryPos(0);
 593                 Image* pImage = 0;
 594
 595                 mpLBTransType->Enable();
 596                 mpTrspTextFT->Enable();
 597                 mpMTRTransparent->Hide();
 598                 mpBTNGradient->Enable();
 599                 mpBTNGradient->Show();
 600
 601                 switch(rGradient.GetGradientStyle())
 602                 {
 603                     default:
 604                     case css::awt::GradientStyle_LINEAR:
 605                     {
 606                         nEntryPos = 2;
 607                         pImage = &maImgLinear;
 608                         break;
 609                     }
 610                     case css::awt::GradientStyle_AXIAL:
 611                     {
 612                         nEntryPos = 3;
 613                         pImage = &maImgAxial;
 614                         break;
 615                     }
 616                     case css::awt::GradientStyle_RADIAL:
 617                     {
 618                         nEntryPos = 4;
 619                         pImage = &maImgRadial;
 620                         break;
 621                     }
 622                     case css::awt::GradientStyle_ELLIPTICAL:
 623                     {
 624                         nEntryPos = 5;
 625                         pImage = &maImgElli;
 626                         break;
 627                     }
 628                     case css::awt::GradientStyle_SQUARE:
 629                     {
 630                         nEntryPos = 6;
 631                         pImage = &maImgQuad;
 632                         break;
 633                     }
 634                     case css::awt::GradientStyle_RECT:
 635                     {
 636                         nEntryPos = 7;
 637                         pImage = &maImgSquare;
 638                         break;
 639                     }
 640                 }
 641
 642                 const sal_uInt16 nIdGradient = mpBTNGradient->GetItemId(UNO_SIDEBARGRADIENT);
 643                 mpLBTransType->SelectEntryPos(nEntryPos);
 644                 mpBTNGradient->SetItemImage(nIdGradient, *pImage);
 645                 bZeroValue = false;
 646             }
 647             else
 648             {
 649                 bZeroValue = true;
 650             }
 651         }
 652
 653         if(bZeroValue)
 654         {
 655             mpLBTransType->Enable();
 656             mpTrspTextFT->Enable();
 657             mpLBTransType->SelectEntryPos(0);
 658             mpBTNGradient->Hide();
 659             mpMTRTransparent->Enable();
 660             mpMTRTransparent->Show();
 661             mpMTRTransparent->SetValue(0);
 662         }
 663     }
 664     else
 665     {
 666         // no transparency at all
 667         mpLBTransType->SetNoSelection();
 668         mpLBTransType->Disable();
 669         mpTrspTextFT->Disable();
 670         mpMTRTransparent->Disable();
 671         mpMTRTransparent->Show();
 672         mpBTNGradient->Disable();
 673         mpBTNGradient->Hide();
 674     }
 675 }
 676
 677
 678
 679 void AreaPropertyPanel::NotifyItemUpdate(
 680     sal_uInt16 nSID,
 681     SfxItemState eState,
 682     const SfxPoolItem* pState,
 683     const bool bIsEnabled)
 684 {
 685     (void)bIsEnabled;
 686     const bool bDisabled(SfxItemState::DISABLED == eState);
 687
 688     switch(nSID)
 689     {
 690         case SID_ATTR_FILL_TRANSPARENCE:
 691         case SID_ATTR_FILL_FLOATTRANSPARENCE:
 692         {
 693             bool bFillTransparenceChanged(false);
 694
 695             if(SID_ATTR_FILL_TRANSPARENCE == nSID)
 696             {
 697                 bFillTransparenceChanged = true;
 698
 699                 if(eState >= SfxItemState::DEFAULT)
 700                 {
 701                     const SfxUInt16Item* pItem = dynamic_cast< const SfxUInt16Item* >(pState);
 702
 703                     if(pItem && (!mpTransparanceItem || *pItem != *mpTransparanceItem))
 704                     {
 705                         mpTransparanceItem.reset(static_cast<SfxUInt16Item*>(pItem->Clone()));
 706                     }
 707                     else
 708                     {
 709                         mpTransparanceItem.reset();
 710                     }
 711                 }
 712                 else
 713                 {
 714                     mpTransparanceItem.reset();
 715                 }
 716             }
 717             else // if(SID_ATTR_FILL_FLOATTRANSPARENCE == nSID)
 718             {
 719                 bFillTransparenceChanged = true;
 720
 721                 if(eState >= SfxItemState::DEFAULT)
 722                 {
 723                     const XFillFloatTransparenceItem* pItem = dynamic_cast< const XFillFloatTransparenceItem* >(pState);
 724
 725                     if(pItem && (!mpFloatTransparenceItem || *pItem != *mpFloatTransparenceItem))
 726                     {
 727                         mpFloatTransparenceItem.reset(static_cast<XFillFloatTransparenceItem*>(pItem->Clone()));
 728                     }
 729                     else
 730                     {
 731                         mpFloatTransparenceItem.reset();
 732                     }
 733                 }
 734                 else
 735                 {
 736                     mpFloatTransparenceItem.reset();
 737                 }
 738             }
 739
 740             if(bFillTransparenceChanged)
 741             {
 742                 // update transparency settings dependent of mpTransparanceItem and mpFloatTransparenceItem
 743                 ImpUpdateTransparencies();
 744             }
 745             break;
 746         }
 747         case SID_ATTR_FILL_STYLE:
 748         {
 749             if(bDisabled)
 750             {
 751                 mpLbFillType->Disable();
 752                 mpColorTextFT->Disable();
 753                 mpLbFillType->SetNoSelection();
 754                 mpLbFillAttr->Show();
 755                 mpLbFillAttr->Disable();
 756                 mpLbFillAttr->SetNoSelection();
 757                 mpToolBoxColor->Hide();
 758                 meLastXFS = static_cast<sal_uInt16>(-1);
 759                 mpStyleItem.reset();
 760             }
 761
 762             if(eState >= SfxItemState::DEFAULT)
 763             {
 764                 const XFillStyleItem* pItem = dynamic_cast< const XFillStyleItem* >(pState);
 765
 766                 if(pItem)
 767                 {
 768                     mpStyleItem.reset(dynamic_cast< XFillStyleItem* >(pItem->Clone()));
 769                     mpLbFillType->Enable();
 770                     mpColorTextFT->Enable();
 771                     drawing::FillStyle eXFS = (drawing::FillStyle)mpStyleItem->GetValue();
 772                     meLastXFS = eXFS;
 773                     mpLbFillType->SelectEntryPos(sal::static_int_cast< sal_Int32 >(eXFS));
 774
 775                     if(drawing::FillStyle_NONE == eXFS)
 776                     {
 777                         mpLbFillAttr->SetNoSelection();
 778                         mpLbFillAttr->Disable();
 779                     }
 780
 781                     Update();
 782                     break;
 783                 }
 784             }
 785
 786             mpLbFillType->SetNoSelection();
 787             mpLbFillAttr->Show();
 788             mpLbFillAttr->Disable();
 789             mpLbFillAttr->SetNoSelection();
 790             mpToolBoxColor->Hide();
 791             meLastXFS = static_cast<sal_uInt16>(-1);
 792             mpStyleItem.reset();
 793             break;
 794         }
 795         case SID_ATTR_FILL_COLOR:
 796         {
 797             if(SfxItemState::DEFAULT == eState)
 798             {
 799                 mpColorItem.reset(pState ? static_cast<XFillColorItem*>(pState->Clone()) : 0);
 800             }
 801
 802             if(mpStyleItem && drawing::FillStyle_SOLID == (drawing::FillStyle)mpStyleItem->GetValue())
 803             {
 804                 mpLbFillAttr->Hide();
 805                 mpToolBoxColor->Show();
 806
 807                 Update();
 808             }
 809             break;
 810         }
 811         case SID_ATTR_FILL_GRADIENT:
 812         {
 813             if(SfxItemState::DEFAULT == eState)
 814             {
 815                 mpFillGradientItem.reset(pState ? static_cast<XFillGradientItem*>(pState->Clone()) : 0);
 816             }
 817
 818             if(mpStyleItem && drawing::FillStyle_GRADIENT == (drawing::FillStyle)mpStyleItem->GetValue())
 819             {
 820                 mpLbFillAttr->Show();
 821                 mpToolBoxColor->Hide();
 822
 823                 if(SfxItemState::DEFAULT == eState)
 824                 {
 825                     mpLbFillAttr->Enable();
 826                     Update();
 827                 }
 828                 else if(SfxItemState::DISABLED == eState )
 829                 {
 830                     mpLbFillAttr->Disable();
 831                     mpLbFillAttr->SetNoSelection();
 832                 }
 833                 else
 834                 {
 835                     mpLbFillAttr->SetNoSelection();
 836                 }
 837             }
 838             break;
 839         }
 840         case SID_ATTR_FILL_HATCH:
 841         {
 842             if(SfxItemState::DEFAULT == eState)
 843             {
 844                 mpHatchItem.reset(pState ? static_cast<XFillHatchItem*>(pState->Clone()) : 0);
 845             }
 846
 847             if(mpStyleItem && drawing::FillStyle_HATCH == (drawing::FillStyle)mpStyleItem->GetValue())
 848             {
 849                 mpLbFillAttr->Show();
 850                 mpToolBoxColor->Hide();
 851
 852                 if(SfxItemState::DEFAULT == eState)
 853                 {
 854                     mpLbFillAttr->Enable();
 855                     Update();
 856                 }
 857                 else if(SfxItemState::DISABLED == eState )
 858                 {
 859                     mpLbFillAttr->Disable();
 860                     mpLbFillAttr->SetNoSelection();
 861                 }
 862                 else
 863                 {
 864                     mpLbFillAttr->SetNoSelection();
 865                 }
 866             }
 867             break;
 868         }
 869         case SID_ATTR_FILL_BITMAP:
 870         {
 871             if(SfxItemState::DEFAULT == eState)
 872             {
 873                 mpBitmapItem.reset(pState ? static_cast<XFillBitmapItem*>(pState->Clone()) : 0);
 874             }
 875
 876             if(mpStyleItem && drawing::FillStyle_BITMAP == (drawing::FillStyle)mpStyleItem->GetValue())
 877             {
 878                 mpLbFillAttr->Show();
 879                 mpToolBoxColor->Hide();
 880
 881                 if(SfxItemState::DEFAULT == eState)
 882                 {
 883                     mpLbFillAttr->Enable();
 884                     Update();
 885                 }
 886                 else if(SfxItemState::DISABLED == eState )
 887                 {
 888                     mpLbFillAttr->Disable();
 889                     mpLbFillAttr->SetNoSelection();
 890                 }
 891                 else
 892                 {
 893                     mpLbFillAttr->SetNoSelection();
 894                 }
 895             }
 896             break;
 897         }
 898         case SID_GRADIENT_LIST:
 899         {
 900             if(SfxItemState::DEFAULT == eState)
 901             {
 902                 if(mpStyleItem && drawing::FillStyle_GRADIENT == (drawing::FillStyle)mpStyleItem->GetValue())
 903                 {
 904                     if(mpFillGradientItem)
 905                     {
 906                         const OUString aString( mpFillGradientItem->GetName() );
 907                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 908                         const SvxGradientListItem aItem( *static_cast<const SvxGradientListItem*>(pSh->GetItem(SID_GRADIENT_LIST)));
 909
 910                         mpLbFillAttr->Clear();
 911                         mpLbFillAttr->Enable();
 912                         mpLbFillAttr->Fill(aItem.GetGradientList());
 913                         mpLbFillAttr->SelectEntry(aString);
 914                     }
 915                     else
 916                     {
 917                         mpLbFillAttr->SetNoSelection();
 918                     }
 919                 }
 920             }
 921             break;
 922         }
 923         case SID_HATCH_LIST:
 924         {
 925             if(SfxItemState::DEFAULT == eState)
 926             {
 927                 if(mpStyleItem && drawing::FillStyle_HATCH == (drawing::FillStyle)mpStyleItem->GetValue())
 928                 {
 929                     if(mpHatchItem)
 930                     {
 931                         const OUString aString( mpHatchItem->GetName() );
 932                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 933                         const SvxHatchListItem aItem(*static_cast<const SvxHatchListItem*>(pSh->GetItem(SID_HATCH_LIST)));
 934
 935                         mpLbFillAttr->Clear();
 936                         mpLbFillAttr->Enable();
 937                         mpLbFillAttr->Fill(aItem.GetHatchList());
 938                         mpLbFillAttr->SelectEntry(aString);
 939                     }
 940                     else
 941                     {
 942                         mpLbFillAttr->SetNoSelection();
 943                     }
 944                 }
 945             }
 946             break;
 947         }
 948         case SID_BITMAP_LIST:
 949         {
 950             if(SfxItemState::DEFAULT == eState)
 951             {
 952                 if(mpStyleItem && drawing::FillStyle_BITMAP == (drawing::FillStyle)mpStyleItem->GetValue())
 953                 {
 954                     if(mpBitmapItem)
 955                     {
 956                         const OUString aString( mpBitmapItem->GetName() );
 957                         const SfxObjectShell* pSh = SfxObjectShell::Current();
 958                         const SvxBitmapListItem aItem(*static_cast<const SvxBitmapListItem*>(pSh->GetItem(SID_BITMAP_LIST)));
 959
 960                         mpLbFillAttr->Clear();
 961                         mpLbFillAttr->Enable();
 962                         mpLbFillAttr->Fill(aItem.GetBitmapList());
 963                         mpLbFillAttr->SelectEntry(aString);
 964                     }
 965                     else
 966                     {
 967                         mpLbFillAttr->SetNoSelection();
 968                     }
 969                 }
 970             }
 971             break;
 972         }
 973     }
 974 }
 975
 976
 977
 978
 979
 980
 981 void AreaPropertyPanel::Update()
 982 {
 983     if(mpStyleItem)
 984     {
 985         const drawing::FillStyle eXFS = (drawing::FillStyle)mpStyleItem->GetValue();
 986         SfxObjectShell* pSh = SfxObjectShell::Current();
 987
 988         switch( eXFS )
 989         {
 990             case drawing::FillStyle_NONE:
 991             {
 992                 mpLbFillAttr->Show();
 993                 mpToolBoxColor->Hide();
 994                 break;
 995             }
 996             case drawing::FillStyle_SOLID:
 997             {
 998                 if(mpColorItem)
 999                 {
1000                     mpLbFillAttr->Hide();
1001                     mpToolBoxColor->Show();
1002                 }
1003                 break;
1004             }
1005             case drawing::FillStyle_GRADIENT:
1006             {
1007                 mpLbFillAttr->Show();
1008                 mpToolBoxColor->Hide();
1009
1010                 if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
1011                 {
1012                     const SvxGradientListItem aItem(*static_cast<const SvxGradientListItem*>(pSh->GetItem(SID_GRADIENT_LIST)));
1013                     mpLbFillAttr->Enable();
1014                     mpLbFillAttr->Clear();
1015                     mpLbFillAttr->Fill(aItem.GetGradientList());
1016
1017                     if(mpFillGradientItem)
1018                     {
1019                         const OUString aString(mpFillGradientItem->GetName());
1020
1021                         mpLbFillAttr->SelectEntry(aString);
1022                     }
1023                     else
1024                     {
1025                         mpLbFillAttr->SetNoSelection();
1026                     }
1027                 }
1028                 else
1029                 {
1030                     mpLbFillAttr->SetNoSelection();
1031                 }
1032                 break;
1033             }
1034             case drawing::FillStyle_HATCH:
1035             {
1036                 mpLbFillAttr->Show();
1037                 mpToolBoxColor->Hide();
1038
1039                 if(pSh && pSh->GetItem(SID_HATCH_LIST))
1040                 {
1041                     const SvxHatchListItem aItem(*static_cast<const SvxHatchListItem*>(pSh->GetItem(SID_HATCH_LIST)));
1042                     mpLbFillAttr->Enable();
1043                     mpLbFillAttr->Clear();
1044                     mpLbFillAttr->Fill(aItem.GetHatchList());
1045
1046                     if(mpHatchItem)
1047                     {
1048                         const OUString aString(mpHatchItem->GetName());
1049
1050                         mpLbFillAttr->SelectEntry( aString );
1051                     }
1052                     else
1053                     {
1054                         mpLbFillAttr->SetNoSelection();
1055                     }
1056                 }
1057                 else
1058                 {
1059                     mpLbFillAttr->SetNoSelection();
1060                 }
1061                 break;
1062             }
1063             case drawing::FillStyle_BITMAP:
1064             {
1065                 mpLbFillAttr->Show();
1066                 mpToolBoxColor->Hide();
1067
1068                 if(pSh && pSh->GetItem(SID_BITMAP_LIST))
1069                 {
1070                     const SvxBitmapListItem aItem(*static_cast<const SvxBitmapListItem*>(pSh->GetItem(SID_BITMAP_LIST)));
1071                     mpLbFillAttr->Enable();
1072                     mpLbFillAttr->Clear();
1073                     mpLbFillAttr->Fill(aItem.GetBitmapList());
1074
1075                     if(mpBitmapItem)
1076                     {
1077                         const OUString aString(mpBitmapItem->GetName());
1078
1079                         mpLbFillAttr->SelectEntry(aString);
1080                     }
1081                     else
1082                     {
1083                         mpLbFillAttr->SetNoSelection();
1084                     }
1085                 }
1086                 else
1087                 {
1088                     mpLbFillAttr->SetNoSelection();
1089                 }
1090                 break;
1091             }
1092             default:
1093                 OSL_ENSURE(false, "Non supported FillType (!)");
1094             break;
1095         }
1096     }
1097 }
1098
1099
1100
1101 IMPL_LINK_TYPED( AreaPropertyPanel, ClickTrGrHdl_Impl, ToolBox*, pToolBox, void )
1102 {
1103     maTrGrPopup.Rearrange(mpFloatTransparenceItem.get());
1104     OSL_ASSERT( pToolBox->GetItemCommand(pToolBox->GetCurItemId()) == UNO_SIDEBARGRADIENT);
1105     maTrGrPopup.Show(*pToolBox);
1106 }
1107
1108
1109
1110 IMPL_LINK_NOARG(AreaPropertyPanel, ChangeTrgrTypeHdl_Impl)
1111 {
1112     sal_Int32 nSelectType = mpLBTransType->GetSelectEntryPos();
1113     bool bGradient = false;
1114     sal_uInt16 nTrans = 0;
1115
1116     if(!nSelectType)
1117     {
1118         mpBTNGradient->Hide();
1119         mpMTRTransparent->Show();
1120         mpMTRTransparent->Enable();
1121         mpMTRTransparent->SetValue(0);
1122     }
1123     else if(1 == nSelectType)
1124     {
1125         mpBTNGradient->Hide();
1126         mpMTRTransparent->Show();
1127         nTrans = mnLastTransSolid;
1128         mpMTRTransparent->SetValue(nTrans);
1129         mpLBTransType->SelectEntryPos(1);
1130         mpMTRTransparent->Enable();
1131     }
1132     else
1133     {
1134         mpBTNGradient->Show();
1135
1136         const sal_uInt16 nIdGradient = mpBTNGradient->GetItemId(UNO_SIDEBARGRADIENT);
1137         switch (nSelectType)
1138         {
1139             case 2:
1140                 mpBTNGradient->SetItemImage(nIdGradient, maImgLinear);
1141                 break;
1142             case 3:
1143                 mpBTNGradient->SetItemImage(nIdGradient, maImgAxial);
1144                 break;
1145             case 4:
1146                 mpBTNGradient->SetItemImage(nIdGradient, maImgRadial);
1147                 break;
1148             case 5:
1149                 mpBTNGradient->SetItemImage(nIdGradient, maImgElli );
1150                 break;
1151             case 6:
1152                 mpBTNGradient->SetItemImage(nIdGradient, maImgQuad );
1153                 break;
1154             case 7:
1155                 mpBTNGradient->SetItemImage(nIdGradient, maImgSquare);
1156                 break;
1157         }
1158
1159         mpMTRTransparent->Hide();
1160         mpBTNGradient->Enable();
1161         bGradient = true;
1162     }
1163
1164     const XFillTransparenceItem aLinearItem(nTrans);
1165     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SfxCallMode::RECORD, &aLinearItem, 0L );
1166
1167     if(nSelectType > 1)
1168     {
1169         nSelectType -= 2;
1170     }
1171
1172     XGradient aTmpGradient;
1173
1174     switch(nSelectType)
1175     {
1176         case css::awt::GradientStyle_LINEAR:
1177             aTmpGradient = maGradientLinear;
1178             break;
1179         case css::awt::GradientStyle_AXIAL:
1180             aTmpGradient = maGradientAxial;
1181             break;
1182         case css::awt::GradientStyle_RADIAL:
1183             aTmpGradient = maGradientRadial;
1184             break;
1185         case css::awt::GradientStyle_ELLIPTICAL:
1186             aTmpGradient = maGradientElliptical;
1187             break;
1188         case css::awt::GradientStyle_SQUARE:
1189             aTmpGradient = maGradientSquare;
1190             break;
1191         case css::awt::GradientStyle_RECT:
1192             aTmpGradient = maGradientRect;
1193             break;
1194         default:
1195             break;
1196     }
1197
1198     SfxItemPool* pPool = 0;
1199     const XFillFloatTransparenceItem aGradientItem(pPool, aTmpGradient, bGradient);
1200     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_FLOATTRANSPARENCE, SfxCallMode::RECORD, &aGradientItem, 0L );
1201
1202     return 0L;
1203 }
1204
1205
1206
1207 IMPL_LINK_NOARG(AreaPropertyPanel, ModifyTransparentHdl_Impl)
1208 {
1209     const sal_uInt16 nTrans = (sal_uInt16)mpMTRTransparent->GetValue();
1210     mnLastTransSolid = nTrans;
1211     const sal_Int32 nSelectType = mpLBTransType->GetSelectEntryPos();
1212
1213     if(nTrans && !nSelectType)
1214     {
1215         mpLBTransType->SelectEntryPos(1);
1216     }
1217
1218     const XFillTransparenceItem aLinearItem(nTrans);
1219     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SfxCallMode::RECORD, &aLinearItem, 0L );
1220
1221     return 0L;
1222 }
1223
1224
1225
1226
1227
1228
1229 XGradient AreaPropertyPanel::GetGradient (const css::awt::GradientStyle eStyle) const
1230 {
1231     switch (eStyle)
1232     {
1233         default:
1234         case css::awt::GradientStyle_LINEAR:
1235             return maGradientLinear;
1236         case css::awt::GradientStyle_AXIAL:
1237             return maGradientAxial;
1238         case css::awt::GradientStyle_RADIAL:
1239             return maGradientRadial;
1240         case css::awt::GradientStyle_ELLIPTICAL:
1241             return maGradientElliptical;
1242         case css::awt::GradientStyle_SQUARE:
1243             return maGradientSquare;
1244         case css::awt::GradientStyle_RECT:
1245             return maGradientRect;
1246     }
1247 }
1248
1249
1250
1251
1252 void AreaPropertyPanel::SetGradient (const XGradient& rGradient)
1253 {
1254     switch (rGradient.GetGradientStyle())
1255     {
1256         case css::awt::GradientStyle_LINEAR:
1257             maGradientLinear = rGradient;
1258             break;
1259         case css::awt::GradientStyle_AXIAL:
1260             maGradientAxial = rGradient;
1261             break;
1262         case css::awt::GradientStyle_RADIAL:
1263             maGradientRadial = rGradient;
1264             break;
1265         case css::awt::GradientStyle_ELLIPTICAL:
1266             maGradientElliptical = rGradient;
1267             break;
1268         case css::awt::GradientStyle_SQUARE:
1269             maGradientSquare = rGradient;
1270             break;
1271         case css::awt::GradientStyle_RECT:
1272             maGradientRect = rGradient;
1273             break;
1274         default:
1275             break;
1276     }
1277 }
1278
1279
1280
1281
1282 sal_Int32 AreaPropertyPanel::GetSelectedTransparencyTypeIndex() const
1283 {
1284     return mpLBTransType->GetSelectEntryPos();
1285 }
1286
1287 } } // end of namespace svx::sidebar
1288
1289 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */