14 files changed, 325 insertions, 125 deletions

diff --git a/sc/source/ui/unoobj/servuno.cxx b/sc/source/ui/unoobj/servuno.cxx
index b28c401c5..0e5a2100d 100644
--- a/sc/source/ui/unoobj/servuno.cxx
+++ b/sc/source/ui/unoobj/servuno.cxx
@@ -61,10 +61,12 @@
 #include <sfx2/docfile.hxx>
 #include <sfx2/docfilt.hxx>
 #include <com/sun/star/script/ScriptEventDescriptor.hpp>
+#include <com/sun/star/script/XVBACompat.hpp>
 #include <com/sun/star/document/XCodeNameQuery.hpp>
 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
 #include <com/sun/star/form/XFormsSupplier.hpp>
 #include <svx/unomod.hxx> 
+#include <vbahelper/vbaaccesshelper.hxx>
 
 #include <comphelper/processfactory.hxx>
 #include <basic/basmgr.hxx>
@@ -72,18 +74,14 @@
 
 using namespace ::com::sun::star;
 
-#ifndef CWS_NPOWER14MISCFIXES
-uno::Reference< uno::XInterface > lcl_createVBAUnoAPIServiceWithArgs( SfxObjectShell* pShell,  const sal_Char* _pAsciiName, const uno::Sequence< uno::Any >& aArgs ) throw (uno::RuntimeException)
+bool isInVBAMode( ScDocShell& rDocSh )
 {
-    uno::Any aUnoVar;
-    if ( !pShell || !pShell->GetBasicManager()->GetGlobalUNOConstant( "VBAGlobals", aUnoVar ) )
-        throw lang::IllegalArgumentException();
-    uno::Reference< lang::XMultiServiceFactory > xVBAFactory( aUnoVar, uno::UNO_QUERY_THROW );
-    ::rtl::OUString sVarName( ::rtl::OUString::createFromAscii( _pAsciiName ) );
-    uno::Reference< uno::XInterface > xIf = xVBAFactory->createInstanceWithArguments( sVarName, aArgs  );
-    return xIf;
+    uno::Reference<script::XLibraryContainer> xLibContainer = rDocSh.GetBasicContainer();
+    uno::Reference<script::XVBACompat> xVBACompat( xLibContainer, uno::UNO_QUERY );
+    if ( xVBACompat.is() )
+        return xVBACompat->getVBACompatModeOn();
+    return false;
 }
-#endif 
 
 class ScVbaObjectForCodeNameProvider : public ::cppu::WeakImplHelper1< container::XNameAccess >
 {
@@ -98,13 +96,10 @@ public:
             throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("")), uno::Reference< uno::XInterface >() );
 
         uno::Sequence< uno::Any > aArgs(2);
-        aArgs[0] = uno::Any( uno::Reference< uno::XInterface >() );
+        // access the application object ( parent for workbook )
+        aArgs[0] = uno::Any( ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.Application", uno::Sequence< uno::Any >() ) );
         aArgs[1] = uno::Any( mpDocShell->GetModel() );
-#ifdef CWS_NPOWER14MISCFIXES
         maWorkbook <<= ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.excel.Workbook", aArgs );
-#else
-        maWorkbook <<= lcl_createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.excel.Workbook", aArgs );
-#endif
     }
 
     virtual ::sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) throw (::com::sun::star::uno::RuntimeException )
@@ -139,13 +134,8 @@ public:
                         aArgs[0] = maWorkbook;
                         aArgs[1] = uno::Any( xModel );
                         aArgs[2] = uno::Any( rtl::OUString( sSheetName ) );
-#ifdef CWS_NPOWER14MISCFIXES
                         // use the convience function
                         maCachedObject <<= ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.excel.Worksheet", aArgs );
-#else
-                        // use the temp function
-                        maCachedObject <<= lcl_createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.excel.Worksheet", aArgs );
-#endif
                         break;
                     }
                 }
@@ -576,7 +566,7 @@ uno::Reference<uno::XInterface> ScServiceProvider::MakeInstance(
             {
                 // Only create the excel faking service for excel docs
                 const SfxFilter *pFilt = pDocShell->GetMedium()->GetFilter();
-                if ( pFilt && pFilt->IsAlienFormat() )
+                if ( pFilt && pFilt->IsAlienFormat() && isInVBAMode( *pDocShell ) )
                 {
                     // application/vnd.ms-excel is the mime type for Excel
                     static const rtl::OUString sExcelMimeType( RTL_CONSTASCII_USTRINGPARAM( "application/vnd.ms-excel" ) );
diff --git a/sc/source/ui/vba/excelvbahelper.cxx b/sc/source/ui/vba/excelvbahelper.cxx
index 272278171..5fc1b3c40 100644
--- a/sc/source/ui/vba/excelvbahelper.cxx
+++ b/sc/source/ui/vba/excelvbahelper.cxx
@@ -31,6 +31,7 @@
 #include "scmod.hxx"
 #include "cellsuno.hxx"
 #include <comphelper/processfactory.hxx>
+#include <com/sun/star/sheet/XSheetCellRange.hpp>
 
 using namespace ::com::sun::star;
 using namespace ::ooo::vba;
@@ -41,6 +42,27 @@ namespace vba
 {
 namespace excel
 {
+
+ScDocShell* GetDocShellFromRange( const uno::Reference< uno::XInterface >& xRange ) throw ( uno::RuntimeException )
+{
+    ScCellRangesBase* pScCellRangesBase = ScCellRangesBase::getImplementation( xRange );
+    if ( !pScCellRangesBase )
+    {
+        throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access underlying doc shell uno range object" ) ), uno::Reference< uno::XInterface >() );
+    }
+    return pScCellRangesBase->GetDocShell();
+}
+
+ScDocument* GetDocumentFromRange( const uno::Reference< uno::XInterface >& xRange ) throw ( uno::RuntimeException )
+{
+        ScDocShell* pDocShell = GetDocShellFromRange( xRange );
+        if ( !pDocShell )
+        {
+                throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Failed to access underlying document from uno range object" ) ), uno::Reference< uno::XInterface >() );
+        }
+        return pDocShell->GetDocument();
+}
+
 void implSetZoom( const uno::Reference< frame::XModel >& xModel, sal_Int16 nZoom, std::vector< SCTAB >& nTabs )
 {
     ScTabViewShell* pViewSh = excel::getBestViewShell( xModel );
@@ -207,12 +229,40 @@ getViewFrame( const uno::Reference< frame::XModel >& xModel )
     return NULL;
 }
 
+uno::Reference< XHelperInterface > 
+getUnoSheetModuleObj( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException )
+{
+    uno::Reference< sheet::XSheetCellRange > xSheetRange( xRange, uno::UNO_QUERY_THROW );
+    uno::Reference< beans::XPropertySet > xProps( xSheetRange->getSpreadsheet(), uno::UNO_QUERY_THROW );
+    rtl::OUString sCodeName;
+    xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("CodeName") ) ) >>= sCodeName;
+    // #TODO #FIXME ideally we should 'throw' here if we don't get a valid parent, but... it is possible
+    // to create a module ( and use 'Option VBASupport 1' ) for a calc document, in this scenario there
+    // are *NO* special document module objects ( of course being able to switch between vba/non vba mode at 
+    // the document in the future could fix this, especially IF the switching of the vba mode takes care to 
+    // create the special document module objects if they don't exist.
+    uno::Reference< XHelperInterface > xParent( ov::getUnoDocModule( sCodeName, GetDocShellFromRange( xRange ) ), uno::UNO_QUERY );
+
+    return xParent;
+}
+
+uno::Reference< XHelperInterface > 
+getUnoSheetModuleObj( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException )
+{
+    uno::Reference< container::XEnumerationAccess > xEnumAccess( xRanges, uno::UNO_QUERY_THROW );
+    uno::Reference< container::XEnumeration > xEnum = xEnumAccess->createEnumeration();
+    uno::Reference< table::XCellRange > xRange( xEnum->nextElement(), uno::UNO_QUERY_THROW );
+
+    return getUnoSheetModuleObj( xRange );
+}
+
 SfxItemSet*
 ScVbaCellRangeAccess::GetDataSet( ScCellRangesBase* pRangeObj )
 {
     return pRangeObj ? pRangeObj->GetCurrentDataSet( true ) : 0;
 }
 
+
 } //excel
 } //vba 
 } //ooo 
