svtools/source/uno/unoevent.cxx

   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
  22 #include <comphelper/propertyvalue.hxx>
  23 #include <cppuhelper/supportsservice.hxx>
  24 #include <o3tl/string_view.hxx>
  25 #include <osl/diagnose.h>
  26 #include <sfx2/event.hxx>
  27 #include <svtools/unoevent.hxx>
  28 #include <svl/macitem.hxx>
  29
  30 using namespace ::com::sun::star;
  31 using namespace css::uno;
  32
  33 using css::container::NoSuchElementException;
  34 using css::container::XNameReplace;
  35 using css::lang::IllegalArgumentException;
  36 using css::beans::PropertyValue;
  37
  38
  39 constexpr OUStringLiteral sAPI_ServiceName = u"com.sun.star.container.XNameReplace";
  40 constexpr OUStringLiteral sEventType = u"EventType";
  41 constexpr OUStringLiteral sMacroName = u"MacroName";
  42 constexpr OUStringLiteral sLibrary = u"Library";
  43 constexpr OUStringLiteral sStarBasic = u"StarBasic";
  44 constexpr OUStringLiteral sScript = u"Script";
  45 constexpr OUStringLiteral sNone = u"None";
  46
  47 namespace {
  48
  49 void getAnyFromMacro(Any& rAny, const SvxMacro& rMacro)
  50 {
  51     bool bRetValueOK = false;   // do we have a ret value?
  52
  53     if (rMacro.HasMacro())
  54     {
  55         switch (rMacro.GetScriptType())
  56         {
  57             case STARBASIC:
  58             {
  59                 // create sequence
  60                 Sequence<PropertyValue> aSequence(
  61                       // create type
  62                     { comphelper::makePropertyValue(sEventType, OUString(sStarBasic)),
  63                       // macro name
  64                       comphelper::makePropertyValue(sMacroName, rMacro.GetMacName()),
  65                       // library name
  66                       comphelper::makePropertyValue(sLibrary, rMacro.GetLibName()) });
  67
  68                 rAny <<= aSequence;
  69                 bRetValueOK = true;
  70                 break;
  71             }
  72             case EXTENDED_STYPE:
  73             {
  74                 // create sequence
  75                 Sequence<PropertyValue> aSequence(
  76                       // create type
  77                     { comphelper::makePropertyValue(sEventType, OUString(sScript)),
  78                       // macro name
  79                       comphelper::makePropertyValue(sScript, rMacro.GetMacName()) });
  80
  81                 rAny <<= aSequence;
  82                 bRetValueOK = true;
  83                 break;
  84             }
  85             case JAVASCRIPT:
  86             default:
  87                 OSL_FAIL("not implemented");
  88         }
  89     }
  90     // else: bRetValueOK not set
  91
  92     // if we don't have a return value, make an empty one
  93     if ( bRetValueOK)
  94         return;
  95
  96     // create "None" macro
  97     Sequence<PropertyValue> aSequence{ comphelper::makePropertyValue(sEventType, OUString(sNone)) };
  98     rAny <<= aSequence;
  99 }
 100
 101 /// @throws IllegalArgumentException
 102 void getMacroFromAny(
 103     SvxMacro& rMacro,
 104     const Any& rAny)
 105 {
 106     // get sequence
 107     Sequence<PropertyValue> aSequence;
 108     rAny >>= aSequence;
 109
 110     // process ...
 111     bool bTypeOK = false;
 112     bool bNone = false;     // true if EventType=="None"
 113     enum ScriptType eType = EXTENDED_STYPE;
 114     OUString sScriptVal;
 115     OUString sMacroVal;
 116     OUString sLibVal;
 117     for (const PropertyValue& aValue : std::as_const(aSequence))
 118     {
 119         if (aValue.Name == sEventType)
 120         {
 121             OUString sTmp;
 122             aValue.Value >>= sTmp;
 123             if (sTmp == sStarBasic)
 124             {
 125                 eType = STARBASIC;
 126                 bTypeOK = true;
 127             }
 128             else if (sTmp == "JavaScript")
 129             {
 130                 eType = JAVASCRIPT;
 131                 bTypeOK = true;
 132             }
 133             else if (sTmp == sScript)
 134             {
 135                 eType = EXTENDED_STYPE;
 136                 bTypeOK = true;
 137             }
 138             else if (sTmp == sNone)
 139             {
 140                 bNone = true;
 141                 bTypeOK = true;
 142             }
 143             // else: unknown script type
 144         }
 145         else if (aValue.Name == sMacroName)
 146         {
 147             aValue.Value >>= sMacroVal;
 148         }
 149         else if (aValue.Name == sLibrary)
 150         {
 151             aValue.Value >>= sLibVal;
 152         }
 153         else if (aValue.Name == sScript)
 154         {
 155             aValue.Value >>= sScriptVal;
 156         }
 157         // else: unknown PropertyValue -> ignore
 158     }
 159
 160     if (!bTypeOK)
 161     {
 162         // no valid type: abort
 163         throw IllegalArgumentException();
 164     }
 165
 166     if (bNone)
 167     {
 168         // return empty macro
 169         rMacro = SvxMacro( "", "" );
 170     }
 171     else
 172     {
 173         if (eType == STARBASIC)
 174         {
 175             // create macro and return
 176             SvxMacro aMacro(sMacroVal, sLibVal, eType);
 177             rMacro = aMacro;
 178         }
 179         else if (eType == EXTENDED_STYPE)
 180         {
 181             SvxMacro aMacro(sScriptVal, sScript);
 182             rMacro = aMacro;
 183         }
 184         else
 185         {
 186             // we can't process type: abort
 187             // TODO: JavaScript macros
 188             throw IllegalArgumentException();
 189         }
 190     }
 191 }
 192
 193 }
 194
 195 SvBaseEventDescriptor::SvBaseEventDescriptor( const SvEventDescription* pSupportedMacroItems ) :
 196         mpSupportedMacroItems(pSupportedMacroItems),
 197         mnMacroItems(0)
 198 {
 199     assert(pSupportedMacroItems != nullptr && "Need a list of supported events!");
 200
 201     for( ; mpSupportedMacroItems[mnMacroItems].mnEvent != SvMacroItemId::NONE; mnMacroItems++) ;
 202 }
 203
 204
 205 SvBaseEventDescriptor::~SvBaseEventDescriptor()
 206 {
 207 }
 208
 209 void SvBaseEventDescriptor::replaceByName(
 210     const OUString& rName,
 211     const Any& rElement )
 212 {
 213     SvMacroItemId nMacroID = getMacroID(rName);
 214
 215     // error checking
 216     if (SvMacroItemId::NONE == nMacroID)
 217         throw NoSuchElementException();
 218     if (rElement.getValueType() != getElementType())
 219         throw IllegalArgumentException();
 220
 221     // get sequence
 222     Sequence<PropertyValue> aSequence;
 223     rElement >>= aSequence;
 224
 225     // perform replace (in subclass)
 226     SvxMacro aMacro("","");
 227     getMacroFromAny(aMacro, rElement);
 228     replaceByName(nMacroID, aMacro);
 229 }
 230
 231 Any SvBaseEventDescriptor::getByName(
 232     const OUString& rName )
 233 {
 234     SvMacroItemId nMacroID = getMacroID(rName);
 235
 236     // error checking
 237     if (SvMacroItemId::NONE == nMacroID)
 238         throw NoSuchElementException();
 239
 240     // perform get (in subclass)
 241     Any aAny;
 242     SvxMacro aMacro( "", "" );
 243     getByName(aMacro, nMacroID);
 244     getAnyFromMacro(aAny, aMacro);
 245     return aAny;
 246 }
 247
 248 Sequence<OUString> SvBaseEventDescriptor::getElementNames()
 249 {
 250     // create and fill sequence
 251     Sequence<OUString> aSequence(mnMacroItems);
 252     auto aSequenceRange = asNonConstRange(aSequence);
 253     for( sal_Int16 i = 0; i < mnMacroItems; i++)
 254     {
 255         aSequenceRange[i] = OUString::createFromAscii( mpSupportedMacroItems[i].mpEventName );
 256     }
 257
 258     return aSequence;
 259 }
 260
 261 sal_Bool SvBaseEventDescriptor::hasByName(
 262     const OUString& rName )
 263 {
 264     SvMacroItemId nMacroID = getMacroID(rName);
 265     return (nMacroID != SvMacroItemId::NONE);
 266 }
 267
 268 Type SvBaseEventDescriptor::getElementType()
 269 {
 270     return cppu::UnoType<Sequence<PropertyValue>>::get();
 271 }
 272
 273 sal_Bool SvBaseEventDescriptor::hasElements()
 274 {
 275     return mnMacroItems != 0;
 276 }
 277
 278 sal_Bool SvBaseEventDescriptor::supportsService(const OUString& rServiceName)
 279 {
 280     return cppu::supportsService(this, rServiceName);
 281 }
 282
 283 Sequence<OUString> SvBaseEventDescriptor::getSupportedServiceNames()
 284 {
 285     return { sAPI_ServiceName };
 286 }
 287
 288 SvMacroItemId SvBaseEventDescriptor::mapNameToEventID(std::u16string_view rName) const
 289 {
 290     // iterate over known event names
 291     for(sal_Int16 i = 0; i < mnMacroItems; i++)
 292     {
 293         if( o3tl::equalsAscii(rName, mpSupportedMacroItems[i].mpEventName))
 294         {
 295             return mpSupportedMacroItems[i].mnEvent;
 296         }
 297     }
 298
 299     // not found -> return zero
 300     return SvMacroItemId::NONE;
 301 }
 302
 303 SvMacroItemId SvBaseEventDescriptor::getMacroID(std::u16string_view rName) const
 304 {
 305     return mapNameToEventID(rName);
 306 }
 307
 308 SvEventDescriptor::SvEventDescriptor(
 309     XInterface& rParent,
 310     const SvEventDescription* pSupportedMacroItems) :
 311         SvBaseEventDescriptor(pSupportedMacroItems),
 312         xParentRef(&rParent)
 313 {
 314 }
 315
 316
 317 SvEventDescriptor::~SvEventDescriptor()
 318 {
 319     // automatically release xParentRef !
 320 }
 321
 322 void SvEventDescriptor::replaceByName(
 323     const SvMacroItemId nEvent,
 324     const SvxMacro& rMacro)
 325 {
 326     SvxMacroItem aItem(getMacroItemWhich());
 327     aItem.SetMacroTable(getMacroItem().GetMacroTable());
 328     aItem.SetMacro(nEvent, rMacro);
 329     setMacroItem(aItem);
 330 }
 331
 332 void SvEventDescriptor::getByName(
 333     SvxMacro& rMacro,
 334     const SvMacroItemId nEvent )
 335 {
 336     const SvxMacroItem& rItem = getMacroItem();
 337     if( rItem.HasMacro( nEvent ) )
 338         rMacro = rItem.GetMacro(nEvent);
 339     else
 340     {
 341         SvxMacro aEmptyMacro("", "");
 342         rMacro = aEmptyMacro;
 343     }
 344 }
 345
 346 SvDetachedEventDescriptor::SvDetachedEventDescriptor(
 347     const SvEventDescription* pSupportedMacroItems) :
 348     SvBaseEventDescriptor(pSupportedMacroItems)
 349 {
 350     aMacros.resize(mnMacroItems);
 351 }
 352
 353 SvDetachedEventDescriptor::~SvDetachedEventDescriptor()
 354 {
 355 }
 356
 357 sal_Int16 SvDetachedEventDescriptor::getIndex(const SvMacroItemId nID) const
 358 {
 359     // iterate over supported events
 360     sal_Int16 nIndex = 0;
 361     while ( (mpSupportedMacroItems[nIndex].mnEvent != nID) &&
 362             (mpSupportedMacroItems[nIndex].mnEvent != SvMacroItemId::NONE)      )
 363     {
 364         nIndex++;
 365     }
 366     return (mpSupportedMacroItems[nIndex].mnEvent == nID) ? nIndex : -1;
 367 }
 368
 369 OUString SvDetachedEventDescriptor::getImplementationName()
 370 {
 371     return "SvDetachedEventDescriptor";
 372 }
 373
 374
 375 void SvDetachedEventDescriptor::replaceByName(
 376     const SvMacroItemId nEvent,
 377     const SvxMacro& rMacro)
 378 {
 379     sal_Int16 nIndex = getIndex(nEvent);
 380     if (-1 == nIndex)
 381         throw IllegalArgumentException();
 382
 383     aMacros[nIndex].reset( new SvxMacro(rMacro.GetMacName(), rMacro.GetLibName(),
 384                                    rMacro.GetScriptType() ) );
 385 }
 386
 387
 388 void SvDetachedEventDescriptor::getByName(
 389     SvxMacro& rMacro,
 390     const SvMacroItemId nEvent )
 391 {
 392     sal_Int16 nIndex = getIndex(nEvent);
 393     if (-1 == nIndex )
 394         throw NoSuchElementException();
 395
 396     if( aMacros[nIndex] )
 397         rMacro = *aMacros[nIndex];
 398 }
 399
 400 bool SvDetachedEventDescriptor::hasById(
 401     const SvMacroItemId nEvent ) const     /// item ID of event
 402 {
 403     sal_Int16 nIndex = getIndex(nEvent);
 404     if (-1 == nIndex)
 405         throw IllegalArgumentException();
 406
 407     return (nullptr != aMacros[nIndex]) && aMacros[nIndex]->HasMacro();
 408 }
 409
 410
 411 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(const SvEventDescription* pSupportedMacroItems) :
 412     SvDetachedEventDescriptor(pSupportedMacroItems)
 413 {
 414 }
 415
 416 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(
 417     const SvxMacroTableDtor& rMacroTable,
 418     const SvEventDescription* pSupportedMacroItems) :
 419         SvDetachedEventDescriptor(pSupportedMacroItems)
 420 {
 421     assert(mpSupportedMacroItems);
 422     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != SvMacroItemId::NONE; i++)
 423     {
 424         const SvMacroItemId nEvent = mpSupportedMacroItems[i].mnEvent;
 425         const SvxMacro* pMacro = rMacroTable.Get(nEvent);
 426         if (nullptr != pMacro)
 427             replaceByName(nEvent, *pMacro);
 428     }
 429 }
 430
 431 SvMacroTableEventDescriptor::~SvMacroTableEventDescriptor()
 432 {
 433 }
 434
 435 void SvMacroTableEventDescriptor::copyMacrosIntoTable(
 436     SvxMacroTableDtor& rMacroTable)
 437 {
 438     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != SvMacroItemId::NONE; i++)
 439     {
 440         const SvMacroItemId nEvent = mpSupportedMacroItems[i].mnEvent;
 441         if (hasById(nEvent))
 442         {
 443             SvxMacro& rMacro = rMacroTable.Insert(nEvent, SvxMacro("", ""));
 444             getByName(rMacro, nEvent);
 445         }
 446     }
 447 }
 448
 449
 450 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */