Grcov report - cairo-xcb-resources.c

1

/* Cairo - a vector graphics library with display and print output

2

3

 * Copyright © 2014 Lukas Lalinsky

4

 * Copyright © 2005 Red Hat, Inc.

5

6

 * This library is free software; you can redistribute it and/or

7

 * modify it either under the terms of the GNU Lesser General Public

8

 * License version 2.1 as published by the Free Software Foundation

9

 * (the "LGPL") or, at your option, under the terms of the Mozilla

10

 * Public License Version 1.1 (the "MPL"). If you do not alter this

11

 * notice, a recipient may use your version of this file under either

12

 * the MPL or the LGPL.

13

14

 * You should have received a copy of the LGPL along with this library

15

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

16

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

17

 * You should have received a copy of the MPL along with this library

18

 * in the file COPYING-MPL-1.1

19

20

 * The contents of this file are subject to the Mozilla Public License

21

 * Version 1.1 (the "License"); you may not use this file except in

22

 * compliance with the License. You may obtain a copy of the License at

23

 * http://www.mozilla.org/MPL/

24

25

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

26

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

27

 * the specific language governing rights and limitations.

28

29

 * Authors:

30

 *    Lukas Lalinsky <lukas@oxygene.sk>

31

32

 * Partially on code from xftdpy.c

33

34

 * Copyright © 2000 Keith Packard

35

36

 * Permission to use, copy, modify, distribute, and sell this software and its

37

 * documentation for any purpose is hereby granted without fee, provided that

38

 * the above copyright notice appear in all copies and that both that

39

 * copyright notice and this permission notice appear in supporting

40

 * documentation, and that the name of Keith Packard not be used in

41

 * advertising or publicity pertaining to distribution of the software without

42

 * specific, written prior permission.  Keith Packard makes no

43

 * representations about the suitability of this software for any purpose.  It

44

 * is provided "as is" without express or implied warranty.

45

46

 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

47

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

48

 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

49

 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

50

 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

51

 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

52

 * PERFORMANCE OF THIS SOFTWARE.

53

*/

54

55

#include "cairoint.h"

56

57

#include "cairo-xcb-private.h"

58

59

#include "cairo-fontconfig-private.h"

60

61

static void

62

parse_boolean (const char *v, cairo_bool_t *out)

63

64

    char c0, c1;

65

66

    c0 = *v;

67

    if (c0 == 't' || c0 == 'T' || c0 == 'y' || c0 == 'Y' || c0 == '1')

68

	*out = TRUE;

69

    if (c0 == 'f' || c0 == 'F' || c0 == 'n' || c0 == 'N' || c0 == '0')

70

	*out = FALSE;

