#i102750# renamed several classes to make them sound more associated with database ranges.

8 files changed, 69 insertions, 69 deletions

diff --git a/sc/source/core/data/dociter.cxx b/sc/source/core/data/dociter.cxx
index f130d22ebc1d..7434588f093c 100644
--- a/sc/source/core/data/dociter.cxx
+++ b/sc/source/core/data/dociter.cxx
@@ -484,17 +484,17 @@ BOOL ScValueIterator::GetNext(double& rValue, USHORT& rErr)
 
 // ============================================================================
 
-ScQueryValueIterator::DataAccess::DataAccess()
+ScDBQueryValueIterator::DataAccess::DataAccess()
 {
 }
 
-ScQueryValueIterator::DataAccess::~DataAccess()
+ScDBQueryValueIterator::DataAccess::~DataAccess()
 {
 }
 
 // ----------------------------------------------------------------------------
 
-ScQueryValueIterator::DataAccessInternal::DataAccessInternal(const ScDBQueryParamInternal* pParam, ScDocument* pDoc) :
+ScDBQueryValueIterator::DataAccessInternal::DataAccessInternal(const ScDBQueryParamInternal* pParam, ScDocument* pDoc) :
     mpParam(pParam),
     mpDoc(pDoc)
 {
@@ -517,11 +517,11 @@ ScQueryValueIterator::DataAccessInternal::DataAccessInternal(const ScDBQueryPara
     nAttrEndRow = 0;
 }
 
-ScQueryValueIterator::DataAccessInternal::~DataAccessInternal()
+ScDBQueryValueIterator::DataAccessInternal::~DataAccessInternal()
 {
 }
 
-bool ScQueryValueIterator::DataAccessInternal::getCurrent(double& rValue, USHORT& rErr)
+bool ScDBQueryValueIterator::DataAccessInternal::getCurrent(double& rValue, USHORT& rErr)
 {
     ScColumn* pCol = &(mpDoc->pTab[nTab])->aCol[nCol];
     SCCOLROW nFirstQueryField = mpParam->GetEntry(0).nField;
@@ -604,7 +604,7 @@ bool ScQueryValueIterator::DataAccessInternal::getCurrent(double& rValue, USHORT
     return false;
 }
 
-bool ScQueryValueIterator::DataAccessInternal::getFirst(double& rValue, USHORT& rErr)
+bool ScDBQueryValueIterator::DataAccessInternal::getFirst(double& rValue, USHORT& rErr)
 {
     if (mpParam->bHasHeader)
         nRow++;
@@ -614,7 +614,7 @@ bool ScQueryValueIterator::DataAccessInternal::getFirst(double& rValue, USHORT&
     return getCurrent(rValue, rErr);
 }
 
-bool ScQueryValueIterator::DataAccessInternal::getNext(double& rValue, USHORT& rErr)
+bool ScDBQueryValueIterator::DataAccessInternal::getNext(double& rValue, USHORT& rErr)
 {
     ++nRow;
     return getCurrent(rValue, rErr);
@@ -622,33 +622,33 @@ bool ScQueryValueIterator::DataAccessInternal::getNext(double& rValue, USHORT& r
 
 // ----------------------------------------------------------------------------
 
-ScQueryValueIterator::DataAccessMatrix::DataAccessMatrix(const ScDBQueryParamMatrix* pParam) :
+ScDBQueryValueIterator::DataAccessMatrix::DataAccessMatrix(const ScDBQueryParamMatrix* pParam) :
     mpParam(pParam)
 {
 }
 
-ScQueryValueIterator::DataAccessMatrix::~DataAccessMatrix()
+ScDBQueryValueIterator::DataAccessMatrix::~DataAccessMatrix()
 {
 }
 
-bool ScQueryValueIterator::DataAccessMatrix::getCurrent(double& /*rValue*/, USHORT& /*rErr*/)
+bool ScDBQueryValueIterator::DataAccessMatrix::getCurrent(double& /*rValue*/, USHORT& /*rErr*/)
 {
     return false;
 }
 
-bool ScQueryValueIterator::DataAccessMatrix::getFirst(double& /*rValue*/, USHORT& /*rErr*/)
+bool ScDBQueryValueIterator::DataAccessMatrix::getFirst(double& /*rValue*/, USHORT& /*rErr*/)
 {
     return false;
 }
 
-bool ScQueryValueIterator::DataAccessMatrix::getNext(double& /*rValue*/, USHORT& /*rErr*/)
+bool ScDBQueryValueIterator::DataAccessMatrix::getNext(double& /*rValue*/, USHORT& /*rErr*/)
 {
     return false;
 }
 
 // ----------------------------------------------------------------------------
 
-ScQueryValueIterator::ScQueryValueIterator(ScDocument* pDocument, ScDBQueryParamBase* pParam) :
+ScDBQueryValueIterator::ScDBQueryValueIterator(ScDocument* pDocument, ScDBQueryParamBase* pParam) :
     mpParam (pParam)
 {
     switch (mpParam->GetType())
@@ -667,17 +667,17 @@ ScQueryValueIterator::ScQueryValueIterator(ScDocument* pDocument, ScDBQueryParam
     }
 }
 
-bool ScQueryValueIterator::GetThis(double& rValue, USHORT& rErr)
+bool ScDBQueryValueIterator::GetThis(double& rValue, USHORT& rErr)
 {
     return mpData->getCurrent(rValue, rErr);
 }
 
-BOOL ScQueryValueIterator::GetFirst(double& rValue, USHORT& rErr)
+BOOL ScDBQueryValueIterator::GetFirst(double& rValue, USHORT& rErr)
 {
     return mpData->getFirst(rValue, rErr);
 }
 
-BOOL ScQueryValueIterator::GetNext(double& rValue, USHORT& rErr)
+BOOL ScDBQueryValueIterator::GetNext(double& rValue, USHORT& rErr)
 {
     return mpData->getNext(rValue, rErr);
 }
diff --git a/sc/source/core/data/documen3.cxx b/sc/source/core/data/documen3.cxx
index 8de57e0b7f45..4b37aa33603e 100644
--- a/sc/source/core/data/documen3.cxx
+++ b/sc/source/core/data/documen3.cxx
@@ -1243,7 +1243,7 @@ BOOL ScDocument::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW n
     return FALSE;
 }
 
-bool ScDocument::FillQueryEntries( ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef,
+bool ScDocument::FillQueryEntries( ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef,
                                    SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCTAB nTab)
 {
     if (!pParam)
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 0b7c910a11ed..f0f92e400b8d 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -1962,7 +1962,7 @@ BOOL ScTable::CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow
 }
 
 bool ScTable::CreateExcelQuery(
-    ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef,
+    ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef,
     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
 {
     bool bValid = true;
@@ -2216,7 +2216,7 @@ BOOL ScTable::CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2
     return bValid;
 }
 
-bool ScTable::CreateStarQuery(ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
+bool ScTable::CreateStarQuery(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
 {
     // A valid StarQuery must be at least 4 columns wide. To be precise it
     // should be exactly 4 columns ...
@@ -2369,7 +2369,7 @@ BOOL ScTable::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow
 }
 
 bool ScTable::FillQueryEntries(
-    ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
+    ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
 {
     PutInOrder(nCol1, nCol2);
     PutInOrder(nRow1, nRow2);
diff --git a/sc/source/core/inc/doubleref.hxx b/sc/source/core/inc/doubleref.hxx
index 2c8a2e040335..ee7e7815abd0 100644
--- a/sc/source/core/inc/doubleref.hxx
+++ b/sc/source/core/inc/doubleref.hxx
@@ -40,28 +40,28 @@ class ScQueryParamBase;
 
 // ============================================================================
 
-class ScDoubleRefBase
+class ScDBRangeBase
 {
 public:
     enum RefType { INTERNAL, EXTERNAL };
 
-    virtual ~ScDoubleRefBase() = 0;
+    virtual ~ScDBRangeBase() = 0;
 
     RefType getType() const;
 
     virtual SCCOL getFirstFieldColumn() const = 0;
     virtual SCCOL findFieldColumn(SCCOL nColIndex) const = 0;
     virtual SCCOL findFieldColumn(const ::rtl::OUString& rStr, sal_uInt16* pErr = NULL) const = 0;
-    virtual ScDBQueryParamBase* createQueryParam(const ScDoubleRefBase* pQueryRef) const = 0;
+    virtual ScDBQueryParamBase* createQueryParam(const ScDBRangeBase* pQueryRef) const = 0;
     virtual bool isRangeEqual(const ScRange& rRange) const = 0;
-    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef) const= 0;
+    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const= 0;
 
 protected:
-    ScDoubleRefBase(ScDocument* pDoc, RefType eType);
+    ScDBRangeBase(ScDocument* pDoc, RefType eType);
     ScDocument* getDoc() const;
 
 private:
-    ScDoubleRefBase(); // disabled
+    ScDBRangeBase(); // disabled
 
     ScDocument* mpDoc;
     RefType meType;
@@ -69,20 +69,20 @@ private:
 
 // ============================================================================
 
-class ScInternalDoubleRef : public ScDoubleRefBase
+class ScDBInternalRange : public ScDBRangeBase
 {
 public:
-    explicit ScInternalDoubleRef(ScDocument* pDoc, const ScRange& rRange);
-    virtual ~ScInternalDoubleRef();
+    explicit ScDBInternalRange(ScDocument* pDoc, const ScRange& rRange);
+    virtual ~ScDBInternalRange();
 
     const ScRange& getRange() const;
 
     virtual SCCOL getFirstFieldColumn() const;
     virtual SCCOL findFieldColumn(SCCOL nColIndex) const;
     virtual SCCOL findFieldColumn(const ::rtl::OUString& rStr, sal_uInt16* pErr = NULL) const;
-    virtual ScDBQueryParamBase* createQueryParam(const ScDoubleRefBase* pQueryRef) const;
+    virtual ScDBQueryParamBase* createQueryParam(const ScDBRangeBase* pQueryRef) const;
     virtual bool isRangeEqual(const ScRange& rRange) const;
-    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef) const;
+    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const;
 
 private:
     sal_uInt16 getCellString(String& rStr, ScBaseCell* pCell) const;
@@ -93,18 +93,18 @@ private:
 
 // ============================================================================
 
-class ScExternalDoubleRef : public ScDoubleRefBase
+class ScDBExternalRange : public ScDBRangeBase
 {
 public:
-    explicit ScExternalDoubleRef(ScDocument* pDoc);
-    virtual ~ScExternalDoubleRef();
+    explicit ScDBExternalRange(ScDocument* pDoc);
+    virtual ~ScDBExternalRange();
 
     virtual SCCOL getFirstFieldColumn() const;
     virtual SCCOL findFieldColumn(SCCOL nColIndex) const;
     virtual SCCOL findFieldColumn(const ::rtl::OUString& rStr, sal_uInt16* pErr = NULL) const;
-    virtual ScDBQueryParamBase* createQueryParam(const ScDoubleRefBase* pQueryRef) const;
+    virtual ScDBQueryParamBase* createQueryParam(const ScDBRangeBase* pQueryRef) const;
     virtual bool isRangeEqual(const ScRange& rRange) const;
-    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef) const;
+    virtual bool fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const;
 };
 
 #endif
diff --git a/sc/source/core/inc/interpre.hxx b/sc/source/core/inc/interpre.hxx
index 650d02ce2aa3..6787f0492997 100644
--- a/sc/source/core/inc/interpre.hxx
+++ b/sc/source/core/inc/interpre.hxx
@@ -53,7 +53,7 @@ class SbxVariable;
 class ScBaseCell;
 class ScFormulaCell;
 class SvNumberFormatter;
-class ScDoubleRefBase;
+class ScDBRangeBase;
 struct MatrixDoubleOp;
 struct ScQueryParam;
 
@@ -303,7 +303,7 @@ void DoubleRefToVars( const ScToken* p,
         SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,
         SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2,
         BOOL bDontCheckForTableOp = FALSE );
-ScDoubleRefBase* PopDoubleRef();
+ScDBRangeBase* PopDoubleRef();
 void PopDoubleRef(SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,
                           SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2,
                           BOOL bDontCheckForTableOp = FALSE );
diff --git a/sc/source/core/tool/doubleref.cxx b/sc/source/core/tool/doubleref.cxx
index 4dfa75d3a78b..1106b88f3678 100644
--- a/sc/source/core/tool/doubleref.cxx
+++ b/sc/source/core/tool/doubleref.cxx
@@ -46,47 +46,47 @@ using ::std::auto_ptr;
 
 // ============================================================================
 
-ScDoubleRefBase::ScDoubleRefBase(ScDocument* pDoc, RefType eType) :
+ScDBRangeBase::ScDBRangeBase(ScDocument* pDoc, RefType eType) :
     mpDoc(pDoc), meType(eType)
 {
 }
 
-ScDoubleRefBase::~ScDoubleRefBase()
+ScDBRangeBase::~ScDBRangeBase()
 {
 }
 
-ScDoubleRefBase::RefType ScDoubleRefBase::getType() const
+ScDBRangeBase::RefType ScDBRangeBase::getType() const
 {
     return meType;
 }
 
-ScDocument* ScDoubleRefBase::getDoc() const
+ScDocument* ScDBRangeBase::getDoc() const
 {
     return mpDoc;
 }
 
 // ============================================================================
 
-ScInternalDoubleRef::ScInternalDoubleRef(ScDocument* pDoc, const ScRange& rRange) :
-    ScDoubleRefBase(pDoc, INTERNAL), maRange(rRange)
+ScDBInternalRange::ScDBInternalRange(ScDocument* pDoc, const ScRange& rRange) :
+    ScDBRangeBase(pDoc, INTERNAL), maRange(rRange)
 {
 }
 
-ScInternalDoubleRef::~ScInternalDoubleRef()
+ScDBInternalRange::~ScDBInternalRange()
 {
 }
 
-const ScRange& ScInternalDoubleRef::getRange() const
+const ScRange& ScDBInternalRange::getRange() const
 {
     return maRange;
 }
 
-SCCOL ScInternalDoubleRef::getFirstFieldColumn() const
+SCCOL ScDBInternalRange::getFirstFieldColumn() const
 {
     return getRange().aStart.Col();
 }
 
-SCCOL ScInternalDoubleRef::findFieldColumn(SCCOL nColIndex) const
+SCCOL ScDBInternalRange::findFieldColumn(SCCOL nColIndex) const
 {
     const ScRange& rRange = getRange();
     const ScAddress& s = rRange.aStart;
@@ -101,7 +101,7 @@ SCCOL ScInternalDoubleRef::findFieldColumn(SCCOL nColIndex) const
     return Min(nDBCol2, static_cast<SCCOL>(nDBCol1 + nColIndex - 1));
 }
 
-sal_uInt16 ScInternalDoubleRef::getCellString(String& rStr, ScBaseCell* pCell) const
+sal_uInt16 ScDBInternalRange::getCellString(String& rStr, ScBaseCell* pCell) const
 {
     sal_uInt16 nErr = 0;
     if (pCell)
@@ -151,7 +151,7 @@ sal_uInt16 ScInternalDoubleRef::getCellString(String& rStr, ScBaseCell* pCell) c
     return nErr;
 }
 
-SCCOL ScInternalDoubleRef::findFieldColumn(const OUString& rStr, sal_uInt16* pErr) const
+SCCOL ScDBInternalRange::findFieldColumn(const OUString& rStr, sal_uInt16* pErr) const
 {
     const ScAddress& s = maRange.aStart;
     const ScAddress& e = maRange.aEnd;
@@ -182,7 +182,7 @@ SCCOL ScInternalDoubleRef::findFieldColumn(const OUString& rStr, sal_uInt16* pEr
     return bFound ? nField : -1;
 }
 
-ScDBQueryParamBase* ScInternalDoubleRef::createQueryParam(const ScDoubleRefBase* pQueryRef) const
+ScDBQueryParamBase* ScDBInternalRange::createQueryParam(const ScDBRangeBase* pQueryRef) const
 {
     auto_ptr<ScDBQueryParamInternal> pParam(new ScDBQueryParamInternal);
 
@@ -208,12 +208,12 @@ ScDBQueryParamBase* ScInternalDoubleRef::createQueryParam(const ScDoubleRefBase*
     return pParam.release();
 }
 
-bool ScInternalDoubleRef::isRangeEqual(const ScRange& rRange) const
+bool ScDBInternalRange::isRangeEqual(const ScRange& rRange) const
 {
     return maRange == rRange;
 }
 
-bool ScInternalDoubleRef::fillQueryEntries(ScQueryParamBase* pParam, const ScDoubleRefBase* pDBRef) const
+bool ScDBInternalRange::fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const
 {
     if (!pDBRef)
         return false;
@@ -225,41 +225,41 @@ bool ScInternalDoubleRef::fillQueryEntries(ScQueryParamBase* pParam, const ScDou
 
 // ============================================================================
 
-ScExternalDoubleRef::ScExternalDoubleRef(ScDocument* pDoc) :
-    ScDoubleRefBase(pDoc, EXTERNAL)
+ScDBExternalRange::ScDBExternalRange(ScDocument* pDoc) :
+    ScDBRangeBase(pDoc, EXTERNAL)
 {
 }
 
-ScExternalDoubleRef::~ScExternalDoubleRef()
+ScDBExternalRange::~ScDBExternalRange()
 {
 }
 
-SCCOL ScExternalDoubleRef::getFirstFieldColumn() const
+SCCOL ScDBExternalRange::getFirstFieldColumn() const
 {
     return -1;
 }
 
-SCCOL ScExternalDoubleRef::findFieldColumn(SCCOL /*nColIndex*/) const
+SCCOL ScDBExternalRange::findFieldColumn(SCCOL /*nColIndex*/) const
 {
     return -1;
 }
 
-SCCOL ScExternalDoubleRef::findFieldColumn(const OUString& rStr, sal_uInt16* pErr) const
+SCCOL ScDBExternalRange::findFieldColumn(const OUString& /*rStr*/, sal_uInt16* /*pErr*/) const
 {
     return -1;
 }
 
-ScDBQueryParamBase* ScExternalDoubleRef::createQueryParam(const ScDoubleRefBase* /*pQueryRef*/) const
+ScDBQueryParamBase* ScDBExternalRange::createQueryParam(const ScDBRangeBase* /*pQueryRef*/) const
 {
     return NULL;
 }
 
-bool ScExternalDoubleRef::isRangeEqual(const ScRange& /*rRange*/) const
+bool ScDBExternalRange::isRangeEqual(const ScRange& /*rRange*/) const
 {
     return false;
 }
 
-bool ScExternalDoubleRef::fillQueryEntries(ScQueryParamBase* /*pParam*/, const ScDoubleRefBase* /*pDBRef*/) const
+bool ScDBExternalRange::fillQueryEntries(ScQueryParamBase* /*pParam*/, const ScDBRangeBase* /*pDBRef*/) const
 {
     return false;
 }
diff --git a/sc/source/core/tool/interpr1.cxx b/sc/source/core/tool/interpr1.cxx
index 73a436147aad..08ad107fe2ee 100644
--- a/sc/source/core/tool/interpr1.cxx
+++ b/sc/source/core/tool/interpr1.cxx
@@ -5673,7 +5673,7 @@ ScDBQueryParamBase* ScInterpreter::GetDBParams( BOOL& rMissingField )
     if ( GetByte() == 3 )
     {
         // First, get the query criteria range.
-        ::std::auto_ptr<ScDoubleRefBase> pQueryRef( PopDoubleRef() );
+        ::std::auto_ptr<ScDBRangeBase> pQueryRef( PopDoubleRef() );
         if (!pQueryRef.get())
             return NULL;
 
@@ -5738,7 +5738,7 @@ ScDBQueryParamBase* ScInterpreter::GetDBParams( BOOL& rMissingField )
                 SetError( errIllegalParameter );
         }
 
-        auto_ptr<ScDoubleRefBase> pDBRef( PopDoubleRef() );
+        auto_ptr<ScDBRangeBase> pDBRef( PopDoubleRef() );
 
         if (nGlobalError || !pDBRef.get())
             return NULL;
@@ -5819,7 +5819,7 @@ void ScInterpreter::DBIterator( ScIterFunc eFunc )
     {
         double nVal;
         USHORT nErr;
-        ScQueryValueIterator aValIter(pDok, pQueryParam.release());
+        ScDBQueryValueIterator aValIter(pDok, pQueryParam.release());
         if ( aValIter.GetFirst(nVal, nErr) && !nErr )
         {
             switch( eFunc )
@@ -5914,7 +5914,7 @@ void ScInterpreter::ScDBCount()
         {   // count only matching records with a value in the "result" field
             double nVal;
             USHORT nErr = 0;
-            ScQueryValueIterator aValIter( pDok, pQueryParam.release());
+            ScDBQueryValueIterator aValIter( pDok, pQueryParam.release());
             if ( aValIter.GetFirst( nVal, nErr) && !nErr )
             {
                 do
@@ -6001,7 +6001,7 @@ void ScInterpreter::GetDBStVarParams( double& rVal, double& rValCount )
     {
         double fVal;
         USHORT nErr;
-        ScQueryValueIterator aValIter(pDok, pQueryParam.release());
+        ScDBQueryValueIterator aValIter(pDok, pQueryParam.release());
         if (aValIter.GetFirst(fVal, nErr) && !nErr)
         {
             do
diff --git a/sc/source/core/tool/interpr4.cxx b/sc/source/core/tool/interpr4.cxx
index ff25fa2a8710..02fbaba310dd 100644
--- a/sc/source/core/tool/interpr4.cxx
+++ b/sc/source/core/tool/interpr4.cxx
@@ -1060,7 +1060,7 @@ void ScInterpreter::DoubleRefToVars( const ScToken* p,
     }
 }
 
-ScDoubleRefBase* ScInterpreter::PopDoubleRef()
+ScDBRangeBase* ScInterpreter::PopDoubleRef()
 {
     if (!sp)
     {
@@ -1085,7 +1085,7 @@ ScDoubleRefBase* ScInterpreter::PopDoubleRef()
             DoubleRefToVars(static_cast<ScToken*>(p),
                             nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, false);
 
-            return new ScInternalDoubleRef(pDok,
+            return new ScDBInternalRange(pDok,
                 ScRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2));
         }
         break;