diff --git a/sc/source/ui/vba/excelvbahelper.hxx b/sc/source/ui/vba/excelvbahelper.hxx
index ce6ba352c..528457a0f 100644
--- a/sc/source/ui/vba/excelvbahelper.hxx
+++ b/sc/source/ui/vba/excelvbahelper.hxx
@@ -29,6 +29,9 @@
 
 #include<vbahelper/vbahelper.hxx>
 #include <docsh.hxx>
+#include <com/sun/star/table/XCellRange.hpp>
+#include <com/sun/star/sheet/XSheetCellRangeContainer.hpp>
+#include <ooo/vba/XHelperInterface.hpp>
 
 class ScCellRangesBase;
 
@@ -48,6 +51,11 @@ namespace ooo
         ScDocShell* getDocShell( const css::uno::Reference< css::frame::XModel>& xModel ) ;
         ScTabViewShell* getCurrentBestViewShell( const css::uno::Reference< css::uno::XComponentContext >& xContext );
         SfxViewFrame* getViewFrame( const css::uno::Reference< css::frame::XModel >& xModel );
+            css::uno::Reference< ooo::vba::XHelperInterface > getUnoSheetModuleObj( const css::uno::Reference< css::sheet::XSheetCellRangeContainer >& xRanges ) throw ( css::uno::RuntimeException );
+            css::uno::Reference< ooo::vba::XHelperInterface > getUnoSheetModuleObj( const css::uno::Reference< css::table::XCellRange >& xRange ) throw ( css::uno::RuntimeException );
+             ScDocShell* GetDocShellFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException );
+             ScDocument* GetDocumentFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException );
+             css::uno::Reference< css::frame::XModel > GetModelFromRange( const css::uno::Reference< css::uno::XInterface >& xRange ) throw ( css::uno::RuntimeException );
             class ScVbaCellRangeAccess
             {
             public:
diff --git a/sc/source/ui/vba/vbaapplication.cxx b/sc/source/ui/vba/vbaapplication.cxx
index e00f6d635..b398c9e48 100644
--- a/sc/source/ui/vba/vbaapplication.cxx
+++ b/sc/source/ui/vba/vbaapplication.cxx
@@ -193,18 +193,47 @@ ScVbaApplication::hasProperty( const ::rtl::OUString& Name ) throw(uno::RuntimeE
 uno::Reference< excel::XWorkbook >
 ScVbaApplication::getActiveWorkbook() throw (uno::RuntimeException)
 {
-    return new ActiveWorkbook( this, mxContext ); 
+    uno::Reference< excel::XWorkbook > xWrkbk;
+    ScDocShell* pShell = excel::getDocShell( getCurrentExcelDoc( mxContext ) );
+    if ( pShell )
+    {
+        String aName;
+        if ( pShell->GetDocument() )
+        {
+            aName = pShell->GetDocument()->GetCodeName();
+            xWrkbk.set( getUnoDocModule(  aName, pShell ), uno::UNO_QUERY );
+            // fallback ( e.g. it's possible a new document was created via the api )
+            // in that case the document will not have the appropriate Document Modules
+            // #TODO #FIXME ( needs to be fixes as part of providing support for an overall document 
+            // vba mode etc. )
+            if ( !xWrkbk.is() )
+                return new ActiveWorkbook( this, mxContext );
+        }
+    }
+    return xWrkbk; 
 }
 
 uno::Reference< excel::XWorkbook > SAL_CALL 
 ScVbaApplication::getThisWorkbook() throw (uno::RuntimeException)
 {
-    uno::Reference< frame::XModel > xModel = getThisExcelDoc(mxContext);
-    if( !xModel.is() )
-        return uno::Reference< excel::XWorkbook >();
-
-    ScVbaWorkbook *pWb = new ScVbaWorkbook( this, mxContext, xModel );
-    return uno::Reference< excel::XWorkbook > (pWb);
+    uno::Reference< excel::XWorkbook > xWrkbk;
+    ScDocShell* pShell = excel::getDocShell( getThisExcelDoc( mxContext ) );
+    if ( pShell )
+    {
+        String aName;
+        if ( pShell->GetDocument() )
+        {
+            aName = pShell->GetDocument()->GetCodeName();
+            xWrkbk.set( getUnoDocModule( aName, pShell ), uno::UNO_QUERY );
+            // fallback ( e.g. it's possible a new document was created via the api )
+            // in that case the document will not have the appropriate Document Modules
+            // #TODO #FIXME ( needs to be fixes as part of providing support for an overall document 
+            // vba mode etc. )
+            if ( !xWrkbk.is() )
+                return new ActiveWorkbook( this, mxContext );
+        }
+    }
+    return xWrkbk;
 }
 
 uno::Reference< XAssistant > SAL_CALL
@@ -246,10 +275,10 @@ ScVbaApplication::getSelection() throw (uno::RuntimeException)
         {
             uno::Reference< sheet::XSheetCellRangeContainer > xRanges( getCurrentDocument()->getCurrentSelection(), ::uno::UNO_QUERY);
             if ( xRanges.is() )
-                return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( this, mxContext, xRanges ) ) );
+                return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( excel::getUnoSheetModuleObj( xRanges ), mxContext, xRanges ) ) );
 
         }
-        return uno::makeAny( uno::Reference< excel::XRange >(new ScVbaRange( this, mxContext, xRange ) ) );
+        return uno::makeAny( uno::Reference< excel::XRange >(new ScVbaRange( excel::getUnoSheetModuleObj( xRange ), mxContext, xRange ) ) );
     }
     else
     {
@@ -531,10 +560,8 @@ ScVbaApplication::GoTo( const uno::Any& Reference, const uno::Any& Scroll ) thro
         ScGridWindow* gridWindow = (ScGridWindow*)pShell->GetWindow(); 
         try
         {
-            // FIXME: pass proper Worksheet parent
             uno::Reference< excel::XRange > xVbaSheetRange = ScVbaRange::getRangeObjectForName(
-                uno::Reference< XHelperInterface >(), mxContext, sRangeName,
-                excel::getDocShell( xModel ), formula::FormulaGrammar::CONV_XL_R1C1 );
+                mxContext, sRangeName, excel::getDocShell( xModel ), formula::FormulaGrammar::CONV_XL_R1C1 );
 
             if( bScroll )
             {
@@ -1068,12 +1095,13 @@ ScVbaApplication::Intersect( const uno::Reference< excel::XRange >& Arg1, const
     ScDocShell* pDocShell = excel::getDocShell( xModel );
     if ( aCellRanges.Count() == 1 )
     {
-        xRefRange = new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, new ScCellRangeObj( pDocShell, *aCellRanges.First() ) );
+                uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pDocShell, *aCellRanges.First() ));
+        xRefRange = new ScVbaRange( excel::getUnoSheetModuleObj( xRange ), mxContext, xRange );
     }
     else if ( aCellRanges.Count() > 1 )
     {
         uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDocShell, aCellRanges ) );
-        xRefRange = new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, xRanges );
+        xRefRange = new ScVbaRange( excel::getUnoSheetModuleObj( xRanges ) , mxContext, xRanges );
 
     }
     return xRefRange;
@@ -1158,12 +1186,13 @@ ScVbaApplication::Union( const uno::Reference< excel::XRange >& Arg1, const uno:
     if ( aCellRanges.Count() == 1 ) 
     {
     // normal range
-        xRange = new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, new ScCellRangeObj( pDocShell, *aCellRanges.First() ) );
+                uno::Reference< table::XCellRange > xCalcRange( new ScCellRangeObj( pDocShell, *aCellRanges.First() ) );
+        xRange = new ScVbaRange( excel::getUnoSheetModuleObj( xCalcRange ), mxContext, xCalcRange );
     }
     else if ( aCellRanges.Count() > 1 ) // Multi-Area
     {
         uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDocShell, aCellRanges ) );
