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 1765 : LwpOverride::LwpOverride(LwpOverride const& rOther)
77 : : m_nValues(rOther.m_nValues)
78 : , m_nOverride(rOther.m_nOverride)
79 1765 : , m_nApply(rOther.m_nApply)
80 : {
81 1765 : }
82 :
83 608 : void LwpOverride::ReadCommon(LwpObjectStream* pStrm)
84 : {
85 608 : m_nValues = pStrm->QuickReaduInt16();
86 608 : m_nOverride = pStrm->QuickReaduInt16();
87 608 : m_nApply = pStrm->QuickReaduInt16();
88 608 : pStrm->SkipExtra();
89 608 : }
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 219 : void LwpOverride::Override(sal_uInt16 nBits, STATE eState)
99 : {
100 219 : if (eState == STATE_STYLE)
101 : {
102 0 : m_nValues &= ~nBits;
103 0 : m_nOverride &= ~nBits;
104 : }
105 : else
106 : {
107 219 : m_nOverride |= nBits;
108 219 : if (eState == STATE_ON)
109 : {
110 219 : m_nValues |= nBits;
111 : }
112 : else /* State == STATE_OFF */
113 : {
114 0 : m_nValues &= ~nBits;
115 : }
116 : }
117 219 : m_nApply |= nBits;
118 219 : }
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 68 : void LwpTextLanguageOverride::Read(LwpObjectStream* pStrm)
133 : {
134 68 : if (pStrm->QuickReadBool())
135 : {
136 53 : ReadCommon(pStrm);
137 53 : m_nLanguage = pStrm->QuickReaduInt16();
138 : }
139 :
140 68 : pStrm->SkipExtra();
141 :
142 68 : }
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 329 : void LwpTextAttributeOverride::Read(LwpObjectStream* pStrm)
158 : {
159 329 : if (pStrm->QuickReadBool())
160 : {
161 314 : ReadCommon(pStrm);
162 314 : m_nHideLevels = pStrm->QuickReaduInt16();
163 :
164 314 : if (LwpFileHeader::m_nFileRevision > 0x000A)
165 314 : m_nBaseLineOffset = pStrm->QuickReaduInt32();
166 : }
167 :
168 329 : pStrm->SkipExtra();
169 329 : }
170 :
171 261 : sal_Bool LwpTextAttributeOverride::IsHighLight()
172 : {
173 261 : return (m_nValues & TAO_HIGHLIGHT);
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 68 : void LwpKinsokuOptsOverride::Read(LwpObjectStream* pStrm)
189 : {
190 68 : if (pStrm->QuickReadBool())
191 : {
192 4 : ReadCommon(pStrm);
193 4 : m_nLevels = pStrm->QuickReaduInt16();
194 : }
195 :
196 68 : pStrm->SkipExtra();
197 68 : }
198 :
199 : /*class LwpBulletOverride*/
200 268 : LwpBulletOverride::LwpBulletOverride(LwpBulletOverride const& rOther)
201 : : LwpOverride(rOther)
202 : , m_SilverBullet(rOther.m_SilverBullet)
203 268 : , m_bIsNull(rOther.m_bIsNull)
204 : {
205 268 : }
206 :
207 268 : LwpBulletOverride* LwpBulletOverride::clone() const
208 : {
209 268 : return new LwpBulletOverride(*this);
210 : }
211 :
212 72 : void LwpBulletOverride::Read(LwpObjectStream * pStrm)
213 : {
214 72 : if (pStrm->QuickReadBool())
215 : {
216 45 : m_bIsNull= sal_False;
217 45 : ReadCommon(pStrm);
218 45 : m_SilverBullet.ReadIndexed(pStrm);
219 : }
220 : else
221 27 : m_bIsNull = sal_True;
222 :
223 72 : pStrm->SkipExtra();
224 72 : }
225 0 : void LwpBulletOverride::OverrideSkip(sal_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(sal_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 4 : void LwpBulletOverride::OverrideSilverBullet(LwpObjectID aID)
250 : {
251 4 : if (!aID.IsNull())
252 : {
253 4 : m_SilverBullet = aID;
254 : }
255 :
256 4 : LwpOverride::Override(BO_SILVERBULLET,STATE_ON);
257 4 : }
258 :
259 4 : void LwpBulletOverride::Override(LwpBulletOverride* pOther)
260 : {
261 4 : if (m_nApply & BO_SILVERBULLET)
262 : {
263 4 : if (IsSilverBulletOverridden())
264 : {
265 4 : pOther->OverrideSilverBullet(m_SilverBullet);
266 : }
267 : else
268 : {
269 0 : pOther->RevertSilverBullet();
270 : }
271 : }
272 :
273 4 : 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 4 : 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 4 : }
298 :
299 : /*class LwpAlignmentOverride*/
300 4 : LwpAlignmentOverride::LwpAlignmentOverride(LwpAlignmentOverride const& rOther)
301 : : LwpOverride(rOther)
302 : , m_nAlignType(rOther.m_nAlignType)
303 : , m_nPosition(rOther.m_nPosition)
304 4 : , m_nAlignChar(rOther.m_nAlignChar)
305 : {
306 4 : }
307 :
308 4 : LwpAlignmentOverride* LwpAlignmentOverride::clone() const
309 : {
310 4 : return new LwpAlignmentOverride(*this);
311 : }
312 :
313 17 : void LwpAlignmentOverride::Read(LwpObjectStream * pStrm)
314 : {
315 17 : if (pStrm->QuickReadBool())
316 : {
317 17 : ReadCommon(pStrm);
318 17 : m_nAlignType = static_cast<AlignType>(pStrm->QuickReaduInt8());
319 17 : m_nPosition = pStrm->QuickReaduInt32();
320 17 : m_nAlignChar = pStrm->QuickReaduInt16();
321 : }
322 :
323 17 : pStrm->SkipExtra();
324 17 : }
325 :
326 : /*class LwpSpacingCommonOverride*/
327 448 : LwpSpacingCommonOverride::LwpSpacingCommonOverride(LwpSpacingCommonOverride const& rOther)
328 : : LwpOverride(rOther)
329 : , m_nSpacingType(rOther.m_nSpacingType)
330 : , m_nAmount(rOther.m_nAmount)
331 448 : , m_nMultiple(rOther.m_nMultiple)
332 : {
333 448 : }
334 :
335 448 : LwpSpacingCommonOverride* LwpSpacingCommonOverride::clone() const
336 : {
337 448 : return new LwpSpacingCommonOverride(*this);
338 : }
339 :
340 104 : void LwpSpacingCommonOverride::Read(LwpObjectStream* pStrm)
341 : {
342 104 : if (pStrm->QuickReadBool())
343 : {
344 87 : ReadCommon(pStrm);
345 87 : m_nSpacingType = static_cast<SpacingType>(pStrm->QuickReaduInt16());
346 87 : m_nAmount = pStrm->QuickReadInt32();
347 87 : m_nMultiple = pStrm->QuickReadInt32();
348 : }
349 :
350 104 : pStrm->SkipExtra();
351 104 : }
352 :
353 : /*class LwpSpacingOverride*/
354 26 : LwpSpacingOverride::LwpSpacingOverride() :
355 26 : m_pSpacing(new LwpSpacingCommonOverride),
356 26 : m_pAboveLineSpacing(new LwpSpacingCommonOverride),
357 26 : m_pParaSpacingAbove(new LwpSpacingCommonOverride),
358 104 : m_pParaSpacingBelow(new LwpSpacingCommonOverride)
359 : {
360 26 : }
361 :
362 414 : LwpSpacingOverride::~LwpSpacingOverride()
363 : {
364 138 : if (m_pSpacing)
365 : {
366 138 : delete m_pSpacing;
367 : }
368 138 : if (m_pAboveLineSpacing)
369 : {
370 138 : delete m_pAboveLineSpacing;
371 : }
372 138 : if (m_pParaSpacingAbove)
373 : {
374 138 : delete m_pParaSpacingAbove;
375 : }
376 138 : if (m_pParaSpacingBelow)
377 : {
378 138 : delete m_pParaSpacingBelow;
379 : }
380 276 : }
381 :
382 112 : LwpSpacingOverride::LwpSpacingOverride(LwpSpacingOverride const& rOther)
383 : : LwpOverride(rOther)
384 : , m_pSpacing(0)
385 : , m_pAboveLineSpacing(0)
386 : , m_pParaSpacingAbove(0)
387 112 : , m_pParaSpacingBelow(0)
388 : {
389 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
390 112 : std::auto_ptr<LwpSpacingCommonOverride> pSpacing(::clone(rOther.m_pSpacing));
391 112 : std::auto_ptr<LwpSpacingCommonOverride> pAboveLineSpacing(::clone(rOther.m_pAboveLineSpacing));
392 112 : std::auto_ptr<LwpSpacingCommonOverride> pParaSpacingAbove(::clone(rOther.m_pParaSpacingAbove));
393 112 : std::auto_ptr<LwpSpacingCommonOverride> pParaSpacingBelow(::clone(rOther.m_pParaSpacingBelow));
394 : SAL_WNODEPRECATED_DECLARATIONS_POP
395 112 : m_pSpacing = pSpacing.release();
396 112 : m_pAboveLineSpacing = pAboveLineSpacing.release();
397 112 : m_pParaSpacingAbove = pParaSpacingAbove.release();
398 112 : m_pParaSpacingBelow = pParaSpacingBelow.release();
399 112 : }
400 :
401 112 : LwpSpacingOverride* LwpSpacingOverride::clone() const
402 : {
403 112 : return new LwpSpacingOverride(*this);
404 : }
405 :
406 26 : void LwpSpacingOverride::Read(LwpObjectStream* pStrm)
407 : {
408 26 : if (pStrm->QuickReadBool())
409 : {
410 26 : ReadCommon(pStrm);
411 26 : m_pSpacing->Read(pStrm);
412 26 : if (LwpFileHeader::m_nFileRevision >= 0x000d)
413 : {
414 26 : m_pAboveLineSpacing->Read(pStrm);
415 : }
416 26 : m_pParaSpacingAbove->Read(pStrm);
417 26 : m_pParaSpacingBelow->Read(pStrm);
418 : }
419 :
420 26 : pStrm->SkipExtra();
421 26 : }
422 :
423 : /*class LwpIndentOverride*/
424 450 : LwpIndentOverride::LwpIndentOverride(LwpIndentOverride const& rOther)
425 : : LwpOverride(rOther)
426 : , m_nAll(rOther.m_nAll)
427 : , m_nFirst(rOther.m_nFirst)
428 : , m_nRest(rOther.m_nRest)
429 450 : , m_nRight(rOther.m_nRight)
430 : {
431 450 : }
432 :
433 450 : LwpIndentOverride* LwpIndentOverride::clone() const
434 : {
435 450 : return new LwpIndentOverride(*this);
436 : }
437 :
438 24 : void LwpIndentOverride::Read(LwpObjectStream* pStrm)
439 : {
440 24 : if (pStrm->QuickReadBool())
441 : {
442 24 : ReadCommon(pStrm);
443 :
444 24 : m_nAll = pStrm->QuickReadInt32();
445 24 : m_nFirst = pStrm->QuickReadInt32();
446 24 : m_nRest = pStrm->QuickReadInt32();
447 24 : m_nRight = pStrm->QuickReadInt32();
448 : }
449 :
450 24 : pStrm->SkipExtra();
451 24 : }
452 :
453 :
454 : /*class LwpAmikakeOverride*/
455 68 : LwpAmikakeOverride::LwpAmikakeOverride() :
456 68 : m_pBackgroundStuff(new LwpBackgroundStuff), m_nType(AMIKAKE_NONE)
457 : {
458 68 : }
459 :
460 204 : LwpAmikakeOverride::~LwpAmikakeOverride()
461 : {
462 68 : if (m_pBackgroundStuff)
463 : {
464 68 : delete m_pBackgroundStuff;
465 : }
466 136 : }
467 :
468 0 : LwpAmikakeOverride::LwpAmikakeOverride(LwpAmikakeOverride const& rOther)
469 : : LwpOverride(rOther)
470 : , m_pBackgroundStuff(0)
471 0 : , m_nType(rOther.m_nType)
472 : {
473 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
474 0 : std::auto_ptr<LwpBackgroundStuff> pBackgroundStuff(::clone(rOther.m_pBackgroundStuff));
475 : SAL_WNODEPRECATED_DECLARATIONS_POP
476 0 : m_pBackgroundStuff = pBackgroundStuff.release();
477 0 : }
478 :
479 0 : LwpAmikakeOverride* LwpAmikakeOverride::clone() const
480 : {
481 0 : return new LwpAmikakeOverride(*this);
482 : }
483 :
484 0 : void LwpAmikakeOverride::Read(LwpObjectStream* pStrm)
485 : {
486 0 : if (pStrm->QuickReadBool())
487 : {
488 0 : ReadCommon(pStrm);
489 0 : m_pBackgroundStuff->Read(pStrm);
490 : }
491 : else
492 : {
493 0 : Clear();
494 : }
495 :
496 0 : if (pStrm->CheckExtra())
497 : {
498 0 : m_nType = pStrm->QuickReaduInt16();
499 0 : pStrm->SkipExtra();
500 : }
501 : else
502 : {
503 0 : m_nType = AMIKAKE_NONE;
504 : }
505 0 : }
506 :
507 4 : void LwpAlignmentOverride::Override(LwpAlignmentOverride* other)//add by 1-24
508 : {
509 4 : if (m_nOverride & AO_TYPE)
510 : {
511 4 : other->OverrideAlignment(m_nAlignType);
512 : }
513 : /* if (m_nOverride & AO_POSITION)
514 : {
515 : Other->OverridePosition(GetPosition());
516 : }
517 : if (m_nOverride & AO_CHAR)
518 : {
519 : Other->OverrideAlignChar(GetAlignChar());
520 : }
521 : */
522 4 : }
523 :
524 4 : void LwpAlignmentOverride::OverrideAlignment(AlignType val)//add by 1-24
525 : {
526 4 : m_nAlignType = val;
527 4 : m_nOverride |= AO_TYPE;
528 4 : }
529 :
530 101 : void LwpIndentOverride::Override(LwpIndentOverride* other)
531 : {
532 101 : if(m_nOverride & IO_ALL)
533 97 : other->OverrideIndentAll(m_nAll);
534 101 : if(m_nOverride & IO_FIRST)
535 100 : other->OverrideIndentFirst(m_nFirst);
536 101 : if(m_nOverride & IO_RIGHT)
537 96 : other->OverrideIndentRight(m_nRight);
538 101 : if(m_nOverride & IO_REST)
539 100 : other->OverrideIndentRest(m_nRest);
540 101 : if(m_nOverride & IO_USE_RELATIVE)
541 2 : other->OverrideUseRelative(IsUseRelative());
542 101 : if (m_nOverride & IO_REL_FLAGS)
543 0 : other->OverrideRelative(GetRelative());
544 101 : }
545 :
546 0 : sal_uInt16 LwpIndentOverride::GetRelative()
547 : {
548 0 : if ((m_nOverride & IO_REL_FLAGS) == IO_REL_FIRST)
549 0 : return RELATIVE_FIRST;
550 0 : else if ((m_nOverride & IO_REL_FLAGS) == IO_REL_ALL)
551 0 : return RELATIVE_ALL;
552 0 : return RELATIVE_REST;
553 : }
554 :
555 310 : sal_Bool LwpIndentOverride::IsUseRelative()
556 : {
557 310 : return (m_nValues & IO_USE_RELATIVE) != 0;
558 : }
559 :
560 97 : void LwpIndentOverride::OverrideIndentAll(sal_Int32 val)
561 : {
562 97 : m_nAll = val;
563 97 : m_nOverride |= IO_ALL;
564 97 : }
565 :
566 100 : void LwpIndentOverride::OverrideIndentFirst(sal_Int32 val)
567 : {
568 100 : m_nFirst = val;
569 100 : m_nOverride |= IO_FIRST;
570 100 : }
571 :
572 96 : void LwpIndentOverride::OverrideIndentRight(sal_Int32 val)
573 : {
574 96 : m_nRight = val;
575 96 : m_nOverride |= IO_RIGHT;
576 96 : }
577 :
578 100 : void LwpIndentOverride::OverrideIndentRest(sal_Int32 val)
579 : {
580 100 : m_nRest = val;
581 : // m_nAll = val;
582 : // m_nFirst = 0-val;
583 100 : m_nOverride |= IO_REST;
584 100 : }
585 :
586 2 : void LwpIndentOverride::OverrideUseRelative(sal_Bool use)
587 : {
588 2 : if (use)
589 : {
590 0 : m_nOverride |= IO_USE_RELATIVE;
591 0 : m_nValues |= IO_USE_RELATIVE;
592 : }
593 : else
594 : {
595 2 : m_nOverride &= ~IO_USE_RELATIVE;
596 2 : m_nValues &= ~IO_USE_RELATIVE;
597 : }
598 2 : }
599 :
600 0 : void LwpIndentOverride::OverrideRelative(sal_uInt16 relative)
601 : {
602 : sal_uInt16 Flag;
603 :
604 0 : if (relative == RELATIVE_FIRST)
605 0 : Flag = IO_REL_FIRST;
606 0 : else if (relative == RELATIVE_ALL)
607 0 : Flag = IO_REL_ALL;
608 : else
609 0 : Flag = IO_REL_REST;
610 :
611 0 : m_nOverride &= ~IO_REL_FLAGS;
612 0 : m_nOverride |= Flag;
613 0 : }
614 :
615 112 : void LwpSpacingOverride::Override(LwpSpacingOverride* other)
616 : {
617 112 : if (other)
618 : {
619 112 : m_pSpacing->Override(other->GetSpacing());
620 112 : m_pAboveLineSpacing->Override(other->GetAboveLineSpacing());
621 112 : m_pParaSpacingAbove->Override(other->GetAboveSpacing());
622 112 : m_pParaSpacingBelow->Override(other->GetBelowSpacing());
623 : }
624 112 : }
625 :
626 448 : void LwpSpacingCommonOverride::Override(LwpSpacingCommonOverride* other)
627 : {
628 448 : if (m_nOverride & SPO_TYPE)
629 318 : other->OverrideType(m_nSpacingType);
630 448 : if (m_nOverride & SPO_AMOUNT)
631 318 : other->OverrideAmount(m_nAmount);
632 448 : if (m_nOverride & SPO_MULTIPLE)
633 291 : other->OverrideMultiple(m_nMultiple);
634 448 : }
635 :
636 318 : void LwpSpacingCommonOverride::OverrideType(SpacingType val)
637 : {
638 318 : m_nSpacingType = val;
639 318 : m_nOverride |= SPO_TYPE;
640 318 : }
641 :
642 318 : void LwpSpacingCommonOverride::OverrideAmount(sal_Int32 val)
643 : {
644 318 : m_nAmount = val;
645 318 : m_nOverride |= SPO_AMOUNT;
646 318 : }
647 :
648 291 : void LwpSpacingCommonOverride::OverrideMultiple(sal_Int32 val)
649 : {
650 291 : m_nMultiple = val;
651 291 : m_nOverride |= SPO_MULTIPLE;
652 291 : }
653 :
654 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
