| /************************************************************** | |
| * | |
| * 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_chartcontroller.hxx" | |
| // header for class SvNumberformat | |
| #ifndef _ZFORMAT_HXX | |
| #ifndef _ZFORLIST_DECLARE_TABLE | |
| #define _ZFORLIST_DECLARE_TABLE | |
| #endif | |
| #include <svl/zformat.hxx> | |
| #endif | |
| // header for SvNumberFormatter | |
| #include <svl/zforlist.hxx> | |
| #include "DataBrowser.hxx" | |
| #include "DataBrowserModel.hxx" | |
| #include "Strings.hrc" | |
| #include "ContainerHelper.hxx" | |
| #include "DataSeriesHelper.hxx" | |
| #include "DiagramHelper.hxx" | |
| #include "ChartModelHelper.hxx" | |
| #include "CommonConverters.hxx" | |
| #include "macros.hxx" | |
| #include "NumberFormatterWrapper.hxx" | |
| #include "servicenames_charttypes.hxx" | |
| #include "ResId.hxx" | |
| #include "Bitmaps.hrc" | |
| #include "Bitmaps_HC.hrc" | |
| #include "HelpIds.hrc" | |
| #include <vcl/fixed.hxx> | |
| #include <vcl/image.hxx> | |
| #include <vcl/msgbox.hxx> | |
| #include <rtl/math.hxx> | |
| #include <com/sun/star/util/XCloneable.hpp> | |
| #include <com/sun/star/chart2/XChartDocument.hpp> | |
| #include <com/sun/star/chart2/XChartType.hpp> | |
| #include <com/sun/star/container/XIndexReplace.hpp> | |
| #include <com/sun/star/util/XNumberFormats.hpp> | |
| #include <algorithm> | |
| #include <functional> | |
| #define SELECT_IMAGE(name,hc) Image( SchResId( hc ? name ## _HC : name )) | |
| /* BROWSER_COLUMNSELECTION : single cells may be selected rather than only | |
| entire rows | |
| BROWSER_(H|V)LINES : show horizontal or vertical grid-lines | |
| BROWSER_AUTO_(H|V)SCROLL : scroll automated horizontally or vertically when | |
| cursor is moved beyond the edge of the dialog | |
| BROWSER_HIGHLIGHT_NONE : Do not mark the current row with selection color | |
| (usually blue) | |
| */ | |
| #define BROWSER_STANDARD_FLAGS \ | |
| BROWSER_COLUMNSELECTION | \ | |
| BROWSER_HLINES | BROWSER_VLINES | \ | |
| BROWSER_AUTO_HSCROLL | BROWSER_AUTO_VSCROLL | \ | |
| BROWSER_HIGHLIGHT_NONE | |
| // BROWSER_HIDECURSOR would prevent flickering in edit fields, but navigating | |
| // with shift up/down, and entering non-editable cells would be problematic, | |
| // e.g. the first cell, or when being in read-only mode | |
| using namespace ::com::sun::star; | |
| using ::com::sun::star::uno::Sequence; | |
| using ::com::sun::star::uno::Reference; | |
| using ::rtl::OUString; | |
| using namespace ::svt; | |
| namespace | |
| { | |
| sal_Int32 lcl_getRowInData( long nRow ) | |
| { | |
| return static_cast< sal_Int32 >( nRow ); | |
| } | |
| sal_Int32 lcl_getColumnInData( sal_uInt16 nCol ) | |
| { | |
| return static_cast< sal_Int32 >( nCol ) - 1; | |
| } | |
| } // anonymous namespace | |
| // -------------------------------------------------------------------------------- | |
| namespace chart | |
| { | |
| // ---------------------------------------- | |
| namespace impl | |
| { | |
| class SeriesHeaderEdit : public Edit | |
| { | |
| public: | |
| SeriesHeaderEdit( Window * pParent ); | |
| virtual ~SeriesHeaderEdit(); | |
| virtual void MouseButtonDown( const MouseEvent& rMEvt ); | |
| void setStartColumn( sal_Int32 nStartColumn ); | |
| sal_Int32 getStartColumn() const; | |
| void SetShowWarningBox( bool bShowWarning = true ); | |
| private: | |
| sal_Int32 m_nStartColumn; | |
| bool m_bShowWarningBox; | |
| }; | |
| SeriesHeaderEdit::SeriesHeaderEdit( Window * pParent ) : | |
| Edit( pParent ), | |
| m_nStartColumn( 0 ), | |
| m_bShowWarningBox( false ) | |
| {} | |
| SeriesHeaderEdit::~SeriesHeaderEdit() | |
| {} | |
| void SeriesHeaderEdit::setStartColumn( sal_Int32 nStartColumn ) | |
| { | |
| m_nStartColumn = nStartColumn; | |
| } | |
| sal_Int32 SeriesHeaderEdit::getStartColumn() const | |
| { | |
| return m_nStartColumn; | |
| } | |
| void SeriesHeaderEdit::SetShowWarningBox( bool bShowWarning ) | |
| { | |
| m_bShowWarningBox = bShowWarning; | |
| } | |
| void SeriesHeaderEdit::MouseButtonDown( const MouseEvent& rMEvt ) | |
| { | |
| Edit::MouseButtonDown( rMEvt ); | |
| if( m_bShowWarningBox ) | |
| WarningBox( this, WinBits( WB_OK ), | |
| String( SchResId( STR_INVALID_NUMBER ))).Execute(); | |
| } | |
| class SeriesHeader | |
| { | |
| public: | |
| explicit SeriesHeader( Window * pParent ); | |
| void SetColor( const Color & rCol ); | |
| void SetPos( const Point & rPos ); | |
| void SetWidth( sal_Int32 nWidth ); | |
| void SetChartType( const Reference< chart2::XChartType > & xChartType, | |
| bool bSwapXAndYAxis, | |
| bool bIsHighContrast ); | |
| void SetSeriesName( const String & rName ); | |
| void SetRange( sal_Int32 nStartCol, sal_Int32 nEndCol ); | |
| void SetPixelPosX( sal_Int32 nPos ); | |
| void SetPixelWidth( sal_Int32 nWidth ); | |
| sal_Int32 GetStartColumn() const; | |
| sal_Int32 GetEndColumn() const; | |
| static sal_Int32 GetRelativeAppFontXPosForNameField(); | |
| void Show(); | |
| /** call this before destroying the class. This notifies the listeners to | |
| changes of the edit field for the series name. | |
| */ | |
| void applyChanges(); | |
| void SetGetFocusHdl( const Link& rLink ); | |
| void SetEditChangedHdl( const Link & rLink ); | |
| bool HasFocus() const; | |
| private: | |
| ::boost::shared_ptr< FixedImage > m_spSymbol; | |
| ::boost::shared_ptr< SeriesHeaderEdit > m_spSeriesName; | |
| ::boost::shared_ptr< FixedText > m_spColorBar; | |
| OutputDevice * m_pDevice; | |
| Link m_aChangeLink; | |
| void notifyChanges(); | |
| DECL_LINK( SeriesNameChanged, void * ); | |
| DECL_LINK( SeriesNameEdited, void * ); | |
| /// @param bHC </sal_True> for hight-contrast image | |
| static Image GetChartTypeImage( | |
| const Reference< chart2::XChartType > & xChartType, | |
| bool bSwapXAndYAxis, | |
| bool bHC ); | |
| sal_Int32 m_nStartCol, m_nEndCol; | |
| sal_Int32 m_nWidth; | |
| Point m_aPos; | |
| bool m_bSeriesNameChangePending; | |
| }; | |
| SeriesHeader::SeriesHeader( Window * pParent ) : | |
| m_spSymbol( new FixedImage( pParent, WB_NOBORDER )), | |
| m_spSeriesName( new SeriesHeaderEdit( pParent )), | |
| m_spColorBar( new FixedText( pParent, WB_NOBORDER )), | |
| m_pDevice( pParent ), | |
| m_nStartCol( 0 ), | |
| m_nEndCol( 0 ), | |
| m_nWidth( 42 ), | |
| m_aPos( 0, 22 ), | |
| m_bSeriesNameChangePending( false ) | |
| { | |
| m_spSeriesName->EnableUpdateData( 4 * EDIT_UPDATEDATA_TIMEOUT ); // define is in vcl/edit.hxx | |
| m_spSeriesName->SetUpdateDataHdl( LINK( this, SeriesHeader, SeriesNameChanged )); | |
| m_spSeriesName->SetModifyHdl( LINK( this, SeriesHeader, SeriesNameEdited )); | |
| m_spSeriesName->SetHelpId( HID_SCH_DATA_SERIES_LABEL ); | |
| Show(); | |
| } | |
| void SeriesHeader::notifyChanges() | |
| { | |
| if( m_aChangeLink.IsSet()) | |
| m_aChangeLink.Call( m_spSeriesName.get()); | |
| m_bSeriesNameChangePending = false; | |
| } | |
| void SeriesHeader::applyChanges() | |
| { | |
| if( m_bSeriesNameChangePending ) | |
| { | |
| notifyChanges(); | |
| } | |
| } | |
| void SeriesHeader::SetColor( const Color & rCol ) | |
| { | |
| m_spColorBar->SetControlBackground( rCol ); | |
| } | |
| const sal_Int32 nSymbolHeight = 10; | |
| const sal_Int32 nSymbolDistance = 2; | |
| sal_Int32 SeriesHeader::GetRelativeAppFontXPosForNameField() | |
| { | |
| return nSymbolHeight + nSymbolDistance; | |
| } | |
| void SeriesHeader::SetPos( const Point & rPos ) | |
| { | |
| m_aPos = rPos; | |
| // chart type symbol | |
| Point aPos( rPos ); | |
| aPos.setY( aPos.getY() + nSymbolDistance ); | |
| Size aSize( nSymbolHeight, nSymbolHeight ); | |
| m_spSymbol->SetPosPixel( m_pDevice->LogicToPixel( aPos, MAP_APPFONT )); | |
| m_spSymbol->SetSizePixel( m_pDevice->LogicToPixel( aSize, MAP_APPFONT )); | |
| aPos.setY( aPos.getY() - nSymbolDistance ); | |
| // series name edit field | |
| aPos.setX( aPos.getX() + nSymbolHeight + nSymbolDistance ); | |
| aSize.setWidth( m_nWidth - nSymbolHeight - nSymbolDistance ); | |
| sal_Int32 nHeight = 12; | |
| aSize.setHeight( nHeight ); | |
| m_spSeriesName->SetPosPixel( m_pDevice->LogicToPixel( aPos, MAP_APPFONT )); | |
| m_spSeriesName->SetSizePixel( m_pDevice->LogicToPixel( aSize, MAP_APPFONT )); | |
| // color bar | |
| aPos.setX( rPos.getX() + 1 ); | |
| aPos.setY( aPos.getY() + nHeight + 2 ); | |
| nHeight = 3; | |
| aSize.setWidth( m_nWidth - 1 ); | |
| aSize.setHeight( nHeight ); | |
| m_spColorBar->SetPosPixel( m_pDevice->LogicToPixel( aPos, MAP_APPFONT )); | |
| m_spColorBar->SetSizePixel( m_pDevice->LogicToPixel( aSize, MAP_APPFONT )); | |
| } | |
| void SeriesHeader::SetWidth( sal_Int32 nWidth ) | |
| { | |
| m_nWidth = nWidth; | |
| SetPos( m_aPos ); | |
| } | |
| void SeriesHeader::SetPixelPosX( sal_Int32 nPos ) | |
| { | |
| Point aPos( m_pDevice->LogicToPixel( m_aPos, MAP_APPFONT )); | |
| aPos.setX( nPos ); | |
| SetPos( m_pDevice->PixelToLogic( aPos, MAP_APPFONT )); | |
| } | |
| void SeriesHeader::SetPixelWidth( sal_Int32 nWidth ) | |
| { | |
| SetWidth( m_pDevice->PixelToLogic( Size( nWidth, 0 ), MAP_APPFONT ).getWidth()); | |
| } | |
| void SeriesHeader::SetChartType( | |
| const Reference< chart2::XChartType > & xChartType, | |
| bool bSwapXAndYAxis, | |
| bool bIsHighContrast ) | |
| { | |
| m_spSymbol->SetImage( GetChartTypeImage( xChartType, bSwapXAndYAxis, bIsHighContrast )); | |
| } | |
| void SeriesHeader::SetSeriesName( const String & rName ) | |
| { | |
| m_spSeriesName->SetText( rName ); | |
| } | |
| void SeriesHeader::SetRange( sal_Int32 nStartCol, sal_Int32 nEndCol ) | |
| { | |
| m_nStartCol = nStartCol; | |
| m_nEndCol = (nEndCol > nStartCol) ? nEndCol : nStartCol; | |
| m_spSeriesName->setStartColumn( nStartCol ); | |
| } | |
| sal_Int32 SeriesHeader::GetStartColumn() const | |
| { | |
| return m_nStartCol; | |
| } | |
| sal_Int32 SeriesHeader::GetEndColumn() const | |
| { | |
| return m_nEndCol; | |
| } | |
| void SeriesHeader::Show() | |
| { | |
| m_spSymbol->Show(); | |
| m_spSeriesName->Show(); | |
| m_spColorBar->Show(); | |
| } | |
| void SeriesHeader::SetEditChangedHdl( const Link & rLink ) | |
| { | |
| m_aChangeLink = rLink; | |
| } | |
| IMPL_LINK( SeriesHeader, SeriesNameChanged, void * , EMPTYARG ) | |
| { | |
| notifyChanges(); | |
| return 0; | |
| } | |
| IMPL_LINK( SeriesHeader, SeriesNameEdited, void * , EMPTYARG ) | |
| { | |
| m_bSeriesNameChangePending = true; | |
| return 0; | |
| } | |
| void SeriesHeader::SetGetFocusHdl( const Link& rLink ) | |
| { | |
| m_spSeriesName->SetGetFocusHdl( rLink ); | |
| } | |
| bool SeriesHeader::HasFocus() const | |
| { | |
| return m_spSeriesName->HasFocus(); | |
| } | |
| Image SeriesHeader::GetChartTypeImage( | |
| const Reference< chart2::XChartType > & xChartType, | |
| bool bSwapXAndYAxis, | |
| bool bHC ) | |
| { | |
| Image aResult; | |
| if( !xChartType.is()) | |
| return aResult; | |
| OUString aChartTypeName( xChartType->getChartType()); | |
| if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_AREA )) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_AREA, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_COLUMN )) | |
| { | |
| if( bSwapXAndYAxis ) | |
| aResult = SELECT_IMAGE( IMG_TYPE_BAR, bHC ); | |
| else | |
| aResult = SELECT_IMAGE( IMG_TYPE_COLUMN, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_LINE )) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_LINE, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_SCATTER )) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_XY, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_PIE )) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_PIE, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_NET ) | |
| || aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_FILLED_NET ) ) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_NET, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK )) | |
| { | |
| // @todo: correct image for candle-stick type | |
| aResult = SELECT_IMAGE( IMG_TYPE_STOCK, bHC ); | |
| } | |
| else if( aChartTypeName.equals( CHART2_SERVICE_NAME_CHARTTYPE_BUBBLE )) | |
| { | |
| aResult = SELECT_IMAGE( IMG_TYPE_BUBBLE, bHC ); | |
| } | |
| return aResult; | |
| } | |
| struct applyChangesFunctor : public ::std::unary_function< ::boost::shared_ptr< SeriesHeader >, void > | |
| { | |
| void operator() ( ::boost::shared_ptr< SeriesHeader > spHeader ) | |
| { | |
| spHeader->applyChanges(); | |
| } | |
| }; | |
| } // namespace impl | |
| // ---------------------------------------- | |
| namespace | |
| { | |
| /** returns false, if no header as the focus. | |
| If a header has the focus, true is returned and the index of the header | |
| with focus is set at pIndex if pOutIndex is not 0. | |
| */ | |
| bool lcl_SeriesHeaderHasFocus( | |
| const ::std::vector< ::boost::shared_ptr< ::chart::impl::SeriesHeader > > & rSeriesHeader, | |
| sal_Int32 * pOutIndex = 0 ) | |
| { | |
| sal_Int32 nIndex = 0; | |
| for( ::std::vector< ::boost::shared_ptr< ::chart::impl::SeriesHeader > >::const_iterator aIt( rSeriesHeader.begin()); | |
| aIt != rSeriesHeader.end(); ++aIt, ++nIndex ) | |
| { | |
| if( (*aIt)->HasFocus()) | |
| { | |
| if( pOutIndex ) | |
| *pOutIndex = nIndex; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| sal_Int32 lcl_getColumnInDataOrHeader( | |
| sal_uInt16 nCol, const ::std::vector< ::boost::shared_ptr< ::chart::impl::SeriesHeader > > & rSeriesHeader ) | |
| { | |
| sal_Int32 nColIdx = 0; | |
| bool bHeaderHasFocus( lcl_SeriesHeaderHasFocus( rSeriesHeader, &nColIdx )); | |
| if( bHeaderHasFocus ) | |
| nColIdx = lcl_getColumnInData( static_cast< sal_uInt16 >( rSeriesHeader[nColIdx]->GetStartColumn())); | |
| else | |
| nColIdx = lcl_getColumnInData( nCol ); | |
| return nColIdx; | |
| } | |
| } // anonymous namespace | |
| DataBrowser::DataBrowser( Window* pParent, const ResId& rId, bool bLiveUpdate ) : | |
| ::svt::EditBrowseBox( pParent, rId, EBBF_SMART_TAB_TRAVEL | EBBF_HANDLE_COLUMN_TEXT, BROWSER_STANDARD_FLAGS ), | |
| m_nSeekRow( 0 ), | |
| m_bIsReadOnly( false ), | |
| m_bIsDirty( false ), | |
| m_bLiveUpdate( bLiveUpdate ), | |
| m_bDataValid( true ), | |
| m_aNumberEditField( & EditBrowseBox::GetDataWindow(), WB_NOBORDER ), | |
| m_aTextEditField( & EditBrowseBox::GetDataWindow(), WB_NOBORDER ), | |
| m_rNumberEditController( new ::svt::FormattedFieldCellController( & m_aNumberEditField )), | |
| m_rTextEditController( new ::svt::EditCellController( & m_aTextEditField )) | |
| { | |
| double fNan; | |
| ::rtl::math::setNan( & fNan ); | |
| m_aNumberEditField.SetDefaultValue( fNan ); | |
| m_aNumberEditField.TreatAsNumber( sal_True ); | |
| RenewTable(); | |
| SetClean(); | |
| } | |
| DataBrowser::~DataBrowser() | |
| { | |
| } | |
| bool DataBrowser::MayInsertRow() const | |
| { | |
| return ! IsReadOnly() | |
| && ( !lcl_SeriesHeaderHasFocus( m_aSeriesHeaders )); | |
| } | |
| bool DataBrowser::MayInsertColumn() const | |
| { | |
| return ! IsReadOnly(); | |
| } | |
| bool DataBrowser::MayDeleteRow() const | |
| { | |
| return ! IsReadOnly() | |
| && ( !lcl_SeriesHeaderHasFocus( m_aSeriesHeaders )) | |
| && ( GetCurRow() >= 0 ) | |
| && ( GetRowCount() > 1 ); | |
| } | |
| bool DataBrowser::MayDeleteColumn() const | |
| { | |
| // if a series header has the focus | |
| if( lcl_SeriesHeaderHasFocus( m_aSeriesHeaders )) | |
| return true; | |
| return ! IsReadOnly() | |
| && ( GetCurColumnId() > 1 ) | |
| && ( ColCount() > 2 ); | |
| } | |
| bool DataBrowser::MaySwapRows() const | |
| { | |
| return ! IsReadOnly() | |
| && ( !lcl_SeriesHeaderHasFocus( m_aSeriesHeaders )) | |
| && ( GetCurRow() >= 0 ) | |
| && ( GetCurRow() < GetRowCount() - 1 ); | |
| } | |
| bool DataBrowser::MaySwapColumns() const | |
| { | |
| // if a series header (except the last one) has the focus | |
| { | |
| sal_Int32 nColIndex(0); | |
| if( lcl_SeriesHeaderHasFocus( m_aSeriesHeaders, &nColIndex )) | |
| return (static_cast< sal_uInt32 >( nColIndex ) < (m_aSeriesHeaders.size() - 1)); | |
| } | |
| sal_Int32 nColIdx = lcl_getColumnInDataOrHeader( GetCurColumnId(), m_aSeriesHeaders ); | |
| return ! IsReadOnly() | |
| && ( nColIdx > 0 ) | |
| && ( nColIdx < ColCount()-2 ) | |
| && m_apDataBrowserModel.get() | |
| && !m_apDataBrowserModel->isCategoriesColumn( nColIdx ); | |
| } | |
| void DataBrowser::clearHeaders() | |
| { | |
| ::std::for_each( m_aSeriesHeaders.begin(), m_aSeriesHeaders.end(), impl::applyChangesFunctor()); | |
| m_aSeriesHeaders.clear(); | |
| } | |
| void DataBrowser::RenewTable() | |
| { | |
| if( ! m_apDataBrowserModel.get()) | |
| return; | |
| long nOldRow = GetCurRow(); | |
| sal_uInt16 nOldColId = GetCurColumnId(); | |
| sal_Bool bLastUpdateMode = GetUpdateMode(); | |
| SetUpdateMode( sal_False ); | |
| if( IsModified() ) | |
| SaveModified(); | |
| DeactivateCell(); | |
| RemoveColumns(); | |
| RowRemoved( 1, GetRowCount() ); | |
| // for row numbers | |
| InsertHandleColumn( static_cast< sal_uInt16 >( | |
| GetDataWindow().LogicToPixel( Size( 42, 0 )).getWidth() )); | |
| OUString aDefaultSeriesName( ::chart::SchResId::getResString( STR_COLUMN_LABEL )); | |
| replaceParamterInString( aDefaultSeriesName, C2U("%COLUMNNUMBER"), OUString::valueOf( sal_Int32(24) ) ); | |
| sal_Int32 nColumnWidth = GetDataWindow().GetTextWidth( aDefaultSeriesName ) | |
| + GetDataWindow().LogicToPixel( Point( 4 + impl::SeriesHeader::GetRelativeAppFontXPosForNameField(), 0 ), MAP_APPFONT ).X(); | |
| sal_Int32 nColumnCount = m_apDataBrowserModel->getColumnCount(); | |
| // nRowCount is a member of a base class | |
| sal_Int32 nRowCountLocal = m_apDataBrowserModel->getMaxRowCount(); | |
| for( sal_Int32 nColIdx=1; nColIdx<=nColumnCount; ++nColIdx ) | |
| { | |
| InsertDataColumn( static_cast< sal_uInt16 >( nColIdx ), GetColString( nColIdx ), nColumnWidth ); | |
| } | |
| RowInserted( 1, nRowCountLocal ); | |
| GoToRow( ::std::min( nOldRow, GetRowCount() - 1 )); | |
| GoToColumnId( ::std::min( nOldColId, static_cast< sal_uInt16 >( ColCount() - 1 ))); | |
| Window * pWin = this->GetParent(); | |
| if( !pWin ) | |
| pWin = this; | |
| // fill series headers | |
| clearHeaders(); | |
| const DataBrowserModel::tDataHeaderVector& aHeaders( m_apDataBrowserModel->getDataHeaders()); | |
| Link aFocusLink( LINK( this, DataBrowser, SeriesHeaderGotFocus )); | |
| Link aSeriesHeaderChangedLink( LINK( this, DataBrowser, SeriesHeaderChanged )); | |
| bool bIsHighContrast = pWin ? (pWin->GetSettings().GetStyleSettings().GetHighContrastMode()) : false; | |
| for( DataBrowserModel::tDataHeaderVector::const_iterator aIt( aHeaders.begin()); | |
| aIt != aHeaders.end(); ++aIt ) | |
| { | |
| ::boost::shared_ptr< impl::SeriesHeader > spHeader( new impl::SeriesHeader( pWin )); | |
| Reference< beans::XPropertySet > xSeriesProp( aIt->m_xDataSeries, uno::UNO_QUERY ); | |
| sal_Int32 nColor = 0; | |
| // @todo: Set "DraftColor", i.e. interpolated colors for gradients, bitmaps, etc. | |
| if( xSeriesProp.is() && | |
| ( xSeriesProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("Color"))) >>= nColor )) | |
| spHeader->SetColor( Color( nColor )); | |
| spHeader->SetChartType( aIt->m_xChartType, aIt->m_bSwapXAndYAxis, bIsHighContrast ); | |
| spHeader->SetSeriesName( | |
| String( DataSeriesHelper::getDataSeriesLabel( | |
| aIt->m_xDataSeries, | |
| (aIt->m_xChartType.is() ? | |
| aIt->m_xChartType->getRoleOfSequenceForSeriesLabel() : | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("values-y")))))); | |
| // index is 1-based, as 0 is for the column that contains the row-numbers | |
| spHeader->SetRange( aIt->m_nStartColumn + 1, aIt->m_nEndColumn + 1 ); | |
| spHeader->SetGetFocusHdl( aFocusLink ); | |
| spHeader->SetEditChangedHdl( aSeriesHeaderChangedLink ); | |
| m_aSeriesHeaders.push_back( spHeader ); | |
| } | |
| ImplAdjustHeaderControls(); | |
| SetDirty(); | |
| SetUpdateMode( bLastUpdateMode ); | |
| ActivateCell(); | |
| Invalidate(); | |
| } | |
| String DataBrowser::GetColString( sal_Int32 nColumnId ) const | |
| { | |
| OSL_ASSERT( m_apDataBrowserModel.get()); | |
| if( nColumnId > 0 ) | |
| return String( m_apDataBrowserModel->getRoleOfColumn( static_cast< sal_Int32 >( nColumnId ) - 1 )); | |
| return String(); | |
| } | |
| String DataBrowser::GetRowString( sal_Int32 nRow ) const | |
| { | |
| return String::CreateFromInt32( nRow + 1 ); | |
| } | |
| String DataBrowser::GetCellText( long nRow, sal_uInt16 nColumnId ) const | |
| { | |
| String aResult; | |
| if( nColumnId == 0 ) | |
| { | |
| aResult = GetRowString( static_cast< sal_Int32 >( nRow )); | |
| } | |
| else if( nRow >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| sal_Int32 nColIndex = static_cast< sal_Int32 >( nColumnId ) - 1; | |
| if( m_apDataBrowserModel->getCellType( nColIndex, nRow ) == DataBrowserModel::NUMBER ) | |
| { | |
| double fData( m_apDataBrowserModel->getCellNumber( nColIndex, nRow )); | |
| sal_Int32 nLabelColor; | |
| bool bColorChanged = false; | |
| if( ! ::rtl::math::isNan( fData ) && | |
| m_spNumberFormatterWrapper.get() ) | |
| aResult = String( m_spNumberFormatterWrapper->getFormattedString( | |
| GetNumberFormatKey( nRow, nColumnId ), | |
| fData, nLabelColor, bColorChanged )); | |
| } | |
| else if( m_apDataBrowserModel->getCellType( nColIndex, nRow ) == DataBrowserModel::TEXTORDATE ) | |
| { | |
| uno::Any aAny = m_apDataBrowserModel->getCellAny( nColIndex, nRow ); | |
| OUString aText; | |
| double fDouble=0.0; | |
| if( aAny>>=aText ) | |
| aResult = aText; | |
| else if( aAny>>=fDouble ) | |
| { | |
| sal_Int32 nLabelColor; | |
| bool bColorChanged = false; | |
| sal_Int32 nDateNumberFormat = DiagramHelper::getDateNumberFormat( Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY) ); | |
| if( ! ::rtl::math::isNan( fDouble ) && m_spNumberFormatterWrapper.get() ) | |
| aResult = String( m_spNumberFormatterWrapper->getFormattedString( | |
| nDateNumberFormat, fDouble, nLabelColor, bColorChanged )); | |
| } | |
| } | |
| else | |
| { | |
| OSL_ASSERT( m_apDataBrowserModel->getCellType( nColIndex, nRow ) == DataBrowserModel::TEXT ); | |
| aResult = m_apDataBrowserModel->getCellText( nColIndex, nRow ); | |
| } | |
| } | |
| return aResult; | |
| } | |
| double DataBrowser::GetCellNumber( long nRow, sal_uInt16 nColumnId ) const | |
| { | |
| double fResult; | |
| ::rtl::math::setNan( & fResult ); | |
| if(( nColumnId >= 1 ) && ( nRow >= 0 ) && | |
| m_apDataBrowserModel.get()) | |
| { | |
| fResult = m_apDataBrowserModel->getCellNumber( | |
| static_cast< sal_Int32 >( nColumnId ) - 1, nRow ); | |
| } | |
| return fResult; | |
| } | |
| void DataBrowser::Resize() | |
| { | |
| sal_Bool bLastUpdateMode = GetUpdateMode(); | |
| SetUpdateMode( sal_False ); | |
| ::svt::EditBrowseBox::Resize(); | |
| ImplAdjustHeaderControls(); | |
| SetUpdateMode( bLastUpdateMode ); | |
| } | |
| bool DataBrowser::SetReadOnly( bool bNewState ) | |
| { | |
| bool bResult = m_bIsReadOnly; | |
| if( m_bIsReadOnly != bNewState ) | |
| { | |
| m_bIsReadOnly = bNewState; | |
| Invalidate(); | |
| DeactivateCell(); | |
| } | |
| return bResult; | |
| } | |
| bool DataBrowser::IsReadOnly() const | |
| { | |
| return m_bIsReadOnly; | |
| } | |
| void DataBrowser::SetClean() | |
| { | |
| m_bIsDirty = false; | |
| } | |
| void DataBrowser::SetDirty() | |
| { | |
| if( !m_bLiveUpdate ) | |
| m_bIsDirty = true; | |
| } | |
| void DataBrowser::CursorMoved() | |
| { | |
| EditBrowseBox::CursorMoved(); | |
| if( GetUpdateMode() && m_aCursorMovedHdlLink.IsSet()) | |
| m_aCursorMovedHdlLink.Call( this ); | |
| } | |
| void DataBrowser::SetCellModifiedHdl( const Link& rLink ) | |
| { | |
| m_aCellModifiedLink = rLink; | |
| } | |
| void DataBrowser::MouseButtonDown( const BrowserMouseEvent& rEvt ) | |
| { | |
| if( !m_bDataValid ) | |
| ShowWarningBox(); | |
| else | |
| EditBrowseBox::MouseButtonDown( rEvt ); | |
| } | |
| void DataBrowser::ShowWarningBox() | |
| { | |
| WarningBox( this, WinBits( WB_OK ), | |
| String( SchResId( STR_INVALID_NUMBER ))).Execute(); | |
| } | |
| bool DataBrowser::ShowQueryBox() | |
| { | |
| QueryBox* pQueryBox = new QueryBox( this, WB_YES_NO, String( SchResId( STR_DATA_EDITOR_INCORRECT_INPUT ))); | |
| return ( pQueryBox->Execute() == RET_YES ); | |
| } | |
| bool DataBrowser::IsDataValid() | |
| { | |
| bool bValid = true; | |
| const sal_Int32 nRow = lcl_getRowInData( GetCurRow()); | |
| const sal_Int32 nCol = lcl_getColumnInData( GetCurColumnId()); | |
| if( m_apDataBrowserModel->getCellType( nCol, nRow ) == DataBrowserModel::NUMBER ) | |
| { | |
| sal_uInt32 nDummy = 0; | |
| double fDummy = 0.0; | |
| String aText( m_aNumberEditField.GetText()); | |
| if( aText.Len() > 0 && | |
| m_spNumberFormatterWrapper.get() && | |
| m_spNumberFormatterWrapper->getSvNumberFormatter() && | |
| ! m_spNumberFormatterWrapper->getSvNumberFormatter()->IsNumberFormat( | |
| aText, nDummy, fDummy )) | |
| { | |
| bValid = false; | |
| } | |
| } | |
| return bValid; | |
| } | |
| bool DataBrowser::IsEnableItem() | |
| { | |
| return m_bDataValid; | |
| } | |
| void DataBrowser::CellModified() | |
| { | |
| m_bDataValid = IsDataValid(); | |
| SetDirty(); | |
| if( m_aCellModifiedLink.IsSet()) | |
| m_aCursorMovedHdlLink.Call( this ); | |
| } | |
| void DataBrowser::SetDataFromModel( | |
| const Reference< chart2::XChartDocument > & xChartDoc, | |
| const Reference< uno::XComponentContext > & xContext ) | |
| { | |
| if( m_bLiveUpdate ) | |
| { | |
| m_xChartDoc.set( xChartDoc ); | |
| } | |
| else | |
| { | |
| Reference< util::XCloneable > xCloneable( xChartDoc, uno::UNO_QUERY ); | |
| if( xCloneable.is()) | |
| m_xChartDoc.set( xCloneable->createClone(), uno::UNO_QUERY ); | |
| } | |
| m_apDataBrowserModel.reset( new DataBrowserModel( m_xChartDoc, xContext )); | |
| m_spNumberFormatterWrapper.reset( | |
| new NumberFormatterWrapper( | |
| Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ))); | |
| if( m_spNumberFormatterWrapper.get() ) | |
| m_aNumberEditField.SetFormatter( m_spNumberFormatterWrapper->getSvNumberFormatter() ); | |
| RenewTable(); | |
| const sal_Int32 nColCnt = m_apDataBrowserModel->getColumnCount(); | |
| const sal_Int32 nRowCnt = m_apDataBrowserModel->getMaxRowCount(); | |
| if( nRowCnt && nColCnt ) | |
| { | |
| GoToRow( 0 ); | |
| GoToColumnId( 1 ); | |
| } | |
| SetClean(); | |
| } | |
| void DataBrowser::InsertColumn() | |
| { | |
| sal_Int32 nColIdx = lcl_getColumnInDataOrHeader( GetCurColumnId(), m_aSeriesHeaders ); | |
| if( nColIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_apDataBrowserModel->insertDataSeries( nColIdx ); | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::InsertTextColumn() | |
| { | |
| sal_Int32 nColIdx = lcl_getColumnInDataOrHeader( GetCurColumnId(), m_aSeriesHeaders ); | |
| if( nColIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_apDataBrowserModel->insertComplexCategoryLevel( nColIdx ); | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::RemoveColumn() | |
| { | |
| sal_Int32 nColIdx = lcl_getColumnInDataOrHeader( GetCurColumnId(), m_aSeriesHeaders ); | |
| if( nColIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_bDataValid = true; | |
| m_apDataBrowserModel->removeDataSeriesOrComplexCategoryLevel( nColIdx ); | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::InsertRow() | |
| { | |
| sal_Int32 nRowIdx = lcl_getRowInData( GetCurRow()); | |
| if( nRowIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_apDataBrowserModel->insertDataPointForAllSeries( nRowIdx ); | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::RemoveRow() | |
| { | |
| sal_Int32 nRowIdx = lcl_getRowInData( GetCurRow()); | |
| if( nRowIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_bDataValid = true; | |
| m_apDataBrowserModel->removeDataPointForAllSeries( nRowIdx ); | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::SwapColumn() | |
| { | |
| sal_Int32 nColIdx = lcl_getColumnInDataOrHeader( GetCurColumnId(), m_aSeriesHeaders ); | |
| if( nColIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_apDataBrowserModel->swapDataSeries( nColIdx ); | |
| // keep cursor in swapped column | |
| if( GetCurColumnId() < ColCount() - 1 ) | |
| { | |
| Dispatch( BROWSER_CURSORRIGHT ); | |
| } | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::SwapRow() | |
| { | |
| sal_Int32 nRowIdx = lcl_getRowInData( GetCurRow()); | |
| if( nRowIdx >= 0 && | |
| m_apDataBrowserModel.get()) | |
| { | |
| // save changes made to edit-field | |
| if( IsModified() ) | |
| SaveModified(); | |
| m_apDataBrowserModel->swapDataPointForAllSeries( nRowIdx ); | |
| // keep cursor in swapped row | |
| if( GetCurRow() < GetRowCount() - 1 ) | |
| { | |
| Dispatch( BROWSER_CURSORDOWN ); | |
| } | |
| RenewTable(); | |
| } | |
| } | |
| void DataBrowser::SetCursorMovedHdl( const Link& rLink ) | |
| { | |
| m_aCursorMovedHdlLink = rLink; | |
| } | |
| // implementations for ::svt::EditBrowseBox (pure virtual methods) | |
| void DataBrowser::PaintCell( | |
| OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId ) const | |
| { | |
| Point aPos( rRect.TopLeft()); | |
| aPos.X() += 1; | |
| String aText = GetCellText( m_nSeekRow, nColumnId ); | |
| Size TxtSize( GetDataWindow().GetTextWidth( aText ), GetDataWindow().GetTextHeight()); | |
| // clipping | |
| if( aPos.X() < rRect.Right() || aPos.X() + TxtSize.Width() > rRect.Right() || | |
| aPos.Y() < rRect.Top() || aPos.Y() + TxtSize.Height() > rRect.Bottom()) | |
| rDev.SetClipRegion( rRect ); | |
| // allow for a disabled control ... | |
| sal_Bool bEnabled = IsEnabled(); | |
| Color aOriginalColor = rDev.GetTextColor(); | |
| if( ! bEnabled ) | |
| rDev.SetTextColor( GetSettings().GetStyleSettings().GetDisableColor() ); | |
| // TEST | |
| // if( nColumnId == 1 ) | |
| // // categories | |
| // rDev.SetFillColor( Color( 0xff, 0xff, 0xff )); | |
| // else if( nColumnId == 2 ) | |
| // // x-values | |
| // rDev.SetFillColor( Color( 0xf0, 0xf0, 0xff )); | |
| // else | |
| // // y-values | |
| // rDev.SetFillColor( Color( 0xff, 0xff, 0xf0 )); | |
| // rDev.DrawRect( rRect ); | |
| // draw the text | |
| rDev.DrawText( aPos, aText ); | |
| // reset the color (if necessary) | |
| if( ! bEnabled ) | |
| rDev.SetTextColor( aOriginalColor ); | |
| if( rDev.IsClipRegion()) | |
| rDev.SetClipRegion(); | |
| } | |
| sal_Bool DataBrowser::SeekRow( long nRow ) | |
| { | |
| if( ! EditBrowseBox::SeekRow( nRow )) | |
| return sal_False; | |
| if( nRow < 0 ) | |
| m_nSeekRow = - 1; | |
| else | |
| m_nSeekRow = nRow; | |
| return sal_True; | |
| } | |
| sal_Bool DataBrowser::IsTabAllowed( sal_Bool bForward ) const | |
| { | |
| long nRow = GetCurRow(); | |
| long nCol = GetCurColumnId(); | |
| // column 0 is header-column | |
| long nBadCol = bForward | |
| ? GetColumnCount() - 1 | |
| : 1; | |
| long nBadRow = bForward | |
| ? GetRowCount() - 1 | |
| : 0; | |
| if( !m_bDataValid ) | |
| { | |
| const_cast< DataBrowser* >( this )->ShowWarningBox(); | |
| return sal_False; | |
| } | |
| return ( nRow != nBadRow || | |
| nCol != nBadCol ); | |
| } | |
| ::svt::CellController* DataBrowser::GetController( long nRow, sal_uInt16 nCol ) | |
| { | |
| if( m_bIsReadOnly ) | |
| return 0; | |
| if( CellContainsNumbers( nRow, nCol )) | |
| { | |
| m_aNumberEditField.UseInputStringForFormatting(); | |
| m_aNumberEditField.SetFormatKey( GetNumberFormatKey( nRow, nCol )); | |
| return m_rNumberEditController; | |
| } | |
| return m_rTextEditController; | |
| } | |
| void DataBrowser::InitController( | |
| ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol ) | |
| { | |
| if( rController == m_rTextEditController ) | |
| { | |
| String aText( GetCellText( nRow, nCol ) ); | |
| m_aTextEditField.SetText( aText ); | |
| m_aTextEditField.SetSelection( Selection( 0, aText.Len() )); | |
| } | |
| else if( rController == m_rNumberEditController ) | |
| { | |
| // treat invalid and empty text as Nan | |
| m_aNumberEditField.EnableNotANumber( true ); | |
| if( ::rtl::math::isNan( GetCellNumber( nRow, nCol ))) | |
| m_aNumberEditField.SetTextValue( String()); | |
| else | |
| m_aNumberEditField.SetValue( GetCellNumber( nRow, nCol ) ); | |
| String aText( m_aNumberEditField.GetText()); | |
| m_aNumberEditField.SetSelection( Selection( 0, aText.Len())); | |
| } | |
| else | |
| { | |
| DBG_ERROR( "Invalid Controller" ); | |
| } | |
| } | |
| bool DataBrowser::CellContainsNumbers( sal_Int32 nRow, sal_uInt16 nCol ) const | |
| { | |
| if( ! m_apDataBrowserModel.get()) | |
| return false; | |
| return (m_apDataBrowserModel->getCellType( lcl_getColumnInData( nCol ), lcl_getRowInData( nRow )) == | |
| DataBrowserModel::NUMBER); | |
| } | |
| sal_uInt32 DataBrowser::GetNumberFormatKey( sal_Int32 nRow, sal_uInt16 nCol ) const | |
| { | |
| if( ! m_apDataBrowserModel.get()) | |
| return 0; | |
| return m_apDataBrowserModel->getNumberFormatKey( lcl_getColumnInData( nCol ), lcl_getRowInData( nRow )); | |
| } | |
| bool DataBrowser::isDateString( rtl::OUString aInputString, double& fOutDateValue ) | |
| { | |
| sal_uInt32 nNumberFormat=0; | |
| SvNumberFormatter* pSvNumberFormatter = m_spNumberFormatterWrapper.get() ? m_spNumberFormatterWrapper->getSvNumberFormatter() : 0; | |
| if( !aInputString.isEmpty() && pSvNumberFormatter && pSvNumberFormatter->IsNumberFormat( aInputString, nNumberFormat, fOutDateValue ) ) | |
| { | |
| Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( m_xChartDoc, uno::UNO_QUERY ); | |
| Reference< util::XNumberFormats > xNumberFormats; | |
| if( xNumberFormatsSupplier.is() ) | |
| xNumberFormats = Reference< util::XNumberFormats >( xNumberFormatsSupplier->getNumberFormats() ); | |
| if( DiagramHelper::isDateNumberFormat( nNumberFormat, xNumberFormats ) ) | |
| return true; | |
| } | |
| return false; | |
| } | |
| sal_Bool DataBrowser::SaveModified() | |
| { | |
| if( ! IsModified() ) | |
| return sal_True; | |
| sal_Bool bChangeValid = sal_True; | |
| const sal_Int32 nRow = lcl_getRowInData( GetCurRow()); | |
| const sal_Int32 nCol = lcl_getColumnInData( GetCurColumnId()); | |
| DBG_ASSERT( nRow >= 0 || nCol >= 0, "This cell should not be modified!" ); | |
| SvNumberFormatter* pSvNumberFormatter = m_spNumberFormatterWrapper.get() ? m_spNumberFormatterWrapper->getSvNumberFormatter() : 0; | |
| switch( m_apDataBrowserModel->getCellType( nCol, nRow )) | |
| { | |
| case DataBrowserModel::NUMBER: | |
| { | |
| sal_uInt32 nDummy = 0; | |
| double fDummy = 0.0; | |
| String aText( m_aNumberEditField.GetText()); | |
| // an empty string is valid, if no numberformatter exists, all | |
| // values are treated as valid | |
| if( aText.Len() > 0 && pSvNumberFormatter && | |
| ! pSvNumberFormatter->IsNumberFormat( aText, nDummy, fDummy ) ) | |
| { | |
| bChangeValid = sal_False; | |
| } | |
| else | |
| { | |
| double fData = m_aNumberEditField.GetValue(); | |
| bChangeValid = m_apDataBrowserModel->setCellNumber( nCol, nRow, fData ); | |
| } | |
| } | |
| break; | |
| case DataBrowserModel::TEXTORDATE: | |
| { | |
| OUString aText( m_aTextEditField.GetText() ); | |
| double fDateValue=0.0; | |
| bChangeValid = sal_False; | |
| if( isDateString( aText, fDateValue ) ) | |
| bChangeValid = m_apDataBrowserModel->setCellAny( nCol, nRow, uno::makeAny( fDateValue ) ); | |
| if(!bChangeValid) | |
| bChangeValid = m_apDataBrowserModel->setCellAny( nCol, nRow, uno::makeAny( aText ) ); | |
| } | |
| break; | |
| case DataBrowserModel::TEXT: | |
| { | |
| OUString aText( m_aTextEditField.GetText()); | |
| bChangeValid = m_apDataBrowserModel->setCellText( nCol, nRow, aText ); | |
| } | |
| break; | |
| } | |
| // the first valid change changes this to true | |
| if( bChangeValid ) | |
| { | |
| RowModified( GetCurRow(), GetCurColumnId()); | |
| ::svt::CellController* pCtrl = GetController( GetCurRow(), GetCurColumnId()); | |
| if( pCtrl ) | |
| pCtrl->ClearModified(); | |
| SetDirty(); | |
| } | |
| return bChangeValid; | |
| } | |
| bool DataBrowser::EndEditing() | |
| { | |
| if( IsModified()) | |
| SaveModified(); | |
| // apply changes made to series headers | |
| ::std::for_each( m_aSeriesHeaders.begin(), m_aSeriesHeaders.end(), impl::applyChangesFunctor()); | |
| if( m_bDataValid ) | |
| return true; | |
| else | |
| return ShowQueryBox(); | |
| } | |
| sal_Int16 DataBrowser::GetFirstVisibleColumNumber() const | |
| { | |
| return GetFirstVisibleColNumber(); | |
| } | |
| void DataBrowser::ColumnResized( sal_uInt16 nColId ) | |
| { | |
| sal_Bool bLastUpdateMode = GetUpdateMode(); | |
| SetUpdateMode( sal_False ); | |
| EditBrowseBox::ColumnResized( nColId ); | |
| ImplAdjustHeaderControls(); | |
| SetUpdateMode( bLastUpdateMode ); | |
| } | |
| // virtual void MouseMove( const MouseEvent& rEvt ); | |
| void DataBrowser::EndScroll() | |
| { | |
| sal_Bool bLastUpdateMode = GetUpdateMode(); | |
| SetUpdateMode( sal_False ); | |
| EditBrowseBox::EndScroll(); | |
| RenewSeriesHeaders(); | |
| SetUpdateMode( bLastUpdateMode ); | |
| } | |
| void DataBrowser::RenewSeriesHeaders() | |
| { | |
| Window * pWin = this->GetParent(); | |
| if( !pWin ) | |
| pWin = this; | |
| clearHeaders(); | |
| DataBrowserModel::tDataHeaderVector aHeaders( m_apDataBrowserModel->getDataHeaders()); | |
| Link aFocusLink( LINK( this, DataBrowser, SeriesHeaderGotFocus )); | |
| Link aSeriesHeaderChangedLink( LINK( this, DataBrowser, SeriesHeaderChanged )); | |
| bool bIsHighContrast = pWin ? (pWin->GetSettings().GetStyleSettings().GetHighContrastMode()) : false; | |
| for( DataBrowserModel::tDataHeaderVector::const_iterator aIt( aHeaders.begin()); | |
| aIt != aHeaders.end(); ++aIt ) | |
| { | |
| ::boost::shared_ptr< impl::SeriesHeader > spHeader( new impl::SeriesHeader( pWin )); | |
| Reference< beans::XPropertySet > xSeriesProp( aIt->m_xDataSeries, uno::UNO_QUERY ); | |
| sal_Int32 nColor = 0; | |
| if( xSeriesProp.is() && | |
| ( xSeriesProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("Color"))) >>= nColor )) | |
| spHeader->SetColor( Color( nColor )); | |
| spHeader->SetChartType( aIt->m_xChartType, aIt->m_bSwapXAndYAxis, bIsHighContrast ); | |
| spHeader->SetSeriesName( | |
| String( DataSeriesHelper::getDataSeriesLabel( | |
| aIt->m_xDataSeries, | |
| (aIt->m_xChartType.is() ? | |
| aIt->m_xChartType->getRoleOfSequenceForSeriesLabel() : | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("values-y")))))); | |
| spHeader->SetRange( aIt->m_nStartColumn + 1, aIt->m_nEndColumn + 1 ); | |
| spHeader->SetGetFocusHdl( aFocusLink ); | |
| spHeader->SetEditChangedHdl( aSeriesHeaderChangedLink ); | |
| m_aSeriesHeaders.push_back( spHeader ); | |
| } | |
| ImplAdjustHeaderControls(); | |
| } | |
| void DataBrowser::ImplAdjustHeaderControls() | |
| { | |
| sal_uInt16 nColCount = this->GetColumnCount(); | |
| sal_uInt32 nCurrentPos = this->GetPosPixel().getX(); | |
| sal_uInt32 nMaxPos = nCurrentPos + this->GetOutputSizePixel().getWidth(); | |
| sal_uInt32 nStartPos = nCurrentPos; | |
| // width of header column | |
| nCurrentPos += this->GetColumnWidth( 0 ); | |
| tSeriesHeaderContainer::iterator aIt( m_aSeriesHeaders.begin()); | |
| sal_uInt16 i = this->GetFirstVisibleColumNumber(); | |
| while( (aIt != m_aSeriesHeaders.end()) && ((*aIt)->GetStartColumn() < i) ) | |
| ++aIt; | |
| for( ; i < nColCount && aIt != m_aSeriesHeaders.end(); ++i ) | |
| { | |
| if( (*aIt)->GetStartColumn() == i ) | |
| nStartPos = nCurrentPos; | |
| nCurrentPos += (this->GetColumnWidth( i )); | |
| if( (*aIt)->GetEndColumn() == i ) | |
| { | |
| if( nStartPos < nMaxPos ) | |
| { | |
| (*aIt)->SetPixelPosX( nStartPos + 2 ); | |
| (*aIt)->SetPixelWidth( nCurrentPos - nStartPos - 3 ); | |
| } | |
| else | |
| // do not hide, to get focus events. Move outside the dialog for "hiding" | |
| (*aIt)->SetPixelPosX( nMaxPos + 42 ); | |
| ++aIt; | |
| } | |
| } | |
| } | |
| IMPL_LINK( DataBrowser, SeriesHeaderGotFocus, impl::SeriesHeaderEdit*, pEdit ) | |
| { | |
| if( pEdit ) | |
| { | |
| pEdit->SetShowWarningBox( !m_bDataValid ); | |
| if( !m_bDataValid ) | |
| GoToCell( 0, 0 ); | |
| else | |
| { | |
| //DeactivateCell(); | |
| MakeFieldVisible( GetCurRow(), static_cast< sal_uInt16 >( pEdit->getStartColumn()), true /* bComplete */ ); | |
| ActivateCell(); | |
| m_aCursorMovedHdlLink.Call( this ); | |
| } | |
| } | |
| return 0; | |
| } | |
| IMPL_LINK( DataBrowser, SeriesHeaderChanged, impl::SeriesHeaderEdit*, pEdit ) | |
| { | |
| if( pEdit ) | |
| { | |
| Reference< chart2::XDataSeries > xSeries( | |
| m_apDataBrowserModel->getDataSeriesByColumn( pEdit->getStartColumn() - 1 )); | |
| Reference< chart2::data::XDataSource > xSource( xSeries, uno::UNO_QUERY ); | |
| if( xSource.is()) | |
| { | |
| Reference< chart2::XChartType > xChartType( | |
| m_apDataBrowserModel->getHeaderForSeries( xSeries ).m_xChartType ); | |
| if( xChartType.is()) | |
| { | |
| Reference< chart2::data::XLabeledDataSequence > xLabeledSeq( | |
| DataSeriesHelper::getDataSequenceByRole( xSource, xChartType->getRoleOfSequenceForSeriesLabel())); | |
| if( xLabeledSeq.is()) | |
| { | |
| Reference< container::XIndexReplace > xIndexReplace( xLabeledSeq->getLabel(), uno::UNO_QUERY ); | |
| if( xIndexReplace.is()) | |
| xIndexReplace->replaceByIndex( | |
| 0, uno::makeAny( OUString( pEdit->GetText()))); | |
| } | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| sal_Int32 DataBrowser::GetTotalWidth() const | |
| { | |
| sal_uLong nWidth = 0; | |
| for ( sal_uInt16 nCol = 0; nCol < ColCount(); ++nCol ) | |
| nWidth += GetColumnWidth( nCol ); | |
| return static_cast< sal_Int32 >( nWidth ); | |
| } | |
| } // namespace chart |