Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*************************************************************************
3 : *
4 : * The Contents of this file are made available subject to the terms of
5 : * either of the following licenses
6 : *
7 : * - GNU Lesser General Public License Version 2.1
8 : * - Sun Industry Standards Source License Version 1.1
9 : *
10 : * Sun Microsystems Inc., October, 2000
11 : *
12 : * GNU Lesser General Public License Version 2.1
13 : * =============================================
14 : * Copyright 2000 by Sun Microsystems, Inc.
15 : * 901 San Antonio Road, Palo Alto, CA 94303, USA
16 : *
17 : * This library is free software; you can redistribute it and/or
18 : * modify it under the terms of the GNU Lesser General Public
19 : * License version 2.1, as published by the Free Software Foundation.
20 : *
21 : * This library is distributed in the hope that it will be useful,
22 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 : * Lesser General Public License for more details.
25 : *
26 : * You should have received a copy of the GNU Lesser General Public
27 : * License along with this library; if not, write to the Free Software
28 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 : * MA 02111-1307 USA
30 : *
31 : *
32 : * Sun Industry Standards Source License Version 1.1
33 : * =================================================
34 : * The contents of this file are subject to the Sun Industry Standards
35 : * Source License Version 1.1 (the "License"); You may not use this file
36 : * except in compliance with the License. You may obtain a copy of the
37 : * License at http://www.openoffice.org/license.html.
38 : *
39 : * Software provided under this License is provided on an "AS IS" basis,
40 : * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
41 : * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
42 : * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
43 : * See the License for the specific provisions governing your rights and
44 : * obligations concerning the Software.
45 : *
46 : * The Initial Developer of the Original Code is: IBM Corporation
47 : *
48 : * Copyright: 2008 by IBM Corporation
49 : *
50 : * All Rights Reserved.
51 : *
52 : * Contributor(s): _______________________________________
53 : *
54 : *
55 : ************************************************************************/
56 : /*************************************************************************
57 : * @file
58 : * For LWP filter architecture prototype
59 : ************************************************************************/
60 : /*************************************************************************
61 : * Change History
62 : Jan 2005 Created
63 : ************************************************************************/
64 :
65 : #include <boost/scoped_ptr.hpp>
66 :
67 : #include "lwpparastyle.hxx"
68 : #include "lwpfilehdr.hxx"
69 : #include "lwpoverride.hxx"
70 : #include "lwpparaborderoverride.hxx"
71 : #include "lwpbreaksoverride.hxx"
72 : #include "lwpnumberingoverride.hxx"
73 : #include "lwptaboverride.hxx"
74 : #include "lwpbackgroundoverride.hxx"
75 : #include "xfilter/xfdefs.hxx"
76 : #include "xfilter/xfparastyle.hxx"
77 : #include "xfilter/xfborders.hxx"
78 : #include "lwpfont.hxx"
79 : #include "lwpfoundry.hxx"
80 : #include "lwppiece.hxx"
81 : #include "lwpshadow.hxx"
82 : #include "lwpborderstuff.hxx"
83 : #include "lwpmargins.hxx"
84 : #include "lwptabrack.hxx"
85 :
86 : #include "lwpsilverbullet.hxx"
87 :
88 68 : LwpParaStyle::LwpParaStyle(LwpObjectHeader& objHdr, LwpSvStream* pStrm) :
89 68 : LwpTextStyle(objHdr, pStrm), m_pKinsokuOptsOverride(new LwpKinsokuOptsOverride),
90 136 : m_pBulletOverride(new LwpBulletOverride)
91 : {
92 68 : }
93 :
94 204 : LwpParaStyle::~LwpParaStyle()
95 : {
96 68 : if (m_pKinsokuOptsOverride)
97 : {
98 68 : delete m_pKinsokuOptsOverride;
99 : }
100 :
101 68 : if (m_pBulletOverride)
102 : {
103 68 : delete m_pBulletOverride;
104 : }
105 136 : }
106 :
107 68 : void LwpParaStyle::Read()
108 : {
109 68 : LwpTextStyle::Read();
110 :
111 68 : if (LwpFileHeader::m_nFileRevision < 0x000B)
112 : {
113 : // read many overrides
114 0 : LwpAlignmentOverride aAlignOverride;
115 0 : aAlignOverride.Read(m_pObjStrm);
116 :
117 0 : LwpSpacingOverride aSpacingOverride;
118 0 : aSpacingOverride.Read(m_pObjStrm);
119 :
120 0 : LwpIndentOverride aIndentOverride;
121 0 : aIndentOverride.Read(m_pObjStrm);
122 :
123 0 : LwpParaBorderOverride aPBOverride;
124 0 : aPBOverride.Read(m_pObjStrm);
125 :
126 0 : LwpBreaksOverride aBreaksOverride;
127 0 : aBreaksOverride.Read(m_pObjStrm);
128 :
129 0 : LwpNumberingOverride aNumberingOverride;
130 0 : aNumberingOverride.Read(m_pObjStrm);
131 :
132 0 : LwpTabOverride aTabOverride;
133 0 : aTabOverride.Read(m_pObjStrm);
134 :
135 : }
136 : else
137 : {
138 68 : m_AlignmentStyle.ReadIndexed(m_pObjStrm);
139 68 : m_SpacingStyle.ReadIndexed(m_pObjStrm);
140 68 : m_IndentStyle.ReadIndexed(m_pObjStrm);
141 68 : m_BorderStyle.ReadIndexed(m_pObjStrm);
142 68 : m_BreaksStyle.ReadIndexed(m_pObjStrm);
143 68 : m_NumberingStyle.ReadIndexed(m_pObjStrm);
144 68 : m_TabStyle.ReadIndexed(m_pObjStrm);
145 :
146 68 : m_pKinsokuOptsOverride->Read(m_pObjStrm);
147 68 : m_pBulletOverride->Read(m_pObjStrm);
148 :
149 68 : if (m_pObjStrm->CheckExtra())
150 : {
151 52 : m_BackgroundStyle.ReadIndexed(m_pObjStrm);
152 52 : m_pObjStrm->SkipExtra();
153 : }
154 :
155 : }
156 68 : }
157 :
158 68 : void LwpParaStyle::Apply(XFParaStyle *pParaStyle)
159 : {
160 : assert(pParaStyle);
161 :
162 68 : LwpVirtualPiece *pPiece = NULL;
163 : //alignment:
164 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_AlignmentStyle.obj().get());
165 68 : if( pPiece )
166 : {
167 20 : LwpAlignmentOverride *pAlign = dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
168 20 : if( pAlign )
169 20 : ApplyAlignment(pParaStyle,pAlign);
170 : }
171 :
172 : //don't known top and bottom indent now.
173 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_IndentStyle.obj().get());
174 68 : if( pPiece )
175 : {
176 49 : LwpIndentOverride *pIndent = dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
177 49 : if( pIndent )
178 : {
179 49 : if (!m_pBulletOverride->IsInValid())//Add by ,for remove bullet indent in named bullet style
180 : {
181 41 : boost::scoped_ptr<LwpIndentOverride> pNewIndent(pIndent->clone());
182 41 : pNewIndent->SetMFirst(0);
183 41 : pNewIndent->SetMRest(0);
184 41 : ApplyIndent(NULL, pParaStyle, pNewIndent.get());
185 : }
186 : else
187 8 : ApplyIndent(NULL,pParaStyle,pIndent);
188 : }
189 : }
190 : //shadow & borders.
191 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BorderStyle.obj().get());
192 68 : if( pPiece )
193 : {
194 4 : LwpParaBorderOverride *pBorder = dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
195 4 : if( pBorder )
196 : {
197 4 : ApplyParaBorder(pParaStyle, pBorder);
198 : }
199 : }
200 :
201 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_SpacingStyle.obj().get());
202 68 : if (pPiece)
203 : {
204 27 : LwpSpacingOverride *pSpacing = dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
205 27 : if( pSpacing)
206 27 : ApplySpacing(NULL,pParaStyle,pSpacing);
207 : }
208 :
209 : //paragraph background.
210 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BackgroundStyle.obj().get());
211 68 : if( pPiece )
212 : {
213 0 : LwpBackgroundOverride *pBack = dynamic_cast<LwpBackgroundOverride*>(pPiece->GetOverride());
214 0 : if( pBack )
215 : {
216 0 : LwpColor color = pBack->GetBackColor();
217 0 : XFColor aXFColor( color.To24Color() );
218 0 : pParaStyle->SetBackColor( aXFColor );
219 : }
220 : }
221 :
222 : //add tab style
223 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_TabStyle.obj().get());
224 68 : if( pPiece )
225 : {
226 0 : LwpTabOverride *pTab = dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
227 0 : if(pTab)
228 : {
229 0 : ApplyTab(pParaStyle,pTab);
230 : }
231 : }
232 68 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BreaksStyle.obj().get());
233 68 : if( pPiece )
234 : {
235 27 : LwpBreaksOverride *pBreak = dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
236 27 : if(pBreak)
237 : {
238 27 : ApplyBreaks(pParaStyle,pBreak);
239 : }
240 : }
241 :
242 68 : }
243 :
244 340 : void LwpParaStyle::ApplySubBorder(LwpBorderStuff* pBorderStuff, LwpBorderStuff::BorderType eType, XFBorders* pXFBorders)
245 : {
246 340 : enumXFBorder eXFBorderSide = enumXFBorderNone;
247 340 : switch (eType)
248 : {
249 : case LwpBorderStuff::LEFT:
250 85 : eXFBorderSide = enumXFBorderLeft;
251 85 : break;
252 : case LwpBorderStuff::RIGHT:
253 85 : eXFBorderSide = enumXFBorderRight;
254 85 : break;
255 : case LwpBorderStuff::TOP:
256 85 : eXFBorderSide = enumXFBorderTop;
257 85 : break;
258 : case LwpBorderStuff::BOTTOM:
259 85 : eXFBorderSide = enumXFBorderBottom;
260 85 : break;
261 : default:
262 0 : break;
263 : }
264 :
265 340 : LwpColor aColor = pBorderStuff->GetSideColor(eType);
266 340 : float fWidth = pBorderStuff->GetSideWidth(eType);
267 340 : sal_uInt16 nType = pBorderStuff->GetSideType(eType);
268 :
269 340 : switch (nType)
270 : {
271 : default://fall through!
272 : case 0x14: //single fall through!
273 : case 0x17: //treble
274 340 : pXFBorders->SetWidth(eXFBorderSide, fWidth);
275 340 : break;
276 : case 0x15: //double , fall through!
277 : case 0x16: //thick double
278 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
279 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.333));
280 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.334));
281 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.333));
282 : // pXFBorders->SetWidth(eXFBorderSide, fWidth);
283 0 : break;
284 : case 0x18: //thick-thin
285 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
286 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.5));
287 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.25));
288 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.25));
289 0 : break;
290 : case 0x19: //thin-thick
291 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
292 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.7));
293 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.15));
294 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.15));
295 0 : break;
296 : }
297 :
298 340 : if (aColor.IsValidColor())
299 : {
300 340 : XFColor aXFColor(aColor.To24Color());
301 340 : pXFBorders->SetColor(eXFBorderSide, aXFColor );
302 340 : }
303 340 : }
304 :
305 6 : void LwpParaStyle::ApplyParaBorder(XFParaStyle* pParaStyle, LwpParaBorderOverride* pBorder)
306 : {
307 : //convert LwpShadow:
308 6 : LwpShadow *pShadow = pBorder->GetShadow();
309 6 : if( pShadow )
310 : {
311 6 : LwpColor color = pShadow->GetColor();
312 6 : float offsetX = pShadow->GetOffsetX();
313 6 : float offsetY = pShadow->GetOffsetY();
314 :
315 6 : if( offsetX && offsetY && color.IsValidColor() )
316 : {
317 1 : XFColor aXFColor(color.To24Color());
318 1 : bool left = false;
319 1 : bool top = false;
320 1 : if( offsetX < 0 )
321 0 : left = true;
322 1 : if( offsetY < 0 )
323 0 : top = true;
324 1 : if( left )
325 : {
326 0 : if( top )
327 0 : pParaStyle->SetShadow(enumXFShadowLeftTop,-offsetX,aXFColor);
328 : else
329 0 : pParaStyle->SetShadow(enumXFShadowLeftBottom,-offsetX,aXFColor);
330 : }
331 : else
332 : {
333 1 : if( top )
334 0 : pParaStyle->SetShadow(enumXFShadowRightTop,offsetX,aXFColor);
335 : else
336 1 : pParaStyle->SetShadow(enumXFShadowRightBottom,offsetX,aXFColor);
337 : }
338 6 : }
339 : }
340 :
341 : //convert to XFBorders object:
342 6 : LwpBorderStuff *pBorderStuff = pBorder->GetBorderStuff();
343 6 : if( pBorderStuff && pBorderStuff->GetSide() != 0 )
344 : {
345 2 : XFBorders *pXFBorders = new XFBorders();
346 2 : pParaStyle->SetBorders(pXFBorders);
347 :
348 2 : LwpMargins* pMargins = pBorder->GetMargins();
349 :
350 : // apply 4 borders respectively
351 : LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
352 2 : LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
353 : float pMarginValue[4];
354 :
355 10 : for (sal_uInt8 nC = 0; nC < 4; nC++)
356 : {
357 8 : if (pBorderStuff->HasSide(pType[nC]))
358 : {
359 8 : ApplySubBorder(pBorderStuff, pType[nC], pXFBorders);
360 :
361 : //get border spacing to text content
362 8 : if (pMargins)
363 : {
364 8 : pMarginValue[nC] = static_cast<float>(pMargins->GetMarginsValue(nC));
365 : }
366 : }
367 :
368 : }
369 :
370 : //apply border spacing to text content
371 2 : pParaStyle->SetPadding(pMarginValue[0], pMarginValue[1], pMarginValue[2], pMarginValue[3]);
372 :
373 : }
374 6 : }
375 :
376 27 : void LwpParaStyle::ApplyBreaks(XFParaStyle* pParaStyle, LwpBreaksOverride* pBreaks)
377 : {
378 27 : if (pBreaks->IsKeepWithNext())
379 : {
380 4 : pParaStyle->SetBreaks(enumXFBreakKeepWithNext);
381 : }
382 27 : if (pBreaks->IsPageBreakBefore())
383 : {
384 0 : pParaStyle->SetBreaks(enumXFBreakBefPage);
385 : }
386 27 : if (pBreaks->IsPageBreakAfter())
387 : {
388 0 : pParaStyle->SetBreaks(enumXFBreakAftPage);
389 : }
390 27 : if (pBreaks->IsColumnBreakBefore())
391 : {
392 0 : pParaStyle->SetBreaks(enumXFBreakBefColumn);
393 : }
394 27 : if (pBreaks->IsColumnBreakAfter())
395 : {
396 0 : pParaStyle->SetBreaks(enumXFBreakAftColumn);
397 : }
398 27 : }
399 :
400 24 : void LwpParaStyle::ApplyAlignment(XFParaStyle* pParaStyle, LwpAlignmentOverride* pAlign)
401 : {
402 24 : enumXFAlignType alignType = enumXFAlignStart;
403 : LwpAlignmentOverride::AlignType type;
404 :
405 24 : type = pAlign->GetAlignType();
406 24 : pParaStyle->SetNumberRight(false);//to identify its align attribute
407 24 : switch(type)
408 : {
409 : case LwpAlignmentOverride::ALIGN_LEFT:
410 4 : alignType = enumXFAlignStart;
411 4 : break;
412 : case LwpAlignmentOverride::ALIGN_RIGHT:
413 2 : alignType = enumXFAlignEnd;
414 2 : break;
415 : case LwpAlignmentOverride::ALIGN_CENTER:
416 14 : alignType = enumXFAlignCenter;
417 14 : break;
418 : case LwpAlignmentOverride::ALIGN_NUMERICLEFT://if non-number in table,ALIGN_NUMERICLEFT/RIGHT are useless
419 0 : alignType = enumXFAlignStart; //note by 1/28
420 0 : break;
421 : case LwpAlignmentOverride::ALIGN_JUSTIFY:
422 : case LwpAlignmentOverride::ALIGN_JUSTIFYALL:
423 0 : alignType = enumXFAlignJustify;
424 0 : break;
425 : case LwpAlignmentOverride::ALIGN_NUMERICRIGHT:
426 4 : pParaStyle->SetNumberRight(true);//to identify its align attribute
427 4 : alignType = enumXFAlignEnd;
428 4 : break;
429 : default:
430 0 : break;
431 : }
432 24 : pParaStyle->SetAlignType(alignType);
433 24 : }
434 :
435 179 : void LwpParaStyle::ApplyIndent(LwpPara* pPara, XFParaStyle* pParaStyle, LwpIndentOverride* pIndent)
436 : {
437 : LwpPara* pParentPara;
438 179 : if (pPara)
439 130 : pParentPara = pPara->GetParent();
440 : else
441 49 : pParentPara = NULL;
442 :
443 179 : std::unique_ptr<LwpIndentOverride> pTotalIndent(new LwpIndentOverride);
444 179 : if (pIndent->IsUseRelative() && pParentPara)
445 : {
446 0 : LwpIndentOverride* pParentIndent = pParentPara->GetIndent();
447 0 : if (!pParentIndent)
448 0 : return;
449 0 : pTotalIndent.reset(pIndent->clone());
450 :
451 : //add by ,for bullet only
452 0 : if (pPara)
453 : {
454 0 : if (pPara->GetBulletFlag())
455 : {
456 0 : pTotalIndent->SetMAll(pParentIndent->GetMAll() + pTotalIndent->GetMAll());
457 0 : pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
458 : pParaStyle->SetMargins(LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(
459 0 : pTotalIndent->GetMAll())), pTotalIndent->GetRight());
460 0 : pPara->SetIndent(pTotalIndent.release());
461 0 : return;
462 : }
463 : }
464 : //end add
465 0 : sal_uInt16 relative = pParentIndent->GetRelative();
466 :
467 0 : sal_Int32 Amount = pParentIndent->GetMAll();
468 :
469 0 : if (relative == LwpIndentOverride::RELATIVE_FIRST)
470 0 : Amount += pParentIndent->GetMFirst();
471 0 : else if (relative == LwpIndentOverride::RELATIVE_REST)
472 0 : Amount += pParentIndent->GetMRest();
473 0 : pTotalIndent->SetMAll(Amount + pTotalIndent->GetMAll());
474 0 : pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
475 :
476 0 : pParaStyle->SetIndent(pTotalIndent->GetFirst());
477 0 : pParaStyle->SetMargins(pTotalIndent->GetLeft(), pTotalIndent->GetRight());
478 0 : pPara->SetIndent(pTotalIndent.release());
479 :
480 : }
481 : else
482 : {
483 179 : pTotalIndent.reset(pIndent->clone());
484 : //add by
485 179 : if (pPara)
486 : {
487 130 : if (pPara->GetBulletFlag())
488 : {
489 : // pParaStyle->SetIndent(LwpTools::ConvertFromUnits(pIndent->GetMAll()));
490 : pParaStyle->SetMargins(LwpTools::ConvertToMetric(
491 4 : LwpTools::ConvertFromUnits(pIndent->GetMAll())), pIndent->GetRight());
492 4 : pPara->SetIndent(pTotalIndent.release());
493 4 : return;
494 : }
495 : }
496 : //end add
497 :
498 175 : pParaStyle->SetIndent(pIndent->GetFirst());
499 175 : pParaStyle->SetMargins(pIndent->GetLeft(), pIndent->GetRight());
500 175 : if (pPara)
501 : {
502 126 : pPara->SetIndent(pTotalIndent.release());
503 : }
504 175 : }
505 : }
506 :
507 139 : void LwpParaStyle::ApplySpacing(LwpPara* pPara, XFParaStyle* pParaStyle, LwpSpacingOverride* pSpacing)
508 : {
509 139 : LwpSpacingCommonOverride* spacing = pSpacing->GetSpacing();
510 139 : LwpSpacingCommonOverride* abovepara = pSpacing->GetAboveSpacing();
511 139 : LwpSpacingCommonOverride* belowpara = pSpacing->GetBelowSpacing();
512 :
513 139 : LwpSpacingCommonOverride::SpacingType type = spacing->GetType();
514 139 : sal_Int32 amount = spacing->GetAmount();
515 139 : sal_Int32 multiple = spacing->GetMultiple();
516 : enumLHType xftype;
517 : double height;
518 :
519 139 : switch(type)
520 : {
521 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
522 : {
523 117 : xftype = enumLHPercent;
524 117 : height = double(multiple)/65536L*100;
525 117 : pParaStyle->SetLineHeight(xftype,height);
526 : }
527 117 : break;
528 : case LwpSpacingCommonOverride::SPACING_LEADING:
529 : {
530 0 : xftype = enumLHSpace;
531 0 : height = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(amount));
532 0 : pParaStyle->SetLineHeight(xftype,height);
533 : }
534 0 : break;
535 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
536 : {
537 0 : xftype = enumLHHeight;
538 0 : height = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
539 0 : pParaStyle->SetLineHeight(xftype,height);
540 : }
541 0 : break;
542 : case LwpSpacingCommonOverride::SPACING_NONE:
543 22 : break;
544 : }
545 :
546 : //TO DO: Above Line need to be processed!!!!!!! what it means?????? 1-26
547 :
548 139 : type = abovepara->GetType();
549 139 : amount = abovepara->GetAmount();
550 139 : multiple = abovepara->GetMultiple();
551 139 : double above_val =-1;
552 139 : switch(type)
553 : {
554 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
555 : // above_val = LINE_HEIGHT*float(multiple)/65536L*100; //TO DO: 1-26
556 12 : break;
557 : case LwpSpacingCommonOverride::SPACING_LEADING:
558 0 : break;
559 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
560 104 : above_val = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
561 104 : break;
562 : case LwpSpacingCommonOverride::SPACING_NONE:
563 23 : break;
564 : }
565 :
566 139 : type = belowpara->GetType();
567 139 : amount = belowpara->GetAmount();
568 139 : multiple = belowpara->GetMultiple();
569 139 : double below_val=-1;
570 139 : switch(type)
571 : {
572 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
573 : // below_val = LINE_HEIGHT*float(multiple)/65536L*100;//TO DO: 1-26
574 4 : break;
575 : case LwpSpacingCommonOverride::SPACING_LEADING:
576 0 : break;
577 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
578 104 : below_val = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
579 104 : break;
580 : case LwpSpacingCommonOverride::SPACING_NONE:
581 31 : break;
582 : }
583 :
584 139 : if (pPara)
585 : {
586 112 : if (below_val != -1)
587 97 : pPara->SetBelowSpacing(below_val);
588 112 : LwpPara* pPrePara = dynamic_cast<LwpPara*>(pPara->GetPrevious().obj().get());
589 112 : if (pPrePara && above_val != -1)
590 : {
591 97 : above_val += pPrePara->GetBelowSpacing();
592 :
593 : }
594 :
595 : }
596 139 : pParaStyle->SetMargins(-1,-1,above_val,below_val);
597 139 : }
598 : /**************************************************************************
599 : * @short:
600 : * @descr:
601 : * @param:
602 : * @param:
603 : * @return:
604 : **************************************************************************/
605 25 : void LwpParaStyle::ApplyTab(XFParaStyle *pParaStyle, LwpTabOverride *pTabOverRide)
606 : {
607 25 : LwpObjectID& rTabRackID = pTabOverRide->GetTabRackID();
608 25 : if(rTabRackID.IsNull())
609 : {
610 20 : return;
611 : }
612 :
613 5 : LwpTabRack* pTabRack = dynamic_cast<LwpTabRack*>(rTabRackID.obj().get());
614 5 : if(!pTabRack)
615 : {
616 0 : return;
617 : }
618 :
619 5 : pParaStyle->ClearTabStyles();
620 : //Get margin left value
621 5 : double dMarginLeft = pParaStyle->GetMargins().GetLeft();
622 :
623 5 : sal_uInt16 nNumTabs = pTabRack->GetNumTabs();
624 15 : for(sal_uInt16 nIndex=0; nIndex<nNumTabs; nIndex++)
625 : {
626 : //get tab type
627 10 : LwpTab* pTab = pTabRack->Lookup(nIndex);
628 10 : if(!pTab)
629 0 : return;
630 :
631 10 : enumXFTab eType = enumXFTabNone;
632 10 : LwpTab::TabType type = pTab->GetTabType();
633 10 : switch(type)
634 : {
635 : case LwpTab::TT_LEFT:
636 0 : eType = enumXFTabLeft;
637 0 : break;
638 : case LwpTab::TT_CENTER:
639 5 : eType = enumXFTabCenter;
640 5 : break;
641 : case LwpTab::TT_RIGHT:
642 5 : eType = enumXFTabRight;
643 5 : break;
644 : case LwpTab::TT_NUMERIC:
645 0 : eType = enumXFTabChar;
646 0 : break;
647 : }
648 :
649 : //get position
650 10 : sal_uInt32 nPos = pTab->GetPosition();
651 : //different feature between SODC and lwp, the tab length must minus the margin left of para.
652 10 : double fLen = LwpTools::ConvertFromUnitsToMetric(nPos) - dMarginLeft;
653 :
654 : //get leader type
655 10 : sal_Unicode cLeader = 0x00;
656 10 : LwpTab::LeaderType leader= pTab->GetLeaderType();
657 10 : switch(leader)
658 : {
659 : case LwpTab::TL_NONE:
660 10 : cLeader = 0x20; //space
661 10 : break;
662 : case LwpTab::TL_HYPHEN: //'-'
663 0 : cLeader = 0xAD;
664 0 : break;
665 : case LwpTab::TL_DOT: //'.'
666 0 : cLeader = 0x2E;
667 0 : break;
668 : case LwpTab::TL_LINE: //'_'
669 0 : cLeader = 0x5F;
670 0 : break;
671 : }
672 :
673 10 : sal_Unicode cAlignChar = static_cast<sal_Unicode>(pTab->GetAlignChar());
674 :
675 10 : pParaStyle->AddTabStyle(eType,fLen,cLeader,cAlignChar);
676 : }
677 :
678 : }
679 :
680 68 : void LwpParaStyle::RegisterStyle()
681 : {
682 68 : XFParaStyle* pStyle = new XFParaStyle();
683 :
684 : //Set name
685 68 : OUString styleName = GetName().str();
686 68 : pStyle->SetStyleName(styleName);
687 :
688 : //Create font
689 68 : LwpFontManager& rFontMgr = m_pFoundry->GetFontManger();
690 136 : rtl::Reference<XFFont> pFont = rFontMgr.CreateFont(m_nFinalFontID);
691 68 : pStyle->SetFont(pFont);
692 :
693 : //Set other paragraph properties...
694 :
695 68 : Apply(pStyle);
696 : //Add style
697 68 : LwpStyleManager* pStyleMgr = m_pFoundry->GetStyleManager();
698 136 : pStyleMgr->AddStyle(GetObjectID(), pStyle);
699 68 : }
700 :
701 8 : LwpAlignmentOverride* LwpParaStyle::GetAlignment()
702 : {
703 8 : if (m_AlignmentStyle.obj() == NULL)
704 0 : return NULL;
705 :
706 8 : LwpAlignmentPiece *pPiece = dynamic_cast<LwpAlignmentPiece*>(m_AlignmentStyle.obj().get());
707 8 : if (pPiece)
708 8 : return dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
709 0 : return NULL;
710 : }
711 :
712 616 : LwpIndentOverride* LwpParaStyle::GetIndent()
713 : {
714 616 : if (m_IndentStyle.obj() == NULL)
715 61 : return NULL;
716 :
717 555 : LwpIndentPiece *pPiece = dynamic_cast<LwpIndentPiece*>(m_IndentStyle.obj().get());
718 555 : if (pPiece)
719 555 : return dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
720 0 : return NULL;
721 : }
722 :
723 224 : LwpSpacingOverride* LwpParaStyle::GetSpacing()
724 : {
725 224 : if (m_SpacingStyle.obj() == NULL)
726 0 : return NULL;
727 :
728 224 : LwpSpacingPiece *pPiece = dynamic_cast<LwpSpacingPiece*>(m_SpacingStyle.obj().get());
729 224 : if (pPiece)
730 224 : return dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
731 0 : return NULL;
732 : }
733 :
734 2 : LwpParaBorderOverride* LwpParaStyle::GetParaBorder() const
735 : {
736 2 : if(m_BorderStyle.IsNull())
737 0 : return NULL;
738 :
739 2 : LwpParaBorderPiece *pPiece = dynamic_cast<LwpParaBorderPiece*>(m_BorderStyle.obj(VO_PARABORDERPIECE).get());
740 2 : if (pPiece)
741 2 : return dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
742 0 : return NULL;
743 : }
744 :
745 127 : LwpBreaksOverride* LwpParaStyle::GetBreaks() const
746 : {
747 127 : if(m_BreaksStyle.IsNull())
748 0 : return NULL;
749 :
750 127 : LwpBreaksPiece *pPiece = dynamic_cast<LwpBreaksPiece*>(m_BreaksStyle.obj(VO_BREAKSPIECE).get());
751 127 : if (pPiece)
752 127 : return dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
753 0 : return NULL;
754 : }
755 :
756 :
757 259 : LwpNumberingOverride* LwpParaStyle::GetNumberingOverride() const
758 : {
759 259 : if(m_NumberingStyle.IsNull())
760 34 : return NULL;
761 :
762 225 : LwpNumberingPiece *pPiece = dynamic_cast<LwpNumberingPiece*>(m_NumberingStyle.obj(VO_NUMBERINGPIECE).get());
763 225 : if (pPiece)
764 225 : return dynamic_cast<LwpNumberingOverride*>(pPiece->GetOverride());
765 0 : return NULL;
766 : }
767 :
768 : /**************************************************************************
769 : * @short:
770 : * @descr:
771 : * @param:
772 : * @param:
773 : * @return:
774 : **************************************************************************/
775 25 : LwpTabOverride* LwpParaStyle::GetTabOverride() const
776 : {
777 25 : if(m_TabStyle.obj() == NULL)
778 25 : return NULL;
779 0 : LwpTabPiece *pPiece = dynamic_cast<LwpTabPiece*>(m_TabStyle.obj().get());
780 0 : if (pPiece)
781 0 : return dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
782 0 : return NULL;
783 : }
784 :
785 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
