svx/source/sidebar/area/AreaPropertyPanel.cxx

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 #include "svx/sidebar/PopupContainer.hxx"
  19 #include "AreaTransparencyGradientControl.hxx"
  20
  21 #include <sfx2/sidebar/ResourceDefinitions.hrc>
  22 #include <sfx2/sidebar/Theme.hxx>
  23 #include <sfx2/sidebar/ControlFactory.hxx>
  24 #include <AreaPropertyPanel.hxx>
  25 #include <AreaPropertyPanel.hrc>
  26 #include <svx/dialogs.hrc>
  27 #include <svx/dialmgr.hxx>
  28 #include <sfx2/objsh.hxx>
  29 #include <svx/xfltrit.hxx>
  30 #include <svx/xflftrit.hxx>
  31 #include <svx/xtable.hxx>
  32 #include <sfx2/dispatch.hxx>
  33 #include <sfx2/bindings.hxx>
  34 #include <helpid.hrc>
  35 #include <svtools/valueset.hxx>
  36 #include <unotools/pathoptions.hxx>
  37 #include <svx/svxitems.hrc>
  38 #include <vcl/toolbox.hxx>
  39 #include <svtools/toolbarmenu.hxx>
  40 #include <svx/sidebar/ColorControl.hxx>
  41
  42 #include <boost/bind.hpp>
  43
  44 using namespace css;
  45 using namespace cssu;
  46 using ::sfx2::sidebar::Theme;
  47
  48 #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString)))
  49
  50
  51
  52
  53 namespace svx { namespace sidebar {
  54
  55 const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERX = 50;
  56 const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERY = 50;
  57 const sal_Int32 AreaPropertyPanel::DEFAULT_ANGLE = 0;
  58 const sal_Int32 AreaPropertyPanel::DEFAULT_STARTVALUE = 0;
  59 const sal_Int32 AreaPropertyPanel::DEFAULT_ENDVALUE = 16777215;
  60 const sal_Int32 AreaPropertyPanel::DEFAULT_BORDER = 0;
  61
  62
  63 AreaPropertyPanel::AreaPropertyPanel(
  64     Window* pParent,
  65     const cssu::Reference<css::frame::XFrame>& rxFrame,
  66     SfxBindings* pBindings)
  67     : Control(pParent, SVX_RES(RID_SIDEBAR_AREA_PANEL)),
  68       meLastXFS(-1),
  69       maLastColor(Color(COL_DEFAULT_SHAPE_FILLING)),
  70       mnLastPosGradient(0),
  71       mnLastPosHatch(0),
  72       mnLastPosBitmap(0),
  73       mnLastTransSolid(50),
  74       maGradientLinear(),
  75       maGradientAxial(),
  76       maGradientRadial(),
  77       maGradientElliptical(),
  78       maGradientSquare(),
  79       maGradientRect(),
  80       mpColorTextFT(new FixedText(this, SVX_RES(FT_COLOR_LIST))),
  81       mpLbFillType(new SvxFillTypeBox(this)),
  82       mpLbFillAttr(new SvxFillAttrBox(this)),
  83       mpToolBoxColorBackground(sfx2::sidebar::ControlFactory::CreateToolBoxBackground(this)),
  84       mpToolBoxColor(sfx2::sidebar::ControlFactory::CreateToolBox(mpToolBoxColorBackground.get(), SVX_RES(TB_COLOR))),
  85       mpTrspTextFT(new FixedText(this, SVX_RES(FL_TRSP_TEXT))),
  86       mpLBTransType(new ListBox(this, SVX_RES(LB_TRGR_TYPES))),
  87       mpMTRTransparent(new MetricField(this, SVX_RES(MTR_TRANSPARENT))),
  88       mpBTNGradientBackground(sfx2::sidebar::ControlFactory::CreateToolBoxBackground(this)),
  89       mpBTNGradient(sfx2::sidebar::ControlFactory::CreateToolBox(mpBTNGradientBackground.get(), SVX_RES(BTN_GRADIENT))),
  90       mpColorUpdater(new ::svx::ToolboxButtonColorUpdater(SID_ATTR_FILL_COLOR, TBI_COLOR, mpToolBoxColor.get(), TBX_UPDATER_MODE_CHAR_COLOR_NEW)),
  91       mpStyleItem(),
  92       mpColorItem(),
  93       mpFillGradientItem(),
  94       mpHatchItem(),
  95       mpBitmapItem(),
  96       maStyleControl(SID_ATTR_FILL_STYLE, *pBindings, *this),
  97       maColorControl(SID_ATTR_FILL_COLOR, *pBindings, *this),
  98       maGradientControl(SID_ATTR_FILL_GRADIENT, *pBindings, *this),
  99       maHatchControl(SID_ATTR_FILL_HATCH, *pBindings, *this),
 100       maBitmapControl(SID_ATTR_FILL_BITMAP, *pBindings, *this),
 101       maColorTableControl(SID_COLOR_TABLE, *pBindings, *this),
 102       maGradientListControl(SID_GRADIENT_LIST, *pBindings, *this),
 103       maHatchListControl(SID_HATCH_LIST, *pBindings, *this),
 104       maBitmapListControl(SID_BITMAP_LIST, *pBindings, *this),
 105       maFillTransparenceController(SID_ATTR_FILL_TRANSPARENCE, *pBindings, *this),
 106       maFillFloatTransparenceController(SID_ATTR_FILL_FLOATTRANSPARENCE, *pBindings, *this),
 107       maImgAxial(SVX_RES(IMG_AXIAL)),
 108       maImgElli(SVX_RES(IMG_ELLI)),
 109       maImgQuad(SVX_RES(IMG_QUAD)),
 110       maImgRadial(SVX_RES(IMG_RADIAL)),
 111       maImgSquare(SVX_RES(IMG_SQUARE)),
 112       maImgLinear(SVX_RES(IMG_LINEAR)),
 113       maImgColor(SVX_RES(IMG_COLOR)),
 114       msHelpFillType(SVX_RES(STR_HELP_TYPE)),
 115       msHelpFillAttr(SVX_RES(STR_HELP_ATTR)),
 116       maTrGrPopup(this, ::boost::bind(&AreaPropertyPanel::CreateTransparencyGradientControl, this, _1)),
 117       maColorPopup(this, ::boost::bind(&AreaPropertyPanel::CreateColorPopupControl, this, _1)),
 118       mpFloatTransparenceItem(),
 119       mpTransparanceItem(),
 120       mxFrame(rxFrame),
 121       mpBindings(pBindings),
 122       mbColorAvail(true)
 123 {
 124     Initialize();
 125     FreeResource();
 126 }
 127
 128
 129
 130 AreaPropertyPanel::~AreaPropertyPanel()
 131 {
 132     // Destroy the toolboxes, then their background windows.
 133     mpToolBoxColor.reset();
 134     mpBTNGradient.reset();
 135     mpToolBoxColorBackground.reset();
 136     mpBTNGradientBackground.reset();
 137 }
 138
 139
 140
 141 void AreaPropertyPanel::Initialize()
 142 {
 143     mpColorTextFT->SetBackground(Wallpaper());
 144     mpTrspTextFT->SetBackground(Wallpaper());
 145
 146     maGradientLinear.SetXOffset(DEFAULT_CENTERX);
 147     maGradientLinear.SetYOffset(DEFAULT_CENTERY);
 148     maGradientLinear.SetAngle(DEFAULT_ANGLE);
 149     maGradientLinear.SetStartColor(Color(DEFAULT_STARTVALUE));
 150     maGradientLinear.SetEndColor(Color(DEFAULT_ENDVALUE));
 151     maGradientLinear.SetBorder(DEFAULT_BORDER);
 152     maGradientLinear.SetGradientStyle(XGRAD_LINEAR);
 153
 154     maGradientAxial = maGradientLinear;
 155     maGradientAxial.SetGradientStyle(XGRAD_AXIAL);
 156
 157     maGradientRadial = maGradientLinear;
 158     maGradientRadial.SetGradientStyle(XGRAD_RADIAL);
 159
 160     maGradientElliptical = maGradientLinear;
 161     maGradientElliptical.SetGradientStyle(XGRAD_ELLIPTICAL);
 162
 163     maGradientSquare = maGradientLinear;
 164     maGradientSquare.SetGradientStyle(XGRAD_SQUARE);
 165
 166     maGradientRect = maGradientLinear;
 167     maGradientRect.SetGradientStyle(XGRAD_RECT);
 168
 169     Size aLogicalFillSize(MBOX_WIDTH,LISTBOX_HEIGHT);
 170     Size aLogicalAttrSize(MBOX_WIDTH + 1,LISTBOX_HEIGHT);
 171
 172     Point aPoint(SECTIONPAGE_MARGIN_HORIZONTAL,SECTIONPAGE_MARGIN_VERTICAL_TOP + FIXED_TEXT_HEIGHT + TEXT_CONTROL_SPACING_VERTICAL);
 173     Point aPoint_Picker(SECTIONPAGE_MARGIN_HORIZONTAL + MBOX_WIDTH + CONTROL_SPACING_HORIZONTAL,SECTIONPAGE_MARGIN_VERTICAL_TOP + FIXED_TEXT_HEIGHT + TEXT_CONTROL_SPACING_VERTICAL);
 174
 175     Size aTypeSize(LogicToPixel(aLogicalFillSize, MAP_APPFONT));
 176     Size aAttrSize(LogicToPixel(aLogicalAttrSize, MAP_APPFONT));
 177
 178     Point aTypePoint(LogicToPixel(aPoint, MAP_APPFONT));
 179     Point aAttrPoint(LogicToPixel(aPoint_Picker, MAP_APPFONT));
 180
 181     mpLbFillType->SetPosSizePixel(aTypePoint,aTypeSize);
 182     mpLbFillAttr->SetPosSizePixel(aAttrPoint,aAttrSize);
 183
 184     mpLbFillType->SetHelpId(HID_PPROPERTYPANEL_AREA_LB_FILL_TYPES);
 185     mpLbFillAttr->SetHelpId(HID_PPROPERTYPANEL_AREA_LB_FILL_ATTR);
 186
 187     mpLbFillType->SetQuickHelpText(msHelpFillType);
 188     mpLbFillAttr->SetQuickHelpText(msHelpFillAttr);
 189
 190     mpLbFillType->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Fill")));    //wj acc
 191     mpLbFillAttr->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Fill")));    //wj acc
 192
 193     Link aLink = LINK( this, AreaPropertyPanel, SelectFillTypeHdl );
 194     mpLbFillType->SetSelectHdl( aLink );
 195
 196     aLink = LINK( this, AreaPropertyPanel, SelectFillAttrHdl );
 197     mpLbFillAttr->SetSelectHdl( aLink );
 198
 199     //add  for new color picker
 200     mpLbFillAttr->Hide();
 201     mpToolBoxColor->SetItemImage(TBI_COLOR, maImgColor);
 202     Size aTbxSize( mpToolBoxColor->CalcWindowSizePixel() );
 203     mpToolBoxColor->SetOutputSizePixel( aTbxSize );
 204     mpToolBoxColor->SetItemBits( TBI_COLOR, mpToolBoxColor->GetItemBits( TBI_COLOR ) | TIB_DROPDOWNONLY );
 205     mpToolBoxColor->SetBackground(Wallpaper());
 206     mpToolBoxColor->SetPaintTransparent(true);
 207     mpToolBoxColor->SetQuickHelpText(TBI_COLOR, String(SVX_RES(STR_HELP_COLOR)));    //wj acc
 208     //mpToolBoxColor->SetItemText(TBI_COLOR, msHelpFillAttr);
 209
 210     long aHeightLBStyle = mpLbFillType->GetSizePixel().getHeight();
 211     long aLBPosY = mpLbFillType->GetPosPixel().getY();
 212     long aHeightTBAttr = mpToolBoxColor->GetSizePixel().getHeight();
 213     Point aPointTBAttr = mpToolBoxColor->GetPosPixel();
 214     aPointTBAttr.setY( aLBPosY + aHeightLBStyle / 2 - aHeightTBAttr / 2);
 215     mpToolBoxColor->SetPosPixel(aPointTBAttr);
 216
 217     aLink = LINK(this, AreaPropertyPanel, ToolBoxColorDropHdl);
 218     mpToolBoxColor->SetDropdownClickHdl ( aLink );
 219     mpToolBoxColor->SetSelectHdl ( aLink );
 220
 221     //add end
 222     mpLBTransType->SetSelectHdl(LINK(this, AreaPropertyPanel, ChangeTrgrTypeHdl_Impl));
 223     mpLBTransType->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Transparency")));    //wj acc
 224
 225     mpMTRTransparent->SetValue( 50 );
 226     mpMTRTransparent->SetModifyHdl(LINK(this, AreaPropertyPanel, ModifyTransparentHdl_Impl));
 227     mpMTRTransparent->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Transparency")));    //wj acc
 228
 229     mpBTNGradient->SetItemBits( TBI_BTX_GRADIENT, mpBTNGradient->GetItemBits( TBI_BTX_GRADIENT ) | TIB_DROPDOWNONLY );
 230     aLink = LINK( this, AreaPropertyPanel, ClickTrGrHdl_Impl );
 231     mpBTNGradient->SetDropdownClickHdl( aLink );
 232     mpBTNGradient->SetSelectHdl( aLink );
 233     aTbxSize = mpBTNGradient->CalcWindowSizePixel();
 234     mpBTNGradient->SetOutputSizePixel( aTbxSize );
 235     mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,maImgLinear);
 236     mpBTNGradient->SetQuickHelpText(TBI_BTX_GRADIENT, String(SVX_RES(STR_HELP_GRADIENT)));    //wj acc
 237     mpBTNGradient->Hide();
 238
 239     long aHeightLBTrans = mpLBTransType->GetSizePixel().getHeight();
 240     Point aPointLB = mpLBTransType->GetPosPixel();
 241     long aPosY = aPointLB.getY();
 242
 243     Point aPointMetric = mpMTRTransparent->GetPosPixel();
 244     Point aPointTB = mpMTRTransparent->GetPosPixel();
 245     long aHeightMetric = mpMTRTransparent->GetSizePixel().getHeight();
 246     long aHeightTool = mpBTNGradient->GetSizePixel().getHeight();
 247     aPointMetric.setY(aPosY+aHeightLBTrans/2-aHeightMetric/2);
 248     aPointTB.setY(aPosY+aHeightLBTrans/2-aHeightTool/2);
 249     aPointTB.setX(aPointTB.getX()+3);
 250     mpMTRTransparent->SetPosPixel(aPointMetric);
 251     mpBTNGradient->SetPosPixel(aPointTB);
 252
 253     mpLbFillType->SetAccessibleRelationLabeledBy(mpColorTextFT.get());
 254     mpLbFillAttr->SetAccessibleRelationLabeledBy(mpLbFillAttr.get());
 255     mpToolBoxColor->SetAccessibleRelationLabeledBy(mpToolBoxColor.get());
 256     mpLBTransType->SetAccessibleRelationLabeledBy(mpTrspTextFT.get());
 257     mpMTRTransparent->SetAccessibleRelationLabeledBy(mpMTRTransparent.get());
 258     mpBTNGradient->SetAccessibleRelationLabeledBy(mpBTNGradient.get());
 259
 260     SetupIcons();
 261 }
 262
 263
 264
 265 IMPL_LINK( AreaPropertyPanel, SelectFillTypeHdl, ListBox *, pToolBox )
 266 {
 267     const XFillStyle eXFS = (XFillStyle)mpLbFillType->GetSelectEntryPos();
 268
 269     if((XFillStyle)meLastXFS != eXFS)
 270     {
 271         mpLbFillAttr->Clear();
 272         SfxObjectShell* pSh = SfxObjectShell::Current();
 273         const XFillStyleItem aXFillStyleItem(eXFS);
 274         GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_STYLE, SFX_CALLMODE_RECORD, &aXFillStyleItem, 0L);
 275
 276         switch( eXFS )
 277         {
 278             case XFILL_NONE:
 279             {
 280                 mpLbFillAttr->Show();
 281                 mpToolBoxColor->Hide();
 282                 mpLbFillType->Selected();
 283                 mpLbFillAttr->Disable();
 284                 break;
 285             }
 286             case XFILL_SOLID:
 287             {
 288                 mpLbFillAttr->Hide();
 289                 mpToolBoxColor->Show();
 290                 const String aTmpStr;
 291                 const Color aColor = maLastColor;
 292                 const XFillColorItem aXFillColorItem( aTmpStr, aColor );
 293                 GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_COLOR, SFX_CALLMODE_RECORD, &aXFillColorItem, 0L);
 294                 break;
 295             }
 296             case XFILL_GRADIENT:
 297             {
 298                 mpLbFillAttr->Show();
 299                 mpToolBoxColor->Hide();
 300
 301                 if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
 302                 {
 303                     if(!mpLbFillAttr->GetEntryCount())
 304                     {
 305                         const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST)));
 306                         mpLbFillAttr->Enable();
 307                         mpLbFillAttr->Clear();
 308                         mpLbFillAttr->Fill(aItem.GetGradientList());
 309                     }
 310
 311                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 312
 313                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosGradient)
 314                     {
 315                         const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST)));
 316
 317                         if(mnLastPosGradient < aItem.GetGradientList()->Count())
 318                         {
 319                             const XGradient aGradient = aItem.GetGradientList()->GetGradient(mnLastPosGradient)->GetGradient();
 320                             const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetEntry(mnLastPosGradient), aGradient);
 321                             GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_GRADIENT, SFX_CALLMODE_RECORD, &aXFillGradientItem, 0L);
 322                             mpLbFillAttr->SelectEntryPos(mnLastPosGradient);
 323                         }
 324                     }
 325                 }
 326                 else
 327                 {
 328                     mpLbFillAttr->Disable();
 329                 }
 330                 break;
 331             }
 332             case XFILL_HATCH:
 333             {
 334                 mpLbFillAttr->Show();
 335                 mpToolBoxColor->Hide();
 336
 337                 if(pSh && pSh->GetItem(SID_HATCH_LIST))
 338                 {
 339                     if(!mpLbFillAttr->GetEntryCount())
 340                     {
 341                         const SvxHatchListItem aItem( *(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST)));
 342                         mpLbFillAttr->Enable();
 343                         mpLbFillAttr->Clear();
 344                         mpLbFillAttr->Fill(aItem.GetHatchList());
 345                     }
 346
 347                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 348
 349                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosHatch)
 350                     {
 351                         const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST)));
 352
 353                         if(mnLastPosHatch < aItem.GetHatchList()->Count())
 354                         {
 355                             const XHatch aHatch = aItem.GetHatchList()->GetHatch(mnLastPosHatch)->GetHatch();
 356                             const XFillHatchItem aXFillHatchItem(mpLbFillAttr->GetSelectEntry(), aHatch);
 357                             GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_HATCH, SFX_CALLMODE_RECORD, &aXFillHatchItem, 0L);
 358                             mpLbFillAttr->SelectEntryPos(mnLastPosHatch);
 359                         }
 360                     }
 361                 }
 362                 else
 363                 {
 364                     mpLbFillAttr->Disable();
 365                 }
 366                 break;
 367             }
 368             case XFILL_BITMAP:
 369             {
 370                 mpLbFillAttr->Show();
 371                 mpToolBoxColor->Hide();
 372
 373                 if(pSh && pSh->GetItem(SID_BITMAP_LIST))
 374                 {
 375                     if(!mpLbFillAttr->GetEntryCount())
 376                     {
 377                         const SvxBitmapListItem aItem( *(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST)));
 378                         mpLbFillAttr->Enable();
 379                         mpLbFillAttr->Clear();
 380                         mpLbFillAttr->Fill(aItem.GetBitmapList());
 381                     }
 382
 383                     mpLbFillAttr->AdaptDropDownLineCountToMaximum();
 384
 385                     if(LISTBOX_ENTRY_NOTFOUND != mnLastPosBitmap)
 386                     {
 387                         const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST)));
 388
 389                         if(mnLastPosBitmap < aItem.GetBitmapList()->Count())
 390                         {
 391                             const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(mnLastPosBitmap);
 392                             const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject());
 393                             GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_BITMAP, SFX_CALLMODE_RECORD, &aXFillBitmapItem, 0L);
 394                             mpLbFillAttr->SelectEntryPos(mnLastPosBitmap);
 395                         }
 396                     }
 397                 }
 398                 else
 399                 {
 400                     mpLbFillAttr->Disable();
 401                 }
 402                 break;
 403             }
 404         }
 405
 406         meLastXFS = (sal_uInt16)eXFS;
 407
 408         if(XFILL_NONE != eXFS)
 409         {
 410             if(pToolBox)
 411             {
 412                 mpLbFillType->Selected();
 413             }
 414         }
 415     }
 416
 417     return 0;
 418 }
 419
 420
 421
 422 IMPL_LINK( AreaPropertyPanel, SelectFillAttrHdl, ListBox*, pToolBox )
 423 {
 424     const XFillStyle eXFS = (XFillStyle)mpLbFillType->GetSelectEntryPos();
 425     const XFillStyleItem aXFillStyleItem(eXFS);
 426     SfxObjectShell* pSh = SfxObjectShell::Current();
 427
 428     if(pToolBox)
 429     {
 430         if((XFillStyle) meLastXFS != eXFS)
 431         {
 432             GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_STYLE, SFX_CALLMODE_RECORD, &aXFillStyleItem, 0L);
 433         }
 434
 435         switch(eXFS)
 436         {
 437             case XFILL_SOLID:
 438             //{
 439             //  //String aTmpStr = mpLbFillAttr->GetSelectEntry();
 440             //  //Color aColor = mpLbFillAttr->GetSelectEntryColor();
 441             //  //if(aColor.GetColor() == 0 && aTmpStr.Equals(String::CreateFromAscii("")))
 442             //  String aTmpStr;
 443             //  Color aColor = maLastColor;
 444             //  XFillColorItem aXFillColorItem( aTmpStr, aColor );
 445             //  GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_COLOR, SFX_CALLMODE_RECORD, &aXFillColorItem, 0L);
 446             //  maLastColor = aColor;
 447             //}
 448             break;
 449
 450             case XFILL_GRADIENT:
 451             {
 452                 sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos();
 453
 454                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 455                 {
 456                     nPos = mnLastPosGradient;
 457                 }
 458
 459                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_GRADIENT_LIST))
 460                 {
 461                     const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST)));
 462
 463                     if(nPos < aItem.GetGradientList()->Count())
 464                     {
 465                         const XGradient aGradient = aItem.GetGradientList()->GetGradient(nPos)->GetGradient();
 466                         const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetSelectEntry(), aGradient);
 467                         GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_GRADIENT, SFX_CALLMODE_RECORD, &aXFillGradientItem, 0L);
 468                     }
 469                 }
 470
 471                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 472                 {
 473                     mnLastPosGradient = nPos;
 474                 }
 475                 break;
 476             }
 477             case XFILL_HATCH:
 478             {
 479                 sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos();
 480
 481                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 482                 {
 483                     nPos = mnLastPosHatch;
 484                 }
 485
 486                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_HATCH_LIST))
 487                 {
 488                     const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST)));
 489
 490                     if(nPos < aItem.GetHatchList()->Count())
 491                     {
 492                         const XHatch aHatch = aItem.GetHatchList()->GetHatch(nPos)->GetHatch();
 493                         const XFillHatchItem aXFillHatchItem( mpLbFillAttr->GetSelectEntry(), aHatch);
 494                         GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_HATCH, SFX_CALLMODE_RECORD, &aXFillHatchItem, 0L);
 495                     }
 496                 }
 497
 498                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 499                 {
 500                     mnLastPosHatch = nPos;
 501                 }
 502                 break;
 503             }
 504             case XFILL_BITMAP:
 505             {
 506                 sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos();
 507
 508                 if(LISTBOX_ENTRY_NOTFOUND == nPos)
 509                 {
 510                     nPos = mnLastPosBitmap;
 511                 }
 512
 513                 if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_BITMAP_LIST))
 514                 {
 515                     const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST)));
 516
 517                     if(nPos < aItem.GetBitmapList()->Count())
 518                     {
 519                         const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(nPos);
 520                         const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject());
 521                         GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_BITMAP, SFX_CALLMODE_RECORD, &aXFillBitmapItem, 0L);
 522                     }
 523                 }
 524
 525                 if(LISTBOX_ENTRY_NOTFOUND != nPos)
 526                 {
 527                     mnLastPosBitmap = nPos;
 528                 }
 529                 break;
 530             }
 531             default: break;
 532         }
 533     }
 534
 535     return 0;
 536 }
 537
 538
 539 IMPL_LINK(AreaPropertyPanel, ToolBoxColorDropHdl, ToolBox*, pToolBox)
 540 {
 541     const sal_uInt16 nId = pToolBox->GetCurItemId();
 542
 543     if(TBI_COLOR == nId)
 544     {
 545         maColorPopup.Show(*pToolBox);
 546
 547         if (mpColorItem)
 548         {
 549             maColorPopup.SetCurrentColor(mpColorItem->GetColorValue(), mbColorAvail);
 550         }
 551         else
 552         {
 553             maColorPopup.SetCurrentColor(COL_WHITE, false);
 554         }
 555     }
 556
 557     return 0;
 558 }
 559
 560
 561
 562 void AreaPropertyPanel::SetColor (
 563     const String& rsColorName,
 564     const Color aColor)
 565 {
 566     const XFillColorItem aXFillColorItem(rsColorName, aColor);
 567     mpBindings->GetDispatcher()->Execute(SID_ATTR_FILL_COLOR, SFX_CALLMODE_RECORD, &aXFillColorItem, 0L);
 568     maLastColor = aColor;
 569 }
 570
 571
 572
 573
 574 PopupControl* AreaPropertyPanel::CreateTransparencyGradientControl (PopupContainer* pParent)
 575 {
 576     return new AreaTransparencyGradientControl(pParent, *this);
 577 }
 578
 579
 580
 581
 582 PopupControl* AreaPropertyPanel::CreateColorPopupControl (PopupContainer* pParent)
 583 {
 584     return new ColorControl(
 585         pParent,
 586         mpBindings,
 587         SVX_RES(RID_POPUPPANEL_AERAPAGE_COLOR),
 588         SVX_RES(VS_COLOR),
 589         ::boost::bind(&AreaPropertyPanel::GetLastColor, this),
 590         ::boost::bind(&AreaPropertyPanel::SetColor, this, _1,_2),
 591         pParent,
 592         0);
 593 }
 594
 595
 596
 597
 598 void AreaPropertyPanel::SetupIcons(void)
 599 {
 600     if(Theme::GetBoolean(Theme::Bool_UseSymphonyIcons))
 601     {
 602         // todo
 603     }
 604     else
 605     {
 606         // todo
 607     }
 608 }
 609
 610
 611
 612 AreaPropertyPanel* AreaPropertyPanel::Create (
 613     Window* pParent,
 614     const cssu::Reference<css::frame::XFrame>& rxFrame,
 615     SfxBindings* pBindings)
 616 {
 617     if (pParent == NULL)
 618         throw lang::IllegalArgumentException(A2S("no parent Window given to AreaPropertyPanel::Create"), NULL, 0);
 619     if ( ! rxFrame.is())
 620         throw lang::IllegalArgumentException(A2S("no XFrame given to AreaPropertyPanel::Create"), NULL, 1);
 621     if (pBindings == NULL)
 622         throw lang::IllegalArgumentException(A2S("no SfxBindings given to AreaPropertyPanel::Create"), NULL, 2);
 623
 624     return new AreaPropertyPanel(
 625         pParent,
 626         rxFrame,
 627         pBindings);
 628 }
 629
 630
 631
 632 void AreaPropertyPanel::DataChanged(
 633     const DataChangedEvent& rEvent)
 634 {
 635     (void)rEvent;
 636
 637     SetupIcons();
 638 }
 639
 640
 641
 642 void AreaPropertyPanel::ImpUpdateTransparencies()
 643 {
 644     if(mpTransparanceItem.get() && mpFloatTransparenceItem.get())
 645     {
 646         bool bZeroValue(false);
 647
 648         if(mpTransparanceItem.get())
 649         {
 650             const sal_uInt16 nValue(mpTransparanceItem->GetValue());
 651
 652             if(!nValue)
 653             {
 654                 bZeroValue = true;
 655             }
 656             else if(nValue <= 100)
 657             {
 658                 mpLBTransType->Enable();
 659                 mpTrspTextFT->Enable();
 660                 mpLBTransType->SelectEntryPos(1);
 661                 mpBTNGradient->Hide();
 662                 mpMTRTransparent->Show();
 663                 mpMTRTransparent->Enable();
 664                 mpMTRTransparent->SetValue(nValue);
 665             }
 666
 667             if(!bZeroValue)
 668             {
 669                 maTrGrPopup.Hide();
 670             }
 671         }
 672
 673         if(bZeroValue && mpFloatTransparenceItem.get())
 674         {
 675             if(mpFloatTransparenceItem->IsEnabled())
 676             {
 677                 const XGradient& rGradient = mpFloatTransparenceItem->GetGradientValue();
 678                 sal_uInt16 nEntryPos(0);
 679                 Image* pImage = 0;
 680
 681                 mpLBTransType->Enable();
 682                 mpTrspTextFT->Enable();
 683                 mpMTRTransparent->Hide();
 684                 mpBTNGradient->Enable();
 685                 mpBTNGradient->Show();
 686
 687                 switch(rGradient.GetGradientStyle())
 688                 {
 689                     case XGRAD_LINEAR:
 690                     {
 691                         nEntryPos = 2;
 692                         pImage = &maImgLinear;
 693                         break;
 694                     }
 695                     case XGRAD_AXIAL:
 696                     {
 697                         nEntryPos = 3;
 698                         pImage = &maImgAxial;
 699                         break;
 700                     }
 701                     case XGRAD_RADIAL:
 702                     {
 703                         nEntryPos = 4;
 704                         pImage = &maImgRadial;
 705                         break;
 706                     }
 707                     case XGRAD_ELLIPTICAL:
 708                     {
 709                         nEntryPos = 5;
 710                         pImage = &maImgElli;
 711                         break;
 712                     }
 713                     case XGRAD_SQUARE:
 714                     {
 715                         nEntryPos = 6;
 716                         pImage = &maImgQuad;
 717                         break;
 718                     }
 719                     case XGRAD_RECT:
 720                     {
 721                         nEntryPos = 7;
 722                         pImage = &maImgSquare;
 723                         break;
 724                     }
 725                 }
 726
 727                 mpLBTransType->SelectEntryPos(nEntryPos);
 728                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, *pImage);
 729                 bZeroValue = false;
 730             }
 731             else
 732             {
 733                 bZeroValue = true;
 734             }
 735         }
 736
 737         if(bZeroValue)
 738         {
 739             mpLBTransType->Enable();
 740             mpTrspTextFT->Enable();
 741             mpLBTransType->SelectEntryPos(0);
 742             mpBTNGradient->Hide();
 743             mpMTRTransparent->Enable();
 744             mpMTRTransparent->Show();
 745             mpMTRTransparent->SetValue(0);
 746         }
 747     }
 748     else
 749     {
 750         // no transparency at all
 751         mpLBTransType->SetNoSelection();
 752         mpLBTransType->Disable();
 753         mpTrspTextFT->Disable();
 754         mpMTRTransparent->Disable();
 755         mpMTRTransparent->Show();
 756         mpBTNGradient->Disable();
 757         mpBTNGradient->Hide();
 758     }
 759 }
 760
 761
 762
 763 void AreaPropertyPanel::NotifyItemUpdate(
 764     sal_uInt16 nSID,
 765     SfxItemState eState,
 766     const SfxPoolItem* pState,
 767     const bool bIsEnabled)
 768 {
 769     (void)bIsEnabled;
 770     const bool bDisabled(SFX_ITEM_DISABLED == eState);
 771
 772     switch(nSID)
 773     {
 774         case SID_ATTR_FILL_TRANSPARENCE:
 775         case SID_ATTR_FILL_FLOATTRANSPARENCE:
 776         {
 777             bool bFillTransparenceChanged(false);
 778
 779             if(SID_ATTR_FILL_TRANSPARENCE == nSID)
 780             {
 781                 bFillTransparenceChanged = true;
 782
 783                 if(eState >= SFX_ITEM_AVAILABLE)
 784                 {
 785                     const SfxUInt16Item* pItem = dynamic_cast< const SfxUInt16Item* >(pState);
 786
 787                     if(pItem && (!mpTransparanceItem || *pItem != *mpTransparanceItem))
 788                     {
 789                         mpTransparanceItem.reset((SfxUInt16Item*)pItem->Clone());
 790                     }
 791                     else
 792                     {
 793                         mpTransparanceItem.reset();
 794                     }
 795                 }
 796                 else
 797                 {
 798                     mpTransparanceItem.reset();
 799                 }
 800             }
 801             else // if(SID_ATTR_FILL_FLOATTRANSPARENCE == nSID)
 802             {
 803                 bFillTransparenceChanged = true;
 804
 805                 if(eState >= SFX_ITEM_AVAILABLE)
 806                 {
 807                     const XFillFloatTransparenceItem* pItem = dynamic_cast< const XFillFloatTransparenceItem* >(pState);
 808
 809                     if(pItem && (!mpFloatTransparenceItem || *pItem != *mpFloatTransparenceItem))
 810                     {
 811                         mpFloatTransparenceItem.reset((XFillFloatTransparenceItem*)pItem->Clone());
 812                     }
 813                     else
 814                     {
 815                         mpFloatTransparenceItem.reset();
 816                     }
 817                 }
 818                 else
 819                 {
 820                     mpFloatTransparenceItem.reset();
 821                 }
 822             }
 823
 824             if(bFillTransparenceChanged)
 825             {
 826                 // update transparency settings dependent of mpTransparanceItem and mpFloatTransparenceItem
 827                 ImpUpdateTransparencies();
 828             }
 829             break;
 830         }
 831         case SID_ATTR_FILL_STYLE:
 832         {
 833             if(bDisabled)
 834             {
 835                 mpLbFillType->Disable();
 836                 mpColorTextFT->Disable();
 837                 mpLbFillType->SetNoSelection();
 838                 mpLbFillAttr->Show();
 839                 mpLbFillAttr->Disable();
 840                 mpLbFillAttr->SetNoSelection();
 841                 mpToolBoxColor->Hide();
 842                 meLastXFS = -1;
 843                 mpStyleItem.reset();
 844             }
 845
 846             if(eState >= SFX_ITEM_AVAILABLE)
 847             {
 848                 const XFillStyleItem* pItem = dynamic_cast< const XFillStyleItem* >(pState);
 849
 850                 if(pItem)
 851                 {
 852                     mpStyleItem.reset(dynamic_cast< XFillStyleItem* >(pItem->Clone()));
 853                     mpLbFillType->Enable();
 854                     mpColorTextFT->Enable();
 855                     XFillStyle eXFS = (XFillStyle)mpStyleItem->GetValue();
 856                     meLastXFS = eXFS;
 857                     mpLbFillType->SelectEntryPos(sal::static_int_cast< sal_uInt16 >(eXFS));
 858
 859                     if(XFILL_NONE == eXFS)
 860                     {
 861                         mpLbFillAttr->SetNoSelection();
 862                         mpLbFillAttr->Disable();
 863                     }
 864
 865                     Update();
 866                     break;
 867                 }
 868             }
 869
 870             mpLbFillType->SetNoSelection();
 871             mpLbFillAttr->Show();
 872             mpLbFillAttr->Disable();
 873             mpLbFillAttr->SetNoSelection();
 874             mpToolBoxColor->Hide();
 875             meLastXFS = -1;
 876             mpStyleItem.reset();
 877             break;
 878         }
 879         case SID_ATTR_FILL_COLOR:
 880         {
 881             if(SFX_ITEM_AVAILABLE == eState)
 882             {
 883                 mpColorItem.reset(pState ? (XFillColorItem*)pState->Clone() : 0);
 884             }
 885
 886             if(mpStyleItem && XFILL_SOLID == (XFillStyle)mpStyleItem->GetValue())
 887             {
 888                 mpLbFillAttr->Hide();
 889                 mpToolBoxColor->Show();
 890
 891                 if(SFX_ITEM_AVAILABLE == eState)
 892                 {
 893                     mpToolBoxColor->Enable();
 894                     mbColorAvail = true;
 895                     // maLastColor = mpColorItem->GetColorValue();
 896                     Update();
 897                 }
 898                 else if(SFX_ITEM_DISABLED == eState)
 899                 {
 900                     mpToolBoxColor->Disable();
 901                     mbColorAvail = false;
 902                     mpColorUpdater->Update(COL_WHITE);
 903                 }
 904                 else
 905                 {
 906                     mbColorAvail = false;
 907                     mpColorUpdater->Update(COL_WHITE);
 908                 }
 909             }
 910             break;
 911         }
 912         case SID_ATTR_FILL_GRADIENT:
 913         {
 914             if(SFX_ITEM_AVAILABLE == eState)
 915             {
 916                 mpFillGradientItem.reset(pState ? (XFillGradientItem*)pState->Clone() : 0);
 917             }
 918
 919             if(mpStyleItem && XFILL_GRADIENT == (XFillStyle)mpStyleItem->GetValue())
 920             {
 921                 mpLbFillAttr->Show();
 922                 mpToolBoxColor->Hide();
 923
 924                 if(SFX_ITEM_AVAILABLE == eState)
 925                 {
 926                     mpLbFillAttr->Enable();
 927                     Update();
 928                 }
 929                 else if(SFX_ITEM_DISABLED == eState )
 930                 {
 931                     mpLbFillAttr->Disable();
 932                     mpLbFillAttr->SetNoSelection();
 933                 }
 934                 else
 935                 {
 936                     mpLbFillAttr->SetNoSelection();
 937                 }
 938             }
 939             break;
 940         }
 941         case SID_ATTR_FILL_HATCH:
 942         {
 943             if(SFX_ITEM_AVAILABLE == eState)
 944             {
 945                 mpHatchItem.reset(pState ? (XFillHatchItem*)pState->Clone() : 0);
 946             }
 947
 948             if(mpStyleItem && XFILL_HATCH == (XFillStyle)mpStyleItem->GetValue())
 949             {
 950                 mpLbFillAttr->Show();
 951                 mpToolBoxColor->Hide();
 952
 953                 if(SFX_ITEM_AVAILABLE == eState)
 954                 {
 955                     mpLbFillAttr->Enable();
 956                     Update();
 957                 }
 958                 else if(SFX_ITEM_DISABLED == eState )
 959                 {
 960                     mpLbFillAttr->Disable();
 961                     mpLbFillAttr->SetNoSelection();
 962                 }
 963                 else
 964                 {
 965                     mpLbFillAttr->SetNoSelection();
 966                 }
 967             }
 968             break;
 969         }
 970         case SID_ATTR_FILL_BITMAP:
 971         {
 972             if(SFX_ITEM_AVAILABLE == eState)
 973             {
 974                 mpBitmapItem.reset(pState ? (XFillBitmapItem*)pState->Clone() : 0);
 975             }
 976
 977             if(mpStyleItem && XFILL_BITMAP == (XFillStyle)mpStyleItem->GetValue())
 978             {
 979                 mpLbFillAttr->Show();
 980                 mpToolBoxColor->Hide();
 981
 982                 if(SFX_ITEM_AVAILABLE == eState)
 983                 {
 984                     mpLbFillAttr->Enable();
 985                     Update();
 986                 }
 987                 else if(SFX_ITEM_DISABLED == eState )
 988                 {
 989                     mpLbFillAttr->Disable();
 990                     mpLbFillAttr->SetNoSelection();
 991                 }
 992                 else
 993                 {
 994                     mpLbFillAttr->SetNoSelection();
 995                 }
 996             }
 997             break;
 998         }
 999         case SID_COLOR_TABLE:
1000         {
1001             if(SFX_ITEM_AVAILABLE == eState)
1002             {
1003                 if(mpStyleItem && XFILL_SOLID == (XFillStyle)mpStyleItem->GetValue())
1004                 {
1005                     if(mpColorItem)
1006                     {
1007                         const Color aColor = mpColorItem->GetColorValue();
1008                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1009                         const SvxColorListItem aItem(*(const SvxColorListItem*)(pSh->GetItem(SID_COLOR_TABLE)));
1010
1011                         mpLbFillAttr->Clear();
1012                         mpLbFillAttr->Enable();
1013                         mpLbFillAttr->Fill(aItem.GetColorList());
1014                         mpLbFillAttr->SelectEntry(aColor);
1015                     }
1016                     else
1017                     {
1018                         mpLbFillAttr->SetNoSelection();
1019                     }
1020                 }
1021             }
1022             break;
1023         }
1024         case SID_GRADIENT_LIST:
1025         {
1026             if(SFX_ITEM_AVAILABLE == eState)
1027             {
1028                 if(mpStyleItem && XFILL_GRADIENT == (XFillStyle)mpStyleItem->GetValue())
1029                 {
1030                     if(mpFillGradientItem)
1031                     {
1032                         const String aString( mpFillGradientItem->GetName() );
1033                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1034                         const SvxGradientListItem aItem( *(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST)));
1035
1036                         mpLbFillAttr->Clear();
1037                         mpLbFillAttr->Enable();
1038                         mpLbFillAttr->Fill(aItem.GetGradientList());
1039                         mpLbFillAttr->SelectEntry(aString);
1040                     }
1041                     else
1042                     {
1043                         mpLbFillAttr->SetNoSelection();
1044                     }
1045                 }
1046             }
1047             break;
1048         }
1049         case SID_HATCH_LIST:
1050         {
1051             if(SFX_ITEM_AVAILABLE == eState)
1052             {
1053                 if(mpStyleItem && XFILL_HATCH == (XFillStyle)mpStyleItem->GetValue())
1054                 {
1055                     if(mpHatchItem)
1056                     {
1057                         const String aString( mpHatchItem->GetName() );
1058                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1059                         const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST)));
1060
1061                         mpLbFillAttr->Clear();
1062                         mpLbFillAttr->Enable();
1063                         mpLbFillAttr->Fill(aItem.GetHatchList());
1064                         mpLbFillAttr->SelectEntry(aString);
1065                     }
1066                     else
1067                     {
1068                         mpLbFillAttr->SetNoSelection();
1069                     }
1070                 }
1071             }
1072             break;
1073         }
1074         case SID_BITMAP_LIST:
1075         {
1076             if(SFX_ITEM_AVAILABLE == eState)
1077             {
1078                 if(mpStyleItem && XFILL_BITMAP == (XFillStyle)mpStyleItem->GetValue())
1079                 {
1080                     if(mpBitmapItem)
1081                     {
1082                         const String aString( mpBitmapItem->GetName() );
1083                         const SfxObjectShell* pSh = SfxObjectShell::Current();
1084                         const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST)));
1085
1086                         mpLbFillAttr->Clear();
1087                         mpLbFillAttr->Enable();
1088                         mpLbFillAttr->Fill(aItem.GetBitmapList());
1089                         mpLbFillAttr->SelectEntry(aString);
1090                     }
1091                     else
1092                     {
1093                         mpLbFillAttr->SetNoSelection();
1094                     }
1095                 }
1096             }
1097             break;
1098         }
1099     }
1100 }
1101
1102
1103
1104 SfxBindings* AreaPropertyPanel::GetBindings()
1105 {
1106     return mpBindings;
1107 }
1108
1109
1110
1111 void AreaPropertyPanel::Update()
1112 {
1113     if(mpStyleItem)
1114     {
1115         const XFillStyle eXFS = (XFillStyle)mpStyleItem->GetValue();
1116         SfxObjectShell* pSh = SfxObjectShell::Current();
1117
1118         switch( eXFS )
1119         {
1120             case XFILL_NONE:
1121             {
1122                 mpLbFillAttr->Show();
1123                 mpToolBoxColor->Hide();
1124                 break;
1125             }
1126             case XFILL_SOLID:
1127             {
1128                 if(mpColorItem)
1129                 {
1130                     mpLbFillAttr->Hide();
1131                     mpToolBoxColor->Show();
1132                     mpColorUpdater->Update(mpColorItem->GetColorValue());
1133                 }
1134                 else
1135                 {
1136                     mpColorUpdater->Update(COL_WHITE);
1137                 }
1138                 break;
1139             }
1140             case XFILL_GRADIENT:
1141             {
1142                 mpLbFillAttr->Show();
1143                 mpToolBoxColor->Hide();
1144
1145                 if(pSh && pSh->GetItem(SID_GRADIENT_LIST))
1146                 {
1147                     const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST)));
1148                     mpLbFillAttr->Enable();
1149                     mpLbFillAttr->Clear();
1150                     mpLbFillAttr->Fill(aItem.GetGradientList());
1151
1152                     if(mpFillGradientItem)
1153                     {
1154                         const String aString(mpFillGradientItem->GetName());
1155
1156                         mpLbFillAttr->SelectEntry(aString);
1157                     }
1158                     else
1159                     {
1160                         mpLbFillAttr->SetNoSelection();
1161                     }
1162                 }
1163                 else
1164                 {
1165                     mpLbFillAttr->SetNoSelection();
1166                 }
1167                 break;
1168             }
1169             case XFILL_HATCH:
1170             {
1171                 mpLbFillAttr->Show();
1172                 mpToolBoxColor->Hide();
1173
1174                 if(pSh && pSh->GetItem(SID_HATCH_LIST))
1175                 {
1176                     const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST)));
1177                     mpLbFillAttr->Enable();
1178                     mpLbFillAttr->Clear();
1179                     mpLbFillAttr->Fill(aItem.GetHatchList());
1180
1181                     if(mpHatchItem)
1182                     {
1183                         const String aString(mpHatchItem->GetName());
1184
1185                         mpLbFillAttr->SelectEntry( aString );
1186                     }
1187                     else
1188                     {
1189                         mpLbFillAttr->SetNoSelection();
1190                     }
1191                 }
1192                 else
1193                 {
1194                     mpLbFillAttr->SetNoSelection();
1195                 }
1196                 break;
1197             }
1198             case XFILL_BITMAP:
1199             {
1200                 mpLbFillAttr->Show();
1201                 mpToolBoxColor->Hide();
1202
1203                 if(pSh && pSh->GetItem(SID_BITMAP_LIST))
1204                 {
1205                     const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST)));
1206                     mpLbFillAttr->Enable();
1207                     mpLbFillAttr->Clear();
1208                     mpLbFillAttr->Fill(aItem.GetBitmapList());
1209
1210                     if(mpBitmapItem)
1211                     {
1212                         const String aString(mpBitmapItem->GetName());
1213
1214                         mpLbFillAttr->SelectEntry(aString);
1215                     }
1216                     else
1217                     {
1218                         mpLbFillAttr->SetNoSelection();
1219                     }
1220                 }
1221                 else
1222                 {
1223                     mpLbFillAttr->SetNoSelection();
1224                 }
1225                 break;
1226             }
1227             default:
1228                 OSL_ENSURE(false, "Non supported FillType (!)");
1229             break;
1230         }
1231     }
1232 }
1233
1234
1235
1236 IMPL_LINK( AreaPropertyPanel, ImplPopupModeEndHdl, FloatingWindow*, EMPTYARG )
1237 {
1238     return 0;
1239 }
1240
1241
1242
1243 IMPL_LINK( AreaPropertyPanel, ClickTrGrHdl_Impl, ToolBox*, pToolBox )
1244 {
1245     maTrGrPopup.Rearrange(mpFloatTransparenceItem.get());
1246     OSL_ASSERT(pToolBox->GetCurItemId() == TBI_BTX_GRADIENT);
1247     maTrGrPopup.Show(*pToolBox);
1248
1249     return (0L);
1250 }
1251
1252
1253
1254 IMPL_LINK(AreaPropertyPanel, ChangeTrgrTypeHdl_Impl, void *, EMPTYARG)
1255 {
1256     sal_uInt16 nSelectType = mpLBTransType->GetSelectEntryPos();
1257     bool bGradient = false;
1258     sal_uInt16 nTrans = 0;
1259
1260     if(!nSelectType)
1261     {
1262         mpBTNGradient->Hide();
1263         mpMTRTransparent->Show();
1264         mpMTRTransparent->Enable();
1265         mpMTRTransparent->SetValue(0);
1266     }
1267     else if(1 == nSelectType)
1268     {
1269         mpBTNGradient->Hide();
1270         mpMTRTransparent->Show();
1271         nTrans = mnLastTransSolid;
1272         mpMTRTransparent->SetValue(nTrans);
1273         mpLBTransType->SelectEntryPos(1);
1274         mpMTRTransparent->Enable();
1275     }
1276     else
1277     {
1278         mpBTNGradient->Show();
1279
1280         switch (nSelectType)
1281         {
1282             case 2:
1283                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgLinear);
1284                 break;
1285             case 3:
1286                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgAxial);
1287                 break;
1288             case 4:
1289                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgRadial);
1290                 break;
1291             case 5:
1292                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgElli );
1293                 break;
1294             case 6:
1295                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgQuad );
1296                 break;
1297             case 7:
1298                 mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, maImgSquare);
1299                 break;
1300         }
1301
1302         mpMTRTransparent->Hide();
1303         mpBTNGradient->Enable();
1304         bGradient = true;
1305     }
1306
1307     const XFillTransparenceItem aLinearItem(nTrans);
1308     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SFX_CALLMODE_RECORD, &aLinearItem, 0L );
1309
1310     if(nSelectType > 1)
1311     {
1312         nSelectType -= 2;
1313     }
1314
1315     XGradient aTmpGradient;
1316
1317     switch(nSelectType)
1318     {
1319         case XGRAD_LINEAR:
1320             aTmpGradient = maGradientLinear;
1321             break;
1322         case XGRAD_AXIAL:
1323             aTmpGradient = maGradientAxial;
1324             break;
1325         case XGRAD_RADIAL:
1326             aTmpGradient = maGradientRadial;
1327             break;
1328         case XGRAD_ELLIPTICAL:
1329             aTmpGradient = maGradientElliptical;
1330             break;
1331         case XGRAD_SQUARE:
1332             aTmpGradient = maGradientSquare;
1333             break;
1334         case XGRAD_RECT:
1335             aTmpGradient = maGradientRect;
1336             break;
1337     }
1338
1339     SfxItemPool* pPool = 0;
1340     const XFillFloatTransparenceItem aGradientItem(pPool, aTmpGradient, sal_Bool(bGradient));
1341     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_FLOATTRANSPARENCE, SFX_CALLMODE_RECORD, &aGradientItem, 0L );
1342
1343     return( 0L );
1344 }
1345
1346
1347
1348 IMPL_LINK(AreaPropertyPanel, ModifyTransparentHdl_Impl, void*, EMPTYARG)
1349 {
1350     const sal_uInt16 nTrans = (sal_uInt16)mpMTRTransparent->GetValue();
1351     mnLastTransSolid = nTrans;
1352     const sal_uInt16 nSelectType = mpLBTransType->GetSelectEntryPos();
1353
1354     if(nTrans && !nSelectType)
1355     {
1356         mpLBTransType->SelectEntryPos(1);
1357     }
1358
1359     const XFillTransparenceItem aLinearItem(nTrans);
1360     GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SFX_CALLMODE_RECORD, &aLinearItem, 0L );
1361
1362     return 0L;
1363 }
1364
1365
1366 Color AreaPropertyPanel::GetLastColor (void) const
1367 {
1368     return maLastColor;
1369 }
1370
1371
1372
1373
1374 XGradient AreaPropertyPanel::GetGradient (const XGradientStyle eStyle) const
1375 {
1376     switch (eStyle)
1377     {
1378         default:
1379         case XGRAD_LINEAR:
1380             return maGradientLinear;
1381         case XGRAD_AXIAL:
1382             return maGradientAxial;
1383         case XGRAD_RADIAL:
1384             return maGradientRadial;
1385         case XGRAD_ELLIPTICAL:
1386             return maGradientElliptical;
1387         case XGRAD_SQUARE:
1388             return maGradientSquare;
1389         case XGRAD_RECT:
1390             return maGradientRect;
1391     }
1392 }
1393
1394
1395
1396
1397 void AreaPropertyPanel::SetGradient (const XGradient& rGradient)
1398 {
1399     switch (rGradient.GetGradientStyle())
1400     {
1401         case XGRAD_LINEAR:
1402             maGradientLinear = rGradient;
1403             break;
1404         case XGRAD_AXIAL:
1405             maGradientAxial = rGradient;
1406             break;
1407         case XGRAD_RADIAL:
1408             maGradientRadial = rGradient;
1409             break;
1410         case XGRAD_ELLIPTICAL:
1411             maGradientElliptical = rGradient;
1412             break;
1413         case XGRAD_SQUARE:
1414             maGradientSquare = rGradient;
1415             break;
1416         case XGRAD_RECT:
1417             maGradientRect = rGradient;
1418             break;
1419     }
1420 }
1421
1422
1423
1424
1425 sal_Int32 AreaPropertyPanel::GetSelectedTransparencyTypeIndex (void) const
1426 {
1427     return mpLBTransType->GetSelectEntryPos();
1428 }
1429
1430 } } // end of namespace svx::sidebar
1431
1432 // eof