-        xRange = new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, xRanges );
+        xRange = new ScVbaRange( excel::getUnoSheetModuleObj( xRanges ), mxContext, xRanges );
     }
     
     // #FIXME need proper (WorkSheet) parent
diff --git a/sc/source/ui/vba/vbachartobjects.cxx b/sc/source/ui/vba/vbachartobjects.cxx
index 2d2d7ffe4..cb5a669d9 100644
--- a/sc/source/ui/vba/vbachartobjects.cxx
+++ b/sc/source/ui/vba/vbachartobjects.cxx
@@ -47,16 +47,15 @@ using namespace ::ooo::vba;
 class ChartObjectEnumerationImpl : public EnumerationHelperImpl
 {
     uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier;
-    uno::Reference< XHelperInterface > xParent;
     
 public:
 
-    ChartObjectEnumerationImpl( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, const uno::Reference< drawing::XDrawPageSupplier >& _xDrawPageSupplier, const uno::Reference< XHelperInterface >& _xParent ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ), xDrawPageSupplier( _xDrawPageSupplier ), xParent( _xParent ) {}
+    ChartObjectEnumerationImpl( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, const uno::Reference< drawing::XDrawPageSupplier >& _xDrawPageSupplier, const uno::Reference< XHelperInterface >& _xParent ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( _xParent, xContext, xEnumeration ), xDrawPageSupplier( _xDrawPageSupplier ) {}
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     { 
         uno::Reference< table::XTableChart > xTableChart( m_xEnumeration->nextElement(), uno::UNO_QUERY_THROW );
         // parent Object is sheet
-        return uno::makeAny(  uno::Reference< excel::XChartObject > ( new ScVbaChartObject(  xParent, m_xContext, xTableChart, xDrawPageSupplier ) ) );
+        return uno::makeAny(  uno::Reference< excel::XChartObject > ( new ScVbaChartObject(  m_xParent, m_xContext, xTableChart, xDrawPageSupplier ) ) );
     }
 };
 
diff --git a/sc/source/ui/vba/vbacomments.cxx b/sc/source/ui/vba/vbacomments.cxx
index ed7cc5db2..db6f56692 100644
--- a/sc/source/ui/vba/vbacomments.cxx
+++ b/sc/source/ui/vba/vbacomments.cxx
@@ -50,10 +50,11 @@ class CommentEnumeration : public EnumerationHelperImpl
     css::uno::Reference< css::frame::XModel > mxModel;
 public:
     CommentEnumeration(
+            const uno::Reference< XHelperInterface >& xParent,
             const uno::Reference< uno::XComponentContext >& xContext,
             const uno::Reference< container::XEnumeration >& xEnumeration,
             const uno::Reference< frame::XModel >& xModel ) throw ( uno::RuntimeException ) :
-        EnumerationHelperImpl( xContext, xEnumeration ),
+        EnumerationHelperImpl( xParent, xContext, xEnumeration ),
         mxModel( xModel, uno::UNO_SET_THROW )
     {}
 
@@ -81,7 +82,7 @@ ScVbaComments::createEnumeration() throw (uno::RuntimeException)
 {
     uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
 
-    return new CommentEnumeration( mxContext, xEnumAccess->createEnumeration(), mxModel );
+    return new CommentEnumeration( mxParent, mxContext, xEnumAccess->createEnumeration(), mxModel );
 }
 
 uno::Any
diff --git a/sc/source/ui/vba/vbaformatconditions.cxx b/sc/source/ui/vba/vbaformatconditions.cxx
index b18877322..6d48bb899 100644
--- a/sc/source/ui/vba/vbaformatconditions.cxx
+++ b/sc/source/ui/vba/vbaformatconditions.cxx
@@ -48,8 +48,8 @@ static rtl::OUString sStyleNamePrefix( RTL_CONSTASCII_USTRINGPARAM("Excel_CondFo
 ScVbaFormatConditions::ScVbaFormatConditions( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext > & xContext, const uno::Reference< sheet::XSheetConditionalEntries >& _xSheetConditionalEntries, const uno::Reference< frame::XModel >& xModel ) : ScVbaFormatConditions_BASE( xParent, xContext, uno::Reference< container::XIndexAccess >( _xSheetConditionalEntries, uno::UNO_QUERY_THROW ) ), mxSheetConditionalEntries( _xSheetConditionalEntries )
 {
     mxRangeParent.set( xParent, uno::UNO_QUERY_THROW );
-    uno::Reference< excel::XWorkbook > xWorkbook = new ScVbaWorkbook(  uno::Reference< XHelperInterface >( Application(), uno::UNO_QUERY_THROW ), xContext, xModel );
-    mxStyles.set( xWorkbook->Styles( uno::Any() ), uno::UNO_QUERY_THROW );
+    uno::Reference< excel::XApplication> xApp( Application(), uno::UNO_QUERY_THROW );
+    mxStyles.set( xApp->getThisWorkbook()->Styles( uno::Any() ), uno::UNO_QUERY_THROW );
     uno::Reference< sheet::XCellRangeAddressable > xCellRange( mxRangeParent->getCellRange(), uno::UNO_QUERY_THROW );
     mxParentRangePropertySet.set( xCellRange, uno::UNO_QUERY_THROW );
     
diff --git a/sc/source/ui/vba/vbaname.cxx b/sc/source/ui/vba/vbaname.cxx
index 81d5ba975..66381c15e 100644
--- a/sc/source/ui/vba/vbaname.cxx
+++ b/sc/source/ui/vba/vbaname.cxx
@@ -232,10 +232,8 @@ ScVbaName::setRefersToR1C1Local( const ::rtl::OUString & rRefersTo ) throw (css:
 css::uno::Reference< ov::excel::XRange >
 ScVbaName::getRefersToRange() throw (css::uno::RuntimeException)
 {
-    // FIXME: pass proper Worksheet parent
     uno::Reference< ov::excel::XRange > xRange = ScVbaRange::getRangeObjectForName(
-        uno::Reference< XHelperInterface >(), mxContext,
-        mxNamedRange->getName(), excel::getDocShell( mxModel ), formula::FormulaGrammar::CONV_XL_R1C1 );
+        mxContext, mxNamedRange->getName(), excel::getDocShell( mxModel ), formula::FormulaGrammar::CONV_XL_R1C1 );
     return xRange;
 }
 
diff --git a/sc/source/ui/vba/vbanames.cxx b/sc/source/ui/vba/vbanames.cxx
index 5373717fe..f993aee4f 100644
--- a/sc/source/ui/vba/vbanames.cxx
+++ b/sc/source/ui/vba/vbanames.cxx
@@ -48,7 +48,7 @@ class NamesEnumeration : public EnumerationHelperImpl
     uno::WeakReference< XHelperInterface > m_xParent;
     uno::Reference< sheet::XNamedRanges > m_xNames;
 public:
-    NamesEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration,  const uno::Reference< frame::XModel >& xModel , const uno::Reference< sheet::XNamedRanges >& xNames ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ), m_xModel( xModel ), m_xParent( xParent ), m_xNames( xNames ) {}
+    NamesEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration,  const uno::Reference< frame::XModel >& xModel , const uno::Reference< sheet::XNamedRanges >& xNames ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), m_xModel( xModel ), m_xParent( xParent ), m_xNames( xNames ) {}
 
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
     {
diff --git a/sc/source/ui/vba/vbapivottables.cxx b/sc/source/ui/vba/vbapivottables.cxx
index 2f8e0775e..f9014a42d 100644
--- a/sc/source/ui/vba/vbapivottables.cxx
+++ b/sc/source/ui/vba/vbapivottables.cxx
@@ -42,7 +42,7 @@ uno::Any DataPilotToPivotTable( const uno::Any& aSource, uno::Reference< uno::XC
 class PivotTableEnumeration : public EnumerationHelperImpl
 {
 public:
-    PivotTableEnumeration( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ) {}
+    PivotTableEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ) {}
 
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     { 
@@ -59,7 +59,7 @@ uno::Reference< container::XEnumeration >
 ScVbaPivotTables::createEnumeration() throw (uno::RuntimeException)
 {
     uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
-    return new PivotTableEnumeration( mxContext, xEnumAccess->createEnumeration() );
+    return new PivotTableEnumeration( mxParent, mxContext, xEnumAccess->createEnumeration() );
 }
 
 uno::Any
diff --git a/sc/source/ui/vba/vbarange.cxx b/sc/source/ui/vba/vbarange.cxx
index 8c107e3ee..de57468b6 100644..100755
--- a/sc/source/ui/vba/vbarange.cxx
+++ b/sc/source/ui/vba/vbarange.cxx
@@ -202,11 +202,10 @@ double lcl_Round2DecPlaces( double nVal )
     return nVal;
 }
 
-uno::Any lcl_makeRange( uno::Reference< uno::XComponentContext >& xContext, const uno::Any aAny, bool bIsRows, bool bIsColumns )
+uno::Any lcl_makeRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Any aAny, bool bIsRows, bool bIsColumns )
 {
     uno::Reference< table::XCellRange > xCellRange( aAny, uno::UNO_QUERY_THROW );
-    // #FIXME need proper (WorkSheet) parent
-    return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( uno::Reference< XHelperInterface >(), xContext, xCellRange, bIsRows, bIsColumns ) ) );
+    return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( xParent, xContext, xCellRange, bIsRows, bIsColumns ) ) );
 }
 
 uno::Reference< excel::XRange > lcl_makeXRangeFromSheetCellRanges( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSheetCellRanges >& xLocSheetCellRanges, ScDocShell* pDoc )
