| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| #include "svx/sidebar/PopupContainer.hxx" |
| #include "AreaTransparencyGradientControl.hxx" |
| |
| #include <sfx2/sidebar/ResourceDefinitions.hrc> |
| #include <sfx2/sidebar/Theme.hxx> |
| #include <sfx2/sidebar/ControlFactory.hxx> |
| #include <sfx2/sidebar/Layouter.hxx> |
| #include <AreaPropertyPanel.hxx> |
| #include <AreaPropertyPanel.hrc> |
| #include <svx/dialogs.hrc> |
| #include <svx/dialmgr.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <svx/xfltrit.hxx> |
| #include <svx/xflftrit.hxx> |
| #include <svx/xtable.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <helpid.hrc> |
| #include <svtools/valueset.hxx> |
| #include <unotools/pathoptions.hxx> |
| #include <svx/svxitems.hrc> |
| #include <vcl/toolbox.hxx> |
| #include <svtools/toolbarmenu.hxx> |
| #include <svx/sidebar/ColorControl.hxx> |
| |
| #include <boost/bind.hpp> |
| |
| using namespace css; |
| using namespace cssu; |
| using ::sfx2::sidebar::Layouter; |
| using ::sfx2::sidebar::Theme; |
| |
| #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString))) |
| |
| |
| |
| |
| namespace svx { namespace sidebar { |
| |
| const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERX = 50; |
| const sal_Int32 AreaPropertyPanel::DEFAULT_CENTERY = 50; |
| const sal_Int32 AreaPropertyPanel::DEFAULT_ANGLE = 0; |
| const sal_Int32 AreaPropertyPanel::DEFAULT_STARTVALUE = 0; |
| const sal_Int32 AreaPropertyPanel::DEFAULT_ENDVALUE = 16777215; |
| const sal_Int32 AreaPropertyPanel::DEFAULT_BORDER = 0; |
| |
| |
| AreaPropertyPanel::AreaPropertyPanel( |
| Window* pParent, |
| const cssu::Reference<css::frame::XFrame>& rxFrame, |
| SfxBindings* pBindings) |
| : Control(pParent, SVX_RES(RID_SIDEBAR_AREA_PANEL)), |
| meLastXFS(-1), |
| maLastColor(Color(COL_DEFAULT_SHAPE_FILLING)), |
| mnLastPosGradient(0), |
| mnLastPosHatch(0), |
| mnLastPosBitmap(0), |
| mnLastTransSolid(50), |
| maGradientLinear(), |
| maGradientAxial(), |
| maGradientRadial(), |
| maGradientElliptical(), |
| maGradientSquare(), |
| maGradientRect(), |
| mpColorTextFT(new FixedText(this, SVX_RES(FT_COLOR_LIST))), |
| mpLbFillType(new SvxFillTypeBox(this)), |
| mpLbFillAttr(new SvxFillAttrBox(this)), |
| mpToolBoxColorBackground(sfx2::sidebar::ControlFactory::CreateToolBoxBackground(this)), |
| mpToolBoxColor(sfx2::sidebar::ControlFactory::CreateToolBox(mpToolBoxColorBackground.get(), SVX_RES(TB_COLOR))), |
| mpTrspTextFT(new FixedText(this, SVX_RES(FL_TRSP_TEXT))), |
| mpLBTransType(new ListBox(this, SVX_RES(LB_TRGR_TYPES))), |
| mpMTRTransparent(new MetricField(this, SVX_RES(MTR_TRANSPARENT))), |
| mpBTNGradientBackground(sfx2::sidebar::ControlFactory::CreateToolBoxBackground(this)), |
| mpBTNGradient(sfx2::sidebar::ControlFactory::CreateToolBox(mpBTNGradientBackground.get(), SVX_RES(BTN_GRADIENT))), |
| mpColorUpdater(new ::svx::ToolboxButtonColorUpdater(SID_ATTR_FILL_COLOR, TBI_COLOR, mpToolBoxColor.get(), TBX_UPDATER_MODE_CHAR_COLOR_NEW)), |
| mpStyleItem(), |
| mpColorItem(), |
| mpFillGradientItem(), |
| mpHatchItem(), |
| mpBitmapItem(), |
| maStyleControl(SID_ATTR_FILL_STYLE, *pBindings, *this), |
| maColorControl(SID_ATTR_FILL_COLOR, *pBindings, *this), |
| maGradientControl(SID_ATTR_FILL_GRADIENT, *pBindings, *this), |
| maHatchControl(SID_ATTR_FILL_HATCH, *pBindings, *this), |
| maBitmapControl(SID_ATTR_FILL_BITMAP, *pBindings, *this), |
| maColorTableControl(SID_COLOR_TABLE, *pBindings, *this), |
| maGradientListControl(SID_GRADIENT_LIST, *pBindings, *this), |
| maHatchListControl(SID_HATCH_LIST, *pBindings, *this), |
| maBitmapListControl(SID_BITMAP_LIST, *pBindings, *this), |
| maFillTransparenceController(SID_ATTR_FILL_TRANSPARENCE, *pBindings, *this), |
| maFillFloatTransparenceController(SID_ATTR_FILL_FLOATTRANSPARENCE, *pBindings, *this), |
| maImgAxial(SVX_RES(IMG_AXIAL)), |
| maImgElli(SVX_RES(IMG_ELLI)), |
| maImgQuad(SVX_RES(IMG_QUAD)), |
| maImgRadial(SVX_RES(IMG_RADIAL)), |
| maImgSquare(SVX_RES(IMG_SQUARE)), |
| maImgLinear(SVX_RES(IMG_LINEAR)), |
| maImgColor(SVX_RES(IMG_COLOR)), |
| maImgAxialH(SVX_RES(IMG_AXIAL_H)), |
| maImgElliH(SVX_RES(IMG_ELLI_H)), |
| maImgQuadH(SVX_RES(IMG_QUAD_H)), |
| maImgRadialH(SVX_RES(IMG_RADIAL_H)), |
| maImgSquareH(SVX_RES(IMG_SQUARE_H)), |
| maImgLinearH(SVX_RES(IMG_LINEAR_H)), |
| maImgColorH(SVX_RES(IMG_COLOR_H)), |
| msHelpFillType(SVX_RES(STR_HELP_TYPE)), |
| msHelpFillAttr(SVX_RES(STR_HELP_ATTR)), |
| maTrGrPopup(this, ::boost::bind(&AreaPropertyPanel::CreateTransparencyGradientControl, this, _1)), |
| maColorPopup(this, ::boost::bind(&AreaPropertyPanel::CreateColorPopupControl, this, _1)), |
| mpFloatTransparenceItem(), |
| mpTransparanceItem(), |
| mxFrame(rxFrame), |
| mpBindings(pBindings), |
| mbColorAvail(true), |
| maLayouter(*this) |
| { |
| Initialize(); |
| FreeResource(); |
| |
| // Setup the grid layouter. |
| const sal_Int32 nMappedMboxWidth (Layouter::MapWidth(*this, MBOX_WIDTH)); |
| |
| maLayouter.GetCell(0,0).SetControl(*mpColorTextFT).SetGridWidth(3); |
| maLayouter.GetCell(1,0).SetControl(*mpLbFillType); |
| maLayouter.GetCell(1,2,0).SetControl(*mpToolBoxColorBackground).SetFixedWidth(); |
| maLayouter.GetCell(1,2,1).SetControl(*mpLbFillAttr); |
| |
| maLayouter.GetCell(2,0).SetControl(*mpTrspTextFT).SetGridWidth(3); |
| maLayouter.GetCell(3,0).SetControl(*mpLBTransType); |
| maLayouter.GetCell(3,2,0).SetControl(*mpMTRTransparent); |
| maLayouter.GetCell(3,2,1).SetControl(*mpBTNGradient); |
| |
| maLayouter.GetColumn(0) |
| .SetWeight(1) |
| .SetLeftPadding(Layouter::MapWidth(*this,SECTIONPAGE_MARGIN_HORIZONTAL)) |
| .SetMinimumWidth(nMappedMboxWidth); |
| maLayouter.GetColumn(1) |
| .SetWeight(0) |
| .SetMinimumWidth(Layouter::MapWidth(*this, CONTROL_SPACING_HORIZONTAL)); |
| maLayouter.GetColumn(2) |
| .SetWeight(1) |
| .SetMinimumWidth(nMappedMboxWidth) |
| .SetRightPadding(Layouter::MapWidth(*this,SECTIONPAGE_MARGIN_HORIZONTAL)); |
| |
| // Make controls that display text handle short widths more |
| // graceful. |
| Layouter::PrepareForLayouting(*mpColorTextFT); |
| Layouter::PrepareForLayouting(*mpTrspTextFT); |
| } |
| |
| |
| |
| AreaPropertyPanel::~AreaPropertyPanel() |
| { |
| // Destroy the toolboxes, then their background windows. |
| mpToolBoxColor.reset(); |
| mpBTNGradient.reset(); |
| mpToolBoxColorBackground.reset(); |
| mpBTNGradientBackground.reset(); |
| } |
| |
| |
| |
| void AreaPropertyPanel::Initialize() |
| { |
| mpColorTextFT->SetBackground(Wallpaper()); |
| mpTrspTextFT->SetBackground(Wallpaper()); |
| |
| maGradientLinear.SetXOffset(DEFAULT_CENTERX); |
| maGradientLinear.SetYOffset(DEFAULT_CENTERY); |
| maGradientLinear.SetAngle(DEFAULT_ANGLE); |
| maGradientLinear.SetStartColor(Color(DEFAULT_STARTVALUE)); |
| maGradientLinear.SetEndColor(Color(DEFAULT_ENDVALUE)); |
| maGradientLinear.SetBorder(DEFAULT_BORDER); |
| maGradientLinear.SetGradientStyle(XGRAD_LINEAR); |
| |
| maGradientAxial = maGradientLinear; |
| maGradientAxial.SetGradientStyle(XGRAD_AXIAL); |
| |
| maGradientRadial = maGradientLinear; |
| maGradientRadial.SetGradientStyle(XGRAD_RADIAL); |
| |
| maGradientElliptical = maGradientLinear; |
| maGradientElliptical.SetGradientStyle(XGRAD_ELLIPTICAL); |
| |
| maGradientSquare = maGradientLinear; |
| maGradientSquare.SetGradientStyle(XGRAD_SQUARE); |
| |
| maGradientRect = maGradientLinear; |
| maGradientRect.SetGradientStyle(XGRAD_RECT); |
| |
| Size aLogicalFillSize(MBOX_WIDTH,LISTBOX_HEIGHT); |
| Size aLogicalAttrSize(MBOX_WIDTH + 1,LISTBOX_HEIGHT); |
| |
| Point aPoint(SECTIONPAGE_MARGIN_HORIZONTAL,SECTIONPAGE_MARGIN_VERTICAL_TOP + FIXED_TEXT_HEIGHT + TEXT_CONTROL_SPACING_VERTICAL); |
| Point aPoint_Picker(SECTIONPAGE_MARGIN_HORIZONTAL + MBOX_WIDTH + CONTROL_SPACING_HORIZONTAL,SECTIONPAGE_MARGIN_VERTICAL_TOP + FIXED_TEXT_HEIGHT + TEXT_CONTROL_SPACING_VERTICAL); |
| |
| Size aTypeSize(LogicToPixel(aLogicalFillSize, MAP_APPFONT)); |
| Size aAttrSize(LogicToPixel(aLogicalAttrSize, MAP_APPFONT)); |
| |
| Point aTypePoint(LogicToPixel(aPoint, MAP_APPFONT)); |
| Point aAttrPoint(LogicToPixel(aPoint_Picker, MAP_APPFONT)); |
| |
| mpLbFillType->SetPosSizePixel(aTypePoint,aTypeSize); |
| mpLbFillAttr->SetPosSizePixel(aAttrPoint,aAttrSize); |
| |
| mpLbFillType->SetHelpId(HID_PPROPERTYPANEL_AREA_LB_FILL_TYPES); |
| mpLbFillAttr->SetHelpId(HID_PPROPERTYPANEL_AREA_LB_FILL_ATTR); |
| |
| mpLbFillType->SetQuickHelpText(msHelpFillType); |
| mpLbFillAttr->SetQuickHelpText(msHelpFillAttr); |
| |
| mpLbFillType->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Fill"))); //wj acc |
| mpLbFillAttr->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Fill"))); //wj acc |
| |
| Link aLink = LINK( this, AreaPropertyPanel, SelectFillTypeHdl ); |
| mpLbFillType->SetSelectHdl( aLink ); |
| |
| aLink = LINK( this, AreaPropertyPanel, SelectFillAttrHdl ); |
| mpLbFillAttr->SetSelectHdl( aLink ); |
| |
| //add for new color picker |
| mpLbFillAttr->Hide(); |
| mpToolBoxColor->SetItemImage(TBI_COLOR, GetDisplayBackground().GetColor().IsDark()? maImgColorH : maImgColor); |
| Size aTbxSize( mpToolBoxColor->CalcWindowSizePixel() ); |
| mpToolBoxColor->SetOutputSizePixel( aTbxSize ); |
| mpToolBoxColor->SetItemBits( TBI_COLOR, mpToolBoxColor->GetItemBits( TBI_COLOR ) | TIB_DROPDOWNONLY ); |
| mpToolBoxColor->SetBackground(Wallpaper()); |
| mpToolBoxColor->SetPaintTransparent(true); |
| mpToolBoxColor->SetQuickHelpText(TBI_COLOR, String(SVX_RES(STR_HELP_COLOR))); //wj acc |
| //mpToolBoxColor->SetItemText(TBI_COLOR, msHelpFillAttr); |
| |
| long aHeightLBStyle = mpLbFillType->GetSizePixel().getHeight(); |
| long aLBPosY = mpLbFillType->GetPosPixel().getY(); |
| long aHeightTBAttr = mpToolBoxColor->GetSizePixel().getHeight(); |
| Point aPointTBAttr = mpToolBoxColor->GetPosPixel(); |
| aPointTBAttr.setY( aLBPosY + aHeightLBStyle / 2 - aHeightTBAttr / 2); |
| mpToolBoxColor->SetPosPixel(aPointTBAttr); |
| |
| aLink = LINK(this, AreaPropertyPanel, ToolBoxColorDropHdl); |
| mpToolBoxColor->SetDropdownClickHdl ( aLink ); |
| mpToolBoxColor->SetSelectHdl ( aLink ); |
| |
| //add end |
| mpLBTransType->SetSelectHdl(LINK(this, AreaPropertyPanel, ChangeTrgrTypeHdl_Impl)); |
| mpLBTransType->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Transparency"))); //wj acc |
| |
| mpMTRTransparent->SetValue( 50 ); |
| mpMTRTransparent->SetModifyHdl(LINK(this, AreaPropertyPanel, ModifyTransparentHdl_Impl)); |
| mpMTRTransparent->SetAccessibleName(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Transparency"))); //wj acc |
| |
| mpBTNGradient->SetItemBits( TBI_BTX_GRADIENT, mpBTNGradient->GetItemBits( TBI_BTX_GRADIENT ) | TIB_DROPDOWNONLY ); |
| aLink = LINK( this, AreaPropertyPanel, ClickTrGrHdl_Impl ); |
| mpBTNGradient->SetDropdownClickHdl( aLink ); |
| mpBTNGradient->SetSelectHdl( aLink ); |
| aTbxSize = mpBTNGradient->CalcWindowSizePixel(); |
| mpBTNGradient->SetOutputSizePixel( aTbxSize ); |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,maImgLinear); |
| mpBTNGradient->SetQuickHelpText(TBI_BTX_GRADIENT, String(SVX_RES(STR_HELP_GRADIENT))); //wj acc |
| mpBTNGradient->Hide(); |
| |
| long aHeightLBTrans = mpLBTransType->GetSizePixel().getHeight(); |
| Point aPointLB = mpLBTransType->GetPosPixel(); |
| long aPosY = aPointLB.getY(); |
| |
| Point aPointMetric = mpMTRTransparent->GetPosPixel(); |
| Point aPointTB = mpMTRTransparent->GetPosPixel(); |
| long aHeightMetric = mpMTRTransparent->GetSizePixel().getHeight(); |
| long aHeightTool = mpBTNGradient->GetSizePixel().getHeight(); |
| aPointMetric.setY(aPosY+aHeightLBTrans/2-aHeightMetric/2); |
| aPointTB.setY(aPosY+aHeightLBTrans/2-aHeightTool/2); |
| aPointTB.setX(aPointTB.getX()+3); |
| mpMTRTransparent->SetPosPixel(aPointMetric); |
| mpBTNGradient->SetPosPixel(aPointTB); |
| |
| mpLbFillType->SetAccessibleRelationLabeledBy(mpColorTextFT.get()); |
| mpLbFillAttr->SetAccessibleRelationLabeledBy(mpLbFillAttr.get()); |
| mpToolBoxColor->SetAccessibleRelationLabeledBy(mpToolBoxColor.get()); |
| mpLBTransType->SetAccessibleRelationLabeledBy(mpTrspTextFT.get()); |
| mpMTRTransparent->SetAccessibleRelationLabeledBy(mpMTRTransparent.get()); |
| mpBTNGradient->SetAccessibleRelationLabeledBy(mpBTNGradient.get()); |
| |
| SetupIcons(); |
| } |
| |
| |
| |
| IMPL_LINK( AreaPropertyPanel, SelectFillTypeHdl, ListBox *, pToolBox ) |
| { |
| const XFillStyle eXFS = (XFillStyle)mpLbFillType->GetSelectEntryPos(); |
| |
| if((XFillStyle)meLastXFS != eXFS) |
| { |
| mpLbFillAttr->Clear(); |
| SfxObjectShell* pSh = SfxObjectShell::Current(); |
| const XFillStyleItem aXFillStyleItem(eXFS); |
| |
| // #122676# Do no longer trigger two Execute calls, one for SID_ATTR_FILL_STYLE |
| // and one for setting the fill attribute itself, but add two SfxPoolItems to the |
| // call to get just one action at the SdrObject and to create only one Undo action, too. |
| // Checked that this works in all apps. |
| switch( eXFS ) |
| { |
| case XFILL_NONE: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| mpLbFillType->Selected(); |
| mpLbFillAttr->Disable(); |
| |
| // #122676# need to call a single SID_ATTR_FILL_STYLE change |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_STYLE, SFX_CALLMODE_RECORD, &aXFillStyleItem, 0L); |
| break; |
| } |
| case XFILL_SOLID: |
| { |
| mpLbFillAttr->Hide(); |
| mpToolBoxColor->Show(); |
| const String aTmpStr; |
| const Color aColor = maLastColor; |
| const XFillColorItem aXFillColorItem( aTmpStr, aColor ); |
| |
| // #122676# change FillStyle and Color in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_COLOR, SFX_CALLMODE_RECORD, &aXFillColorItem, &aXFillStyleItem, 0L); |
| break; |
| } |
| case XFILL_GRADIENT: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_GRADIENT_LIST)) |
| { |
| if(!mpLbFillAttr->GetEntryCount()) |
| { |
| const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetGradientList()); |
| } |
| |
| mpLbFillAttr->AdaptDropDownLineCountToMaximum(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND != mnLastPosGradient) |
| { |
| const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST))); |
| |
| if(mnLastPosGradient < aItem.GetGradientList()->Count()) |
| { |
| const XGradient aGradient = aItem.GetGradientList()->GetGradient(mnLastPosGradient)->GetGradient(); |
| const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetEntry(mnLastPosGradient), aGradient); |
| |
| // #122676# change FillStyle and Gradient in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_GRADIENT, SFX_CALLMODE_RECORD, &aXFillGradientItem, &aXFillStyleItem, 0L); |
| mpLbFillAttr->SelectEntryPos(mnLastPosGradient); |
| } |
| } |
| } |
| else |
| { |
| mpLbFillAttr->Disable(); |
| } |
| break; |
| } |
| case XFILL_HATCH: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_HATCH_LIST)) |
| { |
| if(!mpLbFillAttr->GetEntryCount()) |
| { |
| const SvxHatchListItem aItem( *(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetHatchList()); |
| } |
| |
| mpLbFillAttr->AdaptDropDownLineCountToMaximum(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND != mnLastPosHatch) |
| { |
| const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST))); |
| |
| if(mnLastPosHatch < aItem.GetHatchList()->Count()) |
| { |
| const XHatch aHatch = aItem.GetHatchList()->GetHatch(mnLastPosHatch)->GetHatch(); |
| const XFillHatchItem aXFillHatchItem(mpLbFillAttr->GetSelectEntry(), aHatch); |
| |
| // #122676# change FillStyle and Hatch in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_HATCH, SFX_CALLMODE_RECORD, &aXFillHatchItem, &aXFillStyleItem, 0L); |
| mpLbFillAttr->SelectEntryPos(mnLastPosHatch); |
| } |
| } |
| } |
| else |
| { |
| mpLbFillAttr->Disable(); |
| } |
| break; |
| } |
| case XFILL_BITMAP: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_BITMAP_LIST)) |
| { |
| if(!mpLbFillAttr->GetEntryCount()) |
| { |
| const SvxBitmapListItem aItem( *(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetBitmapList()); |
| } |
| |
| mpLbFillAttr->AdaptDropDownLineCountToMaximum(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND != mnLastPosBitmap) |
| { |
| const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST))); |
| |
| if(mnLastPosBitmap < aItem.GetBitmapList()->Count()) |
| { |
| const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(mnLastPosBitmap); |
| const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject()); |
| |
| // #122676# change FillStyle and Bitmap in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_BITMAP, SFX_CALLMODE_RECORD, &aXFillBitmapItem, &aXFillStyleItem, 0L); |
| mpLbFillAttr->SelectEntryPos(mnLastPosBitmap); |
| } |
| } |
| } |
| else |
| { |
| mpLbFillAttr->Disable(); |
| } |
| break; |
| } |
| } |
| |
| meLastXFS = (sal_uInt16)eXFS; |
| |
| if(XFILL_NONE != eXFS) |
| { |
| if(pToolBox) |
| { |
| mpLbFillType->Selected(); |
| } |
| } |
| |
| maLayouter.Layout(); |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| IMPL_LINK( AreaPropertyPanel, SelectFillAttrHdl, ListBox*, pToolBox ) |
| { |
| const XFillStyle eXFS = (XFillStyle)mpLbFillType->GetSelectEntryPos(); |
| const XFillStyleItem aXFillStyleItem(eXFS); |
| SfxObjectShell* pSh = SfxObjectShell::Current(); |
| |
| if(pToolBox) |
| { |
| // #122676# dependent from bFillStyleChange, do execute a single or two |
| // changes in one Execute call |
| const bool bFillStyleChange((XFillStyle) meLastXFS != eXFS); |
| |
| switch(eXFS) |
| { |
| case XFILL_SOLID: |
| { |
| if(bFillStyleChange) |
| { |
| // #122676# Single FillStyle change call needed here |
| GetBindings()->GetDispatcher()->Execute(SID_ATTR_FILL_STYLE, SFX_CALLMODE_RECORD, &aXFillStyleItem, 0L); |
| } |
| break; |
| } |
| case XFILL_GRADIENT: |
| { |
| sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND == nPos) |
| { |
| nPos = mnLastPosGradient; |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_GRADIENT_LIST)) |
| { |
| const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST))); |
| |
| if(nPos < aItem.GetGradientList()->Count()) |
| { |
| const XGradient aGradient = aItem.GetGradientList()->GetGradient(nPos)->GetGradient(); |
| const XFillGradientItem aXFillGradientItem(mpLbFillAttr->GetSelectEntry(), aGradient); |
| |
| // #122676# Change FillStale and Gradinet in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_GRADIENT, SFX_CALLMODE_RECORD, &aXFillGradientItem, |
| bFillStyleChange ? &aXFillStyleItem : 0L, 0L); |
| } |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos) |
| { |
| mnLastPosGradient = nPos; |
| } |
| break; |
| } |
| case XFILL_HATCH: |
| { |
| sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND == nPos) |
| { |
| nPos = mnLastPosHatch; |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_HATCH_LIST)) |
| { |
| const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST))); |
| |
| if(nPos < aItem.GetHatchList()->Count()) |
| { |
| const XHatch aHatch = aItem.GetHatchList()->GetHatch(nPos)->GetHatch(); |
| const XFillHatchItem aXFillHatchItem( mpLbFillAttr->GetSelectEntry(), aHatch); |
| |
| // #122676# Change FillStale and Hatch in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_HATCH, SFX_CALLMODE_RECORD, &aXFillHatchItem, |
| bFillStyleChange ? &aXFillStyleItem : 0L, 0L); |
| } |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos) |
| { |
| mnLastPosHatch = nPos; |
| } |
| break; |
| } |
| case XFILL_BITMAP: |
| { |
| sal_uInt16 nPos = mpLbFillAttr->GetSelectEntryPos(); |
| |
| if(LISTBOX_ENTRY_NOTFOUND == nPos) |
| { |
| nPos = mnLastPosBitmap; |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos && pSh && pSh->GetItem(SID_BITMAP_LIST)) |
| { |
| const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST))); |
| |
| if(nPos < aItem.GetBitmapList()->Count()) |
| { |
| const XBitmapEntry* pXBitmapEntry = aItem.GetBitmapList()->GetBitmap(nPos); |
| const XFillBitmapItem aXFillBitmapItem(mpLbFillAttr->GetSelectEntry(), pXBitmapEntry->GetGraphicObject()); |
| |
| // #122676# Change FillStale and Bitmap in one call |
| GetBindings()->GetDispatcher()->Execute( |
| SID_ATTR_FILL_BITMAP, SFX_CALLMODE_RECORD, &aXFillBitmapItem, |
| bFillStyleChange ? &aXFillStyleItem : 0L, 0L); |
| } |
| } |
| |
| if(LISTBOX_ENTRY_NOTFOUND != nPos) |
| { |
| mnLastPosBitmap = nPos; |
| } |
| break; |
| } |
| default: break; |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| IMPL_LINK(AreaPropertyPanel, ToolBoxColorDropHdl, ToolBox*, pToolBox) |
| { |
| const sal_uInt16 nId = pToolBox->GetCurItemId(); |
| |
| if(TBI_COLOR == nId) |
| { |
| maColorPopup.Show(*pToolBox); |
| |
| if (mpColorItem) |
| { |
| maColorPopup.SetCurrentColor(mpColorItem->GetColorValue(), mbColorAvail); |
| } |
| else |
| { |
| maColorPopup.SetCurrentColor(COL_WHITE, false); |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| void AreaPropertyPanel::SetColor ( |
| const String& rsColorName, |
| const Color aColor) |
| { |
| const XFillColorItem aXFillColorItem(rsColorName, aColor); |
| mpBindings->GetDispatcher()->Execute(SID_ATTR_FILL_COLOR, SFX_CALLMODE_RECORD, &aXFillColorItem, 0L); |
| maLastColor = aColor; |
| } |
| |
| |
| |
| |
| PopupControl* AreaPropertyPanel::CreateTransparencyGradientControl (PopupContainer* pParent) |
| { |
| return new AreaTransparencyGradientControl(pParent, *this); |
| } |
| |
| |
| |
| |
| PopupControl* AreaPropertyPanel::CreateColorPopupControl (PopupContainer* pParent) |
| { |
| return new ColorControl( |
| pParent, |
| mpBindings, |
| SVX_RES(RID_POPUPPANEL_AERAPAGE_COLOR), |
| SVX_RES(VS_COLOR), |
| ::boost::bind(&AreaPropertyPanel::GetLastColor, this), |
| ::boost::bind(&AreaPropertyPanel::SetColor, this, _1,_2), |
| pParent, |
| 0); |
| } |
| |
| |
| |
| |
| void AreaPropertyPanel::SetupIcons(void) |
| { |
| if(Theme::GetBoolean(Theme::Bool_UseSymphonyIcons)) |
| { |
| // todo |
| } |
| else |
| { |
| // todo |
| } |
| } |
| |
| |
| |
| AreaPropertyPanel* AreaPropertyPanel::Create ( |
| Window* pParent, |
| const cssu::Reference<css::frame::XFrame>& rxFrame, |
| SfxBindings* pBindings) |
| { |
| if (pParent == NULL) |
| throw lang::IllegalArgumentException(A2S("no parent Window given to AreaPropertyPanel::Create"), NULL, 0); |
| if ( ! rxFrame.is()) |
| throw lang::IllegalArgumentException(A2S("no XFrame given to AreaPropertyPanel::Create"), NULL, 1); |
| if (pBindings == NULL) |
| throw lang::IllegalArgumentException(A2S("no SfxBindings given to AreaPropertyPanel::Create"), NULL, 2); |
| |
| return new AreaPropertyPanel( |
| pParent, |
| rxFrame, |
| pBindings); |
| } |
| |
| |
| |
| void AreaPropertyPanel::DataChanged( |
| const DataChangedEvent& rEvent) |
| { |
| (void)rEvent; |
| |
| SetupIcons(); |
| } |
| |
| |
| |
| void AreaPropertyPanel::ImpUpdateTransparencies() |
| { |
| if(mpTransparanceItem.get() && mpFloatTransparenceItem.get()) |
| { |
| bool bZeroValue(false); |
| |
| if(mpTransparanceItem.get()) |
| { |
| const sal_uInt16 nValue(mpTransparanceItem->GetValue()); |
| |
| if(!nValue) |
| { |
| bZeroValue = true; |
| } |
| else if(nValue <= 100) |
| { |
| mpLBTransType->Enable(); |
| mpTrspTextFT->Enable(); |
| mpLBTransType->SelectEntryPos(1); |
| mpBTNGradient->Hide(); |
| mpMTRTransparent->Show(); |
| mpMTRTransparent->Enable(); |
| mpMTRTransparent->SetValue(nValue); |
| } |
| |
| if(!bZeroValue) |
| { |
| maTrGrPopup.Hide(); |
| } |
| } |
| |
| if(bZeroValue && mpFloatTransparenceItem.get()) |
| { |
| if(mpFloatTransparenceItem->IsEnabled()) |
| { |
| const XGradient& rGradient = mpFloatTransparenceItem->GetGradientValue(); |
| const bool bHighContrast(GetSettings().GetStyleSettings().GetHighContrastMode()); |
| sal_uInt16 nEntryPos(0); |
| Image* pImage = 0; |
| |
| mpLBTransType->Enable(); |
| mpTrspTextFT->Enable(); |
| mpMTRTransparent->Hide(); |
| mpBTNGradient->Enable(); |
| mpBTNGradient->Show(); |
| |
| switch(rGradient.GetGradientStyle()) |
| { |
| case XGRAD_LINEAR: |
| { |
| nEntryPos = 2; |
| pImage = bHighContrast ? &maImgLinearH : &maImgLinear; |
| break; |
| } |
| case XGRAD_AXIAL: |
| { |
| nEntryPos = 3; |
| pImage = bHighContrast ? &maImgAxialH : &maImgAxial; |
| break; |
| } |
| case XGRAD_RADIAL: |
| { |
| nEntryPos = 4; |
| pImage = bHighContrast ? &maImgRadialH : &maImgRadial; |
| break; |
| } |
| case XGRAD_ELLIPTICAL: |
| { |
| nEntryPos = 5; |
| pImage = bHighContrast ? &maImgElliH : &maImgElli; |
| break; |
| } |
| case XGRAD_SQUARE: |
| { |
| nEntryPos = 6; |
| pImage = bHighContrast ? &maImgQuadH : &maImgQuad; |
| break; |
| } |
| case XGRAD_RECT: |
| { |
| nEntryPos = 7; |
| pImage = bHighContrast ? &maImgSquareH : &maImgSquare; |
| break; |
| } |
| } |
| |
| mpLBTransType->SelectEntryPos(nEntryPos); |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT, *pImage); |
| bZeroValue = false; |
| } |
| else |
| { |
| bZeroValue = true; |
| } |
| } |
| |
| if(bZeroValue) |
| { |
| mpLBTransType->Enable(); |
| mpTrspTextFT->Enable(); |
| mpLBTransType->SelectEntryPos(0); |
| mpBTNGradient->Hide(); |
| mpMTRTransparent->Enable(); |
| mpMTRTransparent->Show(); |
| mpMTRTransparent->SetValue(0); |
| } |
| } |
| else |
| { |
| // no transparency at all |
| mpLBTransType->SetNoSelection(); |
| mpLBTransType->Disable(); |
| mpTrspTextFT->Disable(); |
| mpMTRTransparent->Disable(); |
| mpMTRTransparent->Show(); |
| mpBTNGradient->Disable(); |
| mpBTNGradient->Hide(); |
| } |
| } |
| |
| |
| |
| void AreaPropertyPanel::NotifyItemUpdate( |
| sal_uInt16 nSID, |
| SfxItemState eState, |
| const SfxPoolItem* pState, |
| const bool bIsEnabled) |
| { |
| (void)bIsEnabled; |
| const bool bDisabled(SFX_ITEM_DISABLED == eState); |
| |
| switch(nSID) |
| { |
| case SID_ATTR_FILL_TRANSPARENCE: |
| case SID_ATTR_FILL_FLOATTRANSPARENCE: |
| { |
| bool bFillTransparenceChanged(false); |
| |
| if(SID_ATTR_FILL_TRANSPARENCE == nSID) |
| { |
| bFillTransparenceChanged = true; |
| |
| if(eState >= SFX_ITEM_AVAILABLE) |
| { |
| const SfxUInt16Item* pItem = dynamic_cast< const SfxUInt16Item* >(pState); |
| |
| if(pItem && (!mpTransparanceItem || *pItem != *mpTransparanceItem)) |
| { |
| mpTransparanceItem.reset((SfxUInt16Item*)pItem->Clone()); |
| } |
| else |
| { |
| mpTransparanceItem.reset(); |
| } |
| } |
| else |
| { |
| mpTransparanceItem.reset(); |
| } |
| } |
| else // if(SID_ATTR_FILL_FLOATTRANSPARENCE == nSID) |
| { |
| bFillTransparenceChanged = true; |
| |
| if(eState >= SFX_ITEM_AVAILABLE) |
| { |
| const XFillFloatTransparenceItem* pItem = dynamic_cast< const XFillFloatTransparenceItem* >(pState); |
| |
| if(pItem && (!mpFloatTransparenceItem || *pItem != *mpFloatTransparenceItem)) |
| { |
| mpFloatTransparenceItem.reset((XFillFloatTransparenceItem*)pItem->Clone()); |
| } |
| else |
| { |
| mpFloatTransparenceItem.reset(); |
| } |
| } |
| else |
| { |
| mpFloatTransparenceItem.reset(); |
| } |
| } |
| |
| if(bFillTransparenceChanged) |
| { |
| // update transparency settings dependent of mpTransparanceItem and mpFloatTransparenceItem |
| ImpUpdateTransparencies(); |
| } |
| break; |
| } |
| case SID_ATTR_FILL_STYLE: |
| { |
| if(bDisabled) |
| { |
| mpLbFillType->Disable(); |
| mpColorTextFT->Disable(); |
| mpLbFillType->SetNoSelection(); |
| mpLbFillAttr->Show(); |
| mpLbFillAttr->Disable(); |
| mpLbFillAttr->SetNoSelection(); |
| mpToolBoxColor->Hide(); |
| meLastXFS = -1; |
| mpStyleItem.reset(); |
| } |
| |
| if(eState >= SFX_ITEM_AVAILABLE) |
| { |
| const XFillStyleItem* pItem = dynamic_cast< const XFillStyleItem* >(pState); |
| |
| if(pItem) |
| { |
| mpStyleItem.reset(dynamic_cast< XFillStyleItem* >(pItem->Clone())); |
| mpLbFillType->Enable(); |
| mpColorTextFT->Enable(); |
| XFillStyle eXFS = (XFillStyle)mpStyleItem->GetValue(); |
| meLastXFS = eXFS; |
| mpLbFillType->SelectEntryPos(sal::static_int_cast< sal_uInt16 >(eXFS)); |
| |
| if(XFILL_NONE == eXFS) |
| { |
| mpLbFillAttr->SetNoSelection(); |
| mpLbFillAttr->Disable(); |
| } |
| |
| Update(); |
| break; |
| } |
| } |
| |
| mpLbFillType->SetNoSelection(); |
| mpLbFillAttr->Show(); |
| mpLbFillAttr->Disable(); |
| mpLbFillAttr->SetNoSelection(); |
| mpToolBoxColor->Hide(); |
| meLastXFS = -1; |
| mpStyleItem.reset(); |
| break; |
| } |
| case SID_ATTR_FILL_COLOR: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpColorItem.reset(pState ? (XFillColorItem*)pState->Clone() : 0); |
| } |
| |
| if(mpStyleItem && XFILL_SOLID == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| mpLbFillAttr->Hide(); |
| mpToolBoxColor->Show(); |
| |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpToolBoxColor->Enable(); |
| mbColorAvail = true; |
| // maLastColor = mpColorItem->GetColorValue(); |
| Update(); |
| } |
| else if(SFX_ITEM_DISABLED == eState) |
| { |
| mpToolBoxColor->Disable(); |
| mbColorAvail = false; |
| mpColorUpdater->Update(COL_WHITE); |
| } |
| else |
| { |
| mbColorAvail = false; |
| mpColorUpdater->Update(COL_WHITE); |
| } |
| } |
| break; |
| } |
| case SID_ATTR_FILL_GRADIENT: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpFillGradientItem.reset(pState ? (XFillGradientItem*)pState->Clone() : 0); |
| } |
| |
| if(mpStyleItem && XFILL_GRADIENT == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpLbFillAttr->Enable(); |
| Update(); |
| } |
| else if(SFX_ITEM_DISABLED == eState ) |
| { |
| mpLbFillAttr->Disable(); |
| mpLbFillAttr->SetNoSelection(); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| break; |
| } |
| case SID_ATTR_FILL_HATCH: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpHatchItem.reset(pState ? (XFillHatchItem*)pState->Clone() : 0); |
| } |
| |
| if(mpStyleItem && XFILL_HATCH == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpLbFillAttr->Enable(); |
| Update(); |
| } |
| else if(SFX_ITEM_DISABLED == eState ) |
| { |
| mpLbFillAttr->Disable(); |
| mpLbFillAttr->SetNoSelection(); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| break; |
| } |
| case SID_ATTR_FILL_BITMAP: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpBitmapItem.reset(pState ? (XFillBitmapItem*)pState->Clone() : 0); |
| } |
| |
| if(mpStyleItem && XFILL_BITMAP == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| mpLbFillAttr->Enable(); |
| Update(); |
| } |
| else if(SFX_ITEM_DISABLED == eState ) |
| { |
| mpLbFillAttr->Disable(); |
| mpLbFillAttr->SetNoSelection(); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| break; |
| } |
| case SID_COLOR_TABLE: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| if(mpStyleItem && XFILL_SOLID == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| if(mpColorItem) |
| { |
| const Color aColor = mpColorItem->GetColorValue(); |
| const SfxObjectShell* pSh = SfxObjectShell::Current(); |
| const SvxColorTableItem aItem(*(const SvxColorTableItem*)(pSh->GetItem(SID_COLOR_TABLE))); |
| |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Fill(aItem.GetColorTable()); |
| mpLbFillAttr->SelectEntry(aColor); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| } |
| break; |
| } |
| case SID_GRADIENT_LIST: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| if(mpStyleItem && XFILL_GRADIENT == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| if(mpFillGradientItem) |
| { |
| const String aString( mpFillGradientItem->GetName() ); |
| const SfxObjectShell* pSh = SfxObjectShell::Current(); |
| const SvxGradientListItem aItem( *(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST))); |
| |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Fill(aItem.GetGradientList()); |
| mpLbFillAttr->SelectEntry(aString); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| } |
| break; |
| } |
| case SID_HATCH_LIST: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| if(mpStyleItem && XFILL_HATCH == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| if(mpHatchItem) |
| { |
| const String aString( mpHatchItem->GetName() ); |
| const SfxObjectShell* pSh = SfxObjectShell::Current(); |
| const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST))); |
| |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Fill(aItem.GetHatchList()); |
| mpLbFillAttr->SelectEntry(aString); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| } |
| break; |
| } |
| case SID_BITMAP_LIST: |
| { |
| if(SFX_ITEM_AVAILABLE == eState) |
| { |
| if(mpStyleItem && XFILL_BITMAP == (XFillStyle)mpStyleItem->GetValue()) |
| { |
| if(mpBitmapItem) |
| { |
| const String aString( mpBitmapItem->GetName() ); |
| const SfxObjectShell* pSh = SfxObjectShell::Current(); |
| const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST))); |
| |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Fill(aItem.GetBitmapList()); |
| mpLbFillAttr->SelectEntry(aString); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| maLayouter.Layout(); |
| } |
| |
| |
| |
| SfxBindings* AreaPropertyPanel::GetBindings() |
| { |
| return mpBindings; |
| } |
| |
| |
| |
| void AreaPropertyPanel::Update() |
| { |
| if(mpStyleItem) |
| { |
| const XFillStyle eXFS = (XFillStyle)mpStyleItem->GetValue(); |
| SfxObjectShell* pSh = SfxObjectShell::Current(); |
| |
| switch( eXFS ) |
| { |
| case XFILL_NONE: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| break; |
| } |
| case XFILL_SOLID: |
| { |
| if(mpColorItem) |
| { |
| mpLbFillAttr->Hide(); |
| mpToolBoxColor->Show(); |
| mpColorUpdater->Update(mpColorItem->GetColorValue()); |
| } |
| else |
| { |
| mpColorUpdater->Update(COL_WHITE); |
| } |
| break; |
| } |
| case XFILL_GRADIENT: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_GRADIENT_LIST)) |
| { |
| const SvxGradientListItem aItem(*(const SvxGradientListItem*)(pSh->GetItem(SID_GRADIENT_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetGradientList()); |
| |
| if(mpFillGradientItem) |
| { |
| const String aString(mpFillGradientItem->GetName()); |
| |
| mpLbFillAttr->SelectEntry(aString); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| break; |
| } |
| case XFILL_HATCH: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_HATCH_LIST)) |
| { |
| const SvxHatchListItem aItem(*(const SvxHatchListItem*)(pSh->GetItem(SID_HATCH_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetHatchList()); |
| |
| if(mpHatchItem) |
| { |
| const String aString(mpHatchItem->GetName()); |
| |
| mpLbFillAttr->SelectEntry( aString ); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| break; |
| } |
| case XFILL_BITMAP: |
| { |
| mpLbFillAttr->Show(); |
| mpToolBoxColor->Hide(); |
| |
| if(pSh && pSh->GetItem(SID_BITMAP_LIST)) |
| { |
| const SvxBitmapListItem aItem(*(const SvxBitmapListItem*)(pSh->GetItem(SID_BITMAP_LIST))); |
| mpLbFillAttr->Enable(); |
| mpLbFillAttr->Clear(); |
| mpLbFillAttr->Fill(aItem.GetBitmapList()); |
| |
| if(mpBitmapItem) |
| { |
| const String aString(mpBitmapItem->GetName()); |
| |
| mpLbFillAttr->SelectEntry(aString); |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| } |
| else |
| { |
| mpLbFillAttr->SetNoSelection(); |
| } |
| break; |
| } |
| default: |
| DBG_ERROR( "Non supported FillType (!)" ); |
| break; |
| } |
| } |
| } |
| |
| |
| |
| IMPL_LINK( AreaPropertyPanel, ImplPopupModeEndHdl, FloatingWindow*, EMPTYARG ) |
| { |
| return 0; |
| } |
| |
| |
| |
| IMPL_LINK( AreaPropertyPanel, ClickTrGrHdl_Impl, ToolBox*, pToolBox ) |
| { |
| maTrGrPopup.Rearrange(mpFloatTransparenceItem.get()); |
| OSL_ASSERT(pToolBox->GetCurItemId() == TBI_BTX_GRADIENT); |
| maTrGrPopup.Show(*pToolBox); |
| |
| return (0L); |
| } |
| |
| |
| |
| IMPL_LINK(AreaPropertyPanel, ChangeTrgrTypeHdl_Impl, void *, EMPTYARG) |
| { |
| sal_uInt16 nSelectType = mpLBTransType->GetSelectEntryPos(); |
| bool bGradient = false; |
| sal_uInt16 nTrans = 0; |
| |
| if(!nSelectType) |
| { |
| mpBTNGradient->Hide(); |
| mpMTRTransparent->Show(); |
| mpMTRTransparent->Enable(); |
| mpMTRTransparent->SetValue(0); |
| } |
| else if(1 == nSelectType) |
| { |
| mpBTNGradient->Hide(); |
| mpMTRTransparent->Show(); |
| nTrans = mnLastTransSolid; |
| mpMTRTransparent->SetValue(nTrans); |
| mpLBTransType->SelectEntryPos(1); |
| mpMTRTransparent->Enable(); |
| } |
| else |
| { |
| mpBTNGradient->Show(); |
| |
| switch (nSelectType) |
| { |
| case 2: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgLinearH : maImgLinear); |
| break; |
| case 3: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgAxialH : maImgAxial); |
| break; |
| case 4: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgRadialH : maImgRadial); |
| break; |
| case 5: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgElliH : maImgElli ); |
| break; |
| case 6: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgQuadH : maImgQuad ); |
| break; |
| case 7: |
| mpBTNGradient->SetItemImage(TBI_BTX_GRADIENT,GetSettings().GetStyleSettings().GetHighContrastMode()? maImgSquareH : maImgSquare); |
| break; |
| } |
| |
| mpMTRTransparent->Hide(); |
| mpBTNGradient->Enable(); |
| bGradient = true; |
| } |
| |
| const XFillTransparenceItem aLinearItem(nTrans); |
| GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SFX_CALLMODE_RECORD, &aLinearItem, 0L ); |
| |
| if(nSelectType > 1) |
| { |
| nSelectType -= 2; |
| } |
| |
| XGradient aTmpGradient; |
| |
| switch(nSelectType) |
| { |
| case XGRAD_LINEAR: |
| aTmpGradient = maGradientLinear; |
| break; |
| case XGRAD_AXIAL: |
| aTmpGradient = maGradientAxial; |
| break; |
| case XGRAD_RADIAL: |
| aTmpGradient = maGradientRadial; |
| break; |
| case XGRAD_ELLIPTICAL: |
| aTmpGradient = maGradientElliptical; |
| break; |
| case XGRAD_SQUARE: |
| aTmpGradient = maGradientSquare; |
| break; |
| case XGRAD_RECT: |
| aTmpGradient = maGradientRect; |
| break; |
| } |
| |
| SfxItemPool* pPool = 0; |
| const XFillFloatTransparenceItem aGradientItem(pPool, aTmpGradient, sal_Bool(bGradient)); |
| GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_FLOATTRANSPARENCE, SFX_CALLMODE_RECORD, &aGradientItem, 0L ); |
| |
| return( 0L ); |
| } |
| |
| |
| |
| IMPL_LINK(AreaPropertyPanel, ModifyTransparentHdl_Impl, void*, EMPTYARG) |
| { |
| const sal_uInt16 nTrans = (sal_uInt16)mpMTRTransparent->GetValue(); |
| mnLastTransSolid = nTrans; |
| const sal_uInt16 nSelectType = mpLBTransType->GetSelectEntryPos(); |
| |
| if(nTrans && !nSelectType) |
| { |
| mpLBTransType->SelectEntryPos(1); |
| } |
| |
| const XFillTransparenceItem aLinearItem(nTrans); |
| GetBindings()->GetDispatcher()->Execute( SID_ATTR_FILL_TRANSPARENCE, SFX_CALLMODE_RECORD, &aLinearItem, 0L ); |
| |
| return 0L; |
| } |
| |
| |
| Color AreaPropertyPanel::GetLastColor (void) const |
| { |
| return maLastColor; |
| } |
| |
| |
| |
| |
| XGradient AreaPropertyPanel::GetGradient (const XGradientStyle eStyle) const |
| { |
| switch (eStyle) |
| { |
| default: |
| case XGRAD_LINEAR: |
| return maGradientLinear; |
| case XGRAD_AXIAL: |
| return maGradientAxial; |
| case XGRAD_RADIAL: |
| return maGradientRadial; |
| case XGRAD_ELLIPTICAL: |
| return maGradientElliptical; |
| case XGRAD_SQUARE: |
| return maGradientSquare; |
| case XGRAD_RECT: |
| return maGradientRect; |
| } |
| } |
| |
| |
| |
| |
| void AreaPropertyPanel::SetGradient (const XGradient& rGradient) |
| { |
| switch (rGradient.GetGradientStyle()) |
| { |
| case XGRAD_LINEAR: |
| maGradientLinear = rGradient; |
| break; |
| case XGRAD_AXIAL: |
| maGradientAxial = rGradient; |
| break; |
| case XGRAD_RADIAL: |
| maGradientRadial = rGradient; |
| break; |
| case XGRAD_ELLIPTICAL: |
| maGradientElliptical = rGradient; |
| break; |
| case XGRAD_SQUARE: |
| maGradientSquare = rGradient; |
| break; |
| case XGRAD_RECT: |
| maGradientRect = rGradient; |
| break; |
| } |
| } |
| |
| |
| |
| |
| sal_Int32 AreaPropertyPanel::GetSelectedTransparencyTypeIndex (void) const |
| { |
| return mpLBTransType->GetSelectEntryPos(); |
| } |
| |
| |
| |
| |
| void AreaPropertyPanel::Resize (void) |
| { |
| maLayouter.Layout(); |
| } |
| |
| |
| |
| } } // end of namespace svx::sidebar |
| |
| // eof |
