sc/source/filter/excel/excrecds.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: excrecds.cxx,v $
  10  * $Revision: 1.88 $
  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
  35
  36 //------------------------------------------------------------------------
  37
  38 #include "excrecds.hxx"
  39
  40 #include <map>
  41 #include <svx/countryid.hxx>
  42
  43 #include "scitems.hxx"
  44 #include <svx/eeitem.hxx>
  45
  46 #include <sfx2/objsh.hxx>
  47
  48 #include <svx/editdata.hxx>
  49 #include <svx/editeng.hxx>
  50 #include <svx/editobj.hxx>
  51 #include <svx/editstat.hxx>
  52
  53 #include <svx/flditem.hxx>
  54 #include <svx/flstitem.hxx>
  55
  56 #include <svx/algitem.hxx>
  57 #include <svx/boxitem.hxx>
  58 #include <svx/brshitem.hxx>
  59 #include <svx/pageitem.hxx>
  60 #include <svx/paperinf.hxx>
  61 #include <svx/sizeitem.hxx>
  62 #include <svx/ulspitem.hxx>
  63 #include <svx/fhgtitem.hxx>
  64 #include <svx/escpitem.hxx>
  65 #include <svtools/intitem.hxx>
  66 #include <svtools/zforlist.hxx>
  67 #include <svtools/zformat.hxx>
  68 #include <svtools/ctrltool.hxx>
  69
  70 #define _SVSTDARR_USHORTS
  71 #include <svtools/svstdarr.hxx>
  72
  73 #include <string.h>
  74
  75 #include "global.hxx"
  76 #include "globstr.hrc"
  77 #include "docpool.hxx"
  78 #include "patattr.hxx"
  79 #include "cell.hxx"
  80 #include "document.hxx"
  81 #include "scextopt.hxx"
  82 #include "patattr.hxx"
  83 #include "attrib.hxx"
  84 #include "progress.hxx"
  85 #include "dociter.hxx"
  86 #include "rangenam.hxx"
  87 #include "dbcolect.hxx"
  88 #include "stlsheet.hxx"
  89 #include "stlpool.hxx"
  90 #include "editutil.hxx"
  91 #include "formula/errorcodes.hxx"
  92
  93 #include "excdoc.hxx"
  94 #include "xeformula.hxx"
  95 #include "xelink.hxx"
  96 #include "xename.hxx"
  97 #include "xecontent.hxx"
  98
  99 #include "xcl97rec.hxx"
 100
 101 #include <oox/core/tokens.hxx>
 102
 103 using ::com::sun::star::uno::Sequence;
 104
 105
 106 using ::rtl::OString;
 107
 108 //--------------------------------------------------------- class ExcDummy_00 -
 109 const BYTE              ExcDummy_00::pMyData[] = {
 110     0xe1, 0x00, 0x00, 0x00,                                                                     // INTERFACEHDR
 111     0xc1, 0x00, 0x02, 0x00, 0x00, 0x00,                                         // MMS
 112     0xbf, 0x00, 0x00, 0x00,                                                                     // TOOLBARHDR
 113     0xc0, 0x00, 0x00, 0x00,                                                                     // TOOLBAREND
 114     0xe2, 0x00, 0x00, 0x00,                                                                     // INTERFACEEND
 115     0x5c, 0x00, 0x20, 0x00, 0x04, 0x4d, 0x72, 0x20, 0x58,       // WRITEACCESS
 116     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 117     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 118     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 119     0x42, 0x00, 0x02, 0x00, 0xe4, 0x04,                                         // CODEPAGE
 120     0x9c, 0x00, 0x02, 0x00, 0x0e, 0x00                                          // FNGROUPCOUNT
 121 };
 122 const sal_Size ExcDummy_00::nMyLen = sizeof( ExcDummy_00::pMyData );
 123
 124 //-------------------------------------------------------- class ExcDummy_04x -
 125 const BYTE              ExcDummy_040::pMyData[] = {
 126     0x40, 0x00, 0x02, 0x00, 0x00, 0x00,                                         // BACKUP
 127     0x8d, 0x00, 0x02, 0x00, 0x00, 0x00,                                         // HIDEOBJ
 128 };
 129 const sal_Size ExcDummy_040::nMyLen = sizeof( ExcDummy_040::pMyData );
 130
 131 const BYTE              ExcDummy_041::pMyData[] = {
 132     0x0e, 0x00, 0x02, 0x00, 0x01, 0x00,                                         // PRECISION
 133     0xda, 0x00, 0x02, 0x00, 0x00, 0x00                                          // BOOKBOOL
 134 };
 135 const sal_Size ExcDummy_041::nMyLen = sizeof( ExcDummy_041::pMyData );
 136
 137 //-------------------------------------------------------- class ExcDummy_02a -
 138 const BYTE      ExcDummy_02a::pMyData[] = {
 139     0x0d, 0x00, 0x02, 0x00, 0x01, 0x00,                                         // CALCMODE
 140     0x0c, 0x00, 0x02, 0x00, 0x64, 0x00,                                         // CALCCOUNT
 141     0x0f, 0x00, 0x02, 0x00, 0x01, 0x00,                                         // REFMODE
 142     0x11, 0x00, 0x02, 0x00, 0x00, 0x00,                                         // ITERATION
 143     0x10, 0x00, 0x08, 0x00, 0xfc, 0xa9, 0xf1, 0xd2, 0x4d,       // DELTA
 144     0x62, 0x50, 0x3f,
 145     0x5f, 0x00, 0x02, 0x00, 0x01, 0x00                      // SAVERECALC
 146 };
 147 const sal_Size ExcDummy_02a::nMyLen = sizeof( ExcDummy_02a::pMyData );
 148
 149 //----------------------------------------------------------- class ExcRecord -
 150
 151 void ExcRecord::Save( XclExpStream& rStrm )
 152 {
 153     SetRecHeader( GetNum(), GetLen() );
 154     XclExpRecord::Save( rStrm );
 155 }
 156
 157 void ExcRecord::SaveCont( XclExpStream& /*rStrm*/ )
 158 {
 159 }
 160
 161 void ExcRecord::WriteBody( XclExpStream& rStrm )
 162 {
 163     SaveCont( rStrm );
 164 }
 165
 166
 167 //--------------------------------------------------------- class ExcEmptyRec -
 168
 169 void ExcEmptyRec::Save( XclExpStream& /*rStrm*/ )
 170 {
 171 }
 172
 173
 174 UINT16 ExcEmptyRec::GetNum() const
 175 {
 176     return 0;
 177 }
 178
 179
 180 sal_Size ExcEmptyRec::GetLen() const
 181 {
 182     return 0;
 183 }
 184
 185
 186
 187 //------------------------------------------------------- class ExcRecordList -
 188
 189 ExcRecordList::~ExcRecordList()
 190 {
 191     for( ExcRecord* pRec = First(); pRec; pRec = Next() )
 192         delete pRec;
 193 }
 194
 195
 196 void ExcRecordList::Save( XclExpStream& rStrm )
 197 {
 198     for( ExcRecord* pRec = First(); pRec; pRec = Next() )
 199         pRec->Save( rStrm );
 200 }
 201
 202
 203
 204 //--------------------------------------------------------- class ExcDummyRec -
 205
 206 void ExcDummyRec::Save( XclExpStream& rStrm )
 207 {
 208     rStrm.Write( GetData(), GetLen() );        // raw write mode
 209 }
 210
 211
 212 UINT16 ExcDummyRec::GetNum( void ) const
 213 {
 214     return 0x0000;
 215 }
 216
 217
 218
 219 //------------------------------------------------------- class ExcBoolRecord -
 220
 221 void ExcBoolRecord::SaveCont( XclExpStream& rStrm )
 222 {
 223     rStrm << (UINT16)(bVal ? 0x0001 : 0x0000);
 224 }
 225
 226
 227 sal_Size ExcBoolRecord::GetLen( void ) const
 228 {
 229     return 2;
 230 }
 231
 232
 233
 234
 235 //--------------------------------------------------------- class ExcBof_Base -
 236
 237 ExcBof_Base::ExcBof_Base() :
 238     nRupBuild( 0x096C ),        // copied from Excel
 239     nRupYear( 0x07C9 )          // copied from Excel
 240 {
 241 }
 242
 243
 244
 245 //-------------------------------------------------------------- class ExcBof -
 246
 247 ExcBof::ExcBof( void )
 248 {
 249     nDocType = 0x0010;
 250     nVers = 0x0500;
 251 }
 252
 253
 254 void ExcBof::SaveCont( XclExpStream& rStrm )
 255 {
 256     rStrm << nVers << nDocType << nRupBuild << nRupYear;
 257 }
 258
 259
 260 UINT16 ExcBof::GetNum( void ) const
 261 {
 262     return 0x0809;
 263 }
 264
 265
 266 sal_Size ExcBof::GetLen( void ) const
 267 {
 268     return 8;
 269 }
 270
 271
 272
 273 //------------------------------------------------------------- class ExcBofW -
 274
 275 ExcBofW::ExcBofW( void )
 276 {
 277     nDocType = 0x0005;
 278     nVers = 0x0500;
 279 }
 280
 281
 282 void ExcBofW::SaveCont( XclExpStream& rStrm )
 283 {
 284     rStrm << nVers << nDocType << nRupBuild << nRupYear;
 285 }
 286
 287
 288
 289 UINT16 ExcBofW::GetNum( void ) const
 290 {
 291     return 0x0809;
 292 }
 293
 294
 295
 296 sal_Size ExcBofW::GetLen( void ) const
 297 {
 298     return 8;
 299 }
 300
 301
 302
 303 //-------------------------------------------------------------- class ExcEof -
 304
 305 UINT16 ExcEof::GetNum( void ) const
 306 {
 307     return 0x000A;
 308 }
 309
 310
 311 sal_Size ExcEof::GetLen( void ) const
 312 {
 313     return 0;
 314 }
 315
 316
 317
 318 //----------------------------------------------------- class ExcFngroupcount -
 319
 320 void ExcFngroupcount::SaveCont( XclExpStream& rStrm )
 321 {
 322     rStrm << ( UINT16 ) 0x000E;         // copied from Excel
 323 }
 324
 325
 326 UINT16 ExcFngroupcount::GetNum( void ) const
 327 {
 328     return 0x009C;
 329 }
 330
 331
 332 sal_Size ExcFngroupcount::GetLen( void ) const
 333 {
 334     return 2;
 335 }
 336
 337
 338
 339 //--------------------------------------------------------- class ExcDummy_00 -
 340
 341 sal_Size ExcDummy_00::GetLen( void ) const
 342 {
 343     return nMyLen;
 344 }
 345
 346
 347 const BYTE* ExcDummy_00::GetData( void ) const
 348 {
 349     return pMyData;
 350 }
 351
 352
 353
 354 //-------------------------------------------------------- class ExcDummy_04x -
 355
 356 sal_Size ExcDummy_040::GetLen( void ) const
 357 {
 358     return nMyLen;
 359 }
 360
 361
 362 const BYTE* ExcDummy_040::GetData( void ) const
 363 {
 364     return pMyData;
 365 }
 366
 367
 368
 369
 370 sal_Size ExcDummy_041::GetLen( void ) const
 371 {
 372     return nMyLen;
 373 }
 374
 375
 376 const BYTE* ExcDummy_041::GetData( void ) const
 377 {
 378     return pMyData;
 379 }
 380
 381
 382
 383 //------------------------------------------------------------- class Exc1904 -
 384
 385 Exc1904::Exc1904( ScDocument& rDoc )
 386 {
 387     Date* pDate = rDoc.GetFormatTable()->GetNullDate();
 388     bVal = pDate ? (*pDate == Date( 1, 1, 1904 )) : FALSE;
 389 }
 390
 391
 392 UINT16 Exc1904::GetNum( void ) const
 393 {
 394     return 0x0022;
 395 }
 396
 397
 398 void Exc1904::SaveXml( XclExpXmlStream& rStrm )
 399 {
 400     rStrm.WriteAttributes(
 401             XML_date1904, XclXmlUtils::ToPsz( bVal ),
 402             FSEND );
 403 }
 404
 405
 406
 407 //------------------------------------------------------ class ExcBundlesheet -
 408
 409 ExcBundlesheetBase::ExcBundlesheetBase( RootData& rRootData, SCTAB nTabNum ) :
 410     nStrPos( STREAM_SEEK_TO_END ),
 411     nOwnPos( STREAM_SEEK_TO_END ),
 412     nGrbit( rRootData.pER->GetTabInfo().IsVisibleTab( nTabNum ) ? 0x0000 : 0x0001 ),
 413     nTab( nTabNum )
 414 {
 415 }
 416
 417
 418 ExcBundlesheetBase::ExcBundlesheetBase() :
 419     nStrPos( STREAM_SEEK_TO_END ),
 420     nOwnPos( STREAM_SEEK_TO_END ),
 421     nGrbit( 0x0000 ),
 422     nTab( SCTAB_GLOBAL )
 423 {
 424 }
 425
 426
 427 void ExcBundlesheetBase::UpdateStreamPos( XclExpStream& rStrm )
 428 {
 429     rStrm.SetSvStreamPos( nOwnPos );
 430     rStrm.DisableEncryption();
 431     rStrm << static_cast<sal_uInt32>(nStrPos);
 432     rStrm.EnableEncryption();
 433 }
 434
 435
 436 UINT16 ExcBundlesheetBase::GetNum( void ) const
 437 {
 438     return 0x0085;
 439 }
 440
 441
 442
 443
 444 ExcBundlesheet::ExcBundlesheet( RootData& rRootData, SCTAB _nTab ) :
 445     ExcBundlesheetBase( rRootData, _nTab )
 446 {
 447     String sTabName = rRootData.pER->GetTabInfo().GetScTabName( _nTab );
 448     DBG_ASSERT( sTabName.Len() < 256, "ExcBundlesheet::ExcBundlesheet - table name too long" );
 449     aName = ByteString( sTabName, rRootData.pER->GetTextEncoding() );
 450 }
 451
 452
 453 void ExcBundlesheet::SaveCont( XclExpStream& rStrm )
 454 {
 455     nOwnPos = rStrm.GetSvStreamPos();
 456     rStrm       << (UINT32)     0x00000000                              // dummy (stream position of the sheet)
 457             << nGrbit;
 458     rStrm.WriteByteString( aName );                             // 8 bit length, max 255 chars
 459 }
 460
 461
 462 sal_Size ExcBundlesheet::GetLen() const
 463 {
 464     return 7 + Min( aName.Len(), (xub_StrLen) 255 );
 465 }
 466
 467
 468 //--------------------------------------------------------- class ExcDummy_02 -
 469
 470 sal_Size ExcDummy_02a::GetLen( void ) const
 471 {
 472     return nMyLen;
 473 }
 474
 475 const BYTE* ExcDummy_02a::GetData( void ) const
 476 {
 477     return pMyData;
 478 }
 479 //--------------------------------------------------------- class ExcDummy_02 -
 480
 481 XclExpCountry::XclExpCountry( const XclExpRoot& rRoot ) :
 482     XclExpRecord( EXC_ID_COUNTRY, 4 )
 483 {
 484     /*  #i31530# set document country as UI country too -
 485         needed for correct behaviour of number formats. */
 486     mnUICountry = mnDocCountry = static_cast< sal_uInt16 >(
 487         ::svx::ConvertLanguageToCountry( rRoot.GetDocLanguage() ) );
 488 }
 489
 490 void XclExpCountry::WriteBody( XclExpStream& rStrm )
 491 {
 492     rStrm << mnUICountry << mnDocCountry;
 493 }
 494
 495 // XclExpWsbool ===============================================================
 496
 497 XclExpWsbool::XclExpWsbool( bool bFitToPages, SCTAB nScTab, XclExpFilterManager* pManager )
 498     : XclExpUInt16Record( EXC_ID_WSBOOL, EXC_WSBOOL_DEFAULTFLAGS )
 499     , mnScTab( nScTab )
 500     , mpManager( pManager )
 501 {
 502     if( bFitToPages )
 503         SetValue( GetValue() | EXC_WSBOOL_FITTOPAGE );
 504 }
 505
 506 void XclExpWsbool::SaveXml( XclExpXmlStream& rStrm )
 507 {
 508     sax_fastparser::FSHelperPtr& rWorksheet = rStrm.GetCurrentStream();
 509     rWorksheet->startElement( XML_sheetPr,
 510             // OOXTODO: XML_syncHorizontal,
 511             // OOXTODO: XML_syncVertical,
 512             // OOXTODO: XML_syncRef,
 513             // OOXTODO: XML_transitionEvaluation,
 514             // OOXTODO: XML_transitionEntry,
 515             // OOXTODO: XML_published,
 516             // OOXTODO: XML_codeName,
 517             XML_filterMode, mpManager ? XclXmlUtils::ToPsz( mpManager->HasFilterMode( mnScTab ) ) : NULL,
 518             // OOXTODO: XML_enableFormatConditionsCalculation,
 519             FSEND );
 520     // OOXTODO: elements XML_tabColor, XML_outlinePr
 521     rWorksheet->singleElement( XML_pageSetUpPr,
 522             // OOXTODO: XML_autoPageBreaks,
 523             XML_fitToPage,  XclXmlUtils::ToPsz( GetValue() & EXC_WSBOOL_FITTOPAGE ),
 524             FSEND );
 525     rWorksheet->endElement( XML_sheetPr );
 526 }
 527
 528
 529 // XclExpWindowProtection ===============================================================
 530
 531 XclExpWindowProtection::XclExpWindowProtection(bool bValue) :
 532     XclExpBoolRecord(EXC_ID_WINDOWPROTECT, bValue)
 533 {
 534 }
 535
 536 void XclExpWindowProtection::SaveXml( XclExpXmlStream& rStrm )
 537 {
 538     rStrm.WriteAttributes(
 539             XML_lockWindows, XclXmlUtils::ToPsz( GetBool() ),
 540             FSEND );
 541 }
 542
 543 // XclExpDocProtection ===============================================================
 544
 545 XclExpProtection::XclExpProtection(bool bValue) :
 546     XclExpBoolRecord(EXC_ID_PROTECT, bValue)
 547 {
 548 }
 549
 550 // ============================================================================
 551
 552 XclExpPassHash::XclExpPassHash(const Sequence<sal_Int8>& aHash) :
 553     XclExpRecord(EXC_ID_PASSWORD, 2),
 554     mnHash(0x0000)
 555 {
 556     if (aHash.getLength() >= 2)
 557     {
 558         mnHash  = ((aHash[0] << 8) & 0xFFFF);
 559         mnHash |= (aHash[1] & 0xFF);
 560     }
 561 }
 562
 563 XclExpPassHash::~XclExpPassHash()
 564 {
 565 }
 566
 567 void XclExpPassHash::WriteBody(XclExpStream& rStrm)
 568 {
 569     rStrm << mnHash;
 570 }
 571
 572 // ============================================================================
 573
 574 XclExpFiltermode::XclExpFiltermode() :
 575     XclExpEmptyRecord( EXC_ID_FILTERMODE )
 576 {
 577 }
 578
 579 // ----------------------------------------------------------------------------
 580
 581 XclExpAutofilterinfo::XclExpAutofilterinfo( const ScAddress& rStartPos, SCCOL nScCol ) :
 582     XclExpUInt16Record( EXC_ID_AUTOFILTERINFO, static_cast< sal_uInt16 >( nScCol ) ),
 583     maStartPos( rStartPos )
 584 {
 585 }
 586
 587 // ----------------------------------------------------------------------------
 588
 589 ExcFilterCondition::ExcFilterCondition() :
 590         nType( EXC_AFTYPE_NOTUSED ),
 591         nOper( EXC_AFOPER_EQUAL ),
 592         fVal( 0.0 ),
 593         pText( NULL )
 594 {
 595 }
 596
 597 ExcFilterCondition::~ExcFilterCondition()
 598 {
 599     if( pText )
 600         delete pText;
 601 }
 602
 603 sal_Size ExcFilterCondition::GetTextBytes() const
 604 {
 605     return pText ? (1 + pText->GetBufferSize()) : 0;
 606 }
 607
 608 void ExcFilterCondition::SetCondition( UINT8 nTp, UINT8 nOp, double fV, String* pT )
 609 {
 610     nType = nTp;
 611     nOper = nOp;
 612     fVal = fV;
 613
 614     delete pText;
 615     pText = pT ? new XclExpString( *pT, EXC_STR_8BITLENGTH ) : NULL;
 616 }
 617
 618 void ExcFilterCondition::Save( XclExpStream& rStrm )
 619 {
 620     rStrm << nType << nOper;
 621     switch( nType )
 622     {
 623         case EXC_AFTYPE_DOUBLE:
 624             rStrm << fVal;
 625         break;
 626         case EXC_AFTYPE_STRING:
 627             DBG_ASSERT( pText, "ExcFilterCondition::Save() -- pText is NULL!" );
 628             rStrm << (UINT32)0 << (UINT8) pText->Len() << (UINT16)0 << (UINT8)0;
 629         break;
 630         case EXC_AFTYPE_BOOLERR:
 631             rStrm << (UINT8)0 << (UINT8)((fVal != 0) ? 1 : 0) << (UINT32)0 << (UINT16)0;
 632         break;
 633         default:
 634             rStrm << (UINT32)0 << (UINT32)0;
 635     }
 636 }
 637
 638 static const char* lcl_GetOperator( UINT8 nOper )
 639 {
 640     switch( nOper )
 641     {
 642         case EXC_AFOPER_EQUAL:          return "equal";
 643         case EXC_AFOPER_GREATER:        return "greaterThan";
 644         case EXC_AFOPER_GREATEREQUAL:   return "greaterThanOrEqual";
 645         case EXC_AFOPER_LESS:           return "lessThan";
 646         case EXC_AFOPER_LESSEQUAL:      return "lessThanOrEqual";
 647         case EXC_AFOPER_NOTEQUAL:       return "notEqual";
 648         case EXC_AFOPER_NONE:
 649         default:                        return "**none**";
 650     }
 651 }
 652
 653 static OString lcl_GetValue( UINT8 nType, double fVal, XclExpString* pStr )
 654 {
 655     switch( nType )
 656     {
 657         case EXC_AFTYPE_STRING:     return XclXmlUtils::ToOString( *pStr );
 658         case EXC_AFTYPE_DOUBLE:     return OString::valueOf( fVal );
 659         case EXC_AFTYPE_BOOLERR:    return OString::valueOf( (sal_Int32) ( fVal != 0 ? 1 : 0 ) );
 660         default:                    return OString();
 661     }
 662 }
 663
 664 void ExcFilterCondition::SaveXml( XclExpXmlStream& rStrm )
 665 {
 666     if( IsEmpty() )
 667         return;
 668
 669     rStrm.GetCurrentStream()->singleElement( XML_customFilter,
 670             XML_operator,   lcl_GetOperator( nOper ),
 671             XML_val,        lcl_GetValue( nType, fVal, pText ).getStr(),
 672             FSEND );
 673 }
 674
 675 void ExcFilterCondition::SaveText( XclExpStream& rStrm )
 676 {
 677     if( nType == EXC_AFTYPE_STRING )
 678     {
 679         DBG_ASSERT( pText, "ExcFilterCondition::SaveText() -- pText is NULL!" );
 680         pText->WriteFlagField( rStrm );
 681         pText->WriteBuffer( rStrm );
 682     }
 683 }
 684
 685 // ----------------------------------------------------------------------------
 686
 687 XclExpAutofilter::XclExpAutofilter( const XclExpRoot& rRoot, UINT16 nC ) :
 688     XclExpRecord( EXC_ID_AUTOFILTER, 24 ),
 689     XclExpRoot( rRoot ),
 690     nCol( nC ),
 691     nFlags( 0 )
 692 {
 693 }
 694
 695 BOOL XclExpAutofilter::AddCondition( ScQueryConnect eConn, UINT8 nType, UINT8 nOp,
 696                                     double fVal, String* pText, BOOL bSimple )
 697 {
 698     if( !aCond[ 1 ].IsEmpty() )
 699         return FALSE;
 700
 701     UINT16 nInd = aCond[ 0 ].IsEmpty() ? 0 : 1;
 702
 703     if( nInd == 1 )
 704         nFlags |= (eConn == SC_OR) ? EXC_AFFLAG_OR : EXC_AFFLAG_AND;
 705     if( bSimple )
 706         nFlags |= (nInd == 0) ? EXC_AFFLAG_SIMPLE1 : EXC_AFFLAG_SIMPLE2;
 707
 708     aCond[ nInd ].SetCondition( nType, nOp, fVal, pText );
 709
 710     AddRecSize( aCond[ nInd ].GetTextBytes() );
 711
 712     return TRUE;
 713 }
 714
 715 BOOL XclExpAutofilter::AddEntry( const ScQueryEntry& rEntry )
 716 {
 717     BOOL        bConflict = FALSE;
 718     String      sText;
 719
 720     if( rEntry.pStr )
 721     {
 722         sText.Assign( *rEntry.pStr );
 723         switch( rEntry.eOp )
 724         {
 725             case SC_CONTAINS:
 726             case SC_DOES_NOT_CONTAIN:
 727             {
 728                 sText.InsertAscii( "*" , 0 );
 729                 sText.AppendAscii( "*" );
 730             }
 731             break;
 732             case SC_BEGINS_WITH:
 733             case SC_DOES_NOT_BEGIN_WITH:
 734                 sText.AppendAscii( "*" );
 735             break;
 736             case SC_ENDS_WITH:
 737             case SC_DOES_NOT_END_WITH:
 738                 sText.InsertAscii( "*" , 0 );
 739             break;
 740             default:
 741             {
 742                 //nothing
 743             }
 744         }
 745     }
 746
 747     BOOL bLen = sText.Len() > 0;
 748
 749     // empty/nonempty fields
 750     if( !bLen && (rEntry.nVal == SC_EMPTYFIELDS) )
 751         bConflict = !AddCondition( rEntry.eConnect, EXC_AFTYPE_EMPTY, EXC_AFOPER_NONE, 0.0, NULL, TRUE );
 752     else if( !bLen && (rEntry.nVal == SC_NONEMPTYFIELDS) )
 753         bConflict = !AddCondition( rEntry.eConnect, EXC_AFTYPE_NOTEMPTY, EXC_AFOPER_NONE, 0.0, NULL, TRUE );
 754     // other conditions
 755     else
 756     {
 757         double  fVal    = 0.0;
 758         sal_uInt32      nIndex  = 0;
 759         BOOL    bIsNum  = bLen ? GetFormatter().IsNumberFormat( sText, nIndex, fVal ) : TRUE;
 760         String* pText   = bIsNum ? NULL : &sText;
 761
 762         // top10 flags
 763         UINT16 nNewFlags = 0x0000;
 764         switch( rEntry.eOp )
 765         {
 766             case SC_TOPVAL:
 767                 nNewFlags = (EXC_AFFLAG_TOP10 | EXC_AFFLAG_TOP10TOP);
 768             break;
 769             case SC_BOTVAL:
 770                 nNewFlags = EXC_AFFLAG_TOP10;
 771             break;
 772             case SC_TOPPERC:
 773                 nNewFlags = (EXC_AFFLAG_TOP10 | EXC_AFFLAG_TOP10TOP | EXC_AFFLAG_TOP10PERC);
 774             break;
 775             case SC_BOTPERC:
 776                 nNewFlags = (EXC_AFFLAG_TOP10 | EXC_AFFLAG_TOP10PERC);
 777             break;
 778             default:;
 779         }
 780         BOOL bNewTop10 = ::get_flag( nNewFlags, EXC_AFFLAG_TOP10 );
 781
 782         bConflict = HasTop10() && bNewTop10;
 783         if( !bConflict )
 784         {
 785             if( bNewTop10 )
 786             {
 787                 if( fVal < 0 )          fVal = 0;
 788                 if( fVal >= 501 )       fVal = 500;
 789                 nFlags |= (nNewFlags | (UINT16)(fVal) << 7);
 790             }
 791             // normal condition
 792             else
 793             {
 794                 UINT8 nType = bIsNum ? EXC_AFTYPE_DOUBLE : EXC_AFTYPE_STRING;
 795                 UINT8 nOper = EXC_AFOPER_NONE;
 796
 797                 switch( rEntry.eOp )
 798                 {
 799                     case SC_EQUAL:                      nOper = EXC_AFOPER_EQUAL;                       break;
 800                     case SC_LESS:                       nOper = EXC_AFOPER_LESS;                        break;
 801                     case SC_GREATER:            nOper = EXC_AFOPER_GREATER;                     break;
 802                     case SC_LESS_EQUAL:         nOper = EXC_AFOPER_LESSEQUAL;           break;
 803                     case SC_GREATER_EQUAL:      nOper = EXC_AFOPER_GREATEREQUAL;        break;
 804                     case SC_NOT_EQUAL:          nOper = EXC_AFOPER_NOTEQUAL;            break;
 805                     case SC_CONTAINS:
 806                     case SC_BEGINS_WITH:
 807                     case SC_ENDS_WITH:
 808                                             nOper = EXC_AFOPER_EQUAL;           break;
 809                     case SC_DOES_NOT_CONTAIN:
 810                     case SC_DOES_NOT_BEGIN_WITH:
 811                     case SC_DOES_NOT_END_WITH:
 812                                             nOper = EXC_AFOPER_NOTEQUAL;        break;
 813                     default:;
 814                 }
 815                 bConflict = !AddCondition( rEntry.eConnect, nType, nOper, fVal, pText );
 816             }
 817         }
 818     }
 819     return bConflict;
 820 }
 821
 822 void XclExpAutofilter::WriteBody( XclExpStream& rStrm )
 823 {
 824     rStrm << nCol << nFlags;
 825     aCond[ 0 ].Save( rStrm );
 826     aCond[ 1 ].Save( rStrm );
 827     aCond[ 0 ].SaveText( rStrm );
 828     aCond[ 1 ].SaveText( rStrm );
 829 }
 830
 831 void XclExpAutofilter::SaveXml( XclExpXmlStream& rStrm )
 832 {
 833     if( !HasCondition() )
 834         return;
 835
 836     sax_fastparser::FSHelperPtr& rWorksheet = rStrm.GetCurrentStream();
 837
 838     rWorksheet->startElement( XML_filterColumn,
 839             XML_colId,          OString::valueOf( (sal_Int32) nCol ).getStr(),
 840             // OOXTODO: XML_hiddenButton,   AutoFilter12 fHideArrow?
 841             // OOXTODO: XML_showButton,
 842             FSEND );
 843
 844     if( HasTop10() )
 845     {
 846         rWorksheet->singleElement( XML_top10,
 847                 XML_top,        XclXmlUtils::ToPsz( get_flag( nFlags, EXC_AFFLAG_TOP10TOP ) ),
 848                 XML_percent,    XclXmlUtils::ToPsz( get_flag( nFlags, EXC_AFFLAG_TOP10PERC ) ),
 849                 XML_val,        OString::valueOf( (sal_Int32) (nFlags >> 7 ) ).getStr(),
 850                 // OOXTODO: XML_filterVal,
 851                 FSEND );
 852     }
 853
 854     rWorksheet->startElement( XML_customFilters,
 855             XML_and,    XclXmlUtils::ToPsz( (nFlags & EXC_AFFLAG_ANDORMASK) == EXC_AFFLAG_AND ),
 856             FSEND );
 857     aCond[ 0 ].SaveXml( rStrm );
 858     aCond[ 1 ].SaveXml( rStrm );
 859     rWorksheet->endElement( XML_customFilters );
 860     // OOXTODO: XLM_colorFilter, XML_dynamicFilter,
 861     // XML_extLst, XML_filters, XML_iconFilter, XML_top10
 862     rWorksheet->endElement( XML_filterColumn );
 863 }
 864
 865 // ----------------------------------------------------------------------------
 866
 867 ExcAutoFilterRecs::ExcAutoFilterRecs( const XclExpRoot& rRoot, SCTAB nTab ) :
 868     XclExpRoot( rRoot ),
 869     pFilterMode( NULL ),
 870     pFilterInfo( NULL )
 871 {
 872     ScDBCollection& rDBColl = GetDatabaseRanges();
 873     XclExpNameManager& rNameMgr = GetNameManager();
 874
 875     // search for first DB-range with filter
 876     UINT16              nIndex  = 0;
 877     BOOL                bFound  = FALSE;
 878     BOOL                bAdvanced = FALSE;
 879     ScDBData*   pData   = NULL;
 880     ScRange             aAdvRange;
 881     while( (nIndex < rDBColl.GetCount()) && !bFound )
 882     {
 883         pData = rDBColl[ nIndex ];
 884         if( pData )
 885         {
 886             ScRange aRange;
 887             pData->GetArea( aRange );
 888             bAdvanced = pData->GetAdvancedQuerySource( aAdvRange );
 889             bFound = (aRange.aStart.Tab() == nTab) &&
 890                 (pData->HasQueryParam() || pData->HasAutoFilter() || bAdvanced);
 891         }
 892         if( !bFound )
 893             nIndex++;
 894     }
 895
 896     if( pData && bFound )
 897     {
 898         ScQueryParam    aParam;
 899         pData->GetQueryParam( aParam );
 900
 901         ScRange aRange( aParam.nCol1, aParam.nRow1, aParam.nTab,
 902                         aParam.nCol2, aParam.nRow2, aParam.nTab );
 903         SCCOL   nColCnt = aParam.nCol2 - aParam.nCol1 + 1;
 904
 905         maRef = aRange;
 906
 907         // #i2394# #100489# built-in defined names must be sorted by containing sheet name
 908         rNameMgr.InsertBuiltInName( EXC_BUILTIN_FILTERDATABASE, aRange );
 909
 910         // advanced filter
 911         if( bAdvanced )
 912         {
 913             // filter criteria, excel allows only same table
 914             if( aAdvRange.aStart.Tab() == nTab )
 915                 rNameMgr.InsertBuiltInName( EXC_BUILTIN_CRITERIA, aAdvRange );
 916
 917             // filter destination range, excel allows only same table
 918             if( !aParam.bInplace )
 919             {
 920                 ScRange aDestRange( aParam.nDestCol, aParam.nDestRow, aParam.nDestTab );
 921                 aDestRange.aEnd.IncCol( nColCnt - 1 );
 922                 if( aDestRange.aStart.Tab() == nTab )
 923                     rNameMgr.InsertBuiltInName( EXC_BUILTIN_EXTRACT, aDestRange );
 924             }
 925
 926             pFilterMode = new XclExpFiltermode;
 927         }
 928         // AutoFilter
 929         else
 930         {
 931             BOOL        bConflict       = FALSE;
 932             BOOL        bContLoop       = TRUE;
 933             BOOL        bHasOr          = FALSE;
 934             SCCOLROW nFirstField = aParam.GetEntry( 0 ).nField;
 935
 936             // create AUTOFILTER records for filtered columns
 937             for( SCSIZE nEntry = 0; !bConflict && bContLoop && (nEntry < aParam.GetEntryCount()); nEntry++ )
 938             {
 939                 const ScQueryEntry& rEntry      = aParam.GetEntry( nEntry );
 940
 941                 bContLoop = rEntry.bDoQuery;
 942                 if( bContLoop )
 943                 {
 944                     XclExpAutofilter* pFilter = GetByCol( static_cast<SCCOL>(rEntry.nField) - aRange.aStart.Col() );
 945
 946                     if( nEntry > 0 )
 947                         bHasOr |= (rEntry.eConnect == SC_OR);
 948
 949                     bConflict = (nEntry > 1) && bHasOr;
 950                     if( !bConflict )
 951                         bConflict = (nEntry == 1) && (rEntry.eConnect == SC_OR) &&
 952                                     (nFirstField != rEntry.nField);
 953                     if( !bConflict )
 954                         bConflict = pFilter->AddEntry( rEntry );
 955                 }
 956             }
 957
 958             // additional tests for conflicts
 959             for( size_t nPos = 0, nSize = maFilterList.GetSize(); !bConflict && (nPos < nSize); ++nPos )
 960             {
 961                 XclExpAutofilterRef xFilter = maFilterList.GetRecord( nPos );
 962                 bConflict = xFilter->HasCondition() && xFilter->HasTop10();
 963             }
 964
 965             if( bConflict )
 966                 maFilterList.RemoveAllRecords();
 967
 968             if( !maFilterList.IsEmpty() )
 969                 pFilterMode = new XclExpFiltermode;
 970             pFilterInfo = new XclExpAutofilterinfo( aRange.aStart, nColCnt );
 971         }
 972     }
 973 }
 974
 975 ExcAutoFilterRecs::~ExcAutoFilterRecs()
 976 {
 977     delete pFilterMode;
 978     delete pFilterInfo;
 979 }
 980
 981 XclExpAutofilter* ExcAutoFilterRecs::GetByCol( SCCOL nCol )
 982 {
 983     XclExpAutofilterRef xFilter;
 984     for( size_t nPos = 0, nSize = maFilterList.GetSize(); nPos < nSize; ++nPos )
 985     {
 986         xFilter = maFilterList.GetRecord( nPos );
 987         if( xFilter->GetCol() == static_cast<sal_uInt16>(nCol) )
 988             return xFilter.get();
 989     }
 990     xFilter.reset( new XclExpAutofilter( GetRoot(), static_cast<sal_uInt16>(nCol) ) );
 991     maFilterList.AppendRecord( xFilter );
 992     return xFilter.get();
 993 }
 994
 995 BOOL ExcAutoFilterRecs::IsFiltered( SCCOL nCol )
 996 {
 997     for( size_t nPos = 0, nSize = maFilterList.GetSize(); nPos < nSize; ++nPos )
 998         if( maFilterList.GetRecord( nPos )->GetCol() == static_cast<sal_uInt16>(nCol) )
 999             return TRUE;
1000     return FALSE;
1001 }
1002
1003 void ExcAutoFilterRecs::AddObjRecs()
1004 {
1005     if( pFilterInfo )
1006     {
1007         ScAddress aAddr( pFilterInfo->GetStartPos() );
1008         for( SCCOL nObj = 0, nCount = pFilterInfo->GetColCount(); nObj < nCount; nObj++ )
1009         {
1010             XclObjDropDown* pObj = new XclObjDropDown( GetRoot(), aAddr, IsFiltered( nObj ) );
1011             GetOldRoot().pObjRecs->Add( pObj );
1012             aAddr.IncCol( 1 );
1013         }
1014     }
1015 }
1016
1017 void ExcAutoFilterRecs::Save( XclExpStream& rStrm )
1018 {
1019     if( pFilterMode )
1020         pFilterMode->Save( rStrm );
1021     if( pFilterInfo )
1022         pFilterInfo->Save( rStrm );
1023     maFilterList.Save( rStrm );
1024 }
1025
1026 void ExcAutoFilterRecs::SaveXml( XclExpXmlStream& rStrm )
1027 {
1028     if( maFilterList.IsEmpty() )
1029         return;
1030
1031     sax_fastparser::FSHelperPtr& rWorksheet = rStrm.GetCurrentStream();
1032     rWorksheet->startElement( XML_autoFilter,
1033             XML_ref,    XclXmlUtils::ToOString( maRef ).getStr(),
1034             FSEND );
1035     // OOXTODO: XML_extLst, XML_sortState
1036     maFilterList.SaveXml( rStrm );
1037     rWorksheet->endElement( XML_autoFilter );
1038 }
1039
1040 bool ExcAutoFilterRecs::HasFilterMode() const
1041 {
1042     return pFilterMode != NULL;
1043 }
1044
1045 // ----------------------------------------------------------------------------
1046
1047 XclExpFilterManager::XclExpFilterManager( const XclExpRoot& rRoot ) :
1048     XclExpRoot( rRoot )
1049 {
1050 }
1051
1052 void XclExpFilterManager::InitTabFilter( SCTAB nScTab )
1053 {
1054     maFilterMap[ nScTab ].reset( new ExcAutoFilterRecs( GetRoot(), nScTab ) );
1055 }
1056
1057 XclExpRecordRef XclExpFilterManager::CreateRecord( SCTAB nScTab )
1058 {
1059     XclExpTabFilterRef xRec;
1060     XclExpTabFilterMap::iterator aIt = maFilterMap.find( nScTab );
1061     if( aIt != maFilterMap.end() )
1062     {
1063         xRec = aIt->second;
1064         xRec->AddObjRecs();
1065     }
1066     return xRec;
1067 }
1068
1069 bool XclExpFilterManager::HasFilterMode( SCTAB nScTab )
1070 {
1071     XclExpTabFilterRef xRec;
1072     XclExpTabFilterMap::iterator aIt = maFilterMap.find( nScTab );
1073     if( aIt != maFilterMap.end() )
1074     {
1075         return aIt->second->HasFilterMode();
1076     }
1077     return false;
1078 }
1079
1080 // ============================================================================
1081