@@ -227,13 +226,11 @@ uno::Reference< excel::XRange > lcl_makeXRangeFromSheetCellRanges( const uno::Re
     if ( aCellRanges.First() == aCellRanges.Last() )
     {
         uno::Reference< table::XCellRange > xTmpRange( new ScCellRangeObj( pDoc, *aCellRanges.First() ) );
-        // #FIXME need proper (WorkSheet) parent
         xRange = new ScVbaRange( xParent, xContext, xTmpRange );
     }
     else
     {
         uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDoc, aCellRanges ) );
-        // #FIXME need proper (WorkSheet) parent
         xRange = new ScVbaRange( xParent, xContext, xRanges );
     }
     }
@@ -269,12 +266,13 @@ SfxItemSet*  ScVbaRange::getCurrentDataSet( ) throw ( uno::RuntimeException )
 
 class SingleRangeEnumeration : public EnumerationHelper_BASE
 {
+    uno::Reference< XHelperInterface > m_xParent;
     uno::Reference< table::XCellRange > m_xRange;
     uno::Reference< uno::XComponentContext > mxContext;
     bool bHasMore;
 public:
 
-    SingleRangeEnumeration( const uno::Reference< css::uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) : m_xRange( xRange ), mxContext( xContext ), bHasMore( true ) { }
+    SingleRangeEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< css::uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) : m_xParent( xParent ), m_xRange( xRange ), mxContext( xContext ), bHasMore( true ) { }
     virtual ::sal_Bool SAL_CALL hasMoreElements(  ) throw (uno::RuntimeException) { return bHasMore; }
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     {
@@ -292,11 +290,12 @@ typedef ::cppu::WeakImplHelper2< container::XIndexAccess, container::XEnumeratio
 class SingleRangeIndexAccess : public SingleRange_BASE
 {
 private:
+    uno::Reference< XHelperInterface > mxParent;
     uno::Reference< table::XCellRange > m_xRange;
     uno::Reference< uno::XComponentContext > mxContext;
     SingleRangeIndexAccess(); // not defined
 public:
-    SingleRangeIndexAccess( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ):m_xRange( xRange ), mxContext( xContext ) {}
+    SingleRangeIndexAccess( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ):mxParent( xParent ), m_xRange( xRange ), mxContext( xContext ) {}
     // XIndexAccess
     virtual ::sal_Int32 SAL_CALL getCount() throw (::uno::RuntimeException) { return 1; }
     virtual uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
@@ -310,7 +309,7 @@ public:
  
         virtual ::sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException) { return sal_True; }
     // XEnumerationAccess
-    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException) { return new SingleRangeEnumeration( mxContext, m_xRange ); }
+    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException) { return new SingleRangeEnumeration( mxParent, mxContext, m_xRange ); }
 
 };
 
@@ -322,10 +321,10 @@ class RangesEnumerationImpl : public EnumerationHelperImpl
     bool mbIsColumns;
 public:
 
-    RangesEnumerationImpl( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, bool bIsRows, bool bIsColumns ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
+    RangesEnumerationImpl( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, bool bIsRows, bool bIsColumns ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     { 
-        return lcl_makeRange( m_xContext, m_xEnumeration->nextElement(), mbIsRows, mbIsColumns );
+        return lcl_makeRange( m_xParent, m_xContext, m_xEnumeration->nextElement(), mbIsRows, mbIsColumns );
     }
 };
 
@@ -335,7 +334,7 @@ class ScVbaRangeAreas : public ScVbaCollectionBaseImpl
     bool mbIsRows;
     bool mbIsColumns;
 public:
-    ScVbaRangeAreas( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XIndexAccess >& xIndexAccess, bool bIsRows, bool bIsColumns ) : ScVbaCollectionBaseImpl( uno::Reference< XHelperInterface >(), xContext, xIndexAccess ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
+    ScVbaRangeAreas( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XIndexAccess >& xIndexAccess, bool bIsRows, bool bIsColumns ) : ScVbaCollectionBaseImpl( xParent, xContext, xIndexAccess ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
 
     // XEnumerationAccess
     virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException);
@@ -355,14 +354,14 @@ uno::Reference< container::XEnumeration > SAL_CALL
 ScVbaRangeAreas::createEnumeration() throw (uno::RuntimeException)
 {
     uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
-    return new RangesEnumerationImpl( mxContext, xEnumAccess->createEnumeration(), mbIsRows, mbIsColumns );
+    return new RangesEnumerationImpl( mxParent, mxContext, xEnumAccess->createEnumeration(), mbIsRows, mbIsColumns );
 
 }
 
 uno::Any
 ScVbaRangeAreas::createCollectionObject( const uno::Any& aSource )
 {
-    return lcl_makeRange( mxContext, aSource, mbIsRows, mbIsColumns );
+    return lcl_makeRange( mxParent, mxContext, aSource, mbIsRows, mbIsColumns );
 }
 
 // assume that xIf is infact a ScCellRangesBase
@@ -618,6 +617,7 @@ public:
 
 class CellsEnumeration : public CellsEnumeration_BASE
 {
+    uno::WeakReference< XHelperInterface > mxParent;
     uno::Reference< uno::XComponentContext > mxContext;
     uno::Reference< XCollection > m_xAreas;
     vCellPos m_CellPositions;
@@ -645,7 +645,7 @@ class CellsEnumeration : public CellsEnumeration_BASE
         }
     }
 public:
-    CellsEnumeration( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< XCollection >& xAreas ): mxContext( xContext ), m_xAreas( xAreas )
+    CellsEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< XCollection >& xAreas ): mxParent( xParent ), mxContext( xContext ), m_xAreas( xAreas )
     {
         sal_Int32 nItems = m_xAreas->getCount();
         for ( sal_Int32 index=1; index <= nItems; ++index )
@@ -664,8 +664,7 @@ public:
 
         uno::Reference< table::XCellRange > xRangeArea = getArea( aPos.m_nArea );
         uno::Reference< table::XCellRange > xCellRange( xRangeArea->getCellByPosition(  aPos.m_nCol, aPos.m_nRow ), uno::UNO_QUERY_THROW );
-        // #FIXME need proper (WorkSheet) parent
-        return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, xCellRange ) ) );
+        return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( mxParent, mxContext, xCellRange ) ) );
 
     }
 };
@@ -1088,11 +1087,11 @@ public:
         return 	uno::Reference< sheet::XSheetCellCursor >( getSpreadSheet()->createCursorByRange( getSheetCellRange() ), uno::UNO_QUERY_THROW );
     }
 
