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