71

    if (c0 == 'o') {

72

	c1 = v[1];

73

	if (c1 == 'n' || c1 == 'N')

74

	    *out = TRUE;

75

	if (c1 == 'f' || c1 == 'F')

76

	    *out = FALSE;

77

78

79

80

static void

81

parse_integer (const char *v, int *out)

82

83

    char *e;

84

    int value;

85

86

#if CAIRO_HAS_FC_FONT

87

    if (FcNameConstant ((FcChar8 *) v, out))

88

	return;

89

#endif

90

91

    value = strtol (v, &e, 0);

92

    if (e != v)

93

	*out = value;

94

95

96

static char *

97

skip_spaces(char *str)

98

99

    while (*str == ' ' || *str == '\t' || *str == '\n')

100

	str++;

101

    return str;

102

103

104

struct resource_parser {

105

    int buffer_size;

106

    int bytes_in_buffer;

107

    char* buffer;

108

    cairo_xcb_resources_t *resources;

109

};

110

111

static cairo_bool_t

112

resource_parse_line (char *name, cairo_xcb_resources_t *resources)

113

114

    char *value;

115

116

    value = strchr (name, ':');

117

    if (value == NULL)

118

	return FALSE;

119

120

    *value++ = 0;

121

122

    name = skip_spaces (name);

123

    value = skip_spaces (value);

124

125

    if (strcmp (name, "Xft.antialias") == 0)

126

	parse_boolean (value, &(resources->xft_antialias));

127

    else if (strcmp (name, "Xft.lcdfilter") == 0)

128

	parse_integer (value, &(resources->xft_lcdfilter));

129

    else if (strcmp (name, "Xft.rgba") == 0)

130

	parse_integer (value, &(resources->xft_rgba));

131

    else if (strcmp (name, "Xft.hinting") == 0)

132

	parse_boolean (value, &(resources->xft_hinting));

133

    else if (strcmp (name, "Xft.hintstyle") == 0)

134

	parse_integer (value, &(resources->xft_hintstyle));

135

136

    return TRUE;

137

138

139

static int

140

resource_parse_lines (struct resource_parser *parser)

141

142

    char *line, *newline;

143

144

    line = parser->buffer;

145

    while (1) {

146

	newline = strchr (line, '\n');

147

	if (newline == NULL)

148

	    break;

149

150

	*newline++ = 0;

151

152

	if (! resource_parse_line (line, parser->resources))

153

	    break;

154

155

	line = newline;

156

157

158

    return line - parser->buffer;

159

160

161

static void

162

resource_parser_init (struct resource_parser *parser, cairo_xcb_resources_t *resources)

163

164

    parser->buffer_size = 0;

165

    parser->bytes_in_buffer = 0;

166

    parser->buffer = NULL;

167

    parser->resources = resources;

168

169

170

static cairo_bool_t

171

resource_parser_update (struct resource_parser *parser, const char *data, int length)

172

173

    int bytes_parsed;

174

175

    if (parser->bytes_in_buffer + length + 1 > parser->buffer_size) {

176

	parser->buffer_size = parser->bytes_in_buffer + length + 1;

177

	parser->buffer = realloc(parser->buffer, parser->buffer_size);

178

	if (! parser->buffer) {

179

	    parser->buffer_size = 0;

180

	    parser->bytes_in_buffer = 0;

181

	    return FALSE;

182

183

184

185

    memmove (parser->buffer + parser->bytes_in_buffer, data, length);

186

    parser->bytes_in_buffer += length;

187

    parser->buffer[parser->bytes_in_buffer] = 0;

188

189

    bytes_parsed = resource_parse_lines (parser);

190

191

    if (parser->bytes_in_buffer > bytes_parsed) {

192

	memmove (parser->buffer, parser->buffer + bytes_parsed, parser->bytes_in_buffer - bytes_parsed);

193

	parser->bytes_in_buffer -= bytes_parsed;

194

    } else {

195

	parser->bytes_in_buffer = 0;

196

197

198

    return TRUE;

199

200

201

static void

202

resource_parser_done (struct resource_parser *parser)

203

204

    if (parser->bytes_in_buffer > 0) {

205

	parser->buffer[parser->bytes_in_buffer] = 0;

206

	resource_parse_line (parser->buffer, parser->resources);

207

208

209

    free (parser->buffer);

210

211

212

static void

213

get_resources(xcb_connection_t *connection, xcb_screen_t *screen, cairo_xcb_resources_t *resources)

214

215

    xcb_get_property_cookie_t cookie;

216

    xcb_get_property_reply_t *reply;

217

    struct resource_parser parser;

218

    int offset;

219

    cairo_bool_t has_more_data;

220

221

    resources->xft_antialias = TRUE;

222

    resources->xft_lcdfilter = -1;

223

    resources->xft_hinting = TRUE;

224

    resources->xft_hintstyle = FC_HINT_FULL;

225

    resources->xft_rgba = FC_RGBA_UNKNOWN;

226

227

    resource_parser_init (&parser, resources);

228

229

    offset = 0;

230

    has_more_data = FALSE;

231

    do {

232

	cookie = xcb_get_property (connection, 0, screen->root, XCB_ATOM_RESOURCE_MANAGER, XCB_ATOM_STRING, offset, 1024);

233

	reply = xcb_get_property_reply (connection, cookie, NULL);

234

235

	if (reply) {

236

	    if (reply->format == 8 && reply->type == XCB_ATOM_STRING) {

237

		char *value = (char *) xcb_get_property_value (reply);

238

		int length = xcb_get_property_value_length (reply);

239

240

		offset += length / 4; /* X needs the offset in 'long' units */

241

		has_more_data = reply->bytes_after > 0;

242

243

		if (! resource_parser_update (&parser, value, length))

244

		    has_more_data = FALSE; /* early exit on error */

245

246

247

	    free (reply);

248

249

    } while (has_more_data);

250

251

    resource_parser_done (&parser);

252

253

254

void

255

_cairo_xcb_resources_get (cairo_xcb_screen_t *screen, cairo_xcb_resources_t *resources)

256

257

    get_resources (screen->connection->xcb_connection, screen->xcb_screen, resources);

258

259

    if (resources->xft_rgba == FC_RGBA_UNKNOWN) {

260

	switch (screen->subpixel_order) {

261

	case XCB_RENDER_SUB_PIXEL_UNKNOWN:

262

	    resources->xft_rgba = FC_RGBA_UNKNOWN;

263

	    break;

264

	case XCB_RENDER_SUB_PIXEL_HORIZONTAL_RGB:

265

	    resources->xft_rgba = FC_RGBA_RGB;

266

	    break;

267

	case XCB_RENDER_SUB_PIXEL_HORIZONTAL_BGR:

268

	    resources->xft_rgba = FC_RGBA_BGR;

269

	    break;

270

	case XCB_RENDER_SUB_PIXEL_VERTICAL_RGB:

271

	    resources->xft_rgba = FC_RGBA_VRGB;

272

	    break;

273

	case XCB_RENDER_SUB_PIXEL_VERTICAL_BGR:

274

	    resources->xft_rgba = FC_RGBA_VBGR;

275

	    break;

276

	case XCB_RENDER_SUB_PIXEL_NONE:

277

	    resources->xft_rgba = FC_RGBA_NONE;

278

	    break;

279

280

281