/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_idl.hxx" #include #include #include #include #include #include #include /****************** SvMetaSlot *****************************************/ SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute ); SvMetaObject *SvMetaSlot::MakeClone() const { return new SvMetaSlot( *this ); } /************************************************************************* |* SvMetaSlot::SvMetaSlot() |* |* Beschreibung Zweites sal_False bei den SvBOOL-Objekten bedeutet, |* IsSet() liefert sal_False (Defaultinitialisierung). *************************************************************************/ SvMetaSlot::SvMetaSlot() : aCachable( sal_True, sal_False ) , aSynchron( sal_True, sal_False ) , aRecordPerSet( sal_True, sal_False ) , aRecordAbsolute( sal_False, sal_False ) , pLinkedSlot(0) , pNextSlot(0) , pEnumValue(0) { } SvMetaSlot::SvMetaSlot( SvMetaType * pType ) : SvMetaAttribute( pType ) , aCachable( sal_True, sal_False ) , aSynchron( sal_True, sal_False ) , aRecordPerSet( sal_True, sal_False ) , aRecordAbsolute( sal_False, sal_False ) , pLinkedSlot(0) , pNextSlot(0) , pEnumValue(0) { } /* #define TEST_READ \ { \ sal_uInt32 nPos; \ rStm >> nPos; \ DBG_ASSERT( nPos +4 == rStm.Tell(), "stream pos error" ); \ } #define TEST_WRITE \ rStm << (sal_uInt32)rStm.Tell(); */ #define TEST_READ #define TEST_WRITE void SvMetaSlot::Load( SvPersistStream & rStm ) { SvMetaAttribute::Load( rStm ); sal_uInt16 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( nMask & 0x0002 ) rStm >> aImageReflection; } void SvMetaSlot::Save( SvPersistStream & rStm ) { SvMetaAttribute::Save( rStm ); // Maske erstellen sal_uInt16 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( aImageReflection.IsSet() ) nMask |= 0x0002; rStm << nMask; TEST_WRITE if( nMask & 0x0001 ) rStm << aUnoName; TEST_WRITE if( nMask & 0x0002 ) rStm << aImageReflection; } /************************************************************************* |* SvMetaSlot::IsVariable() |* |* Beschreibung *************************************************************************/ sal_Bool SvMetaSlot::IsVariable() const { return SvMetaAttribute::IsVariable(); } /************************************************************************* |* SvMetaSlot::IsMethod() |* |* Beschreibung *************************************************************************/ sal_Bool SvMetaSlot::IsMethod() const { sal_Bool b = SvMetaAttribute::IsMethod(); b |= NULL != GetMethod(); return b; } /************************************************************************* |* SvMetaSlot::HasMethods() |* |* Beschreibung *************************************************************************/ ByteString SvMetaSlot::GetMangleName( sal_Bool bVariable ) const { if( !bVariable ) { SvMetaAttribute * pMeth = GetMethod(); if( pMeth ) return pMeth->GetName(); } return GetName(); } /************************************************************************* |* Referenz |* |* Beschreibung Zweites sal_False bei den SvBOOL-Objekten bedeutet, |* IsSet() liefert sal_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(); } sal_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(); } sal_Bool SvMetaSlot::GetPseudoSlots() const { if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots; return ((SvMetaSlot *)GetRef())->GetPseudoSlots(); } /* sal_Bool SvMetaSlot::GetGet() const { if( aGet.IsSet() || !GetRef() ) return aGet; return ((SvMetaSlot *)GetRef())->GetGet(); } sal_Bool SvMetaSlot::GetSet() const { if( aSet.IsSet() || !GetRef() ) return aSet; return ((SvMetaSlot *)GetRef())->GetSet(); } */ sal_Bool SvMetaSlot::GetCachable() const { // Cachable und Volatile sind exclusiv if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() ) return aCachable; return ((SvMetaSlot *)GetRef())->GetCachable(); } sal_Bool SvMetaSlot::GetVolatile() const { // Cachable und Volatile sind exclusiv if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() ) return aVolatile; return ((SvMetaSlot *)GetRef())->GetVolatile(); } sal_Bool SvMetaSlot::GetToggle() const { if( aToggle.IsSet() || !GetRef() ) return aToggle; return ((SvMetaSlot *)GetRef())->GetToggle(); } sal_Bool SvMetaSlot::GetAutoUpdate() const { if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate; return ((SvMetaSlot *)GetRef())->GetAutoUpdate(); } sal_Bool SvMetaSlot::GetSynchron() const { // Synchron und Asynchron sind exclusiv if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() ) return aSynchron; return ((SvMetaSlot *)GetRef())->GetSynchron(); } sal_Bool SvMetaSlot::GetAsynchron() const { // Synchron und Asynchron sind exclusiv if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() ) return aAsynchron; return ((SvMetaSlot *)GetRef())->GetAsynchron(); } sal_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(); } sal_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(); } sal_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(); } sal_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(); } sal_Bool SvMetaSlot::GetRecordAbsolute() const { if( !GetRef() || aRecordAbsolute.IsSet() ) return aRecordAbsolute; return ((SvMetaSlot *)GetRef())->GetRecordAbsolute(); } sal_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(); } sal_Bool SvMetaSlot::GetMenuConfig() const { if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig; return ((SvMetaSlot *)GetRef())->GetMenuConfig(); } sal_Bool SvMetaSlot::GetToolBoxConfig() const { if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig; return ((SvMetaSlot *)GetRef())->GetToolBoxConfig(); } sal_Bool SvMetaSlot::GetStatusBarConfig() const { if( aStatusBarConfig.IsSet() || !GetRef() ) return aStatusBarConfig; return ((SvMetaSlot *)GetRef())->GetStatusBarConfig(); } sal_Bool SvMetaSlot::GetAccelConfig() const { if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig; return ((SvMetaSlot *)GetRef())->GetAccelConfig(); } sal_Bool SvMetaSlot::GetFastCall() const { if( aFastCall.IsSet() || !GetRef() ) return aFastCall; return ((SvMetaSlot *)GetRef())->GetFastCall(); } sal_Bool SvMetaSlot::GetContainer() const { if( aContainer.IsSet() || !GetRef() ) return aContainer; return ((SvMetaSlot *)GetRef())->GetContainer(); } sal_Bool SvMetaSlot::GetImageRotation() const { if( aImageRotation.IsSet() || !GetRef() ) return aImageRotation; return ((SvMetaSlot *)GetRef())->GetImageRotation(); } sal_Bool SvMetaSlot::GetImageReflection() const { if( aImageReflection.IsSet() || !GetRef() ) return aImageReflection; return ((SvMetaSlot *)GetRef())->GetImageReflection(); } 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, sal_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, sal_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 ); sal_Bool bOk = sal_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 ), " 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 ), " old style, use method declaration", rInStm.GetToken()->GetLine(), rInStm.GetToken()->GetColumn() ); } if( aCachable.ReadSvIdl( SvHash_Cachable(), rInStm ) ) SetCachable( aCachable ), bOk = sal_True; if( aVolatile.ReadSvIdl( SvHash_Volatile(), rInStm ) ) SetVolatile( aVolatile ), bOk = sal_True; if( aToggle.ReadSvIdl( SvHash_Toggle(), rInStm ) ) SetToggle( aToggle ), bOk = sal_True; if( aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm ) ) SetAutoUpdate( aAutoUpdate ), bOk = sal_True; if( aSynchron.ReadSvIdl( SvHash_Synchron(), rInStm ) ) SetSynchron( aSynchron ), bOk = sal_True; if( aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm ) ) SetAsynchron( aAsynchron ), bOk = sal_True; if( aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm ) ) SetRecordAbsolute( aRecordAbsolute), bOk = sal_True; if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) ) SetRecordPerItem( aRecordPerItem ), bOk = sal_True; if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) ) SetRecordPerSet( aRecordPerSet ), bOk = sal_True; if( aRecordManual.ReadSvIdl( SvHash_RecordManual(), rInStm ) ) SetRecordManual( aRecordManual ), bOk = sal_True; if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) ) SetNoRecord( aNoRecord ), bOk = sal_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 = sal_True; bOk |= aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm ); bOk |= aContainer.ReadSvIdl( SvHash_Container(), rInStm ); bOk |= aImageRotation.ReadSvIdl( SvHash_ImageRotation(), rInStm ); bOk |= aImageReflection.ReadSvIdl( SvHash_ImageReflection(), rInStm ); bOk |= aUnoName.ReadSvIdl( SvHash_UnoName(), rInStm ); if( !bOk ) { if( !aSlotType.Is() ) { sal_uInt32 nTokPos = rInStm.Tell(); SvToken * pTok = rInStm.GetToken_Next(); if( pTok->Is( SvHash_SlotType() ) ) { sal_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(); sal_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, sal_uInt16 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 const * 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 == sal_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 == sal_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 == sal_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( aImageReflection ) { ( aOut += aDel ) += aImageReflection.GetSvIdlString( SvHash_ImageReflection() ); aDel = ", "; } if( aOut.Len() ) { WriteTab( rOutStm, nTab ); rOutStm << aOut.GetBuffer() << endl; } } /************************************************************************* |* SvMetaSlot::Test() |* |* Beschreibung *************************************************************************/ sal_Bool SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm ) { sal_Bool bOk = SvMetaAttribute::Test( rBase, rInStm ); if( bOk ) { SvMetaType * pType = GetType(); if( pType->GetType() == TYPE_METHOD ) pType = pType->GetReturnType(); if( !pType->IsItem() ) { rBase.SetError( "this attribute is not a slot", rInStm.GetToken() ); rBase.WriteError( rInStm ); bOk = sal_False; } } return bOk; } /************************************************************************* |* SvMetaSlot::ReadSvIdl() |* |* Beschreibung *************************************************************************/ sal_Bool SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) { sal_uInt32 nTokPos = rInStm.Tell(); sal_Bool bOk = sal_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 = sal_False; } } else { bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm ); SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() ); if( pAttr2 ) { // F"ur Testzwecke: Referenz bei kompletter Definition SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 ); if( pKnownSlot ) { SetRef( pKnownSlot ); // Namen d"urfen abweichen, da mit angegeben if ( pKnownSlot->GetName() != GetName() ) { DBG_ERROR("Illegal definition!"); rInStm.Seek( nTokPos ); return sal_False; } SetName( pKnownSlot->GetName(), &rBase ); } else { ByteString aStr( "attribute " ); aStr += pAttr2->GetName(); aStr += " is method or variable but not a slot"; rBase.SetError( aStr, rInStm.GetToken() ); rBase.WriteError( rInStm ); bOk = sal_False; } } } if( !bOk ) rInStm.Seek( nTokPos ); return bOk; } /************************************************************************* |* SvMetaSlot::WriteSvIdl() |* |* Beschreibung *************************************************************************/ void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, sal_uInt16 nTab ) { SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab ); } /************************************************************************* |* SvMetaSlot::Write() |* |* Beschreibung *************************************************************************/ void SvMetaSlot::Write( SvIdlDataBase & rBase, SvStream & rOutStm, sal_uInt16 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 sal_uInt16 nId = (sal_uInt16) GetSlotId().GetValue(); sal_uInt16 nListCount = (sal_uInt16) rList.Count(); sal_uInt16 nPos; sal_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 { sal_uInt16 nMid = 0, nLow = 0; sal_uInt16 nHigh = nListCount - 1; sal_Bool bFound = sal_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 = sal_True; } DBG_ASSERT(!bFound, "Duplicate SlotId!"); nPos = bFound ? nMid : nLow; } DBG_ASSERT( nPos <= nListCount, "nPos too large" ); DBG_ASSERT( nPos == nListCount || nId <= (sal_uInt16) rList.GetObject(nPos)->xSlot->GetSlotId().GetValue(), "Successor has lower SlotId" ); DBG_ASSERT( nPos == 0 || nId > (sal_uInt16) rList.GetObject(nPos-1)->xSlot->GetSlotId().GetValue(), "Predecessor has higher SlotId" ); DBG_ASSERT( nPos+1 >= nListCount || nId < (sal_uInt16) 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( sal_uLong n = 0; n < pEnum->Count(); n++ ) { // Die SlotId erzeugen SvMetaEnumValue *enumValue = pEnum->GetObject(n); ByteString aValName = enumValue->GetName(); ByteString aSId( GetSlotId() ); if( GetPseudoPrefix().Len() ) aSId = GetPseudoPrefix(); aSId += '_'; aSId += aValName.Copy( pEnum->GetPrefix().Len() ); xEnumSlot = NULL; for( m=0; mGetSlotId() == aSId ) { SvMetaSlot* pSlot = PTR_CAST( SvMetaSlot, pAttr ); xEnumSlot = pSlot->Clone(); break; } } if ( m == rBase.GetAttrList().Count() ) { DBG_ERROR("Invalid EnumSlot!"); xEnumSlot = Clone(); sal_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 = sal_False; xEnumSlot->SetEnumValue(enumValue); 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((sal_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" ) { sal_Bool bIn = sal_False; for( sal_uInt16 n = 0; n < rList.Count(); n++ ) { if( *(rList.GetObject(n)) == aMethodName ) { bIn=sal_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" ) { sal_Bool bIn = sal_False; for ( sal_uInt16 n=0; n < rList.Count(); n++ ) { if ( *(rList.GetObject(n)) == aMethodName ) { bIn=sal_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, sal_uInt16 nCount, const ByteString & rSlotId, SvSlotElementList& rSlotList, const ByteString & rPrefix, SvIdlDataBase & rBase, SvStream & rOutStm ) { if ( !GetExport() && !GetHidden() ) return; // sal_Bool bIsEnumSlot = 0 != rValueName.Len(); sal_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( GetImageReflection() ) rOutStm << MakeSlotName( SvHash_ImageReflection() ).GetBuffer() << '|'; 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(); sal_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( sal_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( sal_False ).GetBuffer(); //rOutStm << GetUnoName().GetBuffer(); rOutStm << "\""; } // else // rOutStm << ", 0"; rOutStm << " )," << endl; } sal_uInt16 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( sal_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 (sal_uInt16)rList.Count(); } return 0; } sal_uInt16 SvMetaSlot::WriteSlotMap( const ByteString & rShellName, sal_uInt16 nCount, SvSlotElementList& rSlotList, const ByteString & rPrefix, SvIdlDataBase & rBase, SvStream & rOutStm ) { // SlotId, wenn nicht angegeben, aus Namen generieren ByteString slotId = GetSlotId(); sal_uInt16 nSCount = 0; if( IsMethod() ) { SvMetaType * pType; SvMetaAttribute * pMethod = GetMethod(); if( pMethod ) pType = pMethod->GetType(); else pType = GetType(); nSCount = (sal_uInt16)pType->GetAttrCount(); } WriteSlot( rShellName, nCount, slotId, rSlotList, rPrefix, rBase, rOutStm ); return nSCount; } /************************************************************************* |* SvMetaSlot::WriteSrc() *************************************************************************/ void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, Table * pTable ) { if (!GetToolBoxConfig() && !GetAccelConfig() && !GetMenuConfig() && !GetStatusBarConfig() ) return; sal_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( sal_uLong n = 0; n < pEnum->Count(); n++ ) { ByteString aValName = pEnum->GetObject( n )->GetName(); ByteString aSId( GetSlotId() ); if( GetPseudoPrefix().Len() ) aSId = GetPseudoPrefix(); aSId += '_'; aSId += aValName.Copy( pEnum->GetPrefix().Len() ); sal_uLong nSId2; sal_Bool bIdOk = sal_False; if( rBase.FindId( aSId, &nSId2 ) ) { aSId = ByteString::CreateFromInt32( nSId2 ); bIdOk = sal_True; } // wenn Id nicht gefunden, immer schreiben if( !bIdOk || !pTable->IsKeyValid( nSId2 ) ) { pTable->Insert( nSId2, 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 ) { sal_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( sal_uLong n = 0; n < pEnum->Count(); n++ ) { ByteString aValName = pEnum->GetObject( n )->GetName(); ByteString aSId( GetSlotId() ); if( GetPseudoPrefix().Len() ) aSId = GetPseudoPrefix(); aSId += '_'; aSId += aValName.Copy( pEnum->GetPrefix().Len() ); sal_uLong nSId2; sal_Bool bIdOk = sal_False; if( rBase.FindId( aSId, &nSId2 ) ) { aSId = ByteString::CreateFromInt32( nSId2 ); bIdOk = sal_True; } // wenn Id nicht gefunden, immer schreiben if( !bIdOk || !pTable->IsKeyValid( nSId2 ) ) { pTable->Insert( nSId2, this ); rOutStm << "#define " << aSId.GetBuffer() << '\t' << ByteString::CreateFromInt32( nSId2 ).GetBuffer() << endl; } } } } void WriteBool( sal_Bool bSet, SvStream& rStream ) { if ( bSet ) rStream << "sal_True" << ','; else rStream << "sal_False" << ','; } void SvMetaSlot::WriteCSV( SvIdlDataBase& rBase, SvStream& rStrm ) { rStrm << "PROJECT,"; rStrm << GetSlotId().GetBuffer() << ','; 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 ); WriteBool( GetImageReflection(), rStrm ); 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