Line data Source code
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 "xiescher.hxx"
21 :
22 : #include <com/sun/star/beans/NamedValue.hpp>
23 : #include <com/sun/star/container/XIndexContainer.hpp>
24 : #include <com/sun/star/container/XNameContainer.hpp>
25 : #include <com/sun/star/embed/Aspects.hpp>
26 : #include <com/sun/star/embed/XEmbeddedObject.hpp>
27 : #include <com/sun/star/embed/XEmbedPersist.hpp>
28 : #include <com/sun/star/awt/PushButtonType.hpp>
29 : #include <com/sun/star/awt/ScrollBarOrientation.hpp>
30 : #include <com/sun/star/awt/VisualEffect.hpp>
31 : #include <com/sun/star/style/HorizontalAlignment.hpp>
32 : #include <com/sun/star/style/VerticalAlignment.hpp>
33 : #include <com/sun/star/drawing/XControlShape.hpp>
34 : #include <com/sun/star/form/XForm.hpp>
35 : #include <com/sun/star/form/XFormsSupplier.hpp>
36 : #include <com/sun/star/form/binding/XBindableValue.hpp>
37 : #include <com/sun/star/form/binding/XValueBinding.hpp>
38 : #include <com/sun/star/form/binding/XListEntrySink.hpp>
39 : #include <com/sun/star/form/binding/XListEntrySource.hpp>
40 : #include <com/sun/star/script/ScriptEventDescriptor.hpp>
41 : #include <com/sun/star/script/XEventAttacherManager.hpp>
42 : #include <com/sun/star/beans/XPropertySet.hpp>
43 :
44 : #include <sfx2/objsh.hxx>
45 : #include <unotools/moduleoptions.hxx>
46 : #include <unotools/fltrcfg.hxx>
47 : #include <vcl/dibtools.hxx>
48 : #include <vcl/wmf.hxx>
49 : #include <comphelper/types.hxx>
50 : #include <comphelper/classids.hxx>
51 : #include <toolkit/helper/vclunohelper.hxx>
52 : #include <basegfx/point/b2dpoint.hxx>
53 : #include <basegfx/polygon/b2dpolygon.hxx>
54 :
55 : #include <svx/svdopath.hxx>
56 : #include <svx/svdocirc.hxx>
57 : #include <svx/svdoedge.hxx>
58 : #include <svx/svdogrp.hxx>
59 : #include <svx/svdoashp.hxx>
60 : #include <svx/svdograf.hxx>
61 : #include <svx/svdoole2.hxx>
62 : #include <svx/svdocapt.hxx>
63 : #include <svx/svdouno.hxx>
64 : #include <svx/svdpage.hxx>
65 : #include <editeng/editobj.hxx>
66 : #include <editeng/outliner.hxx>
67 : #include <editeng/outlobj.hxx>
68 : #include <svx/unoapi.hxx>
69 : #include <svx/svditer.hxx>
70 : #include <editeng/writingmodeitem.hxx>
71 : #include <svx/charthelper.hxx>
72 :
73 : #include "scitems.hxx"
74 : #include <editeng/eeitem.hxx>
75 : #include <editeng/colritem.hxx>
76 : #include <svx/xflclit.hxx>
77 : #include <sal/macros.h>
78 : #include <editeng/adjustitem.hxx>
79 : #include <svx/xlineit.hxx>
80 : #include <svx/xlinjoit.hxx>
81 : #include <svx/xlntrit.hxx>
82 : #include <svx/xbtmpit.hxx>
83 : #include <svx/xbitmap.hxx>
84 :
85 : #include "document.hxx"
86 : #include "drwlayer.hxx"
87 : #include "userdat.hxx"
88 : #include "chartarr.hxx"
89 : #include "detfunc.hxx"
90 : #include "unonames.hxx"
91 : #include "convuno.hxx"
92 : #include "postit.hxx"
93 : #include "globstr.hrc"
94 :
95 : #include "fprogressbar.hxx"
96 : #include "xltracer.hxx"
97 : #include "xistream.hxx"
98 : #include "xihelper.hxx"
99 : #include "xiformula.hxx"
100 : #include "xilink.hxx"
101 : #include "xistyle.hxx"
102 : #include "xipage.hxx"
103 : #include "xichart.hxx"
104 : #include "xicontent.hxx"
105 : #include "scextopt.hxx"
106 :
107 : #include "namebuff.hxx"
108 : #include <boost/scoped_ptr.hpp>
109 : #include <boost/shared_ptr.hpp>
110 : #include <sfx2/docfile.hxx>
111 :
112 : using ::com::sun::star::uno::makeAny;
113 : using ::com::sun::star::uno::Any;
114 : using ::com::sun::star::beans::XPropertySet;
115 : using ::com::sun::star::uno::makeAny;
116 : using ::com::sun::star::uno::Exception;
117 : using ::com::sun::star::uno::Reference;
118 : using ::com::sun::star::uno::Sequence;
119 : using ::com::sun::star::uno::UNO_QUERY;
120 : using ::com::sun::star::uno::UNO_QUERY_THROW;
121 : using ::com::sun::star::uno::UNO_SET_THROW;
122 : using ::com::sun::star::uno::XComponentContext;
123 : using ::com::sun::star::beans::NamedValue;
124 : using ::com::sun::star::lang::XMultiServiceFactory;
125 : using ::com::sun::star::container::XIndexContainer;
126 : using ::com::sun::star::container::XNameContainer;
127 : using ::com::sun::star::frame::XModel;
128 : using ::com::sun::star::awt::XControlModel;
129 : using ::com::sun::star::embed::XEmbeddedObject;
130 : using ::com::sun::star::embed::XEmbedPersist;
131 : using ::com::sun::star::drawing::XControlShape;
132 : using ::com::sun::star::drawing::XShape;
133 : using ::com::sun::star::form::XForm;
134 : using ::com::sun::star::form::XFormComponent;
135 : using ::com::sun::star::form::XFormsSupplier;
136 : using ::com::sun::star::form::binding::XBindableValue;
137 : using ::com::sun::star::form::binding::XValueBinding;
138 : using ::com::sun::star::form::binding::XListEntrySink;
139 : using ::com::sun::star::form::binding::XListEntrySource;
140 : using ::com::sun::star::script::ScriptEventDescriptor;
141 : using ::com::sun::star::script::XEventAttacherManager;
142 : using ::com::sun::star::table::CellAddress;
143 : using ::com::sun::star::table::CellRangeAddress;
144 :
145 : namespace {
146 :
147 : /** Helper class which mimics the auto_ptr< SdrObject > semantics, but calls
148 : SdrObject::Free instead of deleting the SdrObject directly. */
149 : template< typename SdrObjType >
150 : class TSdrObjectPtr
151 : {
152 : public:
153 0 : inline explicit TSdrObjectPtr( SdrObjType* pObj = 0 ) : mpObj( pObj ) {}
154 0 : inline ~TSdrObjectPtr() { free(); }
155 :
156 : inline const SdrObjType* operator->() const { return mpObj; }
157 0 : inline SdrObjType* operator->() { return mpObj; }
158 :
159 : inline const SdrObjType* get() const { return mpObj; }
160 0 : inline SdrObjType* get() { return mpObj; }
161 :
162 : inline const SdrObjType& operator*() const { return *mpObj; }
163 0 : inline SdrObjType& operator*() { return *mpObj; }
164 :
165 0 : inline bool is() const { return mpObj != 0; }
166 0 : inline bool operator!() const { return mpObj == 0; }
167 :
168 0 : inline void reset( SdrObjType* pObj = 0 ) { free(); mpObj = pObj; }
169 0 : inline SdrObjType* release() { SdrObjType* pObj = mpObj; mpObj = 0; return pObj; }
170 :
171 : private:
172 : TSdrObjectPtr( const TSdrObjectPtr& ); // not implemented
173 : TSdrObjectPtr& operator=( TSdrObjectPtr& rxObj ); // not implemented
174 :
175 0 : inline void free() { SdrObject* pObj = mpObj; mpObj = 0; SdrObject::Free( pObj ); }
176 :
177 : private:
178 : SdrObjType* mpObj;
179 : };
180 :
181 : typedef TSdrObjectPtr< SdrObject > SdrObjectPtr;
182 :
183 : } // namespace
184 :
185 : // Drawing objects ============================================================
186 :
187 0 : XclImpDrawObjBase::XclImpDrawObjBase( const XclImpRoot& rRoot ) :
188 : XclImpRoot( rRoot ),
189 : mnObjId( EXC_OBJ_INVALID_ID ),
190 : mnTab( 0 ),
191 : mnObjType( EXC_OBJTYPE_UNKNOWN ),
192 : mnDffShapeId( 0 ),
193 : mnDffFlags( 0 ),
194 : mbHasAnchor( false ),
195 : mbHidden( false ),
196 : mbVisible( true ),
197 : mbPrintable( true ),
198 : mbAreaObj( false ),
199 : mbAutoMargin( true ),
200 : mbSimpleMacro( true ),
201 : mbProcessSdr( true ),
202 : mbInsertSdr( true ),
203 0 : mbCustomDff( false )
204 : {
205 0 : }
206 :
207 0 : XclImpDrawObjBase::~XclImpDrawObjBase()
208 : {
209 0 : }
210 :
211 0 : XclImpDrawObjRef XclImpDrawObjBase::ReadObj3( const XclImpRoot& rRoot, XclImpStream& rStrm )
212 : {
213 0 : XclImpDrawObjRef xDrawObj;
214 :
215 0 : if( rStrm.GetRecLeft() >= 30 )
216 : {
217 : sal_uInt16 nObjType;
218 0 : rStrm.Ignore( 4 );
219 0 : rStrm >> nObjType;
220 0 : switch( nObjType )
221 : {
222 0 : case EXC_OBJTYPE_GROUP: xDrawObj.reset( new XclImpGroupObj( rRoot ) ); break;
223 0 : case EXC_OBJTYPE_LINE: xDrawObj.reset( new XclImpLineObj( rRoot ) ); break;
224 0 : case EXC_OBJTYPE_RECTANGLE: xDrawObj.reset( new XclImpRectObj( rRoot ) ); break;
225 0 : case EXC_OBJTYPE_OVAL: xDrawObj.reset( new XclImpOvalObj( rRoot ) ); break;
226 0 : case EXC_OBJTYPE_ARC: xDrawObj.reset( new XclImpArcObj( rRoot ) ); break;
227 0 : case EXC_OBJTYPE_CHART: xDrawObj.reset( new XclImpChartObj( rRoot ) ); break;
228 0 : case EXC_OBJTYPE_TEXT: xDrawObj.reset( new XclImpTextObj( rRoot ) ); break;
229 0 : case EXC_OBJTYPE_BUTTON: xDrawObj.reset( new XclImpButtonObj( rRoot ) ); break;
230 0 : case EXC_OBJTYPE_PICTURE: xDrawObj.reset( new XclImpPictureObj( rRoot ) ); break;
231 : default:
232 : OSL_TRACE( "XclImpDrawObjBase::ReadObj3 - unknown object type 0x%04hX", nObjType );
233 0 : rRoot.GetTracer().TraceUnsupportedObjects();
234 0 : xDrawObj.reset( new XclImpPhObj( rRoot ) );
235 : }
236 : }
237 :
238 0 : xDrawObj->mnTab = rRoot.GetCurrScTab();
239 0 : xDrawObj->ImplReadObj3( rStrm );
240 0 : return xDrawObj;
241 : }
242 :
243 0 : XclImpDrawObjRef XclImpDrawObjBase::ReadObj4( const XclImpRoot& rRoot, XclImpStream& rStrm )
244 : {
245 0 : XclImpDrawObjRef xDrawObj;
246 :
247 0 : if( rStrm.GetRecLeft() >= 30 )
248 : {
249 : sal_uInt16 nObjType;
250 0 : rStrm.Ignore( 4 );
251 0 : rStrm >> nObjType;
252 0 : switch( nObjType )
253 : {
254 0 : case EXC_OBJTYPE_GROUP: xDrawObj.reset( new XclImpGroupObj( rRoot ) ); break;
255 0 : case EXC_OBJTYPE_LINE: xDrawObj.reset( new XclImpLineObj( rRoot ) ); break;
256 0 : case EXC_OBJTYPE_RECTANGLE: xDrawObj.reset( new XclImpRectObj( rRoot ) ); break;
257 0 : case EXC_OBJTYPE_OVAL: xDrawObj.reset( new XclImpOvalObj( rRoot ) ); break;
258 0 : case EXC_OBJTYPE_ARC: xDrawObj.reset( new XclImpArcObj( rRoot ) ); break;
259 0 : case EXC_OBJTYPE_CHART: xDrawObj.reset( new XclImpChartObj( rRoot ) ); break;
260 0 : case EXC_OBJTYPE_TEXT: xDrawObj.reset( new XclImpTextObj( rRoot ) ); break;
261 0 : case EXC_OBJTYPE_BUTTON: xDrawObj.reset( new XclImpButtonObj( rRoot ) ); break;
262 0 : case EXC_OBJTYPE_PICTURE: xDrawObj.reset( new XclImpPictureObj( rRoot ) ); break;
263 0 : case EXC_OBJTYPE_POLYGON: xDrawObj.reset( new XclImpPolygonObj( rRoot ) ); break;
264 : default:
265 : OSL_TRACE( "XclImpDrawObjBase::ReadObj4 - unknown object type 0x%04hX", nObjType );
266 0 : rRoot.GetTracer().TraceUnsupportedObjects();
267 0 : xDrawObj.reset( new XclImpPhObj( rRoot ) );
268 : }
269 : }
270 :
271 0 : xDrawObj->mnTab = rRoot.GetCurrScTab();
272 0 : xDrawObj->ImplReadObj4( rStrm );
273 0 : return xDrawObj;
274 : }
275 :
276 0 : XclImpDrawObjRef XclImpDrawObjBase::ReadObj5( const XclImpRoot& rRoot, XclImpStream& rStrm )
277 : {
278 0 : XclImpDrawObjRef xDrawObj;
279 :
280 0 : if( rStrm.GetRecLeft() >= 34 )
281 : {
282 0 : sal_uInt16 nObjType(EXC_OBJTYPE_UNKNOWN);
283 0 : rStrm.Ignore( 4 );
284 0 : rStrm >> nObjType;
285 0 : switch( nObjType )
286 : {
287 0 : case EXC_OBJTYPE_GROUP: xDrawObj.reset( new XclImpGroupObj( rRoot ) ); break;
288 0 : case EXC_OBJTYPE_LINE: xDrawObj.reset( new XclImpLineObj( rRoot ) ); break;
289 0 : case EXC_OBJTYPE_RECTANGLE: xDrawObj.reset( new XclImpRectObj( rRoot ) ); break;
290 0 : case EXC_OBJTYPE_OVAL: xDrawObj.reset( new XclImpOvalObj( rRoot ) ); break;
291 0 : case EXC_OBJTYPE_ARC: xDrawObj.reset( new XclImpArcObj( rRoot ) ); break;
292 0 : case EXC_OBJTYPE_CHART: xDrawObj.reset( new XclImpChartObj( rRoot ) ); break;
293 0 : case EXC_OBJTYPE_TEXT: xDrawObj.reset( new XclImpTextObj( rRoot ) ); break;
294 0 : case EXC_OBJTYPE_BUTTON: xDrawObj.reset( new XclImpButtonObj( rRoot ) ); break;
295 0 : case EXC_OBJTYPE_PICTURE: xDrawObj.reset( new XclImpPictureObj( rRoot ) ); break;
296 0 : case EXC_OBJTYPE_POLYGON: xDrawObj.reset( new XclImpPolygonObj( rRoot ) ); break;
297 0 : case EXC_OBJTYPE_CHECKBOX: xDrawObj.reset( new XclImpCheckBoxObj( rRoot ) ); break;
298 0 : case EXC_OBJTYPE_OPTIONBUTTON: xDrawObj.reset( new XclImpOptionButtonObj( rRoot ) ); break;
299 0 : case EXC_OBJTYPE_EDIT: xDrawObj.reset( new XclImpEditObj( rRoot ) ); break;
300 0 : case EXC_OBJTYPE_LABEL: xDrawObj.reset( new XclImpLabelObj( rRoot ) ); break;
301 0 : case EXC_OBJTYPE_DIALOG: xDrawObj.reset( new XclImpDialogObj( rRoot ) ); break;
302 0 : case EXC_OBJTYPE_SPIN: xDrawObj.reset( new XclImpSpinButtonObj( rRoot ) ); break;
303 0 : case EXC_OBJTYPE_SCROLLBAR: xDrawObj.reset( new XclImpScrollBarObj( rRoot ) ); break;
304 0 : case EXC_OBJTYPE_LISTBOX: xDrawObj.reset( new XclImpListBoxObj( rRoot ) ); break;
305 0 : case EXC_OBJTYPE_GROUPBOX: xDrawObj.reset( new XclImpGroupBoxObj( rRoot ) ); break;
306 0 : case EXC_OBJTYPE_DROPDOWN: xDrawObj.reset( new XclImpDropDownObj( rRoot ) ); break;
307 : default:
308 : OSL_TRACE( "XclImpDrawObjBase::ReadObj5 - unknown object type 0x%04hX", nObjType );
309 0 : rRoot.GetTracer().TraceUnsupportedObjects();
310 0 : xDrawObj.reset( new XclImpPhObj( rRoot ) );
311 : }
312 : }
313 :
314 : OSL_ENSURE(xDrawObj, "object import failed");
315 :
316 0 : if (xDrawObj)
317 : {
318 0 : xDrawObj->mnTab = rRoot.GetCurrScTab();
319 0 : xDrawObj->ImplReadObj5( rStrm );
320 : }
321 0 : return xDrawObj;
322 : }
323 :
324 0 : XclImpDrawObjRef XclImpDrawObjBase::ReadObj8( const XclImpRoot& rRoot, XclImpStream& rStrm )
325 : {
326 0 : XclImpDrawObjRef xDrawObj;
327 :
328 0 : if( rStrm.GetRecLeft() >= 10 )
329 : {
330 0 : sal_uInt16 nSubRecId(0), nSubRecSize(0), nObjType(0);
331 0 : rStrm >> nSubRecId >> nSubRecSize >> nObjType;
332 : OSL_ENSURE( nSubRecId == EXC_ID_OBJCMO, "XclImpDrawObjBase::ReadObj8 - OBJCMO subrecord expected" );
333 0 : if( (nSubRecId == EXC_ID_OBJCMO) && (nSubRecSize >= 6) )
334 : {
335 0 : switch( nObjType )
336 : {
337 : // in BIFF8, all simple objects support text
338 : case EXC_OBJTYPE_LINE:
339 : case EXC_OBJTYPE_ARC:
340 0 : xDrawObj.reset( new XclImpTextObj( rRoot ) );
341 : // lines and arcs may be 2-dimensional
342 0 : xDrawObj->SetAreaObj( false );
343 0 : break;
344 :
345 : // in BIFF8, all simple objects support text
346 : case EXC_OBJTYPE_RECTANGLE:
347 : case EXC_OBJTYPE_OVAL:
348 : case EXC_OBJTYPE_POLYGON:
349 : case EXC_OBJTYPE_DRAWING:
350 : case EXC_OBJTYPE_TEXT:
351 0 : xDrawObj.reset( new XclImpTextObj( rRoot ) );
352 0 : break;
353 :
354 0 : case EXC_OBJTYPE_GROUP: xDrawObj.reset( new XclImpGroupObj( rRoot ) ); break;
355 0 : case EXC_OBJTYPE_CHART: xDrawObj.reset( new XclImpChartObj( rRoot ) ); break;
356 0 : case EXC_OBJTYPE_BUTTON: xDrawObj.reset( new XclImpButtonObj( rRoot ) ); break;
357 0 : case EXC_OBJTYPE_PICTURE: xDrawObj.reset( new XclImpPictureObj( rRoot ) ); break;
358 0 : case EXC_OBJTYPE_CHECKBOX: xDrawObj.reset( new XclImpCheckBoxObj( rRoot ) ); break;
359 0 : case EXC_OBJTYPE_OPTIONBUTTON: xDrawObj.reset( new XclImpOptionButtonObj( rRoot ) ); break;
360 0 : case EXC_OBJTYPE_EDIT: xDrawObj.reset( new XclImpEditObj( rRoot ) ); break;
361 0 : case EXC_OBJTYPE_LABEL: xDrawObj.reset( new XclImpLabelObj( rRoot ) ); break;
362 0 : case EXC_OBJTYPE_DIALOG: xDrawObj.reset( new XclImpDialogObj( rRoot ) ); break;
363 0 : case EXC_OBJTYPE_SPIN: xDrawObj.reset( new XclImpSpinButtonObj( rRoot ) ); break;
364 0 : case EXC_OBJTYPE_SCROLLBAR: xDrawObj.reset( new XclImpScrollBarObj( rRoot ) ); break;
365 0 : case EXC_OBJTYPE_LISTBOX: xDrawObj.reset( new XclImpListBoxObj( rRoot ) ); break;
366 0 : case EXC_OBJTYPE_GROUPBOX: xDrawObj.reset( new XclImpGroupBoxObj( rRoot ) ); break;
367 0 : case EXC_OBJTYPE_DROPDOWN: xDrawObj.reset( new XclImpDropDownObj( rRoot ) ); break;
368 0 : case EXC_OBJTYPE_NOTE: xDrawObj.reset( new XclImpNoteObj( rRoot ) ); break;
369 :
370 : default:
371 : OSL_TRACE( "XclImpDrawObjBase::ReadObj8 - unknown object type 0x%04hX", nObjType );
372 0 : rRoot.GetTracer().TraceUnsupportedObjects();
373 : }
374 : }
375 : }
376 :
377 0 : if (!xDrawObj) //ensure placeholder for unknown or broken records
378 : {
379 : SAL_WARN( "sc", "XclImpDrawObjBase::ReadObj8 import failed, substituting placeholder");
380 0 : xDrawObj.reset( new XclImpPhObj( rRoot ) );
381 : }
382 :
383 0 : xDrawObj->mnTab = rRoot.GetCurrScTab();
384 0 : xDrawObj->ImplReadObj8( rStrm );
385 0 : return xDrawObj;
386 : }
387 :
388 0 : void XclImpDrawObjBase::SetAnchor( const XclObjAnchor& rAnchor )
389 : {
390 0 : maAnchor = rAnchor;
391 0 : mbHasAnchor = true;
392 0 : }
393 :
394 0 : void XclImpDrawObjBase::SetDffData(
395 : const DffObjData& rDffObjData, const OUString& rObjName, const OUString& rHyperlink,
396 : bool bVisible, bool bAutoMargin )
397 : {
398 0 : mnDffShapeId = rDffObjData.nShapeId;
399 0 : mnDffFlags = rDffObjData.nSpFlags;
400 0 : maObjName = rObjName;
401 0 : maHyperlink = rHyperlink;
402 0 : mbVisible = bVisible;
403 0 : mbAutoMargin = bAutoMargin;
404 0 : }
405 :
406 0 : OUString XclImpDrawObjBase::GetObjName() const
407 : {
408 : /* #i51348# Always return a non-empty name. Create English
409 : default names depending on the object type. This is not implemented as
410 : virtual functions in derived classes, as class type and object type may
411 : not match. */
412 0 : return maObjName.isEmpty() ? GetObjectManager().GetDefaultObjName(*this) : maObjName;
413 : }
414 :
415 0 : const XclObjAnchor* XclImpDrawObjBase::GetAnchor() const
416 : {
417 0 : return mbHasAnchor ? &maAnchor : 0;
418 : }
419 :
420 0 : bool XclImpDrawObjBase::IsValidSize( const Rectangle& rAnchorRect ) const
421 : {
422 : // XclObjAnchor rounds up the width, width of 3 is the result of an Excel width of 0
423 : return mbAreaObj ?
424 0 : ((rAnchorRect.GetWidth() > 3) && (rAnchorRect.GetHeight() > 1)) :
425 0 : ((rAnchorRect.GetWidth() > 3) || (rAnchorRect.GetHeight() > 1));
426 : }
427 :
428 0 : ScRange XclImpDrawObjBase::GetUsedArea( SCTAB nScTab ) const
429 : {
430 0 : ScRange aScUsedArea( ScAddress::INITIALIZE_INVALID );
431 : // #i44077# object inserted -> update used area for OLE object import
432 0 : if( mbHasAnchor && GetAddressConverter().ConvertRange( aScUsedArea, maAnchor, nScTab, nScTab, false ) )
433 : {
434 : // reduce range, if object ends directly on borders between two columns or rows
435 0 : if( (maAnchor.mnRX == 0) && (aScUsedArea.aStart.Col() < aScUsedArea.aEnd.Col()) )
436 0 : aScUsedArea.aEnd.IncCol( -1 );
437 0 : if( (maAnchor.mnBY == 0) && (aScUsedArea.aStart.Row() < aScUsedArea.aEnd.Row()) )
438 0 : aScUsedArea.aEnd.IncRow( -1 );
439 : }
440 0 : return aScUsedArea;
441 : }
442 :
443 0 : sal_Size XclImpDrawObjBase::GetProgressSize() const
444 : {
445 0 : return DoGetProgressSize();
446 : }
447 :
448 0 : SdrObject* XclImpDrawObjBase::CreateSdrObject( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect, bool bIsDff ) const
449 : {
450 0 : SdrObjectPtr xSdrObj;
451 0 : if( bIsDff && !mbCustomDff )
452 : {
453 0 : rDffConv.Progress( GetProgressSize() );
454 : }
455 : else
456 : {
457 0 : xSdrObj.reset( DoCreateSdrObj( rDffConv, rAnchorRect ) );
458 0 : if( xSdrObj.is() )
459 0 : xSdrObj->SetModel( rDffConv.GetModel() );
460 : //added for exporting OCX control
461 : /* mnObjType value set should be as below table:
462 : 0x0000 Group 0x0001 Line
463 : 0x0002 Rectangle 0x0003 Oval
464 : 0x0004 Arc 0x0005 Chart
465 : 0x0006 Text 0x0009 Polygon
466 : +-----------------------------------------------------+
467 : OCX ==>| 0x0008 Picture |
468 : +-----------------------------------------------------+
469 : | 0x0007 Button |
470 : | 0x000B Checkbox 0x000C Radio button |
471 : | 0x000D Edit box 0x000E Label |
472 : TBX ==> | 0x000F Dialog box 0x0010 Spin control |
473 : | 0x0011 Scrollbar 0x0012 List |
474 : | 0x0013 Group box 0x0014 Dropdown list |
475 : +-----------------------------------------------------+
476 : 0x0019 Note 0x001E OfficeArt object
477 : */
478 0 : if( xSdrObj.is() && xSdrObj->IsUnoObj() &&
479 0 : ( (mnObjType < 25 && mnObjType > 10) || mnObjType == 7 || mnObjType == 8 ) )
480 : {
481 0 : SdrUnoObj* pSdrUnoObj = dynamic_cast< SdrUnoObj* >( xSdrObj.get() );
482 0 : if( pSdrUnoObj != NULL )
483 : {
484 0 : Reference< XControlModel > xCtrlModel = pSdrUnoObj->GetUnoControlModel();
485 0 : Reference< XPropertySet > xPropSet(xCtrlModel,UNO_QUERY);
486 0 : const static rtl::OUString sPropertyName("ControlTypeinMSO");
487 :
488 : enum { eCreateFromOffice = 0, eCreateFromMSTBXControl, eCreateFromMSOCXControl };
489 :
490 0 : if( mnObjType == 7 || (mnObjType < 25 && mnObjType > 10) )//TBX
491 : {
492 : //Need summary type for export. Detail type(checkbox, button ...) has been contained by mnObjType
493 0 : const sal_Int16 nTBXControlType = eCreateFromMSTBXControl ;
494 0 : Any aAny;
495 0 : aAny <<= nTBXControlType;
496 : try
497 : {
498 0 : xPropSet->setPropertyValue(sPropertyName, aAny);
499 : }
500 0 : catch(const Exception&)
501 : {
502 : OSL_TRACE("XclImpDrawObjBase::CreateSdrObject, this control can't be set the property ControlTypeinMSO!");
503 0 : }
504 : }
505 0 : if( mnObjType == 8 )//OCX
506 : {
507 : //Need summary type for export
508 0 : const static rtl::OUString sObjIdPropertyName("ObjIDinMSO");
509 0 : const XclImpPictureObj* const pObj = dynamic_cast< const XclImpPictureObj* const >(this);
510 0 : if( pObj != NULL && pObj->IsOcxControl() )
511 : {
512 0 : const sal_Int16 nOCXControlType = eCreateFromMSOCXControl;
513 0 : Any aAny;
514 : try
515 : {
516 0 : aAny <<= nOCXControlType;
517 0 : xPropSet->setPropertyValue(sPropertyName, aAny);
518 : //Detail type(checkbox, button ...)
519 0 : aAny<<= mnObjId;
520 0 : xPropSet->setPropertyValue(sObjIdPropertyName, aAny);
521 : }
522 0 : catch(const Exception&)
523 : {
524 : OSL_TRACE("XclImpDrawObjBase::CreateSdrObject, this control can't be set the property ObjIDinMSO!");
525 0 : }
526 : }
527 0 : }
528 :
529 : }
530 : }
531 : }
532 0 : return xSdrObj.release();
533 : }
534 :
535 0 : void XclImpDrawObjBase::PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
536 : {
537 : // default: front layer, derived classes may have to set other layer in DoPreProcessSdrObj()
538 0 : rSdrObj.NbcSetLayer( SC_LAYER_FRONT );
539 :
540 : // set object name (GetObjName() will always return a non-empty name)
541 0 : rSdrObj.SetName( GetObjName() );
542 :
543 : // #i39167# full width for all objects regardless of horizontal alignment
544 0 : rSdrObj.SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_BLOCK ) );
545 :
546 : // automatic text margin
547 0 : if( mbAutoMargin )
548 : {
549 0 : sal_Int32 nMargin = rDffConv.GetDefaultTextMargin();
550 0 : rSdrObj.SetMergedItem( SdrTextLeftDistItem( nMargin ) );
551 0 : rSdrObj.SetMergedItem( SdrTextRightDistItem( nMargin ) );
552 0 : rSdrObj.SetMergedItem( SdrTextUpperDistItem( nMargin ) );
553 0 : rSdrObj.SetMergedItem( SdrTextLowerDistItem( nMargin ) );
554 : }
555 :
556 : // macro and hyperlink
557 : // removed oracle/sun check for mbSimpleMacro ( no idea what its for )
558 0 : if (!maMacroName.isEmpty() || !maHyperlink.isEmpty())
559 : {
560 0 : if( ScMacroInfo* pInfo = ScDrawLayer::GetMacroInfo( &rSdrObj, true ) )
561 : {
562 0 : pInfo->SetMacro( XclTools::GetSbMacroUrl( maMacroName, GetDocShell() ) );
563 0 : pInfo->SetHlink( maHyperlink );
564 : }
565 : }
566 :
567 : // call virtual function for object type specific processing
568 0 : DoPreProcessSdrObj( rDffConv, rSdrObj );
569 0 : }
570 :
571 0 : void XclImpDrawObjBase::PostProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
572 : {
573 : // call virtual function for object type specific processing
574 0 : DoPostProcessSdrObj( rDffConv, rSdrObj );
575 0 : }
576 :
577 : // protected ------------------------------------------------------------------
578 :
579 0 : void XclImpDrawObjBase::ReadName5( XclImpStream& rStrm, sal_uInt16 nNameLen )
580 : {
581 0 : maObjName = OUString();
582 0 : if( nNameLen > 0 )
583 : {
584 : // name length field is repeated before the name
585 0 : maObjName = rStrm.ReadByteString( false );
586 : // skip padding byte for word boundaries
587 0 : if( rStrm.GetRecPos() & 1 ) rStrm.Ignore( 1 );
588 : }
589 0 : }
590 :
591 0 : void XclImpDrawObjBase::ReadMacro3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
592 : {
593 0 : maMacroName = OUString();
594 0 : rStrm.Ignore( nMacroSize );
595 : // skip padding byte for word boundaries, not contained in nMacroSize
596 0 : if( rStrm.GetRecPos() & 1 ) rStrm.Ignore( 1 );
597 0 : }
598 :
599 0 : void XclImpDrawObjBase::ReadMacro4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
600 : {
601 0 : maMacroName = OUString();
602 0 : rStrm.Ignore( nMacroSize );
603 0 : }
604 :
605 0 : void XclImpDrawObjBase::ReadMacro5( XclImpStream& rStrm, sal_uInt16 nMacroSize )
606 : {
607 0 : maMacroName = OUString();
608 0 : rStrm.Ignore( nMacroSize );
609 0 : }
610 :
611 0 : void XclImpDrawObjBase::ReadMacro8( XclImpStream& rStrm )
612 : {
613 0 : maMacroName = OUString();
614 0 : if( rStrm.GetRecLeft() > 6 )
615 : {
616 : // macro is stored in a tNameXR token containing a link to a defined name
617 : sal_uInt16 nFmlaSize;
618 0 : rStrm >> nFmlaSize;
619 0 : rStrm.Ignore( 4 );
620 : OSL_ENSURE( nFmlaSize == 7, "XclImpDrawObjBase::ReadMacro - unexpected formula size" );
621 0 : if( nFmlaSize == 7 )
622 : {
623 : sal_uInt8 nTokenId;
624 : sal_uInt16 nExtSheet, nExtName;
625 0 : rStrm >> nTokenId >> nExtSheet >> nExtName;
626 : OSL_ENSURE( nTokenId == XclTokenArrayHelper::GetTokenId( EXC_TOKID_NAMEX, EXC_TOKCLASS_REF ),
627 : "XclImpDrawObjBase::ReadMacro - tNameXR token expected" );
628 0 : if( nTokenId == XclTokenArrayHelper::GetTokenId( EXC_TOKID_NAMEX, EXC_TOKCLASS_REF ) )
629 0 : maMacroName = GetLinkManager().GetMacroName( nExtSheet, nExtName );
630 : }
631 : }
632 0 : }
633 :
634 0 : void XclImpDrawObjBase::ConvertLineStyle( SdrObject& rSdrObj, const XclObjLineData& rLineData ) const
635 : {
636 0 : if( rLineData.IsAuto() )
637 : {
638 0 : XclObjLineData aAutoData;
639 0 : aAutoData.mnAuto = 0;
640 0 : ConvertLineStyle( rSdrObj, aAutoData );
641 : }
642 : else
643 : {
644 0 : long nLineWidth = 35 * ::std::min( rLineData.mnWidth, EXC_OBJ_LINE_THICK );
645 0 : rSdrObj.SetMergedItem( XLineWidthItem( nLineWidth ) );
646 0 : rSdrObj.SetMergedItem( XLineColorItem( EMPTY_OUSTRING, GetPalette().GetColor( rLineData.mnColorIdx ) ) );
647 0 : rSdrObj.SetMergedItem( XLineJointItem( com::sun::star::drawing::LineJoint_MITER ) );
648 :
649 0 : sal_uLong nDotLen = ::std::max< sal_uLong >( 70 * rLineData.mnWidth, 35 );
650 0 : sal_uLong nDashLen = 3 * nDotLen;
651 0 : sal_uLong nDist = 2 * nDotLen;
652 :
653 0 : switch( rLineData.mnStyle )
654 : {
655 : default:
656 : case EXC_OBJ_LINE_SOLID:
657 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_SOLID ) );
658 0 : break;
659 : case EXC_OBJ_LINE_DASH:
660 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_DASH ) );
661 0 : rSdrObj.SetMergedItem( XLineDashItem( EMPTY_OUSTRING, XDash( XDASH_RECT, 0, nDotLen, 1, nDashLen, nDist ) ) );
662 0 : break;
663 : case EXC_OBJ_LINE_DOT:
664 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_DASH ) );
665 0 : rSdrObj.SetMergedItem( XLineDashItem( EMPTY_OUSTRING, XDash( XDASH_RECT, 1, nDotLen, 0, nDashLen, nDist ) ) );
666 0 : break;
667 : case EXC_OBJ_LINE_DASHDOT:
668 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_DASH ) );
669 0 : rSdrObj.SetMergedItem( XLineDashItem( EMPTY_OUSTRING, XDash( XDASH_RECT, 1, nDotLen, 1, nDashLen, nDist ) ) );
670 0 : break;
671 : case EXC_OBJ_LINE_DASHDOTDOT:
672 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_DASH ) );
673 0 : rSdrObj.SetMergedItem( XLineDashItem( EMPTY_OUSTRING, XDash( XDASH_RECT, 2, nDotLen, 1, nDashLen, nDist ) ) );
674 0 : break;
675 : case EXC_OBJ_LINE_MEDTRANS:
676 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_SOLID ) );
677 0 : rSdrObj.SetMergedItem( XLineTransparenceItem( 50 ) );
678 0 : break;
679 : case EXC_OBJ_LINE_DARKTRANS:
680 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_SOLID ) );
681 0 : rSdrObj.SetMergedItem( XLineTransparenceItem( 25 ) );
682 0 : break;
683 : case EXC_OBJ_LINE_LIGHTTRANS:
684 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_SOLID ) );
685 0 : rSdrObj.SetMergedItem( XLineTransparenceItem( 75 ) );
686 0 : break;
687 : case EXC_OBJ_LINE_NONE:
688 0 : rSdrObj.SetMergedItem( XLineStyleItem( XLINE_NONE ) );
689 0 : break;
690 : }
691 : }
692 0 : }
693 :
694 0 : void XclImpDrawObjBase::ConvertFillStyle( SdrObject& rSdrObj, const XclObjFillData& rFillData ) const
695 : {
696 0 : if( rFillData.IsAuto() )
697 : {
698 0 : XclObjFillData aAutoData;
699 0 : aAutoData.mnAuto = 0;
700 0 : ConvertFillStyle( rSdrObj, aAutoData );
701 : }
702 0 : else if( rFillData.mnPattern == EXC_PATT_NONE )
703 : {
704 0 : rSdrObj.SetMergedItem( XFillStyleItem( XFILL_NONE ) );
705 : }
706 : else
707 : {
708 0 : Color aPattColor = GetPalette().GetColor( rFillData.mnPattColorIdx );
709 0 : Color aBackColor = GetPalette().GetColor( rFillData.mnBackColorIdx );
710 0 : if( (rFillData.mnPattern == EXC_PATT_SOLID) || (aPattColor == aBackColor) )
711 : {
712 0 : rSdrObj.SetMergedItem( XFillStyleItem( XFILL_SOLID ) );
713 0 : rSdrObj.SetMergedItem( XFillColorItem( EMPTY_OUSTRING, aPattColor ) );
714 : }
715 : else
716 : {
717 : static const sal_uInt8 sppnPatterns[][ 8 ] =
718 : {
719 : { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55 },
720 : { 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD },
721 : { 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22 },
722 : { 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00 },
723 : { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC },
724 : { 0x33, 0x66, 0xCC, 0x99, 0x33, 0x66, 0xCC, 0x99 },
725 : { 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99 },
726 : { 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33 },
727 : { 0xCC, 0xFF, 0x33, 0xFF, 0xCC, 0xFF, 0x33, 0xFF },
728 : { 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00 },
729 : { 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88 },
730 : { 0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88 },
731 : { 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11 },
732 : { 0xFF, 0x11, 0x11, 0x11, 0xFF, 0x11, 0x11, 0x11 },
733 : { 0xAA, 0x44, 0xAA, 0x11, 0xAA, 0x44, 0xAA, 0x11 },
734 : { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 },
735 : { 0x80, 0x00, 0x08, 0x00, 0x80, 0x00, 0x08, 0x00 }
736 : };
737 0 : const sal_uInt8* const pnPattern = sppnPatterns[ ::std::min< size_t >( rFillData.mnPattern - 2, SAL_N_ELEMENTS( sppnPatterns ) ) ];
738 : // create 2-colored 8x8 DIB
739 0 : SvMemoryStream aMemStrm;
740 0 : aMemStrm.WriteUInt32( sal_uInt32( 12 ) ).WriteInt16( sal_Int16( 8 ) ).WriteInt16( sal_Int16( 8 ) ).WriteUInt16( sal_uInt16( 1 ) ).WriteUInt16( sal_uInt16( 1 ) );
741 0 : aMemStrm.WriteUChar( sal_uInt8( 0xFF ) ).WriteUChar( sal_uInt8( 0xFF ) ).WriteUChar( sal_uInt8( 0xFF ) );
742 0 : aMemStrm.WriteUChar( sal_uInt8( 0x00 ) ).WriteUChar( sal_uInt8( 0x00 ) ).WriteUChar( sal_uInt8( 0x00 ) );
743 0 : for( size_t nIdx = 0; nIdx < 8; ++nIdx )
744 0 : aMemStrm.WriteUInt32( sal_uInt32( pnPattern[ nIdx ] ) ); // 32-bit little-endian
745 0 : aMemStrm.Seek( STREAM_SEEK_TO_BEGIN );
746 0 : Bitmap aBitmap;
747 0 : ReadDIB(aBitmap, aMemStrm, false);
748 :
749 0 : XOBitmap aXOBitmap( aBitmap );
750 0 : aXOBitmap.Bitmap2Array();
751 0 : aXOBitmap.SetBitmapType( XBITMAP_8X8 );
752 0 : if( aXOBitmap.GetBackgroundColor().GetColor() == COL_BLACK )
753 0 : ::std::swap( aPattColor, aBackColor );
754 0 : aXOBitmap.SetPixelColor( aPattColor );
755 0 : aXOBitmap.SetBackgroundColor( aBackColor );
756 0 : aXOBitmap.Array2Bitmap();
757 0 : aBitmap = aXOBitmap.GetBitmap();
758 :
759 0 : rSdrObj.SetMergedItem(XFillStyleItem(XFILL_BITMAP));
760 0 : rSdrObj.SetMergedItem(XFillBitmapItem(EMPTY_OUSTRING, Graphic(aBitmap)));
761 : }
762 : }
763 0 : }
764 :
765 0 : void XclImpDrawObjBase::ConvertFrameStyle( SdrObject& rSdrObj, sal_uInt16 nFrameFlags ) const
766 : {
767 0 : if( ::get_flag( nFrameFlags, EXC_OBJ_FRAME_SHADOW ) )
768 : {
769 0 : rSdrObj.SetMergedItem( SdrShadowItem( true ) );
770 0 : rSdrObj.SetMergedItem( SdrShadowXDistItem( 35 ) );
771 0 : rSdrObj.SetMergedItem( SdrShadowYDistItem( 35 ) );
772 0 : rSdrObj.SetMergedItem( SdrShadowColorItem( GetPalette().GetColor( EXC_COLOR_WINDOWTEXT ) ) );
773 : }
774 0 : }
775 :
776 0 : Color XclImpDrawObjBase::GetSolidLineColor( const XclObjLineData& rLineData ) const
777 : {
778 0 : Color aColor( COL_TRANSPARENT );
779 0 : if( rLineData.IsAuto() )
780 : {
781 0 : XclObjLineData aAutoData;
782 0 : aAutoData.mnAuto = 0;
783 0 : aColor = GetSolidLineColor( aAutoData );
784 : }
785 0 : else if( rLineData.mnStyle != EXC_OBJ_LINE_NONE )
786 : {
787 0 : aColor = GetPalette().GetColor( rLineData.mnColorIdx );
788 : }
789 0 : return aColor;
790 : }
791 :
792 0 : Color XclImpDrawObjBase::GetSolidFillColor( const XclObjFillData& rFillData ) const
793 : {
794 0 : Color aColor( COL_TRANSPARENT );
795 0 : if( rFillData.IsAuto() )
796 : {
797 0 : XclObjFillData aAutoData;
798 0 : aAutoData.mnAuto = 0;
799 0 : aColor = GetSolidFillColor( aAutoData );
800 : }
801 0 : else if( rFillData.mnPattern != EXC_PATT_NONE )
802 : {
803 0 : Color aPattColor = GetPalette().GetColor( rFillData.mnPattColorIdx );
804 0 : Color aBackColor = GetPalette().GetColor( rFillData.mnBackColorIdx );
805 0 : aColor = XclTools::GetPatternColor( aPattColor, aBackColor, rFillData.mnPattern );
806 : }
807 0 : return aColor;
808 : }
809 :
810 0 : void XclImpDrawObjBase::DoReadObj3( XclImpStream&, sal_uInt16 )
811 : {
812 0 : }
813 :
814 0 : void XclImpDrawObjBase::DoReadObj4( XclImpStream&, sal_uInt16 )
815 : {
816 0 : }
817 :
818 0 : void XclImpDrawObjBase::DoReadObj5( XclImpStream&, sal_uInt16, sal_uInt16 )
819 : {
820 0 : }
821 :
822 0 : void XclImpDrawObjBase::DoReadObj8SubRec( XclImpStream&, sal_uInt16, sal_uInt16 )
823 : {
824 0 : }
825 :
826 0 : sal_Size XclImpDrawObjBase::DoGetProgressSize() const
827 : {
828 0 : return 1;
829 : }
830 :
831 0 : SdrObject* XclImpDrawObjBase::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& ) const
832 : {
833 0 : rDffConv.Progress( GetProgressSize() );
834 0 : return 0;
835 : }
836 :
837 0 : void XclImpDrawObjBase::DoPreProcessSdrObj( XclImpDffConverter&, SdrObject& ) const
838 : {
839 : // trace if object is not printable
840 0 : if( !IsPrintable() )
841 0 : GetTracer().TraceObjectNotPrintable();
842 0 : }
843 :
844 0 : void XclImpDrawObjBase::DoPostProcessSdrObj( XclImpDffConverter&, SdrObject& ) const
845 : {
846 0 : }
847 :
848 0 : void XclImpDrawObjBase::ImplReadObj3( XclImpStream& rStrm )
849 : {
850 : // back to offset 4 (ignore object count field)
851 0 : rStrm.Seek( 4 );
852 :
853 : sal_uInt16 nObjFlags, nMacroSize;
854 0 : rStrm >> mnObjType >> mnObjId >> nObjFlags >> maAnchor >> nMacroSize;
855 0 : rStrm.Ignore( 2 );
856 :
857 0 : mbHasAnchor = true;
858 0 : mbHidden = ::get_flag( nObjFlags, EXC_OBJ_HIDDEN );
859 0 : mbVisible = ::get_flag( nObjFlags, EXC_OBJ_VISIBLE );
860 0 : DoReadObj3( rStrm, nMacroSize );
861 0 : }
862 :
863 0 : void XclImpDrawObjBase::ImplReadObj4( XclImpStream& rStrm )
864 : {
865 : // back to offset 4 (ignore object count field)
866 0 : rStrm.Seek( 4 );
867 :
868 : sal_uInt16 nObjFlags, nMacroSize;
869 0 : rStrm >> mnObjType >> mnObjId >> nObjFlags >> maAnchor >> nMacroSize;
870 0 : rStrm.Ignore( 2 );
871 :
872 0 : mbHasAnchor = true;
873 0 : mbHidden = ::get_flag( nObjFlags, EXC_OBJ_HIDDEN );
874 0 : mbVisible = ::get_flag( nObjFlags, EXC_OBJ_VISIBLE );
875 0 : mbPrintable = ::get_flag( nObjFlags, EXC_OBJ_PRINTABLE );
876 0 : DoReadObj4( rStrm, nMacroSize );
877 0 : }
878 :
879 0 : void XclImpDrawObjBase::ImplReadObj5( XclImpStream& rStrm )
880 : {
881 : // back to offset 4 (ignore object count field)
882 0 : rStrm.Seek( 4 );
883 :
884 : sal_uInt16 nObjFlags, nMacroSize, nNameLen;
885 0 : rStrm >> mnObjType >> mnObjId >> nObjFlags >> maAnchor >> nMacroSize;
886 0 : rStrm.Ignore( 2 );
887 0 : rStrm >> nNameLen;
888 0 : rStrm.Ignore( 2 );
889 :
890 0 : mbHasAnchor = true;
891 0 : mbHidden = ::get_flag( nObjFlags, EXC_OBJ_HIDDEN );
892 0 : mbVisible = ::get_flag( nObjFlags, EXC_OBJ_VISIBLE );
893 0 : mbPrintable = ::get_flag( nObjFlags, EXC_OBJ_PRINTABLE );
894 0 : DoReadObj5( rStrm, nNameLen, nMacroSize );
895 0 : }
896 :
897 0 : void XclImpDrawObjBase::ImplReadObj8( XclImpStream& rStrm )
898 : {
899 : // back to beginning
900 0 : rStrm.Seek( EXC_REC_SEEK_TO_BEGIN );
901 :
902 0 : bool bLoop = true;
903 0 : while( bLoop && (rStrm.GetRecLeft() >= 4) )
904 : {
905 : sal_uInt16 nSubRecId, nSubRecSize;
906 0 : rStrm >> nSubRecId >> nSubRecSize;
907 0 : rStrm.PushPosition();
908 : // sometimes the last subrecord has an invalid length (OBJLBSDATA) -> min()
909 0 : nSubRecSize = static_cast< sal_uInt16 >( ::std::min< sal_Size >( nSubRecSize, rStrm.GetRecLeft() ) );
910 :
911 0 : switch( nSubRecId )
912 : {
913 : case EXC_ID_OBJCMO:
914 : OSL_ENSURE( rStrm.GetRecPos() == 4, "XclImpDrawObjBase::ImplReadObj8 - unexpected OBJCMO subrecord" );
915 0 : if( (rStrm.GetRecPos() == 4) && (nSubRecSize >= 6) )
916 : {
917 : sal_uInt16 nObjFlags;
918 0 : rStrm >> mnObjType >> mnObjId >> nObjFlags;
919 0 : mbPrintable = ::get_flag( nObjFlags, EXC_OBJCMO_PRINTABLE );
920 : }
921 0 : break;
922 : case EXC_ID_OBJMACRO:
923 0 : ReadMacro8( rStrm );
924 0 : break;
925 : case EXC_ID_OBJEND:
926 0 : bLoop = false;
927 0 : break;
928 : default:
929 0 : DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
930 : }
931 :
932 0 : rStrm.PopPosition();
933 0 : rStrm.Ignore( nSubRecSize );
934 : }
935 :
936 : /* Call DoReadObj8SubRec() with EXC_ID_OBJEND for further stream
937 : processing (e.g. charts), even if the OBJEND subrecord is missing. */
938 0 : DoReadObj8SubRec( rStrm, EXC_ID_OBJEND, 0 );
939 :
940 : /* Pictures that Excel reads from BIFF5 and writes to BIFF8 still have the
941 : IMGDATA record following the OBJ record (but they use the image data
942 : stored in DFF). The IMGDATA record may be continued by several CONTINUE
943 : records. But the last CONTINUE record may be in fact an MSODRAWING
944 : record that contains the DFF data of the next drawing object! So we
945 : have to skip just enough CONTINUE records to look at the next
946 : MSODRAWING/CONTINUE record. */
947 0 : if( (rStrm.GetNextRecId() == EXC_ID3_IMGDATA) && rStrm.StartNextRecord() )
948 : {
949 : sal_uInt32 nDataSize;
950 0 : rStrm.Ignore( 4 );
951 0 : rStrm >> nDataSize;
952 0 : nDataSize -= rStrm.GetRecLeft();
953 : // skip following CONTINUE records until IMGDATA ends
954 0 : while( (nDataSize > 0) && (rStrm.GetNextRecId() == EXC_ID_CONT) && rStrm.StartNextRecord() )
955 : {
956 : OSL_ENSURE( nDataSize >= rStrm.GetRecLeft(), "XclImpDrawObjBase::ImplReadObj8 - CONTINUE too long" );
957 0 : nDataSize -= ::std::min< sal_uInt32 >( rStrm.GetRecLeft(), nDataSize );
958 : }
959 : OSL_ENSURE( nDataSize == 0, "XclImpDrawObjBase::ImplReadObj8 - missing CONTINUE records" );
960 : // next record may be MSODRAWING or CONTINUE or anything else
961 : }
962 0 : }
963 :
964 0 : void XclImpDrawObjVector::InsertGrouped( XclImpDrawObjRef xDrawObj )
965 : {
966 0 : if( !empty() )
967 0 : if( XclImpGroupObj* pGroupObj = dynamic_cast< XclImpGroupObj* >( back().get() ) )
968 0 : if( pGroupObj->TryInsert( xDrawObj ) )
969 0 : return;
970 0 : push_back( xDrawObj );
971 : }
972 :
973 0 : sal_Size XclImpDrawObjVector::GetProgressSize() const
974 : {
975 0 : sal_Size nProgressSize = 0;
976 0 : for( const_iterator aIt = begin(), aEnd = end(); aIt != aEnd; ++aIt )
977 0 : nProgressSize += (*aIt)->GetProgressSize();
978 0 : return nProgressSize;
979 : }
980 :
981 0 : XclImpPhObj::XclImpPhObj( const XclImpRoot& rRoot ) :
982 0 : XclImpDrawObjBase( rRoot )
983 : {
984 0 : SetProcessSdrObj( false );
985 0 : }
986 :
987 0 : XclImpGroupObj::XclImpGroupObj( const XclImpRoot& rRoot ) :
988 : XclImpDrawObjBase( rRoot ),
989 0 : mnFirstUngrouped( 0 )
990 : {
991 0 : }
992 :
993 0 : bool XclImpGroupObj::TryInsert( XclImpDrawObjRef xDrawObj )
994 : {
995 0 : if( xDrawObj->GetObjId() == mnFirstUngrouped )
996 0 : return false;
997 : // insert into own list or into nested group
998 0 : maChildren.InsertGrouped( xDrawObj );
999 0 : return true;
1000 : }
1001 :
1002 0 : void XclImpGroupObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1003 : {
1004 0 : rStrm.Ignore( 4 );
1005 0 : rStrm >> mnFirstUngrouped;
1006 0 : rStrm.Ignore( 16 );
1007 0 : ReadMacro3( rStrm, nMacroSize );
1008 0 : }
1009 :
1010 0 : void XclImpGroupObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1011 : {
1012 0 : rStrm.Ignore( 4 );
1013 0 : rStrm >> mnFirstUngrouped;
1014 0 : rStrm.Ignore( 16 );
1015 0 : ReadMacro4( rStrm, nMacroSize );
1016 0 : }
1017 :
1018 0 : void XclImpGroupObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1019 : {
1020 0 : rStrm.Ignore( 4 );
1021 0 : rStrm >> mnFirstUngrouped;
1022 0 : rStrm.Ignore( 16 );
1023 0 : ReadName5( rStrm, nNameLen );
1024 0 : ReadMacro5( rStrm, nMacroSize );
1025 0 : }
1026 :
1027 0 : sal_Size XclImpGroupObj::DoGetProgressSize() const
1028 : {
1029 0 : return XclImpDrawObjBase::DoGetProgressSize() + maChildren.GetProgressSize();
1030 : }
1031 :
1032 0 : SdrObject* XclImpGroupObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& /*rAnchorRect*/ ) const
1033 : {
1034 0 : TSdrObjectPtr< SdrObjGroup > xSdrObj( new SdrObjGroup );
1035 : // child objects in BIFF2-BIFF5 have absolute size, not needed to pass own anchor rectangle
1036 0 : SdrObjList& rObjList = *xSdrObj->GetSubList(); // SdrObjGroup always returns existing sublist
1037 0 : for( XclImpDrawObjVector::const_iterator aIt = maChildren.begin(), aEnd = maChildren.end(); aIt != aEnd; ++aIt )
1038 0 : rDffConv.ProcessObject( rObjList, **aIt );
1039 0 : rDffConv.Progress();
1040 0 : return xSdrObj.release();
1041 : }
1042 :
1043 0 : XclImpLineObj::XclImpLineObj( const XclImpRoot& rRoot ) :
1044 : XclImpDrawObjBase( rRoot ),
1045 : mnArrows( 0 ),
1046 0 : mnStartPoint( EXC_OBJ_LINE_TL )
1047 : {
1048 0 : SetAreaObj( false );
1049 0 : }
1050 :
1051 0 : void XclImpLineObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1052 : {
1053 0 : rStrm >> maLineData >> mnArrows >> mnStartPoint;
1054 0 : rStrm.Ignore( 1 );
1055 0 : ReadMacro3( rStrm, nMacroSize );
1056 0 : }
1057 :
1058 0 : void XclImpLineObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1059 : {
1060 0 : rStrm >> maLineData >> mnArrows >> mnStartPoint;
1061 0 : rStrm.Ignore( 1 );
1062 0 : ReadMacro4( rStrm, nMacroSize );
1063 0 : }
1064 :
1065 0 : void XclImpLineObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1066 : {
1067 0 : rStrm >> maLineData >> mnArrows >> mnStartPoint;
1068 0 : rStrm.Ignore( 1 );
1069 0 : ReadName5( rStrm, nNameLen );
1070 0 : ReadMacro5( rStrm, nMacroSize );
1071 0 : }
1072 :
1073 0 : SdrObject* XclImpLineObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1074 : {
1075 0 : ::basegfx::B2DPolygon aB2DPolygon;
1076 0 : switch( mnStartPoint )
1077 : {
1078 : default:
1079 : case EXC_OBJ_LINE_TL:
1080 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Left(), rAnchorRect.Top() ) );
1081 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Right(), rAnchorRect.Bottom() ) );
1082 0 : break;
1083 : case EXC_OBJ_LINE_TR:
1084 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Right(), rAnchorRect.Top() ) );
1085 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Left(), rAnchorRect.Bottom() ) );
1086 0 : break;
1087 : case EXC_OBJ_LINE_BR:
1088 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Right(), rAnchorRect.Bottom() ) );
1089 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Left(), rAnchorRect.Top() ) );
1090 0 : break;
1091 : case EXC_OBJ_LINE_BL:
1092 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Left(), rAnchorRect.Bottom() ) );
1093 0 : aB2DPolygon.append( ::basegfx::B2DPoint( rAnchorRect.Right(), rAnchorRect.Top() ) );
1094 0 : break;
1095 : }
1096 0 : SdrObjectPtr xSdrObj( new SdrPathObj( OBJ_LINE, ::basegfx::B2DPolyPolygon( aB2DPolygon ) ) );
1097 0 : ConvertLineStyle( *xSdrObj, maLineData );
1098 :
1099 : // line ends
1100 0 : sal_uInt8 nArrowType = ::extract_value< sal_uInt8 >( mnArrows, 0, 4 );
1101 0 : bool bLineStart = false;
1102 0 : bool bLineEnd = false;
1103 0 : bool bFilled = false;
1104 0 : switch( nArrowType )
1105 : {
1106 0 : case EXC_OBJ_ARROW_OPEN: bLineStart = false; bLineEnd = true; bFilled = false; break;
1107 0 : case EXC_OBJ_ARROW_OPENBOTH: bLineStart = true; bLineEnd = true; bFilled = false; break;
1108 0 : case EXC_OBJ_ARROW_FILLED: bLineStart = false; bLineEnd = true; bFilled = true; break;
1109 0 : case EXC_OBJ_ARROW_FILLEDBOTH: bLineStart = true; bLineEnd = true; bFilled = true; break;
1110 : }
1111 0 : if( bLineStart || bLineEnd )
1112 : {
1113 0 : sal_uInt8 nArrowWidth = ::extract_value< sal_uInt8 >( mnArrows, 4, 4 );
1114 0 : double fArrowWidth = 3.0;
1115 0 : switch( nArrowWidth )
1116 : {
1117 0 : case EXC_OBJ_ARROW_NARROW: fArrowWidth = 2.0; break;
1118 0 : case EXC_OBJ_ARROW_MEDIUM: fArrowWidth = 3.0; break;
1119 0 : case EXC_OBJ_ARROW_WIDE: fArrowWidth = 5.0; break;
1120 : }
1121 :
1122 0 : sal_uInt8 nArrowLength = ::extract_value< sal_uInt8 >( mnArrows, 8, 4 );
1123 0 : double fArrowLength = 3.0;
1124 0 : switch( nArrowLength )
1125 : {
1126 0 : case EXC_OBJ_ARROW_NARROW: fArrowLength = 2.5; break;
1127 0 : case EXC_OBJ_ARROW_MEDIUM: fArrowLength = 3.5; break;
1128 0 : case EXC_OBJ_ARROW_WIDE: fArrowLength = 6.0; break;
1129 : }
1130 :
1131 0 : ::basegfx::B2DPolygon aArrowPoly;
1132 : #define EXC_ARROW_POINT( x, y ) ::basegfx::B2DPoint( fArrowWidth * (x), fArrowLength * (y) )
1133 0 : if( bFilled )
1134 : {
1135 0 : aArrowPoly.append( EXC_ARROW_POINT( 0, 100 ) );
1136 0 : aArrowPoly.append( EXC_ARROW_POINT( 50, 0 ) );
1137 0 : aArrowPoly.append( EXC_ARROW_POINT( 100, 100 ) );
1138 : }
1139 : else
1140 : {
1141 0 : sal_uInt8 nLineWidth = ::limit_cast< sal_uInt8 >( maLineData.mnWidth, EXC_OBJ_LINE_THIN, EXC_OBJ_LINE_THICK );
1142 0 : aArrowPoly.append( EXC_ARROW_POINT( 50, 0 ) );
1143 0 : aArrowPoly.append( EXC_ARROW_POINT( 100, 100 - 3 * nLineWidth ) );
1144 0 : aArrowPoly.append( EXC_ARROW_POINT( 100 - 5 * nLineWidth, 100 ) );
1145 0 : aArrowPoly.append( EXC_ARROW_POINT( 50, 12 * nLineWidth ) );
1146 0 : aArrowPoly.append( EXC_ARROW_POINT( 5 * nLineWidth, 100 ) );
1147 0 : aArrowPoly.append( EXC_ARROW_POINT( 0, 100 - 3 * nLineWidth ) );
1148 : }
1149 : #undef EXC_ARROW_POINT
1150 :
1151 0 : ::basegfx::B2DPolyPolygon aArrowPolyPoly( aArrowPoly );
1152 0 : long nWidth = static_cast< long >( 125 * fArrowWidth );
1153 0 : if( bLineStart )
1154 : {
1155 0 : xSdrObj->SetMergedItem( XLineStartItem( EMPTY_OUSTRING, aArrowPolyPoly ) );
1156 0 : xSdrObj->SetMergedItem( XLineStartWidthItem( nWidth ) );
1157 0 : xSdrObj->SetMergedItem( XLineStartCenterItem( false ) );
1158 : }
1159 0 : if( bLineEnd )
1160 : {
1161 0 : xSdrObj->SetMergedItem( XLineEndItem( EMPTY_OUSTRING, aArrowPolyPoly ) );
1162 0 : xSdrObj->SetMergedItem( XLineEndWidthItem( nWidth ) );
1163 0 : xSdrObj->SetMergedItem( XLineEndCenterItem( false ) );
1164 0 : }
1165 : }
1166 0 : rDffConv.Progress();
1167 0 : return xSdrObj.release();
1168 : }
1169 :
1170 0 : XclImpRectObj::XclImpRectObj( const XclImpRoot& rRoot ) :
1171 : XclImpDrawObjBase( rRoot ),
1172 0 : mnFrameFlags( 0 )
1173 : {
1174 0 : SetAreaObj( true );
1175 0 : }
1176 :
1177 0 : void XclImpRectObj::ReadFrameData( XclImpStream& rStrm )
1178 : {
1179 0 : rStrm >> maFillData >> maLineData >> mnFrameFlags;
1180 0 : }
1181 :
1182 0 : void XclImpRectObj::ConvertRectStyle( SdrObject& rSdrObj ) const
1183 : {
1184 0 : ConvertLineStyle( rSdrObj, maLineData );
1185 0 : ConvertFillStyle( rSdrObj, maFillData );
1186 0 : ConvertFrameStyle( rSdrObj, mnFrameFlags );
1187 0 : }
1188 :
1189 0 : void XclImpRectObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1190 : {
1191 0 : ReadFrameData( rStrm );
1192 0 : ReadMacro3( rStrm, nMacroSize );
1193 0 : }
1194 :
1195 0 : void XclImpRectObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1196 : {
1197 0 : ReadFrameData( rStrm );
1198 0 : ReadMacro4( rStrm, nMacroSize );
1199 0 : }
1200 :
1201 0 : void XclImpRectObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1202 : {
1203 0 : ReadFrameData( rStrm );
1204 0 : ReadName5( rStrm, nNameLen );
1205 0 : ReadMacro5( rStrm, nMacroSize );
1206 0 : }
1207 :
1208 0 : SdrObject* XclImpRectObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1209 : {
1210 0 : SdrObjectPtr xSdrObj( new SdrRectObj( rAnchorRect ) );
1211 0 : ConvertRectStyle( *xSdrObj );
1212 0 : rDffConv.Progress();
1213 0 : return xSdrObj.release();
1214 : }
1215 :
1216 0 : XclImpOvalObj::XclImpOvalObj( const XclImpRoot& rRoot ) :
1217 0 : XclImpRectObj( rRoot )
1218 : {
1219 0 : }
1220 :
1221 0 : SdrObject* XclImpOvalObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1222 : {
1223 0 : SdrObjectPtr xSdrObj( new SdrCircObj( OBJ_CIRC, rAnchorRect ) );
1224 0 : ConvertRectStyle( *xSdrObj );
1225 0 : rDffConv.Progress();
1226 0 : return xSdrObj.release();
1227 : }
1228 :
1229 0 : XclImpArcObj::XclImpArcObj( const XclImpRoot& rRoot ) :
1230 : XclImpDrawObjBase( rRoot ),
1231 0 : mnQuadrant( EXC_OBJ_ARC_TR )
1232 : {
1233 0 : SetAreaObj( false ); // arc may be 2-dimensional
1234 0 : }
1235 :
1236 0 : void XclImpArcObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1237 : {
1238 0 : rStrm >> maFillData >> maLineData >> mnQuadrant;
1239 0 : rStrm.Ignore( 1 );
1240 0 : ReadMacro3( rStrm, nMacroSize );
1241 0 : }
1242 :
1243 0 : void XclImpArcObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1244 : {
1245 0 : rStrm >> maFillData >> maLineData >> mnQuadrant;
1246 0 : rStrm.Ignore( 1 );
1247 0 : ReadMacro4( rStrm, nMacroSize );
1248 0 : }
1249 :
1250 0 : void XclImpArcObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1251 : {
1252 0 : rStrm >> maFillData >> maLineData >> mnQuadrant;
1253 0 : rStrm.Ignore( 1 );
1254 0 : ReadName5( rStrm, nNameLen );
1255 0 : ReadMacro5( rStrm, nMacroSize );
1256 0 : }
1257 :
1258 0 : SdrObject* XclImpArcObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1259 : {
1260 0 : Rectangle aNewRect = rAnchorRect;
1261 0 : long nStartAngle = 0;
1262 0 : long nEndAngle = 0;
1263 0 : switch( mnQuadrant )
1264 : {
1265 : default:
1266 : case EXC_OBJ_ARC_TR:
1267 0 : nStartAngle = 0;
1268 0 : nEndAngle = 9000;
1269 0 : aNewRect.Left() -= rAnchorRect.GetWidth();
1270 0 : aNewRect.Bottom() += rAnchorRect.GetHeight();
1271 0 : break;
1272 : case EXC_OBJ_ARC_TL:
1273 0 : nStartAngle = 9000;
1274 0 : nEndAngle = 18000;
1275 0 : aNewRect.Right() += rAnchorRect.GetWidth();
1276 0 : aNewRect.Bottom() += rAnchorRect.GetHeight();
1277 0 : break;
1278 : case EXC_OBJ_ARC_BL:
1279 0 : nStartAngle = 18000;
1280 0 : nEndAngle = 27000;
1281 0 : aNewRect.Right() += rAnchorRect.GetWidth();
1282 0 : aNewRect.Top() -= rAnchorRect.GetHeight();
1283 0 : break;
1284 : case EXC_OBJ_ARC_BR:
1285 0 : nStartAngle = 27000;
1286 0 : nEndAngle = 0;
1287 0 : aNewRect.Left() -= rAnchorRect.GetWidth();
1288 0 : aNewRect.Top() -= rAnchorRect.GetHeight();
1289 0 : break;
1290 : }
1291 0 : SdrObjKind eObjKind = maFillData.IsFilled() ? OBJ_SECT : OBJ_CARC;
1292 0 : SdrObjectPtr xSdrObj( new SdrCircObj( eObjKind, aNewRect, nStartAngle, nEndAngle ) );
1293 0 : ConvertFillStyle( *xSdrObj, maFillData );
1294 0 : ConvertLineStyle( *xSdrObj, maLineData );
1295 0 : rDffConv.Progress();
1296 0 : return xSdrObj.release();
1297 : }
1298 :
1299 0 : XclImpPolygonObj::XclImpPolygonObj( const XclImpRoot& rRoot ) :
1300 : XclImpRectObj( rRoot ),
1301 : mnPolyFlags( 0 ),
1302 0 : mnPointCount( 0 )
1303 : {
1304 0 : SetAreaObj( false ); // polygon may be 2-dimensional
1305 0 : }
1306 :
1307 0 : void XclImpPolygonObj::ReadCoordList( XclImpStream& rStrm )
1308 : {
1309 0 : if( (rStrm.GetNextRecId() == EXC_ID_COORDLIST) && rStrm.StartNextRecord() )
1310 : {
1311 : OSL_ENSURE( rStrm.GetRecLeft() / 4 == mnPointCount, "XclImpPolygonObj::ReadCoordList - wrong polygon point count" );
1312 0 : while( rStrm.GetRecLeft() >= 4 )
1313 : {
1314 : sal_uInt16 nX, nY;
1315 0 : rStrm >> nX >> nY;
1316 0 : maCoords.push_back( Point( nX, nY ) );
1317 : }
1318 : }
1319 0 : }
1320 :
1321 0 : void XclImpPolygonObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1322 : {
1323 0 : ReadFrameData( rStrm );
1324 0 : rStrm >> mnPolyFlags;
1325 0 : rStrm.Ignore( 10 );
1326 0 : rStrm >> mnPointCount;
1327 0 : rStrm.Ignore( 8 );
1328 0 : ReadMacro4( rStrm, nMacroSize );
1329 0 : ReadCoordList( rStrm );
1330 0 : }
1331 :
1332 0 : void XclImpPolygonObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1333 : {
1334 0 : ReadFrameData( rStrm );
1335 0 : rStrm >> mnPolyFlags;
1336 0 : rStrm.Ignore( 10 );
1337 0 : rStrm >> mnPointCount;
1338 0 : rStrm.Ignore( 8 );
1339 0 : ReadName5( rStrm, nNameLen );
1340 0 : ReadMacro5( rStrm, nMacroSize );
1341 0 : ReadCoordList( rStrm );
1342 0 : }
1343 :
1344 : namespace {
1345 :
1346 0 : ::basegfx::B2DPoint lclGetPolyPoint( const Rectangle& rAnchorRect, const Point& rPoint )
1347 : {
1348 : return ::basegfx::B2DPoint(
1349 0 : rAnchorRect.Left() + static_cast< sal_Int32 >( ::std::min< double >( rPoint.X(), 16384.0 ) / 16384.0 * rAnchorRect.GetWidth() + 0.5 ),
1350 0 : rAnchorRect.Top() + static_cast< sal_Int32 >( ::std::min< double >( rPoint.Y(), 16384.0 ) / 16384.0 * rAnchorRect.GetHeight() + 0.5 ) );
1351 : }
1352 :
1353 : } // namespace
1354 :
1355 0 : SdrObject* XclImpPolygonObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1356 : {
1357 0 : SdrObjectPtr xSdrObj;
1358 0 : if( maCoords.size() >= 2 )
1359 : {
1360 : // create the polygon
1361 0 : ::basegfx::B2DPolygon aB2DPolygon;
1362 0 : for( PointVector::const_iterator aIt = maCoords.begin(), aEnd = maCoords.end(); aIt != aEnd; ++aIt )
1363 0 : aB2DPolygon.append( lclGetPolyPoint( rAnchorRect, *aIt ) );
1364 : // close polygon if specified
1365 0 : if( ::get_flag( mnPolyFlags, EXC_OBJ_POLY_CLOSED ) && (maCoords.front() != maCoords.back()) )
1366 0 : aB2DPolygon.append( lclGetPolyPoint( rAnchorRect, maCoords.front() ) );
1367 : // create the SdrObject
1368 0 : SdrObjKind eObjKind = maFillData.IsFilled() ? OBJ_PATHPOLY : OBJ_PATHPLIN;
1369 0 : xSdrObj.reset( new SdrPathObj( eObjKind, ::basegfx::B2DPolyPolygon( aB2DPolygon ) ) );
1370 0 : ConvertRectStyle( *xSdrObj );
1371 : }
1372 0 : rDffConv.Progress();
1373 0 : return xSdrObj.release();
1374 : }
1375 :
1376 0 : void XclImpObjTextData::ReadByteString( XclImpStream& rStrm )
1377 : {
1378 0 : mxString.reset();
1379 0 : if( maData.mnTextLen > 0 )
1380 : {
1381 0 : mxString.reset( new XclImpString( rStrm.ReadRawByteString( maData.mnTextLen ) ) );
1382 : // skip padding byte for word boundaries
1383 0 : if( rStrm.GetRecPos() & 1 ) rStrm.Ignore( 1 );
1384 : }
1385 0 : }
1386 :
1387 0 : void XclImpObjTextData::ReadFormats( XclImpStream& rStrm )
1388 : {
1389 0 : if( mxString )
1390 0 : mxString->ReadObjFormats( rStrm, maData.mnFormatSize );
1391 : else
1392 0 : rStrm.Ignore( maData.mnFormatSize );
1393 0 : }
1394 :
1395 0 : XclImpTextObj::XclImpTextObj( const XclImpRoot& rRoot ) :
1396 0 : XclImpRectObj( rRoot )
1397 : {
1398 0 : }
1399 :
1400 0 : void XclImpTextObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1401 : {
1402 0 : ReadFrameData( rStrm );
1403 0 : maTextData.maData.ReadObj3( rStrm );
1404 0 : ReadMacro3( rStrm, nMacroSize );
1405 0 : maTextData.ReadByteString( rStrm );
1406 0 : maTextData.ReadFormats( rStrm );
1407 0 : }
1408 :
1409 0 : void XclImpTextObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1410 : {
1411 0 : ReadFrameData( rStrm );
1412 0 : maTextData.maData.ReadObj3( rStrm );
1413 0 : ReadMacro4( rStrm, nMacroSize );
1414 0 : maTextData.ReadByteString( rStrm );
1415 0 : maTextData.ReadFormats( rStrm );
1416 0 : }
1417 :
1418 0 : void XclImpTextObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1419 : {
1420 0 : ReadFrameData( rStrm );
1421 0 : maTextData.maData.ReadObj5( rStrm );
1422 0 : ReadName5( rStrm, nNameLen );
1423 0 : ReadMacro5( rStrm, nMacroSize );
1424 0 : maTextData.ReadByteString( rStrm );
1425 0 : rStrm.Ignore( maTextData.maData.mnLinkSize ); // ignore text link formula
1426 0 : maTextData.ReadFormats( rStrm );
1427 0 : }
1428 :
1429 0 : SdrObject* XclImpTextObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1430 : {
1431 0 : TSdrObjectPtr< SdrObjCustomShape > xSdrObj( new SdrObjCustomShape );
1432 0 : xSdrObj->NbcSetSnapRect( rAnchorRect );
1433 0 : OUString aRectType = "rectangle";
1434 0 : xSdrObj->MergeDefaultAttributes( &aRectType );
1435 0 : ConvertRectStyle( *xSdrObj );
1436 0 : sal_Bool bAutoSize = ::get_flag( maTextData.maData.mnFlags, EXC_OBJ_TEXT_AUTOSIZE );
1437 0 : xSdrObj->SetMergedItem( SdrTextAutoGrowWidthItem( bAutoSize ) );
1438 0 : xSdrObj->SetMergedItem( SdrTextAutoGrowHeightItem( bAutoSize ) );
1439 0 : xSdrObj->SetMergedItem( SdrTextWordWrapItem( true ) );
1440 0 : rDffConv.Progress();
1441 0 : return xSdrObj.release();
1442 : }
1443 :
1444 0 : void XclImpTextObj::DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
1445 : {
1446 : // set text data
1447 0 : if( SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( &rSdrObj ) )
1448 : {
1449 0 : if( maTextData.mxString )
1450 : {
1451 0 : if( maTextData.mxString->IsRich() )
1452 : {
1453 : // rich text
1454 : boost::scoped_ptr< EditTextObject > xEditObj(
1455 0 : XclImpStringHelper::CreateTextObject( GetRoot(), *maTextData.mxString ) );
1456 0 : OutlinerParaObject* pOutlineObj = new OutlinerParaObject( *xEditObj );
1457 0 : pOutlineObj->SetOutlinerMode( OUTLINERMODE_TEXTOBJECT );
1458 : // text object takes ownership of the outliner object
1459 0 : pTextObj->NbcSetOutlinerParaObject( pOutlineObj );
1460 : }
1461 : else
1462 : {
1463 : // plain text
1464 0 : pTextObj->NbcSetText( maTextData.mxString->GetText() );
1465 : }
1466 :
1467 : /* #i96858# Do not apply any formatting if there is no text.
1468 : SdrObjCustomShape::SetVerticalWriting (initiated from
1469 : SetMergedItem) calls SdrTextObj::ForceOutlinerParaObject which
1470 : ensures that we can erroneously write a ClientTextbox record
1471 : (with no content) while exporting to XLS, which can cause a
1472 : corrupted exported document. */
1473 :
1474 0 : SvxAdjust eHorAlign = SVX_ADJUST_LEFT;
1475 0 : SdrTextVertAdjust eVerAlign = SDRTEXTVERTADJUST_TOP;
1476 :
1477 : // orientation (this is only a fake, drawing does not support real text orientation)
1478 : namespace csst = ::com::sun::star::text;
1479 0 : csst::WritingMode eWriteMode = csst::WritingMode_LR_TB;
1480 0 : switch( maTextData.maData.mnOrient )
1481 : {
1482 : default:
1483 : case EXC_OBJ_ORIENT_NONE:
1484 : {
1485 0 : eWriteMode = csst::WritingMode_LR_TB;
1486 0 : switch( maTextData.maData.GetHorAlign() )
1487 : {
1488 0 : case EXC_OBJ_HOR_LEFT: eHorAlign = SVX_ADJUST_LEFT; break;
1489 0 : case EXC_OBJ_HOR_CENTER: eHorAlign = SVX_ADJUST_CENTER; break;
1490 0 : case EXC_OBJ_HOR_RIGHT: eHorAlign = SVX_ADJUST_RIGHT; break;
1491 0 : case EXC_OBJ_HOR_JUSTIFY: eHorAlign = SVX_ADJUST_BLOCK; break;
1492 : }
1493 0 : switch( maTextData.maData.GetVerAlign() )
1494 : {
1495 0 : case EXC_OBJ_VER_TOP: eVerAlign = SDRTEXTVERTADJUST_TOP; break;
1496 0 : case EXC_OBJ_VER_CENTER: eVerAlign = SDRTEXTVERTADJUST_CENTER; break;
1497 0 : case EXC_OBJ_VER_BOTTOM: eVerAlign = SDRTEXTVERTADJUST_BOTTOM; break;
1498 0 : case EXC_OBJ_VER_JUSTIFY: eVerAlign = SDRTEXTVERTADJUST_BLOCK; break;
1499 : }
1500 : }
1501 0 : break;
1502 :
1503 : case EXC_OBJ_ORIENT_90CCW:
1504 : {
1505 0 : if( SdrObjCustomShape* pObjCustomShape = dynamic_cast< SdrObjCustomShape* >( &rSdrObj ) )
1506 : {
1507 0 : double fAngle = 180.0;
1508 0 : com::sun::star::beans::PropertyValue aTextRotateAngle;
1509 0 : aTextRotateAngle.Name = "TextRotateAngle";
1510 0 : aTextRotateAngle.Value <<= fAngle;
1511 0 : SdrCustomShapeGeometryItem aGeometryItem((SdrCustomShapeGeometryItem&)pObjCustomShape->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ));
1512 0 : aGeometryItem.SetPropertyValue( aTextRotateAngle );
1513 0 : pObjCustomShape->SetMergedItem( aGeometryItem );
1514 : }
1515 0 : eWriteMode = csst::WritingMode_TB_RL;
1516 0 : switch( maTextData.maData.GetHorAlign() )
1517 : {
1518 0 : case EXC_OBJ_HOR_LEFT: eVerAlign = SDRTEXTVERTADJUST_TOP; break;
1519 0 : case EXC_OBJ_HOR_CENTER: eVerAlign = SDRTEXTVERTADJUST_CENTER; break;
1520 0 : case EXC_OBJ_HOR_RIGHT: eVerAlign = SDRTEXTVERTADJUST_BOTTOM; break;
1521 0 : case EXC_OBJ_HOR_JUSTIFY: eVerAlign = SDRTEXTVERTADJUST_BLOCK; break;
1522 : }
1523 0 : MSO_Anchor eTextAnchor = (MSO_Anchor)rDffConv.GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
1524 0 : switch( eTextAnchor )
1525 : {
1526 : case mso_anchorTopCentered :
1527 : case mso_anchorMiddleCentered :
1528 : case mso_anchorBottomCentered :
1529 : {
1530 0 : eHorAlign = SVX_ADJUST_CENTER;
1531 : }
1532 0 : break;
1533 :
1534 : default:
1535 : {
1536 0 : switch( maTextData.maData.GetVerAlign() )
1537 : {
1538 0 : case EXC_OBJ_VER_TOP: eHorAlign = SVX_ADJUST_RIGHT; break;
1539 0 : case EXC_OBJ_VER_CENTER: eHorAlign = SVX_ADJUST_CENTER; break;
1540 0 : case EXC_OBJ_VER_BOTTOM: eHorAlign = SVX_ADJUST_LEFT; break;
1541 0 : case EXC_OBJ_VER_JUSTIFY: eHorAlign = SVX_ADJUST_BLOCK; break;
1542 : }
1543 : }
1544 : }
1545 : }
1546 0 : break;
1547 :
1548 : case EXC_OBJ_ORIENT_STACKED: // PASSTHROUGH INTENDED
1549 : {
1550 : // sj: STACKED is not supported, maybe it can be optimized here a bit
1551 : }
1552 : case EXC_OBJ_ORIENT_90CW:
1553 : {
1554 0 : eWriteMode = csst::WritingMode_TB_RL;
1555 0 : switch( maTextData.maData.GetHorAlign() )
1556 : {
1557 0 : case EXC_OBJ_HOR_LEFT: eVerAlign = SDRTEXTVERTADJUST_BOTTOM; break;
1558 0 : case EXC_OBJ_HOR_CENTER: eVerAlign = SDRTEXTVERTADJUST_CENTER; break;
1559 0 : case EXC_OBJ_HOR_RIGHT: eVerAlign = SDRTEXTVERTADJUST_TOP; break;
1560 0 : case EXC_OBJ_HOR_JUSTIFY: eVerAlign = SDRTEXTVERTADJUST_BLOCK; break;
1561 : }
1562 0 : MSO_Anchor eTextAnchor = (MSO_Anchor)rDffConv.GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
1563 0 : switch ( eTextAnchor )
1564 : {
1565 : case mso_anchorTopCentered :
1566 : case mso_anchorMiddleCentered :
1567 : case mso_anchorBottomCentered :
1568 : {
1569 0 : eHorAlign = SVX_ADJUST_CENTER;
1570 : }
1571 0 : break;
1572 :
1573 : default:
1574 : {
1575 0 : switch( maTextData.maData.GetVerAlign() )
1576 : {
1577 0 : case EXC_OBJ_VER_TOP: eHorAlign = SVX_ADJUST_LEFT; break;
1578 0 : case EXC_OBJ_VER_CENTER: eHorAlign = SVX_ADJUST_CENTER; break;
1579 0 : case EXC_OBJ_VER_BOTTOM: eHorAlign = SVX_ADJUST_RIGHT; break;
1580 0 : case EXC_OBJ_VER_JUSTIFY: eHorAlign = SVX_ADJUST_BLOCK; break;
1581 : }
1582 : }
1583 : }
1584 : }
1585 0 : break;
1586 : }
1587 0 : rSdrObj.SetMergedItem( SvxAdjustItem( eHorAlign, EE_PARA_JUST ) );
1588 0 : rSdrObj.SetMergedItem( SdrTextVertAdjustItem( eVerAlign ) );
1589 0 : rSdrObj.SetMergedItem( SvxWritingModeItem( eWriteMode, SDRATTR_TEXTDIRECTION ) );
1590 : }
1591 : }
1592 : // base class processing
1593 0 : XclImpRectObj::DoPreProcessSdrObj( rDffConv, rSdrObj );
1594 0 : }
1595 :
1596 0 : XclImpChartObj::XclImpChartObj( const XclImpRoot& rRoot, bool bOwnTab ) :
1597 : XclImpRectObj( rRoot ),
1598 0 : mbOwnTab( bOwnTab )
1599 : {
1600 0 : SetSimpleMacro( false );
1601 0 : SetCustomDffObj( true );
1602 0 : }
1603 :
1604 0 : void XclImpChartObj::ReadChartSubStream( XclImpStream& rStrm )
1605 : {
1606 : /* If chart is read from a chartsheet (mbOwnTab == true), the BOF record
1607 : has already been read. If chart is embedded as object, the next record
1608 : has to be the BOF record. */
1609 0 : if( mbOwnTab )
1610 : {
1611 : /* #i109800# The input stream may point somewhere inside the chart
1612 : substream and not exactly to the leading BOF record. To read this
1613 : record correctly in the following, the stream has to rewind it, so
1614 : that the next call to StartNextRecord() will find it correctly. */
1615 0 : if( rStrm.GetRecId() != EXC_ID5_BOF )
1616 0 : rStrm.RewindRecord();
1617 : }
1618 : else
1619 : {
1620 0 : if( (rStrm.GetNextRecId() == EXC_ID5_BOF) && rStrm.StartNextRecord() )
1621 : {
1622 : sal_uInt16 nBofType;
1623 0 : rStrm.Seek( 2 );
1624 0 : rStrm >> nBofType;
1625 : DBG_ASSERT( nBofType == EXC_BOF_CHART, "XclImpChartObj::ReadChartSubStream - no chart BOF record" );
1626 : }
1627 : else
1628 : {
1629 : DBG_ERRORFILE( "XclImpChartObj::ReadChartSubStream - missing chart substream" );
1630 0 : return;
1631 : }
1632 : }
1633 :
1634 : // read chart, even if BOF record contains wrong substream identifier
1635 0 : mxChart.reset( new XclImpChart( GetRoot(), mbOwnTab ) );
1636 0 : mxChart->ReadChartSubStream( rStrm );
1637 0 : if( mbOwnTab )
1638 0 : FinalizeTabChart();
1639 : }
1640 :
1641 0 : void XclImpChartObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1642 : {
1643 : // read OBJ record and the following chart substream
1644 0 : ReadFrameData( rStrm );
1645 0 : rStrm.Ignore( 18 );
1646 0 : ReadMacro3( rStrm, nMacroSize );
1647 : // set frame format from OBJ record, it is used if chart itself is transparent
1648 0 : if( mxChart )
1649 0 : mxChart->UpdateObjFrame( maLineData, maFillData );
1650 0 : }
1651 :
1652 0 : void XclImpChartObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
1653 : {
1654 : // read OBJ record and the following chart substream
1655 0 : ReadFrameData( rStrm );
1656 0 : rStrm.Ignore( 18 );
1657 0 : ReadMacro4( rStrm, nMacroSize );
1658 : // set frame format from OBJ record, it is used if chart itself is transparent
1659 0 : if( mxChart )
1660 0 : mxChart->UpdateObjFrame( maLineData, maFillData );
1661 0 : }
1662 :
1663 0 : void XclImpChartObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
1664 : {
1665 : // read OBJ record and the following chart substream
1666 0 : ReadFrameData( rStrm );
1667 0 : rStrm.Ignore( 18 );
1668 0 : ReadName5( rStrm, nNameLen );
1669 0 : ReadMacro5( rStrm, nMacroSize );
1670 0 : ReadChartSubStream( rStrm );
1671 : // set frame format from OBJ record, it is used if chart itself is transparent
1672 0 : if( mxChart )
1673 0 : mxChart->UpdateObjFrame( maLineData, maFillData );
1674 0 : }
1675 :
1676 0 : void XclImpChartObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 /*nSubRecSize*/ )
1677 : {
1678 : // read the following chart substream
1679 0 : if( nSubRecId == EXC_ID_OBJEND )
1680 : {
1681 : // enable CONTINUE handling for the entire chart substream
1682 0 : rStrm.ResetRecord( true );
1683 0 : ReadChartSubStream( rStrm );
1684 : /* disable CONTINUE handling again to be able to read
1685 : following CONTINUE records as MSODRAWING records. */
1686 0 : rStrm.ResetRecord( false );
1687 : }
1688 0 : }
1689 :
1690 0 : sal_Size XclImpChartObj::DoGetProgressSize() const
1691 : {
1692 0 : return mxChart ? mxChart->GetProgressSize() : 1;
1693 : }
1694 :
1695 0 : SdrObject* XclImpChartObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
1696 : {
1697 0 : SdrObjectPtr xSdrObj;
1698 0 : SfxObjectShell* pDocShell = GetDocShell();
1699 0 : if( rDffConv.SupportsOleObjects() && SvtModuleOptions().IsChart() && pDocShell && mxChart && !mxChart->IsPivotChart() )
1700 : {
1701 : // create embedded chart object
1702 0 : OUString aEmbObjName;
1703 0 : Reference< XEmbeddedObject > xEmbObj = pDocShell->GetEmbeddedObjectContainer().
1704 0 : CreateEmbeddedObject( SvGlobalName( SO3_SCH_CLASSID ).GetByteSequence(), aEmbObjName );
1705 :
1706 : /* Set the size to the embedded object, this prevents that font sizes
1707 : of text objects are changed in the chart when the object is
1708 : inserted into the draw page. */
1709 0 : sal_Int64 nAspect = ::com::sun::star::embed::Aspects::MSOLE_CONTENT;
1710 0 : MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xEmbObj->getMapUnit( nAspect ) );
1711 0 : Size aSize( Window::LogicToLogic( rAnchorRect.GetSize(), MapMode( MAP_100TH_MM ), MapMode( aUnit ) ) );
1712 0 : ::com::sun::star::awt::Size aAwtSize( aSize.Width(), aSize.Height() );
1713 0 : xEmbObj->setVisualAreaSize( nAspect, aAwtSize );
1714 :
1715 : // #i121334# This call will change the chart's default background fill from white to transparent.
1716 : // Add here again if this is wanted (see task description for details)
1717 : // ChartHelper::AdaptDefaultsForChart( xEmbObj );
1718 :
1719 : // create the container OLE object
1720 0 : xSdrObj.reset( new SdrOle2Obj( svt::EmbeddedObjectRef( xEmbObj, nAspect ), aEmbObjName, rAnchorRect ) );
1721 : }
1722 :
1723 0 : return xSdrObj.release();
1724 : }
1725 :
1726 0 : void XclImpChartObj::DoPostProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
1727 : {
1728 0 : const SdrOle2Obj* pSdrOleObj = dynamic_cast< const SdrOle2Obj* >( &rSdrObj );
1729 0 : if( mxChart && pSdrOleObj )
1730 : {
1731 0 : Reference< XEmbeddedObject > xEmbObj = pSdrOleObj->GetObjRef();
1732 0 : if( xEmbObj.is() && ::svt::EmbeddedObjectRef::TryRunningState( xEmbObj ) ) try
1733 : {
1734 0 : Reference< XEmbedPersist > xPersist( xEmbObj, UNO_QUERY_THROW );
1735 0 : Reference< XModel > xModel( xEmbObj->getComponent(), UNO_QUERY_THROW );
1736 0 : mxChart->Convert( xModel, rDffConv, xPersist->getEntryName(), rSdrObj.GetLogicRect() );
1737 : }
1738 0 : catch( const Exception& )
1739 : {
1740 0 : }
1741 : }
1742 0 : }
1743 :
1744 0 : void XclImpChartObj::FinalizeTabChart()
1745 : {
1746 : /* #i44077# Calculate and store DFF anchor for sheet charts.
1747 : Needed to get used area if this chart is inserted as OLE object. */
1748 : OSL_ENSURE( mbOwnTab, "XclImpChartObj::FinalizeTabChart - not allowed for embedded chart objects" );
1749 :
1750 : // set uninitialized page to landscape
1751 0 : if( !GetPageSettings().GetPageData().mbValid )
1752 0 : GetPageSettings().SetPaperSize( EXC_PAPERSIZE_DEFAULT, false );
1753 :
1754 : // calculate size of the chart object
1755 0 : const XclPageData& rPageData = GetPageSettings().GetPageData();
1756 0 : Size aPaperSize = rPageData.GetScPaperSize();
1757 :
1758 0 : long nWidth = XclTools::GetHmmFromTwips( aPaperSize.Width() );
1759 0 : long nHeight = XclTools::GetHmmFromTwips( aPaperSize.Height() );
1760 :
1761 : // subtract page margins, give some more extra space
1762 0 : nWidth -= (XclTools::GetHmmFromInch( rPageData.mfLeftMargin + rPageData.mfRightMargin ) + 2000);
1763 0 : nHeight -= (XclTools::GetHmmFromInch( rPageData.mfTopMargin + rPageData.mfBottomMargin ) + 1000);
1764 :
1765 : // print column/row headers?
1766 0 : if( rPageData.mbPrintHeadings )
1767 : {
1768 0 : nWidth -= 2000;
1769 0 : nHeight -= 1000;
1770 : }
1771 :
1772 : // create the object anchor
1773 0 : XclObjAnchor aAnchor;
1774 0 : aAnchor.SetRect( GetRoot(), GetCurrScTab(), Rectangle( 1000, 500, nWidth, nHeight ), MAP_100TH_MM );
1775 0 : SetAnchor( aAnchor );
1776 0 : }
1777 :
1778 0 : XclImpNoteObj::XclImpNoteObj( const XclImpRoot& rRoot ) :
1779 : XclImpTextObj( rRoot ),
1780 : maScPos( ScAddress::INITIALIZE_INVALID ),
1781 0 : mnNoteFlags( 0 )
1782 : {
1783 0 : SetSimpleMacro( false );
1784 : // caption object will be created manually
1785 0 : SetInsertSdrObj( false );
1786 0 : }
1787 :
1788 0 : void XclImpNoteObj::SetNoteData( const ScAddress& rScPos, sal_uInt16 nNoteFlags )
1789 : {
1790 0 : maScPos = rScPos;
1791 0 : mnNoteFlags = nNoteFlags;
1792 0 : }
1793 :
1794 0 : void XclImpNoteObj::DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
1795 : {
1796 : // create formatted text
1797 0 : XclImpTextObj::DoPreProcessSdrObj( rDffConv, rSdrObj );
1798 0 : OutlinerParaObject* pOutlinerObj = rSdrObj.GetOutlinerParaObject();
1799 0 : if( maScPos.IsValid() && pOutlinerObj )
1800 : {
1801 : // create cell note with all data from drawing object
1802 : ScNoteUtil::CreateNoteFromObjectData(
1803 0 : GetDoc(), maScPos,
1804 0 : rSdrObj.GetMergedItemSet().Clone(), // new object on heap expected
1805 0 : new OutlinerParaObject( *pOutlinerObj ), // new object on heap expected
1806 0 : rSdrObj.GetLogicRect(),
1807 0 : ::get_flag( mnNoteFlags, EXC_NOTE_VISIBLE ),
1808 0 : false );
1809 : }
1810 0 : }
1811 :
1812 0 : XclImpControlHelper::XclImpControlHelper( const XclImpRoot& rRoot, XclCtrlBindMode eBindMode ) :
1813 : mrRoot( rRoot ),
1814 0 : meBindMode( eBindMode )
1815 : {
1816 0 : }
1817 :
1818 0 : XclImpControlHelper::~XclImpControlHelper()
1819 : {
1820 0 : }
1821 :
1822 0 : SdrObject* XclImpControlHelper::CreateSdrObjectFromShape(
1823 : const Reference< XShape >& rxShape, const Rectangle& rAnchorRect ) const
1824 : {
1825 0 : mxShape = rxShape;
1826 0 : SdrObjectPtr xSdrObj( SdrObject::getSdrObjectFromXShape( rxShape ) );
1827 0 : if( xSdrObj.is() )
1828 : {
1829 0 : xSdrObj->NbcSetSnapRect( rAnchorRect );
1830 : // #i30543# insert into control layer
1831 0 : xSdrObj->NbcSetLayer( SC_LAYER_CONTROLS );
1832 : }
1833 0 : return xSdrObj.release();
1834 : }
1835 :
1836 0 : void XclImpControlHelper::ApplySheetLinkProps() const
1837 : {
1838 :
1839 0 : Reference< XControlModel > xCtrlModel = XclControlHelper::GetControlModel( mxShape );
1840 0 : if( !xCtrlModel.is() )
1841 0 : return;
1842 0 : ScfPropertySet aPropSet( xCtrlModel );
1843 :
1844 : // sheet links
1845 0 : if( SfxObjectShell* pDocShell = mrRoot.GetDocShell() )
1846 : {
1847 0 : Reference< XMultiServiceFactory > xFactory( pDocShell->GetModel(), UNO_QUERY );
1848 0 : if( xFactory.is() )
1849 : {
1850 : // cell link
1851 0 : if( mxCellLink ) try
1852 : {
1853 0 : Reference< XBindableValue > xBindable( xCtrlModel, UNO_QUERY_THROW );
1854 :
1855 : // create argument sequence for createInstanceWithArguments()
1856 0 : CellAddress aApiAddress;
1857 0 : ScUnoConversion::FillApiAddress( aApiAddress, *mxCellLink );
1858 :
1859 0 : NamedValue aValue;
1860 0 : aValue.Name = SC_UNONAME_BOUNDCELL;
1861 0 : aValue.Value <<= aApiAddress;
1862 :
1863 0 : Sequence< Any > aArgs( 1 );
1864 0 : aArgs[ 0 ] <<= aValue;
1865 :
1866 : // create the CellValueBinding instance and set at the control model
1867 0 : OUString aServiceName;
1868 0 : switch( meBindMode )
1869 : {
1870 0 : case EXC_CTRL_BINDCONTENT: aServiceName = SC_SERVICENAME_VALBIND; break;
1871 0 : case EXC_CTRL_BINDPOSITION: aServiceName = SC_SERVICENAME_LISTCELLBIND; break;
1872 : }
1873 : Reference< XValueBinding > xBinding(
1874 0 : xFactory->createInstanceWithArguments( aServiceName, aArgs ), UNO_QUERY_THROW );
1875 0 : xBindable->setValueBinding( xBinding );
1876 : }
1877 0 : catch( const Exception& )
1878 : {
1879 : }
1880 :
1881 : // source range
1882 0 : if( mxSrcRange ) try
1883 : {
1884 0 : Reference< XListEntrySink > xEntrySink( xCtrlModel, UNO_QUERY_THROW );
1885 :
1886 : // create argument sequence for createInstanceWithArguments()
1887 0 : CellRangeAddress aApiRange;
1888 0 : ScUnoConversion::FillApiRange( aApiRange, *mxSrcRange );
1889 :
1890 0 : NamedValue aValue;
1891 0 : aValue.Name = SC_UNONAME_CELLRANGE;
1892 0 : aValue.Value <<= aApiRange;
1893 :
1894 0 : Sequence< Any > aArgs( 1 );
1895 0 : aArgs[ 0 ] <<= aValue;
1896 :
1897 : // create the EntrySource instance and set at the control model
1898 0 : Reference< XListEntrySource > xEntrySource( xFactory->createInstanceWithArguments(
1899 0 : SC_SERVICENAME_LISTSOURCE, aArgs ), UNO_QUERY_THROW );
1900 0 : xEntrySink->setListEntrySource( xEntrySource );
1901 : }
1902 0 : catch( const Exception& )
1903 : {
1904 : }
1905 0 : }
1906 0 : }
1907 : }
1908 :
1909 0 : void XclImpControlHelper::ProcessControl( const XclImpDrawObjBase& rDrawObj ) const
1910 : {
1911 0 : Reference< XControlModel > xCtrlModel = XclControlHelper::GetControlModel( mxShape );
1912 0 : if( !xCtrlModel.is() )
1913 0 : return;
1914 :
1915 0 : ApplySheetLinkProps();
1916 :
1917 0 : ScfPropertySet aPropSet( xCtrlModel );
1918 :
1919 : // #i51348# set object name at control model
1920 0 : aPropSet.SetStringProperty( "Name", rDrawObj.GetObjName() );
1921 :
1922 : // control visible and printable?
1923 0 : aPropSet.SetBoolProperty( "EnableVisible", rDrawObj.IsVisible() );
1924 0 : aPropSet.SetBoolProperty( "Printable", rDrawObj.IsPrintable() );
1925 :
1926 :
1927 : // virtual call for type specific processing
1928 0 : DoProcessControl( aPropSet );
1929 : }
1930 :
1931 0 : void XclImpControlHelper::ReadCellLinkFormula( XclImpStream& rStrm, bool bWithBoundSize )
1932 : {
1933 0 : ScRangeList aScRanges;
1934 0 : ReadRangeList( aScRanges, rStrm, bWithBoundSize );
1935 : // Use first cell of first range
1936 0 : if ( !aScRanges.empty() )
1937 : {
1938 0 : const ScRange* pScRange = aScRanges.front();
1939 0 : mxCellLink.reset( new ScAddress( pScRange->aStart ) );
1940 0 : }
1941 0 : }
1942 :
1943 0 : void XclImpControlHelper::ReadSourceRangeFormula( XclImpStream& rStrm, bool bWithBoundSize )
1944 : {
1945 0 : ScRangeList aScRanges;
1946 0 : ReadRangeList( aScRanges, rStrm, bWithBoundSize );
1947 : // Use first range
1948 0 : if ( !aScRanges.empty() )
1949 : {
1950 0 : const ScRange* pScRange = aScRanges.front();
1951 0 : mxSrcRange.reset( new ScRange( *pScRange ) );
1952 0 : }
1953 0 : }
1954 :
1955 0 : void XclImpControlHelper::DoProcessControl( ScfPropertySet& ) const
1956 : {
1957 0 : }
1958 :
1959 0 : void XclImpControlHelper::ReadRangeList( ScRangeList& rScRanges, XclImpStream& rStrm )
1960 : {
1961 0 : XclTokenArray aXclTokArr;
1962 0 : aXclTokArr.ReadSize( rStrm );
1963 0 : rStrm.Ignore( 4 );
1964 0 : aXclTokArr.ReadArray( rStrm );
1965 0 : mrRoot.GetFormulaCompiler().CreateRangeList( rScRanges, EXC_FMLATYPE_CONTROL, aXclTokArr, rStrm );
1966 0 : }
1967 :
1968 0 : void XclImpControlHelper::ReadRangeList( ScRangeList& rScRanges, XclImpStream& rStrm, bool bWithBoundSize )
1969 : {
1970 0 : if( bWithBoundSize )
1971 : {
1972 : sal_uInt16 nSize;
1973 0 : rStrm >> nSize;
1974 0 : if( nSize > 0 )
1975 : {
1976 0 : rStrm.PushPosition();
1977 0 : ReadRangeList( rScRanges, rStrm );
1978 0 : rStrm.PopPosition();
1979 0 : rStrm.Ignore( nSize );
1980 : }
1981 : }
1982 : else
1983 : {
1984 0 : ReadRangeList( rScRanges, rStrm );
1985 : }
1986 0 : }
1987 :
1988 0 : XclImpTbxObjBase::XclImpTbxObjBase( const XclImpRoot& rRoot ) :
1989 : XclImpTextObj( rRoot ),
1990 0 : XclImpControlHelper( rRoot, EXC_CTRL_BINDPOSITION )
1991 : {
1992 0 : SetSimpleMacro( false );
1993 0 : SetCustomDffObj( true );
1994 0 : }
1995 :
1996 : namespace {
1997 :
1998 0 : void lclExtractColor( sal_uInt8& rnColorIdx, const DffPropSet& rDffPropSet, sal_uInt32 nPropId )
1999 : {
2000 0 : if( rDffPropSet.IsProperty( nPropId ) )
2001 : {
2002 0 : sal_uInt32 nColor = rDffPropSet.GetPropertyValue( nPropId );
2003 0 : if( (nColor & 0xFF000000) == 0x08000000 )
2004 0 : rnColorIdx = ::extract_value< sal_uInt8 >( nColor, 0, 8 );
2005 : }
2006 0 : }
2007 :
2008 : } // namespace
2009 :
2010 0 : void XclImpTbxObjBase::SetDffProperties( const DffPropSet& rDffPropSet )
2011 : {
2012 0 : maFillData.mnPattern = rDffPropSet.GetPropertyBool( DFF_Prop_fFilled ) ? EXC_PATT_SOLID : EXC_PATT_NONE;
2013 0 : lclExtractColor( maFillData.mnBackColorIdx, rDffPropSet, DFF_Prop_fillBackColor );
2014 0 : lclExtractColor( maFillData.mnPattColorIdx, rDffPropSet, DFF_Prop_fillColor );
2015 0 : ::set_flag( maFillData.mnAuto, EXC_OBJ_LINE_AUTO, false );
2016 :
2017 0 : maLineData.mnStyle = rDffPropSet.GetPropertyBool( DFF_Prop_fLine ) ? EXC_OBJ_LINE_SOLID : EXC_OBJ_LINE_NONE;
2018 0 : lclExtractColor( maLineData.mnColorIdx, rDffPropSet, DFF_Prop_lineColor );
2019 0 : ::set_flag( maLineData.mnAuto, EXC_OBJ_FILL_AUTO, false );
2020 0 : }
2021 :
2022 0 : bool XclImpTbxObjBase::FillMacroDescriptor( ScriptEventDescriptor& rDescriptor ) const
2023 : {
2024 0 : return XclControlHelper::FillMacroDescriptor( rDescriptor, DoGetEventType(), GetMacroName(), GetDocShell() );
2025 : }
2026 :
2027 0 : void XclImpTbxObjBase::ConvertFont( ScfPropertySet& rPropSet ) const
2028 : {
2029 0 : if( maTextData.mxString )
2030 : {
2031 0 : const XclFormatRunVec& rFormatRuns = maTextData.mxString->GetFormats();
2032 0 : if( rFormatRuns.empty() )
2033 0 : GetFontBuffer().WriteDefaultCtrlFontProperties( rPropSet );
2034 : else
2035 0 : GetFontBuffer().WriteFontProperties( rPropSet, EXC_FONTPROPSET_CONTROL, rFormatRuns.front().mnFontIdx );
2036 : }
2037 0 : }
2038 :
2039 0 : void XclImpTbxObjBase::ConvertLabel( ScfPropertySet& rPropSet ) const
2040 : {
2041 0 : if( maTextData.mxString )
2042 : {
2043 0 : OUString aLabel = maTextData.mxString->GetText();
2044 0 : if( maTextData.maData.mnShortcut > 0 )
2045 : {
2046 0 : sal_Int32 nPos = aLabel.indexOf( static_cast< sal_Unicode >( maTextData.maData.mnShortcut ) );
2047 0 : if( nPos != -1 )
2048 0 : aLabel = aLabel.replaceAt( nPos, 0, "~" );
2049 : }
2050 0 : rPropSet.SetStringProperty( "Label", aLabel );
2051 :
2052 : //Excel Alt text <==> Aoo description
2053 : //For TBX control, if user does not operate alt text, alt text will be set label text as default value in Excel.
2054 : //In this case, DFF_Prop_wzDescription will not be set in excel file.
2055 : //So In the end of SvxMSDffManager::ImportShape, description will not be set. But actually in excel,
2056 : //the alt text is the label value. So here set description as label text first which is called before ImportShape.
2057 0 : Reference< ::com::sun::star::beans::XPropertySet > xPropset( mxShape, UNO_QUERY );
2058 : try{
2059 0 : if(xPropset.is())
2060 0 : xPropset->setPropertyValue( "Description", makeAny(::rtl::OUString(aLabel)) );
2061 0 : }catch( ... )
2062 : {
2063 : OSL_TRACE( " Can't set a default text for TBX Control ");
2064 0 : }
2065 : }
2066 0 : ConvertFont( rPropSet );
2067 0 : }
2068 :
2069 0 : SdrObject* XclImpTbxObjBase::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
2070 : {
2071 0 : SdrObjectPtr xSdrObj( rDffConv.CreateSdrObject( *this, rAnchorRect ) );
2072 0 : rDffConv.Progress();
2073 0 : return xSdrObj.release();
2074 : }
2075 :
2076 0 : void XclImpTbxObjBase::DoPreProcessSdrObj( XclImpDffConverter& /*rDffConv*/, SdrObject& /*rSdrObj*/ ) const
2077 : {
2078 : // do not call DoPreProcessSdrObj() from base class (to skip text processing)
2079 0 : ProcessControl( *this );
2080 0 : }
2081 :
2082 0 : XclImpButtonObj::XclImpButtonObj( const XclImpRoot& rRoot ) :
2083 0 : XclImpTbxObjBase( rRoot )
2084 : {
2085 0 : }
2086 :
2087 0 : void XclImpButtonObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2088 : {
2089 : // label and text formatting
2090 0 : ConvertLabel( rPropSet );
2091 :
2092 : /* Horizontal text alignment. For unknown reason, the property type is a
2093 : simple sal_Int16 and not a com.sun.star.style.HorizontalAlignment. */
2094 0 : sal_Int16 nHorAlign = 1;
2095 0 : switch( maTextData.maData.GetHorAlign() )
2096 : {
2097 0 : case EXC_OBJ_HOR_LEFT: nHorAlign = 0; break;
2098 0 : case EXC_OBJ_HOR_CENTER: nHorAlign = 1; break;
2099 0 : case EXC_OBJ_HOR_RIGHT: nHorAlign = 2; break;
2100 : }
2101 0 : rPropSet.SetProperty( "Align", nHorAlign );
2102 :
2103 : // vertical text alignment
2104 : namespace csss = ::com::sun::star::style;
2105 0 : csss::VerticalAlignment eVerAlign = csss::VerticalAlignment_MIDDLE;
2106 0 : switch( maTextData.maData.GetVerAlign() )
2107 : {
2108 0 : case EXC_OBJ_VER_TOP: eVerAlign = csss::VerticalAlignment_TOP; break;
2109 0 : case EXC_OBJ_VER_CENTER: eVerAlign = csss::VerticalAlignment_MIDDLE; break;
2110 0 : case EXC_OBJ_VER_BOTTOM: eVerAlign = csss::VerticalAlignment_BOTTOM; break;
2111 : }
2112 0 : rPropSet.SetProperty( "VerticalAlign", eVerAlign );
2113 :
2114 : // always wrap text automatically
2115 0 : rPropSet.SetBoolProperty( "MultiLine", true );
2116 :
2117 : // default button
2118 0 : bool bDefButton = ::get_flag( maTextData.maData.mnButtonFlags, EXC_OBJ_BUTTON_DEFAULT );
2119 0 : rPropSet.SetBoolProperty( "DefaultButton", bDefButton );
2120 :
2121 : // button type (flags cannot be combined in OOo)
2122 : namespace cssa = ::com::sun::star::awt;
2123 0 : cssa::PushButtonType eButtonType = cssa::PushButtonType_STANDARD;
2124 0 : if( ::get_flag( maTextData.maData.mnButtonFlags, EXC_OBJ_BUTTON_CLOSE ) )
2125 0 : eButtonType = cssa::PushButtonType_OK;
2126 0 : else if( ::get_flag( maTextData.maData.mnButtonFlags, EXC_OBJ_BUTTON_CANCEL ) )
2127 0 : eButtonType = cssa::PushButtonType_CANCEL;
2128 0 : else if( ::get_flag( maTextData.maData.mnButtonFlags, EXC_OBJ_BUTTON_HELP ) )
2129 0 : eButtonType = cssa::PushButtonType_HELP;
2130 : // property type is short, not enum
2131 0 : rPropSet.SetProperty( "PushButtonType", sal_Int16( eButtonType ) );
2132 0 : }
2133 :
2134 0 : OUString XclImpButtonObj::DoGetServiceName() const
2135 : {
2136 0 : return OUString( "com.sun.star.form.component.CommandButton" );
2137 : }
2138 :
2139 0 : XclTbxEventType XclImpButtonObj::DoGetEventType() const
2140 : {
2141 0 : return EXC_TBX_EVENT_ACTION;
2142 : }
2143 :
2144 0 : XclImpCheckBoxObj::XclImpCheckBoxObj( const XclImpRoot& rRoot ) :
2145 : XclImpTbxObjBase( rRoot ),
2146 : mnState( EXC_OBJ_CHECKBOX_UNCHECKED ),
2147 0 : mnCheckBoxFlags( 0 )
2148 : {
2149 0 : }
2150 :
2151 0 : void XclImpCheckBoxObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2152 : {
2153 0 : ReadFrameData( rStrm );
2154 0 : rStrm.Ignore( 10 );
2155 0 : rStrm >> maTextData.maData.mnFlags;
2156 0 : rStrm.Ignore( 20 );
2157 0 : ReadName5( rStrm, nNameLen );
2158 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2159 0 : ReadCellLinkFormula( rStrm, true );
2160 0 : rStrm >> maTextData.maData.mnTextLen;
2161 0 : maTextData.ReadByteString( rStrm );
2162 0 : rStrm >> mnState >> maTextData.maData.mnShortcut >> maTextData.maData.mnShortcutEA >> mnCheckBoxFlags;
2163 0 : }
2164 :
2165 0 : void XclImpCheckBoxObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2166 : {
2167 0 : switch( nSubRecId )
2168 : {
2169 : case EXC_ID_OBJCBLS:
2170 : // do not read EXC_ID_OBJCBLSDATA, not written by OOo Excel export
2171 0 : rStrm >> mnState;
2172 0 : rStrm.Ignore( 4 );
2173 0 : rStrm >> maTextData.maData.mnShortcut >> maTextData.maData.mnShortcutEA >> mnCheckBoxFlags;
2174 0 : break;
2175 : case EXC_ID_OBJCBLSFMLA:
2176 0 : ReadCellLinkFormula( rStrm, false );
2177 0 : break;
2178 : default:
2179 0 : XclImpTbxObjBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2180 : }
2181 0 : }
2182 :
2183 0 : void XclImpCheckBoxObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2184 : {
2185 : // label and text formatting
2186 0 : ConvertLabel( rPropSet );
2187 :
2188 : // state
2189 0 : bool bSupportsTristate = GetObjType() == EXC_OBJTYPE_CHECKBOX;
2190 0 : sal_Int16 nApiState = 0;
2191 0 : switch( mnState )
2192 : {
2193 0 : case EXC_OBJ_CHECKBOX_UNCHECKED: nApiState = 0; break;
2194 0 : case EXC_OBJ_CHECKBOX_CHECKED: nApiState = 1; break;
2195 0 : case EXC_OBJ_CHECKBOX_TRISTATE: nApiState = bSupportsTristate ? 2 : 1; break;
2196 : }
2197 0 : if( bSupportsTristate )
2198 0 : rPropSet.SetBoolProperty( "TriState", nApiState == 2 );
2199 0 : rPropSet.SetProperty( "DefaultState", nApiState );
2200 :
2201 : // box style
2202 : namespace AwtVisualEffect = ::com::sun::star::awt::VisualEffect;
2203 0 : sal_Int16 nEffect = ::get_flagvalue( mnCheckBoxFlags, EXC_OBJ_CHECKBOX_FLAT, AwtVisualEffect::FLAT, AwtVisualEffect::LOOK3D );
2204 0 : rPropSet.SetProperty( "VisualEffect", nEffect );
2205 :
2206 : // do not wrap text automatically
2207 0 : rPropSet.SetBoolProperty( "MultiLine", false );
2208 :
2209 : // #i40279# always centered vertically
2210 : namespace csss = ::com::sun::star::style;
2211 0 : rPropSet.SetProperty( "VerticalAlign", csss::VerticalAlignment_MIDDLE );
2212 :
2213 : // background color
2214 0 : if( maFillData.IsFilled() )
2215 : {
2216 0 : sal_Int32 nColor = static_cast< sal_Int32 >( GetSolidFillColor( maFillData ).GetColor() );
2217 0 : rPropSet.SetProperty( "BackgroundColor", nColor );
2218 : }
2219 0 : }
2220 :
2221 0 : OUString XclImpCheckBoxObj::DoGetServiceName() const
2222 : {
2223 0 : return OUString( "com.sun.star.form.component.CheckBox" );
2224 : }
2225 :
2226 0 : XclTbxEventType XclImpCheckBoxObj::DoGetEventType() const
2227 : {
2228 0 : return EXC_TBX_EVENT_ACTION;
2229 : }
2230 :
2231 0 : XclImpOptionButtonObj::XclImpOptionButtonObj( const XclImpRoot& rRoot ) :
2232 : XclImpCheckBoxObj( rRoot ),
2233 : mnNextInGroup( 0 ),
2234 0 : mnFirstInGroup( 1 )
2235 : {
2236 0 : }
2237 :
2238 0 : void XclImpOptionButtonObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2239 : {
2240 0 : ReadFrameData( rStrm );
2241 0 : rStrm.Ignore( 10 );
2242 0 : rStrm >> maTextData.maData.mnFlags;
2243 0 : rStrm.Ignore( 32 );
2244 0 : ReadName5( rStrm, nNameLen );
2245 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2246 0 : ReadCellLinkFormula( rStrm, true );
2247 0 : rStrm >> maTextData.maData.mnTextLen;
2248 0 : maTextData.ReadByteString( rStrm );
2249 0 : rStrm >> mnState >> maTextData.maData.mnShortcut >> maTextData.maData.mnShortcutEA;
2250 0 : rStrm >> mnCheckBoxFlags >> mnNextInGroup >> mnFirstInGroup;
2251 0 : }
2252 :
2253 0 : void XclImpOptionButtonObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2254 : {
2255 0 : switch( nSubRecId )
2256 : {
2257 : case EXC_ID_OBJRBODATA:
2258 0 : rStrm >> mnNextInGroup >> mnFirstInGroup;
2259 0 : break;
2260 : default:
2261 0 : XclImpCheckBoxObj::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2262 : }
2263 0 : }
2264 :
2265 0 : void XclImpOptionButtonObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2266 : {
2267 0 : XclImpCheckBoxObj::DoProcessControl( rPropSet );
2268 : // TODO: grouping
2269 0 : XclImpOptionButtonObj* pTbxObj = dynamic_cast< XclImpOptionButtonObj* >( GetObjectManager().GetSheetDrawing( GetTab() ).FindDrawObj( mnNextInGroup ).get() );
2270 0 : if ( ( pTbxObj && pTbxObj->mnFirstInGroup ) )
2271 : {
2272 : // Group has terminated
2273 : // traverse each RadioButton in group and
2274 : // a) apply the groupname
2275 : // b) propagate the linked cell from the lead radiobutton
2276 : // c) apply the correct Ref value
2277 0 : XclImpOptionButtonObj* pLeader = pTbxObj;
2278 : ;
2279 0 : sal_Int32 nRefVal = 1;
2280 : OSL_TRACE( "0x%x start group ", pLeader->GetObjId()/*.mnObjId */);
2281 0 : do
2282 : {
2283 :
2284 0 : Reference< XControlModel > xCtrlModel = XclControlHelper::GetControlModel( pTbxObj->mxShape );
2285 0 : if ( xCtrlModel.is() )
2286 : {
2287 0 : ScfPropertySet aProps( xCtrlModel );
2288 0 : OUString sGroupName = OUString::number( pLeader->GetDffShapeId() );
2289 :
2290 0 : aProps.SetStringProperty( "GroupName", sGroupName );
2291 0 : aProps.SetStringProperty( "RefValue", OUString::number( nRefVal++ ) );
2292 0 : if ( pLeader->HasCellLink() && !pTbxObj->HasCellLink() )
2293 : {
2294 : // propagate cell link info
2295 0 : pTbxObj->mxCellLink.reset( new ScAddress( *pLeader->mxCellLink.get() ) );
2296 0 : pTbxObj->ApplySheetLinkProps();
2297 : }
2298 0 : pTbxObj = dynamic_cast< XclImpOptionButtonObj* >( GetObjectManager().GetSheetDrawing( GetTab() ).FindDrawObj( pTbxObj->mnNextInGroup ).get() );
2299 : }
2300 : else
2301 0 : pTbxObj = NULL;
2302 0 : } while ( pTbxObj && !( pTbxObj->mnFirstInGroup == 1 ) );
2303 : }
2304 : else
2305 : {
2306 : // not the leader? try and find it
2307 : }
2308 0 : }
2309 :
2310 0 : OUString XclImpOptionButtonObj::DoGetServiceName() const
2311 : {
2312 0 : return OUString( "com.sun.star.form.component.RadioButton" );
2313 : }
2314 :
2315 0 : XclTbxEventType XclImpOptionButtonObj::DoGetEventType() const
2316 : {
2317 0 : return EXC_TBX_EVENT_ACTION;
2318 : }
2319 :
2320 0 : XclImpLabelObj::XclImpLabelObj( const XclImpRoot& rRoot ) :
2321 0 : XclImpTbxObjBase( rRoot )
2322 : {
2323 0 : }
2324 :
2325 0 : void XclImpLabelObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2326 : {
2327 : // label and text formatting
2328 0 : ConvertLabel( rPropSet );
2329 :
2330 : // text alignment (always top/left aligned)
2331 0 : rPropSet.SetProperty( "Align", sal_Int16( 0 ) );
2332 : namespace csss = ::com::sun::star::style;
2333 0 : rPropSet.SetProperty( "VerticalAlign", csss::VerticalAlignment_TOP );
2334 :
2335 : // always wrap text automatically
2336 0 : rPropSet.SetBoolProperty( "MultiLine", true );
2337 0 : }
2338 :
2339 0 : OUString XclImpLabelObj::DoGetServiceName() const
2340 : {
2341 0 : return OUString( "com.sun.star.form.component.FixedText" );
2342 : }
2343 :
2344 0 : XclTbxEventType XclImpLabelObj::DoGetEventType() const
2345 : {
2346 0 : return EXC_TBX_EVENT_MOUSE;
2347 : }
2348 :
2349 0 : XclImpGroupBoxObj::XclImpGroupBoxObj( const XclImpRoot& rRoot ) :
2350 : XclImpTbxObjBase( rRoot ),
2351 0 : mnGroupBoxFlags( 0 )
2352 : {
2353 0 : }
2354 :
2355 0 : void XclImpGroupBoxObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2356 : {
2357 0 : ReadFrameData( rStrm );
2358 0 : rStrm.Ignore( 10 );
2359 0 : rStrm >> maTextData.maData.mnFlags;
2360 0 : rStrm.Ignore( 26 );
2361 0 : ReadName5( rStrm, nNameLen );
2362 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2363 0 : rStrm >> maTextData.maData.mnTextLen;
2364 0 : maTextData.ReadByteString( rStrm );
2365 0 : rStrm >> maTextData.maData.mnShortcut >> maTextData.maData.mnShortcutEA >> mnGroupBoxFlags;
2366 0 : }
2367 :
2368 0 : void XclImpGroupBoxObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2369 : {
2370 0 : switch( nSubRecId )
2371 : {
2372 : case EXC_ID_OBJGBODATA:
2373 0 : rStrm >> maTextData.maData.mnShortcut >> maTextData.maData.mnShortcutEA >> mnGroupBoxFlags;
2374 0 : break;
2375 : default:
2376 0 : XclImpTbxObjBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2377 : }
2378 0 : }
2379 :
2380 0 : void XclImpGroupBoxObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2381 : {
2382 : // label and text formatting
2383 0 : ConvertLabel( rPropSet );
2384 0 : }
2385 :
2386 0 : OUString XclImpGroupBoxObj::DoGetServiceName() const
2387 : {
2388 0 : return OUString( "com.sun.star.form.component.GroupBox" );
2389 : }
2390 :
2391 0 : XclTbxEventType XclImpGroupBoxObj::DoGetEventType() const
2392 : {
2393 0 : return EXC_TBX_EVENT_MOUSE;
2394 : }
2395 :
2396 0 : XclImpDialogObj::XclImpDialogObj( const XclImpRoot& rRoot ) :
2397 0 : XclImpTbxObjBase( rRoot )
2398 : {
2399 0 : }
2400 :
2401 0 : void XclImpDialogObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2402 : {
2403 : // label and text formatting
2404 0 : ConvertLabel( rPropSet );
2405 0 : }
2406 :
2407 0 : OUString XclImpDialogObj::DoGetServiceName() const
2408 : {
2409 : // dialog frame faked by a groupbox
2410 0 : return OUString( "com.sun.star.form.component.GroupBox" );
2411 : }
2412 :
2413 0 : XclTbxEventType XclImpDialogObj::DoGetEventType() const
2414 : {
2415 0 : return EXC_TBX_EVENT_MOUSE;
2416 : }
2417 :
2418 0 : XclImpEditObj::XclImpEditObj( const XclImpRoot& rRoot ) :
2419 : XclImpTbxObjBase( rRoot ),
2420 : mnContentType( EXC_OBJ_EDIT_TEXT ),
2421 : mnMultiLine( 0 ),
2422 : mnScrollBar( 0 ),
2423 0 : mnListBoxObjId( 0 )
2424 : {
2425 0 : }
2426 :
2427 0 : bool XclImpEditObj::IsNumeric() const
2428 : {
2429 0 : return (mnContentType == EXC_OBJ_EDIT_INTEGER) || (mnContentType == EXC_OBJ_EDIT_DOUBLE);
2430 : }
2431 :
2432 0 : void XclImpEditObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2433 : {
2434 0 : ReadFrameData( rStrm );
2435 0 : rStrm.Ignore( 10 );
2436 0 : rStrm >> maTextData.maData.mnFlags;
2437 0 : rStrm.Ignore( 14 );
2438 0 : ReadName5( rStrm, nNameLen );
2439 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2440 0 : rStrm >> maTextData.maData.mnTextLen;
2441 0 : maTextData.ReadByteString( rStrm );
2442 0 : rStrm >> mnContentType >> mnMultiLine >> mnScrollBar >> mnListBoxObjId;
2443 0 : }
2444 :
2445 0 : void XclImpEditObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2446 : {
2447 0 : switch( nSubRecId )
2448 : {
2449 : case EXC_ID_OBJEDODATA:
2450 0 : rStrm >> mnContentType >> mnMultiLine >> mnScrollBar >> mnListBoxObjId;
2451 0 : break;
2452 : default:
2453 0 : XclImpTbxObjBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2454 : }
2455 0 : }
2456 :
2457 0 : void XclImpEditObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2458 : {
2459 0 : if( maTextData.mxString )
2460 : {
2461 0 : OUString aText = maTextData.mxString->GetText();
2462 0 : if( IsNumeric() )
2463 : {
2464 : // TODO: OUString::toDouble() does not handle local decimal separator
2465 0 : rPropSet.SetProperty( "DefaultValue", aText.toDouble() );
2466 0 : rPropSet.SetBoolProperty( "Spin", mnScrollBar != 0 );
2467 : }
2468 : else
2469 : {
2470 0 : rPropSet.SetProperty( "DefaultText", aText );
2471 0 : rPropSet.SetBoolProperty( "MultiLine", mnMultiLine != 0 );
2472 0 : rPropSet.SetBoolProperty( "VScroll", mnScrollBar != 0 );
2473 0 : }
2474 : }
2475 0 : ConvertFont( rPropSet );
2476 0 : }
2477 :
2478 0 : OUString XclImpEditObj::DoGetServiceName() const
2479 : {
2480 0 : return IsNumeric() ?
2481 : OUString( "com.sun.star.form.component.NumericField" ) :
2482 0 : OUString( "com.sun.star.form.component.TextField" );
2483 : }
2484 :
2485 0 : XclTbxEventType XclImpEditObj::DoGetEventType() const
2486 : {
2487 0 : return EXC_TBX_EVENT_TEXT;
2488 : }
2489 :
2490 0 : XclImpTbxObjScrollableBase::XclImpTbxObjScrollableBase( const XclImpRoot& rRoot ) :
2491 : XclImpTbxObjBase( rRoot ),
2492 : mnValue( 0 ),
2493 : mnMin( 0 ),
2494 : mnMax( 100 ),
2495 : mnStep( 1 ),
2496 : mnPageStep( 10 ),
2497 : mnOrient( 0 ),
2498 : mnThumbWidth( 1 ),
2499 0 : mnScrollFlags( 0 )
2500 : {
2501 0 : }
2502 :
2503 0 : void XclImpTbxObjScrollableBase::ReadSbs( XclImpStream& rStrm )
2504 : {
2505 0 : rStrm.Ignore( 4 );
2506 0 : rStrm >> mnValue >> mnMin >> mnMax >> mnStep >> mnPageStep >> mnOrient >> mnThumbWidth >> mnScrollFlags;
2507 0 : }
2508 :
2509 0 : void XclImpTbxObjScrollableBase::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2510 : {
2511 0 : switch( nSubRecId )
2512 : {
2513 : case EXC_ID_OBJSBS:
2514 0 : ReadSbs( rStrm );
2515 0 : break;
2516 : case EXC_ID_OBJSBSFMLA:
2517 0 : ReadCellLinkFormula( rStrm, false );
2518 0 : break;
2519 : default:
2520 0 : XclImpTbxObjBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2521 : }
2522 0 : }
2523 :
2524 0 : XclImpSpinButtonObj::XclImpSpinButtonObj( const XclImpRoot& rRoot ) :
2525 0 : XclImpTbxObjScrollableBase( rRoot )
2526 : {
2527 0 : }
2528 :
2529 0 : void XclImpSpinButtonObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2530 : {
2531 0 : ReadFrameData( rStrm );
2532 0 : ReadSbs( rStrm );
2533 0 : ReadName5( rStrm, nNameLen );
2534 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2535 0 : ReadCellLinkFormula( rStrm, true );
2536 0 : }
2537 :
2538 0 : void XclImpSpinButtonObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2539 : {
2540 : // Calc's "Border" property is not the 3D/flat style effect in Excel (#i34712#)
2541 0 : rPropSet.SetProperty( "Border", ::com::sun::star::awt::VisualEffect::NONE );
2542 0 : rPropSet.SetProperty< sal_Int32 >( "DefaultSpinValue", mnValue );
2543 0 : rPropSet.SetProperty< sal_Int32 >( "SpinValueMin", mnMin );
2544 0 : rPropSet.SetProperty< sal_Int32 >( "SpinValueMax", mnMax );
2545 0 : rPropSet.SetProperty< sal_Int32 >( "SpinIncrement", mnStep );
2546 :
2547 : // Excel spin buttons always vertical
2548 0 : rPropSet.SetProperty( "Orientation", ::com::sun::star::awt::ScrollBarOrientation::VERTICAL );
2549 0 : }
2550 :
2551 0 : OUString XclImpSpinButtonObj::DoGetServiceName() const
2552 : {
2553 0 : return OUString( "com.sun.star.form.component.SpinButton" );
2554 : }
2555 :
2556 0 : XclTbxEventType XclImpSpinButtonObj::DoGetEventType() const
2557 : {
2558 0 : return EXC_TBX_EVENT_VALUE;
2559 : }
2560 :
2561 0 : XclImpScrollBarObj::XclImpScrollBarObj( const XclImpRoot& rRoot ) :
2562 0 : XclImpTbxObjScrollableBase( rRoot )
2563 : {
2564 0 : }
2565 :
2566 0 : void XclImpScrollBarObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2567 : {
2568 0 : ReadFrameData( rStrm );
2569 0 : ReadSbs( rStrm );
2570 0 : ReadName5( rStrm, nNameLen );
2571 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2572 0 : ReadCellLinkFormula( rStrm, true );
2573 0 : }
2574 :
2575 0 : void XclImpScrollBarObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2576 : {
2577 : // Calc's "Border" property is not the 3D/flat style effect in Excel (#i34712#)
2578 0 : rPropSet.SetProperty( "Border", ::com::sun::star::awt::VisualEffect::NONE );
2579 0 : rPropSet.SetProperty< sal_Int32 >( "DefaultScrollValue", mnValue );
2580 0 : rPropSet.SetProperty< sal_Int32 >( "ScrollValueMin", mnMin );
2581 0 : rPropSet.SetProperty< sal_Int32 >( "ScrollValueMax", mnMax );
2582 0 : rPropSet.SetProperty< sal_Int32 >( "LineIncrement", mnStep );
2583 0 : rPropSet.SetProperty< sal_Int32 >( "BlockIncrement", mnPageStep );
2584 0 : rPropSet.SetProperty( "VisibleSize", ::std::min< sal_Int32 >( mnPageStep, 1 ) );
2585 :
2586 : namespace AwtScrollOrient = ::com::sun::star::awt::ScrollBarOrientation;
2587 0 : sal_Int32 nApiOrient = ::get_flagvalue( mnOrient, EXC_OBJ_SCROLLBAR_HOR, AwtScrollOrient::HORIZONTAL, AwtScrollOrient::VERTICAL );
2588 0 : rPropSet.SetProperty( "Orientation", nApiOrient );
2589 0 : }
2590 :
2591 0 : OUString XclImpScrollBarObj::DoGetServiceName() const
2592 : {
2593 0 : return OUString( "com.sun.star.form.component.ScrollBar" );
2594 : }
2595 :
2596 0 : XclTbxEventType XclImpScrollBarObj::DoGetEventType() const
2597 : {
2598 0 : return EXC_TBX_EVENT_VALUE;
2599 : }
2600 :
2601 0 : XclImpTbxObjListBase::XclImpTbxObjListBase( const XclImpRoot& rRoot ) :
2602 : XclImpTbxObjScrollableBase( rRoot ),
2603 : mnEntryCount( 0 ),
2604 : mnSelEntry( 0 ),
2605 : mnListFlags( 0 ),
2606 : mnEditObjId( 0 ),
2607 0 : mbHasDefFontIdx( false )
2608 : {
2609 0 : }
2610 :
2611 0 : void XclImpTbxObjListBase::ReadLbsData( XclImpStream& rStrm )
2612 : {
2613 0 : ReadSourceRangeFormula( rStrm, true );
2614 0 : rStrm >> mnEntryCount >> mnSelEntry >> mnListFlags >> mnEditObjId;
2615 0 : }
2616 :
2617 0 : void XclImpTbxObjListBase::SetBoxFormatting( ScfPropertySet& rPropSet ) const
2618 : {
2619 : // border style
2620 : namespace AwtVisualEffect = ::com::sun::star::awt::VisualEffect;
2621 0 : sal_Int16 nApiBorder = ::get_flagvalue( mnListFlags, EXC_OBJ_LISTBOX_FLAT, AwtVisualEffect::FLAT, AwtVisualEffect::LOOK3D );
2622 0 : rPropSet.SetProperty( "Border", nApiBorder );
2623 :
2624 : // font formatting
2625 0 : if( mbHasDefFontIdx )
2626 0 : GetFontBuffer().WriteFontProperties( rPropSet, EXC_FONTPROPSET_CONTROL, maTextData.maData.mnDefFontIdx );
2627 : else
2628 0 : GetFontBuffer().WriteDefaultCtrlFontProperties( rPropSet );
2629 0 : }
2630 :
2631 0 : XclImpListBoxObj::XclImpListBoxObj( const XclImpRoot& rRoot ) :
2632 0 : XclImpTbxObjListBase( rRoot )
2633 : {
2634 0 : }
2635 :
2636 0 : void XclImpListBoxObj::ReadFullLbsData( XclImpStream& rStrm, sal_Size nRecLeft )
2637 : {
2638 0 : sal_Size nRecEnd = rStrm.GetRecPos() + nRecLeft;
2639 0 : ReadLbsData( rStrm );
2640 : OSL_ENSURE( (rStrm.GetRecPos() == nRecEnd) || (rStrm.GetRecPos() + mnEntryCount == nRecEnd),
2641 : "XclImpListBoxObj::ReadFullLbsData - invalid size of OBJLBSDATA record" );
2642 0 : while( rStrm.IsValid() && (rStrm.GetRecPos() < nRecEnd) )
2643 0 : maSelection.push_back( rStrm.ReaduInt8() );
2644 0 : }
2645 :
2646 0 : void XclImpListBoxObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2647 : {
2648 0 : ReadFrameData( rStrm );
2649 0 : ReadSbs( rStrm );
2650 0 : rStrm.Ignore( 18 );
2651 0 : rStrm >> maTextData.maData.mnDefFontIdx;
2652 0 : rStrm.Ignore( 4 );
2653 0 : ReadName5( rStrm, nNameLen );
2654 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2655 0 : ReadCellLinkFormula( rStrm, true );
2656 0 : ReadFullLbsData( rStrm, rStrm.GetRecLeft() );
2657 0 : mbHasDefFontIdx = true;
2658 0 : }
2659 :
2660 0 : void XclImpListBoxObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2661 : {
2662 0 : switch( nSubRecId )
2663 : {
2664 : case EXC_ID_OBJLBSDATA:
2665 0 : ReadFullLbsData( rStrm, nSubRecSize );
2666 0 : break;
2667 : default:
2668 0 : XclImpTbxObjListBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2669 : }
2670 0 : }
2671 :
2672 0 : void XclImpListBoxObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2673 : {
2674 : // listbox formatting
2675 0 : SetBoxFormatting( rPropSet );
2676 :
2677 : // selection type
2678 0 : sal_uInt8 nSelType = ::extract_value< sal_uInt8 >( mnListFlags, 4, 2 );
2679 0 : bool bMultiSel = nSelType != EXC_OBJ_LISTBOX_SINGLE;
2680 0 : rPropSet.SetBoolProperty( "MultiSelection", bMultiSel );
2681 :
2682 : // selection (do not set, if listbox is linked to a cell)
2683 0 : if( !HasCellLink() )
2684 : {
2685 0 : ScfInt16Vec aSelVec;
2686 :
2687 : // multi selection: API expects sequence of list entry indexes
2688 0 : if( bMultiSel )
2689 : {
2690 0 : for( ScfUInt8Vec::const_iterator aBeg = maSelection.begin(), aIt = aBeg, aEnd = maSelection.end(); aIt != aEnd; ++aIt )
2691 0 : if( *aIt != 0 )
2692 0 : aSelVec.push_back( static_cast< sal_Int16 >( aIt - aBeg ) );
2693 : }
2694 : // single selection: mnSelEntry is one-based, API expects zero-based
2695 0 : else if( mnSelEntry > 0 )
2696 0 : aSelVec.push_back( static_cast< sal_Int16 >( mnSelEntry - 1 ) );
2697 :
2698 0 : if( !aSelVec.empty() )
2699 : {
2700 0 : Sequence< sal_Int16 > aSelSeq( &aSelVec.front(), static_cast< sal_Int32 >( aSelVec.size() ) );
2701 0 : rPropSet.SetProperty( "DefaultSelection", aSelSeq );
2702 0 : }
2703 : }
2704 0 : }
2705 :
2706 0 : OUString XclImpListBoxObj::DoGetServiceName() const
2707 : {
2708 0 : return OUString( "com.sun.star.form.component.ListBox" );
2709 : }
2710 :
2711 0 : XclTbxEventType XclImpListBoxObj::DoGetEventType() const
2712 : {
2713 0 : return EXC_TBX_EVENT_CHANGE;
2714 : }
2715 :
2716 0 : XclImpDropDownObj::XclImpDropDownObj( const XclImpRoot& rRoot ) :
2717 : XclImpTbxObjListBase( rRoot ),
2718 : mnLeft( 0 ),
2719 : mnTop( 0 ),
2720 : mnRight( 0 ),
2721 : mnBottom( 0 ),
2722 : mnDropDownFlags( 0 ),
2723 : mnLineCount( 0 ),
2724 0 : mnMinWidth( 0 )
2725 : {
2726 0 : }
2727 :
2728 0 : sal_uInt16 XclImpDropDownObj::GetDropDownType() const
2729 : {
2730 0 : return ::extract_value< sal_uInt8 >( mnDropDownFlags, 0, 2 );
2731 : }
2732 :
2733 0 : void XclImpDropDownObj::ReadFullLbsData( XclImpStream& rStrm )
2734 : {
2735 0 : ReadLbsData( rStrm );
2736 0 : rStrm >> mnDropDownFlags >> mnLineCount >> mnMinWidth >> maTextData.maData.mnTextLen;
2737 0 : maTextData.ReadByteString( rStrm );
2738 : // dropdowns of auto-filters have 'simple' style, they don't have a text area
2739 0 : if( GetDropDownType() == EXC_OBJ_DROPDOWN_SIMPLE )
2740 0 : SetProcessSdrObj( false );
2741 0 : }
2742 :
2743 0 : void XclImpDropDownObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 /*nMacroSize*/ )
2744 : {
2745 0 : ReadFrameData( rStrm );
2746 0 : ReadSbs( rStrm );
2747 0 : rStrm.Ignore( 18 );
2748 0 : rStrm >> maTextData.maData.mnDefFontIdx;
2749 0 : rStrm.Ignore( 14 );
2750 0 : rStrm >> mnLeft >> mnTop >> mnRight >> mnBottom;
2751 0 : rStrm.Ignore( 4 );
2752 0 : ReadName5( rStrm, nNameLen );
2753 0 : ReadMacro5( rStrm, rStrm.ReaduInt16() ); // fist macro size invalid and unused
2754 0 : ReadCellLinkFormula( rStrm, true );
2755 0 : ReadFullLbsData( rStrm );
2756 0 : mbHasDefFontIdx = true;
2757 0 : }
2758 :
2759 0 : void XclImpDropDownObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2760 : {
2761 0 : switch( nSubRecId )
2762 : {
2763 : case EXC_ID_OBJLBSDATA:
2764 0 : ReadFullLbsData( rStrm );
2765 0 : break;
2766 : default:
2767 0 : XclImpTbxObjListBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2768 : }
2769 0 : }
2770 :
2771 0 : void XclImpDropDownObj::DoProcessControl( ScfPropertySet& rPropSet ) const
2772 : {
2773 : // dropdown listbox formatting
2774 0 : SetBoxFormatting( rPropSet );
2775 : // enable dropdown button
2776 0 : rPropSet.SetBoolProperty( "Dropdown", true );
2777 : // dropdown line count
2778 0 : rPropSet.SetProperty( "LineCount", mnLineCount );
2779 :
2780 0 : if( GetDropDownType() == EXC_OBJ_DROPDOWN_COMBOBOX )
2781 : {
2782 : // text of editable combobox
2783 0 : if( maTextData.mxString )
2784 0 : rPropSet.SetStringProperty( "DefaultText", maTextData.mxString->GetText() );
2785 : }
2786 : else
2787 : {
2788 : // selection (do not set, if dropdown is linked to a cell)
2789 0 : if( !HasCellLink() && (mnSelEntry > 0) )
2790 : {
2791 0 : Sequence< sal_Int16 > aSelSeq( 1 );
2792 0 : aSelSeq[ 0 ] = mnSelEntry - 1;
2793 0 : rPropSet.SetProperty( "DefaultSelection", aSelSeq );
2794 : }
2795 : }
2796 0 : }
2797 :
2798 0 : OUString XclImpDropDownObj::DoGetServiceName() const
2799 : {
2800 0 : return (GetDropDownType() == EXC_OBJ_DROPDOWN_COMBOBOX) ?
2801 : OUString( "com.sun.star.form.component.ComboBox" ) :
2802 0 : OUString( "com.sun.star.form.component.ListBox" );
2803 : }
2804 :
2805 0 : XclTbxEventType XclImpDropDownObj::DoGetEventType() const
2806 : {
2807 0 : return (GetDropDownType() == EXC_OBJ_DROPDOWN_COMBOBOX) ? EXC_TBX_EVENT_TEXT : EXC_TBX_EVENT_CHANGE;
2808 : }
2809 :
2810 0 : XclImpPictureObj::XclImpPictureObj( const XclImpRoot& rRoot ) :
2811 : XclImpRectObj( rRoot ),
2812 : XclImpControlHelper( rRoot, EXC_CTRL_BINDCONTENT ),
2813 : mnStorageId( 0 ),
2814 : mnCtlsStrmPos( 0 ),
2815 : mnCtlsStrmSize( 0 ),
2816 : mbEmbedded( false ),
2817 : mbLinked( false ),
2818 : mbSymbol( false ),
2819 : mbControl( false ),
2820 0 : mbUseCtlsStrm( false )
2821 : {
2822 0 : SetAreaObj( true );
2823 0 : SetSimpleMacro( true );
2824 0 : SetCustomDffObj( true );
2825 0 : }
2826 :
2827 0 : OUString XclImpPictureObj::GetOleStorageName() const
2828 : {
2829 0 : OUString aStrgName;
2830 0 : if( (mbEmbedded || mbLinked) && !mbControl && (mnStorageId > 0) )
2831 : {
2832 0 : aStrgName = mbEmbedded ? EXC_STORAGE_OLE_EMBEDDED : EXC_STORAGE_OLE_LINKED;
2833 : static const sal_Char spcHexChars[] = "0123456789ABCDEF";
2834 0 : for( sal_uInt8 nIndex = 32; nIndex > 0; nIndex -= 4 )
2835 0 : aStrgName += OUString( sal_Unicode( spcHexChars[ ::extract_value< sal_uInt8 >( mnStorageId, nIndex - 4, 4 ) ] ) );
2836 : }
2837 0 : return aStrgName;
2838 : }
2839 :
2840 0 : void XclImpPictureObj::DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize )
2841 : {
2842 : sal_uInt16 nLinkSize;
2843 0 : ReadFrameData( rStrm );
2844 0 : rStrm.Ignore( 6 );
2845 0 : rStrm >> nLinkSize;
2846 0 : rStrm.Ignore( 2 );
2847 0 : ReadFlags3( rStrm );
2848 0 : ReadMacro3( rStrm, nMacroSize );
2849 0 : ReadPictFmla( rStrm, nLinkSize );
2850 :
2851 0 : if( (rStrm.GetNextRecId() == EXC_ID3_IMGDATA) && rStrm.StartNextRecord() )
2852 0 : maGraphic = XclImpDrawing::ReadImgData( GetRoot(), rStrm );
2853 0 : }
2854 :
2855 0 : void XclImpPictureObj::DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize )
2856 : {
2857 : sal_uInt16 nLinkSize;
2858 0 : ReadFrameData( rStrm );
2859 0 : rStrm.Ignore( 6 );
2860 0 : rStrm >> nLinkSize;
2861 0 : rStrm.Ignore( 2 );
2862 0 : ReadFlags3( rStrm );
2863 0 : ReadMacro4( rStrm, nMacroSize );
2864 0 : ReadPictFmla( rStrm, nLinkSize );
2865 :
2866 0 : if( (rStrm.GetNextRecId() == EXC_ID3_IMGDATA) && rStrm.StartNextRecord() )
2867 0 : maGraphic = XclImpDrawing::ReadImgData( GetRoot(), rStrm );
2868 0 : }
2869 :
2870 0 : void XclImpPictureObj::DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize )
2871 : {
2872 : sal_uInt16 nLinkSize;
2873 0 : ReadFrameData( rStrm );
2874 0 : rStrm.Ignore( 6 );
2875 0 : rStrm >> nLinkSize;
2876 0 : rStrm.Ignore( 2 );
2877 0 : ReadFlags3( rStrm );
2878 0 : rStrm.Ignore( 4 );
2879 0 : ReadName5( rStrm, nNameLen );
2880 0 : ReadMacro5( rStrm, nMacroSize );
2881 0 : ReadPictFmla( rStrm, nLinkSize );
2882 :
2883 0 : if( (rStrm.GetNextRecId() == EXC_ID3_IMGDATA) && rStrm.StartNextRecord() )
2884 : {
2885 : // page background is stored as hidden picture with name "__BkgndObj"
2886 0 : if ( IsHidden() && (GetObjName() == "__BkgndObj") )
2887 0 : GetPageSettings().ReadImgData( rStrm );
2888 : else
2889 0 : maGraphic = XclImpDrawing::ReadImgData( GetRoot(), rStrm );
2890 : }
2891 0 : }
2892 :
2893 0 : void XclImpPictureObj::DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize )
2894 : {
2895 0 : switch( nSubRecId )
2896 : {
2897 : case EXC_ID_OBJFLAGS:
2898 0 : ReadFlags8( rStrm );
2899 0 : break;
2900 : case EXC_ID_OBJPICTFMLA:
2901 0 : ReadPictFmla( rStrm, rStrm.ReaduInt16() );
2902 0 : break;
2903 : default:
2904 0 : XclImpDrawObjBase::DoReadObj8SubRec( rStrm, nSubRecId, nSubRecSize );
2905 : }
2906 0 : }
2907 :
2908 0 : SdrObject* XclImpPictureObj::DoCreateSdrObj( XclImpDffConverter& rDffConv, const Rectangle& rAnchorRect ) const
2909 : {
2910 : // try to create an OLE object or form control
2911 0 : SdrObjectPtr xSdrObj( rDffConv.CreateSdrObject( *this, rAnchorRect ) );
2912 :
2913 : // insert a graphic replacement for unsupported ole object ( if none already
2914 : // exists ) Hmm ok, it's possibly that there has been some imported
2915 : // graphic at a base level but unlikely, normally controls have a valid
2916 : // preview in the IMGDATA record ( see below )
2917 : // It might be possible to push such an imported graphic up to this
2918 : // XclImpPictureObj instance but there are somany layers of indirection I
2919 : // don't see an easy way. This way at least ensures that we can
2920 : // avoid a 'blank' shape that can result from a failed control import
2921 0 : if ( !xSdrObj && IsOcxControl() && maGraphic.GetType() == GRAPHIC_NONE )
2922 : {
2923 0 : const_cast< XclImpPictureObj* >( this )->maGraphic =
2924 0 : SdrOle2Obj::GetEmptyOLEReplacementGraphic();
2925 : }
2926 : // no OLE - create a plain picture from IMGDATA record data
2927 0 : if( !xSdrObj && (maGraphic.GetType() != GRAPHIC_NONE) )
2928 : {
2929 0 : xSdrObj.reset( new SdrGrafObj( maGraphic, rAnchorRect ) );
2930 0 : ConvertRectStyle( *xSdrObj );
2931 : }
2932 :
2933 0 : rDffConv.Progress();
2934 0 : return xSdrObj.release();
2935 : }
2936 :
2937 0 : OUString XclImpPictureObj::GetObjName() const
2938 : {
2939 0 : if( IsOcxControl() )
2940 : {
2941 0 : OUString sName( GetObjectManager().GetOleNameOverride( GetTab(), GetObjId() ) );
2942 0 : if (!sName.isEmpty())
2943 0 : return sName;
2944 : }
2945 0 : return XclImpDrawObjBase::GetObjName();
2946 : }
2947 :
2948 0 : void XclImpPictureObj::DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
2949 : {
2950 0 : if( IsOcxControl() )
2951 : {
2952 : // do not call XclImpRectObj::DoPreProcessSdrObj(), it would trace missing "printable" feature
2953 0 : ProcessControl( *this );
2954 : }
2955 0 : else if( mbEmbedded || mbLinked )
2956 : {
2957 : // trace missing "printable" feature
2958 0 : XclImpRectObj::DoPreProcessSdrObj( rDffConv, rSdrObj );
2959 :
2960 0 : SfxObjectShell* pDocShell = GetDocShell();
2961 0 : SdrOle2Obj* pOleSdrObj = dynamic_cast< SdrOle2Obj* >( &rSdrObj );
2962 0 : if( pOleSdrObj && pDocShell )
2963 : {
2964 0 : comphelper::EmbeddedObjectContainer& rEmbObjCont = pDocShell->GetEmbeddedObjectContainer();
2965 0 : Reference< XEmbeddedObject > xEmbObj = pOleSdrObj->GetObjRef();
2966 0 : OUString aOldName( pOleSdrObj->GetPersistName() );
2967 :
2968 : /* The object persistence should be already in the storage, but
2969 : the object still might not be inserted into the container. */
2970 0 : if( rEmbObjCont.HasEmbeddedObject( aOldName ) )
2971 : {
2972 0 : if( !rEmbObjCont.HasEmbeddedObject( xEmbObj ) )
2973 : // filter code is allowed to call the following method
2974 0 : rEmbObjCont.AddEmbeddedObject( xEmbObj, aOldName );
2975 : }
2976 : else
2977 : {
2978 : /* If the object is still not in container it must be inserted
2979 : there, the name must be generated in this case. */
2980 0 : OUString aNewName;
2981 0 : rEmbObjCont.InsertEmbeddedObject( xEmbObj, aNewName );
2982 0 : if( aOldName != aNewName )
2983 : // SetPersistName, not SetName
2984 0 : pOleSdrObj->SetPersistName( aNewName );
2985 0 : }
2986 : }
2987 : }
2988 0 : }
2989 :
2990 0 : void XclImpPictureObj::ReadFlags3( XclImpStream& rStrm )
2991 : {
2992 : sal_uInt16 nFlags;
2993 0 : rStrm >> nFlags;
2994 0 : mbSymbol = ::get_flag( nFlags, EXC_OBJ_PIC_SYMBOL );
2995 0 : }
2996 :
2997 0 : void XclImpPictureObj::ReadFlags8( XclImpStream& rStrm )
2998 : {
2999 : sal_uInt16 nFlags;
3000 0 : rStrm >> nFlags;
3001 0 : mbSymbol = ::get_flag( nFlags, EXC_OBJ_PIC_SYMBOL );
3002 0 : mbControl = ::get_flag( nFlags, EXC_OBJ_PIC_CONTROL );
3003 0 : mbUseCtlsStrm = ::get_flag( nFlags, EXC_OBJ_PIC_CTLSSTREAM );
3004 : OSL_ENSURE( mbControl || !mbUseCtlsStrm, "XclImpPictureObj::ReadFlags8 - CTLS stream for controls only" );
3005 0 : SetProcessSdrObj( mbControl || !mbUseCtlsStrm );
3006 0 : }
3007 :
3008 0 : void XclImpPictureObj::ReadPictFmla( XclImpStream& rStrm, sal_uInt16 nLinkSize )
3009 : {
3010 0 : sal_Size nLinkEnd = rStrm.GetRecPos() + nLinkSize;
3011 0 : if( nLinkSize >= 6 )
3012 : {
3013 : sal_uInt16 nFmlaSize;
3014 0 : rStrm >> nFmlaSize;
3015 : OSL_ENSURE( nFmlaSize > 0, "XclImpPictureObj::ReadPictFmla - missing link formula" );
3016 : // BIFF3/BIFF4 do not support storages, nothing to do here
3017 0 : if( (nFmlaSize > 0) && (GetBiff() >= EXC_BIFF5) )
3018 : {
3019 0 : rStrm.Ignore( 4 );
3020 : sal_uInt8 nToken;
3021 0 : rStrm >> nToken;
3022 :
3023 : // different processing for linked vs. embedded OLE objects
3024 0 : if( nToken == XclTokenArrayHelper::GetTokenId( EXC_TOKID_NAMEX, EXC_TOKCLASS_REF ) )
3025 : {
3026 0 : mbLinked = true;
3027 0 : switch( GetBiff() )
3028 : {
3029 : case EXC_BIFF5:
3030 : {
3031 : sal_Int16 nRefIdx;
3032 : sal_uInt16 nNameIdx;
3033 0 : rStrm >> nRefIdx;
3034 0 : rStrm.Ignore( 8 );
3035 0 : rStrm >> nNameIdx;
3036 0 : rStrm.Ignore( 12 );
3037 0 : const ExtName* pExtName = GetOldRoot().pExtNameBuff->GetNameByIndex( nRefIdx, nNameIdx );
3038 0 : if( pExtName && pExtName->IsOLE() )
3039 0 : mnStorageId = pExtName->nStorageId;
3040 : }
3041 0 : break;
3042 : case EXC_BIFF8:
3043 : {
3044 : sal_uInt16 nXti, nExtName;
3045 0 : rStrm >> nXti >> nExtName;
3046 0 : const XclImpExtName* pExtName = GetLinkManager().GetExternName( nXti, nExtName );
3047 0 : if( pExtName && (pExtName->GetType() == xlExtOLE) )
3048 0 : mnStorageId = pExtName->GetStorageId();
3049 : }
3050 0 : break;
3051 : default:
3052 : DBG_ERROR_BIFF();
3053 : }
3054 : }
3055 0 : else if( nToken == XclTokenArrayHelper::GetTokenId( EXC_TOKID_TBL, EXC_TOKCLASS_NONE ) )
3056 : {
3057 0 : mbEmbedded = true;
3058 : OSL_ENSURE( nFmlaSize == 5, "XclImpPictureObj::ReadPictFmla - unexpected formula size" );
3059 0 : rStrm.Ignore( nFmlaSize - 1 ); // token ID already read
3060 0 : if( nFmlaSize & 1 )
3061 0 : rStrm.Ignore( 1 ); // padding byte
3062 :
3063 : // a class name may follow inside the picture link
3064 0 : if( rStrm.GetRecPos() + 2 <= nLinkEnd )
3065 : {
3066 : sal_uInt16 nLen;
3067 0 : rStrm >> nLen;
3068 0 : if( nLen > 0 )
3069 0 : maClassName = (GetBiff() == EXC_BIFF8) ? rStrm.ReadUniString( nLen ) : rStrm.ReadRawByteString( nLen );
3070 : }
3071 : }
3072 : // else: ignore other formulas, e.g. pictures linked to cell ranges
3073 : }
3074 : }
3075 :
3076 : // seek behind picture link data
3077 0 : rStrm.Seek( nLinkEnd );
3078 :
3079 : // read additional data for embedded OLE objects following the picture link
3080 0 : if( IsOcxControl() )
3081 : {
3082 : // #i26521# form controls to be ignored
3083 0 : if( maClassName == "Forms.HTML:Hidden.1" )
3084 : {
3085 0 : SetProcessSdrObj( false );
3086 0 : return;
3087 : }
3088 :
3089 0 : if( rStrm.GetRecLeft() <= 8 ) return;
3090 :
3091 : // position and size of control data in 'Ctls' stream
3092 0 : mnCtlsStrmPos = static_cast< sal_Size >( rStrm.ReaduInt32() );
3093 0 : mnCtlsStrmSize = static_cast< sal_Size >( rStrm.ReaduInt32() );
3094 :
3095 0 : if( rStrm.GetRecLeft() <= 8 ) return;
3096 :
3097 : // additional string (16-bit characters), e.g. for progress bar control
3098 : sal_uInt32 nAddStrSize;
3099 0 : rStrm >> nAddStrSize;
3100 : OSL_ENSURE( rStrm.GetRecLeft() >= nAddStrSize + 4, "XclImpPictureObj::ReadPictFmla - missing data" );
3101 0 : if( rStrm.GetRecLeft() >= nAddStrSize + 4 )
3102 : {
3103 0 : rStrm.Ignore( nAddStrSize );
3104 : // cell link and source range
3105 0 : ReadCellLinkFormula( rStrm, true );
3106 0 : ReadSourceRangeFormula( rStrm, true );
3107 : }
3108 : }
3109 0 : else if( mbEmbedded && (rStrm.GetRecLeft() >= 4) )
3110 : {
3111 0 : rStrm >> mnStorageId;
3112 : }
3113 : }
3114 :
3115 : // DFF stream conversion ======================================================
3116 :
3117 0 : void XclImpSolverContainer::InsertSdrObjectInfo( SdrObject& rSdrObj, sal_uInt32 nDffShapeId, sal_uInt32 nDffFlags )
3118 : {
3119 0 : if( nDffShapeId > 0 )
3120 : {
3121 0 : maSdrInfoMap[ nDffShapeId ].Set( &rSdrObj, nDffFlags );
3122 0 : maSdrObjMap[ &rSdrObj ] = nDffShapeId;
3123 : }
3124 0 : }
3125 :
3126 0 : void XclImpSolverContainer::RemoveSdrObjectInfo( SdrObject& rSdrObj )
3127 : {
3128 : // remove info of passed object from the maps
3129 0 : XclImpSdrObjMap::iterator aIt = maSdrObjMap.find( &rSdrObj );
3130 0 : if( aIt != maSdrObjMap.end() )
3131 : {
3132 0 : maSdrInfoMap.erase( aIt->second );
3133 0 : maSdrObjMap.erase( aIt );
3134 : }
3135 :
3136 : // remove info of all child objects of a group object
3137 0 : if( SdrObjGroup* pGroupObj = dynamic_cast< SdrObjGroup* >( &rSdrObj ) )
3138 : {
3139 0 : if( SdrObjList* pSubList = pGroupObj->GetSubList() )
3140 : {
3141 : // iterate flat over the list because this function already works recursively
3142 0 : SdrObjListIter aObjIt( *pSubList, IM_FLAT );
3143 0 : for( SdrObject* pChildObj = aObjIt.Next(); pChildObj; pChildObj = aObjIt.Next() )
3144 0 : RemoveSdrObjectInfo( *pChildObj );
3145 : }
3146 : }
3147 0 : }
3148 :
3149 0 : void XclImpSolverContainer::UpdateConnectorRules()
3150 : {
3151 0 : for ( size_t i = 0, n = aCList.size(); i < n; ++i )
3152 : {
3153 0 : SvxMSDffConnectorRule* pRule = aCList[ i ];
3154 0 : UpdateConnection( pRule->nShapeA, pRule->pAObj, &pRule->nSpFlagsA );
3155 0 : UpdateConnection( pRule->nShapeB, pRule->pBObj, &pRule->nSpFlagsB );
3156 0 : UpdateConnection( pRule->nShapeC, pRule->pCObj );
3157 : }
3158 0 : }
3159 :
3160 0 : void XclImpSolverContainer::RemoveConnectorRules()
3161 : {
3162 : // base class from SVX uses plain untyped tools/List
3163 0 : for ( size_t i = 0, n = aCList.size(); i < n; ++i ) {
3164 0 : delete aCList[ i ];
3165 : }
3166 0 : aCList.clear();
3167 0 : maSdrInfoMap.clear();
3168 0 : maSdrObjMap.clear();
3169 0 : }
3170 :
3171 0 : void XclImpSolverContainer::UpdateConnection( sal_uInt32 nDffShapeId, SdrObject*& rpSdrObj, sal_uInt32* pnDffFlags )
3172 : {
3173 0 : XclImpSdrInfoMap::const_iterator aIt = maSdrInfoMap.find( nDffShapeId );
3174 0 : if( aIt != maSdrInfoMap.end() )
3175 : {
3176 0 : rpSdrObj = aIt->second.mpSdrObj;
3177 0 : if( pnDffFlags )
3178 0 : *pnDffFlags = aIt->second.mnDffFlags;
3179 : }
3180 0 : }
3181 :
3182 0 : XclImpSimpleDffConverter::XclImpSimpleDffConverter( const XclImpRoot& rRoot, SvStream& rDffStrm ) :
3183 0 : SvxMSDffManager( rDffStrm, rRoot.GetBasePath(), 0, 0, rRoot.GetDoc().GetDrawLayer(), 1440, COL_DEFAULT, 24, 0 ),
3184 0 : XclImpRoot( rRoot )
3185 : {
3186 0 : SetSvxMSDffSettings( SVXMSDFF_SETTINGS_CROP_BITMAPS | SVXMSDFF_SETTINGS_IMPORT_EXCEL );
3187 0 : }
3188 :
3189 0 : XclImpSimpleDffConverter::~XclImpSimpleDffConverter()
3190 : {
3191 0 : }
3192 :
3193 0 : bool XclImpSimpleDffConverter::GetColorFromPalette( sal_uInt16 nIndex, Color& rColor ) const
3194 : {
3195 0 : ColorData nColor = GetPalette().GetColorData( static_cast< sal_uInt16 >( nIndex ) );
3196 :
3197 0 : if( nColor == COL_AUTO )
3198 0 : return false;
3199 :
3200 0 : rColor.SetColor( nColor );
3201 0 : return true;
3202 : }
3203 :
3204 0 : XclImpDffConverter::XclImpDffConvData::XclImpDffConvData(
3205 : XclImpDrawing& rDrawing, SdrModel& rSdrModel, SdrPage& rSdrPage ) :
3206 : mrDrawing( rDrawing ),
3207 : mrSdrModel( rSdrModel ),
3208 : mrSdrPage( rSdrPage ),
3209 : mnLastCtrlIndex( -1 ),
3210 0 : mbHasCtrlForm( false )
3211 : {
3212 0 : }
3213 :
3214 :
3215 0 : XclImpDffConverter::XclImpDffConverter( const XclImpRoot& rRoot, SvStream& rDffStrm ) :
3216 : XclImpSimpleDffConverter( rRoot, rDffStrm ),
3217 : oox::ole::MSConvertOCXControls( rRoot.GetDocShell()->GetModel() ),
3218 : maStdFormName( "Standard" ),
3219 0 : mnOleImpFlags( 0 )
3220 : {
3221 0 : const SvtFilterOptions& rFilterOpt = SvtFilterOptions::Get();
3222 0 : if( rFilterOpt.IsMathType2Math() )
3223 0 : mnOleImpFlags |= OLE_MATHTYPE_2_STARMATH;
3224 0 : if( rFilterOpt.IsWinWord2Writer() )
3225 0 : mnOleImpFlags |= OLE_WINWORD_2_STARWRITER;
3226 0 : if( rFilterOpt.IsPowerPoint2Impress() )
3227 0 : mnOleImpFlags |= OLE_POWERPOINT_2_STARIMPRESS;
3228 :
3229 : // try to open the 'Ctls' storage stream containing OCX control properties
3230 0 : mxCtlsStrm = OpenStream( EXC_STREAM_CTLS );
3231 :
3232 : // default text margin (convert EMU to drawing layer units)
3233 0 : mnDefTextMargin = EXC_OBJ_TEXT_MARGIN;
3234 0 : ScaleEmu( mnDefTextMargin );
3235 0 : }
3236 :
3237 0 : XclImpDffConverter::~XclImpDffConverter()
3238 : {
3239 0 : }
3240 :
3241 0 : OUString XclImpObjectManager::GetOleNameOverride( SCTAB nTab, sal_uInt16 nObjId )
3242 : {
3243 0 : OUString sOleName;
3244 0 : OUString sCodeName = GetExtDocOptions().GetCodeName( nTab );
3245 :
3246 0 : if (mxOleCtrlNameOverride.is() && mxOleCtrlNameOverride->hasByName(sCodeName))
3247 : {
3248 0 : Reference< XIndexContainer > xIdToOleName;
3249 0 : mxOleCtrlNameOverride->getByName( sCodeName ) >>= xIdToOleName;
3250 0 : xIdToOleName->getByIndex( nObjId ) >>= sOleName;
3251 : }
3252 : OSL_TRACE("XclImpObjectManager::GetOleNameOverride tab %d, ( module %s ) object id ( %d ) is %s", nTab,
3253 : OUStringToOString( sCodeName, RTL_TEXTENCODING_UTF8 ).getStr(), nObjId,
3254 : OUStringToOString( sOleName, RTL_TEXTENCODING_UTF8 ).getStr() );
3255 :
3256 0 : return sOleName;
3257 : }
3258 :
3259 0 : void XclImpDffConverter::StartProgressBar( sal_Size nProgressSize )
3260 : {
3261 0 : mxProgress.reset( new ScfProgressBar( GetDocShell(), STR_PROGRESS_CALCULATING ) );
3262 0 : mxProgress->AddSegment( nProgressSize );
3263 0 : mxProgress->Activate();
3264 0 : }
3265 :
3266 0 : void XclImpDffConverter::Progress( sal_Size nDelta )
3267 : {
3268 : OSL_ENSURE( mxProgress, "XclImpDffConverter::Progress - invalid call, no progress bar" );
3269 0 : mxProgress->Progress( nDelta );
3270 0 : }
3271 :
3272 0 : void XclImpDffConverter::InitializeDrawing( XclImpDrawing& rDrawing, SdrModel& rSdrModel, SdrPage& rSdrPage )
3273 : {
3274 0 : XclImpDffConvDataRef xConvData( new XclImpDffConvData( rDrawing, rSdrModel, rSdrPage ) );
3275 0 : maDataStack.push_back( xConvData );
3276 0 : SetModel( &xConvData->mrSdrModel, 1440 );
3277 0 : }
3278 :
3279 0 : void XclImpDffConverter::ProcessObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj )
3280 : {
3281 0 : if( rDrawObj.IsProcessSdrObj() )
3282 : {
3283 0 : if( const XclObjAnchor* pAnchor = rDrawObj.GetAnchor() )
3284 : {
3285 0 : Rectangle aAnchorRect = GetConvData().mrDrawing.CalcAnchorRect( *pAnchor, false );
3286 0 : if( rDrawObj.IsValidSize( aAnchorRect ) )
3287 : {
3288 : // CreateSdrObject() recursively creates embedded child objects
3289 0 : SdrObjectPtr xSdrObj( rDrawObj.CreateSdrObject( *this, aAnchorRect, false ) );
3290 0 : if( xSdrObj.is() )
3291 0 : rDrawObj.PreProcessSdrObject( *this, *xSdrObj );
3292 : // call InsertSdrObject() also, if SdrObject is missing
3293 0 : InsertSdrObject( rObjList, rDrawObj, xSdrObj.release() );
3294 : }
3295 : }
3296 : }
3297 0 : }
3298 :
3299 0 : void XclImpDffConverter::ProcessDrawing( const XclImpDrawObjVector& rDrawObjs )
3300 : {
3301 0 : SdrPage& rSdrPage = GetConvData().mrSdrPage;
3302 0 : for( XclImpDrawObjVector::const_iterator aIt = rDrawObjs.begin(), aEnd = rDrawObjs.end(); aIt != aEnd; ++aIt )
3303 0 : ProcessObject( rSdrPage, **aIt );
3304 0 : }
3305 :
3306 0 : void XclImpDffConverter::ProcessDrawing( SvStream& rDffStrm )
3307 : {
3308 0 : rDffStrm.Seek( STREAM_SEEK_TO_END );
3309 0 : if( rDffStrm.Tell() > 0 )
3310 : {
3311 0 : rDffStrm.Seek( STREAM_SEEK_TO_BEGIN );
3312 0 : DffRecordHeader aHeader;
3313 0 : ReadDffRecordHeader( rDffStrm, aHeader );
3314 : OSL_ENSURE( aHeader.nRecType == DFF_msofbtDgContainer, "XclImpDffConverter::ProcessDrawing - unexpected record" );
3315 0 : if( aHeader.nRecType == DFF_msofbtDgContainer )
3316 0 : ProcessDgContainer( rDffStrm, aHeader );
3317 : }
3318 0 : }
3319 :
3320 0 : void XclImpDffConverter::FinalizeDrawing()
3321 : {
3322 : OSL_ENSURE( !maDataStack.empty(), "XclImpDffConverter::FinalizeDrawing - no drawing manager on stack" );
3323 0 : maDataStack.pop_back();
3324 : // restore previous model at core DFF converter
3325 0 : if( !maDataStack.empty() )
3326 0 : SetModel( &maDataStack.back()->mrSdrModel, 1440 );
3327 0 : }
3328 :
3329 0 : SdrObject* XclImpDffConverter::CreateSdrObject( const XclImpTbxObjBase& rTbxObj, const Rectangle& rAnchorRect )
3330 : {
3331 0 : SdrObjectPtr xSdrObj;
3332 :
3333 0 : OUString aServiceName = rTbxObj.GetServiceName();
3334 0 : if( SupportsOleObjects() && !aServiceName.isEmpty() ) try
3335 : {
3336 : // create the form control from scratch
3337 0 : Reference< XFormComponent > xFormComp( ScfApiHelper::CreateInstance( GetDocShell(), aServiceName ), UNO_QUERY_THROW );
3338 : // set controls form, needed in virtual function InsertControl()
3339 0 : InitControlForm();
3340 : // try to insert the control into the form
3341 0 : ::com::sun::star::awt::Size aDummySize;
3342 0 : Reference< XShape > xShape;
3343 0 : XclImpDffConvData& rConvData = GetConvData();
3344 0 : if( rConvData.mxCtrlForm.is() && InsertControl( xFormComp, aDummySize, &xShape, true ) )
3345 : {
3346 0 : xSdrObj.reset( rTbxObj.CreateSdrObjectFromShape( xShape, rAnchorRect ) );
3347 : // try to attach a macro to the control
3348 0 : ScriptEventDescriptor aDescriptor;
3349 0 : if( (rConvData.mnLastCtrlIndex >= 0) && rTbxObj.FillMacroDescriptor( aDescriptor ) )
3350 : {
3351 0 : Reference< XEventAttacherManager > xEventMgr( rConvData.mxCtrlForm, UNO_QUERY_THROW );
3352 0 : xEventMgr->registerScriptEvent( rConvData.mnLastCtrlIndex, aDescriptor );
3353 0 : }
3354 0 : }
3355 : }
3356 0 : catch( const Exception& )
3357 : {
3358 : }
3359 :
3360 0 : return xSdrObj.release();
3361 : }
3362 :
3363 0 : SdrObject* XclImpDffConverter::CreateSdrObject( const XclImpPictureObj& rPicObj, const Rectangle& rAnchorRect )
3364 : {
3365 0 : SdrObjectPtr xSdrObj;
3366 :
3367 0 : if( SupportsOleObjects() )
3368 : {
3369 0 : if( rPicObj.IsOcxControl() )
3370 : {
3371 0 : if( mxCtlsStrm.Is() ) try
3372 : {
3373 : /* set controls form, needed in virtual function InsertControl()
3374 : called from ReadOCXExcelKludgeStream() */
3375 0 : InitControlForm();
3376 :
3377 : // read from mxCtlsStrm into xShape, insert the control model into the form
3378 0 : Reference< XShape > xShape;
3379 0 : if( GetConvData().mxCtrlForm.is() )
3380 : {
3381 0 : Reference< XFormComponent > xFComp;
3382 0 : com::sun::star::awt::Size aSz; // not used in import
3383 0 : ReadOCXCtlsStream( mxCtlsStrm, xFComp, rPicObj.GetCtlsStreamPos(), rPicObj.GetCtlsStreamSize() );
3384 : // recreate the method formally known as
3385 : // ReadOCXExcelKludgeStream( )
3386 0 : if ( xFComp.is() )
3387 : {
3388 0 : ScfPropertySet aPropSet( xFComp );
3389 0 : aPropSet.SetStringProperty( "Name", rPicObj.GetObjName() );
3390 0 : InsertControl( xFComp, aSz,&xShape,true);
3391 0 : xSdrObj.reset( rPicObj.CreateSdrObjectFromShape( xShape, rAnchorRect ) );
3392 0 : }
3393 0 : }
3394 : }
3395 0 : catch( const Exception& )
3396 : {
3397 : }
3398 : }
3399 : else
3400 : {
3401 0 : SfxObjectShell* pDocShell = GetDocShell();
3402 0 : SotStorageRef xSrcStrg = GetRootStorage();
3403 0 : OUString aStrgName = rPicObj.GetOleStorageName();
3404 0 : if( pDocShell && xSrcStrg.Is() && (!aStrgName.isEmpty()) )
3405 : {
3406 : // first try to resolve graphic from DFF storage
3407 0 : Graphic aGraphic;
3408 0 : Rectangle aVisArea;
3409 0 : if( !GetBLIP( GetPropertyValue( DFF_Prop_pib ), aGraphic, &aVisArea ) )
3410 : {
3411 : // if not found, use graphic from object (imported from IMGDATA record)
3412 0 : aGraphic = rPicObj.GetGraphic();
3413 0 : aVisArea = rPicObj.GetVisArea();
3414 : }
3415 0 : if( aGraphic.GetType() != GRAPHIC_NONE )
3416 : {
3417 0 : ErrCode nError = ERRCODE_NONE;
3418 : namespace cssea = ::com::sun::star::embed::Aspects;
3419 0 : sal_Int64 nAspects = rPicObj.IsSymbol() ? cssea::MSOLE_ICON : cssea::MSOLE_CONTENT;
3420 : xSdrObj.reset( CreateSdrOLEFromStorage(
3421 : aStrgName, xSrcStrg, pDocShell->GetStorage(), aGraphic,
3422 0 : rAnchorRect, aVisArea, 0, nError, mnOleImpFlags, nAspects ) );
3423 0 : }
3424 0 : }
3425 : }
3426 : }
3427 :
3428 0 : return xSdrObj.release();
3429 : }
3430 :
3431 0 : bool XclImpDffConverter::SupportsOleObjects() const
3432 : {
3433 0 : return GetConvData().mrDrawing.SupportsOleObjects();
3434 : }
3435 :
3436 : // virtual functions ----------------------------------------------------------
3437 :
3438 0 : void XclImpDffConverter::ProcessClientAnchor2( SvStream& rDffStrm,
3439 : DffRecordHeader& rHeader, void* /*pClientData*/, DffObjData& rObjData )
3440 : {
3441 : // find the OBJ record data related to the processed shape
3442 0 : XclImpDffConvData& rConvData = GetConvData();
3443 0 : if( XclImpDrawObjBase* pDrawObj = rConvData.mrDrawing.FindDrawObj( rObjData.rSpHd ).get() )
3444 : {
3445 : OSL_ENSURE( rHeader.nRecType == DFF_msofbtClientAnchor, "XclImpDffConverter::ProcessClientAnchor2 - no client anchor record" );
3446 0 : XclObjAnchor aAnchor;
3447 0 : rHeader.SeekToContent( rDffStrm );
3448 0 : sal_uInt8 nFlags(0);
3449 0 : rDffStrm.ReadUChar( nFlags );
3450 0 : rDffStrm.SeekRel( 1 ); // flags
3451 0 : rDffStrm >> aAnchor; // anchor format equal to BIFF5 OBJ records
3452 :
3453 0 : pDrawObj->SetAnchor( aAnchor );
3454 0 : rObjData.aChildAnchor = rConvData.mrDrawing.CalcAnchorRect( aAnchor, true );
3455 0 : rObjData.bChildAnchor = true;
3456 : // page anchoring is the best approximation we have if mbMove
3457 : // is set
3458 0 : rObjData.bPageAnchor = ( nFlags & 0x1 );
3459 : }
3460 0 : }
3461 :
3462 0 : SdrObject* XclImpDffConverter::ProcessObj( SvStream& rDffStrm, DffObjData& rDffObjData,
3463 : void* pClientData, Rectangle& /*rTextRect*/, SdrObject* pOldSdrObj )
3464 : {
3465 0 : XclImpDffConvData& rConvData = GetConvData();
3466 :
3467 : /* pOldSdrObj passes a generated SdrObject. This function owns this object
3468 : and can modify it. The function has either to return it back to caller
3469 : or to delete it by itself. */
3470 0 : SdrObjectPtr xSdrObj( pOldSdrObj );
3471 :
3472 : // find the OBJ record data related to the processed shape
3473 0 : XclImpDrawObjRef xDrawObj = rConvData.mrDrawing.FindDrawObj( rDffObjData.rSpHd );
3474 0 : const Rectangle& rAnchorRect = rDffObjData.aChildAnchor;
3475 :
3476 : // Do not process the global page group shape (flag SP_FPATRIARCH)
3477 0 : bool bGlobalPageGroup = ::get_flag< sal_uInt32 >( rDffObjData.nSpFlags, SP_FPATRIARCH );
3478 0 : if( !xDrawObj || !xDrawObj->IsProcessSdrObj() || bGlobalPageGroup )
3479 0 : return 0; // simply return, xSdrObj will be destroyed
3480 :
3481 : /* Pass pointer to top-level object back to caller. If the processed
3482 : object is embedded in a group, the pointer is already set to the
3483 : top-level parent object. */
3484 0 : XclImpDrawObjBase** ppTopLevelObj = reinterpret_cast< XclImpDrawObjBase** >( pClientData );
3485 0 : bool bIsTopLevel = !ppTopLevelObj || !*ppTopLevelObj;
3486 0 : if( ppTopLevelObj && bIsTopLevel )
3487 0 : *ppTopLevelObj = xDrawObj.get();
3488 :
3489 : // connectors don't have to be area objects
3490 0 : if( dynamic_cast< SdrEdgeObj* >( xSdrObj.get() ) )
3491 0 : xDrawObj->SetAreaObj( false );
3492 :
3493 : /* Check for valid size for all objects. Needed to ignore lots of invisible
3494 : phantom objects from deleted rows or columns (for performance reasons).
3495 : #i30816# Include objects embedded in groups.
3496 : #i58780# Ignore group shapes, size is not initialized. */
3497 0 : bool bEmbeddedGroup = !bIsTopLevel && dynamic_cast< SdrObjGroup* >( xSdrObj.get() );
3498 0 : if( !bEmbeddedGroup && !xDrawObj->IsValidSize( rAnchorRect ) )
3499 0 : return 0; // simply return, xSdrObj will be destroyed
3500 :
3501 : // set shape information from DFF stream
3502 0 : OUString aObjName = GetPropertyString( DFF_Prop_wzName, rDffStrm );
3503 0 : OUString aHyperlink = ReadHlinkProperty( rDffStrm );
3504 0 : bool bVisible = !GetPropertyBool( DFF_Prop_fHidden );
3505 0 : bool bAutoMargin = GetPropertyBool( DFF_Prop_AutoTextMargin );
3506 0 : xDrawObj->SetDffData( rDffObjData, aObjName, aHyperlink, bVisible, bAutoMargin );
3507 :
3508 : /* Connect textbox data (string, alignment, text orientation) to object.
3509 : don't ask for a text-ID, DFF export doesn't set one. */
3510 0 : if( XclImpTextObj* pTextObj = dynamic_cast< XclImpTextObj* >( xDrawObj.get() ) )
3511 0 : if( const XclImpObjTextData* pTextData = rConvData.mrDrawing.FindTextData( rDffObjData.rSpHd ) )
3512 0 : pTextObj->SetTextData( *pTextData );
3513 :
3514 : // copy line and fill formatting of TBX form controls from DFF properties
3515 0 : if( XclImpTbxObjBase* pTbxObj = dynamic_cast< XclImpTbxObjBase* >( xDrawObj.get() ) )
3516 0 : pTbxObj->SetDffProperties( *this );
3517 :
3518 : // try to create a custom SdrObject that overwrites the passed object
3519 0 : SdrObjectPtr xNewSdrObj( xDrawObj->CreateSdrObject( *this, rAnchorRect, true ) );
3520 0 : if( xNewSdrObj.is() )
3521 0 : xSdrObj.reset( xNewSdrObj.release() );
3522 :
3523 : // process the SdrObject
3524 0 : if( xSdrObj.is() )
3525 : {
3526 : // cell anchoring
3527 0 : if ( !rDffObjData.bPageAnchor )
3528 0 : ScDrawLayer::SetCellAnchoredFromPosition( *xSdrObj, GetDoc(), xDrawObj->GetTab() );
3529 :
3530 : // filled without color -> set system window color
3531 0 : if( GetPropertyBool( DFF_Prop_fFilled ) && !IsProperty( DFF_Prop_fillColor ) )
3532 0 : xSdrObj->SetMergedItem( XFillColorItem( EMPTY_OUSTRING, GetPalette().GetColor( EXC_COLOR_WINDOWBACK ) ) );
3533 :
3534 : // additional processing on the SdrObject
3535 0 : xDrawObj->PreProcessSdrObject( *this, *xSdrObj );
3536 :
3537 : /* If the SdrObject will not be inserted into the draw page, delete it
3538 : here. Happens e.g. for notes: The PreProcessSdrObject() call above
3539 : has inserted the note into the document, and the SdrObject is not
3540 : needed anymore. */
3541 0 : if( !xDrawObj->IsInsertSdrObj() )
3542 0 : xSdrObj.reset();
3543 : }
3544 :
3545 0 : if( xSdrObj.is() )
3546 : {
3547 : /* Store the relation between shape ID and SdrObject for connectors.
3548 : Must be done here (and not in InsertSdrObject() function),
3549 : otherwise all SdrObjects embedded in groups would be lost. */
3550 0 : rConvData.maSolverCont.InsertSdrObjectInfo( *xSdrObj, xDrawObj->GetDffShapeId(), xDrawObj->GetDffFlags() );
3551 :
3552 : /* If the drawing object is embedded in a group object, call
3553 : PostProcessSdrObject() here. For top-level objects this will be
3554 : done automatically in InsertSdrObject() but grouped shapes are
3555 : inserted into their groups somewhere in the SvxMSDffManager base
3556 : class without chance of notification. Unfortunately, now this is
3557 : called before the object is really inserted into its group object,
3558 : but that should not have any effect for grouped objects. */
3559 0 : if( !bIsTopLevel )
3560 0 : xDrawObj->PostProcessSdrObject( *this, *xSdrObj );
3561 : }
3562 :
3563 0 : return xSdrObj.release();
3564 : }
3565 :
3566 0 : sal_uLong XclImpDffConverter::Calc_nBLIPPos( sal_uLong /*nOrgVal*/, sal_uLong nStreamPos ) const
3567 : {
3568 0 : return nStreamPos + 4;
3569 : }
3570 :
3571 0 : bool XclImpDffConverter::InsertControl( const Reference< XFormComponent >& rxFormComp,
3572 : const ::com::sun::star::awt::Size& /*rSize*/, Reference< XShape >* pxShape,
3573 : bool /*bFloatingCtrl*/ )
3574 : {
3575 0 : if( GetDocShell() ) try
3576 : {
3577 0 : XclImpDffConvData& rConvData = GetConvData();
3578 0 : Reference< XIndexContainer > xFormIC( rConvData.mxCtrlForm, UNO_QUERY_THROW );
3579 0 : Reference< XControlModel > xCtrlModel( rxFormComp, UNO_QUERY_THROW );
3580 :
3581 : // create the control shape
3582 0 : Reference< XShape > xShape( ScfApiHelper::CreateInstance( GetDocShell(), "com.sun.star.drawing.ControlShape" ), UNO_QUERY_THROW );
3583 0 : Reference< XControlShape > xCtrlShape( xShape, UNO_QUERY_THROW );
3584 :
3585 : // insert the new control into the form
3586 0 : sal_Int32 nNewIndex = xFormIC->getCount();
3587 0 : xFormIC->insertByIndex( nNewIndex, Any( rxFormComp ) );
3588 : // on success: store new index of the control for later use (macro events)
3589 0 : rConvData.mnLastCtrlIndex = nNewIndex;
3590 :
3591 : // set control model at control shape and pass back shape to caller
3592 0 : xCtrlShape->setControl( xCtrlModel );
3593 0 : if( pxShape ) *pxShape = xShape;
3594 0 : return true;
3595 : }
3596 0 : catch( const Exception& )
3597 : {
3598 : OSL_FAIL( "XclImpDffConverter::InsertControl - cannot create form control" );
3599 : }
3600 :
3601 0 : return false;
3602 : }
3603 :
3604 : // private --------------------------------------------------------------------
3605 :
3606 0 : XclImpDffConverter::XclImpDffConvData& XclImpDffConverter::GetConvData()
3607 : {
3608 : OSL_ENSURE( !maDataStack.empty(), "XclImpDffConverter::GetConvData - no drawing manager on stack" );
3609 0 : return *maDataStack.back();
3610 : }
3611 :
3612 0 : const XclImpDffConverter::XclImpDffConvData& XclImpDffConverter::GetConvData() const
3613 : {
3614 : OSL_ENSURE( !maDataStack.empty(), "XclImpDffConverter::GetConvData - no drawing manager on stack" );
3615 0 : return *maDataStack.back();
3616 : }
3617 :
3618 0 : OUString XclImpDffConverter::ReadHlinkProperty( SvStream& rDffStrm ) const
3619 : {
3620 : /* Reads hyperlink data from a complex DFF property. Contents of this
3621 : property are equal to the HLINK record, import of this record is
3622 : implemented in class XclImpHyperlink. This function has to create an
3623 : instance of the XclImpStream class to be able to reuse the
3624 : functionality of XclImpHyperlink. */
3625 0 : OUString aString;
3626 0 : sal_uInt32 nBufferSize = GetPropertyValue( DFF_Prop_pihlShape );
3627 0 : if( (0 < nBufferSize) && (nBufferSize <= 0xFFFF) && SeekToContent( DFF_Prop_pihlShape, rDffStrm ) )
3628 : {
3629 : // create a faked BIFF record that can be read by XclImpStream class
3630 0 : SvMemoryStream aMemStream;
3631 0 : aMemStream.WriteUInt16( sal_uInt16( 0 ) ).WriteUInt16( static_cast< sal_uInt16 >( nBufferSize ) );
3632 :
3633 : // copy from DFF stream to memory stream
3634 0 : ::std::vector< sal_uInt8 > aBuffer( nBufferSize );
3635 0 : sal_uInt8* pnData = &aBuffer.front();
3636 0 : if( rDffStrm.Read( pnData, nBufferSize ) == nBufferSize )
3637 : {
3638 0 : aMemStream.Write( pnData, nBufferSize );
3639 :
3640 : // create BIFF import stream to be able to use XclImpHyperlink class
3641 0 : XclImpStream aXclStrm( aMemStream, GetRoot() );
3642 0 : if( aXclStrm.StartNextRecord() )
3643 0 : aString = XclImpHyperlink::ReadEmbeddedData( aXclStrm );
3644 0 : }
3645 : }
3646 0 : return aString;
3647 : }
3648 :
3649 0 : void XclImpDffConverter::ProcessDgContainer( SvStream& rDffStrm, const DffRecordHeader& rDgHeader )
3650 : {
3651 0 : sal_Size nEndPos = rDgHeader.GetRecEndFilePos();
3652 0 : while( rDffStrm.Tell() < nEndPos )
3653 : {
3654 0 : DffRecordHeader aHeader;
3655 0 : ReadDffRecordHeader( rDffStrm, aHeader );
3656 0 : switch( aHeader.nRecType )
3657 : {
3658 : case DFF_msofbtSolverContainer:
3659 0 : ProcessSolverContainer( rDffStrm, aHeader );
3660 0 : break;
3661 : case DFF_msofbtSpgrContainer:
3662 0 : ProcessShGrContainer( rDffStrm, aHeader );
3663 0 : break;
3664 : default:
3665 0 : aHeader.SeekToEndOfRecord( rDffStrm );
3666 : }
3667 : }
3668 : // seek to end of drawing page container
3669 0 : rDgHeader.SeekToEndOfRecord( rDffStrm );
3670 :
3671 : // #i12638# #i37900# connector rules
3672 0 : XclImpSolverContainer& rSolverCont = GetConvData().maSolverCont;
3673 0 : rSolverCont.UpdateConnectorRules();
3674 0 : SolveSolver( rSolverCont );
3675 0 : rSolverCont.RemoveConnectorRules();
3676 0 : }
3677 :
3678 0 : void XclImpDffConverter::ProcessShGrContainer( SvStream& rDffStrm, const DffRecordHeader& rShGrHeader )
3679 : {
3680 0 : sal_Size nEndPos = rShGrHeader.GetRecEndFilePos();
3681 0 : while( rDffStrm.Tell() < nEndPos )
3682 : {
3683 0 : DffRecordHeader aHeader;
3684 0 : ReadDffRecordHeader( rDffStrm, aHeader );
3685 0 : switch( aHeader.nRecType )
3686 : {
3687 : case DFF_msofbtSpgrContainer:
3688 : case DFF_msofbtSpContainer:
3689 0 : ProcessShContainer( rDffStrm, aHeader );
3690 0 : break;
3691 : default:
3692 0 : aHeader.SeekToEndOfRecord( rDffStrm );
3693 : }
3694 : }
3695 : // seek to end of shape group container
3696 0 : rShGrHeader.SeekToEndOfRecord( rDffStrm );
3697 0 : }
3698 :
3699 0 : void XclImpDffConverter::ProcessSolverContainer( SvStream& rDffStrm, const DffRecordHeader& rSolverHeader )
3700 : {
3701 : // solver container wants to read the solver container header again
3702 0 : rSolverHeader.SeekToBegOfRecord( rDffStrm );
3703 : // read the entire solver container
3704 0 : ReadSvxMSDffSolverContainer( rDffStrm, GetConvData().maSolverCont );
3705 : // seek to end of solver container
3706 0 : rSolverHeader.SeekToEndOfRecord( rDffStrm );
3707 0 : }
3708 :
3709 0 : void XclImpDffConverter::ProcessShContainer( SvStream& rDffStrm, const DffRecordHeader& rShHeader )
3710 : {
3711 0 : rShHeader.SeekToBegOfRecord( rDffStrm );
3712 0 : Rectangle aDummy;
3713 0 : const XclImpDrawObjBase* pDrawObj = 0;
3714 : /* The call to ImportObj() creates and returns a new SdrObject for the
3715 : processed shape. We take ownership of the returned object here. If the
3716 : shape is a group object, all embedded objects are created recursively,
3717 : and the returned group object contains them all. ImportObj() calls the
3718 : virtual functions ProcessClientAnchor2() and ProcessObj() and writes
3719 : the pointer to the related draw object data (OBJ record) into pDrawObj. */
3720 0 : SdrObjectPtr xSdrObj( ImportObj( rDffStrm, &pDrawObj, aDummy, aDummy, 0, 0 ) );
3721 0 : if( pDrawObj && xSdrObj.is() )
3722 0 : InsertSdrObject( GetConvData().mrSdrPage, *pDrawObj, xSdrObj.release() );
3723 0 : rShHeader.SeekToEndOfRecord( rDffStrm );
3724 0 : }
3725 :
3726 0 : void XclImpDffConverter::InsertSdrObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj, SdrObject* pSdrObj )
3727 : {
3728 0 : XclImpDffConvData& rConvData = GetConvData();
3729 : /* Take ownership of the passed object. If insertion fails (e.g. rDrawObj
3730 : states to skip insertion), the object is automatically deleted. */
3731 0 : SdrObjectPtr xSdrObj( pSdrObj );
3732 0 : if( xSdrObj.is() && rDrawObj.IsInsertSdrObj() )
3733 : {
3734 0 : rObjList.NbcInsertObject( xSdrObj.release() );
3735 : // callback to drawing manager for e.g. tracking of used sheet area
3736 0 : rConvData.mrDrawing.OnObjectInserted( rDrawObj );
3737 : // callback to drawing object for post processing (use pSdrObj, xSdrObj already released)
3738 0 : rDrawObj.PostProcessSdrObject( *this, *pSdrObj );
3739 : }
3740 : /* SdrObject still here? Insertion failed, remove data from shape ID map.
3741 : The SdrObject will be destructed then. */
3742 0 : if( xSdrObj.is() )
3743 0 : rConvData.maSolverCont.RemoveSdrObjectInfo( *xSdrObj );
3744 0 : }
3745 :
3746 0 : void XclImpDffConverter::InitControlForm()
3747 : {
3748 0 : XclImpDffConvData& rConvData = GetConvData();
3749 0 : if( rConvData.mbHasCtrlForm )
3750 0 : return;
3751 :
3752 0 : rConvData.mbHasCtrlForm = true;
3753 0 : if( SupportsOleObjects() ) try
3754 : {
3755 0 : Reference< XFormsSupplier > xFormsSupplier( rConvData.mrSdrPage.getUnoPage(), UNO_QUERY_THROW );
3756 0 : Reference< XNameContainer > xFormsNC( xFormsSupplier->getForms(), UNO_SET_THROW );
3757 : // find or create the Standard form used to insert the imported controls
3758 0 : if( xFormsNC->hasByName( maStdFormName ) )
3759 : {
3760 0 : xFormsNC->getByName( maStdFormName ) >>= rConvData.mxCtrlForm;
3761 : }
3762 0 : else if( SfxObjectShell* pDocShell = GetDocShell() )
3763 : {
3764 0 : rConvData.mxCtrlForm.set( ScfApiHelper::CreateInstance( pDocShell, "com.sun.star.form.component.Form" ), UNO_QUERY_THROW );
3765 0 : xFormsNC->insertByName( maStdFormName, Any( rConvData.mxCtrlForm ) );
3766 0 : }
3767 : }
3768 0 : catch( const Exception& )
3769 : {
3770 : }
3771 : }
3772 :
3773 : // Drawing manager ============================================================
3774 :
3775 0 : XclImpDrawing::XclImpDrawing( const XclImpRoot& rRoot, bool bOleObjects ) :
3776 : XclImpRoot( rRoot ),
3777 0 : mbOleObjs( bOleObjects )
3778 : {
3779 0 : }
3780 :
3781 0 : XclImpDrawing::~XclImpDrawing()
3782 : {
3783 0 : }
3784 :
3785 0 : Graphic XclImpDrawing::ReadImgData( const XclImpRoot& rRoot, XclImpStream& rStrm )
3786 : {
3787 0 : Graphic aGraphic;
3788 : sal_uInt16 nFormat, nEnv;
3789 : sal_uInt32 nDataSize;
3790 0 : rStrm >> nFormat >> nEnv >> nDataSize;
3791 0 : if( nDataSize <= rStrm.GetRecLeft() )
3792 : {
3793 0 : switch( nFormat )
3794 : {
3795 0 : case EXC_IMGDATA_WMF: ReadWmf( aGraphic, rRoot, rStrm ); break;
3796 0 : case EXC_IMGDATA_BMP: ReadBmp( aGraphic, rRoot, rStrm ); break;
3797 : default: OSL_FAIL( "XclImpDrawing::ReadImgData - unknown image format" );
3798 : }
3799 : }
3800 0 : return aGraphic;
3801 : }
3802 :
3803 0 : void XclImpDrawing::ReadObj( XclImpStream& rStrm )
3804 : {
3805 0 : XclImpDrawObjRef xDrawObj;
3806 :
3807 : /* #i61786# In BIFF8 streams, OBJ records may occur without MSODRAWING
3808 : records. In this case, the OBJ records are in BIFF5 format. Do a sanity
3809 : check here that there is no DFF data loaded before. */
3810 : OSL_ENSURE( maDffStrm.Tell() == 0, "XclImpDrawing::ReadObj - unexpected DFF stream data, OBJ will be ignored" );
3811 0 : if( maDffStrm.Tell() == 0 ) switch( GetBiff() )
3812 : {
3813 : case EXC_BIFF3:
3814 0 : xDrawObj = XclImpDrawObjBase::ReadObj3( GetRoot(), rStrm );
3815 0 : break;
3816 : case EXC_BIFF4:
3817 0 : xDrawObj = XclImpDrawObjBase::ReadObj4( GetRoot(), rStrm );
3818 0 : break;
3819 : case EXC_BIFF5:
3820 : case EXC_BIFF8:
3821 0 : xDrawObj = XclImpDrawObjBase::ReadObj5( GetRoot(), rStrm );
3822 0 : break;
3823 : default:
3824 : DBG_ERROR_BIFF();
3825 : }
3826 :
3827 0 : if( xDrawObj )
3828 : {
3829 : // insert into maRawObjs or into the last open group object
3830 0 : maRawObjs.InsertGrouped( xDrawObj );
3831 : // to be able to find objects by ID
3832 0 : maObjMapId[ xDrawObj->GetObjId() ] = xDrawObj;
3833 0 : }
3834 0 : }
3835 :
3836 0 : void XclImpDrawing::ReadMsoDrawing( XclImpStream& rStrm )
3837 : {
3838 : OSL_ENSURE_BIFF( GetBiff() == EXC_BIFF8 );
3839 : // disable internal CONTINUE handling
3840 0 : rStrm.ResetRecord( false );
3841 : // read leading MSODRAWING record
3842 0 : ReadDffRecord( rStrm );
3843 :
3844 : // read following drawing records, but do not start following unrelated record
3845 0 : bool bLoop = true;
3846 0 : while( bLoop ) switch( rStrm.GetNextRecId() )
3847 : {
3848 : case EXC_ID_MSODRAWING:
3849 : case EXC_ID_MSODRAWINGSEL:
3850 : case EXC_ID_CONT:
3851 0 : rStrm.StartNextRecord();
3852 0 : ReadDffRecord( rStrm );
3853 0 : break;
3854 : case EXC_ID_OBJ:
3855 0 : rStrm.StartNextRecord();
3856 0 : ReadObj8( rStrm );
3857 0 : break;
3858 : case EXC_ID_TXO:
3859 0 : rStrm.StartNextRecord();
3860 0 : ReadTxo( rStrm );
3861 0 : break;
3862 : default:
3863 0 : bLoop = false;
3864 : }
3865 :
3866 : // re-enable internal CONTINUE handling
3867 0 : rStrm.ResetRecord( true );
3868 0 : }
3869 :
3870 0 : XclImpDrawObjRef XclImpDrawing::FindDrawObj( const DffRecordHeader& rHeader ) const
3871 : {
3872 : /* maObjMap stores objects by position of the client data (OBJ record) in
3873 : the DFF stream, which is always behind shape start position of the
3874 : passed header. The function upper_bound() finds the first element in
3875 : the map whose key is greater than the start position of the header. Its
3876 : end position is used to test whether the found object is really related
3877 : to the shape. */
3878 0 : XclImpDrawObjRef xDrawObj;
3879 0 : XclImpObjMap::const_iterator aIt = maObjMap.upper_bound( rHeader.GetRecBegFilePos() );
3880 0 : if( (aIt != maObjMap.end()) && (aIt->first <= rHeader.GetRecEndFilePos()) )
3881 0 : xDrawObj = aIt->second;
3882 0 : return xDrawObj;
3883 : }
3884 :
3885 0 : XclImpDrawObjRef XclImpDrawing::FindDrawObj( sal_uInt16 nObjId ) const
3886 : {
3887 0 : XclImpDrawObjRef xDrawObj;
3888 0 : XclImpObjMapById::const_iterator aIt = maObjMapId.find( nObjId );
3889 0 : if( aIt != maObjMapId.end() )
3890 0 : xDrawObj = aIt->second;
3891 0 : return xDrawObj;
3892 : }
3893 :
3894 0 : const XclImpObjTextData* XclImpDrawing::FindTextData( const DffRecordHeader& rHeader ) const
3895 : {
3896 : /* maTextMap stores textbox data by position of the client data (TXO
3897 : record) in the DFF stream, which is always behind shape start position
3898 : of the passed header. The function upper_bound() finds the first
3899 : element in the map whose key is greater than the start position of the
3900 : header. Its end position is used to test whether the found object is
3901 : really related to the shape. */
3902 0 : XclImpObjTextMap::const_iterator aIt = maTextMap.upper_bound( rHeader.GetRecBegFilePos() );
3903 0 : if( (aIt != maTextMap.end()) && (aIt->first <= rHeader.GetRecEndFilePos()) )
3904 0 : return aIt->second.get();
3905 0 : return 0;
3906 : }
3907 :
3908 0 : void XclImpDrawing::SetSkipObj( sal_uInt16 nObjId )
3909 : {
3910 0 : maSkipObjs.push_back( nObjId );
3911 0 : }
3912 :
3913 0 : sal_Size XclImpDrawing::GetProgressSize() const
3914 : {
3915 0 : sal_Size nProgressSize = maRawObjs.GetProgressSize();
3916 0 : for( XclImpObjMap::const_iterator aIt = maObjMap.begin(), aEnd = maObjMap.end(); aIt != aEnd; ++aIt )
3917 0 : nProgressSize += aIt->second->GetProgressSize();
3918 0 : return nProgressSize;
3919 : }
3920 :
3921 0 : void XclImpDrawing::ImplConvertObjects( XclImpDffConverter& rDffConv, SdrModel& rSdrModel, SdrPage& rSdrPage )
3922 : {
3923 : //rhbz#636521, disable undo during conversion. faster, smaller and stops
3924 : //temp objects being inserted into the undo list
3925 0 : bool bOrigUndoStatus = rSdrModel.IsUndoEnabled();
3926 0 : rSdrModel.EnableUndo(false);
3927 : // register this drawing manager at the passed (global) DFF manager
3928 0 : rDffConv.InitializeDrawing( *this, rSdrModel, rSdrPage );
3929 : // process list of objects to be skipped
3930 0 : for( ScfUInt16Vec::const_iterator aIt = maSkipObjs.begin(), aEnd = maSkipObjs.end(); aIt != aEnd; ++aIt )
3931 0 : if( XclImpDrawObjBase* pDrawObj = FindDrawObj( *aIt ).get() )
3932 0 : pDrawObj->SetProcessSdrObj( false );
3933 : // process drawing objects without DFF data
3934 0 : rDffConv.ProcessDrawing( maRawObjs );
3935 : // process all objects in the DFF stream
3936 0 : rDffConv.ProcessDrawing( maDffStrm );
3937 : // unregister this drawing manager at the passed (global) DFF manager
3938 0 : rDffConv.FinalizeDrawing();
3939 0 : rSdrModel.EnableUndo(bOrigUndoStatus);
3940 0 : }
3941 :
3942 : // protected ------------------------------------------------------------------
3943 :
3944 0 : void XclImpDrawing::AppendRawObject( const XclImpDrawObjRef& rxDrawObj )
3945 : {
3946 : OSL_ENSURE( rxDrawObj, "XclImpDrawing::AppendRawObject - unexpected empty reference" );
3947 0 : maRawObjs.push_back( rxDrawObj );
3948 0 : }
3949 :
3950 : // private --------------------------------------------------------------------
3951 :
3952 0 : void XclImpDrawing::ReadWmf( Graphic& rGraphic, const XclImpRoot&, XclImpStream& rStrm ) // static helper
3953 : {
3954 : // extract graphic data from IMGDATA and following CONTINUE records
3955 0 : rStrm.Ignore( 8 );
3956 0 : SvMemoryStream aMemStrm;
3957 0 : rStrm.CopyToStream( aMemStrm, rStrm.GetRecLeft() );
3958 0 : aMemStrm.Seek( STREAM_SEEK_TO_BEGIN );
3959 : // import the graphic from memory stream
3960 0 : GDIMetaFile aGDIMetaFile;
3961 0 : if( ::ReadWindowMetafile( aMemStrm, aGDIMetaFile, 0 ) )
3962 0 : rGraphic = aGDIMetaFile;
3963 0 : }
3964 :
3965 0 : void XclImpDrawing::ReadBmp( Graphic& rGraphic, const XclImpRoot& rRoot, XclImpStream& rStrm ) // static helper
3966 : {
3967 : // extract graphic data from IMGDATA and following CONTINUE records
3968 0 : SvMemoryStream aMemStrm;
3969 :
3970 : /* Excel 3 and 4 seem to write broken BMP data. Usually they write a
3971 : DIBCOREHEADER (12 bytes) containing width, height, planes = 1, and
3972 : pixel depth = 32 bit. After that, 3 unused bytes are added before the
3973 : actual pixel data. This does even confuse Excel 5 and later, which
3974 : cannot read the image data correctly. */
3975 0 : if( rRoot.GetBiff() <= EXC_BIFF4 )
3976 : {
3977 0 : rStrm.PushPosition();
3978 : sal_uInt32 nHdrSize;
3979 : sal_uInt16 nWidth, nHeight, nPlanes, nDepth;
3980 0 : rStrm >> nHdrSize >> nWidth >> nHeight >> nPlanes >> nDepth;
3981 0 : if( (nHdrSize == 12) && (nPlanes == 1) && (nDepth == 32) )
3982 : {
3983 0 : rStrm.Ignore( 3 );
3984 0 : aMemStrm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
3985 0 : aMemStrm.WriteUInt32( nHdrSize ).WriteUInt16( nWidth ).WriteUInt16( nHeight ).WriteUInt16( nPlanes ).WriteUInt16( nDepth );
3986 0 : rStrm.CopyToStream( aMemStrm, rStrm.GetRecLeft() );
3987 : }
3988 0 : rStrm.PopPosition();
3989 : }
3990 :
3991 : // no special handling above -> just copy the remaining record data
3992 0 : if( aMemStrm.Tell() == 0 )
3993 0 : rStrm.CopyToStream( aMemStrm, rStrm.GetRecLeft() );
3994 :
3995 : // import the graphic from memory stream
3996 0 : aMemStrm.Seek( STREAM_SEEK_TO_BEGIN );
3997 0 : Bitmap aBitmap;
3998 0 : if( ReadDIB(aBitmap, aMemStrm, false) ) // read DIB without file header
3999 0 : rGraphic = aBitmap;
4000 0 : }
4001 :
4002 0 : void XclImpDrawing::ReadDffRecord( XclImpStream& rStrm )
4003 : {
4004 0 : maDffStrm.Seek( STREAM_SEEK_TO_END );
4005 0 : rStrm.CopyRecordToStream( maDffStrm );
4006 0 : }
4007 :
4008 0 : void XclImpDrawing::ReadObj8( XclImpStream& rStrm )
4009 : {
4010 0 : XclImpDrawObjRef xDrawObj = XclImpDrawObjBase::ReadObj8( GetRoot(), rStrm );
4011 : // store the new object in the internal containers
4012 0 : maObjMap[ maDffStrm.Tell() ] = xDrawObj;
4013 0 : maObjMapId[ xDrawObj->GetObjId() ] = xDrawObj;
4014 0 : }
4015 :
4016 0 : void XclImpDrawing::ReadTxo( XclImpStream& rStrm )
4017 : {
4018 0 : XclImpObjTextRef xTextData( new XclImpObjTextData );
4019 0 : maTextMap[ maDffStrm.Tell() ] = xTextData;
4020 :
4021 : // 1) read the TXO record
4022 0 : xTextData->maData.ReadTxo8( rStrm );
4023 :
4024 : // 2) first CONTINUE with string
4025 0 : xTextData->mxString.reset();
4026 0 : bool bValid = true;
4027 0 : if( xTextData->maData.mnTextLen > 0 )
4028 : {
4029 0 : bValid = (rStrm.GetNextRecId() == EXC_ID_CONT) && rStrm.StartNextRecord();
4030 : OSL_ENSURE( bValid, "XclImpDrawing::ReadTxo - missing CONTINUE record" );
4031 0 : if( bValid )
4032 0 : xTextData->mxString.reset( new XclImpString( rStrm.ReadUniString( xTextData->maData.mnTextLen ) ) );
4033 : }
4034 :
4035 : // 3) second CONTINUE with formatting runs
4036 0 : if( xTextData->maData.mnFormatSize > 0 )
4037 : {
4038 0 : bValid = (rStrm.GetNextRecId() == EXC_ID_CONT) && rStrm.StartNextRecord();
4039 : OSL_ENSURE( bValid, "XclImpDrawing::ReadTxo - missing CONTINUE record" );
4040 0 : if( bValid )
4041 0 : xTextData->ReadFormats( rStrm );
4042 0 : }
4043 0 : }
4044 :
4045 0 : XclImpSheetDrawing::XclImpSheetDrawing( const XclImpRoot& rRoot, SCTAB nScTab ) :
4046 : XclImpDrawing( rRoot, true ),
4047 0 : maScUsedArea( ScAddress::INITIALIZE_INVALID )
4048 : {
4049 0 : maScUsedArea.aStart.SetTab( nScTab );
4050 0 : maScUsedArea.aEnd.SetTab( nScTab );
4051 0 : }
4052 :
4053 0 : void XclImpSheetDrawing::ReadNote( XclImpStream& rStrm )
4054 : {
4055 0 : switch( GetBiff() )
4056 : {
4057 : case EXC_BIFF2:
4058 : case EXC_BIFF3:
4059 : case EXC_BIFF4:
4060 : case EXC_BIFF5:
4061 0 : ReadNote3( rStrm );
4062 0 : break;
4063 : case EXC_BIFF8:
4064 0 : ReadNote8( rStrm );
4065 0 : break;
4066 : default:
4067 : DBG_ERROR_BIFF();
4068 : }
4069 0 : }
4070 :
4071 0 : void XclImpSheetDrawing::ReadTabChart( XclImpStream& rStrm )
4072 : {
4073 : OSL_ENSURE_BIFF( GetBiff() >= EXC_BIFF5 );
4074 0 : boost::shared_ptr< XclImpChartObj > xChartObj( new XclImpChartObj( GetRoot(), true ) );
4075 0 : xChartObj->ReadChartSubStream( rStrm );
4076 : // insert the chart as raw object without connected DFF data
4077 0 : AppendRawObject( xChartObj );
4078 0 : }
4079 :
4080 0 : void XclImpSheetDrawing::ConvertObjects( XclImpDffConverter& rDffConv )
4081 : {
4082 0 : if( SdrModel* pSdrModel = GetDoc().GetDrawLayer() )
4083 0 : if( SdrPage* pSdrPage = GetSdrPage( maScUsedArea.aStart.Tab() ) )
4084 0 : ImplConvertObjects( rDffConv, *pSdrModel, *pSdrPage );
4085 0 : }
4086 :
4087 0 : Rectangle XclImpSheetDrawing::CalcAnchorRect( const XclObjAnchor& rAnchor, bool /*bDffAnchor*/ ) const
4088 : {
4089 0 : return rAnchor.GetRect( GetRoot(), maScUsedArea.aStart.Tab(), MAP_100TH_MM );
4090 : }
4091 :
4092 0 : void XclImpSheetDrawing::OnObjectInserted( const XclImpDrawObjBase& rDrawObj )
4093 : {
4094 0 : ScRange aScObjArea = rDrawObj.GetUsedArea( maScUsedArea.aStart.Tab() );
4095 0 : if( aScObjArea.IsValid() )
4096 0 : maScUsedArea.ExtendTo( aScObjArea );
4097 0 : }
4098 :
4099 : // private --------------------------------------------------------------------
4100 :
4101 0 : void XclImpSheetDrawing::ReadNote3( XclImpStream& rStrm )
4102 : {
4103 0 : XclAddress aXclPos;
4104 : sal_uInt16 nTotalLen;
4105 0 : rStrm >> aXclPos >> nTotalLen;
4106 :
4107 0 : ScAddress aScNotePos( ScAddress::UNINITIALIZED );
4108 0 : if( GetAddressConverter().ConvertAddress( aScNotePos, aXclPos, maScUsedArea.aStart.Tab(), true ) )
4109 : {
4110 0 : sal_uInt16 nPartLen = ::std::min( nTotalLen, static_cast< sal_uInt16 >( rStrm.GetRecLeft() ) );
4111 0 : OUString aNoteText = rStrm.ReadRawByteString( nPartLen );
4112 0 : nTotalLen = nTotalLen - nPartLen;
4113 0 : while( (nTotalLen > 0) && (rStrm.GetNextRecId() == EXC_ID_NOTE) && rStrm.StartNextRecord() )
4114 : {
4115 0 : rStrm >> aXclPos >> nPartLen;
4116 : OSL_ENSURE( aXclPos.mnRow == 0xFFFF, "XclImpObjectManager::ReadNote3 - missing continuation NOTE record" );
4117 0 : if( aXclPos.mnRow == 0xFFFF )
4118 : {
4119 : OSL_ENSURE( nPartLen <= nTotalLen, "XclImpObjectManager::ReadNote3 - string too long" );
4120 0 : aNoteText += rStrm.ReadRawByteString( nPartLen );
4121 0 : nTotalLen = nTotalLen - ::std::min( nTotalLen, nPartLen );
4122 : }
4123 : else
4124 : {
4125 : // seems to be a new note, record already started -> load the note
4126 0 : rStrm.Seek( EXC_REC_SEEK_TO_BEGIN );
4127 0 : ReadNote( rStrm );
4128 0 : nTotalLen = 0;
4129 : }
4130 : }
4131 0 : ScNoteUtil::CreateNoteFromString( GetDoc(), aScNotePos, aNoteText, false, false );
4132 : }
4133 0 : }
4134 :
4135 0 : void XclImpSheetDrawing::ReadNote8( XclImpStream& rStrm )
4136 : {
4137 0 : XclAddress aXclPos;
4138 : sal_uInt16 nFlags, nObjId;
4139 0 : rStrm >> aXclPos >> nFlags >> nObjId;
4140 :
4141 0 : ScAddress aScNotePos( ScAddress::UNINITIALIZED );
4142 0 : if( GetAddressConverter().ConvertAddress( aScNotePos, aXclPos, maScUsedArea.aStart.Tab(), true ) )
4143 0 : if( nObjId != EXC_OBJ_INVALID_ID )
4144 0 : if( XclImpNoteObj* pNoteObj = dynamic_cast< XclImpNoteObj* >( FindDrawObj( nObjId ).get() ) )
4145 0 : pNoteObj->SetNoteData( aScNotePos, nFlags );
4146 0 : }
4147 :
4148 : // The object manager =========================================================
4149 :
4150 0 : XclImpObjectManager::XclImpObjectManager( const XclImpRoot& rRoot ) :
4151 0 : XclImpRoot( rRoot )
4152 : {
4153 0 : maDefObjNames[ EXC_OBJTYPE_GROUP ] = "Group";
4154 0 : maDefObjNames[ EXC_OBJTYPE_LINE ] = ScGlobal::GetRscString( STR_SHAPE_LINE );
4155 0 : maDefObjNames[ EXC_OBJTYPE_RECTANGLE ] = ScGlobal::GetRscString( STR_SHAPE_RECTANGLE );
4156 0 : maDefObjNames[ EXC_OBJTYPE_OVAL ] = ScGlobal::GetRscString( STR_SHAPE_OVAL );
4157 0 : maDefObjNames[ EXC_OBJTYPE_ARC ] = "Arc";
4158 0 : maDefObjNames[ EXC_OBJTYPE_CHART ] = "Chart";
4159 0 : maDefObjNames[ EXC_OBJTYPE_TEXT ] = "Text";
4160 0 : maDefObjNames[ EXC_OBJTYPE_BUTTON ] = ScGlobal::GetRscString( STR_FORM_BUTTON );
4161 0 : maDefObjNames[ EXC_OBJTYPE_PICTURE ] = "Picture";
4162 0 : maDefObjNames[ EXC_OBJTYPE_POLYGON ] = "Freeform";
4163 0 : maDefObjNames[ EXC_OBJTYPE_CHECKBOX ] = ScGlobal::GetRscString( STR_FORM_CHECKBOX );
4164 0 : maDefObjNames[ EXC_OBJTYPE_OPTIONBUTTON ] = ScGlobal::GetRscString( STR_FORM_OPTIONBUTTON );
4165 0 : maDefObjNames[ EXC_OBJTYPE_EDIT ] = "Edit Box";
4166 0 : maDefObjNames[ EXC_OBJTYPE_LABEL ] = ScGlobal::GetRscString( STR_FORM_LABEL );
4167 0 : maDefObjNames[ EXC_OBJTYPE_DIALOG ] = "Dialog Frame";
4168 0 : maDefObjNames[ EXC_OBJTYPE_SPIN ] = ScGlobal::GetRscString( STR_FORM_SPINNER );
4169 0 : maDefObjNames[ EXC_OBJTYPE_SCROLLBAR ] = ScGlobal::GetRscString( STR_FORM_SCROLLBAR );
4170 0 : maDefObjNames[ EXC_OBJTYPE_LISTBOX ] = ScGlobal::GetRscString( STR_FORM_LISTBOX );
4171 0 : maDefObjNames[ EXC_OBJTYPE_GROUPBOX ] = ScGlobal::GetRscString( STR_FORM_GROUPBOX );
4172 0 : maDefObjNames[ EXC_OBJTYPE_DROPDOWN ] = ScGlobal::GetRscString( STR_FORM_DROPDOWN );
4173 0 : maDefObjNames[ EXC_OBJTYPE_NOTE ] = "Comment";
4174 0 : maDefObjNames[ EXC_OBJTYPE_DRAWING ] = ScGlobal::GetRscString( STR_SHAPE_AUTOSHAPE );
4175 0 : }
4176 :
4177 0 : XclImpObjectManager::~XclImpObjectManager()
4178 : {
4179 0 : }
4180 :
4181 0 : void XclImpObjectManager::ReadMsoDrawingGroup( XclImpStream& rStrm )
4182 : {
4183 : OSL_ENSURE_BIFF( GetBiff() == EXC_BIFF8 );
4184 : // Excel continues this record with MSODRAWINGGROUP and CONTINUE records, hmm.
4185 0 : rStrm.ResetRecord( true, EXC_ID_MSODRAWINGGROUP );
4186 0 : maDggStrm.Seek( STREAM_SEEK_TO_END );
4187 0 : rStrm.CopyRecordToStream( maDggStrm );
4188 0 : }
4189 :
4190 0 : XclImpSheetDrawing& XclImpObjectManager::GetSheetDrawing( SCTAB nScTab )
4191 : {
4192 0 : XclImpSheetDrawingRef& rxDrawing = maSheetDrawings[ nScTab ];
4193 0 : if( !rxDrawing )
4194 0 : rxDrawing.reset( new XclImpSheetDrawing( GetRoot(), nScTab ) );
4195 0 : return *rxDrawing;
4196 : }
4197 :
4198 0 : void XclImpObjectManager::ConvertObjects()
4199 : {
4200 : // do nothing if the document does not contain a drawing layer
4201 0 : if( !GetDoc().GetDrawLayer() )
4202 0 : return;
4203 :
4204 : // get total progress bar size for all sheet drawing managers
4205 0 : sal_Size nProgressSize = 0;
4206 0 : for( XclImpSheetDrawingMap::iterator aIt = maSheetDrawings.begin(), aEnd = maSheetDrawings.end(); aIt != aEnd; ++aIt )
4207 0 : nProgressSize += aIt->second->GetProgressSize();
4208 : // nothing to do if progress bar is zero (no objects present)
4209 0 : if( nProgressSize == 0 )
4210 0 : return;
4211 :
4212 0 : XclImpDffConverter aDffConv( GetRoot(), maDggStrm );
4213 0 : aDffConv.StartProgressBar( nProgressSize );
4214 0 : for( XclImpSheetDrawingMap::iterator aIt = maSheetDrawings.begin(), aEnd = maSheetDrawings.end(); aIt != aEnd; ++aIt )
4215 0 : aIt->second->ConvertObjects( aDffConv );
4216 :
4217 : // #i112436# don't call ScChartListenerCollection::SetDirty here,
4218 : // instead use InterpretDirtyCells in ScDocument::CalcAfterLoad.
4219 : }
4220 :
4221 0 : OUString XclImpObjectManager::GetDefaultObjName( const XclImpDrawObjBase& rDrawObj ) const
4222 : {
4223 0 : OUStringBuffer aDefName;
4224 0 : DefObjNameMap::const_iterator aIt = maDefObjNames.find( rDrawObj.GetObjType() );
4225 0 : if( aIt != maDefObjNames.end() )
4226 0 : aDefName.append(aIt->second);
4227 0 : return aDefName.append(' ').append(static_cast<sal_Int32>(rDrawObj.GetObjId())).makeStringAndClear();
4228 : }
4229 :
4230 0 : ScRange XclImpObjectManager::GetUsedArea( SCTAB nScTab ) const
4231 : {
4232 0 : XclImpSheetDrawingMap::const_iterator aIt = maSheetDrawings.find( nScTab );
4233 0 : if( aIt != maSheetDrawings.end() )
4234 0 : return aIt->second->GetUsedArea();
4235 0 : return ScRange( ScAddress::INITIALIZE_INVALID );
4236 : }
4237 :
4238 : // DFF property set helper ====================================================
4239 :
4240 0 : XclImpDffPropSet::XclImpDffPropSet( const XclImpRoot& rRoot ) :
4241 : XclImpRoot( rRoot ),
4242 0 : maDffConv( rRoot, maDummyStrm )
4243 : {
4244 0 : }
4245 :
4246 0 : void XclImpDffPropSet::Read( XclImpStream& rStrm )
4247 : {
4248 : sal_uInt32 nPropSetSize;
4249 :
4250 0 : rStrm.PushPosition();
4251 0 : rStrm.Ignore( 4 );
4252 0 : rStrm >> nPropSetSize;
4253 0 : rStrm.PopPosition();
4254 :
4255 0 : mxMemStrm.reset( new SvMemoryStream );
4256 0 : rStrm.CopyToStream( *mxMemStrm, 8 + nPropSetSize );
4257 0 : mxMemStrm->Seek( STREAM_SEEK_TO_BEGIN );
4258 0 : maDffConv.ReadPropSet( *mxMemStrm, 0 );
4259 0 : }
4260 :
4261 0 : sal_uInt32 XclImpDffPropSet::GetPropertyValue( sal_uInt16 nPropId, sal_uInt32 nDefault ) const
4262 : {
4263 0 : return maDffConv.GetPropertyValue( nPropId, nDefault );
4264 : }
4265 :
4266 0 : void XclImpDffPropSet::FillToItemSet( SfxItemSet& rItemSet ) const
4267 : {
4268 0 : if( mxMemStrm.get() )
4269 0 : maDffConv.ApplyAttributes( *mxMemStrm, rItemSet );
4270 0 : }
4271 :
4272 0 : XclImpStream& operator>>( XclImpStream& rStrm, XclImpDffPropSet& rPropSet )
4273 : {
4274 0 : rPropSet.Read( rStrm );
4275 0 : return rStrm;
4276 0 : }
4277 :
4278 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
