diff options
Diffstat (limited to 'sc/source/ui/vba')
32 files changed, 2278 insertions, 1186 deletions
diff --git a/sc/source/ui/vba/excelvbahelper.cxx b/sc/source/ui/vba/excelvbahelper.cxx index 2c39d7154b4b..7d1dcd2e6dc7 100644 --- a/sc/source/ui/vba/excelvbahelper.cxx +++ b/sc/source/ui/vba/excelvbahelper.cxx @@ -30,6 +30,9 @@ #include "transobj.hxx" #include "scmod.hxx" #include "cellsuno.hxx" +#include "compiler.hxx" +#include "token.hxx" +#include "tokenarray.hxx" #include <comphelper/processfactory.hxx> #include <com/sun/star/sheet/XSheetCellRange.hpp> @@ -43,6 +46,52 @@ namespace vba namespace excel { +uno::Reference< sheet::XDatabaseRanges > +GetDataBaseRanges( ScDocShell* pShell ) throw ( uno::RuntimeException ) +{ + uno::Reference< frame::XModel > xModel; + if ( pShell ) + xModel.set( pShell->GetModel(), uno::UNO_QUERY_THROW ); + uno::Reference< beans::XPropertySet > xModelProps( xModel, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XDatabaseRanges > xDBRanges( xModelProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DatabaseRanges") ) ), uno::UNO_QUERY_THROW ); + return xDBRanges; +} + +// returns the XDatabaseRange for the autofilter on sheet (nSheet) +// also populates sName with the name of range +uno::Reference< sheet::XDatabaseRange > +GetAutoFiltRange( ScDocShell* pShell, sal_Int16 nSheet, rtl::OUString& sName ) throw ( uno::RuntimeException ) +{ + uno::Reference< container::XIndexAccess > xIndexAccess( GetDataBaseRanges( pShell ), uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XDatabaseRange > xDataBaseRange; + table::CellRangeAddress dbAddress; + for ( sal_Int32 index=0; index < xIndexAccess->getCount(); ++index ) + { + uno::Reference< sheet::XDatabaseRange > xDBRange( xIndexAccess->getByIndex( index ), uno::UNO_QUERY_THROW ); + uno::Reference< container::XNamed > xNamed( xDBRange, uno::UNO_QUERY_THROW ); + // autofilters work weirdly with openoffice, unnamed is the default + // named range which is used to create an autofilter, but + // its also possible that another name could be used + // this also causes problems when an autofilter is created on + // another sheet + // ( but.. you can use any named range ) + dbAddress = xDBRange->getDataArea(); + if ( dbAddress.Sheet == nSheet ) + { + sal_Bool bHasAuto = sal_False; + uno::Reference< beans::XPropertySet > xProps( xDBRange, uno::UNO_QUERY_THROW ); + xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("AutoFilter") ) ) >>= bHasAuto; + if ( bHasAuto ) + { + sName = xNamed->getName(); + xDataBaseRange=xDBRange; + break; + } + } + } + return xDataBaseRange; +} + ScDocShell* GetDocShellFromRange( const uno::Reference< uno::XInterface >& xRange ) throw ( uno::RuntimeException ) { ScCellRangesBase* pScCellRangesBase = ScCellRangesBase::getImplementation( xRange ); @@ -53,6 +102,13 @@ ScDocShell* GetDocShellFromRange( const uno::Reference< uno::XInterface >& xRang return pScCellRangesBase->GetDocShell(); } +ScDocShell* GetDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException ) +{ + // need the ScCellRangesBase to get docshell + uno::Reference< uno::XInterface > xIf( xRanges, uno::UNO_QUERY_THROW ); + return GetDocShellFromRange( xIf ); +} + ScDocument* GetDocumentFromRange( const uno::Reference< uno::XInterface >& xRange ) throw ( uno::RuntimeException ) { ScDocShell* pDocShell = GetDocShellFromRange( xRange ); @@ -63,6 +119,16 @@ ScDocument* GetDocumentFromRange( const uno::Reference< uno::XInterface >& xRang return pDocShell->GetDocument(); } +uno::Reference< frame::XModel > GetModelFromRange( const uno::Reference< uno::XInterface >& xRange ) throw ( uno::RuntimeException ) +{ + ScDocShell* pDocShell = GetDocShellFromRange( xRange ); + if ( !pDocShell ) + { + throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access underlying model uno range object" ) ), uno::Reference< uno::XInterface >() ); + } + return pDocShell->GetModel(); +} + void implSetZoom( const uno::Reference< frame::XModel >& xModel, sal_Int16 nZoom, std::vector< SCTAB >& nTabs ) { ScTabViewShell* pViewSh = excel::getBestViewShell( xModel ); @@ -192,6 +258,15 @@ void implnPasteSpecial( const uno::Reference< frame::XModel>& xModel, USHORT nFl } +void implnCopyRange( const uno::Reference< frame::XModel>& xModel, const ScRange& rRange ) +{ + ScTabViewShell* pViewShell = getBestViewShell( xModel ); + if ( pViewShell ) + { + pViewShell->CopyToClip( NULL, rRange, FALSE, TRUE, TRUE ); + } +} + ScDocShell* getDocShell( const css::uno::Reference< css::frame::XModel>& xModel ) { @@ -229,6 +304,19 @@ getViewFrame( const uno::Reference< frame::XModel >& xModel ) return NULL; } +sal_Bool IsR1C1ReferFormat( ScDocument* pDoc, const rtl::OUString& sRangeStr ) +{ + ScRangeList aCellRanges; + String sAddress( sRangeStr ); + USHORT nMask = SCA_VALID; + USHORT rResFlags = aCellRanges.Parse( sAddress, pDoc, nMask, formula::FormulaGrammar::CONV_XL_R1C1 ); + if ( rResFlags & SCA_VALID ) + { + return sal_True; + } + return sal_False; +} + uno::Reference< XHelperInterface > getUnoSheetModuleObj( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) { @@ -246,6 +334,84 @@ getUnoSheetModuleObj( const uno::Reference< table::XCellRange >& xRange ) throw return xParent; } +formula::FormulaGrammar::Grammar GetFormulaGrammar( ScDocument* pDoc, const ScAddress& sAddress, const css::uno::Any& aFormula ) +{ + formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_NATIVE_XL_A1; + if ( pDoc && aFormula.hasValue() && aFormula.getValueTypeClass() == uno::TypeClass_STRING ) + { + rtl::OUString sFormula; + aFormula >>= sFormula; + + ScCompiler aCompiler( pDoc, sAddress ); + aCompiler.SetGrammar( formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 ); + ScTokenArray* pCode = aCompiler.CompileString( sFormula ); + if ( pCode ) + { + USHORT nLen = pCode->GetLen(); + formula::FormulaToken** pTokens = pCode->GetArray(); + for ( USHORT nPos = 0; nPos < nLen; nPos++ ) + { + const formula::FormulaToken& rToken = *pTokens[nPos]; + switch ( rToken.GetType() ) + { + case formula::svSingleRef: + case formula::svDoubleRef: + { + return formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1; + } + break; + default: break; + } + } + } + } + return eGrammar; +} + +void CompileExcelFormulaToODF( ScDocument* pDoc, const String& rOldFormula, String& rNewFormula ) +{ + if ( !pDoc ) + { + return; + } + ScCompiler aCompiler( pDoc, ScAddress() ); + aCompiler.SetGrammar( excel::GetFormulaGrammar( pDoc, ScAddress(), uno::Any( rtl::OUString( rOldFormula ) ) ) ); + ScTokenArray* pCode = aCompiler.CompileString( rOldFormula ); + aCompiler.SetGrammar( formula::FormulaGrammar::GRAM_PODF_A1 ); + aCompiler.CreateStringFromTokenArray( rNewFormula ); +} + +void CompileODFFormulaToExcel( ScDocument* pDoc, const String& rOldFormula, String& rNewFormula, const formula::FormulaGrammar::Grammar eGrammar ) +{ + // eGrammar can be formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 and formula::FormulaGrammar::GRAM_NATIVE_XL_A1 + if ( !pDoc ) + { + return; + } + ScCompiler aCompiler( pDoc, ScAddress() ); + aCompiler.SetGrammar( formula::FormulaGrammar::GRAM_PODF_A1 ); + ScTokenArray* pCode = aCompiler.CompileString( rOldFormula ); + aCompiler.SetGrammar( eGrammar ); + if ( !pCode ) + { + return; + } + USHORT nLen = pCode->GetLen(); + formula::FormulaToken** pTokens = pCode->GetArray(); + for ( USHORT nPos = 0; nPos < nLen && pTokens[nPos]; nPos++ ) + { + String rFormula; + formula::FormulaToken* pToken = pTokens[nPos]; + aCompiler.CreateStringFromToken( rFormula, pToken, TRUE ); + if ( pToken->GetOpCode() == ocSep ) + { + // Excel formula separator is ",". + rFormula = String::CreateFromAscii(","); + } + rNewFormula += rFormula; + } +} + uno::Reference< XHelperInterface > getUnoSheetModuleObj( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException ) { diff --git a/sc/source/ui/vba/excelvbahelper.hxx b/sc/source/ui/vba/excelvbahelper.hxx index da0474e6ceb0..fca3d11958fc 100644 --- a/sc/source/ui/vba/excelvbahelper.hxx +++ b/sc/source/ui/vba/excelvbahelper.hxx @@ -29,9 +29,12 @@ #include<vbahelper/vbahelper.hxx> #include <docsh.hxx> +#include <com/sun/star/sheet/XDatabaseRanges.hpp> +#include <com/sun/star/sheet/XDatabaseRange.hpp> #include <com/sun/star/table/XCellRange.hpp> #include <com/sun/star/sheet/XSheetCellRangeContainer.hpp> #include <ooo/vba/XHelperInterface.hpp> +#include <formula/grammar.hxx> class ScCellRangesBase; @@ -39,29 +42,39 @@ namespace ooo { namespace vba { - namespace excel + namespace excel { - // nTabs empty means apply zoom to all sheets - void implSetZoom( const css::uno::Reference< css::frame::XModel >& xModel, sal_Int16 nZoom, std::vector< SCTAB >& nTabs ); - void implnCopy( const css::uno::Reference< css::frame::XModel>& xModel ); - void implnPaste ( const css::uno::Reference< css::frame::XModel>& xModel ); - void implnCut( const css::uno::Reference< css::frame::XModel>& xModel ); - void implnPasteSpecial( const css::uno::Reference< css::frame::XModel>& xModel, sal_uInt16 nFlags,sal_uInt16 nFunction,sal_Bool bSkipEmpty, sal_Bool bTranspose); - ScTabViewShell* getBestViewShell( const css::uno::Reference< css::frame::XModel>& xModel ) ; - ScDocShell* getDocShell( const css::uno::Reference< css::frame::XModel>& xModel ) ; - ScTabViewShell* getCurrentBestViewShell( const css::uno::Reference< css::uno::XComponentContext >& xContext ); - SfxViewFrame* getViewFrame( const css::uno::Reference< css::frame::XModel >& xModel ); + // nTabs empty means apply zoom to all sheets + void implSetZoom( const css::uno::Reference< css::frame::XModel >& xModel, sal_Int16 nZoom, std::vector< SCTAB >& nTabs ); + void implnCopy( const css::uno::Reference< css::frame::XModel>& xModel ); + void implnPaste ( const css::uno::Reference< css::frame::XModel>& xModel ); + void implnCut( const css::uno::Reference< css::frame::XModel>& xModel ); + void implnPasteSpecial( const css::uno::Reference< css::frame::XModel>& xModel, sal_uInt16 nFlags,sal_uInt16 nFunction,sal_Bool bSkipEmpty, sal_Bool bTranspose); + void implnCopyRange( const css::uno::Reference< css::frame::XModel>& xModel, const ScRange& rRange ); + ScTabViewShell* getBestViewShell( const css::uno::Reference< css::frame::XModel>& xModel ) ; + ScDocShell* getDocShell( const css::uno::Reference< css::frame::XModel>& xModel ) ; + ScTabViewShell* getCurrentBestViewShell( const css::uno::Reference< css::uno::XComponentContext >& xContext ); + SfxViewFrame* getViewFrame( const css::uno::Reference< css::frame::XModel >& xModel ); + sal_Bool IsR1C1ReferFormat( ScDocument* pDoc, const ::rtl::OUString& sRangeStr ); + formula::FormulaGrammar::Grammar GetFormulaGrammar( ScDocument* pDoc, const ScAddress& sAddress, const css::uno::Any& aFormula ); + void CompileExcelFormulaToODF( ScDocument* pDoc, const String& rOldFormula, String& rNewFormula ); + void CompileODFFormulaToExcel( ScDocument* pDoc, const String& rOldFormula, String& rNewFormula, const formula::FormulaGrammar::Grammar eGrammar ); + css::uno::Reference< css::sheet::XDatabaseRanges > GetDataBaseRanges( ScDocShell* pShell ) throw ( css::uno::RuntimeException ); + + css::uno::Reference< css::sheet::XDatabaseRange > GetAutoFiltRange( ScDocShell* pShell, sal_Int16 nSheet, rtl::OUString& sName ) throw ( css::uno::RuntimeException ); css::uno::Reference< ooo::vba::XHelperInterface > getUnoSheetModuleObj( const css::uno::Reference< css::sheet::XSheetCellRangeContainer >& xRanges ) throw ( css::uno::RuntimeException ); css::uno::Reference< ooo::vba::XHelperInterface > getUnoSheetModuleObj( const css::uno::Reference< css::table::XCellRange >& xRange ) throw ( css::uno::RuntimeException ); ScDocShell* GetDocShellFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException ); + ScDocShell* GetDocShellFromRanges( const css::uno::Reference< css::sheet::XSheetCellRangeContainer >& xRanges ) throw ( css::uno::RuntimeException ); ScDocument* GetDocumentFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException ); css::uno::Reference< css::frame::XModel > GetModelFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException ); + class ScVbaCellRangeAccess { public: static SfxItemSet* GetDataSet( ScCellRangesBase* pRangeObj ); }; -} -} + } + } } #endif diff --git a/sc/source/ui/vba/makefile.mk b/sc/source/ui/vba/makefile.mk index 92bb3fd39db0..ba50cbad9abd 100644 --- a/sc/source/ui/vba/makefile.mk +++ b/sc/source/ui/vba/makefile.mk @@ -31,7 +31,7 @@ PRJNAME=sc TARGET=vbaobj ENABLE_EXCEPTIONS=TRUE VISIBILITY_HIDDEN=TRUE - +CDEFS+=-DVBA_OOBUILD_HACK # --- Settings ----------------------------------------------------- .INCLUDE : settings.mk @@ -63,18 +63,29 @@ SLOFILES= \ $(SLO)$/vbacharttitle.obj \ $(SLO)$/vbacomment.obj \ $(SLO)$/vbacomments.obj \ + $(SLO)$/vbacommentshape.obj \ $(SLO)$/vbacondition.obj \ $(SLO)$/vbadialog.obj \ $(SLO)$/vbadialogs.obj \ $(SLO)$/vbaeventshelper.obj \ + $(SLO)$/vbafiledialog.obj \ + $(SLO)$/vbafiledialogselecteditems.obj \ + $(SLO)$/vbafilesearch.obj \ $(SLO)$/vbafont.obj \ $(SLO)$/vbaformat.obj \ $(SLO)$/vbaformatcondition.obj \ $(SLO)$/vbaformatconditions.obj \ + $(SLO)$/vbafoundfiles.obj \ $(SLO)$/vbaglobals.obj \ $(SLO)$/vbahyperlink.obj \ $(SLO)$/vbahyperlinks.obj \ $(SLO)$/vbainterior.obj \ + $(SLO)$/vbamenubar.obj \ + $(SLO)$/vbamenubars.obj \ + $(SLO)$/vbamenu.obj \ + $(SLO)$/vbamenus.obj \ + $(SLO)$/vbamenuitem.obj \ + $(SLO)$/vbamenuitems.obj \ $(SLO)$/vbaname.obj \ $(SLO)$/vbanames.obj \ $(SLO)$/vbaoleobject.obj \ @@ -88,6 +99,7 @@ SLOFILES= \ $(SLO)$/vbapivotcache.obj \ $(SLO)$/vbapivottable.obj \ $(SLO)$/vbapivottables.obj \ + $(SLO)$/vbaquerytable.obj \ $(SLO)$/vbarange.obj \ $(SLO)$/vbaseriescollection.obj \ $(SLO)$/vbasheetobject.obj \ diff --git a/sc/source/ui/vba/testvba/testvba.cxx b/sc/source/ui/vba/testvba/testvba.cxx index 686b3e47eaa9..6ae1fb9e1cfc 100644 --- a/sc/source/ui/vba/testvba/testvba.cxx +++ b/sc/source/ui/vba/testvba/testvba.cxx @@ -159,15 +159,15 @@ mxCompLoader( _xCompLoader ), msOutDirPath( convertToURL( _outDirPath ) ) Reference< script::provider::XScript > xScript; try { - xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:Standard.TestMacros.Main?language=Basic&location=document" )); + xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:VBAProject.TestMacros.Main?language=Basic&location=document" )); } catch ( uno::Exception& e ) { try { - xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:Standard.testMacro.Main?language=Basic&location=document" )); + xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:VBAProject.testMacro.Main?language=Basic&location=document" )); } catch ( uno::Exception& e2 ) { - xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:Standard.testMain.Main?language=Basic&location=document" )); + xScript = xProv->getScript( rtl::OUString::createFromAscii( "vnd.sun.star.script:VBAProject.testMain.Main?language=Basic&location=document" )); } } OSL_TRACE("Got script for doc %s", rtl::OUStringToOString( sUrl, RTL_TEXTENCODING_UTF8 ).getStr() ); diff --git a/sc/source/ui/vba/vbaapplication.cxx b/sc/source/ui/vba/vbaapplication.cxx index f3965393e919..de2bf4964055 100644 --- a/sc/source/ui/vba/vbaapplication.cxx +++ b/sc/source/ui/vba/vbaapplication.cxx @@ -27,11 +27,14 @@ #include <stdio.h> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> #include <com/sun/star/sheet/XSpreadsheetView.hpp> #include <com/sun/star/sheet/XSpreadsheets.hpp> #include <com/sun/star/view/XSelectionSupplier.hpp> #include <com/sun/star/lang/XServiceInfo.hpp> #include <ooo/vba/excel/XlCalculation.hpp> +#include <ooo/vba/excel/XlCutCopyMode.hpp> #include <com/sun/star/sheet/XCellRangeReferrer.hpp> #include <com/sun/star/sheet/XCalculatable.hpp> #include <com/sun/star/frame/XLayoutManager.hpp> @@ -40,6 +43,19 @@ #include <ooo/vba/excel/XlMousePointer.hpp> #include <com/sun/star/sheet/XNamedRanges.hpp> #include <com/sun/star/sheet/XCellRangeAddressable.hpp> +#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp> +#include <com/sun/star/ui/dialogs/XFilePicker.hpp> +#include <com/sun/star/ui/dialogs/XFilePicker2.hpp> +#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +//2009-11-06 add by limingl +#include <com/sun/star/ui/dialogs/XFilterManager.hpp> +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +//end +#include<ooo/vba/XCommandBars.hpp> +#include <ooo/vba/excel/XlEnableCancelKey.hpp> //liuchen 2009-11-26 +#include <ooo/vba/excel/XlApplicationInternational.hpp> //liuchen 2009-11-26 +#include <unotools/localedatawrapper.hxx> //liuchen 2009-11-26 #include "vbaapplication.hxx" #include "vbaworkbooks.hxx" @@ -51,25 +67,37 @@ #include "vbawindow.hxx" #include "vbawindows.hxx" #include "vbaglobals.hxx" +#include "vbamenubars.hxx" #include "tabvwsh.hxx" #include "gridwin.hxx" #include "vbanames.hxx" #include <vbahelper/vbashape.hxx> #include "vbatextboxshape.hxx" #include "vbaassistant.hxx" +#include "vbafilesearch.hxx" //liuchen 2009-8-18, add the support of VBA Application.FileSearch #include "sc.hrc" +#include "macromgr.hxx" +#include "global.hxx" //liuchen 2009-11-26 +#include "scmod.hxx" //liuchen 2009-11-26 +#include "docoptio.hxx" //liuchen 2009-11-26 +#include "appoptio.hxx" #include <osl/file.hxx> +#include <map> + #include <sfx2/request.hxx> #include <sfx2/objsh.hxx> #include <sfx2/viewfrm.hxx> #include <sfx2/app.hxx> +#include <comphelper/processfactory.hxx> + #include <toolkit/awt/vclxwindow.hxx> #include <toolkit/helper/vclunohelper.hxx> #include <tools/diagnose_ex.h> +#include <tools/urlobj.hxx> #include <docuno.hxx> @@ -78,15 +106,29 @@ #include <basic/sbuno.hxx> #include <basic/sbmeth.hxx> +#include "transobj.hxx" #include "convuno.hxx" #include "cellsuno.hxx" +#include "miscuno.hxx" +#include "unonames.hxx" #include "docsh.hxx" #include <vbahelper/helperdecl.hxx> #include "excelvbahelper.hxx" - +#include <basic/sbmeth.hxx> +#include <basic/sbmod.hxx> +#include <basic/sbstar.hxx> +#include <basic/sbx.hxx> +#include <basic/sbxobj.hxx> +#include <basic/sbuno.hxx> +//limingl 2009-07-20 +#include "vbafiledialog.hxx" using namespace ::ooo::vba; using namespace ::com::sun::star; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::uno::UNO_QUERY_THROW; +using ::com::sun::star::uno::UNO_QUERY; +using ::rtl::OUString; // #TODO is this defined somewhere else? #if ( defined UNX ) || ( defined OS2 ) //unix @@ -237,16 +279,49 @@ ScVbaApplication::getAssistant() throw (uno::RuntimeException) return uno::Reference< XAssistant >( new ScVbaAssistant( this, mxContext ) ); } +//liuchen 2009-8-18, add support of VBA Application.FileSearch +uno::Reference< XFileSearch > SAL_CALL +ScVbaApplication::getFileSearch() throw (uno::RuntimeException) +{ + if (! m_xFileSearch.get() ) + { + m_xFileSearch = uno::Reference< XFileSearch >( new ScVbaFileSearch( this, uno::Reference< XHelperInterface >( this ), mxContext ) ); + } + + return m_xFileSearch; +} +//liuchen + uno::Any SAL_CALL ScVbaApplication::getSelection() throw (uno::RuntimeException) { OSL_TRACE("** ScVbaApplication::getSelection() ** "); uno::Reference< frame::XModel > xModel( getCurrentDocument() ); - uno::Reference< lang::XServiceInfo > xServiceInfo( xModel->getCurrentSelection(), uno::UNO_QUERY_THROW ); - rtl::OUString sImpementaionName = xServiceInfo->getImplementationName(); - if( sImpementaionName.equalsIgnoreAsciiCaseAscii("com.sun.star.drawing.SvxShapeCollection") ) + + Reference< view::XSelectionSupplier > xSelSupp( xModel->getCurrentController(), UNO_QUERY_THROW ); + Reference< beans::XPropertySet > xPropSet( xSelSupp, UNO_QUERY_THROW ); + OUString aPropName = OUString::createFromAscii( SC_UNO_FILTERED_RANGE_SELECTION ); + uno::Any aOldVal = xPropSet->getPropertyValue( aPropName ); + uno::Any any; + any <<= sal_False; + xPropSet->setPropertyValue( aPropName, any ); + uno::Reference< uno::XInterface > aSelection = ScUnoHelpFunctions::AnyToInterface( + xSelSupp->getSelection() ); + xPropSet->setPropertyValue( aPropName, aOldVal ); + + if (!aSelection.is()) { - uno::Reference< drawing::XShapes > xShapes( xModel->getCurrentSelection(), uno::UNO_QUERY_THROW ); + throw uno::RuntimeException( + rtl::OUString::createFromAscii("failed to obtain current selection"), + uno::Reference< uno::XInterface >() ); + } + + uno::Reference< lang::XServiceInfo > xServiceInfo( aSelection, uno::UNO_QUERY_THROW ); + rtl::OUString sImplementationName = xServiceInfo->getImplementationName(); + + if( sImplementationName.equalsIgnoreAsciiCaseAscii("com.sun.star.drawing.SvxShapeCollection") ) + { + uno::Reference< drawing::XShapes > xShapes( aSelection, uno::UNO_QUERY_THROW ); uno::Reference< container::XIndexAccess > xIndexAccess( xShapes, uno::UNO_QUERY_THROW ); uno::Reference< drawing::XShape > xShape( xIndexAccess->getByIndex(0), uno::UNO_QUERY_THROW ); // if ScVbaShape::getType( xShape ) == office::MsoShapeType::msoAutoShape @@ -265,10 +340,10 @@ ScVbaApplication::getSelection() throw (uno::RuntimeException) else if( xServiceInfo->supportsService( rtl::OUString::createFromAscii("com.sun.star.sheet.SheetCellRange")) || xServiceInfo->supportsService( rtl::OUString::createFromAscii("com.sun.star.sheet.SheetCellRanges"))) { - uno::Reference< table::XCellRange > xRange( getCurrentDocument()->getCurrentSelection(), ::uno::UNO_QUERY); + uno::Reference< table::XCellRange > xRange( aSelection, ::uno::UNO_QUERY); if ( !xRange.is() ) { - uno::Reference< sheet::XSheetCellRangeContainer > xRanges( getCurrentDocument()->getCurrentSelection(), ::uno::UNO_QUERY); + uno::Reference< sheet::XSheetCellRangeContainer > xRanges( aSelection, ::uno::UNO_QUERY); if ( xRanges.is() ) return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( excel::getUnoSheetModuleObj( xRanges ), mxContext, xRanges ) ) ); @@ -277,7 +352,7 @@ ScVbaApplication::getSelection() throw (uno::RuntimeException) } else { - throw uno::RuntimeException( sImpementaionName + rtl::OUString::createFromAscii(" not suported"), uno::Reference< uno::XInterface >() ); + throw uno::RuntimeException( sImplementationName + rtl::OUString::createFromAscii(" not supported"), uno::Reference< uno::XInterface >() ); } } @@ -367,16 +442,67 @@ ScVbaApplication::getActiveWindow() throw (uno::RuntimeException) uno::Any SAL_CALL ScVbaApplication::getCutCopyMode() throw (uno::RuntimeException) { - //# FIXME TODO, implementation uno::Any result; - result <<= sal_False; + ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( NULL ); + ScDocument* pDoc = pOwnClip ? pOwnClip->GetDocument() : NULL; + if ( pDoc ) + { + if ( pDoc->IsCutMode() ) + { + result <<= excel::XlCutCopyMode::xlCut; + } + else + { + result <<= excel::XlCutCopyMode::xlCopy; + } + } + else + { + result <<= sal_False; + } return result; } void SAL_CALL -ScVbaApplication::setCutCopyMode( const uno::Any& /*_cutcopymode*/ ) throw (uno::RuntimeException) +ScVbaApplication::setCutCopyMode( const uno::Any& _cutcopymode ) throw (uno::RuntimeException) { - //# FIXME TODO, implementation + // According to Excel's behavior, no matter what is the value of _cutcopymode, always releases the clip object. + sal_Bool bCutCopyMode = sal_False; + if ( ( _cutcopymode >>= bCutCopyMode ) ) + { + ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( NULL ); + if ( pOwnClip ) + { + pOwnClip->ObjectReleased(); + ScTabViewShell* pTabViewShell = excel::getBestViewShell( getCurrentDocument() ); + if ( pTabViewShell ) + { + ScViewData* pView = pTabViewShell->GetViewData(); + Window* pWindow = pView ? pView->GetActiveWin() : NULL; + if ( pWindow ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = pWindow->GetClipboard(); + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if ( xClipboard.is() ) + { + xClipboard->setContents( NULL, NULL ); + if ( xFlushableClipboard.is() ) + { + const sal_uInt32 nRef = Application::ReleaseSolarMutex(); + try + { + xFlushableClipboard->flushClipboard(); + } + catch( const uno::Exception& ) + { + } + Application::AcquireSolarMutex( nRef ); + } + } + } + } + } + } } uno::Any SAL_CALL @@ -725,6 +851,91 @@ ScVbaApplication::getEnableEvents() throw (uno::RuntimeException) return m_bEnableEvents; } +sal_Bool SAL_CALL +ScVbaApplication::getVisible() throw (uno::RuntimeException) +{ + sal_Bool bVisible = sal_True; + return bVisible; +} + +void SAL_CALL +ScVbaApplication::setVisible(sal_Bool /*bVisible*/) throw (uno::RuntimeException) +{ +} + +//liuchen 2009-11-25 add the support of Excel VBA Application.Iteration +//The Excel Iteration option is global and unique, but in Symphony there is an Iteration property in ScModule and one in every ScDocument, +//so the set method will set all the Iteration properties +sal_Bool SAL_CALL +ScVbaApplication::getIteration() throw (uno::RuntimeException) +{ + ScModule* pScMod = SC_MOD(); + ScDocOptions aDocOpt = pScMod->GetDocOptions(); + + return aDocOpt.IsIter(); +} + +void SAL_CALL +ScVbaApplication::setIteration(sal_Bool bIteration) throw (uno::RuntimeException) +{ + ScModule* pScMod = SC_MOD(); + ScDocOptions& aDocOpt = const_cast< ScDocOptions& > (pScMod->GetDocOptions()); + aDocOpt.SetIter( bIteration ); + + uno::Any aIteration; + aIteration <<= bIteration; + + OUString aPropName = OUString::createFromAscii( "IsIterationEnabled" ); + + uno::Reference< XCollection > xWorkbooks( new ScVbaWorkbooks( this, mxContext ) ); + sal_Int32 nCount = xWorkbooks->getCount(); + + for (sal_Int32 i = 1; i <= nCount; i++) + { + uno::Reference< ooo::vba::excel::XWorkbook > xWorkbook; + uno::Any aWorkbook = xWorkbooks->Item(uno::makeAny(i), uno::Any()); + aWorkbook >>= xWorkbook; + ScVbaWorkbook* pWorkbook = static_cast< ScVbaWorkbook* > ( xWorkbook.get() ); + + uno::Reference< frame::XModel > xModel( pWorkbook->getDocModel(), uno::UNO_QUERY_THROW ); + uno::Reference< beans::XPropertySet > xPropertySet( xModel, uno::UNO_QUERY_THROW ); + xPropertySet->setPropertyValue( aPropName, aIteration ); + } +} +//liuchen 2009-11-25 end + +//liuchen 2009-11-26 add the support of Excel VBA Application.EnableCancelKey +sal_Int32 SAL_CALL +ScVbaApplication::getEnableCancelKey() throw (uno::RuntimeException) +{ + return ooo::vba::excel::XlEnableCancelKey::xlDisabled; +} + +void SAL_CALL +ScVbaApplication::setEnableCancelKey(sal_Int32 /*lEnableCancelKey*/) throw (uno::RuntimeException) +{ +} +//liuchen 2009-11-26 end + +sal_Int32 SAL_CALL ScVbaApplication::getSheetsInNewWorkbook() throw (uno::RuntimeException) +{ + const ScAppOptions& rAppOpt = SC_MOD()->GetAppOptions(); + return rAppOpt.GetTabCountInNewSpreadsheet(); +} + +void SAL_CALL ScVbaApplication::setSheetsInNewWorkbook( sal_Int32 SheetsInNewWorkbook ) throw (script::BasicErrorException, uno::RuntimeException) +{ + if ( SheetsInNewWorkbook < 1 || SheetsInNewWorkbook > MAXTAB ) + { + DebugHelper::exception( OUString::createFromAscii("The number must be between 1 and 255"), uno::Exception(), SbERR_METHOD_FAILED, OUString() ); + } + else + { + ScAppOptions& rAppOpt = const_cast< ScAppOptions& >(SC_MOD()->GetAppOptions()); + rAppOpt.SetTabCountInNewSpreadsheet( SheetsInNewWorkbook ); + } +} + void SAL_CALL ScVbaApplication::Calculate() throw( script::BasicErrorException , uno::RuntimeException ) { @@ -1090,13 +1301,19 @@ ScVbaApplication::Volatile( const uno::Any& aVolatile ) throw ( uno::RuntimeExc { sal_Bool bVolatile = sal_True; aVolatile >>= bVolatile; + SbMethod* pMeth = StarBASIC::GetActiveMethod(); + if ( pMeth ) + { + OSL_TRACE("ScVbaApplication::Volatile() In method ->%s<-", rtl::OUStringToOString( pMeth->GetName(), RTL_TEXTENCODING_UTF8 ).getStr() ); + uno::Reference< frame::XModel > xModel( getCurrentDocument() ); + ScDocument* pDoc = excel::getDocShell( xModel )->GetDocument(); + pDoc->GetMacroManager()->SetUserFuncVolatile( pMeth->GetName(), bVolatile); + } + +// this is bound to break when loading the document return; } -void SAL_CALL -ScVbaApplication::DoEvents() throw ( uno::RuntimeException ) -{ -} ::sal_Bool SAL_CALL ScVbaApplication::getDisplayFormulaBar() throw ( css::uno::RuntimeException ) { @@ -1148,12 +1365,421 @@ ScVbaApplication::Caller( const uno::Any& /*aIndex*/ ) throw ( uno::RuntimeExcep return aRet; } +//Add by minz@cn.ibm.com. 2009-07-08. +uno::Any SAL_CALL +ScVbaApplication::GetOpenFilename(const uno::Any& FileFilter, const uno::Any& FilterIndex, const uno::Any& Title, const uno::Any& ButtonText, const uno::Any& MultiSelect) throw (uno::RuntimeException) +{ + uno::Any aRet = uno::makeAny( sal_False ); + try + { + const ::rtl::OUString sServiceName = ::rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.FilePicker" ); + uno::Reference< lang::XMultiServiceFactory > xMSF( comphelper::getProcessServiceFactory(), uno::UNO_QUERY ); + // Set the type of File Picker Dialog: TemplateDescription::FILEOPEN_SIMPLE. + uno::Sequence< uno::Any > aDialogType( 1 ); + aDialogType[0] <<= ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE; + uno::Reference< ui::dialogs::XFilePicker > xFilePicker( xMSF->createInstanceWithArguments( sServiceName, aDialogType ), UNO_QUERY ); + uno::Reference< ui::dialogs::XFilePicker2 > xFilePicker2( xFilePicker, UNO_QUERY ); + uno::Reference< ui::dialogs::XFilterManager > xFilterManager( xFilePicker, UNO_QUERY ); + uno::Reference< ui::dialogs::XExecutableDialog > xExecutableDialog( xFilePicker, UNO_QUERY ); + uno::Reference< ui::dialogs::XFilePickerControlAccess > xPickerControlAccess( xFilePicker, UNO_QUERY ); + + if ( xFilterManager.is() && FileFilter.hasValue() ) + { + sal_Int32 nFilterIndex = 1; + if ( FilterIndex.hasValue() ) + { + FilterIndex >>= nFilterIndex; + } + ::rtl::OUString strFilter; + FileFilter >>= strFilter; + sal_Int32 nCommaID = 0; + sal_Int32 nIndex = 1; + do + { + ::rtl::OUString aFilterTitleToken = strFilter.getToken( 0, ',' , nCommaID ); + ::rtl::OUString aFilterToken; + if ( nCommaID >= 0 ) + { + aFilterToken = strFilter.getToken( 0, ',' , nCommaID ); + } + else if ( nCommaID < 0 && nIndex == 1 ) + { + throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid FileFilter format!" ), uno::Reference< uno::XInterface >() ); + } + xFilterManager->appendFilter( aFilterTitleToken, aFilterToken ); + if ( nFilterIndex == nIndex ) + { + xFilterManager->setCurrentFilter( aFilterTitleToken ); + } + nIndex++; + } while ( nCommaID >= 0 ); + } + if ( xExecutableDialog.is() && Title.hasValue() ) + { + ::rtl::OUString sTitle; + Title >>= sTitle; + xExecutableDialog->setTitle( sTitle ); + } + if ( xPickerControlAccess.is() && ButtonText.hasValue() ) + { + ::rtl::OUString sButtonText; + ButtonText >>= sButtonText; + xPickerControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::PUSHBUTTON_OK, sButtonText ); + } + sal_Bool bMultiSelect = sal_False; + if ( xFilePicker.is() && MultiSelect.hasValue() ) + { + MultiSelect >>= bMultiSelect; + xFilePicker->setMultiSelectionMode( bMultiSelect ); + } + + if ( xFilePicker.is() && xFilePicker->execute() ) + { + sal_Bool bUseXFilePicker2 = sal_False; + uno::Reference< lang::XServiceInfo > xServiceInfo( xFilePicker, UNO_QUERY ); + if ( xServiceInfo.is() ) + { + rtl::OUString sImplName = xServiceInfo->getImplementationName(); + if ( sImplName.equalsAscii("com.sun.star.comp.fpicker.VistaFileDialog") || sImplName.equalsAscii("com.sun.star.ui.dialogs.SalGtkFilePicker") ) + { + bUseXFilePicker2 = sal_True; + } + } + uno::Sequence< rtl::OUString > aSelectedFiles; + if ( bUseXFilePicker2 && xFilePicker2.is() ) + { + // On Linux, XFilePicker->getFiles() always return one selected file although we select more than one file, also on Vista + // XFilePicker->getFiles() does not work well too, so we call XFilePicker2->getSelectedFiles() to get selected files. + aSelectedFiles = xFilePicker2->getSelectedFiles(); + } + else + { + // If only one file is selected, the first entry of the sequence contains the complete path/filename in URL format. If multiple files are selected, + // the first entry of the sequence contains the path in URL format, and the other entries contains the names of the selected files without path information. + uno::Sequence< rtl::OUString > aTmpFiles = xFilePicker->getFiles(); + aSelectedFiles = aTmpFiles; + sal_Int32 iFileCount = aTmpFiles.getLength(); + if ( iFileCount > 1 ) + { + aSelectedFiles.realloc( iFileCount - 1 ); + INetURLObject aPath( aTmpFiles[0] ); + aPath.setFinalSlash(); + for ( sal_Int32 i = 1; i < iFileCount; i++ ) + { + if ( aTmpFiles[i].indexOf ('/') > 0 || aTmpFiles[i].indexOf ('\\') > 0 ) + { + aSelectedFiles[i - 1] = aTmpFiles[i]; + } + else + { + if ( i == 1 ) + aPath.Append( aTmpFiles[i] ); + else + aPath.setName( aTmpFiles[i] ); + aSelectedFiles[i - 1] = aPath.GetMainURL( INetURLObject::NO_DECODE ); + } + } + } + } + + sal_Int32 iFileCount = aSelectedFiles.getLength(); + for ( sal_Int32 i = 0; i < iFileCount; i++ ) + { + INetURLObject aObj( aSelectedFiles[i] ); + if ( aObj.GetProtocol() == INET_PROT_FILE ) + { + rtl::OUString aTemp = aObj.PathToFileName(); + aSelectedFiles[i] = aTemp.getLength() > 0 ? aTemp : aSelectedFiles[i]; + } + } + if ( bMultiSelect ) + { + aRet = uno::makeAny( aSelectedFiles ); + } + else if ( aSelectedFiles.getLength() > 0 && !bMultiSelect ) + { + aRet = uno::makeAny( aSelectedFiles[0] ); + } + } + } + catch( const uno::Exception& ) + { + DebugHelper::exception(SbERR_METHOD_FAILED, rtl::OUString()); + } + + return aRet; +} + +//liming 2009-7-17 +::com::sun::star::uno::Reference< ::ooo::vba::XFileDialog > SAL_CALL +ScVbaApplication::getFileDialog() throw (::com::sun::star::uno::RuntimeException) +{ + uno::Reference< XFileDialog > xFileDialogs( new ScVbaFileDialog( uno::Reference< XHelperInterface >( this ), mxContext, getCurrentDocument() ) ); + return xFileDialogs; +} + +typedef std::map< ::rtl::OUString, ::rtl::OUString > FileFilterMap; + +//2009-11-06 add by limingl +uno::Any SAL_CALL +ScVbaApplication::GetSaveAsFilename( const ::com::sun::star::uno::Any& InitialFilename, const ::com::sun::star::uno::Any& FileFilter, const ::com::sun::star::uno::Any& FilterIndex, const ::com::sun::star::uno::Any& Title, const ::com::sun::star::uno::Any& ButtonText ) throw (::com::sun::star::uno::RuntimeException) +{ + uno::Any strRet; + try + { + const ::rtl::OUString sServiceName = ::rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.FilePicker" ); + uno::Reference< lang::XMultiServiceFactory > xMSF( comphelper::getProcessServiceFactory(), uno::UNO_QUERY ); + + uno::Sequence< uno::Any > aDialogType( 1 ); + aDialogType[0] <<= ui::dialogs::TemplateDescription::FILESAVE_SIMPLE; + uno::Reference< ui::dialogs::XFilePicker > xFilePicker( xMSF->createInstanceWithArguments( sServiceName, aDialogType ), UNO_QUERY ); + + if (InitialFilename.hasValue()) + { + ::rtl::OUString strInitFileName; + InitialFilename >>= strInitFileName; + xFilePicker->setDefaultName(strInitFileName); + } + + // Begin from 1. + sal_Int32 nFilterIndex = 1; + if (FilterIndex.hasValue()) + { + FilterIndex >>= nFilterIndex; + } + + uno::Reference< ui::dialogs::XFilterManager > xFilter( xFilePicker, UNO_QUERY ); + FileFilterMap mFilterNameMap; + if (FileFilter.hasValue()) + { + ::rtl::OUString strFilter; + sal_Int32 nCommaID = 0; + FileFilter >>= strFilter; + + sal_Int32 nIndex = 1; + do + { + ::rtl::OUString aFilterTitleToken = strFilter.getToken( 0, ',' , nCommaID ); + ::rtl::OUString aFilterToken; + if ( nCommaID >= 0 ) + { + aFilterToken = strFilter.getToken( 0, ',' , nCommaID ); + } + else if ( nCommaID < 0 && nIndex == 1 ) + { + throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid FileFilter format!" ), uno::Reference< uno::XInterface >() ); + } + + FileFilterMap::const_iterator aIt = mFilterNameMap.find( aFilterTitleToken ); + if ( aIt == mFilterNameMap.end() ) + { + xFilter->appendFilter( aFilterTitleToken, aFilterToken ); + if ( nFilterIndex == nIndex ) + { + xFilter->setCurrentFilter( aFilterTitleToken ); + } + nIndex++; + mFilterNameMap[aFilterTitleToken] = aFilterToken; + } + } while ( nCommaID >= 0 ); + } + + if (Title.hasValue()) + { + ::rtl::OUString strTitle; + Title >>= strTitle; + uno::Reference< ::com::sun::star::ui::dialogs::XExecutableDialog> xExcTblDlg(xFilePicker, UNO_QUERY ); + xExcTblDlg->setTitle(strTitle); + } + + if (ButtonText.hasValue()) + { + ::rtl::OUString strBttTxt; + ButtonText >>= strBttTxt; + } + + + if ( xFilePicker.is() ) + { + sal_Int16 nRet = xFilePicker->execute(); + if (nRet == 0) + { + strRet <<= sal_False; + } + else + { + uno::Sequence < rtl::OUString > aPathSeq = xFilePicker->getFiles(); + + if ( aPathSeq.getLength() ) + { + ::rtl::OUString sSelectedFilters; + if ( xFilter.is() ) + { + ::rtl::OUString sSelectedFilterName = xFilter->getCurrentFilter(); + FileFilterMap::const_iterator aIt = mFilterNameMap.find( sSelectedFilterName ); + if ( aIt != mFilterNameMap.end() ) + { + sSelectedFilters = aIt->second; + } + } + INetURLObject aURLObj( aPathSeq[0] ); + ::rtl::OUString aPathStr = aURLObj.PathToFileName(); + if ( aURLObj.GetProtocol() == INET_PROT_FILE ) + { + sal_Int32 nSemicolonID = 0; + ::rtl::OUString sFirstFilter = sSelectedFilters.getToken( 0, ';' , nSemicolonID ); + ::rtl::OUString sFileExtension = aURLObj.GetExtension(); + if ( sFileExtension.equalsAscii("") ) + { + sFileExtension = sFirstFilter.equalsAscii("*.*") ? sFileExtension : sFirstFilter.copy( sFirstFilter.indexOfAsciiL("*.", 2) + 2 ); + aPathStr = sFileExtension.equalsAscii("") ? aPathStr : aPathStr + ::rtl::OUString::createFromAscii(".") + sFileExtension; + } + else + { + sal_Bool bValidFilter = sal_False; + FileFilterMap::const_iterator aIt = mFilterNameMap.begin(); + while ( aIt != mFilterNameMap.end() ) + { + sSelectedFilters = aIt->second; + nSemicolonID = 0; + do + { + ::rtl::OUString aFilterToken = sSelectedFilters.getToken( 0, ';' , nSemicolonID ); + if ( aFilterToken.trim().equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("*.") + sFileExtension) ) + { + bValidFilter = sal_True; + break; + } + } while ( nSemicolonID >= 0 ); + if ( bValidFilter ) + { + break; + } + aIt++; + } + if ( !bValidFilter ) + { + sFileExtension = sFirstFilter.equalsAscii("*.*") ? ::rtl::OUString::createFromAscii("") : sFirstFilter.copy( sFirstFilter.indexOfAsciiL("*.", 2) + 2 ); + aPathStr = sFileExtension.equalsAscii("") ? aPathStr : aPathStr + ::rtl::OUString::createFromAscii(".") + sFileExtension; + } + } + } + strRet <<= aPathStr; + } + } + } + } + catch( const uno::Exception& ) + { + DebugHelper::exception(SbERR_METHOD_FAILED, rtl::OUString()); + } + return strRet; +} + +//end add + uno::Reference< frame::XModel > ScVbaApplication::getCurrentDocument() throw (css::uno::RuntimeException) { return getCurrentExcelDoc(mxContext); } +uno::Any SAL_CALL +ScVbaApplication::MenuBars( const uno::Any& aIndex ) throw (uno::RuntimeException) +{ + uno::Reference< XCommandBars > xCommandBars( CommandBars( uno::Any() ), uno::UNO_QUERY_THROW ); + uno::Reference< XCollection > xMenuBars( new ScVbaMenuBars( this, mxContext, xCommandBars ) ); + if ( aIndex.hasValue() ) + { + return uno::Any ( xMenuBars->Item( aIndex, uno::Any() ) ); + } + + return uno::Any( xMenuBars ); +} + +//liuchen 2009-11-26 add the support of Application.International +sal_Int32 SAL_CALL +ConvertCountryCode(const OUString& language) +{ + sal_Int32 nCode = 0; + + if( language == OUString::createFromAscii("ar") ) nCode = 966; // Arabic + else if ( language == OUString::createFromAscii("cs") ) nCode = 42; // Czech + else if ( language == OUString::createFromAscii("da") ) nCode = 45; // Danish + else if ( language == OUString::createFromAscii("de") ) nCode = 49; // German + else if ( language == OUString::createFromAscii("en") ) nCode = 1; // English + else if ( language == OUString::createFromAscii("es") ) nCode = 34; // Spanish + else if ( language == OUString::createFromAscii("el") ) nCode = 30; // Greek + else if ( language == OUString::createFromAscii("fa") ) nCode = 98; // Persian = Farsi + else if ( language == OUString::createFromAscii("fi") ) nCode = 358; // Finnish + else if ( language == OUString::createFromAscii("fr") ) nCode = 33; // French + else if ( language == OUString::createFromAscii("he") ) nCode = 972; // Hebrew + else if ( language == OUString::createFromAscii("hi") ) nCode = 91; // Indian = Hindi + else if ( language == OUString::createFromAscii("hu") ) nCode = 36; // Hungarian + else if ( language == OUString::createFromAscii("it") ) nCode = 39; // Italian + else if ( language == OUString::createFromAscii("ja") ) nCode = 81; // Japanese + else if ( language == OUString::createFromAscii("ko") ) nCode = 82; // Korean + else if ( language == OUString::createFromAscii("nl") ) nCode = 31; // Dutch + else if ( language == OUString::createFromAscii("no") ) nCode = 47; // Norwegian + else if ( language == OUString::createFromAscii("pl") ) nCode = 48; // Polish + else if ( language == OUString::createFromAscii("pt") ) nCode = 351; // Portuguese + else if ( language == OUString::createFromAscii("ru") ) nCode = 7; // Russian + else if ( language == OUString::createFromAscii("sv") ) nCode = 46; // Swedish + else if ( language == OUString::createFromAscii("th") ) nCode = 66; // Thai + else if ( language == OUString::createFromAscii("tk") ) nCode = 90; // Turkish + else if ( language == OUString::createFromAscii("ur") ) nCode = 92; // Urdu + else if ( language == OUString::createFromAscii("vi") ) nCode = 84; // Vietnamese + else if ( language == OUString::createFromAscii("zh") ) nCode = 86; // Simplified Chinese + + return nCode; +} + +uno::Any SAL_CALL +ScVbaApplication::International( sal_Int32 Index ) throw (uno::RuntimeException) +{ + uno::Any aRet; + OUString str; + const LocaleDataWrapper* pLocaleData = ScGlobal::GetpLocaleData(); + switch ( Index ) + { + case excel::XlApplicationInternational::xlCountryCode: + aRet <<= ConvertCountryCode( pLocaleData->getLanguageCountryInfo().Language ); + break; + case excel::XlApplicationInternational::xlDecimalSeparator: + str = pLocaleData->getNumDecimalSep(); + aRet <<= str; + break; + case excel::XlApplicationInternational::xlDateSeparator: + str = pLocaleData->getDateSep(); + aRet <<= str; + break; + default: + break; + } + return aRet; +} +//liuchen 2009-11-26 end + +//2009-12-11 add by limingl +void SAL_CALL ScVbaApplication::Undo( ) throw (::com::sun::star::uno::RuntimeException) +{ + SfxAllItemSet reqList( SFX_APP()->GetPool() ); + SfxRequest rReq(SID_UNDO, 0, reqList); + ScTabViewShell* pViewShell = excel::getCurrentBestViewShell( mxContext ); + + if (pViewShell != NULL) + { + pViewShell->ExecuteUndo(rReq); + } +} +//end + +double SAL_CALL ScVbaApplication::InchesToPoints( double Inches ) throw (uno::RuntimeException) +{ + // Convert a measurement from Inch to Point (1 inch = 72 points). + return MetricField::ConvertDoubleValue( Inches, 0, 0, FUNIT_INCH, FUNIT_POINT ); +} + rtl::OUString& ScVbaApplication::getServiceImplName() { diff --git a/sc/source/ui/vba/vbaapplication.hxx b/sc/source/ui/vba/vbaapplication.hxx index a7be5feb1d27..9d865a513547 100644 --- a/sc/source/ui/vba/vbaapplication.hxx +++ b/sc/source/ui/vba/vbaapplication.hxx @@ -47,6 +47,7 @@ private: sal_Bool m_bEnableEvents; rtl::OUString getOfficePath( const rtl::OUString& sPath ) throw ( css::uno::RuntimeException ); + css::uno::Reference< ov::XFileSearch > m_xFileSearch; // protected: virtual css::uno::Reference< css::frame::XModel > getCurrentDocument() throw (css::uno::RuntimeException); @@ -89,6 +90,7 @@ public: virtual void SAL_CALL setDisplayFormulaBar( ::sal_Bool _displayformulabar ) throw ( css::uno::RuntimeException ); virtual css::uno::Reference< ov::XAssistant > SAL_CALL getAssistant() throw (css::uno::RuntimeException); + virtual css::uno::Reference< ov::XFileSearch > SAL_CALL getFileSearch() throw (css::uno::RuntimeException); //liuchen 2009-8-18 add the support of Application.FileSearch virtual css::uno::Reference< ov::excel::XWorkbook > SAL_CALL getThisWorkbook() throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Workbooks( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Worksheets( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); @@ -102,6 +104,17 @@ public: virtual ::sal_Int32 SAL_CALL getCursor() throw (css::uno::RuntimeException); virtual void SAL_CALL setCursor( ::sal_Int32 _cursor ) throw (css::uno::RuntimeException); + virtual sal_Bool SAL_CALL getVisible() throw (css::uno::RuntimeException); + virtual void SAL_CALL setVisible( sal_Bool bVisible ) throw (css::uno::RuntimeException); + + virtual sal_Bool SAL_CALL getIteration() throw (css::uno::RuntimeException); //liuchen 2009-11-25 add the support of Iteration + virtual void SAL_CALL setIteration( sal_Bool bIteration ) throw (css::uno::RuntimeException); //liuchen 2009-11-25 add the support of Iteration + virtual sal_Int32 SAL_CALL getEnableCancelKey() throw (css::uno::RuntimeException); //liuchen 2009-11-26 add the support of EnableCancelKey + virtual void SAL_CALL setEnableCancelKey( sal_Int32 lEnableCancelKey ) throw (css::uno::RuntimeException); //liuchen 2009-11-26 add the support of EnableCancelKey + + virtual sal_Int32 SAL_CALL getSheetsInNewWorkbook() throw (css::uno::RuntimeException); + virtual void SAL_CALL setSheetsInNewWorkbook( sal_Int32 SheetsInNewWorkbook ) throw (css::script::BasicErrorException, css::uno::RuntimeException); + virtual sal_Bool SAL_CALL getEnableEvents() throw (css::uno::RuntimeException); virtual void SAL_CALL setEnableEvents( sal_Bool bEnable ) throw (css::uno::RuntimeException); @@ -114,8 +127,16 @@ public: virtual css::uno::Reference< ov::excel::XRange > SAL_CALL Intersect( const css::uno::Reference< ov::excel::XRange >& Arg1, const css::uno::Reference< ov::excel::XRange >& Arg2, const css::uno::Any& Arg3, const css::uno::Any& Arg4, const css::uno::Any& Arg5, const css::uno::Any& Arg6, const css::uno::Any& Arg7, const css::uno::Any& Arg8, const css::uno::Any& Arg9, const css::uno::Any& Arg10, const css::uno::Any& Arg11, const css::uno::Any& Arg12, const css::uno::Any& Arg13, const css::uno::Any& Arg14, const css::uno::Any& Arg15, const css::uno::Any& Arg16, const css::uno::Any& Arg17, const css::uno::Any& Arg18, const css::uno::Any& Arg19, const css::uno::Any& Arg20, const css::uno::Any& Arg21, const css::uno::Any& Arg22, const css::uno::Any& Arg23, const css::uno::Any& Arg24, const css::uno::Any& Arg25, const css::uno::Any& Arg26, const css::uno::Any& Arg27, const css::uno::Any& Arg28, const css::uno::Any& Arg29, const css::uno::Any& Arg30 ) throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual css::uno::Reference< ov::excel::XRange > SAL_CALL Union( const css::uno::Reference< ov::excel::XRange >& Arg1, const css::uno::Reference< ov::excel::XRange >& Arg2, const css::uno::Any& Arg3, const css::uno::Any& Arg4, const css::uno::Any& Arg5, const css::uno::Any& Arg6, const css::uno::Any& Arg7, const css::uno::Any& Arg8, const css::uno::Any& Arg9, const css::uno::Any& Arg10, const css::uno::Any& Arg11, const css::uno::Any& Arg12, const css::uno::Any& Arg13, const css::uno::Any& Arg14, const css::uno::Any& Arg15, const css::uno::Any& Arg16, const css::uno::Any& Arg17, const css::uno::Any& Arg18, const css::uno::Any& Arg19, const css::uno::Any& Arg20, const css::uno::Any& Arg21, const css::uno::Any& Arg22, const css::uno::Any& Arg23, const css::uno::Any& Arg24, const css::uno::Any& Arg25, const css::uno::Any& Arg26, const css::uno::Any& Arg27, const css::uno::Any& Arg28, const css::uno::Any& Arg29, const css::uno::Any& Arg30 ) throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual void SAL_CALL Volatile( const css::uno::Any& Volatile ) throw (css::uno::RuntimeException ); - virtual void SAL_CALL DoEvents() throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Caller( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); + virtual css::uno::Any SAL_CALL MenuBars( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); + virtual css::uno::Any SAL_CALL GetOpenFilename( const css::uno::Any& FileFilter, const css::uno::Any& FilterIndex, const css::uno::Any& Title, const css::uno::Any& ButtonText, const css::uno::Any& MultiSelect ) throw (css::uno::RuntimeException); + virtual ::com::sun::star::uno::Reference< ::ooo::vba::XFileDialog > SAL_CALL getFileDialog() throw (::com::sun::star::uno::RuntimeException); //liminl 2009-08-12 add + virtual css::uno::Any SAL_CALL International( sal_Int32 Index ) throw (css::uno::RuntimeException); //liuchen 2009-11-26 + //2009-12-04 add by limingl + virtual css::uno::Any SAL_CALL GetSaveAsFilename( const ::com::sun::star::uno::Any& InitialFilename, const ::com::sun::star::uno::Any& FileFilter, const ::com::sun::star::uno::Any& FilterIndex, const ::com::sun::star::uno::Any& Title, const ::com::sun::star::uno::Any& ButtonText ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL Undo( ) throw (::com::sun::star::uno::RuntimeException); + virtual double SAL_CALL InchesToPoints( double Inches ) throw (css::uno::RuntimeException); + // XHelperInterface virtual rtl::OUString& getServiceImplName(); virtual css::uno::Sequence<rtl::OUString> getServiceNames(); diff --git a/sc/source/ui/vba/vbacomment.cxx b/sc/source/ui/vba/vbacomment.cxx index 9c50a25b8b7c..31ea50c0dff4 100644 --- a/sc/source/ui/vba/vbacomment.cxx +++ b/sc/source/ui/vba/vbacomment.cxx @@ -33,14 +33,23 @@ #include <com/sun/star/sheet/XSheetAnnotationsSupplier.hpp> #include <com/sun/star/sheet/XSheetAnnotationShapeSupplier.hpp> #include <com/sun/star/sheet/XSheetCellRange.hpp> +#include <com/sun/star/sheet/XCellAddressable.hpp> #include <com/sun/star/table/CellAddress.hpp> #include <com/sun/star/table/XCell.hpp> #include <com/sun/star/text/XText.hpp> +#include <cellsuno.hxx> +#include <postit.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdocapt.hxx> +#include <ooo/vba/msforms/XShape.hpp> +#include <com/sun/star/drawing/XShape.hpp> +#include <com/sun/star/frame/XModel.hpp> + #include <vbahelper/vbashape.hxx> #include "vbaglobals.hxx" #include "vbacomments.hxx" - +#include "vbacommentshape.hxx" using namespace ::ooo::vba; using namespace ::com::sun::star; @@ -178,7 +187,6 @@ ScVbaComment::Text( const uno::Any& aText, const uno::Any& aStart, const uno::An aText >>= sText; uno::Reference< text::XSimpleText > xAnnoText( getAnnotation(), uno::UNO_QUERY_THROW ); - rtl::OUString sAnnoText = xAnnoText->getString(); if ( aStart.hasValue() ) { @@ -212,10 +220,12 @@ ScVbaComment::Text( const uno::Any& aText, const uno::Any& aStart, const uno::An } else if ( aText.hasValue() ) { - xAnnoText->setString( sText ); - return sText; + uno::Reference< sheet::XCellAddressable > xCellAddr(mxRange->getCellByPosition(0, 0), uno::UNO_QUERY_THROW ); + table::CellAddress aAddress = xCellAddr->getCellAddress(); + getAnnotations()->insertNew( aAddress, sText ); } + rtl::OUString sAnnoText = xAnnoText->getString(); return sAnnoText; } diff --git a/sc/source/ui/vba/vbadialog.cxx b/sc/source/ui/vba/vbadialog.cxx index 3c578a04e5d0..d692a8108a3d 100644 --- a/sc/source/ui/vba/vbadialog.cxx +++ b/sc/source/ui/vba/vbadialog.cxx @@ -29,42 +29,58 @@ using namespace ::ooo::vba; using namespace ::com::sun::star; -static const rtl::OUString aStringList[]= +//liuchen 2009-7-27 +//solve the problem that "Application.Dialogs.Item(***).Show" and "Application.Dialogs.Count" cannot get the correct result +struct DialogMatch { - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Open" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:FormatCellDialog" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertCell" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Print" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PasteSpecial" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ToolProtectionDocument" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ColumnWidth" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DefineName" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConfigureDialog" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:HyperlinkDialog" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertGraphic" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertObject" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PageFormatDialog" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataSort" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:RowHeight" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:AutoCorrectDlg" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConditionalFormatDialog" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataConsolidate" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CreateNames" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:FillSeries" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Validation") ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DefineLabelRange" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataFilterAutoFilter" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataFilterSpecialFilter" ) ), - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:AutoFormat" ) ) + sal_Int32 nVbaDlgIndex; + rtl::OUString aOODlgName; }; -const sal_Int32 nDialogSize = sizeof( aStringList ) / sizeof( aStringList[ 0 ] ); +static const DialogMatch aDialogMatchList[] = +{ + { 1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Open" ) ) }, // xlDialogOpen -> .uno:Open + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:FormatCellDialog" ) ) }, // ??? -> .uno:FormatCellDialog + { 55, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertCell" ) ) }, // xlDialogInsert -> .uno:InsertCell + { 8, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Print" ) ) }, // xlDialogPrint -> .uno:Print + { 9, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PrinterSetup" ) ) }, // xlDialogPrinterSetup -> .uno:PrinterSetup + { 53, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PasteSpecial" ) ) }, // xlDialogPasteSpecial -> .uno:PasteSpecial + { 28, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ToolProtectionDocument" ) ) }, // xlDialogProtectDocument -> uno:ToolProtectionDocument + { 47, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ColumnWidth" ) ) }, // xlDialogColumnWidth -> .uno:ColumnWidth + { 61, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DefineName" ) ) }, // xlDialogDefineName -> .uno:DefineName + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConfigureDialog" ) ) }, // ??? -> .uno:ConfigureDialog + { 596, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:HyperlinkDialog" ) ) }, // xlDialogInsertHyperlink -> .uno:HyperlinkDialog + { 342, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertGraphic" ) ) }, // xlDialogInsertPicture -> .uno:InsertGraphic + { 259, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:InsertObject" ) ) }, // xlDialogInsertObject -> .uno:InsertObject + { 7, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PageFormatDialog" ) ) }, // xlDialogPageSetup -> .uno:PageFormatDialog + { 39, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataSort" ) ) }, // xlDialogSort -> .uno:DataSort + { 127, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:RowHeight" ) ) }, // xlDialogRowHeight -> .uno:RowHeight + { 485, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:AutoCorrectDlg" ) ) }, // xlDialogAutoCorrect -> .uno:AutoCorrectDlg + { 583, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConditionalFormatDialog" ) ) }, // xlDialogCondiationalFormatting -> .uno:ConditionalFormatDialog + { 191, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataConsolidate" ) ) }, // xlDialogConsolidate -> .uno:DataConsolidate + { 62, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:CreateNames" ) ) }, // xlDialogCreateNames -> .uno:CreateNames + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:FillSeries" ) ) }, // ??? -> .uno:FillSeries + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Validation" ) ) }, // ??? -> .uno:Validation" + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DefineLabelRange" ) ) }, // ??? -> .uno:DefineLabelRange + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataFilterAutoFilter" ) ) }, // ??? -> .uno:DataFilterAutoFilter + { -1, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:DataFilterSpecialFilter" ) ) }, // ??? -> .uno:DataFilterSpecialFilter + { 269, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:AutoFormat" ) ) } // xlDialogFormatAuto -> .uno:AutoFormat +}; +const sal_Int32 nDialogSize = sizeof( aDialogMatchList ) / sizeof( aDialogMatchList[ 0 ] ); + +//liuchen modified 2009-2-27 rtl::OUString ScVbaDialog::mapIndexToName( sal_Int32 nIndex ) { - if( nIndex < nDialogSize ) - return aStringList[ nIndex ]; + for (int i = 0; i < nDialogSize; i++) + { + if ( aDialogMatchList[i].nVbaDlgIndex == nIndex ) + { + return aDialogMatchList[i].aOODlgName; + } + } + return rtl::OUString(); } @@ -86,3 +102,9 @@ ScVbaDialog::getServiceNames() } return aServiceNames; } + +//liuchen add 2009-7-27 +sal_Int32 ScVbaDialog::GetSupportedDialogCount() +{ + return nDialogSize; +}
\ No newline at end of file diff --git a/sc/source/ui/vba/vbadialog.hxx b/sc/source/ui/vba/vbadialog.hxx index 40f4a4a83a11..086770f19357 100644 --- a/sc/source/ui/vba/vbadialog.hxx +++ b/sc/source/ui/vba/vbadialog.hxx @@ -45,6 +45,9 @@ public: // XHelperInterface virtual rtl::OUString& getServiceImplName(); virtual css::uno::Sequence<rtl::OUString> getServiceNames(); + + //liuchen 2009-7-27 + static sal_Int32 GetSupportedDialogCount(); }; #endif /* SC_VBA_DIALOG_HXX */ diff --git a/sc/source/ui/vba/vbadialogs.cxx b/sc/source/ui/vba/vbadialogs.cxx index 67070879535b..6aa4a65cf7d1 100644 --- a/sc/source/ui/vba/vbadialogs.cxx +++ b/sc/source/ui/vba/vbadialogs.cxx @@ -64,5 +64,13 @@ ScVbaDialogs::getServiceNames() return aServiceNames; } +//liuchen 2009-7-27 +::sal_Int32 +ScVbaDialogs::getCount() throw (uno::RuntimeException) +{ + return ScVbaDialog::GetSupportedDialogCount(); +} + + diff --git a/sc/source/ui/vba/vbadialogs.hxx b/sc/source/ui/vba/vbadialogs.hxx index 9aab5daf11fe..6b5e1f9a8d90 100644 --- a/sc/source/ui/vba/vbadialogs.hxx +++ b/sc/source/ui/vba/vbadialogs.hxx @@ -44,6 +44,7 @@ public: // XCollection virtual css::uno::Any SAL_CALL Item( const css::uno::Any& Index ) throw (css::uno::RuntimeException); + virtual ::sal_Int32 SAL_CALL getCount() throw (css::uno::RuntimeException); //liuchen 2009-7-27 // XDialogs virtual void SAL_CALL Dummy() throw (css::uno::RuntimeException); diff --git a/sc/source/ui/vba/vbaeventshelper.cxx b/sc/source/ui/vba/vbaeventshelper.cxx index 45667adf2f2c..7b06c5995fbe 100755 --- a/sc/source/ui/vba/vbaeventshelper.cxx +++ b/sc/source/ui/vba/vbaeventshelper.cxx @@ -372,7 +372,15 @@ void ScVbaEventsListener::processWindowResizeMacro() { OSL_TRACE( "**** Attempt to FIRE MACRO **** " ); if( !mbDisposed ) - mrVbaEvents.processVbaEvent( WORKBOOK_WINDOWRESIZE, uno::Sequence< uno::Any >() ); + { + try + { + mrVbaEvents.processVbaEvent( WORKBOOK_WINDOWRESIZE, uno::Sequence< uno::Any >() ); + } + catch( uno::Exception& ) + { + } + } } // ============================================================================ diff --git a/sc/source/ui/vba/vbaglobals.cxx b/sc/source/ui/vba/vbaglobals.cxx index c70a7f83726d..4ccdb1299bd1 100644 --- a/sc/source/ui/vba/vbaglobals.cxx +++ b/sc/source/ui/vba/vbaglobals.cxx @@ -247,6 +247,12 @@ ScVbaGlobals::getDebug() throw (uno::RuntimeException) return uno::Any(); } +uno::Any SAL_CALL +ScVbaGlobals::MenuBars( const uno::Any& aIndex ) throw (uno::RuntimeException) +{ + return uno::Any( getApplication()->MenuBars(aIndex) ); +} + uno::Sequence< ::rtl::OUString > SAL_CALL ScVbaGlobals::getAvailableServiceNames( ) throw (uno::RuntimeException) { diff --git a/sc/source/ui/vba/vbaglobals.hxx b/sc/source/ui/vba/vbaglobals.hxx index f22e5b19faa4..3108f5ab871c 100644 --- a/sc/source/ui/vba/vbaglobals.hxx +++ b/sc/source/ui/vba/vbaglobals.hxx @@ -84,6 +84,7 @@ typedef ::cppu::ImplInheritanceHelper1< VbaGlobalsBase, ov::excel::XGlobals > Sc virtual css::uno::Reference< ov::excel::XRange > SAL_CALL Union( const css::uno::Reference< ov::excel::XRange >& Arg1, const css::uno::Reference< ov::excel::XRange >& Arg2, const css::uno::Any& Arg3, const css::uno::Any& Arg4, const css::uno::Any& Arg5, const css::uno::Any& Arg6, const css::uno::Any& Arg7, const css::uno::Any& Arg8, const css::uno::Any& Arg9, const css::uno::Any& Arg10, const css::uno::Any& Arg11, const css::uno::Any& Arg12, const css::uno::Any& Arg13, const css::uno::Any& Arg14, const css::uno::Any& Arg15, const css::uno::Any& Arg16, const css::uno::Any& Arg17, const css::uno::Any& Arg18, const css::uno::Any& Arg19, const css::uno::Any& Arg20, const css::uno::Any& Arg21, const css::uno::Any& Arg22, const css::uno::Any& Arg23, const css::uno::Any& Arg24, const css::uno::Any& Arg25, const css::uno::Any& Arg26, const css::uno::Any& Arg27, const css::uno::Any& Arg28, const css::uno::Any& Arg29, const css::uno::Any& Arg30 ) throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual css::uno::Reference< ov::excel::XApplication > SAL_CALL getExcel() throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL getDebug() throw (css::uno::RuntimeException); + virtual css::uno::Any SAL_CALL MenuBars( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); // XMultiServiceFactory diff --git a/sc/source/ui/vba/vbahelper.cxx b/sc/source/ui/vba/vbahelper.cxx deleted file mode 100644 index cc76b1e60125..000000000000 --- a/sc/source/ui/vba/vbahelper.cxx +++ /dev/null @@ -1,758 +0,0 @@ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ -#include <cppuhelper/bootstrap.hxx> -#include <com/sun/star/util/XURLTransformer.hpp> -#include <com/sun/star/frame/XDispatchProvider.hpp> -#include <com/sun/star/frame/XModel.hpp> -#include <com/sun/star/frame/XFrame.hpp> -#include <com/sun/star/frame/XDesktop.hpp> -#include <com/sun/star/frame/XController.hpp> -#include <com/sun/star/uno/XComponentContext.hpp> -#include <com/sun/star/lang/XMultiComponentFactory.hpp> -#include <com/sun/star/beans/XPropertySet.hpp> -#include <com/sun/star/beans/XIntrospection.hpp> - -#include <comphelper/processfactory.hxx> - -#include <sfx2/objsh.hxx> -#include <sfx2/viewfrm.hxx> -#include <sfx2/dispatch.hxx> -#include <sfx2/app.hxx> -#include <svl/stritem.hxx> - -#include <docuno.hxx> - -#include <basic/sbx.hxx> -#include <basic/sbstar.hxx> -#include <rtl/math.hxx> - -#include <math.h> -#include "vbahelper.hxx" -#include "tabvwsh.hxx" -#include "transobj.hxx" -#include "scmod.hxx" -#include "vbashape.hxx" -#include "unonames.hxx" -#include "cellsuno.hxx" -using namespace ::com::sun::star; -using namespace ::ooo::vba; - -#define POINTTO100THMILLIMETERFACTOR 35.27778 -void unoToSbxValue( SbxVariable* pVar, const uno::Any& aValue ); - -uno::Any sbxToUnoValue( SbxVariable* pVar ); - - -namespace ooo -{ -namespace vba -{ - -const double Millimeter::factor = 35.27778; - -uno::Reference< beans::XIntrospectionAccess > -getIntrospectionAccess( const uno::Any& aObject ) throw (uno::RuntimeException) -{ - static uno::Reference< beans::XIntrospection > xIntrospection; - if( !xIntrospection.is() ) - { - uno::Reference< lang::XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); - xIntrospection.set( xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.beans.Introspection") ), uno::UNO_QUERY_THROW ); - } - return xIntrospection->inspect( aObject ); -} - -uno::Reference< script::XTypeConverter > -getTypeConverter( const uno::Reference< uno::XComponentContext >& xContext ) throw (uno::RuntimeException) -{ - static uno::Reference< script::XTypeConverter > xTypeConv( xContext->getServiceManager()->createInstanceWithContext( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter") ), xContext ), uno::UNO_QUERY_THROW ); - return xTypeConv; -} -// helper method to determine if the view ( calc ) is in print-preview mode -bool isInPrintPreview( SfxViewFrame* pView ) -{ - sal_uInt16 nViewNo = SID_VIEWSHELL1 - SID_VIEWSHELL0; - if ( pView->GetObjectShell()->GetFactory().GetViewFactoryCount() > -nViewNo && !pView->GetObjectShell()->IsInPlaceActive() ) - { - SfxViewFactory &rViewFactory = - pView->GetObjectShell()->GetFactory().GetViewFactory(nViewNo); - if ( pView->GetCurViewId() == rViewFactory.GetOrdinal() ) - return true; - } - return false; -} -const ::rtl::OUString REPLACE_CELLS_WARNING( RTL_CONSTASCII_USTRINGPARAM( "ReplaceCellsWarning")); -const uno::Any& -aNULL() -{ - static uno::Any aNULLL = uno::makeAny( uno::Reference< uno::XInterface >() ); - return aNULLL; -} - -class PasteCellsWarningReseter -{ -private: - bool bInitialWarningState; - static uno::Reference< beans::XPropertySet > getGlobalSheetSettings() throw ( uno::RuntimeException ) - { - static uno::Reference< beans::XPropertySet > xTmpProps( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); - static uno::Reference<uno::XComponentContext > xContext( xTmpProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))), uno::UNO_QUERY_THROW ); - static uno::Reference<lang::XMultiComponentFactory > xServiceManager( - xContext->getServiceManager(), uno::UNO_QUERY_THROW ); - static uno::Reference< beans::XPropertySet > xProps( xServiceManager->createInstanceWithContext( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sheet.GlobalSheetSettings" ) ) ,xContext ), uno::UNO_QUERY_THROW ); - return xProps; - } - - bool getReplaceCellsWarning() throw ( uno::RuntimeException ) - { - sal_Bool res = sal_False; - getGlobalSheetSettings()->getPropertyValue( REPLACE_CELLS_WARNING ) >>= res; - return ( res == sal_True ); - } - - void setReplaceCellsWarning( bool bState ) throw ( uno::RuntimeException ) - { - getGlobalSheetSettings()->setPropertyValue( REPLACE_CELLS_WARNING, uno::makeAny( bState ) ); - } -public: - PasteCellsWarningReseter() throw ( uno::RuntimeException ) - { - bInitialWarningState = getReplaceCellsWarning(); - if ( bInitialWarningState ) - setReplaceCellsWarning( false ); - } - ~PasteCellsWarningReseter() - { - if ( bInitialWarningState ) - { - // don't allow dtor to throw - try - { - setReplaceCellsWarning( true ); - } - catch ( uno::Exception& /*e*/ ){} - } - } -}; - -void dispatchExecute(css::uno::Reference< css::frame::XModel>& xModel, USHORT nSlot, SfxCallMode nCall) -{ - ScTabViewShell* pViewShell = getBestViewShell( xModel ); - SfxViewFrame* pViewFrame = NULL; - if ( pViewShell ) - pViewFrame = pViewShell->GetViewFrame(); - if ( pViewFrame ) - { - SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher(); - if( pDispatcher ) - { - pDispatcher->Execute( nSlot , nCall ); - } - } -} - -void -implnPaste() -{ - PasteCellsWarningReseter resetWarningBox; - ScTabViewShell* pViewShell = getCurrentBestViewShell(); - if ( pViewShell ) - { - pViewShell->PasteFromSystem(); - pViewShell->CellContentChanged(); - } -} - - -void -implnCopy() -{ - ScTabViewShell* pViewShell = getCurrentBestViewShell(); - if ( pViewShell ) - pViewShell->CopyToClip(NULL,false,false,true); -} - -void -implnCut() -{ - ScTabViewShell* pViewShell = getCurrentBestViewShell(); - if ( pViewShell ) - pViewShell->CutToClip( NULL, TRUE ); -} - -void implnPasteSpecial(USHORT nFlags,USHORT nFunction,sal_Bool bSkipEmpty, sal_Bool bTranspose) -{ - PasteCellsWarningReseter resetWarningBox; - sal_Bool bAsLink(sal_False), bOtherDoc(sal_False); - InsCellCmd eMoveMode = INS_NONE; - - ScTabViewShell* pTabViewShell = ScTabViewShell::GetActiveViewShell(); - if ( !pTabViewShell ) - // none active, try next best - pTabViewShell = getCurrentBestViewShell(); - if ( pTabViewShell ) - { - ScViewData* pView = pTabViewShell->GetViewData(); - Window* pWin = ( pView != NULL ) ? pView->GetActiveWin() : NULL; - if ( pView && pWin ) - { - if ( bAsLink && bOtherDoc ) - pTabViewShell->PasteFromSystem(0);//SOT_FORMATSTR_ID_LINK - else - { - ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pWin ); - ScDocument* pDoc = NULL; - if ( pOwnClip ) - pDoc = pOwnClip->GetDocument(); - pTabViewShell->PasteFromClip( nFlags, pDoc, - nFunction, bSkipEmpty, bTranspose, bAsLink, - eMoveMode, IDF_NONE, TRUE ); - pTabViewShell->CellContentChanged(); - } - } - } - -} - - uno::Reference< frame::XModel > -getCurrentDocument() throw (uno::RuntimeException) -{ - uno::Reference< frame::XModel > xModel; - SbxObject* pBasic = dynamic_cast< SbxObject* > ( SFX_APP()->GetBasic() ); - SbxObject* basicChosen = pBasic ; - if ( basicChosen == NULL) - { - OSL_TRACE("getModelFromBasic() StarBASIC* is NULL" ); - return xModel; - } - SbxObject* p = pBasic; - SbxObject* pParent = p->GetParent(); - SbxObject* pParentParent = pParent ? pParent->GetParent() : NULL; - - if( pParentParent ) - { - basicChosen = pParentParent; - } - else if( pParent ) - { - basicChosen = pParent; - } - - - uno::Any aModel; - SbxVariable *pCompVar = basicChosen->Find( UniString(RTL_CONSTASCII_USTRINGPARAM("ThisComponent")), SbxCLASS_OBJECT ); - - if ( pCompVar ) - { - aModel = sbxToUnoValue( pCompVar ); - if ( sal_False == ( aModel >>= xModel ) || - !xModel.is() ) - { - // trying last gasp try the current component - uno::Reference< beans::XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); - // test if vba service is present - uno::Reference< uno::XComponentContext > xCtx( xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))), uno::UNO_QUERY_THROW ); - uno::Reference<lang::XMultiComponentFactory > xSMgr( xCtx->getServiceManager(), uno::UNO_QUERY_THROW ); - uno::Reference< frame::XDesktop > xDesktop (xSMgr->createInstanceWithContext(::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop"), xCtx), uno::UNO_QUERY_THROW ); - xModel.set( xDesktop->getCurrentComponent(), uno::UNO_QUERY ); - if ( !xModel.is() ) - { - throw uno::RuntimeException( - rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Can't extract model from basic ( its obviously not set yet ) therefore don't know the currently selected document") ), uno::Reference< uno::XInterface >() ); - } - return xModel; - } - else - { - OSL_TRACE("Have model ThisComponent points to url %s", - ::rtl::OUStringToOString( xModel->getURL(), - RTL_TEXTENCODING_ASCII_US ).pData->buffer ); - } - } - else - { - OSL_TRACE("Failed to get ThisComponent"); - throw uno::RuntimeException( - rtl::OUString( - RTL_CONSTASCII_USTRINGPARAM( - "Can't determine the currently selected document") ), - uno::Reference< uno::XInterface >() ); - } - return xModel; -} - -ScDocShell* -getDocShell( css::uno::Reference< css::frame::XModel>& xModel ) -{ - uno::Reference< uno::XInterface > xIf( xModel, uno::UNO_QUERY_THROW ); - ScModelObj* pModel = dynamic_cast< ScModelObj* >( xIf.get() ); - ScDocShell* pDocShell = NULL; - if ( pModel ) - pDocShell = (ScDocShell*)pModel->GetEmbeddedObject(); - return pDocShell; - -} - -ScTabViewShell* -getBestViewShell( css::uno::Reference< css::frame::XModel>& xModel ) -{ - ScDocShell* pDocShell = getDocShell( xModel ); - if ( pDocShell ) - return pDocShell->GetBestViewShell(); - return NULL; -} - -ScTabViewShell* -getCurrentBestViewShell() -{ - uno::Reference< frame::XModel > xModel = getCurrentDocument(); - return getBestViewShell( xModel ); -} - -SfxViewFrame* -getCurrentViewFrame() -{ - ScTabViewShell* pViewShell = getCurrentBestViewShell(); - if ( pViewShell ) - return pViewShell->GetViewFrame(); - return NULL; -} - -sal_Int32 -OORGBToXLRGB( sal_Int32 nCol ) -{ - sal_Int32 nRed = nCol; - nRed &= 0x00FF0000; - nRed >>= 16; - sal_Int32 nGreen = nCol; - nGreen &= 0x0000FF00; - nGreen >>= 8; - sal_Int32 nBlue = nCol; - nBlue &= 0x000000FF; - sal_Int32 nRGB = ( (nBlue << 16) | (nGreen << 8) | nRed ); - return nRGB; -} -sal_Int32 -XLRGBToOORGB( sal_Int32 nCol ) -{ - sal_Int32 nBlue = nCol; - nBlue &= 0x00FF0000; - nBlue >>= 16; - sal_Int32 nGreen = nCol; - nGreen &= 0x0000FF00; - nGreen >>= 8; - sal_Int32 nRed = nCol; - nRed &= 0x000000FF; - sal_Int32 nRGB = ( (nRed << 16) | (nGreen << 8) | nBlue ); - return nRGB; -} -uno::Any -OORGBToXLRGB( const uno::Any& aCol ) -{ - sal_Int32 nCol=0; - aCol >>= nCol; - nCol = OORGBToXLRGB( nCol ); - return uno::makeAny( nCol ); -} -uno::Any -XLRGBToOORGB( const uno::Any& aCol ) -{ - sal_Int32 nCol=0; - aCol >>= nCol; - nCol = XLRGBToOORGB( nCol ); - return uno::makeAny( nCol ); -} - -void PrintOutHelper( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& /*ActivePrinter*/, const uno::Any& /*PrintToFile*/, const uno::Any& Collate, const uno::Any& PrToFileName, css::uno::Reference< frame::XModel >& xModel, sal_Bool bUseSelection ) -{ - sal_Int32 nTo = 0; - sal_Int32 nFrom = 0; - sal_Int16 nCopies = 1; - sal_Bool bPreview = sal_False; - sal_Bool bCollate = sal_False; - sal_Bool bSelection = bUseSelection; - From >>= nFrom; - To >>= nTo; - Copies >>= nCopies; - Preview >>= bPreview; - if ( nCopies > 1 ) // Collate only useful when more that 1 copy - Collate >>= bCollate; - - rtl::OUString sRange( RTL_CONSTASCII_USTRINGPARAM( "-" ) ); - rtl::OUString sFileName; - - if (( nFrom || nTo ) ) - { - if ( nFrom ) - sRange = ( ::rtl::OUString::valueOf( nFrom ) + sRange ); - if ( nTo ) - sRange += ::rtl::OUString::valueOf( nTo ); - } - - if ( PrToFileName.getValue() ) - { - PrToFileName >>= sFileName; - } - ScTabViewShell* pViewShell = getBestViewShell( xModel ); - SfxViewFrame* pViewFrame = NULL; - if ( pViewShell ) - pViewFrame = pViewShell->GetViewFrame(); - if ( pViewFrame ) - { - SfxAllItemSet aArgs( SFX_APP()->GetPool() ); - - SfxBoolItem sfxCollate( SID_PRINT_COLLATE, bCollate ); - aArgs.Put( sfxCollate, sfxCollate.Which() ); - SfxInt16Item sfxCopies( SID_PRINT_COPIES, nCopies ); - aArgs.Put( sfxCopies, sfxCopies.Which() ); - if ( sFileName.getLength() ) - { - SfxStringItem sfxFileName( SID_FILE_NAME, sFileName); - aArgs.Put( sfxFileName, sfxFileName.Which() ); - - } - if ( sRange.getLength() ) - { - SfxStringItem sfxRange( SID_PRINT_PAGES, sRange ); - aArgs.Put( sfxRange, sfxRange.Which() ); - } - SfxBoolItem sfxSelection( SID_SELECTION, bSelection ); - aArgs.Put( sfxSelection, sfxSelection.Which() ); - SfxBoolItem sfxAsync( SID_ASYNCHRON, sal_False ); - aArgs.Put( sfxAsync, sfxAsync.Which() ); - SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher(); - - if ( pDispatcher ) - { - if ( bPreview ) - { - if ( !pViewFrame->GetFrame().IsInPlace() ) - { - SC_MOD()->InputEnterHandler(); - pViewFrame->GetDispatcher()->Execute( SID_VIEWSHELL1, SFX_CALLMODE_SYNCHRON ); - while ( isInPrintPreview( pViewFrame ) ) - Application::Yield(); - } - } - else - pDispatcher->Execute( (USHORT)SID_PRINTDOC, (SfxCallMode)SFX_CALLMODE_SYNCHRON, aArgs ); - } - - } - - // #FIXME #TODO - // 1 ActivePrinter ( how/can we switch a printer via API? ) - // 2 PrintToFile ( ms behaviour if this option is specified but no - // filename supplied 'PrToFileName' then the user will be prompted ) - // 3 Need to check behaviour of Selected sheets with range ( e.g. From & To - // values ) in oOO these options are mutually exclusive - // 4 There is a pop up to do with transparent objects in the print source - // should be able to disable that via configuration for the duration - // of this method -} - - void PrintPreviewHelper( const css::uno::Any& /*EnableChanges*/, css::uno::Reference< css::frame::XModel >& xModel ) -{ - dispatchExecute( xModel, SID_VIEWSHELL1 ); -} - -rtl::OUString getAnyAsString( const uno::Any& pvargItem ) throw ( uno::RuntimeException ) -{ - uno::Type aType = pvargItem.getValueType(); - uno::TypeClass eTypeClass = aType.getTypeClass(); - rtl::OUString sString; - switch ( eTypeClass ) - { - case uno::TypeClass_BOOLEAN: - { - sal_Bool bBool = sal_False; - pvargItem >>= bBool; - sString = rtl::OUString::valueOf( bBool ); - break; - } - case uno::TypeClass_STRING: - pvargItem >>= sString; - break; - case uno::TypeClass_FLOAT: - { - float aFloat = 0; - pvargItem >>= aFloat; - sString = rtl::OUString::valueOf( aFloat ); - break; - } - case uno::TypeClass_DOUBLE: - { - double aDouble = 0; - pvargItem >>= aDouble; - sString = rtl::OUString::valueOf( aDouble ); - break; - } - case uno::TypeClass_SHORT: - case uno::TypeClass_LONG: - case uno::TypeClass_BYTE: - { - sal_Int32 aNum = 0; - pvargItem >>= aNum; - sString = rtl::OUString::valueOf( aNum ); - break; - } - - case uno::TypeClass_HYPER: - { - sal_Int64 aHyper = 0; - pvargItem >>= aHyper; - sString = rtl::OUString::valueOf( aHyper ); - break; - } - default: - throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid type, can't convert" ), uno::Reference< uno::XInterface >() ); - } - return sString; -} - - -rtl::OUString -ContainerUtilities::getUniqueName( const uno::Sequence< ::rtl::OUString >& _slist, const rtl::OUString& _sElementName, const ::rtl::OUString& _sSuffixSeparator) -{ - return getUniqueName(_slist, _sElementName, _sSuffixSeparator, sal_Int32(2)); -} - -rtl::OUString -ContainerUtilities::getUniqueName( const uno::Sequence< rtl::OUString >& _slist, const rtl::OUString _sElementName, const rtl::OUString& _sSuffixSeparator, sal_Int32 _nStartSuffix) -{ - sal_Int32 a = _nStartSuffix; - rtl::OUString scompname = _sElementName; - bool bElementexists = true; - sal_Int32 nLen = _slist.getLength(); - if ( nLen == 0 ) - return _sElementName; - - while (bElementexists == true) - { - for (sal_Int32 i = 0; i < nLen; i++) - { - if (FieldInList(_slist, scompname) == -1) - { - return scompname; - } - } - scompname = _sElementName + _sSuffixSeparator + rtl::OUString::valueOf( a++ ); - } - return rtl::OUString(); -} - -sal_Int32 -ContainerUtilities::FieldInList( const uno::Sequence< rtl::OUString >& SearchList, const rtl::OUString& SearchString ) -{ - sal_Int32 FieldLen = SearchList.getLength(); - sal_Int32 retvalue = -1; - for (sal_Int32 i = 0; i < FieldLen; i++) - { - // I wonder why comparing lexicographically is done - // when its a match is whats interesting? - //if (SearchList[i].compareTo(SearchString) == 0) - if ( SearchList[i].equals( SearchString ) ) - { - retvalue = i; - break; - } - } - return retvalue; - -} -bool NeedEsc(sal_Unicode cCode) -{ - String sEsc(RTL_CONSTASCII_USTRINGPARAM(".^$+\\|{}()")); - return (STRING_NOTFOUND != sEsc.Search(cCode)); -} - -rtl::OUString VBAToRegexp(const rtl::OUString &rIn, bool bForLike ) -{ - rtl::OUStringBuffer sResult; - const sal_Unicode *start = rIn.getStr(); - const sal_Unicode *end = start + rIn.getLength(); - - int seenright = 0; - if ( bForLike ) - sResult.append(static_cast<sal_Unicode>('^')); - - while (start < end) - { - switch (*start) - { - case '?': - sResult.append(static_cast<sal_Unicode>('.')); - start++; - break; - case '*': - sResult.append(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".*"))); - start++; - break; - case '#': - sResult.append(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("[0-9]"))); - start++; - break; - case '~': - sResult.append(static_cast<sal_Unicode>('\\')); - sResult.append(*(++start)); - start++; - break; - // dump the ~ and escape the next characture - case ']': - sResult.append(static_cast<sal_Unicode>('\\')); - sResult.append(*start++); - break; - case '[': - sResult.append(*start++); - seenright = 0; - while (start < end && !seenright) - { - switch (*start) - { - case '[': - case '?': - case '*': - sResult.append(static_cast<sal_Unicode>('\\')); - sResult.append(*start); - break; - case ']': - sResult.append(*start); - seenright = 1; - break; - case '!': - sResult.append(static_cast<sal_Unicode>('^')); - break; - default: - if (NeedEsc(*start)) - sResult.append(static_cast<sal_Unicode>('\\')); - sResult.append(*start); - break; - } - start++; - } - break; - default: - if (NeedEsc(*start)) - sResult.append(static_cast<sal_Unicode>('\\')); - sResult.append(*start++); - } - } - - if ( bForLike ) - sResult.append(static_cast<sal_Unicode>('$')); - - return sResult.makeStringAndClear( ); -} - -double getPixelTo100thMillimeterConversionFactor( css::uno::Reference< css::awt::XDevice >& xDevice, sal_Bool bVertical) -{ - double fConvertFactor = 1.0; - if( bVertical ) - { - fConvertFactor = xDevice->getInfo().PixelPerMeterY/100000; - } - else - { - fConvertFactor = xDevice->getInfo().PixelPerMeterX/100000; - } - return fConvertFactor; -} - -double PointsToPixels( css::uno::Reference< css::awt::XDevice >& xDevice, double fPoints, sal_Bool bVertical) -{ - double fConvertFactor = getPixelTo100thMillimeterConversionFactor( xDevice, bVertical ); - return fPoints * POINTTO100THMILLIMETERFACTOR * fConvertFactor; -} -double PixelsToPoints( css::uno::Reference< css::awt::XDevice >& xDevice, double fPixels, sal_Bool bVertical) -{ - double fConvertFactor = getPixelTo100thMillimeterConversionFactor( xDevice, bVertical ); - return (fPixels/fConvertFactor)/POINTTO100THMILLIMETERFACTOR; -} - -ConcreteXShapeGeometryAttributes::ConcreteXShapeGeometryAttributes( const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::drawing::XShape >& xShape ) -{ - m_xShape = new ScVbaShape( xContext, xShape ); -} - -#define VBA_LEFT "PositionX" -#define VBA_TOP "PositionY" -UserFormGeometryHelper::UserFormGeometryHelper( const uno::Reference< uno::XComponentContext >& /*xContext*/, const uno::Reference< awt::XControl >& xControl ) -{ - mxModel.set( xControl->getModel(), uno::UNO_QUERY_THROW ); -} - double UserFormGeometryHelper::getLeft() - { - sal_Int32 nLeft = 0; - mxModel->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( VBA_LEFT ) ) ) >>= nLeft; - return Millimeter::getInPoints( nLeft ); - } - void UserFormGeometryHelper::setLeft( double nLeft ) - { - mxModel->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( VBA_LEFT ) ), uno::makeAny( Millimeter::getInHundredthsOfOneMillimeter( nLeft ) ) ); - } - double UserFormGeometryHelper::getTop() - { - sal_Int32 nTop = 0; - mxModel->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( VBA_TOP ) ) ) >>= nTop; - return Millimeter::getInPoints( nTop ); - } - void UserFormGeometryHelper::setTop( double nTop ) - { - mxModel->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( VBA_TOP ) ), uno::makeAny( Millimeter::getInHundredthsOfOneMillimeter( nTop ) ) ); - } - double UserFormGeometryHelper::getHeight() - { - sal_Int32 nHeight = 0; - mxModel->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_CELLHGT ) ) ) >>= nHeight; - return Millimeter::getInPoints( nHeight ); - } - void UserFormGeometryHelper::setHeight( double nHeight ) - { - mxModel->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_CELLHGT ) ), uno::makeAny( Millimeter::getInHundredthsOfOneMillimeter( nHeight ) ) ); - } - double UserFormGeometryHelper::getWidth() - { - sal_Int32 nWidth = 0; - mxModel->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_CELLWID ) ) ) >>= nWidth; - return Millimeter::getInPoints( nWidth ); - } - void UserFormGeometryHelper::setWidth( double nWidth) - { - mxModel->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_CELLWID ) ), uno::makeAny( Millimeter::getInHundredthsOfOneMillimeter( nWidth ) ) ); - } - -SfxItemSet* -ScVbaCellRangeAccess::GetDataSet( ScCellRangeObj* pRangeObj ) -{ - SfxItemSet* pDataSet = pRangeObj ? pRangeObj->GetCurrentDataSet( true ) : NULL ; - return pDataSet; - -} - -} // vba -} // ooo diff --git a/sc/source/ui/vba/vbaname.cxx b/sc/source/ui/vba/vbaname.cxx index 464b167df250..cd99430acb15 100644 --- a/sc/source/ui/vba/vbaname.cxx +++ b/sc/source/ui/vba/vbaname.cxx @@ -69,8 +69,8 @@ ScVbaName::getWorkSheet() throw (css::uno::RuntimeException) ScVbaName::getName() throw (css::uno::RuntimeException) { String sName; - sName += UniString( getWorkSheet()->getName()); - sName += String::CreateFromAscii("!"); + //sName += UniString( getWorkSheet()->getName()); //liuchen 2009-9-9 resolve the defect that the name get by macro code are not the same with that in UI (for example, if a name of "AA" is found in the UI "Define Names" dialog box, the result of get that name through macro code will be "Sheet1!AA") + //sName += String::CreateFromAscii("!"); sName += UniString ( mxNamedRange->getName() ); return ::rtl::OUString( sName ); } @@ -107,78 +107,41 @@ ScVbaName::setVisible( sal_Bool /*bVisible*/ ) throw (css::uno::RuntimeException ::rtl::OUString ScVbaName::getValue() throw (css::uno::RuntimeException) { - ::rtl::OUString sValue = mxNamedRange->getContent(); - ::rtl::OUString sSheetName = getWorkSheet()->getName(); - ::rtl::OUString sSegmentation = ::rtl::OUString::createFromAscii( ";" ); - ::rtl::OUString sNewSegmentation = ::rtl::OUString::createFromAscii( "," ); - ::rtl::OUString sResult; - sal_Int32 nFrom = 0; - sal_Int32 nTo = 0; - nTo = sValue.indexOf( sSegmentation, nFrom ); - while ( nTo != -1 ) - { - ::rtl::OUString sTmpValue = sValue.copy( nFrom, nTo - nFrom ); - if ( sTmpValue.toChar() == '$' ) - { - ::rtl::OUString sTmp = sTmpValue.copy( 1 ); - sTmp = sTmp.replaceAt(0, (sSheetName + ::rtl::OUString::createFromAscii(".")).getLength(), sSheetName + ::rtl::OUString::createFromAscii("!")); - sResult += sTmp; - sResult += sNewSegmentation; - } - nFrom = nTo + 1; - nTo = sValue.indexOf( sSegmentation, nFrom ); - } - ::rtl::OUString sTmpValue = sValue.copy( nFrom ); - if ( sTmpValue.toChar() == '$' ) + return getValue( formula::FormulaGrammar::GRAM_NATIVE_XL_A1 ); +} + +::rtl::OUString +ScVbaName::getValue(const formula::FormulaGrammar::Grammar eGrammar) throw (css::uno::RuntimeException) +{ + rtl::OUString sValue = mxNamedRange->getContent(); + ScDocShell* pDocShell = excel::getDocShell( mxModel ); + ScDocument* pDoc = pDocShell ? pDocShell->GetDocument() : NULL; + String aContent; + excel::CompileODFFormulaToExcel( pDoc, sValue, aContent, eGrammar ); + if ( aContent.Len() > 0 ) { - ::rtl::OUString sTmp = sTmpValue.copy(1); - sTmp = sTmp.replaceAt(0, (sSheetName + ::rtl::OUString::createFromAscii(".")).getLength(), sSheetName + ::rtl::OUString::createFromAscii("!")); - sResult += sTmp; + sValue = aContent; } - if (sResult.indexOf('=') != 0) + if ( sValue.indexOf('=') != 0 ) { - sResult = ::rtl::OUString::createFromAscii("=") + sResult; + sValue = rtl::OUString::createFromAscii("=") + sValue; } - return sResult; + return sValue; } void ScVbaName::setValue( const ::rtl::OUString & rValue ) throw (css::uno::RuntimeException) { - ::rtl::OUString sSheetName = getWorkSheet()->getName(); ::rtl::OUString sValue = rValue; - ::rtl::OUString sSegmentation = ::rtl::OUString::createFromAscii( "," ); - ::rtl::OUString sNewSegmentation = ::rtl::OUString::createFromAscii( ";" ); - ::rtl::OUString sResult; - sal_Int32 nFrom = 0; - sal_Int32 nTo = 0; - if (sValue.indexOf('=') == 0) + ScDocShell* pDocShell = excel::getDocShell( mxModel ); + ScDocument* pDoc = pDocShell ? pDocShell->GetDocument() : NULL; + String aContent; + excel::CompileExcelFormulaToODF( pDoc, sValue, aContent ); + if ( aContent.Len() > 0 ) { - ::rtl::OUString sTmp = sValue.copy(1); - sValue = sTmp; + sValue = aContent; } - nTo = sValue.indexOf( sSegmentation, nFrom ); - while ( nTo != -1 ) - { - ::rtl::OUString sTmpValue = sValue.copy( nFrom, nTo - nFrom ); - sTmpValue = sTmpValue.replaceAt(0, (sSheetName + ::rtl::OUString::createFromAscii("!")).getLength(), sSheetName + ::rtl::OUString::createFromAscii(".")); - if (sTmpValue.copy(0, sSheetName.getLength()).equals(sSheetName)) - { - sTmpValue = ::rtl::OUString::createFromAscii("$") + sTmpValue; - } - sTmpValue += sNewSegmentation; - sResult += sTmpValue; - nFrom = nTo + 1; - nTo = sValue.indexOf( sSegmentation, nFrom ); - } - ::rtl::OUString sTmpValue = sValue.copy( nFrom ); - sTmpValue = sTmpValue.replaceAt(0, (sSheetName + ::rtl::OUString::createFromAscii("!")).getLength(), sSheetName + ::rtl::OUString::createFromAscii(".")); - if (sTmpValue.copy(0, sSheetName.getLength()).equals(sSheetName)) - { - sTmpValue = ::rtl::OUString::createFromAscii("$") + sTmpValue; - } - sResult += sTmpValue; - mxNamedRange->setContent(sResult); + mxNamedRange->setContent( sValue ); } ::rtl::OUString @@ -208,7 +171,7 @@ ScVbaName::setRefersToLocal( const ::rtl::OUString & rRefersTo ) throw (css::uno ::rtl::OUString ScVbaName::getRefersToR1C1() throw (css::uno::RuntimeException) { - return getRefersTo(); + return getValue( formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 ); } void @@ -220,7 +183,7 @@ ScVbaName::setRefersToR1C1( const ::rtl::OUString & rRefersTo ) throw (css::uno: ::rtl::OUString ScVbaName::getRefersToR1C1Local() throw (css::uno::RuntimeException) { - return getRefersTo(); + return getValue( formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 ); } void diff --git a/sc/source/ui/vba/vbaname.hxx b/sc/source/ui/vba/vbaname.hxx index 81b2555a4ce1..8e0aa3973aae 100644 --- a/sc/source/ui/vba/vbaname.hxx +++ b/sc/source/ui/vba/vbaname.hxx @@ -33,6 +33,8 @@ #include <vbahelper/vbahelperinterface.hxx> +#include <formula/grammar.hxx> + class ScDocument; typedef InheritedHelperInterfaceImpl1< ov::excel::XName > NameImpl_BASE; @@ -48,6 +50,8 @@ class ScVbaName : public NameImpl_BASE protected: virtual css::uno::Reference< css::frame::XModel > getModel() { return mxModel; } virtual css::uno::Reference< ov::excel::XWorksheet > getWorkSheet() throw (css::uno::RuntimeException); + // Get value by FormulaGrammar, such as FormulaGrammar::GRAM_NATIVE_XL_R1C1 + virtual ::rtl::OUString SAL_CALL getValue(const formula::FormulaGrammar::Grammar eGrammar) throw (css::uno::RuntimeException); public: ScVbaName( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::sheet::XNamedRange >& xName , const css::uno::Reference< css::sheet::XNamedRanges >& xNames , const css::uno::Reference< css::frame::XModel >& xModel ); diff --git a/sc/source/ui/vba/vbanames.cxx b/sc/source/ui/vba/vbanames.cxx index 9fd22bf89f7a..f79dc5023d28 100644 --- a/sc/source/ui/vba/vbanames.cxx +++ b/sc/source/ui/vba/vbanames.cxx @@ -87,6 +87,33 @@ ScVbaNames::getScDocument() return pViewData->GetDocument(); } +void GetRangeOrRefersTo( const css::uno::Any& RefersTo, const uno::Reference< uno::XComponentContext >& xContext, css::uno::Reference< excel::XRange >& xRange, rtl::OUString& sRefersTo ) +{ + if ( RefersTo.getValueTypeClass() == uno::TypeClass_STRING ) + { + RefersTo >>= sRefersTo; + } + else if ( RefersTo.getValueTypeClass() == uno::TypeClass_INTERFACE ) + { + RefersTo >>= xRange; + } + else if ( RefersTo.hasValue() ) + { + uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( xContext ); + try + { + if ( xConverter.is() ) + { + uno::Any aConverted = xConverter->convertTo( RefersTo, getCppuType((rtl::OUString*)0) ); + aConverted >>= sRefersTo; + } + } + catch( uno::Exception& ) + { + } + } +} + css::uno::Any ScVbaNames::Add( const css::uno::Any& Name , const css::uno::Any& RefersTo, @@ -100,8 +127,9 @@ ScVbaNames::Add( const css::uno::Any& Name , const css::uno::Any& RefersToR1C1, const css::uno::Any& RefersToR1C1Local ) throw (css::uno::RuntimeException) { - + rtl::OUString sSheetName; rtl::OUString sName; + rtl::OUString sRefersTo; uno::Reference< excel::XRange > xRange; if ( Name.hasValue() ) Name >>= sName; @@ -109,6 +137,12 @@ ScVbaNames::Add( const css::uno::Any& Name , NameLocal >>= sName; if ( sName.getLength() != 0 ) { + sal_Int32 nTokenIndex = sName.indexOf('!'); + if ( nTokenIndex >= 0 ) + { + sSheetName = sName.copy( 0, nTokenIndex ); + sName = sName.copy( nTokenIndex + 1 ); + } if ( !ScRangeData::IsNameValid( sName , getScDocument() ) ) { ::rtl::OUString sResult ; @@ -121,19 +155,22 @@ ScVbaNames::Add( const css::uno::Any& Name , sResult = sName.copy( nIndex ); sName = sResult ; if ( !ScRangeData::IsNameValid( sName , getScDocument() ) ) - throw uno::RuntimeException( rtl::OUString::createFromAscii("This Name is a valid ."), uno::Reference< uno::XInterface >() ); + throw uno::RuntimeException( rtl::OUString::createFromAscii("This Name is a invalid ."), uno::Reference< uno::XInterface >() ); } } if ( RefersTo.hasValue() || RefersToR1C1.hasValue() || RefersToR1C1Local.hasValue() ) { if ( RefersTo.hasValue() ) - RefersTo >>= xRange; + GetRangeOrRefersTo( RefersTo, mxContext, xRange, sRefersTo ); if ( RefersToR1C1.hasValue() ) - RefersToR1C1 >>= xRange; + GetRangeOrRefersTo( RefersToR1C1, mxContext, xRange, sRefersTo ); if ( RefersToR1C1Local.hasValue() ) - RefersToR1C1Local >>= xRange; + GetRangeOrRefersTo( RefersToR1C1Local, mxContext, xRange, sRefersTo ); } + String aContent; + table::CellAddress aPosition; + RangeType nType = RT_NAME; if ( xRange.is() ) { ScVbaRange* pRange = dynamic_cast< ScVbaRange* >( xRange.get() ); @@ -146,19 +183,36 @@ ScVbaNames::Add( const css::uno::Any& Name , ScAddress aPos( static_cast< SCCOL >( aAddr.StartColumn ) , static_cast< SCROW >( aAddr.StartRow ) , static_cast< SCTAB >(aAddr.Sheet ) ); uno::Any xAny2 ; String sRangeAdd = xRange->Address( xAny2, xAny2 , xAny2 , xAny2, xAny2 ); - String sTmp; - sTmp += String::CreateFromAscii("$"); - sTmp += UniString(xRange->getWorksheet()->getName()); - sTmp += String::CreateFromAscii("."); - sTmp += sRangeAdd; - if ( mxNames.is() ) + aContent += String::CreateFromAscii("$"); + aContent += UniString(xRange->getWorksheet()->getName()); + aContent += String::CreateFromAscii("."); + aContent += sRangeAdd; + aPosition = table::CellAddress( aAddr.Sheet , aAddr.StartColumn , aAddr.StartRow ); + } + else + { + ScDocShell* pDocShell = excel::getDocShell( mxModel ); + ScDocument* pDoc = pDocShell ? pDocShell->GetDocument() : NULL; + excel::CompileExcelFormulaToODF( pDoc, sRefersTo, aContent ); + if ( aContent.Len() == 0 ) + { + aContent = sRefersTo; + } + } + + uno::Reference< sheet::XNamedRange > xNewNamedRange; + if ( mxNames.is() ) + { + if ( mxNames->hasByName( sName ) ) { - RangeType nType = RT_NAME; - table::CellAddress aCellAddr( aAddr.Sheet , aAddr.StartColumn , aAddr.StartRow ); - if ( mxNames->hasByName( sName ) ) - mxNames->removeByName(sName); - mxNames->addNewByName( sName , rtl::OUString(sTmp) , aCellAddr , (sal_Int32)nType); + mxNames->removeByName( sName ); } + mxNames->addNewByName( sName, rtl::OUString( aContent ), aPosition, (sal_Int32) nType ); + xNewNamedRange = uno::Reference< sheet::XNamedRange >( mxNames->getByName( sName ), uno::UNO_QUERY ); + } + if ( xNewNamedRange.is() ) + { + return uno::makeAny( uno::Reference< excel::XName >( new ScVbaName( mxParent, mxContext, xNewNamedRange ,mxNames , mxModel ) ) ); } return css::uno::Any(); } diff --git a/sc/source/ui/vba/vbaoleobject.cxx b/sc/source/ui/vba/vbaoleobject.cxx index a35ce4b3120f..e74fa48f1755 100644 --- a/sc/source/ui/vba/vbaoleobject.cxx +++ b/sc/source/ui/vba/vbaoleobject.cxx @@ -67,7 +67,7 @@ ScVbaOLEObject::ScVbaOLEObject( const uno::Reference< XHelperInterface >& xParen uno::Reference< uno::XInterface > SAL_CALL ScVbaOLEObject::getObject() throw (uno::RuntimeException) { - return uno::Reference< uno::XInterface >( m_xControlShape, uno::UNO_QUERY_THROW ); + return uno::Reference< uno::XInterface >( m_xControl, uno::UNO_QUERY_THROW ); } sal_Bool SAL_CALL diff --git a/sc/source/ui/vba/vbapagebreaks.cxx b/sc/source/ui/vba/vbapagebreaks.cxx index 25ccbb0f4cdc..89ea1533921f 100644 --- a/sc/source/ui/vba/vbapagebreaks.cxx +++ b/sc/source/ui/vba/vbapagebreaks.cxx @@ -115,10 +115,13 @@ sal_Int32 SAL_CALL RangePageBreaks::getCount( ) throw (uno::RuntimeException) for( sal_Int32 i=0; i<nLength; i++ ) { sal_Int32 nPos = aTablePageBreakData[i].Position; - if( nPos > nUsedEnd ) - return nCount; - if( nPos >= nUsedStart ) + + // VBA. minz@cn.ibm.com. All page breaks before the used range should be counted. + // And the page break at the end of the used range also should be counted. + if( nPos <= nUsedEnd + 1 ) nCount++; + else + return nCount; } return nCount; @@ -144,26 +147,15 @@ uno::Any SAL_CALL RangePageBreaks::getByIndex( sal_Int32 Index ) throw (lang::In sheet::TablePageBreakData RangePageBreaks::getTablePageBreakData( sal_Int32 nAPIItemIndex ) throw ( script::BasicErrorException, uno::RuntimeException) { - sal_Int32 index = -1; sheet::TablePageBreakData aTablePageBreakData; uno::Reference< excel::XWorksheet > xWorksheet( mxParent, uno::UNO_QUERY_THROW ); uno::Reference< excel::XRange > xRange = xWorksheet->getUsedRange(); - sal_Int32 nUsedStart = getAPIStartofRange( xRange ); - sal_Int32 nUsedEnd = getAPIEndIndexofRange( xRange, nUsedStart ); uno::Sequence<sheet::TablePageBreakData> aTablePageBreakDataList = getAllPageBreaks(); sal_Int32 nLength = aTablePageBreakDataList.getLength(); - for( sal_Int32 i=0; i<nLength; i++ ) - { - aTablePageBreakData = aTablePageBreakDataList[i]; - sal_Int32 nPos = aTablePageBreakData.Position; - if( nPos >= nUsedStart ) - index++; - if( nPos > nUsedEnd ) - DebugHelper::exception(SbERR_METHOD_FAILED, rtl::OUString()); - if( index == nAPIItemIndex ) - return aTablePageBreakData; - } + //VBA. minz@cn.ibm.com. No need to filter the page break. All page breaks before the used range are counted. + if ( nAPIItemIndex < nLength && nAPIItemIndex>=0 ) + aTablePageBreakData = aTablePageBreakDataList[nAPIItemIndex]; return aTablePageBreakData; } diff --git a/sc/source/ui/vba/vbapagesetup.cxx b/sc/source/ui/vba/vbapagesetup.cxx index d660ddbbfd77..f72b32477179 100644 --- a/sc/source/ui/vba/vbapagesetup.cxx +++ b/sc/source/ui/vba/vbapagesetup.cxx @@ -37,6 +37,9 @@ #include <ooo/vba/excel/XlPageOrientation.hpp> #include <ooo/vba/excel/XlOrder.hpp> #include <ooo/vba/excel/Constants.hpp> +#include <i18npool/paper.hxx> +#include <editeng/paperinf.hxx> +#include <ooo/vba/excel/XlPaperSize.hpp> using namespace ::com::sun::star; using namespace ::ooo::vba; @@ -624,3 +627,105 @@ ScVbaPageSetup::getServiceNames() } return aServiceNames; } + +//liuchen 2009-12-11 + +struct PaperSizeMap +{ + Paper ePaper; + sal_Int32 xlPaper; +}; + +static PaperSizeMap paperSizeMappings[] = +{ + { PAPER_A3, ooo::vba::excel::XlPaperSize::xlPaperA3 }, + { PAPER_A4, ooo::vba::excel::XlPaperSize::xlPaperA4 }, + { PAPER_A5, ooo::vba::excel::XlPaperSize::xlPaperA5 }, + { PAPER_B4_ISO, ooo::vba::excel::XlPaperSize::xlPaperB4 }, + { PAPER_B5_ISO, ooo::vba::excel::XlPaperSize::xlPaperB5 }, + { PAPER_LETTER, ooo::vba::excel::XlPaperSize::xlPaperLetter }, + { PAPER_LEGAL, ooo::vba::excel::XlPaperSize::xlPaperLegal }, + { PAPER_TABLOID, ooo::vba::excel::XlPaperSize::xlPaperTabloid }, + { PAPER_USER, ooo::vba::excel::XlPaperSize::xlPaperUser }, + { PAPER_B6_ISO, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeB6 }, + { PAPER_ENV_C4, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeC4 }, + { PAPER_ENV_C5, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeC5 }, + { PAPER_ENV_C6, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeC6 }, + { PAPER_ENV_C65, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeC65 }, + { PAPER_ENV_DL, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeDL }, + { PAPER_C, ooo::vba::excel::XlPaperSize::xlPaperCsheet }, + { PAPER_D, ooo::vba::excel::XlPaperSize::xlPaperDsheet }, + { PAPER_E, ooo::vba::excel::XlPaperSize::xlPaperEsheet }, + { PAPER_ENV_MONARCH, ooo::vba::excel::XlPaperSize::xlPaperEnvelopeMonarch }, + { PAPER_ENV_PERSONAL, ooo::vba::excel::XlPaperSize::xlPaperEnvelopePersonal }, + { PAPER_ENV_9, ooo::vba::excel::XlPaperSize::xlPaperEnvelope9 }, + { PAPER_ENV_10, ooo::vba::excel::XlPaperSize::xlPaperEnvelope10 }, + { PAPER_ENV_11, ooo::vba::excel::XlPaperSize::xlPaperEnvelope11 }, + { PAPER_ENV_12, ooo::vba::excel::XlPaperSize::xlPaperEnvelope12 } +}; + +static const int nMapSize = sizeof(paperSizeMappings) / sizeof(paperSizeMappings[0]); + +sal_Int32 PaperSizeOOoToExcel(Paper ePaper) +{ + sal_Int32 nPaperSize = ooo::vba::excel::XlPaperSize::xlPaperUser; + + for (int i = 0; i < nMapSize; i++) + { + if (ePaper == paperSizeMappings[i].ePaper) + { + nPaperSize = paperSizeMappings[i].xlPaper; + break; + } + } + + return nPaperSize; +} + +sal_Int32 SAL_CALL ScVbaPageSetup::getPaperSize() throw (css::uno::RuntimeException) +{ + com::sun::star::awt::Size size; + Paper ePaper = PAPER_USER; + + try + { + uno::Any aValue = mxPageProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Size"))); + aValue >>= size; + ePaper = SvxPaperInfo::GetSvxPaper( Size(size.Width, size.Height), MAP_100TH_MM, TRUE); + } + catch( uno::Exception& ) + { + } + + return PaperSizeOOoToExcel(ePaper); +} + +Paper PaperSizeExcelToOOo( sal_Int32 xlPaper) +{ + Paper ePaper = PAPER_USER; + + for (int i = 0; i < nMapSize; i++) + { + if (xlPaper == paperSizeMappings[i].xlPaper) + { + ePaper = paperSizeMappings[i].ePaper; + break; + } + } + + return ePaper; +} +void SAL_CALL ScVbaPageSetup::setPaperSize( sal_Int32 paperSize) throw (css::uno::RuntimeException) +{ + Paper ePaper = PaperSizeExcelToOOo( paperSize ); + + try + { + Size size1 = SvxPaperInfo::GetPaperSize( ePaper, MAP_100TH_MM ); + com::sun::star::awt::Size size(size1.Width(), size1.Height()); + mxPageProps->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Size")), uno::makeAny( size )); + } + catch( uno::Exception& ) + { + } +} diff --git a/sc/source/ui/vba/vbapagesetup.hxx b/sc/source/ui/vba/vbapagesetup.hxx index d2c001b225cf..f81ad5a7a29a 100644 --- a/sc/source/ui/vba/vbapagesetup.hxx +++ b/sc/source/ui/vba/vbapagesetup.hxx @@ -82,6 +82,8 @@ public: virtual void SAL_CALL setCenterHorizontally( sal_Bool centerHorizontally ) throw (css::uno::RuntimeException); virtual sal_Bool SAL_CALL getPrintHeadings() throw (css::uno::RuntimeException); virtual void SAL_CALL setPrintHeadings( sal_Bool printHeadings ) throw (css::uno::RuntimeException); + virtual sal_Int32 SAL_CALL getPaperSize() throw (css::uno::RuntimeException); //liuchen 2009-12-11 + virtual void SAL_CALL setPaperSize( sal_Int32 paperSize ) throw (css::uno::RuntimeException); //liuchen 2009-12-11 // XHelperInterface virtual rtl::OUString& getServiceImplName(); diff --git a/sc/source/ui/vba/vbapivotcache.cxx b/sc/source/ui/vba/vbapivotcache.cxx index 322b42368b48..01fe65e8111a 100644 --- a/sc/source/ui/vba/vbapivotcache.cxx +++ b/sc/source/ui/vba/vbapivotcache.cxx @@ -34,6 +34,17 @@ ScVbaPivotCache::ScVbaPivotCache( const uno::Reference< XHelperInterface >& xPar { } +sal_Int32 +ScVbaPivotCache::getMissingItemsLimit() throw (css::uno::RuntimeException) +{ + return -1; +} + +void +ScVbaPivotCache::setMissingItemsLimit( sal_Int32 /*aValue*/ ) throw ( css::uno::RuntimeException) +{ +} + void SAL_CALL ScVbaPivotCache::Refresh() throw (css::uno::RuntimeException) { diff --git a/sc/source/ui/vba/vbapivotcache.hxx b/sc/source/ui/vba/vbapivotcache.hxx index dea3e35d18bd..3b88fe311f33 100644 --- a/sc/source/ui/vba/vbapivotcache.hxx +++ b/sc/source/ui/vba/vbapivotcache.hxx @@ -40,6 +40,10 @@ class ScVbaPivotCache : public PivotCacheImpl_BASE css::uno::Reference< css::sheet::XDataPilotTable > m_xTable; public: ScVbaPivotCache( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::sheet::XDataPilotTable >& xTable ); + + virtual ::sal_Int32 SAL_CALL getMissingItemsLimit() throw (css::uno::RuntimeException); + virtual void SAL_CALL setMissingItemsLimit( ::sal_Int32 aValue ) throw ( css::uno::RuntimeException); + virtual void SAL_CALL Refresh() throw (css::uno::RuntimeException); // XHelperInterface virtual rtl::OUString& getServiceImplName(); diff --git a/sc/source/ui/vba/vbarange.cxx b/sc/source/ui/vba/vbarange.cxx index 455af075306c..bc46b8dbf279 100755 --- a/sc/source/ui/vba/vbarange.cxx +++ b/sc/source/ui/vba/vbarange.cxx @@ -43,7 +43,6 @@ #include <com/sun/star/text/XTextRange.hpp> #include <com/sun/star/sheet/XCellRangeAddressable.hpp> #include <com/sun/star/table/CellRangeAddress.hpp> -#include <com/sun/star/table/CellAddress.hpp> #include <com/sun/star/sheet/XSpreadsheetView.hpp> #include <com/sun/star/sheet/XCellRangeReferrer.hpp> #include <com/sun/star/sheet/XSheetCellRange.hpp> @@ -51,6 +50,7 @@ #include <com/sun/star/sheet/XSheetCellCursor.hpp> #include <com/sun/star/sheet/XArrayFormulaRange.hpp> #include <com/sun/star/sheet/XNamedRange.hpp> +#include <com/sun/star/sheet/XNamedRanges.hpp> #include <com/sun/star/sheet/XPrintAreas.hpp> #include <com/sun/star/sheet/XCellRangesQuery.hpp> #include <com/sun/star/beans/XPropertySet.hpp> @@ -92,6 +92,15 @@ #include <com/sun/star/sheet/XSubTotalDescriptor.hpp> #include <com/sun/star/sheet/GeneralFunction.hdl> +#include <com/sun/star/sheet/XSheetAnnotationsSupplier.hpp> +#include <com/sun/star/sheet/XSheetAnnotations.hpp> + +#include <com/sun/star/sheet/XDataPilotTable.hpp> +#include <com/sun/star/sheet/XDataPilotTable2.hpp> +#include <com/sun/star/sheet/XDataPilotTablesSupplier.hpp> +#include <com/sun/star/sheet/DataPilotTablePositionData.hpp> +#include <com/sun/star/sheet/DataPilotTablePositionType.hpp> + #include <ooo/vba/excel/XlPasteSpecialOperation.hpp> #include <ooo/vba/excel/XlPasteType.hpp> #include <ooo/vba/excel/Constants.hpp> @@ -117,12 +126,15 @@ #include <ooo/vba/excel/XlSpecialCellsValue.hpp> #include <ooo/vba/excel/XlConsolidationFunction.hpp> #include <ooo/vba/excel/XlSearchDirection.hpp> +#include <ooo/vba/excel/XlColumnDataType.hpp> +#include <ooo/vba/excel/XlFilterAction.hpp> #include <scitems.hxx> #include <svl/srchitem.hxx> #include <cellsuno.hxx> #include <dbcolect.hxx> #include "docfunc.hxx" +#include <docuno.hxx> #include <sfx2/dispatch.hxx> #include <sfx2/app.hxx> @@ -133,6 +145,7 @@ #include <sc.hrc> #include <globstr.hrc> #include <unonames.hxx> +#include <tools/stream.hxx> #include "vbarange.hxx" #include "vbafont.hxx" @@ -144,8 +157,13 @@ #include "vbavalidation.hxx" #include "vbahyperlinks.hxx" +#include "vbapivottable.hxx" + +#include "asciiopt.hxx" +#include "impex.hxx" #include "tabvwsh.hxx" #include "rangelst.hxx" +#include "rangenam.hxx" #include "convuno.hxx" #include "compiler.hxx" #include "attrib.hxx" @@ -159,6 +177,8 @@ #include "vbaglobals.hxx" #include "vbastyle.hxx" +#include "vbaname.hxx" +#include "vbanames.hxx" #include <vector> #include <vbahelper/vbacollectionimpl.hxx> // begin test includes @@ -363,55 +383,6 @@ ScVbaRangeAreas::createCollectionObject( const uno::Any& aSource ) return lcl_makeRange( mxParent, mxContext, aSource, mbIsRows, mbIsColumns ); } -// assume that xIf is infact a ScCellRangesBase -ScDocShell* -getDocShellFromIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException ) -{ - ScCellRangesBase* pUno = ScCellRangesBase::getImplementation( xIf ); - if ( !pUno ) - throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access underlying uno range object" ) ), uno::Reference< uno::XInterface >() ); - return pUno->GetDocShell(); -} - -ScDocShell* -getDocShellFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) -{ - // need the ScCellRangesBase to get docshell - uno::Reference< uno::XInterface > xIf( xRange, uno::UNO_QUERY_THROW ); - return getDocShellFromIf(xIf ); -} - -ScDocShell* -getDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException ) -{ - // need the ScCellRangesBase to get docshell - uno::Reference< uno::XInterface > xIf( xRanges, uno::UNO_QUERY_THROW ); - return getDocShellFromIf(xIf ); -} - -uno::Reference< frame::XModel > getModelFromXIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException ) -{ - ScDocShell* pDocShell = getDocShellFromIf(xIf ); - return pDocShell->GetModel(); -} - -uno::Reference< frame::XModel > getModelFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) -{ - uno::Reference< uno::XInterface > xIf( xRange, uno::UNO_QUERY_THROW ); - return getModelFromXIf( xIf ); -} - -ScDocument* -getDocumentFromRange( const uno::Reference< table::XCellRange >& xRange ) -{ - ScDocShell* pDocShell = getDocShellFromRange( xRange ); - if ( !pDocShell ) - throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access underlying docshell from uno range object" ) ), uno::Reference< uno::XInterface >() ); - ScDocument* pDoc = pDocShell->GetDocument(); - return pDoc; -} - - ScDocument* ScVbaRange::getScDocument() throw (uno::RuntimeException) { @@ -419,9 +390,9 @@ ScVbaRange::getScDocument() throw (uno::RuntimeException) { uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW ); uno::Reference< table::XCellRange > xRange( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW ); - return getDocumentFromRange( xRange ); + return excel::GetDocumentFromRange( xRange ); } - return getDocumentFromRange( mxRange ); + return excel::GetDocumentFromRange( mxRange ); } ScDocShell* @@ -431,9 +402,9 @@ ScVbaRange::getScDocShell() throw (uno::RuntimeException) { uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW ); uno::Reference< table::XCellRange > xRange( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW ); - return getDocShellFromRange( xRange ); + return excel::GetDocShellFromRange( xRange ); } - return getDocShellFromRange( mxRange ); + return excel::GetDocShellFromRange( mxRange ); } /*static*/ ScVbaRange* ScVbaRange::getImplementation( const uno::Reference< excel::XRange >& rxRange ) @@ -479,7 +450,7 @@ class NumFormatHelper public: NumFormatHelper( const uno::Reference< table::XCellRange >& xRange ) { - mxSupplier.set( getModelFromRange( xRange ), uno::UNO_QUERY_THROW ); + mxSupplier.set( excel::GetModelFromRange( xRange ), uno::UNO_QUERY_THROW ); mxRangeProps.set( xRange, uno::UNO_QUERY_THROW); mxFormats = mxSupplier->getNumberFormats(); } @@ -744,7 +715,15 @@ CellValueSetter::processValue( const uno::Any& aValue, const uno::Reference< tab { double nDouble = 0.0; if ( aValue >>= nDouble ) + { xCell->setValue( nDouble ); + uno::Reference< table::XCellRange > xRange( xCell, uno::UNO_QUERY_THROW ); + NumFormatHelper cellNumFormat( xRange ); + if ( cellNumFormat.isBooleanType() ) + { + cellNumFormat.setNumberFormat( util::NumberFormat::NUMBER ); + } + } else isExtracted = false; break; @@ -838,9 +817,10 @@ protected: double aDblValue = 0.0; if ( aValue >>= sFormula ) { - // convert to CONV_OOO style formula string because XCell::setFormula - // always compile it in CONV_OOO style. Perhaps css.sheet.FormulaParser - // should be used in future to directly pass formula tokens. + // convert to GRAM_PODF_A1 style grammar because XCell::setFormula + // always compile it in that grammar. Perhaps + // css.sheet.FormulaParser should be used in future to directly + // pass formula tokens when that API stabilizes. if ( m_eGrammar != formula::FormulaGrammar::GRAM_PODF_A1 && ( sFormula.trim().indexOf('=') == 0 ) ) { uno::Reference< uno::XInterface > xIf( xCell, uno::UNO_QUERY_THROW ); @@ -1101,7 +1081,7 @@ public: }; bool -getCellRangesForAddress( USHORT& rResFlags, const rtl::OUString& sAddress, ScDocShell* pDocSh, ScRangeList& rCellRanges, formula::FormulaGrammar::AddressConvention& eConv ) +getCellRangesForAddress( USHORT& rResFlags, const rtl::OUString& sAddress, ScDocShell* pDocSh, ScRangeList& rCellRanges, formula::FormulaGrammar::AddressConvention& eConv, char cDelimiter = 0 ) { ScDocument* pDoc = NULL; @@ -1111,7 +1091,7 @@ getCellRangesForAddress( USHORT& rResFlags, const rtl::OUString& sAddress, ScDoc String aString(sAddress); USHORT nMask = SCA_VALID; //USHORT nParse = rCellRanges.Parse( sAddress, pDoc, nMask, formula::FormulaGrammar::CONV_XL_A1 ); - rResFlags = rCellRanges.Parse( sAddress, pDoc, nMask, eConv, 0 ); + rResFlags = rCellRanges.Parse( sAddress, pDoc, nMask, eConv, cDelimiter ); if ( rResFlags & SCA_VALID ) { return true; @@ -1146,6 +1126,25 @@ bool getScRangeListForAddress( const rtl::OUString& sName, ScDocShell* pDocSh, S formula::FormulaGrammar::AddressConvention eConv = aConv; // spaces are illegal ( but the user of course can enter them ) rtl::OUString sAddress = (*it).trim(); + // if a local name ( on the active sheet ) exists this will + // take precedence over a global with the same name + if ( !xNameAccess->hasByName( sAddress ) && pDocSh ) + { + // try a local name + ScDocument* pDoc = pDocSh->GetDocument(); + SCTAB nCurTab = pDocSh->GetCurTab(); + if ( pDoc ) + { + NameToNameMap* pMap = pDoc->GetLocalNameMap( nCurTab ); + if ( pMap ) + { + NameToNameMap::iterator itTmp = pMap->find( sAddress ); + if ( itTmp != pMap->end() ) // found a mapping + sAddress = itTmp->second; + } + } + } + char aChar = 0; if ( xNameAccess->hasByName( sAddress ) ) { uno::Reference< sheet::XNamedRange > xNamed( xNameAccess->getByName( sAddress ), uno::UNO_QUERY_THROW ); @@ -1153,10 +1152,11 @@ bool getScRangeListForAddress( const rtl::OUString& sName, ScDocShell* pDocSh, S // As the address comes from OOO, the addressing // style is may not be XL_A1 eConv = pDocSh->GetDocument()->GetAddressConvention(); + aChar = ';'; } USHORT nFlags = 0; - if ( !getCellRangesForAddress( nFlags, sAddress, pDocSh, aCellRanges, eConv ) ) + if ( !getCellRangesForAddress( nFlags, sAddress, pDocSh, aCellRanges, eConv, aChar ) ) return false; bool bTabFromReferrer = !( nFlags & SCA_TAB_3D ); @@ -1250,7 +1250,7 @@ uno::Reference< sheet::XSheetCellRangeContainer > lclExpandToMerged( const uno:: ScUnoConversion::FillScRange( aScRange, aRangeAddr ); aScRanges.Append( aScRange ); } - return new ScCellRangesObj( getDocShellFromRanges( rxCellRanges ), aScRanges ); + return new ScCellRangesObj( excel::GetDocShellFromRanges( rxCellRanges ), aScRanges ); } void lclExpandAndMerge( const uno::Reference< table::XCellRange >& rxCellRange, bool bMerge ) throw (uno::RuntimeException) @@ -1296,7 +1296,7 @@ util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxC of a merged range is part of this range are not covered. */ ScRange aScRange; ScUnoConversion::FillScRange( aScRange, aRangeAddr ); - bool bHasMerged = getDocumentFromRange( rxCellRange )->HasAttrib( aScRange, HASATTR_MERGED | HASATTR_OVERLAPPED ); + bool bHasMerged = excel::GetDocumentFromRange( rxCellRange )->HasAttrib( aScRange, HASATTR_MERGED | HASATTR_OVERLAPPED ); return bHasMerged ? util::TriState_INDETERMINATE : util::TriState_NO; } @@ -1313,6 +1313,28 @@ ScVbaRange::getRangeObjectForName( return getRangeForName( xContext, sRangeName, pDocSh, refAddr, eConv ); } +table::CellAddress ScVbaRange::getLeftUpperCellAddress() +{ + table::CellAddress aCellAddress; + uno::Reference< table::XCellRange > xCellRange = mxRange; + if ( mxRanges.is() && m_Areas.is() && m_Areas->getCount() > 1 ) + { + uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY ); + if ( xIndex.is() && xIndex->getCount() > 0 ) + { + xCellRange.set( xIndex->getByIndex( 0 ), uno::UNO_QUERY ); + } + } + if ( xCellRange.is() ) + { + uno::Reference< sheet::XCellAddressable > xCellAddr( xCellRange->getCellByPosition( 0, 0 ), uno::UNO_QUERY ); + if ( xCellAddr.is() ) + { + aCellAddress = xCellAddr->getCellAddress(); + } + } + return aCellAddress; +} table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam, ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention aConv = formula::FormulaGrammar::CONV_XL_A1) throw ( uno::RuntimeException ) { @@ -1340,7 +1362,14 @@ table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam, uno::Reference< excel::XRange > xRange; aParam >>= xRange; if ( xRange.is() ) + { + ScVbaRange* pRange = dynamic_cast< ScVbaRange* >( xRange.get() ); + if ( pRange && pDocSh && pRange->getScDocument() != pDocSh->GetDocument() ) + { + throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Invalid range" ) ), uno::Reference< uno::XInterface >() ); + } xRange->getCellRange() >>= xRangeParam; + } break; } default: @@ -1353,7 +1382,7 @@ uno::Reference< XCollection > lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno::Reference<uno::XComponentContext>& xContext, const uno::Reference< table::XCellRange >& xRange ) throw( uno::RuntimeException ) { uno::Reference< XHelperInterface > xParent( xParentRange, uno::UNO_QUERY_THROW ); - ScDocument* pDoc = getDocumentFromRange(xRange); + ScDocument* pDoc = excel::GetDocumentFromRange(xRange); if ( !pDoc ) throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access document from shell" ) ), uno::Reference< uno::XInterface >() ); ScVbaPalette aPalette( pDoc->GetDocumentShell() ); @@ -1361,8 +1390,21 @@ lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno return borders; } +void lcl_NotifyRangeChanges( const uno::Reference< frame::XModel >& xModel, ScCellRangesBase* pUnoRangesBase ) +{ + if ( xModel.is() && pUnoRangesBase ) + { + ScModelObj* pModelObj = ScModelObj::getImplementation( xModel ); + const ScRangeList& aCellRanges = pUnoRangesBase->GetRangeList(); + if ( pModelObj && pModelObj->HasChangesListeners() ) + { + pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aCellRanges ); + } + } +} + ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args, - uno::Reference< uno::XComponentContext> const & xContext ) throw ( lang::IllegalArgumentException ) : ScVbaRange_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext, getXSomethingFromArgs< beans::XPropertySet >( args, 1, false ), getModelFromXIf( getXSomethingFromArgs< uno::XInterface >( args, 1 ) ), true ), mbIsRows( sal_False ), mbIsColumns( sal_False ) + uno::Reference< uno::XComponentContext> const & xContext ) throw ( lang::IllegalArgumentException ) : ScVbaRange_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext, getXSomethingFromArgs< beans::XPropertySet >( args, 1, false ), excel::GetModelFromRange( getXSomethingFromArgs< uno::XInterface >( args, 1 ) ), true ), mbIsRows( sal_False ), mbIsColumns( sal_False ) { mxRange.set( mxPropertySet, uno::UNO_QUERY ); mxRanges.set( mxPropertySet, uno::UNO_QUERY ); @@ -1379,7 +1421,7 @@ ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args, } ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, sal_Bool bIsRows, sal_Bool bIsColumns ) throw( lang::IllegalArgumentException ) -: ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRange, uno::UNO_QUERY_THROW ), getModelFromRange( xRange), true ), mxRange( xRange ), +: ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRange, uno::UNO_QUERY_THROW ), excel::GetModelFromRange( xRange), true ), mxRange( xRange ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) { @@ -1394,7 +1436,7 @@ ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const } ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges, sal_Bool bIsRows, sal_Bool bIsColumns ) throw ( lang::IllegalArgumentException ) -: ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRanges, uno::UNO_QUERY_THROW ), getModelFromXIf( uno::Reference< uno::XInterface >( xRanges, uno::UNO_QUERY_THROW ) ), true ), mxRanges( xRanges ),mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) +: ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRanges, uno::UNO_QUERY_THROW ), excel::GetModelFromRange( uno::Reference< uno::XInterface >( xRanges, uno::UNO_QUERY_THROW ) ), true ), mxRanges( xRanges ),mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) { uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW ); @@ -1433,7 +1475,53 @@ ScVbaRange::visitArray( ArrayVisitor& visitor ) } } +uno::Any SAL_CALL ScVbaRange::getName() throw (uno::RuntimeException) +{ + uno::Reference< excel::XName > xName; + ScDocShell* pDocShell = getScDocShell(); + uno::Reference< frame::XModel > xModel = pDocShell ? pDocShell->GetModel() : NULL; + if ( !xModel.is() ) + { + throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid document" ), uno::Reference< uno::XInterface >() ); + } + uno::Reference< beans::XPropertySet > xPropertySet( xModel, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XNamedRanges > xNamedRanges( xPropertySet->getPropertyValue( rtl::OUString::createFromAscii("NamedRanges")) , uno::UNO_QUERY_THROW ); + + uno::Reference< excel::XNames > xNames( new ScVbaNames( uno::Reference< XHelperInterface >(), mxContext , xNamedRanges , xModel ) ); + sal_Int32 nCount = xNames->getCount(); + ScCellRangesBase* pUnoRangesBase = getCellRangesBase(); + if ( pUnoRangesBase && nCount > 0 ) + { + ScRangeList aRangeList = pUnoRangesBase->GetRangeList(); + for ( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) + { + uno::Reference< excel::XName > xTmpName( xNames->Item( uno::makeAny( nIndex + 1 ), uno::Any() ), uno::UNO_QUERY ); + if ( xTmpName.is() ) + { + try + { + uno::Reference< excel::XRange > xRange = xTmpName->getRefersToRange(); + if ( xRange.is() ) + { + ScVbaRange* pRange = dynamic_cast< ScVbaRange* >( xRange.get() ); + ScCellRangesBase* pCurRangesBase = pRange ? pRange->getCellRangesBase() : NULL; + if ( pCurRangesBase && aRangeList == pCurRangesBase->GetRangeList() ) + { + xName = xTmpName; + break; + } + } + } + catch (const uno::Exception&) + { + } + } + } + } + + return uno::makeAny( xName ); +} uno::Any ScVbaRange::getValue( ValueGetter& valueGetter) throw (uno::RuntimeException) @@ -1523,6 +1611,9 @@ ScVbaRange::setValue( const uno::Any &aValue ) throw (uno::RuntimeException) } CellValueSetter valueSetter( aValue ); setValue( aValue, valueSetter ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } void @@ -1531,6 +1622,9 @@ ScVbaRange::Clear() throw (uno::RuntimeException) using namespace ::com::sun::star::sheet::CellFlags; sal_Int32 nFlags = VALUE | DATETIME | STRING | FORMULA | HARDATTR | EDITATTR | FORMATTED; ClearContents( nFlags ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } //helper ClearContent @@ -1571,6 +1665,9 @@ ScVbaRange::ClearContents() throw (uno::RuntimeException) sheet::CellFlags::STRING | sheet::CellFlags::DATETIME | sheet::CellFlags::FORMULA ); ClearContents( nClearFlags ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } void @@ -1579,6 +1676,9 @@ ScVbaRange::ClearFormats() throw (uno::RuntimeException) //FIXME: need to check if we need to combine sheet::CellFlags::FORMATTED sal_Int32 nClearFlags = sheet::CellFlags::HARDATTR | sheet::CellFlags::FORMATTED | sheet::CellFlags::EDITATTR; ClearContents( nClearFlags ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } void @@ -1594,6 +1694,9 @@ ScVbaRange::setFormulaValue( const uno::Any& rFormula, formula::FormulaGrammar:: } CellFormulaValueSetter formulaValueSetter( rFormula, getScDocument(), eGram ); setValue( rFormula, formulaValueSetter ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } uno::Any @@ -1753,6 +1856,9 @@ ScVbaRange::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFi uno::Reference< sheet::XCellSeries > xCellSeries(mxRange, uno::UNO_QUERY_THROW ); xCellSeries->fillSeries( nFillDirection, nFillMode, nFillDateMode, fStep, fEndValue ); + + // Fires the range change event. + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), getCellRangesBase() ); } void @@ -1892,7 +1998,16 @@ ScVbaRange::getFormulaArray() throw (uno::RuntimeException) uno::Reference< sheet::XCellRangeFormula> xCellRangeFormula( mxRange, uno::UNO_QUERY_THROW ); uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); uno::Any aMatrix; - aMatrix = xConverter->convertTo( uno::makeAny( xCellRangeFormula->getFormulaArray() ) , getCppuType((uno::Sequence< uno::Sequence< uno::Any > >*)0) ) ; + + //VBA, minz@cn.ibm.com + uno::Sequence< uno::Sequence<rtl::OUString> > aFmArray = xCellRangeFormula->getFormulaArray(); + if( aFmArray.getLength() ) + { + if( aFmArray.getLength() == 1 && aFmArray[0].getLength() == 1 ) + aMatrix <<= aFmArray[0][0]; + else + aMatrix = xConverter->convertTo( uno::makeAny( xCellRangeFormula->getFormulaArray() ) , getCppuType((uno::Sequence< uno::Sequence< uno::Any > >*)0) ) ; + } return aMatrix; } @@ -2063,29 +2178,65 @@ ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) thr // set in the Any, we should convert as appropriate // #FIXME - perhaps worth turning this into some sort of // convertion routine e.g. bSuccess = getValueFromAny( nRow, nRowIndex, getCppuType((sal_Int32*)0) ) - if ( nRowIndex.hasValue() && !( nRowIndex >>= nRow ) ) + uno::Any aRowIndexAny = nRowIndex; + if ( aRowIndexAny.getValueTypeClass() == uno::TypeClass_INTERFACE ) { - uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); - uno::Any aConverted; try { - aConverted = xConverter->convertTo( nRowIndex, getCppuType((sal_Int32*)0) ); - bIsIndex = ( aConverted >>= nRow ); + aRowIndexAny = getDefaultPropByIntrospection( aRowIndexAny ); } - catch( uno::Exception& ) {} // silence any errors + catch( uno::Exception& ) {} } - if ( bIsColumnIndex && !( nColumnIndex >>= nColumn ) ) + else if ( aRowIndexAny.hasValue() && !( aRowIndexAny >>= nRow ) ) { uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); uno::Any aConverted; try { - aConverted = xConverter->convertTo( nColumnIndex, getCppuType((sal_Int32*)0) ); - bIsColumnIndex = ( aConverted >>= nColumn ); + aConverted = xConverter->convertTo( aRowIndexAny, getCppuType((sal_Int32*)0) ); + bIsIndex = ( aConverted >>= nRow ); } catch( uno::Exception& ) {} // silence any errors } + uno::Any aColumnAny = nColumnIndex; + + if ( bIsColumnIndex ) + { + // Column index can be a col address e.g Cells( 1, "B" ) etc. + rtl::OUString sCol; + if ( nColumnIndex >>= sCol ) + { + ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 ); + ScRange tmpRange; + USHORT flags = tmpRange.ParseCols( sCol, excel::GetDocumentFromRange( mxRange ), dDetails ); + if ( ( flags & 0x200 ) != 0x200 ) + throw uno::RuntimeException(); + nColumn = tmpRange.aStart.Col() + 1; + } + else + { + if ( aColumnAny.getValueTypeClass() == uno::TypeClass_INTERFACE ) + { + try + { + aColumnAny = getDefaultPropByIntrospection( aColumnAny ); + } + catch( uno::Exception& ) {} + } + if ( !( aColumnAny >>= nColumn ) ) + { + uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); + uno::Any aConverted; + try + { + aConverted = xConverter->convertTo( aColumnAny, getCppuType((sal_Int32*)0) ); + bIsColumnIndex = ( aConverted >>= nColumn ); + } + catch( uno::Exception& ) {} // silence any errors + } + } + } RangeHelper thisRange( mxRange ); table::CellRangeAddress thisRangeAddress = thisRange.getCellRangeAddressable()->getRangeAddress(); uno::Reference< table::XCellRange > xSheetRange = thisRange.getCellRangeFromSheet(); @@ -2247,7 +2398,7 @@ ScVbaRange::Rows(const uno::Any& aIndex ) throw (uno::RuntimeException) { ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 ); ScRange tmpRange; - tmpRange.ParseRows( sAddress, getDocumentFromRange( mxRange ), dDetails ); + tmpRange.ParseRows( sAddress, excel::GetDocumentFromRange( mxRange ), dDetails ); nStartRow = tmpRange.aStart.Row(); nEndRow = tmpRange.aEnd.Row(); @@ -2294,7 +2445,7 @@ ScVbaRange::Columns(const uno::Any& aIndex ) throw (uno::RuntimeException) { ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 ); ScRange tmpRange; - tmpRange.ParseCols( sAddress, getDocumentFromRange( mxRange ), dDetails ); + tmpRange.ParseCols( sAddress, excel::GetDocumentFromRange( mxRange ), dDetails ); nStartCol = tmpRange.aStart.Col(); nEndCol = tmpRange.aEnd.Col(); @@ -2397,9 +2548,11 @@ ScVbaRange::Copy(const ::uno::Any& Destination) throw (uno::RuntimeException) } else { - uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange ); - Select(); - excel::implnCopy( xModel ); + ScRange aRange; + RangeHelper thisRange( mxRange ); + ScUnoConversion::FillScRange( aRange, thisRange.getCellRangeAddressable()->getRangeAddress() ); + uno::Reference< frame::XModel > xModel = excel::GetModelFromRange( mxRange ); + excel::implnCopyRange( xModel, aRange ); } } @@ -2421,8 +2574,9 @@ ScVbaRange::Cut(const ::uno::Any& Destination) throw (uno::RuntimeException) uno::Reference< sheet::XCellRangeAddressable > xSource( mxRange, uno::UNO_QUERY); xMover->moveRange( xDestination->getCellAddress(), xSource->getRangeAddress() ); } - { - uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange ); + //VBA, minz@cn.ibm.com. + else { + uno::Reference< frame::XModel > xModel = excel::GetModelFromRange( mxRange ); Select(); excel::implnCut( xModel ); } @@ -2742,8 +2896,6 @@ ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, cons uno::Reference< frame::XModel > xModel( ( pShell ? pShell->GetModel() : NULL ), uno::UNO_QUERY_THROW ); uno::Reference< view::XSelectionSupplier > xSelection( xModel->getCurrentController(), uno::UNO_QUERY_THROW ); - // save old selection - uno::Reference< uno::XInterface > xSel( xModel->getCurrentSelection() ); // select this range xSelection->select( uno::makeAny( mxRange ) ); // set up defaults @@ -2764,8 +2916,6 @@ ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, cons USHORT nFlags = getPasteFlags(nPaste); USHORT nFormulaBits = getPasteFormulaBits(nOperation); excel::implnPasteSpecial(pShell->GetModel(), nFlags,nFormulaBits,bSkipBlanks,bTranspose); - // restore selection - xSelection->select( uno::makeAny( xSel ) ); } uno::Reference< excel::XRange > @@ -2986,7 +3136,16 @@ ScVbaRange::Replace( const ::rtl::OUString& What, const ::rtl::OUString& Replace // OOo.org afaik uno::Reference< util::XSearchDescriptor > xSearch( xDescriptor, uno::UNO_QUERY ); + // Find all cells that being replaced, used to fire the range changed event. + uno::Reference< container::XIndexAccess > xIndexAccess = xReplace->findAll( xSearch ); xReplace->replaceAll( xSearch ); + + if ( xIndexAccess.is() && xIndexAccess->getCount() > 0 ) + { + // Fires the range change event. + ScCellRangesBase* pScCellRangesBase = ScCellRangesBase::getImplementation( xIndexAccess ); //liuchen 2010-01-05 + lcl_NotifyRangeChanges( getScDocShell()->GetModel(), pScCellRangesBase ); //liuchen 2010-01-05 the original convert method will fail in SUSE + } } return sal_True; // always } @@ -3137,6 +3296,13 @@ ScVbaRange::Find( const uno::Any& What, const uno::Any& After, const uno::Any& L uno::Reference< uno::XInterface > xInterface = xStartCell.is() ? xSearch->findNext( xStartCell, xDescriptor) : xSearch->findFirst( xDescriptor ); uno::Reference< table::XCellRange > xCellRange( xInterface, uno::UNO_QUERY ); + // if we are searching from a starting cell and failed to find a match + // then try from the begining + if ( !xCellRange.is() && xStartCell.is() ) + { + xInterface = xSearch->findFirst( xDescriptor ); + xCellRange.set( xInterface, uno::UNO_QUERY ); + } if ( xCellRange.is() ) { uno::Reference< excel::XRange > xResultRange = new ScVbaRange( mxParent, mxContext, xCellRange ); @@ -3430,76 +3596,45 @@ ScVbaRange::End( ::sal_Int32 Direction ) throw (uno::RuntimeException) return xRange->End( Direction ); } + table::CellAddress aAddress = getLeftUpperCellAddress(); + SCTAB nTab = aAddress.Sheet; + SCCOL nCurX = aAddress.Column; + SCROW nCurY = aAddress.Row; + SCCOL nNewX = nCurX; + SCROW nNewY = nCurY; - // #FIXME #TODO - // euch! found my orig implementation sucked, so - // trying this even suckier one ( really need to use/expose code in - // around ScTabView::MoveCursorArea(), thats the bit that calcutes - // where the cursor should go ) - // Main problem with this method is the ultra hacky attempt to preserve - // the ActiveCell, there should be no need to go to these extreems - - // Save ActiveCell pos ( to restore later ) - uno::Any aDft; - uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW ); - rtl::OUString sActiveCell = xApplication->getActiveCell()->Address(aDft, aDft, aDft, aDft, aDft ); - - // position current cell upper left of this range - Cells( uno::makeAny( (sal_Int32) 1 ), uno::makeAny( (sal_Int32) 1 ) )->Select(); + ScDocShell* pDocShell = getScDocShell(); + ScDocument* pDoc = pDocShell->GetDocument(); - uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange ); + SCsCOL nMoveX = 0; + SCsROW nMoveY = 0; + switch ( Direction ) + { + case excel::XlDirection::xlDown: + nMoveY = 1; + break; + case excel::XlDirection::xlUp: + nMoveY = -1; + break; + case excel::XlDirection::xlToLeft: + nMoveX = -1; + break; + case excel::XlDirection::xlToRight: + nMoveX = 1; + break; + default: + throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Invalid Direction" ) ), uno::Reference< uno::XInterface >() ); + } - SfxViewFrame* pViewFrame = excel::getViewFrame( xModel ); - if ( pViewFrame ) + if ( pDoc ) { - SfxAllItemSet aArgs( SFX_APP()->GetPool() ); - // Hoping this will make sure this slot is called - // synchronously - SfxBoolItem sfxAsync( SID_ASYNCHRON, sal_False ); - aArgs.Put( sfxAsync, sfxAsync.Which() ); - SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher(); - - USHORT nSID = 0; - - switch( Direction ) - { - case excel::XlDirection::xlDown: - nSID = SID_CURSORBLKDOWN; - break; - case excel::XlDirection::xlUp: - nSID = SID_CURSORBLKUP; - break; - case excel::XlDirection::xlToLeft: - nSID = SID_CURSORBLKLEFT; - break; - case excel::XlDirection::xlToRight: - nSID = SID_CURSORBLKRIGHT; - break; - default: - throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ": Invalid ColumnIndex" ) ), uno::Reference< uno::XInterface >() ); - } - if ( pDispatcher ) - { - pDispatcher->Execute( nSID, (SfxCallMode)SFX_CALLMODE_SYNCHRON, aArgs ); - } + pDoc->FindAreaPos( nNewX, nNewY, nTab, nMoveX, nMoveY ); } - // result is the ActiveCell - rtl::OUString sMoved = xApplication->getActiveCell()->Address(aDft, aDft, aDft, aDft, aDft ); - - // restore old ActiveCell - uno::Any aVoid; - - uno::Reference< excel::XRange > xOldActiveCell( xApplication->getActiveSheet()->Range( uno::makeAny( sActiveCell ), aVoid ), uno::UNO_QUERY_THROW ); - xOldActiveCell->Select(); - - uno::Reference< excel::XRange > resultCell; - - resultCell.set( xApplication->getActiveSheet()->Range( uno::makeAny( sMoved ), aVoid ), uno::UNO_QUERY_THROW ); - - // return result - - return resultCell; + ScRange aNewRange( (SCCOL)nNewX, (SCROW)nNewY, nTab, (SCCOL)nNewX, (SCROW)nNewY, nTab ); + uno::Reference< table::XCellRange > xCellRange( new ScCellRangeObj( getScDocShell(), aNewRange ) ); + uno::Reference< excel::XRange > xResultRange = new ScVbaRange( mxParent, mxContext, xCellRange ); + return xResultRange; } bool @@ -3517,7 +3652,7 @@ ScVbaRange::characters( const uno::Any& Start, const uno::Any& Length ) throw (u if ( !isSingleCellRange() ) throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Can't create Characters property for multicell range ") ), uno::Reference< uno::XInterface >() ); uno::Reference< text::XSimpleText > xSimple(mxRange->getCellByPosition(0,0) , uno::UNO_QUERY_THROW ); - ScDocument* pDoc = getDocumentFromRange(mxRange); + ScDocument* pDoc = excel::GetDocumentFromRange(mxRange); if ( !pDoc ) throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access document from shell" ) ), uno::Reference< uno::XInterface >() ); @@ -3634,7 +3769,7 @@ ScVbaRange::getCalcColWidth( const table::CellRangeAddress& rAddress) throw (uno double ScVbaRange::getCalcRowHeight( const table::CellRangeAddress& rAddress ) throw (uno::RuntimeException) { - ScDocument* pDoc = getDocumentFromRange( mxRange ); + ScDocument* pDoc = excel::GetDocumentFromRange( mxRange ); USHORT nWidth = pDoc->GetOriginalHeight( rAddress.StartRow, rAddress.Sheet ); double nPoints = lcl_TwipsToPoints( nWidth ); nPoints = lcl_Round2DecPlaces( nPoints ); @@ -3896,7 +4031,7 @@ ScVbaRange::setRowHeight( const uno::Any& _rowheight) throw (uno::RuntimeExcepti table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress(); USHORT nTwips = lcl_pointsToTwips( nHeight ); - ScDocShell* pDocShell = getDocShellFromRange( mxRange ); + ScDocShell* pDocShell = excel::GetDocShellFromRange( mxRange ); ScDocFunc aFunc(*pDocShell); SCCOLROW nRowArr[2]; nRowArr[0] = thisAddress.StartRow; @@ -3909,7 +4044,7 @@ uno::Any SAL_CALL ScVbaRange::getPageBreak() throw (uno::RuntimeException) { sal_Int32 nPageBreak = excel::XlPageBreak::xlPageBreakNone; - ScDocShell* pShell = getDocShellFromRange( mxRange ); + ScDocShell* pShell = excel::GetDocShellFromRange( mxRange ); if ( pShell ) { RangeHelper thisRange( mxRange ); @@ -3922,7 +4057,7 @@ ScVbaRange::getPageBreak() throw (uno::RuntimeException) uno::Reference< frame::XModel > xModel = pShell->GetModel(); if ( xModel.is() ) { - ScDocument* pDoc = getDocumentFromRange( mxRange ); + ScDocument* pDoc = excel::GetDocumentFromRange( mxRange ); ScBreakType nBreak = BREAK_NONE; if ( !bColumn ) @@ -3947,7 +4082,7 @@ ScVbaRange::setPageBreak( const uno::Any& _pagebreak) throw (uno::RuntimeExcepti sal_Int32 nPageBreak = 0; _pagebreak >>= nPageBreak; - ScDocShell* pShell = getDocShellFromRange( mxRange ); + ScDocShell* pShell = excel::GetDocShellFromRange( mxRange ); if ( pShell ) { RangeHelper thisRange( mxRange ); @@ -4041,7 +4176,7 @@ ScVbaRange::getWorksheet() throw (uno::RuntimeException) uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW ); xRange.set( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW ); } - ScDocShell* pDocShell = getDocShellFromRange(xRange); + ScDocShell* pDocShell = excel::GetDocShellFromRange(xRange); RangeHelper rHelper(xRange); // parent should be Thisworkbook xSheet.set( new ScVbaWorksheet( uno::Reference< XHelperInterface >(), mxContext,rHelper.getSpreadSheet(),pDocShell->GetModel()) ); @@ -4096,63 +4231,44 @@ ScVbaRange::ApplicationRange( const uno::Reference< uno::XComponentContext >& xC } } } - uno::Reference< sheet::XSpreadsheetView > xView( getCurrentExcelDoc(xContext)->getCurrentController(), uno::UNO_QUERY ); - uno::Reference< table::XCellRange > xSheetRange( xView->getActiveSheet(), uno::UNO_QUERY_THROW ); - ScVbaRange* pRange = new ScVbaRange( excel::getUnoSheetModuleObj( xSheetRange ), xContext, xSheetRange ); - uno::Reference< excel::XRange > xVbSheetRange( pRange ); - return pRange->Range( Cell1, Cell2, true ); -} -uno::Reference< sheet::XDatabaseRanges > -lcl_GetDataBaseRanges( ScDocShell* pShell ) throw ( uno::RuntimeException ) -{ - uno::Reference< frame::XModel > xModel; - if ( pShell ) - xModel.set( pShell->GetModel(), uno::UNO_QUERY_THROW ); - uno::Reference< beans::XPropertySet > xModelProps( xModel, uno::UNO_QUERY_THROW ); - uno::Reference< sheet::XDatabaseRanges > xDBRanges( xModelProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DatabaseRanges") ) ), uno::UNO_QUERY_THROW ); - return xDBRanges; -} -// returns the XDatabaseRange for the autofilter on sheet (nSheet) -// also populates sName with the name of range -uno::Reference< sheet::XDatabaseRange > -lcl_GetAutoFiltRange( ScDocShell* pShell, sal_Int16 nSheet, rtl::OUString& sName ) -{ - uno::Reference< container::XIndexAccess > xIndexAccess( lcl_GetDataBaseRanges( pShell ), uno::UNO_QUERY_THROW ); - uno::Reference< sheet::XDatabaseRange > xDataBaseRange; - table::CellRangeAddress dbAddress; - for ( sal_Int32 index=0; index < xIndexAccess->getCount(); ++index ) - { - uno::Reference< sheet::XDatabaseRange > xDBRange( xIndexAccess->getByIndex( index ), uno::UNO_QUERY_THROW ); - uno::Reference< container::XNamed > xNamed( xDBRange, uno::UNO_QUERY_THROW ); - // autofilters work weirdly with openoffice, unnamed is the default - // named range which is used to create an autofilter, but - // its also possible that another name could be used - // this also causes problems when an autofilter is created on - // another sheet - // ( but.. you can use any named range ) - dbAddress = xDBRange->getDataArea(); - if ( dbAddress.Sheet == nSheet ) - { - sal_Bool bHasAuto = sal_False; - uno::Reference< beans::XPropertySet > xProps( xDBRange, uno::UNO_QUERY_THROW ); - xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("AutoFilter") ) ) >>= bHasAuto; - if ( bHasAuto ) - { - sName = xNamed->getName(); - xDataBaseRange=xDBRange; - break; - } + // Add these codes for supporting shortcut: Application.Range(Range1, Range2), Range1 or Range2 is not the range of current active sheet. + // If Range1 and Range2 are not in current active sheet, we should not use the active sheet, but use the sheet of Range1 and Range2. + // If Range1 and Range2 are not in the same sheet, we throw an exception. + uno::Reference< sheet::XSpreadsheet > xSpreadsheet; + uno::Reference< excel::XRange > xRange1( Cell1, uno::UNO_QUERY ), xRange2( Cell2, uno::UNO_QUERY ); + if ( xRange1.is() ) + { + RangeHelper thisRange( xRange1->getCellRange() ); + xSpreadsheet = thisRange.getSpreadSheet(); + } + else if ( xRange2.is() ) + { + RangeHelper thisRange( xRange2->getCellRange() ); + xSpreadsheet = thisRange.getSpreadSheet(); + } + if ( !xSpreadsheet.is() ) + { + uno::Reference< frame::XModel > xModel = getCurrentExcelDoc( xContext ); + if ( xModel.is() ) + { + uno::Reference< sheet::XSpreadsheetView > xView( xModel->getCurrentController(), uno::UNO_QUERY_THROW ); + xSpreadsheet = xView->getActiveSheet(); } } - return xDataBaseRange; + + uno::Reference< table::XCellRange > xSheetRange( xSpreadsheet, uno::UNO_QUERY_THROW ); + ScVbaRange* pRange = new ScVbaRange( excel::getUnoSheetModuleObj( xSheetRange ), xContext, xSheetRange ); + + uno::Reference< excel::XRange > xVbSheetRange( pRange ); + return pRange->Range( Cell1, Cell2, true ); } // Helper functions for AutoFilter ScDBData* lcl_GetDBData_Impl( ScDocShell* pDocShell, sal_Int16 nSheet ) { rtl::OUString sName; - lcl_GetAutoFiltRange( pDocShell, nSheet, sName ); + excel::GetAutoFiltRange( pDocShell, nSheet, sName ); OSL_TRACE("lcl_GetDBData_Impl got autofilter range %s for sheet %d", rtl::OUStringToOString( sName, RTL_TEXTENCODING_UTF8 ).getStr() , nSheet ); ScDBData* pRet = NULL; @@ -4319,7 +4435,7 @@ ScVbaRange::AutoFilter( const uno::Any& Field, const uno::Any& Criteria1, const ScDocShell* pShell = getScDocShell(); sal_Bool bHasAuto = sal_False; rtl::OUString sAutofiltRangeName; - uno::Reference< sheet::XDatabaseRange > xDataBaseRange = lcl_GetAutoFiltRange( pShell, nSheet, sAutofiltRangeName ); + uno::Reference< sheet::XDatabaseRange > xDataBaseRange = excel::GetAutoFiltRange( pShell, nSheet, sAutofiltRangeName ); if ( xDataBaseRange.is() ) bHasAuto = true; @@ -4352,7 +4468,7 @@ ScVbaRange::AutoFilter( const uno::Any& Field, const uno::Any& Criteria1, const autoFiltAddress = multiCellRange.getCellRangeAddressable()->getRangeAddress(); } - uno::Reference< sheet::XDatabaseRanges > xDBRanges = lcl_GetDataBaseRanges( pShell ); + uno::Reference< sheet::XDatabaseRanges > xDBRanges = excel::GetDataBaseRanges( pShell ); if ( xDBRanges.is() ) { rtl::OUString sGenName( RTL_CONSTASCII_USTRINGPARAM("VBA_Autofilter_") ); @@ -4405,8 +4521,21 @@ ScVbaRange::AutoFilter( const uno::Any& Field, const uno::Any& Criteria1, const // Use the normal uno api, sometimes e.g. when you want to use ALL as the filter // we can't use refresh as the uno interface doesn't have a concept of ALL // in this case we just call the core calc functionality - - bool bAll = false;; - if ( ( Field >>= nField ) ) + bool bAll = false; + uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); + bool bIsValidFieldValue = ( Field >>= nField ); + if ( !bIsValidFieldValue && xConverter.is() ) + { + try + { + uno::Any aConverted = xConverter->convertTo( Field, getCppuType( (sal_Int32*)0 ) ); + bIsValidFieldValue = ( aConverted >>= nField ); + } + catch( const uno::Exception& ex ) + { + } + } + if ( bIsValidFieldValue ) { uno::Reference< sheet::XSheetFilterDescriptor2 > xDesc( xDataBaseRange->getFilterDescriptor(), uno::UNO_QUERY ); @@ -4437,7 +4566,19 @@ ScVbaRange::AutoFilter( const uno::Any& Field, const uno::Any& Criteria1, const bAll = true; // not sure what the relationship between Criteria1 and Operator is, // e.g. can you have a Operator without a Criteria ? in openoffice it - if ( Operator.hasValue() && ( Operator >>= nOperator ) ) + bool bIsValidOpValue = ( Operator.hasValue() && ( Operator >>= nOperator ) ); + if ( Operator.hasValue() && !bIsValidOpValue && xConverter.is() ) + { + try + { + uno::Any aConverted = xConverter->convertTo( Operator, getCppuType( (sal_Int32*)0 ) ); + bIsValidOpValue = ( aConverted >>= nOperator ); + } + catch( const uno::Exception& ex ) + { + } + } + if ( bIsValidOpValue ) { // if its a bottom/top Ten(Percent/Value) and there // is no value specified for critera1 set it to 10 @@ -4585,7 +4726,7 @@ ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& CopyOrigin ) throw (u { // After the insert ( this range ) actually has moved ScRange aRange( static_cast< SCCOL >( thisAddress.StartColumn ), static_cast< SCROW >( thisAddress.StartRow ), static_cast< SCTAB >( thisAddress.Sheet ), static_cast< SCCOL >( thisAddress.EndColumn ), static_cast< SCROW >( thisAddress.EndRow ), static_cast< SCTAB >( thisAddress.Sheet ) ); - uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getDocShellFromRange( mxRange ) , aRange ) ); + uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( excel::GetDocShellFromRange( mxRange ) , aRange ) ); uno::Reference< excel::XRange > xVbaRange( new ScVbaRange( mxParent, mxContext, xRange, mbIsRows, mbIsColumns ) ); xVbaRange->PasteSpecial( uno::Any(), uno::Any(), uno::Any(), uno::Any() ); } @@ -4609,7 +4750,7 @@ ScVbaRange::Autofit() throw (uno::RuntimeException) if ( !( mbIsColumns || mbIsRows ) ) DebugHelper::exception(SbERR_METHOD_FAILED, rtl::OUString()); - ScDocShell* pDocShell = getDocShellFromRange( mxRange ); + ScDocShell* pDocShell = excel::GetDocShellFromRange( mxRange ); if ( pDocShell ) { RangeHelper thisRange( mxRange ); @@ -4641,8 +4782,8 @@ ScVbaRange::Autofit() throw (uno::RuntimeException) ***************************************************************************************/ void SAL_CALL ScVbaRange::TextToColumns( const css::uno::Any& Destination, const css::uno::Any& DataType, const css::uno::Any& TextQualifier, - const css::uno::Any& ConsecutinveDelimiter, const css::uno::Any& Tab, const css::uno::Any& Semicolon, const css::uno::Any& Comma, - const css::uno::Any& Space, const css::uno::Any& Other, const css::uno::Any& OtherChar, const css::uno::Any& /*FieldInfo*/, + const css::uno::Any& ConsecutiveDelimiter, const css::uno::Any& Tab, const css::uno::Any& Semicolon, const css::uno::Any& Comma, + const css::uno::Any& Space, const css::uno::Any& Other, const css::uno::Any& OtherChar, const css::uno::Any& FieldInfo, const css::uno::Any& DecimalSeparator, const css::uno::Any& ThousandsSeparator, const css::uno::Any& /*TrailingMinusNumbers*/ ) throw (css::uno::RuntimeException) { uno::Reference< excel::XRange > xRange; @@ -4679,13 +4820,13 @@ ScVbaRange::TextToColumns( const css::uno::Any& Destination, const css::uno::Any OSL_TRACE("set TextQualifier\n"); } - sal_Bool bConsecutinveDelimiter = sal_False; - if( ConsecutinveDelimiter.hasValue() ) + sal_Bool bConsecutiveDelimiter = sal_False; + if( ConsecutiveDelimiter.hasValue() ) { - if( !( ConsecutinveDelimiter >>= bConsecutinveDelimiter ) ) - throw uno::RuntimeException( rtl::OUString::createFromAscii( "ConsecutinveDelimiter parameter should be a boolean" ), + if( !( ConsecutiveDelimiter >>= bConsecutiveDelimiter ) ) + throw uno::RuntimeException( rtl::OUString::createFromAscii( "ConsecutiveDelimiter parameter should be a boolean" ), uno::Reference< uno::XInterface >() ); - OSL_TRACE("set ConsecutinveDelimiter\n"); + OSL_TRACE("set ConsecutiveDelimiter\n"); } sal_Bool bTab = sal_False; @@ -4737,7 +4878,13 @@ ScVbaRange::TextToColumns( const css::uno::Any& Destination, const css::uno::Any throw uno::RuntimeException( rtl::OUString::createFromAscii( "Other parameter should be a True" ), uno::Reference< uno::XInterface >() ); } - //TODO* FieldInfo Optional Variant. An array containing parse information for the individual columns of data. The interpretation depends on the value of DataType. When the data is delimited, this argument is an array of two-element arrays, with each two-element array specifying the conversion options for a particular column. The first element is the column number (1-based), and the second element is one of the xlColumnDataType constants specifying how the column is parsed. + // FieldInfo, Optional Variant. An array containing parse information for the individual columns of data. + // The interpretation depends on the value of DataType. When the data is delimited, this argument is an array + // of two-element arrays, with each two-element array specifying the conversion options for a particular column. + // The first element is the column number (1-based), and the second element is one of the xlColumnDataType + // constants specifying how the column is parsed. + uno::Sequence< uno::Sequence< uno::Any > > sFieldInfo; + FieldInfo >>= sFieldInfo; rtl::OUString sDecimalSeparator; if( DecimalSeparator.hasValue() ) @@ -4755,7 +4902,106 @@ ScVbaRange::TextToColumns( const css::uno::Any& Destination, const css::uno::Any uno::Reference< uno::XInterface >() ); OSL_TRACE("set ThousandsSpeparator\n" ); } - //TODO* TrailingMinusNumbers Optional Variant. Numbers that begin with a minus character. + //TODO* TrailingMinusNumbers Optional Variant. Numbers that begin with a minus character. + + // Get the destination range's left-upper cell address. + ScVbaRange* pDestVbaRange = dynamic_cast< ScVbaRange* >( xRange.get() ); + ScAddress aScDestAddress; + if ( pDestVbaRange ) + { + ScUnoConversion::FillScAddress( aScDestAddress, pDestVbaRange->getLeftUpperCellAddress() ); + } + + // Parse the value of parameter FieldInfo. + USHORT nCount = 0, nRealCount = 0; + xub_StrLen* pColumns = NULL; + BYTE* pFormats = NULL; + if ( sFieldInfo.getLength() > 0 ) + { + nCount = sFieldInfo.getLength(); + pColumns = new xub_StrLen[nCount]; + pFormats = new BYTE[nCount]; + USHORT nFormat = 1; + uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); + for ( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) + { + if ( sFieldInfo[nIndex].getLength() >= 2 ) + { + nFormat = 1; + try + { + uno::Any aConverted = xConverter->convertTo( sFieldInfo[nIndex][0], getCppuType((xub_StrLen*)0) ); + aConverted >>= pColumns[nRealCount]; + aConverted = xConverter->convertTo( sFieldInfo[nIndex][1], getCppuType((USHORT*)0) ); + aConverted >>= nFormat; + } + catch( const uno::Exception& ) + { + } + pFormats[nRealCount++] = nFormat; + } + } + } + + sal_Unicode cTextQualifier = '"'; + cTextQualifier = xlTextQualifier == excel::XlTextQualifier::xlTextQualifierNone ? '\0' : cTextQualifier; + cTextQualifier = xlTextQualifier == excel::XlTextQualifier::xlTextQualifierSingleQuote ? '\'' : cTextQualifier; + + // Get field delimiters. + String rFieldDelimiters; + if ( bTab ) rFieldDelimiters += '\t'; + if ( bSemicolon ) rFieldDelimiters += ';'; + if ( bComma ) rFieldDelimiters += ','; + if ( bSpace ) rFieldDelimiters += ' '; + if ( bOther ) rFieldDelimiters += *sOtherChar.getStr(); + + // Get the text in current range to SvMemoryStream. + ScRange aSrcScRange; + ScCellRangesBase* pSrcCellRangesBase = getCellRangesBase(); + if ( pSrcCellRangesBase ) + { + ScRangeList aRangeList = pSrcCellRangesBase->GetRangeList(); + if ( aRangeList.First() ) + { + aSrcScRange = *aRangeList.First(); + } + } + ScImportExport aExport( getScDocument(), aSrcScRange ); + aExport.SetDelimiter( static_cast< sal_Unicode >( 0 ) ); + SvMemoryStream aStream; + aStream.SetStreamCharSet( RTL_TEXTENCODING_UNICODE ); + ScImportExport::SetNoEndianSwap( aStream ); + aExport.ExportStream( aStream, String(), FORMAT_STRING ); + aStream.Seek( 0 ); + + // Set ScAsciiOptions according to the input parameters. + ScAsciiOptions aOptions; + aOptions.SetFixedLen( !bDilimited ); + aOptions.SetStartRow( 0 ); + aOptions.SetColInfo( nRealCount, pColumns, pFormats ); + if ( bDilimited ) + { + aOptions.SetFieldSeps( rFieldDelimiters ); + aOptions.SetMergeSeps( bConsecutiveDelimiter ); + aOptions.SetTextSep( cTextQualifier ); + } + + // Split the String in to columns. + if ( pDestVbaRange && pDestVbaRange->getScDocument() ) + { + ScImportExport aImport( pDestVbaRange->getScDocument(), aScDestAddress ); + aImport.SetExtOptions( aOptions ); + aImport.SetApi( false ); + aImport.ImportStream( aStream, String(), FORMAT_STRING ); + } + if ( pColumns ) + { + DELETEZ( pColumns ); + } + if ( pFormats ) + { + DELETEZ( pFormats ); + } } uno::Any SAL_CALL @@ -4900,7 +5146,7 @@ uno::Any ScVbaRange::getShowDetail() throw ( css::uno::RuntimeException) (thisAddress.StartColumn == thisAddress.EndColumn && thisAddress.EndColumn == aOutlineAddress.EndColumn )) { sal_Bool bColumn =thisAddress.StartRow == thisAddress.EndRow ? sal_False:sal_True; - ScDocument* pDoc = getDocumentFromRange( mxRange ); + ScDocument* pDoc = excel::GetDocumentFromRange( mxRange ); ScOutlineTable* pOutlineTable = pDoc->GetOutlineTable(static_cast<SCTAB>(thisAddress.Sheet), sal_True); const ScOutlineArray* pOutlineArray = bColumn ? pOutlineTable->GetColArray(): pOutlineTable->GetRowArray(); if( pOutlineArray ) @@ -4956,6 +5202,24 @@ void ScVbaRange::setShowDetail(const uno::Any& aShowDetail) throw ( css::uno::Ru } } +//09-09-16 add by limingl +::com::sun::star::uno::Reference< ::ooo::vba::excel::XQueryTable > SAL_CALL +ScVbaRange::getQueryTable() throw (::com::sun::star::uno::RuntimeException) +{ + /* + if (m_pQueryTable == NULL) + { + m_pQueryTable = new ScVbaQueryTable(mxParent ,mxContext, getScDocument(), this); //add by limingl + } + //*/ + if (!m_xQueryTable.is()) + { + m_xQueryTable = new ScVbaQueryTable(mxParent ,mxContext, getScDocument(), this); //add by limingl + } + + return m_xQueryTable; +} +//end add uno::Reference< excel::XRange > SAL_CALL ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeException) { @@ -4985,6 +5249,118 @@ ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeExceptio return new ScVbaRange( mxParent, mxContext, mxRange ); } +//2008-08-25 add by limingl +//The recordset's member: Recordset.Fields.Item will get a Field obj. +//Field.value is the column value. +::sal_Int32 SAL_CALL +ScVbaRange::CopyFromRecordset( const ::com::sun::star::uno::Any& Data, const ::com::sun::star::uno::Any& MaxRows, const ::com::sun::star::uno::Any& MaxColumns ) +throw (::com::sun::star::script::BasicErrorException, ::com::sun::star::uno::RuntimeException) +{ + uno::Sequence< uno::Any > aParams; + uno::Sequence< uno::Any > aFieldsParams(1); + uno::Sequence< sal_Int16 > aOutParamIndex; + uno::Sequence< uno::Any > aOutParam; + uno::Reference< uno::XInterface > xIntRes; + uno::Reference< uno::XInterface > xIntFields; + uno::Reference< uno::XInterface > xIntFld; + uno::Any aRet; + uno::Any aPar; + uno::Any aCrrCol; + uno::Any aCrrRow; + sal_Int16 nCrrCol = 0; + sal_Int32 nCrrRow = 0; + sal_Int32 nCol; + sal_Int32 nMaxRows = 0; + sal_Int32 nMaxColumns = 0; + sal_Bool bEof; +// sal_Bool bColName = sal_True; + long lColCnt = 0; + if (MaxColumns.hasValue()) + { + MaxColumns >>= nMaxColumns; + } + + long lMaxCol = nMaxColumns; + + if (MaxRows.hasValue()) + { + MaxRows >>= nMaxRows; + } + + + Data >>= xIntRes; + uno::Reference< script::XInvocation > xInvRes(xIntRes, uno::UNO_QUERY_THROW); + rtl::OUString oMoveNext = rtl::OUString::createFromAscii("MoveNext") ; + rtl::OUString oEof = rtl::OUString::createFromAscii("EOF") ; + rtl::OUString oFields = rtl::OUString::createFromAscii("Fields") ; + + if( !xInvRes->hasMethod(oMoveNext)) + { + return -1; + } + + //Get columns count + aRet = xInvRes->getValue(oFields); + aRet >>= xIntFields; + uno::Reference< script::XInvocation > xInvFields(xIntFields, uno::UNO_QUERY_THROW); + aRet = xInvFields->getValue( rtl::OUString::createFromAscii("Count")) ; + aRet >>= lColCnt; + + //Set the assign column number + if (lMaxCol != 0) + { + if (lColCnt > lMaxCol) + { + lColCnt = lMaxCol; + } + } + + aCrrRow <<= nCrrRow; + aCrrCol <<= nCrrCol; + + + //Get start position + uno::Reference< excel::XRange > xRngStartRow = Rows(uno::Any(sal_Int32(1)) ); + uno::Reference< excel::XRange > xRngPos = xRngStartRow->Columns( uno::Any(sal_Int32(1)) ); + + while(1) + {//travel recordset + //get every column + for (long l = 0; l < lColCnt ; l++) + { + nCol = l; + aPar <<= nCol; + //get every field + aRet = xInvFields->invoke( rtl::OUString::createFromAscii("Item"), uno::Sequence< uno::Any >(&aPar,1) , aOutParamIndex,aOutParam); + aRet >>= xIntFld; + uno::Reference< script::XInvocation > xInvFld(xIntFld, uno::UNO_QUERY_THROW); //Get the Field obj + + //set the field value + aRet = xInvFld->getValue( rtl::OUString::createFromAscii("Value") ); + uno::Reference< excel::XRange > xRngToFill = xRngPos->Offset(aCrrRow,aCrrCol ); + + xRngToFill->setValue(aRet); + nCrrCol++; + aCrrCol <<= nCrrCol; + } + + aRet = xInvRes->invoke(oMoveNext, aParams,aOutParamIndex,aOutParam ); + aRet = xInvRes->getValue(oEof); + aRet >>= bEof; + if (bEof || ( nCrrRow >= nMaxRows && nMaxRows != 0) ) + {//Arrive the end of recordset + break; + } + + nCrrRow++; + aCrrRow <<= nCrrRow; + nCrrCol = 0; + aCrrCol <<= nCrrCol; + } + + return 0; +} +//end add void SAL_CALL ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& ActivePrinter, const uno::Any& PrintToFile, const uno::Any& Collate, const uno::Any& PrToFileName ) throw (uno::RuntimeException) { @@ -5003,7 +5379,7 @@ ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& { ScVbaRange* pRange = getImplementation( xRange ); // initialise the doc shell and the printareas - pShell = getDocShellFromRange( pRange->mxRange ); + pShell = excel::GetDocShellFromRange( pRange->mxRange ); xPrintAreas.set( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW ); } printAreas[ index - 1 ] = rangeAddress; @@ -5089,7 +5465,7 @@ ScVbaRange::AutoFill( const uno::Reference< excel::XRange >& Destination, const } } } - ScDocShell* pDocSh= getDocShellFromRange( mxRange ); + ScDocShell* pDocSh= excel::GetDocShellFromRange( mxRange ); FillCmd eCmd = FILL_AUTO; FillDateCmd eDateCmd = FILL_DAY; @@ -5212,13 +5588,8 @@ ScVbaRange::AutoOutline( ) throw (script::BasicErrorException, uno::RuntimeExce RangeHelper thisRange( mxRange ); table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress(); - if ( isSingleCellRange() || mbIsRows ) - { - uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW ); - xSheetOutline->autoOutline( thisAddress ); - } - else - DebugHelper::exception(SbERR_METHOD_FAILED, rtl::OUString()); + uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW ); + xSheetOutline->autoOutline( thisAddress ); } void SAL_CALL @@ -5245,9 +5616,9 @@ ScVbaRange::groupUnGroup( bool bUnGroup ) throw ( script::BasicErrorException, u { if ( m_Areas->getCount() > 1 ) DebugHelper::exception(SbERR_METHOD_FAILED, STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY); - table::TableOrientation nOrient = table::TableOrientation_ROWS; - if ( mbIsColumns ) - nOrient = table::TableOrientation_COLUMNS; + table::TableOrientation nOrient = table::TableOrientation_COLUMNS; + if ( mbIsRows ) + nOrient = table::TableOrientation_ROWS; RangeHelper thisRange( mxRange ); table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress(); uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW ); @@ -5406,6 +5777,7 @@ ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue) throw bool bIsSingleCell = isSingleCellRange(); bool bIsMultiArea = ( m_Areas->getCount() > 1 ); ScVbaRange* pRangeToUse = this; + uno::Reference< excel::XRange > xUsedRange( getWorksheet()->getUsedRange() ); sal_Int32 nType = 0; if ( !( _oType >>= nType ) ) DebugHelper::exception(SbERR_BAD_PARAMETER, rtl::OUString() ); @@ -5466,7 +5838,6 @@ ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue) throw } else if ( bIsSingleCell ) { - uno::Reference< excel::XRange > xUsedRange = getWorksheet()->getUsedRange(); pRangeToUse = static_cast< ScVbaRange* >( xUsedRange.get() ); } @@ -5641,6 +6012,183 @@ ScVbaRange::Subtotal( ::sal_Int32 _nGroupBy, ::sal_Int32 _nFunction, const uno:: } } +uno::Any SAL_CALL ScVbaRange::AdvancedFilter( sal_Int32 Action, const uno::Any& CriteriaRange, + const uno::Any& CopyToRange, const uno::Any& Unique ) throw (script::BasicErrorException, uno::RuntimeException) +{ + uno::Any aRet; + aRet <<= sal_True; + + uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext ); + ScDocument* pDoc = getScDocument(); + if ( !pDoc ) + { + throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access document from range" ) ), uno::Reference< uno::XInterface >() ); + } + + // Action + if ( Action != excel::XlFilterAction::xlFilterInPlace && Action != excel::XlFilterAction::xlFilterCopy ) + { + throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Invalid input parameter" ) ), uno::Reference< uno::XInterface >() ); + } + if ( m_Areas->getCount() > 1 ) + { + throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Invalid range" ) ), uno::Reference< uno::XInterface >() ); + } + + sal_Bool bCopyOut = ( Action != excel::XlFilterAction::xlFilterInPlace ); + uno::Reference< sheet::XSheetFilterDescriptor > xFilterDesc; + uno::Reference< sheet::XSheetFilterable > xSheetFilter( mxRange, uno::UNO_QUERY_THROW ); + + // CriteriaRange + String aBuiltInCriteria; // Excel Built-In Filter Criteria. + ScRangeData* pData = NULL; + table::CellRangeAddress refParentAddr; + uno::Any aCriteriaRange = CriteriaRange; + formula::FormulaGrammar::AddressConvention aConv = formula::FormulaGrammar::CONV_XL_A1; + if ( aCriteriaRange.hasValue() && aCriteriaRange.getValueTypeClass() == uno::TypeClass_STRING ) + { + rtl::OUString rRangeString; + aCriteriaRange >>= rRangeString; + aConv = excel::IsR1C1ReferFormat( pDoc, rRangeString ) ? formula::FormulaGrammar::CONV_XL_R1C1 : aConv; + } + else + { + // Get Excel BuiltIn Filter Criteria. + ScRangeName* pRangeNames = pDoc->GetRangeName(); + const USHORT nCount = pRangeNames ? pRangeNames->GetCount() : 0; + for ( USHORT index = 0; index < nCount; index++ ) + { + pData = ( ScRangeData* )( pRangeNames->At( index ) ); + if ( pData && pData->HasType( RT_CRITERIA ) ) + { + pData->GetSymbol( aBuiltInCriteria, formula::FormulaGrammar::GRAM_NATIVE_XL_A1 ); + break; + } + } + aCriteriaRange = aBuiltInCriteria.Len() > 0 ? uno::makeAny( rtl::OUString( aBuiltInCriteria ) ) : aCriteriaRange; + } + if ( aCriteriaRange.hasValue() ) + { + table::CellRangeAddress criteriaRangeAddress = getCellRangeAddressForVBARange( aCriteriaRange, getScDocShell(), aConv ); + ScRange refRange; + ScUnoConversion::FillScRange( refRange, criteriaRangeAddress ); + uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell(), refRange ) ); + uno::Reference< sheet::XSheetFilterableEx > xCriteria( xRange, uno::UNO_QUERY ); + if ( xCriteria.is() ) + { + xFilterDesc = xCriteria->createFilterDescriptorByObject( xSheetFilter ); + } + } + else if ( mxRange.is() ) + { + uno::Reference< sheet::XSheetFilterableEx > xCriteria( mxRange, uno::UNO_QUERY ); + if ( xCriteria.is() ) + { + xFilterDesc = xCriteria->createFilterDescriptorByObject( xSheetFilter ); + } + } + + uno::Reference< beans::XPropertySet > xPropertySet( xFilterDesc, uno::UNO_QUERY ); + if ( xPropertySet.is() ) + { + xPropertySet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_COPYOUT ) ), uno::makeAny( bCopyOut ) ); + } + + // CopyToRange + if ( bCopyOut && CopyToRange.hasValue() && xPropertySet.is() ) + { + formula::FormulaGrammar::AddressConvention aTmpConv = formula::FormulaGrammar::CONV_XL_A1; + if ( CopyToRange.getValueTypeClass() == uno::TypeClass_STRING ) + { + rtl::OUString rRangeString; + CopyToRange >>= rRangeString; + aTmpConv = excel::IsR1C1ReferFormat( pDoc, rRangeString ) ? formula::FormulaGrammar::CONV_XL_R1C1 : aConv; + } + ScRange refRange; + ScUnoConversion::FillScRange( refRange, getCellRangeAddressForVBARange( CopyToRange, getScDocShell(), aTmpConv ) ); + uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell(), refRange ) ); + uno::Reference< sheet::XCellAddressable > xCellAddr( xRange->getCellByPosition( 0, 0 ), uno::UNO_QUERY_THROW ); + xPropertySet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_OUTPOS ) ), uno::makeAny( xCellAddr->getCellAddress() ) ); + } + + // Unique + if ( xPropertySet.is() ) + { + sal_Bool bUnique = sal_False; + uno::Any aUnique; + try + { + aUnique <<= bUnique; + aUnique = ( xConverter.is() && Unique.hasValue() ) ? xConverter->convertTo( Unique, getCppuType( ( sal_Bool* ) 0 ) ) : aUnique; + } + catch( const uno::Exception& ) + { + } + xPropertySet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_SKIPDUP ) ), aUnique ); + } + + // Do filter. + if ( xFilterDesc.is() ) + { + xSheetFilter->filter( xFilterDesc ); + } + + return aRet; +} + +//Add by minz@cn.ibm.com. Range.PivotTable. +//Returns a PivotTable object that represents the PivotTable report containing the upper-left corner of the specified range. +uno::Reference< excel::XPivotTable > +ScVbaRange::PivotTable() throw (uno::RuntimeException) +{ + uno::Reference< excel::XPivotTable > xDestPVTable; + + uno::Reference< sheet::XSpreadsheet > xSheet; + if ( mxRange.is() ) + { + RangeHelper thisRange( mxRange ); + xSheet = thisRange.getSpreadSheet(); + } + else if ( mxRanges.is() ) + { + uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW ); + uno::Reference< table::XCellRange > xRange( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW ); + RangeHelper thisRange( xRange ); + xSheet = thisRange.getSpreadSheet(); + } + +// RangeHelper thisRange( mxRange ); +// uno::Reference< sheet::XSpreadsheet > xSheet = thisRange.getSpreadSheet(); + uno::Reference< sheet::XDataPilotTablesSupplier > xTables(xSheet, uno::UNO_QUERY_THROW ) ; + uno::Reference< container::XIndexAccess > xIndexAccess( xTables->getDataPilotTables(), uno::UNO_QUERY_THROW ); + if ( xIndexAccess.is() ) + { + //get the upper-left cell address + table::CellAddress aAddress = getLeftUpperCellAddress(); + + sal_Int32 nCount = xIndexAccess->getCount(); + for (sal_Int32 i=0; i < nCount; i++) + { + uno::Reference< sheet::XDataPilotTable > xDPTable(xIndexAccess->getByIndex(i), uno::UNO_QUERY); + uno::Reference< sheet::XDataPilotTable2 > xDPTable2(xDPTable, uno::UNO_QUERY); + + //check if the cell is in the pivot table + sheet::DataPilotTablePositionData posData = xDPTable2->getPositionData(aAddress); + table::CellRangeAddress aCellRangeAddress = xDPTable->getOutputRange(); + ScRange aScRange( aCellRangeAddress.StartColumn, aCellRangeAddress.StartRow, aCellRangeAddress.Sheet, + aCellRangeAddress.EndColumn, aCellRangeAddress.EndRow, aCellRangeAddress.Sheet ); + ScAddress aPos( aAddress.Column, aAddress.Row, aAddress.Sheet ); + if( !(posData.PositionType == sheet::DataPilotTablePositionType::NOT_IN_TABLE) || aScRange.In( aPos ) ) + { + xDestPVTable = new ScVbaPivotTable( mxContext, xDPTable ); + break; + } + } + } + return xDestPVTable; +} + + rtl::OUString& ScVbaRange::getServiceImplName() { @@ -5660,6 +6208,25 @@ ScVbaRange::getServiceNames() return aServiceNames; } +sal_Bool SAL_CALL +ScVbaRange::hasError() throw (uno::RuntimeException) +{ + double dResult = sal_False; + uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW ); + uno::Reference< script::XInvocation > xInvoc( xApplication->WorksheetFunction(), uno::UNO_QUERY_THROW ); + + static rtl::OUString FunctionName( RTL_CONSTASCII_USTRINGPARAM("IsError" ) ); + uno::Sequence< uno::Any > Params(1); + uno::Reference< excel::XRange > aRange( this ); + Params[0] = uno::makeAny( aRange ); + uno::Sequence< sal_Int16 > OutParamIndex; + uno::Sequence< uno::Any > OutParam; + xInvoc->invoke( FunctionName, Params, OutParamIndex, OutParam ) >>= dResult; + if ( dResult > 0.0 ) + return sal_True; + return sal_False; +} + namespace range { namespace sdecl = comphelper::service_decl; diff --git a/sc/source/ui/vba/vbarange.hxx b/sc/source/ui/vba/vbarange.hxx index e7488e434f30..4623b790a5f0 100644 --- a/sc/source/ui/vba/vbarange.hxx +++ b/sc/source/ui/vba/vbarange.hxx @@ -35,6 +35,7 @@ #include <ooo/vba/excel/XFont.hpp> #include <ooo/vba/excel/XComment.hpp> #include <ooo/vba/XCollection.hpp> +#include <ooo/vba/excel/XPivotTable.hpp> #include <ooo/vba/excel/XlPasteType.hdl> #include <ooo/vba/excel/XlPasteSpecialOperation.hdl> @@ -49,6 +50,8 @@ #include <com/sun/star/sheet/FillDirection.hpp> #include <com/sun/star/sheet/XSpreadsheet.hpp> #include <com/sun/star/sheet/XSheetCellRangeContainer.hpp> +#include <com/sun/star/table/CellAddress.hpp> +#include "vbaquerytable.hxx" //09-09-18 add by limingl //#include <vbahelper/vbahelperinterface.hxx> #include "vbaformat.hxx" @@ -99,6 +102,7 @@ class ScVbaRange : public ScVbaRange_BASE sal_Bool mbIsRows; sal_Bool mbIsColumns; css::uno::Reference< ov::excel::XValidation > m_xValidation; + css::uno::Reference<excel::XQueryTable> m_xQueryTable; //09-09-16 add by limingl double getCalcColWidth( const css::table::CellRangeAddress& ) throw (css::uno::RuntimeException); double getCalcRowHeight( const css::table::CellRangeAddress& ) throw (css::uno::RuntimeException); void visitArray( ArrayVisitor& vistor ); @@ -148,8 +152,10 @@ public: const css::uno::Reference< css::uno::XComponentContext >& xContext, const rtl::OUString& sRangeName, ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( css::uno::RuntimeException ); + css::table::CellAddress getLeftUpperCellAddress(); // Attributes + virtual css::uno::Any SAL_CALL getName() throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL getValue() throw (css::uno::RuntimeException); virtual void SAL_CALL setValue( const css::uno::Any& aValue ) throw ( css::uno::RuntimeException); virtual css::uno::Any SAL_CALL getFormula() throw (css::uno::RuntimeException); @@ -190,6 +196,7 @@ public: virtual css::uno::Any SAL_CALL getPrefixCharacter() throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL getShowDetail() throw (css::uno::RuntimeException); virtual void SAL_CALL setShowDetail(const css::uno::Any& aShowDetail) throw (css::uno::RuntimeException); + virtual ::com::sun::star::uno::Reference< ::ooo::vba::excel::XQueryTable > SAL_CALL getQueryTable() throw (::com::sun::star::uno::RuntimeException); //09-09-16 add by limingl // Methods sal_Bool IsRows() { return mbIsRows; } sal_Bool IsColumns() { return mbIsColumns; } @@ -240,7 +247,7 @@ public: virtual css::uno::Any SAL_CALL BorderAround( const css::uno::Any& LineStyle, const css::uno::Any& Weight, const css::uno::Any& ColorIndex, const css::uno::Any& Color ) throw (css::uno::RuntimeException); virtual void SAL_CALL TextToColumns( const css::uno::Any& Destination, const css::uno::Any& DataType, const css::uno::Any& TextQualifier, - const css::uno::Any& ConsecutinveDelimiter, const css::uno::Any& Tab, const css::uno::Any& Semicolon, const css::uno::Any& Comma, + const css::uno::Any& ConsecutiveDelimiter, const css::uno::Any& Tab, const css::uno::Any& Semicolon, const css::uno::Any& Comma, const css::uno::Any& Space, const css::uno::Any& Other, const css::uno::Any& OtherChar, const css::uno::Any& FieldInfo, const css::uno::Any& DecimalSeparator, const css::uno::Any& ThousandsSeparator, const css::uno::Any& TrailingMinusNumbers ) throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Hyperlinks( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); @@ -265,6 +272,11 @@ public: virtual void SAL_CALL RemoveSubtotal( ) throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual css::uno::Reference< ov::excel::XRange > SAL_CALL MergeArea() throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual void SAL_CALL Subtotal( ::sal_Int32 GroupBy, ::sal_Int32 Function, const css::uno::Sequence< ::sal_Int32 >& TotalList, const css::uno::Any& Replace, const css::uno::Any& PageBreaks, const css::uno::Any& SummaryBelowData ) throw (css::script::BasicErrorException, css::uno::RuntimeException); + virtual css::uno::Any SAL_CALL AdvancedFilter( ::sal_Int32 Action, const css::uno::Any& CriteriaRange, const css::uno::Any& CopyToRange, const css::uno::Any& Unique ) throw (css::script::BasicErrorException, css::uno::RuntimeException); + + virtual css::uno::Reference< ov::excel::XPivotTable > SAL_CALL PivotTable( ) throw (css::uno::RuntimeException); + + virtual ::sal_Int32 SAL_CALL CopyFromRecordset( const ::com::sun::star::uno::Any& Data, const ::com::sun::star::uno::Any& MaxRows, const ::com::sun::star::uno::Any& MaxColumns ) throw (::com::sun::star::script::BasicErrorException, ::com::sun::star::uno::RuntimeException); //2008-08-25 add by limingl // XEnumerationAccess virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration() throw (css::uno::RuntimeException); // XElementAccess @@ -290,6 +302,8 @@ public: static css::uno::Reference< ov::excel::XRange > ApplicationRange( const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Any &Cell1, const css::uno::Any &Cell2 ) throw (css::uno::RuntimeException); virtual sal_Bool SAL_CALL GoalSeek( const css::uno::Any& Goal, const css::uno::Reference< ov::excel::XRange >& ChangingCell ) throw (css::uno::RuntimeException); virtual css::uno::Reference< ov::excel::XRange > SAL_CALL SpecialCells( const css::uno::Any& _oType, const css::uno::Any& _oValue) throw ( css::script::BasicErrorException ); + // XErrorQuery + virtual ::sal_Bool SAL_CALL hasError( ) throw (css::uno::RuntimeException); // XHelperInterface virtual rtl::OUString& getServiceImplName(); virtual css::uno::Sequence<rtl::OUString> getServiceNames(); diff --git a/sc/source/ui/vba/vbavalidation.cxx b/sc/source/ui/vba/vbavalidation.cxx index e2a768549e11..07c61e788310 100644 --- a/sc/source/ui/vba/vbavalidation.cxx +++ b/sc/source/ui/vba/vbavalidation.cxx @@ -25,6 +25,7 @@ * ************************************************************************/ #include "vbavalidation.hxx" +#include "vbaformatcondition.hxx" #include <com/sun/star/sheet/XSheetCondition.hpp> #include <com/sun/star/sheet/ValidationType.hpp> #include <com/sun/star/sheet/ValidationAlertStyle.hpp> @@ -225,8 +226,10 @@ ScVbaValidation::Delete( ) throw (uno::RuntimeException) lcl_setValidationProps( m_xRange, xProps ); } + +// Fix the defect that validatation cannot work when the input should be limited between a lower bound and an upper bound void SAL_CALL -ScVbaValidation::Add( const uno::Any& Type, const uno::Any& AlertStyle, const uno::Any& /*Operator*/, const uno::Any& Formula1, const uno::Any& Formula2 ) throw (uno::RuntimeException) +ScVbaValidation::Add( const uno::Any& Type, const uno::Any& AlertStyle, const uno::Any& Operator, const uno::Any& Formula1, const uno::Any& Formula2 ) throw (uno::RuntimeException) { uno::Reference< beans::XPropertySet > xProps( lcl_getValidationProps( m_xRange ) ); uno::Reference< sheet::XSheetCondition > xCond( xProps, uno::UNO_QUERY_THROW ); @@ -291,6 +294,13 @@ ScVbaValidation::Add( const uno::Any& Type, const uno::Any& AlertStyle, const un xProps->setPropertyValue( ALERTSTYLE, uno::makeAny( eStyle ) ); + //2009-11-11 fix the defect that validatation cannot work when the input should be limited between a lower bound and an upper bound + if ( Operator.hasValue() ) + { + css::sheet::ConditionOperator conOperator = ScVbaFormatCondition::retrieveAPIOperator( Operator ); + xCond->setOperator( conOperator ); + } + //2009-11-11 if ( sFormula1.getLength() ) xCond->setFormula1( sFormula1 ); if ( sFormula2.getLength() ) diff --git a/sc/source/ui/vba/vbaworkbook.cxx b/sc/source/ui/vba/vbaworkbook.cxx index 28469c4685a2..445e5641c89c 100644 --- a/sc/source/ui/vba/vbaworkbook.cxx +++ b/sc/source/ui/vba/vbaworkbook.cxx @@ -36,6 +36,7 @@ #include <com/sun/star/frame/XFrame.hpp> #include <com/sun/star/beans/XPropertySet.hpp> #include <ooo/vba/excel/XlFileFormat.hpp> +#include <ooo/vba/excel/XApplication.hpp> //liuchen 2009-12-16 #include "scextopt.hxx" #include "vbaworksheet.hxx" @@ -125,7 +126,7 @@ ScVbaWorkbook::Colors( const ::uno::Any& Index ) throw (::script::BasicErrorExce } ::sal_Int32 SAL_CALL -ScVbaWorkbook::FileFormat( ) throw (::script::BasicErrorException, ::uno::RuntimeException) +ScVbaWorkbook::getFileFormat( ) throw (::uno::RuntimeException) { sal_Int32 aFileFormat = 0; rtl::OUString aFilterName; @@ -185,6 +186,24 @@ ScVbaWorkbook::FileFormat( ) throw (::script::BasicErrorException, ::uno::Runti return aFileFormat; } +//VBA by minz@cn.ibm.com. Convert Excel fileformat to OO file filter +::rtl::OUString ScVbaWorkbook::convertFileFormat(sal_Int32 aFileFormat) +{ + rtl::OUString aFilterName; + + switch(aFileFormat) + { + case excel::XlFileFormat::xlCSV: + aFilterName = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Text - txt - csv (StarCalc)" ) ); + break; + case excel::XlFileFormat::xlExcel9795: + aFilterName = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MS Excel 97" ) ); + break; + } + + return aFilterName; +} + void ScVbaWorkbook::init() { @@ -264,6 +283,12 @@ ScVbaWorkbook::Activate() throw (uno::RuntimeException) VbaDocumentBase::Activate(); } +void +ScVbaWorkbook::Protect( const uno::Any &aPassword ) throw (uno::RuntimeException) +{ + VbaDocumentBase::Protect( aPassword ); +} + ::sal_Bool ScVbaWorkbook::getProtectStructure() throw (uno::RuntimeException) { @@ -299,6 +324,50 @@ ScVbaWorkbook::SaveCopyAs( const rtl::OUString& sFileName ) throw ( uno::Runtime xStor->storeToURL( aURL, storeProps ); } +//VBA by minz@cn.ibm.com. Add Workbook.SaveAs. +void +ScVbaWorkbook::SaveAs( const rtl::OUString& FileName, const uno::Any& FileFormat, const uno::Any& /*CreateBackup*/ ) throw ( uno::RuntimeException) +{ + rtl::OUString aURL; + osl::FileBase::getFileURLFromSystemPath( FileName, aURL ); + //liuchen 2009-12-16 if the input parameter "FileName" takes the form as "MyFile", we need to get the current directory and combine the current directory and the file name + INetURLObject aFileNameURL( aURL ); + aURL = aFileNameURL.GetMainURL( INetURLObject::NO_DECODE ); + if ( aURL.getLength() == 0 ) + { + uno::Reference< excel::XApplication > xApplication ( Application(),uno::UNO_QUERY_THROW ); + rtl::OUString aPathStr = xApplication->getDefaultFilePath(); + rtl::OUString aPathURLStr; + osl::FileBase::getFileURLFromSystemPath( aPathStr, aPathURLStr ); + INetURLObject aPathURL( aPathURLStr ); + aPathURL.Append( FileName ); + aURL = aPathURL.GetMainURL( INetURLObject::NO_DECODE ); + } + //liuchen 2009-12-16 + uno::Reference< frame::XStorable > xStor( getModel(), uno::UNO_QUERY_THROW ); + + sal_Int32 aFileFormat = excel::XlFileFormat::xlExcel9795; + FileFormat >>= aFileFormat; + + if ( FileName.indexOf('.') == -1 ) + { + if ( aFileFormat == excel::XlFileFormat::xlExcel9795 ) + { + aURL = aURL + rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".xls" ) ); + } + else if ( aFileFormat == excel::XlFileFormat::xlCSV ) + { + aURL = aURL + rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".csv" ) ); + } + } + + uno::Sequence< beans::PropertyValue > storeProps(1); + storeProps[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" ) ); + storeProps[0].Value <<= convertFileFormat(aFileFormat); + + xStor->storeAsURL( aURL, storeProps ); +} + css::uno::Any SAL_CALL ScVbaWorkbook::Styles( const::uno::Any& Item ) throw (uno::RuntimeException) { diff --git a/sc/source/ui/vba/vbaworkbook.hxx b/sc/source/ui/vba/vbaworkbook.hxx index 4aff58078403..a5ccea180dd3 100644 --- a/sc/source/ui/vba/vbaworkbook.hxx +++ b/sc/source/ui/vba/vbaworkbook.hxx @@ -41,6 +41,8 @@ class ScVbaWorkbook : public ScVbaWorkbook_BASE static css::uno::Sequence< sal_Int32 > ColorData; void initColorData( const css::uno::Sequence< sal_Int32 >& sColors ); void init(); + + ::rtl::OUString convertFileFormat(sal_Int32 aFileFormat); protected: ScVbaWorkbook( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext); @@ -61,20 +63,25 @@ public: virtual css::uno::Any SAL_CALL Sheets( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Windows( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); virtual void SAL_CALL Activate() throw (css::uno::RuntimeException); + virtual void SAL_CALL Protect( const css::uno::Any & aPassword ) throw (css::uno::RuntimeException); // Amelia Wang virtual css::uno::Any SAL_CALL Names( const css::uno::Any& aIndex ) throw (css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Styles( const css::uno::Any& Item ) throw (css::uno::RuntimeException); virtual void SAL_CALL ResetColors( ) throw (css::script::BasicErrorException, css::uno::RuntimeException); virtual css::uno::Any SAL_CALL Colors( const css::uno::Any& Index ) throw (css::script::BasicErrorException, css::uno::RuntimeException); - virtual ::sal_Int32 SAL_CALL FileFormat( ) throw (css::script::BasicErrorException, css::uno::RuntimeException); + virtual ::sal_Int32 SAL_CALL getFileFormat( ) throw (css::uno::RuntimeException); virtual void SAL_CALL SaveCopyAs( const rtl::OUString& Filename ) throw ( css::uno::RuntimeException); + virtual void SAL_CALL SaveAs( const rtl::OUString& FileName, const css::uno::Any& FileFormat, const css::uno::Any& CreateBackup ) throw (css::uno::RuntimeException); + // code name virtual ::rtl::OUString SAL_CALL getCodeName() throw ( css::uno::RuntimeException); // XHelperInterface virtual rtl::OUString& getServiceImplName(); virtual css::uno::Sequence<rtl::OUString> getServiceNames(); + + virtual css::uno::Reference< css::frame::XModel > getDocModel() { return mxModel; } }; #endif /* SC_VBA_WORKBOOK_HXX */ diff --git a/sc/source/ui/vba/vbaworksheet.cxx b/sc/source/ui/vba/vbaworksheet.cxx index d76aa7bd612e..187f719d2b7f 100644 --- a/sc/source/ui/vba/vbaworksheet.cxx +++ b/sc/source/ui/vba/vbaworksheet.cxx @@ -63,6 +63,7 @@ #include <ooo/vba/excel/XlEnableSelection.hpp> #include <ooo/vba/excel/XWorkbook.hpp> #include <ooo/vba/XControlProvider.hpp> +#include <ooo/vba/excel/XlSheetVisibility.hpp> #include <comphelper/processfactory.hxx> #include <vbahelper/vbashapes.hxx> @@ -80,7 +81,7 @@ #include "cellsuno.hxx" #include "drwlayer.hxx" - +#include "tabprotection.hxx" #include "scextopt.hxx" #include "vbaoutline.hxx" #include "vbarange.hxx" @@ -94,6 +95,7 @@ #include "vbaworksheets.hxx" #include "vbahyperlinks.hxx" #include "vbasheetobjects.hxx" +#include "viewuno.hxx" //liuchen 2009-9-2 #define STANDARDWIDTH 2267 #define STANDARDHEIGHT 427 @@ -221,7 +223,7 @@ ScVbaWorksheet::setName(const ::rtl::OUString &rName ) throw (uno::RuntimeExcept xNamed->setName( rName ); } -sal_Bool +::sal_Int32 ScVbaWorksheet::getVisible() throw (uno::RuntimeException) { uno::Reference< beans::XPropertySet > xProps( getSheet(), uno::UNO_QUERY_THROW ); @@ -229,13 +231,33 @@ ScVbaWorksheet::getVisible() throw (uno::RuntimeException) (rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsVisible" ) ) ); sal_Bool bRet = false; aValue >>= bRet; - return bRet; + if ( bRet ) + { + return excel::XlSheetVisibility::xlSheetVisible; + } + else + { + return excel::XlSheetVisibility::xlSheetHidden; + } } void -ScVbaWorksheet::setVisible( sal_Bool bVisible ) throw (uno::RuntimeException) +ScVbaWorksheet::setVisible( ::sal_Int32 _Visible ) throw (uno::RuntimeException) { uno::Reference< beans::XPropertySet > xProps( getSheet(), uno::UNO_QUERY_THROW ); + + //VBA by minz@cn.ibm.com. + sal_Bool bVisible = true; + switch( _Visible ) + { + case excel::XlSheetVisibility::xlSheetHidden: + case excel::XlSheetVisibility::xlSheetVeryHidden: + bVisible = false; + break; + case excel::XlSheetVisibility::xlSheetVisible: + bVisible = true; + break; + } uno::Any aValue( bVisible ); xProps->setPropertyValue (rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsVisible" ) ), aValue); @@ -427,6 +449,18 @@ ScVbaWorksheet::getProtectContents()throw (uno::RuntimeException) sal_Bool ScVbaWorksheet::getProtectDrawingObjects() throw (uno::RuntimeException) { + SCTAB nTab = 0; + rtl::OUString aSheetName = getName(); + uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW ); + bool bSheetExists = ScVbaWorksheets::nameExists (xSpreadDoc, aSheetName, nTab); + if ( bSheetExists ) + { + uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_QUERY_THROW ); + ScDocument* pDoc = excel::getDocShell( xModel )->GetDocument(); + ScTableProtection* pProtect = pDoc->GetTabProtection(nTab); + if ( pProtect ) + return pProtect->isOptionEnabled( ScTableProtection::OBJECTS ); + } return sal_False; } @@ -444,10 +478,30 @@ ScVbaWorksheet::Activate() throw (uno::RuntimeException) xSpreadsheet->setActiveSheet(getSheet()); } +//liuchen 2009-9-2, support expand (but not replace) the active sheet void -ScVbaWorksheet::Select() throw (uno::RuntimeException) +ScVbaWorksheet::Select(const css::uno::Any& aReplace) throw (uno::RuntimeException) { - Activate(); + sal_Bool bReplace = true; + if (aReplace.hasValue() && aReplace.getValueTypeClass() == uno::TypeClass_BOOLEAN) + { + aReplace >>= bReplace; + } + + uno::Reference< sheet::XSpreadsheetView > xSpreadsheet( + getModel()->getCurrentController(), uno::UNO_QUERY_THROW ); + ScTabViewObj* pTabView = static_cast< ScTabViewObj* >( xSpreadsheet.get() ); + + if (bReplace) + { + pTabView->selectSheet(getSheet(), false); + } + else + { + uno::Reference< sheet::XSpreadsheet > xOldActiveSheet = pTabView->getActiveSheet(); + pTabView->selectSheet(getSheet(), true); + pTabView->selectSheet(xOldActiveSheet, true); + } } void @@ -509,18 +563,42 @@ ScVbaWorksheet::Copy( const uno::Any& Before, const uno::Any& After ) throw (uno return; } - uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY ); + ScVbaWorksheet* pDestSheet = static_cast< ScVbaWorksheet* >(xSheet.get()); + uno::Reference <sheet::XSpreadsheetDocument> xDestDoc( pDestSheet->getModel(), uno::UNO_QUERY ); + uno::Reference <sheet::XSpreadsheetDocument> xSrcDoc( getModel(), uno::UNO_QUERY ); + SCTAB nDest = 0; + SCTAB nSrc = 0; rtl::OUString aSheetName = xSheet->getName(); - if ( ScVbaWorksheets::nameExists (xSpreadDoc, aSheetName, nDest ) ) + bool bSameDoc = ( pDestSheet->getModel() == getModel() ); + bool bDestSheetExists = ScVbaWorksheets::nameExists (xDestDoc, aSheetName, nDest ); + bool bSheetExists = ScVbaWorksheets::nameExists (xSrcDoc, aCurrSheetName, nSrc ); + + // set sheet name to be newSheet name + aSheetName = aCurrSheetName; + SCTAB nDummy=0; + if ( bSheetExists && bDestSheetExists ) { sal_Bool bAfter = After.hasValue(); if(bAfter) nDest++; - uno::Reference<sheet::XSpreadsheets> xSheets = xSpreadDoc->getSheets(); - getNewSpreadsheetName(aSheetName,aCurrSheetName,xSpreadDoc); - xSheets->copyByName(aCurrSheetName,aSheetName,nDest); + uno::Reference<sheet::XSpreadsheets> xSheets = xDestDoc->getSheets(); + if ( bSameDoc || ScVbaWorksheets::nameExists( xDestDoc, aCurrSheetName, nDummy ) ) + getNewSpreadsheetName(aSheetName,aCurrSheetName,xDestDoc); + if ( bSameDoc ) + xSheets->copyByName(aCurrSheetName,aSheetName,nDest); + else + { + ScDocShell* pDestDocShell = excel::getDocShell( pDestSheet->getModel() ); + ScDocShell* pSrcDocShell = excel::getDocShell( getModel() ); + if ( pDestDocShell && pSrcDocShell ) + pDestDocShell->TransferTab( *pSrcDocShell, static_cast<SCTAB>(nSrc), static_cast<SCTAB>(nDest), TRUE, TRUE ); + } } + // active the new sheet + uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW ); + uno::Reference< excel::XWorksheet > xNewSheet( xApplication->Worksheets( uno::makeAny( aSheetName ) ), uno::UNO_QUERY_THROW ); + xNewSheet->Activate(); } @@ -572,13 +650,25 @@ ScVbaWorksheet::getSheetAtOffset(SCTAB offset) throw (uno::RuntimeException) uno::Reference< excel::XWorksheet > ScVbaWorksheet::getNext() throw (uno::RuntimeException) { - return getSheetAtOffset(static_cast<SCTAB>(1)); + //VBA, minz@cn.ibm.com. catch the exception for index out of bound + try{ + return getSheetAtOffset(static_cast<SCTAB>(1)); + }catch( lang::IndexOutOfBoundsException& /*e*/ ) + { + return NULL; + } } uno::Reference< excel::XWorksheet > ScVbaWorksheet::getPrevious() throw (uno::RuntimeException) { - return getSheetAtOffset(-1); + //VBA, minz@cn.ibm.com. catch the exception for index out of bound + try{ + return getSheetAtOffset(-1); + }catch( lang::IndexOutOfBoundsException& /*e*/ ) + { + return NULL; + } } @@ -662,7 +752,7 @@ ScVbaWorksheet::ChartObjects( const uno::Any& Index ) throw (uno::RuntimeExcepti uno::Reference< table::XTableChartsSupplier > xChartSupplier( getSheet(), uno::UNO_QUERY_THROW ); uno::Reference< table::XTableCharts > xTableCharts = xChartSupplier->getCharts(); - uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( mxSheet, uno::UNO_QUERY_THROW ); + uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( getSheet(), uno::UNO_QUERY_THROW ); //VBA, minz@cn.ibm.com. mxCharts = new ScVbaChartObjects( this, mxContext, xTableCharts, xDrawPageSupplier ); } if ( Index.hasValue() ) @@ -981,7 +1071,7 @@ ScVbaWorksheet::getCodeName() throw (css::uno::RuntimeException) sal_Int16 ScVbaWorksheet::getSheetID() throw (uno::RuntimeException) { - uno::Reference< sheet::XCellRangeAddressable > xAddressable( mxSheet, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XCellRangeAddressable > xAddressable( getSheet(), uno::UNO_QUERY_THROW ); //VBA. minz@cn.ibm.com. if ActiveSheet, mxSheet is null. return xAddressable->getRangeAddress().Sheet; } diff --git a/sc/source/ui/vba/vbaworksheet.hxx b/sc/source/ui/vba/vbaworksheet.hxx index 78bcc2503a49..adcfd4af16fa 100644 --- a/sc/source/ui/vba/vbaworksheet.hxx +++ b/sc/source/ui/vba/vbaworksheet.hxx @@ -42,6 +42,7 @@ #include <ooo/vba/excel/XPageSetup.hpp> #include <ooo/vba/excel/XHPageBreaks.hpp> #include <ooo/vba/excel/XVPageBreaks.hpp> +#include <com/sun/star/container/XNamed.hpp> #include <vbahelper/vbahelperinterface.hxx> #include "address.hxx" @@ -91,8 +92,8 @@ public: // Attributes virtual ::rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException); virtual void SAL_CALL setName( const ::rtl::OUString &rName ) throw (css::uno::RuntimeException); - virtual sal_Bool SAL_CALL getVisible() throw (css::uno::RuntimeException); - virtual void SAL_CALL setVisible( sal_Bool bVisible ) throw (css::uno::RuntimeException); + virtual ::sal_Int32 SAL_CALL getVisible() throw (css::uno::RuntimeException); + virtual void SAL_CALL setVisible( ::sal_Int32 _Visible ) throw (css::uno::RuntimeException); virtual ::sal_Int32 SAL_CALL getStandardWidth() throw (css::uno::RuntimeException); virtual ::sal_Int32 SAL_CALL getStandardHeight() throw (css::uno::RuntimeException); virtual ::sal_Bool SAL_CALL getProtectionMode() throw (css::uno::RuntimeException); @@ -115,7 +116,7 @@ public: // Methods virtual void SAL_CALL Activate() throw (css::uno::RuntimeException); - virtual void SAL_CALL Select() throw (css::uno::RuntimeException); + virtual void SAL_CALL Select(const css::uno::Any& aReplace) throw (css::uno::RuntimeException); //liuchen 2009-9-2, add the input parameter to support expand selection virtual css::uno::Reference< ov::excel::XRange > SAL_CALL Range( const css::uno::Any& Cell1, const css::uno::Any& Cell2 ) throw (css::uno::RuntimeException); virtual void SAL_CALL Move( const css::uno::Any& Before, const css::uno::Any& After ) throw (css::uno::RuntimeException) ; virtual void SAL_CALL Copy( const css::uno::Any& Before, const css::uno::Any& After ) throw (css::uno::RuntimeException); diff --git a/sc/source/ui/vba/vbawsfunction.cxx b/sc/source/ui/vba/vbawsfunction.cxx index 60daa7303f2e..6155c1bda5f0 100644 --- a/sc/source/ui/vba/vbawsfunction.cxx +++ b/sc/source/ui/vba/vbawsfunction.cxx @@ -60,6 +60,18 @@ void lclConvertDoubleToBoolean( uno::Any& rAny ) } } +void lclConvertBooleanToDouble( uno::Any& rAny ) +{ + sal_Bool bValue( sal_False ); + if ( rAny >>= bValue ) + { + if ( bValue ) + rAny <<= double( 1.0 ); + else + rAny <<= double( 0.0 ); + } +} + } // namespace ScVbaWSFunction::ScVbaWSFunction( const uno::Reference< XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext ) : @@ -84,9 +96,57 @@ ScVbaWSFunction::invoke(const rtl::OUString& FunctionName, const uno::Sequence< uno::Any* pArrayEnd = pArray + aParamTemp.getLength(); for( ; pArray < pArrayEnd; ++pArray ) { - uno::Reference< excel::XRange > myRange( *pArray, uno::UNO_QUERY ); - if( myRange.is() ) - *pArray = myRange->getCellRange(); + switch( pArray->getValueType().getTypeClass() ) + { + case uno::TypeClass_BOOLEAN: + lclConvertBooleanToDouble( *pArray ); + break; + case uno::TypeClass_INTERFACE: + { + uno::Reference< excel::XRange > myRange( *pArray, uno::UNO_QUERY ); + if( myRange.is() ) + *pArray = myRange->getCellRange(); + } + break; + case uno::TypeClass_SEQUENCE: + { + // the sheet.FunctionAccess service doesn't deal with Sequences, only Sequences of Sequence + uno::Type aType = pArray->getValueType(); + if ( aType.equals( getCppuType( (uno::Sequence<sal_Int16>*)0 ) ) ) + { + uno::Sequence< uno::Sequence< sal_Int16 > > aTmp(1); + (*pArray) >>= aTmp[ 0 ]; + (*pArray) <<= aTmp; + } + else if ( aType.equals( getCppuType( (uno::Sequence<sal_Int32>*)0 ) ) ) + { + uno::Sequence< uno::Sequence< sal_Int32 > > aTmp(1); + (*pArray) >>= aTmp[ 0 ]; + (*pArray) <<= aTmp; + } + else if ( aType.equals( getCppuType( (uno::Sequence<double>*)0 ) ) ) + { + uno::Sequence< uno::Sequence< double > > aTmp(1); + (*pArray) >>= aTmp[ 0 ]; + (*pArray) <<= aTmp; + } + else if ( aType.equals( getCppuType( (uno::Sequence<rtl::OUString>*)0 ) ) ) + { + uno::Sequence< uno::Sequence< rtl::OUString > > aTmp(1); + (*pArray) >>= aTmp[ 0 ]; + (*pArray) <<= aTmp; + } + else if ( aType.equals( getCppuType( (uno::Sequence<uno::Any>*)0 ) ) ) + { + uno::Sequence< uno::Sequence<uno::Any > > aTmp(1); + (*pArray) >>= aTmp[ 0 ]; + (*pArray) <<= aTmp; + } + } + break; + default: + break; + } OSL_TRACE("Param[%d] is %s", (int)(pArray - aParamTemp.getConstArray()), rtl::OUStringToOString( comphelper::anyToString( *pArray ), RTL_TEXTENCODING_UTF8 ).getStr() ); } } |