lotuswordpro/source/filter/lwpoverride.cxx

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