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