/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#pragma once
#include <config_options.h>
#include <tools/ref.hxx>
#include <svl/hint.hxx>
#include <basic/sbxdef.hxx>
#include <basic/sbxobj.hxx>
#include <basic/basicdllapi.h>
#include <utility>
#include <vector>
#include <memory>
class SvStream;
// Parameter information
struct SbxParamInfo
{
const OUString aName;
// Name of the parameter
SbxDataType eType;
// Data type
SbxFlagBits nFlags;
// Flag-Bits
sal_uInt32 nUserData;
// IDs etc.
SbxParamInfo( OUString s, SbxDataType t, SbxFlagBits n )
: aName(std::move( s )), eType( t ), nFlags( n ), nUserData( 0 ) {}
};
typedef std::vector<std::unique_ptr<SbxParamInfo>> SbxParams;
class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) SbxInfo final :
public SvRefBase
{
friend class SbxVariable;
friend class SbMethod;
OUString aComment;
OUString aHelpFile;
sal_uInt32 nHelpId;
SbxParams m_Params;
SbxInfo(SbxInfo
const&) =
delete;
void operator=(SbxInfo
const&) =
delete;
void LoadData( SvStream&, sal_uInt16 );
void StoreData( SvStream& )
const;
virtual ~SbxInfo() override;
public:
SbxInfo();
SbxInfo( OUString , sal_uInt32 );
void AddParam(
const OUString&, SbxDataType, SbxFlagBits=SbxFlagBits::Read );
const SbxParamInfo* GetParam( sal_uInt16 n )
const;
// index starts with 1!
const OUString& GetComment()
const {
return aComment; }
const OUString& GetHelpFile()
const {
return aHelpFile; }
sal_uInt32 GetHelpId()
const {
return nHelpId; }
void SetComment(
const OUString& r ) { aComment = r; }
};
class BASIC_DLLPUBLIC SbxHint final :
public SfxHint
{
SbxVariable* pVar;
public:
SbxHint( SfxHintId n, SbxVariable* v ) : SfxHint( n ), pVar( v ) {}
~SbxHint() override;
SbxVariable* GetVar()
const {
return pVar; }
};
// SbxArray is an unidimensional, dynamic Array
// The variables convert from SbxVariablen. Put()/Insert() into the
// declared datatype, if they are not SbxVARIANT.
struct SbxVarEntry;
class BASIC_DLLPUBLIC SbxArray :
public SbxBase
{
// #100883 Method to set method directly to parameter array
friend class SbMethod;
friend class SbClassModuleObject;
friend SbxObjectRef cloneTypeObjectImpl(
const SbxObject& rTypeObj );
BASIC_DLLPRIVATE
void PutDirect( SbxVariable* pVar, sal_uInt32 nIdx );
std::vector<SbxVarEntry> mVarEntries;
// The variables
SbxDataType eType;
// Data type of the array
protected:
virtual ~SbxArray() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<
bool, sal_uInt32> StoreData( SvStream& )
const override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_ARRAY,1);
SbxArray( SbxDataType=SbxVARIANT );
SbxArray(
const SbxArray& ) =
delete;
SbxArray&
operator=(
const SbxArray& );
virtual void Clear() override;
sal_uInt32 Count()
const;
virtual SbxDataType GetType()
const override;
SbxVariableRef& GetRef(sal_uInt32);
SbxVariable* Get(sal_uInt32);
void Put(SbxVariable*, sal_uInt32);
void Insert(SbxVariable*, sal_uInt32);
void Remove( sal_uInt32 );
void Remove( SbxVariable
const * );
void Merge( SbxArray* );
const OUString & GetAlias(sal_uInt32);
void PutAlias(
const OUString&, sal_uInt32);
SbxVariable* Find(
const OUString&, SbxClassType );
};
// SbxDimArray is an array that can dimensioned using BASIC conventions.
struct SbxDim {
// an array-dimension:
sal_Int32 nLbound, nUbound;
// Limitations
sal_Int32 nSize;
// Number of elements
};
class BASIC_DLLPUBLIC SbxDimArray final :
public SbxArray
{
std::vector<SbxDim> m_vDimensions;
// Dimension table
BASIC_DLLPRIVATE
void AddDimImpl(sal_Int32, sal_Int32,
bool bAllowSize0);
bool mbHasFixedSize;
sal_uInt32 Offset(
const sal_Int32*);
sal_uInt32 Offset(SbxArray*);
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<
bool, sal_uInt32> StoreData( SvStream& )
const override;
virtual ~SbxDimArray() override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_DIMARRAY,1);
SbxDimArray( SbxDataType=SbxVARIANT );
SbxDimArray(
const SbxDimArray& ) =
delete;
SbxDimArray&
operator=(
const SbxDimArray& );
virtual void Clear() override;
SbxVariable* Get( SbxArray* );
using SbxArray::GetRef;
using SbxArray::Get;
SbxVariable* Get(
const sal_Int32*);
using SbxArray::Put;
void Put(SbxVariable*,
const sal_Int32*);
sal_Int32 GetDims()
const {
return m_vDimensions.size(); }
void AddDim(sal_Int32, sal_Int32);
void unoAddDim(sal_Int32, sal_Int32);
bool GetDim(sal_Int32, sal_Int32&, sal_Int32&)
const;
bool hasFixedSize()
const {
return mbHasFixedSize; };
void setHasFixedSize(
bool bHasFixedSize ) {mbHasFixedSize = bHasFixedSize; };
};
class SbxCollection :
public SbxObject
{
void Initialize();
protected:
virtual ~SbxCollection() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual void Notify( SfxBroadcaster& rBC,
const SfxHint& rHint ) override;
// Overridable methods (why not pure virtual?):
virtual void CollAdd( SbxArray* pPar );
void CollItem( SbxArray* pPar );
virtual void CollRemove( SbxArray* pPar );
public:
SBX_DECL_PERSIST_NODATA(SBXID_COLLECTION,1);
SbxCollection();
SbxCollection(
const SbxCollection& );
SbxCollection&
operator=(
const SbxCollection& );
virtual SbxVariable* Find(
const OUString&, SbxClassType ) override;
virtual void Clear() override;
};
class SbxStdCollection final :
public SbxCollection
{
OUString aElemClass;
bool bAddRemoveOk;
virtual ~SbxStdCollection() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<
bool, sal_uInt32> StoreData( SvStream& )
const override;
virtual void CollAdd( SbxArray* pPar ) override;
virtual void CollRemove( SbxArray* pPar ) override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_FIXCOLLECTION,1);
SbxStdCollection();
SbxStdCollection(
const SbxStdCollection& );
SbxStdCollection&
operator=(
const SbxStdCollection& );
virtual void Insert( SbxVariable* ) override;
};
typedef tools::SvRef<SbxArray> SbxArrayRef;
typedef tools::SvRef<SbxInfo> SbxInfoRef;
typedef tools::SvRef<SbxDimArray> SbxDimArrayRef;
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