-    static uno::Reference< excel::XRange > createRangeFromRange( const uno::Reference<uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, const uno::Reference< sheet::XCellRangeAddressable >& xCellRangeAddressable, sal_Int32 nStartColOffset = 0, sal_Int32 nStartRowOffset = 0,
- sal_Int32 nEndColOffset = 0, sal_Int32 nEndRowOffset = 0 )
+    static uno::Reference< excel::XRange > createRangeFromRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference<uno::XComponentContext >& xContext,
+        const uno::Reference< table::XCellRange >& xRange, const uno::Reference< sheet::XCellRangeAddressable >& xCellRangeAddressable,
+        sal_Int32 nStartColOffset = 0, sal_Int32 nStartRowOffset = 0, sal_Int32 nEndColOffset = 0, sal_Int32 nEndRowOffset = 0 )
     {
-        // #FIXME need proper (WorkSheet) parent
-        return uno::Reference< excel::XRange >( new ScVbaRange( uno::Reference< XHelperInterface >(), xContext,
+        return uno::Reference< excel::XRange >( new ScVbaRange( xParent, xContext,
             xRange->getCellRangeByPosition(
                 xCellRangeAddressable->getRangeAddress().StartColumn + nStartColOffset,
                 xCellRangeAddressable->getRangeAddress().StartRow + nStartRowOffset,
@@ -1178,7 +1177,7 @@ bool getScRangeListForAddress( const rtl::OUString& sName, ScDocShell* pDocSh, S
 
 
 ScVbaRange*
-getRangeForName( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const rtl::OUString& sName, ScDocShell* pDocSh, table::CellRangeAddress& pAddr, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( uno::RuntimeException )
+getRangeForName( const uno::Reference< uno::XComponentContext >& xContext, const rtl::OUString& sName, ScDocShell* pDocSh, table::CellRangeAddress& pAddr, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( uno::RuntimeException )
 {
     ScRangeList aCellRanges;
     ScRange refRange;
@@ -1189,10 +1188,13 @@ getRangeForName( const uno::Reference< XHelperInterface >& xParent, const uno::R
     if ( aCellRanges.First() == aCellRanges.Last() )
     {
         uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pDocSh, *aCellRanges.First() ) );
-        return new ScVbaRange( xParent, xContext, xRange );
+        uno::Reference< XHelperInterface > xFixThisParent = excel::getUnoSheetModuleObj( xRange ); 
+        return new ScVbaRange( xFixThisParent, xContext, xRange );
     }
     uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDocSh, aCellRanges ) );
-    return new ScVbaRange( xParent, xContext, xRanges );
+
+    uno::Reference< XHelperInterface > xFixThisParent = excel::getUnoSheetModuleObj( xRanges ); 
+    return new ScVbaRange( xFixThisParent, xContext, xRanges );
 }
 
 // ----------------------------------------------------------------------------
@@ -1284,12 +1286,12 @@ util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxC
 // ----------------------------------------------------------------------------
 
 css::uno::Reference< excel::XRange >
-ScVbaRange::getRangeObjectForName( const css::uno::Reference< ov::XHelperInterface >& xParent,
+ScVbaRange::getRangeObjectForName(
         const uno::Reference< uno::XComponentContext >& xContext, const rtl::OUString& sRangeName,
         ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention eConv ) throw ( uno::RuntimeException )
 {
     table::CellRangeAddress refAddr;
-    return getRangeForName( xParent, xContext, sRangeName, pDocSh, refAddr, eConv );
+    return getRangeForName( xContext, sRangeName, pDocSh, refAddr, eConv );
 }
 
 
@@ -1348,13 +1350,13 @@ ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args,
     uno::Reference< container::XIndexAccess >  xIndex;
     if ( mxRange.is() )
     {
-        xIndex = new SingleRangeIndexAccess( mxContext, mxRange );
+        xIndex = new SingleRangeIndexAccess( mxParent, mxContext, mxRange );
     }
     else if ( mxRanges.is() )
     {
         xIndex.set( mxRanges, uno::UNO_QUERY_THROW );
     }
-    m_Areas = new ScVbaRangeAreas( mxContext, xIndex, mbIsRows, mbIsColumns );
+    m_Areas = new ScVbaRangeAreas( mxParent, mxContext, xIndex, mbIsRows, mbIsColumns );
 }
 
 ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, sal_Bool bIsRows, sal_Bool bIsColumns ) throw( lang::IllegalArgumentException )
@@ -1367,8 +1369,8 @@ ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const
     if  ( !xRange.is() )
         throw lang::IllegalArgumentException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "range is not set " ) ), uno::Reference< uno::XInterface >() , 1 );
 
-    uno::Reference< container::XIndexAccess > xIndex( new SingleRangeIndexAccess( mxContext, xRange ) );
-    m_Areas = new ScVbaRangeAreas( mxContext, xIndex, mbIsRows, mbIsColumns );
+    uno::Reference< container::XIndexAccess > xIndex( new SingleRangeIndexAccess( mxParent, mxContext, xRange ) );
+    m_Areas = new ScVbaRangeAreas( mxParent, mxContext, xIndex, mbIsRows, mbIsColumns );
 
 }
 
@@ -1377,7 +1379,7 @@ ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const
 
 {
     uno::Reference< container::XIndexAccess >  xIndex( mxRanges, uno::UNO_QUERY_THROW );
-    m_Areas	 = new ScVbaRangeAreas( mxContext, xIndex, mbIsRows, mbIsColumns );
+    m_Areas	 = new ScVbaRangeAreas( xParent, mxContext, xIndex, mbIsRows, mbIsColumns );
 
 }
 
@@ -1806,11 +1808,11 @@ ScVbaRange::Offset( const ::uno::Any &nRowOff, const uno::Any &nColOff ) throw (
     if ( aCellRanges.Count() > 1 ) // Multi-Area
     {
         uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pUnoRangesBase->GetDocShell(), aCellRanges ) );
-        return new ScVbaRange( getParent(), mxContext, xRanges );
+        return new ScVbaRange( mxParent, mxContext, xRanges );
     }
     // normal range
     uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), *aCellRanges.First() ) );
-    return new ScVbaRange( getParent(), mxContext, xRange  );
+    return new ScVbaRange( mxParent, mxContext, xRange  );
 }
 
 uno::Reference< excel::XRange >
@@ -1831,7 +1833,7 @@ ScVbaRange::CurrentRegion() throw (uno::RuntimeException)
         helper.getSheetCellCursor();
     xSheetCellCursor->collapseToCurrentRegion();
     uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
-    return RangeHelper::createRangeFromRange( mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );	
+    return RangeHelper::createRangeFromRange( mxParent, mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );	
 }
 
 uno::Reference< excel::XRange >
@@ -1851,7 +1853,7 @@ ScVbaRange::CurrentArray() throw (uno::RuntimeException)
         helper.getSheetCellCursor();
     xSheetCellCursor->collapseToCurrentArray();
     uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
-    return RangeHelper::createRangeFromRange( mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );	
+    return RangeHelper::createRangeFromRange( mxParent, mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );	
 }
 
 uno::Any
@@ -2069,7 +2071,7 @@ ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) thr
     uno::Reference< table::XCellRange > xSheetRange = thisRange.getCellRangeFromSheet();
     if( !bIsIndex && !bIsColumnIndex ) // .Cells
         // #FIXE needs proper parent ( Worksheet )
-        return uno::Reference< excel::XRange >( new ScVbaRange( uno::Reference< XHelperInterface >(), mxContext, mxRange ) );
+        return uno::Reference< excel::XRange >( new ScVbaRange( mxParent, mxContext, mxRange ) );
 
     sal_Int32 nIndex = --nRow;
     if( bIsIndex && !bIsColumnIndex ) // .Cells(n)
@@ -2087,7 +2089,7 @@ ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) thr
         --nColumn;
     nRow = nRow + thisRangeAddress.StartRow;
     nColumn =  nColumn + thisRangeAddress.StartColumn;	
-    return new ScVbaRange( getParent(), mxContext, xSheetRange->getCellRangeByPosition( nColumn, nRow,                                        nColumn, nRow ) );
+    return new ScVbaRange( mxParent, mxContext, xSheetRange->getCellRangeByPosition( nColumn, nRow,                                        nColumn, nRow ) );
 }
 
 void
