]> git.lyx.org Git - lyx.git/blob - src/frontends/Painter.h
Remove using directives from headers
[lyx.git] / src / frontends / Painter.h
1 // -*- C++ -*-
2 /**
3  * \file Painter.h
4  * This file is part of LyX, the document processor.
5  * Licence details can be found in the file COPYING.
6  *
7  * \author unknown
8  * \author John Levon
9  *
10  * Full author contact details are available in file CREDITS.
11  */
12
13 #ifndef PAINTER_H
14 #define PAINTER_H
15
16 #include "support/strfwd.h"
17 #include "support/types.h"
18
19 namespace lyx {
20
21 class Font;
22 class FontInfo;
23
24 namespace graphics { class Image; }
25
26 namespace frontend {
27
28 /**
29  * Painter - A painter class to encapsulate all graphics parameters and operations
30  *
31  * Every graphics operation in LyX should be made by this class. The
32  * painter is used for drawing on the WorkArea, and is passed around
33  * during draw operations.
34  *
35  * It hides low level windows system parameters so insets and other
36  * clients don't have to worry about them and we can control graphics and
37  * GUI toolkit dependent drawing functions inside this single class.
38  *
39  * The intention for a toolkit is that it uses these methods to paint
40  * onto a backing pixmap. Only when expose events arrive via the event
41  * queue (perhaps generated via Screen::expose), does the copy onto
42  * the actual WorkArea widget take place. Paints are wrapped in (possibly
43  * recursive) calls to start() and end() to facilitate the backing pixmap
44  * management.
45  *
46  * Note that the methods return *this for convenience.
47  *
48  * Caution: All char_type and docstring arguments of the text drawing
49  * methods of this class are no UCS4 chars or strings if the font is a
50  * symbol font. They simply denote the code points of the font instead.
51  * You have to keep this in mind when you implement the methods in a
52  * frontend. You must not pass these parameters to a unicode conversion
53  * function in particular.
54  */
55 class Painter {
56 public:
57         Painter(double pixel_ratio) : drawing_enabled_(true), pixel_ratio_(pixel_ratio) {}
58
59         static const int thin_line;
60
61         /// possible line styles
62         enum line_style {
63                 line_solid, //< solid line
64                 line_onoffdash //< dashes with spaces
65         };
66
67         /// possible fill styles
68         enum fill_style {
69                 fill_none,
70                 fill_oddeven,
71                 fill_winding
72         };
73
74         /// possible character styles of preedit string.
75         /// This is used for CJK input method support.
76         enum preedit_style {
77                 preedit_default, //< when unselecting, no cursor and dashed underline.
78                 preedit_selecting, //< when selecting.
79                 preedit_cursor //< with cursor.
80         };
81
82         virtual ~Painter() {}
83
84         /// draw a line from point to point
85         virtual void line(int x1, int y1, int x2, int y2, Color,
86                 line_style = line_solid, int line_width = thin_line) = 0;
87
88         /**
89          * lines -  draw a set of lines
90          * @param xp array of points' x co-ords
91          * @param yp array of points' y co-ords
92          * @param np size of the points array
93          */
94         virtual void lines(int const * xp, int const * yp, int np, Color,
95                 fill_style = fill_none, line_style = line_solid,
96                 int line_width = thin_line) = 0;
97
98         /**
99          * path -  draw a path with bezier curves
100          * @param xp array of points' x co-ords
101          * @param yp array of points' y co-ords
102          * @param c1x array of first control points' x co-ords
103          * @param c1y array of first control points' y co-ords
104          * @param c2x array of second control points' x co-ords
105          * @param c2y array of second control points' y co-ords
106          * @param np size of the points array
107          */
108         virtual void path(int const * xp, int const * yp,
109                 int const * c1x, int const * c1y,
110                 int const * c2x, int const * c2y,
111                 int np, Color,
112                 fill_style = fill_none, line_style = line_solid,
113                 int line_width = thin_line) = 0;
114
115         /// draw a rectangle
116         virtual void rectangle(int x, int y, int w, int h, Color,
117                 line_style = line_solid, int line_width = thin_line) = 0;
118
119         /// draw a filled rectangle
120         virtual void fillRectangle(int x, int y, int w, int h, Color) = 0;
121
122         /// draw an arc
123         virtual void arc(int x, int y, unsigned int w, unsigned int h,
124                 int a1, int a2, Color) = 0;
125
126         /// draw a pixel
127         virtual void point(int x, int y, Color) = 0;
128
129         /// draw a filled rectangle with the shape of a 3D button
130         virtual void button(int x, int y, int w, int h, bool mouseHover) = 0;
131
132         /// draw an image from the image cache
133         virtual void image(int x, int y, int w, int h,
134                 graphics::Image const & image) = 0;
135
136         /// draw a string at position x, y (y is the baseline).
137         virtual void text(int x, int y, docstring const & str, FontInfo const & f) = 0;
138
139         /// draw a char at position x, y (y is the baseline)
140         virtual void text(int x, int y, char_type c, FontInfo const & f) = 0;
141
142         /** draw a string at position x, y (y is the baseline). The
143          * text direction is enforced by the \c Font.
144          */
145         virtual void text(int x, int y, docstring const & str, Font const & f,
146                       double wordspacing, double textwidth) = 0;
147
148         /** draw a string at position x, y (y is the baseline), but
149          * make sure that the part between \c from and \c to is in
150          * \c other color. The text direction is enforced by the \c Font.
151          */
152         virtual void text(int x, int y, docstring const & str, Font const & f,
153                           Color other, size_type from, size_type to,
154                       double wordspacing, double textwidth) = 0;
155
156         void setDrawingEnabled(bool drawing_enabled)
157         { drawing_enabled_ = drawing_enabled; }
158
159         /// Indicate wether real screen drawing shall be done or not.
160         bool isDrawingEnabled() const { return drawing_enabled_; }
161
162         double pixelRatio() const { return pixel_ratio_; }
163
164         /// draw the underbar, strikeout, uuline and uwave font attributes
165         virtual void textDecoration(FontInfo const & f, int x, int y, int width) = 0;
166
167         /**
168          * Draw a string and enclose it inside a rectangle. If
169          * back color is specified, the background is cleared with
170          * the given color. If frame is specified, a thin frame is drawn
171          * around the text with the given color.
172          */
173         virtual void rectText(int x, int baseline, docstring const & str,
174                 FontInfo const & font, Color back, Color frame) = 0;
175
176         /// draw a string and enclose it inside a button frame
177         virtual void buttonText(int x, int baseline, docstring const & s,
178                 FontInfo const & font, bool mouseHover) = 0;
179
180         /// draw a character of a preedit string for cjk support.
181         virtual int preeditText(int x, int y,
182                 char_type c, FontInfo const & f, preedit_style style) = 0;
183
184         /// start monochrome painting mode, i.e. map every color into [min,max]
185         virtual void enterMonochromeMode(Color const & min, 
186                 Color const & max) = 0;
187         /// leave monochrome painting mode
188         virtual void leaveMonochromeMode() = 0;
189         /// draws a wavy line that can be used for underlining.
190         virtual void wavyHorizontalLine(int x, int y, int width, ColorCode col) = 0;
191 private:
192         ///
193         bool drawing_enabled_;
194         /// Ratio between physical pixels and device-independent pixels
195         double pixel_ratio_;
196 };
197
198 } // namespace frontend
199 } // namespace lyx
200
201 #endif // PAINTER_H