| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_sd.hxx" | |
| #include "sddll.hxx" | |
| #include <com/sun/star/beans/XMultiPropertyStates.hpp> | |
| #include <com/sun/star/frame/XController.hpp> | |
| #include <com/sun/star/view/XSelectionSupplier.hpp> | |
| #include <com/sun/star/style/XStyle.hpp> | |
| #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> | |
| #include <comphelper/processfactory.hxx> | |
| #include <sfx2/viewfrm.hxx> | |
| #include <vcl/bmpacc.hxx> | |
| #include <svl/style.hxx> | |
| #include <sfx2/viewfrm.hxx> | |
| #include <sfx2/bindings.hxx> | |
| #include <sfx2/app.hxx> | |
| #include <sfx2/request.hxx> | |
| #include <sfx2/dispatch.hxx> | |
| #include <svx/svxids.hrc> | |
| #include <svx/svdetc.hxx> | |
| #include <editeng/boxitem.hxx> | |
| #include <editeng/borderline.hxx> | |
| #include <editeng/colritem.hxx> | |
| #include <editeng/eeitem.hxx> | |
| #include <svx/sdr/table/tabledesign.hxx> | |
| #include "TableDesignPane.hxx" | |
| #include "DrawDocShell.hxx" | |
| #include "ViewShellBase.hxx" | |
| #include "DrawViewShell.hxx" | |
| #include "DrawController.hxx" | |
| #include "glob.hrc" | |
| #include "sdresid.hxx" | |
| #include "EventMultiplexer.hxx" | |
| #define C2U(x) OUString( RTL_CONSTASCII_USTRINGPARAM( x ) ) | |
| using ::rtl::OUString; | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::drawing; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::view; | |
| using namespace ::com::sun::star::style; | |
| using namespace ::com::sun::star::frame; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::ui; | |
| namespace sd { | |
| static const sal_Int32 nPreviewColumns = 5; | |
| static const sal_Int32 nPreviewRows = 5; | |
| // -------------------------------------------------------------------- | |
| static const OUString* getPropertyNames() | |
| { | |
| static const OUString gPropNames[ CB_BANDED_COLUMNS-CB_HEADER_ROW+1 ] = | |
| { | |
| C2U( "UseFirstRowStyle" ), | |
| C2U( "UseLastRowStyle" ), | |
| C2U( "UseBandingRowStyle" ), | |
| C2U( "UseFirstColumnStyle" ), | |
| C2U( "UseLastColumnStyle" ), | |
| C2U( "UseBandingColumnStyle" ) | |
| }; | |
| return &gPropNames[0]; | |
| } | |
| // -------------------------------------------------------------------- | |
| TableDesignPane::TableDesignPane( ::Window* pParent, ViewShellBase& rBase, bool bModal ) | |
| : Control( pParent, SdResId(DLG_TABLEDESIGNPANE) ) | |
| , mrBase( rBase ) | |
| , msTableTemplate( RTL_CONSTASCII_USTRINGPARAM( "TableTemplate" ) ) | |
| , mbModal( bModal ) | |
| , mbStyleSelected( false ) | |
| , mbOptionsChanged( false ) | |
| { | |
| Window* pControlParent = mbModal ? pParent : this; | |
| // mxControls[FL_TABLE_STYLES].reset( new FixedLine( pControlParent, SdResId( FL_TABLE_STYLES + 1 ) ) ); | |
| ValueSet* pValueSet = new ValueSet( pControlParent, SdResId( CT_TABLE_STYLES+1 ) ); | |
| mxControls[CT_TABLE_STYLES].reset( pValueSet ); | |
| if( !mbModal ) | |
| { | |
| pValueSet->SetStyle( (pValueSet->GetStyle() & ~(WB_ITEMBORDER|WB_BORDER)) | WB_NO_DIRECTSELECT | WB_FLATVALUESET | WB_NOBORDER ); | |
| pValueSet->SetColor(); | |
| pValueSet->SetExtraSpacing(8); | |
| } | |
| else | |
| { | |
| pValueSet->SetColor( Color( COL_WHITE ) ); | |
| pValueSet->SetBackground( Color( COL_WHITE ) ); | |
| } | |
| pValueSet->SetSelectHdl (LINK(this, TableDesignPane, implValueSetHdl)); | |
| // mxControls[FL_STYLE_OPTIONS].reset( new FixedLine( pControlParent, SdResId( FL_STYLE_OPTIONS + 1 ) ) ); | |
| sal_uInt16 i; | |
| for( i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i ) | |
| { | |
| CheckBox *pCheckBox = new CheckBox( pControlParent, SdResId( i+1 ) ); | |
| mxControls[i].reset( pCheckBox ); | |
| pCheckBox->SetClickHdl( LINK( this, TableDesignPane, implCheckBoxHdl ) ); | |
| } | |
| for( i = 0; i < DESIGNPANE_CONTROL_COUNT; i++ ) | |
| { | |
| if (mxControls[i]) | |
| mnOrgOffsetY[i] = mxControls[i]->GetPosPixel().Y(); | |
| else if (i > 0) | |
| mnOrgOffsetY[i] = mnOrgOffsetY[i-1]; | |
| else | |
| mnOrgOffsetY[i] = 0; | |
| } | |
| // get current controller and initialize listeners | |
| try | |
| { | |
| mxView = Reference< XDrawView >::query(mrBase.GetController()); | |
| addListener(); | |
| Reference< XController > xController( mrBase.GetController(), UNO_QUERY_THROW ); | |
| Reference< XStyleFamiliesSupplier > xFamiliesSupp( xController->getModel(), UNO_QUERY_THROW ); | |
| Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() ); | |
| const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM("table" ) ); | |
| mxTableFamily = Reference< XIndexAccess >( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW ); | |
| } | |
| catch( Exception& e ) | |
| { | |
| (void)e; | |
| DBG_ERROR( "sd::CustomAnimationPane::CustomAnimationPane(), Exception caught!" ); | |
| } | |
| onSelectionChanged(); | |
| updateControls(); | |
| FreeResource(); | |
| } | |
| // -------------------------------------------------------------------- | |
| TableDesignPane::~TableDesignPane() | |
| { | |
| removeListener(); | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::DataChanged( const DataChangedEvent& /*rDCEvt*/ ) | |
| { | |
| updateLayout(); | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::Resize() | |
| { | |
| updateLayout(); | |
| } | |
| LayoutSize TableDesignPane::GetHeightForWidth (const sal_Int32 nWidth) | |
| { | |
| if ( ! IsVisible() || nWidth<=0) | |
| return LayoutSize(0,0,0); | |
| // Initialize the height with the offset above and below the value | |
| // set and below the check boxes. | |
| const Point aOffset (LogicToPixel( Point(3,3), MAP_APPFONT)); | |
| sal_Int32 nHeight (3 * aOffset.Y()); | |
| // Add the height for the check boxes. | |
| nHeight += mnOrgOffsetY[CB_BANDED_COLUMNS] - mnOrgOffsetY[CB_HEADER_ROW] | |
| + mxControls[CB_BANDED_COLUMNS]->GetSizePixel().Height(); | |
| // Setup minimal and maximal heights that include all check boxes | |
| // and a small or large value set. | |
| const sal_Int32 nMinimalHeight (nHeight+100); | |
| const sal_Int32 nMaximalHeight (nHeight+450); | |
| // Calculate the number of rows and columns and then add the | |
| // preferred size of the value set. | |
| ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() ); | |
| if (pValueSet->GetItemCount() > 0) | |
| { | |
| Image aImage = pValueSet->GetItemImage(pValueSet->GetItemId(0)); | |
| Size aItemSize = pValueSet->CalcItemSizePixel(aImage.GetSizePixel()); | |
| aItemSize.Width() += 10; | |
| aItemSize.Height() += 10; | |
| int nColumnCount = (pValueSet->GetSizePixel().Width() - pValueSet->GetScrollWidth()) / aItemSize.Width(); | |
| if (nColumnCount < 1) | |
| nColumnCount = 1; | |
| int nRowCount = (pValueSet->GetItemCount() + nColumnCount - 1) / nColumnCount; | |
| if (nRowCount < 1) | |
| nRowCount = 1; | |
| nHeight += nRowCount * aItemSize.Height(); | |
| } | |
| // Clip the requested height. | |
| if (nHeight<nMinimalHeight) | |
| nHeight = nMinimalHeight; | |
| else if (nHeight>nMaximalHeight) | |
| nHeight = nMaximalHeight; | |
| return LayoutSize(nMinimalHeight, nMaximalHeight, nHeight); | |
| } | |
| // -------------------------------------------------------------------- | |
| static SfxBindings* getBindings( ViewShellBase& rBase ) | |
| { | |
| if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() ) | |
| return &rBase.GetMainViewShell()->GetViewFrame()->GetBindings(); | |
| else | |
| return 0; | |
| } | |
| // -------------------------------------------------------------------- | |
| static SfxDispatcher* getDispatcher( ViewShellBase& rBase ) | |
| { | |
| if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() ) | |
| return rBase.GetMainViewShell()->GetViewFrame()->GetDispatcher(); | |
| else | |
| return 0; | |
| } | |
| // -------------------------------------------------------------------- | |
| IMPL_LINK( TableDesignPane, implValueSetHdl, Control*, EMPTYARG ) | |
| { | |
| mbStyleSelected = true; | |
| if( !mbModal ) | |
| ApplyStyle(); | |
| return 0; | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::ApplyStyle() | |
| { | |
| try | |
| { | |
| OUString sStyleName; | |
| ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() ); | |
| sal_Int32 nIndex = static_cast< sal_Int32 >( pValueSet->GetSelectItemId() ) - 1; | |
| if( (nIndex >= 0) && (nIndex < mxTableFamily->getCount()) ) | |
| { | |
| Reference< XNameAccess > xNames( mxTableFamily, UNO_QUERY_THROW ); | |
| sStyleName = xNames->getElementNames()[nIndex]; | |
| } | |
| if( sStyleName.getLength() == 0 ) | |
| return; | |
| SdrView* pView = mrBase.GetDrawView(); | |
| if( mxSelectedTable.is() ) | |
| { | |
| if( pView ) | |
| { | |
| SfxRequest aReq( SID_TABLE_STYLE, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool() ); | |
| aReq.AppendItem( SfxStringItem( SID_TABLE_STYLE, sStyleName ) ); | |
| rtl::Reference< sdr::SelectionController > xController( pView->getSelectionController() ); | |
| if( xController.is() ) | |
| xController->Execute( aReq ); | |
| SfxBindings* pBindings = getBindings( mrBase ); | |
| if( pBindings ) | |
| { | |
| pBindings->Invalidate( SID_UNDO ); | |
| pBindings->Invalidate( SID_REDO ); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| SfxDispatcher* pDispatcher = getDispatcher( mrBase ); | |
| SfxStringItem aArg( SID_TABLE_STYLE, sStyleName ); | |
| pDispatcher->Execute(SID_INSERT_TABLE, SFX_CALLMODE_ASYNCHRON, &aArg, 0 ); | |
| } | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_ERROR("TableDesignPane::implValueSetHdl(), exception caught!"); | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| IMPL_LINK( TableDesignPane, implCheckBoxHdl, Control*, EMPTYARG ) | |
| { | |
| mbOptionsChanged = true; | |
| if( !mbModal ) | |
| ApplyOptions(); | |
| FillDesignPreviewControl(); | |
| return 0; | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::ApplyOptions() | |
| { | |
| static sal_uInt16 gParamIds[CB_BANDED_COLUMNS-CB_HEADER_ROW+1] = | |
| { | |
| ID_VAL_USEFIRSTROWSTYLE, ID_VAL_USELASTROWSTYLE, ID_VAL_USEBANDINGROWSTYLE, | |
| ID_VAL_USEFIRSTCOLUMNSTYLE, ID_VAL_USELASTCOLUMNSTYLE, ID_VAL_USEBANDINGCOLUMNSTYLE | |
| }; | |
| if( mxSelectedTable.is() ) | |
| { | |
| SfxRequest aReq( SID_TABLE_STYLE_SETTINGS, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool() ); | |
| for( sal_uInt16 i = 0; i < (CB_BANDED_COLUMNS-CB_HEADER_ROW+1); ++i ) | |
| { | |
| aReq.AppendItem( SfxBoolItem( gParamIds[i], static_cast< CheckBox* >( mxControls[CB_HEADER_ROW+i].get() )->IsChecked() ) ); | |
| } | |
| SdrView* pView = mrBase.GetDrawView(); | |
| if( pView ) | |
| { | |
| rtl::Reference< sdr::SelectionController > xController( pView->getSelectionController() ); | |
| if( xController.is() ) | |
| { | |
| xController->Execute( aReq ); | |
| SfxBindings* pBindings = getBindings( mrBase ); | |
| if( pBindings ) | |
| { | |
| pBindings->Invalidate( SID_UNDO ); | |
| pBindings->Invalidate( SID_REDO ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::onSelectionChanged() | |
| { | |
| Reference< XPropertySet > xNewSelection; | |
| if( mxView.is() ) try | |
| { | |
| Reference< XSelectionSupplier > xSel( mxView, UNO_QUERY_THROW ); | |
| if (xSel.is()) | |
| { | |
| Any aSel( xSel->getSelection() ); | |
| Sequence< XShape > xShapeSeq; | |
| if( aSel >>= xShapeSeq ) | |
| { | |
| if( xShapeSeq.getLength() == 1 ) | |
| aSel <<= xShapeSeq[0]; | |
| } | |
| else | |
| { | |
| Reference< XShapes > xShapes( aSel, UNO_QUERY ); | |
| if( xShapes.is() && (xShapes->getCount() == 1) ) | |
| aSel <<= xShapes->getByIndex(0); | |
| } | |
| Reference< XShapeDescriptor > xDesc( aSel, UNO_QUERY ); | |
| if( xDesc.is() && | |
| ( xDesc->getShapeType().equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.TableShape" ) ) || | |
| xDesc->getShapeType().equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.presentation.TableShape" ) ) ) ) | |
| { | |
| xNewSelection = Reference< XPropertySet >::query( xDesc ); | |
| } | |
| } | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_ERROR( "sd::TableDesignPane::onSelectionChanged(), Exception caught!" ); | |
| } | |
| if( mxSelectedTable != xNewSelection ) | |
| { | |
| mxSelectedTable = xNewSelection; | |
| updateControls(); | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::updateLayout() | |
| { | |
| ::Size aPaneSize( GetSizePixel() ); | |
| if(IsVisible() && aPaneSize.Width() > 0) | |
| { | |
| Point aOffset( LogicToPixel( Point(3,3), MAP_APPFONT ) ); | |
| ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() ); | |
| Size aValueSetSize; | |
| if( !mbModal ) | |
| { | |
| const long nOptionsHeight = mnOrgOffsetY[CB_BANDED_COLUMNS] + mxControls[CB_BANDED_COLUMNS]->GetSizePixel().Height() + aOffset.Y(); | |
| const long nStylesHeight = aPaneSize.Height() - nOptionsHeight; | |
| // set width of controls to size of pane | |
| for( sal_Int32 nId = 0; nId < DESIGNPANE_CONTROL_COUNT; ++nId ) | |
| { | |
| if (mxControls[nId]) | |
| { | |
| Size aSize( mxControls[nId]->GetSizePixel() ); | |
| aSize.Width() = aPaneSize.Width() - aOffset.X() - mxControls[nId]->GetPosPixel().X(); | |
| mxControls[nId]->SetSizePixel( aSize ); | |
| mxControls[nId]->SetPaintTransparent(sal_True); | |
| mxControls[nId]->SetBackground(); | |
| } | |
| } | |
| aValueSetSize = Size( pValueSet->GetSizePixel().Width(), nStylesHeight ); | |
| } | |
| else | |
| { | |
| aValueSetSize = pValueSet->GetSizePixel(); | |
| } | |
| // Calculate the number of rows and columns. | |
| if( pValueSet->GetItemCount() > 0 ) | |
| { | |
| Image aImage = pValueSet->GetItemImage(pValueSet->GetItemId(0)); | |
| Size aItemSize = pValueSet->CalcItemSizePixel(aImage.GetSizePixel()); | |
| pValueSet->SetItemWidth( aItemSize.Width() ); | |
| pValueSet->SetItemHeight( aItemSize.Height() ); | |
| aItemSize.Width() += 10; | |
| aItemSize.Height() += 10; | |
| int nColumnCount = (aValueSetSize.Width() - pValueSet->GetScrollWidth()) / aItemSize.Width(); | |
| if (nColumnCount < 1) | |
| nColumnCount = 1; | |
| int nRowCount = (pValueSet->GetItemCount() + nColumnCount - 1) / nColumnCount; | |
| if (nRowCount < 1) | |
| nRowCount = 1; | |
| int nVisibleRowCount = (aValueSetSize.Height()+2) / aItemSize.Height(); | |
| pValueSet->SetLineCount ( (nRowCount < nVisibleRowCount) ? (sal_uInt16)nRowCount : 0 ); | |
| pValueSet->SetColCount ((sal_uInt16)nColumnCount); | |
| pValueSet->SetLineCount ((sal_uInt16)nRowCount); | |
| if( !mbModal ) | |
| { | |
| WinBits nStyle = pValueSet->GetStyle() & ~(WB_VSCROLL); | |
| if( nRowCount < nVisibleRowCount ) | |
| { | |
| aValueSetSize.Height() = nRowCount * aItemSize.Height(); | |
| } | |
| else if( nRowCount > nVisibleRowCount ) | |
| { | |
| nStyle |= WB_VSCROLL; | |
| } | |
| pValueSet->SetStyle( nStyle ); | |
| } | |
| } | |
| if( !mbModal ) | |
| { | |
| pValueSet->SetSizePixel( aValueSetSize ); | |
| pValueSet->SetBackground( GetSettings().GetStyleSettings().GetWindowColor() ); | |
| pValueSet->SetColor( GetSettings().GetStyleSettings().GetWindowColor() ); | |
| Point aPos( pValueSet->GetPosPixel() ); | |
| // The following line may look like a no-op but without it the | |
| // control is placed off-screen when RTL is active. | |
| pValueSet->SetPosPixel(pValueSet->GetPosPixel()); | |
| // shift show options section down | |
| const long nOptionsPos = aPos.Y() + aValueSetSize.Height(); | |
| sal_Int32 nMaxY (0); | |
| for( sal_Int32 nId = FL_STYLE_OPTIONS+1; nId <= CB_BANDED_COLUMNS; ++nId ) | |
| { | |
| if (mxControls[nId]) | |
| { | |
| Point aCPos( mxControls[nId]->GetPosPixel() ); | |
| aCPos.X() = ( nId == FL_STYLE_OPTIONS ? 1 : 2 ) * aOffset.X(); | |
| aCPos.Y() = mnOrgOffsetY[nId] + nOptionsPos; | |
| mxControls[nId]->SetPosPixel( aCPos ); | |
| const sal_Int32 nBottom (aCPos.Y() + mxControls[nId]->GetSizePixel().Height()); | |
| if (nBottom > nMaxY) | |
| nMaxY = nBottom; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::updateControls() | |
| { | |
| static sal_Bool gDefaults[CB_BANDED_COLUMNS-CB_HEADER_ROW+1] = { sal_True, sal_False, sal_True, sal_False, sal_False, sal_False }; | |
| const bool bHasTable = mxSelectedTable.is(); | |
| const OUString* pPropNames = getPropertyNames(); | |
| for( sal_uInt16 i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i ) | |
| { | |
| sal_Bool bUse = gDefaults[i-CB_HEADER_ROW]; | |
| if( bHasTable ) try | |
| { | |
| mxSelectedTable->getPropertyValue( *pPropNames++ ) >>= bUse; | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_ERROR("sd::TableDesignPane::updateControls(), exception caught!"); | |
| } | |
| static_cast< CheckBox* >( mxControls[i].get() )->Check( bUse ? sal_True : sal_False ); | |
| mxControls[i]->Enable(bHasTable ? sal_True : sal_False ); | |
| } | |
| FillDesignPreviewControl(); | |
| updateLayout(); | |
| sal_uInt16 nSelection = 0; | |
| if( mxSelectedTable.is() ) | |
| { | |
| Reference< XNamed > xNamed( mxSelectedTable->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TableTemplate" ) ) ), UNO_QUERY ); | |
| if( xNamed.is() ) | |
| { | |
| const OUString sStyleName( xNamed->getName() ); | |
| Reference< XNameAccess > xNames( mxTableFamily, UNO_QUERY ); | |
| if( xNames.is() ) | |
| { | |
| Sequence< OUString > aNames( xNames->getElementNames() ); | |
| for( sal_Int32 nIndex = 0; nIndex < aNames.getLength(); nIndex++ ) | |
| { | |
| if( aNames[nIndex] == sStyleName ) | |
| { | |
| nSelection = (sal_uInt16)nIndex+1; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() ); | |
| pValueSet->SelectItem( nSelection ); | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::addListener() | |
| { | |
| Link aLink( LINK(this,TableDesignPane,EventMultiplexerListener) ); | |
| mrBase.GetEventMultiplexer()->AddEventListener ( | |
| aLink, | |
| tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION | |
| | tools::EventMultiplexerEvent::EID_CURRENT_PAGE | |
| | tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED | |
| | tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED | |
| | tools::EventMultiplexerEvent::EID_DISPOSING); | |
| } | |
| // -------------------------------------------------------------------- | |
| void TableDesignPane::removeListener() | |
| { | |
| Link aLink( LINK(this,TableDesignPane,EventMultiplexerListener) ); | |
| mrBase.GetEventMultiplexer()->RemoveEventListener( aLink ); | |
| } | |
| // -------------------------------------------------------------------- | |
| IMPL_LINK(TableDesignPane,EventMultiplexerListener, | |
| tools::EventMultiplexerEvent*,pEvent) | |
| { | |
| switch (pEvent->meEventId) | |
| { | |
| case tools::EventMultiplexerEvent::EID_CURRENT_PAGE: | |
| case tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION: | |
| onSelectionChanged(); | |
| break; | |
| case tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED: | |
| mxView = Reference<XDrawView>(); | |
| onSelectionChanged(); | |
| break; | |
| case tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED: | |
| mxView = Reference<XDrawView>::query( mrBase.GetController() ); | |
| onSelectionChanged(); | |
| break; | |
| } | |
| return 0; | |
| } | |
| // -------------------------------------------------------------------- | |
| struct CellInfo | |
| { | |
| Color maCellColor; | |
| Color maTextColor; | |
| SvxBoxItem maBorder; | |
| explicit CellInfo( const Reference< XStyle >& xStyle ); | |
| }; | |
| CellInfo::CellInfo( const Reference< XStyle >& xStyle ) | |
| : maBorder(SDRATTR_TABLE_BORDER) | |
| { | |
| SfxStyleSheet* pStyleSheet = SfxUnoStyleSheet::getUnoStyleSheet( xStyle ); | |
| if( pStyleSheet ) | |
| { | |
| SfxItemSet& rSet = pStyleSheet->GetItemSet(); | |
| // get style fill color | |
| if( !GetDraftFillColor(rSet, maCellColor) ) | |
| maCellColor.SetColor( COL_TRANSPARENT ); | |
| // get style text color | |
| const SvxColorItem* pTextColor = dynamic_cast<const SvxColorItem*>( rSet.GetItem(EE_CHAR_COLOR) ); | |
| if( pTextColor ) | |
| maTextColor = pTextColor->GetValue(); | |
| else | |
| maTextColor.SetColor( COL_TRANSPARENT ); | |
| // get border | |
| const SvxBoxItem* pBoxItem = dynamic_cast<const SvxBoxItem*>(rSet.GetItem( SDRATTR_TABLE_BORDER ) ); | |
| if( pBoxItem ) | |
| maBorder = *pBoxItem; | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| typedef std::vector< boost::shared_ptr< CellInfo > > CellInfoVector; | |
| typedef boost::shared_ptr< CellInfo > CellInfoMatrix[nPreviewColumns][nPreviewRows]; | |
| struct TableStyleSettings | |
| { | |
| bool mbUseFirstRow; | |
| bool mbUseLastRow; | |
| bool mbUseFirstColumn; | |
| bool mbUseLastColumn; | |
| bool mbUseRowBanding; | |
| bool mbUseColumnBanding; | |
| TableStyleSettings() | |
| : mbUseFirstRow(true) | |
| , mbUseLastRow(false) | |
| , mbUseFirstColumn(false) | |
| , mbUseLastColumn(false) | |
| , mbUseRowBanding(true) | |
| , mbUseColumnBanding(false) {} | |
| }; | |
| // -------------------------------------------------------------------- | |
| static void FillCellInfoVector( const Reference< XIndexAccess >& xTableStyle, CellInfoVector& rVector ) | |
| { | |
| DBG_ASSERT( xTableStyle.is() && (xTableStyle->getCount() == sdr::table::style_count ), "sd::FillCellInfoVector(), invalid table style!" ); | |
| if( xTableStyle.is() ) try | |
| { | |
| rVector.resize( sdr::table::style_count ); | |
| for( sal_Int32 nStyle = 0; nStyle < sdr::table::style_count; ++nStyle ) | |
| { | |
| Reference< XStyle > xStyle( xTableStyle->getByIndex( nStyle ), UNO_QUERY ); | |
| if( xStyle.is() ) | |
| rVector[nStyle].reset( new CellInfo( xStyle ) ); | |
| } | |
| } | |
| catch(Exception&) | |
| { | |
| DBG_ERROR("sd::FillCellInfoVector(), exception caught!"); | |
| } | |
| } | |
| static void FillCellInfoMatrix( const CellInfoVector& rStyle, const TableStyleSettings& rSettings, CellInfoMatrix& rMatrix ) | |
| { | |
| for( sal_Int32 nRow = 0; nRow < nPreviewColumns; ++nRow ) | |
| { | |
| const bool bFirstRow = rSettings.mbUseFirstRow && (nRow == 0); | |
| const bool bLastRow = rSettings.mbUseLastRow && (nRow == nPreviewColumns - 1); | |
| for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol ) | |
| { | |
| boost::shared_ptr< CellInfo > xCellInfo; | |
| // first and last row win first, if used and available | |
| if( bFirstRow ) | |
| { | |
| xCellInfo = rStyle[sdr::table::first_row_style]; | |
| } | |
| else if( bLastRow ) | |
| { | |
| xCellInfo = rStyle[sdr::table::last_row_style]; | |
| } | |
| if( !xCellInfo.get() ) | |
| { | |
| // next come first and last column, if used and available | |
| if( rSettings.mbUseFirstColumn && (nCol == 0) ) | |
| { | |
| xCellInfo = rStyle[sdr::table::first_column_style]; | |
| } | |
| else if( rSettings.mbUseLastColumn && (nCol == nPreviewColumns-1) ) | |
| { | |
| xCellInfo = rStyle[sdr::table::last_column_style]; | |
| } | |
| } | |
| if( !xCellInfo.get() ) | |
| { | |
| if( rSettings.mbUseRowBanding ) | |
| { | |
| if( (nRow & 1) == 0 ) | |
| { | |
| xCellInfo = rStyle[sdr::table::even_rows_style]; | |
| } | |
| else | |
| { | |
| xCellInfo = rStyle[sdr::table::odd_rows_style]; | |
| } | |
| } | |
| } | |
| if( !xCellInfo.get() ) | |
| { | |
| if( rSettings.mbUseColumnBanding ) | |
| { | |
| if( (nCol & 1) == 0 ) | |
| { | |
| xCellInfo = rStyle[sdr::table::even_columns_style]; | |
| } | |
| else | |
| { | |
| xCellInfo = rStyle[sdr::table::odd_columns_style]; | |
| } | |
| } | |
| } | |
| if( !xCellInfo.get() ) | |
| { | |
| // use default cell style if non found yet | |
| xCellInfo = rStyle[sdr::table::body_style]; | |
| } | |
| rMatrix[nCol][nRow] = xCellInfo; | |
| } | |
| } | |
| } | |
| // -------------------------------------------------------------------- | |
| const Bitmap CreateDesignPreview( const Reference< XIndexAccess >& xTableStyle, const TableStyleSettings& rSettings, bool bIsPageDark ) | |
| { | |
| CellInfoVector aCellInfoVector(sdr::table::style_count); | |
| FillCellInfoVector( xTableStyle, aCellInfoVector ); | |
| CellInfoMatrix aMatrix; | |
| FillCellInfoMatrix( aCellInfoVector, rSettings, aMatrix ); | |
| // bbbbbbbbbbbb w = 12 pixel | |
| // bccccccccccb h = 7 pixel | |
| // bccccccccccb b = border color | |
| // bcttttttttcb c = cell color | |
| // bccccccccccb t = text color | |
| // bccccccccccb | |
| // bbbbbbbbbbbb | |
| const sal_Int32 nCellWidth = 12; // one pixel is shared with the next cell! | |
| const sal_Int32 nCellHeight = 7; // one pixel is shared with the next cell! | |
| Bitmap aPreviewBmp( Size( (nCellWidth * nPreviewColumns) - (nPreviewColumns - 1), (nCellHeight * nPreviewRows) - (nPreviewRows - 1)), 24, NULL ); | |
| BitmapWriteAccess* pAccess = aPreviewBmp.AcquireWriteAccess(); | |
| if( pAccess ) | |
| { | |
| pAccess->Erase( Color( bIsPageDark ? COL_BLACK : COL_WHITE ) ); | |
| // first draw cell background and text line previews | |
| sal_Int32 nY = 0; | |
| sal_Int32 nRow; | |
| for( nRow = 0; nRow < nPreviewRows; ++nRow, nY += nCellHeight-1 ) | |
| { | |
| sal_Int32 nX = 0; | |
| for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol, nX += nCellWidth-1 ) | |
| { | |
| boost::shared_ptr< CellInfo > xCellInfo( aMatrix[nCol][nRow] ); | |
| Color aTextColor( COL_AUTO ); | |
| if( xCellInfo.get() ) | |
| { | |
| // fill cell background | |
| const Rectangle aRect( nX, nY, nX + nCellWidth - 1, nY + nCellHeight - 1 ); | |
| if( xCellInfo->maCellColor.GetColor() != COL_TRANSPARENT ) | |
| { | |
| pAccess->SetFillColor( xCellInfo->maCellColor ); | |
| pAccess->FillRect( aRect ); | |
| } | |
| aTextColor = xCellInfo->maTextColor; | |
| } | |
| // draw text preview line | |
| if( aTextColor.GetColor() == COL_AUTO ) | |
| aTextColor.SetColor( bIsPageDark ? COL_WHITE : COL_BLACK ); | |
| pAccess->SetLineColor( aTextColor ); | |
| const Point aPnt1( nX + 2, nY + ((nCellHeight - 1 ) >> 1) ); | |
| const Point aPnt2( nX + nCellWidth - 3, aPnt1.Y() ); | |
| pAccess->DrawLine( aPnt1, aPnt2 ); | |
| } | |
| } | |
| // second draw border lines | |
| nY = 0; | |
| for( nRow = 0; nRow < nPreviewRows; ++nRow, nY += nCellHeight-1 ) | |
| { | |
| sal_Int32 nX = 0; | |
| for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol, nX += nCellWidth-1 ) | |
| { | |
| boost::shared_ptr< CellInfo > xCellInfo( aMatrix[nCol][nRow] ); | |
| if( xCellInfo.get() ) | |
| { | |
| const Point aPntTL( nX, nY ); | |
| const Point aPntTR( nX + nCellWidth - 1, nY ); | |
| const Point aPntBL( nX, nY + nCellHeight - 1 ); | |
| const Point aPntBR( nX + nCellWidth - 1, nY + nCellHeight - 1 ); | |
| sal_Int32 border_diffs[8] = { 0,-1, 0,1, -1,0, 1,0 }; | |
| sal_Int32* pDiff = &border_diffs[0]; | |
| // draw top border | |
| for( sal_uInt16 nLine = 0; nLine < 4; ++nLine ) | |
| { | |
| const SvxBorderLine* pBorderLine = xCellInfo->maBorder.GetLine(nLine); | |
| if( !pBorderLine || ((pBorderLine->GetOutWidth() == 0) && (pBorderLine->GetInWidth()==0)) ) | |
| continue; | |
| sal_Int32 nBorderCol = nCol + *pDiff++; | |
| sal_Int32 nBorderRow = nRow + *pDiff++; | |
| if( (nBorderCol >= 0) && (nBorderCol < nPreviewColumns) && (nBorderRow >= 0) && (nBorderRow < nPreviewRows) ) | |
| { | |
| // check border | |
| boost::shared_ptr< CellInfo > xBorderInfo( aMatrix[nBorderCol][nBorderRow] ); | |
| if( xBorderInfo.get() ) | |
| { | |
| const sal_uInt16 nOtherLine = nLine ^ 1; | |
| const SvxBorderLine* pBorderLine2 = xBorderInfo->maBorder.GetLine(nOtherLine^1); | |
| if( pBorderLine2 && pBorderLine2->HasPriority(*pBorderLine) ) | |
| continue; // other border line wins | |
| } | |
| } | |
| pAccess->SetLineColor( pBorderLine->GetColor() ); | |
| switch( nLine ) | |
| { | |
| case 0: pAccess->DrawLine( aPntTL, aPntTR ); break; | |
| case 1: pAccess->DrawLine( aPntBL, aPntBR ); break; | |
| case 2: pAccess->DrawLine( aPntTL, aPntBL ); break; | |
| case 3: pAccess->DrawLine( aPntTR, aPntBR ); break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| aPreviewBmp.ReleaseAccess( pAccess ); | |
| } | |
| return aPreviewBmp; | |
| } | |
| void TableDesignPane::FillDesignPreviewControl() | |
| { | |
| ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() ); | |
| sal_uInt16 nSelectedItem = pValueSet->GetSelectItemId(); | |
| pValueSet->Clear(); | |
| try | |
| { | |
| TableStyleSettings aSettings; | |
| if( mxSelectedTable.is() ) | |
| { | |
| aSettings.mbUseFirstRow = static_cast< CheckBox* >(mxControls[CB_HEADER_ROW].get())->IsChecked(); | |
| aSettings.mbUseLastRow = static_cast< CheckBox* >(mxControls[CB_TOTAL_ROW].get())->IsChecked(); | |
| aSettings.mbUseRowBanding = static_cast< CheckBox* >(mxControls[CB_BANDED_ROWS].get())->IsChecked(); | |
| aSettings.mbUseFirstColumn = static_cast< CheckBox* >(mxControls[CB_FIRST_COLUMN].get())->IsChecked(); | |
| aSettings.mbUseLastColumn = static_cast< CheckBox* >(mxControls[CB_LAST_COLUMN].get())->IsChecked(); | |
| aSettings.mbUseColumnBanding = static_cast< CheckBox* >(mxControls[CB_BANDED_COLUMNS].get())->IsChecked(); | |
| } | |
| sal_Bool bIsPageDark = sal_False; | |
| if( mxView.is() ) | |
| { | |
| Reference< XPropertySet > xPageSet( mxView->getCurrentPage(), UNO_QUERY ); | |
| if( xPageSet.is() ) | |
| { | |
| const OUString sIsBackgroundDark( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundDark" ) ); | |
| xPageSet->getPropertyValue(sIsBackgroundDark) >>= bIsPageDark; | |
| } | |
| } | |
| for( sal_Int32 nIndex = 0; nIndex < mxTableFamily->getCount(); nIndex++ ) try | |
| { | |
| Reference< XIndexAccess > xTableStyle( mxTableFamily->getByIndex( nIndex ), UNO_QUERY ); | |
| if( xTableStyle.is() ) | |
| pValueSet->InsertItem( sal::static_int_cast<sal_uInt16>( nIndex + 1 ), Image( CreateDesignPreview( xTableStyle, aSettings, bIsPageDark ) ) ); | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_ERROR("sd::TableDesignPane::FillDesignPreviewControl(), exception caught!"); | |
| } | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_ERROR("sd::TableDesignPane::FillDesignPreviewControl(), exception caught!"); | |
| } | |
| pValueSet->SelectItem(nSelectedItem); | |
| } | |
| // ==================================================================== | |
| TableDesignDialog::TableDesignDialog(::Window* pParent, ViewShellBase& rBase ) | |
| : ModalDialog( pParent, SdResId( DLG_TABLEDESIGNPANE )) | |
| , mrBase( rBase ) | |
| { | |
| mxFlSep1.reset( new FixedLine( this, SdResId( FL_SEP1 ) ) ); | |
| mxFlSep2.reset( new FixedLine( this, SdResId( FL_SEP2 ) ) ); | |
| mxHelpButton.reset( new HelpButton( this, SdResId( BTN_HELP ) ) ); | |
| mxOkButton.reset( new OKButton( this, SdResId( BTN_OK ) ) ); | |
| mxCancelButton.reset( new CancelButton( this, SdResId( BTN_CANCEL ) ) ); | |
| FreeResource(); | |
| mpDesignPane.reset( new TableDesignPane( this, rBase, true ) ); | |
| mpDesignPane->Hide(); | |
| } | |
| // -------------------------------------------------------------------- | |
| short TableDesignDialog::Execute() | |
| { | |
| if( ModalDialog::Execute() ) | |
| { | |
| if( mpDesignPane->isStyleChanged() ) | |
| mpDesignPane->ApplyStyle(); | |
| if( mpDesignPane->isOptionsChanged() ) | |
| mpDesignPane->ApplyOptions(); | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| // ==================================================================== | |
| ::Window * createTableDesignPanel( ::Window* pParent, ViewShellBase& rBase ) | |
| { | |
| return new TableDesignPane( pParent, rBase, false ); | |
| } | |
| // ==================================================================== | |
| void showTableDesignDialog( ::Window* pParent, ViewShellBase& rBase ) | |
| { | |
| boost::scoped_ptr< TableDesignDialog > xDialog( new TableDesignDialog( pParent, rBase ) ); | |
| xDialog->Execute(); | |
| } | |
| } |