@@ -2239,12 +2241,12 @@ ScVbaRange::Rows(const uno::Any& aIndex ) throw (uno::RuntimeException)
             throw uno::RuntimeException( rtl::OUString::createFromAscii("Internal failure, illegal param"), uno::Reference< uno::XInterface >() );
         // return a normal range ( even for multi-selection
         uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), aRange ) );
-        return new ScVbaRange( getParent(), mxContext, xRange, true  );
+        return new ScVbaRange( mxParent, mxContext, xRange, true  );
     }
     // Rows() - no params
     if ( m_Areas->getCount() > 1 )
-        return new ScVbaRange(  getParent(), mxContext, mxRanges, true );
-    return new ScVbaRange(  getParent(), mxContext, mxRange, true );
+        return new ScVbaRange(  mxParent, mxContext, mxRanges, true );
+    return new ScVbaRange(  mxParent, mxContext, mxRange, true );
 }	
 
 uno::Reference< excel::XRange >
@@ -2286,9 +2288,8 @@ ScVbaRange::Columns(const uno::Any& aIndex ) throw (uno::RuntimeException)
             throw uno::RuntimeException( rtl::OUString::createFromAscii("Internal failure, illegal param"), uno::Reference< uno::XInterface >() );
     }
     // Columns() - no params
-    //return new ScVbaRange(  getParent(), mxContext, mxRange, false, true );
     uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), aRange ) );
-    return new ScVbaRange( getParent(), mxContext, xRange, false, true  );
+    return new ScVbaRange( mxParent, mxContext, xRange, false, true  );
 }	
 
 void
@@ -2473,7 +2474,7 @@ ScVbaRange::Resize( const uno::Any &RowSize, const uno::Any &ColumnSize ) throw
     xCursor->collapseToSize( nColumnSize, nRowSize );
     uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xCursor, ::uno::UNO_QUERY_THROW );
     uno::Reference< table::XCellRange > xRange( xSheetRange->getSpreadsheet(), ::uno::UNO_QUERY_THROW );
-    return new ScVbaRange( getParent(), mxContext,xRange->getCellRangeByPosition(
+    return new ScVbaRange( mxParent, mxContext,xRange->getCellRangeByPosition(
                                         xCellRangeAddressable->getRangeAddress().StartColumn,
                                         xCellRangeAddressable->getRangeAddress().StartRow,
                                         xCellRangeAddressable->getRangeAddress().EndColumn,
@@ -2580,7 +2581,7 @@ ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseI
         Cell1 >>= sName;
         RangeHelper referRange( xReferrer );		
         table::CellRangeAddress referAddress = referRange.getCellRangeAddressable()->getRangeAddress();
-        return getRangeForName( getParent(), mxContext, sName, getScDocShell(), referAddress );
+        return getRangeForName( mxContext, sName, getScDocShell(), referAddress );
  
     }
     else
@@ -2637,7 +2638,7 @@ ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseI
         }
     }
         
-    return new ScVbaRange( getParent(), mxContext, xCellRange );
+    return new ScVbaRange( mxParent, mxContext, xCellRange );
 
 }
 
@@ -2772,10 +2773,10 @@ ScVbaRange::getEntireColumnOrRow( bool bColumn ) throw (uno::RuntimeException)
     {
         uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pUnoRangesBase->GetDocShell(), aCellRanges ) );
         
-        return new ScVbaRange( getParent(), mxContext, xRanges, !bColumn, bColumn );
+        return new ScVbaRange( mxParent, mxContext, xRanges, !bColumn, bColumn );
     }
     uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), *aCellRanges.First() ) );
-    return new ScVbaRange( getParent(), mxContext, xRange, !bColumn, bColumn  );
+    return new ScVbaRange( mxParent, mxContext, xRange, !bColumn, bColumn  );
 }
 
 uno::Reference< excel::XRange > SAL_CALL 
@@ -3121,7 +3122,7 @@ ScVbaRange::Find( const uno::Any& What, const uno::Any& After, const uno::Any& L
         uno::Reference< table::XCellRange > xCellRange( xInterface, uno::UNO_QUERY );
         if ( xCellRange.is() )
         {
-            uno::Reference< excel::XRange > xResultRange = new ScVbaRange( this, mxContext, xCellRange );
+            uno::Reference< excel::XRange > xResultRange = new ScVbaRange( mxParent, mxContext, xCellRange );
             if( xResultRange.is() )
             {
                 xResultRange->Select();
@@ -3148,7 +3149,7 @@ uno::Reference< table::XCellRange > processKey( const uno::Any& Key, uno::Refere
         table::CellRangeAddress  aRefAddr;
         if ( !pDocSh )
             throw uno::RuntimeException( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Range::Sort no docshell to calculate key param")), uno::Reference< uno::XInterface >() );
-        xKeyRange = getRangeForName( uno::Reference< XHelperInterface >(), xContext, sRangeName, pDocSh, aRefAddr );
+        xKeyRange = getRangeForName( xContext, sRangeName, pDocSh, aRefAddr );
     }
     else
         throw uno::RuntimeException( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Range::Sort illegal type value for key param")), uno::Reference< uno::XInterface >() );
@@ -3582,7 +3583,7 @@ ScVbaRange::createEnumeration() throw (uno::RuntimeException)
                 return new ColumnsRowEnumeration( mxContext, xRange, nElems );
         
     }
-    return new CellsEnumeration( mxContext, m_Areas );
+    return new CellsEnumeration( mxParent, mxContext, m_Areas );
 }
 
 ::rtl::OUString SAL_CALL 
@@ -4073,15 +4074,14 @@ ScVbaRange::ApplicationRange( const uno::Reference< uno::XComponentContext >& xC
             uno::Reference< table::XCellRange > xRange = xReferrer->getReferredCells();
             if ( xRange.is() )
             {
-                // #FIXME need proper (WorkSheet) parent
-                uno::Reference< excel::XRange > xVbRange =  new  ScVbaRange( uno::Reference< XHelperInterface >(), xContext, xRange );
+                uno::Reference< excel::XRange > xVbRange =  new ScVbaRange( excel::getUnoSheetModuleObj( xRange ), xContext, xRange );
                 return xVbRange;
             }
         }
     }
     uno::Reference< sheet::XSpreadsheetView > xView( getCurrentExcelDoc(xContext)->getCurrentController(), uno::UNO_QUERY );
     uno::Reference< table::XCellRange > xSheetRange( xView->getActiveSheet(), uno::UNO_QUERY_THROW ); 
-    ScVbaRange* pRange = new ScVbaRange( uno::Reference< XHelperInterface >(), xContext, xSheetRange );
+    ScVbaRange* pRange = new ScVbaRange( excel::getUnoSheetModuleObj( xSheetRange ), xContext, xSheetRange );
     uno::Reference< excel::XRange > xVbSheetRange( pRange );
     return pRange->Range( Cell1, Cell2, true ); 
 }
@@ -4569,7 +4569,7 @@ ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& CopyOrigin ) throw (u
         // After the insert ( this range ) actually has moved
         ScRange aRange( static_cast< SCCOL >( thisAddress.StartColumn ), static_cast< SCROW >( thisAddress.StartRow ), static_cast< SCTAB >( thisAddress.Sheet ), static_cast< SCCOL >( thisAddress.EndColumn ), static_cast< SCROW >( thisAddress.EndRow ), static_cast< SCTAB >( thisAddress.Sheet ) );
          uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getDocShellFromRange( mxRange ) , aRange ) );
-        uno::Reference< excel::XRange > xVbaRange( new ScVbaRange( getParent(), mxContext, xRange, mbIsRows, mbIsColumns ) );	
+        uno::Reference< excel::XRange > xVbaRange( new ScVbaRange( mxParent, mxContext, xRange, mbIsRows, mbIsColumns ) );	
         xVbaRange->PasteSpecial( uno::Any(), uno::Any(), uno::Any(), uno::Any() );
     }
 }
