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 OUString sAPI_ServiceName = u"com.sun.star.container.XNameReplace"_ustr;
  40 constexpr OUString sEventType = u"EventType"_ustr;
  41 constexpr OUString sMacroName = u"MacroName"_ustr;
  42 constexpr OUString sLibrary = u"Library"_ustr;
  43 constexpr OUString sStarBasic = u"StarBasic"_ustr;
  44 constexpr OUString sScript = u"Script"_ustr;
  45 constexpr OUString sNone = u"None"_ustr;
  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, 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, 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, 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 : 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( u""_ustr, u""_ustr );
 170     }
 171     else
 172     {
 173         if (eType == STARBASIC)
 174         {
 175             // create macro and return
 176             rMacro = SvxMacro(sMacroVal, sLibVal, eType);
 177         }
 178         else if (eType == EXTENDED_STYPE)
 179         {
 180             rMacro = SvxMacro(sScriptVal, sScript);
 181         }
 182         else
 183         {
 184             // we can't process type: abort
 185             // TODO: JavaScript macros
 186             throw IllegalArgumentException();
 187         }
 188     }
 189 }
 190
 191 }
 192
 193 SvBaseEventDescriptor::SvBaseEventDescriptor( const SvEventDescription* pSupportedMacroItems ) :
 194         mpSupportedMacroItems(pSupportedMacroItems),
 195         mnMacroItems(0)
 196 {
 197     assert(pSupportedMacroItems != nullptr && "Need a list of supported events!");
 198
 199     for( ; mpSupportedMacroItems[mnMacroItems].mnEvent != SvMacroItemId::NONE; mnMacroItems++) ;
 200 }
 201
 202
 203 SvBaseEventDescriptor::~SvBaseEventDescriptor()
 204 {
 205 }
 206
 207 void SvBaseEventDescriptor::replaceByName(
 208     const OUString& rName,
 209     const Any& rElement )
 210 {
 211     SvMacroItemId nMacroID = getMacroID(rName);
 212
 213     // error checking
 214     if (SvMacroItemId::NONE == nMacroID)
 215         throw NoSuchElementException();
 216     if (rElement.getValueType() != getElementType())
 217         throw IllegalArgumentException();
 218
 219     // get sequence
 220     Sequence<PropertyValue> aSequence;
 221     rElement >>= aSequence;
 222
 223     // perform replace (in subclass)
 224     SvxMacro aMacro(u""_ustr,u""_ustr);
 225     getMacroFromAny(aMacro, rElement);
 226     replaceByName(nMacroID, aMacro);
 227 }
 228
 229 Any SvBaseEventDescriptor::getByName(
 230     const OUString& rName )
 231 {
 232     SvMacroItemId nMacroID = getMacroID(rName);
 233
 234     // error checking
 235     if (SvMacroItemId::NONE == nMacroID)
 236         throw NoSuchElementException();
 237
 238     // perform get (in subclass)
 239     Any aAny;
 240     SvxMacro aMacro( u""_ustr, u""_ustr );
 241     getByName(aMacro, nMacroID);
 242     getAnyFromMacro(aAny, aMacro);
 243     return aAny;
 244 }
 245
 246 Sequence<OUString> SvBaseEventDescriptor::getElementNames()
 247 {
 248     // create and fill sequence
 249     Sequence<OUString> aSequence(mnMacroItems);
 250     auto aSequenceRange = asNonConstRange(aSequence);
 251     for( sal_Int16 i = 0; i < mnMacroItems; i++)
 252     {
 253         aSequenceRange[i] = OUString::createFromAscii( mpSupportedMacroItems[i].mpEventName );
 254     }
 255
 256     return aSequence;
 257 }
 258
 259 sal_Bool SvBaseEventDescriptor::hasByName(
 260     const OUString& rName )
 261 {
 262     SvMacroItemId nMacroID = getMacroID(rName);
 263     return (nMacroID != SvMacroItemId::NONE);
 264 }
 265
 266 Type SvBaseEventDescriptor::getElementType()
 267 {
 268     return cppu::UnoType<Sequence<PropertyValue>>::get();
 269 }
 270
 271 sal_Bool SvBaseEventDescriptor::hasElements()
 272 {
 273     return mnMacroItems != 0;
 274 }
 275
 276 sal_Bool SvBaseEventDescriptor::supportsService(const OUString& rServiceName)
 277 {
 278     return cppu::supportsService(this, rServiceName);
 279 }
 280
 281 Sequence<OUString> SvBaseEventDescriptor::getSupportedServiceNames()
 282 {
 283     return { sAPI_ServiceName };
 284 }
 285
 286 SvMacroItemId SvBaseEventDescriptor::mapNameToEventID(std::u16string_view rName) const
 287 {
 288     // iterate over known event names
 289     for(sal_Int16 i = 0; i < mnMacroItems; i++)
 290     {
 291         if( o3tl::equalsAscii(rName, mpSupportedMacroItems[i].mpEventName))
 292         {
 293             return mpSupportedMacroItems[i].mnEvent;
 294         }
 295     }
 296
 297     // not found -> return zero
 298     return SvMacroItemId::NONE;
 299 }
 300
 301 SvMacroItemId SvBaseEventDescriptor::getMacroID(std::u16string_view rName) const
 302 {
 303     return mapNameToEventID(rName);
 304 }
 305
 306 SvEventDescriptor::SvEventDescriptor(
 307     XInterface& rParent,
 308     const SvEventDescription* pSupportedMacroItems) :
 309         SvBaseEventDescriptor(pSupportedMacroItems),
 310         xParentRef(&rParent)
 311 {
 312 }
 313
 314
 315 SvEventDescriptor::~SvEventDescriptor()
 316 {
 317     // automatically release xParentRef !
 318 }
 319
 320 void SvEventDescriptor::replaceByName(
 321     const SvMacroItemId nEvent,
 322     const SvxMacro& rMacro)
 323 {
 324     SvxMacroItem aItem(getMacroItemWhich());
 325     aItem.SetMacroTable(getMacroItem().GetMacroTable());
 326     aItem.SetMacro(nEvent, rMacro);
 327     setMacroItem(aItem);
 328 }
 329
 330 void SvEventDescriptor::getByName(
 331     SvxMacro& rMacro,
 332     const SvMacroItemId nEvent )
 333 {
 334     const SvxMacroItem& rItem = getMacroItem();
 335     if (rItem.HasMacro(nEvent))
 336         rMacro = rItem.GetMacro(nEvent);
 337     else
 338         rMacro = SvxMacro(u""_ustr, u""_ustr);
 339 }
 340
 341 SvDetachedEventDescriptor::SvDetachedEventDescriptor(
 342     const SvEventDescription* pSupportedMacroItems) :
 343     SvBaseEventDescriptor(pSupportedMacroItems)
 344 {
 345     aMacros.resize(mnMacroItems);
 346 }
 347
 348 SvDetachedEventDescriptor::~SvDetachedEventDescriptor()
 349 {
 350 }
 351
 352 sal_Int16 SvDetachedEventDescriptor::getIndex(const SvMacroItemId nID) const
 353 {
 354     // iterate over supported events
 355     sal_Int16 nIndex = 0;
 356     while ( (mpSupportedMacroItems[nIndex].mnEvent != nID) &&
 357             (mpSupportedMacroItems[nIndex].mnEvent != SvMacroItemId::NONE)      )
 358     {
 359         nIndex++;
 360     }
 361     return (mpSupportedMacroItems[nIndex].mnEvent == nID) ? nIndex : -1;
 362 }
 363
 364 OUString SvDetachedEventDescriptor::getImplementationName()
 365 {
 366     return u"SvDetachedEventDescriptor"_ustr;
 367 }
 368
 369
 370 void SvDetachedEventDescriptor::replaceByName(
 371     const SvMacroItemId nEvent,
 372     const SvxMacro& rMacro)
 373 {
 374     sal_Int16 nIndex = getIndex(nEvent);
 375     if (-1 == nIndex)
 376         throw IllegalArgumentException();
 377
 378     aMacros[nIndex].reset( new SvxMacro(rMacro.GetMacName(), rMacro.GetLibName(),
 379                                    rMacro.GetScriptType() ) );
 380 }
 381
 382
 383 void SvDetachedEventDescriptor::getByName(
 384     SvxMacro& rMacro,
 385     const SvMacroItemId nEvent )
 386 {
 387     sal_Int16 nIndex = getIndex(nEvent);
 388     if (-1 == nIndex )
 389         throw NoSuchElementException();
 390
 391     if( aMacros[nIndex] )
 392         rMacro = *aMacros[nIndex];
 393 }
 394
 395 bool SvDetachedEventDescriptor::hasById(
 396     const SvMacroItemId nEvent ) const     /// item ID of event
 397 {
 398     sal_Int16 nIndex = getIndex(nEvent);
 399     if (-1 == nIndex)
 400         throw IllegalArgumentException();
 401
 402     return (nullptr != aMacros[nIndex]) && aMacros[nIndex]->HasMacro();
 403 }
 404
 405
 406 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(const SvEventDescription* pSupportedMacroItems) :
 407     SvDetachedEventDescriptor(pSupportedMacroItems)
 408 {
 409 }
 410
 411 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(
 412     const SvxMacroTableDtor& rMacroTable,
 413     const SvEventDescription* pSupportedMacroItems) :
 414         SvDetachedEventDescriptor(pSupportedMacroItems)
 415 {
 416     assert(mpSupportedMacroItems);
 417     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != SvMacroItemId::NONE; i++)
 418     {
 419         const SvMacroItemId nEvent = mpSupportedMacroItems[i].mnEvent;
 420         const SvxMacro* pMacro = rMacroTable.Get(nEvent);
 421         if (nullptr != pMacro)
 422             replaceByName(nEvent, *pMacro);
 423     }
 424 }
 425
 426 SvMacroTableEventDescriptor::~SvMacroTableEventDescriptor()
 427 {
 428 }
 429
 430 void SvMacroTableEventDescriptor::copyMacrosIntoTable(
 431     SvxMacroTableDtor& rMacroTable)
 432 {
 433     for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != SvMacroItemId::NONE; i++)
 434     {
 435         const SvMacroItemId nEvent = mpSupportedMacroItems[i].mnEvent;
 436         if (hasById(nEvent))
 437         {
 438             SvxMacro& rMacro = rMacroTable.Insert(nEvent, SvxMacro(u""_ustr, u""_ustr));
 439             getByName(rMacro, nEvent);
 440         }
 441     }
 442 }
 443
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */