sc/source/core/data/markarr.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "markarr.hxx"
  21 #include "global.hxx"
  22 #include "address.hxx"
  23
  24 #include <osl/diagnose.h>
  25
  26 // STATIC DATA -----------------------------------------------------------
  27
  28 ScMarkArray::ScMarkArray() :
  29     nCount( 0 ),
  30     nLimit( 0 ),
  31     pData( NULL )
  32 {
  33     // special case "no marks" with pData = NULL
  34 }
  35
  36 ScMarkArray::~ScMarkArray()
  37 {
  38     delete[] pData;
  39 }
  40
  41 void ScMarkArray::Reset( bool bMarked )
  42 {
  43     // always create pData here
  44     // (or have separate method to ensure pData)
  45
  46     delete[] pData;
  47
  48     nCount = nLimit = 1;
  49     pData = new ScMarkEntry[1];
  50     pData[0].nRow = MAXROW;
  51     pData[0].bMarked = bMarked;
  52 }
  53
  54 bool ScMarkArray::Search( SCROW nRow, SCSIZE& nIndex ) const
  55 {
  56     long    nHi         = static_cast<long>(nCount) - 1;
  57     long    i           = 0;
  58     bool    bFound      = (nCount == 1);
  59     if (pData)
  60     {
  61         long    nLo         = 0;
  62         long    nStartRow   = 0;
  63         while ( !bFound && nLo <= nHi )
  64         {
  65             i = (nLo + nHi) / 2;
  66             if (i > 0)
  67                 nStartRow = (long) pData[i - 1].nRow;
  68             else
  69                 nStartRow = -1;
  70             long nEndRow = (long) pData[i].nRow;
  71             if (nEndRow < (long) nRow)
  72                 nLo = ++i;
  73             else
  74                 if (nStartRow >= (long) nRow)
  75                     nHi = --i;
  76                 else
  77                     bFound = true;
  78         }
  79     }
  80     else
  81         bFound = false;
  82
  83     if (bFound)
  84         nIndex=(SCSIZE)i;
  85     else
  86         nIndex=0;
  87     return bFound;
  88 }
  89
  90 bool ScMarkArray::GetMark( SCROW nRow ) const
  91 {
  92     SCSIZE i;
  93     if (Search( nRow, i ))
  94         return pData[i].bMarked;
  95     else
  96         return false;
  97
  98 }
  99
 100 void ScMarkArray::SetMarkArea( SCROW nStartRow, SCROW nEndRow, bool bMarked )
 101 {
 102     if (ValidRow(nStartRow) && ValidRow(nEndRow))
 103     {
 104         if ((nStartRow == 0) && (nEndRow == MAXROW))
 105         {
 106             Reset(bMarked);
 107         }
 108         else
 109         {
 110             if (!pData)
 111                 Reset(false);   // create pData for further processing - could use special case handling!
 112
 113             SCSIZE nNeeded = nCount + 2;
 114             if ( nLimit < nNeeded )
 115             {
 116                 nLimit += SC_MARKARRAY_DELTA;
 117                 if ( nLimit < nNeeded )
 118                     nLimit = nNeeded;
 119                 ScMarkEntry* pNewData = new ScMarkEntry[nLimit];
 120                 memcpy( pNewData, pData, nCount*sizeof(ScMarkEntry) );
 121                 delete[] pData;
 122                 pData = pNewData;
 123             }
 124
 125             SCSIZE ni;          // number of entries in beginning
 126             SCSIZE nInsert;     // insert position (MAXROW+1 := no insert)
 127             bool bCombined = false;
 128             bool bSplit = false;
 129             if ( nStartRow > 0 )
 130             {
 131                 // skip beginning
 132                 SCSIZE nIndex;
 133                 Search( nStartRow, nIndex );
 134                 ni = nIndex;
 135
 136                 nInsert = MAXROWCOUNT;
 137                 if ( pData[ni].bMarked != bMarked )
 138                 {
 139                     if ( ni == 0 || (pData[ni-1].nRow < nStartRow - 1) )
 140                     {   // may be a split or a simple insert or just a shrink,
 141                         // row adjustment is done further down
 142                         if ( pData[ni].nRow > nEndRow )
 143                             bSplit = true;
 144                         ni++;
 145                         nInsert = ni;
 146                     }
 147                     else if ( ni > 0 && pData[ni-1].nRow == nStartRow - 1 )
 148                         nInsert = ni;
 149                 }
 150                 if ( ni > 0 && pData[ni-1].bMarked == bMarked )
 151                 {   // combine
 152                     pData[ni-1].nRow = nEndRow;
 153                     nInsert = MAXROWCOUNT;
 154                     bCombined = true;
 155                 }
 156             }
 157             else
 158         {
 159                 nInsert = 0;
 160                 ni = 0;
 161         }
 162
 163             SCSIZE nj = ni;     // stop position of range to replace
 164             while ( nj < nCount && pData[nj].nRow <= nEndRow )
 165                 nj++;
 166             if ( !bSplit )
 167             {
 168                 if ( nj < nCount && pData[nj].bMarked == bMarked )
 169                 {   // combine
 170                     if ( ni > 0 )
 171                     {
 172                         if ( pData[ni-1].bMarked == bMarked )
 173                         {   // adjacent entries
 174                             pData[ni-1].nRow = pData[nj].nRow;
 175                             nj++;
 176                         }
 177                         else if ( ni == nInsert )
 178                             pData[ni-1].nRow = nStartRow - 1;   // shrink
 179                     }
 180                     nInsert = MAXROWCOUNT;
 181                     bCombined = true;
 182                 }
 183                 else if ( ni > 0 && ni == nInsert )
 184                     pData[ni-1].nRow = nStartRow - 1;   // shrink
 185             }
 186             if ( ni < nj )
 187             {   // remove middle entries
 188                 if ( !bCombined )
 189                 {   // replace one entry
 190                     pData[ni].nRow = nEndRow;
 191                     pData[ni].bMarked = bMarked;
 192                     ni++;
 193                     nInsert = MAXROWCOUNT;
 194                 }
 195                 if ( ni < nj )
 196                 {   // remove entries
 197                     memmove( pData + ni, pData + nj, (nCount - nj) * sizeof(ScMarkEntry) );
 198                     nCount -= nj - ni;
 199                 }
 200             }
 201
 202             if ( nInsert < sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
 203             {   // insert or append new entry
 204                 if ( nInsert <= nCount )
 205                 {
 206                     if ( !bSplit )
 207                         memmove( pData + nInsert + 1, pData + nInsert,
 208                             (nCount - nInsert) * sizeof(ScMarkEntry) );
 209                     else
 210                     {
 211                         memmove( pData + nInsert + 2, pData + nInsert,
 212                             (nCount - nInsert) * sizeof(ScMarkEntry) );
 213                         pData[nInsert+1] = pData[nInsert-1];
 214                         nCount++;
 215                     }
 216                 }
 217                 if ( nInsert )
 218                     pData[nInsert-1].nRow = nStartRow - 1;
 219                 pData[nInsert].nRow = nEndRow;
 220                 pData[nInsert].bMarked = bMarked;
 221                 nCount++;
 222             }
 223         }
 224     }
 225 }
 226
 227 bool ScMarkArray::IsAllMarked( SCROW nStartRow, SCROW nEndRow ) const
 228 {
 229     SCSIZE nStartIndex;
 230     SCSIZE nEndIndex;
 231
 232     if (Search( nStartRow, nStartIndex ))
 233         if (pData[nStartIndex].bMarked)
 234             if (Search( nEndRow, nEndIndex ))
 235                 if (nEndIndex==nStartIndex)
 236                     return true;
 237
 238     return false;
 239 }
 240
 241 bool ScMarkArray::HasOneMark( SCROW& rStartRow, SCROW& rEndRow ) const
 242 {
 243     bool bRet = false;
 244     if ( nCount == 1 )
 245     {
 246         if ( pData[0].bMarked )
 247         {
 248             rStartRow = 0;
 249             rEndRow = MAXROW;
 250             bRet = true;
 251         }
 252     }
 253     else if ( nCount == 2 )
 254     {
 255         if ( pData[0].bMarked )
 256         {
 257             rStartRow = 0;
 258             rEndRow = pData[0].nRow;
 259         }
 260         else
 261         {
 262             rStartRow = pData[0].nRow + 1;
 263             rEndRow = MAXROW;
 264         }
 265         bRet = true;
 266     }
 267     else if ( nCount == 3 )
 268     {
 269         if ( pData[1].bMarked )
 270         {
 271             rStartRow = pData[0].nRow + 1;
 272             rEndRow = pData[1].nRow;
 273             bRet = true;
 274         }
 275     }
 276     return bRet;
 277 }
 278
 279 bool ScMarkArray::HasEqualRowsMarked( const ScMarkArray& rOther ) const
 280 {
 281     if (nCount != rOther.nCount)
 282         return false;
 283
 284     for (size_t i=0; i < nCount; ++i)
 285     {
 286         if (pData[i].bMarked != rOther.pData[i].bMarked ||
 287                 pData[i].nRow != rOther.pData[i].nRow)
 288             return false;
 289     }
 290
 291     return true;
 292 }
 293
 294 void ScMarkArray::CopyMarksTo( ScMarkArray& rDestMarkArray ) const
 295 {
 296     delete[] rDestMarkArray.pData;
 297
 298     if (pData)
 299     {
 300         rDestMarkArray.pData = new ScMarkEntry[nCount];
 301         memcpy( rDestMarkArray.pData, pData, nCount * sizeof(ScMarkEntry) );
 302     }
 303     else
 304         rDestMarkArray.pData = NULL;
 305
 306     rDestMarkArray.nCount = rDestMarkArray.nLimit = nCount;
 307 }
 308
 309 SCsROW ScMarkArray::GetNextMarked( SCsROW nRow, bool bUp ) const
 310 {
 311     if (!pData)
 312         const_cast<ScMarkArray*>(this)->Reset(false);   // create pData for further processing
 313
 314     SCsROW nRet = nRow;
 315     if (ValidRow(nRow))
 316     {
 317         SCSIZE nIndex;
 318         Search(nRow, nIndex);
 319         if (!pData[nIndex].bMarked)
 320         {
 321             if (bUp)
 322             {
 323                 if (nIndex>0)
 324                     nRet = pData[nIndex-1].nRow;
 325                 else
 326                     nRet = -1;
 327             }
 328             else
 329                 nRet = pData[nIndex].nRow + 1;
 330         }
 331     }
 332     return nRet;
 333 }
 334
 335 SCROW ScMarkArray::GetMarkEnd( SCROW nRow, bool bUp ) const
 336 {
 337     if (!pData)
 338         const_cast<ScMarkArray*>(this)->Reset(false);   // create pData for further processing
 339
 340     SCROW nRet;
 341     SCSIZE nIndex;
 342     Search(nRow, nIndex);
 343     OSL_ENSURE( pData[nIndex].bMarked, "GetMarkEnd without bMarked" );
 344     if (bUp)
 345     {
 346         if (nIndex>0)
 347             nRet = pData[nIndex-1].nRow + 1;
 348         else
 349             nRet = 0;
 350     }
 351     else
 352         nRet = pData[nIndex].nRow;
 353
 354     return nRet;
 355 }
 356
 357 //  -------------- Iterator ----------------------------------------------
 358
 359 ScMarkArrayIter::ScMarkArrayIter( const ScMarkArray* pNewArray ) :
 360     pArray( pNewArray ),
 361     nPos( 0 )
 362 {
 363 }
 364
 365 ScMarkArrayIter::~ScMarkArrayIter()
 366 {
 367 }
 368
 369 bool ScMarkArrayIter::Next( SCROW& rTop, SCROW& rBottom )
 370 {
 371     if ( nPos >= pArray->nCount )
 372         return false;
 373     while (!pArray->pData[nPos].bMarked)
 374     {
 375         ++nPos;
 376         if ( nPos >= pArray->nCount )
 377             return false;
 378     }
 379     rBottom = pArray->pData[nPos].nRow;
 380     if (nPos==0)
 381         rTop = 0;
 382     else
 383         rTop = pArray->pData[nPos-1].nRow + 1;
 384     ++nPos;
 385     return true;
 386 }
 387
 388 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */