sc/source/filter/excel/namebuff.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: namebuff.cxx,v $
  10  * $Revision: 1.26.32.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 #include "namebuff.hxx"
  35
  36 #include <tools/urlobj.hxx>
  37 #include <string.h>
  38
  39 #include "rangenam.hxx"
  40 #include "document.hxx"
  41 #include "compiler.hxx"
  42 #include "scextopt.hxx"
  43
  44 #include "root.hxx"
  45 #include "tokstack.hxx"
  46 #include "xltools.hxx"
  47 #include "xiroot.hxx"
  48
  49
  50 UINT32 StringHashEntry::MakeHashCode( const String& r )
  51 {
  52     register UINT32                                     n = 0;
  53     const sal_Unicode*                          pAkt = r.GetBuffer();
  54     register sal_Unicode                        cAkt = *pAkt;
  55
  56     while( cAkt )
  57     {
  58         n *= 70;
  59         n += ( UINT32 ) cAkt;
  60         pAkt++;
  61         cAkt = *pAkt;
  62     }
  63
  64     return n;
  65 }
  66
  67
  68
  69
  70 NameBuffer::~NameBuffer()
  71 {
  72     register StringHashEntry*   pDel = ( StringHashEntry* ) List::First();
  73     while( pDel )
  74     {
  75         delete pDel;
  76         pDel = ( StringHashEntry* ) List::Next();
  77     }
  78 }
  79
  80
  81 //void NameBuffer::operator <<( const SpString &rNewString )
  82 void NameBuffer::operator <<( const String &rNewString )
  83 {
  84     DBG_ASSERT( Count() + nBase < 0xFFFF,
  85         "*NameBuffer::GetLastIndex(): Ich hab' die Nase voll!" );
  86
  87     List::Insert( new StringHashEntry( rNewString ), LIST_APPEND );
  88 }
  89
  90
  91 #ifdef DBG_UTIL
  92 UINT16  nShrCnt;
  93 #endif
  94
  95
  96 size_t ShrfmlaBuffer::ScAddressHashFunc::operator() (const ScAddress &addr) const
  97 {
  98     // Use something simple, it is just a hash.
  99     return static_cast< UINT16 >( addr.Row() ) | (static_cast< UINT8 >( addr.Col() ) << 16);
 100 }
 101
 102 const size_t nBase = 16384; // Range~ und Shared~ Dingens mit jeweils der Haelfte Ids
 103 ShrfmlaBuffer::ShrfmlaBuffer( RootData* pRD ) :
 104     ExcRoot( pRD ),
 105     mnCurrIdx (nBase)
 106 {
 107 #ifdef DBG_UTIL
 108     nShrCnt = 0;
 109 #endif
 110 }
 111
 112 ShrfmlaBuffer::~ShrfmlaBuffer()
 113 {
 114 }
 115
 116 void ShrfmlaBuffer::Clear()
 117 {
 118     index_hash.clear();
 119     // do not clear index_list, index calculation depends on complete list size...
 120     // do not change mnCurrIdx
 121 }
 122
 123 void ShrfmlaBuffer::Store( const ScRange& rRange, const ScTokenArray& rToken )
 124 {
 125     String                      aName( CreateName( rRange.aStart ) );
 126
 127     DBG_ASSERT( mnCurrIdx <= 0xFFFF, "*ShrfmlaBuffer::Store(): Gleich wird mir schlecht...!" );
 128
 129     ScRangeData* pData = new ScRangeData( pExcRoot->pIR->GetDocPtr(), aName, rToken, rRange.aStart, RT_SHARED );
 130     const ScAddress& rMaxPos = pExcRoot->pIR->GetMaxPos();
 131     pData->SetMaxCol(rMaxPos.Col());
 132     pData->SetMaxRow(rMaxPos.Row());
 133     pData->SetIndex( static_cast< USHORT >( mnCurrIdx ) );
 134     pExcRoot->pIR->GetNamedRanges().Insert( pData );
 135     index_hash[rRange.aStart] = static_cast< USHORT >( mnCurrIdx );
 136     index_list.push_front (rRange);
 137     ++mnCurrIdx;
 138 }
 139
 140
 141 USHORT ShrfmlaBuffer::Find( const ScAddress & aAddr ) const
 142 {
 143     ShrfmlaHash::const_iterator hash = index_hash.find (aAddr);
 144     if (hash != index_hash.end())
 145         return hash->second;
 146
 147     // It was not hashed on the top left corner ?  do a brute force search
 148     unsigned int ind = nBase;
 149     for (ShrfmlaList::const_iterator ptr = index_list.end(); ptr != index_list.begin() ; ind++)
 150         if ((--ptr)->In (aAddr))
 151             return static_cast< USHORT >( ind );
 152     return static_cast< USHORT >( mnCurrIdx );
 153 }
 154
 155
 156 #define SHRFMLA_BASENAME        "SHARED_FORMULA_"
 157
 158 String ShrfmlaBuffer::CreateName( const ScRange& r )
 159 {
 160     String                      aName( RTL_CONSTASCII_USTRINGPARAM( SHRFMLA_BASENAME ) );
 161     aName += String::CreateFromInt32( r.aStart.Col() );
 162     aName.Append( '_' );
 163     aName += String::CreateFromInt32( r.aStart.Row() );
 164     aName.Append( '_' );
 165     aName += String::CreateFromInt32( r.aEnd.Col() );
 166     aName.Append( '_' );
 167     aName += String::CreateFromInt32( r.aEnd.Row() );
 168     aName.Append( '_' );
 169     aName += String::CreateFromInt32( r.aStart.Tab() );
 170
 171     return aName;
 172 }
 173
 174
 175 ExtSheetBuffer::~ExtSheetBuffer()
 176 {
 177     Cont        *pAkt = ( Cont * ) List::First();
 178     while( pAkt )
 179     {
 180         delete pAkt;
 181         pAkt = ( Cont * ) List::Next();
 182     }
 183 }
 184
 185
 186 sal_Int16 ExtSheetBuffer::Add( const String& rFPAN, const String& rTN, const BOOL bSWB )
 187 {
 188     List::Insert( new Cont( rFPAN, rTN, bSWB ), LIST_APPEND );
 189     // return 1-based index of EXTERNSHEET
 190     return static_cast< sal_Int16 >( List::Count() );
 191 }
 192
 193
 194 BOOL ExtSheetBuffer::GetScTabIndex( UINT16 nExcIndex, UINT16& rScIndex )
 195 {
 196     DBG_ASSERT( nExcIndex,
 197         "*ExtSheetBuffer::GetScTabIndex(): Sheet-Index == 0!" );
 198
 199     nExcIndex--;
 200     Cont*               pCur = ( Cont * ) List::GetObject( nExcIndex );
 201     UINT16&             rTabNum = pCur->nTabNum;
 202
 203     if( pCur )
 204     {
 205         if( rTabNum < 0xFFFD )
 206         {
 207             rScIndex = rTabNum;
 208             return TRUE;
 209         }
 210
 211         if( rTabNum == 0xFFFF )
 212         {// neue Tabelle erzeugen
 213             SCTAB       nNewTabNum;
 214             if( pCur->bSWB )
 215             {// Tabelle ist im selben Workbook!
 216                 if( pExcRoot->pIR->GetDoc().GetTable( pCur->aTab, nNewTabNum ) )
 217                 {
 218                     rScIndex = rTabNum = static_cast<UINT16>(nNewTabNum);
 219                     return TRUE;
 220                 }
 221                 else
 222                     rTabNum = 0xFFFD;
 223             }
 224             else if( pExcRoot->pIR->GetDocShell() )
 225             {// Tabelle ist 'echt' extern
 226                 if( pExcRoot->pIR->GetExtDocOptions().GetDocSettings().mnLinkCnt == 0 )
 227                 {
 228                     String              aURL( ScGlobal::GetAbsDocName( pCur->aFile,
 229                                         pExcRoot->pIR->GetDocShell() ) );
 230                     String              aTabName( ScGlobal::GetDocTabName( aURL, pCur->aTab ) );
 231                     if( pExcRoot->pIR->GetDoc().LinkExternalTab( nNewTabNum, aTabName, aURL, pCur->aTab ) )
 232                     {
 233                         rScIndex = rTabNum = static_cast<UINT16>(nNewTabNum);
 234                         return TRUE;
 235                     }
 236                     else
 237                         rTabNum = 0xFFFE;               // Tabelle einmal nicht angelegt -> wird
 238                                                 //  wohl auch nicht mehr gehen...
 239                 }
 240                 else
 241                     rTabNum = 0xFFFE;
 242
 243             }
 244         }
 245     }
 246
 247     return FALSE;
 248 }
 249
 250
 251 BOOL ExtSheetBuffer::IsLink( const UINT16 nExcIndex ) const
 252 {
 253     DBG_ASSERT( nExcIndex > 0, "*ExtSheetBuffer::IsLink(): Index muss >0 sein!" );
 254     Cont*       pRet = ( Cont * ) List::GetObject( nExcIndex - 1 );
 255
 256     if( pRet )
 257         return pRet->bLink;
 258     else
 259         return FALSE;
 260 }
 261
 262
 263 BOOL ExtSheetBuffer::GetLink( const UINT16 nExcIndex, String& rAppl, String& rDoc ) const
 264 {
 265     DBG_ASSERT( nExcIndex > 0, "*ExtSheetBuffer::GetLink(): Index muss >0 sein!" );
 266     Cont*       pRet = ( Cont * ) List::GetObject( nExcIndex - 1 );
 267
 268     if( pRet )
 269     {
 270         rAppl = pRet->aFile;
 271         rDoc = pRet->aTab;
 272         return TRUE;
 273     }
 274     else
 275         return FALSE;
 276 }
 277
 278
 279 void ExtSheetBuffer::Reset( void )
 280 {
 281     Cont        *pAkt = ( Cont * ) List::First();
 282     while( pAkt )
 283     {
 284         delete pAkt;
 285         pAkt = ( Cont * ) List::Next();
 286     }
 287
 288     List::Clear();
 289 }
 290
 291
 292
 293
 294 BOOL ExtName::IsDDE( void ) const
 295 {
 296     return ( nFlags & 0x0001 ) != 0;
 297 }
 298
 299
 300 BOOL ExtName::IsOLE( void ) const
 301 {
 302     return ( nFlags & 0x0002 ) != 0;
 303 }
 304
 305
 306 ExtNameBuff::ExtNameBuff( const XclImpRoot& rRoot ) :
 307     XclImpRoot( rRoot )
 308 {
 309 }
 310
 311
 312 void ExtNameBuff::AddDDE( const String& rName, sal_Int16 nRefIdx )
 313 {
 314     ExtName aNew( rName, 0x0001 );
 315     maExtNames[ nRefIdx ].push_back( aNew );
 316 }
 317
 318
 319 void ExtNameBuff::AddOLE( const String& rName, sal_Int16 nRefIdx, UINT32 nStorageId )
 320 {
 321     ExtName aNew( rName, 0x0002 );
 322     aNew.nStorageId = nStorageId;
 323     maExtNames[ nRefIdx ].push_back( aNew );
 324 }
 325
 326
 327 void ExtNameBuff::AddName( const String& rName, sal_Int16 nRefIdx )
 328 {
 329     ExtName aNew( GetScAddInName( rName ), 0x0004 );
 330     maExtNames[ nRefIdx ].push_back( aNew );
 331 }
 332
 333
 334 const ExtName* ExtNameBuff::GetNameByIndex( sal_Int16 nRefIdx, sal_uInt16 nNameIdx ) const
 335 {
 336     DBG_ASSERT( nNameIdx > 0, "ExtNameBuff::GetNameByIndex() - invalid name index" );
 337     ExtNameMap::const_iterator aIt = maExtNames.find( nRefIdx );
 338     return ((aIt != maExtNames.end()) && (0 < nNameIdx) && (nNameIdx <= aIt->second.size())) ? &aIt->second[ nNameIdx - 1 ] : 0;
 339 }
 340
 341
 342 void ExtNameBuff::Reset( void )
 343 {
 344     maExtNames.clear();
 345 }
 346
 347