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 <svx/XPropertyTable.hxx>
21 : #include "xmlxtexp.hxx"
22 : #include "xmlxtimp.hxx"
23 : #include <tools/urlobj.hxx>
24 : #include <svx/xtable.hxx>
25 : #include <svx/xpool.hxx>
26 : #include <svx/svdobj.hxx>
27 : #include <svx/svdpool.hxx>
28 : #include <stack>
29 :
30 : using namespace com::sun::star;
31 :
32 : // Helper for other sub-classes to have easy-to-read constructors
33 49441 : Color RGB_Color( ColorData nColorName )
34 : {
35 49441 : Color aColor( nColorName );
36 49441 : Color aRGBColor( aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue() );
37 49441 : return aRGBColor;
38 : }
39 :
40 0 : XColorEntry::XColorEntry(const Color& rColor, const OUString& rName)
41 : : XPropertyEntry(rName),
42 0 : aColor(rColor)
43 : {
44 0 : }
45 :
46 0 : XColorEntry::XColorEntry(const XColorEntry& rOther)
47 : : XPropertyEntry(rOther),
48 0 : aColor(rOther.aColor)
49 : {
50 0 : }
51 :
52 20 : XLineEndEntry::XLineEndEntry(const basegfx::B2DPolyPolygon& rB2DPolyPolygon, const OUString& rName)
53 : : XPropertyEntry(rName),
54 20 : aB2DPolyPolygon(rB2DPolyPolygon)
55 : {
56 20 : }
57 :
58 0 : XLineEndEntry::XLineEndEntry(const XLineEndEntry& rOther)
59 : : XPropertyEntry(rOther),
60 0 : aB2DPolyPolygon(rOther.aB2DPolyPolygon)
61 : {
62 0 : }
63 :
64 594 : XDashEntry::XDashEntry(const XDash& rDash, const OUString& rName)
65 : : XPropertyEntry(rName),
66 594 : aDash(rDash)
67 : {
68 594 : }
69 :
70 0 : XDashEntry::XDashEntry(const XDashEntry& rOther)
71 : : XPropertyEntry(rOther),
72 0 : aDash(rOther.aDash)
73 : {
74 0 : }
75 :
76 190 : XHatchEntry::XHatchEntry(const XHatch& rHatch, const OUString& rName)
77 : : XPropertyEntry(rName),
78 190 : aHatch(rHatch)
79 : {
80 190 : }
81 :
82 0 : XHatchEntry::XHatchEntry(const XHatchEntry& rOther)
83 : : XPropertyEntry(rOther),
84 0 : aHatch(rOther.aHatch)
85 : {
86 0 : }
87 :
88 1020 : XGradientEntry::XGradientEntry(const XGradient& rGradient, const OUString& rName)
89 : : XPropertyEntry(rName),
90 1020 : aGradient(rGradient)
91 : {
92 1020 : }
93 :
94 0 : XGradientEntry::XGradientEntry(const XGradientEntry& rOther)
95 : : XPropertyEntry(rOther),
96 0 : aGradient(rOther.aGradient)
97 : {
98 0 : }
99 :
100 210 : XBitmapEntry::XBitmapEntry(const GraphicObject& rGraphicObject, const OUString& rName)
101 : : XPropertyEntry(rName),
102 210 : maGraphicObject(rGraphicObject)
103 : {
104 210 : }
105 :
106 0 : XBitmapEntry::XBitmapEntry(const XBitmapEntry& rOther)
107 : : XPropertyEntry(rOther),
108 0 : maGraphicObject(rOther.maGraphicObject)
109 : {
110 0 : }
111 :
112 21746 : XPropertyList::XPropertyList(
113 : XPropertyListType type,
114 : const OUString& rPath, const OUString& rReferer
115 : ) : meType ( type ),
116 : maName ( "standard" ),
117 : maPath ( rPath ),
118 : maReferer ( rReferer ),
119 : mbListDirty ( true ),
120 21746 : mbEmbedInDocument( false )
121 : {
122 : // fprintf (stderr, "Create type %d count %d\n", (int)meType, count++);
123 21746 : }
124 :
125 43038 : XPropertyList::~XPropertyList()
126 : {
127 : // fprintf (stderr, "Destroy type %d count %d\n", (int)meType, --count);
128 23469 : for( size_t i = 0, n = maList.size(); i < n; ++i )
129 1950 : delete maList[ i ];
130 :
131 21519 : maList.clear();
132 21519 : }
133 :
134 4576 : long XPropertyList::Count() const
135 : {
136 4576 : if( mbListDirty )
137 : {
138 127 : if( !const_cast<XPropertyList*>(this)->Load() )
139 0 : const_cast<XPropertyList*>(this)->Create();
140 : }
141 4576 : return maList.size();
142 : }
143 :
144 37581 : XPropertyEntry* XPropertyList::Get( long nIndex ) const
145 : {
146 37581 : if( mbListDirty )
147 : {
148 0 : if( !const_cast<XPropertyList*>(this)->Load() )
149 0 : const_cast<XPropertyList*>(this)->Create();
150 : }
151 37581 : return ( (size_t)nIndex < maList.size() ) ? maList[ nIndex ] : NULL;
152 : }
153 :
154 249 : long XPropertyList::GetIndex(const OUString& rName) const
155 : {
156 249 : if( mbListDirty )
157 : {
158 8 : if( !const_cast<XPropertyList*>(this)->Load() )
159 0 : const_cast<XPropertyList*>(this)->Create();
160 : }
161 :
162 2739 : for( long i = 0, n = maList.size(); i < n; ++i ) {
163 2490 : if (rName.equals(maList[ i ]->GetName())) {
164 0 : return i;
165 : }
166 : }
167 249 : return -1;
168 : }
169 :
170 30 : Bitmap XPropertyList::GetUiBitmap( long nIndex ) const
171 : {
172 30 : Bitmap aRetval;
173 30 : XPropertyEntry* pEntry = ( (size_t)nIndex < maList.size() ) ? maList[ nIndex ] : NULL;
174 30 : if(pEntry)
175 : {
176 30 : aRetval = pEntry->GetUiBitmap();
177 :
178 30 : if(aRetval.IsEmpty())
179 : {
180 30 : aRetval = const_cast< XPropertyList* >(this)->CreateBitmapForUI(nIndex);
181 30 : pEntry->SetUiBitmap(aRetval);
182 : }
183 : }
184 30 : return aRetval;
185 : }
186 :
187 1980 : void XPropertyList::Insert( XPropertyEntry* pEntry, long nIndex )
188 : {
189 1980 : if ( (size_t)nIndex < maList.size() ) {
190 0 : maList.insert( maList.begin() + nIndex, pEntry );
191 : } else {
192 1980 : maList.push_back( pEntry );
193 : }
194 1980 : }
195 :
196 54 : XPropertyEntry* XPropertyList::Replace( XPropertyEntry* pEntry, long nIndex )
197 : {
198 54 : XPropertyEntry* pOldEntry = (size_t)nIndex < maList.size() ? maList[ nIndex ] : NULL;
199 54 : if ( pOldEntry ) {
200 54 : maList[ nIndex ] = pEntry;
201 : }
202 54 : return pOldEntry;
203 : }
204 :
205 0 : XPropertyEntry* XPropertyList::Remove( long nIndex )
206 : {
207 0 : XPropertyEntry* pEntry = NULL;
208 0 : if ( (size_t)nIndex < maList.size() ) {
209 0 : pEntry = maList[ nIndex ];
210 0 : maList.erase( maList.begin() + nIndex );
211 : }
212 0 : return pEntry;
213 : }
214 :
215 264 : void XPropertyList::SetName( const OUString& rString )
216 : {
217 264 : if(!rString.isEmpty())
218 : {
219 264 : maName = rString;
220 : }
221 264 : }
222 :
223 135 : bool XPropertyList::Load()
224 : {
225 135 : if( mbListDirty )
226 : {
227 135 : mbListDirty = false;
228 135 : std::stack<OUString> aDirs;
229 :
230 135 : sal_Int32 nIndex = 0;
231 270 : do
232 : {
233 270 : aDirs.push(maPath.getToken(0, ';', nIndex));
234 : }
235 270 : while (nIndex >= 0);
236 :
237 : //try all entries palette path list working back to front until one
238 : //succeeds
239 405 : while (!aDirs.empty())
240 : {
241 270 : OUString aPath(aDirs.top());
242 270 : aDirs.pop();
243 :
244 405 : INetURLObject aURL(aPath);
245 :
246 270 : if( INetProtocol::NotValid == aURL.GetProtocol() )
247 : {
248 : DBG_ASSERT( aPath.isEmpty(), "invalid URL" );
249 0 : return false;
250 : }
251 :
252 270 : aURL.Append( maName );
253 :
254 270 : if( aURL.getExtension().isEmpty() )
255 270 : aURL.setExtension( GetDefaultExt() );
256 :
257 : bool bRet = SvxXMLXTableImport::load(aURL.GetMainURL(INetURLObject::NO_DECODE),
258 : maReferer, uno::Reference < embed::XStorage >(),
259 270 : createInstance(), NULL );
260 270 : if (bRet)
261 135 : return bRet;
262 135 : }
263 : }
264 0 : return false;
265 : }
266 :
267 264 : bool XPropertyList::LoadFrom( const uno::Reference < embed::XStorage > &xStorage,
268 : const OUString &rURL, const OUString &rReferer )
269 : {
270 264 : if( !mbListDirty )
271 0 : return false;
272 264 : mbListDirty = false;
273 264 : return SvxXMLXTableImport::load( rURL, rReferer, xStorage, createInstance(), &mbEmbedInDocument );
274 : }
275 :
276 0 : bool XPropertyList::Save()
277 : {
278 : //save to the last path in the palette path list
279 0 : OUString aLastDir;
280 0 : sal_Int32 nIndex = 0;
281 0 : do
282 : {
283 0 : aLastDir = maPath.getToken(0, ';', nIndex);
284 : }
285 0 : while (nIndex >= 0);
286 :
287 0 : INetURLObject aURL(aLastDir);
288 :
289 0 : if( INetProtocol::NotValid == aURL.GetProtocol() )
290 : {
291 : DBG_ASSERT( aLastDir.isEmpty(), "invalid URL" );
292 0 : return false;
293 : }
294 :
295 0 : aURL.Append( maName );
296 :
297 0 : if( aURL.getExtension().isEmpty() )
298 0 : aURL.setExtension( GetDefaultExt() );
299 :
300 : return SvxXMLXTableExportComponent::save( aURL.GetMainURL( INetURLObject::NO_DECODE ),
301 0 : createInstance(),
302 0 : uno::Reference< embed::XStorage >(), NULL );
303 : }
304 :
305 0 : bool XPropertyList::SaveTo( const uno::Reference< embed::XStorage > &xStorage,
306 : const OUString &rURL, OUString *pOptName )
307 : {
308 0 : return SvxXMLXTableExportComponent::save( rURL, createInstance(), xStorage, pOptName );
309 : }
310 :
311 21746 : XPropertyListRef XPropertyList::CreatePropertyList( XPropertyListType t,
312 : const OUString& rPath,
313 : const OUString& rReferer )
314 : {
315 21746 : XPropertyListRef pRet;
316 :
317 : #define MAP(e,c) \
318 : case e: pRet = XPropertyListRef (new c( rPath, rReferer ) ); break
319 21746 : switch (t) {
320 786 : MAP( XCOLOR_LIST, XColorList );
321 4192 : MAP( XLINE_END_LIST, XLineEndList );
322 4192 : MAP( XDASH_LIST, XDashList );
323 4192 : MAP( XHATCH_LIST, XHatchList );
324 4192 : MAP( XGRADIENT_LIST, XGradientList );
325 4192 : MAP( XBITMAP_LIST, XBitmapList );
326 : default:
327 : OSL_FAIL("unknown xproperty type");
328 0 : break;
329 : }
330 : #undef MAP
331 : OSL_ASSERT( !pRet.is() || pRet->meType == t );
332 :
333 21746 : return pRet;
334 : }
335 :
336 : XPropertyListRef
337 0 : XPropertyList::CreatePropertyListFromURL( XPropertyListType t,
338 : const OUString & rURLStr )
339 : {
340 0 : INetURLObject aURL( rURLStr );
341 0 : INetURLObject aPathURL( aURL );
342 :
343 0 : aPathURL.removeSegment();
344 0 : aPathURL.removeFinalSlash();
345 :
346 : XPropertyListRef pList = XPropertyList::CreatePropertyList(
347 0 : t, aPathURL.GetMainURL( INetURLObject::NO_DECODE ), "" );
348 0 : pList->SetName( aURL.getName() );
349 :
350 0 : return pList;
351 : }
352 :
353 : // catch people being silly with ref counting ...
354 :
355 21746 : void* XPropertyList::operator new (size_t nCount)
356 : {
357 21746 : return rtl_allocateMemory( nCount );
358 : }
359 :
360 21519 : void XPropertyList::operator delete(void *pPtr)
361 : {
362 21519 : return rtl_freeMemory( pPtr );
363 : }
364 :
365 : static struct {
366 : XPropertyListType t;
367 : const char *pExt;
368 : } pExtnMap[] = {
369 : { XCOLOR_LIST, "soc" },
370 : { XLINE_END_LIST, "soe" },
371 : { XDASH_LIST, "sod" },
372 : { XHATCH_LIST, "soh" },
373 : { XGRADIENT_LIST, "sog" },
374 : { XBITMAP_LIST, "sob" }
375 : };
376 :
377 360 : OUString XPropertyList::GetDefaultExt( XPropertyListType t )
378 : {
379 1425 : for (size_t i = 0; i < SAL_N_ELEMENTS (pExtnMap); i++)
380 : {
381 1425 : if( pExtnMap[i].t == t )
382 360 : return OUString::createFromAscii( pExtnMap[ i ].pExt );
383 : }
384 0 : return OUString();
385 : }
386 :
387 0 : OUString XPropertyList::GetDefaultExtFilter( XPropertyListType t )
388 : {
389 0 : OUString aFilter( "*." );
390 0 : return aFilter + GetDefaultExt( t );
391 : }
392 :
393 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
