basic/source/sbx/sbxbase.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 <memory>
  21 #include <tools/debug.hxx>
  22 #include <tools/stream.hxx>
  23 #include <vcl/svapp.hxx>
  24
  25 #include <basic/sbx.hxx>
  26 #include <sbxfac.hxx>
  27 #include <sbxform.hxx>
  28 #include <basic/sbxmeth.hxx>
  29 #include <sbxprop.hxx>
  30 #include <sbxbase.hxx>
  31
  32 #include <rtl/ustring.hxx>
  33 #include <sal/log.hxx>
  34
  35 // AppData-Structure for SBX:
  36
  37
  38 SbxAppData::SbxAppData()
  39     : eErrCode(ERRCODE_NONE)
  40     , eBasicFormaterLangType(LANGUAGE_DONTKNOW)
  41 {
  42 }
  43
  44 SbxAppData::~SbxAppData()
  45 {
  46     SolarMutexGuard g;
  47
  48     pBasicFormater.reset();
  49     // basic manager repository must be destroyed before factories
  50     mrImplRepository.clear();
  51 }
  52
  53 SbxBase::SbxBase()
  54 {
  55     nFlags  = SbxFlagBits::ReadWrite;
  56 }
  57
  58 SbxBase::SbxBase( const SbxBase& r )
  59     : SvRefBase( r )
  60 {
  61     nFlags  = r.nFlags;
  62 }
  63
  64 SbxBase::~SbxBase()
  65 {
  66 }
  67
  68 SbxBase& SbxBase::operator=( const SbxBase& r )
  69 {
  70     nFlags = r.nFlags;
  71     return *this;
  72 }
  73
  74 SbxDataType SbxBase::GetType() const
  75 {
  76     return SbxEMPTY;
  77 }
  78
  79 bool SbxBase::IsFixed() const
  80 {
  81     return IsSet( SbxFlagBits::Fixed );
  82 }
  83
  84 void SbxBase::SetModified( bool b )
  85 {
  86     if( IsSet( SbxFlagBits::NoModify ) )
  87         return;
  88     if( b )
  89         SetFlag( SbxFlagBits::Modified );
  90     else
  91         ResetFlag( SbxFlagBits::Modified );
  92 }
  93
  94 ErrCode const & SbxBase::GetError()
  95 {
  96     return GetSbxData_Impl().eErrCode;
  97 }
  98
  99 void SbxBase::SetError( ErrCode e )
 100 {
 101     SbxAppData& r = GetSbxData_Impl();
 102     if( e && r.eErrCode == ERRCODE_NONE )
 103         r.eErrCode = e;
 104 }
 105
 106 bool SbxBase::IsError()
 107 {
 108     return GetSbxData_Impl().eErrCode != ERRCODE_NONE;
 109 }
 110
 111 void SbxBase::ResetError()
 112 {
 113     GetSbxData_Impl().eErrCode = ERRCODE_NONE;
 114 }
 115
 116 void SbxBase::AddFactory( SbxFactory* pFac )
 117 {
 118     GetSbxData_Impl().m_Factories.emplace_back(pFac);
 119 }
 120
 121 void SbxBase::RemoveFactory( SbxFactory const * pFac )
 122 {
 123     if (!IsSbxData_Impl())
 124         return;
 125     SbxAppData& r = GetSbxData_Impl();
 126     auto it = std::find(r.m_Factories.begin(), r.m_Factories.end(), pFac);
 127     if (it != r.m_Factories.end())
 128         r.m_Factories.erase( it );
 129 }
 130
 131
 132 SbxBase* SbxBase::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
 133 {
 134     // #91626: Hack to skip old Basic dialogs
 135     // Problem: There does not exist a factory any more,
 136     // so we have to create a dummy SbxVariable instead
 137     if( nSbxId == 0x65 )    // Dialog Id
 138         return new SbxVariable;
 139
 140     if( nCreator == SBXCR_SBX )
 141       switch( nSbxId )
 142     {
 143         case SBXID_VALUE:       return new SbxValue;
 144         case SBXID_VARIABLE:    return new SbxVariable;
 145         case SBXID_ARRAY:       return new SbxArray;
 146         case SBXID_DIMARRAY:    return new SbxDimArray;
 147         case SBXID_OBJECT:      return new SbxObject( "" );
 148         case SBXID_COLLECTION:  return new SbxCollection;
 149         case SBXID_FIXCOLLECTION:
 150                                 return new SbxStdCollection;
 151         case SBXID_METHOD:      return new SbxMethod( "", SbxEMPTY );
 152         case SBXID_PROPERTY:    return new SbxProperty( "", SbxEMPTY );
 153     }
 154     // Unknown type: go over the factories!
 155     SbxAppData& r = GetSbxData_Impl();
 156     SbxBase* pNew = nullptr;
 157     for (auto const& rpFac : r.m_Factories)
 158     {
 159         pNew = rpFac->Create( nSbxId, nCreator );
 160         if( pNew )
 161             break;
 162     }
 163     SAL_WARN_IF(!pNew, "basic", "No factory for SBX ID " << nSbxId);
 164     return pNew;
 165 }
 166
 167 SbxObject* SbxBase::CreateObject( const OUString& rClass )
 168 {
 169     SbxAppData& r = GetSbxData_Impl();
 170     SbxObject* pNew = nullptr;
 171     for (auto const& rpFac : r.m_Factories)
 172     {
 173         pNew = rpFac->CreateObject( rClass );
 174         if( pNew )
 175             break;
 176     }
 177     SAL_WARN_IF(!pNew, "basic", "No factory for object class " << rClass);
 178     return pNew;
 179 }
 180
 181 SbxBase* SbxBase::Load( SvStream& rStrm )
 182 {
 183     sal_uInt16 nSbxId, nFlagsTmp, nVer;
 184     sal_uInt32 nCreator, nSize;
 185     rStrm.ReadUInt32( nCreator ).ReadUInt16( nSbxId ).ReadUInt16( nFlagsTmp ).ReadUInt16( nVer );
 186     SbxFlagBits nFlags = static_cast<SbxFlagBits>(nFlagsTmp);
 187
 188     // Correcting a foolishness of mine:
 189     if( nFlags & SbxFlagBits::Reserved )
 190         nFlags = ( nFlags & ~SbxFlagBits::Reserved ) | SbxFlagBits::GlobalSearch;
 191
 192     sal_uInt64 nOldPos = rStrm.Tell();
 193     rStrm.ReadUInt32( nSize );
 194     SbxBase* p = Create( nSbxId, nCreator );
 195     if( p )
 196     {
 197         p->nFlags = nFlags;
 198         if( p->LoadData( rStrm, nVer ) )
 199         {
 200             sal_uInt64 const nNewPos = rStrm.Tell();
 201             nOldPos += nSize;
 202             DBG_ASSERT( nOldPos >= nNewPos, "SBX: Too much data loaded" );
 203             if( nOldPos != nNewPos )
 204                 rStrm.Seek( nOldPos );
 205             if( !p->LoadCompleted() )
 206             {
 207                 // Deleting of the object
 208                 SbxBaseRef xDeleteRef( p );
 209                 p = nullptr;
 210             }
 211         }
 212         else
 213         {
 214             rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 215             // Deleting of the object
 216             SbxBaseRef xDeleteRef( p );
 217             p = nullptr;
 218         }
 219     }
 220     else
 221         rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 222     return p;
 223 }
 224
 225 bool SbxBase::Store( SvStream& rStrm )
 226 {
 227     if( ( nFlags & SbxFlagBits::DontStore ) == SbxFlagBits::NONE )
 228     {
 229         rStrm.WriteUInt32( SBXCR_SBX )
 230              .WriteUInt16( GetSbxId() )
 231              .WriteUInt16( static_cast<sal_uInt16>(GetFlags()) )
 232              .WriteUInt16( GetVersion() );
 233         sal_uInt64 const nOldPos = rStrm.Tell();
 234         rStrm.WriteUInt32( 0 );
 235         bool bRes = StoreData( rStrm );
 236         sal_uInt64 const nNewPos = rStrm.Tell();
 237         rStrm.Seek( nOldPos );
 238         rStrm.WriteUInt32( nNewPos - nOldPos );
 239         rStrm.Seek( nNewPos );
 240         if( rStrm.GetError() != ERRCODE_NONE )
 241             bRes = false;
 242         if( bRes )
 243             bRes = true;
 244         return bRes;
 245     }
 246     else
 247         return true;
 248 }
 249
 250 bool SbxBase::LoadCompleted()
 251 {
 252     return true;
 253 }
 254
 255 //////////////////////////////// SbxFactory
 256
 257 SbxFactory::~SbxFactory()
 258 {
 259 }
 260
 261 SbxBase* SbxFactory::Create( sal_uInt16, sal_uInt32 )
 262 {
 263     return nullptr;
 264 }
 265
 266 SbxObject* SbxFactory::CreateObject( const OUString& )
 267 {
 268     return nullptr;
 269 }
 270
 271 ///////////////////////////////// SbxInfo
 272
 273 SbxInfo::~SbxInfo()
 274 {}
 275
 276 void SbxInfo::AddParam(const OUString& rName, SbxDataType eType, SbxFlagBits nFlags)
 277 {
 278     m_Params.push_back(std::make_unique<SbxParamInfo>(rName, eType, nFlags));
 279 }
 280
 281 const SbxParamInfo* SbxInfo::GetParam( sal_uInt16 n ) const
 282 {
 283     if (n < 1 || n > m_Params.size())
 284         return nullptr;
 285     else
 286         return m_Params[n - 1].get();
 287 }
 288
 289 void SbxInfo::LoadData( SvStream& rStrm, sal_uInt16 nVer )
 290 {
 291     m_Params.clear();
 292     sal_uInt16 nParam;
 293     aComment = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 294         RTL_TEXTENCODING_ASCII_US);
 295     aHelpFile = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 296         RTL_TEXTENCODING_ASCII_US);
 297     rStrm.ReadUInt32( nHelpId ).ReadUInt16( nParam );
 298     while( nParam-- )
 299     {
 300         sal_uInt16 nType, nFlagsTmp;
 301         sal_uInt32 nUserData = 0;
 302         OUString aName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 303             RTL_TEXTENCODING_ASCII_US);
 304         rStrm.ReadUInt16( nType ).ReadUInt16( nFlagsTmp );
 305         SbxFlagBits nFlags = static_cast<SbxFlagBits>(nFlagsTmp);
 306         if( nVer > 1 )
 307             rStrm.ReadUInt32( nUserData );
 308         AddParam( aName, static_cast<SbxDataType>(nType), nFlags );
 309         SbxParamInfo& p(*m_Params.back());
 310         p.nUserData = nUserData;
 311     }
 312 }
 313
 314 void SbxInfo::StoreData( SvStream& rStrm ) const
 315 {
 316     write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, aComment,
 317         RTL_TEXTENCODING_ASCII_US );
 318     write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, aHelpFile,
 319         RTL_TEXTENCODING_ASCII_US);
 320     rStrm.WriteUInt32( nHelpId ).WriteUInt16( m_Params.size() );
 321     for (auto const& i : m_Params)
 322     {
 323         write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, i->aName,
 324             RTL_TEXTENCODING_ASCII_US);
 325         rStrm.WriteUInt16( i->eType )
 326              .WriteUInt16( static_cast<sal_uInt16>(i->nFlags) )
 327              .WriteUInt32( i->nUserData );
 328     }
 329 }
 330
 331 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */