| /************************************************************** |
| * |
| * 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 <ctype.h> |
| #include <stdio.h> |
| |
| #include <tools/debug.hxx> |
| |
| #include <attrib.hxx> |
| #include <object.hxx> |
| #include <globals.hxx> |
| #include <database.hxx> |
| |
| /******************** class SvClassElement *******************************/ |
| SV_IMPL_PERSIST1( SvClassElement, SvPersistBase ); |
| |
| /************************************************************************* |
| |* SvClassElement::SvClassElement() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| SvClassElement::SvClassElement() |
| { |
| }; |
| |
| /************************************************************************* |
| |* SvClassElement::Load() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvClassElement::Load( SvPersistStream & rStm ) |
| { |
| sal_uInt8 nMask; |
| rStm >> nMask; |
| if( nMask >= 0x08 ) |
| { |
| rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); |
| DBG_ERROR( "wrong format" ); |
| return; |
| } |
| if( nMask & 0x01 ) rStm >> aAutomation; |
| if( nMask & 0x02 ) rStm.ReadByteString( aPrefix ); |
| if( nMask & 0x04 ) |
| { |
| SvMetaClass * p; |
| rStm >> p; |
| xClass = p; |
| } |
| } |
| |
| /************************************************************************* |
| |* SvClassElement::Save() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvClassElement::Save( SvPersistStream & rStm ) |
| { |
| // Maske erstellen |
| sal_uInt8 nMask = 0; |
| if( aAutomation.IsSet() ) nMask |= 0x1; |
| if( aPrefix.Len() ) nMask |= 0x2; |
| if( xClass.Is() ) nMask |= 0x4; |
| |
| // Daten schreiben |
| rStm << nMask; |
| if( nMask & 0x01 ) rStm << aAutomation; |
| if( nMask & 0x02 ) rStm.WriteByteString( aPrefix ); |
| if( nMask & 0x04 ) rStm << xClass; |
| } |
| |
| /****************** SvMetaClass ******************************************/ |
| SV_IMPL_META_FACTORY1( SvMetaClass, SvMetaType ); |
| /************************************************************************* |
| |* SvMetaClass::SvMetaClass() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| SvMetaClass::SvMetaClass() |
| : aAutomation( sal_True, sal_False ) |
| { |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::Load() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::Load( SvPersistStream & rStm ) |
| { |
| SvMetaType::Load( rStm ); |
| |
| sal_uInt8 nMask; |
| rStm >> nMask; |
| if( nMask >= 0x20 ) |
| { |
| rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); |
| DBG_ERROR( "wrong format" ); |
| return; |
| } |
| if( nMask & 0x01 ) rStm >> aAttrList; |
| if( nMask & 0x02 ) |
| { |
| SvMetaClass * pSuper; |
| rStm >> pSuper; |
| aSuperClass = pSuper; |
| } |
| if( nMask & 0x04 ) rStm >> aClassList; |
| if( nMask & 0x8 ) |
| { |
| SvMetaClass * p; |
| rStm >> p; |
| xAutomationInterface = p; |
| } |
| if( nMask & 0x10 ) rStm >> aAutomation; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::Save() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::Save( SvPersistStream & rStm ) |
| { |
| SvMetaType::Save( rStm ); |
| |
| // Maske erstellen |
| sal_uInt8 nMask = 0; |
| if( aAttrList.Count() ) nMask |= 0x1; |
| if( aSuperClass.Is() ) nMask |= 0x2; |
| if( aClassList.Count() ) nMask |= 0x4; |
| if( xAutomationInterface.Is() ) nMask |= 0x8; |
| if( aAutomation.IsSet() ) nMask |= 0x10; |
| |
| // Daten schreiben |
| rStm << nMask; |
| if( nMask & 0x01 ) rStm << aAttrList; |
| if( nMask & 0x02 ) rStm << aSuperClass; |
| if( nMask & 0x04 ) rStm << aClassList; |
| if( nMask & 0x08 ) rStm << xAutomationInterface; |
| if( nMask & 0x10 ) rStm << aAutomation; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::FillSbxObject() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| /* |
| void SvMetaClass::FillSbxMemberObject( SvIdlDataBase & rBase, |
| SbxObject * pObj, |
| StringList & rSuperList, |
| sal_Bool bVariable ) |
| { |
| // alle Attribute der Klasse schreiben |
| sal_uLong n ; |
| for( n = 0; n < aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| |
| ByteString aMangleName = pAttr->GetMangleName( bVariable ); |
| ByteString * pS = SvIdlDataBase::FindName( aMangleName, rSuperList ); |
| |
| if( !pS && pAttr->GetExport() ) |
| { |
| // nicht doppelt |
| if( bVariable && pAttr->IsVariable() ) |
| { |
| rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND ); |
| pAttr->FillSbxObject( rBase, pObj, bVariable ); |
| } |
| else if( !bVariable && pAttr->IsMethod() ) |
| { |
| rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND ); |
| pAttr->FillSbxObject( rBase, pObj, bVariable ); |
| } |
| } |
| } |
| // alle Attribute der importierten Klassen schreiben |
| for( n = 0; n < aClassList.Count(); n++ ) |
| { |
| SvClassElement * pEle = aClassList.GetObject( n ); |
| SvMetaClass * pClass = pEle->GetClass(); |
| pClass->FillSbxMemberObject( rBase, pObj, rSuperList, bVariable ); |
| } |
| // alle Attribute der Superklassen schreiben |
| if( aSuperClass.Is() ) |
| aSuperClass->FillSbxMemberObject( rBase, pObj, rSuperList, bVariable ); |
| } |
| */ |
| /************************************************************************* |
| |* SvMetaClass::FillSbxObject() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| /* |
| void SvMetaClass::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj ) |
| { |
| StringList aSuperList; |
| FillSbxMemberObject( rBase, pObj, aSuperList, sal_True ); |
| FillSbxMemberObject( rBase, pObj, aSuperList, sal_False ); |
| |
| ByteString * pStr = aSuperList.First(); |
| while( pStr ) |
| { |
| delete pStr; |
| pStr = aSuperList.Next(); |
| } |
| } |
| */ |
| #ifdef IDL_COMPILER |
| /************************************************************************* |
| |* SvMetaClass::ReadAttributesSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase, |
| SvTokenStream & rInStm ) |
| { |
| SvMetaType::ReadAttributesSvIdl( rBase, rInStm ); |
| aAutomation.ReadSvIdl( SvHash_Automation(), rInStm ); |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteAttributesSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase, |
| SvStream & rOutStm, sal_uInt16 nTab ) |
| { |
| SvMetaType::WriteAttributesSvIdl( rBase, rOutStm, nTab ); |
| |
| if( !aAutomation ) |
| { |
| WriteTab( rOutStm, nTab ); |
| rOutStm << "//class SvMetaClass" << endl; |
| if( !aAutomation ) |
| { |
| WriteTab( rOutStm, nTab ); |
| aAutomation.WriteSvIdl( SvHash_Automation(), rOutStm ); |
| rOutStm << ';' << endl; |
| } |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::ReadContextSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase, |
| SvTokenStream & rInStm ) |
| { |
| sal_uInt32 nTokPos = rInStm.Tell(); |
| SvToken * pTok = rInStm.GetToken_Next(); |
| |
| if( pTok->Is( SvHash_import() ) ) |
| { |
| SvMetaClass * pClass = rBase.ReadKnownClass( rInStm ); |
| if( pClass ) |
| { |
| SvClassElementRef xEle = new SvClassElement(); |
| xEle->SetClass( pClass ); |
| aClassList.Append( xEle ); |
| |
| if( rInStm.Read( '[' ) ) |
| { |
| pTok = rInStm.GetToken_Next(); |
| if( pTok->Is( SvHash_Automation() ) ) |
| { |
| if( rInStm.Read( ']' ) ) |
| { |
| if( xAutomationInterface.Is() ) |
| { |
| // Fehler setzen |
| rBase.SetError( "Automation allready set", |
| rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| } |
| xAutomationInterface = pClass; |
| xEle->SetAutomation( sal_True ); |
| } |
| else |
| { |
| // Fehler setzen |
| rBase.SetError( "missing ]", rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| } |
| } |
| else |
| { |
| // Fehler setzen |
| rBase.SetError( "only attribute Automation allowed", |
| rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| } |
| } |
| pTok = rInStm.GetToken(); |
| if( pTok->IsString() ) |
| { |
| xEle->SetPrefix( pTok->GetString() ); |
| rInStm.GetToken_Next(); |
| } |
| return; |
| } |
| else |
| { |
| // Fehler setzen |
| rBase.SetError( "unknown imported interface", rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| } |
| } |
| else |
| { |
| rInStm.Seek( nTokPos ); |
| SvMetaType * pType = rBase.ReadKnownType( rInStm ); |
| |
| sal_Bool bOk = sal_False; |
| SvMetaAttributeRef xAttr; |
| if( !pType || pType->IsItem() ) |
| { |
| xAttr = new SvMetaSlot( pType ); |
| if( xAttr->ReadSvIdl( rBase, rInStm ) ) |
| bOk = xAttr->Test( rBase, rInStm ); |
| } |
| else |
| { |
| xAttr = new SvMetaAttribute( pType ); |
| if( xAttr->ReadSvIdl( rBase, rInStm ) ) |
| bOk = xAttr->Test( rBase, rInStm ); |
| } |
| |
| if( bOk ) |
| bOk = TestAttribute( rBase, rInStm, *xAttr ); |
| if( bOk ) |
| { |
| if( !xAttr->GetSlotId().IsSet() ) |
| { |
| SvNumberIdentifier aI; |
| aI.SetValue( rBase.GetUniqueId() ); |
| xAttr->SetSlotId( aI ); |
| } |
| aAttrList.Append( xAttr ); |
| return; |
| } |
| } |
| rInStm.Seek( nTokPos ); |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteContextSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteContextSvIdl |
| ( |
| SvIdlDataBase & rBase, |
| SvStream & rOutStm, |
| sal_uInt16 nTab |
| ) |
| { |
| //SvMetaType::WriteContextSvIdl( rBase, rOutStm, nTab ); |
| sal_uLong n; |
| for( n = 0; n < aAttrList.Count(); n++ ) |
| { |
| WriteTab( rOutStm, nTab ); |
| aAttrList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab ); |
| rOutStm << ';' << endl; |
| } |
| for( n = 0; n < aClassList.Count(); n++ ) |
| { |
| SvClassElement * pEle = aClassList.GetObject( n ); |
| WriteTab( rOutStm, nTab ); |
| rOutStm << SvHash_import()->GetName().GetBuffer() << ' ' |
| << pEle->GetPrefix().GetBuffer(); |
| if( pEle->GetAutomation() ) |
| rOutStm << " [ " << SvHash_Automation()->GetName().GetBuffer() |
| << " ]"; |
| if( pEle->GetPrefix().Len() ) |
| rOutStm << ' ' << pEle->GetPrefix().GetBuffer(); |
| rOutStm << ';' << endl; |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::ReadSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_Bool SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) |
| { |
| sal_uLong nTokPos = rInStm.Tell(); |
| if( SvMetaType::ReadHeaderSvIdl( rBase, rInStm ) && GetType() == TYPE_CLASS ) |
| { |
| sal_Bool bOk = sal_True; |
| if( rInStm.Read( ':' ) ) |
| { |
| aSuperClass = rBase.ReadKnownClass( rInStm ); |
| bOk = aSuperClass.Is(); |
| if( !bOk ) |
| { |
| // Fehler setzen |
| rBase.SetError( "unknown super class", |
| rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| } |
| } |
| if( bOk ) |
| { |
| rBase.Write( '.' ); |
| bOk = SvMetaName::ReadSvIdl( rBase, rInStm ); |
| } |
| if( bOk ) |
| return bOk; |
| } |
| rInStm.Seek( nTokPos ); |
| return sal_False; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::TestAttribute() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_Bool SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm, |
| SvMetaAttribute & rAttr ) const |
| { |
| if ( !rAttr.GetRef() && rAttr.IsA( TYPE( SvMetaSlot ) ) ) |
| { |
| DBG_ERROR( "Neuer Slot : " ); |
| DBG_ERROR( rAttr.GetSlotId().GetBuffer() ); |
| } |
| |
| for( sal_uLong n = 0; n < aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pS = aAttrList.GetObject( n ); |
| if( pS->GetName() == rAttr.GetName() ) |
| { |
| // Werte muessen uebereinstimmen |
| if( pS->GetSlotId().GetValue() != rAttr.GetSlotId().GetValue() ) |
| { |
| DBG_ERROR( "Gleicher Name in MetaClass : " ); |
| DBG_ERROR( pS->GetName().GetBuffer() ); |
| DBG_ERROR( pS->GetSlotId().GetBuffer() ); |
| DBG_ERROR( rAttr.GetSlotId().GetBuffer() ); |
| |
| ByteString aStr( "Attribute's " ); |
| aStr += pS->GetName(); |
| aStr += " with different id's"; |
| rBase.SetError( aStr, rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| return sal_False; |
| } |
| } |
| else |
| { |
| sal_uInt32 nId1 = pS->GetSlotId().GetValue(); |
| sal_uInt32 nId2 = rAttr.GetSlotId().GetValue(); |
| if( nId1 == nId2 && nId1 != 0 /*&& nId2 != 0 ist ueberfluessig*/ ) |
| { |
| DBG_ERROR( "Gleiche Id in MetaClass : " ); |
| DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId().GetValue() ).GetBuffer() ); |
| DBG_ERROR( pS->GetSlotId().GetBuffer() ); |
| DBG_ERROR( rAttr.GetSlotId().GetBuffer() ); |
| |
| ByteString aStr( "Attribute " ); |
| aStr += pS->GetName(); |
| aStr += " and Attribute "; |
| aStr += rAttr.GetName(); |
| aStr += " with equal id's"; |
| rBase.SetError( aStr, rInStm.GetToken() ); |
| rBase.WriteError( rInStm ); |
| return sal_False; |
| } |
| } |
| } |
| SvMetaClass * pSC = aSuperClass; |
| if( pSC ) |
| return pSC->TestAttribute( rBase, rInStm, rAttr ); |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteSvIdl() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, |
| sal_uInt16 nTab ) |
| { |
| WriteHeaderSvIdl( rBase, rOutStm, nTab ); |
| if( aSuperClass.Is() ) |
| rOutStm << " : " << aSuperClass->GetName().GetBuffer(); |
| rOutStm << endl; |
| SvMetaName::WriteSvIdl( rBase, rOutStm, nTab ); |
| rOutStm << endl; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteOdlMember() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| /* |
| void SvMetaClass::WriteOdlMembers( ByteStringList & rSuperList, |
| sal_Bool bVariable, sal_Bool bWriteTab, |
| SvIdlDataBase & rBase, |
| SvStream & rOutStm, sal_uInt16 nTab ) |
| { |
| // alle Attribute schreiben |
| sal_uLong n; |
| for( n = 0; n < aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| |
| ByteString aMangleName = pAttr->GetMangleName( bVariable ); |
| ByteString * pS = rBase.FindName( aMangleName, rSuperList ); |
| |
| if( !pS && pAttr->GetExport() ) |
| { |
| // nicht doppelt |
| if( bVariable && pAttr->IsVariable() ) |
| { |
| rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND ); |
| pAttr->Write( rBase, rOutStm, nTab +1, WRITE_ODL, |
| WA_VARIABLE ); |
| rOutStm << ';' << endl; |
| } |
| else if( !bVariable && pAttr->IsMethod() ) |
| { |
| rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND ); |
| pAttr->Write( rBase, rOutStm, nTab +1, WRITE_ODL, |
| WA_METHOD ); |
| rOutStm << ';' << endl; |
| } |
| } |
| else |
| continue; |
| } |
| // alle Attribute der importierten Klassen schreiben |
| for( n = 0; n < aClassList.Count(); n++ ) |
| { |
| SvClassElement * pEle = aClassList.GetObject( n ); |
| SvMetaClass * pCl = pEle->GetClass(); |
| pCl->WriteOdlMembers( rSuperList, bVariable, bWriteTab, |
| rBase, rOutStm, nTab ); |
| } |
| // alle Attribute der Superklassen schreiben |
| SvMetaClass * pSC = aSuperClass; |
| if( pSC ) |
| pSC->WriteOdlMembers( rSuperList, bVariable, bWriteTab, |
| rBase, rOutStm, nTab ); |
| } |
| */ |
| |
| /************************************************************************* |
| |* SvMetaClass::Write() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm, |
| sal_uInt16 nTab, |
| WriteType nT, WriteAttribute ) |
| { |
| rBase.aIFaceName = GetName(); |
| switch( nT ) |
| { |
| case WRITE_ODL: |
| { |
| DBG_ERROR( "Not supported anymore!" ); |
| /* |
| // Schreibt die Attribute |
| SvMetaName::Write( rBase, rOutStm, nTab, nT, nA ); |
| |
| WriteTab( rOutStm, nTab ); |
| rOutStm << "dispinterface " << GetName().GetBuffer() << endl; |
| WriteTab( rOutStm, nTab ); |
| rOutStm << '{' << endl; |
| |
| WriteTab( rOutStm, nTab ); |
| rOutStm << "properties:"; |
| rOutStm << endl; |
| |
| StringList aSuperList; |
| WriteOdlMembers( aSuperList, sal_True, sal_True, rBase, rOutStm, nTab ); |
| |
| WriteTab( rOutStm, nTab ); |
| rOutStm << "methods:"; |
| rOutStm << endl; |
| |
| WriteOdlMembers( aSuperList, sal_False, sal_True, rBase, rOutStm, nTab ); |
| |
| ByteString * pStr = aSuperList.First(); |
| while( pStr ) |
| { |
| delete pStr; |
| pStr = aSuperList.Next(); |
| } |
| |
| WriteTab( rOutStm, 1 ); |
| rOutStm << '}' << endl; |
| */ |
| break; |
| } |
| case WRITE_C_SOURCE: |
| case WRITE_C_HEADER: |
| { |
| DBG_ERROR( "Not supported anymore!" ); |
| /* |
| StringList aSuperList; |
| if( nT == WRITE_C_SOURCE ) |
| { |
| rOutStm << "#pragma code_seg (\"" << GetName().GetBuffer() |
| << "\",\"CODE\")" << endl; |
| } |
| WriteCFunctions( aSuperList, rBase, rOutStm, nTab, nT ); |
| */ |
| break; |
| } |
| case WRITE_DOCU: |
| { |
| rOutStm << "<INTERFACE>" << endl |
| << GetName().GetBuffer(); |
| if ( GetAutomation() ) |
| rOutStm << " ( Automation ) "; |
| rOutStm << endl; |
| WriteDescription( rOutStm ); |
| rOutStm << "</INTERFACE>" << endl << endl; |
| |
| // alle Attribute schreiben |
| sal_uLong n; |
| for( n = 0; n < aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| if( !pAttr->GetHidden() ) |
| { |
| if( pAttr->IsMethod() ) |
| pAttr->Write( rBase, rOutStm, nTab, nT, WA_METHOD ); |
| |
| if( pAttr->IsVariable() ) |
| pAttr->Write( rBase, rOutStm, nTab, nT, WA_VARIABLE ); |
| } |
| } |
| |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteSlotParamArray() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_uInt16 SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase, |
| SvSlotElementList & rSlotList, |
| SvStream & rOutStm ) |
| { |
| sal_uInt16 nCount = 0; |
| for( sal_uLong n = 0; n < rSlotList.Count(); n++ ) |
| { |
| SvSlotElement *pEle = rSlotList.GetObject( n ); |
| SvMetaSlot *pAttr = pEle->xSlot; |
| nCount = nCount + pAttr->WriteSlotParamArray( rBase, rOutStm ); |
| } |
| |
| return nCount; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteSlots() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_uInt16 SvMetaClass::WriteSlots( const ByteString & rShellName, |
| sal_uInt16 nCount, SvSlotElementList & rSlotList, |
| SvIdlDataBase & rBase, |
| SvStream & rOutStm ) |
| { |
| sal_uInt16 nSCount = 0; |
| for( sal_uLong n = 0; n < rSlotList.Count(); n++ ) |
| { |
| rSlotList.Seek(n); |
| SvSlotElement * pEle = rSlotList.GetCurObject(); |
| SvMetaSlot * pAttr = pEle->xSlot; |
| nSCount = nSCount + pAttr->WriteSlotMap( rShellName, nCount + nSCount, |
| rSlotList, pEle->aPrefix, rBase, |
| rOutStm ); |
| } |
| |
| return nSCount; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::InsertSlots() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList, |
| SvMetaClassList &rClassList, |
| const ByteString & rPrefix, SvIdlDataBase& rBase) |
| { |
| // Wurde diese Klasse schon geschrieben ? |
| if ( rClassList.GetPos(this) != LIST_ENTRY_NOTFOUND ) |
| return; |
| |
| rClassList.Insert(this, LIST_APPEND); |
| |
| // alle direkten Attribute schreiben |
| sal_uLong n; |
| for( n = 0; n < aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| |
| sal_uLong nId = pAttr->GetSlotId().GetValue(); |
| sal_uInt16 nPos; |
| for ( nPos=0; nPos < rSuperList.Count(); nPos++ ) |
| { |
| if ( rSuperList.GetObject(nPos) == nId ) |
| break; |
| } |
| |
| if( nPos == rSuperList.Count() ) |
| { |
| // nur schreiben, wenn nicht schon bei SubClass oder |
| // importiertem Interface geschrieben |
| rSuperList.Insert( nId, nPos ); |
| pAttr->Insert(rList, rPrefix, rBase); |
| } |
| } |
| |
| // Alle schon von SuperShells importierten Interfaces sollen nicht |
| // mehr geschrieben werden |
| // Es ist also verboten, da\s Shell und SuperShell die gleiche Klasse |
| // direkt importieren ! |
| if( IsShell() && aSuperClass.Is() ) |
| aSuperClass->FillClasses( rClassList ); |
| |
| // alle Attribute der importierten Klassen schreiben, sofern diese nicht |
| // schon von der Superklasse importiert wurden |
| for( n = 0; n < aClassList.Count(); n++ ) |
| { |
| SvClassElement * pEle = aClassList.GetObject( n ); |
| SvMetaClass * pCl = pEle->GetClass(); |
| ByteString rPre = rPrefix; |
| if( rPre.Len() && pEle->GetPrefix().Len() ) |
| rPre += '.'; |
| rPre += pEle->GetPrefix(); |
| |
| // Zun"achst die direkt importierten Interfaces schreiben |
| pCl->InsertSlots( rList, rSuperList, rClassList, rPre, rBase ); |
| } |
| |
| // Superklassen nur schreiben, wenn keine Shell und nicht in der Liste |
| if( !IsShell() && aSuperClass.Is() ) |
| { |
| aSuperClass->InsertSlots( rList, rSuperList, rClassList, rPrefix, rBase ); |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::FillClasses() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::FillClasses( SvMetaClassList & rList ) |
| { |
| // Bin ich noch nicht drin ? |
| if ( rList.GetPos(this) == LIST_ENTRY_NOTFOUND ) |
| { |
| rList.Insert(this, LIST_APPEND); |
| |
| // Meine Imports |
| for( sal_uLong n = 0; n < aClassList.Count(); n++ ) |
| { |
| SvClassElement * pEle = aClassList.GetObject( n ); |
| SvMetaClass * pCl = pEle->GetClass(); |
| pCl->FillClasses( rList ); |
| } |
| |
| // Meine Superklasse |
| if( aSuperClass.Is() ) |
| aSuperClass->FillClasses( rList ); |
| } |
| } |
| |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteSlotStubs() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteSlotStubs( const ByteString & rShellName, |
| SvSlotElementList & rSlotList, |
| ByteStringList & rList, |
| SvStream & rOutStm ) |
| { |
| // alle Attribute schreiben |
| for( sal_uLong n = 0; n < rSlotList.Count(); n++ ) |
| { |
| SvSlotElement *pEle = rSlotList.GetObject( n ); |
| SvMetaSlot *pAttr = pEle->xSlot; |
| pAttr->WriteSlotStubs( rShellName, rList, rOutStm ); |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteSfx() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm ) |
| { |
| WriteStars( rOutStm ); |
| // Klasse definieren |
| rOutStm << "#ifdef " << GetName().GetBuffer() << endl; |
| rOutStm << "#undef ShellClass" << endl; |
| rOutStm << "#undef " << GetName().GetBuffer() << endl; |
| rOutStm << "#define ShellClass " << GetName().GetBuffer() << endl; |
| |
| // rOutStm << "SFX_TYPELIB(" << GetName().GetBuffer() << ',' << endl |
| // << "\t/* library type */" |
| // << '"' << ByteString( GetModule()->GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << "\"," << endl |
| // << "\t\"" << GetModule()->GetTypeLibFileName().GetBuffer() << "\"," |
| // << ByteString::CreateFromInt32( GetModule()->GetVersion().GetMajorVersion() ).GetBuffer() << ',' |
| // << ByteString::CreateFromInt32( GetModule()->GetVersion().GetMinorVersion() ).GetBuffer() << ',' << endl |
| // << "\t/* shell type */" |
| // << '"'; |
| // if( xAutomationInterface.Is() ) |
| // rOutStm << ByteString( xAutomationInterface->GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer(); |
| // else |
| // rOutStm << ByteString( GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer(); |
| // rOutStm << "\");" << endl << endl; |
| |
| // Fuer Interfaces werden kein Slotmaps geschrieben |
| if( !IsShell() ) |
| { |
| rOutStm << "#endif" << endl << endl; |
| return; |
| } |
| // Parameter Array schreiben |
| //rOutStm << "SfxArgList " << GetName().GetBuffer() << "ArgMap[] = {" << endl; |
| rOutStm << "SFX_ARGUMENTMAP(" << GetName().GetBuffer() << ')' << endl |
| << '{' << endl; |
| |
| SvULongs aSuperList; |
| SvMetaClassList classList; |
| SvSlotElementList aSlotList; |
| InsertSlots(aSlotList, aSuperList, classList, ByteString(), rBase); |
| sal_uLong n; |
| for ( n=0; n<aSlotList.Count(); n++ ) |
| { |
| SvSlotElement *pEle = aSlotList.GetObject( n ); |
| SvMetaSlot *pSlot = pEle->xSlot; |
| pSlot->SetListPos(n); |
| } |
| |
| sal_uLong nSlotCount = aSlotList.Count(); |
| |
| // alle Attribute schreiben |
| sal_uInt16 nArgCount = WriteSlotParamArray( rBase, aSlotList, rOutStm ); |
| if( nArgCount ) |
| Back2Delemitter( rOutStm ); |
| else |
| { |
| // mindestens einen dummy |
| WriteTab( rOutStm, 1 ); |
| rOutStm << "SFX_ARGUMENT( 0, 0, SfxVoidItem )" << endl; |
| } |
| rOutStm << endl << "};" << endl << endl; |
| |
| ByteStringList aStringList; |
| WriteSlotStubs( GetName(), aSlotList, aStringList, rOutStm ); |
| ByteString * pStr = aStringList.First(); |
| while( pStr ) |
| { |
| delete pStr; |
| pStr = aStringList.Next(); |
| } |
| |
| rOutStm << endl; |
| |
| // Slotmap schreiben |
| rOutStm << "SFX_SLOTMAP_ARG(" << GetName().GetBuffer() << ')' << endl |
| << '{' << endl; |
| |
| // alle Attribute schreiben |
| WriteSlots( GetName(), 0, aSlotList, rBase, rOutStm ); |
| if( nSlotCount ) |
| Back2Delemitter( rOutStm ); |
| else |
| { |
| // mindestens einen dummy |
| WriteTab( rOutStm, 1 ); |
| rOutStm << "SFX_SLOT_ARG(" << GetName().GetBuffer() |
| << ", 0, 0, " |
| << "SFX_STUB_PTR_EXEC_NONE," |
| << "SFX_STUB_PTR_STATE_NONE," |
| << "0, SfxVoidItem, 0, 0, \"\", 0 )" << endl; |
| } |
| rOutStm << endl << "};" << endl << "#endif" << endl << endl; |
| |
| for( n=0; n<aSlotList.Count(); n++ ) |
| { |
| aSlotList.Seek(n); |
| SvSlotElement* pEle = aSlotList.GetCurObject(); |
| SvMetaSlot* pAttr = pEle->xSlot; |
| pAttr->ResetSlotPointer(); |
| } |
| |
| for ( n=0; n<aSlotList.Count(); n++ ) |
| delete aSlotList.GetObject(n); |
| } |
| |
| void SvMetaClass::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm, |
| Table* pTable ) |
| { |
| for( sal_uLong n=0; n<aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| pAttr->WriteHelpId( rBase, rOutStm, pTable ); |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaShell::WriteSrc() |
| *************************************************************************/ |
| void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, |
| Table * pTable ) |
| { |
| for( sal_uLong n=0; n<aAttrList.Count(); n++ ) |
| { |
| SvMetaAttribute * pAttr = aAttrList.GetObject( n ); |
| pAttr->WriteSrc( rBase, rOutStm, pTable ); |
| } |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteHxx() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 ) |
| { |
| ByteString aSuperName( "SvDispatch" ); |
| if( GetSuperClass() ) |
| aSuperName = GetSuperClass()->GetName(); |
| const char * pSup = aSuperName.GetBuffer(); |
| |
| rOutStm |
| << "class " << GetSvName().GetBuffer() |
| << ": public " << pSup << endl |
| << '{' << endl |
| << "protected:" << endl |
| << "\tvirtual SvGlobalName GetTypeName() const;" << endl |
| << "\tvirtual sal_Bool FillTypeLibInfo( SvGlobalName *, sal_uInt16 * pMajor," << endl |
| << "\t sal_uInt16 * pMinor ) const;" << endl |
| << "\tvirtual sal_Bool FillTypeLibInfo( ByteString * pName, sal_uInt16 * pMajor," << endl; |
| rOutStm |
| << "\t sal_uInt16 * pMinor ) const;" << endl |
| << "\tvirtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) = 0;" << endl |
| << "public:" << endl |
| << "\t static SvGlobalName ClassName()" << endl |
| << "\t { return SvGlobalName( " << ByteString( GetUUId().GetctorName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << " ); }" << endl |
| << "};" << endl; |
| } |
| |
| /************************************************************************* |
| |* SvMetaClass::WriteCxx() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvMetaClass::WriteCxx( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 ) |
| { |
| ByteString aSuperName( "SvDispatch" ); |
| if( GetSuperClass() ) |
| aSuperName = GetSuperClass()->GetName(); |
| const char * pSup = aSuperName.GetBuffer(); |
| |
| ByteString name = GetSvName(); |
| // GetTypeName |
| rOutStm << "SvGlobalName " << name.GetBuffer() << "::GetTypeName() const" << endl |
| << '{' << endl |
| << "\treturn ClassName();" << endl |
| << '}' << endl; |
| |
| SvMetaModule * pMod = GetModule(); |
| // FillTypeLibInfo |
| rOutStm << "sal_Bool " << name.GetBuffer() << "::FillTypeLibInfo( SvGlobalName * pGN," << endl |
| << "\t sal_uInt16 * pMajor," << endl |
| << "\t sal_uInt16 * pMinor ) const" << endl |
| << '{' << endl |
| << "\tSvGlobalName aN( " << ByteString( pMod->GetUUId().GetctorName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << " );" << endl; |
| rOutStm << "\t*pGN = aN;" << endl |
| << "\t*pMajor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMajorVersion()).GetBuffer() << ';' << endl |
| << "\t*pMinor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMinorVersion()).GetBuffer() << ';' << endl |
| << "\treturn sal_True;" << endl |
| << '}' << endl; |
| |
| // FillTypeLibInfo |
| rOutStm << "sal_Bool " << name.GetBuffer() << "::FillTypeLibInfo( ByteString * pName," |
| << "\t sal_uInt16 * pMajor," << endl |
| << "\t sal_uInt16 * pMinor ) const" << endl; |
| rOutStm << '{' << endl |
| << "\t*pName = \"" << pMod->GetTypeLibFileName().GetBuffer() << "\";" << endl |
| << "\t*pMajor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMajorVersion()).GetBuffer() << ';' << endl |
| << "\t*pMinor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMinorVersion()).GetBuffer() << ';' << endl |
| << "\treturn sal_True;" << endl |
| << '}' << endl; |
| |
| rOutStm << "void " << name.GetBuffer() << "::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )" << endl |
| << '{' << endl |
| << "\t" << pSup << "::Notify( rBC, rHint );" << endl |
| << '}' << endl; |
| } |
| |
| #endif // IDL_COMPILER |
| |