reportdesign/source/ui/misc/FunctionHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: formula.hxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #include "precompiled_reportdesign.hxx"
  33 #include "FunctionHelper.hxx"
  34 #include <tools/debug.hxx>
  35
  36 // =============================================================================
  37 namespace rptui
  38 {
  39 // =============================================================================
  40     using namespace ::com::sun::star;
  41
  42 FunctionManager::FunctionManager(const uno::Reference< report::meta::XFunctionManager>& _xMgr)
  43 : m_xMgr(_xMgr)
  44 {
  45 }
  46 FunctionManager::~FunctionManager()
  47 {
  48 }
  49 sal_Unicode FunctionManager::getSingleToken(const formula::IFunctionManager::EToken _eToken) const
  50 {
  51     switch(_eToken)
  52     {
  53         case eOk:
  54             return sal_Unicode('(');
  55         case eClose:
  56             return sal_Unicode(')');
  57         case eSep:
  58             return sal_Unicode(';');
  59         case eArrayOpen:
  60             return sal_Unicode('{');
  61         case eArrayClose:
  62             return sal_Unicode('}');
  63     } // switch(_eToken)
  64     return 0;
  65 }
  66 // -----------------------------------------------------------------------------
  67 sal_uInt32 FunctionManager::getCount() const
  68 {
  69     return m_xMgr->getCount();
  70 }
  71 // -----------------------------------------------------------------------------
  72 const formula::IFunctionCategory* FunctionManager::getCategory(sal_uInt32 _nPos) const
  73 {
  74     if ( _nPos >= m_aCategoryIndex.size() )
  75     {
  76         uno::Reference< report::meta::XFunctionCategory> xCategory = m_xMgr->getCategory(_nPos);
  77         ::boost::shared_ptr< FunctionCategory > pCategory(new FunctionCategory(this,_nPos + 1,xCategory));
  78         m_aCategoryIndex.push_back( m_aCategories.insert(TCategoriesMap::value_type(xCategory->getName(),pCategory)).first );
  79     }
  80     return m_aCategoryIndex[_nPos]->second.get();
  81 }
  82 // -----------------------------------------------------------------------------
  83 const formula::IFunctionDescription* FunctionManager::getFunctionByName(const ::rtl::OUString& _sFunctionName) const
  84 {
  85     const formula::IFunctionDescription* pDesc = NULL;
  86     try
  87     {
  88         pDesc = get(m_xMgr->getFunctionByName(_sFunctionName)).get();
  89     }
  90     catch(uno::Exception&)
  91     {
  92     }
  93     return pDesc;
  94 }
  95 // -----------------------------------------------------------------------------
  96 void FunctionManager::fillLastRecentlyUsedFunctions(::std::vector< const formula::IFunctionDescription*>& /*_rLastRUFunctions*/) const
  97 {
  98     //const sal_uInt32 nCount = getCount();
  99     //for(sal_uInt32 i = 0 ; i < nCount ; ++i)
 100     //{
 101     //    const formula::IFunctionCategory* pCategory = getCategory(
 102     //}
 103 }
 104 // -----------------------------------------------------------------------------
 105 ::boost::shared_ptr< FunctionDescription > FunctionManager::get(const uno::Reference< report::meta::XFunctionDescription>& _xFunctionDescription) const
 106 {
 107     ::boost::shared_ptr< FunctionDescription > pDesc;
 108     if ( _xFunctionDescription.is() )
 109     {
 110         const ::rtl::OUString sFunctionName = _xFunctionDescription->getName();
 111         TFunctionsMap::const_iterator aFunctionFind = m_aFunctions.find(sFunctionName);
 112         if ( aFunctionFind == m_aFunctions.end() )
 113         {
 114             const uno::Reference< report::meta::XFunctionCategory> xCategory = _xFunctionDescription->getCategory();
 115             const ::rtl::OUString sCategoryName = xCategory->getName();
 116             TCategoriesMap::iterator aCategoryFind = m_aCategories.find(sCategoryName);
 117             if ( aCategoryFind == m_aCategories.end() )
 118             {
 119                 aCategoryFind = m_aCategories.insert(TCategoriesMap::value_type(sCategoryName,::boost::shared_ptr< FunctionCategory > (new FunctionCategory(this,xCategory->getNumber() + 1,xCategory)))).first;
 120                 m_aCategoryIndex.push_back( aCategoryFind );
 121             }
 122             aFunctionFind = m_aFunctions.insert(TFunctionsMap::value_type(sFunctionName,::boost::shared_ptr<FunctionDescription>(new FunctionDescription(aCategoryFind->second.get(),_xFunctionDescription)))).first;
 123         } // if ( aFind == m_aFunctions.end() )
 124         pDesc = aFunctionFind->second;
 125     } // if ( _xFunctionDescription.is() )
 126     return pDesc;
 127 }
 128 // -----------------------------------------------------------------------------
 129 FunctionCategory::FunctionCategory(const FunctionManager* _pFMgr,sal_uInt32 _nPos,const uno::Reference< report::meta::XFunctionCategory>& _xCategory)
 130 : m_xCategory(_xCategory)
 131 ,m_nFunctionCount(_xCategory->getCount())
 132 , m_nNumber(_nPos)
 133 ,m_pFunctionManager(_pFMgr)
 134 {
 135 }
 136 // -----------------------------------------------------------------------------
 137 sal_uInt32 FunctionCategory::getCount() const
 138 {
 139     return m_nFunctionCount;
 140 }
 141 // -----------------------------------------------------------------------------
 142 const formula::IFunctionDescription* FunctionCategory::getFunction(sal_uInt32 _nPos) const
 143 {
 144     if ( _nPos >= m_aFunctions.size() && _nPos < m_nFunctionCount )
 145     {
 146         uno::Reference< report::meta::XFunctionDescription> xFunctionDescription = m_xCategory->getFunction(_nPos);
 147         ::boost::shared_ptr< FunctionDescription > pFunction = m_pFunctionManager->get(xFunctionDescription);
 148         m_aFunctions.push_back( pFunction );
 149     }
 150     return m_aFunctions[_nPos].get();
 151 }
 152 // -----------------------------------------------------------------------------
 153 sal_uInt32 FunctionCategory::getNumber() const
 154 {
 155     return m_nNumber;
 156 }
 157 // -----------------------------------------------------------------------------
 158 const formula::IFunctionManager* FunctionCategory::getFunctionManager() const
 159 {
 160     return m_pFunctionManager;
 161 }
 162 // -----------------------------------------------------------------------------
 163 ::rtl::OUString FunctionCategory::getName() const
 164 {
 165     return m_xCategory->getName();
 166 }
 167 // -----------------------------------------------------------------------------
 168 FunctionDescription::FunctionDescription(const formula::IFunctionCategory* _pFunctionCategory,const uno::Reference< report::meta::XFunctionDescription>& _xFunctionDescription)
 169 : m_xFunctionDescription(_xFunctionDescription)
 170 , m_pFunctionCategory(_pFunctionCategory)
 171 {
 172     m_aParameter = m_xFunctionDescription->getArguments();
 173 }
 174 ::rtl::OUString FunctionDescription::getFunctionName() const
 175 {
 176     return m_xFunctionDescription->getName();
 177 }
 178 // -----------------------------------------------------------------------------
 179 const formula::IFunctionCategory* FunctionDescription::getCategory() const
 180 {
 181     return m_pFunctionCategory;
 182 }
 183 // -----------------------------------------------------------------------------
 184 ::rtl::OUString FunctionDescription::getDescription() const
 185 {
 186     return m_xFunctionDescription->getDescription();
 187 }
 188 // -----------------------------------------------------------------------------
 189 xub_StrLen FunctionDescription::getSuppressedArgumentCount() const
 190 {
 191     return static_cast<xub_StrLen>(m_aParameter.getLength());
 192 }
 193 // -----------------------------------------------------------------------------
 194 ::rtl::OUString FunctionDescription::getFormula(const ::std::vector< ::rtl::OUString >& _aArguments) const
 195 {
 196     ::rtl::OUString sFormula;
 197     try
 198     {
 199         const ::rtl::OUString *pArguments = _aArguments.empty() ? 0 : &_aArguments[0];
 200         sFormula = m_xFunctionDescription->createFormula(uno::Sequence< ::rtl::OUString >(pArguments, _aArguments.size()));
 201     }
 202     catch(const uno::Exception&)
 203     {
 204         DBG_ERROR("Exception caught!");
 205     }
 206     return sFormula;
 207 }
 208 // -----------------------------------------------------------------------------
 209 void FunctionDescription::fillVisibleArgumentMapping(::std::vector<USHORT>& _rArguments) const
 210 {
 211     const sal_Int32 nCount = m_aParameter.getLength();
 212     for(USHORT i = 0;i < nCount; ++i)
 213     {
 214         _rArguments.push_back(i);
 215     }
 216 }
 217 // -----------------------------------------------------------------------------
 218 void FunctionDescription::initArgumentInfo()  const
 219 {
 220 }
 221 // -----------------------------------------------------------------------------
 222 ::rtl::OUString FunctionDescription::getSignature() const
 223 {
 224     return m_xFunctionDescription->getSignature();
 225 }
 226 // -----------------------------------------------------------------------------
 227 long FunctionDescription::getHelpId() const
 228 {
 229     return 0;
 230 }
 231 // -----------------------------------------------------------------------------
 232 sal_uInt32 FunctionDescription::getParameterCount() const
 233 {
 234     return m_aParameter.getLength();
 235 }
 236 // -----------------------------------------------------------------------------
 237 ::rtl::OUString FunctionDescription::getParameterName(sal_uInt32 _nPos) const
 238 {
 239     if ( _nPos < static_cast<sal_uInt32>(m_aParameter.getLength()) )
 240         return m_aParameter[_nPos].Name;
 241     return ::rtl::OUString();
 242 }
 243 // -----------------------------------------------------------------------------
 244 ::rtl::OUString FunctionDescription::getParameterDescription(sal_uInt32 _nPos) const
 245 {
 246     if ( _nPos < static_cast<sal_uInt32>(m_aParameter.getLength()) )
 247         return m_aParameter[_nPos].Description;
 248     return ::rtl::OUString();
 249 }
 250 // -----------------------------------------------------------------------------
 251 bool FunctionDescription::isParameterOptional(sal_uInt32 _nPos) const
 252 {
 253     if ( _nPos < static_cast<sal_uInt32>(m_aParameter.getLength()) )
 254         return m_aParameter[_nPos].IsOptional;
 255     return false;
 256 }
 257 // -----------------------------------------------------------------------------
 258 // =============================================================================
 259 } // rptui
 260 // =============================================================================