lotuswordpro/source/filter/lwpoverride.hxx

   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 #ifndef INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_LWPOVERRIDE_HXX
  66 #define INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_LWPOVERRIDE_HXX
  67
  68 #include "lwpobjid.hxx"
  69 #include "lwptools.hxx"
  70
  71 class LwpObjectStream;
  72
  73 enum STATE
  74 {
  75     STATE_OFF   = 0,
  76     STATE_ON    = 1,
  77     STATE_STYLE = 2
  78 };
  79
  80 class LwpOverride
  81 {
  82 public:
  83     LwpOverride() : m_nValues(0), m_nOverride(0), m_nApply(0) {}
  84
  85     virtual ~LwpOverride(){}
  86
  87     virtual LwpOverride* clone() const = 0;
  88
  89     virtual void Read(LwpObjectStream* pStrm) = 0;
  90
  91     void ReadCommon(LwpObjectStream* pStrm);
  92
  93     void Clear();
  94
  95     void Override(sal_uInt16 nBits, STATE eState);
  96
  97 protected:
  98     LwpOverride(LwpOverride const& rOther);
  99
 100 private:
 101     LwpOverride& operator=(LwpOverride const& rOther) SAL_DELETED_FUNCTION;
 102
 103 protected:
 104     sal_uInt16  m_nValues;
 105     sal_uInt16  m_nOverride;
 106     sal_uInt16  m_nApply;
 107 };
 108
 109 class LwpTextLanguageOverride : public LwpOverride
 110 {
 111 public:
 112     LwpTextLanguageOverride() : m_nLanguage(0) {}
 113
 114     virtual LwpTextLanguageOverride* clone() const SAL_OVERRIDE;
 115
 116     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 117
 118 protected:
 119     LwpTextLanguageOverride(LwpTextLanguageOverride const& rOther);
 120
 121 private:
 122     LwpTextLanguageOverride& operator=(LwpTextLanguageOverride const& rOther) SAL_DELETED_FUNCTION;
 123
 124 private:
 125     sal_uInt16  m_nLanguage;
 126 };
 127
 128 class LwpTextAttributeOverride : public LwpOverride
 129 {
 130 public:
 131     LwpTextAttributeOverride() : m_nHideLevels(0), m_nBaseLineOffset(0) {}
 132
 133     virtual LwpTextAttributeOverride* clone() const SAL_OVERRIDE;
 134
 135     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 136
 137     inline sal_uInt16 GetHideLevels() const;
 138
 139     bool IsHighlight();
 140
 141 protected:
 142     LwpTextAttributeOverride(LwpTextAttributeOverride const& rOther);
 143
 144 private:
 145     LwpTextAttributeOverride& operator=(LwpTextAttributeOverride const& rOther) SAL_DELETED_FUNCTION;
 146
 147 private:
 148     enum{
 149     TAO_HIGHLIGHT = 0x08,
 150     };
 151     sal_uInt16  m_nHideLevels;
 152     sal_uInt32  m_nBaseLineOffset;
 153 };
 154
 155 inline sal_uInt16 LwpTextAttributeOverride::GetHideLevels() const
 156 {
 157     return m_nHideLevels;
 158 }
 159
 160 class LwpKinsokuOptsOverride : public LwpOverride
 161 {
 162 public:
 163     LwpKinsokuOptsOverride() : m_nLevels(0) {}
 164
 165     virtual LwpKinsokuOptsOverride* clone() const SAL_OVERRIDE;
 166
 167     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 168
 169 protected:
 170     LwpKinsokuOptsOverride(LwpKinsokuOptsOverride const& rOther);
 171
 172 private:
 173     LwpKinsokuOptsOverride& operator=(LwpKinsokuOptsOverride const& rOther) SAL_DELETED_FUNCTION;
 174
 175 private:
 176     sal_uInt16  m_nLevels;
 177 };
 178
 179 class LwpBulletOverride : public LwpOverride
 180 {
 181 public:
 182     LwpBulletOverride() {m_bIsNull = true;}
 183
 184     virtual LwpBulletOverride* clone() const SAL_OVERRIDE;
 185
 186     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 187
 188     inline LwpObjectID GetSilverBullet() const;
 189
 190     void Override(LwpBulletOverride* pOther);
 191
 192     inline bool IsSilverBulletOverridden();
 193     inline bool IsSkipOverridden();
 194     inline bool IsRightAlignedOverridden();
 195     inline bool IsSkip();
 196     inline bool IsRightAligned();
 197     inline bool IsEditable();
 198
 199     void OverrideSilverBullet(LwpObjectID aID);
 200     void OverrideSkip(bool bOver);
 201     void OverrideRightAligned(bool bOver);
 202
 203     inline void RevertSilverBullet();
 204     inline void RevertSkip();
 205     inline void RevertRightAligned();
 206
 207     bool IsInValid(){return m_bIsNull;}
 208
 209 protected:
 210     LwpBulletOverride(LwpBulletOverride const& rOther);
 211
 212 private:
 213     LwpBulletOverride& operator=(LwpBulletOverride const& rOther) SAL_DELETED_FUNCTION;
 214
 215 private:
 216     enum
 217     {
 218         BO_SILVERBULLET = 0x01,
 219         // 0x02 is free
 220         BO_RIGHTALIGN   = 0x04,
 221         BO_EDITABLE     = 0x08,
 222         BO_SKIP         = 0x10
 223     };
 224
 225     LwpObjectID m_SilverBullet;
 226     bool m_bIsNull;
 227 };
 228
 229 inline LwpObjectID LwpBulletOverride::GetSilverBullet() const
 230 {
 231     return m_SilverBullet;
 232 }
 233
 234 inline bool LwpBulletOverride::IsSilverBulletOverridden()
 235 {
 236     return ((m_nOverride & BO_SILVERBULLET) != 0);
 237 }
 238
 239 inline bool LwpBulletOverride::IsSkipOverridden()
 240 {
 241     return ((m_nOverride & BO_SKIP) != 0);
 242 }
 243
 244 inline bool LwpBulletOverride::IsRightAlignedOverridden()
 245 {
 246     return ((m_nOverride & BO_RIGHTALIGN) != 0);
 247 }
 248
 249 inline bool LwpBulletOverride::IsSkip()
 250 {
 251     return ((m_nValues & BO_SKIP) != 0);
 252 }
 253
 254 inline bool LwpBulletOverride::IsEditable()
 255 {
 256     return ((m_nValues & BO_EDITABLE) != 0);
 257 }
 258
 259 inline bool LwpBulletOverride::IsRightAligned()
 260 {
 261     return ((m_nValues & BO_RIGHTALIGN) != 0);
 262 }
 263
 264 inline void LwpBulletOverride::RevertSilverBullet()
 265 {
 266     LwpOverride::Override(BO_SILVERBULLET, STATE_STYLE);
 267 }
 268
 269 inline void LwpBulletOverride::RevertSkip()
 270 {
 271     LwpOverride::Override(BO_SKIP, STATE_STYLE);
 272 }
 273
 274 inline void LwpBulletOverride::RevertRightAligned()
 275 {
 276     LwpOverride::Override(BO_RIGHTALIGN, STATE_STYLE);
 277 }
 278
 279 class LwpAlignmentOverride : public LwpOverride
 280 {
 281 public:
 282     LwpAlignmentOverride() : m_nAlignType(ALIGN_LEFT), m_nPosition(0), m_nAlignChar(0){}
 283
 284     virtual LwpAlignmentOverride* clone() const SAL_OVERRIDE;
 285
 286     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 287
 288     enum AlignType
 289     {
 290         ALIGN_LEFT          = 0,
 291         ALIGN_RIGHT         = 1,
 292         ALIGN_CENTER        = 2,
 293         ALIGN_JUSTIFY       = 3,
 294         ALIGN_JUSTIFYALL    = 4,
 295         ALIGN_NUMERICLEFT   = 5,
 296         ALIGN_NUMERICRIGHT  = 6,
 297         ALIGN_SQUEEZE       = 7
 298     };
 299
 300     AlignType GetAlignType(){ return m_nAlignType; }
 301     void Override(LwpAlignmentOverride* other);//add by  1-24
 302     void OverrideAlignment(AlignType val);//add by  1-24
 303
 304 protected:
 305     LwpAlignmentOverride(LwpAlignmentOverride const& rOther);
 306
 307 private:
 308     LwpAlignmentOverride& operator=(LwpAlignmentOverride const& rOther) SAL_DELETED_FUNCTION;
 309
 310 private:
 311     enum
 312     {
 313         AO_TYPE     = 0x01,
 314         AO_POSITION = 0x02,
 315         AO_CHAR     = 0x04
 316     };
 317
 318     AlignType   m_nAlignType;
 319     sal_uInt32  m_nPosition;
 320     sal_uInt16  m_nAlignChar;
 321 };
 322
 323 class LwpSpacingCommonOverride : public LwpOverride
 324 {
 325 public:
 326     LwpSpacingCommonOverride() : m_nSpacingType(SPACING_NONE), m_nAmount(0), m_nMultiple(65536){}
 327
 328     virtual LwpSpacingCommonOverride* clone() const SAL_OVERRIDE;
 329
 330     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 331
 332     enum SpacingType
 333     {
 334         SPACING_DYNAMIC = 0,
 335         SPACING_LEADING = 1,
 336         SPACING_CUSTOM  = 2,
 337         SPACING_NONE    = 3
 338     };
 339
 340     SpacingType GetType() const {return m_nSpacingType;}
 341     sal_Int32 GetAmount() const {return m_nAmount;}
 342     sal_Int32 GetMultiple() const {return m_nMultiple;}
 343
 344     void Override(LwpSpacingCommonOverride* other);
 345     void OverrideType(SpacingType val);
 346     void OverrideAmount(sal_Int32 val);
 347     void OverrideMultiple(sal_Int32 val);
 348
 349 protected:
 350     LwpSpacingCommonOverride(LwpSpacingCommonOverride const& rOther);
 351
 352 private:
 353     LwpSpacingCommonOverride& operator=(LwpSpacingCommonOverride const& rOther) SAL_DELETED_FUNCTION;
 354
 355 protected:
 356     enum
 357     {
 358         SPO_TYPE    = 0x01,
 359         SPO_AMOUNT  = 0x02,
 360         SPO_MULTIPLE= 0x04
 361     };
 362     SpacingType m_nSpacingType;//sal_uInt16
 363     sal_Int32   m_nAmount;
 364     sal_Int32   m_nMultiple;
 365 };
 366
 367 class LwpSpacingOverride : public LwpOverride
 368 {
 369 public:
 370     LwpSpacingOverride();
 371     virtual ~LwpSpacingOverride();
 372
 373     virtual LwpSpacingOverride* clone() const SAL_OVERRIDE;
 374
 375     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 376
 377     void Override(LwpSpacingOverride* other);
 378
 379     LwpSpacingCommonOverride* GetSpacing(){return m_pSpacing;}
 380     LwpSpacingCommonOverride* GetAboveLineSpacing(){return m_pAboveLineSpacing;}
 381     LwpSpacingCommonOverride* GetAboveSpacing(){return m_pParaSpacingAbove;}
 382     LwpSpacingCommonOverride* GetBelowSpacing(){return m_pParaSpacingBelow;}
 383
 384 protected:
 385     LwpSpacingOverride(LwpSpacingOverride const& rOther);
 386
 387 private:
 388     LwpSpacingOverride& operator=(LwpSpacingOverride const& rOther) SAL_DELETED_FUNCTION;
 389
 390 private:
 391     LwpSpacingCommonOverride*   m_pSpacing;
 392     LwpSpacingCommonOverride*   m_pAboveLineSpacing;
 393     LwpSpacingCommonOverride*   m_pParaSpacingAbove;
 394     LwpSpacingCommonOverride*   m_pParaSpacingBelow;
 395 };
 396
 397 class LwpIndentOverride : public LwpOverride
 398 {
 399 public:
 400     LwpIndentOverride() : m_nAll(0), m_nFirst(0), m_nRest(0), m_nRight(0) {}
 401
 402     virtual LwpIndentOverride* clone() const SAL_OVERRIDE;
 403
 404     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 405
 406     enum
 407     {
 408         RELATIVE_FIRST, RELATIVE_REST, RELATIVE_ALL
 409     };
 410
 411     inline double GetFirst() const;
 412     inline double GetLeft() const;
 413     inline double GetRight() const;
 414
 415     sal_uInt16 GetRelative();
 416     bool IsUseRelative();
 417     void Override(LwpIndentOverride* other);
 418     void OverrideIndentAll(sal_Int32 val);
 419     void OverrideIndentFirst(sal_Int32 val);
 420     void OverrideIndentRight(sal_Int32 val);
 421     void OverrideIndentRest(sal_Int32 val);
 422     void OverrideUseRelative(bool use);
 423     void OverrideRelative(sal_uInt16 relative);
 424     sal_Int32 GetMAll() const {return m_nAll;}
 425     sal_Int32 GetMFirst() const {return m_nFirst;}
 426     sal_Int32 GetMRest() const {return m_nRest;}
 427     sal_Int32 GetMRight() const {return m_nRight;}
 428     void SetMAll(sal_Int32 val){m_nAll=val;}
 429     void SetMFirst(sal_Int32 val){m_nFirst=val;}
 430     void SetMRest(sal_Int32 val){m_nRest=val;}
 431     void SetMRight(sal_Int32 val){m_nRight=val;}
 432
 433 protected:
 434     LwpIndentOverride(LwpIndentOverride const& rOther);
 435
 436 private:
 437     LwpIndentOverride& operator=(LwpIndentOverride const& rOther) SAL_DELETED_FUNCTION;
 438
 439 private:
 440     enum
 441     {
 442         IO_ALL          = 0x0001,
 443         IO_FIRST        = 0x0002,
 444         IO_REST         = 0x0004,
 445         IO_RIGHT        = 0x0008,
 446         IO_HANGING      = 0x0010,
 447         IO_EQUAL        = 0x0020,
 448         IO_BODY         = 0x0040,
 449         IO_REL_ALL      = 0x0080,
 450         IO_REL_FIRST    = 0x0100,
 451         IO_REL_REST     = 0x0200,
 452         IO_REL_FLAGS    = (IO_REL_ALL | IO_REL_FIRST | IO_REL_REST),
 453         IO_USE_RELATIVE = 0x0400
 454     };
 455
 456     sal_Int32   m_nAll;
 457     sal_Int32   m_nFirst;
 458     sal_Int32   m_nRest;
 459     sal_Int32   m_nRight;
 460 };
 461
 462 inline double LwpIndentOverride::GetFirst() const
 463 {
 464         return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nFirst-m_nRest));
 465 }
 466 inline double LwpIndentOverride::GetLeft() const
 467 {
 468         return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nAll+m_nRest));
 469 }
 470 inline double LwpIndentOverride::GetRight() const
 471 {
 472     return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nRight));
 473 }
 474
 475 class LwpBackgroundStuff;
 476 class LwpAmikakeOverride : public LwpOverride
 477 {
 478 public:
 479     LwpAmikakeOverride();
 480
 481     virtual ~LwpAmikakeOverride();
 482
 483     virtual LwpAmikakeOverride* clone() const SAL_OVERRIDE;
 484
 485     void Read(LwpObjectStream* pStrm) SAL_OVERRIDE;
 486     enum
 487     {
 488         AMIKAKE_NONE        = 0,
 489         AMIKAKE_BACKGROUND  = 1,
 490         AMIKAKE_CHARACTER   = 2
 491     };
 492
 493 protected:
 494     LwpAmikakeOverride(LwpAmikakeOverride const& rOther);
 495
 496 private:
 497     LwpAmikakeOverride& operator=(LwpAmikakeOverride const& rOther) SAL_DELETED_FUNCTION;
 498
 499 private:
 500     LwpBackgroundStuff* m_pBackgroundStuff;
 501     sal_uInt16      m_nType;
 502
 503 };
 504
 505 #endif
 506
 507 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */