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