include/drawinglayer/primitive2d/texthierarchyprimitive2d.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_DRAWINGLAYER_PRIMITIVE2D_TEXTHIERARCHYPRIMITIVE2D_HXX
  21 #define INCLUDED_DRAWINGLAYER_PRIMITIVE2D_TEXTHIERARCHYPRIMITIVE2D_HXX
  22
  23 #include <drawinglayer/drawinglayerdllapi.h>
  24
  25 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
  26 #include <rtl/ustring.hxx>
  27
  28
  29 namespace drawinglayer
  30 {
  31     namespace primitive2d
  32     {
  33         /** TextHierarchyLinePrimitive2D class
  34
  35             Text format hierarchy helper class. It decomposes to its
  36             content, so all direct renderers may ignore it. If You need
  37             to know more about line hierarchies You may react on it and
  38             also need to take care that the source of data uses it.
  39
  40             This primitive encapsulates text lines.
  41          */
  42         class DRAWINGLAYER_DLLPUBLIC TextHierarchyLinePrimitive2D : public GroupPrimitive2D
  43         {
  44         private:
  45         public:
  46             /// constructor
  47             explicit TextHierarchyLinePrimitive2D(const Primitive2DContainer& rChildren);
  48
  49             /// provide unique ID
  50             DeclPrimitive2DIDBlock()
  51         };
  52     } // end of namespace primitive2d
  53 } // end of namespace drawinglayer
  54
  55
  56 namespace drawinglayer
  57 {
  58     namespace primitive2d
  59     {
  60         /** TextHierarchyBulletPrimitive2D class
  61
  62             This primitive encapsulates text bullets.
  63          */
  64         class DRAWINGLAYER_DLLPUBLIC TextHierarchyBulletPrimitive2D : public GroupPrimitive2D
  65         {
  66         private:
  67         public:
  68             /// constructor
  69             explicit TextHierarchyBulletPrimitive2D(const Primitive2DContainer& rChildren);
  70
  71             /// provide unique ID
  72             DeclPrimitive2DIDBlock()
  73         };
  74     } // end of namespace primitive2d
  75 } // end of namespace drawinglayer
  76
  77
  78 namespace drawinglayer
  79 {
  80     namespace primitive2d
  81     {
  82         /** TextHierarchyParagraphPrimitive2D class
  83
  84             This primitive encapsulates text paragraphs.
  85          */
  86         class DRAWINGLAYER_DLLPUBLIC TextHierarchyParagraphPrimitive2D : public GroupPrimitive2D
  87         {
  88         private:
  89         public:
  90             /// constructor
  91             explicit TextHierarchyParagraphPrimitive2D(const Primitive2DContainer& rChildren);
  92
  93             /// provide unique ID
  94             DeclPrimitive2DIDBlock()
  95         };
  96     } // end of namespace primitive2d
  97 } // end of namespace drawinglayer
  98
  99
 100 namespace drawinglayer
 101 {
 102     namespace primitive2d
 103     {
 104         /** TextHierarchyBlockPrimitive2D class
 105
 106             This primitive encapsulates text blocks.
 107          */
 108         class DRAWINGLAYER_DLLPUBLIC TextHierarchyBlockPrimitive2D : public GroupPrimitive2D
 109         {
 110         private:
 111         public:
 112             /// constructor
 113             explicit TextHierarchyBlockPrimitive2D(const Primitive2DContainer& rChildren);
 114
 115             /// provide unique ID
 116             DeclPrimitive2DIDBlock()
 117         };
 118     } // end of namespace primitive2d
 119 } // end of namespace drawinglayer
 120
 121
 122 namespace drawinglayer
 123 {
 124     namespace primitive2d
 125     {
 126         /** FieldType definition */
 127         enum FieldType
 128         {
 129             /** unspecified. If more info is needed for a FieldType,
 130                 create a new type and its handling
 131              */
 132             FIELD_TYPE_COMMON,
 133
 134             /** uses "FIELD_SEQ_BEGIN;PageField" -> special handling */
 135             FIELD_TYPE_PAGE,
 136
 137             /** uses URL as string -> special handling */
 138             FIELD_TYPE_URL
 139         };
 140
 141         /** TextHierarchyFieldPrimitive2D class
 142
 143             This primitive encapsulates text fields.
 144             Also: This type uses a type enum to transport the encapsulated field
 145             type. Also added is a String which is type-dependent. E.g. for URL
 146             fields, it contains the URL.
 147          */
 148         class DRAWINGLAYER_DLLPUBLIC TextHierarchyFieldPrimitive2D : public GroupPrimitive2D
 149         {
 150         private:
 151             FieldType                               meType;
 152             OUString                           maString;
 153
 154         public:
 155             /// constructor
 156             TextHierarchyFieldPrimitive2D(
 157                 const Primitive2DContainer& rChildren,
 158                 const FieldType& rFieldType,
 159                 const OUString& rString);
 160
 161             /// data read access
 162             FieldType getType() const { return meType; }
 163             const OUString& getString() const { return maString; }
 164
 165             /// compare operator
 166             virtual bool operator==(const BasePrimitive2D& rPrimitive) const override;
 167
 168             /// provide unique ID
 169             DeclPrimitive2DIDBlock()
 170         };
 171     } // end of namespace primitive2d
 172 } // end of namespace drawinglayer
 173
 174
 175 namespace drawinglayer
 176 {
 177     namespace primitive2d
 178     {
 179         /** TextHierarchyEditPrimitive2D class
 180
 181             #i97628#
 182             Primitive to encapsulate text from an active text edit; some
 183             renderers need to suppress this output due to painting the
 184             edited text in e.g. an OutlinerEditView. It's derived from
 185             GroupPrimitive2D, so the implicit decomposition will use the
 186             content. To suppress, this primitive needs to be parsed by
 187             the renderer without taking any action.
 188          */
 189         class DRAWINGLAYER_DLLPUBLIC TextHierarchyEditPrimitive2D : public GroupPrimitive2D
 190         {
 191         private:
 192         public:
 193             /// constructor
 194             explicit TextHierarchyEditPrimitive2D(const Primitive2DContainer& rChildren);
 195
 196             /// provide unique ID
 197             DeclPrimitive2DIDBlock()
 198         };
 199     } // end of namespace primitive2d
 200 } // end of namespace drawinglayer
 201
 202
 203 #endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_TEXTHIERARCHYPRIMITIVE2D_HXX
 204
 205 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */