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