Grcov report - hatchings.c

1

/*

2

 * Copyright © 2011 Intel Corporation

3

4

 * Permission is hereby granted, free of charge, to any person

5

 * obtaining a copy of this software and associated documentation

6

 * files (the "Software"), to deal in the Software without

7

 * restriction, including without limitation the rights to use, copy,

8

 * modify, merge, publish, distribute, sublicense, and/or sell copies

9

 * of the Software, and to permit persons to whom the Software is

10

 * furnished to do so, subject to the following conditions:

11

12

 * The above copyright notice and this permission notice shall be

13

 * included in all copies or substantial portions of the Software.

14

15

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

16

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

17

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

18

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

19

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

20

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

21

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

22

 * SOFTWARE.

23

24

 * Author: Chris Wilson <chris@chris-wilson.co.uk>

25

*/

26

27

#include "cairo-test.h"

28

29

#define STEP	5

30

#define WIDTH	100

31

#define HEIGHT	100

32

33

108

static void hatching (cairo_t *cr)

34

35

    int i;

36

37

108

    cairo_rectangle (cr, 0, 0, WIDTH, HEIGHT);

38

108

    cairo_clip (cr);

39

40

2268

    for (i = 0; i < WIDTH; i += STEP) {

41

2160

	cairo_rectangle (cr, i-1, -2, 2, HEIGHT+4);

42

2160

	cairo_rectangle (cr, -2, i-1, WIDTH+4, 2);

43

44

108

45

46

3

static void background (cairo_t *cr)

47

48

3

    cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

49

3

    cairo_set_source_rgb (cr, 1,1,1);

50

3

    cairo_paint (cr);

51

3

52

53

108

static void clip_to_quadrant (cairo_t *cr)

54

55

108

    cairo_rectangle (cr, 0, 0, WIDTH, HEIGHT);

56

108

    cairo_clip (cr);

57

108

58

59

36

static void draw_hatching (cairo_t *cr, void (*func) (cairo_t *))

60

61

36

    cairo_save (cr); {

62

36

	clip_to_quadrant (cr);

63

36

	hatching (cr);

64

36

	func (cr);

65

36

    } cairo_restore (cr);

66

67

36

    cairo_translate (cr, WIDTH, 0);

68

69

36

    cairo_save (cr); {

70

36

	clip_to_quadrant (cr);

71

36

	cairo_translate (cr, 0.25, 0.25);

72

36

	hatching (cr);

73

36

	func (cr);

74

36

    } cairo_restore (cr);

75

76

36

    cairo_translate (cr, WIDTH, 0);

77

78

36

    cairo_save (cr); {

79

36

	clip_to_quadrant (cr);

80

36

	cairo_translate (cr, WIDTH/2, HEIGHT/2);

81

36

	cairo_rotate (cr, M_PI/4);

82

36

	cairo_translate (cr, -WIDTH/2, -HEIGHT/2);

83

36

	hatching (cr);

84

36

	func (cr);

85

36

    } cairo_restore (cr);

86

87

36

    cairo_translate (cr, WIDTH, 0);

88

36

89

90

36

static void do_clip (cairo_t *cr)

91

92

36

    cairo_clip (cr);

93

36

    cairo_paint (cr);

94

36

95

96

36

static void do_clip_alpha (cairo_t *cr)

97

98

36

    cairo_clip (cr);

99

36

    cairo_paint_with_alpha (cr, .5);

100

36

101

102

18

static void hatchings (cairo_t *cr, void (*func) (cairo_t *))

103

104

18

    cairo_save (cr); {

105

18

	cairo_set_source_rgb(cr, 1, 0, 0);

106

18

	cairo_set_antialias (cr, CAIRO_ANTIALIAS_DEFAULT);

107

18

	draw_hatching (cr, func);

108

18

	cairo_set_source_rgb(cr, 0, 0, 1);

109

18

	cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);

110

18

	draw_hatching (cr, func);

111

18

    } cairo_restore (cr);

112

18

113

114

static cairo_test_status_t

115

3

draw (cairo_t *cr, int width, int height)

116

117

3

    background (cr);

118

119

120

    /* aligned, misaligned, diagonal; mono repeat

121

     * x fill

122

     * x clip; paint

123

     * x clip; paint-alpha

124

     * repeated, for over/source

125

*/

126

127

3

    cairo_set_operator (cr, CAIRO_OPERATOR_OVER);

128

129

3

    hatchings (cr, cairo_fill);

130

3

    cairo_translate (cr, 0, HEIGHT);

131

3

    hatchings (cr, do_clip);

132

3

    cairo_translate (cr, 0, HEIGHT);

133

3

    hatchings (cr, do_clip_alpha);

134

3

    cairo_translate (cr, 0, HEIGHT);

135

136

3

    cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

137

138

3

    hatchings (cr, cairo_fill);

139

3

    cairo_translate (cr, 0, HEIGHT);

140

3

    hatchings (cr, do_clip);

141

3

    cairo_translate (cr, 0, HEIGHT);

142

3

    hatchings (cr, do_clip_alpha);

143

3

    cairo_translate (cr, 0, HEIGHT);

144

145

3

    return CAIRO_TEST_SUCCESS;

146

147

148

1

CAIRO_TEST (hatchings,

149

	    "Test drawing through various aligned/unaliged clips",

150

	    "clip, alpha", /* keywords */

151

	    "target=raster", /* requirements */

152

	    6*WIDTH, 6*HEIGHT,

153

	    NULL, draw)