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