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) != 0;
 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     std::unique_ptr<LwpSpacingCommonOverride> pSpacing(::clone(rOther.m_pSpacing));
 390     std::unique_ptr<LwpSpacingCommonOverride> pAboveLineSpacing(::clone(rOther.m_pAboveLineSpacing));
 391     std::unique_ptr<LwpSpacingCommonOverride> pParaSpacingAbove(::clone(rOther.m_pParaSpacingAbove));
 392     std::unique_ptr<LwpSpacingCommonOverride> pParaSpacingBelow(::clone(rOther.m_pParaSpacingBelow));
 393     m_pSpacing = pSpacing.release();
 394     m_pAboveLineSpacing = pAboveLineSpacing.release();
 395     m_pParaSpacingAbove = pParaSpacingAbove.release();
 396     m_pParaSpacingBelow = pParaSpacingBelow.release();
 397 }
 398
 399 LwpSpacingOverride* LwpSpacingOverride::clone() const
 400 {
 401     return new LwpSpacingOverride(*this);
 402 }
 403
 404 void LwpSpacingOverride::Read(LwpObjectStream* pStrm)
 405 {
 406     if (pStrm->QuickReadBool())
 407     {
 408         ReadCommon(pStrm);
 409         m_pSpacing->Read(pStrm);
 410         if (LwpFileHeader::m_nFileRevision >= 0x000d)
 411         {
 412             m_pAboveLineSpacing->Read(pStrm);
 413         }
 414         m_pParaSpacingAbove->Read(pStrm);
 415         m_pParaSpacingBelow->Read(pStrm);
 416     }
 417
 418     pStrm->SkipExtra();
 419 }
 420
 421 /*class LwpIndentOverride*/
 422 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     , m_nRight(rOther.m_nRight)
 428 {
 429 }
 430
 431 LwpIndentOverride* LwpIndentOverride::clone() const
 432 {
 433     return new LwpIndentOverride(*this);
 434 }
 435
 436 void LwpIndentOverride::Read(LwpObjectStream* pStrm)
 437 {
 438     if (pStrm->QuickReadBool())
 439     {
 440         ReadCommon(pStrm);
 441
 442         m_nAll = pStrm->QuickReadInt32();
 443         m_nFirst = pStrm->QuickReadInt32();
 444         m_nRest = pStrm->QuickReadInt32();
 445         m_nRight = pStrm->QuickReadInt32();
 446     }
 447
 448     pStrm->SkipExtra();
 449 }
 450
 451 /*class LwpAmikakeOverride*/
 452 LwpAmikakeOverride::LwpAmikakeOverride() :
 453 m_pBackgroundStuff(new LwpBackgroundStuff), m_nType(AMIKAKE_NONE)
 454 {
 455 }
 456
 457 LwpAmikakeOverride::~LwpAmikakeOverride()
 458 {
 459     if (m_pBackgroundStuff)
 460     {
 461         delete m_pBackgroundStuff;
 462     }
 463 }
 464
 465 LwpAmikakeOverride::LwpAmikakeOverride(LwpAmikakeOverride const& rOther)
 466     : LwpOverride(rOther)
 467     , m_pBackgroundStuff(0)
 468     , m_nType(rOther.m_nType)
 469 {
 470     std::unique_ptr<LwpBackgroundStuff> pBackgroundStuff(::clone(rOther.m_pBackgroundStuff));
 471     m_pBackgroundStuff = pBackgroundStuff.release();
 472 }
 473
 474 LwpAmikakeOverride* LwpAmikakeOverride::clone() const
 475 {
 476     return new LwpAmikakeOverride(*this);
 477 }
 478
 479 void LwpAmikakeOverride::Read(LwpObjectStream* pStrm)
 480 {
 481     if (pStrm->QuickReadBool())
 482     {
 483         ReadCommon(pStrm);
 484         m_pBackgroundStuff->Read(pStrm);
 485     }
 486     else
 487     {
 488         Clear();
 489     }
 490
 491     if (pStrm->CheckExtra())
 492     {
 493         m_nType = pStrm->QuickReaduInt16();
 494         pStrm->SkipExtra();
 495     }
 496     else
 497     {
 498         m_nType = AMIKAKE_NONE;
 499     }
 500 }
 501
 502 void LwpAlignmentOverride::Override(LwpAlignmentOverride* other)//add by  1-24
 503 {
 504     if (m_nOverride & AO_TYPE)
 505     {
 506         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 }
 518
 519 void LwpAlignmentOverride::OverrideAlignment(AlignType val)//add by  1-24
 520 {
 521     m_nAlignType = val;
 522     m_nOverride |= AO_TYPE;
 523 }
 524
 525 void LwpIndentOverride::Override(LwpIndentOverride* other)
 526 {
 527     if(m_nOverride & IO_ALL)
 528         other->OverrideIndentAll(m_nAll);
 529     if(m_nOverride & IO_FIRST)
 530         other->OverrideIndentFirst(m_nFirst);
 531     if(m_nOverride & IO_RIGHT)
 532         other->OverrideIndentRight(m_nRight);
 533     if(m_nOverride & IO_REST)
 534         other->OverrideIndentRest(m_nRest);
 535     if(m_nOverride & IO_USE_RELATIVE)
 536         other->OverrideUseRelative(IsUseRelative());
 537     if (m_nOverride & IO_REL_FLAGS)
 538         other->OverrideRelative(GetRelative());
 539 }
 540
 541 sal_uInt16 LwpIndentOverride::GetRelative()
 542 {
 543     if ((m_nOverride & IO_REL_FLAGS) == IO_REL_FIRST)
 544         return RELATIVE_FIRST;
 545     else if ((m_nOverride & IO_REL_FLAGS) == IO_REL_ALL)
 546         return RELATIVE_ALL;
 547     return RELATIVE_REST;
 548 }
 549
 550 bool LwpIndentOverride::IsUseRelative()
 551 {
 552     return (m_nValues & IO_USE_RELATIVE) != 0;
 553 }
 554
 555 void LwpIndentOverride::OverrideIndentAll(sal_Int32 val)
 556 {
 557     m_nAll = val;
 558     m_nOverride |= IO_ALL;
 559 }
 560
 561 void LwpIndentOverride::OverrideIndentFirst(sal_Int32 val)
 562 {
 563     m_nFirst = val;
 564     m_nOverride |= IO_FIRST;
 565 }
 566
 567 void LwpIndentOverride::OverrideIndentRight(sal_Int32 val)
 568 {
 569     m_nRight = val;
 570     m_nOverride |= IO_RIGHT;
 571 }
 572
 573 void LwpIndentOverride::OverrideIndentRest(sal_Int32 val)
 574 {
 575     m_nRest = val;
 576 //    m_nAll = val;
 577 //    m_nFirst = 0-val;
 578     m_nOverride |= IO_REST;
 579 }
 580
 581 void LwpIndentOverride::OverrideUseRelative(bool use)
 582 {
 583     if (use)
 584     {
 585         m_nOverride |= IO_USE_RELATIVE;
 586         m_nValues |= IO_USE_RELATIVE;
 587     }
 588     else
 589     {
 590         m_nOverride &= ~IO_USE_RELATIVE;
 591         m_nValues &= ~IO_USE_RELATIVE;
 592     }
 593 }
 594
 595 void LwpIndentOverride::OverrideRelative(sal_uInt16 relative)
 596 {
 597     sal_uInt16 Flag;
 598
 599     if (relative == RELATIVE_FIRST)
 600         Flag = IO_REL_FIRST;
 601     else if (relative == RELATIVE_ALL)
 602         Flag = IO_REL_ALL;
 603     else
 604         Flag = IO_REL_REST;
 605
 606     m_nOverride &= ~IO_REL_FLAGS;
 607     m_nOverride |= Flag;
 608 }
 609
 610 void LwpSpacingOverride::Override(LwpSpacingOverride* other)
 611 {
 612     if (other)
 613     {
 614         m_pSpacing->Override(other->GetSpacing());
 615         m_pAboveLineSpacing->Override(other->GetAboveLineSpacing());
 616         m_pParaSpacingAbove->Override(other->GetAboveSpacing());
 617         m_pParaSpacingBelow->Override(other->GetBelowSpacing());
 618     }
 619 }
 620
 621 void LwpSpacingCommonOverride::Override(LwpSpacingCommonOverride* other)
 622 {
 623     if (m_nOverride & SPO_TYPE)
 624         other->OverrideType(m_nSpacingType);
 625     if (m_nOverride & SPO_AMOUNT)
 626         other->OverrideAmount(m_nAmount);
 627     if (m_nOverride & SPO_MULTIPLE)
 628         other->OverrideMultiple(m_nMultiple);
 629 }
 630
 631 void LwpSpacingCommonOverride::OverrideType(SpacingType val)
 632 {
 633     m_nSpacingType = val;
 634     m_nOverride |= SPO_TYPE;
 635 }
 636
 637 void LwpSpacingCommonOverride::OverrideAmount(sal_Int32 val)
 638 {
 639     m_nAmount = val;
 640     m_nOverride |= SPO_AMOUNT;
 641 }
 642
 643 void LwpSpacingCommonOverride::OverrideMultiple(sal_Int32 val)
 644 {
 645     m_nMultiple = val;
 646     m_nOverride |= SPO_MULTIPLE;
 647 }
 648
 649 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */