| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifdef _MSC_VER |
| #pragma hdrstop |
| #endif |
| |
| #include <usr/factoryhlp.hxx> |
| #include <usr/macros.hxx> |
| #include <usr/reflserv.hxx> |
| #include <vos/mutex.hxx> |
| #include <vcl/svapp.hxx> |
| #include <tools/debug.hxx> |
| #include <tools/date.hxx> |
| #include <svl/itemprop.hxx> |
| #include <usr/proptypehlp.hxx> |
| #include <cppuhelper/factory.hxx> |
| #include <uno/lbnames.h> |
| #include <osl/diagnose.h> |
| |
| #include <com/sun/star/util/date.hpp> |
| |
| #include "addin.hxx" |
| #include "result.hxx" |
| |
| using namespace com::sun::star; |
| |
| //------------------------------------------------------------------------ |
| |
| |
| //------------------------------------------------------------------------ |
| |
| SMART_UNO_IMPLEMENTATION( ScTestAddIn, UsrObject ); |
| |
| #define SCADDIN_SERVICE L"com.sun.star.sheet.AddIn" |
| #define SCTESTADDIN_SERVICE L"stardiv.one.sheet.DemoAddIn" |
| |
| //------------------------------------------------------------------------ |
| |
| extern "C" { |
| |
| void SAL_CALL component_getImplementationEnvironment( |
| const sal_Char ** ppEnvTypeName, uno_Environment ** ppEnv ) |
| { |
| *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; |
| } |
| |
| sal_Bool SAL_CALL component_writeInfo( |
| void * pServiceManager, registry::XRegistryKey * pRegistryKey ) |
| { |
| if (pRegistryKey) |
| { |
| try |
| { |
| UString aImpl = L"/"; |
| aImpl += ScTestAddIn::getImplementationName_Static(); |
| aImpl += L"/UNO/SERVICES"; |
| |
| uno::Reference<registry::XRegistryKey> xNewKey( |
| reinterpret_cast<registry::XRegistryKey*>(pRegistryKey)->createKey(aImpl) ); |
| |
| uno::Sequence <rtl::OUString> aSequ = ScTestAddIn::getSupportedServiceNames_Static(); |
| const rtl::OUString * pArray = aSequ.getConstArray(); |
| for( INT32 i = 0; i < aSequ.getLength(); i++ ) |
| xNewKey->createKey( pArray[i] ); |
| |
| return sal_True; |
| } |
| catch (registry::InvalidRegistryException&) |
| { |
| OSL_ENSHURE( sal_False, "### InvalidRegistryException!" ); |
| } |
| } |
| return sal_False; |
| } |
| |
| void * SAL_CALL component_getFactory( |
| const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey ) |
| { |
| void* pRet = 0; |
| |
| if ( pServiceManager && UString(pImplName) == ScTestAddIn::getImplementationName_Static() ) |
| { |
| uno::Reference<lang::XSingleServiceFactory> xFactory( cppu::createOneInstanceFactory( |
| reinterpret_cast<lang::XMultiServiceFactory*>(pServiceManager), |
| ScTestAddIn::getImplementationName_Static(), |
| ScTestAddIn_CreateInstance, |
| ScTestAddIn::getSupportedServiceNames_Static() ) ); |
| |
| if (xFactory.is()) |
| { |
| xFactory->acquire(); |
| pRet = xFactory.get(); |
| } |
| } |
| |
| return pRet; |
| } |
| |
| } // extern C |
| |
| //------------------------------------------------------------------------ |
| |
| ScTestAddIn::ScTestAddIn() |
| { |
| } |
| |
| ScTestAddIn::~ScTestAddIn() |
| { |
| } |
| |
| UString ScTestAddIn::getImplementationName_Static() |
| { |
| return L"stardiv.StarCalc.ScTestAddIn"; |
| } |
| |
| ::com::sun::star::uno::Sequence< ::rtl::OUString > ScTestAddIn::getSupportedServiceNames_Static() |
| { |
| uno::Sequence< rtl::OUString > aRet(2); |
| rtl::OUString* pArray = aRet.getArray(); |
| pArray[0] = SCADDIN_SERVICE; |
| pArray[1] = SCTESTADDIN_SERVICE; |
| return aRet; |
| } |
| |
| uno::Reference<uno::XInterface> ScTestAddIn_CreateInstance( |
| const uno::Reference<lang::XMultiServiceFactory>& ) |
| { |
| static uno::Reference<uno::XInterface> xInst = (cppu::OWeakObject*)new ScTestAddIn(); |
| return xInst; |
| } |
| |
| |
| // XAddIn |
| |
| UString ScTestAddIn::getProgrammaticFuntionName(const UString& aDisplayName) |
| THROWS( (UsrSystemException) ) |
| { |
| //!... |
| return UString(); |
| } |
| |
| UString ScTestAddIn::getDisplayFunctionName(const UString& aProgrammaticName) |
| THROWS( (UsrSystemException) ) |
| { |
| // return translated strings |
| |
| UString aRet; |
| if ( aProgrammaticName == L"countParams" ) aRet = L"ParamAnzahl"; |
| else if ( aProgrammaticName == L"addOne" ) aRet = L"PlusEins"; |
| else if ( aProgrammaticName == L"repeatStr" ) aRet = L"WiederholeString"; |
| else if ( aProgrammaticName == L"getDateString" ) aRet = L"Datumsstring"; |
| else if ( aProgrammaticName == L"getColorValue" ) aRet = L"Farbwert"; |
| else if ( aProgrammaticName == L"transpose" ) aRet = L"Transponieren"; |
| else if ( aProgrammaticName == L"transposeInt" ) aRet = L"IntegerTransponieren"; |
| else if ( aProgrammaticName == L"repeatMultiple" )aRet = L"Mehrfach"; |
| else if ( aProgrammaticName == L"getStrOrVal" ) aRet = L"StringOderWert"; |
| else if ( aProgrammaticName == L"callAsync" ) aRet = L"Asynchron"; |
| return aRet; |
| } |
| |
| UString ScTestAddIn::getFunctionDescription(const UString& aProgrammaticName) |
| THROWS( (UsrSystemException) ) |
| { |
| // return translated strings |
| |
| UString aRet; |
| if ( aProgrammaticName == L"countParams" ) aRet = L"Gibt die Anzahl der Parameter zurueck."; |
| else if ( aProgrammaticName == L"addOne" ) aRet = L"Addiert 1 zur uebergebenen Zahl."; |
| else if ( aProgrammaticName == L"repeatStr" ) aRet = L"Wiederholt eine Zeichenkette."; |
| else if ( aProgrammaticName == L"getDateString" ) aRet = L"Wandelt ein Datum in eine Zeichenkette."; |
| else if ( aProgrammaticName == L"getColorValue" ) aRet = L"Gibt den Farbwert eines Zellbereichs zurueck. Bei transparentem Hintergrund wird -1 zurueckgegeben"; |
| else if ( aProgrammaticName == L"transpose" ) aRet = L"Transponiert eine Matrix."; |
| else if ( aProgrammaticName == L"transposeInt" ) aRet = L"Transponiert eine Matrix mit Ganzzahlen."; |
| else if ( aProgrammaticName == L"repeatMultiple" )aRet = L"Wiederholt mehrere Bestandteile."; |
| else if ( aProgrammaticName == L"getStrOrVal" ) aRet = L"Gibt einen String oder einen Wert zurueck."; |
| else if ( aProgrammaticName == L"callAsync" ) aRet = L"Test fuer asynchrone Funktion."; |
| return aRet; |
| } |
| |
| UString ScTestAddIn::getDisplayArgumentName(const UString& aProgrammaticFunctionName, |
| INT32 nArgument) THROWS( (UsrSystemException) ) |
| { |
| // return translated strings |
| |
| UString aRet; |
| if ( aProgrammaticFunctionName == L"countParams" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Parameter"; |
| } |
| else if ( aProgrammaticFunctionName == L"addOne" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Wert"; |
| } |
| else if ( aProgrammaticFunctionName == L"repeatStr" ) |
| { |
| if ( nArgument == 0 ) aRet = L"String"; |
| else if ( nArgument == 1 ) aRet = L"Anzahl"; |
| } |
| else if ( aProgrammaticFunctionName == L"getDateString" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Dokument"; |
| else if ( nArgument == 1 ) aRet = L"Wert"; |
| } |
| else if ( aProgrammaticFunctionName == L"getColorValue" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Bereich"; |
| } |
| else if ( aProgrammaticFunctionName == L"transpose" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Matrix"; |
| } |
| else if ( aProgrammaticFunctionName == L"transposeInt" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Matrix"; |
| } |
| else if ( aProgrammaticFunctionName == L"repeatMultiple" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Anzahl"; |
| else if ( nArgument == 1 ) aRet = L"Trenner"; |
| else if ( nArgument == 2 ) aRet = L"Inhalt"; |
| } |
| else if ( aProgrammaticFunctionName == L"getStrOrVal" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Flag"; |
| } |
| else if ( aProgrammaticFunctionName == L"callAsync" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Name"; |
| } |
| return aRet; |
| } |
| |
| UString ScTestAddIn::getArgumentDescription(const UString& aProgrammaticFunctionName, |
| INT32 nArgument) THROWS( (UsrSystemException) ) |
| { |
| // return translated strings |
| |
| UString aRet; |
| if ( aProgrammaticFunctionName == L"countParams" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Beliebiger Parameter"; |
| } |
| else if ( aProgrammaticFunctionName == L"addOne" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Der Wert, zu dem 1 addiert wird"; |
| } |
| else if ( aProgrammaticFunctionName == L"repeatStr" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Der Text, der wiederholt wird"; |
| else if ( nArgument == 1 ) aRet = L"Die Anzahl der Wiederholungen"; |
| } |
| else if ( aProgrammaticFunctionName == L"getDateString" ) |
| { |
| if ( nArgument == 0 ) aRet = L"(intern)"; |
| else if ( nArgument == 1 ) aRet = L"Der Wert, der als Datum formatiert wird"; |
| } |
| else if ( aProgrammaticFunctionName == L"getColorValue" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Der Bereich, dessen Hintergrundfarbe abgefragt wird"; |
| } |
| else if ( aProgrammaticFunctionName == L"transpose" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Die Matrix, die transponiert werden soll"; |
| } |
| else if ( aProgrammaticFunctionName == L"transposeInt" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Die Matrix, die transponiert werden soll"; |
| } |
| else if ( aProgrammaticFunctionName == L"repeatMultiple" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Anzahl der Wiederholungen"; |
| else if ( nArgument == 1 ) aRet = L"Text, der zwischen den Inhalten erscheint"; |
| else if ( nArgument == 2 ) aRet = L"Mehrere Inhalte"; |
| } |
| else if ( aProgrammaticFunctionName == L"getStrOrVal" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Wenn Flag 0 ist, wird ein Wert zurueckgegeben, sonst ein String."; |
| } |
| else if ( aProgrammaticFunctionName == L"callAsync" ) |
| { |
| if ( nArgument == 0 ) aRet = L"Ein String"; |
| } |
| return aRet; |
| } |
| |
| UString ScTestAddIn::getProgrammaticCategoryName(const UString& aProgrammaticFunctionName) |
| THROWS( (UsrSystemException) ) |
| { |
| // return non-translated strings |
| |
| UString aRet; |
| if ( aProgrammaticFunctionName == L"countParams" ) aRet = L"Information"; |
| else if ( aProgrammaticFunctionName == L"addOne" ) aRet = L"Mathematical"; |
| else if ( aProgrammaticFunctionName == L"repeatStr" ) aRet = L"Text"; |
| else if ( aProgrammaticFunctionName == L"getDateString" ) aRet = L"Date&Time"; |
| else if ( aProgrammaticFunctionName == L"getColorValue" ) aRet = L"Spreadsheet"; |
| else if ( aProgrammaticFunctionName == L"transpose" ) aRet = L"Matrix"; |
| else if ( aProgrammaticFunctionName == L"transposeInt" ) aRet = L"Matrix"; |
| else if ( aProgrammaticFunctionName == L"repeatMultiple" )aRet = L"Text"; |
| else if ( aProgrammaticFunctionName == L"getStrOrVal" ) aRet = L"Add-In"; |
| else if ( aProgrammaticFunctionName == L"callAsync" ) aRet = L"Realtime"; // new group |
| return aRet; |
| } |
| |
| UString ScTestAddIn::getDisplayCategoryName(const UString& aProgrammaticFunctionName) |
| THROWS( (UsrSystemException) ) |
| { |
| // return translated strings |
| |
| return L"irgendwas"; // not used for predefined categories |
| } |
| |
| // XLocalizable |
| |
| void ScTestAddIn::setLocale(const lang::Locale& eLocale) THROWS( (UsrSystemException) ) |
| { |
| aFuncLoc = eLocale; |
| // DBG_ERROR( UStringToString(aFuncLoc.Language, CHARSET_SYSTEM) + String("-") + |
| // UStringToString(aFuncLoc.Country, CHARSET_SYSTEM) ); |
| } |
| |
| ::com::sun::star::lang::Locale SAL_CALL ScTestAddIn::getLocale( ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return aFuncLoc; |
| } |
| |
| // XTestAddIn |
| |
| sal_Int32 SAL_CALL ScTestAddIn::countParams( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArgs ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return aArgs.getLength(); |
| } |
| |
| double SAL_CALL ScTestAddIn::addOne( double fValue ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return fValue + 1.0; |
| } |
| |
| ::rtl::OUString SAL_CALL ScTestAddIn::repeatStr( const ::rtl::OUString& aStr, sal_Int32 nCount ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| String aRet; |
| String aStrStr = OUStringToString( aStr, CHARSET_SYSTEM ); |
| for (long i=0; i<nCount; i++) |
| aRet += aStrStr; |
| |
| return StringToOUString( aRet, CHARSET_SYSTEM ); |
| } |
| |
| ::rtl::OUString SAL_CALL ScTestAddIn::getDateString( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xCaller, double fValue ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| uno::Any aDateAny = xCaller->getPropertyValue( L"NullDate" ); |
| //! if ( aDateAny.getReflection()->equals( *Date_getReflection() ) ) |
| { |
| util::Date aDate; |
| aDateAny >>= aDate; |
| //const Date* pDate = (const Date*)aDateAny.get(); |
| //if (pDate) |
| { |
| //Date aNewDate = *pDate; |
| Date aNewDate( aDate.Day, aDate.Month, aDate.Year ); |
| |
| aNewDate += (long)(fValue+0.5); |
| |
| String aRet; |
| aRet += aNewDate.GetDay(); |
| aRet += '.'; |
| aRet += aNewDate.GetMonth(); |
| aRet += '.'; |
| aRet += aNewDate.GetYear(); |
| return StringToOUString( aRet, CHARSET_SYSTEM ); |
| } |
| } |
| |
| return L"**ERROR**"; |
| } |
| |
| sal_Int32 SAL_CALL ScTestAddIn::getColorValue( const ::com::sun::star::uno::Reference< ::com::sun::star::table::XCellRange >& xRange ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| uno::Reference<beans::XPropertySet> xProp( xRange, uno::UNO_QUERY ); |
| if (xProp.is()) |
| { |
| long nRet = -1; |
| uno::Any aTrans = xProp->getPropertyValue( L"IsCellBackgroundTransparent" ); |
| BOOL bIsTrans; |
| aTrans >>= bIsTrans; //! dont use >>= for BOOL |
| if (!bIsTrans) |
| { |
| uno::Any aCol = xProp->getPropertyValue( L"CellBackColor" ); |
| //nRet = NAMESPACE_USR(OPropertyTypeConversion)::toINT32( aCol ); |
| aCol >>= nRet; |
| } |
| return nRet; |
| } |
| return 0; |
| } |
| |
| double lcl_GetDoubleElement( const uno::Sequence< uno::Sequence<double> >& aMatrix, long nCol, long nRow ) |
| { |
| if ( nRow < aMatrix.getLength() ) |
| { |
| const uno::Sequence<double>& rRowSeq = aMatrix.getConstArray()[nRow]; |
| if ( nCol < rRowSeq.getLength() ) |
| return rRowSeq.getConstArray()[nCol]; |
| } |
| return 0.0; // error |
| } |
| |
| INT32 lcl_GetLongElement( const uno::Sequence< uno::Sequence<INT32> >& aMatrix, long nCol, long nRow ) |
| { |
| if ( nRow < aMatrix.getLength() ) |
| { |
| const uno::Sequence<INT32>& rRowSeq = aMatrix.getConstArray()[nRow]; |
| if ( nCol < rRowSeq.getLength() ) |
| return rRowSeq.getConstArray()[nCol]; |
| } |
| return 0.0; // error |
| } |
| |
| ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< double > > SAL_CALL ScTestAddIn::transpose( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< double > >& aMatrix ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| long nRowCount = aMatrix.getLength(); |
| long nColCount = 0; |
| if ( nRowCount ) |
| nColCount = aMatrix.getConstArray()[0].getLength(); |
| |
| uno::Sequence< uno::Sequence<double> > aRet( nColCount ); |
| for (long nCol=0; nCol<nColCount; nCol++) |
| { |
| uno::Sequence<double> aSubSeq(nRowCount); |
| for (long nRow=0; nRow<nRowCount; nRow++) |
| aSubSeq.getArray()[nRow] = lcl_GetDoubleElement( aMatrix, nCol, nRow ); |
| |
| aRet.getArray()[nCol] = aSubSeq; |
| } |
| |
| return aRet; |
| } |
| |
| ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< sal_Int32 > > SAL_CALL ScTestAddIn::transposeInt( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< sal_Int32 > >& aMatrix ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| long nRowCount = aMatrix.getLength(); |
| long nColCount = 0; |
| if ( nRowCount ) |
| nColCount = aMatrix.getConstArray()[0].getLength(); |
| |
| uno::Sequence< uno::Sequence<INT32> > aRet( nColCount ); |
| for (long nCol=0; nCol<nColCount; nCol++) |
| { |
| uno::Sequence<INT32> aSubSeq(nRowCount); |
| for (long nRow=0; nRow<nRowCount; nRow++) |
| aSubSeq.getArray()[nRow] = lcl_GetLongElement( aMatrix, nCol, nRow ); |
| |
| aRet.getArray()[nCol] = aSubSeq; |
| } |
| |
| return aRet; |
| } |
| |
| ::rtl::OUString SAL_CALL ScTestAddIn::repeatMultiple( sal_Int32 nCount, const ::com::sun::star::uno::Any& aFirst, const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aFollow ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| String aSeparator; |
| if ( !aFirst.hasValue() ) // not specified |
| aSeparator = ';'; |
| else |
| { |
| rtl::OUString aUStr; |
| aFirst >>= aUStr; |
| aSeparator = OUStringToString( aUStr, CHARSET_SYSTEM ); |
| } |
| |
| String aContent; |
| long nContCount = aFollow.getLength(); |
| const uno::Any* pArr = aFollow.getConstArray(); |
| for (long nPos=0; nPos<nContCount; nPos++) |
| { |
| if ( nPos > 0 ) |
| aContent += ' '; |
| rtl::OUString aUStr; |
| pArr[nPos] >>= aUStr; |
| aContent += OUStringToString( aUStr, CHARSET_SYSTEM ); |
| } |
| |
| String aRet; |
| |
| for (long i=0; i<nCount; i++) |
| { |
| if (i>0) |
| aRet += aSeparator; |
| aRet += aContent; |
| } |
| |
| return StringToOUString(aRet, CHARSET_SYSTEM); |
| } |
| |
| ::com::sun::star::uno::Any SAL_CALL ScTestAddIn::getStrOrVal( sal_Int32 nFlag ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| uno::Any aRet; |
| |
| //! Test |
| if ( nFlag == 42 ) |
| { |
| uno::Sequence<rtl::OUString> aInner(3); |
| aInner.getArray()[0] = L"Bla"; |
| aInner.getArray()[1] = L"Fasel"; |
| aInner.getArray()[2] = L"Suelz"; |
| uno::Sequence< uno::Sequence<rtl::OUString> > aOuter( &aInner, 1 ); |
| |
| //return uno::Any( &aOuter, Sequence< Sequence<UString> >::getReflection() ); |
| |
| aRet <<= aOuter; |
| return aRet; |
| } |
| //! Test |
| |
| if ( nFlag ) |
| aRet <<= UString(L"This is a string."); |
| else |
| aRet <<= (INT32)42; |
| |
| return aRet; |
| } |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::sheet::XVolatileResult > SAL_CALL ScTestAddIn::callAsync( const ::rtl::OUString& aString ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| String aStr = OUStringToString( aString, CHARSET_SYSTEM ); |
| char c = (char) aStr; |
| if ( c >= '0' && c <= '9' ) |
| { |
| if (!xNumResult.is()) |
| xNumResult = new ScAddInResult( "Num" ); |
| return xNumResult; |
| } |
| else |
| { |
| if (!xAlphaResult.is()) |
| xAlphaResult = new ScAddInResult( "Str" ); |
| return xAlphaResult; |
| } |
| } |
| |
| |
| // XServiceName |
| |
| ::rtl::OUString SAL_CALL ScTestAddIn::getServiceName( ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return SCTESTADDIN_SERVICE; // name of specific AddIn service |
| } |
| |
| // XServiceInfo |
| |
| ::rtl::OUString SAL_CALL ScTestAddIn::getImplementationName( ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return getImplementationName_Static(); |
| } |
| |
| sal_Bool SAL_CALL ScTestAddIn::supportsService( const ::rtl::OUString& ServiceName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return ServiceName == SCADDIN_SERVICE || |
| ServiceName == SCTESTADDIN_SERVICE; |
| } |
| |
| ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL ScTestAddIn::getSupportedServiceNames( ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| return getSupportedServiceNames_Static(); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| |
| |