@@ -4955,18 +4955,18 @@ ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeExceptio
             if( aCellAddress.StartColumn ==0 && aCellAddress.EndColumn==0 &&
                 aCellAddress.StartRow==0 && aCellAddress.EndRow==0)
             {
-                return new ScVbaRange( getParent(),mxContext,mxRange );
+                return new ScVbaRange( mxParent,mxContext,mxRange );
             }
             else
             {
                 ScRange refRange( static_cast< SCCOL >( aCellAddress.StartColumn ), static_cast< SCROW >( aCellAddress.StartRow ), static_cast< SCTAB >( aCellAddress.Sheet ), 
                                   static_cast< SCCOL >( aCellAddress.EndColumn ), static_cast< SCROW >( aCellAddress.EndRow ), static_cast< SCTAB >( aCellAddress.Sheet ) );
                 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell() , refRange ) );
-                return new ScVbaRange( getParent(),mxContext,xRange );
+                return new ScVbaRange( mxParent, mxContext,xRange );
             }
         }
     }
-    return new ScVbaRange( getParent(),mxContext,mxRange );
+    return new ScVbaRange( mxParent, mxContext, mxRange );
 }
 
 void SAL_CALL 
@@ -5359,7 +5359,7 @@ ScVbaRange::PreviousNext( bool bIsPrevious )
 
     uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell() , refRange ) );
     
-    return new ScVbaRange( getParent(), mxContext, xRange );
+    return new ScVbaRange( mxParent, mxContext, xRange );
 }
 
 uno::Reference< excel::XRange > SAL_CALL 
@@ -5442,13 +5442,11 @@ ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue) throw
                 if ( aCellRanges.First() == aCellRanges.Last() )
                 {
                     uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell(), *aCellRanges.First() ) );
-                // #FIXME need proper (WorkSheet) parent
-                    return new ScVbaRange( getParent(), mxContext, xRange );
+                    return new ScVbaRange( mxParent, mxContext, xRange );
                 }
                 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( getScDocShell(), aCellRanges ) );
      
-                // #FIXME need proper (WorkSheet) parent
-                return new ScVbaRange( getParent(), mxContext, xRanges );
+                return new ScVbaRange( mxParent, mxContext, xRanges );
             }
             else if ( bIsSingleCell )
             {
diff --git a/sc/source/ui/vba/vbarange.hxx b/sc/source/ui/vba/vbarange.hxx
index bf8c54521..14f0bde9e 100644
--- a/sc/source/ui/vba/vbarange.hxx
+++ b/sc/source/ui/vba/vbarange.hxx
@@ -145,7 +145,6 @@ public:
     bool isSingleCellRange(); 
 
     static css::uno::Reference< ov::excel::XRange > getRangeObjectForName(
-        const css::uno::Reference< ov::XHelperInterface >& xParent,
         const css::uno::Reference< css::uno::XComponentContext >& xContext,
         const rtl::OUString& sRangeName, ScDocShell* pDocSh,
         formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1  ) throw ( css::uno::RuntimeException );
diff --git a/sc/source/ui/vba/vbaworkbooks.cxx b/sc/source/ui/vba/vbaworkbooks.cxx
index a39358e3e..abcff81f9 100644
--- a/sc/source/ui/vba/vbaworkbooks.cxx
+++ b/sc/source/ui/vba/vbaworkbooks.cxx
@@ -46,6 +46,10 @@
 #include <com/sun/star/document/XTypeDetection.hpp>
 #include <com/sun/star/uri/XUriReference.hpp>
 #include <com/sun/star/uri/XUriReferenceFactory.hpp>
+#include <com/sun/star/script/XVBACompat.hpp>
+#include <com/sun/star/script/XVBAModuleInfo.hpp>
+#include <com/sun/star/script/ModuleInfo.hpp>
+#include <com/sun/star/script/ModuleType.hpp>
 
 #include <sfx2/objsh.hxx>
 #include <tools/urlobj.hxx>
@@ -56,21 +60,100 @@
 #include <vbahelper/vbahelper.hxx>
 
 #include <hash_map>
+#include <vector>
 #include <osl/file.hxx>
 using namespace ::ooo::vba;
 using namespace ::com::sun::star;
 
 const sal_Int16 CUSTOM_CHAR = 5;
 
+void setUpDocumentModules( const uno::Reference< sheet::XSpreadsheetDocument >& xDoc )
+{
+    uno::Reference< frame::XModel > xModel( xDoc, uno::UNO_QUERY );
+    ScDocShell* pShell = excel::getDocShell( xModel );
+    if ( pShell )
+    {
+        uno::Reference<script::XLibraryContainer> xLibContainer = pShell->GetBasicContainer();
+        uno::Reference<script::XVBACompat> xVBACompat( xLibContainer, uno::UNO_QUERY_THROW );
+        xVBACompat->setVBACompatModeOn( sal_True );
+        String aPrjName( RTL_CONSTASCII_USTRINGPARAM( "VBAProject" ) );
+        pShell->GetBasicManager()->SetName( aPrjName );
+
+        if( xLibContainer.is() )
+        {
+        if( !xLibContainer->hasByName( aPrjName ) )
+                xLibContainer->createLibrary( aPrjName );    
+            uno::Any aLibAny = xLibContainer->getByName( aPrjName );
+            uno::Reference< container::XNameContainer > xLib;
+        aLibAny >>= xLib;
+            if( xLib.is()  )
+            {           
+                uno::Reference< script::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY_THROW );
+                uno::Reference< lang::XMultiServiceFactory> xSF( pShell->GetModel(), uno::UNO_QUERY_THROW);
+                // bootstrap vbaglobals
+                 xSF->createInstance( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.VBAGlobals")));
+                uno::Reference< container::XNameAccess > xVBACodeNamedObjectAccess( xSF->createInstance( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.VBAObjectModuleObjectProvider"))), uno::UNO_QUERY_THROW );
+                // set up the module info for the workbook and sheets in the nealy created
+                // spreadsheet
+                ScDocument* pDoc = pShell->GetDocument();
+                String sCodeName = pDoc->GetCodeName();
+                if ( sCodeName.Len() == 0 )
+                {
+                    sCodeName = String( RTL_CONSTASCII_USTRINGPARAM("ThisWorkbook") );
+                    pDoc->SetCodeName( sCodeName );
+                }
+
+                std::vector< rtl::OUString > sDocModuleNames;
+                sDocModuleNames.push_back( sCodeName );
+
+                uno::Reference<container::XNameAccess > xSheets( xDoc->getSheets(), uno::UNO_QUERY_THROW );
+                uno::Sequence< rtl::OUString > sSheets( xSheets->getElementNames() );
+
+                for ( sal_Int32 index=0; index < sSheets.getLength() ; ++index )
+                {
+                    sDocModuleNames.push_back( sSheets[ index ] );
+                }
+
+                std::vector<rtl::OUString>::iterator it_end = sDocModuleNames.end();
+
+                for ( std::vector<rtl::OUString>::iterator it = sDocModuleNames.begin(); it != it_end; ++it )
+                {
+                    script::ModuleInfo sModuleInfo;
+    
+                    sModuleInfo.ModuleObject.set( xVBACodeNamedObjectAccess->getByName( *it ), uno::UNO_QUERY );
+                    sModuleInfo.ModuleType = script::ModuleType::DOCUMENT;
+                    xVBAModuleInfo->insertModuleInfo( *it, sModuleInfo );
+                    if( xLib->hasByName( *it ) )
+                        xLib->replaceByName( *it, uno::makeAny( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "Option VBASupport 1\n") ) ) );
+                    else
+                        xLib->insertByName( *it, uno::makeAny( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "Option VBASupport 1\n" ) ) ) );
+                }
+            }
+        } 
+    }
+}
+
 static uno::Any
