lotuswordpro/source/filter/lwpoverride.cxx

   1 /*************************************************************************
   2  *
   3  *  The Contents of this file are made available subject to the terms of
   4  *  either of the following licenses
   5  *
   6  *         - GNU Lesser General Public License Version 2.1
   7  *         - Sun Industry Standards Source License Version 1.1
   8  *
   9  *  Sun Microsystems Inc., October, 2000
  10  *
  11  *  GNU Lesser General Public License Version 2.1
  12  *  =============================================
  13  *  Copyright 2000 by Sun Microsystems, Inc.
  14  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  15  *
  16  *  This library is free software; you can redistribute it and/or
  17  *  modify it under the terms of the GNU Lesser General Public
  18  *  License version 2.1, as published by the Free Software Foundation.
  19  *
  20  *  This library is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  *  Lesser General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU Lesser General Public
  26  *  License along with this library; if not, write to the Free Software
  27  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *  MA  02111-1307  USA
  29  *
  30  *
  31  *  Sun Industry Standards Source License Version 1.1
  32  *  =================================================
  33  *  The contents of this file are subject to the Sun Industry Standards
  34  *  Source License Version 1.1 (the "License"); You may not use this file
  35  *  except in compliance with the License. You may obtain a copy of the
  36  *  License at http://www.openoffice.org/license.html.
  37  *
  38  *  Software provided under this License is provided on an "AS IS" basis,
  39  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  40  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  41  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  42  *  See the License for the specific provisions governing your rights and
  43  *  obligations concerning the Software.
  44  *
  45  *  The Initial Developer of the Original Code is: IBM Corporation
  46  *
  47  *  Copyright: 2008 by IBM Corporation
  48  *
  49  *  All Rights Reserved.
  50  *
  51  *  Contributor(s): _______________________________________
  52  *
  53  *
  54  ************************************************************************/
  55 /*************************************************************************
  56  * @file
  57  *  For LWP filter architecture prototype
  58  ************************************************************************/
  59 /*************************************************************************
  60  * Change History
  61  Jan 2005                       Created
  62  ************************************************************************/
  63
  64 #include "lwpoverride.hxx"
  65 #include "lwpfilehdr.hxx"
  66 #include "lwpatomholder.hxx"
  67 #include "lwpborderstuff.hxx"
  68 #include "lwpmargins.hxx"
  69 #include "lwpbackgroundstuff.hxx"
  70
  71 /*class LwpOverride*/
  72 void LwpOverride::ReadCommon(LwpObjectStream* pStrm)
  73 {
  74         pStrm->QuickRead(&m_nValues, 2);
  75         pStrm->QuickRead(&m_nOverride, 2);
  76         pStrm->QuickRead(&m_nApply, 2);
  77         pStrm->SkipExtra();
  78 }
  79
  80 void LwpOverride::Clear()
  81 {
  82         m_nValues = 0;
  83         m_nOverride = 0;
  84         m_nApply = 0;
  85 }
  86
  87 void LwpOverride::operator=(const LwpOverride& rOther)
  88 {
  89         m_nValues = rOther.m_nValues;
  90         m_nOverride = rOther.m_nOverride;
  91         m_nApply = rOther.m_nApply;
  92 }
  93
  94 void LwpOverride::Override(sal_uInt16 nBits, STATE eState)
  95 {
  96         if (eState == STATE_STYLE)
  97         {
  98                 m_nValues &= ~nBits;
  99                 m_nOverride &= ~nBits;
 100         }
 101         else
 102         {
 103                 m_nOverride |= nBits;
 104                 if (eState == STATE_ON)
 105                 {
 106                         m_nValues |= nBits;
 107                 }
 108                 else    /* State == STATE_OFF */
 109                 {
 110                         m_nValues &= ~nBits;
 111                 }
 112         }
 113         m_nApply |= nBits;
 114 }
 115
 116 /*class LwpTextLanguageOverride*/
 117 void LwpTextLanguageOverride::Read(LwpObjectStream* pStrm)
 118 {
 119         if (pStrm->QuickReadBool())
 120         {
 121                 ReadCommon(pStrm);
 122                 pStrm->QuickRead(&m_nLanguage, 2);
 123         }
 124
 125         pStrm->SkipExtra();
 126
 127 }
 128
 129 /*class LwpTextAttributeOverride*/
 130 void LwpTextAttributeOverride::Read(LwpObjectStream* pStrm)
 131 {
 132         if (pStrm->QuickReadBool())
 133         {
 134                 ReadCommon(pStrm);
 135                 pStrm->QuickRead(&m_nHideLevels, 2);
 136
 137                 if (LwpFileHeader::m_nFileRevision > 0x000A)
 138                 {
 139                         pStrm->QuickRead(&m_nBaseLineOffset, 4);
 140                 }
 141         }
 142
 143         pStrm->SkipExtra();
 144 }
 145
 146 sal_Bool LwpTextAttributeOverride::IsHighLight()
 147 {
 148         return (m_nValues & TAO_HIGHLIGHT);
 149 }
 150
 151 /*class LwpKinsokuOptsOverride*/
 152 void LwpKinsokuOptsOverride::Read(LwpObjectStream* pStrm)
 153 {
 154         if (pStrm->QuickReadBool())
 155         {
 156                 ReadCommon(pStrm);
 157                 pStrm->QuickRead(&m_nLevels, 2);
 158         }
 159
 160         pStrm->SkipExtra();
 161 }
 162
 163 /*class LwpBulletOverride*/
 164 void LwpBulletOverride::Read(LwpObjectStream * pStrm)
 165 {
 166         if (pStrm->QuickReadBool())
 167         {
 168                 m_bIsNull= sal_False;
 169                 ReadCommon(pStrm);
 170                 m_SilverBullet.ReadIndexed(pStrm);
 171         }
 172         else
 173                 m_bIsNull = sal_True;
 174
 175         pStrm->SkipExtra();
 176 }
 177 void LwpBulletOverride::OverrideSkip(sal_Bool bOver)
 178 {
 179         if (bOver)
 180         {
 181                 LwpOverride::Override(BO_SKIP, STATE_ON);
 182         }
 183         else
 184         {
 185                 LwpOverride::Override(BO_SKIP, STATE_OFF);
 186         }
 187 }
 188
 189 void LwpBulletOverride::OverrideRightAligned(sal_Bool bOver)
 190 {
 191         if(bOver)
 192         {
 193                 LwpOverride::Override(BO_RIGHTALIGN,STATE_ON);
 194         }
 195         else
 196         {
 197                 LwpOverride::Override(BO_RIGHTALIGN,STATE_OFF);
 198         }
 199 }
 200
 201 void LwpBulletOverride::operator=(const LwpOverride& rOther)
 202 {
 203         LwpOverride::operator=(rOther);
 204         const LwpBulletOverride* pBullet = static_cast<LwpBulletOverride*>((LwpOverride*)&rOther);
 205
 206         m_SilverBullet = pBullet->m_SilverBullet;
 207
 208 }
 209
 210 void LwpBulletOverride::OverrideSilverBullet(LwpObjectID aID)
 211 {
 212         if (!aID.IsNull())
 213         {
 214                 m_SilverBullet = aID;
 215         }
 216
 217         LwpOverride::Override(BO_SILVERBULLET,STATE_ON);
 218 }
 219
 220 void LwpBulletOverride::Override(LwpBulletOverride* pOther)
 221 {
 222         if (m_nApply & BO_SILVERBULLET)
 223         {
 224                 if (IsSilverBulletOverridden())
 225                 {
 226                         pOther->OverrideSilverBullet(m_SilverBullet);
 227                 }
 228                 else
 229                 {
 230                         pOther->RevertSilverBullet();
 231                 }
 232         }
 233
 234         if (m_nApply & BO_SKIP)
 235         {
 236                 if (IsSkipOverridden())
 237                 {
 238                         pOther->OverrideSkip(IsSkip());
 239                 }
 240                 else
 241                 {
 242                         pOther->RevertSkip();
 243                 }
 244         }
 245
 246         if (m_nApply & BO_RIGHTALIGN)
 247         {
 248                 if (IsRightAlignedOverridden())
 249                 {
 250                         pOther->OverrideRightAligned(IsRightAligned());
 251                 }
 252                 else
 253                 {
 254                         pOther->RevertRightAligned();
 255                 }
 256         }
 257
 258 }
 259
 260 /*class LwpAlignmentOverride*/
 261 void LwpAlignmentOverride::Read(LwpObjectStream * pStrm)
 262 {
 263         if (pStrm->QuickReadBool())
 264         {
 265                 ReadCommon(pStrm);
 266                 pStrm->QuickRead(&m_nAlignType, 1);
 267                 pStrm->QuickRead(&m_nPosition, 4);
 268                 pStrm->QuickRead(&m_nAlignChar, 2);
 269         }
 270
 271         pStrm->SkipExtra();
 272 }
 273
 274 /*class LwpSpacingCommonOverride*/
 275 void LwpSpacingCommonOverride::Read(LwpObjectStream* pStrm)
 276 {
 277         if (pStrm->QuickReadBool())
 278         {
 279                 ReadCommon(pStrm);
 280                 pStrm->QuickRead(&m_nSpacingType, 2);
 281                 pStrm->QuickRead(&m_nAmount, 4);
 282                 pStrm->QuickRead(&m_nMultiple, 4);
 283         }
 284
 285         pStrm->SkipExtra();
 286 }
 287
 288 /*class LwpSpacingOverride*/
 289 LwpSpacingOverride::LwpSpacingOverride() :
 290 m_pSpacing(new LwpSpacingCommonOverride),
 291 m_pAboveLineSpacing(new LwpSpacingCommonOverride),
 292 m_pParaSpacingAbove(new LwpSpacingCommonOverride),
 293 m_pParaSpacingBelow(new LwpSpacingCommonOverride)
 294 {
 295 }
 296
 297 LwpSpacingOverride& LwpSpacingOverride::operator=(LwpSpacingOverride& other)
 298 {
 299     LwpOverride::operator=(other);
 300     *m_pSpacing = *other.m_pSpacing;
 301     *m_pAboveLineSpacing = *other.m_pAboveLineSpacing;
 302     *m_pParaSpacingAbove = *other.m_pParaSpacingAbove;
 303     *m_pParaSpacingAbove = *other.m_pParaSpacingAbove;
 304     return *this;
 305 }
 306
 307 LwpSpacingOverride::~LwpSpacingOverride()
 308 {
 309         if (m_pSpacing)
 310         {
 311                 delete m_pSpacing;
 312         }
 313         if (m_pAboveLineSpacing)
 314         {
 315                 delete m_pAboveLineSpacing;
 316         }
 317         if (m_pParaSpacingAbove)
 318         {
 319                 delete m_pParaSpacingAbove;
 320         }
 321         if (m_pParaSpacingBelow)
 322         {
 323                 delete m_pParaSpacingBelow;
 324         }
 325 }
 326
 327 void LwpSpacingOverride::Read(LwpObjectStream* pStrm)
 328 {
 329         if (pStrm->QuickReadBool())
 330         {
 331                 ReadCommon(pStrm);
 332                 m_pSpacing->Read(pStrm);
 333                 if (LwpFileHeader::m_nFileRevision >= 0x000d)
 334                 {
 335                         m_pAboveLineSpacing->Read(pStrm);
 336                 }
 337                 m_pParaSpacingAbove->Read(pStrm);
 338                 m_pParaSpacingBelow->Read(pStrm);
 339         }
 340
 341         pStrm->SkipExtra();
 342 }
 343
 344 /*class LwpIndentOverride*/
 345 void LwpIndentOverride::Read(LwpObjectStream* pStrm)
 346 {
 347         if (pStrm->QuickReadBool())
 348         {
 349                 ReadCommon(pStrm);
 350
 351                 pStrm->QuickRead(&m_nAll, 4);
 352                 pStrm->QuickRead(&m_nFirst, 4);
 353                 pStrm->QuickRead(&m_nRest, 4);
 354                 pStrm->QuickRead(&m_nRight, 4);
 355         }
 356
 357         pStrm->SkipExtra();
 358 }
 359
 360
 361 /*class LwpAmikakeOverride*/
 362 LwpAmikakeOverride::LwpAmikakeOverride() :
 363 m_pBackgroundStuff(new LwpBackgroundStuff), m_nType(AMIKAKE_NONE)
 364 {
 365 }
 366
 367 LwpAmikakeOverride::~LwpAmikakeOverride()
 368 {
 369         if (m_pBackgroundStuff)
 370         {
 371                 delete m_pBackgroundStuff;
 372         }
 373 }
 374
 375 void LwpAmikakeOverride::Read(LwpObjectStream* pStrm)
 376 {
 377         if (pStrm->QuickReadBool())
 378         {
 379                 ReadCommon(pStrm);
 380                 m_pBackgroundStuff->Read(pStrm);
 381         }
 382         else
 383         {
 384                 Clear();
 385         }
 386
 387         if (pStrm->CheckExtra())
 388         {
 389                 pStrm->QuickRead(&m_nType, 2);
 390                 pStrm->SkipExtra();
 391         }
 392         else
 393         {
 394                 m_nType = AMIKAKE_NONE;
 395         }
 396 }
 397
 398 void LwpAlignmentOverride::Override(LwpAlignmentOverride* other)//add by  1-24
 399 {
 400         if (m_nOverride & AO_TYPE)
 401         {
 402             other->OverrideAlignment(m_nAlignType);
 403         }
 404 /*      if (m_nOverride & AO_POSITION)
 405         {
 406                 Other->OverridePosition(GetPosition());
 407         }
 408         if (m_nOverride & AO_CHAR)
 409         {
 410                 Other->OverrideAlignChar(GetAlignChar());
 411         }
 412 */
 413 }
 414
 415 void LwpAlignmentOverride::OverrideAlignment(AlignType val)//add by  1-24
 416 {
 417     m_nAlignType = val;
 418         m_nOverride |= AO_TYPE;
 419 }
 420
 421 LwpIndentOverride& LwpIndentOverride::operator=(LwpIndentOverride& other)
 422 {
 423         LwpOverride::operator=(other);
 424     m_nAll   = other.m_nAll;
 425         m_nFirst = other.m_nFirst;
 426         m_nRest  = other.m_nRest;
 427         m_nRight = other.m_nRight;
 428         return *this;
 429 }
 430
 431 void LwpIndentOverride::Override(LwpIndentOverride* other)
 432 {
 433     if(m_nOverride & IO_ALL)
 434         other->OverrideIndentAll(m_nAll);
 435     if(m_nOverride & IO_FIRST)
 436         other->OverrideIndentFirst(m_nFirst);
 437     if(m_nOverride & IO_RIGHT)
 438         other->OverrideIndentRight(m_nRight);
 439     if(m_nOverride & IO_REST)
 440         other->OverrideIndentRest(m_nRest);
 441         if(m_nOverride & IO_USE_RELATIVE)
 442                 other->OverrideUseRelative(IsUseRelative());
 443         if (m_nOverride & IO_REL_FLAGS)
 444                 other->OverrideRelative(GetRelative());
 445 }
 446
 447 sal_uInt16 LwpIndentOverride::GetRelative()
 448 {
 449         if ((m_nOverride & IO_REL_FLAGS) == IO_REL_FIRST)
 450                 return RELATIVE_FIRST;
 451         else if ((m_nOverride & IO_REL_FLAGS) == IO_REL_ALL)
 452                 return RELATIVE_ALL;
 453         return RELATIVE_REST;
 454 }
 455
 456 sal_Bool LwpIndentOverride::IsUseRelative()
 457 {
 458         return (m_nValues & IO_USE_RELATIVE) != 0;
 459 }
 460
 461 void LwpIndentOverride::OverrideIndentAll(sal_Int32 val)
 462 {
 463     m_nAll = val;
 464         m_nOverride |= IO_ALL;
 465 }
 466
 467 void LwpIndentOverride::OverrideIndentFirst(sal_Int32 val)
 468 {
 469     m_nFirst = val;
 470         m_nOverride |= IO_FIRST;
 471 }
 472
 473 void LwpIndentOverride::OverrideIndentRight(sal_Int32 val)
 474 {
 475     m_nRight = val;
 476         m_nOverride |= IO_RIGHT;
 477 }
 478
 479 void LwpIndentOverride::OverrideIndentRest(sal_Int32 val)
 480 {
 481     m_nRest = val;
 482 //    m_nAll = val;
 483 //    m_nFirst = 0-val;
 484         m_nOverride |= IO_REST;
 485 }
 486
 487 void LwpIndentOverride::OverrideUseRelative(sal_Bool use)
 488 {
 489         if (use)
 490         {
 491                 m_nOverride |= IO_USE_RELATIVE;
 492                 m_nValues |= IO_USE_RELATIVE;
 493         }
 494         else
 495         {
 496                 m_nOverride &= ~IO_USE_RELATIVE;
 497                 m_nValues &= ~IO_USE_RELATIVE;
 498         }
 499 }
 500
 501 void LwpIndentOverride::OverrideRelative(sal_uInt16 relative)
 502 {
 503         sal_uInt16 Flag;
 504
 505         if (relative == RELATIVE_FIRST)
 506                 Flag = IO_REL_FIRST;
 507         else if (relative == RELATIVE_ALL)
 508                 Flag = IO_REL_ALL;
 509         else
 510                 Flag = IO_REL_REST;
 511
 512         m_nOverride &= ~IO_REL_FLAGS;
 513         m_nOverride |= Flag;
 514 }
 515
 516 void LwpSpacingOverride::Override(LwpSpacingOverride* other)
 517 {
 518 //    if (IsAlwaysOverridden())
 519 //              other->SetAlways(IsAlways());//To be done
 520         if (other)
 521         {
 522                 m_pSpacing->Override(other->GetSpacing());
 523                 m_pAboveLineSpacing->Override(other->GetAboveLineSpacing());
 524                 m_pParaSpacingAbove->Override(other->GetAboveSpacing());
 525                 m_pParaSpacingBelow->Override(other->GetBelowSpacing());
 526         }
 527 }
 528
 529 void LwpSpacingCommonOverride::Override(LwpSpacingCommonOverride* other)
 530 {
 531     if (m_nOverride & SPO_TYPE)
 532         other->OverrideType(m_nSpacingType);
 533     if (m_nOverride & SPO_AMOUNT)
 534         other->OverrideAmount(m_nAmount);
 535     if (m_nOverride & SPO_MULTIPLE)
 536         other->OverrideMultiple(m_nMultiple);
 537 }
 538
 539 void LwpSpacingCommonOverride::OverrideType(SpacingType val)
 540 {
 541     m_nSpacingType = val;
 542     m_nOverride |= SPO_TYPE;
 543 }
 544
 545 void LwpSpacingCommonOverride::OverrideAmount(sal_Int32 val)
 546 {
 547     m_nAmount = val;
 548     m_nOverride |= SPO_AMOUNT;
 549 }
 550
 551 void LwpSpacingCommonOverride::OverrideMultiple(sal_Int32 val)
 552 {
 553     m_nMultiple = val;
 554     m_nOverride |= SPO_MULTIPLE;
 555 }