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 "scitems.hxx"
21 : #include <editeng/memberids.hrc>
22 : #include <svl/poolitem.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <svx/unomid.hxx>
25 : #include "unowids.hxx"
26 : #include <comphelper/servicehelper.hxx>
27 : #include <com/sun/star/table/BorderLine.hpp>
28 : #include <com/sun/star/table/CellVertJustify2.hpp>
29 : #include <com/sun/star/table/ShadowLocation.hpp>
30 : #include <com/sun/star/table/TableBorder.hpp>
31 : #include <com/sun/star/table/ShadowFormat.hpp>
32 : #include <com/sun/star/table/CellRangeAddress.hpp>
33 : #include <com/sun/star/table/CellContentType.hpp>
34 : #include <com/sun/star/table/TableOrientation.hpp>
35 : #include <com/sun/star/table/CellHoriJustify.hpp>
36 : #include <com/sun/star/util/SortField.hpp>
37 : #include <com/sun/star/util/SortFieldType.hpp>
38 : #include <com/sun/star/table/CellOrientation.hpp>
39 : #include <com/sun/star/table/CellAddress.hpp>
40 : #include <com/sun/star/awt/SimpleFontMetric.hpp>
41 : #include <com/sun/star/awt/FontWeight.hpp>
42 : #include <com/sun/star/awt/FontSlant.hpp>
43 : #include <com/sun/star/awt/CharSet.hpp>
44 : #include <com/sun/star/awt/FontDescriptor.hpp>
45 : #include <com/sun/star/awt/FontWidth.hpp>
46 : #include <com/sun/star/awt/XFont.hpp>
47 : #include <com/sun/star/awt/FontType.hpp>
48 : #include <com/sun/star/awt/FontUnderline.hpp>
49 : #include <com/sun/star/awt/FontStrikeout.hpp>
50 : #include <com/sun/star/awt/FontFamily.hpp>
51 : #include <com/sun/star/awt/FontPitch.hpp>
52 :
53 : #include "afmtuno.hxx"
54 : #include "miscuno.hxx"
55 : #include "autoform.hxx"
56 : #include "scdll.hxx"
57 : #include "unonames.hxx"
58 : #include "cellsuno.hxx"
59 :
60 : using namespace ::com::sun::star;
61 :
62 : // ein AutoFormat hat immer 16 Eintraege
63 : #define SC_AF_FIELD_COUNT 16
64 :
65 : // AutoFormat-Map nur fuer PropertySetInfo, ohne Which-IDs
66 :
67 54 : static const SfxItemPropertyMapEntry* lcl_GetAutoFormatMap()
68 : {
69 : static const SfxItemPropertyMapEntry aAutoFormatMap_Impl[] =
70 : {
71 2 : { OUString(SC_UNONAME_INCBACK), 0, ::getBooleanCppuType(), 0, 0 },
72 2 : { OUString(SC_UNONAME_INCBORD), 0, ::getBooleanCppuType(), 0, 0 },
73 2 : { OUString(SC_UNONAME_INCFONT), 0, ::getBooleanCppuType(), 0, 0 },
74 2 : { OUString(SC_UNONAME_INCJUST), 0, ::getBooleanCppuType(), 0, 0 },
75 2 : { OUString(SC_UNONAME_INCNUM), 0, ::getBooleanCppuType(), 0, 0 },
76 2 : { OUString(SC_UNONAME_INCWIDTH), 0, ::getBooleanCppuType(), 0, 0 },
77 : { OUString(), 0, css::uno::Type(), 0, 0 }
78 68 : };
79 54 : return aAutoFormatMap_Impl;
80 : }
81 :
82 : //! Zahlformat (String/Language) ??? (in XNumberFormat nur ReadOnly)
83 : //! table::TableBorder ??!?
84 :
85 8 : static const SfxItemPropertyMapEntry* lcl_GetAutoFieldMap()
86 : {
87 : static const SfxItemPropertyMapEntry aAutoFieldMap_Impl[] =
88 : {
89 2 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, ::cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
90 2 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
91 2 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, ::getBooleanCppuType(), 0, 0 },
92 2 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT, ::getBooleanCppuType(), 0, MID_CROSSED_OUT },
93 2 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
94 2 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
95 2 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
96 2 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
97 2 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
98 2 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
99 2 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
100 2 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
101 2 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
102 2 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
103 2 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
104 2 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
105 2 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, ::cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
106 2 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
107 2 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
108 2 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, ::cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
109 2 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, ::cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
110 2 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT, ::cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
111 2 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT, ::cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
112 2 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, ::cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
113 2 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, ::cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
114 2 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE, ::cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
115 2 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE, ::cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
116 2 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, ::getBooleanCppuType(), 0, 0 },
117 2 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, ::cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
118 2 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, ::cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
119 2 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE, ::cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
120 2 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, ::cppu::UnoType<float>::get(), 0, MID_WEIGHT },
121 2 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT, ::cppu::UnoType<float>::get(), 0, MID_WEIGHT },
122 2 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT, ::cppu::UnoType<float>::get(), 0, MID_WEIGHT },
123 2 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, ::cppu::UnoType<table::CellHoriJustify>::get(), 0, 0 },
124 2 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
125 2 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, ::getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT },
126 2 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, ::getBooleanCppuType(), 0, 0 },
127 2 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, ::cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
128 2 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, ::cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
129 2 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, ::cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
130 2 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, ::cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
131 2 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, ::cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
132 2 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
133 2 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
134 2 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
135 2 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
136 : { OUString(), 0, css::uno::Type(), 0, 0 }
137 104 : };
138 8 : return aAutoFieldMap_Impl;
139 : }
140 :
141 : #define SCAUTOFORMATSOBJ_SERVICE "com.sun.star.sheet.TableAutoFormats"
142 :
143 0 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatFieldObj, "ScAutoFormatFieldObj", "com.sun.star.sheet.TableAutoFormatField" )
144 4 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatObj, "ScAutoFormatObj", "com.sun.star.sheet.TableAutoFormat" )
145 0 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatsObj, "ScAutoFormatsObj", SCAUTOFORMATSOBJ_SERVICE )
146 :
147 22 : static bool lcl_FindAutoFormatIndex( const ScAutoFormat& rFormats, const OUString& rName, sal_uInt16& rOutIndex )
148 : {
149 22 : ScAutoFormat::const_iterator itBeg = rFormats.begin(), itEnd = rFormats.end();
150 322 : for (ScAutoFormat::const_iterator it = itBeg; it != itEnd; ++it)
151 : {
152 310 : const ScAutoFormatData* pEntry = it->second;
153 310 : const OUString& aEntryName = pEntry->GetName();
154 310 : if ( aEntryName.equals(rName) )
155 : {
156 10 : size_t nPos = std::distance(itBeg, it);
157 10 : rOutIndex = nPos;
158 10 : return true;
159 : }
160 : }
161 12 : return false; // is nich
162 : }
163 :
164 2 : ScAutoFormatsObj::ScAutoFormatsObj()
165 : {
166 : //! Dieses Objekt darf es nur einmal geben, und es muss an den Auto-Format-Daten
167 : //! bekannt sein, damit Aenderungen gebroadcasted werden koennen
168 2 : }
169 :
170 4 : ScAutoFormatsObj::~ScAutoFormatsObj()
171 : {
172 4 : }
173 :
174 : // stuff for exService_...
175 :
176 2 : uno::Reference<uno::XInterface> SAL_CALL ScAutoFormatsObj_CreateInstance(
177 : const uno::Reference<lang::XMultiServiceFactory>& )
178 : {
179 2 : SolarMutexGuard aGuard;
180 2 : ScDLL::Init();
181 2 : static uno::Reference< uno::XInterface > xInst((::cppu::OWeakObject*) new ScAutoFormatsObj);
182 2 : return xInst;
183 : }
184 :
185 304 : OUString ScAutoFormatsObj::getImplementationName_Static()
186 : {
187 304 : return OUString( "stardiv.StarCalc.ScAutoFormatsObj" );
188 : }
189 :
190 2 : uno::Sequence<OUString> ScAutoFormatsObj::getSupportedServiceNames_Static()
191 : {
192 2 : uno::Sequence<OUString> aRet(1);
193 2 : OUString* pArray = aRet.getArray();
194 2 : pArray[0] = OUString( SCAUTOFORMATSOBJ_SERVICE );
195 2 : return aRet;
196 : }
197 :
198 : // XTableAutoFormats
199 :
200 52 : ScAutoFormatObj* ScAutoFormatsObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
201 : {
202 52 : if (nIndex < ScGlobal::GetOrCreateAutoFormat()->size())
203 48 : return new ScAutoFormatObj(nIndex);
204 :
205 4 : return NULL; // falscher Index
206 : }
207 :
208 4 : ScAutoFormatObj* ScAutoFormatsObj::GetObjectByName_Impl(const OUString& aName)
209 : {
210 4 : OUString aString(aName);
211 : sal_uInt16 nIndex;
212 4 : if (lcl_FindAutoFormatIndex(
213 4 : *ScGlobal::GetOrCreateAutoFormat(), aString, nIndex ))
214 2 : return GetObjectByIndex_Impl(nIndex);
215 2 : return NULL;
216 : }
217 :
218 : // container::XNameContainer
219 :
220 6 : void SAL_CALL ScAutoFormatsObj::insertByName( const OUString& aName, const uno::Any& aElement )
221 : throw (lang::IllegalArgumentException, container::ElementExistException,
222 : lang::WrappedTargetException, uno::RuntimeException,
223 : std::exception)
224 : {
225 6 : SolarMutexGuard aGuard;
226 6 : bool bDone = false;
227 : // Reflection muss nicht uno::XInterface sein, kann auch irgendein Interface sein...
228 12 : uno::Reference< uno::XInterface > xInterface(aElement, uno::UNO_QUERY);
229 6 : if ( xInterface.is() )
230 : {
231 4 : ScAutoFormatObj* pFormatObj = ScAutoFormatObj::getImplementation( xInterface );
232 4 : if ( pFormatObj && !pFormatObj->IsInserted() ) // noch nicht eingefuegt?
233 : {
234 4 : OUString aNameStr(aName);
235 4 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
236 :
237 : sal_uInt16 nDummy;
238 4 : if (!lcl_FindAutoFormatIndex( *pFormats, aNameStr, nDummy ))
239 : {
240 2 : ScAutoFormatData* pNew = new ScAutoFormatData();
241 2 : pNew->SetName( aNameStr );
242 :
243 2 : if (pFormats->insert(pNew))
244 : {
245 : //! Notify fuer andere Objekte
246 2 : pFormats->Save(); // sofort speichern
247 :
248 : sal_uInt16 nNewIndex;
249 2 : if (lcl_FindAutoFormatIndex( *pFormats, aNameStr, nNewIndex ))
250 : {
251 2 : pFormatObj->InitFormat( nNewIndex ); // kann jetzt benutzt werden
252 2 : bDone = true;
253 : }
254 : }
255 : else
256 : {
257 : OSL_FAIL("AutoFormat konnte nicht eingefuegt werden");
258 0 : throw uno::RuntimeException();
259 : }
260 : }
261 : else
262 : {
263 2 : throw container::ElementExistException();
264 4 : }
265 : }
266 : }
267 :
268 4 : if (!bDone)
269 : {
270 : // other errors are handled above
271 2 : throw lang::IllegalArgumentException();
272 6 : }
273 2 : }
274 :
275 0 : void SAL_CALL ScAutoFormatsObj::replaceByName( const OUString& aName, const uno::Any& aElement )
276 : throw(lang::IllegalArgumentException, container::NoSuchElementException,
277 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
278 : {
279 0 : SolarMutexGuard aGuard;
280 : //! zusammenfassen?
281 0 : removeByName( aName );
282 0 : insertByName( aName, aElement );
283 0 : }
284 :
285 4 : void SAL_CALL ScAutoFormatsObj::removeByName( const OUString& aName )
286 : throw(container::NoSuchElementException,
287 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
288 : {
289 4 : SolarMutexGuard aGuard;
290 4 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
291 :
292 4 : ScAutoFormat::iterator it = pFormats->find(aName);
293 4 : if (it != pFormats->end())
294 : {
295 2 : pFormats->erase(it);
296 :
297 : //! Notify fuer andere Objekte
298 2 : pFormats->Save(); // sofort speichern
299 : }
300 : else
301 : {
302 2 : throw container::NoSuchElementException();
303 4 : }
304 2 : }
305 :
306 : // container::XEnumerationAccess
307 :
308 4 : uno::Reference<container::XEnumeration> SAL_CALL ScAutoFormatsObj::createEnumeration()
309 : throw(uno::RuntimeException, std::exception)
310 : {
311 4 : SolarMutexGuard aGuard;
312 4 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.TableAutoFormatEnumeration"));
313 : }
314 :
315 : // container::XIndexAccess
316 :
317 44 : sal_Int32 SAL_CALL ScAutoFormatsObj::getCount() throw(uno::RuntimeException, std::exception)
318 : {
319 44 : SolarMutexGuard aGuard;
320 44 : return ScGlobal::GetOrCreateAutoFormat()->size();
321 : }
322 :
323 50 : uno::Any SAL_CALL ScAutoFormatsObj::getByIndex( sal_Int32 nIndex )
324 : throw(lang::IndexOutOfBoundsException,
325 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
326 : {
327 50 : SolarMutexGuard aGuard;
328 100 : uno::Reference< container::XNamed > xFormat(GetObjectByIndex_Impl((sal_uInt16)nIndex));
329 50 : if (!xFormat.is())
330 4 : throw lang::IndexOutOfBoundsException();
331 96 : return uno::makeAny(xFormat);
332 : }
333 :
334 2 : uno::Type SAL_CALL ScAutoFormatsObj::getElementType() throw(uno::RuntimeException, std::exception)
335 : {
336 2 : SolarMutexGuard aGuard;
337 2 : return cppu::UnoType<container::XNamed>::get(); // muss zu getByIndex passen
338 : }
339 :
340 2 : sal_Bool SAL_CALL ScAutoFormatsObj::hasElements() throw(uno::RuntimeException, std::exception)
341 : {
342 2 : SolarMutexGuard aGuard;
343 2 : return ( getCount() != 0 );
344 : }
345 :
346 : // container::XNameAccess
347 :
348 4 : uno::Any SAL_CALL ScAutoFormatsObj::getByName( const OUString& aName )
349 : throw(container::NoSuchElementException,
350 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
351 : {
352 4 : SolarMutexGuard aGuard;
353 8 : uno::Reference< container::XNamed > xFormat(GetObjectByName_Impl(aName));
354 4 : if (!xFormat.is())
355 2 : throw container::NoSuchElementException();
356 6 : return uno::makeAny(xFormat);
357 : }
358 :
359 8 : uno::Sequence<OUString> SAL_CALL ScAutoFormatsObj::getElementNames()
360 : throw(uno::RuntimeException, std::exception)
361 : {
362 8 : SolarMutexGuard aGuard;
363 8 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
364 8 : uno::Sequence<OUString> aSeq(pFormats->size());
365 8 : OUString* pAry = aSeq.getArray();
366 8 : ScAutoFormat::const_iterator it = pFormats->begin(), itEnd = pFormats->end();
367 148 : for (size_t i = 0; it != itEnd; ++it, ++i)
368 : {
369 140 : pAry[i] = it->second->GetName();
370 : }
371 8 : return aSeq;
372 : }
373 :
374 8 : sal_Bool SAL_CALL ScAutoFormatsObj::hasByName( const OUString& aName )
375 : throw(uno::RuntimeException, std::exception)
376 : {
377 8 : SolarMutexGuard aGuard;
378 16 : OUString aString(aName);
379 : sal_uInt16 nDummy;
380 : return lcl_FindAutoFormatIndex(
381 16 : *ScGlobal::GetOrCreateAutoFormat(), aString, nDummy );
382 : }
383 :
384 54 : ScAutoFormatObj::ScAutoFormatObj(sal_uInt16 nIndex) :
385 : aPropSet( lcl_GetAutoFormatMap() ),
386 54 : nFormatIndex( nIndex )
387 : {
388 : //! Listening !!!
389 54 : }
390 :
391 162 : ScAutoFormatObj::~ScAutoFormatObj()
392 : {
393 : // Wenn ein AutoFormat-Objekt losgelassen wird, werden eventuelle Aenderungen
394 : // gespeichert, damit sie z.B. im Writer sichtbar sind
395 :
396 54 : if (IsInserted())
397 : {
398 50 : ScAutoFormat* pFormats = ScGlobal::GetAutoFormat();
399 50 : if ( pFormats && pFormats->IsSaveLater() )
400 1 : pFormats->Save();
401 :
402 : // Save() setzt SaveLater Flag zurueck
403 : }
404 108 : }
405 :
406 2 : void ScAutoFormatObj::InitFormat( sal_uInt16 nNewIndex )
407 : {
408 : OSL_ENSURE( nFormatIndex == SC_AFMTOBJ_INVALID, "ScAutoFormatObj::InitFormat mehrfach" );
409 2 : nFormatIndex = nNewIndex;
410 : //! Listening !!!
411 2 : }
412 :
413 : // XUnoTunnel
414 :
415 4 : sal_Int64 SAL_CALL ScAutoFormatObj::getSomething(
416 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
417 : {
418 8 : if ( rId.getLength() == 16 &&
419 4 : 0 == memcmp( getUnoTunnelId().getConstArray(),
420 8 : rId.getConstArray(), 16 ) )
421 : {
422 4 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
423 : }
424 0 : return 0;
425 : }
426 :
427 : namespace
428 : {
429 : class theScAutoFormatObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScAutoFormatObjUnoTunnelId> {};
430 : }
431 :
432 8 : const uno::Sequence<sal_Int8>& ScAutoFormatObj::getUnoTunnelId()
433 : {
434 8 : return theScAutoFormatObjUnoTunnelId::get().getSeq();
435 : }
436 :
437 4 : ScAutoFormatObj* ScAutoFormatObj::getImplementation(
438 : const uno::Reference<uno::XInterface> xObj )
439 : {
440 4 : ScAutoFormatObj* pRet = NULL;
441 4 : uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
442 4 : if (xUT.is())
443 4 : pRet = reinterpret_cast<ScAutoFormatObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
444 4 : return pRet;
445 : }
446 :
447 0 : void ScAutoFormatObj::Notify( SfxBroadcaster& /* rBC */, const SfxHint& /* rHint */ )
448 : {
449 : // spaeter...
450 0 : }
451 :
452 : // XTableAutoFormat
453 :
454 8 : ScAutoFormatFieldObj* ScAutoFormatObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
455 : {
456 8 : if ( IsInserted() && nIndex < SC_AF_FIELD_COUNT )
457 8 : return new ScAutoFormatFieldObj( nFormatIndex, nIndex );
458 :
459 0 : return NULL;
460 : }
461 :
462 : // container::XEnumerationAccess
463 :
464 2 : uno::Reference<container::XEnumeration> SAL_CALL ScAutoFormatObj::createEnumeration()
465 : throw(uno::RuntimeException, std::exception)
466 : {
467 2 : SolarMutexGuard aGuard;
468 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.TableAutoFormatEnumeration"));
469 : }
470 :
471 : // container::XIndexAccess
472 :
473 14 : sal_Int32 SAL_CALL ScAutoFormatObj::getCount() throw(uno::RuntimeException, std::exception)
474 : {
475 14 : SolarMutexGuard aGuard;
476 14 : if (IsInserted())
477 14 : return SC_AF_FIELD_COUNT; // immer 16 Elemente
478 : else
479 0 : return 0;
480 : }
481 :
482 10 : uno::Any SAL_CALL ScAutoFormatObj::getByIndex( sal_Int32 nIndex )
483 : throw(lang::IndexOutOfBoundsException,
484 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
485 : {
486 10 : SolarMutexGuard aGuard;
487 :
488 10 : if ( nIndex < 0 || nIndex >= getCount() )
489 2 : throw lang::IndexOutOfBoundsException();
490 :
491 8 : if (IsInserted())
492 8 : return uno::makeAny(uno::Reference< beans::XPropertySet >(GetObjectByIndex_Impl((sal_uInt16)nIndex)));
493 2 : return uno::Any();
494 : }
495 :
496 2 : uno::Type SAL_CALL ScAutoFormatObj::getElementType() throw(uno::RuntimeException, std::exception)
497 : {
498 2 : SolarMutexGuard aGuard;
499 2 : return cppu::UnoType<beans::XPropertySet>::get(); // muss zu getByIndex passen
500 : }
501 :
502 2 : sal_Bool SAL_CALL ScAutoFormatObj::hasElements() throw(uno::RuntimeException, std::exception)
503 : {
504 2 : SolarMutexGuard aGuard;
505 2 : return ( getCount() != 0 );
506 : }
507 :
508 : // container::XNamed
509 :
510 10 : OUString SAL_CALL ScAutoFormatObj::getName() throw(uno::RuntimeException, std::exception)
511 : {
512 10 : SolarMutexGuard aGuard;
513 10 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
514 10 : if (IsInserted() && nFormatIndex < pFormats->size())
515 10 : return pFormats->findByIndex(nFormatIndex)->GetName();
516 :
517 0 : return OUString();
518 : }
519 :
520 4 : void SAL_CALL ScAutoFormatObj::setName( const OUString& aNewName )
521 : throw (uno::RuntimeException, std::exception)
522 : {
523 4 : SolarMutexGuard aGuard;
524 8 : OUString aNewString(aNewName);
525 4 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
526 :
527 : sal_uInt16 nDummy;
528 8 : if (IsInserted() && nFormatIndex < pFormats->size() &&
529 4 : !lcl_FindAutoFormatIndex( *pFormats, aNewName, nDummy ))
530 : {
531 4 : ScAutoFormat::iterator it = pFormats->begin();
532 4 : std::advance(it, nFormatIndex);
533 4 : ScAutoFormatData* pData = it->second;
534 : OSL_ENSURE(pData,"AutoFormat Daten nicht da");
535 :
536 4 : ScAutoFormatData* pNew = new ScAutoFormatData(*pData);
537 4 : pNew->SetName( aNewString );
538 :
539 4 : pFormats->erase(it);
540 4 : if (pFormats->insert(pNew))
541 : {
542 4 : it = pFormats->find(pNew);
543 4 : ScAutoFormat::iterator itBeg = pFormats->begin();
544 4 : nFormatIndex = std::distance(itBeg, it);
545 :
546 : //! Notify fuer andere Objekte
547 4 : pFormats->SetSaveLater(true);
548 : }
549 : else
550 : {
551 : OSL_FAIL("AutoFormat konnte nicht eingefuegt werden");
552 0 : nFormatIndex = 0; //! alter Index ist ungueltig
553 : }
554 : }
555 : else
556 : {
557 : // not inserted or name exists
558 0 : throw uno::RuntimeException();
559 4 : }
560 4 : }
561 :
562 : // beans::XPropertySet
563 :
564 26 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAutoFormatObj::getPropertySetInfo()
565 : throw(uno::RuntimeException, std::exception)
566 : {
567 26 : SolarMutexGuard aGuard;
568 26 : static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
569 26 : return aRef;
570 : }
571 :
572 36 : void SAL_CALL ScAutoFormatObj::setPropertyValue(
573 : const OUString& aPropertyName, const uno::Any& aValue )
574 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
575 : lang::IllegalArgumentException, lang::WrappedTargetException,
576 : uno::RuntimeException, std::exception)
577 : {
578 36 : SolarMutexGuard aGuard;
579 36 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
580 36 : if (IsInserted() && nFormatIndex < pFormats->size())
581 : {
582 36 : ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
583 : OSL_ENSURE(pData,"AutoFormat Daten nicht da");
584 :
585 36 : OUString aPropString(aPropertyName);
586 : bool bBool;
587 36 : if (aPropString.equalsAscii( SC_UNONAME_INCBACK ) && (aValue >>= bBool))
588 6 : pData->SetIncludeBackground( bBool );
589 30 : else if (aPropString.equalsAscii( SC_UNONAME_INCBORD ) && (aValue >>= bBool))
590 6 : pData->SetIncludeFrame( bBool );
591 24 : else if (aPropString.equalsAscii( SC_UNONAME_INCFONT ) && (aValue >>= bBool))
592 6 : pData->SetIncludeFont( bBool );
593 18 : else if (aPropString.equalsAscii( SC_UNONAME_INCJUST ) && (aValue >>= bBool))
594 6 : pData->SetIncludeJustify( bBool );
595 12 : else if (aPropString.equalsAscii( SC_UNONAME_INCNUM ) && (aValue >>= bBool))
596 6 : pData->SetIncludeValueFormat( bBool );
597 6 : else if (aPropString.equalsAscii( SC_UNONAME_INCWIDTH ) && (aValue >>= bBool))
598 6 : pData->SetIncludeWidthHeight( bBool );
599 :
600 : // else Fehler
601 :
602 : //! Notify fuer andere Objekte
603 36 : pFormats->SetSaveLater(true);
604 36 : }
605 36 : }
606 :
607 84 : uno::Any SAL_CALL ScAutoFormatObj::getPropertyValue( const OUString& aPropertyName )
608 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
609 : uno::RuntimeException, std::exception)
610 : {
611 84 : SolarMutexGuard aGuard;
612 84 : uno::Any aAny;
613 :
614 84 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
615 84 : if (IsInserted() && nFormatIndex < pFormats->size())
616 : {
617 84 : ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
618 : OSL_ENSURE(pData,"AutoFormat Daten nicht da");
619 :
620 : bool bValue;
621 84 : bool bError = false;
622 :
623 84 : if (aPropertyName.equalsAscii( SC_UNONAME_INCBACK ))
624 14 : bValue = pData->GetIncludeBackground();
625 70 : else if (aPropertyName.equalsAscii( SC_UNONAME_INCBORD ))
626 14 : bValue = pData->GetIncludeFrame();
627 56 : else if (aPropertyName.equalsAscii( SC_UNONAME_INCFONT ))
628 14 : bValue = pData->GetIncludeFont();
629 42 : else if (aPropertyName.equalsAscii( SC_UNONAME_INCJUST ))
630 14 : bValue = pData->GetIncludeJustify();
631 28 : else if (aPropertyName.equalsAscii( SC_UNONAME_INCNUM ))
632 14 : bValue = pData->GetIncludeValueFormat();
633 14 : else if (aPropertyName.equalsAscii( SC_UNONAME_INCWIDTH ))
634 14 : bValue = pData->GetIncludeWidthHeight();
635 : else
636 0 : bError = true; // unbekannte Property
637 :
638 84 : if (!bError)
639 84 : aAny <<= bValue;
640 : }
641 :
642 84 : return aAny;
643 : }
644 :
645 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAutoFormatObj )
646 :
647 8 : ScAutoFormatFieldObj::ScAutoFormatFieldObj(sal_uInt16 nFormat, sal_uInt16 nField) :
648 : aPropSet( lcl_GetAutoFieldMap() ),
649 : nFormatIndex( nFormat ),
650 8 : nFieldIndex( nField )
651 : {
652 : //! Listening !!!
653 8 : }
654 :
655 16 : ScAutoFormatFieldObj::~ScAutoFormatFieldObj()
656 : {
657 16 : }
658 :
659 0 : void ScAutoFormatFieldObj::Notify( SfxBroadcaster& /* rBC */, const SfxHint& /* rHint */ )
660 : {
661 : // spaeter...
662 0 : }
663 :
664 : // beans::XPropertySet
665 :
666 2 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAutoFormatFieldObj::getPropertySetInfo()
667 : throw(uno::RuntimeException, std::exception)
668 : {
669 2 : SolarMutexGuard aGuard;
670 2 : static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
671 2 : return aRef;
672 : }
673 :
674 172 : void SAL_CALL ScAutoFormatFieldObj::setPropertyValue(
675 : const OUString& aPropertyName, const uno::Any& aValue )
676 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
677 : lang::IllegalArgumentException, lang::WrappedTargetException,
678 : uno::RuntimeException, std::exception)
679 : {
680 172 : SolarMutexGuard aGuard;
681 172 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
682 : const SfxItemPropertySimpleEntry* pEntry =
683 172 : aPropSet.getPropertyMap().getByName( aPropertyName );
684 :
685 172 : if ( pEntry && pEntry->nWID && nFormatIndex < pFormats->size() )
686 : {
687 172 : ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
688 :
689 172 : if ( IsScItemWid( pEntry->nWID ) )
690 : {
691 168 : if( const SfxPoolItem* pItem = pData->GetItem( nFieldIndex, pEntry->nWID ) )
692 : {
693 168 : bool bDone = false;
694 :
695 168 : switch( pEntry->nWID )
696 : {
697 : case ATTR_STACKED:
698 : {
699 : table::CellOrientation eOrient;
700 4 : if( aValue >>= eOrient )
701 : {
702 4 : switch( eOrient )
703 : {
704 : case table::CellOrientation_STANDARD:
705 0 : pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
706 0 : break;
707 : case table::CellOrientation_TOPBOTTOM:
708 4 : pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
709 4 : pData->PutItem( nFieldIndex, SfxInt32Item( ATTR_ROTATE_VALUE, 27000 ) );
710 4 : break;
711 : case table::CellOrientation_BOTTOMTOP:
712 0 : pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
713 0 : pData->PutItem( nFieldIndex, SfxInt32Item( ATTR_ROTATE_VALUE, 9000 ) );
714 0 : break;
715 : case table::CellOrientation_STACKED:
716 0 : pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, true ) );
717 0 : break;
718 : default:
719 : {
720 : // added to avoid warnings
721 : }
722 : }
723 4 : bDone = true;
724 : }
725 : }
726 4 : break;
727 : default:
728 164 : SfxPoolItem* pNewItem = pItem->Clone();
729 164 : bDone = pNewItem->PutValue( aValue, pEntry->nMemberId );
730 164 : if (bDone)
731 164 : pData->PutItem( nFieldIndex, *pNewItem );
732 164 : delete pNewItem;
733 : }
734 :
735 168 : if (bDone)
736 : //! Notify fuer andere Objekte?
737 168 : pFormats->SetSaveLater(true);
738 : }
739 : }
740 : else
741 : {
742 4 : switch (pEntry->nWID)
743 : {
744 : case SC_WID_UNO_TBLBORD:
745 : {
746 4 : table::TableBorder aBorder;
747 4 : if ( aValue >>= aBorder ) // empty = nothing to do
748 : {
749 4 : SvxBoxItem aOuter(ATTR_BORDER);
750 8 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
751 4 : ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder );
752 4 : pData->PutItem( nFieldIndex, aOuter );
753 :
754 : //! Notify for other objects?
755 8 : pFormats->SetSaveLater(true);
756 : }
757 : }
758 4 : break;
759 : case SC_WID_UNO_TBLBORD2:
760 : {
761 0 : table::TableBorder2 aBorder2;
762 0 : if ( aValue >>= aBorder2 ) // empty = nothing to do
763 : {
764 0 : SvxBoxItem aOuter(ATTR_BORDER);
765 0 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
766 0 : ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder2 );
767 0 : pData->PutItem( nFieldIndex, aOuter );
768 :
769 : //! Notify for other objects?
770 0 : pFormats->SetSaveLater(true);
771 : }
772 : }
773 0 : break;
774 : }
775 : }
776 172 : }
777 172 : }
778 :
779 434 : uno::Any SAL_CALL ScAutoFormatFieldObj::getPropertyValue( const OUString& aPropertyName )
780 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
781 : uno::RuntimeException, std::exception)
782 : {
783 434 : SolarMutexGuard aGuard;
784 434 : uno::Any aVal;
785 :
786 434 : ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
787 : const SfxItemPropertySimpleEntry* pEntry =
788 434 : aPropSet.getPropertyMap().getByName( aPropertyName );
789 :
790 434 : if ( pEntry && pEntry->nWID && nFormatIndex < pFormats->size() )
791 : {
792 434 : const ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
793 :
794 434 : if ( IsScItemWid( pEntry->nWID ) )
795 : {
796 422 : if( const SfxPoolItem* pItem = pData->GetItem( nFieldIndex, pEntry->nWID ) )
797 : {
798 418 : switch( pEntry->nWID )
799 : {
800 : case ATTR_STACKED:
801 : {
802 10 : const SfxInt32Item* pRotItem = static_cast<const SfxInt32Item*>(pData->GetItem( nFieldIndex, ATTR_ROTATE_VALUE ));
803 10 : sal_Int32 nRot = pRotItem ? pRotItem->GetValue() : 0;
804 10 : bool bStacked = static_cast<const SfxBoolItem*>(pItem)->GetValue();
805 10 : SvxOrientationItem( nRot, bStacked, 0 ).QueryValue( aVal );
806 : }
807 10 : break;
808 : default:
809 408 : pItem->QueryValue( aVal, pEntry->nMemberId );
810 : }
811 : }
812 : }
813 : else
814 : {
815 12 : switch (pEntry->nWID)
816 : {
817 : case SC_WID_UNO_TBLBORD:
818 : case SC_WID_UNO_TBLBORD2:
819 : {
820 12 : const SfxPoolItem* pItem = pData->GetItem(nFieldIndex, ATTR_BORDER);
821 12 : if (pItem)
822 : {
823 12 : SvxBoxItem aOuter(*(static_cast<const SvxBoxItem*>(pItem)));
824 24 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
825 :
826 12 : if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
827 2 : ScHelperFunctions::AssignTableBorder2ToAny( aVal, aOuter, aInner);
828 : else
829 22 : ScHelperFunctions::AssignTableBorderToAny( aVal, aOuter, aInner);
830 : }
831 : }
832 12 : break;
833 : }
834 : }
835 : }
836 :
837 434 : return aVal;
838 : }
839 :
840 228 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAutoFormatFieldObj )
841 :
842 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
