LCOV - code coverage report
Current view: top level - libreoffice/idl/source/objects - slot.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 717 930 77.1 %
Date: 2012-12-27 Functions: 52 63 82.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <ctype.h>
      22             : #include <stdio.h>
      23             : #include <rtl/strbuf.hxx>
      24             : #include <tools/debug.hxx>
      25             : #include <slot.hxx>
      26             : #include <globals.hxx>
      27             : #include <database.hxx>
      28             : 
      29       39337 : SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute );
      30             : 
      31          68 : SvMetaObject *SvMetaSlot::MakeClone() const
      32             : {
      33          68 :         return new SvMetaSlot( *this );
      34             : }
      35             : 
      36        8178 : SvMetaSlot::SvMetaSlot()
      37             :     : aCachable( sal_True, sal_False )
      38             :     , aSynchron( sal_True, sal_False )
      39             :     , aRecordPerSet( sal_True, sal_False )
      40             :     , aRecordAbsolute( sal_False, sal_False )
      41             :     , pLinkedSlot(0)
      42             :     , pNextSlot(0)
      43        8178 :     , pEnumValue(0)
      44             : {
      45        8178 : }
      46             : 
      47        4015 : SvMetaSlot::SvMetaSlot( SvMetaType * pType )
      48             :     : SvMetaAttribute( pType )
      49             :     , aCachable( sal_True, sal_False )
      50             :     , aSynchron( sal_True, sal_False )
      51             :     , aRecordPerSet( sal_True, sal_False )
      52             :     , aRecordAbsolute( sal_False, sal_False )
      53             :     , pLinkedSlot(0)
      54             :     , pNextSlot(0)
      55        4015 :     , pEnumValue(0)
      56             : {
      57        4015 : }
      58             : 
      59             : #define TEST_READ
      60             : #define TEST_WRITE
      61             : 
      62           0 : void SvMetaSlot::Load( SvPersistStream & rStm )
      63             : {
      64           0 :     SvMetaAttribute::Load( rStm );
      65             : 
      66             :     sal_uInt16 nMask;
      67           0 :     rStm >> nMask;
      68             : 
      69             :     TEST_READ
      70           0 :     if( nMask & 0x0001 )
      71             :     {
      72             :         SvMetaAttribute * pMeth;
      73           0 :         rStm >> pMeth;
      74           0 :         aMethod = pMeth;
      75             :     }
      76             : 
      77             :     TEST_READ
      78           0 :     if( nMask & 0x0002 ) rStm >> aGroupId;
      79             :     TEST_READ
      80           0 :     if( nMask & 0x0004 ) rStm >> aHasCoreId;
      81             :     TEST_READ
      82           0 :     if( nMask & 0x0008 ) rStm >> aConfigId;
      83             :     TEST_READ
      84           0 :     if( nMask & 0x0010 ) rStm >> aExecMethod;
      85             :     TEST_READ
      86           0 :     if( nMask & 0x0020 ) rStm >> aStateMethod;
      87             :     TEST_READ
      88           0 :     if( nMask & 0x0040 ) rStm >> aDefault;
      89             :     TEST_READ
      90           0 :     if( nMask & 0x0080 ) rStm >> aPseudoSlots;
      91             :     TEST_READ
      92           0 :     if( nMask & 0x0100 ) rStm >> aGet;
      93             :     TEST_READ
      94           0 :     if( nMask & 0x0200 ) rStm >> aSet;
      95             :     TEST_READ
      96           0 :     if( nMask & 0x0400 ) rStm >> aCachable;
      97             :     TEST_READ
      98           0 :     if( nMask & 0x0800 ) rStm >> aVolatile;
      99             :     TEST_READ
     100           0 :     if( nMask & 0x1000 ) rStm >> aToggle;
     101             :     TEST_READ
     102           0 :     if( nMask & 0x2000 ) rStm >> aAutoUpdate;
     103             :     TEST_READ
     104           0 :     if( nMask & 0x4000 ) rStm >> aSynchron;
     105             :     TEST_READ
     106           0 :     if( nMask & 0x8000 ) rStm >> aAsynchron;
     107             : 
     108           0 :     nMask = 0;
     109           0 :     rStm >> nMask;
     110             : 
     111             :     TEST_READ
     112           0 :     if( nMask & 0x0001 ) rStm >> aRecordPerItem;
     113             :     TEST_READ
     114           0 :     if( nMask & 0x0002 ) rStm >> aRecordManual;
     115             :     TEST_READ
     116           0 :     if( nMask & 0x0004 ) rStm >> aNoRecord;
     117             :     TEST_READ
     118           0 :     if( nMask & 0x0008 ) rStm >> aHasDialog;
     119             :     TEST_READ
     120           0 :     if( nMask & 0x0010 ) rStm >> aDisableFlags;
     121             :     TEST_READ
     122           0 :     if( nMask & 0x0020 ) rStm >> aPseudoPrefix;
     123             :     TEST_READ
     124           0 :     if( nMask & 0x0040 ) rStm >> aRecordPerSet;
     125             :     TEST_READ
     126           0 :     if( nMask & 0x0080 ) rStm >> aMenuConfig;
     127             :     TEST_READ
     128           0 :     if( nMask & 0x0100 ) rStm >> aToolBoxConfig;
     129             :     TEST_READ
     130           0 :     if( nMask & 0x0200 ) rStm >> aStatusBarConfig;
     131             :     TEST_READ
     132           0 :     if( nMask & 0x0400 ) rStm >> aAccelConfig;
     133             :     TEST_READ
     134           0 :     if( nMask & 0x0800 ) rStm >> aFastCall;
     135             :     TEST_READ
     136           0 :     if( nMask & 0x1000 ) rStm >> aContainer;
     137             :     TEST_READ
     138             : 
     139           0 :     if( nMask & 0x2000 )
     140             :     {
     141             :         SvMetaType * pT;
     142           0 :         rStm >> pT;
     143           0 :         aSlotType = pT;
     144             :     }
     145             : 
     146             :     TEST_READ
     147           0 :     if( nMask & 0x4000 ) rStm >> aRecordAbsolute;
     148             :     TEST_READ
     149           0 :     if( nMask & 0x8000 ) rStm >> aImageRotation;
     150             : 
     151           0 :     nMask = 0;
     152           0 :     rStm >> nMask;
     153             : 
     154             :     TEST_READ
     155           0 :     if( nMask & 0x0001 ) rStm >> aUnoName;
     156           0 :     if( nMask & 0x0002 ) rStm >> aImageReflection;
     157           0 : }
     158             : 
     159       11858 : void SvMetaSlot::Save( SvPersistStream & rStm )
     160             : {
     161       11858 :     SvMetaAttribute::Save( rStm );
     162             : 
     163             :     // create mask
     164       11858 :     sal_uInt16 nMask = 0;
     165       11858 :     if( aMethod.Is() )          nMask |= 0x0001;
     166       11858 :     if( !aGroupId.getString().isEmpty() )       nMask |= 0x0002;
     167       11858 :     if( aHasCoreId.IsSet() )    nMask |= 0x0004;
     168       11858 :     if( !aConfigId.getString().isEmpty() )      nMask |= 0x0008;
     169       11858 :     if( !aExecMethod.getString().isEmpty() )    nMask |= 0x0010;
     170       11858 :     if( !aStateMethod.getString().isEmpty() )   nMask |= 0x0020;
     171       11858 :     if( !aDefault.getString().isEmpty() )       nMask |= 0x0040;
     172       11858 :     if( aPseudoSlots.IsSet() )  nMask |= 0x0080;
     173       11858 :     if( aGet.IsSet() )          nMask |= 0x0100;
     174       11858 :     if( aSet.IsSet() )          nMask |= 0x0200;
     175       11858 :     if( aCachable.IsSet() )     nMask |= 0x0400;
     176       11858 :     if( aVolatile.IsSet() )     nMask |= 0x0800;
     177       11858 :     if( aToggle.IsSet() )       nMask |= 0x1000;
     178       11858 :     if( aAutoUpdate.IsSet() )   nMask |= 0x2000;
     179       11858 :     if( aSynchron.IsSet() )     nMask |= 0x4000;
     180       11858 :     if( aAsynchron.IsSet() )    nMask |= 0x8000;
     181             : 
     182             :     // write data
     183       11858 :     rStm << nMask;
     184             :     TEST_WRITE
     185       11858 :     if( nMask & 0x0001 ) rStm << aMethod;
     186             :     TEST_WRITE
     187       11858 :     if( nMask & 0x0002 ) rStm << aGroupId;
     188             :     TEST_WRITE
     189       11858 :     if( nMask & 0x0004 ) rStm << aHasCoreId;
     190             :     TEST_WRITE
     191       11858 :     if( nMask & 0x0008 ) rStm << aConfigId;
     192             :     TEST_WRITE
     193       11858 :     if( nMask & 0x0010 ) rStm << aExecMethod;
     194             :     TEST_WRITE
     195       11858 :     if( nMask & 0x0020 ) rStm << aStateMethod;
     196             :     TEST_WRITE
     197       11858 :     if( nMask & 0x0040 ) rStm << aDefault;
     198             :     TEST_WRITE
     199       11858 :     if( nMask & 0x0080 ) rStm << aPseudoSlots;
     200             :     TEST_WRITE
     201       11858 :     if( nMask & 0x0100 ) rStm << aGet;
     202             :     TEST_WRITE
     203       11858 :     if( nMask & 0x0200 ) rStm << aSet;
     204             :     TEST_WRITE
     205       11858 :     if( nMask & 0x0400 ) rStm << aCachable;
     206             :     TEST_WRITE
     207       11858 :     if( nMask & 0x0800 ) rStm << aVolatile;
     208             :     TEST_WRITE
     209       11858 :     if( nMask & 0x1000 ) rStm << aToggle;
     210             :     TEST_WRITE
     211       11858 :     if( nMask & 0x2000 ) rStm << aAutoUpdate;
     212             :     TEST_WRITE
     213       11858 :     if( nMask & 0x4000 ) rStm << aSynchron;
     214             :     TEST_WRITE
     215       11858 :     if( nMask & 0x8000 ) rStm << aAsynchron;
     216             : 
     217             :     // write next bunch
     218             :     // create mask
     219       11858 :     nMask = 0;
     220       11858 :     if( aRecordPerItem.IsSet() )  nMask |= 0x0001;
     221       11858 :     if( aRecordManual.IsSet() )   nMask |= 0x0002;
     222       11858 :     if( aNoRecord.IsSet() )       nMask |= 0x0004;
     223       11858 :     if( aHasDialog.IsSet() )      nMask |= 0x0008;
     224       11858 :     if ( aDisableFlags.IsSet() )      nMask |= 0x0010;
     225       11858 :     if( !aPseudoPrefix.getString().isEmpty() )    nMask |= 0x0020;
     226       11858 :     if( aRecordPerSet.IsSet() )   nMask |= 0x0040;
     227       11858 :     if( aMenuConfig.IsSet() )     nMask |= 0x0080;
     228       11858 :     if( aToolBoxConfig.IsSet() )  nMask |= 0x0100;
     229       11858 :     if( aStatusBarConfig.IsSet() )nMask |= 0x0200;
     230       11858 :     if( aAccelConfig.IsSet() )    nMask |= 0x0400;
     231       11858 :     if( aFastCall.IsSet() )       nMask |= 0x0800;
     232       11858 :     if( aContainer.IsSet() )      nMask |= 0x1000;
     233       11858 :     if( aSlotType.Is() )          nMask |= 0x2000;
     234       11858 :     if( aRecordAbsolute.IsSet() ) nMask |= 0x4000;
     235       11858 :     if( aImageRotation.IsSet() )       nMask |= 0x8000;
     236             : 
     237             :     // write data
     238       11858 :     rStm << nMask;
     239             :     TEST_WRITE
     240       11858 :     if( nMask & 0x0001 ) rStm << aRecordPerItem;
     241             :     TEST_WRITE
     242       11858 :     if( nMask & 0x0002 ) rStm << aRecordManual;
     243             :     TEST_WRITE
     244       11858 :     if( nMask & 0x0004 ) rStm << aNoRecord;
     245             :     TEST_WRITE
     246       11858 :     if( nMask & 0x0008 ) rStm << aHasDialog;
     247             :     TEST_WRITE
     248       11858 :     if( nMask & 0x0010 ) rStm << aDisableFlags;
     249             :     TEST_WRITE
     250       11858 :     if( nMask & 0x0020 ) rStm << aPseudoPrefix;
     251             :     TEST_WRITE
     252       11858 :     if( nMask & 0x0040 ) rStm << aRecordPerSet;
     253             :     TEST_WRITE
     254       11858 :     if( nMask & 0x0080 ) rStm << aMenuConfig;
     255             :     TEST_WRITE
     256       11858 :     if( nMask & 0x0100 ) rStm << aToolBoxConfig;
     257             :     TEST_WRITE
     258       11858 :     if( nMask & 0x0200 ) rStm << aStatusBarConfig;
     259             :     TEST_WRITE
     260       11858 :     if( nMask & 0x0400 ) rStm << aAccelConfig;
     261             :     TEST_WRITE
     262       11858 :     if( nMask & 0x0800 ) rStm << aFastCall;
     263             :     TEST_WRITE
     264       11858 :     if( nMask & 0x1000 ) rStm << aContainer;
     265             :     TEST_WRITE
     266       11858 :     if( nMask & 0x2000 ) rStm << aSlotType;
     267             :     TEST_WRITE
     268       11858 :     if( nMask & 0x4000 ) rStm << aRecordAbsolute;
     269             :     TEST_WRITE
     270       11858 :     if( nMask & 0x8000 ) rStm << aImageRotation;
     271             : 
     272       11858 :     nMask = 0;
     273       11858 :     if( aUnoName.IsSet() )          nMask |= 0x0001;
     274       11858 :     if( aImageReflection.IsSet() )  nMask |= 0x0002;
     275       11858 :     rStm << nMask;
     276             :     TEST_WRITE
     277       11858 :     if( nMask & 0x0001 ) rStm << aUnoName;
     278             :     TEST_WRITE
     279       11858 :     if( nMask & 0x0002 ) rStm << aImageReflection;
     280       11858 : }
     281             : 
     282       15336 : sal_Bool SvMetaSlot::IsVariable() const
     283             : {
     284       15336 :     return SvMetaAttribute::IsVariable();
     285             : }
     286             : 
     287       21926 : sal_Bool SvMetaSlot::IsMethod() const
     288             : {
     289       21926 :     sal_Bool b = SvMetaAttribute::IsMethod();
     290       21926 :     b |= NULL != GetMethod();
     291       21926 :     return b;
     292             : }
     293             : 
     294       10177 : rtl::OString SvMetaSlot::GetMangleName( sal_Bool bVariable ) const
     295             : {
     296       10177 :     if( !bVariable )
     297             :     {
     298       10177 :         SvMetaAttribute * pMeth = GetMethod();
     299       10177 :         if( pMeth )
     300          40 :             return pMeth->GetName().getString();
     301             :     }
     302       10137 :     return GetName().getString();
     303             : }
     304             : 
     305             : /*************************************************************************
     306             : |*    reference
     307             : |*
     308             : |*    description       Second FALSE in the SvBOOL-Objects means
     309             : |*                      IsSet() provides FALSE (default initialization).
     310             : *************************************************************************/
     311             : /** reference disbandment **/
     312       10877 : SvMetaType * SvMetaSlot::GetSlotType() const
     313             : {
     314       10877 :     if( aSlotType.Is() || !GetRef() ) return aSlotType;
     315        5436 :     return ((SvMetaSlot *)GetRef())->GetSlotType();
     316             : }
     317       88007 : SvMetaAttribute * SvMetaSlot::GetMethod() const
     318             : {
     319       88007 :     if( aMethod.Is() || !GetRef() ) return aMethod;
     320       43839 :     return ((SvMetaSlot *)GetRef())->GetMethod();
     321             : }
     322       10950 : sal_Bool SvMetaSlot::GetHasCoreId() const
     323             : {
     324       10950 :     if( aHasCoreId.IsSet() || !GetRef() ) return aHasCoreId;
     325        5441 :     return ((SvMetaSlot *)GetRef())->GetHasCoreId();
     326             : }
     327       21450 : const rtl::OString& SvMetaSlot::GetGroupId() const
     328             : {
     329       21450 :     if( !aGroupId.getString().isEmpty() || !GetRef() ) return aGroupId.getString();
     330       10513 :     return ((SvMetaSlot *)GetRef())->GetGroupId();
     331             : }
     332       10950 : const rtl::OString& SvMetaSlot::GetDisableFlags() const
     333             : {
     334       10950 :     if( !aDisableFlags.getString().isEmpty() || !GetRef() ) return aDisableFlags.getString();
     335        4505 :     return ((SvMetaSlot *)GetRef())->GetDisableFlags();
     336             : }
     337           0 : const rtl::OString& SvMetaSlot::GetConfigId() const
     338             : {
     339           0 :     if( !aConfigId.getString().isEmpty() || !GetRef() ) return aConfigId.getString();
     340           0 :     return ((SvMetaSlot *)GetRef())->GetConfigId();
     341             : }
     342       21825 : const rtl::OString& SvMetaSlot::GetExecMethod() const
     343             : {
     344       21825 :     if( !aExecMethod.getString().isEmpty() || !GetRef() ) return aExecMethod.getString();
     345         608 :     return ((SvMetaSlot *)GetRef())->GetExecMethod();
     346             : }
     347      145250 : const rtl::OString& SvMetaSlot::GetStateMethod() const
     348             : {
     349      145250 :     if( !aStateMethod.getString().isEmpty() || !GetRef() ) return aStateMethod.getString();
     350        8209 :     return ((SvMetaSlot *)GetRef())->GetStateMethod();
     351             : }
     352           0 : const rtl::OString& SvMetaSlot::GetDefault() const
     353             : {
     354           0 :     if( !aDefault.getString().isEmpty() || !GetRef() ) return aDefault.getString();
     355           0 :     return ((SvMetaSlot *)GetRef())->GetDefault();
     356             : }
     357       26610 : sal_Bool SvMetaSlot::GetPseudoSlots() const
     358             : {
     359       26610 :     if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots;
     360        9269 :     return ((SvMetaSlot *)GetRef())->GetPseudoSlots();
     361             : }
     362       10789 : sal_Bool SvMetaSlot::GetCachable() const
     363             : {
     364             :     // Cachable and Volatile are exclusive
     365       10789 :     if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() )
     366        5509 :          return aCachable;
     367        5280 :     return ((SvMetaSlot *)GetRef())->GetCachable();
     368             : }
     369       10789 : sal_Bool SvMetaSlot::GetVolatile() const
     370             : {
     371             :     // Cachable and Volatile are exclusive
     372       10789 :     if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() )
     373        5509 :         return aVolatile;
     374        5280 :     return ((SvMetaSlot *)GetRef())->GetVolatile();
     375             : }
     376       10949 : sal_Bool SvMetaSlot::GetToggle() const
     377             : {
     378       10949 :     if( aToggle.IsSet() || !GetRef() ) return aToggle;
     379        5440 :     return ((SvMetaSlot *)GetRef())->GetToggle();
     380             : }
     381       10929 : sal_Bool SvMetaSlot::GetAutoUpdate() const
     382             : {
     383       10929 :     if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate;
     384        5420 :     return ((SvMetaSlot *)GetRef())->GetAutoUpdate();
     385             : }
     386       10928 : sal_Bool SvMetaSlot::GetSynchron() const
     387             : {
     388             :     // Synchron and Asynchron are exclusive
     389       10928 :     if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() )
     390        5509 :         return aSynchron;
     391        5419 :     return ((SvMetaSlot *)GetRef())->GetSynchron();
     392             : }
     393       10928 : sal_Bool SvMetaSlot::GetAsynchron() const
     394             : {
     395             :     // Synchron and Asynchron are exclusive
     396       10928 :     if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() )
     397        5509 :         return aAsynchron;
     398        5419 :     return ((SvMetaSlot *)GetRef())->GetAsynchron();
     399             : }
     400       10949 : sal_Bool SvMetaSlot::GetRecordPerItem() const
     401             : {
     402             :     // Record- PerItem, No, PerSet and Manual are exclusive
     403       21829 :     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
     404       10880 :       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
     405        5509 :         return aRecordPerItem;
     406        5440 :     return ((SvMetaSlot *)GetRef())->GetRecordPerItem();
     407             : }
     408       10949 : sal_Bool SvMetaSlot::GetRecordPerSet() const
     409             : {
     410             :     // Record- PerItem, No, PerSet and Manual are exclusive
     411       21829 :     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
     412       10880 :       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
     413        5509 :         return aRecordPerSet;
     414        5440 :     return ((SvMetaSlot *)GetRef())->GetRecordPerSet();
     415             : }
     416       10949 : sal_Bool SvMetaSlot::GetRecordManual() const
     417             : {
     418             :     // Record- PerItem, No, PerSet and Manual are exclusive
     419       21829 :     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
     420       10880 :       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
     421        5509 :         return aRecordManual;
     422        5440 :     return ((SvMetaSlot *)GetRef())->GetRecordManual();
     423             : }
     424       10949 : sal_Bool SvMetaSlot::GetNoRecord() const
     425             : {
     426             :     // Record- PerItem, No, PerSet and Manual are exclusive
     427       21829 :     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
     428       10880 :       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
     429        5509 :         return aNoRecord;
     430        5440 :     return ((SvMetaSlot *)GetRef())->GetNoRecord();
     431             : }
     432       10950 : sal_Bool SvMetaSlot::GetRecordAbsolute() const
     433             : {
     434       10950 :     if( !GetRef() || aRecordAbsolute.IsSet() )
     435        5509 :         return aRecordAbsolute;
     436        5441 :     return ((SvMetaSlot *)GetRef())->GetRecordAbsolute();
     437             : }
     438       10935 : sal_Bool SvMetaSlot::GetHasDialog() const
     439             : {
     440       10935 :     if( aHasDialog.IsSet() || !GetRef() ) return aHasDialog;
     441        5426 :     return ((SvMetaSlot *)GetRef())->GetHasDialog();
     442             : }
     443         272 : const rtl::OString& SvMetaSlot::GetPseudoPrefix() const
     444             : {
     445         272 :     if( !aPseudoPrefix.getString().isEmpty() || !GetRef() ) return aPseudoPrefix.getString();
     446         136 :     return ((SvMetaSlot *)GetRef())->GetPseudoPrefix();
     447             : }
     448       10907 : sal_Bool SvMetaSlot::GetMenuConfig() const
     449             : {
     450       10907 :     if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig;
     451        5398 :     return ((SvMetaSlot *)GetRef())->GetMenuConfig();
     452             : }
     453       10915 : sal_Bool SvMetaSlot::GetToolBoxConfig() const
     454             : {
     455       10915 :     if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig;
     456        5406 :     return ((SvMetaSlot *)GetRef())->GetToolBoxConfig();
     457             : }
     458       10949 : sal_Bool SvMetaSlot::GetStatusBarConfig() const
     459             : {
     460       10949 :     if( aStatusBarConfig.IsSet() || !GetRef() ) return aStatusBarConfig;
     461        5440 :     return ((SvMetaSlot *)GetRef())->GetStatusBarConfig();
     462             : }
     463       10919 : sal_Bool SvMetaSlot::GetAccelConfig() const
     464             : {
     465       10919 :     if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig;
     466        5410 :     return ((SvMetaSlot *)GetRef())->GetAccelConfig();
     467             : }
     468       10931 : sal_Bool SvMetaSlot::GetFastCall() const
     469             : {
     470       10931 :     if( aFastCall.IsSet() || !GetRef() ) return aFastCall;
     471        5422 :     return ((SvMetaSlot *)GetRef())->GetFastCall();
     472             : }
     473       10948 : sal_Bool SvMetaSlot::GetContainer() const
     474             : {
     475       10948 :     if( aContainer.IsSet() || !GetRef() ) return aContainer;
     476        5439 :     return ((SvMetaSlot *)GetRef())->GetContainer();
     477             : }
     478             : 
     479       10950 : sal_Bool SvMetaSlot::GetImageRotation() const
     480             : {
     481       10950 :     if( aImageRotation.IsSet() || !GetRef() ) return aImageRotation;
     482        5441 :     return ((SvMetaSlot *)GetRef())->GetImageRotation();
     483             : }
     484             : 
     485       10950 : sal_Bool SvMetaSlot::GetImageReflection() const
     486             : {
     487       10950 :     if( aImageReflection.IsSet() || !GetRef() ) return aImageReflection;
     488        5441 :     return ((SvMetaSlot *)GetRef())->GetImageReflection();
     489             : }
     490             : 
     491           0 : const rtl::OString& SvMetaSlot::GetUnoName() const
     492             : {
     493           0 :     if( aUnoName.IsSet() || !GetRef() ) return aUnoName.getString();
     494           0 :     return ((SvMetaSlot *)GetRef())->GetUnoName();
     495             : }
     496             : 
     497      160490 : void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     498             :                                     SvTokenStream & rInStm )
     499             : {
     500      160490 :     SvMetaAttribute::ReadAttributesSvIdl( rBase, rInStm );
     501             : 
     502      160490 :     sal_Bool bOk = sal_False;
     503      160490 :     bOk |= aDefault.ReadSvIdl( SvHash_Default(), rInStm );
     504      160490 :     bOk |= aPseudoSlots.ReadSvIdl( SvHash_PseudoSlots(), rInStm );
     505      160490 :     bOk |= aHasCoreId.ReadSvIdl( SvHash_HasCoreId(), rInStm );
     506      160490 :     bOk |= aGroupId.ReadSvIdl( SvHash_GroupId(), rInStm );
     507      160490 :     bOk |= aExecMethod.ReadSvIdl( SvHash_ExecMethod(), rInStm );
     508      160490 :     bOk |= aStateMethod.ReadSvIdl( SvHash_StateMethod(), rInStm );
     509      160490 :     bOk |= aDisableFlags.ReadSvIdl( SvHash_DisableFlags(), rInStm );
     510      160490 :     if( aGet.ReadSvIdl( SvHash_Get(), rInStm ) )
     511             :     {
     512           0 :         rBase.WriteError( "warning", rtl::OUStringToOString(rInStm.GetFileName(), RTL_TEXTENCODING_UTF8),
     513             :                     "<Get> old style, use Readonly",
     514             :                     rInStm.GetToken()->GetLine(),
     515           0 :                     rInStm.GetToken()->GetColumn() );
     516             :     }
     517      160490 :     if( aSet.ReadSvIdl( SvHash_Set(), rInStm ) )
     518             :     {
     519           0 :         rBase.WriteError( "warning", rtl::OUStringToOString(rInStm.GetFileName(), RTL_TEXTENCODING_UTF8),
     520             :                     "<Set> old style, use method declaration",
     521             :                     rInStm.GetToken()->GetLine(),
     522           0 :                     rInStm.GetToken()->GetColumn() );
     523             :     }
     524             : 
     525      160490 :     if( aCachable.ReadSvIdl( SvHash_Cachable(), rInStm ) )
     526       16137 :         SetCachable( aCachable ), bOk = sal_True;
     527      160490 :     if( aVolatile.ReadSvIdl( SvHash_Volatile(), rInStm ) )
     528           0 :         SetVolatile( aVolatile ), bOk = sal_True;
     529      160490 :     if( aToggle.ReadSvIdl( SvHash_Toggle(), rInStm ) )
     530        8012 :         SetToggle( aToggle ), bOk = sal_True;
     531      160490 :     if( aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm ) )
     532        8023 :         SetAutoUpdate( aAutoUpdate ), bOk = sal_True;
     533             : 
     534      160490 :     if( aSynchron.ReadSvIdl( SvHash_Synchron(), rInStm ) )
     535        6417 :         SetSynchron( aSynchron ), bOk = sal_True;
     536      160490 :     if( aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm ) )
     537        1607 :         SetAsynchron( aAsynchron ), bOk = sal_True;
     538             : 
     539      160490 :     if( aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm ) )
     540        7822 :         SetRecordAbsolute( aRecordAbsolute), bOk = sal_True;
     541      160490 :     if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) )
     542         562 :         SetRecordPerItem( aRecordPerItem ), bOk = sal_True;
     543      160490 :     if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) )
     544        7013 :         SetRecordPerSet( aRecordPerSet ), bOk = sal_True;
     545      160490 :     if( aRecordManual.ReadSvIdl( SvHash_RecordManual(), rInStm ) )
     546         181 :         SetRecordManual( aRecordManual ), bOk = sal_True;
     547      160490 :     if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) )
     548          67 :         SetNoRecord( aNoRecord ), bOk = sal_True;
     549             : 
     550      160490 :     bOk |= aHasDialog.ReadSvIdl( SvHash_HasDialog(), rInStm );
     551      160490 :     bOk |= aPseudoPrefix.ReadSvIdl( SvHash_PseudoPrefix(), rInStm );
     552      160490 :     bOk |= aMenuConfig.ReadSvIdl( SvHash_MenuConfig(), rInStm );
     553      160490 :     bOk |= aToolBoxConfig.ReadSvIdl( SvHash_ToolBoxConfig(), rInStm );
     554      160490 :     bOk |= aStatusBarConfig.ReadSvIdl( SvHash_StatusBarConfig(), rInStm );
     555      160490 :     bOk |= aAccelConfig.ReadSvIdl( SvHash_AccelConfig(), rInStm );
     556             : 
     557      160490 :     SvBOOL aAllConfig;
     558      160490 :     if( aAllConfig.ReadSvIdl( SvHash_AllConfig(), rInStm ) )
     559           0 :         SetAllConfig( aAllConfig ), bOk = sal_True;
     560      160490 :     bOk |= aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm );
     561      160490 :     bOk |= aContainer.ReadSvIdl( SvHash_Container(), rInStm );
     562      160490 :     bOk |= aImageRotation.ReadSvIdl( SvHash_ImageRotation(), rInStm );
     563      160490 :     bOk |= aImageReflection.ReadSvIdl( SvHash_ImageReflection(), rInStm );
     564      160490 :     bOk |= aUnoName.ReadSvIdl( SvHash_UnoName(), rInStm );
     565             : 
     566      160490 :     if( !bOk )
     567             :     {
     568       24533 :         if( !aSlotType.Is() )
     569             :         {
     570       23704 :             sal_uInt32 nTokPos = rInStm.Tell();
     571       23704 :             SvToken * pTok = rInStm.GetToken_Next();
     572       23704 :             if( pTok->Is( SvHash_SlotType() ) )
     573             :             {
     574         798 :                 sal_Bool bBraket = rInStm.Read( '(' );
     575         798 :                 if( bBraket || rInStm.Read( '=' ) )
     576             :                 {
     577         798 :                     aSlotType = rBase.ReadKnownType( rInStm );
     578         798 :                     if( aSlotType.Is() )
     579             :                     {
     580         798 :                         if( aSlotType->IsItem() )
     581             :                         {
     582         798 :                             if( bBraket )
     583             :                             {
     584           0 :                                 if( rInStm.Read( ')' ) )
     585             :                                     return;
     586             :                             }
     587             :                             else
     588             :                                 return;
     589             :                         }
     590           0 :                         rBase.SetError( "the SlotType is not a item", rInStm.GetToken() );
     591           0 :                         rBase.WriteError( rInStm );
     592             :                     }
     593           0 :                     rBase.SetError( "SlotType with unknown item type", rInStm.GetToken() );
     594           0 :                     rBase.WriteError( rInStm );
     595             :                 }
     596             :             }
     597       22906 :             rInStm.Seek( nTokPos );
     598             : 
     599             :         }
     600       23735 :         if( !aMethod.Is() )
     601             :         {
     602       23659 :             SvToken * pTok = rInStm.GetToken();
     603       23659 :             if( pTok->IsIdentifier() )
     604             :             {
     605          26 :                 aMethod = new SvMetaSlot();
     606          26 :                 sal_uInt32 nTokPos = rInStm.Tell();
     607          26 :                 if( aMethod->ReadSvIdl( rBase, rInStm ) )
     608             :                 {
     609          26 :                     if( aMethod->IsMethod() )
     610             :                     {
     611          26 :                         aMethod->SetSlotId( GetSlotId() );
     612          26 :                         if( aMethod->Test( rBase, rInStm ) )
     613             :                             return;
     614             :                     }
     615           0 :                     rInStm.Seek( nTokPos );
     616             :                 }
     617           0 :                 aMethod.Clear();
     618             :             }
     619             :         }
     620             :     }
     621             : }
     622             : 
     623       11858 : void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     624             :                        SvStream & rOutStm,
     625             :                        sal_uInt16 nTab )
     626             : {
     627       11858 :     SvMetaAttribute::WriteAttributesSvIdl( rBase, rOutStm, nTab );
     628             : 
     629       11858 :     if( aSlotType.Is() )
     630             :     {
     631         798 :         WriteTab( rOutStm, nTab );
     632         798 :         rOutStm << SvHash_SlotType()->GetName().getStr() << '(';
     633         798 :         aSlotType->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
     634         798 :         rOutStm << ");" << endl;
     635             :     }
     636       11858 :     if( aMethod.Is() )
     637             :     {
     638          26 :         WriteTab( rOutStm, nTab );
     639          26 :         aMethod->WriteSvIdl( rBase, rOutStm, nTab );
     640          26 :         rOutStm << ';' << endl;
     641             :     }
     642       11858 :     if( aHasCoreId )
     643             :     {
     644           8 :         aHasCoreId.WriteSvIdl( SvHash_HasCoreId(), rOutStm );
     645           8 :         rOutStm << ';' << endl;
     646             :     }
     647       11858 :     if( !aGroupId.getString().isEmpty() )
     648             :     {
     649        7789 :         WriteTab( rOutStm, nTab );
     650        7789 :         aGroupId.WriteSvIdl( SvHash_GroupId(), rOutStm, nTab +1);
     651        7789 :         rOutStm << ';' << endl;
     652             :     }
     653       11858 :     if( !aExecMethod.getString().isEmpty() )
     654             :     {
     655        3559 :         WriteTab( rOutStm, nTab );
     656        3559 :         aExecMethod.WriteSvIdl( SvHash_ExecMethod(), rOutStm, nTab +1);
     657        3559 :         rOutStm << ';' << endl;
     658             :     }
     659       11858 :     if( !aStateMethod.getString().isEmpty() )
     660             :     {
     661        3576 :         WriteTab( rOutStm, nTab );
     662        3576 :         aStateMethod.WriteSvIdl( SvHash_StateMethod(), rOutStm, nTab +1);
     663        3576 :         rOutStm << ';' << endl;
     664             :     }
     665             : 
     666       11858 :     if( !aDisableFlags.getString().isEmpty() )
     667             :     {
     668         602 :         WriteTab( rOutStm, nTab );
     669         602 :         aDisableFlags.WriteSvIdl( SvHash_DisableFlags(), rOutStm, nTab +1);
     670         602 :         rOutStm << ';' << endl;
     671             :     }
     672             : 
     673       11858 :     if( aSet || aGet || aPseudoSlots )
     674             :     {
     675          49 :         WriteTab( rOutStm, nTab );
     676          49 :         char const * p = "";
     677          49 :         if( aPseudoSlots )
     678             :         {
     679          49 :             aPseudoSlots.WriteSvIdl( SvHash_PseudoSlots(), rOutStm );
     680          49 :             p = ", ";
     681             :         }
     682          49 :         if( aGet )
     683             :         {
     684           0 :             rOutStm << p;
     685           0 :             aGet.WriteSvIdl( SvHash_Get(), rOutStm );
     686           0 :             p = ", ";
     687             :         }
     688          49 :         if( aSet )
     689             :         {
     690           0 :             rOutStm << p;
     691           0 :             aSet.WriteSvIdl( SvHash_Set(), rOutStm );
     692             :         }
     693          49 :         rOutStm << ';' << endl;
     694             :     }
     695             : 
     696       11858 :     rtl::OString aDel(", ");
     697       11858 :     rtl::OStringBuffer aOut;
     698       11858 :     if( aVolatile )
     699           0 :         aOut.append(aVolatile.GetSvIdlString( SvHash_Volatile() ));
     700       11858 :     else if( !aCachable )
     701             :         // because of Default == TRUE, only when no other is set
     702           0 :         aOut.append(aCachable.GetSvIdlString( SvHash_Cachable() ));
     703             :     else
     704       11858 :         aDel = rtl::OString();
     705             : 
     706       11858 :     if( aToggle )
     707             :     {
     708         530 :         aOut.append(aDel).append(aToggle.GetSvIdlString( SvHash_Toggle() ));
     709         530 :         aDel = ", ";
     710             :     }
     711       11858 :     if( aAutoUpdate )
     712             :     {
     713        2812 :         aOut.append(aDel).append(aAutoUpdate.GetSvIdlString( SvHash_AutoUpdate() ));
     714        2812 :         aDel = ", ";
     715             :     }
     716             : 
     717       11858 :     rtl::OString aDel1(", ");
     718       11858 :     if( aAsynchron )
     719        1607 :         aOut.append(aDel).append(aAsynchron.GetSvIdlString( SvHash_Asynchron() ));
     720       10251 :     else if( !aSynchron )
     721             :     {
     722             :         // because of Default == TRUE, only when no other is set
     723           0 :         aOut.append(aDel).append(aSynchron.GetSvIdlString( SvHash_Synchron() ));
     724             :     }
     725             :     else
     726       10251 :         aDel1 = aDel;
     727             : 
     728       11858 :     aDel = ", ";
     729       11858 :     if( aRecordManual )
     730         181 :         aOut.append(aDel1).append(aRecordManual.GetSvIdlString( SvHash_RecordManual() ));
     731       11677 :     else if( aNoRecord )
     732          67 :         aOut.append(aDel1).append(aNoRecord.GetSvIdlString( SvHash_NoRecord() ));
     733       11610 :     else if( !aRecordPerSet )
     734             :         // because of Default == TRUE, only when no other is set
     735         562 :         aOut.append(aDel1).append(aRecordPerSet.GetSvIdlString( SvHash_RecordPerSet() ));
     736       11048 :     else if( aRecordPerItem )
     737           0 :         aOut.append(aDel1).append(aRecordPerItem.GetSvIdlString( SvHash_RecordPerItem() ));
     738             :     else
     739       11048 :         aDel = aDel1;
     740             : 
     741       11858 :     if( aRecordAbsolute )
     742             :     {
     743           9 :         aOut.append(aDel).append(aRecordAbsolute.GetSvIdlString( SvHash_RecordAbsolute() ));
     744           9 :         aDel = ", ";
     745             :     }
     746       11858 :     if( aHasDialog )
     747             :     {
     748        1184 :         aOut.append(aDel).append(aHasDialog.GetSvIdlString( SvHash_HasDialog() ));
     749        1184 :         aDel = ", ";
     750             :     }
     751       11858 :     if( aMenuConfig )
     752             :     {
     753        4446 :         aOut.append(aDel).append(aMenuConfig.GetSvIdlString( SvHash_MenuConfig() ));
     754        4446 :         aDel = ", ";
     755             :     }
     756       11858 :     if( aToolBoxConfig )
     757             :     {
     758        4835 :         aOut.append(aDel).append(aToolBoxConfig.GetSvIdlString( SvHash_ToolBoxConfig() ));
     759        4835 :         aDel = ", ";
     760             :     }
     761       11858 :     if( aStatusBarConfig )
     762             :     {
     763         110 :         aOut.append(aDel).append(aStatusBarConfig.GetSvIdlString( SvHash_StatusBarConfig() ));
     764         110 :         aDel = ", ";
     765             :     }
     766       11858 :     if( aAccelConfig )
     767             :     {
     768        4619 :         aOut.append(aDel).append(aAccelConfig.GetSvIdlString( SvHash_AccelConfig() ));
     769        4619 :         aDel = ", ";
     770             :     }
     771       11858 :     if( aFastCall )
     772             :     {
     773        1119 :         aOut.append(aDel).append(aFastCall.GetSvIdlString( SvHash_FastCall() ));
     774        1119 :         aDel = ", ";
     775             :     }
     776       11858 :     if( aContainer )
     777             :     {
     778        1145 :         aOut.append(aDel).append(aContainer.GetSvIdlString( SvHash_Container() ));
     779        1145 :         aDel = ", ";
     780             :     }
     781       11858 :     if( aImageRotation )
     782             :     {
     783         116 :         aOut.append(aDel).append(aImageRotation.GetSvIdlString( SvHash_ImageRotation() ));
     784         116 :         aDel = ", ";
     785             :     }
     786             : 
     787       11858 :     if( aImageReflection )
     788             :     {
     789          81 :         aOut.append(aDel).append(aImageReflection.GetSvIdlString( SvHash_ImageReflection() ));
     790          81 :         aDel = ", ";
     791             :     }
     792             : 
     793       11858 :     if( aOut.getLength() )
     794             :     {
     795        6873 :         WriteTab( rOutStm, nTab );
     796        6873 :         rOutStm << aOut.getStr() << endl;
     797       11858 :     }
     798       11858 : }
     799             : 
     800             : 
     801       11858 : sal_Bool SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     802             : {
     803       11858 :     sal_Bool bOk = SvMetaAttribute::Test( rBase, rInStm );
     804       11858 :     if( bOk )
     805             :     {
     806       11858 :         SvMetaType * pType = GetType();
     807       11858 :         if( pType->GetType() == TYPE_METHOD )
     808        6645 :             pType = pType->GetReturnType();
     809       11858 :         if( !pType->IsItem() )
     810             :         {
     811           0 :             rBase.SetError( "this attribute is not a slot", rInStm.GetToken() );
     812           0 :             rBase.WriteError( rInStm );
     813           0 :             bOk = sal_False;
     814             :         }
     815             :     }
     816             : 
     817       11858 :     return bOk;
     818             : }
     819             : 
     820       12193 : sal_Bool SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     821             : {
     822       12193 :     sal_uInt32  nTokPos     = rInStm.Tell();
     823       12193 :     sal_Bool bOk = sal_True;
     824             : 
     825       12193 :     SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
     826       12193 :     if( pAttr )
     827             :     {
     828             :         // c
     829        3795 :         SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
     830        3795 :         if( pKnownSlot )
     831             :         {
     832        3795 :             SetRef( pKnownSlot );
     833        3795 :             SetName( pKnownSlot->GetName().getString(), &rBase );
     834        3795 :             bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
     835             :         }
     836             :         else
     837             :         {
     838           0 :             rtl::OStringBuffer aStr( "attribute " );
     839           0 :             aStr.append(pAttr->GetName().getString());
     840           0 :             aStr.append(" is method or variable but not a slot");
     841           0 :             rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
     842           0 :             rBase.WriteError( rInStm );
     843           0 :             bOk = sal_False;
     844             :         }
     845             :     }
     846             :     else
     847             :     {
     848        8398 :         bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm );
     849             : 
     850        8398 :         SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() );
     851        8398 :         if( pAttr2 )
     852             :         {
     853             :             // for testing purposes: reference in case of complete definition
     854          41 :             SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 );
     855          41 :             if( pKnownSlot )
     856             :             {
     857          41 :                 SetRef( pKnownSlot );
     858             : 
     859             :                   // names may differ, because explicitly given
     860          41 :                 if ( pKnownSlot->GetName().getString() != GetName().getString() )
     861             :                 {
     862             :                     OSL_FAIL("Illegal definition!");
     863           0 :                     rInStm.Seek( nTokPos );
     864           0 :                     return sal_False;
     865             :                 }
     866             : 
     867          41 :                   SetName( pKnownSlot->GetName().getString(), &rBase );
     868             :             }
     869             :             else
     870             :             {
     871           0 :                 rtl::OStringBuffer aStr("attribute ");
     872           0 :                 aStr.append(pAttr2->GetName().getString());
     873           0 :                 aStr.append(" is method or variable but not a slot");
     874           0 :                 rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
     875           0 :                 rBase.WriteError( rInStm );
     876           0 :                 bOk = sal_False;
     877             :             }
     878             :         }
     879             :     }
     880             : 
     881       12193 :     if( !bOk )
     882         335 :         rInStm.Seek( nTokPos );
     883             : 
     884       12193 :     return bOk;
     885             : }
     886             : 
     887       11858 : void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     888             :                             sal_uInt16 nTab )
     889             : {
     890       11858 :     SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab );
     891       11858 : }
     892             : 
     893           0 : void SvMetaSlot::Write( SvIdlDataBase & rBase,
     894             :                         SvStream & rOutStm, sal_uInt16 nTab,
     895             :                         WriteType nT, WriteAttribute nA )
     896             : {
     897           0 :     if ( nT == WRITE_DOCU )
     898             :     {
     899           0 :         if ( GetHidden() )
     900           0 :             return;
     901             :     }
     902             :     else
     903             :     {
     904             :         // no attribute for Automation
     905           0 :         if( !GetAutomation() || !GetExport() )
     906           0 :             return;
     907             :     }
     908             : 
     909           0 :     if( !(nA & WA_VARIABLE) )
     910             :     {
     911           0 :         SvMetaAttributeRef xM = GetMethod();
     912           0 :         if( xM.Is() )
     913             :         {
     914           0 :             xM->SetSlotId( GetSlotId() );
     915           0 :             xM->SetDescription( GetDescription().getString() );
     916           0 :             xM->Write( rBase, rOutStm, nTab, nT, nA );
     917             :             return;
     918           0 :         }
     919             :     }
     920             : 
     921           0 :     SvMetaAttribute::Write( rBase, rOutStm, nTab, nT, nA );
     922             : }
     923             : 
     924             : 
     925        5509 : void SvMetaSlot::Insert( SvSlotElementList& rList, const rtl::OString& rPrefix,
     926             :                         SvIdlDataBase& rBase)
     927             : {
     928             :     // get insert position through binary search in slotlist
     929        5509 :     sal_uInt16 nId = (sal_uInt16) GetSlotId().GetValue();
     930        5509 :     sal_uInt16 nListCount = (sal_uInt16) rList.size();
     931             :     sal_uInt16 nPos;
     932             :     sal_uLong m;  // for inner "for" loop
     933             : 
     934        5509 :     if ( !nListCount )
     935          78 :         nPos = 0;
     936        5431 :     else if ( nListCount == 1 )
     937          71 :         nPos = rList[ 0 ]->xSlot->GetSlotId().GetValue() >= nId ? 0 : 1;
     938             :     else
     939             :     {
     940        5360 :         sal_uInt16 nMid = 0, nLow = 0;
     941        5360 :         sal_uInt16 nHigh = nListCount - 1;
     942        5360 :         sal_Bool bFound = sal_False;
     943       43654 :         while ( !bFound && nLow <= nHigh )
     944             :         {
     945       33105 :             nMid = (nLow + nHigh) >> 1;
     946             :             DBG_ASSERT( nMid < nListCount, "bsearch ist buggy" );
     947       33105 :             int nDiff = (int) nId - (int) rList[ nMid ]->xSlot->GetSlotId().GetValue();
     948       33105 :             if ( nDiff < 0)
     949             :             {
     950       14768 :                 if ( nMid == 0 )
     951         171 :                     break;
     952       14597 :                 nHigh = nMid - 1;
     953             :             }
     954       18337 :             else if ( nDiff > 0 )
     955             :             {
     956       18337 :                 nLow = nMid + 1;
     957       18337 :                 if ( nLow == 0 )
     958           0 :                 break;
     959             :             }
     960             :             else
     961           0 :                 bFound = sal_True;
     962             :         }
     963             : 
     964             :         DBG_ASSERT(!bFound, "Duplicate SlotId!");
     965        5360 :         nPos = bFound ? nMid : nLow;
     966             :     }
     967             : 
     968             :     DBG_ASSERT( nPos <= nListCount,
     969             :         "nPos too large" );
     970             :     DBG_ASSERT( nPos == nListCount || nId <=
     971             :         (sal_uInt16) rList[ nPos ]->xSlot->GetSlotId().GetValue(),
     972             :         "Successor has lower SlotId" );
     973             :     DBG_ASSERT( nPos == 0 || nId >
     974             :         (sal_uInt16) rList[ nPos-1 ]->xSlot->GetSlotId().GetValue(),
     975             :         "Predecessor has higher SlotId" );
     976             :     DBG_ASSERT( nPos+1 >= nListCount || nId <
     977             :         (sal_uInt16) rList[ nPos+1 ]->xSlot->GetSlotId().GetValue(),
     978             :         "Successor has lower SlotId" );
     979             : 
     980        5509 :     if ( nPos < rList.size() )
     981             :     {
     982        5053 :         SvSlotElementList::iterator it = rList.begin();
     983        5053 :         std::advance( it, nPos );
     984        5053 :         rList.insert( it, new SvSlotElement( this, rPrefix ) );
     985             :     }
     986             :     else
     987             :     {
     988         456 :         rList.push_back( new SvSlotElement( this, rPrefix ) );
     989             :     }
     990             : 
     991             :     // iron out EnumSlots
     992        5509 :     SvMetaTypeEnum * pEnum = NULL;
     993        5509 :     SvMetaType * pBType = GetType()->GetBaseType();
     994        5509 :     pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
     995        5509 :     if( GetPseudoSlots() && pEnum && pEnum->Count() )
     996             :     {
     997             :         // clone the MasterSlot
     998           5 :         SvMetaSlotRef xEnumSlot;
     999           5 :         SvMetaSlot *pFirstEnumSlot = NULL;
    1000          73 :         for( sal_uLong n = 0; n < pEnum->Count(); n++ )
    1001             :         {
    1002             :             // create SlotId
    1003          68 :             SvMetaEnumValue *enumValue = pEnum->GetObject(n);
    1004          68 :             rtl::OString aValName = enumValue->GetName().getString();
    1005          68 :             rtl::OStringBuffer aBuf;
    1006          68 :             if( !GetPseudoPrefix().isEmpty() )
    1007          68 :                 aBuf.append(GetPseudoPrefix());
    1008             :             else
    1009           0 :                 aBuf.append(GetSlotId().getString());
    1010          68 :             aBuf.append('_');
    1011          68 :             aBuf.append(aValName.copy(pEnum->GetPrefix().getLength()));
    1012             : 
    1013          68 :             rtl::OString aSId = aBuf.makeStringAndClear();
    1014             : 
    1015          68 :             xEnumSlot = NULL;
    1016       36031 :             for( m=0; m<rBase.GetAttrList().size(); m++ )
    1017             :             {
    1018       36031 :                 SvMetaAttribute * pAttr = rBase.GetAttrList()[m];
    1019       36031 :                 if (aSId.equals(pAttr->GetSlotId().getString()))
    1020             :                 {
    1021          68 :                     SvMetaSlot* pSlot = PTR_CAST( SvMetaSlot, pAttr );
    1022          68 :                     xEnumSlot = pSlot->Clone();
    1023          68 :                     break;
    1024             :                 }
    1025             :             }
    1026             : 
    1027          68 :             if ( m == rBase.GetAttrList().size() )
    1028             :             {
    1029             :                 OSL_FAIL("Invalid EnumSlot!");
    1030           0 :                 xEnumSlot = Clone();
    1031             :                 sal_uLong nValue;
    1032           0 :                 if ( rBase.FindId(aSId , &nValue) )
    1033             :                 {
    1034           0 :                     SvNumberIdentifier aId;
    1035           0 :                     aId.setString(aSId);
    1036           0 :                     aId.SetValue(nValue);
    1037           0 :                     xEnumSlot->SetSlotId(aId);
    1038             :                 }
    1039             :             }
    1040             : 
    1041             :             // The slaves are no master!
    1042          68 :             xEnumSlot->aPseudoSlots = sal_False;
    1043          68 :             xEnumSlot->SetEnumValue(enumValue);
    1044             : 
    1045          68 :             if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < pFirstEnumSlot->GetSlotId().GetValue() )
    1046           7 :                 pFirstEnumSlot = xEnumSlot;
    1047             : 
    1048             :             // insert the created slave as well
    1049          68 :             xEnumSlot->Insert( rList, rPrefix, rBase);
    1050             : 
    1051             :             // concatenate the EnumSlots with the master
    1052          68 :             xEnumSlot->pLinkedSlot = this;
    1053          68 :         }
    1054             : 
    1055             :         // master points to the first slave
    1056           5 :         pLinkedSlot = pFirstEnumSlot;
    1057             : 
    1058             :         // concatenate slaves among themselves
    1059           5 :         xEnumSlot = pFirstEnumSlot;
    1060           5 :         size_t i = 0;
    1061             :         SvSlotElement *pEle;
    1062         205 :         do
    1063             :         {
    1064         205 :             pEle = ( ++i < rList.size() ) ? rList[ i ] : NULL;
    1065         205 :             if ( pEle && pEle->xSlot->pLinkedSlot == this )
    1066             :             {
    1067          67 :                 xEnumSlot->pNextSlot = pEle->xSlot;
    1068          67 :                 xEnumSlot = pEle->xSlot;
    1069             :             }
    1070             :         }
    1071             :         while ( pEle );
    1072           5 :         xEnumSlot->pNextSlot = pFirstEnumSlot;
    1073             :     }
    1074        5509 : }
    1075             : 
    1076             : 
    1077       33263 : static rtl::OString MakeSlotName( SvStringHashEntry * pEntry )
    1078             : {
    1079       33263 :     rtl::OStringBuffer aName(RTL_CONSTASCII_STRINGPARAM("SFX_SLOT_"));
    1080       33263 :     aName.append(pEntry->GetName());
    1081       33263 :     return aName.makeStringAndClear().toAsciiUpperCase();
    1082             : };
    1083             : 
    1084        5509 : void SvMetaSlot::WriteSlotStubs( const rtl::OString& rShellName,
    1085             :                                 ByteStringList & rList,
    1086             :                                 SvStream & rOutStm )
    1087             : {
    1088        5509 :     if ( !GetExport() && !GetHidden() )
    1089        5509 :         return;
    1090             : 
    1091        5509 :     rtl::OString aMethodName( GetExecMethod() );
    1092       10646 :     if ( !aMethodName.isEmpty() &&
    1093        5137 :          !aMethodName.equalsL(RTL_CONSTASCII_STRINGPARAM("NoExec")) )
    1094             :     {
    1095        5130 :         sal_Bool bIn = sal_False;
    1096       29998 :         for( size_t n = 0; n < rList.size(); n++ )
    1097             :         {
    1098       29670 :             if (rList[n]->equals(aMethodName))
    1099             :             {
    1100        4802 :                 bIn=sal_True;
    1101        4802 :                 break;
    1102             :             }
    1103             :         }
    1104             : 
    1105        5130 :         if ( !bIn )
    1106             :         {
    1107         328 :             rList.push_back( new rtl::OString(aMethodName) );
    1108         328 :             rOutStm << "SFX_EXEC_STUB("
    1109         656 :                     << rShellName.getStr()
    1110         328 :                     << ','
    1111         656 :                     << aMethodName.getStr()
    1112         328 :                     << ')' << endl;
    1113             :         }
    1114             :     }
    1115             : 
    1116        5509 :     aMethodName = GetStateMethod();
    1117       10622 :     if (!aMethodName.isEmpty() &&
    1118        5113 :         !aMethodName.equalsL(RTL_CONSTASCII_STRINGPARAM("NoState")))
    1119             :     {
    1120        4776 :         sal_Bool bIn = sal_False;
    1121       25804 :         for ( size_t n=0; n < rList.size(); n++ )
    1122             :         {
    1123       25527 :             if (rList[n]->equals(aMethodName))
    1124             :             {
    1125        4499 :                 bIn=sal_True;
    1126        4499 :                 break;
    1127             :             }
    1128             :         }
    1129             : 
    1130        4776 :         if ( !bIn )
    1131             :         {
    1132         277 :             rList.push_back( new rtl::OString(aMethodName) );
    1133         277 :             rOutStm << "SFX_STATE_STUB("
    1134         554 :                     << rShellName.getStr()
    1135         277 :                     << ','
    1136         554 :                     << aMethodName.getStr()
    1137         277 :                     << ')' << endl;
    1138             :         }
    1139        5509 :     }
    1140             : }
    1141             : 
    1142        5509 : void SvMetaSlot::WriteSlot( const rtl::OString& rShellName, sal_uInt16 nCount,
    1143             :                             const rtl::OString& rSlotId,
    1144             :                             SvSlotElementList& rSlotList,
    1145             :                             size_t nStart,
    1146             :                             const rtl::OString& rPrefix,
    1147             :                             SvIdlDataBase & rBase, SvStream & rOutStm )
    1148             : {
    1149        5509 :     if ( !GetExport() && !GetHidden() )
    1150        5509 :         return;
    1151             : 
    1152        5509 :     sal_Bool bIsEnumSlot = 0 != pEnumValue;
    1153             : 
    1154        5509 :     rOutStm << "// Slot Nr. "
    1155       16527 :         << rtl::OString::valueOf(static_cast<sal_Int32>(nListPos)).getStr()
    1156        5509 :         << " : ";
    1157             :     rtl::OString aSlotIdValue(rtl::OString::valueOf(static_cast<sal_Int32>(
    1158        5509 :         GetSlotId().GetValue())));
    1159        5509 :     rOutStm << aSlotIdValue.getStr() << endl;
    1160        5509 :     WriteTab( rOutStm, 1 );
    1161        5509 :     if( bIsEnumSlot )
    1162          68 :         rOutStm << "SFX_NEW_SLOT_ENUM( ";
    1163             :     else
    1164        5441 :         rOutStm << "SFX_NEW_SLOT_ARG( " << rShellName.getStr() << ',' ;
    1165             : 
    1166        5509 :     rOutStm << rSlotId.getStr() << ',';
    1167        5509 :     const SvHelpContext& rHlpCtx = GetHelpContext();
    1168        5509 :     if( rHlpCtx.IsSet() )
    1169           0 :         rOutStm << rHlpCtx.getString().getStr() << ',';
    1170             :     else
    1171        5509 :         rOutStm << rSlotId.getStr() << ',';
    1172             : 
    1173             :     // GroupId
    1174        5509 :     if( !GetGroupId().isEmpty() )
    1175        5428 :         rOutStm << GetGroupId().getStr();
    1176             :     else
    1177          81 :         rOutStm << '0';
    1178        5509 :     rOutStm << ',' << endl;
    1179        5509 :     WriteTab( rOutStm, 4 );
    1180             : 
    1181        5509 :     if( bIsEnumSlot )
    1182             :     {
    1183          68 :         rOutStm << "&a" << rShellName.getStr() << "Slots_Impl["
    1184         204 :             << rtl::OString::valueOf(static_cast<sal_Int32>(pLinkedSlot->GetListPos())).getStr()
    1185          68 :             << "] /*Offset Master*/, " << endl;
    1186          68 :         WriteTab( rOutStm, 4 );
    1187          68 :         rOutStm << "&a" << rShellName.getStr() << "Slots_Impl["
    1188         204 :             << rtl::OString::valueOf(static_cast<sal_Int32>(pNextSlot->GetListPos())).getStr()
    1189          68 :             << "] /*Offset Next*/, " << endl;
    1190             : 
    1191          68 :         WriteTab( rOutStm, 4 );
    1192             : 
    1193             :         // SlotId
    1194          68 :         if( !GetSlotId().getString().isEmpty() )
    1195          68 :             rOutStm << pLinkedSlot->GetSlotId().getString().getStr();
    1196             :         else
    1197           0 :             rOutStm << '0';
    1198          68 :         rOutStm << ',';
    1199          68 :         rOutStm << pEnumValue->GetName().getString().getStr();
    1200             :     }
    1201             :     else
    1202             :     {
    1203             :         // look for the next slot with the same StateMethod like me
    1204             :         // the slotlist is set to the current slot
    1205        5441 :         size_t i = nStart;
    1206        5441 :         SvSlotElement* pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
    1207        5441 :         pNextSlot = pEle ? &pEle->xSlot : NULL;
    1208       48238 :         while ( pNextSlot )
    1209             :         {
    1210       84615 :             if ( !pNextSlot->pNextSlot &&
    1211       42159 :                 pNextSlot->GetStateMethod() == GetStateMethod()
    1212             :             ) {
    1213        5100 :                 break;
    1214             :             }
    1215       37356 :             pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
    1216       37356 :             pNextSlot = pEle ? &pEle->xSlot : NULL;
    1217             :         }
    1218             : 
    1219        5441 :         if ( !pNextSlot )
    1220             :         {
    1221             :             // There is no slot behind me that has the same ExecMethod.
    1222             :             // So I search for the first slot with it (could be myself).
    1223         341 :             i = 0;
    1224         341 :             pEle = rSlotList.empty() ? NULL : rSlotList[ i ];
    1225         341 :             pNextSlot = pEle ? &pEle->xSlot : NULL;
    1226       16467 :             while ( pNextSlot != this )
    1227             :             {
    1228       32011 :                 if ( !pNextSlot->pEnumValue &&
    1229       15942 :                     pNextSlot->GetStateMethod() == GetStateMethod() )
    1230         284 :                     break;
    1231       15785 :                 pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
    1232       15785 :                 pNextSlot = pEle ? &pEle->xSlot : NULL;
    1233             :             }
    1234             :         }
    1235             : 
    1236        5441 :         if ( !pLinkedSlot )
    1237             :         {
    1238        5436 :             rOutStm << "0 ,";
    1239             :         }
    1240             :         else
    1241             :         {
    1242           5 :             rOutStm << "&a" << rShellName.getStr() << "Slots_Impl["
    1243          15 :                 << rtl::OString::valueOf(static_cast<sal_Int32>(pLinkedSlot->GetListPos())).getStr()
    1244           5 :                 << "] /*Offset Linked*/, " << endl;
    1245           5 :             WriteTab( rOutStm, 4 );
    1246             :         }
    1247             : 
    1248        5441 :         rOutStm << "&a" << rShellName.getStr() << "Slots_Impl["
    1249       16323 :             << rtl::OString::valueOf(static_cast<sal_Int32>(pNextSlot->GetListPos())).getStr()
    1250        5441 :             << "] /*Offset Next*/, " << endl;
    1251             : 
    1252        5441 :         WriteTab( rOutStm, 4 );
    1253             : 
    1254             :         // write ExecMethod, with standard name if not specified
    1255       10578 :         if( !GetExecMethod().isEmpty() &&
    1256        5137 :             !GetExecMethod().equalsL(RTL_CONSTASCII_STRINGPARAM("NoExec")))
    1257             :         {
    1258        5130 :             rOutStm << "SFX_STUB_PTR(" << rShellName.getStr() << ','
    1259       10260 :                     << GetExecMethod().getStr() << ')';
    1260             :         }
    1261             :         else
    1262         311 :             rOutStm << "SFX_STUB_PTR_EXEC_NONE";
    1263        5441 :         rOutStm << ',';
    1264             : 
    1265             :         // write StateMethod, with standard name if not specified
    1266       10554 :         if( !GetStateMethod().isEmpty() &&
    1267        5113 :             !GetStateMethod().equalsL(RTL_CONSTASCII_STRINGPARAM("NoState")))
    1268             :         {
    1269        4776 :             rOutStm << "SFX_STUB_PTR(" << rShellName.getStr() << ','
    1270        9552 :                     << GetStateMethod().getStr() << ')';
    1271             :         }
    1272             :         else
    1273         665 :             rOutStm << "SFX_STUB_PTR_STATE_NONE";
    1274             :     }
    1275        5509 :     rOutStm << ',' << endl;
    1276        5509 :     WriteTab( rOutStm, 4 );
    1277             : 
    1278             :     // write flags
    1279        5509 :     if( GetHasCoreId() )
    1280           0 :         rOutStm << MakeSlotName( SvHash_HasCoreId() ).getStr() << '|';
    1281        5509 :     if( GetCachable() )
    1282        5509 :         rOutStm << MakeSlotName( SvHash_Cachable() ).getStr() << '|';
    1283        5509 :     if( GetVolatile() )
    1284           0 :         rOutStm << MakeSlotName( SvHash_Volatile() ).getStr() << '|';
    1285        5509 :     if( GetToggle() )
    1286         274 :         rOutStm << MakeSlotName( SvHash_Toggle() ).getStr() << '|';
    1287        5509 :     if( GetAutoUpdate() )
    1288        1503 :         rOutStm << MakeSlotName( SvHash_AutoUpdate() ).getStr() << '|';
    1289        5509 :     if( GetSynchron() )
    1290        4570 :         rOutStm << MakeSlotName( SvHash_Synchron() ).getStr() << '|';
    1291        5509 :     if( GetAsynchron() )
    1292         939 :         rOutStm << MakeSlotName( SvHash_Asynchron() ).getStr() << '|';
    1293        5509 :     if( GetRecordPerItem() )
    1294         328 :         rOutStm << MakeSlotName( SvHash_RecordPerItem() ).getStr() << '|';
    1295        5509 :     if( GetRecordPerSet() )
    1296        5030 :         rOutStm << MakeSlotName( SvHash_RecordPerSet() ).getStr() << '|';
    1297        5509 :     if( GetRecordManual() )
    1298         136 :         rOutStm << MakeSlotName( SvHash_RecordManual() ).getStr() << '|';
    1299        5509 :     if( GetNoRecord() )
    1300          15 :         rOutStm << MakeSlotName( SvHash_NoRecord() ).getStr() << '|';
    1301        5509 :     if( GetRecordAbsolute() )
    1302           4 :         rOutStm << MakeSlotName( SvHash_RecordAbsolute() ).getStr() << '|';
    1303        5509 :     if( GetHasDialog() )
    1304         847 :         rOutStm << MakeSlotName( SvHash_HasDialog() ).getStr() << '|';
    1305        5509 :     if( GetMenuConfig() )
    1306        3452 :         rOutStm << MakeSlotName( SvHash_MenuConfig() ).getStr() << '|';
    1307        5509 :     if( GetToolBoxConfig() )
    1308        3694 :         rOutStm << MakeSlotName( SvHash_ToolBoxConfig() ).getStr() << '|';
    1309        5509 :     if( GetStatusBarConfig() )
    1310          94 :         rOutStm << MakeSlotName( SvHash_StatusBarConfig() ).getStr() << '|';
    1311        5509 :     if( GetAccelConfig() )
    1312        3545 :         rOutStm << MakeSlotName( SvHash_AccelConfig() ).getStr() << '|';
    1313        5509 :     if( GetFastCall() )
    1314        1012 :         rOutStm << MakeSlotName( SvHash_FastCall() ).getStr() << '|';
    1315        5509 :     if( GetContainer() )
    1316         209 :         rOutStm << MakeSlotName( SvHash_Container() ).getStr() << '|';
    1317        5509 :     if ( GetReadOnlyDoc() )
    1318        1901 :         rOutStm << MakeSlotName( SvHash_ReadOnlyDoc() ).getStr() << '|';
    1319        5509 :     if( GetImageRotation() )
    1320         120 :         rOutStm << MakeSlotName( SvHash_ImageRotation() ).getStr() << '|';
    1321        5509 :     if( GetImageReflection() )
    1322          81 :         rOutStm << MakeSlotName( SvHash_ImageReflection() ).getStr() << '|';
    1323        5509 :     rOutStm << '0';
    1324             : 
    1325        5509 :     rOutStm << ',' << endl;
    1326        5509 :        WriteTab( rOutStm, 4 );
    1327        5509 :     if ( GetDisableFlags().isEmpty() )
    1328        4573 :         rOutStm << "0";
    1329             :     else
    1330         936 :         rOutStm << GetDisableFlags().getStr();
    1331             : 
    1332             :     // write attribute type
    1333        5509 :     if( !bIsEnumSlot )
    1334             :     {
    1335        5441 :         rOutStm << ',' << endl;
    1336        5441 :         WriteTab( rOutStm, 4 );
    1337             : 
    1338        5441 :         SvMetaType * pT = GetSlotType();
    1339        5441 :         if( !pT )
    1340             :         {
    1341        4976 :             if( !IsVariable() )
    1342        2782 :                 pT = rBase.FindType( "SfxVoidItem" );
    1343             :             else
    1344        2194 :                 pT = GetType();
    1345             :         }
    1346        5441 :         if( pT )
    1347             :         {
    1348        5441 :             rOutStm << pT->GetName().getString().getStr();
    1349        5441 :             if( !rBase.FindType( pT, rBase.aUsedTypes ) )
    1350         293 :                 rBase.aUsedTypes.push_back( pT );
    1351             :         }
    1352             :         else
    1353           0 :             rOutStm << "SfxVoidItem not defined";
    1354             :     }
    1355             :     else
    1356             :     {
    1357          68 :         SvMetaType *pT = rBase.FindType( "SfxBoolItem" );
    1358          68 :         if ( pT && !rBase.FindType( pT, rBase.aUsedTypes ) )
    1359           0 :             rBase.aUsedTypes.push_back( pT );
    1360             :     }
    1361             : 
    1362        5509 :     if( !bIsEnumSlot )
    1363             :     {
    1364        5441 :         rOutStm << ',' << endl;
    1365        5441 :         WriteTab( rOutStm, 4 );
    1366             :         rOutStm
    1367       10882 :             << rtl::OString::valueOf(static_cast<sal_Int32>(nCount)).getStr()
    1368        5441 :             << "/*Offset*/, ";
    1369             : 
    1370        5441 :         if( IsMethod() )
    1371             :         {
    1372        3267 :             SvMetaAttribute * pMethod = GetMethod();
    1373             :             SvMetaType * pType;
    1374        3267 :             if( pMethod )
    1375          22 :                 pType = pMethod->GetType();
    1376             :             else
    1377        3245 :                 pType = GetType();
    1378        3267 :             sal_uLong nSCount = pType->GetAttrCount();
    1379             :             rOutStm
    1380             :                 << rtl::OString::valueOf(static_cast<sal_Int32>(
    1381        6534 :                     nSCount)).getStr()
    1382        3267 :                 << "/*Count*/";
    1383             :         }
    1384             :         else
    1385        2174 :             rOutStm << '0';
    1386             : 
    1387             :         // name for recording
    1388        5441 :         if ( GetExport() )
    1389             :         {
    1390        4919 :             rOutStm << ",\"";
    1391        4919 :             if (!rPrefix.isEmpty())
    1392          66 :                 rOutStm << rPrefix.getStr();
    1393        4919 :             rOutStm << '.';
    1394        6895 :             if ( !IsVariable() || !GetType() ||
    1395        1976 :                  GetType()->GetBaseType()->GetType() != TYPE_STRUCT )
    1396        4668 :                 rOutStm << GetMangleName( sal_False ).getStr();
    1397        4919 :             rOutStm << "\",";
    1398             :         }
    1399             :         else
    1400         522 :             rOutStm << ", 0, ";
    1401             : 
    1402             :         // Method/Property flags
    1403        5441 :         if( IsMethod() )
    1404        3267 :             rOutStm << "SFX_SLOT_METHOD|";
    1405        5441 :         if( IsVariable() )
    1406             :         {
    1407        2196 :             rOutStm << "SFX_SLOT_PROPGET|";
    1408        2196 :             if( !GetReadonly() )
    1409        2057 :                 rOutStm << "SFX_SLOT_PROPSET|";
    1410             :         }
    1411             : 
    1412        5441 :         rOutStm << '0';
    1413             :     }
    1414             : 
    1415             :     {
    1416        5509 :         rOutStm << ",\"";
    1417        5509 :         rOutStm << GetMangleName( sal_False ).getStr();
    1418        5509 :         rOutStm << "\"";
    1419             :     }
    1420             : 
    1421        5509 :     rOutStm << " )," << endl;
    1422             : }
    1423             : 
    1424        5509 : sal_uInt16 SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutStm )
    1425             : {
    1426        5509 :     if ( !GetExport() && !GetHidden() )
    1427           0 :         return 0;
    1428             : 
    1429        5509 :     SvMetaAttribute * pMethod = GetMethod();
    1430        5509 :     if( IsMethod() )
    1431             :     {
    1432             :         SvMetaType * pType;
    1433        3289 :         if( pMethod )
    1434          22 :             pType = pMethod->GetType();
    1435             :         else
    1436        3267 :             pType = GetType();
    1437             : 
    1438        3289 :         if( !rBase.FindType( pType, rBase.aUsedTypes ) )
    1439        1840 :             rBase.aUsedTypes.push_back( pType );
    1440             : 
    1441             :         const SvMetaAttributeMemberList & rList =
    1442        3289 :                     pType->GetAttrList();
    1443        5676 :         for( sal_uLong n = 0; n < rList.size(); n++ )
    1444             :         {
    1445        2387 :             SvMetaAttribute * pPar  = rList[n];
    1446        2387 :             SvMetaType * pPType     = pPar->GetType();
    1447        2387 :             WriteTab( rOutStm, 1 );
    1448        2387 :             rOutStm << "SFX_ARGUMENT("
    1449        4774 :                 << pPar->GetSlotId().getString().getStr() << ',' // SlodId
    1450             :                 // parameter name
    1451        4774 :                 << "\"" << pPar->GetName().getString().getStr() << "\","
    1452             :                 // item name
    1453        4774 :                 << pPType->GetName().getString().getStr() << ")," << endl;
    1454        2387 :             if( !rBase.FindType( pPType, rBase.aUsedTypes ) )
    1455         110 :                 rBase.aUsedTypes.push_back( pPType );
    1456             :         }
    1457        3289 :         return (sal_uInt16)rList.size();
    1458             :     }
    1459        2220 :     return 0;
    1460             : }
    1461             : 
    1462        5509 : sal_uInt16 SvMetaSlot::WriteSlotMap( const rtl::OString& rShellName, sal_uInt16 nCount,
    1463             :                                 SvSlotElementList& rSlotList,
    1464             :                                 size_t nStart,
    1465             :                                 const rtl::OString& rPrefix,
    1466             :                                 SvIdlDataBase & rBase,
    1467             :                                 SvStream & rOutStm )
    1468             : {
    1469             :     // SlotId, if not specified generate from name
    1470        5509 :     rtl::OString slotId = GetSlotId().getString();
    1471             : 
    1472        5509 :     sal_uInt16 nSCount = 0;
    1473        5509 :     if( IsMethod() )
    1474             :     {
    1475             :         SvMetaType * pType;
    1476        3289 :         SvMetaAttribute * pMethod = GetMethod();
    1477        3289 :         if( pMethod )
    1478          22 :             pType = pMethod->GetType();
    1479             :         else
    1480        3267 :             pType = GetType();
    1481             : 
    1482        3289 :         nSCount = (sal_uInt16)pType->GetAttrCount();
    1483             :     }
    1484             : 
    1485        5509 :     WriteSlot( rShellName, nCount, slotId, rSlotList, nStart, rPrefix, rBase, rOutStm );
    1486        5509 :     return nSCount;
    1487             : }
    1488             : 
    1489       11832 : void SvMetaSlot::WriteHelpId( SvIdlDataBase & rBase, SvStream & rOutStm,
    1490             :                              HelpIdTable&  rTable )
    1491             : {
    1492       11832 :     sal_uLong nSId = GetSlotId().GetValue();
    1493       11832 :     if( rTable.find( nSId ) == rTable.end() )
    1494             :     {
    1495        7974 :         rTable[ nSId ] = this;
    1496        7974 :         rOutStm << "#define " << GetSlotId().getString().getStr() << '\t'
    1497       23922 :             << rtl::OString::valueOf(static_cast<sal_Int32>(nSId)).getStr()
    1498        7974 :             << endl;
    1499             :     }
    1500             : 
    1501       11832 :     SvMetaTypeEnum * pEnum = PTR_CAST( SvMetaTypeEnum, GetType() );
    1502       11832 :     if( GetPseudoSlots() && pEnum )
    1503             :     {
    1504           0 :         for( sal_uLong n = 0; n < pEnum->Count(); ++n )
    1505             :         {
    1506           0 :             rtl::OString aValName = pEnum->GetObject( n )->GetName().getString();
    1507             : 
    1508           0 :             rtl::OStringBuffer aBuf;
    1509           0 :             if( !GetPseudoPrefix().isEmpty() )
    1510           0 :                 aBuf.append(GetPseudoPrefix());
    1511             :             else
    1512           0 :                 aBuf.append(GetSlotId().getString());
    1513           0 :             aBuf.append('_');
    1514           0 :             aBuf.append(aValName.copy(pEnum->GetPrefix().getLength()));
    1515             : 
    1516           0 :             rtl::OString aSId = aBuf.makeStringAndClear();
    1517             : 
    1518             :             sal_uLong nSId2;
    1519           0 :             sal_Bool bIdOk = sal_False;
    1520           0 :             if( rBase.FindId( aSId, &nSId2 ) )
    1521             :             {
    1522           0 :                 aSId = rtl::OString::valueOf(static_cast<sal_Int32>(nSId2));
    1523           0 :                 bIdOk = sal_True;
    1524             :             }
    1525             : 
    1526             :             // if id not found, write always
    1527           0 :             if( !bIdOk || rTable.find( nSId2 ) == rTable.end() )
    1528             :             {
    1529           0 :                 rTable[ nSId2 ] = this;
    1530             : 
    1531           0 :                 rOutStm << "#define " << aSId.getStr() << '\t'
    1532             :                     << rtl::OString::valueOf(
    1533           0 :                         static_cast<sal_Int32>(nSId2)).getStr()
    1534           0 :                     << endl;
    1535             :             }
    1536           0 :         }
    1537             :     }
    1538       11832 : }
    1539             : 
    1540           0 : void WriteBool( sal_Bool bSet, SvStream& rStream )
    1541             : {
    1542           0 :     if ( bSet )
    1543           0 :         rStream << "TRUE" << ',';
    1544             :     else
    1545           0 :         rStream << "FALSE" << ',';
    1546           0 : }
    1547             : 
    1548           0 : void SvMetaSlot::WriteCSV( SvIdlDataBase& rBase, SvStream& rStrm )
    1549             : {
    1550           0 :     rStrm << "PROJECT,";
    1551           0 :     rStrm << GetSlotId().getString().getStr() << ',';
    1552             :     rStrm
    1553             :         << rtl::OString::valueOf(
    1554           0 :             static_cast<sal_Int32>(GetSlotId().GetValue())).getStr()
    1555           0 :         << ',';
    1556             : 
    1557           0 :     if ( !GetPseudoPrefix().isEmpty() )
    1558           0 :         rStrm << GetPseudoPrefix().getStr() << ',';
    1559             :     else
    1560           0 :         rStrm << ',';
    1561             : 
    1562           0 :     rStrm << GetGroupId().getStr() << ',';
    1563             : 
    1564           0 :     WriteBool( GetAccelConfig(), rStrm );
    1565           0 :     WriteBool( GetMenuConfig(), rStrm );
    1566           0 :     WriteBool( GetStatusBarConfig(), rStrm );
    1567           0 :     WriteBool( GetToolBoxConfig(), rStrm );
    1568             : 
    1569           0 :     if ( GetSlotType() )
    1570           0 :         rStrm << GetSlotType()->GetName().getString().getStr() << ',';
    1571             :     else
    1572           0 :         rStrm << ',';
    1573             : 
    1574           0 :     WriteBool( GetAutoUpdate(), rStrm );
    1575           0 :     if ( GetCachable() )
    1576           0 :         rStrm << "Cachable" << ',';
    1577             :     else
    1578           0 :         rStrm << "Volatile" << ',';
    1579             : 
    1580           0 :     WriteBool( GetContainer(), rStrm );
    1581           0 :     WriteBool( GetFastCall(), rStrm );
    1582           0 :     WriteBool( GetHasCoreId(), rStrm );
    1583           0 :     WriteBool( GetHasDialog(), rStrm );
    1584           0 :     WriteBool( GetReadOnlyDoc(), rStrm );
    1585           0 :     WriteBool( GetImageRotation(), rStrm );
    1586           0 :     WriteBool( GetImageReflection(), rStrm );
    1587           0 :     rStrm << GetDisableFlags().getStr() << ',';
    1588             : 
    1589           0 :     if( GetSynchron() )
    1590           0 :         rStrm << "Synchron" << ',';
    1591             :     else
    1592           0 :         rStrm << "Asynchron" << ',';
    1593             : 
    1594           0 :     WriteBool( GetToggle(), rStrm );
    1595           0 :     WriteBool( GetReadonly(), rStrm );
    1596           0 :     WriteBool( GetExport(), rStrm );
    1597           0 :     if( GetRecordPerItem() )
    1598           0 :         rStrm << "RecordPerItem" << ',';
    1599           0 :     else if ( GetNoRecord() )
    1600           0 :         rStrm << "NoRecord" << ',';
    1601           0 :     else if ( GetRecordManual() )
    1602           0 :         rStrm << "RecordManual" << ',';
    1603             :     else
    1604           0 :         rStrm << "RecordPerSet" << ',';
    1605             : 
    1606           0 :     WriteBool( GetRecordAbsolute(), rStrm );
    1607             : 
    1608           0 :     if ( GetType()->GetType() != TYPE_METHOD && GetMethod() )
    1609             :     {
    1610           0 :         rStrm << GetMethod()->GetType()->GetReturnType()->GetName().getString().getStr() << ',';
    1611           0 :         rStrm << GetMethod()->GetName().getString().getStr() << ',';
    1612             :     }
    1613             :     else
    1614             :     {
    1615           0 :         rStrm << ",,";
    1616             :     }
    1617             : 
    1618           0 :     rStrm << GetType()->GetSvName().getStr() << ',';
    1619           0 :     rStrm << GetName().getString().getStr() << ',';
    1620             : 
    1621           0 :     if ( GetType()->GetType() == TYPE_METHOD || GetMethod() )
    1622             :     {
    1623           0 :         SvMetaAttributeMemberList *pList = &GetType()->GetAttrList();
    1624           0 :            if ( GetMethod() )
    1625           0 :             pList = &GetMethod()->GetType()->GetAttrList();
    1626             : 
    1627           0 :         if( pList && !pList->empty() )
    1628             :         {
    1629           0 :             rStrm << "\"(";
    1630           0 :             SvMetaAttributeMemberList::const_iterator it = pList->begin();
    1631           0 :             while( it != pList->end() )
    1632             :             {
    1633           0 :                 SvMetaAttribute* pAttr = *it;
    1634           0 :                 pAttr->WriteCSV( rBase, rStrm );
    1635           0 :                 ++it;
    1636           0 :                 if( it != pList->end() )
    1637           0 :                     rStrm << ',';
    1638             :             }
    1639           0 :             rStrm << ")\"";
    1640             :         }
    1641             :         else
    1642           0 :             rStrm << "()";
    1643             :     }
    1644             : 
    1645           0 :     rStrm << endl;
    1646           0 : }
    1647             : 
    1648             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10