sc/source/ui/vba/vbaaxis.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 "vbaaxis.hxx"
  21 #include <ooo/vba/excel/XlAxisCrosses.hpp>
  22 #include <ooo/vba/excel/XlAxisType.hpp>
  23 #include <ooo/vba/excel/XlScaleType.hpp>
  24 #include <utility>
  25 #include "vbaaxistitle.hxx"
  26 #include "vbachart.hxx"
  27 using namespace ::com::sun::star;
  28 using namespace ::ooo::vba;
  29 using namespace ::ooo::vba::excel::XlAxisCrosses;
  30 using namespace ::ooo::vba::excel::XlAxisType;
  31 using namespace ::ooo::vba::excel::XlScaleType;
  32
  33 constexpr OUString ORIGIN(u"Origin"_ustr);
  34 constexpr OUString AUTOORIGIN(u"AutoOrigin"_ustr);
  35 constexpr OUString VBA_MIN(u"Max"_ustr);
  36 constexpr OUStringLiteral VBA_MAX(u"Min");
  37 ScVbaChart*
  38 ScVbaAxis::getChartPtr()
  39 {
  40     ScVbaChart* pChart = moChartParent.get();
  41     if ( !pChart )
  42         throw uno::RuntimeException(u"Can't access parent chart impl"_ustr );
  43     return pChart;
  44 }
  45
  46 bool
  47 ScVbaAxis::isValueAxis()
  48 {
  49     if ( getType() == xlCategory )
  50     {
  51         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
  52     }
  53     return true;
  54 }
  55
  56 ScVbaAxis::ScVbaAxis( const rtl::Reference< ScVbaChart >& xParent,
  57                       const uno::Reference< uno::XComponentContext > & xContext,
  58                       uno::Reference< beans::XPropertySet >  _xPropertySet,
  59                       sal_Int32 _nType, sal_Int32 _nGroup )
  60   : ScVbaAxis_BASE( xParent, xContext ),
  61     moChartParent(xParent),
  62     mxPropertySet(std::move( _xPropertySet )),
  63     mnType( _nType ), mnGroup( _nGroup ),
  64     maShapeHelper( uno::Reference< drawing::XShape >( mxPropertySet, uno::UNO_QUERY ) ),
  65     bCrossesAreCustomized( false )
  66 {
  67     setType(_nType);
  68     setCrosses(xlAxisCrossesAutomatic);
  69 }
  70
  71 void SAL_CALL
  72 ScVbaAxis::Delete(  )
  73 {
  74     uno::Reference< lang::XComponent > xComponent( mxPropertySet, uno::UNO_QUERY_THROW );
  75     xComponent->dispose();
  76 }
  77
  78  uno::Reference< ::ooo::vba::excel::XAxisTitle > SAL_CALL
  79 ScVbaAxis::getAxisTitle(  )
  80 {
  81     uno::Reference< excel::XAxisTitle > xAxisTitle;
  82     try
  83     {
  84         ScVbaChart* pChart = getChartPtr();
  85
  86         if (getHasTitle() )
  87         {
  88             int nType = getType();
  89             switch(nType)
  90             {
  91                 case xlCategory:
  92                     xAxisTitle =  new ScVbaAxisTitle(this, mxContext, pChart->xAxisXSupplier->getXAxisTitle());
  93                     break;
  94                 case xlSeriesAxis:
  95                     xAxisTitle = new ScVbaAxisTitle(this, mxContext, pChart->xAxisZSupplier->getZAxisTitle());
  96                     break;
  97                 default: // xlValue:
  98                     xAxisTitle = new ScVbaAxisTitle(this, mxContext, pChart->xAxisYSupplier->getYAxisTitle());
  99                     break;
 100             }
 101         }
 102     }
 103     catch (const uno::Exception& e)
 104     {
 105         DebugHelper::basicexception(e);
 106     }
 107     return xAxisTitle;
 108
 109 }
 110
 111 void SAL_CALL
 112 ScVbaAxis::setDisplayUnit( ::sal_Int32 /*DisplayUnit*/ )
 113 {
 114     DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 115 }
 116
 117 ::sal_Int32 SAL_CALL
 118 ScVbaAxis::getDisplayUnit(  )
 119 {
 120     DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 121     return -1;
 122 }
 123
 124 void SAL_CALL
 125 ScVbaAxis::setCrosses( ::sal_Int32 _nCrosses )
 126 {
 127     try
 128     {
 129         double fNum = 0.0;
 130         switch (_nCrosses)
 131         {
 132             case  xlAxisCrossesAutomatic:       //Microsoft Excel sets the axis crossing point.
 133                 mxPropertySet->setPropertyValue(AUTOORIGIN, uno::Any( true ) );
 134                 bCrossesAreCustomized = false;
 135                 return;
 136             case xlAxisCrossesMinimum:                     // The axis crosses at the minimum value.
 137                 mxPropertySet->getPropertyValue(VBA_MIN) >>= fNum;
 138                 setCrossesAt( fNum );
 139                 bCrossesAreCustomized = false;
 140                 break;
 141             case xlAxisCrossesMaximum:                     // The axis crosses at the maximum value.
 142                 mxPropertySet->getPropertyValue(VBA_MAX) >>= fNum;
 143                 setCrossesAt(fNum);
 144                 bCrossesAreCustomized = false;
 145                 break;
 146             default: //xlAxisCrossesCustom
 147                 bCrossesAreCustomized = true;
 148                 break;
 149         }
 150         mxPropertySet->setPropertyValue(AUTOORIGIN, uno::Any(false) );
 151     }
 152     catch (const uno::Exception&)
 153     {
 154         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 155     }
 156 }
 157 ::sal_Int32 SAL_CALL
 158 ScVbaAxis::getCrosses(  )
 159 {
 160     sal_Int32 nCrosses = xlAxisCrossesCustom;
 161     try
 162     {
 163         bool bisAutoOrigin = false;
 164         mxPropertySet->getPropertyValue(AUTOORIGIN) >>= bisAutoOrigin;
 165         if (bisAutoOrigin)
 166             nCrosses = xlAxisCrossesAutomatic;
 167         else
 168         {
 169             if (bCrossesAreCustomized)
 170                 nCrosses = xlAxisCrossesCustom;
 171             else
 172             {
 173                 double forigin = 0.0;
 174                 mxPropertySet->getPropertyValue(ORIGIN) >>= forigin;
 175                 double fmin = 0.0;
 176                 mxPropertySet->getPropertyValue(VBA_MIN) >>= fmin;
 177                 if (forigin == fmin)
 178                     nCrosses = xlAxisCrossesMinimum;
 179                 else
 180                     nCrosses = xlAxisCrossesMaximum;
 181             }
 182         }
 183     }
 184     catch (uno::Exception& )
 185     {
 186         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 187     }
 188     return nCrosses;
 189 }
 190
 191  void SAL_CALL
 192 ScVbaAxis::setCrossesAt( double _fCrossesAt )
 193 {
 194     try
 195     {
 196         setMaximumScaleIsAuto( false );
 197         setMinimumScaleIsAuto( false );
 198         mxPropertySet->setPropertyValue(ORIGIN, uno::Any(_fCrossesAt));
 199     }
 200     catch (const uno::Exception& e)
 201     {
 202         DebugHelper::basicexception(e);
 203     }
 204 }
 205
 206  double SAL_CALL
 207 ScVbaAxis::getCrossesAt(  )
 208 {
 209     double fCrosses = 0.0;
 210     try
 211     {
 212         mxPropertySet->getPropertyValue(ORIGIN) >>= fCrosses;
 213     }
 214     catch (uno::Exception& )
 215     {
 216         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 217     }
 218     return fCrosses;
 219 }
 220
 221 void SAL_CALL
 222 ScVbaAxis::setType( ::sal_Int32 _nType )
 223 {
 224     mnType = _nType;
 225 }
 226
 227 ::sal_Int32 SAL_CALL
 228 ScVbaAxis::getType(  )
 229 {
 230     return mnType;
 231 }
 232
 233 void SAL_CALL
 234 ScVbaAxis::setHasTitle( sal_Bool _bHasTitle )
 235 {
 236     try
 237     {
 238         ScVbaChart* pChart = getChartPtr();
 239         sal_Int32 nType = getType();
 240         switch(nType)
 241         {
 242             case xlCategory:
 243                 pChart->mxDiagramPropertySet->setPropertyValue(u"HasXAxisTitle"_ustr, uno::Any(_bHasTitle));
 244                 break;
 245             case xlSeriesAxis:
 246                 pChart->mxDiagramPropertySet->setPropertyValue(u"HasZAxisTitle"_ustr, uno::Any(_bHasTitle));
 247                 break;
 248             default: // xlValue:
 249                 pChart->mxDiagramPropertySet->setPropertyValue(u"HasYAxisTitle"_ustr, uno::Any(_bHasTitle));
 250         }
 251
 252     }
 253     catch (const uno::Exception& e)
 254     {
 255         DebugHelper::basicexception(e);
 256     }
 257 }
 258
 259  sal_Bool SAL_CALL
 260 ScVbaAxis::getHasTitle(  )
 261 {
 262     bool bHasTitle = false;
 263     try
 264     {
 265         ScVbaChart* pChart = getChartPtr();
 266         int nType = getType();
 267         switch(nType)
 268         {
 269             case xlCategory:
 270                 pChart->mxDiagramPropertySet->getPropertyValue(u"HasXAxisTitle"_ustr) >>= bHasTitle;
 271                 break;
 272             case xlSeriesAxis:
 273                 pChart->mxDiagramPropertySet->getPropertyValue(u"HasZAxisTitle"_ustr) >>= bHasTitle;
 274                 break;
 275             default: // xlValue:
 276                 pChart->mxDiagramPropertySet->getPropertyValue(u"HasYAxisTitle"_ustr) >>= bHasTitle;
 277         }
 278     }
 279     catch (const uno::Exception& e)
 280     {
 281         DebugHelper::basicexception(e);
 282     }
 283     return bHasTitle;
 284 }
 285
 286 void SAL_CALL
 287 ScVbaAxis::setMinorUnit( double _fMinorUnit )
 288 {
 289     try
 290     {
 291         if (isValueAxis())
 292             mxPropertySet->setPropertyValue(u"StepHelp"_ustr, uno::Any(_fMinorUnit));
 293     }
 294     catch (uno::Exception& )
 295     {
 296         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 297     }
 298 }
 299
 300 double SAL_CALL
 301 ScVbaAxis::getMinorUnit(  )
 302 {
 303     double fMinor = 1.0;
 304     try
 305     {
 306         if (isValueAxis())
 307             mxPropertySet->getPropertyValue(u"StepHelp"_ustr) >>= fMinor;
 308     }
 309     catch (uno::Exception& )
 310     {
 311         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 312     }
 313     return fMinor;
 314 }
 315
 316 void SAL_CALL
 317 ScVbaAxis::setMinorUnitIsAuto( sal_Bool _bMinorUnitIsAuto )
 318 {
 319     try
 320     {
 321         if (isValueAxis())
 322             mxPropertySet->setPropertyValue(u"AutoStepHelp"_ustr, uno::Any(_bMinorUnitIsAuto));
 323     }
 324     catch (uno::Exception& )
 325     {
 326         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 327     }
 328 }
 329
 330  sal_Bool SAL_CALL
 331 ScVbaAxis::getMinorUnitIsAuto(  )
 332 {
 333     bool bIsAuto = false;
 334     try
 335     {
 336         if (isValueAxis())
 337         {
 338             mxPropertySet->getPropertyValue(u"AutoStepHelp"_ustr) >>= bIsAuto;
 339         }
 340     }
 341     catch (const uno::Exception&)
 342     {
 343         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 344     }
 345     return bIsAuto;
 346 }
 347
 348 void SAL_CALL
 349 ScVbaAxis::setReversePlotOrder( sal_Bool /*ReversePlotOrder*/ )
 350 {
 351     DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 352 }
 353
 354 sal_Bool SAL_CALL
 355 ScVbaAxis::getReversePlotOrder(  )
 356 {
 357     DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 358     return false;
 359 }
 360
 361 void SAL_CALL
 362 ScVbaAxis::setMajorUnit( double _fMajorUnit )
 363 {
 364     try
 365     {
 366         if (isValueAxis())
 367         {
 368             mxPropertySet->setPropertyValue(u"StepMain"_ustr, uno::Any(_fMajorUnit));
 369         }
 370     }
 371     catch (const uno::Exception&)
 372     {
 373         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 374     }
 375 }
 376
 377 double SAL_CALL
 378 ScVbaAxis::getMajorUnit(  )
 379 {
 380     double fMax = 1.0;
 381     try
 382     {
 383         if (isValueAxis())
 384             mxPropertySet->getPropertyValue(u"StepMain"_ustr) >>= fMax;
 385     }
 386     catch (const uno::Exception&)
 387     {
 388         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 389     }
 390     return fMax;
 391 }
 392
 393 void SAL_CALL
 394 ScVbaAxis::setMajorUnitIsAuto( sal_Bool _bMajorUnitIsAuto )
 395 {
 396     try
 397     {
 398         if (isValueAxis())
 399         {
 400             mxPropertySet->setPropertyValue(u"AutoStepMain"_ustr, uno::Any( _bMajorUnitIsAuto ));
 401         }
 402     }
 403     catch (const uno::Exception&)
 404     {
 405         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 406     }
 407 }
 408
 409 sal_Bool SAL_CALL
 410 ScVbaAxis::getMajorUnitIsAuto(  )
 411 {
 412     bool bIsAuto = false;
 413     try
 414     {
 415         if (isValueAxis())
 416         {
 417             mxPropertySet->getPropertyValue(u"AutoStepMain"_ustr) >>= bIsAuto;
 418         }
 419     }
 420     catch (const uno::Exception&)
 421     {
 422         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 423     }
 424     return bIsAuto;
 425 }
 426
 427 void SAL_CALL
 428 ScVbaAxis::setMaximumScale( double _fMaximumScale )
 429 {
 430     try
 431     {
 432         if ( isValueAxis() )
 433         {
 434             mxPropertySet->setPropertyValue(u"Max"_ustr, uno::Any(_fMaximumScale));
 435         }
 436     }
 437     catch (const uno::Exception&)
 438     {
 439         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 440     }
 441 }
 442
 443 double SAL_CALL
 444 ScVbaAxis::getMaximumScale(  )
 445 {
 446     double fMax = 1.0;
 447     try
 448     {
 449         if (isValueAxis())
 450         {
 451             mxPropertySet->getPropertyValue(u"Max"_ustr) >>= fMax;
 452         }
 453     }
 454     catch (const uno::Exception&)
 455     {
 456         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 457     }
 458     return fMax;
 459
 460 }
 461
 462 void SAL_CALL
 463 ScVbaAxis::setMaximumScaleIsAuto( sal_Bool _bMaximumScaleIsAuto )
 464 {
 465     try
 466     {
 467         if ( isValueAxis() )
 468             mxPropertySet->setPropertyValue(u"AutoMax"_ustr, uno::Any( _bMaximumScaleIsAuto ));
 469
 470     }
 471     catch (const uno::Exception&)
 472     {
 473         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 474     }
 475 }
 476
 477 sal_Bool SAL_CALL
 478 ScVbaAxis::getMaximumScaleIsAuto(  )
 479 {
 480     bool bIsAuto = false;
 481     try
 482     {
 483         if (isValueAxis())
 484             mxPropertySet->getPropertyValue(u"AutoMax"_ustr) >>= bIsAuto;
 485     }
 486     catch (const uno::Exception&)
 487     {
 488         DebugHelper::basicexception( ERRCODE_BASIC_METHOD_FAILED, {} );
 489     }
 490     return bIsAuto;
 491 }
 492
 493 void SAL_CALL
 494 ScVbaAxis::setMinimumScale( double _fMinimumScale )
 495 {
 496     try
 497     {
 498         if (isValueAxis())
 499             mxPropertySet->setPropertyValue(u"Min"_ustr, uno::Any( _fMinimumScale )  );
 500     }
 501     catch ( uno::Exception& )
 502     {
 503         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 504     }
 505 }
 506
 507 double SAL_CALL
 508 ScVbaAxis::getMinimumScale(  )
 509 {
 510     double fMin = 0.0;
 511     try
 512     {
 513         if (isValueAxis())
 514             mxPropertySet->getPropertyValue(u"Min"_ustr) >>= fMin;
 515     }
 516     catch (const uno::Exception& e)
 517     {
 518         DebugHelper::basicexception(e);
 519     }
 520     return fMin;
 521 }
 522
 523 void SAL_CALL
 524 ScVbaAxis::setMinimumScaleIsAuto( sal_Bool _bMinimumScaleIsAuto )
 525 {
 526     try
 527     {
 528         if (isValueAxis())
 529         {
 530             mxPropertySet->setPropertyValue(u"AutoMin"_ustr, uno::Any(_bMinimumScaleIsAuto));
 531         }
 532     }
 533     catch (const uno::Exception&)
 534     {
 535         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 536     }
 537 }
 538
 539 sal_Bool SAL_CALL
 540 ScVbaAxis::getMinimumScaleIsAuto(  )
 541 {
 542     bool bIsAuto = false;
 543     try
 544     {
 545         if (isValueAxis())
 546         {
 547             mxPropertySet->getPropertyValue(u"AutoMin"_ustr) >>= bIsAuto;
 548         }
 549     }
 550     catch (const uno::Exception&)
 551     {
 552         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 553     }
 554     return bIsAuto;
 555 }
 556
 557 ::sal_Int32 SAL_CALL
 558 ScVbaAxis::getAxisGroup(  )
 559 {
 560     return mnGroup;
 561 }
 562
 563 void SAL_CALL
 564 ScVbaAxis::setScaleType( ::sal_Int32 _nScaleType )
 565 {
 566     try
 567     {
 568         if (isValueAxis())
 569         {
 570             switch (_nScaleType)
 571             {
 572                 case xlScaleLinear:
 573                     mxPropertySet->setPropertyValue(u"Logarithmic"_ustr, uno::Any( false ) );
 574                     break;
 575                 case xlScaleLogarithmic:
 576                     mxPropertySet->setPropertyValue(u"Logarithmic"_ustr, uno::Any( true ) );
 577                     break;
 578                 default:
 579                     // According to MS the parameter is ignored and no Error is thrown
 580                     break;
 581             }
 582         }
 583     }
 584     catch (const uno::Exception&)
 585     {
 586         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 587     }
 588 }
 589
 590 ::sal_Int32 SAL_CALL
 591 ScVbaAxis::getScaleType(  )
 592 {
 593     sal_Int32 nScaleType = xlScaleLinear;
 594     try
 595     {
 596         if (isValueAxis())
 597         {
 598             bool bisLogarithmic = false;
 599             mxPropertySet->getPropertyValue( u"Logarithmic"_ustr ) >>= bisLogarithmic;
 600             if (bisLogarithmic)
 601                 nScaleType = xlScaleLogarithmic;
 602             else
 603                 nScaleType = xlScaleLinear;
 604         }
 605     }
 606     catch (const uno::Exception&)
 607     {
 608         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 609     }
 610     return nScaleType;
 611 }
 612
 613 double SAL_CALL
 614 ScVbaAxis::getHeight(  )
 615 {
 616     return maShapeHelper.getHeight();
 617 }
 618
 619 void SAL_CALL ScVbaAxis::setHeight( double height )
 620 {
 621     maShapeHelper.setHeight( height );
 622 }
 623 double SAL_CALL ScVbaAxis::getWidth(  )
 624 {
 625     return maShapeHelper.getWidth( );
 626 }
 627 void SAL_CALL ScVbaAxis::setWidth( double width )
 628 {
 629     maShapeHelper.setWidth( width );
 630 }
 631 double SAL_CALL ScVbaAxis::getTop(  )
 632 {
 633     return maShapeHelper.getTop( );
 634 }
 635 void SAL_CALL ScVbaAxis::setTop( double top )
 636 {
 637     maShapeHelper.setTop( top );
 638 }
 639 double SAL_CALL ScVbaAxis::getLeft(  )
 640 {
 641     return maShapeHelper.getLeft( );
 642 }
 643 void SAL_CALL ScVbaAxis::setLeft( double left )
 644 {
 645     maShapeHelper.setLeft( left );
 646 }
 647
 648 OUString
 649 ScVbaAxis::getServiceImplName()
 650 {
 651     return u"ScVbaAxis"_ustr;
 652 }
 653
 654 uno::Sequence< OUString >
 655 ScVbaAxis::getServiceNames()
 656 {
 657     static uno::Sequence< OUString > const aServiceNames
 658     {
 659         u"ooo.vba.excel.Axis"_ustr
 660     };
 661     return aServiceNames;
 662 }
 663
 664 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */