/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * 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 . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // table background #define TBL_DEST_CELL 0 #define TBL_DEST_ROW 1 #define TBL_DEST_TBL 2 #include #include "backgrnd.hxx" #include #include #include #include #include #include #include #include #include #include #include #include using namespace ::com::sun::star; // static ---------------------------------------------------------------- static sal_uInt16 pRanges[] = { SID_VIEW_FLD_PIC, SID_VIEW_FLD_PIC, SID_ATTR_BRUSH, SID_ATTR_BRUSH, SID_ATTR_BRUSH_CHAR, SID_ATTR_BRUSH_CHAR, 0 }; struct SvxBackgroundTable_Impl { SvxBrushItem* pCellBrush; SvxBrushItem* pRowBrush; SvxBrushItem* pTableBrush; sal_uInt16 nCellWhich; sal_uInt16 nRowWhich; sal_uInt16 nTableWhich; sal_uInt16 nActPos; SvxBackgroundTable_Impl() : pCellBrush(NULL), pRowBrush(NULL), pTableBrush(NULL), nCellWhich(0), nRowWhich(0), nTableWhich(0) {} }; struct SvxBackgroundPara_Impl { SvxBrushItem* pParaBrush; SvxBrushItem* pCharBrush; sal_uInt16 nActPos; SvxBackgroundPara_Impl() : pParaBrush(NULL), pCharBrush(NULL) {} }; struct SvxBackgroundPage_Impl { Timer* pLoadTimer; sal_Bool bIsImportDlgInExecute; SvxBackgroundPage_Impl() : pLoadTimer(NULL), bIsImportDlgInExecute(sal_False) {} }; static inline sal_uInt8 lcl_PercentToTransparency(long nPercent) { //0xff must not be returned! return sal_uInt8(nPercent ? (50 + 0xfe * nPercent) / 100 : 0); } static inline sal_uInt8 lcl_TransparencyToPercent(sal_uInt8 nTrans) { return (nTrans * 100 + 127) / 254; } static void lcl_SetTransparency(SvxBrushItem& rBrush, long nTransparency) { uno::Any aTransparency; aTransparency <<= (sal_Int8)nTransparency; rBrush.PutValue(aTransparency, MID_GRAPHIC_TRANSPARENCY); } /// Returns the fill style of the currently selected entry. static XFillStyle lcl_getFillStyle(ListBox* pLbSelect) { return (XFillStyle)(sal_uLong)pLbSelect->GetEntryData(pLbSelect->GetSelectEntryPos()); } // Selects the entry matching the specified fill style. static void lcl_setFillStyle(ListBox* pLbSelect, XFillStyle eStyle) { for (int i = 0; i < pLbSelect->GetEntryCount(); ++i) if ((XFillStyle)(sal_uLong)pLbSelect->GetEntryData(i) == eStyle) { pLbSelect->SelectEntryPos(i); return; } } //------------------------------------------------------------------------- sal_uInt16 GetItemId_Impl( ValueSet& rValueSet, const Color& rCol ) { sal_Bool bFound = sal_False; sal_uInt16 nCount = rValueSet.GetItemCount(); sal_uInt16 n = 1; while ( !bFound && n <= nCount ) { Color aValCol = rValueSet.GetItemColor(n); bFound = ( aValCol.GetRed() == rCol.GetRed() && aValCol.GetGreen() == rCol.GetGreen() && aValCol.GetBlue() == rCol.GetBlue() ); if ( !bFound ) n++; } return bFound ? n : 0; } // class BackgroundPreview ----------------------------------------------- /* [Description] preview window for brush or bitmap */ class BackgroundPreviewImpl : public Window { public: BackgroundPreviewImpl(Window* pParent); void setBmp(bool bBmp); ~BackgroundPreviewImpl(); void NotifyChange( const Color& rColor ); void NotifyChange( const Bitmap* pBitmap ); protected: virtual void Paint( const Rectangle& rRect ); virtual void DataChanged( const DataChangedEvent& rDCEvt ); virtual void Resize(); private: void recalcDrawPos(); bool bIsBmp; Bitmap* pBitmap; Point aDrawPos; Size aDrawSize; Rectangle aDrawRect; sal_uInt8 nTransparency; }; BackgroundPreviewImpl::BackgroundPreviewImpl(Window* pParent) : Window(pParent, WB_BORDER) , bIsBmp(false) , pBitmap(NULL) , aDrawRect(Point(0,0), GetOutputSizePixel()) , nTransparency(0) { SetBorderStyle(WINDOW_BORDER_MONO); Paint(aDrawRect); } extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeBackgroundPreview(Window *pParent, VclBuilder::stringmap &) { return new BackgroundPreviewImpl(pParent); } void BackgroundPreviewImpl::setBmp(bool bBmp) { bIsBmp = bBmp; Invalidate(); } //----------------------------------------------------------------------- BackgroundPreviewImpl::~BackgroundPreviewImpl() { delete pBitmap; } //----------------------------------------------------------------------- void BackgroundPreviewImpl::NotifyChange( const Color& rColor ) { if ( !bIsBmp ) { const static Color aTranspCol( COL_TRANSPARENT ); nTransparency = lcl_TransparencyToPercent( rColor.GetTransparency() ); SetFillColor( rColor == aTranspCol ? GetSettings().GetStyleSettings().GetFieldColor() : (Color) rColor.GetRGBColor() ); Paint( aDrawRect ); } } //----------------------------------------------------------------------- void BackgroundPreviewImpl::NotifyChange( const Bitmap* pNewBitmap ) { if ( bIsBmp && (pNewBitmap || pBitmap) ) { if ( pNewBitmap && pBitmap ) *pBitmap = *pNewBitmap; else if ( pNewBitmap && !pBitmap ) pBitmap = new Bitmap( *pNewBitmap ); else if ( !pNewBitmap ) DELETEZ( pBitmap ); recalcDrawPos(); Invalidate( aDrawRect ); Update(); } } void BackgroundPreviewImpl::recalcDrawPos() { if ( pBitmap ) { Size aSize = GetOutputSizePixel(); // InnerSize == Size without one pixel border Size aInnerSize = aSize; aInnerSize.Width() -= 2; aInnerSize.Height() -= 2; aDrawSize = pBitmap->GetSizePixel(); // bitmap bigger than preview window? if ( aDrawSize.Width() > aInnerSize.Width() ) { aDrawSize.Height() = aDrawSize.Height() * aInnerSize.Width() / aDrawSize.Width(); if ( aDrawSize.Height() > aInnerSize.Height() ) { aDrawSize.Width() = aDrawSize.Height(); aDrawSize.Height() = aInnerSize.Height(); } else aDrawSize.Width() = aInnerSize.Width(); } else if ( aDrawSize.Height() > aInnerSize.Height() ) { aDrawSize.Width() = aDrawSize.Width() * aInnerSize.Height() / aDrawSize.Height(); if ( aDrawSize.Width() > aInnerSize.Width() ) { aDrawSize.Height() = aDrawSize.Width(); aDrawSize.Width() = aInnerSize.Width(); } else aDrawSize.Height() = aInnerSize.Height(); } aDrawPos.X() = (aSize.Width() - aDrawSize.Width()) / 2; aDrawPos.Y() = (aSize.Height() - aDrawSize.Height()) / 2; } } void BackgroundPreviewImpl::Resize() { Window::Resize(); aDrawRect = Rectangle(Point(0,0), GetOutputSizePixel()); recalcDrawPos(); } //----------------------------------------------------------------------- void BackgroundPreviewImpl::Paint( const Rectangle& ) { const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); SetBackground(Wallpaper(rStyleSettings.GetWindowColor())); SetLineColor(); if(bIsBmp) SetFillColor( Color(COL_TRANSPARENT) ); DrawRect( aDrawRect ); if ( bIsBmp ) { if ( pBitmap ) DrawBitmap( aDrawPos, aDrawSize, *pBitmap ); else { Size aSize = GetOutputSizePixel(); DrawLine( Point(0,0), Point(aSize.Width(),aSize.Height()) ); DrawLine( Point(0,aSize.Height()), Point(aSize.Width(),0) ); } } } void BackgroundPreviewImpl::DataChanged( const DataChangedEvent& rDCEvt ) { if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) ) { Invalidate(); } Window::DataChanged( rDCEvt ); } // class SvxBackgroundTabPage -------------------------------------------- #define HDL(hdl) LINK(this,SvxBackgroundTabPage,hdl) SvxBackgroundTabPage::SvxBackgroundTabPage(Window* pParent, const SfxItemSet& rCoreSet) : SvxTabPage(pParent, "BackgroundPage", "cui/ui/backgroundpage.ui", rCoreSet) , m_pXPool(rCoreSet.GetPool()) , m_aXFillAttr(m_pXPool) , m_rXFillSet(m_aXFillAttr.GetItemSet()) , nHtmlMode(0) , bAllowShowSelector(true) , bIsGraphicValid(false) , bLinkOnly(false) , bColTransparency(false) , bGraphTransparency(false) , pPageImpl(new SvxBackgroundPage_Impl) , pImportDlg(NULL) , pTableBck_Impl(NULL) , pParaBck_Impl(NULL) { get(m_pAsGrid, "asgrid"); get(m_pSelectTxt, "asft"); get(m_pLbSelect, "selectlb"); get(m_pTblDesc, "forft"); get(m_pTblLBox, "tablelb"); get(m_pParaLBox, "paralb"); get(m_pBackGroundColorFrame, "backgroundcolorframe"); get(m_pBackgroundColorSet, "backgroundcolorset"); get(m_pPreviewWin1, "preview1"); get(m_pColTransFT, "transparencyft"); get(m_pColTransMF, "transparencymf"); get(m_pBtnPreview, "showpreview"); // Initialize gradient controls get(m_pBackGroundGradientFrame, "backgroundgradientframe"); get(m_pLbGradients, "gradientslb"); Size aSize = LogicToPixel(Size(88, 110), MAP_APPFONT); m_pLbGradients->set_width_request(aSize.Width()); m_pLbGradients->set_height_request(aSize.Height()); get(m_pCtlPreview, "previewctl"); aSize = LogicToPixel(Size(88, 42), MAP_APPFONT); m_pCtlPreview->set_width_request(aSize.Width()); m_pCtlPreview->set_height_request(aSize.Height()); get(m_pFileFrame, "fileframe"); get(m_pBtnBrowse, "browse"); get(m_pBtnLink, "link"); get(m_pFtUnlinked, "unlinkedft"); get(m_pFtFile, "fileft"); get(m_pTypeFrame, "typeframe"); get(m_pBtnPosition, "positionrb"); get(m_pBtnArea, "arearb"); get(m_pBtnTile, "tilerb"); get(m_pWndPosition, "windowpos"); get(m_pGraphTransFrame, "graphtransframe"); get(m_pGraphTransMF, "graphtransmf"); get(m_pPreviewWin2, "preview2"); m_pPreviewWin2->setBmp(true); // this page needs ExchangeSupport SetExchangeSupport(); const SfxPoolItem* pItem; SfxObjectShell* pShell; if ( SFX_ITEM_SET == rCoreSet.GetItemState( SID_HTML_MODE, sal_False, &pItem ) || ( 0 != ( pShell = SfxObjectShell::Current()) && 0 != ( pItem = pShell->GetItem( SID_HTML_MODE ) ) ) ) { nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue(); } FillColorValueSets_Impl(); m_pBackgroundColorSet->SetSelectHdl( HDL(BackgroundColorHdl_Impl) ); } //------------------------------------------------------------------------ SvxBackgroundTabPage::~SvxBackgroundTabPage() { delete pPageImpl->pLoadTimer; delete pPageImpl; delete pImportDlg; if( pTableBck_Impl) { delete pTableBck_Impl->pCellBrush; delete pTableBck_Impl->pRowBrush; delete pTableBck_Impl->pTableBrush; delete pTableBck_Impl; } if(pParaBck_Impl) { delete pParaBck_Impl->pParaBrush; delete pParaBck_Impl->pCharBrush; delete pParaBck_Impl; } } //------------------------------------------------------------------------ sal_uInt16* SvxBackgroundTabPage::GetRanges() /* [Description] returns the area of the which-values */ { return pRanges; } //------------------------------------------------------------------------ SfxTabPage* SvxBackgroundTabPage::Create( Window* pParent, const SfxItemSet& rAttrSet ) /* [Description] create method for the TabDialog */ { return ( new SvxBackgroundTabPage( pParent, rAttrSet ) ); } //------------------------------------------------------------------------ void SvxBackgroundTabPage::Reset( const SfxItemSet& rSet ) { // os: Such a nonsense! One will always find such an item somewhere, // but it must be existing in the rSet! // const SfxPoolItem* pX = GetOldItem( rSet, SID_VIEW_FLD_PIC ); // if( pX && pX->ISA(SfxWallpaperItem)) if(SFX_ITEM_AVAILABLE <= rSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), sal_False)) { ResetFromWallpaperItem( rSet ); return; } // condition of the preview button is persistent due to UserData String aUserData = GetUserData(); m_pBtnPreview->Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) ); // don't be allowed to call ShowSelector() after reset anymore bAllowShowSelector = sal_False; // get and evaluate Input-BrushItem const SvxBrushItem* pBgdAttr = NULL; sal_uInt16 nSlot = SID_ATTR_BRUSH; const SfxPoolItem* pItem; sal_uInt16 nDestValue = USHRT_MAX; if ( SFX_ITEM_SET == rSet.GetItemState( SID_BACKGRND_DESTINATION, sal_False, &pItem ) ) { nDestValue = ((const SfxUInt16Item*)pItem)->GetValue(); m_pTblLBox->SelectEntryPos(nDestValue); switch ( nDestValue ) { case TBL_DEST_CELL: nSlot = SID_ATTR_BRUSH; break; case TBL_DEST_ROW: nSlot = SID_ATTR_BRUSH_ROW; break; case TBL_DEST_TBL: nSlot = SID_ATTR_BRUSH_TABLE; break; } } else if( SFX_ITEM_SET == rSet.GetItemState( SID_PARA_BACKGRND_DESTINATION, sal_False, &pItem ) ) { nDestValue = ((const SfxUInt16Item*)pItem)->GetValue(); // character activated? sal_uInt16 nParaSel = m_pParaLBox->GetSelectEntryPos(); if(1 == nParaSel) { // then it was a "standard"-call nDestValue = nParaSel; } m_pParaLBox->SelectEntryPos(nDestValue); switch ( nDestValue ) { case PARA_DEST_PARA: nSlot = SID_ATTR_BRUSH; break; case PARA_DEST_CHAR: nSlot = SID_ATTR_BRUSH_CHAR; break; } } //#111173# the destination item is missing when the parent style has been changed if(USHRT_MAX == nDestValue && (m_pParaLBox->IsVisible()||m_pTblLBox->IsVisible())) nDestValue = 0; sal_uInt16 nWhich = GetWhich( nSlot ); if ( rSet.GetItemState( nWhich, sal_False ) >= SFX_ITEM_AVAILABLE ) pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) ); m_pBtnTile->Check(); if ( pBgdAttr ) { FillControls_Impl(*pBgdAttr, aUserData); aBgdColor = ( (SvxBrushItem*)pBgdAttr )->GetColor(); } else { m_pSelectTxt->Hide(); m_pLbSelect->Hide(); lcl_setFillStyle(m_pLbSelect, XFILL_SOLID); ShowColorUI_Impl(); const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_BRUSH ); if ( pOld ) aBgdColor = ( (SvxBrushItem*)pOld )->GetColor(); } if ( nDestValue != USHRT_MAX ) { if(m_pTblLBox->IsVisible()) { sal_uInt16 nValue = m_pTblLBox->GetSelectEntryPos(); if ( pTableBck_Impl ) { DELETEZ( pTableBck_Impl->pCellBrush); DELETEZ( pTableBck_Impl->pRowBrush); DELETEZ( pTableBck_Impl->pTableBrush); } else pTableBck_Impl = new SvxBackgroundTable_Impl(); pTableBck_Impl->nActPos = nValue; nWhich = GetWhich( SID_ATTR_BRUSH ); if ( rSet.GetItemState( nWhich, sal_False ) >= SFX_ITEM_AVAILABLE ) { pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) ); pTableBck_Impl->pCellBrush = new SvxBrushItem(*pBgdAttr); } pTableBck_Impl->nCellWhich = nWhich; if ( rSet.GetItemState( SID_ATTR_BRUSH_ROW, sal_False ) >= SFX_ITEM_AVAILABLE ) { pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_ROW ) ); pTableBck_Impl->pRowBrush = new SvxBrushItem(*pBgdAttr); } pTableBck_Impl->nRowWhich = SID_ATTR_BRUSH_ROW; if ( rSet.GetItemState( SID_ATTR_BRUSH_TABLE, sal_False ) >= SFX_ITEM_AVAILABLE ) { pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_TABLE ) ); pTableBck_Impl->pTableBrush = new SvxBrushItem(*pBgdAttr); } pTableBck_Impl->nTableWhich = SID_ATTR_BRUSH_TABLE; TblDestinationHdl_Impl(m_pTblLBox); m_pTblLBox->SaveValue(); } else { sal_uInt16 nValue = m_pParaLBox->GetSelectEntryPos(); if ( pParaBck_Impl ) { delete pParaBck_Impl->pParaBrush; delete pParaBck_Impl->pCharBrush; } else pParaBck_Impl = new SvxBackgroundPara_Impl(); pParaBck_Impl->nActPos = nValue; nWhich = GetWhich( SID_ATTR_BRUSH ); if ( rSet.GetItemState( nWhich, sal_False ) >= SFX_ITEM_AVAILABLE ) { pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) ); pParaBck_Impl->pParaBrush = new SvxBrushItem(*pBgdAttr); } nWhich = GetWhich( SID_ATTR_BRUSH_CHAR ); rSet.GetItemState( nWhich, sal_True ); rSet.GetItemState( nWhich, sal_False ); if ( rSet.GetItemState( nWhich, sal_True ) > SFX_ITEM_AVAILABLE ) { pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) ); pParaBck_Impl->pCharBrush = new SvxBrushItem(*pBgdAttr); } else pParaBck_Impl->pCharBrush = new SvxBrushItem(SID_ATTR_BRUSH_CHAR); ParaDestinationHdl_Impl(m_pParaLBox); m_pParaLBox->SaveValue(); } } } void SvxBackgroundTabPage::ResetFromWallpaperItem( const SfxItemSet& rSet ) { ShowSelector(); // condition of the preview button is persistent due to UserData String aUserData = GetUserData(); m_pBtnPreview->Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) ); // get and evaluate Input-BrushItem const SvxBrushItem* pBgdAttr = NULL; sal_uInt16 nSlot = SID_VIEW_FLD_PIC; sal_uInt16 nWhich = GetWhich( nSlot ); SvxBrushItem* pTemp = 0; const CntWallpaperItem* pItem = 0; if ( rSet.GetItemState( nWhich, sal_False ) >= SFX_ITEM_AVAILABLE ) { pItem = (const CntWallpaperItem*)&rSet.Get( nWhich ); pTemp = new SvxBrushItem( *pItem, nWhich ); pBgdAttr = pTemp; } m_pBtnTile->Check(); if ( pBgdAttr ) { FillControls_Impl(*pBgdAttr, aUserData); // brush shall be kept when showing the graphic, too if( aBgdColor != pBgdAttr->GetColor() ) { aBgdColor = pBgdAttr->GetColor(); sal_uInt16 nCol = GetItemId_Impl(*m_pBackgroundColorSet, aBgdColor); m_pBackgroundColorSet->SelectItem( nCol ); m_pPreviewWin1->NotifyChange( aBgdColor ); } } else { lcl_setFillStyle(m_pLbSelect, XFILL_SOLID); ShowColorUI_Impl(); const SfxPoolItem* pOld = GetOldItem( rSet, SID_VIEW_FLD_PIC ); if ( pOld ) aBgdColor = Color( ((CntWallpaperItem*)pOld)->GetColor() ); } // We now have always a link to the background bLinkOnly = sal_True; m_pBtnLink->Check( sal_True ); m_pBtnLink->Show( sal_False ); // if( !pItem || !pItem->GetWallpaper(sal_False).IsBitmap() ) // m_pBtnLink->Check(); delete pTemp; } //------------------------------------------------------------------------ void SvxBackgroundTabPage::FillUserData() /* [Description] When destroying a SfxTabPage this virtual method is called, so that the TabPage can save internal information. In this case the condition of the preview button is saved. */ { SetUserData( m_pBtnPreview->IsChecked() ? rtl::OUString('1') : rtl::OUString('0') ); } //------------------------------------------------------------------------ sal_Bool SvxBackgroundTabPage::FillItemSet( SfxItemSet& rCoreSet ) { if ( pPageImpl->pLoadTimer && pPageImpl->pLoadTimer->IsActive() ) { pPageImpl->pLoadTimer->Stop(); LoadTimerHdl_Impl( pPageImpl->pLoadTimer ); } // os: Such a nonsense! One will always find such an item somewhere, // but it must be existing in the rSet! // const SfxPoolItem* pX = GetOldItem( rCoreSet, SID_VIEW_FLD_PIC ); // if( pX && pX->ISA(SfxWallpaperItem)) if(SFX_ITEM_AVAILABLE <= rCoreSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), sal_False)) return FillItemSetWithWallpaperItem( rCoreSet, SID_VIEW_FLD_PIC ); sal_Bool bModified = sal_False; sal_uInt16 nSlot = SID_ATTR_BRUSH; if ( m_pTblLBox->IsVisible() ) { switch( m_pTblLBox->GetSelectEntryPos() ) { case TBL_DEST_CELL: nSlot = SID_ATTR_BRUSH; break; case TBL_DEST_ROW: nSlot = SID_ATTR_BRUSH_ROW; break; case TBL_DEST_TBL: nSlot = SID_ATTR_BRUSH_TABLE; break; } } else if (m_pParaLBox->GetData() == m_pParaLBox) { switch(m_pParaLBox->GetSelectEntryPos()) { case PARA_DEST_PARA: nSlot = SID_ATTR_BRUSH; break; case PARA_DEST_CHAR: nSlot = SID_ATTR_BRUSH_CHAR; break; } } sal_uInt16 nWhich = GetWhich( nSlot ); const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot ); SfxItemState eOldItemState = rCoreSet.GetItemState(nSlot, sal_False); const SfxItemSet& rOldSet = GetItemSet(); sal_Bool bGraphTransparencyChanged = bGraphTransparency && (m_pGraphTransMF->GetText() != m_pGraphTransMF->GetSavedValue()); if ( pOld ) { const SvxBrushItem& rOldItem = (const SvxBrushItem&)*pOld; SvxGraphicPosition eOldPos = rOldItem.GetGraphicPos(); const sal_Bool bIsBrush = ( XFILL_SOLID == lcl_getFillStyle(m_pLbSelect) ); const bool bIsGradient = ( XFILL_GRADIENT == lcl_getFillStyle(m_pLbSelect) ); // transparency has to be set if enabled, the color not already set to "No fill" and if( bColTransparency && aBgdColor.GetTransparency() < 0xff) { aBgdColor.SetTransparency(lcl_PercentToTransparency(static_cast(m_pColTransMF->GetValue()))); } if ( ( (GPOS_NONE == eOldPos) && (bIsBrush || bIsGradient) ) || ( (GPOS_NONE != eOldPos) && !(bIsBrush || bIsGradient) ) ) // Brush <-> Bitmap changed? { // background art hasn't been changed: if ( (GPOS_NONE == eOldPos) || !m_pLbSelect->IsVisible() ) { if (bIsBrush) { // Brush-treatment: if ( rOldItem.GetColor() != aBgdColor || (SFX_ITEM_AVAILABLE >= eOldItemState && !m_pBackgroundColorSet->IsNoSelection())) { bModified = sal_True; rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) ); } else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) ) rCoreSet.ClearItem( nWhich ); // Handle XFILL_GRADIENT -> XFILL_SOLID XFillStyleItem aFillStyleItem(XFILL_SOLID, GetWhich(SID_ATTR_FILL_STYLE)); rCoreSet.Put(aFillStyleItem); } else { XFillStyleItem aFillStyleItem(((const XFillStyleItem&)m_rXFillSet.Get(XATTR_FILLSTYLE)).GetValue(), GetWhich(SID_ATTR_FILL_STYLE)); rCoreSet.Put(aFillStyleItem); const XFillGradientItem& rFillGradientItem = (const XFillGradientItem&)m_rXFillSet.Get(XATTR_FILLGRADIENT); XFillGradientItem aFillGradientItem(rFillGradientItem.GetName(), rFillGradientItem.GetGradientValue(), GetWhich(SID_ATTR_FILL_GRADIENT)); rCoreSet.Put(aFillGradientItem); } } else { // Bitmap-treatment: SvxGraphicPosition eNewPos = GetGraphicPosition_Impl(); const sal_Bool bIsLink = m_pBtnLink->IsChecked(); const sal_Bool bWasLink = (NULL != rOldItem.GetGraphicLink() ); if ( !bIsLink && !bIsGraphicValid ) bIsGraphicValid = LoadLinkedGraphic_Impl(); if ( bGraphTransparencyChanged || eNewPos != eOldPos || bIsLink != bWasLink || ( bWasLink && *rOldItem.GetGraphicLink() != aBgdGraphicPath ) || ( !bWasLink && rOldItem.GetGraphic()->GetBitmap() != aBgdGraphic.GetBitmap() ) ) { bModified = sal_True; SvxBrushItem aTmpBrush(nWhich); if ( bIsLink ) { aTmpBrush = SvxBrushItem( aBgdGraphicPath, aBgdGraphicFilter, eNewPos, nWhich ); } else aTmpBrush = SvxBrushItem( aBgdGraphic, eNewPos, nWhich ); lcl_SetTransparency(aTmpBrush, static_cast(m_pGraphTransMF->GetValue())); rCoreSet.Put(aTmpBrush); } else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) ) rCoreSet.ClearItem( nWhich ); } } else // Brush <-> Bitmap changed! { if (bIsBrush || bIsGradient) { rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) ); if (bIsGradient) { // Handle XFILL_BITMAP -> XFILL_GRADIENT XFillStyleItem aFillStyleItem(((const XFillStyleItem&)m_rXFillSet.Get(XATTR_FILLSTYLE)).GetValue(), GetWhich(SID_ATTR_FILL_STYLE)); rCoreSet.Put(aFillStyleItem); const XFillGradientItem& rFillGradientItem = (const XFillGradientItem&)m_rXFillSet.Get(XATTR_FILLGRADIENT); XFillGradientItem aFillGradientItem(rFillGradientItem.GetName(), rFillGradientItem.GetGradientValue(), GetWhich(SID_ATTR_FILL_GRADIENT)); rCoreSet.Put(aFillGradientItem); } } else { SvxBrushItem* pTmpBrush = 0; if ( m_pBtnLink->IsChecked() ) { pTmpBrush = new SvxBrushItem( aBgdGraphicPath, aBgdGraphicFilter, GetGraphicPosition_Impl(), nWhich ); } else { if ( !bIsGraphicValid ) bIsGraphicValid = LoadLinkedGraphic_Impl(); if ( bIsGraphicValid ) pTmpBrush = new SvxBrushItem( aBgdGraphic, GetGraphicPosition_Impl(), nWhich ); } if(pTmpBrush) { lcl_SetTransparency(*pTmpBrush, static_cast(m_pGraphTransMF->GetValue())); rCoreSet.Put(*pTmpBrush); delete pTmpBrush; } } bModified = ( bIsBrush || bIsGradient || m_pBtnLink->IsChecked() || bIsGraphicValid ); } } else if ( SID_ATTR_BRUSH_CHAR == nSlot && aBgdColor != Color( COL_WHITE ) ) { rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) ); bModified = sal_True; } if( m_pTblLBox->IsVisible() ) { // the current condition has already been put if( nSlot != SID_ATTR_BRUSH && pTableBck_Impl->pCellBrush) { const SfxPoolItem* pOldCell = GetOldItem( rCoreSet, SID_ATTR_BRUSH ); if ( *pTableBck_Impl->pCellBrush != *pOldCell ) { rCoreSet.Put( *pTableBck_Impl->pCellBrush ); bModified |= sal_True; } } if( nSlot != SID_ATTR_BRUSH_ROW && pTableBck_Impl->pRowBrush) { const SfxPoolItem* pOldRow = GetOldItem( rCoreSet, SID_ATTR_BRUSH_ROW ); if ( *pTableBck_Impl->pRowBrush != *pOldRow ) { rCoreSet.Put( *pTableBck_Impl->pRowBrush ); bModified |= sal_True; } } if( nSlot != SID_ATTR_BRUSH_TABLE && pTableBck_Impl->pTableBrush) { const SfxPoolItem* pOldTable = GetOldItem( rCoreSet, SID_ATTR_BRUSH_TABLE ); if ( *pTableBck_Impl->pTableBrush != *pOldTable ) { rCoreSet.Put( *pTableBck_Impl->pTableBrush ); bModified |= sal_True; } } if( m_pTblLBox->GetSavedValue() != m_pTblLBox->GetSelectEntryPos() ) { rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION, m_pTblLBox->GetSelectEntryPos() ) ); bModified |= sal_True; } } else if (m_pParaLBox->GetData() == m_pParaLBox) { // the current condition has already been put if( nSlot != SID_ATTR_BRUSH && m_pParaLBox->IsVisible()) // not in search format dialog { const SfxPoolItem* pOldPara = GetOldItem( rCoreSet, SID_ATTR_BRUSH ); if ( *pParaBck_Impl->pParaBrush != *pOldPara ) { rCoreSet.Put( *pParaBck_Impl->pParaBrush ); bModified |= sal_True; } } if( nSlot != SID_ATTR_BRUSH_CHAR ) { const SfxPoolItem* pOldChar = GetOldItem( rCoreSet, SID_ATTR_BRUSH_CHAR ); DBG_ASSERT(pParaBck_Impl, "pParaBck_Impl == NULL ?"); if ( pOldChar && //#111173# crash report shows that pParaBck_Impl can be NULL, the cause is unknown pParaBck_Impl && (*pParaBck_Impl->pCharBrush != *pOldChar || *pParaBck_Impl->pCharBrush != SvxBrushItem(SID_ATTR_BRUSH_CHAR))) { rCoreSet.Put( *pParaBck_Impl->pCharBrush ); bModified |= sal_True; } } if( m_pParaLBox->GetSavedValue() != m_pParaLBox->GetSelectEntryPos() ) { rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION, m_pParaLBox->GetSelectEntryPos() ) ); bModified |= sal_True; } } return bModified; } sal_Bool SvxBackgroundTabPage::FillItemSetWithWallpaperItem( SfxItemSet& rCoreSet, sal_uInt16 nSlot) { sal_uInt16 nWhich = GetWhich( nSlot ); const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot ); const SfxItemSet& rOldSet = GetItemSet(); DBG_ASSERT(pOld,"FillItemSetWithWallpaperItem: Item not found"); SvxBrushItem rOldItem( (const CntWallpaperItem&)*pOld, nWhich ); SvxGraphicPosition eOldPos = rOldItem.GetGraphicPos(); const sal_Bool bIsBrush = ( XFILL_SOLID == lcl_getFillStyle(m_pLbSelect) ); sal_Bool bModified = sal_False; if ( ( (GPOS_NONE == eOldPos) && bIsBrush ) || ( (GPOS_NONE != eOldPos) && !bIsBrush ) ) // Brush <-> Bitmap changed? { // background art hasn't been changed if ( (GPOS_NONE == eOldPos) || !m_pLbSelect->IsVisible() ) { // Brush-treatment: if ( rOldItem.GetColor() != aBgdColor ) { bModified = sal_True; CntWallpaperItem aItem( nWhich ); aItem.SetColor( aBgdColor ); rCoreSet.Put( aItem ); } else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) ) rCoreSet.ClearItem( nWhich ); } else { // Bitmap-treatment: SvxGraphicPosition eNewPos = GetGraphicPosition_Impl(); int bBitmapChanged = ( ( eNewPos != eOldPos ) || ( *rOldItem.GetGraphicLink() != aBgdGraphicPath ) ); int bBrushChanged = ( rOldItem.GetColor() != aBgdColor ); if( bBitmapChanged || bBrushChanged ) { bModified = sal_True; CntWallpaperItem aItem( nWhich ); WallpaperStyle eWallStyle = SvxBrushItem::GraphicPos2WallpaperStyle(eNewPos); aItem.SetStyle( sal::static_int_cast< sal_uInt16 >( eWallStyle ) ); aItem.SetColor( aBgdColor ); aItem.SetBitmapURL( aBgdGraphicPath ); rCoreSet.Put( aItem ); } else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) ) rCoreSet.ClearItem( nWhich ); } } else // Brush <-> Bitmap changed! { CntWallpaperItem aItem( nWhich ); if ( bIsBrush ) { aItem.SetColor( aBgdColor ); rCoreSet.Put( aItem ); } else { WallpaperStyle eWallStyle = SvxBrushItem::GraphicPos2WallpaperStyle( GetGraphicPosition_Impl() ); aItem.SetStyle( sal::static_int_cast< sal_uInt16 >( eWallStyle ) ); aItem.SetColor( aBgdColor ); aItem.SetBitmapURL( aBgdGraphicPath ); rCoreSet.Put( aItem ); } bModified = sal_True; } return bModified; } //----------------------------------------------------------------------- int SvxBackgroundTabPage::DeactivatePage( SfxItemSet* _pSet ) /* [Description] virtual method; is called on deactivation */ { if ( pPageImpl->bIsImportDlgInExecute ) return KEEP_PAGE; if ( _pSet ) FillItemSet( *_pSet ); return LEAVE_PAGE; } //----------------------------------------------------------------------- void SvxBackgroundTabPage::PointChanged( Window* , RECT_POINT ) { // has to be implemented so that position control can work } //----------------------------------------------------------------------- void SvxBackgroundTabPage::ShowSelector() { if( bAllowShowSelector) { m_pAsGrid->Show(); m_pSelectTxt->Show(); m_pLbSelect->Show(); m_pLbSelect->SetSelectHdl( HDL(SelectHdl_Impl) ); m_pBtnLink->SetClickHdl( HDL(FileClickHdl_Impl) ); m_pBtnPreview->SetClickHdl( HDL(FileClickHdl_Impl) ); m_pBtnBrowse->SetClickHdl( HDL(BrowseHdl_Impl) ); m_pBtnArea->SetClickHdl( HDL(RadioClickHdl_Impl) ); m_pBtnTile->SetClickHdl( HDL(RadioClickHdl_Impl) ); m_pBtnPosition->SetClickHdl( HDL(RadioClickHdl_Impl) ); m_pLbGradients->SetSelectHdl(HDL(ModifyGradientHdl_Impl)); // delayed loading via timer (because of UI-Update) pPageImpl->pLoadTimer = new Timer; pPageImpl->pLoadTimer->SetTimeout( 500 ); pPageImpl->pLoadTimer->SetTimeoutHdl( LINK( this, SvxBackgroundTabPage, LoadTimerHdl_Impl ) ); bAllowShowSelector = sal_False; if(nHtmlMode & HTMLMODE_ON) { m_pBtnArea->Enable(sal_False); } } } //------------------------------------------------------------------------ void SvxBackgroundTabPage::RaiseLoadError_Impl() { SfxErrorContext aContext( ERRCTX_SVX_BACKGROUND, String(), this, RID_SVXERRCTX, &CUI_MGR() ); ErrorHandler::HandleError( *new StringErrorInfo( ERRCODE_SVX_GRAPHIC_NOTREADABLE, aBgdGraphicPath ) ); } //------------------------------------------------------------------------ sal_Bool SvxBackgroundTabPage::LoadLinkedGraphic_Impl() { sal_Bool bResult = ( aBgdGraphicPath.Len() > 0 ) && ( GRFILTER_OK == GraphicFilter::LoadGraphic( aBgdGraphicPath, aBgdGraphicFilter, aBgdGraphic ) ); return bResult; } //------------------------------------------------------------------------ void SvxBackgroundTabPage::FillColorValueSets_Impl() { SfxObjectShell* pDocSh = SfxObjectShell::Current(); const SfxPoolItem* pItem = NULL; XColorListRef pColorTable = NULL; const Size aSize15x15 = Size( 15, 15 ); if ( pDocSh && ( 0 != ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) ) ) pColorTable = ( (SvxColorListItem*)pItem )->GetColorList(); if ( !pColorTable.is() ) pColorTable = XColorList::CreateStdColorList(); if ( pColorTable.is() ) { short i = 0; long nCount = pColorTable->Count(); XColorEntry* pEntry = NULL; Color aColWhite( COL_WHITE ); String aStrWhite( EditResId( RID_SVXITEMS_COLOR_WHITE ) ); WinBits nBits = ( m_pBackgroundColorSet->GetStyle() | WB_ITEMBORDER | WB_NAMEFIELD | WB_NONEFIELD ); m_pBackgroundColorSet->SetText( SVX_RESSTR( RID_SVXSTR_TRANSPARENT ) ); m_pBackgroundColorSet->SetStyle( nBits ); m_pBackgroundColorSet->SetAccessibleName(m_pBackGroundColorFrame->get_label_widget()->GetText()); for ( i = 0; i < nCount; i++ ) { pEntry = pColorTable->GetColor(i); m_pBackgroundColorSet->InsertItem( i + 1, pEntry->GetColor(), pEntry->GetName() ); } while ( i < 104 ) { m_pBackgroundColorSet->InsertItem( i + 1, aColWhite, aStrWhite ); i++; } if ( nCount > 104 ) { m_pBackgroundColorSet->SetStyle( nBits | WB_VSCROLL ); } } m_pBackgroundColorSet->SetColCount( 8 ); m_pBackgroundColorSet->SetLineCount( 13 ); m_pBackgroundColorSet->CalcWindowSizePixel( aSize15x15 ); } //------------------------------------------------------------------------ //------------------------------------------------------------------------ void SvxBackgroundTabPage::ShowColorUI_Impl() /* [Description] Hide the controls for editing the bitmap and show the controls for color settings instead. */ { if (!m_pBackGroundColorFrame->IsVisible()) { HideBitmapUI_Impl(); HideGradientUI_Impl(); m_pBackGroundColorFrame->Show(); if(bColTransparency) { m_pColTransFT->Show(); m_pColTransMF->Show(); } } } void SvxBackgroundTabPage::HideColorUI_Impl() { m_pBackGroundColorFrame->Hide(); } //------------------------------------------------------------------------ void SvxBackgroundTabPage::ShowBitmapUI_Impl() /* [Description] Hide the controls for color settings and show controls for editing the bitmap instead. */ { if (m_pLbSelect->IsVisible() && (m_pBackGroundColorFrame->IsVisible() || !m_pFileFrame->IsVisible())) { HideColorUI_Impl(); HideGradientUI_Impl(); m_pBtnPreview->Show(); m_pFileFrame->Show(); m_pBtnLink->Show(!bLinkOnly && ! nHtmlMode & HTMLMODE_ON); m_pTypeFrame->Show(); m_pPreviewWin2->Show(); m_pGraphTransFrame->Show(bGraphTransparency); m_pColTransFT->Show(sal_False); m_pColTransMF->Show(sal_False); } } void SvxBackgroundTabPage::HideBitmapUI_Impl() { m_pBtnPreview->Hide(); m_pFileFrame->Hide(); m_pTypeFrame->Hide(); m_pPreviewWin2->Hide(); m_pGraphTransFrame->Hide(); } void SvxBackgroundTabPage::ShowGradientUI_Impl() { if (!m_pBackGroundGradientFrame->IsVisible()) { HideColorUI_Impl(); HideBitmapUI_Impl(); m_pBackGroundGradientFrame->Show(); if (!m_rXFillSet.HasItem(XATTR_FILLSTYLE) || ((const XFillStyleItem&)m_rXFillSet.Get(XATTR_FILLSTYLE)).GetValue() != XFILL_GRADIENT) { // Frame has no gradient? Then select the first one, just to be able to show something in the preview control. m_pLbGradients->SelectEntryPos(0); ModifyGradientHdl_Impl(this); } else { // It has one, try to select the matching entry in the gradient list box. const XFillGradientItem& rFillGradientItem = (const XFillGradientItem&)m_rXFillSet.Get(XATTR_FILLGRADIENT); m_pLbGradients->SelectEntryByList(m_pGradientList, rFillGradientItem.GetName(), rFillGradientItem.GetGradientValue()); } } } void SvxBackgroundTabPage::HideGradientUI_Impl() { m_pBackGroundGradientFrame->Hide(); } //------------------------------------------------------------------------ void SvxBackgroundTabPage::SetGraphicPosition_Impl( SvxGraphicPosition ePos ) { switch ( ePos ) { case GPOS_AREA: { m_pBtnArea->Check(); m_pWndPosition->Disable(); } break; case GPOS_TILED: { m_pBtnTile->Check(); m_pWndPosition->Disable(); } break; default: { m_pBtnPosition->Check(); m_pWndPosition->Enable(); RECT_POINT eNewPos = RP_MM; switch ( ePos ) { case GPOS_MM: break; case GPOS_LT: eNewPos = RP_LT; break; case GPOS_MT: eNewPos = RP_MT; break; case GPOS_RT: eNewPos = RP_RT; break; case GPOS_LM: eNewPos = RP_LM; break; case GPOS_RM: eNewPos = RP_RM; break; case GPOS_LB: eNewPos = RP_LB; break; case GPOS_MB: eNewPos = RP_MB; break; case GPOS_RB: eNewPos = RP_RB; break; default: ;//prevent warning } m_pWndPosition->SetActualRP( eNewPos ); } break; } m_pWndPosition->Invalidate(); } //------------------------------------------------------------------------ SvxGraphicPosition SvxBackgroundTabPage::GetGraphicPosition_Impl() { if ( m_pBtnTile->IsChecked() ) return GPOS_TILED; else if ( m_pBtnArea->IsChecked() ) return GPOS_AREA; else { switch ( m_pWndPosition->GetActualRP() ) { case RP_LT: return GPOS_LT; case RP_MT: return GPOS_MT; case RP_RT: return GPOS_RT; case RP_LM: return GPOS_LM; case RP_MM: return GPOS_MM; case RP_RM: return GPOS_RM; case RP_LB: return GPOS_LB; case RP_MB: return GPOS_MB; case RP_RB: return GPOS_RB; } } return GPOS_MM; } //----------------------------------------------------------------------- // Handler //----------------------------------------------------------------------- IMPL_LINK_NOARG(SvxBackgroundTabPage, BackgroundColorHdl_Impl) /* Handler, called when color selection is changed */ { sal_uInt16 nItemId = m_pBackgroundColorSet->GetSelectItemId(); Color aColor = nItemId ? ( m_pBackgroundColorSet->GetItemColor( nItemId ) ) : Color( COL_TRANSPARENT ); aBgdColor = aColor; m_pPreviewWin1->NotifyChange( aBgdColor ); sal_Bool bEnableTransp = aBgdColor.GetTransparency() < 0xff; m_pColTransFT->Enable(bEnableTransp); m_pColTransMF->Enable(bEnableTransp); return 0; } //------------------------------------------------------------------------ IMPL_LINK_NOARG(SvxBackgroundTabPage, SelectHdl_Impl) { if ( XFILL_SOLID == lcl_getFillStyle(m_pLbSelect) ) { ShowColorUI_Impl(); m_pParaLBox->Enable(); // drawing background can't be a bitmap } else if ( XFILL_BITMAP == lcl_getFillStyle(m_pLbSelect) ) { ShowBitmapUI_Impl(); m_pParaLBox->Enable(sal_False); // drawing background can't be a bitmap } else { ShowGradientUI_Impl(); } return 0; } //------------------------------------------------------------------------ IMPL_LINK( SvxBackgroundTabPage, FileClickHdl_Impl, CheckBox*, pBox ) { if (m_pBtnLink == pBox) { if ( m_pBtnLink->IsChecked() ) { m_pFtUnlinked->Hide(); INetURLObject aObj( aBgdGraphicPath ); String aFilePath; if ( aObj.GetProtocol() == INET_PROT_FILE ) aFilePath = aObj.getFSysPath( INetURLObject::FSYS_DETECT ); else aFilePath = aBgdGraphicPath; m_pFtFile->SetText( aFilePath ); m_pFtFile->Show(); } else { m_pFtUnlinked->Show(); m_pFtFile->Hide(); } } else if (m_pBtnPreview == pBox) { if ( m_pBtnPreview->IsChecked() ) { if ( !bIsGraphicValid ) bIsGraphicValid = LoadLinkedGraphic_Impl(); if ( bIsGraphicValid ) { Bitmap aBmp = aBgdGraphic.GetBitmap(); m_pPreviewWin2->NotifyChange( &aBmp ); } else { if ( aBgdGraphicPath.Len() > 0 ) // only for linked bitmap RaiseLoadError_Impl(); m_pPreviewWin2->NotifyChange( NULL ); } } else m_pPreviewWin2->NotifyChange( NULL ); } return 0; } //------------------------------------------------------------------------ IMPL_LINK( SvxBackgroundTabPage, RadioClickHdl_Impl, RadioButton*, pBtn ) { if (pBtn == m_pBtnPosition) { if ( !m_pWndPosition->IsEnabled() ) { m_pWndPosition->Enable(); m_pWndPosition->Invalidate(); } } else if ( m_pWndPosition->IsEnabled() ) { m_pWndPosition->Disable(); m_pWndPosition->Invalidate(); } return 0; } IMPL_LINK_NOARG(SvxBackgroundTabPage, ModifyGradientHdl_Impl) { sal_uInt16 nPos = m_pLbGradients->GetSelectEntryPos(); if (nPos != LISTBOX_ENTRY_NOTFOUND) { XGradientEntry* pEntry = m_pGradientList->GetGradient(nPos); m_rXFillSet.Put( XFillStyleItem( XFILL_GRADIENT ) ); m_rXFillSet.Put( XFillGradientItem( pEntry->GetName(), pEntry->GetGradient() ) ); } m_pCtlPreview->SetAttributes( m_aXFillAttr.GetItemSet() ); m_pCtlPreview->Invalidate(); return 0; } //------------------------------------------------------------------------ IMPL_LINK_NOARG(SvxBackgroundTabPage, BrowseHdl_Impl) /* [Description] Handler, called by pressing the browse button. Create graphic/insert dialog, set path and start. */ { if ( pPageImpl->pLoadTimer->IsActive() ) return 0; sal_Bool bHtml = 0 != ( nHtmlMode & HTMLMODE_ON ); OUString aStrBrowse(get("findgraphicsft")->GetText()); pImportDlg = new SvxOpenGraphicDialog( aStrBrowse ); if ( bHtml || bLinkOnly ) pImportDlg->EnableLink(sal_False); pImportDlg->SetPath( aBgdGraphicPath, m_pBtnLink->IsChecked() ); pPageImpl->bIsImportDlgInExecute = sal_True; short nErr = pImportDlg->Execute(); pPageImpl->bIsImportDlgInExecute = sal_False; if( !nErr ) { if ( bHtml ) m_pBtnLink->Check(); // if link isn't checked and preview isn't, either, // activate preview, so that the user sees which // graphic he has chosen if ( !m_pBtnLink->IsChecked() && !m_pBtnPreview->IsChecked() ) m_pBtnPreview->Check( sal_True ); // timer-delayed loading of the graphic pPageImpl->pLoadTimer->Start(); } else DELETEZ( pImportDlg ); return 0; } //----------------------------------------------------------------------- IMPL_LINK( SvxBackgroundTabPage, LoadTimerHdl_Impl, Timer* , pTimer ) /* [Description] Delayed loading of the graphic. Graphic is only loaded, if it's different to the current graphic. */ { if ( pTimer == pPageImpl->pLoadTimer ) { pPageImpl->pLoadTimer->Stop(); if ( pImportDlg ) { INetURLObject aOld( aBgdGraphicPath ); INetURLObject aNew( pImportDlg->GetPath() ); if ( !aBgdGraphicPath.Len() || aNew != aOld ) { // new file chosen aBgdGraphicPath = pImportDlg->GetPath(); aBgdGraphicFilter = pImportDlg->GetCurrentFilter(); sal_Bool bLink = ( nHtmlMode & HTMLMODE_ON ) || bLinkOnly ? sal_True : pImportDlg->IsAsLink(); m_pBtnLink->Check( bLink ); m_pBtnLink->Enable(); if ( m_pBtnPreview->IsChecked() ) { if( !pImportDlg->GetGraphic(aBgdGraphic) ) { bIsGraphicValid = sal_True; } else { aBgdGraphicFilter.Erase(); aBgdGraphicPath.Erase(); bIsGraphicValid = sal_False; } } else bIsGraphicValid = sal_False; // load graphic not until preview click if ( m_pBtnPreview->IsChecked() && bIsGraphicValid ) { Bitmap aBmp = aBgdGraphic.GetBitmap(); m_pPreviewWin2->NotifyChange( &aBmp ); } else m_pPreviewWin2->NotifyChange( NULL ); } FileClickHdl_Impl(m_pBtnLink); DELETEZ( pImportDlg ); } } return 0; } //----------------------------------------------------------------------- void SvxBackgroundTabPage::ShowTblControl() { m_pTblLBox->SetSelectHdl( HDL(TblDestinationHdl_Impl) ); m_pTblLBox->SelectEntryPos(0); m_pTblDesc->Show(); m_pTblLBox->Show(); m_pAsGrid->Show(); } //----------------------------------------------------------------------- void SvxBackgroundTabPage::ShowParaControl(sal_Bool bCharOnly) { m_pParaLBox->SetSelectHdl(HDL(ParaDestinationHdl_Impl)); m_pParaLBox->SelectEntryPos(0); if (!bCharOnly) { m_pTblDesc->Show(); m_pParaLBox->Show(); m_pAsGrid->Show(); } m_pParaLBox->SetData(m_pParaLBox); // here it can be recognized that this mode is turned on } //----------------------------------------------------------------------- IMPL_LINK( SvxBackgroundTabPage, TblDestinationHdl_Impl, ListBox*, pBox ) { sal_uInt16 nSelPos = pBox->GetSelectEntryPos(); if( pTableBck_Impl && pTableBck_Impl->nActPos != nSelPos) { SvxBrushItem** pActItem = new (SvxBrushItem*); sal_uInt16 nWhich = 0; switch(pTableBck_Impl->nActPos) { case TBL_DEST_CELL: *pActItem = pTableBck_Impl->pCellBrush; nWhich = pTableBck_Impl->nCellWhich; break; case TBL_DEST_ROW: *pActItem = pTableBck_Impl->pRowBrush; nWhich = pTableBck_Impl->nRowWhich; break; case TBL_DEST_TBL: *pActItem = pTableBck_Impl->pTableBrush; nWhich = pTableBck_Impl->nTableWhich; break; } pTableBck_Impl->nActPos = nSelPos; if(!*pActItem) *pActItem = new SvxBrushItem(nWhich); if(XFILL_SOLID == lcl_getFillStyle(m_pLbSelect)) // brush selected { **pActItem = SvxBrushItem( aBgdColor, nWhich ); } else { SvxGraphicPosition eNewPos = GetGraphicPosition_Impl(); const sal_Bool bIsLink = m_pBtnLink->IsChecked(); if ( !bIsLink && !bIsGraphicValid ) bIsGraphicValid = LoadLinkedGraphic_Impl(); if ( bIsLink ) **pActItem = SvxBrushItem( aBgdGraphicPath, aBgdGraphicFilter, eNewPos, (*pActItem)->Which() ); else **pActItem = SvxBrushItem( aBgdGraphic, eNewPos, (*pActItem)->Which() ); } switch(nSelPos) { case TBL_DEST_CELL: *pActItem = pTableBck_Impl->pCellBrush; m_pLbSelect->Enable(); nWhich = pTableBck_Impl->nCellWhich; break; case TBL_DEST_ROW: { if((nHtmlMode & HTMLMODE_ON) && !(nHtmlMode & HTMLMODE_SOME_STYLES)) m_pLbSelect->Disable(); *pActItem = pTableBck_Impl->pRowBrush; nWhich = pTableBck_Impl->nRowWhich; } break; case TBL_DEST_TBL: *pActItem = pTableBck_Impl->pTableBrush; m_pLbSelect->Enable(); nWhich = pTableBck_Impl->nTableWhich; break; } String aUserData = GetUserData(); if(!*pActItem) *pActItem = new SvxBrushItem(nWhich); FillControls_Impl(**pActItem, aUserData); delete pActItem; } return 0; } //----------------------------------------------------------------------- IMPL_LINK( SvxBackgroundTabPage, ParaDestinationHdl_Impl, ListBox*, pBox ) { sal_uInt16 nSelPos = pBox->GetSelectEntryPos(); if( pParaBck_Impl && pParaBck_Impl->nActPos != nSelPos) { SvxBrushItem** pActItem = new (SvxBrushItem*); switch(pParaBck_Impl->nActPos) { case PARA_DEST_PARA: *pActItem = pParaBck_Impl->pParaBrush; break; case PARA_DEST_CHAR: *pActItem = pParaBck_Impl->pCharBrush; break; } pParaBck_Impl->nActPos = nSelPos; if(XFILL_SOLID == lcl_getFillStyle(m_pLbSelect)) // brush selected { sal_uInt16 nWhich = (*pActItem)->Which(); **pActItem = SvxBrushItem( aBgdColor, nWhich ); } else { SvxGraphicPosition eNewPos = GetGraphicPosition_Impl(); const sal_Bool bIsLink = m_pBtnLink->IsChecked(); if ( !bIsLink && !bIsGraphicValid ) bIsGraphicValid = LoadLinkedGraphic_Impl(); if ( bIsLink ) **pActItem = SvxBrushItem( aBgdGraphicPath, aBgdGraphicFilter, eNewPos, (*pActItem)->Which() ); else **pActItem = SvxBrushItem( aBgdGraphic, eNewPos, (*pActItem)->Which() ); } switch(nSelPos) { case PARA_DEST_PARA: *pActItem = pParaBck_Impl->pParaBrush; m_pLbSelect->Enable(); break; case PARA_DEST_CHAR: { *pActItem = pParaBck_Impl->pCharBrush; m_pLbSelect->Enable(sal_False); } break; } String aUserData = GetUserData(); FillControls_Impl(**pActItem, aUserData); delete pActItem; } return 0; } //----------------------------------------------------------------------- void SvxBackgroundTabPage::FillControls_Impl( const SvxBrushItem& rBgdAttr, const String& rUserData ) { SvxGraphicPosition ePos = rBgdAttr.GetGraphicPos(); const Color& rColor = rBgdAttr.GetColor(); if(bColTransparency) { m_pColTransMF->SetValue(lcl_TransparencyToPercent(rColor.GetTransparency())); m_pColTransMF->SaveValue(); sal_Bool bEnableTransp = rColor.GetTransparency() < 0xff; m_pColTransFT->Enable(bEnableTransp); m_pColTransMF->Enable(bEnableTransp); //the default setting should be "no transparency" if(!bEnableTransp) m_pColTransMF->SetValue(0); } if ( GPOS_NONE == ePos || !m_pLbSelect->IsVisible() ) { // We don't have a graphic, do we have gradient fill style? if (!m_rXFillSet.HasItem(XATTR_FILLSTYLE) || ((const XFillStyleItem&)m_rXFillSet.Get(XATTR_FILLSTYLE)).GetValue() != XFILL_GRADIENT) { lcl_setFillStyle(m_pLbSelect, XFILL_SOLID); ShowColorUI_Impl(); Color aTrColor( COL_TRANSPARENT ); aBgdColor = rColor; sal_uInt16 nCol = ( aTrColor != aBgdColor ) ? GetItemId_Impl(*m_pBackgroundColorSet, aBgdColor) : 0; if( aTrColor != aBgdColor && nCol == 0) { m_pBackgroundColorSet->SetNoSelection(); } else { m_pBackgroundColorSet->SelectItem( nCol ); } m_pPreviewWin1->NotifyChange( aBgdColor ); } else { // Gradient fill style, then initialize preview with data from Writer. lcl_setFillStyle(m_pLbSelect, XFILL_GRADIENT); ShowGradientUI_Impl(); m_pCtlPreview->SetAttributes( m_aXFillAttr.GetItemSet() ); m_pCtlPreview->Invalidate(); } if ( m_pLbSelect->IsVisible() ) // initialize graphic part { aBgdGraphicFilter.Erase(); aBgdGraphicPath.Erase(); if ( !rUserData.Len() ) m_pBtnPreview->Check( sal_False ); m_pBtnLink->Check( sal_False ); m_pBtnLink->Disable(); m_pPreviewWin2->NotifyChange( NULL ); SetGraphicPosition_Impl( GPOS_TILED ); // tiles as default } } else { const String* pStrLink = rBgdAttr.GetGraphicLink(); const String* pStrFilter = rBgdAttr.GetGraphicFilter(); lcl_setFillStyle(m_pLbSelect, XFILL_BITMAP); ShowBitmapUI_Impl(); if ( pStrLink ) { #ifdef DBG_UTIL INetURLObject aObj( *pStrLink ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); #endif aBgdGraphicPath = *pStrLink; m_pBtnLink->Check( sal_True ); m_pBtnLink->Enable(); } else { aBgdGraphicPath.Erase(); m_pBtnLink->Check( sal_False ); m_pBtnLink->Disable(); } if(bGraphTransparency) { const GraphicObject* pObject = rBgdAttr.GetGraphicObject(); if(pObject) m_pGraphTransMF->SetValue(lcl_TransparencyToPercent(pObject->GetAttr().GetTransparency())); else m_pGraphTransMF->SetValue(0); m_pGraphTransMF->SaveValue(); } FileClickHdl_Impl(m_pBtnLink); if ( pStrFilter ) aBgdGraphicFilter = *pStrFilter; else aBgdGraphicFilter.Erase(); if ( !pStrLink || m_pBtnPreview->IsChecked() ) { // Graphic exists in the item and doesn't have // to be loaded: const Graphic* pGraphic = rBgdAttr.GetGraphic(); if ( !pGraphic && m_pBtnPreview->IsChecked() ) bIsGraphicValid = LoadLinkedGraphic_Impl(); else if ( pGraphic ) { aBgdGraphic = *pGraphic; bIsGraphicValid = sal_True; if ( !rUserData.Len() ) m_pBtnPreview->Check(); } else { RaiseLoadError_Impl(); bIsGraphicValid = sal_False; if ( !rUserData.Len() ) m_pBtnPreview->Check( sal_False ); } } if ( m_pBtnPreview->IsChecked() && bIsGraphicValid ) { Bitmap aBmp = aBgdGraphic.GetBitmap(); m_pPreviewWin2->NotifyChange( &aBmp ); } else m_pPreviewWin2->NotifyChange( NULL ); SetGraphicPosition_Impl( ePos ); } } void SvxBackgroundTabPage::EnableTransparency(sal_Bool bColor, sal_Bool bGraphic) { bColTransparency = bColor; bGraphTransparency = bGraphic; m_pColTransFT->Show(bColor); m_pColTransMF->Show(bColor); } void SvxBackgroundTabPage::PageCreated (SfxAllItemSet aSet) { SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False); SFX_ITEMSET_ARG (&aSet,pGradientListItem,SvxGradientListItem,SID_GRADIENT_LIST,sal_False); if (pFlagItem) { sal_uInt32 nFlags=pFlagItem->GetValue(); if ( ( nFlags & SVX_SHOW_TBLCTL ) == SVX_SHOW_TBLCTL ) ShowTblControl(); if ( ( nFlags & SVX_SHOW_PARACTL ) == SVX_SHOW_PARACTL ) ShowParaControl(); if ( ( nFlags & SVX_SHOW_SELECTOR ) == SVX_SHOW_SELECTOR ) ShowSelector(); if ( ( nFlags & SVX_ENABLE_TRANSPARENCY ) == SVX_ENABLE_TRANSPARENCY ) EnableTransparency(sal_True, sal_True); } if (pGradientListItem) { // If we get a gradient list, also read fill and gradient style. m_pGradientList = pGradientListItem->GetGradientList(); m_pLbGradients->Fill(m_pGradientList); const XFillStyleItem& rFillStyleItem = (const XFillStyleItem&)aSet.Get(SID_ATTR_FILL_STYLE); m_rXFillSet.Put(XFillStyleItem(rFillStyleItem.GetValue())); const XFillGradientItem& rFillGradientItem = (const XFillGradientItem&)aSet.Get(SID_ATTR_FILL_GRADIENT); m_rXFillSet.Put(XFillGradientItem(rFillGradientItem.GetName(), rFillGradientItem.GetGradientValue())); } else // Otherwise hide the gradient UI. for (int i = 0; i < m_pLbSelect->GetEntryCount(); ++i) if ((XFillStyle)(sal_uLong)m_pLbSelect->GetEntryData(i) == XFILL_GRADIENT) { m_pLbSelect->RemoveEntry(i); break; } } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */