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