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 136 : LwpParaStyle::LwpParaStyle(LwpObjectHeader& objHdr, LwpSvStream* pStrm) :
89 136 : LwpTextStyle(objHdr, pStrm), m_pKinsokuOptsOverride(new LwpKinsokuOptsOverride),
90 272 : m_pBulletOverride(new LwpBulletOverride)
91 : {
92 136 : }
93 :
94 408 : LwpParaStyle::~LwpParaStyle()
95 : {
96 136 : if (m_pKinsokuOptsOverride)
97 : {
98 136 : delete m_pKinsokuOptsOverride;
99 : }
100 :
101 136 : if (m_pBulletOverride)
102 : {
103 136 : delete m_pBulletOverride;
104 : }
105 272 : }
106 :
107 136 : void LwpParaStyle::Read()
108 : {
109 136 : LwpTextStyle::Read();
110 :
111 136 : 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 136 : m_AlignmentStyle.ReadIndexed(m_pObjStrm);
139 136 : m_SpacingStyle.ReadIndexed(m_pObjStrm);
140 136 : m_IndentStyle.ReadIndexed(m_pObjStrm);
141 136 : m_BorderStyle.ReadIndexed(m_pObjStrm);
142 136 : m_BreaksStyle.ReadIndexed(m_pObjStrm);
143 136 : m_NumberingStyle.ReadIndexed(m_pObjStrm);
144 136 : m_TabStyle.ReadIndexed(m_pObjStrm);
145 :
146 136 : m_pKinsokuOptsOverride->Read(m_pObjStrm);
147 136 : m_pBulletOverride->Read(m_pObjStrm);
148 :
149 136 : if (m_pObjStrm->CheckExtra())
150 : {
151 104 : m_BackgroundStyle.ReadIndexed(m_pObjStrm);
152 104 : m_pObjStrm->SkipExtra();
153 : }
154 :
155 : }
156 136 : }
157 :
158 136 : void LwpParaStyle::Apply(XFParaStyle *pParaStyle)
159 : {
160 : assert(pParaStyle);
161 136 : if (!pParaStyle)
162 136 : return;
163 :
164 136 : LwpVirtualPiece *pPiece = NULL;
165 : //alignment:
166 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_AlignmentStyle.obj().get());
167 136 : if( pPiece )
168 : {
169 40 : LwpAlignmentOverride *pAlign = dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
170 40 : if( pAlign )
171 40 : ApplyAlignment(pParaStyle,pAlign);
172 : }
173 :
174 : //don't known top and bottom indent now.
175 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_IndentStyle.obj().get());
176 136 : if( pPiece )
177 : {
178 98 : LwpIndentOverride *pIndent = dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
179 98 : if( pIndent )
180 : {
181 98 : if (!m_pBulletOverride->IsInValid())//Add by ,for remove bullet indent in named bullet style
182 : {
183 82 : boost::scoped_ptr<LwpIndentOverride> pNewIndent(pIndent->clone());
184 82 : pNewIndent->SetMFirst(0);
185 82 : pNewIndent->SetMRest(0);
186 82 : ApplyIndent(NULL, pParaStyle, pNewIndent.get());
187 : }
188 : else
189 16 : ApplyIndent(NULL,pParaStyle,pIndent);
190 : }
191 : }
192 : //shadow & borders.
193 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BorderStyle.obj().get());
194 136 : if( pPiece )
195 : {
196 8 : LwpParaBorderOverride *pBorder = dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
197 8 : if( pBorder )
198 : {
199 8 : this->ApplyParaBorder(pParaStyle, pBorder);
200 : }
201 : }
202 :
203 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_SpacingStyle.obj().get());
204 136 : if (pPiece)
205 : {
206 54 : LwpSpacingOverride *pSpacing = dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
207 54 : if( pSpacing)
208 54 : ApplySpacing(NULL,pParaStyle,pSpacing);
209 : }
210 :
211 : //paragraph background.
212 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BackgroundStyle.obj().get());
213 136 : if( pPiece )
214 : {
215 0 : LwpBackgroundOverride *pBack = dynamic_cast<LwpBackgroundOverride*>(pPiece->GetOverride());
216 0 : if( pBack )
217 : {
218 0 : LwpColor color = pBack->GetBackColor();
219 0 : XFColor aXFColor( color.To24Color() );
220 0 : pParaStyle->SetBackColor( aXFColor );
221 : }
222 : }
223 :
224 : //add tab style
225 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_TabStyle.obj().get());
226 136 : if( pPiece )
227 : {
228 0 : LwpTabOverride *pTab = dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
229 0 : if(pTab)
230 : {
231 0 : ApplyTab(pParaStyle,pTab);
232 : }
233 : }
234 136 : pPiece = dynamic_cast<LwpVirtualPiece*>(m_BreaksStyle.obj().get());
235 136 : if( pPiece )
236 : {
237 54 : LwpBreaksOverride *pBreak = dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
238 54 : if(pBreak)
239 : {
240 54 : ApplyBreaks(pParaStyle,pBreak);
241 : }
242 : }
243 :
244 : }
245 :
246 680 : void LwpParaStyle::ApplySubBorder(LwpBorderStuff* pBorderStuff, LwpBorderStuff::BorderType eType, XFBorders* pXFBorders)
247 : {
248 680 : enumXFBorder eXFBorderSide = enumXFBorderNone;
249 680 : switch (eType)
250 : {
251 : case LwpBorderStuff::LEFT:
252 170 : eXFBorderSide = enumXFBorderLeft;
253 170 : break;
254 : case LwpBorderStuff::RIGHT:
255 170 : eXFBorderSide = enumXFBorderRight;
256 170 : break;
257 : case LwpBorderStuff::TOP:
258 170 : eXFBorderSide = enumXFBorderTop;
259 170 : break;
260 : case LwpBorderStuff::BOTTOM:
261 170 : eXFBorderSide = enumXFBorderBottom;
262 170 : break;
263 : default:
264 0 : break;
265 : }
266 :
267 680 : LwpColor aColor = pBorderStuff->GetSideColor(eType);
268 680 : float fWidth = pBorderStuff->GetSideWidth(eType);
269 680 : sal_uInt16 nType = pBorderStuff->GetSideType(eType);
270 :
271 680 : switch (nType)
272 : {
273 : default://fall through!
274 : case 0x14: //single fall through!
275 : case 0x17: //treble
276 680 : pXFBorders->SetWidth(eXFBorderSide, fWidth);
277 680 : break;
278 : case 0x15: //double , fall through!
279 : case 0x16: //thick double
280 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
281 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.333));
282 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.334));
283 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.333));
284 : // pXFBorders->SetWidth(eXFBorderSide, fWidth);
285 0 : break;
286 : case 0x18: //thick-thin
287 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
288 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.5));
289 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.25));
290 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.25));
291 0 : break;
292 : case 0x19: //thin-thick
293 0 : pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
294 0 : pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.7));
295 0 : pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.15));
296 0 : pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.15));
297 0 : break;
298 : }
299 :
300 680 : if (aColor.IsValidColor())
301 : {
302 680 : XFColor aXFColor(aColor.To24Color());
303 680 : pXFBorders->SetColor(eXFBorderSide, aXFColor );
304 680 : }
305 680 : }
306 :
307 12 : void LwpParaStyle::ApplyParaBorder(XFParaStyle* pParaStyle, LwpParaBorderOverride* pBorder)
308 : {
309 : //convert LwpShadow:
310 12 : LwpShadow *pShadow = pBorder->GetShadow();
311 12 : if( pShadow )
312 : {
313 12 : LwpColor color = pShadow->GetColor();
314 12 : float offsetX = pShadow->GetOffsetX();
315 12 : float offsetY = pShadow->GetOffsetY();
316 :
317 12 : if( offsetX && offsetY && color.IsValidColor() )
318 : {
319 2 : XFColor aXFColor(color.To24Color());
320 2 : bool left = false;
321 2 : bool top = false;
322 2 : if( offsetX < 0 )
323 0 : left = true;
324 2 : if( offsetY < 0 )
325 0 : top = true;
326 2 : if( left )
327 : {
328 0 : if( top )
329 0 : pParaStyle->SetShadow(enumXFShadowLeftTop,-offsetX,aXFColor);
330 : else
331 0 : pParaStyle->SetShadow(enumXFShadowLeftBottom,-offsetX,aXFColor);
332 : }
333 : else
334 : {
335 2 : if( top )
336 0 : pParaStyle->SetShadow(enumXFShadowRightTop,offsetX,aXFColor);
337 : else
338 2 : pParaStyle->SetShadow(enumXFShadowRightBottom,offsetX,aXFColor);
339 : }
340 12 : }
341 : }
342 :
343 : //convert to XFBorders object:
344 12 : LwpBorderStuff *pBorderStuff = pBorder->GetBorderStuff();
345 12 : if( pBorderStuff && pBorderStuff->GetSide() != 0 )
346 : {
347 4 : XFBorders *pXFBorders = new XFBorders();
348 4 : pParaStyle->SetBorders(pXFBorders);
349 :
350 4 : LwpMargins* pMargins = pBorder->GetMargins();
351 :
352 : // apply 4 borders respectively
353 : LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
354 4 : LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
355 : float pMarginValue[4];
356 :
357 20 : for (sal_uInt8 nC = 0; nC < 4; nC++)
358 : {
359 16 : if (pBorderStuff->HasSide(pType[nC]))
360 : {
361 16 : ApplySubBorder(pBorderStuff, pType[nC], pXFBorders);
362 :
363 : //get border spacing to text content
364 16 : if (pMargins)
365 : {
366 16 : pMarginValue[nC] = static_cast<float>(pMargins->GetMarginsValue(nC));
367 : }
368 : }
369 :
370 : }
371 :
372 : //apply border spacing to text content
373 4 : pParaStyle->SetPadding(pMarginValue[0], pMarginValue[1], pMarginValue[2], pMarginValue[3]);
374 :
375 : }
376 12 : }
377 :
378 54 : void LwpParaStyle::ApplyBreaks(XFParaStyle* pParaStyle, LwpBreaksOverride* pBreaks)
379 : {
380 54 : if (pBreaks->IsKeepWithNext())
381 : {
382 8 : pParaStyle->SetBreaks(enumXFBreakKeepWithNext);
383 : }
384 54 : if (pBreaks->IsPageBreakBefore())
385 : {
386 0 : pParaStyle->SetBreaks(enumXFBreakBefPage);
387 : }
388 54 : if (pBreaks->IsPageBreakAfter())
389 : {
390 0 : pParaStyle->SetBreaks(enumXFBreakAftPage);
391 : }
392 54 : if (pBreaks->IsColumnBreakBefore())
393 : {
394 0 : pParaStyle->SetBreaks(enumXFBreakBefColumn);
395 : }
396 54 : if (pBreaks->IsColumnBreakAfter())
397 : {
398 0 : pParaStyle->SetBreaks(enumXFBreakAftColumn);
399 : }
400 54 : }
401 :
402 48 : void LwpParaStyle::ApplyAlignment(XFParaStyle* pParaStyle, LwpAlignmentOverride* pAlign)
403 : {
404 48 : enumXFAlignType alignType = enumXFAlignStart;
405 : LwpAlignmentOverride::AlignType type;
406 :
407 48 : type = pAlign->GetAlignType();
408 48 : pParaStyle->SetNumberRight(false);//to identify its align attribute
409 48 : switch(type)
410 : {
411 : case LwpAlignmentOverride::ALIGN_LEFT:
412 8 : alignType = enumXFAlignStart;
413 8 : break;
414 : case LwpAlignmentOverride::ALIGN_RIGHT:
415 4 : alignType = enumXFAlignEnd;
416 4 : break;
417 : case LwpAlignmentOverride::ALIGN_CENTER:
418 28 : alignType = enumXFAlignCenter;
419 28 : break;
420 : case LwpAlignmentOverride::ALIGN_NUMERICLEFT://if non-number in table,ALIGN_NUMERICLEFT/RIGHT are useless
421 0 : alignType = enumXFAlignStart; //note by 1/28
422 0 : break;
423 : case LwpAlignmentOverride::ALIGN_JUSTIFY:
424 : case LwpAlignmentOverride::ALIGN_JUSTIFYALL:
425 0 : alignType = enumXFAlignJustify;
426 0 : break;
427 : case LwpAlignmentOverride::ALIGN_NUMERICRIGHT:
428 8 : pParaStyle->SetNumberRight(true);//to identify its align attribute
429 8 : alignType = enumXFAlignEnd;
430 8 : break;
431 : default:
432 0 : break;
433 : }
434 48 : pParaStyle->SetAlignType(alignType);
435 48 : }
436 :
437 358 : void LwpParaStyle::ApplyIndent(LwpPara* pPara, XFParaStyle* pParaStyle, LwpIndentOverride* pIndent)
438 : {
439 : LwpPara* pParentPara;
440 358 : if (pPara)
441 260 : pParentPara = pPara->GetParent();
442 : else
443 98 : pParentPara = NULL;
444 :
445 358 : std::unique_ptr<LwpIndentOverride> pTotalIndent(new LwpIndentOverride);
446 358 : if (pIndent->IsUseRelative() && pParentPara)
447 : {
448 0 : LwpIndentOverride* pParentIndent = pParentPara->GetIndent();
449 0 : if (!pParentIndent)
450 0 : return;
451 0 : pTotalIndent.reset(pIndent->clone());
452 :
453 : //add by ,for bullet only
454 0 : if (pPara)
455 : {
456 0 : if (pPara->GetBulletFlag())
457 : {
458 0 : pTotalIndent->SetMAll(pParentIndent->GetMAll() + pTotalIndent->GetMAll());
459 0 : pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
460 : pParaStyle->SetMargins(LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(
461 0 : pTotalIndent->GetMAll())), pTotalIndent->GetRight());
462 0 : pPara->SetIndent(pTotalIndent.release());
463 0 : return;
464 : }
465 : }
466 : //end add
467 0 : sal_uInt16 relative = pParentIndent->GetRelative();
468 :
469 0 : sal_Int32 Amount = pParentIndent->GetMAll();
470 :
471 0 : if (relative == LwpIndentOverride::RELATIVE_FIRST)
472 0 : Amount += pParentIndent->GetMFirst();
473 0 : else if (relative == LwpIndentOverride::RELATIVE_REST)
474 0 : Amount += pParentIndent->GetMRest();
475 0 : pTotalIndent->SetMAll(Amount + pTotalIndent->GetMAll());
476 0 : pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
477 :
478 0 : pParaStyle->SetIndent(pTotalIndent->GetFirst());
479 0 : pParaStyle->SetMargins(pTotalIndent->GetLeft(), pTotalIndent->GetRight());
480 0 : pPara->SetIndent(pTotalIndent.release());
481 :
482 : }
483 : else
484 : {
485 358 : pTotalIndent.reset(pIndent->clone());
486 : //add by
487 358 : if (pPara)
488 : {
489 260 : if (pPara->GetBulletFlag())
490 : {
491 : // pParaStyle->SetIndent(LwpTools::ConvertFromUnits(pIndent->GetMAll()));
492 : pParaStyle->SetMargins(LwpTools::ConvertToMetric(
493 8 : LwpTools::ConvertFromUnits(pIndent->GetMAll())), pIndent->GetRight());
494 8 : pPara->SetIndent(pTotalIndent.release());
495 8 : return;
496 : }
497 : }
498 : //end add
499 :
500 350 : pParaStyle->SetIndent(pIndent->GetFirst());
501 350 : pParaStyle->SetMargins(pIndent->GetLeft(), pIndent->GetRight());
502 350 : if (pPara)
503 : {
504 252 : pPara->SetIndent(pTotalIndent.release());
505 : }
506 350 : }
507 : }
508 :
509 278 : void LwpParaStyle::ApplySpacing(LwpPara* pPara, XFParaStyle* pParaStyle, LwpSpacingOverride* pSpacing)
510 : {
511 278 : LwpSpacingCommonOverride* spacing = pSpacing->GetSpacing();
512 278 : LwpSpacingCommonOverride* abovepara = pSpacing->GetAboveSpacing();
513 278 : LwpSpacingCommonOverride* belowpara = pSpacing->GetBelowSpacing();
514 :
515 278 : LwpSpacingCommonOverride::SpacingType type = spacing->GetType();
516 278 : sal_Int32 amount = spacing->GetAmount();
517 278 : sal_Int32 multiple = spacing->GetMultiple();
518 : enumLHType xftype;
519 : double height;
520 :
521 278 : switch(type)
522 : {
523 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
524 : {
525 234 : xftype = enumLHPercent;
526 234 : height = double(multiple)/65536L*100;
527 234 : pParaStyle->SetLineHeight(xftype,height);
528 : }
529 234 : break;
530 : case LwpSpacingCommonOverride::SPACING_LEADING:
531 : {
532 0 : xftype = enumLHSpace;
533 0 : height = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(amount));
534 0 : pParaStyle->SetLineHeight(xftype,height);
535 : }
536 0 : break;
537 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
538 : {
539 0 : xftype = enumLHHeight;
540 0 : height = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
541 0 : pParaStyle->SetLineHeight(xftype,height);
542 : }
543 0 : break;
544 : case LwpSpacingCommonOverride::SPACING_NONE:
545 44 : break;
546 : }
547 :
548 : //TO DO: Above Line need to be processed!!!!!!! what it means?????? 1-26
549 :
550 278 : type = abovepara->GetType();
551 278 : amount = abovepara->GetAmount();
552 278 : multiple = abovepara->GetMultiple();
553 278 : double above_val =-1;
554 278 : switch(type)
555 : {
556 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
557 : // above_val = LINE_HEIGHT*float(multiple)/65536L*100; //TO DO: 1-26
558 24 : break;
559 : case LwpSpacingCommonOverride::SPACING_LEADING:
560 0 : break;
561 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
562 208 : above_val = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
563 208 : break;
564 : case LwpSpacingCommonOverride::SPACING_NONE:
565 46 : break;
566 : }
567 :
568 278 : type = belowpara->GetType();
569 278 : amount = belowpara->GetAmount();
570 278 : multiple = belowpara->GetMultiple();
571 278 : double below_val=-1;
572 278 : switch(type)
573 : {
574 : case LwpSpacingCommonOverride::SPACING_DYNAMIC:
575 : // below_val = LINE_HEIGHT*float(multiple)/65536L*100;//TO DO: 1-26
576 8 : break;
577 : case LwpSpacingCommonOverride::SPACING_LEADING:
578 0 : break;
579 : case LwpSpacingCommonOverride::SPACING_CUSTOM:
580 208 : below_val = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
581 208 : break;
582 : case LwpSpacingCommonOverride::SPACING_NONE:
583 62 : break;
584 : }
585 :
586 278 : if (pPara)
587 : {
588 224 : if (below_val != -1)
589 194 : pPara->SetBelowSpacing(below_val);
590 224 : LwpPara* pPrePara = dynamic_cast<LwpPara*>(pPara->GetPrevious().obj().get());
591 224 : if (pPrePara && above_val != -1)
592 : {
593 194 : above_val += pPrePara->GetBelowSpacing();
594 :
595 : }
596 :
597 : }
598 278 : pParaStyle->SetMargins(-1,-1,above_val,below_val);
599 278 : }
600 : /**************************************************************************
601 : * @short:
602 : * @descr:
603 : * @param:
604 : * @param:
605 : * @return:
606 : **************************************************************************/
607 50 : void LwpParaStyle::ApplyTab(XFParaStyle *pParaStyle, LwpTabOverride *pTabOverRide)
608 : {
609 50 : LwpObjectID& rTabRackID = pTabOverRide->GetTabRackID();
610 50 : if(rTabRackID.IsNull())
611 : {
612 40 : return;
613 : }
614 :
615 10 : LwpTabRack* pTabRack = dynamic_cast<LwpTabRack*>(rTabRackID.obj().get());
616 10 : if(!pTabRack)
617 : {
618 0 : return;
619 : }
620 :
621 10 : pParaStyle->ClearTabStyles();
622 : //Get margin left value
623 10 : double dMarginLeft = pParaStyle->GetMargins().GetLeft();
624 :
625 10 : sal_uInt16 nNumTabs = pTabRack->GetNumTabs();
626 30 : for(sal_uInt16 nIndex=0; nIndex<nNumTabs; nIndex++)
627 : {
628 : //get tab type
629 20 : LwpTab* pTab = pTabRack->Lookup(nIndex);
630 20 : if(!pTab)
631 0 : return;
632 :
633 20 : enumXFTab eType = enumXFTabNone;
634 20 : LwpTab::TabType type = pTab->GetTabType();
635 20 : switch(type)
636 : {
637 : case LwpTab::TT_LEFT:
638 0 : eType = enumXFTabLeft;
639 0 : break;
640 : case LwpTab::TT_CENTER:
641 10 : eType = enumXFTabCenter;
642 10 : break;
643 : case LwpTab::TT_RIGHT:
644 10 : eType = enumXFTabRight;
645 10 : break;
646 : case LwpTab::TT_NUMERIC:
647 0 : eType = enumXFTabChar;
648 0 : break;
649 : }
650 :
651 : //get position
652 20 : sal_uInt32 nPos = pTab->GetPosition();
653 : //different feature between SODC and lwp, the tab length must minus the margin left of para.
654 20 : double fLen = LwpTools::ConvertFromUnitsToMetric(nPos) - dMarginLeft;
655 :
656 : //get leader type
657 20 : sal_Unicode cLeader = 0x00;
658 20 : LwpTab::LeaderType leader= pTab->GetLeaderType();
659 20 : switch(leader)
660 : {
661 : case LwpTab::TL_NONE:
662 20 : cLeader = 0x20; //space
663 20 : break;
664 : case LwpTab::TL_HYPHEN: //'-'
665 0 : cLeader = 0xAD;
666 0 : break;
667 : case LwpTab::TL_DOT: //'.'
668 0 : cLeader = 0x2E;
669 0 : break;
670 : case LwpTab::TL_LINE: //'_'
671 0 : cLeader = 0x5F;
672 0 : break;
673 : }
674 :
675 20 : sal_Unicode cAlignChar = static_cast<sal_Unicode>(pTab->GetAlignChar());
676 :
677 20 : pParaStyle->AddTabStyle(eType,fLen,cLeader,cAlignChar);
678 : }
679 :
680 : }
681 :
682 136 : void LwpParaStyle::RegisterStyle()
683 : {
684 136 : XFParaStyle* pStyle = new XFParaStyle();
685 :
686 : //Set name
687 136 : OUString styleName = GetName().str();
688 136 : pStyle->SetStyleName(styleName);
689 :
690 : //Create font
691 136 : LwpFontManager& rFontMgr = m_pFoundry->GetFontManger();
692 272 : rtl::Reference<XFFont> pFont = rFontMgr.CreateFont(m_nFinalFontID);
693 136 : pStyle->SetFont(pFont);
694 :
695 : //Set other paragraph properties...
696 :
697 136 : Apply(pStyle);
698 : //Add style
699 136 : LwpStyleManager* pStyleMgr = m_pFoundry->GetStyleManager();
700 272 : pStyleMgr->AddStyle(GetObjectID(), pStyle);
701 136 : }
702 :
703 16 : LwpAlignmentOverride* LwpParaStyle::GetAlignment()
704 : {
705 16 : if (m_AlignmentStyle.obj() == NULL)
706 0 : return NULL;
707 :
708 16 : LwpAlignmentPiece *pPiece = dynamic_cast<LwpAlignmentPiece*>(m_AlignmentStyle.obj().get());
709 16 : if (pPiece)
710 16 : return dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
711 0 : return NULL;
712 : }
713 :
714 1232 : LwpIndentOverride* LwpParaStyle::GetIndent()
715 : {
716 1232 : if (m_IndentStyle.obj() == NULL)
717 122 : return NULL;
718 :
719 1110 : LwpIndentPiece *pPiece = dynamic_cast<LwpIndentPiece*>(m_IndentStyle.obj().get());
720 1110 : if (pPiece)
721 1110 : return dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
722 0 : return NULL;
723 : }
724 :
725 448 : LwpSpacingOverride* LwpParaStyle::GetSpacing()
726 : {
727 448 : if (m_SpacingStyle.obj() == NULL)
728 0 : return NULL;
729 :
730 448 : LwpSpacingPiece *pPiece = dynamic_cast<LwpSpacingPiece*>(m_SpacingStyle.obj().get());
731 448 : if (pPiece)
732 448 : return dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
733 0 : return NULL;
734 : }
735 :
736 4 : LwpParaBorderOverride* LwpParaStyle::GetParaBorder() const
737 : {
738 4 : if(m_BorderStyle.IsNull())
739 0 : return NULL;
740 :
741 4 : LwpParaBorderPiece *pPiece = dynamic_cast<LwpParaBorderPiece*>(m_BorderStyle.obj(VO_PARABORDERPIECE).get());
742 4 : if (pPiece)
743 4 : return dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
744 0 : return NULL;
745 : }
746 :
747 254 : LwpBreaksOverride* LwpParaStyle::GetBreaks() const
748 : {
749 254 : if(m_BreaksStyle.IsNull())
750 0 : return NULL;
751 :
752 254 : LwpBreaksPiece *pPiece = dynamic_cast<LwpBreaksPiece*>(m_BreaksStyle.obj(VO_BREAKSPIECE).get());
753 254 : if (pPiece)
754 254 : return dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
755 0 : return NULL;
756 : }
757 :
758 :
759 518 : LwpNumberingOverride* LwpParaStyle::GetNumberingOverride() const
760 : {
761 518 : if(m_NumberingStyle.IsNull())
762 68 : return NULL;
763 :
764 450 : LwpNumberingPiece *pPiece = dynamic_cast<LwpNumberingPiece*>(m_NumberingStyle.obj(VO_NUMBERINGPIECE).get());
765 450 : if (pPiece)
766 450 : return dynamic_cast<LwpNumberingOverride*>(pPiece->GetOverride());
767 0 : return NULL;
768 : }
769 :
770 : /**************************************************************************
771 : * @short:
772 : * @descr:
773 : * @param:
774 : * @param:
775 : * @return:
776 : **************************************************************************/
777 50 : LwpTabOverride* LwpParaStyle::GetTabOverride() const
778 : {
779 50 : if(m_TabStyle.obj() == NULL)
780 50 : return NULL;
781 0 : LwpTabPiece *pPiece = dynamic_cast<LwpTabPiece*>(m_TabStyle.obj().get());
782 0 : if (pPiece)
783 0 : return dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
784 0 : return NULL;
785 : }
786 :
787 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
