This file is indexed.

/usr/include/qwt-qt4/qwt_text.h is in libqwt5-qt4-dev 5.2.3-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2003   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

// vim: expandtab

#ifndef QWT_TEXT_H
#define QWT_TEXT_H

#include <qstring.h>
#include <qsize.h>
#include <qfont.h>
#include "qwt_global.h"

class QColor;
class QPen;
class QBrush;
class QRect;
class QPainter;
class QwtTextEngine;

/*!
  \brief A class representing a text

  A QwtText is a text including a set of attributes how to render it.

  - Format\n
    A text might include control sequences (f.e tags) describing
    how to render it. Each format (f.e MathML, TeX, Qt Rich Text)
    has its own set of control sequences, that can be handles by
    a QwtTextEngine for this format.
  - Background\n
    A text might have a background, defined by a QPen and QBrush
    to improve its visibility.
  - Font\n
    A text might have an individual font.
  - Color\n
    A text might have an individual color.
  - Render Flags\n
    Flags from Qt::AlignmentFlag and Qt::TextFlag used like in
    QPainter::drawText.

  \sa QwtTextEngine, QwtTextLabel
*/

class QWT_EXPORT QwtText
{
public:

    /*!
      \brief Text format

      The text format defines the QwtTextEngine, that is used to render
      the text.

      - AutoText\n
        The text format is determined using QwtTextEngine::mightRender for
        all available text engines in increasing order > PlainText.
        If none of the text engines can render the text is rendered
        like PlainText.
      - PlainText\n
        Draw the text as it is, using a QwtPlainTextEngine.
      - RichText\n
        Use the Scribe framework (Qt Rich Text) to render the text.
      - MathMLText\n
        Use a MathML (http://en.wikipedia.org/wiki/MathML) render engine
        to display the text. The Qwt MathML extension offers such an engine
        based on the MathML renderer of the Qt solutions package. Unfortunately
        it is only available for owners of a commercial Qt license.
      - TeXText\n
        Use a TeX (http://en.wikipedia.org/wiki/TeX) render engine
        to display the text. 
      - OtherFormat\n
        The number of text formats can be extended using setTextEngine.
        Formats >= OtherFormat are not used by Qwt.

      \sa QwtTextEngine, setTextEngine()
    */

    enum TextFormat
    {
        AutoText = 0,
        
        PlainText,
        RichText,

        MathMLText,
        TeXText,

        OtherFormat = 100
    };

    /*!
      \brief Paint Attributes

      Font and color and background are optional attributes of a QwtText. 
      The paint attributes hold the information, if they are set.

      - PaintUsingTextFont\n
        The text has an individual font.
      - PaintUsingTextColor\n
        The text has an individual color.
      - PaintBackground\n
        The text has an individual background.
    */
    enum PaintAttribute
    {
        PaintUsingTextFont = 1,
        PaintUsingTextColor = 2,
        PaintBackground = 4
    };

    /*!
      \brief Layout Attributes

      The layout attributes affects some aspects of the layout of the text.

      - MinimumLayout\n
        Layout the text without its margins. This mode is useful if a
        text needs to be aligned accurately, like the tick labels of a scale.
        If QwtTextEngine::textMargins is not implemented for the format
        of the text, MinimumLayout has no effect.
    */
    enum LayoutAttribute
    {
        MinimumLayout = 1
    };

    QwtText(const QString & = QString::null, 
        TextFormat textFormat = AutoText);
    QwtText(const QwtText &);
    ~QwtText();

    QwtText &operator=(const QwtText &);

    int operator==(const QwtText &) const;
    int operator!=(const QwtText &) const;

    void setText(const QString &, 
        QwtText::TextFormat textFormat = AutoText);
    QString text() const;

    bool isNull() const;
    bool isEmpty() const;

    void setFont(const QFont &);
    QFont font() const;

    QFont usedFont(const QFont &) const;

    void setRenderFlags(int flags);
    int renderFlags() const;

    void setColor(const QColor &);
    QColor color() const;

    QColor usedColor(const QColor &) const;

    void setBackgroundPen(const QPen &);
    QPen backgroundPen() const;

    void setBackgroundBrush(const QBrush &);
    QBrush backgroundBrush() const;

    void setPaintAttribute(PaintAttribute, bool on = true);
    bool testPaintAttribute(PaintAttribute) const;

    void setLayoutAttribute(LayoutAttribute, bool on = true);
    bool testLayoutAttribute(LayoutAttribute) const;

    int heightForWidth(int width, const QFont & = QFont()) const;
    QSize textSize(const QFont & = QFont()) const;

    void draw(QPainter *painter, const QRect &rect) const;

    static const QwtTextEngine *textEngine(const QString &text,
        QwtText::TextFormat = AutoText);

    static const QwtTextEngine *textEngine(QwtText::TextFormat);
    static void setTextEngine(QwtText::TextFormat, QwtTextEngine *);

private:
    class PrivateData;
    PrivateData *d_data;

    class LayoutCache;
    LayoutCache *d_layoutCache;
};

//! \return text().isNull()
inline bool QwtText::isNull() const 
{ 
    return text().isNull(); 
}

//! \return text().isEmpty()
inline bool QwtText::isEmpty() const 
{ 
    return text().isEmpty(); 
}

#endif