Bug Summary

File:home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:line 192, column 9
Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name vbaworksheet.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sc/source/core/inc -I /home/maarten/src/libreoffice/core/sc/source/filter/inc -I /home/maarten/src/libreoffice/core/sc/source/ui/inc -I /home/maarten/src/libreoffice/core/sc/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sc/source/ui/vba/vbaworksheet.cxx

/home/maarten/src/libreoffice/core/sc/source/ui/vba/vbaworksheet.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 "vbaworksheet.hxx"
21#include "vbanames.hxx"
22
23#include <com/sun/star/beans/XPropertySet.hpp>
24#include <com/sun/star/beans/XIntrospectionAccess.hpp>
25#include <com/sun/star/container/XNamed.hpp>
26#include <com/sun/star/util/XProtectable.hpp>
27#include <com/sun/star/table/XCellRange.hpp>
28#include <com/sun/star/sheet/XSpreadsheetView.hpp>
29#include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
30#include <com/sun/star/sheet/XCalculatable.hpp>
31#include <com/sun/star/sheet/XCellRangeAddressable.hpp>
32#include <com/sun/star/sheet/XSheetCellRange.hpp>
33#include <com/sun/star/sheet/XSheetCellCursor.hpp>
34#include <com/sun/star/sheet/XSheetAnnotationsSupplier.hpp>
35#include <com/sun/star/sheet/XUsedAreaCursor.hpp>
36#include <com/sun/star/sheet/XSpreadsheets.hpp>
37#include <com/sun/star/sheet/XSheetOutline.hpp>
38#include <com/sun/star/sheet/XSheetPageBreak.hpp>
39#include <com/sun/star/sheet/XDataPilotTablesSupplier.hpp>
40#include <com/sun/star/sheet/XNamedRanges.hpp>
41#include <com/sun/star/frame/Desktop.hpp>
42#include <com/sun/star/table/XTableChartsSupplier.hpp>
43#include <com/sun/star/drawing/XDrawPageSupplier.hpp>
44#include <com/sun/star/drawing/XControlShape.hpp>
45#include <com/sun/star/form/XFormsSupplier.hpp>
46#include <ooo/vba/excel/XApplication.hpp>
47#include <ooo/vba/excel/XlEnableSelection.hpp>
48#include <ooo/vba/excel/XlSheetVisibility.hpp>
49#include <ooo/vba/XControlProvider.hpp>
50
51#include <basic/sberrors.hxx>
52#include <comphelper/processfactory.hxx>
53#include <comphelper/servicehelper.hxx>
54#include <vbahelper/vbashapes.hxx>
55
56//zhangyun showdataform
57#include <scabstdlg.hxx>
58#include <tabvwsh.hxx>
59
60#include <tabprotection.hxx>
61#include "excelvbahelper.hxx"
62#include "vbaoutline.hxx"
63#include "vbarange.hxx"
64#include "vbacomments.hxx"
65#include "vbachartobjects.hxx"
66#include "vbapivottables.hxx"
67#include "vbaoleobjects.hxx"
68#include "vbapagesetup.hxx"
69#include "vbapagebreaks.hxx"
70#include "vbaworksheets.hxx"
71#include "vbahyperlinks.hxx"
72#include "vbasheetobjects.hxx"
73#include <dbdata.hxx>
74
75#include <attrib.hxx>
76
77#define STANDARDWIDTH2267 2267
78#define STANDARDHEIGHT427 427
79
80using namespace com::sun::star;
81using namespace ooo::vba;
82
83static void getNewSpreadsheetName (OUString &aNewName, const OUString& aOldName, const uno::Reference <sheet::XSpreadsheetDocument>& xSpreadDoc )
84{
85 if (!xSpreadDoc.is())
86 throw lang::IllegalArgumentException( "getNewSpreadsheetName() xSpreadDoc is null", uno::Reference< uno::XInterface >(), 1 );
87 static const char aUnderScore[] = "_";
88 int currentNum =2;
89 aNewName = aOldName + aUnderScore + OUString::number(currentNum) ;
90 SCTAB nTab = 0;
91 while ( ScVbaWorksheets::nameExists(xSpreadDoc,aNewName, nTab ) )
92 {
93 aNewName = aOldName + aUnderScore + OUString::number(++currentNum);
94 }
95}
96
97static void removeAllSheets( const uno::Reference <sheet::XSpreadsheetDocument>& xSpreadDoc, const OUString& aSheetName)
98{
99 if (!xSpreadDoc.is())
100 throw lang::IllegalArgumentException( "removeAllSheets() xSpreadDoc is null", uno::Reference< uno::XInterface >(), 1 );
101 uno::Reference<sheet::XSpreadsheets> xSheets = xSpreadDoc->getSheets();
102 uno::Reference <container::XIndexAccess> xIndex( xSheets, uno::UNO_QUERY );
103
104 if ( !xIndex.is() )
105 return;
106
107 uno::Reference<container::XNameContainer> xNameContainer(xSheets,uno::UNO_QUERY_THROW);
108 for (sal_Int32 i = xIndex->getCount() -1; i>= 1; i--)
109 {
110 uno::Reference< sheet::XSpreadsheet > xSheet(xIndex->getByIndex(i), uno::UNO_QUERY);
111 uno::Reference< container::XNamed > xNamed( xSheet, uno::UNO_QUERY_THROW );
112 xNameContainer->removeByName(xNamed->getName());
113 }
114
115 uno::Reference< sheet::XSpreadsheet > xSheet(xIndex->getByIndex(0), uno::UNO_QUERY);
116 uno::Reference< container::XNamed > xNamed( xSheet, uno::UNO_QUERY_THROW );
117 xNamed->setName(aSheetName);
118}
119
120static uno::Reference<frame::XModel>
121openNewDoc(const OUString& aSheetName )
122{
123 uno::Reference<frame::XModel> xModel;
124 try
125 {
126 uno::Reference< uno::XComponentContext > xContext(
127 comphelper::getProcessComponentContext() );
128
129 uno::Reference <frame::XDesktop2 > xComponentLoader = frame::Desktop::create(xContext);
130
131 uno::Reference<lang::XComponent > xComponent( xComponentLoader->loadComponentFromURL(
132 "private:factory/scalc",
133 "_blank", 0,
134 uno::Sequence < css::beans::PropertyValue >() ) );
135 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( xComponent, uno::UNO_QUERY_THROW );
136 removeAllSheets(xSpreadDoc,aSheetName);
137 xModel.set(xSpreadDoc,uno::UNO_QUERY_THROW);
138 }
139 catch ( uno::Exception & /*e*/ )
140 {
141 }
142 return xModel;
143}
144
145ScVbaWorksheet::ScVbaWorksheet(const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext,
146 const uno::Reference< sheet::XSpreadsheet >& xSheet,
147 const uno::Reference< frame::XModel >& xModel ) : WorksheetImpl_BASE( xParent, xContext ), mxSheet( xSheet ), mxModel(xModel), mbVeryHidden( false )
148{
149}
150
151ScVbaWorksheet::ScVbaWorksheet( uno::Sequence< uno::Any> const & args,
152 uno::Reference< uno::XComponentContext> const & xContext ) : WorksheetImpl_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext ), mxModel( getXSomethingFromArgs< frame::XModel >( args, 1 ) ), mbVeryHidden( false )
153{
154 if ( args.getLength() < 3 )
155 throw lang::IllegalArgumentException();
156
157 OUString sSheetName;
158 args[2] >>= sSheetName;
159
160 uno::Reference< sheet::XSpreadsheetDocument > xSpreadDoc( mxModel, uno::UNO_QUERY_THROW );
161 uno::Reference< container::XNameAccess > xNameAccess( xSpreadDoc->getSheets(), uno::UNO_QUERY_THROW );
162 mxSheet.set( xNameAccess->getByName( sSheetName ), uno::UNO_QUERY_THROW );
163}
164
165ScVbaWorksheet::~ScVbaWorksheet()
166{
167}
168
169namespace
170{
171 class theScVbaWorksheetUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScVbaWorksheetUnoTunnelId > {};
172}
173
174const uno::Sequence<sal_Int8>& ScVbaWorksheet::getUnoTunnelId()
175{
176 return theScVbaWorksheetUnoTunnelId::get().getSeq();
177}
178
179uno::Reference< ov::excel::XWorksheet >
180ScVbaWorksheet::createSheetCopyInNewDoc(const OUString& aCurrSheetName)
181{
182 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor = getSheet()->createCursor( );
183 uno::Reference<sheet::XUsedAreaCursor> xUsedCursor(xSheetCellCursor,uno::UNO_QUERY_THROW);
184 uno::Reference<excel::XRange> xRange = new ScVbaRange( this, mxContext, xSheetCellCursor);
185 if (xRange.is())
186 xRange->Select();
187 excel::implnCopy(mxModel);
188 uno::Reference<frame::XModel> xModel = openNewDoc(aCurrSheetName);
189 if (xModel.is())
190 {
191 excel::implnPaste(xModel);
192 }
193 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( xModel, uno::UNO_QUERY_THROW );
194 excel::setUpDocumentModules(xSpreadDoc);
195 uno::Reference <sheet::XSpreadsheets> xSheets( xSpreadDoc->getSheets(), uno::UNO_SET_THROW );
196 uno::Reference <container::XIndexAccess> xIndex( xSheets, uno::UNO_QUERY_THROW );
197 uno::Reference< sheet::XSpreadsheet > xSheet(xIndex->getByIndex(0), uno::UNO_QUERY_THROW);
198
199 ScDocShell* pShell = excel::getDocShell( xModel );
200 OUString aCodeName;
201 pShell->GetDocument().GetCodeName( 0, aCodeName );
202 return uno::Reference< excel::XWorksheet >( getUnoDocModule( aCodeName, pShell ), uno::UNO_QUERY_THROW );
203}
204
205css::uno::Reference< ov::excel::XWorksheet >
206ScVbaWorksheet::createSheetCopy(uno::Reference<excel::XWorksheet> const & xSheet, bool bAfter)
207{
208 OUString aCurrSheetName = getName();
209 ScVbaWorksheet* pDestSheet = excel::getImplFromDocModuleWrapper<ScVbaWorksheet>( xSheet );
210
211 uno::Reference <sheet::XSpreadsheetDocument> xDestDoc( pDestSheet->getModel(), uno::UNO_QUERY );
212 uno::Reference <sheet::XSpreadsheetDocument> xSrcDoc( getModel(), uno::UNO_QUERY );
213
214 SCTAB nDest = 0;
215 SCTAB nSrc = 0;
216 OUString aSheetName = xSheet->getName();
217 bool bSameDoc = ( pDestSheet->getModel() == getModel() );
218 bool bDestSheetExists = ScVbaWorksheets::nameExists (xDestDoc, aSheetName, nDest );
219 bool bSheetExists = ScVbaWorksheets::nameExists (xSrcDoc, aCurrSheetName, nSrc );
220
221 // set sheet name to be newSheet name
222 aSheetName = aCurrSheetName;
223 if ( bSheetExists && bDestSheetExists )
224 {
225 SCTAB nDummy=0;
226 if(bAfter)
227 nDest++;
228 uno::Reference<sheet::XSpreadsheets> xSheets = xDestDoc->getSheets();
229 if ( bSameDoc || ScVbaWorksheets::nameExists( xDestDoc, aCurrSheetName, nDummy ) )
230 getNewSpreadsheetName(aSheetName,aCurrSheetName,xDestDoc);
231 if ( bSameDoc )
232 xSheets->copyByName(aCurrSheetName,aSheetName,nDest);
233 else
234 {
235 ScDocShell* pDestDocShell = excel::getDocShell( pDestSheet->getModel() );
236 ScDocShell* pSrcDocShell = excel::getDocShell( getModel() );
237 if ( pDestDocShell && pSrcDocShell )
238 pDestDocShell->TransferTab( *pSrcDocShell, nSrc, nDest, true, true );
239 }
240 }
241 // return new sheet
242 uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW );
243 uno::Reference< excel::XWorksheet > xNewSheet( xApplication->Worksheets( uno::makeAny( aSheetName ) ), uno::UNO_QUERY_THROW );
244 return xNewSheet;
245}
246
247OUString
248ScVbaWorksheet::getName()
249{
250 uno::Reference< container::XNamed > xNamed( getSheet(), uno::UNO_QUERY_THROW );
251 return xNamed->getName();
252}
253
254void
255ScVbaWorksheet::setName(const OUString &rName )
256{
257 uno::Reference< container::XNamed > xNamed( getSheet(), uno::UNO_QUERY_THROW );
258 xNamed->setName( rName );
259}
260
261sal_Int32
262ScVbaWorksheet::getVisible()
263{
264 uno::Reference< beans::XPropertySet > xProps( getSheet(), uno::UNO_QUERY_THROW );
265 bool bVisible = false;
266 xProps->getPropertyValue( "IsVisible" ) >>= bVisible;
267 using namespace ::ooo::vba::excel::XlSheetVisibility;
268 return bVisible ? xlSheetVisible : (mbVeryHidden ? xlSheetVeryHidden : xlSheetHidden);
269}
270
271void
272ScVbaWorksheet::setVisible( sal_Int32 nVisible )
273{
274 using namespace ::ooo::vba::excel::XlSheetVisibility;
275 bool bVisible = true;
276 switch( nVisible )
277 {
278 case xlSheetVisible: case 1: // Excel accepts -1 and 1 for visible sheets
279 bVisible = true;
280 mbVeryHidden = false;
281 break;
282 case xlSheetHidden:
283 bVisible = false;
284 mbVeryHidden = false;
285 break;
286 case xlSheetVeryHidden:
287 bVisible = false;
288 mbVeryHidden = true;
289 break;
290 default:
291 throw uno::RuntimeException();
292 }
293 uno::Reference< beans::XPropertySet > xProps( getSheet(), uno::UNO_QUERY_THROW );
294 xProps->setPropertyValue( "IsVisible", uno::Any( bVisible ) );
295}
296
297sal_Int16
298ScVbaWorksheet::getIndex()
299{
300 return getSheetID() + 1;
301}
302
303sal_Int32
304ScVbaWorksheet::getEnableSelection()
305{
306 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
307 SCTAB nTab = 0;
308 if ( !ScVbaWorksheets::nameExists(xSpreadDoc, getName(), nTab) )
309 throw uno::RuntimeException("Sheet Name does not exist." );
310
311 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
312 ScDocument& rDoc = excel::getDocShell( xModel )->GetDocument();
313 ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);
314 bool bLockedCells = false;
315 bool bUnlockedCells = false;
316 if( pProtect )
317 {
318 bLockedCells = pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
319 bUnlockedCells = pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
320 }
321 if( bLockedCells )
322 return excel::XlEnableSelection::xlNoRestrictions;
323 if( bUnlockedCells )
324 return excel::XlEnableSelection::xlUnlockedCells;
325 return excel::XlEnableSelection::xlNoSelection;
326
327}
328
329void
330ScVbaWorksheet::setEnableSelection( sal_Int32 nSelection )
331{
332 if( (nSelection != excel::XlEnableSelection::xlNoRestrictions) &&
333 (nSelection != excel::XlEnableSelection::xlUnlockedCells) &&
334 (nSelection != excel::XlEnableSelection::xlNoSelection) )
335 {
336 DebugHelper::runtimeexception(ERRCODE_BASIC_BAD_PARAMETERErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 7));
337 }
338
339 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
340 SCTAB nTab = 0;
341 if ( !ScVbaWorksheets::nameExists(xSpreadDoc, getName(), nTab) )
342 throw uno::RuntimeException("Sheet Name does not exist." );
343
344 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
345 ScDocument& rDoc = excel::getDocShell( xModel )->GetDocument();
346 ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);
347 // default is xlNoSelection
348 bool bLockedCells = false;
349 bool bUnlockedCells = false;
350 if( nSelection == excel::XlEnableSelection::xlNoRestrictions )
351 {
352 bLockedCells = true;
353 bUnlockedCells = true;
354 }
355 else if( nSelection == excel::XlEnableSelection::xlUnlockedCells )
356 {
357 bUnlockedCells = true;
358 }
359 if( pProtect )
360 {
361 pProtect->setOption( ScTableProtection::SELECT_LOCKED_CELLS, bLockedCells );
362 pProtect->setOption( ScTableProtection::SELECT_UNLOCKED_CELLS, bUnlockedCells );
363 }
364
365
366}
367
368sal_Bool SAL_CALL ScVbaWorksheet::getAutoFilterMode()
369{
370 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
371 ScDocument& rDoc = excel::getDocShell( xModel )->GetDocument();
372 ScDBData* pDBData = rDoc.GetAnonymousDBData(getSheetID());
373 if (pDBData)
374 return pDBData->HasAutoFilter();
375 return false;
376}
377
378void SAL_CALL ScVbaWorksheet::setAutoFilterMode( sal_Bool bAutoFilterMode )
379{
380 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
381 ScDocShell* pDocShell = excel::getDocShell( xModel );
382 ScDocument& rDoc = pDocShell->GetDocument();
383 ScDBData* pDBData = rDoc.GetAnonymousDBData(getSheetID());
384 if (!pDBData)
385 return;
386
387 pDBData->SetAutoFilter(bAutoFilterMode);
388 ScRange aRange;
389 pDBData->GetArea(aRange);
390 if (bAutoFilterMode)
391 rDoc.ApplyFlagsTab( aRange.aStart.Col(), aRange.aStart.Row(),
392 aRange.aEnd.Col(), aRange.aStart.Row(),
393 aRange.aStart.Tab(), ScMF::Auto );
394 else if (!bAutoFilterMode)
395 rDoc.RemoveFlagsTab(aRange.aStart.Col(), aRange.aStart.Row(),
396 aRange.aEnd.Col(), aRange.aStart.Row(),
397 aRange.aStart.Tab(), ScMF::Auto );
398 ScRange aPaintRange(aRange.aStart, aRange.aEnd);
399 aPaintRange.aEnd.SetRow(aPaintRange.aStart.Row());
400 pDocShell->PostPaint(aPaintRange, PaintPartFlags::Grid);
401}
402
403uno::Reference< excel::XRange >
404ScVbaWorksheet::getUsedRange()
405{
406 uno::Reference< sheet::XSheetCellRange > xSheetCellRange(getSheet(), uno::UNO_QUERY_THROW );
407 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor( getSheet()->createCursorByRange( xSheetCellRange ), uno::UNO_SET_THROW );
408 uno::Reference<sheet::XUsedAreaCursor> xUsedCursor(xSheetCellCursor,uno::UNO_QUERY_THROW);
409 xUsedCursor->gotoStartOfUsedArea( false );
410 xUsedCursor->gotoEndOfUsedArea( true );
411 return new ScVbaRange(this, mxContext, xSheetCellCursor);
412}
413
414uno::Reference< excel::XOutline >
415ScVbaWorksheet::Outline( )
416{
417 uno::Reference<sheet::XSheetOutline> xOutline(getSheet(),uno::UNO_QUERY_THROW);
418 return new ScVbaOutline( this, mxContext, xOutline);
419}
420
421uno::Reference< excel::XPageSetup >
422ScVbaWorksheet::PageSetup( )
423{
424 return new ScVbaPageSetup( this, mxContext, getSheet(), getModel() );
425}
426
427uno::Any
428ScVbaWorksheet::HPageBreaks( const uno::Any& aIndex )
429{
430 uno::Reference< sheet::XSheetPageBreak > xSheetPageBreak(getSheet(),uno::UNO_QUERY_THROW);
431 uno::Reference< excel::XHPageBreaks > xHPageBreaks( new ScVbaHPageBreaks( this, mxContext, xSheetPageBreak));
432 if ( aIndex.hasValue() )
433 return xHPageBreaks->Item( aIndex, uno::Any());
434 return uno::makeAny( xHPageBreaks );
435}
436
437uno::Any
438ScVbaWorksheet::VPageBreaks( const uno::Any& aIndex )
439{
440 uno::Reference< sheet::XSheetPageBreak > xSheetPageBreak( getSheet(), uno::UNO_QUERY_THROW );
441 uno::Reference< excel::XVPageBreaks > xVPageBreaks( new ScVbaVPageBreaks( this, mxContext, xSheetPageBreak ) );
442 if( aIndex.hasValue() )
443 return xVPageBreaks->Item( aIndex, uno::Any());
444 return uno::makeAny( xVPageBreaks );
445}
446
447sal_Int32
448ScVbaWorksheet::getStandardWidth()
449{
450 return STANDARDWIDTH2267 ;
451}
452
453sal_Int32
454ScVbaWorksheet::getStandardHeight()
455{
456 return STANDARDHEIGHT427;
457}
458
459sal_Bool
460ScVbaWorksheet::getProtectionMode()
461{
462 return false;
463}
464
465sal_Bool
466ScVbaWorksheet::getProtectContents()
467{
468 uno::Reference<util::XProtectable > xProtectable(getSheet(), uno::UNO_QUERY_THROW);
469 return xProtectable->isProtected();
470}
471
472sal_Bool
473ScVbaWorksheet::getProtectDrawingObjects()
474{
475 SCTAB nTab = 0;
476 OUString aSheetName = getName();
477 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
478 bool bSheetExists = ScVbaWorksheets::nameExists (xSpreadDoc, aSheetName, nTab);
479 if ( bSheetExists )
480 {
481 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
482 ScDocument& rDoc = excel::getDocShell( xModel )->GetDocument();
483 ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);
484 if ( pProtect )
485 return pProtect->isOptionEnabled( ScTableProtection::OBJECTS );
486 }
487 return false;
488}
489
490sal_Bool
491ScVbaWorksheet::getProtectScenarios()
492{
493 return false;
494}
495
496void
497ScVbaWorksheet::Activate()
498{
499 uno::Reference< sheet::XSpreadsheetView > xSpreadsheet(
500 getModel()->getCurrentController(), uno::UNO_QUERY_THROW );
501 xSpreadsheet->setActiveSheet(getSheet());
502}
503
504void
505ScVbaWorksheet::Select()
506{
507 Activate();
508}
509
510void
511ScVbaWorksheet::Move( const uno::Any& Before, const uno::Any& After )
512{
513 uno::Reference<excel::XWorksheet> xSheet;
514 OUString aCurrSheetName = getName();
515
516 if (!(Before >>= xSheet) && !(After >>=xSheet)&& !(Before.hasValue()) && !(After.hasValue()))
517 {
518 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor = getSheet()->createCursor( );
519 uno::Reference<sheet::XUsedAreaCursor> xUsedCursor(xSheetCellCursor,uno::UNO_QUERY_THROW);
520 // #FIXME needs worksheet as parent
521 uno::Reference<excel::XRange> xRange = new ScVbaRange( this, mxContext, xSheetCellCursor);
522 if (xRange.is())
523 xRange->Select();
524 excel::implnCopy(mxModel);
525 uno::Reference<frame::XModel> xModel = openNewDoc(aCurrSheetName);
526 if (xModel.is())
527 {
528 excel::implnPaste(xModel);
529 Delete();
530 }
531 return ;
532 }
533
534 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
535 SCTAB nDest = 0;
536 if ( ScVbaWorksheets::nameExists (xSpreadDoc, xSheet->getName(), nDest) )
537 {
538 bool bAfter = After.hasValue();
539 if (bAfter)
540 nDest++;
541 uno::Reference<sheet::XSpreadsheets> xSheets = xSpreadDoc->getSheets();
542 xSheets->moveByName(aCurrSheetName,nDest);
543 }
544}
545
546void
547ScVbaWorksheet::Copy( const uno::Any& Before, const uno::Any& After )
548{
549 uno::Reference<excel::XWorksheet> xSheet;
550 if (!(Before >>= xSheet) && !(After >>=xSheet)&& !(Before.hasValue()) && !(After.hasValue()))
551 {
552 createSheetCopyInNewDoc(getName());
553 return;
554 }
555
556 uno::Reference<excel::XWorksheet> xNewSheet = createSheetCopy(xSheet, After.hasValue());
557 xNewSheet->Activate();
558}
559
560void
561ScVbaWorksheet::Paste( const uno::Any& Destination, const uno::Any& /*Link*/ )
562{
563 // #TODO# #FIXME# Link is not used
564 uno::Reference<excel::XRange> xRange( Destination, uno::UNO_QUERY );
565 if ( xRange.is() )
566 xRange->Select();
567 excel::implnPaste( mxModel );
568}
569
570void
571ScVbaWorksheet::Delete()
572{
573 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
574 OUString aSheetName = getName();
575 SCTAB nTab = 0;
576 if (!ScVbaWorksheets::nameExists(xSpreadDoc, aSheetName, nTab ))
577 {
578 return;
579 }
580 uno::Reference<sheet::XSpreadsheets> xSheets = xSpreadDoc->getSheets();
581 uno::Reference<container::XNameContainer> xNameContainer(xSheets,uno::UNO_QUERY_THROW);
582 xNameContainer->removeByName(aSheetName);
583 mxSheet.clear();
584}
585
586uno::Reference< excel::XWorksheet >
587ScVbaWorksheet::getSheetAtOffset(SCTAB offset)
588{
589 uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( getModel(), uno::UNO_QUERY_THROW );
590 uno::Reference <sheet::XSpreadsheets> xSheets( xSpreadDoc->getSheets(), uno::UNO_SET_THROW );
591 uno::Reference <container::XIndexAccess> xIndex( xSheets, uno::UNO_QUERY_THROW );
592
593 SCTAB nIdx = 0;
594 if ( !ScVbaWorksheets::nameExists (xSpreadDoc, getName(), nIdx ) )
595 return uno::Reference< excel::XWorksheet >();
596 nIdx = nIdx + offset;
597 uno::Reference< sheet::XSpreadsheet > xSheet(xIndex->getByIndex(nIdx), uno::UNO_QUERY_THROW);
598 // parent will be the parent of 'this' worksheet
599 return new ScVbaWorksheet (getParent(), mxContext, xSheet, getModel());
600}
601
602uno::Reference< excel::XWorksheet >
603ScVbaWorksheet::getNext()
604{
605 return getSheetAtOffset(static_cast<SCTAB>(1));
606}
607
608uno::Reference< excel::XWorksheet >
609ScVbaWorksheet::getPrevious()
610{
611 return getSheetAtOffset(-1);
612}
613
614void
615ScVbaWorksheet::Protect( const uno::Any& Password, const uno::Any& /*DrawingObjects*/, const uno::Any& /*Contents*/, const uno::Any& /*Scenarios*/, const uno::Any& /*UserInterfaceOnly*/ )
616{
617 // #TODO# #FIXME# is there anything we can do with the unused param
618 // can the implementation use anything else here
619 uno::Reference<util::XProtectable > xProtectable(getSheet(), uno::UNO_QUERY_THROW);
620 OUString aPasswd;
621 Password >>= aPasswd;
622 xProtectable->protect( aPasswd );
623}
624
625void
626ScVbaWorksheet::Unprotect( const uno::Any& Password )
627{
628 uno::Reference<util::XProtectable > xProtectable(getSheet(), uno::UNO_QUERY_THROW);
629 OUString aPasswd;
630 Password >>= aPasswd;
631 xProtectable->unprotect( aPasswd );
632}
633
634void
635ScVbaWorksheet::Calculate()
636{
637 uno::Reference <sheet::XCalculatable> xReCalculate(getModel(), uno::UNO_QUERY_THROW);
638 xReCalculate->calculate();
639}
640
641uno::Reference< excel::XRange >
642ScVbaWorksheet::Range( const ::uno::Any& Cell1, const ::uno::Any& Cell2 )
643{
644 uno::Reference< excel::XRange > xSheetRange( new ScVbaRange( this, mxContext
645, uno::Reference< table::XCellRange >( getSheet(), uno::UNO_QUERY_THROW ) ) );
646 return xSheetRange->Range( Cell1, Cell2 );
647}
648
649void
650ScVbaWorksheet::CheckSpelling( const uno::Any& /*CustomDictionary*/,const uno::Any& /*IgnoreUppercase*/,const uno::Any& /*AlwaysSuggest*/, const uno::Any& /*SpellingLang*/ )
651{
652 // #TODO# #FIXME# unused params above, can we do anything with those
653 uno::Reference< frame::XModel > xModel( getModel() );
654 dispatchRequests(xModel,".uno:SpellDialog");
655}
656
657uno::Reference< excel::XRange >
658ScVbaWorksheet::getSheetRange()
659{
660 uno::Reference< table::XCellRange > xRange( getSheet(),uno::UNO_QUERY_THROW );
661 return uno::Reference< excel::XRange >( new ScVbaRange( this, mxContext, xRange ) );
662}
663
664// These are hacks - we prolly (somehow) need to inherit
665// the vbarange functionality here ...
666uno::Reference< excel::XRange >
667ScVbaWorksheet::Cells( const ::uno::Any &nRow, const ::uno::Any &nCol )
668{
669 // Performance optimization for often-called Cells method:
670 // Use a common helper method instead of creating a new ScVbaRange object
671 uno::Reference< table::XCellRange > xRange( getSheet(), uno::UNO_QUERY_THROW );
672 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
673 ScDocument& rDoc = excel::getDocShell( xModel )->GetDocument();
674 return ScVbaRange::CellsHelper( rDoc, this, mxContext, xRange, nRow, nCol );
675}
676
677uno::Reference< excel::XRange >
678ScVbaWorksheet::Rows(const uno::Any& aIndex )
679{
680 return getSheetRange()->Rows( aIndex );
681}
682
683uno::Reference< excel::XRange >
684ScVbaWorksheet::Columns( const uno::Any& aIndex )
685{
686 return getSheetRange()->Columns( aIndex );
687}
688
689uno::Any SAL_CALL
690ScVbaWorksheet::ChartObjects( const uno::Any& Index )
691{
692 if ( !mxCharts.is() )
693 {
694 uno::Reference< table::XTableChartsSupplier > xChartSupplier( getSheet(), uno::UNO_QUERY_THROW );
695 uno::Reference< table::XTableCharts > xTableCharts = xChartSupplier->getCharts();
696
697 uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( mxSheet, uno::UNO_QUERY_THROW );
698 mxCharts = new ScVbaChartObjects( this, mxContext, xTableCharts, xDrawPageSupplier );
699 }
700 if ( Index.hasValue() )
701 {
702 uno::Reference< XCollection > xColl( mxCharts, uno::UNO_QUERY_THROW );
703 return xColl->Item( Index, uno::Any() );
704 }
705 else
706 return uno::makeAny( mxCharts );
707
708}
709
710uno::Any SAL_CALL
711ScVbaWorksheet::PivotTables( const uno::Any& Index )
712{
713 uno::Reference< css::sheet::XSpreadsheet > xSheet = getSheet();
714 uno::Reference< sheet::XDataPilotTablesSupplier > xTables(xSheet, uno::UNO_QUERY_THROW ) ;
715 uno::Reference< container::XIndexAccess > xIndexAccess( xTables->getDataPilotTables(), uno::UNO_QUERY_THROW );
716
717 uno::Reference< XCollection > xColl( new ScVbaPivotTables( this, mxContext, xIndexAccess ) );
718 if ( Index.hasValue() )
719 return xColl->Item( Index, uno::Any() );
720 return uno::makeAny( xColl );
721}
722
723uno::Any SAL_CALL
724ScVbaWorksheet::Comments( const uno::Any& Index )
725{
726 uno::Reference< css::sheet::XSpreadsheet > xSheet = getSheet();
727 uno::Reference< sheet::XSheetAnnotationsSupplier > xAnnosSupp( xSheet, uno::UNO_QUERY_THROW );
728 uno::Reference< sheet::XSheetAnnotations > xAnnos( xAnnosSupp->getAnnotations(), uno::UNO_SET_THROW );
729 uno::Reference< container::XIndexAccess > xIndexAccess( xAnnos, uno::UNO_QUERY_THROW );
730 uno::Reference< XCollection > xColl( new ScVbaComments( this, mxContext, mxModel, xIndexAccess ) );
731 if ( Index.hasValue() )
732 return xColl->Item( Index, uno::Any() );
733 return uno::makeAny( xColl );
734}
735
736uno::Any SAL_CALL
737ScVbaWorksheet::Hyperlinks( const uno::Any& aIndex )
738{
739 /* The worksheet always returns the same Hyperlinks object.
740 See vbahyperlinks.hxx for more details. */
741 if( !mxHlinks.is() )
742 mxHlinks.set( new ScVbaHyperlinks( this, mxContext ) );
743 if( aIndex.hasValue() )
744 return uno::Reference< XCollection >( mxHlinks, uno::UNO_QUERY_THROW )->Item( aIndex, uno::Any() );
745 return uno::Any( mxHlinks );
746}
747
748uno::Any SAL_CALL
749ScVbaWorksheet::Names( const css::uno::Any& aIndex )
750{
751 css::uno::Reference<css::beans::XPropertySet> xProps(getSheet(), css::uno::UNO_QUERY_THROW);
752 uno::Reference< sheet::XNamedRanges > xNamedRanges( xProps->getPropertyValue("NamedRanges"), uno::UNO_QUERY_THROW );
753 uno::Reference< XCollection > xNames( new ScVbaNames( this, mxContext, xNamedRanges, mxModel ) );
754 if ( aIndex.hasValue() )
755 return xNames->Item( aIndex, uno::Any() );
756 return uno::Any( xNames );
757}
758
759uno::Any SAL_CALL
760ScVbaWorksheet::OLEObjects( const uno::Any& Index )
761{
762 uno::Reference< sheet::XSpreadsheet > xSpreadsheet( getSheet(), uno::UNO_SET_THROW );
763 uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( xSpreadsheet, uno::UNO_QUERY_THROW );
764 uno::Reference< drawing::XDrawPage > xDrawPage( xDrawPageSupplier->getDrawPage(), uno::UNO_SET_THROW );
765 uno::Reference< container::XIndexAccess > xIndexAccess( xDrawPage, uno::UNO_QUERY_THROW );
766
767 uno::Reference< excel::XOLEObjects >xOleObjects( new ScVbaOLEObjects( this, mxContext, xIndexAccess ) );
768 if( Index.hasValue() )
769 return xOleObjects->Item( Index, uno::Any() );
770 return uno::Any( xOleObjects );
771}
772
773uno::Any SAL_CALL
774ScVbaWorksheet::Shapes( const uno::Any& aIndex )
775{
776 uno::Reference< sheet::XSpreadsheet > xSpreadsheet( getSheet(), uno::UNO_SET_THROW );
777 uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( xSpreadsheet, uno::UNO_QUERY_THROW );
778 uno::Reference< drawing::XShapes > xShapes( xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY_THROW );
779 uno::Reference< container::XIndexAccess > xIndexAccess( xShapes, uno::UNO_QUERY_THROW );
780
781 uno::Reference< msforms::XShapes> xVbaShapes( new ScVbaShapes( this, mxContext, xIndexAccess, getModel() ) );
782 if ( aIndex.hasValue() )
783 return xVbaShapes->Item( aIndex, uno::Any() );
784 return uno::makeAny( xVbaShapes );
785}
786
787uno::Any
788ScVbaWorksheet::getButtons( const uno::Any &rIndex, bool bOptionButtons )
789{
790 ::rtl::Reference< ScVbaSheetObjectsBase > &rxButtons = bOptionButtons ? mxButtons[0] : mxButtons[1];
791
792 if( !rxButtons.is() )
793 rxButtons.set( new ScVbaButtons( this, mxContext, mxModel, mxSheet, bOptionButtons ) );
794 else
795 rxButtons->collectShapes();
796 if( rIndex.hasValue() )
797 return rxButtons->Item( rIndex, uno::Any() );
798 return uno::Any( uno::Reference< XCollection >( rxButtons.get() ) );
799}
800
801uno::Any SAL_CALL
802ScVbaWorksheet::Buttons( const uno::Any& rIndex )
803{
804 return getButtons( rIndex, false );
805}
806
807uno::Any SAL_CALL
808ScVbaWorksheet::CheckBoxes( const uno::Any& /*rIndex*/ )
809{
810 throw uno::RuntimeException();
811}
812
813uno::Any SAL_CALL
814ScVbaWorksheet::DropDowns( const uno::Any& /*rIndex*/ )
815{
816 throw uno::RuntimeException();
817}
818
819uno::Any SAL_CALL
820ScVbaWorksheet::GroupBoxes( const uno::Any& /*rIndex*/ )
821{
822 throw uno::RuntimeException();
823}
824
825uno::Any SAL_CALL
826ScVbaWorksheet::Labels( const uno::Any& /*rIndex*/ )
827{
828 throw uno::RuntimeException();
829}
830
831uno::Any SAL_CALL
832ScVbaWorksheet::ListBoxes( const uno::Any& /*rIndex*/ )
833{
834 throw uno::RuntimeException();
835}
836
837uno::Any SAL_CALL
838ScVbaWorksheet::OptionButtons( const uno::Any& rIndex )
839{
840 return getButtons( rIndex, true );
841}
842
843uno::Any SAL_CALL
844ScVbaWorksheet::ScrollBars( const uno::Any& /*rIndex*/ )
845{
846 throw uno::RuntimeException();
847}
848
849uno::Any SAL_CALL
850ScVbaWorksheet::Spinners( const uno::Any& /*rIndex*/ )
851{
852 throw uno::RuntimeException();
853}
854
855void SAL_CALL
856ScVbaWorksheet::ShowDataForm( )
857{
858 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
859 ScTabViewShell* pTabViewShell = excel::getBestViewShell( xModel );
860
861 ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
862
863 ScopedVclPtr<AbstractScDataFormDlg> pDlg(pFact->CreateScDataFormDlg(pTabViewShell->GetFrameWeld(),
1
Calling constructor for 'ScopedVclPtr<AbstractScDataFormDlg>'
→
8
←
Returning from constructor for 'ScopedVclPtr<AbstractScDataFormDlg>'
→
864 pTabViewShell));
9
←
Calling implicit destructor for 'VclPtr<AbstractScDataFormDlg>'
→
10
←
Calling '~Reference'
→
17
←
Returning from '~Reference'
→
18
←
Returning from destructor for 'VclPtr<AbstractScDataFormDlg>'
→
865
866 pDlg->Execute();
19
←
Calling 'VclPtr::operator->'
→
867}
868
869uno::Any SAL_CALL
870ScVbaWorksheet::Evaluate( const OUString& Name )
871{
872 // #TODO Evaluate allows other things to be evaluated, e.g. functions
873 // I think ( like SIN(3) etc. ) need to investigate that
874 // named Ranges also? e.g. [MyRange] if so need a list of named ranges
875 uno::Any aVoid;
876 return uno::Any( Range( uno::Any( Name ), aVoid ) );
877}
878
879uno::Reference< beans::XIntrospectionAccess > SAL_CALL
880ScVbaWorksheet::getIntrospection( )
881{
882 return uno::Reference< beans::XIntrospectionAccess >();
883}
884
885uno::Any SAL_CALL
886ScVbaWorksheet::invoke( const OUString& /*aFunctionName*/, const uno::Sequence< uno::Any >& /*aParams*/, uno::Sequence< ::sal_Int16 >& /*aOutParamIndex*/, uno::Sequence< uno::Any >& /*aOutParam*/ )
887{
888 throw uno::RuntimeException("Unsupported"); // unsupported operation
889}
890
891void SAL_CALL
892ScVbaWorksheet::setValue( const OUString& aPropertyName, const uno::Any& aValue )
893{
894 setDefaultPropByIntrospection( getValue( aPropertyName ), aValue );
895}
896uno::Any SAL_CALL
897ScVbaWorksheet::getValue( const OUString& aPropertyName )
898{
899 uno::Reference< drawing::XControlShape > xControlShape( getControlShape( aPropertyName ), uno::UNO_QUERY_THROW );
900
901 uno::Reference<lang::XMultiComponentFactory > xServiceManager( mxContext->getServiceManager(), uno::UNO_SET_THROW );
902 uno::Reference< XControlProvider > xControlProvider( xServiceManager->createInstanceWithContext("ooo.vba.ControlProvider", mxContext ), uno::UNO_QUERY_THROW );
903 uno::Reference< msforms::XControl > xControl( xControlProvider->createControl( xControlShape, getModel() ) );
904 return uno::makeAny( xControl );
905}
906
907sal_Bool SAL_CALL
908ScVbaWorksheet::hasMethod( const OUString& /*aName*/ )
909{
910 return false;
911}
912
913uno::Reference< container::XNameAccess >
914ScVbaWorksheet::getFormControls() const
915{
916 uno::Reference< container::XNameAccess > xFormControls;
917 try
918 {
919 uno::Reference< sheet::XSpreadsheet > xSpreadsheet( getSheet(), uno::UNO_SET_THROW );
920 uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( xSpreadsheet, uno::UNO_QUERY_THROW );
921 uno::Reference< form::XFormsSupplier > xFormSupplier( xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY_THROW );
922 uno::Reference< container::XIndexAccess > xIndexAccess( xFormSupplier->getForms(), uno::UNO_QUERY_THROW );
923 // get the www-standard container ( maybe we should access the
924 // 'www-standard' by name rather than index, this seems an
925 // implementation detail
926 if( xIndexAccess->hasElements() )
927 xFormControls.set( xIndexAccess->getByIndex(0), uno::UNO_QUERY );
928
929 }
930 catch( uno::Exception& )
931 {
932 }
933 return xFormControls;
934
935 }
936sal_Bool SAL_CALL
937ScVbaWorksheet::hasProperty( const OUString& aName )
938{
939 uno::Reference< container::XNameAccess > xFormControls( getFormControls() );
940 if ( xFormControls.is() )
941 return xFormControls->hasByName( aName );
942 return false;
943}
944
945uno::Any
946ScVbaWorksheet::getControlShape( const OUString& sName )
947{
948 // ideally we would get an XControl object but it appears an XControl
949 // implementation only exists for a Control implementation obtained from the
950 // view ( e.g. in basic you would get this from
951 // thiscomponent.currentcontroller.getControl( controlModel ) )
952 // and the thing to realise is that it is only possible to get an XControl
953 // for a currently displayed control :-( often we would want to modify
954 // a control not on the active sheet. But... you can always access the
955 // XControlShape from the DrawPage whether that is the active drawpage or not
956
957 uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( getSheet(), uno::UNO_QUERY_THROW );
958 uno::Reference< container::XIndexAccess > xIndexAccess( xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY_THROW );
959
960 sal_Int32 nCount = xIndexAccess->getCount();
961 for( int index = 0; index < nCount; index++ )
962 {
963 uno::Any aUnoObj = xIndexAccess->getByIndex( index );
964 // It seems there are some drawing objects that can not query into Control shapes?
965 uno::Reference< drawing::XControlShape > xControlShape( aUnoObj, uno::UNO_QUERY );
966 if( xControlShape.is() )
967 {
968 uno::Reference< container::XNamed > xNamed( xControlShape->getControl(), uno::UNO_QUERY_THROW );
969 if( sName == xNamed->getName() )
970 {
971 return aUnoObj;
972 }
973 }
974 }
975 return uno::Any();
976}
977
978OUString
979ScVbaWorksheet::getServiceImplName()
980{
981 return "ScVbaWorksheet";
982}
983
984void SAL_CALL
985ScVbaWorksheet::setEnableCalculation( sal_Bool bEnableCalculation )
986{
987 uno::Reference <sheet::XCalculatable> xCalculatable(getModel(), uno::UNO_QUERY_THROW);
988 xCalculatable->enableAutomaticCalculation( bEnableCalculation);
989}
990sal_Bool SAL_CALL
991ScVbaWorksheet::getEnableCalculation( )
992{
993 uno::Reference <sheet::XCalculatable> xCalculatable(getModel(), uno::UNO_QUERY_THROW);
994 return xCalculatable->isAutomaticCalculationEnabled();
995}
996
997uno::Sequence< OUString >
998ScVbaWorksheet::getServiceNames()
999{
1000 static uno::Sequence< OUString > const aServiceNames
1001 {
1002 "ooo.vba.excel.Worksheet"
1003 };
1004 return aServiceNames;
1005}
1006
1007OUString SAL_CALL
1008ScVbaWorksheet::getCodeName()
1009{
1010 uno::Reference< beans::XPropertySet > xSheetProp( mxSheet, uno::UNO_QUERY_THROW );
1011 return xSheetProp->getPropertyValue("CodeName").get< OUString >();
1012}
1013
1014sal_Int16
1015ScVbaWorksheet::getSheetID() const
1016{
1017 uno::Reference< sheet::XCellRangeAddressable > xAddressable( mxSheet, uno::UNO_QUERY_THROW ); // if ActiveSheet, mxSheet is null.
1018 return xAddressable->getRangeAddress().Sheet;
1019}
1020
1021void SAL_CALL
1022ScVbaWorksheet::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& ActivePrinter, const uno::Any& PrintToFile, const uno::Any& Collate, const uno::Any& PrToFileName, const uno::Any& )
1023{
1024 sal_Int32 nTo = 0;
1025 sal_Int32 nFrom = 0;
1026 bool bSelection = false;
1027 From >>= nFrom;
1028 To >>= nTo;
1029
1030 if ( !( nFrom || nTo ) )
1031 bSelection = true;
1032
1033 uno::Reference< frame::XModel > xModel( getModel(), uno::UNO_SET_THROW );
1034 PrintOutHelper( excel::getBestViewShell( xModel ), From, To, Copies, Preview, ActivePrinter, PrintToFile, Collate, PrToFileName, bSelection );
1035}
1036
1037sal_Int64 SAL_CALL
1038ScVbaWorksheet::getSomething(const uno::Sequence<sal_Int8 > & rId)
1039{
1040 if (isUnoTunnelId<ScVbaWorksheet>(rId))
1041 {
1042 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
1043 }
1044 return 0;
1045}
1046
1047extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface*
1048Calc_ScVbaWorksheet_get_implementation(
1049 css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& args)
1050{
1051 return cppu::acquire(new ScVbaWorksheet(args, context));
1052}
1053
1054/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→
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#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX
22
23#include <sal/config.h>
24
25#include <rtl/ref.hxx>
26
27#include <utility>
28#include <type_traits>
29
30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif
35
36class VclReferenceBase;
37
38namespace vcl::detail {
39
40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }
42
43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
44 int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }
46
47} // namespace vcl::detail
48
49/**
50 * A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
51 *
52 * For more details on the design please see vcl/README.lifecycle
53 *
54 * @param reference_type must be a subclass of vcl::Window
55 */
56template <class reference_type>
57class VclPtr
58{
59 static_assert(
60 vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
61 nullptr),
62 "template argument type must be derived from VclReferenceBase");
63
64 ::rtl::Reference<reference_type> m_rInnerRef;
65
66public:
67 /** Constructor...
68 */
69 VclPtr()
70 : m_rInnerRef()
71 {}
72
73 /** Constructor...
74 */
75 VclPtr (reference_type * pBody)
76 : m_rInnerRef(pBody)
77 {}
78
79 /** Constructor... that doesn't take a ref.
80 */
81 VclPtr (reference_type * pBody, __sal_NoAcquire)
82 : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
83 {}
84
85 /** Up-casting conversion constructor: Copies interface reference.
86
87 Does not work for up-casts to ambiguous bases. For the special case of
88 up-casting to Reference< XInterface >, see the corresponding conversion
89 operator.
90
91 @param rRef another reference
92 */
93 template< class derived_type >
94 VclPtr(
95 const VclPtr< derived_type > & rRef,
96 typename std::enable_if<
97 std::is_base_of<reference_type, derived_type>::value, int>::type
98 = 0 )
99 : m_rInnerRef( static_cast<reference_type*>(rRef) )
100 {
101 }
102
103#if defined(DBG_UTIL) && !defined(_WIN32)
104 virtual ~VclPtr()
105 {
106 assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
107 // We can be one of the intermediate counts, but if we are the last
108 // VclPtr keeping this object alive, then something forgot to call dispose().
109 assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
"someone forgot to call dispose()") ? void (0) : __assert_fail
("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
110 && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
"someone forgot to call dispose()") ? void (0) : __assert_fail
("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
111 }
112 VclPtr(VclPtr const &) = default;
113 VclPtr(VclPtr &&) = default;
114 VclPtr & operator =(VclPtr const &) = default;
115 VclPtr & operator =(VclPtr &&) = default;
116#endif
117
118 /**
119 * A construction helper for VclPtr. Since VclPtr types are created
120 * with a reference-count of one - to help fit into the existing
121 * code-flow; this helps us to construct them easily.
122 *
123 * For more details on the design please see vcl/README.lifecycle
124 *
125 * @tparam reference_type must be a subclass of vcl::Window
126 */
127 template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
128 {
129 return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
130 }
131
132 /** Probably most common used: handle->someBodyOp().
133 */
134 reference_type * operator->() const
135 {
136 return m_rInnerRef.get();
20
←
Calling 'Reference::get'
→
137 }
138
139 /** Get the body. Can be used instead of operator->().
140 I.e. handle->someBodyOp() and handle.get()->someBodyOp()
141 are the same.
142 */
143 reference_type * get() const
144 {
145 return m_rInnerRef.get();
146 }
147
148 void set(reference_type *pBody)
149 {
150 m_rInnerRef.set(pBody);
151 }
152
153 void reset(reference_type *pBody)
154 {
155 m_rInnerRef.set(pBody);
156 }
157
158 /** Up-casting copy assignment operator.
159
160 Does not work for up-casts to ambiguous bases.
161
162 @param rRef another reference
163 */
164 template<typename derived_type>
165 typename std::enable_if<
166 std::is_base_of<reference_type, derived_type>::value,
167 VclPtr &>::type
168 operator =(VclPtr<derived_type> const & rRef)
169 {
170 m_rInnerRef.set(rRef.get());
171 return *this;
172 }
173
174 VclPtr & operator =(reference_type * pBody)
175 {
176 m_rInnerRef.set(pBody);
177 return *this;
178 }
179
180 operator reference_type * () const
181 {
182 return m_rInnerRef.get();
183 }
184
185 explicit operator bool () const
186 {
187 return m_rInnerRef.get() != nullptr;
188 }
189
190 void clear()
191 {
192 m_rInnerRef.clear();
193 }
194
195 void reset()
196 {
197 m_rInnerRef.clear();
198 }
199
200 void disposeAndClear()
201 {
202 // hold it alive for the lifetime of this method
203 ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
204 m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
205 if (aTmp.get()) {
206 aTmp->disposeOnce();
207 }
208 }
209
210 /** Needed to place VclPtr's into STL collection.
211 */
212 bool operator< (const VclPtr<reference_type> & handle) const
213 {
214 return (m_rInnerRef < handle.m_rInnerRef);
215 }
216}; // class VclPtr
217
218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
220 return p1.get() == p2.get();
221}
222
223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
225 return p1.get() == p2;
226}
227
228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
229 return p1.get() == p2;
230}
231
232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
234 return p1 == p2.get();
235}
236
237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
238 return p1 == p2.get();
239}
240
241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
243 return !(p1 == p2);
244}
245
246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
248 return !(p1 == p2);
249}
250
251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
252 return !(p1 == p2);
253}
254
255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
257 return !(p1 == p2);
258}
259
260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
261 return !(p1 == p2);
262}
263
264/**
265 * A construction helper for a temporary VclPtr. Since VclPtr types
266 * are created with a reference-count of one - to help fit into
267 * the existing code-flow; this helps us to construct them easily.
268 * see also VclPtr::Create and ScopedVclPtr
269 *
270 * For more details on the design please see vcl/README.lifecycle
271 *
272 * @param reference_type must be a subclass of vcl::Window
273 */
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
278 template<typename... Arg> VclPtrInstance(Arg &&... arg)
279 : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
280 {
281 }
282
283 /**
284 * Override and disallow this, to prevent people accidentally calling it and actually
285 * getting VclPtr::Create and getting a naked VclPtr<> instance
286 */
287 template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};
289
290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
294 /** Constructor...
295 */
296 ScopedVclPtr()
297 : VclPtr<reference_type>()
298 {}
299
300 /** Constructor
301 */
302 ScopedVclPtr (reference_type * pBody)
303 : VclPtr<reference_type>(pBody)
304 {}
305
306 /** Copy constructor...
307 */
308 ScopedVclPtr (const VclPtr<reference_type> & handle)
309 : VclPtr<reference_type>(handle)
2
←
Calling implicit copy constructor for 'VclPtr<AbstractScDataFormDlg>'
→
3
←
Calling copy constructor for 'Reference<AbstractScDataFormDlg>'
→
6
←
Returning from copy constructor for 'Reference<AbstractScDataFormDlg>'
→
7
←
Returning from copy constructor for 'VclPtr<AbstractScDataFormDlg>'
→
310 {}
311
312 /**
313 Assignment that releases the last reference.
314 */
315 void disposeAndReset(reference_type *pBody)
316 {
317 if (pBody != this->get()) {
318 VclPtr<reference_type>::disposeAndClear();
319 VclPtr<reference_type>::set(pBody);
320 }
321 }
322
323 /**
324 Assignment that releases the last reference.
325 */
326 ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
327 {
328 disposeAndReset(pBody);
329 return *this;
330 }
331
332 /** Up-casting conversion constructor: Copies interface reference.
333
334 Does not work for up-casts to ambiguous bases. For the special case of
335 up-casting to Reference< XInterface >, see the corresponding conversion
336 operator.
337
338 @param rRef another reference
339 */
340 template< class derived_type >
341 ScopedVclPtr(
342 const VclPtr< derived_type > & rRef,
343 typename std::enable_if<
344 std::is_base_of<reference_type, derived_type>::value, int>::type
345 = 0 )
346 : VclPtr<reference_type>( rRef )
347 {
348 }
349
350 /** Up-casting assignment operator.
351
352 Does not work for up-casts to ambiguous bases.
353
354 @param rRef another VclPtr
355 */
356 template<typename derived_type>
357 typename std::enable_if<
358 std::is_base_of<reference_type, derived_type>::value,
359 ScopedVclPtr &>::type
360 operator =(VclPtr<derived_type> const & rRef)
361 {
362 disposeAndReset(rRef.get());
363 return *this;
364 }
365
366 /**
367 * Override and disallow this, to prevent people accidentally calling it and actually
368 * getting VclPtr::Create and getting a naked VclPtr<> instance
369 */
370 template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;
371
372 ~ScopedVclPtr()
373 {
374 VclPtr<reference_type>::disposeAndClear();
375 assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
376 }
377
378private:
379 // Most likely we don't want this default copy-constructor.
380 ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
381 // And certainly we don't want a default assignment operator.
382 ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
383 // And disallow reset as that doesn't call disposeAndClear on the original reference
384 void reset() = delete;
385 void reset(reference_type *pBody) = delete;
386
387protected:
388 ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
389 : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
390 {}
391};
392
393/**
394 * A construction helper for ScopedVclPtr. Since VclPtr types are created
395 * with a reference-count of one - to help fit into the existing
396 * code-flow; this helps us to construct them easily.
397 *
398 * For more details on the design please see vcl/README.lifecycle
399 *
400 * @param reference_type must be a subclass of vcl::Window
401 */
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
410 template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
411 : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
412 {
413 }
414
415 /**
416 * Override and disallow this, to prevent people accidentally calling it and actually
417 * getting VclPtr::Create and getting a naked VclPtr<> instance
418 */
419 template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;
420
421private:
422 // Prevent the above perfect forwarding ctor from hijacking (accidental)
423 // attempts at ScopedVclPtrInstance copy construction (where the hijacking
424 // would typically lead to somewhat obscure error messages); both non-const
425 // and const variants are needed here, as the ScopedVclPtr base class has a
426 // const--variant copy ctor, so the implicitly declared copy ctor for
427 // ScopedVclPtrInstance would also be the const variant, so non-const copy
428 // construction attempts would be hijacked by the perfect forwarding ctor;
429 // but if we only declared a non-const variant here, the const variant would
430 // no longer be implicitly declared (as there would already be an explicitly
431 // declared copy ctor), so const copy construction attempts would then be
432 // hijacked by the perfect forwarding ctor:
433 ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
434 ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif
439
440#endif // INCLUDED_VCL_PTR_HXX
441
442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→
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#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX
22
23#include "sal/config.h"
24
25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif
31
32#include "sal/types.h"
33
34namespace rtl
35{
36
37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
42 /** The <b>reference_type</b> body pointer.
43 */
44 reference_type * m_pBody;
45
46
47public:
48 /** Constructor...
49 */
50 Reference()
51 : m_pBody (NULL__null)
52 {}
53
54
55 /** Constructor...
56 */
57 Reference (reference_type * pBody, __sal_NoAcquire)
58 : m_pBody (pBody)
59 {
60 }
61
62 /** Constructor...
63 */
64 Reference (reference_type * pBody)
65 : m_pBody (pBody)
66 {
67 if (m_pBody)
68 m_pBody->acquire();
69 }
70
71 /** Copy constructor...
72 */
73 Reference (const Reference<reference_type> & handle)
74 : m_pBody (handle.m_pBody)
75 {
76 if (m_pBody)
4
←
Assuming field 'm_pBody' is non-null
→
5
←
Taking true branch
→
77 m_pBody->acquire();
78 }
79
80#ifdef LIBO_INTERNAL_ONLY1
81 /** Move constructor...
82 */
83 Reference (Reference<reference_type> && handle) noexcept
84 : m_pBody (handle.m_pBody)
85 {
86 handle.m_pBody = nullptr;
87 }
88#endif
89
90#if defined LIBO_INTERNAL_ONLY1
91 /** Up-casting conversion constructor: Copies interface reference.
92
93 Does not work for up-casts to ambiguous bases.
94
95 @param rRef another reference
96 */
97 template< class derived_type >
98 inline Reference(
99 const Reference< derived_type > & rRef,
100 std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
101 : m_pBody (rRef.get())
102 {
103 if (m_pBody)
104 m_pBody->acquire();
105 }
106#endif
107
108 /** Destructor...
109 */
110 ~Reference() COVERITY_NOEXCEPT_FALSE
111 {
112 if (m_pBody
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
)
11
←
Taking true branch
→
113 m_pBody->release();
12
←
Calling 'VclReferenceBase::release'
→
16
←
Returning; memory was released
→
114 }
115
116 /** Set...
117 Similar to assignment.
118 */
119 Reference<reference_type> &
120 SAL_CALL set (reference_type * pBody)
121 {
122 if (pBody)
123 pBody->acquire();
124 reference_type * const pOld = m_pBody;
125 m_pBody = pBody;
126 if (pOld)
127 pOld->release();
128 return *this;
129 }
130
131 /** Assignment.
132 Unbinds this instance from its body (if bound) and
133 bind it to the body represented by the handle.
134 */
135 Reference<reference_type> &
136 SAL_CALL operator= (const Reference<reference_type> & handle)
137 {
138 return set( handle.m_pBody );
139 }
140
141#ifdef LIBO_INTERNAL_ONLY1
142 /** Assignment.
143 * Unbinds this instance from its body (if bound),
144 * bind it to the body represented by the handle, and
145 * set the body represented by the handle to nullptr.
146 */
147 Reference<reference_type> &
148 operator= (Reference<reference_type> && handle)
149 {
150 // self-movement guts ourself
151 if (m_pBody)
152 m_pBody->release();
153 m_pBody = handle.m_pBody;
154 handle.m_pBody = nullptr;
155 return *this;
156 }
157#endif
158
159 /** Assignment...
160 */
161 Reference<reference_type> &
162 SAL_CALL operator= (reference_type * pBody)
163 {
164 return set( pBody );
165 }
166
167 /** Unbind the body from this handle.
168 Note that for a handle representing a large body,
169 "handle.clear().set(new body());" _might_
170 perform a little bit better than "handle.set(new body());",
171 since in the second case two large objects exist in memory
172 (the old body and the new body).
173 */
174 Reference<reference_type> & SAL_CALL clear()
175 {
176 if (m_pBody)
177 {
178 reference_type * const pOld = m_pBody;
179 m_pBody = NULL__null;
180 pOld->release();
181 }
182 return *this;
183 }
184
185
186 /** Get the body. Can be used instead of operator->().
187 I.e. handle->someBodyOp() and handle.get()->someBodyOp()
188 are the same.
189 */
190 reference_type * SAL_CALL get() const
191 {
192 return m_pBody;
21
←
Use of memory after it is freed
193 }
194
195
196 /** Probably most common used: handle->someBodyOp().
197 */
198 reference_type * SAL_CALL operator->() const
199 {
200 assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
201 return m_pBody;
202 }
203
204
205 /** Allows (*handle).someBodyOp().
206 */
207 reference_type & SAL_CALL operator*() const
208 {
209 assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
210 return *m_pBody;
211 }
212
213
214 /** Returns True if the handle does point to a valid body.
215 */
216 bool SAL_CALL is() const
217 {
218 return (m_pBody != NULL__null);
219 }
220
221#if defined LIBO_INTERNAL_ONLY1
222 /** Returns True if the handle does point to a valid body.
223 */
224 explicit operator bool() const
225 {
226 return is();
227 }
228#endif
229
230 /** Returns True if this points to pBody.
231 */
232 bool SAL_CALL operator== (const reference_type * pBody) const
233 {
234 return (m_pBody == pBody);
235 }
236
237
238 /** Returns True if handle points to the same body.
239 */
240 bool
241 SAL_CALL operator== (const Reference<reference_type> & handle) const
242 {
243 return (m_pBody == handle.m_pBody);
244 }
245
246
247 /** Needed to place References into STL collection.
248 */
249 bool
250 SAL_CALL operator!= (const Reference<reference_type> & handle) const
251 {
252 return (m_pBody != handle.m_pBody);
253 }
254
255
256 /** Needed to place References into STL collection.
257 */
258 bool
259 SAL_CALL operator< (const Reference<reference_type> & handle) const
260 {
261 return (m_pBody < handle.m_pBody);
262 }
263
264
265 /** Needed to place References into STL collection.
266 */
267 bool
268 SAL_CALL operator> (const Reference<reference_type> & handle) const
269 {
270 return (m_pBody > handle.m_pBody);
271 }
272};
273
274} // namespace rtl
275
276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{
279
280/// @cond INTERNAL
281/**
282 Make rtl::Reference hashable by default for use in STL containers.
283
284 @since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
289 std::size_t operator()(::rtl::Reference<T> const & s) const
290 { return std::size_t(s.get()); }
291};
292/// @endcond
293
294}
295
296#endif
297
298#endif /* ! INCLUDED_RTL_REF_HXX */
299
300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

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#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27 mutable oslInterlockedCount mnRefCnt;
28
29 template<typename T> friend class VclPtr;
30
31public:
32 void acquire() const
33 {
34 osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35 }
36
37 void release() const
38 {
39 if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
13
←
Assuming the condition is true
→
14
←
Taking true branch
→
40 delete this;
15
←
Memory is released
→
41 }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44 sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47
48
49private:
50 VclReferenceBase(const VclReferenceBase&) = delete;
51 VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52
53 bool mbDisposed : 1;
54
55protected:
56 VclReferenceBase();
57protected:
58 virtual ~VclReferenceBase();
59
60protected:
61 virtual void dispose();
62
63public:
64 void disposeOnce();
65 bool isDisposed() const { return mbDisposed; }
66
67};
68#endif