sc/source/core/data/markdata.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: markdata.cxx,v $
  10  * $Revision: 1.8 $
  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 // INCLUDE ---------------------------------------------------------------
  37
  38 #include <tools/debug.hxx>
  39
  40 #include "markdata.hxx"
  41 #include "markarr.hxx"
  42 #include "rangelst.hxx"
  43
  44 // STATIC DATA -----------------------------------------------------------
  45
  46 //------------------------------------------------------------------------
  47
  48 ScMarkData::ScMarkData() :
  49     pMultiSel( NULL )
  50 {
  51     for (SCTAB i=0; i<=MAXTAB; i++)
  52         bTabMarked[i] = FALSE;
  53
  54     ResetMark();
  55 }
  56
  57 ScMarkData::ScMarkData(const ScMarkData& rData) :
  58     aMarkRange( rData.aMarkRange ),
  59     aMultiRange( rData.aMultiRange ),
  60     pMultiSel( NULL )
  61 {
  62     bMarked              = rData.bMarked;
  63     bMultiMarked = rData.bMultiMarked;
  64     bMarking     = rData.bMarking;
  65     bMarkIsNeg   = rData.bMarkIsNeg;
  66
  67     for (SCTAB i=0; i<=MAXTAB; i++)
  68         bTabMarked[i] = rData.bTabMarked[i];
  69
  70     if (rData.pMultiSel)
  71     {
  72         pMultiSel = new ScMarkArray[MAXCOLCOUNT];
  73         for (SCCOL j=0; j<MAXCOLCOUNT; j++)
  74             rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
  75     }
  76 }
  77
  78 ScMarkData&     ScMarkData::operator=(const ScMarkData& rData)
  79 {
  80     if ( &rData == this )
  81         return *this;
  82
  83     delete[] pMultiSel;
  84     pMultiSel = NULL;
  85
  86     aMarkRange   = rData.aMarkRange;
  87     aMultiRange  = rData.aMultiRange;
  88     bMarked              = rData.bMarked;
  89     bMultiMarked = rData.bMultiMarked;
  90     bMarking     = rData.bMarking;
  91     bMarkIsNeg   = rData.bMarkIsNeg;
  92
  93     for (SCTAB i=0; i<=MAXTAB; i++)
  94         bTabMarked[i] = rData.bTabMarked[i];
  95
  96     if (rData.pMultiSel)
  97     {
  98         pMultiSel = new ScMarkArray[MAXCOLCOUNT];
  99         for (SCCOL j=0; j<MAXCOLCOUNT; j++)
 100             rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
 101     }
 102
 103     return *this;
 104 }
 105
 106 ScMarkData::~ScMarkData()
 107 {
 108     delete[] pMultiSel;
 109 }
 110
 111 void ScMarkData::ResetMark()
 112 {
 113     delete[] pMultiSel;
 114     pMultiSel = NULL;
 115
 116     bMarked = bMultiMarked = FALSE;
 117     bMarking = bMarkIsNeg = FALSE;
 118 }
 119
 120 void ScMarkData::SetMarkArea( const ScRange& rRange )
 121 {
 122     aMarkRange = rRange;
 123     aMarkRange.Justify();
 124     if ( !bMarked )
 125     {
 126         // #77987# Upon creation of a document ScFormatShell GetTextAttrState
 127         // may query (default) attributes although no sheet is marked yet.
 128         // => mark that one.
 129         if ( !GetSelectCount() )
 130             bTabMarked[ aMarkRange.aStart.Tab() ] = TRUE;
 131         bMarked = TRUE;
 132     }
 133 }
 134
 135 void ScMarkData::GetMarkArea( ScRange& rRange ) const
 136 {
 137     rRange = aMarkRange;                //! inline ?
 138 }
 139
 140 void ScMarkData::GetMultiMarkArea( ScRange& rRange ) const
 141 {
 142     rRange = aMultiRange;
 143 }
 144
 145 void ScMarkData::SetMultiMarkArea( const ScRange& rRange, BOOL bMark )
 146 {
 147     if (!pMultiSel)
 148     {
 149         pMultiSel = new ScMarkArray[MAXCOL+1];
 150
 151         // if simple mark range is set, copy to multi marks
 152         if ( bMarked && !bMarkIsNeg )
 153         {
 154             bMarked = FALSE;
 155             SetMultiMarkArea( aMarkRange, TRUE );
 156         }
 157     }
 158
 159     SCCOL nStartCol = rRange.aStart.Col();
 160     SCROW nStartRow = rRange.aStart.Row();
 161     SCCOL nEndCol = rRange.aEnd.Col();
 162     SCROW nEndRow = rRange.aEnd.Row();
 163     PutInOrder( nStartRow, nEndRow );
 164     PutInOrder( nStartCol, nEndCol );
 165
 166     SCCOL nCol;
 167     for (nCol=nStartCol; nCol<=nEndCol; nCol++)
 168         pMultiSel[nCol].SetMarkArea( nStartRow, nEndRow, bMark );
 169
 170     if ( bMultiMarked )                                 // aMultiRange updaten
 171     {
 172         if ( nStartCol < aMultiRange.aStart.Col() )
 173             aMultiRange.aStart.SetCol( nStartCol );
 174         if ( nStartRow < aMultiRange.aStart.Row() )
 175             aMultiRange.aStart.SetRow( nStartRow );
 176         if ( nEndCol > aMultiRange.aEnd.Col() )
 177             aMultiRange.aEnd.SetCol( nEndCol );
 178         if ( nEndRow > aMultiRange.aEnd.Row() )
 179             aMultiRange.aEnd.SetRow( nEndRow );
 180     }
 181     else
 182     {
 183         aMultiRange = rRange;                   // neu
 184         bMultiMarked = TRUE;
 185     }
 186 }
 187
 188 void ScMarkData::SetAreaTab( SCTAB nTab )
 189 {
 190     aMarkRange.aStart.SetTab(nTab);
 191     aMarkRange.aEnd.SetTab(nTab);
 192     aMultiRange.aStart.SetTab(nTab);
 193     aMultiRange.aEnd.SetTab(nTab);
 194 }
 195
 196 void ScMarkData::SelectOneTable( SCTAB nTab )
 197 {
 198     for (SCTAB i=0; i<=MAXTAB; i++)
 199         bTabMarked[i] = ( nTab == i );
 200 }
 201
 202 SCTAB ScMarkData::GetSelectCount() const
 203 {
 204     SCTAB nCount = 0;
 205     for (SCTAB i=0; i<=MAXTAB; i++)
 206         if (bTabMarked[i])
 207             ++nCount;
 208
 209     return nCount;
 210 }
 211
 212 SCTAB ScMarkData::GetFirstSelected() const
 213 {
 214     for (SCTAB i=0; i<=MAXTAB; i++)
 215         if (bTabMarked[i])
 216             return i;
 217
 218     DBG_ERROR("GetFirstSelected: keine markiert");
 219     return 0;
 220 }
 221
 222 void ScMarkData::MarkToMulti()
 223 {
 224     if ( bMarked && !bMarking )
 225     {
 226         SetMultiMarkArea( aMarkRange, !bMarkIsNeg );
 227         bMarked = FALSE;
 228
 229         //      check if all multi mark ranges have been removed
 230         if ( bMarkIsNeg && !HasAnyMultiMarks() )
 231             ResetMark();
 232     }
 233 }
 234
 235 void ScMarkData::MarkToSimple()
 236 {
 237     if ( bMarking )
 238         return;
 239
 240     if ( bMultiMarked && bMarked )
 241         MarkToMulti();                                  // may result in bMarked and bMultiMarked reset
 242
 243     if ( bMultiMarked )
 244     {
 245         DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 246
 247         ScRange aNew = aMultiRange;
 248
 249         BOOL bOk = FALSE;
 250         SCCOL nStartCol = aNew.aStart.Col();
 251         SCCOL nEndCol   = aNew.aEnd.Col();
 252
 253         while ( nStartCol < nEndCol && !pMultiSel[nStartCol].HasMarks() )
 254             ++nStartCol;
 255         while ( nStartCol < nEndCol && !pMultiSel[nEndCol].HasMarks() )
 256             --nEndCol;
 257
 258         //      Zeilen werden nur aus MarkArray genommen
 259         SCROW nStartRow, nEndRow;
 260         if ( pMultiSel[nStartCol].HasOneMark( nStartRow, nEndRow ) )
 261         {
 262             bOk = TRUE;
 263             SCROW nCmpStart, nCmpEnd;
 264             for (SCCOL nCol=nStartCol+1; nCol<=nEndCol && bOk; nCol++)
 265                 if ( !pMultiSel[nCol].HasOneMark( nCmpStart, nCmpEnd )
 266                         || nCmpStart != nStartRow || nCmpEnd != nEndRow )
 267                     bOk = FALSE;
 268         }
 269
 270         if (bOk)
 271         {
 272             aNew.aStart.SetCol(nStartCol);
 273             aNew.aStart.SetRow(nStartRow);
 274             aNew.aEnd.SetCol(nEndCol);
 275             aNew.aEnd.SetRow(nEndRow);
 276
 277             ResetMark();
 278             aMarkRange = aNew;
 279             bMarked = TRUE;
 280             bMarkIsNeg = FALSE;
 281         }
 282     }
 283 }
 284
 285 BOOL ScMarkData::IsCellMarked( SCCOL nCol, SCROW nRow, BOOL bNoSimple ) const
 286 {
 287     if ( bMarked && !bNoSimple && !bMarkIsNeg )
 288         if ( aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
 289              aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
 290             return TRUE;
 291
 292     if (bMultiMarked)
 293     {
 294         //!     hier auf negative Markierung testen ?
 295
 296         DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 297         return pMultiSel[nCol].GetMark( nRow );
 298     }
 299
 300     return FALSE;
 301 }
 302
 303 BOOL ScMarkData::IsColumnMarked( SCCOL nCol ) const
 304 {
 305     //  bMarkIsNeg inzwischen auch fuer Spaltenkoepfe
 306     //! GetMarkColumnRanges fuer komplett markierte Spalten
 307
 308     if ( bMarked && !bMarkIsNeg &&
 309                     aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
 310                     aMarkRange.aStart.Row() == 0        && aMarkRange.aEnd.Row() == MAXROW )
 311         return TRUE;
 312
 313     if ( bMultiMarked && pMultiSel[nCol].IsAllMarked(0,MAXROW) )
 314         return TRUE;
 315
 316     return FALSE;
 317 }
 318
 319 BOOL ScMarkData::IsRowMarked( SCROW nRow ) const
 320 {
 321     //  bMarkIsNeg inzwischen auch fuer Zeilenkoepfe
 322     //! GetMarkRowRanges fuer komplett markierte Zeilen
 323
 324     if ( bMarked && !bMarkIsNeg &&
 325                     aMarkRange.aStart.Col() == 0        && aMarkRange.aEnd.Col() == MAXCOL &&
 326                     aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
 327         return TRUE;
 328
 329     if ( bMultiMarked )
 330     {
 331         DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 332         for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
 333             if (!pMultiSel[nCol].GetMark(nRow))
 334                 return FALSE;
 335         return TRUE;
 336     }
 337
 338     return FALSE;
 339 }
 340
 341 void ScMarkData::MarkFromRangeList( const ScRangeList& rList, BOOL bReset )
 342 {
 343     if (bReset)
 344     {
 345         for (SCTAB i=0; i<=MAXTAB; i++)
 346             bTabMarked[i] = FALSE;                              // Tabellen sind nicht in ResetMark
 347         ResetMark();
 348     }
 349
 350     ULONG nCount = rList.Count();
 351     if ( nCount == 1 && !bMarked && !bMultiMarked )
 352     {
 353         ScRange aRange = *rList.GetObject(0);
 354         SetMarkArea( aRange );
 355         SelectTable( aRange.aStart.Tab(), TRUE );
 356     }
 357     else
 358     {
 359         for (ULONG i=0; i<nCount; i++)
 360         {
 361             ScRange aRange = *rList.GetObject(i);
 362             SetMultiMarkArea( aRange, TRUE );
 363             SelectTable( aRange.aStart.Tab(), TRUE );
 364         }
 365     }
 366 }
 367
 368 void ScMarkData::FillRangeListWithMarks( ScRangeList* pList, BOOL bClear ) const
 369 {
 370     if (!pList)
 371         return;
 372
 373     if (bClear)
 374         pList->RemoveAll();
 375
 376     //!         bei mehreren selektierten Tabellen mehrere Ranges eintragen !!!
 377
 378     if ( bMultiMarked )
 379     {
 380         DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 381
 382         SCTAB nTab = aMultiRange.aStart.Tab();
 383
 384         SCCOL nStartCol = aMultiRange.aStart.Col();
 385         SCCOL nEndCol = aMultiRange.aEnd.Col();
 386         for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
 387             if (pMultiSel[nCol].HasMarks())
 388             {
 389                 SCROW nTop, nBottom;
 390                 ScRange aRange( nCol, 0, nTab );
 391                 ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
 392                 while ( aMarkIter.Next( nTop, nBottom ) )
 393                 {
 394                     aRange.aStart.SetRow( nTop );
 395                     aRange.aEnd.SetRow( nBottom );
 396                     pList->Join( aRange );
 397                 }
 398             }
 399     }
 400
 401     if ( bMarked )
 402         pList->Append( aMarkRange );
 403 }
 404
 405 void ScMarkData::ExtendRangeListTables( ScRangeList* pList ) const
 406 {
 407     if (!pList)
 408         return;
 409
 410     ScRangeList aOldList(*pList);
 411     pList->RemoveAll();                                 //!     oder die vorhandenen unten weglassen
 412
 413     for (SCTAB nTab=0; nTab<=MAXTAB; nTab++)
 414         if (bTabMarked[nTab])
 415         {
 416             ULONG nCount = aOldList.Count();
 417             for (ULONG i=0; i<nCount; i++)
 418             {
 419                 ScRange aRange = *aOldList.GetObject(i);
 420                 aRange.aStart.SetTab(nTab);
 421                 aRange.aEnd.SetTab(nTab);
 422                 pList->Append( aRange );
 423             }
 424         }
 425 }
 426
 427 SCCOLROW ScMarkData::GetMarkColumnRanges( SCCOLROW* pRanges )
 428 {
 429     if (bMarked)
 430         MarkToMulti();
 431
 432     if (!bMultiMarked)
 433         return 0;
 434
 435     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 436
 437     SCCOLROW nRangeCnt = 0;
 438     SCCOLROW nStart = 0;
 439     while (nStart<=MAXCOL)
 440     {
 441         while (nStart<MAXCOL && !pMultiSel[nStart].HasMarks())
 442             ++nStart;
 443         if (pMultiSel[nStart].HasMarks())
 444         {
 445             SCCOLROW nEnd = nStart;
 446             while (nEnd<MAXCOL && pMultiSel[nEnd].HasMarks())
 447                 ++nEnd;
 448             if (!pMultiSel[nEnd].HasMarks())
 449                 --nEnd;
 450             pRanges[2*nRangeCnt  ] = nStart;
 451             pRanges[2*nRangeCnt+1] = nEnd;
 452             ++nRangeCnt;
 453             nStart = nEnd+1;
 454         }
 455         else
 456             nStart = MAXCOL+1;
 457     }
 458
 459     return nRangeCnt;
 460 }
 461
 462 SCCOLROW ScMarkData::GetMarkRowRanges( SCCOLROW* pRanges )
 463 {
 464     if (bMarked)
 465         MarkToMulti();
 466
 467     if (!bMultiMarked)
 468         return 0;
 469
 470     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 471
 472     //  Welche Zeilen sind markiert?
 473
 474     BOOL*   bRowMarked = new BOOL[MAXROW+1];
 475     SCROW  nRow;
 476     SCCOL  nCol;
 477     for (nRow=0; nRow<=MAXROW; nRow++)
 478         bRowMarked[nRow] = FALSE;
 479
 480     SCROW nTop, nBottom;
 481     for (nCol=0; nCol<=MAXCOL; nCol++)
 482     {
 483         ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
 484         while (aMarkIter.Next( nTop, nBottom ))
 485             for (nRow=nTop; nRow<=nBottom; nRow++)
 486                 bRowMarked[nRow] = TRUE;
 487     }
 488
 489     //  zu Bereichen zusammenfassen
 490
 491     SCCOLROW nRangeCnt = 0;
 492     SCCOLROW nStart = 0;
 493     while (nStart<=MAXROW)
 494     {
 495         while (nStart<MAXROW && !bRowMarked[nStart])
 496             ++nStart;
 497         if (bRowMarked[nStart])
 498         {
 499             SCCOLROW nEnd = nStart;
 500             while (nEnd<MAXROW && bRowMarked[nEnd])
 501                 ++nEnd;
 502             if (!bRowMarked[nEnd])
 503                 --nEnd;
 504             pRanges[2*nRangeCnt  ] = nStart;
 505             pRanges[2*nRangeCnt+1] = nEnd;
 506             ++nRangeCnt;
 507             nStart = nEnd+1;
 508         }
 509         else
 510             nStart = MAXROW+1;
 511     }
 512
 513     delete[] bRowMarked;
 514     return nRangeCnt;
 515 }
 516
 517 BOOL ScMarkData::IsAllMarked( const ScRange& rRange ) const
 518 {
 519     if ( !bMultiMarked )
 520         return FALSE;
 521
 522     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 523
 524     SCCOL nStartCol = rRange.aStart.Col();
 525     SCROW nStartRow = rRange.aStart.Row();
 526     SCCOL nEndCol = rRange.aEnd.Col();
 527     SCROW nEndRow = rRange.aEnd.Row();
 528     BOOL bOk = TRUE;
 529     for (SCCOL nCol=nStartCol; nCol<=nEndCol && bOk; nCol++)
 530         if ( !pMultiSel[nCol].IsAllMarked( nStartRow, nEndRow ) )
 531             bOk = FALSE;
 532
 533     return bOk;
 534 }
 535
 536 SCsROW ScMarkData::GetNextMarked( SCCOL nCol, SCsROW nRow, BOOL bUp ) const
 537 {
 538     if ( !bMultiMarked )
 539         return nRow;
 540
 541     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 542
 543     return pMultiSel[nCol].GetNextMarked( nRow, bUp );
 544 }
 545
 546 BOOL ScMarkData::HasMultiMarks( SCCOL nCol ) const
 547 {
 548     if ( !bMultiMarked )
 549         return FALSE;
 550
 551     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 552
 553     return pMultiSel[nCol].HasMarks();
 554 }
 555
 556 BOOL ScMarkData::HasAnyMultiMarks() const
 557 {
 558     if ( !bMultiMarked )
 559         return FALSE;
 560
 561     DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
 562
 563     for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
 564         if ( pMultiSel[nCol].HasMarks() )
 565             return TRUE;
 566
 567     return FALSE;               // nix
 568 }
 569
 570 void ScMarkData::InsertTab( SCTAB nTab )
 571 {
 572     for (SCTAB i=MAXTAB; i>nTab; i--)
 573         bTabMarked[i] = bTabMarked[i-1];
 574     bTabMarked[nTab] = FALSE;
 575 }
 576
 577 void ScMarkData::DeleteTab( SCTAB nTab )
 578 {
 579     for (SCTAB i=nTab; i<MAXTAB; i++)
 580         bTabMarked[i] = bTabMarked[i+1];
 581     bTabMarked[MAXTAB] = FALSE;
 582 }
 583
 584
 585
 586
 587