2029 lines
63 KiB
C++
2029 lines
63 KiB
C++
/*************************************************************************
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: slot.cxx,v $
|
|
*
|
|
* $Revision: 1.15 $
|
|
*
|
|
* last change: $Author: rt $ $Date: 2005-09-07 17:51:06 $
|
|
*
|
|
* The Contents of this file are made available subject to
|
|
* the terms of GNU Lesser General Public License Version 2.1.
|
|
*
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2005 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
************************************************************************/
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <tools/debug.hxx>
|
|
#include <attrib.hxx>
|
|
#include <slot.hxx>
|
|
#include <globals.hxx>
|
|
#include <database.hxx>
|
|
#pragma hdrstop
|
|
|
|
|
|
/****************** SvMetaSlot *****************************************/
|
|
SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute );
|
|
#ifdef IDL_COMPILER
|
|
SvAttributeList & SvMetaSlot::GetAttributeList()
|
|
{
|
|
if( !pAttribList )
|
|
{
|
|
pAttribList = new SvAttributeList();
|
|
}
|
|
return *pAttribList;
|
|
}
|
|
#endif
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::SvMetaSlot()
|
|
|*
|
|
|* Beschreibung Zweites FALSE bei den SvBOOL-Objekten bedeutet,
|
|
|* IsSet() liefert FALSE (Defaultinitialisierung).
|
|
*************************************************************************/
|
|
SvMetaSlot::SvMetaSlot()
|
|
: aCachable( TRUE, FALSE )
|
|
, aSynchron( TRUE, FALSE )
|
|
, aRecordPerSet( TRUE, FALSE )
|
|
, aRecordAbsolute( FALSE, FALSE )
|
|
, pLinkedSlot(0)
|
|
, pNextSlot(0)
|
|
, pEnumValue(0)
|
|
{
|
|
}
|
|
|
|
SvMetaSlot::SvMetaSlot( SvMetaType * pType )
|
|
: SvMetaAttribute( pType )
|
|
, aCachable( TRUE, FALSE )
|
|
, aSynchron( TRUE, FALSE )
|
|
, aRecordPerSet( TRUE, FALSE )
|
|
, aRecordAbsolute( FALSE, FALSE )
|
|
, pLinkedSlot(0)
|
|
, pNextSlot(0)
|
|
, pEnumValue(0)
|
|
{
|
|
}
|
|
|
|
/*
|
|
#define TEST_READ \
|
|
{ \
|
|
UINT32 nPos; \
|
|
rStm >> nPos; \
|
|
DBG_ASSERT( nPos +4 == rStm.Tell(), "stream pos error" ); \
|
|
}
|
|
|
|
#define TEST_WRITE \
|
|
rStm << (UINT32)rStm.Tell();
|
|
*/
|
|
#define TEST_READ
|
|
#define TEST_WRITE
|
|
|
|
void SvMetaSlot::Load( SvPersistStream & rStm )
|
|
{
|
|
SvMetaAttribute::Load( rStm );
|
|
|
|
USHORT nMask;
|
|
rStm >> nMask;
|
|
|
|
TEST_READ
|
|
if( nMask & 0x0001 )
|
|
{
|
|
SvMetaAttribute * pMeth;
|
|
rStm >> pMeth;
|
|
aMethod = pMeth;
|
|
}
|
|
|
|
TEST_READ
|
|
if( nMask & 0x0002 ) rStm >> aGroupId;
|
|
TEST_READ
|
|
if( nMask & 0x0004 ) rStm >> aHasCoreId;
|
|
TEST_READ
|
|
if( nMask & 0x0008 ) rStm >> aConfigId;
|
|
TEST_READ
|
|
if( nMask & 0x0010 ) rStm >> aExecMethod;
|
|
TEST_READ
|
|
if( nMask & 0x0020 ) rStm >> aStateMethod;
|
|
TEST_READ
|
|
if( nMask & 0x0040 ) rStm >> aDefault;
|
|
TEST_READ
|
|
if( nMask & 0x0080 ) rStm >> aPseudoSlots;
|
|
TEST_READ
|
|
if( nMask & 0x0100 ) rStm >> aGet;
|
|
TEST_READ
|
|
if( nMask & 0x0200 ) rStm >> aSet;
|
|
TEST_READ
|
|
if( nMask & 0x0400 ) rStm >> aCachable;
|
|
TEST_READ
|
|
if( nMask & 0x0800 ) rStm >> aVolatile;
|
|
TEST_READ
|
|
if( nMask & 0x1000 ) rStm >> aToggle;
|
|
TEST_READ
|
|
if( nMask & 0x2000 ) rStm >> aAutoUpdate;
|
|
TEST_READ
|
|
if( nMask & 0x4000 ) rStm >> aSynchron;
|
|
TEST_READ
|
|
if( nMask & 0x8000 ) rStm >> aAsynchron;
|
|
|
|
nMask = 0;
|
|
rStm >> nMask;
|
|
|
|
TEST_READ
|
|
if( nMask & 0x0001 ) rStm >> aRecordPerItem;
|
|
TEST_READ
|
|
if( nMask & 0x0002 ) rStm >> aRecordManual;
|
|
TEST_READ
|
|
if( nMask & 0x0004 ) rStm >> aNoRecord;
|
|
TEST_READ
|
|
if( nMask & 0x0008 ) rStm >> aHasDialog;
|
|
TEST_READ
|
|
if( nMask & 0x0010 ) rStm >> aDisableFlags;
|
|
TEST_READ
|
|
if( nMask & 0x0020 ) rStm >> aPseudoPrefix;
|
|
TEST_READ
|
|
if( nMask & 0x0040 ) rStm >> aRecordPerSet;
|
|
TEST_READ
|
|
if( nMask & 0x0080 ) rStm >> aMenuConfig;
|
|
TEST_READ
|
|
if( nMask & 0x0100 ) rStm >> aToolBoxConfig;
|
|
TEST_READ
|
|
if( nMask & 0x0200 ) rStm >> aStatusBarConfig;
|
|
TEST_READ
|
|
if( nMask & 0x0400 ) rStm >> aAccelConfig;
|
|
TEST_READ
|
|
if( nMask & 0x0800 ) rStm >> aFastCall;
|
|
TEST_READ
|
|
if( nMask & 0x1000 ) rStm >> aContainer;
|
|
TEST_READ
|
|
|
|
if( nMask & 0x2000 )
|
|
{
|
|
SvMetaType * pT;
|
|
rStm >> pT;
|
|
aSlotType = pT;
|
|
}
|
|
|
|
TEST_READ
|
|
if( nMask & 0x4000 ) rStm >> aRecordAbsolute;
|
|
TEST_READ
|
|
if( nMask & 0x8000 ) rStm >> aImageRotation;
|
|
|
|
nMask = 0;
|
|
rStm >> nMask;
|
|
|
|
TEST_READ
|
|
if( nMask & 0x0001 ) rStm >> aUnoName;
|
|
#if SUPD>=643
|
|
if( nMask & 0x0002 ) rStm >> aImageReflection;
|
|
#endif
|
|
}
|
|
|
|
void SvMetaSlot::Save( SvPersistStream & rStm )
|
|
{
|
|
SvMetaAttribute::Save( rStm );
|
|
|
|
// Maske erstellen
|
|
USHORT nMask = 0;
|
|
if( aMethod.Is() ) nMask |= 0x0001;
|
|
if( aGroupId.Len() ) nMask |= 0x0002;
|
|
if( aHasCoreId.IsSet() ) nMask |= 0x0004;
|
|
if( aConfigId.Len() ) nMask |= 0x0008;
|
|
if( aExecMethod.Len() ) nMask |= 0x0010;
|
|
if( aStateMethod.Len() ) nMask |= 0x0020;
|
|
if( aDefault.Len() ) nMask |= 0x0040;
|
|
if( aPseudoSlots.IsSet() ) nMask |= 0x0080;
|
|
if( aGet.IsSet() ) nMask |= 0x0100;
|
|
if( aSet.IsSet() ) nMask |= 0x0200;
|
|
if( aCachable.IsSet() ) nMask |= 0x0400;
|
|
if( aVolatile.IsSet() ) nMask |= 0x0800;
|
|
if( aToggle.IsSet() ) nMask |= 0x1000;
|
|
if( aAutoUpdate.IsSet() ) nMask |= 0x2000;
|
|
if( aSynchron.IsSet() ) nMask |= 0x4000;
|
|
if( aAsynchron.IsSet() ) nMask |= 0x8000;
|
|
|
|
// Daten schreiben
|
|
rStm << nMask;
|
|
TEST_WRITE
|
|
if( nMask & 0x0001 ) rStm << aMethod;
|
|
TEST_WRITE
|
|
if( nMask & 0x0002 ) rStm << aGroupId;
|
|
TEST_WRITE
|
|
if( nMask & 0x0004 ) rStm << aHasCoreId;
|
|
TEST_WRITE
|
|
if( nMask & 0x0008 ) rStm << aConfigId;
|
|
TEST_WRITE
|
|
if( nMask & 0x0010 ) rStm << aExecMethod;
|
|
TEST_WRITE
|
|
if( nMask & 0x0020 ) rStm << aStateMethod;
|
|
TEST_WRITE
|
|
if( nMask & 0x0040 ) rStm << aDefault;
|
|
TEST_WRITE
|
|
if( nMask & 0x0080 ) rStm << aPseudoSlots;
|
|
TEST_WRITE
|
|
if( nMask & 0x0100 ) rStm << aGet;
|
|
TEST_WRITE
|
|
if( nMask & 0x0200 ) rStm << aSet;
|
|
TEST_WRITE
|
|
if( nMask & 0x0400 ) rStm << aCachable;
|
|
TEST_WRITE
|
|
if( nMask & 0x0800 ) rStm << aVolatile;
|
|
TEST_WRITE
|
|
if( nMask & 0x1000 ) rStm << aToggle;
|
|
TEST_WRITE
|
|
if( nMask & 0x2000 ) rStm << aAutoUpdate;
|
|
TEST_WRITE
|
|
if( nMask & 0x4000 ) rStm << aSynchron;
|
|
TEST_WRITE
|
|
if( nMask & 0x8000 ) rStm << aAsynchron;
|
|
|
|
// naechste Fuhre schreiben
|
|
// Maske erstellen
|
|
nMask = 0;
|
|
if( aRecordPerItem.IsSet() ) nMask |= 0x0001;
|
|
if( aRecordManual.IsSet() ) nMask |= 0x0002;
|
|
if( aNoRecord.IsSet() ) nMask |= 0x0004;
|
|
if( aHasDialog.IsSet() ) nMask |= 0x0008;
|
|
if ( aDisableFlags.IsSet() ) nMask |= 0x0010;
|
|
if( aPseudoPrefix.Len() ) nMask |= 0x0020;
|
|
if( aRecordPerSet.IsSet() ) nMask |= 0x0040;
|
|
if( aMenuConfig.IsSet() ) nMask |= 0x0080;
|
|
if( aToolBoxConfig.IsSet() ) nMask |= 0x0100;
|
|
if( aStatusBarConfig.IsSet() )nMask |= 0x0200;
|
|
if( aAccelConfig.IsSet() ) nMask |= 0x0400;
|
|
if( aFastCall.IsSet() ) nMask |= 0x0800;
|
|
if( aContainer.IsSet() ) nMask |= 0x1000;
|
|
if( aSlotType.Is() ) nMask |= 0x2000;
|
|
if( aRecordAbsolute.IsSet() ) nMask |= 0x4000;
|
|
if( aImageRotation.IsSet() ) nMask |= 0x8000;
|
|
|
|
// Daten schreiben
|
|
rStm << nMask;
|
|
TEST_WRITE
|
|
if( nMask & 0x0001 ) rStm << aRecordPerItem;
|
|
TEST_WRITE
|
|
if( nMask & 0x0002 ) rStm << aRecordManual;
|
|
TEST_WRITE
|
|
if( nMask & 0x0004 ) rStm << aNoRecord;
|
|
TEST_WRITE
|
|
if( nMask & 0x0008 ) rStm << aHasDialog;
|
|
TEST_WRITE
|
|
if( nMask & 0x0010 ) rStm << aDisableFlags;
|
|
TEST_WRITE
|
|
if( nMask & 0x0020 ) rStm << aPseudoPrefix;
|
|
TEST_WRITE
|
|
if( nMask & 0x0040 ) rStm << aRecordPerSet;
|
|
TEST_WRITE
|
|
if( nMask & 0x0080 ) rStm << aMenuConfig;
|
|
TEST_WRITE
|
|
if( nMask & 0x0100 ) rStm << aToolBoxConfig;
|
|
TEST_WRITE
|
|
if( nMask & 0x0200 ) rStm << aStatusBarConfig;
|
|
TEST_WRITE
|
|
if( nMask & 0x0400 ) rStm << aAccelConfig;
|
|
TEST_WRITE
|
|
if( nMask & 0x0800 ) rStm << aFastCall;
|
|
TEST_WRITE
|
|
if( nMask & 0x1000 ) rStm << aContainer;
|
|
TEST_WRITE
|
|
if( nMask & 0x2000 ) rStm << aSlotType;
|
|
TEST_WRITE
|
|
if( nMask & 0x4000 ) rStm << aRecordAbsolute;
|
|
TEST_WRITE
|
|
if( nMask & 0x8000 ) rStm << aImageRotation;
|
|
|
|
nMask = 0;
|
|
if( aUnoName.IsSet() ) nMask |= 0x0001;
|
|
#if SUPD>=643
|
|
if( aImageReflection.IsSet() ) nMask |= 0x0002;
|
|
#endif
|
|
rStm << nMask;
|
|
TEST_WRITE
|
|
if( nMask & 0x0001 ) rStm << aUnoName;
|
|
#if SUPD>=643
|
|
TEST_WRITE
|
|
if( nMask & 0x0002 ) rStm << aImageReflection;
|
|
#endif
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::IsVariable()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
BOOL SvMetaSlot::IsVariable() const
|
|
{
|
|
return SvMetaAttribute::IsVariable();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::IsMethod()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
BOOL SvMetaSlot::IsMethod() const
|
|
{
|
|
BOOL b = SvMetaAttribute::IsMethod();
|
|
b |= NULL != GetMethod();
|
|
return b;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::HasMethods()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
|
|
{
|
|
if( !bVariable )
|
|
{
|
|
SvMetaAttribute * pMeth = GetMethod();
|
|
if( pMeth )
|
|
return pMeth->GetName();
|
|
}
|
|
return GetName();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* Referenz
|
|
|*
|
|
|* Beschreibung Zweites FALSE bei den SvBOOL-Objekten bedeutet,
|
|
|* IsSet() liefert FALSE (Defaultinitialisierung).
|
|
*************************************************************************/
|
|
/** Referenz Aufloesung **/
|
|
SvMetaType * SvMetaSlot::GetSlotType() const
|
|
{
|
|
if( aSlotType.Is() || !GetRef() ) return aSlotType;
|
|
return ((SvMetaSlot *)GetRef())->GetSlotType();
|
|
}
|
|
SvMetaAttribute * SvMetaSlot::GetMethod() const
|
|
{
|
|
if( aMethod.Is() || !GetRef() ) return aMethod;
|
|
return ((SvMetaSlot *)GetRef())->GetMethod();
|
|
}
|
|
BOOL SvMetaSlot::GetHasCoreId() const
|
|
{
|
|
if( aHasCoreId.IsSet() || !GetRef() ) return aHasCoreId;
|
|
return ((SvMetaSlot *)GetRef())->GetHasCoreId();
|
|
}
|
|
const ByteString & SvMetaSlot::GetGroupId() const
|
|
{
|
|
if( aGroupId.Len() || !GetRef() ) return aGroupId;
|
|
return ((SvMetaSlot *)GetRef())->GetGroupId();
|
|
}
|
|
const ByteString & SvMetaSlot::GetDisableFlags() const
|
|
{
|
|
if( aDisableFlags.Len() || !GetRef() ) return aDisableFlags;
|
|
return ((SvMetaSlot *)GetRef())->GetDisableFlags();
|
|
}
|
|
const ByteString & SvMetaSlot::GetConfigId() const
|
|
{
|
|
if( aConfigId.Len() || !GetRef() ) return aConfigId;
|
|
return ((SvMetaSlot *)GetRef())->GetConfigId();
|
|
}
|
|
const ByteString & SvMetaSlot::GetExecMethod() const
|
|
{
|
|
if( aExecMethod.Len() || !GetRef() ) return aExecMethod;
|
|
return ((SvMetaSlot *)GetRef())->GetExecMethod();
|
|
}
|
|
const ByteString & SvMetaSlot::GetStateMethod() const
|
|
{
|
|
if( aStateMethod.Len() || !GetRef() ) return aStateMethod;
|
|
return ((SvMetaSlot *)GetRef())->GetStateMethod();
|
|
}
|
|
const ByteString & SvMetaSlot::GetDefault() const
|
|
{
|
|
if( aDefault.Len() || !GetRef() ) return aDefault;
|
|
return ((SvMetaSlot *)GetRef())->GetDefault();
|
|
}
|
|
BOOL SvMetaSlot::GetPseudoSlots() const
|
|
{
|
|
if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots;
|
|
return ((SvMetaSlot *)GetRef())->GetPseudoSlots();
|
|
}
|
|
/*
|
|
BOOL SvMetaSlot::GetGet() const
|
|
{
|
|
if( aGet.IsSet() || !GetRef() ) return aGet;
|
|
return ((SvMetaSlot *)GetRef())->GetGet();
|
|
}
|
|
BOOL SvMetaSlot::GetSet() const
|
|
{
|
|
if( aSet.IsSet() || !GetRef() ) return aSet;
|
|
return ((SvMetaSlot *)GetRef())->GetSet();
|
|
}
|
|
*/
|
|
BOOL SvMetaSlot::GetCachable() const
|
|
{
|
|
// Cachable und Volatile sind exclusiv
|
|
if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() )
|
|
return aCachable;
|
|
return ((SvMetaSlot *)GetRef())->GetCachable();
|
|
}
|
|
BOOL SvMetaSlot::GetVolatile() const
|
|
{
|
|
// Cachable und Volatile sind exclusiv
|
|
if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() )
|
|
return aVolatile;
|
|
return ((SvMetaSlot *)GetRef())->GetVolatile();
|
|
}
|
|
BOOL SvMetaSlot::GetToggle() const
|
|
{
|
|
if( aToggle.IsSet() || !GetRef() ) return aToggle;
|
|
return ((SvMetaSlot *)GetRef())->GetToggle();
|
|
}
|
|
BOOL SvMetaSlot::GetAutoUpdate() const
|
|
{
|
|
if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate;
|
|
return ((SvMetaSlot *)GetRef())->GetAutoUpdate();
|
|
}
|
|
BOOL SvMetaSlot::GetSynchron() const
|
|
{
|
|
// Synchron und Asynchron sind exclusiv
|
|
if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() )
|
|
return aSynchron;
|
|
return ((SvMetaSlot *)GetRef())->GetSynchron();
|
|
}
|
|
BOOL SvMetaSlot::GetAsynchron() const
|
|
{
|
|
// Synchron und Asynchron sind exclusiv
|
|
if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() )
|
|
return aAsynchron;
|
|
return ((SvMetaSlot *)GetRef())->GetAsynchron();
|
|
}
|
|
BOOL SvMetaSlot::GetRecordPerItem() const
|
|
{
|
|
// Record- PerItem, No, PerSet und Manual sind exclusiv
|
|
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|
|
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
|
|
return aRecordPerItem;
|
|
return ((SvMetaSlot *)GetRef())->GetRecordPerItem();
|
|
}
|
|
BOOL SvMetaSlot::GetRecordPerSet() const
|
|
{
|
|
// Record- PerItem, No, PerSet und Manual sind exclusiv
|
|
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|
|
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
|
|
return aRecordPerSet;
|
|
return ((SvMetaSlot *)GetRef())->GetRecordPerSet();
|
|
}
|
|
BOOL SvMetaSlot::GetRecordManual() const
|
|
{
|
|
// Record- PerItem, No, PerSet und Manual sind exclusiv
|
|
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|
|
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
|
|
return aRecordManual;
|
|
return ((SvMetaSlot *)GetRef())->GetRecordManual();
|
|
}
|
|
BOOL SvMetaSlot::GetNoRecord() const
|
|
{
|
|
// Record- PerItem, No, PerSet und Manual sind exclusiv
|
|
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|
|
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
|
|
return aNoRecord;
|
|
return ((SvMetaSlot *)GetRef())->GetNoRecord();
|
|
}
|
|
BOOL SvMetaSlot::GetRecordAbsolute() const
|
|
{
|
|
if( !GetRef() || aRecordAbsolute.IsSet() )
|
|
return aRecordAbsolute;
|
|
return ((SvMetaSlot *)GetRef())->GetRecordAbsolute();
|
|
}
|
|
BOOL SvMetaSlot::GetHasDialog() const
|
|
{
|
|
if( aHasDialog.IsSet() || !GetRef() ) return aHasDialog;
|
|
return ((SvMetaSlot *)GetRef())->GetHasDialog();
|
|
}
|
|
const ByteString & SvMetaSlot::GetPseudoPrefix() const
|
|
{
|
|
if( aPseudoPrefix.Len() || !GetRef() ) return aPseudoPrefix;
|
|
return ((SvMetaSlot *)GetRef())->GetPseudoPrefix();
|
|
}
|
|
BOOL SvMetaSlot::GetMenuConfig() const
|
|
{
|
|
if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig;
|
|
return ((SvMetaSlot *)GetRef())->GetMenuConfig();
|
|
}
|
|
BOOL SvMetaSlot::GetToolBoxConfig() const
|
|
{
|
|
if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig;
|
|
return ((SvMetaSlot *)GetRef())->GetToolBoxConfig();
|
|
}
|
|
BOOL SvMetaSlot::GetStatusBarConfig() const
|
|
{
|
|
if( aStatusBarConfig.IsSet() || !GetRef() ) return aStatusBarConfig;
|
|
return ((SvMetaSlot *)GetRef())->GetStatusBarConfig();
|
|
}
|
|
BOOL SvMetaSlot::GetAccelConfig() const
|
|
{
|
|
if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig;
|
|
return ((SvMetaSlot *)GetRef())->GetAccelConfig();
|
|
}
|
|
BOOL SvMetaSlot::GetFastCall() const
|
|
{
|
|
if( aFastCall.IsSet() || !GetRef() ) return aFastCall;
|
|
return ((SvMetaSlot *)GetRef())->GetFastCall();
|
|
}
|
|
BOOL SvMetaSlot::GetContainer() const
|
|
{
|
|
if( aContainer.IsSet() || !GetRef() ) return aContainer;
|
|
return ((SvMetaSlot *)GetRef())->GetContainer();
|
|
}
|
|
|
|
BOOL SvMetaSlot::GetImageRotation() const
|
|
{
|
|
if( aImageRotation.IsSet() || !GetRef() ) return aImageRotation;
|
|
return ((SvMetaSlot *)GetRef())->GetImageRotation();
|
|
}
|
|
|
|
#if SUPD>=643
|
|
BOOL SvMetaSlot::GetImageReflection() const
|
|
{
|
|
if( aImageReflection.IsSet() || !GetRef() ) return aImageReflection;
|
|
return ((SvMetaSlot *)GetRef())->GetImageReflection();
|
|
}
|
|
#endif
|
|
|
|
const ByteString& SvMetaSlot::GetUnoName() const
|
|
{
|
|
if( aUnoName.IsSet() || !GetRef() ) return aUnoName;
|
|
return ((SvMetaSlot *)GetRef())->GetUnoName();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::FillSbxObject()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
/*
|
|
void SvMetaSlot::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj,
|
|
BOOL bVariable )
|
|
{
|
|
// keine Attribut fuer Automation
|
|
if( !GetAutomation() || !GetExport() )
|
|
return;
|
|
|
|
if( !bVariable )
|
|
{
|
|
SvMetaAttributeRef xM = GetMethod();
|
|
if( xM.Is() )
|
|
{
|
|
SvMetaType * pType = xM->GetType();
|
|
SvMetaType * pRetBaseType = pType->GetReturnType()->GetBaseType();
|
|
ByteString aName = xM->GetName();
|
|
|
|
SbxMethodRef xMeth = new SbxMethod( aName,
|
|
pRetBaseType->GetSbxDataType() );
|
|
pType->FillSbxObject( xMeth, bVariable );
|
|
xMeth->SetUserData( MakeSlotValue(rBase, FALSE) );
|
|
|
|
pObj->Insert( &xMeth );
|
|
return;
|
|
}
|
|
}
|
|
|
|
SvMetaAttribute::FillSbxObject( rBase, pObj, bVariable );
|
|
}
|
|
*/
|
|
|
|
#ifdef IDL_COMPILER
|
|
/*************************************************************************
|
|
|* SvMetaSlot::ReadAttributesSvIdl()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
|
|
SvTokenStream & rInStm )
|
|
{
|
|
SvMetaAttribute::ReadAttributesSvIdl( rBase, rInStm );
|
|
|
|
BOOL bOk = FALSE;
|
|
bOk |= aDefault.ReadSvIdl( SvHash_Default(), rInStm );
|
|
bOk |= aPseudoSlots.ReadSvIdl( SvHash_PseudoSlots(), rInStm );
|
|
bOk |= aHasCoreId.ReadSvIdl( SvHash_HasCoreId(), rInStm );
|
|
bOk |= aGroupId.ReadSvIdl( SvHash_GroupId(), rInStm );
|
|
bOk |= aExecMethod.ReadSvIdl( SvHash_ExecMethod(), rInStm );
|
|
bOk |= aStateMethod.ReadSvIdl( SvHash_StateMethod(), rInStm );
|
|
bOk |= aDisableFlags.ReadSvIdl( SvHash_DisableFlags(), rInStm );
|
|
if( aGet.ReadSvIdl( SvHash_Get(), rInStm ) )
|
|
{
|
|
rBase.WriteError( "warning", ByteString( rInStm.GetFileName(), RTL_TEXTENCODING_UTF8 ),
|
|
"<Get> old style, use Readonly",
|
|
rInStm.GetToken()->GetLine(),
|
|
rInStm.GetToken()->GetColumn() );
|
|
}
|
|
if( aSet.ReadSvIdl( SvHash_Set(), rInStm ) )
|
|
{
|
|
rBase.WriteError( "warning", ByteString( rInStm.GetFileName(), RTL_TEXTENCODING_UTF8 ),
|
|
"<Set> old style, use method declaration",
|
|
rInStm.GetToken()->GetLine(),
|
|
rInStm.GetToken()->GetColumn() );
|
|
}
|
|
|
|
if( aCachable.ReadSvIdl( SvHash_Cachable(), rInStm ) )
|
|
SetCachable( aCachable ), bOk = TRUE;
|
|
if( aVolatile.ReadSvIdl( SvHash_Volatile(), rInStm ) )
|
|
SetVolatile( aVolatile ), bOk = TRUE;
|
|
if( aToggle.ReadSvIdl( SvHash_Toggle(), rInStm ) )
|
|
SetToggle( aToggle ), bOk = TRUE;
|
|
if( aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm ) )
|
|
SetAutoUpdate( aAutoUpdate ), bOk = TRUE;
|
|
|
|
if( aSynchron.ReadSvIdl( SvHash_Synchron(), rInStm ) )
|
|
SetSynchron( aSynchron ), bOk = TRUE;
|
|
if( aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm ) )
|
|
SetAsynchron( aAsynchron ), bOk = TRUE;
|
|
|
|
if( aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm ) )
|
|
SetRecordAbsolute( aRecordAbsolute), bOk = TRUE;
|
|
if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) )
|
|
SetRecordPerItem( aRecordPerItem ), bOk = TRUE;
|
|
if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) )
|
|
SetRecordPerSet( aRecordPerSet ), bOk = TRUE;
|
|
if( aRecordManual.ReadSvIdl( SvHash_RecordManual(), rInStm ) )
|
|
SetRecordManual( aRecordManual ), bOk = TRUE;
|
|
if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) )
|
|
SetNoRecord( aNoRecord ), bOk = TRUE;
|
|
|
|
bOk |= aHasDialog.ReadSvIdl( SvHash_HasDialog(), rInStm );
|
|
bOk |= aPseudoPrefix.ReadSvIdl( SvHash_PseudoPrefix(), rInStm );
|
|
bOk |= aMenuConfig.ReadSvIdl( SvHash_MenuConfig(), rInStm );
|
|
bOk |= aToolBoxConfig.ReadSvIdl( SvHash_ToolBoxConfig(), rInStm );
|
|
bOk |= aStatusBarConfig.ReadSvIdl( SvHash_StatusBarConfig(), rInStm );
|
|
bOk |= aAccelConfig.ReadSvIdl( SvHash_AccelConfig(), rInStm );
|
|
|
|
SvBOOL aAllConfig;
|
|
if( aAllConfig.ReadSvIdl( SvHash_AllConfig(), rInStm ) )
|
|
SetAllConfig( aAllConfig ), bOk = TRUE;
|
|
bOk |= aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm );
|
|
bOk |= aContainer.ReadSvIdl( SvHash_Container(), rInStm );
|
|
bOk |= aImageRotation.ReadSvIdl( SvHash_ImageRotation(), rInStm );
|
|
#if SUPD>=643
|
|
bOk |= aImageReflection.ReadSvIdl( SvHash_ImageReflection(), rInStm );
|
|
#endif
|
|
bOk |= aUnoName.ReadSvIdl( SvHash_UnoName(), rInStm );
|
|
|
|
if( !bOk )
|
|
{
|
|
if( !aSlotType.Is() )
|
|
{
|
|
UINT32 nTokPos = rInStm.Tell();
|
|
SvToken * pTok = rInStm.GetToken_Next();
|
|
if( pTok->Is( SvHash_SlotType() ) )
|
|
{
|
|
BOOL bBraket = rInStm.Read( '(' );
|
|
if( bBraket || rInStm.Read( '=' ) )
|
|
{
|
|
aSlotType = rBase.ReadKnownType( rInStm );
|
|
if( aSlotType.Is() )
|
|
{
|
|
if( aSlotType->IsItem() )
|
|
{
|
|
if( bBraket )
|
|
{
|
|
if( rInStm.Read( ')' ) )
|
|
return;
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
rBase.SetError( "the SlotType is not a item", rInStm.GetToken() );
|
|
rBase.WriteError( rInStm );
|
|
}
|
|
rBase.SetError( "SlotType with unknown item type", rInStm.GetToken() );
|
|
rBase.WriteError( rInStm );
|
|
}
|
|
}
|
|
rInStm.Seek( nTokPos );
|
|
|
|
}
|
|
if( !aMethod.Is() )
|
|
{
|
|
SvToken * pTok = rInStm.GetToken();
|
|
if( pTok->IsIdentifier() )
|
|
{
|
|
aMethod = new SvMetaSlot();
|
|
UINT32 nTokPos = rInStm.Tell();
|
|
if( aMethod->ReadSvIdl( rBase, rInStm ) )
|
|
{
|
|
if( aMethod->IsMethod() )
|
|
{
|
|
aMethod->SetSlotId( GetSlotId() );
|
|
if( aMethod->Test( rBase, rInStm ) )
|
|
return;
|
|
}
|
|
rInStm.Seek( nTokPos );
|
|
}
|
|
aMethod.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::WriteAttributesSvIdl()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
|
|
SvStream & rOutStm,
|
|
USHORT nTab )
|
|
{
|
|
SvMetaAttribute::WriteAttributesSvIdl( rBase, rOutStm, nTab );
|
|
|
|
if( aSlotType.Is() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
rOutStm << SvHash_SlotType()->GetName().GetBuffer() << '(';
|
|
aSlotType->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
|
|
rOutStm << ");" << endl;
|
|
}
|
|
if( aMethod.Is() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
aMethod->WriteSvIdl( rBase, rOutStm, nTab );
|
|
rOutStm << ';' << endl;
|
|
}
|
|
if( aHasCoreId )
|
|
{
|
|
aHasCoreId.WriteSvIdl( SvHash_HasCoreId(), rOutStm );
|
|
rOutStm << ';' << endl;
|
|
}
|
|
if( aGroupId.Len() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
aGroupId.WriteSvIdl( SvHash_GroupId(), rOutStm, nTab +1);
|
|
rOutStm << ';' << endl;
|
|
}
|
|
if( aExecMethod.Len() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
aExecMethod.WriteSvIdl( SvHash_ExecMethod(), rOutStm, nTab +1);
|
|
rOutStm << ';' << endl;
|
|
}
|
|
if( aStateMethod.Len() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
aStateMethod.WriteSvIdl( SvHash_StateMethod(), rOutStm, nTab +1);
|
|
rOutStm << ';' << endl;
|
|
}
|
|
|
|
if( aDisableFlags.Len() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
aDisableFlags.WriteSvIdl( SvHash_DisableFlags(), rOutStm, nTab +1);
|
|
rOutStm << ';' << endl;
|
|
}
|
|
|
|
if( aSet || aGet || aPseudoSlots )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
char * p = "";
|
|
if( aPseudoSlots )
|
|
{
|
|
aPseudoSlots.WriteSvIdl( SvHash_PseudoSlots(), rOutStm );
|
|
p = ", ";
|
|
}
|
|
if( aGet )
|
|
{
|
|
rOutStm << p;
|
|
aGet.WriteSvIdl( SvHash_Get(), rOutStm );
|
|
p = ", ";
|
|
}
|
|
if( aSet )
|
|
{
|
|
rOutStm << p;
|
|
aSet.WriteSvIdl( SvHash_Set(), rOutStm );
|
|
}
|
|
rOutStm << ';' << endl;
|
|
}
|
|
|
|
ByteString aDel( ", " );
|
|
ByteString aOut;
|
|
if( aVolatile )
|
|
aOut += aVolatile.GetSvIdlString( SvHash_Volatile() );
|
|
else if( !aCachable )
|
|
// wegen Default == TRUE, nur wenn kein anderer gesetzt
|
|
aOut += aCachable.GetSvIdlString( SvHash_Cachable() );
|
|
else
|
|
aDel.Erase();
|
|
|
|
if( aToggle )
|
|
{
|
|
( aOut += aDel ) += aToggle.GetSvIdlString( SvHash_Toggle() );
|
|
aDel = ", ";
|
|
}
|
|
if( aAutoUpdate )
|
|
{
|
|
(aOut += aDel ) += aAutoUpdate.GetSvIdlString( SvHash_AutoUpdate() );
|
|
aDel = ", ";
|
|
}
|
|
|
|
ByteString aDel1( ", " );
|
|
if( aAsynchron )
|
|
( aOut += aDel ) += aAsynchron.GetSvIdlString( SvHash_Asynchron() );
|
|
else if( !aSynchron )
|
|
// wegen Default == TRUE, nur wenn kein anderer gesetzt
|
|
( aOut += aDel ) += aSynchron.GetSvIdlString( SvHash_Synchron() );
|
|
else
|
|
aDel1 = aDel;
|
|
|
|
aDel = ", ";
|
|
if( aRecordManual )
|
|
( aOut += aDel1 ) += aRecordManual.GetSvIdlString( SvHash_RecordManual() );
|
|
else if( aNoRecord )
|
|
( aOut += aDel1 ) += aNoRecord.GetSvIdlString( SvHash_NoRecord() );
|
|
else if( !aRecordPerSet )
|
|
// wegen Default == TRUE, nur wenn kein anderer gesetzt
|
|
( aOut += aDel1 ) += aRecordPerSet.GetSvIdlString( SvHash_RecordPerSet() );
|
|
else if( aRecordPerItem )
|
|
( aOut += aDel1 ) += aRecordPerItem.GetSvIdlString( SvHash_RecordPerItem() );
|
|
else
|
|
aDel = aDel1;
|
|
|
|
if( aRecordAbsolute )
|
|
{
|
|
( aOut += aDel ) += aRecordAbsolute.GetSvIdlString( SvHash_RecordAbsolute() );
|
|
aDel = ", ";
|
|
}
|
|
if( aHasDialog )
|
|
{
|
|
( aOut += aDel ) += aHasDialog.GetSvIdlString( SvHash_HasDialog() );
|
|
aDel = ", ";
|
|
}
|
|
if( aMenuConfig )
|
|
{
|
|
( aOut += aDel ) += aMenuConfig.GetSvIdlString( SvHash_MenuConfig() );
|
|
aDel = ", ";
|
|
}
|
|
if( aToolBoxConfig )
|
|
{
|
|
( aOut += aDel ) += aToolBoxConfig.GetSvIdlString( SvHash_ToolBoxConfig() );
|
|
aDel = ", ";
|
|
}
|
|
if( aStatusBarConfig )
|
|
{
|
|
( aOut += aDel ) += aStatusBarConfig.GetSvIdlString( SvHash_StatusBarConfig() );
|
|
aDel = ", ";
|
|
}
|
|
if( aAccelConfig )
|
|
{
|
|
( aOut += aDel ) += aAccelConfig.GetSvIdlString( SvHash_AccelConfig() );
|
|
aDel = ", ";
|
|
}
|
|
if( aFastCall )
|
|
{
|
|
( aOut += aDel ) += aFastCall.GetSvIdlString( SvHash_FastCall() );
|
|
aDel = ", ";
|
|
}
|
|
if( aContainer )
|
|
{
|
|
( aOut += aDel ) += aContainer.GetSvIdlString( SvHash_Container() );
|
|
aDel = ", ";
|
|
}
|
|
if( aImageRotation )
|
|
{
|
|
( aOut += aDel ) += aImageRotation.GetSvIdlString( SvHash_ImageRotation() );
|
|
aDel = ", ";
|
|
}
|
|
|
|
#if SUPD>=643
|
|
if( aImageReflection )
|
|
{
|
|
( aOut += aDel ) += aImageReflection.GetSvIdlString( SvHash_ImageReflection() );
|
|
aDel = ", ";
|
|
}
|
|
#endif
|
|
|
|
if( aOut.Len() )
|
|
{
|
|
WriteTab( rOutStm, nTab );
|
|
rOutStm << aOut.GetBuffer() << endl;
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::Test()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
|
|
{
|
|
BOOL bOk = SvMetaAttribute::Test( rBase, rInStm );
|
|
if( bOk )
|
|
{
|
|
SvMetaType * pType = GetType();
|
|
if( pType->GetType() == TYPE_METHOD )
|
|
pType = pType->GetReturnType();
|
|
SvMetaType * pBaseType = pType->GetBaseType();
|
|
if( !pType->IsItem() )
|
|
{
|
|
rBase.SetError( "this attribute is not a slot", rInStm.GetToken() );
|
|
rBase.WriteError( rInStm );
|
|
bOk = FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
if ( bOk )
|
|
{
|
|
SvMetaSlot* pRef = (SvMetaSlot*) GetRef();
|
|
if ( pRef )
|
|
CompareSlotAttributes( pRef );
|
|
}
|
|
*/
|
|
return bOk;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::ReadSvIdl()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
|
|
{
|
|
UINT32 nTokPos = rInStm.Tell();
|
|
BOOL bOk = TRUE;
|
|
|
|
SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
|
|
if( pAttr )
|
|
{
|
|
// F"ur Testzwecke: Referenz bei Kurz-Syntax
|
|
SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
|
|
if( pKnownSlot )
|
|
{
|
|
SetRef( pKnownSlot );
|
|
SetName( pKnownSlot->GetName(), &rBase );
|
|
bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
|
|
}
|
|
else
|
|
{
|
|
ByteString aStr( "attribute " );
|
|
aStr += pAttr->GetName();
|
|
aStr += " is method or variable but not a slot";
|
|
rBase.SetError( aStr, rInStm.GetToken() );
|
|
rBase.WriteError( rInStm );
|
|
bOk = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm );
|
|
|
|
SvMetaAttribute *pAttr = rBase.SearchKnownAttr( GetSlotId() );
|
|
if( pAttr )
|
|
{
|
|
// F"ur Testzwecke: Referenz bei kompletter Definition
|
|
SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
|
|
if( pKnownSlot )
|
|
{
|
|
SetRef( pKnownSlot );
|
|
|
|
// Namen d"urfen abweichen, da mit angegeben
|
|
if ( pKnownSlot->GetName() != GetName() )
|
|
{
|
|
DBG_ERROR("Illegal definition!");
|
|
rInStm.Seek( nTokPos );
|
|
return FALSE;
|
|
}
|
|
|
|
SetName( pKnownSlot->GetName(), &rBase );
|
|
}
|
|
else
|
|
{
|
|
ByteString aStr( "attribute " );
|
|
aStr += pAttr->GetName();
|
|
aStr += " is method or variable but not a slot";
|
|
rBase.SetError( aStr, rInStm.GetToken() );
|
|
rBase.WriteError( rInStm );
|
|
bOk = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !bOk )
|
|
rInStm.Seek( nTokPos );
|
|
|
|
return bOk;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::WriteSvIdl()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
|
|
USHORT nTab )
|
|
{
|
|
SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab );
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::Write()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
void SvMetaSlot::Write( SvIdlDataBase & rBase,
|
|
SvStream & rOutStm, USHORT nTab,
|
|
WriteType nT, WriteAttribute nA )
|
|
{
|
|
if ( nT == WRITE_DOCU )
|
|
{
|
|
if ( GetHidden() )
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// keine Attribut fuer Automation
|
|
if( !GetAutomation() || !GetExport() )
|
|
return;
|
|
}
|
|
|
|
if( !(nA & WA_VARIABLE) )
|
|
{
|
|
SvMetaAttributeRef xM = GetMethod();
|
|
if( xM.Is() )
|
|
{
|
|
xM->SetSlotId( GetSlotId() );
|
|
xM->SetDescription( GetDescription() );
|
|
xM->Write( rBase, rOutStm, nTab, nT, nA );
|
|
return;
|
|
}
|
|
}
|
|
|
|
SvMetaAttribute::Write( rBase, rOutStm, nTab, nT, nA );
|
|
}
|
|
|
|
|
|
void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
|
|
SvIdlDataBase& rBase)
|
|
{
|
|
// Einf"ugeposition durch bin"are Suche in der SlotListe ermitteln
|
|
USHORT nId = (USHORT) GetSlotId().GetValue();
|
|
USHORT nListCount = (USHORT) rList.Count();
|
|
USHORT nPos;
|
|
ULONG m; // for inner "for" loop
|
|
|
|
if ( !nListCount )
|
|
nPos = 0;
|
|
else if ( nListCount == 1 )
|
|
nPos = rList.GetObject(0)->xSlot->GetSlotId().GetValue() >= nId ? 0 : 1;
|
|
else
|
|
{
|
|
USHORT nMid, nLow = 0;
|
|
USHORT nHigh = nListCount - 1;
|
|
BOOL bFound = FALSE;
|
|
while ( !bFound && nLow <= nHigh )
|
|
{
|
|
nMid = (nLow + nHigh) >> 1;
|
|
DBG_ASSERT( nMid < nListCount, "bsearch ist buggy" );
|
|
int nDiff = (int) nId - (int) rList.GetObject(nMid)->xSlot->GetSlotId().GetValue();
|
|
if ( nDiff < 0)
|
|
{
|
|
if ( nMid == 0 )
|
|
break;
|
|
nHigh = nMid - 1;
|
|
}
|
|
else if ( nDiff > 0 )
|
|
{
|
|
nLow = nMid + 1;
|
|
if ( nLow == 0 )
|
|
break;
|
|
}
|
|
else
|
|
bFound = TRUE;
|
|
}
|
|
|
|
DBG_ASSERT(!bFound, "Duplicate SlotId!");
|
|
nPos = bFound ? nMid : nLow;
|
|
}
|
|
|
|
DBG_ASSERT( nPos <= nListCount,
|
|
"nPos too large" );
|
|
DBG_ASSERT( nPos == nListCount || nId <=
|
|
(USHORT) rList.GetObject(nPos)->xSlot->GetSlotId().GetValue(),
|
|
"Successor has lower SlotId" );
|
|
DBG_ASSERT( nPos == 0 || nId >
|
|
(USHORT) rList.GetObject(nPos-1)->xSlot->GetSlotId().GetValue(),
|
|
"Predecessor has higher SlotId" );
|
|
DBG_ASSERT( nPos+1 >= nListCount || nId <
|
|
(USHORT) rList.GetObject(nPos+1)->xSlot->GetSlotId().GetValue(),
|
|
"Successor has lower SlotId" );
|
|
|
|
rList.Insert( new SvSlotElement( this, rPrefix ), nPos );
|
|
|
|
// EnumSlots plattklopfen
|
|
SvMetaTypeEnum * pEnum = NULL;
|
|
SvMetaType * pBType = GetType()->GetBaseType();
|
|
pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
|
|
if( GetPseudoSlots() && pEnum && pEnum->Count() )
|
|
{
|
|
// Den MasterSlot clonen
|
|
SvMetaSlotRef xEnumSlot;
|
|
SvMetaSlot *pFirstEnumSlot = NULL;
|
|
for( ULONG n = 0; n < pEnum->Count(); n++ )
|
|
{
|
|
// Die SlotId erzeugen
|
|
SvMetaEnumValue *pEnumValue = pEnum->GetObject(n);
|
|
ByteString aValName = pEnumValue->GetName();
|
|
ByteString aSId( GetSlotId() );
|
|
if( GetPseudoPrefix().Len() )
|
|
aSId = GetPseudoPrefix();
|
|
aSId += '_';
|
|
USHORT nLen = pEnum->GetPrefix().Len();
|
|
aSId += aValName.Copy( pEnum->GetPrefix().Len() );
|
|
|
|
xEnumSlot = NULL;
|
|
for( m=0; m<rBase.GetAttrList().Count(); m++ )
|
|
{
|
|
SvMetaAttribute * pAttr = rBase.GetAttrList().GetObject( m );
|
|
if( pAttr->GetSlotId() == aSId )
|
|
{
|
|
SvMetaSlot* pSlot = PTR_CAST( SvMetaSlot, pAttr );
|
|
xEnumSlot = pSlot->Clone();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( m == rBase.GetAttrList().Count() )
|
|
{
|
|
DBG_ERROR("Invalid EnumSlot!");
|
|
xEnumSlot = Clone();
|
|
ULONG nValue;
|
|
if ( rBase.FindId(aSId , &nValue) )
|
|
{
|
|
SvNumberIdentifier aId;
|
|
*((SvIdentifier*)&aId) = aSId;
|
|
aId.SetValue(nValue);
|
|
xEnumSlot->SetSlotId(aId);
|
|
}
|
|
}
|
|
|
|
// Die Slaves sind kein Master !
|
|
xEnumSlot->aPseudoSlots = FALSE;
|
|
xEnumSlot->SetEnumValue(pEnumValue);
|
|
|
|
if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < pFirstEnumSlot->GetSlotId().GetValue() )
|
|
pFirstEnumSlot = xEnumSlot;
|
|
|
|
// Den erzeugten Slave ebenfalls einf"ugen
|
|
xEnumSlot->Insert( rList, rPrefix, rBase);
|
|
|
|
// Die EnumSlots mit dem Master verketten
|
|
xEnumSlot->pLinkedSlot = this;
|
|
}
|
|
|
|
// Master zeigt auf den ersten Slave
|
|
pLinkedSlot = pFirstEnumSlot;
|
|
|
|
// Slaves untereinander verketten
|
|
rList.Seek((ULONG)0);
|
|
xEnumSlot = pFirstEnumSlot;
|
|
SvSlotElement *pEle;
|
|
do
|
|
{
|
|
pEle = rList.Next();
|
|
if ( pEle && pEle->xSlot->pLinkedSlot == this )
|
|
{
|
|
xEnumSlot->pNextSlot = pEle->xSlot;
|
|
xEnumSlot = pEle->xSlot;
|
|
}
|
|
}
|
|
while ( pEle );
|
|
xEnumSlot->pNextSlot = pFirstEnumSlot;
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::WriteSlotMap()
|
|
|*
|
|
|* Beschreibung
|
|
*************************************************************************/
|
|
static ByteString MakeSlotName( SvStringHashEntry * pEntry )
|
|
{
|
|
ByteString aName( "SFX_SLOT_" );
|
|
aName += pEntry->GetName();
|
|
return aName.ToUpperAscii();
|
|
};
|
|
|
|
void SvMetaSlot::WriteSlotStubs( const ByteString & rShellName,
|
|
ByteStringList & rList,
|
|
SvStream & rOutStm )
|
|
{
|
|
/*
|
|
ByteString aName = GetName();
|
|
SvMetaAttribute * pAttr = rAttrList.First();
|
|
while( pAttr )
|
|
{
|
|
if( pAttr->GetName() == aName )
|
|
break;
|
|
pAttr = rAttrList.Next();
|
|
}
|
|
if( pAttr )
|
|
return;
|
|
*/
|
|
if ( !GetExport() && !GetHidden() )
|
|
return;
|
|
|
|
ByteString aMethodName( GetExecMethod() );
|
|
if ( aMethodName.Len() && aMethodName != "NoExec" )
|
|
{
|
|
BOOL bIn = FALSE;
|
|
for( USHORT n = 0; n < rList.Count(); n++ )
|
|
{
|
|
if( *(rList.GetObject(n)) == aMethodName )
|
|
{
|
|
bIn=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bIn )
|
|
{
|
|
rList.Insert( new ByteString(aMethodName), LIST_APPEND );
|
|
rOutStm << "SFX_EXEC_STUB("
|
|
<< rShellName.GetBuffer()
|
|
<< ','
|
|
<< aMethodName.GetBuffer()
|
|
<< ')' << endl;
|
|
}
|
|
}
|
|
|
|
aMethodName = GetStateMethod();
|
|
if ( aMethodName.Len() && aMethodName != "NoState" )
|
|
{
|
|
BOOL bIn = FALSE;
|
|
for ( USHORT n=0; n < rList.Count(); n++ )
|
|
{
|
|
if ( *(rList.GetObject(n)) == aMethodName )
|
|
{
|
|
bIn=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bIn )
|
|
{
|
|
rList.Insert( new ByteString(aMethodName), LIST_APPEND );
|
|
rOutStm << "SFX_STATE_STUB("
|
|
<< rShellName.GetBuffer()
|
|
<< ','
|
|
<< aMethodName.GetBuffer()
|
|
<< ')' << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
|
|
const ByteString & rSlotId,
|
|
const ByteString & rValueName,
|
|
SvSlotElementList& rSlotList,
|
|
const ByteString & rPrefix,
|
|
SvIdlDataBase & rBase, SvStream & rOutStm )
|
|
{
|
|
if ( !GetExport() && !GetHidden() )
|
|
return;
|
|
|
|
// BOOL bIsEnumSlot = 0 != rValueName.Len();
|
|
BOOL bIsEnumSlot = 0 != pEnumValue;
|
|
|
|
rOutStm << "// Slot Nr. " << ByteString::CreateFromInt32(nListPos).GetBuffer() << " : ";
|
|
ByteString aSlotIdValue( ByteString::CreateFromInt32( GetSlotId().GetValue() ) );
|
|
rOutStm << aSlotIdValue.GetBuffer() << endl;
|
|
WriteTab( rOutStm, 1 );
|
|
if( bIsEnumSlot )
|
|
rOutStm << "SFX_NEW_SLOT_ENUM( ";
|
|
else
|
|
rOutStm << "SFX_NEW_SLOT_ARG( " << rShellName.GetBuffer() << ',' ;
|
|
|
|
rOutStm << rSlotId.GetBuffer() << ',';
|
|
const SvHelpContext& rHlpCtx = GetHelpContext();
|
|
if( rHlpCtx.IsSet() )
|
|
rOutStm << rHlpCtx.GetBuffer() << ',';
|
|
else
|
|
rOutStm << rSlotId.GetBuffer() << ',';
|
|
|
|
// GroupId
|
|
if( GetGroupId().Len() )
|
|
rOutStm << GetGroupId().GetBuffer();
|
|
else
|
|
rOutStm << '0';
|
|
rOutStm << ',' << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
|
|
if( bIsEnumSlot )
|
|
{
|
|
rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl["
|
|
<< ByteString::CreateFromInt32(pLinkedSlot->GetListPos()).GetBuffer()
|
|
<< "] /*Offset Master*/, " << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl["
|
|
<< ByteString::CreateFromInt32(pNextSlot->GetListPos()).GetBuffer()
|
|
<< "] /*Offset Next*/, " << endl;
|
|
|
|
WriteTab( rOutStm, 4 );
|
|
|
|
// SlotId
|
|
if( GetSlotId().Len() )
|
|
rOutStm << pLinkedSlot->GetSlotId().GetBuffer();
|
|
else
|
|
rOutStm << '0';
|
|
rOutStm << ',';
|
|
rOutStm << pEnumValue->GetName().GetBuffer();
|
|
}
|
|
else
|
|
{
|
|
// Den n"achsten Slot suchen, der die gleiche StateMethod hat wie ich
|
|
// Die SlotList ist auf den aktuellen Slot geseekt
|
|
SvSlotElement * pEle = rSlotList.Next();
|
|
pNextSlot = pEle ? &pEle->xSlot : NULL;
|
|
while ( pNextSlot )
|
|
{
|
|
if ( !pNextSlot->pNextSlot &&
|
|
pNextSlot->GetStateMethod() == GetStateMethod() )
|
|
break;
|
|
pEle = rSlotList.Next();
|
|
pNextSlot = pEle ? &pEle->xSlot : NULL;
|
|
}
|
|
|
|
if ( !pNextSlot )
|
|
{
|
|
// Es gibt nach mir keinen Slot mehr, der die gleiche ExecMethode
|
|
// hat. Also suche ich den ersten Slot, der diese hatte (das
|
|
// k"onnte auch ich selbst sein)
|
|
pEle = rSlotList.First();
|
|
pNextSlot = pEle ? &pEle->xSlot : NULL;
|
|
while ( pNextSlot != this )
|
|
{
|
|
if ( !pNextSlot->pEnumValue &&
|
|
pNextSlot->GetStateMethod() == GetStateMethod() )
|
|
break;
|
|
pEle = rSlotList.Next();
|
|
pNextSlot = pEle ? &pEle->xSlot : NULL;
|
|
}
|
|
}
|
|
|
|
if ( !pLinkedSlot )
|
|
{
|
|
rOutStm << "0 ,";
|
|
}
|
|
else
|
|
{
|
|
rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl["
|
|
<< ByteString::CreateFromInt32(pLinkedSlot->GetListPos()).GetBuffer()
|
|
<< "] /*Offset Linked*/, " << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
}
|
|
|
|
rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl["
|
|
<< ByteString::CreateFromInt32(pNextSlot->GetListPos()).GetBuffer()
|
|
<< "] /*Offset Next*/, " << endl;
|
|
|
|
WriteTab( rOutStm, 4 );
|
|
|
|
// ExecMethod schreiben, wenn nicht angegeben, standard Namen
|
|
if( GetExecMethod().Len() && GetExecMethod() != "NoExec")
|
|
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
|
|
<< GetExecMethod().GetBuffer() << ')';
|
|
else
|
|
rOutStm << "SFX_STUB_PTR_EXEC_NONE";
|
|
rOutStm << ',';
|
|
|
|
// StateMethod schreiben, wenn nicht angegeben, standard Namen
|
|
if( GetStateMethod().Len() && GetStateMethod() != "NoState")
|
|
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
|
|
<< GetStateMethod().GetBuffer() << ')';
|
|
else
|
|
rOutStm << "SFX_STUB_PTR_STATE_NONE";
|
|
}
|
|
rOutStm << ',' << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
|
|
// Flags schreiben
|
|
if( GetHasCoreId() )
|
|
rOutStm << MakeSlotName( SvHash_HasCoreId() ).GetBuffer() << '|';
|
|
if( GetCachable() )
|
|
rOutStm << MakeSlotName( SvHash_Cachable() ).GetBuffer() << '|';
|
|
if( GetVolatile() )
|
|
rOutStm << MakeSlotName( SvHash_Volatile() ).GetBuffer() << '|';
|
|
if( GetToggle() )
|
|
rOutStm << MakeSlotName( SvHash_Toggle() ).GetBuffer() << '|';
|
|
if( GetAutoUpdate() )
|
|
rOutStm << MakeSlotName( SvHash_AutoUpdate() ).GetBuffer() << '|';
|
|
if( GetSynchron() )
|
|
rOutStm << MakeSlotName( SvHash_Synchron() ).GetBuffer() << '|';
|
|
if( GetAsynchron() )
|
|
rOutStm << MakeSlotName( SvHash_Asynchron() ).GetBuffer() << '|';
|
|
if( GetRecordPerItem() )
|
|
rOutStm << MakeSlotName( SvHash_RecordPerItem() ).GetBuffer() << '|';
|
|
if( GetRecordPerSet() )
|
|
rOutStm << MakeSlotName( SvHash_RecordPerSet() ).GetBuffer() << '|';
|
|
if( GetRecordManual() )
|
|
rOutStm << MakeSlotName( SvHash_RecordManual() ).GetBuffer() << '|';
|
|
if( GetNoRecord() )
|
|
rOutStm << MakeSlotName( SvHash_NoRecord() ).GetBuffer() << '|';
|
|
if( GetRecordAbsolute() )
|
|
rOutStm << MakeSlotName( SvHash_RecordAbsolute() ).GetBuffer() << '|';
|
|
if( GetHasDialog() )
|
|
rOutStm << MakeSlotName( SvHash_HasDialog() ).GetBuffer() << '|';
|
|
if( GetMenuConfig() )
|
|
rOutStm << MakeSlotName( SvHash_MenuConfig() ).GetBuffer() << '|';
|
|
if( GetToolBoxConfig() )
|
|
rOutStm << MakeSlotName( SvHash_ToolBoxConfig() ).GetBuffer() << '|';
|
|
if( GetStatusBarConfig() )
|
|
rOutStm << MakeSlotName( SvHash_StatusBarConfig() ).GetBuffer() << '|';
|
|
if( GetAccelConfig() )
|
|
rOutStm << MakeSlotName( SvHash_AccelConfig() ).GetBuffer() << '|';
|
|
if( GetFastCall() )
|
|
rOutStm << MakeSlotName( SvHash_FastCall() ).GetBuffer() << '|';
|
|
if( GetContainer() )
|
|
rOutStm << MakeSlotName( SvHash_Container() ).GetBuffer() << '|';
|
|
if ( GetReadOnlyDoc() )
|
|
rOutStm << MakeSlotName( SvHash_ReadOnlyDoc() ).GetBuffer() << '|';
|
|
if( GetImageRotation() )
|
|
rOutStm << MakeSlotName( SvHash_ImageRotation() ).GetBuffer() << '|';
|
|
#if SUPD>=643
|
|
if( GetImageReflection() )
|
|
rOutStm << MakeSlotName( SvHash_ImageReflection() ).GetBuffer() << '|';
|
|
#endif
|
|
rOutStm << '0';
|
|
|
|
rOutStm << ',' << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
if ( !GetDisableFlags().Len() )
|
|
rOutStm << "0";
|
|
else
|
|
rOutStm << GetDisableFlags().GetBuffer();
|
|
|
|
// Attribut Typ schreiben
|
|
if( !bIsEnumSlot )
|
|
{
|
|
rOutStm << ',' << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
|
|
SvMetaType * pT = GetSlotType();
|
|
if( !pT )
|
|
{
|
|
if( !IsVariable() )
|
|
pT = rBase.FindType( "SfxVoidItem" );
|
|
else
|
|
pT = GetType();
|
|
}
|
|
if( pT )
|
|
{
|
|
rOutStm << pT->GetName().GetBuffer();
|
|
if( !rBase.FindType( pT, rBase.aUsedTypes ) )
|
|
rBase.aUsedTypes.Append( pT );
|
|
}
|
|
else
|
|
rOutStm << "SfxVoidItem not defined";
|
|
}
|
|
else
|
|
{
|
|
SvMetaType *pT = rBase.FindType( "SfxBoolItem" );
|
|
if ( pT && !rBase.FindType( pT, rBase.aUsedTypes ) )
|
|
rBase.aUsedTypes.Append( pT );
|
|
}
|
|
|
|
if( !bIsEnumSlot )
|
|
{
|
|
rOutStm << ',' << endl;
|
|
WriteTab( rOutStm, 4 );
|
|
rOutStm << ByteString::CreateFromInt32( nCount ).GetBuffer() << "/*Offset*/, ";
|
|
|
|
if( IsMethod() )
|
|
{
|
|
SvMetaAttribute * pMethod = GetMethod();
|
|
SvMetaType * pType;
|
|
if( pMethod )
|
|
pType = pMethod->GetType();
|
|
else
|
|
pType = GetType();
|
|
ULONG nSCount = pType->GetAttrCount();
|
|
rOutStm << ByteString::CreateFromInt32( nSCount ).GetBuffer() << "/*Count*/";
|
|
}
|
|
else
|
|
rOutStm << '0';
|
|
|
|
// Name f"urs Recording
|
|
if ( GetExport() )
|
|
{
|
|
rOutStm << ",\"";
|
|
if( rPrefix.Len() )
|
|
rOutStm << rPrefix.GetBuffer();
|
|
rOutStm << '.';
|
|
if ( !IsVariable() || !GetType() ||
|
|
GetType()->GetBaseType()->GetType() != TYPE_STRUCT )
|
|
rOutStm << GetMangleName( FALSE ).GetBuffer();
|
|
rOutStm << "\",";
|
|
}
|
|
else
|
|
rOutStm << ", 0, ";
|
|
|
|
// Method/Property Flags
|
|
if( IsMethod() )
|
|
rOutStm << "SFX_SLOT_METHOD|";
|
|
if( IsVariable() )
|
|
{
|
|
rOutStm << "SFX_SLOT_PROPGET|";
|
|
if( !GetReadonly() )
|
|
rOutStm << "SFX_SLOT_PROPSET|";
|
|
}
|
|
|
|
rOutStm << '0';
|
|
}
|
|
|
|
// if ( GetUnoName().Len() )
|
|
{
|
|
rOutStm << ",\"";
|
|
rOutStm << GetMangleName( FALSE ).GetBuffer();
|
|
//rOutStm << GetUnoName().GetBuffer();
|
|
rOutStm << "\"";
|
|
}
|
|
// else
|
|
// rOutStm << ", 0";
|
|
|
|
rOutStm << " )," << endl;
|
|
}
|
|
|
|
USHORT SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutStm )
|
|
{
|
|
if ( !GetExport() && !GetHidden() )
|
|
return 0;
|
|
|
|
SvMetaAttribute * pMethod = GetMethod();
|
|
if( IsMethod() )
|
|
{
|
|
SvMetaType * pType;
|
|
if( pMethod )
|
|
pType = pMethod->GetType();
|
|
else
|
|
pType = GetType();
|
|
|
|
if( !rBase.FindType( pType, rBase.aUsedTypes ) )
|
|
rBase.aUsedTypes.Append( pType );
|
|
|
|
const SvMetaAttributeMemberList & rList =
|
|
pType->GetAttrList();
|
|
for( ULONG n = 0; n < rList.Count(); n++ )
|
|
{
|
|
SvMetaAttribute * pPar = rList.GetObject( n );
|
|
SvMetaType * pPType = pPar->GetType();
|
|
WriteTab( rOutStm, 1 );
|
|
rOutStm << "SFX_ARGUMENT("
|
|
<< pPar->GetSlotId().GetBuffer() << ',' // SlodId
|
|
// Parameter Name
|
|
<< "\"" << pPar->GetName().GetBuffer() << "\","
|
|
// Item Name
|
|
<< pPType->GetName().GetBuffer() << ")," << endl;
|
|
if( !rBase.FindType( pPType, rBase.aUsedTypes ) )
|
|
rBase.aUsedTypes.Append( pPType );
|
|
}
|
|
return (USHORT)rList.Count();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
USHORT SvMetaSlot::WriteSlotMap( const ByteString & rShellName, USHORT nCount,
|
|
SvSlotElementList& rSlotList,
|
|
const ByteString & rPrefix,
|
|
SvIdlDataBase & rBase,
|
|
SvStream & rOutStm )
|
|
{
|
|
// SlotId, wenn nicht angegeben, aus Namen generieren
|
|
ByteString aSlotId = GetSlotId();
|
|
|
|
USHORT nSCount = 0;
|
|
if( IsMethod() )
|
|
{
|
|
SvMetaType * pType;
|
|
SvMetaAttribute * pMethod = GetMethod();
|
|
if( pMethod )
|
|
pType = pMethod->GetType();
|
|
else
|
|
pType = GetType();
|
|
|
|
nSCount = (USHORT)pType->GetAttrCount();
|
|
}
|
|
|
|
WriteSlot( rShellName, nCount, aSlotId, ByteString(),
|
|
rSlotList, rPrefix, rBase, rOutStm );
|
|
/*
|
|
SvMetaTypeEnum * pEnum = NULL;
|
|
SvMetaType * pBType = GetType()->GetBaseType();
|
|
pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
|
|
if( aPseudoSlots && pEnum )
|
|
{
|
|
rBase.nMasterPos = rBase.nSlotPos-1;
|
|
rBase.nEnumPos = rBase.nMasterPos + pEnum->Count() + 1;
|
|
|
|
for( ULONG n = 0; n < pEnum->Count(); n++ )
|
|
{
|
|
ByteString aValName = pEnum->GetObject( n )->GetName();
|
|
ByteString aSId( aSlotId );
|
|
if( GetPseudoPrefix().Len() )
|
|
aSId = GetPseudoPrefix();
|
|
aSId += '_';
|
|
USHORT nLen = pEnum->GetPrefix().Len();
|
|
aSId += aValName.Copy( pEnum->GetPrefix().Len() );
|
|
WriteSlot( rShellName, nCount + nSCount, aSId, aValName, rSlotList, rBase, rOutStm );
|
|
}
|
|
}
|
|
*/
|
|
return nSCount;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|* SvMetaSlot::WriteSrc()
|
|
*************************************************************************/
|
|
void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
|
|
Table * pTable )
|
|
{
|
|
if (!GetToolBoxConfig() && !GetAccelConfig() && !GetMenuConfig() && !GetStatusBarConfig() )
|
|
return;
|
|
|
|
ULONG nSId = GetSlotId().GetValue();
|
|
if( !pTable->IsKeyValid( nSId ) )
|
|
{
|
|
pTable->Insert( nSId, this );
|
|
rOutStm << "SfxSlotInfo " << ByteString::CreateFromInt32( nSId ).GetBuffer()
|
|
<< endl << '{' << endl;
|
|
|
|
WriteTab( rOutStm, 1 );
|
|
ByteString aStr = GetConfigName();
|
|
if( !aStr.Len() )
|
|
aStr = GetName();
|
|
|
|
rOutStm << "SlotName = \"" << aStr.GetBuffer() << "\";" << endl;
|
|
|
|
aStr = GetHelpText();
|
|
if( aStr.Len() )
|
|
{
|
|
WriteTab( rOutStm, 1 );
|
|
rOutStm << "HelpText = \"" << aStr.GetBuffer() << "\";" << endl;
|
|
}
|
|
|
|
rOutStm << "};" << endl;
|
|
}
|
|
|
|
SvMetaTypeEnum * pEnum = PTR_CAST( SvMetaTypeEnum, GetType() );
|
|
if( GetPseudoSlots() && pEnum )
|
|
{
|
|
for( ULONG n = 0; n < pEnum->Count(); n++ )
|
|
{
|
|
ByteString aValName = pEnum->GetObject( n )->GetName();
|
|
ByteString aSId( GetSlotId() );
|
|
if( GetPseudoPrefix().Len() )
|
|
aSId = GetPseudoPrefix();
|
|
aSId += '_';
|
|
USHORT nLen = pEnum->GetPrefix().Len();
|
|
aSId += aValName.Copy( pEnum->GetPrefix().Len() );
|
|
|
|
ULONG nSId;
|
|
BOOL bIdOk = FALSE;
|
|
if( rBase.FindId( aSId, &nSId ) )
|
|
{
|
|
aSId = ByteString::CreateFromInt32( nSId );
|
|
bIdOk = TRUE;
|
|
}
|
|
|
|
// wenn Id nicht gefunden, immer schreiben
|
|
if( !bIdOk || !pTable->IsKeyValid( nSId ) )
|
|
{
|
|
pTable->Insert( nSId, this );
|
|
rOutStm << "SfxSlotInfo " << aSId.GetBuffer()
|
|
<< endl << '{' << endl;
|
|
|
|
WriteTab( rOutStm, 1 );
|
|
rOutStm << "SlotName = \"" << aValName.GetBuffer() << "\";" << endl;
|
|
|
|
ByteString aStr = GetHelpText();
|
|
if( aStr.Len() )
|
|
{
|
|
WriteTab( rOutStm, 1 );
|
|
rOutStm << "HelpText = \"" << aStr.GetBuffer() << "\";" << endl;
|
|
}
|
|
rOutStm << "};" << endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SvMetaSlot::WriteHelpId( SvIdlDataBase & rBase, SvStream & rOutStm,
|
|
Table * pTable )
|
|
{
|
|
ULONG nSId = GetSlotId().GetValue();
|
|
if( !pTable->IsKeyValid( nSId ) )
|
|
{
|
|
pTable->Insert( nSId, this );
|
|
rOutStm << "#define " << GetSlotId().GetBuffer() << '\t' << ByteString::CreateFromInt32( nSId ).GetBuffer() << endl;
|
|
}
|
|
|
|
SvMetaTypeEnum * pEnum = PTR_CAST( SvMetaTypeEnum, GetType() );
|
|
if( GetPseudoSlots() && pEnum )
|
|
{
|
|
for( ULONG n = 0; n < pEnum->Count(); n++ )
|
|
{
|
|
ByteString aValName = pEnum->GetObject( n )->GetName();
|
|
ByteString aSId( GetSlotId() );
|
|
if( GetPseudoPrefix().Len() )
|
|
aSId = GetPseudoPrefix();
|
|
aSId += '_';
|
|
USHORT nLen = pEnum->GetPrefix().Len();
|
|
aSId += aValName.Copy( pEnum->GetPrefix().Len() );
|
|
|
|
ULONG nSId;
|
|
BOOL bIdOk = FALSE;
|
|
if( rBase.FindId( aSId, &nSId ) )
|
|
{
|
|
aSId = ByteString::CreateFromInt32( nSId );
|
|
bIdOk = TRUE;
|
|
}
|
|
|
|
// wenn Id nicht gefunden, immer schreiben
|
|
if( !bIdOk || !pTable->IsKeyValid( nSId ) )
|
|
{
|
|
pTable->Insert( nSId, this );
|
|
|
|
rOutStm << "#define " << aSId.GetBuffer() << '\t'
|
|
<< ByteString::CreateFromInt32( nSId ).GetBuffer() << endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SvMetaSlot::CompareSlotAttributes( SvMetaSlot* pSlot )
|
|
{
|
|
ByteString aStr = Compare( pSlot );
|
|
|
|
if ( GetMenuConfig() || GetToolBoxConfig() || GetAccelConfig() || GetStatusBarConfig() )
|
|
{
|
|
if ( GetHelpText().Len() )
|
|
{
|
|
ByteString aRefText( pSlot->GetHelpText() );
|
|
ByteString aText( GetHelpText() );
|
|
if ( !aText.Equals( aRefText ) )
|
|
{
|
|
aStr += " HelpText\n";
|
|
aStr += aText;
|
|
aStr += '\n';
|
|
aStr += aRefText;
|
|
aStr += '\n';
|
|
}
|
|
}
|
|
|
|
if ( GetConfigName().Len() )
|
|
{
|
|
ByteString aRefText( pSlot->GetConfigName() );
|
|
ByteString aText( GetConfigName() );
|
|
if ( !aText.Equals( aRefText ) )
|
|
{
|
|
aStr += " ConfigName\n";
|
|
aStr += aText;
|
|
aStr += '\n';
|
|
aStr += aRefText;
|
|
aStr += '\n';
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( GetExport() && !GetName().Equals( pSlot->GetName() ) )
|
|
{
|
|
aStr += " Name\n";
|
|
aStr += GetName();
|
|
aStr += '\n';
|
|
aStr += pSlot->GetName();
|
|
aStr += '\n';
|
|
}
|
|
|
|
if ( (SvMetaType *)GetSlotType() != (SvMetaType *)pSlot->GetSlotType() )
|
|
aStr += " SlotType\n";
|
|
|
|
if ( GetMethod() && !pSlot->GetMethod() ||
|
|
!GetMethod() && pSlot->GetMethod() )
|
|
aStr += " Method\n";
|
|
|
|
if ( GetMethod() && pSlot->GetMethod() )
|
|
GetMethod()->Compare( pSlot->GetMethod() );
|
|
|
|
if ( !GetGroupId().Equals( pSlot->GetGroupId() ) )
|
|
aStr += " GroupId\n";
|
|
|
|
if ( GetHasCoreId() != (BOOL) pSlot->GetHasCoreId() )
|
|
aStr += " HasCoreId\n";
|
|
|
|
if ( !GetConfigId().Equals( pSlot->GetConfigId() ) )
|
|
aStr += " ConfigId\n";
|
|
|
|
if ( !GetDefault().Equals( pSlot->GetDefault() ) )
|
|
aStr += " Default\n";
|
|
|
|
if ( GetPseudoSlots() != pSlot->GetPseudoSlots() )
|
|
aStr += " PseudoSlots\n";
|
|
|
|
if ( GetCachable() != pSlot->GetCachable() )
|
|
aStr += " Cachable\n";
|
|
|
|
if ( GetVolatile() != pSlot->GetVolatile() )
|
|
aStr += " Volatile";
|
|
|
|
if ( GetToggle() != pSlot->GetToggle() )
|
|
aStr += " Toggle\n";
|
|
|
|
if ( GetAutoUpdate() != pSlot->GetAutoUpdate() )
|
|
aStr += " AutoUpdate\n";
|
|
|
|
if ( GetSynchron() != pSlot->GetSynchron() )
|
|
aStr += " Synchron\n";
|
|
|
|
if ( GetAsynchron() != pSlot->GetAsynchron() )
|
|
aStr += " Asynchron\n";
|
|
|
|
if ( GetRecordPerItem() != pSlot->GetRecordPerItem() )
|
|
aStr += " RecordPerItem\n";
|
|
|
|
if ( GetRecordPerSet() != pSlot->GetRecordPerSet() )
|
|
aStr += " RecordPerSet\n";
|
|
|
|
if ( GetRecordManual() != pSlot->GetRecordManual() )
|
|
aStr += " RecordManual\n";
|
|
|
|
if ( GetNoRecord() != pSlot->GetNoRecord() )
|
|
aStr += " NoRecord\n";
|
|
|
|
if ( GetRecordAbsolute() != pSlot->GetRecordAbsolute() )
|
|
aStr += " RecordAbsolute\n";
|
|
|
|
if ( GetHasDialog() != pSlot->GetHasDialog() )
|
|
aStr += " HasDialog\n";
|
|
|
|
if ( GetMenuConfig() != pSlot->GetMenuConfig() )
|
|
aStr += " MenuConfig\n";
|
|
|
|
if ( GetToolBoxConfig() != pSlot->GetToolBoxConfig() )
|
|
aStr += " ToolBoxConfig\n";
|
|
|
|
if ( GetStatusBarConfig() != pSlot->GetStatusBarConfig() )
|
|
aStr += " StatusBarConfig\n";
|
|
|
|
if ( GetAccelConfig() != pSlot->GetAccelConfig() )
|
|
aStr += " AccelConfig\n";
|
|
|
|
if ( pSlot->GetFastCall() && !GetFastCall() )
|
|
aStr += " FastCall\n";
|
|
|
|
if ( GetContainer() != pSlot->GetContainer() )
|
|
aStr += " Container\n";
|
|
|
|
if ( GetImageRotation() != pSlot->GetImageRotation() )
|
|
aStr += " ImageRotation\n";
|
|
#if SUPD>=643
|
|
if ( GetImageReflection() != pSlot->GetImageReflection() )
|
|
aStr += " ImageReflection\n";
|
|
#endif
|
|
if ( !GetPseudoPrefix().Equals( pSlot->GetPseudoPrefix() ) )
|
|
aStr += " PseudoPrefix\n";
|
|
|
|
if ( IsVariable() != pSlot->IsVariable() )
|
|
aStr += " Variable\n";
|
|
|
|
if ( aStr.Len() )
|
|
{
|
|
DBG_ERROR( GetSlotId().GetBuffer() );
|
|
DBG_ERROR( aStr.GetBuffer() );
|
|
}
|
|
}
|
|
|
|
void WriteBool( BOOL bSet, SvStream& rStream )
|
|
{
|
|
if ( bSet )
|
|
rStream << "TRUE" << ',';
|
|
else
|
|
rStream << "FALSE" << ',';
|
|
}
|
|
|
|
void SvMetaSlot::WriteCSV( SvIdlDataBase& rBase, SvStream& rStrm )
|
|
{
|
|
rStrm << "PROJECT,";
|
|
rStrm << GetSlotId().GetBuffer() << ',';
|
|
USHORT nId = (USHORT) GetSlotId().GetValue();
|
|
rStrm << ByteString::CreateFromInt32( GetSlotId().GetValue() ).GetBuffer() << ',';
|
|
|
|
if ( GetPseudoPrefix().Len() )
|
|
rStrm << GetPseudoPrefix().GetBuffer() << ',';
|
|
else
|
|
rStrm << ',';
|
|
|
|
rStrm << GetGroupId().GetBuffer() << ',';
|
|
|
|
WriteBool( GetAccelConfig(), rStrm );
|
|
WriteBool( GetMenuConfig(), rStrm );
|
|
WriteBool( GetStatusBarConfig(), rStrm );
|
|
WriteBool( GetToolBoxConfig(), rStrm );
|
|
|
|
if ( GetSlotType() )
|
|
rStrm << GetSlotType()->GetName().GetBuffer() << ',';
|
|
else
|
|
rStrm << ',';
|
|
|
|
WriteBool( GetAutoUpdate(), rStrm );
|
|
if ( GetCachable() )
|
|
rStrm << "Cachable" << ',';
|
|
else
|
|
rStrm << "Volatile" << ',';
|
|
|
|
WriteBool( GetContainer(), rStrm );
|
|
WriteBool( GetFastCall(), rStrm );
|
|
WriteBool( GetHasCoreId(), rStrm );
|
|
WriteBool( GetHasDialog(), rStrm );
|
|
WriteBool( GetReadOnlyDoc(), rStrm );
|
|
WriteBool( GetImageRotation(), rStrm );
|
|
#if SUPD>=643
|
|
WriteBool( GetImageReflection(), rStrm );
|
|
#endif
|
|
rStrm << GetDisableFlags().GetBuffer() << ',';
|
|
|
|
if( GetSynchron() )
|
|
rStrm << "Synchron" << ',';
|
|
else
|
|
rStrm << "Asynchron" << ',';
|
|
|
|
WriteBool( GetToggle(), rStrm );
|
|
WriteBool( GetReadonly(), rStrm );
|
|
WriteBool( GetExport(), rStrm );
|
|
if( GetRecordPerItem() )
|
|
rStrm << "RecordPerItem" << ',';
|
|
else if ( GetNoRecord() )
|
|
rStrm << "NoRecord" << ',';
|
|
else if ( GetRecordManual() )
|
|
rStrm << "RecordManual" << ',';
|
|
else
|
|
rStrm << "RecordPerSet" << ',';
|
|
|
|
WriteBool( GetRecordAbsolute(), rStrm );
|
|
|
|
if ( GetType()->GetType() != TYPE_METHOD && GetMethod() )
|
|
{
|
|
rStrm << GetMethod()->GetType()->GetReturnType()->GetName().GetBuffer() << ',';
|
|
rStrm << GetMethod()->GetName().GetBuffer() << ',';
|
|
}
|
|
else
|
|
{
|
|
rStrm << ",,";
|
|
}
|
|
|
|
rStrm << GetType()->GetSvName().GetBuffer() << ',';
|
|
rStrm << GetName().GetBuffer() << ',';
|
|
|
|
if ( GetType()->GetType() == TYPE_METHOD || GetMethod() )
|
|
{
|
|
SvMetaAttributeMemberList *pList = &GetType()->GetAttrList();
|
|
if ( GetMethod() )
|
|
pList = &GetMethod()->GetType()->GetAttrList();
|
|
|
|
if( pList && pList->Count() )
|
|
{
|
|
rStrm << "\"(";
|
|
SvMetaAttribute* pAttr = pList->First();
|
|
while( pAttr )
|
|
{
|
|
pAttr->WriteCSV( rBase, rStrm );
|
|
pAttr = pList->Next();
|
|
if( pAttr )
|
|
rStrm << ',';
|
|
}
|
|
rStrm << ")\"";
|
|
}
|
|
else
|
|
rStrm << "()";
|
|
}
|
|
|
|
rStrm << endl;
|
|
}
|
|
|
|
#endif // IDL_COMPILER
|
|
|
|
|