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

Generated by: LCOV version 1.10