-getWorkbook( uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSpreadsheetDocument > &xDoc, const uno::Any& aApplication )
+getWorkbook( uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSpreadsheetDocument > &xDoc, const uno::Reference< XHelperInterface >& xParent )
 {
     // FIXME: fine as long as ScVbaWorkbook is stateless ...
     uno::Reference< frame::XModel > xModel( xDoc, uno::UNO_QUERY );
     if( !xModel.is() )
         return uno::Any();
     
-    ScVbaWorkbook *pWb = new ScVbaWorkbook(  uno::Reference< XHelperInterface >( aApplication, uno::UNO_QUERY_THROW ), xContext, xModel );
+    ScDocShell* pShell = excel::getDocShell( xModel );
+    if ( pShell )
+    {
+        String sCodeName = pShell->GetDocument()->GetCodeName();
+        uno::Reference< uno::XInterface > xIf = getUnoDocModule( sCodeName, pShell );
+                if ( xIf.is() )
+                {
+                    OSL_TRACE(" *** Returning Module uno Object *** ");
+                    return  uno::makeAny( xIf );
+                }
+    }
+
+    ScVbaWorkbook *pWb = new ScVbaWorkbook(  xParent, xContext, xModel );
     return uno::Any( uno::Reference< excel::XWorkbook > (pWb) );
 }
 
@@ -78,12 +161,12 @@ class WorkBookEnumImpl : public EnumerationHelperImpl
 {
     uno::Any m_aApplication;
 public:
-    WorkBookEnumImpl( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, const uno::Any& aApplication ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ), m_aApplication( aApplication ) {}
+    WorkBookEnumImpl( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, const uno::Any& aApplication ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), m_aApplication( aApplication ) {}
 
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     { 
         uno::Reference< sheet::XSpreadsheetDocument > xDoc( m_xEnumeration->nextElement(), uno::UNO_QUERY_THROW );
-        return getWorkbook( m_xContext, xDoc, m_aApplication );
+        return getWorkbook( m_xContext, xDoc, m_xParent );
     }
 
 };
@@ -105,14 +188,14 @@ ScVbaWorkbooks::createEnumeration() throw (uno::RuntimeException)
     // safer to create an enumeration based on this objects state
     // rather than one effectively based of the desktop component
     uno::Reference< container::XEnumerationAccess > xEnumerationAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
-    return new WorkBookEnumImpl( mxContext, xEnumerationAccess->createEnumeration(), Application() );
+    return new WorkBookEnumImpl( mxParent, mxContext, xEnumerationAccess->createEnumeration(), Application() );
 }
 
 uno::Any
 ScVbaWorkbooks::createCollectionObject( const css::uno::Any& aSource )
 {
     uno::Reference< sheet::XSpreadsheetDocument > xDoc( aSource, uno::UNO_QUERY_THROW );
-    return getWorkbook( mxContext, xDoc, Application() );
+    return getWorkbook( mxContext, xDoc, mxParent );
 }
 
 
@@ -120,9 +203,11 @@ uno::Any SAL_CALL
 ScVbaWorkbooks::Add() throw (uno::RuntimeException)
 {
     uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( VbaDocumentsBase::Add() , uno::UNO_QUERY_THROW );
-                                                                                                                             
+
+    // need to set up the document modules ( and vba mode ) here                                
+    setUpDocumentModules( xSpreadDoc );
     if( xSpreadDoc.is() )
-        return getWorkbook( mxContext, xSpreadDoc, Application() );
+        return getWorkbook( mxContext, xSpreadDoc, mxParent );
     return uno::Any();
 }
 
@@ -249,7 +334,7 @@ ScVbaWorkbooks::Open( const rtl::OUString& rFileName, const uno::Any& /*UpdateLi
         throw uno::RuntimeException( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Bad Format")), uno::Reference< uno::XInterface >() );
     
     uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( VbaDocumentsBase::Open( rFileName, ReadOnly, sProps ), uno::UNO_QUERY_THROW );
-    uno::Any aRet = getWorkbook( mxContext, xSpreadDoc, Application() );
+    uno::Any aRet = getWorkbook( mxContext, xSpreadDoc, mxParent );
     uno::Reference< excel::XWorkbook > xWBook( aRet, uno::UNO_QUERY );
     if ( xWBook.is() )
         xWBook->Activate();
diff --git a/sc/source/ui/vba/vbaworksheets.cxx b/sc/source/ui/vba/vbaworksheets.cxx
index c183a0f6c..85ed97c00 100644
--- a/sc/source/ui/vba/vbaworksheets.cxx
+++ b/sc/source/ui/vba/vbaworksheets.cxx
@@ -52,6 +52,7 @@
 #include "vbaglobals.hxx"
 #include "vbaworksheet.hxx"
 #include "vbaworkbook.hxx"
+#include <unonames.hxx>
 
 using namespace ::ooo::vba;
 using namespace ::com::sun::star;
@@ -63,6 +64,27 @@ typedef ::cppu::WeakImplHelper3< container::XNameAccess, container::XIndexAccess
 // (as added ) of the items
 typedef std::vector< uno::Reference< sheet::XSpreadsheet > >  SheetMap;
 
+
+// #FIXME #TODO the implementation of the Sheets collections sucks,
+// e.g. there is no support for tracking sheets added/removed from the collection
+
+uno::Reference< uno::XInterface > 
+lcl_getModulAsUnoObject( const uno::Reference< sheet::XSpreadsheet >& xSheet, const uno::Reference< frame::XModel >& xModel ) throw ( uno::RuntimeException )
+{
+    uno::Reference< uno::XInterface > xRet;
+    if ( !xSheet.is() )
+        throw uno::RuntimeException();
+    uno::Reference< beans::XPropertySet > xProps( xSheet, uno::UNO_QUERY_THROW );
+    rtl::OUString sName;
+    xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_CODENAME ) ) ) >>= sName;
+
+    ScDocShell* pShell = excel::getDocShell( xModel );
+    
+    if ( pShell )
+        xRet = getUnoDocModule(  sName, pShell );
+    return xRet;
+}
+
 class WorkSheetsEnumeration : public SheetEnumeration_BASE
 {
     SheetMap mSheetMap;
@@ -145,14 +167,24 @@ public:
 class SheetsEnumeration : public EnumerationHelperImpl
 {
     uno::Reference< frame::XModel > m_xModel;
-    uno::WeakReference< XHelperInterface > m_xParent;
 public:
-    SheetsEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration,  const uno::Reference< frame::XModel >& xModel  ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xContext, xEnumeration ), m_xModel( xModel ), m_xParent( xParent ) {}
+    SheetsEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration,  const uno::Reference< frame::XModel >& xModel  ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), m_xModel( xModel ) {}
 
     virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) 
     { 
         uno::Reference< sheet::XSpreadsheet > xSheet( m_xEnumeration->nextElement(), uno::UNO_QUERY_THROW );
-        return uno::makeAny( uno::Reference< excel::XWorksheet > ( new ScVbaWorksheet( m_xParent, m_xContext, xSheet, m_xModel ) ) );
+        uno::Reference< uno::XInterface > xIf = lcl_getModulAsUnoObject( xSheet, m_xModel );
+        uno::Any aRet;
+        if ( !xIf.is() )
+                {
+            // if the Sheet is in a document created by the api unfortunately ( at the 
+            // moment, it actually wont have the special Document modules
+            uno::Reference< excel::XWorksheet > xNewSheet( new ScVbaWorksheet( m_xParent, m_xContext, xSheet, m_xModel ) );
+            aRet <<= xNewSheet; 
+                }
+                else
+            aRet <<= xIf; 
+        return aRet;
     }
 
 };
@@ -188,7 +220,18 @@ uno::Any
 ScVbaWorksheets::createCollectionObject( const uno::Any& aSource )
 {
     uno::Reference< sheet::XSpreadsheet > xSheet( aSource, uno::UNO_QUERY );
-    return uno::makeAny( uno::Reference< excel::XWorksheet > ( new ScVbaWorksheet( getParent(), mxContext, xSheet, mxModel ) ) );
+    uno::Reference< XInterface > xIf = lcl_getModulAsUnoObject( xSheet, mxModel );
+    uno::Any aRet;
+    if ( !xIf.is() )
+    {
+        // if the Sheet is in a document created by the api unfortunately ( at the 
+        // moment, it actually wont have the special Document modules
+        uno::Reference< excel::XWorksheet > xNewSheet( new ScVbaWorksheet( getParent(), mxContext, xSheet, mxModel ) );
+        aRet <<= xNewSheet;
+    }
+    else
+        aRet <<= xIf;
+    return aRet;
 }
 
 // XWorksheets