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
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_VIEWS_PAINTER_H_
#define UI_VIEWS_PAINTER_H_
#include <stddef.h>
#include <memory>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/base/nine_image_painter_factory.h"
#include "ui/views/views_export.h"
namespace gfx {
class Canvas;
class ImageSkia;
class Insets;
class InsetsF;
class Rect;
class Size;
}
namespace views {
class View;
// Painter, as the name implies, is responsible for painting in a particular
// region. Think of Painter as a Border or Background that can be painted
// in any region of a View.
class VIEWS_EXPORT Painter {
public:
Painter();
virtual ~Painter();
// A convenience method for painting a Painter in a particular region.
// This translates the canvas to x/y and paints the painter.
static void PaintPainterAt(gfx::Canvas* canvas,
Painter* painter,
const gfx::Rect& rect);
// Convenience that paints |focus_painter| only if |view| HasFocus() and
// |focus_painter| is non-NULL.
static void PaintFocusPainter(View* view,
gfx::Canvas* canvas,
Painter* focus_painter);
// Creates a painter that draws a RoundRect with a solid color and given
// corner radius.
static std::unique_ptr<Painter> CreateSolidRoundRectPainter(SkColor color,
float radius);
// Creates a painter that draws a RoundRect with a solid color and a given
// corner radius, and also adds a 1px border (inset) in the given color.
static std::unique_ptr<Painter> CreateRoundRectWith1PxBorderPainter(
SkColor bg_color,
SkColor stroke_color,
float radius);
// TODO(estade): remove. The last client (table_header.cc) is going away soon.
static std::unique_ptr<Painter> CreateVerticalGradient(SkColor c1,
SkColor c2);
// Creates a painter that divides |image| into nine regions. The four corners
// are rendered at the size specified in insets (eg. the upper-left corner is
// rendered at 0 x 0 with a size of insets.left() x insets.top()). The center
// and edge images are stretched to fill the painted area.
static std::unique_ptr<Painter> CreateImagePainter(
const gfx::ImageSkia& image,
const gfx::Insets& insets);
// Creates a painter that paints images in a scalable grid. The images must
// share widths by column and heights by row. The corners are painted at full
// size, while center and edge images are stretched to fill the painted area.
// The center image may be zero (to be skipped). This ordering must be used:
// Top-Left/Top/Top-Right/Left/[Center]/Right/Bottom-Left/Bottom/Bottom-Right.
static std::unique_ptr<Painter> CreateImageGridPainter(const int image_ids[]);
// Factory methods for creating painters intended for rendering focus.
static std::unique_ptr<Painter> CreateDashedFocusPainter();
static std::unique_ptr<Painter> CreateDashedFocusPainterWithInsets(
const gfx::Insets& insets);
// Deprecated: used the InsetsF version below.
static std::unique_ptr<Painter> CreateSolidFocusPainter(
SkColor color,
const gfx::Insets& insets);
// |thickness| is in dip.
static std::unique_ptr<Painter> CreateSolidFocusPainter(
SkColor color,
int thickness,
const gfx::InsetsF& insets);
// Returns the minimum size this painter can paint without obvious graphical
// problems (e.g. overlapping images).
virtual gfx::Size GetMinimumSize() const = 0;
// Paints the painter in the specified region.
virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(Painter);
};
// HorizontalPainter paints 3 images into a box: left, center and right. The
// left and right images are drawn to size at the left/right edges of the
// region. The center is tiled in the remaining space. All images must have the
// same height.
class VIEWS_EXPORT HorizontalPainter : public Painter {
public:
// Constructs a new HorizontalPainter loading the specified image names.
// The images must be in the order left, right and center.
explicit HorizontalPainter(const int image_resource_names[]);
~HorizontalPainter() override;
// Painter:
gfx::Size GetMinimumSize() const override;
void Paint(gfx::Canvas* canvas, const gfx::Size& size) override;
private:
// The image chunks.
enum BorderElements {
LEFT,
CENTER,
RIGHT
};
// NOTE: the images are owned by ResourceBundle. Don't free them.
const gfx::ImageSkia* images_[3];
DISALLOW_COPY_AND_ASSIGN(HorizontalPainter);
};
} // namespace views
#endif // UI_VIEWS_PAINTER_H_
|
