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