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 <memory>
66 :
67 : #include "clone.hxx"
68 : #include "lwpoverride.hxx"
69 : #include "lwpfilehdr.hxx"
70 : #include "lwpatomholder.hxx"
71 : #include "lwpborderstuff.hxx"
72 : #include "lwpmargins.hxx"
73 : #include "lwpbackgroundstuff.hxx"
74 :
75 : /*class LwpOverride*/
76 3518 : LwpOverride::LwpOverride(LwpOverride const& rOther)
77 : : m_nValues(rOther.m_nValues)
78 : , m_nOverride(rOther.m_nOverride)
79 3518 : , m_nApply(rOther.m_nApply)
80 : {
81 3518 : }
82 :
83 1216 : void LwpOverride::ReadCommon(LwpObjectStream* pStrm)
84 : {
85 1216 : m_nValues = pStrm->QuickReaduInt16();
86 1216 : m_nOverride = pStrm->QuickReaduInt16();
87 1216 : m_nApply = pStrm->QuickReaduInt16();
88 1216 : pStrm->SkipExtra();
89 1216 : }
90 :
91 0 : void LwpOverride::Clear()
92 : {
93 0 : m_nValues = 0;
94 0 : m_nOverride = 0;
95 0 : m_nApply = 0;
96 0 : }
97 :
98 438 : void LwpOverride::Override(sal_uInt16 nBits, STATE eState)
99 : {
100 438 : if (eState == STATE_STYLE)
101 : {
102 0 : m_nValues &= ~nBits;
103 0 : m_nOverride &= ~nBits;
104 : }
105 : else
106 : {
107 438 : m_nOverride |= nBits;
108 438 : if (eState == STATE_ON)
109 : {
110 438 : m_nValues |= nBits;
111 : }
112 : else /* State == STATE_OFF */
113 : {
114 0 : m_nValues &= ~nBits;
115 : }
116 : }
117 438 : m_nApply |= nBits;
118 438 : }
119 :
120 : /*class LwpTextLanguageOverride*/
121 0 : LwpTextLanguageOverride::LwpTextLanguageOverride(LwpTextLanguageOverride const& rOther)
122 : : LwpOverride(rOther)
123 0 : , m_nLanguage(rOther.m_nLanguage)
124 : {
125 0 : }
126 :
127 0 : LwpTextLanguageOverride* LwpTextLanguageOverride::clone() const
128 : {
129 0 : return new LwpTextLanguageOverride(*this);
130 : }
131 :
132 136 : void LwpTextLanguageOverride::Read(LwpObjectStream* pStrm)
133 : {
134 136 : if (pStrm->QuickReadBool())
135 : {
136 106 : ReadCommon(pStrm);
137 106 : m_nLanguage = pStrm->QuickReaduInt16();
138 : }
139 :
140 136 : pStrm->SkipExtra();
141 :
142 136 : }
143 :
144 : /*class LwpTextAttributeOverride*/
145 0 : LwpTextAttributeOverride::LwpTextAttributeOverride(LwpTextAttributeOverride const& rOther)
146 : : LwpOverride(rOther)
147 : , m_nHideLevels(rOther.m_nHideLevels)
148 0 : , m_nBaseLineOffset(rOther.m_nBaseLineOffset)
149 : {
150 0 : }
151 :
152 0 : LwpTextAttributeOverride* LwpTextAttributeOverride::clone() const
153 : {
154 0 : return new LwpTextAttributeOverride(*this);
155 : }
156 :
157 658 : void LwpTextAttributeOverride::Read(LwpObjectStream* pStrm)
158 : {
159 658 : if (pStrm->QuickReadBool())
160 : {
161 628 : ReadCommon(pStrm);
162 628 : m_nHideLevels = pStrm->QuickReaduInt16();
163 :
164 628 : if (LwpFileHeader::m_nFileRevision > 0x000A)
165 628 : m_nBaseLineOffset = pStrm->QuickReaduInt32();
166 : }
167 :
168 658 : pStrm->SkipExtra();
169 658 : }
170 :
171 522 : bool LwpTextAttributeOverride::IsHighlight()
172 : {
173 522 : return (m_nValues & TAO_HIGHLIGHT) != 0;
174 : }
175 :
176 : /*class LwpKinsokuOptsOverride*/
177 0 : LwpKinsokuOptsOverride::LwpKinsokuOptsOverride(LwpKinsokuOptsOverride const& rOther)
178 : : LwpOverride(rOther)
179 0 : , m_nLevels(rOther.m_nLevels)
180 : {
181 0 : }
182 :
183 0 : LwpKinsokuOptsOverride* LwpKinsokuOptsOverride::clone() const
184 : {
185 0 : return new LwpKinsokuOptsOverride(*this);
186 : }
187 :
188 136 : void LwpKinsokuOptsOverride::Read(LwpObjectStream* pStrm)
189 : {
190 136 : if (pStrm->QuickReadBool())
191 : {
192 8 : ReadCommon(pStrm);
193 8 : m_nLevels = pStrm->QuickReaduInt16();
194 : }
195 :
196 136 : pStrm->SkipExtra();
197 136 : }
198 :
199 : /*class LwpBulletOverride*/
200 530 : LwpBulletOverride::LwpBulletOverride(LwpBulletOverride const& rOther)
201 : : LwpOverride(rOther)
202 : , m_SilverBullet(rOther.m_SilverBullet)
203 530 : , m_bIsNull(rOther.m_bIsNull)
204 : {
205 530 : }
206 :
207 530 : LwpBulletOverride* LwpBulletOverride::clone() const
208 : {
209 530 : return new LwpBulletOverride(*this);
210 : }
211 :
212 144 : void LwpBulletOverride::Read(LwpObjectStream * pStrm)
213 : {
214 144 : if (pStrm->QuickReadBool())
215 : {
216 90 : m_bIsNull= false;
217 90 : ReadCommon(pStrm);
218 90 : m_SilverBullet.ReadIndexed(pStrm);
219 : }
220 : else
221 54 : m_bIsNull = true;
222 :
223 144 : pStrm->SkipExtra();
224 144 : }
225 0 : void LwpBulletOverride::OverrideSkip(bool bOver)
226 : {
227 0 : if (bOver)
228 : {
229 0 : LwpOverride::Override(BO_SKIP, STATE_ON);
230 : }
231 : else
232 : {
233 0 : LwpOverride::Override(BO_SKIP, STATE_OFF);
234 : }
235 0 : }
236 :
237 0 : void LwpBulletOverride::OverrideRightAligned(bool bOver)
238 : {
239 0 : if(bOver)
240 : {
241 0 : LwpOverride::Override(BO_RIGHTALIGN,STATE_ON);
242 : }
243 : else
244 : {
245 0 : LwpOverride::Override(BO_RIGHTALIGN,STATE_OFF);
246 : }
247 0 : }
248 :
249 8 : void LwpBulletOverride::OverrideSilverBullet(LwpObjectID aID)
250 : {
251 8 : if (!aID.IsNull())
252 : {
253 8 : m_SilverBullet = aID;
254 : }
255 :
256 8 : LwpOverride::Override(BO_SILVERBULLET,STATE_ON);
257 8 : }
258 :
259 8 : void LwpBulletOverride::Override(LwpBulletOverride* pOther)
260 : {
261 8 : if (m_nApply & BO_SILVERBULLET)
262 : {
263 8 : if (IsSilverBulletOverridden())
264 : {
265 8 : pOther->OverrideSilverBullet(m_SilverBullet);
266 : }
267 : else
268 : {
269 0 : pOther->RevertSilverBullet();
270 : }
271 : }
272 :
273 8 : if (m_nApply & BO_SKIP)
274 : {
275 0 : if (IsSkipOverridden())
276 : {
277 0 : pOther->OverrideSkip(IsSkip());
278 : }
279 : else
280 : {
281 0 : pOther->RevertSkip();
282 : }
283 : }
284 :
285 8 : if (m_nApply & BO_RIGHTALIGN)
286 : {
287 0 : if (IsRightAlignedOverridden())
288 : {
289 0 : pOther->OverrideRightAligned(IsRightAligned());
290 : }
291 : else
292 : {
293 0 : pOther->RevertRightAligned();
294 : }
295 : }
296 :
297 8 : }
298 :
299 : /*class LwpAlignmentOverride*/
300 8 : LwpAlignmentOverride::LwpAlignmentOverride(LwpAlignmentOverride const& rOther)
301 : : LwpOverride(rOther)
302 : , m_nAlignType(rOther.m_nAlignType)
303 : , m_nPosition(rOther.m_nPosition)
304 8 : , m_nAlignChar(rOther.m_nAlignChar)
305 : {
306 8 : }
307 :
308 8 : LwpAlignmentOverride* LwpAlignmentOverride::clone() const
309 : {
310 8 : return new LwpAlignmentOverride(*this);
311 : }
312 :
313 34 : void LwpAlignmentOverride::Read(LwpObjectStream * pStrm)
314 : {
315 34 : if (pStrm->QuickReadBool())
316 : {
317 34 : ReadCommon(pStrm);
318 34 : m_nAlignType = static_cast<AlignType>(pStrm->QuickReaduInt8());
319 34 : m_nPosition = pStrm->QuickReaduInt32();
320 34 : m_nAlignChar = pStrm->QuickReaduInt16();
321 : }
322 :
323 34 : pStrm->SkipExtra();
324 34 : }
325 :
326 : /*class LwpSpacingCommonOverride*/
327 896 : LwpSpacingCommonOverride::LwpSpacingCommonOverride(LwpSpacingCommonOverride const& rOther)
328 : : LwpOverride(rOther)
329 : , m_nSpacingType(rOther.m_nSpacingType)
330 : , m_nAmount(rOther.m_nAmount)
331 896 : , m_nMultiple(rOther.m_nMultiple)
332 : {
333 896 : }
334 :
335 896 : LwpSpacingCommonOverride* LwpSpacingCommonOverride::clone() const
336 : {
337 896 : return new LwpSpacingCommonOverride(*this);
338 : }
339 :
340 208 : void LwpSpacingCommonOverride::Read(LwpObjectStream* pStrm)
341 : {
342 208 : if (pStrm->QuickReadBool())
343 : {
344 174 : ReadCommon(pStrm);
345 174 : m_nSpacingType = static_cast<SpacingType>(pStrm->QuickReaduInt16());
346 174 : m_nAmount = pStrm->QuickReadInt32();
347 174 : m_nMultiple = pStrm->QuickReadInt32();
348 : }
349 :
350 208 : pStrm->SkipExtra();
351 208 : }
352 :
353 : /*class LwpSpacingOverride*/
354 52 : LwpSpacingOverride::LwpSpacingOverride() :
355 52 : m_pSpacing(new LwpSpacingCommonOverride),
356 52 : m_pAboveLineSpacing(new LwpSpacingCommonOverride),
357 52 : m_pParaSpacingAbove(new LwpSpacingCommonOverride),
358 208 : m_pParaSpacingBelow(new LwpSpacingCommonOverride)
359 : {
360 52 : }
361 :
362 828 : LwpSpacingOverride::~LwpSpacingOverride()
363 : {
364 276 : if (m_pSpacing)
365 : {
366 276 : delete m_pSpacing;
367 : }
368 276 : if (m_pAboveLineSpacing)
369 : {
370 276 : delete m_pAboveLineSpacing;
371 : }
372 276 : if (m_pParaSpacingAbove)
373 : {
374 276 : delete m_pParaSpacingAbove;
375 : }
376 276 : if (m_pParaSpacingBelow)
377 : {
378 276 : delete m_pParaSpacingBelow;
379 : }
380 552 : }
381 :
382 224 : LwpSpacingOverride::LwpSpacingOverride(LwpSpacingOverride const& rOther)
383 : : LwpOverride(rOther)
384 : , m_pSpacing(0)
385 : , m_pAboveLineSpacing(0)
386 : , m_pParaSpacingAbove(0)
387 224 : , m_pParaSpacingBelow(0)
388 : {
389 224 : std::unique_ptr<LwpSpacingCommonOverride> pSpacing(::clone(rOther.m_pSpacing));
390 448 : std::unique_ptr<LwpSpacingCommonOverride> pAboveLineSpacing(::clone(rOther.m_pAboveLineSpacing));
391 448 : std::unique_ptr<LwpSpacingCommonOverride> pParaSpacingAbove(::clone(rOther.m_pParaSpacingAbove));
392 448 : std::unique_ptr<LwpSpacingCommonOverride> pParaSpacingBelow(::clone(rOther.m_pParaSpacingBelow));
393 224 : m_pSpacing = pSpacing.release();
394 224 : m_pAboveLineSpacing = pAboveLineSpacing.release();
395 224 : m_pParaSpacingAbove = pParaSpacingAbove.release();
396 448 : m_pParaSpacingBelow = pParaSpacingBelow.release();
397 224 : }
398 :
399 224 : LwpSpacingOverride* LwpSpacingOverride::clone() const
400 : {
401 224 : return new LwpSpacingOverride(*this);
402 : }
403 :
404 52 : void LwpSpacingOverride::Read(LwpObjectStream* pStrm)
405 : {
406 52 : if (pStrm->QuickReadBool())
407 : {
408 52 : ReadCommon(pStrm);
409 52 : m_pSpacing->Read(pStrm);
410 52 : if (LwpFileHeader::m_nFileRevision >= 0x000d)
411 : {
412 52 : m_pAboveLineSpacing->Read(pStrm);
413 : }
414 52 : m_pParaSpacingAbove->Read(pStrm);
415 52 : m_pParaSpacingBelow->Read(pStrm);
416 : }
417 :
418 52 : pStrm->SkipExtra();
419 52 : }
420 :
421 : /*class LwpIndentOverride*/
422 894 : LwpIndentOverride::LwpIndentOverride(LwpIndentOverride const& rOther)
423 : : LwpOverride(rOther)
424 : , m_nAll(rOther.m_nAll)
425 : , m_nFirst(rOther.m_nFirst)
426 : , m_nRest(rOther.m_nRest)
427 894 : , m_nRight(rOther.m_nRight)
428 : {
429 894 : }
430 :
431 894 : LwpIndentOverride* LwpIndentOverride::clone() const
432 : {
433 894 : return new LwpIndentOverride(*this);
434 : }
435 :
436 48 : void LwpIndentOverride::Read(LwpObjectStream* pStrm)
437 : {
438 48 : if (pStrm->QuickReadBool())
439 : {
440 48 : ReadCommon(pStrm);
441 :
442 48 : m_nAll = pStrm->QuickReadInt32();
443 48 : m_nFirst = pStrm->QuickReadInt32();
444 48 : m_nRest = pStrm->QuickReadInt32();
445 48 : m_nRight = pStrm->QuickReadInt32();
446 : }
447 :
448 48 : pStrm->SkipExtra();
449 48 : }
450 :
451 : /*class LwpAmikakeOverride*/
452 136 : LwpAmikakeOverride::LwpAmikakeOverride() :
453 136 : m_pBackgroundStuff(new LwpBackgroundStuff), m_nType(AMIKAKE_NONE)
454 : {
455 136 : }
456 :
457 408 : LwpAmikakeOverride::~LwpAmikakeOverride()
458 : {
459 136 : if (m_pBackgroundStuff)
460 : {
461 136 : delete m_pBackgroundStuff;
462 : }
463 272 : }
464 :
465 0 : LwpAmikakeOverride::LwpAmikakeOverride(LwpAmikakeOverride const& rOther)
466 : : LwpOverride(rOther)
467 : , m_pBackgroundStuff(0)
468 0 : , m_nType(rOther.m_nType)
469 : {
470 0 : std::unique_ptr<LwpBackgroundStuff> pBackgroundStuff(::clone(rOther.m_pBackgroundStuff));
471 0 : m_pBackgroundStuff = pBackgroundStuff.release();
472 0 : }
473 :
474 0 : LwpAmikakeOverride* LwpAmikakeOverride::clone() const
475 : {
476 0 : return new LwpAmikakeOverride(*this);
477 : }
478 :
479 0 : void LwpAmikakeOverride::Read(LwpObjectStream* pStrm)
480 : {
481 0 : if (pStrm->QuickReadBool())
482 : {
483 0 : ReadCommon(pStrm);
484 0 : m_pBackgroundStuff->Read(pStrm);
485 : }
486 : else
487 : {
488 0 : Clear();
489 : }
490 :
491 0 : if (pStrm->CheckExtra())
492 : {
493 0 : m_nType = pStrm->QuickReaduInt16();
494 0 : pStrm->SkipExtra();
495 : }
496 : else
497 : {
498 0 : m_nType = AMIKAKE_NONE;
499 : }
500 0 : }
501 :
502 8 : void LwpAlignmentOverride::Override(LwpAlignmentOverride* other)//add by 1-24
503 : {
504 8 : if (m_nOverride & AO_TYPE)
505 : {
506 8 : other->OverrideAlignment(m_nAlignType);
507 : }
508 : /* if (m_nOverride & AO_POSITION)
509 : {
510 : Other->OverridePosition(GetPosition());
511 : }
512 : if (m_nOverride & AO_CHAR)
513 : {
514 : Other->OverrideAlignChar(GetAlignChar());
515 : }
516 : */
517 8 : }
518 :
519 8 : void LwpAlignmentOverride::OverrideAlignment(AlignType val)//add by 1-24
520 : {
521 8 : m_nAlignType = val;
522 8 : m_nOverride |= AO_TYPE;
523 8 : }
524 :
525 202 : void LwpIndentOverride::Override(LwpIndentOverride* other)
526 : {
527 202 : if(m_nOverride & IO_ALL)
528 194 : other->OverrideIndentAll(m_nAll);
529 202 : if(m_nOverride & IO_FIRST)
530 200 : other->OverrideIndentFirst(m_nFirst);
531 202 : if(m_nOverride & IO_RIGHT)
532 192 : other->OverrideIndentRight(m_nRight);
533 202 : if(m_nOverride & IO_REST)
534 200 : other->OverrideIndentRest(m_nRest);
535 202 : if(m_nOverride & IO_USE_RELATIVE)
536 4 : other->OverrideUseRelative(IsUseRelative());
537 202 : if (m_nOverride & IO_REL_FLAGS)
538 0 : other->OverrideRelative(GetRelative());
539 202 : }
540 :
541 0 : sal_uInt16 LwpIndentOverride::GetRelative()
542 : {
543 0 : if ((m_nOverride & IO_REL_FLAGS) == IO_REL_FIRST)
544 0 : return RELATIVE_FIRST;
545 0 : else if ((m_nOverride & IO_REL_FLAGS) == IO_REL_ALL)
546 0 : return RELATIVE_ALL;
547 0 : return RELATIVE_REST;
548 : }
549 :
550 614 : bool LwpIndentOverride::IsUseRelative()
551 : {
552 614 : return (m_nValues & IO_USE_RELATIVE) != 0;
553 : }
554 :
555 194 : void LwpIndentOverride::OverrideIndentAll(sal_Int32 val)
556 : {
557 194 : m_nAll = val;
558 194 : m_nOverride |= IO_ALL;
559 194 : }
560 :
561 200 : void LwpIndentOverride::OverrideIndentFirst(sal_Int32 val)
562 : {
563 200 : m_nFirst = val;
564 200 : m_nOverride |= IO_FIRST;
565 200 : }
566 :
567 192 : void LwpIndentOverride::OverrideIndentRight(sal_Int32 val)
568 : {
569 192 : m_nRight = val;
570 192 : m_nOverride |= IO_RIGHT;
571 192 : }
572 :
573 200 : void LwpIndentOverride::OverrideIndentRest(sal_Int32 val)
574 : {
575 200 : m_nRest = val;
576 : // m_nAll = val;
577 : // m_nFirst = 0-val;
578 200 : m_nOverride |= IO_REST;
579 200 : }
580 :
581 4 : void LwpIndentOverride::OverrideUseRelative(bool use)
582 : {
583 4 : if (use)
584 : {
585 0 : m_nOverride |= IO_USE_RELATIVE;
586 0 : m_nValues |= IO_USE_RELATIVE;
587 : }
588 : else
589 : {
590 4 : m_nOverride &= ~IO_USE_RELATIVE;
591 4 : m_nValues &= ~IO_USE_RELATIVE;
592 : }
593 4 : }
594 :
595 0 : void LwpIndentOverride::OverrideRelative(sal_uInt16 relative)
596 : {
597 : sal_uInt16 Flag;
598 :
599 0 : if (relative == RELATIVE_FIRST)
600 0 : Flag = IO_REL_FIRST;
601 0 : else if (relative == RELATIVE_ALL)
602 0 : Flag = IO_REL_ALL;
603 : else
604 0 : Flag = IO_REL_REST;
605 :
606 0 : m_nOverride &= ~IO_REL_FLAGS;
607 0 : m_nOverride |= Flag;
608 0 : }
609 :
610 224 : void LwpSpacingOverride::Override(LwpSpacingOverride* other)
611 : {
612 224 : if (other)
613 : {
614 224 : m_pSpacing->Override(other->GetSpacing());
615 224 : m_pAboveLineSpacing->Override(other->GetAboveLineSpacing());
616 224 : m_pParaSpacingAbove->Override(other->GetAboveSpacing());
617 224 : m_pParaSpacingBelow->Override(other->GetBelowSpacing());
618 : }
619 224 : }
620 :
621 896 : void LwpSpacingCommonOverride::Override(LwpSpacingCommonOverride* other)
622 : {
623 896 : if (m_nOverride & SPO_TYPE)
624 636 : other->OverrideType(m_nSpacingType);
625 896 : if (m_nOverride & SPO_AMOUNT)
626 636 : other->OverrideAmount(m_nAmount);
627 896 : if (m_nOverride & SPO_MULTIPLE)
628 582 : other->OverrideMultiple(m_nMultiple);
629 896 : }
630 :
631 636 : void LwpSpacingCommonOverride::OverrideType(SpacingType val)
632 : {
633 636 : m_nSpacingType = val;
634 636 : m_nOverride |= SPO_TYPE;
635 636 : }
636 :
637 636 : void LwpSpacingCommonOverride::OverrideAmount(sal_Int32 val)
638 : {
639 636 : m_nAmount = val;
640 636 : m_nOverride |= SPO_AMOUNT;
641 636 : }
642 :
643 582 : void LwpSpacingCommonOverride::OverrideMultiple(sal_Int32 val)
644 : {
645 582 : m_nMultiple = val;
646 582 : m_nOverride |= SPO_MULTIPLE;
647 582 : }
648 :
649 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
