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 : #include <DocumentStylePoolManager.hxx>
20 : #include <doc.hxx>
21 : #include <DocumentSettingManager.hxx>
22 : #include <IDocumentState.hxx>
23 : #include <IDocumentUndoRedo.hxx>
24 : #include <fmtanchr.hxx>
25 : #include <fmtfsize.hxx>
26 : #include <paratr.hxx>
27 : #include <poolfmt.hxx>
28 : #include <fmtornt.hxx>
29 : #include <fmtsrndenum.hxx>
30 : #include <charfmt.hxx>
31 : #include <fmtsrnd.hxx>
32 : #include <docary.hxx>
33 : #include <GetMetricVal.hxx>
34 : #include <pagedesc.hxx>
35 : #include <frmfmt.hxx>
36 : #include <fmtline.hxx>
37 : #include <numrule.hxx>
38 : #include <editeng/paperinf.hxx>
39 : #include <editeng/wghtitem.hxx>
40 : #include <editeng/fontitem.hxx>
41 : #include <editeng/fhgtitem.hxx>
42 : #include <editeng/tstpitem.hxx>
43 : #include <editeng/lrspitem.hxx>
44 : #include <editeng/ulspitem.hxx>
45 : #include <editeng/lspcitem.hxx>
46 : #include <editeng/adjustitem.hxx>
47 : #include <editeng/postitem.hxx>
48 : #include <editeng/keepitem.hxx>
49 : #include <editeng/opaqitem.hxx>
50 : #include <editeng/boxitem.hxx>
51 : #include <editeng/cmapitem.hxx>
52 : #include <editeng/udlnitem.hxx>
53 : #include <editeng/colritem.hxx>
54 : #include <editeng/protitem.hxx>
55 : #include <editeng/escapementitem.hxx>
56 : #include <editeng/langitem.hxx>
57 : #include <editeng/charrotateitem.hxx>
58 : #include <editeng/frmdiritem.hxx>
59 : #include <editeng/emphasismarkitem.hxx>
60 : #include <editeng/scriptspaceitem.hxx>
61 : #include <rcid.hrc>
62 : #include <com/sun/star/table/BorderLineStyle.hpp>
63 : #include <com/sun/star/text/VertOrientation.hpp>
64 : #include <com/sun/star/text/RelOrientation.hpp>
65 : #include <com/sun/star/text/HoriOrientation.hpp>
66 :
67 : using namespace ::editeng;
68 : using namespace ::com::sun::star;
69 :
70 : namespace
71 : {
72 : static const sal_uInt16 PT_3 = 3 * 20; // 3 pt
73 : static const sal_uInt16 PT_6 = 6 * 20; // 6 pt
74 : static const sal_uInt16 PT_7 = 7 * 20; // 7 pt
75 : static const sal_uInt16 PT_10 = 10 * 20; // 10 pt
76 : static const sal_uInt16 PT_12 = 12 * 20; // 12 pt
77 : static const sal_uInt16 PT_14 = 14 * 20; // 14 pt
78 : static const sal_uInt16 PT_16 = 16 * 20; // 16 pt
79 : static const sal_uInt16 PT_18 = 18 * 20; // 18 pt
80 : static const sal_uInt16 PT_24 = 24 * 20; // 24 pt
81 : static const sal_uInt16 PT_28 = 28 * 20; // 28 pt
82 :
83 : #define HTML_PARSPACE GetMetricVal( CM_05 )
84 :
85 : static const sal_uInt16 aHeadlineSizes[ 2 * MAXLEVEL ] = {
86 : // we do everything procentual now:
87 : 130, 115, 101, 95, 85,
88 : 85, 80, 80, 75, 75, // normal
89 : PT_24, PT_18, PT_14, PT_12, PT_10,
90 : PT_7, PT_7, PT_7, PT_7, PT_7 // HTML mode
91 : };
92 :
93 467 : static long lcl_GetRightMargin( SwDoc& rDoc )
94 : {
95 : // Make sure that the printer settings are taken over to the standard
96 : // page style
97 467 : const SwFrameFormat& rPgDscFormat = rDoc.GetPageDesc( 0 ).GetMaster();
98 467 : const SvxLRSpaceItem& rLR = rPgDscFormat.GetLRSpace();
99 467 : const long nLeft = rLR.GetLeft();
100 467 : const long nRight = rLR.GetRight();
101 467 : const long nWidth = rPgDscFormat.GetFrmSize().GetWidth();
102 467 : return nWidth - nLeft - nRight;
103 : }
104 :
105 49 : static void lcl_SetDfltFont( DefaultFontType nFntType, SfxItemSet& rSet )
106 : {
107 : static struct {
108 : sal_uInt16 nResLngId;
109 : sal_uInt16 nResFntId;
110 : } aArr[ 3 ] = {
111 : { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT },
112 : { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT },
113 : { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT }
114 : };
115 196 : for( sal_uInt16 n = 0; n < 3; ++n )
116 : {
117 : sal_uInt16 nLng = static_cast<const SvxLanguageItem&>(rSet.GetPool()->GetDefaultItem(
118 147 : aArr[n].nResLngId )).GetLanguage();
119 : vcl::Font aFnt( OutputDevice::GetDefaultFont( nFntType,
120 147 : nLng, GetDefaultFontFlags::OnlyOne ) );
121 :
122 147 : rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
123 : OUString(), aFnt.GetPitch(),
124 294 : aFnt.GetCharSet(), aArr[n].nResFntId ));
125 147 : }
126 49 : }
127 :
128 1 : static void lcl_SetDfltFont( DefaultFontType nLatinFntType, DefaultFontType nCJKFntType,
129 : DefaultFontType nCTLFntType, SfxItemSet& rSet )
130 : {
131 : static struct {
132 : sal_uInt16 nResLngId;
133 : sal_uInt16 nResFntId;
134 : DefaultFontType nFntType;
135 : } aArr[ 3 ] = {
136 : { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT, static_cast<DefaultFontType>(0) },
137 : { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT, static_cast<DefaultFontType>(0) },
138 : { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT, static_cast<DefaultFontType>(0) }
139 : };
140 1 : aArr[0].nFntType = nLatinFntType;
141 1 : aArr[1].nFntType = nCJKFntType;
142 1 : aArr[2].nFntType = nCTLFntType;
143 :
144 4 : for( sal_uInt16 n = 0; n < 3; ++n )
145 : {
146 : sal_uInt16 nLng = static_cast<const SvxLanguageItem&>(rSet.GetPool()->GetDefaultItem(
147 3 : aArr[n].nResLngId )).GetLanguage();
148 : vcl::Font aFnt( OutputDevice::GetDefaultFont( aArr[n].nFntType,
149 3 : nLng, GetDefaultFontFlags::OnlyOne ) );
150 :
151 3 : rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
152 : OUString(), aFnt.GetPitch(),
153 6 : aFnt.GetCharSet(), aArr[n].nResFntId ));
154 3 : }
155 1 : }
156 :
157 1326 : static void lcl_SetHeadline( SwDoc* pDoc, SwTextFormatColl* pColl,
158 : SfxItemSet& rSet,
159 : sal_uInt16 nOutLvlBits, sal_uInt8 nLevel, bool bItalic )
160 : {
161 1326 : SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
162 1326 : SvxFontHeightItem aHItem(240, 100, RES_CHRATR_FONTSIZE);
163 1326 : const bool bHTMLMode = pDoc->GetDocumentSettingManager().get(DocumentSettingId::HTML_MODE);
164 1326 : if( bHTMLMode )
165 1 : aHItem.SetHeight( aHeadlineSizes[ MAXLEVEL + nLevel ] );
166 : else
167 1325 : aHItem.SetHeight( PT_14, aHeadlineSizes[ nLevel ] );
168 1326 : SetAllScriptItem( rSet, aHItem );
169 :
170 1326 : if( bItalic && !bHTMLMode )
171 59 : SetAllScriptItem( rSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );
172 :
173 1326 : if( bHTMLMode )
174 : {
175 : lcl_SetDfltFont( DefaultFontType::LATIN_TEXT, DefaultFontType::CJK_TEXT,
176 1 : DefaultFontType::CTL_TEXT, rSet );
177 : }
178 :
179 1326 : if( pColl )
180 : {
181 1326 : if( !( nOutLvlBits & ( 1 << nLevel )) )
182 : {
183 1326 : pColl->AssignToListLevelOfOutlineStyle(nLevel);
184 1326 : if( !bHTMLMode )
185 : {
186 1325 : SwNumRule * pOutlineRule = pDoc->GetOutlineNumRule();
187 1325 : const SwNumFormat& rNFormat = pOutlineRule->Get( nLevel );
188 :
189 2650 : if ( rNFormat.GetPositionAndSpaceMode() ==
190 1328 : SvxNumberFormat::LABEL_WIDTH_AND_POSITION &&
191 6 : ( rNFormat.GetAbsLSpace() || rNFormat.GetFirstLineOffset() ) )
192 : {
193 0 : SvxLRSpaceItem aLR( static_cast<const SvxLRSpaceItem&>(pColl->GetFormatAttr( RES_LR_SPACE )) );
194 0 : aLR.SetTextFirstLineOfstValue( rNFormat.GetFirstLineOffset() );
195 0 : aLR.SetTextLeft( rNFormat.GetAbsLSpace() );
196 0 : pColl->SetFormatAttr( aLR );
197 : }
198 :
199 : // #i71764#
200 : // Check on document setting OUTLINE_LEVEL_YIELDS_OUTLINE_RULE no longer needed.
201 : // All paragraph styles, which are assigned to a level of the
202 : // outline style has to have the outline style set as its list style.
203 : {
204 1325 : SwNumRuleItem aItem(pOutlineRule->GetName());
205 :
206 1325 : pColl->SetFormatAttr(aItem);
207 : }
208 : }
209 : }
210 1326 : pColl->SetNextTextFormatColl( *pDoc->getIDocumentStylePoolAccess().GetTextCollFromPool(
211 1326 : RES_POOLCOLL_TEXT ));
212 1326 : }
213 1326 : }
214 :
215 258 : static void lcl_SetRegister( SwDoc* pDoc, SfxItemSet& rSet, sal_uInt16 nFact,
216 : bool bHeader, bool bTab )
217 : {
218 258 : SvxLRSpaceItem aLR( RES_LR_SPACE );
219 258 : sal_uInt16 nLeft = nFact ? GetMetricVal( CM_05 ) * nFact : 0;
220 258 : aLR.SetTextLeft( nLeft );
221 :
222 258 : rSet.Put( aLR );
223 258 : if( bHeader )
224 : {
225 58 : SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
226 58 : SetAllScriptItem( rSet, SvxFontHeightItem( PT_16, 100, RES_CHRATR_FONTSIZE ) );
227 : }
228 258 : if( bTab )
229 : {
230 180 : long nRightMargin = lcl_GetRightMargin( *pDoc );
231 180 : SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
232 : aTStops.Insert( SvxTabStop( nRightMargin - nLeft,
233 : SVX_TAB_ADJUST_RIGHT,
234 180 : cDfltDecimalChar, '.' ));
235 180 : rSet.Put( aTStops );
236 258 : }
237 258 : }
238 :
239 120 : static void lcl_SetNumBul( SwDoc* pDoc, SwTextFormatColl* pColl,
240 : SfxItemSet& rSet,
241 : sal_uInt16 nNxt, SwTwips nEZ, SwTwips nLeft,
242 : SwTwips nUpper, SwTwips nLower )
243 : {
244 :
245 240 : SvxLRSpaceItem aLR( RES_LR_SPACE ); SvxULSpaceItem aUL( RES_UL_SPACE );
246 120 : aLR.SetTextFirstLineOfst( sal_uInt16(nEZ) ); aLR.SetTextLeft( sal_uInt16(nLeft) );
247 120 : aUL.SetUpper( sal_uInt16(nUpper) ); aUL.SetLower( sal_uInt16(nLower) );
248 120 : rSet.Put( aLR );
249 120 : rSet.Put( aUL );
250 :
251 120 : if( pColl )
252 240 : pColl->SetNextTextFormatColl( *pDoc->getIDocumentStylePoolAccess().GetTextCollFromPool( nNxt ));
253 120 : }
254 :
255 358 : static void lcl_PutStdPageSizeIntoItemSet( SwDoc* pDoc, SfxItemSet& rSet )
256 : {
257 358 : SwPageDesc* pStdPgDsc = pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_STANDARD );
258 358 : SwFormatFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
259 358 : if( pStdPgDsc->GetLandscape() )
260 : {
261 1 : SwTwips nTmp = aFrmSz.GetHeight();
262 1 : aFrmSz.SetHeight( aFrmSz.GetWidth() );
263 1 : aFrmSz.SetWidth( nTmp );
264 : }
265 358 : rSet.Put( aFrmSz );
266 358 : }
267 : }
268 :
269 :
270 : namespace sw
271 : {
272 :
273 2958 : DocumentStylePoolManager::DocumentStylePoolManager( SwDoc& i_rSwdoc ) : m_rDoc( i_rSwdoc )
274 : {
275 2958 : }
276 :
277 96667 : SwTextFormatColl* DocumentStylePoolManager::GetTextCollFromPool( sal_uInt16 nId, bool bRegardLanguage )
278 : {
279 : OSL_ENSURE(
280 : (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
281 : (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
282 : (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
283 : (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
284 : (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
285 : (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
286 : "Wrong AutoFormat Id" );
287 :
288 : SwTextFormatColl* pNewColl;
289 96667 : sal_uInt16 nOutLvlBits = 0;
290 572170 : for( size_t n = 0; n < m_rDoc.GetTextFormatColls()->size(); ++n )
291 : {
292 545472 : if( nId == ( pNewColl = (*m_rDoc.GetTextFormatColls())[ n ] )->GetPoolFormatId() )
293 : {
294 69969 : return pNewColl;
295 : }
296 :
297 475503 : if( pNewColl->IsAssignedToListLevelOfOutlineStyle())
298 3974 : nOutLvlBits |= ( 1 << pNewColl->GetAssignedOutlineStyleLevel() );
299 : }
300 :
301 : // Didn't find it until here -> create anew
302 26698 : sal_uInt16 nResId = 0;
303 26698 : if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END )
304 12213 : nResId = RC_POOLCOLL_TEXT_BEGIN - RES_POOLCOLL_TEXT_BEGIN;
305 14485 : else if (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END)
306 3219 : nResId = RC_POOLCOLL_LISTS_BEGIN - RES_POOLCOLL_LISTS_BEGIN;
307 11266 : else if (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END)
308 5473 : nResId = RC_POOLCOLL_EXTRA_BEGIN - RES_POOLCOLL_EXTRA_BEGIN;
309 5793 : else if (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END)
310 4357 : nResId = RC_POOLCOLL_REGISTER_BEGIN - RES_POOLCOLL_REGISTER_BEGIN;
311 1436 : else if (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END)
312 1026 : nResId = RC_POOLCOLL_DOC_BEGIN - RES_POOLCOLL_DOC_BEGIN;
313 410 : else if (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END)
314 410 : nResId = RC_POOLCOLL_HTML_BEGIN - RES_POOLCOLL_HTML_BEGIN;
315 :
316 : OSL_ENSURE( nResId, "Invalid Pool ID" );
317 26698 : if( !nResId )
318 0 : return GetTextCollFromPool( RES_POOLCOLL_STANDARD );
319 :
320 26698 : ResId aResId( nResId + nId, *pSwResMgr );
321 26698 : OUString aNm( aResId );
322 :
323 : // A Set for all to-be-set Attributes
324 53396 : SwAttrSet aSet( m_rDoc.GetAttrPool(), aTextFormatCollSetRange );
325 26698 : sal_uInt16 nParent = GetPoolParent( nId );
326 :
327 : {
328 :
329 : //FEATURE::CONDCOLL
330 26698 : if(::IsConditionalByPoolId( nId ))
331 2947 : pNewColl = new SwConditionTextFormatColl( m_rDoc.GetAttrPool(), aNm, !nParent
332 0 : ? m_rDoc.GetDfltTextFormatColl()
333 2947 : : GetTextCollFromPool( nParent ));
334 : else
335 : //FEATURE::CONDCOLL
336 23751 : pNewColl = new SwTextFormatColl( m_rDoc.GetAttrPool(), aNm, !nParent
337 2979 : ? m_rDoc.GetDfltTextFormatColl()
338 26730 : : GetTextCollFromPool( nParent ));
339 26698 : pNewColl->SetPoolFormatId( nId );
340 26698 : m_rDoc.GetTextFormatColls()->push_back( pNewColl );
341 : }
342 :
343 26698 : bool bNoDefault = m_rDoc.GetDocumentSettingManager().get( DocumentSettingId::STYLES_NODEFAULT );
344 26698 : if ( !bNoDefault )
345 : {
346 21357 : switch( nId )
347 : {
348 : // General content forms
349 : case RES_POOLCOLL_STANDARD:
350 : /* koreans do not like SvxScriptItem(TRUE) */
351 2979 : if (bRegardLanguage)
352 : {
353 2979 : sal_uLong nAppLanguage = GetAppLanguage();
354 2979 : if (GetDefaultFrameDirection(nAppLanguage) ==
355 : FRMDIR_HORI_RIGHT_TOP)
356 : {
357 0 : SvxAdjustItem aAdjust(SVX_ADJUST_RIGHT, RES_PARATR_ADJUST );
358 0 : aSet.Put(aAdjust);
359 : }
360 2979 : if (nAppLanguage == LANGUAGE_KOREAN)
361 : {
362 0 : SvxScriptSpaceItem aScriptSpace(false, RES_PARATR_SCRIPTSPACE);
363 0 : aSet.Put(aScriptSpace);
364 : }
365 : }
366 2979 : break;
367 :
368 : case RES_POOLCOLL_TEXT: // Text body
369 : {
370 : SvxLineSpacingItem aLSpc( LINE_SPACE_DEFAULT_HEIGHT,
371 2914 : RES_PARATR_LINESPACING );
372 5828 : SvxULSpaceItem aUL( 0, PT_7, RES_UL_SPACE );
373 2914 : aLSpc.SetPropLineSpace( (const sal_uInt8) 120 );
374 2914 : if( m_rDoc.GetDocumentSettingManager().get(DocumentSettingId::HTML_MODE) ) aUL.SetLower( HTML_PARSPACE );
375 2914 : aSet.Put( aUL );
376 5828 : aSet.Put( aLSpc );
377 : }
378 2914 : break;
379 : case RES_POOLCOLL_TEXT_IDENT: // Text body indentation
380 : {
381 10 : SvxLRSpaceItem aLR( RES_LR_SPACE );
382 10 : aLR.SetTextFirstLineOfst( GetMetricVal( CM_05 ));
383 10 : aSet.Put( aLR );
384 : }
385 10 : break;
386 : case RES_POOLCOLL_TEXT_NEGIDENT: // Text body neg. indentation
387 : {
388 3 : SvxLRSpaceItem aLR( RES_LR_SPACE );
389 3 : aLR.SetTextFirstLineOfst( -(short)GetMetricVal( CM_05 ));
390 3 : aLR.SetTextLeft( GetMetricVal( CM_1 ));
391 6 : SvxTabStopItem aTStops(RES_PARATR_TABSTOP); aTStops.Insert( SvxTabStop( 0 ));
392 :
393 3 : aSet.Put( aLR );
394 6 : aSet.Put( aTStops );
395 : }
396 3 : break;
397 : case RES_POOLCOLL_TEXT_MOVE: // Text body move
398 : {
399 21 : SvxLRSpaceItem aLR( RES_LR_SPACE );
400 21 : aLR.SetTextLeft( GetMetricVal( CM_05 ));
401 21 : aSet.Put( aLR );
402 : }
403 21 : break;
404 :
405 : case RES_POOLCOLL_CONFRONTATION: // Text body confrontation
406 : {
407 9 : SvxLRSpaceItem aLR( RES_LR_SPACE );
408 9 : aLR.SetTextFirstLineOfst( - short( GetMetricVal( CM_1 ) * 4 +
409 9 : GetMetricVal( CM_05)) );
410 9 : aLR.SetTextLeft( GetMetricVal( CM_1 ) * 5 );
411 18 : SvxTabStopItem aTStops( RES_PARATR_TABSTOP ); aTStops.Insert( SvxTabStop( 0 ));
412 :
413 9 : aSet.Put( aLR );
414 18 : aSet.Put( aTStops );
415 : }
416 9 : break;
417 : case RES_POOLCOLL_MARGINAL: // Text body marginal
418 : {
419 2 : SvxLRSpaceItem aLR( RES_LR_SPACE );
420 2 : aLR.SetTextLeft( GetMetricVal( CM_1 ) * 4 );
421 2 : aSet.Put( aLR );
422 : }
423 2 : break;
424 :
425 : case RES_POOLCOLL_HEADLINE_BASE: // Base headline
426 : {
427 : static const sal_uInt16 aFontWhich[] =
428 : { RES_CHRATR_FONT,
429 : RES_CHRATR_CJK_FONT,
430 : RES_CHRATR_CTL_FONT
431 : };
432 : static const sal_uInt16 aLangTypes[] =
433 : {
434 : RES_CHRATR_LANGUAGE,
435 : RES_CHRATR_CJK_LANGUAGE,
436 : RES_CHRATR_CTL_LANGUAGE
437 : };
438 : static const sal_uInt16 aLangs[] =
439 : {
440 : LANGUAGE_ENGLISH_US,
441 : LANGUAGE_ENGLISH_US,
442 : LANGUAGE_ARABIC_SAUDI_ARABIA
443 : };
444 : static const DefaultFontType nFontTypes[] =
445 : {
446 : DefaultFontType::LATIN_HEADING,
447 : DefaultFontType::CJK_HEADING,
448 : DefaultFontType::CTL_HEADING
449 : };
450 :
451 11624 : for( int i = 0; i < 3; ++i )
452 : {
453 8718 : sal_uInt16 nLng = static_cast<const SvxLanguageItem&>(m_rDoc.GetDefault( aLangTypes[i] )).GetLanguage();
454 8718 : if( LANGUAGE_DONTKNOW == nLng )
455 0 : nLng = aLangs[i];
456 :
457 8718 : vcl::Font aFnt( OutputDevice::GetDefaultFont( nFontTypes[i],
458 17436 : nLng, GetDefaultFontFlags::OnlyOne ) );
459 :
460 8718 : aSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
461 : OUString(), aFnt.GetPitch(),
462 17436 : aFnt.GetCharSet(), aFontWhich[i] ));
463 8718 : }
464 :
465 2906 : SvxFontHeightItem aFntSize( PT_14, 100, RES_CHRATR_FONTSIZE );
466 5812 : SvxULSpaceItem aUL( PT_12, PT_6, RES_UL_SPACE );
467 2906 : if( m_rDoc.GetDocumentSettingManager().get(DocumentSettingId::HTML_MODE) )
468 0 : aUL.SetLower( HTML_PARSPACE );
469 2906 : aSet.Put( SvxFormatKeepItem( true, RES_KEEP ));
470 :
471 2906 : pNewColl->SetNextTextFormatColl( *GetTextCollFromPool( RES_POOLCOLL_TEXT ));
472 :
473 2906 : aSet.Put( aUL );
474 5812 : SetAllScriptItem( aSet, aFntSize );
475 : }
476 2906 : break;
477 :
478 : case RES_POOLCOLL_NUMBUL_BASE: // Base Numbering
479 2913 : break;
480 :
481 : case RES_POOLCOLL_GREETING: // Greeting
482 : case RES_POOLCOLL_REGISTER_BASE: // Base indexes
483 : case RES_POOLCOLL_SIGNATURE: // Signatures
484 : case RES_POOLCOLL_TABLE: // Tabele content
485 : {
486 3109 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
487 3109 : aSet.Put( aLN );
488 : }
489 3109 : break;
490 :
491 : case RES_POOLCOLL_HEADLINE1: // Headinline 1
492 : {
493 403 : SvxULSpaceItem aUL( PT_12, PT_6, RES_UL_SPACE );
494 403 : aSet.Put( aUL );
495 403 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 0, false );
496 : }
497 403 : break;
498 : case RES_POOLCOLL_HEADLINE2: // Headinline 2
499 : {
500 397 : SvxULSpaceItem aUL( PT_10, PT_6, RES_UL_SPACE );
501 397 : aSet.Put( aUL );
502 397 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 1, false );
503 : }
504 397 : break;
505 : case RES_POOLCOLL_HEADLINE3: // Headinline 3
506 : {
507 389 : SvxULSpaceItem aUL( PT_7, PT_6, RES_UL_SPACE );
508 389 : aSet.Put( aUL );
509 389 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 2, false );
510 : }
511 389 : break;
512 : case RES_POOLCOLL_HEADLINE4: // Headinline 4
513 : {
514 21 : SvxULSpaceItem aUL( PT_6, PT_6, RES_UL_SPACE );
515 21 : aSet.Put( aUL );
516 21 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 3, true );
517 : }
518 21 : break;
519 : case RES_POOLCOLL_HEADLINE5: // Headinline 5
520 : {
521 24 : SvxULSpaceItem aUL( PT_6, PT_3, RES_UL_SPACE );
522 24 : aSet.Put( aUL );
523 24 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 4, false );
524 : }
525 24 : break;
526 : case RES_POOLCOLL_HEADLINE6: // Headinline 6
527 : {
528 19 : SvxULSpaceItem aUL( PT_3, PT_3, RES_UL_SPACE );
529 19 : aSet.Put( aUL );
530 19 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 5, true );
531 : }
532 19 : break;
533 : case RES_POOLCOLL_HEADLINE7: // Headinline 7
534 : {
535 22 : SvxULSpaceItem aUL( PT_3, PT_3, RES_UL_SPACE );
536 22 : aSet.Put( aUL );
537 22 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 6, false );
538 : }
539 22 : break;
540 : case RES_POOLCOLL_HEADLINE8: // Headinline 8
541 : {
542 19 : SvxULSpaceItem aUL( PT_3, PT_3, RES_UL_SPACE );
543 19 : aSet.Put( aUL );
544 19 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 7, true );
545 : }
546 19 : break;
547 : case RES_POOLCOLL_HEADLINE9: // Headinline 9
548 : {
549 22 : SvxULSpaceItem aUL( PT_3, PT_3, RES_UL_SPACE );
550 22 : aSet.Put( aUL );
551 22 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 8, false );
552 : }
553 22 : break;
554 : case RES_POOLCOLL_HEADLINE10: // Headinline 10
555 : {
556 10 : SvxULSpaceItem aUL( PT_3, PT_3, RES_UL_SPACE );
557 10 : aSet.Put( aUL );
558 10 : lcl_SetHeadline( &m_rDoc, pNewColl, aSet, nOutLvlBits, 9, false );
559 : }
560 10 : break;
561 :
562 : // Special sections:
563 : // Header
564 : case RES_POOLCOLL_HEADER:
565 : case RES_POOLCOLL_HEADERL:
566 : case RES_POOLCOLL_HEADERR:
567 : // Footer
568 : case RES_POOLCOLL_FOOTER:
569 : case RES_POOLCOLL_FOOTERL:
570 : case RES_POOLCOLL_FOOTERR:
571 : {
572 287 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
573 287 : aSet.Put( aLN );
574 :
575 287 : long nRightMargin = lcl_GetRightMargin( m_rDoc );
576 :
577 574 : SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
578 287 : aTStops.Insert( SvxTabStop( nRightMargin / 2, SVX_TAB_ADJUST_CENTER ) );
579 287 : aTStops.Insert( SvxTabStop( nRightMargin, SVX_TAB_ADJUST_RIGHT ) );
580 :
581 574 : aSet.Put( aTStops );
582 : }
583 287 : break;
584 :
585 : case RES_POOLCOLL_TABLE_HDLN:
586 : {
587 149 : SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
588 149 : aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );
589 149 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
590 149 : aSet.Put( aLN );
591 : }
592 149 : break;
593 :
594 : case RES_POOLCOLL_FOOTNOTE: // paragraph style Footnote
595 : case RES_POOLCOLL_ENDNOTE: // paragraph style Endnote
596 : {
597 170 : SvxLRSpaceItem aLR( RES_LR_SPACE );
598 170 : aLR.SetTextFirstLineOfst( -(short)( GetMetricVal( CM_05 ) + GetMetricVal( CM_01 ) ) );
599 170 : aLR.SetTextLeft( GetMetricVal( CM_05 ) + GetMetricVal( CM_01 ) );
600 170 : SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
601 170 : aSet.Put( aLR );
602 340 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
603 340 : aSet.Put( aLN );
604 : }
605 170 : break;
606 :
607 : case RES_POOLCOLL_LABEL: // basic caption
608 : {
609 2913 : SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetUpper( PT_6 ); aUL.SetLower( PT_6 );
610 2913 : aSet.Put( aUL );
611 2913 : SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );
612 2913 : SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
613 5826 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
614 5826 : aSet.Put( aLN );
615 : }
616 2913 : break;
617 :
618 : case RES_POOLCOLL_FRAME: // Frame content
619 : case RES_POOLCOLL_LABEL_ABB: // caption image
620 : case RES_POOLCOLL_LABEL_TABLE: // caption table
621 : case RES_POOLCOLL_LABEL_FRAME: // caption frame
622 : case RES_POOLCOLL_LABEL_DRAWING: // caption drawing
623 134 : break;
624 :
625 : case RES_POOLCOLL_JAKETADRESS: // envelope address
626 : {
627 5 : SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
628 5 : aSet.Put( aUL );
629 10 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
630 10 : aSet.Put( aLN );
631 : }
632 5 : break;
633 :
634 : case RES_POOLCOLL_SENDADRESS: // Sender address
635 : {
636 12 : if( m_rDoc.GetDocumentSettingManager().get(DocumentSettingId::HTML_MODE) )
637 0 : SetAllScriptItem( aSet, SvxPostureItem(ITALIC_NORMAL, RES_CHRATR_POSTURE) );
638 : else
639 : {
640 12 : SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
641 12 : aSet.Put( aUL );
642 : }
643 12 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
644 12 : aSet.Put( aLN );
645 : }
646 12 : break;
647 :
648 : // User defined indexes:
649 : case RES_POOLCOLL_TOX_USERH: // Header
650 8 : lcl_SetRegister( &m_rDoc, aSet, 0, true, false );
651 : {
652 8 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
653 8 : aSet.Put( aLN );
654 : }
655 8 : break;
656 : case RES_POOLCOLL_TOX_USER1: // 1. Level
657 6 : lcl_SetRegister( &m_rDoc, aSet, 0, false, true );
658 6 : break;
659 : case RES_POOLCOLL_TOX_USER2: // 2. Level
660 5 : lcl_SetRegister( &m_rDoc, aSet, 1, false, true );
661 5 : break;
662 : case RES_POOLCOLL_TOX_USER3: // 3. Level
663 2 : lcl_SetRegister( &m_rDoc, aSet, 2, false, true );
664 2 : break;
665 : case RES_POOLCOLL_TOX_USER4: // 4. Level
666 2 : lcl_SetRegister( &m_rDoc, aSet, 3, false, true );
667 2 : break;
668 : case RES_POOLCOLL_TOX_USER5: // 5. Level
669 2 : lcl_SetRegister( &m_rDoc, aSet, 4, false, true );
670 2 : break;
671 : case RES_POOLCOLL_TOX_USER6: // 6. Level
672 2 : lcl_SetRegister( &m_rDoc, aSet, 5, false, true );
673 2 : break;
674 : case RES_POOLCOLL_TOX_USER7: // 7. Level
675 2 : lcl_SetRegister( &m_rDoc, aSet, 6, false, true );
676 2 : break;
677 : case RES_POOLCOLL_TOX_USER8: // 8. Level
678 2 : lcl_SetRegister( &m_rDoc, aSet, 7, false, true );
679 2 : break;
680 : case RES_POOLCOLL_TOX_USER9: // 9. Level
681 2 : lcl_SetRegister( &m_rDoc, aSet, 8, false, true );
682 2 : break;
683 : case RES_POOLCOLL_TOX_USER10: // 10. Level
684 5 : lcl_SetRegister( &m_rDoc, aSet, 9, false, true );
685 5 : break;
686 :
687 : // Index
688 : case RES_POOLCOLL_TOX_IDXH: // Header
689 8 : lcl_SetRegister( &m_rDoc, aSet, 0, true, false );
690 : {
691 8 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
692 8 : aSet.Put( aLN );
693 : }
694 8 : break;
695 : case RES_POOLCOLL_TOX_IDX1: // 1. Level
696 7 : lcl_SetRegister( &m_rDoc, aSet, 0, false, false );
697 7 : break;
698 : case RES_POOLCOLL_TOX_IDX2: // 2. Level
699 5 : lcl_SetRegister( &m_rDoc, aSet, 1, false, false );
700 5 : break;
701 : case RES_POOLCOLL_TOX_IDX3: // 3. Level
702 4 : lcl_SetRegister( &m_rDoc, aSet, 2, false, false );
703 4 : break;
704 : case RES_POOLCOLL_TOX_IDXBREAK: // Trenner
705 4 : lcl_SetRegister( &m_rDoc, aSet, 0, false, false );
706 4 : break;
707 :
708 : // Table of Content
709 : case RES_POOLCOLL_TOX_CNTNTH: // Header
710 20 : lcl_SetRegister( &m_rDoc, aSet, 0, true, false );
711 : {
712 20 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
713 20 : aSet.Put( aLN );
714 : }
715 20 : break;
716 : case RES_POOLCOLL_TOX_CNTNT1: // 1. Level
717 19 : lcl_SetRegister( &m_rDoc, aSet, 0, false, true );
718 19 : break;
719 : case RES_POOLCOLL_TOX_CNTNT2: // 2. Level
720 18 : lcl_SetRegister( &m_rDoc, aSet, 1, false, true );
721 18 : break;
722 : case RES_POOLCOLL_TOX_CNTNT3: // 3. Level
723 20 : lcl_SetRegister( &m_rDoc, aSet, 2, false, true );
724 20 : break;
725 : case RES_POOLCOLL_TOX_CNTNT4: // 4. Level
726 15 : lcl_SetRegister( &m_rDoc, aSet, 3, false, true );
727 15 : break;
728 : case RES_POOLCOLL_TOX_CNTNT5: // 5. Level
729 11 : lcl_SetRegister( &m_rDoc, aSet, 4, false, true );
730 11 : break;
731 : case RES_POOLCOLL_TOX_CNTNT6: // 6. Level
732 11 : lcl_SetRegister( &m_rDoc, aSet, 5, false, true );
733 11 : break;
734 : case RES_POOLCOLL_TOX_CNTNT7: // 7. Level
735 11 : lcl_SetRegister( &m_rDoc, aSet, 6, false, true );
736 11 : break;
737 : case RES_POOLCOLL_TOX_CNTNT8: // 8. Level
738 11 : lcl_SetRegister( &m_rDoc, aSet, 7, false, true );
739 11 : break;
740 : case RES_POOLCOLL_TOX_CNTNT9: // 9. Level
741 11 : lcl_SetRegister( &m_rDoc, aSet, 8, false, true );
742 11 : break;
743 : case RES_POOLCOLL_TOX_CNTNT10: // 10. Level
744 8 : lcl_SetRegister( &m_rDoc, aSet, 9, false, true );
745 8 : break;
746 :
747 : case RES_POOLCOLL_TOX_ILLUSH:
748 : case RES_POOLCOLL_TOX_OBJECTH:
749 : case RES_POOLCOLL_TOX_TABLESH:
750 : case RES_POOLCOLL_TOX_AUTHORITIESH:
751 22 : lcl_SetRegister( &m_rDoc, aSet, 0, true, false );
752 : {
753 22 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
754 22 : aSet.Put( aLN );
755 : }
756 22 : break;
757 : case RES_POOLCOLL_TOX_ILLUS1:
758 : case RES_POOLCOLL_TOX_OBJECT1:
759 : case RES_POOLCOLL_TOX_TABLES1:
760 : case RES_POOLCOLL_TOX_AUTHORITIES1:
761 15 : lcl_SetRegister( &m_rDoc, aSet, 0, false, true );
762 15 : break;
763 :
764 : case RES_POOLCOLL_NUM_LEVEL1S:
765 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
766 4 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
767 4 : PT_12, PT_6 );
768 4 : break;
769 : case RES_POOLCOLL_NUM_LEVEL1:
770 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
771 8 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
772 8 : 0, PT_6 );
773 8 : break;
774 : case RES_POOLCOLL_NUM_LEVEL1E:
775 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
776 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
777 2 : 0, PT_12 );
778 2 : break;
779 : case RES_POOLCOLL_NUM_NONUM1:
780 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM1,
781 4 : 0, SwNumRule::GetNumIndent( 0 ), 0, PT_6 );
782 4 : break;
783 : case RES_POOLCOLL_NUM_LEVEL2S:
784 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
785 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
786 2 : PT_12, PT_6 );
787 2 : break;
788 : case RES_POOLCOLL_NUM_LEVEL2:
789 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
790 5 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
791 5 : 0, PT_6 );
792 5 : break;
793 : case RES_POOLCOLL_NUM_LEVEL2E:
794 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
795 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
796 2 : 0, PT_12 );
797 2 : break;
798 : case RES_POOLCOLL_NUM_NONUM2:
799 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM2,
800 3 : 0, SwNumRule::GetNumIndent( 1 ), 0, PT_6 );
801 3 : break;
802 : case RES_POOLCOLL_NUM_LEVEL3S:
803 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
804 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
805 2 : PT_12, PT_6 );
806 2 : break;
807 : case RES_POOLCOLL_NUM_LEVEL3:
808 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
809 4 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
810 4 : 0, PT_6 );
811 4 : break;
812 : case RES_POOLCOLL_NUM_LEVEL3E:
813 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
814 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
815 2 : 0, PT_12 );
816 2 : break;
817 : case RES_POOLCOLL_NUM_NONUM3:
818 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM3,
819 2 : 0, SwNumRule::GetNumIndent( 2 ), 0, PT_6 );
820 2 : break;
821 : case RES_POOLCOLL_NUM_LEVEL4S:
822 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
823 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
824 2 : PT_12, PT_6 );
825 2 : break;
826 : case RES_POOLCOLL_NUM_LEVEL4:
827 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
828 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
829 2 : 0, PT_6 );
830 2 : break;
831 : case RES_POOLCOLL_NUM_LEVEL4E:
832 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
833 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
834 2 : 0, PT_12 );
835 2 : break;
836 : case RES_POOLCOLL_NUM_NONUM4:
837 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM4,
838 2 : 0, SwNumRule::GetNumIndent( 3 ), 0, PT_6 );
839 2 : break;
840 : case RES_POOLCOLL_NUM_LEVEL5S:
841 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
842 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
843 2 : PT_12, PT_6 );
844 2 : break;
845 : case RES_POOLCOLL_NUM_LEVEL5:
846 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
847 4 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
848 4 : 0, PT_6 );
849 4 : break;
850 : case RES_POOLCOLL_NUM_LEVEL5E:
851 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
852 2 : lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
853 2 : 0, PT_12 );
854 2 : break;
855 : case RES_POOLCOLL_NUM_NONUM5:
856 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM5,
857 2 : 0, SwNumRule::GetNumIndent( 4 ), 0, PT_6 );
858 2 : break;
859 :
860 : case RES_POOLCOLL_BUL_LEVEL1S:
861 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
862 3 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
863 3 : PT_12, PT_6 );
864 3 : break;
865 : case RES_POOLCOLL_BUL_LEVEL1:
866 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
867 6 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
868 6 : 0, PT_6 );
869 6 : break;
870 : case RES_POOLCOLL_BUL_LEVEL1E:
871 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
872 4 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
873 4 : 0, PT_12 );
874 4 : break;
875 : case RES_POOLCOLL_BUL_NONUM1:
876 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM1,
877 4 : 0, SwNumRule::GetBullIndent( 0 ), 0, PT_6 );
878 4 : break;
879 : case RES_POOLCOLL_BUL_LEVEL2S:
880 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
881 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
882 2 : PT_12, PT_6 );
883 2 : break;
884 : case RES_POOLCOLL_BUL_LEVEL2:
885 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
886 4 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
887 4 : 0, PT_6 );
888 4 : break;
889 : case RES_POOLCOLL_BUL_LEVEL2E:
890 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
891 3 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
892 3 : 0, PT_12 );
893 3 : break;
894 : case RES_POOLCOLL_BUL_NONUM2:
895 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM2,
896 3 : 0, SwNumRule::GetBullIndent( 1 ), 0, PT_6 );
897 3 : break;
898 : case RES_POOLCOLL_BUL_LEVEL3S:
899 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
900 3 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
901 3 : PT_12, PT_6 );
902 3 : break;
903 : case RES_POOLCOLL_BUL_LEVEL3:
904 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
905 5 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
906 5 : 0, PT_6 );
907 5 : break;
908 : case RES_POOLCOLL_BUL_LEVEL3E:
909 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
910 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
911 2 : 0, PT_12 );
912 2 : break;
913 : case RES_POOLCOLL_BUL_NONUM3:
914 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM3,
915 2 : 0, SwNumRule::GetBullIndent( 2 ), 0, PT_6 );
916 2 : break;
917 : case RES_POOLCOLL_BUL_LEVEL4S:
918 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
919 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
920 2 : PT_12, PT_6 );
921 2 : break;
922 : case RES_POOLCOLL_BUL_LEVEL4:
923 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
924 4 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
925 4 : 0, PT_6 );
926 4 : break;
927 : case RES_POOLCOLL_BUL_LEVEL4E:
928 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
929 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
930 2 : 0, PT_12 );
931 2 : break;
932 : case RES_POOLCOLL_BUL_NONUM4:
933 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM4,
934 2 : 0, SwNumRule::GetBullIndent( 3 ), 0, PT_6 );
935 2 : break;
936 : case RES_POOLCOLL_BUL_LEVEL5S:
937 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
938 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
939 2 : PT_12, PT_6 );
940 2 : break;
941 : case RES_POOLCOLL_BUL_LEVEL5:
942 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
943 3 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
944 3 : 0, PT_6 );
945 3 : break;
946 : case RES_POOLCOLL_BUL_LEVEL5E:
947 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
948 2 : lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
949 2 : 0, PT_12 );
950 2 : break;
951 : case RES_POOLCOLL_BUL_NONUM5:
952 : lcl_SetNumBul( &m_rDoc, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM5,
953 4 : 0, SwNumRule::GetBullIndent( 4 ), 0, PT_6 );
954 4 : break;
955 :
956 : case RES_POOLCOLL_DOC_TITEL: // Document Title
957 : {
958 363 : SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
959 363 : SetAllScriptItem( aSet, SvxFontHeightItem( PT_28, 100, RES_CHRATR_FONTSIZE ) );
960 :
961 363 : aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );
962 :
963 363 : pNewColl->SetNextTextFormatColl( *GetTextCollFromPool( RES_POOLCOLL_TEXT ));
964 : }
965 363 : break;
966 :
967 : case RES_POOLCOLL_DOC_SUBTITEL: // Document subtitle
968 : {
969 367 : SvxULSpaceItem aUL( PT_3, PT_6, RES_UL_SPACE );
970 367 : aSet.Put( aUL );
971 367 : SetAllScriptItem( aSet, SvxFontHeightItem( PT_18, 100, RES_CHRATR_FONTSIZE ));
972 :
973 367 : aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ));
974 :
975 : pNewColl->SetNextTextFormatColl( *GetTextCollFromPool(
976 367 : RES_POOLCOLL_TEXT ));
977 : }
978 367 : break;
979 :
980 : case RES_POOLCOLL_HTML_BLOCKQUOTE:
981 : {
982 355 : SvxLRSpaceItem aLR( RES_LR_SPACE );
983 355 : aLR.SetLeft( GetMetricVal( CM_1 ));
984 355 : aLR.SetRight( GetMetricVal( CM_1 ));
985 355 : aSet.Put( aLR );
986 710 : SvxULSpaceItem aUL( RES_UL_SPACE );
987 355 : aUL = pNewColl->GetULSpace();
988 355 : aUL.SetLower( HTML_PARSPACE );
989 710 : aSet.Put( aUL);
990 : }
991 355 : break;
992 :
993 : case RES_POOLCOLL_HTML_PRE:
994 : {
995 11 : ::lcl_SetDfltFont( DefaultFontType::FIXED, aSet );
996 :
997 : // WORKAROUND: Set PRE to 10pt
998 11 : SetAllScriptItem( aSet, SvxFontHeightItem(PT_10, 100, RES_CHRATR_FONTSIZE) );
999 :
1000 : // The lower paragraph distance is set explicitly (makes
1001 : // assigning hard attributes easier)
1002 11 : SvxULSpaceItem aULSpaceItem( RES_UL_SPACE );
1003 11 : aULSpaceItem = pNewColl->GetULSpace();
1004 11 : aULSpaceItem.SetLower( 0 );
1005 11 : aSet.Put( aULSpaceItem );
1006 : }
1007 11 : break;
1008 :
1009 : case RES_POOLCOLL_HTML_HR:
1010 : {
1011 6 : SvxBoxItem aBox( RES_BOX );
1012 6 : Color aColor( COL_GRAY );
1013 6 : SvxBorderLine aNew(&aColor, 1, table::BorderLineStyle::DOUBLE);
1014 6 : aBox.SetLine( &aNew, SvxBoxItemLine::BOTTOM );
1015 :
1016 6 : aSet.Put( aBox );
1017 6 : aSet.Put( SwParaConnectBorderItem( false ) );
1018 6 : SetAllScriptItem( aSet, SvxFontHeightItem(120, 100, RES_CHRATR_FONTSIZE) );
1019 :
1020 12 : SvxULSpaceItem aUL( RES_UL_SPACE );
1021 : {
1022 : pNewColl->SetNextTextFormatColl( *GetTextCollFromPool(
1023 6 : RES_POOLCOLL_TEXT ));
1024 6 : aUL = pNewColl->GetULSpace();
1025 : }
1026 6 : aUL.SetLower( HTML_PARSPACE );
1027 6 : aSet.Put( aUL);
1028 12 : SwFormatLineNumber aLN; aLN.SetCountLines( false );
1029 12 : aSet.Put( aLN );
1030 : }
1031 6 : break;
1032 :
1033 : case RES_POOLCOLL_HTML_DD:
1034 : {
1035 13 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1036 13 : aLR = pNewColl->GetLRSpace();
1037 : // We indent by 1 cm. The IDs are always 2 away from each other!
1038 13 : aLR.SetLeft( GetMetricVal( CM_1 ));
1039 13 : aSet.Put( aLR );
1040 : }
1041 13 : break;
1042 : case RES_POOLCOLL_HTML_DT:
1043 : {
1044 2 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1045 : {
1046 : pNewColl->SetNextTextFormatColl( *GetTextCollFromPool(
1047 2 : RES_POOLCOLL_HTML_DD ));
1048 2 : aLR = pNewColl->GetLRSpace();
1049 : }
1050 : // We indent by 0 cm. The IDs are always 2 away from each other!
1051 2 : aLR.SetLeft( 0 );
1052 2 : aSet.Put( aLR );
1053 : }
1054 2 : break;
1055 : }
1056 : }
1057 :
1058 26698 : if( aSet.Count() )
1059 : {
1060 : {
1061 15331 : pNewColl->SetFormatAttr( aSet );
1062 : }
1063 : }
1064 53396 : return pNewColl;
1065 : }
1066 :
1067 : /// Return the AutomaticFormat with the supplied Id. If it doesn't
1068 : /// exist, create it.
1069 22879 : SwFormat* DocumentStylePoolManager::GetFormatFromPool( sal_uInt16 nId )
1070 : {
1071 22879 : SwFormat *pNewFormat = 0;
1072 22879 : SwFormat *pDeriveFormat = 0;
1073 :
1074 : SwFormatsBase* pArray[ 2 ];
1075 22879 : sal_uInt16 nArrCnt = 1, nRCId = 0;
1076 22879 : sal_uInt16* pWhichRange = 0;
1077 :
1078 22879 : switch( nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
1079 : {
1080 : case POOLGRP_CHARFMT:
1081 : {
1082 19308 : pArray[0] = m_rDoc.GetCharFormats();
1083 19308 : pDeriveFormat = m_rDoc.GetDfltCharFormat();
1084 :
1085 19308 : if( nId > RES_POOLCHR_NORMAL_END )
1086 240 : nRCId = RC_POOLCHRFMT_HTML_BEGIN - RES_POOLCHR_HTML_BEGIN;
1087 : else
1088 19068 : nRCId = RC_POOLCHRFMT_BEGIN - RES_POOLCHR_BEGIN;
1089 19308 : pWhichRange = aCharFormatSetRange;
1090 :
1091 : // Fault: unknown Format, but a CharFormat
1092 : // -> return the first one
1093 19308 : if( RES_POOLCHR_BEGIN > nId || nId >= RES_POOLCHR_END )
1094 : {
1095 : OSL_ENSURE( false, "invalid Id" );
1096 0 : nId = RES_POOLCHR_BEGIN;
1097 : }
1098 : }
1099 19308 : break;
1100 : case POOLGRP_FRAMEFMT:
1101 : {
1102 3571 : pArray[0] = m_rDoc.GetFrameFormats();
1103 3571 : pArray[1] = m_rDoc.GetSpzFrameFormats();
1104 3571 : pDeriveFormat = m_rDoc.GetDfltFrameFormat();
1105 3571 : nArrCnt = 2;
1106 3571 : nRCId = RC_POOLFRMFMT_BEGIN - RES_POOLFRM_BEGIN;
1107 3571 : pWhichRange = aFrameFormatSetRange;
1108 :
1109 : // Fault: unknown Format, but a FrameFormat
1110 : // -> return the first one
1111 3571 : if( RES_POOLFRM_BEGIN > nId || nId >= RES_POOLFRM_END )
1112 : {
1113 : OSL_ENSURE( false, "invalid Id" );
1114 0 : nId = RES_POOLFRM_BEGIN;
1115 : }
1116 : }
1117 3571 : break;
1118 :
1119 : default:
1120 : // Fault, unknown Format
1121 : OSL_ENSURE( nId, "invalid Id" );
1122 0 : return 0;
1123 : }
1124 : OSL_ENSURE( nRCId, "invalid Id" );
1125 :
1126 52226 : while( nArrCnt-- )
1127 210550 : for( size_t n = 0; n < (*pArray[nArrCnt]).GetFormatCount(); ++n )
1128 408164 : if( nId == ( pNewFormat = (*pArray[ nArrCnt ] ).GetFormat( n ) )->
1129 204082 : GetPoolFormatId() )
1130 : {
1131 19982 : return pNewFormat;
1132 : }
1133 :
1134 2897 : ResId aResId( nRCId + nId, *pSwResMgr );
1135 2897 : OUString aNm( aResId );
1136 5794 : SwAttrSet aSet( m_rDoc.GetAttrPool(), pWhichRange );
1137 :
1138 : {
1139 2897 : bool bIsModified = m_rDoc.getIDocumentState().IsModified();
1140 :
1141 : {
1142 2897 : ::sw::UndoGuard const undoGuard(m_rDoc.GetIDocumentUndoRedo());
1143 2897 : switch (nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
1144 : {
1145 : case POOLGRP_CHARFMT:
1146 1326 : pNewFormat = m_rDoc._MakeCharFormat(aNm, pDeriveFormat, false, true);
1147 1326 : break;
1148 : case POOLGRP_FRAMEFMT:
1149 1571 : pNewFormat = m_rDoc._MakeFrameFormat(aNm, pDeriveFormat, false, true);
1150 1571 : break;
1151 : default:
1152 0 : break;
1153 2897 : }
1154 : }
1155 :
1156 2897 : if( !bIsModified )
1157 647 : m_rDoc.getIDocumentState().ResetModified();
1158 2897 : pNewFormat->SetPoolFormatId( nId );
1159 2897 : pNewFormat->SetAuto( false ); // no AutoFormat
1160 : }
1161 :
1162 2897 : switch( nId )
1163 : {
1164 : case RES_POOLCHR_FOOTNOTE: // Footnote
1165 : case RES_POOLCHR_PAGENO: // Page/Field
1166 : case RES_POOLCHR_LABEL: // Label
1167 : case RES_POOLCHR_DROPCAPS: // Dropcaps
1168 : case RES_POOLCHR_NUM_LEVEL: // Numbering level
1169 : case RES_POOLCHR_TOXJUMP: // Table of contents jump
1170 : case RES_POOLCHR_ENDNOTE: // Endnote
1171 : case RES_POOLCHR_LINENUM: // Line numbering
1172 389 : break;
1173 :
1174 : case RES_POOLCHR_ENDNOTE_ANCHOR: // Endnote anchor
1175 : case RES_POOLCHR_FOOTNOTE_ANCHOR: // Footnote anchor
1176 : {
1177 108 : aSet.Put( SvxEscapementItem( DFLT_ESC_AUTO_SUPER, 58, RES_CHRATR_ESCAPEMENT ) );
1178 : }
1179 108 : break;
1180 :
1181 : case RES_POOLCHR_BUL_LEVEL: // Bullet character
1182 : {
1183 39 : const vcl::Font& rBulletFont = numfunc::GetDefBulletFont();
1184 : SetAllScriptItem( aSet, SvxFontItem( rBulletFont.GetFamily(),
1185 39 : rBulletFont.GetName(), rBulletFont.GetStyleName(),
1186 78 : rBulletFont.GetPitch(), rBulletFont.GetCharSet(), RES_CHRATR_FONT ));
1187 : }
1188 39 : break;
1189 :
1190 : case RES_POOLCHR_INET_NORMAL:
1191 : {
1192 440 : Color aCol( COL_BLUE );
1193 440 : aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1194 440 : aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
1195 : // i40133: patch submitted by rail: set language to 'none' to prevent spell checking:
1196 440 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
1197 440 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
1198 440 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
1199 : }
1200 440 : break;
1201 : case RES_POOLCHR_INET_VISIT:
1202 : {
1203 54 : Color aCol( COL_RED );
1204 54 : aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1205 54 : aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
1206 54 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
1207 54 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
1208 54 : aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
1209 : }
1210 54 : break;
1211 : case RES_POOLCHR_JUMPEDIT:
1212 : {
1213 25 : Color aCol( COL_CYAN );
1214 25 : aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1215 25 : aSet.Put( SvxUnderlineItem( UNDERLINE_DOTTED, RES_CHRATR_UNDERLINE ) );
1216 25 : aSet.Put( SvxCaseMapItem( SVX_CASEMAP_KAPITAELCHEN, RES_CHRATR_CASEMAP ) );
1217 : }
1218 25 : break;
1219 :
1220 : case RES_POOLCHR_RUBYTEXT:
1221 : {
1222 : long nH = static_cast<const SvxFontHeightItem*>(GetDfltAttr(
1223 30 : RES_CHRATR_CJK_FONTSIZE ))->GetHeight() / 2;
1224 30 : SetAllScriptItem( aSet, SvxFontHeightItem( nH, 100, RES_CHRATR_FONTSIZE));
1225 30 : aSet.Put(SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE ));
1226 30 : aSet.Put(SvxEmphasisMarkItem( EMPHASISMARK_NONE, RES_CHRATR_EMPHASIS_MARK) );
1227 : }
1228 30 : break;
1229 :
1230 : case RES_POOLCHR_HTML_EMPHASIS:
1231 : case RES_POOLCHR_HTML_CITIATION:
1232 : case RES_POOLCHR_HTML_VARIABLE:
1233 : {
1234 151 : SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE) );
1235 : }
1236 151 : break;
1237 :
1238 : case RES_POOLCHR_IDX_MAIN_ENTRY:
1239 : case RES_POOLCHR_HTML_STRONG:
1240 : {
1241 35 : SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ));
1242 : }
1243 35 : break;
1244 :
1245 : case RES_POOLCHR_HTML_CODE:
1246 : case RES_POOLCHR_HTML_SAMPLE:
1247 : case RES_POOLCHR_HTML_KEYBOARD:
1248 : case RES_POOLCHR_HTML_TELETYPE:
1249 : {
1250 38 : ::lcl_SetDfltFont( DefaultFontType::FIXED, aSet );
1251 : }
1252 38 : break;
1253 : case RES_POOLCHR_VERT_NUM:
1254 3 : aSet.Put( SvxCharRotateItem( 900, false, RES_CHRATR_ROTATE ) );
1255 3 : break;
1256 :
1257 : case RES_POOLFRM_FRAME:
1258 : {
1259 782 : if ( m_rDoc.GetDocumentSettingManager().get(DocumentSettingId::HTML_MODE) )
1260 : {
1261 1 : aSet.Put( SwFormatAnchor( FLY_AS_CHAR ));
1262 1 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::LINE_CENTER, text::RelOrientation::PRINT_AREA ) );
1263 1 : aSet.Put( SwFormatSurround( SURROUND_NONE ) );
1264 : }
1265 : else
1266 : {
1267 781 : aSet.Put( SwFormatAnchor( FLY_AT_PARA ));
1268 781 : aSet.Put( SwFormatSurround( SURROUND_PARALLEL ) );
1269 781 : aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::PRINT_AREA ) );
1270 781 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::PRINT_AREA ) );
1271 781 : Color aCol( COL_BLACK );
1272 781 : SvxBorderLine aLine( &aCol, DEF_LINE_WIDTH_0 );
1273 781 : SvxBoxItem aBox( RES_BOX );
1274 781 : aBox.SetLine( &aLine, SvxBoxItemLine::TOP );
1275 781 : aBox.SetLine( &aLine, SvxBoxItemLine::BOTTOM );
1276 781 : aBox.SetLine( &aLine, SvxBoxItemLine::LEFT );
1277 781 : aBox.SetLine( &aLine, SvxBoxItemLine::RIGHT );
1278 781 : aBox.SetDistance( 85 );
1279 781 : aSet.Put( aBox );
1280 781 : aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1281 781 : aSet.Put( SvxULSpaceItem( 114, 114, RES_UL_SPACE ) );
1282 : }
1283 :
1284 : //UUUU for styles of FlyFrames do not set the FillStyle to make it a derived attribute
1285 782 : aSet.ClearItem(XATTR_FILLSTYLE);
1286 : }
1287 782 : break;
1288 : case RES_POOLFRM_GRAPHIC:
1289 : case RES_POOLFRM_OLE:
1290 : {
1291 671 : aSet.Put( SwFormatAnchor( FLY_AT_PARA ));
1292 671 : aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
1293 671 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
1294 671 : aSet.Put( SwFormatSurround( SURROUND_IDEAL ));
1295 : }
1296 671 : break;
1297 : case RES_POOLFRM_FORMEL:
1298 : {
1299 116 : aSet.Put( SwFormatAnchor( FLY_AS_CHAR ) );
1300 116 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::CHAR_CENTER, text::RelOrientation::FRAME ) );
1301 116 : aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1302 : }
1303 116 : break;
1304 : case RES_POOLFRM_MARGINAL:
1305 : {
1306 0 : aSet.Put( SwFormatAnchor( FLY_AT_PARA ));
1307 0 : aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::FRAME ));
1308 0 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
1309 0 : aSet.Put( SwFormatSurround( SURROUND_PARALLEL ));
1310 : // Set the default width to 3.5 cm, use the minimum value for the height
1311 : aSet.Put( SwFormatFrmSize( ATT_MIN_SIZE,
1312 0 : GetMetricVal( CM_1 ) * 3 + GetMetricVal( CM_05 ),
1313 0 : MM50 ));
1314 : }
1315 0 : break;
1316 : case RES_POOLFRM_WATERSIGN:
1317 : {
1318 0 : aSet.Put( SwFormatAnchor( FLY_AT_PAGE ));
1319 0 : aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
1320 0 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::CENTER, text::RelOrientation::FRAME ));
1321 0 : aSet.Put( SvxOpaqueItem( RES_OPAQUE, false ));
1322 0 : aSet.Put( SwFormatSurround( SURROUND_THROUGHT ));
1323 : }
1324 0 : break;
1325 : case RES_POOLFRM_LABEL:
1326 : {
1327 2 : aSet.Put( SwFormatAnchor( FLY_AS_CHAR ) );
1328 2 : aSet.Put( SwFormatVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ) );
1329 2 : aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1330 :
1331 2 : SvxProtectItem aProtect( RES_PROTECT );
1332 2 : aProtect.SetSizeProtect( true );
1333 2 : aProtect.SetPosProtect( true );
1334 2 : aSet.Put( aProtect );
1335 :
1336 2 : pNewFormat->SetAutoUpdateFormat( true );
1337 : }
1338 2 : break;
1339 : }
1340 2897 : if( aSet.Count() )
1341 : {
1342 : {
1343 2494 : pNewFormat->SetFormatAttr( aSet );
1344 : }
1345 : }
1346 5794 : return pNewFormat;
1347 : }
1348 :
1349 3571 : SwFrameFormat* DocumentStylePoolManager::GetFrameFormatFromPool( sal_uInt16 nId )
1350 : {
1351 3571 : return static_cast<SwFrameFormat*>(GetFormatFromPool( nId ));
1352 : }
1353 :
1354 19308 : SwCharFormat* DocumentStylePoolManager::GetCharFormatFromPool( sal_uInt16 nId )
1355 : {
1356 19308 : return static_cast<SwCharFormat*>(GetFormatFromPool( nId ));
1357 : }
1358 :
1359 73688 : SwPageDesc* DocumentStylePoolManager::GetPageDescFromPool( sal_uInt16 nId, bool bRegardLanguage )
1360 : {
1361 : OSL_ENSURE( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
1362 : "Wrong AutoFormat Id" );
1363 :
1364 74508 : for( size_t n = 0; n < m_rDoc.GetPageDescCnt(); ++n )
1365 : {
1366 71164 : if ( nId == m_rDoc.GetPageDesc(n).GetPoolFormatId() )
1367 : {
1368 70344 : return &m_rDoc.GetPageDesc(n);
1369 : }
1370 : }
1371 :
1372 3344 : if( RES_POOLPAGE_BEGIN > nId || nId >= RES_POOLPAGE_END )
1373 : {
1374 : // unknown page pool ID
1375 : OSL_ENSURE( false, "<SwDoc::GetPageDescFromPool(..)> - unknown page pool ID" );
1376 0 : nId = RES_POOLPAGE_BEGIN;
1377 : }
1378 :
1379 3344 : SwPageDesc* pNewPgDsc = 0;
1380 : {
1381 3344 : const ResId aResId( sal_uInt32(RC_POOLPAGEDESC_BEGIN + nId - RES_POOLPAGE_BEGIN), *pSwResMgr );
1382 3344 : const OUString aNm( aResId );
1383 3344 : const bool bIsModified = m_rDoc.getIDocumentState().IsModified();
1384 :
1385 : {
1386 3344 : ::sw::UndoGuard const undoGuard(m_rDoc.GetIDocumentUndoRedo());
1387 3344 : pNewPgDsc = m_rDoc.MakePageDesc(aNm, 0, bRegardLanguage);
1388 : }
1389 :
1390 3344 : pNewPgDsc->SetPoolFormatId( nId );
1391 3344 : if ( !bIsModified )
1392 : {
1393 2966 : m_rDoc.getIDocumentState().ResetModified();
1394 3344 : }
1395 : }
1396 :
1397 3344 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1398 : {
1399 3344 : aLR.SetLeft( GetMetricVal( CM_1 ) * 2 );
1400 3344 : aLR.SetRight( aLR.GetLeft() );
1401 : }
1402 6688 : SvxULSpaceItem aUL( RES_UL_SPACE );
1403 : {
1404 3344 : aUL.SetUpper( (sal_uInt16)aLR.GetLeft() );
1405 3344 : aUL.SetLower( (sal_uInt16)aLR.GetLeft() );
1406 : }
1407 :
1408 6688 : SwAttrSet aSet( m_rDoc.GetAttrPool(), aPgFrameFormatSetRange );
1409 3344 : bool bSetLeft = true;
1410 :
1411 3344 : switch( nId )
1412 : {
1413 : case RES_POOLPAGE_STANDARD: // "Default"
1414 : {
1415 2979 : aSet.Put( aLR );
1416 2979 : aSet.Put( aUL );
1417 2979 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL | nsUseOnPage::PD_FIRSTSHARE );
1418 : }
1419 2979 : break;
1420 :
1421 : case RES_POOLPAGE_FIRST: // "First Page"
1422 : case RES_POOLPAGE_REGISTER: // "Index"
1423 : {
1424 288 : lcl_PutStdPageSizeIntoItemSet( &m_rDoc, aSet );
1425 288 : aSet.Put( aLR );
1426 288 : aSet.Put( aUL );
1427 288 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1428 288 : if( RES_POOLPAGE_FIRST == nId )
1429 285 : pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_STANDARD ));
1430 : }
1431 288 : break;
1432 :
1433 : case RES_POOLPAGE_LEFT: // "Left Page"
1434 : {
1435 8 : lcl_PutStdPageSizeIntoItemSet( &m_rDoc, aSet );
1436 8 : aSet.Put( aLR );
1437 8 : aSet.Put( aUL );
1438 8 : bSetLeft = false;
1439 8 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_LEFT );
1440 : // this relies on GetPageDescFromPool() not going into infinite recursion
1441 : // (by this point RES_POOLPAGE_LEFT will not reach this place again)
1442 8 : pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_RIGHT ));
1443 : }
1444 8 : break;
1445 : case RES_POOLPAGE_RIGHT: // "Right Page"
1446 : {
1447 8 : lcl_PutStdPageSizeIntoItemSet( &m_rDoc, aSet );
1448 8 : aSet.Put( aLR );
1449 8 : aSet.Put( aUL );
1450 8 : bSetLeft = false;
1451 8 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_RIGHT );
1452 8 : pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_LEFT ));
1453 : }
1454 8 : break;
1455 :
1456 : case RES_POOLPAGE_JAKET: // "Envelope"
1457 : {
1458 5 : Size aPSize( SvxPaperInfo::GetPaperSize( PAPER_ENV_C65 ) );
1459 5 : LandscapeSwap( aPSize );
1460 5 : aSet.Put( SwFormatFrmSize( ATT_FIX_SIZE, aPSize.Width(), aPSize.Height() ));
1461 5 : aLR.SetLeft( 0 ); aLR.SetRight( 0 );
1462 5 : aUL.SetUpper( 0 ); aUL.SetLower( 0 );
1463 5 : aSet.Put( aLR );
1464 5 : aSet.Put( aUL );
1465 :
1466 5 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1467 5 : pNewPgDsc->SetLandscape( true );
1468 : }
1469 5 : break;
1470 :
1471 : case RES_POOLPAGE_HTML: // "HTML"
1472 : {
1473 15 : lcl_PutStdPageSizeIntoItemSet( &m_rDoc, aSet );
1474 15 : aLR.SetRight( GetMetricVal( CM_1 ));
1475 15 : aUL.SetUpper( (sal_uInt16)aLR.GetRight() );
1476 15 : aUL.SetLower( (sal_uInt16)aLR.GetRight() );
1477 15 : aSet.Put( aLR );
1478 15 : aSet.Put( aUL );
1479 :
1480 15 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1481 : }
1482 15 : break;
1483 :
1484 : case RES_POOLPAGE_FOOTNOTE: // "Footnote"
1485 : case RES_POOLPAGE_ENDNOTE: // "Endnote"
1486 : {
1487 39 : lcl_PutStdPageSizeIntoItemSet( &m_rDoc, aSet );
1488 39 : aSet.Put( aLR );
1489 39 : aSet.Put( aUL );
1490 39 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1491 39 : SwPageFootnoteInfo aInf( pNewPgDsc->GetFootnoteInfo() );
1492 39 : aInf.SetLineWidth( 0 );
1493 39 : aInf.SetTopDist( 0 );
1494 39 : aInf.SetBottomDist( 0 );
1495 39 : pNewPgDsc->SetFootnoteInfo( aInf );
1496 : }
1497 39 : break;
1498 :
1499 : case RES_POOLPAGE_LANDSCAPE: // "Landscape"
1500 : {
1501 2 : SwPageDesc* pStdPgDsc = GetPageDescFromPool( RES_POOLPAGE_STANDARD );
1502 2 : SwFormatFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
1503 2 : if ( !pStdPgDsc->GetLandscape() )
1504 : {
1505 2 : const SwTwips nTmp = aFrmSz.GetHeight();
1506 2 : aFrmSz.SetHeight( aFrmSz.GetWidth() );
1507 2 : aFrmSz.SetWidth( nTmp );
1508 : }
1509 2 : aSet.Put( aFrmSz );
1510 2 : aSet.Put( aLR );
1511 2 : aSet.Put( aUL );
1512 2 : pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1513 2 : pNewPgDsc->SetLandscape( true );
1514 : }
1515 2 : break;
1516 :
1517 : }
1518 :
1519 3344 : if( aSet.Count() )
1520 : {
1521 3344 : if( bSetLeft )
1522 : {
1523 3328 : pNewPgDsc->GetLeft().SetFormatAttr( aSet );
1524 3328 : pNewPgDsc->GetFirstLeft().SetFormatAttr( aSet );
1525 : }
1526 3344 : pNewPgDsc->GetMaster().SetFormatAttr( aSet );
1527 3344 : pNewPgDsc->GetFirstMaster().SetFormatAttr( aSet );
1528 : }
1529 6688 : return pNewPgDsc;
1530 : }
1531 :
1532 81 : SwNumRule* DocumentStylePoolManager::GetNumRuleFromPool( sal_uInt16 nId )
1533 : {
1534 : OSL_ENSURE( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END,
1535 : "Wrong AutoFormat Id" );
1536 :
1537 : SwNumRule* pNewRule;
1538 :
1539 397 : for (size_t n = 0; n < m_rDoc.GetNumRuleTable().size(); ++n )
1540 : {
1541 316 : if (nId == ( pNewRule = m_rDoc.GetNumRuleTable()[ n ] )->GetPoolFormatId())
1542 : {
1543 0 : return pNewRule;
1544 : }
1545 : }
1546 :
1547 : // error: unknown Pool style
1548 81 : if( RES_POOLNUMRULE_BEGIN > nId || nId >= RES_POOLNUMRULE_END )
1549 : {
1550 : OSL_ENSURE( false, "invalid Id" );
1551 0 : nId = RES_POOLNUMRULE_BEGIN;
1552 : }
1553 :
1554 81 : ResId aResId( sal_uInt32(RC_POOLNUMRULE_BEGIN + nId - RES_POOLNUMRULE_BEGIN), *pSwResMgr );
1555 81 : OUString aNm( aResId );
1556 :
1557 81 : SwCharFormat *pNumCFormat = 0, *pBullCFormat = 0;
1558 :
1559 : const SvxNumberFormat::SvxNumPositionAndSpaceMode eNumberFormatPositionAndSpaceMode
1560 81 : = numfunc::GetDefaultPositionAndSpaceMode(); //#i89178#
1561 : {
1562 81 : bool bIsModified = m_rDoc.getIDocumentState().IsModified();
1563 :
1564 81 : sal_uInt16 n = m_rDoc.MakeNumRule( aNm, 0, false, eNumberFormatPositionAndSpaceMode );
1565 :
1566 81 : pNewRule = m_rDoc.GetNumRuleTable()[ n ];
1567 81 : pNewRule->SetPoolFormatId( nId );
1568 81 : pNewRule->SetAutoRule( false );
1569 :
1570 81 : if( RES_POOLNUMRULE_NUM1 <= nId && nId <= RES_POOLNUMRULE_NUM5 )
1571 48 : pNumCFormat = GetCharFormatFromPool( RES_POOLCHR_NUM_LEVEL );
1572 :
1573 81 : if( ( RES_POOLNUMRULE_BUL1 <= nId && nId <= RES_POOLNUMRULE_BUL5 ) ||
1574 : RES_POOLNUMRULE_NUM5 == nId )
1575 40 : pBullCFormat = GetCharFormatFromPool( RES_POOLCHR_NUM_LEVEL );
1576 :
1577 81 : if( !bIsModified )
1578 0 : m_rDoc.getIDocumentState().ResetModified();
1579 : }
1580 :
1581 81 : switch( nId )
1582 : {
1583 : case RES_POOLNUMRULE_NUM1:
1584 : {
1585 16 : SwNumFormat aFormat;
1586 16 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1587 16 : aFormat.SetNumberingType(SVX_NUM_ARABIC);
1588 16 : aFormat.SetCharFormat( pNumCFormat );
1589 16 : aFormat.SetStart( 1 );
1590 16 : aFormat.SetIncludeUpperLevels( 1 );
1591 16 : aFormat.SetSuffix( "." );
1592 :
1593 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1594 : {
1595 : // cm: 0,5 1,0 1,5 2,0 2,5 3,0 3,5 4,0 4,5 5,0
1596 : 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1597 : };
1598 16 : const sal_uInt16* pArr = aAbsSpace;
1599 :
1600 16 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1601 : {
1602 0 : aFormat.SetFirstLineOffset( - (*pArr) );
1603 : }
1604 16 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1605 : {
1606 16 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1607 16 : aFormat.SetFirstLineIndent( - (*pArr) );
1608 : }
1609 :
1610 176 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
1611 : {
1612 160 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1613 : {
1614 0 : aFormat.SetAbsLSpace( *pArr );
1615 : }
1616 160 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1617 : {
1618 160 : aFormat.SetListtabPos( *pArr );
1619 160 : aFormat.SetIndentAt( *pArr );
1620 : }
1621 :
1622 160 : pNewRule->Set( n, aFormat );
1623 16 : }
1624 : }
1625 16 : break;
1626 :
1627 : case RES_POOLNUMRULE_NUM2:
1628 : {
1629 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1630 : {
1631 : 283, 283, 567, 709, // 0.50, 0.50, 1.00, 1.25
1632 : 850, 1021, 1304, 1474, // 1.50, 1.80, 2.30, 2.60
1633 : 1588, 1758 // 2.80, 3.10
1634 : };
1635 :
1636 9 : const sal_uInt16* pArr = aAbsSpace;
1637 9 : SwNumFormat aFormat;
1638 :
1639 9 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1640 9 : aFormat.SetNumberingType(SVX_NUM_ARABIC);
1641 9 : aFormat.SetCharFormat( pNumCFormat );
1642 9 : aFormat.SetIncludeUpperLevels( 1 );
1643 :
1644 9 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1645 : {
1646 9 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1647 : }
1648 :
1649 9 : sal_uInt16 nSpace = 0;
1650 99 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n)
1651 : {
1652 90 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1653 : {
1654 0 : aFormat.SetAbsLSpace( nSpace = nSpace + pArr[ n ] );
1655 0 : aFormat.SetFirstLineOffset( - pArr[ n ] );
1656 : }
1657 90 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1658 : {
1659 90 : aFormat.SetListtabPos( nSpace = nSpace + pArr[ n ] );
1660 90 : aFormat.SetIndentAt( nSpace );
1661 90 : aFormat.SetFirstLineIndent( - pArr[ n ] );
1662 : }
1663 :
1664 90 : aFormat.SetStart( n+1 );
1665 90 : pNewRule->Set( n, aFormat );
1666 9 : }
1667 : }
1668 9 : break;
1669 : case RES_POOLNUMRULE_NUM3:
1670 : {
1671 8 : SwNumFormat aFormat;
1672 :
1673 8 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1674 8 : aFormat.SetNumberingType(SVX_NUM_ARABIC);
1675 8 : aFormat.SetCharFormat( pNumCFormat );
1676 8 : aFormat.SetIncludeUpperLevels( 1 );
1677 :
1678 8 : sal_uInt16 nOffs = GetMetricVal( CM_1 ) * 3;
1679 :
1680 8 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1681 : {
1682 0 : aFormat.SetFirstLineOffset( - nOffs );
1683 : }
1684 8 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1685 : {
1686 8 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1687 8 : aFormat.SetFirstLineIndent( - nOffs );
1688 : }
1689 :
1690 88 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n)
1691 : {
1692 80 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1693 : {
1694 0 : aFormat.SetAbsLSpace( (n+1) * nOffs );
1695 : }
1696 80 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1697 : {
1698 80 : long nPos = (n+1) * static_cast<long>(nOffs);
1699 80 : aFormat.SetListtabPos(nPos);
1700 80 : aFormat.SetIndentAt(nPos);
1701 : }
1702 :
1703 80 : aFormat.SetStart( n+1 );
1704 80 : pNewRule->Set( n, aFormat );
1705 8 : }
1706 : }
1707 8 : break;
1708 : case RES_POOLNUMRULE_NUM4:
1709 : {
1710 8 : SwNumFormat aFormat;
1711 :
1712 8 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1713 8 : aFormat.SetNumberingType(SVX_NUM_ROMAN_UPPER);
1714 8 : aFormat.SetCharFormat( pNumCFormat );
1715 8 : aFormat.SetIncludeUpperLevels( 1 );
1716 8 : aFormat.SetSuffix( "." );
1717 :
1718 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1719 : {
1720 : // cm: 0,5 1,0 1,5 2,0 2,5 3,0 3,5 4,0 4,5 5,0
1721 : 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1722 : };
1723 8 : const sal_uInt16* pArr = aAbsSpace;
1724 :
1725 8 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1726 : {
1727 0 : aFormat.SetFirstLineOffset( - (*pArr) );
1728 : }
1729 8 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1730 : {
1731 8 : aFormat.SetLabelFollowedBy( SvxNumberFormat::SPACE );
1732 8 : aFormat.SetFirstLineIndent( - (*pArr) );
1733 : }
1734 :
1735 88 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
1736 : {
1737 80 : aFormat.SetStart( n + 1 );
1738 :
1739 80 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1740 : {
1741 0 : aFormat.SetAbsLSpace( *pArr );
1742 : }
1743 80 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1744 : {
1745 80 : aFormat.SetListtabPos( *pArr );
1746 80 : aFormat.SetIndentAt( *pArr );
1747 : }
1748 :
1749 80 : pNewRule->Set( n, aFormat );
1750 8 : }
1751 : }
1752 8 : break;
1753 : case RES_POOLNUMRULE_NUM5:
1754 : {
1755 : // [ First, LSpace ]
1756 : static const sal_uInt16 aAbsSpace0to2[] =
1757 : {
1758 : 227, 227, // 0.40, 0.40,
1759 : 369, 624, // 0.65, 1.10,
1760 : 255, 879 // 0.45, 1.55
1761 : };
1762 :
1763 7 : const sal_uInt16* pArr0to2 = aAbsSpace0to2;
1764 7 : SwNumFormat aFormat;
1765 :
1766 7 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1767 7 : aFormat.SetNumberingType(SVX_NUM_ARABIC);
1768 7 : aFormat.SetStart( 1 );
1769 7 : aFormat.SetIncludeUpperLevels( 1 );
1770 7 : aFormat.SetSuffix( "." );
1771 :
1772 7 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1773 : {
1774 7 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1775 : }
1776 :
1777 7 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1778 : {
1779 0 : aFormat.SetFirstLineOffset( -pArr0to2[0] ); // == 0.40 cm
1780 0 : aFormat.SetAbsLSpace( pArr0to2[1] ); // == 0.40 cm
1781 : }
1782 7 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1783 : {
1784 7 : aFormat.SetFirstLineIndent( -pArr0to2[0] );
1785 7 : aFormat.SetListtabPos( pArr0to2[1] );
1786 7 : aFormat.SetIndentAt( pArr0to2[1] );
1787 : }
1788 :
1789 7 : aFormat.SetCharFormat( pNumCFormat );
1790 7 : pNewRule->Set( 0, aFormat );
1791 :
1792 7 : aFormat.SetIncludeUpperLevels( 2 );
1793 7 : aFormat.SetStart( 2 );
1794 :
1795 7 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1796 : {
1797 0 : aFormat.SetFirstLineOffset( -pArr0to2[2] ); // == 0.65 cm
1798 0 : aFormat.SetAbsLSpace( pArr0to2[3] ); // == 1.10 cm
1799 : }
1800 7 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1801 : {
1802 7 : aFormat.SetFirstLineIndent( -pArr0to2[2] );
1803 7 : aFormat.SetListtabPos( pArr0to2[3] );
1804 7 : aFormat.SetIndentAt( pArr0to2[3] );
1805 : }
1806 :
1807 7 : pNewRule->Set( 1, aFormat );
1808 :
1809 7 : aFormat.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER);
1810 7 : aFormat.SetSuffix(OUString(static_cast<sal_Unicode>(')')));
1811 7 : aFormat.SetIncludeUpperLevels( 1 );
1812 7 : aFormat.SetStart( 3 );
1813 :
1814 7 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1815 : {
1816 0 : aFormat.SetFirstLineOffset( - pArr0to2[4] ); // == 0.45cm
1817 0 : aFormat.SetAbsLSpace( pArr0to2[5] ); // == 1.55 cm
1818 : }
1819 7 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1820 : {
1821 7 : aFormat.SetFirstLineIndent( -pArr0to2[4] );
1822 7 : aFormat.SetListtabPos( pArr0to2[5] );
1823 7 : aFormat.SetIndentAt( pArr0to2[5] );
1824 : }
1825 :
1826 7 : pNewRule->Set( 2, aFormat );
1827 :
1828 7 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1829 7 : aFormat.SetCharFormat( pBullCFormat );
1830 7 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
1831 7 : aFormat.SetBulletChar( cBulletChar );
1832 7 : sal_Int16 nOffs = GetMetricVal( CM_01 ) * 4,
1833 7 : nOffs2 = GetMetricVal( CM_1 ) * 2;
1834 :
1835 7 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1836 : {
1837 0 : aFormat.SetFirstLineOffset( - nOffs );
1838 : }
1839 7 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1840 : {
1841 7 : aFormat.SetFirstLineIndent( - nOffs );
1842 : }
1843 :
1844 7 : aFormat.SetSuffix( OUString() );
1845 56 : for (sal_uInt16 n = 3; n < MAXLEVEL; ++n)
1846 : {
1847 49 : aFormat.SetStart( n+1 );
1848 :
1849 49 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1850 : {
1851 0 : aFormat.SetAbsLSpace( nOffs2 + ((n-3) * nOffs) );
1852 : }
1853 49 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1854 : {
1855 49 : long nPos = nOffs2 + ((n-3) * static_cast<long>(nOffs));
1856 49 : aFormat.SetListtabPos(nPos);
1857 49 : aFormat.SetIndentAt(nPos);
1858 : }
1859 :
1860 49 : pNewRule->Set( n, aFormat );
1861 7 : }
1862 : }
1863 7 : break;
1864 :
1865 : case RES_POOLNUMRULE_BUL1:
1866 : {
1867 14 : SwNumFormat aFormat;
1868 :
1869 14 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1870 14 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1871 14 : aFormat.SetCharFormat( pBullCFormat );
1872 14 : aFormat.SetStart( 1 );
1873 14 : aFormat.SetIncludeUpperLevels( 1 );
1874 14 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
1875 14 : aFormat.SetBulletChar( cBulletChar );
1876 :
1877 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1878 : {
1879 : // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0
1880 : 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
1881 : };
1882 14 : const sal_uInt16* pArr = aAbsSpace;
1883 :
1884 14 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1885 : {
1886 0 : aFormat.SetFirstLineOffset( - (*pArr) );
1887 : }
1888 14 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1889 : {
1890 14 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1891 14 : aFormat.SetFirstLineIndent( - (*pArr) );
1892 : }
1893 :
1894 154 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
1895 : {
1896 140 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1897 : {
1898 0 : aFormat.SetAbsLSpace( *pArr );
1899 : }
1900 140 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1901 : {
1902 140 : aFormat.SetListtabPos( *pArr );
1903 140 : aFormat.SetIndentAt( *pArr );
1904 : }
1905 :
1906 140 : pNewRule->Set( n, aFormat );
1907 14 : }
1908 : }
1909 14 : break;
1910 : case RES_POOLNUMRULE_BUL2:
1911 : {
1912 6 : SwNumFormat aFormat;
1913 :
1914 6 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1915 6 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1916 6 : aFormat.SetCharFormat( pBullCFormat );
1917 6 : aFormat.SetStart( 1 );
1918 6 : aFormat.SetIncludeUpperLevels( 1 );
1919 6 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
1920 6 : aFormat.SetBulletChar( 0x2013 );
1921 :
1922 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1923 : {
1924 : // cm: 0,3 0,6 0,9 1,2 1,5 1,8 2,1 2,4 2,7 3,0
1925 : 170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701
1926 : };
1927 6 : const sal_uInt16* pArr = aAbsSpace;
1928 :
1929 6 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1930 : {
1931 0 : aFormat.SetFirstLineOffset( - (*pArr) );
1932 : }
1933 6 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1934 : {
1935 6 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1936 6 : aFormat.SetFirstLineIndent( - (*pArr) );
1937 : }
1938 :
1939 66 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
1940 : {
1941 60 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1942 : {
1943 0 : aFormat.SetAbsLSpace( *pArr );
1944 : }
1945 60 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1946 : {
1947 60 : aFormat.SetListtabPos( *pArr );
1948 60 : aFormat.SetIndentAt( *pArr );
1949 : }
1950 :
1951 60 : pNewRule->Set( n, aFormat );
1952 6 : }
1953 : }
1954 6 : break;
1955 : case RES_POOLNUMRULE_BUL3:
1956 : {
1957 4 : SwNumFormat aFormat;
1958 :
1959 4 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1960 :
1961 4 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1962 4 : aFormat.SetCharFormat( pBullCFormat );
1963 4 : aFormat.SetStart( 1 );
1964 4 : aFormat.SetIncludeUpperLevels( 1 );
1965 4 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
1966 :
1967 4 : sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4;
1968 :
1969 4 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1970 : {
1971 0 : aFormat.SetFirstLineOffset( - nOffs );
1972 : }
1973 4 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1974 : {
1975 4 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1976 4 : aFormat.SetFirstLineIndent( - nOffs );
1977 : }
1978 :
1979 44 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n)
1980 : {
1981 40 : aFormat.SetBulletChar( ( n & 1 ? 0x25a1 : 0x2611 ) );
1982 :
1983 40 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1984 : {
1985 0 : aFormat.SetAbsLSpace( ((n & 1) +1) * nOffs );
1986 : }
1987 40 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1988 : {
1989 40 : long nPos = ((n & 1) +1) * static_cast<long>(nOffs);
1990 40 : aFormat.SetListtabPos(nPos);
1991 40 : aFormat.SetIndentAt(nPos);
1992 : }
1993 :
1994 40 : pNewRule->Set( n, aFormat );
1995 4 : }
1996 : }
1997 4 : break;
1998 : case RES_POOLNUMRULE_BUL4:
1999 : {
2000 4 : SwNumFormat aFormat;
2001 :
2002 4 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2003 4 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2004 4 : aFormat.SetCharFormat( pBullCFormat );
2005 4 : aFormat.SetStart( 1 );
2006 4 : aFormat.SetIncludeUpperLevels( 1 );
2007 4 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
2008 :
2009 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2010 : {
2011 : // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0
2012 : 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2013 : };
2014 :
2015 4 : const sal_uInt16* pArr = aAbsSpace;
2016 :
2017 4 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2018 : {
2019 0 : aFormat.SetFirstLineOffset( - (*pArr) );
2020 : }
2021 4 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2022 : {
2023 4 : aFormat.SetLabelFollowedBy( SvxNumberFormat::SPACE );
2024 4 : aFormat.SetFirstLineIndent( - (*pArr) );
2025 : }
2026 :
2027 44 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
2028 : {
2029 40 : switch( n )
2030 : {
2031 4 : case 0: aFormat.SetBulletChar( 0x27a2 ); break;
2032 4 : case 1: aFormat.SetBulletChar( 0xE006 ); break;
2033 32 : default: aFormat.SetBulletChar( 0xE004 ); break;
2034 : }
2035 :
2036 40 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2037 : {
2038 0 : aFormat.SetAbsLSpace( *pArr );
2039 : }
2040 40 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2041 : {
2042 40 : aFormat.SetListtabPos( *pArr );
2043 40 : aFormat.SetIndentAt( *pArr );
2044 : }
2045 :
2046 40 : pNewRule->Set( n, aFormat );
2047 4 : }
2048 : }
2049 4 : break;
2050 : case RES_POOLNUMRULE_BUL5:
2051 : {
2052 5 : SwNumFormat aFormat;
2053 :
2054 5 : aFormat.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2055 5 : aFormat.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2056 5 : aFormat.SetCharFormat( pBullCFormat );
2057 5 : aFormat.SetStart( 1 );
2058 5 : aFormat.SetIncludeUpperLevels( 1 );
2059 5 : aFormat.SetBulletChar( 0x2717 );
2060 5 : aFormat.SetBulletFont( &numfunc::GetDefBulletFont() );
2061 :
2062 : static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2063 : {
2064 : // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0
2065 : 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2066 : };
2067 5 : const sal_uInt16* pArr = aAbsSpace;
2068 :
2069 5 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2070 : {
2071 0 : aFormat.SetFirstLineOffset( - (*pArr) );
2072 : }
2073 5 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2074 : {
2075 5 : aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
2076 5 : aFormat.SetFirstLineIndent( - (*pArr) );
2077 : }
2078 :
2079 55 : for (sal_uInt16 n = 0; n < MAXLEVEL; ++n, ++pArr)
2080 : {
2081 50 : if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2082 : {
2083 0 : aFormat.SetAbsLSpace( *pArr );
2084 : }
2085 50 : else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2086 : {
2087 50 : aFormat.SetListtabPos( *pArr );
2088 50 : aFormat.SetIndentAt( *pArr );
2089 : }
2090 :
2091 50 : pNewRule->Set( n, aFormat );
2092 5 : }
2093 : }
2094 5 : break;
2095 : }
2096 :
2097 81 : return pNewRule;
2098 : }
2099 :
2100 : /// Check if this AutoCollection is already/still in use in this Document
2101 4332215 : bool DocumentStylePoolManager::IsPoolTextCollUsed( sal_uInt16 nId ) const
2102 : {
2103 : OSL_ENSURE(
2104 : (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
2105 : (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
2106 : (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
2107 : (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
2108 : (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
2109 : (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
2110 : "Wrong AutoFormat Id" );
2111 :
2112 4332215 : SwTextFormatColl* pNewColl = 0;
2113 4332215 : bool bFnd = false;
2114 57099817 : for( sal_uInt16 n = 0; !bFnd && n < m_rDoc.GetTextFormatColls()->size(); ++n )
2115 : {
2116 52767602 : pNewColl = (*m_rDoc.GetTextFormatColls())[ n ];
2117 52767602 : if( nId == pNewColl->GetPoolFormatId() )
2118 415446 : bFnd = true;
2119 : }
2120 :
2121 4332215 : if( !bFnd || !pNewColl->HasWriterListeners() )
2122 4224828 : return false;
2123 :
2124 107387 : SwAutoFormatGetDocNode aGetHt( &m_rDoc.GetNodes() );
2125 107387 : return !pNewColl->GetInfo( aGetHt );
2126 : }
2127 :
2128 : /// Check if this AutoCollection is already/still in use
2129 38463 : bool DocumentStylePoolManager::IsPoolFormatUsed( sal_uInt16 nId ) const
2130 : {
2131 38463 : const SwFormat *pNewFormat = 0;
2132 : const SwFormatsBase* pArray[ 2 ];
2133 38463 : sal_uInt16 nArrCnt = 1;
2134 38463 : bool bFnd = true;
2135 :
2136 38463 : if (RES_POOLCHR_BEGIN <= nId && nId < RES_POOLCHR_END)
2137 : {
2138 21320 : pArray[0] = m_rDoc.GetCharFormats();
2139 : }
2140 17143 : else if (RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END)
2141 : {
2142 17143 : pArray[0] = m_rDoc.GetFrameFormats();
2143 17143 : pArray[1] = m_rDoc.GetSpzFrameFormats();
2144 17143 : nArrCnt = 2;
2145 : }
2146 : else
2147 : {
2148 : SAL_WARN("sw.core", "Invalid Pool Id: " << nId << " should be within "
2149 : "[" << int(RES_POOLCHR_BEGIN) << "," << int(RES_POOLCHR_END) << ") or "
2150 : "[" << int(RES_POOLFRM_BEGIN) << "," << int(RES_POOLFRM_END) << ")");
2151 0 : bFnd = false;
2152 : }
2153 :
2154 38463 : if( bFnd )
2155 : {
2156 38463 : bFnd = false;
2157 132532 : while( nArrCnt-- && !bFnd )
2158 645303 : for( size_t n = 0; !bFnd && n < (*pArray[nArrCnt]).GetFormatCount(); ++n )
2159 1179394 : if( nId == ( pNewFormat = (*pArray[ nArrCnt ] ).GetFormat( n ) )->
2160 589697 : GetPoolFormatId() )
2161 1042 : bFnd = true;
2162 : }
2163 :
2164 : // Not found or no dependencies?
2165 38463 : if( bFnd && pNewFormat->HasWriterListeners() )
2166 : {
2167 : // Check if we have dependent ContentNodes in the Nodes array
2168 : // (also indirect ones for derived Formats)
2169 85 : SwAutoFormatGetDocNode aGetHt( &m_rDoc.GetNodes() );
2170 85 : bFnd = !pNewFormat->GetInfo( aGetHt );
2171 : }
2172 : else
2173 38378 : bFnd = false;
2174 :
2175 38463 : return bFnd;
2176 : }
2177 :
2178 : /// Check if this AutoCollection is already/still in use in this Document
2179 4130 : bool DocumentStylePoolManager::IsPoolPageDescUsed( sal_uInt16 nId ) const
2180 : {
2181 : OSL_ENSURE( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
2182 : "Wrong AutoFormat Id" );
2183 4130 : SwPageDesc *pNewPgDsc = 0;
2184 4130 : bool bFnd = false;
2185 18256 : for( size_t n = 0; !bFnd && n < m_rDoc.GetPageDescCnt(); ++n )
2186 : {
2187 14126 : pNewPgDsc = &m_rDoc.GetPageDesc(n);
2188 14126 : if( nId == pNewPgDsc->GetPoolFormatId() )
2189 476 : bFnd = true;
2190 : }
2191 :
2192 : // Not found or no dependencies?
2193 4130 : if( !bFnd || !pNewPgDsc->HasWriterListeners() ) // ??????
2194 3728 : return false;
2195 :
2196 : // Check if we have dependent ContentNodes in the Nodes array
2197 : // (also indirect ones for derived Formats)
2198 402 : SwAutoFormatGetDocNode aGetHt( &m_rDoc.GetNodes() );
2199 402 : return !pNewPgDsc->GetInfo( aGetHt );
2200 : }
2201 :
2202 5898 : DocumentStylePoolManager::~DocumentStylePoolManager()
2203 : {
2204 5898 : }
2205 :
2206 177 : }
2207 :
2208 :
2209 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
