sw/source/ui/utlui/prcntfld.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
  21 #include "prcntfld.hxx"
  22
  23 PercentField::PercentField( Window* pWin, const ResId& rResId ) :
  24         MetricField ( pWin, rResId ),
  25
  26         nOldMax     (0),
  27         nOldMin     (0),
  28         nLastPercent(-1),
  29         nLastValue  (-1),
  30         eOldUnit    (FUNIT_NONE),
  31         bLockAutoCalculation(sal_False)
  32 {
  33
  34     nOldSpinSize = GetSpinSize();
  35     nRefValue = DenormalizePercent(MetricField::GetMax(FUNIT_TWIP));
  36     nOldDigits = GetDecimalDigits();
  37     SetCustomUnitText(OUString('%'));
  38 }
  39
  40 PercentFieldWrap::PercentFieldWrap()
  41     : nOldMax(0)
  42     , nOldMin(0)
  43     , nLastPercent(-1)
  44     , nLastValue(-1)
  45     , eOldUnit(FUNIT_NONE)
  46     , bLockAutoCalculation(sal_False)
  47 {
  48 }
  49
  50 void PercentFieldWrap::set(MetricField *pField)
  51 {
  52     m_pField = pField;
  53     nOldSpinSize = m_pField->GetSpinSize();
  54     nRefValue = DenormalizePercent(m_pField->GetMax(FUNIT_TWIP));
  55     nOldDigits = m_pField->GetDecimalDigits();
  56     m_pField->SetCustomUnitText(OUString('%'));
  57 }
  58
  59 void PercentField::SetRefValue(sal_Int64 nValue)
  60 {
  61     sal_Int64 nRealValue = GetRealValue(eOldUnit);
  62
  63     nRefValue = nValue;
  64
  65     if (!bLockAutoCalculation && (GetUnit() == FUNIT_CUSTOM))
  66         SetPrcntValue(nRealValue, eOldUnit);
  67 }
  68
  69 void PercentFieldWrap::SetRefValue(sal_Int64 nValue)
  70 {
  71     sal_Int64 nRealValue = GetRealValue(eOldUnit);
  72
  73     nRefValue = nValue;
  74
  75     if (!bLockAutoCalculation && (m_pField->GetUnit() == FUNIT_CUSTOM))
  76         SetPrcntValue(nRealValue, eOldUnit);
  77 }
  78
  79 void PercentField::ShowPercent(sal_Bool bPercent)
  80 {
  81     if ((bPercent && GetUnit() == FUNIT_CUSTOM) ||
  82         (!bPercent && GetUnit() != FUNIT_CUSTOM))
  83         return;
  84
  85     sal_Int64 nOldValue;
  86
  87     if (bPercent)
  88     {
  89         sal_Int64 nAktWidth, nPercent;
  90
  91         nOldValue = GetValue();
  92
  93         eOldUnit = GetUnit();
  94         nOldDigits = GetDecimalDigits();
  95         nOldMin = GetMin();
  96         nOldMax = GetMax();
  97         nOldSpinSize = GetSpinSize();
  98         nOldBaseValue = GetBaseValue();
  99         SetUnit(FUNIT_CUSTOM);
 100         SetDecimalDigits( 0 );
 101
 102         nAktWidth = ConvertValue(nOldMin, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 103         // round to 0.5 percent
 104         nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 105
 106         MetricField::SetMin(std::max(static_cast< sal_Int64 >(1), nPercent));
 107         MetricField::SetMax(100);
 108         SetSpinSize(5);
 109         MetricField::SetBaseValue(0);
 110         if (nOldValue != nLastValue)
 111         {
 112             nAktWidth = ConvertValue(nOldValue, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 113             nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 114             MetricFormatter::SetValue(nPercent);
 115             nLastPercent = nPercent;
 116             nLastValue = nOldValue;
 117         }
 118         else
 119             MetricFormatter::SetValue(nLastPercent);
 120     }
 121     else
 122     {
 123         sal_Int64 nOldPercent = GetValue(FUNIT_CUSTOM);
 124
 125         nOldValue = Convert(GetValue(), GetUnit(), eOldUnit);
 126
 127         SetUnit(eOldUnit);
 128         SetDecimalDigits(nOldDigits);
 129         MetricField::SetMin(nOldMin);
 130         MetricField::SetMax(nOldMax);
 131         SetSpinSize(nOldSpinSize);
 132         MetricField::SetBaseValue(nOldBaseValue);
 133
 134         if (nOldPercent != nLastPercent)
 135         {
 136             SetPrcntValue(nOldValue, eOldUnit);
 137             nLastPercent = nOldPercent;
 138             nLastValue = nOldValue;
 139         }
 140         else
 141             SetPrcntValue(nLastValue, eOldUnit);
 142     }
 143 }
 144
 145 void PercentFieldWrap::ShowPercent(bool bPercent)
 146 {
 147     if ((bPercent && m_pField->GetUnit() == FUNIT_CUSTOM) ||
 148         (!bPercent && m_pField->GetUnit() != FUNIT_CUSTOM))
 149         return;
 150
 151     sal_Int64 nOldValue;
 152
 153     if (bPercent)
 154     {
 155         sal_Int64 nAktWidth, nPercent;
 156
 157         nOldValue = GetValue();
 158
 159         eOldUnit = m_pField->GetUnit();
 160         nOldDigits = m_pField->GetDecimalDigits();
 161         nOldMin = m_pField->GetMin();
 162         nOldMax = m_pField->GetMax();
 163         nOldSpinSize = m_pField->GetSpinSize();
 164         nOldBaseValue = m_pField->GetBaseValue();
 165         m_pField->SetUnit(FUNIT_CUSTOM);
 166         m_pField->SetDecimalDigits( 0 );
 167
 168         nAktWidth = m_pField->ConvertValue(nOldMin, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 169         // round to 0.5 percent
 170         nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 171
 172         m_pField->SetMin(std::max(static_cast< sal_Int64 >(1), nPercent));
 173         m_pField->SetMax(100);
 174         m_pField->SetSpinSize(5);
 175         m_pField->SetBaseValue(0);
 176         if (nOldValue != nLastValue)
 177         {
 178             nAktWidth = m_pField->ConvertValue(nOldValue, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 179             nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 180             m_pField->SetValue(nPercent);
 181             nLastPercent = nPercent;
 182             nLastValue = nOldValue;
 183         }
 184         else
 185             m_pField->SetValue(nLastPercent);
 186     }
 187     else
 188     {
 189         sal_Int64 nOldPercent = GetValue(FUNIT_CUSTOM);
 190
 191         nOldValue = Convert(GetValue(), m_pField->GetUnit(), eOldUnit);
 192
 193         m_pField->SetUnit(eOldUnit);
 194         m_pField->SetDecimalDigits(nOldDigits);
 195         m_pField->SetMin(nOldMin);
 196         m_pField->SetMax(nOldMax);
 197         m_pField->SetSpinSize(nOldSpinSize);
 198         m_pField->SetBaseValue(nOldBaseValue);
 199
 200         if (nOldPercent != nLastPercent)
 201         {
 202             SetPrcntValue(nOldValue, eOldUnit);
 203             nLastPercent = nOldPercent;
 204             nLastValue = nOldValue;
 205         }
 206         else
 207             SetPrcntValue(nLastValue, eOldUnit);
 208     }
 209 }
 210
 211 void PercentField::SetValue(sal_Int64 nNewValue, FieldUnit eInUnit)
 212 {
 213    MetricFormatter::SetValue(nNewValue, eInUnit);
 214 }
 215
 216 void PercentField::SetPrcntValue(sal_Int64 nNewValue, FieldUnit eInUnit)
 217 {
 218     if (GetUnit() != FUNIT_CUSTOM || eInUnit == FUNIT_CUSTOM)
 219         MetricFormatter::SetValue(Convert(nNewValue, eInUnit, GetUnit()));
 220
 221     else
 222     {
 223         // Overwrite output value, do not restore later
 224         sal_Int64 nPercent, nAktWidth;
 225         if(eInUnit == FUNIT_TWIP)
 226         {
 227             nAktWidth = ConvertValue(nNewValue, 0, nOldDigits, FUNIT_TWIP, FUNIT_TWIP);
 228         }
 229         else
 230         {
 231             sal_Int64 nValue = Convert(nNewValue, eInUnit, eOldUnit);
 232             nAktWidth = ConvertValue(nValue, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 233         }
 234         nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 235         MetricFormatter::SetValue(nPercent);
 236     }
 237 }
 238
 239 void PercentFieldWrap::SetPrcntValue(sal_Int64 nNewValue, FieldUnit eInUnit)
 240 {
 241     if (m_pField->GetUnit() != FUNIT_CUSTOM || eInUnit == FUNIT_CUSTOM)
 242         m_pField->SetValue(Convert(nNewValue, eInUnit, m_pField->GetUnit()));
 243     else
 244     {
 245         // Overwrite output value, do not restore later
 246         sal_Int64 nPercent, nAktWidth;
 247         if(eInUnit == FUNIT_TWIP)
 248         {
 249             nAktWidth = m_pField->ConvertValue(nNewValue, 0, nOldDigits, FUNIT_TWIP, FUNIT_TWIP);
 250         }
 251         else
 252         {
 253             sal_Int64 nValue = Convert(nNewValue, eInUnit, eOldUnit);
 254             nAktWidth = m_pField->ConvertValue(nValue, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 255         }
 256         nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 257         m_pField->SetValue(nPercent);
 258     }
 259 }
 260
 261 void PercentField::SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit )
 262 {
 263     if (GetUnit() != FUNIT_CUSTOM || eInUnit == FUNIT_CUSTOM)
 264         MetricField::SetUserValue(Convert(nNewValue, eInUnit, GetUnit()),FUNIT_NONE);
 265
 266     else
 267     {
 268         // Overwrite output value, do not restore later
 269         sal_Int64 nPercent, nAktWidth;
 270         if(eInUnit == FUNIT_TWIP)
 271         {
 272             nAktWidth = ConvertValue(nNewValue, 0, nOldDigits, FUNIT_TWIP, FUNIT_TWIP);
 273         }
 274         else
 275         {
 276             sal_Int64 nValue = Convert(nNewValue, eInUnit, eOldUnit);
 277             nAktWidth = ConvertValue(nValue, 0, nOldDigits, eOldUnit, FUNIT_TWIP);
 278         }
 279         nPercent = ((nAktWidth * 10) / nRefValue + 5) / 10;
 280         MetricField::SetUserValue(nPercent,FUNIT_NONE);
 281     }
 282
 283 }
 284
 285 void PercentField::SetBaseValue(sal_Int64 nNewValue, FieldUnit eInUnit)
 286 {
 287     if (GetUnit() == FUNIT_CUSTOM)
 288         nOldBaseValue = ConvertValue(nNewValue, 0, nOldDigits, eInUnit, eOldUnit);
 289     else
 290         MetricField::SetBaseValue(nNewValue, eInUnit);
 291 }
 292
 293 sal_Int64 PercentField::GetValue( FieldUnit eOutUnit )
 294 {
 295     return Convert(MetricField::GetValue(), GetUnit(), eOutUnit);
 296 }
 297
 298 sal_Int64 PercentFieldWrap::GetValue(FieldUnit eOutUnit)
 299 {
 300     return Convert(m_pField->GetValue(), m_pField->GetUnit(), eOutUnit);
 301 }
 302
 303 void PercentField::SetMin(sal_Int64 nNewMin, FieldUnit eInUnit)
 304 {
 305     if (GetUnit() != FUNIT_CUSTOM)
 306         MetricField::SetMin(nNewMin, eInUnit);
 307     else
 308     {
 309         if (eInUnit == FUNIT_NONE)
 310             eInUnit = eOldUnit;
 311         nOldMin = Convert(nNewMin, eInUnit, eOldUnit);
 312
 313         sal_Int64 nPercent = Convert(nNewMin, eInUnit, FUNIT_CUSTOM);
 314         MetricField::SetMin(std::max( static_cast< sal_Int64 >(1), nPercent));
 315     }
 316 }
 317
 318 void PercentFieldWrap::SetMin(sal_Int64 nNewMin, FieldUnit eInUnit)
 319 {
 320     if (m_pField->GetUnit() != FUNIT_CUSTOM)
 321         m_pField->SetMin(nNewMin, eInUnit);
 322     else
 323     {
 324         if (eInUnit == FUNIT_NONE)
 325             eInUnit = eOldUnit;
 326         nOldMin = Convert(nNewMin, eInUnit, eOldUnit);
 327
 328         sal_Int64 nPercent = Convert(nNewMin, eInUnit, FUNIT_CUSTOM);
 329         m_pField->SetMin(std::max( static_cast< sal_Int64 >(1), nPercent));
 330     }
 331 }
 332
 333 void PercentField::SetMax(sal_Int64 nNewMax, FieldUnit eInUnit)
 334 {
 335     if (GetUnit() != FUNIT_CUSTOM)
 336         MetricField::SetMax(nNewMax, eInUnit);
 337     else
 338     {
 339         if (eInUnit == FUNIT_NONE)
 340             eInUnit = eOldUnit;
 341     }
 342 }
 343
 344 void PercentFieldWrap::SetMax(sal_Int64 nNewMax, FieldUnit eInUnit)
 345 {
 346     if (m_pField->GetUnit() != FUNIT_CUSTOM)
 347         m_pField->SetMax(nNewMax, eInUnit);
 348     else
 349     {
 350         if (eInUnit == FUNIT_NONE)
 351             eInUnit = eOldUnit;
 352     }
 353 }
 354
 355 sal_Int64 PercentField::NormalizePercent(sal_Int64 nValue)
 356 {
 357     if (GetUnit() != FUNIT_CUSTOM)
 358         nValue = MetricField::Normalize(nValue);
 359     else
 360         nValue = nValue * ImpPower10(nOldDigits);
 361
 362     return nValue;
 363 }
 364
 365 sal_Int64 PercentFieldWrap::NormalizePercent(sal_Int64 nValue)
 366 {
 367     if (m_pField->GetUnit() != FUNIT_CUSTOM)
 368         nValue = m_pField->Normalize(nValue);
 369     else
 370         nValue = nValue * ImpPower10(nOldDigits);
 371     return nValue;
 372 }
 373
 374 sal_Int64 PercentField::DenormalizePercent(sal_Int64 nValue)
 375 {
 376     if (GetUnit() != FUNIT_CUSTOM)
 377         nValue = MetricField::Denormalize(nValue);
 378     else
 379     {
 380         sal_Int64 nFactor = ImpPower10(nOldDigits);
 381         nValue = ((nValue+(nFactor/2)) / nFactor);
 382     }
 383
 384     return nValue;
 385 }
 386
 387 sal_Int64 PercentFieldWrap::DenormalizePercent(sal_Int64 nValue)
 388 {
 389     if (m_pField->GetUnit() != FUNIT_CUSTOM)
 390         nValue = m_pField->Denormalize(nValue);
 391     else
 392     {
 393         sal_Int64 nFactor = ImpPower10(nOldDigits);
 394         nValue = ((nValue+(nFactor/2)) / nFactor);
 395     }
 396     return nValue;
 397 }
 398
 399 sal_Bool PercentField::IsValueModified()
 400 {
 401     if (GetUnit() == FUNIT_CUSTOM)
 402         return sal_True;
 403     else
 404         return MetricField::IsValueModified();
 405 }
 406
 407 sal_Int64 PercentField::ImpPower10( sal_uInt16 n )
 408 {
 409     sal_uInt16 i;
 410     sal_Int64   nValue = 1;
 411
 412     for ( i=0; i < n; i++ )
 413         nValue *= 10;
 414
 415     return nValue;
 416 }
 417
 418 sal_Int64 PercentFieldWrap::ImpPower10(sal_uInt16 n)
 419 {
 420     sal_Int64 nValue = 1;
 421
 422     for (sal_uInt16 i=0; i < n; ++i)
 423         nValue *= 10;
 424
 425     return nValue;
 426 }
 427
 428 sal_Int64 PercentField::GetRealValue(FieldUnit eOutUnit)
 429 {
 430     if (GetUnit() != FUNIT_CUSTOM)
 431         return GetValue(eOutUnit);
 432     else
 433         return Convert(GetValue(), GetUnit(), eOutUnit);
 434 }
 435
 436 sal_Int64 PercentFieldWrap::GetRealValue(FieldUnit eOutUnit)
 437 {
 438     if (m_pField->GetUnit() != FUNIT_CUSTOM)
 439         return GetValue(eOutUnit);
 440     else
 441         return Convert(GetValue(), m_pField->GetUnit(), eOutUnit);
 442 }
 443
 444 sal_Int64 PercentField::Convert(sal_Int64 nValue, FieldUnit eInUnit, FieldUnit eOutUnit)
 445 {
 446     if (eInUnit == eOutUnit ||
 447         (eInUnit == FUNIT_NONE && eOutUnit == GetUnit()) ||
 448         (eOutUnit == FUNIT_NONE && eInUnit == GetUnit()))
 449         return nValue;
 450
 451     if (eInUnit == FUNIT_CUSTOM)
 452     {
 453         // Convert to metric
 454         sal_Int64 nTwipValue = (nRefValue * nValue + 50) / 100;
 455
 456         if (eOutUnit == FUNIT_TWIP) // Only convert if necessary
 457             return NormalizePercent(nTwipValue);
 458         else
 459             return ConvertValue(NormalizePercent(nTwipValue), 0, nOldDigits, FUNIT_TWIP, eOutUnit);
 460     }
 461
 462     if (eOutUnit == FUNIT_CUSTOM)
 463     {
 464         // Convert to percent
 465         sal_Int64 nAktWidth;
 466         nValue = DenormalizePercent(nValue);
 467
 468         if (eInUnit == FUNIT_TWIP)  // Only convert if necessary
 469             nAktWidth = nValue;
 470         else
 471             nAktWidth = ConvertValue(nValue, 0, nOldDigits, eInUnit, FUNIT_TWIP);
 472         // Round to 0.5 percent
 473         return ((nAktWidth * 1000) / nRefValue + 5) / 10;
 474     }
 475
 476     return ConvertValue(nValue, 0, nOldDigits, eInUnit, eOutUnit);
 477 }
 478
 479 sal_Int64 PercentFieldWrap::Convert(sal_Int64 nValue, FieldUnit eInUnit, FieldUnit eOutUnit)
 480 {
 481     if (eInUnit == eOutUnit ||
 482         (eInUnit == FUNIT_NONE && eOutUnit == m_pField->GetUnit()) ||
 483         (eOutUnit == FUNIT_NONE && eInUnit == m_pField->GetUnit()))
 484         return nValue;
 485
 486     if (eInUnit == FUNIT_CUSTOM)
 487     {
 488         // Convert to metric
 489         sal_Int64 nTwipValue = (nRefValue * nValue + 50) / 100;
 490
 491         if (eOutUnit == FUNIT_TWIP) // Only convert if necessary
 492             return NormalizePercent(nTwipValue);
 493         else
 494             return m_pField->ConvertValue(NormalizePercent(nTwipValue), 0, nOldDigits, FUNIT_TWIP, eOutUnit);
 495     }
 496
 497     if (eOutUnit == FUNIT_CUSTOM)
 498     {
 499         // Convert to percent
 500         sal_Int64 nAktWidth;
 501         nValue = DenormalizePercent(nValue);
 502
 503         if (eInUnit == FUNIT_TWIP)  // Only convert if necessary
 504             nAktWidth = nValue;
 505         else
 506             nAktWidth = m_pField->ConvertValue(nValue, 0, nOldDigits, eInUnit, FUNIT_TWIP);
 507         // Round to 0.5 percent
 508         return ((nAktWidth * 1000) / nRefValue + 5) / 10;
 509     }
 510
 511     return m_pField->ConvertValue(nValue, 0, nOldDigits, eInUnit, eOutUnit);
 512 }
 513
 514 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */