/************************************************************************* * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: docuno.cxx,v $ * * $Revision: 1.55 $ * * last change: $Author: kz $ $Date: 2006-07-21 14:36:31 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. * * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2005 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library 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 for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sc.hxx" #include "scitems.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // DBL_MAX #include #include #include #include #include #include #ifndef _COMPHELPER_PROCESSFACTORY_HXX_ #include #endif #include "docuno.hxx" #include "cellsuno.hxx" #include "nameuno.hxx" #include "datauno.hxx" #include "miscuno.hxx" #include "notesuno.hxx" #include "styleuno.hxx" #include "linkuno.hxx" #include "servuno.hxx" #include "targuno.hxx" #include "convuno.hxx" #include "optuno.hxx" #include "forbiuno.hxx" #include "docsh.hxx" #include "hints.hxx" #include "docfunc.hxx" #include "dociter.hxx" #include "cell.hxx" #include "drwlayer.hxx" #include "rangeutl.hxx" #include "markdata.hxx" #include "docoptio.hxx" #include "unoguard.hxx" #include "unonames.hxx" #include "shapeuno.hxx" #include "printfun.hxx" #include "pfuncache.hxx" #include "scmod.hxx" #ifndef _SC_VIEWSETTINGSSEQUENCEDEFINES_HXX #include "ViewSettingsSequenceDefines.hxx" #endif using namespace com::sun::star; //------------------------------------------------------------------------ // alles ohne Which-ID, Map nur fuer PropertySetInfo //! umbenennen, sind nicht mehr nur Options const SfxItemPropertyMap* lcl_GetDocOptPropertyMap() { static SfxItemPropertyMap aDocOptPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNO_APPLYFMDES), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_AREALINKS), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_AUTOCONTFOC), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_BASICLIBRARIES), 0, &getCppuType((uno::Reference< script::XLibraryContainer >*)0), beans::PropertyAttribute::READONLY}, {MAP_CHAR_LEN(SC_UNO_CALCASSHOWN), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), 0, &getCppuType((lang::Locale*)0), 0}, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), 0, &getCppuType((lang::Locale*)0), 0}, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), 0, &getCppuType((lang::Locale*)0), 0}, {MAP_CHAR_LEN(SC_UNO_COLLABELRNG), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_DDELINKS), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_DEFTABSTOP), 0, &getCppuType((sal_Int16*)0), 0}, {MAP_CHAR_LEN(SC_UNO_FORBIDDEN), 0, &getCppuType((uno::Reference*)0), beans::PropertyAttribute::READONLY}, {MAP_CHAR_LEN(SC_UNO_HASDRAWPAGES), 0, &getBooleanCppuType(), beans::PropertyAttribute::READONLY}, {MAP_CHAR_LEN(SC_UNO_IGNORECASE), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_ITERENABLED), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_ITERCOUNT), 0, &getCppuType((sal_Int32*)0), 0}, {MAP_CHAR_LEN(SC_UNO_ITEREPSILON), 0, &getCppuType((double*)0), 0}, {MAP_CHAR_LEN(SC_UNO_LOOKUPLABELS), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_MATCHWHOLE), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_NAMEDRANGES), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_DATABASERNG), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_NULLDATE), 0, &getCppuType((util::Date*)0), 0}, {MAP_CHAR_LEN(SC_UNO_ROWLABELRNG), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_SHEETLINKS), 0, &getCppuType((uno::Reference*)0), 0}, {MAP_CHAR_LEN(SC_UNO_SPELLONLINE), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_STANDARDDEC), 0, &getCppuType((sal_Int16*)0), 0}, {MAP_CHAR_LEN(SC_UNO_REGEXENABLED), 0, &getBooleanCppuType(), 0}, {MAP_CHAR_LEN(SC_UNO_RUNTIMEUID), 0, &getCppuType(static_cast< const rtl::OUString * >(0)), beans::PropertyAttribute::READONLY}, {MAP_CHAR_LEN(SC_UNO_HASVALIDSIGNATURES),0, &getBooleanCppuType(), beans::PropertyAttribute::READONLY}, {MAP_CHAR_LEN("BuildId"), 0, &::getCppuType(static_cast< const rtl::OUString * >(0)), 0, 0}, {0,0,0,0} }; return aDocOptPropertyMap_Impl; } //! StandardDecimals als Property und vom NumberFormatter ???????? const SfxItemPropertyMap* lcl_GetColumnsPropertyMap() { static SfxItemPropertyMap aColumnsPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_OWIDTH), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLWID), 0, &getCppuType((sal_Int32*)0), 0, 0 }, {0,0,0,0} }; return aColumnsPropertyMap_Impl; } const SfxItemPropertyMap* lcl_GetRowsPropertyMap() { static SfxItemPropertyMap aRowsPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_CELLHGT), 0, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLFILT), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_OHEIGHT), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &::getCppuType((const sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &::getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, // not sorted, not used with SfxItemPropertyMap::GetByName {0,0,0,0} }; return aRowsPropertyMap_Impl; } //! move these functions to a header file inline long TwipsToHMM(long nTwips) { return (nTwips * 127 + 36) / 72; } inline long HMMToTwips(long nHMM) { return (nHMM * 72 + 63) / 127; } //------------------------------------------------------------------------ #define SCMODELOBJ_SERVICE "com.sun.star.sheet.SpreadsheetDocument" #define SCDOCSETTINGS_SERVICE "com.sun.star.sheet.SpreadsheetDocumentSettings" #define SCDOC_SERVICE "com.sun.star.document.OfficeDocument" SC_SIMPLE_SERVICE_INFO( ScAnnotationsObj, "ScAnnotationsObj", "com.sun.star.sheet.CellAnnotations" ) SC_SIMPLE_SERVICE_INFO( ScDrawPagesObj, "ScDrawPagesObj", "com.sun.star.drawing.DrawPages" ) SC_SIMPLE_SERVICE_INFO( ScScenariosObj, "ScScenariosObj", "com.sun.star.sheet.Scenarios" ) SC_SIMPLE_SERVICE_INFO( ScSpreadsheetSettingsObj, "ScSpreadsheetSettingsObj", "com.sun.star.sheet.SpreadsheetDocumentSettings" ) SC_SIMPLE_SERVICE_INFO( ScTableColumnsObj, "ScTableColumnsObj", "com.sun.star.table.TableColumns" ) SC_SIMPLE_SERVICE_INFO( ScTableRowsObj, "ScTableRowsObj", "com.sun.star.table.TableRows" ) SC_SIMPLE_SERVICE_INFO( ScTableSheetsObj, "ScTableSheetsObj", "com.sun.star.sheet.Spreadsheets" ) //------------------------------------------------------------------------ // static void ScModelObj::CreateAndSet(ScDocShell* pDocSh) { if (pDocSh) pDocSh->SetBaseModel( new ScModelObj(pDocSh) ); } ScModelObj::ScModelObj( ScDocShell* pDocSh ) : SfxBaseModel( pDocSh ), aPropSet( lcl_GetDocOptPropertyMap() ), pDocShell( pDocSh ), pPrintFuncCache( NULL ) { // pDocShell may be NULL if this is the base of a ScDocOptionsObj if ( pDocShell ) { pDocShell->GetDocument()->AddUnoObject(*this); // SfxModel is derived from SfxListener // setDelegator veraendert den RefCount, darum eine Referenz selber halten // (direkt am m_refCount, um sich beim release nicht selbst zu loeschen) comphelper::increment( m_refCount ); // waehrend des queryInterface braucht man ein Ref auf das // SvNumberFormatsSupplierObj, sonst wird es geloescht. uno::Reference xFormatter(new SvNumberFormatsSupplierObj( pDocShell->GetDocument()->GetFormatTable() )); { xNumberAgg.set(uno::Reference( xFormatter, uno::UNO_QUERY )); // extra block to force deletion of the temporary before setDelegator } // beim setDelegator darf die zusaetzliche Ref nicht mehr existieren xFormatter = NULL; if (xNumberAgg.is()) xNumberAgg->setDelegator( (cppu::OWeakObject*)this ); comphelper::decrement( m_refCount ); } } ScModelObj::~ScModelObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); if (xNumberAgg.is()) xNumberAgg->setDelegator(uno::Reference()); delete pPrintFuncCache; } ScDocument* ScModelObj::GetDocument() const { if (pDocShell) return pDocShell->GetDocument(); return NULL; } SfxObjectShell* ScModelObj::GetEmbeddedObject() const { return pDocShell; } BOOL ScModelObj::IsEmbedded() const { if (pDocShell) { return pDocShell->IsOle(); } return FALSE; } double ScModelObj::GetOutputFactor() const { if (pDocShell) return pDocShell->GetOutputFactor(); return 1.0; } BOOL ScModelObj::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) { if (pDocShell) return pDocShell->AdjustRowHeight( nStartRow, nEndRow, nTab ); return FALSE; } ScDrawLayer* ScModelObj::MakeDrawLayer() { if (pDocShell) return pDocShell->MakeDrawLayer(); return NULL; } void ScModelObj::BeforeXMLLoading() { if (pDocShell) pDocShell->BeforeXMLLoading(); } void ScModelObj::AfterXMLLoading(sal_Bool bRet) { if (pDocShell) pDocShell->AfterXMLLoading(bRet); } uno::Any SAL_CALL ScModelObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( sheet::XSpreadsheetDocument ) SC_QUERYINTERFACE( document::XActionLockable ) SC_QUERYINTERFACE( sheet::XCalculatable ) SC_QUERYINTERFACE( util::XProtectable ) SC_QUERYINTERFACE( drawing::XDrawPagesSupplier ) SC_QUERYINTERFACE( sheet::XGoalSeek ) SC_QUERYINTERFACE( sheet::XConsolidatable ) SC_QUERYINTERFACE( sheet::XDocumentAuditing ) SC_QUERYINTERFACE( style::XStyleFamiliesSupplier ) SC_QUERYINTERFACE( view::XRenderable ) SC_QUERYINTERFACE( document::XLinkTargetSupplier ) SC_QUERYINTERFACE( beans::XPropertySet ) SC_QUERYINTERFACE( lang::XMultiServiceFactory ) SC_QUERYINTERFACE( lang::XServiceInfo ) uno::Any aRet(SfxBaseModel::queryInterface( rType )); if ( !aRet.hasValue() && xNumberAgg.is() ) aRet = xNumberAgg->queryAggregation( rType ); return aRet; } void SAL_CALL ScModelObj::acquire() throw() { SfxBaseModel::acquire(); } void SAL_CALL ScModelObj::release() throw() { SfxBaseModel::release(); } uno::Sequence SAL_CALL ScModelObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes(SfxBaseModel::getTypes()); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); uno::Sequence aAggTypes; if ( xNumberAgg.is() ) { const uno::Type& rProvType = ::getCppuType((uno::Reference*) 0); uno::Any aNumProv(xNumberAgg->queryAggregation(rProvType)); if(aNumProv.getValueType() == rProvType) { uno::Reference xNumProv( *(uno::Reference*)aNumProv.getValue()); aAggTypes = xNumProv->getTypes(); } } long nAggLen = aAggTypes.getLength(); const uno::Type* pAggPtr = aAggTypes.getConstArray(); const long nThisLen = 14; aTypes.realloc( nParentLen + nAggLen + nThisLen ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 1] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 2] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 3] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 4] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 5] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 6] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 7] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 8] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 9] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +10] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +11] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +12] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +13] = getCppuType((const uno::Reference*)0); long i; for (i=0; i SAL_CALL ScModelObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } void ScModelObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { // Not interested in reference update hints here if ( rHint.ISA( SfxSimpleHint ) ) { ULONG nId = ((const SfxSimpleHint&)rHint).GetId(); if ( nId == SFX_HINT_DYING ) { pDocShell = NULL; // has become invalid if (xNumberAgg.is()) { SvNumberFormatsSupplierObj* pNumFmt = SvNumberFormatsSupplierObj::getImplementation( uno::Reference(xNumberAgg, uno::UNO_QUERY) ); if ( pNumFmt ) pNumFmt->SetNumberFormatter( NULL ); } DELETEZ( pPrintFuncCache ); // must be deleted because it has a pointer to the DocShell } else if ( nId == SFX_HINT_DATACHANGED ) { // cached data for rendering become invalid when contents change // (if a broadcast is added to SetDrawModified, is has to be tested here, too) DELETEZ( pPrintFuncCache ); } } else if ( rHint.ISA( ScPointerChangedHint ) ) { USHORT nFlags = ((const ScPointerChangedHint&)rHint).GetFlags(); if (nFlags & SC_POINTERCHANGED_NUMFMT) { // NumberFormatter-Pointer am Uno-Objekt neu setzen if (xNumberAgg.is()) { SvNumberFormatsSupplierObj* pNumFmt = SvNumberFormatsSupplierObj::getImplementation( uno::Reference(xNumberAgg, uno::UNO_QUERY) ); if ( pNumFmt && pDocShell ) pNumFmt->SetNumberFormatter( pDocShell->GetDocument()->GetFormatTable() ); } } } // always call parent - SfxBaseModel might need to handle the same hints again SfxBaseModel::Notify( rBC, rHint ); // SfxBaseModel is derived from SfxListener } // XSpreadsheetDocument uno::Reference SAL_CALL ScModelObj::getSheets() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScTableSheetsObj(pDocShell); return NULL; } // XStyleFamiliesSupplier uno::Reference SAL_CALL ScModelObj::getStyleFamilies() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScStyleFamiliesObj(pDocShell); return NULL; } // XRenderable OutputDevice* lcl_GetRenderDevice( const uno::Sequence& rOptions ) { OutputDevice* pRet = NULL; const beans::PropertyValue* pPropArray = rOptions.getConstArray(); long nPropCount = rOptions.getLength(); for (long i = 0; i < nPropCount; i++) { const beans::PropertyValue& rProp = pPropArray[i]; String aPropName(rProp.Name); if (aPropName.EqualsAscii( SC_UNONAME_RENDERDEV )) { uno::Reference xRenderDevice(rProp.Value, uno::UNO_QUERY); if ( xRenderDevice.is() ) { VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice ); if ( pDevice ) { pRet = pDevice->GetOutputDevice(); pRet->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() ); } } } } return pRet; } bool lcl_ParseTarget( const String& rTarget, ScRange& rTargetRange, Rectangle& rTargetRect, bool& rIsSheet, ScDocument* pDoc, SCTAB nSourceTab ) { // test in same order as in SID_CURRENTCELL execute ScAddress aAddress; ScRangeUtil aRangeUtil; SCTAB nNameTab; sal_Int32 nNumeric; bool bRangeValid = false; bool bRectValid = false; if ( rTargetRange.Parse( rTarget, pDoc ) & SCA_VALID ) { bRangeValid = true; // range reference } else if ( aAddress.Parse( rTarget, pDoc ) & SCA_VALID ) { rTargetRange = aAddress; bRangeValid = true; // cell reference } else if ( aRangeUtil.MakeRangeFromName( rTarget, pDoc, nSourceTab, rTargetRange, RUTL_NAMES ) || aRangeUtil.MakeRangeFromName( rTarget, pDoc, nSourceTab, rTargetRange, RUTL_DBASE ) ) { bRangeValid = true; // named range or database range } else if ( ByteString( rTarget, RTL_TEXTENCODING_ASCII_US ).IsNumericAscii() && ( nNumeric = rTarget.ToInt32() ) > 0 && nNumeric <= MAXROW+1 ) { // row number is always mapped to cell A(row) on the same sheet rTargetRange = ScAddress( 0, (SCROW)(nNumeric-1), nSourceTab ); // target row number is 1-based bRangeValid = true; // row number } else if ( pDoc->GetTable( rTarget, nNameTab ) ) { rTargetRange = ScAddress(0,0,nNameTab); bRangeValid = true; // sheet name rIsSheet = true; // needs special handling (first page of the sheet) } else { // look for named drawing object ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer(); if ( pDrawLayer ) { SCTAB nTabCount = pDoc->GetTableCount(); for (SCTAB i=0; iGetPage(static_cast(i)); DBG_ASSERT(pPage,"Page ?"); if (pPage) { SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS ); SdrObject* pObject = aIter.Next(); while (pObject && !bRangeValid) { if ( ScDrawLayer::GetVisibleName( pObject ) == rTarget ) { rTargetRect = pObject->GetLogicRect(); // 1/100th mm rTargetRange = pDoc->GetRange( i, rTargetRect ); // underlying cells bRangeValid = bRectValid = true; // rectangle is valid } pObject = aIter.Next(); } } } } } if ( bRangeValid && !bRectValid ) { // get rectangle for cell range rTargetRect = pDoc->GetMMRect( rTargetRange.aStart.Col(), rTargetRange.aStart.Row(), rTargetRange.aEnd.Col(), rTargetRange.aEnd.Row(), rTargetRange.aStart.Tab() ); } return bRangeValid; } BOOL ScModelObj::FillRenderMarkData( const uno::Any& aSelection, ScMarkData& rMark, ScPrintSelectionStatus& rStatus ) const { DBG_ASSERT( !rMark.IsMarked() && !rMark.IsMultiMarked(), "FillRenderMarkData: MarkData must be empty" ); DBG_ASSERT( pDocShell, "FillRenderMarkData: DocShell must be set" ); BOOL bDone = FALSE; uno::Reference xInterface(aSelection, uno::UNO_QUERY); if ( xInterface.is() ) { ScCellRangesBase* pSelObj = ScCellRangesBase::getImplementation( xInterface ); if ( pSelObj && pSelObj->GetDocShell() == pDocShell ) { BOOL bSheet = ( ScTableSheetObj::getImplementation( xInterface ) != NULL ); BOOL bCursor = pSelObj->IsCursorOnly(); const ScRangeList& rRanges = pSelObj->GetRangeList(); rMark.MarkFromRangeList( rRanges, FALSE ); rMark.MarkToSimple(); if ( rMark.IsMarked() && !rMark.IsMultiMarked() ) { // a sheet object is treated like an empty selection: print the used area of the sheet if ( bCursor || bSheet ) // nothing selected -> use whole tables { rMark.ResetMark(); // doesn't change table selection rStatus.SetMode( SC_PRINTSEL_CURSOR ); } else rStatus.SetMode( SC_PRINTSEL_RANGE ); rStatus.SetRanges( rRanges ); bDone = TRUE; } // multi selection isn't supported } else if ( ScModelObj::getImplementation( xInterface ) == this ) { // render the whole document // -> no selection, all sheets SCTAB nTabCount = pDocShell->GetDocument()->GetTableCount(); for (SCTAB nTab = 0; nTab < nTabCount; nTab++) rMark.SelectTable( nTab, TRUE ); rStatus.SetMode( SC_PRINTSEL_DOCUMENT ); bDone = TRUE; } // other selection types aren't supported } return bDone; } sal_Int32 SAL_CALL ScModelObj::getRendererCount( const uno::Any& aSelection, const uno::Sequence& xOptions ) throw (lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScMarkData aMark; ScPrintSelectionStatus aStatus; if ( !FillRenderMarkData( aSelection, aMark, aStatus ) ) return 0; // The same ScPrintFuncCache object in pPrintFuncCache is used as long as // the same selection is used (aStatus) and the document isn't changed // (pPrintFuncCache is cleared in Notify handler) if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) ) { delete pPrintFuncCache; pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus ); } return pPrintFuncCache->GetPageCount(); } uno::Sequence SAL_CALL ScModelObj::getRenderer( sal_Int32 nRenderer, const uno::Any& aSelection, const uno::Sequence& xOptions ) throw (lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScMarkData aMark; ScPrintSelectionStatus aStatus; if ( !FillRenderMarkData( aSelection, aMark, aStatus ) ) throw lang::IllegalArgumentException(); if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) ) { delete pPrintFuncCache; pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus ); } long nTotalPages = pPrintFuncCache->GetPageCount(); if ( nRenderer >= nTotalPages ) throw lang::IllegalArgumentException(); // printer is used as device (just for page layout), draw view is not needed SCTAB nTab = pPrintFuncCache->GetTabForPage( nRenderer ); ScRange aRange; const ScRange* pSelRange = NULL; if ( aMark.IsMarked() ) { aMark.GetMarkArea( aRange ); pSelRange = &aRange; } ScPrintFunc aFunc( pDocShell, pDocShell->GetPrinter(), nTab, pPrintFuncCache->GetFirstAttr(nTab), nTotalPages, pSelRange ); aFunc.SetRenderFlag( TRUE ); Range aPageRange( nRenderer+1, nRenderer+1 ); MultiSelection aPage( aPageRange ); aPage.SetTotalRange( Range(0,RANGE_MAX) ); aPage.Select( aPageRange ); long nDisplayStart = pPrintFuncCache->GetDisplayStart( nTab ); long nTabStart = pPrintFuncCache->GetTabStart( nTab ); long nPrinted = aFunc.DoPrint( aPage, nTabStart, nDisplayStart, FALSE, NULL, NULL ); ScRange aCellRange; BOOL bWasCellRange = aFunc.GetLastSourceRange( aCellRange ); Size aTwips = aFunc.GetPageSize(); awt::Size aPageSize( TwipsToHMM( aTwips.Width() ), TwipsToHMM( aTwips.Height() ) ); long nPropCount = bWasCellRange ? 2 : 1; uno::Sequence aSequence(nPropCount); beans::PropertyValue* pArray = aSequence.getArray(); pArray[0].Name = rtl::OUString::createFromAscii( SC_UNONAME_PAGESIZE ); pArray[0].Value <<= aPageSize; if ( bWasCellRange ) { table::CellRangeAddress aRangeAddress( nTab, aCellRange.aStart.Col(), aCellRange.aStart.Row(), aCellRange.aEnd.Col(), aCellRange.aEnd.Row() ); pArray[1].Name = rtl::OUString::createFromAscii( SC_UNONAME_SOURCERANGE ); pArray[1].Value <<= aRangeAddress; } return aSequence; } void SAL_CALL ScModelObj::render( sal_Int32 nRenderer, const uno::Any& aSelection, const uno::Sequence& rOptions ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScMarkData aMark; ScPrintSelectionStatus aStatus; if ( !FillRenderMarkData( aSelection, aMark, aStatus ) ) throw lang::IllegalArgumentException(); if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) ) { delete pPrintFuncCache; pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus ); } long nTotalPages = pPrintFuncCache->GetPageCount(); if ( nRenderer >= nTotalPages ) throw lang::IllegalArgumentException(); OutputDevice* pDev = lcl_GetRenderDevice( rOptions ); if ( !pDev ) throw lang::IllegalArgumentException(); SCTAB nTab = pPrintFuncCache->GetTabForPage( nRenderer ); ScDocument* pDoc = pDocShell->GetDocument(); FmFormView* pDrawView = NULL; Rectangle aFull( 0, 0, LONG_MAX, LONG_MAX ); // #114135# ScDrawLayer* pModel = pDoc->GetDrawLayer(); if( pModel ) { pDrawView = new FmFormView( pModel, pDev ); pDrawView->ShowPagePgNum( static_cast(nTab), Point() ); pDrawView->SetPrintPreview( TRUE ); } ScRange aRange; const ScRange* pSelRange = NULL; if ( aMark.IsMarked() ) { aMark.GetMarkArea( aRange ); pSelRange = &aRange; } // to increase performance, ScPrintState might be used here for subsequent // pages of the same sheet ScPrintFunc aFunc( pDev, pDocShell, nTab, pPrintFuncCache->GetFirstAttr(nTab), nTotalPages, pSelRange ); aFunc.SetDrawView( pDrawView ); aFunc.SetRenderFlag( TRUE ); Range aPageRange( nRenderer+1, nRenderer+1 ); MultiSelection aPage( aPageRange ); aPage.SetTotalRange( Range(0,RANGE_MAX) ); aPage.Select( aPageRange ); long nDisplayStart = pPrintFuncCache->GetDisplayStart( nTab ); long nTabStart = pPrintFuncCache->GetTabStart( nTab ); if ( nRenderer == nTabStart ) { // first page of a sheet: add outline item for the sheet name vcl::PDFExtOutDevData* pPDFData = PTR_CAST( vcl::PDFExtOutDevData, pDev->GetExtOutDevData() ); if ( pPDFData ) { // the sheet starts at the top of the page Rectangle aArea( pDev->PixelToLogic( Rectangle( 0,0,0,0 ) ) ); sal_Int32 nDestID = pPDFData->CreateDest( aArea ); String aTabName; pDoc->GetName( nTab, aTabName ); sal_Int32 nParent = -1; // top-level pPDFData->CreateOutlineItem( nParent, aTabName, nDestID ); } } long nPrinted = aFunc.DoPrint( aPage, nTabStart, nDisplayStart, TRUE, NULL, NULL ); // resolve the hyperlinks for PDF export vcl::PDFExtOutDevData* pPDFData = PTR_CAST( vcl::PDFExtOutDevData, pDev->GetExtOutDevData() ); if ( pPDFData ) { // iterate over the hyperlinks that were output for this page std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFData->GetBookmarks(); std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIter = rBookmarks.begin(); std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIEnd = rBookmarks.end(); while ( aIter != aIEnd ) { rtl::OUString aBookmark = aIter->aBookmark; if ( aBookmark.toChar() == (sal_Unicode) '#' ) { // try to resolve internal link String aTarget( aBookmark.copy( 1 ) ); ScRange aTargetRange; Rectangle aTargetRect; // 1/100th mm bool bIsSheet = false; bool bValid = lcl_ParseTarget( aTarget, aTargetRange, aTargetRect, bIsSheet, pDoc, nTab ); if ( bValid ) { sal_Int32 nPage = -1; Rectangle aArea; if ( bIsSheet ) { // Get first page for sheet (if nothing from that sheet is printed, // this page can show a different sheet) nPage = pPrintFuncCache->GetTabStart( aTargetRange.aStart.Tab() ); aArea = pDev->PixelToLogic( Rectangle( 0,0,0,0 ) ); } else { pPrintFuncCache->InitLocations( aMark, pDev ); // does nothing if already initialized ScPrintPageLocation aLocation; if ( pPrintFuncCache->FindLocation( aTargetRange.aStart, aLocation ) ) { nPage = aLocation.nPage; // get the rectangle of the page's cell range in 1/100th mm ScRange aLocRange = aLocation.aCellRange; Rectangle aLocationMM = pDoc->GetMMRect( aLocRange.aStart.Col(), aLocRange.aStart.Row(), aLocRange.aEnd.Col(), aLocRange.aEnd.Row(), aLocRange.aStart.Tab() ); Rectangle aLocationPixel = aLocation.aRectangle; // Scale and move the target rectangle from aLocationMM to aLocationPixel, // to get the target rectangle in pixels. Fraction aScaleX( aLocationPixel.GetWidth(), aLocationMM.GetWidth() ); Fraction aScaleY( aLocationPixel.GetHeight(), aLocationMM.GetHeight() ); long nX1 = aLocationPixel.Left() + (long) ( Fraction( aTargetRect.Left() - aLocationMM.Left(), 1 ) * aScaleX ); long nX2 = aLocationPixel.Left() + (long) ( Fraction( aTargetRect.Right() - aLocationMM.Left(), 1 ) * aScaleX ); long nY1 = aLocationPixel.Top() + (long) ( Fraction( aTargetRect.Top() - aLocationMM.Top(), 1 ) * aScaleY ); long nY2 = aLocationPixel.Top() + (long) ( Fraction( aTargetRect.Bottom() - aLocationMM.Top(), 1 ) * aScaleY ); if ( nX1 > aLocationPixel.Right() ) nX1 = aLocationPixel.Right(); if ( nX2 > aLocationPixel.Right() ) nX2 = aLocationPixel.Right(); if ( nY1 > aLocationPixel.Bottom() ) nY1 = aLocationPixel.Bottom(); if ( nY2 > aLocationPixel.Bottom() ) nY2 = aLocationPixel.Bottom(); // The link target area is interpreted using the device's MapMode at // the time of the CreateDest call, so PixelToLogic can be used here, // regardless of the MapMode that is actually selected. aArea = pDev->PixelToLogic( Rectangle( nX1, nY1, nX2, nY2 ) ); } } if ( nPage >= 0 ) pPDFData->SetLinkDest( aIter->nLinkId, pPDFData->CreateDest( aArea, nPage ) ); } } else { // external link, use as-is pPDFData->SetLinkURL( aIter->nLinkId, aBookmark ); } aIter++; } rBookmarks.clear(); } delete pDrawView; } // XLinkTargetSupplier uno::Reference SAL_CALL ScModelObj::getLinks() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScLinkTargetTypesObj(pDocShell); return NULL; } // XActionLockable sal_Bool SAL_CALL ScModelObj::isActionLocked() throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bLocked = FALSE; if (pDocShell) bLocked = ( pDocShell->GetLockCount() != 0 ); return bLocked; } void SAL_CALL ScModelObj::addActionLock() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) pDocShell->LockDocument(); } void SAL_CALL ScModelObj::removeActionLock() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) pDocShell->UnlockDocument(); } void SAL_CALL ScModelObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) pDocShell->SetLockCount(nLock); } sal_Int16 SAL_CALL ScModelObj::resetActionLocks() throw(uno::RuntimeException) { ScUnoGuard aGuard; USHORT nRet = 0; if (pDocShell) { nRet = pDocShell->GetLockCount(); pDocShell->SetLockCount(0); } return nRet; } void SAL_CALL ScModelObj::lockControllers() throw (::com::sun::star::uno::RuntimeException) { ScUnoGuard aGuard; SfxBaseModel::lockControllers(); if (pDocShell) pDocShell->LockPaint(); } void SAL_CALL ScModelObj::unlockControllers() throw (::com::sun::star::uno::RuntimeException) { ScUnoGuard aGuard; if (hasControllersLocked()) { SfxBaseModel::unlockControllers(); if (pDocShell) pDocShell->UnlockPaint(); } } // XCalculate void SAL_CALL ScModelObj::calculate() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) pDocShell->DoRecalc(TRUE); else DBG_ERROR("keine DocShell"); //! Exception oder so? } void SAL_CALL ScModelObj::calculateAll() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) pDocShell->DoHardRecalc(TRUE); else DBG_ERROR("keine DocShell"); //! Exception oder so? } sal_Bool SAL_CALL ScModelObj::isAutomaticCalculationEnabled() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return pDocShell->GetDocument()->GetAutoCalc(); DBG_ERROR("keine DocShell"); //! Exception oder so? return FALSE; } void SAL_CALL ScModelObj::enableAutomaticCalculation( sal_Bool bEnabled ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); if ( pDoc->GetAutoCalc() != bEnabled ) { pDoc->SetAutoCalc( bEnabled ); pDocShell->SetDocumentModified(); } } else DBG_ERROR("keine DocShell"); //! Exception oder so? } // XProtectable void SAL_CALL ScModelObj::protect( const rtl::OUString& aPassword ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { String aString(aPassword); ScDocFunc aFunc(*pDocShell); aFunc.Protect( TABLEID_DOC, aString, TRUE ); } } void SAL_CALL ScModelObj::unprotect( const rtl::OUString& aPassword ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { String aString(aPassword); ScDocFunc aFunc(*pDocShell); aFunc.Unprotect( TABLEID_DOC, aString, TRUE ); //! Rueckgabewert auswerten, Exception oder so } } sal_Bool SAL_CALL ScModelObj::isProtected() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return pDocShell->GetDocument()->IsDocProtected(); DBG_ERROR("keine DocShell"); //! Exception oder so? return FALSE; } // XDrawPagesSupplier uno::Reference SAL_CALL ScModelObj::getDrawPages() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScDrawPagesObj(pDocShell); DBG_ERROR("keine DocShell"); //! Exception oder so? return NULL; } #if 0 // XPrintable rtl::OUString ScModelObj::getPrinterName(void) const { ScUnoGuard aGuard; if (pDocShell) { SfxPrinter* pPrinter = pDocShell->GetPrinter(); if (pPrinter) return pPrinter->GetName(); } DBG_ERROR("getPrinterName: keine DocShell oder kein Printer"); return rtl::OUString(); } void ScModelObj::setPrinterName(const rtl::OUString& PrinterName) { ScUnoGuard aGuard; // Drucker setzen - wie in SfxViewShell::ExecPrint_Impl if (pDocShell) { SfxPrinter* pPrinter = pDocShell->GetPrinter(); if (pPrinter) { String aString(PrinterName); SfxPrinter* pNewPrinter = new SfxPrinter( pPrinter->GetOptions().Clone(), aString ); if (pNewPrinter->IsKnown()) pDocShell->SetPrinter( pNewPrinter, SFX_PRINTER_PRINTER ); else delete pNewPrinter; } } } XPropertySetRef ScModelObj::createPrintOptions(void) { ScUnoGuard aGuard; return new ScPrintSettingsObj; //! ScPrintSettingsObj implementieren! } void ScModelObj::print(const XPropertySetRef& xOptions) { ScUnoGuard aGuard; if (pDocShell) { //! xOptions auswerten (wie denn?) //! muss noch } } #endif // XGoalSeek sheet::GoalResult SAL_CALL ScModelObj::seekGoal( const table::CellAddress& aFormulaPosition, const table::CellAddress& aVariablePosition, const ::rtl::OUString& aGoalValue ) throw(uno::RuntimeException) { ScUnoGuard aGuard; sheet::GoalResult aResult; aResult.Divergence = DBL_MAX; // nichts gefunden if (pDocShell) { WaitObject aWait( pDocShell->GetDialogParent() ); String aGoalString(aGoalValue); ScDocument* pDoc = pDocShell->GetDocument(); double fValue = 0.0; BOOL bFound = pDoc->Solver( (SCCOL)aFormulaPosition.Column, (SCROW)aFormulaPosition.Row, aFormulaPosition.Sheet, (SCCOL)aVariablePosition.Column, (SCROW)aVariablePosition.Row, aVariablePosition.Sheet, aGoalString, fValue ); aResult.Result = fValue; if (bFound) aResult.Divergence = 0.0; //! das ist gelogen } return aResult; } // XConsolidatable uno::Reference SAL_CALL ScModelObj::createConsolidationDescriptor( sal_Bool bEmpty ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScConsolidationDescriptor* pNew = new ScConsolidationDescriptor; if ( pDocShell && !bEmpty ) { ScDocument* pDoc = pDocShell->GetDocument(); const ScConsolidateParam* pParam = pDoc->GetConsolidateDlgData(); if (pParam) pNew->SetParam( *pParam ); } return pNew; } void SAL_CALL ScModelObj::consolidate( const uno::Reference& xDescriptor ) throw(uno::RuntimeException) { ScUnoGuard aGuard; // das koennte theoretisch ein fremdes Objekt sein, also nur das // oeffentliche XConsolidationDescriptor Interface benutzen, um // die Daten in ein ScConsolidationDescriptor Objekt zu kopieren: //! wenn es schon ein ScConsolidationDescriptor ist, direkt per getImplementation? ScConsolidationDescriptor aImpl; aImpl.setFunction( xDescriptor->getFunction() ); aImpl.setSources( xDescriptor->getSources() ); aImpl.setStartOutputPosition( xDescriptor->getStartOutputPosition() ); aImpl.setUseColumnHeaders( xDescriptor->getUseColumnHeaders() ); aImpl.setUseRowHeaders( xDescriptor->getUseRowHeaders() ); aImpl.setInsertLinks( xDescriptor->getInsertLinks() ); if (pDocShell) { const ScConsolidateParam& rParam = aImpl.GetParam(); pDocShell->DoConsolidate( rParam, TRUE ); pDocShell->GetDocument()->SetConsolidateDlgData( &rParam ); } } // XDocumentAuditing void SAL_CALL ScModelObj::refreshArrows() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocFunc aFunc(*pDocShell); aFunc.DetectiveRefresh(); } } // XViewDataSupplier uno::Reference< container::XIndexAccess > SAL_CALL ScModelObj::getViewData( ) throw (uno::RuntimeException) { uno::Reference < container::XIndexAccess > xRet( SfxBaseModel::getViewData() ); if( !xRet.is() ) { ScUnoGuard aGuard; if (pDocShell && pDocShell->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED) { xRet.set(uno::Reference < container::XIndexAccess >::query(::comphelper::getProcessServiceFactory()->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.IndexedPropertyValues"))))); uno::Reference < container::XIndexContainer > xCont( xRet, uno::UNO_QUERY ); DBG_ASSERT( xCont.is(), "ScModelObj::getViewData() failed for OLE object" ); if( xCont.is() ) { uno::Sequence< beans::PropertyValue > aSeq; aSeq.realloc(1); String sName; pDocShell->GetDocument()->GetName( pDocShell->GetDocument()->GetVisibleTab(), sName ); rtl::OUString sOUName(sName); aSeq[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_ACTIVETABLE)); aSeq[0].Value <<= sOUName; xCont->insertByIndex( 0, uno::makeAny( aSeq ) ); } } } return xRet; } // XPropertySet (Doc-Optionen) //! auch an der Applikation anbieten? uno::Reference SAL_CALL ScModelObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef( new SfxItemPropertySetInfo( aPropSet.getPropertyMap() )); return aRef; } void SAL_CALL ScModelObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aString(aPropertyName); if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); const ScDocOptions& rOldOpt = pDoc->GetDocOptions(); ScDocOptions aNewOpt = rOldOpt; BOOL bOpt = ScDocOptionsHelper::setPropertyValue( aNewOpt, aPropertyName, aValue ); if (bOpt) { // done... } else if ( aString.EqualsAscii( SC_UNONAME_CLOCAL ) ) { lang::Locale aLocale; if ( aValue >>= aLocale ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); eLatin = ScUnoConversion::GetLanguage(aLocale); pDoc->SetLanguage( eLatin, eCjk, eCtl ); } } else if ( aString.EqualsAscii( SC_UNO_CJK_CLOCAL ) ) { lang::Locale aLocale; if ( aValue >>= aLocale ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); eCjk = ScUnoConversion::GetLanguage(aLocale); pDoc->SetLanguage( eLatin, eCjk, eCtl ); } } else if ( aString.EqualsAscii( SC_UNO_CTL_CLOCAL ) ) { lang::Locale aLocale; if ( aValue >>= aLocale ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); eCtl = ScUnoConversion::GetLanguage(aLocale); pDoc->SetLanguage( eLatin, eCjk, eCtl ); } } else if ( aString.EqualsAscii( SC_UNO_APPLYFMDES ) ) { // model is created if not there ScDrawLayer* pModel = pDocShell->MakeDrawLayer(); pModel->SetOpenInDesignMode( ScUnoHelpFunctions::GetBoolFromAny( aValue ) ); SfxBindings* pBindings = pDocShell->GetViewBindings(); if (pBindings) pBindings->Invalidate( SID_FM_OPEN_READONLY ); } else if ( aString.EqualsAscii( SC_UNO_AUTOCONTFOC ) ) { // model is created if not there ScDrawLayer* pModel = pDocShell->MakeDrawLayer(); pModel->SetAutoControlFocus( ScUnoHelpFunctions::GetBoolFromAny( aValue ) ); SfxBindings* pBindings = pDocShell->GetViewBindings(); if (pBindings) pBindings->Invalidate( SID_FM_AUTOCONTROLFOCUS ); } else if ( aString.EqualsAscii( "BuildId" ) ) { aValue >>= maBuildId; } if ( aNewOpt != rOldOpt ) { pDoc->SetDocOptions( aNewOpt ); // Don't recalculate while loading XML, when the formula text is stored. // Recalculation after loading is handled separately. //! Recalc only for options that need it? if ( !pDoc->IsImportingXML() ) pDocShell->DoHardRecalc( TRUE ); pDocShell->SetDocumentModified(); } } } uno::Any SAL_CALL ScModelObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aString(aPropertyName); uno::Any aRet; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); const ScDocOptions& rOpt = pDoc->GetDocOptions(); aRet = ScDocOptionsHelper::getPropertyValue( rOpt, aPropertyName ); if ( aRet.hasValue() ) { // done... } else if ( aString.EqualsAscii( SC_UNONAME_CLOCAL ) ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); lang::Locale aLocale; ScUnoConversion::FillLocale( aLocale, eLatin ); aRet <<= aLocale; } else if ( aString.EqualsAscii( SC_UNO_CJK_CLOCAL ) ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); lang::Locale aLocale; ScUnoConversion::FillLocale( aLocale, eCjk ); aRet <<= aLocale; } else if ( aString.EqualsAscii( SC_UNO_CTL_CLOCAL ) ) { LanguageType eLatin, eCjk, eCtl; pDoc->GetLanguage( eLatin, eCjk, eCtl ); lang::Locale aLocale; ScUnoConversion::FillLocale( aLocale, eCtl ); aRet <<= aLocale; } else if ( aString.EqualsAscii( SC_UNO_NAMEDRANGES ) ) { aRet <<= uno::Reference(new ScNamedRangesObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_DATABASERNG ) ) { aRet <<= uno::Reference(new ScDatabaseRangesObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_COLLABELRNG ) ) { aRet <<= uno::Reference(new ScLabelRangesObj( pDocShell, TRUE )); } else if ( aString.EqualsAscii( SC_UNO_ROWLABELRNG ) ) { aRet <<= uno::Reference(new ScLabelRangesObj( pDocShell, FALSE )); } else if ( aString.EqualsAscii( SC_UNO_AREALINKS ) ) { aRet <<= uno::Reference(new ScAreaLinksObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_DDELINKS ) ) { aRet <<= uno::Reference(new ScDDELinksObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_SHEETLINKS ) ) { aRet <<= uno::Reference(new ScSheetLinksObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_APPLYFMDES ) ) { // default for no model is TRUE ScDrawLayer* pModel = pDoc->GetDrawLayer(); sal_Bool bOpenInDesign = pModel ? pModel->GetOpenInDesignMode() : sal_True; ScUnoHelpFunctions::SetBoolInAny( aRet, bOpenInDesign ); } else if ( aString.EqualsAscii( SC_UNO_AUTOCONTFOC ) ) { // default for no model is FALSE ScDrawLayer* pModel = pDoc->GetDrawLayer(); sal_Bool bAutoControlFocus = pModel ? pModel->GetAutoControlFocus() : sal_False; ScUnoHelpFunctions::SetBoolInAny( aRet, bAutoControlFocus ); } else if ( aString.EqualsAscii( SC_UNO_FORBIDDEN ) ) { aRet <<= uno::Reference(new ScForbiddenCharsObj( pDocShell )); } else if ( aString.EqualsAscii( SC_UNO_HASDRAWPAGES ) ) { ScUnoHelpFunctions::SetBoolInAny( aRet, (pDocShell->GetDocument()->GetDrawLayer() != 0) ); } else if ( aString.EqualsAscii( SC_UNO_BASICLIBRARIES ) ) { aRet <<= pDocShell->GetBasicContainer(); } else if ( aString.EqualsAscii( SC_UNO_RUNTIMEUID ) ) { aRet <<= getRuntimeUID(); } else if ( aString.EqualsAscii( SC_UNO_HASVALIDSIGNATURES ) ) { aRet <<= hasValidSignatures(); } else if ( aString.EqualsAscii( "BuildId" ) ) { aRet <<= maBuildId; } } return aRet; } SC_IMPL_DUMMY_PROPERTY_LISTENER( ScModelObj ) // XMultiServiceFactory uno::Reference SAL_CALL ScModelObj::createInstance( const rtl::OUString& aServiceSpecifier ) throw(uno::Exception, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xRet; String aNameStr(aServiceSpecifier); USHORT nType = ScServiceProvider::GetProviderType(aNameStr); if ( nType != SC_SERVICE_INVALID ) { // drawing layer tables must be kept as long as the model is alive // return stored instance if already set switch ( nType ) { case SC_SERVICE_GRADTAB: xRet.set(xDrawGradTab); break; case SC_SERVICE_HATCHTAB: xRet.set(xDrawHatchTab); break; case SC_SERVICE_BITMAPTAB: xRet.set(xDrawBitmapTab); break; case SC_SERVICE_TRGRADTAB: xRet.set(xDrawTrGradTab); break; case SC_SERVICE_MARKERTAB: xRet.set(xDrawMarkerTab); break; case SC_SERVICE_DASHTAB: xRet.set(xDrawDashTab); break; case SC_SERVICE_CHDATAPROV: xRet.set(xChartDataProv); break; } if ( !xRet.is() ) { xRet.set(ScServiceProvider::MakeInstance( nType, pDocShell )); // store created instance switch ( nType ) { case SC_SERVICE_GRADTAB: xDrawGradTab.set(xRet); break; case SC_SERVICE_HATCHTAB: xDrawHatchTab.set(xRet); break; case SC_SERVICE_BITMAPTAB: xDrawBitmapTab.set(xRet); break; case SC_SERVICE_TRGRADTAB: xDrawTrGradTab.set(xRet); break; case SC_SERVICE_MARKERTAB: xDrawMarkerTab.set(xRet); break; case SC_SERVICE_DASHTAB: xDrawDashTab.set(xRet); break; case SC_SERVICE_CHDATAPROV: xChartDataProv.set(xRet); break; } } } else { // alles was ich nicht kenn, werf ich der SvxFmMSFactory an den Hals, // da wird dann 'ne Exception geworfen, wenn's nicht passt... { xRet.set(SvxFmMSFactory::createInstance(aServiceSpecifier)); // extra block to force deletion of the temporary before ScShapeObj ctor (setDelegator) } // #96117# if the drawing factory created a shape, a ScShapeObj has to be used // to support own properties like ImageMap: uno::Reference xShape( xRet, uno::UNO_QUERY ); if ( xShape.is() ) { xRet.clear(); // for aggregation, xShape must be the object's only ref new ScShapeObj( xShape ); // aggregates object and modifies xShape xRet.set(xShape); } } return xRet; } uno::Reference SAL_CALL ScModelObj::createInstanceWithArguments( const rtl::OUString& ServiceSpecifier, const uno::Sequence& aArgs ) throw(uno::Exception, uno::RuntimeException) { //! unterscheiden zwischen eigenen Services und denen vom Drawing-Layer? ScUnoGuard aGuard; uno::Reference xInt(createInstance(ServiceSpecifier)); if ( aArgs.getLength() ) { // used only for cell value binding so far - it can be initialized after creating uno::Reference xInit( xInt, uno::UNO_QUERY ); if ( xInit.is() ) xInit->initialize( aArgs ); } return xInt; } uno::Sequence SAL_CALL ScModelObj::getAvailableServiceNames() throw(uno::RuntimeException) { ScUnoGuard aGuard; //! warum sind die Parameter bei concatServiceNames nicht const ??? //! return concatServiceNames( ScServiceProvider::GetAllServiceNames(), //! SvxFmMSFactory::getAvailableServiceNames() ); uno::Sequence aMyServices(ScServiceProvider::GetAllServiceNames()); uno::Sequence aDrawServices(SvxFmMSFactory::getAvailableServiceNames()); return concatServiceNames( aMyServices, aDrawServices ); } // XServiceInfo rtl::OUString SAL_CALL ScModelObj::getImplementationName() throw(uno::RuntimeException) { return rtl::OUString::createFromAscii( "ScModelObj" ); } sal_Bool SAL_CALL ScModelObj::supportsService( const rtl::OUString& rServiceName ) throw(uno::RuntimeException) { String aServiceStr(rServiceName); return aServiceStr.EqualsAscii( SCMODELOBJ_SERVICE ) || aServiceStr.EqualsAscii( SCDOCSETTINGS_SERVICE ) || aServiceStr.EqualsAscii( SCDOC_SERVICE ); } uno::Sequence SAL_CALL ScModelObj::getSupportedServiceNames() throw(uno::RuntimeException) { uno::Sequence aRet(2); rtl::OUString* pArray = aRet.getArray(); pArray[0] = rtl::OUString::createFromAscii( SCMODELOBJ_SERVICE ); pArray[1] = rtl::OUString::createFromAscii( SCDOCSETTINGS_SERVICE ); return aRet; } // XUnoTunnel sal_Int64 SAL_CALL ScModelObj::getSomething( const uno::Sequence& rId ) throw(uno::RuntimeException) { if ( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) { return (sal_Int64)this; } // aggregated number formats supplier has XUnoTunnel, too // interface from aggregated object must be obtained via queryAggregation sal_Int64 nRet = SfxBaseModel::getSomething( rId ); if ( nRet ) return nRet; if ( xNumberAgg.is() ) { const uno::Type& rTunnelType = ::getCppuType((uno::Reference*) 0); uno::Any aNumTunnel(xNumberAgg->queryAggregation(rTunnelType)); if(aNumTunnel.getValueType() == rTunnelType) { uno::Reference xTunnelAgg( *(uno::Reference*)aNumTunnel.getValue()); return xTunnelAgg->getSomething( rId ); } } return 0; } // static const uno::Sequence& ScModelObj::getUnoTunnelId() { static uno::Sequence * pSeq = 0; if( !pSeq ) { osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); if( !pSeq ) { static uno::Sequence< sal_Int8 > aSeq( 16 ); rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); pSeq = &aSeq; } } return *pSeq; } // static ScModelObj* ScModelObj::getImplementation( const uno::Reference xObj ) { ScModelObj* pRet = NULL; uno::Reference xUT( xObj, uno::UNO_QUERY ); if (xUT.is()) pRet = (ScModelObj*) xUT->getSomething( getUnoTunnelId() ); return pRet; } //------------------------------------------------------------------------ ScDrawPagesObj::ScDrawPagesObj(ScDocShell* pDocSh) : pDocShell( pDocSh ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScDrawPagesObj::~ScDrawPagesObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScDrawPagesObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { // Referenz-Update interessiert hier nicht if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } uno::Reference ScDrawPagesObj::GetObjectByIndex_Impl(INT32 nIndex) const { if (pDocShell) { ScDrawLayer* pDrawLayer = pDocShell->MakeDrawLayer(); DBG_ASSERT(pDrawLayer,"kann Draw-Layer nicht anlegen"); if ( pDrawLayer && nIndex >= 0 && nIndex < pDocShell->GetDocument()->GetTableCount() ) { SdrPage* pPage = pDrawLayer->GetPage((USHORT)nIndex); DBG_ASSERT(pPage,"Draw-Page nicht gefunden"); if (pPage) { return uno::Reference (pPage->getUnoPage(), uno::UNO_QUERY); } } } return NULL; } // XDrawPages uno::Reference SAL_CALL ScDrawPagesObj::insertNewByIndex( sal_Int32 nPos ) throw(uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xRet; if (pDocShell) { String aNewName; pDocShell->GetDocument()->CreateValidTabName(aNewName); ScDocFunc aFunc(*pDocShell); if ( aFunc.InsertTable( (SCTAB)nPos, aNewName, TRUE, TRUE ) ) xRet.set(GetObjectByIndex_Impl( nPos )); } return xRet; } void SAL_CALL ScDrawPagesObj::remove( const uno::Reference& xPage ) throw(uno::RuntimeException) { ScUnoGuard aGuard; SvxDrawPage* pImp = SvxDrawPage::getImplementation( xPage ); if ( pDocShell && pImp ) { SdrPage* pPage = pImp->GetSdrPage(); if (pPage) { SCTAB nPageNum = static_cast(pPage->GetPageNum()); ScDocFunc aFunc(*pDocShell); aFunc.DeleteTable( nPageNum, TRUE, TRUE ); } } } // XIndexAccess sal_Int32 SAL_CALL ScDrawPagesObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return pDocShell->GetDocument()->GetTableCount(); return 0; } uno::Any SAL_CALL ScDrawPagesObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xPage(GetObjectByIndex_Impl(nIndex)); if (xPage.is()) return uno::makeAny(xPage); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScDrawPagesObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScDrawPagesObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } //------------------------------------------------------------------------ ScTableSheetsObj::ScTableSheetsObj(ScDocShell* pDocSh) : pDocShell( pDocSh ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScTableSheetsObj::~ScTableSheetsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScTableSheetsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { // Referenz-Update interessiert hier nicht if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XSpreadsheets ScTableSheetObj* ScTableSheetsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const { if ( pDocShell && nIndex < pDocShell->GetDocument()->GetTableCount() ) return new ScTableSheetObj( pDocShell, static_cast(nIndex) ); return NULL; } ScTableSheetObj* ScTableSheetsObj::GetObjectByName_Impl(const rtl::OUString& aName) const { if (pDocShell) { SCTAB nIndex; String aString(aName); if ( pDocShell->GetDocument()->GetTable( aString, nIndex ) ) return new ScTableSheetObj( pDocShell, nIndex ); } return NULL; } void SAL_CALL ScTableSheetsObj::insertNewByName( const rtl::OUString& aName, sal_Int16 nPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if (pDocShell) { String aNamStr(aName); ScDocFunc aFunc(*pDocShell); bDone = aFunc.InsertTable( nPosition, aNamStr, TRUE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } void SAL_CALL ScTableSheetsObj::moveByName( const rtl::OUString& aName, sal_Int16 nDestination ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if (pDocShell) { String aNamStr(aName); SCTAB nSource; if ( pDocShell->GetDocument()->GetTable( aNamStr, nSource ) ) bDone = pDocShell->MoveTable( nSource, nDestination, FALSE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } void SAL_CALL ScTableSheetsObj::copyByName( const rtl::OUString& aName, const rtl::OUString& aCopy, sal_Int16 nDestination ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if (pDocShell) { String aNamStr(aName); String aNewStr(aCopy); SCTAB nSource; if ( pDocShell->GetDocument()->GetTable( aNamStr, nSource ) ) { bDone = pDocShell->MoveTable( nSource, nDestination, TRUE, TRUE ); if (bDone) { ScDocFunc aFunc(*pDocShell); bDone = aFunc.RenameTable( nDestination, aNewStr, TRUE, TRUE ); } } } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } void SAL_CALL ScTableSheetsObj::insertByName( const rtl::OUString& aName, const uno::Any& aElement ) throw(lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; BOOL bIllArg = FALSE; //! Type of aElement can be some specific interface instead of XInterface if ( pDocShell ) { uno::Reference xInterface(aElement, uno::UNO_QUERY); if ( xInterface.is() ) { ScTableSheetObj* pSheetObj = ScTableSheetObj::getImplementation( xInterface ); if ( pSheetObj && !pSheetObj->GetDocShell() ) // noch nicht eingefuegt? { ScDocument* pDoc = pDocShell->GetDocument(); String aNamStr(aName); SCTAB nDummy; if ( pDoc->GetTable( aNamStr, nDummy ) ) { // name already exists throw container::ElementExistException(); } else { SCTAB nPosition = pDoc->GetTableCount(); ScDocFunc aFunc(*pDocShell); bDone = aFunc.InsertTable( nPosition, aNamStr, TRUE, TRUE ); if (bDone) pSheetObj->InitInsertSheet( pDocShell, nPosition ); // Dokument und neuen Range am Objekt setzen } } else bIllArg = TRUE; } else bIllArg = TRUE; } if (!bDone) { if (bIllArg) throw lang::IllegalArgumentException(); else throw uno::RuntimeException(); // ElementExistException is handled above } } void SAL_CALL ScTableSheetsObj::replaceByName( const rtl::OUString& aName, const uno::Any& aElement ) throw(lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; BOOL bIllArg = FALSE; //! Type of aElement can be some specific interface instead of XInterface if ( pDocShell ) { uno::Reference xInterface(aElement, uno::UNO_QUERY); if ( xInterface.is() ) { ScTableSheetObj* pSheetObj = ScTableSheetObj::getImplementation( xInterface ); if ( pSheetObj && !pSheetObj->GetDocShell() ) // noch nicht eingefuegt? { String aNamStr(aName); SCTAB nPosition; if ( pDocShell->GetDocument()->GetTable( aNamStr, nPosition ) ) { ScDocFunc aFunc(*pDocShell); if ( aFunc.DeleteTable( nPosition, TRUE, TRUE ) ) { // InsertTable kann jetzt eigentlich nicht schiefgehen... bDone = aFunc.InsertTable( nPosition, aNamStr, TRUE, TRUE ); if (bDone) pSheetObj->InitInsertSheet( pDocShell, nPosition ); } } else { // not found throw container::NoSuchElementException(); } } else bIllArg = TRUE; } else bIllArg = TRUE; } if (!bDone) { if (bIllArg) throw lang::IllegalArgumentException(); else throw uno::RuntimeException(); // NoSuchElementException is handled above } } void SAL_CALL ScTableSheetsObj::removeByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if (pDocShell) { SCTAB nIndex; String aString(aName); if ( pDocShell->GetDocument()->GetTable( aString, nIndex ) ) { ScDocFunc aFunc(*pDocShell); bDone = aFunc.DeleteTable( nIndex, TRUE, TRUE ); } else { // not found throw container::NoSuchElementException(); } } if (!bDone) throw uno::RuntimeException(); // NoSuchElementException is handled above } // XEnumerationAccess uno::Reference SAL_CALL ScTableSheetsObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SpreadsheetsEnumeration"))); } // XIndexAccess sal_Int32 SAL_CALL ScTableSheetsObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return pDocShell->GetDocument()->GetTableCount(); return 0; } uno::Any SAL_CALL ScTableSheetsObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xSheet(GetObjectByIndex_Impl(nIndex)); if (xSheet.is()) return uno::makeAny(xSheet); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScTableSheetsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScTableSheetsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } // XNameAccess uno::Any SAL_CALL ScTableSheetsObj::getByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xSheet(GetObjectByName_Impl(aName)); if (xSheet.is()) return uno::makeAny(xSheet); else throw container::NoSuchElementException(); return uno::Any(); } uno::Sequence SAL_CALL ScTableSheetsObj::getElementNames() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); SCTAB nCount = pDoc->GetTableCount(); String aName; uno::Sequence aSeq(nCount); rtl::OUString* pAry = aSeq.getArray(); for (SCTAB i=0; iGetName( i, aName ); pAry[i] = aName; } return aSeq; } return uno::Sequence(); } sal_Bool SAL_CALL ScTableSheetsObj::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { SCTAB nIndex; if ( pDocShell->GetDocument()->GetTable( String(aName), nIndex ) ) return TRUE; } return FALSE; } //------------------------------------------------------------------------ ScTableColumnsObj::ScTableColumnsObj(ScDocShell* pDocSh, SCTAB nT, SCCOL nSC, SCCOL nEC) : pDocShell( pDocSh ), nTab ( nT ), nStartCol( nSC ), nEndCol ( nEC ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScTableColumnsObj::~ScTableColumnsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScTableColumnsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; //! Referenz-Update fuer Tab und Start/Ende } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XTableColumns ScTableColumnObj* ScTableColumnsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const { SCCOL nCol = static_cast(nIndex) + nStartCol; if ( pDocShell && nCol <= nEndCol ) return new ScTableColumnObj( pDocShell, nCol, nTab ); return NULL; // falscher Index } ScTableColumnObj* ScTableColumnsObj::GetObjectByName_Impl(const rtl::OUString& aName) const { SCCOL nCol = 0; String aString(aName); if ( ::AlphaToCol( nCol, aString) ) if ( pDocShell && nCol >= nStartCol && nCol <= nEndCol ) return new ScTableColumnObj( pDocShell, nCol, nTab ); return NULL; } void SAL_CALL ScTableColumnsObj::insertByIndex( sal_Int32 nPosition, sal_Int32 nCount ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if ( pDocShell && nCount > 0 && nPosition >= 0 && nStartCol+nPosition <= nEndCol && nStartCol+nPosition+nCount-1 <= MAXCOL ) { ScDocFunc aFunc(*pDocShell); ScRange aRange( (SCCOL)(nStartCol+nPosition), 0, nTab, (SCCOL)(nStartCol+nPosition+nCount-1), MAXROW, nTab ); bDone = aFunc.InsertCells( aRange, INS_INSCOLS, TRUE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } void SAL_CALL ScTableColumnsObj::removeByIndex( sal_Int32 nIndex, sal_Int32 nCount ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; // Der zu loeschende Bereich muss innerhalb des Objekts liegen if ( pDocShell && nCount > 0 && nIndex >= 0 && nStartCol+nIndex+nCount-1 <= nEndCol ) { ScDocFunc aFunc(*pDocShell); ScRange aRange( (SCCOL)(nStartCol+nIndex), 0, nTab, (SCCOL)(nStartCol+nIndex+nCount-1), MAXROW, nTab ); bDone = aFunc.DeleteCells( aRange, DEL_DELCOLS, TRUE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } // XEnumerationAccess uno::Reference SAL_CALL ScTableColumnsObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.table.TableColumnsEnumeration"))); } // XIndexAccess sal_Int32 SAL_CALL ScTableColumnsObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; return nEndCol - nStartCol + 1; } uno::Any SAL_CALL ScTableColumnsObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xColumn(GetObjectByIndex_Impl(nIndex)); if (xColumn.is()) return uno::makeAny(xColumn); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScTableColumnsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScTableColumnsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } uno::Any SAL_CALL ScTableColumnsObj::getByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xColumn(GetObjectByName_Impl(aName)); if (xColumn.is()) return uno::makeAny(xColumn); else throw container::NoSuchElementException(); return uno::Any(); } uno::Sequence SAL_CALL ScTableColumnsObj::getElementNames() throw(uno::RuntimeException) { ScUnoGuard aGuard; SCCOL nCount = nEndCol - nStartCol + 1; uno::Sequence aSeq(nCount); rtl::OUString* pAry = aSeq.getArray(); for (SCCOL i=0; i= nStartCol && nCol <= nEndCol ) return TRUE; return FALSE; // nicht gefunden } // XPropertySet uno::Reference SAL_CALL ScTableColumnsObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef( new SfxItemPropertySetInfo( lcl_GetColumnsPropertyMap() )); return aRef; } void SAL_CALL ScTableColumnsObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScDocFunc aFunc(*pDocShell); ScDocument* pDoc = pDocShell->GetDocument(); SCCOLROW nColArr[2]; nColArr[0] = nStartCol; nColArr[1] = nEndCol; String aNameString(aPropertyName); if ( aNameString.EqualsAscii( SC_UNONAME_CELLWID ) ) { sal_Int32 nNewWidth; if ( aValue >>= nNewWidth ) aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, SC_SIZE_ORIGINAL, (USHORT)HMMToTwips(nNewWidth), TRUE, TRUE ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, eMode, 0, TRUE, TRUE ); // SC_SIZE_DIRECT with size 0: hide } else if ( aNameString.EqualsAscii( SC_UNONAME_OWIDTH ) ) { BOOL bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bOpt) aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, TRUE, TRUE ); // FALSE for columns currently has no effect } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) || aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { //! single function to set/remove all breaks? BOOL bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++) if (bSet) aFunc.InsertPageBreak( TRUE, ScAddress(nCol,0,nTab), TRUE, TRUE, TRUE ); else aFunc.RemovePageBreak( TRUE, ScAddress(nCol,0,nTab), TRUE, TRUE, TRUE ); } } uno::Any SAL_CALL ScTableColumnsObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScDocument* pDoc = pDocShell->GetDocument(); String aNameString(aPropertyName); uno::Any aAny; //! loop over all columns for current state? if ( aNameString.EqualsAscii( SC_UNONAME_CELLWID ) ) { // for hidden column, return original height USHORT nWidth = pDoc->GetOriginalWidth( nStartCol, nTab ); aAny <<= (sal_Int32)TwipsToHMM(nWidth); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = !(pDoc->GetColFlags( nStartCol, nTab ) & CR_HIDDEN); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_OWIDTH ) ) { BOOL bOpt = !(pDoc->GetColFlags( nStartCol, nTab ) & CR_MANUALSIZE); ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt ); } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetColFlags( nStartCol, nTab ) & (CR_PAGEBREAK|CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else if ( aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetColFlags( nStartCol, nTab ) & (CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } return aAny; } SC_IMPL_DUMMY_PROPERTY_LISTENER( ScTableColumnsObj ) //------------------------------------------------------------------------ ScTableRowsObj::ScTableRowsObj(ScDocShell* pDocSh, SCTAB nT, SCROW nSR, SCROW nER) : pDocShell( pDocSh ), nTab ( nT ), nStartRow( nSR ), nEndRow ( nER ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScTableRowsObj::~ScTableRowsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScTableRowsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; //! Referenz-Update fuer Tab und Start/Ende } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XTableRows ScTableRowObj* ScTableRowsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const { SCROW nRow = static_cast(nIndex) + nStartRow; if ( pDocShell && nRow <= nEndRow ) return new ScTableRowObj( pDocShell, nRow, nTab ); return NULL; // falscher Index } void SAL_CALL ScTableRowsObj::insertByIndex( sal_Int32 nPosition, sal_Int32 nCount ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; if ( pDocShell && nCount > 0 && nPosition >= 0 && nStartRow+nPosition <= nEndRow && nStartRow+nPosition+nCount-1 <= MAXROW ) { ScDocFunc aFunc(*pDocShell); ScRange aRange( 0, (SCROW)(nStartRow+nPosition), nTab, MAXCOL, (SCROW)(nStartRow+nPosition+nCount-1), nTab ); bDone = aFunc.InsertCells( aRange, INS_INSROWS, TRUE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } void SAL_CALL ScTableRowsObj::removeByIndex( sal_Int32 nIndex, sal_Int32 nCount ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; // Der zu loeschende Bereich muss innerhalb des Objekts liegen if ( pDocShell && nCount > 0 && nIndex >= 0 && nStartRow+nIndex+nCount-1 <= nEndRow ) { ScDocFunc aFunc(*pDocShell); ScRange aRange( 0, (SCROW)(nStartRow+nIndex), nTab, MAXCOL, (SCROW)(nStartRow+nIndex+nCount-1), nTab ); bDone = aFunc.DeleteCells( aRange, DEL_DELROWS, TRUE, TRUE ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } // XEnumerationAccess uno::Reference SAL_CALL ScTableRowsObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.table.TableRowsEnumeration"))); } // XIndexAccess sal_Int32 SAL_CALL ScTableRowsObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; return nEndRow - nStartRow + 1; } uno::Any SAL_CALL ScTableRowsObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xRow(GetObjectByIndex_Impl(nIndex)); if (xRow.is()) return uno::makeAny(xRow); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScTableRowsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScTableRowsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } // XPropertySet uno::Reference SAL_CALL ScTableRowsObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef( new SfxItemPropertySetInfo( lcl_GetRowsPropertyMap() )); return aRef; } void SAL_CALL ScTableRowsObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScDocFunc aFunc(*pDocShell); ScDocument* pDoc = pDocShell->GetDocument(); SCCOLROW nRowArr[2]; nRowArr[0] = nStartRow; nRowArr[1] = nEndRow; String aNameString(aPropertyName); if ( aNameString.EqualsAscii( SC_UNONAME_CELLHGT ) ) { sal_Int32 nNewHeight; if ( aValue >>= nNewHeight ) aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, SC_SIZE_ORIGINAL, (USHORT)HMMToTwips(nNewHeight), TRUE, TRUE ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, eMode, 0, TRUE, TRUE ); // SC_SIZE_DIRECT with size 0: hide } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLFILT ) ) { //! undo etc. if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) pDoc->GetRowFlagsArrayModifiable( nTab).OrValue( nStartRow, nEndRow, CR_FILTERED); else pDoc->GetRowFlagsArrayModifiable( nTab).AndValue( nStartRow, nEndRow, ~CR_FILTERED); } else if ( aNameString.EqualsAscii( SC_UNONAME_OHEIGHT ) ) { BOOL bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bOpt) aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, SC_SIZE_OPTIMAL, 0, TRUE, TRUE ); else { //! manually set old heights again? } } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE) || aNameString.EqualsAscii( SC_UNONAME_MANPAGE) ) { //! single function to set/remove all breaks? BOOL bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++) if (bSet) aFunc.InsertPageBreak( FALSE, ScAddress(0,nRow,nTab), TRUE, TRUE, TRUE ); else aFunc.RemovePageBreak( FALSE, ScAddress(0,nRow,nTab), TRUE, TRUE, TRUE ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLBACK ) || aNameString.EqualsAscii( SC_UNONAME_CELLTRAN ) ) { // #i57867# Background color is specified for row styles in the file format, // so it has to be supported along with the row properties (import only). // Use ScCellRangeObj to set the property for all cells in the rows // (this means, the "row attribute" must be set before individual cell attributes). ScRange aRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ); uno::Reference xRangeObj = new ScCellRangeObj( pDocShell, aRange ); xRangeObj->setPropertyValue( aPropertyName, aValue ); } } uno::Any SAL_CALL ScTableRowsObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if (!pDocShell) throw uno::RuntimeException(); ScDocument* pDoc = pDocShell->GetDocument(); String aNameString(aPropertyName); uno::Any aAny; //! loop over all rows for current state? if ( aNameString.EqualsAscii( SC_UNONAME_CELLHGT ) ) { // for hidden row, return original height USHORT nHeight = pDoc->GetOriginalHeight( nStartRow, nTab ); aAny <<= (sal_Int32)TwipsToHMM(nHeight); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = !(pDoc->GetRowFlags( nStartRow, nTab ) & CR_HIDDEN); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLFILT ) ) { BOOL bVis = ((pDoc->GetRowFlags( nStartRow, nTab ) & CR_FILTERED) != 0); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_OHEIGHT ) ) { BOOL bOpt = !(pDoc->GetRowFlags( nStartRow, nTab ) & CR_MANUALSIZE); ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt ); } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetRowFlags( nStartRow, nTab ) & (CR_PAGEBREAK|CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else if ( aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetRowFlags( nStartRow, nTab ) & (CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLBACK ) || aNameString.EqualsAscii( SC_UNONAME_CELLTRAN ) ) { // Use ScCellRangeObj to get the property from the cell range // (for completeness only, this is not used by the XML filter). ScRange aRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ); uno::Reference xRangeObj = new ScCellRangeObj( pDocShell, aRange ); aAny = xRangeObj->getPropertyValue( aPropertyName ); } return aAny; } SC_IMPL_DUMMY_PROPERTY_LISTENER( ScTableRowsObj ) //------------------------------------------------------------------------ ScSpreadsheetSettingsObj::ScSpreadsheetSettingsObj(ScDocShell* pDocSh) : pDocShell( pDocSh ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScSpreadsheetSettingsObj::~ScSpreadsheetSettingsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScSpreadsheetSettingsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { // Referenz-Update interessiert hier nicht if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XPropertySet uno::Reference SAL_CALL ScSpreadsheetSettingsObj::getPropertySetInfo() throw(uno::RuntimeException) { //! muss noch return NULL; } void SAL_CALL ScSpreadsheetSettingsObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { //! muss noch } uno::Any SAL_CALL ScSpreadsheetSettingsObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { //! muss noch return uno::Any(); } SC_IMPL_DUMMY_PROPERTY_LISTENER( ScSpreadsheetSettingsObj ) //------------------------------------------------------------------------ ScAnnotationsObj::ScAnnotationsObj(ScDocShell* pDocSh, SCTAB nT) : pDocShell( pDocSh ), nTab( nT ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScAnnotationsObj::~ScAnnotationsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScAnnotationsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { //! nTab bei Referenz-Update anpassen!!! if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } BOOL ScAnnotationsObj::GetAddressByIndex_Impl( ULONG nIndex, ScAddress& rPos ) const { if (pDocShell) { ULONG nFound = 0; ScDocument* pDoc = pDocShell->GetDocument(); ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab ); ScBaseCell* pCell = aCellIter.GetFirst(); while (pCell) { if (pCell->GetNotePtr()) { if (nFound == nIndex) { rPos = ScAddress( aCellIter.GetCol(), aCellIter.GetRow(), aCellIter.GetTab() ); return TRUE; } ++nFound; } pCell = aCellIter.GetNext(); } } return FALSE; // nicht gefunden } // XSheetAnnotations ScAnnotationObj* ScAnnotationsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const { if (pDocShell) { ScAddress aPos; if ( GetAddressByIndex_Impl( nIndex, aPos ) ) return new ScAnnotationObj( pDocShell, aPos ); } return NULL; } void SAL_CALL ScAnnotationsObj::insertNew( const table::CellAddress& aPosition, const ::rtl::OUString& aText ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { DBG_ASSERT( aPosition.Sheet == nTab, "addAnnotation mit falschem Sheet" ); ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocShell); aFunc.SetNoteText( aPos, String(aText), TRUE ); } } void SAL_CALL ScAnnotationsObj::removeByIndex( sal_Int32 nIndex ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScAddress aPos; if ( GetAddressByIndex_Impl( nIndex, aPos ) ) { ScMarkData aMarkData; aMarkData.SelectTable( aPos.Tab(), TRUE ); aMarkData.SetMultiMarkArea( ScRange(aPos) ); ScDocFunc aFunc(*pDocShell); aFunc.DeleteContents( aMarkData, IDF_NOTE, TRUE, TRUE ); } } } // XEnumerationAccess uno::Reference SAL_CALL ScAnnotationsObj::createEnumeration() throw(uno::RuntimeException) { //! iterate directly (more efficiently)? ScUnoGuard aGuard; return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.CellAnnotationsEnumeration"))); } // XIndexAccess sal_Int32 SAL_CALL ScAnnotationsObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; ULONG nCount = 0; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab ); ScBaseCell* pCell = aCellIter.GetFirst(); while (pCell) { if (pCell->GetNotePtr()) ++nCount; pCell = aCellIter.GetNext(); } } return nCount; } uno::Any SAL_CALL ScAnnotationsObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xAnnotation(GetObjectByIndex_Impl(nIndex)); if (xAnnotation.is()) return uno::makeAny(xAnnotation); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScAnnotationsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScAnnotationsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } //------------------------------------------------------------------------ ScScenariosObj::ScScenariosObj(ScDocShell* pDocSh, SCTAB nT) : pDocShell( pDocSh ), nTab ( nT ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScScenariosObj::~ScScenariosObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScScenariosObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; //! Referenz-Update fuer Tab und Start/Ende } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XScenarios BOOL ScScenariosObj::GetScenarioIndex_Impl( const rtl::OUString& rName, SCTAB& rIndex ) { //! Case-insensitiv ???? if ( pDocShell ) { String aString(rName); String aTabName; ScDocument* pDoc = pDocShell->GetDocument(); SCTAB nCount = (SCTAB)getCount(); for (SCTAB i=0; iGetName( nTab+i+1, aTabName )) if ( aTabName == aString ) { rIndex = i; return TRUE; } } return FALSE; } ScTableSheetObj* ScScenariosObj::GetObjectByIndex_Impl(sal_Int32 nIndex) { USHORT nCount = (USHORT)getCount(); if ( pDocShell && nIndex < nCount ) return new ScTableSheetObj( pDocShell, nTab+static_cast(nIndex)+1 ); return NULL; // kein Dokument oder falscher Index } ScTableSheetObj* ScScenariosObj::GetObjectByName_Impl(const rtl::OUString& aName) { SCTAB nIndex; if ( pDocShell && GetScenarioIndex_Impl( aName, nIndex ) ) return new ScTableSheetObj( pDocShell, nTab+nIndex+1 ); return NULL; // nicht gefunden } void SAL_CALL ScScenariosObj::addNewByName( const rtl::OUString& aName, const uno::Sequence& aRanges, const rtl::OUString& aComment ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell ) { ScMarkData aMarkData; aMarkData.SelectTable( nTab, TRUE ); USHORT nRangeCount = (USHORT)aRanges.getLength(); if (nRangeCount) { const table::CellRangeAddress* pAry = aRanges.getConstArray(); for (USHORT i=0; iMakeScenario( nTab, aNameStr, aCommStr, aColor, nFlags, aMarkData ); } } void SAL_CALL ScScenariosObj::removeByName( const rtl::OUString& aName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; SCTAB nIndex; if ( pDocShell && GetScenarioIndex_Impl( aName, nIndex ) ) { ScDocFunc aFunc(*pDocShell); aFunc.DeleteTable( nTab+nIndex+1, TRUE, TRUE ); } } // XEnumerationAccess uno::Reference SAL_CALL ScScenariosObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.ScenariosEnumeration"))); } // XIndexAccess sal_Int32 SAL_CALL ScScenariosObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; SCTAB nCount = 0; if ( pDocShell ) { ScDocument* pDoc = pDocShell->GetDocument(); if (!pDoc->IsScenario(nTab)) { SCTAB nTabCount = pDoc->GetTableCount(); SCTAB nNext = nTab + 1; while (nNext < nTabCount && pDoc->IsScenario(nNext)) { ++nCount; ++nNext; } } } return nCount; } uno::Any SAL_CALL ScScenariosObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xScen(GetObjectByIndex_Impl(nIndex)); if (xScen.is()) return uno::makeAny(xScen); else throw lang::IndexOutOfBoundsException(); return uno::Any(); } uno::Type SAL_CALL ScScenariosObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScScenariosObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); } uno::Any SAL_CALL ScScenariosObj::getByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xScen(GetObjectByName_Impl(aName)); if (xScen.is()) return uno::makeAny(xScen); else throw container::NoSuchElementException(); return uno::Any(); } uno::Sequence SAL_CALL ScScenariosObj::getElementNames() throw(uno::RuntimeException) { ScUnoGuard aGuard; SCTAB nCount = (SCTAB)getCount(); uno::Sequence aSeq(nCount); if ( pDocShell ) // sonst ist auch Count = 0 { String aTabName; ScDocument* pDoc = pDocShell->GetDocument(); rtl::OUString* pAry = aSeq.getArray(); for (SCTAB i=0; iGetName( nTab+i+1, aTabName )) pAry[i] = aTabName; } return aSeq; } sal_Bool SAL_CALL ScScenariosObj::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; SCTAB nIndex; return GetScenarioIndex_Impl( aName, nIndex ); }