LibreOffice Module sc (master)  1
vbaaxis.cxx
Go to the documentation of this file.
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 constexpr OUStringLiteral ORIGIN(u"Origin");
33 constexpr OUStringLiteral AUTOORIGIN(u"AutoOrigin");
34 constexpr OUStringLiteral VBA_MIN(u"Max");
35 constexpr OUStringLiteral VBA_MAX(u"Min");
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
47 {
48  if ( getType() == xlCategory )
49  {
50  DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
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
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
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, {});
107 }
108 
109 ::sal_Int32 SAL_CALL
111 {
112  DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
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, {});
147  }
148 }
149 ::sal_Int32 SAL_CALL
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  {
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, {} );
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
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, {});
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
221 {
222  return mnType;
223 }
224 
225 void SAL_CALL
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
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, {});
289  }
290 }
291 
292 double SAL_CALL
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, {});
304  }
305  return fMinor;
306 }
307 
308 void SAL_CALL
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, {} );
319  }
320 }
321 
322  sal_Bool SAL_CALL
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, {});
336  }
337  return bIsAuto;
338 }
339 
340 void SAL_CALL
342 {
343  DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
344 }
345 
346 sal_Bool SAL_CALL
348 {
349  DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
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, {});
366  }
367 }
368 
369 double SAL_CALL
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, {} );
381  }
382  return fMax;
383 }
384 
385 void SAL_CALL
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, {});
398  }
399 }
400 
401 sal_Bool SAL_CALL
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, {});
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, {});
432  }
433 }
434 
435 double SAL_CALL
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, {});
449  }
450  return fMax;
451 
452 }
453 
454 void SAL_CALL
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, {});
466  }
467 }
468 
469 sal_Bool SAL_CALL
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, {} );
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, {} );
496  }
497 }
498 
499 double SAL_CALL
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
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, {});
528  }
529 }
530 
531 sal_Bool SAL_CALL
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, {});
545  }
546  return bIsAuto;
547 }
548 
549 ::sal_Int32 SAL_CALL
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, {});
579  }
580 }
581 
582 ::sal_Int32 SAL_CALL
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, {});
601  }
602  return nScaleType;
603 }
604 
605 double SAL_CALL
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
642 {
643  return "ScVbaAxis";
644 }
645 
646 uno::Sequence< OUString >
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: */
virtual void SAL_CALL setHeight(double height) override
Definition: vbaaxis.cxx:611
sal_Int32 mnType
Definition: vbaaxis.hxx:32
bool isValueAxis()
Definition: vbaaxis.cxx:46
virtual void SAL_CALL setDisplayUnit(::sal_Int32 DisplayUnit) override
Definition: vbaaxis.cxx:104
virtual double SAL_CALL getMajorUnit() override
Definition: vbaaxis.cxx:370
virtual sal_Bool SAL_CALL getMinimumScaleIsAuto() override
Definition: vbaaxis.cxx:532
css::uno::Reference< css::chart::XAxisZSupplier > xAxisZSupplier
Definition: vbachart.hxx:46
virtual sal_Bool SAL_CALL getMaximumScaleIsAuto() override
Definition: vbaaxis.cxx:470
virtual void SAL_CALL setScaleType(::sal_Int32 ScaleType) override
Definition: vbaaxis.cxx:556
virtual void SAL_CALL setMaximumScale(double MaximumScale) override
Definition: vbaaxis.cxx:420
constexpr OUStringLiteral ORIGIN(u"Origin")
virtual double SAL_CALL getTop() override
Definition: vbaaxis.cxx:623
Sequence< OUString > aServiceNames
virtual ::sal_Int32 SAL_CALL getScaleType() override
Definition: vbaaxis.cxx:583
ScVbaAxis(const css::uno::Reference< ov::XHelperInterface > &xParent, const css::uno::Reference< css::uno::XComponentContext > &xContext, const css::uno::Reference< css::beans::XPropertySet > &_xPropertySet, sal_Int32 _nType, sal_Int32 _nGroup)
Definition: vbaaxis.cxx:55
virtual OUString getServiceImplName() override
Definition: vbaaxis.cxx:641
#define ERRCODE_BASIC_NOT_IMPLEMENTED
std::unique_ptr< ov::ShapeHelper > oShapeHelper
Definition: vbaaxis.hxx:39
virtual double SAL_CALL getCrossesAt() override
Definition: vbaaxis.cxx:199
css::uno::Reference< ov::excel::XChart > moChartParent
Definition: vbaaxis.hxx:30
virtual void SAL_CALL setType(::sal_Int32 Type) override
Definition: vbaaxis.cxx:214
sal_Int32 mnGroup
Definition: vbaaxis.hxx:33
virtual ::sal_Int32 SAL_CALL getType() override
Definition: vbaaxis.cxx:220
virtual sal_Bool SAL_CALL getHasTitle() override
Definition: vbaaxis.cxx:252
virtual double SAL_CALL getLeft() override
Definition: vbaaxis.cxx:631
virtual sal_Bool SAL_CALL getReversePlotOrder() override
Definition: vbaaxis.cxx:347
css::uno::Reference< css::chart::XAxisYSupplier > xAxisYSupplier
Definition: vbachart.hxx:45
constexpr OUStringLiteral AUTOORIGIN(u"AutoOrigin")
virtual css::uno::Sequence< OUString > getServiceNames() override
Definition: vbaaxis.cxx:647
sal_Int32 mnType
virtual void SAL_CALL setHasTitle(sal_Bool HasTitle) override
Definition: vbaaxis.cxx:226
virtual void SAL_CALL setMinorUnitIsAuto(sal_Bool MinorUnitIsAuto) override
Definition: vbaaxis.cxx:309
virtual void SAL_CALL Delete() override
Definition: vbaaxis.cxx:64
virtual void SAL_CALL setMinimumScale(double MinimumScale) override
Definition: vbaaxis.cxx:486
unsigned char sal_Bool
virtual double SAL_CALL getMaximumScale() override
Definition: vbaaxis.cxx:436
virtual ::sal_Int32 SAL_CALL getDisplayUnit() override
Definition: vbaaxis.cxx:110
virtual void SAL_CALL setWidth(double width) override
Definition: vbaaxis.cxx:619
virtual css::uno::Reference< ::ooo::vba::excel::XAxisTitle > SAL_CALL getAxisTitle() override
Definition: vbaaxis.cxx:71
ScVbaChart * getChartPtr()
Definition: vbaaxis.cxx:37
virtual double SAL_CALL getMinorUnit() override
Definition: vbaaxis.cxx:293
virtual void SAL_CALL setMaximumScaleIsAuto(sal_Bool MaximumScaleIsAuto) override
Definition: vbaaxis.cxx:455
virtual void SAL_CALL setReversePlotOrder(sal_Bool ReversePlotOrder) override
Definition: vbaaxis.cxx:341
css::uno::Reference< css::uno::XComponentContext > mxContext
virtual sal_Bool SAL_CALL getMajorUnitIsAuto() override
Definition: vbaaxis.cxx:402
bool bCrossesAreCustomized
Definition: vbaaxis.hxx:34
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:400
#define ERRCODE_BASIC_METHOD_FAILED
constexpr OUStringLiteral VBA_MAX(u"Min")
constexpr OUStringLiteral VBA_MIN(u"Max")
virtual void SAL_CALL setMajorUnitIsAuto(sal_Bool MajorUnitIsAuto) override
Definition: vbaaxis.cxx:386
virtual void SAL_CALL setCrossesAt(double CrossesAt) override
Definition: vbaaxis.cxx:184
virtual double SAL_CALL getHeight() override
Definition: vbaaxis.cxx:606
css::uno::Reference< css::beans::XPropertySet > mxPropertySet
Definition: vbaaxis.hxx:31
virtual void SAL_CALL setMinimumScaleIsAuto(sal_Bool MinimumScaleIsAuto) override
Definition: vbaaxis.cxx:516
virtual double SAL_CALL getWidth() override
Definition: vbaaxis.cxx:615
css::uno::Reference< css::beans::XPropertySet > mxDiagramPropertySet
Definition: vbachart.hxx:42
virtual void SAL_CALL setMajorUnit(double MajorUnit) override
Definition: vbaaxis.cxx:354
virtual void SAL_CALL setCrosses(::sal_Int32 Crosses) override
Definition: vbaaxis.cxx:117
virtual void SAL_CALL setMinorUnit(double MinorUnit) override
Definition: vbaaxis.cxx:279
virtual ::sal_Int32 SAL_CALL getAxisGroup() override
Definition: vbaaxis.cxx:550
virtual sal_Bool SAL_CALL getMinorUnitIsAuto() override
Definition: vbaaxis.cxx:323
virtual void SAL_CALL setTop(double top) override
Definition: vbaaxis.cxx:627
virtual void SAL_CALL setLeft(double left) override
Definition: vbaaxis.cxx:635
virtual double SAL_CALL getMinimumScale() override
Definition: vbaaxis.cxx:500
css::uno::Reference< css::chart::XAxisXSupplier > xAxisXSupplier
Definition: vbachart.hxx:44
virtual ::sal_Int32 SAL_CALL getCrosses() override
Definition: vbaaxis.cxx:150