sc/source/core/tool/refdata.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 "refdata.hxx"
  21
  22 void ScSingleRefData::InitAddress( const ScAddress& rAdr )
  23 {
  24     InitAddress( rAdr.Col(), rAdr.Row(), rAdr.Tab());
  25 }
  26
  27 void ScSingleRefData::InitAddress( SCCOL nColP, SCROW nRowP, SCTAB nTabP )
  28 {
  29     InitFlags();
  30     mnCol = nColP;
  31     mnRow = nRowP;
  32     mnTab = nTabP;
  33 }
  34
  35 void ScSingleRefData::InitAddressRel( const ScAddress& rAdr, const ScAddress& rPos )
  36 {
  37     InitFlags();
  38     SetColRel(true);
  39     SetRowRel(true);
  40     SetTabRel(true);
  41     SetAddress(rAdr, rPos);
  42 }
  43
  44 sal_uInt8 ScSingleRefData::FlagValue() const
  45 {
  46     return mnFlagValue;
  47 }
  48
  49 void ScSingleRefData::SetAbsCol( SCCOL nVal )
  50 {
  51     Flags.bColRel = false;
  52     mnCol = nVal;
  53 }
  54
  55 void ScSingleRefData::SetRelCol( SCCOL nVal )
  56 {
  57     Flags.bColRel = true;
  58     mnCol = nVal;
  59 }
  60
  61 void ScSingleRefData::IncCol( SCCOL nInc )
  62 {
  63     mnCol += nInc;
  64 }
  65
  66 void ScSingleRefData::SetAbsRow( SCROW nVal )
  67 {
  68     Flags.bRowRel = false;
  69     mnRow = nVal;
  70 }
  71
  72 void ScSingleRefData::SetRelRow( SCROW nVal )
  73 {
  74     Flags.bRowRel = true;
  75     mnRow = nVal;
  76 }
  77
  78 void ScSingleRefData::IncRow( SCROW nInc )
  79 {
  80     mnRow += nInc;
  81 }
  82
  83 void ScSingleRefData::SetAbsTab( SCTAB nVal )
  84 {
  85     Flags.bTabRel = false;
  86     mnTab = nVal;
  87 }
  88
  89 void ScSingleRefData::SetRelTab( SCTAB nVal )
  90 {
  91     Flags.bTabRel = true;
  92     mnTab = nVal;
  93 }
  94
  95 void ScSingleRefData::IncTab( SCTAB nInc )
  96 {
  97     mnTab += nInc;
  98 }
  99
 100 void ScSingleRefData::SetColDeleted( bool bVal )
 101 {
 102     Flags.bColDeleted = bVal;
 103 }
 104
 105 bool ScSingleRefData::IsColDeleted() const
 106 {
 107     return Flags.bColDeleted;
 108 }
 109
 110 void ScSingleRefData::SetRowDeleted( bool bVal )
 111 {
 112     Flags.bRowDeleted = bVal;
 113 }
 114
 115 bool ScSingleRefData::IsRowDeleted() const
 116 {
 117     return Flags.bRowDeleted;
 118 }
 119
 120 void ScSingleRefData::SetTabDeleted( bool bVal )
 121 {
 122     Flags.bTabDeleted = bVal;
 123 }
 124
 125 bool ScSingleRefData::IsTabDeleted() const
 126 {
 127     return Flags.bTabDeleted;
 128 }
 129
 130 bool ScSingleRefData::IsDeleted() const
 131 {
 132     return IsColDeleted() || IsRowDeleted() || IsTabDeleted();
 133 }
 134
 135 bool ScSingleRefData::Valid() const
 136 {
 137     return ColValid() && RowValid() && TabValid();
 138 }
 139
 140 bool ScSingleRefData::ColValid() const
 141 {
 142     if (Flags.bColRel)
 143     {
 144         if (mnCol < -MAXCOL || MAXCOL < mnCol)
 145             return false;
 146     }
 147     else
 148     {
 149         if (mnCol < 0 || MAXCOL < mnCol)
 150             return false;
 151     }
 152
 153     return true;
 154 }
 155
 156 bool ScSingleRefData::RowValid() const
 157 {
 158     if (Flags.bRowRel)
 159     {
 160         if (mnRow < -MAXROW || MAXROW < mnRow)
 161             return false;
 162     }
 163     else
 164     {
 165         if (mnRow < 0 || MAXROW < mnRow)
 166             return false;
 167     }
 168
 169     return true;
 170 }
 171
 172 bool ScSingleRefData::TabValid() const
 173 {
 174     if (Flags.bTabRel)
 175     {
 176         if (mnTab < -MAXTAB || MAXTAB < mnTab)
 177             return false;
 178     }
 179     else
 180     {
 181         if (mnTab < 0 || MAXTAB < mnTab)
 182             return false;
 183     }
 184
 185     return true;
 186 }
 187
 188 bool ScSingleRefData::ValidExternal() const
 189 {
 190     return ColValid() && RowValid() && mnTab == -1;
 191 }
 192
 193 ScAddress ScSingleRefData::toAbs( const ScAddress& rPos ) const
 194 {
 195     SCCOL nRetCol = Flags.bColRel ? mnCol + rPos.Col() : mnCol;
 196     SCROW nRetRow = Flags.bRowRel ? mnRow + rPos.Row() : mnRow;
 197     SCTAB nRetTab = Flags.bTabRel ? mnTab + rPos.Tab() : mnTab;
 198
 199     ScAddress aAbs(ScAddress::INITIALIZE_INVALID);
 200
 201     if (ValidCol(nRetCol))
 202         aAbs.SetCol(nRetCol);
 203
 204     if (ValidRow(nRetRow))
 205         aAbs.SetRow(nRetRow);
 206
 207     if (ValidTab(nRetTab))
 208         aAbs.SetTab(nRetTab);
 209
 210     return aAbs;
 211 }
 212
 213 void ScSingleRefData::SetAddress( const ScAddress& rAddr, const ScAddress& rPos )
 214 {
 215     if (Flags.bColRel)
 216         mnCol = rAddr.Col() - rPos.Col();
 217     else
 218         mnCol = rAddr.Col();
 219
 220     if (Flags.bRowRel)
 221         mnRow = rAddr.Row() - rPos.Row();
 222     else
 223         mnRow = rAddr.Row();
 224
 225     if (Flags.bTabRel)
 226         mnTab = rAddr.Tab() - rPos.Tab();
 227     else
 228         mnTab = rAddr.Tab();
 229 }
 230
 231 SCROW ScSingleRefData::Row() const
 232 {
 233     if (Flags.bRowDeleted)
 234         return -1;
 235     return mnRow;
 236 }
 237
 238 SCCOL ScSingleRefData::Col() const
 239 {
 240     if (Flags.bColDeleted)
 241         return -1;
 242     return mnCol;
 243 }
 244
 245 SCTAB ScSingleRefData::Tab() const
 246 {
 247     if (Flags.bTabDeleted)
 248         return -1;
 249     return mnTab;
 250 }
 251
 252 bool ScSingleRefData::operator==( const ScSingleRefData& r ) const
 253 {
 254     return mnFlagValue == r.mnFlagValue && mnCol == r.mnCol && mnRow == r.mnRow && mnTab == r.mnTab;
 255 }
 256
 257 bool ScSingleRefData::operator!=( const ScSingleRefData& r ) const
 258 {
 259     return !operator==(r);
 260 }
 261
 262 #if DEBUG_FORMULA_COMPILER
 263 void ScSingleRefData::Dump( int nIndent ) const
 264 {
 265     std::string aIndent;
 266     for (int i = 0; i < nIndent; ++i)
 267         aIndent += "  ";
 268
 269     cout << aIndent << "address type column: " << (IsColRel()?"relative":"absolute")
 270          << "  row : " << (IsRowRel()?"relative":"absolute") << "  sheet: "
 271          << (IsTabRel()?"relative":"absolute") << endl;
 272     cout << aIndent << "deleted column: " << (IsColDeleted()?"yes":"no")
 273          << "  row : " << (IsRowDeleted()?"yes":"no") << "  sheet: "
 274          << (IsTabDeleted()?"yes":"no") << endl;
 275     cout << aIndent << "column: " << mnCol << "  row: " << mnRow << "  sheet: " << mnTab << endl;
 276     cout << aIndent << "3d ref: " << (IsFlag3D()?"yes":"no") << endl;
 277 }
 278 #endif
 279
 280 ScComplexRefData& ScComplexRefData::Extend( const ScSingleRefData & rRef, const ScAddress & rPos )
 281 {
 282     ScRange aAbsRange = toAbs(rPos);
 283     ScAddress aAbs = rRef.toAbs(rPos);
 284
 285     if (aAbs.Col() < aAbsRange.aStart.Col())
 286         aAbsRange.aStart.SetCol(aAbs.Col());
 287
 288     if (aAbs.Row() < aAbsRange.aStart.Row())
 289         aAbsRange.aStart.SetRow(aAbs.Row());
 290
 291     if (aAbs.Tab() < aAbsRange.aStart.Tab())
 292         aAbsRange.aStart.SetTab(aAbs.Tab());
 293
 294     if (aAbsRange.aEnd.Col() < aAbs.Col())
 295         aAbsRange.aEnd.SetCol(aAbs.Col());
 296
 297     if (aAbsRange.aEnd.Row() < aAbs.Row())
 298         aAbsRange.aEnd.SetRow(aAbs.Row());
 299
 300     if (aAbsRange.aEnd.Tab() < aAbs.Tab())
 301         aAbsRange.aEnd.SetTab(aAbs.Tab());
 302
 303     SetRange(aAbsRange, rPos);
 304
 305     return *this;
 306 }
 307
 308
 309 ScComplexRefData& ScComplexRefData::Extend( const ScComplexRefData & rRef, const ScAddress & rPos )
 310 {
 311     return Extend( rRef.Ref1, rPos).Extend( rRef.Ref2, rPos);
 312 }
 313
 314 bool ScComplexRefData::IsDeleted() const
 315 {
 316     return Ref1.IsDeleted() || Ref2.IsDeleted();
 317 }
 318
 319 bool ScComplexRefData::Valid() const
 320 {
 321     return Ref1.Valid() && Ref2.Valid();
 322 }
 323
 324 bool ScComplexRefData::ValidExternal() const
 325 {
 326     return Ref1.ValidExternal() && Ref2.ColValid() && Ref2.RowValid() && Ref1.Tab() <= Ref2.Tab();
 327 }
 328
 329 ScRange ScComplexRefData::toAbs( const ScAddress& rPos ) const
 330 {
 331     return ScRange(Ref1.toAbs(rPos), Ref2.toAbs(rPos));
 332 }
 333
 334 void ScComplexRefData::SetRange( const ScRange& rRange, const ScAddress& rPos )
 335 {
 336     Ref1.SetAddress(rRange.aStart, rPos);
 337     Ref2.SetAddress(rRange.aEnd, rPos);
 338 }
 339
 340 #if DEBUG_FORMULA_COMPILER
 341 void ScComplexRefData::Dump( int nIndent ) const
 342 {
 343     std::string aIndent;
 344     for (int i = 0; i < nIndent; ++i)
 345         aIndent += "  ";
 346
 347     cout << aIndent << "ref 1" << endl;
 348     Ref1.Dump(nIndent+1);
 349     cout << aIndent << "ref 2" << endl;
 350     Ref2.Dump(nIndent+1);
 351 }
 352 #endif
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */