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