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