sw/source/core/doc/docbasic.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 <hintids.hxx>
  21
  22 #include <rtl/ustring.hxx>
  23 #include <sal/log.hxx>
  24 #include <vcl/imap.hxx>
  25 #include <vcl/imapobj.hxx>
  26 #include <basic/sbx.hxx>
  27 #include <frmfmt.hxx>
  28 #include <fmtinfmt.hxx>
  29 #include <fmturl.hxx>
  30 #include <frmatr.hxx>
  31 #include <doc.hxx>
  32 #include <docsh.hxx>
  33 #include <swevent.hxx>
  34 #include <frameformats.hxx>
  35 #include <memory>
  36
  37 using namespace ::com::sun::star::uno;
  38
  39 static Sequence<Any> *lcl_docbasic_convertArgs( SbxArray& rArgs )
  40 {
  41     Sequence<Any> *pRet = nullptr;
  42
  43     sal_uInt32 nCount = rArgs.Count();
  44     if( nCount > 1 )
  45     {
  46         nCount--;
  47         pRet = new Sequence<Any>( nCount );
  48         Any *pUnoArgs = pRet->getArray();
  49         for( sal_uInt32 i=0; i<nCount; i++ )
  50         {
  51             SbxVariable* pVar = rArgs.Get(i + 1);
  52             switch( pVar->GetType() )
  53             {
  54             case SbxSTRING:
  55                 pUnoArgs[i] <<= pVar->GetOUString();
  56                 break;
  57             case SbxCHAR:
  58                 pUnoArgs[i] <<= static_cast<sal_Int16>(pVar->GetChar()) ;
  59                 break;
  60             case SbxUSHORT:
  61                 pUnoArgs[i] <<= static_cast<sal_Int16>(pVar->GetUShort());
  62                 break;
  63             case SbxLONG:
  64                 pUnoArgs[i] <<= pVar->GetLong();
  65                 break;
  66             default:
  67                 pUnoArgs[i].clear();
  68                 break;
  69             }
  70         }
  71     }
  72
  73     return pRet;
  74 }
  75
  76 void SwDoc::ExecMacro( const SvxMacro& rMacro, OUString* pRet, SbxArray* pArgs )
  77 {
  78     switch( rMacro.GetScriptType() )
  79     {
  80     case STARBASIC:
  81         {
  82             SbxBaseRef aRef;
  83             SbxValue* pRetValue = new SbxValue;
  84             aRef = pRetValue;
  85             mpDocShell->CallBasic( rMacro.GetMacName(),
  86                                          rMacro.GetLibName(),
  87                                          pArgs, pRet ? pRetValue : nullptr );
  88
  89             if( pRet && SbxNULL <  pRetValue->GetType() &&
  90                         SbxVOID != pRetValue->GetType() )
  91             {
  92                 // valid value, so set it
  93                 *pRet = pRetValue->GetOUString();
  94             }
  95         }
  96         break;
  97     case JAVASCRIPT:
  98         // ignore JavaScript calls
  99         break;
 100     case EXTENDED_STYPE:
 101         {
 102             std::unique_ptr<Sequence<Any> > pUnoArgs;
 103             if( pArgs )
 104             {
 105                 // better to rename the local function to lcl_translateBasic2Uno and
 106                 // a much shorter routine can be found in sfx2/source/doc/objmisc.cxx
 107                 pUnoArgs.reset(lcl_docbasic_convertArgs( *pArgs ));
 108             }
 109
 110             if (!pUnoArgs)
 111             {
 112                 pUnoArgs.reset(new Sequence< Any > (0));
 113             }
 114
 115             // TODO - return value is not handled
 116             Any aRet;
 117             Sequence< sal_Int16 > aOutArgsIndex;
 118             Sequence< Any > aOutArgs;
 119
 120             SAL_INFO("sw", "SwDoc::ExecMacro URL is " << rMacro.GetMacName() );
 121
 122             mpDocShell->CallXScript(
 123                 rMacro.GetMacName(), *pUnoArgs, aRet, aOutArgsIndex, aOutArgs);
 124
 125             break;
 126         }
 127     }
 128 }
 129
 130 sal_uInt16 SwDoc::CallEvent( SvMacroItemId nEvent, const SwCallMouseEvent& rCallEvent,
 131                     bool bCheckPtr )
 132 {
 133     if( !mpDocShell )        // we can't do that without a DocShell!
 134         return 0;
 135
 136     sal_uInt16 nRet = 0;
 137     const SvxMacroTableDtor* pTable = nullptr;
 138     switch( rCallEvent.eType )
 139     {
 140     case EVENT_OBJECT_INETATTR:
 141         if( bCheckPtr  )
 142         {
 143             for (const SfxPoolItem* pItem : GetAttrPool().GetItemSurrogates(RES_TXTATR_INETFMT))
 144             {
 145                 auto pFormatItem = dynamic_cast<const SwFormatINetFormat*>(pItem);
 146                 if( pFormatItem && rCallEvent.PTR.pINetAttr == pFormatItem )
 147                 {
 148                     bCheckPtr = false;       // misuse as a flag
 149                     break;
 150                 }
 151             }
 152         }
 153         if( !bCheckPtr )
 154             pTable = rCallEvent.PTR.pINetAttr->GetMacroTable();
 155         break;
 156
 157     case EVENT_OBJECT_URLITEM:
 158     case EVENT_OBJECT_IMAGE:
 159         {
 160             const auto pSpz = static_cast<const sw::SpzFrameFormat*>(rCallEvent.PTR.pFormat);
 161             if( bCheckPtr )
 162             {
 163                 if (GetSpzFrameFormats()->IsAlive(pSpz))
 164                     bCheckPtr = false;      // misuse as a flag
 165                 else
 166                     // this shouldn't be possible now that SwCallMouseEvent
 167                     // listens for dying format?
 168                     assert(false);
 169             }
 170             if( !bCheckPtr )
 171                 pTable = &pSpz->GetMacro().GetMacroTable();
 172         }
 173         break;
 174
 175     case EVENT_OBJECT_IMAGEMAP:
 176         {
 177             const IMapObject* pIMapObj = rCallEvent.PTR.IMAP.pIMapObj;
 178             if( bCheckPtr )
 179             {
 180                 const auto pSpz = static_cast<const sw::SpzFrameFormat*>(rCallEvent.PTR.IMAP.pFormat);
 181                 if (GetSpzFrameFormats()->IsAlive(pSpz))
 182                 {
 183                     const ImageMap* pIMap = pSpz->GetURL().GetMap();
 184                     if (pIMap)
 185                     {
 186                         for( size_t nPos = pIMap->GetIMapObjectCount(); nPos; )
 187                             if( pIMapObj == pIMap->GetIMapObject( --nPos ))
 188                             {
 189                                 bCheckPtr = false;      // misuse as a flag
 190                                 break;
 191                             }
 192                     }
 193                 }
 194             }
 195             if( !bCheckPtr )
 196                 pTable = &pIMapObj->GetMacroTable();
 197         }
 198         break;
 199     default:
 200         break;
 201     }
 202
 203     if( pTable )
 204     {
 205         nRet = 0x1;
 206         if( pTable->IsKeyValid( nEvent ) )
 207         {
 208             const SvxMacro& rMacro = *pTable->Get( nEvent );
 209             if( STARBASIC == rMacro.GetScriptType() )
 210             {
 211                 nRet += ERRCODE_NONE == mpDocShell->CallBasic( rMacro.GetMacName(),
 212                                     rMacro.GetLibName(), nullptr ) ? 1 : 0;
 213             }
 214             else if( EXTENDED_STYPE == rMacro.GetScriptType() )
 215             {
 216                 Sequence<Any> aUnoArgs;
 217
 218                 Any aRet;
 219                 Sequence< sal_Int16 > aOutArgsIndex;
 220                 Sequence< Any > aOutArgs;
 221
 222                 SAL_INFO("sw", "SwDoc::CallEvent URL is " << rMacro.GetMacName() );
 223
 224                 nRet += ERRCODE_NONE == mpDocShell->CallXScript(
 225                     rMacro.GetMacName(), aUnoArgs, aRet, aOutArgsIndex, aOutArgs) ? 1 : 0;
 226             }
 227             // JavaScript calls are ignored
 228         }
 229     }
 230     return nRet;
 231 }
 232
 233 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */