This file is indexed.

/usr/include/qwt-qt4/qwt_plot_rescaler.h is in libqwt5-qt4-dev 5.2.2-1ubuntu2.

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
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   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
 *****************************************************************************/

#ifndef QWT_PLOT_RESCALER_H
#define QWT_PLOT_RESCALER_H 1

#include "qwt_global.h"
#include "qwt_double_rect.h"
#include "qwt_double_interval.h"
#include "qwt_plot.h"
#include <qobject.h>

class QwtPlotCanvas;
class QResizeEvent;

/*!
    \brief QwtPlotRescaler takes care of fixed aspect ratios for plot scales

    QwtPlotRescaler autoadjusts the axes of a QwtPlot according
    to fixed aspect ratios.
*/

class QWT_EXPORT QwtPlotRescaler: public QObject
{
public:
    /*!
        \brief Rescale Policy

        The rescale policy defines how to rescale the reference axis and
        their depending axes.

        - Fixed

          The interval of the reference axis remains unchanged, when the
          geometry of the canvas changes. All other axes 
          will be adjusted according to their aspect ratio.

        - Expanding

          The interval of the reference axis will be shrinked/expanded,
          when the geometry of the canvas changes. All other axes
          will be adjusted according to their aspect ratio.

          The interval, that is represented by one pixel is fixed.

        - Fitting

          The intervals of the axes are calculated, so that all axes include
          their minimal interval.
    */

    enum RescalePolicy
    {
        Fixed,
        Expanding,
        Fitting
    };

    enum ExpandingDirection
    {
        ExpandUp,
        ExpandDown,
        ExpandBoth
    };

    explicit QwtPlotRescaler(QwtPlotCanvas *, 
        int referenceAxis = QwtPlot::xBottom, 
        RescalePolicy = Expanding );

    virtual ~QwtPlotRescaler();

    void setEnabled(bool);
    bool isEnabled() const;

    void setRescalePolicy(RescalePolicy);
    RescalePolicy rescalePolicy() const;

    void setExpandingDirection(ExpandingDirection);
    void setExpandingDirection(int axis, ExpandingDirection);
    ExpandingDirection expandingDirection(int axis) const;

    void setReferenceAxis(int axis);
    int referenceAxis() const;

    void setAspectRatio(double ratio);
    void setAspectRatio(int axis, double ratio);
    double aspectRatio(int axis) const;

    void setIntervalHint(int axis, const QwtDoubleInterval&);
    QwtDoubleInterval intervalHint(int axis) const;

    QwtPlotCanvas *canvas();
    const QwtPlotCanvas *canvas() const;

    QwtPlot *plot();
    const QwtPlot *plot() const;

    virtual bool eventFilter(QObject *, QEvent *);

    void rescale() const;

protected:
    virtual void canvasResizeEvent(QResizeEvent *);

    virtual void rescale(const QSize &oldSize, const QSize &newSize) const;
    virtual QwtDoubleInterval expandScale( int axis, 
        const QSize &oldSize, const QSize &newSize) const;
 
    virtual QwtDoubleInterval syncScale(
        int axis, const QwtDoubleInterval& reference,
        const QSize &size) const; 

    virtual void updateScales(
        QwtDoubleInterval intervals[QwtPlot::axisCnt]) const;

    Qt::Orientation orientation(int axis) const;
    QwtDoubleInterval interval(int axis) const;
    QwtDoubleInterval expandInterval(const QwtDoubleInterval &, 
        double width, ExpandingDirection) const;

private:
    double pixelDist(int axis, const QSize &) const;

    class AxisData;
    class PrivateData;
    PrivateData *d_data;
};

#endif