diff options
Diffstat (limited to 'sd/source/ui/table')
| -rw-r--r-- | sd/source/ui/table/TableDesignPane.cxx | 763 | ||||
| -rw-r--r-- | sd/source/ui/table/tablefunction.cxx | 292 | ||||
| -rw-r--r-- | sd/source/ui/table/tableobjectbar.cxx | 224 | ||||
| -rw-r--r-- | sd/source/ui/table/tableobjectbar.hxx | 56 |
4 files changed, 1335 insertions, 0 deletions
diff --git a/sd/source/ui/table/TableDesignPane.cxx b/sd/source/ui/table/TableDesignPane.cxx new file mode 100644 index 000000000..82d4485fb --- /dev/null +++ b/sd/source/ui/table/TableDesignPane.cxx @@ -0,0 +1,763 @@ +/* -*- 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 <sal/config.h> + +#include <string_view> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/drawing/XDrawView.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/sequence.hxx> +#include <sfx2/viewfrm.hxx> +#include <vcl/image.hxx> +#include <vcl/settings.hxx> +#include <vcl/virdev.hxx> + +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <svl/style.hxx> +#include <svl/stritem.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 <o3tl/enumrange.hxx> + +#include <TableDesignPane.hxx> + +#include <ViewShell.hxx> +#include <ViewShellBase.hxx> +#include <EventMultiplexer.hxx> + +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 { + +const sal_Int32 nPreviewColumns = 5; +const sal_Int32 nPreviewRows = 5; +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! +const sal_Int32 nBitmapWidth = (nCellWidth * nPreviewColumns) - (nPreviewColumns - 1); +const sal_Int32 nBitmapHeight = (nCellHeight * nPreviewRows) - (nPreviewRows - 1); + +const std::string_view gPropNames[CB_COUNT] = +{ + "UseFirstRowStyle", + "UseLastRowStyle", + "UseBandingRowStyle", + "UseFirstColumnStyle", + "UseLastColumnStyle", + "UseBandingColumnStyle" +}; + +TableDesignWidget::TableDesignWidget(weld::Builder& rBuilder, ViewShellBase& rBase) + : mrBase(rBase) + , m_xValueSet(new TableValueSet(rBuilder.weld_scrolled_window("previewswin", true))) + , m_xValueSetWin(new weld::CustomWeld(rBuilder, "previews", *m_xValueSet)) +{ + m_xValueSet->SetStyle(m_xValueSet->GetStyle() | WB_NO_DIRECTSELECT | WB_FLATVALUESET | WB_ITEMBORDER); + m_xValueSet->SetExtraSpacing(8); + m_xValueSet->setModal(false); + m_xValueSet->SetColor(); + m_xValueSet->SetSelectHdl(LINK(this, TableDesignWidget, implValueSetHdl)); + + for (sal_uInt16 i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i) + { + m_aCheckBoxes[i] = rBuilder.weld_check_button(OString(gPropNames[i].data(), gPropNames[i].size())); + m_aCheckBoxes[i]->connect_toggled(LINK(this, TableDesignWidget, implCheckBoxHdl)); + } + + // get current controller and initialize listeners + try + { + mxView.set(mrBase.GetController(), UNO_QUERY); + addListener(); + + Reference< XController > xController( mrBase.GetController(), UNO_SET_THROW ); + Reference< XStyleFamiliesSupplier > xFamiliesSupp( xController->getModel(), UNO_QUERY_THROW ); + Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() ); + mxTableFamily.set( xFamilies->getByName( "table" ), UNO_QUERY_THROW ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::CustomAnimationPane::CustomAnimationPane()" ); + } + + onSelectionChanged(); + updateControls(); +} + +TableDesignWidget::~TableDesignWidget() +{ + removeListener(); +} + +static SfxBindings* getBindings( ViewShellBase const & rBase ) +{ + if( rBase.GetMainViewShell() && rBase.GetMainViewShell()->GetViewFrame() ) + return &rBase.GetMainViewShell()->GetViewFrame()->GetBindings(); + else + return nullptr; +} + +static SfxDispatcher* getDispatcher( ViewShellBase const & rBase ) +{ + if( rBase.GetMainViewShell() && rBase.GetMainViewShell()->GetViewFrame() ) + return rBase.GetMainViewShell()->GetViewFrame()->GetDispatcher(); + else + return nullptr; +} + +IMPL_LINK_NOARG(TableDesignWidget, implValueSetHdl, ValueSet*, void) +{ + ApplyStyle(); +} + +void TableDesignWidget::ApplyStyle() +{ + try + { + OUString sStyleName; + sal_Int32 nIndex = static_cast< sal_Int32 >( m_xValueSet->GetSelectedItemId() ) - 1; + + if( (nIndex >= 0) && (nIndex < mxTableFamily->getCount()) ) + { + Reference< XNameAccess > xNames( mxTableFamily, UNO_QUERY_THROW ); + sStyleName = xNames->getElementNames()[nIndex]; + } + + if( sStyleName.isEmpty() ) + return; + + SdrView* pView = mrBase.GetDrawView(); + if( mxSelectedTable.is() ) + { + if( pView ) + { + SfxRequest aReq( SID_TABLE_STYLE, SfxCallMode::SYNCHRON, SfxGetpApp()->GetPool() ); + aReq.AppendItem( SfxStringItem( SID_TABLE_STYLE, sStyleName ) ); + + const 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->ExecuteList(SID_INSERT_TABLE, SfxCallMode::ASYNCHRON, + { &aArg }); + } + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "TableDesignWidget::implValueSetHdl()"); + } +} + +IMPL_LINK_NOARG(TableDesignWidget, implCheckBoxHdl, weld::Toggleable&, void) +{ + ApplyOptions(); + FillDesignPreviewControl(); +} + +void TableDesignWidget::ApplyOptions() +{ + static const sal_uInt16 gParamIds[CB_COUNT] = + { + ID_VAL_USEFIRSTROWSTYLE, ID_VAL_USELASTROWSTYLE, ID_VAL_USEBANDINGROWSTYLE, + ID_VAL_USEFIRSTCOLUMNSTYLE, ID_VAL_USELASTCOLUMNSTYLE, ID_VAL_USEBANDINGCOLUMNSTYLE + }; + + if( !mxSelectedTable.is() ) + return; + + SfxRequest aReq( SID_TABLE_STYLE_SETTINGS, SfxCallMode::SYNCHRON, SfxGetpApp()->GetPool() ); + + for( sal_uInt16 i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i ) + { + aReq.AppendItem( SfxBoolItem( gParamIds[i], m_aCheckBoxes[i]->get_active() ) ); + } + + SdrView* pView = mrBase.GetDrawView(); + if( !pView ) + return; + + const 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 TableDesignWidget::onSelectionChanged() +{ + Reference< XPropertySet > xNewSelection; + + if( mxView.is() ) try + { + Reference< XSelectionSupplier > xSel( mxView, UNO_QUERY_THROW ); + 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() == "com.sun.star.drawing.TableShape" || xDesc->getShapeType() == "com.sun.star.presentation.TableShape" ) ) + { + xNewSelection.set( xDesc, UNO_QUERY ); + } + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::TableDesignWidget::onSelectionChanged()" ); + } + + if( mxSelectedTable != xNewSelection ) + { + mxSelectedTable = xNewSelection; + updateControls(); + } +} + +void TableValueSet::Resize() +{ + ValueSet::Resize(); + // Calculate the number of rows and columns. + if( GetItemCount() <= 0 ) + return; + + Size aValueSetSize = GetOutputSizePixel(); + + Image aImage = GetItemImage(GetItemId(0)); + Size aItemSize = aImage.GetSizePixel(); + + aItemSize.AdjustHeight(10 ); + int nColumnCount = (aValueSetSize.Width() - GetScrollWidth()) / aItemSize.Width(); + if (nColumnCount < 1) + nColumnCount = 1; + + int nRowCount = (GetItemCount() + nColumnCount - 1) / nColumnCount; + if (nRowCount < 1) + nRowCount = 1; + + int nVisibleRowCount = (aValueSetSize.Height()+2) / aItemSize.Height(); + + SetColCount (static_cast<sal_uInt16>(nColumnCount)); + SetLineCount (static_cast<sal_uInt16>(nRowCount)); + + if( !m_bModal ) + { + WinBits nStyle = GetStyle() & ~WB_VSCROLL; + if( nRowCount > nVisibleRowCount ) + { + nStyle |= WB_VSCROLL; + } + SetStyle( nStyle ); + } +} + +TableValueSet::TableValueSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow) + : ValueSet(std::move(pScrolledWindow)) + , m_bModal(false) +{ +} + +void TableValueSet::StyleUpdated() +{ + updateSettings(); +} + +void TableValueSet::updateSettings() +{ + if( !m_bModal ) + { + Color aColor = Application::GetSettings().GetStyleSettings().GetWindowColor(); + SetColor(aColor); + SetExtraSpacing(8); + } +} + +void TableDesignWidget::updateControls() +{ + static const bool gDefaults[CB_COUNT] = { true, false, true, false, false, false }; + + const bool bHasTable = mxSelectedTable.is(); + + for (sal_uInt16 i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i) + { + bool bUse = gDefaults[i]; + if( bHasTable ) try + { + mxSelectedTable->getPropertyValue( OUString::createFromAscii(gPropNames[i]) ) >>= bUse; + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::TableDesignWidget::updateControls()"); + } + m_aCheckBoxes[i]->set_active(bUse); + m_aCheckBoxes[i]->set_sensitive(bHasTable); + } + + FillDesignPreviewControl(); + m_xValueSet->updateSettings(); + m_xValueSet->Resize(); + + sal_uInt16 nSelection = 0; + if( mxSelectedTable.is() ) + { + Reference< XNamed > xNamed( mxSelectedTable->getPropertyValue( "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() ); + sal_Int32 nIndex = comphelper::findValue(aNames, sStyleName); + if (nIndex != -1) + nSelection = static_cast<sal_uInt16>(nIndex) + 1; + } + } + } + m_xValueSet->SelectItem( nSelection ); +} + +void TableDesignWidget::addListener() +{ + Link<tools::EventMultiplexerEvent&,void> aLink( LINK(this,TableDesignWidget,EventMultiplexerListener) ); + mrBase.GetEventMultiplexer()->AddEventListener( aLink ); +} + +void TableDesignWidget::removeListener() +{ + Link<tools::EventMultiplexerEvent&,void> aLink( LINK(this,TableDesignWidget,EventMultiplexerListener) ); + mrBase.GetEventMultiplexer()->RemoveEventListener( aLink ); +} + +IMPL_LINK(TableDesignWidget,EventMultiplexerListener, + tools::EventMultiplexerEvent&, rEvent, void) +{ + switch (rEvent.meEventId) + { + case EventMultiplexerEventId::CurrentPageChanged: + case EventMultiplexerEventId::EditViewSelection: + onSelectionChanged(); + break; + + case EventMultiplexerEventId::MainViewRemoved: + mxView.clear(); + onSelectionChanged(); + break; + + case EventMultiplexerEventId::MainViewAdded: + mxView.set( mrBase.GetController(), UNO_QUERY ); + onSelectionChanged(); + break; + + default: break; + } +} + +namespace { + +struct CellInfo +{ + Color maCellColor; + Color maTextColor; + std::shared_ptr<SvxBoxItem> maBorder; + + explicit CellInfo( const Reference< XStyle >& xStyle ); +}; + +} + +CellInfo::CellInfo( const Reference< XStyle >& xStyle ) +: maBorder(std::make_shared<SvxBoxItem>(SDRATTR_TABLE_BORDER)) +{ + SfxStyleSheet* pStyleSheet = SfxUnoStyleSheet::getUnoStyleSheet( xStyle ); + if( !pStyleSheet ) + return; + + SfxItemSet& rSet = pStyleSheet->GetItemSet(); + + // get style fill color + if( !GetDraftFillColor(rSet, maCellColor) ) + maCellColor = COL_TRANSPARENT; + + // get style text color + const SvxColorItem* pTextColor = rSet.GetItem(EE_CHAR_COLOR); + if( pTextColor ) + maTextColor = pTextColor->GetValue(); + else + maTextColor = COL_TRANSPARENT; + + // get border + const SvxBoxItem* pBoxItem = rSet.GetItem( SDRATTR_TABLE_BORDER ); + if( pBoxItem ) + maBorder.reset(pBoxItem->Clone()); +} + +typedef std::vector< std::shared_ptr< CellInfo > > CellInfoVector; +typedef std::shared_ptr< CellInfo > CellInfoMatrix[nPreviewColumns * nPreviewRows]; + +namespace { + +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() ) + return; + + 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] = std::make_shared<CellInfo>( xStyle ); + } + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::FillCellInfoVector()"); + } +} + +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 ) + { + std::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 ) + { + // 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 ) + { + if( rSettings.mbUseRowBanding ) + { + if( (nRow & 1) == 0 ) + { + xCellInfo = rStyle[sdr::table::even_rows_style]; + } + else + { + xCellInfo = rStyle[sdr::table::odd_rows_style]; + } + } + } + + if( !xCellInfo ) + { + if( rSettings.mbUseColumnBanding ) + { + if( (nCol & 1) == 0 ) + { + xCellInfo = rStyle[sdr::table::even_columns_style]; + } + else + { + xCellInfo = rStyle[sdr::table::odd_columns_style]; + } + } + } + + if( !xCellInfo ) + { + // use default cell style if non found yet + xCellInfo = rStyle[sdr::table::body_style]; + } + + rMatrix[(nCol * nPreviewColumns) + nRow] = xCellInfo; + } + } +} + +static BitmapEx 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 + + ScopedVclPtr<VirtualDevice> pVirDev(VclPtr<VirtualDevice>::Create()); + Size aBmpSize(nBitmapWidth, nBitmapHeight); + pVirDev->SetOutputSizePixel(aBmpSize); + + pVirDev->SetBackground( bIsPageDark ? COL_BLACK : COL_WHITE ); + pVirDev->Erase(); + + // 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 ) + { + std::shared_ptr< CellInfo > xCellInfo(aMatrix[(nCol * nPreviewColumns) + nRow]); + + Color aTextColor( COL_AUTO ); + if( xCellInfo ) + { + // fill cell background + const ::tools::Rectangle aRect( nX, nY, nX + nCellWidth - 1, nY + nCellHeight - 1 ); + + if( xCellInfo->maCellColor != COL_TRANSPARENT ) + { + pVirDev->SetFillColor( xCellInfo->maCellColor ); + pVirDev->DrawRect( aRect ); + } + + aTextColor = xCellInfo->maTextColor; + } + + // draw text preview line + if( aTextColor == COL_AUTO ) + aTextColor = bIsPageDark ? COL_WHITE : COL_BLACK; + pVirDev->SetLineColor( aTextColor ); + const Point aPnt1( nX + 2, nY + ((nCellHeight - 1 ) >> 1) ); + const Point aPnt2( nX + nCellWidth - 3, aPnt1.Y() ); + pVirDev->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 ) + { + std::shared_ptr< CellInfo > xCellInfo(aMatrix[(nCol * nPreviewColumns) + nRow]); + + if( xCellInfo ) + { + 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( SvxBoxItemLine nLine : o3tl::enumrange<SvxBoxItemLine>() ) + { + const ::editeng::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 + std::shared_ptr< CellInfo > xBorderInfo(aMatrix[(nBorderCol * nPreviewColumns) + nBorderRow]); + if( xBorderInfo ) + { + const ::editeng::SvxBorderLine* pBorderLine2 = xBorderInfo->maBorder->GetLine(static_cast<SvxBoxItemLine>(static_cast<int>(nLine)^1)); + if( pBorderLine2 && pBorderLine2->HasPriority(*pBorderLine) ) + continue; // other border line wins + } + } + + pVirDev->SetLineColor( pBorderLine->GetColor() ); + switch( nLine ) + { + case SvxBoxItemLine::TOP: pVirDev->DrawLine( aPntTL, aPntTR ); break; + case SvxBoxItemLine::BOTTOM: pVirDev->DrawLine( aPntBL, aPntBR ); break; + case SvxBoxItemLine::LEFT: pVirDev->DrawLine( aPntTL, aPntBL ); break; + case SvxBoxItemLine::RIGHT: pVirDev->DrawLine( aPntTR, aPntBR ); break; + } + } + } + } + } + + return pVirDev->GetBitmapEx(Point(0,0), aBmpSize); +} + +void TableDesignWidget::FillDesignPreviewControl() +{ + sal_uInt16 nSelectedItem = m_xValueSet->GetSelectedItemId(); + m_xValueSet->Clear(); + try + { + TableStyleSettings aSettings; + if( mxSelectedTable.is() ) + { + aSettings.mbUseFirstRow = m_aCheckBoxes[CB_HEADER_ROW]->get_active(); + aSettings.mbUseLastRow = m_aCheckBoxes[CB_TOTAL_ROW]->get_active(); + aSettings.mbUseRowBanding = m_aCheckBoxes[CB_BANDED_ROWS]->get_active(); + aSettings.mbUseFirstColumn = m_aCheckBoxes[CB_FIRST_COLUMN]->get_active(); + aSettings.mbUseLastColumn = m_aCheckBoxes[CB_LAST_COLUMN]->get_active(); + aSettings.mbUseColumnBanding = m_aCheckBoxes[CB_BANDED_COLUMNS]->get_active(); + } + + bool bIsPageDark = false; + if( mxView.is() ) + { + Reference< XPropertySet > xPageSet( mxView->getCurrentPage(), UNO_QUERY ); + if( xPageSet.is() ) + { + xPageSet->getPropertyValue("IsBackgroundDark") >>= bIsPageDark; + } + } + + sal_Int32 nCount = mxTableFamily->getCount(); + for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex ) try + { + Reference< XIndexAccess > xTableStyle( mxTableFamily->getByIndex( nIndex ), UNO_QUERY ); + if( xTableStyle.is() ) + m_xValueSet->InsertItem( sal::static_int_cast<sal_uInt16>( nIndex + 1 ), Image( CreateDesignPreview( xTableStyle, aSettings, bIsPageDark ) ) ); + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::TableDesignWidget::FillDesignPreviewControl()"); + } + sal_Int32 nCols = 3; + sal_Int32 nRows = (nCount+2)/3; + m_xValueSet->SetColCount(nCols); + m_xValueSet->SetLineCount(nRows); + WinBits nStyle = m_xValueSet->GetStyle() & ~WB_VSCROLL; + m_xValueSet->SetStyle(nStyle); + + m_xValueSet->SetOptimalSize(); + weld::DrawingArea* pDrawingArea = m_xValueSet->GetDrawingArea(); + Size aSize = pDrawingArea->get_preferred_size(); + aSize.AdjustWidth(10 * nCols); + aSize.AdjustHeight(10 * nRows); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + + m_xValueSet->Resize(); + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::TableDesignWidget::FillDesignPreviewControl()"); + } + m_xValueSet->SelectItem(nSelectedItem); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sd/source/ui/table/tablefunction.cxx b/sd/source/ui/table/tablefunction.cxx new file mode 100644 index 000000000..c19445429 --- /dev/null +++ b/sd/source/ui/table/tablefunction.cxx @@ -0,0 +1,292 @@ +/* -*- 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 <sal/config.h> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/drawing/XSelectionFunction.hpp> + +#include <comphelper/lok.hxx> + +#include <svx/svdotable.hxx> +#include <svx/svxids.hrc> +#include <svx/svdpagv.hxx> +#include <svx/svxdlg.hxx> + +#include <svl/intitem.hxx> +#include <svl/stritem.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/request.hxx> +#include <sfx2/sidebar/Sidebar.hxx> +#include <svl/style.hxx> +#include <tools/diagnose_ex.h> + +#include <tablefunction.hxx> +#include <DrawViewShell.hxx> +#include <drawdoc.hxx> +#include <sdpage.hxx> +#include <Window.hxx> +#include <drawview.hxx> +#include <sdmod.hxx> + +#include <memory> + +using namespace ::sd; +using namespace sdr::table; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::drawing; +using namespace ::com::sun::star::linguistic2; + +namespace sd +{ + +static void apply_table_style( SdrTableObj* pObj, SdrModel const * pModel, const OUString& sTableStyle ) +{ + if( !(pModel && pObj) ) + return; + + Reference< XNameAccess > xPool( dynamic_cast< XNameAccess* >( pModel->GetStyleSheetPool() ) ); + if( !xPool.is() ) + return; + + try + { + Reference< XNameContainer > xTableFamily( xPool->getByName( "table" ), UNO_QUERY_THROW ); + OUString aStdName( "default" ); + if( !sTableStyle.isEmpty() ) + aStdName = sTableStyle; + Reference< XIndexAccess > xStyle( xTableFamily->getByName( aStdName ), UNO_QUERY_THROW ); + pObj->setTableStyle( xStyle ); + } + catch( Exception& ) + { + TOOLS_WARN_EXCEPTION( "sd", "sd::apply_default_table_style()"); + } +} + +static void InsertTableImpl(const DrawViewShell* pShell, + ::sd::View* pView, + sal_Int32 nColumns, + sal_Int32 nRows, + const OUString& sTableStyle) +{ + ::tools::Rectangle aRect; + + SdrObject* pPickObj = pView->GetEmptyPresentationObject( PresObjKind::Table ); + if( pPickObj ) + { + aRect = pPickObj->GetLogicRect(); + aRect.setHeight( 200 ); + } + else + { + Size aSize( 14100, 2000 ); + + Point aPos; + ::tools::Rectangle aWinRect(aPos, pShell->GetActiveWindow()->GetOutputSizePixel()); + aWinRect = pShell->GetActiveWindow()->PixelToLogic(aWinRect); + + // make sure that the default size of the table fits on the paper and is inside the viewing area. + // if zoomed in close, don't make the table bigger than the viewing window. + Size aMaxSize = pShell->getCurrentPage()->GetSize(); + + if (comphelper::LibreOfficeKit::isActive()) + { + // aWinRect is nonsensical in the LOK case + aWinRect = ::tools::Rectangle(aPos, aMaxSize); + } + else + { + if( aMaxSize.Height() > aWinRect.getHeight() ) + aMaxSize.setHeight( aWinRect.getHeight() ); + if( aMaxSize.Width() > aWinRect.getWidth() ) + aMaxSize.setWidth( aWinRect.getWidth() ); + } + + if( aSize.Width() > aMaxSize.getWidth() ) + aSize.setWidth( aMaxSize.getWidth() ); + + // adjust height based on # of rows. + if( nRows > 0 ) + { + aSize.setHeight( aSize.Height() * nRows ); + if( aSize.Height() > aMaxSize.getHeight() ) + aSize.setHeight( aMaxSize.getHeight() ); + } + + aPos = aWinRect.Center(); + aPos.AdjustX( -(aSize.Width() / 2) ); + aPos.AdjustY( -(aSize.Height() / 2) ); + aRect = ::tools::Rectangle(aPos, aSize); + } + + sdr::table::SdrTableObj* pObj = new sdr::table::SdrTableObj( + *pShell->GetDoc(), // TTTT should be reference + aRect, + nColumns, + nRows); + pObj->NbcSetStyleSheet( pShell->GetDoc()->GetDefaultStyleSheet(), true ); + apply_table_style( pObj, pShell->GetDoc(), sTableStyle ); + SdrPageView* pPV = pView->GetSdrPageView(); + + // #i123359# if an object is to be replaced/manipulated it may be that it is in text edit mode, + // so to be on the safe side call SdrEndTextEdit here + SdrTextObj* pCheckForTextEdit = dynamic_cast< SdrTextObj* >(pPickObj); + + if(pCheckForTextEdit && pCheckForTextEdit->IsInEditMode()) + { + pView->SdrEndTextEdit(); + } + + // if we have a pick obj we need to make this new ole a pres obj replacing the current pick obj + if( pPickObj ) + { + SdPage* pPage = static_cast< SdPage* >(pPickObj->getSdrPageFromSdrObject()); + if(pPage && pPage->IsPresObj(pPickObj)) + { + pObj->SetUserCall( pPickObj->GetUserCall() ); + pPage->InsertPresObj( pObj, PresObjKind::Table ); + } + } + + pShell->GetParentWindow()->GrabFocus(); + if( pPickObj ) + pView->ReplaceObjectAtView(pPickObj, *pPV, pObj ); + else + pView->InsertObjectAtView(pObj, *pPV, SdrInsertFlags::SETDEFLAYER); +} + +void DrawViewShell::FuTable(SfxRequest& rReq) +{ + switch( rReq.GetSlot() ) + { + case SID_INSERT_TABLE: + { + sal_Int32 nColumns = 0; + sal_Int32 nRows = 0; + OUString sTableStyle; + DrawViewShell* pShell = this; + ::sd::View* pView = mpView; + + const SfxUInt16Item* pCols = rReq.GetArg<SfxUInt16Item>(SID_ATTR_TABLE_COLUMN); + const SfxUInt16Item* pRows = rReq.GetArg<SfxUInt16Item>(SID_ATTR_TABLE_ROW); + const SfxStringItem* pStyle = rReq.GetArg<SfxStringItem>(SID_TABLE_STYLE); + + if( pCols ) + nColumns = pCols->GetValue(); + + if( pRows ) + nRows = pRows->GetValue(); + + if( pStyle ) + sTableStyle = pStyle->GetValue(); + + if( (nColumns == 0) || (nRows == 0) ) + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + std::shared_ptr<SvxAbstractNewTableDialog> pDlg( pFact->CreateSvxNewTableDialog(rReq.GetFrameWeld()) ); + + weld::DialogController::runAsync(pDlg->getDialogController(), + [pDlg, pShell, pView, sTableStyle] (sal_Int32 nResult) { + if (nResult == RET_OK) + { + sal_Int32 nColumnsIn = pDlg->getColumns(); + sal_Int32 nRowsIn = pDlg->getRows(); + + InsertTableImpl(pShell, pView, nColumnsIn, nRowsIn, sTableStyle); + } + }); + } + else + { + InsertTableImpl(pShell, pView, nColumns, nRows, sTableStyle); + } + + rReq.Ignore(); + SfxViewShell* pViewShell = GetViewShell(); + OSL_ASSERT (pViewShell!=nullptr); + SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_INSERT_TABLE, true ); + break; + } + case SID_TABLEDESIGN: + { + // First make sure that the sidebar is visible + GetViewFrame()->ShowChildWindow(SID_SIDEBAR); + ::sfx2::sidebar::Sidebar::ShowPanel( + u"SdTableDesignPanel", + GetViewFrame()->GetFrame().GetFrameInterface()); + + Cancel(); + rReq.Done (); + break; + } + default: + break; + } +} + +void DrawViewShell::GetTableMenuState( SfxItemSet &rSet ) +{ + OUString aActiveLayer = mpDrawView->GetActiveLayer(); + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + if( + ( !aActiveLayer.isEmpty() && pPV && ( pPV->IsLayerLocked(aActiveLayer) || + !pPV->IsLayerVisible(aActiveLayer) ) ) || + SD_MOD()->GetWaterCan() ) + { + rSet.DisableItem( SID_INSERT_TABLE ); + } +} + +void CreateTableFromRTF( SvStream& rStream, SdDrawDocument* pModel ) +{ + rStream.Seek( 0 ); + + if( !pModel ) + return; + + SdrPage* pPage = pModel->GetPage(0); + if( !pPage ) + return; + + Size aSize( 200, 200 ); + ::tools::Rectangle aRect (Point(), aSize); + sdr::table::SdrTableObj* pObj = new sdr::table::SdrTableObj( + *pModel, + aRect, + 1, + 1); + pObj->NbcSetStyleSheet( pModel->GetDefaultStyleSheet(), true ); + apply_table_style( pObj, pModel, OUString() ); + + pPage->NbcInsertObject( pObj ); + + sdr::table::ImportAsRTF( rStream, *pObj ); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sd/source/ui/table/tableobjectbar.cxx b/sd/source/ui/table/tableobjectbar.cxx new file mode 100644 index 000000000..62d81d980 --- /dev/null +++ b/sd/source/ui/table/tableobjectbar.cxx @@ -0,0 +1,224 @@ +/* -*- 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 <sfx2/bindings.hxx> +#include <sfx2/msg.hxx> +#include <sfx2/request.hxx> +#include <sfx2/objface.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/msgpool.hxx> +#include <vcl/EnumContext.hxx> +#include <svl/intitem.hxx> +#include <svx/svxdlg.hxx> +#include <svx/svxids.hrc> + +#include <createtableobjectbar.hxx> +#include <registerinterfaces.hxx> + +#include <strings.hrc> +#include <DrawDocShell.hxx> +#include <ViewShell.hxx> +#include <sdmod.hxx> +#include <sdresid.hxx> +#include <DrawViewShell.hxx> + +#include "tableobjectbar.hxx" + +using namespace sd; +using namespace sd::ui::table; + +#define ShellClass_TableObjectBar +#include <sdslots.hxx> + +namespace sd::ui::table { + +/** creates a table object bar for the given ViewShell */ +SfxShell* CreateTableObjectBar( ViewShell& rShell, ::sd::View* pView ) +{ + return new TableObjectBar( &rShell, pView ); +} + +/** registers the interfaces from the table ui */ +void RegisterInterfaces(const SfxModule* pMod) +{ + TableObjectBar::RegisterInterface(pMod); +} + + +SFX_IMPL_INTERFACE(TableObjectBar, SfxShell) + +void TableObjectBar::InitInterface_Impl() +{ +} + +TableObjectBar::TableObjectBar( ViewShell* pSdViewShell, ::sd::View* pSdView ) +: SfxShell( pSdViewShell->GetViewShell() ) +, mpView( pSdView ) +, mpViewSh( pSdViewShell ) +{ + DrawDocShell* pDocShell = mpViewSh->GetDocSh(); + if( pDocShell ) + { + SetPool( &pDocShell->GetPool() ); + SetUndoManager( pDocShell->GetUndoManager() ); + } + SetRepeatTarget( mpView ); + SetName( SdResId( RID_DRAW_TABLE_TOOLBOX ) ); + SetContextName(vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Table)); +} + +TableObjectBar::~TableObjectBar() +{ + SetRepeatTarget( nullptr ); +} + +void TableObjectBar::GetState( SfxItemSet& rSet ) +{ + if( mpView ) + { + rtl::Reference< sdr::SelectionController > xController( mpView->getSelectionController() ); + if( xController.is() ) + { + xController->GetState( rSet ); + } + } +} + +void TableObjectBar::GetAttrState( SfxItemSet& rSet ) +{ + DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( mpViewSh ); + if( pDrawViewShell ) + pDrawViewShell->GetAttrState( rSet ); +} + +void TableObjectBar::Execute( SfxRequest& rReq ) +{ + if( !mpView ) + return; + + SdrView* pView = mpView; + SfxBindings* pBindings = &mpViewSh->GetViewFrame()->GetBindings(); + + rtl::Reference< sdr::SelectionController > xController( mpView->getSelectionController() ); + sal_uLong nSlotId = rReq.GetSlot(); + if( xController.is() ) + { + switch( nSlotId ) + { + case SID_TABLE_INSERT_ROW_DLG: + case SID_TABLE_INSERT_ROW_BEFORE: + case SID_TABLE_INSERT_ROW_AFTER: + case SID_TABLE_INSERT_COL_DLG: + case SID_TABLE_INSERT_COL_BEFORE: + case SID_TABLE_INSERT_COL_AFTER: + { + ScopedVclPtr<SvxAbstractInsRowColDlg> pDlg; + if (nSlotId == SID_TABLE_INSERT_ROW_DLG || nSlotId == SID_TABLE_INSERT_COL_DLG) + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + vcl::Window* pWin = mpView->GetViewShell()->GetParentWindow(); + pDlg.disposeAndReset( pFact->CreateSvxInsRowColDlg(pWin ? pWin->GetFrameWeld() : nullptr, + nSlotId == SID_TABLE_INSERT_COL_DLG, + SD_MOD()->GetSlotPool()->GetSlot(nSlotId)->GetCommand()) ); + + if (pDlg->Execute() != 1) + break; + } + + sal_uInt16 nCount = 1; + bool bInsertAfter = (nSlotId == SID_TABLE_INSERT_ROW_AFTER) || (nSlotId == SID_TABLE_INSERT_COL_AFTER); + + if (nSlotId == SID_TABLE_INSERT_ROW_DLG) + { + nCount = pDlg->getInsertCount(); + bInsertAfter = !pDlg->isInsertBefore(); + } + else if (nSlotId == SID_TABLE_INSERT_COL_DLG) + { + nCount = pDlg->getInsertCount(); + bInsertAfter = !pDlg->isInsertBefore(); + } + + if (nSlotId == SID_TABLE_INSERT_ROW_DLG || nSlotId == SID_TABLE_INSERT_ROW_BEFORE || nSlotId == SID_TABLE_INSERT_ROW_AFTER) + nSlotId = SID_TABLE_INSERT_ROW; + else + nSlotId = SID_TABLE_INSERT_COL; + + rReq.AppendItem(SfxInt16Item(static_cast<sal_uInt16>(nSlotId), nCount)); + rReq.AppendItem(SfxBoolItem(SID_TABLE_PARAM_INSERT_AFTER, bInsertAfter)); + + rReq.SetSlot( static_cast<sal_uInt16>(nSlotId) ); + } + } + + xController->Execute( rReq ); + } + + // note: we may be deleted at this point, no more member access possible + + switch( rReq.GetSlot() ) + { + case SID_ATTR_BORDER: + case SID_TABLE_MERGE_CELLS: + case SID_TABLE_SPLIT_CELLS: + case SID_OPTIMIZE_TABLE: + case SID_TABLE_DELETE_ROW: + case SID_TABLE_DELETE_COL: + case SID_TABLE_DELETE_TABLE: + case SID_FORMAT_TABLE_DLG: + case SID_TABLE_INSERT_ROW: + case SID_TABLE_INSERT_COL: + { + pView->AdjustMarkHdl(); + pBindings->Invalidate( SID_TABLE_DELETE_ROW ); + pBindings->Invalidate( SID_TABLE_DELETE_COL ); + pBindings->Invalidate( SID_TABLE_DELETE_TABLE ); + pBindings->Invalidate( SID_FRAME_LINESTYLE ); + pBindings->Invalidate( SID_FRAME_LINECOLOR ); + pBindings->Invalidate( SID_ATTR_BORDER ); + pBindings->Invalidate( SID_ATTR_FILL_STYLE ); + pBindings->Invalidate( SID_ATTR_FILL_USE_SLIDE_BACKGROUND ); + pBindings->Invalidate( SID_ATTR_FILL_TRANSPARENCE ); + pBindings->Invalidate( SID_ATTR_FILL_FLOATTRANSPARENCE ); + pBindings->Invalidate( SID_TABLE_MERGE_CELLS ); + pBindings->Invalidate( SID_TABLE_SPLIT_CELLS ); + pBindings->Invalidate( SID_OPTIMIZE_TABLE ); + pBindings->Invalidate( SID_TABLE_VERT_BOTTOM ); + pBindings->Invalidate( SID_TABLE_VERT_CENTER ); + pBindings->Invalidate( SID_TABLE_VERT_NONE ); + break; + } + case SID_TABLE_VERT_BOTTOM: + case SID_TABLE_VERT_CENTER: + case SID_TABLE_VERT_NONE: + { + pBindings->Invalidate( SID_TABLE_VERT_BOTTOM ); + pBindings->Invalidate( SID_TABLE_VERT_CENTER ); + pBindings->Invalidate( SID_TABLE_VERT_NONE ); + break; + } + } + + pBindings->Invalidate( SID_UNDO ); + pBindings->Invalidate( SID_REDO ); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sd/source/ui/table/tableobjectbar.hxx b/sd/source/ui/table/tableobjectbar.hxx new file mode 100644 index 000000000..c5d513bff --- /dev/null +++ b/sd/source/ui/table/tableobjectbar.hxx @@ -0,0 +1,56 @@ +/* -*- 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 . + */ + +#pragma once + +#include <sfx2/shell.hxx> +#include <glob.hxx> + +namespace sd { + +class View; +class ViewShell; + +} + +namespace sd::ui::table { + +class TableObjectBar final : public SfxShell +{ +public: + SFX_DECL_INTERFACE( SD_IF_SDDRAWTABLEOBJECTBAR ) + + TableObjectBar( ::sd::ViewShell* pSdViewShell, ::sd::View* pSdView); + virtual ~TableObjectBar() override; + + void GetState( SfxItemSet& rSet ); + void GetAttrState( SfxItemSet& rSet ); + void Execute( SfxRequest& rReq ); + +private: + /// SfxInterface initializer. + static void InitInterface_Impl(); + + ::sd::View* mpView; + ::sd::ViewShell* mpViewSh; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |