← Back to branch summary

~ubuntu-branches/ubuntu/saucy/goldencheetah/saucy

« back to all changes in this revision

Viewing changes to qwt/src/qwt_painter.h

  • Committer: Package Import Robot
  • Author(s): KURASHIKI Satoru
  • Date: 2013-08-18 07:02:45 UTC
  • mfrom: (4.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20130818070245-zgdvb47e1k3mtgil
Tags: 3.0-3
http://bugs.debian.org/719571
debian/control: remove needless dependency. (Closes: #719571)

Show diffs side-by-side

added added

removed removed

Lines of Context:
qwt/src/qwt_painter.h
2
2
 * Qwt Widget Library
3
3
 * Copyright (C) 1997   Josef Wilgen
4
4
 * Copyright (C) 2002   Uwe Rathmann
5
 
 * 
 
5
 *
6
6
 * This library is free software; you can redistribute it and/or
7
7
 * modify it under the terms of the Qwt License, Version 1.0
8
8
 *****************************************************************************/
10
10
#ifndef QWT_PAINTER_H
11
11
#define QWT_PAINTER_H
12
12
 
 
13
#include "qwt_global.h"
 
14
 
13
15
#include <qpoint.h>
14
16
#include <qrect.h>
15
17
#include <qpen.h>
16
 
#include "qwt_global.h"
17
 
#include "qwt_layout_metrics.h"
18
 
#include "qwt_polygon.h"
 
18
#include <qline.h>
19
19
 
20
20
class QPainter;
21
21
class QBrush;
22
22
class QColor;
23
23
class QWidget;
 
24
class QPolygonF;
 
25
class QRectF;
 
26
class QImage;
 
27
class QPixmap;
24
28
class QwtScaleMap;
25
29
class QwtColorMap;
26
 
class QwtDoubleInterval;
 
30
class QwtInterval;
27
31
 
28
 
#if QT_VERSION < 0x040000
29
 
class QColorGroup;
30
 
class QSimpleRichText;
31
 
#else
32
32
class QPalette;
33
33
class QTextDocument;
34
 
#endif
35
 
 
36
 
#if defined(Q_WS_X11)
37
 
// Warning: QCOORD_MIN, QCOORD_MAX are wrong on X11.
38
 
#define QWT_COORD_MAX 16384
39
 
#define QWT_COORD_MIN (-QWT_COORD_MAX - 1)
40
 
#else
41
 
#define QWT_COORD_MAX 2147483647
42
 
#define QWT_COORD_MIN -QWT_COORD_MAX - 1
43
 
#endif
 
34
class QPainterPath;
44
35
 
45
36
/*!
46
37
  \brief A collection of QPainter workarounds
47
 
 
48
 
  1) Clipping to coordinate system limits (Qt3 only)
49
 
 
50
 
  On X11 pixel coordinates are stored in shorts. Qt 
51
 
  produces overruns when mapping QCOORDS to shorts. 
52
 
 
53
 
  2) Scaling to device metrics
54
 
 
55
 
  QPainter scales fonts, line and fill patterns to the metrics
56
 
  of the paint device. Other values like the geometries of rects, points
57
 
  remain device independend. To enable a device independent widget 
58
 
  implementation, QwtPainter adds scaling of these geometries.
59
 
  (Unfortunately QPainter::scale scales both types of paintings,
60
 
   so the objects of the first type would be scaled twice).
61
38
*/
62
 
 
63
39
class QWT_EXPORT QwtPainter
64
40
{
65
41
public:
66
 
    static void setMetricsMap(const QPaintDevice *layout,
67
 
        const QPaintDevice *device);
68
 
    static void setMetricsMap(const QwtMetricsMap &);
69
 
    static void resetMetricsMap();
70
 
    static const QwtMetricsMap &metricsMap();
71
 
 
72
 
    static void setDeviceClipping(bool);
73
 
    static bool deviceClipping();
74
 
    static const QRect &deviceClipRect();
75
 
 
76
 
    static void setClipRect(QPainter *, const QRect &);
77
 
 
78
 
    static void drawText(QPainter *, int x, int y, 
79
 
        const QString &);
80
 
    static void drawText(QPainter *, const QPoint &, 
81
 
        const QString &);
82
 
    static void drawText(QPainter *, int x, int y, int w, int h, 
83
 
        int flags, const QString &);
84
 
    static void drawText(QPainter *, const QRect &, 
85
 
        int flags, const QString &);
 
42
    static void setPolylineSplitting( bool );
 
43
    static bool polylineSplitting();
 
44
 
 
45
    static void setRoundingAlignment( bool );
 
46
    static bool roundingAlignment();
 
47
    static bool roundingAlignment(QPainter *);
 
48
 
 
49
    static void drawText( QPainter *, double x, double y, const QString & );
 
50
    static void drawText( QPainter *, const QPointF &, const QString & );
 
51
    static void drawText( QPainter *, double x, double y, double w, double h,
 
52
        int flags, const QString & );
 
53
    static void drawText( QPainter *, const QRectF &,
 
54
        int flags, const QString & );
86
55
 
87
56
#ifndef QT_NO_RICHTEXT
88
 
#if QT_VERSION < 0x040000
89
 
    static void drawSimpleRichText(QPainter *, const QRect &,
90
 
        int flags, QSimpleRichText &);
91
 
#else
92
 
    static void drawSimpleRichText(QPainter *, const QRect &,
93
 
        int flags, QTextDocument &);
94
 
#endif
95
 
#endif
96
 
 
97
 
    static void drawRect(QPainter *, int x, int y, int w, int h);
98
 
    static void drawRect(QPainter *, const QRect &rect);
99
 
    static void fillRect(QPainter *, const QRect &, const QBrush &); 
100
 
 
101
 
    static void drawEllipse(QPainter *, const QRect &);
102
 
    static void drawPie(QPainter *, const QRect & r, int a, int alen);
103
 
 
104
 
    static void drawLine(QPainter *, int x1, int y1, int x2, int y2);
105
 
    static void drawLine(QPainter *, const QPoint &p1, const QPoint &p2);
106
 
    static void drawPolygon(QPainter *, const QwtPolygon &pa);
107
 
    static void drawPolyline(QPainter *, const QwtPolygon &pa);
108
 
    static void drawPoint(QPainter *, int x, int y);
109
 
 
110
 
#if QT_VERSION < 0x040000
111
 
    static void drawRoundFrame(QPainter *, const QRect &,
112
 
        int width, const QColorGroup &cg, bool sunken);
113
 
#else
114
 
    static void drawRoundFrame(QPainter *, const QRect &,
115
 
        int width, const QPalette &, bool sunken);
116
 
#endif
117
 
    static void drawFocusRect(QPainter *, QWidget *);
118
 
    static void drawFocusRect(QPainter *, QWidget *, const QRect &);
119
 
 
120
 
    static void drawColorBar(QPainter *painter, 
121
 
        const QwtColorMap &, const QwtDoubleInterval &,
122
 
        const QwtScaleMap &, Qt::Orientation, const QRect &);
123
 
 
124
 
#if QT_VERSION < 0x040000
125
 
    static void setSVGMode(bool on);
126
 
    static bool isSVGMode();
127
 
#endif
128
 
 
129
 
    static QPen scaledPen(const QPen &);
 
57
    static void drawSimpleRichText( QPainter *, const QRectF &,
 
58
        int flags, const QTextDocument & );
 
59
#endif
 
60
 
 
61
    static void drawRect( QPainter *, double x, double y, double w, double h );
 
62
    static void drawRect( QPainter *, const QRectF &rect );
 
63
    static void fillRect( QPainter *, const QRectF &, const QBrush & );
 
64
 
 
65
    static void drawEllipse( QPainter *, const QRectF & );
 
66
    static void drawPie( QPainter *, const QRectF & r, int a, int alen );
 
67
 
 
68
    static void drawLine( QPainter *, double x1, double y1, double x2, double y2 );
 
69
    static void drawLine( QPainter *, const QPointF &p1, const QPointF &p2 );
 
70
    static void drawLine( QPainter *, const QLineF & );
 
71
 
 
72
    static void drawPolygon( QPainter *, const QPolygonF &pa );
 
73
    static void drawPolyline( QPainter *, const QPolygonF &pa );
 
74
    static void drawPolyline( QPainter *, const QPointF *, int pointCount );
 
75
 
 
76
    static void drawPoint( QPainter *, double x, double y );
 
77
    static void drawPoint( QPainter *, const QPointF & );
 
78
 
 
79
    static void drawPath( QPainter *, const QPainterPath & );
 
80
    static void drawImage( QPainter *, const QRectF &, const QImage & );
 
81
    static void drawPixmap( QPainter *, const QRectF &, const QPixmap & );
 
82
 
 
83
    static void drawRoundedFrame( QPainter *,
 
84
        const QRectF &, double xRadius, double yRadius,
 
85
        const QPalette &, int lineWidth, int frameStyle );
 
86
 
 
87
    static void drawFocusRect( QPainter *, QWidget * );
 
88
    static void drawFocusRect( QPainter *, QWidget *, const QRect & );
 
89
 
 
90
    static void drawColorBar( QPainter *painter,
 
91
        const QwtColorMap &, const QwtInterval &,
 
92
        const QwtScaleMap &, Qt::Orientation, const QRectF & );
 
93
 
 
94
    static bool isAligning( QPainter *painter );
130
95
 
131
96
private:
132
 
    static void drawColoredArc(QPainter *, const QRect &,
133
 
        int peak, int arc, int intervall, const QColor &c1, const QColor &c2);
134
 
 
135
 
    static bool d_deviceClipping;
136
 
    static QwtMetricsMap d_metricsMap;
137
 
#if QT_VERSION < 0x040000
138
 
    static bool d_SVGMode;
139
 
#endif
 
97
    static bool d_polylineSplitting;
 
98
    static bool d_roundingAlignment;
140
99
};
141
100
 
142
 
//!  Wrapper for QPainter::drawLine()
143
 
inline void QwtPainter::drawLine(QPainter *painter,
144
 
    const QPoint &p1, const QPoint &p2)
145
 
{
146
 
    drawLine(painter, p1.x(), p1.y(), p2.x(), p2.y());
147
 
}
148
 
 
149
 
/*!
150
 
  Returns whether device clipping is enabled. On X11 the default
151
 
  is enabled, otherwise it is disabled.
152
 
  \sa QwtPainter::setDeviceClipping()
153
 
*/
154
 
inline bool QwtPainter::deviceClipping()
155
 
{
156
 
    return d_deviceClipping;
157
 
}
158
 
 
 
101
//!  Wrapper for QPainter::drawPoint()
 
102
inline void QwtPainter::drawPoint( QPainter *painter, double x, double y )
 
103
{
 
104
    QwtPainter::drawPoint( painter, QPointF( x, y ) );
 
105
}
 
106
 
 
107
//!  Wrapper for QPainter::drawLine()
 
108
inline void QwtPainter::drawLine( QPainter *painter,
 
109
    double x1, double y1, double x2, double y2 )
 
110
{
 
111
    QwtPainter::drawLine( painter, QPointF( x1, y1 ), QPointF( x2, y2 ) );
 
112
}
 
113
 
 
114
//!  Wrapper for QPainter::drawLine()
 
115
inline void QwtPainter::drawLine( QPainter *painter, const QLineF &line )
 
116
{
 
117
    QwtPainter::drawLine( painter, line.p1(), line.p2() );
 
118
}
 
119
 
 
120
/*!
 
121
  Returns whether line splitting for the raster paint engine is enabled.
 
122
  \sa setPolylineSplitting()
 
123
*/
 
124
inline bool QwtPainter::polylineSplitting()
 
125
{
 
126
    return d_polylineSplitting;
 
127
}
 
128
 
 
129
/*!
 
130
  Returns whether coordinates should be rounded, before they are painted
 
131
  to a paint engine that floors to integer values.  For other paint engines
 
132
  this ( Pdf, SVG ), this flag has no effect.
 
133
 
 
134
  \sa setRoundingAlignment(), isAligning()
 
135
*/
 
136
inline bool QwtPainter::roundingAlignment()
 
137
{
 
138
    return d_roundingAlignment;
 
139
}
 
140
 
 
141
/*!
 
142
  \return roundingAlignment() && isAligning(painter);
 
143
  \param painter Painter
 
144
*/
 
145
inline bool QwtPainter::roundingAlignment(QPainter *painter)
 
146
{
 
147
    return d_roundingAlignment && isAligning(painter);
 
148
}
159
149
#endif