LCOV - code coverage report
Current view: top level - svtools/source/uno - unoevent.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 91 232 39.2 %
Date: 2014-11-03 Functions: 20 34 58.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <com/sun/star/beans/PropertyValue.hpp>
      21             : #include <cppuhelper/supportsservice.hxx>
      22             : #include <rtl/ustrbuf.hxx>
      23             : #include <tools/rtti.hxx>
      24             : #include <svtools/unoevent.hxx>
      25             : #include <svl/macitem.hxx>
      26             : 
      27             : using namespace ::com::sun::star;
      28             : using namespace ::com::sun::star::uno;
      29             : 
      30             : using ::com::sun::star::container::NoSuchElementException;
      31             : using ::com::sun::star::container::XNameReplace;
      32             : using ::com::sun::star::lang::IllegalArgumentException;
      33             : using ::com::sun::star::lang::WrappedTargetException;
      34             : using ::com::sun::star::lang::XServiceInfo;
      35             : using ::com::sun::star::beans::PropertyValue;
      36             : using ::cppu::WeakImplHelper2;
      37             : 
      38             : 
      39             : const sal_Char sAPI_ServiceName[] = "com.sun.star.container.XNameReplace";
      40             : const sal_Char sAPI_SvDetachedEventDescriptor[] = "SvDetachedEventDescriptor";
      41             : 
      42             : 
      43         106 : SvBaseEventDescriptor::SvBaseEventDescriptor( const SvEventDescription* pSupportedMacroItems ) :
      44             :         sEventType("EventType"),
      45             :         sMacroName("MacroName"),
      46             :         sLibrary("Library"),
      47             :         sStarBasic("StarBasic"),
      48             :         sJavaScript("JavaScript"),
      49             :         sScript("Script"),
      50             :         sNone("None"),
      51             :         sServiceName(sAPI_ServiceName),
      52             :         sEmpty(),
      53             :         mpSupportedMacroItems(pSupportedMacroItems),
      54         106 :         mnMacroItems(0)
      55             : {
      56             :     assert(pSupportedMacroItems != NULL && "Need a list of supported events!");
      57             : 
      58         106 :     for( ; mpSupportedMacroItems[mnMacroItems].mnEvent != 0; mnMacroItems++) ;
      59         106 : }
      60             : 
      61             : 
      62         106 : SvBaseEventDescriptor::~SvBaseEventDescriptor()
      63             : {
      64         106 : }
      65             : 
      66           0 : void SvBaseEventDescriptor::replaceByName(
      67             :     const OUString& rName,
      68             :     const Any& rElement )
      69             :     throw(
      70             :         IllegalArgumentException,
      71             :         NoSuchElementException,
      72             :         WrappedTargetException,
      73             :         RuntimeException, std::exception)
      74             : {
      75           0 :     sal_uInt16 nMacroID = getMacroID(rName);
      76             : 
      77             :     // error checking
      78           0 :     if (0 == nMacroID)
      79           0 :         throw NoSuchElementException();
      80           0 :     if (rElement.getValueType() != getElementType())
      81           0 :         throw IllegalArgumentException();
      82             : 
      83             :     // get sequence
      84           0 :     Sequence<PropertyValue> aSequence;
      85           0 :     rElement >>= aSequence;
      86             : 
      87             :     // perform replace (in subclass)
      88           0 :     SvxMacro aMacro(sEmpty,sEmpty);
      89           0 :     getMacroFromAny(aMacro, rElement);
      90           0 :     replaceByName(nMacroID, aMacro);
      91           0 : }
      92             : 
      93         720 : Any SvBaseEventDescriptor::getByName(
      94             :     const OUString& rName )
      95             :     throw(
      96             :         NoSuchElementException,
      97             :         WrappedTargetException,
      98             :         RuntimeException, std::exception)
      99             : {
     100         720 :     sal_uInt16 nMacroID = getMacroID(rName);
     101             : 
     102             :     // error checking
     103         720 :     if (0 == nMacroID)
     104           0 :         throw NoSuchElementException();
     105             : 
     106             :     // perform get (in subclass)
     107         720 :     Any aAny;
     108        1440 :     SvxMacro aMacro( sEmpty, sEmpty );
     109         720 :     getByName(aMacro, nMacroID);
     110         720 :     getAnyFromMacro(aAny, aMacro);
     111        1440 :     return aAny;
     112             : }
     113             : 
     114          88 : Sequence<OUString> SvBaseEventDescriptor::getElementNames()
     115             :     throw(RuntimeException, std::exception)
     116             : {
     117             :     // create and fill sequence
     118          88 :     Sequence<OUString> aSequence(mnMacroItems);
     119         808 :     for( sal_Int16 i = 0; i < mnMacroItems; i++)
     120             :     {
     121         720 :         aSequence[i] = OUString::createFromAscii( mpSupportedMacroItems[i].mpEventName );
     122             :     }
     123             : 
     124          88 :     return aSequence;
     125             : }
     126             : 
     127           0 : sal_Bool SvBaseEventDescriptor::hasByName(
     128             :     const OUString& rName )
     129             :     throw(RuntimeException, std::exception)
     130             : {
     131           0 :     sal_uInt16 nMacroID = getMacroID(rName);
     132           0 :     return (nMacroID != 0);
     133             : }
     134             : 
     135           0 : Type SvBaseEventDescriptor::getElementType()
     136             :     throw(RuntimeException, std::exception)
     137             : {
     138           0 :     return ::getCppuType((Sequence<PropertyValue> *)0);
     139             : }
     140             : 
     141           0 : sal_Bool SvBaseEventDescriptor::hasElements()
     142             :     throw(RuntimeException, std::exception)
     143             : {
     144           0 :     return mnMacroItems != 0;
     145             : }
     146             : 
     147           0 : sal_Bool SvBaseEventDescriptor::supportsService(const OUString& rServiceName)
     148             :     throw(RuntimeException, std::exception)
     149             : {
     150           0 :     return cppu::supportsService(this, rServiceName);
     151             : }
     152             : 
     153           0 : Sequence<OUString> SvBaseEventDescriptor::getSupportedServiceNames(void)
     154             :     throw(RuntimeException, std::exception)
     155             : {
     156           0 :     Sequence<OUString> aSequence(1);
     157           0 :     aSequence[0] = sServiceName;
     158             : 
     159           0 :     return aSequence;
     160             : }
     161             : 
     162         720 : sal_uInt16 SvBaseEventDescriptor::mapNameToEventID(const OUString& rName) const
     163             : {
     164             :     // iterate over known event names
     165        3584 :     for(sal_Int16 i = 0; i < mnMacroItems; i++)
     166             :     {
     167        3584 :         if( rName.equalsAscii(mpSupportedMacroItems[i].mpEventName))
     168             :         {
     169         720 :             return mpSupportedMacroItems[i].mnEvent;
     170             :         }
     171             :     }
     172             : 
     173             :     // not found -> return zero
     174           0 :     return 0;
     175             : }
     176             : 
     177         720 : sal_uInt16 SvBaseEventDescriptor::getMacroID(const OUString& rName) const
     178             : {
     179         720 :     return mapNameToEventID(rName);
     180             : }
     181             : 
     182         720 : void SvBaseEventDescriptor::getAnyFromMacro(Any& rAny,
     183             :                                        const SvxMacro& rMacro)
     184             : {
     185         720 :     bool bRetValueOK = false;   // do we have a ret value?
     186             : 
     187         720 :     if (rMacro.HasMacro())
     188             :     {
     189           0 :         switch (rMacro.GetScriptType())
     190             :         {
     191             :             case STARBASIC:
     192             :             {
     193             :                 // create sequence
     194           0 :                 Sequence<PropertyValue> aSequence(3);
     195           0 :                 Any aTmp;
     196             : 
     197             :                 // create type
     198           0 :                 PropertyValue aTypeValue;
     199           0 :                 aTypeValue.Name = sEventType;
     200           0 :                 aTmp <<= sStarBasic;
     201           0 :                 aTypeValue.Value = aTmp;
     202           0 :                 aSequence[0] = aTypeValue;
     203             : 
     204             :                 // macro name
     205           0 :                 PropertyValue aNameValue;
     206           0 :                 aNameValue.Name = sMacroName;
     207           0 :                 OUString sNameTmp(rMacro.GetMacName());
     208           0 :                 aTmp <<= sNameTmp;
     209           0 :                 aNameValue.Value = aTmp;
     210           0 :                 aSequence[1] = aNameValue;
     211             : 
     212             :                 // library name
     213           0 :                 PropertyValue aLibValue;
     214           0 :                 aLibValue.Name = sLibrary;
     215           0 :                 OUString sLibTmp(rMacro.GetLibName());
     216           0 :                 aTmp <<= sLibTmp;
     217           0 :                 aLibValue.Value = aTmp;
     218           0 :                 aSequence[2] = aLibValue;
     219             : 
     220           0 :                 rAny <<= aSequence;
     221           0 :                 bRetValueOK = true;
     222           0 :                 break;
     223             :             }
     224             :             case EXTENDED_STYPE:
     225             :             {
     226             :                 // create sequence
     227           0 :                 Sequence<PropertyValue> aSequence(2);
     228           0 :                 Any aTmp;
     229             : 
     230             :                 // create type
     231           0 :                 PropertyValue aTypeValue;
     232           0 :                 aTypeValue.Name = sEventType;
     233           0 :                 aTmp <<= sScript;
     234           0 :                 aTypeValue.Value = aTmp;
     235           0 :                 aSequence[0] = aTypeValue;
     236             : 
     237             :                 // macro name
     238           0 :                 PropertyValue aNameValue;
     239           0 :                 aNameValue.Name = sScript;
     240           0 :                 OUString sNameTmp(rMacro.GetMacName());
     241           0 :                 aTmp <<= sNameTmp;
     242           0 :                 aNameValue.Value = aTmp;
     243           0 :                 aSequence[1] = aNameValue;
     244             : 
     245           0 :                 rAny <<= aSequence;
     246           0 :                 bRetValueOK = true;
     247           0 :                 break;
     248             :                         }
     249             :             case JAVASCRIPT:
     250             :             default:
     251             :                 OSL_FAIL("not implemented");
     252             :         }
     253             :     }
     254             :     // else: bRetValueOK not set
     255             : 
     256             :     // if we don't have a return value, make an empty one
     257         720 :     if (! bRetValueOK)
     258             :     {
     259             :         // create "None" macro
     260         720 :         Sequence<PropertyValue> aSequence(1);
     261             : 
     262        1440 :         PropertyValue aKindValue;
     263         720 :         aKindValue.Name = sEventType;
     264        1440 :         Any aTmp;
     265         720 :         aTmp <<= sNone;
     266         720 :         aKindValue.Value = aTmp;
     267         720 :         aSequence[0] = aKindValue;
     268             : 
     269         720 :         rAny <<= aSequence;
     270        1440 :         bRetValueOK = true;
     271             :     }
     272         720 : }
     273             : 
     274             : 
     275           0 : void SvBaseEventDescriptor::getMacroFromAny(
     276             :     SvxMacro& rMacro,
     277             :     const Any& rAny)
     278             :         throw ( IllegalArgumentException )
     279             : {
     280             :     // get sequence
     281           0 :     Sequence<PropertyValue> aSequence;
     282           0 :     rAny >>= aSequence;
     283             : 
     284             :     // process ...
     285           0 :     bool bTypeOK = false;
     286           0 :     bool bNone = false;     // true if EventType=="None"
     287           0 :     enum ScriptType eType = EXTENDED_STYPE;
     288           0 :     OUString sScriptVal;
     289           0 :     OUString sMacroVal;
     290           0 :     OUString sLibVal;
     291           0 :     sal_Int32 nCount = aSequence.getLength();
     292           0 :     for (sal_Int32 i = 0; i < nCount; i++)
     293             :     {
     294           0 :         PropertyValue& aValue = aSequence[i];
     295           0 :         if (aValue.Name.equals(sEventType))
     296             :         {
     297           0 :             OUString sTmp;
     298           0 :             aValue.Value >>= sTmp;
     299           0 :             if (sTmp.equals(sStarBasic))
     300             :             {
     301           0 :                 eType = STARBASIC;
     302           0 :                 bTypeOK = true;
     303             :             }
     304           0 :             else if (sTmp.equals(sJavaScript))
     305             :             {
     306           0 :                 eType = JAVASCRIPT;
     307           0 :                 bTypeOK = true;
     308             :             }
     309           0 :             else if (sTmp.equals(sScript))
     310             :             {
     311           0 :                 eType = EXTENDED_STYPE;
     312           0 :                 bTypeOK = true;
     313             :             }
     314           0 :             else if (sTmp.equals(sNone))
     315             :             {
     316           0 :                 bNone = true;
     317           0 :                 bTypeOK = true;
     318           0 :             }
     319             :             // else: unknown script type
     320             :         }
     321           0 :         else if (aValue.Name.equals(sMacroName))
     322             :         {
     323           0 :             aValue.Value >>= sMacroVal;
     324             :         }
     325           0 :         else if (aValue.Name.equals(sLibrary))
     326             :         {
     327           0 :             aValue.Value >>= sLibVal;
     328             :         }
     329           0 :         else if (aValue.Name.equals(sScript))
     330             :         {
     331           0 :             aValue.Value >>= sScriptVal;
     332             :         }
     333             :         // else: unknown PropertyValue -> ignore
     334             :     }
     335             : 
     336           0 :     if (bTypeOK)
     337             :     {
     338           0 :         if (bNone)
     339             :         {
     340             :             // return empty macro
     341           0 :             rMacro = SvxMacro( sEmpty, sEmpty );
     342             :         }
     343             :         else
     344             :         {
     345           0 :             if (eType == STARBASIC)
     346             :             {
     347             :                 // create macro and return
     348           0 :                 SvxMacro aMacro(sMacroVal, sLibVal, eType);
     349           0 :                 rMacro = aMacro;
     350             :             }
     351           0 :             else if (eType == EXTENDED_STYPE)
     352             :             {
     353           0 :                 SvxMacro aMacro(sScriptVal, sScript);
     354           0 :                 rMacro = aMacro;
     355             :             }
     356             :             else
     357             :             {
     358             :                 // we can't process type: abort
     359             :                 // TODO: JavaScript macros
     360           0 :                 throw IllegalArgumentException();
     361             :             }
     362             :         }
     363             :     }
     364             :     else
     365             :     {
     366             :         // no valid type: abort
     367           0 :         throw IllegalArgumentException();
     368           0 :     }
     369           0 : }
     370             : 
     371             : 
     372          88 : SvEventDescriptor::SvEventDescriptor(
     373             :     XInterface& rParent,
     374             :     const SvEventDescription* pSupportedMacroItems) :
     375             :         SvBaseEventDescriptor(pSupportedMacroItems),
     376          88 :         xParentRef(&rParent)
     377             : {
     378          88 : }
     379             : 
     380             : 
     381          88 : SvEventDescriptor::~SvEventDescriptor()
     382             : {
     383             :     // automatically release xParentRef !
     384          88 : }
     385             : 
     386           0 : void SvEventDescriptor::replaceByName(
     387             :     const sal_uInt16 nEvent,
     388             :     const SvxMacro& rMacro)
     389             :         throw(
     390             :             IllegalArgumentException,
     391             :             NoSuchElementException,
     392             :             WrappedTargetException,
     393             :             RuntimeException)
     394             : {
     395           0 :     SvxMacroItem aItem(getMacroItemWhich());
     396           0 :     aItem.SetMacroTable(getMacroItem().GetMacroTable());
     397           0 :     aItem.SetMacro(nEvent, rMacro);
     398           0 :     setMacroItem(aItem);
     399           0 : }
     400             : 
     401         720 : void SvEventDescriptor::getByName(
     402             :     SvxMacro& rMacro,
     403             :     const sal_uInt16 nEvent )
     404             :         throw(
     405             :             NoSuchElementException,
     406             :             WrappedTargetException,
     407             :             RuntimeException)
     408             : {
     409         720 :     const SvxMacroItem& rItem = getMacroItem();
     410         720 :     if( rItem.HasMacro( nEvent ) )
     411           0 :         rMacro = rItem.GetMacro(nEvent);
     412             :     else
     413             :     {
     414         720 :         SvxMacro aEmptyMacro(sEmpty, sEmpty);
     415         720 :         rMacro = aEmptyMacro;
     416             :     }
     417         720 : }
     418             : 
     419             : 
     420          18 : SvDetachedEventDescriptor::SvDetachedEventDescriptor(
     421             :     const SvEventDescription* pSupportedMacroItems) :
     422             :     SvBaseEventDescriptor(pSupportedMacroItems),
     423          18 :     sImplName(sAPI_SvDetachedEventDescriptor)
     424             : {
     425             :     // allocate aMacros
     426          18 :     aMacros = new SvxMacro*[mnMacroItems];
     427             : 
     428             :     // ... and initialize
     429          48 :     for(sal_Int16 i = 0; i < mnMacroItems; i++)
     430             :     {
     431          30 :         aMacros[i] = NULL;
     432             :     }
     433          18 : }
     434             : 
     435          36 : SvDetachedEventDescriptor::~SvDetachedEventDescriptor()
     436             : {
     437             :     // delete contents of aMacros
     438          48 :     for(sal_Int16 i = 0; i < mnMacroItems; i++)
     439             :     {
     440          30 :         if (NULL != aMacros[i])
     441           0 :             delete aMacros[i];
     442             :     }
     443             : 
     444          18 :     delete [] aMacros;
     445          18 : }
     446             : 
     447           8 : sal_Int16 SvDetachedEventDescriptor::getIndex(const sal_uInt16 nID) const
     448             : {
     449             :     // iterate over supported events
     450           8 :     sal_Int16 nIndex = 0;
     451          24 :     while ( (mpSupportedMacroItems[nIndex].mnEvent != nID) &&
     452           4 :             (mpSupportedMacroItems[nIndex].mnEvent != 0)      )
     453             :     {
     454           4 :         nIndex++;
     455             :     }
     456           8 :     return (mpSupportedMacroItems[nIndex].mnEvent == nID) ? nIndex : -1;
     457             : }
     458             : 
     459           0 : OUString SvDetachedEventDescriptor::getImplementationName()
     460             :     throw( ::com::sun::star::uno::RuntimeException, std::exception )
     461             : {
     462           0 :     return sImplName;
     463             : }
     464             : 
     465             : 
     466           0 : void SvDetachedEventDescriptor::replaceByName(
     467             :     const sal_uInt16 nEvent,
     468             :     const SvxMacro& rMacro)
     469             :     throw(
     470             :         IllegalArgumentException,
     471             :         NoSuchElementException,
     472             :         WrappedTargetException,
     473             :         RuntimeException)
     474             : {
     475           0 :     sal_Int16 nIndex = getIndex(nEvent);
     476           0 :     if (-1 == nIndex)
     477           0 :         throw IllegalArgumentException();
     478             : 
     479           0 :     aMacros[nIndex] = new SvxMacro(rMacro.GetMacName(), rMacro.GetLibName(),
     480           0 :                                    rMacro.GetScriptType() );
     481           0 : }
     482             : 
     483             : 
     484           0 : void SvDetachedEventDescriptor::getByName(
     485             :     SvxMacro& rMacro,
     486             :     const sal_uInt16 nEvent )
     487             :     throw(
     488             :         NoSuchElementException,
     489             :         WrappedTargetException,
     490             :         RuntimeException)
     491             : {
     492           0 :     sal_Int16 nIndex = getIndex(nEvent);
     493           0 :     if (-1 == nIndex )
     494           0 :         throw NoSuchElementException();
     495             : 
     496           0 :     if( aMacros[nIndex] )
     497           0 :         rMacro = (*aMacros[nIndex]);
     498           0 : }
     499             : 
     500           8 : bool SvDetachedEventDescriptor::hasByName(
     501             :     const sal_uInt16 nEvent ) const     /// item ID of event
     502             :         throw(IllegalArgumentException)
     503             : {
     504           8 :     sal_Int16 nIndex = getIndex(nEvent);
     505           8 :     if (-1 == nIndex)
     506           0 :         throw IllegalArgumentException();
     507             : 
     508           8 :     return (NULL != aMacros[nIndex]) && aMacros[nIndex]->HasMacro();
     509             : }
     510             : 
     511             : 
     512          10 : SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(const SvEventDescription* pSupportedMacroItems) :
     513          10 :     SvDetachedEventDescriptor(pSupportedMacroItems)
     514             : {
     515          10 : }
     516             : 
     517           2 : SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(
     518             :     const SvxMacroTableDtor& rMacroTable,
     519             :     const SvEventDescription* pSupportedMacroItems) :
     520           2 :         SvDetachedEventDescriptor(pSupportedMacroItems)
     521             : {
     522           2 :     copyMacrosFromTable(rMacroTable);
     523           2 : }
     524             : 
     525          24 : SvMacroTableEventDescriptor::~SvMacroTableEventDescriptor()
     526             : {
     527          24 : }
     528             : 
     529           2 : void SvMacroTableEventDescriptor::copyMacrosFromTable(
     530             :     const SvxMacroTableDtor& rMacroTable)
     531             : {
     532           6 :     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != 0; i++)
     533             :     {
     534           4 :         const sal_uInt16 nEvent = mpSupportedMacroItems[i].mnEvent;
     535           4 :         const SvxMacro* pMacro = rMacroTable.Get(nEvent);
     536           4 :         if (NULL != pMacro)
     537           0 :             replaceByName(nEvent, *pMacro);
     538             :     }
     539             : 
     540           2 : }
     541             : 
     542           4 : void SvMacroTableEventDescriptor::copyMacrosIntoTable(
     543             :     SvxMacroTableDtor& rMacroTable)
     544             : {
     545          12 :     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != 0; i++)
     546             :     {
     547           8 :         const sal_uInt16 nEvent = mpSupportedMacroItems[i].mnEvent;
     548           8 :         if (hasByName(nEvent))
     549             :         {
     550           0 :             SvxMacro& rMacro = rMacroTable.Insert(nEvent, SvxMacro(sEmpty, sEmpty));
     551           0 :             getByName(rMacro, nEvent);
     552             :         }
     553             :     }
     554           4 : }
     555             : 
     556             : 
     557             : 
     558             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10